InstancedRenderer.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 "InstancedRenderer.h"
#include "InstancedActor.h"
 
#include "Agrarsense/Settings/AgrarsenseSettings.h"
#include "Agrarsense/Game/AgrarsenseStatics.h"
#include "Agrarsense/Weather/Weather.h"
 
#include "Components/StaticMeshComponent.h"
#include "UObject/ConstructorHelpers.h"
#include "Kismet/GameplayStatics.h"
#include "Materials/Material.h"
#include "TimerManager.h"
#include "Engine/World.h"
 
AInstancedRenderer* AInstancedRenderer::Instance = nullptr;
 
AInstancedRenderer::AInstancedRenderer(const FObjectInitializer& ObjectInitializer)
    : Super(ObjectInitializer)
{
    RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("SceneRoot"));
    RootComponent->SetMobility(EComponentMobility::Static);
    PrimaryActorTick.bCanEverTick = false;
 
    // Load a default cube mesh asset
    static ConstructorHelpers::FObjectFinder<UStaticMesh> DefaultMesh(TEXT("/Engine/BasicShapes/Cube.Cube"));
    if (DefaultMesh.Succeeded())
    {
        CubeMesh = DefaultMesh.Object;
    }
}
 
void AInstancedRenderer::BeginPlay()
{
    Super::BeginPlay();
 
    // SetActorEnableCollision(false);
 
    if (Instance == nullptr)
    {
        Instance = this;
    }
    else
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: Instance already exists. Destroying this actor.."));
#endif
        Destroy();
    }
 
    UWorld* World = GetWorld();
 
    UAgrarsenseSettings* Settings = UAgrarsenseStatics::GetAgrarsenseSettings();
    if (Settings)
    {
        WorldPositionOffsetDistance = Settings->GetWorldPositionOffsetRenderDistance();
        Settings->OnGraphicsSettingsChanged.AddUniqueDynamic(this, &AInstancedRenderer::OnGraphicsSettingsChanged);
    }
 
    AWeather* Weather = UAgrarsenseStatics::GetWeatherActor(World);
    if (Weather)
    {
        CurrentWeatherParameters = Weather->GetCurrentWeather();
        Weather->OnWeatherChanged.AddUniqueDynamic(this, &AInstancedRenderer::OnWeatherParametersChanged);
    }
 
#if WITH_EDITOR
    FTimerHandle Handle;
    World->GetTimerManager().SetTimer(Handle, FTimerDelegate::CreateLambda([this] {
        LogInfo();
    }),
        1.0f, false);
 
    if (!InstanceEntries.IsEmpty() && InstanceEntries[0].UsingProxy)
    {
        ToggleProxyMesh();
    }
#endif
}
 
void AInstancedRenderer::LogInfo() const
{
#if WITH_EDITOR
    UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: Unique mesh entries: %d | Total Instance Count: %d"), InstanceEntries.Num(), TotalInstanceCount);
#endif
}
 
void AInstancedRenderer::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
 
    if (Instance == this)
    {
        Instance = nullptr;
    }
    else
    {
        return;
    }
 
    UWorld* World = GetWorld();
 
    UAgrarsenseSettings* Settings = UAgrarsenseStatics::GetAgrarsenseSettings();
    if (Settings)
    {
        Settings->OnGraphicsSettingsChanged.RemoveDynamic(this, &AInstancedRenderer::OnGraphicsSettingsChanged);
    }
 
    AWeather* Weather = UAgrarsenseStatics::GetWeatherActor(World);
    if (Weather)
    {
        Weather->OnWeatherChanged.RemoveDynamic(this, &AInstancedRenderer::OnWeatherParametersChanged);
    }
 
    // Destroy all Instanced entries
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        if (Entry.InstancedStaticMeshComponent)
        {
            Entry.InstancedStaticMeshComponent->ClearInstances();
            Entry.InstancedStaticMeshComponent->UnregisterComponent();
            Entry.InstancedStaticMeshComponent->DetachFromComponent(FDetachmentTransformRules::KeepRelativeTransform);
            Entry.InstancedStaticMeshComponent->DestroyComponent();
            Entry.InstancedStaticMeshComponent = nullptr;
        }
 
        Entry.Materials.Empty();
        Entry.Mesh.Reset();
    }
 
    InstanceEntries.Empty();
}
 
