#include <InstancedActorRenderer.h>

Inheritance diagram for AInstancedActorRenderer:

Collaboration diagram for AInstancedActorRenderer:

[legend]

Public Member Functions
	AInstancedActorRenderer (const FObjectInitializer &ObjectInitializer)

virtual void	BeginPlay () override

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

void	SetupFromInstancedActor (AInstancedActor *InstancedActor)

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

bool	Matches (UStaticMeshComponent *StaticMeshComponent, const bool CanHaveAlternativeMaterial) const

bool	Matches (UInstancedStaticMeshComponent *ISM) const

bool	SpawnInstancesBackActors ()

UInstancedStaticMeshComponent *	GetInstancedStaticMeshComponent () const

FInstancedActorParameters	GetInstancedActorParameters () const

UStaticMesh *	GetStaticMesh () const

Public Attributes
UInstancedStaticMeshComponent *	InstancedStaticMeshComponent = nullptr

Protected Member Functions
void	SetWorldPositionOffsetDistance (int32 NewWPODistance)

void	SetShadowCacheBehaviour (EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehaviour)

void	SetRenderWorldPositionOffet (bool RenderWPO)

Protected Attributes
FInstancedActorParameters	InstancedActorParameters

Private Member Functions
void	OnGraphicsSettingsChanged (FGlobalGraphicsSettings GraphicsSettings)

void	OnWeatherParametersChanged (FWeatherParameters WeatherParameters)

Private Attributes
FWeatherParameters	CurrentWeatherParameters

int32	WorldPositionOffsetDistance = 30000

bool	Rendering = true

bool	RenderingWPO = false

Detailed Description

Definition at line 50 of file InstancedActorRenderer.h.

Constructor & Destructor Documentation

◆ AInstancedActorRenderer()

AInstancedActorRenderer::AInstancedActorRenderer ( const FObjectInitializer & ObjectInitializer )

Definition at line 12 of file InstancedActorRenderer.cpp.

                                                                                            : Super(ObjectInitializer)
{
    PrimaryActorTick.bCanEverTick = false;
}

Member Function Documentation

◆ BeginPlay()

void AInstancedActorRenderer::BeginPlay ( )

overridevirtual

Definition at line 17 of file InstancedActorRenderer.cpp.

{
    Super::BeginPlay();
 
    UWorld* World = GetWorld();
 
    UAgrarsenseSettings* Settings = UAgrarsenseStatics::GetAgrarsenseSettings();
    if (Settings)
    {
        WorldPositionOffsetDistance = Settings->GetWorldPositionOffsetRenderDistance();
        Settings->OnGraphicsSettingsChanged.AddUniqueDynamic(this, &AInstancedActorRenderer::OnGraphicsSettingsChanged);
    }
 
    AWeather* Weather = UAgrarsenseStatics::GetWeatherActor(World);
    if (Weather)
    {
        CurrentWeatherParameters = Weather->GetCurrentWeather();
        Weather->OnWeatherChanged.AddUniqueDynamic(this, &AInstancedActorRenderer::OnWeatherParametersChanged);
    }
}

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

◆ EndPlay()

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

overridevirtual

Definition at line 38 of file InstancedActorRenderer.cpp.

{
    Super::EndPlay(EndPlayReason);
 
    UWorld* World = GetWorld();
 
    UAgrarsenseSettings* Settings = UAgrarsenseStatics::GetAgrarsenseSettings();
    if (Settings)
    {
        Settings->OnGraphicsSettingsChanged.RemoveDynamic(this, &AInstancedActorRenderer::OnGraphicsSettingsChanged);
    }
 
    AWeather* Weather = UAgrarsenseStatics::GetWeatherActor(World);
    if (Weather)
    {
        Weather->OnWeatherChanged.RemoveDynamic(this, &AInstancedActorRenderer::OnWeatherParametersChanged);
    }
}

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

◆ GetInstancedActorParameters()

FInstancedActorParameters AInstancedActorRenderer::GetInstancedActorParameters ( ) const

inline

Definition at line 82 of file InstancedActorRenderer.h.

    {
        return InstancedActorParameters;
    }

