ParticleEmitterInstances.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    UnParticleEmitterInstances.h: 
    Particle emitter instance definitions/ macros.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "Materials/MaterialRelevance.h"
#include "Stats/Stats.h"
#include "ProfilingDebugging/ResourceSize.h"
#include "Distributions.h"
#include "Distributions/DistributionFloat.h"
#include "ParticleHelper.h"
#include "Distributions/DistributionVector.h"
#include "Particles/Orientation/ParticleModuleOrientationAxisLock.h"
 
//Temporary define to allow switching on and off of some trail optimizations until bugs can be worked out.
#define ENABLE_TRAILS_START_END_INDEX_OPTIMIZATION (0)
 
class UParticleEmitter;
class UParticleLODLevel;
class UParticleModuleBeamModifier;
class UParticleModuleBeamNoise;
class UParticleModuleBeamSource;
class UParticleModuleBeamTarget;
class UParticleModuleSpawnPerUnit;
class UParticleModuleTrailSource;
class UParticleModuleTypeDataAnimTrail;
class UParticleModuleTypeDataBeam2;
class UParticleModuleTypeDataMesh;
class UParticleModuleTypeDataRibbon;
class UParticleSystemComponent;
 
/*-----------------------------------------------------------------------------
    Forward declarations
-----------------------------------------------------------------------------*/
class IParticleEmitterInstanceOwner;
//  Emitter and module types
class UParticleEmitter;
class UParticleSpriteEmitter;
class UParticleModule;
// Data types
class UParticleModuleTypeDataMesh;
class UParticleModuleTypeDataBeam2;
class UParticleModuleTypeDataRibbon;
class UParticleModuleTypeDataAnimTrail;
 
class UStaticMeshComponent;
class UParticleSystemComponent;
 
class UParticleModuleBeamSource;
class UParticleModuleBeamTarget;
class UParticleModuleBeamNoise;
 
class UParticleModuleTrailSource;
 
class UParticleModuleSpawnPerUnit;
 
class UParticleModuleOrientationAxisLock;
 
class UParticleLODLevel;
 
enum ETrailWidthMode : int;
 
struct FLODBurstFired
{
    TArray<bool> Fired;
};
 
/*-----------------------------------------------------------------------------
    Information compiled from modules to build runtime emitter data.
-----------------------------------------------------------------------------*/
 
struct FParticleEmitterBuildInfo
{
    class UParticleModuleRequired* RequiredModule;
    class UParticleModuleSpawn* SpawnModule;
    class UParticleModuleSpawnPerUnit* SpawnPerUnitModule;
    TArray<class UParticleModule*> SpawnModules;
 
    FComposableVectorDistribution OrbitOffset;
    FComposableVectorDistribution OrbitInitialRotation;
    FComposableVectorDistribution OrbitRotationRate;
 
    FComposableVectorDistribution ColorScale;
    FComposableFloatDistribution AlphaScale;
 
    FRawDistributionVector DynamicColor;
    FRawDistributionFloat DynamicAlpha;
 
    FRawDistributionVector DynamicColorScale;
    FRawDistributionFloat DynamicAlphaScale;
    
    FComposableVectorDistribution SizeScale;
    FVector2D MaxSize;
    FVector2D SizeScaleBySpeed;
    FVector2D MaxSizeScaleBySpeed;
 
    FComposableFloatDistribution SubImageIndex;
 
    FComposableFloatDistribution DragCoefficient;
    FComposableFloatDistribution DragScale;
 
    bool bEnableCollision;
    uint8 CollisionResponse;
    uint8 CollisionMode;
    float CollisionRadiusScale;
    float CollisionRadiusBias;
    float CollisionRandomSpread;
    float CollisionRandomDistribution;
    float Friction;
    FComposableFloatDistribution Resilience;
    FComposableFloatDistribution ResilienceScaleOverLife;
 
    FVector PointAttractorPosition;
    float PointAttractorRadius;
    FComposableFloatDistribution PointAttractorStrength;
 
    FComposableFloatDistribution VectorFieldScale;
    FComposableFloatDistribution VectorFieldScaleOverLife;
    float GlobalVectorFieldScale;
    float GlobalVectorFieldTightness;
 
    class UVectorField* LocalVectorField;
    FTransform LocalVectorFieldTransform;
    float LocalVectorFieldIntensity;
    float LocalVectorFieldTightness;
    FVector LocalVectorFieldMinInitialRotation;
    FVector LocalVectorFieldMaxInitialRotation;
    FVector LocalVectorFieldRotationRate;
 
    FVector ConstantAcceleration;
 
    float MaxLifetime;
    float MaxRotationRate;
    int32 EstimatedMaxActiveParticleCount;
 
    int32 ScreenAlignment;
 
    FVector2D PivotOffset;
 
    uint32 bLocalVectorFieldIgnoreComponentTransform : 1;
    uint32 bLocalVectorFieldTileX : 1;
    uint32 bLocalVectorFieldTileY : 1;
    uint32 bLocalVectorFieldTileZ : 1;
    uint32 bLocalVectorFieldUseFixDT : 1;
 
    uint32 bUseVelocityForMotionBlur : 1;
 
    uint32 bRemoveHMDRoll : 1;
    float MinFacingCameraBlendDistance;
    float MaxFacingCameraBlendDistance;
    
    FParticleEmitterBuildInfo();
};
 
// Hacky base class to avoid 8 bytes of padding after the vtable
struct FParticleEmitterInstanceFixLayout
{
    virtual ~FParticleEmitterInstanceFixLayout() = default;
};
 
 
/*-----------------------------------------------------------------------------
    FParticleEmitterInstance
-----------------------------------------------------------------------------*/
struct FParticleEmitterInstance : FParticleEmitterInstanceFixLayout
{
public:
    static ENGINE_API const float PeakActiveParticleUpdateDelta;
 
