AssetLibrary.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 "AssetLibrary.h"
 
#include "Agrarsense/Physics/PhysicsUtilities.h"
#include "Agrarsense/Logging/SimulatorLog.h"
#include "Agrarsense/Utils/EnumUtilities.h"
#include "Agrarsense/ActorInterfaces/ActorInformation.h"
#include "Agrarsense/InstancedRendering/InstancedActor.h"
#include "Agrarsense/Vehicle/Vehicle.h"
#include "Agrarsense/Vehicle/Forwarder.h"
#include "Agrarsense/Vehicle/Harvester.h"
#include "Agrarsense/Vehicle/PIDDrone.h"
 
#include "Agrarsense/Walker/Walker.h"
#include "Agrarsense/Walker/WalkerActorAssetMapDataAsset.h"
#include "Agrarsense/Walker/WalkerActorAssetDataAsset.h"
 
#include "Kismet/KismetSystemLibrary.h"
#include "Engine/GameViewportClient.h"
#include "GameFramework/Actor.h"
#include "Engine/Engine.h"
#include "UObject/Class.h"
#include "Engine/World.h"
 
// Paths to data assets
static const FString VEHICLE_ASSET_PATH = "/Game/Agrarsense/Data/Vehicles/VehicleActorAssetMap";
static const FString FOLIAGE_ASSET_PATH = "/Game/Agrarsense/Data/Foliage/FoliageActorAssetMap";
static const FString WALKER_ASSET_PATH = "/Game/Agrarsense/Data/Walkers/WalkerActorAssetMap";
static const FString PROP_ASSET_PATH = "/Game/Agrarsense/Data/Props/PropActorAssetMap";
 
TWeakObjectPtr<UFoliageActorAssetMapDataAsset> UAssetLibrary::FoliageActorAssetMapDataAsset;
TArray<FInstancedActorData> UAssetLibrary::AddedFoliageActors;
TMap<EFoliageTypes, FString> UAssetLibrary::FoliageTypeMap;
TArray<EFoliageTypes> UAssetLibrary::FoliageKeys;
 
TWeakObjectPtr <UVehicleActorAssetMapDataAsset> UAssetLibrary::VehicleDataAsset;
TArray<FVehicleData> UAssetLibrary::SpawnedVehicles;
 
TWeakObjectPtr<UPropActorAssetMapDataAsset> UAssetLibrary::PropActorAssetMapDataAsset;
TArray<FInstancedActorData> UAssetLibrary::SpawnedPropActors;
TMap<EPropTypes, FString> UAssetLibrary::PropTypeMap;
TArray<EPropTypes> UAssetLibrary::PropKeys;
 
TWeakObjectPtr<UWalkerActorAssetMapDataAsset> UAssetLibrary::WalkerActorAssetMapDataAsset;
TArray<TWeakObjectPtr<AWalker>> UAssetLibrary::SpawnedWalkers;
 
AActor* UAssetLibrary::SpawnFoliage(EFoliageTypes FoliageType, FTransform Transform, 
    FString ActorName, FString ActorID,
    bool RandomZRotation, bool SnapToGround)
{
    SetupFoliageDataAsset();
 
    if (!FoliageActorAssetMapDataAsset.IsValid())
    {
        return nullptr;
    }
 
    UFoliageActorAssetDataAsset* ActorAssetData = FoliageActorAssetMapDataAsset->Foliages.FindRef(FoliageType);
    TSubclassOf<AActor> ActorClass = ActorAssetData ? ActorAssetData->ActorAsset.Actor : nullptr;
 
    AActor* SpawnedActor = TrySpawnActor(ActorClass, Transform, ActorName, ActorID, SnapToGround, RandomZRotation);
 
    AInstancedActor* InstancedActor = Cast<AInstancedActor>(SpawnedActor);
    if (InstancedActor)
    {
        if (FoliageTypeMap.Contains(FoliageType))
        {
            // Set InstactedActor type and model strings, this is used for JSON exporting.
            FString Model = FoliageTypeMap[FoliageType];
            InstancedActor->SetTypeAndModel("foliage", Model);
        }
 
        // Add to array
        FInstancedActorData Data;
        Data.Actor = InstancedActor;
        AddedFoliageActors.Add(Data);
    }
 
    return SpawnedActor;
}
 
