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

Finish CSamusHud and subsystems

This commit is contained in:
Jack Andersen 2017-04-13 09:28:31 -10:00
parent 84578e9909
commit 0fe125d913
42 changed files with 1094 additions and 316 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -35,6 +35,10 @@ struct ITweakGui : ITweak
virtual float GetEnergyBarShadowSpeed() const=0; virtual float GetEnergyBarShadowSpeed() const=0;
virtual float GetEnergyBarDrainDelay() const=0; virtual float GetEnergyBarDrainDelay() const=0;
virtual bool GetEnergyBarAlwaysResetDelay() const=0; virtual bool GetEnergyBarAlwaysResetDelay() const=0;
virtual float GetHudDamagePracticalsGainConstant() const=0;
virtual float GetHudDamagePracticalsGainLinear() const=0;
virtual float GetHudDamagePracticalsInitConstant() const=0;
virtual float GetHudDamagePracticalsInitLinear() const=0;
virtual float GetHudDamageLightSpotAngle() const=0; virtual float GetHudDamageLightSpotAngle() const=0;
virtual float GetDamageLightAngleC() const=0; virtual float GetDamageLightAngleC() const=0;
virtual float GetDamageLightAngleL() const=0; virtual float GetDamageLightAngleL() const=0;
@ -43,6 +47,15 @@ struct ITweakGui : ITweak
virtual atVec3f GetDamageLightCenterTranslate() const=0; virtual atVec3f GetDamageLightCenterTranslate() const=0;
virtual float GetDamageLightXfXAngle() const=0; virtual float GetDamageLightXfXAngle() const=0;
virtual float GetDamageLightXfZAngle() const=0; virtual float GetDamageLightXfZAngle() const=0;
virtual float GetHudDecoShakeTranslateVelConstant() const=0;
virtual float GetHudDecoShakeTranslateVelLinear() const=0;
virtual float GetMaxDecoDamageShakeTranslate() const=0;
virtual float GetDecoDamageShakeDeceleration() const=0;
virtual float GetDecoShakeGainConstant() const=0;
virtual float GetDecoShakeGainLinear() const=0;
virtual float GetDecoShakeInitConstant() const=0;
virtual float GetDecoShakeInitLinear() const=0;
virtual float GetMaxDecoDamageShakeRotate() const=0;
virtual atUint32 GetHudCamFovTweak() const=0; virtual atUint32 GetHudCamFovTweak() const=0;
virtual atUint32 GetHudCamYTweak() const=0; virtual atUint32 GetHudCamYTweak() const=0;
virtual atUint32 GetHudCamZTweak() const=0; virtual atUint32 GetHudCamZTweak() const=0;
@ -65,7 +78,20 @@ struct ITweakGui : ITweak
virtual float GetFreeLookFadeTime() const=0; virtual float GetFreeLookFadeTime() const=0;
virtual float GetFreeLookSfxPitchScale() const=0; virtual float GetFreeLookSfxPitchScale() const=0;
virtual bool GetNoAbsoluteFreeLookSfxPitch() const=0; virtual bool GetNoAbsoluteFreeLookSfxPitch() const=0;
virtual float GetFaceReflectionDistance() const=0;
virtual float GetFaceReflectionHeight() const=0;
virtual float GetMissileWarningPulseTime() const=0; virtual float GetMissileWarningPulseTime() const=0;
virtual float GetExplosionLightFalloffMultConstant() const=0;
virtual float GetExplosionLightFalloffMultLinear() const=0;
virtual float GetExplosionLightFalloffMultQuadratic() const=0;
virtual float GetHudDamagePeakFactor() const=0;
virtual float GetHudDamageFilterGainConstant() const=0;
virtual float GetHudDamageFilterGainLinear() const=0;
virtual float GetHudDamageFilterInitConstant() const=0;
virtual float GetHudDamageFilterInitLinear() const=0;
virtual float GetHudDamagePulseDuration() const=0;
virtual float GetHudDamageColorGain() const=0;
virtual float GetHudDecoShakeTranslateGain() const=0;
virtual float GetHudLagOffsetScale() const=0; virtual float GetHudLagOffsetScale() const=0;
virtual float GetScanAppearanceOffset() const=0; virtual float GetScanAppearanceOffset() const=0;
virtual float GetBallViewportYReduction() const=0; virtual float GetBallViewportYReduction() const=0;
@ -86,6 +112,15 @@ struct ITweakGui : ITweak
virtual const zeus::CColor& GetXRayFogColor() const=0; virtual const zeus::CColor& GetXRayFogColor() const=0;
virtual float GetThermalVisorLevel() const=0; virtual float GetThermalVisorLevel() const=0;
virtual const zeus::CColor& GetThermalVisorColor() const=0; virtual const zeus::CColor& GetThermalVisorColor() const=0;
virtual const zeus::CColor& GetVisorHudLightAdd(int v) const=0;
virtual const zeus::CColor& GetVisorHudLightMultiply(int v) const=0;
virtual const zeus::CColor& GetHudReflectivityLightColor() const=0;
virtual float GetHudLightAttMulConstant() const=0;
virtual float GetHudLightAttMulLinear() const=0;
virtual float GetHudLightAttMulQuadratic() const=0;
static float FaceReflectionDistanceDebugValueToActualValue(float v) { return 0.015f * v + 0.2f; }
static float FaceReflectionHeightDebugValueToActualValue(float v) { return 0.005f * v - 0.05f; }
}; };
} }

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

@ -9,79 +9,83 @@ struct ITweakGuiColors : BigYAML
{ {
struct VisorEnergyInitColors struct VisorEnergyInitColors
{ {
zeus::CColor tankFilled; const zeus::CColor& tankFilled;
zeus::CColor tankEmpty; const zeus::CColor& tankEmpty;
zeus::CColor digitsFont; const zeus::CColor& digitsFont;
zeus::CColor digitsOutline; const zeus::CColor& digitsOutline;
}; };
struct VisorEnergyBarColors struct VisorEnergyBarColors
{ {
zeus::CColor filled; const zeus::CColor& filled;
zeus::CColor empty; const zeus::CColor& empty;
zeus::CColor shadow; const zeus::CColor& shadow;
}; };
virtual zeus::CColor GetRadarStuffColor() const=0; virtual const zeus::CColor& GetRadarStuffColor() const=0;
virtual zeus::CColor GetRadarPlayerPaintColor() const=0; virtual const zeus::CColor& GetRadarPlayerPaintColor() const=0;
virtual zeus::CColor GetRadarEnemyPaintColor() const=0; virtual const zeus::CColor& GetRadarEnemyPaintColor() const=0;
virtual zeus::CColor GetHudMessageFill() const=0; virtual const zeus::CColor& GetHudMessageFill() const=0;
virtual zeus::CColor GetHudMessageOutline() const=0; virtual const zeus::CColor& GetHudMessageOutline() const=0;
virtual zeus::CColor GetHudFrameColor() const=0; virtual const zeus::CColor& GetHudFrameColor() const=0;
virtual zeus::CColor GetMissileIconColorActive() const=0; virtual const zeus::CColor& GetMissileIconColorActive() const=0;
virtual zeus::CColor GetVisorBeamMenuItemActive() const=0; virtual const zeus::CColor& GetVisorBeamMenuItemActive() const=0;
virtual zeus::CColor GetVisorBeamMenuItemInactive() const=0; virtual const zeus::CColor& GetVisorBeamMenuItemInactive() const=0;
virtual zeus::CColor GetEnergyBarFilledLowEnergy() const=0; virtual const zeus::CColor& GetEnergyBarFilledLowEnergy() const=0;
virtual zeus::CColor GetEnergyBarShadowLowEnergy() const=0; virtual const zeus::CColor& GetEnergyBarShadowLowEnergy() const=0;
virtual zeus::CColor GetEnergyBarEmptyLowEnergy() const=0; virtual const zeus::CColor& GetEnergyBarEmptyLowEnergy() const=0;
virtual zeus::CColor GetHudDamageLightColor() const=0; virtual const zeus::CColor& GetHudDamageLightColor() const=0;
virtual zeus::CColor GetVisorMenuTextFont() const=0; virtual const zeus::CColor& GetVisorMenuTextFont() const=0;
virtual zeus::CColor GetVisorMenuTextOutline() const=0; virtual const zeus::CColor& GetVisorMenuTextOutline() const=0;
virtual zeus::CColor GetBeamMenuTextFont() const=0; virtual const zeus::CColor& GetBeamMenuTextFont() const=0;
virtual zeus::CColor GetBeamMenuTextOutline() const=0; virtual const zeus::CColor& GetBeamMenuTextOutline() const=0;
virtual zeus::CColor GetEnergyWarningFont() const=0; virtual const zeus::CColor& GetEnergyWarningFont() const=0;
virtual zeus::CColor GetThreatWarningFont() const=0; virtual const zeus::CColor& GetThreatWarningFont() const=0;
virtual zeus::CColor GetMissileWarningFont() const=0; virtual const zeus::CColor& GetMissileWarningFont() const=0;
virtual zeus::CColor GetThreatBarFilled() const=0; virtual const zeus::CColor& GetThreatBarFilled() const=0;
virtual zeus::CColor GetThreatBarShadow() const=0; virtual const zeus::CColor& GetThreatBarShadow() const=0;
virtual zeus::CColor GetThreatBarEmpty() const=0; virtual const zeus::CColor& GetThreatBarEmpty() const=0;
virtual zeus::CColor GetMissileBarFilled() const=0; virtual const zeus::CColor& GetMissileBarFilled() const=0;
virtual zeus::CColor GetMissileBarShadow() const=0; virtual const zeus::CColor& GetMissileBarShadow() const=0;
virtual zeus::CColor GetMissileBarEmpty() const=0; virtual const zeus::CColor& GetMissileBarEmpty() const=0;
virtual zeus::CColor GetThreatIconColor() const=0; virtual const zeus::CColor& GetThreatIconColor() const=0;
virtual zeus::CColor GetTickDecoColor() const=0; virtual const zeus::CColor& GetTickDecoColor() const=0;
virtual zeus::CColor GetHelmetLightColor() const=0; virtual const zeus::CColor& GetHelmetLightColor() const=0;
virtual zeus::CColor GetThreatIconSafeColor() const=0; virtual const zeus::CColor& GetThreatIconSafeColor() const=0;
virtual zeus::CColor GetMissileIconColorInactive() const=0; virtual const zeus::CColor& GetMissileIconColorInactive() const=0;
virtual zeus::CColor GetMissileIconColorChargedCanAlt() const=0; virtual const zeus::CColor& GetMissileIconColorChargedCanAlt() const=0;
virtual zeus::CColor GetMissileIconColorChargedNoAlt() const=0; virtual const zeus::CColor& GetMissileIconColorChargedNoAlt() const=0;
virtual zeus::CColor GetMissileIconColorDepleteAlt() const=0; virtual const zeus::CColor& GetMissileIconColorDepleteAlt() const=0;
virtual zeus::CColor GetVisorBeamMenuLozColor() const=0; virtual const zeus::CColor& GetVisorBeamMenuLozColor() const=0;
virtual zeus::CColor GetEnergyWarningOutline() const=0; virtual const zeus::CColor& GetEnergyWarningOutline() const=0;
virtual zeus::CColor GetThreatWarningOutline() const=0; virtual const zeus::CColor& GetThreatWarningOutline() const=0;
virtual zeus::CColor GetMissileWarningOutline() const=0; virtual const zeus::CColor& GetMissileWarningOutline() const=0;
virtual zeus::CColor GetEnergyBarFlashColor() const=0; virtual const zeus::CColor& GetDamageAmbientColor() const=0;
virtual zeus::CColor GetXRayEnergyDecoColor() const=0; virtual const zeus::CColor& GetScanVisorHudLightMultiply() const=0;
virtual zeus::CColor GetPowerBombDigitAvailableFont() const=0; virtual const zeus::CColor& GetThermalVisorHudLightMultiply() const=0;
virtual zeus::CColor GetPowerBombDigitAvailableOutline() const=0; virtual const zeus::CColor& GetDamageAmbientPulseColor() const=0;
virtual zeus::CColor GetBallBombFilledColor() const=0; virtual const zeus::CColor& GetEnergyBarFlashColor() const=0;
virtual zeus::CColor GetBallBombEmptyColor() const=0; virtual const zeus::CColor& GetXRayEnergyDecoColor() const=0;
virtual zeus::CColor GetPowerBombIconAvailableColor() const=0; virtual const zeus::CColor& GetPowerBombDigitAvailableFont() const=0;
virtual zeus::CColor GetBallBombEnergyColor() const=0; virtual const zeus::CColor& GetPowerBombDigitAvailableOutline() const=0;
virtual zeus::CColor GetBallBombDecoColor() const=0; virtual const zeus::CColor& GetBallBombFilledColor() const=0;
virtual zeus::CColor GetPowerBombDigitDelpetedFont() const=0; virtual const zeus::CColor& GetBallBombEmptyColor() const=0;
virtual zeus::CColor GetPowerBombDigitDelpetedOutline() const=0; virtual const zeus::CColor& GetPowerBombIconAvailableColor() const=0;
virtual zeus::CColor GetPowerBombIconDepletedColor() const=0; virtual const zeus::CColor& GetBallBombEnergyColor() const=0;
virtual zeus::CColor GetThreatIconWarningColor() const=0; virtual const zeus::CColor& GetBallBombDecoColor() const=0;
virtual zeus::CColor GetHudCounterFill() const=0; virtual const zeus::CColor& GetPowerBombDigitDelpetedFont() const=0;
virtual zeus::CColor GetHudCounterOutline() const=0; virtual const zeus::CColor& GetPowerBombDigitDelpetedOutline() const=0;
virtual zeus::CColor GetThreatDigitsFont() const=0; virtual const zeus::CColor& GetPowerBombIconDepletedColor() const=0;
virtual zeus::CColor GetThreatDigitsOutline() const=0; virtual const zeus::CColor& GetThreatIconWarningColor() const=0;
virtual zeus::CColor GetMissileDigitsFont() const=0; virtual const zeus::CColor& GetHudCounterFill() const=0;
virtual zeus::CColor GetMissileDigitsOutline() const=0; virtual const zeus::CColor& GetHudCounterOutline() const=0;
virtual zeus::CColor GetThermalDecoColor() const=0; virtual const zeus::CColor& GetThreatDigitsFont() const=0;
virtual zeus::CColor GetThermalOutlinesColor() const=0; virtual const zeus::CColor& GetThreatDigitsOutline() const=0;
virtual zeus::CColor GetThermalLockColor() const=0; virtual const zeus::CColor& GetMissileDigitsFont() const=0;
virtual const zeus::CColor& GetMissileDigitsOutline() const=0;
virtual const zeus::CColor& GetThermalDecoColor() const=0;
virtual const zeus::CColor& GetThermalOutlinesColor() const=0;
virtual const zeus::CColor& GetThermalLockColor() const=0;
virtual VisorEnergyInitColors GetVisorEnergyInitColors(int idx) const=0; virtual VisorEnergyInitColors GetVisorEnergyInitColors(int idx) const=0;
virtual VisorEnergyBarColors GetVisorEnergyBarColors(int idx) const=0; virtual VisorEnergyBarColors GetVisorEnergyBarColors(int idx) const=0;
}; };

13
DataSpec/DNAMP1/MREA.cpp
View File

