MovieSceneTemplateInterrogation.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "CoreMinimal.h"
#include "Evaluation/MovieSceneAnimTypeID.h"
#include "HAL/Platform.h"
#include "Misc/InlineValue.h"
#include "Misc/Optional.h"
#include "Templates/Decay.h"
#include "Templates/SharedPointer.h"
#include "Templates/UnrealTemplate.h"
 
class UObject;
struct FMovieSceneBlendingAccumulator;
struct FMovieSceneContext;
template<typename T> struct TMovieSceneInterrogationIterator;
 
struct FMovieSceneInterrogationKey
{
    FMovieSceneAnimTypeID AnimTypeID;
 
    FMovieSceneInterrogationKey(FMovieSceneAnimTypeID InAnimTypeID)
        : AnimTypeID(InAnimTypeID)
    {}
 
    friend bool operator==(FMovieSceneInterrogationKey A, FMovieSceneInterrogationKey B)
    {
        return A.AnimTypeID == B.AnimTypeID;
    }
    friend bool operator!=(FMovieSceneInterrogationKey A, FMovieSceneInterrogationKey B)
    {
        return A.AnimTypeID != B.AnimTypeID;
    }
 
    MOVIESCENE_API static FMovieSceneInterrogationKey GetTransformInterrogationKey();
};
 
struct IMovieSceneInterrogationToken
{
    FMovieSceneInterrogationKey Key;
    IMovieSceneInterrogationToken(FMovieSceneInterrogationKey InKey) : Key(InKey) {}
};
 
template<typename T>
struct TMovieSceneInterrogationToken : IMovieSceneInterrogationToken
{
    T Data;
 
    template<typename U> TMovieSceneInterrogationToken(U&& In, FMovieSceneInterrogationKey InKey)
        : IMovieSceneInterrogationToken(InKey)
        , Data(Forward<U>(In))
    {
    }
};
 
struct FMovieSceneInterrogationData
{
    template<typename T>
    void Add(T&& InData, FMovieSceneInterrogationKey Key)
    {
        TokenData.Add(TMovieSceneInterrogationToken<typename TDecay<T>::Type>(Forward<T>(InData), Key));
    }
    TArray<TInlineValue<IMovieSceneInterrogationToken>>::TConstIterator Iterate() const
    {
        return TokenData.CreateConstIterator();
    }
 
    template<typename T>
    TMovieSceneInterrogationIterator<T> Iterate(FMovieSceneInterrogationKey Key) const
    {
        return TMovieSceneInterrogationIterator<T>(*this, Key);
    }
 
    MOVIESCENE_API void Finalize(const FMovieSceneContext& Context, UObject* BindingOverride);
 
    MOVIESCENE_API FMovieSceneBlendingAccumulator& GetAccumulator();
 
private:
 
    template<typename T> friend struct TMovieSceneInterrogationIterator;
    TArray<TInlineValue<IMovieSceneInterrogationToken>> TokenData;
 
    TSharedPtr<FMovieSceneBlendingAccumulator> Accumulator;
};
 
 
template<typename DataType>
struct TMovieSceneInterrogationIterator
{
    TMovieSceneInterrogationIterator(const FMovieSceneInterrogationData& InContainer, FMovieSceneInterrogationKey InPredicateKey)
        : Container(InContainer)
        , PredicateKey(InPredicateKey)
        , Index(-1)
    {
        NextElement();
    }
 
    TMovieSceneInterrogationIterator& operator++()
    {
        NextElement();
        return *this;
    }
 
    const DataType& operator*() const
    {
        return static_cast<const TMovieSceneInterrogationToken<DataType>&>(Container.TokenData[Index].GetValue()).Data;
    }
 
    const DataType* operator->() const
    {
        return &static_cast<const TMovieSceneInterrogationToken<DataType>&>(Container.TokenData[Index].GetValue()).Data;
    }
 
    inline explicit operator bool() const
    {
        return Container.TokenData.IsValidIndex(Index);
    }
 
    inline bool operator!() const 
    {
        return !(bool)*this;
    }
 
    inline friend bool operator==(const TMovieSceneInterrogationIterator& LHS, const TMovieSceneInterrogationIterator& RHS) { return &LHS.Container == &RHS.Container && LHS.Index == RHS.Index; }
    inline friend bool operator!=(const TMovieSceneInterrogationIterator& LHS, const TMovieSceneInterrogationIterator& RHS) { return &LHS.Container != &RHS.Container || LHS.Index != RHS.Index; }
 
    inline friend TMovieSceneInterrogationIterator<DataType> begin(const TMovieSceneInterrogationIterator<DataType>& In) { return In; }
    inline friend TMovieSceneInterrogationIterator<DataType> end(  const TMovieSceneInterrogationIterator<DataType>& In) { TMovieSceneInterrogationIterator<DataType> New = In; New.Index = -1; return New; }
 
    void NextElement()
    {
        while (Container.TokenData.IsValidIndex(++Index))
        {
            if (!PredicateKey.IsSet() || Container.TokenData[Index]->Key == PredicateKey)
            {
                break;
            }
        }
 
        if (!Container.TokenData.IsValidIndex(Index))
        {
            Index = -1;
        }
    }
 
private:
    const FMovieSceneInterrogationData& Container;
    TOptional<FMovieSceneInterrogationKey> PredicateKey;
    int32 Index;
};