MeshLoaderCollada.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/>.
 *
 */
 
/*
 * Copyright (C) 2006-2010 - Frictional Games
 *
 * This file is part of HPL1 Engine.
 */
 
#ifndef HPL_MESH_LOADER_COLLADA_H
#define HPL_MESH_LOADER_COLLADA_H
 
#include "common/list.h"
#include "hpl1/engine/graphics/VertexBuffer.h"
#include "hpl1/engine/math/MathTypes.h"
#include "hpl1/engine/physics/PhysicsJoint.h"
#include "hpl1/engine/resources/MeshLoader.h"
#include "hpl1/engine/system/MemoryManager.h"
 
class TiXmlElement;
 
namespace hpl {
 
class cMesh;
class cNode3D;
class iVertexBuffer;
class cBone;
class cAnimation;
class cAnimationTrack;
class cSkeleton;
class cWorld3D;
class cSector;
class cMeshEntity;
class iPhysicsBody;
class cColliderEntity;
class cMeshJoint;
class cSystem;
 
// HELP CLASSES
 
class cColladaImage {
public:
    tString msId;
    tString msName;
 
    tString msSource;
};
 
typedef Common::Array<cColladaImage> tColladaImageVec;
 
//------------------------------------------------
 
class cColladaTexture {
public:
    tString msId;
    tString msName;
 
    tString msImage;
};
 
typedef Common::Array<cColladaTexture> tColladaTextureVec;
 
//------------------------------------------------
 
class cColladaMaterial {
public:
    tString msId;
    tString msName;
 
    tString msTexture;
    cColor mDiffuseColor;
};
 
typedef Common::Array<cColladaMaterial> tColladaMaterialVec;
 
//------------------------------------------------
 
class cColladaLight {
public:
    tString msId;
    tString msName;
    tString msType;
 
    cColor mDiffuseColor;
    float mfAngle;
};
 
typedef Common::Array<cColladaLight> tColladaLightVec;
 
//------------------------------------------------
 
class cColladaVtxArray {
public:
    cColladaVtxArray() : mbIsInVertex(false) {}
 
    tString msId;
    tString msType;
    bool mbIsInVertex;
 
    tVector3fVec mvArray;
};
 
typedef Common::Array<cColladaVtxArray> tColladaVtxArrayVec;
 
class cColladaVtxIndex {
public:
    int mlVtx;
    int mlNorm;
    int mlTex;
};
 
typedef Common::Array<cColladaVtxIndex> tColladaVtxIndexVec;
 
//------------------------------------------------
 
class cColladaExtraVtx {
public:
    cColladaExtraVtx(int alVtx, int alNorm, int alTex, int alNewVtx) {
        mlVtx = alVtx;
        mlNorm = alNorm;
        mlTex = alTex;
        mlNewVtx = alNewVtx;
    }
 
    cColladaExtraVtx() {}
 
    int mlVtx;
    int mlNorm;
    int mlTex;
 
    int mlNewVtx;
 
    bool Equals(const cColladaVtxIndex &aData) {
        if (mlVtx == aData.mlVtx && mlNorm == aData.mlNorm && mlTex == aData.mlTex) {
            return true;
        }
 
        return false;
    }
};
 
typedef Common::List<cColladaExtraVtx> tColladaExtraVtxList;
typedef tColladaExtraVtxList::iterator tColladaExtraVtxListIt;
 
typedef Common::Array<tColladaExtraVtxList> tColladaExtraVtxListVec;
 
//------------------------------------------------
 
class cColladaGeometry {
public:
    cColladaGeometry() : mlPosArrayIdx(-1), mlNormArrayIdx(-1), mlTexArrayIdx(-1),
                         mlPosIdxNum(-1), mlNormIdxNum(-1), mlTexIdxNum(-1) {}
 
    void Clear() {
        mvIndices.clear();
 
        for (int i = 0; i < (int)mvArrayVec.size(); i++) {
            mvArrayVec[i].mvArray.clear();
        }
        /*mvVertexVec.clear();
        mvIndexVec.clear();
        mvExtraVtxVec.clear();*/
    }
 
    tString msId;
    tString msName;
 
    tVertexVec mvVertexVec;
    tUIntVec mvIndexVec;
    tColladaExtraVtxListVec mvExtraVtxVec;
    tFloatVec mvTangents;
 
    tString msMaterial;
 
    // THe following are ONLY used when loading from a geometry element.!!
    tColladaVtxArrayVec mvArrayVec;
    tColladaVtxIndexVec mvIndices;
 