bool AInstancedRenderer::AddActorToInstancedRendering(AInstancedActor* InstancedActor)
{
    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;
    }
 
    int32 ComponentIndex = 9999;
 
    // Find or create InstancedStaticMeshComponents array index for this instance
    bool Found = FindOrAddUniqueMesh(StaticMeshComponent, InstancedActor, ComponentIndex);
 
    if (!Found || !InstanceEntries.IsValidIndex(ComponentIndex))
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: ComponentIndex is not valid!"));
#endif
        return false;
    }
 
    UInstancedStaticMeshComponent* InstancedStaticMeshComponent = InstanceEntries[ComponentIndex].InstancedStaticMeshComponent;
    if (!InstancedStaticMeshComponent)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: UInstancedStaticMeshComponent is nullptr!"));
#endif
        return false;
    }
 
    // Get the StaticMeshComponent transform and add instance
    FTransform ActorTransform = StaticMeshComponent->GetComponentTransform();
    InstancedStaticMeshComponent->AddInstance(ActorTransform);
 
    int32 InstanceIndex = InstancedStaticMeshComponent->GetNumRenderInstances() - 1;
 
    // Notify the actor that instance has been added successfully.
    InstancedActor->InstanceAdded(ComponentIndex, InstanceIndex);
    // InstancedActor->Destroy();
 
    ++TotalInstanceCount;
 
    return true;
}
 
bool AInstancedRenderer::FindOrAddUniqueMesh(UStaticMeshComponent* StaticMeshComponent, AInstancedActor* InstancedActor, int32& InstanceNum)
{
    if (InstancedActor == nullptr || StaticMeshComponent == nullptr)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("StaticInstancedRenderer.cpp: StaticMeshComponent or InstancedActor is null!"));
