MovieSceneTrack.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Compilation/MovieSceneSegmentCompiler.h"
#include "IMovieSceneTrackVirtualAPI.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "Evaluation/Blending/MovieSceneBlendType.h"
#include "Evaluation/MovieSceneEvaluationField.h"
#include "Decorations/MovieSceneDecorationContainer.h"
#include "HAL/Platform.h"
#include "Internationalization/Text.h"
#include "Math/Color.h"
#include "Misc/AssertionMacros.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/Guid.h"
#include "Misc/InlineValue.h"
#include "MovieSceneSignedObject.h"
#include "MovieSceneTrackEvaluationField.h"
#include "Templates/SubclassOf.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectMacros.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/UnrealNames.h"
#include "UObject/UnrealType.h"
#include "Conditions/MovieSceneCondition.h"
 
#if WITH_EDITOR
#include "Styling/SlateColor.h"
#endif
 
#include "MovieSceneTrack.generated.h"
 
class UMovieSceneSection;
class UObject;
struct FMovieSceneEvaluationTrack;
struct FMovieSceneTrackRowSegmentBlender;
struct FMovieSceneTrackSegmentBlender;
struct IMovieSceneTemplateGenerator;
struct FMovieSceneConditionContainer;
template<typename> struct TMovieSceneEvaluationTree;
 
enum class ECookOptimizationFlags
{
    None            = 0,
    RemoveTrack     = 1 << 0,
    RemoveObject    = 1 << 1,
    RemoveSection   = 1 << 2,
};
ENUM_CLASS_FLAGS(ECookOptimizationFlags)
 
 
USTRUCT()
struct FMovieSceneTrackEvalOptions
{
    GENERATED_BODY()
    
    FMovieSceneTrackEvalOptions()
        : bCanEvaluateNearestSection(false)
        , bEvalNearestSection(false)
        , bEvaluateInPreroll(false)
        , bEvaluateInPostroll(false)
        , bEvaluateNearestSection_DEPRECATED(false)
    {}
 
    UPROPERTY()
    uint32 bCanEvaluateNearestSection : 1;
 
    UPROPERTY(EditAnywhere, Category="Track", DisplayName="Evaluate Nearest Section", meta=(EditCondition=bCanEvaluateNearestSection, HideEditConditionToggle))
    uint32 bEvalNearestSection : 1;
 
    UPROPERTY(EditAnywhere, Category="Track")
    uint32 bEvaluateInPreroll : 1;
 
    UPROPERTY(EditAnywhere, Category="Track")
    uint32 bEvaluateInPostroll : 1;
 
    UPROPERTY()
    uint32 bEvaluateNearestSection_DEPRECATED : 1;
};
 
 
USTRUCT()
struct FMovieSceneTrackDisplayOptions
{
    GENERATED_BODY()
 
    FMovieSceneTrackDisplayOptions()
        : bShowVerticalFrames(false)
    {}
 
    UPROPERTY(EditAnywhere, Category = "Track")
    uint32 bShowVerticalFrames : 1;
};
 
enum class EMovieSceneTrackEasingSupportFlags
{
    None = 0,
    AutomaticEaseIn = 1 << 0,
    AutomaticEaseOut = 1 << 1,
    ManualEaseIn = 1 << 2,
    ManualEaseOut = 1 << 3,
    AutomaticEasing = AutomaticEaseIn | AutomaticEaseOut,
    ManualEasing = ManualEaseIn | ManualEaseOut,
    All = AutomaticEasing | ManualEasing
};
ENUM_CLASS_FLAGS(EMovieSceneTrackEasingSupportFlags)
 
 
struct FMovieSceneSupportsEasingParams
{
    // Non-null if we are asking for a specific section.
    const UMovieSceneSection* ForSection;
 
    FMovieSceneSupportsEasingParams() : ForSection(nullptr) {}
    FMovieSceneSupportsEasingParams(const UMovieSceneSection* InSection) : ForSection(InSection) {}
};
 
struct FMovieSceneTrackPreCompileResult
{
    FMovieSceneEvaluationFieldEntityMetaData DefaultMetaData;
};
 
#if WITH_EDITOR
struct FMovieSceneSectionMovedParams
{
    EPropertyChangeType::Type MoveType;
 
    FMovieSceneSectionMovedParams(EPropertyChangeType::Type InMoveType) : MoveType(InMoveType) {}
};
 
