MovieSceneSection.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Conditions/MovieSceneCondition.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/ContainersFwd.h"
#include "Containers/Map.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "Evaluation/Blending/MovieSceneBlendType.h"
#include "Evaluation/MovieSceneCompletionMode.h"
#include "Evaluation/MovieSceneEvaluationCustomVersion.h"
#include "EventHandlers/ISectionEventHandler.h"
#include "EventHandlers/MovieSceneDataEventContainer.h"
#include "Decorations/MovieSceneDecorationContainer.h"
#include "HAL/PlatformCrt.h"
#include "Math/Range.h"
#include "Math/RangeBound.h"
#include "Misc/AssertionMacros.h"
#include "Misc/FrameNumber.h"
#include "Misc/QualifiedFrameTime.h"
#include "Misc/FrameRate.h"
#include "Misc/FrameTime.h"
#include "Misc/Optional.h"
#include "Misc/Timecode.h"
#include "MovieSceneFrameMigration.h"
#include "MovieSceneSequenceID.h"
#include "MovieSceneSignedObject.h"
#include "Templates/SharedPointer.h"
#include "UObject/NameTypes.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ScriptInterface.h"
#include "UObject/UObjectGlobals.h"
 
#include "MovieSceneSection.generated.h"
 
class FArchive;
class FStructOnScope;
class IMovieSceneEasingFunction;
class IMovieScenePlayer;
class UMovieSceneEntitySystemLinker;
class UObject;
class UMovieSceneTrack;
enum class ECookOptimizationFlags;
struct FEasingComponentData;
struct FFrame;
struct FFrameRate;
struct FGuid;
struct FKeyHandle;
struct FMovieSceneBlendTypeField;
struct FMovieSceneChannelProxy;
struct FMovieSceneEvalTemplatePtr;
struct FMovieSceneSequenceHierarchy;
struct FMovieSceneSequenceID;
struct FPropertyChangedEvent;
struct FQualifiedFrameTime;
struct FMovieSceneTimeWarpVariant;
 
namespace UE::MovieScene
{
    class ISectionEventHandler;
    struct FEntityImportParams;
    struct FFixedObjectBindingID;
    struct FImportedEntity;
    struct FSharedPlaybackState;
    struct IRetimingInterface;
}
 
enum class EMovieSceneChannelProxyType : uint8
{
    Static,
 
    Dynamic
};
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FOnMovieSceneSectionAddedToTrack, UMovieSceneTrack*, UMovieSceneSection*);
DECLARE_MULTICAST_DELEGATE_OneParam(FOnMovieSceneSectionChanged, UMovieSceneSection*);
 
USTRUCT()
struct FMovieSceneSectionEvalOptions
{
    GENERATED_BODY()
    
    FMovieSceneSectionEvalOptions()
        : bCanEditCompletionMode(false)
        , CompletionMode(EMovieSceneCompletionMode::KeepState)
    {}
 
    void EnableAndSetCompletionMode(EMovieSceneCompletionMode NewCompletionMode)
    {
        bCanEditCompletionMode = true;
        CompletionMode = NewCompletionMode;
    }
 
    UPROPERTY()
    bool bCanEditCompletionMode;
 
    UPROPERTY(EditAnywhere, DisplayName="When Finished", Category="Section")
    EMovieSceneCompletionMode CompletionMode;
};
 
USTRUCT()
struct FMovieSceneEasingSettings
{
    GENERATED_BODY()
 
    FMovieSceneEasingSettings()
        : AutoEaseInDuration(0), AutoEaseOutDuration(0)
        , EaseIn(nullptr), bManualEaseIn(false), ManualEaseInDuration(0)
        , EaseOut(nullptr), bManualEaseOut(false), ManualEaseOutDuration(0)
#if WITH_EDITORONLY_DATA
        , AutoEaseInTime_DEPRECATED(0.f), AutoEaseOutTime_DEPRECATED(0.f), ManualEaseInTime_DEPRECATED(0.f), ManualEaseOutTime_DEPRECATED(0.f)
#endif
    {}
 
public:
 
    int32 GetEaseInDuration() const
    {
        return bManualEaseIn ? ManualEaseInDuration : AutoEaseInDuration;
    }
 
