InstancedRenderer.h

Go to the documentation of this file.

// Copyright (c) 2023 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 "Engine/EngineTypes.h"
#include "Engine/StaticMesh.h"
#include "Materials/MaterialInterface.h"
#include "Components/InstancedStaticMeshComponent.h"
#include "Components/StaticMeshComponent.h"
 
#include <vector>
 
#include "Agrarsense/Settings/GlobalSimulationSettings.h"
#include "Agrarsense/Settings/GlobalGraphicsSettings.h"
#include "Agrarsense/Weather/WeatherParameters.h"
#include "InstancedActorData.h"
#include "InstancedActor.h"
 
#include "InstancedRenderer.generated.h"
 
USTRUCT(Blueprintable)
struct AGRARSENSE_API FInstanceEntry
{
    GENERATED_BODY()
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
    UInstancedStaticMeshComponent* InstancedStaticMeshComponent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite)
    TSubclassOf<AActor> ActorClass;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
    TWeakObjectPtr<UStaticMesh> Mesh;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
    TArray<UMaterialInterface*> Materials;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    int32 InstanceEntryIndex = 0;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
    int32 CustomDepthStencilValue;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadWrite)
    bool AllowWorldPositionOffsetDisable = false;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    bool IsTree = false;
 
    bool UsingProxy = false;
};
 
UCLASS()
class AGRARSENSE_API AInstancedRenderer : public AActor
{
    GENERATED_BODY()
 
public:
 
    AInstancedRenderer(const FObjectInitializer& ObjectInitializer);
 
    /*
    * Try to add AInstancedActor into instanced rendering. This is only callable from C++ by design.
    * @param AInstancedActor AInstancedActor pointer
    */
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    bool AddActorToInstancedRendering(AInstancedActor* InstancedActor);
 
    /*
    * Remove instance from this Renderer.
    * @param ComponentIndex index to TArray<UInstancedStaticMeshComponent*>
    * @param InstanceNumber instance number
    */
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    void RemoveInstance(int32 ComponentIndex, int32 InstanceNumber);
 
    /*
    * Update one of the instances transform
    * @param ComponentIndex index to TArray<UInstancedStaticMeshComponent*>
    * @param InstanceNumber instance number
    * @param NewTransform Transform to move the instance
    */
    void UpdateInstanceTransform(int32 ComponentIndex, int32 InstanceNumber, const FTransform& NewTransform);
 
    /*
    * Is this renderer currently rendering all InstancedStaticMeshComponents
    */
    UFUNCTION(BlueprintPure, Category = "Instanced Renderer")
    bool IsRendering() const
    {
        return Rendering;
    }
 
    /*
    * Get number of total instances
    * @return TotalInstanceCount number of total instances
    */
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    int32 GetTotalInstanceCount() const
    {
        return TotalInstanceCount;
    }
 
    /*
    * Get number of unique instances
    * @return number of InstancedStaticMeshComponents
    */
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    int32 GetUniqueInstancesCount() const
    {
        return InstanceEntries.Num();
    }
 
    /*
    * Get Mesh entries TArray
    * @return TArray<FMeshEntry>
    */
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    TArray<FInstanceEntry> GetInstanceEntries() const
    {
        return InstanceEntries;
    }
 
    /*
    * Set Instanced Rendering on/off. Debugging purposes.
    */
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    void SetInstancedRendering(bool ShouldRender);
 
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    void SetComponentIndexVisibility(int32 Index, bool Visible);
 
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    void SetRenderCustomDepth(bool Enabled);
 
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    void SetWorldPositionOffsetDistance(int32 NewWPODistance);
 
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    void SetShadowCacheBehaviour(EShadowCacheInvalidationBehavior ShadowCacheInvalidationBehaviour);
 
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    void SetRenderWorldPositionOffet(bool RenderWPO);
 
    /*
    * Log renderer info to console. Debugging purposes.
    */
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    void LogInfo() const;
 
    /*
    * Toggles instanced static mesh materials between Unreal's default and their original. Debugging purposes.
    * @param SetUnrealDefaultMaterial - If true, uses the default material; if false, restores original materials.
    */
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    void DebugMaterialImpact(bool SetUnrealDefaultMaterial);
 
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    void ToggleProxyMesh();
 
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    void SpawnAllInstancesBackActors();
 
    /*
    * Spawn speficic ISM instance back to original Actor.
    */
    UFUNCTION(BlueprintCallable, Category = "Instanced Renderer")
    bool SpawnInstanceBackToActor(UInstancedStaticMeshComponent* ISM, int32 Index);
 
    static AInstancedRenderer* Get()
    {
        return Instance;
    }
 
protected:
 
    UPROPERTY(VisibleAnywhere, AdvancedDisplay, BlueprintReadWrite)
    TArray<FInstanceEntry> InstanceEntries;
 
    UPROPERTY(BlueprintReadWrite)
    TArray<UInstancedStaticMeshComponent*> InstancesStaticMeshComponents;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    int32 TotalInstanceCount = 0;
 
private:
 
    TWeakObjectPtr<UStaticMesh> ProxyMesh;
 
    static AInstancedRenderer* Instance;
 
    virtual void BeginPlay() override;
 
    virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    UFUNCTION()
    void OnGraphicsSettingsChanged(FGlobalGraphicsSettings GraphicsSettings);
 
    UFUNCTION()
    void OnWeatherParametersChanged(FWeatherParameters WeatherParameters);
 
    /*
    * Find existing InstancedStaticMeshComponents array index or create new one for the mesh and its materials
    * @return index to InstancedStaticMeshComponents array
    */
    int32 FindOrAddUniqueMesh(UStaticMeshComponent* StaticMeshComponent, AInstancedActor* InstancedActor);
 
    int32 WorldPositionOffsetDistance = 30000;
 
    FWeatherParameters CurrentWeatherParameters;
 
    bool Rendering = true;
 
    bool RenderingWPO = true;
};