InstancedActorRenderer.cpp

Go to the documentation of this file.

// Copyright (c) 2025 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 "InstancedActorRenderer.h"
 
#include "Agrarsense/Game/AgrarsenseStatics.h"
#include "Agrarsense/Settings/AgrarsenseSettings.h"
#include "Agrarsense/Weather/Weather.h"
 
AInstancedActorRenderer::AInstancedActorRenderer(const FObjectInitializer& ObjectInitializer) : Super(ObjectInitializer)
{
    PrimaryActorTick.bCanEverTick = false;
}
 
void AInstancedActorRenderer::BeginPlay()
{
    Super::BeginPlay();
 
    UWorld* World = GetWorld();
 
    UAgrarsenseSettings* Settings = UAgrarsenseStatics::GetAgrarsenseSettings();
    if (Settings)
    {
        WorldPositionOffsetDistance = Settings->GetWorldPositionOffsetRenderDistance();
        Settings->OnGraphicsSettingsChanged.AddUniqueDynamic(this, &AInstancedActorRenderer::OnGraphicsSettingsChanged);
    }
 
    AWeather* Weather = UAgrarsenseStatics::GetWeatherActor(World);
    if (Weather)
    {
        CurrentWeatherParameters = Weather->GetCurrentWeather();
        Weather->OnWeatherChanged.AddUniqueDynamic(this, &AInstancedActorRenderer::OnWeatherParametersChanged);
    }
}
 
void AInstancedActorRenderer::EndPlay(const EEndPlayReason::Type EndPlayReason)
{
    Super::EndPlay(EndPlayReason);
 
    UWorld* World = GetWorld();
 
    UAgrarsenseSettings* Settings = UAgrarsenseStatics::GetAgrarsenseSettings();
    if (Settings)
    {
        Settings->OnGraphicsSettingsChanged.RemoveDynamic(this, &AInstancedActorRenderer::OnGraphicsSettingsChanged);
    }
 
    AWeather* Weather = UAgrarsenseStatics::GetWeatherActor(World);
    if (Weather)
    {
        Weather->OnWeatherChanged.RemoveDynamic(this, &AInstancedActorRenderer::OnWeatherParametersChanged);
    }
}
 
void AInstancedActorRenderer::SetupFromInstancedActor(AInstancedActor* InstancedActor)
{
    if (!InstancedActor)
    {
        return;
    }
 
    UStaticMeshComponent* StaticMeshComponent = InstancedActor->GetStaticMeshComponent();
    UStaticMesh* Mesh = StaticMeshComponent->GetStaticMesh();
    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(" "));
    }
 
#if WITH_EDITOR
    FString ActorName = Name;
    ActorName.ReplaceInline(TEXT(","), TEXT(""));
    ActorName.ReplaceInline(TEXT(" "), TEXT("_"));
    ActorName += "_Instanced";
    SetActorLabel(ActorName);
#endif
 
    // Generate a 4-character GUID
    FString Guid = FGuid::NewGuid().ToString().Left(4);
    Name = FString::Printf(TEXT("%s(_%s_)"), *Name, *Guid);
 
    InstancedStaticMeshComponent = NewObject<UInstancedStaticMeshComponent>(this);
    InstancedStaticMeshComponent->AttachToComponent(GetRootComponent(), FAttachmentTransformRules::KeepRelativeTransform);
    AddInstanceComponent(InstancedStaticMeshComponent);
 
    // Add new instance.
    const FTransform& Transform = InstancedActor->GetActorTransform();
    InstancedStaticMeshComponent->AddInstance(Transform);
 
    InstancedStaticMeshComponent->Rename(*Name);
    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();
 
    bool AllowWorldPositionOffsetDisable = InstancedActor->GetAllowWorldPositionOffsetDisable();
 
    // For whatever reason this only works when done a bit later..
    FTimerHandle Handle;
    GetWorld()->GetTimerManager().SetTimer(Handle, FTimerDelegate::CreateLambda([this, 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;
 
    const int32 NumberOfMaterials = StaticMeshComponent->GetNumMaterials();
    TArray<UMaterialInterface*> MeshMaterials;
    MeshMaterials.Reserve(NumberOfMaterials);
    for (int32 i = 0; i < NumberOfMaterials; i++)
    {
        MeshMaterials.Add(StaticMeshComponent->GetMaterial(i));
    }
 
    InstancedActorParameters.ActorClass = ClassPtr;
    InstancedActorParameters.Mesh = Mesh;
    InstancedActorParameters.Materials = MeshMaterials;
    InstancedActorParameters.CustomDepthStencilValue = StaticMeshComponent->CustomDepthStencilValue;
    InstancedActorParameters.AllowWorldPositionOffsetDisable = AllowWorldPositionOffsetDisable;
    InstancedActorParameters.IsTree = InstancedActor->IsTreeActor();
 
    // Set materials to newly created UInstancedStaticMeshComponent
    const int32 MaterialCount = MeshMaterials.Num();
    for (int32 MaterialIndex = 0; MaterialIndex < MaterialCount; ++MaterialIndex)
    {
        UMaterialInterface* MaterialInterface = InstancedActorParameters.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("AInstancedRendererManager: Material '%s' bUsedWithInstancedStaticMeshes is not set to true!"), *Material->GetName());
                }
            }
#endif
        }
    }
 
    InstancedActor->InstanceAdded();
    InstancedActor->Destroy();
}
 