◆ GetInstancedStaticMeshComponent()

UInstancedStaticMeshComponent * AInstancedActorRenderer::GetInstancedStaticMeshComponent ( ) const

inline

Definition at line 76 of file InstancedActorRenderer.h.

    {
        return InstancedStaticMeshComponent;
    }

Referenced by AInstancedRendererManager::AppendOrCreateISM().

◆ GetStaticMesh()

UStaticMesh * AInstancedActorRenderer::GetStaticMesh ( ) const

Definition at line 236 of file InstancedActorRenderer.cpp.

{
    if (InstancedStaticMeshComponent) 
    {
        return InstancedStaticMeshComponent->GetStaticMesh();
    }
 
    return nullptr;
}

References InstancedStaticMeshComponent.

◆ Matches() [1/2]

bool AInstancedActorRenderer::Matches ( UInstancedStaticMeshComponent * ISM ) const

Definition at line 354 of file InstancedActorRenderer.cpp.

{
    if (!ISM || InstancedStaticMeshComponent)
    {
        return false;
    }
 
    if (ISM->GetStaticMesh() == InstancedActorParameters.Mesh)
    {
        const int32 NumberOfMaterials = ISM->GetNumMaterials();
        if (NumberOfMaterials != InstancedActorParameters.Materials.Num())
        {
            return false;
        }
 
        for (int32 i = 0; i < NumberOfMaterials; i++)
        {
            if (ISM->GetMaterial(i) != InstancedActorParameters.Materials[i])
            {
                return false;
            }
        }
 
        return true;
    }
 
    return false;
}

References InstancedActorParameters, InstancedStaticMeshComponent, FInstancedActorParameters::Materials, and FInstancedActorParameters::Mesh.

◆ Matches() [2/2]

bool AInstancedActorRenderer::Matches	(	UStaticMeshComponent *	StaticMeshComponent,
		const bool	CanHaveAlternativeMaterial
	)		const

Definition at line 299 of file InstancedActorRenderer.cpp.

{
    if (!StaticMeshComponent)
    {
        return false;
    }
 
    UStaticMesh* StaticMesh = StaticMeshComponent->GetStaticMesh();
    if (!StaticMesh)
    {
        return false;
    }
 
    if (!CanHaveAlternativeMaterial)
    {
        if (InstancedActorParameters.Mesh == StaticMesh) 
        {
            return true;
        }
    }
    else 
    {
        const int32 NumberOfMaterials = StaticMeshComponent->GetNumMaterials();
        TArray<UMaterialInterface*> MeshMaterials;
        MeshMaterials.Reserve(NumberOfMaterials);
        for (int32 i = 0; i < NumberOfMaterials; i++)
        {
            MeshMaterials.Add(StaticMeshComponent->GetMaterial(i));
        }
 
        if (InstancedActorParameters.Mesh == StaticMesh)
        {
            bool bMaterialsMatch = true;
 
            for (int32 MaterialIndex = 0; MaterialIndex < InstancedActorParameters.Materials.Num(); ++MaterialIndex)
            {
                UMaterialInterface* UniqueMeshMaterial = InstancedActorParameters.Materials[MaterialIndex];
                UMaterialInterface* MeshMaterial = MeshMaterials[MaterialIndex];
                if (UniqueMeshMaterial != MeshMaterial)
                {
                    bMaterialsMatch = false;
                }
            }
            MeshMaterials.Empty();
 
            if (bMaterialsMatch)
            {
                return true;
            }
        }
    }
 
    return false;
}

References InstancedActorParameters, FInstancedActorParameters::Materials, and FInstancedActorParameters::Mesh.

◆ OnGraphicsSettingsChanged()

void AInstancedActorRenderer::OnGraphicsSettingsChanged ( FGlobalGraphicsSettings GraphicsSettings )

private

Definition at line 415 of file InstancedActorRenderer.cpp.

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

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

Referenced by BeginPlay(), and EndPlay().

◆ OnWeatherParametersChanged()

void AInstancedActorRenderer::OnWeatherParametersChanged ( FWeatherParameters WeatherParameters )

private

