ParticleSystemComponent.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Components/SceneComponent.h"
#include "Components/PrimitiveComponent.h"
#include "Materials/MaterialInterface.h"
#include "Particles/ParticleSystem.h"
#include "Particles/Emitter.h"
#include "Runtime/Launch/Resources/Version.h"
#include "Particles/WorldPSCPool.h"
#include "Particles/ParticlePerfStats.h"
#include "StateStream/ParticleSystemStateStreamHandle.h"
#include "ParticleSystemComponent.generated.h"
 
class FParticleDynamicData;
class FPrimitiveSceneProxy;
class UParticleSystemReplay;
class UPhysicalMaterial;
struct EventData;
struct FDynamicEmitterDataBase;
struct FDynamicEmitterReplayDataBase;
struct FParticleEmitterInstance;
enum class EParticleSignificanceLevel : uint8;
struct FPSCTickData;
class FParticleSystemWorldManager;
 
//
// Forward declarations.
//
class UAnimNotifyState;
class FParticleDynamicData;
class FParticleSystemSceneProxy;
class UAnimNotifyState;
class UFXSystemAsset;
struct FDynamicEmitterDataBase;
struct FDynamicEmitterReplayDataBase;
struct FParticleAnimTrailEmitterInstance;
 
UENUM(BlueprintType)
enum EParticleSysParamType : int
{
    PSPT_None UMETA(DisplayName="None"),
    PSPT_Scalar UMETA(DisplayName="Scalar"),
    PSPT_ScalarRand UMETA(DisplayName="Scalar Random"),
    PSPT_Vector UMETA(DisplayName="Vector"),
    PSPT_VectorRand UMETA(DisplayName="Vector Random"),
    PSPT_Color UMETA(DisplayName="Color"),
    PSPT_Actor UMETA(DisplayName="Actor"),
    PSPT_Material UMETA(DisplayName="Material"),
    PSPT_VectorUnitRand UMETA(DisplayName = "Vector Unit Random"),
    PSPT_MAX,
};
 
UENUM()
enum ParticleReplayState : int
{
    PRS_Disabled UMETA(DisplayName="Disabled"),
    PRS_Capturing UMETA(DisplayName="Capturing"),
    PRS_Replaying UMETA(DisplayName="Replaying"),
    PRS_MAX,
};
 
UENUM()
enum EParticleEventType : int
{
    EPET_Any UMETA(DisplayName="Any"),
    EPET_Spawn UMETA(DisplayName="Spawn"),
    EPET_Death UMETA(DisplayName="Death"),
    EPET_Collision UMETA(DisplayName="Collision"),
    EPET_Burst UMETA(DisplayName="Burst"),
    EPET_Blueprint UMETA(DisplayName="Blueprint"),
    EPET_MAX,
};
 
// Called when the particle system is done
DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam( FOnSystemFinished, class UParticleSystemComponent*, PSystem );
 
//Called just before the activation of a component changes.
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnSystemPreActivationChange, class UParticleSystemComponent*, bool);
 
USTRUCT(BlueprintType)
struct FParticleSysParam
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=ParticleSysParam)
    FName Name;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=ParticleSysParam)
    TEnumAsByte<enum EParticleSysParamType> ParamType;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=ParticleSysParam)
    float Scalar;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=ParticleSysParam)
    float Scalar_Low;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=ParticleSysParam)
    FVector Vector;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=ParticleSysParam)
    FVector Vector_Low;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=ParticleSysParam)
    FColor Color;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=ParticleSysParam)
    TObjectPtr<class AActor> Actor;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=ParticleSysParam)
    TObjectPtr<class UMaterialInterface> Material;
 
    FParticleSysParam()
        : ParamType(0)
        , Scalar(0)
        , Scalar_Low(0)
        , Vector(ForceInit)
        , Vector_Low(ForceInit)
        , Color(ForceInit)
        , Actor(NULL)
        , Material(NULL)
        , AsyncActorToWorld(FTransform::Identity)
        , AsyncActorVelocity(FVector::ZeroVector)
        , bAsyncDataCopyIsValid(false)
    {
    }
 
    void UpdateAsyncActorCache()
    {
        check(IsInGameThread());
        if(Actor)
        {
            AsyncActorToWorld = Actor->ActorToWorld();
            AsyncActorVelocity = Actor->GetVelocity();
        }
        
        bAsyncDataCopyIsValid = true;
    }
 
    void ResetAsyncActorCache()
    {
        check(IsInGameThread());
        bAsyncDataCopyIsValid = false;
    }
 
    FTransform GetAsyncActorToWorld() const
    {
        if(bAsyncDataCopyIsValid)
        {
            return AsyncActorToWorld;
        }
        else if(Actor)
        {
            check(IsInGameThread());
            return Actor->ActorToWorld();
        }
 
        return FTransform::Identity;
    }
 
    FVector GetAsyncActorVelocity() const
    {
        if (bAsyncDataCopyIsValid)
        {
            return AsyncActorVelocity;
        }
        else if (Actor)
        {
            check(IsInGameThread());
            return Actor->GetVelocity();
        }
 
        return FVector::ZeroVector;
    }
 
