ParticleEmitter.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
//~=============================================================================
// ParticleEmitter
// The base class for any particle emitter objects.
//~=============================================================================
 
#pragma once
 
#include "CoreMinimal.h"
#include "Stats/Stats.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "ParticleEmitterInstances.h"
#include "ParticleEmitter.generated.h"
 
class IParticleEmitterInstanceOwner;
class UInterpCurveEdSetup;
class UParticleLODLevel;
class UParticleSystemComponent;
 
enum EDetailMode : int;
 
//~=============================================================================
//  Burst emissions
//~=============================================================================
UENUM()
enum EParticleBurstMethod : int
{
    EPBM_Instant UMETA(DisplayName="Instant"),
    EPBM_Interpolated UMETA(DisplayName="Interpolated"),
    EPBM_MAX,
};
 
//~=============================================================================
//  SubUV-related
//~=============================================================================
UENUM()
enum EParticleSubUVInterpMethod : int
{
    PSUVIM_None UMETA(DisplayName="None"),
    PSUVIM_Linear UMETA(DisplayName="Linear"),
    PSUVIM_Linear_Blend UMETA(DisplayName="Linear Blend"),
    PSUVIM_Random UMETA(DisplayName="Random"),
    PSUVIM_Random_Blend UMETA(DisplayName="Random Blend"),
    PSUVIM_MAX,
};
 
//~=============================================================================
//  Cascade-related
//~=============================================================================
UENUM()
enum EEmitterRenderMode : int
{
    ERM_Normal UMETA(DisplayName="Normal"),
    ERM_Point UMETA(DisplayName="Point"),
    ERM_Cross UMETA(DisplayName="Cross"),
    ERM_LightsOnly UMETA(DisplayName = "Lights Only"),
    ERM_None UMETA(DisplayName = "None"),
    ERM_MAX,
};
 
USTRUCT()
struct FParticleBurst
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=ParticleBurst)
    int32 Count;
 
    UPROPERTY(EditAnywhere, Category=ParticleBurst)
    int32 CountLow;
 
    UPROPERTY(EditAnywhere, Category=ParticleBurst)
    float Time;
 
 
 
        FParticleBurst()
        : Count(0)
        , CountLow(-1)      // Disabled by default...
        , Time(0.0f)
        {
        }
    
};
 
DECLARE_STATS_GROUP(TEXT("Emitters"), STATGROUP_Emitters, STATCAT_Advanced);
DECLARE_STATS_GROUP(TEXT("Emitters"), STATGROUP_EmittersRT, STATCAT_Advanced);
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("STAT_EmittersStatGroupTester"), STAT_EmittersStatGroupTester, STATGROUP_Emitters, ENGINE_API);
DECLARE_DWORD_COUNTER_STAT_EXTERN(TEXT("STAT_EmittersRTStatGroupTester"), STAT_EmittersRTStatGroupTester, STATGROUP_EmittersRT, ENGINE_API);
 
UCLASS(hidecategories=Object, editinlinenew, abstract, MinimalAPI)
class UParticleEmitter : public UObject
{
    GENERATED_UCLASS_BODY()
 
    //~=============================================================================
    //  General variables
    //~=============================================================================
    UPROPERTY(EditAnywhere, Category=Particle)
    FName EmitterName;
 
    UPROPERTY(transient)
    int32 SubUVDataOffset;
 
    UPROPERTY(EditAnywhere, Category=Cascade)
    TEnumAsByte<enum EEmitterRenderMode> EmitterRenderMode;
 
    UPROPERTY(EditAnywhere, Category = Significance)
    EParticleSignificanceLevel SignificanceLevel;
 
    TEnumAsByte<EParticleAxisLock> LockAxisFlags;
 
    UPROPERTY(EditAnywhere, Category = Particle, AdvancedDisplay)
    uint8 bUseLegacySpawningBehavior : 1;
 
    // Below is information udpated by calling CacheEmitterModuleInfo
 
    uint8 bRequiresLoopNotification : 1;
    uint8 bAxisLockEnabled : 1;
    uint8 bMeshRotationActive : 1;
 
    UPROPERTY()
    uint8 ConvertedModules:1;
 
    UPROPERTY(transient)
    uint8 bIsSoloing:1;
 
    UPROPERTY()
    uint8 bCookedOut:1;
 
    UPROPERTY(EditAnywhere, Category = Particle)
    uint8 bDisabledLODsKeepEmitterAlive : 1;
    
    UPROPERTY(EditAnywhere, Category = Significance)
    uint8 bDisableWhenInsignficant : 1;
 
    uint8 bRemoveHMDRollInVR : 1;
 
#if WITH_EDITORONLY_DATA
 
    UPROPERTY(EditAnywhere, Category=Cascade)
    uint8 bCollapsed:1;
 
    UPROPERTY(EditAnywhere, Category=Cascade)
    FColor EmitterEditorColor;
 
#endif // WITH_EDITORONLY_DATA
    //~=============================================================================
    //  'Private' data - not required by the editor
    //~=============================================================================
    UPROPERTY(instanced)
    TArray<TObjectPtr<class UParticleLODLevel>> LODLevels;
 
    UPROPERTY()
    int32 PeakActiveParticles;
 
    //~=============================================================================
    //  Performance/LOD Data
    //~=============================================================================
    
    UPROPERTY(EditAnywhere, Category=Particle)
    int32 InitialAllocationCount;
 
    UPROPERTY(EditAnywhere, Category = Particle)
    float QualityLevelSpawnRateScale;
 
    UPROPERTY(EditAnywhere, Category = Particle, meta = (Bitmask, BitmaskEnum = "/Script/Engine.EParticleDetailMode"))
    uint32 DetailModeBitmask;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(Transient, VisibleAnywhere, Category = Particle, DisplayName="Current Detailmodes")
    FString DetailModeDisplay;
#endif // WITH_EDITORONLY_DATA
 
