#include <GravityPhysicsVolume.h>

Inheritance diagram for AGravityPhysicsVolume:

Public Member Functions
	AGravityPhysicsVolume (const FObjectInitializer &ObjectInitializer)

virtual void	ActorEnteredVolume (class AActor *Other) override

virtual void	ActorLeavingVolume (class AActor *Other) override

virtual FVector	GetGravity (class USceneComponent *SceneComponent) const

virtual FVector	GetGravityDirection (class USceneComponent *SceneComponent) const

virtual float	GetGravityMagnitude (class USceneComponent *SceneComponent) const

virtual float	GetFinalGravityScale (class USceneComponent *SceneComponent) const

virtual void	K2_SetFixedGravityDirection (const FVector &NewGravityDirection)

virtual void	SetFixedGravityDirection (const FVector &NewFixedGravityDirection)

virtual void	SetSplineTangentGravityDirection (AActor *NewGravityActor)

virtual void	SetPointGravityDirection (const FVector &NewGravityPoint)

virtual void	SetPointGravityDirectionFromActor (AActor *NewGravityActor)

virtual void	SetLineGravityDirection (const FVector &NewGravityLineStart, const FVector &NewGravityLineEnd)

virtual void	SetSegmentGravityDirection (const FVector &NewGravitySegmentStart, const FVector &NewGravitySegmentEnd)

virtual void	SetSplineGravityDirection (AActor *NewGravityActor)

virtual void	K2_SetPlaneGravityDirection (const FVector &NewGravityPlaneBase, const FVector &NewGravityPlaneNormal)

virtual void	SetPlaneGravityDirection (const FVector &NewGravityPlaneBase, const FVector &NewGravityPlaneNormal)

virtual void	SetSplinePlaneGravityDirection (AActor *NewGravityActor)

virtual void	SetBoxGravityDirection (const FVector &NewGravityBoxOrigin, const FVector &NewGravityBoxExtent)

virtual void	SetBoxGravityDirectionFromActor (AActor *NewGravityActor)

virtual void	SetCollisionGravityDirection (AActor *NewGravityActor)

virtual float	GetGravityScale () const

virtual void	SetGravityScale (const float NewGravityScale)

Public Attributes
FVector	CharacterFallVelocity

Protected Member Functions
virtual void	BeginPlay () override

virtual void	Tick (float DeltaTime) override

Protected Attributes
bool	bDebuggingMode = false

TArray< TObjectPtr< AActor > >	TrackedActors

TArray< class IALSCharacterInterface * >	TrackedCharacters

EGravityDirectionMode	GravityDirectionMode

FVector	GravityVectorA

FVector	GravityVectorB

TObjectPtr< AActor >	GravityActor

float	GravityScale

Constructor & Destructor Documentation

◆ AGravityPhysicsVolume()

AGravityPhysicsVolume::AGravityPhysicsVolume ( const FObjectInitializer & ObjectInitializer )

    : Super(ObjectInitializer)
{
#if WITH_EDITORONLY_DATA
    // Create and configure attached text render component
    TextRenderComponent = CreateEditorOnlyDefaultSubobject<UTextRenderComponent>(TextRenderComponentName);
    if (!IsRunningCommandlet() && TextRenderComponent != nullptr)
    {
        TextRenderComponent->bHiddenInGame = true;
        TextRenderComponent->HorizontalAlignment = EHorizTextAligment::EHTA_Center;
        TextRenderComponent->Text = FText::AsCultureInvariant(TEXT("Gravity Physics Volume"));
        TextRenderComponent->SetUsingAbsoluteRotation(true);
        TextRenderComponent->SetupAttachment(GetBrushComponent());
    }
#endif // WITH_EDITORONLY_DATA
 
    // Change 'tick' configuration
    PrimaryActorTick.bCanEverTick = true;
    PrimaryActorTick.bStartWithTickEnabled = false;
 
    GravityActor = nullptr;
    GravityDirectionMode = EGravityDirectionMode::Fixed;
    GravityScale = 1.0f;
    GravityVectorA = FVector(0.0f, 0.0f, -1.0f);
    GravityVectorB = FVector::ZeroVector;
    CharacterFallVelocity = FVector::ZeroVector;
 
#if WITH_EDITOR
    bDebuggingMode = true;
#endif
 
}

Member Function Documentation

◆ ActorEnteredVolume()

void AGravityPhysicsVolume::ActorEnteredVolume ( class AActor * Other )

overridevirtual

Called when an Actor enters this volume.

Parameters

Other - Actor that entered this volume

