BVB Source Codes

CRYENGINE Show GeomCache.h Source code

Return Download CRYENGINE: download GeomCache.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:   GeomCache.h
  5. //  Created:     19/7/2012 by Axel Gneiting
  6. //  Description: Manages geometry cache data
  7. // -------------------------------------------------------------------------
  8. ////////////////////////////////////////////////////////////////////////////
  9.  
  10. #ifndef _GEOMCACHE_
  11. #define _GEOMCACHE_
  12.  
  13. #pragma once
  14.  
  15. #if defined(USE_GEOM_CACHES)
  16.  
  17.         #include <Cry3DEngine/IGeomCache.h>
  18.         #include <Cry3DEngine/GeomCacheFileFormat.h>
  19.  
  20. struct SGeomCacheStaticMeshData
  21. {
  22.         bool                                  m_bUsePredictor;
  23.         uint8                                 m_positionPrecision[3];
  24.         uint32                                m_numVertices;
  25.         GeomCacheFile::EStreams               m_constantStreams;
  26.         GeomCacheFile::EStreams               m_animatedStreams;
  27.         uint64                                m_hash;
  28.         AABB                                  m_aabb;
  29.         string                                m_name;
  30.  
  31.         std::vector<vtx_idx>                  m_indices;
  32.         std::vector<uint32>                   m_numIndices;
  33.         stl::aligned_vector<Vec3, 16>         m_positions;
  34.         stl::aligned_vector<UCol, 16>         m_colors;
  35.         stl::aligned_vector<Vec2, 16>         m_texcoords;
  36.         stl::aligned_vector<SPipTangents, 16> m_tangents;
  37.         std::vector<uint16>                   m_materialIds;
  38.         std::vector<uint16>                   m_predictorData;
  39. };
  40.  
  41. struct SGeomCacheStaticNodeData
  42. {
  43.         uint32                        m_meshOrGeometryIndex;
  44.         uint32                        m_numChildren;
  45.         GeomCacheFile::ENodeType      m_type;
  46.         GeomCacheFile::ETransformType m_transformType;
  47.         QuatTNS                       m_localTransform;
  48.         uint32                        m_nameHash;
  49.         string                        m_name;
  50. };
  51.  
  52. class CGeomCacheStreamReader
  53. {
  54. public:
  55.         CGeomCacheStreamReader(const char* pData, const size_t length)
  56.                 : m_pData(pData), m_length(length), m_position(0) {}
  57.  
  58.         template<class T>
  59.         bool Read(T* pDest, size_t numElements)
  60.         {
  61.                 const size_t numBytes = sizeof(T) * numElements;
  62.  
  63.                 if (m_position + numBytes > m_length)
  64.                 {
  65.                         return false;
  66.                 }
  67.  
  68.                 memcpy(pDest, &m_pData[m_position], numBytes);
  69.                 m_position += numBytes;
  70.  
  71.                 return true;
  72.         }
  73.  
  74.         template<class T>
  75.         bool Read(T* pDest)
  76.         {
  77.                 const size_t numBytes = sizeof(T);
  78.  
  79.                 if (m_position + numBytes > m_length)
  80.                 {
  81.                         return false;
  82.                 }
  83.  
  84.                 memcpy(pDest, &m_pData[m_position], numBytes);
  85.                 m_position += numBytes;
  86.  
  87.                 return true;
  88.         }
  89.  
  90. private:
  91.         const char*  m_pData;
  92.         const size_t m_length;
  93.         size_t       m_position;
  94. };
  95.  
  96. struct IGeomCacheListener
  97. {
  98. public:
  99.         virtual ~IGeomCacheListener() {}
  100.  
  101.         virtual void OnGeomCacheStaticDataLoaded() = 0;
  102.         virtual void OnGeomCacheStaticDataUnloaded() = 0;
  103. };
  104.  
  105. class CGeomCache : public IGeomCache, public IStreamCallback, public Cry3DEngineBase
  106. {
  107.         friend class CGeomCacheManager;
  108.  
  109. public:
  110.         CGeomCache(const char* pFileName);
  111.         ~CGeomCache();
  112.  
  113.         // Gets number of frames
  114.         uint GetNumFrames() const;
  115.  
  116.         // Returns true if cache plays back from memory
  117.         bool        PlaybackFromMemory() const;
  118.  
  119.         const char* GetFrameData(const uint frameIndex) const;
  120.         uint64      GetCompressedAnimationDataSize() const;
  121.  
  122.         // Gets the max extend of the geom cache through the entire animation
  123.         AABB GetAABB() const;
  124.  
  125.         // Returns frame for specific time. Rounds to ceil or floor
  126.         uint GetFloorFrameIndex(const float time) const;
  127.         uint GetCeilFrameIndex(const float time) const;
  128.  
  129.         // Frame infos
  130.         GeomCacheFile::EFrameType GetFrameType(const uint frameIndex) const;
  131.         uint64                    GetFrameOffset(const uint frameIndex) const;
  132.         uint32                    GetFrameSize(const uint frameIndex) const;
  133.         float                     GetFrameTime(const uint frameIndex) const;
  134.         uint                      GetPrevIFrame(const uint frameIndex) const;
  135.         uint                      GetNextIFrame(const uint frameIndex) const;
  136.  
  137.         // Returns true if this frame uses motion prediction and needs the last two frames
  138.         bool NeedsPrevFrames(const uint frameIndex) const;
  139.  
  140.         // Validates a frame range for reading from disk
  141.         void ValidateReadRange(const uint start, uint& end) const;
  142.  
  143.         // Get block compression format
  144.         GeomCacheFile::EBlockCompressionFormat GetBlockCompressionFormat() const;
  145.  
  146.         // Access to the mesh and node lists
  147.         const std::vector<SGeomCacheStaticMeshData>& GetStaticMeshData() const    { return m_staticMeshData; }
  148.         const std::vector<SGeomCacheStaticNodeData>& GetStaticNodeData() const    { return m_staticNodeData; }
  149.         const std::vector<phys_geometry*>&           GetPhysicsGeometries() const { return m_physicsGeometries; }
  150.  
  151.         // Listener interface for async loading
  152.         void AddListener(IGeomCacheListener* pListener);
  153.         void RemoveListener(IGeomCacheListener* pListener);
  154.  
  155.         bool IsLoaded() const { return m_bLoaded; }
  156.         void UnloadData();
  157.  
  158.         // Ref count for streams
  159.         uint GetNumStreams() const { return m_numStreams; }
  160.         void IncreaseNumStreams()  { ++m_numStreams; }
  161.         void DecreaseNumStreams()  { --m_numStreams; }
  162.  
  163.         // IGeomCache
  164.         virtual int                         AddRef();
  165.         virtual int                         Release();
  166.  
  167.         virtual bool                        IsValid() const { return m_bValid; }
  168.  
  169.         virtual void                        SetMaterial(IMaterial* pMaterial);
  170.         virtual _smart_ptr<IMaterial>       GetMaterial();
  171.         virtual const _smart_ptr<IMaterial> GetMaterial() const;
  172.  
  173.         virtual const char*                 GetFilePath() const;
  174.  
  175.         virtual float                       GetDuration() const;
  176.  
  177.         virtual IGeomCache::SStatistics     GetStatistics() const;
  178.  
  179.         virtual void                        Reload();
  180.  
  181.         // Static data streaming
  182.         void UpdateStreamableComponents(float importance, const Matrix34A& objMatrix, IRenderNode* pRenderNode, bool bFullUpdate);
  183.         void SetLastDrawMainFrameId(const uint32 id) { m_lastDrawMainFrameId = id; }
  184.  
  185.         // IStreamable
  186.         virtual void   StartStreaming(bool bFinishNow, IReadStream_AutoPtr* ppStream);
  187.         virtual int    GetStreamableContentMemoryUsage(bool bJustForDebug);
  188.         virtual void   ReleaseStreamableContent();
  189.         virtual void   GetStreamableName(string& sName);
  190.         virtual uint32 GetLastDrawMainFrameId();
  191.         virtual bool   IsUnloadable() const;
  192.  
  193.         // IStreamCallback
  194.         virtual void StreamOnComplete(IReadStream* pStream, unsigned nError);
  195.         virtual void StreamAsyncOnComplete(IReadStream* pStream, unsigned nError);
  196.  
  197. private:
  198.         struct SFrameInfo
  199.         {
  200.                 float  m_frameTime;
  201.                 uint32 m_frameType;
  202.                 uint32 m_frameSize;
  203.                 uint32 m_prevIFrame;
  204.                 uint32 m_nextIFrame;
  205.                 uint64 m_frameOffset;
  206.         };
  207.  
  208.         void Shutdown();
  209.  
  210.         bool LoadGeomCache();
  211.  
  212.         bool ReadFrameInfos(FILE* pFile, const uint32 numFrames);
  213.  
  214.         bool ReadStaticBlock(FILE* pFile, GeomCacheFile::EBlockCompressionFormat compressionFormat, std::vector<char>& compressedData);
  215.         bool DecompressStaticBlock(GeomCacheFile::EBlockCompressionFormat compressionFormat, const char* pCompressedData, std::vector<char>& decompressedData);
  216.  
  217.         bool ReadMeshesStaticData(CGeomCacheStreamReader& reader, const char* pFileName);
  218.         bool ReadMeshStaticData(CGeomCacheStreamReader& reader, const GeomCacheFile::SMeshInfo& meshInfo,
  219.                                 SGeomCacheStaticMeshData& mesh, const char* pFileName);
  220.  
  221.         bool        LoadAnimatedData(const char* pData, const size_t bufferOffset);
  222.  
  223.         bool        ReadNodesStaticDataRec(CGeomCacheStreamReader& reader);
  224.  
  225.         static bool CompareFrameTimes(const SFrameInfo& a, const SFrameInfo& b)
  226.         {
  227.                 return a.m_frameTime < b.m_frameTime;
  228.         }
  229.  
  230.         char* GetFrameData(const uint frameIndex);
  231.  
  232.         bool                  m_bValid;
  233.         bool                  m_bLoaded;
  234.  
  235.         int                   m_refCount;
  236.         _smart_ptr<IMaterial> m_pMaterial;
  237.         string                m_fileName;
  238.         string                m_lastError;
  239.  
  240.         // Static data streaming state
  241.         bool           m_bUseStreaming;
  242.         uint32         m_lastDrawMainFrameId;
  243.         IReadStreamPtr m_pStaticDataReadStream;
  244.  
  245.         // Cache block compression format
  246.         GeomCacheFile::EBlockCompressionFormat m_blockCompressionFormat;
  247.  
  248.         // Playback from memory flag
  249.         bool m_bPlaybackFromMemory;
  250.  
  251.         // Number of frames
  252.         uint m_numFrames;
  253.  
  254.         // Number of streams reading from this cache
  255.         uint m_numStreams;
  256.  
  257.         // Offset of static mesh data
  258.         uint64 m_staticMeshDataOffset;
  259.  
  260.         // Total size of animated data
  261.         uint64 m_compressedAnimationDataSize;
  262.  
  263.         // Total size of uncompressed animation data
  264.         uint64 m_totalUncompressedAnimationSize;
  265.  
  266.         // AABB of entire animation
  267.         AABB m_aabb;
  268.  
  269.         // Static data size;
  270.         GeomCacheFile::SCompressedBlockHeader m_staticDataHeader;
  271.  
  272.         // Frame infos
  273.         std::vector<SFrameInfo>               m_frameInfos;
  274.  
  275.         std::vector<SGeomCacheStaticMeshData> m_staticMeshData;
  276.         std::vector<SGeomCacheStaticNodeData> m_staticNodeData;
  277.  
  278.         // Physics
  279.         std::vector<phys_geometry*> m_physicsGeometries;
  280.  
  281.         // Holds references of static render meshes until cache object dies
  282.         std::vector<_smart_ptr<IRenderMesh>> m_staticRenderMeshes;
  283.  
  284.         // Listeners
  285.         std::vector<IGeomCacheListener*> m_listeners;
  286.  
  287.         // Animation data (memory playback)
  288.         std::vector<char> m_animationData;
  289. };
  290.  
  291. #endif
  292. #endif
  293.  
downloadGeomCache.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