ParticleModuleRequired.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 "RenderCommandFence.h"
#include "Particles/ParticleModule.h"
#include "Particles/ParticleSpriteEmitter.h"
#include "Particles/SubUVAnimation.h"
#include "ParticleModuleRequired.generated.h"
 
class UInterpCurveEdSetup;
class UParticleLODLevel;
struct FCurveEdEntry;
 
UENUM()
enum class EParticleUVFlipMode : uint8
{
    None,
    FlipUV,
    FlipUOnly,
    FlipVOnly,
    RandomFlipUV,
    RandomFlipUOnly,
    RandomFlipVOnly,
    RandomFlipUVIndependent,
};
 
inline void AdjustParticleBaseSizeForUVFlipping(FVector& OutSize, EParticleUVFlipMode FlipMode, FRandomStream& InRandomStream)
{
    static const float HalfRandMax = 0.5f;
 
    switch (FlipMode)
    {
        case EParticleUVFlipMode::None:
            return;
 
        case EParticleUVFlipMode::FlipUV:
            OutSize = -OutSize;
            return;
        
        case EParticleUVFlipMode::FlipUOnly:
            OutSize.X = -OutSize.X;
            return;
        
        case EParticleUVFlipMode::FlipVOnly:
            OutSize.Y = -OutSize.Y;
            return;
        
        case EParticleUVFlipMode::RandomFlipUV:
            OutSize = InRandomStream.FRand() > HalfRandMax ? -OutSize : OutSize;
            return;
 
        case EParticleUVFlipMode::RandomFlipUOnly:
            OutSize.X = InRandomStream.FRand() > HalfRandMax ? -OutSize.X : OutSize.X;
            return;
 
        case EParticleUVFlipMode::RandomFlipVOnly:
            OutSize.Y = InRandomStream.FRand() > HalfRandMax ? -OutSize.Y : OutSize.Y;
            return;
 
        case EParticleUVFlipMode::RandomFlipUVIndependent:
            OutSize.X = InRandomStream.FRand() > HalfRandMax ? -OutSize.X : OutSize.X;
            OutSize.Y = InRandomStream.FRand() > HalfRandMax ? -OutSize.Y : OutSize.Y;
            return;
 
        default:
            checkNoEntry();
            break;
    }
}
 
UENUM()
enum EParticleSortMode : int
{
    PSORTMODE_None,
    PSORTMODE_ViewProjDepth,
    PSORTMODE_DistanceToView,
    PSORTMODE_Age_OldestFirst,
    PSORTMODE_Age_NewestFirst,
    PSORTMODE_MAX,
};
 
UENUM()
enum EEmitterNormalsMode : int
{
    ENM_CameraFacing,
    ENM_Spherical,
    ENM_Cylindrical,
    ENM_MAX,
};
 
struct FParticleRequiredModule
{
    uint32 NumFrames;
    uint32 NumBoundingVertices;
    uint32 NumBoundingTriangles;
    float AlphaThreshold;
    TArray<FVector2f> FrameData;
    FRHIShaderResourceView* BoundingGeometryBufferSRV;
    uint8 bCutoutTexureIsValid : 1;
    uint8 bUseVelocityForMotionBlur : 1;
};
 
 
 
UCLASS(editinlinenew, hidecategories=(Object, Cascade), meta=(DisplayName = "Required"), MinimalAPI)
class UParticleModuleRequired : public UParticleModule
{
    GENERATED_UCLASS_BODY()
 
    //
    // General.
    // 
    
    
    UPROPERTY(EditAnywhere, Category=Emitter)
    TObjectPtr<class UMaterialInterface> Material;
 
    UPROPERTY(EditAnywhere, Category = Emitter, meta = (UIMin = "0", DisplayAfter="ScreenAlignment"))
    float MinFacingCameraBlendDistance;
 
    UPROPERTY(EditAnywhere, Category = Emitter, meta = (UIMin = "0", DisplayAfter="MinFacingCameraBlendDistance"))
    float MaxFacingCameraBlendDistance;
 
    UPROPERTY(EditAnywhere, Category=Emitter)
    FVector EmitterOrigin;
 
    UPROPERTY(EditAnywhere, Category=Emitter)
    FRotator EmitterRotation;
 
    UPROPERTY(EditAnywhere, Category=Emitter)
    TEnumAsByte<EParticleScreenAlignment> ScreenAlignment;
 