    UParticleEmitter* SpriteTemplate;
    IParticleEmitterInstanceOwner& Component;
    UParticleLODLevel* CurrentLODLevel;
    int32 CurrentLODLevelIndex;
    int32 TypeDataOffset;
    int32 TypeDataInstanceOffset;
    int32 SubUVDataOffset;
    int32 DynamicParameterDataOffset;
    int32 LightDataOffset;
    float LightVolumetricScatteringIntensity;
    int32 OrbitModuleOffset;
    int32 CameraPayloadOffset;
    int32 PayloadOffset;
    FVector Location;
    FMatrix EmitterToSimulation;
    FMatrix SimulationToWorld;
    uint8 bEnabled : 1;
    uint8 bKillOnDeactivate:1;
    uint8 bKillOnCompleted:1;
    uint8 bRequiresSorting:1;
    uint8 bHaltSpawning : 1;
    uint8 bHaltSpawningExternal : 1;
    uint8 bRequiresLoopNotification:1;
    uint8 bIgnoreComponentScale:1;
    uint8 bIsBeam:1;
    uint8 bAxisLockEnabled : 1;
    uint8 bFakeBurstsWhenSpawningSupressed : 1;
    uint8 bEmitterIsDone:1;
    TEnumAsByte<EParticleAxisLock> LockAxisFlags;
    int32 SortMode;
    uint8* ParticleData;
    uint16* ParticleIndices;
    uint8* InstanceData;
    int32 InstancePayloadSize;
    int32 ParticleSize;
    int32 ParticleStride;
    int32 ActiveParticles;
    uint32 ParticleCounter;
    int32 MaxActiveParticles;
    float SpawnFraction;
    float SecondsSinceCreation;
    float EmitterTime;
    float LastDeltaTime;
#if WITH_EDITOR
    float LastTickDurationMs;
#endif
    FVector OldLocation;
    FBox ParticleBoundingBox;
    TArray<struct FLODBurstFired> BurstFired;
    int32 LoopCount;
    int32 IsRenderDataDirty;
    float EmitterDuration;
    TArray<float> EmitterDurations;
    float CurrentDelay;
 
    int32   TrianglesToRender;
    int32 MaxVertexIndex;
 
    UMaterialInterface* CurrentMaterial;
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
    int32 EventCount;
    int32 MaxEventCount;
#endif  //#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
 
    FVector PositionOffsetThisTick;
    
    FVector2D PivotOffset;
 
    TArray<class UPointLightComponent*> HighQualityLights;
 
    ENGINE_API FParticleEmitterInstance(IParticleEmitterInstanceOwner& InComponent);
 
    ENGINE_API virtual ~FParticleEmitterInstance();
 
#if STATS
    ENGINE_API void PreDestructorCall();
#endif
 
    //
    ENGINE_API virtual void InitParameters(UParticleEmitter* InTemplate);
    ENGINE_API virtual void Init();
 
    ENGINE_API virtual bool Resize(int32 NewMaxActiveParticles, bool bSetMaxActiveCount = true);
 
    ENGINE_API virtual void Tick(float DeltaTime, bool bSuppressSpawning);
    ENGINE_API void CheckEmitterFinished();
 
    ENGINE_API void FakeBursts();
 
    ENGINE_API virtual float Tick_EmitterTimeSetup(float DeltaTime, UParticleLODLevel* CurrentLODLevel);
    ENGINE_API virtual float Tick_SpawnParticles(float DeltaTime, UParticleLODLevel* CurrentLODLevel, bool bSuppressSpawning, bool bFirstTime);
    ENGINE_API virtual void Tick_ModuleUpdate(float DeltaTime, UParticleLODLevel* CurrentLODLevel);
    ENGINE_API virtual void Tick_ModulePostUpdate(float DeltaTime, UParticleLODLevel* CurrentLODLevel);
    ENGINE_API virtual void Tick_ModuleFinalUpdate(float DeltaTime, UParticleLODLevel* CurrentLODLevel);
 
    ENGINE_API virtual void SetCurrentLODIndex(int32 InLODIndex, bool bInFullyProcess);
 
    ENGINE_API virtual void Rewind();
    ENGINE_API virtual FBox GetBoundingBox();
    ENGINE_API virtual void UpdateBoundingBox(float DeltaTime);
    ENGINE_API virtual void ForceUpdateBoundingBox();
    ENGINE_API virtual uint32 RequiredBytes();
    ENGINE_API uint32 GetModuleDataOffset(UParticleModule* Module);
    ENGINE_API uint8* GetModuleInstanceData(UParticleModule* Module);
    ENGINE_API FParticleRandomSeedInstancePayload* GetModuleRandomSeedInstanceData(UParticleModule* Module);
    ENGINE_API virtual uint8* GetTypeDataModuleInstanceData();
    ENGINE_API virtual uint32 CalculateParticleStride(uint32 ParticleSize);
    ENGINE_API virtual void ResetBurstList();
    ENGINE_API virtual float GetCurrentBurstRateOffset(float& DeltaTime, int32& Burst);
    ENGINE_API virtual void ResetParticleParameters(float DeltaTime);
    ENGINE_API void CalculateOrbitOffset(FOrbitChainModuleInstancePayload& Payload, 
        FVector& AccumOffset, FVector& AccumRotation, FVector& AccumRotationRate, 
        float DeltaTime, FVector& Result, FMatrix& RotationMat);
    ENGINE_API virtual void UpdateOrbitData(float DeltaTime);
    ENGINE_API virtual void ParticlePrefetch();
 
    ENGINE_API virtual float Spawn(float DeltaTime);
 
    ENGINE_API void SpawnParticles( int32 Count, float StartTime, float Increment, const FVector& InitialLocation, const FVector& InitialVelocity, struct FParticleEventInstancePayload* EventPayload );
 
    ENGINE_API virtual void ForceSpawn(float DeltaTime, int32 InSpawnCount, int32 InBurstCount, FVector& InLocation, FVector& InVelocity);
    ENGINE_API void CheckSpawnCount(int32 InNewCount, int32 InMaxCount);
 
    ENGINE_API virtual void PreSpawn(FBaseParticle* Particle, const FVector& InitialLocation, const FVector& InitialVelocity);
 
    ENGINE_API virtual void PostSpawn(FBaseParticle* Particle, float InterpolationPercentage, float SpawnTime);
 