    int32 GetEaseOutDuration() const
    {
        return bManualEaseOut ? ManualEaseOutDuration : AutoEaseOutDuration;
    }
 
public:
 
    UPROPERTY()
    int32 AutoEaseInDuration;
 
    UPROPERTY()
    int32 AutoEaseOutDuration;
 
    UPROPERTY()
    TScriptInterface<IMovieSceneEasingFunction> EaseIn;
 
    UPROPERTY()
    bool bManualEaseIn;
 
    UPROPERTY()
    int32 ManualEaseInDuration;
 
    UPROPERTY()
    TScriptInterface<IMovieSceneEasingFunction> EaseOut;
 
    UPROPERTY()
    bool bManualEaseOut;
 
    UPROPERTY()
    int32 ManualEaseOutDuration;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    float AutoEaseInTime_DEPRECATED;
    UPROPERTY()
    float AutoEaseOutTime_DEPRECATED;
    UPROPERTY()
    float ManualEaseInTime_DEPRECATED;
    UPROPERTY()
    float ManualEaseOutTime_DEPRECATED;
#endif
};
 
USTRUCT(BlueprintType)
struct FMovieSceneTimecodeSource
{
    GENERATED_BODY()
 
    FMovieSceneTimecodeSource(FTimecode InTimecode)
        : Timecode(InTimecode)
    {}
 
    FMovieSceneTimecodeSource()
        : Timecode(FTimecode())
    {}
 
    inline bool operator==(const FMovieSceneTimecodeSource& Other) const
    {
        return Timecode == Other.Timecode;
    }
    inline bool operator!=(const FMovieSceneTimecodeSource& Other) const
    {
        return Timecode != Other.Timecode;
    }
 
public:
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Timecode")
    FTimecode Timecode;
};
enum class EMovieSceneTransformChannel : uint32
{
    None = 0x000,
 
    TranslationX = 0x001,
    TranslationY = 0x002,
    TranslationZ = 0x004,
    Translation = TranslationX | TranslationY | TranslationZ,
 
    RotationX = 0x008,
    RotationY = 0x010,
    RotationZ = 0x020,
    Rotation = RotationX | RotationY | RotationZ,
 
    ScaleX = 0x040,
    ScaleY = 0x080,
    ScaleZ = 0x100,
    Scale = ScaleX | ScaleY | ScaleZ,
 
    AllTransform = Translation | Rotation | Scale,
 
    Weight = 0x200,
 
    All = Translation | Rotation | Scale | Weight,
};
 