{
    UE_LOG(LogTemp, Error, TEXT("Entered Volume"));
    Super::ActorEnteredVolume(Other);
    if(Other != nullptr)
    {
        UE_LOG(LogTemp, Error, TEXT("Actor: %s Entered Gravity"), *Other->GetHumanReadableName());
    }
    // Remove all empty positions of the TrackedActors list
    TrackedActors.RemoveAll([](const AActor* Actor)
    {
        return Actor == nullptr;
    });
 
    // Remove all empty positions of the TrackedCharacters list
    TrackedCharacters.RemoveAll([](const IALSCharacterInterface* Character)
    {
        return Character == nullptr;
    });
 
    if (IsValid(Other))
    {
        IALSCharacterInterface* Character = Cast<IALSCharacterInterface>(Other);
        if(Character != nullptr && Character->GetALSGravityMovementInterface() != nullptr)
        {
            IALSGravityMovementInterface* ALSGravityMovement = Character->GetALSGravityMovementInterface();
            if(ALSGravityMovement == nullptr){return;}
            // Just change gravity settings of Characters
            switch (GravityDirectionMode)
            {
                case EGravityDirectionMode::Fixed:
                {
                    ALSGravityMovement->SetFixedGravityDirection(GravityVectorA);
                    break;
                }
        
                case EGravityDirectionMode::SplineTangent:
                {
                    if(IsValid(GravityActor))
                    {
                        ALSGravityMovement->SetSplineTangentGravityDirection(GravityActor);
                    }
                    else
                    {
                        ALSGravityMovement->SetSplineTangentGravityDirection(this);
                    }
                    break;
                }
        
                case EGravityDirectionMode::Point:
                {
                    if (IsValid(GravityActor))
                    {
                        ALSGravityMovement->SetPointGravityDirectionFromActor(GravityActor);
                    }
                    else
                    {
                        ALSGravityMovement->SetPointGravityDirection(GravityVectorA);
                    }
        
                    break;
                }
        
                case EGravityDirectionMode::Line:
                {
                    ALSGravityMovement->SetLineGravityDirection(GravityVectorA, GravityVectorB);
                    break;
                }
        
                case EGravityDirectionMode::Segment:
                {
                    ALSGravityMovement->SetSegmentGravityDirection(GravityVectorA, GravityVectorB);
                    break;
                }
        
                case EGravityDirectionMode::Spline:
                {
                    if (IsValid(GravityActor))
                    {
                        ALSGravityMovement->SetSplineGravityDirection(GravityActor);
                    }
                    else
                    {
                        ALSGravityMovement->SetSplineGravityDirection(this);
                    }
        
                    break;
                }
        
                case EGravityDirectionMode::Plane:
                {
                    ALSGravityMovement->SetPlaneGravityDirection(GravityVectorA, GravityVectorB);
                    break;
                }
        
                case EGravityDirectionMode::SplinePlane:
                {
                    if (IsValid(GravityActor))
                    {
                        ALSGravityMovement->SetSplinePlaneGravityDirection(GravityActor);
                    }
                    else
                    {
                        ALSGravityMovement->SetSplinePlaneGravityDirection(this);
                    }
        
                    break;
                }
        
                case EGravityDirectionMode::Box:
                {
                    if (IsValid(GravityActor))
                    {
                        ALSGravityMovement->SetBoxGravityDirectionFromActor(GravityActor);
                    }
                    else
                    {
                        ALSGravityMovement->SetBoxGravityDirection(GravityVectorA, GravityVectorB);
                    }
        
                    break;
                }
        
                case EGravityDirectionMode::Collision:
                default:
                {
                    if (IsValid(GravityActor))
                    {
                        ALSGravityMovement->SetCollisionGravityDirection(GravityActor);
                    }
        
                    break;
                }
                
            }
        
            // Launch walking Character if configured
            if(!CharacterFallVelocity.IsZero() && ALSGravityMovement->GetIsWalking())
            {
                ALSGravityMovement->LaunchCharacter(CharacterFallVelocity);
            }
        
            TrackedCharacters.AddUnique(Character);
        }
        else
        {
            // Make sure the received Actor is valid and has physics
            const UPrimitiveComponent* Primitive = Cast<UPrimitiveComponent>(Other->GetRootComponent());
            if (Primitive != nullptr && Primitive->IsAnySimulatingPhysics())
            {
                TrackedActors.AddUnique(Other);
            }
        }
    }
    SetActorTickEnabled(TrackedActors.Num() > 0);
}

◆ ActorLeavingVolume()

void AGravityPhysicsVolume::ActorLeavingVolume ( class AActor * Other )

overridevirtual

Called when an Actor leaves this volume.

Parameters

Other - Actor that left this volume, can be nullptr

{
    UE_LOG(LogTemp, Error, TEXT("Leave Volume"));
    Super::ActorLeavingVolume(Other);
    if(Other != nullptr)
    {
        UE_LOG(LogTemp, Warning, TEXT("Actor: %s Left Gravity"), *Other->GetHumanReadableName());
    }
 
    // Remove the received Actor from the TrackedActors list
    if (Other != nullptr)
    {
        IALSCharacterInterface* Character = Cast<IALSCharacterInterface>(Other);
        if(Character != nullptr)
        {
            TrackedCharacters.Remove(Character);
        }
        else
        {
            TrackedActors.Remove(Other);
        }
    }
    // Remove all empty positions of the TrackedActors list
    TrackedActors.RemoveAll([](const AActor* Actor)
    {
        return Actor == nullptr;
    });
 
    // Remove all empty positions of the TrackedNinjas list
    TrackedCharacters.RemoveAll([](const IALSCharacterInterface* Character)
    {
        return Character == nullptr;
    });
 
    SetActorTickEnabled(TrackedActors.Num() > 0);
 
}

◆ BeginPlay()

void AGravityPhysicsVolume::BeginPlay ( )

overrideprotectedvirtual

{
    Super::BeginPlay();
    TArray<AActor*> ActorsToIgnore;
    TArray<FHitResult> HitResults;
    TArray<AActor*> OverlappingActors;
 
    if(UKismetSystemLibrary::BoxTraceMulti(this, GetActorLocation(), GetActorLocation(), GetBrushComponent()->Bounds.BoxExtent,
        FRotator::ZeroRotator, UEngineTypes::ConvertToTraceType(ECC_EngineTraceChannel1), false, ActorsToIgnore,
        UBaseHelpersBPLib::GetDrawDebugType(bDebuggingMode), HitResults, true))
    {
        for(auto& HitResult : HitResults)
        {
            if(HitResult.GetActor() != nullptr)
            {
                OverlappingActors.AddUnique(HitResult.GetActor());
                // ActorEnteredVolume(HitResult.GetActor());
            }
        }
    }
    for(const auto OverlappingActor : OverlappingActors)
    {
        ActorEnteredVolume(OverlappingActor);
    }
    // TArray<AActor*> OverlappingActors;
    // GetBrushComponent()->GetOverlappingActors(OverlappingActors);
    // // GetOverlappingActors(OverlappingActors);
    // for(const auto OverlappingActor : OverlappingActors)
    // {
    //  UE_LOG(LogTemp, Error, TEXT("OverlappingActor: %s"), *OverlappingActor->GetHumanReadableName());
    //  ActorEnteredVolume(OverlappingActor);
    // }
}

◆ GetFinalGravityScale()

float AGravityPhysicsVolume::GetFinalGravityScale ( class USceneComponent * SceneComponent ) const

virtual

Obtains the scale factor that affects magnitude of current gravity vector that influences a SceneComponent.

Parameters

SceneComponent - component in space affected by gravity

Returns: final gravity scale factor

{
    return GetGravityScale();
}

◆ GetGravity()

FVector AGravityPhysicsVolume::GetGravity ( class USceneComponent * SceneComponent ) const

virtual

Obtains the gravity vector that influences a SceneComponent.

Parameters

SceneComponent - component in space affected by gravity