    ENGINE_API virtual bool HasCompleted();
    ENGINE_API virtual void KillParticles();
    ENGINE_API virtual void KillParticle(int32 Index);
 
    ENGINE_API virtual void KillParticlesForced(bool bFireEvents = false);
 
    virtual void SetHaltSpawning(bool bInHaltSpawning)
    {
        bHaltSpawning = bInHaltSpawning;
    }
 
    virtual void SetHaltSpawningExternal(bool bInHaltSpawning)
    {
        bHaltSpawningExternal = bInHaltSpawning;
    }
 
    inline void SetFakeBurstWhenSpawningSupressed(bool bInFakeBurstsWhenSpawningSupressed)
    {
        bFakeBurstsWhenSpawningSupressed = bInFakeBurstsWhenSpawningSupressed;
    }
 
    ENGINE_API int32 GetOrbitPayloadOffset();
 
    ENGINE_API FVector GetParticleLocationWithOrbitOffset(FBaseParticle* Particle);
 
    ENGINE_API virtual FBaseParticle* GetParticle(int32 Index);
    inline int32 GetParticleDirectIndex(int32 InIndex)
    {
        if (InIndex < MaxActiveParticles)
        {
            return ParticleIndices[InIndex];
        }
        return -1;
    }
    ENGINE_API virtual FBaseParticle* GetParticleDirect(int32 InDirectIndex);
 
    ENGINE_API void SetupEmitterDuration();
    
    bool HasActiveParticles()
    {
        return ActiveParticles > 0;
    }
 
    ENGINE_API virtual bool IsDynamicDataRequired(UParticleLODLevel* CurrentLODLevel);
 
    virtual FDynamicEmitterDataBase* GetDynamicData(bool bSelected, ERHIFeatureLevel::Type InFeatureLevel)
    {
        return NULL;
    }
 
    virtual FDynamicEmitterReplayDataBase* GetReplayData()
    {
        return NULL;
    }
 
    virtual void GetAllocatedSize(int32& OutNum, int32& OutMax)
    {
        OutNum = 0;
        OutMax = 0;
    }
    
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize)
    {
    }
 
    ENGINE_API virtual void ProcessParticleEvents(float DeltaTime, bool bSuppressSpawning);
 
    virtual void OnDeactivateSystem()
    {
    }
 
    virtual int32 GetMeshRotationOffset() const
    {
        return 0;
    }
 
    virtual bool IsMeshRotationActive() const
    {
        return false;
    }
 
    virtual void SetMeshMaterials( const TArray<UMaterialInterface*>& InMaterials )
    {
    }
 
    UE_DEPRECATED(5.7, "Please use GatherMaterialRelevance with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    ENGINE_API virtual void GatherMaterialRelevance( FMaterialRelevance* OutMaterialRelevance, const UParticleLODLevel* LODLevel, ERHIFeatureLevel::Type InFeatureLevel ) const;
    ENGINE_API virtual void GatherMaterialRelevance( FMaterialRelevance* OutMaterialRelevance, const UParticleLODLevel* LODLevel, EShaderPlatform InShaderPlatform ) const;
 
    virtual void OnEmitterInstanceKilled(FParticleEmitterInstance* Instance)
    {
 
    }
 
    // Beam interface
    virtual void SetBeamEndPoint(FVector NewEndPoint) {};
    virtual void SetBeamSourcePoint(FVector NewSourcePoint,int32 SourceIndex) {};
    virtual void SetBeamSourceTangent(FVector NewTangentPoint,int32 SourceIndex) {};
    virtual void SetBeamSourceStrength(float NewSourceStrength,int32 SourceIndex) {};
    virtual void SetBeamTargetPoint(FVector NewTargetPoint,int32 TargetIndex) {};
    virtual void SetBeamTargetTangent(FVector NewTangentPoint,int32 TargetIndex) {};
    virtual void SetBeamTargetStrength(float NewTargetStrength,int32 TargetIndex) {};
 
    //Beam get interface
    virtual bool GetBeamEndPoint(FVector& OutEndPoint) const { return false; }
    virtual bool GetBeamSourcePoint(int32 SourceIndex, FVector& OutSourcePoint) const { return false; }
    virtual bool GetBeamSourceTangent(int32 SourceIndex, FVector& OutTangentPoint) const { return false; }
    virtual bool GetBeamSourceStrength(int32 SourceIndex, float& OutSourceStrength) const { return false; }
    virtual bool GetBeamTargetPoint(int32 TargetIndex, FVector& OutTargetPoint) const { return false; }
    virtual bool GetBeamTargetTangent(int32 TargetIndex, FVector& OutTangentPoint) const { return false; }
    virtual bool GetBeamTargetStrength(int32 TargetIndex, float& OutTargetStrength) const { return false; }
    
    // Called on world origin changes
    ENGINE_API virtual void ApplyWorldOffset(FVector InOffset, bool bWorldShift);
        
    virtual bool IsTrailEmitter()const{ return false; }
 
    virtual void BeginTrail(){}
 
    virtual void EndTrail(){}
 
    virtual void SetTrailSourceData(FName InFirstSocketName, FName InSecondSocketName, ETrailWidthMode InWidthMode, float InWidth){}
 
    ENGINE_API virtual void Tick_MaterialOverrides(int32 EmitterIndex);
 
    ENGINE_API bool UseLocalSpace();
 
    ENGINE_API void GetScreenAlignmentAndScale(int32& OutScreenAlign, FVector& OutScale);
 
protected:
 
    ENGINE_API virtual bool FillReplayData( FDynamicEmitterReplayDataBase& OutData );
 
    ENGINE_API void UpdateTransforms();
 
    ENGINE_API class UParticleLODLevel* GetCurrentLODLevelChecked();
 
    ENGINE_API UMaterialInterface* GetCurrentMaterial();
 
 
    ENGINE_API void FixupParticleIndices();
 
};
 
