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/Game/AgrarsenseStatics.h"
#include "Agrarsense/Settings/AgrarsenseSettings.h"
#include "Agrarsense/Weather/Weather.h"
 
#include "TimerManager.h"
#include "Materials/Material.h"
#include "Kismet/GameplayStatics.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 = true;
}
 
void AInstancedRenderer::BeginPlay()
{
    Super::BeginPlay();
 
    // Disable collision for this actor. The instanced actor's themselves have their own collisions
    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);
    }
 
    InstancedActorsToUpdate.clear();
 
    // 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.ActorData.Empty();
        Entry.Mesh.Reset();
    }
 
    InstanceEntries.Empty();
}
 
void AInstancedRenderer::Tick(float DeltaTime)
{
    UpdateInstancedActors();
}
 
void AInstancedRenderer::UpdateInstancedActors()
{
    int NumberOfActorsToUpdate = InstancedActorsToUpdate.size();
    if (InstancedActorsToUpdate.size() == 0)
    {
        SetActorTickEnabled(false);
        return;
    }
 
    for (int32 i = 0; i < NumberOfActorsToUpdate; i++)
    {
        FInstancedActorData& InstancedData = InstancedActorsToUpdate[i];
        AInstancedActor* ActorPtr = InstancedData.Actor.Get();
        if (ActorPtr)
        {
            FTransform CurrentActorTransform = ActorPtr->GetActorTransform();
            if (!AreTransformsEqual(ActorPtr->GetPreviousTransform(), CurrentActorTransform))
            {
                UpdateInstanceTransform(ActorPtr->GetComponentIndex(), ActorPtr->GetInstanceIndex(), CurrentActorTransform);
                ActorPtr->UpdatePreviousTransform(CurrentActorTransform);
            }
        }
        else
        {
            // Remove InstancedData from std::vector InstancedActorsToUpdate
            InstancedActorsToUpdate.erase(InstancedActorsToUpdate.begin() + i);
            NumberOfActorsToUpdate--;
            i--;
        }
    }
}
 
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;
    }
 
    // Add InstancedActor to TArray
    FInstancedActorData InstancedData;
    InstancedData.Actor = InstancedActor;
    InstanceEntries[ComponentIndex].ActorData.Add(InstancedData);
 
    // Get the StaticMeshComponent transform and add instance
    FTransform ActorTransform = StaticMeshComponent->GetComponentTransform();
    InstancedStaticMeshComponent->AddInstance(ActorTransform);
 
    // If actor has bool UpdateTransformAutomatically true,
    // add actor and its data to InstancedActorsToUpdate array
    if (InstancedActor->UpdateTransformAutomatically())
    {
        InstancedStaticMeshComponent->SetMobility(EComponentMobility::Movable);
        AddOrRemoveActorFromAutomaticTransformUpdates(true, InstancedActor);
    }
 
    int32 InstanceIndex = InstancedStaticMeshComponent->GetNumRenderInstances() - 1;
 
    // Notify the actor that instance has been added successfully.
    InstancedActor->InstanceAdded(ComponentIndex, InstanceIndex);
 
    ++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);
    InstancedStaticMeshComponent->RegisterComponent();
    InstancedStaticMeshComponent->SetCollisionEnabled(ECollisionEnabled::NoCollision);
    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.Mesh = Mesh;
    InstanceEntry.Materials = MeshMaterials;
    InstanceEntry.InstanceEntryIndex = InstanceEntries.Num();
    InstanceEntry.MeshName = Mesh->GetName();
    InstanceEntry.InstancedStaticMeshComponent = InstancedStaticMeshComponent;
    InstanceEntry.AllowWorldPositionOffsetDisable = AllowWorldPositionOffsetDisable;
 
    // 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::AddOrRemoveActorFromAutomaticTransformUpdates(bool Add, AInstancedActor* InstancedActor)
{
    if (!InstancedActor)
    {
        return;
    }
 
    if (Add)
    {
        FInstancedActorData InstancedData;
        InstancedData.Actor = InstancedActor;
        InstancedActor->UpdatePreviousTransform(InstancedActor->GetActorTransform());
        InstancedActorsToUpdate.emplace_back(InstancedData);
 
        // Set this Actor's tick to true.
        SetActorTickEnabled(true);
    }
    else
    {
        auto it = std::remove_if(InstancedActorsToUpdate.begin(), InstancedActorsToUpdate.end(),
            [InstancedActor](const FInstancedActorData& Data)
            {
                return Data.Actor == InstancedActor;
            });
 
        if (it != InstancedActorsToUpdate.end())
        {
            InstancedActorsToUpdate.erase(it, InstancedActorsToUpdate.end());
        }
    }
}
 
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);
    }
 
    auto& InstancedActors = InstanceEntries[ComponentIndex].ActorData;
 
    // Remove instance if within range
    if (InstanceNumber >= 0 && InstanceNumber < InstancedActors.Num())
    {
        // Is it necessary here to check the Actor validity?
        AInstancedActor* InstanceToRemove = InstancedActors[InstanceNumber].Actor.Get();
        if (InstanceToRemove)
        {
            InstancedActors.RemoveAt(InstanceNumber);
        }
    }
 
    for (int32 i = 0; i < InstancedActors.Num(); i++)
    {
        AInstancedActor* InstanceActor = InstancedActors[i].Actor.Get();
        if (InstanceActor)
        {
            // Notify all AInstancedActor that are part of this InstanceEntry
            // that one of the InstancedActors has been removed,
            // this is because we need to adjust each AInstancedActor* InstanceNumber,
            // unless the removed instance number is smaller 
            // than AInstancedActor* InstanceNumber (handled in the UpdateIndex() function).
            InstanceActor->UpdateIndex(InstanceNumber);
        }
    }
 
    --TotalInstanceCount;
}
 
bool AInstancedRenderer::AreTransformsEqual(const FTransform& TransformA, const FTransform& TransformB) const
{
    if (TransformA.GetTranslation() != TransformB.GetTranslation())
    {
        return false;
    }
 
    if (TransformA.GetRotation() != TransformB.GetRotation())
    {
        return false;
    }
 
    if (TransformA.GetScale3D() != TransformB.GetScale3D())
    {
        return false;
    }
 
    // else Transforms are equal
    return true;
}
 
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);
                    }
                }
            }
        }
    }
}