AgrarsenseSettings.cpp

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>.
 
#include "AgrarsenseSettings.h"
 
#include "Agrarsense/InstancedRendering/InstancedRenderer.h"
#include "Agrarsense/Game/AgrarsenseGameModeBase.h"
#include "Agrarsense/Logging/SimulatorLog.h"
#include "Agrarsense/Game/AgrarsenseStatics.h"
#include "Agrarsense/Utils/EnumUtilities.h"
#include "Agrarsense/Sensor/SensorManager.h"
#include "Agrarsense/Sensor/Sensor.h"
#include "Agrarsense/Spectator/Spectator.h"
 
#include "Misc/CommandLine.h"
#include "GenericPlatform/GenericPlatformMisc.h"
#include "Kismet/GameplayStatics.h"
#include "GameFramework/GameUserSettings.h"
#include "Misc/CoreDelegates.h"
#include "Misc/Parse.h"
#include "Misc/App.h"
#include "Engine/Engine.h"
#include "Engine/GameViewportClient.h"
#include "UObject/ObjectPtr.h"
#include "LandscapeSubsystem.h"
#include "Engine/World.h"
#include "Engine/GameInstance.h"
#include "TimerManager.h"
 
#include "RHI.h"
#include "RHIDefinitions.h"
 
bool UAgrarsenseSettings::IsMainMenu = false;
FString UAgrarsenseSettings::CurrentMapName;
 
UAgrarsenseSettings::UAgrarsenseSettings()
{
}
 
void UAgrarsenseSettings::Setup(UWorld* World)
{
#if WITH_EDITOR
    // In case the simulator was shutdown when it was paused, 
    // reset this static variable
    SimulationSettings.IsSimulationPaused = false;
#endif
    
    CurrentWorld = World;
 
    UWorld* GameWorld = CurrentWorld.Get();
 
    CurrentMapName = GameWorld->GetMapName().ToLower();
    IsMainMenu = CurrentMapName.Contains("mainmenu");
 
    if (GameWorld)
    {
        // Prioritize grass creation
        // This allows turning grass on faster if it was turned off.
        ULandscapeSubsystem* LandscapeSubsystem = CurrentWorld->GetSubsystem<ULandscapeSubsystem>();
        if (LandscapeSubsystem)
        {
            LandscapeSubsystem->PrioritizeGrassCreation(true);
        }
    }
 
    // Apply Graphics and Simulation settings when Simulator is started
    ApplySettings(true);
 
    // Apply few console commands. One time setup.
    if (GEngine && World) 
    {
        GEngine->Exec(World, TEXT("g.TimeoutForBlockOnRenderFence 600000"));
        GEngine->Exec(World, TEXT("r.Streaming.PoolSize 0"));
        GEngine->Exec(World, TEXT("r.CustomDepth 0"));
 
        // Disable application starting to throttle performance if Window loses focus
        GEngine->Exec(World, TEXT("t.IdleWhenNotForeground 0"));
    }
 
    USensorManager* Manager = USensorManager::Get();
    if (Manager)
    {
        Manager->OnSensorSpawned.AddUniqueDynamic(this, &UAgrarsenseSettings::OnSensorSpawned);
        Manager->OnSensorDestroyed.AddUniqueDynamic(this, &UAgrarsenseSettings::OnSensorDestroyed);
    }
    else
    {
        // Else failed to get SensorManager and listen Sensor spawning, always render custom depth
        RenderCustomDepth = true;
    }
 
#if UE_BUILD_SHIPPING
    // In Shipping mode check for Fullscreen and WindowedFullscreen launch args,
    // Otherwise set window to windowed by default.
    if (FParse::Param(FCommandLine::Get(), TEXT("Fullscreen")))
    {
        SetWindowMode(EWindowMode::Type::Fullscreen);
    }
    else if (FParse::Param(FCommandLine::Get(), TEXT("WindowedFullscreen")))
    {
        SetWindowMode(EWindowMode::Type::WindowedFullscreen);
    }
    else
    {
        SetWindowMode(EWindowMode::Type::Windowed);
    }
#endif
}
 
void UAgrarsenseSettings::PostInitProperties()
{
    Super::PostInitProperties();
 
#if UE_BUILD_SHIPPING || UE_BUILD_DEVELOPMENT
    if (ParseLaunchArguments())
    {
        SaveConfig();
    }
#endif
}
 
UAgrarsenseSettings* UAgrarsenseSettings::GetAgrarsenseSettings()
{
    return Cast<UAgrarsenseSettings>(UGameUserSettings::GetGameUserSettings());
}
 
void UAgrarsenseSettings::LoadSettings(bool bForceReload)
{
    Super::LoadSettings(bForceReload);
}
 
void UAgrarsenseSettings::ApplySettings(bool bCheckForCommandLineOverrides)
{
    Super::ApplySettings(bCheckForCommandLineOverrides);
 
    SetGraphicsSettings(GraphicsSettings);
    SetSimulationSettings(SimulationSettings);
}
 
