MovieSceneEvaluationField.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/Set.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "EntitySystem/MovieSceneEntityIDs.h"
#include "EntitySystem/MovieSceneEntitySystemTypes.h"
#include "Evaluation/MovieSceneEvaluationKey.h"
#include "Evaluation/MovieSceneEvaluationTree.h"
#include "Evaluation/MovieSceneSegment.h"
#include "Evaluation/MovieSceneTrackIdentifier.h"
#include "Math/NumericLimits.h"
#include "Math/Range.h"
#include "Misc/FrameNumber.h"
#include "Misc/Guid.h"
#include "MovieSceneFrameMigration.h"
#include "MovieSceneSequenceID.h"
#include "Serialization/Archive.h"
#include "Templates/Function.h"
#include "Templates/TypeHash.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/Class.h"
#include "UObject/ObjectMacros.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
#include "MovieSceneEvaluationField.generated.h"
 
class UMovieSceneSequence;
class UObject;
struct FFrameNumber;
struct FMovieSceneSequenceHierarchy;
struct IMovieSceneSequenceTemplateStore;
class UMovieSceneCondition;
 
 
USTRUCT()
struct FMovieSceneEvaluationFieldEntityKey
{
    GENERATED_BODY()
 
    friend bool operator==(FMovieSceneEvaluationFieldEntityKey A, FMovieSceneEvaluationFieldEntityKey B)
    {
        return A.EntityOwner == B.EntityOwner && A.EntityID == B.EntityID;
    }
    friend bool operator!=(FMovieSceneEvaluationFieldEntityKey A, FMovieSceneEvaluationFieldEntityKey B)
    {
        return !(A == B);
    }
    friend uint32 GetTypeHash(FMovieSceneEvaluationFieldEntityKey In)
    {
        return GetTypeHash(In.EntityOwner) ^ In.EntityID;
    }
 
    UPROPERTY()
    TWeakObjectPtr<UObject> EntityOwner;
 
    UPROPERTY()
    uint32 EntityID = 0;
};
 
 
 
USTRUCT()
struct FMovieSceneEvaluationFieldEntity
{
public:
 
    GENERATED_BODY()
 
    FMovieSceneEvaluationFieldEntity()
        : SharedMetaDataIndex(INDEX_NONE)
    {}
 
    FMovieSceneEvaluationFieldEntity(const FMovieSceneEvaluationFieldEntityKey& InKey, int32 InSharedMetaDataIndex = INDEX_NONE)
        : Key(InKey)
        , SharedMetaDataIndex(InSharedMetaDataIndex)
    {}
 
    UPROPERTY()
    FMovieSceneEvaluationFieldEntityKey Key;
 
    UPROPERTY()
    int32 SharedMetaDataIndex;
};
 
USTRUCT()
struct FMovieSceneEvaluationFieldSharedEntityMetaData
{
    GENERATED_BODY()
 
    UPROPERTY()
    FGuid ObjectBindingID;
};
 
USTRUCT()
struct FMovieSceneEvaluationFieldEntityMetaData
{
    GENERATED_BODY()
 
    FMovieSceneEvaluationFieldEntityMetaData()
        : ForcedTime(TNumericLimits<int32>::Lowest())
        , Flags(ESectionEvaluationFlags::None)
        , bEvaluateInSequencePreRoll(false)
        , bEvaluateInSequencePostRoll(false)
    {}
 
    bool IsRedundant() const
    {
        return *this == FMovieSceneEvaluationFieldEntityMetaData();
    }
 
    friend bool operator==(const FMovieSceneEvaluationFieldEntityMetaData& A, const FMovieSceneEvaluationFieldEntityMetaData& B)
    {
        return A.ForcedTime == B.ForcedTime && 
            A.Flags == B.Flags && 
            A.bEvaluateInSequencePreRoll == B.bEvaluateInSequencePreRoll && 
            A.bEvaluateInSequencePostRoll == B.bEvaluateInSequencePostRoll &&
            A.OverrideBoundPropertyPath == B.OverrideBoundPropertyPath &&
            A.NotifyFunctionName == B.NotifyFunctionName &&
            A.Condition == B.Condition;
    }
 