Returns: current gravity

{
    SCOPE_CYCLE_COUNTER(STAT_PhysicsVolumeGetGravity);
    if (GetGravityScale() == 0.0f)
    {
        return FVector::ZeroVector;
    }
    FVector Gravity = FVector::ZeroVector;
 
    switch(GravityDirectionMode)
    {
        case EGravityDirectionMode::Fixed:
        {
            Gravity = GravityVectorA * (FMath::Abs(GetGravityZ()) * GetFinalGravityScale(SceneComponent));
            break;
        }
 
        case EGravityDirectionMode::SplineTangent:
        {
            USplineComponent* Spline = nullptr;
            if (IsValid(GravityActor))
            {
                Spline = Cast<USplineComponent>(
                    GravityActor->GetComponentByClass(USplineComponent::StaticClass()));
            }
            else
            {
                Spline = Cast<USplineComponent>(GetComponentByClass(USplineComponent::StaticClass()));
            }
 
            if (Spline != nullptr)
            {
                const FVector Point = SceneComponent->GetComponentLocation();
                const FVector GravityDir = Spline->FindDirectionClosestToWorldLocation(
                    Point, ESplineCoordinateSpace::Type::World);
                if (!GravityDir.IsZero())
                {
                    Gravity = GravityDir * (FMath::Abs(GetGravityZ()) * GetFinalGravityScale(SceneComponent));
                }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
                if (GravityPhysicsVolumeCVars::ShowGravity > 0 && !GravityDir.IsZero())
                {
                    DrawDebugDirectionalArrow(GetWorld(), Point, Point + GravityDir * 100.0f,
                        1000.0f, FColor::Green, false, 0.02f, 0, 4.0f);
                }
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
            }
 
            break;
        }
 
        case EGravityDirectionMode::Point:
        {
            FVector GravityPoint = GravityVectorA;
 
            if (IsValid(GravityActor))
            {
                GravityPoint = GravityActor->GetActorLocation();
            }
 
            const FVector GravityDir = GravityPoint - SceneComponent->GetComponentLocation();
            if (!GravityDir.IsZero())
            {
                Gravity = GravityDir.GetSafeNormal() *
                    (FMath::Abs(GetGravityZ()) * GetFinalGravityScale(SceneComponent));
            }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
            if (GravityPhysicsVolumeCVars::ShowGravity > 0)
            {
                DrawDebugSphere(GetWorld(), GravityPoint, 4.0, 8, FColor::Green, false, 0.02f, 0, 10.0f);
            }
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
 
            break;
        }
 
        case EGravityDirectionMode::Line:
        {
            const FVector Point = SceneComponent->GetComponentLocation();
            const FVector GravityDir = FMath::ClosestPointOnInfiniteLine(
                GravityVectorA, GravityVectorB, Point) - Point;
            if (!GravityDir.IsZero())
            {
                Gravity = GravityDir.GetSafeNormal() *
                    (FMath::Abs(GetGravityZ()) * GetFinalGravityScale(SceneComponent));
            }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
            if (GravityPhysicsVolumeCVars::ShowGravity > 0)
            {
                DrawDebugLine(GetWorld(), GravityVectorA + (GravityVectorA - GravityVectorB),
                    GravityVectorB + (GravityVectorB - GravityVectorA), FColor::Green, false, 0.02f, 0, 4.0f);
                DrawDebugSphere(GetWorld(), GravityVectorA, 4.0, 8, FColor::Blue, false, 0.02f, 0, 10.0f);
                DrawDebugSphere(GetWorld(), GravityVectorB, 4.0, 8, FColor::Blue, false, 0.02f, 0, 10.0f);
            }
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
 
            break;
        }
 
        case EGravityDirectionMode::Segment:
        {
            const FVector Point = SceneComponent->GetComponentLocation();
            const FVector GravityDir = FMath::ClosestPointOnLine(GravityVectorA,
                GravityVectorB, Point) - Point;
            if (!GravityDir.IsZero())
            {
                Gravity = GravityDir.GetSafeNormal() *
                    (FMath::Abs(GetGravityZ()) * GetFinalGravityScale(SceneComponent));
            }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
            if (GravityPhysicsVolumeCVars::ShowGravity > 0)
            {
                DrawDebugLine(GetWorld(), GravityVectorA, GravityVectorB, FColor::Green, false, 0.02f, 0, 4.0f);
                DrawDebugSphere(GetWorld(), GravityVectorA, 4.0, 8, FColor::Blue, false, 0.02f, 0, 10.0f);
                DrawDebugSphere(GetWorld(), GravityVectorB, 4.0, 8, FColor::Blue, false, 0.02f, 0, 10.0f);
            }
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
 
            break;
        }
 
        case EGravityDirectionMode::Spline:
        {
            USplineComponent* Spline = nullptr;
            if (IsValid(GravityActor))
            {
                Spline = Cast<USplineComponent>(
                    GravityActor->GetComponentByClass(USplineComponent::StaticClass()));
            }
            else
            {
                Spline = Cast<USplineComponent>(GetComponentByClass(USplineComponent::StaticClass()));
            }
 
            if (Spline != nullptr)
            {
                const FVector Point = SceneComponent->GetComponentLocation();
                const FVector GravityPoint = Spline->FindLocationClosestToWorldLocation(
                    Point, ESplineCoordinateSpace::Type::World);
                const FVector GravityDir = GravityPoint - Point;
                if (!GravityDir.IsZero())
                {
                    Gravity = GravityDir.GetSafeNormal() *
                        (FMath::Abs(GetGravityZ()) * GetFinalGravityScale(SceneComponent));
                }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
                if (GravityPhysicsVolumeCVars::ShowGravity > 0)
                {
                    DrawDebugSphere(GetWorld(), GravityPoint, 4.0, 8, FColor::Green, false, 0.02f, 0, 10.0f);
                }
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
            }
 
            break;
        }
 
        case EGravityDirectionMode::Plane:
        {
            const FVector Point = SceneComponent->GetComponentLocation();
            const FVector GravityDir = FVector::PointPlaneProject(Point,
                GravityVectorA, GravityVectorB) - Point;
            if (!GravityDir.IsZero())
            {
                Gravity = GravityDir.GetSafeNormal() *
                    (FMath::Abs(GetGravityZ()) * GetFinalGravityScale(SceneComponent));
            }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
            if (GravityPhysicsVolumeCVars::ShowGravity > 0)
            {
                DrawDebugSolidPlane(GetWorld(), FPlane(GravityVectorA, GravityVectorB), GravityVectorA,
                    FVector2D(500.0f, 500.0f), FColor::Green);
            }
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
 
            break;
        }
 
        case EGravityDirectionMode::SplinePlane:
        {
            USplineComponent* Spline = nullptr;
            if (IsValid(GravityActor))
            {
                Spline = Cast<USplineComponent>(
                    GravityActor->GetComponentByClass(USplineComponent::StaticClass()));
            }
            else
            {
                Spline = Cast<USplineComponent>(GetComponentByClass(USplineComponent::StaticClass()));
            }
 
            if (Spline != nullptr)
            {
                const FVector Point = SceneComponent->GetComponentLocation();
 
                const float InputKey = Spline->FindInputKeyClosestToWorldLocation(Point);
                const FVector ClosestLocation = Spline->GetLocationAtSplineInputKey(
                    InputKey, ESplineCoordinateSpace::Type::World);
                const FVector ClosestUpVector = Spline->GetUpVectorAtSplineInputKey(
                    InputKey, ESplineCoordinateSpace::Type::World);
 
                const FVector GravityDir = FVector::PointPlaneProject(Point,
                    ClosestLocation, ClosestUpVector) - Point;
                if (!GravityDir.IsZero())
                {
                    Gravity = GravityDir.GetSafeNormal() *
                        (FMath::Abs(GetGravityZ()) * GetFinalGravityScale(SceneComponent));
                }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
                if (GravityPhysicsVolumeCVars::ShowGravity > 0)
                {
                    DrawDebugSolidPlane(GetWorld(), FPlane(ClosestLocation, ClosestUpVector),
                        ClosestLocation, FVector2D(500.0f, 500.0f), FColor::Green);
                }
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
            }
 
            break;
        }
 
        case EGravityDirectionMode::Box:
        {
            FVector BoxOrigin = GravityVectorA;
            FVector BoxExtent = GravityVectorB;
 
            if (IsValid(GravityActor))
            {
                GravityActor->GetActorBounds(true, BoxOrigin, BoxExtent);
            }
 
            const FVector Point = SceneComponent->GetComponentLocation();
            const FVector GravityDir = FBox(BoxOrigin - BoxExtent,
                BoxOrigin + BoxExtent).GetClosestPointTo(Point) - Point;
            if (!GravityDir.IsZero())
            {
                Gravity = GravityDir.GetSafeNormal() *
                    (FMath::Abs(GetGravityZ()) * GetFinalGravityScale(SceneComponent));
            }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
            if (GravityPhysicsVolumeCVars::ShowGravity > 0)
            {
                DrawDebugSolidBox(GetWorld(), BoxOrigin, BoxExtent, FColor::Green);
            }
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
 
            break;
        }
 
        case EGravityDirectionMode::Collision:
        {
            if (IsValid(GravityActor))
            {
                const FVector Point = SceneComponent->GetComponentLocation();
 
                FVector ClosestPoint;
                if (Cast<UPrimitiveComponent>(GravityActor->GetRootComponent())->GetClosestPointOnCollision(
                    Point, ClosestPoint) > 0.0f)
                {
                    const FVector GravityDir = ClosestPoint - Point;
                    if (!GravityDir.IsZero())
                    {
                        Gravity = GravityDir.GetSafeNormal() *
                            (FMath::Abs(GetGravityZ()) * GetFinalGravityScale(SceneComponent));
                    }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
                    if (GravityPhysicsVolumeCVars::ShowGravity > 0)
                    {
                        DrawDebugSphere(GetWorld(), ClosestPoint, 4.0, 8, FColor::Green, false, 0.02f, 0, 10.0f);
                    }
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
                }
            }
 
            break;
        }
    }
 
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    if (GravityPhysicsVolumeCVars::ShowGravity > 0 && !Gravity.IsZero())
    {
        const FVector Point = SceneComponent->GetComponentLocation();
        DrawDebugDirectionalArrow(GetWorld(), Point, Point + Gravity, 1000.0f,
            FColor::Red, false, 0.02f, 0, 7.0f);
    }
#endif // !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
 
    return Gravity;
}