#if STATS
struct FScopeCycleCounterEmitter : public FCycleCounter
{
    template<class T>
    inline FScopeCycleCounterEmitter(const T *Object)
    {
        if (Object)
        {
            TStatId SpriteStatId = Object->SpriteTemplate->GetStatID();
            if (FThreadStats::IsCollectingData(SpriteStatId))
            {
                Start(SpriteStatId);
            }
        }
    }
    template<class T>
    inline FScopeCycleCounterEmitter(const T *Object, TStatId OtherStat)
    {
        if (FThreadStats::IsCollectingData(OtherStat) && Object)
        {
            TStatId StatId = Object->SpriteTemplate->GetStatID();
            if (!StatId.IsNone())
            {
                Start(StatId);
            }
        }
    }
    inline ~FScopeCycleCounterEmitter()
    {
        Stop();
    }
};
#else
struct FScopeCycleCounterEmitter
{
    inline FScopeCycleCounterEmitter(const FParticleEmitterInstance *Object)
    {
    }
    inline FScopeCycleCounterEmitter(const FParticleEmitterInstance *Object, TStatId OtherStat)
    {
    }
};
#endif
 
/*-----------------------------------------------------------------------------
    ParticleSpriteEmitterInstance
-----------------------------------------------------------------------------*/
struct FParticleSpriteEmitterInstance : public FParticleEmitterInstance
{
    FParticleSpriteEmitterInstance(IParticleEmitterInstanceOwner& InComponent);
 
    virtual ~FParticleSpriteEmitterInstance();
 
    virtual FDynamicEmitterDataBase* GetDynamicData(bool bSelected, ERHIFeatureLevel::Type InFeatureLevel) override;
 
    virtual FDynamicEmitterReplayDataBase* GetReplayData() override;
 
    virtual void GetAllocatedSize(int32& OutNum, int32& OutMax) override;
 
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
 
protected:
 
    virtual bool FillReplayData( FDynamicEmitterReplayDataBase& OutData ) override;
 
};
 
/*-----------------------------------------------------------------------------
    ParticleMeshEmitterInstance
-----------------------------------------------------------------------------*/
struct FParticleMeshEmitterInstance : public FParticleEmitterInstance
{
    UParticleModuleTypeDataMesh* MeshTypeData;
    bool MeshRotationActive;
    int32 MeshRotationOffset;
    int32 MeshMotionBlurOffset;
 
    TArray<UMaterialInterface*> CurrentMaterials;
 
    ENGINE_API FParticleMeshEmitterInstance(IParticleEmitterInstanceOwner& InComponent);
 
    ENGINE_API virtual void InitParameters(UParticleEmitter* InTemplate) override;
    ENGINE_API virtual void Init() override;
    ENGINE_API virtual bool Resize(int32 NewMaxActiveParticles, bool bSetMaxActiveCount = true) override;
    ENGINE_API virtual void Tick(float DeltaTime, bool bSuppressSpawning) override;
    ENGINE_API virtual void UpdateBoundingBox(float DeltaTime) override;
    ENGINE_API virtual uint32 RequiredBytes() override;
    ENGINE_API virtual void PostSpawn(FBaseParticle* Particle, float InterpolationPercentage, float SpawnTime) override;
    ENGINE_API virtual FDynamicEmitterDataBase* GetDynamicData(bool bSelected, ERHIFeatureLevel::Type InFeatureLevel) override;
    ENGINE_API virtual bool IsDynamicDataRequired(UParticleLODLevel* CurrentLODLevel) override;
 
    ENGINE_API virtual void Tick_MaterialOverrides(int32 EmitterIndex) override;
 
    ENGINE_API virtual FDynamicEmitterReplayDataBase* GetReplayData() override;
 
    ENGINE_API virtual void GetAllocatedSize(int32& OutNum, int32& OutMax) override;
 
    ENGINE_API virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
 
    virtual int32 GetMeshRotationOffset() const override
    {
        return MeshRotationOffset;
    }
 
    virtual bool IsMeshRotationActive() const override
    {
        return MeshRotationActive;
    }
 
    ENGINE_API virtual void SetMeshMaterials( const TArray<UMaterialInterface*>& InMaterials ) override;
 
    UE_DEPRECATED(5.7, "Please use GatherMaterialRelevance with EShaderPlatform argument and not ERHIFeatureLevel::Type")
    ENGINE_API virtual void GatherMaterialRelevance(FMaterialRelevance* OutMaterialRelevance, const UParticleLODLevel* LODLevel, ERHIFeatureLevel::Type InFeatureLevel) const override;
    ENGINE_API virtual void GatherMaterialRelevance(FMaterialRelevance* OutMaterialRelevance, const UParticleLODLevel* LODLevel, EShaderPlatform InShaderPlatform) const override;
 
    UE_DEPRECATED(5.7, "Please use GatherMaterialRelevance without ERHIFeatureLevel::Type")
    ENGINE_API void GetMeshMaterials(TArray<UMaterialInterface*,TInlineAllocator<2> >& OutMaterials, const UParticleLODLevel* LODLevel, ERHIFeatureLevel::Type InFeatureLevel, bool bLogWarnings = false) const;
    ENGINE_API void GetMeshMaterials(TArray<UMaterialInterface*,TInlineAllocator<2> >& OutMaterials, const UParticleLODLevel* LODLevel, bool bLogWarnings = false) const;
 
protected:
 
    ENGINE_API virtual bool FillReplayData( FDynamicEmitterReplayDataBase& OutData ) override;
};
 
/*-----------------------------------------------------------------------------
    ParticleBeam2EmitterInstance
-----------------------------------------------------------------------------*/
struct FParticleBeam2EmitterInstance : public FParticleEmitterInstance
{
    UParticleModuleTypeDataBeam2*   BeamTypeData;
 
    UParticleModuleBeamSource*      BeamModule_Source;
    UParticleModuleBeamTarget*      BeamModule_Target;
    UParticleModuleBeamNoise*       BeamModule_Noise;
    UParticleModuleBeamModifier*    BeamModule_SourceModifier;
    int32                               BeamModule_SourceModifier_Offset;
    UParticleModuleBeamModifier*    BeamModule_TargetModifier;
    int32                               BeamModule_TargetModifier_Offset;
 