private:
    FTransform AsyncActorToWorld;
    FVector AsyncActorVelocity;
    bool bAsyncDataCopyIsValid;
 
};
 
template <> struct TIsPODType<FParticleSysParam> { enum { Value = true }; };
 
struct FParticleEventData
{
    int32 Type;
 
    FName EventName;
 
    float EmitterTime;
 
    FVector Location;
 
    FVector Velocity;
 
    TArray<class UParticleModuleEventSendToGame*> EventData;
 
    FParticleEventData()
        : Type(0)
        , EmitterTime(0)
    {
    }
};
 
struct FParticleExistingData : FParticleEventData
{
    float ParticleTime;
 
    FVector Direction;
 
    FParticleExistingData()
        : ParticleTime(0)
        , Direction(ForceInit)
    {
    }
};
 
struct FParticleEventSpawnData : public FParticleEventData
{
};
 
struct FParticleEventDeathData : public FParticleExistingData
{
 
};
 
struct FParticleEventCollideData : public FParticleExistingData
{
    FVector Normal;
 
    float Time;
 
    int32 Item;
 
    FName BoneName;
 
    UPhysicalMaterial* PhysMat;
 
    FParticleEventCollideData()
        : Normal(ForceInit)
        , Time(0)
        , Item(0)
    {
    }
 
};
 
struct FParticleEventBurstData : public FParticleEventData
{
    int32 ParticleCount;
 
    FParticleEventBurstData()
        : ParticleCount(0)
    {
    }
};
 
struct FParticleEventKismetData : public FParticleEventData
{
};
 
USTRUCT(BlueprintType)
struct FFXSystemSpawnParameters
{
    GENERATED_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = "Effects|Components|ParticleSystem")
    TObjectPtr<const UObject> WorldContextObject;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Effects|Components|ParticleSystem")
    TObjectPtr<UFXSystemAsset> SystemTemplate;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Effects|Components|ParticleSystem")
    FVector Location = FVector::ZeroVector;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Effects|Components|ParticleSystem")
    FRotator Rotation = FRotator::ZeroRotator;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Effects|Components|ParticleSystem")
    FVector Scale = FVector(1.f);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = "Effects|Components|ParticleSystem")
    TObjectPtr<USceneComponent> AttachToComponent;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = "Effects|Components|ParticleSystem")
    FName AttachPointName = NAME_None;
    
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = "Effects|Components|ParticleSystem")
    TEnumAsByte<EAttachLocation::Type> LocationType = EAttachLocation::KeepWorldPosition;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Effects|Components|ParticleSystem")
    bool bAutoDestroy = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Effects|Components|ParticleSystem")
    bool bAutoActivate = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = "Effects|Components|ParticleSystem")
    EPSCPoolMethod PoolingMethod = EPSCPoolMethod::None;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = "Effects|Components|ParticleSystem")
    bool bPreCullCheck = true;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category = "Effects|Components|ParticleSystem")
    bool bIsPlayerEffect = false;
};
 
UCLASS(Abstract, MinimalAPI)
class UFXSystemComponent : public UPrimitiveComponent
{
    GENERATED_UCLASS_BODY()
public:
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    virtual void SetBoolParameter(FName ParameterName, bool Param) {}
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    virtual void SetIntParameter(FName ParameterName, int Param) {}
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    virtual void SetFloatParameter(FName ParameterName, float Param) {}
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    virtual void SetVectorParameter(FName ParameterName, FVector Param) {}
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    virtual void SetColorParameter(FName ParameterName, FLinearColor Param) {}
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    virtual void SetActorParameter(FName ParameterName, class AActor* Param) {}
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    virtual UFXSystemAsset* GetFXSystemAsset() const { return nullptr; };
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    virtual void SetEmitterEnable(FName EmitterName, bool bNewEnableState) {};
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    virtual void SetAutoAttachmentParameters(USceneComponent* Parent, FName SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule) {}
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    virtual void SetUseAutoManageAttachment(bool bAutoManage) {}
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    virtual void ReleaseToPool() {}
 
    virtual uint32 GetApproxMemoryUsage() const { return 0; }
 
    virtual void ActivateSystem(bool bFlagAsJustAttached = false) { };
 
    virtual void DeactivateImmediate() {}
 
