BVB Source Codes

CRYENGINE Show GeomCacheManager.h Source code

Return Download CRYENGINE: download GeomCacheManager.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:   GeomCacheManager.h
  5. //  Created:     20/7/2012 by Axel Gneiting
  6. //  Description: Manages geometry cache instances and streaming
  7. // -------------------------------------------------------------------------
  8. //
  9. ////////////////////////////////////////////////////////////////////////////
  10.  
  11. #ifndef _GEOMCACHE_MANAGER_
  12. #define _GEOMCACHE_MANAGER_
  13.  
  14. #pragma once
  15.  
  16. #if defined(USE_GEOM_CACHES)
  17.  
  18.         #include "GeomCacheDecoder.h"
  19.         #include "GeomCacheMeshManager.h"
  20.  
  21. class CGeomCache;
  22. class CGeomCacheRenderNode;
  23.  
  24. struct SGeomCacheStreamInfo;
  25.  
  26. struct SGeomCacheBufferHandle
  27. {
  28.         SGeomCacheBufferHandle()
  29.         {
  30.                 m_pNext = NULL;
  31.                 m_startFrame = 0;
  32.                 m_endFrame = 0;
  33.                 m_bufferSize = 0;
  34.                 m_pBuffer = NULL;
  35.                 m_numJobReferences = 0;
  36.         }
  37.  
  38.         volatile int          m_numJobReferences;
  39.         uint32                m_bufferSize;
  40.         uint32                m_startFrame;
  41.         uint32                m_endFrame;
  42.         char*                 m_pBuffer;
  43.  
  44.         SGeomCacheStreamInfo* m_pStream;
  45.         CTimeValue            m_frameTime;
  46.  
  47.         // Next buffer handle for this stream or in the free list
  48.         SGeomCacheBufferHandle* m_pNext;
  49.  
  50.         CryConditionVariable    m_jobReferencesCV;
  51. };
  52.  
  53. // This handle represents a block in the read buffer
  54. struct SGeomCacheReadRequestHandle : public SGeomCacheBufferHandle, public IStreamCallback
  55. {
  56.         // IStreamCallback
  57.         virtual void StreamOnComplete(IReadStream* pStream, unsigned nError) {}
  58.         virtual void StreamAsyncOnComplete(IReadStream* pStream, unsigned nError)
  59.         {
  60.                 if (nError != 0 && nError != ERROR_USER_ABORT)
  61.                 {
  62.                         string error = "Geom cache read request failed with error: " + string(pStream->GetErrorName());
  63.                         gEnv->pLog->LogError("%s", error.c_str());
  64.                 }
  65.  
  66.                 m_state = eRRHS_FinishedRead;
  67.                 m_error = nError;
  68.  
  69.                 if (CryInterlockedDecrement(&m_numJobReferences) == 0)
  70.                 {
  71.                         m_jobReferencesCV.Notify();
  72.                 }
  73.         }
  74.  
  75.         enum EReadRequestHandleState
  76.         {
  77.                 eRRHS_Reading       = 0,
  78.                 eRRHS_FinishedRead  = 1,
  79.                 eRRHS_Decompressing = 2,
  80.                 eRRHS_Done          = 3
  81.         };
  82.  
  83.         volatile EReadRequestHandleState m_state;
  84.         volatile long                    m_error;
  85.         IReadStreamPtr                   m_pReadStream;
  86. };
  87.  
  88. struct SGeomCacheStreamInfo
  89. {
  90.         SGeomCacheStreamInfo(CGeomCacheRenderNode* pRenderNode, CGeomCache* pGeomCache, const uint numFrames)
  91.                 : m_pRenderNode(pRenderNode)
  92.                 , m_pGeomCache(pGeomCache)
  93.                 , m_numFrames(numFrames)
  94.                 , m_displayedFrameTime(-1.0f)
  95.                 , m_wantedPlaybackTime(0.0f)
  96.                 , m_wantedFloorFrame(0)
  97.                 , m_wantedCeilFrame(0)
  98.                 , m_sameFrameFillCount(0)
  99.                 , m_numFramesMissed(0)
  100.                 , m_pOldestReadRequestHandle(NULL)
  101.                 , m_pNewestReadRequestHandle(NULL)
  102.                 , m_pReadAbortListHead(NULL)
  103.                 , m_pOldestDecompressHandle(NULL)
  104.                 , m_pNewestDecompressHandle(NULL)
  105.                 , m_pDecompressAbortListHead(NULL)
  106.                 , m_bAbort(0L)
  107.                 , m_bLooping(false)
  108.         {}
  109.  
  110.         CGeomCacheRenderNode*        m_pRenderNode;
  111.         CGeomCache*                  m_pGeomCache;
  112.  
  113.         uint                         m_numFrames;
  114.  
  115.         volatile float               m_displayedFrameTime;
  116.         volatile float               m_wantedPlaybackTime;
  117.         volatile uint                m_wantedFloorFrame;
  118.         volatile uint                m_wantedCeilFrame;
  119.         volatile int                 m_sameFrameFillCount;
  120.  
  121.         uint                         m_numFramesMissed;
  122.  
  123.         SGeomCacheReadRequestHandle* m_pOldestReadRequestHandle;
  124.         SGeomCacheReadRequestHandle* m_pNewestReadRequestHandle;
  125.         SGeomCacheReadRequestHandle* m_pReadAbortListHead;
  126.  
  127.         SGeomCacheBufferHandle*      m_pOldestDecompressHandle;
  128.         SGeomCacheBufferHandle*      m_pNewestDecompressHandle;
  129.         SGeomCacheBufferHandle*      m_pDecompressAbortListHead;
  130.  
  131.         volatile bool                m_bAbort;
  132.         CryCriticalSection           m_abortCS;
  133.  
  134.         bool                         m_bLooping;
  135.  
  136.         JobManager::SJobState        m_fillRenderNodeJobState;
  137.  
  138.         struct SFrameData
  139.         {
  140.                 bool m_bDecompressJobLaunched;
  141.  
  142.                 // For each frame we initialize a counter to the number of jobs
  143.                 // that need to complete before the frame can be decoded.
  144.                 //
  145.                 // Each index frame has exactly one dependent job (inflate)
  146.                 // The first B frame after an index frame has three dependencies (inflate + previous and last index frame)
  147.                 // All other B frames have only two dependencies (inflate + previous B frame)
  148.                 int m_decodeDependencyCounter;
  149.  
  150.                 // Pointer to decompress handle for this frame.
  151.                 SGeomCacheBufferHandle* m_pDecompressHandle;
  152.         };
  153.  
  154.         // Array with data for each frame
  155.         std::vector<SFrameData> m_frameData;
  156. };
  157.  
  158. struct SDecodeFrameJobData
  159. {
  160.         uint                  m_frameIndex;
  161.         const CGeomCache*     m_pGeomCache;
  162.         SGeomCacheStreamInfo* m_pStreamInfo;
  163. };
  164.  
  165. class CGeomCacheManager : public Cry3DEngineBase
  166. {
  167. public:
  168.         CGeomCacheManager();
  169.         ~CGeomCacheManager();
  170.  
  171.         // Called during level unload to free all resource references
  172.         void        Reset();
  173.  
  174.         CGeomCache* LoadGeomCache(const char* szFileName);
  175.         void        DeleteGeomCache(CGeomCache* pGeomCache);
  176.  
  177.         void        StreamingUpdate();
  178.  
  179.         void        RegisterForStreaming(CGeomCacheRenderNode* pRenderNode);
  180.         void        UnRegisterForStreaming(CGeomCacheRenderNode* pRenderNode, bool bWaitForJobs);
  181.  
  182.         float       GetPrecachedTime(const IGeomCacheRenderNode* pRenderNode);
  183.  
  184.         #ifndef _RELEASE
  185.         void DrawDebugInfo();
  186.         void ResetDebugInfo() { m_numMissedFrames = 0; m_numStreamAborts = 0; m_numFailedAllocs = 0; }
  187.         #endif
  188.  
  189.         void DecompressFrame_JobEntry(SGeomCacheStreamInfo* pStreamInfo, const uint blockIndex,
  190.                                       SGeomCacheBufferHandle* pDecompressHandle, SGeomCacheReadRequestHandle* pReadRequestHandle);
  191.  
  192.         void                   FillRenderNodeAsync_JobEntry(SGeomCacheStreamInfo* pStreamInfo);
  193.  
  194.         void                   DecodeIFrame_JobEntry(SDecodeFrameJobData jobState);
  195.         void                   DecodeBFrame_JobEntry(SDecodeFrameJobData jobState);
  196.  
  197.         CGeomCacheMeshManager& GetMeshManager() { return m_meshManager; }
  198.  
  199.         void                   StopCacheStreamsAndWait(CGeomCache* pGeomCache);
  200.  
  201.         CGeomCache*            FindGeomCacheByFilename(const char* filename);
  202.  
  203.         // For changing the buffer size on runtime. This will do a blocking wait on all active streams,
  204.         // so it should only be called when we are sure that no caches are playing (e.g. on level load)
  205.         void ChangeBufferSize(const uint newSizeInMiB);
  206.  
  207. private:
  208.         static void                                          OnChangeBufferSize(ICVar* pCVar);
  209.  
  210.         void                                                 ReinitializeStreamFrameData(SGeomCacheStreamInfo& streamInfo, uint startFrame, uint endFrame);
  211.  
  212.         void                                                 UnloadGeomCaches();
  213.  
  214.         bool                                                 IssueDiskReadRequest(SGeomCacheStreamInfo& pStreamInfo);
  215.  
  216.         void                                                 LaunchStreamingJobs(const uint numStreams, const CTimeValue currentFrameTime);
  217.         void                                                 LaunchDecompressJobs(SGeomCacheStreamInfo* pStreamInfo, const CTimeValue currentFrameTime);
  218.         void                                                 LaunchDecodeJob(SDecodeFrameJobData jobState);
  219.  
  220.         template<class TBufferHandleType> TBufferHandleType* NewBufferHandle(const uint32 size, SGeomCacheStreamInfo& streamInfo);
  221.         SGeomCacheReadRequestHandle*                         NewReadRequestHandle(const uint32 size, SGeomCacheStreamInfo& streamInfo);
  222.  
  223.         void                                                 RetireHandles(SGeomCacheStreamInfo& streamInfo);
  224.         void                                                 RetireOldestReadRequestHandle(SGeomCacheStreamInfo& streamInfo);
  225.         void                                                 RetireOldestDecompressHandle(SGeomCacheStreamInfo& streamInfo);
  226.         void                                                 RetireDecompressHandle(SGeomCacheStreamInfo& streamInfo, SGeomCacheBufferHandle* pHandle);
  227.         template<class TBufferHandleType> void               RetireBufferHandle(TBufferHandleType* pHandle);
  228.  
  229.         void                                                 RetireRemovedStreams();
  230.         void                                                 ValidateStream(SGeomCacheStreamInfo& streamInfo);
  231.         void                                                 AbortStream(SGeomCacheStreamInfo& streamInfo);
  232.         void                                                 AbortStreamAndWait(SGeomCacheStreamInfo& streamInfo);
  233.         void                                                 RetireAbortedHandles(SGeomCacheStreamInfo& streamInfo);
  234.  
  235.         SGeomCacheBufferHandle*                              GetFrameDecompressHandle(SGeomCacheStreamInfo* pStreamInfo, const uint frameIndex);
  236.         SGeomCacheFrameHeader*                               GetFrameDecompressHeader(SGeomCacheStreamInfo* pStreamInfo, const uint frameIndex);
  237.         char*                                                GetFrameDecompressData(SGeomCacheStreamInfo* pStreamInfo, const uint frameIndex);
  238.         int*                                                 GetDependencyCounter(SGeomCacheStreamInfo* pStreamInfo, const uint frameIndex);
  239.  
  240.         void*               m_pPoolBaseAddress;
  241.         IGeneralMemoryHeap* m_pPool;
  242.         size_t              m_poolSize;
  243.  
  244.         uint                m_lastRequestStream;
  245.  
  246.         uint                m_numMissedFrames;
  247.         uint                m_numStreamAborts;
  248.         uint                m_numErrorAborts;
  249.         uint                m_numDecompressStreamAborts;
  250.         uint                m_numReadStreamAborts;
  251.         uint                m_numFailedAllocs;
  252.  
  253.         typedef std::vector<SGeomCacheStreamInfo*>::iterator TStreamInfosIter;
  254.         std::vector<SGeomCacheStreamInfo*> m_streamInfos;
  255.         std::vector<SGeomCacheStreamInfo*> m_streamInfosAbortList;
  256.  
  257.         typedef std::map<string, CGeomCache*, stl::less_stricmp<string>> TGeomCacheMap;
  258.         TGeomCacheMap         m_nameToGeomCacheMap;
  259.  
  260.         CGeomCacheMeshManager m_meshManager;
  261. };
  262.  
  263. #endif
  264. #endif
  265.  
downloadGeomCacheManager.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