575 lines
18 KiB
C++
575 lines
18 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "CoreMinimal.h"
|
|
#include "Misc/Attribute.h"
|
|
#include "ToolMenuContext.h"
|
|
#include "ISequencer.h"
|
|
#include "Modules/ModuleInterface.h"
|
|
#include "AnimatedPropertyKey.h"
|
|
#include "ISequencerChannelInterface.h"
|
|
#include "IMovieRendererInterface.h"
|
|
#include "MovieSceneSequenceEditor.h"
|
|
|
|
class IKeyArea;
|
|
class FExtender;
|
|
class FStructOnScope;
|
|
class FExtensibilityManager;
|
|
class FMenuBuilder;
|
|
class FSequencerCustomizationManager;
|
|
class ISequencerTrackEditor;
|
|
class ISequencerEditorObjectBinding;
|
|
class IToolkitHost;
|
|
class UMovieSceneSequence;
|
|
struct FSequencerInitParams;
|
|
|
|
namespace UE::Sequencer
|
|
{
|
|
class FTrackModel;
|
|
class IObjectSchema;
|
|
class IOutlinerColumn;
|
|
class IOutlinerIndicatorBuilder;
|
|
} // namespace UE::Sequencer
|
|
|
|
enum class ECurveEditorTreeFilterType : uint32;
|
|
|
|
/** Forward declaration for the default templated channel interface. Include SequencerChannelInterface.h for full definition. */
|
|
template<typename> struct TSequencerChannelInterface;
|
|
|
|
namespace SequencerMenuExtensionPoints
|
|
{
|
|
static const FName AddTrackMenu_PropertiesSection("AddTrackMenu_PropertiesSection");
|
|
}
|
|
|
|
/** Enum representing supported scrubber styles */
|
|
enum class ESequencerScrubberStyle : uint8
|
|
{
|
|
/** Scrubber is represented as a single thin line for the current time, with a constant-sized thumb. */
|
|
Vanilla,
|
|
|
|
/** Scrubber thumb occupies a full 'display rate' frame, with a single thin line for the current time. Tailored to frame-accuracy scenarios. */
|
|
FrameBlock,
|
|
};
|
|
|
|
/** A delegate which will create an auto-key handler. */
|
|
DECLARE_DELEGATE_RetVal_OneParam(TSharedRef<ISequencerTrackEditor>, FOnCreateTrackEditor, TSharedRef<ISequencer>);
|
|
|
|
/** A delegate which will create an object binding handler. */
|
|
DECLARE_DELEGATE_RetVal_OneParam(TSharedRef<ISequencerEditorObjectBinding>, FOnCreateEditorObjectBinding, TSharedRef<ISequencer>);
|
|
|
|
/** A delegate which will create a track model. */
|
|
DECLARE_DELEGATE_RetVal_OneParam(TSharedPtr<UE::Sequencer::FTrackModel>, FOnCreateTrackModel, UMovieSceneTrack*);
|
|
|
|
/** A delegate which will create an outliner column */
|
|
DECLARE_DELEGATE_RetVal(TSharedRef<UE::Sequencer::IOutlinerColumn>, FOnCreateOutlinerColumn);
|
|
|
|
/** A delegate which will create an outliner indicator item */
|
|
DECLARE_DELEGATE_RetVal(TSharedRef<UE::Sequencer::IOutlinerIndicatorBuilder>, FOnCreateOutlinerIndicator);
|
|
|
|
/** A delegate that is executed when adding menu content. */
|
|
DECLARE_DELEGATE_OneParam(FOnGetContextMenuContent, FMenuBuilder& /*MenuBuilder*/);
|
|
|
|
/** A delegate that is executed when adding menu content. */
|
|
DECLARE_DELEGATE_TwoParams(FOnGetAddMenuContent, FMenuBuilder& /*MenuBuilder*/, TSharedRef<ISequencer>);
|
|
|
|
/** A delegate that is executed when initializing tool menu context. */
|
|
DECLARE_DELEGATE_OneParam(FOnInitToolMenuContext, FToolMenuContext&);
|
|
|
|
/** A delegate that is executed when menu object is clicked. Unlike FExtender delegates we pass in the FGuid which exists even for deleted objects. */
|
|
DECLARE_DELEGATE_TwoParams(FOnBuildCustomContextMenuForGuid, FMenuBuilder&, FGuid);
|
|
|
|
/** A delegate that gets executed then a sequencer is created */
|
|
DECLARE_MULTICAST_DELEGATE_OneParam(FOnSequencerCreated, TSharedRef<ISequencer>);
|
|
|
|
/** A delegate that gets executed a sequencer is initialize and allow modification the initialization params. */
|
|
DECLARE_MULTICAST_DELEGATE_ThreeParams(FOnPreSequencerInit, TSharedRef<ISequencer>, TSharedRef<ISequencerObjectChangeListener>, const FSequencerInitParams&);
|
|
|
|
/**
|
|
* Sequencer view parameters.
|
|
*/
|
|
struct FSequencerViewParams
|
|
{
|
|
/** Called when building the add track menu */
|
|
FOnGetAddMenuContent OnGetAddMenuContent;
|
|
|
|
/** Called when building a context menu for an object binding */
|
|
FOnBuildCustomContextMenuForGuid OnBuildCustomContextMenuForGuid;
|
|
|
|
/** Called when this sequencer has received user focus */
|
|
FSimpleDelegate OnReceivedFocus;
|
|
|
|
/** Called when this sequencer is initializing the tool menu context */
|
|
FOnInitToolMenuContext OnInitToolMenuContext;
|
|
|
|
/** The playback speed options available */
|
|
ISequencer::FOnGetPlaybackSpeeds OnGetPlaybackSpeeds;
|
|
|
|
/** A menu extender for the add menu */
|
|
TSharedPtr<FExtender> AddMenuExtender;
|
|
|
|
/** A toolbar extender for the main toolbar */
|
|
TSharedPtr<FExtender> ToolbarExtender;
|
|
|
|
/** Unique name for the sequencer. */
|
|
FString UniqueName;
|
|
|
|
/** Whether the sequencer is read-only */
|
|
bool bReadOnly;
|
|
|
|
/** Whether the playback range spin box should be visible in TimeRange widget */
|
|
bool bShowPlaybackRangeInTimeSlider;
|
|
|
|
/** Style of scrubber to use */
|
|
ESequencerScrubberStyle ScrubberStyle;
|
|
|
|
FSequencerViewParams(FString InName = FString())
|
|
: OnGetPlaybackSpeeds(ISequencer::FOnGetPlaybackSpeeds::CreateLambda([]() { return TArray<float>{ 0.1f, 0.25f, 0.5f, 1.f, 2.f, 5.f, 10.f }; }))
|
|
, UniqueName(MoveTemp(InName))
|
|
, bReadOnly(false)
|
|
, bShowPlaybackRangeInTimeSlider(false)
|
|
, ScrubberStyle(ESequencerScrubberStyle::Vanilla)
|
|
{ }
|
|
};
|
|
|
|
/**
|
|
* Sequencer host functionality capabilities. These are no longer
|
|
* based on whether or not there is a Toolkit host as we may have
|
|
* a toolkit host outside of conditions where these are supported.
|
|
*/
|
|
struct FSequencerHostCapabilities
|
|
{
|
|
/** Should we show the Save-As button in the toolbar? */
|
|
bool bSupportsSaveMovieSceneAsset;
|
|
|
|
/** Do we support the curve editor */
|
|
bool bSupportsCurveEditor;
|
|
|
|
/** Do we support recording */
|
|
bool bSupportsRecording;
|
|
|
|
/** Do we support rendering to a movie */
|
|
bool bSupportsRenderMovie;
|
|
|
|
/** Do we support adding content from the content browser */
|
|
bool bSupportsAddFromContentBrowser;
|
|
|
|
/** Do we support the sidebar widget */
|
|
bool bSupportsSidebar;
|
|
|
|
/** Do we support selectability options in the viewport */
|
|
bool bSupportsViewportSelectability;
|
|
|
|
FSequencerHostCapabilities()
|
|
: bSupportsSaveMovieSceneAsset(false)
|
|
, bSupportsCurveEditor(false)
|
|
, bSupportsRecording(false)
|
|
, bSupportsRenderMovie(false)
|
|
, bSupportsAddFromContentBrowser(false)
|
|
, bSupportsSidebar(false)
|
|
, bSupportsViewportSelectability(false)
|
|
{}
|
|
};
|
|
|
|
/**
|
|
* Sequencer initialization parameters.
|
|
*/
|
|
struct FSequencerInitParams
|
|
{
|
|
/** The root movie scene sequence being edited. */
|
|
UMovieSceneSequence* RootSequence;
|
|
|
|
/** The asset editor created for this (if any) */
|
|
TSharedPtr<IToolkitHost> ToolkitHost;
|
|
|
|
/** View parameters */
|
|
FSequencerViewParams ViewParams;
|
|
|
|
/** Immutable capability set specified when our instance is created. Used to specify which feature set is supported. */
|
|
FSequencerHostCapabilities HostCapabilities;
|
|
|
|
/** Whether or not sequencer should be edited within the level editor */
|
|
bool bEditWithinLevelEditor;
|
|
|
|
/** Domain-specific spawn register for the movie scene */
|
|
TSharedPtr<FMovieSceneSpawnRegister> SpawnRegister;
|
|
|
|
/** Accessor for event contexts */
|
|
TAttribute<TArray<UObject*>> EventContexts;
|
|
|
|
/** Accessor for playback context */
|
|
TAttribute<UObject*> PlaybackContext;
|
|
|
|
/** Accessor for playback client */
|
|
TAttribute<IMovieScenePlaybackClient*> PlaybackClient;
|
|
|
|
FSequencerInitParams()
|
|
: RootSequence(nullptr)
|
|
, ToolkitHost(nullptr)
|
|
, bEditWithinLevelEditor(false)
|
|
, SpawnRegister(nullptr)
|
|
{}
|
|
};
|
|
|
|
/**
|
|
* Interface for the Sequencer module.
|
|
*/
|
|
class ISequencerModule
|
|
: public IModuleInterface
|
|
{
|
|
public:
|
|
|
|
virtual ~ISequencerModule();
|
|
|
|
/**
|
|
* Create a new instance of a standalone sequencer that can be added to other UIs.
|
|
*
|
|
* @param InitParams Initialization parameters.
|
|
* @return The new sequencer object.
|
|
*/
|
|
virtual TSharedRef<ISequencer> CreateSequencer(const FSequencerInitParams& InitParams) = 0;
|
|
|
|
/**
|
|
* Registers a delegate that will create an editor for a track in each sequencer.
|
|
*
|
|
* @param InOnCreateTrackEditor Delegate to register.
|
|
* @return A handle to the newly-added delegate.
|
|
*/
|
|
virtual FDelegateHandle RegisterTrackEditor(FOnCreateTrackEditor InOnCreateTrackEditor, TArrayView<FAnimatedPropertyKey> AnimatedPropertyTypes = TArrayView<FAnimatedPropertyKey>()) = 0;
|
|
|
|
/**
|
|
* Unregisters a previously registered delegate for creating a track editor
|
|
*
|
|
* @param InHandle Handle to the delegate to unregister
|
|
*/
|
|
virtual void UnRegisterTrackEditor(FDelegateHandle InHandle) = 0;
|
|
|
|
/**
|
|
* Registers a delegate that will create a track view model for a given track
|
|
*
|
|
* @param InCreator Delegate to register
|
|
* @return A handle to the newly-added delegate
|
|
*/
|
|
virtual FDelegateHandle RegisterTrackModel(FOnCreateTrackModel InCreator) = 0;
|
|
|
|
/**
|
|
* Unregisters a previously registered delegate for creating track view models
|
|
*
|
|
* @param InHandle Handle to the delegate to unregister
|
|
*/
|
|
virtual void UnregisterTrackModel(FDelegateHandle InHandle) = 0;
|
|
|
|
/**
|
|
* Registers a delegate that will create a gutter column view model for a given Outliner column
|
|
*
|
|
* @param InCreator Delegate to register
|
|
* @return A handle to the newly added delegate
|
|
*/
|
|
virtual FDelegateHandle RegisterOutlinerColumn(FOnCreateOutlinerColumn InCreator) = 0;
|
|
|
|
/**
|
|
* Unregisters a previously registered delegate for creating Outliner columns
|
|
*
|
|
* @param InHandle Handle to the delegate to unregister
|
|
*/
|
|
virtual void UnregisterOutlinerColumn(FDelegateHandle InHandle) = 0;
|
|
|
|
/**
|
|
* Registers a delegate that will create an outliner indicator item
|
|
*
|
|
* @param InCreator Delegate to register
|
|
* @return A handle to the newly added delegate
|
|
*/
|
|
virtual FDelegateHandle RegisterOutlinerIndicator(FOnCreateOutlinerIndicator InCreator) = 0;
|
|
|
|
/**
|
|
* Unregisters a previously registered delegate for creating an outliner indicator item
|
|
*
|
|
* @param InHandle Handle to the delegate to unregister
|
|
*/
|
|
virtual void UnregisterOutlinerIndicator(FDelegateHandle InHandle) = 0;
|
|
|
|
/**
|
|
* Registers a delegate that will be called when a sequencer is created
|
|
*
|
|
* @param InOnSequencerCreated Delegate to register.
|
|
* @return A handle to the newly-added delegate.
|
|
*/
|
|
virtual FDelegateHandle RegisterOnSequencerCreated(FOnSequencerCreated::FDelegate InOnSequencerCreated) = 0;
|
|
|
|
/**
|
|
* Unregisters a previously registered delegate called when a sequencer is created
|
|
*
|
|
* @param InHandle Handle to the delegate to unregister
|
|
*/
|
|
virtual void UnregisterOnSequencerCreated(FDelegateHandle InHandle) = 0;
|
|
|
|
/**
|
|
* Registers a delegate that will be called just before a sequencer is initialized
|
|
*
|
|
* @param InOnPreSequencerInit Delegate to register.
|
|
* @return A handle to the newly-added delegate.
|
|
*/
|
|
virtual FDelegateHandle RegisterOnPreSequencerInit(FOnPreSequencerInit::FDelegate InOnPreSequencerInit) = 0;
|
|
|
|
/**
|
|
* Unregisters a previously registered delegate called just before a sequencer is initialized
|
|
*
|
|
* @param InHandle Handle to the delegate to unregister
|
|
*/
|
|
virtual void UnregisterOnPreSequencerInit(FDelegateHandle InHandle) = 0;
|
|
|
|
/**
|
|
* Registers a delegate that will create editor UI for an object binding in sequencer.
|
|
*
|
|
* @param InOnCreateEditorObjectBinding Delegate to register.
|
|
* @return A handle to the newly-added delegate.
|
|
*/
|
|
virtual FDelegateHandle RegisterEditorObjectBinding(FOnCreateEditorObjectBinding InOnCreateEditorObjectBinding) = 0;
|
|
|
|
/**
|
|
* Unregisters a previously registered delegate for creating editor UI for an object binding in sequencer.
|
|
*
|
|
* @param InHandle Handle to the delegate to unregister
|
|
*/
|
|
virtual void UnRegisterEditorObjectBinding(FDelegateHandle InHandle) = 0;
|
|
|
|
/**
|
|
* Register that the specified property type can be animated in sequencer
|
|
*/
|
|
virtual void RegisterPropertyAnimator(FAnimatedPropertyKey Key) = 0;
|
|
|
|
/**
|
|
* Unregister that the specified property type can be animated in sequencer
|
|
*/
|
|
virtual void UnRegisterPropertyAnimator(FAnimatedPropertyKey Key) = 0;
|
|
|
|
/**
|
|
* Check whether the specified property type can be animated by sequeuncer
|
|
*/
|
|
virtual bool CanAnimateProperty(FProperty* Property) = 0;
|
|
|
|
/**
|
|
* Get the extensibility manager for object binding menus.
|
|
*
|
|
* @return ObjectBinding Context Menu extensibility manager.
|
|
*/
|
|
virtual TSharedPtr<FExtensibilityManager> GetObjectBindingContextMenuExtensibilityManager() const = 0;
|
|
|
|
/**
|
|
* Get the extensibility manager for add track menus.
|
|
*
|
|
* @return Add Track Menu extensibility manager.
|
|
*/
|
|
virtual TSharedPtr<FExtensibilityManager> GetAddTrackMenuExtensibilityManager() const = 0;
|
|
|
|
/**
|
|
* Get the extensibility manager for toolbars.
|
|
*
|
|
* @return Toolbar extensibility manager.
|
|
*/
|
|
virtual TSharedPtr<FExtensibilityManager> GetToolBarExtensibilityManager() const = 0;
|
|
|
|
/**
|
|
* Get the extensibility manager for the view options menu.
|
|
*
|
|
* @return Toolbar extensibility manager.
|
|
*/
|
|
virtual TSharedPtr<FExtensibilityManager> GetViewMenuExtensibilityManager() const = 0;
|
|
|
|
/**
|
|
* Get the extensibility manager for the actions menu.
|
|
*
|
|
* @return Toolbar extensibility manager.
|
|
*/
|
|
virtual TSharedPtr<FExtensibilityManager> GetActionsMenuExtensibilityManager() const = 0;
|
|
|
|
/**
|
|
* Get the extensibility manager for the sidebar.
|
|
*
|
|
* @return Sidebar extensibility manager.
|
|
*/
|
|
virtual TSharedPtr<FExtensibilityManager> GetSidebarExtensibilityManager() const = 0;
|
|
|
|
/**
|
|
* Get the sequencer customization manager, which handles editor customizations applied based on
|
|
* the currently focused sequence type and other dynamic criteria.
|
|
*/
|
|
virtual TSharedPtr<FSequencerCustomizationManager> GetSequencerCustomizationManager() const = 0;
|
|
|
|
/**
|
|
* Register a new object schema defining how an object is able to be animated through Sequencer
|
|
*/
|
|
virtual void RegisterObjectSchema(TSharedPtr<UE::Sequencer::IObjectSchema> InObjectSchema) = 0;
|
|
|
|
/**
|
|
* Unregister a new object schema defining how an object is able to be animated through Sequencer
|
|
*/
|
|
virtual void UnregisterObjectSchema(TSharedPtr<UE::Sequencer::IObjectSchema> InSchema) = 0;
|
|
|
|
/**
|
|
* Retrieve all the currently registered object schemas
|
|
*/
|
|
virtual TArrayView<const TSharedPtr<UE::Sequencer::IObjectSchema>> GetObjectSchemas() const = 0;
|
|
|
|
/**
|
|
* Find an object schema for the specified object
|
|
*/
|
|
virtual TSharedPtr<UE::Sequencer::IObjectSchema> FindObjectSchema(const UObject* Object) const = 0;
|
|
|
|
/**
|
|
* Register a sequencer channel type using a default channel interface.
|
|
*/
|
|
template<typename ChannelType>
|
|
void RegisterChannelInterface();
|
|
|
|
/**
|
|
* Register a sequencer channel type using the specified interface.
|
|
*/
|
|
template<typename ChannelType>
|
|
void RegisterChannelInterface(TUniquePtr<ISequencerChannelInterface>&& InInterface);
|
|
|
|
/**
|
|
* Find a sequencer channel for the specified channel type name
|
|
*/
|
|
ISequencerChannelInterface* FindChannelEditorInterface(FName ChannelTypeName) const;
|
|
|
|
|
|
/**
|
|
* Retrieve the unique identifer for the sequencer selection curve editor filter (of type FSequencerSelectionCurveFilter)
|
|
*/
|
|
static ECurveEditorTreeFilterType GetSequencerSelectionFilterType();
|
|
|
|
public:
|
|
|
|
/**
|
|
* Register a sequence editor for the specified type of sequence. Sequence editors provide editor-only functionality for particular sequence types.
|
|
*/
|
|
FDelegateHandle RegisterSequenceEditor(UClass* SequenceClass, TUniquePtr<FMovieSceneSequenceEditor>&& InSequenceEditor)
|
|
{
|
|
check(SequenceClass);
|
|
|
|
FDelegateHandle NewHandle(FDelegateHandle::GenerateNewHandle);
|
|
|
|
SequenceEditors.Add(FSequenceEditorEntry{ NewHandle, SequenceClass, MoveTemp(InSequenceEditor) });
|
|
|
|
return NewHandle;
|
|
}
|
|
|
|
/**
|
|
* Unregister a sequence editor for the specified type of sequence.
|
|
*/
|
|
void UnregisterSequenceEditor(FDelegateHandle Handle)
|
|
{
|
|
SequenceEditors.RemoveAll([Handle](const FSequenceEditorEntry& In){ return In.Handle == Handle; });
|
|
}
|
|
|
|
/**
|
|
* Find a sequence editor for the specified sequence class
|
|
*/
|
|
FMovieSceneSequenceEditor* FindSequenceEditor(UClass* SequenceClass) const
|
|
{
|
|
check(SequenceClass);
|
|
|
|
UClass* MostRelevantClass = nullptr;
|
|
FMovieSceneSequenceEditor* SequenceEditor = nullptr;
|
|
|
|
for (const FSequenceEditorEntry& Entry : SequenceEditors)
|
|
{
|
|
if (SequenceClass->IsChildOf(Entry.ApplicableClass))
|
|
{
|
|
if (!MostRelevantClass || Entry.ApplicableClass->IsChildOf(MostRelevantClass))
|
|
{
|
|
MostRelevantClass = Entry.ApplicableClass;
|
|
SequenceEditor = Entry.Editor.Get();
|
|
}
|
|
}
|
|
}
|
|
|
|
return SequenceEditor;
|
|
}
|
|
|
|
public:
|
|
|
|
/**
|
|
* Helper template for registering property track editors
|
|
*
|
|
* @param InOnCreateTrackEditor Delegate to register.
|
|
* @return A handle to the newly-added delegate.
|
|
*/
|
|
template<typename PropertyTrackEditorType>
|
|
FDelegateHandle RegisterPropertyTrackEditor()
|
|
{
|
|
auto PropertyTypes = PropertyTrackEditorType::GetAnimatedPropertyTypes();
|
|
return RegisterTrackEditor(FOnCreateTrackEditor::CreateStatic(PropertyTrackEditorType::CreateTrackEditor), PropertyTypes);
|
|
}
|
|
|
|
public:
|
|
|
|
/**
|
|
* Register a movie renderer for this sequencer.
|
|
*/
|
|
virtual FDelegateHandle RegisterMovieRenderer(TUniquePtr<IMovieRendererInterface>&& InMovieRenderer) = 0;
|
|
|
|
/**
|
|
* Unregister a movie renderer for this sequencer.
|
|
*/
|
|
virtual void UnregisterMovieRenderer(FDelegateHandle InDelegateHandle) = 0;
|
|
|
|
/**
|
|
* Get the movie renderer with the requested name.
|
|
*/
|
|
virtual IMovieRendererInterface* GetMovieRenderer(const FString& InMovieRendererName) = 0;
|
|
|
|
/**
|
|
* Get a list of registered movie renderers.
|
|
*/
|
|
virtual TArray<FString> GetMovieRendererNames() = 0;
|
|
|
|
private:
|
|
|
|
/** Map of sequencer interfaces for movie scene channel types, keyed on channel UStruct name */
|
|
TMap<FName, TUniquePtr<ISequencerChannelInterface>> ChannelToEditorInterfaceMap;
|
|
|
|
struct FSequenceEditorEntry
|
|
{
|
|
FDelegateHandle Handle;
|
|
UClass* ApplicableClass;
|
|
TUniquePtr<FMovieSceneSequenceEditor> Editor;
|
|
};
|
|
|
|
/** Array of sequence editor entries */
|
|
TArray<FSequenceEditorEntry> SequenceEditors;
|
|
};
|
|
|
|
|
|
/**
|
|
* Register a sequencer channel type using a default channel interface.
|
|
*/
|
|
template<typename ChannelType>
|
|
void ISequencerModule::RegisterChannelInterface()
|
|
{
|
|
RegisterChannelInterface<ChannelType>(TUniquePtr<ISequencerChannelInterface>(new TSequencerChannelInterface<ChannelType>()));
|
|
}
|
|
|
|
/**
|
|
* Register a sequencer channel type using the specified interface.
|
|
*/
|
|
template<typename ChannelType>
|
|
void ISequencerModule::RegisterChannelInterface(TUniquePtr<ISequencerChannelInterface>&& InInterface)
|
|
{
|
|
const FName ChannelTypeName = ChannelType::StaticStruct()->GetFName();
|
|
check(!ChannelToEditorInterfaceMap.Contains(ChannelTypeName));
|
|
ChannelToEditorInterfaceMap.Add(ChannelTypeName, MoveTemp(InInterface));
|
|
}
|
|
|
|
/**
|
|
* Find a sequencer channel for the specified channel type name
|
|
*/
|
|
inline ISequencerChannelInterface* ISequencerModule::FindChannelEditorInterface(FName ChannelTypeName) const
|
|
{
|
|
const TUniquePtr<ISequencerChannelInterface>* Found = ChannelToEditorInterfaceMap.Find(ChannelTypeName);
|
|
ensureMsgf(Found, TEXT("No channel interface found for type ID. Did you call RegisterChannelInterface<> for that type?"));
|
|
return Found ? Found->Get() : nullptr;
|
|
}
|