MovieScenePropertyTrack.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Channels/IMovieSceneChannelOverrideProvider.h"
#include "Channels/MovieSceneSectionChannelOverrideRegistry.h"
#include "EntitySystem/BuiltInComponentTypes.h"
#include "EntitySystem/IMovieSceneEntityProvider.h"
#include "EntitySystem/MovieSceneEntityBuilder.h"
#include "EntitySystem/MovieScenePropertyBinding.h"
#include "MovieSceneCommonHelpers.h"
#include "MovieSceneNameableTrack.h"
#include "MovieSceneTracksComponentTypes.h"
#include "Systems/MovieScenePiecewiseBoolBlenderSystem.h"
#include "UObject/ObjectMacros.h"
#include "MovieScenePropertyTrack.generated.h"
 
namespace UE::MovieScene
{
    struct FPropertyDefinition;
}
 
UCLASS(abstract, MinimalAPI)
class UMovieScenePropertyTrack
    : public UMovieSceneNameableTrack
{
    GENERATED_UCLASS_BODY()
 
public:
 
    // UMovieSceneTrack interface
 
    MOVIESCENETRACKS_API virtual void RemoveAllAnimationData() override;
    MOVIESCENETRACKS_API virtual bool HasSection(const UMovieSceneSection& Section) const override;
    MOVIESCENETRACKS_API virtual void AddSection(UMovieSceneSection& Section) override;
    MOVIESCENETRACKS_API virtual void RemoveSection(UMovieSceneSection& Section) override;
    MOVIESCENETRACKS_API virtual void RemoveSectionAt(int32 SectionIndex) override;
    MOVIESCENETRACKS_API virtual bool IsEmpty() const override;
    MOVIESCENETRACKS_API virtual const TArray<UMovieSceneSection*>& GetAllSections() const override;
    virtual void InitializeFromProperty(const FProperty* Property, const UE::MovieScene::FPropertyDefinition* Definition)
    {
    }
 
#if WITH_EDITORONLY_DATA
    MOVIESCENETRACKS_API virtual FText GetDefaultDisplayName() const override;
    MOVIESCENETRACKS_API virtual FText GetDisplayNameToolTipText(const FMovieSceneLabelParams& LabelParams) const override;
    MOVIESCENETRACKS_API virtual FSlateColor GetLabelColor(const FMovieSceneLabelParams& LabelParams) const override;
#endif
    MOVIESCENETRACKS_API virtual FName GetTrackName() const override;
 
    MOVIESCENETRACKS_API virtual void PostLoad() override;
    MOVIESCENETRACKS_API virtual void Serialize(FArchive& Ar) override;
 
public:
 
    MOVIESCENETRACKS_API void SetPropertyNameAndPath(FName InPropertyName, const FString& InPropertyPath);
 
    FName GetPropertyName() const { return PropertyBinding.PropertyName; }
 
    FName GetPropertyPath() const { return PropertyBinding.PropertyPath; }
 
    const FMovieScenePropertyBinding& GetPropertyBinding() const { return PropertyBinding; }
 
    template <typename ValueType>
    TOptional<ValueType> GetCurrentValue(const UObject* Object) const
    {
        return FTrackInstancePropertyBindings::StaticValue<ValueType>(Object, PropertyBinding.PropertyPath.ToString());
    }
 
    MOVIESCENETRACKS_API TArray<UMovieSceneSection*, TInlineAllocator<4>> FindAllSections(FFrameNumber Time);
 
    MOVIESCENETRACKS_API class UMovieSceneSection* FindSection(FFrameNumber Time);
 
    MOVIESCENETRACKS_API class UMovieSceneSection* FindOrExtendSection(FFrameNumber Time, float& OutWeight);
 
    MOVIESCENETRACKS_API class UMovieSceneSection* FindOrAddSection(FFrameNumber Time, bool& bSectionAdded);
 
    MOVIESCENETRACKS_API virtual void SetSectionToKey(UMovieSceneSection* Section) override;
 
    MOVIESCENETRACKS_API virtual UMovieSceneSection* GetSectionToKey() const override;
 
#if WITH_EDITORONLY_DATA
public:
    UE_DEPRECATED(5.6, "UniqueTrackName is deprecated, use GetTrackName instead.")
    UPROPERTY()
    FName UniqueTrackName;
 
    UPROPERTY()
    FName PropertyName_DEPRECATED;
 
    UPROPERTY()
    FString PropertyPath_DEPRECATED;
 
#endif
 
 
private:
    UPROPERTY()
    TObjectPtr<UMovieSceneSection> SectionToKey;
 
protected:
 
    UPROPERTY()
    FMovieScenePropertyBinding PropertyBinding;
 
    UPROPERTY()
    TArray<TObjectPtr<UMovieSceneSection>> Sections;
};
 
 
struct FMovieScenePropertyTrackEntityImportHelper
{
    static MOVIESCENETRACKS_API const int32 SectionPropertyValueImportingID;
    static MOVIESCENETRACKS_API const int32 SectionEditConditionToggleImportingID;
 
