ShowFlag.Niagara

ShowFlag.Niagara

#Overview

name: ShowFlag.Niagara

This variable is created as a Console Variable (cvar).

It is referenced in 60 C++ source files.

#Summary

#Usage in the C++ source code

The purpose of ShowFlag.Niagara is to control the visibility of Niagara particle systems in the rendering pipeline. It is specifically used to toggle the rendering of Niagara effects in the game view or scene capture.

ShowFlag.Niagara is primarily relied upon by the Niagara plugin and the rendering system within Unreal Engine. It is used to determine whether Niagara renderers should be processed and displayed in the current view.

The value of this variable is typically set through the engine’s show flags system, which allows developers and users to toggle various rendering features on and off. It can be controlled via the engine’s UI, console commands, or programmatically.

This variable interacts closely with other show flags, particularly the general Particles show flag. While the Particles flag controls the visibility of all particle systems, the Niagara flag specifically targets Niagara-based effects.

Developers should be aware that this show flag is marked as SHOWFLAG_FIXED_IN_SHIPPING(1), which means it’s set to be always enabled in shipping builds. This ensures that Niagara effects are always visible in the final product unless explicitly disabled through other means.

Best practices when using this variable include:

  1. Using it for debugging and performance testing, enabling/disabling Niagara effects to isolate rendering issues.
  2. Considering its interaction with other show flags, especially the general Particles flag.
  3. Being aware that it may not have an effect in shipping builds due to the FIXED_IN_SHIPPING setting.

The associated variable ‘Niagara’ is used in various parts of the Niagara system, particularly in the rendering pipeline. It serves a similar purpose to ShowFlag.Niagara, controlling the visibility and processing of Niagara effects. This variable is used in shader compilation, scene proxy creation, and view relevance calculations for Niagara systems.

When working with the ‘Niagara’ variable:

  1. It’s often used in conditional statements to determine if Niagara-related code should be executed.
  2. It’s typically checked alongside other rendering conditions, such as the general Particles show flag.
  3. Its value is usually derived from the engine’s show flags system, reflecting the state of ShowFlag.Niagara.

Developers should ensure that checks for this variable are properly implemented in custom rendering code that interacts with Niagara systems to maintain consistency with the engine’s visibility settings.

#References in C++ code

#Callsites

This variable is referenced in the following C++ source code:

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/ShowFlagsValues.inl:191

Scope: file

Source code excerpt:

SHOWFLAG_ALWAYS_ACCESSIBLE(Particles, SFG_Normal, NSLOCTEXT("UnrealEd", "ParticlesSF", "Particle Sprites"))
/** Niagara, for now SHOWFLAG_ALWAYS_ACCESSIBLE because it's exposed in SceneCapture */
SHOWFLAG_FIXED_IN_SHIPPING(1, Niagara, SFG_Advanced, NSLOCTEXT("UnrealEd", "NiagaraSF", "Niagara Renderers"))
/** HeterogeneousVolumes, for now SHOWFLAG_ALWAYS_ACCESSIBLE because it's exposed in SceneCapture */
SHOWFLAG_FIXED_IN_SHIPPING(1, HeterogeneousVolumes, SFG_Advanced, NSLOCTEXT("UnrealEd", "HeterogeneousVolumesSF", "Heterogeneous Volumes"))
/** if SkeletalMeshes are getting rendered, for now SHOWFLAG_ALWAYS_ACCESSIBLE because it's exposed in SceneCapture */
SHOWFLAG_ALWAYS_ACCESSIBLE(SkeletalMeshes, SFG_Normal, NSLOCTEXT("UnrealEd", "SkeletalMeshesSF", "Skeletal Meshes"))
/** if the builder brush (editor) is getting rendered */
SHOWFLAG_FIXED_IN_SHIPPING(0, BuilderBrush, SFG_Hidden, NSLOCTEXT("UnrealEd", "BuilderBrushSF", "Builder Brush"))

#Associated Variable and Callsites

This variable is associated with another variable named Niagara. They share the same value. See the following C++ source code.

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraComponent.cpp:194

Scope (from outer to inner):

file
function     FNiagaraSceneProxy::FNiagaraSceneProxy

Source code excerpt:

	if (SystemInstanceController && NiagaraSystem)
	{
		LLM_SCOPE(ELLMTag::Niagara);

		RenderData = SystemInstanceController->CreateSystemRenderData(GetScene().GetFeatureLevel());
		ComputeDispatchInterface = SystemInstanceController->GetComputeDispatchInterface();

		bAlwaysHasVelocity = RenderData->HasAnyMotionBlurEnabled();
		bIsHeterogeneousVolume = RenderData->HasAnyHeterogeneousVolumesEnabled();

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraComponent.cpp:254

Scope (from outer to inner):

file
function     void FNiagaraSceneProxy::CreateRenderThreadResources

Source code excerpt:

	if (RenderData)
	{
		LLM_SCOPE(ELLMTag::Niagara);
		RenderData->CreateRenderThreadResources(RHICmdList);
	}
}

