#include <GravityActor.h>

Inheritance diagram for AGravityActor:

Public Member Functions
	AGravityActor ()

virtual void	Tick (float DeltaTime) override

virtual void	ActorEnteredVolume (AActor SelfActor, AActor Other)

void	OnActorEnteredVolume (AActor *Other)

virtual void	ActorLeavingVolume (AActor SelfActor, AActor Other)

void	OnActorLeavingVolume (AActor *Other)

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

float	GetGravityZ () const

Protected Attributes
TObjectPtr< UBoxComponent >	BoxComponent

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

◆ AGravityActor()

AGravityActor::AGravityActor ( )

{
 
    PrimaryActorTick.bCanEverTick = true;
    PrimaryActorTick.bStartWithTickEnabled = false;
    
    BoxComponent = CreateDefaultSubobject<UBoxComponent>("Box Collision");
    RootComponent = BoxComponent;
    OnActorBeginOverlap.AddUniqueDynamic(this, &AGravityActor::ActorEnteredVolume);
    OnActorEndOverlap.AddUniqueDynamic(this, &AGravityActor::ActorLeavingVolume);
 
    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
    
#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(BoxComponent);
    }
 
    PreviewIcon = CreateEditorOnlyDefaultSubobject<UBillboardComponent>(PreviewIconComponentName);
    if (!IsRunningCommandlet() && PreviewIcon != nullptr)
    {
        PreviewIcon->bHiddenInGame = true;
        // PreviewIcon->HorizontalAlignment = EHorizTextAligment::EHTA_Center;
        // PreviewIcon->Text = FText::AsCultureInvariant(TEXT("Gravity Physics Volume"));
        // PreviewIcon->SetUsingAbsoluteRotation(true);
        PreviewIcon->SetupAttachment(BoxComponent);
    }
#endif // WITH_EDITORONLY_DATA
}

Member Function Documentation

◆ ActorEnteredVolume()

void AGravityActor::ActorEnteredVolume	(	AActor *	SelfActor,
		AActor *	Other )

virtual

Called when an Actor enters this volume.

Parameters

Other - Actor that entered this volume

{
    UE_LOG(LogTemp, Error, TEXT("Entered Actor"));
    // if(Other != nullptr)
    // {
    //  UE_LOG(LogTemp, Error, TEXT("Actor: %s Entered Gravity Actor"), *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);
    OnActorEnteredVolume(Other);
}

◆ ActorLeavingVolume()

void AGravityActor::ActorLeavingVolume	(	AActor *	SelfActor,
		AActor *	Other )

virtual

Called when an Actor leaves this volume.

Parameters

Other - Actor that left this volume, can be nullptr

{
    UE_LOG(LogTemp, Error, TEXT("Leave Actor"));
    // if(Other != nullptr)
    // {
    //  UE_LOG(LogTemp, Warning, TEXT("Actor: %s Left Gravity Actor"), *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);
    OnActorLeavingVolume(Other);
}

◆ BeginPlay()

void AGravityActor::BeginPlay ( )

overrideprotectedvirtual

Reimplemented in AGravityActorSpline.

{
    Super::BeginPlay();
    const TArray<AActor*> ActorsToIgnore;
    TArray<FHitResult> HitResults;
    TArray<AActor*> OverlappingActors;
 
    if(UKismetSystemLibrary::BoxTraceMulti(this, GetActorLocation(), GetActorLocation(), BoxComponent->GetScaledBoxExtent(),
        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());
            }
        }
    }
    for(const auto OverlappingActor : OverlappingActors)
    {
        ActorEnteredVolume(this, OverlappingActor);
    }
 
    
}

◆ GetFinalGravityScale()

