UPhysicsUtilities Class Reference

#include <PhysicsUtilities.h>

Inheritance diagram for UPhysicsUtilities:

Collaboration diagram for UPhysicsUtilities:

Static Public Member Functions
static bool	SnapActorToGround (AActor *Actor, float StartZOffset=600.0f, float EndZOffset=600.0f)
static bool	SnapActorAboveGround (AActor *Actor, float AboveOffset=50.0f)
static bool	DoesTopPercentageMeshOverlap (AActor *Actor, const UStaticMesh *Mesh, float TopPercentage, ECollisionChannel CollisionChannel)
static bool	HasOverlappingActors (const UStaticMesh *StaticMesh, const FTransform &Transform)
static TArray< AActor * >	FindOverlappingActorsInSphere (const FTransform &ActorTransform, float Radius, bool DebugVisualizeRadius=false)
static bool	AlignTransformFromGroundInMeters (AActor *Actor, FTransform &InTransform)
template<typename T >
static TArray< T * >	FindOverlappingActorsOfClass (const FTransform &ActorTransform, float Radius, bool DebugVisualizeRadius=false)

Detailed Description

UPhysicsUtilities is collection of static functions for Physics related utilities.

Definition at line 21 of file PhysicsUtilities.h.

Member Function Documentation

AlignTransformFromGroundInMeters()

bool UPhysicsUtilities::AlignTransformFromGroundInMeters ( AActor *  Actor, FTransform &  InTransform  )

static

Definition at line 145 of file PhysicsUtilities.cpp.

{
    if (!GEngine || !GEngine->GameViewport)
    {
        return false;
    }
 
    UWorld* World = GEngine->GameViewport->GetWorld();
    if (!World)
    {
        return false;
    }
 
    FVector Position = InTransform.GetLocation();
    const float HeightAboveGroundMeters = Position.Z;
 
    // TraceStart at X,Y position but higher up in the air to avoid going underground.
    const FVector TraceStart = FVector(Position.X, Position.Y, 6000.0f);
    const FVector TraceEnd = TraceStart - FVector(0, 0, 100000.0f);
 
    FHitResult HitResult;
    FCollisionQueryParams QueryParams;
    QueryParams.AddIgnoredActor(Actor);
 
    bool bHit = World->LineTraceSingleByChannel(HitResult, TraceStart, TraceEnd, ECC_GameTraceChannel6, QueryParams);
    if (bHit)
    {
        Position.Z = HitResult.ImpactPoint.Z + (HeightAboveGroundMeters * 100.0f);
        InTransform.SetLocation(Position);
 
        return true;
    }
 
    return false;
}

Referenced by UROSCommands::HandleTeleportActorByID(), UROSCommands::HandleTeleportSpectator(), USimulatorJsonParser::ParseAndSetDroneParameters(), USimulatorJsonParser::ParseDataCapture(), USimulatorJsonParser::ParseVehicle(), ADataCapture::SetupDataCapture(), and USimulatorJsonParser::SpawnSensorWorld().

DoesTopPercentageMeshOverlap()

bool UPhysicsUtilities::DoesTopPercentageMeshOverlap ( AActor *  Actor, const UStaticMesh *  Mesh, float  TopPercentage, ECollisionChannel  CollisionChannel  )

static

Checks if the top percentage of a given mesh overlaps with any other objects.

Parameters

Actor	The actor to check for overlap with.
Mesh	The static mesh to check for overlap with.
TopPercentage	The percentage of the mesh's top area to check for overlap (0.0 to 1.0).
CollisionChannel	The collision channel to use for the overlap check.

Returns

True if the top percentage of the mesh overlaps with other objects, false otherwise.

Definition at line 70 of file PhysicsUtilities.cpp.