    static MOVIESCENETRACKS_API void PopulateEvaluationField(UMovieSceneSection& Section, const TRange<FFrameNumber>& EffectiveRange, const FMovieSceneEvaluationFieldEntityMetaData& InMetaData, FMovieSceneEntityComponentFieldBuilder* OutFieldBuilder);
 
    static MOVIESCENETRACKS_API bool IsPropertyValueID(const UE::MovieScene::FEntityImportParams& Params);
    static MOVIESCENETRACKS_API bool IsEditConditionToggleID(const UE::MovieScene::FEntityImportParams& Params);
    static MOVIESCENETRACKS_API void ImportEditConditionToggleEntity(const UE::MovieScene::FEntityImportParams& Params, UE::MovieScene::FImportedEntity* OutImportedEntity);
 
    static MOVIESCENETRACKS_API FName SanitizeBoolPropertyName(FName InPropertyName);
};
 
 
namespace UE
{
namespace MovieScene
{
 
template<typename... T>
struct TPropertyTrackEntityImportHelperImpl
{
    TPropertyTrackEntityImportHelperImpl(TEntityBuilder<T...>&& InBuilder, FComponentTypeID InPropertyTag = {})
        : Builder(MoveTemp(InBuilder))
        , PropertyTag(InPropertyTag)
    {
    }
 
    template<typename U, typename PayloadType>
    TPropertyTrackEntityImportHelperImpl<T..., TAdd<U>> Add(TComponentTypeID<U> ComponentType, PayloadType&& InPayload)
    {
        return TPropertyTrackEntityImportHelperImpl<T..., TAdd<U>>(Builder.Add(ComponentType, InPayload), PropertyTag);
    }
 
    template<typename U, typename PayloadType>
    TPropertyTrackEntityImportHelperImpl<T..., TAddConditional<U>> AddConditional(TComponentTypeID<U> ComponentType, PayloadType&& InPayload, bool bCondition)
    {
        return TPropertyTrackEntityImportHelperImpl<T..., TAddConditional<U>>(Builder.AddConditional(ComponentType, InPayload, bCondition), PropertyTag);
    }
 
