ParticleHelper.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    ParticleHelper.h: Particle helper definitions/ macros.
=============================================================================*/
 
#pragma once
 
#include "Math/Quat.h"
#include "Math/RandomStream.h"
#include "Math/Vector4.h"
#include "ParticleVertexFactory.h"
#include "Particles/ParticlePerfStats.h"
#include "ParticleHelper.generated.h"
 
#define _ENABLE_PARTICLE_LOD_INGAME_
 
class FGlobalDynamicIndexBuffer;
class FGlobalDynamicVertexBuffer;
class FMaterialRenderProxy;
class FMeshElementCollector;
class FMeshParticleVertexFactory;
class FParticleSystemSceneProxy;
class FPrimitiveDrawInterface;
class FSceneView;
class FSceneViewFamily;
class FSimpleLightArray;
class UMaterialInterface;
class UParticleModuleRequired;
class UStaticMesh;
namespace ERHIFeatureLevel { enum Type : int; }
struct FBaseParticle;
struct FParticleMeshEmitterInstance;
struct FStaticMeshLODResources;
struct FGlobalDynamicIndexBufferAllocation;
struct FGlobalDynamicVertexBufferAllocation;
 
DECLARE_LOG_CATEGORY_EXTERN(LogParticles, Log, All);
 
UENUM()
enum EParticleDetailMode : int
{
    PDM_Low UMETA(DisplayName = "Low"),
    PDM_Medium UMETA(DisplayName = "Medium"),
    PDM_High UMETA(DisplayName = "High"),
    PDM_Epic UMETA(DisplayName = "Epic"),
    PDM_MAX UMETA(Hidden),
};
inline const int32 PDM_DefaultValue = 0xFFFF;
 
 
/*-----------------------------------------------------------------------------
    Helper macros.
-----------------------------------------------------------------------------*/
//  Macro fun.
#define _PARTICLES_USE_PREFETCH_
#if defined(_PARTICLES_USE_PREFETCH_)
    #define PARTICLE_PREFETCH(Index)                    FPlatformMisc::Prefetch( ParticleData, ParticleStride * ParticleIndices[Index] )
    #define PARTICLE_INSTANCE_PREFETCH(Instance, Index) FPlatformMisc::Prefetch( Instance->ParticleData, Instance->ParticleStride * Instance->ParticleIndices[Index] )
    #define PARTICLE_OWNER_PREFETCH(Index)              FPlatformMisc::Prefetch( Owner->ParticleData, Owner->ParticleStride * Owner->ParticleIndices[Index] )
#else   //#if defined(_PARTICLES_USE_PREFETCH_)
    #define PARTICLE_PREFETCH(Index)                    
    #define PARTICLE_INSTANCE_PREFETCH(Instance, Index) 
    #define PARTICLE_OWNER_PREFETCH(Index)              
#endif  //#if defined(_PARTICLES_USE_PREFETCH_)
 
#define DECLARE_PARTICLE(Name,Address)      \
    FBaseParticle& Name = *((FBaseParticle*) (Address));
 
#define DECLARE_PARTICLE_CONST(Name,Address)        \
    const FBaseParticle& Name = *((const FBaseParticle*) (Address));
 
#define DECLARE_PARTICLE_PTR(Name,Address)      \
    FBaseParticle* Name = (FBaseParticle*) (Address);
 
#define BEGIN_UPDATE_LOOP                                                                                               \
    {                                                                                                                   \
        int32&          ActiveParticles = Context.Owner.ActiveParticles;                                                \
        int32           Offset  = Context.Offset;                                                                       \
        uint32          CurrentOffset   = Offset;                                                                       \
        float           DeltaTime = Context.DeltaTime;                                                                  \
        const uint8*    ParticleData    = Context.Owner.ParticleData;                                                   \
        const uint32    ParticleStride  = Context.Owner.ParticleStride;                                                 \
        uint16*         ParticleIndices = Context.Owner.ParticleIndices;                                                \
        for(int32 i=ActiveParticles-1; i>=0; i--)                                                                       \
        {                                                                                                               \
            const int32 CurrentIndex    = ParticleIndices[i];                                                           \
            const uint8* ParticleBase   = ParticleData + CurrentIndex * ParticleStride;                                 \
            FBaseParticle& Particle     = *((FBaseParticle*) ParticleBase);                                             \
            if ((Particle.Flags & STATE_Particle_Freeze) == 0)                                                          \
            {                                                                                                           \
 
#define END_UPDATE_LOOP                                                                                                 \
            }                                                                                                           \
            CurrentOffset               = Offset;                                                                       \
        }                                                                                                               \
    }
 
#define CONTINUE_UPDATE_LOOP                                                                                            \
        CurrentOffset = Offset;                                                                                         \
        continue;
 
#define SPAWN_INIT                                                                                                      \
    const int32     ActiveParticles = Context.Owner.ActiveParticles;                                                    \
    const uint32    ParticleStride  = Context.Owner.ParticleStride;                                                     \
    uint32          CurrentOffset   = Context.Offset;                                                                   \
    FBaseParticle*  ParticleBase    = Context.ParticleBase;                                                             \
    FBaseParticle&  Particle        = *(ParticleBase);
 
#define PARTICLE_ELEMENT(Type,Name)                                                                                     \
    Type& Name = *((Type*)((uint8*)ParticleBase + CurrentOffset));                                                              \
    CurrentOffset += sizeof(Type);
 
#define KILL_CURRENT_PARTICLE                                                                                           \
    {                                                                                                                   \
        ParticleIndices[i]                  = ParticleIndices[ActiveParticles-1];                                       \
        ParticleIndices[ActiveParticles-1]  = CurrentIndex;                                                             \
        ActiveParticles--;                                                                                              \
    }
 
/*-----------------------------------------------------------------------------
    Helper functions.
-----------------------------------------------------------------------------*/
 
inline void Particle_SetColorFromVector(const FVector3f& InColorVec, const float InAlpha, FLinearColor& OutColor)
{
    OutColor.R = InColorVec.X;
    OutColor.G = InColorVec.Y;
    OutColor.B = InColorVec.Z;
    OutColor.A = InAlpha;
}
 
/*-----------------------------------------------------------------------------
    Forward declarations
-----------------------------------------------------------------------------*/
//  Emitter and module types
class UParticleEmitter;
class UParticleSpriteEmitter;
class UParticleModule;
// Data types
class UParticleModuleTypeDataMesh;
class UParticleModuleTypeDataBeam2;
class UParticleModuleTypeDataTrail2;
 
class UParticleSystem;
 
class UParticleModuleBeamSource;
class UParticleModuleBeamTarget;
class UParticleModuleBeamNoise;
class UParticleModuleBeamModifier;
 
class UParticleModuleTrailSource;
class UParticleModuleTrailSpawn;
class UParticleModuleTrailTaper;
 
class UParticleModuleOrientationAxisLock;
 
class UParticleLODLevel;
 
struct FDynamicBeam2EmitterData;
struct FDynamicTrail2EmitterData;
 
struct FParticleSpriteEmitterInstance;
struct FParticleMeshEmitterInstance;
struct FParticleBeam2EmitterInstance;
 
struct FStaticMeshLODResources;
 
// Special module indices...
#define INDEX_TYPEDATAMODULE    (INDEX_NONE - 1)
#define INDEX_REQUIREDMODULE    (INDEX_NONE - 2)
#define INDEX_SPAWNMODULE       (INDEX_NONE - 3)
 
/*-----------------------------------------------------------------------------
    FBaseParticle
-----------------------------------------------------------------------------*/
// Mappings for 'standard' particle data
// Only used when required.
struct FBaseParticle
{
    // 48 bytes
    FVector     OldLocation;            // Last frame's location, used for collision
    FVector     Location;               // Current location
 
    // 16 bytes
    FVector3f       BaseVelocity;           // Velocity = BaseVelocity at the start of each frame.
    float           Rotation;               // Rotation of particle (in Radians)
 
    // 16 bytes
    FVector3f       Velocity;               // Current velocity, gets reset to BaseVelocity each frame to allow 
    float           BaseRotationRate;       // Initial angular velocity of particle (in Radians per second)
 
    // 16 bytes
    FVector3f       BaseSize;               // Size = BaseSize at the start of each frame
    float           RotationRate;           // Current rotation rate, gets reset to BaseRotationRate each frame
 
    // 16 bytes
    FVector3f       Size;                   // Current size, gets reset to BaseSize each frame
    int32           Flags;                  // Flags indicating various particle states
 
    // 16 bytes
    FLinearColor    Color;                  // Current color of particle.
 
    // 16 bytes
    FLinearColor    BaseColor;              // Base color of the particle
 
    // 16 bytes
    float           RelativeTime;           // Relative time, range is 0 (==spawn) to 1 (==death)
    float           OneOverMaxLifetime;     // Reciprocal of lifetime
    float           Placeholder0;
    float           Placeholder1;
};
 
/*-----------------------------------------------------------------------------
    Particle State Flags
-----------------------------------------------------------------------------*/
enum EParticleStates
{
    STATE_Particle_JustSpawned          = 0x02000000,
    STATE_Particle_Freeze               = 0x04000000,
    STATE_Particle_IgnoreCollisions     = 0x08000000,
    STATE_Particle_FreezeTranslation    = 0x10000000,
    STATE_Particle_FreezeRotation       = 0x20000000,
    STATE_Particle_CollisionIgnoreCheck = STATE_Particle_Freeze |STATE_Particle_IgnoreCollisions | STATE_Particle_FreezeTranslation| STATE_Particle_FreezeRotation,
    STATE_Particle_DelayCollisions      = 0x40000000,
    STATE_Particle_CollisionHasOccurred = 0x80000000,
    STATE_Mask = 0xFE000000,
    STATE_CounterMask = (~STATE_Mask)
};
 
/*-----------------------------------------------------------------------------
    FParticlesStatGroup
-----------------------------------------------------------------------------*/
 