    /* Optional condition that the entity can provide to be checked at runtime before import. If the condition fails, the entity will not be imported. 
    */
    UPROPERTY()
    TSoftObjectPtr<const UMovieSceneCondition> Condition;
 
    UPROPERTY()
    FString OverrideBoundPropertyPath;
 
    UPROPERTY()
    FName NotifyFunctionName;
 
    UPROPERTY()
    FFrameNumber ForcedTime;
 
    UPROPERTY()
    ESectionEvaluationFlags Flags;
 
    UPROPERTY()
    uint8 bEvaluateInSequencePreRoll : 1;
 
    UPROPERTY()
    uint8 bEvaluateInSequencePostRoll : 1;
};
 
struct FMovieSceneEvaluationFieldEntityQuery
{
    FMovieSceneEvaluationFieldEntity Entity;
    int32 MetaDataIndex;
};
 
struct FMovieSceneEvaluationFieldEntityKeyFuncs : BaseKeyFuncs<FMovieSceneEvaluationFieldEntityQuery,FMovieSceneEvaluationFieldEntityKey,false>
{
    static inline FMovieSceneEvaluationFieldEntityKey GetSetKey(const FMovieSceneEvaluationFieldEntityQuery& Element)        { return Element.Entity.Key; }
    static inline bool Matches(const FMovieSceneEvaluationFieldEntityKey& A, const FMovieSceneEvaluationFieldEntityKey& B)   { return A == B;      }
    static inline uint32 GetKeyHash(const FMovieSceneEvaluationFieldEntityKey& Key)                                          { return GetTypeHash(Key); }
};
using FMovieSceneEvaluationFieldEntitySet = TSet<FMovieSceneEvaluationFieldEntityQuery, FMovieSceneEvaluationFieldEntityKeyFuncs>;
 
USTRUCT()
struct FMovieSceneEvaluationFieldEntityTree
{
    GENERATED_BODY()
 
    bool Serialize(FArchive& Ar)
    {
        Ar << SerializedData;
        return true;
    }
 
    bool Identical(const FMovieSceneEvaluationFieldEntityTree* Other, uint32 PortFlags) const
    {
        return Other->SerializedData == SerializedData;
    }
 
    struct FEntityAndMetaDataIndex
    {
        int32 EntityIndex;
        int32 MetaDataIndex;
 
        friend FArchive& operator<<(FArchive& Ar, FEntityAndMetaDataIndex& In)
        {
            return Ar << In.EntityIndex << In.MetaDataIndex;
        }
        friend bool operator==(const FEntityAndMetaDataIndex& A, const FEntityAndMetaDataIndex& B)
        {
            return A.EntityIndex == B.EntityIndex && A.MetaDataIndex == B.MetaDataIndex;
        }
    };
    TMovieSceneEvaluationTree<FEntityAndMetaDataIndex> SerializedData;
};
template<> struct TStructOpsTypeTraits<FMovieSceneEvaluationFieldEntityTree> : public TStructOpsTypeTraitsBase2<FMovieSceneEvaluationFieldEntityTree>
{
    enum { WithSerializer = true, WithIdentical = true, WithCopy = false };
};
 
 
 
USTRUCT()
struct FMovieSceneEntityComponentField
{
    GENERATED_BODY()
 
    
    bool IsEmpty() const
    {
        return Entities.Num() == 0;
    }
 
    const FMovieSceneEvaluationFieldEntity& GetEntity(int32 EntityIndex) const
    {
        return Entities[EntityIndex];
    }
 
    const FMovieSceneEvaluationFieldEntityMetaData* FindMetaData(const FMovieSceneEvaluationFieldEntityQuery& InQuery) const
    {
        return InQuery.MetaDataIndex != INDEX_NONE ? &EntityMetaData[InQuery.MetaDataIndex] : nullptr;
    }
 