◆ GetGravityDirection()

FVector AGravityPhysicsVolume::GetGravityDirection ( class USceneComponent * SceneComponent ) const

virtual

Obtains the normalized direction of gravity that influences a SceneComponent.

Note: Could return zero gravity

Parameters

SceneComponent - component in space affected by gravity

Returns: normalized direction of gravity

{
        SCOPE_CYCLE_COUNTER(STAT_PhysicsVolumeGetGravityDirection);
 
    if (GetGravityScale() == 0.0f)
    {
        return FVector::ZeroVector;
    }
 
    FVector GravityDir = FVector::ZeroVector;
 
    switch (GravityDirectionMode)
    {
        case EGravityDirectionMode::Fixed:
        {
            GravityDir = GravityVectorA * ((GetFinalGravityScale(SceneComponent) > 0.0f) ? 1.0f : -1.0f);
            break;
        }
 
        case EGravityDirectionMode::SplineTangent:
        {
            USplineComponent* Spline = nullptr;
            if (IsValid(GravityActor))
            {
                Spline = Cast<USplineComponent>(
                    GravityActor->GetComponentByClass(USplineComponent::StaticClass()));
            }
            else
            {
                Spline = Cast<USplineComponent>(GetComponentByClass(USplineComponent::StaticClass()));
            }
 
            if (Spline != nullptr)
            {
                GravityDir = Spline->FindDirectionClosestToWorldLocation(
                    SceneComponent->GetComponentLocation(), ESplineCoordinateSpace::Type::World) *
                    ((GetFinalGravityScale(SceneComponent) > 0.0f) ? 1.0f : -1.0f);
            }
 
            break;
        }
 
        case EGravityDirectionMode::Point:
        {
            FVector GravityPoint = GravityVectorA;
 
            if (IsValid(GravityActor))
            {
                GravityPoint = GravityActor->GetActorLocation();
            }
 
            GravityDir = GravityPoint - SceneComponent->GetComponentLocation();
            if (!GravityDir.IsZero())
            {
                GravityDir = GravityDir.GetSafeNormal() *
                    ((GetFinalGravityScale(SceneComponent) > 0.0f) ? 1.0f : -1.0f);
            }
 
            break;
        }
 
        case EGravityDirectionMode::Line:
        {
            const FVector Point = SceneComponent->GetComponentLocation();
            GravityDir = FMath::ClosestPointOnInfiniteLine(
                GravityVectorA, GravityVectorB, Point) - Point;
            if (!GravityDir.IsZero())
            {
                GravityDir = GravityDir.GetSafeNormal() *
                    ((GetFinalGravityScale(SceneComponent) > 0.0f) ? 1.0f : -1.0f);
            }
 
            break;
        }
 
        case EGravityDirectionMode::Segment:
        {
            const FVector Point = SceneComponent->GetComponentLocation();
            GravityDir = FMath::ClosestPointOnLine(GravityVectorA,
                GravityVectorB, Point) - Point;
            if (!GravityDir.IsZero())
            {
                GravityDir = GravityDir.GetSafeNormal() *
                    ((GetFinalGravityScale(SceneComponent) > 0.0f) ? 1.0f : -1.0f);
            }
 
            break;
        }
 
        case EGravityDirectionMode::Spline:
        {
            USplineComponent* Spline = nullptr;
            if (IsValid(GravityActor))
            {
                Spline = Cast<USplineComponent>(
                    GravityActor->GetComponentByClass(USplineComponent::StaticClass()));
            }
            else
            {
                Spline = Cast<USplineComponent>(GetComponentByClass(USplineComponent::StaticClass()));
            }
 
            if (Spline != nullptr)
            {
                const FVector Point = SceneComponent->GetComponentLocation();
                const FVector GravityPoint = Spline->FindLocationClosestToWorldLocation(
                    Point, ESplineCoordinateSpace::Type::World);
                GravityDir = GravityPoint - Point;
                if (!GravityDir.IsZero())
                {
                    GravityDir = GravityDir.GetSafeNormal() *
                        ((GetFinalGravityScale(SceneComponent) > 0.0f) ? 1.0f : -1.0f);
                }
            }
 
            break;
        }
 
        case EGravityDirectionMode::Plane:
        {
            const FVector Point = SceneComponent->GetComponentLocation();
            GravityDir = FVector::PointPlaneProject(Point, GravityVectorA,
                GravityVectorB) - Point;
            if (!GravityDir.IsZero())
            {
                GravityDir = GravityDir.GetSafeNormal() *
                    ((GetFinalGravityScale(SceneComponent) > 0.0f) ? 1.0f : -1.0f);
            }
 
            break;
        }
 
        case EGravityDirectionMode::SplinePlane:
        {
            USplineComponent* Spline = nullptr;
            if (IsValid(GravityActor))
            {
                Spline = Cast<USplineComponent>(
                    GravityActor->GetComponentByClass(USplineComponent::StaticClass()));
            }
            else
            {
                Spline = Cast<USplineComponent>(GetComponentByClass(USplineComponent::StaticClass()));
            }
 
            if (Spline != nullptr)
            {
                const FVector Point = SceneComponent->GetComponentLocation();
 
                const float InputKey = Spline->FindInputKeyClosestToWorldLocation(Point);
                const FVector ClosestLocation = Spline->GetLocationAtSplineInputKey(
                    InputKey, ESplineCoordinateSpace::Type::World);
                const FVector ClosestUpVector = Spline->GetUpVectorAtSplineInputKey(
                    InputKey, ESplineCoordinateSpace::Type::World);
 
                GravityDir = FVector::PointPlaneProject(Point,
                    ClosestLocation, ClosestUpVector) - Point;
                if (!GravityDir.IsZero())
                {
                    GravityDir = GravityDir.GetSafeNormal() *
                        ((GetFinalGravityScale(SceneComponent) > 0.0f) ? 1.0f : -1.0f);
                }
            }
 
            break;
        }
 
        case EGravityDirectionMode::Box:
        {
            FVector BoxOrigin = GravityVectorA;
            FVector BoxExtent = GravityVectorB;
 
            if (IsValid(GravityActor))
            {
                GravityActor->GetActorBounds(true, BoxOrigin, BoxExtent);
            }
 
            const FVector Point = SceneComponent->GetComponentLocation();
            GravityDir = FBox(BoxOrigin - BoxExtent,
                BoxOrigin + BoxExtent).GetClosestPointTo(Point) - Point;
            if (!GravityDir.IsZero())
            {
                GravityDir = GravityDir.GetSafeNormal() *
                    ((GetFinalGravityScale(SceneComponent) > 0.0f) ? 1.0f : -1.0f);
            }
 
            break;
        }
 
        case EGravityDirectionMode::Collision:
        {
            if (IsValid(GravityActor))
            {
                const FVector Point = SceneComponent->GetComponentLocation();
 
                FVector ClosestPoint;
                if (Cast<UPrimitiveComponent>(GravityActor->GetRootComponent())->GetClosestPointOnCollision(
                    Point, ClosestPoint) > 0.0f)
                {
                    GravityDir = ClosestPoint - Point;
                    if (!GravityDir.IsZero())
                    {
                        GravityDir = GravityDir.GetSafeNormal() *
                            ((GetFinalGravityScale(SceneComponent) > 0.0f) ? 1.0f : -1.0f);
                    }
                }
            }
            break;
        }
    }
    return GravityDir;
}