{
    if (!Actor)
    {
        return false;
    }
 
    UWorld* World = Actor->GetWorld();
 
    if (World && Mesh)
    {
        FTransform Transform = Actor->GetActorTransform();
        FVector ActorLocation = Transform.GetLocation();
        FVector ActorScale = Transform.GetScale3D();
 
        // Calculate the top extent of the mesh bounds
        FVector MeshExtent = Mesh->GetBounds().BoxExtent;
        FVector TopExtent = FVector(MeshExtent.X, MeshExtent.Y, MeshExtent.Z * TopPercentage);
 
        FVector StartLocation = ActorLocation + FVector(0.0f, 0.0f, MeshExtent.Z);
        FVector EndLocation = ActorLocation + FVector(0.0f, 0.0f, MeshExtent.Z * TopPercentage);
 
        FHitResult HitResult;
        FCollisionQueryParams QueryParams;
        QueryParams.AddIgnoredActor(Actor);
 
        // Perform a line trace to check for collisions in the top percentage of the mesh
        return World->LineTraceSingleByChannel(HitResult, StartLocation, EndLocation, CollisionChannel, QueryParams);
    }
 
    return false;
}

References Transform.

FindOverlappingActorsInSphere()

TArray< AActor * > UPhysicsUtilities::FindOverlappingActorsInSphere ( const FTransform &  ActorTransform, float  Radius, bool  DebugVisualizeRadius = false  )

static

Finds all overlapping actors within a sphere.

Parameters

ActorTransform	The transform of the actor to check for overlaps.
Radius	The radius of the sphere.
DebugVisualizeRadius	If true, visualizes the sphere for 2 seconds in the editor for debugging purposes.

Returns

An array of overlapping actors within the sphere.

Definition at line 140 of file PhysicsUtilities.cpp.

{
    return FindOverlappingActorsOfClass<AActor>(ActorTransform, Radius, DebugVisualizeRadius);
}

FindOverlappingActorsOfClass()

template<typename T >

TArray< T * > UPhysicsUtilities::FindOverlappingActorsOfClass ( const FTransform &  ActorTransform, float  Radius, bool  DebugVisualizeRadius = false  )

static

Finds all overlapping actors of a specific class within a sphere.

Parameters

ActorTransform	The transform of the actor to check for overlaps.
Radius	The radius of the sphere.
DebugVisualizeRadius	If true, visualizes the sphere for 2 seconds in the editor for debugging purposes.

Returns

An array of overlapping actors of the specified class within the sphere.

Definition at line 182 of file PhysicsUtilities.cpp.

{
    TArray<T*> OverlappingActors;
 
    if (!GEngine || !GEngine->GameViewport)
    {
        return OverlappingActors;
    }
 
    UWorld* World = GEngine->GameViewport->GetWorld();
 
    if (World)
    {
        TArray<FOverlapResult> OverlapResults;
        FCollisionQueryParams Params;
        Params.AddIgnoredActor(nullptr);
        Params.bTraceComplex = false;
        Params.bReturnPhysicalMaterial = false;
 
        FCollisionObjectQueryParams ObjectQueryParams;
        ObjectQueryParams.AddObjectTypesToQuery(ECC_WorldStatic);
 
        bool bOverlap = World->OverlapMultiByObjectType(
            OverlapResults,
            ActorTransform.GetLocation(),
            ActorTransform.GetRotation(),
            ObjectQueryParams,
            FCollisionShape::MakeSphere(Radius),
            Params
        );
 
        if (bOverlap)
        {
            for (const FOverlapResult& OverlapResult : OverlapResults)
            {
                T* OverlappingActor = Cast<T>(OverlapResult.GetActor());
                if (OverlappingActor)
                {
                    OverlappingActors.Add(OverlappingActor);
                }
            }
        }
    }
 
#if WITH_EDITOR
    if (DebugVisualizeRadius)
    {
        DrawDebugSphere(World, ActorTransform.GetLocation(), Radius, 12, FColor::Green, false, 2.0f, 0, 1.0f);
    }
#endif
 
    return OverlappingActors;
}

HasOverlappingActors()

bool UPhysicsUtilities::HasOverlappingActors ( const UStaticMesh *  StaticMesh, const FTransform &  Transform  )

static

Checks if there are any overlapping actors based on a provided static mesh and transform.

Parameters

StaticMesh	The static mesh used to define the shape for overlap detection.
Transform	The transform of the actor to check for overlapping actors.

Returns

True if there are overlapping actors, false otherwise.

Definition at line 103 of file PhysicsUtilities.cpp.