AVehicle* UAssetLibrary::SpawnVehicle(EVehicleTypes VehicleType,
    FTransform SpawnTransform, const FString& ActorName,
    const FString& ActorID, bool SnapAboveGround,
    const float AboveOffset, const bool DestroyOverlappingActors)
{
    SetupVehicleDataAsset();
 
    if (!VehicleDataAsset.IsValid())
    {
        return nullptr;
    }
 
    UVehicleActorAssetDataAsset* ActorAssetData = VehicleDataAsset->Vehicles.FindRef(VehicleType);
    TSubclassOf<AActor> ActorClass = ActorAssetData ? ActorAssetData->ActorAsset.Actor : nullptr;
 
    ESpawnActorCollisionHandlingMethod SpawnCollisionHandling = ESpawnActorCollisionHandlingMethod::Undefined;
    if (VehicleType == EVehicleTypes::Drone)
    {
        // Workaround for drone
        SpawnCollisionHandling = ESpawnActorCollisionHandlingMethod::AlwaysSpawn;
    }
 
    FString ID = ActorID;
    if (ID.IsEmpty())
    {
        ID = UEnumUtilities::ConvertVehicleTypeToString(VehicleType);
    }
 
    AActor* SpawnedActor = TrySpawnActor(ActorClass, SpawnTransform, ActorName, ID, false, false, SpawnCollisionHandling);
 
    AVehicle* Vehicle = Cast<AVehicle>(SpawnedActor);
    if (SpawnedActor && Vehicle)
    {
        if (SnapAboveGround)
        {
            UPhysicsUtilities::SnapActorAboveGround(Vehicle, AboveOffset);
            SpawnTransform = SpawnedActor->GetTransform();
        }
 
        FVehicleData VehicleData;
        VehicleData.Vehicle = Vehicle;
        VehicleData.VehicleType = VehicleType;
        SpawnedVehicles.Add(VehicleData);
 
        Vehicle->TeleportTo(SpawnTransform.GetLocation(), SpawnTransform.GetRotation().Rotator());
 
        if (DestroyOverlappingActors)
        {
            DestroyOverlappingActorsSphere(Vehicle);
        }
 
        // Add to array
        FVehicleData Data;
        Data.Vehicle = Vehicle;
        Data.VehicleType = Vehicle->GetVehicleType();
        SpawnedVehicles.Add(Data);
    }
 
    return Vehicle;
}
 
AActor* UAssetLibrary::SpawnProp(EPropTypes PropType, FTransform Transform, 
    FString ActorName, FString ActorID, 
    bool RandomZRotation, bool SnapToGround)
{
    SetupPropDataAsset();
 
    if (!PropActorAssetMapDataAsset.IsValid())
    {
        return nullptr;
    }
 
    UPropActorAssetDataAsset* ActorAssetData = PropActorAssetMapDataAsset->Props.FindRef(PropType);
    TSubclassOf<AActor> ActorClass = ActorAssetData ? ActorAssetData->ActorAsset.Actor : nullptr;
 
    AActor* SpawnedActor = TrySpawnActor(ActorClass, Transform, ActorName, ActorID, SnapToGround, RandomZRotation);
 
    AInstancedActor* InstancedActor = Cast<AInstancedActor>(SpawnedActor);
    if (InstancedActor)
    {
        FInstancedActorData InstancedActorData;
        InstancedActorData.Actor = InstancedActor;
        SpawnedPropActors.Add(InstancedActorData);
 
        if (PropTypeMap.Contains(PropType))
        {
            // Set InstactedActor type and model strings, this is used for JSON exporting.
            FString Model = PropTypeMap[PropType];
            InstancedActor->SetTypeAndModel("prop", Model);
        }
 
 
        // Add to array
        FInstancedActorData Data;
        Data.Actor = InstancedActor;
        SpawnedPropActors.Add(Data);
    }
 
    return SpawnedActor;
}
 
