BVB Source Codes

CRYENGINE Show ObjMan.h Source code

Return Download CRYENGINE: download ObjMan.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:   statobjman.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 CObjManager_H
  15. #define CObjManager_H
  16.  
  17. #include "StatObj.h"
  18. #include "../RenderDll/Common/Shadow_Renderer.h"
  19. #include "terrain_sector.h"
  20. #include <CryCore/StlUtils.h>
  21. #include <CryMemory/PoolAllocator.h>
  22. #include "CCullThread.h"
  23.  
  24. #include <map>
  25. #include <vector>
  26.  
  27. #include "ObjManCullQueue.h"
  28.  
  29. #define ENTITY_MAX_DIST_FACTOR  100
  30. #define MAX_VALID_OBJECT_VOLUME (10000000000.f)
  31. #define DEFAULT_CGF_NAME        ("EngineAssets\\Objects\\Default.cgf")
  32.  
  33. struct CStatObj;
  34. struct IIndoorBase;
  35. struct IRenderNode;
  36. struct ISystem;
  37. struct IDecalRenderNode;
  38. struct SCheckOcclusionJobData;
  39. struct SCheckOcclusionOutput;
  40.  
  41. class CVegetation;
  42.  
  43. class C3DEngine;
  44. struct IMaterial;
  45.  
  46. #define SMC_EXTEND_FRUSTUM              8
  47. #define SMC_SHADOW_FRUSTUM_TEST         16
  48.  
  49. #define OCCL_TEST_HEIGHT_MAP            1
  50. #define OCCL_TEST_CBUFFER               2
  51. #define OCCL_TEST_INDOOR_OCCLUDERS_ONLY 4
  52. #define POOL_STATOBJ_ALLOCS
  53.  
  54. //! contains stat obj instance group properties (vegetation object properties)
  55. struct StatInstGroup : public IStatInstGroup
  56. {
  57.         StatInstGroup()
  58.         {
  59.                 pStatObj = 0;
  60.                 ZeroStruct(m_arrSSpriteLightInfo);
  61.                 m_fSpriteSwitchDist = 0;
  62.         }
  63.  
  64.         CStatObj* GetStatObj()
  65.         {
  66.                 IStatObj* p = pStatObj;
  67.                 return (CStatObj*)p;
  68.         }
  69.         const CStatObj* GetStatObj() const
  70.         {
  71.                 const IStatObj* p = pStatObj;
  72.                 return (const CStatObj*)p;
  73.         }
  74.  
  75.         void  Update(struct CVars* pCVars, int nGeomDetailScreenRes);
  76.         void  GetMemoryUsage(ICrySizer* pSizer) const {}
  77.         float GetAlignToTerrainAmount() const;
  78.  
  79.         SVegetationSpriteLightInfo m_arrSSpriteLightInfo[FAR_TEX_COUNT];
  80.  
  81.         float                      m_fSpriteSwitchDist;
  82. };
  83.  
  84. struct SExportedBrushMaterial
  85. {
  86.         int  size;
  87.         char material[64];
  88. };
  89.  
  90. struct SRenderMeshInfoOutput
  91. {
  92.         SRenderMeshInfoOutput() { memset(this, 0, sizeof(*this)); }
  93.         _smart_ptr<IRenderMesh> pMesh;
  94.         IMaterial*              pMat;
  95. };
  96.  
  97. // Inplace object for IStreamable* to cache StreamableMemoryContentSize
  98. struct SStreamAbleObject
  99. {
  100.         explicit SStreamAbleObject(IStreamable* pObj, bool bUpdateMemUsage = true) : m_pObj(pObj), fCurImportance(-1000.f)
  101.         {
  102.                 if (pObj && bUpdateMemUsage)
  103.                         m_nStreamableContentMemoryUsage = pObj->GetStreamableContentMemoryUsage();
  104.                 else
  105.                         m_nStreamableContentMemoryUsage = 0;
  106.         }
  107.  
  108.         bool operator==(const SStreamAbleObject& rOther) const
  109.         {
  110.                 return m_pObj == rOther.m_pObj;
  111.         }
  112.  
  113.         int          GetStreamableContentMemoryUsage() const { return m_nStreamableContentMemoryUsage; }
  114.         IStreamable* GetStreamAbleObject() const             { return m_pObj; }
  115.         uint32       GetLastDrawMainFrameId() const
  116.         {
  117.                 return m_pObj->GetLastDrawMainFrameId();
  118.         }
  119.         float        fCurImportance;
  120. private:
  121.         IStreamable* m_pObj;
  122.         int          m_nStreamableContentMemoryUsage;
  123.  
  124. };
  125.  
  126. struct SObjManPrecacheCamera
  127. {
  128.         SObjManPrecacheCamera()
  129.                 : vPosition(ZERO)
  130.                 , vDirection(ZERO)
  131.                 , bbox(AABB::RESET)
  132.                 , fImportanceFactor(1.0f)
  133.         {
  134.         }
  135.  
  136.         Vec3  vPosition;
  137.         Vec3  vDirection;
  138.         AABB  bbox;
  139.         float fImportanceFactor;
  140. };
  141.  
  142. struct SObjManPrecachePoint
  143. {
  144.         SObjManPrecachePoint()
  145.                 : nId(0)
  146.         {
  147.         }
  148.  
  149.         int        nId;
  150.         CTimeValue expireTime;
  151. };
  152.  
  153. struct SObjManRenderDebugInfo
  154. {
  155.         SObjManRenderDebugInfo()
  156.                 : pEnt(nullptr)
  157.                 , fEntDistance(0.0f)
  158.         {}
  159.  
  160.         SObjManRenderDebugInfo(IRenderNode* _pEnt, float _fEntDistance)
  161.                 : pEnt(_pEnt)
  162.                 , fEntDistance(_fEntDistance)
  163.         {}
  164.  
  165.         IRenderNode* pEnt;
  166.         float        fEntDistance;
  167. };
  168.  
  169. //////////////////////////////////////////////////////////////////////////
  170. class CObjManager : public Cry3DEngineBase
  171. {
  172. public:
  173.         enum
  174.         {
  175.                 MaxPrecachePoints = 4,
  176.         };
  177.  
  178. public:
  179.         CObjManager();
  180.         ~CObjManager();
  181.  
  182.         void      PreloadLevelObjects();
  183.         void      UnloadObjects(bool bDeleteAll);
  184.         void      UnloadVegetationModels(bool bDeleteAll);
  185.         void      UnloadFarObjects();
  186.  
  187.         void      DrawFarObjects(float fMaxViewDist, const SRenderingPassInfo& passInfo);
  188.         void      GenerateFarObjects(float fMaxViewDist, const SRenderingPassInfo& passInfo);
  189.         void      RenderFarObjects(const SRenderingPassInfo& passInfo);
  190.         void      CheckTextureReadyFlag();
  191.  
  192.         CStatObj* AllocateStatObj();
  193.         void      FreeStatObj(CStatObj* pObj);
  194.  
  195.         template<class T>
  196.         static int GetItemId(std::vector<T*>* pArray, T* pItem, bool bAssertIfNotFound = true)
  197.         {
  198.                 for (uint32 i = 0, end = pArray->size(); i < end; ++i)
  199.                         if ((*pArray)[i] == pItem)
  200.                                 return i;
  201.  
  202.                 //    if(bAssertIfNotFound)
  203.                 //    assert(!"Item not found");
  204.  
  205.                 return -1;
  206.         }
  207.  
  208.         template<class T>
  209.         static T* GetItemPtr(std::vector<T*>* pArray, int nId)
  210.         {
  211.                 if (nId < 0)
  212.                         return NULL;
  213.  
  214.                 assert(nId < (int)pArray->size());
  215.  
  216.                 if (nId < (int)pArray->size())
  217.                         return (*pArray)[nId];
  218.                 else
  219.                         return NULL;
  220.         }
  221.  
  222.         CStatObj* LoadStatObj(const char* szFileName, const char* szGeomName = NULL, IStatObj::SSubObject** ppSubObject = NULL, bool bUseStreaming = true, unsigned long nLoadingFlags = 0,
  223.                               const void* m_pData = 0, int m_nDataSize = 0, const char* szBlockName = NULL);
  224.         void      GetLoadedStatObjArray(IStatObj** pObjectsArray, int& nCount);
  225.  
  226.         // Deletes object.
  227.         // Only should be called by Release function of CStatObj.
  228.         bool InternalDeleteObject(CStatObj* pObject);
  229.  
  230.         PodArray<PodArray<StatInstGroup>> m_lstStaticTypes;
  231.  
  232.         uint64 GetShadowFrustumsList(PodArray<CDLight*>* pAffectingLights, const AABB& aabbReceiver,
  233.                                      float fObjDistance, uint32 nDLightMask, bool bIncludeNearFrustums,
  234.                                      const SRenderingPassInfo& passInfo);
  235.  
  236.         CThreadSafeRendererContainer<SVegetationSpriteInfo> m_arrVegetationSprites[MAX_RECURSION_LEVELS][nThreadsNum];
  237.  
  238.         void MakeShadowCastersList(CVisArea* pReceiverArea, const AABB& aabbReceiver,
  239.                                    int dwAllowedTypes, int32 nRenderNodeFlags, Vec3 vLightPos, CDLight* pLight, ShadowMapFrustum* pFr, PodArray<struct SPlaneObject>* pShadowHull, const SRenderingPassInfo& passInfo);
  240.  
  241.         int MakeStaticShadowCastersList(IRenderNode* pIgnoreNode, ShadowMapFrustum* pFrustum, const PodArray<struct SPlaneObject>* pShadowHull, int renderNodeExcludeFlags, int nMaxNodes, const SRenderingPassInfo& passInfo);
  242.  
  243.         // decal pre-caching
  244.         typedef std::vector<IDecalRenderNode*> DecalsToPrecreate;
  245.         DecalsToPrecreate m_decalsToPrecreate;
  246.  
  247.         void                    PrecacheStatObjMaterial(IMaterial* pMaterial, const float fEntDistance, IStatObj* pStatObj, bool bFullUpdate, bool bDrawNear);
  248.  
  249.         void                    PrecacheStatObj(CStatObj* pStatObj, int nLod, const Matrix34A& statObjMatrix, IMaterial* pMaterial, float fImportance, float fEntDistance, bool bFullUpdate, bool bHighPriority);
  250.  
  251.         NCullQueue::SCullQueue& CullQueue() { return m_cullQueue; }
  252.  
  253.         //////////////////////////////////////////////////////////////////////////
  254.  
  255.         typedef std::map<string, CStatObj*, stl::less_stricmp<string>> ObjectsMap;
  256.         ObjectsMap m_nameToObjectMap;
  257.  
  258.         typedef std::set<CStatObj*> LoadedObjects;
  259.         LoadedObjects m_lstLoadedObjects;
  260.  
  261. protected:
  262.         CREFarTreeSprites* m_REFarTreeSprites;
  263.  
  264. #if CRY_PLATFORM_WINDOWS && CRY_PLATFORM_64BIT
  265.         #pragma warning( push )               //AMD Port
  266.         #pragma warning( disable : 4267 )
  267. #endif
  268.  
  269. public:
  270.         int GetLoadedObjectCount() { return m_lstLoadedObjects.size(); }
  271.  
  272. #if CRY_PLATFORM_WINDOWS && CRY_PLATFORM_64BIT
  273.         #pragma warning( pop )                //AMD Port
  274. #endif
  275.  
  276.         uint16 CheckCachedNearestCubeProbe(IRenderNode* pEnt, Vec4* pEnvProbMults = nullptr)
  277.         {
  278.                 if (pEnt->m_pTempData)
  279.                 {
  280.                         SRenderNodeTempData::SUserData& pUserDataRN = pEnt->m_pTempData->userData;
  281.  
  282.                         const uint16 nCacheClearThreshold = 32;
  283.                         ++pUserDataRN.nCubeMapIdCacheClearCounter;
  284.                         pUserDataRN.nCubeMapIdCacheClearCounter &= (nCacheClearThreshold - 1);
  285.  
  286.                         if (pUserDataRN.nCubeMapId && pUserDataRN.nCubeMapIdCacheClearCounter)
  287.                         {
  288.                                 if (pEnvProbMults)
  289.                                         *pEnvProbMults = pUserDataRN.vEnvironmentProbeMults;
  290.                                 return pUserDataRN.nCubeMapId;
  291.                         }
  292.                 }
  293.  
  294.                 // cache miss
  295.                 return 0;
  296.         }
  297.  
  298.         int16 GetNearestCubeProbe(PodArray<CDLight*>* pAffectingLights, IVisArea* pVisArea, const AABB& objBox, bool bSpecular = true, Vec4* pEnvProbeMults = nullptr);
  299.  
  300.         void  RenderObject(IRenderNode* o,
  301.                            PodArray<CDLight*>* pAffectingLights,
  302.                            const Vec3& vAmbColor,
  303.                            const AABB& objBox,
  304.                            float fEntDistance,
  305.                            bool bSunOnly,
  306.                            EERType eERType,
  307.                            const SRenderingPassInfo& passInfo);
  308.  
  309.         void RenderVegetation(class CVegetation* pEnt, PodArray<CDLight*>* pAffectingLights,
  310.                                                                                                         const AABB &objBox, float fEntDistance, bool bSunOnly,
  311.                                                                                                         SSectorTextureSet * pTerrainTexInfo, bool nCheckOcclusion, const SRenderingPassInfo &passInfo);
  312.         void RenderBrush(class CBrush* pEnt, PodArray<CDLight*>* pAffectingLights,
  313.                                                                                  SSectorTextureSet * pTerrainTexInfo,
  314.                                                                                  const AABB &objBox, float fEntDistance, bool bSunOnly,
  315.                                                                                  CVisArea * pVisArea, bool nCheckOcclusion, const SRenderingPassInfo &passInfo);
  316.  
  317.         int  ComputeDissolve(const CLodValue& lodValueIn, IRenderNode* pEnt, float fEntDistance, CLodValue arrlodValuesOut[2]);
  318.  
  319.         void RenderDecalAndRoad(IRenderNode* pEnt, PodArray<CDLight*>* pAffectingLights,
  320.                                 const Vec3& vAmbColor, const AABB& objBox, float fEntDistance,
  321.                                 bool bSunOnly, bool nCheckOcclusion, const SRenderingPassInfo& passInfo);
  322.  
  323.         void      RenderObjectDebugInfo(IRenderNode* pEnt, float fEntDistance, const SRenderingPassInfo& passInfo);
  324.         void      RenderAllObjectDebugInfo();
  325.         void      RenderObjectDebugInfo_Impl(IRenderNode* pEnt, float fEntDistance);
  326.         void      RemoveFromRenderAllObjectDebugInfo(IRenderNode* pEnt);
  327.  
  328.         float     GetXYRadius(int nType, int nSID = GetDefSID());
  329.         bool      GetStaticObjectBBox(int nType, Vec3& vBoxMin, Vec3& vBoxMax, int nSID = GetDefSID());
  330.  
  331.         IStatObj* GetStaticObjectByTypeID(int nTypeID, int nSID = GetDefSID());
  332.         IStatObj* FindStaticObjectByFilename(const char* filename);
  333.  
  334.         float     GetBendingRandomFactor();
  335.  
  336.         bool      IsBoxOccluded(const AABB& objBox,
  337.                                 float fDistance,
  338.                                 OcclusionTestClient* const __restrict pOcclTestVars,
  339.                                 bool bIndoorOccludersOnly,
  340.                                 EOcclusionObjectType eOcclusionObjectType,
  341.                                 const SRenderingPassInfo& passInfo);
  342.  
  343.         // tmp containers (replacement for local static vars)
  344.  
  345.         //  void DrawObjSpritesSorted(PodArray<CVegetation*> *pList, float fMaxViewDist, int useBending);
  346.         //      void ProcessActiveShadowReceiving(IRenderNode * pEnt, float fEntDistance, CDLight * pLight, bool bFocusOnHead);
  347.  
  348.         //      void SetupEntityShadowMapping( IRenderNode * pEnt, SRendParams * pDrawParams, float fEntDistance, CDLight * pLight );
  349.         //////////////////////////////////////////////////////////////////////////
  350.  
  351.         void RegisterForStreaming(IStreamable* pObj);
  352.         void UnregisterForStreaming(IStreamable* pObj);
  353.         void UpdateRenderNodeStreamingPriority(IRenderNode* pObj, float fEntDistance, float fImportanceFactor, bool bFullUpdate, const SRenderingPassInfo& passInfo, bool bHighPriority = false);
  354.  
  355.         void GetMemoryUsage(class ICrySizer* pSizer) const;
  356.         void GetBandwidthStats(float* fBandwidthRequested);
  357.  
  358.         //  PodArray<class CBrush*> m_lstBrushContainer;
  359.         //  PodArray<class CVegetation*> m_lstVegetContainer;
  360.         void       LoadBrushes();
  361.         //  void MergeBrushes();
  362.         void       ReregisterEntitiesInArea(Vec3 vBoxMin, Vec3 vBoxMax);
  363.         //      void ProcessEntityParticles(IRenderNode * pEnt, float fEntDistance);
  364.         void       UpdateObjectsStreamingPriority(bool bSyncLoad, const SRenderingPassInfo& passInfo);
  365.         ILINE void SetCurrentTime(float fCurrentTime) { m_fCurrTime = fCurrentTime; }
  366.         void       ProcessObjectsStreaming(const SRenderingPassInfo& passInfo);
  367.  
  368.         // implementation parts of ProcessObjectsStreaming
  369.         void ProcessObjectsStreaming_Impl(bool bSyncLoad, const SRenderingPassInfo& passInfo);
  370.         void ProcessObjectsStreaming_Sort(bool bSyncLoad, const SRenderingPassInfo& passInfo);
  371.         void ProcessObjectsStreaming_Release();
  372.         void ProcessObjectsStreaming_InitLoad(bool bSyncLoad);
  373.         void ProcessObjectsStreaming_Finish();
  374.  
  375. #ifdef OBJMAN_STREAM_STATS
  376.         void ProcessObjectsStreaming_Stats(const SRenderingPassInfo& passInfo);
  377. #endif
  378.  
  379.         // time counters
  380.  
  381.         static bool IsAfterWater(const Vec3& vPos, const Vec3& vCamPos, const SRenderingPassInfo& passInfo, float fUserWaterLevel = WATER_LEVEL_UNKNOWN);
  382.  
  383.         void        GetObjectsStreamingStatus(I3DEngine::SObjectsStreamingStatus& outStatus);
  384.         //      bool ProcessShadowMapCasting(IRenderNode * pEnt, CDLight * pLight);
  385.  
  386.         //      bool IsSphereAffectedByShadow(IRenderNode * pCaster, IRenderNode * pReceiver, CDLight * pLight);
  387.         //      void MakeShadowCastersListInArea(CBasicArea * pArea, const AABB & boxReceiver,
  388.         //              int dwAllowedTypes, Vec3 vLightPos, CDLight * pLight, ShadowMapFrustum * pFr, PodArray<struct SPlaneObject> * pShadowHull );
  389.         //      void DrawEntityShadowFrustums(IRenderNode * pEnt);
  390.  
  391.         void FreeNotUsedCGFs();
  392.  
  393.         //      void RenderObjectVegetationNonCastersNoFogVolume( IRenderNode * pEnt,uint32 nDLightMask,
  394.         //      const CCamera & EntViewCamera,
  395.         //bool bAllInside, float fMaxViewDist, IRenderNodeInfo * pEntInfo);
  396.         //      void InitEntityShadowMapInfoStructure(IRenderNode * pEnt);
  397.         //      float CalculateEntityShadowVolumeExtent(IRenderNode * pEntity, CDLight * pLight);
  398.         //      void MakeShadowBBox(Vec3 & vBoxMin, Vec3 & vBoxMax, const Vec3 & vLightPos, float fLightRadius, float fShadowVolumeExtent);
  399.         void MakeUnitCube();
  400.  
  401.         void BoxCastingShadow_HWOcclQuery(const AABB& objBox, const Vec3& rSunDir, OcclusionTestClient* const pOcclTestVars)
  402.         {
  403. #ifdef USE_CULL_QUEUE
  404.                 if (GetCVars()->e_CoverageBuffer)
  405.                 {
  406.                         const uint32 mainFrameID = passInfo.GetMainFrameID();
  407.                         CullQueue().AddItem(objBox, rSunDir, pOcclTestVars, mainFrameID);
  408.                 }
  409. #endif
  410.         }
  411.         bool IsBoxOccluded_HeightMap(const AABB& objBox, float fDistance, EOcclusionObjectType eOcclusionObjectType, OcclusionTestClient* pOcclTestVars, const SRenderingPassInfo& passInfo);
  412.  
  413.         //////////////////////////////////////////////////////////////////////////
  414.         // CheckOcclusion functionality
  415.         bool CheckOcclusion_TestAABB(const AABB& rAABB, float fEntDistance);
  416.         bool CheckOcclusion_TestQuad(const Vec3& vCenter, const Vec3& vAxisX, const Vec3& vAxisY);
  417.  
  418.         void PushIntoCullQueue(const SCheckOcclusionJobData& rCheckOcclusionData);
  419.         void PopFromCullQueue(SCheckOcclusionJobData* pCheckOcclusionData);
  420.  
  421.         void PushIntoCullOutputQueue(const SCheckOcclusionOutput& rCheckOcclusionOutput);
  422.         bool PopFromCullOutputQueue(SCheckOcclusionOutput* pCheckOcclusionOutput);
  423.  
  424.         void BeginCulling();
  425.         void RemoveCullJobProducer();
  426.         void AddCullJobProducer();
  427.  
  428. #ifndef _RELEASE
  429.         void CoverageBufferDebugDraw();
  430. #endif
  431.  
  432.         bool LoadOcclusionMesh(const char* pFileName);
  433.  
  434.         //////////////////////////////////////////////////////////////////////////
  435.         // Garbage collection for parent stat objects.
  436.         // Returns number of deleted objects
  437.         void        ClearStatObjGarbage();
  438.         void        CheckForGarbage(CStatObj* pObject);
  439.         void        UnregisterForGarbage(CStatObj* pObject);
  440.  
  441.         static int  GetObjectLOD(const IRenderNode* pObj, float fDistance);
  442.         static bool RayStatObjIntersection(IStatObj* pStatObj, const Matrix34& objMat, IMaterial* pMat,
  443.                                            Vec3 vStart, Vec3 vEnd, Vec3& vClosestHitPoint, float& fClosestHitDistance, bool bFastTest);
  444.         static bool RayRenderMeshIntersection(IRenderMesh* pRenderMesh, const Vec3& vInPos, const Vec3& vInDir, Vec3& vOutPos, Vec3& vOutNormal, bool bFastTest, IMaterial* pMat);
  445.         static bool SphereRenderMeshIntersection(IRenderMesh* pRenderMesh, const Vec3& vInPos, const float fRadius, IMaterial* pMat);
  446.         static void FillTerrainTexInfo(IOctreeNode* pOcNode, float fEntDistance, struct SSectorTextureSet*& pTerrainTexInfo, const AABB& objBox);
  447.         PodArray<CVisArea*> m_tmpAreas0, m_tmpAreas1;
  448.  
  449.         void         CleanStreamingData();
  450.         IRenderMesh* GetRenderMeshBox();
  451.  
  452.         void         PrepareCullbufferAsync(const CCamera& rCamera);
  453.         void         BeginOcclusionCulling(const SRenderingPassInfo& passInfo);
  454.         void         EndOcclusionCulling();
  455.         void         RenderBufferedRenderMeshes(const SRenderingPassInfo& passInfo);
  456.         uint32       GetResourcesModificationChecksum(IRenderNode* pOwnerNode) const;
  457.         bool         AddOrCreatePersistentRenderObject(SRenderNodeTempData* pTempData, CRenderObject*& pRenderObject, const CLodValue* pLodValue, const SRenderingPassInfo& passInfo) const;
  458.  
  459. public:
  460.         //////////////////////////////////////////////////////////////////////////
  461.         // Public Member variables (need to be cleaned).
  462.         //////////////////////////////////////////////////////////////////////////
  463.  
  464.         static int  m_nUpdateStreamingPrioriryRoundId;
  465.         static int  m_nUpdateStreamingPrioriryRoundIdFast;
  466.         static int  s_nLastStreamingMemoryUsage;        //For streaming tools in editor
  467.  
  468.         Vec3        m_vSkyColor;          //
  469.         Vec3        m_vSunColor;          //
  470.         float       m_fSunSkyRel;         //relation factor of sun sky, 1->sun has full part of brightness, 0->sky has full part
  471.         float       m_fILMul;
  472.         float       m_fSkyBrightMul;
  473.         float       m_fSSAOAmount;
  474.         float       m_fSSAOContrast;
  475.         float       m_fGIAmount;
  476.         SRainParams m_rainParams;
  477.         SSnowParams m_snowParams;
  478.  
  479.         int         m_bLockCGFResources;
  480.  
  481.         float       m_fMaxViewDistanceScale;
  482.         float       m_fGSMMaxDistance;
  483.  
  484. public:
  485.         //////////////////////////////////////////////////////////////////////////
  486.         // Private Member variables.
  487.         //////////////////////////////////////////////////////////////////////////
  488.         PodArray<IStreamable*> m_arrStreamableToRelease;
  489.         PodArray<IStreamable*> m_arrStreamableToLoad;
  490.         PodArray<IStreamable*> m_arrStreamableToDelete;
  491.         bool                   m_bNeedProcessObjectsStreaming_Finish;
  492.  
  493.         float                  m_fCurrTime;
  494.  
  495.         //      bool LoadStaticObjectsFromXML(XmlNodeRef xmlVegetation);
  496.         _smart_ptr<CStatObj>    m_pDefaultCGF;
  497.         _smart_ptr<IRenderMesh> m_pRMBox;
  498.  
  499.         //////////////////////////////////////////////////////////////////////////
  500.         std::vector<_smart_ptr<IStatObj>> m_lockedObjects;
  501.  
  502.         //////////////////////////////////////////////////////////////////////////
  503.         CryMT::vector<CStatObj*>        m_checkForGarbage;
  504.         bool                            m_bGarbageCollectionEnabled;
  505.  
  506.         PodArray<SStreamAbleObject>     m_arrStreamableObjects;
  507.         NCullQueue::SCullQueue          m_cullQueue;
  508.         PodArray<COctreeNode*>          m_arrStreamingNodeStack;
  509.         PodArray<SObjManPrecachePoint>  m_vStreamPreCachePointDefs;
  510.         PodArray<SObjManPrecacheCamera> m_vStreamPreCacheCameras;
  511.         int                             m_nNextPrecachePointId;
  512.         bool                            m_bCameraPrecacheOverridden;
  513.  
  514.         PodArray<CTerrainNode*>         m_lstTmpCastingNodes;
  515.  
  516. #ifdef POOL_STATOBJ_ALLOCS
  517.         stl::PoolAllocator<sizeof(CStatObj), stl::PSyncMultiThread, alignof(CStatObj)>* m_statObjPool;
  518. #endif
  519.  
  520.         CThreadSafeRendererContainer<SObjManRenderDebugInfo>             m_arrRenderDebugInfo;
  521.  
  522.         NAsyncCull::CCullThread                                          m_CullThread;
  523.         CryMT::SingleProducerSingleConsumerQueue<SCheckOcclusionJobData> m_CheckOcclusionQueue;
  524.         CryMT::N_ProducerSingleConsumerQueue<SCheckOcclusionOutput>      m_CheckOcclusionOutputQueue;
  525. };
  526.  
  527. #endif // CObjManager_H
  528.  
downloadObjMan.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