BVB Source Codes

CRYENGINE Show CET_LevelLoading.cpp Source code

Return Download CRYENGINE: download CET_LevelLoading.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #include "StdAfx.h"
  4. #include "CET_LevelLoading.h"
  5. #include "ILevelSystem.h"
  6. #include "GameClientChannel.h"
  7. #include <CryNetwork/NetHelpers.h>
  8. #include "GameContext.h"
  9. #include "GameContext.h"
  10. #include <CryThreading/IThreadManager.h>
  11.  
  12. /*
  13.  * Prepare level
  14.  */
  15.  
  16. class CCET_PrepareLevel : public CCET_Base
  17. {
  18. public:
  19.         const char*                 GetName() { return "PrepareLevel"; }
  20.  
  21.         EContextEstablishTaskResult OnStep(SContextEstablishState& state)
  22.         {
  23.                 CGameContext* pGameContext = CCryAction::GetCryAction()->GetGameContext();
  24.                 string levelName = pGameContext ? pGameContext->GetLevelName() : "";
  25.                 if (levelName.empty())
  26.                 {
  27.                         //GameWarning("No level name set");
  28.                         return eCETR_Wait;
  29.                 }
  30.                 if (gEnv->IsClient() && !gEnv->bServer)
  31.                 {
  32.                         CryLogAlways("============================ PrepareLevel %s ============================", levelName.c_str());
  33.  
  34.                         gEnv->pSystem->GetISystemEventDispatcher()->OnSystemEvent(ESYSTEM_EVENT_LEVEL_LOAD_PREPARE, 0, 0);
  35.  
  36.                         CCryAction::GetCryAction()->GetILevelSystem()->PrepareNextLevel(levelName);
  37.                 }
  38.                 return eCETR_Ok;
  39.         }
  40. };
  41.  
  42. void AddPrepareLevelLoad(IContextEstablisher* pEst, EContextViewState state)
  43. {
  44.         pEst->AddTask(state, new CCET_PrepareLevel());
  45. }
  46.  
  47. /*
  48.  * Load a level
  49.  */
  50.  
  51. class CCET_LoadLevel : public CCET_Base
  52. {
  53. public:
  54.         CCET_LoadLevel() : m_bStarted(false) {}
  55.  
  56.         const char*                 GetName() { return "LoadLevel"; }
  57.  
  58.         EContextEstablishTaskResult OnStep(SContextEstablishState& state)
  59.         {
  60.                 ILevelInfo* pILevel = NULL;
  61.                 string levelName = CCryAction::GetCryAction()->GetGameContext()->GetLevelName();
  62.                 if (levelName.empty())
  63.                 {
  64.                         GameWarning("No level name set");
  65.                         return eCETR_Failed;
  66.                 }
  67.  
  68.                 CCryAction* pAction = CCryAction::GetCryAction();
  69.  
  70.                 pAction->StartNetworkStallTicker(true);
  71.                 GetISystem()->GetISystemEventDispatcher()->OnSystemEvent(ESYSTEM_EVENT_LEVEL_LOAD_START, (UINT_PTR)(levelName.c_str()), 0);
  72.                 pILevel = pAction->GetILevelSystem()->LoadLevel(levelName);
  73.                 GetISystem()->GetISystemEventDispatcher()->OnSystemEvent(ESYSTEM_EVENT_LEVEL_LOAD_END, 0, 0);
  74.                 pAction->StopNetworkStallTicker();
  75.  
  76.                 if (pILevel == NULL)
  77.                 {
  78.                         GameWarning("Failed to load level: %s", levelName.c_str());
  79.                         return eCETR_Failed;
  80.                 }
  81.                 m_bStarted = true;
  82.                 return eCETR_Ok;
  83.         }
  84.  
  85.         bool m_bStarted;
  86. };
  87.  
  88. class CLevelLoadingThread : public IThread
  89. {
  90. public:
  91.         enum EState
  92.         {
  93.                 eState_Working,
  94.                 eState_Failed,
  95.                 eState_Succeeded,
  96.         };
  97.  
  98.         CLevelLoadingThread(ILevelSystem* pLevelSystem, const char* szLevelName)
  99.                 : m_pLevelSystem(pLevelSystem), m_state(eState_Working), m_levelName(szLevelName)
  100.         {
  101.         }
  102.  
  103.         virtual void ThreadEntry() override
  104.         {
  105.                 const threadID levelLoadingThreadId = CryGetCurrentThreadId();
  106.                 gEnv->pRenderer->SetLevelLoadingThreadId(levelLoadingThreadId);
  107.                 gEnv->pAudioSystem->SetAllowedThreadId(levelLoadingThreadId);
  108.  
  109.                 const ILevelInfo* pLoadedLevelInfo = m_pLevelSystem->LoadLevel(m_levelName.c_str());
  110.                 const bool bResult = (pLoadedLevelInfo != NULL);
  111.                 gEnv->pRenderer->SetLevelLoadingThreadId(0);
  112.                 gEnv->pAudioSystem->SetAllowedThreadId(gEnv->mMainThreadId);
  113.  
  114.                 m_state = bResult ? eState_Succeeded : eState_Failed;
  115.         }
  116.  
  117.         EState GetState() const
  118.         {
  119.                 return m_state;
  120.         }
  121.  
  122. private:
  123.         ILevelSystem* m_pLevelSystem;
  124.         volatile EState m_state;
  125.         const string m_levelName;
  126. };
  127.  
  128. class CCET_LoadLevelAsync : public CCET_Base
  129. {
  130. public:
  131.         CCET_LoadLevelAsync() : m_bStarted(false), m_pLevelLoadingThread(nullptr) {}
  132.  
  133.         virtual const char* GetName() override
  134.         {
  135.                 return "LoadLevelAsync";
  136.         }
  137.  
  138.         virtual EContextEstablishTaskResult OnStep( SContextEstablishState& state ) override
  139.         {
  140.                 CCryAction* pAction = CCryAction::GetCryAction();
  141.                 const string levelName = pAction->GetGameContext()->GetLevelName();
  142.                 if (!m_bStarted)
  143.                 {
  144.                         if (levelName.empty())
  145.                         {
  146.                                 GameWarning("No level name set");
  147.                                 return eCETR_Failed;
  148.                         }
  149.  
  150.                         pAction->StartNetworkStallTicker(true);
  151.                         GetISystem()->GetISystemEventDispatcher()->OnSystemEvent(ESYSTEM_EVENT_LEVEL_LOAD_START, (UINT_PTR)(levelName.c_str()), 0);
  152.  
  153.                         ILevelSystem* pLevelSystem = pAction->GetILevelSystem();
  154.                         m_pLevelLoadingThread = new CLevelLoadingThread(pLevelSystem, levelName.c_str());
  155.                         if (!gEnv->pThreadManager->SpawnThread(m_pLevelLoadingThread, "LevelLoadingThread"))
  156.                         {
  157.                                 CryFatalError("Error spawning LevelLoadingThread thread.");
  158.                         }
  159.  
  160.                         m_bStarted = true;
  161.                 }
  162.  
  163.                 const CLevelLoadingThread::EState threadState = m_pLevelLoadingThread->GetState();
  164.                 if(threadState == CLevelLoadingThread::eState_Working)
  165.                         return eCETR_Wait;
  166.  
  167.                 gEnv->pThreadManager->JoinThread(m_pLevelLoadingThread, eJM_Join);
  168.                 delete m_pLevelLoadingThread;
  169.                 m_pLevelLoadingThread = nullptr;
  170.  
  171.                 GetISystem()->GetISystemEventDispatcher()->OnSystemEvent(ESYSTEM_EVENT_LEVEL_LOAD_END, 0, 0);
  172.                 pAction->StopNetworkStallTicker();
  173.                 if(threadState == CLevelLoadingThread::eState_Succeeded)
  174.                 {
  175.                         return eCETR_Ok;
  176.                 }
  177.                 else
  178.                 {
  179.                         GameWarning("Failed to load level: %s", levelName.c_str());
  180.                         return eCETR_Failed;
  181.                 }
  182.         }
  183.  
  184.         bool m_bStarted;
  185.         CLevelLoadingThread* m_pLevelLoadingThread;
  186. };
  187.  
  188. void AddLoadLevel( IContextEstablisher * pEst, EContextViewState state, bool ** ppStarted )
  189. {
  190.         const bool bIsEditor = gEnv->IsEditor();
  191.         const bool bIsDedicated = gEnv->IsDedicated();
  192.         const ICVar* pAsyncLoad = gEnv->pConsole->GetCVar("g_asynclevelload");
  193.         const bool bAsyncLoad = pAsyncLoad && pAsyncLoad->GetIVal() > 0;
  194.  
  195.         if(!bIsEditor && !bIsDedicated && bAsyncLoad)
  196.         {
  197.                 CCET_LoadLevelAsync* pLL = new CCET_LoadLevelAsync;
  198.                 pEst->AddTask( state, pLL );
  199.                 *ppStarted = &pLL->m_bStarted;
  200.         }
  201.         else
  202.         {
  203.                 CCET_LoadLevel* pLL = new CCET_LoadLevel;
  204.                 pEst->AddTask( state, pLL );
  205.                 *ppStarted = &pLL->m_bStarted;
  206.         }
  207. }
  208.  
  209. /*
  210.  * Loading complete
  211.  */
  212.  
  213. class CCET_LoadingComplete : public CCET_Base
  214. {
  215. public:
  216.         CCET_LoadingComplete(bool* pStarted) : m_pStarted(pStarted) {}
  217.  
  218.         const char*                 GetName() { return "LoadingComplete"; }
  219.  
  220.         EContextEstablishTaskResult OnStep(SContextEstablishState& state)
  221.         {
  222.                 ILevelSystem* pLS = CCryAction::GetCryAction()->GetILevelSystem();
  223.                 if (pLS->GetCurrentLevel())
  224.                 {
  225.                         pLS->OnLoadingComplete(pLS->GetCurrentLevel());
  226.                         return eCETR_Ok;
  227.                 }
  228.                 return eCETR_Failed;
  229.         }
  230.         virtual void OnFailLoading(bool hasEntered)
  231.         {
  232.                 ILevelSystem* pLS = CCryAction::GetCryAction()->GetILevelSystem();
  233.                 if (m_pStarted && *m_pStarted && !hasEntered)
  234.                         pLS->OnLoadingError(NULL, "context establisher failed");
  235.         }
  236.  
  237.         bool* m_pStarted;
  238. };
  239.  
  240. void AddLoadingComplete(IContextEstablisher* pEst, EContextViewState state, bool* pStarted)
  241. {
  242.         pEst->AddTask(state, new CCET_LoadingComplete(pStarted));
  243. }
  244.  
  245. /*
  246.  * Reset Areas
  247.  */
  248. class CCET_ResetAreas : public CCET_Base
  249. {
  250. public:
  251.         const char*                 GetName() { return "ResetAreas"; }
  252.  
  253.         EContextEstablishTaskResult OnStep(SContextEstablishState& state)
  254.         {
  255.                 gEnv->pEntitySystem->ResetAreas();
  256.                 return eCETR_Ok;
  257.         }
  258. };
  259.  
  260. void AddResetAreas(IContextEstablisher* pEst, EContextViewState state)
  261. {
  262.         pEst->AddTask(state, new CCET_ResetAreas);
  263. }
  264.  
  265. /*
  266.  * Lock resources
  267.  */
  268.  
  269. struct SLockResourcesState : public CMultiThreadRefCount
  270. {
  271.         SLockResourcesState() : m_bLocked(false) {}
  272.         bool m_bLocked;
  273. };
  274. typedef _smart_ptr<SLockResourcesState> SLockResourcesStatePtr;
  275.  
  276. class CCET_LockResources : public CCET_Base
  277. {
  278. public:
  279.         const char* GetName() { return (m_bLock) ? "LockResources (lock)" : "LockResources (unlock)"; }
  280.  
  281.         CCET_LockResources(bool bLock, SLockResourcesStatePtr pState, CGameContext* pGameContext) : m_pState(pState), m_bLock(bLock), m_pGameContext(pGameContext) {}
  282.  
  283.         EContextEstablishTaskResult OnStep(SContextEstablishState& state)
  284.         {
  285.                 if (m_bLock && !m_pState->m_bLocked)
  286.                 {
  287.                         m_pGameContext->LockResources();
  288.                         m_pState->m_bLocked = true;
  289.                 }
  290.                 if (!m_bLock && m_pState->m_bLocked)
  291.                 {
  292.                         m_pGameContext->UnlockResources();
  293.                         m_pState->m_bLocked = false;
  294.                 }
  295.                 return eCETR_Ok;
  296.         }
  297.  
  298.         EContextEstablishTaskResult OnLeaveState(SContextEstablishState& state)
  299.         {
  300.                 return eCETR_Ok;
  301.         }
  302.  
  303.         void OnFailLoading(bool hasEntered)
  304.         {
  305.                 if (m_pState->m_bLocked)
  306.                 {
  307.                         m_pGameContext->UnlockResources();
  308.                         m_pState->m_bLocked = false;
  309.                 }
  310.         }
  311.  
  312. private:
  313.         SLockResourcesStatePtr m_pState;
  314.         bool                   m_bLock;
  315.         CGameContext*          m_pGameContext;
  316. };
  317.  
  318. void AddLockResources(IContextEstablisher* pEst, EContextViewState stateBegin, EContextViewState stateEnd, CGameContext* pGameContext)
  319. {
  320.         SLockResourcesStatePtr pState = new SLockResourcesState;
  321.         pEst->AddTask(stateBegin, new CCET_LockResources(true, pState, pGameContext));
  322.         pEst->AddTask(stateEnd, new CCET_LockResources(false, pState, pGameContext));
  323. }
  324.  
  325. /*
  326.  * Action events
  327.  */
  328. class CCET_ActionEvent : public CCET_Base
  329. {
  330. public:
  331.         CCET_ActionEvent(const SActionEvent& evt) : m_evt(evt) {}
  332.  
  333.         const char*                 GetName() { return "ActionEvent"; }
  334.  
  335.         EContextEstablishTaskResult OnStep(SContextEstablishState& state)
  336.         {
  337.                 CCryAction::GetCryAction()->OnActionEvent(m_evt);
  338.                 return eCETR_Ok;
  339.         }
  340.  
  341. private:
  342.         SActionEvent m_evt;
  343. };
  344.  
  345. void AddActionEvent(IContextEstablisher* pEst, EContextViewState state, const SActionEvent& evt)
  346. {
  347.         pEst->AddTask(state, new CCET_ActionEvent(evt));
  348. }
  349.  
downloadCET_LevelLoading.cpp 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