InstancedRendererManager.cpp

Go to the documentation of this file.

// Copyright (c) 2025 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 "InstancedRendererManager.h"
#include "Agrarsense/Logging/CSVFile.h"
#include "Agrarsense/Utils/CoordinateConversionUtilities.h"
 
#include "Engine/World.h"
#include "GeoReferencingSystem.h"
#include "Kismet/GameplayStatics.h"
 
AInstancedRendererManager* AInstancedRendererManager::Instance = nullptr;
 
AInstancedRendererManager::AInstancedRendererManager(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer)
{
    PrimaryActorTick.bCanEverTick = false;
}
 
void AInstancedRendererManager::BeginPlay()
{
    Super::BeginPlay();
 
    if (!Instance)
    {
        Instance = this;
    }
    else
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: Instance already exists. Destroying this actor.."));
#endif
        Destroy();
    }
 
    UWorld* World = GetWorld();
 
    
    // Ensure we don't create ISM's for these maps.
    // Instance Segmentation Camera sensor doesn't support ISM/HISM components (or non-nanite meshes).
    FString MapName = World->GetMapName().ToLower();
    if (MapName.Contains(TEXT("vindeln_dev")) || MapName.Contains(TEXT("rovaniemiforest_dev")))
    {
        AllowISMCreation = false;
    }
 
    if (AllowISMCreation)
    {
        // Get all existing AInstancedActor in the world and try to add them to instanced rendering.
        TArray<AActor*> Actors;
        UGameplayStatics::GetAllActorsOfClass(World, AInstancedActor::StaticClass(), Actors);
 
        for (AActor* Actor : Actors)
        {
            AInstancedActor* InstancedActor = Cast<AInstancedActor>(Actor);
            if (InstancedActor && InstancedActor->CanAddToInstancedRenderer())
            {
                AddActorToInstancedRendering(InstancedActor);
            }
        }
 
        // Subscribe to OnActorSpawned event to catch any new AInstancedActor spawned in the world to add them to instanced rendering.
        ActorSpawnedDelegateHandle = World->AddOnActorSpawnedHandler(FOnActorSpawned::FDelegate::CreateUObject(this, &AInstancedRendererManager::OnActorSpawned));
    }
}
 
void AInstancedRendererManager::OnActorSpawned(AActor* Actor)
{
    if (AInstancedActor* InstancedActor = Cast<AInstancedActor>(Actor))
    {
        // Try to add the newly spawned AInstancedActor to instanced rendering.
        if (InstancedActor->CanAddToInstancedRenderer())
        {
            AddActorToInstancedRendering(InstancedActor);
        }
    }
}
 
void AInstancedRendererManager::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
 
    ActorSpawnedDelegateHandle.Reset();
 
    if (Instance == this)
    {
        Instance = nullptr;
    }
}
 
bool AInstancedRendererManager::AddActorToInstancedRendering(AInstancedActor* InstancedActor)
{
    if (!AllowISMCreation)
    {
        return false;
    }
 
    if (!InstancedActor)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: Actor is null!"));
#endif
        return false;
    }
 
    if (InstancedActor->UpdateTransformAutomatically())
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: AInstancedActor %s is set to update transform automatically."), *InstancedActor->GetName());
#endif
        return false;
    }
 
    UStaticMeshComponent* StaticMeshComponent = InstancedActor->GetStaticMeshComponent();
    if (!StaticMeshComponent)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: AInstancedActor %s UStaticMeshComponent is null!"), *InstancedActor->GetName());
#endif
        return false;
    }
 
    UStaticMesh* Mesh = StaticMeshComponent->GetStaticMesh();
    if (!Mesh)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: AInstancedActor %s UStaticMeshComponent mesh is null!"), *InstancedActor->GetName());
#endif
        return false;
    }
 
    // Loop throigh InstancedRenderers and check if we already have this type of instance in the world.
    for (AInstancedActorRenderer* Renderer : InstancedRenderers)
    {
        if (Renderer && Renderer->Matches(StaticMeshComponent, InstancedActor->AlternativeMaterial))
        {
            UInstancedStaticMeshComponent* Comp = Renderer->GetInstancedStaticMeshComponent();
            if (Comp)
            {
                Comp->AddInstance(InstancedActor->GetActorTransform());
                InstancedActor->InstanceAdded();
                InstancedActor->Destroy();
                return true;
            }
        }
    }
 
    // Else this is new instance, create new AInstancedActorRenderer Actor.
    FTransform SpawnTransform = FTransform::Identity;
    FActorSpawnParameters SpawnParams;
 
    AInstancedActorRenderer* NewRenderer = GetWorld()->SpawnActor<AInstancedActorRenderer>(
        AInstancedActorRenderer::StaticClass(),
        SpawnTransform,
        SpawnParams
    );
 
    InstancedRenderers.AddUnique(NewRenderer);
    NewRenderer->SetupFromInstancedActor(InstancedActor);
 
    return true;
}
 