◆ GetGravityMagnitude()

float AGravityPhysicsVolume::GetGravityMagnitude ( class USceneComponent * SceneComponent ) const

virtual

Obtains the absolute (positive) magnitude of gravity that influences a SceneComponent.

Parameters

SceneComponent - component in space affected by gravity

Returns: magnitude of gravity

{
    return FMath::Abs(GetGravityZ() * GetFinalGravityScale(SceneComponent));
}

◆ GetGravityScale()

float AGravityPhysicsVolume::GetGravityScale ( ) const

virtual

Obtains the scale factor that affects magnitude of current gravity.

Returns: gravity scale factor

{
    return GravityScale;
}

◆ K2_SetFixedGravityDirection()

void AGravityPhysicsVolume::K2_SetFixedGravityDirection ( const FVector & NewGravityDirection )

virtual

Sets a new fixed gravity direction.

Note: It can be influenced by GravityScale

Parameters

NewGravityDirection - new gravity direction, assumes it isn't normalized

{
    SetFixedGravityDirection(NewGravityDirection.GetSafeNormal());
}

◆ K2_SetPlaneGravityDirection()

void AGravityPhysicsVolume::K2_SetPlaneGravityDirection	(	const FVector &	NewGravityPlaneBase,
		const FVector &	NewGravityPlaneNormal )