    int mlPosIdxNum;  // The position in the triangle element
    int mlNormIdxNum; // for eternal use only
    int mlTexIdxNum;
 
    int mlPosArrayIdx;  // The index for array containing positions
    int mlNormArrayIdx; // The index for array containing normals
    int mlTexArrayIdx;  // The index for array containing texcoords
};
 
typedef Common::Array<cColladaGeometry> tColladaGeometryVec;
 
//------------------------------------------------
 
class cColladaJointPair {
public:
    cColladaJointPair() {}
    cColladaJointPair(int alJoint, int alWeight) {
        mlJoint = alJoint;
        mlWeight = alWeight;
    }
 
    int mlJoint;
    int mlWeight;
};
 
typedef Common::List<cColladaJointPair> tColladaJointPairList;
typedef tColladaJointPairList::iterator tColladaJointPairListIt;
 
typedef Common::Array<tColladaJointPairList> tColladaJointPairListVec;
 
class cColladaController {
public:
    cColladaController() : mlJointPairIdx(-1), mlWeightPairIdx(-1) {}
 
    tString msTarget;
    tString msId;
 
    cMatrixf m_mtxBindShapeMatrix;
 
    int mlJointPairIdx;
    int mlWeightPairIdx;
 
    tStringVec mvJoints;
    tFloatVec mvWeights;
    tMatrixfVec mvMatrices;
 
    tColladaJointPairListVec mvPairs;
};
 
typedef Common::Array<cColladaController> tColladaControllerVec;
 
//------------------------------------------------
 
class cColladaChannel {
public:
    tString msId;
    tString msTarget;
    tString msSource;
};
 
typedef Common::Array<cColladaChannel> tColladaChannelVec;
 
class cColladaSampler {
public:
    tString msId;
    tString msTimeArray;
    tString msValueArray;
 
    tString msTarget;
};
 
typedef Common::Array<cColladaSampler> tColladaSamplerVec;
 
class cColladaAnimSource {
public:
    tString msId;
    tFloatVec mvValues;
};
 
typedef Common::Array<cColladaAnimSource> tColladaAnimSourceVec;
 
class cColladaAnimation {
public:
    tString msId;
    // tString msName;
    tString msTargetNode;
 
    tColladaChannelVec mvChannels;
    tColladaSamplerVec mvSamplers;
 
    tColladaAnimSourceVec mvSources;
 
    tFloatVec *GetSourceVec(const tString &asId) {
        for (size_t i = 0; i < mvSources.size(); i++) {
            if (mvSources[i].msId == asId) {
                return &mvSources[i].mvValues;
            }
        }
 
        return NULL;
    }
};
 
typedef Common::Array<cColladaAnimation> tColladaAnimationVec;
 
//------------------------------------------------
 
class cColladaTransform {
public:
    tString msSid;
    tString msType;
    tFloatVec mvValues;
};
 
typedef Common::List<cColladaTransform> tColladaTransformList;
typedef tColladaTransformList::iterator tColladaTransformListIt;
 
class cColladaNode;
typedef Common::List<cColladaNode *> tColladaNodeList;
typedef tColladaNodeList::iterator tColladaNodeListIt;
 
class cColladaNode {
public:
    cColladaNode() : mlCount(0), pParent(NULL), mvScale(1, 1, 1), mbSourceIsFile(false) {}
 
    tString msId;
    tString msName;
    tString msType;
 
    tString msSource;
    bool mbSourceIsFile;
 
    cMatrixf m_mtxTransform;
    cMatrixf m_mtxWorldTransform;
 
    cColladaNode *pParent;
 
    cVector3f mvScale;
 
    int mlCount;
 
    tColladaNodeList mlstChildren;
 
    tColladaTransformList mlstTransforms;
 
    /*void DeleteChildren()
    {
        STLDeleteAll(mlstChildren);
    }*/
 
    cColladaNode *CreateChild() {
        cColladaNode *pNode = hplNew(cColladaNode, ());
        mlstChildren.push_back(pNode);
        pNode->pParent = this;
        return pNode;
    }
 
    cColladaTransform *GetTransform(const tString &asSid) {
        tColladaTransformListIt it = mlstTransforms.begin();
        for (; it != mlstTransforms.end(); it++) {
            cColladaTransform &Trans = *it;
            if (Trans.msSid == asSid) {
                return &Trans;
            }
        }
        return NULL;
    }
};
 
class cColladaScene {
public:
    cColladaScene() {
        mRoot.m_mtxTransform = cMatrixf::Identity;
        mRoot.m_mtxWorldTransform = cMatrixf::Identity;
 
        mfDeltaTime = 0;
    }
 
