mirror of
https://github.com/AxioDL/metaforce.git
synced 2025-05-14 11:51:21 +00:00
902f4fb5c5
Now, with all of the headers normalized, we can safely convert some headers into forward declarations without needing to worry about potentially breaking code in other headers or source files.
247 lines
10 KiB
C++
247 lines
10 KiB
C++
#pragma once
|
|
|
|
#include <memory>
|
|
#include <string_view>
|
|
#include <vector>
|
|
|
|
#include "Runtime/CToken.hpp"
|
|
#include "Runtime/rstl.hpp"
|
|
#include "Runtime/Camera/CCameraFilter.hpp"
|
|
#include "Runtime/Graphics/Shaders/CRandomStaticFilter.hpp"
|
|
#include "Runtime/GuiSys/CHudBallInterface.hpp"
|
|
#include "Runtime/GuiSys/CHudBossEnergyInterface.hpp"
|
|
#include "Runtime/GuiSys/CHudDecoInterface.hpp"
|
|
#include "Runtime/GuiSys/CHudEnergyInterface.hpp"
|
|
#include "Runtime/GuiSys/CHudFreeLookInterface.hpp"
|
|
#include "Runtime/GuiSys/CHudHelmetInterface.hpp"
|
|
#include "Runtime/GuiSys/CHudMissileInterface.hpp"
|
|
#include "Runtime/GuiSys/CHudRadarInterface.hpp"
|
|
#include "Runtime/GuiSys/CHudThreatInterface.hpp"
|
|
#include "Runtime/GuiSys/CHudVisorBeamMenu.hpp"
|
|
#include "Runtime/GuiSys/CTargetingManager.hpp"
|
|
#include "Runtime/MP1/CInGameGuiManager.hpp"
|
|
#include "Runtime/World/CHUDMemoParms.hpp"
|
|
|
|
#include <zeus/CColor.hpp>
|
|
#include <zeus/CMatrix3f.hpp>
|
|
#include <zeus/CQuaternion.hpp>
|
|
#include <zeus/CVector3f.hpp>
|
|
|
|
namespace urde {
|
|
class CGuiFrame;
|
|
class CGuiLight;
|
|
class CStateManager;
|
|
|
|
enum class EHudState { Combat, XRay, Thermal, Scan, Ball, None };
|
|
|
|
namespace MP1 {
|
|
|
|
class CSamusHud {
|
|
enum class ELoadPhase { Zero, One, Two, Three };
|
|
|
|
enum class ETransitionState { NotTransitioning, Countdown, Loading, Transitioning };
|
|
|
|
struct SCachedHudLight {
|
|
zeus::CVector3f x0_pos;
|
|
zeus::CColor xc_color;
|
|
float x10_distC = 0.f;
|
|
float x14_distL = 0.f;
|
|
float x18_distQ = 0.f;
|
|
float x1c_fader = 0.f;
|
|
SCachedHudLight(const zeus::CVector3f& pos, const zeus::CColor& color, float f1, float f2, float f3, float f4)
|
|
: x0_pos(pos), xc_color(color), x10_distC(f1), x14_distL(f2), x18_distQ(f3), x1c_fader(f4) {}
|
|
};
|
|
|
|
struct SVideoBand {
|
|
CGuiModel* x0_videoband = nullptr;
|
|
float x4_randA = 0.f;
|
|
float x8_randB = 0.f;
|
|
};
|
|
|
|
struct SProfileInfo {
|
|
u32 x0_ = 0;
|
|
u32 x4_ = 0;
|
|
u64 x8_profUsec = 0;
|
|
};
|
|
|
|
friend class CInGameGuiManager;
|
|
ELoadPhase x4_loadPhase = ELoadPhase::Zero;
|
|
CTargetingManager x8_targetingMgr;
|
|
TLockedToken<CGuiFrame> x258_frmeHelmet;
|
|
CGuiFrame* x264_loadedFrmeHelmet = nullptr;
|
|
TLockedToken<CGuiFrame> x268_frmeBaseHud;
|
|
CGuiFrame* x274_loadedFrmeBaseHud = nullptr;
|
|
TLockedToken<CGuiFrame> x278_selectedHud; // used to be optional
|
|
CGuiFrame* x288_loadedSelectedHud = nullptr;
|
|
std::unique_ptr<CHudEnergyInterface> x28c_energyIntf;
|
|
std::unique_ptr<CHudThreatInterface> x290_threatIntf;
|
|
std::unique_ptr<CHudMissileInterface> x294_missileIntf;
|
|
std::unique_ptr<IFreeLookInterface> x298_freeLookIntf;
|
|
std::unique_ptr<IHudDecoInterface> x29c_decoIntf;
|
|
std::unique_ptr<CHudHelmetInterface> x2a0_helmetIntf;
|
|
std::unique_ptr<CHudVisorBeamMenu> x2a4_visorMenu;
|
|
std::unique_ptr<CHudVisorBeamMenu> x2a8_beamMenu;
|
|
std::unique_ptr<CHudRadarInterface> x2ac_radarIntf;
|
|
std::unique_ptr<CHudBallInterface> x2b0_ballIntf;
|
|
std::unique_ptr<CHudBossEnergyInterface> x2b4_bossEnergyIntf;
|
|
EHudState x2b8_curState = EHudState::None;
|
|
EHudState x2bc_nextState = EHudState::None;
|
|
EHudState x2c0_setState = EHudState::None;
|
|
ETransitionState x2c4_activeTransState = ETransitionState::NotTransitioning;
|
|
float x2c8_transT = 1.f;
|
|
u32 x2cc_preLoadCountdown = 0;
|
|
float x2d0_playerHealth = 0.f;
|
|
u32 x2d4_totalEnergyTanks = 0;
|
|
u32 x2d8_missileAmount = 0;
|
|
u32 x2dc_missileCapacity = 0;
|
|
|
|
union {
|
|
struct {
|
|
bool x2e0_24_inFreeLook : 1;
|
|
bool x2e0_25_lookControlHeld : 1;
|
|
bool x2e0_26_latestFirstPerson : 1;
|
|
bool x2e0_27_energyLow : 1;
|
|
};
|
|
u16 _dummy = 0;
|
|
};
|
|
|
|
u32 x2e4_ = 0;
|
|
u32 x2e8_ = 0;
|
|
CPlayerGun::EMissleMode x2ec_missileMode = CPlayerGun::EMissleMode::Inactive;
|
|
float x2f0_visorBeamMenuAlpha = 1.f;
|
|
zeus::CVector3f x2f8_fpCamDir;
|
|
zeus::CVector3f x304_basewidgetIdlePos;
|
|
zeus::CVector3f x310_cameraPos;
|
|
zeus::CQuaternion x31c_hudLag;
|
|
zeus::CQuaternion x32c_invHudLag;
|
|
std::unique_ptr<CActorLights> x33c_lights;
|
|
rstl::reserved_vector<SCachedHudLight, 3> x340_hudLights;
|
|
CSfxHandle x3a4_damageSfx;
|
|
CCameraFilterPass<CColoredQuadFilter> x3a8_camFilter;
|
|
CGuiLight* x3d4_damageLight = nullptr;
|
|
std::vector<zeus::CTransform> x3d8_lightTransforms;
|
|
float x3e8_damageTIme = 0.f;
|
|
float x3ec_damageLightPulser = 0.f;
|
|
float x3f0_damageFilterAmtInit = 1.f;
|
|
float x3f4_damageFilterAmt = 0.f;
|
|
float x3f8_damageFilterAmtGain = 0.f;
|
|
float x3fc_hudDamagePracticalsInit = 0.f;
|
|
float x400_hudDamagePracticals = 0.f;
|
|
float x404_hudDamagePracticalsGain = 0.f;
|
|
zeus::CVector3f x408_damagerToPlayerNorm;
|
|
float x414_decoShakeTranslateAmt = 0.f;
|
|
float x418_decoShakeTranslateAmtVel = 0.f;
|
|
zeus::CVector3f x41c_decoShakeTranslate;
|
|
zeus::CMatrix3f x428_decoShakeRotate;
|
|
zeus::CQuaternion x44c_hudLagShakeRot;
|
|
float x45c_decoShakeAmtInit = 0.f;
|
|
float x460_decoShakeAmt = 0.f;
|
|
float x464_decoShakeAmtGain = 0.f;
|
|
rstl::reserved_vector<zeus::CTransform, 3> x46c_;
|
|
zeus::CVector2f x500_viewportScale = {1.f, 1.f};
|
|
CSfxHandle x508_staticSfxHi;
|
|
CSfxHandle x50c_staticSfxLo;
|
|
float x510_staticInterp = 0.f;
|
|
float x514_staticCycleTimerHi = 0.f;
|
|
float x518_staticCycleTimerLo = 0.f;
|
|
CCameraFilterPass<CRandomStaticFilter> x51c_camFilter2;
|
|
CHUDMemoParms x548_hudMemoParms;
|
|
TLockedToken<CStringTable> x550_hudMemoString;
|
|
u32 x554_hudMemoIdx = 0;
|
|
float x558_messageTextTime = 0.f;
|
|
float x55c_lastSfxChars = 0.f;
|
|
float x560_messageTextScale = 0.f;
|
|
CSfxHandle x564_freeLookSfx;
|
|
zeus::CVector3f x568_fpCamDir;
|
|
float x574_lookDeltaDot = 1.f;
|
|
float x578_freeLookSfxCycleTimer = 0.f;
|
|
float x57c_energyLowTimer = 0.f;
|
|
float x580_energyLowPulse = 0.f;
|
|
float x584_abuttonPulse = 0.f;
|
|
CGuiWidget* x588_base_basewidget_pivot;
|
|
CGuiWidget* x58c_helmet_BaseWidget_Pivot;
|
|
CGuiModel* x590_base_Model_AutoMapper;
|
|
CGuiTextPane* x594_base_textpane_counter;
|
|
CGuiWidget* x598_base_basewidget_message;
|
|
CGuiTextPane* x59c_base_textpane_message;
|
|
CGuiModel* x5a0_base_model_abutton;
|
|
rstl::reserved_vector<SVideoBand, 4> x5a4_videoBands;
|
|
rstl::reserved_vector<CGuiLight*, 4> x5d8_guiLights;
|
|
float x5ec_camFovTweaks[16];
|
|
float x62c_camYTweaks[64];
|
|
float x72c_camZTweaks[32];
|
|
rstl::reserved_vector<SProfileInfo, 15> x7ac_;
|
|
|
|
CColoredQuadFilter m_energyDrainFilter;
|
|
CCookieCutterDepthRandomStaticFilter m_cookieCutterStatic = {EFilterType::NoColor};
|
|
|
|
static CSamusHud* g_SamusHud;
|
|
static rstl::reserved_vector<bool, 4> BuildPlayerHasVisors(const CStateManager& mgr);
|
|
static rstl::reserved_vector<bool, 4> BuildPlayerHasBeams(const CStateManager& mgr);
|
|
void InitializeFrameGluePermanent(const CStateManager& mgr);
|
|
void InitializeFrameGlueMutable(const CStateManager& mgr);
|
|
void UninitializeFrameGlueMutable();
|
|
void InitializeDamageLight();
|
|
void UpdateEnergy(float dt, const CStateManager& mgr, bool init);
|
|
void UpdateFreeLook(float dt, const CStateManager& mgr);
|
|
void UpdateMissile(float dt, const CStateManager& mgr, bool init);
|
|
void UpdateVideoBands(float dt, const CStateManager& mgr);
|
|
void UpdateBallMode(const CStateManager& mgr, bool init);
|
|
void UpdateThreatAssessment(float dt, const CStateManager& mgr);
|
|
void UpdateVisorAndBeamMenus(float dt, const CStateManager& mgr);
|
|
void UpdateCameraDebugSettings();
|
|
void UpdateEnergyLow(float dt, const CStateManager& mgr);
|
|
void ApplyClassicLag(const zeus::CUnitVector3f& lookDir, zeus::CQuaternion& rot, const CStateManager& mgr, float dt,
|
|
bool invert);
|
|
void UpdateHudLag(float dt, const CStateManager& mgr);
|
|
bool IsCachedLightInAreaLights(const SCachedHudLight& light, const CActorLights& areaLights) const;
|
|
bool IsAreaLightInCachedLights(const CLight& light) const;
|
|
int FindEmptyHudLightSlot(const CLight& light) const;
|
|
zeus::CColor GetVisorHudLightColor(const zeus::CColor& color, const CStateManager& mgr) const;
|
|
void UpdateHudDynamicLights(float dt, const CStateManager& mgr);
|
|
void UpdateHudDamage(float dt, const CStateManager& mgr, DataSpec::ITweakGui::EHelmetVisMode helmetVis);
|
|
void UpdateStaticSfx(CSfxHandle& handle, float& cycleTimer, u16 sfxId, float dt, float oldStaticInterp,
|
|
float staticThreshold);
|
|
void UpdateStaticInterference(float dt, const CStateManager& mgr);
|
|
int GetRelativeDirection(const zeus::CVector3f& position, const CStateManager& mgr);
|
|
void ShowDamage(const zeus::CVector3f& position, float dam, float prevDam, const CStateManager& mgr);
|
|
void EnterFirstPerson(const CStateManager& mgr);
|
|
void LeaveFirstPerson(const CStateManager& mgr);
|
|
void DrawAttachedEnemyEffect(const CStateManager& mgr) const;
|
|
static EHudState GetDesiredHudState(const CStateManager& mgr);
|
|
|
|
public:
|
|
CSamusHud(CStateManager& stateMgr);
|
|
~CSamusHud();
|
|
void Update(float dt, const CStateManager& mgr, CInGameGuiManager::EHelmetVisMode helmetVis, bool hudVis,
|
|
bool targetingManager);
|
|
void Draw(const CStateManager& mgr, float alpha, CInGameGuiManager::EHelmetVisMode helmetVis, bool hudVis,
|
|
bool targetingManager) const;
|
|
void DrawHelmet(const CStateManager& mgr, float camYOff) const;
|
|
void ProcessControllerInput(const CFinalInput& input);
|
|
void UpdateStateTransition(float time, const CStateManager& mgr);
|
|
bool CheckLoadComplete(CStateManager& stateMgr);
|
|
void OnNewInGameGuiState(EInGameGuiState state, CStateManager& stateMgr);
|
|
void RefreshHudOptions();
|
|
void Touch();
|
|
CTargetingManager& GetTargetingManager() { return x8_targetingMgr; }
|
|
const zeus::CVector2f& GetViewportScale() const { return x500_viewportScale; }
|
|
static zeus::CTransform BuildFinalCameraTransform(const zeus::CQuaternion& rot, const zeus::CVector3f& pos,
|
|
const zeus::CVector3f& camPos);
|
|
static void DisplayHudMemo(std::u16string_view text, const CHUDMemoParms& info) {
|
|
if (g_SamusHud)
|
|
g_SamusHud->InternalDisplayHudMemo(text, info);
|
|
}
|
|
void InternalDisplayHudMemo(std::u16string_view text, const CHUDMemoParms& info) { SetMessage(text, info); }
|
|
void SetMessage(std::u16string_view text, const CHUDMemoParms& info);
|
|
static void DeferHintMemo(CAssetId strg, u32 strgIdx, const CHUDMemoParms& info) {
|
|
if (g_SamusHud)
|
|
g_SamusHud->InternalDeferHintMemo(strg, strgIdx, info);
|
|
}
|
|
void InternalDeferHintMemo(CAssetId strg, u32 strgIdx, const CHUDMemoParms& info);
|
|
CGuiFrame* GetBaseHudFrame() const { return x274_loadedFrmeBaseHud; }
|
|
};
|
|
|
|
} // namespace MP1
|
|
} // namespace urde
|