BVB Source Codes

CRYENGINE Show terrain_sector.h Source code

Return Download CRYENGINE: download terrain_sector.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:   terrain_sector.h
  5. //  Version:     v1.00
  6. //  Created:     28/5/2001 by Vladimir Kajalin
  7. //  Compilers:   Visual Studio.NET
  8. //  Description:
  9. // -------------------------------------------------------------------------
  10. //  History:
  11. //
  12. ////////////////////////////////////////////////////////////////////////////
  13.  
  14. #ifndef SECINFO_H
  15. #define SECINFO_H
  16.  
  17. #define MML_NOT_SET          ((uint8) - 1)
  18.  
  19. #define ARR_TEX_OFFSETS_SIZE 4
  20.  
  21. #include "BasicArea.h"
  22. #include "Array2d.h"
  23.  
  24. enum eTexureType
  25. {
  26.         ett_Diffuse,
  27.         ett_LM
  28. };
  29.  
  30. class CUpdateTerrainTempData;
  31.  
  32. struct SSurfaceTypeInfo
  33. {
  34.         SSurfaceTypeInfo() { memset(this, 0, sizeof(SSurfaceTypeInfo)); }
  35.         struct SSurfaceType*    pSurfaceType;
  36.         _smart_ptr<IRenderMesh> arrpRM[3];
  37.  
  38.         bool HasRM() { return arrpRM[0] || arrpRM[1] || arrpRM[2]; }
  39.         int  GetIndexCount();
  40.         void DeleteRenderMeshes(IRenderer* pRend);
  41.  
  42.         void GetMemoryUsage(ICrySizer* pSizer) const { /*nothing*/ }
  43. };
  44.  
  45. struct SRangeInfo
  46. {
  47.         SRangeInfo()
  48.                 : fOffset(0.0f)
  49.                 , fRange(0.0f)
  50.                 , pHMData(nullptr)
  51.                 , nSize(0)
  52.                 , nUnitBitShift(0)
  53.                 , nModified(0)
  54.                 , pSTPalette(nullptr)
  55.                 , iOffset(0)
  56.                 , iRange(0)
  57.                 , iStep(0)
  58.         {
  59.         }
  60.  
  61.         void UpdateBitShift(int nUnitToSectorBS)
  62.         {
  63.                 const int nSecSize = 1 << nUnitToSectorBS;
  64.                 int n = nSize - 1;
  65.                 nUnitBitShift = 0;
  66.                 while (n > 0 && nSecSize > n)
  67.                 {
  68.                         nUnitBitShift++;
  69.                         n *= 2;
  70.                 }
  71.         }
  72.  
  73.         inline uint32 GetRawDataByIndex(unsigned i) const
  74.         {
  75.                 //              assert(i < nSize*nSize);
  76.                 assert(pHMData);
  77.  
  78.                 return pHMData[i];
  79.         }
  80.  
  81.         inline uint32 GetRawData(unsigned nX, unsigned nY) const
  82.         {
  83.                 assert(nX < nSize);
  84.                 assert(nY < nSize);
  85.                 assert(pHMData);
  86.  
  87.                 return GetRawDataByIndex(nX * nSize + nY);
  88.         }
  89.  
  90.         inline float RawDataToHeight(uint32 data) const
  91.         {
  92.                 return 0.05f * iOffset + (data >> 4) * iStep * 0.05f;
  93.         }
  94.  
  95.         inline float GetHeightByIndex(unsigned i) const
  96.         {
  97.                 //              assert(i < nSize*nSize);
  98.                 assert(pHMData);
  99.  
  100.                 return RawDataToHeight(pHMData[i]);
  101.         }
  102.  
  103.         inline float GetHeight(unsigned nX, unsigned nY) const
  104.         {
  105.                 assert(nX < nSize);
  106.                 assert(nY < nSize);
  107.                 assert(pHMData);
  108.  
  109.                 return GetHeightByIndex(nX * nSize + nY);
  110.         }
  111.  
  112.         inline uint32 GetSurfaceTypeByIndex(unsigned i) const
  113.         {
  114.                 //              assert(i < nSize*nSize);
  115.                 assert(pHMData);
  116.  
  117.                 return pHMData[i] & e_index_hole;
  118.         }
  119.  
  120.         inline uint32 GetSurfaceType(unsigned nX, unsigned nY) const
  121.         {
  122.                 assert(nX < nSize);
  123.                 assert(nY < nSize);
  124.                 assert(pHMData);
  125.  
  126.                 return GetSurfaceTypeByIndex(nX * nSize + nY);
  127.         }
  128.  
  129.         inline void SetDataLocal(int nX, int nY, uint16 usValue)
  130.         {
  131.                 assert(nX >= 0 && nX < (int)nSize);
  132.                 assert(nY >= 0 && nY < (int)nSize);
  133.                 assert(pHMData);
  134.                 pHMData[nX * nSize + nY] = usValue;
  135.         }
  136.  
  137.         inline uint16 GetDataUnits(int nX_units, int nY_units) const
  138.         {
  139.                 int nMask = nSize - 2;
  140.                 int nX = nX_units >> nUnitBitShift;
  141.                 int nY = nY_units >> nUnitBitShift;
  142.                 return GetRawData(nX & nMask, nY & nMask);
  143.         }
  144.  
  145.         // Finds or selects a 4-bit index in this sector (0-14) to represent the given global surface type index (0-126).
  146.         uint16 GetLocalSurfaceTypeID(uint16 usGlobalSurfaceTypeID)
  147.         {
  148.                 if (pSTPalette)
  149.                 {
  150.                         if (usGlobalSurfaceTypeID == e_undefined) return e_index_undefined;
  151.                         if (usGlobalSurfaceTypeID == e_hole) return e_index_hole;
  152.  
  153.                         // Check if a local entry has already been assigned for this global entry.
  154.                         for (uint16 i = 0; i < e_index_undefined; i++)
  155.                                 if (pSTPalette[i] == usGlobalSurfaceTypeID)
  156.                                         return i;
  157.                         // No local entry has been assigned; look for an entry that is marked as currently unused.
  158.                         for (uint16 i = 0; i < e_index_undefined; i++)
  159.                                 if (pSTPalette[i] == e_undefined)
  160.                                 {
  161.                                         pSTPalette[i] = (uchar)usGlobalSurfaceTypeID;
  162.                                         return i;
  163.                                 }
  164.                         // No local entry is marked as unused; look for one whose local ID does not actually occur in the data.
  165.                         int nUsageCounters[e_palette_size];
  166.                         memset(nUsageCounters, 0, sizeof(nUsageCounters));
  167.                         int nCount = nSize * nSize;
  168.  
  169.                         for (uint16 i = 0; i < nCount; i++) nUsageCounters[pHMData[i] & e_index_hole]++;
  170.                         for (uint16 i = 0; i < e_index_undefined; i++)
  171.                                 if (!nUsageCounters[i])
  172.                                 {
  173.                                         pSTPalette[i] = (uchar)usGlobalSurfaceTypeID;
  174.                                         return i;
  175.                                 }
  176.                         // Could not assign a local ID; mark the problem area with holes. (Should not happen, we have integrity checks.)
  177.                         return e_index_undefined;
  178.                 }
  179.                 else
  180.                 {
  181.                         // If the sector still has no palette, create one and assign local ID 0.
  182.                         pSTPalette = new uchar[e_palette_size];
  183.  
  184.                         for (int i = 0; i < e_index_hole; pSTPalette[i++] = e_undefined);
  185.  
  186.                         pSTPalette[0] = (uchar)usGlobalSurfaceTypeID;
  187.                         pSTPalette[e_index_hole] = e_hole;
  188.                         return 0;
  189.                 }
  190.         }
  191.  
  192.         float   fOffset;
  193.         float   fRange;
  194.         uint16* pHMData;
  195.  
  196.         uint16  nSize;
  197.         uint8   nUnitBitShift;
  198.         uint8   nModified;
  199.         uchar*  pSTPalette; // Maps the local surface type indices from the HM to the global ones in CTerrain
  200.  
  201.         int     iOffset;
  202.         int     iRange;
  203.         int     iStep;
  204.  
  205.         enum
  206.         {
  207.                 e_index_undefined = 14,
  208.                 e_index_hole,
  209.                 e_palette_size,
  210.  
  211.                 e_undefined = 127,
  212.                 e_hole,
  213.                 e_max_surface_types
  214.         };
  215. };
  216.  
  217. template<class T> class TPool
  218. {
  219. public:
  220.  
  221.         TPool(int nPoolSize)
  222.         {
  223.                 m_nPoolSize = nPoolSize;
  224.                 m_pPool = new T[nPoolSize];
  225.                 m_lstFree.PreAllocate(nPoolSize, 0);
  226.                 m_lstUsed.PreAllocate(nPoolSize, 0);
  227.                 for (int i = 0; i < nPoolSize; i++)
  228.                         m_lstFree.Add(&m_pPool[i]);
  229.         }
  230.  
  231.         ~TPool()
  232.         {
  233.                 delete[] m_pPool;
  234.         }
  235.  
  236.         void ReleaseObject(T* pInst)
  237.         {
  238.                 if (m_lstUsed.Delete(pInst))
  239.                         m_lstFree.Add(pInst);
  240.         }
  241.  
  242.         int GetUsedInstancesCount(int& nAll)
  243.         {
  244.                 nAll = m_nPoolSize;
  245.                 return m_lstUsed.Count();
  246.         }
  247.  
  248.         T* GetObject()
  249.         {
  250.                 T* pInst = NULL;
  251.                 if (m_lstFree.Count())
  252.                 {
  253.                         pInst = m_lstFree.Last();
  254.                         m_lstFree.DeleteLast();
  255.                         m_lstUsed.Add(pInst);
  256.                 }
  257.                 else
  258.                         assert(!"TPool::GetObject: Out of free elements error");
  259.  
  260.                 return pInst;
  261.         }
  262.  
  263.         void GetMemoryUsage(class ICrySizer* pSizer) const
  264.         {
  265.                 pSizer->AddObject(m_lstFree);
  266.                 pSizer->AddObject(m_lstUsed);
  267.  
  268.                 if (m_pPool)
  269.                         for (int i = 0; i < m_nPoolSize; i++)
  270.                                 m_pPool[i].GetMemoryUsage(pSizer);
  271.         }
  272.  
  273.         PodArray<T*> m_lstFree;
  274.         PodArray<T*> m_lstUsed;
  275.         T*           m_pPool;
  276.         int          m_nPoolSize;
  277. };
  278.  
  279. #define MAX_PROC_OBJ_CHUNKS_NUM (GetCVars()->e_ProcVegetationMaxChunksInCache * GetCVars()->e_ProcVegetationMaxCacheLevels)
  280. #define MAX_PROC_SECTORS_NUM    (GetCVars()->e_ProcVegetationMaxSectorsInCache * GetCVars()->e_ProcVegetationMaxCacheLevels)
  281.  
  282. struct SProcObjChunk : public Cry3DEngineBase
  283. {
  284.         CVegetation* m_pInstances;
  285.         int nAllocatedItems;
  286.         SProcObjChunk();
  287.         ~SProcObjChunk();
  288.         void GetMemoryUsage(class ICrySizer* pSizer) const;
  289. };
  290.  
  291. typedef TPool<SProcObjChunk> SProcObjChunkPool;
  292.  
  293. class CProcObjSector : public Cry3DEngineBase
  294. {
  295. public:
  296.         CProcObjSector() { m_nProcVegetNum = 0; m_ProcVegetChunks.PreAllocate(32); }
  297.         ~CProcObjSector();
  298.         CVegetation* AllocateProcObject(int nSID);
  299.         void         ReleaseAllObjects();
  300.         int          GetUsedInstancesCount(int& nAll) { nAll = m_ProcVegetChunks.Count(); return m_nProcVegetNum; }
  301.         void         GetMemoryUsage(ICrySizer* pSizer) const;
  302.  
  303. protected:
  304.         PodArray<SProcObjChunk*> m_ProcVegetChunks;
  305.         int                      m_nProcVegetNum;
  306. };
  307.  
  308. typedef TPool<CProcObjSector> CProcVegetPoolMan;
  309.  
  310. struct STerrainNodeLeafData
  311. {
  312.         STerrainNodeLeafData() { memset(this, 0, sizeof(*this)); }
  313.         ~STerrainNodeLeafData();
  314.         float                   m_arrTexGen[MAX_RECURSION_LEVELS][ARR_TEX_OFFSETS_SIZE];
  315.         int                     m_arrpNonBorderIdxNum[SRangeInfo::e_max_surface_types][4];
  316.         PodArray<CTerrainNode*> m_lstNeighbourSectors;
  317.         PodArray<uint8>         m_lstNeighbourLods;
  318.         _smart_ptr<IRenderMesh> m_pRenderMesh;
  319. };
  320.  
  321. enum ETextureEditingState : unsigned int
  322. {
  323.         eTES_SectorIsUnmodified = 0,
  324.         eTES_SectorIsModified_AtlasIsUpToDate,
  325.         eTES_SectorIsModified_AtlasIsDirty
  326. };
  327.  
  328. struct CTerrainNode : public Cry3DEngineBase, public IRenderNode, public IStreamCallback
  329. {
  330. public:
  331.  
  332.         // IRenderNode implementation
  333.         virtual const char*             GetName() const                         { return "TerrainNode"; }
  334.         virtual const char*             GetEntityClassName() const              { return "TerrainNodeClass"; }
  335.         virtual Vec3                    GetPos(bool bWorldOnly = true) const    { return Vec3(m_nOriginX, m_nOriginY, 0); }
  336.         virtual void                    SetBBox(const AABB& WSBBox)             {}
  337.         virtual struct IPhysicalEntity* GetPhysics() const                      { return NULL; }
  338.         virtual void                    SetPhysics(IPhysicalEntity* pPhys)      {}
  339.         virtual void                    SetMaterial(IMaterial* pMat)            {}
  340.         virtual IMaterial*              GetMaterial(Vec3* pHitPos = NULL) const { return NULL; }
  341.         virtual IMaterial*              GetMaterialOverride()                   { return NULL; }
  342.         virtual float                   GetMaxViewDist()                        { return 1000000.f; }
  343.         virtual EERType                 GetRenderNodeType()                     { return eERType_TerrainSector;  }
  344.  
  345.         friend class CTerrain;
  346.         friend class CTerrainUpdateDispatcher;
  347.  
  348.         virtual void                       Render(const SRendParams& RendParams, const SRenderingPassInfo& passInfo);
  349.         const AABB                         GetBBox() const;
  350.         virtual const AABB                 GetBBoxVirtual()                                                                                   { return GetBBox(); }
  351.         virtual void                       FillBBox(AABB& aabb);
  352.         virtual struct ICharacterInstance* GetEntityCharacter(unsigned int nSlot, Matrix34A* pMatrix = NULL, bool bReturnOnlyVisible = false) { return NULL; };
  353.  
  354.         //////////////////////////////////////////////////////////////////////////
  355.         // IStreamCallback
  356.         //////////////////////////////////////////////////////////////////////////
  357.         // streaming
  358.         virtual void StreamOnComplete(IReadStream* pStream, unsigned nError);
  359.         virtual void StreamAsyncOnComplete(IReadStream* pStream, unsigned nError);
  360.         //////////////////////////////////////////////////////////////////////////
  361.         void         StartSectorTexturesStreaming(bool bFinishNow);
  362.  
  363.         void         Init(int x1, int y1, int nNodeSize, CTerrainNode* pParent, bool bBuildErrorsTable, int nSID);
  364.         CTerrainNode() :
  365.                 m_nSID(0),
  366.                 m_nNodeTexSet(),
  367.                 m_nTexSet(),
  368.                 m_nNodeTextureOffset(-1),
  369.                 m_nNodeHMDataOffset(-1),
  370.                 m_pParent(),
  371.                 m_pLeafData(NULL),
  372.                 m_pUpdateTerrainTempData(NULL),
  373.                 m_pChilds(0),
  374.                 m_nLastTimeUsed(0),
  375.                 m_nSetLodFrameId(0),
  376.                 m_pGeomErrors(0),
  377.                 m_pProcObjPoolPtr(0),
  378.                 m_nGSMFrameId(0)
  379.         {
  380.                 memset(&m_arrfDistance, 0, sizeof(m_arrfDistance));
  381.                 m_nNodesCounter++;
  382.         }
  383.         ~CTerrainNode();
  384.         static void   ResetStaticData();
  385.         bool          CheckVis(bool bAllIN, bool bAllowRenderIntoCBuffer, const Vec3& vSegmentOrigin, const SRenderingPassInfo& passInfo);
  386.         void          SetupTexturing(bool bMakeUncompressedForEditing, const SRenderingPassInfo& passInfo);
  387.         void          RequestTextures(const SRenderingPassInfo& passInfo);
  388.         void          EnableTextureEditingMode(unsigned int textureId);
  389.         void          UpdateNodeTextureFromEditorData();
  390.         void                                    UpdateNodeNormalMapFromEditorData();
  391.         static void   SaveCompressedMipmapLevel(const void* data, size_t size, void* userData);
  392.         void          CheckNodeGeomUnload(const SRenderingPassInfo& passInfo);
  393.         IRenderMesh*  MakeSubAreaRenderMesh(const Vec3& vPos, float fRadius, IRenderMesh* pPrevRenderMesh, IMaterial* pMaterial, bool bRecalIRenderMeshconst, const char* szLSourceName);
  394.         void          SetChildsLod(int nNewGeomLOD, const SRenderingPassInfo& passInfo);
  395.         int           GetAreaLOD(const SRenderingPassInfo& passInfo);
  396.         bool          RenderNodeHeightmap(const SRenderingPassInfo& passInfo);
  397.         bool          CheckUpdateProcObjects(const SRenderingPassInfo& passInfo);
  398.         void          IntersectTerrainAABB(const AABB& aabbBox, PodArray<CTerrainNode*>& lstResult);
  399.         void          UpdateDetailLayersInfo(bool bRecursive);
  400.         void          RemoveProcObjects(bool bRecursive = false, bool bReleaseAllObjects = true);
  401.         void          IntersectWithShadowFrustum(bool bAllIn, PodArray<IShadowCaster*>* plstResult, ShadowMapFrustum* pFrustum, const float fHalfGSMBoxSize, const SRenderingPassInfo& passInfo);
  402.         void          IntersectWithBox(const AABB& aabbBox, PodArray<CTerrainNode*>* plstResult);
  403.         CTerrainNode* FindMinNodeContainingBox(const AABB& aabbBox);
  404.         bool          RenderSector(const SRenderingPassInfo& passInfo); // returns true only if the sector rendermesh is valid and does not need to be updated
  405.         CTerrainNode* GetTexuringSourceNode(int nTexMML, eTexureType eTexType);
  406.         CTerrainNode* GetReadyTexSourceNode(int nTexMML, eTexureType eTexType);
  407.         int           GetData(byte*& pData, int& nDataSize, EEndian eEndian, SHotUpdateInfo* pExportInfo);
  408.         void          CalculateTexGen(const CTerrainNode* pTextureSourceNode, float& fTexOffsetX, float& fTexOffsetY, float& fTexScale);
  409.         void          FillSectorHeightMapTextureData(Array2d<float> &arrHmData);
  410.         void          RescaleToInt();
  411.  
  412.         template<class T>
  413.         int   Load_T(T*& f, int& nDataSize, EEndian eEndian, bool bSectorPalettes, SHotUpdateInfo* pExportInfo);
  414.         int   Load(uint8*& f, int& nDataSize, EEndian eEndian, bool bSectorPalettes, SHotUpdateInfo* pExportInfo);
  415.         int   Load(FILE*& f, int& nDataSize, EEndian eEndian, bool bSectorPalettes, SHotUpdateInfo* pExportInfo);
  416.         int   ReloadModifiedHMData(FILE* f);
  417.         void  ReleaseHoleNodes();
  418.  
  419.         void  UnloadNodeTexture(bool bRecursive);
  420.         float GetSurfaceTypeAmount(Vec3 vPos, int nSurfType);
  421.         void  GetMemoryUsage(ICrySizer* pSizer) const;
  422.         void  GetResourceMemoryUsage(ICrySizer* pSizer, const AABB& cstAABB);
  423.  
  424.         void  SetLOD(const SRenderingPassInfo& passInfo);
  425.         uint8 GetTextureLOD(float fDistance, const SRenderingPassInfo& passInfo);
  426.  
  427.         void                ReleaseHeightMapGeometry(bool bRecursive = false, const AABB* pBox = NULL);
  428.         void                ResetHeightMapGeometry(bool bRecursive = false, const AABB* pBox = NULL);
  429.         int                 GetSecIndex();
  430.  
  431.         void                DrawArray(const SRenderingPassInfo& passInfo);
  432.  
  433.         void                UpdateRenderMesh(struct CStripsInfo* pArrayInfo, bool bUpdateVertices);
  434.         void                BuildVertices(int step, bool bSafetyBorder);
  435.  
  436.         int                 GetMML(int dist, int mmMin, int mmMax);
  437.  
  438.         uint32                       GetLastTimeUsed() { return m_nLastTimeUsed; }
  439.  
  440.         void                         AddIndexAliased(int _x, int _y, int _step, int nSectorSize, PodArray<CTerrainNode*>* plstNeighbourSectors, CStripsInfo* pArrayInfo, const SRenderingPassInfo& passInfo);
  441.         static void                  GenerateIndicesForAllSurfaces(IRenderMesh* pRM, bool bOnlyBorder, int arrpNonBorderIdxNum[SRangeInfo::e_max_surface_types][4], int nBorderStartIndex, SSurfaceTypeInfo* pSurfaceTypeInfos, int nSID, CUpdateTerrainTempData* pUpdateTerrainTempData = NULL);
  442.         void                         BuildIndices(CStripsInfo& si, PodArray<CTerrainNode*>* pNeighbourSectors, bool bSafetyBorder, const SRenderingPassInfo& passInfo);
  443.  
  444.         void                         BuildIndices_Wrapper(SRenderingPassInfo passInfo);
  445.         void                         BuildVertices_Wrapper();
  446.         void                         RenderSectorUpdate_Finish(const SRenderingPassInfo& passInfo);
  447.  
  448.         static void                  UpdateSurfaceRenderMeshes(const _smart_ptr<IRenderMesh> pSrcRM, struct SSurfaceType* pSurface, _smart_ptr<IRenderMesh>& pMatRM, int nProjectionId, PodArray<vtx_idx>& lstIndices, const char* szComment, bool bUpdateOnlyBorders, int nNonBorderIndicesCount, const SRenderingPassInfo& passInfo);
  449.         static void                  SetupTexGenParams(SSurfaceType* pLayer, float* pOutParams, uint8 ucProjAxis, bool bOutdoor, float fTexGenScale = 1.f);
  450.  
  451.         int                          CreateSectorTexturesFromBuffer(float * pSectorHeightMap);
  452.  
  453.         bool                         CheckUpdateDiffuseMap();
  454.         bool                         AssignTextureFileOffset(int16*& pIndices, int16& nElementsNum);
  455.         static CProcVegetPoolMan*    GetProcObjPoolMan()                                       { return m_pProcObjPoolMan; }
  456.         static SProcObjChunkPool*    GetProcObjChunkPool()                                     { return m_pProcObjChunkPool; }
  457.         static void                  SetProcObjPoolMan(CProcVegetPoolMan* pProcObjPoolMan)     { m_pProcObjPoolMan = pProcObjPoolMan; }
  458.         static void                  SetProcObjChunkPool(SProcObjChunkPool* pProcObjChunkPool) { m_pProcObjChunkPool = pProcObjChunkPool; }
  459.         void                         UpdateDistance(const SRenderingPassInfo& passInfo);
  460.         const float                  GetDistance(const SRenderingPassInfo& passInfo);
  461.         bool                         IsProcObjectsReady() { return m_bProcObjectsReady != 0; }
  462.         void                         UpdateRangeInfoShift();
  463.         int                          GetSectorSizeInHeightmapUnits() const;
  464.         void                         CheckLeafData();
  465.         inline STerrainNodeLeafData* GetLeafData() { return m_pLeafData; }
  466.         void                         OffsetPosition(const Vec3& delta);
  467.         _smart_ptr<IRenderMesh>                  GetSharedRenderMesh();
  468.         uint32                                                                                   GetMaterialsModificationId();
  469.  
  470.         //////////////////////////////////////////////////////////////////////////
  471.         // Member variables
  472.         //////////////////////////////////////////////////////////////////////////
  473. public:
  474.         IReadStreamPtr       m_pReadStream;
  475.         EFileStreamingStatus m_eTexStreamingStatus;
  476.  
  477.         CTerrainNode*        m_pChilds; // 4 childs or NULL
  478.  
  479.         // flags
  480.         uint8                m_bProcObjectsReady  : 1;
  481.         uint8                m_bMergeNotAllowed   : 1;
  482.         uint8                m_bHasHoles          : 2; // sector has holes in the ground
  483.         uint8                m_bNoOcclusion       : 1; // sector has visareas under terrain surface
  484.         uint8                m_bUpdateOnlyBorders : 1; // remember if only the border were updated
  485.  
  486. #ifndef _RELEASE
  487.         ETextureEditingState m_eTextureEditingState, m_eElevTexEditingState;
  488. #endif // _RELEASE
  489.  
  490.         uint8 // LOD's
  491.           m_cNewGeomMML, m_cCurrGeomMML,
  492.           m_cNewGeomMML_Min, m_cNewGeomMML_Max,
  493.           m_cNodeNewTexMML, m_cNodeNewTexMML_Min;
  494.         uint8  m_nTreeLevel;
  495.  
  496.         uint16 m_nOriginX, m_nOriginY; // sector origin
  497.         int    m_nLastTimeUsed;        // basically last time rendered
  498.         int    m_nSetLodFrameId;
  499.  
  500.         float* m_pGeomErrors;  // errors for each lod level
  501.  
  502. protected:
  503.  
  504.         // temp data for terrain generation
  505.         CUpdateTerrainTempData* m_pUpdateTerrainTempData;
  506.  
  507. public:
  508.  
  509.         PodArray<SSurfaceTypeInfo> m_lstSurfaceTypeInfo;
  510.  
  511.         SRangeInfo                 m_rangeInfo;
  512.  
  513.         STerrainNodeLeafData*      m_pLeafData;
  514.  
  515.         CProcObjSector*            m_pProcObjPoolPtr;
  516.  
  517.         SSectorTextureSet          m_nNodeTexSet, m_nTexSet; // texture id's
  518.  
  519.         uint16                     m_nNodeTextureLastUsedSec4;
  520.         uint16                     m_nSID;
  521.  
  522.         AABB                       m_boxHeigtmapLocal;
  523.         struct CTerrainNode*       m_pParent;
  524.         int                        m_nGSMFrameId;
  525.  
  526.         float                      m_arrfDistance[MAX_RECURSION_LEVELS];
  527.         int                        m_nNodeTextureOffset;
  528.         int                        m_nNodeHMDataOffset;
  529.         int FTell(uint8*& f);
  530.         int FTell(FILE*& f);
  531.  
  532.         static PodArray<vtx_idx>       m_arrIndices[SRangeInfo::e_max_surface_types][4];
  533.         static PodArray<SSurfaceType*> m_lstReadyTypes;
  534.         static CProcVegetPoolMan*      m_pProcObjPoolMan;
  535.         static SProcObjChunkPool*      m_pProcObjChunkPool;
  536.         static int                     m_nNodesCounter;
  537.  
  538.         OcclusionTestClient            m_occlusionTestClient;
  539. };
  540.  
  541. // Container to manager temp memory as well as running update jobs
  542. class CTerrainUpdateDispatcher : public Cry3DEngineBase
  543. {
  544. public:
  545.         CTerrainUpdateDispatcher();
  546.         ~CTerrainUpdateDispatcher();
  547.  
  548.         void QueueJob(CTerrainNode*, const SRenderingPassInfo& passInfo);
  549.         void SyncAllJobs(bool bForceAll, const SRenderingPassInfo& passInfo);
  550.         bool Contains(CTerrainNode* pNode)
  551.         { return (m_queuedJobs.Find(pNode) != -1 || m_arrRunningJobs.Find(pNode) != -1); };
  552.  
  553.         void GetMemoryUsage(ICrySizer* pSizer) const;
  554.  
  555.         void RemoveJob(CTerrainNode* pNode);
  556.  
  557. private:
  558.         bool AddJob(CTerrainNode*, bool executeAsJob, const SRenderingPassInfo& passInfo);
  559.  
  560.         static const size_t            TempPoolSize = (4U << 20);
  561.  
  562.         void*                          m_pHeapStorage;
  563.         _smart_ptr<IGeneralMemoryHeap> m_pHeap;
  564.  
  565.         PodArray<CTerrainNode*>        m_queuedJobs;
  566.         PodArray<CTerrainNode*>        m_arrRunningJobs;
  567. };
  568.  
  569. #pragma pack(push,4)
  570.  
  571. struct STerrainNodeChunk
  572. {
  573.         int16 nChunkVersion;
  574.         int16 bHasHoles;
  575.         AABB  boxHeightmap;
  576.         float fOffset;
  577.         float fRange;
  578.         int   nSize;
  579.         int   nSurfaceTypesNum;
  580.  
  581.         AUTO_STRUCT_INFO;
  582. };
  583.  
  584. #pragma pack(pop)
  585.  
  586. #include "terrain.h"
  587.  
  588. inline const AABB CTerrainNode::GetBBox() const
  589. {
  590.         const Vec3& vOrigin = GetTerrain()->m_arrSegmentOrigns[m_nSID];
  591.         return AABB(m_boxHeigtmapLocal.min + vOrigin, m_boxHeigtmapLocal.max + vOrigin);
  592. }
  593.  
  594. #endif
  595.  
downloadterrain_sector.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