Mesh.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_H
#define HPL_MESH_H
 
#include "hpl1/engine/graphics/GraphicsTypes.h"
#include "hpl1/engine/math/MathTypes.h"
#include "hpl1/engine/resources/ResourceBase.h"
#include "hpl1/engine/system/SystemTypes.h"
 
#include "hpl1/engine/physics/CollideShape.h"
#include "hpl1/engine/physics/PhysicsJoint.h"
 
#include "common/array.h"
#include "hpl1/engine/scene/Light3D.h"
#include "common/stablemap.h"
#include "common/multimap.h"
 
namespace hpl {
 
class cMaterialManager;
class cAnimationManager;
class cSubMesh;
class cMeshEntity;
class cSkeleton;
class cAnimation;
class cNode3D;
class iCollideShape;
class iPhysicsWorld;
class iPhysicsBody;
class iPhysicsJoint;
class cBillboard;
class cBeam;
class cParticleSystem3D;
class cSoundEntity;
class cWorld3D;
 
//--------------------------------------------------
 
typedef Common::Array<cAnimation *> tAnimationVec;
typedef tAnimationVec::iterator tAnimationVecIt;
 
typedef Common::StableMap<tString, int> tAnimationIndexMap;
typedef tAnimationIndexMap::iterator tAnimationIndexMapIt;
 
typedef Common::Array<cSubMesh *> tSubMeshVec;
typedef Common::Array<cSubMesh *>::iterator tSubMeshVecIt;
 
typedef Common::MultiMap<tString, cSubMesh *> tSubMeshMap;
typedef tSubMeshMap::iterator tSubMeshMapIt;
 
typedef Common::Array<cNode3D *> tNode3DVec;
typedef tNode3DVec::iterator tNode3DVecIt;
 
//--------------------------------------------------
 
class cMeshCollider {
public:
    tString msGroup;
 
    eCollideShapeType mType;
    cVector3f mvSize;
    cMatrixf m_mtxOffset;
};
 
typedef Common::Array<cMeshCollider *> tMeshColliderVec;
typedef tMeshColliderVec::iterator tMeshColliderVecIt;
 
//--------------------------------------------------
 
class cMeshJoint {
public:
    ePhysicsJointType mType;
 
    tString msName;
 
    bool mbCollide;
 
    cVector3f mvPivot;
    cVector3f mvPinDir;
 
    float mfMax;
    float mfMin;
 
    tString msChildBody;
    tString msParentBody;
};
 
typedef Common::Array<cMeshJoint *> tMeshJointVec;
typedef tMeshJointVec::iterator tMeshJointVecIt;
 
//--------------------------------------------------
 
class cMeshLight {
public:
    tString msParent;
    tString msFile;
    tString msName;
 
    eLight3DType mType;
    cMatrixf m_mtxTransform;
    cColor mColor;
    float mfRadius;
    float mfFOV;
    bool mbCastShadows;
};
 
typedef Common::Array<cMeshLight *> tMeshLightVec;
typedef tMeshLightVec::iterator tMeshLightVecIt;
 
//--------------------------------------------------
 
class cMeshBeam {
public:
    tString msFile;
    tString msName;
 
    tString msStartParent;
    cVector3f mvStartPosition;
 
    tString msEndParent;
    cVector3f mvEndPosition;
};
 
typedef Common::Array<cMeshBeam *> tMeshBeamVec;
typedef tMeshBeamVec::iterator tMeshBeamVecIt;
 
//--------------------------------------------------
 
class cMeshBillboard {
public:
    tString msParent;
    tString msFile;
    tString msName;
 
    cVector2f mvSize;
    cVector3f mvPosition;
    cVector3f mvAxis;
    float mfOffset;
};
 
typedef Common::Array<cMeshBillboard *> tMeshBillboardVec;
typedef tMeshBillboardVec::iterator tMeshBillboardVecIt;
 
//--------------------------------------------------
 
class cMeshParticleSystem {
public:
    tString msParent;
    tString msType;
    tString msName;
 
    cMatrixf m_mtxTransform;
    cVector3f mvSize;
};
 
typedef Common::Array<cMeshParticleSystem *> tMeshParticleSystemVec;
typedef tMeshParticleSystemVec::iterator tMeshParticleSystemVecIt;
 
//--------------------------------------------------
 
class cMeshSoundEntity {
public:
    tString msParent;
    tString msType;
    tString msName;
 
    cVector3f mvPosition;
};
 
typedef Common::Array<cMeshSoundEntity *> tMeshSoundEntityVec;
typedef tMeshSoundEntityVec::iterator tMeshSoundEntityVecIt;
 
//--------------------------------------------------
 
class cMeshReference {
public:
    tString msParent;
    tString msName;
    tString msFile;
 
    cMatrixf m_mtxTransform;
};
 
typedef Common::Array<cMeshReference *> tMeshReferenceVec;
typedef tMeshReferenceVec::iterator tMeshReferenceVecIt;
 
//--------------------------------------------------
 
class cMesh : public iResourceBase {
    friend class cSubMesh;
    friend class cMeshEntity;
 
public:
    cMesh(const tString asName, cMaterialManager *apMaterialManager,
          cAnimationManager *apAnimationManager);
    ~cMesh();
 
    bool CreateFromFile(const tString asFile);
 
    cSubMesh *CreateSubMesh(const tString &asName);
 
    cSubMesh *GetSubMesh(unsigned int alIdx);
    cSubMesh *GetSubMeshName(const tString &asName);
    int GetSubMeshNum();
 
