cModelX.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cModelX_H
#define _INC_cModelX_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cModel.h"
#include "../Resource/cXResourceFile.h"
#include "../DX/cDXMesh.h"
#include "GrayLib/include/Geometry/cTriangle3.h"
#include "GrayCore/include/cFilePath.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cBits.h"
 
namespace Gray3D
{
        enum ModelX_FrameName_TYPE
        {
#define cModelXFrameName(a,b,c) ModelX_FrameName_##a,
#include "cModelXFrameNames.tbl"
#undef cModelXFrameName
                ModelX_FrameName_QTY,
        };
 
        enum ModelX_FrameMask_TYPE_
        {
#define cModelXFrameName(a,b,c) ModelX_FrameMask_##a = _1BITMASK(ModelX_FrameName_##a),
#include "cModelXFrameNames.tbl"
#undef cModelXFrameName
        };
 
        typedef WORD ModelX_FrameMask_t;        // what frames does this hierarchy have ?
 
        class GRAY3D_LINK DECLSPEC_UUID("{a6342e06-8899-44c0-ab3a-596bc92b25df}") cModelXHeader
        {
        public:
                enum { VERSION = 2 };
 
                DWORD m_nVersion;               //!< cModelXHeader::VERSION
                cBounds3f m_BBox;               //!< pre-calculate a full model bbox. (before any animation)
                cSpheref m_BSphere;             //!< pre-calculate a full model tight bsphere. (before any animation)
                int m_nVerticesTotal;   //!< Count total for the hierarchical model.
                int m_nFacesTotal;              //!< Count total for the hierarchical model.
 
        public:
                void InitXFileHeader()
                {
                        m_nVersion = 0; // unknown version.
                        m_nVerticesTotal = 0;
                        m_nFacesTotal = 0;
                }
        };
 
        class GRAY3D_LINK cModelXEffectParam
        {
 
        public:
                cString m_sName;                                //!< param name
 
                // Variant
                enum _D3DXEFFECTDEFAULTTYPE m_eType;    //!< param value type. D3DXEDT_STRING, DWORD, FLOATS (or array of such based on size of m_Value) VARTYPE_DWORD, VARTYPE_ArrayT
                cHeapBlock m_Value;                             //!< binary blob of data for param value. D3DXEFFECTDEFAULT
        };
 
        class GRAY3D_LINK cModelXMaterial
        {
                // UVVelocity
        public:
                cStringF m_sTextureFilename;    //!< + normal, bump map, gloss map, etc ?
                cStringF m_sEffectFilename;
                cArrayStruct<cModelXEffectParam> m_aDefaults; //!< set default params for m_sEffectFilename
        };
 
        class GRAY3D_LINK cModelXMeshCont
                : public _D3DXMESHCONTAINER
        {
 
        public:
                cStringA m_sName;                               //!< stores the name of this mesh.
                cBounds3f m_BBoxMesh;                   //!< pre-transformed. local mesh coord units.
                cSpheref m_BSphereMesh;                 //!< pre-transformed. local mesh coord units.
                cArrayStruct<cModelXMaterial> m_aMaterials;     //!< materials and effects on the material. (NumMaterials) for (pMaterials and pEffects)
 
                static const _D3DVERTEXELEMENT9 k_VertDeclX[5];
 
        public:
                cModelXMeshCont(const ATOMCHAR_t* pszName);
                virtual ~cModelXMeshCont();
 
                virtual HRESULT DisposeThis();
 
                void InitAdjacency(const DWORD *pAdjacencyInit, DWORD dwNumFaces);
                HRESULT InitTangents(DWORD dwOpt, IDirect3DDevice9* pDXDev);
                void InitMaterials(const _D3DXMATERIAL* pMaterials2, DWORD dwNumMaterials);
                void InitEffectInstances(const _D3DXEFFECTINSTANCE* pEffects2, DWORD dwNumMaterials);
 
                DWORD ComputeMeshBoundingBox(cBounds3f& tBox) const;
                DWORD ComputeMeshBoundingSphere(const cMatrix4x4f& CombinedTransformationMatrix, cSphereWork& bsphere) const;
                DWORD ComputePointCloud(const cMatrix4x4f& CombinedTransformationMatrix, cArrayStruct<cVector3f>& cloud);
 
                HRESULT GetIndexedFaceMesh(_Inout_ DWORD& rdwFaceToFind, OUT cTriangle3f& tri) const;
 
                DWORD get_NumMaterials() const
                {
                        return this->NumMaterials;
                }
                HRESULT GetMaterialTexName(int iMaterial, cStringF& sFileName) const;
 
                cModelXMeshCont* get_NextMeshCont() const
                {
                        return static_cast<cModelXMeshCont*>(this->pNextMeshContainer);
                }
 
                ID3DXMesh* get_Mesh() const
                {
                        ASSERT(MeshData.Type == D3DXMESHTYPE_MESH);
                        return MeshData.pMesh;
                }
 
                void put_MeshX(ID3DXMesh* pMesh)
                {
                        if (MeshData.pMesh == pMesh)
                                return;
                        if (MeshData.pMesh != nullptr)
                        {
                                MeshData.pMesh->Release();
                        }
                        MeshData.pMesh = pMesh;
                        MeshData.Type = D3DXMESHTYPE_MESH;
                        if (pMesh != nullptr)
                        {
                                pMesh->AddRef();
                        }
                }
 
                HRESULT CountIntersections(const cVector3f& v1, const cVector3f& vDir, float* pfDistHit);
        };
 
