UAgrarsenseSettings Class Reference

#include <AgrarsenseSettings.h>

Inheritance diagram for UAgrarsenseSettings:

Collaboration diagram for UAgrarsenseSettings:

Public Member Functions
void	Setup (UWorld *World)
virtual void	PostInitProperties () override
void	LoadSettings (bool bForceReload=false) override
void	ApplySettings (bool bCheckForCommandLineOverrides) override
void	SetGraphicsSettings (FGlobalGraphicsSettings NewSettings)
void	SetWindowMode (EWindowMode::Type WindowType)
void	SetSimulationSettings (FGlobalSimulationSettings NewSettings)
void	SetWorldRendering (bool enabled)
void	SetQualityLevel (EQualityLevel newQualityLevel)
void	SetQualityLevelFromString (const FString &QualityLevelString)
int	GetGlobalTargetFrameRate () const
void	SetGlobalTargetFrameRate (int NewTargetFrameRate)
float	GetGlobalTimeDilation () const
void	SetSpectatorMaxSpeed (float MaxSpeed)
void	SetShowSpectatorRainAndSnowfall (bool Show)
float	GetSpectatorMaxSpeed () const
bool	GetShowSpectatorRainAndSnowfall () const
void	SetGlobalTimeDilation (float TimeDilation)
void	PauseSimulation ()
void	UnPauseSimulation ()
void	PauseSimulationEndOfThisFrame ()
void	AdvanceFrameCount (int32 FramesToAdvance)
void	AdvanceTime (float TimeToAdvance)
void	ChangeMapByName (FString MapName)
void	ChangeMapByMapPath (const FString &Path)
bool	GetGrassVisibility () const
void	SetGrassVisibility (bool Visible)
bool	GetShadowCSMCache () const
void	SetShadowCSMCache (bool CacheShadowCSM)
EAntiAliasing	GetAntiAliasingMethod () const
void	SetAntiAliasingMethod (EAntiAliasing AntiAliasingMethod)
void	SetAntiAliasingMethodFromString (const FString &AntiAliasingMethodString)
void	SetInstancedRenderingVisibility (bool Visible)
void	SetWorldPositionOffsetRenderDistance (int32 WorldPositionOffsetDistance)
void	SetNaniteMaxPixelsPerEdge (float MaxPixelsPerEdge=1.0f)
void	SetShadowCacheInvalidationBehavior (EShadowCacheInvalidationBehavior Behaviour=EShadowCacheInvalidationBehavior::Rigid)
void	SetShadowCacheInvalidationBehaviorFromString (const FString &BehaviourString)
int32	GetWorldPositionOffsetRenderDistance () const
float	GetNaniteMaxPixelsPerEdge () const
EShadowCacheInvalidationBehavior	GetShadowCacheInvalidationBehavior () const
bool	GetStartWindowInitiallyMinimized () const
void	SetStartWindowInitiallyMinimized (bool Minimized)
void	SetRenderCustomDepthPass (bool RenderCustomDepthPass)
void	SetUseVirtualShadowMaps (bool UseVirtualShadowMaps)
bool	GetIsUsingVirtualShadowMaps () const
bool	GetIsRenderingCustomDepthPass () const
int32	GetNumberOfWorkerThreads () const
FString	GetConsoleVariableValueString (const FString &VariableName) const
EQualityLevel	GetCurrentQualityLevel () const
TArray< FString >	GetMapNames () const
TArray< FString >	GetMapPaths () const

Static Public Member Functions
static UAgrarsenseSettings *	GetAgrarsenseSettings ()
static bool	ShouldStartWindowMinimized ()
static bool	IsPlayingInMainMenu ()
static FGlobalSimulationSettings	GetGlobalSimulationSettings ()
static bool	IsSimulationPaused ()
static FGlobalGraphicsSettings	GetGlobalGraphicsSettings ()

Public Attributes
FGraphicsSettingsDelegate	OnGraphicsSettingsChanged

Private Member Functions
	UAgrarsenseSettings ()
bool	ParseLaunchArguments ()
void	OnSensorSpawned (ASensor *SensorPtr)
void	OnSensorDestroyed (ASensor *SensorPtr)
void	SetUltraWithRaytracingLevel ()
bool	IsRaytracingSupported () const
void	EnableRaytracing ()
void	DisableRaytracing ()
void	SetUltraQualityLevel ()
void	SetBalancedQualityLevel ()
void	SetLowQualityLevel ()

Private Attributes
int	NumberOfPostProcessingSensors = 0
bool	RenderCustomDepth = false
TWeakObjectPtr< UWorld >	CurrentWorld = nullptr
FGlobalSimulationSettings	SimulationSettings
FGlobalGraphicsSettings	GraphicsSettings
FDelegateHandle	AdvanceFramesHandle
int32	FrameCount = 0
FDelegateHandle	EndOfFrameHandle
const TArray< FString >	MapNames
const TArray< FString >	MapPaths

Static Private Attributes
static bool	IsMainMenu = false
static FString	CurrentMapName

Friends
class	AAgrarsenseGameModeBase

Detailed Description

Definition at line 28 of file AgrarsenseSettings.h.

Constructor & Destructor Documentation

UAgrarsenseSettings()

UAgrarsenseSettings::UAgrarsenseSettings ( )

private

Definition at line 41 of file AgrarsenseSettings.cpp.

{
}

Member Function Documentation

AdvanceFrameCount()

void UAgrarsenseSettings::AdvanceFrameCount

(

int32

FramesToAdvance

)

Amount of frames to advance before pausing simulation.

Parameters

Frames

number of frames to advance before pausing simulation.

Definition at line 668 of file AgrarsenseSettings.cpp.

{
    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();
                }
            }
        });
}

References AdvanceFramesHandle, EndOfFrameHandle, FrameCount, PauseSimulationEndOfThisFrame(), and UnPauseSimulation().

Referenced by UROSCommands::HandleAdvanceFrames(), and UROSCommands::HandleAdvanceOneFrame().