    TMap<UParticleModule*, uint32> ModuleOffsetMap;
 
    TMap<UParticleModule*, uint32> ModuleInstanceOffsetMap;
 
    TMap<UParticleModule*, uint32> ModuleRandomSeedInstanceOffsetMap;
    
    TArray<class UMaterialInterface*> MeshMaterials;
 
    int32 DynamicParameterDataOffset;
    int32 LightDataOffset;
    float LightVolumetricScatteringIntensity;
    int32 CameraPayloadOffset;
    int32 ParticleSize;
    int32 ReqInstanceBytes;
    FVector2D PivotOffset;
    int32 TypeDataOffset;
    int32 TypeDataInstanceOffset;
 
    float MinFacingCameraBlendDistance;
    float MaxFacingCameraBlendDistance;
 
    // Array of modules that want emitter instance data
    TArray<UParticleModule*> ModulesNeedingInstanceData;
 
    // Array of modules that want emitter random seed instance data
    TArray<UParticleModule*> ModulesNeedingRandomSeedInstanceData;
 
    class USubUVAnimation* RESTRICT SubUVAnimation;
 
 
    //~ Begin UObject Interface
#if WITH_EDITOR
    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
 
#endif
 
#if WITH_EDITORONLY_DATA
    // Update the at-a-glance display for detail mode
    void UpdateDetailModeDisplayString()
    {
        DetailModeDisplay = "";
        DetailModeDisplay += DetailModeBitmask & (1 << EParticleDetailMode::PDM_Low) ? "Low, " : "";
        DetailModeDisplay += DetailModeBitmask & (1 << EParticleDetailMode::PDM_Medium) ? "Medium, " : "";
        DetailModeDisplay += DetailModeBitmask & (1 << EParticleDetailMode::PDM_High) ? "High, " : "";
        DetailModeDisplay += DetailModeBitmask & (1 << EParticleDetailMode::PDM_Epic) ? "Epic" : "";
    }
#endif // WITH_EDITORONLY_DATA
    virtual void Serialize(FArchive& Ar)override;
    virtual void PostLoad() override;
    virtual bool IsPostLoadThreadSafe() const override;
    //~ End UObject Interface
 
    // @todo document
    virtual FParticleEmitterInstance* CreateInstance(IParticleEmitterInstanceOwner& InComponent);
 
    // Sets up this emitter with sensible defaults so we can see some particles as soon as its created.
    virtual void SetToSensibleDefaults() {}
 
    // @todo document
    virtual void UpdateModuleLists();
 
    // @todo document
    ENGINE_API void SetEmitterName(FName Name);
 
    // @todo document
    ENGINE_API FName& GetEmitterName();
 
    // @todo document
    virtual void                        SetLODCount(int32 LODCount);
 
    // For Cascade
    // @todo document
    void    AddEmitterCurvesToEditor(UInterpCurveEdSetup* EdSetup);
 
    // @todo document
    ENGINE_API void RemoveEmitterCurvesFromEditor(UInterpCurveEdSetup* EdSetup);
 
    // @todo document
    ENGINE_API void ChangeEditorColor(FColor& Color, UInterpCurveEdSetup* EdSetup);
 
    // @todo document
    ENGINE_API void AutoPopulateInstanceProperties(UParticleSystemComponent* PSysComp);
 
    ENGINE_API int32        CreateLODLevel(int32 LODLevel, bool bGenerateModuleData = true);
 
    ENGINE_API bool IsLODLevelValid(int32 LODLevel);
 
    ENGINE_API UParticleLODLevel* GetCurrentLODLevel(FParticleEmitterInstance* Instance);
 
    ENGINE_API void EditorUpdateCurrentLOD(FParticleEmitterInstance* Instance);
 
    ENGINE_API UParticleLODLevel*   GetLODLevel(int32 LODLevel);
    
    virtual bool        AutogenerateLowestLODLevel(bool bDuplicateHighest = false);
    
    virtual bool        CalculateMaxActiveParticleCount();
 
    void GetParametersUtilized(TArray<FString>& ParticleSysParamList,
                               TArray<FString>& ParticleParameterList);
 
    void Build();
 
    void CacheEmitterModuleInfo();
 
    float GetQualityLevelSpawnRateMult();
 
    ENGINE_API bool HasAnyEnabledLODs() const;
 
    STAT(mutable TStatId StatID;)
    STAT(mutable TStatId StatIDRT;)
        
    inline TStatId GetStatID(bool bForDeferredUse = false) const
    {
#if STATS
        // this is done to avoid even registering stats for a disabled group (unless we plan on using it later)
        if (bForDeferredUse || FThreadStats::IsCollectingData(GET_STATID(STAT_EmittersStatGroupTester)))
        {
            if (!StatID.IsValidStat())
            {
                CreateStatID();
            }
            return StatID;
        }
#endif
        return TStatId(); // not doing stats at the moment, or ever
    }
 
    inline TStatId GetStatIDRT(bool bForDeferredUse = false) const
    {
#if STATS
        // this is done to avoid even registering stats for a disabled group (unless we plan on using it later)
        if (bForDeferredUse || FThreadStats::IsCollectingData(GET_STATID(STAT_EmittersRTStatGroupTester)))
        {
            if (!StatIDRT.IsValidStat())
            {
                CreateStatID();
            }
            return StatIDRT;
        }
#endif
        return TStatId(); // not doing stats at the moment, or ever
    }
#if STATS
    void CreateStatID() const;
#endif
 
    ENGINE_API bool IsSignificant(EParticleSignificanceLevel RequiredSignificance);
};