bool AInstancedActorRenderer::SpawnInstanceBackToActor(UInstancedStaticMeshComponent* ISM, int32 Index, bool OnlyTree)
{
    if (!ISM || !InstancedStaticMeshComponent|| Index < 0 || Index >= ISM->GetInstanceCount())
    {
        return false;
    }
 
    if (ISM != InstancedStaticMeshComponent) 
    {
        return false;
    }
 
    UWorld* World = GetWorld();
    if (!World)
    {
        return false;
    }
 
    if (OnlyTree && !InstancedActorParameters.IsTree)
    {
        return false;
    }
 
    UClass* ActorClass = InstancedActorParameters.ActorClass;
    if (!ActorClass)
    {
        return false;
    }
 
    // Get the transform for the specified instance
    FTransform InstanceTransform;
    InstancedStaticMeshComponent->GetInstanceTransform(Index, InstanceTransform);
 
    // 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 InstancedStaticMeshComponent->RemoveInstance(Index);
    }
 
    return true;
}
 
UStaticMesh* AInstancedActorRenderer::GetStaticMesh() const
{
    if (InstancedStaticMeshComponent) 
    {
        return InstancedStaticMeshComponent->GetStaticMesh();
    }
 
    return nullptr;
}
 
bool AInstancedActorRenderer::SpawnInstancesBackActors()
{
    UWorld* World = GetWorld();
 
    if (!World)
    {
        return false;
    }
 
    if (!InstancedStaticMeshComponent)
    {
        return false;
    }
 
    UClass* Class = InstancedActorParameters.ActorClass;
    if (!Class)
    {
        UE_LOG(LogTemp, Warning, TEXT("AInstancedActorRenderer: No spawn class setup."));
        return false;
    }
 
    InstancedStaticMeshComponent->SetVisibility(false);
 
    // Extract transforms from ISM component into TArray
    TArray<FTransform> Transforms;
 
    const int32 InstanceCount = InstancedStaticMeshComponent->GetInstanceCount();
 
    for (int32 i = 0; i < InstanceCount; i++)
    {
        FTransform Transform;
        InstancedStaticMeshComponent->GetInstanceTransform(i, Transform);
        Transforms.Add(Transform);
    }
 
    // Spawn actors to level
    for (const FTransform& Transform : Transforms)
    {
        if (Class)
        {
            AActor* SpawnedActor = World->SpawnActorDeferred<AActor>(Class, Transform);
            if (SpawnedActor)
            {
                SpawnedActor->FinishSpawning(Transform);
            }
        }
    }
 
    InstancedStaticMeshComponent->DestroyComponent();
 
    return true;
}
 