@ -167,15 +167,12 @@ bool MREA::Extract(const SpecBase& dataSpec,
rs.seek(secStart + head.secSizes[curSec++], athena::Begin); rs.seek(secStart + head.secSizes[curSec++], athena::Begin);
/* Dump VISI entities */ /* Dump VISI entities */
auto visiPos = rs.position();
if (head.secSizes[curSec] && rs.readUint32Big() == 'VISI') if (head.secSizes[curSec] && rs.readUint32Big() == 'VISI')
{ {
athena::io::YAMLDocWriter visiWriter("VISI"); athena::io::YAMLDocWriter visiWriter("VISI");
uint32_t unkCount = 0;
if (auto __vec = visiWriter.enterSubVector("entities")) if (auto __vec = visiWriter.enterSubVector("entities"))
{ {
rs.seek(14, athena::Current); rs.seek(18, athena::Current);
unkCount = rs.readUint32Big();
uint32_t entityCount = rs.readUint32Big(); uint32_t entityCount = rs.readUint32Big();
rs.seek(8, athena::Current); rs.seek(8, athena::Current);
for (int i=0 ; i<entityCount ; ++i) for (int i=0 ; i<entityCount ; ++i)
@ -187,14 +184,6 @@ bool MREA::Extract(const SpecBase& dataSpec,
hecl::ProjectPath visiMetadataPath(outPath.getParentPath(), _S("!visi.yaml")); hecl::ProjectPath visiMetadataPath(outPath.getParentPath(), _S("!visi.yaml"));
athena::io::FileWriter visiMetadata(visiMetadataPath.getAbsolutePath()); athena::io::FileWriter visiMetadata(visiMetadataPath.getAbsolutePath());
visiWriter.finish(&visiMetadata); visiWriter.finish(&visiMetadata);
if (unkCount)
{
rs.seek(visiPos, athena::Begin);
auto bytes = rs.readUBytes(head.secSizes[curSec]);
athena::io::FileWriter fw(std::string("/Users/jacko/Desktop/") + pakRouter.getBestEntryName(entry, false).c_str() + ".visi");
fw.writeUBytes(bytes.get(), head.secSizes[curSec]);
}
} }
/* Origins to center of mass */ /* Origins to center of mass */

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

@ -26,10 +26,10 @@ struct CTweakGui : ITweakGui
Value<float> x38_energyBarShadowSpeed; Value<float> x38_energyBarShadowSpeed;
Value<float> x3c_energyBarDrainDelay; Value<float> x3c_energyBarDrainDelay;
Value<bool> x40_energyBarAlwaysResetDelay; Value<bool> x40_energyBarAlwaysResetDelay;
Value<float> x44_; Value<float> x44_hudDamagePracticalsGainConstant;
Value<float> x48_; Value<float> x48_hudDamagePracticalsGainLinear;
Value<float> x4c_; Value<float> x4c_hudDamagePracticalsInitConstant;
Value<float> x50_; Value<float> x50_hudDamagePracticalsInitLinear;
Value<float> x54_hudDamageLightSpotAngle; Value<float> x54_hudDamageLightSpotAngle;
Value<float> x58_damageLightAngleC; Value<float> x58_damageLightAngleC;
Value<float> x5c_damageLightAngleL; Value<float> x5c_damageLightAngleL;
@ -38,15 +38,15 @@ struct CTweakGui : ITweakGui
Value<atVec3f> x70_damageLightCenterTranslate; Value<atVec3f> x70_damageLightCenterTranslate;
Value<float> x7c_damageLightXfXAngle; Value<float> x7c_damageLightXfXAngle;
Value<float> x80_damageLightXfZAngle; Value<float> x80_damageLightXfZAngle;
Value<float> x84_; Value<float> x84_hudDecoShakeTranslateVelConstant;
Value<float> x88_; Value<float> x88_hudDecoShakeTranslateVelLinear;
Value<float> x8c_; Value<float> x8c_maxDecoDamageShakeTranslate;
Value<float> x90_; Value<float> x90_decoDamageShakeDeceleration;
Value<float> x94_; Value<float> x94_decoShakeGainConstant;
Value<float> x98_; Value<float> x98_decoShakeGainLinear;
Value<float> x9c_; Value<float> x9c_decoShakeInitConstant;
Value<float> xa0_; Value<float> xa0_decoShakeInitLinear;
Value<float> xa4_; Value<float> xa4_maxDecoDamageShakeRotate;
Value<atUint32> xa8_hudCamFovTweak; Value<atUint32> xa8_hudCamFovTweak;
Value<atUint32> xac_hudCamYTweak; Value<atUint32> xac_hudCamYTweak;
Value<atUint32> xb0_hudCamZTweak; Value<atUint32> xb0_hudCamZTweak;
@ -86,8 +86,8 @@ struct CTweakGui : ITweakGui
Value<float> x138_; Value<float> x138_;
Value<atUint32> x13c_; Value<atUint32> x13c_;
Value<atUint32> x140_; Value<atUint32> x140_;
Value<atUint32> x144_; Value<atUint32> x144_faceReflectionDistance;
Value<atUint32> x148_; Value<atUint32> x148_faceReflectionHeight;
Value<atUint32> x14c_; Value<atUint32> x14c_;
String<-1> x150_; String<-1> x150_;
String<-1> x160_; String<-1> x160_;
@ -95,21 +95,21 @@ struct CTweakGui : ITweakGui
String<-1> x180_; String<-1> x180_;
String<-1> x190_; String<-1> x190_;
Value<float> x1a0_missileWarningPulseTime; Value<float> x1a0_missileWarningPulseTime;
Value<float> x1a4_; Value<float> x1a4_explosionLightFalloffMultConstant;
Value<float> x1a8_; Value<float> x1a8_explosionLightFalloffMultLinear;
Value<float> x1ac_; Value<float> x1ac_explosionLightFalloffMultQuadratic;
Value<float> x1b0_; Value<float> x1b0_;
Value<float> x1b4_; Value<float> x1b4_hudDamagePeakFactor;
Value<float> x1b8_; Value<float> x1b8_hudDamageFilterGainConstant;
Value<float> x1bc_; Value<float> x1bc_hudDamageFilterGainLinear;
Value<float> x1c0_; Value<float> x1c0_hudDamageFilterInitConstant;
Value<float> x1c4_; Value<float> x1c4_hudDamageFilterInitLinear;
Value<float> x1c8_; Value<float> x1c8_;
Value<bool> x1cc_; Value<bool> x1cc_;
Value<bool> x1cd_; Value<bool> x1cd_;
Value<float> x1d0_; Value<float> x1d0_hudDamagePulseDuration;
Value<float> x1d4_; Value<float> x1d4_hudDamageColorGain;
Value<float> x1d8_; Value<float> x1d8_hudDecoShakeTranslateGain;
Value<float> x1dc_hudLagOffsetScale; Value<float> x1dc_hudLagOffsetScale;
Value<float> x1e0_; Value<float> x1e0_;
Value<float> x1e4_; Value<float> x1e4_;
@ -157,18 +157,12 @@ struct CTweakGui : ITweakGui
DNAColor x288_xrayFogColor; DNAColor x288_xrayFogColor;
Value<float> x28c_thermalVisorLevel; Value<float> x28c_thermalVisorLevel;
DNAColor x290_thermalVisorColor; DNAColor x290_thermalVisorColor;
DNAColor x294_; DNAColor x294_hudLightAddPerVisor[4];
DNAColor x298_; DNAColor x2a4_hudLightMultiplyPerVisor[4];
DNAColor x29c_; DNAColor x2b4_hudReflectivityLightColor;
DNAColor x2a0_; Value<float> x2b8_hudLightAttMulConstant;
DNAColor x2a4_; Value<float> x2bc_hudLightAttMulLinear;
DNAColor x2a8_; Value<float> x2c0_hudLightAttMulQuadratic;
DNAColor x2ac_;
DNAColor x2b0_;
DNAColor x2b4_;
Value<float> x2b8_;
Value<float> x2bc_;
Value<float> x2c0_;
Value<atUint32> m_scanSpeedsCount; Value<atUint32> m_scanSpeedsCount;
Vector<float, DNA_COUNT(m_scanSpeedsCount)> x2c4_scanSpeeds; Vector<float, DNA_COUNT(m_scanSpeedsCount)> x2c4_scanSpeeds;
String<-1> x2d0_; String<-1> x2d0_;
@ -203,6 +197,10 @@ struct CTweakGui : ITweakGui
float GetEnergyBarShadowSpeed() const { return x38_energyBarShadowSpeed; } float GetEnergyBarShadowSpeed() const { return x38_energyBarShadowSpeed; }
float GetEnergyBarDrainDelay() const { return x3c_energyBarDrainDelay; } float GetEnergyBarDrainDelay() const { return x3c_energyBarDrainDelay; }
bool GetEnergyBarAlwaysResetDelay() const { return x40_energyBarAlwaysResetDelay; } bool GetEnergyBarAlwaysResetDelay() const { return x40_energyBarAlwaysResetDelay; }
float GetHudDamagePracticalsGainConstant() const { return x44_hudDamagePracticalsGainConstant; }
float GetHudDamagePracticalsGainLinear() const { return x48_hudDamagePracticalsGainLinear; }
float GetHudDamagePracticalsInitConstant() const { return x4c_hudDamagePracticalsInitConstant; }
float GetHudDamagePracticalsInitLinear() const { return x50_hudDamagePracticalsInitLinear; }
float GetHudDamageLightSpotAngle() const { return x54_hudDamageLightSpotAngle; } float GetHudDamageLightSpotAngle() const { return x54_hudDamageLightSpotAngle; }
float GetDamageLightAngleC() const { return x58_damageLightAngleC; } float GetDamageLightAngleC() const { return x58_damageLightAngleC; }
float GetDamageLightAngleL() const { return x5c_damageLightAngleL; } float GetDamageLightAngleL() const { return x5c_damageLightAngleL; }
@ -211,6 +209,15 @@ struct CTweakGui : ITweakGui
atVec3f GetDamageLightCenterTranslate() const { return x70_damageLightCenterTranslate; } atVec3f GetDamageLightCenterTranslate() const { return x70_damageLightCenterTranslate; }
float GetDamageLightXfXAngle() const { return x7c_damageLightXfXAngle; } float GetDamageLightXfXAngle() const { return x7c_damageLightXfXAngle; }
float GetDamageLightXfZAngle() const { return x80_damageLightXfZAngle; } float GetDamageLightXfZAngle() const { return x80_damageLightXfZAngle; }
float GetHudDecoShakeTranslateVelConstant() const { return x84_hudDecoShakeTranslateVelConstant; }
float GetHudDecoShakeTranslateVelLinear() const { return x88_hudDecoShakeTranslateVelLinear; }
float GetMaxDecoDamageShakeTranslate() const { return x8c_maxDecoDamageShakeTranslate; }
float GetDecoDamageShakeDeceleration() const { return x90_decoDamageShakeDeceleration; }
float GetDecoShakeGainConstant() const { return x94_decoShakeGainConstant; }
float GetDecoShakeGainLinear() const { return x98_decoShakeGainLinear; }
float GetDecoShakeInitConstant() const { return x9c_decoShakeInitConstant; }
float GetDecoShakeInitLinear() const { return xa0_decoShakeInitLinear; }
float GetMaxDecoDamageShakeRotate() const { return xa4_maxDecoDamageShakeRotate; }
atUint32 GetHudCamFovTweak() const { return xa8_hudCamFovTweak; } atUint32 GetHudCamFovTweak() const { return xa8_hudCamFovTweak; }
atUint32 GetHudCamYTweak() const { return xac_hudCamYTweak; } atUint32 GetHudCamYTweak() const { return xac_hudCamYTweak; }
atUint32 GetHudCamZTweak() const { return xb0_hudCamZTweak; } atUint32 GetHudCamZTweak() const { return xb0_hudCamZTweak; }
@ -233,7 +240,20 @@ struct CTweakGui : ITweakGui
float GetFreeLookFadeTime() const { return x118_freeLookFadeTime; } float GetFreeLookFadeTime() const { return x118_freeLookFadeTime; }
float GetFreeLookSfxPitchScale() const { return x12c_freeLookSfxPitchScale; } float GetFreeLookSfxPitchScale() const { return x12c_freeLookSfxPitchScale; }
bool GetNoAbsoluteFreeLookSfxPitch() const { return x130_noAbsoluteFreeLookSfxPitch; } bool GetNoAbsoluteFreeLookSfxPitch() const { return x130_noAbsoluteFreeLookSfxPitch; }
float GetFaceReflectionDistance() const { return x144_faceReflectionDistance; }
float GetFaceReflectionHeight() const { return x148_faceReflectionHeight; }
float GetMissileWarningPulseTime() const { return x1a0_missileWarningPulseTime; } float GetMissileWarningPulseTime() const { return x1a0_missileWarningPulseTime; }
float GetExplosionLightFalloffMultConstant() const { return x1a4_explosionLightFalloffMultConstant; }
float GetExplosionLightFalloffMultLinear() const { return x1a8_explosionLightFalloffMultLinear; }
float GetExplosionLightFalloffMultQuadratic() const { return x1ac_explosionLightFalloffMultQuadratic; }
float GetHudDamagePeakFactor() const { return x1b4_hudDamagePeakFactor; }
float GetHudDamageFilterGainConstant() const { return x1b8_hudDamageFilterGainConstant; }
float GetHudDamageFilterGainLinear() const { return x1bc_hudDamageFilterGainLinear; }
float GetHudDamageFilterInitConstant() const { return x1c0_hudDamageFilterInitConstant; }
float GetHudDamageFilterInitLinear() const { return x1c4_hudDamageFilterInitLinear; }
float GetHudDamagePulseDuration() const { return x1d0_hudDamagePulseDuration; }
float GetHudDamageColorGain() const { return x1d4_hudDamageColorGain; }
float GetHudDecoShakeTranslateGain() const { return x1d8_hudDecoShakeTranslateGain; }
float GetHudLagOffsetScale() const { return x1dc_hudLagOffsetScale; } float GetHudLagOffsetScale() const { return x1dc_hudLagOffsetScale; }
float GetScanAppearanceOffset() const { return x244_scanAppearanceOffset; } float GetScanAppearanceOffset() const { return x244_scanAppearanceOffset; }
float GetBallViewportYReduction() const { return x254_ballViewportYReduction; } float GetBallViewportYReduction() const { return x254_ballViewportYReduction; }
@ -253,6 +273,12 @@ struct CTweakGui : ITweakGui
const zeus::CColor& GetXRayFogColor() const { return x288_xrayFogColor; } const zeus::CColor& GetXRayFogColor() const { return x288_xrayFogColor; }
float GetThermalVisorLevel() const { return x28c_thermalVisorLevel; } float GetThermalVisorLevel() const { return x28c_thermalVisorLevel; }
const zeus::CColor& GetThermalVisorColor() const { return x290_thermalVisorColor; } const zeus::CColor& GetThermalVisorColor() const { return x290_thermalVisorColor; }
const zeus::CColor& GetVisorHudLightAdd(int v) const { return x294_hudLightAddPerVisor[v]; }
const zeus::CColor& GetVisorHudLightMultiply(int v) const { return x2a4_hudLightMultiplyPerVisor[v]; }
const zeus::CColor& GetHudReflectivityLightColor() const { return x2b4_hudReflectivityLightColor; }
float GetHudLightAttMulConstant() const { return x2b8_hudLightAttMulConstant; }
float GetHudLightAttMulLinear() const { return x2bc_hudLightAttMulLinear; }
float GetHudLightAttMulQuadratic() const { return x2c0_hudLightAttMulQuadratic; }
float GetScanSpeed(int idx) const float GetScanSpeed(int idx) const
{ {
@ -282,7 +308,7 @@ struct CTweakGui : ITweakGui
else else
x27c_xrayFogMode = 0; x27c_xrayFogMode = 0;
x84_ *= 2.0f; x84_hudDecoShakeTranslateVelConstant *= 2.0f;
} }
}; };

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

@ -58,15 +58,15 @@ struct CTweakGuiColors : public ITweakGuiColors
DNAColor xb8_threatWarningOutline; DNAColor xb8_threatWarningOutline;
DNAColor xbc_missileWarningOutline; DNAColor xbc_missileWarningOutline;
DNAColor xc0_; DNAColor xc0_;
DNAColor xc4_; DNAColor xc4_damageAmbientColor;
DNAColor xc8_; DNAColor xc8_;
DNAColor xcc_; DNAColor xcc_;
DNAColor xd0_; DNAColor xd0_;
DNAColor xd4_; DNAColor xd4_scanVisorHudLightMultiply;
DNAColor xd8_; DNAColor xd8_;
DNAColor xdc_; DNAColor xdc_thermalVisorHudLightMultiply;
DNAColor xe0_; DNAColor xe0_;
DNAColor xe4_; DNAColor xe4_damageAmbientPulseColor;
DNAColor xe8_energyBarFlashColor; DNAColor xe8_energyBarFlashColor;
DNAColor xec_; DNAColor xec_;
DNAColor xf0_; DNAColor xf0_;
@ -140,66 +140,70 @@ struct CTweakGuiColors : public ITweakGuiColors
CTweakGuiColors() = default; CTweakGuiColors() = default;
CTweakGuiColors(athena::io::IStreamReader& r) { this->read(r); } CTweakGuiColors(athena::io::IStreamReader& r) { this->read(r); }
zeus::CColor GetRadarStuffColor() const { return x8_radarStuffColor; } const zeus::CColor& GetRadarStuffColor() const { return x8_radarStuffColor; }
zeus::CColor GetRadarPlayerPaintColor() const { return xc_radarPlayerPaintColor; } const zeus::CColor& GetRadarPlayerPaintColor() const { return xc_radarPlayerPaintColor; }
zeus::CColor GetRadarEnemyPaintColor() const { return x10_radarEnemyPaintColor; } const zeus::CColor& GetRadarEnemyPaintColor() const { return x10_radarEnemyPaintColor; }
zeus::CColor GetHudMessageFill() const { return x14_hudMessageFill; } const zeus::CColor& GetHudMessageFill() const { return x14_hudMessageFill; }
zeus::CColor GetHudMessageOutline() const { return x18_hudMessageOutline; } const zeus::CColor& GetHudMessageOutline() const { return x18_hudMessageOutline; }
zeus::CColor GetHudFrameColor() const { return x1c_hudFrameColor; } const zeus::CColor& GetHudFrameColor() const { return x1c_hudFrameColor; }
zeus::CColor GetMissileIconColorActive() const { return x28_missileIconColorActive; } const zeus::CColor& GetMissileIconColorActive() const { return x28_missileIconColorActive; }
zeus::CColor GetVisorBeamMenuItemActive() const { return x2c_visorBeamMenuItemActive; } const zeus::CColor& GetVisorBeamMenuItemActive() const { return x2c_visorBeamMenuItemActive; }
zeus::CColor GetVisorBeamMenuItemInactive() const { return x30_visorBeamMenuColorInactive; } const zeus::CColor& GetVisorBeamMenuItemInactive() const { return x30_visorBeamMenuColorInactive; }
zeus::CColor GetEnergyBarFilledLowEnergy() const { return x34_energyBarFilledLowEnergy; } const zeus::CColor& GetEnergyBarFilledLowEnergy() const { return x34_energyBarFilledLowEnergy; }
zeus::CColor GetEnergyBarShadowLowEnergy() const { return x38_energyBarShadowLowEnergy; } const zeus::CColor& GetEnergyBarShadowLowEnergy() const { return x38_energyBarShadowLowEnergy; }
zeus::CColor GetEnergyBarEmptyLowEnergy() const { return x3c_energyBarEmptyLowEnergy; } const zeus::CColor& GetEnergyBarEmptyLowEnergy() const { return x3c_energyBarEmptyLowEnergy; }
zeus::CColor GetHudDamageLightColor() const { return x40_hudDamageLightColor; } const zeus::CColor& GetHudDamageLightColor() const { return x40_hudDamageLightColor; }
zeus::CColor GetVisorMenuTextFont() const { return x4c_visorMenuTextFont; } const zeus::CColor& GetVisorMenuTextFont() const { return x4c_visorMenuTextFont; }
zeus::CColor GetVisorMenuTextOutline() const { return x50_visorMenuTextOutline; } const zeus::CColor& GetVisorMenuTextOutline() const { return x50_visorMenuTextOutline; }
zeus::CColor GetBeamMenuTextFont() const { return x54_beamMenuTextFont; } const zeus::CColor& GetBeamMenuTextFont() const { return x54_beamMenuTextFont; }
zeus::CColor GetBeamMenuTextOutline() const { return x58_beamMenuTextOutline; } const zeus::CColor& GetBeamMenuTextOutline() const { return x58_beamMenuTextOutline; }
zeus::CColor GetEnergyWarningFont() const { return x5c_energyWarningFont; } const zeus::CColor& GetEnergyWarningFont() const { return x5c_energyWarningFont; }
zeus::CColor GetThreatWarningFont() const { return x60_threatWarningFont; } const zeus::CColor& GetThreatWarningFont() const { return x60_threatWarningFont; }
zeus::CColor GetMissileWarningFont() const { return x64_missileWarningFont; } const zeus::CColor& GetMissileWarningFont() const { return x64_missileWarningFont; }
zeus::CColor GetThreatBarFilled() const { return x68_threatBarFilled; } const zeus::CColor& GetThreatBarFilled() const { return x68_threatBarFilled; }
zeus::CColor GetThreatBarShadow() const { return x6c_threatBarShadow; } const zeus::CColor& GetThreatBarShadow() const { return x6c_threatBarShadow; }
zeus::CColor GetThreatBarEmpty() const { return x70_threatBarEmpty; } const zeus::CColor& GetThreatBarEmpty() const { return x70_threatBarEmpty; }
zeus::CColor GetMissileBarFilled() const { return x74_missileBarFilled; } const zeus::CColor& GetMissileBarFilled() const { return x74_missileBarFilled; }
zeus::CColor GetMissileBarShadow() const { return x78_missileBarShadow; } const zeus::CColor& GetMissileBarShadow() const { return x78_missileBarShadow; }
zeus::CColor GetMissileBarEmpty() const { return x7c_missileBarEmpty; } const zeus::CColor& GetMissileBarEmpty() const { return x7c_missileBarEmpty; }
zeus::CColor GetThreatIconColor() const { return x80_threatIconColor; } const zeus::CColor& GetThreatIconColor() const { return x80_threatIconColor; }
zeus::CColor GetTickDecoColor() const { return x88_tickDecoColor; } const zeus::CColor& GetTickDecoColor() const { return x88_tickDecoColor; }
zeus::CColor GetHelmetLightColor() const { return x8c_helmetLightColor; } const zeus::CColor& GetHelmetLightColor() const { return x8c_helmetLightColor; }
zeus::CColor GetThreatIconSafeColor() const { return x90_threatIconSafeColor; } const zeus::CColor& GetThreatIconSafeColor() const { return x90_threatIconSafeColor; }
zeus::CColor GetMissileIconColorInactive() const { return x94_missileIconColorInactive; } const zeus::CColor& GetMissileIconColorInactive() const { return x94_missileIconColorInactive; }
zeus::CColor GetMissileIconColorChargedCanAlt() const { return x98_missileIconColorChargedCanAlt; } const zeus::CColor& GetMissileIconColorChargedCanAlt() const { return x98_missileIconColorChargedCanAlt; }
zeus::CColor GetMissileIconColorChargedNoAlt() const { return x9c_missileIconColorChargedNoAlt; } const zeus::CColor& GetMissileIconColorChargedNoAlt() const { return x9c_missileIconColorChargedNoAlt; }
zeus::CColor GetMissileIconColorDepleteAlt() const { return xa0_missileIconColorDepleteAlt; } const zeus::CColor& GetMissileIconColorDepleteAlt() const { return xa0_missileIconColorDepleteAlt; }
zeus::CColor GetVisorBeamMenuLozColor() const { return xb0_visorBeamMenuLozColor; } const zeus::CColor& GetVisorBeamMenuLozColor() const { return xb0_visorBeamMenuLozColor; }
zeus::CColor GetEnergyWarningOutline() const { return xb4_energyWarningOutline; } const zeus::CColor& GetEnergyWarningOutline() const { return xb4_energyWarningOutline; }
zeus::CColor GetThreatWarningOutline() const { return xb8_threatWarningOutline; } const zeus::CColor& GetThreatWarningOutline() const { return xb8_threatWarningOutline; }
zeus::CColor GetMissileWarningOutline() const { return xbc_missileWarningOutline; } const zeus::CColor& GetMissileWarningOutline() const { return xbc_missileWarningOutline; }
zeus::CColor GetEnergyBarFlashColor() const { return xe8_energyBarFlashColor; } const zeus::CColor& GetDamageAmbientColor() const { return xc4_damageAmbientColor; }
zeus::CColor GetXRayEnergyDecoColor() const { return x100_xrayEnergyDecoColor; } const zeus::CColor& GetScanVisorHudLightMultiply() const { return xd4_scanVisorHudLightMultiply; }
zeus::CColor GetPowerBombDigitAvailableFont() const { return x13c_powerBombDigitAvailableFont; } const zeus::CColor& GetThermalVisorHudLightMultiply() const { return xdc_thermalVisorHudLightMultiply; }
zeus::CColor GetPowerBombDigitAvailableOutline() const { return x140_powerBombDigitAvailableOutline; } const zeus::CColor& GetDamageAmbientPulseColor() const { return xe4_damageAmbientPulseColor; }
zeus::CColor GetBallBombFilledColor() const { return x148_ballBombFilled; } const zeus::CColor& GetEnergyBarFlashColor() const { return xe8_energyBarFlashColor; }
zeus::CColor GetBallBombEmptyColor() const { return x14c_ballBombEmpty; } const zeus::CColor& GetXRayEnergyDecoColor() const { return x100_xrayEnergyDecoColor; }
zeus::CColor GetPowerBombIconAvailableColor() const { return x150_powerBombIconAvailable; } const zeus::CColor& GetPowerBombDigitAvailableFont() const { return x13c_powerBombDigitAvailableFont; }
zeus::CColor GetBallBombEnergyColor() const { return x158_ballEnergyDeco; } const zeus::CColor& GetPowerBombDigitAvailableOutline() const { return x140_powerBombDigitAvailableOutline; }
zeus::CColor GetBallBombDecoColor() const { return x15c_ballBombDeco; } const zeus::CColor& GetBallBombFilledColor() const { return x148_ballBombFilled; }
zeus::CColor GetPowerBombDigitDelpetedFont() const { return x160_powerBombDigitDepletedFont; } const zeus::CColor& GetBallBombEmptyColor() const { return x14c_ballBombEmpty; }
zeus::CColor GetPowerBombDigitDelpetedOutline() const { return x164_powerBombDigitDepletedOutline; } const zeus::CColor& GetPowerBombIconAvailableColor() const { return x150_powerBombIconAvailable; }
zeus::CColor GetPowerBombIconDepletedColor() const { return x168_powerBombIconUnavailable; } const zeus::CColor& GetBallBombEnergyColor() const { return x158_ballEnergyDeco; }
zeus::CColor GetThreatIconWarningColor() const { return x17c_threatIconWarningColor; } const zeus::CColor& GetBallBombDecoColor() const { return x15c_ballBombDeco; }
zeus::CColor GetHudCounterFill() const { return x180_hudCounterFill; } const zeus::CColor& GetPowerBombDigitDelpetedFont() const { return x160_powerBombDigitDepletedFont; }
zeus::CColor GetHudCounterOutline() const { return x184_hudCounterOutline; } const zeus::CColor& GetPowerBombDigitDelpetedOutline() const { return x164_powerBombDigitDepletedOutline; }
zeus::CColor GetThreatDigitsFont() const { return x19c_threatDigitsFont; } const zeus::CColor& GetPowerBombIconDepletedColor() const { return x168_powerBombIconUnavailable; }
zeus::CColor GetThreatDigitsOutline() const { return x1a0_threatDigitsOutline; } const zeus::CColor& GetThreatIconWarningColor() const { return x17c_threatIconWarningColor; }
zeus::CColor GetMissileDigitsFont() const { return x1a4_missileDigitsFont; } const zeus::CColor& GetHudCounterFill() const { return x180_hudCounterFill; }
zeus::CColor GetMissileDigitsOutline() const { return x1a8_missileDigitsOutline; } const zeus::CColor& GetHudCounterOutline() const { return x184_hudCounterOutline; }
zeus::CColor GetThermalDecoColor() const { return x1ac_thermalDecoColor; } const zeus::CColor& GetThreatDigitsFont() const { return x19c_threatDigitsFont; }
zeus::CColor GetThermalOutlinesColor() const { return x1b0_thermalOutlinesColor; } const zeus::CColor& GetThreatDigitsOutline() const { return x1a0_threatDigitsOutline; }
zeus::CColor GetThermalLockColor() const { return x1b8_thermalLockColor; } const zeus::CColor& GetMissileDigitsFont() const { return x1a4_missileDigitsFont; }
const zeus::CColor& GetMissileDigitsOutline() const { return x1a8_missileDigitsOutline; }
const zeus::CColor& GetThermalDecoColor() const { return x1ac_thermalDecoColor; }
const zeus::CColor& GetThermalOutlinesColor() const { return x1b0_thermalOutlinesColor; }
const zeus::CColor& GetThermalLockColor() const { return x1b8_thermalLockColor; }
VisorEnergyInitColors GetVisorEnergyInitColors(int idx) const VisorEnergyInitColors GetVisorEnergyInitColors(int idx) const
{ {
const PerVisorColors& colors = x1c4_perVisorColors[idx]; const PerVisorColors& colors = x1c4_perVisorColors[idx];

21
Runtime/Audio/CSfxManager.cpp
View File

@ -371,6 +371,27 @@ CSfxHandle CSfxManager::SfxStart(u16 id, float vol, float pan, bool useAcoustics
return wrapper; return wrapper;
} }
void CSfxManager::RemoveEmitter(const CSfxHandle& handle)
{
StopSound(handle);
}
void CSfxManager::UpdateEmitter(const CSfxHandle& handle, const zeus::CVector3f& pos,
const zeus::CVector3f& dir, float maxVol)
{
if (!handle || !handle->IsEmitter() || !handle->IsPlaying())
return;
m_doUpdate = true;
CSfxEmitterWrapper& emitter = static_cast<CSfxEmitterWrapper&>(*handle);
emitter.GetEmitterData().x0_pos = pos;
emitter.GetEmitterData().xc_dir = dir;
emitter.GetEmitterData().x26_maxVol = maxVol;
amuse::Emitter& h = *emitter.GetHandle();
h.setPos(pos.v);
h.setDir(dir.v);
h.setMaxVol(maxVol);
}
CSfxHandle CSfxManager::AddEmitter(u16 id, const zeus::CVector3f& pos, const zeus::CVector3f& dir, float vol, CSfxHandle CSfxManager::AddEmitter(u16 id, const zeus::CVector3f& pos, const zeus::CVector3f& dir, float vol,
bool useAcoustics, bool looped, s16 prio, s32 areaId) bool useAcoustics, bool looped, s16 prio, s32 areaId)
{ {

5
Runtime/Audio/CSfxManager.hpp
View File

@ -128,6 +128,7 @@ public:
void UpdateEmitterSilent(); void UpdateEmitterSilent();
void UpdateEmitter(); void UpdateEmitter();
void SetReverb(float rev); void SetReverb(float rev);
CAudioSys::C3DEmitterParmData& GetEmitterData() { return x24_parmData; }
const std::shared_ptr<amuse::Emitter>& GetHandle() const { return x50_emitterHandle; } const std::shared_ptr<amuse::Emitter>& GetHandle() const { return x50_emitterHandle; }
@ -203,12 +204,14 @@ public:
static s16 GetRank(CBaseSfxWrapper* sfx); static s16 GetRank(CBaseSfxWrapper* sfx);
static void ApplyReverb(); static void ApplyReverb();
static float GetReverbAmount(); static float GetReverbAmount();
static void RemoveEmitter(const CSfxHandle&) {}
static void PitchBend(const CSfxHandle& handle, float pitch); static void PitchBend(const CSfxHandle& handle, float pitch);
static void SfxVolume(const CSfxHandle& handle, float vol); static void SfxVolume(const CSfxHandle& handle, float vol);
static u16 TranslateSFXID(u16); static u16 TranslateSFXID(u16);
static void SfxStop(const CSfxHandle& handle); static void SfxStop(const CSfxHandle& handle);
static CSfxHandle SfxStart(u16 id, float vol, float pan, bool useAcoustics, s16 prio, bool looped, s32 areaId); static CSfxHandle SfxStart(u16 id, float vol, float pan, bool useAcoustics, s16 prio, bool looped, s32 areaId);
static void RemoveEmitter(const CSfxHandle& handle);
static void UpdateEmitter(const CSfxHandle& handle, const zeus::CVector3f& pos, const zeus::CVector3f& dir,
float maxVol);
static CSfxHandle AddEmitter(u16 id, const zeus::CVector3f& pos, const zeus::CVector3f& dir, float vol, static CSfxHandle AddEmitter(u16 id, const zeus::CVector3f& pos, const zeus::CVector3f& dir, float vol,
bool useAcoustics, bool looped, s16 prio, s32 areaId); bool useAcoustics, bool looped, s16 prio, s32 areaId);
static CSfxHandle AddEmitter(const CAudioSys::C3DEmitterParmData& parmData, static CSfxHandle AddEmitter(const CAudioSys::C3DEmitterParmData& parmData,

15
Runtime/CStateManager.cpp
View File

@ -507,11 +507,6 @@ bool CStateManager::CanCreateProjectile(TUniqueId uid, EWeaponType type, int tes
return ((xorv >> 1) - xorv & test) >> 31; return ((xorv >> 1) - xorv & test) >> 31;
} }
const std::vector<CLight>& CStateManager::GetDynamicLightList() const
{
return x8e0_dynamicLights;
}
void CStateManager::BuildDynamicLightListForWorld() void CStateManager::BuildDynamicLightListForWorld()
{ {
if (x8b8_playerState->GetActiveVisor(*this) == CPlayerState::EPlayerVisor::Thermal) if (x8b8_playerState->GetActiveVisor(*this) == CPlayerState::EPlayerVisor::Thermal)
@ -1975,7 +1970,7 @@ void CStateManager::UpdateHintState(float dt)
CHintOptions& ho = g_GameState->HintOptions(); CHintOptions& ho = g_GameState->HintOptions();
ho.Update(dt, *this); ho.Update(dt, *this);
u32 nextHintIdx = -1; u32 nextHintIdx = -1;
u32 hintPeriods = -1; u32 pageIdx = -1;
if (const CHintOptions::SHintState* state = ho.GetCurrentDisplayedHint()) if (const CHintOptions::SHintState* state = ho.GetCurrentDisplayedHint())
{ {
const CGameHintInfo::CGameHint& next = g_MemoryCardSys->GetHints()[ho.GetNextHintIdx()]; const CGameHintInfo::CGameHint& next = g_MemoryCardSys->GetHints()[ho.GetNextHintIdx()];
@ -1987,11 +1982,11 @@ void CStateManager::UpdateHintState(float dt)
if (state->x4_time < next.GetTextTime()) if (state->x4_time < next.GetTextTime())
{ {
nextHintIdx = ho.GetNextHintIdx(); nextHintIdx = ho.GetNextHintIdx();
hintPeriods = state->x4_time / 3.f; pageIdx = state->x4_time / 3.f;
} }
} }
if (xeec_hintIdx != nextHintIdx || xef0_hintPeriods != hintPeriods) if (xeec_hintIdx != nextHintIdx || xef0_hintPeriods != pageIdx)
{ {
if (nextHintIdx == -1) if (nextHintIdx == -1)
{ {
@ -2002,10 +1997,10 @@ void CStateManager::UpdateHintState(float dt)
{ {
const CGameHintInfo::CGameHint& data = g_MemoryCardSys->GetHints()[nextHintIdx]; const CGameHintInfo::CGameHint& data = g_MemoryCardSys->GetHints()[nextHintIdx];
CHUDMemoParms memoInfo = {0.f, true, false, true}; CHUDMemoParms memoInfo = {0.f, true, false, true};
MP1::CSamusHud::DeferHintMemo(data.GetStringID(), hintPeriods, memoInfo); MP1::CSamusHud::DeferHintMemo(data.GetStringID(), pageIdx, memoInfo);
} }
xeec_hintIdx = nextHintIdx; xeec_hintIdx = nextHintIdx;
xef0_hintPeriods = hintPeriods; xef0_hintPeriods = pageIdx;
} }
} }

2
Runtime/CStateManager.hpp
View File

@ -284,7 +284,7 @@ public:
static void ReflectionDrawer(void*, const zeus::CVector3f&); static void ReflectionDrawer(void*, const zeus::CVector3f&);
void CacheReflection(); void CacheReflection();
bool CanCreateProjectile(TUniqueId, EWeaponType, int) const; bool CanCreateProjectile(TUniqueId, EWeaponType, int) const;
const std::vector<CLight>& GetDynamicLightList() const; const std::vector<CLight>& GetDynamicLightList() const { return x8e0_dynamicLights; }
void BuildDynamicLightListForWorld(); void BuildDynamicLightListForWorld();
void DrawDebugStuff() const; void DrawDebugStuff() const;
void RenderCamerasAndAreaLights() const; void RenderCamerasAndAreaLights() const;

177
Runtime/Character/CActorLights.cpp
View File

@ -3,6 +3,12 @@
#include "World/CGameArea.hpp" #include "World/CGameArea.hpp"
#include "CStateManager.hpp" #include "CStateManager.hpp"
#include "Collision/CGameCollision.hpp" #include "Collision/CGameCollision.hpp"
#include "Camera/CFirstPersonCamera.hpp"
#include "World/CGameLight.hpp"
#include "TCastTo.hpp"
#include "GameGlobalObjects.hpp"
#include "World/CExplosion.hpp"
#include "Graphics/CBooRenderer.hpp"
namespace urde namespace urde
{ {
@ -50,11 +56,59 @@ void CActorLights::BuildConstantAmbientLighting(const zeus::CColor& color)
void CActorLights::BuildFakeLightList(const std::vector<CLight>& lights, const zeus::CColor& color) void CActorLights::BuildFakeLightList(const std::vector<CLight>& lights, const zeus::CColor& color)
{ {
BuildConstantAmbientLighting(color); BuildConstantAmbientLighting(color);
x0_areaLights.clear();
x144_dynamicLights = lights; x144_dynamicLights = lights;
} }
void CActorLights::BuildFaceLightList(CStateManager& mgr, const CGameArea& area, const zeus::CAABox& aabb) void CActorLights::BuildFaceLightList(const CStateManager& mgr, const CGameArea& area, const zeus::CAABox& aabb)
{ {
zeus::CTransform fpTransform = mgr.GetCameraManager()->GetFirstPersonCamera()->GetTransform();
x288_ambientColor = zeus::CColor::skBlack;
x144_dynamicLights.clear();
zeus::CColor accumColor = zeus::CColor::skBlack;
for (CEntity* light : mgr.GetLightObjectList())
{
if (!light || !light->GetActive())
continue;
CGameLight* castLight = static_cast<CGameLight*>(light);
if (TCastToConstPtr<CExplosion> explosion = mgr.GetObjectById(castLight->GetParentId()))
{
CLight originalLight = castLight->GetLight();
CLight explosionLight = originalLight;
explosionLight.SetAttenuation(explosionLight.GetAttenuationConstant() * g_tweakGui->GetExplosionLightFalloffMultConstant(),
explosionLight.GetAttenuationLinear() * g_tweakGui->GetExplosionLightFalloffMultLinear(),
explosionLight.GetAttenuationQuadratic() * g_tweakGui->GetExplosionLightFalloffMultQuadratic());
zeus::CVector3f camToExplo = explosion->GetTranslation() - fpTransform.origin;
if (fpTransform.transposeRotate(camToExplo).dot(zeus::CVector3f::skForward) >= 0.f)
{
camToExplo.y = -camToExplo.y + ITweakGui::FaceReflectionDistanceDebugValueToActualValue(
g_tweakGui->GetFaceReflectionDistance());
camToExplo.z = -camToExplo.z + ITweakGui::FaceReflectionHeightDebugValueToActualValue(
g_tweakGui->GetFaceReflectionHeight());
explosionLight.SetPosition(fpTransform * camToExplo);
zeus::CSphere sphere(originalLight.GetPosition(), originalLight.GetRadius());
if (aabb.intersects(sphere))
{
accumColor += explosionLight.GetNormalIndependentLightingAtPoint(fpTransform.origin);
if (originalLight.GetIntensity() > FLT_EPSILON && originalLight.GetRadius() > FLT_EPSILON)
x144_dynamicLights.push_back(explosionLight);
}
}
}
}
float greyscale = accumColor.rgbDot(zeus::CColor(0.3f, 0.6f, 0.1f));
if (greyscale < 0.012f)
x144_dynamicLights.clear();
if (greyscale > 0.03f)
{
float attMul = 1.f / (0.03f / greyscale);
for (CLight& light : x144_dynamicLights)
light.SetAttenuation(light.GetAttenuationConstant() * attMul,
light.GetAttenuationLinear() * attMul,
light.GetAttenuationQuadratic() * attMul);
}
} }
struct SLightValue struct SLightValue
@ -68,25 +122,73 @@ struct SLightValue
void CActorLights::MergeOverflowLight(CLight& out, zeus::CColor& color, const CLight& in, float colorMag) void CActorLights::MergeOverflowLight(CLight& out, zeus::CColor& color, const CLight& in, float colorMag)
{ {
color += in.GetColor() * colorMag;
out.SetAngleAttenuation(in.GetAngleAttenuationConstant() * colorMag + out.GetAngleAttenuationConstant(),
in.GetAngleAttenuationLinear() * colorMag + out.GetAngleAttenuationLinear(),
in.GetAngleAttenuationQuadratic() * colorMag + out.GetAngleAttenuationQuadratic());
out.SetAttenuation(in.GetAttenuationConstant() * colorMag + out.GetAttenuationConstant(),
in.GetAttenuationLinear() * colorMag + out.GetAttenuationLinear(),
in.GetAttenuationQuadratic() * colorMag + out.GetAttenuationQuadratic());
out.SetPosition(in.GetPosition() * colorMag + out.GetPosition());
out.SetDirection(in.GetDirection() * colorMag + out.GetDirection());
} }
void CActorLights::AddOverflowToLights(const CLight& light, const zeus::CColor& color, float mag) void CActorLights::AddOverflowToLights(const CLight& light, const zeus::CColor& color, float mag)
{ {
if (mag < 0.001f || x2b8_maxAreaLights < 1)
return;
mag = 1.f / mag;
zeus::CColor useColor = color * mag;
useColor.a = 1.f;
x0_areaLights.push_back(CLight::BuildCustom(light.GetPosition() * mag, light.GetDirection() * mag, useColor,
light.GetAttenuationConstant() * mag,
light.GetAttenuationLinear() * mag,
light.GetAttenuationQuadratic() * mag,
light.GetAngleAttenuationConstant() * mag,
light.GetAngleAttenuationLinear() * mag,
light.GetAngleAttenuationQuadratic() * mag));
} }
void CActorLights::MoveAmbienceToLights(const zeus::CColor& color) void CActorLights::MoveAmbienceToLights(const zeus::CColor& color)
{ {
if (x298_29_ambientChannelOverflow)
{
x288_ambientColor += color * 0.333333f;
x288_ambientColor.a = 1.f;
return;
}
zeus::CColor useColor = x0_areaLights[0].GetColor() + color;
float maxComponent = std::max(useColor.r, std::max(useColor.g, useColor.b));
if (maxComponent > FLT_EPSILON)
useColor *= (1.f / maxComponent);
useColor.a = 1.f;
x0_areaLights[0].SetColor(useColor);
} }
void CActorLights::MultiplyLightingLevels(float level) void CActorLights::MultiplyLightingLevels(float level)
{ {
x288_ambientColor *= level;
for (CLight& light : x0_areaLights)
{
zeus::CColor color = light.GetColor();
color *= level;
color.a = 1.f;
light.SetColor(color);
}
} }
bool CActorLights::BuildAreaLightList(CStateManager& mgr, const CGameArea& area, const zeus::CAABox& aabb) void CActorLights::UpdateBrightLight()
{
if (x2dc_brightLightLag > 0 && x299_24_inBrightLight)
--x2dc_brightLightLag;
else if (x2dc_brightLightLag < 15 && !x299_24_inBrightLight)
++x2dc_brightLightLag;
x299_25_useBrightLightLag = true;
}
bool CActorLights::BuildAreaLightList(const CStateManager& mgr, const CGameArea& area, const zeus::CAABox& aabb)
{ {
const std::vector<CWorldLight>& lightList = x298_30_layer2 ? area.GetPostConstructed()->x80_lightsB : const std::vector<CWorldLight>& lightList = x298_30_layer2 ? area.GetPostConstructed()->x80_lightsB :
area.GetPostConstructed()->x60_lightsA; area.GetPostConstructed()->x60_lightsA;
@ -294,10 +396,10 @@ bool CActorLights::BuildAreaLightList(CStateManager& mgr, const CGameArea& area,
x299_24_inBrightLight = actorToLightContact; x299_24_inBrightLight = actorToLightContact;
if (x2d8_brightLightIdx != value.x0_areaLightIdx) if (x2d8_brightLightIdx != value.x0_areaLightIdx)
{ {
x2dc_overrideDist = actorToLightContact ? 0 : 15; x2dc_brightLightLag = actorToLightContact ? 0 : 15;
x2d8_brightLightIdx = value.x0_areaLightIdx; x2d8_brightLightIdx = value.x0_areaLightIdx;
} }
x299_25_overrideFirstDist = false; x299_25_useBrightLightLag = false;
actorToLightContact = true; actorToLightContact = true;
} }
} }
@ -349,8 +451,56 @@ bool CActorLights::BuildAreaLightList(CStateManager& mgr, const CGameArea& area,
return true; return true;
} }
void CActorLights::BuildDynamicLightList(CStateManager& mgr, const zeus::CAABox& aabb) void CActorLights::BuildDynamicLightList(const CStateManager& mgr, const zeus::CAABox& aabb)
{ {
UpdateBrightLight();
x299_26_ = false;
x144_dynamicLights.clear();
if (!x29a_)
{
for (const CLight& light : mgr.GetDynamicLightList())
{
zeus::CSphere sphere(light.GetPosition(), light.GetRadius());
if (aabb.intersects(sphere))
x144_dynamicLights.push_back(light);
if (x144_dynamicLights.size() >= x2bc_maxDynamicLights)
break;
}
}
else
{
const CLight* addedLights[8] = {};
for (int i=0 ; i<x2bc_maxDynamicLights && i<8 ; ++i)
{
float minRad = FLT_MAX;
for (const CLight& light : mgr.GetDynamicLightList())
{
zeus::CSphere sphere(light.GetPosition(), light.GetRadius());
float intRadius = aabb.intersectionRadius(sphere);
if (intRadius >= 0.f && intRadius < minRad)
{
bool alreadyIn = false;
for (int j=0 ; j<i ; ++j)
{
if (&light == addedLights[j])
{
alreadyIn = true;
break;
}
}
if (alreadyIn)
continue;
addedLights[i] = &light;
minRad = intRadius;
}
}
if (addedLights[i])
x144_dynamicLights.push_back(*addedLights[i]);
if (x144_dynamicLights.size() >= x2bc_maxDynamicLights)
break;
}
}
} }
void CActorLights::ActivateLights(CBooModel& model) const void CActorLights::ActivateLights(CBooModel& model) const
@ -360,8 +510,9 @@ void CActorLights::ActivateLights(CBooModel& model) const
{ {
if (!x298_26_hasAreaLights || !x299_26_) if (!x298_26_hasAreaLights || !x299_26_)
{ {
g_Renderer->SetAmbientColor(zeus::CColor::skWhite);
model.ActivateLights(lights); model.ActivateLights(lights);
//return; return;
} }
} }
@ -369,10 +520,10 @@ void CActorLights::ActivateLights(CBooModel& model) const
if (x0_areaLights.size()) if (x0_areaLights.size())
{ {
if (x2dc_overrideDist && x299_25_overrideFirstDist) if (x2dc_brightLightLag && x299_25_useBrightLightLag)
{ {
CLight overrideLight = x0_areaLights[0]; CLight overrideLight = x0_areaLights[0];
overrideLight.SetColor(overrideLight.GetColor() * (1.f - x2dc_overrideDist / 15.f)); overrideLight.SetColor(overrideLight.GetColor() * (1.f - x2dc_brightLightLag / 15.f));
lights.push_back(overrideLight); lights.push_back(overrideLight);
} }
else else
@ -388,6 +539,12 @@ void CActorLights::ActivateLights(CBooModel& model) const
lights.push_back(light); lights.push_back(light);
model.ActivateLights(lights); model.ActivateLights(lights);
if (x298_31_disableWorldLights)
{
zeus::CColor color(x2d4_worldLightingLevel);
g_Renderer->SetWorldLightMultiplyColor(color);
}
} }
const CLight& CActorLights::GetLight(u32 idx) const const CLight& CActorLights::GetLight(u32 idx) const

14
Runtime/Character/CActorLights.hpp
View File

@ -34,7 +34,7 @@ class CActorLights
bool x298_30_layer2 : 1; bool x298_30_layer2 : 1;
bool x298_31_disableWorldLights : 1; bool x298_31_disableWorldLights : 1;
bool x299_24_inBrightLight : 1; bool x299_24_inBrightLight : 1;
bool x299_25_overrideFirstDist : 1; bool x299_25_useBrightLightLag : 1;
bool x299_26_ : 1; bool x299_26_ : 1;
}; };
u16 _dummy = 0; u16 _dummy = 0;
@ -52,12 +52,13 @@ class CActorLights
float x2d0_shadowDynamicRangeThreshold = 0.f; float x2d0_shadowDynamicRangeThreshold = 0.f;
float x2d4_worldLightingLevel = 1.f; float x2d4_worldLightingLevel = 1.f;
u32 x2d8_brightLightIdx = -1; u32 x2d8_brightLightIdx = -1;
u32 x2dc_overrideDist = 0; u32 x2dc_brightLightLag = 0;
static void MergeOverflowLight(CLight& out, zeus::CColor& color, const CLight& in, float colorMag); static void MergeOverflowLight(CLight& out, zeus::CColor& color, const CLight& in, float colorMag);
void AddOverflowToLights(const CLight& light, const zeus::CColor& color, float mag); void AddOverflowToLights(const CLight& light, const zeus::CColor& color, float mag);
void MoveAmbienceToLights(const zeus::CColor& color); void MoveAmbienceToLights(const zeus::CColor& color);
void MultiplyLightingLevels(float level); void MultiplyLightingLevels(float level);
void UpdateBrightLight();
public: public:
CActorLights(u32 areaUpdateFramePeriod, const zeus::CVector3f& actorPosBias, CActorLights(u32 areaUpdateFramePeriod, const zeus::CVector3f& actorPosBias,
@ -67,15 +68,18 @@ public:
void BuildConstantAmbientLighting(); void BuildConstantAmbientLighting();
void BuildConstantAmbientLighting(const zeus::CColor& color); void BuildConstantAmbientLighting(const zeus::CColor& color);
void BuildFakeLightList(const std::vector<CLight>& lights, const zeus::CColor& color); void BuildFakeLightList(const std::vector<CLight>& lights, const zeus::CColor& color);
void BuildFaceLightList(CStateManager& mgr, const CGameArea& area, const zeus::CAABox& aabb); void BuildFaceLightList(const CStateManager& mgr, const CGameArea& area, const zeus::CAABox& aabb);
bool BuildAreaLightList(CStateManager& mgr, const CGameArea& area, const zeus::CAABox& aabb); bool BuildAreaLightList(const CStateManager& mgr, const CGameArea& area, const zeus::CAABox& aabb);
void BuildDynamicLightList(CStateManager& mgr, const zeus::CAABox& aabb); void BuildDynamicLightList(const CStateManager& mgr, const zeus::CAABox& aabb);
void ActivateLights(CBooModel& model) const; void ActivateLights(CBooModel& model) const;
void SetCastShadows(bool v) { x298_25_castShadows = v; } void SetCastShadows(bool v) { x298_25_castShadows = v; }
void SetAmbientColor(const zeus::CColor& color) { x288_ambientColor = color; } void SetAmbientColor(const zeus::CColor& color) { x288_ambientColor = color; }
const zeus::CColor& GetAmbientColor() const { return x288_ambientColor; }
const CLight& GetLight(u32 idx) const; const CLight& GetLight(u32 idx) const;
u32 GetActiveLightCount() const; u32 GetActiveLightCount() const;
const std::vector<CLight>& GetAreaLights() const { return x0_areaLights; }
const std::vector<CLight>& GetDynamicLights() const { return x144_dynamicLights; }
}; };
} }

19
Runtime/Graphics/CBooRenderer.cpp
View File

@ -237,6 +237,7 @@ void CBooRenderer::RenderBucketItems(CAreaListItem* item)
} }
case EDrawableType::WorldSurface: case EDrawableType::WorldSurface:
{ {
SetupRendererStates();
CBooSurface* surf = static_cast<CBooSurface*>((void*)drawable->GetData()); CBooSurface* surf = static_cast<CBooSurface*>((void*)drawable->GetData());
CBooModel* model = surf->m_parent; CBooModel* model = surf->m_parent;
if (model) if (model)
@ -465,6 +466,12 @@ void CBooRenderer::RenderFogVolumeModel(const zeus::CAABox& aabb, const CModel*
} }
} }
void CBooRenderer::SetupRendererStates() const
{
CGraphics::SetModelMatrix(zeus::CTransform::Identity());
CGraphics::g_ColorRegs[1] = x2fc_tevReg1Color;
}
void CBooRenderer::ReallyRenderFogVolume(const zeus::CColor& color, const zeus::CAABox& aabb, void CBooRenderer::ReallyRenderFogVolume(const zeus::CColor& color, const zeus::CAABox& aabb,
const CModel* model, const CSkinnedModel* sModel) const CModel* model, const CSkinnedModel* sModel)
{ {
@ -708,6 +715,7 @@ void CBooRenderer::RemoveStaticGeometry(const std::vector<CMetroidModelInstance>
void CBooRenderer::DrawAreaGeometry(int areaIdx, int mask, int targetMask) void CBooRenderer::DrawAreaGeometry(int areaIdx, int mask, int targetMask)
{ {
x318_30_inAreaDraw = true; x318_30_inAreaDraw = true;
SetupRendererStates();
CModelFlags flags; CModelFlags flags;
for (CAreaListItem& item : x1c_areaListItems) for (CAreaListItem& item : x1c_areaListItems)
@ -745,7 +753,7 @@ void CBooRenderer::DrawAreaGeometry(int areaIdx, int mask, int targetMask)
void CBooRenderer::DrawUnsortedGeometry(int areaIdx, int mask, int targetMask) void CBooRenderer::DrawUnsortedGeometry(int areaIdx, int mask, int targetMask)
{ {
//SetupRendererStates(true); SetupRendererStates();
CAreaListItem* lastOctreeItem = nullptr; CAreaListItem* lastOctreeItem = nullptr;
@ -823,7 +831,7 @@ void CBooRenderer::DrawUnsortedGeometry(int areaIdx, int mask, int targetMask)
void CBooRenderer::DrawSortedGeometry(int areaIdx, int mask, int targetMask) void CBooRenderer::DrawSortedGeometry(int areaIdx, int mask, int targetMask)
{ {
//SetupRendererStates(true); SetupRendererStates();
CAreaListItem* lastOctreeItem = nullptr; CAreaListItem* lastOctreeItem = nullptr;
@ -1157,6 +1165,11 @@ void CBooRenderer::PrepareDynamicLights(const std::vector<CLight>& lights)
} }
} }
void CBooRenderer::SetWorldLightMultiplyColor(const zeus::CColor& color)
{
CGraphics::g_ColorRegs[1] = color;
}
void CBooRenderer::SetWorldLightFadeLevel(float level) void CBooRenderer::SetWorldLightFadeLevel(float level)
{ {
x2fc_tevReg1Color = zeus::CColor(level, level, level, 1.f); x2fc_tevReg1Color = zeus::CColor(level, level, level, 1.f);
@ -1210,6 +1223,8 @@ void CBooRenderer::FindOverlappingWorldModels(std::vector<u32>& modelBits, const
int CBooRenderer::DrawOverlappingWorldModelIDs(int alphaVal, const std::vector<u32>& modelBits, int CBooRenderer::DrawOverlappingWorldModelIDs(int alphaVal, const std::vector<u32>& modelBits,
const zeus::CAABox& aabb) const const zeus::CAABox& aabb) const
{ {
SetupRendererStates();
CModelFlags flags; CModelFlags flags;
flags.m_extendedShader = EExtendedShader::SolidColor; // Do solid color draw flags.m_extendedShader = EExtendedShader::SolidColor; // Do solid color draw

2
Runtime/Graphics/CBooRenderer.hpp
View File

@ -180,6 +180,7 @@ class CBooRenderer : public IRenderer
static void RenderFogVolumeModel(const zeus::CAABox& aabb, const CModel* model, const zeus::CTransform& modelMtx, static void RenderFogVolumeModel(const zeus::CAABox& aabb, const CModel* model, const zeus::CTransform& modelMtx,
const zeus::CTransform& viewMtx, const CSkinnedModel* sModel, int pass, const zeus::CTransform& viewMtx, const CSkinnedModel* sModel, int pass,
CFogVolumePlaneShader* fvs); CFogVolumePlaneShader* fvs);
void SetupRendererStates() const;
public: public:
CBooRenderer(IObjectStore& store, IFactory& resFac); CBooRenderer(IObjectStore& store, IFactory& resFac);
@ -245,6 +246,7 @@ public:
void DoThermalBlendHot(); void DoThermalBlendHot();
u32 GetStaticWorldDataSize(); u32 GetStaticWorldDataSize();
void PrepareDynamicLights(const std::vector<CLight>& lights); void PrepareDynamicLights(const std::vector<CLight>& lights);
void SetWorldLightMultiplyColor(const zeus::CColor& color);
void SetWorldLightFadeLevel(float level); void SetWorldLightFadeLevel(float level);
void ReallyRenderFogVolume(const zeus::CColor& color, const zeus::CAABox& aabb, void ReallyRenderFogVolume(const zeus::CColor& color, const zeus::CAABox& aabb,

1
Runtime/Graphics/CGraphics.cpp
View File

@ -10,6 +10,7 @@ namespace urde
CGraphics::CProjectionState CGraphics::g_Proj; CGraphics::CProjectionState CGraphics::g_Proj;
CGraphics::CFogState CGraphics::g_Fog; CGraphics::CFogState CGraphics::g_Fog;
zeus::CColor CGraphics::g_ColorRegs[3] = {};
float CGraphics::g_ProjAspect = 1.f; float CGraphics::g_ProjAspect = 1.f;
u32 CGraphics::g_NumLightsActive = 0; u32 CGraphics::g_NumLightsActive = 0;
u32 CGraphics::g_NumBreakpointsWaiting = 0; u32 CGraphics::g_NumBreakpointsWaiting = 0;

1
Runtime/Graphics/CGraphics.hpp
View File

@ -222,6 +222,7 @@ public:
static CProjectionState g_Proj; static CProjectionState g_Proj;
static zeus::CVector2f g_CachedDepthRange; static zeus::CVector2f g_CachedDepthRange;
static CFogState g_Fog; static CFogState g_Fog;
static zeus::CColor g_ColorRegs[3];
static float g_ProjAspect; static float g_ProjAspect;
static u32 g_NumLightsActive; static u32 g_NumLightsActive;
static u32 g_NumBreakpointsWaiting; static u32 g_NumBreakpointsWaiting;

6
Runtime/Graphics/CLight.hpp
View File

@ -92,6 +92,9 @@ public:
x4c_24_intensityDirty = true; x4c_24_intensityDirty = true;
x4c_25_radiusDirty = true; x4c_25_radiusDirty = true;
} }
float GetAttenuationConstant() const { return x24_distC; }
float GetAttenuationLinear() const { return x28_distL; }
float GetAttenuationQuadratic() const { return x2c_distQ; }
void SetAngleAttenuation(float constant, float linear, float quadratic) void SetAngleAttenuation(float constant, float linear, float quadratic)
{ {
@ -101,6 +104,9 @@ public:
x4c_24_intensityDirty = true; x4c_24_intensityDirty = true;
x4c_25_radiusDirty = true; x4c_25_radiusDirty = true;
} }
float GetAngleAttenuationConstant() const { return x30_angleC; }
float GetAngleAttenuationLinear() const { return x34_angleL; }
float GetAngleAttenuationQuadratic() const { return x38_angleQ; }
float GetRadius() const float GetRadius() const
{ {

1
Runtime/Graphics/CModel.hpp
View File

@ -29,7 +29,6 @@ struct CModelFlags
u16 x2_flags = 0; /* Flags */ u16 x2_flags = 0; /* Flags */
zeus::CColor x4_color; /* Set into kcolor slot specified by material */ zeus::CColor x4_color; /* Set into kcolor slot specified by material */
zeus::CColor addColor = zeus::CColor::skClear; zeus::CColor addColor = zeus::CColor::skClear;
zeus::CColor regColors[3];
zeus::CAABox mbShadowBox; zeus::CAABox mbShadowBox;
CModelFlags() = default; CModelFlags() = default;

6
Runtime/Graphics/CModelBoo.cpp
View File

@ -807,9 +807,9 @@ void CBooModel::UpdateUniformData(const CModelFlags& flags,
{ {
CModelShaders::LightingUniform& lightingOut = *reinterpret_cast<CModelShaders::LightingUniform*>(dataCur); CModelShaders::LightingUniform& lightingOut = *reinterpret_cast<CModelShaders::LightingUniform*>(dataCur);
lightingOut = m_lightingData; lightingOut = m_lightingData;
lightingOut.colorRegs[0] = flags.regColors[0]; lightingOut.colorRegs[0] = CGraphics::g_ColorRegs[0];
lightingOut.colorRegs[1] = flags.regColors[1]; lightingOut.colorRegs[1] = CGraphics::g_ColorRegs[1];
lightingOut.colorRegs[2] = flags.regColors[2]; lightingOut.colorRegs[2] = CGraphics::g_ColorRegs[2];
lightingOut.mulColor = flags.x4_color; lightingOut.mulColor = flags.x4_color;
lightingOut.fog = CGraphics::g_Fog; lightingOut.fog = CGraphics::g_Fog;
} }

1
Runtime/Graphics/IRenderer.hpp
View File

@ -101,6 +101,7 @@ public:
virtual void DoThermalBlendHot()=0; virtual void DoThermalBlendHot()=0;
virtual u32 GetStaticWorldDataSize()=0; virtual u32 GetStaticWorldDataSize()=0;
virtual void PrepareDynamicLights(const std::vector<CLight>& lights)=0; virtual void PrepareDynamicLights(const std::vector<CLight>& lights)=0;
virtual void SetWorldLightMultiplyColor(const zeus::CColor& color)=0;
virtual void SetWorldLightFadeLevel(float level)=0; virtual void SetWorldLightFadeLevel(float level)=0;
}; };

37
Runtime/GuiSys/CGuiFrame.cpp
View File

@ -8,6 +8,7 @@
#include "Input/CFinalInput.hpp" #include "Input/CFinalInput.hpp"
#include "zeus/CColor.hpp" #include "zeus/CColor.hpp"
#include "CSimplePool.hpp" #include "CSimplePool.hpp"
#include "Graphics/CModel.hpp"
namespace urde namespace urde
{ {
@ -51,15 +52,18 @@ void CGuiFrame::SortDrawOrder()
}); });
} }
void CGuiFrame::EnableLights(u32 lights) const void CGuiFrame::EnableLights(u32 lights, CBooModel& model) const
{ {
std::vector<CLight> lightsOut;
lightsOut.reserve(m_indexedLights.size() + 1);
CGraphics::DisableAllLights(); CGraphics::DisableAllLights();
zeus::CColor accumColor(zeus::CColor::skBlack);
zeus::CColor ambColor(zeus::CColor::skBlack);
ERglLight lightId = ERglLight::Zero; ERglLight lightId = ERglLight::Zero;
int idx = 0; int idx = 0;
for (auto& light : m_indexedLights) for (CGuiLight* light : m_indexedLights)
{ {
if (!light) if (!light || !light->GetIsVisible())
{ {
++reinterpret_cast<std::underlying_type_t<ERglLight>&>(lightId); ++reinterpret_cast<std::underlying_type_t<ERglLight>&>(lightId);
++idx; ++idx;
@ -67,18 +71,31 @@ void CGuiFrame::EnableLights(u32 lights) const
} }
if ((lights & (1 << idx)) != 0) if ((lights & (1 << idx)) != 0)
{ {
// accumulate color const zeus::CColor& geomCol = light->GetGeometryColor();
accumColor += light->GetColor(); if (geomCol.r || geomCol.g || geomCol.b)
CGraphics::LoadLight(lightId, light->BuildLight()); {
CGraphics::EnableLight(lightId); //CGraphics::LoadLight(lightId, light->BuildLight());
lightsOut.push_back(light->BuildLight());
CGraphics::EnableLight(lightId);
}
// accumulate ambient color
ambColor += light->GetAmbientLightColor();
} }
++reinterpret_cast<std::underlying_type_t<ERglLight>&>(lightId); ++reinterpret_cast<std::underlying_type_t<ERglLight>&>(lightId);
++idx; ++idx;
} }
if (m_indexedLights.empty()) if (m_indexedLights.empty())
CGraphics::SetAmbientColor(zeus::CColor::skWhite); {
//CGraphics::SetAmbientColor(zeus::CColor::skWhite);
lightsOut.push_back(CLight::BuildLocalAmbient(zeus::CVector3f::skZero, zeus::CColor::skWhite));
}
else else
CGraphics::SetAmbientColor(accumColor); {
//CGraphics::SetAmbientColor(ambColor);
lightsOut.push_back(CLight::BuildLocalAmbient(zeus::CVector3f::skZero, ambColor));
}
model.ActivateLights(lightsOut);
} }
void CGuiFrame::DisableLights() const void CGuiFrame::DisableLights() const

3
Runtime/GuiSys/CGuiFrame.hpp
View File

@ -17,6 +17,7 @@ class CGuiLight;
class CVParamTransfer; class CVParamTransfer;
class CObjectReference; class CObjectReference;
class CSimplePool; class CSimplePool;
class CBooModel;
class CGuiFrame class CGuiFrame
{ {
@ -54,7 +55,7 @@ public:
void SetHeadWidget(std::shared_ptr<CGuiHeadWidget>&& hwig) { xc_headWidget = std::move(hwig); } void SetHeadWidget(std::shared_ptr<CGuiHeadWidget>&& hwig) { xc_headWidget = std::move(hwig); }
CGuiHeadWidget* GetHeadWidget() const { return xc_headWidget.get(); } CGuiHeadWidget* GetHeadWidget() const { return xc_headWidget.get(); }
void SortDrawOrder(); void SortDrawOrder();
void EnableLights(u32 lights) const; void EnableLights(u32 lights, CBooModel& model) const;
void DisableLights() const; void DisableLights() const;
void RemoveLight(CGuiLight* light); void RemoveLight(CGuiLight* light);
void AddLight(CGuiLight* light); void AddLight(CGuiLight* light);

6
Runtime/GuiSys/CGuiLight.hpp
View File

@ -19,7 +19,7 @@ class CGuiLight : public CGuiWidget
float xd0_angleL; float xd0_angleL;
float xd4_angleQ; float xd4_angleQ;
u32 xd8_loadedIdx; u32 xd8_loadedIdx;
zeus::CColor xdc_color = zeus::CColor::skBlack; zeus::CColor xdc_ambColor = zeus::CColor::skBlack;
public: public:
~CGuiLight(); ~CGuiLight();
CGuiLight(const CGuiWidgetParms& parms, const CLight& light); CGuiLight(const CGuiWidgetParms& parms, const CLight& light);
@ -28,7 +28,7 @@ public:
CLight BuildLight() const; CLight BuildLight() const;
void SetIsVisible(bool vis); void SetIsVisible(bool vis);
u32 GetLoadedIdx() const {return xd8_loadedIdx;} u32 GetLoadedIdx() const {return xd8_loadedIdx;}
const zeus::CColor& GetColor() const {return xdc_color;} const zeus::CColor& GetAmbientLightColor() const {return xdc_ambColor;}
void SetSpotCutoff(float v) {xbc_spotCutoff = v;} void SetSpotCutoff(float v) {xbc_spotCutoff = v;}
void SetDistC(float v) {xc0_distC = v;} void SetDistC(float v) {xc0_distC = v;}
void SetDistL(float v) {xc4_distL = v;} void SetDistL(float v) {xc4_distL = v;}
@ -37,7 +37,7 @@ public:
void SetAngleL(float v) {xd0_angleL = v;} void SetAngleL(float v) {xd0_angleL = v;}
void SetAngleQ(float v) {xd4_angleQ = v;} void SetAngleQ(float v) {xd4_angleQ = v;}
void SetLoadedIdx(u32 idx) {xd8_loadedIdx = idx;} void SetLoadedIdx(u32 idx) {xd8_loadedIdx = idx;}
void SetColor(const zeus::CColor& color) {xdc_color = color;} void SetAmbientLightColor(const zeus::CColor& color) {xdc_ambColor = color;}
static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp); static std::shared_ptr<CGuiWidget> Create(CGuiFrame* frame, CInputStream& in, CSimplePool* sp);

2
Runtime/GuiSys/CGuiModel.cpp
View File

@ -56,7 +56,7 @@ void CGuiModel::Draw(const CGuiWidgetDrawParms& parms) const
{ {
zeus::CColor moduCol = xa8_color2; zeus::CColor moduCol = xa8_color2;
moduCol.a *= parms.x0_alphaMod; moduCol.a *= parms.x0_alphaMod;
xb0_frame->EnableLights(x10c_lightMask); xb0_frame->EnableLights(x10c_lightMask, const_cast<CBooModel&>(model->GetInstance()));
if (xb6_29_cullFaces) if (xb6_29_cullFaces)
CGraphics::SetCullMode(ERglCullMode::Front); CGraphics::SetCullMode(ERglCullMode::Front);

2
Runtime/GuiSys/CGuiTextSupport.hpp
View File

@ -138,6 +138,8 @@ public:
void SetImageBaseline(bool b); void SetImageBaseline(bool b);
bool GetIsTextSupportFinishedLoading() const; bool GetIsTextSupportFinishedLoading() const;
float GetCurTime() const { return x3c_curTime; } float GetCurTime() const { return x3c_curTime; }
void SetCurTime(float t) { x3c_curTime = t; }
const std::u16string& GetString() const { return x0_string; }
void SetScanStates(const std::vector<CSaveWorld::SScanState>* scanStates); void SetScanStates(const std::vector<CSaveWorld::SScanState>* scanStates);
}; };

1
Runtime/GuiSys/CGuiWidget.hpp
View File

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

425
Runtime/MP1/CSamusHud.cpp
View File

@ -10,6 +10,7 @@
#include "GuiSys/CGuiCamera.hpp" #include "GuiSys/CGuiCamera.hpp"
#include "Camera/CFirstPersonCamera.hpp" #include "Camera/CFirstPersonCamera.hpp"
#include "TCastTo.hpp" #include "TCastTo.hpp"
#include "World/CGameLight.hpp"
namespace urde namespace urde
{ {
@ -323,7 +324,7 @@ void CSamusHud::InitializeDamageLight()
lightColor.g *= lightColor.a; lightColor.g *= lightColor.a;
lightColor.b *= lightColor.a; lightColor.b *= lightColor.a;
lightColor.a = 1.f; lightColor.a = 1.f;
x3d4_damageLight->SetColor(lightColor); x3d4_damageLight->SetAmbientLightColor(lightColor);
x3d4_damageLight->SetDistC(1.f); x3d4_damageLight->SetDistC(1.f);
x3d4_damageLight->SetDistL(0.f); x3d4_damageLight->SetDistL(0.f);
@ -734,8 +735,8 @@ void CSamusHud::UpdateHudLag(float dt, const CStateManager& mgr)
zeus::CVector3f bobTranslation = player.GetCameraBob()->GetHelmetBobTranslation(); zeus::CVector3f bobTranslation = player.GetCameraBob()->GetHelmetBobTranslation();
zeus::CQuaternion lagRot = x44c_ * x31c_hudLag; zeus::CQuaternion lagRot = x44c_hudLagShakeRot * x31c_hudLag;
zeus::CVector3f lagOff = x41c_ * g_tweakGui->GetHudLagOffsetScale(); zeus::CVector3f lagOff = x41c_decoShakeTranslate * g_tweakGui->GetHudLagOffsetScale();
lagOff.z += bobTranslation.z; lagOff.z += bobTranslation.z;
if (x2a0_helmetIntf) if (x2a0_helmetIntf)
{ {
@ -755,21 +756,316 @@ void CSamusHud::UpdateHudLag(float dt, const CStateManager& mgr)
} }
} }
bool CSamusHud::IsCachedLightInAreaLights(const SCachedHudLight& light, const CActorLights& areaLights) const
{
for (const CLight& l : areaLights.GetAreaLights())
{
if (l.GetColor() != light.xc_color || l.GetPosition() != light.x0_pos)
continue;
return true;
}
return false;
}
bool CSamusHud::IsAreaLightInCachedLights(const CLight& light) const
{
for (const SCachedHudLight& l : x340_hudLights)
{
if (l.x1c_fader == 0.f)
continue;
if (l.xc_color != light.GetColor() || l.x0_pos != light.GetPosition())
continue;
return true;
}
return false;
}
int CSamusHud::FindEmptyHudLightSlot(const CLight& light) const
{
for (int i=0 ; i<3 ; ++i)
if (x340_hudLights[i].x1c_fader == 0.f)
return i;
return -1;
}
zeus::CColor CSamusHud::GetVisorHudLightColor(const zeus::CColor& color, const CStateManager& mgr) const
{
zeus::CColor ret = color;
const CPlayerState& playerState = *mgr.GetPlayerState();
float t = playerState.GetVisorTransitionFactor();
switch (playerState.GetCurrentVisor())
{
case CPlayerState::EPlayerVisor::Scan:
ret *= zeus::CColor::lerp(zeus::CColor::skWhite, g_tweakGuiColors->GetScanVisorHudLightMultiply(), t);
break;
case CPlayerState::EPlayerVisor::Thermal:
ret *= g_tweakGuiColors->GetThermalVisorHudLightMultiply();
break;
case CPlayerState::EPlayerVisor::XRay:
ret = zeus::CColor(zeus::CColor(0.3f, 0.6f, 0.1f).rgbDot(ret));
break;
default: break;
}
return ret;
}
void CSamusHud::UpdateHudDynamicLights(float dt, const CStateManager& mgr) void CSamusHud::UpdateHudDynamicLights(float dt, const CStateManager& mgr)
{ {
if (TCastToConstPtr<CFirstPersonCamera> fpCam = mgr.GetCameraManager()->GetCurrentCamera(mgr)) if (TCastToConstPtr<CFirstPersonCamera> fpCam = mgr.GetCameraManager()->GetCurrentCamera(mgr))
{ {
zeus::CVector3f lookDir = fpCam->GetTransform().basis[1];
zeus::CAABox camAABB(fpCam->GetTranslation() - 0.125f, fpCam->GetTranslation() + 0.125f); zeus::CAABox camAABB(fpCam->GetTranslation() - 0.125f, fpCam->GetTranslation() + 0.125f);
if (mgr.GetPlayer().GetAreaIdAlways() == kInvalidAreaId) TAreaId playerArea = mgr.GetPlayer().GetAreaIdAlways();
if (playerArea == kInvalidAreaId)
return; return;
//x33c_lights-> x33c_lights->BuildAreaLightList(mgr, *mgr.GetWorld()->GetAreaAlways(playerArea), camAABB);
for (SCachedHudLight& light : x340_hudLights)
if ((light.x0_pos - fpCam->GetTranslation()).normalized().dot(lookDir) > 0.15707964f)
if (!IsCachedLightInAreaLights(light, *x33c_lights))
light.x1c_fader *= -1.f;
int negCount = 0;
for (SCachedHudLight& light : x340_hudLights)
if (light.x1c_fader <= 0.f)
++negCount;
--negCount;
for (const CLight& light : x33c_lights->GetAreaLights())
{
if (IsAreaLightInCachedLights(light))
continue;
if ((light.GetPosition() - fpCam->GetTranslation()).normalized().dot(lookDir) > 0.15707964f)
{
int slot = FindEmptyHudLightSlot(light);
if (slot == -1)
continue;
SCachedHudLight& cachedLight = x340_hudLights[slot];
cachedLight.x0_pos = light.GetPosition();
cachedLight.xc_color = light.GetColor();
cachedLight.x10_distC = light.GetAttenuationConstant();
cachedLight.x14_distL = light.GetAttenuationLinear();
cachedLight.x18_distQ = light.GetAttenuationQuadratic();
cachedLight.x1c_fader = 0.001f;
}
}
float dt2 = 2.f * dt;
for (SCachedHudLight& light : x340_hudLights)
{
if (light.x1c_fader < 0.f)
light.x1c_fader = std::max(0.f, light.x1c_fader + dt2);
else if (light.x1c_fader < 1.f && light.x1c_fader != 0)
light.x1c_fader = std::min(light.x1c_fader + dt2, 1.f);
}
CPlayerState& playerState = *mgr.GetPlayerState();
CPlayerState::EPlayerVisor visor = playerState.GetCurrentVisor();
float visorT = playerState.GetVisorTransitionFactor();
zeus::CColor lightAdd =
zeus::CColor::lerp(g_tweakGui->GetVisorHudLightAdd(0),
g_tweakGui->GetVisorHudLightAdd(int(visor)),
visorT);
zeus::CColor lightMul =
zeus::CColor::lerp(g_tweakGui->GetVisorHudLightMultiply(0),
g_tweakGui->GetVisorHudLightMultiply(int(visor)),
visorT);
auto lightIt = x5d8_guiLights.begin();
float maxIntensity = 0.f;
int maxIntensityIdx = 0;
for (int i=0 ; i<3 ; ++i)
{
SCachedHudLight& light = x340_hudLights[i];
CGuiLight* lightWidget = *lightIt;
zeus::CVector3f lightToCam = fpCam->GetTranslation() - light.x0_pos;
zeus::CVector3f lightNormal = fpCam->GetTransform().buildMatrix3f() * lightToCam.normalized();
float dist = std::max(lightToCam.magnitude(), FLT_EPSILON);
float falloffMul = 1.f /
(dist * dist * light.x18_distQ * g_tweakGui->GetHudLightAttMulQuadratic() +
dist * light.x14_distL * g_tweakGui->GetHudLightAttMulLinear() +
light.x10_distC * g_tweakGui->GetHudLightAttMulConstant());
falloffMul = std::min(falloffMul, 1.f);
lightWidget->SetO2WTransform(zeus::lookAt(zeus::CVector3f::skZero, lightNormal));
float fadedFalloff = falloffMul * std::fabs(light.x1c_fader);
zeus::CColor lightColor = GetVisorHudLightColor(light.xc_color * zeus::CColor(fadedFalloff), mgr);
lightWidget->SetColor(lightColor);
lightAdd += lightColor * lightMul;
float greyscale = fadedFalloff * zeus::CVector3f::skForward.dot(-lightNormal) *
lightAdd.rgbDot(zeus::CColor(0.3f, 0.6f, 0.1f));
if (greyscale > maxIntensity)
{
maxIntensity = greyscale;
maxIntensityIdx = i;
}
}
CLight brightestGameLight = CLight::BuildPoint(zeus::CVector3f::skZero, zeus::CColor::skBlack);
for (CEntity* ent : mgr.GetLightObjectList())
{
if (!ent || !ent->GetActive())
continue;
CGameLight& gameLight = static_cast<CGameLight&>(*ent);
if (TCastToConstPtr<CGameProjectile>(mgr.GetObjectById(gameLight.GetParentId())))
continue;
CLight thisLight = gameLight.GetLight();
if (thisLight.GetIntensity() > brightestGameLight.GetIntensity())
{
zeus::CSphere sphere(thisLight.GetPosition(), thisLight.GetRadius());
if (camAABB.intersects(sphere))
brightestGameLight = thisLight;
}
}
if (brightestGameLight.GetIntensity() > FLT_EPSILON)
{
zeus::CVector3f lightToCam = fpCam->GetTranslation() - brightestGameLight.GetPosition();
float dist = std::max(lightToCam.magnitude(), FLT_EPSILON);
float falloffMul = 1.f /
(dist * dist * brightestGameLight.GetAttenuationQuadratic() * g_tweakGui->GetHudLightAttMulQuadratic() +
dist * brightestGameLight.GetAttenuationLinear() * g_tweakGui->GetHudLightAttMulLinear() +
brightestGameLight.GetAttenuationConstant() * g_tweakGui->GetHudLightAttMulConstant());
falloffMul = std::min(falloffMul, 1.f);
zeus::CColor falloffColor = brightestGameLight.GetColor() * zeus::CColor(falloffMul);
falloffColor = GetVisorHudLightColor(falloffColor, mgr);
if (brightestGameLight.GetType() == ELightType::Spot)
{
float quarterCicleFactor = zeus::clamp(0.f, std::asin(std::max(0.f, fpCam->GetTransform().basis[1].
dot(brightestGameLight.GetDirection()))) * (M_PIF / 2.f), 1.f);
falloffColor *= zeus::CColor(quarterCicleFactor);
}
lightAdd += falloffColor;
}
const CGuiLight& brightestLight = *x5d8_guiLights[maxIntensityIdx];
lightAdd += x33c_lights->GetAmbientColor() * zeus::CColor(0.25f, 1.f);
zeus::CVector3f revDir = -brightestLight.GetWorldTransform().basis[1];
float foreDot = revDir.dot(zeus::CVector3f::skForward);
x5d8_guiLights[3]->SetO2WTransform(
zeus::lookAt(zeus::CVector3f::skZero, zeus::CVector3f::skForward * 2.f * foreDot - revDir));
x5d8_guiLights[3]->SetColor(g_tweakGui->GetHudReflectivityLightColor() * brightestLight.GetIntermediateColor());
x5d8_guiLights[3]->SetAmbientLightColor(lightAdd);
} }
} }
void CSamusHud::UpdateHudDamage(float dt, const CStateManager& mgr, void CSamusHud::UpdateHudDamage(float dt, const CStateManager& mgr,
DataSpec::ITweakGui::EHelmetVisMode helmetVis) DataSpec::ITweakGui::EHelmetVisMode helmetVis)
{ {
CPlayer& player = mgr.GetPlayer();
if (player.WasDamaged() && mgr.GetGameState() == CStateManager::EGameState::Running)
x3e8_damageTIme += dt;
else
x3e8_damageTIme = 0.f;
float pulseDur = g_tweakGui->GetHudDamagePulseDuration();
float pulseTime = std::fabs(std::fmod(x3e8_damageTIme, pulseDur));
if (pulseTime < 0.5f * pulseDur)
x3ec_damageLightPulser = pulseTime / (0.5f * pulseDur);
else
x3ec_damageLightPulser = (pulseDur - pulseTime) / (0.5f * pulseDur);
x3ec_damageLightPulser = zeus::clamp(0.f, g_tweakGui->GetHudDamageColorGain() * x3ec_damageLightPulser * std::min(0.5f, player.GetDamageAmount()), 1.f);
zeus::CColor damageAmbColor = g_tweakGuiColors->GetHudFrameColor();
damageAmbColor.r *= damageAmbColor.a;
damageAmbColor.g *= damageAmbColor.a;
damageAmbColor.b *= damageAmbColor.a;
damageAmbColor += zeus::CColor(x3ec_damageLightPulser);
damageAmbColor.a = 1.f;
if (x3d4_damageLight)
x3d4_damageLight->SetAmbientLightColor(damageAmbColor);
if (x3f4_damageFilterAmt > 0.f)
{
x3f4_damageFilterAmt = std::max(0.f, x3f4_damageFilterAmt - dt);
if (x3f4_damageFilterAmt == 0.f)
{
CSfxManager::RemoveEmitter(x3a4_damageSfx);
x3a4_damageSfx.reset();
}
}
float tmp = x3f0_damageFilterAmtInit * g_tweakGui->GetHudDamagePeakFactor();
float colorGain;
if (x3f4_damageFilterAmt > tmp)
colorGain = (x3f0_damageFilterAmtInit - x3f4_damageFilterAmt) / (x3f0_damageFilterAmtInit - tmp);
else
colorGain = x3f4_damageFilterAmt / tmp;
colorGain = zeus::clamp(0.f, colorGain * x3f8_damageFilterAmtGain, 1.f);
zeus::CColor color0 = g_tweakGuiColors->GetDamageAmbientColor();
color0.a *= colorGain;
zeus::CColor color1 = g_tweakGuiColors->GetDamageAmbientPulseColor();
color1.a *= x3ec_damageLightPulser;
zeus::CColor color2 = color0 + color1;
if (color2.a)
{
if (player.GetMorphballTransitionState() != CPlayer::EPlayerMorphBallState::Unmorphed)
color2.a *= 0.75f;
x3a8_camFilter.SetFilter(CCameraFilterPass::EFilterType::Add, CCameraFilterPass::EFilterShape::Fullscreen,
0.f, color2, -1);
}
else
{
x3a8_camFilter.DisableFilter(0.f);
}
if (x3a4_damageSfx)
CSfxManager::UpdateEmitter(x3a4_damageSfx, player.GetTranslation(), player.GetTransform().basis[1], 1.f);
if (x400_hudDamagePracticals > 0.f)
{
x400_hudDamagePracticals = std::max(0.f, x400_hudDamagePracticals - dt);
float practicals = x400_hudDamagePracticals / x3fc_hudDamagePracticalsInit;
if (x28c_energyIntf)
x28c_energyIntf->SetFlashMagnitude(practicals);
practicals = std::min(practicals * x404_hudDamagePracticalsGain, 1.f);
x2a0_helmetIntf->AddHelmetLightValue(practicals);
if (x29c_decoIntf)
x29c_decoIntf->SetFrameColorValue(practicals);
if (practicals > 0.f)
{
x3d4_damageLight->SetColor(g_tweakGuiColors->GetHudDamageLightColor() * zeus::CColor(practicals));
x3d4_damageLight->SetIsVisible(true);
}
else
{
x3d4_damageLight->SetIsVisible(false);
}
}
bool transformUpdate = false;
if (x414_decoShakeTranslateAmt > 0.f)
{
x418_decoShakeTranslateAmtVel -= g_tweakGui->GetDecoDamageShakeDeceleration() * 60.f * dt;
x414_decoShakeTranslateAmt = std::max(0.f, x414_decoShakeTranslateAmt + x418_decoShakeTranslateAmtVel);
transformUpdate = true;
}
if (x460_decoShakeAmt > 0.f)
{
x460_decoShakeAmt = std::max(0.f, x460_decoShakeAmt - dt);
x44c_hudLagShakeRot = zeus::CQuaternion::skNoRotation;
float rotMul = std::min(g_tweakGui->GetMaxDecoDamageShakeRotate(),
x460_decoShakeAmt / x45c_decoShakeAmtInit * x464_decoShakeAmtGain);
float rotAng = rotMul * (2.f * M_PIF / 10.f);
x44c_hudLagShakeRot.rotateX(rand() / float(RAND_MAX) * rotAng);
x44c_hudLagShakeRot.rotateZ(rand() / float(RAND_MAX) * rotAng);
zeus::CVector3f vecs[] = {zeus::CVector3f::skRight,
zeus::CVector3f::skForward,
zeus::CVector3f::skUp};
for (int i=0 ; i<4 ; ++i)
vecs[int(rand() / float(RAND_MAX) * 4.f) & 0x3] += (rand() / float(RAND_MAX) - dt) * rotMul;
x428_decoShakeRotate = zeus::CMatrix3f(vecs[0], vecs[1], vecs[2]).transposed();
transformUpdate = true;
}
if (transformUpdate)
{
x41c_decoShakeTranslate = x408_damagerToPlayerNorm * std::min(g_tweakGui->GetMaxDecoDamageShakeTranslate(),
x414_decoShakeTranslateAmt);
if (x29c_decoIntf)
x29c_decoIntf->SetDamageTransform(x428_decoShakeRotate, x41c_decoShakeTranslate *
g_tweakGui->GetHudDecoShakeTranslateGain());
}
} }
void CSamusHud::UpdateStaticSfx(CSfxHandle& handle, float& cycleTimer, u16 sfxId, float dt, void CSamusHud::UpdateStaticSfx(CSfxHandle& handle, float& cycleTimer, u16 sfxId, float dt,
@ -825,10 +1121,76 @@ void CSamusHud::UpdateStaticInterference(float dt, const CStateManager& mgr)
} }
} }
int CSamusHud::GetRelativeDirection(const zeus::CVector3f& position, const CStateManager& mgr)
{
TCastToConstPtr<CFirstPersonCamera> fpCam = mgr.GetCameraManager()->GetCurrentCamera(mgr);
if (!fpCam)
return 0;
zeus::CVector3f camToPosLocal = fpCam->GetTransform().transposeRotate(position - fpCam->GetTranslation());
if (camToPosLocal == position)
return 0;
float y = std::cos(2.f * M_PIF * 0.0027777778f * 0.5f * fpCam->GetFov());
float x = std::cos(2.f * M_PIF * 0.0027777778f * 0.5f * fpCam->GetFov() * fpCam->GetAspectRatio());
zeus::CVector2f camToPosXY = zeus::CVector2f(camToPosLocal.x, camToPosLocal.y).normalized();
zeus::CVector2f camToPosYZ = zeus::CVector2f(camToPosLocal.y, camToPosLocal.z).normalized();
if (camToPosXY.dot(zeus::CVector2f(0.f, 1.f)) > x && camToPosYZ.dot(zeus::CVector2f(1.f, 0.f)) > y)
return 0;
if (camToPosXY.dot(zeus::CVector2f(0.f, -1.f)) > x && camToPosYZ.dot(zeus::CVector2f(-1.f, 0.f)) > y)
return 1;
zeus::CVector3f camToPosNorm = camToPosLocal.normalized();
zeus::CQuaternion quat;
quat.rotateY(2.f * M_PIF / 8.f);
zeus::CVector3f vec = zeus::CVector3f::skUp;
float maxDot = -1.f;
int ret = -1;
for (int i=0 ; i<8 ; ++i)
{
float dot = camToPosNorm.dot(vec);
if (dot > maxDot)
{
maxDot = dot;
ret = i + 2;
}
vec = quat.transform(vec);
}
return ret;
}
void CSamusHud::ShowDamage(const zeus::CVector3f& position, float dam, float prevDam, void CSamusHud::ShowDamage(const zeus::CVector3f& position, float dam, float prevDam,
const CStateManager& mgr) const CStateManager& mgr)
{ {
CPlayer& player = mgr.GetPlayer();
int dir = GetRelativeDirection(position, mgr);
TCastToConstPtr<CFirstPersonCamera> fpCam = mgr.GetCameraManager()->GetCurrentCamera(mgr);
x404_hudDamagePracticalsGain = g_tweakGui->GetHudDamagePracticalsGainLinear() * dam +
g_tweakGui->GetHudDamagePracticalsGainConstant();
x3fc_hudDamagePracticalsInit = std::max(FLT_EPSILON, g_tweakGui->GetHudDamagePracticalsInitLinear() * dam +
g_tweakGui->GetHudDamagePracticalsInitConstant());
x400_hudDamagePracticals = x3fc_hudDamagePracticalsInit;
if (x3d4_damageLight)
x3d4_damageLight->SetLocalTransform(x3d8_lightTransforms[dir]);
x3f8_damageFilterAmtGain = g_tweakGui->GetHudDamageFilterGainLinear() * dam +
g_tweakGui->GetHudDamageFilterGainConstant();
x3f0_damageFilterAmtInit = g_tweakGui->GetHudDamageFilterInitLinear() * dam +
g_tweakGui->GetHudDamageFilterInitConstant();
x3f4_damageFilterAmt = x3f0_damageFilterAmtInit;
if (!x3a4_damageSfx)
{
x3a4_damageSfx = CSfxManager::AddEmitter(1385, player.GetTranslation(), player.GetTransform().basis[1],
0.f, false, true, 0xff, kInvalidAreaId);
}
if (fpCam)
{
x418_decoShakeTranslateAmtVel = g_tweakGui->GetHudDecoShakeTranslateVelLinear() * prevDam +
g_tweakGui->GetHudDecoShakeTranslateVelConstant();
x414_decoShakeTranslateAmt = x418_decoShakeTranslateAmtVel;
x408_damagerToPlayerNorm = -(fpCam->GetTransform().inverse() * position).normalized();
x464_decoShakeAmtGain = g_tweakGui->GetDecoShakeGainLinear() * prevDam +
g_tweakGui->GetDecoShakeGainConstant();
x45c_decoShakeAmtInit = g_tweakGui->GetDecoShakeInitLinear() * prevDam +
g_tweakGui->GetDecoShakeInitConstant();
x460_decoShakeAmt = x45c_decoShakeAmtInit;
}
} }
void CSamusHud::EnterFirstPerson(const CStateManager& mgr) void CSamusHud::EnterFirstPerson(const CStateManager& mgr)
@ -1293,12 +1655,59 @@ zeus::CTransform CSamusHud::BuildFinalCameraTransform(const zeus::CQuaternion& r
void CSamusHud::SetMessage(const std::u16string& text, const CHUDMemoParms& info) void CSamusHud::SetMessage(const std::u16string& text, const CHUDMemoParms& info)
{ {
bool isWidgetVisible = x598_base_basewidget_message->GetIsVisible();
if (!isWidgetVisible || info.x6_hintMemo)
{
if (info.x5_hintDismissSound)
{
if (!info.x6_hintMemo || !isWidgetVisible)
return;
CSfxManager::SfxStart(1449, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
return;
}
x598_base_basewidget_message->SetColor(zeus::CColor::skWhite);
x598_base_basewidget_message->SetVisibility(false, ETraversalMode::Children);
CGuiWidget* pane = info.x6_hintMemo ? x598_base_basewidget_message : x59c_base_textpane_message;
pane->SetVisibility(true, ETraversalMode::Children);
x59c_base_textpane_message->TextSupport()->SetTypeWriteEffectOptions(true, 0.1f, 40.f);
if (info.x4_initializeMemo)
{
x55c_lastSfxChars = 0.f;
x59c_base_textpane_message->TextSupport()->SetCurTime(0.f);
x59c_base_textpane_message->TextSupport()->SetText(text);
}
else if (x59c_base_textpane_message->TextSupport()->GetString().empty())
{
x55c_lastSfxChars = 0.f;
x59c_base_textpane_message->TextSupport()->AddText(text);
}
else
{
x59c_base_textpane_message->TextSupport()->AddText(std::u16string(u"\n") + text);
}
x59c_base_textpane_message->SetColor(zeus::CColor::skWhite);
x598_base_basewidget_message->SetColor(zeus::CColor::skWhite);
x558_messageTextAlpha = info.x0_alpha;
if (info.x6_hintMemo)
{
if (!isWidgetVisible)
{
CSfxManager::SfxStart(1443, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
}
}
else
{
x598_base_basewidget_message->SetLocalTransform(x598_base_basewidget_message->GetTransform());
}
}
} }
void CSamusHud::InternalDeferHintMemo(ResId strg, u32 timePeriods, const CHUDMemoParms& info) void CSamusHud::InternalDeferHintMemo(ResId strg, u32 strgIdx, const CHUDMemoParms& info)
{ {
x548_hudMemoParms = info;
x550_hudMemoString = g_SimplePool->GetObj(SObjectTag{FOURCC('STRG'), strg});
x554_hudMemoIdx = strgIdx;
} }
} }

72
Runtime/MP1/CSamusHud.hpp
View File

@ -22,17 +22,18 @@ class CGuiLight;
struct CHUDMemoParms struct CHUDMemoParms
{ {
float x0_ = 0.f; float x0_alpha = 0.f;
bool x4_ = false; bool x4_initializeMemo = false;
bool x5_ = false; bool x5_hintDismissSound = false;
bool x6_ = false; bool x6_hintMemo = false;
CHUDMemoParms() = default; CHUDMemoParms() = default;
CHUDMemoParms(float f1, bool b1, bool b2, bool b3) CHUDMemoParms(float alpha, bool initializeMemo, bool hintDismissSound, bool hintMemo)
: x0_(f1), x4_(b1), x5_(b2), x6_(b3) {} : x0_alpha(alpha), x4_initializeMemo(initializeMemo),
x5_hintDismissSound(hintDismissSound), x6_hintMemo(hintMemo) {}
CHUDMemoParms(CInputStream& in) CHUDMemoParms(CInputStream& in)
{ {
x0_ = in.readFloatBig(); x0_alpha = in.readFloatBig();
x4_ = in.readBool(); x4_initializeMemo = in.readBool();
} }
}; };
@ -71,13 +72,13 @@ class CSamusHud
{ {
zeus::CVector3f x0_pos; zeus::CVector3f x0_pos;
zeus::CColor xc_color; zeus::CColor xc_color;
float x10_ = 0.f; float x10_distC = 0.f;
float x14_ = 0.f; float x14_distL = 0.f;
float x18_ = 0.f; float x18_distQ = 0.f;
float x1c_ = 0.f; float x1c_fader = 0.f;
SCachedHudLight(const zeus::CVector3f& pos, const zeus::CColor& color, SCachedHudLight(const zeus::CVector3f& pos, const zeus::CColor& color,
float f1, float f2, float f3, float f4) float f1, float f2, float f3, float f4)
: x0_pos(pos), xc_color(color), x10_(f1), x14_(f2), x18_(f3), x1c_(f4) {} : x0_pos(pos), xc_color(color), x10_distC(f1), x14_distL(f2), x18_distQ(f3), x1c_fader(f4) {}
}; };
struct SVideoBand struct SVideoBand
@ -154,23 +155,23 @@ class CSamusHud
CCameraFilterPass x3a8_camFilter; CCameraFilterPass x3a8_camFilter;
CGuiLight* x3d4_damageLight = nullptr; CGuiLight* x3d4_damageLight = nullptr;
std::vector<zeus::CTransform> x3d8_lightTransforms; std::vector<zeus::CTransform> x3d8_lightTransforms;
float x3e8_ = 0.f; float x3e8_damageTIme = 0.f;
float x3ec_ = 0.f; float x3ec_damageLightPulser = 0.f;
float x3f0_ = 1.f; float x3f0_damageFilterAmtInit = 1.f;
float x3f4_ = 0.f; float x3f4_damageFilterAmt = 0.f;
float x3f8_ = 0.f; float x3f8_damageFilterAmtGain = 0.f;
float x3fc_ = 0.f; float x3fc_hudDamagePracticalsInit = 0.f;
float x400_ = 0.f; float x400_hudDamagePracticals = 0.f;
float x404_ = 0.f; float x404_hudDamagePracticalsGain = 0.f;
zeus::CVector3f x408_; zeus::CVector3f x408_damagerToPlayerNorm;
float x414_ = 0.f; float x414_decoShakeTranslateAmt = 0.f;
float x418_ = 0.f; float x418_decoShakeTranslateAmtVel = 0.f;
zeus::CVector3f x41c_; zeus::CVector3f x41c_decoShakeTranslate;
zeus::CMatrix3f x428_; zeus::CMatrix3f x428_decoShakeRotate;
zeus::CQuaternion x44c_; zeus::CQuaternion x44c_hudLagShakeRot;
float x45c_ = 0.f; float x45c_decoShakeAmtInit = 0.f;
float x460_ = 0.f; float x460_decoShakeAmt = 0.f;
float x464_ = 0.f; float x464_decoShakeAmtGain = 0.f;
rstl::reserved_vector<zeus::CTransform, 3> x46c_; rstl::reserved_vector<zeus::CTransform, 3> x46c_;
zeus::CVector2f x500_viewportScale = {1.f, 1.f}; zeus::CVector2f x500_viewportScale = {1.f, 1.f};
CSfxHandle x508_staticSfxHi; CSfxHandle x508_staticSfxHi;
@ -225,12 +226,17 @@ class CSamusHud
void ApplyClassicLag(const zeus::CUnitVector3f& lookDir, zeus::CQuaternion& rot, void ApplyClassicLag(const zeus::CUnitVector3f& lookDir, zeus::CQuaternion& rot,
const CStateManager& mgr, float dt, bool invert); const CStateManager& mgr, float dt, bool invert);
void UpdateHudLag(float dt, const CStateManager& mgr); 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 UpdateHudDynamicLights(float dt, const CStateManager& mgr);
void UpdateHudDamage(float dt, const CStateManager& mgr, void UpdateHudDamage(float dt, const CStateManager& mgr,
DataSpec::ITweakGui::EHelmetVisMode helmetVis); DataSpec::ITweakGui::EHelmetVisMode helmetVis);
void UpdateStaticSfx(CSfxHandle& handle, float& cycleTimer, u16 sfxId, float dt, void UpdateStaticSfx(CSfxHandle& handle, float& cycleTimer, u16 sfxId, float dt,
float oldStaticInterp, float staticThreshold); float oldStaticInterp, float staticThreshold);
void UpdateStaticInterference(float dt, const CStateManager& mgr); 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 ShowDamage(const zeus::CVector3f& position, float dam, float prevDam, const CStateManager& mgr);
void EnterFirstPerson(const CStateManager& mgr); void EnterFirstPerson(const CStateManager& mgr);
void LeaveFirstPerson(const CStateManager& mgr); void LeaveFirstPerson(const CStateManager& mgr);
@ -260,12 +266,12 @@ public:
SetMessage(text, info); SetMessage(text, info);
} }
void SetMessage(const std::u16string& text, const CHUDMemoParms& info); void SetMessage(const std::u16string& text, const CHUDMemoParms& info);
static void DeferHintMemo(ResId strg, u32 timePeriods, const CHUDMemoParms& info) static void DeferHintMemo(ResId strg, u32 strgIdx, const CHUDMemoParms& info)
{ {
if (g_SamusHud) if (g_SamusHud)
g_SamusHud->InternalDeferHintMemo(strg, timePeriods, info); g_SamusHud->InternalDeferHintMemo(strg, strgIdx, info);
} }
void InternalDeferHintMemo(ResId strg, u32 timePeriods, const CHUDMemoParms& info); void InternalDeferHintMemo(ResId strg, u32 strgIdx, const CHUDMemoParms& info);
}; };
} }

13
Runtime/World/CEffect.cpp Normal file
View File

@ -0,0 +1,13 @@
#include "CEffect.hpp"
#include "CActorParameters.hpp"
namespace urde
{
CEffect::CEffect(TUniqueId uid, const CEntityInfo& info, bool active, const std::string& name, const zeus::CTransform& xf)
: CActor(uid, active, name, info, xf, CModelData::CModelDataNull(), CMaterialList(EMaterialTypes::Unknown),
CActorParameters::None(), kInvalidUniqueId)
{
}
}

17
Runtime/World/CEffect.hpp Normal file
View File

@ -0,0 +1,17 @@
#ifndef __URDE_CEFFECT_HPP__
#define __URDE_CEFFECT_HPP__
#include "CActor.hpp"
namespace urde
{
class CEffect : public CActor
{
public:
CEffect(TUniqueId uid, const CEntityInfo& info, bool active, const std::string& name, const zeus::CTransform& xf);
};
}
#endif // __URDE_CEFFECT_HPP__

25
Runtime/World/CExplosion.cpp Normal file
View File

@ -0,0 +1,25 @@
#include "CExplosion.hpp"
namespace urde
{
CExplosion::CExplosion(const TLockedToken<CGenDescription>& particle, TUniqueId uid, bool active,
const CEntityInfo& info, const std::string& name, const zeus::CTransform& xf,
u32 flags, const zeus::CVector3f& scale, const zeus::CColor& color)
: CEffect(uid, info, active, name, xf)
{
xe8_particleGen = std::make_unique<CElementGen>(particle, CElementGen::EModelOrientationType::Normal,
flags & 0x2 ? CElementGen::EOptionalSystemFlags::Two :
CElementGen::EOptionalSystemFlags::One);
xf0_particleDesc = particle.GetObj();
xf4_24_ = flags & 0x4;
xf4_25_ = true;
xf4_26_ = flags & 0x8;
xe6_27_ = flags & 0x1 ? 1 : 2;
xe8_particleGen->SetGlobalTranslation(xf.origin);
xe8_particleGen->SetOrientation(xf.getRotation());
xe8_particleGen->SetGlobalScale(scale);
xe8_particleGen->SetModulationColor(color);
}
}

28
Runtime/World/CExplosion.hpp Normal file
View File

@ -0,0 +1,28 @@
#ifndef __URDE_CEXPLOSION_HPP__
#define __URDE_CEXPLOSION_HPP__
#include "CEffect.hpp"
#include "Particle/CElementGen.hpp"
namespace urde
{
class CExplosion : public CEffect
{
std::unique_ptr<CElementGen> xe8_particleGen;
TUniqueId xec_ = kInvalidUniqueId;
const CGenDescription* xf0_particleDesc;
bool xf4_24_:1;
bool xf4_25_:1;
bool xf4_26_:1;
float xf8_ = 0.f;
public:
CExplosion(const TLockedToken<CGenDescription>& particle, TUniqueId uid, bool active,
const CEntityInfo& info, const std::string& name, const zeus::CTransform& xf,
u32, const zeus::CVector3f& scale, const zeus::CColor& color);
};
}
#endif // __URDE_CEXPLOSION_HPP__

2
Runtime/World/CGameArea.hpp
View File

@ -259,7 +259,7 @@ private:
CGameArea* x130_next = nullptr; CGameArea* x130_next = nullptr;
CGameArea* x134_prev = nullptr; CGameArea* x134_prev = nullptr;
EChain x138_curChain = EChain::Zero; EChain x138_curChain = EChain::ToDeallocate;
void UpdateFog(float dt); void UpdateFog(float dt);
void UpdateThermalVisor(float dt); void UpdateThermalVisor(float dt);

5
Runtime/World/CGameLight.cpp
View File

@ -56,9 +56,4 @@ CLight CGameLight::GetLight() const
return ret; return ret;
} }
TUniqueId CGameLight::GetParentId() const
{
return xe8_parentId;
}
} }

