WorldPSCPool.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 "WorldPSCPool.generated.h"
 
class UParticleSystemComponent;
class UParticleSystem;
 
#define ENABLE_PSC_POOL_DEBUGGING (!UE_BUILD_SHIPPING)
 
UENUM()
enum class EPSCPoolMethod : uint8
{
    None,
 
    AutoRelease,
 
    ManualRelease,
 
 
    ManualRelease_OnComplete UMETA(Hidden),
 
    FreeInPool UMETA(Hidden),
};
 
USTRUCT()
struct FPSCPoolElem
{
    GENERATED_BODY()
 
    UPROPERTY(transient)
    TObjectPtr<UParticleSystemComponent> PSC;
 
    float LastUsedTime;
 
    FPSCPoolElem()
        : PSC(nullptr), LastUsedTime(0.0f)
    {
 
    }
    FPSCPoolElem(UParticleSystemComponent* InPSC, float InLastUsedTime)
        : PSC(InPSC), LastUsedTime(InLastUsedTime)
    {
 
    }
};
 
 
USTRUCT()
struct FPSCPool
{
    GENERATED_BODY()
 
    //Collection of all currently allocated, free items ready to be grabbed for use.
    //TODO: Change this to a FIFO queue to get better usage. May need to make this whole class behave similar to TCircularQueue.
    UPROPERTY(transient)
    TArray<FPSCPoolElem> FreeElements;
 
#if ENABLE_PSC_POOL_DEBUGGING
    //Array of currently in flight components that will auto release.
    TArray<TWeakObjectPtr<UParticleSystemComponent>> InUseComponents_Auto;
 
    //Array of currently in flight components that need manual release.
    TArray<TWeakObjectPtr<UParticleSystemComponent>> InUseComponents_Manual;
    
    int32 MaxUsed = 0;
#endif
 
public:
 
    void Cleanup();
 
    UParticleSystemComponent* Acquire(UWorld* World, UParticleSystem* Template, EPSCPoolMethod PoolingMethod);
    void Reclaim(UParticleSystemComponent* PSC, const float CurrentTimeSeconds);
 
    void KillUnusedComponents(float KillTime, UParticleSystem* Template);
 
    int32 NumComponents() { return FreeElements.Num(); }
};
 
USTRUCT()
struct FWorldPSCPool
{
    GENERATED_BODY()
 
private:
    UPROPERTY()
    TMap<TObjectPtr<UParticleSystem>, FPSCPool> WorldParticleSystemPools;
 
    float LastParticleSytemPoolCleanTime;
 
    float CachedWorldTime;
public:
 
    ENGINE_API FWorldPSCPool();
    ENGINE_API ~FWorldPSCPool();
 
    ENGINE_API void Cleanup(UWorld* World);
 
    ENGINE_API UParticleSystemComponent* CreateWorldParticleSystem(UParticleSystem* Template, UWorld* World, EPSCPoolMethod PoolingMethod);
 
    ENGINE_API void ReclaimWorldParticleSystem(UParticleSystemComponent* PSC);
 
    ENGINE_API void Dump();
};