metaforce/Runtime/MP1/CFrontEndUI.hpp

#ifndef __URDE_CFRONTENDUI_HPP__
#define __URDE_CFRONTENDUI_HPP__

#include "CIOWin.hpp"
#include "CGameDebug.hpp"
#include "RetroTypes.hpp"
#include "CToken.hpp"
#include "Audio/CStaticAudioPlayer.hpp"
#include "Audio/CSfxManager.hpp"
#include "CGBASupport.hpp"
#include "zeus/CVector3f.hpp"
#include "Input/CRumbleGenerator.hpp"
#include "GuiSys/CGuiTextSupport.hpp"
#include "Graphics/Shaders/CTexturedQuadFilter.hpp"
#include "Graphics/Shaders/CColoredQuadFilter.hpp"
#include "CFrontEndUITouchBar.hpp"
#include "CGameOptionsTouchBar.hpp"

namespace urde
{
class CGuiSliderGroup;
class CGuiTableGroup;
class CMoviePlayer;
struct SObjectTag;
class CDependencyGroup;
class CTexture;
class CAudioGroupSet;
class CSaveWorld;
class CStringTable;
class CGuiFrame;
class CGuiTextPane;
class CGuiWidget;
class CGuiTableGroup;
class CGuiModel;

namespace MP1
{
class CNESEmulator;
class CSaveGameScreen;
class CQuitGameScreen;

class CFrontEndUI : public CIOWin
{
public:
    enum class EPhase
    {
        LoadDepsGroup,
        LoadDeps,
        LoadFrames,
        LoadMovies,
        DisplayFrontEnd,
        ToPlayGame,
        ExitFrontEnd
    };
    enum class EScreen
    {
        OpenCredits,
        Title,
        AttractMovie,
        FileSelect,
        FusionBonus,
        ToPlayGame
    };
    enum class EMenuMovie
    {
        Stopped = -1,
        FirstStart = 0,
        StartLoop,
        StartFileSelectA,
        FileSelectLoop,
        FileSelectPlayGameA,
        FileSelectGBA,
        GBALoop,
        GBAFileSelectA,
        GBAFileSelectB
    };

    static void PlayAdvanceSfx();

    struct SGuiTextPair
    {
        CGuiTextPane* x0_panes[2] = {};
        void SetPairText(std::u16string_view str);
    };
    static SGuiTextPair FindTextPanePair(CGuiFrame* frame, const char* name);
    static void FindAndSetPairText(CGuiFrame* frame, const char* name, std::u16string_view str);

    struct SFileMenuOption
    {
        CGuiWidget* x0_base;

        /* filename, world, playtime, date */
        SGuiTextPair x4_textpanes[4];

        u32 x28_curField = 0;
        float x2c_chRate = ComputeRandom();

        static float ComputeRandom()
        {
            return rand() / float(RAND_MAX) * 30.f + 30.f;
        }
    };

    struct SNewFileSelectFrame
    {
        enum class ESubMenu
        {
            Root,
            EraseGame,
            EraseGamePopup,
            NewGamePopup
        };

        enum class EAction
        {
            None,
            GameOptions,
            FusionBonus,
            SlideShow
        };

        u32 x0_rnd;
        CSaveGameScreen* x4_saveUI;
        ESubMenu x8_subMenu = ESubMenu::Root;
        EAction xc_action = EAction::None;
        TLockedToken<CGuiFrame> x10_frme;
        CGuiFrame* x1c_loadedFrame = nullptr;
        CGuiTableGroup* x20_tablegroup_fileselect = nullptr;
        CGuiModel* x24_model_erase = nullptr;
        SGuiTextPair x28_textpane_erase;
        SGuiTextPair x30_textpane_cheats;
        SGuiTextPair x38_textpane_gba;
        CGuiTableGroup* x40_tablegroup_popup = nullptr;
        CGuiModel* x44_model_dash7 = nullptr;
        SGuiTextPair x48_textpane_popupadvance;
        SGuiTextPair x50_textpane_popupcancel;
        SGuiTextPair x58_textpane_popupextra;
        CGuiTextPane* x60_textpane_cancel = nullptr;
        SFileMenuOption x64_fileSelections[3];
        zeus::CVector3f xf8_model_erase_position;
        float x104_rowPitch = 0.f;
        float x108_curTime = 0.f;
        bool x10c_saveReady = false;
        bool x10d_needsEraseToggle = false;
        bool x10e_needsNewToggle = false;

