AxioDL/metaforce
2
0
Fork 0
mirror of https://github.com/AxioDL/metaforce.git synced 2025-12-09 23:47:43 +00:00
Code Issues Projects Releases Wiki Activity

Additional HUD interfaces

Browse Source
This commit is contained in:
Jack Andersen
2017-04-03 19:48:13 -10:00
parent 67ed82bc52
commit dc781f5c67
23 changed files with 631 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Runtime/GuiSys/CAuiEnergyBarT01.hpp
View File

@@ -47,6 +47,7 @@ public:
void Update(float dt);
void Draw(const CGuiWidgetDrawParms& drawParms) const;
float GetActualFraction() const { return xe0_maxEnergy == 0.f ? 0.f : xf4_setEnergy / xe0_maxEnergy; }
float GetSetEnergy() const { return xf4_setEnergy; }
float GetFilledEnergy() const { return xf8_filledEnergy; }
void SetCurrEnergy(float e, ESetMode mode);
void SetCoordFunc(FCoordFunc func) { xd8_coordFunc = func; }

6
Runtime/GuiSys/CGuiWidget.cpp
View File

@@ -115,6 +115,12 @@ bool CGuiWidget::GetIsFinishedLoadingWidgetSpecific() const
return true;
}
void CGuiWidget::SetTransform(const zeus::CTransform& xf)
{
x74_transform = xf;
ReapplyXform();
}
void CGuiWidget::SetIdlePosition(const zeus::CVector3f& pos, bool reapply)
{
x74_transform.origin = pos;

1
Runtime/GuiSys/CGuiWidget.hpp
View File

@@ -113,6 +113,7 @@ public:
const zeus::CTransform& GetTransform() const {return x74_transform;}
zeus::CTransform& GetTransform() {return x74_transform;}
const zeus::CVector3f& GetIdlePosition() const {return x74_transform.origin;}
void SetTransform(const zeus::CTransform& xf);
const zeus::CColor& GetGeometryColor() const { return xa8_color2; }
void SetIdlePosition(const zeus::CVector3f& pos, bool reapply);
void ReapplyXform();

55
Runtime/GuiSys/CHudBossEnergyInterface.cpp
View File

@@ -1,11 +1,66 @@
#include "CHudBossEnergyInterface.hpp"
#include "CGuiFrame.hpp"
#include "CAuiEnergyBarT01.hpp"
#include "GameGlobalObjects.hpp"
#include "CGuiTextPane.hpp"
namespace urde
{
CHudBossEnergyInterface::CHudBossEnergyInterface(CGuiFrame& selHud)
{
x10_24_visible = false;
x14_basewidget_bossenergystuff = selHud.FindWidget("basewidget_bossenergystuff");
x18_energybart01_bossbar = static_cast<CAuiEnergyBarT01*>(selHud.FindWidget("energybart01_bossbar"));
x1c_textpane_boss = static_cast<CGuiTextPane*>(selHud.FindWidget("textpane_boss"));
x18_energybart01_bossbar->SetCoordFunc(BossEnergyCoordFunc);
x18_energybart01_bossbar->SetTesselation(0.2f);
ITweakGuiColors::VisorEnergyBarColors barColors = g_tweakGuiColors->GetVisorEnergyBarColors(0);
x18_energybart01_bossbar->SetFilledColor(barColors.filled);
x18_energybart01_bossbar->SetShadowColor(barColors.shadow);
x18_energybart01_bossbar->SetEmptyColor(barColors.empty);
}
void CHudBossEnergyInterface::Update(float dt)
{
if (x10_24_visible)
x4_fader = std::min(x4_fader + dt, 1.f);
else
x4_fader = std::max(0.f, x4_fader - dt);
if (x4_fader > 0.f)
{
zeus::CColor color = zeus::CColor::skWhite;
color.a = x0_alpha * x4_fader;
x14_basewidget_bossenergystuff->SetColor(color);
x14_basewidget_bossenergystuff->SetVisibility(true, ETraversalMode::Children);
}
else
{
x14_basewidget_bossenergystuff->SetVisibility(false, ETraversalMode::Children);
}
}
void CHudBossEnergyInterface::SetBossParams(bool visible, const std::u16string& name,
float curEnergy, float maxEnergy)
{
x10_24_visible = visible;
if (visible)
{
x18_energybart01_bossbar->SetFilledDrainSpeed(maxEnergy);
x18_energybart01_bossbar->SetCurrEnergy(curEnergy, CAuiEnergyBarT01::ESetMode::Normal);
x18_energybart01_bossbar->SetMaxEnergy(maxEnergy);
x1c_textpane_boss->TextSupport()->SetText(name);
}
x8_curEnergy = curEnergy;
xc_maxEnergy = maxEnergy;
}
std::pair<zeus::CVector3f, zeus::CVector3f> CHudBossEnergyInterface::BossEnergyCoordFunc(float t)
{
float x = 9.25f * t - 4.625f;
return {zeus::CVector3f(x, 0.f, 0.f), zeus::CVector3f(x, 0.f, 0.4f)};
}
}

19
Runtime/GuiSys/CHudBossEnergyInterface.hpp
View File

@@ -1,15 +1,32 @@
#ifndef __URDE_CHUDBOSSENERGYINTERFACE_HPP__
#define __URDE_CHUDBOSSENERGYINTERFACE_HPP__
#include "RetroTypes.hpp"
namespace urde
{
class CGuiFrame;
class CGuiWidget;
class CAuiEnergyBarT01;
class CGuiTextPane;
class CHudBossEnergyInterface
{
float x0_alpha;
float x4_fader = 0.f;
float x8_curEnergy = 0.f;
float xc_maxEnergy = 0.f;
bool x10_24_visible : 1;
CGuiWidget* x14_basewidget_bossenergystuff;
CAuiEnergyBarT01* x18_energybart01_bossbar;
CGuiTextPane* x1c_textpane_boss;
public:
void SetAlpha(float a) { x0_alpha = a; }
CHudBossEnergyInterface(CGuiFrame& selHud);
void Update(float dt);
void SetAlpha(float a) { x0_alpha = a; }
void SetBossParams(bool visible, const std::u16string& name,
float curEnergy, float maxEnergy);
static std::pair<zeus::CVector3f, zeus::CVector3f> BossEnergyCoordFunc(float t);
};
}

20
Runtime/GuiSys/CHudEnergyInterface.cpp
View File

@@ -21,12 +21,12 @@ static const CAuiEnergyBarT01::FCoordFunc CoordFuncs[] =
static const float Tesselations[] =
{
0.2f, 0.2f, 0.1f, 0.2f, 0.1f
0.2f, 0.2f, 0.1f, 0.2f, 1.f
};
CHudEnergyInterface::CHudEnergyInterface(CGuiFrame& selHud, float tankEnergy, int totalEnergyTanks,
int numTanksFilled, bool energyLow, EBarType barType)
: x0_barType(barType), xc_tankEnergy(tankEnergy), x10_totalEnergyTanks(totalEnergyTanks),
int numTanksFilled, bool energyLow, EHudType hudType)
: x0_hudType(hudType), xc_tankEnergy(tankEnergy), x10_totalEnergyTanks(totalEnergyTanks),
x14_numTanksFilled(numTanksFilled)
{
x1c_24_ = true;
@@ -39,11 +39,11 @@ CHudEnergyInterface::CHudEnergyInterface(CGuiFrame& selHud, float tankEnergy, in
x28_textpane_energywarning = static_cast<CGuiTextPane*>(selHud.FindWidget("textpane_energywarning"));
x2c_energybart01_energybar = static_cast<CAuiEnergyBarT01*>(selHud.FindWidget("energybart01_energybar"));
x2c_energybart01_energybar->SetCoordFunc(CoordFuncs[int(barType)]);
x2c_energybart01_energybar->SetTesselation(Tesselations[int(barType)]);
x2c_energybart01_energybar->SetCoordFunc(CoordFuncs[int(hudType)]);
x2c_energybart01_energybar->SetTesselation(Tesselations[int(hudType)]);
ITweakGuiColors::VisorEnergyBarColors barColors = g_tweakGuiColors->GetVisorEnergyBarColors(int(barType));
ITweakGuiColors::VisorEnergyInitColors initColors = g_tweakGuiColors->GetVisorEnergyInitColors(int(barType));
ITweakGuiColors::VisorEnergyBarColors barColors = g_tweakGuiColors->GetVisorEnergyBarColors(int(hudType));
ITweakGuiColors::VisorEnergyInitColors initColors = g_tweakGuiColors->GetVisorEnergyInitColors(int(hudType));
x20_textpane_energydigits->TextSupport()->SetFontColor(initColors.digitsFont);
x20_textpane_energydigits->TextSupport()->SetOutlineColor(initColors.digitsOutline);
@@ -108,12 +108,12 @@ void CHudEnergyInterface::Update(float dt, float energyLowPulse)
{
x1c_26_barDirty = false;
x18_cachedBarEnergy = x2c_energybart01_energybar->GetFilledEnergy();
std::u16string string = hecl::UTF8ToChar16(hecl::Format("%02d",
int(std::fmod(x18_cachedBarEnergy, CPlayerState::GetEnergyTankCapacity()))));
std::string string = hecl::Format("%02d",
int(std::fmod(x18_cachedBarEnergy, CPlayerState::GetEnergyTankCapacity())));
x20_textpane_energydigits->TextSupport()->SetText(string);
}
ITweakGuiColors::VisorEnergyBarColors barColors = g_tweakGuiColors->GetVisorEnergyBarColors(int(x0_barType));
ITweakGuiColors::VisorEnergyBarColors barColors = g_tweakGuiColors->GetVisorEnergyBarColors(int(x0_hudType));
zeus::CColor emptyColor = x1c_27_energyLow ? g_tweakGuiColors->GetEnergyBarEmptyLowEnergy() : barColors.empty;
zeus::CColor filledColor = x1c_27_energyLow ? g_tweakGuiColors->GetEnergyBarFilledLowEnergy() : barColors.filled;
zeus::CColor shadowColor = x1c_27_energyLow ? g_tweakGuiColors->GetEnergyBarShadowLowEnergy() : barColors.shadow;

15
Runtime/GuiSys/CHudEnergyInterface.hpp
View File

@@ -2,6 +2,7 @@
#define __URDE_CHUDENERGYINTERFACE_HPP__
#include "RetroTypes.hpp"
#include "CHudInterface.hpp"
namespace urde
{
@@ -13,17 +14,7 @@ class CAuiEnergyBarT01;
class CHudEnergyInterface
{
public:
enum class EBarType
{
Combat,
Scan,
XRay,
Thermal,
Ball
};
private:
EBarType x0_barType;
EHudType x0_hudType;
float x4_energyLowFader = 0.f;
float x8_flashMag = 0.f;
float xc_tankEnergy;
@@ -47,7 +38,7 @@ private:
CAuiEnergyBarT01* x2c_energybart01_energybar;
public:
CHudEnergyInterface(CGuiFrame& selHud, float tankEnergy, int totalEnergyTanks,
int numTanksFilled, bool energyLow, EBarType barType);
int numTanksFilled, bool energyLow, EHudType hudType);
void Update(float dt, float energyLowPulse);
void SetEnergyLow(bool energyLow);
void SetFlashMagnitude(float mag);

52
Runtime/GuiSys/CHudHelmetInterface.cpp
View File

@@ -1,31 +1,77 @@
#include "CHudHelmetInterface.hpp"
#include "CGuiFrame.hpp"
#include "CGuiCamera.hpp"
#include "GameGlobalObjects.hpp"
#include "CGameState.hpp"
namespace urde
{
CHudHelmetInterface::CHudHelmetInterface(CGuiFrame& helmetFrame)
{
x3c_24_helmetVisibleDebug = true;
x3c_25_helmetVisibleGame = true;
x3c_26_glowVisibleDebug = true;
x3c_27_glowVisibleGame = true;
x40_camera = helmetFrame.GetFrameCamera();
x44_BaseWidget_Pivot = helmetFrame.FindWidget("BaseWidget_Pivot");
x48_BaseWidget_Helmet = helmetFrame.FindWidget("BaseWidget_Helmet");
x4c_BaseWidget_Glow = helmetFrame.FindWidget("BaseWidget_Glow");
x50_BaseWidget_HelmetLight = helmetFrame.FindWidget("BaseWidget_HelmetLight");
x24_pivotPosition = x44_BaseWidget_Pivot->GetIdlePosition();
x50_BaseWidget_HelmetLight->SetColor(g_tweakGuiColors->GetHelmetLightColor());
}
void CHudHelmetInterface::UpdateVisibility()
{
x48_BaseWidget_Helmet->SetVisibility(x3c_24_helmetVisibleDebug && x3c_25_helmetVisibleGame, ETraversalMode::Children);
x4c_BaseWidget_Glow->SetVisibility(x3c_26_glowVisibleDebug && x3c_27_glowVisibleGame, ETraversalMode::Children);
}
void CHudHelmetInterface::Update(float dt)
{
if (x3c_28_hudLagDirty)
{
x3c_28_hudLagDirty = false;
x44_BaseWidget_Pivot->SetTransform(zeus::CTransform(x0_hudLagRotation, x24_pivotPosition + x30_hudLagPosition));
}
}
void CHudHelmetInterface::SetIsVisibleDebug(bool helmet, bool glow)
void CHudHelmetInterface::SetHudLagOffset(const zeus::CVector3f& off)
{
x30_hudLagPosition = off;
x3c_28_hudLagDirty = true;
}
void CHudHelmetInterface::SetHudLagRotation(const zeus::CMatrix3f& rot)
{
x0_hudLagRotation = rot;
x3c_28_hudLagDirty = true;
}
void CHudHelmetInterface::AddHelmetLightValue(float val)
{
x50_BaseWidget_HelmetLight->SetColor(g_tweakGuiColors->GetHelmetLightColor() + zeus::CColor(val, val));
}
void CHudHelmetInterface::UpdateCameraDebugSettings(float fov, float y, float z)
{
x40_camera->SetFov(fov);
x40_camera->SetTransform(zeus::CTransform(x40_camera->GetTransform().buildMatrix3f(), zeus::CVector3f(0.f, y, z)));
}
void CHudHelmetInterface::UpdateHelmetAlpha()
{
zeus::CColor color = zeus::CColor::skWhite;
color.a = g_GameState->GameOptions().GetHelmetAlpha() / 255.f;
x44_BaseWidget_Pivot->SetColor(color);
}
void CHudHelmetInterface::SetIsVisibleDebug(bool helmet, bool glow)
{
x3c_24_helmetVisibleDebug = helmet;
x3c_26_glowVisibleDebug = glow;
UpdateVisibility();
}
}

31
Runtime/GuiSys/CHudHelmetInterface.hpp
View File

@@ -1,18 +1,47 @@
#ifndef __URDE_CHUDHELMETINTERFACE_HPP__
#define __URDE_CHUDHELMETINTERFACE_HPP__
#include "zeus/CMatrix3f.hpp"
#include "RetroTypes.hpp"
namespace urde
{
class CGuiFrame;
class CGuiWidget;
class CGuiCamera;
class CHudHelmetInterface
{
zeus::CMatrix3f x0_hudLagRotation;
zeus::CVector3f x24_pivotPosition;
zeus::CVector3f x30_hudLagPosition;
union
{
struct
{
bool x3c_24_helmetVisibleDebug : 1;
bool x3c_25_helmetVisibleGame : 1;
bool x3c_26_glowVisibleDebug : 1;
bool x3c_27_glowVisibleGame : 1;
bool x3c_28_hudLagDirty : 1;
};
u16 _dummy = 0;
};
CGuiCamera* x40_camera;
CGuiWidget* x44_BaseWidget_Pivot;
CGuiWidget* x48_BaseWidget_Helmet;
CGuiWidget* x4c_BaseWidget_Glow;
CGuiWidget* x50_BaseWidget_HelmetLight;
void UpdateVisibility();
public:
CHudHelmetInterface(CGuiFrame& helmetFrame);
void Update(float dt);
void SetIsVisibleDebug(bool helmet, bool glow);
void SetHudLagOffset(const zeus::CVector3f& off);
void SetHudLagRotation(const zeus::CMatrix3f& rot);
void AddHelmetLightValue(float val);
void UpdateCameraDebugSettings(float fov, float y, float z);
void UpdateHelmetAlpha();
void SetIsVisibleDebug(bool helmet, bool glow);
};
}

18
Runtime/GuiSys/CHudInterface.hpp Normal file
View File

@@ -0,0 +1,18 @@
#ifndef __URDE_CHUDINTERFACE_HPP__
#define __URDE_CHUDINTERFACE_HPP__
namespace urde
{
enum class EHudType
{
Combat,
Scan,
XRay,
Thermal,
Ball
};
}
#endif // __URDE_CHUDINTERFACE_HPP__

305
Runtime/GuiSys/CHudMissileInterface.cpp
View File

@@ -1,11 +1,314 @@
#include "CHudMissileInterface.hpp"
#include "CGuiFrame.hpp"
#include "CAuiEnergyBarT01.hpp"
#include "CGuiTextPane.hpp"
#include "GameGlobalObjects.hpp"
#include "CStateManager.hpp"
#include "CGuiModel.hpp"
#include "CStringTable.hpp"
namespace urde
{
void CHudMissileInterfaceCombat::Update(float dt, const CStateManager& mgr)
static const CAuiEnergyBarT01::FCoordFunc CoordFuncs[] =
{
CHudMissileInterface::CombatMissileBarCoordFunc,
nullptr,
CHudMissileInterface::XRayMissileBarCoordFunc,
CHudMissileInterface::ThermalMissileBarCoordFunc,
nullptr
};
static const float IconTranslateRanges[] =
{
6.05f, 0.f, 0.f, 8.4f, 0.f
};
CHudMissileInterface::CHudMissileInterface(CGuiFrame& selHud, int missileCapacity, int numMissiles,
float chargeFactor, bool missilesActive, EHudType hudType,
const CStateManager& mgr)
: x0_hudType(hudType), x4_missileCapacity(missileCapacity),
x8_numMissles(numMissiles), x4c_chargeBeamFactor(chargeFactor)
{
x58_24_missilesActive = missilesActive;
x58_25_visibleDebug = true;
x58_26_visibleGame = true;
x5c_basewidget_missileicon = selHud.FindWidget("basewidget_missileicon");
x60_textpane_missiledigits = static_cast<CGuiTextPane*>(selHud.FindWidget("textpane_missiledigits"));
x64_energybart01_missilebar = static_cast<CAuiEnergyBarT01*>(selHud.FindWidget("energybart01_missilebar"));
x68_textpane_missilewarning = static_cast<CGuiTextPane*>(selHud.FindWidget("textpane_missilewarning"));
x6c_model_missilearrowup = static_cast<CGuiModel*>(selHud.FindWidget("model_missilearrowup"));
x70_model_missilearrowdown = static_cast<CGuiModel*>(selHud.FindWidget("model_missilearrowdown"));
x74_basewidget_missileicon = selHud.FindWidget("basewidget_missileicon");
x58_27_hasArrows = x6c_model_missilearrowup && x70_model_missilearrowdown;
x58_28_notXRay = hudType != EHudType::XRay;
x10_missleIconXf = x74_basewidget_missileicon->GetLocalTransform();
x60_textpane_missiledigits->TextSupport()->SetFontColor(g_tweakGuiColors->GetMissileDigitsFont());
x60_textpane_missiledigits->TextSupport()->SetOutlineColor(g_tweakGuiColors->GetMissileDigitsOutline());
x74_basewidget_missileicon->SetColor(g_tweakGuiColors->GetMissileIconColorInactive());
x64_energybart01_missilebar->SetEmptyColor(g_tweakGuiColors->GetMissileBarEmpty());
x64_energybart01_missilebar->SetFilledColor(g_tweakGuiColors->GetMissileBarFilled());
x64_energybart01_missilebar->SetShadowColor(g_tweakGuiColors->GetMissileBarShadow());
x64_energybart01_missilebar->SetCoordFunc(CoordFuncs[int(hudType)]);
x64_energybart01_missilebar->SetTesselation(hudType == EHudType::Combat ? 1.f : 0.1f);
x64_energybart01_missilebar->SetMaxEnergy(5.f);
x64_energybart01_missilebar->SetFilledDrainSpeed(g_tweakGui->GetEnergyBarFilledSpeed());
x64_energybart01_missilebar->SetShadowDrainSpeed(g_tweakGui->GetEnergyBarShadowSpeed());
x64_energybart01_missilebar->SetShadowDrainDelay(g_tweakGui->GetEnergyBarDrainDelay());
x64_energybart01_missilebar->SetIsAlwaysResetTimer(true);
if (x68_textpane_missilewarning)
{
x68_textpane_missilewarning->TextSupport()->SetFontColor(g_tweakGuiColors->GetMissileWarningFont());
x68_textpane_missilewarning->TextSupport()->SetOutlineColor(g_tweakGuiColors->GetMissileWarningOutline());
}
SetNumMissiles(x8_numMissles, mgr);
x44_latestStatus = GetMissileInventoryStatus();
}
void CHudMissileInterface::UpdateVisibility(const CStateManager& mgr)
{
bool vis = x58_25_visibleDebug && x58_26_visibleGame;
x5c_basewidget_missileicon->SetVisibility(vis, ETraversalMode::Children);
x64_energybart01_missilebar->SetVisibility(vis, ETraversalMode::Children);
if (vis)
Update(0.f, mgr);
}
void CHudMissileInterface::Update(float dt, const CStateManager& mgr)
{
if (x4_missileCapacity < 1)
x5c_basewidget_missileicon->SetIsVisible(false);
else
x5c_basewidget_missileicon->SetIsVisible(true);
if (x54_missileIconIncrement < 0.f)
{
x54_missileIconIncrement -= 3.f * dt;
if (x54_missileIconIncrement <= -1.f)
x54_missileIconIncrement = 1.f;
}
else if (x54_missileIconIncrement > 0.f)
{
x54_missileIconIncrement = std::max(0.f, x54_missileIconIncrement - dt);
}
zeus::CColor addColor = g_tweakGuiColors->GetMissileIconColorActive() * x54_missileIconIncrement;
if (x50_missileIconAltDeplete > 0.f)
{
x74_basewidget_missileicon->SetColor(
zeus::CColor::lerp(g_tweakGuiColors->GetMissileIconColorInactive(),
g_tweakGuiColors->GetMissileIconColorDepleteAlt(), x50_missileIconAltDeplete) + addColor);
}
else
{
if (x4c_chargeBeamFactor > 0.f)
{
float factor = std::min(x4c_chargeBeamFactor / CPlayerState::GetMissileComboChargeFactor(), 1.f);
if (x8_numMissles > mgr.GetPlayerState()->GetMissileCostForAltAttack())
{
x74_basewidget_missileicon->SetColor(
zeus::CColor::lerp(g_tweakGuiColors->GetMissileIconColorInactive(),
g_tweakGuiColors->GetMissileIconColorChargedCanAlt(), factor) + addColor);
}
else
{
x74_basewidget_missileicon->SetColor(
zeus::CColor::lerp(g_tweakGuiColors->GetMissileIconColorInactive(),
g_tweakGuiColors->GetMissileIconColorChargedNoAlt(), factor) + addColor);
}
}
else
{
if (x58_24_missilesActive)
x74_basewidget_missileicon->SetColor(g_tweakGuiColors->GetMissileIconColorActive() + addColor);
else
x74_basewidget_missileicon->SetColor(g_tweakGuiColors->GetMissileIconColorInactive() + addColor);
}
}
x50_missileIconAltDeplete = std::max(0.f, x50_missileIconAltDeplete - dt);
x64_energybart01_missilebar->SetMaxEnergy(x4_missileCapacity);
x64_energybart01_missilebar->SetCurrEnergy(x8_numMissles, CAuiEnergyBarT01::ESetMode::Normal);
if (x58_28_notXRay)
{
x74_basewidget_missileicon->SetLocalTransform(x10_missleIconXf *
zeus::CTransform::Translate(0.f, 0.f, x8_numMissles *
IconTranslateRanges[int(x0_hudType)] / float(x4_missileCapacity)));
}
if (x58_27_hasArrows)
{
if (xc_arrowTimer > 0.f)
{
xc_arrowTimer = std::max(0.f, xc_arrowTimer - dt);
zeus::CColor color = g_tweakGuiColors->GetMissileIconColorActive();
color.a *= xc_arrowTimer / g_tweakGui->GetMissileArrowVisTime();
x6c_model_missilearrowup->SetColor(color);
x70_model_missilearrowdown->SetIsVisible(false);
}
else if (xc_arrowTimer < 0.f)
{
xc_arrowTimer = std::min(0.f, xc_arrowTimer + dt);
zeus::CColor color = g_tweakGuiColors->GetMissileIconColorActive();
color.a *= -xc_arrowTimer / g_tweakGui->GetMissileArrowVisTime();
x70_model_missilearrowdown->SetColor(color);
x6c_model_missilearrowup->SetIsVisible(false);
}
else
{
x6c_model_missilearrowup->SetIsVisible(false);
x70_model_missilearrowdown->SetIsVisible(false);
}
}
if (x68_textpane_missilewarning)
{
EInventoryStatus curStatus = GetMissileInventoryStatus();
if (curStatus != x44_latestStatus)
{
std::u16string string;
switch (curStatus)
{
case EInventoryStatus::Warning:
string = g_MainStringTable->GetString(12); // Missiles Low
case EInventoryStatus::Depleted:
string = g_MainStringTable->GetString(13); // Depleted
default: break;
}
x68_textpane_missilewarning->TextSupport()->SetText(string);
if (x44_latestStatus == EInventoryStatus::Normal && curStatus == EInventoryStatus::Warning)
{
CSfxManager::SfxStart(1397, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
x48_missileWarningPulse = g_tweakGui->GetMissileWarningPulseTime();
}
else if (curStatus == EInventoryStatus::Depleted)
{
CSfxManager::SfxStart(1397, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
x48_missileWarningPulse = g_tweakGui->GetMissileWarningPulseTime();
}
x44_latestStatus = curStatus;
}
x48_missileWarningPulse = std::max(0.f, x48_missileWarningPulse - dt);
float warnPulse = std::min(x48_missileWarningPulse, 1.f);
if (x44_latestStatus != EInventoryStatus::Normal)
x40_missileWarningAlpha = std::min(x40_missileWarningAlpha + 2.f * dt, 1.f);
else
x40_missileWarningAlpha = std::max(0.f, x40_missileWarningAlpha - 2.f * dt);
float tmp = std::fabs(std::fmod(CGraphics::GetSecondsMod900(), 0.5f));
if (tmp < 0.25f)
tmp = tmp / 0.25f;
else
tmp = (0.5f - tmp) / 0.25f;
zeus::CColor color = zeus::CColor::skWhite;
color.a = x40_missileWarningAlpha * tmp * warnPulse;
x68_textpane_missilewarning->SetColor(color);
if (x68_textpane_missilewarning->GetGeometryColor().a)
x68_textpane_missilewarning->SetIsVisible(true);
else
x68_textpane_missilewarning->SetIsVisible(false);
}
}
void CHudMissileInterface::SetIsVisibleGame(bool v, const CStateManager& mgr)
{
x58_26_visibleGame = v;
UpdateVisibility(mgr);
}
void CHudMissileInterface::SetIsVisibleDebug(bool v, const CStateManager& mgr)
{
x58_25_visibleDebug = v;
UpdateVisibility(mgr);
}
void CHudMissileInterface::SetIsMissilesActive(bool active)
{
x58_24_missilesActive = active;
}
void CHudMissileInterface::SetChargeBeamFactor(float t)
{
x4c_chargeBeamFactor = t;
}
void CHudMissileInterface::SetNumMissiles(int numMissiles, const CStateManager& mgr)
{
numMissiles = zeus::clamp(0, numMissiles, 999);
x60_textpane_missiledigits->TextSupport()->SetText(hecl::Format("%3d", numMissiles));
if (x8_numMissles < numMissiles)
{
xc_arrowTimer = g_tweakGui->GetMissileArrowVisTime();
x54_missileIconIncrement = -FLT_EPSILON;
}
else if (x8_numMissles > numMissiles)
{
xc_arrowTimer = -g_tweakGui->GetMissileArrowVisTime();
}
if (mgr.GetPlayerState()->GetMissileCostForAltAttack() + numMissiles <= x8_numMissles)
x50_missileIconAltDeplete = 1.f;
x8_numMissles = numMissiles;
}
void CHudMissileInterface::SetMissileCapacity(int missileCapacity)
{
x4_missileCapacity = missileCapacity;
}
CHudMissileInterface::EInventoryStatus CHudMissileInterface::GetMissileInventoryStatus()
{
if (x64_energybart01_missilebar->GetSetEnergy() == 0.f)
return EInventoryStatus::Depleted;
return EInventoryStatus(x64_energybart01_missilebar->GetActualFraction() <
g_tweakGui->GetMissileWarningFraction());
}
std::pair<zeus::CVector3f, zeus::CVector3f> CHudMissileInterface::CombatMissileBarCoordFunc(float t)
{
float z = t * IconTranslateRanges[int(EHudType::Combat)];
return {zeus::CVector3f(0.f, 0.f, z), zeus::CVector3f(0.3f, 0.f, z)};
}
std::pair<zeus::CVector3f, zeus::CVector3f> CHudMissileInterface::XRayMissileBarCoordFunc(float t)
{
float theta = 0.8f * (t - 0.5f);
float x = 9.55f * std::cos(theta);
float z = 9.55f * std::sin(theta);
return {zeus::CVector3f(x - 0.4f, 0.f, z), zeus::CVector3f(x, 0.f, z)};
}
std::pair<zeus::CVector3f, zeus::CVector3f> CHudMissileInterface::ThermalMissileBarCoordFunc(float t)
{
float transRange = IconTranslateRanges[int(EHudType::Thermal)];
float a = 0.08f * transRange;
float b = t * transRange;
float c;
if (b < a)
c = b / a;
else if (b < transRange - a)
c = 1.f;
else
c = 1.f - (b - (transRange - a)) / a;
return {zeus::CVector3f(-0.5f * c - 0.1f, 0.f, b), zeus::CVector3f(-0.1f, 0.f, b)};
}
}

62
Runtime/GuiSys/CHudMissileInterface.hpp
View File

@@ -1,14 +1,74 @@
#ifndef __URDE_CHUDMISSILEINTERFACE_HPP__
#define __URDE_CHUDMISSILEINTERFACE_HPP__
#include "RetroTypes.hpp"
#include "CHudInterface.hpp"
#include "zeus/CTransform.hpp"
namespace urde
{
class CStateManager;
class CGuiFrame;
class CGuiWidget;
class CGuiTextPane;
class CAuiEnergyBarT01;
class CGuiModel;
class CHudMissileInterfaceCombat
class CHudMissileInterface
{
enum class EInventoryStatus
{
Normal,
Warning,
Depleted
};
EHudType x0_hudType;
int x4_missileCapacity;
int x8_numMissles;
float xc_arrowTimer = 0.f;
zeus::CTransform x10_missleIconXf;
float x40_missileWarningAlpha = 0.f;
EInventoryStatus x44_latestStatus = EInventoryStatus::Normal;
float x48_missileWarningPulse = 0.f;
float x4c_chargeBeamFactor;
float x50_missileIconAltDeplete = 0.f;
float x54_missileIconIncrement = 0.f;
union
{
struct
{
bool x58_24_missilesActive : 1;
bool x58_25_visibleDebug : 1;
bool x58_26_visibleGame : 1;
bool x58_27_hasArrows : 1;
bool x58_28_notXRay : 1;
};
u16 _dummy = 0;
};
CGuiWidget* x5c_basewidget_missileicon;
CGuiTextPane* x60_textpane_missiledigits;
CAuiEnergyBarT01* x64_energybart01_missilebar;
CGuiTextPane* x68_textpane_missilewarning;
CGuiModel* x6c_model_missilearrowup;
CGuiModel* x70_model_missilearrowdown;
CGuiWidget* x74_basewidget_missileicon;
void UpdateVisibility(const CStateManager& mgr);
public:
CHudMissileInterface(CGuiFrame& selHud, int missileCapacity, int numMissiles,
float chargeFactor, bool missilesActive, EHudType hudType,
const CStateManager& mgr);
void Update(float dt, const CStateManager& mgr);
void SetIsVisibleGame(bool v, const CStateManager& mgr);
void SetIsVisibleDebug(bool v, const CStateManager& mgr);
void SetIsMissilesActive(bool active);
void SetChargeBeamFactor(float t);
void SetNumMissiles(int numMissiles, const CStateManager& mgr);
void SetMissileCapacity(int missileCapacity);
EInventoryStatus GetMissileInventoryStatus();
static std::pair<zeus::CVector3f, zeus::CVector3f> CombatMissileBarCoordFunc(float t);
static std::pair<zeus::CVector3f, zeus::CVector3f> XRayMissileBarCoordFunc(float t);
static std::pair<zeus::CVector3f, zeus::CVector3f> ThermalMissileBarCoordFunc(float t);
};
}

1
Runtime/GuiSys/CMakeLists.txt
View File

@@ -48,6 +48,7 @@ set(GUISYS_SOURCES
CHudVisorBeamMenu.hpp CHudVisorBeamMenu.cpp
CHudRadarInterface.hpp CHudRadarInterface.cpp
CHudBallInterface.hpp CHudBallInterface.cpp
CHudInterface.hpp
CScanDisplay.hpp CScanDisplay.cpp)
runtime_add_list(GuiSys GUISYS_SOURCES)