bool UAgrarsenseSettings::ParseLaunchArguments()
{
    bool SettingsWereChanged = false;
 
    // Check -map= launch argument
    FString AntiAliasingString;
    if (FParse::Value(FCommandLine::Get(), TEXT("-antialiasing="), AntiAliasingString))
    {
        // Convert incoming string to int and then EAntiAliasing enum
        int32 AntiAliasingInt;
        if (AntiAliasingString.IsNumeric())
        {
            AntiAliasingInt = FCString::Atoi(*AntiAliasingString);
            EAntiAliasing NewAntiAliasingMethod = static_cast<EAntiAliasing>(AntiAliasingInt);
            GraphicsSettings.AntiAliasingMethod = NewAntiAliasingMethod;
            SettingsWereChanged = true;
        }
    }
 
    // Check -no-world-rendering launch argument
    if (FParse::Param(FCommandLine::Get(), TEXT("-no-spectator-rendering")))
    {
        GraphicsSettings.DisableSpectatorRendering = true;
        SettingsWereChanged = true;
    }
 
    // Check -start-camerawindows-minimized launch argument
    if (FParse::Param(FCommandLine::Get(), TEXT("-start-camerawindows-minimized")))
    {
        SimulationSettings.StartCameraWindowsMinimized = true;
        SettingsWereChanged = true;
    }
 
    // Check -quality-level= launch argument
    FString QualityLevelString;
    if (FParse::Value(FCommandLine::Get(), TEXT("-quality-level="), QualityLevelString))
    {
        GraphicsSettings.QualityLevel = UEnumUtilities::ConvertStringToQualityLevel(QualityLevelString);
        SettingsWereChanged = true;
    }
 
    return SettingsWereChanged;
}
 
int32 UAgrarsenseSettings::GetNumberOfWorkerThreads() const
{
    return FPlatformMisc::NumberOfWorkerThreadsToSpawn();
}
 
FString UAgrarsenseSettings::GetConsoleVariableValueString(const FString& VariableName) const
{
    IConsoleVariable* ConsoleVariable = IConsoleManager::Get().FindConsoleVariable(*VariableName);
    if (ConsoleVariable)
    {
        FString VariableValue = ConsoleVariable->GetString();
        return VariableValue;
    }
    else
    {
        return FString();
    }
}
 
void UAgrarsenseSettings::SetGraphicsSettings(FGlobalGraphicsSettings NewSettings)
{
    GraphicsSettings = NewSettings;
 
    SetWorldRendering(!GraphicsSettings.DisableSpectatorRendering);
    SetQualityLevel(GraphicsSettings.QualityLevel);
    SetAntiAliasingMethod(GraphicsSettings.AntiAliasingMethod);
    SetGrassVisibility(GraphicsSettings.RenderGrass);
    SetShadowCSMCache(GraphicsSettings.ShadowCSMCaching);
    SetUseVirtualShadowMaps(GraphicsSettings.UseVirtualShadowMaps);
}
 
void UAgrarsenseSettings::SetWindowMode(EWindowMode::Type WindowType)
{
    if (GEngine)
    {
        UGameUserSettings* UserSettings = GEngine->GetGameUserSettings();
        if (UserSettings)
        {
            UserSettings->SetFullscreenMode(WindowType);
            UserSettings->ApplySettings(false);
        }
    }
}
 
void UAgrarsenseSettings::SetSimulationSettings(FGlobalSimulationSettings NewSettings)
{
    SimulationSettings = NewSettings;
 
    SetStartWindowInitiallyMinimized(SimulationSettings.StartCameraWindowsMinimized);
    SetGlobalTimeDilation(SimulationSettings.TimeDilation);
    SetSpectatorMaxSpeed(SimulationSettings.SpectatorMaxSpeed);
    SetShowSpectatorRainAndSnowfall(SimulationSettings.ShowSpectatorRainAndSnowfall);
}
 
bool UAgrarsenseSettings::GetGrassVisibility() const
{
    return GraphicsSettings.RenderGrass;
}
 
void UAgrarsenseSettings::SetGrassVisibility(bool Visible)
{
    if (GraphicsSettings.RenderGrass == Visible) 
    {
        return;
    }
 
    UWorld* World = CurrentWorld.Get();
 
    if (!GEngine || !World)
    {
        return;
    }
 
    GraphicsSettings.RenderGrass = Visible;
 
    if (!GraphicsSettings.RenderGrass)
    {
        GEngine->Exec(World, TEXT("grass.enable 0"));
        GEngine->Exec(World, TEXT("grass.FlushCache"));
    }
    else
    {
        GEngine->Exec(World, TEXT("grass.enable 1"));
    }
 
    OnGraphicsSettingsChanged.Broadcast(GraphicsSettings);
}
 
bool UAgrarsenseSettings::GetShadowCSMCache() const
{
    return GraphicsSettings.ShadowCSMCaching;
}
 
