AxioDL/metaforce
2
0
Fork 0
mirror of https://github.com/AxioDL/metaforce.git synced 2025-12-15 06:46:08 +00:00
Code Issues Projects Releases Wiki Activity

Implement most of CTargetingManager

Browse Source
This commit is contained in:
Jack Andersen
2017-10-28 20:21:52 -10:00
parent bb10aa9844
commit 6eff4f2e01
13 changed files with 943 additions and 122 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
Runtime/GuiSys/CCompoundTargetReticle.hpp
View File

@@ -1,43 +1,53 @@
#ifndef __CCOMPOUNDTARGETRETICLE_HPP__
#define __CCOMPOUNDTARGETRETICLE_HPP__
#include <Runtime/CPlayerState.hpp>
#include "RetroTypes.hpp"
#include "zeus/CQuaternion.hpp"
#include "CToken.hpp"
#include "Graphics/CLineRenderer.hpp"
namespace urde
{
class CActor;
class CModel;
class CStateManager;
class CScriptGrapplePoint;
class CTargetReticleRenderState
{
TUniqueId x0_target;
float x4_;
zeus::CVector3f x8_;
float x14_;
float x18_;
bool x1c_;
float x4_radiusWorld;
zeus::CVector3f x8_positionWorld;
float x14_factor;
float x18_minVpClampScale;
bool x1c_orbitZoneIdlePosition;
public:
static const CTargetReticleRenderState skZeroRenderState;
CTargetReticleRenderState(TUniqueId, float, const zeus::CVector3f&, float, float, bool);
void SetTargetId(TUniqueId);
void SetFactor(float);
void SetIsOrbitZoneIdlePosition(bool);
float GetMinViewportClampScale() const;
float GetFactor() const;
float GetRadiusWorld() const;
const zeus::CVector3f& GetTargetPositionWorld() const;
bool GetIsOrbitZoneIdlePosition() const;
void SetTargetPositionWorld(const zeus::CVector3f&);
void SetRadiusWorld(float);
TUniqueId GetTargetId() const;
static void InterpolateWithClamp(const CTargetReticleRenderState&, CTargetReticleRenderState&,
const CTargetReticleRenderState&, float);
float SetMinViewportClampScale(float);
CTargetReticleRenderState(TUniqueId target, float radiusWorld,
const zeus::CVector3f& positionWorld, float factor,
float minVpClampScale, bool orbitZoneIdlePosition)
: x0_target(target), x4_radiusWorld(radiusWorld), x8_positionWorld(positionWorld),
x14_factor(factor), x18_minVpClampScale(minVpClampScale),
x1c_orbitZoneIdlePosition(orbitZoneIdlePosition)
{}
void SetTargetId(TUniqueId id) { x0_target = id; }
void SetFactor(float f) { x14_factor = f; }
void SetIsOrbitZoneIdlePosition(bool b) { x1c_orbitZoneIdlePosition = b; }
float GetMinViewportClampScale() const { return x18_minVpClampScale; }
float GetFactor() const { return x14_factor; }
float GetRadiusWorld() const { return x4_radiusWorld; }
const zeus::CVector3f& GetTargetPositionWorld() const { return x8_positionWorld; }
bool GetIsOrbitZoneIdlePosition() const { return x1c_orbitZoneIdlePosition; }
void SetTargetPositionWorld(const zeus::CVector3f& pos) { x8_positionWorld = pos; }
void SetRadiusWorld(float r) { x4_radiusWorld = r; }
TUniqueId GetTargetId() const { return x0_target; }
void SetMinViewportClampScale(float s) { x18_minVpClampScale = s; }
static void InterpolateWithClamp(const CTargetReticleRenderState& a, CTargetReticleRenderState& out,
const CTargetReticleRenderState& b, float t);
};
class CCompoundTargetReticle
@@ -45,7 +55,7 @@ class CCompoundTargetReticle
public:
struct SOuterItemInfo
{
TToken<CModel> x0_;
TCachedToken<CModel> x0_model;
float xc_ = 0.f;
float x10_ = 0.f;
float x14_ = 0.f;
@@ -55,6 +65,16 @@ public:
private:
enum class EReticleState
{
Combat,
Scan,
XRay,
Thermal,
Four,
Unspecified
};
static constexpr const char* skCrosshairsReticleAssetName = "CMDL_Crosshairs";
static constexpr const char* skOrbitZoneReticleAssetName = "CMDL_OrbitZone";
static constexpr const char* skSeekerAssetName = "CMDL_Seeker";
@@ -71,31 +91,31 @@ private:
static constexpr const char* skXRayRingModelName = "CMDL_XRayRetRing";
static constexpr const char* skThermalReticleAssetName = "CMDL_ThermalRet";
static constexpr const char* skOrbitPointAssetName = "CMDL_OrbitPoint";
zeus::CQuaternion x0_;
zeus::CQuaternion x10_;
u32 x20_ = 5;
u32 x24_ = 5;
u32 x28_ = 0;
zeus::CQuaternion x0_leadingOrientation;
zeus::CQuaternion x10_laggingOrientation;
EReticleState x20_prevState = EReticleState::Unspecified;
EReticleState x24_nextState = EReticleState::Unspecified;
mutable u32 x28_noDrawTicks = 0;
float x2c_overshootOffsetHalf;
float x30_premultOvershootOffset;
TToken<CModel> x34_crosshairs;
TToken<CModel> x40_seeker;
TToken<CModel> x4c_lockConfirm;
TToken<CModel> x58_targetFlower;
TToken<CModel> x64_missileBracket;
TToken<CModel> x70_innerBeamIcon;
TToken<CModel> x7c_lockFire;
TToken<CModel> x88_lockDagger;
TToken<CModel> x94_grapple;
TToken<CModel> xa0_chargeTickFirst;
TToken<CModel> xac_xrayRetRing;
TToken<CModel> xb8_thermalReticle;
TCachedToken<CModel> x34_crosshairs;
TCachedToken<CModel> x40_seeker;
TCachedToken<CModel> x4c_lockConfirm;
TCachedToken<CModel> x58_targetFlower;
TCachedToken<CModel> x64_missileBracket;
TCachedToken<CModel> x70_innerBeamIcon;
TCachedToken<CModel> x7c_lockFire;
TCachedToken<CModel> x88_lockDagger;
TCachedToken<CModel> x94_grapple;
TCachedToken<CModel> xa0_chargeTickFirst;
TCachedToken<CModel> xac_xrayRetRing;
TCachedToken<CModel> xb8_thermalReticle;
SOuterItemInfo xc4_chargeGauge;
std::vector<SOuterItemInfo> xe0_outerBeamIconSquares;
TUniqueId xf0_;
TUniqueId xf2_;
zeus::CVector3f xf4_;
zeus::CVector3f x100_;
zeus::CVector3f xf4_targetPos;
zeus::CVector3f x100_laggingTargetPos;
CTargetReticleRenderState x10c_ = CTargetReticleRenderState::skZeroRenderState;
CTargetReticleRenderState x12c_ = CTargetReticleRenderState::skZeroRenderState;
CTargetReticleRenderState x14c_ = CTargetReticleRenderState::skZeroRenderState;
@@ -106,50 +126,64 @@ private:
CTargetReticleRenderState x1b4_ = CTargetReticleRenderState::skZeroRenderState;
float x1d4_ = 0.f;
float x1d8_ = 0.f;
TUniqueId x1dc_ = kInvalidUniqueId;
TUniqueId x1de_ = kInvalidUniqueId;
float x1e0_ = 0.f;
float x1e4_ = 0.f;
float x1e8_ = 0.f;
float x1ec_ = 0.f;
float x1f0_ = 0.f;
u8 x1f4_ = 0;
TUniqueId x1dc_grapplePoint0 = kInvalidUniqueId;
TUniqueId x1de_grapplePoint1 = kInvalidUniqueId;
float x1e0_grapplePoint0T = 0.f;
float x1e4_grapplePoint1T = 0.f;
float x1e8_crosshairsScale = 0.f;
float x1ec_seekerAngle = 0.f;
float x1f0_xrayRetAngle = 0.f;
bool x1f4_missileActive = false;
float x1f8_ = 0.f;
float x1fc_ = 0.f;
u32 x200_ = 0;
CPlayerState::EBeamId x200_beam = CPlayerState::EBeamId::Power;
float x204_ = 0.f;
float x208_;
float x20c_ = 0.f;
float x210_ = 0.f;
float x214_ = 0.f;
u8 x218_ = 0;
u8 x219_ = 0;
u8 x21a_ = 0;
bool x218_beamShot = false;
bool x219_missileShot = false;
bool x21a_fullyCharged = false;
u8 x21b_ = 0;
u32 x21c_;
u32 x220_;
u32 x228_;
struct SScanReticuleRenderer
{
boo::GraphicsDataToken m_token;
std::experimental::optional<CLineRenderer> m_lineRenderers[2];
std::experimental::optional<CLineRenderer> m_stripRenderers[2][4];
SScanReticuleRenderer();
};
mutable SScanReticuleRenderer m_scanRetRenderer;
void DrawGrapplePoint(const CScriptGrapplePoint& point, float t, const CStateManager& mgr,
const zeus::CMatrix3f& rot, bool zEqual) const;
public:
CCompoundTargetReticle(const CStateManager&);
void SetLeadingOrientation(const zeus::CQuaternion&);
void SetLeadingOrientation(const zeus::CQuaternion& o) { x0_leadingOrientation = o; }
bool CheckLoadComplete() { return true; }
void GetDesiredReticleState(const CStateManager&) const;
EReticleState GetDesiredReticleState(const CStateManager&) const;
void Update(float, const CStateManager&);
void UpdateCurrLockOnGroup(float, const CStateManager&);
void UpdateUpdateNextLockOnGroup(float, const CStateManager&);
void UpdateNextLockOnGroup(float, const CStateManager&);
void UpdateOrbitZoneGroup(float, const CStateManager&);
void Draw(const CStateManager&) const;
void DrawCurrLockOnGroup(const CStateManager&) const;
void DrawNextLockOnGroup(const CStateManager&) const;
void DrawOrbitZoneGroup(const CStateManager&) const;
void Draw(const CStateManager&, bool hideLockon) const;
void DrawGrappleGroup(const zeus::CMatrix3f& rot, const CStateManager&, bool) const;
void DrawCurrLockOnGroup(const zeus::CMatrix3f& rot, const CStateManager&) const;
void DrawNextLockOnGroup(const zeus::CMatrix3f& rot, const CStateManager&) const;
void DrawOrbitZoneGroup(const zeus::CMatrix3f& rot, const CStateManager&) const;
void UpdateTargetParameters(CTargetReticleRenderState&, const CStateManager&);
float CalculateRadiusWorld(const CActor&, const CStateManager&) const;
zeus::CVector3f CalculatePositionWorld(const CActor&, const CStateManager&) const;
zeus::CVector3f CalculateOrbitZoneReticlePosition(const CStateManager&) const;
zeus::CVector3f CalculateOrbitZoneReticlePosition(const CStateManager& mgr, bool lag) const;
bool IsGrappleTarget(TUniqueId, const CStateManager&) const;
static float CalculateClampedScale(const zeus::CVector3f&, float, float, float, const CStateManager&);
void Touch() const;
void Touch();
};
}