MovieSceneChannelProxy.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Algo/BinarySearch.h"
#include "Channels/MovieSceneChannelEditorDataEntry.h"
#include "Channels/MovieSceneChannelHandle.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "Misc/AssertionMacros.h"
#include "Misc/InlineValue.h"
#include "Templates/SharedPointer.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/UnrealTypeTraits.h"
#include "UObject/NameTypes.h"
 
struct FMovieSceneChannel;
struct FMovieSceneChannelMetaData;
struct FMovieSceneChannelProxy;
struct FMovieSceneChannelProxyData;
 
struct FMovieSceneChannelEntry : FMovieSceneChannelEditorDataEntry
{
    FName GetChannelTypeName() const
    {
        return ChannelTypeName;
    }
 
    TArrayView<FMovieSceneChannel* const> GetChannels() const
    {
        return Channels;
    }
 
#if WITH_EDITOR
 
    template<typename ChannelType>
    TArrayView<const typename TMovieSceneChannelTraits<ChannelType>::ExtendedEditorDataType> GetAllExtendedEditorData() const
    {
        check(ChannelType::StaticStruct()->GetFName() == ChannelTypeName);
        return FMovieSceneChannelEditorDataEntry::GetAllExtendedEditorData<ChannelType>();
    }
 
#endif
 
private:
 
    // only FMovieSceneChannelProxyData and FMovieSceneChannelProxy can create entries
    friend FMovieSceneChannelProxyData;
    friend FMovieSceneChannelProxy;
 
    template<typename ChannelType>
    explicit FMovieSceneChannelEntry(FName InChannelTypeName, const ChannelType& Channel)
        : FMovieSceneChannelEditorDataEntry(Channel)
        , ChannelTypeName(InChannelTypeName)
    {}
 
    FName ChannelTypeName;
 
    TArray<FMovieSceneChannel*> Channels;
};
 
 
 
 
struct FMovieSceneChannelProxyData
{
#if WITH_EDITOR
 
    template<typename ChannelType>
    void Add(ChannelType& InChannel, const FMovieSceneChannelMetaData& InMetaData)
    {
        static_assert(std::is_same_v<typename TMovieSceneChannelTraits<ChannelType>::ExtendedEditorDataType, void>, "Must supply extended editor data according to the channel's traits.");
        static_assert(!std::is_same_v<ChannelType, FMovieSceneChannel>, "Cannot add channels by their base FMovieSceneChannel type.");
 
        // Add the channel
        const int32 ChannelTypeIndex = AddInternal(InChannel);
        // Add the editor data at the same index
        Entries[ChannelTypeIndex].AddMetaData<ChannelType>(InMetaData);
    }
 
    template<typename ChannelType>
    FMovieSceneChannelHandle AddWithDefaultEditorData(ChannelType& InChannel, const FMovieSceneChannelMetaData& InMetaData)
    {
        static_assert(!std::is_same_v<typename TMovieSceneChannelTraits<ChannelType>::ExtendedEditorDataType, void>, "This method is for channels with typed editor data. You *must* call SetExtendedEditorData afterwards.");
        static_assert(!std::is_same_v<ChannelType, FMovieSceneChannel>, "Cannot add channels by their base FMovieSceneChannel type.");
 
        // Add the channel
        const int32 ChannelTypeIndex = AddInternal(InChannel);
        // Add a default editor data at the same index, hopefully the caller will set it afterwards
        Entries[ChannelTypeIndex].AddMetaData<ChannelType>(InMetaData, typename TMovieSceneChannelTraits<ChannelType>::ExtendedEditorDataType());
        // Return index usable for SetExtendedEditorData
        const FName ChannelTypeName = ChannelType::StaticStruct()->GetFName();
        return FMovieSceneChannelHandle(nullptr, ChannelTypeName, Entries[ChannelTypeIndex].GetChannels().Num() - 1);
    }
 