enum class EMovieSceneSectionMovedResult
{
    None = 0,
    SectionsChanged = 1
};
ENUM_CLASS_FLAGS(EMovieSceneSectionMovedResult);
 
struct FMovieSceneLabelParams
{
    class IMovieScenePlayer* Player = nullptr;
    FGuid BindingID;
    FMovieSceneSequenceID SequenceID;
    bool bIsDimmed = false;
};
#endif
 
/* Metadata tied to a track row. */
USTRUCT()
struct FMovieSceneTrackRowMetadata
{
    GENERATED_BODY()
    
    /* Optional dynamic conditions tied to specific track rows. */
    UPROPERTY(EditAnywhere, Category="Track Row", meta=(ShowOnlyInnerProperties))
    FMovieSceneConditionContainer ConditionContainer;
};
 
 
// Disable some VS warnings that are emitted by Add/RemoveSection functions hiding the
//    private virtual methods in IMovieSceneTrackVirtualAPI
#if PLATFORM_COMPILER_CLANG
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Woverloaded-virtual"
#elif PLATFORM_MICROSOFT
    #pragma warning(push)
    #pragma warning(disable:4263)
    #pragma warning(disable:4264)
#else
    static_assert(false, "Unexpected compiler detected");
#endif
 
UCLASS(abstract, DefaultToInstanced, MinimalAPI, BlueprintType)
class UMovieSceneTrack
    : public UMovieSceneDecorationContainerObject
    , public IMovieSceneTrackVirtualAPI
{
    GENERATED_BODY()
 
public:
 
    MOVIESCENE_API UMovieSceneTrack(const FObjectInitializer& InInitializer);
    ~UMovieSceneTrack() {};
 
public:
 
    UPROPERTY(EditAnywhere, Category = "Track", meta = (ShowOnlyInnerProperties))
    FMovieSceneTrackEvalOptions EvalOptions;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category = "Track", meta = (ShowOnlyInnerProperties))
    FMovieSceneTrackDisplayOptions DisplayOptions;
#endif
 
    UPROPERTY(EditAnywhere, Category = "Track")
    FMovieSceneConditionContainer ConditionContainer;
 
    FMovieSceneBlendTypeField GetSupportedBlendTypes() const
    {
        return SupportedBlendTypes;
    }
 
    MOVIESCENE_API virtual FMovieSceneTrackRowSegmentBlenderPtr GetRowSegmentBlender() const;
 
    MOVIESCENE_API virtual FMovieSceneTrackSegmentBlenderPtr GetTrackSegmentBlender() const;
 
    MOVIESCENE_API virtual void UpdateEasing();
 
 
    void OnAddedToMovieScene(UMovieScene* MovieScene);
    void OnRemovedFromMovieScene();
 
protected:
 
    //~ UObject interface
    MOVIESCENE_API virtual void PostInitProperties() override;
    MOVIESCENE_API virtual void PostLoad() override;
    MOVIESCENE_API virtual bool IsPostLoadThreadSafe() const override;
 
    MOVIESCENE_API virtual void OnDecorationAdded(UObject* NewDecoration) override;
    MOVIESCENE_API virtual void OnDecorationRemoved(UObject* Decoration) override;
 
    FMovieSceneBlendTypeField SupportedBlendTypes;
 
    UPROPERTY()
    bool bIsEvalDisabled;
 
    UPROPERTY()
    TArray<int32> RowsDisabled;
 
#if WITH_EDITORONLY_DATA
 
    UPROPERTY(Transient)
    bool bIsLocalEvalDisabled;
 
    UPROPERTY(Transient)
    TArray<int32> LocalRowsDisabled;
 
#endif
 
public:
 
    void PreCompile(FMovieSceneTrackPreCompileResult& OutPreCompileResult);
 
    MOVIESCENE_API const FMovieSceneTrackEvaluationField& GetEvaluationField();
 
    virtual int8 GetEvaluationFieldVersion() const { return 0; }
 
    MOVIESCENE_API FGuid FindObjectBindingGuid() const;
 
protected:
 
    enum class ETreePopulationMode : uint8
    {
        None,
        Blended,
        HighPass,
        HighPassPerRow,
    };
 
    ETreePopulationMode BuiltInTreePopulationMode;
 
protected:
 
    MOVIESCENE_API void ForceUpdateEvaluationTree();
 