AdvanceTime()

void UAgrarsenseSettings::AdvanceTime

(

float

TimeToAdvance

)

Amount of time to advance before pausing simulation. @TimeToAdvance time in seconds.

Definition at line 713 of file AgrarsenseSettings.cpp.

{
    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);
}

References CurrentWorld, PauseSimulationEndOfThisFrame(), and UnPauseSimulation().

Referenced by UROSCommands::HandleAdvanceTime().

ApplySettings()

void UAgrarsenseSettings::ApplySettings ( bool  bCheckForCommandLineOverrides )

override

Definition at line 137 of file AgrarsenseSettings.cpp.

{
    Super::ApplySettings(bCheckForCommandLineOverrides);
 
    SetGraphicsSettings(GraphicsSettings);
    SetSimulationSettings(SimulationSettings);
}

References GraphicsSettings, SetGraphicsSettings(), SetSimulationSettings(), and SimulationSettings.

Referenced by SetGlobalTargetFrameRate(), and Setup().

ChangeMapByMapPath()

void UAgrarsenseSettings::ChangeMapByMapPath

(

const FString &

Path

)

Change map by map relative path

Definition at line 763 of file AgrarsenseSettings.cpp.

{
    UWorld* World = CurrentWorld.Get();
    if (World)
    {
        UGameplayStatics::OpenLevel(World, *Path, TRAVEL_Absolute);
    }
}

References CurrentWorld.

Referenced by ChangeMapByName().

ChangeMapByName()

void UAgrarsenseSettings::ChangeMapByName

(

FString

MapName

)

Change map by name. This only works for maps defined in MapNames TArray.

Parameters

MapName

map name as FString

Definition at line 736 of file AgrarsenseSettings.cpp.

{
    // 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);
    }
}

References ChangeMapByMapPath(), SimulatorLog::Log(), MapNames, and MapPaths.

Referenced by UROSCommands::HandleChangeMap().

DisableRaytracing()

void UAgrarsenseSettings::DisableRaytracing ( )

private

Definition at line 865 of file AgrarsenseSettings.cpp.

{
    UWorld* World = CurrentWorld.Get();
    if (!World || !GEngine)
    {
        return;
    }
 
    GEngine->Exec(World, TEXT("r.Lumen.HardwareRayTracing 0"));
    GEngine->Exec(World, TEXT("r.RayTracing.Geometry 0"));
    GEngine->Exec(World, TEXT("r.RayTracing.Shadows 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"));
}

References CurrentWorld.

Referenced by SetBalancedQualityLevel(), SetLowQualityLevel(), and SetUltraQualityLevel().

EnableRaytracing()

void UAgrarsenseSettings::EnableRaytracing ( )

private

Definition at line 847 of file AgrarsenseSettings.cpp.

{
    UWorld* World = CurrentWorld.Get();
    if (!World || !GEngine)
    {
        return;
    }
 
    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.Shadows 1"));               // Enable ray tracing shadows
    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
}

References CurrentWorld.

Referenced by SetUltraWithRaytracingLevel().

GetAgrarsenseSettings()

UAgrarsenseSettings * UAgrarsenseSettings::GetAgrarsenseSettings ( )

static

Definition at line 127 of file AgrarsenseSettings.cpp.

{
    return Cast<UAgrarsenseSettings>(UGameUserSettings::GetGameUserSettings());
}

Referenced by UAgrarsenseStatics::GetAgrarsenseSettings(), and AAgrarsenseGameModeBase::SpawnNeededActorsInitGame().

GetAntiAliasingMethod()

EAntiAliasing UAgrarsenseSettings::GetAntiAliasingMethod

(

)

const

Get current anti aliasing method

Returns

Definition at line 445 of file AgrarsenseSettings.cpp.

{
    return GraphicsSettings.AntiAliasingMethod;
}

References FGlobalGraphicsSettings::AntiAliasingMethod, and GraphicsSettings.

GetConsoleVariableValueString()

FString UAgrarsenseSettings::GetConsoleVariableValueString

(

const FString &

VariableName

)

const

Get Console variable value as FString.

Returns

console variable value as FString or empty string if not found.

Definition at line 194 of file AgrarsenseSettings.cpp.

{
    IConsoleVariable* ConsoleVariable = IConsoleManager::Get().FindConsoleVariable(*VariableName);
    if (ConsoleVariable)
    {
        FString VariableValue = ConsoleVariable->GetString();
        return VariableValue;
    }
    else
    {
        return FString();
    }
}

GetCurrentQualityLevel()

EQualityLevel UAgrarsenseSettings::GetCurrentQualityLevel ( ) const

inline

Get current graphics quality level

Returns

EQualityLevel enum

Definition at line 360 of file AgrarsenseSettings.h.

    {
        return GraphicsSettings.QualityLevel;
    }

GetGlobalGraphicsSettings()

static FGlobalGraphicsSettings UAgrarsenseSettings::GetGlobalGraphicsSettings ( )

inlinestatic

Get Global Graphics settings.

Definition at line 432 of file AgrarsenseSettings.h.

    {
        return GetAgrarsenseSettings()->GraphicsSettings;
    }

GetGlobalSimulationSettings()

static FGlobalSimulationSettings UAgrarsenseSettings::GetGlobalSimulationSettings ( )

inlinestatic

Get Global simulation settings.

Definition at line 414 of file AgrarsenseSettings.h.

    {
        return GetAgrarsenseSettings()->SimulationSettings;
    }

GetGlobalTargetFrameRate()

int UAgrarsenseSettings::GetGlobalTargetFrameRate

(

)

const

Get the global target frame rate for the Simulator

Returns

int TargetFrameRate

Definition at line 547 of file AgrarsenseSettings.cpp.

{
    return GetFrameRateLimit();
}

GetGlobalTimeDilation()

float UAgrarsenseSettings::GetGlobalTimeDilation

(

)

const

Get global time dilation factor, affecting the entire simulation tick time flow.

Returns

float TimeDilation