Definition at line 421 of file InstancedActorRenderer.cpp.

{
    CurrentWeatherParameters = WeatherParameters;
 
    bool IsWinter = WeatherParameters.IsWinterSeason();
    bool IsWindy = WeatherParameters.WindIntensity > 0.05f;
 
    // Should render tree wind (WPO)
    bool ShouldRenderTreeWPO = IsWinter || IsWindy;
 
    // Should render snow (WPO), like rocks etc.
    bool ShouldRenderSnowWPO = WeatherParameters.SnowAmount != 0.0f;
 
    bool ShouldRenderWPO = IsWinter || IsWindy;
 
    // Only update if the rendering state has changed
    if (RenderingWPO != ShouldRenderWPO)
    {
        RenderingWPO = ShouldRenderWPO;
        SetRenderWorldPositionOffet(ShouldRenderWPO);
    }
}

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

Referenced by BeginPlay(), and EndPlay().

◆ SetRenderWorldPositionOffet()

void AInstancedActorRenderer::SetRenderWorldPositionOffet ( bool RenderWPO )

protected

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 406 of file InstancedActorRenderer.cpp.

{
    if (InstancedStaticMeshComponent)
    {
        InstancedStaticMeshComponent->SetEvaluateWorldPositionOffset(RenderWPO);
        InstancedStaticMeshComponent->SetEvaluateWorldPositionOffsetInRayTracing(RenderWPO);
    }
}

References InstancedStaticMeshComponent.

Referenced by OnWeatherParametersChanged().

◆ SetShadowCacheBehaviour()

void AInstancedActorRenderer::SetShadowCacheBehaviour ( EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehaviour )

protected

Sets the behavior for shadow cache invalidation. Default Rigid.

Parameters

ShadowCacheInvalidationBehaviour The new behavior for shadow cache invalidation.

Definition at line 398 of file InstancedActorRenderer.cpp.

{
    if (InstancedStaticMeshComponent)
    {
        InstancedStaticMeshComponent->ShadowCacheInvalidationBehavior = ShadowCacheInvalidationBehaviour;
    }
}

References InstancedStaticMeshComponent.

Referenced by OnGraphicsSettingsChanged().

◆ SetupFromInstancedActor()

void AInstancedActorRenderer::SetupFromInstancedActor ( AInstancedActor * InstancedActor )

Definition at line 57 of file InstancedActorRenderer.cpp.