private:
 
    virtual bool PopulateEvaluationTree(TMovieSceneEvaluationTree<FMovieSceneTrackEvaluationData>& OutData) const
    {
        return false;
    }
 
    virtual void PreCompileImpl(FMovieSceneTrackPreCompileResult& OutPreCompileResult)
    {
    }
 
    virtual void OnAddedToMovieSceneImpl(UMovieScene* InMovieScene)
    {
    }
 
    virtual void OnRemovedFromMovieSceneImpl()
    {
    }
 
private:
 
    void UpdateEvaluationTree();
    void AddSectionRangesToTree(TArrayView<UMovieSceneSection* const> Sections, TMovieSceneEvaluationTree<FMovieSceneTrackEvaluationData>& OutData);
    void AddSectionPrePostRollRangesToTree(TArrayView<UMovieSceneSection* const> Sections, TMovieSceneEvaluationTree<FMovieSceneTrackEvaluationData>& OutData);
 
    UPROPERTY()
    FGuid EvaluationFieldGuid;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    int8 EvaluationFieldVersion;
#endif
 
    UPROPERTY()
    FMovieSceneTrackEvaluationField EvaluationField;
 
    /* Optional extra metadata tied to specific track rows. */
    UPROPERTY()
    TMap<int32, FMovieSceneTrackRowMetadata> TrackRowMetadata;
 
public:
 
    virtual FName GetTrackName() const { return NAME_None; }
 
    virtual bool IsEmpty() const PURE_VIRTUAL(UMovieSceneTrack::IsEmpty, return true;);
 
    virtual void RemoveAllAnimationData() { }
 
    virtual bool SupportsMultipleRows() const
    {
        return SupportedBlendTypes.Num() != 0;
    }
 
    virtual EMovieSceneTrackEasingSupportFlags SupportsEasing(FMovieSceneSupportsEasingParams& Params) const
    {
        return SupportedBlendTypes.Num() > 0 ? EMovieSceneTrackEasingSupportFlags::All : EMovieSceneTrackEasingSupportFlags::None;
    }
 
     virtual void SetSectionToKey(UMovieSceneSection* InSection) {};
 
     virtual UMovieSceneSection* GetSectionToKey() const { return nullptr; }
 
    MOVIESCENE_API int32 GetMaxRowIndex() const;
 
    MOVIESCENE_API virtual bool FixRowIndices();
 
    MOVIESCENE_API virtual void OnRowIndicesChanged(const TMap<int32, int32>& NewToOldRowIndices);
 
    MOVIESCENE_API bool IsEvalDisabled(const bool bInCheckLocal = true) const;
    MOVIESCENE_API bool IsRowEvalDisabled(const int32 InRowIndex, const bool bInCheckLocal = true) const;
 
    void SetEvalDisabled(const bool bInEvalDisabled) { bIsEvalDisabled = bInEvalDisabled; }
    MOVIESCENE_API void SetRowEvalDisabled(const bool bInEvalDisabled, const int32 InRowIndex);
 
#if WITH_EDITOR
 
    bool IsLocalEvalDisabled() const { return bIsLocalEvalDisabled; }
    MOVIESCENE_API bool IsLocalRowEvalDisabled(const int32 InRowIndex) const;
 
    void SetLocalEvalDisabled(const bool bInEvalDisabled) { bIsLocalEvalDisabled = bInEvalDisabled; }
    MOVIESCENE_API void SetLocalRowEvalDisabled(const bool bInEvalDisabled, int32 InRowIndex);
 
#endif
 
    /*
     * Returns a pointer to optional track row metadata at the given RowIndex, or nullptr if none exists.
     */
    MOVIESCENE_API const FMovieSceneTrackRowMetadata* FindTrackRowMetadata(int32 RowIndex) const;
 
    /*
     * Returns a pointer to optional track row metadata at the given RowIndex, or nullptr if none exists;
     */
    MOVIESCENE_API FMovieSceneTrackRowMetadata* FindTrackRowMetadata(int32 RowIndex);
 
    /*
     * Returns a pointer to optional track row metadata at the given RowIndex, or nullptr if none exists;
     */
    MOVIESCENE_API FMovieSceneTrackRowMetadata& FindOrAddTrackRowMetadata(int32 RowIndex);
 