DECLARE_STATS_GROUP(TEXT("ParticlesOverview"), STATGROUP_ParticlesOverview, STATCAT_Advanced);
DECLARE_CYCLE_STAT_EXTERN(TEXT("GT Total"), STAT_ParticlesOverview_GT, STATGROUP_ParticlesOverview, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("GT Concurrent Total"), STAT_ParticlesOverview_GT_CNC, STATGROUP_ParticlesOverview, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("RT Total"), STAT_ParticlesOverview_RT, STATGROUP_ParticlesOverview, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("RT Concurrent Total"), STAT_ParticlesOverview_RT_CNC, STATGROUP_ParticlesOverview, );
 
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Sprite Particles"),STAT_SpriteParticles,STATGROUP_Particles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Sprite Ptcls Spawned"),STAT_SpriteParticlesSpawned,STATGROUP_Particles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Sprite Ptcls Updated"),STAT_SpriteParticlesUpdated,STATGROUP_Particles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Sprite Ptcls Killed"),STAT_SpriteParticlesKilled,STATGROUP_Particles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Particle Draw Calls"),STAT_ParticleDrawCalls,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Sort Time RT"),STAT_SortingTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Sprite Render Time RT"),STAT_SpriteRenderingTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Sprite Tick Time GT"),STAT_SpriteTickTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Sprite Spawn Time GT"),STAT_SpriteSpawnTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("PSys Comp Tick Time GT"),STAT_PSysCompTickTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Particle Collision Time GT"),STAT_ParticleCollisionTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Particle SkelMeshSurf Time GT"),STAT_ParticleSkelMeshSurfTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Particle Pool Time RT"),STAT_ParticlePoolTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Particle Compute Time GT,AT"),STAT_ParticleComputeTickTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Particle Finalize Time GT"),STAT_ParticleFinalizeTickTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Particle GT Stall Time"),STAT_GTSTallTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Particle Render Time RT"),STAT_ParticleRenderingTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Particle Packing Time RT"),STAT_ParticlePackingTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("SetTemplate Time GT"),STAT_ParticleSetTemplateTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Initialize Time GT"),STAT_ParticleInitializeTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Activate Time GT"),STAT_ParticleActivateTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Async Work Time"),STAT_ParticleAsyncTime,STATGROUP_Particles, );           // regardless of if it is actually performed on other threads or not
DECLARE_CYCLE_STAT_EXTERN(TEXT("Wait For ASync Time"),STAT_ParticleAsyncWaitTime,STATGROUP_Particles, );   // can be either performed on this thread or a true wait
DECLARE_CYCLE_STAT_EXTERN(TEXT("Update Bounds Time GT"),STAT_ParticleUpdateBounds,STATGROUP_Particles, );
 
DECLARE_MEMORY_STAT_EXTERN(TEXT("Ptcls Data GT Mem"),STAT_GTParticleData,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Ptcls Data GT Mem MAX"),STAT_GTParticleData_MAX,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Ptcls Data RT Mem"),STAT_RTParticleData,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Ptcls Data RT Mem MAX"),STAT_RTParticleData_MAX,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Ptcls Data RT Largest"),STAT_RTParticleData_Largest,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Ptcls Data RT Largest MAX"),STAT_RTParticleData_Largest_MAX,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynPSysComp Mem"),STAT_DynamicPSysCompMem,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynPSysComp Mem MAX"),STAT_DynamicPSysCompMem_MAX,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynEmitter Mem"),STAT_DynamicEmitterMem,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynEmitter Mem MAX"),STAT_DynamicEmitterMem_MAX,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynEmitter GTMem Waste"),STAT_DynamicEmitterGTMem_Waste,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynEmitter GTMem Largest"),STAT_DynamicEmitterGTMem_Largest,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynEmitter GTMem Waste MAX"),STAT_DynamicEmitterGTMem_Waste_MAX,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynEmitter GTMem Largest MAX"),STAT_DynamicEmitterGTMem_Largest_MAX,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynPSysComp Count"),STAT_DynamicPSysCompCount,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynPSysComp Count MAX"),STAT_DynamicPSysCompCount_MAX,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynEmitter Count"),STAT_DynamicEmitterCount,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynEmitter Count Max"),STAT_DynamicEmitterCount_MAX,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynSprite Count"),STAT_DynamicSpriteCount,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynSprite Max"),STAT_DynamicSpriteCount_MAX,STATGROUP_ParticleMem, );
DECLARE_MEMORY_STAT_EXTERN(TEXT("DynSprite GT Mem"),STAT_DynamicSpriteGTMem,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynSprite GT Mem Max"),STAT_DynamicSpriteGTMem_MAX,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynSubUV Count"),STAT_DynamicSubUVCount,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynSubUV Max"),STAT_DynamicSubUVCount_MAX,STATGROUP_ParticleMem, );
DECLARE_MEMORY_STAT_EXTERN(TEXT("DynSubUV GT Mem"),STAT_DynamicSubUVGTMem,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynSubUV GT Mem Max"),STAT_DynamicSubUVGTMem_Max,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynMesh Count"),STAT_DynamicMeshCount,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynMesh Max"),STAT_DynamicMeshCount_MAX,STATGROUP_ParticleMem, );
DECLARE_MEMORY_STAT_EXTERN(TEXT("DynMesh GT Mem"),STAT_DynamicMeshGTMem,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynMesh GT Mem Max"),STAT_DynamicMeshGTMem_MAX,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynBeam Count"),STAT_DynamicBeamCount,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynBeam Max"),STAT_DynamicBeamCount_MAX,STATGROUP_ParticleMem, );
DECLARE_MEMORY_STAT_EXTERN(TEXT("DynBeam GT Mem"),STAT_DynamicBeamGTMem,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynBeam GT Mem Max"),STAT_DynamicBeamGTMem_MAX,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynRibbon Count"),STAT_DynamicRibbonCount,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynRibbon Max"),STAT_DynamicRibbonCount_MAX,STATGROUP_ParticleMem, );
DECLARE_MEMORY_STAT_EXTERN(TEXT("DynRibbon GT Mem"),STAT_DynamicRibbonGTMem,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynRibbon GT Mem Max"),STAT_DynamicRibbonGTMem_MAX,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynAnimTrail Count"),STAT_DynamicAnimTrailCount,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynAnimTrail Max"),STAT_DynamicAnimTrailCount_MAX,STATGROUP_ParticleMem, );
DECLARE_MEMORY_STAT_EXTERN(TEXT("DynAnimTrail GT Mem"),STAT_DynamicAnimTrailGTMem,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynAnimTrail GT Mem Max"),STAT_DynamicAnimTrailGTMem_MAX,STATGROUP_ParticleMem, );
DECLARE_MEMORY_STAT_EXTERN(TEXT("DynUntracked Mem"),STAT_DynamicUntrackedGTMem,STATGROUP_ParticleMem, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("DynUntracked Mem Max"),STAT_DynamicUntrackedGTMem_MAX,STATGROUP_ParticleMem, );
 
// GPU Particle stats.
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Sprites"),STAT_GPUSpriteParticles,STATGROUP_GPUParticles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Sprites Spawned"),STAT_GPUSpritesSpawned,STATGROUP_GPUParticles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Sorted Emitters"),STAT_SortedGPUEmitters,STATGROUP_GPUParticles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Sorted Particles"),STAT_SortedGPUParticles,STATGROUP_GPUParticles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Free Tiles"),STAT_FreeGPUTiles,STATGROUP_GPUParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Sprite Tick Time"),STAT_GPUSpriteTickTime,STATGROUP_GPUParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Sprite Spawn Time"),STAT_GPUSpriteSpawnTime,STATGROUP_GPUParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Sprite PreRender Time"),STAT_GPUSpritePreRenderTime,STATGROUP_GPUParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Sprite Render Time"),STAT_GPUSpriteRenderingTime,STATGROUP_GPUParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("GPU Particle Tick Time"),STAT_GPUParticleTickTime,STATGROUP_GPUParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Build Sim Commands"),STAT_GPUParticleBuildSimCmdsTime,STATGROUP_GPUParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Misc1"),STAT_GPUParticleMisc1,STATGROUP_GPUParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Misc2"),STAT_GPUParticleMisc2,STATGROUP_GPUParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Misc3"),STAT_GPUParticleMisc3,STATGROUP_GPUParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Injection Tick Time"), STAT_GPUParticlesInjectionTime, STATGROUP_GPUParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Execute Simulation Commands Time"), STAT_GPUParticlesSimulationCommands, STATGROUP_GPUParticles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Single Iteration Emitters"), STAT_GPUSingleIterationEmitters, STATGROUP_GPUParticles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Multi Iterations Emitters"), STAT_GPUMultiIterationsEmitters, STATGROUP_GPUParticles, );
 
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Mesh Particles"),STAT_MeshParticles,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Mesh Render Time RT"),STAT_MeshRenderingTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Mesh Tick Time GT,AT"),STAT_MeshTickTime,STATGROUP_Particles, );
 
struct FParticleSpriteVertex
{
    FVector3f Position;
    float RelativeTime;
    FVector3f   OldPosition;
    float ParticleId;
    FVector2f Size;
    float Rotation;
    float SubImageIndex;
    FLinearColor Color;
};
 
struct FParticleSpriteVertexNonInstanced
{
    FVector2f UV;
    FVector3f Position;
    float RelativeTime;
    FVector3f   OldPosition;
    float ParticleId;
    FVector2f Size;
    float Rotation;
    float SubImageIndex;
    FLinearColor Color;
};
 
 
//  FParticleSpriteVertexDynamicParameter
struct FParticleVertexDynamicParameter
{
    float           DynamicValue[4];
};
 
//  FParticleBeamTrailVertex
struct FParticleBeamTrailVertex
{
    FVector3f Position;
    float RelativeTime;
    FVector3f   OldPosition;
    float ParticleId;
    FVector2f Size;
    float Rotation;
    float SubImageIndex;
    FLinearColor Color;
 
    float           Tex_U;
    float           Tex_V;
 
    float           Tex_U2;
    float           Tex_V2;
};
 