Definition at line 558 of file AgrarsenseSettings.cpp.

{
    UWorld* World = CurrentWorld.Get();
 
    if (!World)
    {
        return SimulationSettings.TimeDilation;
    }
 
    return UGameplayStatics::GetGlobalTimeDilation(World);
}

References CurrentWorld, SimulationSettings, and FGlobalSimulationSettings::TimeDilation.

GetGrassVisibility()

bool UAgrarsenseSettings::GetGrassVisibility

(

)

const

Get if grass visible or not

Returns

Grass visibility

Definition at line 243 of file AgrarsenseSettings.cpp.

{
    return GraphicsSettings.RenderGrass;
}

References GraphicsSettings, and FGlobalGraphicsSettings::RenderGrass.

GetIsRenderingCustomDepthPass()

bool UAgrarsenseSettings::GetIsRenderingCustomDepthPass

(

)

const

Get is rendering custom depth pass on.

Definition at line 440 of file AgrarsenseSettings.cpp.

{
    return RenderCustomDepth;
}

References RenderCustomDepth.

GetIsUsingVirtualShadowMaps()

bool UAgrarsenseSettings::GetIsUsingVirtualShadowMaps

(

)

const

Get is rendering virtual shadow maps on.

Definition at line 435 of file AgrarsenseSettings.cpp.

{
    return GraphicsSettings.UseVirtualShadowMaps;
}

References GraphicsSettings, and FGlobalGraphicsSettings::UseVirtualShadowMaps.

GetMapNames()

TArray< FString > UAgrarsenseSettings::GetMapNames ( ) const

inline

Get map names as TArray. This TArray is hardcoded.

Returns

TArray<FString> MapNames

Definition at line 370 of file AgrarsenseSettings.h.

    {
        return MapNames;
    }

Referenced by UROSCommands::HandlePrintMaps().

GetMapPaths()

TArray< FString > UAgrarsenseSettings::GetMapPaths ( ) const

inline

Get map paths as TArray. This TArray is hardcoded.

Returns

TArray<FString> MapPaths

Definition at line 380 of file AgrarsenseSettings.h.

    {
        return MapPaths;
    }

GetNaniteMaxPixelsPerEdge()

float UAgrarsenseSettings::GetNaniteMaxPixelsPerEdge

(

)

const

Definition at line 378 of file AgrarsenseSettings.cpp.

{
    return GraphicsSettings.NaniteMaxPixelsPerEdge;
}

References GraphicsSettings, and FGlobalGraphicsSettings::NaniteMaxPixelsPerEdge.

GetNumberOfWorkerThreads()

int32 UAgrarsenseSettings::GetNumberOfWorkerThreads

(

)

const

Returns the number of worker threads used by the Simulator.

Definition at line 189 of file AgrarsenseSettings.cpp.

{
    return FPlatformMisc::NumberOfWorkerThreadsToSpawn();
}

GetShadowCacheInvalidationBehavior()

EShadowCacheInvalidationBehavior UAgrarsenseSettings::GetShadowCacheInvalidationBehavior

(

)

const

Definition at line 383 of file AgrarsenseSettings.cpp.

{
    return GraphicsSettings.FoliageShadowCacheInvalidationBehaviour;
}

References FGlobalGraphicsSettings::FoliageShadowCacheInvalidationBehaviour, and GraphicsSettings.

GetShadowCSMCache()

bool UAgrarsenseSettings::GetShadowCSMCache

(

)

const

Get Shadow CSM cache

Returns

Shadow CSM cache on/off

Definition at line 277 of file AgrarsenseSettings.cpp.

{
    return GraphicsSettings.ShadowCSMCaching;
}

References GraphicsSettings, and FGlobalGraphicsSettings::ShadowCSMCaching.

GetShowSpectatorRainAndSnowfall()

bool UAgrarsenseSettings::GetShowSpectatorRainAndSnowfall ( ) const

inline

Get if spectator rain and snowfall niagara system should be visible

Returns

Show or not

Definition at line 141 of file AgrarsenseSettings.h.

    {
        return SimulationSettings.ShowSpectatorRainAndSnowfall;
    }

GetSpectatorMaxSpeed()

float UAgrarsenseSettings::GetSpectatorMaxSpeed ( ) const

inline

Get the max of the spectator pawn

Returns

Current max speed

Definition at line 131 of file AgrarsenseSettings.h.

    {
        return SimulationSettings.SpectatorMaxSpeed;
    }

GetStartWindowInitiallyMinimized()

bool UAgrarsenseSettings::GetStartWindowInitiallyMinimized

(

)

const

Get if new UnrealWindow's start minimized instead of popping in front of everything.

Definition at line 388 of file AgrarsenseSettings.cpp.

{
    return SimulationSettings.StartCameraWindowsMinimized;
}

References SimulationSettings, and FGlobalSimulationSettings::StartCameraWindowsMinimized.

GetWorldPositionOffsetRenderDistance()

int32 UAgrarsenseSettings::GetWorldPositionOffsetRenderDistance

(

)

const

Definition at line 373 of file AgrarsenseSettings.cpp.

{
    return GraphicsSettings.WorldPositionOffsetDistance;
}

References GraphicsSettings, and FGlobalGraphicsSettings::WorldPositionOffsetDistance.

Referenced by AInstancedRenderer::BeginPlay().

IsPlayingInMainMenu()

static bool UAgrarsenseSettings::IsPlayingInMainMenu ( )

inlinestatic

Check if currently playing in the main menu map.

Returns

true if the game is playing in the main menu, false otherwise.

Definition at line 405 of file AgrarsenseSettings.h.

    {
        return IsMainMenu;
    }

Referenced by ATagger::BeginPlay(), and USimulatorJsonParser::ParseAndOperateJSONFile().

IsRaytracingSupported()

bool UAgrarsenseSettings::IsRaytracingSupported ( ) const

private

Definition at line 821 of file AgrarsenseSettings.cpp.

{
    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;
    }
 
