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 "Agrarsense/Settings/AgrarsenseSettings.h"
#include "Agrarsense/Game/AgrarsenseStatics.h"
#include "Agrarsense/Weather/Weather.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())
    {
        ProxyMesh = 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);
#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 == nullptr)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: Actor is null!"));
#endif
        return false;
    }
 
    UStaticMeshComponent* StaticMeshComponent = InstancedActor->GetStaticMeshComponent();
    if (StaticMeshComponent == nullptr)
    {
#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 == nullptr)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: AInstancedActor %s UStaticMeshComponent mesh is null!"), *InstancedActor->GetName());
#endif
        return false;
    }
 
    // Find or create InstancedStaticMeshComponents array index for this instance
    int32 ComponentIndex = FindOrAddUniqueMesh(StaticMeshComponent, InstancedActor);
 
    // Check index validity
    if (!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;
}
 
int32 AInstancedRenderer::FindOrAddUniqueMesh(UStaticMeshComponent* StaticMeshComponent, AInstancedActor* InstancedActor)
{
    if (InstancedActor == nullptr || StaticMeshComponent == nullptr)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("StaticInstancedRenderer.cpp: StaticMeshComponent or InstancedActor is null!"));
#endif
        // return absurd number which should fail adding this instance to this renderer in above function.
        return 99999999;
    }
 
    UStaticMesh* Mesh = StaticMeshComponent->GetStaticMesh();
 
    if (!InstancedActor->HasAlternativeMaterial())
    {
        const int num = InstanceEntries.Num();
        for (int32 Index = 0; Index < num; ++Index)
        {
            if (InstanceEntries[Index].Mesh == Mesh)
            {
                return Index;
            }
        }
    }
 
    const int count = StaticMeshComponent->GetNumMaterials();
 
    TArray<UMaterialInterface*> MeshMaterials;
    MeshMaterials.Reserve(count);
 
    for (int32 i = 0; i < count; 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)
            {
                return Index;
            }
        }
    }
 
    // 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);
 
    // 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 = InstancedActor->GetClass();
    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);
 
    return InstanceEntries.Num() - 1;
}
 
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)
    {
        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)
{
    // When weather changes, we check current wind intensity to 
    // enable or disable certain instances world position offset evaluation.
    // Disabling WPO completely when wind is 0.0 saves a lot of performance with foliage.
    if (CurrentWeatherParameters.WindIntensity != WeatherParameters.WindIntensity)
    {
        CurrentWeatherParameters = WeatherParameters;
        bool ShouldRenderWPO = CurrentWeatherParameters.WindIntensity > 0.05f;
        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(ProxyMesh.Get());
                Entry.UsingProxy = true;
            }
            else 
            {
                ISMComponent->SetStaticMesh(Entry.Mesh.Get());
                Entry.UsingProxy = false;
            }
        }
    }
#endif
}
 
void AInstancedRenderer::SpawnAllInstancesBackActors()
{
#if WITH_EDITOR
    UWorld* World = GetWorld();
 
    if (InstanceEntries.IsEmpty()) 
    {
        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();
#endif
}
 
bool AInstancedRenderer::SpawnInstanceBackToActor(UInstancedStaticMeshComponent* ISM, int32 Index)
{
    if (!ISM || Index < 0 || Index >= ISM->GetInstanceCount())
    {
        return false;
    }
 
    UWorld* World = GetWorld();
    if (!World)
    {
        return false;
    }
 
    // 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)
    {
        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;
}