#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	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)

void	ToggleProxyMesh ()

void	SpawnAllInstancesBackActors ()

bool	SpawnInstanceBackToActor (UInstancedStaticMeshComponent *ISM, int32 Index)

Static Public Member Functions
static AInstancedRenderer *	Get ()

Protected Attributes
TArray< FInstanceEntry >	InstanceEntries

TArray< UInstancedStaticMeshComponent * >	InstancesStaticMeshComponents

int32	TotalInstanceCount = 0

Private Member Functions
virtual void	BeginPlay () override

virtual void	EndPlay (const EEndPlayReason::Type EndPlayReason) override

void	OnGraphicsSettingsChanged (FGlobalGraphicsSettings GraphicsSettings)

void	OnWeatherParametersChanged (FWeatherParameters WeatherParameters)

int32	FindOrAddUniqueMesh (UStaticMeshComponent StaticMeshComponent, AInstancedActor InstancedActor)

Private Attributes
TWeakObjectPtr< UStaticMesh >	ProxyMesh

int32	WorldPositionOffsetDistance = 30000

FWeatherParameters	CurrentWeatherParameters

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 UInstancedStaticMeshComponents.

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.

Or you can setup AInstancedActor based actors in your level and then go to BP_InstancedRenderer Actor and click "AddExistingActorsToRenderer" button to turn AInstancedActors into BP_InstancedRenderer ISM instances. This reduces the amount of Actors in the level and should speed up loading times.

AInstancedActors marked as "TreeActor" can be turned back into regular Actor at runtime when vehicle gets close.

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

Definition at line 75 of file InstancedRenderer.h.

Constructor & Destructor Documentation

◆ AInstancedRenderer()

AInstancedRenderer::AInstancedRenderer ( const FObjectInitializer & ObjectInitializer )

Definition at line 19 of file InstancedRenderer.cpp.

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

References ProxyMesh.

Member Function Documentation

◆ AddActorToInstancedRendering()

bool AInstancedRenderer::AddActorToInstancedRendering ( AInstancedActor * InstancedActor )

Definition at line 129 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;
    }
 
    // 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;
}

References FindOrAddUniqueMesh(), AInstancedActor::GetStaticMeshComponent(), AInstancedActor::InstanceAdded(), InstanceEntries, and TotalInstanceCount.

Referenced by AInstancedActor::AddToInstancedRendering().

◆ BeginPlay()

void AInstancedRenderer::BeginPlay ( )

overrideprivatevirtual

Definition at line 33 of file InstancedRenderer.cpp.

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

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 481 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 )

overrideprivatevirtual

Definition at line 83 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);
    }
 
    // 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();
}

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

◆ FindOrAddUniqueMesh()

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

private

Definition at line 193 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);
 
    // 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;
}

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

Referenced by AddActorToInstancedRendering().

◆ Get()

static AInstancedRenderer * AInstancedRenderer::Get ( )

inlinestatic

Definition at line 212 of file InstancedRenderer.h.

    {
        return Instance;
    }

◆ GetInstanceEntries()

TArray< FInstanceEntry > AInstancedRenderer::GetInstanceEntries ( ) const

inline

Definition at line 140 of file InstancedRenderer.h.

    {
        return InstanceEntries;
    }

◆ GetTotalInstanceCount()

int32 AInstancedRenderer::GetTotalInstanceCount ( ) const

inline

Definition at line 120 of file InstancedRenderer.h.

    {
        return TotalInstanceCount;
    }

◆ GetUniqueInstancesCount()

int32 AInstancedRenderer::GetUniqueInstancesCount ( ) const

inline

Definition at line 130 of file InstancedRenderer.h.

    {
        return InstanceEntries.Num();
    }

◆ IsRendering()

bool AInstancedRenderer::IsRendering ( ) const

inline

Definition at line 110 of file InstancedRenderer.h.

    {
        return Rendering;
    }

◆ LogInfo()

void AInstancedRenderer::LogInfo ( ) const

Definition at line 76 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 410 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 416 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 359 of file InstancedRenderer.cpp.