#if ENGINE_MAJOR_VERSION == 5 && ENGINE_MINOR_VERSION <= 3 // Check Engine version. In UE 5.4 Vulkan also supports raytracing.
    #if PLATFORM_WINDOWS
        {
            // DirectX Raytracing support check
            if (!GDynamicRHI && GDynamicRHI->GetName() == FString(TEXT("D3D12")))
            {
                RayTracingSupported = false;
            }
        }
    #endif
#endif
 
    return RayTracingSupported;
}

Referenced by SetUltraWithRaytracingLevel().

IsSimulationPaused()

static bool UAgrarsenseSettings::IsSimulationPaused ( )

inlinestatic

Is simulation paused

Definition at line 423 of file AgrarsenseSettings.h.

    {
        return GetAgrarsenseSettings()->SimulationSettings.IsSimulationPaused;
    }

References FGlobalSimulationSettings::IsSimulationPaused.

LoadSettings()

void UAgrarsenseSettings::LoadSettings ( bool  bForceReload = false )

override

Load and apply saved settings

Definition at line 132 of file AgrarsenseSettings.cpp.

{
    Super::LoadSettings(bForceReload);
}

OnSensorDestroyed()

void UAgrarsenseSettings::OnSensorDestroyed ( ASensor *  SensorPtr )

private

Definition at line 788 of file AgrarsenseSettings.cpp.

{
    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);
        }
    }
}

References ASensor::GetSensorType(), NumberOfPostProcessingSensors, SemanticSegmentationCamera, SetRenderCustomDepthPass(), and ThermalCamera.

Referenced by Setup().

OnSensorSpawned()

void UAgrarsenseSettings::OnSensorSpawned ( ASensor *  SensorPtr )

private

Definition at line 772 of file AgrarsenseSettings.cpp.

{
    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);
    }
}

References ASensor::GetSensorType(), NumberOfPostProcessingSensors, SemanticSegmentationCamera, SetRenderCustomDepthPass(), and ThermalCamera.

Referenced by Setup().

ParseLaunchArguments()

bool UAgrarsenseSettings::ParseLaunchArguments ( )

private

Definition at line 145 of file AgrarsenseSettings.cpp.

{
    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;
}

References FGlobalGraphicsSettings::AntiAliasingMethod, UEnumUtilities::ConvertStringToQualityLevel(), FGlobalGraphicsSettings::DisableSpectatorRendering, GraphicsSettings, FGlobalGraphicsSettings::QualityLevel, SimulationSettings, and FGlobalSimulationSettings::StartCameraWindowsMinimized.

Referenced by PostInitProperties().

PauseSimulation()

void UAgrarsenseSettings::PauseSimulation

(

)

Pause the Simulator immediately.

Definition at line 618 of file AgrarsenseSettings.cpp.

{
    UWorld* World = CurrentWorld.Get();
    if (World && !SimulationSettings.IsSimulationPaused)
    {
        UGameplayStatics::SetGlobalTimeDilation(World, 0.0f);
        UGameplayStatics::SetGamePaused(World, true);
        SimulationSettings.IsSimulationPaused = true;
        
        SimulatorLog::Log("Simulator paused");
    }
}

References CurrentWorld, FGlobalSimulationSettings::IsSimulationPaused, SimulatorLog::Log(), and SimulationSettings.

Referenced by PauseSimulationEndOfThisFrame().

PauseSimulationEndOfThisFrame()

void UAgrarsenseSettings::PauseSimulationEndOfThisFrame

(

)

Pauses the Simulator after the end of this frame.

Definition at line 644 of file AgrarsenseSettings.cpp.

{
    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();
            }
        });
}

References EndOfFrameHandle, FGlobalSimulationSettings::IsSimulationPaused, PauseSimulation(), and SimulationSettings.

Referenced by AdvanceFrameCount(), AdvanceTime(), and UROSCommands::HandlePauseSimulator().

PostInitProperties()

void UAgrarsenseSettings::PostInitProperties ( )

overridevirtual

Definition at line 115 of file AgrarsenseSettings.cpp.

{
    Super::PostInitProperties();
 
#if UE_BUILD_SHIPPING || UE_BUILD_DEVELOPMENT
    if (ParseLaunchArguments())
    {
        SaveConfig();
    }
#endif
}

References ParseLaunchArguments().

SetAntiAliasingMethod()

void UAgrarsenseSettings::SetAntiAliasingMethod

(

EAntiAliasing

AntiAliasingMethod

)

Override anti aliasing method. Default TAA.

Parameters

AntiAliasingMethod

Definition at line 450 of file AgrarsenseSettings.cpp.

{
 
    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);
}

References FGlobalGraphicsSettings::AntiAliasingMethod, CurrentWorld, FXAA, GraphicsSettings, NONE, OnGraphicsSettingsChanged, TAA, and TSR.

Referenced by SetAntiAliasingMethodFromString(), and SetGraphicsSettings().

SetAntiAliasingMethodFromString()

void UAgrarsenseSettings::SetAntiAliasingMethodFromString

(

const FString &

AntiAliasingMethodString

)

@Override anti aliasing method using a string.

Parameters

AntiAliasingMethodString

Definition at line 492 of file AgrarsenseSettings.cpp.

{
    EAntiAliasing NewMethod = UEnumUtilities::ConvertStringToAntiAliasingMethod(AntiAliasingMethodString);
    SetAntiAliasingMethod(NewMethod);
}

References UEnumUtilities::ConvertStringToAntiAliasingMethod(), and SetAntiAliasingMethod().

SetBalancedQualityLevel()

void UAgrarsenseSettings::SetBalancedQualityLevel ( )

private

Definition at line 922 of file AgrarsenseSettings.cpp.

{
    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);
}

References CurrentWorld, DisableRaytracing(), and SetShadowCacheInvalidationBehavior().

Referenced by SetQualityLevel().

SetGlobalTargetFrameRate()

void UAgrarsenseSettings::SetGlobalTargetFrameRate

(

int

NewTargetFrameRate

)

