AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Finish CInGameGuiManager

This commit is contained in:
Jack Andersen 2017-05-21 12:01:04 -04:00
parent c8d09f3de7
commit 4b048a0dff
34 changed files with 505 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
DataSpec/DNACommon/Tweaks/ITweakAutoMapper.hpp
View File

@ -15,9 +15,11 @@ struct ITweakAutoMapper : public ITweak
virtual float GetMinCamRotateX() const=0;
virtual float GetMaxCamRotateX() const=0;
virtual float GetCamAngle() const=0;
virtual const zeus::CColor& GetAutomapperWidgetColor() const=0;
virtual float GetMiniCamDist() const=0;
virtual float GetMiniCamXAngle() const=0;
virtual float GetMiniCamAngle() const=0;
virtual const zeus::CColor& GetAutomapperWidgetMiniColor() const=0;
virtual const zeus::CColor& GetSurfaceVisitedColor() const=0;
virtual const zeus::CColor& GetOutlineVisitedColor() const=0;
virtual const zeus::CColor& GetSurfaceUnvisitedColor() const=0;
@ -53,6 +55,8 @@ struct ITweakAutoMapper : public ITweak
virtual float GetMaxUniverseCamDist() const=0;
virtual float GetSwitchToFromUniverseTime() const=0;
virtual float GetCamPanUnitsPerFrame() const=0;
virtual float GetAutomapperScaleX() const=0;
virtual float GetAutomapperScaleZ() const=0;
virtual float GetCamVerticalOffset() const=0;
virtual const zeus::CColor& GetMiniMapSamusModColor() const=0;
virtual const zeus::CColor& GetAreaFlashPulseColor() const=0;

4
DataSpec/DNACommon/Tweaks/ITweakGui.hpp
View File

@ -89,6 +89,9 @@ struct ITweakGui : ITweak
virtual float GetHudDamageFilterGainLinear() const=0;
virtual float GetHudDamageFilterInitConstant() const=0;
virtual float GetHudDamageFilterInitLinear() const=0;
virtual float GetEnergyDrainModPeriod() const=0;
virtual bool GetEnergyDrainSinusoidalPulse() const=0;
virtual bool GetEnergyDrainFilterAdditive() const=0;
virtual float GetHudDamagePulseDuration() const=0;
virtual float GetHudDamageColorGain() const=0;
virtual float GetHudDecoShakeTranslateGain() const=0;
@ -114,6 +117,7 @@ struct ITweakGui : ITweak
virtual float GetScanDataDotHoldDurationMin() const=0;
virtual float GetScanDataDotHoldDurationMax() const=0;
virtual float GetScanSidesPositionStart() const=0;
virtual bool GetShowAutomapperInMorphball() const=0;
virtual bool GetLatchArticleText() const=0;
virtual float GetWorldTransManagerCharsPerSfx() const=0;
virtual atUint32 GetXRayFogMode() const=0;

1
DataSpec/DNACommon/Tweaks/ITweakGuiColors.hpp
View File

@ -64,6 +64,7 @@ struct ITweakGuiColors : BigYAML
virtual const zeus::CColor& GetDamageAmbientColor() const=0;
virtual const zeus::CColor& GetScanVisorHudLightMultiply() const=0;
virtual const zeus::CColor& GetThermalVisorHudLightMultiply() const=0;
virtual const zeus::CColor& GetEnergyDrainFilterColor() const=0;
virtual const zeus::CColor& GetDamageAmbientPulseColor() const=0;
virtual const zeus::CColor& GetEnergyBarFlashColor() const=0;
virtual const zeus::CColor& GetXRayEnergyDecoColor() const=0;

12
DataSpec/DNAMP1/Tweaks/CTweakAutoMapper.hpp
View File

@ -21,12 +21,12 @@ struct CTweakAutoMapper : public ITweakAutoMapper
Value<float> x18_maxCamRotateX;
Value<float> x1c_camAngle;
Value<float> x20_;
DNAColor x24_;
DNAColor x24_automapperWidgetColor;
Value<float> x28_miniCamDist;
Value<float> x2c_miniCamXAngle;
Value<float> x30_miniCamAngle;
Value<float> x34_;
DNAColor x38_;
DNAColor x38_automapperWidgetMiniColor;
DNAColor x3c_surfColorVisited;
DNAColor x40_outlineColorVisited;
DNAColor x44_surfColorUnvisited;
@ -68,8 +68,8 @@ struct CTweakAutoMapper : public ITweakAutoMapper
Value<float> xd8_maxUniverseCamDist;
Value<float> xdc_switchToFromUniverseTime;
Value<float> xe0_camPanUnitsPerFrame;
Value<float> xe4_;
Value<float> xe8_;
Value<float> xe4_automapperScaleX;
Value<float> xe8_automapperScaleZ;
Value<float> xec_camVerticalOffset;
DNAColor xf0_miniMapSamusModColor;
DNAColor xf4_areaFlashPulseColor;
@ -90,9 +90,11 @@ struct CTweakAutoMapper : public ITweakAutoMapper
float GetMinCamRotateX() const { return x14_minCamRotateX; }
float GetMaxCamRotateX() const { return x18_maxCamRotateX; }
float GetCamAngle() const { return x1c_camAngle; }
const zeus::CColor& GetAutomapperWidgetColor() const { return x24_automapperWidgetColor; }
float GetMiniCamDist() const { return x28_miniCamDist; }
float GetMiniCamXAngle() const { return x2c_miniCamXAngle; }
float GetMiniCamAngle() const { return x30_miniCamAngle; }
const zeus::CColor& GetAutomapperWidgetMiniColor() const { return x38_automapperWidgetMiniColor; }
const zeus::CColor& GetSurfaceVisitedColor() const { return x3c_surfColorVisited; }
const zeus::CColor& GetOutlineVisitedColor() const { return x40_outlineColorVisited; }
const zeus::CColor& GetSurfaceUnvisitedColor() const { return x44_surfColorUnvisited; }
@ -128,6 +130,8 @@ struct CTweakAutoMapper : public ITweakAutoMapper
float GetMaxUniverseCamDist() const { return xd8_maxUniverseCamDist; }
float GetSwitchToFromUniverseTime() const { return xdc_switchToFromUniverseTime; }
float GetCamPanUnitsPerFrame() const { return xe0_camPanUnitsPerFrame; }
float GetAutomapperScaleX() const { return xe4_automapperScaleX; }
float GetAutomapperScaleZ() const { return xe8_automapperScaleZ; }
float GetCamVerticalOffset() const { return xec_camVerticalOffset; }
const zeus::CColor& GetMiniMapSamusModColor() const { return xf0_miniMapSamusModColor; }
const zeus::CColor& GetAreaFlashPulseColor() const { return xf4_areaFlashPulseColor; }

