ParaXStaticModel.h

#pragma once
#ifdef USE_DIRECTX_RENDERER
#include "StaticMesh.h"
#endif
#include "ParaXStaticBase.h"
#include "ParaXStaticModelRenderPass.h"

namespace ParaEngine
{
    class CEffectFile;
    class CFaceGroup;
    class XFileParser;
    using namespace std;
    namespace XFile
    {
        struct Node;
        struct Mesh;
        struct Scene;
        struct Material;
    }

    //-----------------------------------------------------------------------------
    // Name: class CParaXStaticModel
    //-----------------------------------------------------------------------------
    class CParaXStaticModel : public CParaXStaticBase
    {
    public:
        virtual int GetAttributeClassID() { return ATTRIBUTE_CLASSID_CParaXStaticModel; }
        virtual const char* GetAttributeClassName() { static const char name[] = "CParaXStaticModel"; return name; }
        virtual const char* GetAttributeClassDescription() { static const char desc[] = ""; return desc; }

        virtual int GetPolyCount();
        virtual int GetPhysicsCount();
        virtual const char* DumpTextureUsage();

        virtual int GetNextPhysicsGroupID(int nPhysicsGroup = -1);

        virtual TextureEntity* GetDefaultReplaceableTexture(int ReplaceableTextureID);

        // Creation/destruction
        virtual HRESULT Create(RenderDevicePtr pd3dDevice, void* buffer, DWORD nFileSize, bool bCheckSecondUV = false);
#ifdef USE_DIRECTX_RENDERER
        virtual HRESULT Create(RenderDevicePtr pd3dDevice, LPD3DXFILEDATA pFileData) { return S_FALSE;  };
#endif
        virtual HRESULT Create(RenderDevicePtr pd3dDevice, XFile::Scene* pFileData);

        virtual HRESULT Destroy();

        // Initializing
        virtual HRESULT InitDeviceObjects();
        virtual HRESULT DeleteDeviceObjects();

        // -- Get Bounding sphere
        virtual FLOAT ComputeBoundingSphere(Vector3* vObjectCenter, FLOAT* fObjectRadius);
        virtual HRESULT ComputeBoundingBox(Vector3 *pMin, Vector3 *pMax);

        virtual HRESULT ClonePhysicsMesh(DWORD* pNumVertices, Vector3 ** ppVerts, DWORD* pNumTriangles, WORD** ppIndices, int* pnMeshPhysicsGroup = nullptr, int* pnTotalMeshGroupCount = nullptr);

#ifdef USE_DIRECTX_RENDERER
        virtual MeshHeader& GetMeshHeader(LPD3DXFILE pFileParser = nullptr) { return GetMeshHeader((XFileParser*)nullptr);  };
#endif
        virtual MeshHeader& GetMeshHeader(XFileParser* pFileParser = nullptr);

#ifdef USE_DIRECTX_RENDERER

        virtual bool GetMeshHeaderFromFile(CParaFile& myFile, LPD3DXFILE pFileParser) { return false;  };
#endif
        virtual bool GetMeshHeaderFromFile(CParaFile& myFile, XFileParser* pFileParser);

        // Rendering
        virtual HRESULT Render(SceneState * pSceneState, RenderDevicePtr pd3dDevice,
            bool bDrawOpaqueSubsets = true,
            bool bDrawAlphaSubsets = true, float fAlphaFactor = 1.0f)
        {
            return S_OK; 
        };

        virtual HRESULT Render(SceneState * pSceneState, CEffectFile *pEffect,
            bool bDrawOpaqueSubsets = true,
            bool bDrawAlphaSubsets = true, float fAlphaFactor = 1.0f, CParameterBlock* materialParams = nullptr);

        CParaXStaticModel(const char* strName = nullptr, XFileParser* pXFileParser = nullptr);
        virtual ~CParaXStaticModel();

    protected:
        HRESULT LoadToSystemBuffer(XFile::Scene* pFileData);
        void BuildRenderBuffer();
        void DrawRenderPass(int i);
    protected:
        std::vector<ParaXStaticModelRenderPass> m_passes;

        // system buffers
        std::vector<mesh_vertex_normal> m_vertices;

        std::vector<int16> m_indices;
        // device buffers
        ParaVertexBuffer m_vertexBuffer;

        ParaIndexBuffer m_indexBuffer;
    };

#ifndef USE_DIRECTX_RENDERER
    typedef ref_ptr<CParaXStaticModel> CParaXStaticModelPtr;
    typedef CParaXStaticModel* CParaXStaticModelRawPtr;
#endif
}