#include <InstancedRenderer.h>

Inheritance diagram for AInstancedRenderer:

Collaboration diagram for AInstancedRenderer:

Public Member Functions
	AInstancedRenderer (const FObjectInitializer &ObjectInitializer)

bool	AddActorToInstancedRendering (AInstancedActor *InstancedActor)

void	RemoveInstance (int32 ComponentIndex, int32 InstanceNumber)

void	AddOrRemoveActorFromAutomaticTransformUpdates (bool Add, AInstancedActor *InstancedActor)

void	UpdateInstanceTransform (int32 ComponentIndex, int32 InstanceNumber, const FTransform &NewTransform)

bool	IsRendering () const

int32	GetTotalInstanceCount () const

int32	GetUniqueInstancesCount () const

TArray< FInstanceEntry >	GetInstanceEntries () const

void	SetInstancedRendering (bool ShouldRender)

void	SetComponentIndexVisibility (int32 Index, bool Visible)

void	SetRenderCustomDepth (bool Enabled)

void	SetWorldPositionOffsetDistance (int32 NewWPODistance)

void	SetShadowCacheBehaviour (EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehaviour)

void	SetRenderWorldPositionOffet (bool RenderWPO)

void	LogInfo () const

void	DebugMaterialImpact (bool SetUnrealDefaultMaterial)

Private Member Functions
void	BeginPlay () override

void	Tick (float DeltaTime) override

void	EndPlay (const EEndPlayReason::Type EndPlayReason) override

void	OnGraphicsSettingsChanged (FGlobalGraphicsSettings GraphicsSettings)

void	OnWeatherParametersChanged (FWeatherParameters WeatherParameters)

bool	AreTransformsEqual (const FTransform &TransformA, const FTransform &TransformB) const

void	UpdateInstancedActors ()

int32	FindOrAddUniqueMesh (UStaticMeshComponent StaticMeshComponent, AInstancedActor InstancedActor)

Private Attributes
TArray< FInstanceEntry >	InstanceEntries

int32	WorldPositionOffsetDistance = 30000

std::vector< FInstancedActorData >	InstancedActorsToUpdate

FWeatherParameters	CurrentWeatherParameters

int32	TotalInstanceCount

bool	Rendering = true

bool	RenderingWPO = true

Static Private Attributes
static AInstancedRenderer *	Instance = nullptr

Detailed Description

This Actor is responsible for rendering all added unique mesh entries with unique materials efficiently with UInstancedStaticMeshComponent.

The way this works is by creating blueprint based on AInstancedActor in Unreal Editor, setup the desired mesh and material in the blueprint and placing them in the level in any way. Then at runtime (AInstancedActor BeginPlay), its Mesh and Material is added to this Renderer.

Note. Mesh material(s) need to have bUsedWithInstancedStaticMeshes set to True to work with UInstancedStaticMeshComponent.

Definition at line 64 of file InstancedRenderer.h.

Constructor & Destructor Documentation

◆ AInstancedRenderer()

AInstancedRenderer::AInstancedRenderer ( const FObjectInitializer & ObjectInitializer )

Definition at line 18 of file InstancedRenderer.cpp.

                                                                                  : Super(ObjectInitializer)
{
    RootComponent = CreateDefaultSubobject<USceneComponent>(TEXT("SceneRoot"));
    RootComponent->SetMobility(EComponentMobility::Static);
    PrimaryActorTick.bCanEverTick = true;
}

Member Function Documentation

◆ AddActorToInstancedRendering()

bool AInstancedRenderer::AddActorToInstancedRendering ( AInstancedActor * InstancedActor )

Definition at line 162 of file InstancedRenderer.cpp.

{
    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;
}

References FInstancedActorData::Actor, AddOrRemoveActorFromAutomaticTransformUpdates(), FindOrAddUniqueMesh(), AInstancedActor::GetStaticMeshComponent(), AInstancedActor::InstanceAdded(), InstanceEntries, TotalInstanceCount, and AInstancedActor::UpdateTransformAutomatically().