    void SetSkeleton(cSkeleton *apSkeleton);
    cSkeleton *GetSkeleton();
 
    void AddAnimation(cAnimation *apAnimation);
 
    cAnimation *GetAnimation(int alIndex);
    cAnimation *GetAnimationFromName(const tString &asName);
    int GetAnimationIndex(const tString &asName);
 
    void ClearAnimations(bool abDeleteAll);
 
    int GetAnimationNum();
 
    void SetupBones();
 
    // Joints
    cMeshJoint *CreatePhysicsJoint(ePhysicsJointType);
    cMeshJoint *GetPhysicsJoint(int alIdx);
    int GetPhysicsJointNum();
    iPhysicsJoint *CreateJointInWorld(const tString &sNamePrefix, cMeshJoint *apMeshJoint,
                                      iPhysicsBody *apParentBody, iPhysicsBody *apChildBody,
                                      const cMatrixf &a_mtxOffset, iPhysicsWorld *apWorld);
 
    void CreateNodeBodies(iPhysicsBody **apRootBodyPtr, Common::Array<iPhysicsBody *> *apSubBodyVec,
                          cMeshEntity *apEntity, iPhysicsWorld *apWorld,
                          const cMatrixf &a_mtxTransform);
 
    void CreateJointsAndBodies(Common::Array<iPhysicsBody *> *apBodyVec, cMeshEntity *apEntity,
                               Common::Array<iPhysicsJoint *> *apJointVec,
                               const cMatrixf &a_mtxOffset, iPhysicsWorld *apWorld);
 
    bool HasSeveralBodies();
 
    // Colliders
    cMeshCollider *CreateCollider(eCollideShapeType aType);
    cMeshCollider *GetCollider(int alIdx);
    int GetColliderNum();
    iCollideShape *CreateCollideShape(iPhysicsWorld *apWorld);
    iCollideShape *CreateCollideShapeFromCollider(cMeshCollider *pCollider, iPhysicsWorld *apWorld);
 
    // Lights
    cMeshLight *CreateLight(eLight3DType aType);
    cMeshLight *GetLight(int alIdx);
    int GetLightNum();
    iLight3D *CreateLightInWorld(const tString &sNamePrefix, cMeshLight *apMeshLight,
                                 cMeshEntity *apMeshEntity, cWorld3D *apWorld);
 
    // Billboards
    cMeshBillboard *CreateBillboard();
    cMeshBillboard *GetBillboard(int alIdx);
    int GetBillboardNum();
    cBillboard *CreateBillboardInWorld(const tString &sNamePrefix, cMeshBillboard *apMeshBillboard,
                                       cMeshEntity *apMeshEntity, cWorld3D *apWorld);
 
    // Beams
    cMeshBeam *CreateBeam();
    cMeshBeam *GetBeam(int alIdx);
    int GetBeamNum();
    cBeam *CreateBeamInWorld(const tString &sNamePrefix, cMeshBeam *apMeshBeam,
                             cMeshEntity *apMeshEntity, cWorld3D *apWorld);
 
    // Particle systems
    cMeshParticleSystem *CreateParticleSystem();
    cMeshParticleSystem *GetParticleSystem(int alIdx);
    int GetParticleSystemNum();
    cParticleSystem3D *CreateParticleSystemInWorld(const tString &sNamePrefix, cMeshParticleSystem *apMeshPS,
                                                   cMeshEntity *apMeshEntity, cWorld3D *apWorld);
 
    // References
    cMeshReference *CreateReference();
    cMeshReference *GetReference(int alIdx);
    int GetReferenceNum();
    iEntity3D *CreateReferenceInWorld(const tString &sNamePrefix, cMeshReference *apMeshRef,
                                      cMeshEntity *apMeshEntity, cWorld3D *apWorld,
                                      const cMatrixf &a_mtxOffset);
 
    // Sound entities
    cMeshSoundEntity *CreateSoundEntity();
    cMeshSoundEntity *GetSoundEntity(int alIdx);
    int GetSoundEntityNum();
    cSoundEntity *CreateSoundEntityInWorld(const tString &sNamePrefix, cMeshSoundEntity *apMeshSound,
                                           cMeshEntity *apMeshEntity, cWorld3D *apWorld);
 
    // Node
    cNode3D *GetRootNode();
    void AddNode(cNode3D *apNode);
    int GetNodeNum();
    cNode3D *GetNode(int alIdx);
 
    // Resources implementation
    bool reload() { return false; }
    void unload() {}
    void destroy() {}
 
private:
    cMaterialManager *mpMaterialManager;
    cAnimationManager *mpAnimationManager;
 
    tSubMeshVec mvSubMeshes;
    tSubMeshMap m_mapSubMeshes;
 
    cSkeleton *mpSkeleton;
 
    tAnimationVec mvAnimations;
    tAnimationIndexMap m_mapAnimIndices;
 
    cNode3D *mpRootNode;
    tNode3DVec mvNodes;
 
    tMeshJointVec mvPhysicJoints;
    tMeshColliderVec mvColliders;
 
    tMeshLightVec mvLights;
    tMeshBillboardVec mvBillboards;
    tMeshBeamVec mvBeams;
    tMeshParticleSystemVec mvParticleSystems;
    tMeshSoundEntityVec mvSoundEntities;
    tMeshReferenceVec mvReferences;
};
 
} // namespace hpl
 
#endif // HPL_MESH_H