FXSystemPrivate.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    FXSystemPrivate.h: Internal effects system interface.
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "FXSystem.h"
#include "VectorField.h"
#include "ParticleSortingGPU.h"
#include "GPUSortManager.h"
#include "ParticleVertexFactory.h"
 
class FCanvas;
class FGlobalDistanceFieldParameterData;
class FParticleSimulationGPU;
class FParticleSimulationResources;
class FViewUniformShaderParameters;
class IParticleEmitterInstanceOwner;
class UParticleSystemComponent;
class UVectorFieldComponent;
struct FGPUSpriteEmitterInfo;
struct FParticleEmitterInstance;
 
/*-----------------------------------------------------------------------------
    Forward declarations.
-----------------------------------------------------------------------------*/
 
class FParticleSimulationGPU;
class FParticleSimulationResources;
 
namespace EParticleSimulatePhase
{
    enum Type
    {
        Main,
        CollisionDistanceField,
        CollisionDepthBuffer,
 
        /**********************************************************************/
 
        First = Main,
        Last = CollisionDepthBuffer
    };
};
 
enum EParticleCollisionShaderMode
{
    PCM_None,
    PCM_DepthBuffer,
    PCM_DistanceField
};
 
extern bool IsParticleCollisionModeSupported(EShaderPlatform InPlatform, EParticleCollisionShaderMode InCollisionShaderMode);
 
inline EParticleSimulatePhase::Type GetLastParticleSimulationPhase(EShaderPlatform InPlatform)
{
    return (IsParticleCollisionModeSupported(InPlatform, PCM_DepthBuffer) ? EParticleSimulatePhase::Last : EParticleSimulatePhase::Main);
}
 
/*-----------------------------------------------------------------------------
Injecting particles in to the GPU for simulation.
-----------------------------------------------------------------------------*/
 
struct FNewParticle
{
    FVector3f Position;
    float RelativeTime;
    FVector3f Velocity;
    float TimeScale;
    FVector2f Size;
    float Rotation;
    float RelativeRotationRate;
    float DragCoefficient;
    float VectorFieldScale;
    union
    {
        float Resilience;
        int32 AllocatedTileIndex;
    } ResilienceAndTileIndex;
    float RandomOrbit;
    FVector3f Offset;
};
 
 
class FGPUSpriteVertexFactory : public FParticleVertexFactoryBase
{
    DECLARE_VERTEX_FACTORY_TYPE(FGPUSpriteVertexFactory);
 
public:
    FGPUSpriteVertexFactory(ERHIFeatureLevel::Type InFeatureLevel)
        : FParticleVertexFactoryBase(InFeatureLevel)
    {
    }
 
    FRHIUniformBuffer* EmitterUniformBuffer;
    FUniformBufferRHIRef EmitterDynamicUniformBuffer;
    FRHIShaderResourceView* UnsortedParticleIndicesSRV;
    FRHITexture* PositionTextureRHI;
    FRHITexture* VelocityTextureRHI;
    FRHITexture* AttributesTextureRHI;
    FVector3f LWCTile;
    FVector3f TilePageScale;
 
    FGPUSpriteVertexFactory()
        : FParticleVertexFactoryBase(PVFT_MAX, ERHIFeatureLevel::Num)
        , UnsortedParticleIndicesSRV(0)
        , PositionTextureRHI(nullptr)
        , VelocityTextureRHI(nullptr)
        , AttributesTextureRHI(nullptr)
        , LWCTile(FVector3f::ZeroVector)
        , TilePageScale(FVector3f::OneVector)
    {}
 
    virtual void InitRHI(FRHICommandListBase& RHICmdList) override;
    virtual bool RendersPrimitivesAsCameraFacingSprites() const override { return true; }
 
    void SetUnsortedParticleIndicesSRV(FRHIShaderResourceView* VertexBuffer)
    {
        UnsortedParticleIndicesSRV = VertexBuffer;
    }
 
    static bool ShouldCompilePermutation(const FVertexFactoryShaderPermutationParameters& Parameters);
 
    static void ModifyCompilationEnvironment(const FVertexFactoryShaderPermutationParameters& Parameters, FShaderCompilerEnvironment& OutEnvironment);
 
    static void GetPSOPrecacheVertexFetchElements(EVertexInputStreamType VertexInputStreamType, FVertexDeclarationElementList& Elements);
};
 
/*-----------------------------------------------------------------------------
    FX system declaration.
-----------------------------------------------------------------------------*/
 
class FFXSystem : public FFXSystemInterface
{
public:
 
    FFXSystem(ERHIFeatureLevel::Type InFeatureLevel, EShaderPlatform InShaderPlatform, FGPUSortManager* InGPUSortManager);
 
    virtual ~FFXSystem();
 
    static const FName Name;
    virtual FFXSystemInterface* GetInterface(const FName& InName) override;
 
