AgrarsenseSettings.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 "Engine/World.h"
#include "GameFramework/GameUserSettings.h"
 
#include "GlobalSimulationSettings.h"
#include "GlobalGraphicsSettings.h"
 
#include "AgrarsenseSettings.generated.h"
 
class ASensor;
 
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FGraphicsSettingsDelegate, FGlobalGraphicsSettings, GraphicsSettings);
 
/*
 * AGRARSENSE settings class.
 */
UCLASS(BlueprintType, Blueprintable)
class AGRARSENSE_API UAgrarsenseSettings : public UGameUserSettings
{
    GENERATED_BODY()
 
public:
 
    UFUNCTION(BlueprintPure)
    static UAgrarsenseSettings* GetAgrarsenseSettings();
 
    void Setup(UWorld* World);
 
    virtual void PostInitProperties() override;
 
    void LoadSettings(bool bForceReload = false) override;
 
    void ApplySettings(bool bCheckForCommandLineOverrides) override;
 
    void SetWindowMode(EWindowMode::Type WindowType);
 
    void SetSimulationSettings(FGlobalSimulationSettings NewSettings);
 
    UFUNCTION(BlueprintCallable)
    void SetWorldRendering(bool enabled);
 
    UFUNCTION(BlueprintCallable)
    void SetQualityLevel(EQualityLevel newQualityLevel);
 
    UFUNCTION(BlueprintCallable)
    void SetQualityLevelFromString(const FString& QualityLevelString);
 
    UFUNCTION(BlueprintCallable, BlueprintPure)
    int GetGlobalTargetFrameRate() const;
 
    UFUNCTION(BlueprintCallable)
    void SetGlobalTargetFrameRate(int NewTargetFrameRate);
 
    UFUNCTION(BlueprintCallable, BlueprintPure)
    float GetGlobalTimeDilation() const;
 
    UFUNCTION(BlueprintCallable)
    void SetSpectatorMaxSpeed(float MaxSpeed);
 
    UFUNCTION(BlueprintCallable)
    void SetShowSpectatorRainAndSnowfall(bool Show);
 
    UFUNCTION(BlueprintCallable, BlueprintPure)
    float GetSpectatorMaxSpeed() const
    {
        return SimulationSettings.SpectatorMaxSpeed;
    }
 
    UFUNCTION(BlueprintCallable, BlueprintPure)
    bool GetShowSpectatorRainAndSnowfall() const
    {
        return SimulationSettings.ShowSpectatorRainAndSnowfall;
    }
 
    UFUNCTION(BlueprintCallable)
    void SetGlobalTimeDilation(float TimeDilation);
 
    UFUNCTION(BlueprintCallable)
    void PauseSimulation();
 
    UFUNCTION(BlueprintCallable)
    void UnPauseSimulation();
 
    UFUNCTION(BlueprintCallable)
    void PauseSimulationEndOfThisFrame();
 
    UFUNCTION(BlueprintCallable)
    void AdvanceFrameCount(int32 FramesToAdvance);
 
    UFUNCTION(BlueprintCallable)
    void AdvanceTime(float TimeToAdvance);
 
    UFUNCTION(BlueprintCallable)
    void ChangeMapByName(FString MapName);
 
    UFUNCTION(BlueprintCallable)
    void ChangeMapByMapPath(const FString& Path);
 
    UFUNCTION(BlueprintCallable, BlueprintPure)
    bool GetGrassVisibility() const;
 
    UFUNCTION(BlueprintCallable)
    void SetGrassVisibility(bool Visible);
 
    UFUNCTION(BlueprintCallable, BlueprintPure)
    bool GetShadowCSMCache() const;
 
    /*
     * Set Shadow CSM cache on or off (r.Shadow.CSMCaching)
     */
    UFUNCTION(BlueprintCallable)
    void SetShadowCSMCache(bool CacheShadowCSM);
 
    UFUNCTION(BlueprintCallable, BlueprintPure)
    EAntiAliasing GetAntiAliasingMethod() const;
 
    UFUNCTION(BlueprintCallable)
    void SetAntiAliasingMethod(EAntiAliasing AntiAliasingMethod);
 
    UFUNCTION(BlueprintCallable)
    void SetAntiAliasingMethodFromString(const FString& AntiAliasingMethodString);
 
    UFUNCTION(BlueprintCallable)
    void SetInstancedRenderingVisibility(bool Visible);
 
    /*
     * Set how far should World Position Offset be rendered in cm.
     * Only applies for meshes rendered by InstancedRenderer system.
     */
    UFUNCTION(BlueprintCallable)
    void SetWorldPositionOffsetRenderDistance(int32 WorldPositionOffsetDistance);
 
    /*
     * Set Nanite max pixels per edge multiplier. Default is 1.0 by the engine.
     */
    UFUNCTION(BlueprintCallable)
    void SetNaniteMaxPixelsPerEdge(float MaxPixelsPerEdge = 1.0f);
 
    /*
    * Set Shadow cache invalidation behavior option.
    * Meshes with World Position Offset (WPO) is very expensive for shadows to be recalculated,
    * for that reason default option is Rigid, meaning mesh shadows do not move when WPO (wind for example) moves a mesh.
    * Set this to Auto or Always if you want mesh shadows to move accurately.
    * Only applies to meshes rendered with InstancedRenderer system.
    * https://docs.unrealengine.com/5.3/en-US/PythonAPI/class/ShadowCacheInvalidationBehavior.html
    */
    UFUNCTION(BlueprintCallable)
    void SetShadowCacheInvalidationBehavior(EShadowCacheInvalidationBehavior Behaviour = EShadowCacheInvalidationBehavior::Rigid);
 