    const FMovieSceneEvaluationFieldSharedEntityMetaData* FindSharedMetaData(const FMovieSceneEvaluationFieldEntityQuery& InQuery) const
    {
        return InQuery.Entity.SharedMetaDataIndex != INDEX_NONE ? &SharedMetaData[InQuery.Entity.SharedMetaDataIndex] : nullptr;
    }
 
    MOVIESCENE_API void QueryPersistentEntities(FFrameNumber QueryTime, TRange<FFrameNumber>& OutRange, FMovieSceneEvaluationFieldEntitySet& OutEntities) const;
 
    MOVIESCENE_API void QueryPersistentEntities(FFrameNumber QueryTime, TFunctionRef<bool(const FMovieSceneEvaluationFieldEntityQuery&)> QueryCallback, TRange<FFrameNumber>& OutRange) const;
 
    MOVIESCENE_API bool HasAnyOneShotEntities() const;
 
    MOVIESCENE_API void QueryOneShotEntities(const TRange<FFrameNumber>& QueryRange, FMovieSceneEvaluationFieldEntitySet& OutEntityIndices) const;
 
private:
 
    friend struct FMovieSceneEntityComponentFieldBuilder;
 
    UPROPERTY()
    FMovieSceneEvaluationFieldEntityTree PersistentEntityTree;
 
    UPROPERTY()
    FMovieSceneEvaluationFieldEntityTree OneShotEntityTree;
 
    UPROPERTY()
    TArray<FMovieSceneEvaluationFieldEntity> Entities;
 
    UPROPERTY()
    TArray<FMovieSceneEvaluationFieldEntityMetaData> EntityMetaData;
 
    UPROPERTY()
    TArray<FMovieSceneEvaluationFieldSharedEntityMetaData> SharedMetaData;
};
 
 
struct FMovieSceneEntityComponentFieldBuilder
{
    static constexpr uint32 InvalidEntityID = ~0u;
 
    MOVIESCENE_API FMovieSceneEntityComponentFieldBuilder(FMovieSceneEntityComponentField* InField);
 
    MOVIESCENE_API ~FMovieSceneEntityComponentFieldBuilder();
 
    MOVIESCENE_API FMovieSceneEvaluationFieldSharedEntityMetaData& GetSharedMetaData();
 
    MOVIESCENE_API int32 GetSharedMetaDataIndex() const;
 
    MOVIESCENE_API int32 AddMetaData(const FMovieSceneEvaluationFieldEntityMetaData& InMetaData);
 
    MOVIESCENE_API int32 FindOrAddEntity(UObject* EntityOwner, uint32 EntityID = 0);
 
    MOVIESCENE_API void AddPersistentEntity(const TRange<FFrameNumber>& Range, UObject* EntityOwner, uint32 EntityID = 0, int32 InMetaDataIndex = INDEX_NONE);
 
    MOVIESCENE_API void AddPersistentEntity(const TRange<FFrameNumber>& Range, int32 LocalIndex, int32 InMetaDataIndex = INDEX_NONE);
 
    MOVIESCENE_API void AddOneShotEntity(const TRange<FFrameNumber>& OneShotRange, UObject* EntityOwner, uint32 EntityID = 0, int32 InMetaDataIndex = INDEX_NONE);
 
    MOVIESCENE_API void AddOneShotEntity(const TRange<FFrameNumber>& OneShotRange, int32 LocalIndex, int32 InMetaDataIndex = INDEX_NONE);
 
private:
 
    MOVIESCENE_API int32 LocalEntityIndexToFieldIndex(int32 LocalIndex);
 
    MOVIESCENE_API int32 LocalMetaDataIndexToFieldIndex(int32 LocalIndex);
 
    struct FKeyToIndex
    {
        FMovieSceneEvaluationFieldEntityKey Key;
        int32 FieldIndex;
    };
    TArray<FKeyToIndex, TInlineAllocator<4>> KeyToFieldIndex;
 
    struct FMetaDataToIndex
    {
        FMovieSceneEvaluationFieldEntityMetaData MetaData;
        int32 FieldIndex;
    };
    TArray<FMetaDataToIndex, TInlineAllocator<2>> MetaDataToFieldIndex;
 