AWalker* UAssetLibrary::SpawnWalker(FWalkerParameters Parameters, const FString& ActorName, 
    const FString& ActorID, bool StartAutomatically)
{
    SetupWalkerDataAsset();
 
    if (!WalkerActorAssetMapDataAsset.IsValid()) 
    {
        return nullptr;
    }
 
    UWalkerActorAssetDataAsset* ActorAssetData = WalkerActorAssetMapDataAsset->Walkers.FindRef(Parameters.WalkerType);
    TSubclassOf<AActor> ActorClass = ActorAssetData ? ActorAssetData->ActorAsset.Actor : nullptr;
 
    FTransform StartTransform;
    auto& Transforms = Parameters.Points;
 
    if (!Transforms.IsEmpty())
    {
        if (Parameters.WalkerAction == EWalkerAction::FollowPath && Transforms.Num() < 2)
        {
            SimulatorLog::Log("Failed to spawn FollowPath Walker due to insufficient path points.");
            return nullptr;
        }
        StartTransform = Transforms[0];
    }
 
    FString ID = ActorID;
    if (ID.IsEmpty())
    {
        ID = UEnumUtilities::ConvertWalkerTypeToString(Parameters.WalkerType);
    }
 
    AActor* SpawnedActor = TrySpawnActor(ActorClass, StartTransform, ActorName, ID, false, false);
 
    AWalker* Walker = Cast<AWalker>(SpawnedActor);
    if (Walker)
    {
        SpawnedWalkers.Add(Walker);
        Walker->SetWalkerParameters(Parameters);
        Walker->SetIgnoreInput(!StartAutomatically);
 
        // Add to array
        SpawnedWalkers.Add(Walker);
    }
 
    return Walker;
}
 
AActor* UAssetLibrary::TrySpawnActor(TSubclassOf<AActor> ActorClass, FTransform& Transform,
    FString ActorName, FString ActorID,
    bool SnapToGround, bool RandomZRotation, ESpawnActorCollisionHandlingMethod CollisionMethod)
{
    if (!IsInGameThread())
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("AssetLibrary.cpp: Attempting to spawn actor from a background thread. This is not allowed."));
#endif
        return nullptr;
    }
 
    if (!ActorClass)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("AssetLibrary.cpp: ActorClass is nullptr! Cannot spawn actor."));
#endif
        return nullptr;
    }
 
    UWorld* World = nullptr;
    if (GEngine && GEngine->GameViewport)
    {
        World = GEngine->GameViewport->GetWorld();
    }
 
    if (!World)
    {
        return nullptr;
    }
 
    // Spawn actor deferred 
    AActor* SpawnedActor = World->SpawnActorDeferred<AActor>(ActorClass, Transform, nullptr, nullptr, CollisionMethod);
 
    if (SpawnedActor)
    {
        if (SnapToGround)
        {
            UPhysicsUtilities::SnapActorToGround(SpawnedActor);
            Transform = SpawnedActor->GetTransform();
        }
 
        if (RandomZRotation)
        {
            float RotationAngle = FMath::FRandRange(0.0f, 360.0f);
            Transform.SetRotation(FQuat::MakeFromEuler(FVector(0.0f, 0.0f, RotationAngle)));
        }
 
        // Set ID and name through IActorInformation if the spawned actor implements it
        if (SpawnedActor && SpawnedActor->GetClass()->ImplementsInterface(UActorInformation::StaticClass()))
        {
            IActorInformation::Execute_SetActorIDAndName(SpawnedActor, ActorName, ActorID);
        }
 
        // Finish Actor spawning (BeginPlay runs now)
        SpawnedActor->FinishSpawning(Transform);
    }
 
    return SpawnedActor;
}
 
