InstancedActorRenderer.h

Go to the documentation of this file.

// Copyright (c) 2025 FrostBit Software Lab at the Lapland University of Applied Sciences
//
// This work is licensed under the terms of the MIT license.
// For a copy, see <https://opensource.org/licenses/MIT>.
 
#pragma once
 
#include "CoreMinimal.h"
#include "GameFramework/Actor.h"
#include "Components/InstancedStaticMeshComponent.h"
 
#include "Agrarsense/Settings/GlobalSimulationSettings.h"
#include "Agrarsense/Settings/GlobalGraphicsSettings.h"
#include "Agrarsense/Weather/WeatherParameters.h"
#include "InstancedActor.h"
 
#include "InstancedActorRenderer.generated.h"
 
/*
* AInstancedActor parameters.
*/
USTRUCT(Blueprintable)
struct AGRARSENSE_API FInstancedActorParameters
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    TSubclassOf<AActor> ActorClass;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
    TWeakObjectPtr<UStaticMesh> Mesh;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
    TArray<UMaterialInterface*> Materials;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    int32 CustomDepthStencilValue = 0;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    bool AllowWorldPositionOffsetDisable = false;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    bool IsTree = false;
};
 
/*
* This Actor handles rendering each unique AInstancedActor with UInstancedStaticMeshComponent.
*/
UCLASS()
class AGRARSENSE_API AInstancedActorRenderer : public AActor
{
    GENERATED_BODY()
 
public:
 
    AInstancedActorRenderer(const FObjectInitializer& ObjectInitializer);
 
    virtual void BeginPlay() override;
 
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    UFUNCTION(BlueprintCallable)
    void SetupFromInstancedActor(AInstancedActor* InstancedActor);
 
    UFUNCTION(BlueprintCallable)
    bool SpawnInstanceBackToActor(UInstancedStaticMeshComponent* ISM, int32 Index, bool OnlyTree);
 
    bool Matches(UStaticMeshComponent* StaticMeshComponent, const bool CanHaveAlternativeMaterial) const;
 
    bool Matches(UInstancedStaticMeshComponent* ISM) const;
 
    UFUNCTION(BlueprintCallable)
    bool SpawnInstancesBackActors();
 
    UFUNCTION(BlueprintPure)
    UInstancedStaticMeshComponent* GetInstancedStaticMeshComponent() const
    {
        return InstancedStaticMeshComponent;
    }
 
    UFUNCTION(BlueprintPure)
    FInstancedActorParameters GetInstancedActorParameters() const
    {
        return InstancedActorParameters;
    }
 
    UFUNCTION(BlueprintPure)
    UStaticMesh* GetStaticMesh() const;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "InstancedActorRenderer")
    UInstancedStaticMeshComponent* InstancedStaticMeshComponent = nullptr;
 
protected:
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "InstancedActorRenderer")
    FInstancedActorParameters InstancedActorParameters;
 
    UFUNCTION(BlueprintCallable, Category = "InstancedActorRenderer")
    void SetWorldPositionOffsetDistance(int32 NewWPODistance);
 
    UFUNCTION(BlueprintCallable, Category = "InstancedActorRenderer")
    void SetShadowCacheBehaviour(EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehaviour);
 
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    void SetRenderWorldPositionOffet(bool RenderWPO);
 
private:
 
    UFUNCTION()
    void OnGraphicsSettingsChanged(FGlobalGraphicsSettings GraphicsSettings);
 
    UFUNCTION()
    void OnWeatherParametersChanged(FWeatherParameters WeatherParameters);
 
    FWeatherParameters CurrentWeatherParameters;
 
    int32 WorldPositionOffsetDistance = 30000;
 
    bool Rendering = true;
 
    bool RenderingWPO = false;
 
};