#endif
        return false;
    }
 
    UStaticMesh* Mesh = StaticMeshComponent->GetStaticMesh();
 
    if (!InstancedActor->HasAlternativeMaterial())
    {
        const int32 Num = InstanceEntries.Num();
        for (int32 Index = 0; Index < Num; ++Index)
        {
            if (InstanceEntries[Index].Mesh == Mesh)
            {
                InstanceNum = Index;
                return true;
            }
        }
    }
 
    const int32 NumberOfMaterials = StaticMeshComponent->GetNumMaterials();
 
    TArray<UMaterialInterface*> MeshMaterials;
    MeshMaterials.Reserve(NumberOfMaterials);
 
    for (int32 i = 0; i < NumberOfMaterials; i++)
    {
        MeshMaterials.Add(StaticMeshComponent->GetMaterial(i));
    }
 
    const int Size = InstanceEntries.Num();
    for (int32 Index = 0; Index < Size; ++Index)
    {
        if (InstanceEntries[Index].Mesh == Mesh)
        {
            bool bMaterialsMatch = true;
 
            for (int32 MaterialIndex = 0; MaterialIndex < InstanceEntries[Index].Materials.Num(); ++MaterialIndex)
            {
                UMaterialInterface* UniqueMeshMaterial = InstanceEntries[Index].Materials[MaterialIndex];
                UMaterialInterface* MeshMaterial = MeshMaterials[MaterialIndex];
                if (UniqueMeshMaterial != MeshMaterial)
                {
                    bMaterialsMatch = false;
                }
            }
 
            if (bMaterialsMatch)
            {
                InstanceNum = Index;
                return true;
            }
        }
    }
 
    // Else this is completely new mesh and/or mesh with alternative material,
    // we need to create new FInstanceEntry and UInstancedStaticMeshComponent for it
 
    // Create and setup new UInstancedStaticMeshComponent
    UInstancedStaticMeshComponent* InstancedStaticMeshComponent = NewObject<UInstancedStaticMeshComponent>(this);
 
    UClass* ClassPtr = InstancedActor->GetClass();
 
    FString Name = IInteractable::Execute_GetInteractableName(InstancedActor).ToString();
 
    if (Name.IsEmpty())
    {
        Name = ClassPtr->GetAuthoredName();
        if (Name.EndsWith(TEXT("_C")))
        {
            Name = Name.LeftChop(2);
        }
        if (Name.StartsWith(TEXT("BP_")))
        {
            Name = Name.RightChop(3);
        }
        Name.ReplaceInline(TEXT("_"), TEXT(" "));
        Name.ReplaceInline(TEXT("Instanced"), TEXT(" "));
    }
 
    // Generate a 4-character GUID
    FString Guid = FGuid::NewGuid().ToString().Left(4);
 
    Name = FString::Printf(TEXT("%s(_%s_)"), *Name, *Guid);
 
    InstancedStaticMeshComponent->Rename(*Name);
 
    // Add Actor component list
    InstancedStaticMeshComponent->AttachToComponent(GetRootComponent(), FAttachmentTransformRules::KeepRelativeTransform);
    AddInstanceComponent(InstancedStaticMeshComponent);
 
    InstancedStaticMeshComponent->bEditableWhenInherited = false;
    InstancedStaticMeshComponent->RegisterComponent();
    InstancedStaticMeshComponent->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
    InstancedStaticMeshComponent->CreatePhysicsState(false);
    InstancedStaticMeshComponent->SetSimulatePhysics(false);
    InstancedStaticMeshComponent->SetStaticMesh(Mesh);
    InstancedStaticMeshComponent->SetMobility(EComponentMobility::Static);
    InstancedStaticMeshComponent->SetHiddenInGame(false);
    InstancedStaticMeshComponent->SetVisibility(true);
    InstancedStaticMeshComponent->AttachToComponent(RootComponent, FAttachmentTransformRules::KeepWorldTransform);
    InstancedStaticMeshComponent->InstanceStartCullDistance = InstancedActor->GetInstanceStartCullDistance();
    InstancedStaticMeshComponent->InstanceEndCullDistance = InstancedActor->GetInstanceEndCullDistance();
 
    // Set WPO distance and evaluation
    InstancedStaticMeshComponent->SetWorldPositionOffsetDisableDistance(WorldPositionOffsetDistance);
    /*InstancedStaticMeshComponent->SetEvaluateWorldPositionOffset(true);
    InstancedStaticMeshComponent->SetEvaluateWorldPositionOffsetInRayTracing(true);*/
 
    bool AllowWorldPositionOffsetDisable = InstancedActor->GetAllowWorldPositionOffsetDisable();
 
    // For whatever reason this only works when done a bit later..
    FTimerHandle Handle;
    GetWorld()->GetTimerManager().SetTimer(Handle, FTimerDelegate::CreateLambda([this, InstancedStaticMeshComponent, AllowWorldPositionOffsetDisable] {
        if (InstancedStaticMeshComponent && AllowWorldPositionOffsetDisable && CurrentWeatherParameters.WindIntensity < 0.05f)
        {
            InstancedStaticMeshComponent->SetEvaluateWorldPositionOffset(false);
            InstancedStaticMeshComponent->SetEvaluateWorldPositionOffsetInRayTracing(false);
        }
    }),
        0.350f, false);
 
    // Thermal and Semantic camera use custom depth.
    // RenderCustomDepth is set to false, if no Thermal or Semantic camera exists in the level,
    // and is automatically set to true/false for all instances when they are spawned/destroyed.
    // Doing this saves a lot rendering performance.
    InstancedStaticMeshComponent->SetRenderCustomDepth(true);
    InstancedStaticMeshComponent->SetCustomDepthStencilValue(StaticMeshComponent->CustomDepthStencilValue);
 
    // Huge performance implication, recommend is Rigid (especially for Foliage with WPO).
    // https://docs.unrealengine.com/5.3/en-US/PythonAPI/class/ShadowCacheInvalidationBehavior.html
    InstancedStaticMeshComponent->ShadowCacheInvalidationBehavior = EShadowCacheInvalidationBehavior::Rigid;
 
    // Create new FInstanceEntry
    FInstanceEntry InstanceEntry;
    InstanceEntry.InstancedStaticMeshComponent = InstancedStaticMeshComponent;
    InstanceEntry.ActorClass = ClassPtr;
    InstanceEntry.Mesh = Mesh;
    InstanceEntry.Materials = MeshMaterials;
    InstanceEntry.InstanceEntryIndex = InstanceEntries.Num();
    InstanceEntry.CustomDepthStencilValue = StaticMeshComponent->CustomDepthStencilValue;
    InstanceEntry.AllowWorldPositionOffsetDisable = AllowWorldPositionOffsetDisable;
    InstanceEntry.IsTree = InstancedActor->IsTreeActor();
 
    // Set materials to newly created UInstancedStaticMeshComponent
    const int32 MaterialCount = MeshMaterials.Num();
    for (int32 MaterialIndex = 0; MaterialIndex < MaterialCount; ++MaterialIndex)
    {
        UMaterialInterface* MaterialInterface = InstanceEntry.Materials[MaterialIndex];
 
        if (MaterialInterface)
        {
            InstancedStaticMeshComponent->SetMaterial(MaterialIndex, MaterialInterface);
 
#if WITH_EDITOR
            // Validate in Editor that material has bUsedWithInstancedStaticMeshes on
            UMaterial* Material = Cast<UMaterial>(MaterialInterface);
            if (Material)
            {
                if (!Material->bUsedWithInstancedStaticMeshes)
                {
                    UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: Material '%s' bUsedWithInstancedStaticMeshes is not set to true!"), *Material->GetName());
                }
            }
#endif
        }
    }
 
    InstanceEntries.Add(InstanceEntry);
 
    InstanceNum = InstanceEntries.Num() - 1;
 
    return true;
}
 