    UPROPERTY(EditAnywhere, Category=Emitter, meta = (DisplayAfter = "MaxFacingCameraBlendDistance"))
    uint8 bUseLocalSpace:1;
 
    UPROPERTY(EditAnywhere, Category=Emitter)
    uint8 bKillOnDeactivate:1;
 
    UPROPERTY(EditAnywhere, Category=Emitter)
    uint8 bKillOnCompleted:1;
 
    UPROPERTY(EditAnywhere, Category=Emitter)
    TEnumAsByte<EParticleSortMode> SortMode;
 
    UPROPERTY(EditAnywhere, Category=Emitter)
    uint8 bUseLegacyEmitterTime:1;
 
    UPROPERTY(EditAnywhere, Category=Emitter, meta=(DisplayName = "Remove HMD Roll"))
    uint8 bRemoveHMDRoll:1;
 
    UPROPERTY(EditAnywhere, Category=Emitter)
    uint8 bSupportLargeWorldCoordinates:1;
 
    UPROPERTY(EditAnywhere, Category = Duration)
    uint8 bEmitterDurationUseRange : 1;
 
 
    UPROPERTY(EditAnywhere, Category = Rendering)
    uint8 bOverrideUseVelocityForMotionBlur : 1;
 
    UPROPERTY(EditAnywhere, Category = Rendering, meta=(EditCondition = "bOverrideUseVelocityForMotionBlur"))
    uint8 bUseVelocityForMotionBlur : 1;
 
    UPROPERTY(EditAnywhere, Category=Duration, meta = (DisplayAfter="bRemoveHMDRoll"))
    float EmitterDuration;
 
    //
    // Spawn-related.
    //
    
    UPROPERTY()
    struct FRawDistributionFloat SpawnRate;
 
    UPROPERTY(export, noclear)
    TArray<FParticleBurst> BurstList;
 
    //
    // Delay-related.
    //
    
    UPROPERTY(EditAnywhere, Category=Delay)
    float EmitterDelay;
 
    UPROPERTY(EditAnywhere, Category=Delay)
    float EmitterDelayLow;
 
    UPROPERTY(EditAnywhere, Category=Delay)
    uint8 bDelayFirstLoopOnly:1;
 
    //
    // SubUV-related.
    //
    
    UPROPERTY(EditAnywhere, Category=SubUV)
    TEnumAsByte<EParticleSubUVInterpMethod> InterpolationMethod;
 
    UPROPERTY(EditAnywhere, Category = SubUV)
    uint8 bScaleUV : 1;
 
    UPROPERTY(EditAnywhere, Category=Delay)
    uint8 bEmitterDelayUseRange:1;
 
    UPROPERTY()
    TEnumAsByte<EParticleBurstMethod> ParticleBurstMethod;
 
    UPROPERTY(EditAnywhere, Category = MacroUV)
    uint8 bOverrideSystemMacroUV : 1;
 
    UPROPERTY(EditAnywhere, Category = Rendering)
    uint8 bUseMaxDrawCount : 1;
 
    UPROPERTY(EditAnywhere, Category=ParticleCutout)
    TEnumAsByte<enum EOpacitySourceMode> OpacitySourceMode;
 
    UPROPERTY(EditAnywhere, Category = Normals)
    TEnumAsByte<enum EEmitterNormalsMode> EmitterNormalsMode;
 
    UPROPERTY(EditAnywhere, Category = Emitter)
    uint8 bOrbitModuleAffectsVelocityAlignment : 1;
 
    UPROPERTY(EditAnywhere, Category=SubUV)
    int32 SubImages_Horizontal;
 
    UPROPERTY(EditAnywhere, Category=SubUV)
    int32 SubImages_Vertical;
 
    UPROPERTY()
    float RandomImageTime;
 
    UPROPERTY(EditAnywhere, Category=SubUV)
    int32 RandomImageChanges;
 
    UPROPERTY(EditAnywhere, Category=MacroUV)
    FVector MacroUVPosition;
 
    UPROPERTY(EditAnywhere, Category=MacroUV)
    float MacroUVRadius;
 
    UPROPERTY(EditAnywhere, Category = Rendering)
    EParticleUVFlipMode UVFlippingMode;
 
    UPROPERTY(EditAnywhere, Category=ParticleCutout)
    TEnumAsByte<enum ESubUVBoundingVertexCount> BoundingMode;
 
    UPROPERTY(EditAnywhere, Category = Duration)
    uint8 bDurationRecalcEachLoop : 1;
 
    UPROPERTY(EditAnywhere, Category=Normals)
    FVector NormalsSphereCenter;
 
