cMesh.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cMesh_H
#define _INC_cMesh_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "../Gray3D.h"
#include "GrayLib/include/Math/cVector.h"
#include "GrayLib/include/Math/cMatrix.h"
#include "GrayCore/include/cArray.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/HResult.h"
 
interface ID3DXBaseMesh;
 
namespace GrayLib
{
        class cPlanef;
};
 
namespace Gray3D
{
        class GRAY3D_LINK cMeshVertsV
        {
        public:
                cMeshVertsV(size_t nVertStride = sizeof(cVector3f))
                        : m_nVertStride(nVertStride)
                        , m_nVertices(0)
                {
                }
                size_t get_VertStride() const
                {
                        return m_nVertStride;
                }
                ITERATE_t get_VertQty() const
                {
                        return m_nVertices;
                }
 
                cVector3f& ref_Vert(ITERATE_t i)
                {
                        ASSERT(IS_INDEX_GOOD(i, m_nVertices));
                        return *((cVector3f*)(m_Vertices.get_DataBytes() + (i * m_nVertStride)));
                }
                const cVector3f& get_Vert(ITERATE_t i) const
                {
                        ASSERT(IS_INDEX_GOOD(i, m_nVertices));
                        return *((const cVector3f*)(m_Vertices.get_DataBytes() + (i * m_nVertStride)));
                }
 
                cVector3f* get_VertPtr()
                {
                        return (cVector3f*)m_Vertices.get_DataBytes();
                }
 
                void SetVertQty(ITERATE_t dwQty, size_t nVertStride)
                {
                        m_nVertices = dwQty;
                        m_nVertStride = nVertStride;
                        m_Vertices.ReAlloc(m_nVertices * m_nVertStride);
                }
                void FreeVerts()
                {
                        m_nVertices = 0;
                        m_Vertices.Free();
                }
                void AddVert(const void* pVert)
                {
                        size_t nSize = m_nVertices * m_nVertStride;
                        m_Vertices.ReAlloc(nSize + m_nVertStride);
                        memcpy(m_Vertices.get_DataBytes() + nSize, pVert, m_nVertStride);
                        m_nVertices++;
                }
 
        protected:
                size_t m_nVertStride;           
                ITERATE_t m_nVertices;          
                cHeapBlock m_Vertices;          
        };
 
        template< class _TYPE_VERT >
        class GRAY3D_LINK cMeshVertsT
        {
 
        public:
                cMeshVertsT()
                        : cMeshVertsV(sizeof(_TYPE_VERT))
                {
                }
        };
 
        template< typename _TYPE_INDEX = WORD >
        class GRAY3D_LINK cMeshIndexT
        {
        public:
                typedef _TYPE_INDEX INDEX_t;    
                ITERATE_t get_IndexQty() const
                {
                        return m_aIndexes.GetSize();
                }
                void put_IndexQty(ITERATE_t nQty)
                {
                        m_aIndexes.SetSize(nQty);
                }
 
                INDEX_t get_Index(ITERATE_t i) const
                {
                        return m_aIndexes.GetAt(i);
                }
                INDEX_t& ref_Index(ITERATE_t i)
                {
                        return m_aIndexes.ElementAt(i);
                }
                INDEX_t* get_IndexPtr()
                {
                        return m_aIndexes.GetData();
                }
                const INDEX_t* get_IndexPtr() const
                {
                        return m_aIndexes.GetData();
                }
 
                ITERATE_t AddIndex(INDEX_t index)
                {
                        return m_aIndexes.AddTail(index);
                }
                void FreeIndexes()
                {
                        m_aIndexes.RemoveAll();
                }
 
                ITERATE_t get_TriangleQty() const
                {
                        ITERATE_t nCount = 0;
                        for (ITERATE_t i = 0; i < get_IndexQty(); i++)
                        {
                                INDEX_t idx = m_aIndexes[i];
                                if (idx >= 0)
                                {
                                        nCount++;
                                }
                                else
                                {
                                        nCount -= 2;
                                }
                        }
                        return nCount;
                }
 
        protected:
                cArrayVal<INDEX_t> m_aIndexes;          
        };
 
        template< typename _TYPE_INDEX = WORD >
        class GRAY3D_LINK cMeshT
        {
        public:
                typedef _TYPE_INDEX INDEX_t;    
                cMeshT(size_t nVertStride = 0)
                        : m_Verts(nVertStride)
                {
                }
                void FreeMesh()
                {
                        m_Index.FreeIndexes();
                        m_Verts.FreeVerts();
                }
        public:
                cMeshIndexT<_TYPE_INDEX> m_Index;       
                cMeshVertsV m_Verts;                    
        };
 
        struct GRAY3D_LINK cMesh : public cMeshT<WORD>
        {
        public:
                // DECLARE_HEAP_ALIGNED_ALLOC(cMeshVar);
#ifdef USE_DXX
                HRESULT put_MeshX(ID3DXBaseMesh* pMesh);
#endif
                UNITTEST_FRIEND(cMesh);
        };
 
        class GRAY3D_LINK cMeshInt : public cMeshT<int>
        {
 
                typedef DWORD HASHUV_t;
                typedef cPair<HASHUV_t, ITERATE_t> SplitEdge_t;
 
        public:
                HRESULT GetHalfspaceMesh(const cPlanef& plane, OUT cMeshInt& meshResult, ITERATE_t numVerts = -1, ITERATE_t numInds = -1) const;
        };
};
#endif // _INC_cMesh_H