MovieSceneSegment.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/FrameTime.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Class.h"
#include "Containers/ArrayView.h"
#include "UObject/SequencerObjectVersion.h"
#include "MovieSceneFrameMigration.h"
#include "MovieSceneSegment.generated.h"
 
struct FMovieSceneEvaluationTrackSegments;
 
UENUM()
enum class ESectionEvaluationFlags : uint8
{
    None        = 0x00,
    PreRoll     = 0x01,
    PostRoll    = 0x02,
 
    ForceKeepState = 0x04,
    ForceRestoreState = 0x08,
};
ENUM_CLASS_FLAGS(ESectionEvaluationFlags);
 
USTRUCT()
struct FMovieSceneSegmentIdentifier
{
    GENERATED_BODY()
 
    FMovieSceneSegmentIdentifier() : IdentifierIndex(INDEX_NONE) {}
    FMovieSceneSegmentIdentifier(int32 InIndex) : IdentifierIndex(InIndex) {}
 
    friend bool operator==(FMovieSceneSegmentIdentifier A, FMovieSceneSegmentIdentifier B) { return A.IdentifierIndex == B.IdentifierIndex; }
    friend bool operator!=(FMovieSceneSegmentIdentifier A, FMovieSceneSegmentIdentifier B) { return A.IdentifierIndex != B.IdentifierIndex; }
    friend uint32 GetTypeHash(FMovieSceneSegmentIdentifier LHS) { return GetTypeHash(LHS.IdentifierIndex); }
 
    bool IsValid() const
    {
        return IdentifierIndex != INDEX_NONE;
    }
 
    bool Serialize(FArchive& Ar)
    {
        Ar << IdentifierIndex;
        return true;
    }
 
    friend FArchive& operator<<(FArchive& Ar, FMovieSceneSegmentIdentifier& ID)
    {
        ID.Serialize(Ar);
        return Ar;
    }
 
    int32 GetIndex() const
    {
        return IdentifierIndex;
    }
 
    UPROPERTY()
    int32 IdentifierIndex;
};
 
template<> struct TStructOpsTypeTraits<FMovieSceneSegmentIdentifier> : public TStructOpsTypeTraitsBase2<FMovieSceneSegmentIdentifier>
{
    enum { WithSerializer = true, WithIdenticalViaEquality = true };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};
 
USTRUCT()
struct FSectionEvaluationData
{
    GENERATED_BODY()
 
    
    FSectionEvaluationData() : ImplIndex(-1), ForcedTime(TNumericLimits<int32>::Lowest()), Flags(ESectionEvaluationFlags::None) {}
 
    explicit FSectionEvaluationData(int32 InImplIndex)
        : ImplIndex(InImplIndex), ForcedTime(TNumericLimits<int32>::Lowest()), Flags(ESectionEvaluationFlags::None)
    {}
 
    FSectionEvaluationData(int32 InImplIndex, FFrameNumber InForcedTime)
        : ImplIndex(InImplIndex), ForcedTime(InForcedTime), Flags(ESectionEvaluationFlags::None)
    {}
 
    FSectionEvaluationData(int32 InImplIndex, ESectionEvaluationFlags InFlags)
        : ImplIndex(InImplIndex), ForcedTime(TNumericLimits<int32>::Lowest()), Flags(InFlags)
    {}
 
    friend bool operator==(FSectionEvaluationData A, FSectionEvaluationData B)
    {
        return A.ImplIndex == B.ImplIndex && A.ForcedTime == B.ForcedTime && A.Flags == B.Flags;
    }
 
    FFrameTime GetTime(FFrameTime InActualTime)
    {
        return ForcedTime == TNumericLimits<int32>::Lowest() ? InActualTime : FFrameTime(ForcedTime);
    }
 
    inline bool IsPreRoll() const { return (Flags & ESectionEvaluationFlags::PreRoll) != ESectionEvaluationFlags::None; }
 
