BVB Source Codes

CRYENGINE Show MeshCompiler.h Source code

Return Download CRYENGINE: download MeshCompiler.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // -------------------------------------------------------------------------
  4. //  File name:   MeshCompiler.h
  5. //  Version:     v1.00
  6. //  Created:     5/11/2004 by Timur.
  7. //  Compilers:   Visual Studio.NET 2003
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #ifndef __MeshCompiler_h__
  15. #define __MeshCompiler_h__
  16. #pragma once
  17.  
  18. #include <Cry3DEngine/IIndexedMesh.h>
  19.  
  20. namespace mesh_compiler
  21. {
  22.  
  23. enum EMeshCompileFlags
  24. {
  25.         MESH_COMPILE_OPTIMIZE                    = BIT(0),
  26.         MESH_COMPILE_TANGENTS                    = BIT(1),
  27.         MESH_COMPILE_IGNORE_TANGENT_SPACE_ERRORS = BIT(2),
  28.         MESH_COMPILE_USE_CUSTOM_NORMALS          = BIT(3),
  29.         MESH_COMPILE_VALIDATE                    = BIT(4),
  30. };
  31.  
  32. //////////////////////////////////////////////////////////////////////////
  33. class CMeshCompiler
  34. {
  35. public:
  36.         CMeshCompiler();
  37.         ~CMeshCompiler();
  38.  
  39. #if CRY_PLATFORM_WINDOWS
  40.         // for flags see EMeshCompilerFlags
  41.         bool Compile(CMesh& mesh, int flags);
  42. #endif
  43.  
  44.         void SetVertexRemapping(std::vector<int>* pVertexMap)
  45.         {
  46.                 m_pVertexMap = pVertexMap;
  47.         }
  48.  
  49.         void SetIndexRemapping(std::vector<int>* pIndexMap)
  50.         {
  51.                 m_pIndexMap = pIndexMap;
  52.         }
  53.  
  54.         static inline bool IsEquivalentVec3dCheckYFirst(const Vec3& v0, const Vec3& v1, float fEpsilon)
  55.         {
  56.                 if (fabsf(v0.y - v1.y) < fEpsilon)
  57.                         if (fabsf(v0.x - v1.x) < fEpsilon)
  58.                                 if (fabsf(v0.z - v1.z) < fEpsilon)
  59.                                         return true;
  60.                 return false;
  61.         }
  62.  
  63.         static inline const Vec3& ToVec3(const Vec3& vec)    { return vec; }
  64.         static inline const Vec3  ToVec3(const Vec3f16& vec) { return vec.ToVec3(); }
  65.  
  66.         template<class T>
  67.         static inline int FindInPosBuffer_VF_P3X(const Vec3& vPosToFind, const T* pVertBuff, std::vector<int>* pHash, float fEpsilon)
  68.         {
  69.                 for (uint32 i = 0; i < pHash->size(); i++)
  70.                         if (IsEquivalentVec3dCheckYFirst(ToVec3(pVertBuff[(*pHash)[i]].xyz), vPosToFind, fEpsilon))
  71.                                 return (*pHash)[i];
  72.  
  73.                 return -1;
  74.         }
  75.  
  76.         template<class V, class I>
  77.         void WeldPos_VF_P3X(
  78.           PodArray<V>& vertices,
  79.           PodArray<SPipTangents>& tangents,
  80.           PodArray<SPipNormal>& normals,
  81.           PodArray<I>& indices,
  82.           float fEpsilon,
  83.           const AABB& boxBoundary)
  84.         {
  85.                 const int numVertices = vertices.Count();
  86.                 V* pTmpVerts = new V[numVertices];
  87.                 SPipTangents* pTmpTangents = new SPipTangents[tangents.Count()];
  88.  
  89. #if ENABLE_NORMALSTREAM_SUPPORT
  90.                 SPipNormal* pTmpNormals = NULL;
  91.                 if (normals.Count() > 0)
  92.                         pTmpNormals = new SPipNormal[normals.Count()];
  93.  
  94.                 SPipNormal emptyNormal;
  95. #endif
  96.  
  97.                 int nCurVertex = 0;
  98.                 PodArray<I> newIndices;
  99.                 std::vector<int> arrHashTable[256];
  100.                 newIndices.reserve(indices.size());
  101.                 std::vector<int>* pHash = 0;
  102.  
  103.                 float fHashElemSize = 256.0f / max(boxBoundary.max.x - boxBoundary.min.x, 0.01f);
  104.  
  105.                 for (uint32 i = 0; i < indices.size(); i++)
  106.                 {
  107.                         int v = indices[i];
  108.  
  109.                         assert(v < vertices.Count());
  110.  
  111.                         V& vPos = vertices[v];
  112.                         SPipTangents& vTang = tangents[v];
  113. #if ENABLE_NORMALSTREAM_SUPPORT
  114.                         SPipNormal& vNorm = pTmpNormals ? normals[v] : emptyNormal;
  115. #endif
  116.  
  117.                         bool bInRange(
  118.                           vPos.xyz.x > boxBoundary.min.x && vPos.xyz.y > boxBoundary.min.y && vPos.xyz.z > boxBoundary.min.z &&
  119.                           vPos.xyz.x < boxBoundary.max.x && vPos.xyz.y < boxBoundary.max.y && vPos.xyz.z < boxBoundary.max.z);
  120.  
  121.                         int nHashValue = int((vPos.xyz.x - boxBoundary.min.x) * fHashElemSize);
  122.  
  123.                         pHash = &arrHashTable[(unsigned char)(nHashValue)];
  124.                         int nFind = FindInPosBuffer_VF_P3X(ToVec3(vPos.xyz), pTmpVerts, pHash, bInRange ? fEpsilon : 0.01f);
  125.                         if (nFind < 0)
  126.                         {
  127.                                 pHash->push_back(nCurVertex);
  128.  
  129.                                 // make sure neighbor hashes also have this vertex
  130.                                 if (bInRange && fEpsilon > 0.01f)
  131.                                 {
  132.                                         pHash = &arrHashTable[(unsigned char)(nHashValue + 1)];
  133.                                         if (FindInPosBuffer_VF_P3X(ToVec3(vPos.xyz), pTmpVerts, pHash, fEpsilon) < 0)
  134.                                                 pHash->push_back(nCurVertex);
  135.  
  136.                                         pHash = &arrHashTable[(unsigned char)(nHashValue - 1)];
  137.                                         if (FindInPosBuffer_VF_P3X(ToVec3(vPos.xyz), pTmpVerts, pHash, fEpsilon) < 0)
  138.                                                 pHash->push_back(nCurVertex);
  139.                                 }
  140.  
  141.                                 PREFAST_ASSUME(nCurVertex < numVertices);
  142.  
  143.                                 // add new vertex
  144.                                 pTmpVerts[nCurVertex] = vPos;
  145.                                 pTmpTangents[nCurVertex] = vTang;
  146. #if ENABLE_NORMALSTREAM_SUPPORT
  147.                                 if (pTmpNormals)
  148.                                         pTmpNormals[nCurVertex] = vNorm;
  149. #endif
  150.                                 newIndices.push_back(nCurVertex);
  151.                                 nCurVertex++;
  152.                         }
  153.                         else
  154.                         {
  155.                                 newIndices.push_back(nFind);
  156.                         }
  157.                 }
  158.  
  159.                 indices.Clear();
  160.                 indices.AddList(newIndices);
  161.  
  162.                 vertices.Clear();
  163.                 vertices.AddList(pTmpVerts, nCurVertex);
  164.  
  165.                 tangents.Clear();
  166.                 tangents.AddList(pTmpTangents, nCurVertex);
  167.  
  168. #if ENABLE_NORMALSTREAM_SUPPORT
  169.                 if (pTmpNormals)
  170.                 {
  171.                         normals.Clear();
  172.                         normals.AddList(pTmpNormals, nCurVertex);
  173.  
  174.                         delete[] pTmpNormals;
  175.                 }
  176. #endif
  177.  
  178.                 delete[] pTmpVerts;
  179.                 delete[] pTmpTangents;
  180.         }
  181.  
  182.         static bool CompareMeshes(const CMesh& mesh1, const CMesh& mesh2);
  183.  
  184.         const char* GetLastError() const
  185.         {
  186.                 return m_LastError;
  187.         }
  188.  
  189. private:
  190. #if CRY_PLATFORM_WINDOWS
  191.         bool        CreateIndicesAndDeleteDuplicateVertices(CMesh& mesh);
  192.         bool        StripifyMesh_Forsyth(CMesh& mesh);
  193.         static bool CheckForDegenerateFaces(const CMesh& mesh);
  194.         static void FindVertexRanges(CMesh& mesh);
  195. #endif
  196.  
  197. private:
  198.         struct SBasisFace
  199.         {
  200.                 int v[3];
  201.         };
  202.         std::vector<const SMeshFace*> m_vhash_table[MAX_SUB_MATERIALS];
  203.         std::vector<SBasisFace>       m_thash_table[MAX_SUB_MATERIALS];
  204.  
  205.         std::vector<int>*             m_pVertexMap;
  206.         std::vector<int>*             m_pIndexMap;
  207.  
  208.         string                        m_LastError;
  209. };
  210.  
  211. } // namespace mesh_compiler
  212.  
  213. #endif // __MeshCompiler_h__
  214.  
downloadMeshCompiler.h Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top