Sets the global target frame rate for the Simulator. This function allows you to specify a target frame rate in frames per second (FPS) that Unreal Engine will attempt to maintain.

Parameters

NewTargetFrameRate

The desired target frame rate to set (in FPS).

Definition at line 552 of file AgrarsenseSettings.cpp.

{
    SetFrameRateLimit(NewTargetFrameRate);
    ApplySettings(false);
}

References ApplySettings().

Referenced by UROSCommands::HandleSetGlobalTargetFrameRate().

SetGlobalTimeDilation()

void UAgrarsenseSettings::SetGlobalTimeDilation

(

float

TimeDilation

)

Set the global time dilation factor, affecting the entire simulation tick time flow. This function allows you to control the time dilation factor for the entire game world. Time dilation affects the speed of all game actors, animations, and other time-dependent processes.

Parameters

TimeDilation

The desired time dilation factor. A value of 1.0 represents real-time, while values less than 1.0 slow down time, and values greater than 1.0 speed it up.

Definition at line 570 of file AgrarsenseSettings.cpp.

{
    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);
}

References CurrentWorld, SimulatorLog::Log(), SimulationSettings, and FGlobalSimulationSettings::TimeDilation.

Referenced by UROSCommands::HandleSetGlobalTimeDilation(), and SetSimulationSettings().

SetGraphicsSettings()

void UAgrarsenseSettings::SetGraphicsSettings

(

FGlobalGraphicsSettings

NewSettings

)

Change global graphics settings.

Parameters

NewSettings

The new graphics settings to apply.

Definition at line 208 of file AgrarsenseSettings.cpp.

{
    GraphicsSettings = NewSettings;
 
    SetWorldRendering(!GraphicsSettings.DisableSpectatorRendering);
    SetQualityLevel(GraphicsSettings.QualityLevel);
    SetAntiAliasingMethod(GraphicsSettings.AntiAliasingMethod);
    SetGrassVisibility(GraphicsSettings.RenderGrass);
    SetShadowCSMCache(GraphicsSettings.ShadowCSMCaching);
    SetUseVirtualShadowMaps(GraphicsSettings.UseVirtualShadowMaps);
}

References FGlobalGraphicsSettings::AntiAliasingMethod, FGlobalGraphicsSettings::DisableSpectatorRendering, GraphicsSettings, FGlobalGraphicsSettings::QualityLevel, FGlobalGraphicsSettings::RenderGrass, SetAntiAliasingMethod(), SetGrassVisibility(), SetQualityLevel(), SetShadowCSMCache(), SetUseVirtualShadowMaps(), SetWorldRendering(), FGlobalGraphicsSettings::ShadowCSMCaching, and FGlobalGraphicsSettings::UseVirtualShadowMaps.

Referenced by ApplySettings().

SetGrassVisibility()

void UAgrarsenseSettings::SetGrassVisibility

(

bool

Visible

)

Set grass rendering visibility.

Definition at line 248 of file AgrarsenseSettings.cpp.

{
    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);
}

References CurrentWorld, GraphicsSettings, OnGraphicsSettingsChanged, and FGlobalGraphicsSettings::RenderGrass.

Referenced by SetGraphicsSettings().

SetInstancedRenderingVisibility()

void UAgrarsenseSettings::SetInstancedRenderingVisibility

(

bool

Visible

)

Set instanced rendering visibility which is most static objects. Mainly for debugging purposes.

Definition at line 307 of file AgrarsenseSettings.cpp.

{
    UWorld* World = CurrentWorld.Get();
 
    if (World)
    {
        AInstancedRenderer* InstanceRenderer = UAgrarsenseStatics::GetInstancedRenderer(World);
        if (InstanceRenderer)
        {
            InstanceRenderer->SetInstancedRendering(Visible);
        }
    }
}

References CurrentWorld, UAgrarsenseStatics::GetInstancedRenderer(), and AInstancedRenderer::SetInstancedRendering().

SetLowQualityLevel()

void UAgrarsenseSettings::SetLowQualityLevel ( )

private

Definition at line 960 of file AgrarsenseSettings.cpp.

{
    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);
}

References CurrentWorld, DisableRaytracing(), and SetShadowCacheInvalidationBehavior().

Referenced by SetQualityLevel().

SetNaniteMaxPixelsPerEdge()

void UAgrarsenseSettings::SetNaniteMaxPixelsPerEdge

(

float

MaxPixelsPerEdge = 1.0f

)

Definition at line 327 of file AgrarsenseSettings.cpp.

{
    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);
    }
}

References CurrentWorld, GraphicsSettings, FGlobalGraphicsSettings::NaniteMaxPixelsPerEdge, and OnGraphicsSettingsChanged.

Referenced by UROSCommands::HandleSetNaniteMaxPixelsPerEdge().

SetQualityLevel()

void UAgrarsenseSettings::SetQualityLevel

(

EQualityLevel

newQualityLevel

)

Set new Graphics quality level.

Parameters

qualityLevel

EQualityLevel enum

Definition at line 512 of file AgrarsenseSettings.cpp.

{
    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);
}

References Balanced, UEnumUtilities::ConvertQualityLevelToString(), GraphicsSettings, SimulatorLog::Log(), Low, OnGraphicsSettingsChanged, FGlobalGraphicsSettings::QualityLevel, SetBalancedQualityLevel(), SetLowQualityLevel(), SetUltraQualityLevel(), SetUltraWithRaytracingLevel(), Ultra, and UltraRaytracing.

Referenced by SetGraphicsSettings(), and SetQualityLevelFromString().

SetQualityLevelFromString()

void UAgrarsenseSettings::SetQualityLevelFromString

(

const FString &

QualityLevelString

)

Set new graphics quality level from string parsed to quality level enum.

Parameters

FString&

QualityLevelString

Definition at line 542 of file AgrarsenseSettings.cpp.

{
    SetQualityLevel(UEnumUtilities::ConvertStringToQualityLevel(QualityLevelString));
}

References UEnumUtilities::ConvertStringToQualityLevel(), and SetQualityLevel().