    bool                            FirstEmission;
    int32                               TickCount;
    int32                               ForceSpawnCount;
    int32                               BeamMethod;
    TArray<int32>                       TextureTiles;
    int32                               BeamCount;
    AActor*                         SourceActor;
    FParticleEmitterInstance*       SourceEmitter;
    TArray<FVector>                 UserSetSourceArray;
    TArray<FVector>                 UserSetSourceTangentArray;
    TArray<float>                   UserSetSourceStrengthArray;
    TArray<float>                   DistanceArray;
    TArray<FVector>                 TargetPointArray;
    TArray<FVector>                 TargetTangentArray;
    TArray<float>                   UserSetTargetStrengthArray;
    AActor*                         TargetActor;
    FParticleEmitterInstance*       TargetEmitter;
    TArray<FName>                   TargetPointSourceNames;
    TArray<FVector>                 UserSetTargetArray;
    TArray<FVector>                 UserSetTargetTangentArray;
 
    int32                               VertexCount;
    int32                               TriangleCount;
    TArray<int32>                       BeamTrianglesPerSheet;
 
    FParticleBeam2EmitterInstance(IParticleEmitterInstanceOwner& InComponent);
 
    virtual ~FParticleBeam2EmitterInstance();
 
    // Beam interface.
    virtual void SetBeamEndPoint(FVector NewEndPoint) override;
    virtual void SetBeamSourcePoint(FVector NewSourcePoint,int32 SourceIndex) override;
    virtual void SetBeamSourceTangent(FVector NewTangentPoint,int32 SourceIndex) override;
    virtual void SetBeamSourceStrength(float NewSourceStrength,int32 SourceIndex) override;
    virtual void SetBeamTargetPoint(FVector NewTargetPoint,int32 TargetIndex) override;
    virtual void SetBeamTargetTangent(FVector NewTangentPoint,int32 TargetIndex) override;
    virtual void SetBeamTargetStrength(float NewTargetStrength,int32 TargetIndex) override;
    virtual void ApplyWorldOffset(FVector InOffset, bool bWorldShift) override;
    
    virtual bool GetBeamEndPoint(FVector& OutEndPoint) const override;
    virtual bool GetBeamSourcePoint(int32 SourceIndex, FVector& OutSourcePoint) const override;
    virtual bool GetBeamSourceTangent(int32 SourceIndex, FVector& OutTangentPoint) const override;
    virtual bool GetBeamSourceStrength(int32 SourceIndex, float& OutSourceStrength) const override;
    virtual bool GetBeamTargetPoint(int32 TargetIndex, FVector& OutTargetPoint) const override;
    virtual bool GetBeamTargetTangent(int32 TargetIndex, FVector& OutTangentPoint) const override;
    virtual bool GetBeamTargetStrength(int32 TargetIndex, float& OutTargetStrength) const override;
    //
    virtual void InitParameters(UParticleEmitter* InTemplate) override;
    virtual void Init() override;
    virtual void Tick(float DeltaTime, bool bSuppressSpawning) override;
    virtual void Tick_ModulePostUpdate(float DeltaTime, UParticleLODLevel* CurrentLODLevel) override;
 
    virtual void SetCurrentLODIndex(int32 InLODIndex, bool bInFullyProcess) override;
 
    virtual void PostSpawn(FBaseParticle* Particle, float InterpolationPercentage, float SpawnTime) override;
 
    virtual void UpdateBoundingBox(float DeltaTime) override;
    virtual void ForceUpdateBoundingBox() override;
    virtual uint32 RequiredBytes() override;
    float SpawnBeamParticles(float OldLeftover, float Rate, float DeltaTime, int32 Burst = 0, float BurstTime = 0.0f);
    virtual void KillParticles() override;
    void SetupBeamModifierModulesOffsets();
    void ResolveSource();
    void ResolveTarget();
    void DetermineVertexAndTriangleCount();
 
    virtual FDynamicEmitterDataBase* GetDynamicData(bool bSelected, ERHIFeatureLevel::Type InFeatureLevel) override;
 
    virtual FDynamicEmitterReplayDataBase* GetReplayData() override;
 
    virtual void GetAllocatedSize(int32& OutNum, int32& OutMax) override;
 
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
 
    virtual void OnEmitterInstanceKilled(FParticleEmitterInstance* Instance) override
    {
        if (SourceEmitter == Instance)
        {
            SourceEmitter = NULL;
        }
        if (TargetEmitter == Instance)
        {
            TargetEmitter = NULL;
        }
    }
 
protected:
    UMaterialInterface* GetCurrentMaterial();
 
    virtual bool FillReplayData( FDynamicEmitterReplayDataBase& OutData ) override;
 
};
 
/*-----------------------------------------------------------------------------
    FParticleRibbonEmitterInstance.
-----------------------------------------------------------------------------*/
struct FParticleTrailsEmitterInstance_Base : public FParticleEmitterInstance
{
    int32 VertexCount;
    int32 TriangleCount;
    int32 TrailCount;
    int32 MaxTrailCount;
    float RunningTime;
    float LastTickTime;
    uint32 bDeadTrailsOnDeactivate:1;
 
    TArray<float> TrailSpawnTimes;
    TArray<float> LastSpawnTime;
    TArray<float> SourceDistanceTraveled;
    TArray<float> TiledUDistanceTraveled;
    uint32 bFirstUpdate:1;
    uint32 bEnableInactiveTimeTracking:1;
 
#if ENABLE_TRAILS_START_END_INDEX_OPTIMIZATION
    int32 CurrentStartIndices[128];
    int32 CurrentEndIndices[128];
 
    void SetStartIndex(int32 TrailIndex, int32 ParticleIndex)
    {
        CurrentStartIndices[TrailIndex] = ParticleIndex;
        if (CurrentEndIndices[TrailIndex] == ParticleIndex)
        {
            CurrentEndIndices[TrailIndex] = INDEX_NONE;
        }
        CheckIndices(TrailIndex);
    }
 
