BVB Source Codes

CRYENGINE Show GeomCacheMeshManager.cpp Source code

Return Download CRYENGINE: download GeomCacheMeshManager.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. // ------------------------------------------------------------------------
  4. //  File name:   GeomCacheMeshManager.cpp
  5. //  Created:     18/1/2013 by Axel Gneiting
  6. //  Description: Manages static meshes for geometry caches
  7. // -------------------------------------------------------------------------
  8. //
  9. ////////////////////////////////////////////////////////////////////////////
  10.  
  11. #include "StdAfx.h"
  12.  
  13. #if defined(USE_GEOM_CACHES)
  14.  
  15.         #include "GeomCacheMeshManager.h"
  16.         #include "GeomCacheDecoder.h"
  17.  
  18. void CGeomCacheMeshManager::Reset()
  19. {
  20.         stl::free_container(m_meshMap);
  21. }
  22.  
  23. bool CGeomCacheMeshManager::ReadMeshStaticData(CGeomCacheStreamReader& reader, const GeomCacheFile::SMeshInfo& meshInfo, SGeomCacheStaticMeshData& staticMeshData) const
  24. {
  25.         FUNCTION_PROFILER_3DENGINE;
  26.  
  27.         if (staticMeshData.m_constantStreams & GeomCacheFile::eStream_Indices)
  28.         {
  29.                 if (!ReadMeshIndices(reader, meshInfo, staticMeshData, staticMeshData.m_indices))
  30.                 {
  31.                         return false;
  32.                 }
  33.         }
  34.  
  35.         if ((staticMeshData.m_constantStreams & GeomCacheFile::eStream_Positions) != 0)
  36.         {
  37.                 staticMeshData.m_positions.resize(staticMeshData.m_numVertices);
  38.  
  39.                 strided_pointer<Vec3> positions(&staticMeshData.m_positions[0], sizeof(Vec3));
  40.                 if (!ReadMeshPositions(reader, meshInfo, positions))
  41.                 {
  42.                         return false;
  43.                 }
  44.         }
  45.  
  46.         if ((staticMeshData.m_constantStreams & GeomCacheFile::eStream_Texcoords) != 0)
  47.         {
  48.                 staticMeshData.m_texcoords.resize(staticMeshData.m_numVertices);
  49.  
  50.                 strided_pointer<Vec2> texcoords(&staticMeshData.m_texcoords[0], sizeof(Vec2));
  51.                 if (!ReadMeshTexcoords(reader, meshInfo, texcoords))
  52.                 {
  53.                         return false;
  54.                 }
  55.         }
  56.  
  57.         if ((staticMeshData.m_constantStreams & GeomCacheFile::eStream_QTangents) != 0)
  58.         {
  59.                 staticMeshData.m_tangents.resize(staticMeshData.m_numVertices);
  60.  
  61.                 strided_pointer<SPipTangents> tangents(&staticMeshData.m_tangents[0], sizeof(SPipTangents));
  62.                 if (!ReadMeshQTangents(reader, meshInfo, tangents))
  63.                 {
  64.                         return false;
  65.                 }
  66.         }
  67.  
  68.         if ((staticMeshData.m_constantStreams & GeomCacheFile::eStream_Colors) != 0)
  69.         {
  70.                 UCol defaultColor;
  71.                 defaultColor.dcolor = 0xFFFFFFFF;
  72.                 staticMeshData.m_colors.resize(staticMeshData.m_numVertices, defaultColor);
  73.  
  74.                 strided_pointer<UCol> colors(&staticMeshData.m_colors[0], sizeof(UCol));
  75.                 if (!ReadMeshColors(reader, meshInfo, colors))
  76.                 {
  77.                         return false;
  78.                 }
  79.         }
  80.  
  81.         if (staticMeshData.m_bUsePredictor)
  82.         {
  83.                 uint32 predictorDataSize;
  84.                 if (!reader.Read(&predictorDataSize))
  85.                 {
  86.                         return false;
  87.                 }
  88.  
  89.                 staticMeshData.m_predictorData.resize(predictorDataSize);
  90.                 if (!reader.Read(&staticMeshData.m_predictorData[0], predictorDataSize))
  91.                 {
  92.                         return false;
  93.                 }
  94.         }
  95.  
  96.         return true;
  97. }
  98.  
  99. _smart_ptr<IRenderMesh> CGeomCacheMeshManager::ConstructStaticRenderMesh(CGeomCacheStreamReader& reader,
  100.                                                                          const GeomCacheFile::SMeshInfo& meshInfo, SGeomCacheStaticMeshData& staticMeshData, const char* pFileName)
  101. {
  102.         FUNCTION_PROFILER_3DENGINE;
  103.  
  104.         std::vector<char> vertexData(staticMeshData.m_numVertices * sizeof(SVF_P3F_C4B_T2F), 0);
  105.         std::vector<SPipTangents> tangentData(staticMeshData.m_numVertices);
  106.  
  107.         std::vector<vtx_idx> indices;
  108.         strided_pointer<Vec3> positions((Vec3*)(&vertexData[0] + offsetof(SVF_P3F_C4B_T2F, xyz)), sizeof(SVF_P3F_C4B_T2F));
  109.         strided_pointer<UCol> colors((UCol*)(&vertexData[0] + offsetof(SVF_P3F_C4B_T2F, color)), sizeof(SVF_P3F_C4B_T2F));
  110.         strided_pointer<Vec2> texcoords((Vec2*)(&vertexData[0] + offsetof(SVF_P3F_C4B_T2F, st)), sizeof(SVF_P3F_C4B_T2F));
  111.         strided_pointer<SPipTangents> tangents((SPipTangents*)((char*)(&tangentData[0])), sizeof(SPipTangents));
  112.  
  113.         if (!ReadMeshIndices(reader, meshInfo, staticMeshData, indices)
  114.             || !ReadMeshPositions(reader, meshInfo, positions)
  115.             || !ReadMeshTexcoords(reader, meshInfo, texcoords)
  116.             || !ReadMeshQTangents(reader, meshInfo, tangents))
  117.         {
  118.                 return NULL;
  119.         }
  120.  
  121.         if (meshInfo.m_constantStreams & GeomCacheFile::eStream_Colors)
  122.         {
  123.                 if (!ReadMeshColors(reader, meshInfo, colors))
  124.                 {
  125.                         return NULL;
  126.                 }
  127.         }
  128.         else
  129.         {
  130.                 UCol defaultColor;
  131.                 defaultColor.dcolor = 0xFFFFFFFF;
  132.  
  133.                 const uint numVertices = meshInfo.m_numVertices;
  134.                 for (uint i = 0; i < numVertices; ++i)
  135.                 {
  136.                         colors[i] = defaultColor;
  137.                 }
  138.         }
  139.  
  140.         TMeshMap::iterator findIter = m_meshMap.find(staticMeshData.m_hash);
  141.         if (findIter != m_meshMap.end())
  142.         {
  143.                 ++findIter->second.m_refCount;
  144.                 return findIter->second.m_pRenderMesh;
  145.         }
  146.  
  147.         _smart_ptr<IRenderMesh> pRenderMesh = gEnv->pRenderer ?
  148.                                               gEnv->pRenderer->CreateRenderMeshInitialized(&vertexData[0], meshInfo.m_numVertices,
  149.                                                                                            eVF_P3F_C4B_T2F, &indices[0], indices.size(), prtTriangleList, "GeomCacheConstantMesh", pFileName, eRMT_Static, 1, 0,
  150.                                                                                            NULL, NULL, false, false, &tangentData[0]) : nullptr;
  151.  
  152.         CRenderChunk chunk;
  153.         chunk.nNumVerts = meshInfo.m_numVertices;
  154.         uint32 currentIndexOffset = 0;
  155.  
  156.         if (gEnv->pRenderer)
  157.         {
  158.                 for (unsigned int i = 0; i < meshInfo.m_numMaterials; ++i)
  159.                 {
  160.                         chunk.nFirstIndexId = currentIndexOffset;
  161.                         chunk.nNumIndices = staticMeshData.m_numIndices[i];
  162.                         chunk.m_nMatID = staticMeshData.m_materialIds[i];
  163.                         pRenderMesh->SetChunk(i, chunk);
  164.                         currentIndexOffset += chunk.nNumIndices;
  165.                 }
  166.         }
  167.  
  168.         SMeshMapInfo meshMapInfo;
  169.         meshMapInfo.m_refCount = 1;
  170.         meshMapInfo.m_pRenderMesh = pRenderMesh;
  171.  
  172.         m_meshMap[staticMeshData.m_hash] = meshMapInfo;
  173.         return pRenderMesh;
  174. }
  175.  
  176. _smart_ptr<IRenderMesh> CGeomCacheMeshManager::GetStaticRenderMesh(const uint64 hash) const
  177. {
  178.         TMeshMap::const_iterator findIter = m_meshMap.find(hash);
  179.         if (findIter != m_meshMap.end())
  180.         {
  181.                 return findIter->second.m_pRenderMesh;
  182.         }
  183.  
  184.         return NULL;
  185. }
  186.  
  187. void CGeomCacheMeshManager::RemoveReference(SGeomCacheStaticMeshData& staticMeshData)
  188. {
  189.         TMeshMap::iterator findIter = m_meshMap.find(staticMeshData.m_hash);
  190.         if (findIter != m_meshMap.end())
  191.         {
  192.                 uint& refCount = findIter->second.m_refCount;
  193.                 --refCount;
  194.  
  195.                 if (refCount == 0)
  196.                 {
  197.                         m_meshMap.erase(findIter);
  198.                 }
  199.         }
  200. }
  201.  
  202. bool CGeomCacheMeshManager::ReadMeshIndices(CGeomCacheStreamReader& reader, const GeomCacheFile::SMeshInfo& meshInfo,
  203.                                             SGeomCacheStaticMeshData& staticMeshData, std::vector<vtx_idx>& indices) const
  204. {
  205.         const uint16 numMaterials = meshInfo.m_numMaterials;
  206.         staticMeshData.m_numIndices.reserve(numMaterials);
  207.  
  208.         for (unsigned int i = 0; i < numMaterials; ++i)
  209.         {
  210.                 uint32 numIndices;
  211.                 if (!reader.Read(&numIndices))
  212.                 {
  213.                         return false;
  214.                 }
  215.  
  216.                 staticMeshData.m_numIndices.push_back(numIndices);
  217.  
  218.                 const uint indicesStart = indices.size();
  219.                 indices.resize(indicesStart + numIndices);
  220.                 if (!reader.Read(&indices[indicesStart], numIndices))
  221.                 {
  222.                         return false;
  223.                 }
  224.         }
  225.  
  226.         return true;
  227. }
  228.  
  229. bool CGeomCacheMeshManager::ReadMeshPositions(CGeomCacheStreamReader& reader, const GeomCacheFile::SMeshInfo& meshInfo, strided_pointer<Vec3> positions) const
  230. {
  231.         const Vec3 aabbMin = Vec3(meshInfo.m_aabbMin[0], meshInfo.m_aabbMin[1], meshInfo.m_aabbMin[2]);
  232.         const Vec3 aabbMax = Vec3(meshInfo.m_aabbMax[0], meshInfo.m_aabbMax[1], meshInfo.m_aabbMax[2]);
  233.         const AABB meshAABB(aabbMin, aabbMax);
  234.         const Vec3 aabbSize = meshAABB.GetSize();
  235.         const Vec3 posConvertFactor = Vec3(1.0f / float((2 << (meshInfo.m_positionPrecision[0] - 1)) - 1),
  236.                                            1.0f / float((2 << (meshInfo.m_positionPrecision[1] - 1)) - 1),
  237.                                            1.0f / float((2 << (meshInfo.m_positionPrecision[2] - 1)) - 1));
  238.  
  239.         const uint numVertices = meshInfo.m_numVertices;
  240.         for (uint i = 0; i < numVertices; ++i)
  241.         {
  242.                 GeomCacheFile::Position position;
  243.  
  244.                 if (!reader.Read(&position))
  245.                 {
  246.                         return false;
  247.                 }
  248.  
  249.                 positions[i] = GeomCacheDecoder::DecodePosition(aabbMin, aabbSize, position, posConvertFactor);
  250.         }
  251.  
  252.         return true;
  253. }
  254.  
  255. bool CGeomCacheMeshManager::ReadMeshTexcoords(CGeomCacheStreamReader& reader, const GeomCacheFile::SMeshInfo& meshInfo, strided_pointer<Vec2> texcoords) const
  256. {
  257.         const uint numVertices = meshInfo.m_numVertices;
  258.         for (uint i = 0; i < numVertices; ++i)
  259.         {
  260.                 GeomCacheFile::Texcoords texcoord;
  261.  
  262.                 if (!reader.Read(&texcoord))
  263.                 {
  264.                         return false;
  265.                 }
  266.  
  267.                 texcoords[i] = GeomCacheDecoder::DecodeTexcoord(texcoord);
  268.         }
  269.  
  270.         return true;
  271. }
  272.  
  273. bool CGeomCacheMeshManager::ReadMeshQTangents(CGeomCacheStreamReader& reader, const GeomCacheFile::SMeshInfo& meshInfo, strided_pointer<SPipTangents> tangents) const
  274. {
  275.         const uint numVertices = meshInfo.m_numVertices;
  276.         for (uint i = 0; i < numVertices; ++i)
  277.         {
  278.                 GeomCacheFile::QTangent qTangent;
  279.  
  280.                 if (!reader.Read(&qTangent))
  281.                 {
  282.                         return false;
  283.                 }
  284.  
  285.                 Quat qDecodedTangent = GeomCacheDecoder::DecodeQTangent(qTangent);
  286.                 GeomCacheDecoder::ConvertToTangentAndBitangent(qDecodedTangent, tangents[i]);
  287.         }
  288.  
  289.         return true;
  290. }
  291.  
  292. bool CGeomCacheMeshManager::ReadMeshColors(CGeomCacheStreamReader& reader, const GeomCacheFile::SMeshInfo& meshInfo, strided_pointer<UCol> colors) const
  293. {
  294.         const uint numVertices = meshInfo.m_numVertices;
  295.         for (int colorIndex = 2; colorIndex >= 0; --colorIndex)
  296.         {
  297.                 for (uint i = 0; i < numVertices; ++i)
  298.                 {
  299.                         GeomCacheFile::Color color;
  300.  
  301.                         if (!reader.Read(&color))
  302.                         {
  303.                                 return false;
  304.                         }
  305.  
  306.                         colors[i].bcolor[colorIndex] = color;
  307.                 }
  308.         }
  309.  
  310.         for (uint i = 0; i < numVertices; ++i)
  311.         {
  312.                 GeomCacheFile::Color color;
  313.  
  314.                 if (!reader.Read(&color))
  315.                 {
  316.                         return false;
  317.                 }
  318.  
  319.                 colors[i].bcolor[3] = color;
  320.         }
  321.  
  322.         return true;
  323. }
  324.  
  325. #endif
  326.  
downloadGeomCacheMeshManager.cpp 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