gff4file.h

Go to the documentation of this file.

/* xoreos - A reimplementation of BioWare's Aurora engine
 *
 * xoreos is the legal property of its developers, whose names
 * can be found in the AUTHORS file distributed with this source
 * distribution.
 *
 * xoreos is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 3
 * of the License, or (at your option) any later version.
 *
 * xoreos is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with xoreos. If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef AURORA_GFF4FILE_H
#define AURORA_GFF4FILE_H

#include <vector>
#include <map>

#include "glm/mat4x4.hpp"

#include <boost/noncopyable.hpp>

#include "src/common/types.h"
#include "src/common/scopedptr.h"
#include "src/common/ustring.h"
#include "src/common/encoding.h"

#include "src/aurora/types.h"
#include "src/aurora/aurorafile.h"
#include "src/aurora/gff4fields.h"

namespace Common {
    class SeekableReadStream;
    class SeekableSubReadStreamEndian;
}

namespace Aurora {

class GFF4Struct;

class GFF4File : boost::noncopyable, public AuroraFile {
public:
    GFF4File(Common::SeekableReadStream *gff4, uint32 type = 0xFFFFFFFF);
    GFF4File(const Common::UString &gff4, FileType fileType, uint32 type = 0xFFFFFFFF);
    ~GFF4File();

    uint32 getType() const;
    uint32 getTypeVersion() const;
    uint32 getPlatform() const;

    bool isBigEndian() const;
    Common::Encoding getNativeEncoding() const;

    const GFF4Struct &getTopLevel() const;


private:
    enum Platform {
        kPlatformPC      = MKTAG('P', 'C', ' ', ' '),
        kPlatformPS3     = MKTAG('P', 'S', '3', ' '),
        kPlatformXbox360 = MKTAG('X', '3', '6', '0')
    };

    struct Header {
        uint32 platformID;   
        uint32 type;         
        uint32 typeVersion;  
        uint32 structCount;  
        uint32 stringCount;  
        uint32 stringOffset; 
        uint32 dataOffset;   

        bool hasSharedStrings;

        void read(Common::SeekableReadStream &gff4, uint32 version);
        bool isBigEndian() const;
    };

    struct StructTemplate {
        struct Field {
            uint32 label;
            uint16 type;
            uint16 flags;
            uint32 offset;
        };

        uint32 index;
        uint32 label;
        uint32 size;

        std::vector<Field> fields;
    };

    typedef std::vector<StructTemplate> StructTemplates;
    typedef std::vector<Common::UString> SharedStrings;
    typedef std::map<uint64, GFF4Struct *> StructMap;



    Common::ScopedPtr<Common::SeekableReadStream> _origStream;
    Common::ScopedPtr<Common::SeekableSubReadStreamEndian> _stream;

    Header          _header;
    StructTemplates _structTemplates;

    SharedStrings _sharedStrings;

    StructMap   _structs;
    GFF4Struct *_topLevelStruct;


    // .--- Loading helpers
    void load(uint32 type);
    void loadHeader(uint32 type);
    void loadStructs();
    void loadStrings();

    void clear();
    // '---

    // .--- Helper methods called by GFF4Struct
    void registerStruct(uint64 id, GFF4Struct *strct);
    void unregisterStruct(uint64 id);
    GFF4Struct *findStruct(uint64 id);

    Common::SeekableSubReadStreamEndian &getStream(uint32 offset) const;
    const StructTemplate &getStructTemplate(uint32 i) const;
    uint32 getDataOffset() const;

    bool hasSharedStrings() const;
    Common::UString getSharedString(uint32 i) const;
    // '---

    friend class GFF4Struct;
};

class GFF4Struct {
public:
    enum FieldType {
        kFieldTypeNone        = -    1, 
        kFieldTypeUint8       =      0, 
        kFieldTypeSint8       =      1, 
        kFieldTypeUint16      =      2, 
        kFieldTypeSint16      =      3, 
        kFieldTypeUint32      =      4, 
        kFieldTypeSint32      =      5, 
        kFieldTypeUint64      =      6, 
        kFieldTypeSint64      =      7, 
        kFieldTypeFloat32     =      8, 
        kFieldTypeFloat64     =      9, 
        kFieldTypeVector3f    =     10, 
        kFieldTypeVector4f    =     12, 
        kFieldTypeQuaternionf =     13, 
        kFieldTypeString      =     14, 
        kFieldTypeColor4f     =     15, 
        kFieldTypeMatrix4x4f  =     16, 
        kFieldTypeTlkString   =     17, 
        kFieldTypeNDSFixed    =     18, 
        kFieldTypeASCIIString =     20, 
        kFieldTypeStruct      =  65534, 
        kFieldTypeGeneric     =  65535  
    };

    uint64 getID() const;
    uint32 getRefCount() const;

    uint32 getLabel() const;

    size_t getFieldCount() const;
    bool hasField(uint32 field) const;

    const std::vector<uint32> &getFieldLabels() const;

    FieldType getFieldType(uint32 field) const;
    FieldType getFieldType(uint32 field, bool &isList) const;

    bool getFieldProperties(uint32 field, FieldType &type, uint32 &label, bool &isList) const;


    // .--- Single values
    uint64 getUint(uint32 field, uint64 def = 0    ) const;
     int64 getSint(uint32 field,  int64 def = 0    ) const;
    bool   getBool(uint32 field, bool   def = false) const;

    double getDouble(uint32 field, double def = 0.0 ) const;
    float  getFloat (uint32 field, float  def = 0.0f) const;

    Common::UString getString(uint32 field, Common::Encoding encoding, const Common::UString &def = "") const;

    Common::UString getString(uint32 field, const Common::UString &def = "") const;

    bool getTalkString(uint32 field, Common::Encoding encoding, uint32 &strRef, Common::UString &str) const;

    bool getTalkString(uint32 field, uint32 &strRef, Common::UString &str) const;

    bool getVector3(uint32 field, double &v1, double &v2, double &v3) const;
    bool getVector4(uint32 field, double &v1, double &v2, double &v3, double &v4) const;

    bool getMatrix4x4(uint32 field, double (&m)[16]) const;

    bool getVector3(uint32 field, float &v1, float &v2, float &v3) const;
    bool getVector4(uint32 field, float &v1, float &v2, float &v3, float &v4) const;

    bool getMatrix4x4(uint32 field, float (&m)[16]) const;

    bool getVectorMatrix(uint32 field, std::vector<double> &vectorMatrix) const;
    bool getVectorMatrix(uint32 field, std::vector<float > &vectorMatrix) const;

    bool getMatrix4x4(uint32 field, glm::mat4 &m) const;
    // '---

    // .--- Lists of values
    bool getUint(uint32 field, std::vector<uint64> &list) const;
    bool getSint(uint32 field, std::vector< int64> &list) const;
    bool getBool(uint32 field, std::vector<bool  > &list) const;

    bool getDouble(uint32 field, std::vector<double> &list) const;
    bool getFloat (uint32 field, std::vector<float > &list) const;

    bool getString(uint32 field, Common::Encoding encoding, std::vector<Common::UString> &list) const;

    bool getString(uint32 field, std::vector<Common::UString> &list) const;

    bool getTalkString(uint32 field, Common::Encoding encoding,
                       std::vector<uint32> &strRefs, std::vector<Common::UString> &strs) const;

    bool getTalkString(uint32 field,
                       std::vector<uint32> &strRefs, std::vector<Common::UString> &strs) const;

    bool getVectorMatrix(uint32 field, std::vector< std::vector<double> > &list) const;
    bool getVectorMatrix(uint32 field, std::vector< std::vector<float > > &list) const;

    bool getMatrix4x4(uint32 field, std::vector<glm::mat4> &list) const;
    // '---

    // .--- Structs and lists of structs
    const GFF4Struct *getStruct (uint32 field) const;
    const GFF4Struct *getGeneric(uint32 field) const;
    const GFF4List   &getList   (uint32 field) const;
    // '---

    // .--- Raw data
    Common::SeekableReadStream *getData(uint32 field) const;
    // '---

private:
    struct Field {
        uint32    label;  
        FieldType type;   
        uint32    offset; 

        bool isList;      
        bool isReference; 
        bool isGeneric;   

        uint16   structIndex; 
        GFF4List structs;     

        Field();
        Field(uint32 l, uint16 t, uint16 f, uint32 o, bool g = false);
        ~Field();
    };

    typedef std::map<uint32, Field> FieldMap;


    const GFF4File *_parent;

    uint32 _label;

    uint64 _id;
    uint32 _refCount;

    size_t _fieldCount;

    FieldMap _fields;

    std::vector<uint32> _fieldLabels;


    // .--- Loader
    GFF4Struct(GFF4File &parent, uint32 offset, const GFF4File::StructTemplate &tmplt);
    GFF4Struct(GFF4File &parent, const Field &genericParent);
    ~GFF4Struct();

    void load(GFF4File &parent, uint32 offset, const GFF4File::StructTemplate &tmplt);
    void loadStructs(GFF4File &parent, Field &field);
    void loadGeneric(GFF4File &parent, Field &field);

    void load(GFF4File &parent, const Field &genericParent);

    static uint64 generateID(uint32 offset, const GFF4File::StructTemplate *tmplt = 0);
    // '---

    // .--- Field and field data accessors
    const Field *getField(uint32 field) const;

    uint32 getDataOffset(bool isReference, uint32 offset) const;
    uint32 getDataOffset(const Field &field) const;

    Common::SeekableSubReadStreamEndian *getData(const Field &field) const;
    Common::SeekableSubReadStreamEndian *getField(uint32 fieldID, const Field *&field) const;
    // '---

    // .--- Field reader helpers
    uint32 getListCount(Common::SeekableSubReadStreamEndian &data, const Field &field) const;
    uint32 getFieldSize(FieldType type) const;

    uint64 getUint(Common::SeekableSubReadStreamEndian &data, FieldType type) const;
     int64 getSint(Common::SeekableSubReadStreamEndian &data, FieldType type) const;

    double getDouble(Common::SeekableSubReadStreamEndian &data, FieldType type) const;
    float  getFloat (Common::SeekableSubReadStreamEndian &data, FieldType type) const;

    Common::UString getString(Common::SeekableSubReadStreamEndian &data, Common::Encoding encoding) const;
    Common::UString getString(Common::SeekableSubReadStreamEndian &data, Common::Encoding encoding,
                              uint32 offset) const;
    Common::UString getString(Common::SeekableSubReadStreamEndian &data, const Field &field,
                              Common::Encoding encoding) const;

    uint32 getVectorMatrixLength(const Field &field, uint32 minLength, uint32 maxLength) const;
    // '---


    friend class GFF4File;
};

} // End of namespace Aurora

#endif // AURORA_GFF4FILE_H