bool AInstancedActorRenderer::Matches(UStaticMeshComponent* StaticMeshComponent, const bool CanHaveAlternativeMaterial) const
{
    if (!StaticMeshComponent)
    {
        return false;
    }
 
    UStaticMesh* StaticMesh = StaticMeshComponent->GetStaticMesh();
    if (!StaticMesh)
    {
        return false;
    }
 
    if (!CanHaveAlternativeMaterial)
    {
        if (InstancedActorParameters.Mesh == StaticMesh) 
        {
            return true;
        }
    }
    else 
    {
        const int32 NumberOfMaterials = StaticMeshComponent->GetNumMaterials();
        TArray<UMaterialInterface*> MeshMaterials;
        MeshMaterials.Reserve(NumberOfMaterials);
        for (int32 i = 0; i < NumberOfMaterials; i++)
        {
            MeshMaterials.Add(StaticMeshComponent->GetMaterial(i));
        }
 
        if (InstancedActorParameters.Mesh == StaticMesh)
        {
            bool bMaterialsMatch = true;
 
            for (int32 MaterialIndex = 0; MaterialIndex < InstancedActorParameters.Materials.Num(); ++MaterialIndex)
            {
                UMaterialInterface* UniqueMeshMaterial = InstancedActorParameters.Materials[MaterialIndex];
                UMaterialInterface* MeshMaterial = MeshMaterials[MaterialIndex];
                if (UniqueMeshMaterial != MeshMaterial)
                {
                    bMaterialsMatch = false;
                }
            }
            MeshMaterials.Empty();
 
            if (bMaterialsMatch)
            {
                return true;
            }
        }
    }
 
    return false;
}
 
bool AInstancedActorRenderer::Matches(UInstancedStaticMeshComponent* ISM) const
{
    if (!ISM || InstancedStaticMeshComponent)
    {
        return false;
    }
 
    if (ISM->GetStaticMesh() == InstancedActorParameters.Mesh)
    {
        const int32 NumberOfMaterials = ISM->GetNumMaterials();
        if (NumberOfMaterials != InstancedActorParameters.Materials.Num())
        {
            return false;
        }
 
        for (int32 i = 0; i < NumberOfMaterials; i++)
        {
            if (ISM->GetMaterial(i) != InstancedActorParameters.Materials[i])
            {
                return false;
            }
        }
 
        return true;
    }
 
    return false;
}
 
void AInstancedActorRenderer::SetWorldPositionOffsetDistance(int32 NewWPODistance)
{
    if (WorldPositionOffsetDistance == NewWPODistance)
    {
        return;
    }
 
    WorldPositionOffsetDistance = NewWPODistance;
 
    if (InstancedStaticMeshComponent)
    {
        InstancedStaticMeshComponent->SetWorldPositionOffsetDisableDistance(WorldPositionOffsetDistance);
    }
}
 
void AInstancedActorRenderer::SetShadowCacheBehaviour(EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehaviour)
{
    if (InstancedStaticMeshComponent)
    {
        InstancedStaticMeshComponent->ShadowCacheInvalidationBehavior = ShadowCacheInvalidationBehaviour;
    }
}
 
void AInstancedActorRenderer::SetRenderWorldPositionOffet(bool RenderWPO)
{
    if (InstancedStaticMeshComponent)
    {
        InstancedStaticMeshComponent->SetEvaluateWorldPositionOffset(RenderWPO);
        InstancedStaticMeshComponent->SetEvaluateWorldPositionOffsetInRayTracing(RenderWPO);
    }
}
 
void AInstancedActorRenderer::OnGraphicsSettingsChanged(FGlobalGraphicsSettings GraphicsSettings)
{
    SetWorldPositionOffsetDistance(GraphicsSettings.WorldPositionOffsetDistance);
    SetShadowCacheBehaviour(GraphicsSettings.FoliageShadowCacheInvalidationBehaviour);
}
 
void AInstancedActorRenderer::OnWeatherParametersChanged(FWeatherParameters WeatherParameters)
{
    CurrentWeatherParameters = WeatherParameters;
 
    bool IsWinter = WeatherParameters.IsWinterSeason();
    bool IsWindy = WeatherParameters.WindIntensity > 0.05f;
 
    // Should render tree wind (WPO)
    bool ShouldRenderTreeWPO = IsWinter || IsWindy;
 
    // Should render snow (WPO), like rocks etc.
    bool ShouldRenderSnowWPO = WeatherParameters.SnowAmount != 0.0f;
 
    bool ShouldRenderWPO = IsWinter || IsWindy;
 
    // Only update if the rendering state has changed
    if (RenderingWPO != ShouldRenderWPO)
    {
        RenderingWPO = ShouldRenderWPO;
        SetRenderWorldPositionOffet(ShouldRenderWPO);
    }
}