mirror of https://github.com/AxioDL/metaforce.git
599 lines
22 KiB
C++
599 lines
22 KiB
C++
#include "Runtime/Weapon/CGrappleArm.hpp"
|
|
|
|
#include "Runtime/CDependencyGroup.hpp"
|
|
#include "Runtime/CSimplePool.hpp"
|
|
#include "Runtime/GameGlobalObjects.hpp"
|
|
#include "Runtime/Camera/CGameCamera.hpp"
|
|
#include "Runtime/Graphics/CSkinnedModel.hpp"
|
|
#include "Runtime/Graphics/CVertexMorphEffect.hpp"
|
|
#include "Runtime/Particle/CElementGen.hpp"
|
|
#include "Runtime/World/CPlayer.hpp"
|
|
|
|
#include "TCastTo.hpp" // Generated file, do not modify include path
|
|
|
|
namespace urde {
|
|
|
|
float CGrappleArm::g_GrappleBeamAnglePhaseDelta = 0.875f;
|
|
float CGrappleArm::g_GrappleBeamXWaveAmplitude = 0.25f;
|
|
float CGrappleArm::g_GrappleBeamZWaveAmplitude = 0.125f;
|
|
float CGrappleArm::g_GrappleBeamSpeed = 5.f;
|
|
|
|
CGrappleArm::CGrappleArm(const zeus::CVector3f& scale)
|
|
: x0_grappleArmModel(CAnimRes(g_tweakGunRes->x8_grappleArm, 0, scale, 41, false))
|
|
, xa0_grappleGearModel(CStaticRes(NWeaponTypes::get_asset_id_from_name("GrappleGear"), scale))
|
|
, xec_grapNoz1Model(CStaticRes(NWeaponTypes::get_asset_id_from_name("GrapNoz1"), scale))
|
|
, x138_grapNoz2Model(CStaticRes(NWeaponTypes::get_asset_id_from_name("GrapNoz2"), scale))
|
|
, x184_grappleArm(g_SimplePool->GetObj(SObjectTag{FOURCC('ANCS'), g_tweakGunRes->x8_grappleArm}))
|
|
, x31c_scale(scale)
|
|
, x354_grappleSegmentDesc(g_SimplePool->GetObj(SObjectTag{FOURCC('PART'), g_tweakGunRes->xb4_grappleSegment}))
|
|
, x360_grappleClawDesc(g_SimplePool->GetObj(SObjectTag{FOURCC('PART'), g_tweakGunRes->xb8_grappleClaw}))
|
|
, x36c_grappleHitDesc(g_SimplePool->GetObj(SObjectTag{FOURCC('PART'), g_tweakGunRes->xbc_grappleHit}))
|
|
, x378_grappleMuzzleDesc(g_SimplePool->GetObj(SObjectTag{FOURCC('PART'), g_tweakGunRes->xc0_grappleMuzzle}))
|
|
, x384_grappleSwooshDesc(g_SimplePool->GetObj(SObjectTag{FOURCC('SWHC'), g_tweakGunRes->xc4_grappleSwoosh}))
|
|
, x390_grappleSegmentGen(std::make_unique<CElementGen>(x354_grappleSegmentDesc))
|
|
, x394_grappleClawGen(std::make_unique<CElementGen>(x360_grappleClawDesc))
|
|
, x398_grappleHitGen(std::make_unique<CElementGen>(x36c_grappleHitDesc))
|
|
, x39c_grappleMuzzleGen(std::make_unique<CElementGen>(x378_grappleMuzzleDesc))
|
|
, x3a0_grappleSwooshGen(std::make_unique<CParticleSwoosh>(x384_grappleSwooshDesc, 0))
|
|
, x3a4_rainSplashGenerator(std::make_unique<CRainSplashGenerator>(scale, 20, 2, 0.f, 0.125f)) {
|
|
x0_grappleArmModel->SetSortThermal(true);
|
|
xa0_grappleGearModel.SetSortThermal(true);
|
|
xec_grapNoz1Model.SetSortThermal(true);
|
|
x138_grapNoz2Model.SetSortThermal(true);
|
|
|
|
g_GrappleBeamAnglePhaseDelta = g_tweakPlayer->GetGrappleBeamAnglePhaseDelta();
|
|
g_GrappleBeamXWaveAmplitude = g_tweakPlayer->GetGrappleBeamXWaveAmplitude();
|
|
g_GrappleBeamZWaveAmplitude = g_tweakPlayer->GetGrappleBeamZWaveAmplitude();
|
|
g_GrappleBeamSpeed = g_tweakPlayer->GetGrappleBeamSpeed();
|
|
|
|
x39c_grappleMuzzleGen->SetParticleEmission(false);
|
|
x390_grappleSegmentGen->SetParticleEmission(false);
|
|
x3a0_grappleSwooshGen->DoGrappleWarmup();
|
|
|
|
BuildSuitDependencyList();
|
|
LoadAnimations();
|
|
}
|
|
|
|
static const char* skDependencyNames[] = {
|
|
"PowerSuit_DGRP", "GravitySuit_DGRP", "VariaSuit_DGRP", "PhazonSuit_DGRP",
|
|
"FusionSuit_DGRP", "FusionSuitG_DGRP", "FusionSuitV_DGRP", "FusionSuitP_DGRP",
|
|
};
|
|
|
|
void CGrappleArm::FillTokenVector(const std::vector<SObjectTag>& tags, std::vector<CToken>& objects) {
|
|
objects.reserve(tags.size());
|
|
for (const SObjectTag& tag : tags)
|
|
objects.push_back(g_SimplePool->GetObj(tag));
|
|
}
|
|
|
|
void CGrappleArm::BuildSuitDependencyList() {
|
|
x184_grappleArm.Lock();
|
|
for (const char* name : skDependencyNames) {
|
|
TLockedToken<CDependencyGroup> dgrp = g_SimplePool->GetObj(name);
|
|
x19c_suitDeps.emplace_back();
|
|
std::vector<CToken>& depsOut = x19c_suitDeps.back();
|
|
FillTokenVector(dgrp->GetObjectTagVector(), depsOut);
|
|
}
|
|
}
|
|
|
|
void CGrappleArm::LoadAnimations() {
|
|
NWeaponTypes::get_token_vector(*x0_grappleArmModel->GetAnimationData(), 0, 42, x18c_anims, true);
|
|
x0_grappleArmModel = std::nullopt;
|
|
}
|
|
|
|
void CGrappleArm::AsyncLoadSuit(CStateManager& mgr) {
|
|
CPlayerState::EPlayerSuit suit = NWeaponTypes::get_current_suit(mgr);
|
|
if (suit == x3a8_loadedSuit)
|
|
return;
|
|
|
|
x0_grappleArmModel = std::nullopt;
|
|
x3b2_29_suitLoading = true;
|
|
if (x3a8_loadedSuit != CPlayerState::EPlayerSuit::Invalid) {
|
|
NWeaponTypes::unlock_tokens(x19c_suitDeps[int(x3a8_loadedSuit)]);
|
|
x19c_suitDeps[int(x3a8_loadedSuit)].clear();
|
|
}
|
|
|
|
if (suit < CPlayerState::EPlayerSuit::Power || suit > CPlayerState::EPlayerSuit::FusionPhazon)
|
|
x3a8_loadedSuit = CPlayerState::EPlayerSuit::Power;
|
|
else
|
|
x3a8_loadedSuit = suit;
|
|
|
|
NWeaponTypes::lock_tokens(x19c_suitDeps[int(x3a8_loadedSuit)]);
|
|
}
|
|
|
|
void CGrappleArm::ResetAuxParams(bool resetGunController) {
|
|
x3b2_24_active = false;
|
|
x3b2_27_armMoving = false;
|
|
x2e0_auxXf = zeus::CTransform();
|
|
if (resetGunController)
|
|
x328_gunController->Reset();
|
|
}
|
|
|
|
void CGrappleArm::DisconnectGrappleBeam() {
|
|
x394_grappleClawGen->SetParticleEmission(false);
|
|
x3b2_25_beamActive = false;
|
|
GrappleBeamDisconnected();
|
|
}
|
|
|
|
void CGrappleArm::SetAnimState(EArmState state) {
|
|
if (x334_animState == state)
|
|
return;
|
|
|
|
x0_grappleArmModel->GetAnimationData()->EnableLooping(false);
|
|
x3b2_28_isGrappling = true;
|
|
|
|
switch (state) {
|
|
case EArmState::IntoGrapple: {
|
|
ResetAuxParams(true);
|
|
CAnimPlaybackParms parms(0, -1, 1.f, true);
|
|
x0_grappleArmModel->GetAnimationData()->SetAnimation(parms, false);
|
|
x3b2_25_beamActive = false;
|
|
x3b2_24_active = true;
|
|
break;
|
|
}
|
|
case EArmState::IntoGrappleIdle: {
|
|
CAnimPlaybackParms parms(1, -1, 1.f, true);
|
|
x0_grappleArmModel->GetAnimationData()->EnableLooping(true);
|
|
x0_grappleArmModel->GetAnimationData()->SetAnimation(parms, false);
|
|
break;
|
|
}
|
|
case EArmState::FireGrapple: {
|
|
CAnimPlaybackParms parms(2, -1, 1.f, true);
|
|
x0_grappleArmModel->GetAnimationData()->SetAnimation(parms, false);
|
|
break;
|
|
}
|
|
case EArmState::ConnectGrapple: {
|
|
CAnimPlaybackParms parms(3, -1, 1.f, true);
|
|
x0_grappleArmModel->GetAnimationData()->SetAnimation(parms, false);
|
|
break;
|
|
}
|
|
case EArmState::Connected: {
|
|
CAnimPlaybackParms parms(3, -1, 1.f, true);
|
|
x0_grappleArmModel->GetAnimationData()->SetAnimation(parms, false);
|
|
break;
|
|
}
|
|
case EArmState::OutOfGrapple: {
|
|
CAnimPlaybackParms parms(4, -1, 1.f, true);
|
|
x0_grappleArmModel->GetAnimationData()->SetAnimation(parms, false);
|
|
DisconnectGrappleBeam();
|
|
break;
|
|
}
|
|
case EArmState::Done:
|
|
x3b2_28_isGrappling = false;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
x334_animState = state;
|
|
}
|
|
|
|
void CGrappleArm::Activate(bool intoGrapple) {
|
|
SetAnimState(intoGrapple ? EArmState::IntoGrapple : EArmState::OutOfGrapple);
|
|
}
|
|
|
|
void CGrappleArm::GrappleBeamDisconnected() {
|
|
if (x32c_grappleLoopSfx) {
|
|
CSfxManager::SfxStop(x32c_grappleLoopSfx);
|
|
x32c_grappleLoopSfx.reset();
|
|
}
|
|
}
|
|
|
|
void CGrappleArm::GrappleBeamConnected() {
|
|
if (!x32c_grappleLoopSfx)
|
|
x32c_grappleLoopSfx = NWeaponTypes::play_sfx(SFXsam_grapple_lp, false, true, -0.15f);
|
|
}
|
|
|
|
void CGrappleArm::RenderGrappleBeam(const CStateManager& mgr, const zeus::CVector3f& pos) {
|
|
if (x3b2_24_active && !x3b2_29_suitLoading) {
|
|
zeus::CTransform tmpXf = zeus::CTransform::Translate(pos) * x220_xf;
|
|
if (x3b2_25_beamActive) {
|
|
if (x3b2_26_grappleHit)
|
|
x398_grappleHitGen->Render();
|
|
x394_grappleClawGen->Render();
|
|
x3a0_grappleSwooshGen->Render();
|
|
x390_grappleSegmentGen->Render();
|
|
zeus::CTransform backupViewMtx = CGraphics::g_ViewMatrix;
|
|
CGraphics::SetViewPointMatrix(tmpXf.inverse() * backupViewMtx);
|
|
CGraphics::SetModelMatrix(zeus::CTransform());
|
|
x39c_grappleMuzzleGen->Render();
|
|
CGraphics::SetViewPointMatrix(backupViewMtx);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CGrappleArm::TouchModel(const CStateManager& mgr) const {
|
|
if (x3b2_24_active && !x3b2_29_suitLoading) {
|
|
x0_grappleArmModel->Touch(mgr, 0);
|
|
if (x50_grappleArmSkeletonModel)
|
|
x50_grappleArmSkeletonModel->Touch(mgr, 0);
|
|
if (mgr.GetPlayerState()->HasPowerUp(CPlayerState::EItemType::GrappleBeam)) {
|
|
xa0_grappleGearModel.Touch(mgr, 0);
|
|
xec_grapNoz1Model.Touch(mgr, 0);
|
|
x138_grapNoz2Model.Touch(mgr, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CGrappleArm::LoadSuitPoll() {
|
|
if (NWeaponTypes::are_tokens_ready(x19c_suitDeps[int(x3a8_loadedSuit)])) {
|
|
x0_grappleArmModel.emplace(CAnimRes(g_tweakGunRes->x8_grappleArm, int(x3a8_loadedSuit), x31c_scale, 41, false));
|
|
x0_grappleArmModel->SetSortThermal(true);
|
|
x328_gunController = std::make_unique<CGunController>(*x0_grappleArmModel);
|
|
x3b2_29_suitLoading = false;
|
|
}
|
|
}
|
|
|
|
void CGrappleArm::BuildXRayModel() {
|
|
x50_grappleArmSkeletonModel.emplace(CAnimRes(g_tweakGunRes->x8_grappleArm, 8, x31c_scale,
|
|
!x328_gunController ? 41 : x328_gunController->GetCurAnimId(), false));
|
|
x50_grappleArmSkeletonModel->SetSortThermal(true);
|
|
}
|
|
|
|
void CGrappleArm::DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type) {
|
|
switch (type) {
|
|
case EUserEventType::Projectile:
|
|
if (x3b2_27_armMoving)
|
|
return;
|
|
x3b2_25_beamActive = true;
|
|
x398_grappleHitGen = std::make_unique<CElementGen>(x36c_grappleHitDesc);
|
|
x39c_grappleMuzzleGen = std::make_unique<CElementGen>(x378_grappleMuzzleDesc);
|
|
x338_beamT = 0.f;
|
|
x33c_beamDist = 0.f;
|
|
x340_anglePhase = 0.f;
|
|
x344_xAmplitude = g_GrappleBeamXWaveAmplitude;
|
|
x348_zAmplitude = g_GrappleBeamZWaveAmplitude;
|
|
x398_grappleHitGen->SetParticleEmission(false);
|
|
x394_grappleClawGen->SetParticleEmission(true);
|
|
NWeaponTypes::play_sfx(SFXsam_grapple_fire, false, false, -0.15f);
|
|
mgr.GetRumbleManager().Rumble(mgr, ERumbleFxId::PlayerGrappleFire, 1.f, ERumblePriority::Three);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CGrappleArm::DoUserAnimEvents(CStateManager& mgr) {
|
|
zeus::CVector3f armToCam = mgr.GetCameraManager()->GetCurrentCamera(mgr)->GetTranslation() - x220_xf.origin;
|
|
const CAnimData& animData = *x0_grappleArmModel->GetAnimationData();
|
|
for (int i = 0; i < animData.GetPassedSoundPOICount(); ++i) {
|
|
const CSoundPOINode& node = CAnimData::g_SoundPOINodes[i];
|
|
if (node.GetPoiType() != EPOIType::Sound ||
|
|
(node.GetCharacterIndex() != -1 && animData.x204_charIdx != node.GetCharacterIndex()))
|
|
continue;
|
|
NWeaponTypes::do_sound_event(x34c_animSfx, x3ac_pitchBend, false, node.GetSfxId(), node.GetWeight(),
|
|
node.GetFlags(), node.GetFalloff(), node.GetMaxDist(), 0.16f, 1.f, armToCam,
|
|
x220_xf.origin, mgr.GetPlayer().GetAreaIdAlways(), mgr);
|
|
}
|
|
for (int i = 0; i < animData.GetPassedIntPOICount(); ++i) {
|
|
const CInt32POINode& node = CAnimData::g_Int32POINodes[i];
|
|
switch (node.GetPoiType()) {
|
|
case EPOIType::UserEvent:
|
|
DoUserAnimEvent(mgr, node, EUserEventType(node.GetValue()));
|
|
break;
|
|
case EPOIType::SoundInt32:
|
|
if (node.GetCharacterIndex() != -1 && animData.x204_charIdx != node.GetCharacterIndex())
|
|
break;
|
|
NWeaponTypes::do_sound_event(x34c_animSfx, x3ac_pitchBend, false, u32(node.GetValue()), node.GetWeight(),
|
|
node.GetFlags(), 0.1f, 150.f, 0.16f, 1.f, armToCam, x220_xf.origin,
|
|
mgr.GetPlayer().GetAreaIdAlways(), mgr);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CGrappleArm::UpdateArmMovement(float dt, CStateManager& mgr) {
|
|
DoUserAnimEvents(mgr);
|
|
if (x328_gunController->Update(dt, mgr))
|
|
ResetAuxParams(false);
|
|
}
|
|
|
|
void CGrappleArm::UpdateGrappleBeamFx(const zeus::CVector3f& beamGunPos, const zeus::CVector3f& beamAirPos,
|
|
CStateManager& mgr) {
|
|
x394_grappleClawGen->SetTranslation(beamAirPos);
|
|
x390_grappleSegmentGen->SetParticleEmission(true);
|
|
|
|
zeus::CVector3f segmentDelta = beamAirPos - beamGunPos;
|
|
zeus::CVector3f swooshSegmentDelta = segmentDelta * 0.02f;
|
|
int numSegments = int(2.f * segmentDelta.magnitude() + 1.f);
|
|
segmentDelta = (1.f / float(numSegments)) * segmentDelta;
|
|
|
|
zeus::CVector3f segmentPos = beamGunPos;
|
|
zeus::CTransform rotation = x220_xf.getRotation();
|
|
for (int i = 0; i < numSegments; ++i) {
|
|
zeus::CVector3f vec;
|
|
if (i > 0)
|
|
vec = rotation *
|
|
zeus::CVector3f(std::cos(i + x340_anglePhase) * x344_xAmplitude, 0.f, std::sin(float(i)) * x348_zAmplitude);
|
|
x390_grappleSegmentGen->SetTranslation(vec * segmentPos);
|
|
x390_grappleSegmentGen->ForceParticleCreation(1);
|
|
segmentPos += segmentDelta;
|
|
}
|
|
|
|
x390_grappleSegmentGen->SetParticleEmission(false);
|
|
x3a0_grappleSwooshGen->DoGrappleUpdate(beamGunPos, rotation, x340_anglePhase, x344_xAmplitude, x348_zAmplitude,
|
|
swooshSegmentDelta);
|
|
}
|
|
|
|
bool CGrappleArm::UpdateGrappleBeam(float dt, const zeus::CTransform& beamLoc, CStateManager& mgr) {
|
|
bool beamConnected = false;
|
|
if (TCastToConstPtr<CActor> act = mgr.GetObjectById(mgr.GetPlayer().GetOrbitTargetId()))
|
|
x310_grapplePointPos = act->GetTranslation();
|
|
else
|
|
x310_grapplePointPos = x220_xf.origin;
|
|
|
|
zeus::CVector3f beamGunPos = (x220_xf * beamLoc).origin;
|
|
zeus::CVector3f beamAirPos = beamGunPos * (1.f - x338_beamT) + x310_grapplePointPos * x338_beamT;
|
|
|
|
switch (x334_animState) {
|
|
case EArmState::FireGrapple:
|
|
case EArmState::Three: {
|
|
float gunToPointMag = (x310_grapplePointPos - beamGunPos).magnitude();
|
|
if (gunToPointMag > 0.f)
|
|
x338_beamT = x33c_beamDist / gunToPointMag;
|
|
else
|
|
x338_beamT = 1.f;
|
|
float speedMult = mgr.GetPlayer().GetPlayerMovementState() != CPlayer::EPlayerMovementState::OnGround ? 2.f : 1.f;
|
|
x33c_beamDist += speedMult * (dt * g_GrappleBeamSpeed);
|
|
if (x338_beamT >= 1.f) {
|
|
x338_beamT = 1.f;
|
|
beamConnected = true;
|
|
}
|
|
break;
|
|
}
|
|
case EArmState::ConnectGrapple: {
|
|
float delta = 4.f * dt;
|
|
x344_xAmplitude -= delta;
|
|
x348_zAmplitude -= delta;
|
|
if (x344_xAmplitude < 0.f)
|
|
x344_xAmplitude = 0.f;
|
|
if (x348_zAmplitude < 0.f)
|
|
x348_zAmplitude = 0.f;
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (x3b2_25_beamActive) {
|
|
x340_anglePhase += g_GrappleBeamAnglePhaseDelta;
|
|
UpdateGrappleBeamFx(beamGunPos, beamAirPos, mgr);
|
|
x394_grappleClawGen->Update(dt);
|
|
x390_grappleSegmentGen->Update(dt);
|
|
}
|
|
|
|
return beamConnected;
|
|
}
|
|
|
|
void CGrappleArm::UpdateSwingAction(float grappleSwingT, float dt, CStateManager& mgr) {
|
|
if (x3b2_29_suitLoading)
|
|
return;
|
|
|
|
if (x334_animState == EArmState::FireGrapple)
|
|
DoUserAnimEvents(mgr);
|
|
|
|
zeus::CTransform beamLocXf = x0_grappleArmModel->GetScaledLocatorTransform("LGBeam");
|
|
bool grappleConnected = UpdateGrappleBeam(dt, beamLocXf, mgr);
|
|
|
|
if ((grappleSwingT > 0.175f && grappleSwingT < 0.3f) || (grappleSwingT > 0.7f && grappleSwingT < 0.9f)) {
|
|
if (!CSfxManager::IsPlaying(x330_swooshSfx)) {
|
|
x330_swooshSfx = NWeaponTypes::play_sfx(SFXsam_grapple_swoosh, false, false, -0.15f);
|
|
if (x3b0_rumbleHandle != -1)
|
|
mgr.GetRumbleManager().StopRumble(x3b0_rumbleHandle);
|
|
x3b0_rumbleHandle =
|
|
mgr.GetRumbleManager().Rumble(mgr, ERumbleFxId::PlayerGrappleSwoosh, 1.f, ERumblePriority::Three);
|
|
}
|
|
}
|
|
|
|
if (!x0_grappleArmModel->GetAnimationData()->IsAnimTimeRemaining(dt, "Whole Body")) {
|
|
switch (x334_animState) {
|
|
case EArmState::IntoGrapple:
|
|
case EArmState::Seven:
|
|
SetAnimState(EArmState::IntoGrappleIdle);
|
|
break;
|
|
case EArmState::FireGrapple:
|
|
if (grappleConnected) {
|
|
SetAnimState(EArmState::ConnectGrapple);
|
|
x3b2_26_grappleHit = true;
|
|
x398_grappleHitGen->SetParticleEmission(true);
|
|
GrappleBeamConnected();
|
|
if (x3b0_rumbleHandle != -1)
|
|
mgr.GetRumbleManager().StopRumble(x3b0_rumbleHandle);
|
|
}
|
|
break;
|
|
case EArmState::ConnectGrapple:
|
|
if (x344_xAmplitude == 0.f)
|
|
SetAnimState(EArmState::Connected);
|
|
break;
|
|
case EArmState::OutOfGrapple:
|
|
if (x3b0_rumbleHandle != -1)
|
|
mgr.GetRumbleManager().StopRumble(x3b0_rumbleHandle);
|
|
SetAnimState(EArmState::Done);
|
|
x3b2_24_active = false;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (x3b2_25_beamActive) {
|
|
x39c_grappleMuzzleGen->SetTranslation(beamLocXf.origin);
|
|
x39c_grappleMuzzleGen->Update(dt);
|
|
if (x3b2_26_grappleHit) {
|
|
x3b2_26_grappleHit = !x398_grappleHitGen->IsSystemDeletable();
|
|
x398_grappleHitGen->SetTranslation(x310_grapplePointPos);
|
|
x398_grappleHitGen->Update(dt);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CGrappleArm::Update(float grappleSwingT, float dt, CStateManager& mgr) {
|
|
if (!(x3b2_24_active && !x3b2_29_suitLoading)) {
|
|
if (x3b2_29_suitLoading)
|
|
LoadSuitPoll();
|
|
return;
|
|
}
|
|
|
|
if (mgr.GetPlayerState()->GetCurrentVisor() == CPlayerState::EPlayerVisor::XRay) {
|
|
if (!x50_grappleArmSkeletonModel)
|
|
BuildXRayModel();
|
|
} else {
|
|
if (x50_grappleArmSkeletonModel)
|
|
x50_grappleArmSkeletonModel = std::nullopt;
|
|
}
|
|
|
|
float speed = 1.f;
|
|
if (!x3b2_27_armMoving)
|
|
speed = (mgr.GetPlayer().GetPlayerMovementState() != CPlayer::EPlayerMovementState::OnGround &&
|
|
x334_animState != EArmState::OutOfGrapple)
|
|
? 4.f
|
|
: 1.f;
|
|
x0_grappleArmModel->AdvanceAnimation(speed * dt, mgr, kInvalidAreaId, true);
|
|
if (mgr.GetPlayerState()->HasPowerUp(CPlayerState::EItemType::GrappleBeam)) {
|
|
x250_grapLocatorXf = x0_grappleArmModel->GetScaledLocatorTransformDynamic("grapLocator_SDK", nullptr);
|
|
x280_grapNozLoc1Xf = x0_grappleArmModel->GetScaledLocatorTransform("gNozLoc1_SDK");
|
|
x2b0_grapNozLoc2Xf = x0_grappleArmModel->GetScaledLocatorTransform("gNozLoc1_SDK");
|
|
}
|
|
|
|
if (x3b2_27_armMoving)
|
|
UpdateArmMovement(dt, mgr);
|
|
else
|
|
UpdateSwingAction(grappleSwingT, dt, mgr);
|
|
|
|
if (x3a4_rainSplashGenerator)
|
|
x3a4_rainSplashGenerator->Update(dt, mgr);
|
|
}
|
|
|
|
void CGrappleArm::PreRender(const CStateManager& mgr, const zeus::CFrustum& frustum, const zeus::CVector3f& camPos) {
|
|
if (x3b2_24_active && !x3b2_29_suitLoading) {
|
|
x0_grappleArmModel->GetAnimationData()->PreRender();
|
|
if (x50_grappleArmSkeletonModel)
|
|
x50_grappleArmSkeletonModel->GetAnimationData()->PreRender();
|
|
}
|
|
}
|
|
|
|
void CGrappleArm::RenderXRayModel(const CStateManager& mgr, const zeus::CTransform& modelXf,
|
|
const CModelFlags& flags) const {
|
|
CGraphics::SetModelMatrix(modelXf * zeus::CTransform::Scale(x0_grappleArmModel->GetScale()));
|
|
// CGraphics::DisableAllLights();
|
|
// g_Renderer->SetAmbientColor(zeus::skWhite);
|
|
CSkinnedModel& model = const_cast<CSkinnedModel&>(*x50_grappleArmSkeletonModel->GetAnimationData()->GetModelData());
|
|
model.GetModelInst()->ActivateLights({CLight::BuildLocalAmbient({}, zeus::skWhite)});
|
|
const_cast<CGrappleArm*>(this)->x0_grappleArmModel->GetAnimationData()->Render(model, flags, {}, nullptr);
|
|
// g_Renderer->SetAmbientColor(zeus::skWhite);
|
|
// CGraphics::DisableAllLights();
|
|
}
|
|
|
|
void CGrappleArm::PointGenerator(void* ctx, const std::vector<std::pair<zeus::CVector3f, zeus::CVector3f>>& vn) {
|
|
reinterpret_cast<CRainSplashGenerator*>(ctx)->GeneratePoints(vn);
|
|
}
|
|
|
|
void CGrappleArm::Render(const CStateManager& mgr, const zeus::CVector3f& pos, const CModelFlags& flags,
|
|
const CActorLights* lights) const {
|
|
if (x3b2_24_active && !x3b2_29_suitLoading) {
|
|
SCOPED_GRAPHICS_DEBUG_GROUP("CGrappleArm::Render", zeus::skOrange);
|
|
zeus::CTransform modelXf = zeus::CTransform::Translate(pos) * x220_xf * x2e0_auxXf;
|
|
if (x50_grappleArmSkeletonModel)
|
|
RenderXRayModel(mgr, modelXf, flags);
|
|
|
|
CModelFlags useFlags;
|
|
const CActorLights* useLights;
|
|
if (mgr.GetPlayerState()->GetCurrentVisor() == CPlayerState::EPlayerVisor::XRay) {
|
|
useFlags = CModelFlags(5, 0, 3, zeus::CColor(1.f, 0.25f));
|
|
useLights = nullptr;
|
|
} else {
|
|
useFlags = flags;
|
|
useLights = lights;
|
|
}
|
|
|
|
if (x3a4_rainSplashGenerator && x3a4_rainSplashGenerator->IsRaining())
|
|
CSkinnedModel::SetPointGeneratorFunc(x3a4_rainSplashGenerator.get(), PointGenerator);
|
|
|
|
x0_grappleArmModel->Render(mgr, modelXf, useLights, useFlags);
|
|
|
|
if (x3a4_rainSplashGenerator && x3a4_rainSplashGenerator->IsRaining()) {
|
|
CSkinnedModel::ClearPointGeneratorFunc();
|
|
x3a4_rainSplashGenerator->Draw(modelXf);
|
|
}
|
|
|
|
if (mgr.GetPlayerState()->HasPowerUp(CPlayerState::EItemType::GrappleBeam)) {
|
|
xa0_grappleGearModel.Render(mgr, modelXf * x250_grapLocatorXf, useLights, useFlags);
|
|
xec_grapNoz1Model.Render(mgr, modelXf * x280_grapNozLoc1Xf, useLights, useFlags);
|
|
x138_grapNoz2Model.Render(mgr, modelXf * x2b0_grapNozLoc2Xf, useLights, useFlags);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CGrappleArm::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) {
|
|
if (msg == EScriptObjectMessage::Registered)
|
|
AsyncLoadSuit(mgr);
|
|
}
|
|
|
|
void CGrappleArm::EnterStruck(CStateManager& mgr, float angle, bool bigStrike, bool notInFreeLook) {
|
|
if (x3b2_29_suitLoading)
|
|
return;
|
|
|
|
if (x3b2_28_isGrappling) {
|
|
DisconnectGrappleBeam();
|
|
x3b2_28_isGrappling = false;
|
|
}
|
|
|
|
if (!x3b2_27_armMoving) {
|
|
x3b2_24_active = true;
|
|
x3b2_27_armMoving = true;
|
|
x334_animState = EArmState::GunControllerAnimation;
|
|
}
|
|
|
|
x328_gunController->EnterStruck(mgr, angle, bigStrike, notInFreeLook);
|
|
}
|
|
|
|
void CGrappleArm::EnterIdle(CStateManager& mgr) {
|
|
if (x3b2_29_suitLoading)
|
|
return;
|
|
|
|
x328_gunController->EnterIdle(mgr);
|
|
}
|
|
|
|
void CGrappleArm::EnterFidget(CStateManager& mgr, SamusGun::EFidgetType type, s32 gunId, s32 animSet) {
|
|
if (x3b2_29_suitLoading)
|
|
return;
|
|
|
|
x3b2_24_active = true;
|
|
x3b2_27_armMoving = true;
|
|
x334_animState = EArmState::GunControllerAnimation;
|
|
|
|
x328_gunController->EnterFidget(mgr, s32(type), gunId, animSet);
|
|
}
|
|
|
|
void CGrappleArm::EnterFreeLook(s32 gunId, s32 setId, CStateManager& mgr) {
|
|
if (x3b2_29_suitLoading)
|
|
return;
|
|
|
|
x3b2_24_active = true;
|
|
x3b2_27_armMoving = true;
|
|
x334_animState = EArmState::GunControllerAnimation;
|
|
|
|
x328_gunController->EnterFreeLook(mgr, gunId, setId);
|
|
}
|
|
|
|
void CGrappleArm::EnterComboFire(s32 gunId, CStateManager& mgr) {
|
|
if (x3b2_29_suitLoading)
|
|
return;
|
|
|
|
x3b2_24_active = true;
|
|
x3b2_27_armMoving = true;
|
|
x334_animState = EArmState::GunControllerAnimation;
|
|
|
|
x328_gunController->EnterComboFire(mgr, gunId);
|
|
}
|
|
|
|
void CGrappleArm::ReturnToDefault(CStateManager& mgr, float dt, bool setState) {
|
|
if (x3b2_29_suitLoading)
|
|
return;
|
|
|
|
x328_gunController->ReturnToDefault(mgr, dt, setState);
|
|
}
|
|
|
|
} // namespace urde
|