//  FParticleBeamTrailVertexDynamicParameter
struct FParticleBeamTrailVertexDynamicParameter
{
    float           DynamicValue[4];
};
 
// Per-particle data sent to the GPU.
struct FMeshParticleInstanceVertex
{
    FLinearColor Color;
 
    FVector4f Transform[3];
 
    FVector4f Velocity;
 
    int16 SubUVParams[4];
 
    float SubUVLerp;
 
    float RelativeTime;
};
 
struct FMeshParticleInstanceVertexDynamicParameter
{
    float DynamicValue[4];
};
 
struct FMeshParticleInstanceVertexPrevTransform
{
    FVector4f PrevTransform0;
    FVector4f PrevTransform1;
    FVector4f PrevTransform2;
};
 
//
//  Trail emitter flags and macros
//
// ForceKill: Indicates all the particles in the trail should be killed in the next KillParticles call.
#define TRAIL_EMITTER_FLAG_FORCEKILL    0x00000000
// DeadTrail: indicates that the particle is the start of a trail than should no longer spawn.
//            It should just fade out as the particles die...
#define TRAIL_EMITTER_FLAG_DEADTRAIL    0x10000000
// Middle: indicates the particle is in the middle of a trail.
#define TRAIL_EMITTER_FLAG_MIDDLE       0x20000000
// Start: indicates the particle is the start of a trail.
#define TRAIL_EMITTER_FLAG_START        0x40000000
// End: indicates the particle is the end of a trail.
#define TRAIL_EMITTER_FLAG_END          0x80000000
 
//#define TRAIL_EMITTER_FLAG_ONLY           (TRAIL_EMITTER_FLAG_START | TRAIL_EMITTER_FLAG_END)
#define TRAIL_EMITTER_FLAG_MASK         0xf0000000
#define TRAIL_EMITTER_PREV_MASK         0x0fffc000
#define TRAIL_EMITTER_PREV_SHIFT        14
#define TRAIL_EMITTER_NEXT_MASK         0x00003fff
#define TRAIL_EMITTER_NEXT_SHIFT        0
 
#define TRAIL_EMITTER_NULL_PREV         (TRAIL_EMITTER_PREV_MASK >> TRAIL_EMITTER_PREV_SHIFT)
#define TRAIL_EMITTER_NULL_NEXT         (TRAIL_EMITTER_NEXT_MASK >> TRAIL_EMITTER_NEXT_SHIFT)
 
// Helper macros
#define TRAIL_EMITTER_CHECK_FLAG(val, mask, flag)               ((val & mask) == flag)
#define TRAIL_EMITTER_SET_FLAG(val, mask, flag)                 ((val & ~mask) | flag)
#define TRAIL_EMITTER_GET_PREVNEXT(val, mask, shift)            ((val & mask) >> shift)
#define TRAIL_EMITTER_SET_PREVNEXT(val, mask, shift, setval)    ((val & ~mask) | ((setval << shift) & mask))
 
// Start/end accessor macros
#define TRAIL_EMITTER_IS_START(index)       TRAIL_EMITTER_CHECK_FLAG(index, TRAIL_EMITTER_FLAG_MASK, TRAIL_EMITTER_FLAG_START)
#define TRAIL_EMITTER_SET_START(index)      TRAIL_EMITTER_SET_FLAG(index, TRAIL_EMITTER_FLAG_MASK, TRAIL_EMITTER_FLAG_START)
 
#define TRAIL_EMITTER_IS_END(index)         TRAIL_EMITTER_CHECK_FLAG(index, TRAIL_EMITTER_FLAG_MASK, TRAIL_EMITTER_FLAG_END)
#define TRAIL_EMITTER_SET_END(index)        TRAIL_EMITTER_SET_FLAG(index, TRAIL_EMITTER_FLAG_MASK, TRAIL_EMITTER_FLAG_END)
 
#define TRAIL_EMITTER_IS_MIDDLE(index)      TRAIL_EMITTER_CHECK_FLAG(index, TRAIL_EMITTER_FLAG_MASK, TRAIL_EMITTER_FLAG_MIDDLE)
#define TRAIL_EMITTER_SET_MIDDLE(index)     TRAIL_EMITTER_SET_FLAG(index, TRAIL_EMITTER_FLAG_MASK, TRAIL_EMITTER_FLAG_MIDDLE)
 
// Only is used for the first emission from the emitter
#define TRAIL_EMITTER_IS_ONLY(index)        (TRAIL_EMITTER_CHECK_FLAG(index, TRAIL_EMITTER_FLAG_MASK, TRAIL_EMITTER_FLAG_START) && \
                                            (TRAIL_EMITTER_GET_NEXT(index) == TRAIL_EMITTER_NULL_NEXT))
#define TRAIL_EMITTER_SET_ONLY(index)       TRAIL_EMITTER_SET_FLAG(index, TRAIL_EMITTER_FLAG_MASK, TRAIL_EMITTER_FLAG_START)
 
#define TRAIL_EMITTER_IS_FORCEKILL(index)   TRAIL_EMITTER_CHECK_FLAG(index, TRAIL_EMITTER_FLAG_MASK, TRAIL_EMITTER_FLAG_FORCEKILL)
#define TRAIL_EMITTER_SET_FORCEKILL(index)  TRAIL_EMITTER_SET_FLAG(index, TRAIL_EMITTER_FLAG_MASK, TRAIL_EMITTER_FLAG_FORCEKILL)
 
#define TRAIL_EMITTER_IS_DEADTRAIL(index)   TRAIL_EMITTER_CHECK_FLAG(index, TRAIL_EMITTER_FLAG_MASK, TRAIL_EMITTER_FLAG_DEADTRAIL)
#define TRAIL_EMITTER_SET_DEADTRAIL(index)  TRAIL_EMITTER_SET_FLAG(index, TRAIL_EMITTER_FLAG_MASK, TRAIL_EMITTER_FLAG_DEADTRAIL)
 
#define TRAIL_EMITTER_IS_HEAD(index)        (TRAIL_EMITTER_IS_START(index) || TRAIL_EMITTER_IS_DEADTRAIL(index))
#define TRAIL_EMITTER_IS_HEADONLY(index)    ((TRAIL_EMITTER_IS_START(index) || TRAIL_EMITTER_IS_DEADTRAIL(index)) && \
                                            (TRAIL_EMITTER_GET_NEXT(index) == TRAIL_EMITTER_NULL_NEXT))
 
// Prev/Next accessor macros
#define TRAIL_EMITTER_GET_PREV(index)       TRAIL_EMITTER_GET_PREVNEXT(index, TRAIL_EMITTER_PREV_MASK, TRAIL_EMITTER_PREV_SHIFT)
#define TRAIL_EMITTER_SET_PREV(index, prev) TRAIL_EMITTER_SET_PREVNEXT(index, TRAIL_EMITTER_PREV_MASK, TRAIL_EMITTER_PREV_SHIFT, prev)
#define TRAIL_EMITTER_GET_NEXT(index)       TRAIL_EMITTER_GET_PREVNEXT(index, TRAIL_EMITTER_NEXT_MASK, TRAIL_EMITTER_NEXT_SHIFT)
#define TRAIL_EMITTER_SET_NEXT(index, next) TRAIL_EMITTER_SET_PREVNEXT(index, TRAIL_EMITTER_NEXT_MASK, TRAIL_EMITTER_NEXT_SHIFT, next)
 
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Trail Particles"),STAT_TrailParticles,STATGROUP_Particles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Trail Ptcl Render Calls"),STAT_TrailParticlesRenderCalls,STATGROUP_TrailParticles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Trail Ptcls Spawned"),STAT_TrailParticlesSpawned,STATGROUP_Particles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Trail Tick Calls"),STAT_TrailParticlesTickCalls,STATGROUP_TrailParticles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Trail Ptcls Killed"),STAT_TrailParticlesKilled,STATGROUP_Particles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Trail Ptcl Tris"),STAT_TrailParticlesTrianglesRendered,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Trail FillVertex Time RT"),STAT_TrailFillVertexTime,STATGROUP_TrailParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Trail FillIndex Time RT"),STAT_TrailFillIndexTime,STATGROUP_TrailParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Trail Render Time RT"),STAT_TrailRenderingTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Trail Tick Time GT"),STAT_TrailTickTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("AnimTrail Notify Time GT"),STAT_AnimTrailNotifyTime,STATGROUP_Particles, );
 
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Beam Particles"),STAT_BeamParticles,STATGROUP_Particles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Beam Ptcl Render Calls"),STAT_BeamParticlesRenderCalls,STATGROUP_BeamParticles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Beam Ptcls Spawned"),STAT_BeamParticlesSpawned,STATGROUP_Particles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Beam Ptcl Update Calls"),STAT_BeamParticlesUpdateCalls,STATGROUP_BeamParticles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Beam Ptcls Updated"),STAT_BeamParticlesUpdated,STATGROUP_BeamParticles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Beam Ptcls Killed"),STAT_BeamParticlesKilled,STATGROUP_Particles, );
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Beam Ptcl Tris"),STAT_BeamParticlesTrianglesRendered,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Beam Spawn Time GT"),STAT_BeamSpawnTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Beam FillVertex Time RT"),STAT_BeamFillVertexTime,STATGROUP_BeamParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Beam FillIndex Time RT"),STAT_BeamFillIndexTime,STATGROUP_BeamParticles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Beam Render Time RT"),STAT_BeamRenderingTime,STATGROUP_Particles, );
DECLARE_CYCLE_STAT_EXTERN(TEXT("Beam Tick Time GT"),STAT_BeamTickTime,STATGROUP_Particles, );
 
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("Mesh Particle Polys"), STAT_MeshParticlePolys, STATGROUP_Particles, );
 
//
//  Helper structures for payload data...
//
 
//
//  SubUV-related payloads
//
struct FFullSubUVPayload
{
    // The integer portion indicates the sub-image index.
    // The fractional portion indicates the lerp factor.
    float ImageIndex;
    float RandomImageTime;
};
 
//
//  AttractorParticle
//
struct FAttractorParticlePayload
{
    int32           SourceIndex;
    uint32      SourcePointer;
    FVector3f       SourceVelocity;
};
 