{
    if (!InstancedActor)
    {
        return;
    }
 
    UStaticMeshComponent* StaticMeshComponent = InstancedActor->GetStaticMeshComponent();
    UStaticMesh* Mesh = StaticMeshComponent->GetStaticMesh();
    UClass* ClassPtr = InstancedActor->GetClass();
 
    FString Name = IInteractable::Execute_GetInteractableName(InstancedActor).ToString();
 
    if (Name.IsEmpty())
    {
        Name = ClassPtr->GetAuthoredName();
        if (Name.EndsWith(TEXT("_C")))
        {
            Name = Name.LeftChop(2);
        }
        if (Name.StartsWith(TEXT("BP_")))
        {
            Name = Name.RightChop(3);
        }
        Name.ReplaceInline(TEXT("_"), TEXT(" "));
        Name.ReplaceInline(TEXT("Instanced"), TEXT(" "));
    }
 
#if WITH_EDITOR
    FString ActorName = Name;
    ActorName.ReplaceInline(TEXT(","), TEXT(""));
    ActorName.ReplaceInline(TEXT(" "), TEXT("_"));
    ActorName += "_Instanced";
    SetActorLabel(ActorName);
#endif
 
    // Generate a 4-character GUID
    FString Guid = FGuid::NewGuid().ToString().Left(4);
    Name = FString::Printf(TEXT("%s(_%s_)"), *Name, *Guid);
 
    InstancedStaticMeshComponent = NewObject<UInstancedStaticMeshComponent>(this);
    InstancedStaticMeshComponent->AttachToComponent(GetRootComponent(), FAttachmentTransformRules::KeepRelativeTransform);
    AddInstanceComponent(InstancedStaticMeshComponent);
 
    // Add new instance.
    const FTransform& Transform = InstancedActor->GetActorTransform();
    InstancedStaticMeshComponent->AddInstance(Transform);
 
    InstancedStaticMeshComponent->Rename(*Name);
    InstancedStaticMeshComponent->bEditableWhenInherited = false;
    InstancedStaticMeshComponent->RegisterComponent();
    InstancedStaticMeshComponent->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);
    InstancedStaticMeshComponent->CreatePhysicsState(false);
    InstancedStaticMeshComponent->SetSimulatePhysics(false);
    InstancedStaticMeshComponent->SetStaticMesh(Mesh);
    InstancedStaticMeshComponent->SetMobility(EComponentMobility::Static);
    InstancedStaticMeshComponent->SetHiddenInGame(false);
    InstancedStaticMeshComponent->SetVisibility(true);
    InstancedStaticMeshComponent->AttachToComponent(RootComponent, FAttachmentTransformRules::KeepWorldTransform);
    InstancedStaticMeshComponent->InstanceStartCullDistance = InstancedActor->GetInstanceStartCullDistance();
    InstancedStaticMeshComponent->InstanceEndCullDistance = InstancedActor->GetInstanceEndCullDistance();
 
    bool AllowWorldPositionOffsetDisable = InstancedActor->GetAllowWorldPositionOffsetDisable();
 
    // For whatever reason this only works when done a bit later..
    FTimerHandle Handle;
    GetWorld()->GetTimerManager().SetTimer(Handle, FTimerDelegate::CreateLambda([this, AllowWorldPositionOffsetDisable] {
        if (InstancedStaticMeshComponent && AllowWorldPositionOffsetDisable && CurrentWeatherParameters.WindIntensity < 0.05f)
        {
            InstancedStaticMeshComponent->SetEvaluateWorldPositionOffset(false);
            InstancedStaticMeshComponent->SetEvaluateWorldPositionOffsetInRayTracing(false);
        }}), 0.350f, false);
 
    // Thermal and Semantic camera use custom depth.
    // RenderCustomDepth is set to false, if no Thermal or Semantic camera exists in the level,
    // and is automatically set to true/false for all instances when they are spawned/destroyed.
    // Doing this saves a lot rendering performance.
    InstancedStaticMeshComponent->SetRenderCustomDepth(true);
    InstancedStaticMeshComponent->SetCustomDepthStencilValue(StaticMeshComponent->CustomDepthStencilValue);
 
    // Huge performance implication, recommend is Rigid (especially for Foliage with WPO).
    // https://docs.unrealengine.com/5.3/en-US/PythonAPI/class/ShadowCacheInvalidationBehavior.html
    InstancedStaticMeshComponent->ShadowCacheInvalidationBehavior = EShadowCacheInvalidationBehavior::Rigid;
 
    const int32 NumberOfMaterials = StaticMeshComponent->GetNumMaterials();
    TArray<UMaterialInterface*> MeshMaterials;
    MeshMaterials.Reserve(NumberOfMaterials);
    for (int32 i = 0; i < NumberOfMaterials; i++)
    {
        MeshMaterials.Add(StaticMeshComponent->GetMaterial(i));
    }
 
    InstancedActorParameters.ActorClass = ClassPtr;
    InstancedActorParameters.Mesh = Mesh;
    InstancedActorParameters.Materials = MeshMaterials;
    InstancedActorParameters.CustomDepthStencilValue = StaticMeshComponent->CustomDepthStencilValue;
    InstancedActorParameters.AllowWorldPositionOffsetDisable = AllowWorldPositionOffsetDisable;
    InstancedActorParameters.IsTree = InstancedActor->IsTreeActor();
 
    // Set materials to newly created UInstancedStaticMeshComponent
    const int32 MaterialCount = MeshMaterials.Num();
    for (int32 MaterialIndex = 0; MaterialIndex < MaterialCount; ++MaterialIndex)
    {
        UMaterialInterface* MaterialInterface = InstancedActorParameters.Materials[MaterialIndex];
 
        if (MaterialInterface)
        {
            InstancedStaticMeshComponent->SetMaterial(MaterialIndex, MaterialInterface);
 
#if WITH_EDITOR
            // Validate in Editor that material has bUsedWithInstancedStaticMeshes on
            UMaterial* Material = Cast<UMaterial>(MaterialInterface);
            if (Material)
            {
                if (!Material->bUsedWithInstancedStaticMeshes)
                {
                    UE_LOG(LogTemp, Warning, TEXT("AInstancedRendererManager: Material '%s' bUsedWithInstancedStaticMeshes is not set to true!"), *Material->GetName());
                }
            }
#endif
        }
    }
 
    InstancedActor->InstanceAdded();
    InstancedActor->Destroy();
}

