ParaXModel.h

#pragma once
#include "IAttributeFields.h"
#include "modelheaders.h"
#include "animated.h"
#include "AnimInstanceBase.h"
#include "ParameterBlock.h"
#include "ParaXModelInstance.h"
#include "TextureAnim.h"
#include "ParaXModelCommon.h"
#include "ModelRenderPass.h"

namespace ParaEngine
{ 
    class Bone;
    class ParticleSystem;
    class RibbonEmitter;
    class CParaXModel;
    struct TextureEntity;
    class CEffectFile;
    struct CharacterPose;
    class ShadowVolume;
    struct LightParams;
    class CFaceGroup;
    struct ModelAttachment;
    

    class CParaXModel : public IAttributeFields
    {
    public:
        CParaXModel(const ParaXHeaderDef& xheader);
        virtual ~CParaXModel(void);

        enum RENDER_METHOD{
            SOFT_ANIM = 0, 
            SHADER_ANIM, 
            NO_ANIM,
            BMAX_MODEL,
        };
    public:
        // implementation of IAttributeFields

        virtual int GetAttributeClassID(){return ATTRIBUTE_CLASSID_CParaXModel;}
        virtual const char* GetAttributeClassName(){static const char name[] = "CParaXModel"; return name;}
        virtual const char* GetAttributeClassDescription(){static const char desc[] = ""; return desc;}
        virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

        virtual int GetChildAttributeColumnCount();
        virtual IAttributeFields* GetChildAttributeObject(const std::string& sName);
        virtual int GetChildAttributeObjectCount(int nColumnIndex = 0);
        virtual IAttributeFields* GetChildAttributeObject(int nRowIndex, int nColumnIndex = 0);

        ATTRIBUTE_METHOD1(CParaXModel, DumpTextureUsage_s, const char**)    {*p1 = cls->DumpTextureUsage(); return S_OK;}
        ATTRIBUTE_METHOD1(CParaXModel, GetPolyCount_s, int*)    {*p1 = cls->GetPolyCount(); return S_OK;}
        ATTRIBUTE_METHOD1(CParaXModel, GetPhysicsCount_s, int*) {*p1 = cls->GetPhysicsCount(); return S_OK;}
        ATTRIBUTE_METHOD1(CParaXModel, GetGeosetsCount_s, int*) { *p1 = (int)cls->geosets.size(); return S_OK; }
        ATTRIBUTE_METHOD1(CParaXModel, GetRenderPassesCount_s, int*)    { *p1 = (int)cls->passes.size(); return S_OK; }
        ATTRIBUTE_METHOD1(CParaXModel, GetObjectNum_s, void**)  { *p1 = (void*)(&(cls->GetObjectNum())); return S_OK; }
        ATTRIBUTE_METHOD1(CParaXModel, GetVertices_s, void**)   { *p1 = (void*)(cls->m_origVertices); return S_OK; }
        ATTRIBUTE_METHOD1(CParaXModel, GetRenderPasses_s, void**)   { *p1 = (void*)(&(cls->passes[0])); return S_OK; }
        ATTRIBUTE_METHOD1(CParaXModel, GetGeosets_s, void**)    { *p1 = (void*)(&(cls->geosets[0])); return S_OK; }
        ATTRIBUTE_METHOD1(CParaXModel, GetIndices_s, void**)    { *p1 = (void*)(&(cls->m_indices[0])); return S_OK; }
        ATTRIBUTE_METHOD1(CParaXModel, GetAnimations_s, void**) { *p1 = (void*)(cls->anims); return S_OK; }
        ATTRIBUTE_METHOD1(CParaXModel, SaveToDisk_s, char*) { cls->SaveToDisk(p1); return S_OK; }
    public:
        int GetPolyCount();
        int GetPhysicsCount();
        const char* DumpTextureUsage();

        inline const ParaXModelObjNum& GetObjectNum() const {return m_objNum;};
        inline const ParaXHeaderDef& GetHeader() const {return m_header;};
        bool CheckMinVersion(int v0, int v1=0, int v2=0, int v3=0);

        void initVertices(int nVertices, ModelVertex* pVertices);
        void initIndices(int nIndices, uint16* pIndices);


        void initTranslucentFaceGroups();

        ModelAttachment& NewAttachment(bool bOverwrite, int nAttachmentID, int nBoneIndex, const Vector3& pivotPoint);

        bool IsValid();

        bool InitDeviceObjects();
        bool DeleteDeviceObjects();

        bool SetupTransformByID(int nID);

        void drawModel(SceneState * pSceneState, CParameterBlock* pMaterialParam = NULL, int nRenderMethod = -1);
        
        void animate(SceneState * pSceneState, CharacterPose* pPose, IAttributeFields* pAnimInstance = NULL);

        void draw(SceneState * pSceneState, CParameterBlock* materialParams = NULL, int nRenderMethod = -1);

        void BuildShadowVolume(ShadowVolume * pShadowVolume, LightParams* pLight, Matrix4* mxWorld);
        
        void updateEmitters(SceneState * pSceneState, float dt);
        void drawBones();
        void drawBoundingVolume();

        void calcBones(CharacterPose* pPose, const AnimIndex& CurrentAnim, const AnimIndex& BlendingAnim, float blendingFactor, IAttributeFields* pAnimInstance = NULL);

        void calcBones();

        void PostCalculateBoneMatrix(uint32 nBones);

