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, BlueprintReadOnly)
    UInstancedStaticMeshComponent* InstancedStaticMeshComponent;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    TArray<FInstancedActorData> ActorData;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    TWeakObjectPtr<UStaticMesh> Mesh;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    TArray<UMaterialInterface*> Materials;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    FString MeshName;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    int32 InstanceEntryIndex = 0;
 
    UPROPERTY(VisibleAnywhere, BlueprintReadOnly)
    bool AllowWorldPositionOffsetDisable = 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
    */
    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);
 
    void AddOrRemoveActorFromAutomaticTransformUpdates(bool Add, AInstancedActor* InstancedActor);
 
    /*
    * 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);
 
private:
 
    static AInstancedRenderer* Instance;
 
    void BeginPlay() override;
 
    void Tick(float DeltaTime) override;
 
    void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
 
    UFUNCTION()
    void OnGraphicsSettingsChanged(FGlobalGraphicsSettings GraphicsSettings);
 
    UFUNCTION()
    void OnWeatherParametersChanged(FWeatherParameters WeatherParameters);
 
    bool AreTransformsEqual(const FTransform& TransformA, const FTransform& TransformB) const;
 
    /*
    * Update all AInstancedActors that have UpdateTransformAutomatically set to true 
    */
    void UpdateInstancedActors();
 
    /*
    * 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);
 
    UPROPERTY(VisibleAnywhere)
    TArray<FInstanceEntry> InstanceEntries;
 
    int32 WorldPositionOffsetDistance = 30000;
 
    std::vector<FInstancedActorData> InstancedActorsToUpdate;
 
    FWeatherParameters CurrentWeatherParameters;
 
    int32 TotalInstanceCount;
 
    bool Rendering = true;
 
    bool RenderingWPO = true;
};