        CFrontEndUITouchBar& m_touchBar;

        SNewFileSelectFrame(CSaveGameScreen* sui, u32 rnd, CFrontEndUITouchBar& touchBar);
        void FinishedLoading();
        bool PumpLoad();
        bool IsTextDoneAnimating() const;
        void Update(float dt);
        EAction ProcessUserInput(const CFinalInput& input, CFrontEndUITouchBar::EAction tbAction);
        void Draw() const;

        void HandleActiveChange(CGuiTableGroup* active);
        void DeactivateEraseGamePopup();
        void ActivateEraseGamePopup();
        void DeactivateNewGamePopup();
        void ActivateNewGamePopup();

        void ResetFrame();
        void ActivateErase();
        void ClearFrameContents();
        void SetupFrameContents();

        void DoPopupCancel(CGuiTableGroup* caller);
        void DoPopupAdvance(CGuiTableGroup* caller);
        void DoFileMenuCancel(CGuiTableGroup* caller);
        void DoSelectionChange(CGuiTableGroup* caller, int oldSel);
        void DoFileMenuAdvance(CGuiTableGroup* caller);

        static SFileMenuOption FindFileSelectOption(CGuiFrame* frame, int idx);
        static void StartTextAnimating(CGuiTextPane* text, std::u16string_view str, float chRate);
    };

    struct SFusionBonusFrame
    {
        struct SGBALinkFrame
        {
            enum class EUIType
            {
                Empty = -1,
                InsertPak = 0,
                ConnectSocket = 1,
                PressStartAndSelect = 2,
                BeginLink = 3,
                Linking = 4,
                LinkFailed = 5,
                LinkCompleteOrLinking = 6,
                TurnOffGBA = 7,
                Complete = 8,
                Cancelled = 9
            };

            enum class EAction
            {
                None = 0,
                Complete = 1,
                Cancelled = 2
            };

            EUIType x0_uiType;
            CGBASupport* x4_gbaSupport;
            CGuiFrame* x8_frme;
            SGuiTextPair xc_textpane_instructions;
            CGuiTextPane* x14_textpane_yes = nullptr;
            CGuiTextPane* x18_textpane_no = nullptr;
            CGuiModel* x1c_model_gc = nullptr;
            CGuiModel* x20_model_gba = nullptr;
            CGuiModel* x24_model_cable = nullptr;
            CGuiModel* x28_model_circlegcport = nullptr;
            CGuiModel* x2c_model_circlegbaport = nullptr;
            CGuiModel* x30_model_circlestartselect = nullptr;
            CGuiModel* x34_model_pakout = nullptr;
            CGuiModel* x38_model_gbascreen = nullptr;
            CGuiModel* x3c_model_connect = nullptr;
            bool x40_linkInProgress;

            void SetUIText(EUIType tp);
            EAction ProcessUserInput(const CFinalInput &input, bool linkInProgress,
                                     CFrontEndUITouchBar::EAction tbAction);
            void Update(float dt);
            void FinishedLoading();
            void Draw();
            SGBALinkFrame(CGuiFrame* linkFrame, CGBASupport* support, bool linkInProgress);
        };

        enum class EAction
        {
            None,
            GoBack,
            PlayNESMetroid
        };

        std::unique_ptr<SGBALinkFrame> x0_gbaLinkFrame;
        std::unique_ptr<CGBASupport> x4_gbaSupport;
        EAction x8_action = EAction::None;
        TLockedToken<CGuiFrame> xc_gbaScreen;
        TLockedToken<CGuiFrame> x18_gbaLink;
        CGuiFrame* x24_loadedFrame = nullptr;
        CGuiTableGroup* x28_tablegroup_options = nullptr;
        CGuiTableGroup* x2c_tablegroup_fusionsuit = nullptr;
        SGuiTextPair x30_textpane_instructions;
        bool x38_lastDoDraw = false;
        bool x39_fusionNotComplete = false;
        bool x3a_mpNotComplete = false;

        CFrontEndUITouchBar& m_touchBar;