    template<typename TrailDataType> void GetTrailStart(const int32 TrailIdx, int32 &OutStartIndex, TrailDataType *&OutTrailData, FBaseParticle *&OutParticle)
    {
        if (TrailIdx != INDEX_NONE)
        {
            OutStartIndex = CurrentStartIndices[TrailIdx];
            if (OutStartIndex != INDEX_NONE)
            {
                DECLARE_PARTICLE_PTR(CheckParticle, ParticleData + ParticleStride * OutStartIndex);
                TrailDataType* CheckTrailData = ((TrailDataType*)((uint8*)CheckParticle + TypeDataOffset));
                check(TRAIL_EMITTER_IS_START(CheckTrailData->Flags));
                OutTrailData = CheckTrailData;
                OutParticle = CheckParticle;
            }
        }
    }
 
    template<typename TrailDataType> void GetTrailEnd(const int32 TrailIdx, int32 &OutEndIndex, TrailDataType *&OutTrailData, FBaseParticle *&OutParticle)
    {
        if (TrailIdx != INDEX_NONE)
        {
            OutEndIndex = CurrentEndIndices[TrailIdx];
            if (OutEndIndex != INDEX_NONE)
            {
                DECLARE_PARTICLE_PTR(CheckParticle, ParticleData + ParticleStride * OutEndIndex);
                TrailDataType* CheckTrailData = ((TrailDataType*)((uint8*)CheckParticle + TypeDataOffset));
                check(TRAIL_EMITTER_IS_END(CheckTrailData->Flags));
                OutTrailData = CheckTrailData;
                OutParticle = CheckParticle;
            }
        }
    }
 
 
    void SetEndIndex(int32 TrailIndex, int32 ParticleIndex)
    {
        CurrentEndIndices[TrailIndex] = ParticleIndex;
        if (CurrentStartIndices[TrailIndex] == ParticleIndex)
        {
            CurrentStartIndices[TrailIndex] = INDEX_NONE;
        }
        CheckIndices(TrailIndex);
    }
 
    void SetDeadIndex(int32 TrailIndex, int32 ParticleIndex)
    {
        if (CurrentStartIndices[TrailIndex] == ParticleIndex)
        {
            CurrentStartIndices[TrailIndex] = INDEX_NONE;
        }
 
        if (CurrentEndIndices[TrailIndex] == ParticleIndex)
        {
            CurrentEndIndices[TrailIndex] = INDEX_NONE;
        }
        CheckIndices(TrailIndex);
    }
 
    void ClearIndices(int32 TrailIndex, int32 ParticleIndex)
    {
        SetDeadIndex(TrailIndex, ParticleIndex);
        CheckIndices(TrailIndex);
    }
 
    void CheckIndices(int32 TrailIdx)
    {
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
        if (CurrentEndIndices[TrailIdx] != INDEX_NONE)
        {
            DECLARE_PARTICLE_PTR(EndParticle, ParticleData + ParticleStride * CurrentEndIndices[TrailIdx]);
            FTrailsBaseTypeDataPayload* EndTrailData = ((FTrailsBaseTypeDataPayload*)((uint8*)EndParticle + TypeDataOffset));
            check(TRAIL_EMITTER_IS_END(EndTrailData->Flags));
        }
 
        if (CurrentStartIndices[TrailIdx] != INDEX_NONE)
        {
            DECLARE_PARTICLE_PTR(StartParticle, ParticleData + ParticleStride * CurrentStartIndices[TrailIdx]);
            FTrailsBaseTypeDataPayload* StartTrailData = ((FTrailsBaseTypeDataPayload*)((uint8*)StartParticle + TypeDataOffset));
            check(TRAIL_EMITTER_IS_START(StartTrailData->Flags));
        }
#endif
    }
 
    void CheckAllIndices()
    {
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
        for (uint32 TrailIdx = 0; TrailIdx < 128; TrailIdx++)
        {
            if (CurrentEndIndices[TrailIdx] != INDEX_NONE)
            {
                DECLARE_PARTICLE_PTR(EndParticle, ParticleData + ParticleStride * CurrentEndIndices[TrailIdx]);
                FRibbonTypeDataPayload* EndTrailData = ((FRibbonTypeDataPayload*)((uint8*)EndParticle + TypeDataOffset));
                check(TRAIL_EMITTER_IS_END(EndTrailData->Flags));
            }
 
            if (CurrentStartIndices[TrailIdx] != INDEX_NONE)
            {
                DECLARE_PARTICLE_PTR(StartParticle, ParticleData + ParticleStride * CurrentStartIndices[TrailIdx]);
                FRibbonTypeDataPayload* StartTrailData = ((FRibbonTypeDataPayload*)((uint8*)StartParticle + TypeDataOffset));
                check(TRAIL_EMITTER_IS_START(StartTrailData->Flags));
            }
        }
#endif
    }
 
#else //ENABLE_TRAILS_START_END_INDEX_OPTIMIZATION
 
template<typename TrailDataType> void GetTrailStart(const int32 TrailIdx, int32 &OutStartIndex, TrailDataType *&OutTrailData, FBaseParticle *&OutParticle)
{
    for (int32 FindTrailIdx = 0; FindTrailIdx < ActiveParticles; FindTrailIdx++)
    {
        int32 CheckIndex = ParticleIndices[FindTrailIdx];
        DECLARE_PARTICLE_PTR(CheckParticle, ParticleData + ParticleStride * CheckIndex);
        TrailDataType* CheckTrailData = ((TrailDataType*)((uint8*)CheckParticle + TypeDataOffset));
        if (TRAIL_EMITTER_IS_START(CheckTrailData->Flags))
        {
            if (CheckTrailData->TrailIndex == TrailIdx)
            {
                OutStartIndex = CheckIndex;
                OutParticle = CheckParticle;
                OutTrailData = CheckTrailData;              
                break;
            }
        }
    }
}
template<typename TrailDataType> void GetTrailEnd(const int32 TrailIdx, int32 &OutEndIndex, TrailDataType *&OutTrailData, FBaseParticle *&OutParticle)
{
    for (int32 FindTrailIdx = 0; FindTrailIdx < ActiveParticles; FindTrailIdx++)
    {
        int32 CheckIndex = ParticleIndices[FindTrailIdx];
        DECLARE_PARTICLE_PTR(CheckParticle, ParticleData + ParticleStride * CheckIndex);
        TrailDataType* CheckTrailData = ((TrailDataType*)((uint8*)CheckParticle + TypeDataOffset));
        if (TRAIL_EMITTER_IS_END(CheckTrailData->Flags))
        {
            if (CheckTrailData->TrailIndex == TrailIdx)
            {
                OutEndIndex = CheckIndex;
                OutParticle = CheckParticle;
                OutTrailData = CheckTrailData;
                break;
            }
        }
    }
}
void SetStartIndex(int32 TrailIndex, int32 ParticleIndex){}
void SetEndIndex(int32 TrailIndex, int32 ParticleIndex){}
void SetDeadIndex(int32 TrailIndex, int32 ParticleIndex){}
void ClearIndices(int32 TrailIndex, int32 ParticleIndex){}
void CheckIndices(int32 TrailIdx){}
void CheckAllIndices(){}
 
#endif
 