    static ENGINE_API bool RequiresLWCTileRecache(const FVector3f CurrentTile, const FVector CurrentLocation);
 
#if WITH_PER_COMPONENT_PARTICLE_PERF_STATS
    mutable FParticlePerfStats* ParticlePerfStats = nullptr;
#endif
 
protected:
    ENGINE_API void PrecacheAssetPSOs(UFXSystemAsset* FXSystemAsset);
};
 
 
UCLASS(ClassGroup=(Rendering), hidecategories=Object, hidecategories=Physics, hidecategories=Collision, showcategories=Trigger, editinlinenew, meta=(BlueprintSpawnableComponent, DisplayName = "Cascade Particle System Component"), MinimalAPI)
class UParticleSystemComponent : public UFXSystemComponent
{
    friend class FParticleSystemWorldManager;
 
    GENERATED_UCLASS_BODY()
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Particles)
    TObjectPtr<class UParticleSystem> Template;
 
    UPROPERTY(transient, duplicatetransient)
    TArray<TObjectPtr<class UMaterialInterface>> EmitterMaterials;
 
    UPROPERTY(transient, duplicatetransient)
    TArray<TObjectPtr<class USkeletalMeshComponent>> SkelMeshComponents;
 
    uint8 bWasCompleted:1;
 
    uint8 bSuppressSpawning:1;
 
private:
    uint8 bIsElligibleForAsyncTick:1;
    uint8 bIsElligibleForAsyncTickComputed:1;
public:
 
    uint8 bWasDeactivated:1;
 
    uint8 bWasActive:1;
 
    uint8 bResetTriggered : 1;
 
    uint8 bDeactivateTriggered : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Particles)
    uint8 bResetOnDetach:1;
 
    UPROPERTY()
    uint8 bUpdateOnDedicatedServer:1;
 
    uint8 bJustRegistered:1;
 
    uint8 bHasBeenActivated:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, AdvancedDisplay, Category=Particles)
    uint8 bAllowRecycling:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Attachment)
    uint8 bAutoManageAttachment:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Attachment, meta=(EditCondition="bAutoManageAttachment"))
    uint8 bAutoAttachWeldSimulatedBodies:1;
    
    uint8 bIsManagingSignificance : 1;
    uint8 bWasManagingSignificance : 1;
 
    uint8 bIsDuringRegister : 1;
 
    UPROPERTY()
    uint8 bWarmingUp:1;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LOD)
    uint8 bOverrideLODMethod:1;
 
    UPROPERTY()
    uint8 bSkipUpdateDynamicDataDuringTick:1;
 
    uint8 bForcedInActive:1;
 
    uint8 bForceLODUpdateFromRenderer:1;
 
    uint8 bIsViewRelevanceDirty : 1;
 
    uint8 bAutoDestroy : 1;
 
private:
    
    uint8 bIsTransformDirty:1;
 
    uint8 bDidAutoAttach : 1;
 
    uint8 bAsyncDataCopyIsValid:1;
    uint8 bParallelRenderThreadUpdate:1;
 
    uint8 bNeedsFinalize:1;
    
    volatile bool bAsyncWorkOutstanding;
    
    ENGINE_API void CancelAutoAttachment(bool bDetachFromParent, const UWorld* MyWorld);
 
    int32 ManagerHandle : 30;
    int32 bPendingManagerAdd : 1;
    int32 bPendingManagerRemove : 1;
 
public:
 
#if WITH_EDITOR
    virtual bool Editor_CanBeTickManaged()const { return true; }
#endif
    ENGINE_API bool ShouldBeTickManaged()const;
 
    inline bool IsTickManaged()const { return ManagerHandle != INDEX_NONE && !IsPendingManagerRemove(); }
    inline int32 GetManagerHandle()const { return ManagerHandle; }
    inline void SetManagerHandle(int32 InHandle) { ManagerHandle = InHandle; }
 
    inline int32 IsPendingManagerAdd()const { return bPendingManagerAdd; }
    inline void SetPendingManagerAdd(bool bValue) { bPendingManagerAdd = bValue; }
    inline int32 IsPendingManagerRemove()const { return bPendingManagerRemove; }
    inline void SetPendingManagerRemove(bool bValue) { bPendingManagerRemove = bValue; }
 
    ENGINE_API FPSCTickData& GetManagerTickData();
    ENGINE_API FParticleSystemWorldManager* GetWorldManager()const;
 
 
    EPSCPoolMethod PoolingMethod;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=LOD)
    TEnumAsByte<enum ParticleSystemLODMethod> LODMethod;
 
    UPROPERTY()
    EParticleSignificanceLevel RequiredSignificance;
 
    TEnumAsByte<enum ParticleReplayState> ReplayState;
 
    void ResetNextTick()
    {
        bResetTriggered = true;
    }
 
    void DeactivaateNextTick()
    {
        bDeactivateTriggered = true;
    }
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Particles)
    TArray<struct FParticleSysParam> InstanceParameters;
 
    UPROPERTY(BlueprintAssignable)
    FParticleSpawnSignature OnParticleSpawn;
 
    UPROPERTY(BlueprintAssignable)
    FParticleBurstSignature OnParticleBurst;
 
    UPROPERTY(BlueprintAssignable)
    FParticleDeathSignature OnParticleDeath;
 
    UPROPERTY(BlueprintAssignable)
    FParticleCollisionSignature OnParticleCollide;
 
    UPROPERTY(Transient, DuplicateTransient)
    bool bOldPositionValid;
 
    UPROPERTY(Transient, DuplicateTransient)
    FVector OldPosition;
 
    UPROPERTY(Transient, DuplicateTransient)
    FVector PartSysVelocity;
 
    UPROPERTY(Transient, DuplicateTransient)
    float WarmupTime;
 
    UPROPERTY(Transient, DuplicateTransient)
    float WarmupTickRate;
 
