BVB Source Codes

CRYENGINE Show Cry3DEngineBase.h Source code

Return Download CRYENGINE: download Cry3DEngineBase.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:   cry3denginebase.h
  5. //  Version:     v1.00
  6. //  Created:     28/5/2001 by Vladimir Kajalin
  7. //  Compilers:   Visual Studio.NET
  8. //  Description: Access to external stuff used by 3d engine. Most 3d engine classes
  9. //               are derived from this base class to access other interfaces
  10. // -------------------------------------------------------------------------
  11. //  History:
  12. //
  13. ////////////////////////////////////////////////////////////////////////////
  14.  
  15. #ifndef _Cry3DEngineBase_h_
  16. #define _Cry3DEngineBase_h_
  17.  
  18. #include "3DEngineMemory.h"
  19.  
  20. struct ISystem;
  21. struct IRenderer;
  22. struct ILog;
  23. struct IPhysicalWorld;
  24. struct ITimer;
  25. struct IConsole;
  26. struct I3DEngine;
  27. struct CVars;
  28. struct CVisAreaManager;
  29. namespace pfx2{
  30. struct IParticleSystem;
  31. }
  32. class CTerrain;
  33. class CIndirectLighting;
  34. class CObjManager;
  35. class C3DEngine;
  36. class CParticleManager;
  37. class CDecalManager;
  38. class CRainManager;
  39. class CCloudsManager;
  40. class CSkyLightManager;
  41. class CWaterWaveManager;
  42. class CRenderMeshMerger;
  43. class CMergedMeshesManager;
  44. class CGeomCacheManager;
  45. class CBreezeGenerator;
  46. class CMatMan;
  47. class CClipVolumeManager;
  48.  
  49. #define DISTANCE_TO_THE_SUN 1000000
  50.  
  51. #if !defined(_RELEASE) || defined(ENABLE_STATOSCOPE_RELEASE)
  52.         #define OBJMAN_STREAM_STATS
  53. #endif
  54.  
  55. struct Cry3DEngineBase
  56. {
  57.         static ISystem*                               m_pSystem;
  58. #if !defined(DEDICATED_SERVER)
  59.         static IRenderer*                             m_pRenderer;
  60. #else
  61.         static IRenderer* const                       m_pRenderer;
  62. #endif
  63.         static ITimer*                                m_pTimer;
  64.         static ILog*                                  m_pLog;
  65.         static IPhysicalWorld*                        m_pPhysicalWorld;
  66.         static IConsole*                              m_pConsole;
  67.         static C3DEngine*                             m_p3DEngine;
  68.         static CVars*                                 m_pCVars;
  69.         static ICryPak*                               m_pCryPak;
  70.         static CObjManager*                           m_pObjManager;
  71.         static CTerrain*                              m_pTerrain;
  72.         static IParticleManager*                      m_pPartManager;
  73.         static std::shared_ptr<pfx2::IParticleSystem> m_pParticleSystem;
  74.         static IOpticsManager*                        m_pOpticsManager;
  75.         static CDecalManager*                         m_pDecalManager;
  76.         static CCloudsManager*                        m_pCloudsManager;
  77.         static CVisAreaManager*                       m_pVisAreaManager;
  78.         static CClipVolumeManager*                    m_pClipVolumeManager;
  79.         static CMatMan*                               m_pMatMan;
  80.         static CSkyLightManager*                      m_pSkyLightManager;
  81.         static CWaterWaveManager*                     m_pWaterWaveManager;
  82.         static CRenderMeshMerger*                     m_pRenderMeshMerger;
  83.         static CMergedMeshesManager*                  m_pMergedMeshesManager;
  84.         static CBreezeGenerator*                      m_pBreezeGenerator;
  85.         static IStreamedObjectListener*               m_pStreamListener;
  86. #if defined(USE_GEOM_CACHES)
  87.         static CGeomCacheManager*                     m_pGeomCacheManager;
  88. #endif
  89.  
  90.         static bool              m_bProfilerEnabled;
  91.         static threadID          m_nMainThreadId;
  92.         static bool              m_bLevelLoadingInProgress;
  93.         static bool              m_bIsInRenderScene;
  94.         static bool              m_bAsyncOctreeUpdates;
  95.         static bool              m_bRenderTypeEnabled[eERType_TypesNum];
  96.         static int               m_mergedMeshesPoolSize;
  97.  
  98.         static ESystemConfigSpec m_LightConfigSpec;
  99. #if CRY_PLATFORM_DESKTOP
  100.         static bool              m_bEditor;
  101. #else
  102.         static const bool        m_bEditor = false;
  103. #endif
  104.         static int               m_arrInstancesCounter[eERType_TypesNum];
  105.  
  106.         // components access
  107.         ILINE static ISystem*            GetSystem()                 { return m_pSystem; }
  108.         ILINE static IRenderer*          GetRenderer()               { return m_pRenderer; }
  109.         ILINE static ITimer*             GetTimer()                  { return m_pTimer; }
  110.         ILINE static ILog*               GetLog()                    { return m_pLog; }
  111.  
  112.         inline static IPhysicalWorld*    GetPhysicalWorld()          { return m_pPhysicalWorld; }
  113.         inline static IConsole*          GetConsole()                { return m_pConsole; }
  114.         inline static C3DEngine*         Get3DEngine()               { return m_p3DEngine; }
  115.         inline static CObjManager*       GetObjManager()             { return m_pObjManager; };
  116.         inline static CTerrain*          GetTerrain()                { return m_pTerrain; };
  117.         inline static CVars*             GetCVars()                  { return m_pCVars; }
  118.         inline static CVisAreaManager*   GetVisAreaManager()         { return m_pVisAreaManager; }
  119.         inline static ICryPak*           GetPak()                    { return m_pCryPak; }
  120.         inline static CMatMan*           GetMatMan()                 { return m_pMatMan; }
  121.         inline static CCloudsManager*    GetCloudsManager()          { return m_pCloudsManager; }
  122.         inline static CWaterWaveManager* GetWaterWaveManager()       { return m_pWaterWaveManager; };
  123.         inline static CRenderMeshMerger* GetSharedRenderMeshMerger() { return m_pRenderMeshMerger; };
  124.         inline static CTemporaryPool*    GetTemporaryPool()          { return CTemporaryPool::Get(); };
  125.  
  126. #if defined(USE_GEOM_CACHES)
  127.         inline static CGeomCacheManager* GetGeomCacheManager() { return m_pGeomCacheManager; };
  128. #endif
  129.  
  130.         inline static int GetMergedMeshesPoolSize()                               { return m_mergedMeshesPoolSize; }
  131.         ILINE static bool IsRenderNodeTypeEnabled(EERType rnType)                 { return m_bRenderTypeEnabled[(int)rnType]; }
  132.         ILINE static void SetRenderNodeTypeEnabled(EERType rnType, bool bEnabled) { m_bRenderTypeEnabled[(int)rnType] = bEnabled; }
  133.  
  134.         inline static int GetDefSID()                                             { return DEFAULT_SID; };
  135.  
  136.         static float      GetCurTimeSec();
  137.         static float      GetCurAsyncTimeSec();
  138.  
  139.         static void       PrintMessage(const char* szText, ...) PRINTF_PARAMS(1, 2);
  140.         static void       PrintMessagePlus(const char* szText, ...) PRINTF_PARAMS(1, 2);
  141.         static void       PrintComment(const char* szText, ...) PRINTF_PARAMS(1, 2);
  142.  
  143.         // Validator warning.
  144.         static void    Warning(const char* format, ...) PRINTF_PARAMS(1, 2);
  145.         static void    Error(const char* format, ...) PRINTF_PARAMS(1, 2);
  146.         static void    FileWarning(int flags, const char* file, const char* format, ...) PRINTF_PARAMS(3, 4);
  147.  
  148.         CRenderObject* GetIdentityCRenderObject(int nThreadID)
  149.         {
  150.                 CRenderObject* pCRenderObject = GetRenderer()->EF_GetObject_Temp(nThreadID);
  151.                 if (!pCRenderObject)
  152.                         return NULL;
  153.                 pCRenderObject->m_II.m_Matrix.SetIdentity();
  154.                 return pCRenderObject;
  155.         }
  156.  
  157.         static bool IsValidFile(const char* sFilename);
  158.         static bool IsResourceLocked(const char* sFilename);
  159.  
  160.         static bool IsPreloadEnabled();
  161.  
  162.         IMaterial*  MakeSystemMaterialFromShader(const char* sShaderName, SInputShaderResources* Res = NULL);
  163.         static void DrawBBoxLabeled(const AABB& aabb, const Matrix34& m34, const ColorB& col, const char* format, ...) PRINTF_PARAMS(4, 5);
  164.         static void DrawBBox(const Vec3& vMin, const Vec3& vMax, ColorB col = Col_White);
  165.         static void DrawBBox(const AABB& box, ColorB col = Col_White);
  166.         static void DrawLine(const Vec3& vMin, const Vec3& vMax, ColorB col = Col_White);
  167.         static void DrawSphere(const Vec3& vPos, float fRadius, ColorB color = ColorB(255, 255, 255, 255));
  168.         static void DrawQuad(const Vec3& v0, const Vec3& v1, const Vec3& v2, const Vec3& v3, ColorB color);
  169.  
  170.         int&        GetInstCount(EERType eType)                            { return m_arrInstancesCounter[eType]; }
  171.  
  172.         uint32      GetMinSpecFromRenderNodeFlags(uint64 dwRndFlags) const { return (dwRndFlags & ERF_SPEC_BITS_MASK) >> ERF_SPEC_BITS_SHIFT; }
  173.         static bool CheckMinSpec(uint32 nMinSpec);
  174.  
  175.         static bool IsEscapePressed();
  176.  
  177.         size_t      fread(
  178.           void* buffer,
  179.           size_t elementSize,
  180.           size_t count,
  181.           FILE* stream)
  182.         {
  183.                 size_t res = ::fread(buffer, elementSize, count, stream);
  184.                 if (res != count)
  185.                         Error("fread() failed");
  186.                 return res;
  187.         }
  188.  
  189.         int fseek(
  190.           FILE* stream,
  191.           long offset,
  192.           int whence
  193.           )
  194.         {
  195.                 int res = ::fseek(stream, offset, whence);
  196.                 if (res != 0)
  197.                         Error("fseek() failed");
  198.                 return res;
  199.         }
  200.  
  201. };
  202.  
  203. #endif // _Cry3DEngineBase_h_
  204.  
downloadCry3DEngineBase.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