    inline bool IsPostRoll() const { return (Flags & ESectionEvaluationFlags::PostRoll) != ESectionEvaluationFlags::None; }
 
    friend FArchive& operator<<(FArchive& Ar, FSectionEvaluationData& Data)
    {
        FSectionEvaluationData::StaticStruct()->SerializeItem(Ar, &Data, nullptr);
        return Ar;
    }
 
    UPROPERTY()
    int32 ImplIndex;
 
    UPROPERTY()
    FFrameNumber ForcedTime;
 
    UPROPERTY()
    ESectionEvaluationFlags Flags;
};
 
USTRUCT()
struct FMovieSceneSegment
{
    GENERATED_BODY()
 
    FMovieSceneSegment()
    {}
 
    FMovieSceneSegment(const TRange<FFrameNumber>& InRange)
        : Range(InRange)
        , bAllowEmpty(false)
    {}
 
    FMovieSceneSegment(const TRange<FFrameNumber>& InRange, TArrayView<const FSectionEvaluationData> InApplicationImpls)
        : Range(InRange)
        , bAllowEmpty(true)
    {
        Impls.Reserve(InApplicationImpls.Num());
        for (const FSectionEvaluationData& Impl : InApplicationImpls)
        {
            Impls.Add(Impl);
        }
    }
 
    FMovieSceneSegment(const TRange<FFrameNumber>& InRange, std::initializer_list<FSectionEvaluationData> InApplicationImpls)
        : FMovieSceneSegment(InRange, MakeArrayView(InApplicationImpls))
    {
    }
 
    friend bool operator==(const FMovieSceneSegment& A, const FMovieSceneSegment& B)
    {
        return A.Range == B.Range && A.ID == B.ID && A.bAllowEmpty == B.bAllowEmpty && A.Impls == B.Impls;
    }
 
    bool IsValid() const
    {
        return bAllowEmpty || Impls.Num() != 0;
    }
 
    bool CombineWith(const FMovieSceneSegment& OtherSegment)
    {
        if (Range.Adjoins(OtherSegment.Range) && Impls == OtherSegment.Impls && bAllowEmpty == OtherSegment.bAllowEmpty)
        {
            Range = TRange<FFrameNumber>::Hull(OtherSegment.Range, Range);
            return true;
        }
        return false;
    }
 
    bool Serialize(FArchive& Ar)
    {
        Ar.UsingCustomVersion(FSequencerObjectVersion::GUID);
 
        if (Ar.IsLoading() && Ar.CustomVer(FSequencerObjectVersion::GUID) < FSequencerObjectVersion::FloatToIntConversion)
        {
            TRange<float> OldFloatRange;
            Ar << OldFloatRange;
            Range = FMovieSceneFrameRange::FromFloatRange(OldFloatRange);
        }
        else
        {
            Ar << Range;
        }
 
        if (Ar.CustomVer(FSequencerObjectVersion::GUID) >= FSequencerObjectVersion::EvaluationTree)
        {
            Ar << ID;
            Ar << bAllowEmpty;
        }
 
        int32 NumStructs = Impls.Num();
        Ar << NumStructs;
 
        if (Ar.IsLoading())
        {
            for (int32 Index = 0; Index < NumStructs; ++Index)
            {
                FSectionEvaluationData Data;
                Ar << Data;
                Impls.Add(Data);
            }
        }
        else if (Ar.IsSaving())
        {
            for (FSectionEvaluationData& Data : Impls)
            {
                Ar << Data;
            }
        }
        return true;
    }
 
    TRange<FFrameNumber> Range;
 
    FMovieSceneSegmentIdentifier ID;
 
    bool bAllowEmpty;
 
    TArray<FSectionEvaluationData, TInlineAllocator<4>> Impls;
};
 
template<> struct TStructOpsTypeTraits<FMovieSceneSegment> : public TStructOpsTypeTraitsBase2<FMovieSceneSegment>
{
    enum { WithSerializer = true, WithCopy = true, WithIdenticalViaEquality = true };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::None;
};