12
DataSpec/DNAMP1/Tweaks/CTweakGui.hpp
View File

@ -104,9 +104,9 @@ struct CTweakGui : ITweakGui
Value<float> x1bc_hudDamageFilterGainLinear;
Value<float> x1c0_hudDamageFilterInitConstant;
Value<float> x1c4_hudDamageFilterInitLinear;
Value<float> x1c8_;
Value<bool> x1cc_;
Value<bool> x1cd_;
Value<float> x1c8_energyDrainModPeriod;
Value<bool> x1cc_energyDrainSinusoidalPulse;
Value<bool> x1cd_energyDrainFilterAdditive;
Value<float> x1d0_hudDamagePulseDuration;
Value<float> x1d4_hudDamageColorGain;
Value<float> x1d8_hudDecoShakeTranslateGain;
@ -148,7 +148,7 @@ struct CTweakGui : ITweakGui
Value<float> x268_;
Value<float> x26c_;
Value<float> x270_scanSidesPositionStart;
Value<bool> x274_;
Value<bool> x274_showAutomapperInMorphball;
bool x275_latchArticleText = true;
Value<float> x278_wtMgrCharsPerSfx;
Value<atUint32> x27c_xrayFogMode;
@ -251,6 +251,9 @@ struct CTweakGui : ITweakGui
float GetHudDamageFilterGainLinear() const { return x1bc_hudDamageFilterGainLinear; }
float GetHudDamageFilterInitConstant() const { return x1c0_hudDamageFilterInitConstant; }
float GetHudDamageFilterInitLinear() const { return x1c4_hudDamageFilterInitLinear; }
float GetEnergyDrainModPeriod() const { return x1c8_energyDrainModPeriod; }
bool GetEnergyDrainSinusoidalPulse() const { return x1cc_energyDrainSinusoidalPulse; }
bool GetEnergyDrainFilterAdditive() const { return x1cd_energyDrainFilterAdditive; }
float GetHudDamagePulseDuration() const { return x1d0_hudDamagePulseDuration; }
float GetHudDamageColorGain() const { return x1d4_hudDamageColorGain; }
float GetHudDecoShakeTranslateGain() const { return x1d8_hudDecoShakeTranslateGain; }
@ -275,6 +278,7 @@ struct CTweakGui : ITweakGui
float GetScanPaneFadeOutTime() const { return x250_scanPaneFadeOutTime; }
float GetBallViewportYReduction() const { return x254_ballViewportYReduction; }
float GetScanSidesPositionStart() const { return x270_scanSidesPositionStart; }
bool GetShowAutomapperInMorphball() const { return x274_showAutomapperInMorphball; }
bool GetLatchArticleText() const { return x275_latchArticleText; }
float GetWorldTransManagerCharsPerSfx() const { return x278_wtMgrCharsPerSfx; }
atUint32 GetXRayFogMode() const { return x27c_xrayFogMode; }

3
DataSpec/DNAMP1/Tweaks/CTweakGuiColors.hpp
View File

@ -65,7 +65,7 @@ struct CTweakGuiColors : public ITweakGuiColors
DNAColor xd4_scanVisorHudLightMultiply;
DNAColor xd8_;
DNAColor xdc_thermalVisorHudLightMultiply;
DNAColor xe0_;
DNAColor xe0_energyDrainFilterColor;
DNAColor xe4_damageAmbientPulseColor;
DNAColor xe8_energyBarFlashColor;
DNAColor xec_;
@ -182,6 +182,7 @@ struct CTweakGuiColors : public ITweakGuiColors
const zeus::CColor& GetDamageAmbientColor() const { return xc4_damageAmbientColor; }
const zeus::CColor& GetScanVisorHudLightMultiply() const { return xd4_scanVisorHudLightMultiply; }
const zeus::CColor& GetThermalVisorHudLightMultiply() const { return xdc_thermalVisorHudLightMultiply; }
const zeus::CColor& GetEnergyDrainFilterColor() const { return xe0_energyDrainFilterColor; }
const zeus::CColor& GetDamageAmbientPulseColor() const { return xe4_damageAmbientPulseColor; }
const zeus::CColor& GetEnergyBarFlashColor() const { return xe8_energyBarFlashColor; }
const zeus::CColor& GetXRayEnergyDecoColor() const { return x100_xrayEnergyDecoColor; }

25
Runtime/AutoMapper/CAutoMapper.cpp
View File

@ -1398,16 +1398,12 @@ void CAutoMapper::Draw(const CStateManager& mgr, const zeus::CTransform& xf, flo
}
else if (x1c0_nextState == EAutoMapperState::MiniMap)
{
float t = 0.f;
if (x1c4_interpDur > 0.f)
t = x1c8_interpTime / x1c4_interpDur;
float t = GetInterp();
alphaInterp = alpha * t + (1.f - t);
}
else if (x1bc_state == EAutoMapperState::MiniMap)
{
float t = 0.f;
if (x1c4_interpDur > 0.f)
t = x1c8_interpTime / x1c4_interpDur;
float t = GetInterp();
alphaInterp = alpha * (1.f - t) + t;
}
else
@ -1429,24 +1425,13 @@ void CAutoMapper::Draw(const CStateManager& mgr, const zeus::CTransform& xf, flo
if (x1c0_nextState == EAutoMapperState::MapScreenUniverse)
{
if (x1bc_state == EAutoMapperState::MapScreenUniverse)
{
universeInterp = 1.f;
}
else
{
if (x1c4_interpDur > 0.f)
universeInterp = x1c8_interpTime / x1c4_interpDur;
else
universeInterp = 0.f;
}
universeInterp = GetInterp();
}
else if (x1bc_state == EAutoMapperState::MapScreenUniverse)
{
if (x1c4_interpDur > 0.f)
universeInterp = x1c8_interpTime / x1c4_interpDur;
else
universeInterp = 0.f;
universeInterp = 1.f - universeInterp;
universeInterp = 1.f - GetInterp();
}
zeus::CTransform preXf;
@ -1642,7 +1627,7 @@ void CAutoMapper::Draw(const CStateManager& mgr, const zeus::CTransform& xf, flo
if (x1c0_nextState != EAutoMapperState::MiniMap)
{
if (x1c4_interpDur > 0.f)
frmeAlpha = x1c8_interpTime / x1c4_interpDur;
frmeAlpha = x1c8_interpTime / x1c4_interpDur;
}
else
{

24
Runtime/AutoMapper/CAutoMapper.hpp
View File

@ -292,6 +292,7 @@ public:
std::pair<int, int>
FindClosestVisibleWorld(const zeus::CVector3f&, const zeus::CUnitVector3f&, const CStateManager&) const;
EAutoMapperState GetNextState() const { return x1c0_nextState; }
bool IsInMapperState(EAutoMapperState state) const
{
return state == x1bc_state && state == x1c0_nextState;
@ -304,20 +305,17 @@ public:
{
return x1c8_interpTime < x1c4_interpDur;
}
void UpdateOptionsMenu(const CTweakValue::Audio&);
void UpdateAudioMusicMenu();
void UpdateAudioEvents();
void UpdateAudioEventMenu();
void GetCurrentAudioInfo() const;
void PresentAudioMenuInput(const CFinalInput&);
void SetFocusAudioMenu(CAudioMenu::EMenu);
bool IsStateTransitioning() const;
bool IsFullyInMiniMapState() const;
static bool IsDrawState(EAutoMapperState);
bool IsStateTransitioning() const { return x1bc_state != x1c0_nextState; }
bool IsFullyInMiniMapState() const { return IsInMapperState(EAutoMapperState::MiniMap); }
bool IsFullyOutOfMiniMapState() const { return x1bc_state != EAutoMapperState::MiniMap &&
x1c0_nextState != EAutoMapperState::MiniMap; }
void OnNewInGameGuiState(EInGameGuiState, const CStateManager&);
void OnChangeAudioMusicSelection();
float GetInterp() const
{
if (x1c4_interpDur > 0.f)
return x1c8_interpTime / x1c4_interpDur;
return 0.f;
}
};
}

7
Runtime/CInGameTweakManagerBase.hpp
View File

@ -76,6 +76,13 @@ public:
{
return true;
}
static std::string GetIdentifierForMidiEvent(ResId world, ResId area,
const std::string& midiObj)
{
return hecl::Format("World %8.8x Area %8.8x MidiObject: %s",
u32(world), u32(area), midiObj.c_str());
}
};
}