    void Commit(const UMovieSceneSection* InSection, const UE::MovieScene::FEntityImportParams& Params, UE::MovieScene::FImportedEntity* OutImportedEntity)
    {
        const FGuid ObjectBindingID = Params.GetObjectBindingID();
        const FMovieSceneEvaluationFieldEntityMetaData* MetaData = Params.EntityMetaData;
        const FBuiltInComponentTypes* BuiltInComponents = FBuiltInComponentTypes::Get();
        const FMovieSceneTracksComponentTypes* TracksComponents = FMovieSceneTracksComponentTypes::Get();
 
        if (UMovieScenePropertyTrack* PropertyTrack = Cast<UMovieScenePropertyTrack>(InSection->GetOuter()))
        {
            if (FMovieScenePropertyTrackEntityImportHelper::IsPropertyValueID(Params))
            {
                const FName NotifyFunctionName = (MetaData ? MetaData->NotifyFunctionName : NAME_None);
 
                OutImportedEntity->AddBuilder(
                    Builder
                    .Add(BuiltInComponents->PropertyBinding, PropertyTrack->GetPropertyBinding())
                    .AddConditional(BuiltInComponents->GenericObjectBinding, ObjectBindingID, ObjectBindingID.IsValid())
                    .AddConditional(TracksComponents->PropertyNotify, FPropertyNotifyComponentData{ NotifyFunctionName }, !NotifyFunctionName.IsNone()));
            }
            else if (ensure(FMovieScenePropertyTrackEntityImportHelper::IsEditConditionToggleID(Params)))
            {
                // We effectively discard the builder we've been setting up, because we just
                // need to import the edit condition toggle entity.
                FMovieScenePropertyTrackEntityImportHelper::ImportEditConditionToggleEntity(Params, OutImportedEntity);
            }
        }
        else
        {
            OutImportedEntity->AddBuilder(
                Builder
                .AddConditional(BuiltInComponents->GenericObjectBinding, ObjectBindingID, ObjectBindingID.IsValid()));
        }
    }
 
protected:
 
    TEntityBuilder<T...> Builder;
    FComponentTypeID PropertyTag;
};
 
 
template<>
struct TPropertyTrackEntityImportHelperImpl<>
{
    TPropertyTrackEntityImportHelperImpl(FComponentTypeID InPropertyTag)
        : Builder(FEntityBuilder().AddTag(InPropertyTag))
        , PropertyTag(InPropertyTag)
    {
    }
 
    template<typename U, typename PayloadType>
    TPropertyTrackEntityImportHelperImpl<FAdd, TAdd<U>> Add(TComponentTypeID<U> ComponentType, PayloadType&& InPayload)
    {
        return TPropertyTrackEntityImportHelperImpl<FAdd, TAdd<U>>(Builder.Add(ComponentType, InPayload), PropertyTag);
    }
 
    template<typename U, typename PayloadType>
    TPropertyTrackEntityImportHelperImpl<FAdd, TAddConditional<U>> AddConditional(TComponentTypeID<U> ComponentType, PayloadType&& InPayload, bool bCondition)
    {
        return TPropertyTrackEntityImportHelperImpl<FAdd, TAddConditional<U>>(Builder.AddConditional(ComponentType, InPayload, bCondition), PropertyTag);
    }
 
protected:
 
    TEntityBuilder<FAdd> Builder;
    FComponentTypeID PropertyTag;
};
 
struct FPropertyTrackEntityImportHelper : TPropertyTrackEntityImportHelperImpl<>
{
    template<typename PropertyTraits>
    FPropertyTrackEntityImportHelper(const TPropertyComponents<PropertyTraits>& PropertyComponents)
        : TPropertyTrackEntityImportHelperImpl<>(PropertyComponents.PropertyTag)
    {}
};
 
struct FPropertyTrackEntityImportHelperParamsImpl
{
    FPropertyTrackEntityImportHelperParamsImpl(TScriptInterface<IMovieSceneChannelOverrideProvider> InRegistryProvider)
        : RegistryProvider(InRegistryProvider)
    {
        if (InRegistryProvider)
        {
            Registry = InRegistryProvider->GetChannelOverrideRegistry(false);
        }
    }
    TScriptInterface<IMovieSceneChannelOverrideProvider> RegistryProvider;
    TObjectPtr<UMovieSceneSectionChannelOverrideRegistry> Registry;
    TArray<FChannelOverrideEntityImportParams> ImportParams;
};
 
template<typename... T>
struct TPropertyTrackWithOverridableChannelsEntityImportHelperImpl
{
    TPropertyTrackWithOverridableChannelsEntityImportHelperImpl(TEntityBuilder<T...>&& InBuilder, FPropertyTrackEntityImportHelperParamsImpl& InOverrideInfo, FComponentTypeID InPropertyTag = {})
        : Builder(MoveTemp(InBuilder))
        , OverrideInfo(InOverrideInfo)
        , PropertyTag(InPropertyTag)
    {
    }
 