References FInstancedActorParameters::ActorClass, FInstancedActorParameters::AllowWorldPositionOffsetDisable, CurrentWeatherParameters, FInstancedActorParameters::CustomDepthStencilValue, AInstancedActor::GetAllowWorldPositionOffsetDisable(), AInstancedActor::GetInstanceEndCullDistance(), AInstancedActor::GetInstanceStartCullDistance(), AInstancedActor::GetStaticMeshComponent(), AInstancedActor::InstanceAdded(), InstancedActorParameters, InstancedStaticMeshComponent, FInstancedActorParameters::IsTree, AInstancedActor::IsTreeActor(), FInstancedActorParameters::Materials, FInstancedActorParameters::Mesh, Transform, and FWeatherParameters::WindIntensity.

Referenced by AInstancedRendererManager::AddActorToInstancedRendering().

◆ SetWorldPositionOffsetDistance()

void AInstancedActorRenderer::SetWorldPositionOffsetDistance ( int32 NewWPODistance )

protected

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

Parameters

NewWPODistance The new distance for the World Position Offset.

Definition at line 383 of file InstancedActorRenderer.cpp.

{
    if (WorldPositionOffsetDistance == NewWPODistance)
    {
        return;
    }
 
    WorldPositionOffsetDistance = NewWPODistance;
 
    if (InstancedStaticMeshComponent)
    {
        InstancedStaticMeshComponent->SetWorldPositionOffsetDisableDistance(WorldPositionOffsetDistance);
    }
}

References InstancedStaticMeshComponent, and WorldPositionOffsetDistance.

Referenced by OnGraphicsSettingsChanged().

◆ SpawnInstanceBackToActor()

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

Definition at line 184 of file InstancedActorRenderer.cpp.

{
    if (!ISM || !InstancedStaticMeshComponent|| Index < 0 || Index >= ISM->GetInstanceCount())
    {
        return false;
    }
 
    if (ISM != InstancedStaticMeshComponent) 
    {
        return false;
    }
 
    UWorld* World = GetWorld();
    if (!World)
    {
        return false;
    }
 
    if (OnlyTree && !InstancedActorParameters.IsTree)
    {
        return false;
    }
 
    UClass* ActorClass = InstancedActorParameters.ActorClass;
    if (!ActorClass)
    {
        return false;
    }
 
    // Get the transform for the specified instance
    FTransform InstanceTransform;
    InstancedStaticMeshComponent->GetInstanceTransform(Index, InstanceTransform);
 
    // Spawn the actor
    AActor* SpawnedActor = World->SpawnActorDeferred<AActor>(ActorClass, InstanceTransform);
    if (SpawnedActor)
    {
        AInstancedActor* InstancedActor = Cast<AInstancedActor>(SpawnedActor);
        if (InstancedActor)
        {
            InstancedActor->AddToInstancedRenderer = false;
        }
 
        SpawnedActor->FinishSpawning(InstanceTransform);
 
        // Remove this ISM instance.
        return InstancedStaticMeshComponent->RemoveInstance(Index);
    }
 
    return true;
}

References FInstancedActorParameters::ActorClass, AInstancedActor::AddToInstancedRenderer, InstancedActorParameters, InstancedStaticMeshComponent, and FInstancedActorParameters::IsTree.

◆ SpawnInstancesBackActors()

bool AInstancedActorRenderer::SpawnInstancesBackActors ( )

Definition at line 246 of file InstancedActorRenderer.cpp.