4
Runtime/Camera/CCameraFilter.cpp
View File

@ -41,9 +41,7 @@ void CCameraBlurPass::Draw()
if (x10_curType == EBlurType::NoBlur)
return;
SClipScreenRect rect = {};
rect.xc_width = g_Viewport.x8_width;
rect.x10_height = g_Viewport.xc_height;
SClipScreenRect rect(g_Viewport);
CGraphics::ResolveSpareTexture(rect);
if (x10_curType == EBlurType::Xray)

6
Runtime/Graphics/CBooRenderer.cpp
View File

@ -1215,11 +1215,7 @@ void CBooRenderer::DrawPhazonSuitIndirectEffect(const zeus::CColor& nonIndirectM
/* Indirect background already in binding 0 */
/* Resolve alpha channel of just-drawn phazon suit into binding 1 */
SClipScreenRect rect;
rect.x4_left = g_Viewport.x0_left;
rect.x8_top = g_Viewport.x4_top;
rect.xc_width = g_Viewport.x8_width;
rect.x10_height = g_Viewport.xc_height;
SClipScreenRect rect(g_Viewport);
CGraphics::ResolveSpareTexture(rect, 1);
/* Perform blur filter and resolve into binding 2 */

8
Runtime/Graphics/CGraphics.hpp
View File

@ -178,6 +178,14 @@ struct SClipScreenRect
x10_height = rect.size[1];
x14_dstWidth = rect.size[0];
}
SClipScreenRect(const SViewport& vp)
{
x4_left = vp.x0_left;
x8_top = vp.x4_top;
xc_width = vp.x8_width;
x10_height = vp.xc_height;
}
};
enum class ETexelFormat

4
Runtime/Graphics/Shaders/CCameraBlurFilter.cpp
View File

@ -20,9 +20,7 @@ void CCameraBlurFilter::draw(float amount)
if (amount <= 0.f)
return;
SClipScreenRect clipRect = {};
clipRect.xc_width = g_Viewport.x8_width;
clipRect.x10_height = g_Viewport.xc_height;
SClipScreenRect clipRect(g_Viewport);
CGraphics::ResolveSpareTexture(clipRect);
float aspect = CGraphics::g_CroppedViewport.xc_width / float(CGraphics::g_CroppedViewport.x10_height);

22
Runtime/GuiSys/CGuiCamera.cpp
View File