        class GRAY3D_LINK cModelXFrame
                : public _D3DXFRAME     // has a transform matrix.
                , public cHeapObject
        {
 
        public:
                cStringA m_sName;
                ModelX_FrameMask_t m_uFrameFlags;               //!< inside, outside,... flags for meshes in this frame
                ModelX_FrameMask_t m_uChildrenFlags;    //!< all frame children flags concatenated. (NOT sibs)
 
                cMatrix4x4f     m_mCombinedTransformation;      //!< multiply up all my parent chains matrices. how to transform into full model coords. NOT valid if animated
                cBounds3f m_BBoxFrame;                          //!< combined model space bbox. NOT valid if animated.
                cSpheref m_BSphereFrame;                        //!< combined model space bsphere. NOT valid if animated.
 
        public:
                CHEAPOBJECT_IMPL;
                DECLARE_HEAP_ALIGNED_ALLOC(cModelXFrame);
 
                cModelXFrame(const ATOMCHAR_t* pszFrameName);
                virtual ~cModelXFrame();
 
                cModelXFrame* get_FrameSibling() const
                {
                        return static_cast<cModelXFrame*>(this->pFrameSibling);
                }
                cModelXFrame* get_FrameChild0() const
                {
                        return static_cast<cModelXFrame*>(this->pFrameFirstChild);
                }
 
                cModelXMeshCont* get_MeshCont0() const
                {
                        return static_cast<cModelXMeshCont*>(this->pMeshContainer);
                }
 
                DWORD get_MeshContFaces(bool bChildFrames, bool bSiblings) const;
                HRESULT GetIndexedFaceFrame(DWORD dwFaceToFind, cTriangle3f& tri, const cMatrix4x4f** ppmTransform, bool bCheckSiblings) const;
 
                DWORD ComputeFrameBoundingBox(cBounds3f& bres, bool bSibsAndChildren) const;
                DWORD ComputeFrameBoundingSphere(cSphereWork& bsphere, bool bSibsAndChildren) const;
                DWORD ComputePointCloud(const cMatrix4x4f* pParentMatrix, cArrayStruct<cVector3f>& cloud);
 
                cModelXMeshCont* FindMeshCont(const ATOMCHAR_t* pszMeshContName, bool bSiblings) const;
                cModelXFrame* FindFrame(const ATOMCHAR_t* pszFrameName, bool bSiblings) const;
 
                bool GetHitTest(float& fDistHit, const cVector3f& vo, const cVector3f& vd, const cMatrix4x4f& mWorldRoot);
                int CountIntersections(const cVector3f& vStart, const cVector3f& vDir, ModelX_FrameMask_t uFrameMask);
 
                void UpdateCombinedTransformationMatrixs(const cMatrix4x4f* pParentMatrix);
                ModelX_FrameMask_t UpdateChildrenFlags();
        };
 
