BVB Source Codes

CRYENGINE Show 3dEngine.h Source code

Return Download CRYENGINE: download 3dEngine.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:   3dengine.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 C3DENGINE_H
  15. #define C3DENGINE_H
  16.  
  17. #if _MSC_VER > 1000
  18.         #pragma once
  19. #endif
  20.  
  21. #include <CryThreading/CryThreadSafeRendererContainer.h>
  22. #include "VisibleRenderNodeManager.h"
  23. #include "LightVolumeManager.h"
  24.  
  25. #ifdef DrawText
  26.         #undef DrawText
  27. #endif //DrawText
  28.  
  29. // forward declaration
  30. struct SNodeInfo;
  31. class CStitchedImage;
  32. class CWaterRippleManager;
  33.  
  34. struct SEntInFoliage
  35. {
  36.         int   id;
  37.         float timeIdle;
  38.  
  39.         void  GetMemoryUsage(ICrySizer* pSizer) const { /*nothing*/ }
  40. };
  41.  
  42. class CMemoryBlock : public IMemoryBlock
  43. {
  44. public:
  45.         virtual void* GetData() { return m_pData; }
  46.         virtual int   GetSize() { return m_nSize; }
  47.         virtual ~CMemoryBlock() { delete[] m_pData; }
  48.  
  49.         CMemoryBlock() { m_pData = 0; m_nSize = 0; }
  50.         CMemoryBlock(const void* pData, int nSize)
  51.         {
  52.                 m_pData = 0;
  53.                 m_nSize = 0;
  54.                 SetData(pData, nSize);
  55.         }
  56.         void SetData(const void* pData, int nSize)
  57.         {
  58.                 delete[] m_pData;
  59.                 m_pData = new uint8[nSize];
  60.                 memcpy(m_pData, pData, nSize);
  61.                 m_nSize = nSize;
  62.         }
  63.         void Free()
  64.         {
  65.                 delete[] m_pData;
  66.                 m_pData = NULL;
  67.                 m_nSize = 0;
  68.         }
  69.         void Allocate(int nSize)
  70.         {
  71.                 delete[] m_pData;
  72.                 m_pData = new uint8[nSize];
  73.                 memset(m_pData, 0, nSize);
  74.                 m_nSize = nSize;
  75.         }
  76.  
  77.         static CMemoryBlock* CompressToMemBlock(void* pData, int nSize, ISystem* pSystem)
  78.         {
  79.                 CMemoryBlock* pMemBlock = NULL;
  80.                 uint8* pTmp = new uint8[nSize + 4];
  81.                 size_t nComprSize = nSize;
  82.                 *(uint32*)pTmp = nSize;
  83.                 if (pSystem->CompressDataBlock(pData, nSize, pTmp + 4, nComprSize))
  84.                 {
  85.                         pMemBlock = new CMemoryBlock(pTmp, nComprSize + 4);
  86.                 }
  87.  
  88.                 delete[] pTmp;
  89.                 return pMemBlock;
  90.         }
  91.  
  92.         static CMemoryBlock* DecompressFromMemBlock(CMemoryBlock* pMemBlock, ISystem* pSystem)
  93.         {
  94.                 size_t nUncompSize = *(uint32*)pMemBlock->GetData();
  95.                 SwapEndian(nUncompSize);
  96.                 CMemoryBlock* pResult = new CMemoryBlock;
  97.                 pResult->Allocate(nUncompSize);
  98.                 if (!pSystem->DecompressDataBlock((byte*)pMemBlock->GetData() + 4, pMemBlock->GetSize() - 4, pResult->GetData(), nUncompSize))
  99.                 {
  100.                         assert(!"CMemoryBlock::DecompressFromMemBlock failed");
  101.                         delete pResult;
  102.                         pResult = NULL;
  103.                 }
  104.  
  105.                 return pResult;
  106.         }
  107.  
  108.         uint8* m_pData;
  109.         int    m_nSize;
  110. };
  111.  
  112. // Values to combine for phys area type selection
  113. enum EAreaPhysics
  114. {
  115.         Area_Water = BIT(0),
  116.         Area_Air   = BIT(1),
  117.         // Other physics media can be masked in as well
  118.  
  119.         Area_Gravity = BIT(14),
  120.         Area_Other   = BIT(15),
  121. };
  122.  
  123. struct SAreaChangeRecord
  124. {
  125.         AABB   boxAffected;         // Area of change
  126.         uint16 uPhysicsMask;        // Types of mediums for this area
  127. };
  128.  
  129. struct SOptimizedOutdoorWindArea
  130. {
  131.         int              x0, x1, y0, y1; // 2d rectangle extents for the wind area
  132.         Vec2             point[5];       // Extent points of the wind area (index 4 is center)
  133.         Vec3             windSpeed[5];   // Wind speed at every corner and center.
  134.         float            z;
  135.         IPhysicalEntity* pArea;// Physical area
  136. };
  137.  
  138. struct DLightAmount
  139. {
  140.         CDLight* pLight;
  141.         float    fAmount;
  142. };
  143.  
  144. struct SImageSubInfo
  145. {
  146.         SImageSubInfo() { memset(this, 0, sizeof(*this)); fTiling = fTilingIn = 1.f; }
  147.  
  148.         static const int nMipsNum = 4;
  149.  
  150.         union
  151.         {
  152.                 byte* pImgMips[nMipsNum];
  153.                 int   pImgMipsSizeKeeper[8];
  154.         };
  155.  
  156.         float fAmount;
  157.         int   nReady;
  158.         int   nDummy[4];
  159.  
  160.         union
  161.         {
  162.                 IMaterial* pMat;
  163.                 int        pMatSizeKeeper[2];
  164.         };
  165.  
  166.         int   nDim;
  167.         float fTilingIn;
  168.         float fTiling;
  169.         float fSpecularAmount;
  170.         int   nSortOrder;
  171.         int   nAlignFix;
  172.  
  173.         AUTO_STRUCT_INFO;
  174. };
  175.  
  176. struct SImageInfo : public Cry3DEngineBase
  177. {
  178.         SImageInfo()
  179.         {
  180.                 szDetMatName[0] = szBaseTexName[0] = nPhysSurfaceType = 0;
  181.                 nLayerId = 0;
  182.                 fUseRemeshing = 0;
  183.                 fBr = 1.f;
  184.                 layerFilterColor = Col_White;
  185.                 nDetailSurfTypeId = 0;
  186.                 ZeroStruct(arrTextureId);
  187.         }
  188.  
  189.         void GetMemoryUsage(ICrySizer* pSizer) const { /*nothing*/ }
  190.  
  191.         SImageSubInfo baseInfo;
  192.         SImageSubInfo detailInfo;
  193.  
  194.         char          szDetMatName[128 - 20];
  195.  
  196.         int           arrTextureId[4];
  197.         int           nPhysSurfaceType;
  198.  
  199.         char          szBaseTexName[128];
  200.  
  201.         float         fUseRemeshing;
  202.         ColorF        layerFilterColor;
  203.         int           nLayerId;
  204.         float         fBr;
  205.         int           nDetailSurfTypeId;
  206.  
  207.         int GetMemoryUsage();
  208.  
  209.         AUTO_STRUCT_INFO;
  210. };
  211.  
  212. struct SSceneFrustum
  213. {
  214.         uint32*      pRgbImage;
  215.         uint32       nRgbWidth, nRgbHeight;
  216.  
  217.         float*       pDepthImage;
  218.         uint32       nDepthWidth, nDepthHeight;
  219.  
  220.         CCamera      camera;
  221.  
  222.         IRenderMesh* pRM;
  223.         IMaterial*   pMaterial;
  224.  
  225.         float        fDistance;
  226.         int          nId;
  227.  
  228.         static int   Compare(const void* v1, const void* v2)
  229.         {
  230.                 SSceneFrustum* p[2] = { (SSceneFrustum*)v1, (SSceneFrustum*)v2 };
  231.  
  232.                 if (p[0]->fDistance > p[1]->fDistance)
  233.                         return 1;
  234.                 if (p[0]->fDistance < p[1]->fDistance)
  235.                         return -1;
  236.  
  237.                 if (p[0]->nId > p[1]->nId)
  238.                         return 1;
  239.                 if (p[0]->nId < p[1]->nId)
  240.                         return -1;
  241.  
  242.                 return 0;
  243.         }
  244. };
  245.  
  246. struct SPerObjectShadow
  247. {
  248.         IShadowCaster* pCaster;
  249.         float          fConstBias;
  250.         float          fSlopeBias;
  251.         float          fJitter;
  252.         Vec3           vBBoxScale;
  253.         uint           nTexSize;
  254. };
  255. //////////////////////////////////////////////////////////////////////
  256.  
  257. // onscreen infodebug for e_debugDraw >= 100
  258. #ifndef _RELEASE
  259. class CDebugDrawListMgr
  260. {
  261.         typedef CryFixedStringT<64>  TMyStandardString;
  262.         typedef CryFixedStringT<128> TFilenameString;
  263.  
  264. public:
  265.  
  266.         CDebugDrawListMgr();
  267.         void        Update();
  268.         void        AddObject(I3DEngine::SObjectInfoToAddToDebugDrawList& objInfo);
  269.         void        DumpLog();
  270.         bool        IsEnabled() const { return Cry3DEngineBase::GetCVars()->e_DebugDraw >= LM_BASENUMBER; }
  271.         static void ConsoleCommand(IConsoleCmdArgs* args);
  272.  
  273. private:
  274.  
  275.         enum { UNDEFINED_ASSET_ID = 0xffffffff };
  276.  
  277.         struct TAssetInfo
  278.         {
  279.                 TMyStandardString                   name;
  280.                 TFilenameString                     fileName;
  281.                 uint32                              numTris;
  282.                 uint32                              numVerts;
  283.                 uint32                              texMemory;
  284.                 uint32                              meshMemory;
  285.                 uint32                              drawCalls;
  286.                 uint32                              numInstances;
  287.                 I3DEngine::EDebugDrawListAssetTypes type;
  288.                 uint32                              ID; // to identify which drawBoxes belong to this asset
  289.  
  290.                 TAssetInfo(const I3DEngine::SObjectInfoToAddToDebugDrawList& objInfo);
  291.                 bool operator<(const TAssetInfo& other) const;
  292.         };
  293.  
  294.         struct TObjectDrawBoxInfo
  295.         {
  296.                 Matrix34 mat;
  297.                 AABB     bbox;
  298.                 uint32   assetID;
  299.  
  300.                 TObjectDrawBoxInfo(const I3DEngine::SObjectInfoToAddToDebugDrawList& objInfo);
  301.         };
  302.  
  303.         void        FindNewLeastValueAsset();
  304.         void        ClearFrameData();
  305.         void        ClearConsoleCommandRequestVars();
  306.         static bool SortComparison(const TAssetInfo& A, const TAssetInfo& B) { return B < A; }
  307.         const char* GetStrCurrMode();
  308.         void        GetStrCurrFilter(TMyStandardString& strOut);
  309.         bool        ShouldFilterOutObject(const I3DEngine::SObjectInfoToAddToDebugDrawList& newObject);
  310.         void        MemToString(uint32 memVal, TMyStandardString& outStr);
  311.         static void PrintText(float x, float y, const ColorF& fColor, const char* label_text, ...);
  312.         const char* GetAssetTypeName(I3DEngine::EDebugDrawListAssetTypes type);
  313.         TAssetInfo* FindDuplicate(const TAssetInfo& object);
  314.         void        CheckFilterCVar();
  315.  
  316.         // to avoid any heap allocation
  317.         static void                   MyStandardString_Concatenate(TMyStandardString& outStr, const char* str);
  318.         static void                   MyFileNameString_Assign(TFilenameString& outStr, const char* pStr);
  319.  
  320.         template<class T> static void MyString_Assign(T& outStr, const char* pStr)
  321.         {
  322.                 if (pStr)
  323.                         outStr._Assign(pStr, min(strlen(pStr), outStr.capacity()));
  324.                 else
  325.                         outStr = "";
  326.         }
  327.  
  328.         enum EListModes
  329.         {
  330.                 LM_BASENUMBER = 100,
  331.                 LM_TRI_COUNT  = LM_BASENUMBER,
  332.                 LM_VERT_COUNT,
  333.                 LM_DRAWCALLS,
  334.                 LM_TEXTMEM,
  335.                 LM_MESHMEM
  336.         };
  337.  
  338.         bool                            m_isFrozen;
  339.         uint32                          m_counter;
  340.         uint32                          m_assetCounter;
  341.         uint32                          m_indexLeastValueAsset;
  342.         std::vector<TAssetInfo>         m_assets;
  343.         std::vector<TObjectDrawBoxInfo> m_drawBoxes;
  344.         CryCriticalSection              m_lock;
  345.  
  346.         static bool                     m_dumpLogRequested;
  347.         static bool                     m_freezeRequested;
  348.         static bool                     m_unfreezeRequested;
  349.         static uint32                   m_filter;
  350. };
  351. #endif //_RELEASE
  352.  
  353. //////////////////////////////////////////////////////////////////////
  354. class C3DEngine : public I3DEngine, public Cry3DEngineBase
  355. {
  356.         // IProcess Implementation
  357.         void SetFlags(int flags) { m_nFlags = flags; }
  358.         int  GetFlags(void)      { return m_nFlags; }
  359.         int m_nFlags;
  360.  
  361. public:
  362.  
  363.         // I3DEngine interface implementation
  364.         virtual bool      Init();
  365.         virtual void      OnFrameStart();
  366.         virtual void      Update();
  367.         virtual void      RenderWorld(const int nRenderFlags, const SRenderingPassInfo& passInfo, const char* szDebugName);
  368.         virtual void      PreWorldStreamUpdate(const CCamera& cam);
  369.         virtual void      WorldStreamUpdate();
  370.         virtual void      ShutDown();
  371.         virtual void      Release() { CryAlignedDelete(this); };
  372.         virtual void      SetLevelPath(const char* szFolderName);
  373.         virtual bool      LoadLevel(const char* szFolderName, const char* szMissionName);
  374.         virtual void      UnloadLevel();
  375.         virtual void      PostLoadLevel();
  376.         virtual bool      InitLevelForEditor(const char* szFolderName, const char* szMissionName);
  377.         virtual void      DisplayInfo(float& fTextPosX, float& fTextPosY, float& fTextStepY, const bool bEnhanced);
  378.         virtual void      SetupDistanceFog();
  379.         virtual IStatObj* LoadStatObj(const char* szFileName, const char* szGeomName = NULL, /*[Out]*/ IStatObj::SSubObject** ppSubObject = NULL, bool bUseStreaming = true, unsigned long nLoadingFlags = 0);
  380.         virtual IStatObj* FindStatObjectByFilename(const char* filename);
  381.         virtual void      RegisterEntity(IRenderNode* pEnt, int nSID = -1, int nSIDConsideredSafe = -1);
  382.         virtual void      SelectEntity(IRenderNode* pEnt);
  383.  
  384. #ifndef _RELEASE
  385.         virtual void AddObjToDebugDrawList(SObjectInfoToAddToDebugDrawList& objInfo);
  386.         virtual bool IsDebugDrawListEnabled() const { return m_DebugDrawListMgr.IsEnabled(); }
  387. #endif
  388.  
  389.         virtual void   UnRegisterEntityDirect(IRenderNode* pEnt);
  390.         virtual void   UnRegisterEntityAsJob(IRenderNode* pEnt);
  391.  
  392.         virtual void   AddWaterRipple(const Vec3& vPos, float scale, float strength);
  393.  
  394.         virtual bool   IsUnderWater(const Vec3& vPos) const;
  395.         virtual void   SetOceanRenderFlags(uint8 nFlags);
  396.         virtual uint8  GetOceanRenderFlags() const { return m_nOceanRenderFlags; }
  397.         virtual uint32 GetOceanVisiblePixelsCount() const;
  398.         virtual float  GetBottomLevel(const Vec3& referencePos, float maxRelevantDepth, int objtypes);
  399.         virtual float  GetBottomLevel(const Vec3& referencePos, float maxRelevantDepth /* = 10.0f*/);
  400.         virtual float  GetBottomLevel(const Vec3& referencePos, int objflags);
  401.  
  402. #if defined(USE_GEOM_CACHES)
  403.         virtual IGeomCache* LoadGeomCache(const char* szFileName);
  404.         virtual IGeomCache* FindGeomCacheByFilename(const char* szFileName);
  405. #endif
  406.  
  407.         virtual IStatObj* LoadDesignerObject(int nVersion, const char* szBinaryStream, int size);
  408.  
  409.         void              AsyncOctreeUpdate(IRenderNode* pEnt, int nSID, int nSIDConsideredSafe, uint32 nFrameID, bool bUnRegisterOnly);
  410.         bool              UnRegisterEntityImpl(IRenderNode* pEnt);
  411.         virtual void      UpdateObjectsLayerAABB(IRenderNode* pEnt);
  412.  
  413.         // Fast option - use if just ocean height required
  414.         virtual float                    GetWaterLevel();
  415.         // This will return ocean height or water volume height, optional for accurate water height query
  416.         virtual float                    GetWaterLevel(const Vec3* pvPos, IPhysicalEntity* pent = NULL, bool bAccurate = false);
  417.         // Only use for Accurate query - this will return exact ocean height
  418.         virtual float                    GetAccurateOceanHeight(const Vec3& pCurrPos) const;
  419.  
  420.         virtual Vec4                     GetCausticsParams() const;
  421.         virtual Vec4                     GetOceanAnimationCausticsParams() const;
  422.         virtual void                     GetOceanAnimationParams(Vec4& pParams0, Vec4& pParams1) const;
  423.         virtual void                     GetHDRSetupParams(Vec4 pParams[5]) const;
  424.         virtual void                     CreateDecal(const CryEngineDecalInfo& Decal);
  425.         virtual void                     DrawFarTrees(const SRenderingPassInfo& passInfo);
  426.         virtual void                     GenerateFarTrees(const SRenderingPassInfo& passInfo);
  427.         virtual float                    GetTerrainElevation(float x, float y, int nSID = GetDefSID());
  428.         virtual float                    GetTerrainElevation3D(Vec3 vPos);
  429.         virtual float                    GetTerrainZ(int x, int y);
  430.         virtual bool                     GetTerrainHole(int x, int y);
  431.         virtual int                      GetHeightMapUnitSize();
  432.         virtual int                      GetTerrainSize();
  433.         virtual void                     SetSunDir(const Vec3& newSunOffset);
  434.         virtual Vec3                     GetSunDir() const;
  435.         virtual Vec3                     GetSunDirNormalized() const;
  436.         virtual Vec3                     GetRealtimeSunDirNormalized() const;
  437.         virtual void                     SetSkyColor(Vec3 vColor);
  438.         virtual void                     SetSunColor(Vec3 vColor);
  439.         virtual void                     SetSkyBrightness(float fMul);
  440.         virtual void                     SetSSAOAmount(float fMul);
  441.         virtual void                     SetSSAOContrast(float fMul);
  442.         virtual void                     SetGIAmount(float fMul);
  443.         virtual float                    GetSunRel() const;
  444.         virtual void                     SetRainParams(const SRainParams& rainParams);
  445.         virtual bool                     GetRainParams(SRainParams& rainParams);
  446.         virtual void                     SetSnowSurfaceParams(const Vec3& vCenter, float fRadius, float fSnowAmount, float fFrostAmount, float fSurfaceFreezing);
  447.         virtual bool                     GetSnowSurfaceParams(Vec3& vCenter, float& fRadius, float& fSnowAmount, float& fFrostAmount, float& fSurfaceFreezing);
  448.         virtual void                     SetSnowFallParams(int nSnowFlakeCount, float fSnowFlakeSize, float fSnowFallBrightness, float fSnowFallGravityScale, float fSnowFallWindScale, float fSnowFallTurbulence, float fSnowFallTurbulenceFreq);
  449.         virtual bool                     GetSnowFallParams(int& nSnowFlakeCount, float& fSnowFlakeSize, float& fSnowFallBrightness, float& fSnowFallGravityScale, float& fSnowFallWindScale, float& fSnowFallTurbulence, float& fSnowFallTurbulenceFreq);
  450.         virtual void                     OnExplosion(Vec3 vPos, float fRadius, bool bDeformTerrain = true);
  451.         //! For editor
  452.         virtual void                     RemoveAllStaticObjects(int nSID);
  453.         virtual void                     SetTerrainSurfaceType(int x, int y, int nType);
  454.         virtual void                     SetTerrainSectorTexture(const int nTexSectorX, const int nTexSectorY, unsigned int textureId);
  455.         virtual void                     SetPhysMaterialEnumerator(IPhysMaterialEnumerator* pPhysMaterialEnumerator);
  456.         virtual IPhysMaterialEnumerator* GetPhysMaterialEnumerator();
  457.         virtual void                     LoadMissionDataFromXMLNode(const char* szMissionName);
  458.  
  459.         void                             AddDynamicLightSource(const class CDLight& LSource, ILightSource* pEnt, int nEntityLightId, float fFadeout, const SRenderingPassInfo& passInfo);
  460.  
  461.         inline void                      AddLightToRenderer(const CDLight& light, float fMult, const SRenderingPassInfo& passInfo)
  462.         {
  463.                 const uint32 nLightID = passInfo.GetIRenderView()->GetLightsCount(eDLT_DeferredLight);
  464.                 //passInfo.GetIRenderView()->AddLight(eDLT_DeferredLight,light);
  465.                 GetRenderer()->EF_AddDeferredLight(light, fMult, passInfo);
  466.                 Get3DEngine()->m_LightVolumesMgr.RegisterLight(light, nLightID, passInfo);
  467.                 m_nDeferredLightsNum++;
  468.         }
  469.  
  470.         virtual void                 ApplyForceToEnvironment(Vec3 vPos, float fRadius, float fAmountOfForce);
  471.         virtual void                 SetMaxViewDistanceScale(float fScale) { m_fMaxViewDistScale = fScale; }
  472.         virtual float                GetMaxViewDistance(bool bScaled = true);
  473.         virtual const SFrameLodInfo& GetFrameLodInfo() const               { return m_frameLodInfo; }
  474.         virtual void                 SetFrameLodInfo(const SFrameLodInfo& frameLodInfo);
  475.         virtual void                 SetFogColor(const Vec3& vFogColor);
  476.         virtual Vec3                 GetFogColor();
  477.         virtual float                GetDistanceToSectorWithWater();
  478.  
  479.         virtual void                 GetSkyLightParameters(Vec3& sunDir, Vec3& sunIntensity, float& Km, float& Kr, float& g, Vec3& rgbWaveLengths);
  480.         virtual void                 SetSkyLightParameters(const Vec3& sunDir, const Vec3& sunIntensity, float Km, float Kr, float g, const Vec3& rgbWaveLengths, bool forceImmediateUpdate = false);
  481.  
  482.         void                         SetLightsHDRDynamicPowerFactor(const float value);
  483.         virtual float                GetLightsHDRDynamicPowerFactor() const;
  484.  
  485.         // Return true if tessellation is allowed (by cvars) into currently set shadow map LOD
  486.         bool                              IsTessellationAllowedForShadowMap(const SRenderingPassInfo& passInfo) const;
  487.         // Return true if tessellation is allowed for given render object
  488.         virtual bool                      IsTessellationAllowed(const CRenderObject* pObj, const SRenderingPassInfo& passInfo, bool bIgnoreShadowPass = false) const;
  489.  
  490.         virtual void                      SetRenderNodeMaterialAtPosition(EERType eNodeType, const Vec3& vPos, IMaterial* pMat);
  491.         virtual void                      OverrideCameraPrecachePoint(const Vec3& vPos);
  492.         virtual int                       AddPrecachePoint(const Vec3& vPos, const Vec3& vDir, float fTimeOut = 3.f, float fImportanceFactor = 1.0f);
  493.         virtual void                      ClearPrecachePoint(int id);
  494.         virtual void                      ClearAllPrecachePoints();
  495.         virtual void                      GetPrecacheRoundIds(int pRoundIds[MAX_STREAM_PREDICTION_ZONES]);
  496.  
  497.         virtual void                      TraceFogVolumes(const Vec3& worldPos, ColorF& fogVolumeContrib, const SRenderingPassInfo& passInfo);
  498.  
  499.         virtual Vec3                      GetSkyColor() const;
  500.         virtual Vec3                      GetSunColor() const;
  501.         virtual float                     GetSkyBrightness() const;
  502.         virtual float                     GetSSAOAmount() const;
  503.         virtual float                     GetSSAOContrast() const;
  504.         virtual float                     GetGIAmount() const;
  505.         virtual float                     GetTerrainTextureMultiplier(int nSID) const;
  506.  
  507.         virtual Vec3                      GetAmbientColorFromPosition(const Vec3& vPos, float fRadius = 1.f);
  508.         virtual void                      FreeRenderNodeState(IRenderNode* pEnt);
  509.         virtual const char*               GetLevelFilePath(const char* szFileName);
  510.         virtual void                      SetTerrainBurnedOut(int x, int y, bool bBurnedOut);
  511.         virtual bool                      IsTerrainBurnedOut(int x, int y);
  512.         virtual int                       GetTerrainSectorSize();
  513.         virtual void                      LoadTerrainSurfacesFromXML(XmlNodeRef pDoc, bool bUpdateTerrain, int nSID);
  514.         virtual bool                      SetStatInstGroup(int nGroupId, const IStatInstGroup& siGroup, int nSID);
  515.         virtual bool                      GetStatInstGroup(int nGroupId, IStatInstGroup& siGroup, int nSID);
  516.         virtual void                      ActivatePortal(const Vec3& vPos, bool bActivate, const char* szEntityName);
  517.         virtual void                      GetMemoryUsage(ICrySizer* pSizer) const;
  518.         virtual void                      GetResourceMemoryUsage(ICrySizer* pSizer, const AABB& cstAABB);
  519.         virtual IVisArea*                 CreateVisArea(uint64 visGUID);
  520.         virtual void                      DeleteVisArea(IVisArea* pVisArea);
  521.         virtual void                      UpdateVisArea(IVisArea* pArea, const Vec3* pPoints, int nCount, const char* szName,
  522.                                                         const SVisAreaInfo& info, bool bReregisterObjects);
  523.         virtual IClipVolume*              CreateClipVolume();
  524.         virtual void                      DeleteClipVolume(IClipVolume* pClipVolume);
  525.         virtual void                      UpdateClipVolume(IClipVolume* pClipVolume, _smart_ptr<IRenderMesh> pRenderMesh, IBSPTree3D* pBspTree, const Matrix34& worldTM, bool bActive, uint32 flags, const char* szName);
  526.         virtual void                      ResetParticlesAndDecals();
  527.         virtual IRenderNode*              CreateRenderNode(EERType type);
  528.         virtual void                      DeleteRenderNode(IRenderNode* pRenderNode);
  529.         virtual void                      SetWind(const Vec3& vWind);
  530.         virtual Vec3                      GetWind(const AABB& box, bool bIndoors) const;
  531.  
  532.         void                              StartWindGridJob(const Vec3& vPos);
  533.         void                              FinishWindGridJob();
  534.         void                              UpdateWindGridJobEntry(Vec3 vPos);
  535.         void                              UpdateWindGridArea(SWindGrid& rWindGrid, const SOptimizedOutdoorWindArea& windArea, const AABB& windBox);
  536.  
  537.         virtual Vec3                      GetGlobalWind(bool bIndoors) const;
  538.         virtual bool                      SampleWind(Vec3* pSamples, int nSamples, const AABB& volume, bool bIndoors) const;
  539.         virtual IVisArea*                 GetVisAreaFromPos(const Vec3& vPos);
  540.         virtual bool                      IntersectsVisAreas(const AABB& box, void** pNodeCache = 0);
  541.         virtual bool                      ClipToVisAreas(IVisArea* pInside, Sphere& sphere, Vec3 const& vNormal, void* pNodeCache = 0);
  542.         virtual bool                      IsVisAreasConnected(IVisArea* pArea1, IVisArea* pArea2, int nMaxReqursion, bool bSkipDisabledPortals);
  543.         void                              EnableOceanRendering(bool bOcean); // todo: remove
  544.  
  545.         virtual struct ILightSource*      CreateLightSource();
  546.         virtual void                      DeleteLightSource(ILightSource* pLightSource);
  547.         virtual const PodArray<CDLight*>* GetStaticLightSources();
  548.         virtual bool                      IsTerrainHightMapModifiedByGame();
  549.         virtual bool                      RestoreTerrainFromDisk(int nSID);
  550.         virtual void                      CheckMemoryHeap();
  551.         virtual void                      CloseTerrainTextureFile(int nSID);
  552.         virtual int                       GetLoadedObjectCount();
  553.         virtual void                      GetLoadedStatObjArray(IStatObj** pObjectsArray, int& nCount);
  554.         virtual void                      GetObjectsStreamingStatus(SObjectsStreamingStatus& outStatus);
  555.         virtual void                      GetStreamingSubsystemData(int subsystem, SStremaingBandwidthData& outData);
  556.         virtual void                      DeleteEntityDecals(IRenderNode* pEntity);
  557.         virtual void                      DeleteDecalsInRange(AABB* pAreaBox, IRenderNode* pEntity);
  558.         virtual void                      CompleteObjectsGeometry();
  559.         virtual void                      LockCGFResources();
  560.         virtual void                      UnlockCGFResources();
  561.  
  562.         virtual void                      SerializeState(TSerialize ser);
  563.         virtual void                      PostSerialize(bool bReading);
  564.  
  565.         virtual void                      SetHeightMapMaxHeight(float fMaxHeight);
  566.  
  567.         virtual void                      SetStreamableListener(IStreamedObjectListener* pListener);
  568.  
  569.         //////////////////////////////////////////////////////////////////////////
  570.         // Materials access.
  571.         virtual IMaterialHelpers& GetMaterialHelpers();
  572.         virtual IMaterialManager* GetMaterialManager();
  573.         //////////////////////////////////////////////////////////////////////////
  574.  
  575.         //////////////////////////////////////////////////////////////////////////
  576.         // CGF Loader.
  577.         //////////////////////////////////////////////////////////////////////////
  578.         virtual CContentCGF* CreateChunkfileContent(const char* filename);
  579.         virtual void         ReleaseChunkfileContent(CContentCGF*);
  580.         virtual bool         LoadChunkFileContent(CContentCGF* pCGF, const char* filename, bool bNoWarningMode = false, bool bCopyChunkFile = true);
  581.         virtual bool         LoadChunkFileContentFromMem(CContentCGF* pCGF, const void* pData, size_t nDataLen, uint32 nLoadingFlags, bool bNoWarningMode = false, bool bCopyChunkFile = true);
  582.         //////////////////////////////////////////////////////////////////////////
  583.         virtual IChunkFile*  CreateChunkFile(bool bReadOnly = false);
  584.  
  585.         //////////////////////////////////////////////////////////////////////////
  586.         // Chunk file writer.
  587.         //////////////////////////////////////////////////////////////////////////
  588.         virtual ChunkFile::IChunkFileWriter* CreateChunkFileWriter(EChunkFileFormat eFormat, ICryPak* pPak, const char* filename) const;
  589.         virtual void                         ReleaseChunkFileWriter(ChunkFile::IChunkFileWriter* p) const;
  590.  
  591.         //////////////////////////////////////////////////////////////////////////
  592.         // Post processing effects interfaces
  593.  
  594.         virtual void   SetPostEffectParam(const char* pParam, float fValue, bool bForceValue = false) const;
  595.         virtual void   SetPostEffectParamVec4(const char* pParam, const Vec4& pValue, bool bForceValue = false) const;
  596.         virtual void   SetPostEffectParamString(const char* pParam, const char* pszArg) const;
  597.  
  598.         virtual void   GetPostEffectParam(const char* pParam, float& fValue) const;
  599.         virtual void   GetPostEffectParamVec4(const char* pParam, Vec4& pValue) const;
  600.         virtual void   GetPostEffectParamString(const char* pParam, const char*& pszArg) const;
  601.  
  602.         virtual int32  GetPostEffectID(const char* pPostEffectName);
  603.  
  604.         virtual void   ResetPostEffects(bool bOnSpecChange = false) const;
  605.  
  606.         virtual void   SetShadowsGSMCache(bool bCache);
  607.         virtual void   SetCachedShadowBounds(const AABB& shadowBounds, float fAdditionalCascadesScale);
  608.         virtual void   SetRecomputeCachedShadows(uint nUpdateStrategy = 0);
  609.         void           SetShadowsCascadesBias(const float* pCascadeConstBias, const float* pCascadeSlopeBias);
  610.         const float*   GetShadowsCascadesConstBias() const { return m_pShadowCascadeConstBias; }
  611.         const float*   GetShadowsCascadesSlopeBias() const { return m_pShadowCascadeSlopeBias; }
  612.         int            GetShadowsCascadeCount(const CDLight* pLight) const;
  613.  
  614.         virtual uint32 GetObjectsByType(EERType objType, IRenderNode** pObjects);
  615.         virtual uint32 GetObjectsByTypeInBox(EERType objType, const AABB& bbox, IRenderNode** pObjects);
  616.         virtual uint32 GetObjectsInBox(const AABB& bbox, IRenderNode** pObjects = 0);
  617.         virtual void   GetObjectsByTypeInBox(EERType objType, const AABB& bbox, PodArray<IRenderNode*>* pLstObjects);
  618.         virtual uint32 GetObjectsByFlags(uint dwFlags, IRenderNode** pObjects = 0);
  619.         virtual void   OnObjectModified(IRenderNode* pRenderNode, IRenderNode::RenderFlagsType dwFlags);
  620.  
  621.         virtual void   ActivateObjectsLayer(uint16 nLayerId, bool bActivate, bool bPhys, bool bObjects, bool bStaticLights, const char* pLayerName, IGeneralMemoryHeap* pHeap = NULL, bool bCheckLayerActivation = true);
  622.         bool           IsObjectsLayerHidden(uint16 nLayerId, const AABB& objBox);
  623.         virtual void   GetLayerMemoryUsage(uint16 nLayerId, ICrySizer* pSizer, int* pNumBrushes, int* pNumDecals) const;
  624.         virtual void   SkipLayerLoading(uint16 nLayerId, bool bClearList);
  625.         bool           IsLayerSkipped(uint16 nLayerId);
  626.         void           ObjectsTreeMarkAsUncompiled(const IRenderNode* pRenderNode);
  627.  
  628.         //////////////////////////////////////////////////////////////////////////
  629.  
  630.         virtual int  GetTerrainTextureNodeSizeMeters();
  631.         virtual int  GetTerrainTextureNodeSizePixels(int nLayer);
  632.  
  633.         virtual void SetTerrainLayerBaseTextureData(int nLayerId, byte* pImage, int nDim, const char* nImgFileName, IMaterial* pMat, float fBr, float fTiling, int nDetailSurfTypeId, float fTilingDetail, float fSpecularAmount, float fSortOrder, ColorF layerFilterColor, float fUseRemeshing, bool bShowSelection);
  634.         SImageInfo*  GetBaseTextureData(int nLayerId);
  635.         SImageInfo*  GetBaseTextureDataFromSurfType(int nSurfTypeId);
  636.  
  637.         const char*  GetLevelFolder() { return m_szLevelFolder; }
  638.  
  639.         bool         SaveCGF(std::vector<IStatObj*>& pObjs);
  640.  
  641.         virtual bool IsAreaActivationInUse() { return m_bAreaActivationInUse && GetCVars()->e_ObjectLayersActivation; }
  642.  
  643.         int          GetCurrentLightSpec()
  644.         {
  645.                 return CONFIG_VERYHIGH_SPEC; // very high spec.
  646.         }
  647.  
  648.         void         UpdateRenderingCamera(const char* szCallerName, const SRenderingPassInfo& passInfo);
  649.         virtual void PrepareOcclusion(const CCamera& rCamera);
  650.         virtual void EndOcclusion();
  651. #ifndef _RELEASE
  652.         void         ProcessStreamingLatencyTest(const CCamera& camIn, CCamera& camOut, const SRenderingPassInfo& passInfo);
  653. #endif
  654.  
  655.         void ScreenShotHighRes(CStitchedImage* pStitchedImage, const int nRenderFlags, const SRenderingPassInfo& passInfo, uint32 SliceCount, f32 fTransitionSize);
  656.  
  657.         // cylindrical mapping made by multiple slices rendered and distorted
  658.         // Returns:
  659.         //   true=mode is active, stop normal rendering, false=mode is not active
  660.         bool         ScreenShotPanorama(CStitchedImage* pStitchedImage, const int nRenderFlags, const SRenderingPassInfo& passInfo, uint32 SliceCount, f32 fTransitionSize);
  661.         // Render simple top-down screenshot for map overviews
  662.         bool         ScreenShotMap(CStitchedImage* pStitchedImage, const int nRenderFlags, const SRenderingPassInfo& passInfo, uint32 SliceCount, f32 fTransitionSize);
  663.  
  664.         void         ScreenshotDispatcher(const int nRenderFlags, const SRenderingPassInfo& passInfo);
  665.  
  666.         virtual void FillDebugFPSInfo(SDebugFPSInfo& info);
  667.  
  668.         void         ClearDebugFPSInfo(bool bUnload = false)
  669.         {
  670.                 m_fAverageFPS = 0.0f;
  671.                 m_fMinFPS = m_fMinFPSDecay = 999.f;
  672.                 m_fMaxFPS = m_fMaxFPSDecay = 0.0f;
  673.                 if (bUnload)
  674.                         stl::free_container(arrFPSforSaveLevelStats);
  675.                 else
  676.                         arrFPSforSaveLevelStats.clear();
  677.         }
  678.  
  679.         void ClearPrecacheInfo()
  680.         {
  681.                 m_nFramesSinceLevelStart = 0;
  682.                 m_nStreamingFramesSinceLevelStart = 0;
  683.                 m_bPreCacheEndEventSent = false;
  684.                 m_fTimeStateStarted = 0.0f;
  685.         }
  686.  
  687.         virtual const CCamera& GetRenderingCamera() const { return m_RenderingCamera; }
  688.         virtual float          GetZoomFactor() const      { return m_fZoomFactor; }
  689.         virtual float          IsZoomInProgress()  const  { return m_bZoomInProgress; }
  690.         virtual void           Tick();
  691.  
  692.         virtual void           UpdateShaderItems();
  693.         void                   GetCollisionClass(SCollisionClass& collclass, int tableIndex);
  694.  
  695.         virtual void           OffsetPosition(Vec3& delta);
  696.  
  697. public:
  698.         C3DEngine(ISystem* pSystem);
  699.         ~C3DEngine();
  700.  
  701.         virtual void RenderScene(const int nRenderFlags, const SRenderingPassInfo& passInfo);
  702.         virtual void DebugDraw_UpdateDebugNode();
  703.  
  704.         void         DebugDraw_Draw();
  705.         bool         IsOutdoorVisible();
  706.         void         RenderSkyBox(IMaterial* pMat, const SRenderingPassInfo& passInfo);
  707.         int          GetStreamingFramesSinceLevelStart() { return m_nStreamingFramesSinceLevelStart; }
  708.         int          GetRenderFramesSinceLevelStart()    { return m_nFramesSinceLevelStart; }
  709.  
  710.         bool CreateDecalInstance(const CryEngineDecalInfo &DecalInfo, class CDecal * pCallerManagedDecal);
  711.         //void CreateDecalOnCharacterComponents(ICharacterInstance * pChar, const struct CryEngineDecalInfo & decal);
  712.         Vec3 GetTerrainSurfaceNormal(Vec3 vPos);
  713.         void LoadEnvironmentSettingsFromXML(XmlNodeRef pInputNode, int nSID);
  714. #if defined(FEATURE_SVO_GI)
  715.         void LoadTISettings(XmlNodeRef pInputNode);
  716. #endif
  717.         void LoadDefaultAssets();
  718.  
  719.         // access to components
  720.         ILINE static CVars*            GetCVars()              { return m_pCVars; }
  721.         ILINE CVisAreaManager*         GetVisAreaManager()     { return m_pVisAreaManager; }
  722.         ILINE CClipVolumeManager*      GetClipVolumeManager()  { return m_pClipVolumeManager; }
  723.         ILINE PodArray<ILightSource*>* GetLightEntities()      { return &m_lstStaticLights; }
  724.  
  725.         ILINE IGeneralMemoryHeap*      GetBreakableBrushHeap() { return m_pBreakableBrushHeap; }
  726.  
  727.         virtual void                   OnCameraTeleport();
  728.  
  729.         // this data is stored in memory for instances streaming
  730.         std::vector<struct IStatObj*>* m_pLevelStatObjTable;
  731.         std::vector<IMaterial*>*       m_pLevelMaterialsTable;
  732.         bool                           m_bLevelFilesEndian;
  733.         struct SLayerActivityInfo
  734.         {
  735.                 SLayerActivityInfo() { objectsBox.Reset(); bActive = false; }
  736.                 AABB objectsBox;
  737.                 bool bActive;
  738.         };
  739.         PodArray<SLayerActivityInfo> m_arrObjectLayersActivity;
  740.  
  741.         bool                         m_bAreaActivationInUse;
  742.  
  743.         // Level info
  744.         float m_fSkyBoxAngle,
  745.               m_fSkyBoxStretching;
  746.  
  747.         float                 m_fMaxViewDistScale;
  748.         float                 m_fMaxViewDistHighSpec;
  749.         float                 m_fMaxViewDistLowSpec;
  750.         float                 m_fTerrainDetailMaterialsViewDistRatio;
  751.  
  752.         float                 m_volFogGlobalDensity;
  753.         float                 m_volFogGlobalDensityMultiplierLDR;
  754.         float                 m_volFogFinalDensityClamp;
  755.  
  756.         int                   m_nCurWind;         // Current wind-field buffer Id
  757.         SWindGrid             m_WindGrid[2];      // Wind field double-buffered
  758.         Vec2*                 m_pWindField;       // Old wind speed values for interpolation
  759.         int*                  m_pWindAreaFrames;  // Area frames for rest updates
  760.         Vec3                  m_vWindFieldCamera; // Wind field camera for interpolation
  761.         JobManager::SJobState m_WindJobState;
  762.         bool                  m_bWindJobRun;
  763.  
  764.         float                 m_fCloudShadingSunLightMultiplier;
  765.         float                 m_fCloudShadingSkyLightMultiplier;
  766.         Vec3                  m_vCloudShadingCustomSunColor;
  767.         Vec3                  m_vCloudShadingCustomSkyColor;
  768.  
  769.         Vec3                  m_vVolCloudAtmosphericScattering;
  770.         Vec3                  m_vVolCloudGenParams;
  771.         Vec3                  m_vVolCloudScatteringLow;
  772.         Vec3                  m_vVolCloudScatteringHigh;
  773.         Vec3                  m_vVolCloudGroundColor;
  774.         Vec3                  m_vVolCloudScatteringMulti;
  775.         Vec3                  m_vVolCloudWindAtmospheric;
  776.         Vec3                  m_vVolCloudTurbulence;
  777.         Vec3                  m_vVolCloudEnvParams;
  778.         Vec3                  m_vVolCloudGlobalNoiseScale;
  779.         Vec3                  m_vVolCloudRenderParams;
  780.         Vec3                  m_vVolCloudTurbulenceNoiseScale;
  781.         Vec3                  m_vVolCloudTurbulenceNoiseParams;
  782.         Vec3                  m_vVolCloudDensityParams;
  783.         Vec3                  m_vVolCloudMiscParams;
  784.         Vec3                  m_vVolCloudTilingSize;
  785.         Vec3                  m_vVolCloudTilingOffset;
  786.  
  787.         Vec3                  m_vFogColor;
  788.         Vec3                  m_vDefFogColor;
  789.         Vec3                  m_vSunDir;
  790.         Vec3                  m_vSunDirNormalized;
  791.         float                 m_fSunDirUpdateTime;
  792.         Vec3                  m_vSunDirRealtime;
  793.         Vec3                  m_vWindSpeed;
  794.  
  795.         Vec3                  m_volFogRamp;
  796.         Vec3                  m_volFogShadowRange;
  797.         Vec3                  m_volFogShadowDarkening;
  798.         Vec3                  m_volFogShadowEnable;
  799.  
  800.         Vec3                  m_volFog2CtrlParams;
  801.         Vec3                  m_volFog2ScatteringParams;
  802.         Vec3                  m_volFog2Ramp;
  803.         Vec3                  m_volFog2Color;
  804.         Vec3                  m_volFog2GlobalDensity;
  805.         Vec3                  m_volFog2HeightDensity;
  806.         Vec3                  m_volFog2HeightDensity2;
  807.         Vec3                  m_volFog2Color1;
  808.         Vec3                  m_volFog2Color2;
  809.  
  810.         Vec3                  m_nightSkyHorizonCol;
  811.         Vec3                  m_nightSkyZenithCol;
  812.         float                 m_nightSkyZenithColShift;
  813.         float                 m_nightSkyStarIntensity;
  814.         Vec3                  m_nightMoonCol;
  815.         float                 m_nightMoonSize;
  816.         Vec3                  m_nightMoonInnerCoronaCol;
  817.         float                 m_nightMoonInnerCoronaScale;
  818.         Vec3                  m_nightMoonOuterCoronaCol;
  819.         float                 m_nightMoonOuterCoronaScale;
  820.  
  821.         float                 m_moonRotationLatitude;
  822.         float                 m_moonRotationLongitude;
  823.         Vec3                  m_moonDirection;
  824.         int                   m_nWaterBottomTexId;
  825.         int                   m_nNightMoonTexId;
  826.         bool                  m_bShowTerrainSurface;
  827.         float                 m_fSunClipPlaneRange;
  828.         float                 m_fSunClipPlaneRangeShift;
  829.         bool                  m_bSunShadows;
  830.         bool                  m_bSunShadowsFromTerrain;
  831.  
  832.         int                   m_nCloudShadowTexId;
  833.  
  834.         float                 m_fGsmRange;
  835.         float                 m_fGsmRangeStep;
  836.         float                 m_fShadowsConstBias;
  837.         float                 m_fShadowsSlopeBias;
  838.  
  839.         int                   m_nSunAdditionalCascades;
  840.         int                   m_nGsmCache;
  841.         Vec3                  m_oceanFogColor;
  842.         Vec3                  m_oceanFogColorShallow;
  843.         float                 m_oceanFogDensity;
  844.         float                 m_skyboxMultiplier;
  845.         float                 m_dayNightIndicator;
  846.         bool                  m_bHeightMapAoEnabled;
  847.  
  848.         Vec3                  m_fogColor2;
  849.         Vec3                  m_fogColorRadial;
  850.         Vec3                  m_volFogHeightDensity;
  851.         Vec3                  m_volFogHeightDensity2;
  852.         Vec3                  m_volFogGradientCtrl;
  853.  
  854.         Vec3                  m_fogColorSkylightRayleighInScatter;
  855.  
  856.         float                 m_oceanCausticsDistanceAtten;
  857.         float                 m_oceanCausticsMultiplier;
  858.         float                 m_oceanCausticsDarkeningMultiplier;
  859.         float                 m_oceanCausticsTilling;
  860.         float                 m_oceanCausticHeight;
  861.         float                 m_oceanCausticDepth;
  862.         float                 m_oceanCausticIntensity;
  863.  
  864.         string                m_skyMatName;
  865.         string                m_skyLowSpecMatName;
  866.  
  867.         float                 m_oceanWindDirection;
  868.         float                 m_oceanWindSpeed;
  869.         float                 m_oceanWavesSpeed;
  870.         float                 m_oceanWavesAmount;
  871.         float                 m_oceanWavesSize;
  872.  
  873.         float                 m_dawnStart;
  874.         float                 m_dawnEnd;
  875.         float                 m_duskStart;
  876.         float                 m_duskEnd;
  877.  
  878.         // film characteristic curve tweakables
  879.         Vec4  m_vHDRFilmCurveParams;
  880.         Vec3  m_vHDREyeAdaptation;
  881.         Vec3  m_vHDREyeAdaptationLegacy;
  882.         float m_fHDRBloomAmount;
  883.  
  884.         // hdr color grading
  885.         Vec3  m_vColorBalance;
  886.         float m_fHDRSaturation;
  887.  
  888. #ifndef _RELEASE
  889.         CDebugDrawListMgr m_DebugDrawListMgr;
  890. #endif
  891.  
  892. #define MAX_SHADOW_CASCADES_NUM 20
  893.         float m_pShadowCascadeConstBias[MAX_SHADOW_CASCADES_NUM];
  894.         float m_pShadowCascadeSlopeBias[MAX_SHADOW_CASCADES_NUM];
  895.  
  896.         AABB  m_CachedShadowsBounds;
  897.         uint  m_nCachedShadowsUpdateStrategy;
  898.         float m_fCachedShadowsCascadeScale;
  899.  
  900.         // special case for combat mode adjustments
  901.         float m_fSaturation;
  902.         Vec4  m_pPhotoFilterColor;
  903.         float m_fPhotoFilterColorDensity;
  904.         float m_fGrainAmount;
  905.         float m_fSunSpecMult;
  906.  
  907.         // Level shaders
  908.         _smart_ptr<IMaterial> m_pTerrainWaterMat;
  909.         _smart_ptr<IMaterial> m_pSkyMat;
  910.         _smart_ptr<IMaterial> m_pSkyLowSpecMat;
  911.         _smart_ptr<IMaterial> m_pSunMat;
  912.  
  913.         // Fog Materials
  914.         _smart_ptr<IMaterial> m_pMatFogVolEllipsoid;
  915.         _smart_ptr<IMaterial> m_pMatFogVolBox;
  916.  
  917.         _smart_ptr<IShader>   m_pFarTreeSprites;
  918.  
  919.         void CleanLevelShaders()
  920.         {
  921.                 m_pTerrainWaterMat = 0;
  922.                 m_pSkyMat = 0;
  923.                 m_pSkyLowSpecMat = 0;
  924.                 m_pSunMat = 0;
  925.                 m_pFarTreeSprites = 0;
  926.  
  927.                 m_pMatFogVolEllipsoid = 0;
  928.                 m_pMatFogVolBox = 0;
  929.         }
  930.  
  931.         // Render elements
  932.         CRESky*    m_pRESky;
  933.         CREHDRSky* m_pREHDRSky;
  934.  
  935.         int        m_nDeferredLightsNum;
  936.  
  937. private:
  938.         // not sorted
  939.  
  940.         void  LoadTimeOfDaySettingsFromXML(XmlNodeRef node);
  941.         char* GetXMLAttribText(XmlNodeRef pInputNode, const char* szLevel1, const char* szLevel2, const char* szDefaultValue);
  942.         char* GetXMLAttribText(XmlNodeRef pInputNode, const char* szLevel1, const char* szLevel2, const char* szLevel3, const char* szDefaultValue);
  943.  
  944.         // without calling high level functions like panorama screenshot
  945.         void RenderInternal(const int nRenderFlags, const SRenderingPassInfo& passInfo, const char* szDebugName);
  946.  
  947.         void RegisterLightSourceInSectors(CDLight* pDynLight, int nSID, const SRenderingPassInfo& passInfo);
  948.  
  949.         bool IsCameraAnd3DEngineInvalid(const SRenderingPassInfo& passInfo, const char* szCaller);
  950.  
  951.         void DebugDrawStreaming(const SRenderingPassInfo& passInfo);
  952.         //////////////////////////////////////////////////////////////////////////
  953.         //////////////////////////////////////////////////////////////////////////
  954.  
  955.         void ResetCasterCombinationsCache();
  956.  
  957.         void FindPotentialLightSources(const SRenderingPassInfo& passInfo);
  958.         void DeleteAllStaticLightSources();
  959.         void LoadParticleEffects(const char* szFolderName);
  960.  
  961.         void UpdateSunLightSource(const SRenderingPassInfo& passInfo);
  962.  
  963.         // Query physics for physical air affecting area and create an optimized query structure for 3d engine
  964.         void UpdateWindAreas();
  965.  
  966.         void UpdateMoonDirection();
  967.  
  968.         // Copy objects from tree
  969.         void CopyObjectsByType(EERType objType, const AABB* pBox, PodArray<IRenderNode*>* plistObjects);
  970.         void CopyObjects(const AABB* pBox, PodArray<IRenderNode*>* plistObjects);
  971.  
  972.         void CleanUpOldDecals();
  973. public:
  974.         // functions SRenderingPass
  975.         virtual CCamera* GetRenderingPassCamera(const CCamera& rCamera);
  976.         virtual int      GetZoomMode() const;
  977.         virtual float    GetPrevZoomFactor();
  978.         virtual void     SetZoomMode(int nZoomMode);
  979.         virtual void     SetPrevZoomFactor(float fZoomFactor);
  980.  
  981. #if defined(FEATURE_SVO_GI)
  982.         virtual bool GetSvoStaticTextures(I3DEngine::SSvoStaticTexInfo& svoInfo, PodArray<I3DEngine::SLightTI>* pLightsTI_S, PodArray<I3DEngine::SLightTI>* pLightsTI_D);
  983.         virtual void GetSvoBricksForUpdate(PodArray<SSvoNodeInfo>& arrNodeInfo, float fNodeSize, PodArray<SVF_P3F_C4B_T2F>* pVertsOut);
  984. #endif
  985.         // LiveCreate
  986.         virtual void SaveInternalState(struct IDataWriteStream& writer, const AABB& filterArea, const bool bTerrain, const uint32 objectMask);
  987.         virtual void LoadInternalState(struct IDataReadStream& reader, const uint8* pVisibleLayersMask, const uint16* pLayerIdTranslation);
  988.  
  989.         void         SetupLightScissors(CDLight* pLight, const SRenderingPassInfo& passInfo);
  990.         bool         IsTerrainTextureStreamingInProgress() { return m_bTerrainTextureStreamingInProgress; }
  991.  
  992.         bool         IsTerrainSyncLoad()                   { return m_bContentPrecacheRequested && GetCVars()->e_AutoPrecacheTerrainAndProcVeget; }
  993.         bool         IsShadersSyncLoad()                   { return m_bContentPrecacheRequested && GetCVars()->e_AutoPrecacheTexturesAndShaders; }
  994.         bool         IsStatObjSyncLoad()                   { return m_bContentPrecacheRequested && GetCVars()->e_AutoPrecacheCgf; }
  995.         float        GetAverageCameraSpeed()               { return m_fAverageCameraSpeed; }
  996.         Vec3         GetAverageCameraMoveDir()             { return m_vAverageCameraMoveDir; }
  997.  
  998.         typedef std::map<uint64, int> ShadowFrustumListsCacheUsers;
  999.         ShadowFrustumListsCacheUsers m_FrustumsCacheUsers[2];
  1000.  
  1001.         class CStatObjFoliage*       m_pFirstFoliage, * m_pLastFoliage;
  1002.         PodArray<SEntInFoliage>      m_arrEntsInFoliage;
  1003.         void RemoveEntInFoliage(int i, IPhysicalEntity* pent = 0);
  1004.  
  1005.         PodArray<class CRoadRenderNode*> m_lstRoadRenderNodesForUpdate;
  1006.  
  1007.         struct ILightSource*            GetSunEntity();
  1008.         PodArray<struct ILightSource*>* GetAffectingLights(const AABB& bbox, bool bAllowSun, const SRenderingPassInfo& passInfo);
  1009.         void                            UregisterLightFromAccessabilityCache(ILightSource* pLight);
  1010.         void                            OnCasterDeleted(IShadowCaster* pCaster);
  1011.  
  1012.         virtual void                    ResetCoverageBufferSignalVariables();
  1013.  
  1014.         void                            UpdateScene(const SRenderingPassInfo& passInfo);
  1015.         void                            UpdateLightSources(const SRenderingPassInfo& passInfo);
  1016.         void                            PrepareLightSourcesForRendering_0(const SRenderingPassInfo& passInfo);
  1017.         void                            PrepareLightSourcesForRendering_1(const SRenderingPassInfo& passInfo);
  1018.         void                            InitShadowFrustums(const SRenderingPassInfo& passInfo);
  1019.  
  1020.         ///////////////////////////////////////////////////////////////////////////////
  1021.  
  1022.         virtual void            GetLightVolumes(threadID nThreadID, SLightVolume*& pLightVols, uint32& nNumVols);
  1023.         const CLightVolumesMgr& GetLightVolumeManager() const { return m_LightVolumesMgr; }
  1024.         CLightVolumesMgr&       GetLightVolumeManager()       { return m_LightVolumesMgr; }
  1025.  
  1026.         ///////////////////////////////////////////////////////////////////////////////
  1027.  
  1028.         void                        FreeLightSourceComponents(CDLight* pLight, bool bDeleteLight = true);
  1029.         void                        RemoveEntityLightSources(IRenderNode* pEntity);
  1030.  
  1031.         void                        CheckPhysicalized(const Vec3& vBoxMin, const Vec3& vBoxMax);
  1032.  
  1033.         virtual PodArray<CDLight*>* GetDynamicLightSources() { return &m_lstDynLights; }
  1034.  
  1035.         int                         GetRealLightsNum()       { return m_nRealLightsNum; }
  1036.         void                        SetupClearColor();
  1037.         void                        CheckAddLight(CDLight* pLight, const SRenderingPassInfo& passInfo);
  1038.  
  1039.         void                        DrawTextRightAligned(const float x, const float y, const char* format, ...) PRINTF_PARAMS(4, 5);
  1040.         void                        DrawTextRightAligned(const float x, const float y, const float scale, const ColorF& color, const char* format, ...) PRINTF_PARAMS(6, 7);
  1041.         void                        DrawTextLeftAligned(const float x, const float y, const float scale, const ColorF& color, const char* format, ...) PRINTF_PARAMS(6, 7);
  1042.         void                        DrawTextAligned(int flags, const float x, const float y, const float scale, const ColorF& color, const char* format, ...) PRINTF_PARAMS(7, 8);
  1043.  
  1044.         float                       GetLightAmount(CDLight* pLight, const AABB& objBox);
  1045.  
  1046.         IStatObj*                   CreateStatObj();
  1047.         virtual IStatObj*           CreateStatObjOptionalIndexedMesh(bool createIndexedMesh);
  1048.  
  1049.         IStatObj*                   UpdateDeformableStatObj(IGeometry* pPhysGeom, bop_meshupdate* pLastUpdate = 0, IFoliage* pSrcFoliage = 0);
  1050.  
  1051.         // Creates a new indexed mesh.
  1052.         IIndexedMesh*                 CreateIndexedMesh();
  1053.  
  1054.         void                          InitMaterialDefautMappingAxis(IMaterial* pMat);
  1055.  
  1056.         virtual ITerrain*             GetITerrain()             { return (ITerrain*)m_pTerrain; }
  1057.         virtual IVisAreaManager*      GetIVisAreaManager()      { return (IVisAreaManager*)m_pVisAreaManager; }
  1058.         virtual IMergedMeshesManager* GetIMergedMeshesManager() { return (IMergedMeshesManager*)m_pMergedMeshesManager; }
  1059.  
  1060.         virtual ITerrain*             CreateTerrain(const STerrainInfo& TerrainInfo);
  1061.         void                          DeleteTerrain();
  1062.         bool                          LoadTerrain(XmlNodeRef pDoc, std::vector<struct IStatObj*>** ppStatObjTable, std::vector<IMaterial*>** ppMatTable, int nSID, Vec3 vSegmentOrigin);
  1063.         bool                          LoadVisAreas(std::vector<struct IStatObj*>** ppStatObjTable, std::vector<IMaterial*>** ppMatTable);
  1064.         bool                          LoadUsedShadersList();
  1065.         bool                          PrecreateDecals();
  1066.         void                          LoadPhysicsData();
  1067.         void                          UnloadPhysicsData();
  1068.         void                          LoadFlaresData();
  1069.         void                          FreeFoliages();
  1070.  
  1071.         void                          LoadCollisionClasses(XmlNodeRef node);
  1072.  
  1073.         virtual float                 GetLightAmountInRange(const Vec3& pPos, float fRange, bool bAccurate = 0);
  1074.  
  1075.         virtual void                  PrecacheLevel(bool bPrecacheAllVisAreas, Vec3* pPrecachePoints, int nPrecachePointsNum);
  1076.         virtual void                  ProposeContentPrecache()     { m_bContentPrecacheRequested = true; }
  1077.         bool                          IsContentPrecacheRequested() { return m_bContentPrecacheRequested; }
  1078.  
  1079.         virtual ITimeOfDay*           GetTimeOfDay();
  1080.         //! [GDC09]: Return SkyBox material
  1081.         virtual IMaterial*            GetSkyMaterial();
  1082.         virtual void                  SetSkyMaterial(IMaterial* pSkyMat);
  1083.         bool                          IsHDRSkyMaterial(IMaterial* pMat) const;
  1084.  
  1085.         using I3DEngine::SetGlobalParameter;
  1086.         virtual void                     SetGlobalParameter(E3DEngineParameter param, const Vec3& v);
  1087.         using I3DEngine::GetGlobalParameter;
  1088.         virtual void                     GetGlobalParameter(E3DEngineParameter param, Vec3& v);
  1089.         virtual void                     SetShadowMode(EShadowMode shadowMode) { m_eShadowMode = shadowMode; }
  1090.         virtual EShadowMode              GetShadowMode() const                 { return m_eShadowMode; }
  1091.         virtual void                     AddPerObjectShadow(IShadowCaster* pCaster, float fConstBias, float fSlopeBias, float fJitter, const Vec3& vBBoxScale, uint nTexSize);
  1092.         virtual void                     RemovePerObjectShadow(IShadowCaster* pCaster);
  1093.         virtual struct SPerObjectShadow* GetPerObjectShadow(IShadowCaster* pCaster);
  1094.         virtual void                     GetCustomShadowMapFrustums(ShadowMapFrustum**& arrFrustums, int& nFrustumCount);
  1095.         virtual int                      SaveStatObj(IStatObj* pStatObj, TSerialize ser);
  1096.         virtual IStatObj*                LoadStatObj(TSerialize ser);
  1097.  
  1098.         virtual bool                     CheckIntersectClouds(const Vec3& p1, const Vec3& p2);
  1099.         virtual void                     OnRenderMeshDeleted(IRenderMesh* pRenderMesh);
  1100.         virtual bool                     RenderMeshRayIntersection(IRenderMesh* pRenderMesh, SRayHitInfo& hitInfo, IMaterial* pCustomMtl = 0);
  1101.  
  1102.         virtual const char*              GetVoxelEditOperationName(EVoxelEditOperation eOperation);
  1103.  
  1104.         virtual void                     SetGetLayerIdAtCallback(IGetLayerIdAtCallback* pCallBack) { m_pGetLayerIdAtCallback = pCallBack; }
  1105.         static IGetLayerIdAtCallback* m_pGetLayerIdAtCallback;
  1106.  
  1107.         virtual IParticleManager* GetParticleManager() { return m_pPartManager; }
  1108.         virtual IOpticsManager*   GetOpticsManager()   { return m_pOpticsManager; }
  1109.  
  1110.         virtual void              RegisterForStreaming(IStreamable* pObj);
  1111.         virtual void              UnregisterForStreaming(IStreamable* pObj);
  1112.  
  1113.         virtual void              PrecacheCharacter(IRenderNode* pObj, const float fImportance, ICharacterInstance* pCharacter, IMaterial* pSlotMat, const Matrix34& matParent, const float fEntDistance, const float fScale, int nMaxDepth, bool bForceStreamingSystemUpdate, const SRenderingPassInfo& passInfo);
  1114.         virtual void              PrecacheRenderNode(IRenderNode* pObj, float fEntDistanceReal);
  1115.  
  1116.         void                      MarkRNTmpDataPoolForReset() { m_bResetRNTmpDataPool = true; }
  1117.  
  1118.         static void               GetObjectsByTypeGlobal(PodArray<IRenderNode*>& lstObjects, EERType objType, const AABB* pBBox, bool* pInstStreamReady = NULL, uint64 dwFlags = ~0);
  1119.         static void               MoveObjectsIntoListGlobal(PodArray<SRNInfo>* plstResultEntities, const AABB* pAreaBox, bool bRemoveObjects = false, bool bSkipDecals = false, bool bSkip_ERF_NO_DECALNODE_DECALS = false, bool bSkipDynamicObjects = false, EERType eRNType = eERType_TypesNum);
  1120.  
  1121.         virtual ISegmentsManager* GetSegmentsManager() { return m_pSegmentsManager; };
  1122.         virtual void              SetSegmentsManager(ISegmentsManager* pSegmentsManager);
  1123.         virtual bool              IsSegmentOperationInProgress();
  1124.         virtual void              SetSegmentOperationInProgress(bool bActive);
  1125.  
  1126.         // Returns true if the segment is completely loaded and prepared to be used/rendered/whatever in game.
  1127.         // If this returns false, DO NOT TOUCH THE SEGMENT OR ANYTHING IN IT. It is probably being streamed in
  1128.         // a background thread and you will race all over its internal structures.
  1129.         inline bool IsSegmentSafeToUse(int nSID)
  1130.         {
  1131. #ifdef SEG_WORLD
  1132.                 return m_safeToUseSegments[nSID] != 0;
  1133. #else
  1134.                 return !m_pObjectsTree.empty() && m_pObjectsTree[nSID] != NULL;
  1135. #endif
  1136.         }
  1137.  
  1138.         void         CreateRenderNodeTempData(SRenderNodeTempData** ppInfo, IRenderNode* pRNode, const SRenderingPassInfo& passInfo);
  1139.         bool         CheckAndCreateRenderNodeTempData(SRenderNodeTempData** ppTempData, IRenderNode* pRNode, const SRenderingPassInfo& passInfo);
  1140.  
  1141.         void         UpdateRNTmpDataPool(bool bFreeAll);
  1142.  
  1143.         void         UpdateStatInstGroups();
  1144.         void         UpdateRenderTypeEnableLookup();
  1145.         void         ProcessOcean(const SRenderingPassInfo& passInfo);
  1146.         void         ReRegisterKilledVegetationInstances();
  1147.         Vec3         GetEntityRegisterPoint(IRenderNode* pEnt);
  1148.  
  1149.         virtual void RenderRenderNode_ShadowPass(IShadowCaster* pRNode, const SRenderingPassInfo& passInfo);
  1150.         void         ProcessCVarsChange();
  1151.         ILINE int    GetGeomDetailScreenRes()
  1152.         {
  1153.                 if (GetCVars()->e_ForceDetailLevelForScreenRes)
  1154.                 {
  1155.                         return GetCVars()->e_ForceDetailLevelForScreenRes;
  1156.                 }
  1157.                 else if (GetRenderer())
  1158.                 {
  1159.                         return GetRenderer()->GetWidth();
  1160.                 }
  1161.                 return 1;
  1162.         }
  1163.  
  1164.         int                                   GetBlackTexID()   { return m_nBlackTexID; }
  1165.         int                                   GetBlackCMTexID() { return m_nBlackCMTexID; }
  1166.         int                                   GetWhiteTexID()   { return m_nWhiteTexID; }
  1167.  
  1168.         virtual void                          SyncProcessStreamingUpdate();
  1169.  
  1170.         virtual void                          SetScreenshotCallback(IScreenshotCallback* pCallback);
  1171.  
  1172.         virtual IDeferredPhysicsEventManager* GetDeferredPhysicsEventManager() { return m_pDeferredPhysicsEventManager; }
  1173.  
  1174.         void                                  PrintDebugInfo(const SRenderingPassInfo& passInfo);
  1175.  
  1176. public:
  1177.         //////////////////////////////////////////////////////////////////////////
  1178.         // PUBLIC DATA
  1179.         //////////////////////////////////////////////////////////////////////////
  1180.         PodArray<class COctreeNode*> m_pObjectsTree;
  1181.         PodArray<char>               m_safeToUseSegments;
  1182.         //  class CSceneTree * m_pSceneTree;
  1183.  
  1184.         int                            m_idMatLeaves; // for shooting foliages
  1185.         bool                           m_bResetRNTmpDataPool;
  1186.  
  1187.         float                          m_fRefreshSceneDataCVarsSumm;
  1188.         int                            m_nRenderTypeEnableCVarSum;
  1189.  
  1190.         PodArray<IRenderNode*>         m_lstAlwaysVisible;
  1191.         PodArray<IRenderNode*>         m_lstKilledVegetations;
  1192.         PodArray<SPerObjectShadow>     m_lstPerObjectShadows;
  1193.         std::vector<ShadowMapFrustum*> m_lstCustomShadowFrustums;
  1194.         int                            m_nCustomShadowFrustumCount;
  1195.  
  1196.         PodArray<SImageInfo>           m_arrBaseTextureData;
  1197.  
  1198.         ISegmentsManager*              m_pSegmentsManager;
  1199.  
  1200.         bool                           m_bInShutDown;
  1201.         bool                           m_bInUnload;
  1202.         bool                           m_bInLoad;
  1203.  
  1204. private:
  1205.         //////////////////////////////////////////////////////////////////////////
  1206.         // PRIVATE DATA
  1207.         //////////////////////////////////////////////////////////////////////////
  1208.         struct CLightEntity* m_pSun;
  1209.  
  1210.         std::vector<byte>    arrFPSforSaveLevelStats;
  1211.         PodArray<float>      m_arrProcessStreamingLatencyTestResults;
  1212.         PodArray<int>        m_arrProcessStreamingLatencyTexNum;
  1213.  
  1214.         // fields which are used by SRenderingPass to store over frame information
  1215.         CThreadSafeRendererContainer<CCamera> m_RenderingPassCameras[2];                 // camera storage for SRenderingPass, the cameras cannot be stored on stack to allow job execution
  1216.  
  1217.         float m_fZoomFactor;                                // zoom factor of m_RenderingCamera
  1218.         float m_fPrevZoomFactor;                            // zoom factor of m_RenderingCamera from last frame
  1219.         bool  m_bZoomInProgress;                            // indicates if the RenderingCamera is currently zooming
  1220.         int   m_nZoomMode;                                  // the zoom level of the camera (0-4) 0: no zoom, 4: full zoom
  1221.  
  1222.         // cameras used by 3DEngine
  1223.         CCamera                m_RenderingCamera;           // Camera used for Rendering on 3DEngine Side, normaly equal to the viewcamera, except if frozen with e_camerafreeze
  1224.  
  1225.         PodArray<IRenderNode*> m_deferredRenderProxyStreamingPriorityUpdates;     // deferred streaming priority updates for newly seen CRenderProxies
  1226.  
  1227.         float                  m_fLightsHDRDynamicPowerFactor; // lights hdr exponent/exposure
  1228.  
  1229.         int                    m_nBlackTexID;
  1230.         int                    m_nBlackCMTexID;
  1231.         int                    m_nWhiteTexID;
  1232.  
  1233.         char                   m_sGetLevelFilePathTmpBuff[MAX_PATH_LENGTH];
  1234.         char                   m_szLevelFolder[_MAX_PATH];
  1235.  
  1236.         bool                   m_bOcean; // todo: remove
  1237.  
  1238.         Vec3                   m_vSkyHightlightPos;
  1239.         Vec3                   m_vSkyHightlightCol;
  1240.         float                  m_fSkyHighlightSize;
  1241.         Vec3                   m_vAmbGroundCol;
  1242.         float                  m_fAmbMaxHeight;
  1243.         float                  m_fAmbMinHeight;
  1244.         IPhysicalEntity*       m_pGlobalWind;
  1245.         uint8                  m_nOceanRenderFlags;
  1246.         Vec3                   m_vPrevMainFrameCamPos;
  1247.         float                  m_fAverageCameraSpeed;
  1248.         Vec3                   m_vAverageCameraMoveDir;
  1249.         EShadowMode            m_eShadowMode;
  1250.         bool                   m_bLayersActivated;
  1251.         bool                   m_bContentPrecacheRequested;
  1252.         bool                   m_bTerrainTextureStreamingInProgress;
  1253.         bool                   m_bSegmentOperationInProgress;
  1254.  
  1255.         // interfaces
  1256.         IPhysMaterialEnumerator* m_pPhysMaterialEnumerator;
  1257.  
  1258.         // data containers
  1259.         PodArray<CDLight*>                        m_lstDynLights;
  1260.         PodArray<CDLight*>                        m_lstDynLightsNoLight;
  1261.         int                                       m_nRealLightsNum;
  1262.  
  1263.         PodArray<ILightSource*>                   m_lstStaticLights;
  1264.         PodArray<PodArray<struct ILightSource*>*> m_lstAffectingLightsCombinations;
  1265.         PodArray<CDLight*>                        m_tmpLstLights;
  1266.         PodArray<struct ILightSource*>            m_tmpLstAffectingLights;
  1267.  
  1268.         PodArray<SCollisionClass>                 m_collisionClasses;
  1269.  
  1270. #define MAX_LIGHTS_NUM 32
  1271.         PodArray<CCamera> m_arrLightProjFrustums;
  1272.  
  1273.         class CTimeOfDay* m_pTimeOfDay;
  1274.  
  1275.         ICVar*            m_pLightQuality;
  1276.  
  1277.         // FPS for savelevelstats
  1278.  
  1279.         float                          m_fAverageFPS;
  1280.         float                          m_fMinFPS, m_fMinFPSDecay;
  1281.         float                          m_fMaxFPS, m_fMaxFPSDecay;
  1282.         int                            m_nFramesSinceLevelStart;
  1283.         int                            m_nStreamingFramesSinceLevelStart;
  1284.         bool                           m_bPreCacheEndEventSent;
  1285.         float                          m_fTimeStateStarted;
  1286.         uint32                         m_nRenderWorldUSecs;
  1287.         SFrameLodInfo                  m_frameLodInfo;
  1288.  
  1289.         ITexture*                      m_ptexIconLowMemoryUsage;
  1290.         ITexture*                      m_ptexIconAverageMemoryUsage;
  1291.         ITexture*                      m_ptexIconHighMemoryUsage;
  1292.         ITexture*                      m_ptexIconEditorConnectedToConsole;
  1293.  
  1294.         std::vector<IDecalRenderNode*> m_decalRenderNodes; // list of registered decal render nodes, used to clean up longer not drawn decals
  1295.  
  1296.         SImageSubInfo* RegisterImageInfo(byte** pMips, int nDim, const char* pName);
  1297.         SImageSubInfo* GetImageInfo(const char* pName);
  1298.         std::map<string, SImageSubInfo*>       m_imageInfos;
  1299.         byte**         AllocateMips(byte* pImage, int nDim, byte** pImageMips);
  1300.         IScreenshotCallback*                   m_pScreenshotCallback;
  1301.         OcclusionTestClient                    m_OceanOcclTestVar;
  1302.  
  1303.         IDeferredPhysicsEventManager*          m_pDeferredPhysicsEventManager;
  1304.  
  1305.         std::set<uint16>                       m_skipedLayers;
  1306.  
  1307.         IGeneralMemoryHeap*                    m_pBreakableBrushHeap;
  1308.  
  1309.         CVisibleRenderNodesManager             m_visibleNodesManager;
  1310.  
  1311.         int                                    m_nCurrentWindAreaList;
  1312.         std::vector<SOptimizedOutdoorWindArea> m_outdoorWindAreas[2];
  1313.         std::vector<SOptimizedOutdoorWindArea> m_indoorWindAreas[2];
  1314.  
  1315.         CLightVolumesMgr                       m_LightVolumesMgr;
  1316.  
  1317.         std::unique_ptr<CWaterRippleManager>   m_pWaterRippleManager;
  1318.  
  1319.         friend struct SRenderNodeTempData;
  1320. };
  1321.  
  1322. #endif // C3DENGINE_H
  1323.  
download3dEngine.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