@ -10,18 +10,15 @@ CGuiCamera::CGuiCamera(const CGuiWidgetParms& parms,
float left, float right,
float top, float bottom,
float znear, float zfar)
: CGuiWidget(parms), xb8_proj(EProjection::Orthographic),
xbc_left(left), xc0_right(right),
xc4_top(top), xc8_bottom(bottom),
xcc_znear(znear), xd0_zfar(zfar)
: CGuiWidget(parms), xb8_projtype(EProjection::Orthographic),
m_proj(left, right, top, bottom, znear, zfar)
{}
CGuiCamera::CGuiCamera(const CGuiWidgetParms& parms,
float fov, float aspect,
float znear, float zfar)
: CGuiWidget(parms), xb8_proj(EProjection::Perspective),
xbc_fov(fov), xc0_aspect(aspect),
xc4_znear(znear), xc8_zfar(zfar)
: CGuiWidget(parms), xb8_projtype(EProjection::Perspective),
m_proj(fov, aspect, znear, zfar)
{}
zeus::CVector3f CGuiCamera::ConvertToScreenSpace(const zeus::CVector3f& vec) const
@ -30,18 +27,19 @@ zeus::CVector3f CGuiCamera::ConvertToScreenSpace(const zeus::CVector3f& vec) con
if (local.isZero())
return {-1.f, -1.f, 1.f};
zeus::CMatrix4f mat = CGraphics::CalculatePerspectiveMatrix(xbc_fov, xc0_aspect,
xc4_znear, xc8_zfar,
zeus::CMatrix4f mat = CGraphics::CalculatePerspectiveMatrix(m_proj.xbc_fov, m_proj.xc0_aspect,
m_proj.xc4_znear, m_proj.xc8_zfar,
false);
return mat.multiplyOneOverW(local);
}
void CGuiCamera::Draw(const CGuiWidgetDrawParms& parms) const
{
if (xb8_proj == EProjection::Perspective)
CGraphics::SetPerspective(xbc_fov, xc0_aspect, xc4_znear, xc8_zfar);
if (xb8_projtype == EProjection::Perspective)
CGraphics::SetPerspective(m_proj.xbc_fov, m_proj.xc0_aspect, m_proj.xc4_znear, m_proj.xc8_zfar);
else
CGraphics::SetOrtho(xbc_left, xc0_right, xc4_top, xc8_bottom, xcc_znear, xd0_zfar);
CGraphics::SetOrtho(m_proj.xbc_left, m_proj.xc0_right, m_proj.xc4_top, m_proj.xc8_bottom,
m_proj.xcc_znear, m_proj.xd0_zfar);
CGraphics::SetViewPointMatrix(GetGuiFrame()->GetAspectTransform() *
zeus::CTransform::Translate(parms.x4_cameraOffset) * x34_worldXF);
CGuiWidget::Draw(parms);

46
Runtime/GuiSys/CGuiCamera.hpp
View File

@ -15,27 +15,36 @@ public:
Perspective,
Orthographic
};
private:
EProjection xb8_proj;
union
struct SProjection
{
struct
union
{
float xbc_left;
float xc0_right;
float xc4_top;
float xc8_bottom;
float xcc_znear;
float xd0_zfar;
};
struct
{
float xbc_fov;
float xc0_aspect;
float xc4_znear;
float xc8_zfar;
struct
{
float xbc_left;
float xc0_right;
float xc4_top;
float xc8_bottom;
float xcc_znear;
float xd0_zfar;
};
struct
{
float xbc_fov;
float xc0_aspect;
float xc4_znear;
float xc8_zfar;
};
};
SProjection(float left, float right, float top, float bottom, float znear, float zfar)
: xbc_left(left), xc0_right(right), xc4_top(top), xc8_bottom(bottom), xcc_znear(znear),
xd0_zfar(zfar) {}
SProjection(float fov, float aspect, float znear, float zfar)
: xbc_fov(fov), xc0_aspect(aspect), xc4_znear(znear), xc8_zfar(zfar) {}
};
private:
EProjection xb8_projtype;
SProjection m_proj;
public:
CGuiCamera(const CGuiWidgetParms& parms, float left, float right,
float top, float bottom,
@ -46,7 +55,8 @@ public:
static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp);
zeus::CVector3f ConvertToScreenSpace(const zeus::CVector3f& vec) const;
void SetFov(float fov) { xbc_fov = fov; }
const SProjection& GetProjection() const { return m_proj; }
void SetFov(float fov) { m_proj.xbc_fov = fov; }
void Draw(const CGuiWidgetDrawParms& parms) const;
std::shared_ptr<CGuiCamera> shared_from_this()

2
Runtime/GuiSys/CTargetingManager.cpp
View File

@ -18,7 +18,7 @@ void CTargetingManager::Update(float dt, const CStateManager& stateMgr)
}
void CTargetingManager::Draw(const CStateManager& stateMgr) const
void CTargetingManager::Draw(const CStateManager& stateMgr, bool hideLockon) const
{
}

2
Runtime/GuiSys/CTargetingManager.hpp
View File

@ -14,7 +14,7 @@ public:
CTargetingManager(const CStateManager& stateMgr);
bool CheckLoadComplete();
void Update(float, const CStateManager& stateMgr);
void Draw(const CStateManager& stateMgr) const;
void Draw(const CStateManager& stateMgr, bool hideLockon) const;
void Touch() const;
void SetRotation(const zeus::CQuaternion& rot) { x0_rot = rot; }
};

236
Runtime/MP1/CInGameGuiManager.cpp
View File

