BVB Source Codes

CRYENGINE Show GameSerializeHelpers.h Source code

Return Download CRYENGINE: download GameSerializeHelpers.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __GAME_SERIALIZE_HELPERS_H__
  4. #define __GAME_SERIALIZE_HELPERS_H__
  5.  
  6. #include "CryActionCVars.h"
  7.  
  8. // Some Helpers
  9. // Checkpoint for easy section timing
  10. struct Checkpoint
  11. {
  12.         // if msg is given (const char ptr!), auto-message on d'tor
  13.         Checkpoint(bool bOutput, const char* msg = 0) : m_bOutput(bOutput), m_szMsg(msg)
  14.         {
  15.                 Start();
  16.         }
  17.  
  18.         ~Checkpoint()
  19.         {
  20.                 if (m_szMsg)
  21.                 {
  22.                         Check(m_szMsg);
  23.                 }
  24.         }
  25.         void Start()
  26.         {
  27.                 m_startTime = gEnv->pTimer->GetAsyncTime();
  28.         }
  29.  
  30.         CTimeValue End()
  31.         {
  32.                 return gEnv->pTimer->GetAsyncTime() - m_startTime;
  33.         }
  34.         CTimeValue Check(const char* msg)
  35.         {
  36.                 CTimeValue elapsed = End();
  37.                 if (m_bOutput && msg && CCryActionCVars::Get().g_saveLoadExtendedLog != 0)
  38.                         CryLog("Checkpoint %12s : %.4f ms", msg, elapsed.GetMilliSeconds());
  39.                 Start();
  40.                 return elapsed;
  41.         }
  42.         CTimeValue  m_startTime;
  43.         bool        m_bOutput;
  44.         const char* m_szMsg;
  45. };
  46.  
  47. // Safe pausing of the CTimer
  48. // pause the timer
  49. // if it had been already paused before it will not be unpaused
  50. struct SPauseGameTimer
  51. {
  52.         SPauseGameTimer()
  53.         {
  54.                 m_bGameTimerWasPaused = gEnv->pTimer->IsTimerPaused(ITimer::ETIMER_GAME);
  55.                 gEnv->pTimer->PauseTimer(ITimer::ETIMER_GAME, true);
  56.         }
  57.  
  58.         ~SPauseGameTimer()
  59.         {
  60.                 if (m_bGameTimerWasPaused == false)
  61.                         gEnv->pTimer->PauseTimer(ITimer::ETIMER_GAME, false);
  62.         }
  63.  
  64.         bool m_bGameTimerWasPaused;
  65. };
  66.  
  67. struct SBasicEntityData
  68. {
  69.         enum ExtraFlags
  70.         {
  71.                 FLAG_HIDDEN             = BIT(0),
  72.                 FLAG_ACTIVE             = BIT(1),
  73.                 FLAG_INVISIBLE          = BIT(2),
  74.                 FLAG_IGNORE_POS_ROT_SCL = BIT(3),
  75.                 FLAG_PHYSICS_ENABLED    = BIT(4)
  76.         };
  77.  
  78.         SBasicEntityData() :
  79.                 pEntity(NULL),
  80.                 pos(0.0f, 0.0f, 0.0f),
  81.                 rot(1.0f, 0.0f, 0.0f, 0.0f),
  82.                 scale(1.0f, 1.0f, 1.0f),
  83.                 flags(0),
  84.                 updatePolicy(0),
  85.                 iPhysType(0),
  86.                 parentEntity(0),
  87.                 aiObjectId(0),
  88.                 isHidden(false),
  89.                 isActive(false),
  90.                 isInvisible(false),
  91.                 ignorePosRotScl(false),
  92.                 isPhysicsEnabled(false)
  93.         {
  94.         }
  95.  
  96.         void Serialize(TSerialize ser)
  97.         {
  98.                 uint32 flags2 = 0;
  99.  
  100.                 if (ser.IsWriting())
  101.                 {
  102.                         if (isHidden)          flags2 |= FLAG_HIDDEN;
  103.                         if (isActive)          flags2 |= FLAG_ACTIVE;
  104.                         if (isInvisible)       flags2 |= FLAG_INVISIBLE;
  105.                         if (ignorePosRotScl)   flags2 |= FLAG_IGNORE_POS_ROT_SCL;
  106.                         if (isPhysicsEnabled)  flags2 |= FLAG_PHYSICS_ENABLED;
  107.  
  108.                         flags2 |= (updatePolicy & 0xF) << (32 - 4);
  109.                         flags2 |= (iPhysType & 0xF) << (32 - 8);
  110.                 }
  111.  
  112.                 ser.Value("id", id);
  113.                 ser.Value("flags", flags);
  114.                 ser.Value("flags2", flags2);
  115.  
  116.                 // Moved here from CEntity::Serialize.
  117.                 ser.Value("aiObjectID", aiObjectId);
  118.  
  119.                 if (ser.IsReading())
  120.                 {
  121.                         isHidden = (flags2 & FLAG_HIDDEN) != 0;
  122.                         isActive = (flags2 & FLAG_ACTIVE) != 0;
  123.                         isInvisible = (flags2 & FLAG_INVISIBLE) != 0;
  124.                         ignorePosRotScl = (flags2 & FLAG_IGNORE_POS_ROT_SCL) != 0;
  125.                         isPhysicsEnabled = (flags2 & FLAG_PHYSICS_ENABLED) != 0;
  126.                         iPhysType = (flags2 >> (32 - 8)) & 0xF;
  127.                         updatePolicy = (flags2 >> (32 - 4)) & 0xF;
  128.                 }
  129.  
  130.                 if (!ignorePosRotScl)
  131.                 {
  132.                         ser.Value("pos", pos);
  133.  
  134.                         if (ser.IsReading() || !rot.IsIdentity())
  135.                                 ser.Value("rot", rot);
  136.  
  137.                         if (ser.IsReading() || !scale.IsEquivalent(Vec3(1.0f, 1.0f, 1.0f)))
  138.                                 ser.Value("scl", scale);
  139.                 }
  140.  
  141.                 if (ser.IsReading() && scale.IsZero())
  142.                 {
  143.                         scale = Vec3(1.0f, 1.0f, 1.0f);
  144.                 }
  145.  
  146.                 // Don't need to serialize this on non-dynamic entities.
  147.                 if (!(flags & ENTITY_FLAG_UNREMOVABLE) || !CCryActionCVars::Get().g_saveLoadBasicEntityOptimization)
  148.                 {
  149.                         ser.Value("name", name);
  150.                         ser.Value("class", className);
  151.                         ser.Value("archetype", archetype);
  152.                 }
  153.  
  154.                 ser.Value("parent", parentEntity);
  155.         }
  156.  
  157.         inline bool operator==(const SBasicEntityData& otherData) const
  158.         {
  159.                 return id == otherData.id;
  160.         }
  161.  
  162.         inline bool operator!=(const SBasicEntityData& otherData) const
  163.         {
  164.                 return !(*this == otherData);
  165.         }
  166.  
  167.         inline bool operator<(const SBasicEntityData& otherData) const
  168.         {
  169.                 return id < otherData.id;
  170.         }
  171.  
  172.         inline bool operator>(const SBasicEntityData& otherData) const
  173.         {
  174.                 return id > otherData.id;
  175.         }
  176.  
  177.         IEntity*    pEntity;
  178.         EntityId    id;
  179.         string      name;
  180.         string      className;
  181.         string      archetype;
  182.         Vec3        pos;
  183.         Quat        rot;
  184.         Vec3        scale;
  185.         uint32      flags;
  186.         uint32      updatePolicy;
  187.         EntityId    parentEntity;
  188.         tAIObjectID aiObjectId;
  189.         int         iPhysType;
  190.  
  191.         bool        isHidden         : 1;
  192.         bool        isActive         : 1;
  193.         bool        isInvisible      : 1;
  194.         bool        ignorePosRotScl  : 1;
  195.         bool        isPhysicsEnabled : 1;
  196. };
  197.  
  198. class CSaveGameHolder
  199. {
  200. public:
  201.         CSaveGameHolder(ISaveGame* pSaveGame) : m_pSaveGame(pSaveGame) {}
  202.         ~CSaveGameHolder()
  203.         {
  204.                 if (m_pSaveGame)
  205.                         m_pSaveGame->Complete(false);
  206.         }
  207.  
  208.         static ISaveGame* ReturnNull()
  209.         {
  210.                 return NULL;
  211.         }
  212.  
  213.         bool PointerOk()
  214.         {
  215.                 return m_pSaveGame != 0;
  216.         }
  217.  
  218.         bool Complete()
  219.         {
  220.                 if (!m_pSaveGame)
  221.                         return false;
  222.                 bool ok = m_pSaveGame->Complete(true);
  223.                 m_pSaveGame = 0;
  224.                 return ok;
  225.         }
  226.  
  227.         ISaveGame* operator->() const
  228.         {
  229.                 return m_pSaveGame;
  230.         }
  231.  
  232.         ISaveGame* Get() const
  233.         {
  234.                 return m_pSaveGame;
  235.         }
  236.  
  237. private:
  238.         ISaveGame* m_pSaveGame;
  239. };
  240.  
  241. struct STempAutoResourcesLock
  242. {
  243.         STempAutoResourcesLock() : m_bIsLocked(false)
  244.         {
  245.                 Lock();
  246.         }
  247.  
  248.         ~STempAutoResourcesLock()
  249.         {
  250.                 Unlock();
  251.         }
  252.  
  253.         void Lock()
  254.         {
  255.                 if (!m_bIsLocked)
  256.                 {
  257.                         if (gEnv->p3DEngine)
  258.                                 gEnv->p3DEngine->LockCGFResources();
  259.                         m_bIsLocked = true;
  260.                 }
  261.         }
  262.  
  263.         void Unlock()
  264.         {
  265.                 if (m_bIsLocked)
  266.                 {
  267.                         if (gEnv->p3DEngine)
  268.                                 gEnv->p3DEngine->UnlockCGFResources();
  269.                         m_bIsLocked = false;
  270.                 }
  271.         }
  272.  
  273.         bool m_bIsLocked;
  274. };
  275.  
  276. //TODO: this class is nearly identical to CSaveGameHolder, but CSaveGameHolder has an extra Complete() method. Is it safe to merge these two?
  277. class CLoadGameHolder
  278. {
  279. public:
  280.         CLoadGameHolder(ILoadGame* pLoadGame) : m_pLoadGame(pLoadGame) {}
  281.         ~CLoadGameHolder()
  282.         {
  283.                 if (m_pLoadGame)
  284.                         m_pLoadGame->Complete();
  285.         }
  286.  
  287.         static ILoadGame* ReturnNull()
  288.         {
  289.                 return NULL;
  290.         }
  291.  
  292.         bool PointerOk()
  293.         {
  294.                 return m_pLoadGame != 0;
  295.         }
  296.  
  297.         ILoadGame* operator->() const
  298.         {
  299.                 return m_pLoadGame;
  300.         }
  301.  
  302.         ILoadGame* Get() const
  303.         {
  304.                 return m_pLoadGame;
  305.         }
  306.  
  307. private:
  308.         ILoadGame* m_pLoadGame;
  309. };
  310.  
  311. #endif //__GAME_SERIALIZE_HELPERS_H__
  312.  
downloadGameSerializeHelpers.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