public:
 
    /*
     * Does this track support this section class type?
 
     * @param ClassType The movie scene section class type
     * @return Whether this track supports this section class type
     */
    virtual bool SupportsType(TSubclassOf<UMovieSceneSection> SectionClass) const PURE_VIRTUAL(UMovieSceneTrack::SupportsType, return false;);
 
    // Parameter structs that only exist to differentiate overloads from IMovieSceneTrackVirtualAPI
    struct FSectionParameter
    {
        FSectionParameter(UMovieSceneSection& InSection) : Section(&InSection) {};
        UMovieSceneSection* Section;
    };
    struct FSectionIndexParameter
    {
        FSectionIndexParameter(int32 InSectionIndex) : SectionIndex(InSectionIndex) {};
        int32 SectionIndex;
    };
 
    MOVIESCENE_API void AddSection(FSectionParameter Section);
 
    MOVIESCENE_API void RemoveSection(FSectionParameter Section);
 
    MOVIESCENE_API void RemoveSectionAt(FSectionIndexParameter SectionIndex);
 
public:
    virtual class UMovieSceneSection* CreateNewSection() PURE_VIRTUAL(UMovieSceneTrack::CreateNewSection, return nullptr;);
    
    virtual const TArray<UMovieSceneSection*>& GetAllSections() const PURE_VIRTUAL(UMovieSceneTrack::GetAllSections, static TArray<UMovieSceneSection*> Empty; return Empty;);
 
    virtual bool HasSection(const UMovieSceneSection& Section) const PURE_VIRTUAL(UMovieSceneTrack::HasSection, return false;);
 
private:
 
    virtual void OnSectionAddedImpl(UMovieSceneSection* Section)
    {
    }
 
    virtual void OnSectionRemovedImpl(UMovieSceneSection* Section)
    {
    }
 
public:
 
#if WITH_EDITOR
 
    MOVIESCENE_API virtual ECookOptimizationFlags GetCookOptimizationFlags() const;
 
    MOVIESCENE_API virtual void RemoveForCook();
 
    static bool RemoveMutedTracksOnCook();
 
#endif
 
#if WITH_EDITORONLY_DATA
 
    virtual FText GetDisplayName() const PURE_VIRTUAL(UMovieSceneTrack::GetDisplayName, return FText::FromString(TEXT("Unnamed Track")););
 
    virtual FText GetTrackRowDisplayName(int32 RowIndex) const { return FText::FromString(TEXT("Unnamed Track")); }
 
    virtual FText GetDisplayNameToolTipText(const FMovieSceneLabelParams& LabelParams) const { return FText::GetEmpty(); }
 
    virtual FSlateColor GetLabelColor(const FMovieSceneLabelParams& LabelParams) const { return FSlateColor::UseForeground(); }
 
    const FColor& GetColorTint() const
    {
        return TrackTint;
    }
 
    void SetColorTint(const FColor& InTrackTint)
    {
        TrackTint = InTrackTint;
    }
 
    int32 GetSortingOrder() const
    {
        return SortingOrder;
    }
 
    void SetSortingOrder(const int32 InSortingOrder)
    {
        SortingOrder = InSortingOrder;
    }
 
    virtual bool SupportsDefaultSections() const
    {
        return bSupportsDefaultSections;
    }
 
    virtual bool SupportsConditions() const
    {
        return bSupportsConditions;
    }
 
    /*
    * Returns an array of all conditions on track, track row, or section
    */
    MOVIESCENE_API TArray<UMovieSceneCondition*> GetAllConditions();
 
protected:
 
    UPROPERTY()
    FGuid ObjectBindingID;
 
    UPROPERTY(EditAnywhere, Category="Track", DisplayName = Color)
    FColor TrackTint;
 
    UPROPERTY()
    int32 SortingOrder;
 
    UPROPERTY()
    bool bSupportsDefaultSections;
 
    UPROPERTY()
    bool bSupportsConditions;
 
public:
#endif
 
#if WITH_EDITOR
    virtual EMovieSceneSectionMovedResult OnSectionMoved(UMovieSceneSection& Section, const FMovieSceneSectionMovedParams& Params)
    {
        return EMovieSceneSectionMovedResult::None;
    }
 
    #endif
};
 
#if PLATFORM_COMPILER_CLANG
    #pragma clang diagnostic pop
#elif PLATFORM_MICROSOFT
    #pragma warning(pop)
#endif