void AInstancedRenderer::UpdateInstanceTransform(int32 ComponentIndex, int32 InstanceNumber, const FTransform& NewTransform)
{
    if (!InstanceEntries.IsValidIndex(ComponentIndex))
    {
        return;
    }
 
    FInstanceEntry& Entry = InstanceEntries[ComponentIndex];
 
    if (Entry.InstancedStaticMeshComponent)
    {
        Entry.InstancedStaticMeshComponent->UpdateInstanceTransform(InstanceNumber, NewTransform, true, true);
    }
}
 
void AInstancedRenderer::RemoveInstance(int32 ComponentIndex, int32 InstanceNumber)
{
    if (!InstanceEntries.IsValidIndex(ComponentIndex))
    {
        return;
    }
 
    FInstanceEntry& Entry = InstanceEntries[ComponentIndex];
 
    if (Entry.InstancedStaticMeshComponent)
    {
        // Ensure InstanceNumber is valid before attempting to remove
        if (InstanceNumber >= 0 && InstanceNumber < Entry.InstancedStaticMeshComponent->GetInstanceCount())
        {
            Entry.InstancedStaticMeshComponent->RemoveInstance(InstanceNumber);
            --TotalInstanceCount;
        }
    }
}
 
void AInstancedRenderer::SetInstancedRendering(bool ShouldRender)
{
    Rendering = ShouldRender;
    for (const FInstanceEntry& Entry : InstanceEntries)
    {
        if (Entry.InstancedStaticMeshComponent)
        {
            Entry.InstancedStaticMeshComponent->SetVisibility(Rendering);
        }
    }
 
#if WITH_EDITOR
    UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: Rendering: %s"), (Rendering ? TEXT("true") : TEXT("false")));
#endif
}
 
void AInstancedRenderer::SetComponentIndexVisibility(int32 Index, bool Visible)
{
    if (!InstanceEntries.IsValidIndex(Index))
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: Index %d is not valid!"), Index);
#endif
        return;
    }
 
    FInstanceEntry& Entry = InstanceEntries[Index];
 
    if (Entry.InstancedStaticMeshComponent)
    {
        Entry.InstancedStaticMeshComponent->SetVisibility(Visible);
    }
}
 
void AInstancedRenderer::OnGraphicsSettingsChanged(FGlobalGraphicsSettings GraphicsSettings)
{
    SetWorldPositionOffsetDistance(GraphicsSettings.WorldPositionOffsetDistance);
    SetShadowCacheBehaviour(GraphicsSettings.FoliageShadowCacheInvalidationBehaviour);
}
 
void AInstancedRenderer::OnWeatherParametersChanged(FWeatherParameters WeatherParameters)
{
    CurrentWeatherParameters = WeatherParameters;
 
    bool IsWinter = WeatherParameters.IsWinterSeason();
    bool IsWindy = WeatherParameters.WindIntensity > 0.05f;
    bool ShouldRenderWPO = IsWinter || IsWindy;
 
    // Only update if the rendering state has changed
    if (RenderingWPO != ShouldRenderWPO)
    {
        RenderingWPO = ShouldRenderWPO;
        SetRenderWorldPositionOffet(ShouldRenderWPO);
    }
}
 