2
Runtime/World/CGameLight.hpp
View File

@ -22,7 +22,7 @@ public:
void SetLightPriorityAndId(); void SetLightPriorityAndId();
void SetLight(const CLight&); void SetLight(const CLight&);
CLight GetLight() const; CLight GetLight() const;
TUniqueId GetParentId() const; TUniqueId GetParentId() const { return xe8_parentId; }
}; };
} }
#endif // __URDE_CGAMELIGHT_HPP__ #endif // __URDE_CGAMELIGHT_HPP__

0
Runtime/World/CIceImpact.cpp Normal file
View File

0
Runtime/World/CIceImpact.hpp Normal file
View File

3
Runtime/World/CMakeLists.txt
View File

@ -115,7 +115,10 @@ set(WORLD_SOURCES
CRippleManager.hpp CRippleManager.cpp CRippleManager.hpp CRippleManager.cpp
CRipple.hpp CRipple.cpp CRipple.hpp CRipple.cpp
CDestroyableRock.hpp CDestroyableRock.cpp CDestroyableRock.hpp CDestroyableRock.cpp
CEffect.hpp CEffect.cpp
CHUDBillboardEffect.hpp CHUDBillboardEffect.cpp CHUDBillboardEffect.hpp CHUDBillboardEffect.cpp
CExplosion.hpp CExplosion.cpp
CIceImpact.hpp CIceImpact.cpp
CEntityInfo.hpp) CEntityInfo.hpp)
runtime_add_list(World WORLD_SOURCES) runtime_add_list(World WORLD_SOURCES)

