ParticleSystem.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 "UObject/ScriptMacros.h"
#include "Particles/ParticlePerfStats.h"
#include "Async/TaskGraphInterfaces.h"
#include "RHIDefinitions.h"
#include "PSOPrecache.h"
 
#include "ParticleSystem.generated.h"
 
enum class EParticleSignificanceLevel : uint8;
enum class EParticleSystemInsignificanceReaction: uint8;
class UInterpCurveEdSetup;
class UMaterialInterface;
class UParticleSystemComponent;
class UParticleEmitter;
 
UENUM()
enum EParticleSystemUpdateMode : int
{
    EPSUM_RealTime UMETA(DisplayName="Real-Time"),
    EPSUM_FixedTime UMETA(DisplayName="Fixed-Time")
};
 
UENUM()
enum ParticleSystemLODMethod : int
{
    // Automatically set the LOD level, checking every LODDistanceCheckTime seconds.
    PARTICLESYSTEMLODMETHOD_Automatic UMETA(DisplayName="Automatic"),
 
    // LOD level is directly set by the game code.
    PARTICLESYSTEMLODMETHOD_DirectSet UMETA(DisplayName = "Direct Set"),
 
    // LOD level is determined at Activation time, then left alone unless directly set by game code.
    PARTICLESYSTEMLODMETHOD_ActivateAutomatic UMETA(DisplayName = "Activate Automatic")
};
 
UENUM()
enum EParticleSystemOcclusionBoundsMethod : int
{
    EPSOBM_None UMETA(DisplayName="None"),
    EPSOBM_ParticleBounds UMETA(DisplayName="Particle Bounds"),
    EPSOBM_CustomBounds UMETA(DisplayName="Custom Bounds")
};
 
USTRUCT()
struct FParticleSystemLOD
{
    GENERATED_USTRUCT_BODY()
 
    FParticleSystemLOD()
    {
    }
 
    static FParticleSystemLOD CreateParticleSystemLOD()
    {
        FParticleSystemLOD NewLOD;
        return NewLOD;
    }
};
 
USTRUCT()
struct FLODSoloTrack
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY(transient)
    TArray<uint8> SoloEnableSetting;
 
};
 
USTRUCT()
struct FNamedEmitterMaterial
{
    GENERATED_USTRUCT_BODY()
 
    FNamedEmitterMaterial()
    : Name(NAME_None)
    , Material(nullptr)
    {
    }
 
    UPROPERTY(EditAnywhere, Category = NamedMaterial)
    FName Name;
 
    UPROPERTY(EditAnywhere, Category = NamedMaterial)
    TObjectPtr<UMaterialInterface> Material;
};
 
using FMaterialPSOPrecacheRequestID = uint32;
 
UCLASS(Abstract, MinimalAPI, BlueprintType)
class UFXSystemAsset : public UObject
{
    GENERATED_UCLASS_BODY()
public:
    UFXSystemAsset() {}
 
    UPROPERTY(EditAnywhere, Category = Performance, AdvancedDisplay)
    uint32 MaxPoolSize;
    //TODO: Allow pool size overriding per world and possibly implement some preallocation too.
 
    UPROPERTY(EditAnywhere, Category = Performance, AdvancedDisplay)
    uint32 PoolPrimeSize = 0;
 
#if WITH_PER_SYSTEM_PARTICLE_PERF_STATS
    mutable FParticlePerfStats* ParticlePerfStats = nullptr;
#endif
 
    const bool HasLaunchedPSOPrecaching() const { return PSOPrecachingLaunched; }
    const FGraphEventRef& GetPrecachePSOsEvent() const { return PrecachePSOsEvent; }
    const TArray<FMaterialPSOPrecacheRequestID>& GetMaterialPSOPrecacheRequestIDs() const { return MaterialPSOPrecacheRequestIDs; }
 
protected:
    
    ENGINE_API void LaunchPSOPrecaching(const FMaterialInterfacePSOPrecacheParamsList& VFsPerMaterials);
 
    bool PSOPrecachingLaunched = false;
    FGraphEventRef PrecachePSOsEvent;
    TArray<FMaterialPSOPrecacheRequestID> MaterialPSOPrecacheRequestIDs;
};
 
UCLASS(hidecategories=Object, MinimalAPI, BlueprintType)
class UParticleSystem : public UFXSystemAsset
{
    GENERATED_UCLASS_BODY()
 
    UParticleSystem()
    :OcclusionBoundsMethod(EPSOBM_ParticleBounds)
    {
 
    }
 
    UPROPERTY(EditAnywhere, Category=ParticleSystem)
    float UpdateTime_FPS;
 
