xfile_loader.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program 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.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/*
 * Partially based on XFile parser code from Wine sources.
 * Copyright 2008 Christian Costa
 */

#ifndef WINTERMUTE_XFILE_LOADER_H
#define WINTERMUTE_XFILE_LOADER_H

#include "common/str.h"
#include "common/stack.h"

namespace Wintermute {

enum XTokenType : uint16 {
    XTOKEN_ERROR        = 0xffff,
    XTOKEN_NONE         = 0,
    XTOKEN_NAME         = 1,
    XTOKEN_STRING       = 2,
    XTOKEN_INTEGER      = 3,
    XTOKEN_GUID         = 5,
    XTOKEN_INTEGER_LIST = 6,
    XTOKEN_FLOAT_LIST   = 7,
    XTOKEN_OBRACE       = 10,
    XTOKEN_CBRACE       = 11,
    XTOKEN_OPAREN       = 12,
    XTOKEN_CPAREN       = 13,
    XTOKEN_OBRACKET     = 14,
    XTOKEN_CBRACKET     = 15,
    XTOKEN_OANGLE       = 16,
    XTOKEN_CANGLE       = 17,
    XTOKEN_DOT          = 18,
    XTOKEN_COMMA        = 19,
    XTOKEN_SEMICOLON    = 20,
    XTOKEN_TEMPLATE     = 31,
    XTOKEN_WORD         = 40,
    XTOKEN_DWORD        = 41,
    XTOKEN_FLOAT        = 42,
    XTOKEN_DOUBLE       = 43,
    XTOKEN_CHAR         = 44,
    XTOKEN_UCHAR        = 45,
    XTOKEN_SWORD        = 46,
    XTOKEN_SDWORD       = 47,
    XTOKEN_VOID         = 48,
    XTOKEN_LPSTR        = 49,
    XTOKEN_UNICODE      = 50,
    XTOKEN_CSTRING      = 51,
    XTOKEN_ARRAY        = 52
};

#define XMAX_NAME_LEN   120
#define XMAX_STRING_LEN 500

struct XToken {
    XTokenType      _type;
    char            _textVal[XMAX_STRING_LEN];
    uint32          _integerVal;
    float           _floatVal;
};

struct XVector {
    float           _x;
    float           _y;
    float           _z;
};

struct XCoords2d {
    float           _u;
    float           _v;
};

struct XMeshFace {
    uint32          _numFaceVertexIndices;
    uint32          _faceVertexIndices[4];
};

struct XTimedFloatKeys {
    float           _time;
    uint32          _numTfkeys;
    float           _tfkeys[16];
};

struct XIndexedColor {
    uint32          _index;
    float           _indexColorR;
    float           _indexColorG;
    float           _indexColorB;
    float           _indexColorA;
};

struct XVertexElement {
    uint32          _type;
    uint32          _method;
    uint32          _usage;
    uint32          _usageIndex;
};

struct XMeshMaterialListObject {
    uint32          _nMaterials;
    uint32          _numFaceIndexes;
    uint32          *_faceIndexes{};

    ~XMeshMaterialListObject() {
        delete[] _faceIndexes;
    }
};

struct XVertexDuplicationIndicesObject {
    uint32          _nOriginalVertices;
    uint32          _numIndices;
    uint32          *_indices{};

    ~XVertexDuplicationIndicesObject() {
        delete[] _indices;
    }
};

struct XSkinMeshHeaderObject{
    uint32          _nMaxSkinWeightsPerVertex;
    uint32          _nMaxSkinWeightsPerFace;
    uint32          _nBones;
};

struct XSkinWeightsObject {
    char            _transformNodeName[XMAX_NAME_LEN];
    uint32          _numVertexIndices;
    uint32          *_vertexIndices{};
    uint32          _numWeights;
    float           *_weights{};
    float           _matrixOffset[16];

    ~XSkinWeightsObject() {
        delete[] _vertexIndices;
        delete[] _weights;
    }
};

struct XMeshObject {
    uint32          _numVertices;
    XVector         *_vertices{};
    uint32          _numFaces;
    XMeshFace       *_faces{};

    ~XMeshObject() {
        delete[] _vertices;
        delete[] _faces;
    }
};

struct XMeshNormalsObject {
    uint32          _numNormals;
    XVector         *_normals{};
    uint32          _numFaceNormals;
    XMeshFace       *_faceNormals{};

    ~XMeshNormalsObject() {
        delete[] _normals;
        delete[] _faceNormals;
    }
};

struct XMeshVertexColorsObject {
    uint32          _numVertexColors;
    XIndexedColor   *_vertexColors{};

    ~XMeshVertexColorsObject() {
        delete[] _vertexColors;
    }
};

struct XMeshTextureCoordsObject {
    uint32          _numTextureCoords;
    XCoords2d       *_textureCoords{};

