GameApplicationBase.h

#pragma once
 
#include <Core/Configuration/PlatformProfile.h>
#include <Core/Console/ConsoleFunction.h>
#include <Core/GameApplication/WindowOutputTargetBase.h>
#include <Core/GameState/GameStateBase.h>
#include <Core/System/Window.h>
#include <Foundation/Application/Application.h>
#include <Foundation/Types/UniquePtr.h>
 
class plWindowBase;
struct plWindowCreationDesc;
class plWorld;
 
struct plGameApplicationStaticEvent
{
  enum class Type
  {
    AfterGameStateActivated,
    BeforeGameStateDeactivated
  };
 
  Type m_Type;
};
 
struct plGameApplicationExecutionEvent
{
  enum class Type
  {
    BeginAppTick,
    BeforeWorldUpdates,
    AfterWorldUpdates,
    BeforeUpdatePlugins,
    AfterUpdatePlugins,
    BeforePresent,
    AfterPresent,
    EndAppTick,
  };
 
  Type m_Type;
};
 
// TODO: document this and update plGameApplication comments
 
class PL_CORE_DLL plGameApplicationBase : public plApplication
{
public:
  using SUPER = plApplication;
 
  plGameApplicationBase(plStringView sAppName);
  ~plGameApplicationBase();
 
 
public:
  static plGameApplicationBase* GetGameApplicationBaseInstance() { return s_pGameApplicationBaseInstance; }
 
protected:
  static plGameApplicationBase* s_pGameApplicationBaseInstance;
 
 
public:
  void TakeProfilingCapture();
 
  void TakeScreenshot();
 
protected:
  virtual void StoreScreenshot(plImage&& image, plStringView sContext = {});
 
  void ExecuteTakeScreenshot(plWindowOutputTargetBase* pOutputTarget, plStringView sContext = {});
 
  bool m_bTakeScreenshot = false;
 
  plConsoleFunction<void()> m_ConFunc_TakeScreenshot;
 
 
public:
  void CaptureFrame();
 
  void SetContinuousFrameCapture(bool bEnable);
  bool GetContinousFrameCapture() const;
 
  virtual plResult GetAbsFrameCaptureOutputPath(plStringBuilder& ref_sOutputPath);
 
protected:
  void ExecuteFrameCapture(plWindowHandle targetWindowHandle, plStringView sContext = {});
 
  bool m_bContinuousFrameCapture = false;
  bool m_bCaptureFrame = false;
 
  plConsoleFunction<void()> m_ConFunc_CaptureFrame;
 
public:
  plResult ActivateGameState(plWorld* pWorld = nullptr, const plTransform* pStartPosition = nullptr);
 
  void DeactivateGameState();
 
  plGameStateBase* GetActiveGameState() const { return m_pGameState.Borrow(); }
 
  plGameStateBase* GetActiveGameStateLinkedToWorld(const plWorld* pWorld) const;
 
protected:
  virtual plUniquePtr<plGameStateBase> CreateGameState(plWorld* pWorld);
 
  virtual void ActivateGameStateAtStartup();
 
  plUniquePtr<plGameStateBase> m_pGameState;
  plWorld* m_pWorldLinkedWithGameState = nullptr;
 
public:
  const plPlatformProfile& GetPlatformProfile() const { return m_PlatformProfile; }
 
 
protected:
  plPlatformProfile m_PlatformProfile;
 
protected:
  virtual plResult BeforeCoreSystemsStartup() override;
  virtual void AfterCoreSystemsStartup() override;
 
  virtual plString FindProjectDirectory() const = 0;
 
  virtual plString GetBaseDataDirectoryPath() const;
 
  virtual plString GetProjectDataDirectoryPath() const;
 
  virtual void ExecuteBaseInitFunctions();
  virtual void BaseInit_ConfigureLogging();
 
  plEventSubscriptionID m_LogToConsoleID = 0;
  plEventSubscriptionID m_LogToVsID = 0;
 
  virtual void ExecuteInitFunctions();
  virtual void Init_PlatformProfile_SetPreferred();
  virtual void Init_ConfigureTelemetry();
  virtual void Init_FileSystem_SetSpecialDirs();
  virtual void Init_LoadRequiredPlugins();
  virtual void Init_ConfigureAssetManagement();
  virtual void Init_FileSystem_ConfigureDataDirs();
  virtual void Init_LoadWorldModuleConfig();
  virtual void Init_LoadProjectPlugins();
  virtual void Init_PlatformProfile_LoadForRuntime();
  virtual void Init_ConfigureInput();
  virtual void Init_ConfigureTags();
  virtual void Init_ConfigureCVars();
  virtual void Init_SetupGraphicsDevice() = 0;
  virtual void Init_SetupDefaultResources();
 
  plEvent<const plGameApplicationStaticEvent&> m_StaticEvents;
 
protected:
  virtual void BeforeHighLevelSystemsShutdown() override;
  virtual void BeforeCoreSystemsShutdown() override;
 
  virtual void Deinit_ShutdownGraphicsDevice() = 0;
  virtual void Deinit_UnloadPlugins();
  virtual void Deinit_ShutdownLogging();
 
 
public:
  virtual plApplication::Execution Run() override;
 
  void RunOneFrame();
 
  plCopyOnBroadcastEvent<const plGameApplicationExecutionEvent&> m_ExecutionEvents;
 
  plTime GetFrameTime() const { return m_FrameTime; }
 
protected:
  virtual bool IsGameUpdateEnabled() const { return true; }
 
  virtual void Run_InputUpdate();
  virtual bool Run_ProcessApplicationInput();
  virtual void Run_AcquireImage();
  virtual void Run_WorldUpdateAndRender() = 0;
  virtual void Run_BeforeWorldUpdate();
  virtual void Run_AfterWorldUpdate();
  virtual void Run_UpdatePlugins();
  virtual void Run_PresentImage();
  virtual void Run_FinishFrame();
 
  void UpdateFrameTime();
 
  plTime m_FrameTime;
};