    // Begin FFXSystemInterface.
    virtual void Tick(UWorld* World, float DeltaSeconds) override;
    virtual void OnMarkPendingKill() override;
#if WITH_EDITOR
    virtual void Suspend() override;
    virtual void Resume() override;
#endif // #if WITH_EDITOR
    virtual void DrawDebug(FCanvas* Canvas) override;
    virtual void AddVectorField(UVectorFieldComponent* VectorFieldComponent) override;
    virtual void RemoveVectorField(UVectorFieldComponent* VectorFieldComponent) override;
    virtual void UpdateVectorField(UVectorFieldComponent* VectorFieldComponent) override;
    FParticleEmitterInstance* CreateGPUSpriteEmitterInstance(IParticleEmitterInstanceOwner& InComponent, FGPUSpriteEmitterInfo& EmitterInfo);
    virtual void PreInitViews(class FRDGBuilder& GraphBuilder, bool bAllowGPUParticleUpdate, const TArrayView<const FSceneViewFamily*>& ViewFamilies, const FSceneViewFamily* CurrentFamily) override;
    virtual void PostInitViews(FRDGBuilder& GraphBuilder, TConstStridedView<FSceneView> Views, bool bAllowGPUParticleUpdate) override;
    virtual bool UsesGlobalDistanceField() const override;
    virtual bool UsesDepthBuffer() const override;
    virtual bool RequiresEarlyViewUniformBuffer() const override;
    virtual bool RequiresRayTracingScene() const override;
    virtual void PreRender(FRDGBuilder& GraphBuilder, TConstStridedView<FSceneView> Views, FSceneUniformBuffer &SceneUniformBuffer, bool bAllowGPUParticleUpdate) override;
    virtual void PostRenderOpaque(FRDGBuilder& GraphBuilder, TConstStridedView<FSceneView> Views, FSceneUniformBuffer &SceneUniformBuffer, bool bAllowGPUParticleUpdate) override;
    // End FFXSystemInterface.
 
    /*--------------------------------------------------------------------------
        Internal interface for GPU simulation.
    --------------------------------------------------------------------------*/
    ERHIFeatureLevel::Type GetFeatureLevel() const { return FeatureLevel; }
 
    EShaderPlatform GetShaderPlatform() const { return GShaderPlatformForFeatureLevel[FeatureLevel]; }
 
    void AddGPUSimulation(FParticleSimulationGPU* Simulation);
 
    void RemoveGPUSimulation(FParticleSimulationGPU* Simulation);
 
    void OnSimulationPhaseChanged(const FParticleSimulationGPU* Simulation, EParticleSimulatePhase::Type PrevPhase);
 
    FParticleSimulationResources* GetParticleSimulationResources()
    {
        return ParticleSimulationResources;
    }
 
    bool AddSortedGPUSimulation(FRHICommandListBase& RHICmdList, FParticleSimulationGPU* Simulation, const FVector& ViewOrigin, bool bIsTranslucent, FGPUSortManager::FAllocationInfo& OutInfo);
 
    void PrepareGPUSimulation(FRHICommandListImmediate& RHICmdList);
    void FinalizeGPUSimulation(FRHICommandListImmediate& RHICmdList);
 
    virtual FGPUSortManager* GetGPUSortManager() const override;
 
    virtual void SetSceneTexturesUniformBuffer(const TUniformBufferRef<FSceneTextureUniformParameters>& InSceneTexturesUniformParams) override { SceneTexturesUniformParams = InSceneTexturesUniformParams; }
 
private:
 
    void GenerateSortKeys(FRHICommandListImmediate& RHICmdList, int32 BatchId, int32 NumElementsInBatch, EGPUSortFlags Flags, FRHIUnorderedAccessView* KeysUAV, FRHIUnorderedAccessView* ValuesUAV);
 
    /*--------------------------------------------------------------------------
        Private interface for GPU simulations.
    --------------------------------------------------------------------------*/
 
    void InitGPUSimulation();
 
    virtual void DestroyGPUSimulation();
 
    void InitGPUResources();
 
    void ReleaseGPUResources();
 
    void AdvanceGPUParticleFrame(FRHICommandListImmediate& RHICmdList, bool bAllowGPUParticleUpdate);
 
    bool UsesGlobalDistanceFieldInternal() const;
    bool UsesDepthBufferInternal() const;
    bool RequiresEarlyViewUniformBufferInternal() const;
    bool RequiresRayTracingSceneInternal() const;
 
    void UpdateMultiGPUResources(FRHICommandListImmediate& RHICmdList);
 
    void SimulateGPUParticles(
        FRHICommandListImmediate& RHICmdList,
        EParticleSimulatePhase::Type Phase,
        const TUniformBufferRef<FViewUniformShaderParameters>& ViewUniformBuffer,
        const FGlobalDistanceFieldParameterData* GlobalDistanceFieldParameterData
        );
 
    void VisualizeGPUParticles(FCanvas* Canvas);
 
private:
 
    template<typename TVectorFieldUniformParametersType>
    void SimulateGPUParticles_Internal(
        FRHICommandListImmediate& RHICmdList,
        EParticleSimulatePhase::Type Phase,
        const TUniformBufferRef<FViewUniformShaderParameters>& ViewUniformBuffer,
        const FGlobalDistanceFieldParameterData* GlobalDistanceFieldParameterData,
        FRHITexture* SceneDepthTexture,
        FRHITexture* GBufferATexture
    );
 
    /*-------------------------------------------------------------------------
        GPU simulation state.
    -------------------------------------------------------------------------*/
 
    FVectorFieldInstanceList VectorFields;
    TSparseArray<FParticleSimulationGPU*> GPUSimulations;
    int32 NumGPUSimulations[EParticleSimulatePhase::Last + 1] = {};
    FParticleSimulationResources* ParticleSimulationResources;
    ERHIFeatureLevel::Type FeatureLevel;
 
    TRefCountPtr<FGPUSortManager> GPUSortManager;
    TArray<FParticleSimulationSortInfo> SimulationsToSort;
 
    TArray<FNewParticle> LastFrameNewParticles;
 
    UE::FMutex AddSortedGPUSimulationMutex;
 
#if WITH_EDITOR
    bool bSuspended;
#endif // #if WITH_EDITOR
 
#if WITH_MGPU
    EParticleSimulatePhase::Type PhaseToWaitForResourceTransfer = EParticleSimulatePhase::First;
    EParticleSimulatePhase::Type PhaseToBroadcastResourceTransfer = EParticleSimulatePhase::First;
#endif
 
    TUniformBufferRef<FSceneTextureUniformParameters> SceneTexturesUniformParams;
};