bool AInstancedRendererManager::AppendISM(UInstancedStaticMeshComponent* ISM)
{
    if (!ISM)
    {
        return false;
    }
 
    for (AInstancedActorRenderer* Renderer : InstancedRenderers)
    {
        if (!Renderer || !Renderer->Matches(ISM))
        {
            continue;
        }
 
        UInstancedStaticMeshComponent* Comp = Renderer->GetInstancedStaticMeshComponent();
        if (!Comp)
        {
            continue;
        }
 
        const int32 InstanceCount = ISM->GetInstanceCount();
        for (int32 i = 0; i < InstanceCount; ++i)
        {
            FTransform InstanceTransform;
            if (ISM->GetInstanceTransform(i, InstanceTransform, true))
            {
                Comp->AddInstance(InstanceTransform);
            }
        }
 
        return true;
    }
 
    return false;
}
 
bool AInstancedRendererManager::AppendOrCreateISM(UInstancedStaticMeshComponent* ISM)
{
    if (!ISM)
    {
        return false;
    }
 
    if (!AppendISM(ISM))
    {
        FTransform SpawnTransform = FTransform::Identity;
        FActorSpawnParameters SpawnParams;
 
        AInstancedActorRenderer* NewRenderer = GetWorld()->SpawnActor<AInstancedActorRenderer>(
            AInstancedActorRenderer::StaticClass(),
            SpawnTransform,
            SpawnParams
        );
 
        if (!NewRenderer)
        {
            return false;
        }
 
        InstancedRenderers.AddUnique(NewRenderer);
 
        UInstancedStaticMeshComponent* Comp = NewRenderer->GetInstancedStaticMeshComponent();
 
        if (Comp)
        {
            Comp->SetStaticMesh(ISM->GetStaticMesh());
            const int32 NumberOfMaterials = ISM->GetNumMaterials();
            for (int32 i = 0; i < NumberOfMaterials; i++)
            {
                Comp->SetMaterial(i, ISM->GetMaterial(i));
            }
 
            TArray<FTransform> InstanceTransforms;
            for (int32 i = 0; i < ISM->GetInstanceCount(); i++)
            {
                FTransform InstanceTransform;
                if (ISM->GetInstanceTransform(i, InstanceTransform, true))
                {
                    InstanceTransforms.Add(InstanceTransform);
                }
            }
 
            for (const FTransform& Transform : InstanceTransforms)
            {
                Comp->AddInstance(Transform);
            }
        }
 
        return true;
    }
 
    return true;
}
 
void AInstancedRendererManager::SpawnAllInstancesBackToActors()
{
    for (int32 i = InstancedRenderers.Num() - 1; i >= 0; --i)
    {
        AInstancedActorRenderer* Renderer = InstancedRenderers[i];
        if (Renderer && Renderer->SpawnInstancesBackActors())
        {
            Renderer->Destroy();
            InstancedRenderers.RemoveAt(i);
        }
    }
}
 
TArray<AInstancedActorRenderer*> AInstancedRendererManager::GetAllInstancedActorRendererActors() const
{
    UWorld* World = GetWorld();
    if (World && !World->IsGameWorld())
    {
        TArray<AActor*> FoundActors;
        UGameplayStatics::GetAllActorsOfClass(World, AInstancedActorRenderer::StaticClass(), FoundActors);
 
        TArray<AInstancedActorRenderer*> RendererActors;
        for (AActor* Actor : FoundActors)
        {
            if (AInstancedActorRenderer* Renderer = Cast<AInstancedActorRenderer>(Actor))
            {
                RendererActors.AddUnique(Renderer);
            }
        }
        return RendererActors;
    }
 
    // If running at runtime (including PIE), return InstancedRenderers
    return InstancedRenderers;
}
 
int32 AInstancedRendererManager::GetTotalInstanceCount()
{
    int32 total = 0;
    for (AInstancedActorRenderer* Renderer : InstancedRenderers)
    {
        if (Renderer)
        {
            UInstancedStaticMeshComponent* Comp = Renderer->GetInstancedStaticMeshComponent();
            if (Comp)
            {
                total += Comp->GetInstanceCount();
            }
        }
    }
 
    TotalInstanceCount = total;
 
    return TotalInstanceCount;
}
 
bool AInstancedRendererManager::SpawnInstanceBackToActor(UInstancedStaticMeshComponent* ISM, int32 Index, bool OnlyTree)
{
    for (AInstancedActorRenderer* Renderer : InstancedRenderers)
    {
        if (Renderer && Renderer->SpawnInstanceBackToActor(ISM, Index, OnlyTree))
        {
            return true;
        }
    }
 
    // Didn't find instance or spawning instance back to actor failed.
    return false;
}
 