        SFusionBonusFrame(CFrontEndUITouchBar& touchBar);
        void FinishedLoading();
        bool PumpLoad();
        void SetTableColors(CGuiTableGroup* tbgp) const;
        void Update(float dt, CSaveGameScreen* saveUI);
        EAction ProcessUserInput(const CFinalInput& input, CSaveGameScreen* sui,
                                 CFrontEndUITouchBar::EAction tbAction);
        void Draw() const;

        void ResetCompletionFlags()
        {
            x39_fusionNotComplete = false;
            x3a_mpNotComplete = false;
        }

        void DoCancel(CGuiTableGroup* caller);
        void DoSelectionChange(CGuiTableGroup* caller, int oldSel);
        void DoAdvance(CGuiTableGroup* caller);
    };

    struct SFrontEndFrame
    {
        enum class EAction
        {
            None,
            StartGame,
            FusionBonus,
            GameOptions,
            SlideShow
        };

        u32 x0_rnd;
        EAction x4_action;
        TLockedToken<CGuiFrame> x8_frme;
        CGuiFrame* x14_loadedFrme = nullptr;
        CGuiTableGroup* x18_tablegroup_mainmenu = nullptr;
        SGuiTextPair x1c_gbaPair;
        SGuiTextPair x24_cheatPair;

        CFrontEndUITouchBar& m_touchBar;

        SFrontEndFrame(u32 rnd, CFrontEndUITouchBar& touchBar);
        void FinishedLoading();
        bool PumpLoad();
        void Update(float dt);
        EAction ProcessUserInput(const CFinalInput& input, CFrontEndUITouchBar::EAction tbAction);
        void Draw() const;
        void HandleActiveChange(CGuiTableGroup* active);

        void DoCancel(CGuiTableGroup* caller);
        void DoSelectionChange(CGuiTableGroup* caller, int oldSel);
        void DoAdvance(CGuiTableGroup* caller);
    };

    struct SNesEmulatorFrame
    {
        enum class EMode
        {
            Emulator,
            SaveProgress,
            ContinuePlaying,
            QuitNESMetroid
        };

        EMode x0_mode = EMode::Emulator;
        std::unique_ptr<CNESEmulator> x4_nesEmu;
        std::unique_ptr<CQuitGameScreen> x8_quitScreen;
        std::unique_ptr<CGuiTextSupport> xc_textSupport;
        float x10_remTime = 8.f;
        bool x14_emulationSuspended = false;
        bool x15_enableFiltering = true;

        SNesEmulatorFrame();
        void SetMode(EMode mode);
        void ProcessUserInput(const CFinalInput& input, CSaveGameScreen* sui);
        bool Update(float dt, CSaveGameScreen* saveUi);
        void Draw(CSaveGameScreen* saveUi) const;
    };

    struct SOptionsFrontEndFrame
    {
        float x0_uiAlpha = 0.f;
        TLockedToken<CGuiFrame> x4_frme;
        TLockedToken<CStringTable> x10_pauseScreen;
        CGuiFrame* x1c_loadedFrame = nullptr;
        CStringTable* x20_loadedPauseStrg = nullptr;
        CGuiTableGroup* x24_tablegroup_leftmenu = nullptr;
        CGuiTableGroup* x28_tablegroup_rightmenu = nullptr;
        CGuiTableGroup* x2c_tablegroup_double = nullptr;
        CGuiTableGroup* x30_tablegroup_triple = nullptr;
        CGuiSliderGroup* x34_slidergroup_slider = nullptr;
        float x38_rowPitch = 0.f;
        CSfxHandle x3c_sliderSfx;
        CRumbleGenerator x40_rumbleGen;
        union
        {
            u8 _dummy = 0;
            struct
            {
                bool x134_24_visible : 1;
                bool x134_25_exitOptions : 1;
            };
        };

        std::unique_ptr<CGameOptionsTouchBar> m_touchBar;
        bool m_touchBarInValue = false;
        bool m_touchBarValueDirty = false;

        SOptionsFrontEndFrame();

        void DoSliderChange(CGuiSliderGroup* caller, float value);
        void DoMenuCancel(CGuiTableGroup* caller);
        void DoMenuSelectionChange(CGuiTableGroup* caller, int oldSel);
        void DoLeftMenuAdvance(CGuiTableGroup* caller);

        void DeactivateRightMenu();
        void HandleRightSelectionChange();