struct FLightParticlePayload
{
    FVector3f       ColorScale;
    uint64      LightId;
    float       RadiusScale;
    float       LightExponent;
    float       InverseExposureBlend;
    bool        bValid;
    bool        bAffectsTranslucency;
    bool        bHighQuality;
};
 
//
//  TypeDataBeam2 payload
//
#define BEAM2_TYPEDATA_LOCKED_MASK                  0x80000000
#define BEAM2_TYPEDATA_LOCKED(x)                    ((x & BEAM2_TYPEDATA_LOCKED_MASK) != 0)
#define BEAM2_TYPEDATA_SETLOCKED(x, Locked)         (x = Locked ? (x | BEAM2_TYPEDATA_LOCKED_MASK) : (x & ~BEAM2_TYPEDATA_LOCKED_MASK))
 
#define BEAM2_TYPEDATA_FREQUENCY_MASK               0x00fff000
#define BEAM2_TYPEDATA_FREQUENCY_SHIFT              12
#define BEAM2_TYPEDATA_FREQUENCY(x)                 ((x & BEAM2_TYPEDATA_FREQUENCY_MASK) >> BEAM2_TYPEDATA_FREQUENCY_SHIFT)
#define BEAM2_TYPEDATA_SETFREQUENCY(x, Freq)        (x = ((x & ~BEAM2_TYPEDATA_FREQUENCY_MASK) | (Freq << BEAM2_TYPEDATA_FREQUENCY_SHIFT)))
 
struct FBeam2TypeDataPayload
{
    FVector     SourcePoint;
    FVector     SourceTangent;
    float       SourceStrength;
 
    FVector     TargetPoint;
    FVector     TargetTangent;
    float       TargetStrength;
 
    int32       Lock_Max_NumNoisePoints;
 
    int32       InterpolationSteps;
 
    FVector     Direction;
    double      StepSize;
    int32       Steps;
    float       TravelRatio;
 
    int32       TriangleCount;
 
    int32           Flags;
};
 
struct FBeamParticleSourceTargetPayloadData
{
    int32           ParticleIndex;
};
 
struct FBeamParticleSourceBranchPayloadData
{
    int32           NoiseIndex;
};
 
struct FBeamParticleModifierPayloadData
{
    uint32  bModifyPosition:1;
    uint32  bScalePosition:1;
    uint32  bModifyTangent:1;
    uint32  bScaleTangent:1;
    uint32  bModifyStrength:1;
    uint32  bScaleStrength:1;
    FVector Position;
    FVector Tangent;
    float   Strength;
 
    // Helper functions
    inline void UpdatePosition(FVector& Value)
    {
        if (bModifyPosition == true)
        {
            if (bScalePosition == false)
            {
                Value += Position;
            }
            else
            {
                Value *= Position;
            }
        }
    }
 
    inline void UpdateTangent(FVector& Value, bool bAbsolute)
    {
        if (bModifyTangent == true)
        {
            FVector ModTangent;
            if (bAbsolute == false)
            {
                // Transform the modified tangent so it is relative to the real tangent
                const FQuat RotQuat = FQuat::FindBetweenNormals(FVector(1.0f, 0.0f, 0.0f), Value);
                ModTangent = RotQuat.RotateVector(Tangent);
            }
            else
            {
                ModTangent = Tangent;
            }
 
            if (bScaleTangent == false)
            {
                Value += ModTangent;
            }
            else
            {
                Value *= ModTangent;
            }
        }
    }
 
    inline void UpdateStrength(float& Value)
    {
        if (bModifyStrength == true)
        {
            if (bScaleStrength == false)
            {
                Value += Strength;
            }
            else
            {
                Value *= Strength;
            }
        }
    }
};
 
struct FTrailsBaseTypeDataPayload
{
    int32 Flags;
    int32 TrailIndex;
    int32 TriangleCount;
    float SpawnTime;
    float SpawnDelta;
    float TiledU;
    int32 SpawnedTessellationPoints;
    int32 RenderingInterpCount;
    float PinchScaleFactor;
    uint32 bInterpolatedSpawn:1;
    uint32 bMovementSpawned:1;
};
 
struct FRibbonTypeDataPayload : public FTrailsBaseTypeDataPayload
{
    FVector3f Tangent;
    FVector3f Up;
    int32 SourceIndex;
};
 
struct FAnimTrailTypeDataPayload : public FTrailsBaseTypeDataPayload
{
    //Direction from the first socket sample to the second.
    FVector3f Direction;
    //Tangent of the curve.
    FVector3f Tangent;
    //Half length between the sockets. First vertex = Location - Dir * Length; Second vertex = Location + Dir * Lenght
    float Length;
    float InterpolationParameter;
};
 
struct FMeshRotationPayloadData
{
    FVector3f    InitialOrientation;        // from mesh data module
    FVector3f  InitRotation;                // from init rotation module
    FVector3f  Rotation;
    FVector3f    CurContinuousRotation;
    FVector3f  RotationRate;
    FVector3f  RotationRateBase;
};
 
struct FMeshMotionBlurPayloadData
{
    FVector3f BaseParticlePrevVelocity;
    FVector3f BaseParticlePrevSize;
    FVector3f PayloadPrevRotation;
    FVector3f PayloadPrevOrbitOffset;
    float   BaseParticlePrevRotation;
    float   PayloadPrevCameraOffset;
};
 
struct FLocationEmitterInstancePayload
{
    int32       LastSelectedIndex;
};
 
template <typename ElementType>
class TPreallocatedArrayProxy
{
public:
 
    TPreallocatedArrayProxy() : 
        ArrayMax(0),
        Array(NULL)
    {}
 
    TPreallocatedArrayProxy( uint8* ArrayStart, int32 ArraySize ) :
        ArrayMax( ArraySize ),
        Array( (ElementType*) ArrayStart )
    {}
 
    inline ElementType& operator[]( int32 Index )
    {
        check((Index >= 0) & ((Index < ArrayMax) | ((Index == 0) & (ArrayMax == 0)))); // & and | for one branch
        return Array[Index];
    }
 
    inline const ElementType& operator[]( int32 Index ) const
    {
        check((Index >= 0) & ((Index < ArrayMax) | ((Index == 0) & (ArrayMax == 0)))); // & and | for one branch
        return Array[Index];
    }
 
    int32 Find( const ElementType& Item ) const
    {
        const ElementType* const RESTRICT DataEnd = Array + ArrayMax;
        for(const ElementType* RESTRICT Data = Array; Data < DataEnd; ++Data)
        {
            if( *Data==Item )
            {
                return (int32)(Data - Array);
            }
        }
        return INDEX_NONE;
    }
 
    bool Contains( const ElementType& Item ) const
    {
        return ( Find(Item) != INDEX_NONE );
    }
 
    int32 Num() const
    {
        return ArrayMax;
    }
 
private:
    int32 ArrayMax;
    ElementType* Array;
};
 
struct FModuleLocationBoneSocketParticlePayload
{
    int32 SourceIndex;
};
 
struct FOrbitChainModuleInstancePayload
{
    FVector3f   BaseOffset;
    FVector3f   Offset;
    FVector3f   Rotation;
    FVector3f   BaseRotationRate;
    FVector3f   RotationRate;
    FVector3f   PreviousOffset;
};
 
struct FParticleSpawnPerUnitInstancePayload
{
    float   CurrentDistanceTravelled;
};
 
struct FParticleCollisionPayload
{
    FVector3f   UsedDampingFactor;
    FVector3f   UsedDampingFactorRotation;
    int32       UsedCollisions;
    float   Delay;
};
 
struct FParticleCollisionInstancePayload
{
    uint8 CurrentLODBoundsCheckCount;
    uint8 Padding1;
    uint8 Padding2;
    uint8 Padding3;
};
 
struct FParticleEventInstancePayload
{
    uint32 bSpawnEventsPresent:1;
    uint32 bDeathEventsPresent:1;
    uint32 bCollisionEventsPresent:1;
    uint32 bBurstEventsPresent:1;
 
    int32 SpawnTrackingCount;
    int32 DeathTrackingCount;
    int32 CollisionTrackingCount;
    int32 BurstTrackingCount;
};
 
struct FEmitterDynamicParameterPayload
{
    float DynamicParameterValue[4];
};
 
inline void GetDynamicValueFromPayload(int32 InDynamicPayloadOffset, const FBaseParticle& InParticle, FVector4f& OutDynamicData)
{
    checkSlow(InDynamicPayloadOffset > 0);
    const FEmitterDynamicParameterPayload* DynPayload = ((const FEmitterDynamicParameterPayload*)((uint8*)(&InParticle) + InDynamicPayloadOffset));
    OutDynamicData.X = DynPayload->DynamicParameterValue[0];
    OutDynamicData.Y = DynPayload->DynamicParameterValue[1];
    OutDynamicData.Z = DynPayload->DynamicParameterValue[2];
    OutDynamicData.W = DynPayload->DynamicParameterValue[3];
}
 
struct FCameraOffsetParticlePayload
{
    float   BaseOffset;
    float   Offset;
};
 
struct FParticleRandomSeedInstancePayload
{
    FRandomStream   RandomStream;
};
 
/*-----------------------------------------------------------------------------
    Particle Sorting Helper
-----------------------------------------------------------------------------*/
struct FParticleOrder
{
    int32 ParticleIndex;
 
    union
    {
        float Z;
        uint32 C;
    };
    
    FParticleOrder(int32 InParticleIndex,float InZ):
        ParticleIndex(InParticleIndex),
        Z(InZ)
    {}
 
    FParticleOrder(int32 InParticleIndex,uint32 InC):
        ParticleIndex(InParticleIndex),
        C(InC)
    {}
};
 
 
/*-----------------------------------------------------------------------------
    Async Fill Organizational Structure
-----------------------------------------------------------------------------*/
 