    template<typename U, typename PayloadType>
    TPropertyTrackEntityImportHelperImpl<T..., TAddConditional<U>> Add(TComponentTypeID<U> ComponentType, PayloadType&& InPayload, FChannelOverrideEntityImportParams OverrideParams)
    {
        const bool bOverriden = (OverrideInfo.Registry && OverrideInfo.Registry->ContainsChannel(OverrideParams.ChannelName));
        if (bOverriden)
        {
            OverrideInfo.ImportParams.Add(MoveTemp(OverrideParams));
        }
        return TPropertyTrackEntityImportHelperImpl<T..., TAddConditional<U>>(Builder.Add(ComponentType, InPayload, !bOverriden), OverrideInfo, PropertyTag);
    }
 
    template<typename U, typename PayloadType>
    TPropertyTrackEntityImportHelperImpl<T..., TAddConditional<U>> AddConditional(TComponentTypeID<U> ComponentType, PayloadType&& InPayload, bool bCondition, FChannelOverrideEntityImportParams OverrideParams)
    {
        const bool bOverriden = (OverrideInfo.Registry && OverrideInfo.Registry->ContainsChannel(OverrideParams.ChannelName));
        if (bOverriden)
        {
            OverrideInfo.ImportParams.Add(MoveTemp(OverrideParams));
        }
        return TPropertyTrackEntityImportHelperImpl<T..., TAddConditional<U>>(Builder.AddConditional(ComponentType, InPayload, bCondition && !bOverriden), OverrideInfo, PropertyTag);
    }
 
    void Commit(const UMovieSceneSection* InSection, const UE::MovieScene::FEntityImportParams& Params, UE::MovieScene::FImportedEntity* OutImportedEntity)
    {
        const FGuid ObjectBindingID = Params.GetObjectBindingID();
        const FMovieSceneEvaluationFieldEntityMetaData* MetaData = Params.EntityMetaData;
        const FBuiltInComponentTypes* BuiltInComponents = FBuiltInComponentTypes::Get();
        const FMovieSceneTracksComponentTypes* TracksComponents = FMovieSceneTracksComponentTypes::Get();
 
        if (UMovieScenePropertyTrack* PropertyTrack = Cast<UMovieScenePropertyTrack>(InSection->GetOuter()))
        {
            if (FMovieScenePropertyTrackEntityImportHelper::IsPropertyValueID(Params))
            {
                const FName NotifyFunctionName = (MetaData ? MetaData->NotifyFunctionName : NAME_None);
 
                OutImportedEntity->AddBuilder(
                    Builder
                    .Add(BuiltInComponents->PropertyBinding, PropertyTrack->GetPropertyBinding())
                    .AddConditional(BuiltInComponents->GenericObjectBinding, ObjectBindingID, ObjectBindingID.IsValid())
                    .AddConditional(TracksComponents->PropertyNotify, FPropertyNotifyComponentData{ NotifyFunctionName }, !NotifyFunctionName.IsNone()));
            }
            else if (FMovieScenePropertyTrackEntityImportHelper::IsEditConditionToggleID(Params))
            {
                // We effectively discard the builder we've been setting up, because we just
                // need to import the edit condition toggle entity.
                FMovieScenePropertyTrackEntityImportHelper::ImportEditConditionToggleEntity(Params, OutImportedEntity);
            }
            else if (ensure(OverrideInfo.Registry))
            {
                // This should be an overriden channel, which goes into a different entity.
                if (ensure(OverrideInfo.RegistryProvider))
                {
                    auto BaseBuilder = FEntityBuilder()
                        .Add(BuiltInComponents->PropertyBinding, PropertyTrack->GetPropertyBinding())
                        .AddConditional(BuiltInComponents->GenericObjectBinding, ObjectBindingID, ObjectBindingID.IsValid())
                        .AddTag(PropertyTag);
                    OutImportedEntity->AddBuilder(BaseBuilder);
                
                    FChannelOverrideProviderTraitsHandle Traits = OverrideInfo.RegistryProvider->GetChannelOverrideProviderTraits();
                    check(Traits.IsValid());
                    const FName ChannelOverrideName = Traits->GetChannelOverrideName(Params.EntityID);
                    auto* ChannelOverrideParams = OverrideInfo.ImportParams.FindByPredicate(
                            [=](const FChannelOverrideEntityImportParams& CurParams)
                            {
                                return CurParams.ChannelName == ChannelOverrideName;
                            });
                    if (ensure(ChannelOverrideParams))
                    {
                        OverrideInfo.Registry->ImportEntityImpl(*ChannelOverrideParams, Params, OutImportedEntity);
                    }
                }
            }
        }
        else
        {
            OutImportedEntity->AddBuilder(
                Builder
                .AddConditional(BuiltInComponents->GenericObjectBinding, ObjectBindingID, ObjectBindingID.IsValid()));
        }
    }
 
protected:
 