        class GRAY3D_LINK cModelX
                : public cXResourceFile
                , public ID3DXAllocateHierarchy
                , public ID3DXLoadUserData
        {
 
        public:
                static const char* k_szFrameNames[ModelX_FrameName_QTY + 1];    // ModelX_FrameName_TYPE
 
                cModelXHeader m_ModelXHeader;   //!< for new (compiled) formats
                cModelXFrame* m_pFrameRoot;             //!< created by CreateFrame() (a list)
 
#ifdef USE_DXX
                // Optionally - Multiple set of animations that may run on this model. ID3DXAnimationSet
                cIUnkPtr<ID3DXAnimationController> m_pAnimController; //!< created only for models that can animate.
#endif
 
        protected:
                bool m_bXHeaderValid;                           //!< m_ModelXHeader is valid ? read or computed.
                ModelX_FrameMask_t m_uTotalFlags;       //!< m_uFrameFlags | m_uChildrenFlags for all frames
 
        public:
                cModelX(const FILECHAR_t* pszFileName);
                virtual ~cModelX();
 
                virtual HRESULT LoadMeshHierarchy(const FILECHAR_t* pstrMeshXFilePath, IDirect3DDevice9* pd3dDevice);
                virtual HRESULT DeleteDeviceObjects();
 
                HRESULT FrameMove(float fElapsedTime);
 
                // public helpers
                cModelXFrame* get_FrameRoot() const
                {
                        return m_pFrameRoot;
                }
                ModelX_FrameMask_t get_TotalFlags() const
                {
                        return m_uTotalFlags;
                }
 
                void UpdateXHeader()
                {
                        m_bXHeaderValid = true;
                        m_ModelXHeader.m_nVerticesTotal = ComputeBoundingSphere(m_ModelXHeader.m_BSphere);
                        ComputeBoundingBox(m_ModelXHeader.m_BBox);
                }
 
                const cBounds3f& get_BBox()
                {
                        if (!m_bXHeaderValid)
                        {
                                UpdateXHeader();
                        }
                        return m_ModelXHeader.m_BBox;
                }
 
                const cSpheref& get_BSphere()
                {
                        if (!m_bXHeaderValid)
                        {
                                UpdateXHeader();
                        }
                        return m_ModelXHeader.m_BSphere;
                }
 
                int ComputeBoundingBox(cBounds3f& bres);
                int ComputeBoundingSphere(cSpheref& bsphere);
 
                cModelXFrame* FindFrame(const ATOMCHAR_t* pszFrameName) const;
                void DestroyFrameX(cModelXFrame* pFrame);
 
                STDMETHOD(CreateFrame)(THIS_ const char* pszName, _D3DXFRAME** ppNewFrame);
                STDMETHOD(CreateMeshContainer)(THIS_
                        const char* pszName,
                        const _D3DXMESHDATA *pMeshData,
                        const _D3DXMATERIAL *pMaterials,
                        const _D3DXEFFECTINSTANCE *pEffectInstances,
                        DWORD NumMaterials,
                        const DWORD *pAdjacency,
                        ID3DXSkinInfo* /* pSkinInfo*/,
                        _D3DXMESHCONTAINER** ppNewMeshCont);
                STDMETHOD(DestroyFrame)(THIS_ _D3DXFRAME* pFrameToFree);
                STDMETHOD(DestroyMeshContainer)(THIS_ _D3DXMESHCONTAINER* pMeshContBase);
 
                STDMETHOD(LoadTopLevelData)(ID3DXFileData* pData);
                STDMETHOD(LoadFrameChildData)(_D3DXFRAME* pF, ID3DXFileData* pData)
                {
                        UNREFERENCED_PARAMETER(pF);
                        UNREFERENCED_PARAMETER(pData);
                        return S_OK;
                }
                STDMETHOD(LoadMeshChildData)(_D3DXMESHCONTAINER* pMC, ID3DXFileData* pData)
                {
                        UNREFERENCED_PARAMETER(pMC);
                        UNREFERENCED_PARAMETER(pData);
                        return S_OK;
                }
 
                UNITTEST_FRIEND(cModelX);
        };
 
        typedef cRefPtr<cModelX> cModelXPtr;
};
 
#endif // _INC_cModelX_H