BVB Source Codes

CRYENGINE Show terrain.h Source code

Return Download CRYENGINE: download terrain.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.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 TERRAIN_H
  15. #define TERRAIN_H
  16.  
  17. #include "TerrainModifications.h"           // CTerrainModifications
  18.  
  19. // lowest level of the outdoor world
  20. #define TERRAIN_BOTTOM_LEVEL      0
  21.  
  22. #define TERRAIN_BASE_TEXTURES_NUM 2
  23.  
  24. // max view distance for objects shadow is size of object multiplied by this number
  25. #define OBJ_MAX_SHADOW_VIEW_DISTANCE_RATIO 4
  26.  
  27. #define TERRAIN_NODE_TREE_DEPTH            16
  28.  
  29. #define OCEAN_IS_VERY_FAR_AWAY             1000000.f
  30.  
  31. #define ARR_TEX_OFFSETS_SIZE_DET_MAT       16
  32.  
  33. enum { nHMCacheSize = 64 };
  34.  
  35. class CTerrainUpdateDispatcher;
  36.  
  37. // Heightmap data
  38. class CHeightMap : public Cry3DEngineBase
  39. {
  40. public:
  41.         // Access to heightmap data
  42.         float                GetZSafe(int x, int y, int nSID);
  43.         float                GetZ(int x, int y, int nSID, bool bUpdatePos = false) const;
  44.         void                 SetZ(const int x, const int y, float fHeight, int nSID);
  45.         float                GetZfromUnits(uint32 nX_units, uint32 nY_units, int nSID) const;
  46.         void                 SetZfromUnits(uint32 nX_units, uint32 nY_units, float fHeight, int nSID);
  47.         float                GetZMaxFromUnits(uint32 nX0_units, uint32 nY0_units, uint32 nX1_units, uint32 nY1_units, int nSID) const;
  48.         uint8                GetSurfTypefromUnits(uint32 nX_units, uint32 nY_units, int nSID) const;
  49.         static float         GetHeightFromUnits_Callback(int ix, int iy);
  50.         static unsigned char GetSurfaceTypeFromUnits_Callback(int ix, int iy);
  51.  
  52.         uint8                GetSurfaceTypeID(int x, int y, int nSID) const;
  53.         float                GetZApr(float x1, float y1, int nSID) const;
  54.         float                GetZMax(float x0, float y0, float x1, float y1, int nSID) const;
  55.         bool                 GetHole(int x, int y, int nSID) const;
  56.         bool                 IntersectWithHeightMap(Vec3 vStartPoint, Vec3 vStopPoint, float fDist, int nMaxTestsToScip, int nSID);
  57.         bool                 IsMeshQuadFlipped(const int x, const int y, const int nUnitSize, const int nSID) const;
  58.  
  59. #ifdef SUPP_HMAP_OCCL
  60.         bool Intersect(Vec3 vStartPoint, Vec3 vStopPoint, float fDist, int nMaxTestsToScip, Vec3& vLastVisPoint, int nSID);
  61.         bool IsBoxOccluded
  62.         (
  63.           const AABB& objBox,
  64.           float fDistance,
  65.           bool bTerrainNode,
  66.           OcclusionTestClient* const __restrict pOcclTestVars,
  67.           int nSID,
  68.           const SRenderingPassInfo& passInfo
  69.         );
  70. #endif
  71.         // Exact test.
  72.         struct SRayTrace
  73.         {
  74.                 float      fInterp;
  75.                 Vec3       vHit;
  76.                 Vec3       vNorm;
  77.                 IMaterial* pMaterial;
  78.  
  79.                 SRayTrace() : fInterp(0), vHit(0, 0, 0), vNorm(0, 0, 1), pMaterial(0) {}
  80.                 SRayTrace(float fT, Vec3 const& vH, Vec3 const& vN, IMaterial* pM)
  81.                         : fInterp(fT), vHit(vH), vNorm(vN), pMaterial(pM)
  82.                 {}
  83.         };
  84.         bool RayTrace(Vec3 const& vStart, Vec3 const& vEnd, SRayTrace* prt, int nSID);
  85.  
  86.         CHeightMap()
  87.         {
  88.                 m_nUnitsToSectorBitShift = m_nBitShift = 0;
  89.                 m_fHeightmapZRatio = 0;
  90.                 m_bHeightMapModified = 0;
  91.                 ResetHeightMapCache();
  92.         }
  93.  
  94.         void ResetHeightMapCache()
  95.         {
  96.                 memset(m_arrCacheHeight, 0, sizeof(m_arrCacheHeight));
  97.                 assert(sizeof(m_arrCacheHeight[0]) == 8);
  98.                 memset(m_arrCacheSurfType, 0, sizeof(m_arrCacheSurfType));
  99.                 assert(sizeof(m_arrCacheSurfType[0]) == 8);
  100.         }
  101.  
  102.         int   m_nBitShift;
  103.         int   m_nUnitsToSectorBitShift;
  104.         int   m_bHeightMapModified;
  105.         float m_fHeightmapZRatio;
  106.  
  107. protected:
  108.  
  109.         //protected: passes some internal data to avoid repetitive member loading
  110.         bool IsPointUnderGround(CTerrain* const __restrict pTerrain,
  111.                                 int nUnitsToSectorBitShift,
  112.                                 uint32 nX_units,
  113.                                 uint32 nY_units,
  114.                                 float fTestZ, int nSID);
  115.  
  116.         inline bool IsPointUnderGround(uint32 nX_units, uint32 nY_units, float fTestZ, int nSID)
  117.         {
  118.                 CTerrain* const __restrict pTerrain = Cry3DEngineBase::GetTerrain();
  119.                 return IsPointUnderGround(pTerrain, m_nUnitsToSectorBitShift, nX_units, nY_units, fTestZ, nSID);
  120.         }
  121.  
  122.         struct SCachedHeight
  123.         {
  124.                 SCachedHeight() { x = y = 0; fHeight = 0; }
  125.                 uint16 x, y;
  126.                 float  fHeight;
  127.         };
  128.  
  129.         struct SCachedSurfType
  130.         {
  131.                 SCachedSurfType() { x = y = surfType = 0; }
  132.                 uint16 x, y;
  133.                 uint32 surfType;
  134.         };
  135.  
  136.         static CRY_ALIGN(128) SCachedHeight m_arrCacheHeight[nHMCacheSize * nHMCacheSize];
  137.         static CRY_ALIGN(128) SCachedSurfType m_arrCacheSurfType[nHMCacheSize * nHMCacheSize];
  138. };
  139.  
  140. struct SSurfaceType
  141. {
  142.         SSurfaceType()
  143.         { memset(this, 0, sizeof(SSurfaceType)); ucThisSurfaceTypeId = 255; }
  144.  
  145.         bool       IsMaterial3D() { return pLayerMat && pLayerMat->GetSubMtlCount() == 3; }
  146.  
  147.         bool       HasMaterial()  { return pLayerMat != NULL; }
  148.  
  149.         IMaterial* GetMaterialOfProjection(uint8 ucProjAxis)
  150.         {
  151.                 if (pLayerMat)
  152.                 {
  153.                         if (pLayerMat->GetSubMtlCount() == 3)
  154.                         {
  155.                                 return pLayerMat->GetSubMtl(ucProjAxis - 'X');
  156.                         }
  157.                         else if (ucProjAxis == ucDefProjAxis)
  158.                                 return pLayerMat;
  159.  
  160.                         //assert(!"SSurfaceType::GetMaterialOfProjection: Material not found");
  161.                 }
  162.  
  163.                 return NULL;
  164.         }
  165.  
  166.         float GetMaxMaterialDistanceOfProjection(uint8 ucProjAxis)
  167.         {
  168.                 if (ucProjAxis == 'X' || ucProjAxis == 'Y')
  169.                         return fMaxMatDistanceXY;
  170.  
  171.                 return fMaxMatDistanceZ;
  172.         }
  173.  
  174.         char                 szName[128];
  175.         _smart_ptr<CMatInfo> pLayerMat;
  176.         float                fScale;
  177.         PodArray<int>        lstnVegetationGroups;
  178.         float                fMaxMatDistanceXY;
  179.         float                fMaxMatDistanceZ;
  180.         float                arrRECustomData[4][ARR_TEX_OFFSETS_SIZE_DET_MAT];
  181.         uint8                ucDefProjAxis;
  182.         uint8                ucThisSurfaceTypeId;
  183.         float                fCustomMaxDistance;
  184. };
  185.  
  186. struct CTerrainNode;
  187.  
  188. struct CTextureCache : public Cry3DEngineBase
  189. {
  190.         PodArray<uint16> m_FreeTextures;
  191.         PodArray<uint16> m_UsedTextures;
  192.         PodArray<uint16> m_Quarantine;
  193.         ETEX_Format      m_eTexFormat;
  194.         int              m_nDim;
  195.         int              m_nPoolTexId;
  196.         int              m_nPoolDim;
  197.  
  198.         CTextureCache();
  199.         ~CTextureCache();
  200.         uint16 GetTexture(byte* pData, uint16& nSlotId);
  201.         void   UpdateTexture(byte* pData, const uint16& nSlotId);
  202.         void   ReleaseTexture(uint16& nTexId, uint16& nSlotId);
  203.         bool   Update();
  204.         void   InitPool(byte* pData, int nDim, ETEX_Format eTexFormat);
  205.         void   GetSlotRegion(RectI& region, int i);
  206.         int    GetPoolTexDim() { return m_nPoolDim * m_nDim; }
  207.         void   ResetTexturePool();
  208.         int    GetPoolSize();
  209. };
  210.  
  211. #pragma pack(push,4)
  212.  
  213. //! structure to vegetation group properties loading/saving
  214. //! do not change the size of this struct
  215. struct StatInstGroupChunk
  216. {
  217.         StatInstGroupChunk()
  218.         {
  219.                 ZeroStruct(*this);
  220.         }
  221.         char   szFileName[256];
  222.         float  fBending;
  223.         float  fSpriteDistRatio;
  224.         float  fShadowDistRatio;
  225.         float  fMaxViewDistRatio;
  226.         float  fBrightness;
  227.         int32  nRotationRangeToTerrainNormal; // applied to a vegetation object that has been realigned in the terrain's Y/X direction
  228.         float  fAlignToTerrainCoefficient;
  229.         uint32 nMaterialLayers;
  230.  
  231.         float  fDensity;
  232.         float  fElevationMax;
  233.         float  fElevationMin;
  234.         float  fSize;
  235.         float  fSizeVar;
  236.         float  fSlopeMax;
  237.         float  fSlopeMin;
  238.  
  239.         float  fStatObjRadius_NotUsed;
  240.         int    nIDPlusOne; // For backward compatibility, we need to save ID + 1
  241.  
  242.         float  fLodDistRatio;
  243.         uint32 nReserved;
  244.  
  245.         int    nFlags;
  246.         int    nMaterialId;
  247.  
  248.         //! flags similar to entity render flags
  249.         int   m_dwRndFlags;
  250.  
  251.         float fStiffness;
  252.         float fDamping;
  253.         float fVariance;
  254.         float fAirResistance;
  255.  
  256.         AUTO_STRUCT_INFO_LOCAL;
  257. };
  258.  
  259. struct SNameChunk
  260. {
  261.         SNameChunk() { memset(this, 0, sizeof(SNameChunk)); }
  262.  
  263.         char szFileName[256];
  264.  
  265.         AUTO_STRUCT_INFO_LOCAL;
  266. };
  267.  
  268. #pragma pack(pop)
  269.  
  270. enum ETerrainDataLoadStep
  271. {
  272.         eTDLS_NotStarted,
  273.         eTDLS_Initialize,
  274.         eTDLS_BuildSectorsTree,
  275.         eTDLS_SetupEntityGrid,
  276.         eTDLS_ReadTables,
  277.         eTDLS_LoadVegetationStatObjs,
  278.         eTDLS_LoadBrushStatObjs,
  279.         eTDLS_LoadMaterials,
  280.         eTDLS_LoadTerrainNodes,
  281.         eTDLS_StartLoadObjectTree,
  282.         eTDLS_LoadObjectTree,
  283.         eTDLS_FinishUp,
  284.         eTDLS_Complete,
  285.         eTDLS_Error
  286. };
  287.  
  288. struct STerrainDataLoadStatus
  289. {
  290.         STerrainDataLoadStatus()
  291.         {
  292.                 Clear();
  293.         }
  294.  
  295.         void Clear()
  296.         {
  297.                 loadingStep = eTDLS_NotStarted;
  298.                 vegetationIndex = 0;
  299.                 brushesIndex = 0;
  300.                 materialsIndex = 0;
  301.                 offset = 0;
  302.  
  303.                 lstVegetation.Clear();
  304.                 lstBrushes.Clear();
  305.                 lstMaterials.Clear();
  306.                 arrUnregisteredObjects.Clear();
  307.  
  308.                 statObjTable.clear();
  309.                 matTable.clear();
  310.         }
  311.  
  312.         ETerrainDataLoadStep         loadingStep;
  313.         PodArray<StatInstGroupChunk> lstVegetation;
  314.         int                          vegetationIndex;
  315.         PodArray<SNameChunk>         lstBrushes;
  316.         int                          brushesIndex;
  317.         PodArray<SNameChunk>         lstMaterials;
  318.         int                          materialsIndex;
  319.         std::vector<IStatObj*>       statObjTable;
  320.         std::vector<IMaterial*>      matTable;
  321.         ptrdiff_t                    offset;
  322.         PodArray<IRenderNode*>       arrUnregisteredObjects;
  323. };
  324.  
  325. struct TSegmentRect
  326. {
  327.         Rectf localRect;
  328.         int   nSID;
  329. };
  330.  
  331. // The Terrain Class
  332. class CTerrain : public ITerrain, public CHeightMap
  333. {
  334.         friend struct CTerrainNode;
  335.  
  336. public:
  337.  
  338.         CTerrain(const STerrainInfo& TerrainInfo);
  339.         ~CTerrain();
  340.  
  341.         void                    InitHeightfieldPhysics(int nSID);
  342.         void                    SetMaterialMapping(int nSID);
  343.         inline static const int GetTerrainSize()       { return m_nTerrainSize; }
  344.         inline static const int GetSectorSize()        { return m_nSectorSize; }
  345.         inline static const int GetHeightMapUnitSize() { return m_nUnitSize; }
  346.         inline static const int GetSectorsTableSize(int nSID)
  347.         {
  348. #ifdef SEG_WORLD
  349.                 CTerrain* pThis = Get3DEngine()->GetTerrain();
  350.                 AABB aabb;
  351.                 if (!pThis->GetSegmentBounds(nSID, aabb))
  352.                 {
  353.                         assert(0);
  354.                         return 0;
  355.                 }
  356.                 int i = (int) (aabb.max.x - aabb.min.x) >> (pThis->m_nBitShift + pThis->m_nUnitsToSectorBitShift);
  357.                 return i;
  358. #else
  359.                 return m_nSectorsTableSize;
  360. #endif
  361.         }
  362.         inline static const float GetInvUnitSize()  { return m_fInvUnitSize; }
  363.  
  364.         ILINE const int           GetTerrainUnits() { return m_nTerrainSizeDiv; }
  365.         ILINE void                ClampUnits(uint32& xu, uint32& yu)
  366.         {
  367.                 xu = (int)xu < 0 ? 0 : (int)xu < GetTerrainUnits() ? xu : GetTerrainUnits();//min(max((int)xu, 0), GetTerrainUnits());
  368.                 yu = (int)yu < 0 ? 0 : (int)yu < GetTerrainUnits() ? yu : GetTerrainUnits();//min(max((int)xu, 0), GetTerrainUnits());
  369.         }
  370. #ifdef SEG_WORLD
  371.         CTerrainNode* GetSecInfoUnits(int xu, int yu, int nSID)
  372. #else
  373.         ILINE CTerrainNode * GetSecInfoUnits(int xu, int yu, int nSID)
  374. #endif
  375.         {
  376. #ifdef SEG_WORLD
  377.                 nSID = WorldToSegment(xu, yu, m_nBitShift, nSID);
  378.                 if (nSID < 0)
  379.                         return 0;
  380.                 if (!m_pParentNodes[nSID])
  381.                         return 0;
  382.         #ifdef _DEBUG
  383.                 Array2d<struct CTerrainNode*>& arrTerrainNode = m_arrSecInfoPyramid[nSID][0];
  384.                 int x = xu >> m_nUnitsToSectorBitShift;
  385.                 int y = yu >> m_nUnitsToSectorBitShift;
  386.                 assert(x < arrTerrainNode.m_nSize && y < arrTerrainNode.m_nSize);
  387.         #endif
  388. #endif
  389.  
  390.                 if (m_arrSecInfoPyramid.IsEmpty() || m_arrSecInfoPyramid[nSID].IsEmpty())
  391.                         return nullptr;
  392.  
  393.                 return m_arrSecInfoPyramid[nSID][0][xu >> m_nUnitsToSectorBitShift][yu >> m_nUnitsToSectorBitShift];
  394.         }
  395.         ILINE CTerrainNode* GetSecInfoUnits(int xu, int yu, int nUnitsToSectorBitShift, int nSID)
  396.         {
  397. #ifdef SEG_WORLD
  398.                 assert(nSID >= 0);
  399. #endif
  400.                 return m_arrSecInfoPyramid[nSID][0][xu >> nUnitsToSectorBitShift][yu >> nUnitsToSectorBitShift];
  401.         }
  402.         CTerrainNode* GetSecInfo(int x, int y, int nSID)
  403.         {
  404. #ifdef SEG_WORLD
  405.                 nSID = WorldToSegment(x, y, 0, nSID);
  406.                 if (nSID < 0)
  407.                         return 0;
  408. #else
  409.                 if (x < 0 || y < 0 || x >= m_nTerrainSize || y >= m_nTerrainSize || !m_pParentNodes[nSID])
  410.                         return 0;
  411. #endif
  412.                 return GetSecInfoUnits(x >> m_nBitShift, y >> m_nBitShift, nSID);
  413.         }
  414.         CTerrainNode* GetSecInfo(const Vec3& pos)
  415.         {
  416.                 for (int nSID = 0; nSID < m_arrSecInfoPyramid.Count() && nSID < m_pParentNodes.Count(); nSID++)
  417.                 {
  418.                         if (m_pParentNodes[nSID])
  419.                                 if (Overlap::Point_AABB2D(pos, m_pParentNodes[nSID]->GetBBoxVirtual()))
  420.                                         return GetSecInfo((int)pos.x, (int)pos.y, nSID);
  421.                 }
  422.                 assert(!"Requested segment is not loaded");
  423.                 return NULL;
  424.         }
  425.         CTerrainNode* GetSecInfo(int x, int y)
  426.         {
  427.                 Vec3 vPos((float)x, (float)y, 0);
  428.                 return GetSecInfo(vPos);
  429.         }
  430.         ILINE CTerrainNode* GetSecInfo(const Vec3& pos, int nSID)
  431.         {
  432.                 return GetSecInfo((int)pos.x, (int)pos.y, nSID);
  433.         }
  434.         ILINE float GetWaterLevel()                       { return m_fOceanWaterLevel; /* ? m_fOceanWaterLevel : WATER_LEVEL_UNKNOWN;*/ }
  435.         ILINE void  SetWaterLevel(float fOceanWaterLevel) { m_fOceanWaterLevel = fOceanWaterLevel; }
  436.  
  437.         //////////////////////////////////////////////////////////////////////////
  438.         // ITerrain Implementation.
  439.         //////////////////////////////////////////////////////////////////////////
  440.  
  441.         template<class T>
  442.         bool Load_Tables_T(T*& f, int& nDataSize, std::vector<struct IStatObj*>*& pStatObjTable, std::vector<IMaterial*>*& pMatTable, bool bHotUpdate, bool bSW, EEndian eEndian);
  443.  
  444.         template<class T>
  445.         bool                 Load_T(T*& f, int& nDataSize, STerrainChunkHeader* pTerrainChunkHeader, std::vector<struct IStatObj*>** ppStatObjTable, std::vector<IMaterial*>** ppMatTable, bool bHotUpdate, SHotUpdateInfo* pExportInfo, int nSID, Vec3 vSegmentOrigin);
  446.  
  447.         virtual bool         GetCompiledData(byte* pData, int nDataSize, std::vector<struct IStatObj*>** ppStatObjTable, std::vector<IMaterial*>** ppMatTable, std::vector<struct IStatInstGroup*>** ppStatInstGroupTable, EEndian eEndian, SHotUpdateInfo* pExportInfo, int nSID, const Vec3& segmentOffset);
  448.         virtual int          GetCompiledDataSize(SHotUpdateInfo* pExportInfo, int nSID);
  449.         virtual void         GetStatObjAndMatTables(DynArray<IStatObj*>* pStatObjTable, DynArray<IMaterial*>* pMatTable, DynArray<IStatInstGroup*>* pStatInstGroupTable, uint32 nObjTypeMask, int nSID);
  450.  
  451.         virtual int          GetTablesSize(SHotUpdateInfo* pExportInfo, int nSID);
  452.         virtual void         SaveTables(byte*& pData, int& nDataSize, std::vector<struct IStatObj*>*& pStatObjTable, std::vector<IMaterial*>*& pMatTable, std::vector<struct IStatInstGroup*>*& pStatInstGroupTable, EEndian eEndian, SHotUpdateInfo* pExportInfo, int nSID);
  453.         virtual void         GetTables(std::vector<struct IStatObj*>*& pStatObjTable, std::vector<IMaterial*>*& pMatTable, std::vector<struct IStatInstGroup*>*& pStatInstGroupTable, int nSID);
  454.         virtual void         ReleaseTables(std::vector<struct IStatObj*>*& pStatObjTable, std::vector<IMaterial*>*& pMatTable, std::vector<struct IStatInstGroup*>*& pStatInstGroupTable);
  455.  
  456.         virtual IRenderNode* AddVegetationInstance(int nStaticGroupIndex, const Vec3& vPos, const float fScale, uint8 ucBright, uint8 angle, uint8 angleX, uint8 angleY, int nSID);
  457.         virtual void         SetOceanWaterLevel(float fOceanWaterLevel);
  458.  
  459.         virtual void         ReleaseInactiveSegments();
  460.         virtual int          CreateSegment(Vec3 vSegmentSize, Vec3 vSegmentOrigin = Vec3(0, 0, 0), const char* pcPath = 0);
  461.         virtual bool         SetSegmentPath(int nSID, const char* pcPath);
  462.         virtual const char*  GetSegmentPath(int nSID);
  463.         virtual bool         SetSegmentOrigin(int nSID, Vec3 vSegmentOrigin, bool callOffsetPosition = true);
  464.         virtual const Vec3& GetSegmentOrigin(int nSID) const;
  465.         virtual bool        DeleteSegment(int nSID, bool bDeleteNow);
  466.         virtual int         FindSegment(Vec3 vPt);
  467.         virtual int         FindSegment(int x, int y);
  468.         virtual int         GetMaxSegmentsCount() const;
  469.         virtual bool        GetSegmentBounds(int nSID, AABB& bbox);
  470.         virtual int         WorldToSegment(Vec3& vPt, int nSID = DEFAULT_SID);
  471.         virtual int         WorldToSegment(int& x, int& y, int nBitShift, int nSID = DEFAULT_SID);
  472.         virtual void        SplitWorldRectToSegments(const Rectf& worldRect, PodArray<TSegmentRect>& segmentRects);
  473.         virtual void        MarkAndOffsetCloneRegion(const AABB& region, const Vec3& offset);
  474.         virtual void        CloneRegion(const AABB& region, const Vec3& offset, float zRotation, const uint16* pIncludeLayers, int numIncludeLayers);
  475.         virtual void        ClearCloneSources();
  476.         virtual void        ChangeOceanMaterial(IMaterial* pMat);
  477.         //////////////////////////////////////////////////////////////////////////
  478.  
  479.         void          RemoveAllStaticObjects(int nSID);
  480.         void          ApplyForceToEnvironment(Vec3 vPos, float fRadius, float fAmountOfForce);
  481.         //      void CheckUnload();
  482.         void          CloseTerrainTextureFile(int nSID);
  483.         void          DrawVisibleSectors(const SRenderingPassInfo& passInfo);
  484.         virtual int   GetDetailTextureMaterials(IMaterial* materials[], int nSID);
  485.         void          MakeCrater(Vec3 vExploPos, float fExploRadius);
  486.         bool          RemoveObjectsInArea(Vec3 vExploPos, float fExploRadius);
  487.         float         GetDistanceToSectorWithWater() { return m_fDistanceToSectorWithWater; }
  488.         void GetMemoryUsage(class ICrySizer* pSizer) const;
  489.         void          GetObjects(PodArray<struct SRNInfo>* pLstObjects);
  490.         void          GetObjectsAround(Vec3 vPos, float fRadius, PodArray<struct SRNInfo>* pEntList, bool bSkip_ERF_NO_DECALNODE_DECALS, bool bSkipDynamicObjects);
  491.         class COcean* GetOcean() { return m_pOcean; }
  492.         Vec3          GetTerrainSurfaceNormal(Vec3 vPos, float fRange, int nSID = GetDefSID());
  493.         Vec3          GetTerrainSurfaceNormal_Int(int x, int y, int nSID);
  494.         void          GetTerrainAlignmentMatrix(const Vec3& vPos, const float amount, Matrix33& matrix33);
  495.         int           GetActiveTextureNodesCount() { return m_lstActiveTextureNodes.Count(); }
  496.         int           GetActiveProcObjNodesCount() { return m_lstActiveProcObjNodes.Count(); }
  497.         int           GetNotReadyTextureNodesCount();
  498.         void          GetTextureCachesStatus(int& nCount0, int& nCount1)
  499.         { nCount0 = m_texCache[0].GetPoolSize(); nCount1 = m_texCache[1].GetPoolSize(); }
  500.  
  501.         void CheckVis(const SRenderingPassInfo& passInfo);
  502.         int  UpdateOcean(const SRenderingPassInfo& passInfo);
  503.         int  RenderOcean(const SRenderingPassInfo& passInfo);
  504.         void UpdateNodesIncrementaly(const SRenderingPassInfo& passInfo);
  505.         void CheckNodesGeomUnload(int nSID, const SRenderingPassInfo& passInfo);
  506.         void GetStreamingStatus(int& nLoadedSectors, int& nTotalSectors);
  507.         void InitTerrainWater(IMaterial* pTerrainWaterMat, int nWaterBottomTexId);
  508.         void ResetTerrainVertBuffers(const AABB* pBox, int nSID);
  509.         void SetTerrainSectorTexture(int nTexSectorX, int nTexSectorY, unsigned int textureId, bool bMergeNotAllowed, int nSID = GetDefSID());
  510.         void SetDetailLayerProperties(int nId, float fScaleX, float fScaleY, uint8 ucProjAxis, const char* szSurfName, const PodArray<int>& lstnVegetationGroups, IMaterial* pMat, int nSID);
  511.         bool IsOceanVisible() { return m_bOceanIsVisible != 0; }
  512.         void SetTerrainElevation(int x1, int y1, int nSizeX, int nSizeY, float* pTerrainBlock, unsigned char* pSurfaceData, int nSurfOrgX, int nSurfOrgY, int nSurfSizeX, int nSurfSizeY, uint32* pResolMap, int nResolMapSizeX, int nResolMapSizeY, int nSID);
  513.         void HighlightTerrain(int x1, int y1, int x2, int y2, int nSID = GetDefSID());
  514.         bool CanPaintSurfaceType(int x, int y, int r, uint16 usGlobalSurfaceType);
  515.         void GetVisibleSectorsInAABB(PodArray<struct CTerrainNode*>& lstBoxSectors, const AABB& boxBox);
  516.         void LoadSurfaceTypesFromXML(XmlNodeRef pDoc, int nSID);
  517.         void UpdateSurfaceTypes(int nSID);
  518.         bool RenderArea(Vec3 vPos, float fRadius, _smart_ptr<IRenderMesh>& arrLightRenderMeshs, CRenderObject* pObj, IMaterial* pMaterial, const char* szComment, float* pCustomData, Plane* planes, const SRenderingPassInfo& passInfo);
  519.         void IntersectWithShadowFrustum(PodArray<IShadowCaster*>* plstResult, ShadowMapFrustum* pFrustum, int nSID, const SRenderingPassInfo& passInfo);
  520.         void IntersectWithBox(const AABB& aabbBox, PodArray<CTerrainNode*>* plstResult, int nSID);
  521.         void MarkAllSectorsAsUncompiled(int nSID);
  522.         void BuildErrorsTableForArea(float* pLodErrors, int nMaxLods, int X1, int Y1, int X2, int Y2, float* pTerrainBlock,
  523.                                      uint8* pSurfaceData, int nSurfOffsetX, int nSurfOffsetY, int nSurfSizeX, int nSurfSizeY, bool& bHasHoleEdges);
  524.  
  525.         void GetResourceMemoryUsage(ICrySizer* pSizer, const AABB& crstAABB, int nSID);
  526.         void UpdateSectorMeshes(const SRenderingPassInfo& passInfo);
  527.         void AddVisSector(CTerrainNode* newsec);
  528.  
  529.         void ReleaseHeightmapGeometryAroundSegment(int nSID);
  530.         void ResetHeightmapGeometryAroundSegment(int nSID);
  531.  
  532.         Vec3 GetSegmentOrigin(int nSID);
  533.         void GetVegetationMaterials(std::vector<IMaterial*>*& pMatTable);
  534.         void LoadVegetationData(PodArray<struct StatInstGroup>& rTable, PodArray<StatInstGroupChunk>& lstFileChunks, int i);
  535.  
  536. protected:
  537.  
  538.         PodArray<CTerrainNode*>          m_pParentNodes;
  539.         PodArray<CTerrainNode*>          m_lstSectors;
  540.  
  541.         PodArray<Vec3>                   m_arrSegmentOrigns;
  542.  
  543.         PodArray<Vec2i>                  m_arrSegmentSizeUnits;
  544.         PodArray<string>                 m_arrSegmentPaths;
  545.         PodArray<STerrainDataLoadStatus> m_arrLoadStatuses;
  546.         PodArray<int>                    m_arrDeletedSegments;
  547.  
  548.         void       BuildSectorsTree(bool bBuildErrorsTable, int nSID);
  549.         int        GetTerrainNodesAmount(int nSID);
  550.         bool       OpenTerrainTextureFile(SCommonFileHeader& hdrDiffTexHdr, STerrainTextureFileHeader& hdrDiffTexInfo, const char* szFileName, uint8*& ucpDiffTexTmpBuffer, int& nDiffTexIndexTableSize, int nSID);
  551.         ILINE bool IsRenderNodeIncluded(IRenderNode* pNode, const AABB& region, const uint16* pIncludeLayers, int numIncludeLayers);
  552.  
  553.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  554.         // Variables
  555.         ////////////////////////////////////////////////////////////////////////////////////////////////////
  556.  
  557. public:
  558.         CTerrainNode* GetParentNode(int nId) { return (nId >= 0 && nId < m_pParentNodes.Count()) ? m_pParentNodes.GetAt(nId) : NULL; }
  559.  
  560.         bool          Recompile_Modified_Incrementaly_RoadRenderNodes();
  561.  
  562.         virtual void  SerializeTerrainState(TSerialize ser);
  563.  
  564.         void          SetHeightMapMaxHeight(float fMaxHeight);
  565.  
  566.         SSurfaceType* GetSurfaceTypePtr(int x, int y, int nSID)
  567.         {
  568. #ifdef SEG_WORLD
  569.                 nSID = WorldToSegment(x, y, 0, nSID);
  570.                 if (nSID < 0)
  571.                         return NULL;
  572. #endif
  573.                 int nType = GetSurfaceTypeID(x, y, nSID);
  574.                 assert(nType >= 0 && nType < SRangeInfo::e_max_surface_types);
  575.                 return (nType < SRangeInfo::e_undefined) ? &m_SSurfaceType[nSID][nType] : NULL;
  576.         }
  577.  
  578.         SSurfaceType* GetSurfaceTypes(int nSID)           { return &m_SSurfaceType[nSID][0]; }
  579.         int           GetSurfaceTypeCount(int nSID) const { return (int) m_SSurfaceType[nSID].size(); }
  580.  
  581.         int           GetTerrainTextureNodeSizeMeters()   { return GetSectorSize(); }
  582.  
  583.         int           GetTerrainTextureNodeSizePixels(int nLayer, int nSID)
  584.         {
  585.                 assert(nLayer >= 0 && nLayer < 2);
  586.                 return m_arrBaseTexInfos[nSID].m_TerrainTextureLayer[nLayer].nSectorSizePixels;
  587.         }
  588.  
  589.         void GetMaterials(IMaterial*& pTerrainEf)
  590.         {
  591.                 pTerrainEf = m_pTerrainEf;
  592.         }
  593.  
  594.         IMaterial* GetMaterial()
  595.         {
  596.                 return m_pTerrainEf;
  597.         }
  598.  
  599.         int m_nWhiteTexId;
  600.         int m_nBlackTexId;
  601.  
  602.         PodArray<PodArray<Array2d<struct CTerrainNode*>>> m_arrSecInfoPyramid;         //[TERRAIN_NODE_TREE_DEPTH];
  603.  
  604.         float                         GetTerrainTextureMultiplier(int nSID) const { return m_arrBaseTexInfos[nSID].m_hdrDiffTexInfo.fBrMultiplier; }
  605.  
  606.         void                          ActivateNodeTexture(CTerrainNode* pNode, const SRenderingPassInfo& passInfo);
  607.         void                          ActivateNodeProcObj(CTerrainNode* pNode);
  608.         CTerrainNode*                 FindMinNodeContainingBox(const AABB& someBox, int nSID);
  609.         int                           FindMinNodesContainingBox(const AABB& someBox, PodArray<CTerrainNode*>& arrNodes);
  610.         int                           GetTerrainLightmapTexId(Vec4& vTexGenInfo, int nSID);
  611.         void GetAtlasTexId(int& nTex0, int& nTex1, int& nTex2, int nSID);
  612.  
  613.         _smart_ptr<IRenderMesh>       MakeAreaRenderMesh(const Vec3& vPos, float fRadius, IMaterial* pMat, const char* szLSourceName, Plane* planes);
  614.  
  615.         template<class T> static bool LoadDataFromFile(T* data, size_t elems, FILE*& f, int& nDataSize, EEndian eEndian, int* pSeek = 0)
  616.         {
  617.                 if (pSeek)
  618.                         *pSeek = GetPak()->FTell(f);
  619.  
  620.                 if (GetPak()->FRead(data, elems, f, eEndian) != elems)
  621.                 {
  622.                         assert(0);
  623.                         return false;
  624.                 }
  625.                 nDataSize -= sizeof(T) * elems;
  626.                 assert(nDataSize >= 0);
  627.                 return true;
  628.         }
  629.  
  630.         static bool LoadDataFromFile_Seek(size_t elems, FILE*& f, int& nDataSize, EEndian eEndian)
  631.         {
  632.                 GetPak()->FSeek(f, elems, SEEK_CUR);
  633.                 nDataSize -= elems;
  634.                 assert(nDataSize >= 0);
  635.                 return (nDataSize >= 0);
  636.         }
  637.  
  638.         template<class T> static bool LoadDataFromFile(T* data, size_t elems, uint8*& f, int& nDataSize, EEndian eEndian, int* pSeek = 0)
  639.         {
  640.                 StepDataCopy(data, f, elems, eEndian);
  641.                 nDataSize -= elems * sizeof(T);
  642.                 assert(nDataSize >= 0);
  643.                 return (nDataSize >= 0);
  644.         }
  645.  
  646.         static bool LoadDataFromFile_Seek(size_t elems, uint8*& f, int& nDataSize, EEndian eEndian)
  647.         {
  648.                 nDataSize -= elems;
  649.                 f += elems;
  650.                 assert(nDataSize >= 0);
  651.                 return true;
  652.         }
  653.  
  654.         static void LoadDataFromFile_FixAllignemt(FILE*& f, int& nDataSize)
  655.         {
  656.                 while (nDataSize & 3)
  657.                 {
  658.                         int nRes = GetPak()->FSeek(f, 1, SEEK_CUR);
  659.                         assert(nRes == 0);
  660.                         assert(nDataSize);
  661.                         nDataSize--;
  662.                 }
  663.                 assert(nDataSize >= 0);
  664.         }
  665.  
  666.         static void LoadDataFromFile_FixAllignemt(uint8*& f, int& nDataSize)
  667.         {
  668.                 while (nDataSize & 3)
  669.                 {
  670.                         assert(*f == 222);
  671.                         f++;
  672.                         assert(nDataSize);
  673.                         nDataSize--;
  674.                 }
  675.                 assert(nDataSize >= 0);
  676.         }
  677.  
  678.         int ReloadModifiedHMData(FILE* f, int nSID);
  679.  
  680. protected: // ------------------------------------------------------------------------
  681.         friend class CTerrainUpdateDispatcher;
  682.  
  683.         CTerrainModifications m_StoredModifications;                // to serialize (load/save) terrain heighmap changes and limit the modification
  684.         int                   m_nLoadedSectors;                     //
  685.         int                   m_bOceanIsVisible;                    //
  686.  
  687.         float                 m_fDistanceToSectorWithWater;         //
  688.         bool                  m_bProcVegetationInUse;
  689.  
  690.         struct SBaseTexInfo
  691.         {
  692.                 int                            m_nDiffTexIndexTableSize;
  693.                 SCommonFileHeader              m_hdrDiffTexHdr;
  694.                 STerrainTextureFileHeader      m_hdrDiffTexInfo;
  695.                 STerrainTextureLayerFileHeader m_TerrainTextureLayer[2];
  696.                 uint8*                         m_ucpDiffTexTmpBuffer;
  697.                 void                           GetMemoryUsage(ICrySizer* pSizer) const
  698.                 {
  699.                         pSizer->AddObject(m_ucpDiffTexTmpBuffer, m_TerrainTextureLayer[0].nSectorSizeBytes + m_TerrainTextureLayer[1].nSectorSizeBytes);
  700.                 }
  701.         };
  702.  
  703.         PodArray<SBaseTexInfo>           m_arrBaseTexInfos;
  704.  
  705.         _smart_ptr<IMaterial>            m_pTerrainEf;
  706.         _smart_ptr<IMaterial>            m_pImposterEf;
  707.  
  708.         float                            m_fOceanWaterLevel;
  709.  
  710.         PodArray<struct CTerrainNode*>   m_lstVisSectors;
  711.         PodArray<struct CTerrainNode*>   m_lstUpdatedSectors;
  712.  
  713.         PodArray<PodArray<SSurfaceType>> m_SSurfaceType;
  714.  
  715.         static int                       m_nUnitSize;    // in meters
  716.         static float                     m_fInvUnitSize; // in 1/meters
  717.         static int                       m_nTerrainSize; // in meters
  718.         int                              m_nTerrainSizeDiv;
  719.         static int                       m_nSectorSize; // in meters
  720. #ifndef SEG_WORLD
  721.         static int                       m_nSectorsTableSize; // sector width/height of the finest LOD level (sector count is the square of this value)
  722. #endif
  723.  
  724.         class COcean*             m_pOcean;
  725.  
  726.         PodArray<CTerrainNode*>   m_lstActiveTextureNodes;
  727.         PodArray<CTerrainNode*>   m_lstActiveProcObjNodes;
  728.  
  729.         CTextureCache m_texCache[3]; // RGB, Normal and Height
  730.  
  731.         EEndian                   m_eEndianOfTexture;
  732.  
  733.         static bool               m_bOpenTerrainTextureFileNoLog;
  734.  
  735.         CTerrainUpdateDispatcher* m_pTerrainUpdateDispatcher;
  736.  
  737. #if defined(FEATURE_SVO_GI)
  738.         PodArray<ColorB>* m_pTerrainRgbLowResSystemCopy;
  739. #endif
  740.  
  741.         _smart_ptr<IRenderMesh> m_pSharedRenderMesh;
  742.  
  743. public:
  744.         bool    SetCompiledData(byte* pData, int nDataSize, std::vector<struct IStatObj*>** ppStatObjTable, std::vector<IMaterial*>** ppMatTable, bool bHotUpdate, SHotUpdateInfo* pExportInfo, int nSID, Vec3 vSegmentOrigin);
  745.         bool    Load(FILE* f, int nDataSize, struct STerrainChunkHeader* pTerrainChunkHeader, std::vector<struct IStatObj*>** ppStatObjTable, std::vector<IMaterial*>** ppMatTable, int nSID, Vec3 vSegmentOrigin);
  746.         EEndian GetEndianOfTexture() { return m_eEndianOfTexture; }
  747.  
  748.         void    ClearVisSectors()
  749.         {
  750.                 m_lstVisSectors.Clear();
  751.         }
  752.  
  753. #if defined(FEATURE_SVO_GI)
  754.         const PodArray<ColorB>* GetTerrainRgbLowResSystemCopy() { return m_pTerrainRgbLowResSystemCopy; }
  755. #endif
  756.         virtual bool            StreamCompiledData(byte* pData, int nDataSize, int nSID, const Vec3& vSegmentOrigin);
  757.         virtual void            CancelStreamCompiledData(int nSID);
  758.  
  759. private:
  760.         void StreamStep_Initialize(STerrainDataLoadStatus& status, byte* pData, int nDataSize, int nSID, const Vec3& vSegmentOrigin);
  761.         void StreamStep_BuildSectorsTree(STerrainDataLoadStatus& status, byte* pData, int nDataSize, int nSID, const Vec3& vSegmentOrigin);
  762.         void StreamStep_SetupEntityGrid(STerrainDataLoadStatus& status, byte* pData, int nDataSize, int nSID, const Vec3& vSegmentOrigin);
  763.         void StreamStep_ReadTables(STerrainDataLoadStatus& status, byte* pData, int nDataSize, int nSID, const Vec3& vSegmentOrigin);
  764.         void StreamStep_LoadVegetationStatObjs(STerrainDataLoadStatus& status, byte* pData, int nDataSize, int nSID, const Vec3& vSegmentOrigin);
  765.         void StreamStep_LoadBrushStatObjs(STerrainDataLoadStatus& status, byte* pData, int nDataSize, int nSID, const Vec3& vSegmentOrigin);
  766.         void StreamStep_LoadMaterials(STerrainDataLoadStatus& status, byte* pData, int nDataSize, int nSID, const Vec3& vSegmentOrigin);
  767.         void StreamStep_LoadTerrainNodes(STerrainDataLoadStatus& status, byte* pData, int nDataSize, int nSID, const Vec3& vSegmentOrigin);
  768.         void StreamStep_StartLoadObjectTree(STerrainDataLoadStatus& status, byte* pData, int nDataSize, int nSID, const Vec3& vSegmentOrigin);
  769.         void StreamStep_LoadObjectTree(STerrainDataLoadStatus& status, byte* pData, int nDataSize, int nSID, const Vec3& vSegmentOrigin);
  770.         void StreamStep_FinishUp(STerrainDataLoadStatus& status, byte* pData, int nDataSize, int nSID, const Vec3& vSegmentOrigin);
  771. };
  772.  
  773. #endif // TERRAIN_H
  774.  
downloadterrain.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