void UAssetLibrary::DestroyOverlappingActorsSphere(AActor* SpawnedActor)
{
    UWorld* World = nullptr;
    if (GEngine && GEngine->GameViewport)
    {
        World = GEngine->GameViewport->GetWorld();
    }
 
    if (!World || !SpawnedActor)
    {
        return;
    }
 
    FVector Origin;
    FVector BoxExtent;
    SpawnedActor->GetActorBounds(true, Origin, BoxExtent);
 
    float SphereRadius = BoxExtent.GetMax();
 
    TArray<AActor*> OverlappingActors;
    UKismetSystemLibrary::SphereOverlapActors(World, SpawnedActor->GetTransform().GetLocation(), SphereRadius, {}, nullptr, {}, OverlappingActors);
 
    for (AActor* OverlappingActor : OverlappingActors)
    {
        if (OverlappingActor && OverlappingActor != SpawnedActor)
        {
            if (OverlappingActor->IsA(AWalker::StaticClass()) ||
                OverlappingActor->IsA(AInstancedActor::StaticClass()) ||
                OverlappingActor->IsA(AVehicle::StaticClass()))
            {
                OverlappingActor->Destroy();
            }
        }
    }
}
 
TArray<FVehicleData> UAssetLibrary::GetSpawnedVehicles()
{
    SpawnedVehicles.RemoveAll([](const FVehicleData& VehicleData)
        {
            return !VehicleData.Vehicle.IsValid();
        });
 
    return SpawnedVehicles;
}
 
UFoliageActorAssetMapDataAsset* UAssetLibrary::GetFoliageActorAssetMapDataAsset()
{
    SetupFoliageDataAsset();
 
    return FoliageActorAssetMapDataAsset.Get();
}
 
EFoliageTypes UAssetLibrary::GetRandomFoliageType()
{
    SetupFoliageDataAsset();
 
    EFoliageTypes RandomFoliageType = EFoliageTypes::NONE;
    if (FoliageKeys.Num())
    {
        int32 RandomIndex = FMath::RandRange(0, FoliageKeys.Num() - 1);
        RandomFoliageType = FoliageKeys[RandomIndex];
    }
 
    return RandomFoliageType;
}
 
TArray<AInstancedActor*> UAssetLibrary::GetAllAddedFoliageActors()
{
    AddedFoliageActors.RemoveAll([](const FInstancedActorData& ActorData)
        {
            return !ActorData.Actor.IsValid();
        });
 
    TArray<AInstancedActor*> ValidActors;
    ValidActors.Reserve(AddedFoliageActors.Num());
 
    for (const FInstancedActorData& ActorData : AddedFoliageActors)
    {
        if (ActorData.Actor.IsValid())
        {
            ValidActors.Add(ActorData.Actor.Get());
        }
    }
 
    return ValidActors;
}
 
UPropActorAssetMapDataAsset* UAssetLibrary::GetPropActorAssetMapDataAsset()
{
    SetupPropDataAsset();
 
    return PropActorAssetMapDataAsset.Get();
}
 
EPropTypes UAssetLibrary::GetRandomPropType()
{
    SetupPropDataAsset();
 
    EPropTypes RandomPropType = EPropTypes::NONE;
    if (PropKeys.Num())
    {
        int32 RandomIndex = FMath::RandRange(0, PropKeys.Num() - 1);
        RandomPropType = PropKeys[RandomIndex];
    }
 
    return RandomPropType;
}
 
TArray<AInstancedActor*> UAssetLibrary::GetAllAddedPropActors()
{
    SpawnedPropActors.RemoveAll([](const FInstancedActorData& ActorData)
        {
            return !ActorData.Actor.IsValid();
        });
 
    TArray<AInstancedActor*> ValidActors;
    ValidActors.Reserve(SpawnedPropActors.Num());
 
    for (const FInstancedActorData& ActorData : SpawnedPropActors)
    {
        if (ActorData.Actor.IsValid())
        {
            ValidActors.Add(ActorData.Actor.Get());
        }
    }
 
    return ValidActors;
}
 
