#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 Attributes
bool	AllowISMCreation = false

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 65 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 AInstancedActor::AddToInstancedRendering().

◆ AppendISM()

bool AInstancedRendererManager::AppendISM ( UInstancedStaticMeshComponent * ISM )

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

Definition at line 138 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 174 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();
    }
 
#ifdef InstanceSegmentationPass_EXISTS
    // if using our fork of Unreal Engine, user can use instance segmentation sensor, 
    // but only in Vindeln_Dev or RovaniemiForest_Dev maps where 
    // there are no ISM instances (expect for landscape vegetation)
    FString MapName = GetWorld()->GetMapName().ToLower();
 
    if (MapName.Contains(TEXT("vindeln")) && !MapName.Contains(TEXT("dev")))
    {
        AllowISMCreation = true;
    }
 
    if (MapName.Contains(TEXT("rovaniemiforest")) && !MapName.Contains(TEXT("dev")))
    {
        AllowISMCreation = true;
    }
#endif
}

References AllowISMCreation, Destroy, and Instance.

◆ 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 302 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 55 of file InstancedRendererManager.cpp.

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

References Instance.

◆ ExportTreesAsCSV()

void AInstancedRendererManager::ExportTreesAsCSV ( )

Definition at line 356 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 245 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 268 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.

◆ SetInstancedRendering()

void AInstancedRendererManager::SetInstancedRendering ( bool Visible )

Set all ISM components visibility.

Definition at line 341 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 232 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 288 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

◆ AllowISMCreation

bool AInstancedRendererManager::AllowISMCreation = false

private

Definition at line 101 of file InstancedRendererManager.h.

Referenced by AddActorToInstancedRendering(), and BeginPlay().

◆ Instance

AInstancedRendererManager * AInstancedRendererManager::Instance = nullptr

staticprivate

Definition at line 99 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 Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AInstancedRendererManager()

Member Function Documentation

◆ AddActorToInstancedRendering()

◆ AppendISM()

◆ AppendOrCreateISM()

◆ BeginPlay()

◆ DestroyOverlappingInstancesBox()

◆ EndPlay()

◆ ExportTreesAsCSV()

◆ GetAllInstancedActorRendererActors()

◆ GetTotalInstanceCount()

◆ SetInstancedRendering()

◆ SpawnAllInstancesBackToActors()

◆ SpawnInstanceBackToActor()

Member Data Documentation

◆ AllowISMCreation

◆ Instance

◆ InstancedRenderers

◆ TotalInstanceCount