struct FAsyncBufferFillData
{
    FMatrix LocalToWorld;
    FMatrix WorldToLocal;
    const FSceneView*                   View;
    int32                                   VertexCount;
    int32                                   VertexSize; 
    void*                               VertexData;
    int32                                   IndexCount;
    void*                               IndexData;
    int32                                   OutTriangleCount;
    void*                               DynamicParameterData;
 
    FAsyncBufferFillData()
    {
        // this is all POD
        FMemory::Memzero(this,sizeof(FAsyncBufferFillData));
    }
    ~FAsyncBufferFillData()
    {
        FMemory::Memzero(this,sizeof(FAsyncBufferFillData));
    }
};
 
/*-----------------------------------------------------------------------------
    Particle vertex factory pools
-----------------------------------------------------------------------------*/
class FParticleVertexFactoryBase;
 
/*-----------------------------------------------------------------------------
    Particle Dynamic Data
-----------------------------------------------------------------------------*/
 
enum EDynamicEmitterType
{
    DET_Unknown = 0,
    DET_Sprite,
    DET_Mesh,
    DET_Beam2,
    DET_Ribbon,
    DET_AnimTrail,
    DET_Custom
};
 
struct FParticleDataContainer
{
    int32 MemBlockSize;
    int32 ParticleDataNumBytes;
    int32 ParticleIndicesNumShorts;
    uint8* ParticleData; // this is also the memory block we allocated
    uint16* ParticleIndices; // not allocated, this is at the end of the memory block
 
    FParticleDataContainer()
        : MemBlockSize(0)
        , ParticleDataNumBytes(0)
        , ParticleIndicesNumShorts(0)
        , ParticleData(nullptr)
        , ParticleIndices(nullptr)
    {
    }
    ~FParticleDataContainer()
    {
        Free();
    }
    void Alloc(int32 InParticleDataNumBytes, int32 InParticleIndicesNumShorts);
    void Free();
};
 
struct FMacroUVOverride
{
    FMacroUVOverride() : bOverride(false), Radius(0.f), Position(0.f,0.f,0.f) {}
 
    bool    bOverride;
    float   Radius;
    FVector3f Position;
 
    friend inline FArchive& operator<<(FArchive& Ar, FMacroUVOverride& O)
    {
        Ar << O.bOverride;
        Ar << O.Radius;
        Ar << O.Position;
        return Ar;
    }
};
 
struct FDynamicEmitterReplayDataBase
{
    EDynamicEmitterType eEmitterType;
 
    int32 ActiveParticleCount;
 
    int32 ParticleStride;
    FParticleDataContainer DataContainer;
 
    FVector3f Scale;
 
    int32 SortMode;
 
    FMacroUVOverride MacroUVOverride;
 
    FDynamicEmitterReplayDataBase()
        : eEmitterType( DET_Unknown ),
          ActiveParticleCount( 0 ),
          ParticleStride( 0 ),
          Scale( FVector3f( 1.0f ) ),
          SortMode(0)   // Default to PSORTMODE_None          
    {
    }
 
    virtual ~FDynamicEmitterReplayDataBase()
    {
    }
 
    virtual void Serialize( FArchive& Ar )
    {
        int32 EmitterTypeAsInt = eEmitterType;
        Ar << EmitterTypeAsInt;
        eEmitterType = static_cast< EDynamicEmitterType >( EmitterTypeAsInt );
 
        Ar << ActiveParticleCount;
        Ar << ParticleStride;
        
        TArray<uint8> ParticleData;
        TArray<uint16> ParticleIndices;
 
        if (!Ar.IsLoading() && !Ar.IsObjectReferenceCollector())
        {
            if (DataContainer.ParticleDataNumBytes)
            {
                ParticleData.AddUninitialized(DataContainer.ParticleDataNumBytes);
                FMemory::Memcpy(ParticleData.GetData(), DataContainer.ParticleData, DataContainer.ParticleDataNumBytes);
            }
            if (DataContainer.ParticleIndicesNumShorts)
            {
                ParticleIndices.AddUninitialized(DataContainer.ParticleIndicesNumShorts);
                FMemory::Memcpy(ParticleIndices.GetData(), DataContainer.ParticleIndices, DataContainer.ParticleIndicesNumShorts * sizeof(uint16));
            }
        }
 
        Ar << ParticleData;
        Ar << ParticleIndices;
 
        if (Ar.IsLoading())
        {
            DataContainer.Free();
            if (ParticleData.Num())
            {
                DataContainer.Alloc(ParticleData.Num(), ParticleIndices.Num());
                FMemory::Memcpy(DataContainer.ParticleData, ParticleData.GetData(), DataContainer.ParticleDataNumBytes);
                if (DataContainer.ParticleIndicesNumShorts)
                {
                    FMemory::Memcpy(DataContainer.ParticleIndices, ParticleIndices.GetData(), DataContainer.ParticleIndicesNumShorts * sizeof(uint16));
                }
            }
            else
            {
                check(!ParticleIndices.Num());
            }
        }
 
        Ar << Scale;
        Ar << SortMode;
        Ar << MacroUVOverride;
    }
 
};
 
 
 
struct FDynamicEmitterDataBase
{
    FDynamicEmitterDataBase(const class UParticleModuleRequired* RequiredModule);
    
    virtual ~FDynamicEmitterDataBase()
    {
    }
 
    void* operator new(size_t Size);
    void operator delete(void *RawMemory, size_t Size);
 
    virtual void UpdateRenderThreadResourcesEmitter(const FParticleSystemSceneProxy* InOwnerProxy)
    {
    }
 
    virtual void ReleaseRenderThreadResources(const FParticleSystemSceneProxy* InOwnerProxy)
    {
    }
 
    virtual void GetDynamicMeshElementsEmitter(const FParticleSystemSceneProxy* Proxy, const FSceneView* View, const FSceneViewFamily& ViewFamily, int32 ViewIndex, FMeshElementCollector& Collector) const {}
 
    virtual const FMaterialRenderProxy* GetMaterialRenderProxy() = 0;
 
    virtual void GatherSimpleLights(const FParticleSystemSceneProxy* Proxy, const FSceneViewFamily& ViewFamily, FSimpleLightArray& OutParticleLights) const {}
 
    virtual const FDynamicEmitterReplayDataBase& GetSource() const = 0;
 
    virtual const FMacroUVOverride& GetMacroUVOverride() const { return GetSource().MacroUVOverride; }
 
    mutable TStatId StatID;
    uint32  bSelected:1;
    uint32  bValid:1;
 
    int32  EmitterIndex;
};
 
struct FDynamicSpriteEmitterReplayDataBase
    : public FDynamicEmitterReplayDataBase
{
    UMaterialInterface*             MaterialInterface;
    struct FParticleRequiredModule  *RequiredModule;
    FVector3f                           NormalsSphereCenter;
    FVector3f                           NormalsCylinderDirection;
    float                           InvDeltaSeconds;
    FVector3f                       LWCTile;
    int32                           MaxDrawCount;
    int32                           OrbitModuleOffset;
    int32                           DynamicParameterDataOffset;
    int32                           LightDataOffset;
    float                           LightVolumetricScatteringIntensity;
    int32                           CameraPayloadOffset;
    int32                           SubUVDataOffset;
    int32                           SubImages_Horizontal;
    int32                           SubImages_Vertical;
    bool                        bUseLocalSpace;
    bool                        bLockAxis;
    uint8                       ScreenAlignment;
    uint8                       LockAxisFlag;
    uint8                       EmitterRenderMode;
    uint8                       EmitterNormalsMode;
    FVector2f                   PivotOffset;
    bool                        bUseVelocityForMotionBlur;
    bool                        bRemoveHMDRoll;
    float                       MinFacingCameraBlendDistance;
    float                       MaxFacingCameraBlendDistance;
    
    FDynamicSpriteEmitterReplayDataBase();
    ~FDynamicSpriteEmitterReplayDataBase();
 
    virtual void Serialize( FArchive& Ar );
 
};
 
struct FDynamicSpriteEmitterDataBase : public FDynamicEmitterDataBase
{
    FDynamicSpriteEmitterDataBase(const UParticleModuleRequired* RequiredModule) : 
        FDynamicEmitterDataBase(RequiredModule),
        bUsesDynamicParameter( false )
    {
        MaterialResource = nullptr;
    }
 
    virtual ~FDynamicSpriteEmitterDataBase()
    {
    }
 
    const FMaterialRenderProxy* GetMaterialRenderProxy() 
    { 
        return MaterialResource;
    }
 
    void SortSpriteParticles(int32 SortMode, bool bLocalSpace, 
        int32 ParticleCount, const uint8* ParticleData, int32 ParticleStride, const uint16* ParticleIndices,
        const FSceneView* View, const FMatrix& LocalToWorld, FParticleOrder* ParticleOrder) const;
 
    virtual int32 GetDynamicVertexStride(ERHIFeatureLevel::Type /*InFeatureLevel*/) const
    {
        checkf(0, TEXT("GetDynamicVertexStride MUST be overridden"));
        return 0;
    }
 
    virtual int32 GetDynamicParameterVertexStride() const
    {
        checkf(0, TEXT("GetDynamicParameterVertexStride MUST be overridden"));
        return 0;
    }
 
    virtual const FDynamicSpriteEmitterReplayDataBase* GetSourceData() const
    {
        checkf(0, TEXT("GetSourceData MUST be overridden"));
        return NULL;
    }
    
    virtual void GetIndexAllocInfo(int32& OutNumIndices, int32& OutStride ) const
    {
        checkf(0, TEXT("GetIndexAllocInfo is not valid for this class."));
    }
 
    virtual void RenderDebug(const FParticleSystemSceneProxy* Proxy, FPrimitiveDrawInterface* PDI, const FSceneView* View, bool bCrosses) const;
 
    virtual void DoBufferFill(FAsyncBufferFillData& Me) const
    {
        // Must be overridden if called
        check(0);
    }
 