    FMovieSceneEntityComponentField* Field;
 
    int32 SharedMetaDataIndex;
};
 
 
//---------------------------------------------------------
// Legacy track template field structures begin here
//---------------------------------------------------------
 
 
USTRUCT()
struct FMovieSceneEvaluationFieldTrackPtr
{
    GENERATED_BODY()
 
    
    FMovieSceneEvaluationFieldTrackPtr(){}
 
    FMovieSceneEvaluationFieldTrackPtr(FMovieSceneSequenceIDRef InSequenceID, FMovieSceneTrackIdentifier InTrackIdentifier)
        : SequenceID(InSequenceID)
        , TrackIdentifier(InTrackIdentifier)
    {}
 
    friend bool operator==(FMovieSceneEvaluationFieldTrackPtr A, FMovieSceneEvaluationFieldTrackPtr B)
    {
        return A.TrackIdentifier == B.TrackIdentifier && A.SequenceID == B.SequenceID;
    }
 
    friend uint32 GetTypeHash(FMovieSceneEvaluationFieldTrackPtr LHS)
    {
        return HashCombine(GetTypeHash(LHS.TrackIdentifier), GetTypeHash(LHS.SequenceID));
    }
 
    UPROPERTY()
    FMovieSceneSequenceID SequenceID;
 
    UPROPERTY()
    FMovieSceneTrackIdentifier TrackIdentifier;
};
 
USTRUCT()
struct FMovieSceneEvaluationFieldSegmentPtr : public FMovieSceneEvaluationFieldTrackPtr
{
    GENERATED_BODY()
 
    
    FMovieSceneEvaluationFieldSegmentPtr(){}
 
    FMovieSceneEvaluationFieldSegmentPtr(FMovieSceneSequenceIDRef InSequenceID, FMovieSceneTrackIdentifier InTrackIdentifier, FMovieSceneSegmentIdentifier InSegmentID)
        : FMovieSceneEvaluationFieldTrackPtr(InSequenceID, InTrackIdentifier)
        , SegmentID(InSegmentID)
    {}
 
    friend bool operator==(FMovieSceneEvaluationFieldSegmentPtr A, FMovieSceneEvaluationFieldSegmentPtr B)
    {
        return A.SegmentID == B.SegmentID && A.TrackIdentifier == B.TrackIdentifier && A.SequenceID == B.SequenceID;
    }
 
    friend uint32 GetTypeHash(FMovieSceneEvaluationFieldSegmentPtr LHS)
    {
        return HashCombine(GetTypeHash(LHS.SegmentID), GetTypeHash(static_cast<FMovieSceneEvaluationFieldTrackPtr&>(LHS)));
    }
 
    UPROPERTY()
    FMovieSceneSegmentIdentifier SegmentID;
};
 
USTRUCT()
struct FMovieSceneFieldEntry_EvaluationTrack
{
    GENERATED_BODY()
 
    UPROPERTY()
    FMovieSceneEvaluationFieldTrackPtr TrackPtr;
 
    UPROPERTY()
    uint16 NumChildren = 0;
};
 
USTRUCT()
struct FMovieSceneFieldEntry_ChildTemplate
{
    GENERATED_BODY()
 
    FMovieSceneFieldEntry_ChildTemplate()
        : ChildIndex(-1)
        , Flags(ESectionEvaluationFlags::None)
        , ForcedTime(TNumericLimits<int32>::Lowest())
    {}
 
    FMovieSceneFieldEntry_ChildTemplate(uint16 InChildIndex, ESectionEvaluationFlags InFlags, FFrameNumber InForcedTime)
        : ChildIndex(InChildIndex)
        , Flags(InFlags)
        , ForcedTime(InForcedTime)
    {}
 
    UPROPERTY()
    uint16 ChildIndex;
 
    UPROPERTY()
    ESectionEvaluationFlags Flags;
 
    UPROPERTY()
    FFrameNumber ForcedTime;
};
 