2
Runtime/World/CScriptDock.cpp
View File

@ -184,7 +184,6 @@ void CScriptDock::Touch(CActor& act, CStateManager&)
zeus::CPlane CScriptDock::GetPlane(const CStateManager& mgr) const zeus::CPlane CScriptDock::GetPlane(const CStateManager& mgr) const
{ {
const IGameArea::Dock* dock = mgr.GetWorld()->GetAreaAlways(x260_area)->GetDock(x25c_dock); const IGameArea::Dock* dock = mgr.GetWorld()->GetAreaAlways(x260_area)->GetDock(x25c_dock);
return zeus::CPlane(dock->GetPoint(0), dock->GetPoint(1), dock->GetPoint(2)); return zeus::CPlane(dock->GetPoint(0), dock->GetPoint(1), dock->GetPoint(2));
} }
@ -237,7 +236,6 @@ void CScriptDock::UpdateAreaActivateFlags(CStateManager& mgr)
bool CScriptDock::HasPointCrossedDock(const CStateManager& mgr, const zeus::CVector3f& point) const bool CScriptDock::HasPointCrossedDock(const CStateManager& mgr, const zeus::CVector3f& point) const
{ {
const zeus::CPlane plane = GetPlane(mgr); const zeus::CPlane plane = GetPlane(mgr);
return (plane.vec.dot(point) >= plane.d); return (plane.vec.dot(point) >= plane.d);
} }