    UPROPERTY(EditAnywhere, Category = ParticleCutout, meta = (UIMin = "0", UIMax = "1"))
    float AlphaThreshold;
 
    UPROPERTY(EditAnywhere, Category = Duration)
    int32 EmitterLoops;
 
    UPROPERTY(EditAnywhere, Category = ParticleCutout)
    TObjectPtr<UTexture2D> CutoutTexture;
 
    UPROPERTY(EditAnywhere, Category = Rendering)
    int32 MaxDrawCount;
 
    UPROPERTY(EditAnywhere, Category = Duration, meta = (DisplayAfter = "EmitterDuration"))
    float EmitterDurationLow;
 
    UPROPERTY(EditAnywhere, Category=Normals)
    FVector NormalsCylinderDirection;
 
    UPROPERTY(EditAnywhere, Category = Materials)
    TArray<FName> NamedMaterialOverrides;
 
    void InitializeDefaults();
 
    //~ Begin UObject Interface
    virtual void PostLoad() override;
    virtual void PostInitProperties() override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
#if WITH_EDITOR
    virtual void PreEditChange(FProperty* PropertyAboutToChange) override;
    virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    virtual bool IsValidForLODLevel(UParticleLODLevel* LODLevel, FString& OutErrorString) override;
#endif // WITH_EDITOR
    virtual void BeginDestroy() override;
    virtual bool IsReadyForFinishDestroy() override;
    virtual void FinishDestroy() override;
    //~ End UObject Interface
 
    //~ Begin UParticleModule Interface
    virtual void SetToSensibleDefaults(UParticleEmitter* Owner) override;
    virtual bool AddModuleCurvesToEditor(UInterpCurveEdSetup* EdSetup, TArray<const FCurveEdEntry*>& OutCurveEntries) override
    {
        // Overide the base implementation to prevent old SpawnRate from being added...
        return true;
    }
    virtual EModuleType GetModuleType() const override {    return EPMT_Required;   }
    virtual bool GenerateLODModuleValues(UParticleModule* SourceModule, float Percentage, UParticleLODLevel* LODLevel) override;
    //~ End UParticleModule Interface
 
    bool ShouldUseVelocityForMotionBlur() const;
 
    inline int32 GetNumFrames() const
    {
        return SubImages_Vertical * SubImages_Horizontal;
    }
 
    inline bool IsBoundingGeometryValid() const
    {
        return CutoutTexture != nullptr;
    }
 
    inline FRHIShaderResourceView* GetBoundingGeometrySRV() const
    {
        return BoundingGeometryBuffer->ShaderResourceView;
    }
 
    inline int32 GetNumBoundingVertices() const
    {
        return BoundingMode == BVC_FourVertices ? 4 : 8;
    }
 
    inline int32 GetNumBoundingTriangles() const
    {
        return BoundingMode == BVC_FourVertices ? 2 : 6;
    }
 
    inline const FVector2f* GetFrameData(int32 FrameIndex) const
    {
        return &DerivedData.BoundingGeometry[FrameIndex * GetNumBoundingVertices()];
    }
 
    FParticleRequiredModule *CreateRendererResource()
    {
        FParticleRequiredModule *FReqMod = new FParticleRequiredModule();
        FReqMod->bCutoutTexureIsValid = IsBoundingGeometryValid();
        FReqMod->bUseVelocityForMotionBlur = ShouldUseVelocityForMotionBlur();
        FReqMod->NumFrames = GetNumFrames();
        FReqMod->FrameData = DerivedData.BoundingGeometry;
        FReqMod->NumBoundingVertices = GetNumBoundingVertices();
        FReqMod->NumBoundingTriangles = GetNumBoundingTriangles();
        check(FReqMod->NumBoundingTriangles == 2 || FReqMod->NumBoundingTriangles == 6);
        FReqMod->AlphaThreshold = AlphaThreshold;
        FReqMod->BoundingGeometryBufferSRV = GetBoundingGeometrySRV();
        return FReqMod;
    }
 
protected:
    friend class FParticleModuleRequiredDetails;
    friend struct FParticleEmitterInstance;
 
private:
    FSubUVDerivedData DerivedData;
 
    FRenderCommandFence ReleaseFence;
 
    FSubUVBoundingGeometryBuffer* BoundingGeometryBuffer;
 
    void CacheDerivedData();
    void InitBoundingGeometryBuffer();
    void GetDefaultCutout();
};