virtual

Sets a new infinite plane which gravity direction points to.

Note: It can be influenced by GravityScale

Parameters

NewGravityPlaneBase	- a point that belongs to the plane
NewGravityPlaneNormal	- normal of the plane, assumes it isn't normalized

{
    SetPlaneGravityDirection(NewGravityPlaneBase, NewGravityPlaneNormal.GetSafeNormal());
}

◆ SetBoxGravityDirection()

void AGravityPhysicsVolume::SetBoxGravityDirection	(	const FVector &	NewGravityBoxOrigin,
		const FVector &	NewGravityBoxExtent )

virtual

Sets a new axis-aligned box which gravity direction points to.

Note: It can be influenced by GravityScale

Parameters

NewGravityBoxOrigin	- origin of the box
NewGravityBoxExtent	- extents of the box

{
    if (GravityDirectionMode == EGravityDirectionMode::Box &&
    GravityVectorA == NewGravityBoxOrigin && GravityVectorB == NewGravityBoxExtent)
    {
        return;
    }
 
    GravityDirectionMode = EGravityDirectionMode::Box;
    GravityVectorA = NewGravityBoxOrigin;
    GravityVectorB = NewGravityBoxExtent;
    GravityActor = nullptr;
 
    // Change gravity settings of Characters
    for(const IALSCharacterInterface* Character : TrackedCharacters)
    {
        if(Character != nullptr && Character->GetALSGravityMovementInterface() != nullptr)
        {
            Character->GetALSGravityMovementInterface()->SetBoxGravityDirection(NewGravityBoxOrigin, NewGravityBoxExtent);
        }
    }
}

◆ SetBoxGravityDirectionFromActor()

void AGravityPhysicsVolume::SetBoxGravityDirectionFromActor ( AActor * NewGravityActor )

virtual

Sets a new axis-aligned box which gravity direction points to.

Note: It can be influenced by GravityScale

Parameters

NewGravityActor - Actor that provides its collision bounding box as gravity target

{
    if (GravityDirectionMode == EGravityDirectionMode::Box &&
    GravityActor == NewGravityActor)
    {
        return;
    }
 
    GravityDirectionMode = EGravityDirectionMode::Box;
    GravityActor = NewGravityActor;
 
    // Change gravity settings of Characters
    for(const IALSCharacterInterface* Character : TrackedCharacters)
    {
        if(Character != nullptr && Character->GetALSGravityMovementInterface() != nullptr)
        {
            Character->GetALSGravityMovementInterface()->SetBoxGravityDirectionFromActor(NewGravityActor);
        }
    }
}

◆ SetCollisionGravityDirection()

void AGravityPhysicsVolume::SetCollisionGravityDirection ( AActor * NewGravityActor )

virtual

Sets a new collision geometry which gravity direction points to.

Note: It can be influenced by GravityScale

Parameters

NewGravityActor - Actor that owns the PrimitiveComponent that has collision geometry

{
    if (NewGravityActor == nullptr ||
    (GravityDirectionMode == EGravityDirectionMode::Collision &&
    GravityActor == NewGravityActor))
    {
        return;
    }
 
    const UPrimitiveComponent* Primitive = Cast<UPrimitiveComponent>(NewGravityActor->GetRootComponent());
    if (Primitive != nullptr)
    {
        GravityDirectionMode = EGravityDirectionMode::Collision;
        GravityActor = NewGravityActor;
 
        // Change gravity settings of Characters
        for(const IALSCharacterInterface* Character : TrackedCharacters)
        {
            if(Character != nullptr && Character->GetALSGravityMovementInterface() != nullptr)
            {
                Character->GetALSGravityMovementInterface()->SetCollisionGravityDirection(NewGravityActor);
            }
        }
    }
}

◆ SetFixedGravityDirection()

void AGravityPhysicsVolume::SetFixedGravityDirection ( const FVector & NewFixedGravityDirection )

virtual

Sets a new fixed gravity direction.

Note: It can be influenced by GravityScale

Parameters

NewFixedGravityDirection - new fixed gravity direction, assumes it is normalized

{
    if (NewFixedGravityDirection.IsZero() ||
    (GravityDirectionMode == EGravityDirectionMode::Fixed &&
    GravityVectorA == NewFixedGravityDirection))
    {
        return;
    }
 
    GravityDirectionMode = EGravityDirectionMode::Fixed;
    GravityVectorA = NewFixedGravityDirection;
 
    // Change gravity settings of Characters
    for(const IALSCharacterInterface* Character : TrackedCharacters)
    {
        if(Character != nullptr && Character->GetALSGravityMovementInterface() != nullptr)
        {
            Character->GetALSGravityMovementInterface()->SetFixedGravityDirection(NewFixedGravityDirection);
        }
    }
}

◆ SetGravityScale()

void AGravityPhysicsVolume::SetGravityScale ( const float NewGravityScale )

virtual

Sets a new scale factor that affects magnitude of current gravity.

Parameters

NewGravityScale - new gravity scale factor

{
    GravityScale = NewGravityScale;
}

◆ SetLineGravityDirection()

void AGravityPhysicsVolume::SetLineGravityDirection	(	const FVector &	NewGravityLineStart,
		const FVector &	NewGravityLineEnd )

virtual

Sets a new infinite line which gravity direction points to.

Note: It can be influenced by GravityScale

Parameters

NewGravityLineStart	- a point that belongs to the infinite line
NewGravityLineEnd	- another point that belongs to the infinite line