void AInstancedRendererManager::DestroyOverlappingInstancesBox(UInstancedStaticMeshComponent* ISM, FBox AreaBox, bool OnlyTrees)
{
    if (!ISM)
    {
        return;
    }
 
    for (AInstancedActorRenderer* Renderer : InstancedRenderers)
    {
        if (!Renderer)
        {
            continue;
        }
 
        FInstancedActorParameters params = Renderer->GetInstancedActorParameters();
        if (!params.IsTree && OnlyTrees)
        {
            continue;
        }
 
        UInstancedStaticMeshComponent* Comp = Renderer->GetInstancedStaticMeshComponent();
        if (Comp && Comp == ISM)
        {
            TArray<int32> OverlappingInstances = Comp->GetInstancesOverlappingBox(AreaBox);
 
            // Sort indices in descending order to avoid shifting issues
            OverlappingInstances.Sort([](int32 A, int32 B)
                {
                    return B < A;
                });
 
            for (int32 InstanceIndex : OverlappingInstances)
            {
                Comp->RemoveInstance(InstanceIndex);
            }
        }
    }
}
 
void AInstancedRendererManager::SetInstancedRendering(bool Visible)
{
    for (AInstancedActorRenderer* Renderer : InstancedRenderers)
    {
        if (Renderer)
        {
            UInstancedStaticMeshComponent* Comp = Renderer->GetInstancedStaticMeshComponent();
            if (Comp)
            {
                Comp->SetVisibility(Visible);
            }
        }
    }
}
 
void AInstancedRendererManager::ExportTreesAsCSV()
{
    AGeoReferencingSystem* GeoReferencingSystem = AGeoReferencingSystem::GetGeoReferencingSystem(GetWorld());
    TArray<TArray<FString>> Rows;
 
    for (AInstancedActorRenderer* Renderer : InstancedRenderers)
    {
        if (Renderer && Renderer->GetInstancedActorParameters().IsTree)
        {
            UInstancedStaticMeshComponent* ISM = Renderer->GetInstancedStaticMeshComponent();
            if (!ISM) continue;
 
            const int32 InstanceCount = ISM->GetInstanceCount();
            const FString MeshName = Renderer->GetStaticMesh() ? Renderer->GetStaticMesh()->GetName() : TEXT("Unknown");
 
            for (int32 i = 0; i < InstanceCount; ++i)
            {
                FTransform Transform;
                if (!ISM->GetInstanceTransform(i, Transform, true)) continue;
 
                const FVector Location = Transform.GetLocation();
                const FRotator Rotation = Transform.Rotator();
 
                FString LatitudeStr = TEXT(""), LongitudeStr = TEXT(""), AltitudeStr = TEXT("");
 
                if (GeoReferencingSystem)
                {
                    const FGeographicCoordinates GeographicCoordinates = UCoordinateConversionUtilities::UnrealToGeographicCoordinates(GeoReferencingSystem, Location);
                    LatitudeStr = FString::Printf(TEXT("%.8f"), GeographicCoordinates.Latitude);
                    LongitudeStr = FString::Printf(TEXT("%.8f"), GeographicCoordinates.Longitude);
                    AltitudeStr = FString::Printf(TEXT("%.8f"), GeographicCoordinates.Altitude);
                }
 
                TArray<FString> Row;
                Row.Add(MeshName);
                Row.Add(FString::Printf(TEXT("%.2f"), Location.X));
                Row.Add(FString::Printf(TEXT("%.2f"), Location.Y));
                Row.Add(FString::Printf(TEXT("%.2f"), Location.Z));
 
                if (GeoReferencingSystem)
                {
                    Row.Add(LatitudeStr);
                    Row.Add(LongitudeStr);
                    Row.Add(AltitudeStr);
                }
 
                Rows.Add(Row);
            }
        }
    }
 
    if (Rows.IsEmpty())
    {
        return;
    }
 
    // CSV file settings
    FCSVFileSettings Settings;
    Settings.Delimiter = ECSVDelimiter::Semicolon;
    Settings.Append = false;
    Settings.CreateUnique = true;
    Settings.FileWriteOption = FCSVFileWriteOptions::Queue;
 
    // Filename
    FString MapName = GetWorld()->GetMapName();
    FString FileName = MapName + TEXT("_TreeLocations");
 
    // Create CSV file
    UCSVFile* CSV = UCSVFile::CreateCSVFile(FileName, Settings);
 
    // Create CSV Header row
    TArray<FString> Header = { TEXT("name"), TEXT("x"), TEXT("y"), TEXT("z") };
    if (GeoReferencingSystem)
    {
        Header.Append({ TEXT("latitude"), TEXT("longitude"), TEXT("altitude") });
    }
    CSV->WriteRow(Header);
 
    // Write data rows
    for (const TArray<FString>& Row : Rows)
    {
        CSV->WriteRow(Row);
    }
 
    // Finish writing and close the file
    CSV->Destroy();
}