    void BuildViewFillData(
        const FParticleSystemSceneProxy* Proxy, 
        const FSceneView *InView, 
        int32 InVertexCount, 
        int32 InVertexSize, 
        int32 InDynamicParameterVertexSize, 
        FGlobalDynamicIndexBuffer& DynamicIndexBuffer,
        FGlobalDynamicVertexBuffer& DynamicVertexBuffer,
        FGlobalDynamicVertexBufferAllocation& DynamicVertexAllocation,
        FGlobalDynamicIndexBufferAllocation& DynamicIndexAllocation,
        FGlobalDynamicVertexBufferAllocation* DynamicParameterAllocation,
        FAsyncBufferFillData& Data) const;
 
    const FMaterialRenderProxy* MaterialResource;
    uint32 bUsesDynamicParameter:1;
};
 
struct FDynamicSpriteEmitterReplayData
    : public FDynamicSpriteEmitterReplayDataBase
{
    FDynamicSpriteEmitterReplayData()
    {
    }
 
 
    virtual void Serialize( FArchive& Ar )
    {
        // Call parent implementation
        FDynamicSpriteEmitterReplayDataBase::Serialize( Ar );
 
        // ...
    }
 
};
 
struct FDynamicSpriteEmitterData : public FDynamicSpriteEmitterDataBase
{
    FDynamicSpriteEmitterData(const UParticleModuleRequired* RequiredModule) :
        FDynamicSpriteEmitterDataBase(RequiredModule)
    {
    }
 
    ~FDynamicSpriteEmitterData()
    {
    }
 
    void Init( bool bInSelected );
 
    virtual int32 GetDynamicVertexStride(ERHIFeatureLevel::Type InFeatureLevel) const override
    {
        return sizeof(FParticleSpriteVertex);
    }
 
    virtual int32 GetDynamicParameterVertexStride() const override
    {
        return sizeof(FParticleVertexDynamicParameter);
    }
 
    virtual const FDynamicSpriteEmitterReplayDataBase* GetSourceData() const override
    {
        return &Source;
    }
 
    bool GetVertexAndIndexData(void* VertexData, void* DynamicParameterVertexData, void* FillIndexData, FParticleOrder* ParticleOrder, const FVector& InCameraPosition, const FMatrix& InLocalToWorld, uint32 InstanceFactor) const;
 
    virtual void GatherSimpleLights(const FParticleSystemSceneProxy* Proxy, const FSceneViewFamily& ViewFamily, FSimpleLightArray& OutParticleLights) const override;
 
    virtual void GetDynamicMeshElementsEmitter(const FParticleSystemSceneProxy* Proxy, const FSceneView* View, const FSceneViewFamily& ViewFamily, int32 ViewIndex, FMeshElementCollector& Collector) const override;
 
    virtual void UpdateRenderThreadResourcesEmitter(const FParticleSystemSceneProxy* InOwnerProxy) override;
 
    virtual const FDynamicEmitterReplayDataBase& GetSource() const override
    {
        return Source;
    }
 
    FDynamicSpriteEmitterReplayData Source;
 
    FParticleSpriteUniformParameters UniformParameters;
};
 
struct FDynamicMeshEmitterReplayData
    : public FDynamicSpriteEmitterReplayDataBase
{
    int32   SubUVInterpMethod;
    int32   SubUVDataOffset;
    int32   SubImages_Horizontal;
    int32   SubImages_Vertical;
    bool    bScaleUV;
    int32   MeshRotationOffset;
    int32   MeshMotionBlurOffset;
    uint8   MeshAlignment;
    bool    bMeshRotationActive;
    FVector3f   LockedAxis; 
 
    FDynamicMeshEmitterReplayData() : 
        SubUVInterpMethod( 0 ),
        SubUVDataOffset( 0 ),
        SubImages_Horizontal( 0 ),
        SubImages_Vertical( 0 ),
        bScaleUV( false ),
        MeshRotationOffset( 0 ),
        MeshMotionBlurOffset( 0 ),
        MeshAlignment( 0 ),
        bMeshRotationActive( false ),
        LockedAxis(1.0f, 0.0f, 0.0f)
    {
    }
 
 
    virtual void Serialize( FArchive& Ar )
    {
        // Call parent implementation
        FDynamicSpriteEmitterReplayDataBase::Serialize( Ar );
        
        Ar << SubUVInterpMethod;
        Ar << SubUVDataOffset;
        Ar << SubImages_Horizontal;
        Ar << SubImages_Vertical;
        Ar << bScaleUV;
        Ar << MeshRotationOffset;
        Ar << MeshMotionBlurOffset;
        Ar << MeshAlignment;
        Ar << bMeshRotationActive;
        Ar << LockedAxis;
    }
 
};
 
 
struct FDynamicMeshEmitterData : public FDynamicSpriteEmitterDataBase
{
    FDynamicMeshEmitterData(const UParticleModuleRequired* RequiredModule);
 
    virtual ~FDynamicMeshEmitterData();
 
    uint32 GetMeshLODIndexFromProxy(const FParticleSystemSceneProxy *InOwnerProxy) const;
    void Init(  bool bInSelected,
                const FParticleMeshEmitterInstance* InEmitterInstance,
                UStaticMesh* InStaticMesh,
                bool InUseStaticMeshLODs,
                float InLODSizeScale,
                ERHIFeatureLevel::Type InFeatureLevel);
 
    virtual void UpdateRenderThreadResourcesEmitter(const FParticleSystemSceneProxy* InOwnerProxy) override;
 
    virtual void ReleaseRenderThreadResources(const FParticleSystemSceneProxy* InOwnerProxy) override;
 
    virtual void GetDynamicMeshElementsEmitter(const FParticleSystemSceneProxy* Proxy, const FSceneView* View, const FSceneViewFamily& ViewFamily, int32 ViewIndex, FMeshElementCollector& Collector) const override;
 
    void GetInstanceData(void* InstanceData, void* DynamicParameterData, void* PrevTransformBuffer, const FParticleSystemSceneProxy* Proxy, const FSceneView* View, uint32 InstanceFactor) const;
 
    void GetParticleTransform(const FBaseParticle& InParticle, const FParticleSystemSceneProxy* Proxy, const FSceneView* View, FMatrix& OutTransformMat) const;
 
    void GetParticlePrevTransform(const FBaseParticle& InParticle, const FParticleSystemSceneProxy* Proxy, const FSceneView* View, FMatrix& OutTransformMat) const;
 
    void CalculateParticleTransform(
        const FMatrix& ProxyLocalToWorld,
        const FVector& ParticleLocation,
              float    ParticleRotation,
        const FVector3f& ParticleVelocity,
        const FVector3f& ParticleSize,
        const FVector3f& ParticlePayloadInitialOrientation,
        const FVector3f& ParticlePayloadRotation,
        const FVector& ParticlePayloadCameraOffset,
        const FVector3f& ParticlePayloadOrbitOffset,
        const FVector& ViewOrigin,
        const FVector3f& ViewDirection,
        FMatrix& OutTransformMat
        ) const;
 
    virtual void GatherSimpleLights(const FParticleSystemSceneProxy* Proxy, const FSceneViewFamily& ViewFamily, FSimpleLightArray& OutParticleLights) const override;
 
    virtual int32 GetDynamicVertexStride(ERHIFeatureLevel::Type /*InFeatureLevel*/) const override
    {
        return sizeof(FMeshParticleInstanceVertex);
    }
 
    virtual int32 GetDynamicParameterVertexStride() const override 
    {
        return sizeof(FMeshParticleInstanceVertexDynamicParameter);
    }
 
    virtual const FDynamicSpriteEmitterReplayDataBase* GetSourceData() const override
    {
        return &Source;
    }
 
    void SetupVertexFactory( FRHICommandListBase& RHICmdList, FMeshParticleVertexFactory* InVertexFactory, const FStaticMeshLODResources& LODResources, uint32 LODIdx) const;
 
    virtual const FDynamicEmitterReplayDataBase& GetSource() const override
    {
        return Source;
    }
 
    FDynamicMeshEmitterReplayData Source;
 
    int32                   LastFramePreRendered;
 
    UStaticMesh*        StaticMesh;
    TArray<FMaterialRenderProxy*, TInlineAllocator<2>> MeshMaterials;   
 
    uint32 MeshTypeDataOffset;
 
    // 'orientation' items...
    // These don't need to go into the replay data, as they are constant over the life of the emitter
    uint32 bApplyPreRotation:1;
    uint32 bUseMeshLockedAxis:1;
    uint32 bUseCameraFacing:1;
    uint32 bApplyParticleRotationAsSpin:1;  
    uint32 bFaceCameraDirectionRatherThanPosition:1;
    uint8 CameraFacingOption;
 
    bool bUseStaticMeshLODs;
    float LODSizeScale;
    mutable int32 LastCalculatedMeshLOD;
    const FParticleMeshEmitterInstance* EmitterInstance;
};
 