void AInstancedRenderer::SetRenderCustomDepth(bool Enabled)
{
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        if (Entry.InstancedStaticMeshComponent)
        {
            Entry.InstancedStaticMeshComponent->SetRenderCustomDepth(Enabled);
        }
    }
}
 
void AInstancedRenderer::SetWorldPositionOffsetDistance(int32 NewWPODistance)
{
    if (WorldPositionOffsetDistance == NewWPODistance)
    {
        return;
    }
 
    WorldPositionOffsetDistance = NewWPODistance;
 
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        if (Entry.InstancedStaticMeshComponent)
        {
            Entry.InstancedStaticMeshComponent->SetWorldPositionOffsetDisableDistance(WorldPositionOffsetDistance);
        }
    }
}
 
void AInstancedRenderer::SetShadowCacheBehaviour(EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehaviour)
{
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        if (Entry.InstancedStaticMeshComponent)
        {
            Entry.InstancedStaticMeshComponent->ShadowCacheInvalidationBehavior = ShadowCacheInvalidationBehaviour;
        }
    }
}
 
void AInstancedRenderer::SetRenderWorldPositionOffet(bool RenderWPO)
{
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        if (Entry.AllowWorldPositionOffsetDisable && Entry.InstancedStaticMeshComponent)
        {
            Entry.InstancedStaticMeshComponent->SetEvaluateWorldPositionOffset(RenderWPO);
            Entry.InstancedStaticMeshComponent->SetEvaluateWorldPositionOffsetInRayTracing(RenderWPO);
        }
    }
}
 
void AInstancedRenderer::DebugMaterialImpact(bool SetUnrealDefaultMaterial)
{
    UMaterialInterface* DefaultMaterial = nullptr;
    if (SetUnrealDefaultMaterial)
    {
        DefaultMaterial = UMaterial::GetDefaultMaterial(EMaterialDomain(0));
    }
 
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        if (Entry.AllowWorldPositionOffsetDisable && Entry.InstancedStaticMeshComponent)
        {
            if (SetUnrealDefaultMaterial)
            {
                for (int32 i = 0; i < Entry.InstancedStaticMeshComponent->GetNumMaterials(); ++i)
                {
                    UMaterialInterface* CurrentMaterial = Entry.InstancedStaticMeshComponent->GetMaterial(i);
                    Entry.Materials.Add(CurrentMaterial);
                }
                for (int32 i = 0; i < Entry.InstancedStaticMeshComponent->GetNumMaterials(); ++i)
                {
                    Entry.InstancedStaticMeshComponent->SetMaterial(i, DefaultMaterial);
                }
            }
            else
            {
                if (Entry.Materials.Num() > 0)
                {
                    for (int32 i = 0; i < Entry.Materials.Num(); ++i)
                    {
                        UMaterialInterface* OriginalMaterial = Entry.Materials[i];
                        Entry.InstancedStaticMeshComponent->SetMaterial(i, OriginalMaterial);
                    }
                }
            }
        }
    }
}
 
void AInstancedRenderer::ToggleProxyMesh()
{
#if WITH_EDITOR
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        auto& ISMComponent = Entry.InstancedStaticMeshComponent;
 
        if (ISMComponent)
        {
            if (!Entry.UsingProxy)
            {
                ISMComponent->SetStaticMesh(CubeMesh.Get());
                Entry.UsingProxy = true;
            }
            else
            {
                ISMComponent->SetStaticMesh(Entry.Mesh.Get());
                Entry.UsingProxy = false;
            }
        }
    }
#endif
}
 
