#include <InstancedRendererManager.h>

Inheritance diagram for AInstancedRendererManager:

Collaboration diagram for AInstancedRendererManager:

Public Member Functions
	AInstancedRendererManager (const FObjectInitializer &ObjectInitializer)

virtual void	BeginPlay () override

virtual void	EndPlay (const EEndPlayReason::Type EndPlayReason) override

bool	AddActorToInstancedRendering (AInstancedActor *InstancedActor)

bool	AppendISM (UInstancedStaticMeshComponent *ISM)

bool	AppendOrCreateISM (UInstancedStaticMeshComponent *ISM)

void	SpawnAllInstancesBackToActors ()

bool	SpawnInstanceBackToActor (UInstancedStaticMeshComponent *ISM, int32 Index, bool OnlyTree)

void	ExportTreesAsCSV ()

void	DestroyOverlappingInstancesBox (UInstancedStaticMeshComponent *ISM, FBox AreaBox, bool OnlyTrees)

void	SetInstancedRendering (bool Visible)

TArray< AInstancedActorRenderer * >	GetAllInstancedActorRendererActors () const

int32	GetTotalInstanceCount ()

Protected Attributes
TArray< AInstancedActorRenderer * >	InstancedRenderers

int32	TotalInstanceCount = 0

Private Member Functions
void	OnActorSpawned (AActor *Actor)

Private Attributes
FDelegateHandle	ActorSpawnedDelegateHandle

bool	AllowISMCreation = true

Static Private Attributes
static AInstancedRendererManager *	Instance = nullptr

Detailed Description

Manages all AInstancedActorRenderer actors. Handles adding/removing instances, spawning them back into actors, and toggling visibility.

Definition at line 20 of file InstancedRendererManager.h.

Constructor & Destructor Documentation

◆ AInstancedRendererManager()

AInstancedRendererManager::AInstancedRendererManager ( const FObjectInitializer & ObjectInitializer )

Definition at line 16 of file InstancedRendererManager.cpp.

                                                                                                : Super(ObjectInitializer)
{
    PrimaryActorTick.bCanEverTick = false;
}

Member Function Documentation

◆ AddActorToInstancedRendering()

bool AInstancedRendererManager::AddActorToInstancedRendering ( AInstancedActor * InstancedActor )

Adds an AInstancedActor to the appropriate instanced renderer.

Definition at line 92 of file InstancedRendererManager.cpp.

{
    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;
}

References AllowISMCreation, AInstancedActor::AlternativeMaterial, AInstancedActor::GetStaticMeshComponent(), AInstancedActor::InstanceAdded(), InstancedRenderers, AInstancedActorRenderer::SetupFromInstancedActor(), and AInstancedActor::UpdateTransformAutomatically().

Referenced by BeginPlay(), and OnActorSpawned().

◆ AppendISM()

bool AInstancedRendererManager::AppendISM ( UInstancedStaticMeshComponent * ISM )

Appends an existing Instanced Static Mesh (ISM) to a matching AInstancedActorRenderer instance.

Definition at line 165 of file InstancedRendererManager.cpp.

{
    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;
}

References InstancedRenderers.

Referenced by AppendOrCreateISM().

◆ AppendOrCreateISM()

bool AInstancedRendererManager::AppendOrCreateISM ( UInstancedStaticMeshComponent * ISM )

Appends an existing Instanced Static Mesh (ISM) to a matching AInstancedActorRenderer instance. If no matching renderer exists, creates a new one.

Definition at line 201 of file InstancedRendererManager.cpp.

{
    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;
}

References AppendISM(), AInstancedActorRenderer::GetInstancedStaticMeshComponent(), InstancedRenderers, and Transform.

◆ BeginPlay()

void AInstancedRendererManager::BeginPlay ( )

overridevirtual

Definition at line 21 of file InstancedRendererManager.cpp.

{
    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));
    }
}