    UPROPERTY()
    float UpdateTime_Delta;
 
    UPROPERTY(EditAnywhere, Category=ParticleSystem, meta=(DisplayName="Warmup Time - beware hitches!"))
    float WarmupTime;
 
    UPROPERTY(EditAnywhere, Category=ParticleSystem)
    float WarmupTickRate;
 
    UPROPERTY(instanced)
    TArray<TObjectPtr<UParticleEmitter>> Emitters;
 
    UPROPERTY(transient)
    TObjectPtr<UParticleSystemComponent> PreviewComponent;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FRotator ThumbnailAngle;
 
    UPROPERTY()
    float ThumbnailDistance;
 
    UPROPERTY(EditAnywhere, Category=Thumbnail)
    float ThumbnailWarmup;
 
#endif // WITH_EDITORONLY_DATA
    UPROPERTY(export)
    TObjectPtr<UInterpCurveEdSetup> CurveEdSetup;
 
    //
    //  LOD
    //
    UPROPERTY(EditAnywhere, Category=LOD, AssetRegistrySearchable)
    float LODDistanceCheckTime;
 
    UPROPERTY(EditAnywhere, Category = MacroUV)
    float MacroUVRadius;
 
    UPROPERTY(EditAnywhere, editfixedsize, Category=LOD)
    TArray<float> LODDistances;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    int32 EditorLODSetting;
 
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, Category=LOD)
    TArray<FParticleSystemLOD> LODSettings;
 
    UPROPERTY(EditAnywhere, Category=Bounds)
    FBox FixedRelativeBoundingBox;
 
    UPROPERTY(EditAnywhere, Category=ParticleSystem)
    float SecondsBeforeInactive;
 
#if WITH_EDITORONLY_DATA
    //
    //  Cascade 'floor' mesh information.
    //
    UPROPERTY()
    FString FloorMesh;
 
    UPROPERTY()
    FVector FloorPosition;
 
    UPROPERTY()
    FRotator FloorRotation;
 
    UPROPERTY()
    float FloorScale;
 
    UPROPERTY()
    FVector FloorScale3D;
 
    UPROPERTY()
    FColor BackgroundColor;
 
#endif // WITH_EDITORONLY_DATA
    
    UPROPERTY(EditAnywhere, Category=Delay, AssetRegistrySearchable)
    float Delay;
 
    UPROPERTY(EditAnywhere, Category=Delay)
    float DelayLow;
 
    UPROPERTY(EditAnywhere, Category = ParticleSystem)
    uint8 bOrientZAxisTowardCamera : 1;
 
    UPROPERTY(EditAnywhere, Category = Bounds)
    uint8 bUseFixedRelativeBoundingBox : 1;
 
    UPROPERTY()
    uint8 bShouldResetPeakCounts : 1;
 
    UPROPERTY(transient)
    uint8 bHasPhysics : 1;
 
    UPROPERTY(EditAnywhere, Category=Thumbnail)
    uint8 bUseRealtimeThumbnail : 1;
 
    UPROPERTY()
    uint8 ThumbnailImageOutOfDate : 1;
 
private:
    uint8 bIsElligibleForAsyncTick : 1;
    uint8 bIsElligibleForAsyncTickComputed : 1;
public:
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TObjectPtr<class UTexture2D> ThumbnailImage;
 
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, Category=Delay)
    uint8 bUseDelayRange : 1;
 
    UPROPERTY(EditAnywhere, Category = Performance, meta = (ToolTip = "Whether or not to allow instances of this system to have their ticks managed."), AdvancedDisplay)
    uint8 bAllowManagedTicking : 1;
 
    UPROPERTY(EditAnywhere, Category = Performance, meta = (ToolTip = "Auto-deactivate system if all emitters are determined to not spawn particles again, regardless of lifetime."))
    uint8 bAutoDeactivate : 1;
 
    UPROPERTY()
    uint8 bRegenerateLODDuplicate : 1;
 
    UPROPERTY(EditAnywhere, Category = ParticleSystem, AssetRegistrySearchable)
    TEnumAsByte<enum EParticleSystemUpdateMode> SystemUpdateMode;
 
    UPROPERTY(EditAnywhere, Category=LOD)
    TEnumAsByte<enum ParticleSystemLODMethod> LODMethod;
 
    UPROPERTY(EditAnywhere, Category = Performance)
    EParticleSystemInsignificanceReaction InsignificantReaction;
 
    UPROPERTY(EditAnywhere, Category = Occlusion)
    TEnumAsByte<enum EParticleSystemOcclusionBoundsMethod> OcclusionBoundsMethod;
 