@ -14,6 +14,8 @@
#include "Input/CInputGenerator.hpp"
#include "TCastTo.hpp"
#include "Camera/CFirstPersonCamera.hpp"
#include "Graphics/CBooRenderer.hpp"
#include "GuiSys/CGuiWidgetDrawParms.hpp"
namespace urde
{
@ -308,14 +310,73 @@ bool CInGameGuiManager::CheckLoadComplete(CStateManager& stateMgr)
}
}
void CInGameGuiManager::RefreshHudOptions()
{
x34_samusHud->RefreshHudOptions();
}
void CInGameGuiManager::OnNewPauseScreenState(CArchitectureQueue& archQueue)
{
if (x1c0_nextState != EInGameGuiState::PauseGame && x1c0_nextState != EInGameGuiState::PauseLogBook)
{
if (x48_pauseScreen->IsTransitioning())
return;
x48_pauseScreen.reset();
}
if (x1c0_nextState >= EInGameGuiState::Zero && x1c0_nextState <= EInGameGuiState::InGame)
{
if (x44_messageScreen)
x44_messageScreen.reset();
RefreshHudOptions();
}
x1bc_prevState = x1c0_nextState;
}
void CInGameGuiManager::UpdateAutoMapper(float dt, const CStateManager& stateMgr)
{
x38_autoMapper->Update(dt, stateMgr);
zeus::CTransform xf = x148_model_automapper->GetParent()->GetWorldTransform() *
x144_basewidget_automapper->GetTransform();
x154_automapperRotate = zeus::CQuaternion(xf.basis);
x164_automapperOffset = xf.origin;
x170_camRotate = zeus::CQuaternion(x14c_basehud_camera->GetWorldTransform().basis);
x180_camOffset = x14c_basehud_camera->GetWorldTransform().basis[1] * 2.f +
x14c_basehud_camera->GetWorldPosition() +
x14c_basehud_camera->GetWorldTransform().basis[2] * g_tweakAutoMapper->GetCamVerticalOffset();
float frameLength = std::tan(zeus::degToRad(x14c_basehud_camera->GetProjection().xbc_fov) / 2.f) / 0.7f;
float scaleX = frameLength * g_tweakAutoMapper->GetAutomapperScaleX();
float scaleZ = frameLength * g_tweakAutoMapper->GetAutomapperScaleZ();
if (x38_autoMapper->IsFullyOutOfMiniMapState())
{
x148_model_automapper->SetO2WTransform(
zeus::CTransform(x170_camRotate, x180_camOffset) * zeus::CTransform::Scale(scaleX, 1.f, scaleZ));
x18c_camXf = zeus::CTransform(x170_camRotate, x180_camOffset) *
zeus::CTransform::Scale(frameLength, 1.f, frameLength);
x148_model_automapper->SetColor(g_tweakAutoMapper->GetAutomapperWidgetColor());
}
else if (x38_autoMapper->IsFullyInMiniMapState())
{
x148_model_automapper->SetO2WTransform(zeus::CTransform(x154_automapperRotate, x164_automapperOffset));
x18c_camXf = x148_model_automapper->GetWorldTransform();
x148_model_automapper->SetColor(g_tweakAutoMapper->GetAutomapperWidgetMiniColor());
}
else
{
float t;
if (x38_autoMapper->GetNextState() != CAutoMapper::EAutoMapperState::MiniMap)
t = x38_autoMapper->GetInterp();
else
t = 1.f - x38_autoMapper->GetInterp();
float st = t * (frameLength - 1.f) + 1.f;
x148_model_automapper->SetO2WTransform(zeus::CTransform(
zeus::CQuaternion::slerp(x154_automapperRotate, x170_camRotate, t),
x164_automapperOffset * (1.f - t) + x180_camOffset * t) * zeus::CTransform::Scale(st, 1.f, st));
x148_model_automapper->SetColor(zeus::CColor::lerp(g_tweakAutoMapper->GetAutomapperWidgetMiniColor(),
g_tweakAutoMapper->GetAutomapperWidgetColor(), t));
}
}
void CInGameGuiManager::Update(CStateManager& stateMgr, float dt, CArchitectureQueue& archQueue, bool useHud)
@ -503,7 +564,170 @@ void CInGameGuiManager::PreDraw(CStateManager& stateMgr, bool cameraActive)
void CInGameGuiManager::Draw(CStateManager& stateMgr)
{
//if (!GetIsGameDraw())
// g_Renderer->x318_26_requestRGBA6 = true;
if (x1d8_onScreenTexAlpha > 0.f && x1dc_onScreenTexTok.IsLoaded())
{
if (!m_onScreenQuad || m_onScreenQuad->GetTex().GetObj() != x1dc_onScreenTexTok.GetObj())
m_onScreenQuad.emplace(CCameraFilterPass::EFilterType::Blend, x1dc_onScreenTexTok);
// No depth read/write
// Alpha blend
int w = (g_Viewport.x0_left + (x1c4_onScreenTex.x4_origin.x - g_Viewport.x8_width) / 2 + x1c4_onScreenTex.xc_extent.x) -
x1c4_onScreenTex.x4_origin.x;
int h = (g_Viewport.x4_top + (x1c4_onScreenTex.x4_origin.y - g_Viewport.xc_height) / 2 - x1c4_onScreenTex.xc_extent.y) -
x1c4_onScreenTex.x4_origin.y;
zeus::CRectangle rect(x1c4_onScreenTex.x4_origin.x / float(g_Viewport.x8_width),
x1c4_onScreenTex.x4_origin.y / float(g_Viewport.xc_height),
w / float(g_Viewport.x8_width), h / float(g_Viewport.xc_height));
m_onScreenQuad->draw(zeus::CColor(1.f, x1d8_onScreenTexAlpha), 1.f, rect);
}
float staticAlpha = 0.f;
if (stateMgr.GetPlayer().GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Unmorphed &&
stateMgr.GetPlayer().GetDeathTime() > 0.f)
staticAlpha = zeus::clamp(0.f, stateMgr.GetPlayer().GetDeathTime() / (0.3f * 2.5f), 1.f);
bool notInCine = !stateMgr.GetCameraManager()->IsInCinematicCamera();
bool drawVisor = false;
if (notInCine && (x1bc_prevState == EInGameGuiState::InGame || x1c0_nextState == EInGameGuiState::InGame))
drawVisor = true;
if (x3c_pauseScreenBlur->GetX50_25())
{
x34_samusHud->GetTargetingManager().Draw(stateMgr, true);
CGraphics::SetDepthRange(0.015625f, 0.03125f);
bool scanVisor = stateMgr.GetPlayerState()->GetActiveVisor(stateMgr) == CPlayerState::EPlayerVisor::Scan;
if (drawVisor && x1f0_enablePlayerVisor)
{
if (stateMgr.GetPlayer().GetCameraState() == CPlayer::EPlayerCameraState::Zero)
x20_faceplateDecor.Draw(stateMgr);
CTargetingManager* tgtMgr = nullptr;
if (scanVisor && x1e4_enableTargetingManager)
tgtMgr = &x34_samusHud->GetTargetingManager();
x30_playerVisor->Draw(stateMgr, tgtMgr);
}
x40_samusReflection->Draw(stateMgr);
if (drawVisor)
{
CGraphics::SetDepthRange(0.001953125f, 0.015625f);
if (staticAlpha > 0.f)
{
CCameraFilterPass::DrawFilter(CCameraFilterPass::EFilterType::Blend,
CCameraFilterPass::EFilterShape::RandomStatic,
zeus::CColor(1.f, staticAlpha), nullptr, 1.f);
}
x34_samusHud->Draw(stateMgr, x1f4_visorStaticAlpha * (1.f - staticAlpha),
x1e0_helmetVisMode, x1ec_hudVisMode != EHudVisMode::Zero,
x1e4_enableTargetingManager && !scanVisor);
}
}
float preDrawBlur = true;
if (x1bc_prevState >= EInGameGuiState::Zero && x1bc_prevState <= EInGameGuiState::InGame)
if (x1bc_prevState != EInGameGuiState::MapScreen && x1c0_nextState != EInGameGuiState::MapScreen)
preDrawBlur = false;
if (preDrawBlur)
x3c_pauseScreenBlur->Draw(stateMgr);
if (notInCine && x1e8_enableAutoMapper &&
(x3c_pauseScreenBlur->GetX50_25() || x1bc_prevState == EInGameGuiState::MapScreen ||
x1c0_nextState == EInGameGuiState::MapScreen))
{
float t;
if (stateMgr.GetPlayerState()->GetCurrentVisor() == CPlayerState::EPlayerVisor::Combat)
t = stateMgr.GetPlayerState()->GetVisorTransitionFactor();
else
t = 0.f;
float mapAlpha;
if (g_tweakGui->GetShowAutomapperInMorphball())
mapAlpha = 1.f;
else if (stateMgr.GetPlayer().GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Unmorphed)
mapAlpha = 1.f;
else
mapAlpha = 0.f;
x34_samusHud->GetBaseHudFrame()->GetFrameCamera()->Draw(CGuiWidgetDrawParms(0.f, zeus::CVector3f::skZero));
CGraphics::SetDepthRange(0.f, 0.001953125f);
x148_model_automapper->SetIsVisible(true);
x148_model_automapper->Draw(CGuiWidgetDrawParms(1.f, zeus::CVector3f::skZero));
// ZTest no write
x38_autoMapper->Draw(stateMgr, zeus::CTransform::Translate(0.f, 0.02f, 0.f) * x18c_camXf, mapAlpha * x1f4_visorStaticAlpha * t);
// Zest and write
x148_model_automapper->SetIsVisible(false);
}
if (!preDrawBlur)
x3c_pauseScreenBlur->Draw(stateMgr);
if (x1e0_helmetVisMode != EHelmetVisMode::ReducedUpdate && notInCine)
{
float camYOff;
if (!x48_pauseScreen)
camYOff = 0.f;
else
camYOff = x48_pauseScreen->GetHelmetCamYOff();
x34_samusHud->DrawHelmet(stateMgr, camYOff);
}
if (x4c_saveUI)
x4c_saveUI->Draw();
if (x44_messageScreen)
x44_messageScreen->Draw();
if (x48_pauseScreen)
x48_pauseScreen->Draw();
xf8_camFilter.Draw();
if (stateMgr.GetPlayer().GetDeathTime() > 0.f)
{
float dieDur;
if (stateMgr.GetPlayer().GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Unmorphed)
dieDur = 2.5f;
else
dieDur = 6.f;
float alpha = zeus::clamp(0.f, stateMgr.GetPlayer().GetDeathTime() / dieDur, 1.f);
CCameraFilterPass::DrawFilter(CCameraFilterPass::EFilterType::Blend,
CCameraFilterPass::EFilterShape::Fullscreen,
zeus::CColor(1.f, alpha), nullptr, 1.f);
float zStart = dieDur - 0.5f - 0.5f - 1.f;
float xStart = 0.5f - zStart;
float colStart = 0.5f - xStart;
if (stateMgr.GetPlayer().GetDeathTime() > zStart)
{
float zT = 1.f - zeus::clamp(0.f, (stateMgr.GetPlayer().GetDeathTime() - zStart) / 0.5f, 1.f);
float xT = 1.f - zeus::clamp(0.f, (stateMgr.GetPlayer().GetDeathTime() - xStart) / 0.5f, 1.f);
float colT = 1.f - zeus::clamp(0.f, (stateMgr.GetPlayer().GetDeathTime() - colStart) / 0.5f, 1.f);
SClipScreenRect rect(g_Viewport);
CGraphics::ResolveSpareTexture(rect);
CCameraFilterPass::DrawFilter(CCameraFilterPass::EFilterType::Blend,
CCameraFilterPass::EFilterShape::Fullscreen,
zeus::CColor::skBlack, nullptr, 1.f);
float z = 0.5f * (zT * zT * zT * zT * zT * (g_Viewport.xc_height - 12.f) + 12.f);
float x = 0.5f * (xT * (g_Viewport.x8_width - 12.f) + 12.f);
CTexturedQuadFilter::Vert verts[] =
{
{{-x, 0.f, z}, {0.f, 0.f}},
{{-x, 0.f, -z}, {0.f, 1.f}},
{{x, 0.f, z}, {1.f, 0.f}},
{{x, 0.f, -z}, {1.f, 1.f}}
};
if (!m_deathRenderTexQuad)
m_deathRenderTexQuad.emplace(CCameraFilterPass::EFilterType::Blend, CGraphics::g_SpareTexture);
m_deathRenderTexQuad->drawVerts(zeus::CColor(1.f, colT), verts);
if (!m_deathDotQuad)
m_deathDotQuad.emplace(CCameraFilterPass::EFilterType::Multiply, x50_deathDot);
m_deathDotQuad->drawVerts(zeus::CColor(1.f, colT), verts);
}
}
}
void CInGameGuiManager::ShowPauseGameHudMessage(CStateManager& stateMgr, ResId pauseMsg, float time)
@ -522,7 +746,10 @@ void CInGameGuiManager::PauseGame(CStateManager& stateMgr, EInGameGuiState state
void CInGameGuiManager::StartFadeIn()
{
xf8_camFilter.SetFilter(CCameraFilterPass::EFilterType::Multiply,
CCameraFilterPass::EFilterShape::Fullscreen,
0.f, zeus::CColor::skBlack, -1);
xf8_camFilter.DisableFilter(0.5f);
}
bool CInGameGuiManager::GetIsGameDraw() const
@ -530,12 +757,5 @@ bool CInGameGuiManager::GetIsGameDraw() const
return x3c_pauseScreenBlur->GetX50_25();
}
std::string CInGameGuiManager::GetIdentifierForMidiEvent(ResId world, ResId area,
const std::string& midiObj)
{
return hecl::Format("World %8.8x Area %8.8x MidiObject: %s",
u32(world), u32(area), midiObj.c_str());
}
}
}

