MovieSceneEvalTemplate.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "Evaluation/MovieSceneCompletionMode.h"
#include "Evaluation/MovieSceneEvalTemplateBase.h"
#include "Evaluation/MovieSceneExecutionTokens.h"
#include "Evaluation/MovieScenePlayback.h"
#include "Evaluation/PersistentEvaluationData.h"
#include "Math/Range.h"
#include "Misc/AssertionMacros.h"
#include "Misc/FrameNumber.h"
#include "Misc/FrameTime.h"
#include "Misc/InlineValue.h"
#include "MovieSceneSection.h"
#include "Templates/Decay.h"
#include "Templates/EnableIf.h"
#include "Templates/PointerIsConvertibleFromTo.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/UnrealTypeTraits.h"
#include "UObject/Class.h"
#include "UObject/ObjectMacros.h"
#include "UObject/WeakObjectPtr.h"
#include "UObject/WeakObjectPtrTemplates.h"
 
#include "MovieSceneEvalTemplate.generated.h"
 
class FArchive;
class IMovieScenePlayer;
class UObject;
struct FMovieSceneEvaluationOperand;
struct FMovieSceneExecutionTokens;
struct FMovieSceneInterrogationData;
 
USTRUCT()
struct FMovieSceneEvalTemplate : public FMovieSceneEvalTemplateBase
{
public:
    GENERATED_BODY()
 
    
    FMovieSceneEvalTemplate()
    {
        CompletionMode = EMovieSceneCompletionMode::KeepState;
    }
 
    bool RequiresInitialization() const
    {
        return (OverrideMask & RequiresInitializeFlag) != 0;
    }
 
    EMovieSceneCompletionMode GetCompletionMode() const
    {
        return CompletionMode;
    }
 
    void SetCompletionMode(EMovieSceneCompletionMode InCompletionMode)
    {
        CompletionMode = InCompletionMode;
    }
 
    virtual void Initialize(const FMovieSceneEvaluationOperand& Operand, const FMovieSceneContext& Context, FPersistentEvaluationData& PersistentData, IMovieScenePlayer& Player) const
    {
        ensureMsgf(false, TEXT("FMovieSceneEvalTemplate::Initialize has not been implemented. Verify EnableOverrides() usage is correct or implement this function."));
    }
 
    virtual void Evaluate(const FMovieSceneEvaluationOperand& Operand, const FMovieSceneContext& Context, const FPersistentEvaluationData& PersistentData, FMovieSceneExecutionTokens& ExecutionTokens) const
    {
        ensureMsgf(false, TEXT("FMovieSceneEvalTemplate::Evaluate has not been implemented. Verify that this template's evaluation track has correct evaluation method (usually set in UMovieSceneTrack::PostCompile), or implement this function."));
    }
 
    virtual void EvaluateSwept(const FMovieSceneEvaluationOperand& Operand, const FMovieSceneContext& Context, const TRange<FFrameNumber>& SweptRange, const FPersistentEvaluationData& PersistentData, FMovieSceneExecutionTokens& ExecutionTokens) const
    {
        ensureMsgf(false, TEXT("FMovieSceneEvalTemplate::EvaluateSwept has not been implemented. Verify that this template's evaluation track has correct evaluation method (usually set in UMovieSceneTrack::PostCompile), or implement this function."));
    }
 
    virtual void Interrogate(const FMovieSceneContext& Context, FMovieSceneInterrogationData& Container, UObject* BindingOverride) const
    {
    }
 
    virtual void Interrogate(const FMovieSceneContext& Context, TRange<FFrameNumber> SweptRange, FMovieSceneInterrogationData& Container, UObject* BindingOverride) const
    {
    }
 
public:
 
    void SetSourceSection(const UMovieSceneSection* InSourceSection)
    {
        SourceSectionPtr = InSourceSection;
    }
 
    const UMovieSceneSection* GetSourceSection() const
    {
        return SourceSectionPtr.Get();
    }
 
protected:
 
    MOVIESCENE_API float EvaluateEasing(FFrameTime CurrentTime) const;
 
    enum EOverrideMask
    {
        RequiresInitializeFlag      = 0x004,
    };
 
    UPROPERTY()
    EMovieSceneCompletionMode CompletionMode;
 
    UPROPERTY()
    TWeakObjectPtr<const UMovieSceneSection> SourceSectionPtr;
};
 
USTRUCT()
struct FMovieSceneEvalTemplatePtr
#if CPP
    : TInlineValue<FMovieSceneEvalTemplate, 128>
#endif
{
    GENERATED_BODY()
 
    
    FMovieSceneEvalTemplatePtr(){}
 
    template<
        typename T,
        typename = typename TEnableIf<TPointerIsConvertibleFromTo<typename TDecay<T>::Type, FMovieSceneEvalTemplate>::Value>::Type
    >
    FMovieSceneEvalTemplatePtr(T&& In)
        : TInlineValue(Forward<T>(In))
    {
        static_assert(!std::is_same_v<typename TDecay<T>::Type, FMovieSceneEvalTemplate>, "Direct usage of FMovieSceneEvalTemplate is prohibited.");
        
#if WITH_EDITOR
        checkf(T::StaticStruct() == &In.GetScriptStruct() && T::StaticStruct() != FMovieSceneEvalTemplate::StaticStruct(), TEXT("%s does not correctly override GetScriptStructImpl. Template will not serialize correctly."), *T::StaticStruct()->GetName());
#endif
    }
 
    FMovieSceneEvalTemplatePtr(const FMovieSceneEvalTemplatePtr& RHS)
    {
        *this = RHS;
    }
    FMovieSceneEvalTemplatePtr& operator=(const FMovieSceneEvalTemplatePtr& RHS)
    {
        if (RHS.IsValid())
        {
            UScriptStruct::ICppStructOps& StructOps = *RHS->GetScriptStruct().GetCppStructOps();
 
            void* Allocation = Reserve(StructOps.GetSize(), StructOps.GetAlignment());
            StructOps.Construct(Allocation);
            StructOps.Copy(Allocation, &RHS.GetValue(), 1);
        }
        else
        {
            Reset();
        }
 
        return *this;
    }
 
    FMovieSceneEvalTemplatePtr(FMovieSceneEvalTemplatePtr&&) = default;
    FMovieSceneEvalTemplatePtr& operator=(FMovieSceneEvalTemplatePtr&&) = default;
 
    MOVIESCENE_API bool Serialize(FArchive& Ar);
};
 
template<> struct TStructOpsTypeTraits<FMovieSceneEvalTemplatePtr> : public TStructOpsTypeTraitsBase2<FMovieSceneEvalTemplatePtr>
{
    enum { WithSerializer = true, WithCopy = true };
};