        Matrix4* GetAttachmentMatrix(Matrix4* pOut, int nAttachmentID, const AnimIndex& CurrentAnim, const AnimIndex& BlendingAnim, float blendingFactor, bool bRecalcBone = true, IAttributeFields* pAnimInstance = NULL);

        bool HasAttachmentMatrix(int nAttachmentID);

        inline Vector3 GetWeightedVertexByIndex(unsigned short nIndex);
        void lightsOn(uint32 lbase);
        void lightsOff(uint32 lbase);
        bool HasAnimation();

        bool IsBmaxModel();
        void SetBmaxModel();

        void LoadTextures();
    
        AnimIndex GetAnimIndexByID(int nAnimID);
        int GetAnimIDByIndex(int nAnimIndex);
        
        const ModelAnimation* GetModelAnimByIndex(int nAnimIndex);

        float GetBoundingRadius();
        bool canAttach(int id);
    
        void RenderNoAnim(SceneState* pSceneState);
        void RenderSoftAnim(SceneState* pSceneState,CParameterBlock* pMaterialParams=NULL);
        void RenderSoftNoAnim(SceneState* pSceneState, CParameterBlock* pMaterialParams = NULL);
        void RenderShaderAnim(SceneState* pSceneState);
        void RenderBMaxModel(SceneState* pSceneState, CParameterBlock* pMaterialParams = NULL);
        void DrawPass(ModelRenderPass &p);
        void DrawPass_NoAnim(ModelRenderPass &p);
        void DrawPass_NoAnim_VB(ModelRenderPass &p, size_t start);
        void DrawPass_BMax_VB(ModelRenderPass &p, size_t start);
        void DrawPass_BMax(ModelRenderPass &p);
        void ClearFaceGroups();
        bool HasAlphaBlendedObjects();

        int GetNextPhysicsGroupID(int nPhysicsGroup = -1);
        
        HRESULT ClonePhysicsMesh(DWORD* pNumVertices, Vector3 ** ppVerts, DWORD* pNumTriangles, DWORD** ppIndices, int* pnMeshPhysicsGroup = NULL, int* pnTotalMeshGroupCount = NULL);

        void SaveToDisk(const char* path);

        void SetRenderMethod(RENDER_METHOD method);

        void SetVertexBufferDirty();

        friend struct ModelRenderPass;

    private:
        void InitVertexBuffer_NOANIM();
        void InitVertexBuffer_BMAX();
        void InitVertexBuffer();

    public:
        ParaXHeaderDef  m_header;
        ParaXModelObjNum m_objNum;
        float m_radius;
        int m_nHasAlphaBlendedRenderPass;

        RENDER_METHOD m_RenderMethod;

        const static int MAX_MODEL_TEXTURES = 32;
        const static int MAX_MODEL_ATTACHMENTS = 40;

        ModelAnimation *anims;

        static CEffectFile * m_pEffectFile;
        static VertexDeclarationPtr m_pVertexDeclaration;
        ParaVertexBuffer m_pVertexBuffer;
        ParaIndexBuffer m_pIndexBuffer;

        size_t vbufsize;
        bool animated : 1;
        bool animGeometry : 1, animTextures : 1, animBones : 1, animTexRGB : 1;
        bool rotatePartice2SpeedVector : 1;
        bool forceAnim : 1;

        TextureAnim *texanims;
        int *globalSequences;
        ModelColor *colors;
        ModelTransparency *transparency;
        ModelLight *lights;
        ParticleSystem *particleSystems;
        RibbonEmitter *ribbons;

        ModelVertex *m_origVertices;
        int* m_frame_number_vertices;
        int m_nCurrentFrameNumber;
        Vector3 * m_vertices, *m_normals;// the position and normals for the vertices
        Vector2 *texcoords1;// the texture coordinates for the vertices
        uint16 *m_indices;

        Vector3 *bounds;
        uint16 *boundTris;

        ModelCamera cam;
        Bone *bones;
        asset_ptr<TextureEntity> *textures;

        std::vector<ModelRenderPass> passes;
        std::vector<int> m_TranslucentPassIndice;
        std::vector<CFaceGroup*>  m_faceGroups;

        std::vector<ModelGeoset> geosets;
        bool *showGeosets;

        int specialTextures[MAX_MODEL_TEXTURES];
        TextureEntity* replaceTextures[MAX_MODEL_TEXTURES];
        bool useReplaceTextures[MAX_MODEL_TEXTURES];

        AnimIndex m_CurrentAnim;

        AnimIndex m_NextAnim;

        AnimIndex m_BlendingAnim;

        float blendingFactor;

        float fBlendingTime;

        bool m_bIsValid;
        bool hasCamera;
        bool m_bTextureLoaded;

        float m_trans;
        std::vector<ModelAttachment> m_atts;
        int m_attLookup[MAX_MODEL_ATTACHMENTS];

        Vector3 m_vNeckYawAxis;
        Vector3 m_vNeckPitchAxis;

        int m_boneLookup[MAX_KNOWN_BONE_NODE];

    private:
        enum VERTEX_BUFFER_STATE
        {
            NOT_SET = 0,
            NEED_INIT           = 1,
            INITED              = 2,
            NOT_USE = 3,
        };

        VERTEX_BUFFER_STATE m_vbState;

        static const size_t MAX_USE_VERTEX_BUFFER_SIZE = 1024 * 1024 * 256;
        static size_t m_uUsedVB;
    };

    struct CharacterPose
    {
        float m_fUpperBodyFacingAngle;
        float m_fUpperBodyUpDownAngle;
    };

    typedef asset_ptr<CParaXModel> CParaXModelPtr;
}