UCLASS(abstract, DefaultToInstanced, MinimalAPI, BlueprintType)
class UMovieSceneSection
    : public UMovieSceneDecorationContainerObject
{
    GENERATED_UCLASS_BODY()
 
public:
 
    UPROPERTY(EditAnywhere, Category="Section", meta=(ShowOnlyInnerProperties))
    FMovieSceneSectionEvalOptions EvalOptions;
 
    UE::MovieScene::TDataEventContainer<UE::MovieScene::ISectionEventHandler> EventHandlers;
 
public:
 
    MOVIESCENE_API bool TryModify(bool bAlwaysMarkDirty=true);
 
    /*
     * A section is read only if it or its outer movie are read only
     * 
     * @return Returns whether this section is read only
     */
    MOVIESCENE_API bool IsReadOnly() const;
 
    TRange<FFrameNumber> GetRange() const
    {
        return SectionRange.Value;
    }
 
    TRange<FFrameNumber> GetTrueRange() const
    {
        TRangeBound<FFrameNumber> SectionLower = SectionRange.Value.GetLowerBound();
        TRangeBound<FFrameNumber> SectionUpper = SectionRange.Value.GetUpperBound();
 
        // Make exclusive lower bounds inclusive on the next frame
        if (SectionLower.IsExclusive())
        {
            SectionLower = TRangeBound<FFrameNumber>::Inclusive(SectionLower.GetValue() + 1);
        }
        // Make inclusive upper bounds exclusive on the next frame
        if (SectionUpper.IsInclusive())
        {
            SectionUpper = TRangeBound<FFrameNumber>::Exclusive(SectionUpper.GetValue() + 1);
        }
        return TRange<FFrameNumber>(SectionLower, SectionUpper);
    }
 
    void ExpandToFrame(FFrameNumber InFrame)
    {
        FFrameNumber StartOffset = HasStartFrame() ? FMath::Min(GetInclusiveStartFrame(), InFrame) - GetInclusiveStartFrame() : 0;
 
        SetRange(TRange<FFrameNumber>::Hull(GetRange(), TRange<FFrameNumber>::Inclusive(InFrame, InFrame)));
        if (StartOffset != 0)
        {
            FixupRelativeKeyframes(StartOffset);
        }
    }
 
    virtual void SetRange(const TRange<FFrameNumber>& NewRange)
    {
        const bool bHasChanged = NewRange != SectionRange.Value; 
        if (IsReadOnly() || !bHasChanged)
        {
            return;
        }
        
        // Skip TryModify for objects that still need initialization (i.e. we're in the object's constructor), because modifying objects in their constructor can lead to non-deterministic cook issues.
        bool bCanSetRange = true;
        if (!HasAnyFlags(RF_NeedInitialization))
        {
            bCanSetRange = TryModify();
        }
 
        const bool bInvariants = ensure(
            NewRange.GetLowerBound().IsOpen() || NewRange.GetUpperBound().IsOpen()
            || NewRange.GetLowerBoundValue() <= NewRange.GetUpperBoundValue()
            );
        if (bCanSetRange && bInvariants)
        {
            SectionRange.Value = NewRange;
        }
    }
 
    bool HasStartFrame() const
    {
        return !SectionRange.Value.GetLowerBound().IsOpen();
    }
 
    bool HasEndFrame() const
    {
        return !SectionRange.Value.GetUpperBound().IsOpen();
    }
 
    FFrameNumber GetInclusiveStartFrame() const
    {
        TRangeBound<FFrameNumber> LowerBound = SectionRange.GetLowerBound();
        return LowerBound.IsInclusive() ? LowerBound.GetValue() : LowerBound.GetValue() + 1;
    }
 
    FFrameNumber GetExclusiveEndFrame() const
    {
        TRangeBound<FFrameNumber> UpperBound = SectionRange.GetUpperBound();
        return UpperBound.IsInclusive() ? UpperBound.GetValue() + 1 : UpperBound.GetValue();
    }
 
    MOVIESCENE_API virtual void SetStartFrame(TRangeBound<FFrameNumber> NewStartFrame);
 
    MOVIESCENE_API virtual void SetEndFrame(TRangeBound<FFrameNumber> NewEndFrame);
 
    bool IsTimeWithinSection(FFrameNumber Position) const 
    {
        return SectionRange.Value.Contains(Position);
    }
 
    /*
     * Returns the range to auto size this section to, if there is one. This defaults to the 
     * range of all the keys.
     *
     * @return the range of this section to auto size to
     */
    MOVIESCENE_API virtual TOptional<TRange<FFrameNumber> > GetAutoSizeRange() const;
 
    UFUNCTION(BlueprintPure, Category = "Sequencer|Section")
    EMovieSceneCompletionMode GetCompletionMode() const
    {
        return EvalOptions.CompletionMode;
    }
 
    /*
     * Sets this section's completion mode
     */
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Section")
    void SetCompletionMode(EMovieSceneCompletionMode InCompletionMode)
    {
        EvalOptions.CompletionMode = InCompletionMode;
    }
 
    UFUNCTION(BlueprintPure, Category = "Sequencer|Section")
    FOptionalMovieSceneBlendType GetBlendType() const
    {
        return BlendType;
    }
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Section")
    virtual void SetBlendType(EMovieSceneBlendType InBlendType)
    {
        if (GetSupportedBlendTypes().Contains(InBlendType))
        {
            BlendType = InBlendType;
        }
    }
 
    MOVIESCENE_API FMovieSceneBlendTypeField GetSupportedBlendTypes() const;
 
    MOVIESCENE_API int32 GetBlendingOrder() const;
 
    MOVIESCENE_API virtual void MoveSection(FFrameNumber DeltaTime);
 
    MOVIESCENE_API TRange<FFrameNumber> ComputeEffectiveRange() const;
 
    MOVIESCENE_API virtual UMovieSceneSection* SplitSection(FQualifiedFrameTime SplitTime, bool bDeleteKeys);
 
    MOVIESCENE_API virtual void TrimSection(FQualifiedFrameTime TrimTime, bool bTrimLeft, bool bDeleteKeys);
 
    MOVIESCENE_API virtual TSharedPtr<FStructOnScope> GetKeyStruct(TArrayView<const FKeyHandle> KeyHandles);
 
    virtual FMovieSceneTimeWarpVariant* GetTimeWarp()
    {
        return nullptr;
    }
 
    virtual void GetSnapTimes(TArray<FFrameNumber>& OutSnapTimes, bool bGetSectionBorders) const
    {
        if (bGetSectionBorders)
        {
            if (SectionRange.Value.GetLowerBound().IsClosed())
            {
                OutSnapTimes.Add(SectionRange.Value.GetLowerBoundValue());
            }
 
            if (SectionRange.Value.GetUpperBound().IsClosed())
            {
                OutSnapTimes.Add(SectionRange.Value.GetUpperBoundValue());
            }
        }
    }
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Section")
    MOVIESCENE_API void SetRowIndex(int32 NewRowIndex);
 
    UFUNCTION(BlueprintPure, Category = "Sequencer|Section")
    int32 GetRowIndex() const { return RowIndex; }
    
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Section")
    void SetOverlapPriority(int32 NewPriority)
    {
        OverlapPriority = NewPriority;
    }
 
    UFUNCTION(BlueprintPure, Category = "Sequencer|Section")
    int32 GetOverlapPriority() const
    {
        return OverlapPriority;
    }
 
    virtual MOVIESCENE_API const UMovieSceneSection* OverlapsWithSections(const TArray<UMovieSceneSection*>& Sections, int32 TrackDelta = 0, int32 TimeDelta = 0) const;
    
    virtual MOVIESCENE_API void InitialPlacement(const TArray<UMovieSceneSection*>& Sections, FFrameNumber InStartTime, int32 InDuration, bool bAllowMultipleRows);
 
    virtual MOVIESCENE_API void InitialPlacementOnRow(const TArray<UMovieSceneSection*>& Sections, FFrameNumber InStartTime, int32 InDuration, int32 InRowIndex);
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Section")
    void SetIsActive(bool bInIsActive) { if (TryModify()) { bIsActive = bInIsActive; } }
    UFUNCTION(BlueprintPure, Category = "Sequencer|Section")
    bool IsActive() const { return bIsActive; }
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Section")
    void SetIsLocked(bool bInIsLocked) { Modify(); bIsLocked = bInIsLocked; }
    UFUNCTION(BlueprintPure, Category = "Sequencer|Section")
    bool IsLocked() const { return bIsLocked; }
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Section")
    void SetPreRollFrames(int32 InPreRollFrames) { PreRollFrames = InPreRollFrames; }
    UFUNCTION(BlueprintPure, Category = "Sequencer|Section")
    int32 GetPreRollFrames() const { return PreRollFrames.Value; }
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Section")
    void SetPostRollFrames(int32 InPostRollFrames) { PostRollFrames = InPostRollFrames; }
    UFUNCTION(BlueprintPure, Category = "Sequencer|Section")
    int32 GetPostRollFrames() const { return PostRollFrames.Value; }
 
    UFUNCTION(BlueprintCallable, Category = "Sequencer|Section")
    MOVIESCENE_API void SetColorTint(const FColor& InColorTint);
    UFUNCTION(BlueprintPure, Category = "Sequencer|Section")
    MOVIESCENE_API FColor GetColorTint() const;
 
    virtual TOptional<FFrameTime> GetOffsetTime() const { return TOptional<FFrameTime>(); }
 
    /* Migrate the frame times of the movie scene section from the source frame rate to the destination frame rate */
    virtual void MigrateFrameTimes(FFrameRate SourceRate, FFrameRate DestinationRate) {}
    virtual void MigrateFrameTimes(const UE::MovieScene::IRetimingInterface& Retimer) {}
 
    virtual void OnBindingIDsUpdated(const TMap<UE::MovieScene::FFixedObjectBindingID, UE::MovieScene::FFixedObjectBindingID>& OldFixedToNewFixedMap, FMovieSceneSequenceID LocalSequenceID, TSharedRef<UE::MovieScene::FSharedPlaybackState> SharedPlaybackState) {}
 
    virtual void GetReferencedBindings(TArray<FGuid>& OutBindings) {}
 
    MOVIESCENE_API void GetOverlappingSections(TArray<UMovieSceneSection*>& OutSections, bool bSameRow, bool bIncludeThis);
 
    /* Returns whether this section can have an open lower bound. This will generally be false if sections of this type cannot be blended and there is another section on the same row before this one.*/
    MOVIESCENE_API bool CanHaveOpenLowerBound() const;
 
    /* Returns whether this section can have an open upper bound. This will generally be false if sections of this type cannot be blended and there is another section on the same row after this one.*/
    MOVIESCENE_API bool CanHaveOpenUpperBound() const;
 
    MOVIESCENE_API float EvaluateEasing(FFrameTime InTime) const;
 
    MOVIESCENE_API void EvaluateEasing(FFrameTime InTime, TOptional<float>& OutEaseInValue, TOptional<float>& OutEaseOutValue, float* OutEaseInInterp, float* OutEaseOutInterp) const;
 
    MOVIESCENE_API TRange<FFrameNumber> GetEaseInRange() const;
 
    MOVIESCENE_API TRange<FFrameNumber> GetEaseOutRange() const;
 
    MOVIESCENE_API FMovieSceneChannelProxy& GetChannelProxy() const;
 
    MOVIESCENE_API void InvalidateChannelProxy();
 
    bool GetSupportsInfiniteRange() const { return bSupportsInfiniteRange; }
 
    virtual bool ShowCurveForChannel(const void *Channel) const  { return true; }
 
    virtual float GetTotalWeightValue(FFrameTime InTime) const { return EvaluateEasing(InTime); }
 
 
    MOVIESCENE_API virtual UObject* GetImplicitObjectOwner();
 
    virtual UObject* GetSourceObject() const { return nullptr; }
 
    void OnAddedToTrack(UMovieSceneTrack* Track);
    void OnRemovedFromTrack();
 
#if WITH_EDITOR
    MOVIESCENE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
 
    MOVIESCENE_API virtual void PostPaste();
#endif
 
#if WITH_EDITOR
 
    MOVIESCENE_API virtual ECookOptimizationFlags GetCookOptimizationFlags() const;
 
    MOVIESCENE_API virtual void RemoveForCook();
 
#endif
 
public:
 
    MOVIESCENE_API void BuildDefaultComponents(UMovieSceneEntitySystemLinker* EntityLinker, const UE::MovieScene::FEntityImportParams& Params, UE::MovieScene::FImportedEntity* OutLedgerEntry);
 
#if WITH_EDITORONLY_DATA
    MOVIESCENE_API static void DeclareConstructClasses(TArray<FTopLevelAssetPath>& OutConstructClasses, const UClass* SpecificSubclass);
#endif
 
#if WITH_EDITORONLY_DATA
 
public:
 
    MOVIESCENE_API static FOnMovieSceneSectionAddedToTrack& GetOnSectionAddedToTrack();
    MOVIESCENE_API static FOnMovieSceneSectionChanged& GetOnSectionRemovedFromTrack();
 
private:
 
    static FOnMovieSceneSectionAddedToTrack OnAddedToTrackEvent;
    static FOnMovieSceneSectionChanged OnRemovedFromTrackEvent;
 
#endif
 
protected:
 
    //~ UObject interface
    MOVIESCENE_API virtual void PostInitProperties() override;
    MOVIESCENE_API virtual bool IsPostLoadThreadSafe() const override;
    MOVIESCENE_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
    MOVIESCENE_API virtual void PostRename(UObject* OldOuter, const FName OldName) override;
    MOVIESCENE_API virtual void PostEditImport() override;
    MOVIESCENE_API virtual void Serialize(FArchive& Ar) override;
 
    MOVIESCENE_API virtual void OnDecorationAdded(UObject* NewDecoration) override;
    MOVIESCENE_API virtual void OnDecorationRemoved(UObject* NewDecoration) override;
 
    virtual void OnAddedToTrackImpl(UMovieSceneTrack* Track)
    {
    }
    virtual void OnRemovedFromTrackImpl()
    {
    }
 
    virtual void OnMoved(int32 DeltaTime) {}
    virtual void OnDilated(float DilationFactor, FFrameNumber Origin) {}
 
    MOVIESCENE_API void FixupRelativeKeyframes(FFrameNumber Offset);
 
    MOVIESCENE_API bool ShouldUpgradeEntityData(FArchive& Ar, FMovieSceneEvaluationCustomVersion::Type UpgradeVersion) const;
 
private:
 
    MOVIESCENE_API virtual EMovieSceneChannelProxyType CacheChannelProxy();
 
    void MoveSectionImpl(FFrameNumber DeltaTime);
 
public:
 
    UPROPERTY(EditAnywhere, Category="Easing", meta=(ShowOnlyInnerProperties))
    FMovieSceneEasingSettings Easing;
 
    UPROPERTY(EditAnywhere, Category="Section")
    FMovieSceneFrameRange SectionRange;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category="Section")
    FMovieSceneTimecodeSource TimecodeSource;