private:
    uint8 bAnyEmitterLoopsForever : 1;
 
public:
 
    UPROPERTY(EditAnywhere, Category = Performance)
    EParticleSignificanceLevel MaxSignificanceLevel;
 
    UPROPERTY(EditAnywhere, Category = Performance, meta = (ToolTip = "Minimum duration between ticks; 33=tick at max. 30FPS, 16=60FPS, 8=120FPS"))
    uint32 MinTimeBetweenTicks;
 
    UPROPERTY(EditAnywhere, Category = Performance)
    float InsignificanceDelay;
 
    UPROPERTY(EditAnywhere, Category=MacroUV)
    FVector MacroUVPosition;
 
    UPROPERTY(EditAnywhere, Category=Occlusion)
    FBox CustomOcclusionBounds;
 
    UPROPERTY(transient)
    TArray<struct FLODSoloTrack> SoloTracking;
 
    UPROPERTY(EditAnywhere, Category = Materials)
    TArray<FNamedEmitterMaterial> NamedMaterialSlots;
 
    //~ Begin UObject Interface.
#if WITH_EDITOR
    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif // WITH_EDITOR
    virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
    virtual void PostLoad() override;
    virtual bool IsPostLoadThreadSafe() const override;
    virtual void GetAssetRegistryTags(FAssetRegistryTagsContext Context) const override;
    UE_DEPRECATED(5.4, "Implement the version that takes FAssetRegistryTagsContext instead.")
    virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
    bool UsesCPUCollision() const;
    virtual bool CanBeClusterRoot() const override;
    virtual void Serialize(FArchive& Ar) override;
 
    //~ End UObject Interface.
 
    void PrecachePSOs();
 
    bool CanBePooled()const;
 
    // @todo document
    void UpdateColorModuleClampAlpha(class UParticleModuleColorBase* ColorModule);
 
    virtual bool        CalculateMaxActiveParticleCounts();
    
    ENGINE_API void GetParametersUtilized(TArray<TArray<FString> >& ParticleSysParamList,
                               TArray<TArray<FString> >& ParticleParameterList);
 
    ENGINE_API void SetupSoloing();
 
    ENGINE_API bool ToggleSoloing(class UParticleEmitter* InEmitter);
 
    ENGINE_API bool TurnOffSoloing();
 
    ENGINE_API void SetupLODValidity();
 
    ENGINE_API void SetDelay(float InDelay);
 
#if WITH_EDITOR
    ENGINE_API bool RemoveAllDuplicateModules(bool bInMarkForCooker, TMap<UObject*,bool>* OutRemovedModules);
 
    ENGINE_API void UpdateAllModuleLists();
#endif
    virtual enum ParticleSystemLODMethod GetCurrentLODMethod();
 
    virtual int32 GetLODLevelCount();
    
    virtual float GetLODDistance(int32 LODLevelIndex);
    
    virtual void SetCurrentLODMethod(ParticleSystemLODMethod InMethod);
 
    virtual bool SetLODDistance(int32 LODLevelIndex, float InDistance);
 
    bool DoesAnyEmitterHaveMotionBlur(int32 LODLevelIndex) const;
 
    ENGINE_API void BuildEmitters();
 
    inline bool CanTickInAnyThread()
    {
        if (!bIsElligibleForAsyncTickComputed)
        {
            ComputeCanTickInAnyThread();
        }
        return bIsElligibleForAsyncTick;
    }
    ENGINE_API void ComputeCanTickInAnyThread();
 
    bool HasGPUEmitter() const;
 
    UFUNCTION(BlueprintCallable, Category = "Particle System")
    bool ContainsEmitterType(UClass* TypeData);
 
    bool IsLooping() const { return bAnyEmitterLoopsForever; }
    bool IsImmortal() const { return bIsImmortal; }
    bool WillBecomeZombie() const { return bWillBecomeZombie; }
 
    EParticleSignificanceLevel GetHighestSignificance()const { return HighestSignificance; }
    EParticleSignificanceLevel GetLowestSignificance()const { return LowestSignificance; }
    bool ShouldManageSignificance()const { return bShouldManageSignificance; }
 
    inline bool AllowManagedTicking()const { return bAllowManagedTicking; }
private:
 
    EParticleSignificanceLevel HighestSignificance;
    EParticleSignificanceLevel LowestSignificance;
    
    uint8 bShouldManageSignificance : 1;
 
    uint8 bIsImmortal : 1;
    uint8 bWillBecomeZombie : 1;
};