    void DumpCircularTrailsSpam();
#if !UE_BUILD_SHIPPING
    bool CheckForCircularTrail(FBaseParticle* StartParticle, FBaseParticle* CheckParticle)
    {
        if (StartParticle == CheckParticle)
        {
            DumpCircularTrailsSpam();
            return true;
        }
        return false;
    }
#else
    bool CheckForCircularTrail(FBaseParticle* StartParticle, FBaseParticle* CheckParticle) { return StartParticle == CheckParticle; }
#endif
 
    FParticleTrailsEmitterInstance_Base(IParticleEmitterInstanceOwner& InComponent) :
          FParticleEmitterInstance(InComponent)
        , VertexCount(0)
        , TriangleCount(0)
        , TrailCount(0)
        , MaxTrailCount(0)
        , RunningTime(0.0f)
        , LastTickTime(0.0f)
        , bDeadTrailsOnDeactivate(false)
        , bFirstUpdate(true)
        , bEnableInactiveTimeTracking(false)
    {
        TrailSpawnTimes.Empty();
        LastSpawnTime.Empty();
        SourceDistanceTraveled.Empty();
        TiledUDistanceTraveled.Empty();
 
        for (int32 TrailIdx = 0; TrailIdx < 128; TrailIdx++)
        {
#if ENABLE_TRAILS_START_END_INDEX_OPTIMIZATION
            CurrentStartIndices[TrailIdx] = INDEX_NONE;
            CurrentEndIndices[TrailIdx] = INDEX_NONE;
#endif
        }
    }
 
    virtual ~FParticleTrailsEmitterInstance_Base()
    {
    }
 
    virtual void Init() override;
    virtual void InitParameters(UParticleEmitter* InTemplate) override;
    virtual void Tick(float DeltaTime, bool bSuppressSpawning) override;
 
    bool AddParticleHelper(int32 InTrailIdx,
        int32 StartParticleIndex, FTrailsBaseTypeDataPayload* StartTrailData,
        int32 ParticleIndex, FTrailsBaseTypeDataPayload* TrailData);
 
    virtual void Tick_RecalculateTangents(float DeltaTime, UParticleLODLevel* CurrentLODLevel);
    virtual void UpdateBoundingBox(float DeltaTime) override;
    virtual void ForceUpdateBoundingBox() override;
    virtual void KillParticles() override;
 
    virtual void KillParticles(int32 InTrailIdx, int32 InKillCount);
 
    virtual void SetupTrailModules() {};
    virtual void UpdateSourceData(float DeltaTime, bool bFirstTime);
    // Update the start particles of the trail, if needed
//  virtual void UpdateStartParticles(float DeltaTime, bool bFirstTime) {}
 
    virtual void OnDeactivateSystem() override;
 
protected:
    UMaterialInterface* GetCurrentMaterial();
 
    enum EGetTrailDirection
    {
        GET_Prev,
        GET_Next
    };
    enum EGetTrailParticleOption
    {
        GET_Any,            // Grab the prev/next particle
        GET_Spawned,        // Grab the first prev/next particle that was true spawned
        GET_Interpolated,   // Grab the first prev/next particle that was interpolation spawned
        GET_Start,          // Grab the start particle for the trail the particle is in
        GET_End,            // Grab the end particle for the trail the particle is in
    };
 
    bool GetParticleInTrail(
        bool bSkipStartingParticle,
        FBaseParticle* InStartingFromParticle,
        FTrailsBaseTypeDataPayload* InStartingTrailData,
        EGetTrailDirection InGetDirection,
        EGetTrailParticleOption InGetOption,
        FBaseParticle*& OutParticle,
        FTrailsBaseTypeDataPayload*& OutTrailData);
 
    virtual void PrintParticleData(FBaseParticle* Particle, FTrailsBaseTypeDataPayload* TrailData, int32 CurrentIndex, int32 TrailIndex){}
    virtual void PrintAllActiveParticles(){}
    virtual void PrintTrails(){}
};
 
struct FParticleRibbonEmitterInstance : public FParticleTrailsEmitterInstance_Base
{
    UParticleModuleTypeDataRibbon*  TrailTypeData;
 
    UParticleModuleSpawnPerUnit*    SpawnPerUnitModule;
 
    UParticleModuleTrailSource*     SourceModule;
    int32                               TrailModule_Source_Offset;
 
    TArray<FVector> CurrentSourcePosition;
    TArray<FQuat> CurrentSourceRotation;
    TArray<FVector> CurrentSourceUp;
    TArray<FVector> CurrentSourceTangent;
    TArray<float> CurrentSourceTangentStrength;
    TArray<FVector> LastSourcePosition;
    TArray<FQuat> LastSourceRotation;
    TArray<FVector> LastSourceUp;
    TArray<FVector> LastSourceTangent;
    TArray<float> LastSourceTangentStrength;
    AActor* SourceActor;
    TArray<FVector> SourceOffsets;
    FParticleEmitterInstance* SourceEmitter;
    int32 LastSelectedParticleIndex;
    TArray<int32> SourceIndices;
    TArray<float> SourceTimes;
    TArray<float> LastSourceTimes;
    TArray<float> CurrentLifetimes;
    TArray<float> CurrentSizes;
//  TArray<int32> CurrentStartIndices;
//  TArray<bool> SkipSourceSegment;
 