float AGravityActor::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 AGravityActor::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_PhysicsActorGetGravity);
    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 (GravityActorVolumeCVars::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 (GravityActorVolumeCVars::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 (GravityActorVolumeCVars::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 (GravityActorVolumeCVars::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 (GravityActorVolumeCVars::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 (GravityActorVolumeCVars::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 (GravityActorVolumeCVars::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 (GravityActorVolumeCVars::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 (GravityActorVolumeCVars::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 (GravityActorVolumeCVars::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 AGravityActor::GetGravityDirection ( class USceneComponent * SceneComponent ) const

virtual

Obtains the normalized direction of gravity that infl uences a SceneComponent.

Note: Could return zero gravity

Parameters

SceneComponent - component in space affected by gravity

Returns: normalized direction of gravity

{
        SCOPE_CYCLE_COUNTER(STAT_PhysicsActorGetGravityDirection);
 
    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 AGravityActor::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 AGravityActor::GetGravityScale ( ) const

virtual

Obtains the scale factor that affects magnitude of current gravity.

Returns: gravity scale factor

{
    return GravityScale;
}

◆ GetGravityZ()

float AGravityActor::GetGravityZ ( ) const

protected

{
    const UWorld* MyWorld = GetWorld();
    return MyWorld ? MyWorld->GetGravityZ() : UPhysicsSettings::Get()->DefaultGravityZ;
}

◆ K2_SetFixedGravityDirection()

void AGravityActor::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 AGravityActor::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());
}

◆ OnActorEnteredVolume()

void AGravityActor::OnActorEnteredVolume ( AActor * Other )

◆ OnActorLeavingVolume()

void AGravityActor::OnActorLeavingVolume ( AActor * Other )

◆ SetBoxGravityDirection()

void AGravityActor::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 AGravityActor::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 AGravityActor::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 AGravityActor::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 AGravityActor::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 AGravityActor::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 AGravityActor::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 AGravityActor::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 AGravityActor::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 AGravityActor::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 AGravityActor::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 AGravityActor::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 AGravityActor::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 AGravityActor::Tick ( float DeltaTime )

overridevirtual

Reimplemented in AGravityActorSpline.

{
    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 AGravityActor::bDebuggingMode = false

protected

◆ BoxComponent

TObjectPtr<UBoxComponent> AGravityActor::BoxComponent

protected

◆ CharacterFallVelocity

FVector AGravityActor::CharacterFallVelocity

Imparts this falling velocity to entering walking Character.

◆ GravityActor

TObjectPtr<AActor> AGravityActor::GravityActor

protected

Optional Actor that determines direction of gravity.

◆ GravityDirectionMode

EGravityDirectionMode AGravityActor::GravityDirectionMode

protected

Mode that determines direction of gravity.

◆ GravityScale

float AGravityActor::GravityScale

protected

Gravity vector is multiplied by this amount.

◆ GravityVectorA

FVector AGravityActor::GravityVectorA

protected

Stores information that determines direction of gravity.

◆ GravityVectorB

FVector AGravityActor::GravityVectorB

protected

Stores additional information that determines direction of gravity.

◆ TrackedActors

TArray<TObjectPtr<AActor> > AGravityActor::TrackedActors

protected

List of tracked Actors that are affected by gravity settings.

◆ TrackedCharacters

TArray<class IALSCharacterInterface*> AGravityActor::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/GravityActor.h
T:/Unreal/Unreal Projects/SpaceAdventure52/SpaceAdventure/Source/SpaceAdventure/Private/Gravity/GravityActor.cpp

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Constructor & Destructor Documentation

◆ AGravityActor()

Member Function Documentation

◆ ActorEnteredVolume()

◆ ActorLeavingVolume()

◆ BeginPlay()

◆ GetFinalGravityScale()

◆ GetGravity()

◆ GetGravityDirection()

◆ GetGravityMagnitude()

◆ GetGravityScale()

◆ GetGravityZ()

◆ K2_SetFixedGravityDirection()

◆ K2_SetPlaneGravityDirection()

◆ OnActorEnteredVolume()

◆ OnActorLeavingVolume()

◆ SetBoxGravityDirection()

◆ SetBoxGravityDirectionFromActor()

◆ SetCollisionGravityDirection()

◆ SetFixedGravityDirection()

◆ SetGravityScale()

◆ SetLineGravityDirection()

◆ SetPlaneGravityDirection()

◆ SetPointGravityDirection()

◆ SetPointGravityDirectionFromActor()

◆ SetSegmentGravityDirection()

◆ SetSplineGravityDirection()

◆ SetSplinePlaneGravityDirection()

◆ SetSplineTangentGravityDirection()

◆ Tick()

Member Data Documentation

◆ bDebuggingMode

◆ BoxComponent

◆ CharacterFallVelocity

◆ GravityActor

◆ GravityDirectionMode

◆ GravityScale

◆ GravityVectorA

◆ GravityVectorB

◆ TrackedActors

◆ TrackedCharacters