ParticleModule.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 "ParticleHelper.h"
#include "ParticleModule.generated.h"
 
class UDistribution;
class UDistributionFloat;
class UDistributionVector;
class UInterpCurveEdSetup;
class UParticleEmitter;
class UParticleLODLevel;
class UParticleModuleTypeDataBase;
class UParticleSystemComponent;
struct FCurveEdEntry;
struct FParticleEmitterInstance;
 
UENUM()
enum EModuleType : int
{
    EPMT_General UMETA(DisplayName="General"),
    EPMT_TypeData UMETA(DisplayName="Type Data"),
    EPMT_Beam UMETA(DisplayName="Beam"),
    EPMT_Trail UMETA(DisplayName="Trail"),
    EPMT_Spawn UMETA(DisplayName="Spawn"),
    EPMT_Required UMETA(DisplayName="Required"),
    EPMT_Event UMETA(DisplayName="Event"),
    EPMT_Light UMETA(DisplayName="Light"),
    EPMT_SubUV UMETA(DisplayName = "SubUV"),
    EPMT_MAX,
};
 
UENUM()
enum EParticleSourceSelectionMethod : int
{
    EPSSM_Random UMETA(DisplayName="Random"),
    EPSSM_Sequential UMETA(DisplayName="Sequential"),
    EPSSM_MAX,
};
 
USTRUCT()
struct FParticleCurvePair
{
    GENERATED_USTRUCT_BODY()
 
    UPROPERTY()
    FString CurveName;
 
    UPROPERTY()
    TObjectPtr<class UObject> CurveObject;
 
 
    FParticleCurvePair()
        : CurveObject(NULL)
    {
    }
 
};
 
USTRUCT()
struct FParticleRandomSeedInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, Category=ParticleRandomSeedInfo)
    FName ParameterName;
 
    UPROPERTY(EditAnywhere, Category=ParticleRandomSeedInfo)
    uint8 bGetSeedFromInstance:1;
 
    UPROPERTY(EditAnywhere, Category=ParticleRandomSeedInfo)
    uint8 bInstanceSeedIsIndex:1;
 
    UPROPERTY(EditAnywhere, Category=ParticleRandomSeedInfo)
    uint8 bResetSeedOnEmitterLooping:1;
 
    UPROPERTY(EditAnywhere, Category = ParticleRandomSeedInfo)
    uint8 bRandomlySelectSeedArray:1;
 
    UPROPERTY(EditAnywhere, Category=ParticleRandomSeedInfo)
    TArray<int32> RandomSeeds;
 
 
 
        FParticleRandomSeedInfo()
        : bGetSeedFromInstance(false)
        , bInstanceSeedIsIndex(false)
        , bResetSeedOnEmitterLooping(true)
        , bRandomlySelectSeedArray(false)
        {
        }
        inline int32 GetInstancePayloadSize() const
        {
            return ((RandomSeeds.Num() > 0) ? sizeof(FParticleRandomSeedInstancePayload) : 0);
        }
    
};
 
UCLASS(editinlinenew, hidecategories=Object, abstract, Within=ParticleSystem, MinimalAPI)
class UParticleModule : public UObject
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY()
    uint8 bSpawnModule:1;
 
    UPROPERTY()
    uint8 bUpdateModule:1;
 
    UPROPERTY()
    uint8 bFinalUpdateModule:1;
 
    UPROPERTY()
    uint8 bUpdateForGPUEmitter:1;
 
    UPROPERTY()
    uint8 bCurvesAsColor:1;
 
    UPROPERTY(EditAnywhere, Category=Cascade)
    uint8 b3DDrawMode:1;
 
    UPROPERTY()
    uint8 bSupported3DDrawMode:1;
 
    UPROPERTY()
    uint8 bEnabled:1;
 
    UPROPERTY()
    uint8 bEditable:1;
 
    UPROPERTY()
    uint8 LODDuplicate:1;
 
    UPROPERTY()
    uint8 bSupportsRandomSeed:1;
 
    UPROPERTY()
    uint8 bRequiresLoopingNotification:1;
 
    UPROPERTY()
    uint8 LODValidity;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category=Cascade)
    FColor ModuleEditorColor;
 
#endif // WITH_EDITORONLY_DATA
 
    //~ Begin UObject Interface
    ENGINE_API virtual bool IsPostLoadThreadSafe() const override;