{
    if (NewGravityLineStart == NewGravityLineEnd ||
        (GravityDirectionMode == EGravityDirectionMode::Line &&
        GravityVectorA == NewGravityLineStart && GravityVectorB == NewGravityLineEnd))
    {
        return;
    }
 
    GravityDirectionMode = EGravityDirectionMode::Line;
    GravityVectorA = NewGravityLineStart;
    GravityVectorB = NewGravityLineEnd;
 
    // Change gravity settings of Characters
    for(const IALSCharacterInterface* Character : TrackedCharacters)
    {
        if(Character != nullptr && Character->GetALSGravityMovementInterface() != nullptr)
        {
            Character->GetALSGravityMovementInterface()->SetLineGravityDirection(NewGravityLineStart, NewGravityLineEnd);
        }
    }
}

◆ SetPlaneGravityDirection()

void AGravityPhysicsVolume::SetPlaneGravityDirection	(	const FVector &	NewGravityPlaneBase,
		const FVector &	NewGravityPlaneNormal )

virtual

Sets a new infinite plane which gravity direction points to.

Note: It can be influenced by GravityScale

Parameters

NewGravityPlaneBase	- a point that belongs to the plane
NewGravityPlaneNormal	- normal of the plane, assumes it is normalized

{
    if (NewGravityPlaneNormal.IsZero() ||
    (GravityDirectionMode == EGravityDirectionMode::Plane &&
    GravityVectorA == NewGravityPlaneBase && GravityVectorB == NewGravityPlaneNormal))
    {
        return;
    }
 
    GravityDirectionMode = EGravityDirectionMode::Plane;
    GravityVectorA = NewGravityPlaneBase;
    GravityVectorB = NewGravityPlaneNormal;
 
    // Change gravity settings of Characters
    for(const IALSCharacterInterface* Character : TrackedCharacters)
    {
        if(Character != nullptr && Character->GetALSGravityMovementInterface() != nullptr)
        {
            Character->GetALSGravityMovementInterface()->SetPlaneGravityDirection(NewGravityPlaneBase, NewGravityPlaneNormal);
        }
    }
}

◆ SetPointGravityDirection()

void AGravityPhysicsVolume::SetPointGravityDirection ( const FVector & NewGravityPoint )

virtual

Sets a new point which gravity direction points to.

Note: It can be influenced by GravityScale

Parameters

NewGravityPoint - new point which gravity direction points to

{
    if (GravityDirectionMode == EGravityDirectionMode::Point &&
        GravityVectorA == NewGravityPoint)
    {
        return;
    }
 
    GravityDirectionMode = EGravityDirectionMode::Point;
    GravityVectorA = NewGravityPoint;
    GravityActor = nullptr;
 
    // Change gravity settings of Characters
    for(const IALSCharacterInterface* Character : TrackedCharacters)
    {
        if(Character != nullptr && Character->GetALSGravityMovementInterface() != nullptr)
        {
            Character->GetALSGravityMovementInterface()->SetPointGravityDirection(NewGravityPoint);
        }
    }
}

◆ SetPointGravityDirectionFromActor()

void AGravityPhysicsVolume::SetPointGravityDirectionFromActor ( AActor * NewGravityActor )

virtual

Sets a new point which gravity direction points to.

Note: It can be influenced by GravityScale

Parameters

NewGravityActor - Actor that provides its location as gravity point

{
    if (GravityDirectionMode == EGravityDirectionMode::Point &&
    GravityActor == NewGravityActor)
    {
        return;
    }
 
    GravityDirectionMode = EGravityDirectionMode::Point;
    GravityActor = NewGravityActor;
 
    // Change gravity settings of Characters
    for(const IALSCharacterInterface* Character : TrackedCharacters)
    {
        if(Character != nullptr && Character->GetALSGravityMovementInterface() != nullptr)
        {
            Character->GetALSGravityMovementInterface()->SetPointGravityDirectionFromActor(NewGravityActor);
        }
    }
}

◆ SetSegmentGravityDirection()

void AGravityPhysicsVolume::SetSegmentGravityDirection	(	const FVector &	NewGravitySegmentStart,
		const FVector &	NewGravitySegmentEnd )

virtual

Sets a new segment line which gravity direction points to.

Note: It can be influenced by GravityScale

Parameters

NewGravitySegmentStart	- start point of the segment line
NewGravitySegmentEnd	- end point of the segment line

{
    if (NewGravitySegmentStart == NewGravitySegmentEnd ||
    (GravityDirectionMode == EGravityDirectionMode::Segment &&
    GravityVectorA == NewGravitySegmentStart && GravityVectorB == NewGravitySegmentEnd))
    {
        return;
    }
 
    GravityDirectionMode = EGravityDirectionMode::Segment;
    GravityVectorA = NewGravitySegmentStart;
    GravityVectorB = NewGravitySegmentEnd;
 
    // Change gravity settings of Characters
    for(const IALSCharacterInterface* Character : TrackedCharacters)
    {
        if(Character != nullptr && Character->GetALSGravityMovementInterface() != nullptr)
        {
            Character->GetALSGravityMovementInterface()->SetSegmentGravityDirection(NewGravitySegmentStart, NewGravitySegmentEnd);
        }
    }
}

◆ SetSplineGravityDirection()

void AGravityPhysicsVolume::SetSplineGravityDirection ( AActor * NewGravityActor )

virtual

Sets a new spline which gravity direction points to.

Note: It can be influenced by GravityScale

Parameters

NewGravityActor - Actor that provides a spline

{
    if (NewGravityActor == nullptr ||
    (GravityDirectionMode == EGravityDirectionMode::Spline &&
    GravityActor == NewGravityActor))
    {
        return;
    }
 
    const USplineComponent* Spline = Cast<USplineComponent>(
        NewGravityActor->GetComponentByClass(USplineComponent::StaticClass()));
    if (Spline != nullptr)
    {
        GravityDirectionMode = EGravityDirectionMode::Spline;
        GravityActor = NewGravityActor;
 
        // Change gravity settings of Characters
        for(const IALSCharacterInterface* Character : TrackedCharacters)
        {
            if(Character != nullptr && Character->GetALSGravityMovementInterface() != nullptr)
            {
                Character->GetALSGravityMovementInterface()->SetSplineGravityDirection(NewGravityActor);
            }
        }
    }
}

◆ SetSplinePlaneGravityDirection()

void AGravityPhysicsVolume::SetSplinePlaneGravityDirection ( AActor * NewGravityActor )

