cDXMesh.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cDXMesh_H
#define _INC_cDXMesh_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cDXBuffer.h"
#include "UseDXX.h"
#include "GrayLib/include/Math/cVector.h"
#include "GrayLib/include/Math/cMatrix.h"
#include "GrayLib/include/Geometry/cBounds3.h"
#include "GrayLib/include/Geometry/cSphere.h"
#include "GrayCore/include/cLogMgr.h" // DEBUG_ERR
#include "GrayCore/include/cIUnkPtr.h"
#include "GrayCore/include/cArraySort.h"
#include "GrayCore/include/cString.h"
 
namespace Gray3D
{
        class GRAY3D_LINK cDXMesh
        {
        public:
                cIUnkPtr<ID3DXMesh> m_pMesh;    
 
        public:
                cDXMesh(ID3DXMesh* pMesh = nullptr)
                        : m_pMesh(pMesh)
                {
                }
 
                ID3DXMesh* get_Mesh() const
                {
                        return m_pMesh;
                }
 
                HRESULT OptimizeInplace(DWORD* pAdjacency);
                HRESULT OptimizeInplace(ID3DXBuffer* pAdjacency);
 
                DWORD ComputeMeshBoundingBox(OUT cBounds3f& tBox) const;
                DWORD ComputeMeshBoundingSphere(const cMatrix4x4f& CombinedTransformationMatrix, OUT cSphereWork& bsphere) const;
 
#ifdef USE_DXX
                HRESULT LoadMesh(const FILECHAR_t* pszMeshName, IDirect3DDevice9* pDevice, cIUnkPtr<ID3DXBuffer>& pAdjacency);
                HRESULT LoadMeshOpt(const FILECHAR_t* pszMeshName, IDirect3DDevice9* pDevice);
#endif
        };
 
        //**********************************************************************
 
        template <class _TYPE_VERT = cVector3f >
        class GRAY3D_LINK cDXMeshVertex // : public cLockerT<>
        {
        public:
                _TYPE_VERT* m_pVertex;          
                size_t m_nVertStride;           
        private:
                ID3DXBaseMesh* m_pIMesh;        
        public:
                cDXMeshVertex(ID3DXBaseMesh* pIMesh, DWORD dwFlags = D3DLOCK_READONLY)
                        : m_pVertex(nullptr)
                        , m_pIMesh(pIMesh)
                {
                        ASSERT(m_pIMesh != nullptr);
                        m_nVertStride = m_pIMesh->GetNumBytesPerVertex();
                        Lock(dwFlags);
                }
                ~cDXMeshVertex()
                {
                        Unlock();
                }
                bool IsValid() const
                {
                        return m_pVertex != nullptr;
                }
                HRESULT Lock(DWORD dwFlags = D3DLOCK_READONLY)
                {
                        ASSERT(m_pIMesh != nullptr);
                        HRESULT hRes = m_pIMesh->LockVertexBuffer(dwFlags, reinterpret_cast<void**>(&m_pVertex));
                        if (FAILED(hRes))
                        {
                                DEBUG_ERR(("LockVertexBuffer ERR='%s'", LOGERR(hRes)));
                                m_pVertex = nullptr;
                        }
                        return hRes;
                }
                void Unlock()
                {
                        if (m_pVertex != nullptr)
                        {
                                m_pVertex = nullptr;
                                ASSERT(m_pIMesh != nullptr);
                                m_pIMesh->UnlockVertexBuffer();
                        }
                }
                operator const _TYPE_VERT* () const
                {
                        ASSERT(m_pVertex != nullptr);
                        return m_pVertex;
                }
                operator _TYPE_VERT* ()
                {
                        ASSERT(m_pVertex != nullptr);
                        return m_pVertex;
                }
                _TYPE_VERT* operator -> () const
                {
                        ASSERT(m_pVertex != nullptr); return(m_pVertex);
                }
 
                _TYPE_VERT* GetVertPtr(int i) const
                {
                        ASSERT(m_pVertex != nullptr);
                        ASSERT(m_nVertStride);
                        return (_TYPE_VERT*)(((BYTE*)m_pVertex) + (i * m_nVertStride));
                }
                cVector3f& GetVert(int i) const
                {
                        return *((cVector3f*)GetVertPtr(i));
                }
        };
 
        template class GRAY3D_LINK cDXMeshVertex<cVector3f>;
 
        template <typename _TYPE_INDEX = WORD>
        class GRAY3D_LINK cDXMeshIndex
        {
        public:
                _TYPE_INDEX* m_pIndex;          
        private:
                ID3DXBaseMesh* m_pIMesh;        
        public:
                cDXMeshIndex(ID3DXBaseMesh* pIMesh, DWORD dwFlags = D3DLOCK_READONLY)
                        : m_pIMesh(pIMesh)
                {
                        ASSERT(pIMesh != nullptr);
                        HRESULT hRes = pIMesh->LockIndexBuffer(dwFlags,
                                reinterpret_cast<void**>(&m_pIndex));
                        if (FAILED(hRes))
                        {
                                DEBUG_ERR(("LockIndexBuffer FAIL ERR='%s'", LOGERR(hRes)));
                                m_pIndex = nullptr;
                        }
                }
                ~cDXMeshIndex()
                {
                        Unlock();
                }
                bool IsValid() const
                {
                        return m_pIndex != nullptr ;
                }
                void Unlock()
                {
                        if (m_pIndex != nullptr)
                        {
                                m_pIndex = nullptr;
                                ASSERT(m_pIMesh != nullptr);
                                m_pIMesh->UnlockIndexBuffer();
                        }
                }
                operator const _TYPE_INDEX* () const
                {
                        ASSERT(m_pIndex != nullptr);
                        return m_pIndex;
                }
                operator _TYPE_INDEX* ()
                {
                        ASSERT(m_pIndex != nullptr);
                        return m_pIndex;
                }
        };
 
        template class GRAY3D_LINK cDXMeshIndex<WORD>;
 
        class GRAY3D_LINK cDXMeshAttribute
        {
        public:
                DWORD* m_pdwAttrib;             
        private:
                ID3DXMesh* m_pIMesh;
        public:
                cDXMeshAttribute(ID3DXMesh* pIMesh, DWORD dwFlags = D3DLOCK_READONLY) :
                        m_pIMesh(pIMesh)
                {
                        ASSERT(pIMesh != nullptr);
                        HRESULT hRes = pIMesh->LockAttributeBuffer(dwFlags, &m_pdwAttrib);
                        if (FAILED(hRes))
                        {
                                DEBUG_ERR(("LockAttributeBuffer FAIL ERR='%s'", LOGERR(hRes)));
                                m_pdwAttrib = nullptr;
                        }
                }
                ~cDXMeshAttribute()
                {
                        Unlock();
                }
                bool IsValid() const
                {
                        return(m_pdwAttrib != nullptr);
                }
                void Unlock()
                {
                        if (m_pdwAttrib != nullptr)
                        {
                                m_pdwAttrib = nullptr;
                                ASSERT(m_pIMesh != nullptr);
                                m_pIMesh->UnlockAttributeBuffer();
                        }
                }
                operator const DWORD* () const
                {
                        ASSERT(m_pdwAttrib != nullptr);
                        return m_pdwAttrib;
                }
                operator DWORD* ()
                {
                        ASSERT(m_pdwAttrib != nullptr);
                        return m_pdwAttrib;
                }
        };
}
 
#endif // _INC_cDXMesh_H