Referenced by AInstancedActor::AddToInstancedRendering().

◆ AddOrRemoveActorFromAutomaticTransformUpdates()

void AInstancedRenderer::AddOrRemoveActorFromAutomaticTransformUpdates	(	bool	Add,
		AInstancedActor *	InstancedActor
	)

Adds or removes an instanced actor from automatic transform updates.

Parameters

Add	True to add the actor to automatic transform updates, false to remove.
InstancedActor	Pointer to the instanced actor being added or removed.

Definition at line 381 of file InstancedRenderer.cpp.

{
    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());
        }
    }
}

References FInstancedActorData::Actor, InstancedActorsToUpdate, and AInstancedActor::UpdatePreviousTransform().

Referenced by AddActorToInstancedRendering(), and AInstancedActor::SetUpdateTransformAutomatically().

◆ AreTransformsEqual()

bool AInstancedRenderer::AreTransformsEqual	(	const FTransform &	TransformA,
		const FTransform &	TransformB
	)		const

private

Definition at line 472 of file InstancedRenderer.cpp.

{
    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;
}

Referenced by UpdateInstancedActors().

◆ BeginPlay()

void AInstancedRenderer::BeginPlay ( )

overrideprivate

Definition at line 25 of file InstancedRenderer.cpp.

{
    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
}

References CurrentWeatherParameters, Destroy, UAgrarsenseStatics::GetAgrarsenseSettings(), AWeather::GetCurrentWeather(), UAgrarsenseStatics::GetWeatherActor(), UAgrarsenseSettings::GetWorldPositionOffsetRenderDistance(), Instance, LogInfo(), OnGraphicsSettingsChanged(), UAgrarsenseSettings::OnGraphicsSettingsChanged, AWeather::OnWeatherChanged, OnWeatherParametersChanged(), and WorldPositionOffsetDistance.

◆ DebugMaterialImpact()

void AInstancedRenderer::DebugMaterialImpact ( bool SetUnrealDefaultMaterial )

Definition at line 598 of file InstancedRenderer.cpp.

{
    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);
                    }
                }
            }
        }
    }
}

References InstanceEntries.

◆ EndPlay()

void AInstancedRenderer::EndPlay ( const EEndPlayReason::Type EndPlayReason )

overrideprivate

Definition at line 76 of file InstancedRenderer.cpp.

{
    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();
}

References UAgrarsenseStatics::GetAgrarsenseSettings(), UAgrarsenseStatics::GetWeatherActor(), Instance, InstancedActorsToUpdate, InstanceEntries, OnGraphicsSettingsChanged(), UAgrarsenseSettings::OnGraphicsSettingsChanged, AWeather::OnWeatherChanged, and OnWeatherParametersChanged().

◆ FindOrAddUniqueMesh()

int32 AInstancedRenderer::FindOrAddUniqueMesh	(	UStaticMeshComponent *	StaticMeshComponent,
		AInstancedActor *	InstancedActor
	)

private

Definition at line 238 of file InstancedRenderer.cpp.

{
    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;
}

References FInstanceEntry::AllowWorldPositionOffsetDisable, CurrentWeatherParameters, AInstancedActor::GetAllowWorldPositionOffsetDisable(), AInstancedActor::GetInstanceEndCullDistance(), AInstancedActor::GetInstanceStartCullDistance(), AInstancedActor::HasAlternativeMaterial(), FInstanceEntry::InstancedStaticMeshComponent, InstanceEntries, FInstanceEntry::InstanceEntryIndex, FInstanceEntry::Materials, FInstanceEntry::Mesh, FInstanceEntry::MeshName, FWeatherParameters::WindIntensity, and WorldPositionOffsetDistance.

Referenced by AddActorToInstancedRendering().

◆ GetInstanceEntries()

TArray< FInstanceEntry > AInstancedRenderer::GetInstanceEntries ( ) const

inline

Definition at line 135 of file InstancedRenderer.h.

    {
        return InstanceEntries;
    }

