BVB Source Codes

CRYENGINE Show GameVolumesManager.cpp Source code

Return Download CRYENGINE: download GameVolumesManager.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "GameVolumesManager.h"
  5.  
  6. //#pragma optimize("", off)
  7. //#pragma inline_depth(0)
  8.  
  9. CGameVolumesManager::CGameVolumesManager()
  10. {
  11.  
  12. }
  13.  
  14. CGameVolumesManager::~CGameVolumesManager()
  15. {
  16.  
  17. }
  18.  
  19. IGameVolumesEdit* CGameVolumesManager::GetEditorInterface()
  20. {
  21.         return gEnv->IsEditor() ? this : NULL;
  22. }
  23.  
  24. bool CGameVolumesManager::GetVolumeInfoForEntity(EntityId entityId, IGameVolumes::VolumeInfo* pOutInfo) const
  25. {
  26.         TEntityVolumes::const_iterator volumeIt = std::find(m_volumesData.begin(), m_volumesData.end(), entityId);
  27.  
  28.         if (volumeIt != m_volumesData.end() && !(*volumeIt).vertices.empty())
  29.         {
  30.                 const EntityVolume& entityVolume = *volumeIt;
  31.  
  32.                 pOutInfo->volumeHeight = entityVolume.height;
  33.                 pOutInfo->closed = entityVolume.closed;
  34.                 pOutInfo->verticesCount = entityVolume.vertices.size();
  35.                 pOutInfo->pVertices = &entityVolume.vertices[0];
  36.  
  37.                 return true;
  38.         }
  39.  
  40.         return false;
  41. }
  42.  
  43. void CGameVolumesManager::Load(const char* fileName)
  44. {
  45.         //////////////////////////////////////////////////////////////////////////
  46.         /// Free any left data (it should be empty though...)
  47.         Reset();
  48.  
  49.         //////////////////////////////////////////////////////////////////////////
  50.         /// No need to load in editor
  51.         /// The saved entities will restore the data inside the manager
  52.         if (gEnv->IsEditor())
  53.                 return;
  54.  
  55.         CCryFile file;
  56.         if (false != file.Open(fileName, "rb"))
  57.         {
  58.                 uint32 nFileVersion = GAME_VOLUMES_FILE_VERSION;
  59.                 file.ReadType(&nFileVersion);
  60.  
  61.                 // Verify version...
  62.                 if ((nFileVersion >= 1) && (nFileVersion <= GAME_VOLUMES_FILE_VERSION))
  63.                 {
  64.                         const uint32 maxVertices = 512;
  65.                         Vec3 readVertexBuffer[maxVertices];
  66.  
  67.                         // Read volumes
  68.                         uint32 nVolumeCount = 0;
  69.                         file.ReadType(&nVolumeCount);
  70.  
  71.                         m_volumesData.resize(nVolumeCount);
  72.  
  73.                         for (uint32 i = 0; i < nVolumeCount; ++i)
  74.                         {
  75.                                 EntityVolume& volumeInfo = m_volumesData[i];
  76.  
  77.                                 uint32 nVertexCount = 0;
  78.                                 uint32 nEntityId = 0;
  79.                                 f32 fHeight = 0;
  80.                                 bool bClosed = false;
  81.  
  82.                                 file.ReadType(&nEntityId);
  83.                                 file.ReadType(&fHeight);
  84.                                 if (nFileVersion > 1)
  85.                                 {
  86.                                         file.ReadType(&bClosed);
  87.                                 }
  88.                                 file.ReadType(&nVertexCount);
  89.  
  90.                                 volumeInfo.entityId = (EntityId)nEntityId;
  91.                                 volumeInfo.height = fHeight;
  92.                                 volumeInfo.closed = bClosed;
  93.                                 volumeInfo.vertices.resize(nVertexCount);
  94.                                 if (nVertexCount > 0)
  95.                                 {
  96.                                         file.ReadType(&readVertexBuffer[0], nVertexCount);
  97.  
  98.                                         for (uint32 v = 0; v < nVertexCount; ++v)
  99.                                         {
  100.                                                 volumeInfo.vertices[v] = readVertexBuffer[v];
  101.                                         }
  102.                                 }
  103.                         }
  104.                 }
  105.                 else
  106.                 {
  107.                         GameWarning("GameVolumesManger:Load - Failed to load file '%s'. Version mis-match, try to re-export your level", fileName);
  108.                 }
  109.  
  110.                 file.Close();
  111.         }
  112. }
  113.  
  114. void CGameVolumesManager::Reset()
  115. {
  116.         stl::free_container(m_volumesData);
  117. }
  118.  
  119. void CGameVolumesManager::SetVolume(EntityId entityId, const IGameVolumes::VolumeInfo& volumeInfo)
  120. {
  121.         bool inserted = false;
  122.  
  123.         TEntityVolumes::iterator volumeIt = std::find(m_volumesData.begin(), m_volumesData.end(), entityId);
  124.         if (volumeIt == m_volumesData.end())
  125.         {
  126.                 m_volumesData.push_back(EntityVolume());
  127.                 inserted = true;
  128.         }
  129.  
  130.         EntityVolume& entityVolume = inserted ? m_volumesData.back() : *volumeIt;
  131.         entityVolume.entityId = entityId;
  132.         entityVolume.height = volumeInfo.volumeHeight;
  133.         entityVolume.closed = volumeInfo.closed;
  134.         entityVolume.vertices.resize(volumeInfo.verticesCount);
  135.         for (uint32 i = 0; i < volumeInfo.verticesCount; ++i)
  136.         {
  137.                 entityVolume.vertices[i] = volumeInfo.pVertices[i];
  138.         }
  139. }
  140.  
  141. void CGameVolumesManager::DestroyVolume(EntityId entityId)
  142. {
  143.         stl::find_and_erase(m_volumesData, entityId);
  144. }
  145.  
  146. void CGameVolumesManager::RegisterEntityClass(const char* className)
  147. {
  148.         IEntityClass* pClass = gEnv->pEntitySystem->GetClassRegistry()->FindClass(className);
  149.         if (pClass)
  150.         {
  151.                 stl::push_back_unique(m_classes, pClass);
  152.         }
  153. }
  154.  
  155. size_t CGameVolumesManager::GetVolumeClassesCount() const
  156. {
  157.         return m_classes.size();
  158. }
  159.  
  160. const char* CGameVolumesManager::GetVolumeClass(size_t index) const
  161. {
  162.         if (index < m_classes.size())
  163.         {
  164.                 return m_classes[index]->GetName();
  165.         }
  166.  
  167.         return NULL;
  168. }
  169.  
  170. void CGameVolumesManager::Export(const char* fileName) const
  171. {
  172.         CCryFile file;
  173.         if (false != file.Open(fileName, "wb"))
  174.         {
  175.                 const uint32 maxVertices = 512;
  176.                 Vec3 writeVertexBuffer[maxVertices];
  177.  
  178.                 // File version
  179.                 uint32 nFileVersion = GAME_VOLUMES_FILE_VERSION;
  180.                 file.Write(&nFileVersion, sizeof(nFileVersion));
  181.  
  182.                 // Save volume info
  183.                 uint32 nVolumeCount = (uint32)m_volumesData.size();
  184.                 file.Write(&nVolumeCount, sizeof(nVolumeCount));
  185.  
  186.                 for (uint32 i = 0; i < nVolumeCount; ++i)
  187.                 {
  188.                         const EntityVolume& volumeInfo = m_volumesData[i];
  189.  
  190.                         CRY_ASSERT(volumeInfo.vertices.size() < maxVertices);
  191.  
  192.                         uint32 nVertexCount = min((uint32)volumeInfo.vertices.size(), maxVertices);
  193.                         uint32 nEntityId = volumeInfo.entityId;
  194.                         f32 fHeight = volumeInfo.height;
  195.                         bool bClosed = volumeInfo.closed;
  196.  
  197.                         file.Write(&nEntityId, sizeof(nEntityId));
  198.                         file.Write(&fHeight, sizeof(fHeight));
  199.                         if (nFileVersion > 1)
  200.                         {
  201.                                 file.Write(&bClosed, sizeof(bClosed));
  202.                         }
  203.                         file.Write(&nVertexCount, sizeof(nVertexCount));
  204.  
  205.                         if (nVertexCount > 0)
  206.                         {
  207.                                 for (uint32 v = 0; v < nVertexCount; ++v)
  208.                                 {
  209.                                         writeVertexBuffer[v] = volumeInfo.vertices[v];
  210.                                 }
  211.                                 file.Write(&writeVertexBuffer[0], sizeof(writeVertexBuffer[0]) * nVertexCount);
  212.                         }
  213.                 }
  214.  
  215.                 file.Close();
  216.         }
  217. }
  218.  
downloadGameVolumesManager.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