mirror of https://github.com/AxioDL/metaforce.git
299 lines
8.6 KiB
C++
299 lines
8.6 KiB
C++
#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 "World/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
|
|
{
|
|
|
|
enum class EGameplayResult
|
|
{
|
|
None,
|
|
Win,
|
|
Lose,
|
|
Playing
|
|
};
|
|
|
|
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));
|
|
}
|
|
};
|
|
|
|
#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*)
|
|
{ xe8_b24_finished = true; }
|
|
void appFilesOpen(boo::IApplication*, const std::vector<std::string>& paths)
|
|
{
|
|
fprintf(stderr, "OPENING: ");
|
|
for (const std::string& path : paths)
|
|
fprintf(stderr, "%s ", path.c_str());
|
|
fprintf(stderr, "\n");
|
|
}
|
|
#endif
|
|
public:
|
|
enum class FlowState
|
|
{
|
|
Zero,
|
|
One,
|
|
Two,
|
|
Three,
|
|
Four,
|
|
Five,
|
|
Six,
|
|
};
|
|
private:
|
|
|
|
struct BooSetter
|
|
{
|
|
BooSetter(boo::IGraphicsDataFactory* factory,
|
|
boo::IGraphicsCommandQueue* cmdQ,
|
|
boo::ITextureR* spareTex);
|
|
} m_booSetter;
|
|
|
|
//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 x128_globalObjects;
|
|
CGameArchitectureSupport m_archSupport;
|
|
|
|
FlowState x12c_ = FlowState::Five;
|
|
|
|
u32 x130_[10] = { 1000000 };
|
|
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
bool x160_24_ : 1;
|
|
bool x160_25_ : 1;
|
|
bool x160_26_ : 1;
|
|
bool x160_27_ : 1;
|
|
bool x160_28_ : 1;
|
|
bool x160_29_ : 1;
|
|
bool x160_30_ : 1;
|
|
bool x160_31_ : 1;
|
|
bool x161_24_ : 1;
|
|
};
|
|
u16 _dummy = 0;
|
|
};
|
|
|
|
u32 x164_ = 0;
|
|
|
|
void InitializeSubsystems(const hecl::Runtime::FileStoreManager& storeMgr,
|
|
boo::IAudioVoiceEngine* voiceEngine);
|
|
|
|
public:
|
|
CMain(IFactory& resFactory, CSimplePool& resStore,
|
|
boo::IGraphicsDataFactory* gfxFactory,
|
|
boo::IGraphicsCommandQueue* cmdQ,
|
|
boo::ITextureR* spareTex);
|
|
void RegisterResourceTweaks();
|
|
void ResetGameState();
|
|
void StreamNewGameState(CInputStream&);
|
|
void CheckTweakManagerDebugOptions() {}
|
|
|
|
//int RsMain(int argc, const boo::SystemChar* argv[]);
|
|
void Init(const hecl::Runtime::FileStoreManager& storeMgr,
|
|
boo::IAudioVoiceEngine* voiceEngine);
|
|
bool Proc();
|
|
void Shutdown();
|
|
|
|
bool CheckReset();
|
|
bool CheckTerminate() {return false;}
|
|
void DrawDebugMetrics(double, CStopwatch&) {}
|
|
void DoPredrawMetrics() {}
|
|
void FillInAssetIDs();
|
|
void LoadAudio();
|
|
void ShutdownSubsystems();
|
|
EGameplayResult GetGameplayResult() const {return xe4_gameplayResult;}
|
|
void SetGameplayResult(EGameplayResult wl) {xe4_gameplayResult = wl;}
|
|
|
|
FlowState GetFlowState() const { return x12c_; }
|
|
};
|
|
|
|
}
|
|
}
|
|
|
|
#endif // __URDE_MP1_HPP__
|