Prep MP1::CMain for testing

Runtime/MP1/MP1.hpp

@@ -1,15 +1,51 @@
 #ifndef __URDE_MP1_HPP__
 #define __URDE_MP1_HPP__
 
+#define MP1_USE_BOO 0
+
 #include <boo/boo.hpp>
+#include <boo/graphicsdev/GL.hpp>
+#include <boo/audiodev/IAudioVoiceEngine.hpp>
 #include "CMemory.hpp"
 #include "CTweaks.hpp"
 #include "CPlayMovie.hpp"
 #include "IOStreams.hpp"
+#include "CBasics.hpp"
+#include "CMemoryCardSys.hpp"
+#include "CResFactory.hpp"
+#include "CSimplePool.hpp"
+#include "Character/CAssetFactory.hpp"
+#include "CAi.hpp"
+#include "CGameState.hpp"
+#include "CInGameTweakManager.hpp"
+#include "Particle/CElementGen.hpp"
+#include "Character/CAnimData.hpp"
+#include "Particle/CDecalManager.hpp"
+#include "Particle/CGenDescription.hpp"
+#include "Graphics/CBooRenderer.hpp"
+#include "Audio/CAudioSys.hpp"
+#include "Input/CInputGenerator.hpp"
+#include "GuiSys/CGuiSys.hpp"
+#include "CIOWinManager.hpp"
+#include "GuiSys/CSplashScreen.hpp"
+#include "CMainFlow.hpp"
+#include "GuiSys/CConsoleOutputWindow.hpp"
+#include "GuiSys/CTextParser.hpp"
+#include "Audio/CAudioStateWin.hpp"
+#include "GameGlobalObjects.hpp"
+#include "CArchitectureQueue.hpp"
+#include "MP1.hpp"
+#include "CTimeProvider.hpp"
+#include "GuiSys/CTextExecuteBuffer.hpp"
+
+#include "DataSpec/DNAMP1/Tweaks/CTweakPlayer.hpp"
+#include "DataSpec/DNAMP1/Tweaks/CTweakGame.hpp"
 
 namespace urde
 {
 class CStopwatch;
+class IFactory;
+class IObjectStore;
 
 namespace MP1
 {
@@ -22,12 +58,143 @@ enum class EGameplayResult
     Playing
 };
 
-class WindowCallback : public boo::IWindowCallback
+class CGameGlobalObjects
 {
+    CMemoryCardSys x0_memoryCardSys;
+    IFactory& x20_resFactory;
+    CSimplePool& x114_simplePool;
+    CCharacterFactoryBuilder x14c_charFactoryBuilder;
+    CAiFuncMap x188_aiFuncMap;
+    CGameState x1a8_gameState;
+    CInGameTweakManager x1c0_tweakManager;
+    std::unique_ptr<CBooRenderer> m_renderer;
+
+    void LoadStringTable()
+    {
+    }
+    static CBooRenderer*
+    AllocateRenderer(IObjectStore& store, IFactory& resFactory)
+    {
+        g_Renderer = new CBooRenderer(store, resFactory);
+        return g_Renderer;
+    }
+
+public:
+    CGameGlobalObjects(IFactory& resFactory, CSimplePool& objStore)
+    : x20_resFactory(resFactory), x114_simplePool(objStore)
+    {
+        g_MemoryCardSys = &x0_memoryCardSys;
+        g_ResFactory = &x20_resFactory;
+        g_SimplePool = &x114_simplePool;
+        g_CharFactoryBuilder = &x14c_charFactoryBuilder;
+        g_AiFuncMap = &x188_aiFuncMap;
+        g_GameState = &x1a8_gameState;
+        g_TweakManager = &x1c0_tweakManager;
+    }
+
+    void PostInitialize()
+    {
+        LoadStringTable();
+        m_renderer.reset(AllocateRenderer(x114_simplePool, x20_resFactory));
+    }
 };
 
-class CMain : public boo::IApplicationCallback
+#if MP1_USE_BOO
+class CGameArchitectureSupport : public boo::IWindowCallback
+#else
+class CGameArchitectureSupport
+#endif
 {
+    CArchitectureQueue m_archQueue;
+    CAudioSys m_audioSys;
+    CInputGenerator m_inputGenerator;
+    CGuiSys m_guiSys;
+    CIOWinManager m_ioWinManager;
+    CSplashScreen m_splashScreen;
+    CMainFlow m_mainFlow;
+    CConsoleOutputWindow m_consoleWindow;
+    CAudioStateWin m_audioStateWin;
+    boo::SWindowRect m_windowRect;
+    bool m_rectIsDirty;
+
+    void mouseDown(const boo::SWindowCoord &coord, boo::EMouseButton button, boo::EModifierKey mods)
+    { m_inputGenerator.mouseDown(coord, button, mods); }
+    void mouseUp(const boo::SWindowCoord &coord, boo::EMouseButton button, boo::EModifierKey mods)
+    { m_inputGenerator.mouseUp(coord, button, mods); }
+    void mouseMove(const boo::SWindowCoord &coord)
+    { m_inputGenerator.mouseMove(coord); }
+    void scroll(const boo::SWindowCoord &coord, const boo::SScrollDelta &scroll)
+    { m_inputGenerator.scroll(coord, scroll); }
+    void charKeyDown(unsigned long charCode, boo::EModifierKey mods, bool isRepeat)
+    { m_inputGenerator.charKeyDown(charCode, mods, isRepeat); }
+    void charKeyUp(unsigned long charCode, boo::EModifierKey mods)
+    { m_inputGenerator.charKeyUp(charCode, mods); }
+    void specialKeyDown(boo::ESpecialKey key, boo::EModifierKey mods, bool isRepeat)
+    { m_inputGenerator.specialKeyDown(key, mods, isRepeat); }
+    void specialKeyUp(boo::ESpecialKey key, boo::EModifierKey mods)
+    { m_inputGenerator.specialKeyUp(key, mods); }
+    void modKeyDown(boo::EModifierKey mod, bool isRepeat)
+    { m_inputGenerator.modKeyDown(mod, isRepeat);}
+    void modKeyUp(boo::EModifierKey mod)
+    { m_inputGenerator.modKeyUp(mod); }
+
+    void destroyed() { m_archQueue.Push(std::move(MakeMsg::CreateApplicationExit(EArchMsgTarget::ArchitectureSupport))); }
+
+    void resized(const boo::SWindowRect &rect)
+    {
+        m_windowRect = rect;
+        m_rectIsDirty = true;
+    }
+
+public:
+    CGameArchitectureSupport()
+        : m_audioSys(0,0,0,0,0),
+          m_inputGenerator(0.0f /*g_tweakPlayer->GetLeftLogicalThreshold()*/,
+                           0.0f /*g_tweakPlayer->GetRightLogicalThreshold()*/),
+          m_guiSys(*g_ResFactory, *g_SimplePool, CGuiSys::EUsageMode::Zero)
+    {
+        g_GuiSys = &m_guiSys;
+        m_inputGenerator.startScanning();
+    }
+    bool Update()
+    {
+        bool finished = false;
+        m_inputGenerator.Update(1.0 / 60.0, m_archQueue);
+
+        while(m_archQueue)
+        {
+            CArchitectureMessage msg = m_archQueue.Pop();
+            if (msg.GetTarget() == EArchMsgTarget::ArchitectureSupport)
+            {
+                if (msg.GetType() == EArchMsgType::ApplicationExit)
+                    finished = true;
+            }
+
+            if (msg.GetTarget() == EArchMsgTarget::Game && msg.GetType() == EArchMsgType::UserInput)
+            {
+                const CArchMsgParmUserInput* input = msg.GetParm<CArchMsgParmUserInput>();
+                if (input->x4_parm.DStart())
+                    m_archQueue.Push(std::move(MakeMsg::CreateApplicationExit(EArchMsgTarget::ArchitectureSupport)));
+            }
+        }
+        return finished;
+    }
+
+    bool isRectDirty() { return m_rectIsDirty; }
+    const boo::SWindowRect& getWindowRect()
+    {
+        m_rectIsDirty = false;
+        return m_windowRect;
+    }
+};
+
+#if MP1_USE_BOO
+class CMain : public boo::IApplicationCallback
+#else
+class CMain
+#endif
+{
+#if MP1_USE_BOO
     boo::IWindow* mainWindow;
     int appMain(boo::IApplication* app);
     void appQuitting(boo::IApplication*)
@@ -39,20 +206,39 @@ class CMain : public boo::IApplicationCallback
             fprintf(stderr, "%s ", path.c_str());
         fprintf(stderr, "\n");
     }
+#endif
 
-    CMemorySys x6c_memSys;
+    //CMemorySys x6c_memSys;
     CTweaks x70_tweaks;
     EGameplayResult xe4_gameplayResult;
     bool xe8_b24_finished = false;
 
+    /* urde addition: these are simply initialized along with everything else */
+    CGameGlobalObjects m_globalObjects;
+    CGameArchitectureSupport m_archSupport;
+
+    void InitializeSubsystems(boo::IGraphicsDataFactory* factory,
+                              boo::IGraphicsCommandQueue* cc,
+                              boo::ITextureR* renderTex,
+                              const hecl::Runtime::FileStoreManager& storeMgr,
+                              boo::IAudioVoiceEngine* voiceEngine);
+
 public:
-    CMain();
+    CMain(IFactory& resFactory, CSimplePool& resStore);
     void RegisterResourceTweaks();
     void ResetGameState();
     void StreamNewGameState(CInputStream&);
     void CheckTweakManagerDebugOptions() {}
-    void AddWorldPaks();
-    int RsMain(int argc, const boo::SystemChar* argv[]);
+
+    //int RsMain(int argc, const boo::SystemChar* argv[]);
+    void Init(boo::IGraphicsDataFactory* factory,
+              boo::IGraphicsCommandQueue* cc,
+              boo::ITextureR* renderTex,
+              const hecl::Runtime::FileStoreManager& storeMgr,
+              boo::IAudioVoiceEngine* voiceEngine);
+    bool Proc();
+    void Shutdown();
+
     bool CheckReset();
     bool CheckTerminate() {return false;}
     void DrawDebugMetrics(double, CStopwatch&) {}
@@ -60,7 +246,6 @@ public:
     void FillInAssetIDs();
     void LoadAudio();
     void ShutdownSubsystems();
-    void InitializeSubsystems();
     EGameplayResult GetGameplayResult() const {return xe4_gameplayResult;}
     void SetGameplayResult(EGameplayResult wl) {xe4_gameplayResult = wl;}
 };