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

void	UpdateRenderDistances ()

void	DestroyOverlappingInstancesBox (UInstancedStaticMeshComponent *ISM, FBox AreaBox, bool OnlyTrees)

bool	SpawnInstanceBackToActor (UInstancedStaticMeshComponent *ISM, int32 Index, bool OnlyTree)

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)

bool	FindOrAddUniqueMesh (UStaticMeshComponent StaticMeshComponent, AInstancedActor InstancedActor, int32 &InstanceNum)

Private Attributes
TWeakObjectPtr< UStaticMesh >	CubeMesh

int32	WorldPositionOffsetDistance = 30000

FWeatherParameters	CurrentWeatherParameters

bool	Rendering = true

bool	RenderingWPO = false

Static Private Attributes
static AInstancedRenderer *	Instance = nullptr

Detailed Description

This Actor is responsible for managing all Instanced Static Mesh Components in the level.

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 in Editor. This reduces the amount of Actors in the level and should speed up loading and Editor play 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 76 of file InstancedRenderer.h.

Constructor & Destructor Documentation

◆ AInstancedRenderer()

AInstancedRenderer::AInstancedRenderer ( const FObjectInitializer & ObjectInitializer )

Definition at line 22 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())
    {
        CubeMesh = DefaultMesh.Object;
    }
}

References CubeMesh.

Member Function Documentation

◆ AddActorToInstancedRendering()

bool AInstancedRenderer::AddActorToInstancedRendering ( AInstancedActor * InstancedActor )

Definition at line 138 of file InstancedRenderer.cpp.

{
    if (!InstancedActor)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: Actor is null!"));
#endif
        return false;
    }
 
    if (InstancedActor->UpdateTransformAutomatically())
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: AInstancedActor %s is set to update transform automatically."), *InstancedActor->GetName());
#endif
        return false;
    }
 
    UStaticMeshComponent* StaticMeshComponent = InstancedActor->GetStaticMeshComponent();
    if (!StaticMeshComponent)
    {
#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)
    {
#if WITH_EDITOR
        UE_LOG(LogTemp, Warning, TEXT("InstancedRenderer.cpp: AInstancedActor %s UStaticMeshComponent mesh is null!"), *InstancedActor->GetName());
#endif
        return false;
    }
 
    int32 ComponentIndex = 9999;
 
    // Find or create InstancedStaticMeshComponents array index for this instance
    bool Found = FindOrAddUniqueMesh(StaticMeshComponent, InstancedActor, ComponentIndex);
 
    if (!Found || !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, TotalInstanceCount, and AInstancedActor::UpdateTransformAutomatically().

Referenced by AInstancedActor::AddToInstancedRendering().

◆ BeginPlay()

void AInstancedRenderer::BeginPlay ( )

overrideprivatevirtual

Definition at line 37 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);
 
    if (!InstanceEntries.IsEmpty() && InstanceEntries[0].UsingProxy)
    {
        ToggleProxyMesh();
    }
#endif
}

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

◆ DebugMaterialImpact()

void AInstancedRenderer::DebugMaterialImpact ( bool SetUnrealDefaultMaterial )

Definition at line 534 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.

◆ DestroyOverlappingInstancesBox()

void AInstancedRenderer::DestroyOverlappingInstancesBox	(	UInstancedStaticMeshComponent *	ISM,
		FBox	AreaBox,
		bool	OnlyTrees
	)

Destroys all instances overlapping the specified Box area.

Parameters

ISM	- The instanced static mesh component.
AreaBox	- The bounding box defining the area to check.
OnlyTrees	- Whether to limit destruction to tree instances only.

Definition at line 738 of file InstancedRenderer.cpp.

{
    // Check incoming ISM exists in InstanceEntries
    FInstanceEntry* Entry = InstanceEntries.FindByPredicate([ISM](const FInstanceEntry& InEntry) {
        return InEntry.InstancedStaticMeshComponent == ISM;
    });
 
    if (!Entry || (!Entry->IsTree && OnlyTrees))
    {
        return;
    }
 
    // Remove all instances that overlap incoming AreaBox bounds
    if (UInstancedStaticMeshComponent* Comp = Entry->InstancedStaticMeshComponent)
    {
        TArray<int32> OverlappingInstances = Comp->GetInstancesOverlappingBox(AreaBox);
        for (int32 InstanceIndex : OverlappingInstances)
        {
            Comp->RemoveInstance(InstanceIndex);
        }
    }
}

References FInstanceEntry::InstancedStaticMeshComponent, InstanceEntries, and FInstanceEntry::IsTree.

Referenced by ADeletionVolume::DestroyOverlappingActors().

