ParticleSystemManager.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 "Engine/EngineTypes.h"
#include "Engine/EngineBaseTypes.h"
#include "Engine/World.h"
 
#include "ParticleSystemManager.generated.h"
 
class UActorComponent;
class UParticleSystemComponent;
class FParticleSystemWorldManager;
 
//Whether to use dynamic or static lists.
//Static lists are possibly cheaper but dynamic list have benefit of reduced complexity, likely easier to implement budgeted system in future and will access tick data more contiguously which may offset the cost of building them.
#define PSC_MAN_USE_STATIC_TICK_LISTS 1
 
//If we our final TG should wait for our async tasks to complete before completing itself.
//Likely required to ensure nothing overruns EOF updates.
#define PSC_MAN_TG_WAIT_FOR_ASYNC 1
 
struct FPSCTickData
{
    FPSCTickData();
        
    TObjectPtr<UActorComponent> PrereqComponent;
 
#if PSC_MAN_USE_STATIC_TICK_LISTS
    int32 TickListHandle;
#endif
 
    //Tick group 
    TEnumAsByte<ETickingGroup> TickGroup;
 
    uint8 bCanTickConcurrent : 1;
    uint8 bPendingUnregister : 1;
    uint8 bPendingReregister : 1;
};
 
USTRUCT()
struct FParticleSystemWorldManagerTickFunction : public FTickFunction
{
    GENERATED_USTRUCT_BODY()
 
    //~ FTickFunction Interface
    ENGINE_API virtual void ExecuteTick(float DeltaTime, ELevelTick TickType, ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent) override;
    ENGINE_API virtual FString DiagnosticMessage() override;
    ENGINE_API virtual FName DiagnosticContext(bool bDetailed)  override;
    //~ FTickFunction Interface
 
    FParticleSystemWorldManager* Owner;
};
 
template<>
struct TStructOpsTypeTraits<FParticleSystemWorldManagerTickFunction> : public TStructOpsTypeTraitsBase2<FParticleSystemWorldManagerTickFunction>
{
    enum
    {
        WithCopy = false
    };
};
 
//Define this so we can create inline alloc arrays of the right size but still allow runtime modification if desired.
#define INITIAL_PSC_MANAGER_ASYNC_BATCH_SIZE 8
typedef TArray<int32, TInlineAllocator<INITIAL_PSC_MANAGER_ASYNC_BATCH_SIZE>> FPSCManagerAsyncTickBatch;
 
class FParticleSystemWorldManager : public FGCObject
{
private:
    static const int32 MaxTickGroup = (int32)TG_NewlySpawned;
    static TMap<UWorld*, FParticleSystemWorldManager*> WorldManagers;
 
    static void OnWorldInit(UWorld* World, const UWorld::InitializationValues IVS);
    static void OnWorldCleanup(UWorld* World, bool bSessionEnded, bool bCleanupResources);
    static void OnPreWorldFinishDestroy(UWorld* World);
    static void OnWorldBeginTearDown(UWorld* World);
 
    typedef TFunction<void(UParticleSystemComponent*, FPSCTickData&, int32)> FPSCTickListFunction;
 
    struct FTickList
    {
        FTickList(FParticleSystemWorldManager* InOwner)
            :Owner(InOwner)
        {
        }
 
        FParticleSystemWorldManager* Owner;
 
        TArray<int32> TickList;
 
        void Add(int32 Handle);
        void Remove(int32 Handle);
        void Reset();
        inline int32 Num()const { return TickList.Num(); }
        inline int32& operator[](const int32 Index) { return TickList[Index]; }
        inline TArray<int32>& Get() { return TickList; }
    };
 
public:
    static void OnStartup();
    static void OnShutdown();
 
    inline static FParticleSystemWorldManager* Get(UWorld* World)
    {
        FParticleSystemWorldManager** Ret =  WorldManagers.Find(World);
        if (Ret)
        {
            checkSlow(*Ret);
            return *Ret;
        }
        return nullptr;
    }
 
    FParticleSystemWorldManager(UWorld* InWorld);
    virtual ~FParticleSystemWorldManager();
    void Cleanup();
 
    bool RegisterComponent(UParticleSystemComponent* PSC);
    void UnregisterComponent(UParticleSystemComponent* PSC);
 
    inline FPSCTickData& GetTickData(int32 Handle) { return PSCTickData[Handle]; }
    inline UParticleSystemComponent* GetManagedComponent(int32 Handle) { return ManagedPSCs[Handle]; }
 
    void Tick(ETickingGroup TickGroup, float DeltaTime, ELevelTick TickType, ENamedThreads::Type CurrentThread, const FGraphEventRef& MyCompletionGraphEvent);
 
    // FGCObject interface
    virtual void AddReferencedObjects(FReferenceCollector& Collector) override;
    virtual FString GetReferencerName() const override;
 
    void Dump();
 
    void SetTickGroupPriority(const int32 ParticleSystemTickGroupIndex, const bool bHighPriority);
    static void SetFirstHighPriTickGroup(int FirstHighPriTickGroupIndex);
 
protected:
    void HandlePostGarbageCollect();
 
 
private:
 
    void BuildTickLists(int32 StartIndex, ETickingGroup CurrTickGroup);
 
    template<bool bAsync>
    void ProcessTickList(float DeltaTime, ELevelTick TickType, ETickingGroup TickGroup, TArray<FTickList>& TickLists, const FGraphEventRef& TickGroupCompletionGraphEvent);
    inline void FlushAsyncTicks(const FGraphEventRef& TickGroupCompletionGraphEvent);
    inline void QueueAsyncTick(int32 Handle, const FGraphEventRef& TickGroupCompletionGraphEvent);
 
    void AddPSC(UParticleSystemComponent* PSC);
    void RemovePSC(int32 PSCIndex);
 
    void HandleManagerEnabled();
 
    void ClearPendingUnregister();
 
    UWorld* World;
 
    TArray<FParticleSystemWorldManagerTickFunction> TickFunctions;
       
    TArray<TObjectPtr<UParticleSystemComponent>> ManagedPSCs;
    TArray<FPSCTickData> PSCTickData;
    
    TArray<FTickList> TickLists_Concurrent;
 
    TArray<FTickList> TickLists_GT;
 
    TArray<TObjectPtr<UParticleSystemComponent>> PendingRegisterPSCs;
 
    int32 bCachedParticleWorldManagerEnabled;
 
    FDelegateHandle PostGarbageCollectHandle;
 
    FPSCManagerAsyncTickBatch AsyncTickBatch;
 
#if !UE_BUILD_SHIPPING
    static const UEnum* TickGroupEnum;
#endif
};
 
extern ENGINE_API int32 GbEnablePSCWorldManager;