    ~XMeshTextureCoordsObject() {
        delete[] _textureCoords;
    }
};

struct XMaterialObject {
    float           _colorR;
    float           _colorG;
    float           _colorB;
    float           _colorA;
    float           _power;
    float           _specularR;
    float           _specularG;
    float           _specularB;
    float           _emissiveR;
    float           _emissiveG;
    float           _emissiveB;
};

struct XTextureFilenameObject {
    char            _filename[XMAX_NAME_LEN];
};

struct XAnimTicksPerSecondObject {
    uint32          _animTicksPerSecond;
};

struct XAnimationSetObject{
};

struct XAnimationObject{
};

struct XAnimationKeyObject {
    uint32          _keyType;
    uint32          _numKeys;
    XTimedFloatKeys *_keys{};

    ~XAnimationKeyObject() {
        delete[] _keys;
    }
};

struct XAnimationOptionsObject {
    uint32          _openclosed;
    uint32          _positionquality;
};

struct XFrameObject {
};

struct XFrameTransformMatrixObject {
    float           _frameMatrix[16];
};

struct XDeclDataObject {
    uint32          _numElements;
    XVertexElement  *_elements{};
    uint32          _numData;
    uint32          *_data{};

    ~XDeclDataObject() {
        delete[] _elements;
        delete[] _data;
    }
};

struct XFVFDataObject {
    uint32          _dwFVF;
    uint32          _numData;
    uint32          *_data{};

    ~XFVFDataObject() {
        delete[] _data;
    }
};

enum XClassType {
    kXClassUnknown = 0,
    kXClassAnimTicksPerSecond,
    kXClassFrameTransformMatrix,
    kXClassFrame,
    kXClassMesh,
    kXClassMeshNormals,
    kXClassMeshVertexColors,
    kXClassMeshTextureCoords,
    kXClassMeshMaterialList,
    kXClassVertexDuplicationIndices,
    kXClassMaterial,
    kXClassTextureFilename,
    kXClassSkinMeshHeader,
    kXClassSkinWeights,
    kXClassAnimationSet,
    kXClassAnimation,
    kXClassAnimationKey,
    kXClassAnimationOptions,
    kXClassDeclData,
    kXClassFVFData,
};

class XFileEnumObject;

class XObject {
    friend class XFileLoader;
    friend class XFileData;
    friend class XFileEnumObject;

private:

    Common::String _name;
    XClassType _classType{};
    void *_object{};
    XObject *_targetObject{};
    Common::Stack<XObject *> _children;

public:

    void deinit() {
        switch (_classType) {
        case kXClassAnimTicksPerSecond:
            delete (XAnimTicksPerSecondObject *)_object;
            break;
        case kXClassAnimationKey:
            delete (XAnimationKeyObject *)_object;
            break;
        case kXClassAnimation:
            delete (XAnimationObject *)_object;
            break;
        case kXClassAnimationOptions:
            delete (XAnimationOptionsObject *)_object;
            break;
        case kXClassAnimationSet:
            delete (XAnimationSetObject *)_object;
            break;
        case kXClassDeclData:
            delete (XDeclDataObject *)_object;
            break;
        case kXClassFrame:
            delete (XFrameObject *)_object;
            break;
        case kXClassFrameTransformMatrix:
            delete (XFrameTransformMatrixObject *)_object;
            break;
        case kXClassFVFData:
            delete (XFVFDataObject *)_object;
            break;
        case kXClassMaterial:
            delete (XMaterialObject *)_object;
            break;
        case kXClassMesh:
            delete (XMeshObject *)_object;
            break;
        case kXClassMeshMaterialList:
            delete (XMeshMaterialListObject *)_object;
            break;
        case kXClassMeshNormals:
            delete (XMeshNormalsObject *)_object;
            break;
        case kXClassMeshVertexColors:
            delete (XMeshVertexColorsObject *)_object;
            break;
        case kXClassMeshTextureCoords:
            delete (XMeshTextureCoordsObject *)_object;
            break;
        case kXClassSkinMeshHeader:
            delete (XSkinMeshHeaderObject *)_object;
            break;
        case kXClassSkinWeights:
            delete (XSkinWeightsObject *)_object;
            break;
        case kXClassVertexDuplicationIndices:
            delete (XVertexDuplicationIndicesObject *)_object;
            break;
        case kXClassTextureFilename:
            delete (XTextureFilenameObject *)_object;
            break;
        case kXClassUnknown:
            break;
        }
    }
};

class XFileLoader {
    friend class XFileEnumObject;

private:

    const int kCabBlockSize = 0x8000;
    const int kCabInputmax = kCabBlockSize + 12;

    bool _initialised{};
    XToken _currentToken;
    byte *_decompBuffer{};
    byte *_buffer;
    uint32 _bufferLeft;
    bool _isText;
    uint32 _listNbElements;
    bool _listTypeFloat;
    bool _listSeparator;
    bool _tokenPresent;

