PhysicsUtilities.cpp

Go to the documentation of this file.

// Copyright (c) 2023 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#include "PhysicsUtilities.h"
#include "GameFramework/Actor.h"
#include "Engine/GameViewportClient.h"
#include "Engine/OverlapResult.h"
#include "Engine/HitResult.h"
#include "Engine/EngineTypes.h"
#include "Engine/Engine.h"
#include "Engine/World.h"
 
#if WITH_EDITOR
#include "DrawDebugHelpers.h"
#endif
 
bool UPhysicsUtilities::SnapActorToGround(AActor* Actor, float StartZOffset, float EndZOffset)
{
    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;
}
 
bool UPhysicsUtilities::SnapActorAboveGround(AActor* Actor, float AboveOffset)
{
    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;
}
 
bool UPhysicsUtilities::DoesTopPercentageMeshOverlap(AActor* Actor, const UStaticMesh* Mesh, float TopPercentage, ECollisionChannel CollisionChannel)
{
    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;
}
 
bool UPhysicsUtilities::HasOverlappingActors(const UStaticMesh* StaticMesh, const FTransform& Transform)
{
    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;
}
 
TArray<AActor*> UPhysicsUtilities::FindOverlappingActorsInSphere(const FTransform& ActorTransform, float Radius, bool DebugVisualizeRadius)
{
    return FindOverlappingActorsOfClass<AActor>(ActorTransform, Radius, DebugVisualizeRadius);
}
 
bool UPhysicsUtilities::AlignTransformFromGroundInMeters(AActor* Actor, FTransform& InTransform)
{
    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;
}
 
template<typename T>
TArray<T*> UPhysicsUtilities::FindOverlappingActorsOfClass(const FTransform& ActorTransform, float Radius, bool DebugVisualizeRadius)
{
    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;
}