Referenced by UROSCommands::HandleSetQualityLevel().

SetRenderCustomDepthPass()

void UAgrarsenseSettings::SetRenderCustomDepthPass

(

bool

RenderCustomDepthPass

)

Set should custom depth pass be rendered at all.

Definition at line 398 of file AgrarsenseSettings.cpp.

{
    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"));
        }
    }
}

References CurrentWorld, and RenderCustomDepth.

Referenced by OnSensorDestroyed(), and OnSensorSpawned().

SetShadowCacheInvalidationBehavior()

void UAgrarsenseSettings::SetShadowCacheInvalidationBehavior

(

EShadowCacheInvalidationBehavior

Behaviour = EShadowCacheInvalidationBehavior::Rigid

)

Definition at line 342 of file AgrarsenseSettings.cpp.

{
    if (GraphicsSettings.FoliageShadowCacheInvalidationBehaviour != Behaviour)
    {
        GraphicsSettings.FoliageShadowCacheInvalidationBehaviour = Behaviour;
        OnGraphicsSettingsChanged.Broadcast(GraphicsSettings);
    }
}

References FGlobalGraphicsSettings::FoliageShadowCacheInvalidationBehaviour, GraphicsSettings, and OnGraphicsSettingsChanged.

Referenced by SetBalancedQualityLevel(), SetLowQualityLevel(), SetShadowCacheInvalidationBehaviorFromString(), and SetUltraQualityLevel().

SetShadowCacheInvalidationBehaviorFromString()

void UAgrarsenseSettings::SetShadowCacheInvalidationBehaviorFromString

(

const FString &

BehaviourString

)

Set Shadow cache invalidation behavior option from string.

See also

SetShadowCacheInvalidationBehaviour(EShadowCacheInvalidationBehavior Behaviour) for what setting does

Parameters

BehaviourString

String to convert to enum

Definition at line 351 of file AgrarsenseSettings.cpp.

{
    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);
    }
}

References SetShadowCacheInvalidationBehavior().

SetShadowCSMCache()

void UAgrarsenseSettings::SetShadowCSMCache

(

bool

CacheShadowCSM

)

Definition at line 282 of file AgrarsenseSettings.cpp.

{
    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);
    }
}

References CurrentWorld, GraphicsSettings, OnGraphicsSettingsChanged, and FGlobalGraphicsSettings::ShadowCSMCaching.

Referenced by SetGraphicsSettings().

SetShowSpectatorRainAndSnowfall()

void UAgrarsenseSettings::SetShowSpectatorRainAndSnowfall

(

bool

Show

)

Set if specator rain and snowfall niagara system is enabled

Definition at line 601 of file AgrarsenseSettings.cpp.

{
    UWorld* World = CurrentWorld.Get();
    if (!World)
    {
        return;
    }
 
    ASpectator* Spectator = UAgrarsenseStatics::GetSpectator(World);
 
    if (IsValid(Spectator))
    {
        Spectator->SetNiagaraComponentVisibility(Show);
        SimulationSettings.ShowSpectatorRainAndSnowfall = Spectator->IsNiagaraComponentVisible();
    }
}

References CurrentWorld, UAgrarsenseStatics::GetSpectator(), ASpectator::IsNiagaraComponentVisible(), ASpectator::SetNiagaraComponentVisibility(), FGlobalSimulationSettings::ShowSpectatorRainAndSnowfall, and SimulationSettings.

Referenced by SetSimulationSettings().

SetSimulationSettings()

void UAgrarsenseSettings::SetSimulationSettings

(

FGlobalSimulationSettings

NewSettings

)

Change global simulation settings

Parameters

NewSettings

The new simulation settings to apply

Definition at line 233 of file AgrarsenseSettings.cpp.

{
    SimulationSettings = NewSettings;
 
    SetStartWindowInitiallyMinimized(SimulationSettings.StartCameraWindowsMinimized);
    SetGlobalTimeDilation(SimulationSettings.TimeDilation);
    SetSpectatorMaxSpeed(SimulationSettings.SpectatorMaxSpeed);
    SetShowSpectatorRainAndSnowfall(SimulationSettings.ShowSpectatorRainAndSnowfall);
}

References SetGlobalTimeDilation(), SetShowSpectatorRainAndSnowfall(), SetSpectatorMaxSpeed(), SetStartWindowInitiallyMinimized(), FGlobalSimulationSettings::ShowSpectatorRainAndSnowfall, SimulationSettings, FGlobalSimulationSettings::SpectatorMaxSpeed, FGlobalSimulationSettings::StartCameraWindowsMinimized, and FGlobalSimulationSettings::TimeDilation.

Referenced by ApplySettings().

SetSpectatorMaxSpeed()

void UAgrarsenseSettings::SetSpectatorMaxSpeed

(

float

MaxSpeed

)

Set the max speed of the spectator pawn

Definition at line 585 of file AgrarsenseSettings.cpp.

{
    UWorld* World = CurrentWorld.Get();
    if (!World)
    {
        return;
    }
 
    ASpectator* Spectator = UAgrarsenseStatics::GetSpectator(World);
    if (IsValid(Spectator))
    {
        Spectator->SetMaxSpeed(MaxSpeed);
        SimulationSettings.SpectatorMaxSpeed = Spectator->GetMaxSpeed();
    }
}

References CurrentWorld, ASpectator::GetMaxSpeed(), UAgrarsenseStatics::GetSpectator(), ASpectator::SetMaxSpeed(), SimulationSettings, and FGlobalSimulationSettings::SpectatorMaxSpeed.

Referenced by SetSimulationSettings().

SetStartWindowInitiallyMinimized()

void UAgrarsenseSettings::SetStartWindowInitiallyMinimized

(

bool

Minimized

)

Set should new UnrealWindow's start minimized instead of popping in front of everything.

Definition at line 393 of file AgrarsenseSettings.cpp.

{
    SimulationSettings.StartCameraWindowsMinimized = Minimized;
}

