metaforce/Runtime/MP1/CPauseScreen.cpp

354 lines
14 KiB
C++

#include "CPauseScreen.hpp"
#include "GameGlobalObjects.hpp"
#include "CSimplePool.hpp"
#include "Audio/CSfxManager.hpp"
#include "CLogBookScreen.hpp"
#include "COptionsScreen.hpp"
#include "GuiSys/CGuiSys.hpp"
#include "GuiSys/CGuiTextPane.hpp"
#include "GuiSys/CGuiWidgetDrawParms.hpp"
#include "Input/ControlMapper.hpp"
namespace urde::MP1 {
CPauseScreen::CPauseScreen(ESubScreen subscreen, const CDependencyGroup& suitDgrp, const CDependencyGroup& ballDgrp)
: x0_initialSubScreen(subscreen)
, x14_strgPauseScreen(g_SimplePool->GetObj("STRG_PauseScreen"))
, x20_suitDgrp(suitDgrp)
, x24_ballDgrp(ballDgrp)
, x28_pauseScreenInstructions(g_SimplePool->GetObj("FRME_PauseScreenInstructions"))
, x54_frmePauseScreenId(g_ResFactory->GetResourceIdByName("FRME_PauseScreen")->id) {
SObjectTag frmeTag(FOURCC('FRME'), x54_frmePauseScreenId);
x58_frmePauseScreenBufSz = g_ResFactory->ResourceSize(frmeTag);
x5c_frmePauseScreenBuf.reset(new u8[x58_frmePauseScreenBufSz]);
x60_loadTok = g_ResFactory->LoadResourceAsync(frmeTag, x5c_frmePauseScreenBuf.get());
CSfxManager::SfxStart(SFXui_pause_screen_enter, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
x7c_screens.resize(2);
m_returnDown = false;
m_nextDown = false;
m_backDown = false;
m_lDown = false;
m_rDown = false;
}
CPauseScreen::~CPauseScreen() {
if (x60_loadTok)
x60_loadTok->PostCancelRequest();
}
std::unique_ptr<CPauseScreenBase> CPauseScreen::BuildPauseSubScreen(ESubScreen subscreen, const CStateManager& mgr,
CGuiFrame& frame) const {
switch (subscreen) {
case ESubScreen::LogBook:
return std::make_unique<CLogBookScreen>(mgr, frame, *x14_strgPauseScreen);
case ESubScreen::Options:
return std::make_unique<COptionsScreen>(mgr, frame, *x14_strgPauseScreen);
case ESubScreen::Inventory:
return std::make_unique<CInventoryScreen>(mgr, frame, *x14_strgPauseScreen, x20_suitDgrp, x24_ballDgrp);
default:
return {};
}
}
void CPauseScreen::InitializeFrameGlue() {
x38_textpane_l1 = static_cast<CGuiTextPane*>(x34_loadedPauseScreenInstructions->FindWidget("textpane_l1"));
x38_textpane_l1->SetMouseActive(true);
x3c_textpane_r = static_cast<CGuiTextPane*>(x34_loadedPauseScreenInstructions->FindWidget("textpane_r"));
x3c_textpane_r->SetMouseActive(true);
x40_textpane_a = static_cast<CGuiTextPane*>(x34_loadedPauseScreenInstructions->FindWidget("textpane_a"));
x40_textpane_a->SetMouseActive(true);
x44_textpane_b = static_cast<CGuiTextPane*>(x34_loadedPauseScreenInstructions->FindWidget("textpane_b"));
x44_textpane_b->SetMouseActive(true);
x48_textpane_return = static_cast<CGuiTextPane*>(x34_loadedPauseScreenInstructions->FindWidget("textpane_return"));
x48_textpane_return->SetMouseActive(true);
x4c_textpane_next = static_cast<CGuiTextPane*>(x34_loadedPauseScreenInstructions->FindWidget("textpane_next"));
x4c_textpane_next->SetMouseActive(true);
x50_textpane_back = static_cast<CGuiTextPane*>(x34_loadedPauseScreenInstructions->FindWidget("textpane_back"));
x50_textpane_back->SetMouseActive(true);
x40_textpane_a->TextSupport().SetText(x14_strgPauseScreen->GetString(7)); // OPTIONS
x40_textpane_a->TextSupport().SetFontColor(g_tweakGuiColors->GetPauseItemAmberColor());
x44_textpane_b->TextSupport().SetText(x14_strgPauseScreen->GetString(6)); // LOG BOOK
x44_textpane_b->TextSupport().SetFontColor(g_tweakGuiColors->GetPauseItemAmberColor());
x40_textpane_a->SetColor(zeus::CColor::skClear);
x44_textpane_b->SetColor(zeus::CColor::skClear);
if (CGuiWidget* deco = x34_loadedPauseScreenInstructions->FindWidget("basewidget_deco")) {
zeus::CColor color = g_tweakGuiColors->GetPauseItemAmberColor();
color.a() *= 0.75f;
deco->SetColor(color);
}
x34_loadedPauseScreenInstructions->SetMouseDownCallback(std::bind(&CPauseScreen::OnWidgetMouseDown, this,
std::placeholders::_1, std::placeholders::_2));
x34_loadedPauseScreenInstructions->SetMouseUpCallback(std::bind(&CPauseScreen::OnWidgetMouseUp, this,
std::placeholders::_1, std::placeholders::_2));
}
bool CPauseScreen::CheckLoadComplete(const CStateManager& mgr) {
if (x90_resourcesLoaded)
return true;
if (!x14_strgPauseScreen.IsLoaded())
return false;
if (!x34_loadedPauseScreenInstructions) {
if (!x28_pauseScreenInstructions.IsLoaded())
return false;
if (!x28_pauseScreenInstructions->GetIsFinishedLoading())
return false;
x34_loadedPauseScreenInstructions = x28_pauseScreenInstructions.GetObj();
x34_loadedPauseScreenInstructions->SetMaxAspect(1.77f);
InitializeFrameGlue();
}
if (x60_loadTok) {
if (!x60_loadTok->IsComplete())
return false;
for (int i = 0; i < 2; ++i) {
CMemoryInStream s(x5c_frmePauseScreenBuf.get(), x58_frmePauseScreenBufSz);
x64_frameInsts.push_back(CGuiFrame::CreateFrame(x54_frmePauseScreenId, *g_GuiSys, s, g_SimplePool));
x64_frameInsts.back()->SetMaxAspect(1.77f);
}
x5c_frmePauseScreenBuf.reset();
x60_loadTok.reset();
}
if (!x64_frameInsts[0]->GetIsFinishedLoading() || !x64_frameInsts[1]->GetIsFinishedLoading())
return false;
x90_resourcesLoaded = true;
StartTransition(FLT_EPSILON, mgr, x0_initialSubScreen, 2);
x91_initialTransition = true;
return true;
}
void CPauseScreen::StartTransition(float time, const CStateManager& mgr, ESubScreen subscreen, int b) {
if (subscreen == xc_nextSubscreen)
return;
xc_nextSubscreen = subscreen;
x4_ = b;
x10_alphaInterp = time;
std::unique_ptr<CPauseScreenBase>& newScreenSlot = x7c_screens[1 - x78_activeIdx];
std::unique_ptr<CGuiFrame>& newScreenInst = x64_frameInsts[1 - x78_activeIdx];
newScreenSlot = BuildPauseSubScreen(xc_nextSubscreen, mgr, *newScreenInst);
if (x7c_screens[x78_activeIdx])
x7c_screens[x78_activeIdx]->TransitioningAway();
x91_initialTransition = false;
}
bool CPauseScreen::InputEnabled() const {
if (xc_nextSubscreen != x8_curSubscreen)
return false;
if (const std::unique_ptr<CPauseScreenBase>& screenSlot = x7c_screens[x78_activeIdx])
if (screenSlot->InputDisabled())
return false;
if (const std::unique_ptr<CPauseScreenBase>& screenSlot = x7c_screens[1 - x78_activeIdx])
if (screenSlot->InputDisabled())
return false;
return true;
}
CPauseScreen::ESubScreen CPauseScreen::GetPreviousSubscreen(ESubScreen screen) {
switch (screen) {
case ESubScreen::Inventory:
return ESubScreen::Options;
case ESubScreen::Options:
return ESubScreen::LogBook;
case ESubScreen::LogBook:
return ESubScreen::Inventory;
default:
return ESubScreen::ToGame;
}
}
CPauseScreen::ESubScreen CPauseScreen::GetNextSubscreen(ESubScreen screen) {
switch (screen) {
case ESubScreen::Inventory:
return ESubScreen::LogBook;
case ESubScreen::Options:
return ESubScreen::Inventory;
case ESubScreen::LogBook:
return ESubScreen::Options;
default:
return ESubScreen::ToGame;
}
}
void CPauseScreen::ProcessControllerInput(const CStateManager& mgr, const CFinalInput& input) {
if (!IsLoaded())
return;
if (x8_curSubscreen == ESubScreen::ToGame)
return;
m_returnClicked = false;
m_nextClicked = false;
m_backClicked = false;
m_lClicked = false;
m_rClicked = false;
bool bExits = false;
if (std::unique_ptr<CPauseScreenBase>& curScreen = x7c_screens[x78_activeIdx]) {
float yOff = 0.f;
if (curScreen->CanDraw())
yOff = curScreen->GetCameraYBias();
CGuiWidgetDrawParms parms(1.f, zeus::CVector3f{0.f, 15.f * yOff, 0.f});
x34_loadedPauseScreenInstructions->ProcessMouseInput(input, parms);
if (curScreen->GetMode() == CPauseScreenBase::EMode::LeftTable)
bExits = true;
curScreen->ProcessControllerInput(input);
}
if (InputEnabled()) {
bool invalid = x8_curSubscreen == ESubScreen::ToGame;
if (input.PStart() || m_returnClicked ||
((input.PB() || m_backClicked || input.PSpecialKey(boo::ESpecialKey::Esc)) && bExits) ||
(x7c_screens[x78_activeIdx] && x7c_screens[x78_activeIdx]->ShouldExitPauseScreen())) {
CSfxManager::SfxStart(SFXui_pause_screen_exit, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
StartTransition(0.5f, mgr, ESubScreen::ToGame, 2);
} else {
if (ControlMapper::GetPressInput(ControlMapper::ECommands::PreviousPauseScreen, input) || m_lClicked) {
CSfxManager::SfxStart(SFXui_pause_screen_change, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
StartTransition(0.5f, mgr, GetPreviousSubscreen(x8_curSubscreen), invalid ? 2 : 0);
} else if (ControlMapper::GetPressInput(ControlMapper::ECommands::NextPauseScreen, input) || m_rClicked) {
CSfxManager::SfxStart(SFXui_pause_screen_change, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
StartTransition(0.5f, mgr, GetNextSubscreen(x8_curSubscreen), invalid ? 2 : 1);
}
}
}
x38_textpane_l1->TextSupport().SetText(
hecl::Format("&image=%8.8X;", u32(g_tweakPlayerRes->x74_lTrigger[input.DLTrigger() || m_lDown].Value())));
x3c_textpane_r->TextSupport().SetText(
hecl::Format("&image=%8.8X;", u32(g_tweakPlayerRes->x80_rTrigger[input.DRTrigger() || m_rDown].Value())));
x48_textpane_return->TextSupport().SetText(
hecl::Format("&image=%8.8X;", u32(g_tweakPlayerRes->x8c_startButton[input.DStart() || m_returnDown].Value())));
x50_textpane_back->TextSupport().SetText(
hecl::Format("&image=%8.8X;", u32(g_tweakPlayerRes->x98_aButton[input.DA() || m_backDown].Value())));
x4c_textpane_next->TextSupport().SetText(
hecl::Format("&image=%8.8X;", u32(g_tweakPlayerRes->xa4_bButton[input.DB() || m_nextDown].Value())));
}
void CPauseScreen::TransitionComplete() {
std::unique_ptr<CPauseScreenBase>& curScreen = x7c_screens[x78_activeIdx];
curScreen.reset();
x78_activeIdx = 1 - x78_activeIdx;
x8_curSubscreen = xc_nextSubscreen;
x40_textpane_a->TextSupport().SetText(x14_strgPauseScreen->GetString(int(GetPreviousSubscreen(x8_curSubscreen)) + 6));
x44_textpane_b->TextSupport().SetText(x14_strgPauseScreen->GetString(int(GetNextSubscreen(x8_curSubscreen)) + 6));
}
void CPauseScreen::OnWidgetMouseDown(CGuiWidget* widget, bool resume) {
if (widget == x48_textpane_return)
m_returnDown = true;
else if (widget == x4c_textpane_next)
m_backDown = true;
else if (widget == x50_textpane_back)
m_nextDown = true;
else if (widget == x38_textpane_l1 || widget == x40_textpane_a)
m_lDown = true;
else if (widget == x3c_textpane_r || widget == x44_textpane_b)
m_rDown = true;
}
void CPauseScreen::OnWidgetMouseUp(CGuiWidget* widget, bool cancel) {
if (widget == x48_textpane_return)
m_returnDown = false;
else if (widget == x4c_textpane_next)
m_backDown = false;
else if (widget == x50_textpane_back)
m_nextDown = false;
else if (widget == x38_textpane_l1 || widget == x40_textpane_a)
m_lDown = false;
else if (widget == x3c_textpane_r || widget == x44_textpane_b)
m_rDown = false;
if (cancel)
return;
if (widget == x48_textpane_return)
m_returnClicked = true;
else if (widget == x4c_textpane_next)
m_backClicked = true;
else if (widget == x50_textpane_back)
m_nextClicked = true;
else if (widget == x38_textpane_l1 || widget == x40_textpane_a)
m_lClicked = true;
else if (widget == x3c_textpane_r || widget == x44_textpane_b)
m_rClicked = true;
}
void CPauseScreen::Update(float dt, const CStateManager& mgr, CRandom16& rand, CArchitectureQueue& archQueue) {
if (!CheckLoadComplete(mgr))
return;
std::unique_ptr<CPauseScreenBase>& curScreen = x7c_screens[x78_activeIdx];
std::unique_ptr<CPauseScreenBase>& otherScreen = x7c_screens[1 - x78_activeIdx];
if (x8_curSubscreen != xc_nextSubscreen) {
x10_alphaInterp = std::max(0.f, x10_alphaInterp - dt);
if (!curScreen || !curScreen->InputDisabled()) {
if (!otherScreen || otherScreen->IsReady()) {
if (x10_alphaInterp == 0.f)
TransitionComplete();
}
}
}
if (std::unique_ptr<CPauseScreenBase>& curScreen = x7c_screens[x78_activeIdx]) {
curScreen->Update(dt, rand, archQueue);
zeus::CColor color = zeus::CColor::skWhite;
color.a() = std::min(curScreen->GetAlpha(), x8_curSubscreen != xc_nextSubscreen ? x10_alphaInterp / 0.5f : 1.f);
x40_textpane_a->SetColor(color);
x44_textpane_b->SetColor(color);
}
}
void CPauseScreen::PreDraw() {
if (!IsLoaded())
return;
if (std::unique_ptr<CPauseScreenBase>& curScreen = x7c_screens[x78_activeIdx])
if (curScreen->CanDraw())
curScreen->Touch();
}
void CPauseScreen::Draw() {
if (!IsLoaded())
return;
float totalAlpha = 0.f;
float yOff = 0.f;
std::unique_ptr<CPauseScreenBase>& curScreen = x7c_screens[x78_activeIdx];
if (curScreen && curScreen->CanDraw()) {
float useInterp = x10_alphaInterp == 0.f ? 1.f : x10_alphaInterp / 0.5f;
float initInterp = std::min(curScreen->GetAlpha(), useInterp);
if (xc_nextSubscreen == ESubScreen::ToGame)
totalAlpha = useInterp;
else if (x91_initialTransition)
totalAlpha = initInterp;
else
totalAlpha = 1.f;
curScreen->Draw(x8_curSubscreen != xc_nextSubscreen ? useInterp : 1.f, totalAlpha, 0.f);
yOff = curScreen->GetCameraYBias();
}
CGuiWidgetDrawParms parms(totalAlpha, zeus::CVector3f{0.f, 15.f * yOff, 0.f});
x34_loadedPauseScreenInstructions->Draw(parms);
}
bool CPauseScreen::ShouldSwitchToMapScreen() const {
return IsLoaded() && x8_curSubscreen == ESubScreen::ToMap && xc_nextSubscreen == ESubScreen::ToMap;
}
bool CPauseScreen::ShouldSwitchToInGame() const {
return IsLoaded() && x8_curSubscreen == ESubScreen::ToGame && xc_nextSubscreen == ESubScreen::ToGame;
}
float CPauseScreen::GetHelmetCamYOff() const {
CPauseScreenBase* screen = x7c_screens[x78_activeIdx].get();
if (screen)
return screen->GetCameraYBias();
return 0.f;
}
} // namespace urde::MP1