References ActorSpawnedDelegateHandle, AddActorToInstancedRendering(), AllowISMCreation, AInstancedActor::CanAddToInstancedRenderer(), Destroy, Instance, and OnActorSpawned().

◆ DestroyOverlappingInstancesBox()

void AInstancedRendererManager::DestroyOverlappingInstancesBox	(	UInstancedStaticMeshComponent *	ISM,
		FBox	AreaBox,
		bool	OnlyTrees
	)

Destroys all instances overlapping the specified Box area.

Parameters

ISM	- The instanced static mesh component.
AreaBox	- The bounding box defining the area to check.
OnlyTrees	- Whether to limit destruction to tree instances only.

Definition at line 329 of file InstancedRendererManager.cpp.

{
    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);
            }
        }
    }
}

References InstancedRenderers, and FInstancedActorParameters::IsTree.

Referenced by ADeletionVolume::DestroyOverlappingActors().

◆ EndPlay()

void AInstancedRendererManager::EndPlay ( const EEndPlayReason::Type EndPlayReason )

overridevirtual

Definition at line 80 of file InstancedRendererManager.cpp.

{
    Super::EndPlay(EndPlayReason);
 
    ActorSpawnedDelegateHandle.Reset();
 
    if (Instance == this)
    {
        Instance = nullptr;
    }
}

References ActorSpawnedDelegateHandle, and Instance.

◆ ExportTreesAsCSV()

void AInstancedRendererManager::ExportTreesAsCSV ( )

Definition at line 383 of file InstancedRendererManager.cpp.

{
    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();
}

References FCSVFileSettings::Append, UCSVFile::CreateCSVFile(), FCSVFileSettings::CreateUnique, FCSVFileSettings::Delimiter, UCSVFile::Destroy(), FCSVFileSettings::FileWriteOption, InstancedRenderers, Queue, Semicolon, Transform, UCoordinateConversionUtilities::UnrealToGeographicCoordinates(), and UCSVFile::WriteRow().

◆ GetAllInstancedActorRendererActors()

TArray< AInstancedActorRenderer * > AInstancedRendererManager::GetAllInstancedActorRendererActors ( ) const

Definition at line 272 of file InstancedRendererManager.cpp.

{
    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;
}

References InstancedRenderers.

◆ GetTotalInstanceCount()

int32 AInstancedRendererManager::GetTotalInstanceCount ( )

Definition at line 295 of file InstancedRendererManager.cpp.

{
    int32 total = 0;
    for (AInstancedActorRenderer* Renderer : InstancedRenderers)
    {
        if (Renderer)
        {
            UInstancedStaticMeshComponent* Comp = Renderer->GetInstancedStaticMeshComponent();
            if (Comp)
            {
                total += Comp->GetInstanceCount();
            }
        }
    }
 
    TotalInstanceCount = total;
 
    return TotalInstanceCount;
}

References InstancedRenderers, and TotalInstanceCount.

◆ OnActorSpawned()

void AInstancedRendererManager::OnActorSpawned ( AActor * Actor )

private

Definition at line 68 of file InstancedRendererManager.cpp.

{
    if (AInstancedActor* InstancedActor = Cast<AInstancedActor>(Actor))
    {
        // Try to add the newly spawned AInstancedActor to instanced rendering.
        if (InstancedActor->CanAddToInstancedRenderer())
        {
            AddActorToInstancedRendering(InstancedActor);
        }
    }
}

References AddActorToInstancedRendering().

Referenced by BeginPlay().

◆ SetInstancedRendering()

void AInstancedRendererManager::SetInstancedRendering ( bool Visible )

Set all ISM components visibility.

Definition at line 368 of file InstancedRendererManager.cpp.

{
    for (AInstancedActorRenderer* Renderer : InstancedRenderers)
    {
        if (Renderer)
        {
            UInstancedStaticMeshComponent* Comp = Renderer->GetInstancedStaticMeshComponent();
            if (Comp)
            {
                Comp->SetVisibility(Visible);
            }
        }
    }
}