    template<typename ChannelType, typename ExtendedEditorDataType>
    void Add(ChannelType& InChannel, const FMovieSceneChannelMetaData& InMetaData, ExtendedEditorDataType&& InExtendedEditorData)
    {
        static_assert(!std::is_same_v<typename TMovieSceneChannelTraits<ChannelType>::ExtendedEditorDataType, void>, "Must supply typed editor data according to the channel's traits. Define TMovieSceneChannelTraits<ChannelType>::ExtendedEditorDataType to use this function.");
        static_assert(!std::is_same_v<ChannelType, FMovieSceneChannel>, "Cannot add channels by their base FMovieSceneChannel type.");
 
        // Add the channel
        const int32 ChannelTypeIndex = AddInternal(InChannel);
        // Add the editor data at the same index
        Entries[ChannelTypeIndex].AddMetaData<ChannelType>(InMetaData, Forward<ExtendedEditorDataType>(InExtendedEditorData));
    }
 
    template<typename ChannelType, typename ExtendedEditorDataType>
    void SetExtendedEditorData(FMovieSceneChannelHandle ChannelHandle, ExtendedEditorDataType&& InExtendedEditorData)
    {
        // Find the entry
        // TODO: we rely on ChannelType's extended editor data to be the same as the overriden extended editor data!
        const FName ChannelTypeName = ChannelHandle.GetChannelTypeName();
        FMovieSceneChannelEntry* Entry = Entries.FindByPredicate([=](const FMovieSceneChannelEntry& CurEntry)
                { return CurEntry.ChannelTypeName == ChannelTypeName; });
        if (ensure(Entry))
        {
            Entry->SetExtendedEditorData<ChannelType>(ChannelHandle.GetChannelIndex(), InExtendedEditorData);
        }
    }
 
#else
 
    template<typename ChannelType>
    void Add(ChannelType& InChannel)
    {
        AddInternal(InChannel);
    }
 
#endif
 
private:
 
    template<typename ChannelType>
    int32 AddInternal(ChannelType& InChannel);
 
    friend struct FMovieSceneChannelProxy;
    TArray<FMovieSceneChannelEntry, TInlineAllocator<1>> Entries;
};
 
 
struct FMovieSceneChannelProxy : TSharedFromThis<FMovieSceneChannelProxy>
{
public:
 
    FSimpleMulticastDelegate OnDestroy;
 
    FMovieSceneChannelProxy(){}
 
    ~FMovieSceneChannelProxy()
    {
        OnDestroy.Broadcast();
    }
 
    FMovieSceneChannelProxy(FMovieSceneChannelProxyData&& InChannels)
        : Entries(MoveTemp(InChannels.Entries))
    {}
 
    FMovieSceneChannelProxy(const FMovieSceneChannelProxy&) = delete;
    FMovieSceneChannelProxy& operator=(const FMovieSceneChannelProxy&) = delete;
 
    FMovieSceneChannelProxy(FMovieSceneChannelProxy&&) = delete;
    FMovieSceneChannelProxy& operator=(FMovieSceneChannelProxy&&) = delete;
 
public:
 
    TArrayView<const FMovieSceneChannelEntry> GetAllEntries() const
    {
        return Entries;
    }
 
    MOVIESCENE_API const FMovieSceneChannelEntry* FindEntry(FName ChannelTypeName) const;
 
    MOVIESCENE_API int32 FindIndex(FName ChannelTypeName, const FMovieSceneChannel* ChannelPtr) const;
 
    template<typename ChannelType>
    TArrayView<ChannelType*> GetChannels() const;
 
    template<typename ChannelType>
    ChannelType* GetChannel(int32 ChannelIndex) const;
 
    MOVIESCENE_API FMovieSceneChannel* GetChannel(FName ChannelTypeName, int32 ChannelIndex) const;
 
    MOVIESCENE_API int32 NumChannels() const;
 
    MOVIESCENE_API FMovieSceneChannelHandle MakeHandle(FName ChannelTypeName, int32 Index);
 
    template<typename ChannelType>
    TMovieSceneChannelHandle<ChannelType> MakeHandle(int32 Index)
    {
        FName ChannelTypeName = ChannelType::StaticStruct()->GetFName();
        return MakeHandle(ChannelTypeName, Index).template Cast<ChannelType>();
    }
 