void UAgrarsenseSettings::SetShadowCSMCache(bool CacheShadowCSM)
{
    if (GraphicsSettings.ShadowCSMCaching == CacheShadowCSM)
    {
        return;
    }
 
    UWorld* World = CurrentWorld.Get();
    if (GEngine && World)
    {
        GraphicsSettings.ShadowCSMCaching = CacheShadowCSM;
 
        if (GraphicsSettings.ShadowCSMCaching)
        {
            GEngine->Exec(World, TEXT("r.Shadow.CSMCaching 1"));
        }
        else
        {
            GEngine->Exec(World, TEXT("r.Shadow.CSMCaching 0"));
        }
 
        OnGraphicsSettingsChanged.Broadcast(GraphicsSettings);
    }
}
 
void UAgrarsenseSettings::SetInstancedRenderingVisibility(bool Visible)
{
    UWorld* World = CurrentWorld.Get();
 
    if (World)
    {
        AInstancedRenderer* InstanceRenderer = UAgrarsenseStatics::GetInstancedRenderer(World);
        if (InstanceRenderer)
        {
            InstanceRenderer->SetInstancedRendering(Visible);
        }
    }
}
 
void UAgrarsenseSettings::SetWorldPositionOffsetRenderDistance(int32 WorldPositionOffsetDistance)
{
    GraphicsSettings.WorldPositionOffsetDistance = WorldPositionOffsetDistance;
    OnGraphicsSettingsChanged.Broadcast(GraphicsSettings);
}
 
void UAgrarsenseSettings::SetNaniteMaxPixelsPerEdge(float MaxPixelsPerEdge)
{
    UWorld* World = CurrentWorld.Get();
    if (GEngine && World)
    {
        MaxPixelsPerEdge = FMath::Clamp(MaxPixelsPerEdge, 0.1f, 10.0f);
 
        FString Command = FString::Printf(TEXT("r.Nanite.MaxPixelsPerEdge %f"), MaxPixelsPerEdge);
        GEngine->Exec(World, *Command);
 
        GraphicsSettings.NaniteMaxPixelsPerEdge = MaxPixelsPerEdge;
        OnGraphicsSettingsChanged.Broadcast(GraphicsSettings);
    }
}
 
void UAgrarsenseSettings::SetShadowCacheInvalidationBehavior(EShadowCacheInvalidationBehavior Behaviour)
{
    if (GraphicsSettings.FoliageShadowCacheInvalidationBehaviour != Behaviour)
    {
        GraphicsSettings.FoliageShadowCacheInvalidationBehaviour = Behaviour;
        OnGraphicsSettingsChanged.Broadcast(GraphicsSettings);
    }
}
 
void UAgrarsenseSettings::SetShadowCacheInvalidationBehaviorFromString(const FString& BehaviourString)
{
    FString BehaviourStringToLower = BehaviourString.ToLower();
 
    if (BehaviourStringToLower == "auto")
    {
        SetShadowCacheInvalidationBehavior(EShadowCacheInvalidationBehavior::Auto);
    }
    else if (BehaviourStringToLower == "rigid")
    {
        SetShadowCacheInvalidationBehavior(EShadowCacheInvalidationBehavior::Rigid);
    }
    else if (BehaviourStringToLower == "always")
    {
        SetShadowCacheInvalidationBehavior(EShadowCacheInvalidationBehavior::Always);
    }
    else if (BehaviourStringToLower == "static")
    {
        SetShadowCacheInvalidationBehavior(EShadowCacheInvalidationBehavior::Static);
    }
}
 
int32 UAgrarsenseSettings::GetWorldPositionOffsetRenderDistance() const
{
    return GraphicsSettings.WorldPositionOffsetDistance;
}
 
float UAgrarsenseSettings::GetNaniteMaxPixelsPerEdge() const
{
    return GraphicsSettings.NaniteMaxPixelsPerEdge;
}
 
EShadowCacheInvalidationBehavior UAgrarsenseSettings::GetShadowCacheInvalidationBehavior() const
{
    return GraphicsSettings.FoliageShadowCacheInvalidationBehaviour;
}
 
bool UAgrarsenseSettings::GetStartWindowInitiallyMinimized() const
{
    return SimulationSettings.StartCameraWindowsMinimized;
}
 
void UAgrarsenseSettings::SetStartWindowInitiallyMinimized(bool Minimized)
{
    SimulationSettings.StartCameraWindowsMinimized = Minimized;
}
 
void UAgrarsenseSettings::SetRenderCustomDepthPass(bool RenderCustomDepthPass)
{
    UWorld* World = CurrentWorld.Get();
    if (GEngine || World)
    {
        RenderCustomDepth = RenderCustomDepthPass;
        if (RenderCustomDepthPass)
        {
            GEngine->Exec(World, TEXT("r.CustomDepth 3"));
        }
        else
        {
            GEngine->Exec(World, TEXT("r.CustomDepth 0"));
        }
    }
}
 