private:
    int32 LODLevel;
 
public:
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Particles)
    float SecondsBeforeInactive;
 
private:
    float TimeSinceLastForceUpdateTransform;
 
public:
    UPROPERTY()
    float MaxTimeBeforeForceUpdateTransform;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    int32 EditorLODLevel;
 
    UPROPERTY()
    int32 EditorDetailMode;
 
#endif // WITH_EDITORONLY_DATA
    float AccumTickTime;
 
    float LastSignificantTime;
 
    float AccumLODDistanceCheckTime;
 
    TArray<FMaterialRelevance> CachedViewRelevanceFlags;
 
    UPROPERTY()
    TArray<TObjectPtr<class UParticleSystemReplay>> ReplayClips;
 
    int32 ReplayClipIDNumber;
 
    int32 ReplayFrameIndex;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Particles)
    float CustomTimeDilation;
 
    float EmitterDelay;
 
    TArray<struct FParticleEventSpawnData> SpawnEvents;
 
    TArray<struct FParticleEventDeathData> DeathEvents;
 
    TArray<struct FParticleEventCollideData> CollisionEvents;
 
    TArray<struct FParticleEventBurstData> BurstEvents;
 
    TArray<struct FParticleEventKismetData> KismetEvents;
 
public:
    UPROPERTY(VisibleInstanceOnly, BlueprintReadWrite, Category=Attachment, meta=(EditCondition="bAutoManageAttachment"))
    TWeakObjectPtr<USceneComponent> AutoAttachParent;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category=Attachment, meta=(EditCondition="bAutoManageAttachment"))
    FName AutoAttachSocketName;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TEnumAsByte<EAttachLocation::Type> AutoAttachLocationType_DEPRECATED;
#endif
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Attachment, meta = (EditCondition = "bAutoManageAttachment"))
    EAttachmentRule AutoAttachLocationRule;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Attachment, meta = (EditCondition = "bAutoManageAttachment"))
    EAttachmentRule AutoAttachRotationRule;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Attachment, meta = (EditCondition = "bAutoManageAttachment"))
    EAttachmentRule AutoAttachScaleRule;
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem", meta=(DeprecatedFunction, DeprecationMessage="Please use Set Auto Attachment Parameters"))
    void SetAutoAttachParams(USceneComponent* Parent, FName SocketName = NAME_None, EAttachLocation::Type LocationType = EAttachLocation::KeepRelativeOffset);
 
    ENGINE_API void SetAutoAttachmentParameters(USceneComponent* Parent, FName SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule) override;
 
    virtual void SetUseAutoManageAttachment(bool bAutoManage) override { bAutoManageAttachment = bAutoManage; }
 
private:
 
    FVector SavedAutoAttachRelativeLocation;
    FRotator SavedAutoAttachRelativeRotation;
    FVector SavedAutoAttachRelativeScale3D;
 
public:
    class FFXSystem* FXSystem;
 
    // Called when the particle system is done
    UPROPERTY(BlueprintAssignable)
    FOnSystemFinished OnSystemFinished;
 
private:
    TArray<struct FParticleSysParam> AsyncInstanceParameters;
    TArray<FVector> PlayerLocations;
    TArray<float> PlayerLODDistanceFactor;
    FBoxSphereBounds AsyncBounds;
    FVector AsyncPartSysVelocity;
    FVector3f LWCTile = FVector3f::ZeroVector;