6
Runtime/MP1/CInGameGuiManager.hpp
View File

@ -90,6 +90,7 @@ private:
SOnScreenTex x1c4_onScreenTex;
float x1d8_onScreenTexAlpha = 0.f;
TLockedToken<CTexture> x1dc_onScreenTexTok; // Used to be heap-allocated
std::experimental::optional<CTexturedQuadFilterAlpha> m_onScreenQuad;
EHelmetVisMode x1e0_helmetVisMode;
bool x1e4_enableTargetingManager;
bool x1e8_enableAutoMapper;
@ -97,6 +98,9 @@ private:
u32 x1f0_enablePlayerVisor;
float x1f4_visorStaticAlpha;
std::experimental::optional<CTexturedQuadFilter> m_deathRenderTexQuad;
std::experimental::optional<CTexturedQuadFilter> m_deathDotQuad;
union
{
struct
@ -120,6 +124,7 @@ private:
bool IsInPausedStateNotTransitioning() const;
void UpdateAutoMapper(float dt, const CStateManager& stateMgr);
void OnNewPauseScreenState(CArchitectureQueue& archQueue);
void RefreshHudOptions();
public:
CInGameGuiManager(CStateManager& stateMgr, CArchitectureQueue& archQueue);
@ -136,7 +141,6 @@ public:
bool IsInGame() const { return x1c0_nextState >= EInGameGuiState::Zero && x1c0_nextState <= EInGameGuiState::InGame; }
bool IsInSaveUI() const { return x1f8_27_exitSaveUI; }
bool GetIsGameDraw() const;
static std::string GetIdentifierForMidiEvent(ResId world, ResId area, const std::string& midiObj);
};
}

5
Runtime/MP1/CMessageScreen.cpp
View File

@ -20,5 +20,10 @@ bool CMessageScreen::Update(float dt, float blurAmt)
return false;
}
void CMessageScreen::Draw() const
{
}
}
}

1
Runtime/MP1/CMessageScreen.hpp
View File

@ -16,6 +16,7 @@ public:
CMessageScreen(ResId msg, float time);
void ProcessControllerInput(const CFinalInput& input);
bool Update(float dt, float blurAmt);
void Draw() const;
};
}

7
Runtime/MP1/CPauseScreen.cpp
View File

@ -300,5 +300,12 @@ bool CPauseScreen::ShouldSwitchToInGame() const
return IsLoaded() && x8_curSubscreen == ESubScreen::ToGame && xc_nextSubscreen == ESubScreen::ToGame;
}
float CPauseScreen::GetHelmetCamYOff() const
{
if (CPauseScreenBase* screen = x7c_screens[x78_activeIdx].get())
return screen->GetCameraYBias();
return 0.f;
}
}
}