struct FDynamicBeam2EmitterReplayData
    : public FDynamicSpriteEmitterReplayDataBase
{
    int32                                   VertexCount;
    int32                                   IndexCount;
    int32                                   IndexStride;
 
    TArray<int32>                           TrianglesPerSheet;
    int32                                   UpVectorStepSize;
 
    // Offsets to particle data
    int32                                   BeamDataOffset;
    int32                                   InterpolatedPointsOffset;
    int32                                   NoiseRateOffset;
    int32                                   NoiseDeltaTimeOffset;
    int32                                   TargetNoisePointsOffset;
    int32                                   NextNoisePointsOffset;
    int32                                   TaperValuesOffset;
    int32                                   NoiseDistanceScaleOffset;
 
    bool                                bLowFreqNoise_Enabled;
    bool                                bHighFreqNoise_Enabled;
    bool                                bSmoothNoise_Enabled;
    bool                                bUseSource;
    bool                                bUseTarget;
    bool                                bTargetNoise;
    int32                                   Sheets;
    int32                                   Frequency;
    int32                                   NoiseTessellation;
    float                               NoiseRangeScale;
    float                               NoiseTangentStrength;
    FVector3f                               NoiseSpeed;
    float                               NoiseLockTime;
    float                               NoiseLockRadius;
    float                               NoiseTension;
 
    int32                                   TextureTile;
    float                               TextureTileDistance;
    uint8                               TaperMethod;
    int32                                   InterpolationPoints;
 
    bool                                bRenderGeometry;
    bool                                bRenderDirectLine;
    bool                                bRenderLines;
    bool                                bRenderTessellation;
 
    FDynamicBeam2EmitterReplayData()
        : VertexCount(0)
        , IndexCount(0)
        , IndexStride(0)
        , TrianglesPerSheet()
        , UpVectorStepSize(0)
        , BeamDataOffset(-1)
        , InterpolatedPointsOffset(-1)
        , NoiseRateOffset(-1)
        , NoiseDeltaTimeOffset(-1)
        , TargetNoisePointsOffset(-1)
        , NextNoisePointsOffset(-1)
        , TaperValuesOffset(-1)
        , NoiseDistanceScaleOffset(-1)
        , bLowFreqNoise_Enabled( false )
        , bHighFreqNoise_Enabled( false )
        , bSmoothNoise_Enabled( false )
        , bUseSource( false )
        , bUseTarget( false )
        , bTargetNoise( false )
        , Sheets(1)
        , Frequency(1)
        , NoiseTessellation(1)
        , NoiseRangeScale(1)
        , NoiseTangentStrength( 0.0f )
        , NoiseSpeed( 0.0f, 0.0f, 0.0f )
        , NoiseLockTime( 0.0f )
        , NoiseLockRadius( 0.0f )
        , NoiseTension( 0.0f )
        , TextureTile(0)
        , TextureTileDistance(0)
        , TaperMethod(0)
        , InterpolationPoints(0)
        , bRenderGeometry(true)
        , bRenderDirectLine(false)
        , bRenderLines(false)
        , bRenderTessellation(false)
    {
    }
 
 
    virtual void Serialize( FArchive& Ar )
    {
        // Call parent implementation
        FDynamicSpriteEmitterReplayDataBase::Serialize( Ar );
 
        Ar << VertexCount;
        Ar << IndexCount;
        Ar << IndexStride;
 
        Ar << TrianglesPerSheet;
        Ar << UpVectorStepSize;
        Ar << BeamDataOffset;
        Ar << InterpolatedPointsOffset;
        Ar << NoiseRateOffset;
        Ar << NoiseDeltaTimeOffset;
        Ar << TargetNoisePointsOffset;
        Ar << NextNoisePointsOffset;
        Ar << TaperValuesOffset;
        Ar << NoiseDistanceScaleOffset;
 
        Ar << bLowFreqNoise_Enabled;
        Ar << bHighFreqNoise_Enabled;
        Ar << bSmoothNoise_Enabled;
        Ar << bUseSource;
        Ar << bUseTarget;
        Ar << bTargetNoise;
        Ar << Sheets;
        Ar << Frequency;
        Ar << NoiseTessellation;
        Ar << NoiseRangeScale;
        Ar << NoiseTangentStrength;
        Ar << NoiseSpeed;
        Ar << NoiseLockTime;
        Ar << NoiseLockRadius;
        Ar << NoiseTension;
 
        Ar << TextureTile;
        Ar << TextureTileDistance;
        Ar << TaperMethod;
        Ar << InterpolationPoints;
 
        Ar << bRenderGeometry;
        Ar << bRenderDirectLine;
        Ar << bRenderLines;
        Ar << bRenderTessellation;
    }
 
};
 
 
 
struct FDynamicBeam2EmitterData : public FDynamicSpriteEmitterDataBase 
{
    static const uint32 MaxBeams = 2 * 1024;
    static const uint32 MaxInterpolationPoints = 250;
    static const uint32 MaxNoiseFrequency = 250;
 
    FDynamicBeam2EmitterData(const UParticleModuleRequired* RequiredModule)
        : 
          FDynamicSpriteEmitterDataBase(RequiredModule)
        , LastFramePreRendered(-1)
    {
    }
 
    ~FDynamicBeam2EmitterData();
 
    void Init( bool bInSelected );
 
 
    virtual void GetDynamicMeshElementsEmitter(const FParticleSystemSceneProxy* Proxy, const FSceneView* View, const FSceneViewFamily& ViewFamily, int32 ViewIndex, FMeshElementCollector& Collector) const override;
 
    // Debugging functions
    virtual void RenderDirectLine(const FParticleSystemSceneProxy* Proxy, FPrimitiveDrawInterface* PDI,const FSceneView* View) const;
    virtual void RenderLines(const FParticleSystemSceneProxy* Proxy, FPrimitiveDrawInterface* PDI,const FSceneView* View) const;
 
    virtual void RenderDebug(const FParticleSystemSceneProxy* Proxy, FPrimitiveDrawInterface* PDI, const FSceneView* View, bool bCrosses) const override;
 
    // Data fill functions
    int32 FillIndexData(struct FAsyncBufferFillData& Data) const;
    int32 FillVertexData_NoNoise(struct FAsyncBufferFillData& Data) const;
    int32 FillData_Noise(struct FAsyncBufferFillData& Data) const;
    int32 FillData_InterpolatedNoise(struct FAsyncBufferFillData& Data) const;
 
    virtual const FDynamicEmitterReplayDataBase& GetSource() const override
    {
        return Source;
    }
 
    virtual void DoBufferFill(FAsyncBufferFillData& Me) const override;
 
    virtual int32 GetDynamicVertexStride(ERHIFeatureLevel::Type /*InFeatureLevel*/) const override
    {
        return sizeof(FParticleBeamTrailVertex);
    }
 
    virtual int32 GetDynamicParameterVertexStride() const override
    {
        return sizeof(FParticleBeamTrailVertexDynamicParameter);
    }
        
    virtual void GetIndexAllocInfo(int32& OutNumIndices, int32& OutStride ) const override;
 
    FDynamicBeam2EmitterReplayData Source;
 
    int32                                   LastFramePreRendered;
};
 
struct FDynamicTrailsEmitterReplayData : public FDynamicSpriteEmitterReplayDataBase
{
    int32                   PrimitiveCount;
    int32                   VertexCount;
    int32                   IndexCount;
    int32                   IndexStride;
 
    // Payload offsets
    int32                   TrailDataOffset;
 
    int32                   MaxActiveParticleCount;
    int32                   TrailCount;
    int32                   Sheets;
 
    FDynamicTrailsEmitterReplayData()
        : PrimitiveCount(0)
        , VertexCount(0)
        , IndexCount(0)
        , IndexStride(0)
        , TrailDataOffset(-1)
        , MaxActiveParticleCount(0)
        , TrailCount(1)
        , Sheets(1)
    {
    }
 
    virtual void Serialize( FArchive& Ar )
    {
        // Call parent implementation
        FDynamicSpriteEmitterReplayDataBase::Serialize( Ar );
 
        Ar << PrimitiveCount;
        Ar << VertexCount;
        Ar << IndexCount;
        Ar << IndexStride;
 
        Ar << TrailDataOffset;
 
        Ar << MaxActiveParticleCount;
        Ar << TrailCount;
        Ar << Sheets;
    }
};
 
struct FDynamicRibbonEmitterReplayData : public FDynamicTrailsEmitterReplayData
{
    // Payload offsets
    int32 MaxTessellationBetweenParticles;
 
    FDynamicRibbonEmitterReplayData()
        : FDynamicTrailsEmitterReplayData()
        , MaxTessellationBetweenParticles(0)
    {
    }
 
    virtual void Serialize( FArchive& Ar )
    {
        // Call parent implementation
        FDynamicTrailsEmitterReplayData::Serialize( Ar );
        Ar << MaxTessellationBetweenParticles;
    }
};
 
struct FDynamicTrailsEmitterData : public FDynamicSpriteEmitterDataBase 
{
    FDynamicTrailsEmitterData(const UParticleModuleRequired* RequiredModule) : 
          FDynamicSpriteEmitterDataBase(RequiredModule)
        , LastFramePreRendered(-1)
        , bClipSourceSegement(false)
        , bRenderGeometry(true)
        , bRenderParticles(false)
        , bRenderTangents(false)
        , bRenderTessellation(false)
        , bTextureTileDistance(false)
        , DistanceTessellationStepSize(12.5f)
        , TangentTessellationScalar(25.0f)
        , TextureTileDistance(0.0f)
    {
    }
 
    ~FDynamicTrailsEmitterData();
 
    virtual void Init(bool bInSelected);
 
    virtual void GetDynamicMeshElementsEmitter(const FParticleSystemSceneProxy* Proxy, const FSceneView* View, const FSceneViewFamily& ViewFamily, int32 ViewIndex, FMeshElementCollector& Collector) const override;
 
    virtual void RenderDebug(const FParticleSystemSceneProxy* Proxy, FPrimitiveDrawInterface* PDI, const FSceneView* View, bool bCrosses) const override;
 
    // Data fill functions
    virtual int32 FillIndexData(struct FAsyncBufferFillData& Data) const;
    virtual int32 FillVertexData(struct FAsyncBufferFillData& Data) const;
 
    virtual const FDynamicEmitterReplayDataBase& GetSource() const override
    {
        check(SourcePointer);
        return *SourcePointer;
    }
 
    virtual const FDynamicTrailsEmitterReplayData* GetSourceData() const override
    {
        check(SourcePointer);
        return SourcePointer;
    }
 
    virtual void DoBufferFill(FAsyncBufferFillData& Me) const override
    {
        if( Me.VertexCount <= 0 || Me.IndexCount <= 0 || Me.VertexData == NULL || Me.IndexData == NULL )
        {
            return;
        }
 
        FillIndexData(Me);
        FillVertexData(Me);
    }
        
    virtual int32 GetDynamicVertexStride(ERHIFeatureLevel::Type /*InFeatureLevel*/) const override
    {
        return sizeof(FParticleBeamTrailVertex);
    }
 
    virtual int32 GetDynamicParameterVertexStride() const override
    {
        return sizeof(FParticleBeamTrailVertexDynamicParameter);
    }
    
    virtual void GetIndexAllocInfo(int32& OutNumIndices, int32& OutStride ) const override;
 
    FDynamicTrailsEmitterReplayData*    SourcePointer;
    int32                                   LastFramePreRendered;
 