60
Runtime/World/CWorld.cpp
View File

@ -186,7 +186,7 @@ int CDummyWorld::IGetAreaCount() const { return x18_areas.size(); }
CWorld::CWorld(IObjectStore& objStore, IFactory& resFactory, ResId mlvlId) CWorld::CWorld(IObjectStore& objStore, IFactory& resFactory, ResId mlvlId)
: x8_mlvlId(mlvlId), x60_objectStore(objStore), x64_resFactory(resFactory) : x8_mlvlId(mlvlId), x60_objectStore(objStore), x64_resFactory(resFactory)
{ {
x70_24_ = true; x70_24_currentAreaNeedsAllocation = true;
SObjectTag tag{FOURCC('MLVL'), mlvlId}; SObjectTag tag{FOURCC('MLVL'), mlvlId};
static_cast<ProjectResourceFactoryBase&>(resFactory).LoadResourceAsync(tag, x40_loadBuf); static_cast<ProjectResourceFactoryBase&>(resFactory).LoadResourceAsync(tag, x40_loadBuf);
} }
@ -301,7 +301,7 @@ bool CWorld::CheckWorldComplete(CStateManager* mgr, TAreaId id, ResId mreaId)
} }
for (std::unique_ptr<CGameArea>& area : x18_areas) for (std::unique_ptr<CGameArea>& area : x18_areas)
MoveToChain(area.get(), EChain::One); MoveToChain(area.get(), EChain::Deallocated);
x24_mapwId = r.readUint32Big(); x24_mapwId = r.readUint32Big();
x28_mapWorld = g_SimplePool->GetObj(SObjectTag{FOURCC('MAPW'), x24_mapwId}); x28_mapWorld = g_SimplePool->GetObj(SObjectTag{FOURCC('MAPW'), x24_mapwId});
@ -412,16 +412,16 @@ bool CWorld::ScheduleAreaToLoad(CGameArea* area, CStateManager& mgr)
{ {
if (!area->xf0_24_postConstructed) if (!area->xf0_24_postConstructed)
{ {
MoveToChain(area, EChain::Two); MoveToChain(area, EChain::Loading);
return true; return true;
} }
else else
{ {
if (area->x138_curChain != EChain::Alive) if (area->x138_curChain != EChain::Alive)
{ {
if (area->x138_curChain != EChain::Four) if (area->x138_curChain != EChain::AliveJudgement)
{ {
x70_24_ = true; x70_24_currentAreaNeedsAllocation = true;
} }
MoveToChain(area, EChain::Alive); MoveToChain(area, EChain::Alive);
} }
@ -433,37 +433,37 @@ void CWorld::TravelToArea(TAreaId aid, CStateManager& mgr, bool skipLoadOther)
{ {
if (aid < 0 || aid >= x18_areas.size()) if (aid < 0 || aid >= x18_areas.size())
return; return;
x70_24_ = false; x70_24_currentAreaNeedsAllocation = false;
x68_curAreaId = aid; x68_curAreaId = aid;
CGameArea* chain0 = x4c_chainHeads[0]; CGameArea* toDeallocateAreas = x4c_chainHeads[0];
while (chain0) while (toDeallocateAreas)
{ {
if (chain0->Invalidate(mgr)) if (toDeallocateAreas->Invalidate(mgr))
{ {
MoveToChain(chain0, EChain::One); MoveToChain(toDeallocateAreas, EChain::Deallocated);
break; break;
} }
chain0 = chain0->x130_next; toDeallocateAreas = toDeallocateAreas->x130_next;
} }
CGameArea* chain3 = x4c_chainHeads[3]; CGameArea* aliveAreas = x4c_chainHeads[3];
while (chain3) while (aliveAreas)
{ {
MoveToChain(chain3, EChain::Four); MoveToChain(aliveAreas, EChain::AliveJudgement);
chain3 = chain3->x130_next; aliveAreas = aliveAreas->x130_next;
} }
CGameArea* chain2 = x4c_chainHeads[2]; CGameArea* loadingAreas = x4c_chainHeads[2];
while (chain2) while (loadingAreas)
{ {
MoveToChain(chain2, EChain::Zero); MoveToChain(loadingAreas, EChain::ToDeallocate);
chain2 = chain2->x130_next; loadingAreas = loadingAreas->x130_next;
} }
CGameArea* area = x18_areas[aid].get(); CGameArea* area = x18_areas[aid].get();
if (area->x138_curChain != EChain::Four) if (area->x138_curChain != EChain::AliveJudgement)
x70_24_ = true; x70_24_currentAreaNeedsAllocation = true;
area->Validate(mgr); area->Validate(mgr);
MoveToChain(area, EChain::Alive); MoveToChain(area, EChain::Alive);
area->SetOcclusionState(CGameArea::EOcclusionState::Visible); area->SetOcclusionState(CGameArea::EOcclusionState::Visible);
@ -496,19 +496,19 @@ void CWorld::TravelToArea(TAreaId aid, CStateManager& mgr, bool skipLoadOther)
} }
} }
CGameArea* chain4 = x4c_chainHeads[4]; CGameArea* judgementArea = x4c_chainHeads[4];
while (chain4) while (judgementArea)
{ {
MoveToChain(chain4, EChain::Zero); MoveToChain(judgementArea, EChain::ToDeallocate);
chain4 = chain4->x130_next; judgementArea = judgementArea->x130_next;
} }
size_t toStreamCount = 0; size_t toStreamCount = 0;
chain0 = x4c_chainHeads[0]; toDeallocateAreas = x4c_chainHeads[0];
while (chain0) while (toDeallocateAreas)
{ {
chain0->RemoveStaticGeometry(); toDeallocateAreas->RemoveStaticGeometry();
chain0 = chain0->x130_next; toDeallocateAreas = toDeallocateAreas->x130_next;
++toStreamCount; ++toStreamCount;
} }
@ -520,7 +520,7 @@ void CWorld::TravelToArea(TAreaId aid, CStateManager& mgr, bool skipLoadOther)
void CWorld::SetPauseState(bool paused) void CWorld::SetPauseState(bool paused)
{ {
for (auto it = GetChainHead(EChain::Two) ; it != AliveAreasEnd() ; ++it) for (auto it = GetChainHead(EChain::Loading) ; it != AliveAreasEnd() ; ++it)
it->SetPauseState(paused); it->SetPauseState(paused);
x70_25_paused = paused; x70_25_paused = paused;
} }

2
Runtime/World/CWorld.hpp
View File

@ -134,7 +134,7 @@ private:
{ {
struct struct
{ {
bool x70_24_ : 1; bool x70_24_currentAreaNeedsAllocation : 1;
bool x70_25_paused : 1; bool x70_25_paused : 1;
bool x70_26_ : 1; bool x70_26_ : 1;
bool x70_27_ : 1; bool x70_27_ : 1;

8
Runtime/World/IGameArea.hpp
View File

@ -55,11 +55,11 @@ public:
enum class EChain enum class EChain
{ {
Invalid = -1, Invalid = -1,
Zero, ToDeallocate,
One, Deallocated,
Two, Loading,
Alive, Alive,
Four AliveJudgement
}; };
} }

2
specter

@ -1 +1 @@
Subproject commit ce3b1c7399061d0199268a8da1ec3fdfa15c51a2 Subproject commit 0badca1998a07b8ac1c99c103e9f9b97daee9c60