#if WITH_EDITOR
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif // WITH_EDITOR   
    //~ End UObject Interface
 
    ENGINE_API virtual void CompileModule( struct FParticleEmitterBuildInfo& EmitterInfo );
 
    struct FContext
    {
        FParticleEmitterInstance& Owner;
        const FTransform& GetTransform() const;
        UObject* GetDistributionData() const;
        FString GetTemplateName() const;
        FString GetInstanceName() const;
        FContext(FParticleEmitterInstance& Ow) : Owner(Ow) {}
    };
 
    struct FSpawnContext : FContext
    {
        int32 Offset;
        float SpawnTime;
        FBaseParticle* ParticleBase;
        FSpawnContext(FParticleEmitterInstance& Ow, int32 Of, float St, FBaseParticle* Pb) : FContext(Ow), Offset(Of), SpawnTime(St), ParticleBase(Pb) {}
    };
    ENGINE_API virtual void Spawn(const FSpawnContext& Context);
 
    struct FUpdateContext : FContext
    {
        int32 Offset;
        float DeltaTime;
        FUpdateContext(FParticleEmitterInstance& Ow, int32 Of, float Dt) : FContext(Ow), Offset(Of), DeltaTime(Dt) {}
    };
    ENGINE_API virtual void Update(const FUpdateContext& Context);
    ENGINE_API virtual void FinalUpdate(const FUpdateContext& Context);
 
    ENGINE_API virtual uint32   RequiredBytes(UParticleModuleTypeDataBase* TypeData);
    ENGINE_API virtual uint32   RequiredBytesPerInstance();
 
    ENGINE_API virtual uint32   PrepPerInstanceBlock(FParticleEmitterInstance* Owner, void* InstData);
 
    // For Cascade
    ENGINE_API virtual void SetToSensibleDefaults(UParticleEmitter* Owner);
    
    ENGINE_API virtual void GetCurveObjects(TArray<FParticleCurvePair>& OutCurves);
    ENGINE_API virtual  bool    AddModuleCurvesToEditor(UInterpCurveEdSetup* EdSetup, TArray<const FCurveEdEntry*>& OutCurveEntries);
    ENGINE_API void RemoveModuleCurvesFromEditor(UInterpCurveEdSetup* EdSetup);
    ENGINE_API bool ModuleHasCurves();
    ENGINE_API bool IsDisplayedInCurveEd(UInterpCurveEdSetup* EdSetup);
    ENGINE_API void     ChangeEditorColor(FColor& Color, UInterpCurveEdSetup* EdSetup);
 
    struct FPreviewContext : FContext
    {
        const FSceneView* View;
        FPrimitiveDrawInterface* PDI;
        FPreviewContext(FParticleEmitterInstance& Ow, const FSceneView* Vi, FPrimitiveDrawInterface* Pd) : FContext(Ow), View(Vi), PDI(Pd) {}
    };
    virtual void Render3DPreview(const FPreviewContext& Context) {}
 
    virtual EModuleType GetModuleType() const   {   return EPMT_General;    }
 
    ENGINE_API virtual void AutoPopulateInstanceProperties(UParticleSystemComponent* PSysComp);
    
    ENGINE_API virtual bool GenerateLODModuleValues(UParticleModule* SourceModule, float Percentage, UParticleLODLevel* LODLevel);
 
    ENGINE_API virtual bool ConvertFloatDistribution(UDistributionFloat* FloatDist, UDistributionFloat* SourceFloatDist, float Percentage);
    ENGINE_API virtual bool ConvertVectorDistribution(UDistributionVector* VectorDist, UDistributionVector* SourceVectorDist, float Percentage);
    virtual bool   IsSizeMultiplyLife() { return false; };
 
    bool SupportsRandomSeed() const
    {
        return bSupportsRandomSeed;
    }
 
    bool RequiresLoopingNotification() const
    {
        return bRequiresLoopingNotification;
    }
 
    virtual void EmitterLoopingNotify(FParticleEmitterInstance* Owner)
    {
    }
 
    ENGINE_API virtual UParticleModule* GenerateLODModule(UParticleLODLevel* SourceLODLevel, UParticleLODLevel* DestLODLevel, float Percentage, 
        bool bGenerateModuleData, bool bForceModuleConstruction = false);
 
    virtual bool WillGeneratedModuleBeIdentical(UParticleLODLevel* SourceLODLevel, UParticleLODLevel* DestLODLevel, float Percentage)
    {
        // The assumption is that at 100%, ANY module will be identical...
        // (Although this is virtual to allow over-riding that assumption on a case-by-case basis!)
 
        if (Percentage != 100.0f)
        {
            return LODDuplicate;
        }
 
        return true;
    }
 
    ENGINE_API virtual bool IsUsedInLODLevel(int32 SourceLODIndex) const;
 
    ENGINE_API virtual void GetParticleSysParamsUtilized(TArray<FString>& ParticleSysParamList);
 
    ENGINE_API virtual void GetParticleParametersUtilized(TArray<FString>& ParticleParameterList);
    
    virtual void RefreshModule(UInterpCurveEdSetup* EdSetup, UParticleEmitter* InEmitter, int32 InLODLevel) {}
 
    virtual bool    TouchesMeshRotation() const { return false; }
 
    ENGINE_API virtual uint32   PrepRandomSeedInstancePayload(FParticleEmitterInstance* Owner, FParticleRandomSeedInstancePayload* InRandSeedPayload, const FParticleRandomSeedInfo& InRandSeedInfo);
 
    virtual FParticleRandomSeedInfo* GetRandomSeedInfo()
    {
        return NULL;
    }
 
    ENGINE_API virtual bool SetRandomSeedEntry(int32 InIndex, int32 InRandomSeed);
 
    virtual bool CanTickInAnyThread()
    {
        return true;
    }
 
    ENGINE_API bool IsUsedInGPUEmitter()const;
 
    ENGINE_API FRandomStream& GetRandomStream(const FContext& Context);
 
#if WITH_EDITOR
    ENGINE_API virtual void PostLoadSubobjects( FObjectInstancingGraph* OuterInstanceGraph ) override;
 
    virtual int32 GetNumberOfCustomMenuOptions() const { return 0; }
 
    virtual bool GetCustomMenuEntryDisplayString(int32 InEntryIndex, FString& OutDisplayString) const { return false; }
 
    virtual bool PerformCustomMenuEntry(int32 InEntryIndex) { return false; }
 
    virtual bool IsValidForLODLevel(UParticleLODLevel* LODLevel, FString& OutErrorString)
    {
        return true;
    }
 
    static ENGINE_API  void GetDistributionsRestrictedOnGPU(TArray<FString>& OutRestrictedDistributions);
        
    static ENGINE_API bool IsDistributionAllowedOnGPU(const UDistribution* Distribution);
    
    static ENGINE_API FText GetDistributionNotAllowedOnGPUText(const FString& ModuleName, const FString& PropertyName);
 
    ENGINE_API void SetTransactionFlag();
#endif
};