void AInstancedRenderer::SpawnAllInstancesBackActors()
{
    UWorld* World = GetWorld();
 
    if (InstanceEntries.IsEmpty() || !World)
    {
        return;
    }
 
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        UInstancedStaticMeshComponent* ISMComponent = Entry.InstancedStaticMeshComponent;
        if (!ISMComponent)
        {
            continue;
        }
 
        ISMComponent->SetVisibility(false);
 
        // Extract transforms from ISM component into TArray
        TArray<FTransform> Transforms;
 
        const int32 InstanceCount = ISMComponent->GetInstanceCount();
 
        for (int32 i = 0; i < InstanceCount; i++)
        {
            FTransform Transform;
            ISMComponent->GetInstanceTransform(i, Transform);
            Transforms.Add(Transform);
        }
 
        // Spawn actors to level
        UClass* Class = Entry.ActorClass;
        for (const FTransform& Transform : Transforms)
        {
            AActor* SpawnedActor = World->SpawnActorDeferred<AActor>(Class, Transform);
            if (SpawnedActor)
            {
                SpawnedActor->FinishSpawning(Transform);
            }
        }
 
        ISMComponent->DestroyComponent();
    }
 
    InstanceEntries.Empty();
}
 
void AInstancedRenderer::UpdateRenderDistances()
{
#if WITH_EDITOR
    UWorld* World = GetWorld();
 
    if (InstanceEntries.IsEmpty() || !World)
    {
        return;
    }
 
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        UInstancedStaticMeshComponent* ISMComponent = Entry.InstancedStaticMeshComponent;
        if (!ISMComponent)
        {
            continue;
        }
 
        UClass* Class = Entry.ActorClass;
        FTransform Transform;
        AActor* SpawnedActor = World->SpawnActorDeferred<AActor>(Class, Transform);
        if (SpawnedActor)
        {
            SpawnedActor->FinishSpawning(Transform);
        }
 
        AInstancedActor* Actor = Cast<AInstancedActor>(SpawnedActor);
        if (Actor)
        {
 
            int32 Min = Actor->GetInstanceStartCullDistance();
            int32 Max = Actor->GetInstanceEndCullDistance();
            ISMComponent->SetCullDistances(Min, Max);
 
            Actor->Destroy();
        }
    }
#endif
}
 
bool AInstancedRenderer::SpawnInstanceBackToActor(UInstancedStaticMeshComponent* ISM, int32 Index, bool OnlyTree)
{
    if (!ISM || Index < 0 || Index >= ISM->GetInstanceCount())
    {
        return false;
    }
 
    UWorld* World = GetWorld();
 
    // Get the transform for the specified instance
    FTransform InstanceTransform;
    ISM->GetInstanceTransform(Index, InstanceTransform);
 
    // Get the actor class from the associated entry
    FInstanceEntry* Entry = InstanceEntries.FindByPredicate([ISM](const FInstanceEntry& InEntry) {
        return InEntry.InstancedStaticMeshComponent == ISM;
    });
 
    if (!Entry || !World)
    {
        return false;
    }
 
    if (OnlyTree && !Entry->IsTree)
    {
        return false;
    }
 
    UClass* ActorClass = Entry->ActorClass;
    if (!ActorClass)
    {
        return false;
    }
 
    // Spawn the actor
    AActor* SpawnedActor = World->SpawnActorDeferred<AActor>(ActorClass, InstanceTransform);
    if (SpawnedActor)
    {
        AInstancedActor* InstancedActor = Cast<AInstancedActor>(SpawnedActor);
        if (InstancedActor)
        {
            InstancedActor->AddToInstancedRenderer = false;
        }
 
        SpawnedActor->FinishSpawning(InstanceTransform);
 
        // Remove this ISM instance.
        return ISM->RemoveInstance(Index);
    }
 
    return false;
}
 
void AInstancedRenderer::DestroyOverlappingInstancesBox(UInstancedStaticMeshComponent* ISM, FBox AreaBox, bool OnlyTrees)
{
    // Check incoming ISM exists in InstanceEntries
    FInstanceEntry* Entry = InstanceEntries.FindByPredicate([ISM](const FInstanceEntry& InEntry) {
        return InEntry.InstancedStaticMeshComponent == ISM;
    });
 
    if (!Entry || (!Entry->IsTree && OnlyTrees))
    {
        return;
    }
 
    // Remove all instances that overlap incoming AreaBox bounds
    if (UInstancedStaticMeshComponent* Comp = Entry->InstancedStaticMeshComponent)
    {
        TArray<int32> OverlappingInstances = Comp->GetInstancesOverlappingBox(AreaBox);
        for (int32 InstanceIndex : OverlappingInstances)
        {
            Comp->RemoveInstance(InstanceIndex);
        }
    }
}