virtual

Sets a new infinite plane determined by closest spline point and spline up vector which gravity direction points to.

Note: It can be influenced by GravityScale

Parameters

NewGravityActor - Actor that provides a spline

{
    if (NewGravityActor == nullptr ||
    (GravityDirectionMode == EGravityDirectionMode::SplinePlane &&
    GravityActor == NewGravityActor))
    {
        return;
    }
 
    const USplineComponent* Spline = Cast<USplineComponent>(
        NewGravityActor->GetComponentByClass(USplineComponent::StaticClass()));
    if (Spline != nullptr)
    {
        GravityDirectionMode = EGravityDirectionMode::SplinePlane;
        GravityActor = NewGravityActor;
 
        // Change gravity settings of Characters
        for(const IALSCharacterInterface* Character : TrackedCharacters)
        {
            if(Character != nullptr && Character->GetALSGravityMovementInterface() != nullptr)
            {
                Character->GetALSGravityMovementInterface()->SetSplinePlaneGravityDirection(NewGravityActor);
            }
        }
    }
}

◆ SetSplineTangentGravityDirection()

void AGravityPhysicsVolume::SetSplineTangentGravityDirection ( AActor * NewGravityActor )

virtual

Sets a new gravity direction determined by closest spline tangent.

Note: It can be influenced by GravityScale

Parameters

NewGravityActor - Actor that provides a spline

{
    if (NewGravityActor == nullptr ||
    (GravityDirectionMode == EGravityDirectionMode::SplineTangent &&
    GravityActor == NewGravityActor))
    {
        return;
    }
 
    const USplineComponent* Spline = Cast<USplineComponent>(
        NewGravityActor->GetComponentByClass(USplineComponent::StaticClass()));
    if (Spline != nullptr)
    {
        GravityDirectionMode = EGravityDirectionMode::SplineTangent;
        GravityActor = NewGravityActor;
 
        // Change gravity settings of Characters
        for(const IALSCharacterInterface* Character : TrackedCharacters)
        {
            if(Character != nullptr && Character->GetALSGravityMovementInterface() != nullptr)
            {
                Character->GetALSGravityMovementInterface()->SetSplineTangentGravityDirection(NewGravityActor);
            }
        }
    }
}

◆ Tick()

void AGravityPhysicsVolume::Tick ( float DeltaTime )

overrideprotectedvirtual

{
    Super::Tick(DeltaTime);
    for(const AActor* TrackedActor : TrackedActors)
    {
        if(IsValid(TrackedActor) && TrackedActor->GetRootComponent() != nullptr)
        {
            UPrimitiveComponent* Primitive = Cast<UPrimitiveComponent>(TrackedActor->GetRootComponent());
            if(Primitive != nullptr && Primitive->IsGravityEnabled())
            {
                // Add force combination of reverse engine's gravity and custom gravity
                const FVector GravityForce = FVector(0.0f, 0.0f, GetGravityZ() * -1.0f) + GetGravity(Primitive);
 
                USkeletalMeshComponent* SkeletalMesh = Cast<USkeletalMeshComponent>(Primitive);
                if(SkeletalMesh != nullptr)
                {
                    SkeletalMesh->AddForceToAllBodiesBelow(GravityForce, NAME_None, true, true);
                }
                else
                {
                    Primitive->AddForce(GravityForce, NAME_None, true);
                }
            }
        }
    }
}

Member Data Documentation

◆ bDebuggingMode

bool AGravityPhysicsVolume::bDebuggingMode = false

protected

◆ CharacterFallVelocity

FVector AGravityPhysicsVolume::CharacterFallVelocity

Imparts this falling velocity to entering walking Ninjas.

◆ GravityActor

TObjectPtr<AActor> AGravityPhysicsVolume::GravityActor

protected

Optional Actor that determines direction of gravity.

◆ GravityDirectionMode

EGravityDirectionMode AGravityPhysicsVolume::GravityDirectionMode

protected

Mode that determines direction of gravity.

◆ GravityScale

float AGravityPhysicsVolume::GravityScale

protected

Gravity vector is multiplied by this amount.

◆ GravityVectorA

FVector AGravityPhysicsVolume::GravityVectorA

protected

Stores information that determines direction of gravity.

◆ GravityVectorB

FVector AGravityPhysicsVolume::GravityVectorB

protected

Stores additional information that determines direction of gravity.

◆ TrackedActors

TArray<TObjectPtr<AActor> > AGravityPhysicsVolume::TrackedActors

protected

List of tracked Actors that are affected by gravity settings.

◆ TrackedCharacters

TArray<class IALSCharacterInterface*> AGravityPhysicsVolume::TrackedCharacters

protected

List of tracked Characters that are affected by gravity settings.

The documentation for this class was generated from the following files:

T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Source/SpaceAdventure/Public/Gravity/GravityPhysicsVolume.h
T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Source/SpaceAdventure/Private/Gravity/GravityPhysicsVolume.cpp

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Constructor & Destructor Documentation

◆ AGravityPhysicsVolume()

Member Function Documentation

◆ ActorEnteredVolume()

◆ ActorLeavingVolume()

◆ BeginPlay()

◆ GetFinalGravityScale()

◆ GetGravity()

◆ GetGravityDirection()

◆ GetGravityMagnitude()

◆ GetGravityScale()

◆ K2_SetFixedGravityDirection()

◆ K2_SetPlaneGravityDirection()

◆ SetBoxGravityDirection()

◆ SetBoxGravityDirectionFromActor()

◆ SetCollisionGravityDirection()

◆ SetFixedGravityDirection()

◆ SetGravityScale()

◆ SetLineGravityDirection()

◆ SetPlaneGravityDirection()

◆ SetPointGravityDirection()

◆ SetPointGravityDirectionFromActor()

◆ SetSegmentGravityDirection()

◆ SetSplineGravityDirection()

◆ SetSplinePlaneGravityDirection()

◆ SetSplineTangentGravityDirection()

◆ Tick()

Member Data Documentation

◆ bDebuggingMode

◆ CharacterFallVelocity

◆ GravityActor

◆ GravityDirectionMode

◆ GravityScale

◆ GravityVectorA

◆ GravityVectorB

◆ TrackedActors

◆ TrackedCharacters