第一次提交

This commit is contained in:
不明不惑
2026-03-03 01:23:02 +08:00
commit 3e434877e8
1053 changed files with 102411 additions and 0 deletions

View File

@@ -0,0 +1,478 @@
// // Copyright 2025 https://yuewu.dev/en All Rights Reserved.
//
//
// #include "Movement/GMS_CharacterMovementComponent.h"
//
// #include "GMS_CharacterMovementSystemComponent.h"
// #include "GMS_MovementSystemComponent.h"
// #include "GameFramework/Character.h"
// #include "Locomotions/GMS_MainAnimInstance.h"
// #include "Settings/GMS_SettingObjectLibrary.h"
// #include "Utility/GMS_Constants.h"
// #include "Utility/GMS_Log.h"
// #include "Utility/GMS_Math.h"
//
// #include UE_INLINE_GENERATED_CPP_BY_NAME(GMS_CharacterMovementComponent)
//
// UGMS_CharacterMovementComponent::UGMS_CharacterMovementComponent(const FObjectInitializer& ObjectInitializer): Super(ObjectInitializer)
// {
// }
//
// void UGMS_CharacterMovementComponent::InitializeComponent()
// {
// Super::InitializeComponent();
// if (CharacterOwner)
// {
// UGMS_CharacterMovementSystemComponent* NewMovementSystem = CharacterOwner->FindComponentByClass<UGMS_CharacterMovementSystemComponent>();
// if (NewMovementSystem == nullptr)
// {
// GMS_CLOG(Warning, "Requires GMS Character Movement System Component to function!")
// return;
// }
// MovementSystem = NewMovementSystem;
// }
// }
//
// void UGMS_CharacterMovementComponent::SetUpdatedComponent(USceneComponent* NewUpdatedComponent)
// {
// Super::SetUpdatedComponent(NewUpdatedComponent);
// if (CharacterOwner)
// {
// UGMS_CharacterMovementSystemComponent* NewMovementSystem = CharacterOwner->FindComponentByClass<UGMS_CharacterMovementSystemComponent>();
// if (NewMovementSystem == nullptr)
// {
// GMS_CLOG(Warning, "Requires GMS Character Movement System Component to function!")
// return;
// }
// MovementSystem = NewMovementSystem;
// }
// }
//
// bool UGMS_CharacterMovementComponent::HasValidData() const
// {
// return Super::HasValidData() && IsValid(MovementSystem);
// }
//
// void UGMS_CharacterMovementComponent::TickCharacterPose(float DeltaTime)
// {
// Super::TickCharacterPose(DeltaTime);
// }
//
// void UGMS_CharacterMovementComponent::PhysicsRotation(float DeltaTime)
// {
// if (bUseNativeRotation)
// {
// Super::PhysicsRotation(DeltaTime);
// }
// else
// {
// GMS_PhysicsRotation(DeltaTime);
// }
// }
//
// void UGMS_CharacterMovementComponent::GMS_TurnToDesiredRotation(const FRotator& CurrentRotation, FRotator DesiredRotation, FRotator DeltaRot)
// {
// const bool bWantsToBeVertical = ShouldRemainVertical();
//
// if (bWantsToBeVertical)
// {
// if (HasCustomGravity())
// {
// FRotator GravityRelativeDesiredRotation = (GetWorldToGravityTransform() * DesiredRotation.Quaternion()).Rotator();
// GravityRelativeDesiredRotation.Pitch = 0.f;
// GravityRelativeDesiredRotation.Yaw = FRotator::NormalizeAxis(GravityRelativeDesiredRotation.Yaw);
// GravityRelativeDesiredRotation.Roll = 0.f;
// DesiredRotation = (GetWorldToGravityTransform() * GravityRelativeDesiredRotation.Quaternion()).Rotator();
// }
// else
// {
// DesiredRotation.Pitch = 0.f;
// DesiredRotation.Yaw = FRotator::NormalizeAxis(DesiredRotation.Yaw);
// DesiredRotation.Roll = 0.f;
// }
// }
// else
// {
// DesiredRotation.Normalize();
// }
//
// // Accumulate a desired new rotation.
// constexpr float AngleTolerance = 1e-3f;
//
// if (!CurrentRotation.Equals(DesiredRotation, AngleTolerance))
// {
// // If we'd be prevented from becoming vertical, override the non-yaw rotation rates to allow the character to snap upright
//
// static bool PreventNonVerticalOrientationBlock = true;
// if (PreventNonVerticalOrientationBlock && bWantsToBeVertical)
// {
// if (FMath::IsNearlyZero(DeltaRot.Pitch))
// {
// DeltaRot.Pitch = 360.0;
// }
// if (FMath::IsNearlyZero(DeltaRot.Roll))
// {
// DeltaRot.Roll = 360.0;
// }
// }
//
// if (HasCustomGravity())
// {
// FRotator GravityRelativeCurrentRotation = (GetWorldToGravityTransform() * CurrentRotation.Quaternion()).Rotator();
// FRotator GravityRelativeDesiredRotation = (GetWorldToGravityTransform() * DesiredRotation.Quaternion()).Rotator();
//
// // PITCH
// if (!FMath::IsNearlyEqual(GravityRelativeCurrentRotation.Pitch, GravityRelativeDesiredRotation.Pitch, AngleTolerance))
// {
// // GravityRelativeDesiredRotation.Pitch = UGMS_Math::ExponentialDecayAngle(GravityRelativeCurrentRotation.Pitch,
// // GravityRelativeDesiredRotation.Pitch, DeltaTime, DeltaRot.Pitch);
// GravityRelativeDesiredRotation.Pitch = FMath::FixedTurn(GravityRelativeCurrentRotation.Pitch, GravityRelativeDesiredRotation.Pitch, DeltaRot.Pitch);
// }
//
// // YAW
// if (!FMath::IsNearlyEqual(GravityRelativeCurrentRotation.Yaw, GravityRelativeDesiredRotation.Yaw, AngleTolerance))
// {
// // GravityRelativeDesiredRotation.Yaw = UGMS_Math::ExponentialDecayAngle(GravityRelativeCurrentRotation.Yaw,
// // GravityRelativeDesiredRotation.Yaw, DeltaTime, DeltaRot.Yaw);
// GravityRelativeDesiredRotation.Yaw = FMath::FixedTurn(GravityRelativeCurrentRotation.Yaw, GravityRelativeDesiredRotation.Yaw, DeltaRot.Yaw);
// }
//
// // ROLL
// if (!FMath::IsNearlyEqual(GravityRelativeCurrentRotation.Roll, GravityRelativeDesiredRotation.Roll, AngleTolerance))
// {
// // GravityRelativeDesiredRotation.Roll = UGMS_Math::ExponentialDecayAngle(GravityRelativeCurrentRotation.Roll,
// // GravityRelativeDesiredRotation.Roll, DeltaTime, DeltaRot.Roll);
// GravityRelativeDesiredRotation.Roll = FMath::FixedTurn(GravityRelativeCurrentRotation.Roll, GravityRelativeDesiredRotation.Roll, DeltaRot.Roll);
// }
//
// DesiredRotation = (GetWorldToGravityTransform() * GravityRelativeDesiredRotation.Quaternion()).Rotator();
// }
// else
// {
// // PITCH
// if (!FMath::IsNearlyEqual(CurrentRotation.Pitch, DesiredRotation.Pitch, AngleTolerance))
// {
// // DesiredRotation.Pitch = UGMS_Math::ExponentialDecayAngle(CurrentRotation.Pitch, DesiredRotation.Pitch, DeltaTime, DeltaRot.Pitch);
// DesiredRotation.Pitch = FMath::FixedTurn(CurrentRotation.Pitch, DesiredRotation.Pitch, DeltaRot.Pitch);
// }
//
// // YAW
// if (!FMath::IsNearlyEqual(CurrentRotation.Yaw, DesiredRotation.Yaw, AngleTolerance))
// {
// // DesiredRotation.Yaw = UGMS_Math::ExponentialDecayAngle(CurrentRotation.Yaw, DesiredRotation.Yaw, DeltaTime, DeltaRot.Yaw);
// DesiredRotation.Yaw = FMath::FixedTurn(CurrentRotation.Yaw, DesiredRotation.Yaw, DeltaRot.Yaw);
// }
//
// // ROLL
// if (!FMath::IsNearlyEqual(CurrentRotation.Roll, DesiredRotation.Roll, AngleTolerance))
// {
// // DesiredRotation.Roll = UGMS_Math::ExponentialDecayAngle(CurrentRotation.Roll, DesiredRotation.Roll, DeltaTime, DeltaRot.Yaw);
// DesiredRotation.Roll = FMath::FixedTurn(CurrentRotation.Roll, DesiredRotation.Roll, DeltaRot.Roll);
// }
// }
//
// // Set the new rotation.
// DesiredRotation.DiagnosticCheckNaN(TEXT("CharacterMovementComponent::PhysicsRotation(): DesiredRotation"));
// MoveUpdatedComponent(FVector::ZeroVector, DesiredRotation, /*bSweep*/ false);
// }
// }
//
// void UGMS_CharacterMovementComponent::GMS_TurnToDesiredRotationWithRotationRate(const FRotator& CurrentRotation, FRotator DesiredRotation, FRotator DeltaRot)
// {
// const bool bWantsToBeVertical = ShouldRemainVertical();
//
// if (bWantsToBeVertical)
// {
// if (HasCustomGravity())
// {
// FRotator GravityRelativeDesiredRotation = (GetWorldToGravityTransform() * DesiredRotation.Quaternion()).Rotator();
// GravityRelativeDesiredRotation.Pitch = 0.f;
// GravityRelativeDesiredRotation.Yaw = FRotator::NormalizeAxis(GravityRelativeDesiredRotation.Yaw);
// GravityRelativeDesiredRotation.Roll = 0.f;
// DesiredRotation = (GetWorldToGravityTransform() * GravityRelativeDesiredRotation.Quaternion()).Rotator();
// }
// else
// {
// DesiredRotation.Pitch = 0.f;
// DesiredRotation.Yaw = FRotator::NormalizeAxis(DesiredRotation.Yaw);
// DesiredRotation.Roll = 0.f;
// }
// }
// else
// {
// DesiredRotation.Normalize();
// }
//
// // Accumulate a desired new rotation.
// constexpr float AngleTolerance = 1e-3f;
//
// if (!CurrentRotation.Equals(DesiredRotation, AngleTolerance))
// {
// // If we'd be prevented from becoming vertical, override the non-yaw rotation rates to allow the character to snap upright
//
// static bool PreventNonVerticalOrientationBlock = true;
// if (PreventNonVerticalOrientationBlock && bWantsToBeVertical)
// {
// if (FMath::IsNearlyZero(DeltaRot.Pitch))
// {
// DeltaRot.Pitch = 360.0;
// }
// if (FMath::IsNearlyZero(DeltaRot.Roll))
// {
// DeltaRot.Roll = 360.0;
// }
// }
//
// if (HasCustomGravity())
// {
// FRotator GravityRelativeCurrentRotation = (GetWorldToGravityTransform() * CurrentRotation.Quaternion()).Rotator();
// FRotator GravityRelativeDesiredRotation = (GetWorldToGravityTransform() * DesiredRotation.Quaternion()).Rotator();
//
// // PITCH
// if (!FMath::IsNearlyEqual(GravityRelativeCurrentRotation.Pitch, GravityRelativeDesiredRotation.Pitch, AngleTolerance))
// {
// GravityRelativeDesiredRotation.Pitch = FMath::FixedTurn(GravityRelativeCurrentRotation.Pitch, GravityRelativeDesiredRotation.Pitch, DeltaRot.Pitch);
// }
//
// // YAW
// if (!FMath::IsNearlyEqual(GravityRelativeCurrentRotation.Yaw, GravityRelativeDesiredRotation.Yaw, AngleTolerance))
// {
// GravityRelativeDesiredRotation.Yaw = FMath::FixedTurn(GravityRelativeCurrentRotation.Yaw, GravityRelativeDesiredRotation.Yaw, DeltaRot.Yaw);
// }
//
// // ROLL
// if (!FMath::IsNearlyEqual(GravityRelativeCurrentRotation.Roll, GravityRelativeDesiredRotation.Roll, AngleTolerance))
// {
// GravityRelativeDesiredRotation.Roll = FMath::FixedTurn(GravityRelativeCurrentRotation.Roll, GravityRelativeDesiredRotation.Roll, DeltaRot.Roll);
// }
//
// DesiredRotation = (GetWorldToGravityTransform() * GravityRelativeDesiredRotation.Quaternion()).Rotator();
// }
// else
// {
// // PITCH
// if (!FMath::IsNearlyEqual(CurrentRotation.Pitch, DesiredRotation.Pitch, AngleTolerance))
// {
// DesiredRotation.Pitch = FMath::FixedTurn(CurrentRotation.Pitch, DesiredRotation.Pitch, DeltaRot.Pitch);
// }
//
// // YAW
// if (!FMath::IsNearlyEqual(CurrentRotation.Yaw, DesiredRotation.Yaw, AngleTolerance))
// {
// DesiredRotation.Yaw = FMath::FixedTurn(CurrentRotation.Yaw, DesiredRotation.Yaw, DeltaRot.Yaw);
// }
//
// // ROLL
// if (!FMath::IsNearlyEqual(CurrentRotation.Roll, DesiredRotation.Roll, AngleTolerance))
// {
// DesiredRotation.Roll = FMath::FixedTurn(CurrentRotation.Roll, DesiredRotation.Roll, DeltaRot.Roll);
// }
// }
//
// // Set the new rotation.
// DesiredRotation.DiagnosticCheckNaN(TEXT("CharacterMovementComponent::PhysicsRotation(): DesiredRotation"));
// MoveUpdatedComponent(FVector::ZeroVector, DesiredRotation, /*bSweep*/ false);
// }
// }
//
// void UGMS_CharacterMovementComponent::GMS_PhysicsRotation_Implementation(float DeltaTime)
// {
// if (!(bOrientRotationToMovement || bUseControllerDesiredRotation))
// {
// return;
// }
//
// if (!HasValidData() || (!CharacterOwner->Controller && !bRunPhysicsWithNoController))
// {
// return;
// }
//
// FRotator CurrentRotation = UpdatedComponent->GetComponentRotation(); // Normalized
// CurrentRotation.DiagnosticCheckNaN(TEXT("CharacterMovementComponent::PhysicsRotation(): CurrentRotation"));
//
// FRotator DeltaRot = GetDeltaRotation(DeltaTime);
// DeltaRot.DiagnosticCheckNaN(TEXT("CharacterMovementComponent::PhysicsRotation(): GetDeltaRotation"));
//
// FRotator DesiredRotation = CurrentRotation;
// if (bOrientRotationToMovement)
// {
// DesiredRotation = GMS_ComputeOrientToDesiredMovementRotation(CurrentRotation, DeltaTime, DeltaRot);
// }
// else if (CharacterOwner->Controller && bUseControllerDesiredRotation)
// {
// DesiredRotation = CharacterOwner->Controller->GetDesiredRotation();
// // DesiredRotation = MovementSystem->GetViewState().Rotation;
// }
// else if (!CharacterOwner->Controller && bRunPhysicsWithNoController && bUseControllerDesiredRotation)
// {
// if (AController* ControllerOwner = Cast<AController>(CharacterOwner->GetOwner()))
// {
// DesiredRotation = ControllerOwner->GetDesiredRotation();
// }
// }
// else
// {
// return;
// }
//
// const bool bWantsToBeVertical = ShouldRemainVertical();
//
// if (bWantsToBeVertical)
// {
// if (HasCustomGravity())
// {
// FRotator GravityRelativeDesiredRotation = (GetGravityToWorldTransform() * DesiredRotation.Quaternion()).Rotator();
// GravityRelativeDesiredRotation.Pitch = 0.f;
// GravityRelativeDesiredRotation.Yaw = FRotator::NormalizeAxis(GravityRelativeDesiredRotation.Yaw);
// GravityRelativeDesiredRotation.Roll = 0.f;
// DesiredRotation = (GetWorldToGravityTransform() * GravityRelativeDesiredRotation.Quaternion()).Rotator();
// }
// else
// {
// DesiredRotation.Pitch = 0.f;
// DesiredRotation.Yaw = FRotator::NormalizeAxis(DesiredRotation.Yaw);
// DesiredRotation.Roll = 0.f;
// }
// }
// else
// {
// DesiredRotation.Normalize();
// }
//
// // Accumulate a desired new rotation.
// constexpr float AngleTolerance = 1e-3f;
//
// if (!CurrentRotation.Equals(DesiredRotation, AngleTolerance))
// {
// // If we'd be prevented from becoming vertical, override the non-yaw rotation rates to allow the character to snap upright
// if (true && bWantsToBeVertical)
// {
// if (FMath::IsNearlyZero(DeltaRot.Pitch))
// {
// DeltaRot.Pitch = 360.0;
// }
// if (FMath::IsNearlyZero(DeltaRot.Roll))
// {
// DeltaRot.Roll = 360.0;
// }
// }
//
// if (HasCustomGravity())
// {
// FRotator GravityRelativeCurrentRotation = (GetGravityToWorldTransform() * CurrentRotation.Quaternion()).Rotator();
// FRotator GravityRelativeDesiredRotation = (GetGravityToWorldTransform() * DesiredRotation.Quaternion()).Rotator();
//
// // PITCH
// if (!FMath::IsNearlyEqual(GravityRelativeCurrentRotation.Pitch, GravityRelativeDesiredRotation.Pitch, AngleTolerance))
// {
// GravityRelativeDesiredRotation.Pitch = FMath::FixedTurn(GravityRelativeCurrentRotation.Pitch, GravityRelativeDesiredRotation.Pitch, DeltaRot.Pitch);
// }
//
// // YAW
// if (!FMath::IsNearlyEqual(GravityRelativeCurrentRotation.Yaw, GravityRelativeDesiredRotation.Yaw, AngleTolerance))
// {
// GravityRelativeDesiredRotation.Yaw = FMath::FixedTurn(GravityRelativeCurrentRotation.Yaw, GravityRelativeDesiredRotation.Yaw, DeltaRot.Yaw);
// }
//
// // ROLL
// if (!FMath::IsNearlyEqual(GravityRelativeCurrentRotation.Roll, GravityRelativeDesiredRotation.Roll, AngleTolerance))
// {
// GravityRelativeDesiredRotation.Roll = FMath::FixedTurn(GravityRelativeCurrentRotation.Roll, GravityRelativeDesiredRotation.Roll, DeltaRot.Roll);
// }
//
// DesiredRotation = (GetWorldToGravityTransform() * GravityRelativeDesiredRotation.Quaternion()).Rotator();
// }
// else
// {
// // PITCH
// if (!FMath::IsNearlyEqual(CurrentRotation.Pitch, DesiredRotation.Pitch, AngleTolerance))
// {
// DesiredRotation.Pitch = FMath::FixedTurn(CurrentRotation.Pitch, DesiredRotation.Pitch, DeltaRot.Pitch);
// }
//
// // YAW
// if (!FMath::IsNearlyEqual(CurrentRotation.Yaw, DesiredRotation.Yaw, AngleTolerance))
// {
// DesiredRotation.Yaw = FMath::FixedTurn(CurrentRotation.Yaw, DesiredRotation.Yaw, DeltaRot.Yaw);
// }
//
// // ROLL
// if (!FMath::IsNearlyEqual(CurrentRotation.Roll, DesiredRotation.Roll, AngleTolerance))
// {
// DesiredRotation.Roll = FMath::FixedTurn(CurrentRotation.Roll, DesiredRotation.Roll, DeltaRot.Roll);
// }
// }
//
// // Set the new rotation.
// DesiredRotation.DiagnosticCheckNaN(TEXT("CharacterMovementComponent::PhysicsRotation(): DesiredRotation"));
// MoveUpdatedComponent(FVector::ZeroVector, DesiredRotation, /*bSweep*/ false);
// }
// }
//
// FRotator UGMS_CharacterMovementComponent::GMS_ComputeOrientToDesiredViewRotation_Implementation(const FRotator& CurrentRotation, float DeltaTime, FRotator& DeltaRotation) const
// {
// check(MovementSystem->GetControlSetting());
//
// bool bMoving = MovementSystem->GetLocomotionState().bMoving;
//
// DeltaRotation.Yaw = DeltaRotation.Pitch = DeltaRotation.Roll = MovementSystem->GetControlSetting()->ViewDirectionSetting.Get().RotationInterpolationSpeed;
//
// float DeltaYawAngle{0.0f};
// if (!bMoving && HasAnimationRotationDeltaYawAngle(DeltaTime, DeltaYawAngle))
// {
// auto NewRotation{CurrentRotation};
// NewRotation.Yaw += DeltaYawAngle;
// DeltaRotation.Yaw = -1;
// return NewRotation;
// }
//
// FRotator ControllerDesiredRotation = CharacterOwner->Controller->GetDesiredRotation();
//
// if (const FGMS_ViewDirectionSetting_Default* Setting = MovementSystem->GetControlSetting()->ViewDirectionSetting.GetPtr<FGMS_ViewDirectionSetting_Default>())
// {
// if (bMoving || Setting->bEnableRotationWhenNotMoving)
// {
// auto NewRotation{CurrentRotation};
// NewRotation.Yaw = ControllerDesiredRotation.Yaw;
// return NewRotation;
// }
// return CurrentRotation;
// }
//
// if (const FGMS_ViewDirectionSetting_Aiming* Setting = MovementSystem->GetControlSetting()->ViewDirectionSetting.GetPtr<FGMS_ViewDirectionSetting_Aiming>())
// {
// if (!bMoving && Setting->bEnableRotationWhenNotMoving)
// {
// auto NewRotation{CurrentRotation};
// NewRotation.Yaw = ControllerDesiredRotation.Yaw;
// return NewRotation;
// }
// }
//
// return CurrentRotation;
// }
//
//
// bool UGMS_CharacterMovementComponent::HasAnimationRotationDeltaYawAngle_Implementation(float DeltaTime, float& OutDeltaYawAngle) const
// {
// UAnimInstance* AnimInstance = CharacterOwner->GetMesh()->GetAnimInstance();
// if (UGMS_MainAnimInstance* AnimInst = Cast<UGMS_MainAnimInstance>(AnimInstance))
// {
// if (AnimInst->GetOffsetRootBoneRotationMode() != EOffsetRootBoneMode::Release)
// {
// return false;
// }
// }
//
// const float CurveValue = AnimInstance->GetCurveValue(UGMS_Constants::RotationYawSpeedCurveName());
//
// OutDeltaYawAngle = CurveValue * DeltaTime;
//
// return FMath::Abs(OutDeltaYawAngle) > UE_SMALL_NUMBER;
// }
//
//
// FRotator UGMS_CharacterMovementComponent::GMS_ComputeOrientToDesiredMovementRotation_Implementation(const FRotator& CurrentRotation, float DeltaTime, FRotator& DeltaRotation) const
// {
// return Super::ComputeOrientToMovementRotation(CurrentRotation, DeltaTime, DeltaRotation);
// }