References SimulationSettings, and FGlobalSimulationSettings::StartCameraWindowsMinimized.

Referenced by SetSimulationSettings().

SetUltraQualityLevel()

void UAgrarsenseSettings::SetUltraQualityLevel ( )

private

Definition at line 883 of file AgrarsenseSettings.cpp.

{
    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);
}

References CurrentWorld, DisableRaytracing(), and SetShadowCacheInvalidationBehavior().

Referenced by SetQualityLevel(), and SetUltraWithRaytracingLevel().

SetUltraWithRaytracingLevel()

void UAgrarsenseSettings::SetUltraWithRaytracingLevel ( )

private

Definition at line 808 of file AgrarsenseSettings.cpp.

{
    if (IsRaytracingSupported())
    {
        SetUltraQualityLevel();
        EnableRaytracing();
    }
    else
    {
        SimulatorLog::Log("Graphics settings: Ray tracing not supported on this hardware.");
    }
}

References EnableRaytracing(), IsRaytracingSupported(), SimulatorLog::Log(), and SetUltraQualityLevel().

Referenced by SetQualityLevel().

Setup()

void UAgrarsenseSettings::Setup

(

UWorld *

World

)

Setup the settings with the new world, and apply settings.

Parameters

World

Definition at line 45 of file AgrarsenseSettings.cpp.

{
#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) 
    {
        // Set OptimizedWPO to 1 to allow disabling WPO runtime for foliage (see InstancedRenderer.cpp)
        GEngine->Exec(World, TEXT("r.OptimizedWPO 1"));
 
        GEngine->Exec(World, TEXT("g.TimeoutForBlockOnRenderFence 600000"));
        GEngine->Exec(World, TEXT("r.Streaming.PoolSize 0"));
        GEngine->Exec(World, TEXT("r.CustomDepth 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
}

References ApplySettings(), CurrentMapName, CurrentWorld, USensorManager::Get(), IsMainMenu, FGlobalSimulationSettings::IsSimulationPaused, USensorManager::OnSensorDestroyed, OnSensorDestroyed(), USensorManager::OnSensorSpawned, OnSensorSpawned(), RenderCustomDepth, SetWindowMode(), and SimulationSettings.

Referenced by AAgrarsenseGameModeBase::SpawnNeededActorsInitGame().

SetUseVirtualShadowMaps()

void UAgrarsenseSettings::SetUseVirtualShadowMaps

(

bool

UseVirtualShadowMaps

)

Set should virtual shadow maps be used, otherwise regular shadow maps are used.

Definition at line 415 of file AgrarsenseSettings.cpp.

{
    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);
    }
}

References CurrentWorld, GraphicsSettings, OnGraphicsSettingsChanged, and FGlobalGraphicsSettings::UseVirtualShadowMaps.

Referenced by SetGraphicsSettings().

SetWindowMode()

void UAgrarsenseSettings::SetWindowMode

(

EWindowMode::Type

WindowType

)

Set Main unreal window type

Definition at line 220 of file AgrarsenseSettings.cpp.

{
    if (GEngine)
    {
        UGameUserSettings* UserSettings = GEngine->GetGameUserSettings();
        if (UserSettings)
        {
            UserSettings->SetFullscreenMode(WindowType);
            UserSettings->ApplySettings(false);
        }
    }
}

Referenced by Setup().

SetWorldPositionOffsetRenderDistance()

void UAgrarsenseSettings::SetWorldPositionOffsetRenderDistance

(

int32

WorldPositionOffsetDistance

)

Definition at line 321 of file AgrarsenseSettings.cpp.

{
    GraphicsSettings.WorldPositionOffsetDistance = WorldPositionOffsetDistance;
    OnGraphicsSettingsChanged.Broadcast(GraphicsSettings);
}

References GraphicsSettings, OnGraphicsSettingsChanged, and FGlobalGraphicsSettings::WorldPositionOffsetDistance.

Referenced by UROSCommands::HandleSetWPO().

SetWorldRendering()

void UAgrarsenseSettings::SetWorldRendering

(

bool

enabled

)

Set main Unreal window world rendering on or off. Doesn't stop rendering UI elements.

Parameters

enabled

boolean to set rendering on or off

Definition at line 498 of file AgrarsenseSettings.cpp.

{
    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);
    }
}

References FGlobalGraphicsSettings::DisableSpectatorRendering, GraphicsSettings, SimulatorLog::Log(), and OnGraphicsSettingsChanged.

Referenced by UROSCommands::HandleSetWorldRendering(), and SetGraphicsSettings().

ShouldStartWindowMinimized()

static bool UAgrarsenseSettings::ShouldStartWindowMinimized ( )

inlinestatic

Static method to determine whether the Unreal window should start in a minimized state. Called by UnrealWindow.cpp.

Returns

true if the Unreal window should start minimized, false otherwise.

Definition at line 396 of file AgrarsenseSettings.h.

    {
        return GetAgrarsenseSettings()->SimulationSettings.StartCameraWindowsMinimized;
    }

Referenced by FUnrealWindow::FUnrealWindow().

UnPauseSimulation()

void UAgrarsenseSettings::UnPauseSimulation

(

)

Unpause the simulator immediately.

Definition at line 631 of file AgrarsenseSettings.cpp.

{
    UWorld* World = CurrentWorld.Get();
    if (World && SimulationSettings.IsSimulationPaused)
    {
        UGameplayStatics::SetGlobalTimeDilation(World, SimulationSettings.TimeDilation);
        UGameplayStatics::SetGamePaused(World, false);
        SimulationSettings.IsSimulationPaused = false;
 
        SimulatorLog::Log("Simulator unpaused");
    }
}

References CurrentWorld, FGlobalSimulationSettings::IsSimulationPaused, SimulatorLog::Log(), SimulationSettings, and FGlobalSimulationSettings::TimeDilation.

Referenced by AdvanceFrameCount(), AdvanceTime(), and UROSCommands::HandleUnPauseSimulator().

Friends And Related Function Documentation

