BVB Source Codes

CRYENGINE Show SegmentNode.cpp Source code

Return Download CRYENGINE: download SegmentNode.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:   SegmentNode.cpp
  5. //  Version:     v1.00
  6. //  Created:     18/04/2012 by Allen Chen
  7. //  Compilers:   Visual Studio.NET
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #include "StdAfx.h"
  15. #include "SegmentNode.h"
  16. #include "SegmentedWorld.h"
  17. #include <CrySystem/ITimer.h>
  18. #include <CryAISystem/INavigationSystem.h>
  19.  
  20. #define MAX_MS_TO_STREAM 8.0f
  21.  
  22. CSegmentNode::CSegmentNode(CSegmentedWorld* pParent, int wx, int wy, int lx, int ly)
  23.         : m_pSW(pParent),
  24.         m_wx(wx),
  25.         m_wy(wy),
  26.         m_lx(lx),
  27.         m_ly(ly),
  28.         m_nSID(-1),
  29.         m_inited(false),
  30.         m_status(ESEG_IDLE),
  31.         m_streamingStatus(ESSS_Streaming_TerrainData)
  32. {
  33. }
  34.  
  35. CSegmentNode::~CSegmentNode()
  36. {
  37.         Delete();
  38.  
  39.         m_pStreamTerrain = 0;
  40.         m_pStreamVisArea = 0;
  41.         m_pFileDataBlock = 0;
  42. }
  43.  
  44. bool CSegmentNode::Init()
  45. {
  46.         assert(m_pSW);
  47.  
  48.         if (m_inited)
  49.                 return true;
  50.  
  51.         string segLevelPath = string().Format("seg\\seg%d_%d\\", m_wx, m_wy);
  52.         static const char* gameFolder = gEnv->pConsole->GetCVar("sys_game_folder")->GetString();
  53.         m_segGamePath = string().Format("%s\\levels\\%s\\%s", gameFolder, m_pSW->s_levelName.c_str(), segLevelPath.c_str());
  54.  
  55.         m_segPackName = string().Format("%s\\seg.pak", m_segGamePath.c_str());
  56.         if (!gEnv->pCryPak->OpenPack(m_segPackName))
  57.                 return false;
  58.  
  59.         float size = (float)m_pSW->GetSegmentSizeInMeters();
  60.         Vec3 vSize(size, size, size);
  61. #if USE_RELATIVE_COORD
  62.         m_nSID = gEnv->p3DEngine->GetITerrain()->CreateSegment(vSize, m_pSW->GridToWorldPosition(m_lx, m_ly), segLevelPath);
  63. #else
  64.         m_nSID = gEnv->p3DEngine->GetITerrain()->CreateSegment(vSize, m_pSW->GridToWorldPosition(m_wx, m_wy), segLevelPath);
  65. #endif
  66.         gEnv->p3DEngine->GetIVisAreaManager()->CreateSegment(m_nSID);
  67.         gEnv->p3DEngine->LoadTerrainSurfacesFromXML(m_pSW->s_levelSurfaceTypes, false, m_nSID);
  68.  
  69.         m_inited = true;
  70.  
  71.         return m_inited;
  72. }
  73.  
  74. void CSegmentNode::Delete()
  75. {
  76.         //for(int i = 0; i < m_globalEntities.size(); ++i)
  77.         //{
  78.         //      IEntity *pEntity = m_globalEntities[i];
  79.         //      assert(gEnv->pEntitySystem->GetEntity(pEntity->GetId()));
  80.         //      pEntity->Invisible(true);
  81.         //}
  82.         //m_globalEntities.clear();
  83.  
  84.         for (int j = 0; j < m_localEntities.size(); ++j)
  85.         {
  86.                 IEntity* pEntity = m_localEntities[j];
  87.                 assert(gEnv->pEntitySystem->GetEntity(pEntity->GetId()));
  88.                 if (pEntity)
  89.                 {
  90.                         pEntity->ClearFlags(ENTITY_FLAG_UNREMOVABLE);
  91.                         pEntity->ResetKeepAliveCounter();
  92.                         gEnv->pEntitySystem->RemoveEntity(pEntity->GetId(), true);
  93.                 }
  94.         }
  95.         m_localEntities.clear();
  96.  
  97.         gEnv->p3DEngine->GetIVisAreaManager()->DeleteSegment(m_nSID, false);
  98.         gEnv->p3DEngine->GetITerrain()->DeleteSegment(m_nSID, false);
  99.  
  100.         gEnv->pCryPak->ClosePack(m_segPackName);
  101. }
  102.  
  103. bool CSegmentNode::LoadTerrain(void* pData, int nDataSize, float maxMs)
  104. {
  105.         if (StreamingFinished())
  106.                 return true;
  107.  
  108.         const Vec3& vSegmentOrigin = gEnv->p3DEngine->GetITerrain()->GetSegmentOrigin(m_nSID);
  109.  
  110.         if (pData == 0)
  111.         {
  112.                 string compiledDataPath = m_segGamePath + COMPILED_HEIGHT_MAP_FILE_NAME;
  113.                 CCryFile fData;
  114.                 if (!fData.Open(compiledDataPath, "rb"))
  115.                 {
  116.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CSegmentedWorld::LoadTerrainSegment: failed to open file: %s", compiledDataPath.c_str());
  117.                         return false;
  118.                 }
  119.  
  120.                 int size = (int)fData.GetLength();
  121.                 if (!size)
  122.                 {
  123.                         fData.Close();
  124.                         return false;
  125.                 }
  126.  
  127.                 byte* compiledData = new byte[size];
  128.                 fData.ReadRaw(compiledData, size);
  129.  
  130.                 // Always stream completely here
  131.                 while (gEnv->p3DEngine->GetITerrain()->StreamCompiledData(compiledData, size, m_nSID, vSegmentOrigin))
  132.                         ;
  133.  
  134.                 delete[] compiledData;
  135.                 fData.Close();
  136.  
  137.                 return true;
  138.         }
  139.         else
  140.         {
  141.                 bool stillStreaming = false;
  142.  
  143.                 CTimeValue startTime, endTime;
  144.                 startTime = gEnv->pTimer->GetAsyncTime();
  145.                 do
  146.                 {
  147.                         stillStreaming = gEnv->p3DEngine->GetITerrain()->StreamCompiledData((byte*)pData, nDataSize, m_nSID, vSegmentOrigin);
  148.                         endTime = gEnv->pTimer->GetAsyncTime();
  149.                 }
  150.                 while (stillStreaming && (endTime - startTime).GetMilliSeconds() < maxMs);
  151.  
  152.                 return !stillStreaming;
  153.         }
  154. }
  155.  
  156. bool CSegmentNode::LoadVisArea(void* pData, int nDataSize, float maxMs)
  157. {
  158.         if (StreamingFinished())
  159.                 return true;
  160.  
  161.         // should be moved to a single step
  162.         std::vector<IStatObj*>* pStatObjTable = NULL;
  163.         std::vector<IMaterial*>* pMatTable = NULL;
  164.         std::vector<IStatInstGroup*>* pStatInstGroupTable = NULL;
  165.         gEnv->p3DEngine->GetITerrain()->GetTables(pStatObjTable, pMatTable, pStatInstGroupTable, m_nSID);
  166.  
  167.         const Vec3& vSegmentOrigin = gEnv->p3DEngine->GetITerrain()->GetSegmentOrigin(m_nSID);
  168.  
  169.         Vec2 vIndexOffset(0, 0);
  170.         string offsetFile = m_segGamePath + "offsetinfo.xml";
  171.         XmlNodeRef offsetInfo = gEnv->pSystem->LoadXmlFromFile(offsetFile);
  172.         if (offsetInfo)
  173.                 offsetInfo->getAttr("vOff", vIndexOffset);
  174.  
  175.         if (pData == 0)
  176.         {
  177.                 string compiledDataPath = m_segGamePath + COMPILED_VISAREA_MAP_FILE_NAME;
  178.                 CCryFile fData;
  179.                 if (!fData.Open(compiledDataPath, "rb"))
  180.                 {
  181.                         CryWarning(VALIDATOR_MODULE_GAME, VALIDATOR_WARNING, "CSegmentedWorld::LoadVisAreaSegment: failed to open file: %s", compiledDataPath.c_str());
  182.                         return false;
  183.                 }
  184.  
  185.                 int size = (int)fData.GetLength();
  186.                 if (!size)
  187.                 {
  188.                         fData.Close();
  189.                         return false;
  190.                 }
  191.  
  192.                 byte* compiledData = new byte[size];
  193.                 fData.ReadRaw(compiledData, size);
  194.  
  195.                 // Always stream completely here
  196.                 gEnv->p3DEngine->GetIVisAreaManager()->StreamCompiledData(compiledData, size, m_nSID, pStatObjTable, pMatTable, pStatInstGroupTable, vSegmentOrigin, vIndexOffset);
  197.  
  198.                 delete[] compiledData;
  199.                 fData.Close();
  200.  
  201.                 return true;
  202.         }
  203.         else
  204.         {
  205.                 bool stillStreaming = false;
  206.  
  207.                 CTimeValue startTime, endTime;
  208.                 startTime = gEnv->pTimer->GetAsyncTime();
  209.                 do
  210.                 {
  211.                         stillStreaming = gEnv->p3DEngine->GetIVisAreaManager()->StreamCompiledData((byte*)pData, nDataSize, m_nSID, pStatObjTable, pMatTable, pStatInstGroupTable, vSegmentOrigin, vIndexOffset);
  212.                         endTime = gEnv->pTimer->GetAsyncTime();
  213.                 }
  214.                 while (stillStreaming && (endTime - startTime).GetMilliSeconds() < maxMs);
  215.  
  216.                 return !stillStreaming;
  217.         }
  218. }
  219.  
  220. bool CSegmentNode::LoadEntities()
  221. {
  222.         if (StreamingFinished())
  223.                 return true;
  224.  
  225.         string entitiesPath = m_segGamePath + "entities.xml";
  226.         XmlNodeRef entitiesNode = gEnv->pSystem->LoadXmlFromFile(entitiesPath);
  227.  
  228.         if (!entitiesNode)
  229.                 return false;
  230.  
  231.         if (entitiesNode->getChildCount())
  232.         {
  233.                 const Vec3& vSegmentOrigin = gEnv->p3DEngine->GetITerrain()->GetSegmentOrigin(m_nSID);
  234.                 gEnv->pEntitySystem->LoadEntities(entitiesNode, true, vSegmentOrigin, &m_globalEntities, &m_localEntities);
  235.         }
  236.  
  237.         for (int i = 0; i < m_globalEntities.size(); i++)
  238.         {
  239.                 IEntity* pEntity = m_globalEntities[i];
  240.                 assert(gEnv->pEntitySystem->GetEntity(pEntity->GetId()));
  241.                 pEntity->Invisible(false);
  242.  
  243.                 // force update position for physics proxy
  244.                 if (pEntity->GetPhysics())
  245.                         pEntity->SetPos(pEntity->GetPos(), 0, true, true);
  246.         }
  247.  
  248.         return true;
  249. }
  250.  
  251. bool CSegmentNode::LoadNavigation()
  252. {
  253.         if (StreamingFinished())
  254.                 return true;
  255.  
  256.         if (gEnv->bServer || !gEnv->bMultiplayer)
  257.         {
  258.                 string navigationDataFile = m_segGamePath + "mnmnav.bai";
  259.                 INavigationSystem* pNavigationSystem = gEnv->pAISystem->GetNavigationSystem();
  260.                 if (pNavigationSystem)
  261.                         pNavigationSystem->ReadFromFile(navigationDataFile, false);
  262.         }
  263.  
  264.         return true;
  265. }
  266.  
  267. //
  268. // Load areas(AIPaths, ...) for this segment.
  269. bool CSegmentNode::LoadAreas()
  270. {
  271.         if (StreamingFinished())
  272.                 return true;
  273.  
  274.         if (gEnv->bServer || !gEnv->bMultiplayer)
  275.         {
  276.                 string areasDataFilePath = m_segGamePath + "areas.bai";
  277.                 const Vec3& vSegmentOrigin = gEnv->p3DEngine->GetITerrain()->GetSegmentOrigin(m_nSID);
  278. #ifdef SEG_WORLD
  279.                 gEnv->pAISystem->ReadAreasFromFile(areasDataFilePath, vSegmentOrigin);
  280. #else
  281.                 gEnv->pAISystem->ReadAreasFromFile(areasDataFilePath);
  282. #endif
  283.         }
  284.  
  285.         return true;
  286. }
  287.  
  288. bool CSegmentNode::ForceLoad(unsigned int flags)
  289. {
  290.         if (StreamingFinished())
  291.                 return true;
  292.  
  293.         if (!Init())
  294.         {
  295.                 m_streamingStatus = ESSS_Warning;
  296.                 return false;
  297.         }
  298.  
  299.         bool result = true;
  300.  
  301.         if (flags & ISegmentsManager::slfTerrain)
  302.                 result &= LoadTerrain(0, 0, FLT_MAX);
  303.         if (flags & ISegmentsManager::slfVisArea)
  304.                 result &= LoadVisArea(0, 0, FLT_MAX);
  305.         if (flags & ISegmentsManager::slfEntity)
  306.                 result &= LoadEntities();
  307.         if (flags & ISegmentsManager::slfNavigation)
  308.         {
  309.                 result &= LoadNavigation();
  310.                 result &= LoadAreas();
  311.         }
  312.  
  313.         m_streamingStatus = result ? ESSS_Loaded : ESSS_Warning;
  314.  
  315.         return result;
  316. }
  317.  
  318. void CSegmentNode::Stream()
  319. {
  320.         switch (m_streamingStatus)
  321.         {
  322.         case ESSS_Streaming_TerrainData:
  323.                 {
  324.                         if (m_pStreamTerrain == 0)
  325.                         {
  326.                                 // start streaming terrain.dat
  327.                                 string compiledDataPath = m_segGamePath + COMPILED_HEIGHT_MAP_FILE_NAME;
  328.                                 m_pStreamTerrain = gEnv->pSystem->GetStreamEngine()->StartRead(eStreamTaskTypeGeometry, compiledDataPath, this);
  329.                         }
  330.                         else if (m_pStreamTerrain->IsError())
  331.                         {
  332.                                 // nothing to do here
  333.                                 m_streamingStatus = ESSS_Warning;
  334.                         }
  335.                         else if (m_pStreamTerrain->IsFinished())
  336.                         {
  337.                                 m_streamDatasLock.Lock();
  338.                                 m_pFileDataBlock = m_streamDatas[m_pStreamTerrain];
  339.                                 m_streamDatas.erase(m_pStreamTerrain);
  340.                                 m_streamDatasLock.Unlock();
  341.  
  342.                                 m_streamingStatus = ESSS_Setting_TerrainData;
  343.                         }
  344.                         break;
  345.                 }
  346.  
  347.         case ESSS_Setting_TerrainData:
  348.                 {
  349.                         if (!StreamingFinished())
  350.                         {
  351.                                 bool bTerrainLoaded = LoadTerrain(m_pFileDataBlock->pData, m_pFileDataBlock->nDataSize, MAX_MS_TO_STREAM);
  352.  
  353.                                 if (bTerrainLoaded)
  354.                                         m_streamingStatus = ESSS_Streaming_VisAreaData;
  355.                         }
  356.                         else
  357.                         {
  358.                                 m_streamingStatus = ESSS_Warning;
  359.                         }
  360.                         break;
  361.                 }
  362.  
  363.         case ESSS_Streaming_VisAreaData:
  364.                 {
  365.                         if (m_pStreamVisArea == 0)
  366.                         {
  367.                                 // start streaming indoor.dat
  368.                                 string compiledDataPath = m_segGamePath + COMPILED_VISAREA_MAP_FILE_NAME;
  369.                                 m_pStreamVisArea = gEnv->pSystem->GetStreamEngine()->StartRead(eStreamTaskTypeGeometry, compiledDataPath, this);
  370.                         }
  371.                         else if (m_pStreamVisArea->IsError())
  372.                         {
  373.                                 // nothing to do here
  374.                                 m_streamingStatus = ESSS_Warning;
  375.                         }
  376.                         else if (m_pStreamVisArea->IsFinished())
  377.                         {
  378.                                 m_streamDatasLock.Lock();
  379.                                 m_pFileDataBlock = m_streamDatas[m_pStreamVisArea];
  380.                                 m_streamDatas.erase(m_pStreamVisArea);
  381.                                 m_streamDatasLock.Unlock();
  382.  
  383.                                 m_streamingStatus = ESSS_Setting_VisAreaData;
  384.                         }
  385.                         break;
  386.                 }
  387.  
  388.         case ESSS_Setting_VisAreaData:
  389.                 {
  390.                         if (!StreamingFinished())
  391.                         {
  392.                                 bool bVisAreaLoaded = LoadVisArea(m_pFileDataBlock->pData, m_pFileDataBlock->nDataSize, MAX_MS_TO_STREAM);
  393.  
  394.                                 if (bVisAreaLoaded)
  395.                                 {
  396.                                         // CS - update connections..
  397.                                         gEnv->p3DEngine->GetIVisAreaManager()->UpdateConnections();
  398.                                         m_streamingStatus = ESSS_Streaming_EntityData;
  399.                                 }
  400.                         }
  401.                         else
  402.                         {
  403.                                 m_streamingStatus = ESSS_Warning;
  404.                         }
  405.                         break;
  406.                 }
  407.  
  408.         case ESSS_Streaming_EntityData:
  409.                 {
  410.                         if (!StreamingFinished())
  411.                         {
  412.                                 bool bEntitiesLoaded = LoadEntities();
  413.                                 LoadNavigation();
  414.                                 LoadAreas();
  415.  
  416.                                 if (bEntitiesLoaded)
  417.                                         m_streamingStatus = ESSS_Setting_EntityData;
  418.                         }
  419.                         else
  420.                         {
  421.                                 m_streamingStatus = ESSS_Warning;
  422.                         }
  423.                         break;
  424.                 }
  425.  
  426.         case ESSS_Setting_EntityData:
  427.                 {
  428.                         m_streamingStatus = ESSS_Loaded;
  429.  
  430.                         break;
  431.                 }
  432.         }
  433. }
  434.  
  435. void CSegmentNode::Update()
  436. {
  437.         switch (m_status)
  438.         {
  439.         case ESEG_INIT:
  440.                 Init();
  441.                 m_status = ESEG_STREAM;
  442.                 break;
  443.  
  444.         case ESEG_STREAM:
  445.                 if (StreamingFinished())
  446.                         m_status = ESEG_IDLE;
  447.                 else
  448.                         Stream();
  449.                 break;
  450.  
  451.         case ESEG_IDLE:
  452.         default:
  453.                 break;
  454.         }
  455. }
  456.  
  457. void CSegmentNode::SetLocalCoords(int lx, int ly)
  458. {
  459. #if USE_RELATIVE_COORD
  460.         assert(m_pSW);
  461.  
  462.         if (OffsetApplied(lx, ly))
  463.                 return;
  464.  
  465.         gEnv->p3DEngine->GetITerrain()->SetSegmentOrigin(m_nSID, m_pSW->GridToWorldPosition(lx, ly), true);
  466.  
  467.         m_lx = lx;
  468.         m_ly = ly;
  469. #endif
  470. }
  471.  
downloadSegmentNode.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