LatentActionManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/ObjectMacros.h"
#include "UObject/WeakObjectPtr.h"
#include "LatentActionManager.generated.h"
 
class FPendingLatentAction;
 
namespace LatentActionCVars
{
    extern int32 GuaranteeEngineTickDelay;  // 0: next-tick delays may run at end of current frame (default behavior pre-5.5),  1: next-tick delays will always wait until the engine frame has advanced
}
 
// Latent action info
USTRUCT(BlueprintInternalUseOnly)
struct FLatentActionInfo
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(meta=(NeedsLatentFixup = true))
    int32 Linkage;
 
    UPROPERTY()
    int32 UUID;
 
    UPROPERTY()
    FName ExecutionFunction;
 
    UPROPERTY(meta=(LatentCallbackTarget = true))
    TObjectPtr<UObject> CallbackTarget;
 
    FLatentActionInfo()
        : Linkage(INDEX_NONE)
        , UUID(INDEX_NONE)
        , ExecutionFunction(NAME_None)
        , CallbackTarget(NULL)
    {
    }
 
    FORCENOINLINE FLatentActionInfo(int32 InLinkage, int32 InUUID, const TCHAR* InFunctionName, UObject* InCallbackTarget)
        : Linkage(InLinkage)
        , UUID(InUUID)
        , ExecutionFunction(InFunctionName)
        , CallbackTarget(InCallbackTarget)
    {
    }
};
 
enum class ELatentActionChangeType : uint8
{
    ActionsRemoved,
 
    ActionsAdded,
};
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnLatentActionsChanged, UObject*, ELatentActionChangeType)
 
// The latent action manager handles all pending latent actions for a single world
USTRUCT()
struct FLatentActionManager
{
    GENERATED_USTRUCT_BODY()
 
public: 
    static FOnLatentActionsChanged& OnLatentActionsChanged() { return LatentActionsChangedDelegate; }
 
    ENGINE_API void ProcessLatentActions(UObject* InObject, float DeltaTime);
 
    template<typename ActionType, typename PredicateType>
    ActionType* FindExistingActionWithPredicate(UObject* InActionObject, int32 UUID, const PredicateType& FilterPredicate)
    {
        FObjectActions* ObjectActionList = GetActionsForObject(InActionObject);
        if ((ObjectActionList != nullptr) && (ObjectActionList->ActionList.Num(UUID) > 0))
        {
            for (auto It = ObjectActionList->ActionList.CreateKeyIterator(UUID); It; ++It)
            {
                ActionType* Item = (ActionType*)(It.Value());
                if (FilterPredicate(Item))
                {
                    return Item;
                }
            }
        }
 
        return nullptr;
    }
 
    template<typename ActionType>
    ActionType* FindExistingAction(UObject* InActionObject, int32 UUID)
    {
        struct FFirstItemPredicate
        {
            FORCEINLINE bool operator()(void*) const { return true; }
        };
 
        return FindExistingActionWithPredicate<ActionType, FFirstItemPredicate>(InActionObject, UUID, FFirstItemPredicate());
    }
 
    ENGINE_API void RemoveActionsForObject(TWeakObjectPtr<UObject> InObject);
 
    ENGINE_API void AddNewAction(UObject* InActionObject, int32 UUID, FPendingLatentAction* NewAction);
 
    ENGINE_API void BeginFrame();
 
    ENGINE_API int32 GetNumActionsForObject(TWeakObjectPtr<UObject> InObject);
 
#if WITH_EDITOR
    ENGINE_API void GetActiveUUIDs(UObject* InObject, TSet<int32>& UUIDList) const;
 
    ENGINE_API FString GetDescription(UObject* InObject, int32 UUID) const;
#endif
 
    ENGINE_API ~FLatentActionManager();
 
protected:
    typedef TMultiMap<int32, class FPendingLatentAction*> FActionList;
 
    struct FObjectActions
    {
        FActionList ActionList;
        bool bProcessedThisFrame = false;
    };
 
    typedef TMap< TWeakObjectPtr<UObject>, TSharedPtr<FObjectActions>, FDefaultSetAllocator, TWeakObjectPtrMapKeyFuncs<TWeakObjectPtr<UObject>, TSharedPtr<FObjectActions> > > FObjectToActionListMap;
    FObjectToActionListMap ObjectToActionListMap;
 
    const FObjectActions* GetActionsForObject(const TWeakObjectPtr<UObject>& InObject) const
    {
        auto ObjectActionListPtr = ObjectToActionListMap.Find(InObject);
        return ObjectActionListPtr ? ObjectActionListPtr->Get() : nullptr;
    }
 
    FObjectActions* GetActionsForObject(const TWeakObjectPtr<UObject>& InObject)
    {
        auto ObjectActionListPtr = ObjectToActionListMap.Find(InObject);
        return ObjectActionListPtr ? ObjectActionListPtr->Get() : nullptr;
    }
 
    ENGINE_API void TickLatentActionForObject(float DeltaTime, FActionList& ObjectActionList, UObject* InObject);
 
protected:
    typedef TPair<int32, class FPendingLatentAction*> FUuidAndAction;
    typedef TPair<TWeakObjectPtr<UObject>, TSharedPtr<TArray<FUuidAndAction>>> FWeakObjectAndActions;
    typedef TArray<FWeakObjectAndActions> FActionsForObject;
    FActionsForObject ActionsToRemoveMap;
 
    static ENGINE_API FOnLatentActionsChanged LatentActionsChangedDelegate;
};