2
Runtime/MP1/CPauseScreen.hpp
View File

@ -71,6 +71,8 @@ public:
bool IsLoaded() const { return x90_resourcesLoaded; }
bool ShouldSwitchToMapScreen() const;
bool ShouldSwitchToInGame() const;
bool IsTransitioning() const { return x8_curSubscreen != xc_nextSubscreen; }
float GetHelmetCamYOff() const;
};
}

5
Runtime/MP1/CPauseScreenBlur.cpp
View File

@ -25,5 +25,10 @@ void CPauseScreenBlur::Update(float dt, const CStateManager& stateMgr, bool)
}
void CPauseScreenBlur::Draw(const CStateManager& stateMgr) const
{
}
}
}

1
Runtime/MP1/CPauseScreenBlur.hpp
View File

@ -29,6 +29,7 @@ public:
void OnNewInGameGuiState(EInGameGuiState state, CStateManager& stateMgr);
bool GetX50_25() const { return x50_25_; }
void Update(float dt, const CStateManager& stateMgr, bool);
void Draw(const CStateManager& stateMgr) const;
float GetBlurAmt() const { return std::fabs(x18_blurAmt); }
bool IsNotTransitioning() const { return x10_ == x14_; }
};

5
Runtime/MP1/CPlayerVisor.cpp
View File

@ -15,6 +15,11 @@ void CPlayerVisor::Update(float dt, const CStateManager& stateMgr)
}
void CPlayerVisor::Draw(const CStateManager& stateMgr, const CTargetingManager* tgtManager) const
{
}
void CPlayerVisor::Touch()
{

2
Runtime/MP1/CPlayerVisor.hpp
View File

@ -4,6 +4,7 @@
namespace urde
{
class CStateManager;
class CTargetingManager;
namespace MP1
{
@ -13,6 +14,7 @@ class CPlayerVisor
public:
CPlayerVisor(CStateManager& stateMgr);
void Update(float dt, const CStateManager& stateMgr);
void Draw(const CStateManager& stateMgr, const CTargetingManager* tgtManager) const;
void Touch();
float GetDesiredViewportScaleX(const CStateManager& stateMgr) const;
float GetDesiredViewportScaleY(const CStateManager& stateMgr) const;

5
Runtime/MP1/CSamusFaceReflection.cpp
View File

@ -21,6 +21,11 @@ void CSamusFaceReflection::PreDraw(const CStateManager& stateMgr)
}
void CSamusFaceReflection::Draw(const CStateManager& stateMgr) const
{
}
void CSamusFaceReflection::Update(float dt, const CStateManager& stateMgr, CRandom16& rand)
{

1
Runtime/MP1/CSamusFaceReflection.hpp
View File

@ -20,6 +20,7 @@ class CSamusFaceReflection
public:
CSamusFaceReflection(CStateManager& stateMgr);
void PreDraw(const CStateManager& stateMgr);
void Draw(const CStateManager& stateMgr) const;
void Update(float dt, const CStateManager& stateMgr, CRandom16& rand);
};

119
Runtime/MP1/CSamusHud.cpp
View File

@ -8,6 +8,7 @@
#include "GuiSys/CGuiLight.hpp"
#include "GuiSys/CGuiModel.hpp"
#include "GuiSys/CGuiCamera.hpp"
#include "GuiSys/CGuiWidgetDrawParms.hpp"
#include "Camera/CFirstPersonCamera.hpp"
#include "TCastTo.hpp"
#include "World/CGameLight.hpp"
@ -1510,6 +1511,124 @@ void CSamusHud::Update(float dt, const CStateManager& mgr,
x29c_decoIntf->Update(dt, mgr);
}
void CSamusHud::DrawAttachedEnemyEffect(const CStateManager& mgr) const
{
float drainTime = mgr.GetPlayer().GetEnergyDrain().GetEnergyDrainTime();
if (drainTime <= 0.f)
return;
float modPeriod = g_tweakGui->GetEnergyDrainModPeriod();
float alpha;
if (g_tweakGui->GetEnergyDrainSinusoidalPulse())
{
alpha = (std::sin(-0.25f * modPeriod + 2.f * M_PIF * drainTime / modPeriod) + 1.f) * 0.5f;
}
else
{
float halfModPeriod = 0.5 * modPeriod;
float tmp = std::fabs(std::fmod(drainTime, modPeriod));
if (tmp < halfModPeriod)
alpha = tmp / halfModPeriod;
else
alpha = (modPeriod - tmp) / halfModPeriod;
}
zeus::CColor filterColor = g_tweakGuiColors->GetEnergyDrainFilterColor();
filterColor.a *= alpha;
CCameraFilterPass::DrawFilter(g_tweakGui->GetEnergyDrainFilterAdditive() ?
CCameraFilterPass::EFilterType::Add : CCameraFilterPass::EFilterType::Blend,
CCameraFilterPass::EFilterShape::Fullscreen, filterColor,
nullptr, 1.f);
}
void CSamusHud::Draw(const CStateManager& mgr, float alpha,
CInGameGuiManager::EHelmetVisMode helmetVis,
bool hudVis, bool targetingManager) const
{
if (x2bc_nextState == EHudState::None)
return;
if (mgr.GetPlayer().GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Unmorphed)
{
DrawAttachedEnemyEffect(mgr);
x51c_camFilter2.Draw();
if (targetingManager)
x8_targetingMgr.Draw(mgr, false);
}
if (helmetVis != CInGameGuiManager::EHelmetVisMode::ReducedUpdate &&
helmetVis < CInGameGuiManager::EHelmetVisMode::HelmetOnly)
{
if (alpha < 1.f)
{
CCameraFilterPass::DrawFilter(CCameraFilterPass::EFilterType::NoColor,
CCameraFilterPass::EFilterShape::CookieCutterDepthRandomStatic,
zeus::CColor::skWhite, nullptr, 1.f - alpha);
}
if (x288_loadedSelectedHud)
{
if (mgr.GetPlayer().GetDeathTime() > 0.f)
{
if (mgr.GetPlayer().GetMorphballTransitionState() != CPlayer::EPlayerMorphBallState::Unmorphed)
{
CGuiWidgetDrawParms parms(
x2c8_transT * zeus::clamp(0.f, 1.f - mgr.GetPlayer().GetDeathTime() / 6.f, 1.f),
zeus::CVector3f::skZero);
x288_loadedSelectedHud->Draw(parms);
}
else
{
CGuiWidgetDrawParms parms(x2c8_transT, zeus::CVector3f::skZero);
x288_loadedSelectedHud->Draw(parms);
}
}
else
{
CGuiWidgetDrawParms parms(x2c8_transT, zeus::CVector3f::skZero);
x288_loadedSelectedHud->Draw(parms);
}
}
if (x274_loadedFrmeBaseHud)
x274_loadedFrmeBaseHud->Draw(CGuiWidgetDrawParms::Default);
}
if (x29c_decoIntf && !x2cc_preLoadCountdown)
x29c_decoIntf->Draw();
if (x2bc_nextState >= EHudState::Combat && x2bc_nextState <= EHudState::Scan)
{
if (hudVis &&
helmetVis != CInGameGuiManager::EHelmetVisMode::ReducedUpdate &&
helmetVis < CInGameGuiManager::EHelmetVisMode::HelmetOnly)
{
float t;
if (mgr.GetPlayerState()->GetCurrentVisor() == CPlayerState::EPlayerVisor::Combat)
t = mgr.GetPlayerState()->GetVisorTransitionFactor();
else
t = 0.f;
x2ac_radarIntf->Draw(mgr, t * alpha);
}
// Depth read/write enable
}
}
void CSamusHud::DrawHelmet(const CStateManager& mgr, float camYOff) const
{
if (!x264_loadedFrmeHelmet ||
mgr.GetPlayer().GetMorphballTransitionState() != CPlayer::EPlayerMorphBallState::Unmorphed ||
x2bc_nextState == EHudState::Ball)
return;
float t;
if (x2c4_activeTransState == ETransitionState::Transitioning && x2b8_curState == EHudState::Ball)
t = x2c8_transT;
else
t = 1.f;
x264_loadedFrmeHelmet->Draw(CGuiWidgetDrawParms(t, zeus::CVector3f(0.f, 15.f * camYOff, 0.f)));
}
void CSamusHud::ProcessControllerInput(const CFinalInput& input)
{
if (x29c_decoIntf)

9
Runtime/MP1/CSamusHud.hpp
View File

@ -92,8 +92,7 @@ class CSamusHud
{
u32 x0_ = 0;
u32 x4_ = 0;
u32 x8_ = 0;
u32 xc_ = 0;
u64 x8_profUsec = 0;
};
friend class CInGameGuiManager;
@ -240,6 +239,7 @@ class CSamusHud
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:
@ -248,6 +248,10 @@ public:
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);
@ -275,6 +279,7 @@ public:
g_SamusHud->InternalDeferHintMemo(strg, strgIdx, info);
}
void InternalDeferHintMemo(ResId strg, u32 strgIdx, const CHUDMemoParms& info);
CGuiFrame* GetBaseHudFrame() const { return x274_loadedFrmeBaseHud; }
};
}