    Common::Stack<XObject *> _xobjects;

public:

    XFileLoader();
    ~XFileLoader();
    bool load(byte *buffer, uint32 bufferSize);
    bool createEnumObject(XFileEnumObject &xobj);

private:

    void init();
    void deinit();

    FORCEINLINE bool readChar(char &c);
    FORCEINLINE void rewindBytes(uint32 size);
    bool readBytes(void *data, uint32 size);
    bool readLE16(uint16 *data);
    bool readLE32(uint32 *data);
    bool readBE32(uint32 *data);

    FORCEINLINE bool getInteger(uint32 &value);
    FORCEINLINE bool getFloat(float &value);
    FORCEINLINE bool getString(char *str, uint maxLen);
    FORCEINLINE bool skipSemicolonComma();

    FORCEINLINE bool isSpace(char c);
    FORCEINLINE bool isOperator(char c);
    FORCEINLINE bool isSeparator(char c);
    FORCEINLINE bool isPrimitiveType(XTokenType token);
    FORCEINLINE bool isGuid();
    FORCEINLINE bool isName();
    FORCEINLINE bool isFloat();
    FORCEINLINE bool isInteger();
    FORCEINLINE bool isString();
    FORCEINLINE bool isKeyword(const char *keyword, uint len);
    FORCEINLINE XTokenType getKeywordToken();
    FORCEINLINE XTokenType checkToken();
    XTokenType getToken();
    void parseToken();

    bool decompressMsZipData();

    bool parseHeader();

    bool parseTemplate();
    bool parseTemplateParts();
    bool parseTemplateOptionInfo();
    bool parseTemplateMembersList();
    XObject *resolveChildObject(XObject *object, const Common::String &referenceName);
    bool resolveObject(XObject *referenceObject, const Common::String &referenceName);
    bool parseObject(XObject *object);
    bool parseChildObjects(XObject *object);
    bool parseObjectParts(XObject *object);
};

class XFileData {
    friend class XFileEnumObject;

private:

    XObject *_xobject{};
    bool _reference{};

public:

    bool getChild(uint id, XFileData &child) {
        if (_xobject) {
            if (id < _xobject->_children.size()) {
                child._xobject = _xobject->_children[id];
                if (child._xobject->_targetObject) {
                    child._xobject = child._xobject->_targetObject;
                    child._reference = true;
                }
                return true;
            }
        }
        return false;
    }

    bool getChildren(uint &num) {
        if (_xobject) {
            num = _xobject->_children.size();
            return true;
        }
        return false;
    }

    bool getName(Common::String &name) {
        if (_xobject) {
            name = _xobject->_name;
            return true;
        }
        return false;
    }

    bool getType(XClassType &classType) {
        if (_xobject) {
            classType = _xobject->_classType;
            return true;
        }
        return false;
    }

    bool isReference() {
        if (_xobject) {
            return _reference;
        }
        return false;
    }

#define GET_OBJECT_FUNC(objectName) \
    objectName *get ## objectName() { \
        if (_xobject) \
            return static_cast<objectName *>(_xobject->_object); \
        else \
            return nullptr; \
    }

    GET_OBJECT_FUNC(XAnimTicksPerSecondObject)
    GET_OBJECT_FUNC(XAnimationKeyObject)
    GET_OBJECT_FUNC(XAnimationObject)
    GET_OBJECT_FUNC(XAnimationOptionsObject)
    GET_OBJECT_FUNC(XAnimationSetObject)
    GET_OBJECT_FUNC(XDeclDataObject)
    GET_OBJECT_FUNC(XFrameObject)
    GET_OBJECT_FUNC(XFrameTransformMatrixObject)
    GET_OBJECT_FUNC(XFVFDataObject)
    GET_OBJECT_FUNC(XMaterialObject)
    GET_OBJECT_FUNC(XMeshObject)
    GET_OBJECT_FUNC(XMeshMaterialListObject)
    GET_OBJECT_FUNC(XMeshNormalsObject)
    GET_OBJECT_FUNC(XMeshVertexColorsObject)
    GET_OBJECT_FUNC(XMeshTextureCoordsObject)
    GET_OBJECT_FUNC(XSkinMeshHeaderObject)
    GET_OBJECT_FUNC(XSkinWeightsObject)
    GET_OBJECT_FUNC(XVertexDuplicationIndicesObject)
    GET_OBJECT_FUNC(XTextureFilenameObject)
};

class XFileEnumObject {
    friend class XFileLoader;

private:

    XFileLoader *_file{};

public:

    bool getChild(uint id, XFileData &child) {
        if (_file) {
            if (id < _file->_xobjects.size()) {
                child._xobject = _file->_xobjects[id];
                return true;
            }
        }
        return false;
    }

    bool getChildren(uint &num) {
        if (_file) {
            num = _file->_xobjects.size();
            return true;
        }
        return false;
    }
};

} // namespace Wintermute

#endif