USTRUCT()
struct FMovieSceneEvaluationGroupLUTIndex
{
    GENERATED_BODY()
 
    FMovieSceneEvaluationGroupLUTIndex()
        : NumInitPtrs(0)
        , NumEvalPtrs(0)
    {}
 
    UPROPERTY()
    int32 NumInitPtrs;
 
    UPROPERTY()
    int32 NumEvalPtrs;
};
 
USTRUCT()
struct FMovieSceneEvaluationGroup
{
    GENERATED_BODY()
 
    
    UPROPERTY()
    TArray<FMovieSceneEvaluationGroupLUTIndex> LUTIndices;
 
    UPROPERTY()
    TArray<FMovieSceneFieldEntry_EvaluationTrack> TrackLUT;
 
    UPROPERTY()
    TArray<FMovieSceneFieldEntry_ChildTemplate> SectionLUT;
};
 
USTRUCT()
struct FMovieSceneOrderedEvaluationKey
{
    GENERATED_BODY()
 
    UPROPERTY()
    FMovieSceneEvaluationKey Key;
 
    UPROPERTY()
    uint16 SetupIndex = 0;
 
    UPROPERTY()
    uint16 TearDownIndex = 0;
};
 
USTRUCT()
struct FMovieSceneEvaluationMetaData
{
    GENERATED_BODY()
 
    
    void Reset()
    {
        ActiveSequences.Reset();
        ActiveEntities.Reset();
    }
 
    void DiffSequences(const FMovieSceneEvaluationMetaData& LastFrame, TArray<FMovieSceneSequenceID>* NewSequences, TArray<FMovieSceneSequenceID>* ExpiredSequences) const;
 
    void DiffEntities(const FMovieSceneEvaluationMetaData& LastFrame, TArray<FMovieSceneOrderedEvaluationKey>* NewKeys, TArray<FMovieSceneOrderedEvaluationKey>* ExpiredKeys) const;
 
    UPROPERTY()
    TArray<FMovieSceneSequenceID> ActiveSequences;
 
    UPROPERTY()
    TArray<FMovieSceneOrderedEvaluationKey> ActiveEntities;
};
 
USTRUCT()
struct FMovieSceneEvaluationField
{
    GENERATED_BODY()
 
    
    MOVIESCENE_API int32 GetSegmentFromTime(FFrameNumber Time) const;
 
    MOVIESCENE_API TRange<int32> OverlapRange(const TRange<FFrameNumber>& Range) const;
 
    MOVIESCENE_API void Invalidate(const TRange<FFrameNumber>& Range);
 
    MOVIESCENE_API int32 Insert(const TRange<FFrameNumber>& InRange, FMovieSceneEvaluationGroup&& InGroup, FMovieSceneEvaluationMetaData&& InMetaData);
 
    MOVIESCENE_API void Add(const TRange<FFrameNumber>& InRange, FMovieSceneEvaluationGroup&& InGroup, FMovieSceneEvaluationMetaData&& InMetaData);
 
#if WITH_EDITORONLY_DATA
    const FGuid& GetSignature() const
    {
        return Signature;
    }
#endif
 
    int32 Size() const
    {
        return Ranges.Num();
    }
 
    TArrayView<const FMovieSceneFrameRange> GetRanges() const
    {
        return Ranges;
    }
 
    const TRange<FFrameNumber>& GetRange(int32 Index) const
    {
        return Ranges[Index].Value;
    }
 
    const FMovieSceneEvaluationGroup& GetGroup(int32 Index) const
    {
        return Groups[Index];
    }
 
    const FMovieSceneEvaluationMetaData& GetMetaData(int32 Index) const
    {
        return MetaData[Index];
    }
 
private:
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FGuid Signature;
#endif
 
    UPROPERTY()
    TArray<FMovieSceneFrameRange> Ranges;
 
    UPROPERTY()
    TArray<FMovieSceneEvaluationGroup> Groups;
 
    UPROPERTY()
    TArray<FMovieSceneEvaluationMetaData> MetaData;
};