        void SetRightUIText();
        void SetTableColors(CGuiTableGroup* tbgp) const;
        void FinishedLoading();
        bool PumpLoad();

        bool ProcessUserInput(const CFinalInput& input, CSaveGameScreen* sui);
        void Update(float dt, CSaveGameScreen* saveUi);
        void Draw() const;
    };

    bool CanShowSaveUI() const
    {
        if (x50_curScreen != EScreen::FileSelect && x50_curScreen != EScreen::FusionBonus)
            return false;
        if (x54_nextScreen != EScreen::FileSelect && x54_nextScreen != EScreen::FusionBonus)
            return false;
        return true;
    }

private:
    EPhase x14_phase = EPhase::LoadDepsGroup;
    u32 x18_rndA;
    u32 x1c_rndB;
    TLockedToken<CDependencyGroup> x20_depsGroup;
    std::vector<CToken> x2c_deps;
    TLockedToken<CTexture> x38_pressStart;
    TLockedToken<CAudioGroupSet> x44_frontendAudioGrp;
    EScreen x50_curScreen = EScreen::OpenCredits;
    EScreen x54_nextScreen = EScreen::OpenCredits;
    float x58_fadeBlackTimer = 0.f;
    bool x5c_fadeBlackWithMovie = false;
    float x60_pressStartTime = 0.f;
    float x64_pressStartAlpha = 0.f;
    float x68_musicVol = 1.f;
    u32 x6c_;
    std::unique_ptr<CMoviePlayer> x70_menuMovies[9];
    EMenuMovie xb8_curMovie = EMenuMovie::Stopped;
    int xbc_nextAttract = 0;
    int xc0_attractCount = 0;
    std::unique_ptr<CMoviePlayer> xc4_attractMovie;
    CMoviePlayer* xcc_curMoviePtr = nullptr;
    bool xd0_playerSkipToTitle = false;
    bool xd1_moviesLoaded = false;
    bool xd2_deferSlideShow = false;
    std::unique_ptr<CStaticAudioPlayer> xd4_audio1;
    std::unique_ptr<CStaticAudioPlayer> xd8_audio2;
    std::unique_ptr<CSaveGameScreen> xdc_saveUI;
    std::unique_ptr<SNewFileSelectFrame> xe0_frontendCardFrme;
    std::unique_ptr<SFusionBonusFrame> xe4_fusionBonusFrme;
    std::unique_ptr<SFrontEndFrame> xe8_frontendNoCardFrme;
    std::unique_ptr<SNesEmulatorFrame> xec_emuFrme;
    std::unique_ptr<SOptionsFrontEndFrame> xf0_optionsFrme;
    CStaticAudioPlayer* xf4_curAudio = nullptr;

    CColoredQuadFilter m_fadeToBlack = {EFilterType::Blend};
    std::experimental::optional<CTexturedQuadFilterAlpha> m_pressStartQuad;

    std::unique_ptr<CFrontEndUITouchBar> m_touchBar;

    void SetFadeBlackWithMovie()
    {
        x58_fadeBlackTimer = 1000000.f;
        x5c_fadeBlackWithMovie = true;
    }

    void SetFadeBlackTimer(float seconds)
    {
        x58_fadeBlackTimer = seconds;
        x5c_fadeBlackWithMovie = false;
    }

    void TransitionToGame();
    void UpdateMusicVolume();
    void FinishedLoadingDepsGroup();
    bool PumpLoad();
public:

    CFrontEndUI();
    void StartSlideShow(CArchitectureQueue& queue);
    std::string GetAttractMovieFileName(int idx);
    std::string GetNextAttractMovieFileName();
    void SetCurrentMovie(EMenuMovie movie);
    void StopAttractMovie();
    void StartAttractMovie();
    void StartStateTransition(EScreen screen);
    void CompleteStateTransition();
    void HandleDebugMenuReturnValue(CGameDebug::EReturnValue val, CArchitectureQueue& queue);
    void Draw() const;
    void UpdateMovies(float dt);
    bool PumpMovieLoad();
    void ProcessUserInput(const CFinalInput& input, CArchitectureQueue& queue);
    EMessageReturn Update(float dt, CArchitectureQueue& queue);
    EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue);
};

}
}

#endif // __URDE_CFRONTENDUI_HPP__