◆ GetTotalInstanceCount()

int32 AInstancedRenderer::GetTotalInstanceCount ( ) const

inline

Definition at line 115 of file InstancedRenderer.h.

    {
        return TotalInstanceCount;
    }

◆ GetUniqueInstancesCount()

int32 AInstancedRenderer::GetUniqueInstancesCount ( ) const

inline

Definition at line 125 of file InstancedRenderer.h.

    {
        return InstanceEntries.Num();
    }

◆ IsRendering()

bool AInstancedRenderer::IsRendering ( ) const

inline

Definition at line 105 of file InstancedRenderer.h.

    {
        return Rendering;
    }

◆ LogInfo()

void AInstancedRenderer::LogInfo ( ) const

Definition at line 69 of file InstancedRenderer.cpp.

{
#if WITH_EDITOR
    UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: Unique mesh entries: %d | Total Instance Count: %d"), InstanceEntries.Num(), TotalInstanceCount);
#endif
}

References InstanceEntries, and TotalInstanceCount.

Referenced by BeginPlay().

◆ OnGraphicsSettingsChanged()

void AInstancedRenderer::OnGraphicsSettingsChanged ( FGlobalGraphicsSettings GraphicsSettings )

private

Definition at line 527 of file InstancedRenderer.cpp.

{
    SetWorldPositionOffsetDistance(GraphicsSettings.WorldPositionOffsetDistance);
    SetShadowCacheBehaviour(GraphicsSettings.FoliageShadowCacheInvalidationBehaviour);
}

References FGlobalGraphicsSettings::FoliageShadowCacheInvalidationBehaviour, SetShadowCacheBehaviour(), SetWorldPositionOffsetDistance(), and FGlobalGraphicsSettings::WorldPositionOffsetDistance.

Referenced by BeginPlay(), and EndPlay().

◆ OnWeatherParametersChanged()

void AInstancedRenderer::OnWeatherParametersChanged ( FWeatherParameters WeatherParameters )

private

Definition at line 533 of file InstancedRenderer.cpp.

{
    // 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);
    }
}

References CurrentWeatherParameters, SetRenderWorldPositionOffet(), and FWeatherParameters::WindIntensity.

Referenced by BeginPlay(), and EndPlay().

◆ RemoveInstance()

void AInstancedRenderer::RemoveInstance	(	int32	ComponentIndex,
		int32	InstanceNumber
	)

Definition at line 428 of file InstancedRenderer.cpp.

{
    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;
}

References FInstanceEntry::InstancedStaticMeshComponent, InstanceEntries, TotalInstanceCount, and AInstancedActor::UpdateIndex().

Referenced by AInstancedActor::RemoveFromInstancedRendering().

◆ SetComponentIndexVisibility()

void AInstancedRenderer::SetComponentIndexVisibility	(	int32	Index,
		bool	Visible
	)

Set the visibility of a specific UInstancedStaticMeshComponent at the given index. Debugging purposes.

Parameters

Index	The index of the UInstancedStaticMeshComponent to modify.
Visible	Whether to make the component visible (true) or hidden (false).

Definition at line 509 of file InstancedRenderer.cpp.

{
    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);
    }
}

References FInstanceEntry::InstancedStaticMeshComponent, and InstanceEntries.

◆ SetInstancedRendering()

void AInstancedRenderer::SetInstancedRendering ( bool ShouldRender )

Definition at line 493 of file InstancedRenderer.cpp.

{
    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
}

References InstanceEntries, and Rendering.

Referenced by UAgrarsenseSettings::SetInstancedRenderingVisibility().

◆ SetRenderCustomDepth()

void AInstancedRenderer::SetRenderCustomDepth ( bool Enabled )

Sets whether the custom depth rendering is enabled or disabled.

Parameters

Enabled True to enable custom depth rendering, false to disable.

Definition at line 546 of file InstancedRenderer.cpp.

{
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        if (Entry.InstancedStaticMeshComponent)
        {
            Entry.InstancedStaticMeshComponent->SetRenderCustomDepth(Enabled);
        }
    }
}