{
    UWorld* World = GetWorld();
 
    if (!World)
    {
        return false;
    }
 
    if (!InstancedStaticMeshComponent)
    {
        return false;
    }
 
    UClass* Class = InstancedActorParameters.ActorClass;
    if (!Class)
    {
        UE_LOG(LogTemp, Warning, TEXT("AInstancedActorRenderer: No spawn class setup."));
        return false;
    }
 
    InstancedStaticMeshComponent->SetVisibility(false);
 
    // Extract transforms from ISM component into TArray
    TArray<FTransform> Transforms;
 
    const int32 InstanceCount = InstancedStaticMeshComponent->GetInstanceCount();
 
    for (int32 i = 0; i < InstanceCount; i++)
    {
        FTransform Transform;
        InstancedStaticMeshComponent->GetInstanceTransform(i, Transform);
        Transforms.Add(Transform);
    }
 
    // Spawn actors to level
    for (const FTransform& Transform : Transforms)
    {
        if (Class)
        {
            AActor* SpawnedActor = World->SpawnActorDeferred<AActor>(Class, Transform);
            if (SpawnedActor)
            {
                SpawnedActor->FinishSpawning(Transform);
            }
        }
    }
 
    InstancedStaticMeshComponent->DestroyComponent();
 
    return true;
}

References FInstancedActorParameters::ActorClass, InstancedActorParameters, InstancedStaticMeshComponent, and Transform.

Referenced by AInstancedRendererManager::SpawnAllInstancesBackToActors().

Member Data Documentation

◆ CurrentWeatherParameters

FWeatherParameters AInstancedActorRenderer::CurrentWeatherParameters

private

Definition at line 127 of file InstancedActorRenderer.h.

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

◆ InstancedActorParameters

FInstancedActorParameters AInstancedActorRenderer::InstancedActorParameters

protected

Definition at line 96 of file InstancedActorRenderer.h.

Referenced by Matches(), SetupFromInstancedActor(), SpawnInstanceBackToActor(), and SpawnInstancesBackActors().

◆ InstancedStaticMeshComponent

UInstancedStaticMeshComponent* AInstancedActorRenderer::InstancedStaticMeshComponent = nullptr

Definition at line 91 of file InstancedActorRenderer.h.

Referenced by GetStaticMesh(), Matches(), SetRenderWorldPositionOffet(), SetShadowCacheBehaviour(), SetupFromInstancedActor(), SetWorldPositionOffsetDistance(), SpawnInstanceBackToActor(), and SpawnInstancesBackActors().

◆ Rendering

bool AInstancedActorRenderer::Rendering = true

private

Definition at line 134 of file InstancedActorRenderer.h.

◆ RenderingWPO

bool AInstancedActorRenderer::RenderingWPO = false

private

Definition at line 136 of file InstancedActorRenderer.h.

Referenced by OnWeatherParametersChanged().

◆ WorldPositionOffsetDistance

int32 AInstancedActorRenderer::WorldPositionOffsetDistance = 30000

private

World Position Offset (WPO) render distance in cm

Definition at line 132 of file InstancedActorRenderer.h.

Referenced by BeginPlay(), and SetWorldPositionOffsetDistance().

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

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

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ AInstancedActorRenderer()

Member Function Documentation

◆ BeginPlay()

◆ EndPlay()

◆ GetInstancedActorParameters()

◆ GetInstancedStaticMeshComponent()

◆ GetStaticMesh()

◆ Matches() [1/2]

◆ Matches() [2/2]

◆ OnGraphicsSettingsChanged()

◆ OnWeatherParametersChanged()

◆ SetRenderWorldPositionOffet()

◆ SetShadowCacheBehaviour()

◆ SetupFromInstancedActor()

◆ SetWorldPositionOffsetDistance()

◆ SpawnInstanceBackToActor()

◆ SpawnInstancesBackActors()

Member Data Documentation

◆ CurrentWeatherParameters

◆ InstancedActorParameters

◆ InstancedStaticMeshComponent

◆ Rendering

◆ RenderingWPO

◆ WorldPositionOffsetDistance