UDocumentation UE5.7 10.02.2026 (Source)
API documentation for Unreal Engine 5.7
ParticleSystemComponent.cpp File Reference
#include "Particles/ParticleSystemComponent.h"
#include "Distributions/DistributionFloat.h"
#include "Distributions/DistributionFloatConstant.h"
#include "Distributions/DistributionFloatConstantCurve.h"
#include "Distributions/DistributionFloatUniform.h"
#include "Distributions/DistributionVector.h"
#include "Distributions/DistributionVectorConstant.h"
#include "Distributions/DistributionVectorConstantCurve.h"
#include "Distributions/DistributionVectorUniform.h"
#include "Engine/Engine.h"
#include "Engine/GameInstance.h"
#include "Engine/World.h"
#include "GameFramework/WorldSettings.h"
#include "Logging/MessageLog.h"
#include "Materials/MaterialInstanceDynamic.h"
#include "MeshUVChannelInfo.h"
#include "Misc/LargeWorldRenderPosition.h"
#include "Misc/MapErrors.h"
#include "Misc/UObjectToken.h"
#include "ParticleEmitterInstanceOwner.h"
#include "ParticleEmitterInstances.h"
#include "ParticleHelper.h"
#include "ParticleSystemSceneProxy.h"
#include "Particles/EmitterCameraLensEffectBase.h"
#include "Particles/FXSystemPrivate.h"
#include "Particles/ParticleEmitter.h"
#include "Particles/ParticleEventManager.h"
#include "Particles/ParticleLODLevel.h"
#include "Particles/ParticleModuleRequired.h"
#include "Particles/ParticleSystemManager.h"
#include "Particles/ParticleSystemReplay.h"
#include "Particles/TypeData/ParticleModuleTypeDataMesh.h"
#include "SceneInterface.h"
#include "StateStream/ParticleSystemStateStream.h"
#include "UObject/FrameworkObjectVersion.h"
#include "UObject/UObjectIterator.h"
#include "UnrealEngine.h"
#include "InGamePerformanceTracker.h"

Classes

class  UParticleSystemComponent::FInstanceOwner
 
class  FParticleFinalizeTask
 
class  FParticleAsyncTask
 
class  FDispatchBatchedAsyncTasks
 
class  FGameThreadDispatchBatchedAsyncTasks
 
struct  FFXAsyncBatcher
 
class  FArchiveCountStructMem
 

Namespaces

namespace  CascadeLocal
 

Macros

#define LOCTEXT_NAMESPACE   "ParticleComponents"
 
#define WORLD_TYPE_CASE(WorldType)   case EWorldType::WorldType: WorldInfoString += TEXT(#WorldType); break;
 

Typedefs

typedef TPair< const UMaterialInterface *, floatFMaterialWithScale
 

Functions

 DECLARE_CYCLE_STAT (TEXT("ParticleComponent InitParticles GT"), STAT_ParticleSystemComponent_InitParticles, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent SendRenderDynamicData GT"), STAT_ParticleSystemComponent_SendRenderDynamicData_Concurrent, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent SendRenderTransform Concurrent GT"), STAT_ParticleSystemComponent_SendRenderTransform_Concurrent, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent DestroyRenderState Concurrent GT"), STAT_ParticleSystemComponent_DestroyRenderState_Concurrent, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent CreateDynamicData GT"), STAT_ParticleSystemComponent_CreateDynamicData, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent CreateDynamicData Replay GT"), STAT_ParticleSystemComponent_CreateDynamicData_Replay, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent CreateDynamicData Capture GT"), STAT_ParticleSystemComponent_CreateDynamicData_Capture, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent CreateDynamicData Gather GT"), STAT_ParticleSystemComponent_CreateDynamicData_Gather, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent GetDynamicData GT"), STAT_ParticleSystemComponent_GetDynamicData, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent GetDynamicData Selected GT"), STAT_ParticleSystemComponent_GetDynamicData_Selected, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent CreateDynamicData GatherCapture GT"), STAT_ParticleSystemComponent_CreateDynamicData_GatherCapture, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent UpdateDynamicData GT"), STAT_ParticleSystemComponent_UpdateDynamicData, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent OrientZAxisTowardCamera GT"), STAT_UParticleSystemComponent_OrientZAxisTowardCamera, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent QueueFinalize GT"), STAT_UParticleSystemComponent_QueueFinalize, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent CheckForReset GT"), STAT_UParticleSystemComponent_CheckForReset, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent LOD GT"), STAT_UParticleSystemComponent_LOD, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent QueueTasksGT"), STAT_UParticleSystemComponent_QueueTasks, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent QueueAsyncGT"), STAT_UParticleSystemComponent_QueueAsync, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent WaitForAsyncAndFinalize GT"), STAT_UParticleSystemComponent_WaitForAsyncAndFinalize, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("ParticleComponent CreateRenderState Concurrent GT"), STAT_ParticleSystemComponent_CreateRenderState_Concurrent, STATGROUP_Particles)
 
 DECLARE_CYCLE_STAT (TEXT("PSys Comp Marshall Time GT"), STAT_UParticleSystemComponent_Marshall, STATGROUP_Particles)
 
 CSV_DECLARE_CATEGORY_MODULE_EXTERN (CORE_API, Basic)
 
 DEFINE_STAT (STAT_ParticlesOverview_GT)
 
 DEFINE_STAT (STAT_ParticlesOverview_GT_CNC)
 
 DEFINE_STAT (STAT_ParticlesOverview_RT)
 
 DEFINE_STAT (STAT_ParticlesOverview_RT_CNC)
 
 DEFINE_LOG_CATEGORY (LogParticles)
 