void UAgrarsenseSettings::SetUseVirtualShadowMaps(bool UseVirtualShadowMaps)
{
    UWorld* World = CurrentWorld.Get();
    if (GEngine || World)
    {
        GraphicsSettings.UseVirtualShadowMaps = UseVirtualShadowMaps;
 
        if (GraphicsSettings.UseVirtualShadowMaps)
        {
            GEngine->Exec(World, TEXT("r.Shadow.Virtual.Enable 1"));
        }
        else
        {
            GEngine->Exec(World, TEXT("r.Shadow.Virtual.Enable 0"));
        }
 
        OnGraphicsSettingsChanged.Broadcast(GraphicsSettings);
    }
}
 
bool UAgrarsenseSettings::GetIsUsingVirtualShadowMaps() const
{
    return GraphicsSettings.UseVirtualShadowMaps;
}
 
bool UAgrarsenseSettings::GetIsRenderingCustomDepthPass() const
{
    return RenderCustomDepth;
}
 
EAntiAliasing UAgrarsenseSettings::GetAntiAliasingMethod() const
{
    return GraphicsSettings.AntiAliasingMethod;
}
 
void UAgrarsenseSettings::SetAntiAliasingMethod(EAntiAliasing AntiAliasingMethod)
{
 
    UWorld* World = CurrentWorld.Get();
 
    if (!GEngine || !World)
    {
        return;
    }
 
    GraphicsSettings.AntiAliasingMethod = AntiAliasingMethod;
 
    FString ExecCommand;
    switch (AntiAliasingMethod)
    {
        case EAntiAliasing::NONE:
            ExecCommand = TEXT("r.AntiAliasingMethod 0");
            break;
 
        case EAntiAliasing::FXAA:
            ExecCommand = TEXT("r.AntiAliasingMethod 1");
            break;
 
        case EAntiAliasing::TAA:
            ExecCommand = TEXT("r.AntiAliasingMethod 2");
            break;
 
            // MSAA ("r.AntiAliasingMethod 3) is not supported on Deferred rendering
 
        case EAntiAliasing::TSR:
            ExecCommand = TEXT("r.AntiAliasingMethod 4");
            break;
 
        default:
            return;
    }
 
    GEngine->Exec(World, *ExecCommand);
 
    OnGraphicsSettingsChanged.Broadcast(GraphicsSettings);
}
 
void UAgrarsenseSettings::SetAntiAliasingMethodFromString(const FString& AntiAliasingMethodString)
{
    EAntiAliasing NewMethod = UEnumUtilities::ConvertStringToAntiAliasingMethod(AntiAliasingMethodString);
    SetAntiAliasingMethod(NewMethod);
}
 
void UAgrarsenseSettings::SetWorldRendering(bool enabled)
{
    if (GEngine && GEngine->GameViewport)
    {
        GEngine->GameViewport->bDisableWorldRendering = !enabled;
        GraphicsSettings.DisableSpectatorRendering = !enabled;
 
        FString msg = FString::Printf(TEXT("World rendering: %s"), enabled ? TEXT("On") : TEXT("Off"));
        SimulatorLog::Log(msg);
 
        OnGraphicsSettingsChanged.Broadcast(GraphicsSettings);
    }
}
 
void UAgrarsenseSettings::SetQualityLevel(EQualityLevel newQualityLevel)
{
    GraphicsSettings.QualityLevel = newQualityLevel;
 
    switch (GraphicsSettings.QualityLevel)
    {
    case EQualityLevel::UltraRaytracing:
        SetUltraWithRaytracingLevel();
        break;
 
    case EQualityLevel::Ultra:
        SetUltraQualityLevel();
        break;
 
    case EQualityLevel::Balanced:
        SetBalancedQualityLevel();
        break;
 
    case EQualityLevel::Low:
        SetLowQualityLevel();
        break;
    }
 
    FString QualityLevelString = UEnumUtilities::ConvertQualityLevelToString(GraphicsSettings.QualityLevel);
    FString Msg = FString::Printf(TEXT("Graphics settings: %s"), *QualityLevelString);
    SimulatorLog::Log(Msg);
 
    OnGraphicsSettingsChanged.Broadcast(GraphicsSettings);
}
 
void UAgrarsenseSettings::SetQualityLevelFromString(const FString& QualityLevelString)
{
    SetQualityLevel(UEnumUtilities::ConvertStringToQualityLevel(QualityLevelString));
}
 
int UAgrarsenseSettings::GetGlobalTargetFrameRate() const
{
    return GetFrameRateLimit();
}
 
void UAgrarsenseSettings::SetGlobalTargetFrameRate(int NewTargetFrameRate)
{
    SetFrameRateLimit(NewTargetFrameRate);
    ApplySettings(false);
}
 
float UAgrarsenseSettings::GetGlobalTimeDilation() const
{
    UWorld* World = CurrentWorld.Get();
 
    if (!World)
    {
        return SimulationSettings.TimeDilation;
    }
 
    return UGameplayStatics::GetGlobalTimeDilation(World);
}
 