References InstanceEntries.

◆ SetRenderWorldPositionOffet()

void AInstancedRenderer::SetRenderWorldPositionOffet ( bool RenderWPO )

Sets whether the World Position Offset (WPO) rendering is enabled or disabled.

Parameters

RenderWPO True to enable World Position Offset rendering, false to disable.

Definition at line 586 of file InstancedRenderer.cpp.

{
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        if (Entry.AllowWorldPositionOffsetDisable && Entry.InstancedStaticMeshComponent)
        {
            Entry.InstancedStaticMeshComponent->SetEvaluateWorldPositionOffset(RenderWPO);
            Entry.InstancedStaticMeshComponent->SetEvaluateWorldPositionOffsetInRayTracing(RenderWPO);
        }
    }
}

References InstanceEntries.

Referenced by OnWeatherParametersChanged().

◆ SetShadowCacheBehaviour()

void AInstancedRenderer::SetShadowCacheBehaviour ( EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehaviour )

Sets the behavior for shadow cache invalidation. Default Rigid.

Parameters

ShadowCacheInvalidationBehaviour The new behavior for shadow cache invalidation.

Definition at line 575 of file InstancedRenderer.cpp.

{
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        if (Entry.InstancedStaticMeshComponent)
        {
            Entry.InstancedStaticMeshComponent->ShadowCacheInvalidationBehavior = ShadowCacheInvalidationBehaviour;
        }
    }
}

References InstanceEntries.

Referenced by OnGraphicsSettingsChanged().

◆ SetWorldPositionOffsetDistance()

void AInstancedRenderer::SetWorldPositionOffsetDistance ( int32 NewWPODistance )

Sets the distance for the World Position Offset (WPO) effect.

Parameters

NewWPODistance The new distance for the World Position Offset.

Definition at line 557 of file InstancedRenderer.cpp.

{
    if (WorldPositionOffsetDistance == NewWPODistance)
    {
        return;
    }
 
    WorldPositionOffsetDistance = NewWPODistance;
 
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        if (Entry.InstancedStaticMeshComponent)
        {
            Entry.InstancedStaticMeshComponent->SetWorldPositionOffsetDisableDistance(WorldPositionOffsetDistance);
        }
    }
}

References InstanceEntries, and WorldPositionOffsetDistance.

Referenced by OnGraphicsSettingsChanged().

◆ Tick()

void AInstancedRenderer::Tick ( float DeltaTime )

overrideprivate

Definition at line 125 of file InstancedRenderer.cpp.

{
    UpdateInstancedActors();
}

References UpdateInstancedActors().

◆ UpdateInstancedActors()

void AInstancedRenderer::UpdateInstancedActors ( )

private

Definition at line 130 of file InstancedRenderer.cpp.

{
    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--;
        }
    }
}

References FInstancedActorData::Actor, AreTransformsEqual(), AInstancedActor::GetComponentIndex(), AInstancedActor::GetInstanceIndex(), AInstancedActor::GetPreviousTransform(), InstancedActorsToUpdate, UpdateInstanceTransform(), and AInstancedActor::UpdatePreviousTransform().

Referenced by Tick().

◆ UpdateInstanceTransform()

void AInstancedRenderer::UpdateInstanceTransform	(	int32	ComponentIndex,
		int32	InstanceNumber,
		const FTransform &	NewTransform
	)

Definition at line 413 of file InstancedRenderer.cpp.

{
    if (!InstanceEntries.IsValidIndex(ComponentIndex))
    {
        return;
    }
 
    FInstanceEntry& Entry = InstanceEntries[ComponentIndex];
 
    if (Entry.InstancedStaticMeshComponent)
    {
        Entry.InstancedStaticMeshComponent->UpdateInstanceTransform(InstanceNumber, NewTransform, true, true);
    }
}

References FInstanceEntry::InstancedStaticMeshComponent, and InstanceEntries.

Referenced by UpdateInstancedActors(), and AInstancedActor::UpdateTransformPosition().