    int32 HeadOnlyParticles;
 
    FParticleRibbonEmitterInstance(IParticleEmitterInstanceOwner& InComponent);
 
    virtual ~FParticleRibbonEmitterInstance();
 
    virtual void InitParameters(UParticleEmitter* InTemplate) override;
 
    virtual void Tick_RecalculateTangents(float DeltaTime, UParticleLODLevel* CurrentLODLevel) override;
 
    virtual bool GetSpawnPerUnitAmount(float DeltaTime, int32 InTrailIdx, int32& OutCount, float& OutRate);
 
    void GetParticleLifetimeAndSize(int32 InTrailIdx, const FBaseParticle* InParticle, bool bInNoLivingParticles, float& OutOneOverMaxLifetime, float& OutSize);
 
    virtual float Spawn(float DeltaTime) override;
 
    bool Spawn_Source(float DeltaTime);
    float Spawn_RateAndBurst(float DeltaTime);
    
    virtual void SetupTrailModules() override;
    void ResolveSource();
    virtual void UpdateSourceData(float DeltaTime, bool bFirstTime) override;
    // Update the start particles of the trail, if needed
//  virtual void UpdateStartParticles(float DeltaTime, bool bFirstTime);
    bool ResolveSourcePoint(int32 InTrailIdx, FVector& OutPosition, FQuat& OutRotation, FVector& OutUp, FVector& OutTangent, float& OutTangentStrength);
 
    void DetermineVertexAndTriangleCount();
 
    virtual bool IsDynamicDataRequired(UParticleLODLevel* CurrentLODLevel) override;
 
    virtual FDynamicEmitterDataBase* GetDynamicData(bool bSelected, ERHIFeatureLevel::Type InFeatureLevel) override;
 
    virtual FDynamicEmitterReplayDataBase* GetReplayData() override;
 
    virtual void GetAllocatedSize(int32& OutNum, int32& OutMax) override;
 
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
 
    virtual void OnEmitterInstanceKilled(FParticleEmitterInstance* Instance) override
    {
        if (SourceEmitter == Instance)
        {
            SourceEmitter = NULL;
        }
    }
    
    virtual void ApplyWorldOffset(FVector InOffset, bool bWorldShift) override;
 
protected:
 
    virtual bool FillReplayData( FDynamicEmitterReplayDataBase& OutData ) override;
};
 
/*-----------------------------------------------------------------------------
    FParticleAnimTrailEmitterInstance.
-----------------------------------------------------------------------------*/
 
struct FParticleAnimTrailEmitterInstance : public FParticleTrailsEmitterInstance_Base
{
    UParticleModuleTypeDataAnimTrail*   TrailTypeData;
 
    UParticleModuleSpawnPerUnit*        SpawnPerUnitModule;
 
    FName FirstSocketName;
 
    FName SecondSocketName;
 
    float Width;
 
    ETrailWidthMode WidthMode;
 
    const void* Owner;
    
    bool bTagTrailAsDead;
 
    bool bTrailEnabled;
 
#if WITH_EDITORONLY_DATA
    uint32 bRenderGeometry : 1;
    uint32 bRenderSpawnPoints : 1;
    uint32 bRenderTangents : 1;
    uint32 bRenderTessellation : 1;
#endif
 
    int32 HeadOnlyParticles;
 
    FParticleAnimTrailEmitterInstance(IParticleEmitterInstanceOwner& InComponent);
 
    virtual ~FParticleAnimTrailEmitterInstance();
 
    virtual void InitParameters(UParticleEmitter* InTemplate) override;
 
    virtual void RecalculateTangentAndInterpolationParam(
        FBaseParticle* PrevParticle, FAnimTrailTypeDataPayload* PrevTrailData, 
        FBaseParticle* CurrParticle, FAnimTrailTypeDataPayload* CurrTrailData, 
        FBaseParticle* NextParticle, FAnimTrailTypeDataPayload* NextTrailData);
 
    virtual void Tick_RecalculateTangents(float DeltaTime, UParticleLODLevel* CurrentLODLevel) override;
 
    virtual bool GetSpawnPerUnitAmount(float DeltaTime, int32 InTrailIdx, int32& OutCount, float& OutRate);
 
    virtual float Spawn(float DeltaTime) override;
 
    virtual void SetupTrailModules() override;
    void ResolveSource();
    virtual void UpdateSourceData(float DeltaTime, bool bFirstTime) override;
 
    void UpdateBoundingBox(float DeltaTime) override;
    void ForceUpdateBoundingBox() override;
 
    void DetermineVertexAndTriangleCount();
 
    virtual bool HasCompleted() override;
    virtual FDynamicEmitterDataBase* GetDynamicData(bool bSelected, ERHIFeatureLevel::Type InFeatureLevel) override;
 
    virtual FDynamicEmitterReplayDataBase* GetReplayData() override;
 
    virtual void GetAllocatedSize(int32& OutNum, int32& OutMax) override;
 
    virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
 
    virtual bool IsTrailEmitter() const override { return true; }
 
    virtual void BeginTrail() override;
 
    virtual void EndTrail() override;
 
    virtual void SetTrailSourceData(FName InFirstSocketName, FName InSecondSocketName, ETrailWidthMode InWidthMode, float InWidth) override;
 
    bool IsTrailActive()const;
 
#if WITH_EDITORONLY_DATA
    void SetTrailDebugData(bool bInRenderGeometry, bool bInRenderSpawnPoints, bool bInRenderTessellation, bool bInRenderTangents);
#endif
 
protected:
 
    virtual bool FillReplayData( FDynamicEmitterReplayDataBase& OutData ) override;
 
    void SpawnParticle( int32& StartParticleIndex, const struct FAnimTrailParticleSpawnParams& Params );
 
    virtual void PrintParticleData(FBaseParticle* Particle, FTrailsBaseTypeDataPayload* TrailData, int32 CurrentIndex, int32 TrailIndex) override;
    virtual void PrintAllActiveParticles() override;
    virtual void PrintTrails() override;
};