void FNiagaraSceneProxy::OnTransformChanged(FRHICommandListBase& RHICmdList)
{

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraComponent.cpp:280

Scope (from outer to inner):

file
function     FPrimitiveViewRelevance FNiagaraSceneProxy::GetViewRelevance

Source code excerpt:

	Relevance							= RenderData->GetViewRelevance(*View, *this);
	Relevance.bDynamicRelevance			= true;
	Relevance.bDrawRelevance			= IsShown(View) && View->Family->EngineShowFlags.Particles && View->Family->EngineShowFlags.Niagara;
	Relevance.bRenderCustomDepth		= ShouldRenderCustomDepth();
	Relevance.bShadowRelevance			= IsShadowCast(View);
	Relevance.bRenderInMainPass			= ShouldRenderInMainPass();
	Relevance.bUsesLightingChannels		= GetLightingChannelMask() != GetDefaultLightingChannelMask();
	Relevance.bTranslucentSelfShadow	= bCastVolumetricTranslucentShadow;
	Relevance.bVelocityRelevance		= DrawsVelocity() && Relevance.bOpaque && Relevance.bRenderInMainPass;

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraComponent.cpp:501

Scope (from outer to inner):

file
function     void FNiagaraSceneProxy::GetDynamicMeshElements

Source code excerpt:

	}

	if (ViewFamily.EngineShowFlags.Particles && ViewFamily.EngineShowFlags.Niagara)
	{
		for (int32 ViewIndex = 0; ViewIndex < Views.Num(); ViewIndex++)
		{
			if (VisibilityMap & (1 << ViewIndex))
			{
				RenderBounds(Collector.GetPDI(ViewIndex), ViewFamily.EngineShowFlags, GetBounds(), IsSelected());

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraComponent.cpp:805

Scope (from outer to inner):

file
function     void UNiagaraComponent::TickComponent

Source code excerpt:

void UNiagaraComponent::TickComponent(float DeltaSeconds, enum ELevelTick TickType, FActorComponentTickFunction* ThisTickFunction)
{
	LLM_SCOPE(ELLMTag::Niagara);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	SCOPE_CYCLE_COUNTER(STAT_NiagaraComponentTick);

	if (!::IsValid(Asset))
	{
		//-TODO: If our Asset is null or has become Garbage should we force deactive the component / ticking?

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraComponent.cpp:1116

Scope (from outer to inner):

file
function     bool UNiagaraComponent::InitializeSystem

Source code excerpt:

	if (SystemInstanceController.IsValid() == false)
	{
		LLM_SCOPE(ELLMTag::Niagara);
		CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
		
		UWorld* World = GetWorld();
		check(World);
		check(Asset);

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraComponent.cpp:2199

Scope (from outer to inner):

file
function     void UNiagaraComponent::SendRenderDynamicData_Concurrent

Source code excerpt:

void UNiagaraComponent::SendRenderDynamicData_Concurrent()
{
	LLM_SCOPE(ELLMTag::Niagara);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	SCOPE_CYCLE_COUNTER(STAT_NiagaraComponentSendRenderData);
	PARTICLE_PERF_STAT_CYCLES_GT(FParticlePerfStatsContext(GetWorld(), GetAsset(), this), EndOfFrame);

	Super::SendRenderDynamicData_Concurrent();

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraComponent.cpp:2314

Scope (from outer to inner):

file
function     FPrimitiveSceneProxy* UNiagaraComponent::CreateSceneProxy

Source code excerpt:

FPrimitiveSceneProxy* UNiagaraComponent::CreateSceneProxy()
{
	LLM_SCOPE(ELLMTag::Niagara);
	SCOPE_CYCLE_COUNTER(STAT_NiagaraCreateSceneProxy);
	SCOPE_CYCLE_COUNTER(STAT_NiagaraOverview_GT);
    
#if UE_WITH_PSO_PRECACHING
	if (Asset != nullptr)
	{

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraEmitter.cpp:2000

Scope (from outer to inner):

file
function     void UNiagaraEmitter::UpdateEmitterAfterLoad

Source code excerpt:

	}
	bFullyLoaded = true;
	LLM_SCOPE(ELLMTag::Niagara);
	
#if WITH_EDITORONLY_DATA
	check(IsInGameThread());

	// We remove emitters and scripts on dedicated servers (and platforms which don't use AV data), so skip further work.
	const bool bIsDedicatedServer = !GIsClient && GIsServer;

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraFunctionLibrary.cpp:206

Scope (from outer to inner):

file
function     UNiagaraComponent* UNiagaraFunctionLibrary::SpawnSystemAttachedWithParams

Source code excerpt:

UNiagaraComponent* UNiagaraFunctionLibrary::SpawnSystemAttachedWithParams(const FFXSystemSpawnParameters& SpawnParams)
{
	LLM_SCOPE(ELLMTag::Niagara);
	
	UNiagaraComponent* PSC = nullptr;
	UNiagaraSystem* NiagaraSystem = Cast<UNiagaraSystem>(SpawnParams.SystemTemplate);
	if (NiagaraSystem)
	{
		if (!SpawnParams.AttachToComponent)

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraGpuComputeDispatch.cpp:1823

Scope (from outer to inner):

file
function     void FNiagaraGpuComputeDispatch::PreInitViews

Source code excerpt:

{
	SCOPE_CYCLE_COUNTER(STAT_NiagaraGPUDispatchSetup_RT);
	RDG_CSV_STAT_EXCLUSIVE_SCOPE(GraphBuilder, Niagara);
	LLM_SCOPE(ELLMTag::Niagara);

	bIsFirstViewFamily = CurrentFamily ? CurrentFamily == ViewFamilies[0] : true;
	bIsLastViewFamily = CurrentFamily ? CurrentFamily == ViewFamilies.Last() : true;
	bRequiresReadback = false;
#if WITH_EDITOR
	bRaisedWarningThisFrame = false;

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraGpuComputeDispatch.cpp:1971

Scope (from outer to inner):

file
function     void FNiagaraGpuComputeDispatch::PostInitViews

Source code excerpt:

void FNiagaraGpuComputeDispatch::PostInitViews(FRDGBuilder& GraphBuilder, TConstStridedView<FSceneView> Views, bool bAllowGPUParticleUpdate)
{
	LLM_SCOPE(ELLMTag::Niagara);

	bAllowGPUParticleUpdate = bAllowGPUParticleUpdate && Views.Num() > 0 && Views[0].AllowGPUParticleUpdate();

	if (bAllowGPUParticleUpdate && FNiagaraUtilities::AllowGPUParticles(GetShaderPlatform()))
	{
		RDG_CSV_STAT_EXCLUSIVE_SCOPE(GraphBuilder, Niagara);

		ExecuteTicks(GraphBuilder, Views, ENiagaraGpuComputeTickStage::PostInitViews);
	}
}

BEGIN_SHADER_PARAMETER_STRUCT(FNiagaraGpuComputeDispatchParameters,)

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraGpuComputeDispatch.cpp:1996

Scope: file

Source code excerpt:

void FNiagaraGpuComputeDispatch::PostRenderOpaque(FRDGBuilder& GraphBuilder, TConstStridedView<FSceneView> Views, FSceneUniformBuffer &SceneUniformBuffer, bool bAllowGPUParticleUpdate)
{
	LLM_SCOPE(ELLMTag::Niagara);

	bAllowGPUParticleUpdate = bAllowGPUParticleUpdate && Views.Num() > 0 && Views[0].AllowGPUParticleUpdate();

	// If we are during a scene render cache the GDF information for any potential tick flushing
	// This fixes issues with distance field collisions (for example) where we may be scrubbing backwards and are force to flush to avoid TDRs / RDG pass limits
	// The alternative to this would be to query the FSceneInterface but we currently do not have a clean way to do this as the GDF clipmaps are built transiently plus the ViewStates do not exist

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraGpuComputeDispatch.cpp:2183

Scope (from outer to inner):

file
function     void FNiagaraGpuComputeDispatch::PreRender

Source code excerpt:

	}

	LLM_SCOPE(ELLMTag::Niagara);
}

void FNiagaraGpuComputeDispatch::OnDestroy()
{
	FNiagaraWorldManager::OnComputeDispatchInterfaceDestroyed(this);
	FFXSystemInterface::OnDestroy();

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraModule.cpp:51

Scope: file

Source code excerpt:

#endif

IMPLEMENT_MODULE(INiagaraModule, Niagara);

#define LOCTEXT_NAMESPACE "NiagaraModule"

int32 FNiagaraCompileHashVisitor::LogCompileIdGeneration = 0;
static FAutoConsoleVariableRef CVarLogCompileIdGeneration(
	TEXT("fx.LogCompileIdGeneration"),

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraModule.cpp:300

Scope (from outer to inner):

file
function     void INiagaraModule::StartupModule

Source code excerpt:

	FNiagaraTypeHelper::InitLWCTypes();

	LLM_SCOPE(ELLMTag::Niagara);
	FNiagaraTypeDefinition::Init();
	FNiagaraTypeRegistry::ProcessRegistryQueue();
	FNiagaraTypeHelper::RegisterLWCTypes();

	if (IsRunningCookCommandlet())
	{

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraRendererLights.cpp:49

Scope (from outer to inner):

file
function     FPrimitiveViewRelevance FNiagaraRendererLights::GetViewRelevance

Source code excerpt:

{
	FPrimitiveViewRelevance Result;
	Result.bDrawRelevance = bHasLights && SceneProxy->IsShown(View) && View->Family->EngineShowFlags.Particles && View->Family->EngineShowFlags.Niagara;
	Result.bShadowRelevance = false;
	Result.bDynamicRelevance = false;
	Result.bOpaque = false;
	Result.bHasSimpleLights = bHasLights;

	return Result;

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraRendererProperties.cpp:844

Scope (from outer to inner):

file
function     void UNiagaraRendererProperties::GetAssetTagsForContext

Source code excerpt:

		{
			FString Key = Class->GetName();
			Key.ReplaceInline(TEXT("Niagara"), TEXT(""));
			Key.ReplaceInline(TEXT("Properties"), TEXT(""));
			NumericKeys.Add(FName(Key)) = NumInstances;
		}
	}
}

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraSystem.cpp:69

Scope (from outer to inner):

file
namespace    NiagaraScriptCookStats
lambda-function

Source code excerpt:

	static FCookStatsManager::FAutoRegisterCallback RegisterNiagaraSystemCookStats([](FCookStatsManager::AddStatFuncRef AddStat)
	{
		AddStat(TEXT("Niagara"), FCookStatsManager::CreateKeyValueArray(TEXT("NiagaraSystemWaitForCompilationCompleteTime"), NiagaraSystemWaitForCompilationCompleteTime));
	});
}
#endif

namespace NiagaraSystemPrivate
{

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraSystem.cpp:2201

Scope (from outer to inner):

file
function     void UNiagaraSystem::CacheFromCompiledData

Source code excerpt:

void UNiagaraSystem::CacheFromCompiledData()
{
	LLM_SCOPE(ELLMTag::Niagara);
	const FNiagaraDataSetCompiledData& SystemDataSet = SystemCompiledData.DataSetCompiledData;
	const UNiagaraSettings* NiagaraSettings = GetDefault<UNiagaraSettings>();

	bNeedsAsyncOptimize = true;

	// Reset static buffers

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraSystem.cpp:2766

Scope (from outer to inner):

file
function     void UNiagaraSystem::WaitForCompilationComplete

Source code excerpt:

void UNiagaraSystem::WaitForCompilationComplete(bool bIncludingGPUShaders, bool bShowProgress)
{
	LLM_SCOPE(ELLMTag::Niagara);
	TRACE_CPUPROFILER_EVENT_SCOPE(WaitForNiagaraCompilation);
	TRACE_CPUPROFILER_EVENT_SCOPE_TEXT_ON_CHANNEL(*GetPathName(), NiagaraChannel);
	COOK_STAT(FScopedDurationTimer DurationTimer(NiagaraScriptCookStats::NiagaraSystemWaitForCompilationCompleteTime));

	if (bNeedsRequestCompile)
	{

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraSystemInstance.cpp:1021

Scope (from outer to inner):

file
function     void FNiagaraSystemInstance::ReInitInternal

Source code excerpt:

	SCOPE_CYCLE_COUNTER(STAT_NiagaraOverview_GT);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	LLM_SCOPE(ELLMTag::Niagara);

	Age = 0;
	TickCount = 0;
	LocalBounds = FBox(FVector::ZeroVector, FVector::ZeroVector);
	CachedDeltaSeconds = 0.0f;
	bAlreadyBound = false;

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraSystemInstance.cpp:2216

Scope (from outer to inner):

file
function     void FNiagaraSystemInstance::ManualTick

Source code excerpt:

	SCOPE_CYCLE_COUNTER(STAT_NiagaraSystemInst_ComponentTickGT);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	LLM_SCOPE(ELLMTag::Niagara);

	if (IsDisabled())
	{
		return;
	}

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraSystemInstance.cpp:2237

Scope (from outer to inner):

file
function     void FNiagaraSystemInstance::SimCacheTick_GameThread

Source code excerpt:

	SCOPE_CYCLE_COUNTER(STAT_NiagaraSystemInst_TickGT);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	LLM_SCOPE(ELLMTag::Niagara);

	check(IsInGameThread());
	check(bSolo);

	FNiagaraCrashReporterScope CRScope(this);

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraSystemInstance.cpp:2441

Scope (from outer to inner):

file
function     void FNiagaraSystemInstance::Tick_GameThread

Source code excerpt:

	SCOPE_CYCLE_COUNTER(STAT_NiagaraOverview_GT);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	LLM_SCOPE(ELLMTag::Niagara);

	FNiagaraCrashReporterScope CRScope(this);

	FScopeCycleCounter SystemStat(System->GetStatID(true, false));

	// We should have no pending async operations, but wait to be safe

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraSystemInstance.cpp:2502

Scope (from outer to inner):

file
function     void FNiagaraSystemInstance::Tick_Concurrent

Source code excerpt:

	SCOPE_CYCLE_COUNTER(STAT_NiagaraOverview_GT_CNC);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	LLM_SCOPE(ELLMTag::Niagara);
	FScopeCycleCounterUObject AdditionalScope(GetSystem(), GET_STATID(STAT_NiagaraOverview_GT_CNC));

	FNiagaraCrashReporterScope CRScope(this);

	// Reset values that will be accumulated during emitter tick.
	TotalGPUParamSize = 0;

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraSystemInstance.cpp:2685

Scope (from outer to inner):

file
function     void FNiagaraSystemInstance::FinalizeTick_GameThread

Source code excerpt:

	SCOPE_CYCLE_COUNTER(STAT_NiagaraSystemInst_FinalizeGT);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	LLM_SCOPE(ELLMTag::Niagara);

	// Ensure concurrent work is complete and clear the finalize ref
	check(ConcurrentTickGraphEvent == nullptr || ConcurrentTickGraphEvent->IsComplete());
	ConcurrentTickGraphEvent = nullptr;
	check(ConcurrentTickBatchGraphEvent == nullptr || ConcurrentTickBatchGraphEvent->IsComplete());
	ConcurrentTickBatchGraphEvent = nullptr;

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraSystemSimulation.cpp:1112

Scope (from outer to inner):

file
function     void FNiagaraSystemSimulation::Tick_GameThread_Internal

Source code excerpt:

	SCOPE_CYCLE_COUNTER(STAT_NiagaraSystemSim_TickGT);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	LLM_SCOPE(ELLMTag::Niagara);
	FScopeCycleCounterUObject AdditionalScope(GetSystem(), GET_STATID(STAT_NiagaraOverview_GT_CNC));


#if STATS
	FScopeCycleCounter SystemStatCounter(System->GetStatID(true, false));
#endif

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraSystemSimulation.cpp:1327

Scope (from outer to inner):

file
function     void FNiagaraSystemSimulation::UpdateTickGroups_GameThread

Source code excerpt:

	SCOPE_CYCLE_COUNTER(STAT_NiagaraOverview_GT);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	LLM_SCOPE(ELLMTag::Niagara);
	FScopeCycleCounterUObject AdditionalScope(GetSystem(), GET_STATID(STAT_NiagaraOverview_GT_CNC));

	FNiagaraWorldManager* WorldManager = FNiagaraWorldManager::Get(World);
	check(WorldManager != nullptr);

	check(System != nullptr);

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraSystemSimulation.cpp:1394

Scope (from outer to inner):

file
function     void FNiagaraSystemSimulation::Spawn_GameThread

Source code excerpt:

	SCOPE_CYCLE_COUNTER(STAT_NiagaraOverview_GT);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	LLM_SCOPE(ELLMTag::Niagara);

	FScopeCycleCounterUObject AdditionalScope(System, GET_STATID(STAT_NiagaraOverview_GT_CNC));

	FNiagaraCrashReporterScope CRScope(this);

	bInSpawnPhase = true;

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraSystemSimulation.cpp:1671

Scope (from outer to inner):

file
function     void FNiagaraSystemSimulation::Tick_Concurrent

Source code excerpt:

	SCOPE_CYCLE_COUNTER(STAT_NiagaraOverview_GT_CNC);
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	LLM_SCOPE(ELLMTag::Niagara);

	FScopeCycleCounterUObject AdditionalScope(Context.System, GET_STATID(STAT_NiagaraOverview_GT_CNC));
	if (!bCanExecute || !Context.Instances.Num())
	{
		return;
	}

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraWorldManager.cpp:623

Scope (from outer to inner):

file
function     FNiagaraSystemSimulationRef FNiagaraWorldManager::GetSystemSimulation

Source code excerpt:

FNiagaraSystemSimulationRef FNiagaraWorldManager::GetSystemSimulation(ETickingGroup TickGroup, UNiagaraSystem* System)
{
	LLM_SCOPE(ELLMTag::Niagara);

	int32 ActualTickGroup = NiagaraWorldManagerInternal::GetNiagaraTickGroup(TickGroup);
	if (ActiveNiagaraTickGroup == ActualTickGroup)
	{
		int32 DemotedTickGroup = NiagaraWorldManagerInternal::GetNiagaraTickGroup((ETickingGroup)(TickGroup + 1));
		ActualTickGroup = DemotedTickGroup == ActualTickGroup ? 0 : DemotedTickGroup;

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraWorldManager.cpp:1023

Scope (from outer to inner):

file
function     void FNiagaraWorldManager::TickStart

Source code excerpt:

{
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	LLM_SCOPE(ELLMTag::Niagara);
	SCOPE_CYCLE_COUNTER(STAT_NiagaraWorldManTick);

	DataChannelManager->BeginFrame(DeltaSeconds);

#if WITH_NIAGARA_LEAK_DETECTOR
	if (ComponentLeakDetector.IsValid() && HasActiveWorld())

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraWorldManager.cpp:1044

Scope (from outer to inner):

file
function     void FNiagaraWorldManager::PostActorTick

Source code excerpt:

{
	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	LLM_SCOPE(ELLMTag::Niagara);
	SCOPE_CYCLE_COUNTER(STAT_NiagaraWorldManTick);
	SCOPE_CYCLE_COUNTER(STAT_NiagaraOverview_GT);
	QUICK_SCOPE_CYCLE_COUNTER(STAT_NiagaraPostActorTick_GT);

	NiagaraWorldManagerInternal::ExecuteGlobalDeferredCallbacks();

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/Niagara/Private/NiagaraWorldManager.cpp:1275

Scope (from outer to inner):

file
function     void FNiagaraWorldManager::Tick

Source code excerpt:


	CSV_SCOPED_TIMING_STAT_EXCLUSIVE(Effects);
	LLM_SCOPE(ELLMTag::Niagara);
	SCOPE_CYCLE_COUNTER(STAT_NiagaraWorldManTick);
	SCOPE_CYCLE_COUNTER(STAT_NiagaraOverview_GT);

	// Execute any global and local deferred functions
	NiagaraWorldManagerInternal::ExecuteGlobalDeferredCallbacks();
	DeferredMethods.ExecuteAndClear();

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/Customizations/NiagaraComponentDetails.cpp:133

Scope (from outer to inner):

file
function     void FNiagaraComponentDetails::CustomizeDetails

Source code excerpt:

		const FText DisplayName = LOCTEXT("EffectsSectionName", "Effects");
		TSharedRef<FPropertySection> Section = PropertyModule.FindOrCreateSection("NiagaraComponent", "Effects", DisplayName);
		Section->AddCategory(TEXT("Niagara"));
		Section->AddCategory(ParamCategoryName);
		Section->AddCategory(ParamUtilitiesName); 
		Section->AddCategory(TEXT("Activation"));
		Section->AddCategory(ScriptCategoryName);
		Section->AddCategory(TEXT("Randomness"));
		Section->AddCategory(TEXT("Warmup"));

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/EdGraphSchema_Niagara.cpp:226

Scope (from outer to inner):

file
function     TSharedPtr<FNiagaraAction_NewNode> AddNewNodeMenuAction

Source code excerpt:

	FText Keywords = FText(),
	FNiagaraActionSourceData SourceData = FNiagaraActionSourceData(
		EScriptSource::Niagara, FText::FromString(TEXT("Niagara")), true))
{
	const UNiagaraEditorSettings* NiagaraEditorSettings = GetDefault<UNiagaraEditorSettings>();
	TSharedPtr<FNiagaraAction_NewNode> NewAction = MakeShared<FNiagaraAction_NewNode>(DisplayName, Section, NestedCategories, Tooltip, Keywords);
	if (ensureMsgf(InNodeTemplate == nullptr || NiagaraEditorSettings->IsVisibleClass(InNodeTemplate->GetClass()),
		TEXT("Can not create a menu action for a node of class %s."), *InNodeTemplate->GetClass()->GetName()))
	{

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/NiagaraCompilationTasks.cpp:41

Scope (from outer to inner):

file
namespace    NiagaraSystemCookStats
lambda-function

Source code excerpt:

	static FCookStatsManager::FAutoRegisterCallback RegisterNiagaraCompilationCookStats([](FCookStatsManager::AddStatFuncRef AddStat)
	{
		AddStat(TEXT("Niagara"), FCookStatsManager::CreateKeyValueArray(TEXT("NiagaraScriptTranslationCount"), ScriptTranslationCount));
		AddStat(TEXT("Niagara"), FCookStatsManager::CreateKeyValueArray(TEXT("NiagaraCpuScriptCompileCount"), CpuScriptCompileCount));
		AddStat(TEXT("Niagara"), FCookStatsManager::CreateKeyValueArray(TEXT("NiagaraCpuScriptDdcCacheHitCount"), CpuScriptDdcCacheHitCount));
		AddStat(TEXT("Niagara"), FCookStatsManager::CreateKeyValueArray(TEXT("NiagaraCpuScriptDdcCacheMissCount"), CpuScriptDdcCacheMissCount));
		AddStat(TEXT("Niagara"), FCookStatsManager::CreateKeyValueArray(TEXT("NiagaraGpuScriptCompileCount"), GpuScriptCompileCount));
		AddStat(TEXT("Niagara"), FCookStatsManager::CreateKeyValueArray(TEXT("NiagaraGpuScriptDdcCacheHitCount"), GpuScriptDdcCacheHitCount));
		AddStat(TEXT("Niagara"), FCookStatsManager::CreateKeyValueArray(TEXT("NiagaraGpuScriptDdcCacheMissCount"), GpuScriptDdcCacheMissCount));
	});
}
#endif


namespace NiagaraCompilationTasksImpl

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/NiagaraEditorSettings.cpp:73

Scope (from outer to inner):

file
function     FLinearColor UNiagaraEditorSettings::GetSourceColor

Source code excerpt:

FLinearColor UNiagaraEditorSettings::GetSourceColor(EScriptSource  Source) const
{
	if(Source == EScriptSource::Niagara)
	{
		return ActionColors.NiagaraColor;
	}
	else if(Source == EScriptSource::Game)
	{
		return ActionColors.GameColor;

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/NiagaraEditorUtilities.cpp:1954

Scope (from outer to inner):

file
function     TTuple<EScriptSource, FText> FNiagaraEditorUtilities::GetScriptSource

Source code excerpt:

			{
				FString PluginName = LeftPart.RightChop(ContentFoundIndex + 1);
				return TTuple<EScriptSource, FText>(EScriptSource::Niagara, FText::FromString(PluginName));
			}
		}
	}
	
	if(FPaths::IsUnderDirectory(PackagePathLocal, FPaths::EnginePluginsDir()) || FPaths::IsUnderDirectory(PackagePathLocal, FPaths::ProjectPluginsDir()))
	{

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/NiagaraGraph.cpp:443

Scope (from outer to inner):

file
function     void UNiagaraGraph::PostLoad

Source code excerpt:

void UNiagaraGraph::PostLoad()
{
	LLM_SCOPE(ELLMTag::Niagara);
	check(!bIsForCompilationOnly);

	Super::PostLoad();

	//////////////////////////////////////////////////////////////////////////
	/// GLOBAL CLEANUP/INVALIDATION

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/ViewModels/Stack/NiagaraStackScriptItemGroup.cpp:82

Scope (from outer to inner):

file
class        class FScriptGroupAddAction : public INiagaraStackItemGroupAddAction
function     static TSharedRef<FScriptGroupAddAction> CreateModuleActionFromScratchPadScript

Source code excerpt:


		FAssetData Data = FAssetData(ModuleScript);
		FNiagaraActionSourceData SourceData(EScriptSource::Niagara, FText::FromString("Scratch Pad"), true);
		return MakeShareable(new FScriptGroupAddAction(DisplayName, {Category.ToString()}, Description, Keywords, bSuggested, bIsInLibrary, FNiagaraVariable(), false, FAssetData(), ModuleScript, false, false, SourceData));
	}

	static TSharedRef<FScriptGroupAddAction> CreateExistingParameterModuleAction(FNiagaraVariable ParameterVariable)
	{
		FText Category = LOCTEXT("ExistingParameterModuleCategory", "Set Specific Parameters");

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/ViewModels/Stack/NiagaraStackScriptItemGroup.cpp:192

Scope (from outer to inner):

file
class        class FScriptGroupAddAction : public INiagaraStackItemGroupAddAction
function     FScriptGroupAddAction

Source code excerpt:

		FNiagaraVariable InModuleParameterVariable, bool bInRenameParameterOnAdd,
		FAssetData InModuleAssetData, UNiagaraScript* InModuleScript,
		bool bInIsNewScratchModuleAction, bool bInIsNewSetSpecificModuleAction, FNiagaraActionSourceData InSourceData = FNiagaraActionSourceData(EScriptSource::Niagara, FText::FromString(TEXT("Niagara")), true))

		: DisplayName(InDisplayName)
		, Categories(InCategories)
		, Description(InDescription)
		, Keywords(InKeywords)
		, bSuggested(bInSuggested)

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Private/Widgets/SNiagaraFilterBox.cpp:14

Scope: file

Source code excerpt:

TMap<EScriptSource, bool> SNiagaraSourceFilterBox::SourceState
{
	{EScriptSource::Niagara, true},
	{EScriptSource::Game, true},
	{EScriptSource::Plugins, false},
	{EScriptSource::Developer, false},
};

TOptional<ENiagaraScriptTemplateSpecification> SNiagaraTemplateTabBox::CachedActiveTab;

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraEditor/Public/NiagaraActions.h:26

Scope: file

Source code excerpt:

enum class EScriptSource : uint8
{
	Niagara,
	Game,
	Plugins,
	Developer,
	Unknown
};

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraEditorWidgets/Private/Stack/SNiagaraStackFunctionInputValue.cpp:1109

Scope (from outer to inner):

file
function     TArray<TSharedPtr<FNiagaraMenuAction_Generic>> SNiagaraStackFunctionInputValue::CollectDynamicInputActionsForReassign

Source code excerpt:

		if(ScratchPadDynamicInputs.Contains(DynamicInputScript))
		{
			Source = TTuple<EScriptSource, FText>(EScriptSource::Niagara, FText::FromString("Scratch Pad"));
			bIsInLibrary = true;
		}
		
		TSharedPtr<FNiagaraMenuAction_Generic> DynamicInputAction(new FNiagaraMenuAction_Generic(
			FNiagaraMenuAction_Generic::FOnExecuteAction::CreateStatic(&ReassignDynamicInputScript, FunctionInput, DynamicInputScript),
			DisplayName, ScriptData->bSuggested ? ENiagaraMenuSections::Suggested : ENiagaraMenuSections::General, {CategoryName.ToString()}, Tooltip, ScriptData->Keywords

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraEditorWidgets/Private/Stack/SNiagaraStackFunctionInputValue.cpp:1219

Scope (from outer to inner):

file
function     TArray<TSharedPtr<FNiagaraMenuAction_Generic>> SNiagaraStackFunctionInputValue::CollectActions

Source code excerpt:

	bool bIsDataInterfaceOrObject = FunctionInput->GetInputType().IsDataInterface() || FunctionInput->GetInputType().IsUObject();

	FNiagaraActionSourceData NiagaraSourceData(EScriptSource::Niagara, FText::FromString(TEXT("Niagara")), true);
	
	// Set a local value
	{
		bool bCanSetLocalValue = 
			(FunctionInput->GetInputType().IsDataInterface() && FunctionInput->GetValueMode() != UNiagaraStackFunctionInput::EValueMode::Data) ||
			(bIsDataInterfaceOrObject == false && FunctionInput->GetValueMode() != UNiagaraStackFunctionInput::EValueMode::Local);

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraEditorWidgets/Private/Stack/SNiagaraStackFunctionInputValue.cpp:1262

Scope (from outer to inner):

file
function     TArray<TSharedPtr<FNiagaraMenuAction_Generic>> SNiagaraStackFunctionInputValue::CollectActions

Source code excerpt:

			if(ScratchPadDynamicInputs.Contains(DynamicInputScript))
			{
				Source = TTuple<EScriptSource, FText>(EScriptSource::Niagara, FText::FromString("Scratch Pad"));
				bIsInLibrary = true;
			}
			
			TSharedPtr<FNiagaraMenuAction_Generic> DynamicInputAction(new FNiagaraMenuAction_Generic(
                FNiagaraMenuAction_Generic::FOnExecuteAction::CreateSP(this, &SNiagaraStackFunctionInputValue::DynamicInputScriptSelected, DynamicInputScript),
                DisplayName, ScriptData->bSuggested ? ENiagaraMenuSections::Suggested : ENiagaraMenuSections::General, {CategoryName.ToString()}, Tooltip, ScriptData->Keywords));

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraShader/Private/NiagaraDebugShaders.cpp:169

Scope (from outer to inner):

file
function     BEGIN_SHADER_PARAMETER_STRUCT

Source code excerpt:

END_SHADER_PARAMETER_STRUCT()

IMPLEMENT_GLOBAL_SHADER(FNiagaraDebugDrawLineVS, "/Plugin/FX/Niagara/Private/NiagaraDebugDraw.usf", "MainVS", SF_Vertex);
IMPLEMENT_GLOBAL_SHADER(FNiagaraDebugDrawLinePS, "/Plugin/FX/Niagara/Private/NiagaraDebugDraw.usf", "MainPS", SF_Pixel);

//////////////////////////////////////////////////////////////////////////

void NiagaraDebugShaders::ClearUAV(FRDGBuilder& GraphBuilder, FRDGBufferUAVRef UAV, FUintVector4 ClearValues, uint32 UIntsToSet)
{
	check(UIntsToSet > 0);

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraShader/Private/NiagaraShaderModule.cpp:57

Scope (from outer to inner):

file
function     UNiagaraDataInterfaceBase* INiagaraShaderModule::RequestDefaultDataInterface

Source code excerpt:


		EModuleLoadResult LoadResult;
		FModuleManager::Get().LoadModuleWithFailureReason(TEXT("Niagara"), LoadResult);
		if (LoadResult != EModuleLoadResult::Success)
		{
			UE_LOG(LogTemp, Warning, TEXT("Module manager failed to load Niagara module LoadResult(%d)."), int(LoadResult));
		}

		if ( !OnRequestDefaultDataInterface.IsBound() )

#Loc: <Workspace>/Engine/Plugins/FX/Niagara/Source/NiagaraShader/Public/NiagaraShaderType.h:97

Scope (from outer to inner):

file
class        class FNiagaraShaderType : public FShaderType
function     FNiagaraShaderType

Source code excerpt:

		const FShaderParametersMetadata* InRootParametersMetadata = nullptr
	)
		: FShaderType(EShaderTypeForDynamicCast::Niagara, InTypeLayout, InName, InSourceFilename, InFunctionName, SF_Compute, InTotalPermutationCount,
			InConstructSerializedRef,
			InConstructCompiledRef,
			InShouldCompilePermutationRef,
			InGetRayTracingPayloadTypeRef,
#if WITH_EDITOR
			InModifyCompilationEnvironmentRef,

#Loc: <Workspace>/Engine/Source/Developer/IoStoreUtilities/Private/IoStoreUtilities.cpp:3433

Scope: file

Source code excerpt:

	Level, 
	Animation,
	Niagara,
	Material,
	Blueprint,
	Geometry,
	Other,
	COUNT
};

#Loc: <Workspace>/Engine/Source/Developer/IoStoreUtilities/Private/IoStoreUtilities.cpp:4103

Scope: file

Source code excerpt:

					else if (AssetData->AssetClassPath == NiagaraSystemPath)
					{
						AssetSizeClass = EPluginGraphSizeClass::Niagara;
					}
					else if (AssetData->AssetClassPath == MaterialInstancePath)
					{
						AssetSizeClass = EPluginGraphSizeClass::Material;
					}
					else if (AssetData->AssetClassPath == LevelPath)

#Loc: <Workspace>/Engine/Source/Runtime/Engine/Public/ShowFlagsValues.inl:191

Scope: file

Source code excerpt:

SHOWFLAG_ALWAYS_ACCESSIBLE(Particles, SFG_Normal, NSLOCTEXT("UnrealEd", "ParticlesSF", "Particle Sprites"))
/** Niagara, for now SHOWFLAG_ALWAYS_ACCESSIBLE because it's exposed in SceneCapture */
SHOWFLAG_FIXED_IN_SHIPPING(1, Niagara, SFG_Advanced, NSLOCTEXT("UnrealEd", "NiagaraSF", "Niagara Renderers"))
/** HeterogeneousVolumes, for now SHOWFLAG_ALWAYS_ACCESSIBLE because it's exposed in SceneCapture */
SHOWFLAG_FIXED_IN_SHIPPING(1, HeterogeneousVolumes, SFG_Advanced, NSLOCTEXT("UnrealEd", "HeterogeneousVolumesSF", "Heterogeneous Volumes"))
/** if SkeletalMeshes are getting rendered, for now SHOWFLAG_ALWAYS_ACCESSIBLE because it's exposed in SceneCapture */
SHOWFLAG_ALWAYS_ACCESSIBLE(SkeletalMeshes, SFG_Normal, NSLOCTEXT("UnrealEd", "SkeletalMeshesSF", "Skeletal Meshes"))
/** if the builder brush (editor) is getting rendered */
SHOWFLAG_FIXED_IN_SHIPPING(0, BuilderBrush, SFG_Hidden, NSLOCTEXT("UnrealEd", "BuilderBrushSF", "Builder Brush"))

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/ShaderParameters.cpp:494

Scope (from outer to inner):

file
function     void FShaderType::DumpDebugInfo

Source code excerpt:

		UE_LOG(LogConsoleResponse, Display, TEXT("               :ShaderType MeshMaterial"));
		break;
	case EShaderTypeForDynamicCast::Niagara:
		UE_LOG(LogConsoleResponse, Display, TEXT("               :ShaderType Niagara"));
		break;
	}

#if 0
	UE_LOG(LogConsoleResponse, Display, TEXT("  --- %d shaders"), ShaderIdMap.Num());

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Private/ShaderParameters.cpp:529

Scope (from outer to inner):

file
function     void FShaderType::GetShaderStableKeyParts

Source code excerpt:

		SaveKeyVal.ShaderClass = NAME_MeshMaterial;
		break;
	case EShaderTypeForDynamicCast::Niagara:
		SaveKeyVal.ShaderClass = NAME_Niagara;
		break;
	}
	SaveKeyVal.ShaderType = FName(GetName() ? GetName() : TEXT("null"));
}

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Public/Shader.h:1202

Scope (from outer to inner):

file
class        class FShaderType

Source code excerpt:

		Material,
		MeshMaterial,
		Niagara,
		OCIO,
		ComputeKernel,
		NumShaderTypes,
	};

	/**

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Public/Shader.h:1325

Scope (from outer to inner):

file
class        class FShaderType
function     const FNiagaraShaderType* GetNiagaraShaderType

Source code excerpt:

	FORCEINLINE const FNiagaraShaderType* GetNiagaraShaderType() const
	{
		return (ShaderTypeForDynamicCast == EShaderTypeForDynamicCast::Niagara) ? reinterpret_cast<const FNiagaraShaderType*>(this) : nullptr;
	}
	FORCEINLINE FNiagaraShaderType* GetNiagaraShaderType()
	{
		return (ShaderTypeForDynamicCast == EShaderTypeForDynamicCast::Niagara) ? reinterpret_cast<FNiagaraShaderType*>(this) : nullptr;
	}
	FORCEINLINE const FOpenColorIOShaderType* GetOpenColorIOShaderType() const
	{
		return (ShaderTypeForDynamicCast == EShaderTypeForDynamicCast::OCIO) ? reinterpret_cast<const FOpenColorIOShaderType*>(this) : nullptr;
	}
	FORCEINLINE FOpenColorIOShaderType* GetOpenColorIOShaderType()

#Loc: <Workspace>/Engine/Source/Runtime/RenderCore/Public/Shader.h:1368

Scope (from outer to inner):

file
class        class FShaderType
function     const FNiagaraShaderType* AsNiagaraShaderType

Source code excerpt:

	FORCEINLINE const FNiagaraShaderType* AsNiagaraShaderType() const
	{
		checkf(ShaderTypeForDynamicCast == EShaderTypeForDynamicCast::Niagara, TEXT("ShaderType %s is not Niagara"), GetName());
		return reinterpret_cast<const FNiagaraShaderType*>(this);
	}

	FORCEINLINE const FOpenColorIOShaderType* AsOpenColorIOShaderType() const
	{
		checkf(ShaderTypeForDynamicCast == EShaderTypeForDynamicCast::OCIO, TEXT("ShaderType %s is not OCIO"), GetName());