    ~cColladaScene() {
        // mRoot.DeleteChildren();
        STLDeleteAll(mlstNodes);
    }
 
    void ResetNodes() {
        STLDeleteAll(mlstNodes);
        mRoot.mlstChildren.clear();
    }
 
    cColladaNode *GetNode(const tString asId) {
        tColladaNodeListIt it = mlstNodes.begin();
        for (; it != mlstNodes.end(); ++it) {
            cColladaNode *pNode = *it;
            if (pNode->msId == asId || pNode->msName == asId) {
                return pNode;
            }
        }
 
        return NULL;
    }
 
    cColladaNode *GetNodeFromSource(const tString asSource) {
        tColladaNodeListIt it = mlstNodes.begin();
        for (; it != mlstNodes.end(); ++it) {
            cColladaNode *pNode = *it;
            if (pNode->msSource == asSource) {
                return pNode;
            }
        }
 
        return NULL;
    }
 
    float mfStartTime;
    float mfEndTime;
    float mfDeltaTime;
 
    cColladaNode mRoot;
 
    tColladaNodeList mlstNodes;
};
 
//------------------------------------------------
 
class cMeshLoaderCollada : public iMeshLoader {
public:
    cMeshLoaderCollada(iLowLevelGraphics *apLowLevelGraphics);
    virtual ~cMeshLoaderCollada();
 
    cMesh *LoadMesh(const tString &asFile, tMeshLoadFlag aFlags);
    bool SaveMesh(cMesh *apMesh, const tString &asFile) { return false; }
 
    cWorld3D *LoadWorld(const tString &asFile, cScene *apScene, tWorldLoadFlag aFlags);
 
    cAnimation *LoadAnimation(const tString &asFile);
 
    bool IsSupported(const tString asFileType);
 
    void AddSupportedTypes(tStringVec *avFileTypes);
 
private:
    bool mbZToY;
 
    tWorldLoadFlag mFlags;
 
    tString GetParentName(cColladaNode *apNode, tColladaGeometryVec *apColladaGeometries);
 
    void CreateMeshJoint(cMeshJoint *apJoint, ePhysicsJointType aJointType, cBoundingVolume &aBV,
                         tStringVec &avStrings, cColladaNode *apNode, cColladaScene &aColladaScene,
                         tColladaGeometryVec &avColladaGeom);
 
    void CreateHierarchyNodes(cMesh *apMesh, cNode3D *mpParentNode,
                              cColladaNode *apColladaNode,
                              tColladaGeometryVec &avColladaGeom);
 
    cColladaGeometry *GetGeometry(const tString &asId, tColladaGeometryVec &avGeomVec);
    cColladaLight *GetLight(const tString &asId, tColladaLightVec &avLightVec);
 
    cMeshEntity *CreateStaticMeshEntity(cColladaNode *apNode, cWorld3D *apWorld,
                                        cColladaGeometry *apGeom, bool abInRoomGroup,
                                        tColladaMaterialVec &avColladaMaterials,
                                        tColladaTextureVec &avColladaTextures,
                                        tColladaImageVec &avColladaImages);
 
    cColliderEntity *CreateStaticCollider(cColladaNode *apNode, cWorld3D *apWorld,
                                          cColladaGeometry *apGeom,
                                          tColladaMaterialVec &avColladaMaterials,
                                          tColladaTextureVec &avColladaTextures,
                                          tColladaImageVec &avColladaImages,
                                          bool abCharacterCollider);
 
    void AddSceneObjects(cColladaNode *apNode, cWorld3D *apWorld,
                         tColladaGeometryVec &avColladaGeometries, tColladaLightVec &avColladaLights,
                         tColladaMaterialVec &avColladaMaterials, tColladaTextureVec &avColladaTextures,
                         tColladaImageVec &avColladaImages, cColladaScene *apColladaScene);
 
    void AddSectorChildren(cColladaNode *apNode, tString asSector, cWorld3D *apWorld,
                           tColladaGeometryVec &avColladaGeometries, tColladaLightVec &avColladaLights,
                           tColladaMaterialVec &avColladaMaterials, tColladaTextureVec &avColladaTextures,
                           tColladaImageVec &avColladaImages);
 