◆ EndPlay()

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

overrideprivatevirtual

Definition at line 92 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()

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

private

Definition at line 211 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 false;
    }
 
    UStaticMesh* Mesh = StaticMeshComponent->GetStaticMesh();
 
    if (!InstancedActor->HasAlternativeMaterial())
    {
        const int32 Num = InstanceEntries.Num();
        for (int32 Index = 0; Index < Num; ++Index)
        {
            if (InstanceEntries[Index].Mesh == Mesh)
            {
                InstanceNum = Index;
                return true;
            }
        }
    }
 
    const int32 NumberOfMaterials = StaticMeshComponent->GetNumMaterials();
 
    TArray<UMaterialInterface*> MeshMaterials;
    MeshMaterials.Reserve(NumberOfMaterials);
 
    for (int32 i = 0; i < NumberOfMaterials; 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)
            {
                InstanceNum = Index;
                return true;
            }
        }
    }
 
    // 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);
 
    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(" "));
    }
 
    // Generate a 4-character GUID
    FString Guid = FGuid::NewGuid().ToString().Left(4);
 
    Name = FString::Printf(TEXT("%s(_%s_)"), *Name, *Guid);
 
    InstancedStaticMeshComponent->Rename(*Name);
 
    // 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 = ClassPtr;
    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);
 
    InstanceNum = InstanceEntries.Num() - 1;
 
    return true;
}

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

    {
        return Instance;
    }

◆ GetInstanceEntries()

TArray< FInstanceEntry > AInstancedRenderer::GetInstanceEntries ( ) const

inline

Definition at line 141 of file InstancedRenderer.h.

    {
        return InstanceEntries;
    }

◆ GetTotalInstanceCount()

int32 AInstancedRenderer::GetTotalInstanceCount ( ) const

inline

Definition at line 121 of file InstancedRenderer.h.

    {
        return TotalInstanceCount;
    }

◆ GetUniqueInstancesCount()

int32 AInstancedRenderer::GetUniqueInstancesCount ( ) const

inline

Definition at line 131 of file InstancedRenderer.h.

    {
        return InstanceEntries.Num();
    }

◆ IsRendering()

bool AInstancedRenderer::IsRendering ( ) const

inline

Definition at line 111 of file InstancedRenderer.h.

    {
        return Rendering;
    }

◆ LogInfo()

void AInstancedRenderer::LogInfo ( ) const

Definition at line 85 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 460 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 466 of file InstancedRenderer.cpp.

{
    CurrentWeatherParameters = WeatherParameters;
 
    bool IsWinter = WeatherParameters.IsWinterSeason();
    bool IsWindy = WeatherParameters.WindIntensity > 0.05f;
    bool ShouldRenderWPO = IsWinter || IsWindy;
 
    // Only update if the rendering state has changed
    if (RenderingWPO != ShouldRenderWPO)
    {
        RenderingWPO = ShouldRenderWPO;
        SetRenderWorldPositionOffet(ShouldRenderWPO);
    }
}

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

Referenced by BeginPlay(), and EndPlay().

◆ RemoveInstance()

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

Definition at line 406 of file InstancedRenderer.cpp.