    template<typename ChannelType>
    TMovieSceneChannelHandle<ChannelType> CopyHandle(TMovieSceneChannelHandle<ChannelType> InOtherHandle)
    {
        return MakeHandle(InOtherHandle.GetChannelTypeName(), InOtherHandle.GetChannelIndex()).template Cast<ChannelType>();
    }
 
#if !WITH_EDITOR
 
    template<typename ChannelType>
    FMovieSceneChannelProxy(ChannelType& InChannel);
 
#else
 
    template<typename ChannelType>
    FMovieSceneChannelProxy(ChannelType& InChannel, const FMovieSceneChannelMetaData& InMetaData);
 
    template<typename ChannelType, typename ExtendedEditorDataType>
    FMovieSceneChannelProxy(ChannelType& InChannel, const FMovieSceneChannelMetaData& InMetaData, ExtendedEditorDataType&& InExtendedEditorData);
 
 
    template<typename ChannelType>
    TArrayView<const FMovieSceneChannelMetaData> GetMetaData() const;
 
    template<typename ChannelType>
    TMovieSceneChannelHandle<ChannelType> GetChannelByName(FName ChannelName) const;
 
    MOVIESCENE_API FMovieSceneChannelHandle GetChannelByName(FName ChannelName) const;
 
    template<typename ChannelType>
    TArrayView<const typename TMovieSceneChannelTraits<ChannelType>::ExtendedEditorDataType> GetAllExtendedEditorData() const;
 
#endif  // !WITH_EDITOR
 
private:
 
    using TSharedFromThis::AsShared;
 
    TArray<FMovieSceneChannelEntry, TInlineAllocator<1>> Entries;
 
#if WITH_EDITOR
 
    MOVIESCENE_API void EnsureHandlesByNamePopulated() const;
 
    mutable TMap<FName, FMovieSceneChannelHandle> HandlesByName;
    mutable bool bHandlesByNamePopulated = false;
 
#endif // WITH_EDITOR
};
 
 
template<typename ChannelType>
int32 FMovieSceneChannelProxyData::AddInternal(ChannelType& InChannel)
{
    FMovieSceneChannelHandle::TrackChannelTypeName<ChannelType>();
 
    // Find the entry for this channel's type
    FName ChannelTypeName = ChannelType::StaticStruct()->GetFName();
 
    // Find the first entry that has a >= channel ID
    int32 ChannelTypeIndex = Algo::LowerBoundBy(Entries, ChannelTypeName, &FMovieSceneChannelEntry::GetChannelTypeName, FNameLexicalLess());
 
    // If the index we found isn't valid, or it's not the channel we want, we need to add a new entry there
    if (ChannelTypeIndex >= Entries.Num() || Entries[ChannelTypeIndex].GetChannelTypeName() != ChannelTypeName)
    {
        Entries.Insert(FMovieSceneChannelEntry(ChannelTypeName, InChannel), ChannelTypeIndex);
    }
 
    check(Entries.IsValidIndex(ChannelTypeIndex));
 
    // Add the channel to the channels array
    Entries[ChannelTypeIndex].Channels.Add(&InChannel);
    return ChannelTypeIndex;
}
 
 
template<typename ChannelType>
TArrayView<ChannelType*> FMovieSceneChannelProxy::GetChannels() const
{
    FName ChannelTypeName = ChannelType::StaticStruct()->GetFName();
    const FMovieSceneChannelEntry* FoundEntry = FindEntry(ChannelTypeName);
 
    if (FoundEntry)
    {
        return TArrayView<ChannelType*>((ChannelType**)(FoundEntry->Channels.GetData()), FoundEntry->Channels.Num());
    }
    return TArrayView<ChannelType*>();
}
 
 
template<typename ChannelType>
ChannelType* FMovieSceneChannelProxy::GetChannel(int32 ChannelIndex) const
{
    TArrayView<ChannelType*> Channels = GetChannels<ChannelType>();
    return Channels.IsValidIndex(ChannelIndex) ? Channels[ChannelIndex] : nullptr;
}
 