{
    if (!StaticMesh)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("UPhysicsUtilities.cpp: StaticMesh is null!"));
#endif
        return false;
    }
 
    if (!GEngine || !GEngine->GameViewport)
    {
        return false;
    }
 
    TArray<FOverlapResult> OverlapResults;
 
    UWorld* World = GEngine->GameViewport->GetWorld();
    if (World)
    {
        FVector Location = Transform.GetLocation();
        FQuat Rotation = Transform.GetRotation();
        FVector Scale = Transform.GetScale3D();
        FBox ActorBounds = StaticMesh->GetBoundingBox().TransformBy(FTransform(Rotation, Location, Scale));
 
        World->OverlapMultiByObjectType(
            OverlapResults,
            Location,
            Rotation,
            FCollisionObjectQueryParams(ECC_WorldStatic),
            FCollisionShape::MakeBox(ActorBounds.GetSize() * 0.5f)
        );
    }
 
    return OverlapResults.Num() > 0;
}

References Transform.

SnapActorAboveGround()

bool UPhysicsUtilities::SnapActorAboveGround ( AActor *  Actor, float  AboveOffset = 50.0f  )

static

Snaps the given actor above ground

Parameters

Actor	The actor to snap to the ground.
AboveOffset	The offset value to the ground

Returns

True if the actor's position was adjusted, false otherwise.

Definition at line 51 of file PhysicsUtilities.cpp.

{
    if (!Actor)
    {
        return false;
    }
 
    // First snap actor to the ground
    SnapActorToGround(Actor);
 
    // Then add Z offset
    const FVector CurrentActorLocation = Actor->GetActorLocation();
    const FVector EndActorLocation = CurrentActorLocation + FVector(0.0f, 0.0f, AboveOffset);
    Actor->TeleportTo(EndActorLocation, Actor->GetActorRotation());
    //Actor->SetActorLocation(EndActorLocation);
 
    return true;
}

References SnapActorToGround().

Referenced by UAssetLibrary::SpawnVehicle().

SnapActorToGround()

bool UPhysicsUtilities::SnapActorToGround ( AActor *  Actor, float  StartZOffset = 600.0f, float  EndZOffset = 600.0f  )

static

Snaps the given actor to the ground by performing a line trace and adjusting its location.

Parameters

Actor	The actor to snap to the ground.
StartZOffset	The offset value added to the actor's original Z coordinate to determine the start location of the line trace.
EndZOffset	The offset value subtracted from the actor's original Z coordinate to determine the end location of the line trace.

Returns

True if the actor's position was adjusted, false otherwise.

Definition at line 19 of file PhysicsUtilities.cpp.

{
    bool ActorPositionWasChanged = false;
 
    if (!Actor)
    {
        return ActorPositionWasChanged;
    }
 
    UWorld* World = Actor->GetWorld();
    if (World && Actor)
    {
        // Perform a line trace from a point above the actor's location to a point slightly below it
        const FVector ActorLocation = Actor->GetActorLocation();
        const FVector StartLocation = ActorLocation + FVector(0.0f, 0.0f, StartZOffset);
        const FVector EndLocation = ActorLocation - FVector(0.0f, 0.0f, EndZOffset);
        FHitResult HitResult;
        FCollisionQueryParams QueryParams;
        QueryParams.AddIgnoredActor(Actor);
        bool Hits = World->LineTraceSingleByChannel(HitResult, StartLocation, EndLocation, ECC_WorldStatic, QueryParams);
 
        if (Hits)
        {
            //Actor->SetActorLocation(HitResult.ImpactPoint);
            Actor->TeleportTo(HitResult.ImpactPoint, Actor->GetActorRotation());
            ActorPositionWasChanged = true;
        }
    }
 
    return ActorPositionWasChanged;
}

Referenced by SnapActorAboveGround(), UAssetLibrary::TrySpawnActor(), and UAssetLibrary::TrySpawnActorDeferred().

---

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

• Unreal/Agrarsense/Source/Agrarsense/Physics/PhysicsUtilities.h
• Unreal/Agrarsense/Source/Agrarsense/Physics/PhysicsUtilities.cpp