IMovieScenePlaybackCapability.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "EntitySystem/MovieSceneSequenceInstanceHandle.h"
#include "Misc/AssertionMacros.h"
#include "Misc/EnumClassFlags.h"
#include "Templates/SharedPointer.h"
 
class IMovieScenePlayer;
class UMovieSceneEntitySystemLinker;
 
namespace UE::MovieScene
{
 
struct FInstanceHandle;
struct FSharedPlaybackState;
 
struct FPlaybackCapabilityID
{
    int32 Index = INDEX_NONE;
 
    bool IsValid() const
    {
        return Index != INDEX_NONE;
    }
 
protected:
    static MOVIESCENE_API FPlaybackCapabilityID Register(const TCHAR* InDebugName);
};
 
template<typename T>
struct TPlaybackCapabilityID : FPlaybackCapabilityID
{
public:
    using CapabilityType = T;
 
private:
    // Only T should construct this (to ensure safe construction over DLL boundaries)
    friend T;
 
    TPlaybackCapabilityID()
    {}
 
    explicit TPlaybackCapabilityID(int32 InIndex)
        : FPlaybackCapabilityID{ InIndex }
    {}
 
    UE_DEPRECATED(5.6, "Use the version that takes a debug name. If defining a static ID field, please upgrade to UE_DECLARE_MOVIESCENE_PLAYBACK_CAPABILITY_API and UE_DEFINE_MOVIESCENE_PLAYBACK_CAPABILITY instead.")
    static TPlaybackCapabilityID<T> Register()
    {
        return TPlaybackCapabilityID<T>::Register(TEXT("Unknown"));
    }
 
    static TPlaybackCapabilityID<T> Register(const TCHAR* InDebugName)
    {
        FPlaybackCapabilityID StaticID = FPlaybackCapabilityID::Register(InDebugName);
        return TPlaybackCapabilityID<T>(StaticID.Index);
    }
};
 
struct IPlaybackCapability
{
    virtual ~IPlaybackCapability() {}
 
    virtual void Initialize(TSharedRef<const FSharedPlaybackState> Owner) {}
    virtual void OnSubInstanceCreated(TSharedRef<const FSharedPlaybackState> Owner, const FInstanceHandle InstanceHandle) {}
    virtual void InvalidateCachedData(UMovieSceneEntitySystemLinker* Linker) {}
};
 
struct FPlaybackCapabilityIDInfo
{
#if UE_MOVIESCENE_ENTITY_DEBUG
    FString DebugName;
#endif
};
 
class FPlaybackCapabilityIDRegistry
{
public:
 
    static MOVIESCENE_API FPlaybackCapabilityIDRegistry* Get();
 
    MOVIESCENE_API FPlaybackCapabilityID RegisterNewID(const TCHAR* InDebugName);
 
private:
 
    TArray<FPlaybackCapabilityIDInfo> Infos;
};
 
extern MOVIESCENE_API FPlaybackCapabilityIDRegistry* GPlaybackCapabilityIDRegistryForDebuggingVisualizers;
 
#if UE_MOVIESCENE_ENTITY_DEBUG
 
struct IPlaybackCapabilityDebuggingTypedPtr
{
    virtual ~IPlaybackCapabilityDebuggingTypedPtr() {}
    void* Ptr = nullptr;
};
 
template<typename T>
struct TPlaybackCapabilityDebuggingTypedPtr : IPlaybackCapabilityDebuggingTypedPtr
{
    TPlaybackCapabilityDebuggingTypedPtr(T* InPtr)
    {
        static_assert(sizeof(TPlaybackCapabilityDebuggingTypedPtr) == sizeof(IPlaybackCapabilityDebuggingTypedPtr), "Size must match");
        Ptr = InPtr;
    }
};
 
#endif
 
#define UE_DECLARE_MOVIESCENE_PLAYBACK_CAPABILITY_API(ApiDeclSpec, ClassName)\
    static ApiDeclSpec UE::MovieScene::TPlaybackCapabilityID<ClassName> GetPlaybackCapabilityID();\
 
#define UE_DECLARE_MOVIESCENE_PLAYBACK_CAPABILITY(ClassName)\
    static UE::MovieScene::TPlaybackCapabilityID<ClassName> GetPlaybackCapabilityID();\
 
#define UE_DEFINE_MOVIESCENE_PLAYBACK_CAPABILITY(ClassName)\
    UE::MovieScene::TPlaybackCapabilityID<ClassName> ClassName::GetPlaybackCapabilityID()\
    {\
        static UE::MovieScene::TPlaybackCapabilityID<ClassName> StaticID = \
            UE::MovieScene::TPlaybackCapabilityID<ClassName>::Register(TEXT(#ClassName));\
        return StaticID;\
    }
 
} // namespace UE::MovieScene