#endif
 
    UPROPERTY(EditAnywhere, Category="Section")
    FMovieSceneConditionContainer ConditionContainer;
 
private:
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category="Section", meta=(UIMin=0, UIFrameDisplayAs="NonMusical|Duration"))
    FFrameNumber PreRollFrames;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category="Section", meta=(UIMin=0, UIFrameDisplayAs="NonMusical|Duration"))
    FFrameNumber PostRollFrames;
 
    UPROPERTY()
    int32 RowIndex;
 
    UPROPERTY()
    int32 OverlapPriority;
 
    UPROPERTY(EditAnywhere, Category="Section")
    uint32 bIsActive : 1;
 
    UPROPERTY(EditAnywhere, Category="Section")
    uint32 bIsLocked : 1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY(EditAnywhere, Category = "Section")
    FColor ColorTint;
#endif
 
protected:
 
    UPROPERTY()
    float StartTime_DEPRECATED;
 
    UPROPERTY()
    float EndTime_DEPRECATED;
 
    UPROPERTY()
    float PreRollTime_DEPRECATED;
 
    UPROPERTY()
    float PostRollTime_DEPRECATED;
 
    UPROPERTY()
    uint32 bIsInfinite_DEPRECATED : 1;
 
protected:
    UPROPERTY()
    bool bSupportsInfiniteRange;
 
    UPROPERTY()
    FOptionalMovieSceneBlendType BlendType;
 
    mutable TSharedPtr<FMovieSceneChannelProxy> ChannelProxy;
 
    mutable EMovieSceneChannelProxyType ChannelProxyType;
};
 
template<typename SectionParams>
inline FFrameNumber GetFirstLoopStartOffsetAtTrimTime(FQualifiedFrameTime TrimTime, const SectionParams& Params, FFrameNumber StartFrame, FFrameRate FrameRate)
{
    const float AnimPlayRate = FMath::IsNearlyZero(Params.PlayRate) ? 1.0f : Params.PlayRate;
    const float AnimPosition = static_cast<float>((TrimTime.Time - StartFrame) / TrimTime.Rate * AnimPlayRate);
    const float SeqLength = static_cast<float>(Params.GetSequenceLength() - FrameRate.AsSeconds(Params.StartFrameOffset + Params.EndFrameOffset) / AnimPlayRate);
 
    FFrameNumber NewOffset = FrameRate.AsFrameNumber(FMath::Fmod(AnimPosition, SeqLength));
    NewOffset += Params.FirstLoopStartFrameOffset;
 
    const FFrameNumber SeqLengthInFrames = FrameRate.AsFrameNumber(SeqLength);
    NewOffset = NewOffset % SeqLengthInFrames;
 
    return NewOffset;
}