#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)

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 19 of file PhysicsUtilities.h.

Member Function Documentation

◆ 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 68 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 138 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 144 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 101 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 49 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 17 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(), and UAssetLibrary::TrySpawnActor().

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

Static Public Member Functions

Detailed Description

Member Function Documentation

◆ DoesTopPercentageMeshOverlap()

◆ FindOverlappingActorsInSphere()

◆ FindOverlappingActorsOfClass()

◆ HasOverlappingActors()

◆ SnapActorAboveGround()

◆ SnapActorToGround()