bool CascadeLocal::AllowTemplate (UParticleSystem *Template)
 
void Particle_ModifyFloatDistribution (UDistributionFloat *pkDistribution, float fScale)
 
void Particle_ModifyVectorDistribution (UDistributionVector *pkDistribution, FVector &vScale)
 
void DetailModeSink ()
 
void AddMaterials (TArray< FMaterialWithScale, TInlineAllocator< 12 > > &OutMaterialWithScales, const TArray< UMaterialInterface * > &InMaterials, float InScale)
 
FArchiveoperator<< (FArchive &Ar, FParticleSystemReplayFrame &Obj)
 
FArchiveoperator<< (FArchive &Ar, FParticleEmitterReplayFrame &Obj)
 

Variables

FCustomVersionRegistration GRegisterParticleSystemCustomVersion (FParticleSystemCustomVersion::GUID, FParticleSystemCustomVersion::LatestVersion, TEXT("ParticleSystemVer"))
 
int32 GParticleLODBias = 0
 
FAutoConsoleVariableRef CVarParticleLODBias (TEXT("r.ParticleLODBias"), GParticleLODBias, TEXT("LOD bias for particle systems, default is 0"), ECVF_Scalability)
 
float GFXLWCTileRecache = 2
 
FAutoConsoleVariableRef CVarFXLWCTileRecache (TEXT("fx.LWCTileRecache"), GFXLWCTileRecache, TEXT("Setting this value to 0 will remove this behavior but could introduce rendering & simulation artifacts.\n"), ECVF_Default)
 
FAutoConsoleVariableRef CVarFXSkipZeroDeltaTime (TEXT("fx.Cascade.SkipZeroDeltaTime"), GFXSkipZeroDeltaTime, TEXT("This fixes issue like PSA_Velocity aligned sprites, but could cause issues with things that rely on accurate velocities (i.e. TSR)."), ECVF_Default)
 
int32 GCascadePSOPrecachingTime = 1
 
FAutoConsoleVariableRef CVarCascadePSOPrecachingTime (TEXT("r.PSOPrecache.CascadePrecachingTime"), GCascadePSOPrecachingTime, TEXT(" 3: precaching at component proxy creation time"), ECVF_Default)
 
ENGINE_API bool GIsAllowingParticles = true
 
bool GbEnableGameThreadLODCalculation = true
 
bool CascadeLocal::bUseTemplateDenyList = false
 
TSet< FNameCascadeLocal::TemplateDenyList
 
FString CascadeLocal::TemplateDenyListString
 
FSceneViewGParticleView = NULL
 
TAutoConsoleVariable< int32CVarFXEarlySchedule (TEXT("FX.EarlyScheduleAsync"), 0, TEXT("If 1, particle system components that can run async will be scheduled earlier in the frame"))
 
FAutoConsoleTaskPriority CPrio_ParticleAsyncTask (TEXT("TaskGraph.TaskPriorities.ParticleAsyncTask"), TEXT("Task and thread priority for FParticleAsyncTask."), ENamedThreads::HighThreadPriority, ENamedThreads::NormalTaskPriority, ENamedThreads::HighTaskPriority)
 
int32 GbDeferrPSCDeactivation = 0
 
FAutoConsoleVariableRef CVarDeferrPSCDeactivation (TEXT("fx.DeferrPSCDeactivation"), GbDeferrPSCDeactivation, TEXT("If > 0, all deactivations on Particle System Components is deferred until next tick."), ECVF_Scalability)
 