    uint32  bClipSourceSegement:1;
    uint32  bRenderGeometry:1;
    uint32  bRenderParticles:1;
    uint32  bRenderTangents:1;
    uint32  bRenderTessellation:1;
    uint32  bTextureTileDistance:1;
 
    float DistanceTessellationStepSize;
    float TangentTessellationScalar;
    float TextureTileDistance;
};
 
struct FDynamicRibbonEmitterData : public FDynamicTrailsEmitterData
{
    FDynamicRibbonEmitterData(const UParticleModuleRequired* RequiredModule) : 
          FDynamicTrailsEmitterData(RequiredModule)
    {
    }
 
    virtual ~FDynamicRibbonEmitterData()
    {
    }
 
    virtual void Init(bool bInSelected);
 
    virtual void RenderDebug(const FParticleSystemSceneProxy* Proxy, FPrimitiveDrawInterface* PDI, const FSceneView* View, bool bCrosses) const;
 
    // Data fill functions
    virtual int32 FillVertexData(struct FAsyncBufferFillData& Data) const;
        
    virtual const FDynamicRibbonEmitterReplayData* GetSourceData() const
    {
        return &Source;
    }
 
    FDynamicRibbonEmitterReplayData Source;
 
    uint32  RenderAxisOption:2;
};
 
struct FDynamicAnimTrailEmitterData : public FDynamicTrailsEmitterData
{
    FDynamicAnimTrailEmitterData(const UParticleModuleRequired* RequiredModule) : 
          FDynamicTrailsEmitterData(RequiredModule)
    {
    }
 
    virtual ~FDynamicAnimTrailEmitterData()
    {
    }
 
    virtual void Init(bool bInSelected);
 
    virtual void RenderDebug(const FParticleSystemSceneProxy* Proxy, FPrimitiveDrawInterface* PDI, const FSceneView* View, bool bCrosses) const;
 
    // Data fill functions
    virtual int32 FillVertexData(struct FAsyncBufferFillData& Data) const;
 
    FDynamicTrailsEmitterReplayData Source;
};
 
/*-----------------------------------------------------------------------------
 *  Particle dynamic data
 *  This is a copy of the particle system data needed to render the system in
 *  another thread.
 ----------------------------------------------------------------------------*/
class FParticleDynamicData
{
public:
    FParticleDynamicData()
        : DynamicEmitterDataArray()
    {
    }
 
    ~FParticleDynamicData()
    {
        ClearEmitterDataArray();
    }
 
    ENGINE_API void* operator new(size_t Size);
    ENGINE_API void operator delete(void *RawMemory, size_t Size);
 
    void ClearEmitterDataArray()
    {
        for (int32 Index = 0; Index < DynamicEmitterDataArray.Num(); Index++)
        {
            FDynamicEmitterDataBase* Data = DynamicEmitterDataArray[Index];
            delete Data;
        }
        DynamicEmitterDataArray.Reset();
    }
 
    uint32 GetMemoryFootprint( void ) const { return( sizeof( *this ) + DynamicEmitterDataArray.GetAllocatedSize() ); }
 
    uint32 EmitterIndex;
 
    // Variables
    TArray<FDynamicEmitterDataBase*, TInlineAllocator<12> > DynamicEmitterDataArray;
 
    FVector SystemPositionForMacroUVs;
 
    float SystemRadiusForMacroUVs;
 
#if WITH_PARTICLE_PERF_STATS
    FParticlePerfStatsContext PerfStatContext;
#endif
};
 
 
#if STATS
/*-----------------------------------------------------------------------------
 *  FParticleMemoryStatManager
 *  Handles the collection of various ParticleSystemComponents memory stats
 ----------------------------------------------------------------------------*/
struct FParticleMemoryStatManager
{
public:
    static uint32 DynamicPSysCompCount;
    static uint32 DynamicPSysCompMem;
    static uint32 DynamicEmitterCount;
    static uint32 DynamicEmitterMem;
    static uint32 TotalGTParticleData;
    static uint32 TotalRTParticleData;
 
    static uint32 DynamicSpriteCount;
    static uint32 DynamicSubUVCount;
    static uint32 DynamicMeshCount;
    static uint32 DynamicBeamCount;
    static uint32 DynamicRibbonCount;
    static uint32 DynamicAnimTrailCount;
 
    static uint32 DynamicSpriteGTMem;
    static uint32 DynamicSubUVGTMem;
    static uint32 DynamicMeshGTMem;
    static uint32 DynamicBeamGTMem;
    static uint32 DynamicRibbonGTMem;
    static uint32 DynamicAnimTrailGTMem;
    static uint32 DynamicUntrackedGTMem;
 
    static uint32 DynamicPSysCompCount_MAX;
    static uint32 DynamicPSysCompMem_MAX;
    static uint32 DynamicEmitterCount_MAX;
    static uint32 DynamicEmitterMem_MAX;
    static uint32 DynamicEmitterGTMem_Waste_MAX;
    static uint32 DynamicEmitterGTMem_Largest_MAX;
    static uint32 TotalGTParticleData_MAX;
    static uint32 TotalRTParticleData_MAX;
    static uint32 LargestRTParticleData_MAX;
 
    static uint32 DynamicSpriteCount_MAX;
    static uint32 DynamicSubUVCount_MAX;
    static uint32 DynamicMeshCount_MAX;
    static uint32 DynamicBeamCount_MAX;
    static uint32 DynamicRibbonCount_MAX;
    static uint32 DynamicAnimTrailCount_MAX;
 
    static uint32 DynamicSpriteGTMem_MAX;
    static uint32 DynamicSubUVGTMem_MAX;
    static uint32 DynamicMeshGTMem_MAX;
    static uint32 DynamicBeamGTMem_MAX;
    static uint32 DynamicRibbonGTMem_MAX;
    static uint32 DynamicAnimTrailGTMem_MAX;
    static uint32 DynamicUntrackedGTMem_MAX;
 
    static void ResetParticleMemoryMaxValues();
 
    static void DumpParticleMemoryStats(FOutputDevice& Ar);
 
    static void UpdateStats();
};
 
#endif
 
class FNullDynamicParameterVertexBuffer : public FVertexBuffer
{
public:
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override
    {
        // create a static vertex buffer
        const FRHIBufferCreateDesc CreateDesc =
            FRHIBufferCreateDesc::CreateVertex(TEXT("FNullDynamicParameterVertexBuffer"), sizeof(FParticleVertexDynamicParameter))
            .AddUsage(EBufferUsageFlags::Static)
            .SetInitialState(ERHIAccess::VertexOrIndexBuffer)
            .SetInitActionInitializer();
 
        FParticleVertexDynamicParameter Value;
        Value.DynamicValue[0] = Value.DynamicValue[1] = Value.DynamicValue[2] = Value.DynamicValue[3] = 1.0f;
 
        FRHIBufferInitializer Initializer = RHICmdList.CreateBufferInitializer(CreateDesc);
        Initializer.WriteData(&Value, sizeof(Value));
 
        VertexBufferRHI = Initializer.Finalize();
    }
};
 
extern ENGINE_API TGlobalResource<FNullDynamicParameterVertexBuffer> GNullDynamicParameterVertexBuffer;
 
inline FVector3f GetParticleBaseSize(const FBaseParticle& Particle, bool bKeepFlipScale = false)
{
    return bKeepFlipScale ? Particle.BaseSize : FVector3f(FMath::Abs(Particle.BaseSize.X), FMath::Abs(Particle.BaseSize.Y), FMath::Abs(Particle.BaseSize.Z));
}
 
inline FVector2D GetParticleSizeWithUVFlipInSign(const FBaseParticle& Particle, const FVector2D& ScaledSize)
{
    return FVector2D(
        Particle.BaseSize.X >= 0.0f ? ScaledSize.X : -ScaledSize.X,
        Particle.BaseSize.Y >= 0.0f ? ScaledSize.Y : -ScaledSize.Y);
}
 
 
UENUM()
enum class EParticleSignificanceLevel : uint8
{
    Low,
    Medium,
    High,
    Critical,
 
    Num UMETA(Hidden),
};
 
UENUM()
enum class EParticleSystemInsignificanceReaction: uint8
{
    Auto,
    Complete,
    DisableTick,
    DisableTickAndKill UMETA(Hidden), //Hidden for now until I make it useful i.e. Killing particles saves memory.
 
    Num UMETA(Hidden),
};
 
class FParticleResetContext
{
public:
 
    TArray<class UParticleSystem*, TInlineAllocator<32>> SystemsToReset;
    ENGINE_API void AddTemplate(class UParticleSystem* Template);
    ENGINE_API void AddTemplate(class UParticleModule* Module);
    ENGINE_API void AddTemplate(class UParticleEmitter* Emitter);
    ENGINE_API ~FParticleResetContext();
};
 
 
struct FParticleSystemCustomVersion
{
    enum Type
    {
        // Before any version changes were made
        BeforeCustomVersionWasAdded = 0,
        SkipCookingEmittersBasedOnDetailMode,   // skip emitter cooking if their detail mode doesn't match predefined
        FixLegacySpawningBugs,                  // fixing some spawning bugs but must keep old behavior around for existing systems.
        AddEpicDetailMode,                      // adding another bitmask entry to EParticleDetailMode
 
        // -----<new versions can be added above this line>-------------------------------------------------
        VersionPlusOne,
        LatestVersion = VersionPlusOne - 1
    };
    // The GUID for this custom version number
    const static FGuid GUID;
 
private:
    FParticleSystemCustomVersion() {}
};
 
#if UE_ENABLE_INCLUDE_ORDER_DEPRECATED_IN_5_6
#include "CoreMinimal.h"
#include "Containers/IndirectArray.h"
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "Math/RandomStream.h"
#include "RHI.h"
#include "RenderResource.h"
#include "UniformBuffer.h"
#include "PrimitiveViewRelevance.h"
#include "PrimitiveSceneProxy.h"
#include "Materials/MaterialInterface.h"
#include "MeshBatch.h"
#include "MeshParticleVertexFactory.h"
#include "PrimitiveSceneProxy.h"
#include "ParticleSystemSceneProxy.h"
#endif