void UAgrarsenseSettings::SetGlobalTimeDilation(float TimeDilation)
{
    UWorld* World = CurrentWorld.Get();
    if (!World)
    {
        return;
    }
 
    SimulationSettings.TimeDilation = TimeDilation;
    UGameplayStatics::SetGlobalTimeDilation(World, TimeDilation);
 
    FString msg = FString::Printf(TEXT("Global time dilation: %f"), TimeDilation);
    SimulatorLog::Log(msg);
}
 
void UAgrarsenseSettings::SetSpectatorMaxSpeed(float MaxSpeed)
{
    UWorld* World = CurrentWorld.Get();
    if (!World)
    {
        return;
    }
 
    ASpectator* Spectator = UAgrarsenseStatics::GetSpectator(World);
    if (IsValid(Spectator))
    {
        Spectator->SetMaxSpeed(MaxSpeed);
        SimulationSettings.SpectatorMaxSpeed = Spectator->GetMaxSpeed();
    }
}
 
void UAgrarsenseSettings::SetShowSpectatorRainAndSnowfall(bool Show)
{
    UWorld* World = CurrentWorld.Get();
    if (!World)
    {
        return;
    }
 
    ASpectator* Spectator = UAgrarsenseStatics::GetSpectator(World);
 
    if (IsValid(Spectator))
    {
        Spectator->SetNiagaraComponentVisibility(Show);
        SimulationSettings.ShowSpectatorRainAndSnowfall = Spectator->IsNiagaraComponentVisible();
    }
}
 
void UAgrarsenseSettings::PauseSimulation()
{
    UWorld* World = CurrentWorld.Get();
    if (World && !SimulationSettings.IsSimulationPaused)
    {
        UGameplayStatics::SetGlobalTimeDilation(World, 0.0f);
        UGameplayStatics::SetGamePaused(World, true);
        SimulationSettings.IsSimulationPaused = true;
        
        SimulatorLog::Log("Simulator paused");
    }
}
 
void UAgrarsenseSettings::UnPauseSimulation()
{
    UWorld* World = CurrentWorld.Get();
    if (World && SimulationSettings.IsSimulationPaused)
    {
        UGameplayStatics::SetGlobalTimeDilation(World, SimulationSettings.TimeDilation);
        UGameplayStatics::SetGamePaused(World, false);
        SimulationSettings.IsSimulationPaused = false;
 
        SimulatorLog::Log("Simulator unpaused");
    }
}
 
void UAgrarsenseSettings::PauseSimulationEndOfThisFrame()
{
    if (SimulationSettings.IsSimulationPaused)
    {
        return;
    }
 
    // Subscribe to Unreal Engine end of frame callback
    EndOfFrameHandle = FCoreDelegates::OnEndFrame.AddLambda([this]()
        {
            // After receiving the event, unsubcribe from the event and pause the simulation.
            if (IsValid(this))
            {
                if (EndOfFrameHandle.IsValid())
                {
                    FCoreDelegates::OnEndFrame.Remove(EndOfFrameHandle);
                    EndOfFrameHandle.Reset();
                }
 
                PauseSimulation();
            }
        });
}
 
void UAgrarsenseSettings::AdvanceFrameCount(int32 FramesToAdvance)
{
    if (FramesToAdvance == 0)
    {
        return;
    }
 
    if (AdvanceFramesHandle.IsValid())
    {
        // Already running this, return
        return;
    }
 
    if (EndOfFrameHandle.IsValid())
    {
        // If PauseSimulationEndOfThisFrame was called, unsubribe
        FCoreDelegates::OnEndFrame.Remove(EndOfFrameHandle);
        EndOfFrameHandle.Reset();
    }
 
    // Unpause simulation now
    UnPauseSimulation();
 
    FrameCount = 0;
 
    // Subscribe to Unreal Engine end of frame callback
    AdvanceFramesHandle = FCoreDelegates::OnEndFrame.AddLambda([this, FramesToAdvance]()
        {
            ++FrameCount;
            if (FrameCount == FramesToAdvance)
            {
                // After given number of frames, 
                // unsubscribe from the event and pause simulation again at the end of that frame
                if (IsValid(this))
                {
                    FCoreDelegates::OnEndFrame.Remove(AdvanceFramesHandle);
                    AdvanceFramesHandle.Reset();
                    FrameCount = 0;
 
                    PauseSimulationEndOfThisFrame();
                }
            }
        });
}
 
void UAgrarsenseSettings::AdvanceTime(float TimeToAdvance)
{
    UWorld* World = CurrentWorld.Get();
    if (!World)
    {
        return;
    }
 
    // Unpause simulation now
    UnPauseSimulation();
 
    // Pause simulation again after TimeToAdvance
    FTimerHandle AdvanceTimeTimer;
    World->GetTimerManager().SetTimer(AdvanceTimeTimer, FTimerDelegate::CreateLambda([this]
    {
        if (IsValid(this))
        {
            PauseSimulationEndOfThisFrame();
        }
 
    }), TimeToAdvance, false);
}
 