FAutoConsoleCommand GDumpPSCStateCommand (TEXT("fx.DumpPSCTickStateInfo"), TEXT("Dumps state information for all current Particle System Components."), FConsoleCommandDelegate::CreateStatic([]() { struct FPSCInfo { UParticleSystemComponent *PSC;bool bIsActive;bool bIsSignificant;bool bIsVisible;int32 NumActiveParticles;FPSCInfo() :PSC((UParticleSystemComponent *) 0xDEADBEEFDEADBEEF), bIsActive(false), bIsSignificant(false), bIsVisible(false), NumActiveParticles(0) {} };struct FPSCInfoSummary { TArray< FPSCInfo > Components;int32 NumTicking;int32 NumManaged;int32 NumTickingNoTemplate;int32 NumTickingButInactive;int32 NumTickingButInvisible;int32 NumTickingButNonSignificant;int32 NumTickingNoEmitters;int32 NumPooled;FPSCInfoSummary() :NumTicking(0), NumManaged(0), NumTickingNoTemplate(0), NumTickingButInactive(0), NumTickingButInvisible(0), NumTickingButNonSignificant(0), NumTickingNoEmitters(0), NumPooled(0) {} };struct FPSCWorldInfo { TMap< UParticleSystem *, FPSCInfoSummary > SummaryMap;int32 TotalPSCs;int32 TotalTicking;int32 TotalManaged;int32 TotalTickingNoTemplate;int32 TotalTickingButInactive;int32 TotalTickingButInvisible;int32 TotalTickingButNonSignificant;int32 TotalTickingNoEmitters;int32 TotalPooled;FPSCWorldInfo() :TotalPSCs(0), TotalTicking(0), TotalManaged(0), TotalTickingNoTemplate(0), TotalTickingButInactive(0), TotalTickingButInvisible(0), TotalTickingButNonSignificant(0), TotalTickingNoEmitters(0), TotalPooled(0) {} };TMap< UWorld *, FPSCWorldInfo > InfoMap;for(TObjectIterator< UParticleSystemComponent > PSCIt;PSCIt;++PSCIt) { UParticleSystemComponent *PSC= *PSCIt;check(PSC);UWorld *World=PSC->GetWorld();UParticleSystem *Sys=PSC->Template;FPSCWorldInfo &WorldInfo=InfoMap.FindOrAdd(World);FPSCInfoSummary &Info=WorldInfo.SummaryMap.FindOrAdd(Sys);int32 PSCInfoIndex=Info.Components.AddDefaulted();FPSCInfo &PSCInfo=Info.Components[PSCInfoIndex];PSCInfo.PSC=PSC;++WorldInfo.TotalPSCs;if(PSC->IsComponentTickEnabled()) { int32 NumParticles=PSC->GetNumActiveParticles();PSCInfo.NumActiveParticles=NumParticles;if(PSC->IsTickManaged()) {++Info.NumManaged;++WorldInfo.TotalManaged;} else {++Info.NumTicking;++WorldInfo.TotalTicking;} if(PSC->Template==nullptr) {++Info.NumTickingNoTemplate;++WorldInfo.TotalTickingNoTemplate;} if(PSC->EmitterInstances.Num()==0) {++Info.NumTickingNoEmitters;++WorldInfo.TotalTickingNoEmitters;} if(PSC->IsActive()) { PSCInfo.bIsActive=true;} else {++Info.NumTickingButInactive;++WorldInfo.TotalTickingButInactive;PSCInfo.bIsActive=false;} PSCInfo.bIsVisible=!PSC->CanConsiderInvisible();if(!PSCInfo.bIsVisible) {++Info.NumTickingButInvisible;++WorldInfo.TotalTickingButInvisible;} if(PSC->bIsManagingSignificance) { uint32 NumSignificantEmitters=0;for(UParticleEmitter *Emitter :PSC->Template->Emitters) { if(Emitter->IsSignificant(PSC->RequiredSignificance)) {++NumSignificantEmitters;} } PSCInfo.bIsSignificant=NumSignificantEmitters > 0;if(NumSignificantEmitters==0 &&NumParticles==0) {++Info.NumTickingButNonSignificant;++WorldInfo.TotalTickingButNonSignificant;} } else { PSCInfo.bIsSignificant=true;} } } auto PrintPSCInfo=[](const UParticleSystem *Sys, FPSCInfoSummary &Info) { float KBUsed=(sizeof(UParticleSystemComponent) *Info.Components.Num())/1024.0f;FString MaxSigName;if(Sys) { switch(Sys->GetHighestSignificance()) { case EParticleSignificanceLevel::Critical:MaxSigName=TEXT("Crit");break;case EParticleSignificanceLevel::High:MaxSigName=TEXT("High");break;case EParticleSignificanceLevel::Medium:MaxSigName=TEXT("Med");break;case EParticleSignificanceLevel::Low:MaxSigName=TEXT("Low");break;} } UE_LOG(LogParticles, Log, TEXT("| %5u | %7.2f | %7u | %7u | %8u | %9u || %4d | %6s |%s"), Info.Components.Num(), KBUsed, Info.NumTicking, Info.NumManaged, Info.NumTickingButInactive, Info.NumTickingButInvisible, Sys ? Sys->IsLooping() :0, *MaxSigName, Sys ? *Sys->GetFullName() :TEXT("NULL SYSTEM!"));};for(TPair< UWorld *, FPSCWorldInfo > InfoMapPair :InfoMap) { UWorld *World=InfoMapPair.Key;FPSCWorldInfo &WorldInfo=InfoMapPair.Value;FString WorldInfoString;if(World) { #define WORLD_TYPE_CASE(WorldType) switch(World->WorldType) { };WorldInfoString+=TEXT(" | ");WorldInfoString+=World->GetFullName();} float KBUsed=(sizeof(UParticleSystemComponent) *WorldInfo.TotalPSCs)/1024.0f;UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|"));UE_LOG(LogParticles, Log, TEXT("| Particle System Component Tick State Info |"));UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|"));UE_LOG(LogParticles, Log, TEXT("| World: 0x%p - %s |"), World, *WorldInfoString);UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|"));UE_LOG(LogParticles, Log, TEXT("| Inactive = Ticking but is not active and has no active particles. This should be investigated. |"));UE_LOG(LogParticles, Log, TEXT("| Invisible = Ticking but is not visible. Ideally these systems could be culled by the significance manager but this requires them to be non critical. |"));UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|"));UE_LOG(LogParticles, Log, TEXT("| Summary |"));UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|"));UE_LOG(LogParticles, Log, TEXT("| Total | Mem(KB) | Ticking | Managed | Inactive | Invisible | Template |---------||"));UE_LOG(LogParticles, Log, TEXT("| %5u | %7.2f | %7u | %7u | %8u | %9u|| Loop | MaxSig | Name |"), WorldInfo.TotalPSCs, KBUsed, WorldInfo.TotalTicking, WorldInfo.TotalManaged, WorldInfo.TotalTickingButInactive, WorldInfo.TotalTickingButInvisible);UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|"));WorldInfo.SummaryMap.ValueSort([](const FPSCInfoSummary &A, const FPSCInfoSummary &B) { return((A.Components.Num()/1000.0f)+(A.NumManaged+A.NumTicking)) >((B.Components.Num()/1000.0f)+(B.NumManaged+B.NumTicking));});for(TPair< UParticleSystem *, FPSCInfoSummary > &Pair :WorldInfo.SummaryMap) { const UParticleSystem *Sys=Pair.Key;FPSCInfoSummary &Info=Pair.Value;{ PrintPSCInfo(Sys, Info);} } UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------|"));UE_LOG(LogParticles, Log, TEXT("|-- All Ticking or Managed Components By System --------------------------------------------|"));UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------|"));for(TPair< UParticleSystem *, FPSCInfoSummary > &Pair :WorldInfo.SummaryMap) { const UParticleSystem *Sys=Pair.Key;FPSCInfoSummary &Info=Pair.Value;if(Info.NumManaged > 0||Info.NumTicking > 0) { UE_LOG(LogParticles, Log, TEXT("|-- Sys: %s -------------------------------------------------------|"), Sys ? *Sys->GetFullName() :TEXT("null"));Info.Components.Sort([](const FPSCInfo &A, const FPSCInfo &B) { return !A.bIsActive+!A.bIsSignificant+!A.bIsVisible< !B.bIsActive+!B.bIsSignificant+!B.bIsVisible;});for(FPSCInfo &PSCInfo :Info.Components) { bool bTickManaged=PSCInfo.PSC->IsTickManaged();if(PSCInfo.PSC->IsComponentTickEnabled()) { UE_LOG(LogParticles, Log, TEXT("| PSC: %p | Ticking: %d | Managed: %d | Active: %d | Sig: %d | Vis: %d | Num: %d | %s"), PSCInfo.PSC, !bTickManaged, bTickManaged, PSCInfo.bIsActive, PSCInfo.bIsSignificant, PSCInfo.bIsVisible, PSCInfo.NumActiveParticles, *PSCInfo.PSC->GetFullName());} } } } } }))
 

Macro Definition Documentation

◆ LOCTEXT_NAMESPACE

#define LOCTEXT_NAMESPACE   "ParticleComponents"

◆ WORLD_TYPE_CASE

#define WORLD_TYPE_CASE (   WorldType)    case EWorldType::WorldType: WorldInfoString += TEXT(#WorldType); break;

Typedef Documentation

◆ FMaterialWithScale

Function Documentation

◆ AddMaterials()

void AddMaterials ( TArray< FMaterialWithScale, TInlineAllocator< 12 > > &  OutMaterialWithScales,
const TArray< UMaterialInterface * > &  InMaterials,
float  InScale 
)

◆ CSV_DECLARE_CATEGORY_MODULE_EXTERN()

CSV_DECLARE_CATEGORY_MODULE_EXTERN ( CORE_API  ,
Basic   
)

◆ DECLARE_CYCLE_STAT() [1/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent CheckForReset GT" ,
STAT_UParticleSystemComponent_CheckForReset  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [2/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent CreateDynamicData Capture GT" ,
STAT_ParticleSystemComponent_CreateDynamicData_Capture  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [3/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent CreateDynamicData Gather GT" ,
STAT_ParticleSystemComponent_CreateDynamicData_Gather  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [4/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent CreateDynamicData GatherCapture GT" ,
STAT_ParticleSystemComponent_CreateDynamicData_GatherCapture  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [5/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent CreateDynamicData GT" ,
STAT_ParticleSystemComponent_CreateDynamicData  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [6/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent CreateDynamicData Replay GT" ,
STAT_ParticleSystemComponent_CreateDynamicData_Replay  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [7/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent CreateRenderState Concurrent GT" ,
STAT_ParticleSystemComponent_CreateRenderState_Concurrent  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [8/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent DestroyRenderState Concurrent GT" ,
STAT_ParticleSystemComponent_DestroyRenderState_Concurrent  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [9/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent GetDynamicData GT" ,
STAT_ParticleSystemComponent_GetDynamicData  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [10/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent GetDynamicData Selected GT" ,
STAT_ParticleSystemComponent_GetDynamicData_Selected  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [11/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent InitParticles GT" ,
STAT_ParticleSystemComponent_InitParticles  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [12/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent LOD GT" ,
STAT_UParticleSystemComponent_LOD  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [13/21]

◆ DECLARE_CYCLE_STAT() [14/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent QueueAsyncGT" ,
STAT_UParticleSystemComponent_QueueAsync  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [15/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent QueueFinalize GT" ,
STAT_UParticleSystemComponent_QueueFinalize  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [16/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent QueueTasksGT" ,
STAT_UParticleSystemComponent_QueueTasks  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [17/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent SendRenderDynamicData GT" ,
STAT_ParticleSystemComponent_SendRenderDynamicData_Concurrent  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [18/21]

◆ DECLARE_CYCLE_STAT() [19/21]

DECLARE_CYCLE_STAT ( TEXT("ParticleComponent UpdateDynamicData GT" ,
STAT_ParticleSystemComponent_UpdateDynamicData  ,
STATGROUP_Particles   
)

◆ DECLARE_CYCLE_STAT() [20/21]

◆ DECLARE_CYCLE_STAT() [21/21]

◆ DEFINE_LOG_CATEGORY()

DEFINE_LOG_CATEGORY ( LogParticles  )

◆ DEFINE_STAT() [1/4]

DEFINE_STAT ( STAT_ParticlesOverview_GT  )

◆ DEFINE_STAT() [2/4]

DEFINE_STAT ( STAT_ParticlesOverview_GT_CNC  )

◆ DEFINE_STAT() [3/4]

DEFINE_STAT ( STAT_ParticlesOverview_RT  )

◆ DEFINE_STAT() [4/4]

DEFINE_STAT ( STAT_ParticlesOverview_RT_CNC  )

◆ DetailModeSink()

void DetailModeSink ( )

◆ operator<<() [1/2]

FArchive & operator<< ( FArchive Ar,
FParticleEmitterReplayFrame Obj 
)

FParticleEmitterReplayFrame serialization operator

◆ operator<<() [2/2]

FArchive & operator<< ( FArchive Ar,
FParticleSystemReplayFrame Obj 
)

FParticleSystemReplayFrame serialization operator

◆ Particle_ModifyFloatDistribution()

void Particle_ModifyFloatDistribution ( UDistributionFloat pkDistribution,
float  fScale 
)

◆ Particle_ModifyVectorDistribution()

void Particle_ModifyVectorDistribution ( UDistributionVector pkDistribution,
FVector vScale 
)

Variable Documentation

◆ CPrio_ParticleAsyncTask

FAutoConsoleTaskPriority CPrio_ParticleAsyncTask(TEXT("TaskGraph.TaskPriorities.ParticleAsyncTask"), TEXT("Task and thread priority for FParticleAsyncTask."), ENamedThreads::HighThreadPriority, ENamedThreads::NormalTaskPriority, ENamedThreads::HighTaskPriority) ( TEXT("TaskGraph.TaskPriorities.ParticleAsyncTask")  ,
TEXT("Task and thread priority for FParticleAsyncTask." ,
ENamedThreads::HighThreadPriority  ,
ENamedThreads::NormalTaskPriority  ,
ENamedThreads::HighTaskPriority   
)

◆ CVarCascadePSOPrecachingTime

FAutoConsoleVariableRef CVarCascadePSOPrecachingTime(TEXT("r.PSOPrecache.CascadePrecachingTime"), GCascadePSOPrecachingTime, TEXT(" 3: precaching at component proxy creation time"), ECVF_Default) ( TEXT("r.PSOPrecache.CascadePrecachingTime")  ,
GCascadePSOPrecachingTime  ,
TEXT(" 3: precaching at component proxy creation time" ,
ECVF_Default   
)

◆ CVarDeferrPSCDeactivation

FAutoConsoleVariableRef CVarDeferrPSCDeactivation(TEXT("fx.DeferrPSCDeactivation"), GbDeferrPSCDeactivation, TEXT("If > 0, all deactivations on Particle System Components is deferred until next tick."), ECVF_Scalability) ( TEXT("fx.DeferrPSCDeactivation")  ,
GbDeferrPSCDeactivation  ,
TEXT("If > 0, all deactivations on Particle System Components is deferred until next tick." ,
ECVF_Scalability   
)

◆ CVarFXEarlySchedule

TAutoConsoleVariable< int32 > CVarFXEarlySchedule(TEXT("FX.EarlyScheduleAsync"), 0, TEXT("If 1, particle system components that can run async will be scheduled earlier in the frame")) ( TEXT("FX.EarlyScheduleAsync")  ,
,
TEXT("If 1, particle system components that can run async will be scheduled earlier in the frame"  
)

◆ CVarFXLWCTileRecache

FAutoConsoleVariableRef CVarFXLWCTileRecache(TEXT("fx.LWCTileRecache"), GFXLWCTileRecache, TEXT("Setting this value to 0 will remove this behavior but could introduce rendering & simulation artifacts.\n"), ECVF_Default) ( TEXT("fx.LWCTileRecache")  ,
GFXLWCTileRecache  ,
TEXT("Setting this value to 0 will remove this behavior but could introduce rendering & simulation artifacts.\n" ,
ECVF_Default   
)

◆ CVarFXSkipZeroDeltaTime

FAutoConsoleVariableRef CVarFXSkipZeroDeltaTime(TEXT("fx.Cascade.SkipZeroDeltaTime"), GFXSkipZeroDeltaTime, TEXT("This fixes issue like PSA_Velocity aligned sprites, but could cause issues with things that rely on accurate velocities (i.e. TSR)."), ECVF_Default) ( TEXT("fx.Cascade.SkipZeroDeltaTime")  ,
GFXSkipZeroDeltaTime  ,
TEXT("This fixes issue like PSA_Velocity aligned sprites, but could cause issues with things that rely on accurate velocities (i.e. TSR).")  ,
ECVF_Default   
)

◆ CVarParticleLODBias

FAutoConsoleVariableRef CVarParticleLODBias(TEXT("r.ParticleLODBias"), GParticleLODBias, TEXT("LOD bias for particle systems, default is 0"), ECVF_Scalability) ( TEXT("r.ParticleLODBias")  ,
GParticleLODBias  ,
TEXT("LOD bias for particle systems, default is 0")  ,
ECVF_Scalability   
)

◆ GbDeferrPSCDeactivation

int32 GbDeferrPSCDeactivation = 0

◆ GbEnableGameThreadLODCalculation

bool GbEnableGameThreadLODCalculation = true

Whether to calculate LOD on the GameThread in-game.

◆ GCascadePSOPrecachingTime

int32 GCascadePSOPrecachingTime = 1

When to precache Cascade systems' PSOs

◆ GDumpPSCStateCommand

FAutoConsoleCommand GDumpPSCStateCommand(TEXT("fx.DumpPSCTickStateInfo"), TEXT("Dumps state information for all current Particle System Components."), FConsoleCommandDelegate::CreateStatic([]() { struct FPSCInfo { UParticleSystemComponent *PSC; bool bIsActive; bool bIsSignificant; bool bIsVisible; int32 NumActiveParticles; FPSCInfo() :PSC((UParticleSystemComponent *) 0xDEADBEEFDEADBEEF), bIsActive(false), bIsSignificant(false), bIsVisible(false), NumActiveParticles(0) {} }; struct FPSCInfoSummary { TArray< FPSCInfo > Components; int32 NumTicking; int32 NumManaged; int32 NumTickingNoTemplate; int32 NumTickingButInactive; int32 NumTickingButInvisible; int32 NumTickingButNonSignificant; int32 NumTickingNoEmitters; int32 NumPooled; FPSCInfoSummary() :NumTicking(0), NumManaged(0), NumTickingNoTemplate(0), NumTickingButInactive(0), NumTickingButInvisible(0), NumTickingButNonSignificant(0), NumTickingNoEmitters(0), NumPooled(0) {} }; struct FPSCWorldInfo { TMap< UParticleSystem *, FPSCInfoSummary > SummaryMap; int32 TotalPSCs; int32 TotalTicking; int32 TotalManaged; int32 TotalTickingNoTemplate; int32 TotalTickingButInactive; int32 TotalTickingButInvisible; int32 TotalTickingButNonSignificant; int32 TotalTickingNoEmitters; int32 TotalPooled; FPSCWorldInfo() :TotalPSCs(0), TotalTicking(0), TotalManaged(0), TotalTickingNoTemplate(0), TotalTickingButInactive(0), TotalTickingButInvisible(0), TotalTickingButNonSignificant(0), TotalTickingNoEmitters(0), TotalPooled(0) {} }; TMap< UWorld *, FPSCWorldInfo > InfoMap; for(TObjectIterator< UParticleSystemComponent > PSCIt;PSCIt;++PSCIt) { UParticleSystemComponent *PSC=*PSCIt; check(PSC); UWorld *World=PSC->GetWorld(); UParticleSystem *Sys=PSC->Template; FPSCWorldInfo &WorldInfo=InfoMap.FindOrAdd(World); FPSCInfoSummary &Info=WorldInfo.SummaryMap.FindOrAdd(Sys); int32 PSCInfoIndex=Info.Components.AddDefaulted(); FPSCInfo &PSCInfo=Info.Components[PSCInfoIndex]; PSCInfo.PSC=PSC;++WorldInfo.TotalPSCs; if(PSC->IsComponentTickEnabled()) { int32 NumParticles=PSC->GetNumActiveParticles(); PSCInfo.NumActiveParticles=NumParticles; if(PSC->IsTickManaged()) {++Info.NumManaged;++WorldInfo.TotalManaged; } else {++Info.NumTicking;++WorldInfo.TotalTicking; } if(PSC->Template==nullptr) {++Info.NumTickingNoTemplate;++WorldInfo.TotalTickingNoTemplate; } if(PSC->EmitterInstances.Num()==0) {++Info.NumTickingNoEmitters;++WorldInfo.TotalTickingNoEmitters; } if(PSC->IsActive()) { PSCInfo.bIsActive=true; } else {++Info.NumTickingButInactive;++WorldInfo.TotalTickingButInactive; PSCInfo.bIsActive=false; } PSCInfo.bIsVisible=!PSC->CanConsiderInvisible(); if(!PSCInfo.bIsVisible) {++Info.NumTickingButInvisible;++WorldInfo.TotalTickingButInvisible; } if(PSC->bIsManagingSignificance) { uint32 NumSignificantEmitters=0; for(UParticleEmitter *Emitter :PSC->Template->Emitters) { if(Emitter->IsSignificant(PSC->RequiredSignificance)) {++NumSignificantEmitters; } } PSCInfo.bIsSignificant=NumSignificantEmitters > 0; if(NumSignificantEmitters==0 &&NumParticles==0) {++Info.NumTickingButNonSignificant;++WorldInfo.TotalTickingButNonSignificant; } } else { PSCInfo.bIsSignificant=true; } } } auto PrintPSCInfo=[](const UParticleSystem *Sys, FPSCInfoSummary &Info) { float KBUsed=(sizeof(UParticleSystemComponent) *Info.Components.Num())/1024.0f; FString MaxSigName; if(Sys) { switch(Sys->GetHighestSignificance()) { case EParticleSignificanceLevel::Critical:MaxSigName=TEXT("Crit");break; case EParticleSignificanceLevel::High:MaxSigName=TEXT("High");break; case EParticleSignificanceLevel::Medium:MaxSigName=TEXT("Med");break; case EParticleSignificanceLevel::Low:MaxSigName=TEXT("Low");break; } } UE_LOG(LogParticles, Log, TEXT("| %5u | %7.2f | %7u | %7u | %8u | %9u || %4d | %6s |%s"), Info.Components.Num(), KBUsed, Info.NumTicking, Info.NumManaged, Info.NumTickingButInactive, Info.NumTickingButInvisible, Sys ? Sys->IsLooping() :0, *MaxSigName, Sys ? *Sys->GetFullName() :TEXT("NULL SYSTEM!")); }; for(TPair< UWorld *, FPSCWorldInfo > InfoMapPair :InfoMap) { UWorld *World=InfoMapPair.Key; FPSCWorldInfo &WorldInfo=InfoMapPair.Value; FString WorldInfoString; if(World) { #define WORLD_TYPE_CASE(WorldType) switch(World->WorldType) { }; WorldInfoString+=TEXT(" | "); WorldInfoString+=World->GetFullName(); } float KBUsed=(sizeof(UParticleSystemComponent) *WorldInfo.TotalPSCs)/1024.0f; UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("| Particle System Component Tick State Info |")); UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("| World: 0x%p - %s |"), World, *WorldInfoString); UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("| Inactive = Ticking but is not active and has no active particles. This should be investigated. |")); UE_LOG(LogParticles, Log, TEXT("| Invisible = Ticking but is not visible. Ideally these systems could be culled by the significance manager but this requires them to be non critical. |")); UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("| Summary |")); UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("| Total | Mem(KB) | Ticking | Managed | Inactive | Invisible | Template |---------||")); UE_LOG(LogParticles, Log, TEXT("| %5u | %7.2f | %7u | %7u | %8u | %9u|| Loop | MaxSig | Name |"), WorldInfo.TotalPSCs, KBUsed, WorldInfo.TotalTicking, WorldInfo.TotalManaged, WorldInfo.TotalTickingButInactive, WorldInfo.TotalTickingButInvisible); UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|")); WorldInfo.SummaryMap.ValueSort([](const FPSCInfoSummary &A, const FPSCInfoSummary &B) { return((A.Components.Num()/1000.0f)+(A.NumManaged+A.NumTicking)) >((B.Components.Num()/1000.0f)+(B.NumManaged+B.NumTicking));}); for(TPair< UParticleSystem *, FPSCInfoSummary > &Pair :WorldInfo.SummaryMap) { const UParticleSystem *Sys=Pair.Key; FPSCInfoSummary &Info=Pair.Value; { PrintPSCInfo(Sys, Info); } } UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("|-- All Ticking or Managed Components By System --------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------|")); for(TPair< UParticleSystem *, FPSCInfoSummary > &Pair :WorldInfo.SummaryMap) { const UParticleSystem *Sys=Pair.Key; FPSCInfoSummary &Info=Pair.Value; if(Info.NumManaged > 0||Info.NumTicking > 0) { UE_LOG(LogParticles, Log, TEXT("|-- Sys: %s -------------------------------------------------------|"), Sys ? *Sys->GetFullName() :TEXT("null")); Info.Components.Sort([](const FPSCInfo &A, const FPSCInfo &B) { return !A.bIsActive+!A.bIsSignificant+!A.bIsVisible< !B.bIsActive+!B.bIsSignificant+!B.bIsVisible;}); for(FPSCInfo &PSCInfo :Info.Components) { bool bTickManaged=PSCInfo.PSC->IsTickManaged(); if(PSCInfo.PSC->IsComponentTickEnabled()) { UE_LOG(LogParticles, Log, TEXT("| PSC: %p | Ticking: %d | Managed: %d | Active: %d | Sig: %d | Vis: %d | Num: %d | %s"), PSCInfo.PSC, !bTickManaged, bTickManaged, PSCInfo.bIsActive, PSCInfo.bIsSignificant, PSCInfo.bIsVisible, PSCInfo.NumActiveParticles, *PSCInfo.PSC->GetFullName()); } } } } } })) ( TEXT("fx.DumpPSCTickStateInfo")  ,
TEXT("Dumps state information for all current Particle System Components." ,
FConsoleCommandDelegate::CreateStatic([](){ struct FPSCInfo { UParticleSystemComponent *PSC; bool bIsActive; bool bIsSignificant; bool bIsVisible; int32 NumActiveParticles; FPSCInfo() :PSC((UParticleSystemComponent *) 0xDEADBEEFDEADBEEF), bIsActive(false), bIsSignificant(false), bIsVisible(false), NumActiveParticles(0) {} };struct FPSCInfoSummary { TArray< FPSCInfo > Components; int32 NumTicking; int32 NumManaged; int32 NumTickingNoTemplate; int32 NumTickingButInactive; int32 NumTickingButInvisible; int32 NumTickingButNonSignificant; int32 NumTickingNoEmitters; int32 NumPooled; FPSCInfoSummary() :NumTicking(0), NumManaged(0), NumTickingNoTemplate(0), NumTickingButInactive(0), NumTickingButInvisible(0), NumTickingButNonSignificant(0), NumTickingNoEmitters(0), NumPooled(0) {} };struct FPSCWorldInfo { TMap< UParticleSystem *, FPSCInfoSummary > SummaryMap; int32 TotalPSCs; int32 TotalTicking; int32 TotalManaged; int32 TotalTickingNoTemplate; int32 TotalTickingButInactive; int32 TotalTickingButInvisible; int32 TotalTickingButNonSignificant; int32 TotalTickingNoEmitters; int32 TotalPooled; FPSCWorldInfo() :TotalPSCs(0), TotalTicking(0), TotalManaged(0), TotalTickingNoTemplate(0), TotalTickingButInactive(0), TotalTickingButInvisible(0), TotalTickingButNonSignificant(0), TotalTickingNoEmitters(0), TotalPooled(0) {} }; TMap< UWorld *, FPSCWorldInfo > InfoMap;for(TObjectIterator< UParticleSystemComponent > PSCIt;PSCIt;++PSCIt) { UParticleSystemComponent *PSC=*PSCIt; check(PSC); UWorld *World=PSC->GetWorld(); UParticleSystem *Sys=PSC->Template; FPSCWorldInfo &WorldInfo=InfoMap.FindOrAdd(World); FPSCInfoSummary &Info=WorldInfo.SummaryMap.FindOrAdd(Sys); int32 PSCInfoIndex=Info.Components.AddDefaulted(); FPSCInfo &PSCInfo=Info.Components[PSCInfoIndex]; PSCInfo.PSC=PSC;++WorldInfo.TotalPSCs; if(PSC->IsComponentTickEnabled()) { int32 NumParticles=PSC->GetNumActiveParticles(); PSCInfo.NumActiveParticles=NumParticles; if(PSC->IsTickManaged()) {++Info.NumManaged;++WorldInfo.TotalManaged; } else {++Info.NumTicking;++WorldInfo.TotalTicking; } if(PSC->Template==nullptr) {++Info.NumTickingNoTemplate;++WorldInfo.TotalTickingNoTemplate; } if(PSC->EmitterInstances.Num()==0) {++Info.NumTickingNoEmitters;++WorldInfo.TotalTickingNoEmitters; } if(PSC->IsActive()) { PSCInfo.bIsActive=true; } else {++Info.NumTickingButInactive;++WorldInfo.TotalTickingButInactive; PSCInfo.bIsActive=false; } PSCInfo.bIsVisible=!PSC->CanConsiderInvisible(); if(!PSCInfo.bIsVisible) {++Info.NumTickingButInvisible;++WorldInfo.TotalTickingButInvisible; } if(PSC->bIsManagingSignificance) { uint32 NumSignificantEmitters=0; for(UParticleEmitter *Emitter :PSC->Template->Emitters) { if(Emitter->IsSignificant(PSC->RequiredSignificance)) {++NumSignificantEmitters; } } PSCInfo.bIsSignificant=NumSignificantEmitters > 0; if(NumSignificantEmitters==0 &&NumParticles==0) {++Info.NumTickingButNonSignificant;++WorldInfo.TotalTickingButNonSignificant; } } else { PSCInfo.bIsSignificant=true; } } } auto PrintPSCInfo=[](const UParticleSystem *Sys, FPSCInfoSummary &Info) { float KBUsed=(sizeof(UParticleSystemComponent) *Info.Components.Num())/1024.0f; FString MaxSigName; if(Sys) { switch(Sys->GetHighestSignificance()) { case EParticleSignificanceLevel::Critical:MaxSigName=TEXT("Crit");break; case EParticleSignificanceLevel::High:MaxSigName=TEXT("High");break; case EParticleSignificanceLevel::Medium:MaxSigName=TEXT("Med");break; case EParticleSignificanceLevel::Low:MaxSigName=TEXT("Low");break; } } UE_LOG(LogParticles, Log, TEXT("| %5u | %7.2f | %7u | %7u | %8u | %9u || %4d | %6s |%s"), Info.Components.Num(), KBUsed, Info.NumTicking, Info.NumManaged, Info.NumTickingButInactive, Info.NumTickingButInvisible, Sys ? Sys->IsLooping() :0, *MaxSigName, Sys ? *Sys->GetFullName() :TEXT("NULL SYSTEM!"));};for(TPair< UWorld *, FPSCWorldInfo > InfoMapPair :InfoMap) { UWorld *World=InfoMapPair.Key; FPSCWorldInfo &WorldInfo=InfoMapPair.Value; FString WorldInfoString; if(World) {#define WORLD_TYPE_CASE(WorldType) switch(World->WorldType) { }; WorldInfoString+=TEXT(" | "); WorldInfoString+=World->GetFullName(); } float KBUsed=(sizeof(UParticleSystemComponent) *WorldInfo.TotalPSCs)/1024.0f; UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("| Particle System Component Tick State Info |")); UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("| World: 0x%p - %s |"), World, *WorldInfoString); UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("| Inactive = Ticking but is not active and has no active particles. This should be investigated. |")); UE_LOG(LogParticles, Log, TEXT("| Invisible = Ticking but is not visible. Ideally these systems could be culled by the significance manager but this requires them to be non critical. |")); UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("| Summary |")); UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("| Total | Mem(KB) | Ticking | Managed | Inactive | Invisible | Template |---------||")); UE_LOG(LogParticles, Log, TEXT("| %5u | %7.2f | %7u | %7u | %8u | %9u|| Loop | MaxSig | Name |"), WorldInfo.TotalPSCs, KBUsed, WorldInfo.TotalTicking, WorldInfo.TotalManaged, WorldInfo.TotalTickingButInactive, WorldInfo.TotalTickingButInvisible); UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------------------|")); WorldInfo.SummaryMap.ValueSort([](const FPSCInfoSummary &A, const FPSCInfoSummary &B) { return((A.Components.Num()/1000.0f)+(A.NumManaged+A.NumTicking)) >((B.Components.Num()/1000.0f)+(B.NumManaged+B.NumTicking));}); for(TPair< UParticleSystem *, FPSCInfoSummary > &Pair :WorldInfo.SummaryMap) { const UParticleSystem *Sys=Pair.Key; FPSCInfoSummary &Info=Pair.Value; { PrintPSCInfo(Sys, Info); } } UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("|-- All Ticking or Managed Components By System --------------------------------------------|")); UE_LOG(LogParticles, Log, TEXT("|-------------------------------------------------------------------------------------------|")); for(TPair< UParticleSystem *, FPSCInfoSummary > &Pair :WorldInfo.SummaryMap) { const UParticleSystem *Sys=Pair.Key; FPSCInfoSummary &Info=Pair.Value; if(Info.NumManaged > 0||Info.NumTicking > 0) { UE_LOG(LogParticles, Log, TEXT("|-- Sys: %s -------------------------------------------------------|"), Sys ? *Sys->GetFullName() :TEXT("null")); Info.Components.Sort([](const FPSCInfo &A, const FPSCInfo &B) { return !A.bIsActive+!A.bIsSignificant+!A.bIsVisible< !B.bIsActive+!B.bIsSignificant+!B.bIsVisible;}); for(FPSCInfo &PSCInfo :Info.Components) { bool bTickManaged=PSCInfo.PSC->IsTickManaged(); if(PSCInfo.PSC->IsComponentTickEnabled()) { UE_LOG(LogParticles, Log, TEXT("| PSC: %p | Ticking: %d | Managed: %d | Active: %d | Sig: %d | Vis: %d | Num: %d | %s"), PSCInfo.PSC, !bTickManaged, bTickManaged, PSCInfo.bIsActive, PSCInfo.bIsSignificant, PSCInfo.bIsVisible, PSCInfo.NumActiveParticles, *PSCInfo.PSC->GetFullName()); } } } } }})   
)

◆ GFXLWCTileRecache

float GFXLWCTileRecache = 2

◆ GIsAllowingParticles

ENGINE_API bool GIsAllowingParticles = true

Whether to allow particle systems to perform work.

◆ GParticleLODBias

int32 GParticleLODBias = 0

◆ GParticleView

FSceneView* GParticleView = NULL

◆ GRegisterParticleSystemCustomVersion