public:
 
    ENGINE_API void SetRequiredSignificance(EParticleSignificanceLevel NewRequiredSignificance);
    ENGINE_API bool ShouldManageSignificance()const;
    ENGINE_API void OnSignificanceChanged(bool bSignificant, bool bApplyToEmitters, bool bAsync=false);
 
    inline void SetManagingSignificance(bool bManageSignificance)
    {
        bWasManagingSignificance = bIsManagingSignificance;
        bIsManagingSignificance = bManageSignificance;
    }
 
    inline const FVector3f& GetLWCTile() const { return LWCTile;  }
    
    ENGINE_API float GetApproxDistanceSquared(FVector Point)const;
    
    ENGINE_API bool CanConsiderInvisible()const;
 
    ENGINE_API bool CanSkipTickDueToVisibility();
 
    ENGINE_API bool CanBeOccluded()const;
 
    ENGINE_API void Complete();
    
    inline const FTransform& GetAsyncComponentToWorld()
    {
        if (!bParallelRenderThreadUpdate && !IsInGameThread())
        {
            check(bAsyncDataCopyIsValid); 
            return AsyncComponentToWorld;
        }
        return GetComponentTransform();
    }
 
    inline const TArray<struct FParticleSysParam>& GetAsyncInstanceParameters()
    {
        if (!bParallelRenderThreadUpdate && !IsInGameThread())
        {
            check(bAsyncDataCopyIsValid); 
            return AsyncInstanceParameters;
        }
        return InstanceParameters;
    }
 
    inline const FBoxSphereBounds& GetAsyncBounds()
    {
        if (!bParallelRenderThreadUpdate && !IsInGameThread())
        {
            check(bAsyncDataCopyIsValid);
            return AsyncBounds;
        }
        return Bounds;
    }
 
    inline const FVector& GetAsyncPartSysVelocity()
    {
        if (!bParallelRenderThreadUpdate && !IsInGameThread())
        {
            check(bAsyncDataCopyIsValid);
            return AsyncPartSysVelocity;
        }
        return PartSysVelocity;
    }
 
    inline const TArray<FVector>& GetPlayerLocations()
    {
        return PlayerLocations;
    }
 
    inline const TArray<float>& GetPlayerLODDistanceFactor()
    {
        return PlayerLODDistanceFactor;
    }
 
    //
    //  Beam-related script functions.
    //
    
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    ENGINE_API virtual void SetBeamEndPoint(int32 EmitterIndex, FVector NewEndPoint);
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    ENGINE_API virtual void SetBeamSourcePoint(int32 EmitterIndex, FVector NewSourcePoint, int32 SourceIndex);
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    ENGINE_API virtual void SetBeamSourceTangent(int32 EmitterIndex, FVector NewTangentPoint, int32 SourceIndex);
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    ENGINE_API virtual void SetBeamSourceStrength(int32 EmitterIndex, float NewSourceStrength, int32 SourceIndex);
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    ENGINE_API virtual void SetBeamTargetPoint(int32 EmitterIndex, FVector NewTargetPoint, int32 TargetIndex);
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    ENGINE_API virtual void SetBeamTargetTangent(int32 EmitterIndex, FVector NewTangentPoint, int32 TargetIndex);
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    ENGINE_API virtual void SetBeamTargetStrength(int32 EmitterIndex, float NewTargetStrength, int32 TargetIndex);
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    ENGINE_API virtual bool GetBeamEndPoint(int32 EmitterIndex, FVector& OutEndPoint) const;
    
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    ENGINE_API virtual bool GetBeamSourcePoint(int32 EmitterIndex, int32 SourceIndex, FVector& OutSourcePoint) const;
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    ENGINE_API virtual bool GetBeamSourceTangent(int32 EmitterIndex, int32 SourceIndex, FVector& OutTangentPoint) const;
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    ENGINE_API virtual bool GetBeamSourceStrength(int32 EmitterIndex, int32 SourceIndex, float& OutSourceStrength) const;
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    ENGINE_API virtual bool GetBeamTargetPoint(int32 EmitterIndex, int32 TargetIndex, FVector& OutTargetPoint) const;
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    ENGINE_API virtual bool GetBeamTargetTangent(int32 EmitterIndex, int32 TargetIndex, FVector& OutTangentPoint) const;
    
    UFUNCTION(BlueprintCallable, Category = "Effects|Components|ParticleSystem")
    ENGINE_API virtual bool GetBeamTargetStrength(int32 EmitterIndex, int32 TargetIndex, float& OutTargetStrength) const;
    
    ENGINE_API void SetEmitterEnable(FName EmitterName, bool bNewEnableState) override;
 
 
    ENGINE_API void SetBoolParameter(FName ParameterName, bool Param) override;
 
    ENGINE_API void SetIntParameter(FName ParameterName, int Param) override;
 
    ENGINE_API void SetFloatParameter(FName ParameterName, float Param) override;
 
    ENGINE_API void SetVectorParameter(FName ParameterName, FVector Param) override;
 
    ENGINE_API void SetColorParameter(FName ParameterName, FLinearColor Param) override;
 
    ENGINE_API void SetActorParameter(FName ParameterName, class AActor* Param) override;
 
    virtual UFXSystemAsset* GetFXSystemAsset() const { return Template; };
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    ENGINE_API void SetMaterialParameter(FName ParameterName, class UMaterialInterface* Param);
 
    ENGINE_API virtual bool GetFloatParameter(const FName InName, float& OutFloat);
 
    ENGINE_API virtual bool GetVectorParameter(const FName InName, FVector& OutVector);
 
    ENGINE_API virtual bool GetAnyVectorParameter(const FName InName, FVector& OutVector);
 
    ENGINE_API virtual bool GetColorParameter(const FName InName, FLinearColor& OutColor);
 
    ENGINE_API virtual bool GetActorParameter(const FName InName, class AActor*& OutActor);
 
    ENGINE_API virtual bool GetMaterialParameter(const FName InName, class UMaterialInterface*& OutMaterial);
 
    ENGINE_API void ClearParameter(FName ParameterName, enum EParticleSysParamType ParameterType = EParticleSysParamType(0));
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    ENGINE_API void SetTemplate(class UParticleSystem* NewTemplate);
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    ENGINE_API int32 GetNumActiveParticles() const;
 
 
    typedef TArray< struct FParticleAnimTrailEmitterInstance*, TInlineAllocator<8> > TrailEmitterArray;
 
    ENGINE_API virtual void GetOwnedTrailEmitters(TrailEmitterArray& OutTrailEmitters, const void* InOwner, bool bSetOwner = false);
    
    UFUNCTION(BlueprintCallable, Category = "Effects|Particles|Trails")
    ENGINE_API void BeginTrails(FName InFirstSocketName, FName InSecondSocketName, ETrailWidthMode InWidthMode, float InWidth);
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Particles|Trails")
    ENGINE_API void EndTrails();
 
    ENGINE_API void ReleaseToPool() override;
 
    UFUNCTION(BlueprintCallable, Category = "Effects|Particles|Trails")
    ENGINE_API void SetTrailSourceData(FName InFirstSocketName, FName InSecondSocketName, ETrailWidthMode InWidthMode, float InWidth);
 