void UAgrarsenseSettings::ChangeMapByName(FString MapName)
{
    // Make the map name to lower
    // This is because ROSCommands.cpp uses this and all the messages are in lower case.
    MapName = MapName.ToLower();
 
    bool FoundMap = false;
    for (int32 i = 0; i < MapNames.Num(); i++)
    {
        if (MapName == MapNames[i])
        {
            FoundMap = true;
            FString msg = FString::Printf(TEXT("Changing map to: %s"), *MapName);
            SimulatorLog::Log(msg);
 
            ChangeMapByMapPath(MapPaths[i]);
            break;
        }
    }
 
    if (!FoundMap)
    {
        FString msg = FString::Printf(TEXT("Couldn't find map: %s"), *MapName);
        SimulatorLog::Log(msg);
    }
}
 
void UAgrarsenseSettings::ChangeMapByMapPath(const FString& Path)
{
    UWorld* World = CurrentWorld.Get();
    if (World)
    {
        UGameplayStatics::OpenLevel(World, *Path, TRAVEL_Absolute);
    }
}
 
void UAgrarsenseSettings::OnSensorSpawned(ASensor* SensorPtr)
{
    if (!SensorPtr)
    {
        return;
    }
 
    ESensorTypes type = SensorPtr->GetSensorType();
    if (type == ESensorTypes::SemanticSegmentationCamera || type == ESensorTypes::ThermalCamera)
    {
        // If the the sensor uses CustomDepthPass to color objects, enable custom depth pass
        ++NumberOfPostProcessingSensors;
        SetRenderCustomDepthPass(true);
    }
}
 
void UAgrarsenseSettings::OnSensorDestroyed(ASensor* SensorPtr)
{
    if (!SensorPtr)
    {
        return;
    }
 
    ESensorTypes type = SensorPtr->GetSensorType();
    if (type == ESensorTypes::SemanticSegmentationCamera || type == ESensorTypes::ThermalCamera)
    {
        --NumberOfPostProcessingSensors;
        if (NumberOfPostProcessingSensors == 0)
        {
            // If there's no more sensors that need CustomDepthPass to work, 
            // disable it to save rendering performance
            SetRenderCustomDepthPass(false);
        }
    }
}
 
void UAgrarsenseSettings::SetUltraWithRaytracingLevel()
{
    if (IsRaytracingSupported())
    {
        SetUltraQualityLevel();
        EnableRaytracing();
    }
    else
    {
        SimulatorLog::Log("Graphics settings: Ray tracing not supported on this hardware.");
    }
}
 
bool UAgrarsenseSettings::IsRaytracingSupported() const
{
    bool RayTracingSupported = false;
 
    // Check if the hardware supports ray tracing
    IConsoleVariable* CVar = IConsoleManager::Get().FindConsoleVariable(TEXT("r.RayTracing"));
    if (CVar && CVar->GetInt() > 0 && GRHISupportsRayTracing)
    {
        RayTracingSupported = true;
    }
 
    return RayTracingSupported;
}
 
void UAgrarsenseSettings::EnableRaytracing()
{
    UWorld* World = CurrentWorld.Get();
    if (!World || !GEngine)
    {
        return;
    }
 
    GEngine->Exec(World, TEXT("r.RayTracing 1"));
    GEngine->Exec(World, TEXT("r.Lumen.HardwareRayTracing 1"));                         // Enable lumen raytracing
    GEngine->Exec(World, TEXT("r.RayTracing.Geometry 1"));                              // Enable ray tracing geometry
    GEngine->Exec(World, TEXT("r.RayTracing.Reflections 1"));                           // Enable ray tracing reflections
    GEngine->Exec(World, TEXT("r.RayTracing.AmbientOcclusion 1"));                      // Enable ray tracing ambient occlusion
    GEngine->Exec(World, TEXT("r.RayTracing.GlobalIllumination 1"));                    // Enable ray tracing global illumination
    GEngine->Exec(World, TEXT("r.RayTracing.Translucency 1"));                          // Enable ray tracing translucency
    GEngine->Exec(World, TEXT("r.RayTracing.SkyLight 1"));                              // Enable ray tracing sky light
 
    // Couldn't get Nanite trees with WPO to work with Raytracing
    //GEngine->Exec(World, TEXT("r.RayTracing.Shadows 1"));                             // Enable ray tracing shadows
    //GEngine->Exec(World, TEXT("r.RayTracing.Shadows.SoftShadows 1"));
    //GEngine->Exec(World, TEXT("r.RayTracing.Shadows.SamplesPerPixel 4"));
 
    GEngine->Exec(World, TEXT("r.RayTracing.Reflections.MaxRoughness 1.0"));            // Enable reflections on all surfaces
    GEngine->Exec(World, TEXT("r.RayTracing.Reflections.Shadows 1"));                   // Enable ray-traced shadows in reflections
    GEngine->Exec(World, TEXT("r.RayTracing.Reflections.SortTiles 1"));                 // Optimized tile sorting for performance
    GEngine->Exec(World, TEXT("r.RayTracing.GlobalIllumination.Quality 4"));            // Increase RT GI quality (0-4)
    GEngine->Exec(World, TEXT("r.RayTracing.GlobalIllumination.SamplesPerPixel 4"));    // Improve GI smoothness
    
    GEngine->Exec(World, TEXT("r.Lumen.Reflections 1"));                                // Enable Lumen reflections
    GEngine->Exec(World, TEXT("r.Lumen.ScreenProbeGather.ScreenTraces 1"));             // Improve Lumen probe accuracy
 
    GEngine->Exec(World, TEXT("r.RayTracing.Denoiser 1"));                              // Enable denoiser
    GEngine->Exec(World, TEXT("r.RayTracing.Denoiser.TemporalAccumulation 1"));         // Temporal stability
    GEngine->Exec(World, TEXT("r.RayTracing.Denoiser.ReuseRadiance 1"));                // Improves light reuse
}
 