References InstancedRenderers.

Referenced by UAgrarsenseSettings::SetInstancedRenderingVisibility().

◆ SpawnAllInstancesBackToActors()

void AInstancedRendererManager::SpawnAllInstancesBackToActors ( )

Spawn all instanced back to actors.

Definition at line 259 of file InstancedRendererManager.cpp.

{
    for (int32 i = InstancedRenderers.Num() - 1; i >= 0; --i)
    {
        AInstancedActorRenderer* Renderer = InstancedRenderers[i];
        if (Renderer && Renderer->SpawnInstancesBackActors())
        {
            Renderer->Destroy();
            InstancedRenderers.RemoveAt(i);
        }
    }
}

References InstancedRenderers, and AInstancedActorRenderer::SpawnInstancesBackActors().

◆ SpawnInstanceBackToActor()

bool AInstancedRendererManager::SpawnInstanceBackToActor	(	UInstancedStaticMeshComponent *	ISM,
		int32	Index,
		bool	OnlyTree
	)

Spawns a specific ISM instance back to its original Actor. Cannot be added back to ISM instance afterwards.

Parameters

ISM	The instanced static mesh component containing the instance.
Index	The index of the instance to spawn back.

Returns: True if the instance was successfully spawned, false otherwise.

Definition at line 315 of file InstancedRendererManager.cpp.

{
    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;
}

References InstancedRenderers.

Member Data Documentation

◆ ActorSpawnedDelegateHandle

FDelegateHandle AInstancedRendererManager::ActorSpawnedDelegateHandle

private

Definition at line 103 of file InstancedRendererManager.h.

Referenced by BeginPlay(), and EndPlay().

◆ AllowISMCreation

bool AInstancedRendererManager::AllowISMCreation = true

private

Definition at line 105 of file InstancedRendererManager.h.

Referenced by AddActorToInstancedRendering(), and BeginPlay().

◆ Instance

AInstancedRendererManager * AInstancedRendererManager::Instance = nullptr

staticprivate

Definition at line 101 of file InstancedRendererManager.h.

Referenced by BeginPlay(), and EndPlay().

◆ InstancedRenderers

TArray<AInstancedActorRenderer*> AInstancedRendererManager::InstancedRenderers

protected

Definition at line 92 of file InstancedRendererManager.h.

Referenced by AddActorToInstancedRendering(), AppendISM(), AppendOrCreateISM(), DestroyOverlappingInstancesBox(), ExportTreesAsCSV(), GetAllInstancedActorRendererActors(), GetTotalInstanceCount(), SetInstancedRendering(), SpawnAllInstancesBackToActors(), and SpawnInstanceBackToActor().

◆ TotalInstanceCount

int32 AInstancedRendererManager::TotalInstanceCount = 0

protected

Definition at line 95 of file InstancedRendererManager.h.

Referenced by GetTotalInstanceCount().

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

Unreal/Agrarsense/Source/Agrarsense/InstancedRendering/InstancedRendererManager.h
Unreal/Agrarsense/Source/Agrarsense/InstancedRendering/InstancedRendererManager.cpp

Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AInstancedRendererManager()

Member Function Documentation

◆ AddActorToInstancedRendering()

◆ AppendISM()

◆ AppendOrCreateISM()

◆ BeginPlay()

◆ DestroyOverlappingInstancesBox()

◆ EndPlay()

◆ ExportTreesAsCSV()

◆ GetAllInstancedActorRendererActors()

◆ GetTotalInstanceCount()

◆ OnActorSpawned()

◆ SetInstancedRendering()

◆ SpawnAllInstancesBackToActors()

◆ SpawnInstanceBackToActor()

Member Data Documentation

◆ ActorSpawnedDelegateHandle

◆ AllowISMCreation

◆ Instance

◆ InstancedRenderers

◆ TotalInstanceCount