public:
    class FRenderCommandFence* ReleaseResourcesFence;
 
    TArray<struct FParticleEmitterInstance*> EmitterInstances;
 
    static ENGINE_API FOnSystemPreActivationChange OnSystemPreActivationChange;
 
    FRandomStream RandomStream;
 
    class FInstanceOwner;
    TUniquePtr<FInstanceOwner> InstanceOwner;
 
private:
    inline void SetAsyncWork(FGraphEventRef& InAsyncWork) { AsyncWork = InAsyncWork; }
 
    FTransform AsyncComponentToWorld;
 
    FGraphEventRef AsyncWork;
 
    float DeltaTimeTick;
    int32 TotalActiveParticles;
    uint32 NumSignificantEmitters;
    uint32 TimeSinceLastTick;
 
#if WITH_STATE_STREAM_ACTOR
    FParticleSystemHandle ParticleSystemHandle;
#endif
 
public:
 
    //~ Begin UActorComponent Interface.
#if WITH_EDITOR
    ENGINE_API virtual void CheckForErrors() override;
#endif
    ENGINE_API virtual bool IsReadyForOwnerToAutoDestroy() const override;
    ENGINE_API virtual void TickComponent(float DeltaTime, enum ELevelTick TickType, FActorComponentTickFunction *ThisTickFunction) override;
    virtual UObject const* AdditionalStatObject() const override
    {
        return Template;
    }
    ENGINE_API virtual void SetComponentTickEnabled(bool bEnabled)override;
    ENGINE_API virtual bool IsComponentTickEnabled() const override;
 
    ENGINE_API virtual void OnAttachmentChanged()override;
    ENGINE_API virtual void OnChildAttached(USceneComponent* ChildComponent)override;
    ENGINE_API virtual void OnChildDetached(USceneComponent* ChildComponent)override;
 
    ENGINE_API virtual void OnEndOfFrameUpdateDuringTick() override;
protected:
    ENGINE_API virtual void CreateRenderState_Concurrent(FRegisterComponentContext* Context) override;
    ENGINE_API virtual void SendRenderTransform_Concurrent() override;
    ENGINE_API virtual void DestroyRenderState_Concurrent() override;
    ENGINE_API virtual void OnRegister() override;
    ENGINE_API virtual void OnUnregister()  override;
    ENGINE_API virtual void SendRenderDynamicData_Concurrent() override;
public:
#if WITH_EDITORONLY_DATA
    virtual bool RequiresGameThreadEndOfFrameUpdates() const override { return true; }
    virtual bool RequiresGameThreadEndOfFrameRecreate() const override { return true; }