    UFUNCTION(BlueprintCallable)
    void SetShadowCacheInvalidationBehaviorFromString(const FString& BehaviourString);
 
    /*
     * Get how far should World Position Offset be rendered.
     */
    UFUNCTION(BlueprintCallable)
    int32 GetWorldPositionOffsetRenderDistance() const;
 
    /*
     * Get Nanite max pixels per edge multiplier.
     */
    UFUNCTION(BlueprintCallable, BlueprintPure)
    float GetNaniteMaxPixelsPerEdge() const;
 
    /*
     * Get Shadow cache invalidation behavior option.
     */
    UFUNCTION(BlueprintCallable, BlueprintPure)
    EShadowCacheInvalidationBehavior GetShadowCacheInvalidationBehavior() const;
 
    UFUNCTION(BlueprintCallable, BlueprintPure)
    bool GetStartWindowInitiallyMinimized() const;
 
    UFUNCTION(BlueprintCallable)
    void SetStartWindowInitiallyMinimized(bool Minimized);
 
    UFUNCTION(BlueprintCallable)
    void SetRenderCustomDepthPass(bool RenderCustomDepthPass);
 
    UFUNCTION(BlueprintCallable)
    void SetUseVirtualShadowMaps(bool UseVirtualShadowMaps);
 
    UFUNCTION(BlueprintCallable)
    bool GetIsUsingVirtualShadowMaps() const;
 
    UFUNCTION(BlueprintCallable)
    bool GetIsRenderingCustomDepthPass() const;
 
    UFUNCTION(BlueprintCallable)
    int32 GetNumberOfWorkerThreads() const;
 
    UFUNCTION(BlueprintCallable)
    FString GetConsoleVariableValueString(const FString& VariableName) const;
 
    UFUNCTION(BlueprintPure)
    EQualityLevel GetCurrentQualityLevel() const
    {
        return GraphicsSettings.QualityLevel;
    }
 
    UFUNCTION(BlueprintCallable)
    TArray<FString> GetMapNames() const
    {
        return MapNames;
    }
 
    UFUNCTION(BlueprintCallable)
    TArray<FString> GetMapPaths() const
    {
        return MapPaths;
    }
 
    UPROPERTY(BlueprintAssignable)
    FGraphicsSettingsDelegate OnGraphicsSettingsChanged;
 
    static bool ShouldStartWindowMinimized()
    {
        return GetAgrarsenseSettings()->SimulationSettings.StartCameraWindowsMinimized;
    }
 
    static bool IsPlayingInMainMenu()
    {
        return IsMainMenu;
    }
 
    UFUNCTION(BlueprintPure)
    static FGlobalSimulationSettings GetGlobalSimulationSettings()
    {
        return GetAgrarsenseSettings()->SimulationSettings;
    }
 
    UFUNCTION(BlueprintPure)
    static bool IsSimulationPaused()
    {
        return GetAgrarsenseSettings()->SimulationSettings.IsSimulationPaused;
    }
 
    UFUNCTION(BlueprintPure)
    static FGlobalGraphicsSettings GetGlobalGraphicsSettings()
    {
        return GetAgrarsenseSettings()->GraphicsSettings;
    }
 
    UFUNCTION(BlueprintPure)
    bool IsRaytracingSupported() const;
 
private:
 
    // Allow AAgrarsenseGameModeBase access private methods
    friend class AAgrarsenseGameModeBase;
 
    UAgrarsenseSettings();
    
    void SetGraphicsSettings(FGlobalGraphicsSettings NewSettings);
 
    bool ParseLaunchArguments();
 
    UFUNCTION()
    void OnSensorSpawned(ASensor* SensorPtr);
 
    UFUNCTION()
    void OnSensorDestroyed(ASensor* SensorPtr);
 
    void SetUltraWithRaytracingLevel();
 
    void EnableRaytracing();
 
    void DisableRaytracing();
 
    void SetUltraQualityLevel();
 
    void SetBalancedQualityLevel();
 
    void SetLowQualityLevel();
 
    int NumberOfPostProcessingSensors = 0;
 
    bool RenderCustomDepth = false;
 
    UPROPERTY()
    TWeakObjectPtr<UWorld> CurrentWorld = nullptr;
 
    UPROPERTY(config)
    FGlobalSimulationSettings SimulationSettings;
 
    UPROPERTY(config)
    FGlobalGraphicsSettings GraphicsSettings;
 
    // For AdvanceFrameCount
    FDelegateHandle AdvanceFramesHandle;
    int32 FrameCount = 0;
 
    // For PauseSimulationEndOfThisFrame
    FDelegateHandle EndOfFrameHandle;
    
    // Hardcoded map names and paths
    // These should also be included in DefaultGame.ini file,
    // otherwise maps are not included in packaged build.
    // Keep these arrays in sync!
 
    // Map names, intentionally lower case
    const TArray<FString> MapNames =
    {
        "mainmenu",
        "rovaniemiforest",
        "vindeln",
        "sensorshowcase",
        "playground"
    };
 
    // Maps relative paths
    const TArray<FString> MapPaths =
    {
        "/Game/Agrarsense/Maps/MainMenu",
        "/Game/Agrarsense/Maps/RovaniemiForest/RovaniemiForest",
        "/Game/Agrarsense/Maps/Vindeln/Vindeln",
        "/Game/Agrarsense/Maps/SensorShowCase/SensorShowCase",
        "/Game/Agrarsense/Maps/Playground"
    };
 
    static bool IsMainMenu;
    static FString CurrentMapName;
};