Member Data Documentation

◆ CurrentWeatherParameters

FWeatherParameters AInstancedRenderer::CurrentWeatherParameters

private

Definition at line 238 of file InstancedRenderer.h.

Referenced by BeginPlay(), FindOrAddUniqueMesh(), and OnWeatherParametersChanged().

◆ Instance

AInstancedRenderer * AInstancedRenderer::Instance = nullptr

staticprivate

Definition at line 197 of file InstancedRenderer.h.

Referenced by BeginPlay(), and EndPlay().

◆ InstancedActorsToUpdate

std::vector<FInstancedActorData> AInstancedRenderer::InstancedActorsToUpdate

private

Definition at line 236 of file InstancedRenderer.h.

Referenced by AddOrRemoveActorFromAutomaticTransformUpdates(), EndPlay(), and UpdateInstancedActors().

◆ InstanceEntries

TArray<FInstanceEntry> AInstancedRenderer::InstanceEntries

private

Array containing instance entries for each unique mesh and material combination. Each entry represents an instance of a mesh with associated actors and properties.

Definition at line 229 of file InstancedRenderer.h.

Referenced by AddActorToInstancedRendering(), DebugMaterialImpact(), EndPlay(), FindOrAddUniqueMesh(), LogInfo(), RemoveInstance(), SetComponentIndexVisibility(), SetInstancedRendering(), SetRenderCustomDepth(), SetRenderWorldPositionOffet(), SetShadowCacheBehaviour(), SetWorldPositionOffsetDistance(), and UpdateInstanceTransform().

◆ Rendering

bool AInstancedRenderer::Rendering = true

private

Definition at line 242 of file InstancedRenderer.h.

Referenced by SetInstancedRendering().

◆ RenderingWPO

bool AInstancedRenderer::RenderingWPO = true

private

Definition at line 244 of file InstancedRenderer.h.

◆ TotalInstanceCount

int32 AInstancedRenderer::TotalInstanceCount

private

Definition at line 240 of file InstancedRenderer.h.

Referenced by AddActorToInstancedRendering(), LogInfo(), and RemoveInstance().

◆ WorldPositionOffsetDistance

int32 AInstancedRenderer::WorldPositionOffsetDistance = 30000

private

World Position Offset (WPO) render distance in cm

Definition at line 234 of file InstancedRenderer.h.

Referenced by BeginPlay(), FindOrAddUniqueMesh(), and SetWorldPositionOffsetDistance().

The documentation for this class was generated from the following files:

Unreal/Agrarsense/Source/Agrarsense/InstancedRendering/InstancedRenderer.h
Unreal/Agrarsense/Source/Agrarsense/InstancedRendering/InstancedRenderer.cpp

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AInstancedRenderer()

Member Function Documentation

◆ AddActorToInstancedRendering()

◆ AddOrRemoveActorFromAutomaticTransformUpdates()

◆ AreTransformsEqual()

◆ BeginPlay()

◆ DebugMaterialImpact()

◆ EndPlay()

◆ FindOrAddUniqueMesh()

◆ GetInstanceEntries()

◆ GetTotalInstanceCount()

◆ GetUniqueInstancesCount()

◆ IsRendering()

◆ LogInfo()

◆ OnGraphicsSettingsChanged()

◆ OnWeatherParametersChanged()

◆ RemoveInstance()

◆ SetComponentIndexVisibility()

◆ SetInstancedRendering()

◆ SetRenderCustomDepth()

◆ SetRenderWorldPositionOffet()

◆ SetShadowCacheBehaviour()

◆ SetWorldPositionOffsetDistance()

◆ Tick()

◆ UpdateInstancedActors()

◆ UpdateInstanceTransform()

Member Data Documentation

◆ CurrentWeatherParameters

◆ Instance

◆ InstancedActorsToUpdate

◆ InstanceEntries

◆ Rendering

◆ RenderingWPO

◆ TotalInstanceCount

◆ WorldPositionOffsetDistance