#endif
    //~ End UActorComponent Interface.
 
    enum EForceAsyncWorkCompletion
    {
        STALL,
        ENSURE_AND_STALL,
        SILENT, // this would only be appropriate for editor only or other unusual things that we never see in game
    };
    inline void ForceAsyncWorkCompletion(EForceAsyncWorkCompletion Behavior, bool bDefinitelyGameThread, bool InSkipUpdateDynamicDataDuringTick)
    {
        if (AsyncWork.GetReference())
        {
            const bool bSavedSkipUpdate = bSkipUpdateDynamicDataDuringTick;
            bSkipUpdateDynamicDataDuringTick |= InSkipUpdateDynamicDataDuringTick;
            WaitForAsyncAndFinalize(Behavior, bDefinitelyGameThread);
            bSkipUpdateDynamicDataDuringTick = bSavedSkipUpdate;
        }
    }
 
    inline void ForceAsyncWorkCompletion(EForceAsyncWorkCompletion Behavior, bool bDefinitelyGameThread = true) const
    {
        if (AsyncWork.GetReference())
        {
            WaitForAsyncAndFinalize(Behavior, bDefinitelyGameThread);
        }
    }
 
    ENGINE_API int32 GetCurrentDetailMode() const;
 
    ENGINE_API void ComputeTickComponent_Concurrent();
 
    ENGINE_API void FinalizeTickComponent();
 
    ENGINE_API void ForceReset();
 
    ENGINE_API void MarshalParamsForAsyncTick();
private:
    ENGINE_API void WaitForAsyncAndFinalize(EForceAsyncWorkCompletion Behavior, bool bDefinitelyGameThread = true) const;
 
    ENGINE_API void CacheViewRelevanceFlags(class UParticleSystem* TemplateToCache);
 
public:
 
    //~ Begin UObject Interface.
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual void FinishDestroy() override;
#if WITH_EDITOR
    ENGINE_API virtual void PreEditChange(FProperty* PropertyThatWillChange) override;
    ENGINE_API virtual void PostEditChangeChainProperty(FPropertyChangedChainEvent& PropertyChangedEvent) override;
#endif // WITH_EDITOR
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
    ENGINE_API virtual void GetResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) override;
    ENGINE_API virtual FString GetDetailedInfoInternal() const override;
    //~ End UObject Interface.
 
    //Begin UPrimitiveComponent Interface
    ENGINE_API virtual int32 GetNumMaterials() const override;
    ENGINE_API virtual UMaterialInterface* GetMaterial(int32 ElementIndex) const override;
    ENGINE_API virtual void SetMaterial(int32 ElementIndex, UMaterialInterface* Material) override;
    ENGINE_API virtual FBoxSphereBounds CalcBounds(const FTransform& LocalToWorld) const override;
    ENGINE_API virtual FPrimitiveSceneProxy* CreateSceneProxy() override;
    ENGINE_API virtual void GetUsedMaterials( TArray<UMaterialInterface*>& OutMaterials, bool bGetDebugMaterials = false ) const override;
    ENGINE_API virtual void GetStreamingRenderAssetInfo(FStreamingTextureLevelContext& LevelContext, TArray<FStreamingRenderAssetPrimitiveInfo>& OutStreamingRenderAssets) const override;
    ENGINE_API virtual FBodyInstance* GetBodyInstance(FName BoneName = NAME_None, bool bGetWelded = true, int32 Index = INDEX_NONE) const override;
    //End UPrimitiveComponent Interface
 
    //~ Begin USceneComonent Interface
protected:
    ENGINE_API virtual bool ShouldActivate() const override;
 
public:
#if WITH_EDITOR
    ENGINE_API virtual bool GetMaterialPropertyPath(int32 ElementIndex, UObject*& OutOwner, FString& OutPropertyPath, FProperty*& OutProperty) override;
#endif // WITH_EDITOR
    ENGINE_API virtual void Activate(bool bReset=false) override;
    ENGINE_API virtual void Deactivate() override;
    ENGINE_API virtual void DeactivateImmediate() override;
    ENGINE_API virtual void ApplyWorldOffset(const FVector& InOffset, bool bWorldShift) override;
    //~ End USceneComponent Interface
 
    ENGINE_API virtual void ActivateSystem(bool bFlagAsJustAttached = false) override;
    ENGINE_API void DeactivateSystem();
    // Collision Handling...
    ENGINE_API virtual bool ParticleLineCheck(FHitResult& Hit, AActor* SourceActor, const FVector& End, const FVector& Start, const FVector& HalfExtent, const FCollisionObjectQueryParams& ObjectParams);
 
    inline bool CanTickInAnyThread()
    {
        if (!bIsElligibleForAsyncTickComputed)
        {
            ComputeCanTickInAnyThread();
        }
        return bIsElligibleForAsyncTick;
    }
    ENGINE_API void ComputeCanTickInAnyThread();
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API virtual class UMaterialInstanceDynamic* CreateNamedDynamicMaterialInstance(FName InName, class UMaterialInterface* SourceMaterial = NULL);
 
    ENGINE_API virtual UMaterialInterface* GetMaterialByName(FName MaterialSlotName) const override;
    ENGINE_API virtual void SetMaterialByName(FName MaterialSlotName, class UMaterialInterface* SourceMaterial) override;
 
    UFUNCTION(BlueprintCallable, Category = "Rendering|Material")
    ENGINE_API virtual class UMaterialInterface* GetNamedMaterial(FName InName) const;
 
    ENGINE_API virtual int32 GetNamedMaterialIndex(FName InName) const;
 
    ENGINE_API virtual FName GetNameForMaterial(UMaterialInterface* InMaterial) const;
 
    ENGINE_API uint32 GetApproxMemoryUsage() const override;
 