void UAgrarsenseSettings::DisableRaytracing()
{
    UWorld* World = CurrentWorld.Get();
    if (!World || !GEngine)
    {
        return;
    }
 
    GEngine->Exec(World, TEXT("r.RayTracing 0"));
    GEngine->Exec(World, TEXT("r.RayTracing.Denoiser 0"));
    GEngine->Exec(World, TEXT("r.Lumen.HardwareRayTracing 0"));
    GEngine->Exec(World, TEXT("r.RayTracing.Geometry 0"));
    GEngine->Exec(World, TEXT("r.RayTracing.Reflections 0"));
    GEngine->Exec(World, TEXT("r.RayTracing.AmbientOcclusion 0"));
    GEngine->Exec(World, TEXT("r.RayTracing.GlobalIllumination 0"));
    GEngine->Exec(World, TEXT("r.RayTracing.Translucency 0"));
    GEngine->Exec(World, TEXT("r.RayTracing.SkyLight 0"));
    GEngine->Exec(World, TEXT("r.RayTracing.Shadows 0"));
}
 
void UAgrarsenseSettings::SetUltraQualityLevel()
{
    UWorld* World = CurrentWorld.Get();
    if (!World || !GEngine)
    {
        return;
    }
 
    DisableRaytracing();
 
    // https://dev.epicgames.com/documentation/en-us/unreal-engine/scalability-reference-for-unreal-engine?application_version=5.3
    GEngine->Exec(World, TEXT("sg.PostProcessQuality 3"));
    GEngine->Exec(World, TEXT("sg.ShadowQuality 3"));
    GEngine->Exec(World, TEXT("sg.TextureQuality 4"));
    GEngine->Exec(World, TEXT("sg.EffectsQuality 4"));
    GEngine->Exec(World, TEXT("sg.FoliageQuality 4"));
 
    GEngine->Exec(World, TEXT("r.MinScreenRadiusForLights 0.03"));
    GEngine->Exec(World, TEXT("r.SeparateTranslucency 1"));
    GEngine->Exec(World, TEXT("r.DepthOfFieldQuality 2"));
    GEngine->Exec(World, TEXT("r.TranslucencyVolumeBlur 1"));
    GEngine->Exec(World, TEXT("r.TranslucencyLightingVolumeDim 64"));
    GEngine->Exec(World, TEXT("r.MaxAnisotropy 8"));
    GEngine->Exec(World, TEXT("r.LensFlareQuality 2"));
    GEngine->Exec(World, TEXT("r.SceneColorFringeQuality 1"));
    GEngine->Exec(World, TEXT("r.FastBlurThreshold 7"));
    GEngine->Exec(World, TEXT("r.EarlyZPassMovable 1"));
    GEngine->Exec(World, TEXT("r.ShadowQuality 5"));
    GEngine->Exec(World, TEXT("r.TranslucentLightingVolume 1"));
    GEngine->Exec(World, TEXT("r.LightShaftDownSampleFactor 2"));
    GEngine->Exec(World, TEXT("r.DetailMode 2"));
    GEngine->Exec(World, TEXT("foliage.DensityScale 1"));
    GEngine->Exec(World, TEXT("grass.DensityScale 1"));
    GEngine->Exec(World, TEXT("r.Streaming.PoolSize 0 "));
    GEngine->Exec(World, TEXT("r.Shadow.RadiusThreshold 0.00"));
 
    SetShadowCacheInvalidationBehavior(EShadowCacheInvalidationBehavior::Auto);
}
 