    TEntityBuilder<T...> Builder;
    FPropertyTrackEntityImportHelperParamsImpl OverrideInfo;
    FComponentTypeID PropertyTag;
};
 
 
template<>
struct TPropertyTrackWithOverridableChannelsEntityImportHelperImpl<>
{
    TPropertyTrackWithOverridableChannelsEntityImportHelperImpl(FComponentTypeID InPropertyTag, TScriptInterface<IMovieSceneChannelOverrideProvider> InRegistryProvider)
        : Builder(FEntityBuilder().AddTag(InPropertyTag))
        , OverrideInfo(InRegistryProvider)
        , PropertyTag(InPropertyTag)
    {
    }
 
    template<typename U, typename PayloadType>
    TPropertyTrackWithOverridableChannelsEntityImportHelperImpl<FAdd, TAddConditional<U>> Add(TComponentTypeID<U> ComponentType, PayloadType&& InPayload, FChannelOverrideEntityImportParams OverrideParams)
    {
        const bool bOverriden = (OverrideInfo.Registry && OverrideInfo.Registry->ContainsChannel(OverrideParams.ChannelName));
        if (bOverriden)
        {
            OverrideInfo.ImportParams.Add(MoveTemp(OverrideParams));
        }
        return TPropertyTrackWithOverridableChannelsEntityImportHelperImpl<FAdd, TAddConditional<U>>(Builder.AddConditional(ComponentType, InPayload, !bOverriden), OverrideInfo, PropertyTag);
    }
 
    template<typename U, typename PayloadType>
    TPropertyTrackWithOverridableChannelsEntityImportHelperImpl<FAdd, TAddConditional<U>> AddConditional(TComponentTypeID<U> ComponentType, PayloadType&& InPayload, bool bCondition, FChannelOverrideEntityImportParams OverrideParams)
    {
        const bool bOverriden = (OverrideInfo.Registry && OverrideInfo.Registry->ContainsChannel(OverrideParams.ChannelName));
        if (bOverriden)
        {
            OverrideInfo.ImportParams.Add(MoveTemp(OverrideParams));
        }
        return TPropertyTrackWithOverridableChannelsEntityImportHelperImpl<FAdd, TAddConditional<U>>(Builder.AddConditional(ComponentType, InPayload, bCondition && !bOverriden), OverrideInfo, PropertyTag);
    }
 
protected:
 
    TEntityBuilder<FAdd> Builder;
    FPropertyTrackEntityImportHelperParamsImpl OverrideInfo;
    FComponentTypeID PropertyTag;
};
 
struct FPropertyTrackWithOverridableChannelsEntityImportHelper : TPropertyTrackWithOverridableChannelsEntityImportHelperImpl<>
{
    template<typename PropertyTraits>
    FPropertyTrackWithOverridableChannelsEntityImportHelper(const TPropertyComponents<PropertyTraits>& PropertyComponents, TScriptInterface<IMovieSceneChannelOverrideProvider> InRegistryProvider)
        : TPropertyTrackWithOverridableChannelsEntityImportHelperImpl<>(PropertyComponents.PropertyTag, InRegistryProvider)
    {}
};
 
}
}