#if !WITH_EDITOR
 
 
template<typename ChannelType>
FMovieSceneChannelProxy::FMovieSceneChannelProxy(ChannelType& InChannel)
{
    static_assert(!std::is_same_v<ChannelType, FMovieSceneChannel>, "Cannot add channels by their base FMovieSceneChannel type..");
 
    const FName ChannelTypeName = ChannelType::StaticStruct()->GetFName();
    Entries.Add(FMovieSceneChannelEntry(ChannelTypeName, InChannel));
    Entries[0].Channels.Add(&InChannel);
}
 
 
#else   // !WITH_EDITOR
 
 
template<typename ChannelType>
FMovieSceneChannelProxy::FMovieSceneChannelProxy(ChannelType& InChannel, const FMovieSceneChannelMetaData& InMetaData)
{
    static_assert(!std::is_same_v<ChannelType, FMovieSceneChannel>, "Cannot add channels by their base FMovieSceneChannel type..");
    static_assert(std::is_same_v<typename TMovieSceneChannelTraits<ChannelType>::ExtendedEditorDataType, void>, "Must supply typed editor data according to the channel's traits.");
 
    const FName ChannelTypeName = ChannelType::StaticStruct()->GetFName();
    Entries.Add(FMovieSceneChannelEntry(ChannelTypeName, InChannel));
    Entries[0].Channels.Add(&InChannel);
    Entries[0].AddMetaData<ChannelType>(InMetaData);
}
 
 
template<typename ChannelType, typename ExtendedEditorDataType>
FMovieSceneChannelProxy::FMovieSceneChannelProxy(ChannelType& InChannel, const FMovieSceneChannelMetaData& InMetaData, ExtendedEditorDataType&& InExtendedEditorDataType)
{
    static_assert(!std::is_same_v<ChannelType, FMovieSceneChannel>, "Cannot add channels by their base FMovieSceneChannel type..");
    static_assert(!std::is_same_v<typename TMovieSceneChannelTraits<ChannelType>::ExtendedEditorDataType, void>, "Must supply typed editor data according to the channel's traits. Define TMovieSceneChannelTraits<ChannelType>::ExtendedEditorDataType to use this function.");
 
    const FName ChannelTypeName = ChannelType::StaticStruct()->GetFName();
    Entries.Add(FMovieSceneChannelEntry(ChannelTypeName, InChannel));
    Entries[0].Channels.Add(&InChannel);
    Entries[0].AddMetaData<ChannelType>(InMetaData, Forward<ExtendedEditorDataType>(InExtendedEditorDataType));
}
 
 
template<typename ChannelType>
TArrayView<const typename TMovieSceneChannelTraits<ChannelType>::ExtendedEditorDataType> FMovieSceneChannelProxy::GetAllExtendedEditorData() const
{
    FName ChannelTypeName = ChannelType::StaticStruct()->GetFName();
    const FMovieSceneChannelEntry* FoundEntry = FindEntry(ChannelTypeName);
 
    if (FoundEntry)
    {
        return FoundEntry->GetAllExtendedEditorData<ChannelType>();
    }
    return TArrayView<const typename TMovieSceneChannelTraits<ChannelType>::ExtendedEditorDataType>();
}
 
 
template<typename ChannelType>
TArrayView<const FMovieSceneChannelMetaData> FMovieSceneChannelProxy::GetMetaData() const
{
    FName ChannelTypeName = ChannelType::StaticStruct()->GetFName();
    const FMovieSceneChannelEntry* FoundEntry = FindEntry(ChannelTypeName);
 
    if (FoundEntry)
    {
        return FoundEntry->GetMetaData();
    }
    return TArrayView<const FMovieSceneChannelMetaData>();
}
 
 
template<typename ChannelType>
TMovieSceneChannelHandle<ChannelType> FMovieSceneChannelProxy::GetChannelByName(FName ChannelName) const
{
    const FMovieSceneChannelHandle UntypedHandle = GetChannelByName(ChannelName);
    const FName ChannelTypeName = ChannelType::StaticStruct()->GetFName();
    // Invalid handles will have a type name of 'None', so we will always fail this test and retrun a null typed handle
    if (UntypedHandle.GetChannelTypeName() == ChannelTypeName)
    {
        return UntypedHandle.Cast<ChannelType>();
    }
    return TMovieSceneChannelHandle<ChannelType>();
}
 
 
#endif  // !WITH_EDITOR