UWalkerActorAssetMapDataAsset* UAssetLibrary::GetWalkerActorAssetMapDataAsset()
{
    SetupWalkerDataAsset();
 
    return WalkerActorAssetMapDataAsset.Get();
}
 
TArray<AWalker*> UAssetLibrary::GetAllWalkers()
{
    SpawnedWalkers.RemoveAll([](const TWeakObjectPtr<AWalker>& ActorData)
        {
            return !ActorData.IsValid();
        });
 
    TArray<AWalker*> ValidWalkers;
    ValidWalkers.Reserve(SpawnedWalkers.Num());
 
    for (const TWeakObjectPtr<AWalker>& ActorData : SpawnedWalkers)
    {
        AWalker* WalkerPtr = ActorData.Get();
        if (WalkerPtr)
        {
            ValidWalkers.Add(WalkerPtr);
        }
    }
 
    return ValidWalkers;
}
 
void UAssetLibrary::DestroyAllWalkers()
{
    TArray<AWalker*> WalkersActors = GetAllWalkers();
 
    if (WalkersActors.IsEmpty())
    {
        return;
    }
 
    for (AWalker* Walker : WalkersActors)
    {
        if (Walker)
        {
            Walker->Destroy();
        }
    }
 
    WalkersActors.Empty();
 
    FString Message = FString::Printf(TEXT("Destroyed all %d Walkers."), WalkersActors.Num());
    SimulatorLog::Log(Message);
}
 
void UAssetLibrary::SetupVehicleDataAsset()
{
    if (!VehicleDataAsset.IsValid())
    {
        VehicleDataAsset.Reset();
        FSoftObjectPath VehicleActorAssetMap(VEHICLE_ASSET_PATH);
        VehicleDataAsset = Cast<UVehicleActorAssetMapDataAsset>(VehicleActorAssetMap.TryLoad());
    }
}
 
void UAssetLibrary::SetupFoliageDataAsset()
{
    if (FoliageActorAssetMapDataAsset.IsValid())
    {
        return;
    }
 
    FoliageActorAssetMapDataAsset.Reset();
    FSoftObjectPath FoliageActorAssetMapDataAssetPath(FOLIAGE_ASSET_PATH);
    FoliageActorAssetMapDataAsset = Cast<UFoliageActorAssetMapDataAsset>(FoliageActorAssetMapDataAssetPath.TryLoad());
 
    if (FoliageActorAssetMapDataAsset.IsValid())
    {
        FoliageActorAssetMapDataAsset->Foliages.GetKeys(FoliageKeys);
        FoliageTypeMap.Empty();
        FoliageTypeMap = UEnumUtilities::CreateEnumStringMap<EFoliageTypes>("/Script/Agrarsense.EFoliageTypes");
    }
}
 
void UAssetLibrary::SetupPropDataAsset()
{
    if (PropActorAssetMapDataAsset.IsValid())
    {
        return;
    }
 
    FSoftObjectPath PropActorAssetMapDataAssetPath(PROP_ASSET_PATH);
    PropActorAssetMapDataAsset = Cast<UPropActorAssetMapDataAsset>(PropActorAssetMapDataAssetPath.TryLoad());
 
    if (PropActorAssetMapDataAsset.IsValid())
    {
        PropActorAssetMapDataAsset->Props.GetKeys(PropKeys);
        SpawnedPropActors.Empty();
 
        PropTypeMap.Empty();
        PropTypeMap = UEnumUtilities::CreateEnumStringMap<EPropTypes>("/Script/Agrarsense.EPropTypes");
    }
}
 
void UAssetLibrary::SetupWalkerDataAsset()
{
    if (!WalkerActorAssetMapDataAsset.IsValid())
    {
        FSoftObjectPath WalkerActorAssetMapDataAssetPath(WALKER_ASSET_PATH);
        WalkerActorAssetMapDataAsset = Cast<UWalkerActorAssetMapDataAsset>(WalkerActorAssetMapDataAssetPath.TryLoad());
    }
}