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

970 lines
45 KiB
C++
Raw Normal View History

RuntimeCommonB: Normalize cpp file includes Like the prior changes normalizing the inclusions within headers, this tackles the cpp files of the RuntimeCommonB target, making these source files consistent with their headers.
2019-12-22 20:04:07 +00:00
#include "Runtime/GuiSys/CCompoundTargetReticle.hpp"
Huge compile performance refactor
2017-12-29 08:08:12 +00:00
#include <cstdlib>
RuntimeCommonB: Normalize cpp file includes Like the prior changes normalizing the inclusions within headers, this tackles the cpp files of the RuntimeCommonB target, making these source files consistent with their headers.
2019-12-22 20:04:07 +00:00
#include "Runtime/GameGlobalObjects.hpp"
#include "Runtime/CSimplePool.hpp"
#include "Runtime/CStateManager.hpp"
#include "Runtime/Camera/CGameCamera.hpp"
#include "Runtime/World/CPlayer.hpp"
#include "Runtime/World/CScriptGrapplePoint.hpp"
#include "Runtime/World/CWorld.hpp"
Fix TCastTo.hpp inclusions, add comment to warn against modifying include path
2019-09-21 13:07:13 +00:00
#include "TCastTo.hpp" // Generated file, do not modify include path
Add missing factories, update hecl
2017-02-13 21:29:00 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
namespace urde {
CCompoundTargetReticle: Move private strings into the cpp file This is an internal detail, so we don't need to expose this in the header,
2019-09-12 09:45:51 +00:00
namespace {
CCompoundTargetReticle: Declare file-scope strings as arrays Reduces the overall size of the resulting binary, as only the string data will be stored rather than the string and a pointer pointing to said string data.
2019-09-12 10:38:01 +00:00
constexpr char skCrosshairsReticleAssetName[] = "CMDL_Crosshairs";
[[maybe_unused]] constexpr char skOrbitZoneReticleAssetName[] = "CMDL_OrbitZone";
constexpr char skSeekerAssetName[] = "CMDL_Seeker";
constexpr char skLockConfirmAssetName[] = "CMDL_LockConfirm";
constexpr char skTargetFlowerAssetName[] = "CMDL_TargetFlower";
constexpr char skMissileBracketAssetName[] = "CMDL_MissileBracket";
constexpr char skChargeGaugeAssetName[] = "CMDL_ChargeGauge";
constexpr char skChargeBeamTickAssetName[] = "CMDL_ChargeTickFirst";
constexpr char skOuterBeamIconSquareNameBase[] = "CMDL_BeamSquare";
constexpr char skInnerBeamIconName[] = "CMDL_InnerBeamIcon";
CCompoundTargetReticle: Fix typo in lock fire string In the actual game executable, the string is stored with a lower-case 'i', not an upper-case one.
2019-09-12 10:40:50 +00:00
constexpr char skLockFireAssetName[] = "CMDL_LockFire";
CCompoundTargetReticle: Declare file-scope strings as arrays Reduces the overall size of the resulting binary, as only the string data will be stored rather than the string and a pointer pointing to said string data.
2019-09-12 10:38:01 +00:00
constexpr char skLockDaggerAssetName[] = "CMDL_LockDagger0";
constexpr char skGrappleReticleAssetName[] = "CMDL_Grapple";
constexpr char skXRayRingModelName[] = "CMDL_XRayRetRing";
constexpr char skThermalReticleAssetName[] = "CMDL_ThermalRet";
[[maybe_unused]] constexpr char skOrbitPointAssetName[] = "CMDL_OrbitPoint";
CCompoundTargetReticle: Move private strings into the cpp file This is an internal detail, so we don't need to expose this in the header,
2019-09-12 09:45:51 +00:00
float offshoot_func(float f1, float f2, float f3) { return (f1 * 0.5f) + std::sin((f3 - 0.5f) * f2); }
Add missing factories, update hecl
2017-02-13 21:29:00 +00:00
CCompoundTargetReticle: Move private strings into the cpp file This is an internal detail, so we don't need to expose this in the header,
2019-09-12 09:45:51 +00:00
float calculate_premultiplied_overshoot_offset(float f1) { return 2.f * (M_PIF - std::asin(1.f / f1)); }
} // Anonymous namespace
Initial CCollisionActor imps, minor cleanup
2017-02-21 03:29:28 +00:00
CCompoundTargetReticle: Make skZeroRenderState constexpr Allows eliding runtime initializers where applicable. Particularly for the static data.
2020-04-12 08:19:48 +00:00
constexpr CTargetReticleRenderState CTargetReticleRenderState::skZeroRenderState(kInvalidUniqueId, 1.f, zeus::skZero3f,
0.f, 1.f, true);
Initial CCollisionActor imps, minor cleanup
2017-02-21 03:29:28 +00:00
Massive fmtlib refactor
2019-07-20 04:27:21 +00:00
CCompoundTargetReticle::SOuterItemInfo::SOuterItemInfo(std::string_view res) : x0_model(g_SimplePool->GetObj(res)) {}
Initial CCollisionActor imps, minor cleanup
2017-02-21 03:29:28 +00:00
CCompoundTargetReticle::CCompoundTargetReticle(const CStateManager& mgr)
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
: x0_leadingOrientation(mgr.GetCameraManager()->GetCurrentCamera(mgr)->GetTransform().buildMatrix3f())
, x10_laggingOrientation(mgr.GetCameraManager()->GetCurrentCamera(mgr)->GetTransform().buildMatrix3f())
Finish CCompoundTargetReticle
2017-10-30 03:37:20 +00:00
, x2c_overshootOffsetHalf(0.5f * g_tweakTargeting->GetChargeGaugeOvershootOffset())
, x30_premultOvershootOffset(
New code style refactor
2018-12-08 05:30:43 +00:00
calculate_premultiplied_overshoot_offset(g_tweakTargeting->GetChargeGaugeOvershootOffset()))
Initial CCollisionActor imps, minor cleanup
2017-02-21 03:29:28 +00:00
, x34_crosshairs(g_SimplePool->GetObj(skCrosshairsReticleAssetName))
, x40_seeker(g_SimplePool->GetObj(skSeekerAssetName))
, x4c_lockConfirm(g_SimplePool->GetObj(skLockConfirmAssetName))
, x58_targetFlower(g_SimplePool->GetObj(skTargetFlowerAssetName))
, x64_missileBracket(g_SimplePool->GetObj(skMissileBracketAssetName))
, x70_innerBeamIcon(g_SimplePool->GetObj(skInnerBeamIconName))
, x7c_lockFire(g_SimplePool->GetObj(skLockFireAssetName))
, x88_lockDagger(g_SimplePool->GetObj(skLockDaggerAssetName))
, x94_grapple(g_SimplePool->GetObj(skGrappleReticleAssetName))
, xa0_chargeTickFirst(g_SimplePool->GetObj(skChargeBeamTickAssetName))
, xac_xrayRetRing(g_SimplePool->GetObj(skXRayRingModelName))
, xb8_thermalReticle(g_SimplePool->GetObj(skThermalReticleAssetName))
, xc4_chargeGauge(skChargeGaugeAssetName)
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
, xf4_targetPos(CalculateOrbitZoneReticlePosition(mgr, false))
, x100_laggingTargetPos(CalculateOrbitZoneReticlePosition(mgr, true))
New code style refactor
2018-12-08 05:30:43 +00:00
, x208_lockonTimer(g_tweakTargeting->GetLockonDuration()) {
xe0_outerBeamIconSquares.reserve(9);
Massive fmtlib refactor
2019-07-20 04:27:21 +00:00
for (u32 i = 0; i < 9; ++i)
Update fmtlib
2020-04-11 22:51:39 +00:00
xe0_outerBeamIconSquares.emplace_back(fmt::format(FMT_STRING("{}{}"), skOuterBeamIconSquareNameBase, i));
New code style refactor
2018-12-08 05:30:43 +00:00
x34_crosshairs.Lock();
}
CCompoundTargetReticle::SScanReticuleRenderer::SScanReticuleRenderer() {
CGraphics::CommitResources([this](boo::IGraphicsDataFactory::Context& ctx) {
for (int i = 0; i < 2; ++i) {
m_lineRenderers[i].emplace(ctx, CLineRenderer::EPrimitiveMode::Lines, 8, nullptr, true, true);
for (int j = 0; j < 4; ++j)
m_stripRenderers[i][j].emplace(ctx, CLineRenderer::EPrimitiveMode::LineStrip, 4, nullptr, true, true);
Initial CCollisionActor imps, minor cleanup
2017-02-21 03:29:28 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
return true;
} BooTrace);
Initial CCollisionActor imps, minor cleanup
2017-02-21 03:29:28 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
CCompoundTargetReticle::EReticleState CCompoundTargetReticle::GetDesiredReticleState(const CStateManager& mgr) const {
switch (mgr.GetPlayerState()->GetCurrentVisor()) {
case CPlayerState::EPlayerVisor::Scan:
return EReticleState::Scan;
case CPlayerState::EPlayerVisor::XRay:
return EReticleState::XRay;
case CPlayerState::EPlayerVisor::Combat:
default:
return EReticleState::Combat;
case CPlayerState::EPlayerVisor::Thermal:
return EReticleState::Thermal;
}
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CCompoundTargetReticle::Update(float dt, const CStateManager& mgr) {
float angle = x10_laggingOrientation.angleFrom(x0_leadingOrientation).asDegrees();
float t;
if (angle < 0.1f || angle > 45.f)
t = 1.f;
else
t = std::min(1.f, g_tweakTargeting->GetAngularLagSpeed() * dt / angle);
x10_laggingOrientation =
t == 1.f ? x0_leadingOrientation : zeus::CQuaternion::slerp(x10_laggingOrientation, x0_leadingOrientation, t);
xf4_targetPos = CalculateOrbitZoneReticlePosition(mgr, false);
x100_laggingTargetPos = CalculateOrbitZoneReticlePosition(mgr, true);
UpdateCurrLockOnGroup(dt, mgr);
UpdateNextLockOnGroup(dt, mgr);
UpdateOrbitZoneGroup(dt, mgr);
EReticleState desiredState = GetDesiredReticleState(mgr);
if (desiredState != x20_prevState && x20_prevState == x24_nextState) {
x24_nextState = desiredState;
x28_noDrawTicks = 2;
}
if (x20_prevState != x24_nextState && x28_noDrawTicks <= 0) {
x20_prevState = x24_nextState;
float combat = false;
float scan = false;
float xray = false;
float thermal = false;
switch (x24_nextState) {
case EReticleState::Combat:
combat = true;
break;
case EReticleState::Scan:
scan = true;
break;
case EReticleState::XRay:
xray = true;
break;
case EReticleState::Thermal:
thermal = true;
break;
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
default:
New code style refactor
2018-12-08 05:30:43 +00:00
break;
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
if (combat)
x40_seeker.Lock();
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
else
New code style refactor
2018-12-08 05:30:43 +00:00
x40_seeker.Unlock();
if (combat)
x4c_lockConfirm.Lock();
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
else
New code style refactor
2018-12-08 05:30:43 +00:00
x4c_lockConfirm.Unlock();
if (combat)
x58_targetFlower.Lock();
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
else
New code style refactor
2018-12-08 05:30:43 +00:00
x58_targetFlower.Unlock();
if (combat)
x64_missileBracket.Lock();
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
else
New code style refactor
2018-12-08 05:30:43 +00:00
x64_missileBracket.Unlock();
if (combat)
x70_innerBeamIcon.Lock();
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
else
New code style refactor
2018-12-08 05:30:43 +00:00
x70_innerBeamIcon.Unlock();
if (combat)
x7c_lockFire.Lock();
else
x7c_lockFire.Unlock();
if (combat)
x88_lockDagger.Lock();
else
x88_lockDagger.Unlock();
if (combat)
xa0_chargeTickFirst.Lock();
else
xa0_chargeTickFirst.Unlock();
if (xray)
xac_xrayRetRing.Lock();
else
xac_xrayRetRing.Unlock();
if (thermal)
xb8_thermalReticle.Lock();
else
xb8_thermalReticle.Unlock();
if (combat)
xc4_chargeGauge.x0_model.Lock();
else
xc4_chargeGauge.x0_model.Unlock();
if (!scan)
x94_grapple.Lock();
else
x94_grapple.Unlock();
for (SOuterItemInfo& info : xe0_outerBeamIconSquares) {
if (combat)
info.x0_model.Lock();
else
info.x0_model.Unlock();
}
}
CPlayerGun* gun = mgr.GetPlayer().GetPlayerGun();
bool fullyCharged = (gun->IsCharging() ? gun->GetChargeBeamFactor() : 0.f) >= 1.f;
if (fullyCharged != x21a_fullyCharged)
x21a_fullyCharged = fullyCharged;
if (x21a_fullyCharged)
x214_fullChargeFadeTimer = std::min(dt / g_tweakTargeting->GetFullChargeFadeDuration() + x214_fullChargeFadeTimer,
g_tweakTargeting->GetFullChargeFadeDuration());
else
x214_fullChargeFadeTimer =
std::max(x214_fullChargeFadeTimer - dt / g_tweakTargeting->GetFullChargeFadeDuration(), 0.f);
bool missileActive = gun->GetMissleMode() == CPlayerGun::EMissleMode::Active;
if (missileActive != x1f4_missileActive) {
if (x1f8_missileBracketTimer != 0.f)
x1f8_missileBracketTimer = FLT_EPSILON - x1f8_missileBracketTimer;
else
x1f8_missileBracketTimer = FLT_EPSILON;
x1f4_missileActive = missileActive;
}
CPlayerState::EBeamId beam = gun->GetCurrentBeam();
if (beam != x200_beam) {
x204_chargeGaugeOvershootTimer = g_tweakTargeting->GetChargeGaugeOvershootDuration();
for (int i = 0; i < 9; ++i) {
zeus::CRelAngle baseAngle = g_tweakTargeting->GetOuterBeamSquareAngles(int(beam))[i];
CRelAngle fix
2018-12-17 03:52:51 +00:00
baseAngle.makeRel();
New code style refactor
2018-12-08 05:30:43 +00:00
SOuterItemInfo& icon = xe0_outerBeamIconSquares[i];
zeus::CRelAngle offshootAngleDelta = baseAngle.asRadians() - icon.x10_rotAng;
if ((i & 0x1) == 1)
offshootAngleDelta =
(baseAngle > 0.f) ? zeus::CRelAngle(-2.f * M_PIF - baseAngle) : zeus::CRelAngle(2.f * M_PIF + baseAngle);
icon.xc_offshootBaseAngle = icon.x10_rotAng;
icon.x18_offshootAngleDelta = offshootAngleDelta;
icon.x14_baseAngle = baseAngle;
}
zeus::CRelAngle baseAngle = g_tweakTargeting->GetChargeGaugeAngle(int(beam));
CRelAngle fix
2018-12-17 03:52:51 +00:00
baseAngle.makeRel();
New code style refactor
2018-12-08 05:30:43 +00:00
float offshootAngleDelta = baseAngle.asRadians() - xc4_chargeGauge.x10_rotAng;
if ((rand() & 0x1) == 1)
offshootAngleDelta =
(offshootAngleDelta > 0.f) ? -2.f * M_PIF - offshootAngleDelta : 2.f * M_PIF + offshootAngleDelta;
xc4_chargeGauge.xc_offshootBaseAngle = xc4_chargeGauge.x10_rotAng;
xc4_chargeGauge.x18_offshootAngleDelta = offshootAngleDelta;
xc4_chargeGauge.x14_baseAngle = baseAngle;
x200_beam = beam;
x208_lockonTimer = 0.f;
}
if (gun->GetLastFireButtonStates() & 0x1) {
if (!x218_beamShot)
x210_lockFireTimer = g_tweakTargeting->GetLockFireDuration();
x218_beamShot = true;
} else {
x218_beamShot = false;
}
if (gun->GetLastFireButtonStates() & 0x2) {
if (!x219_missileShot)
x1fc_missileBracketScaleTimer = g_tweakTargeting->GetMissileBracketScaleDuration();
x219_missileShot = true;
} else {
x219_missileShot = false;
}
if (TCastToConstPtr<CScriptGrapplePoint> point = mgr.GetObjectById(xf2_nextTargetId)) {
if (point->GetUniqueId() != x1dc_grapplePoint0) {
float tmp;
if (point->GetUniqueId() == x1de_grapplePoint1)
tmp = std::max(FLT_EPSILON, x1e4_grapplePoint1T);
else
tmp = FLT_EPSILON;
x1de_grapplePoint1 = x1dc_grapplePoint0;
x1e4_grapplePoint1T = x1e0_grapplePoint0T;
x1e0_grapplePoint0T = tmp;
x1dc_grapplePoint0 = point->GetUniqueId();
}
} else if (x1dc_grapplePoint0 != kInvalidUniqueId) {
x1de_grapplePoint1 = x1dc_grapplePoint0;
x1e4_grapplePoint1T = x1e0_grapplePoint0T;
x1e0_grapplePoint0T = 0.f;
x1dc_grapplePoint0 = kInvalidUniqueId;
}
if (x1e0_grapplePoint0T > 0.f)
x1e0_grapplePoint0T = std::min(dt / 0.5f + x1e0_grapplePoint0T, 1.f);
if (x1e4_grapplePoint1T > 0.f) {
x1e4_grapplePoint1T = std::max(0.f, x1e4_grapplePoint1T - dt / 0.5f);
if (x1e4_grapplePoint1T == 0.f)
x1de_grapplePoint1 = kInvalidUniqueId;
}
x1f0_xrayRetAngle =
CRelAngle fix
2018-12-17 03:52:51 +00:00
zeus::CRelAngle(zeus::degToRad(g_tweakTargeting->GetXRayRetAngleSpeed() * dt) + x1f0_xrayRetAngle).asRel();
x1ec_seekerAngle = zeus::CRelAngle(zeus::degToRad(g_tweakTargeting->GetSeekerAngleSpeed() * dt) + x1ec_seekerAngle).
asRel();
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CTargetReticleRenderState::InterpolateWithClamp(const CTargetReticleRenderState& a, CTargetReticleRenderState& out,
const CTargetReticleRenderState& b, float t) {
t = zeus::clamp(0.f, t, 1.f);
float omt = 1.f - t;
out.x4_radiusWorld = omt * a.x4_radiusWorld + t * b.x4_radiusWorld;
out.x14_factor = omt * a.x14_factor + t * b.x14_factor;
out.x18_minVpClampScale = omt * a.x18_minVpClampScale + t * b.x18_minVpClampScale;
out.x8_positionWorld = zeus::CVector3f::lerp(a.x8_positionWorld, b.x8_positionWorld, t);
if (t == 1.f)
out.x0_target = b.x0_target;
else if (t == 0.f)
out.x0_target = a.x0_target;
else
out.x0_target = kInvalidUniqueId;
Finish CCompoundTargetReticle
2017-10-30 03:37:20 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
static bool IsDamageOrbit(CPlayer::EPlayerOrbitRequest req) {
switch (req) {
case CPlayer::EPlayerOrbitRequest::Five:
case CPlayer::EPlayerOrbitRequest::ActivateOrbitSource:
case CPlayer::EPlayerOrbitRequest::ProjectileCollide:
case CPlayer::EPlayerOrbitRequest::Freeze:
case CPlayer::EPlayerOrbitRequest::DamageOnGrapple:
return true;
default:
return false;
}
}
Finish CCompoundTargetReticle
2017-10-30 03:37:20 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
void CCompoundTargetReticle::UpdateCurrLockOnGroup(float dt, const CStateManager& mgr) {
TUniqueId targetId = mgr.GetPlayer().GetOrbitTargetId();
if (targetId != xf0_targetId) {
if (targetId != kInvalidUniqueId) {
if (TCastToConstPtr<CScriptGrapplePoint> point = mgr.GetObjectById(targetId))
CSfxManager::SfxStart(SFXui_lockon_grapple, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
else
CSfxManager::SfxStart(SFXui_lockon_poi, 1.f, 0.f, false, 0x7f, false, kInvalidAreaId);
}
if (targetId == kInvalidUniqueId) {
x12c_currGroupA = x10c_currGroupInterp;
x14c_currGroupB.SetFactor(0.f);
x16c_currGroupDur =
IsDamageOrbit(mgr.GetPlayer().GetOrbitRequest()) ? 0.65f : g_tweakTargeting->GetCurrLockOnEnterDuration();
} else {
x12c_currGroupA = x10c_currGroupInterp;
if (xf0_targetId == kInvalidUniqueId)
x12c_currGroupA.SetTargetId(targetId);
x14c_currGroupB = CTargetReticleRenderState(
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
targetId, 1.f, zeus::skZero3f, 1.f,
New code style refactor
2018-12-08 05:30:43 +00:00
IsGrappleTarget(targetId, mgr) ? g_tweakTargeting->GetGrappleMinClampScale() : 1.f, false);
x16c_currGroupDur = xf0_targetId == kInvalidUniqueId ? g_tweakTargeting->GetCurrLockOnExitDuration()
: g_tweakTargeting->GetCurrLockOnSwitchDuration();
}
x170_currGroupTimer = x16c_currGroupDur;
xf0_targetId = targetId;
}
if (x170_currGroupTimer > 0.f) {
UpdateTargetParameters(x12c_currGroupA, mgr);
UpdateTargetParameters(x14c_currGroupB, mgr);
x170_currGroupTimer = std::max(0.f, x170_currGroupTimer - dt);
CTargetReticleRenderState::InterpolateWithClamp(x12c_currGroupA, x10c_currGroupInterp, x14c_currGroupB,
1.f - x170_currGroupTimer / x16c_currGroupDur);
} else {
UpdateTargetParameters(x10c_currGroupInterp, mgr);
}
if (x1f8_missileBracketTimer != 0.f && x1f8_missileBracketTimer < g_tweakTargeting->GetMissileBracketDuration()) {
if (x1f8_missileBracketTimer < 0.f)
x1f8_missileBracketTimer = std::min(0.f, x1f8_missileBracketTimer + dt);
Finish CCompoundTargetReticle
2017-10-30 03:37:20 +00:00
else
New code style refactor
2018-12-08 05:30:43 +00:00
x1f8_missileBracketTimer = std::min(g_tweakTargeting->GetMissileBracketDuration(), x1f8_missileBracketTimer + dt);
}
if (x204_chargeGaugeOvershootTimer > 0.f) {
x204_chargeGaugeOvershootTimer = std::max(0.f, x204_chargeGaugeOvershootTimer - dt);
if (x204_chargeGaugeOvershootTimer == 0.f) {
for (int i = 0; i < 9; ++i)
xe0_outerBeamIconSquares[i].x10_rotAng = xe0_outerBeamIconSquares[i].x14_baseAngle;
xc4_chargeGauge.x10_rotAng = xc4_chargeGauge.x14_baseAngle;
x208_lockonTimer = FLT_EPSILON;
} else {
float offshoot =
offshoot_func(x2c_overshootOffsetHalf, x30_premultOvershootOffset,
1.f - x204_chargeGaugeOvershootTimer / g_tweakTargeting->GetChargeGaugeOvershootDuration());
for (int i = 0; i < 9; ++i) {
SOuterItemInfo& item = xe0_outerBeamIconSquares[i];
CRelAngle fix
2018-12-17 03:52:51 +00:00
item.x10_rotAng = zeus::CRelAngle(item.x18_offshootAngleDelta * offshoot + item.xc_offshootBaseAngle).
asRel();
New code style refactor
2018-12-08 05:30:43 +00:00
}
xc4_chargeGauge.x10_rotAng =
CRelAngle fix
2018-12-17 03:52:51 +00:00
zeus::CRelAngle(xc4_chargeGauge.x18_offshootAngleDelta * offshoot + xc4_chargeGauge.xc_offshootBaseAngle).
asRel();
New code style refactor
2018-12-08 05:30:43 +00:00
}
}
if (x208_lockonTimer > 0.f && x208_lockonTimer < g_tweakTargeting->GetLockonDuration())
x208_lockonTimer = std::min(g_tweakTargeting->GetLockonDuration(), x208_lockonTimer + dt);
if (x210_lockFireTimer > 0.f)
x210_lockFireTimer = std::max(0.f, x210_lockFireTimer - dt);
if (x1fc_missileBracketScaleTimer > 0.f)
x1fc_missileBracketScaleTimer = std::max(0.f, x1fc_missileBracketScaleTimer - dt);
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CCompoundTargetReticle::UpdateNextLockOnGroup(float dt, const CStateManager& mgr) {
TUniqueId nextTargetId = mgr.GetPlayer().GetOrbitNextTargetId();
if (mgr.GetPlayerState()->GetCurrentVisor() == CPlayerState::EPlayerVisor::Scan &&
mgr.GetPlayer().GetOrbitTargetId() != kInvalidUniqueId)
nextTargetId = mgr.GetPlayer().GetOrbitTargetId();
if (nextTargetId != xf2_nextTargetId) {
if (nextTargetId == kInvalidUniqueId) {
x194_nextGroupA = x174_nextGroupInterp;
x1b4_nextGroupB = CTargetReticleRenderState(
kInvalidUniqueId, 1.f,
(x20_prevState == EReticleState::XRay || x20_prevState == EReticleState::Thermal) ? x100_laggingTargetPos
: xf4_targetPos,
0.f, 1.f, true);
x1d4_nextGroupDur = x1d8_nextGroupTimer = g_tweakTargeting->GetNextLockOnExitDuration();
xf2_nextTargetId = nextTargetId;
} else {
x194_nextGroupA = x174_nextGroupInterp;
x1b4_nextGroupB = CTargetReticleRenderState(
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
nextTargetId, 1.f, zeus::skZero3f, 1.f,
New code style refactor
2018-12-08 05:30:43 +00:00
IsGrappleTarget(nextTargetId, mgr) ? g_tweakTargeting->GetGrappleMinClampScale() : 1.f, true);
x1d4_nextGroupDur = x1d8_nextGroupTimer = xf2_nextTargetId == kInvalidUniqueId
? g_tweakTargeting->GetNextLockOnEnterDuration()
: g_tweakTargeting->GetNextLockOnSwitchDuration();
xf2_nextTargetId = nextTargetId;
}
}
if (x1d8_nextGroupTimer > 0.f) {
UpdateTargetParameters(x194_nextGroupA, mgr);
UpdateTargetParameters(x1b4_nextGroupB, mgr);
x1d8_nextGroupTimer = std::max(0.f, x1d8_nextGroupTimer - dt);
CTargetReticleRenderState::InterpolateWithClamp(x194_nextGroupA, x174_nextGroupInterp, x1b4_nextGroupB,
1.f - x1d8_nextGroupTimer / x1d4_nextGroupDur);
} else {
UpdateTargetParameters(x174_nextGroupInterp, mgr);
}
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CCompoundTargetReticle::UpdateOrbitZoneGroup(float dt, const CStateManager& mgr) {
if (xf0_targetId == kInvalidUniqueId && xf2_nextTargetId != kInvalidUniqueId)
x20c_ = std::min(1.f, 2.f * dt + x20c_);
else
x20c_ = std::max(0.f, x20c_ - 2.f * dt);
if (mgr.GetPlayer().IsShowingCrosshairs() &&
mgr.GetPlayerState()->GetCurrentVisor() != CPlayerState::EPlayerVisor::Scan)
x1e8_crosshairsScale = std::min(1.f, dt / g_tweakTargeting->GetCrosshairsScaleDuration() + x1e8_crosshairsScale);
else
x1e8_crosshairsScale = std::max(0.f, x1e8_crosshairsScale - dt / g_tweakTargeting->GetCrosshairsScaleDuration());
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
CCompoundTargetingReticle: Remove mutable specifier on m_scanRetRenderer This can be trivially resolved by dropping const qualifiers on the necessary member functions.
2020-04-10 01:28:50 +00:00
void CCompoundTargetReticle::Draw(const CStateManager& mgr, bool hideLockon) {
New code style refactor
2018-12-08 05:30:43 +00:00
if (mgr.GetPlayer().GetMorphballTransitionState() == CPlayer::EPlayerMorphBallState::Unmorphed &&
!mgr.GetCameraManager()->IsInCinematicCamera()) {
Graphics debug groups and bug fixes
2019-07-21 08:42:52 +00:00
SCOPED_GRAPHICS_DEBUG_GROUP("CCompoundTargetReticle::Draw", zeus::skCyan);
New code style refactor
2018-12-08 05:30:43 +00:00
zeus::CTransform camXf = mgr.GetCameraManager()->GetCurrentCameraTransform(mgr);
CGraphics::SetViewPointMatrix(camXf);
if (!hideLockon) {
DrawCurrLockOnGroup(camXf.basis, mgr);
DrawNextLockOnGroup(camXf.basis, mgr);
DrawOrbitZoneGroup(camXf.basis, mgr);
}
DrawGrappleGroup(camXf.basis, mgr, hideLockon);
}
if (x28_noDrawTicks > 0)
--x28_noDrawTicks;
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
void CCompoundTargetReticle::DrawGrapplePoint(const CScriptGrapplePoint& point, float t, const CStateManager& mgr,
New code style refactor
2018-12-08 05:30:43 +00:00
const zeus::CMatrix3f& rot, bool zEqual) const {
zeus::CVector3f orbitPos = point.GetOrbitPosition(mgr);
zeus::CColor color;
if (point.GetGrappleParameters().GetLockSwingTurn())
color = g_tweakTargeting->GetLockedGrapplePointSelectColor();
else
color = g_tweakTargeting->GetGrapplePointSelectColor();
color = zeus::CColor::lerp(g_tweakTargeting->GetGrapplePointColor(), color, t);
zeus::CMatrix3f scale(
CalculateClampedScale(orbitPos, 1.f, g_tweakTargeting->GetGrappleClampMin(),
g_tweakTargeting->GetGrappleClampMax(), mgr) *
((1.f - t) * g_tweakTargeting->GetGrappleScale() + t * g_tweakTargeting->GetGrappleSelectScale()));
zeus::CTransform modelXf(rot * scale, orbitPos);
CGraphics::SetModelMatrix(modelXf);
CModelFlags flags(7, 0, 0, color);
x94_grapple->Draw(flags);
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CCompoundTargetReticle::DrawGrappleGroup(const zeus::CMatrix3f& rot, const CStateManager& mgr,
bool hideLockon) const {
if (x28_noDrawTicks > 0)
return;
if (mgr.GetPlayerState()->HasPowerUp(CPlayerState::EItemType::GrappleBeam) && x94_grapple.IsLoaded() &&
x20_prevState != EReticleState::Scan) {
if (hideLockon) {
for (const CEntity* ent : mgr.GetAllObjectList()) {
if (TCastToConstPtr<CScriptGrapplePoint> point = ent) {
if (point->GetActive()) {
if (point->GetAreaIdAlways() != kInvalidAreaId) {
const CGameArea* area = mgr.GetWorld()->GetAreaAlways(point->GetAreaIdAlways());
CGameArea::EOcclusionState occState =
area->IsPostConstructed() ? area->GetOcclusionState() : CGameArea::EOcclusionState::Occluded;
if (occState != CGameArea::EOcclusionState::Visible)
continue;
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
float t = 0.f;
if (point->GetUniqueId() == x1dc_grapplePoint0)
t = x1e0_grapplePoint0T;
else if (point->GetUniqueId() == x1de_grapplePoint1)
t = x1e4_grapplePoint1T;
if (std::fabs(t) < 0.00001f)
DrawGrapplePoint(*point, t, mgr, rot, true);
}
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
} else {
TCastToConstPtr<CScriptGrapplePoint> point0 = mgr.GetObjectById(x1dc_grapplePoint0);
TCastToConstPtr<CScriptGrapplePoint> point1 = mgr.GetObjectById(x1de_grapplePoint1);
for (int i = 0; i < 2; ++i) {
const CScriptGrapplePoint* point = i == 0 ? point0.GetPtr() : point1.GetPtr();
float t = i == 0 ? x1e0_grapplePoint0T : x1e4_grapplePoint1T;
if (point)
DrawGrapplePoint(*point, t, mgr, rot, false);
}
}
}
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CCompoundTargetReticle::DrawCurrLockOnGroup(const zeus::CMatrix3f& rot, const CStateManager& mgr) const {
if (x28_noDrawTicks > 0)
return;
if (x1e0_grapplePoint0T + x1e4_grapplePoint1T > 0 || x10c_currGroupInterp.GetFactor() == 0.f)
return;
float lockBreakAlpha = x10c_currGroupInterp.GetFactor();
float visorFactor = mgr.GetPlayerState()->GetVisorTransitionFactor();
bool lockConfirm = false;
bool lockReticule = false;
switch (x20_prevState) {
case EReticleState::Combat:
lockConfirm = true;
lockReticule = true;
break;
case EReticleState::Scan:
lockConfirm = true;
break;
default:
break;
}
zeus::CMatrix3f lockBreakXf;
zeus constexpr refactor and thermal visor fixes
2019-02-24 07:15:54 +00:00
zeus::CColor lockBreakColor = zeus::skClear;
New code style refactor
2018-12-08 05:30:43 +00:00
if (IsDamageOrbit(mgr.GetPlayer().GetOrbitRequest()) && x14c_currGroupB.GetFactor() == 0.f) {
zeus::CMatrix3f lockBreakRM;
for (int i = 0; i < 4; ++i) {
int a = rand() % 9;
auto b = std::div(a, 3);
lockBreakRM[b.rem][b.quot] += rand() / float(RAND_MAX) - 0.5f;
}
lockBreakXf = lockBreakRM.transposed();
if (x10c_currGroupInterp.GetFactor() > 0.8f)
lockBreakColor = zeus::CColor(1.f, (x10c_currGroupInterp.GetFactor() - 0.8f) * 0.3f / 0.2f);
lockBreakAlpha = x10c_currGroupInterp.GetFactor() > 0.75f
? 1.f
: std::max(0.f, (x10c_currGroupInterp.GetFactor() - 0.55f) / 0.2f);
}
if (lockConfirm && x4c_lockConfirm.IsLoaded()) {
zeus::CMatrix3f scale(CalculateClampedScale(x10c_currGroupInterp.GetTargetPositionWorld(),
x10c_currGroupInterp.GetRadiusWorld(),
x10c_currGroupInterp.GetMinViewportClampScale() *
g_tweakTargeting->GetLockConfirmClampMin(),
g_tweakTargeting->GetLockConfirmClampMax(), mgr) *
g_tweakTargeting->GetLockConfirmScale() / x10c_currGroupInterp.GetFactor());
zeus::CTransform modelXf(lockBreakXf * (rot * zeus::CMatrix3f::RotateY(x1ec_seekerAngle) * scale),
x10c_currGroupInterp.GetTargetPositionWorld());
CGraphics::SetModelMatrix(modelXf);
zeus::CColor color = g_tweakTargeting->GetLockConfirmColor();
color.a() *= lockBreakAlpha;
CModelFlags flags(7, 0, 0, lockBreakColor + color);
x4c_lockConfirm->Draw(flags);
}
if (lockReticule) {
if (x58_targetFlower.IsLoaded()) {
zeus::CMatrix3f scale(CalculateClampedScale(x10c_currGroupInterp.GetTargetPositionWorld(),
x10c_currGroupInterp.GetRadiusWorld(),
x10c_currGroupInterp.GetMinViewportClampScale() *
g_tweakTargeting->GetTargetFlowerClampMin(),
g_tweakTargeting->GetTargetFlowerClampMax(), mgr) *
g_tweakTargeting->GetTargetFlowerScale() / lockBreakAlpha);
zeus::CTransform modelXf(lockBreakXf * (rot * zeus::CMatrix3f::RotateY(x1f0_xrayRetAngle) * scale),
x10c_currGroupInterp.GetTargetPositionWorld());
CGraphics::SetModelMatrix(modelXf);
zeus::CColor color = g_tweakTargeting->GetTargetFlowerColor();
color.a() *= lockBreakAlpha * visorFactor;
CModelFlags flags(7, 0, 0, lockBreakColor + color);
x58_targetFlower->Draw(flags);
}
if (x1f8_missileBracketTimer != 0.f && x64_missileBracket.IsLoaded()) {
float t = std::fabs((x1fc_missileBracketScaleTimer - 0.5f * g_tweakTargeting->GetMissileBracketScaleDuration()) /
0.5f * g_tweakTargeting->GetMissileBracketScaleDuration());
float tscale = ((1.f - t) * g_tweakTargeting->GetMissileBracketScaleEnd() +
t * g_tweakTargeting->GetMissileBracketScaleStart());
zeus::CMatrix3f scale(CalculateClampedScale(x10c_currGroupInterp.GetTargetPositionWorld(),
x10c_currGroupInterp.GetRadiusWorld(),
x10c_currGroupInterp.GetMinViewportClampScale() *
g_tweakTargeting->GetMissileBracketClampMin(),
g_tweakTargeting->GetMissileBracketClampMax(), mgr) *
std::fabs(x1f8_missileBracketTimer) / g_tweakTargeting->GetMissileBracketDuration() *
tscale / x10c_currGroupInterp.GetFactor());
for (int i = 0; i < 4; ++i) {
zeus::CTransform modelXf(
lockBreakXf * rot * zeus::CMatrix3f(zeus::CVector3f{i < 2 ? 1.f : -1.f, 1.f, i & 0x1 ? 1.f : -1.f}) * scale,
x10c_currGroupInterp.GetTargetPositionWorld());
CGraphics::SetModelMatrix(modelXf);
zeus::CColor color = g_tweakTargeting->GetMissileBracketColor();
color.a() *= lockBreakAlpha * visorFactor;
CModelFlags flags(7, 0, 0, lockBreakColor + color);
x64_missileBracket->Draw(flags);
}
}
zeus::CMatrix3f scale(CalculateClampedScale(x10c_currGroupInterp.GetTargetPositionWorld(),
x10c_currGroupInterp.GetRadiusWorld(),
x10c_currGroupInterp.GetMinViewportClampScale() *
g_tweakTargeting->GetChargeGaugeClampMin(),
g_tweakTargeting->GetChargeGaugeClampMax(), mgr) *
1.f / x10c_currGroupInterp.GetFactor() * g_tweakTargeting->GetOuterBeamSquaresScale());
zeus::CMatrix3f outerBeamXf = rot * scale;
for (int i = 0; i < 9; ++i) {
const SOuterItemInfo& info = xe0_outerBeamIconSquares[i];
if (info.x0_model.IsLoaded()) {
zeus::CTransform modelXf(lockBreakXf * outerBeamXf * zeus::CMatrix3f::RotateY(info.x10_rotAng),
Finish CCompoundTargetReticle
2017-10-30 03:37:20 +00:00
x10c_currGroupInterp.GetTargetPositionWorld());
CGraphics::SetModelMatrix(modelXf);
New code style refactor
2018-12-08 05:30:43 +00:00
zeus::CColor color = g_tweakTargeting->GetOuterBeamSquareColor();
color.a() *= lockBreakAlpha * visorFactor;
Finish CCompoundTargetReticle
2017-10-30 03:37:20 +00:00
CModelFlags flags(7, 0, 0, lockBreakColor + color);
New code style refactor
2018-12-08 05:30:43 +00:00
info.x0_model->Draw(flags);
}
}
if (xc4_chargeGauge.x0_model.IsLoaded()) {
zeus::CMatrix3f scale(CalculateClampedScale(x10c_currGroupInterp.GetTargetPositionWorld(),
x10c_currGroupInterp.GetRadiusWorld(),
x10c_currGroupInterp.GetMinViewportClampScale() *
g_tweakTargeting->GetChargeGaugeClampMin(),
g_tweakTargeting->GetChargeGaugeClampMax(), mgr) *
g_tweakTargeting->GetChargeGaugeScale() / x10c_currGroupInterp.GetFactor());
zeus::CMatrix3f chargeGaugeXf = rot * scale * zeus::CMatrix3f::RotateY(xc4_chargeGauge.x10_rotAng);
float pulseT = std::fabs(std::fmod(CGraphics::GetSecondsMod900(), g_tweakTargeting->GetChargeGaugePulsePeriod()));
zeus::CColor gaugeColor =
zeus::CColor::lerp(g_tweakTargeting->GetChargeGaugeNonFullColor(),
zeus::CColor::lerp(g_tweakTargeting->GetChargeGaugePulseColorHigh(),
g_tweakTargeting->GetChargeGaugePulseColorLow(),
pulseT < 0.5f * g_tweakTargeting->GetChargeGaugePulsePeriod()
? pulseT / (0.5f * g_tweakTargeting->GetChargeGaugePulsePeriod())
: (g_tweakTargeting->GetChargeGaugePulsePeriod() - pulseT) /
(0.5f * g_tweakTargeting->GetChargeGaugePulsePeriod())),
x214_fullChargeFadeTimer / g_tweakTargeting->GetFullChargeFadeDuration());
zeus::CTransform modelXf(lockBreakXf * chargeGaugeXf, x10c_currGroupInterp.GetTargetPositionWorld());
CGraphics::SetModelMatrix(modelXf);
zeus::CColor color = gaugeColor;
color.a() *= lockBreakAlpha * visorFactor;
CModelFlags flags(7, 0, 0, lockBreakColor + color);
xc4_chargeGauge.x0_model->Draw(flags);
if (xa0_chargeTickFirst.IsLoaded()) {
const CPlayerGun* gun = mgr.GetPlayer().GetPlayerGun();
int numTicks =
int(g_tweakTargeting->GetChargeTickCount() * (gun->IsCharging() ? gun->GetChargeBeamFactor() : 0.f));
for (int i = 0; i < numTicks; ++i) {
CModelFlags flags(7, 0, 0, lockBreakColor + color);
xa0_chargeTickFirst->Draw(flags);
modelXf.rotateLocalY(g_tweakTargeting->GetChargeTickAnglePitch());
CGraphics::SetModelMatrix(modelXf);
Finish CCompoundTargetReticle
2017-10-30 03:37:20 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
Finish CCompoundTargetReticle
2017-10-30 03:37:20 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
if (x208_lockonTimer > 0.f && x70_innerBeamIcon.IsLoaded()) {
const zeus::CColor* iconColor;
switch (x200_beam) {
case CPlayerState::EBeamId::Power:
iconColor = &g_tweakTargeting->GetInnerBeamColorPower();
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
break;
New code style refactor
2018-12-08 05:30:43 +00:00
case CPlayerState::EBeamId::Ice:
iconColor = &g_tweakTargeting->GetInnerBeamColorIce();
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
break;
New code style refactor
2018-12-08 05:30:43 +00:00
case CPlayerState::EBeamId::Wave:
iconColor = &g_tweakTargeting->GetInnerBeamColorWave();
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
break;
New code style refactor
2018-12-08 05:30:43 +00:00
default:
iconColor = &g_tweakTargeting->GetInnerBeamColorPlasma();
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
break;
New code style refactor
2018-12-08 05:30:43 +00:00
}
zeus::CMatrix3f scale(
CalculateClampedScale(x10c_currGroupInterp.GetTargetPositionWorld(), x10c_currGroupInterp.GetRadiusWorld(),
x10c_currGroupInterp.GetMinViewportClampScale() *
g_tweakTargeting->GetInnerBeamClampMin(),
g_tweakTargeting->GetInnerBeamClampMax(), mgr) *
g_tweakTargeting->GetInnerBeamScale() * (x208_lockonTimer / g_tweakTargeting->GetLockonDuration()) /
x10c_currGroupInterp.GetFactor());
zeus::CTransform modelXf(lockBreakXf * rot * scale, x10c_currGroupInterp.GetTargetPositionWorld());
CGraphics::SetModelMatrix(modelXf);
zeus::CColor color = *iconColor;
color.a() *= lockBreakAlpha * visorFactor;
CModelFlags flags(7, 0, 0, lockBreakColor + color);
x70_innerBeamIcon->Draw(flags);
}
if (x210_lockFireTimer > 0.f && x7c_lockFire.IsLoaded()) {
zeus::CMatrix3f scale(CalculateClampedScale(x10c_currGroupInterp.GetTargetPositionWorld(),
x10c_currGroupInterp.GetRadiusWorld(),
x10c_currGroupInterp.GetMinViewportClampScale() *
g_tweakTargeting->GetLockFireClampMin(),
g_tweakTargeting->GetLockFireClampMax(), mgr) *
g_tweakTargeting->GetLockFireScale() / x10c_currGroupInterp.GetFactor());
zeus::CTransform modelXf(lockBreakXf * rot * scale * zeus::CMatrix3f::RotateY(x1f0_xrayRetAngle),
x10c_currGroupInterp.GetTargetPositionWorld());
CGraphics::SetModelMatrix(modelXf);
zeus::CColor color = g_tweakTargeting->GetLockFireColor();
color.a() *= visorFactor * lockBreakAlpha * (x210_lockFireTimer / g_tweakTargeting->GetLockFireDuration());
CModelFlags flags(7, 0, 0, lockBreakColor + color);
x7c_lockFire->Draw(flags);
}
if (x208_lockonTimer > 0.f && x88_lockDagger.IsLoaded()) {
float t = std::fabs((x210_lockFireTimer - 0.5f * g_tweakTargeting->GetLockFireDuration()) / 0.5f *
g_tweakTargeting->GetLockFireDuration());
float tscale =
((1.f - t) * g_tweakTargeting->GetLockDaggerScaleEnd() + t * g_tweakTargeting->GetLockDaggerScaleStart());
zeus::CMatrix3f scale(
CalculateClampedScale(x10c_currGroupInterp.GetTargetPositionWorld(), x10c_currGroupInterp.GetRadiusWorld(),
x10c_currGroupInterp.GetMinViewportClampScale() *
g_tweakTargeting->GetLockDaggerClampMin(),
g_tweakTargeting->GetLockDaggerClampMax(), mgr) *
tscale * (x208_lockonTimer / g_tweakTargeting->GetLockonDuration()) / x10c_currGroupInterp.GetFactor());
zeus::CMatrix3f lockDaggerXf = rot * scale;
for (int i = 0; i < 3; ++i) {
float ang;
switch (i) {
case 0:
ang = g_tweakTargeting->GetLockDaggerAngle0();
break;
case 1:
ang = g_tweakTargeting->GetLockDaggerAngle1();
break;
default:
ang = g_tweakTargeting->GetLockDaggerAngle2();
break;
}
zeus::CTransform modelXf(lockBreakXf * lockDaggerXf * zeus::CMatrix3f::RotateY(ang),
x10c_currGroupInterp.GetTargetPositionWorld());
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
CGraphics::SetModelMatrix(modelXf);
New code style refactor
2018-12-08 05:30:43 +00:00
zeus::CColor color = g_tweakTargeting->GetLockDaggerColor();
color.a() *= visorFactor * lockBreakAlpha;
CModelFlags flags(7, 0, 0, lockBreakColor + color);
x88_lockDagger->Draw(flags);
}
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
}
}
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
CCompoundTargetingReticle: Remove mutable specifier on m_scanRetRenderer This can be trivially resolved by dropping const qualifiers on the necessary member functions.
2020-04-10 01:28:50 +00:00
void CCompoundTargetReticle::DrawNextLockOnGroup(const zeus::CMatrix3f& rot, const CStateManager& mgr) {
if (x28_noDrawTicks > 0) {
New code style refactor
2018-12-08 05:30:43 +00:00
return;
CCompoundTargetingReticle: Remove mutable specifier on m_scanRetRenderer This can be trivially resolved by dropping const qualifiers on the necessary member functions.
2020-04-10 01:28:50 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
zeus::CVector3f position = x174_nextGroupInterp.GetTargetPositionWorld();
float visorFactor = mgr.GetPlayerState()->GetVisorTransitionFactor();
bool scanRet = false;
bool xrayRet = false;
bool thermalRet = false;
switch (x20_prevState) {
case EReticleState::Scan:
scanRet = true;
break;
case EReticleState::XRay:
xrayRet = true;
break;
case EReticleState::Thermal:
thermalRet = true;
break;
default:
break;
}
if (!xrayRet && x174_nextGroupInterp.GetFactor() > 0.f && x40_seeker.IsLoaded()) {
zeus::CMatrix3f scale(
CalculateClampedScale(position, x174_nextGroupInterp.GetRadiusWorld(),
x174_nextGroupInterp.GetMinViewportClampScale() * g_tweakTargeting->GetSeekerClampMin(),
g_tweakTargeting->GetSeekerClampMax(), mgr) *
g_tweakTargeting->GetSeekerScale());
zeus::CTransform modelXf(rot * zeus::CMatrix3f::RotateY(x1ec_seekerAngle) * scale,
x174_nextGroupInterp.GetTargetPositionWorld());
CGraphics::SetModelMatrix(modelXf);
zeus::CColor color = g_tweakTargeting->GetSeekerColor();
color.a() *= x174_nextGroupInterp.GetFactor();
CModelFlags flags(7, 0, 0, color);
x40_seeker->Draw(flags);
}
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (xrayRet && xac_xrayRetRing.IsLoaded()) {
zeus::CMatrix3f scale(
CalculateClampedScale(position, x174_nextGroupInterp.GetRadiusWorld(),
x174_nextGroupInterp.GetMinViewportClampScale() * g_tweakTargeting->GetReticuleClampMin(),
g_tweakTargeting->GetReticuleClampMax(), mgr) *
g_tweakTargeting->GetReticuleScale());
zeus::CTransform modelXf(rot * scale * zeus::CMatrix3f::RotateY(x1f0_xrayRetAngle),
x174_nextGroupInterp.GetTargetPositionWorld());
CGraphics::SetModelMatrix(modelXf);
zeus::CColor color = g_tweakTargeting->GetXRayRetRingColor();
color.a() *= visorFactor;
CModelFlags flags(7, 0, 0, color);
xac_xrayRetRing->Draw(flags);
}
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (thermalRet && xb8_thermalReticle.IsLoaded()) {
zeus::CMatrix3f scale(
CalculateClampedScale(position, x174_nextGroupInterp.GetRadiusWorld(),
x174_nextGroupInterp.GetMinViewportClampScale() * g_tweakTargeting->GetReticuleClampMin(),
g_tweakTargeting->GetReticuleClampMax(), mgr) *
g_tweakTargeting->GetReticuleScale());
zeus::CTransform modelXf(rot * scale, x174_nextGroupInterp.GetTargetPositionWorld());
CGraphics::SetModelMatrix(modelXf);
zeus::CColor color = g_tweakTargeting->GetThermalReticuleColor();
color.a() *= visorFactor;
CModelFlags flags(7, 0, 0, color);
xb8_thermalReticle->Draw(flags);
}
if (scanRet && visorFactor > 0.f) {
float factor = visorFactor * x174_nextGroupInterp.GetFactor();
zeus::CMatrix3f scale(CalculateClampedScale(position, x174_nextGroupInterp.GetRadiusWorld(),
x174_nextGroupInterp.GetMinViewportClampScale() *
g_tweakTargeting->GetScanTargetClampMin(),
g_tweakTargeting->GetScanTargetClampMax(), mgr) *
(1.f / factor));
zeus::CTransform modelXf(rot * scale, x174_nextGroupInterp.GetTargetPositionWorld());
CGraphics::SetModelMatrix(modelXf);
// compare, GX_LESS, no update
float alpha = 0.5f * factor;
zeus::CColor color = g_tweakGuiColors->GetScanReticuleColor();
color.a() *= alpha;
for (int i = 0; i < 2; ++i) {
float lineWidth = i ? 2.5f : 1.f;
auto& rend = *m_scanRetRenderer.m_lineRenderers[i];
rend.Reset();
rend.AddVertex({-0.5f, 0.f, 0.f}, color, lineWidth);
rend.AddVertex({-20.5f, 0.f, 0.f}, color, lineWidth);
rend.AddVertex({0.5f, 0.f, 0.f}, color, lineWidth);
rend.AddVertex({20.5f, 0.f, 0.f}, color, lineWidth);
rend.AddVertex({0.f, 0.f, -0.5f}, color, lineWidth);
rend.AddVertex({0.f, 0.f, -20.5f}, color, lineWidth);
rend.AddVertex({0.f, 0.f, 0.5f}, color, lineWidth);
rend.AddVertex({0.f, 0.f, 20.5f}, color, lineWidth);
rend.Render();
for (int j = 0; j < 4; ++j) {
float xSign = j < 2 ? -1.f : 1.f;
float zSign = (j & 0x1) ? -1.f : 1.f;
// begin line strip
auto& rend = *m_scanRetRenderer.m_stripRenderers[i][j];
rend.Reset();
rend.AddVertex({0.5f * xSign, 0.f, 0.1f * zSign}, color, lineWidth);
rend.AddVertex({0.5f * xSign, 0.f, 0.35f * zSign}, color, lineWidth);
rend.AddVertex({0.35f * xSign, 0.f, 0.5f * zSign}, color, lineWidth);
rend.AddVertex({0.1f * xSign, 0.f, 0.5f * zSign}, color, lineWidth);
rend.Render();
}
}
}
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CCompoundTargetReticle::DrawOrbitZoneGroup(const zeus::CMatrix3f& rot, const CStateManager& mgr) const {
if (x28_noDrawTicks > 0)
return;
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
if (x1e8_crosshairsScale > 0.f && x34_crosshairs.IsLoaded()) {
CGraphics::SetModelMatrix(zeus::CTransform(rot, xf4_targetPos) * zeus::CTransform::Scale(x1e8_crosshairsScale));
zeus::CColor color = g_tweakTargeting->GetCrosshairsColor();
color.a() *= x1e8_crosshairsScale;
CModelFlags flags(7, 0, 0, color);
x34_crosshairs->Draw(flags);
}
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CCompoundTargetReticle::UpdateTargetParameters(CTargetReticleRenderState& state, const CStateManager& mgr) {
if (auto act = TCastToConstPtr<CActor>(mgr.GetAllObjectList().GetObjectById(state.GetTargetId()))) {
state.SetRadiusWorld(CalculateRadiusWorld(*act, mgr));
state.SetTargetPositionWorld(CalculatePositionWorld(*act, mgr));
} else if (state.GetIsOrbitZoneIdlePosition()) {
state.SetRadiusWorld(1.f);
state.SetTargetPositionWorld((x20_prevState == EReticleState::XRay || x20_prevState == EReticleState::Thermal)
? x100_laggingTargetPos
: xf4_targetPos);
}
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
float CCompoundTargetReticle::CalculateRadiusWorld(const CActor& act, const CStateManager& mgr) const {
auto tb = act.GetTouchBounds();
zeus::CAABox aabb = tb ? *tb : zeus::CAABox(act.GetAimPosition(mgr, 0.f), act.GetAimPosition(mgr, 0.f));
float radius;
zeus::CVector3f delta = aabb.max - aabb.min;
switch (g_tweakTargeting->GetTargetRadiusMode()) {
case 0: {
radius = std::min(delta.x(), std::min(delta.y(), delta.z())) * 0.5f;
break;
}
case 1: {
radius = std::max(delta.x(), std::max(delta.y(), delta.z())) * 0.5f;
break;
}
default: {
radius = (delta.x() + delta.y() + delta.z()) / 6.f;
break;
}
}
return radius > 0.f ? radius : 1.f;
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
zeus::CVector3f CCompoundTargetReticle::CalculatePositionWorld(const CActor& act, const CStateManager& mgr) const {
if (x20_prevState == EReticleState::Scan)
return act.GetOrbitPosition(mgr);
return act.GetAimPosition(mgr, 0.f);
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
zeus::CVector3f CCompoundTargetReticle::CalculateOrbitZoneReticlePosition(const CStateManager& mgr, bool lag) const {
const CGameCamera* curCam = mgr.GetCameraManager()->GetCurrentCamera(mgr);
float distMul =
224.f / float(g_tweakPlayer->GetOrbitScreenBoxHalfExtentY(0)) / std::tan(zeus::degToRad(0.5f * curCam->GetFov()));
zeus::CTransform camXf = mgr.GetCameraManager()->GetCurrentCameraTransform(mgr);
zeus::CVector3f lookDir = camXf.basis[1];
if (lag)
lookDir = x10_laggingOrientation.transform(lookDir);
return lookDir * distMul + camXf.origin;
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
bool CCompoundTargetReticle::IsGrappleTarget(TUniqueId uid, const CStateManager& mgr) const {
return TCastToConstPtr<CScriptGrapplePoint>(mgr.GetAllObjectList().GetObjectById(uid)).operator bool();
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
Work on CPlayerVisor
2017-05-30 03:45:31 +00:00
New code style refactor
2018-12-08 05:30:43 +00:00
float CCompoundTargetReticle::CalculateClampedScale(const zeus::CVector3f& pos, float scale, float clampMin,
float clampMax, const CStateManager& mgr) {
const CGameCamera* cam = mgr.GetCameraManager()->GetCurrentCamera(mgr);
mgr.GetCameraManager()->GetCurrentCameraTransform(mgr);
zeus::CVector3f viewPos = cam->GetTransform().transposeRotate(pos - cam->GetTransform().origin);
viewPos = zeus::CVector3f(viewPos.x(), viewPos.z(), -viewPos.y());
float realX = cam->GetPerspectiveMatrix().multiplyOneOverW(viewPos).x();
float offsetX = cam->GetPerspectiveMatrix().multiplyOneOverW(viewPos + zeus::CVector3f(scale, 0.f, 0.f)).x();
float unclampedX = (offsetX - realX) * 640;
return zeus::clamp(clampMin, unclampedX, clampMax) / unclampedX * scale;
Work on CPlayerVisor
2017-05-30 03:45:31 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
void CCompoundTargetReticle::Touch() {
if (x34_crosshairs.IsLoaded())
x34_crosshairs->Touch(0);
if (x40_seeker.IsLoaded())
x40_seeker->Touch(0);
if (x4c_lockConfirm.IsLoaded())
x4c_lockConfirm->Touch(0);
if (x58_targetFlower.IsLoaded())
x58_targetFlower->Touch(0);
if (x64_missileBracket.IsLoaded())
x64_missileBracket->Touch(0);
if (x70_innerBeamIcon.IsLoaded())
x70_innerBeamIcon->Touch(0);
if (x7c_lockFire.IsLoaded())
x7c_lockFire->Touch(0);
if (x88_lockDagger.IsLoaded())
x88_lockDagger->Touch(0);
if (x94_grapple.IsLoaded())
x94_grapple->Touch(0);
if (xa0_chargeTickFirst.IsLoaded())
xa0_chargeTickFirst->Touch(0);
if (xac_xrayRetRing.IsLoaded())
xac_xrayRetRing->Touch(0);
if (xb8_thermalReticle.IsLoaded())
xb8_thermalReticle->Touch(0);
if (xc4_chargeGauge.x0_model.IsLoaded())
xc4_chargeGauge.x0_model->Touch(0);
for (SOuterItemInfo& info : xe0_outerBeamIconSquares)
if (info.x0_model.IsLoaded())
info.x0_model->Touch(0);
Implement most of CTargetingManager
2017-10-29 06:21:52 +00:00
}
New code style refactor
2018-12-08 05:30:43 +00:00
} // namespace urde