void UAgrarsenseSettings::SetBalancedQualityLevel()
{
    UWorld* World = CurrentWorld.Get();
    if (!World || !GEngine)
    {
        return;
    }
 
    DisableRaytracing();
 
    GEngine->Exec(World, TEXT("sg.PostProcessQuality 3"));
    GEngine->Exec(World, TEXT("sg.TextureQuality 3"));
    GEngine->Exec(World, TEXT("sg.EffectsQuality 3"));
    GEngine->Exec(World, TEXT("sg.FoliageQuality 3"));
 
    GEngine->Exec(World, TEXT("r.MinScreenRadiusForLights 0.03"));
    GEngine->Exec(World, TEXT("r.SeparateTranslucency 1"));
    GEngine->Exec(World, TEXT("r.DepthOfFieldQuality 2"));
    GEngine->Exec(World, TEXT("r.TranslucencyVolumeBlur 1"));
    GEngine->Exec(World, TEXT("r.TranslucencyLightingVolumeDim 64"));
    GEngine->Exec(World, TEXT("r.MaxAnisotropy 8"));
    GEngine->Exec(World, TEXT("r.LensFlareQuality 2"));
    GEngine->Exec(World, TEXT("r.SceneColorFringeQuality 1"));
    GEngine->Exec(World, TEXT("r.FastBlurThreshold 7"));
    GEngine->Exec(World, TEXT("r.EarlyZPassMovable 1"));
    GEngine->Exec(World, TEXT("r.ShadowQuality 3"));
    GEngine->Exec(World, TEXT("r.TranslucentLightingVolume 1"));
    GEngine->Exec(World, TEXT("r.LightShaftDownSampleFactor 2"));
    GEngine->Exec(World, TEXT("r.DetailMode 2"));
    GEngine->Exec(World, TEXT("r.BloomQuality 4"));
    GEngine->Exec(World, TEXT("foliage.DensityScale 1"));
    GEngine->Exec(World, TEXT("grass.DensityScale 1"));
    GEngine->Exec(World, TEXT("r.Streaming.PoolSize 0 "));
    GEngine->Exec(World, TEXT("r.Shadow.RadiusThreshold 0.01"));
 
    SetShadowCacheInvalidationBehavior(EShadowCacheInvalidationBehavior::Rigid);
}
 
void UAgrarsenseSettings::SetLowQualityLevel()
{
    UWorld* World = CurrentWorld.Get();
    if (!World || !GEngine)
    {
        return;
    }
 
    DisableRaytracing();
 
    GEngine->Exec(World, TEXT("sg.PostProcessQuality 0"));
    GEngine->Exec(World, TEXT("sg.ShadowQuality 0"));
    GEngine->Exec(World, TEXT("sg.TextureQuality 0"));
    GEngine->Exec(World, TEXT("sg.EffectsQuality 0"));
    GEngine->Exec(World, TEXT("sg.FoliageQuality 0"));
 
    GEngine->Exec(World, TEXT("r.DefaultFeature.MotionBlur 0"));
    GEngine->Exec(World, TEXT("r.DefaultFeature.Bloom 0"));
    GEngine->Exec(World, TEXT("r.DefaultFeature.AmbientOcclusion 0"));
    GEngine->Exec(World, TEXT("r.DefaultFeature.AmbientOcclusionStaticFraction 0"));
    GEngine->Exec(World, TEXT("r.HZBOcclusion 0"));
    GEngine->Exec(World, TEXT("r.MinScreenRadiusForLights 0.01"));
    GEngine->Exec(World, TEXT("r.SeparateTranslucency 0"));
    GEngine->Exec(World, TEXT("r.FinishCurrentFrame 0"));
    GEngine->Exec(World, TEXT("r.MotionBlurQuality 0"));
    GEngine->Exec(World, TEXT("r.BloomQuality 1"));
    GEngine->Exec(World, TEXT("r.DepthOfFieldQuality 0"));
    GEngine->Exec(World, TEXT("r.TranslucencyVolumeBlur 0"));
    GEngine->Exec(World, TEXT("r.TranslucencyLightingVolumeDim 4"));
    GEngine->Exec(World, TEXT("r.MaxAnisotropy 4"));
    GEngine->Exec(World, TEXT("r.LensFlareQuality 0"));
    GEngine->Exec(World, TEXT("r.SceneColorFringeQuality 0"));
    GEngine->Exec(World, TEXT("r.FastBlurThreshold 0"));
    GEngine->Exec(World, TEXT("r.SSR 0"));
    GEngine->Exec(World, TEXT("r.EarlyZPassMovable 1"));
    GEngine->Exec(World, TEXT("r.TranslucentLightingVolume 0"));
    GEngine->Exec(World, TEXT("r.LightShaftDownSampleFactor 4"));
    GEngine->Exec(World, TEXT("r.OcclusionQueryLocation 1"));
    GEngine->Exec(World, TEXT("foliage.DensityScale 0"));
    GEngine->Exec(World, TEXT("grass.DensityScale 0"));
    GEngine->Exec(World, TEXT("r.Streaming.PoolSize 0 "));
 
    SetShadowCacheInvalidationBehavior(EShadowCacheInvalidationBehavior::Rigid);
}