AAgrarsenseGameModeBase

friend class AAgrarsenseGameModeBase

friend

Definition at line 440 of file AgrarsenseSettings.h.

Member Data Documentation

AdvanceFramesHandle

FDelegateHandle UAgrarsenseSettings::AdvanceFramesHandle

private

Definition at line 480 of file AgrarsenseSettings.h.

Referenced by AdvanceFrameCount().

CurrentMapName

FString UAgrarsenseSettings::CurrentMapName

staticprivate

Definition at line 512 of file AgrarsenseSettings.h.

Referenced by Setup().

CurrentWorld

TWeakObjectPtr<UWorld> UAgrarsenseSettings::CurrentWorld = nullptr

private

Definition at line 471 of file AgrarsenseSettings.h.

Referenced by AdvanceTime(), ChangeMapByMapPath(), DisableRaytracing(), EnableRaytracing(), GetGlobalTimeDilation(), PauseSimulation(), SetAntiAliasingMethod(), SetBalancedQualityLevel(), SetGlobalTimeDilation(), SetGrassVisibility(), SetInstancedRenderingVisibility(), SetLowQualityLevel(), SetNaniteMaxPixelsPerEdge(), SetRenderCustomDepthPass(), SetShadowCSMCache(), SetShowSpectatorRainAndSnowfall(), SetSpectatorMaxSpeed(), SetUltraQualityLevel(), Setup(), SetUseVirtualShadowMaps(), and UnPauseSimulation().

EndOfFrameHandle

FDelegateHandle UAgrarsenseSettings::EndOfFrameHandle

private

Definition at line 484 of file AgrarsenseSettings.h.

Referenced by AdvanceFrameCount(), and PauseSimulationEndOfThisFrame().

FrameCount

int32 UAgrarsenseSettings::FrameCount = 0

private

Definition at line 481 of file AgrarsenseSettings.h.

Referenced by AdvanceFrameCount().

GraphicsSettings

FGlobalGraphicsSettings UAgrarsenseSettings::GraphicsSettings

private

Definition at line 477 of file AgrarsenseSettings.h.

Referenced by ApplySettings(), GetAntiAliasingMethod(), GetGrassVisibility(), GetIsUsingVirtualShadowMaps(), GetNaniteMaxPixelsPerEdge(), GetShadowCacheInvalidationBehavior(), GetShadowCSMCache(), GetWorldPositionOffsetRenderDistance(), ParseLaunchArguments(), SetAntiAliasingMethod(), SetGraphicsSettings(), SetGrassVisibility(), SetNaniteMaxPixelsPerEdge(), SetQualityLevel(), SetShadowCacheInvalidationBehavior(), SetShadowCSMCache(), SetUseVirtualShadowMaps(), SetWorldPositionOffsetRenderDistance(), and SetWorldRendering().

IsMainMenu

bool UAgrarsenseSettings::IsMainMenu = false

staticprivate

Definition at line 511 of file AgrarsenseSettings.h.

Referenced by Setup().

MapNames

const TArray<FString> UAgrarsenseSettings::MapNames

private

Initial value:

=
    {
        "mainmenu",
        "rovaniemiforest",
        "vindeln",
        "sensorshowcase",
        "playground"
    }

Definition at line 492 of file AgrarsenseSettings.h.

Referenced by ChangeMapByName().

MapPaths

const TArray<FString> UAgrarsenseSettings::MapPaths

private

Initial value:

=
    {
        "/Game/Agrarsense/Maps/MainMenu",
        "/Game/Agrarsense/Maps/RovaniemiForest/RovaniemiForest",
        "/Game/Agrarsense/Maps/Vindeln/Vindeln",
        "/Game/Agrarsense/Maps/SensorShowCase/SensorShowCase",
        "/Game/Agrarsense/Maps/Playground"
    }

Definition at line 502 of file AgrarsenseSettings.h.

Referenced by ChangeMapByName().

NumberOfPostProcessingSensors

int UAgrarsenseSettings::NumberOfPostProcessingSensors = 0

private

Definition at line 466 of file AgrarsenseSettings.h.

Referenced by OnSensorDestroyed(), and OnSensorSpawned().

OnGraphicsSettingsChanged

FGraphicsSettingsDelegate UAgrarsenseSettings::OnGraphicsSettingsChanged

On Graphics settings changed event

Returns

FGlobalGraphicsSettings struct

Definition at line 390 of file AgrarsenseSettings.h.

Referenced by AInstancedRenderer::BeginPlay(), AInstancedRenderer::EndPlay(), SetAntiAliasingMethod(), SetGrassVisibility(), SetNaniteMaxPixelsPerEdge(), SetQualityLevel(), SetShadowCacheInvalidationBehavior(), SetShadowCSMCache(), SetUseVirtualShadowMaps(), SetWorldPositionOffsetRenderDistance(), and SetWorldRendering().

RenderCustomDepth

bool UAgrarsenseSettings::RenderCustomDepth = false

private

Definition at line 468 of file AgrarsenseSettings.h.

Referenced by GetIsRenderingCustomDepthPass(), SetRenderCustomDepthPass(), and Setup().

SimulationSettings

FGlobalSimulationSettings UAgrarsenseSettings::SimulationSettings

private

Definition at line 474 of file AgrarsenseSettings.h.

Referenced by ApplySettings(), GetGlobalTimeDilation(), GetStartWindowInitiallyMinimized(), ParseLaunchArguments(), PauseSimulation(), PauseSimulationEndOfThisFrame(), SetGlobalTimeDilation(), SetShowSpectatorRainAndSnowfall(), SetSimulationSettings(), SetSpectatorMaxSpeed(), SetStartWindowInitiallyMinimized(), Setup(), and UnPauseSimulation().

---

The documentation for this class was generated from the following files:

• Unreal/Agrarsense/Source/Agrarsense/Settings/AgrarsenseSettings.h
• Unreal/Agrarsense/Source/Agrarsense/Settings/AgrarsenseSettings.cpp