protected:
 
    // @todo document
    ENGINE_API virtual void UpdateLODInformation();
 
    static ENGINE_API FDynamicEmitterDataBase* CreateDynamicDataFromReplay( FParticleEmitterInstance* EmitterInstance, const FDynamicEmitterReplayDataBase* EmitterReplayData, bool bSelected, ERHIFeatureLevel::Type InFeatureLevel );
 
    ENGINE_API FParticleDynamicData* CreateDynamicData(ERHIFeatureLevel::Type InFeatureLevel);
 
    ENGINE_API void OrientZAxisTowardCamera();
 
    ENGINE_API void ClearDynamicData();
 
    // @todo document
    ENGINE_API virtual void UpdateDynamicData();
 
public:
    inline int32 GetCurrentLODIndex() const
    {
        return LODLevel;
    }
 
    // If particles have not already been initialised (ie. EmitterInstances created) do it now.
    ENGINE_API virtual void InitParticles();
 
 
    // @todo document
    ENGINE_API void ResetParticles(bool bEmptyInstances = false);
 
 
    // @todo document
    ENGINE_API void ResetBurstLists();
 
 
    // @todo document
    ENGINE_API void UpdateInstances(bool bEmptyInstances = false);
 
 
    // @todo document
    ENGINE_API bool HasCompleted();
 
 
    // @todo document
    ENGINE_API void InitializeSystem();
 
    ENGINE_API void ConditionalCacheViewRelevanceFlags(class UParticleSystem* NewTemplate = NULL);
 
    ENGINE_API void AutoPopulateInstanceProperties();
 
    ENGINE_API void ReportEventSpawn(const FName InEventName, const float InEmitterTime,
        const FVector InLocation, const FVector InVelocity, const TArray<class UParticleModuleEventSendToGame*>& InEventData);
 
    ENGINE_API void ReportEventDeath(const FName InEventName, const float InEmitterTime,
        const FVector InLocation, const FVector InVelocity, const TArray<class UParticleModuleEventSendToGame*>& InEventData, const float InParticleTime);
 
    ENGINE_API void ReportEventCollision(const FName InEventName, const float InEmitterTime, const FVector InLocation,
        const FVector InDirection, const FVector InVelocity, const TArray<class UParticleModuleEventSendToGame*>& InEventData, 
        const float InParticleTime, const FVector InNormal, const float InTime, const int32 InItem, const FName InBoneName, UPhysicalMaterial* PhysMat);
 
    ENGINE_API void ReportEventBurst(const FName InEventName, const float InEmitterTime, const int32 ParticleCount,
        const FVector InLocation, const TArray<class UParticleModuleEventSendToGame*>& InEventData);
 
    UFUNCTION(BlueprintCallable, Category="Effects|Components|ParticleSystem")
    ENGINE_API void GenerateParticleEvent(const FName InEventName, const float InEmitterTime,
        const FVector InLocation, const FVector InDirection, const FVector InVelocity);
 
 
    ENGINE_API UParticleSystemReplay* FindReplayClipForIDNumber( const int32 InClipIDNumber );
 
    // @todo document
    ENGINE_API void KillParticlesForced();
    
    ENGINE_API void SetVectorRandParameter(FName ParameterName, const FVector& Param, const FVector& ParamLow);
 
 
 
    ENGINE_API void SetVectorUnitRandParameter(FName ParameterName, const FVector& Param, const FVector& ParamLow);
 
    ENGINE_API void SetFloatRandParameter(FName ParameterName, float Param, float ParamLow);
 
    ENGINE_API void ForceUpdateBounds();    
    
 
    // @todo document
    ENGINE_API virtual void RewindEmitterInstances();
    
    ENGINE_API virtual int32 DetermineLODLevelForLocation(const FVector& EffectLocation);
    
    ENGINE_API virtual void SetLODLevel(int32 InLODLevel);
    
    ENGINE_API virtual int32 GetLODLevel();
    
    ENGINE_API void ResetToDefaults();
 
private:
    ENGINE_API bool ShouldComputeLODFromGameThread();
 
public:
    inline FParticlePerfStatsContext GetPerfStatsContext(){ return FParticlePerfStatsContext(GetWorld(), Template, this); }
};
 
 
// ParticleSystemComponent inlines
 
inline void UParticleSystemComponent::SetAutoAttachParams(USceneComponent* Parent, FName SocketName, EAttachLocation::Type LocationType)
{
    AutoAttachParent = Parent;
    AutoAttachSocketName = SocketName;
 
    USceneComponent::ConvertAttachLocation(LocationType, AutoAttachLocationRule, AutoAttachRotationRule, AutoAttachScaleRule);
}