5
Runtime/World/CPlayer.hpp
View File

@ -101,7 +101,7 @@ private:
u32 x258_jumpState = 0;
TUniqueId x26c_ = kInvalidUniqueId;
float x270_ = 0.f;
CPlayerEnergyDrain x274_ = CPlayerEnergyDrain(4);
CPlayerEnergyDrain x274_energyDrain = CPlayerEnergyDrain(4);
float x288_ = 0.f;
float x28c_sjTimer = 0.f;
float x290_ = 0.f;
@ -363,6 +363,7 @@ public:
void UpdateGunTransform(const zeus::CVector3f&, float, CStateManager& mgr, bool);
void DrawGun(CStateManager& mgr);
void HolsterGun(CStateManager& mgr);
EPlayerCameraState GetCameraState() const { return x2f4_cameraState; }
EPlayerMorphBallState GetMorphballTransitionState() const { return x2f8_morphTransState; }
void UpdateGrappleArmTransform(const zeus::CVector3f&, CStateManager& mgr, float);
void ApplyGrappleForces(const CFinalInput& input, CStateManager& mgr, float);
@ -455,6 +456,8 @@ public:
CPlayerGun* GetPlayerGun() const { return x490_gun.get(); }
CMorphBall* GetMorphBall() const { return x768_morphball.get(); }
CPlayerCameraBob* GetCameraBob() const { return x76c_cameraBob.get(); }
float GetDeathTime() const { return x9f4_deathTime; }
const CPlayerEnergyDrain& GetEnergyDrain() const { return x274_energyDrain; }
void Touch();

12
Runtime/World/CScriptMidi.cpp
View File

@ -30,9 +30,9 @@ void CScriptMidi::Stop(CStateManager& mgr, float fadeTime)
{
const CWorld* wld = mgr.GetWorld();
const CGameArea* area = wld->GetAreaAlways(x4_areaId);
std::string twkName = MP1::CInGameGuiManager::GetIdentifierForMidiEvent(wld->IGetWorldAssetId(),
area->GetAreaAssetId(),
x10_name);
std::string twkName = CInGameTweakManagerBase::GetIdentifierForMidiEvent(wld->IGetWorldAssetId(),
area->GetAreaAssetId(),
x10_name);
if (g_TweakManager->HasTweakValue(twkName))
{
const CTweakValue::Audio& audio = g_TweakManager->GetTweakValue(twkName)->GetAudio();
@ -47,9 +47,9 @@ void CScriptMidi::Play(CStateManager& mgr, float fadeTime)
u32 volume = x48_volume;
const CWorld* wld = mgr.GetWorld();
const CGameArea* area = wld->GetAreaAlways(x4_areaId);
std::string twkName = MP1::CInGameGuiManager::GetIdentifierForMidiEvent(wld->IGetWorldAssetId(),
area->GetAreaAssetId(),
x10_name);
std::string twkName = CInGameTweakManagerBase::GetIdentifierForMidiEvent(wld->IGetWorldAssetId(),
area->GetAreaAssetId(),
x10_name);
if (g_TweakManager->HasTweakValue(twkName))
{
const CTweakValue::Audio& audio = g_TweakManager->GetTweakValue(twkName)->GetAudio();

4
Runtime/World/CWorldTransManager.cpp
View File

@ -278,9 +278,7 @@ void CWorldTransManager::DrawEnabled()
{
float t = zeus::clamp(0.f, (x0_curTime - x4_modelData->x1d0_dissolveStartTime) / 2.f, 1.f);
DrawFirstPass();
SClipScreenRect rect = {};
rect.xc_width = g_Viewport.x8_width;
rect.x10_height = g_Viewport.xc_height;
SClipScreenRect rect(g_Viewport);
CGraphics::ResolveSpareTexture(rect);
CGraphics::g_BooMainCommandQueue->clearTarget(true, true);
DrawSecondPass();