{
    if (!InstanceEntries.IsValidIndex(ComponentIndex))
    {
        return;
    }
 
    FInstanceEntry& Entry = InstanceEntries[ComponentIndex];
 
    if (Entry.InstancedStaticMeshComponent)
    {
        // Ensure InstanceNumber is valid before attempting to remove
        if (InstanceNumber >= 0 && InstanceNumber < Entry.InstancedStaticMeshComponent->GetInstanceCount())
        {
            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 442 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 426 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 482 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 522 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 511 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 493 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 597 of file InstancedRenderer.cpp.

{
    UWorld* World = GetWorld();
 
    if (InstanceEntries.IsEmpty() || !World)
    {
        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();
}

References InstanceEntries, and Transform.

◆ SpawnInstanceBackToActor()

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

Spawns a specific ISM instance back to its original Actor. Cannot be added back to ISM instance afterwards.

Parameters

ISM	The instanced static mesh component containing the instance.
Index	The index of the instance to spawn back.

Returns: True if the instance was successfully spawned, false otherwise.

Definition at line 685 of file InstancedRenderer.cpp.

{
    if (!ISM || Index < 0 || Index >= ISM->GetInstanceCount())
    {
        return false;
    }
 
    UWorld* World = GetWorld();
 
    // 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 || !World)
    {
        return false;
    }
 
    if (OnlyTree && !Entry->IsTree)
    {
        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, InstanceEntries, and FInstanceEntry::IsTree.

◆ ToggleProxyMesh()

void AInstancedRenderer::ToggleProxyMesh ( )

Definition at line 573 of file InstancedRenderer.cpp.

{
#if WITH_EDITOR
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        auto& ISMComponent = Entry.InstancedStaticMeshComponent;
 
        if (ISMComponent)
        {
            if (!Entry.UsingProxy)
            {
                ISMComponent->SetStaticMesh(CubeMesh.Get());
                Entry.UsingProxy = true;
            }
            else
            {
                ISMComponent->SetStaticMesh(Entry.Mesh.Get());
                Entry.UsingProxy = false;
            }
        }
    }
#endif
}

References CubeMesh, and InstanceEntries.

Referenced by BeginPlay().

◆ UpdateInstanceTransform()

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

Definition at line 391 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().

◆ UpdateRenderDistances()

void AInstancedRenderer::UpdateRenderDistances ( )

Definition at line 645 of file InstancedRenderer.cpp.

{
#if WITH_EDITOR
    UWorld* World = GetWorld();
 
    if (InstanceEntries.IsEmpty() || !World)
    {
        return;
    }
 
    for (FInstanceEntry& Entry : InstanceEntries)
    {
        UInstancedStaticMeshComponent* ISMComponent = Entry.InstancedStaticMeshComponent;
        if (!ISMComponent)
        {
            continue;
        }
 
        UClass* Class = Entry.ActorClass;
        FTransform Transform;
        AActor* SpawnedActor = World->SpawnActorDeferred<AActor>(Class, Transform);
        if (SpawnedActor)
        {
            SpawnedActor->FinishSpawning(Transform);
        }
 
        AInstancedActor* Actor = Cast<AInstancedActor>(SpawnedActor);
        if (Actor)
        {
 
            int32 Min = Actor->GetInstanceStartCullDistance();
            int32 Max = Actor->GetInstanceEndCullDistance();
            ISMComponent->SetCullDistances(Min, Max);
 
            Actor->Destroy();
        }
    }
#endif
}

References AInstancedActor::GetInstanceEndCullDistance(), AInstancedActor::GetInstanceStartCullDistance(), InstanceEntries, and Transform.

Member Data Documentation

◆ CubeMesh

TWeakObjectPtr<UStaticMesh> AInstancedRenderer::CubeMesh

private

Definition at line 261 of file InstancedRenderer.h.

Referenced by AInstancedRenderer(), and ToggleProxyMesh().

◆ CurrentWeatherParameters

FWeatherParameters AInstancedRenderer::CurrentWeatherParameters

private

Definition at line 286 of file InstancedRenderer.h.

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

◆ Instance

AInstancedRenderer * AInstancedRenderer::Instance = nullptr

staticprivate

Definition at line 263 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 251 of file InstancedRenderer.h.

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

◆ InstancesStaticMeshComponents

TArray<UInstancedStaticMeshComponent*> AInstancedRenderer::InstancesStaticMeshComponents

protected

Definition at line 254 of file InstancedRenderer.h.

◆ Rendering

bool AInstancedRenderer::Rendering = true

private

Definition at line 288 of file InstancedRenderer.h.

Referenced by SetInstancedRendering().

◆ RenderingWPO

bool AInstancedRenderer::RenderingWPO = false

private

Definition at line 290 of file InstancedRenderer.h.

Referenced by OnWeatherParametersChanged().

◆ TotalInstanceCount

int32 AInstancedRenderer::TotalInstanceCount = 0

protected

Definition at line 257 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 284 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()

◆ DestroyOverlappingInstancesBox()

◆ EndPlay()

◆ FindOrAddUniqueMesh()

◆ Get()

◆ GetInstanceEntries()

◆ GetTotalInstanceCount()

◆ GetUniqueInstancesCount()

◆ IsRendering()

◆ LogInfo()

◆ OnGraphicsSettingsChanged()

◆ OnWeatherParametersChanged()

◆ RemoveInstance()

◆ SetComponentIndexVisibility()

◆ SetInstancedRendering()

◆ SetRenderCustomDepth()

◆ SetRenderWorldPositionOffet()

◆ SetShadowCacheBehaviour()

◆ SetWorldPositionOffsetDistance()

◆ SpawnAllInstancesBackActors()

◆ SpawnInstanceBackToActor()

◆ ToggleProxyMesh()

◆ UpdateInstanceTransform()

◆ UpdateRenderDistances()

Member Data Documentation

◆ CubeMesh

◆ CurrentWeatherParameters

◆ Instance

◆ InstanceEntries

◆ InstancesStaticMeshComponents

◆ Rendering

◆ RenderingWPO

◆ TotalInstanceCount

◆ WorldPositionOffsetDistance