{
    if (!InstanceEntries.IsValidIndex(ComponentIndex))
    {
        return;
    }
 
    FInstanceEntry& Entry = InstanceEntries[ComponentIndex];
 
    if (Entry.InstancedStaticMeshComponent)
    {
        Entry.InstancedStaticMeshComponent->RemoveInstance(InstanceNumber);
    }
 
    --TotalInstanceCount;
}

References FInstanceEntry::InstancedStaticMeshComponent, InstanceEntries, and TotalInstanceCount.

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 392 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 376 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 429 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 469 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 458 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 440 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().

◆ SpawnAllInstancesBackActors()

void AInstancedRenderer::SpawnAllInstancesBackActors ( )

Definition at line 544 of file InstancedRenderer.cpp.

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

References InstanceEntries, and Transform.

◆ SpawnInstanceBackToActor()

bool AInstancedRenderer::SpawnInstanceBackToActor	(	UInstancedStaticMeshComponent *	ISM,
		int32	Index
	)

Definition at line 594 of file InstancedRenderer.cpp.

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

References FInstanceEntry::ActorClass, AInstancedActor::AddToInstancedRenderer, FInstanceEntry::InstancedStaticMeshComponent, and InstanceEntries.

◆ ToggleProxyMesh()

void AInstancedRenderer::ToggleProxyMesh ( )

Definition at line 520 of file InstancedRenderer.cpp.

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

References InstanceEntries, and ProxyMesh.

◆ UpdateInstanceTransform()

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

Definition at line 344 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 AInstancedActor::UpdateTransformPosition().

Member Data Documentation

◆ CurrentWeatherParameters

FWeatherParameters AInstancedRenderer::CurrentWeatherParameters

private

Definition at line 259 of file InstancedRenderer.h.

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

◆ Instance

AInstancedRenderer * AInstancedRenderer::Instance = nullptr

staticprivate

Definition at line 236 of file InstancedRenderer.h.

Referenced by BeginPlay(), and EndPlay().

◆ InstanceEntries

TArray<FInstanceEntry> AInstancedRenderer::InstanceEntries

protected

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 224 of file InstancedRenderer.h.

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

◆ InstancesStaticMeshComponents

TArray<UInstancedStaticMeshComponent*> AInstancedRenderer::InstancesStaticMeshComponents

protected

Definition at line 227 of file InstancedRenderer.h.

◆ ProxyMesh

TWeakObjectPtr<UStaticMesh> AInstancedRenderer::ProxyMesh

private

Definition at line 234 of file InstancedRenderer.h.

Referenced by AInstancedRenderer(), and ToggleProxyMesh().

◆ Rendering

bool AInstancedRenderer::Rendering = true

private

Definition at line 261 of file InstancedRenderer.h.

Referenced by SetInstancedRendering().

◆ RenderingWPO

bool AInstancedRenderer::RenderingWPO = true

private

Definition at line 263 of file InstancedRenderer.h.

◆ TotalInstanceCount

int32 AInstancedRenderer::TotalInstanceCount = 0

protected

Definition at line 230 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 257 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

Static Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AInstancedRenderer()

Member Function Documentation

◆ AddActorToInstancedRendering()

◆ BeginPlay()

◆ DebugMaterialImpact()

◆ EndPlay()

◆ FindOrAddUniqueMesh()

◆ Get()

◆ GetInstanceEntries()

◆ GetTotalInstanceCount()

◆ GetUniqueInstancesCount()

◆ IsRendering()

◆ LogInfo()

◆ OnGraphicsSettingsChanged()

◆ OnWeatherParametersChanged()

◆ RemoveInstance()

◆ SetComponentIndexVisibility()

◆ SetInstancedRendering()

◆ SetRenderCustomDepth()

◆ SetRenderWorldPositionOffet()

◆ SetShadowCacheBehaviour()

◆ SetWorldPositionOffsetDistance()

◆ SpawnAllInstancesBackActors()

◆ SpawnInstanceBackToActor()

◆ ToggleProxyMesh()

◆ UpdateInstanceTransform()

Member Data Documentation

◆ CurrentWeatherParameters

◆ Instance

◆ InstanceEntries

◆ InstancesStaticMeshComponents

◆ ProxyMesh

◆ Rendering

◆ RenderingWPO

◆ TotalInstanceCount

◆ WorldPositionOffsetDistance