    cAnimationTrack *CreateAnimTrack(cAnimation *apAnimation, cSkeleton *apSkeleton,
                                     cColladaAnimation &aAnim, cColladaScene *apScene);
 
    void CalcLocalMatrixRec(cBone *apBone, cMatrixf a_mtxParentGlobal, int alDepth);
 
    void CreateSkeletonBone(cColladaNode *apColladaNode, cBone *apParentBone);
 
    iVertexBuffer *CreateVertexBuffer(cColladaGeometry &aGeometry,
                                      eVertexBufferUsageType aUsageType);
    // tColladaExtraVtxListVec &vExtraVtxVec);
 
    bool FillStructures(const tString &asFile,
                        tColladaImageVec *apColladaImageVec,
                        tColladaTextureVec *apColladaTextureVec,
                        tColladaMaterialVec *apColladaMaterialVec,
                        tColladaLightVec *apColladaLightVec,
                        tColladaGeometryVec *apColladaGeometryVec,
                        tColladaControllerVec *apColladaControllerVec,
                        tColladaAnimationVec *apColladaAnimVec,
                        cColladaScene *apColladaScene,
                        bool abCache);
 
    bool SaveStructures(const tString &asFile,
                        tColladaImageVec *apColladaImageVec,
                        tColladaTextureVec *apColladaTextureVec,
                        tColladaMaterialVec *apColladaMaterialVec,
                        tColladaLightVec *apColladaLightVec,
                        tColladaGeometryVec *apColladaGeometryVec,
                        tColladaControllerVec *apColladaControllerVec,
                        tColladaAnimationVec *apColladaAnimVec,
                        cColladaScene *apColladaScene);
 
    bool LoadStructures(const tString &asFile,
                        tColladaImageVec *apColladaImageVec,
                        tColladaTextureVec *apColladaTextureVec,
                        tColladaMaterialVec *apColladaMaterialVec,
                        tColladaLightVec *apColladaLightVec,
                        tColladaGeometryVec *apColladaGeometryVec,
                        tColladaControllerVec *apColladaControllerVec,
                        tColladaAnimationVec *apColladaAnimVec,
                        cColladaScene *apColladaScene);
 
    void LoadColladaScene(TiXmlElement *apRootElem, cColladaNode *apParentNode, cColladaScene *apScene,
                          tColladaLightVec *apColladaLightVec);
 
    void LoadAnimations(TiXmlElement *apRootElem, tColladaAnimationVec &avAnimations,
                        cColladaScene *apColladaScene);
 
    void LoadImages(TiXmlElement *apRootElem, tColladaImageVec &avColladaImageVec);
 
    void LoadTextures(TiXmlElement *apRootElem, tColladaTextureVec &avColladaTextureVec);
 
    void LoadMaterials(TiXmlElement *apRootElem, tColladaMaterialVec &avColladaMaterialVec);
 
    void LoadLights(TiXmlElement *apRootElem, tColladaLightVec &avColladaLightVec);
 
    void LoadGeometry(TiXmlElement *apRootElem, tColladaGeometryVec &avColladaGeometryVec, cColladaScene *apColladaScene);
    void LoadVertexData(TiXmlElement *apSourceElem, tVector3fVec &avVtxVec);
 
    void LoadControllers(TiXmlElement *apRootElem, tColladaControllerVec &avColladaControllerVec,
                         tColladaGeometryVec *apColladaGeometryVec);
    void LoadJointData(TiXmlElement *apSourceElem, cColladaController &aController);
 
    // Helpers
    void SplitVertices(cColladaGeometry &aGeometry, tColladaExtraVtxListVec &avExtraVtxVec,
                       tVertexVec &avVertexVec, tUIntVec &avIndexVec);
 
    void FillVertexVec(const char *apChars, tVector3fVec &avVtxVec, int alElements, int alVtxCount);
    tString GetTopString(const tString asPath);
    tString GetMaterialTextureFile(const tString &asMaterial, tColladaMaterialVec &avColladaMaterialVec,
                                   tColladaTextureVec &avColladaTextureVec,
                                   tColladaImageVec &avColladaImageVec);
 
    cVector3f GetVectorPos(const cVector3f &avVec);
    cVector3f GetVectorPosFromPtr(float *apVec);
    cVector3f GetVectorScaleFromPtr(float *apVec);
};
 
} // namespace hpl
 
#endif // HPL_MESH_LOADER_COLLADA_H