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	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
bool	IsRaytracingSupported () 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 ()
void	SetGraphicsSettings (FGlobalGraphicsSettings NewSettings)
bool	ParseLaunchArguments ()
void	OnSensorSpawned (ASensor *SensorPtr)
void	OnSensorDestroyed (ASensor *SensorPtr)
void	SetUltraWithRaytracingLevel ()
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 38 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 665 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 710 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 134 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 760 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 733 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 868 of file AgrarsenseSettings.cpp.

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

References CurrentWorld.

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

EnableRaytracing()

void UAgrarsenseSettings::EnableRaytracing ( )

private

Definition at line 832 of file AgrarsenseSettings.cpp.

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

References CurrentWorld.

Referenced by SetUltraWithRaytracingLevel().

GetAgrarsenseSettings()

UAgrarsenseSettings * UAgrarsenseSettings::GetAgrarsenseSettings ( )

static

Definition at line 124 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 442 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 191 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 354 of file AgrarsenseSettings.h.

    {
        return GraphicsSettings.QualityLevel;
    }

GetGlobalGraphicsSettings()

static FGlobalGraphicsSettings UAgrarsenseSettings::GetGlobalGraphicsSettings ( )

inlinestatic

Get Global Graphics settings.

Definition at line 426 of file AgrarsenseSettings.h.

    {
        return GetAgrarsenseSettings()->GraphicsSettings;
    }

GetGlobalSimulationSettings()

static FGlobalSimulationSettings UAgrarsenseSettings::GetGlobalSimulationSettings ( )

inlinestatic

Get Global simulation settings.

Definition at line 408 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 544 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 555 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 240 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 437 of file AgrarsenseSettings.cpp.

{
    return RenderCustomDepth;
}

References RenderCustomDepth.

GetIsUsingVirtualShadowMaps()

bool UAgrarsenseSettings::GetIsUsingVirtualShadowMaps

(

)

const

Get is rendering virtual shadow maps on.

Definition at line 432 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 364 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 374 of file AgrarsenseSettings.h.

    {
        return MapPaths;
    }

GetNaniteMaxPixelsPerEdge()

float UAgrarsenseSettings::GetNaniteMaxPixelsPerEdge

(

)

const

Definition at line 375 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 186 of file AgrarsenseSettings.cpp.

{
    return FPlatformMisc::NumberOfWorkerThreadsToSpawn();
}

GetShadowCacheInvalidationBehavior()

EShadowCacheInvalidationBehavior UAgrarsenseSettings::GetShadowCacheInvalidationBehavior

(

)

const

Definition at line 380 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 274 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 135 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 125 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 385 of file AgrarsenseSettings.cpp.

{
    return SimulationSettings.StartCameraWindowsMinimized;
}

References SimulationSettings, and FGlobalSimulationSettings::StartCameraWindowsMinimized.

GetWorldPositionOffsetRenderDistance()

int32 UAgrarsenseSettings::GetWorldPositionOffsetRenderDistance

(

)

const

Definition at line 370 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 399 of file AgrarsenseSettings.h.

    {
        return IsMainMenu;
    }

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

IsRaytracingSupported()

bool UAgrarsenseSettings::IsRaytracingSupported

(

)

const

Definition at line 818 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;
    }
 
    return RayTracingSupported;
}

Referenced by SetUltraWithRaytracingLevel().

IsSimulationPaused()

static bool UAgrarsenseSettings::IsSimulationPaused ( )

inlinestatic

Is simulation paused

Definition at line 417 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 129 of file AgrarsenseSettings.cpp.

{
    Super::LoadSettings(bForceReload);
}

OnSensorDestroyed()

void UAgrarsenseSettings::OnSensorDestroyed ( ASensor *  SensorPtr )

private

Definition at line 785 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 769 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 142 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 615 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 641 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 112 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 447 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 489 of file AgrarsenseSettings.cpp.

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

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

SetBalancedQualityLevel()

void UAgrarsenseSettings::SetBalancedQualityLevel ( )

private

Definition at line 927 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 549 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 567 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 )

private

Change global graphics settings.

Parameters

NewSettings

The new graphics settings to apply.

Definition at line 205 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 245 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 304 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 965 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 324 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 509 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 539 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 395 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 339 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 348 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 279 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 598 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 230 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 582 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 390 of file AgrarsenseSettings.cpp.

{
    SimulationSettings.StartCameraWindowsMinimized = Minimized;
}

References SimulationSettings, and FGlobalSimulationSettings::StartCameraWindowsMinimized.

Referenced by SetSimulationSettings().

SetUltraQualityLevel()

void UAgrarsenseSettings::SetUltraQualityLevel ( )

private

Definition at line 888 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 805 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 42 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) 
    {
        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
}

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 412 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 217 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 318 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 495 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 390 of file AgrarsenseSettings.h.

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

Referenced by FUnrealWindow::FUnrealWindow().

UnPauseSimulation()

void UAgrarsenseSettings::UnPauseSimulation

(

)

Unpause the simulator immediately.

Definition at line 628 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 437 of file AgrarsenseSettings.h.

Member Data Documentation

AdvanceFramesHandle

FDelegateHandle UAgrarsenseSettings::AdvanceFramesHandle

private

Definition at line 481 of file AgrarsenseSettings.h.

Referenced by AdvanceFrameCount().

CurrentMapName

FString UAgrarsenseSettings::CurrentMapName

staticprivate

Definition at line 513 of file AgrarsenseSettings.h.

Referenced by Setup().

CurrentWorld

TWeakObjectPtr<UWorld> UAgrarsenseSettings::CurrentWorld = nullptr

private

Definition at line 472 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 485 of file AgrarsenseSettings.h.

Referenced by AdvanceFrameCount(), and PauseSimulationEndOfThisFrame().

FrameCount

int32 UAgrarsenseSettings::FrameCount = 0

private

Definition at line 482 of file AgrarsenseSettings.h.

Referenced by AdvanceFrameCount().

GraphicsSettings

FGlobalGraphicsSettings UAgrarsenseSettings::GraphicsSettings

private

Definition at line 478 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 512 of file AgrarsenseSettings.h.

Referenced by Setup().

MapNames

const TArray<FString> UAgrarsenseSettings::MapNames

private

Initial value:

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

Definition at line 493 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 503 of file AgrarsenseSettings.h.

Referenced by ChangeMapByName().

NumberOfPostProcessingSensors

int UAgrarsenseSettings::NumberOfPostProcessingSensors = 0

private

Definition at line 467 of file AgrarsenseSettings.h.

Referenced by OnSensorDestroyed(), and OnSensorSpawned().

OnGraphicsSettingsChanged

FGraphicsSettingsDelegate UAgrarsenseSettings::OnGraphicsSettingsChanged

On Graphics settings changed event

Returns

FGlobalGraphicsSettings struct

Definition at line 384 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 469 of file AgrarsenseSettings.h.

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

SimulationSettings

FGlobalSimulationSettings UAgrarsenseSettings::SimulationSettings

private

Definition at line 475 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