TrackInstancePropertyBindings.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
 
#include "Containers/Map.h"
#include "Misc/TVariant.h"
#include "UObject/Class.h"
#include "UObject/ObjectKey.h"
#include "UObject/UnrealType.h"
#include "UObject/WeakFieldPtr.h"
 
namespace UE::MovieScene
{
 
struct FSourcePropertyValue;
 
struct FCachedProperty
{
    TWeakFieldPtr<FProperty> Property = nullptr;
 
    void* ContainerAddress = nullptr;
 
    int32 ArrayIndex = INDEX_NONE;
 
    FProperty* GetValidProperty() const
    {
        FProperty* PropertyPtr = Property.Get();
        if (ContainerAddress && PropertyPtr && !PropertyPtr->HasAnyFlags(RF_BeginDestroyed | RF_FinishDestroyed))
        {
            return PropertyPtr;
        }
        return nullptr;
    }
 
    template<typename ValueType>
    ValueType* GetPropertyAddress() const
    {
        if (FProperty* PropertyPtr = GetValidProperty())
        {
            if (ArrayIndex == INDEX_NONE)
            {
                return PropertyPtr->ContainerPtrToValuePtr<ValueType>(ContainerAddress);
            }
            else if (FArrayProperty* ArrayProp = CastFieldChecked<FArrayProperty>(PropertyPtr))
            {
                FScriptArrayHelper ArrayHelper(ArrayProp, ArrayProp->ContainerPtrToValuePtr<void>(ContainerAddress));
                check(ArrayHelper.IsValidIndex(ArrayIndex));
                return (ValueType*)ArrayHelper.GetRawPtr(ArrayIndex);
            }
        }
        return nullptr;
    }
};
 
struct FVolatilePropertyStep
{
private:
 
    using FData = TVariant<
        // ContainerOffset : A fixed offset to jump by.
        // Size = 4 bytes
        uint32,
        // CheckArrayIndex : A jump into an array's buffer, checking that the element index we'll 
        // offset to next is still valid.
        // Size = 4 bytes
        int32,
        // CheckStruct : A jump into an instanced struct's buffer, checking that the struct type
        // is what we expect.
        // Size = 8 bytes
        TWeakObjectPtr<UScriptStruct>
    >;
    FData Data;
 
public:
 
    void* ResolveAddress(void* ContainerAddress, bool& bNeedsRecaching) const;
 
    void SetContainerOffset(uint32 InOffset) { Data.Set<uint32>(InOffset); }
    void SetCheckArrayIndex(int32 InArrayIndex) { Data.Set<int32>(InArrayIndex); }
    void SetCheckStruct(TWeakObjectPtr<UScriptStruct> InScriptStruct) { Data.Set<TWeakObjectPtr<UScriptStruct>>(InScriptStruct); }
};
// The TVariant data type flag is 8 bytes so with the biggest union field being 8 bytes, it should 
// all fit inside of 16 bytes.
static_assert(sizeof(FVolatilePropertyStep) <= 16, "Try to fit FVolatilePropertyStep inside 16 bytes");
 
struct FVolatileProperty
{
    const UObject* RootContainer = nullptr;
    FString PropertyPath;
 
    TArray<FVolatilePropertyStep> PropertySteps;
    TWeakFieldPtr<FProperty> LeafProperty;
    int32 LeafContainerStepIndex = INDEX_NONE;
 
    FProperty* GetValidProperty() const
    {
        FProperty* PropertyPtr = LeafProperty.Get();
        if (RootContainer && PropertyPtr && !PropertyPtr->HasAnyFlags(RF_BeginDestroyed | RF_FinishDestroyed))
        {
            return PropertyPtr;
        }
        return nullptr;
    }
 
    void* GetLeafContainerAddress() const
    {
        return ResolvePropertySteps(true);
    }
 
    template<typename ValueType>
    ValueType* GetPropertyAddress() const
    {
        return (ValueType*)ResolvePropertySteps(false);
    }
 
private:
 
    MOVIESCENE_API void* ResolvePropertySteps(bool bStopAtLeafStep) const;
 
    void* ResolvePropertyStepsImpl(bool bStopAtLeafStep, bool& bNeedsRecaching) const;
};
 
}  // namespace UE::MovieScene
 
class FTrackInstancePropertyBindings
{
public:
 
    MOVIESCENE_API FTrackInstancePropertyBindings(FName InPropertyName, const FString& InPropertyPath);
 
    template <typename ValueType>
    void CallFunction(UObject& InRuntimeObject, typename TCallTraits<ValueType>::ParamType PropertyValue)
    {
        const FResolvedPropertyAndFunction& PropAndFunction = FindOrAdd(InRuntimeObject);
 
        FProperty* Property = PropAndFunction.GetValidProperty();
        if (Property && Property->HasSetter())
        {
            Property->CallSetter(&InRuntimeObject, &PropertyValue);
        }
        else if (UFunction* SetterFunction = PropAndFunction.SetterFunction.Get())
        {
            InvokeSetterFunction(&InRuntimeObject, SetterFunction, PropertyValue);
        }
        else if (ValueType* Val = PropAndFunction.GetPropertyAddress<ValueType>())
        {
            *Val = MoveTempIfPossible(PropertyValue);
        }
    }
 
    MOVIESCENE_API void CallFunctionForEnum( UObject& InRuntimeObject, int64 PropertyValue );
 
    MOVIESCENE_API void CacheBinding(const UObject& InRuntimeObject);
 
    MOVIESCENE_API FProperty* GetProperty(const UObject& Object);
 
    MOVIESCENE_API bool HasValidBinding(const UObject& Object);
 
    MOVIESCENE_API const UStruct* GetPropertyStruct(const UObject& Object);
 
    template <typename ValueType>
    ValueType GetCurrentValue(const UObject& Object)
    {
        ValueType Value{};
 
        const FResolvedPropertyAndFunction& PropAndFunction = FindOrAdd(Object);
        TryGetPropertyValue<ValueType>(PropAndFunction, Value);
 
        return Value;
    }
 
    template <typename ValueType>
    TOptional<ValueType> GetOptionalValue(const UObject& Object)
    {
        ValueType Value{};
 
        const FResolvedPropertyAndFunction& PropAndFunction = FindOrAdd(Object);
        if (TryGetPropertyValue<ValueType>(PropAndFunction, Value))
        {
            return Value;
        }
 
        return TOptional<ValueType>();
    }
 
    MOVIESCENE_API int64 GetCurrentValueForEnum(const UObject& Object);
 
    template <typename ValueType>
    void SetCurrentValue(UObject& Object, typename TCallTraits<ValueType>::ParamType InValue)
    {
        const FResolvedPropertyAndFunction& PropAndFunction = FindOrAdd(Object);
 
        if (ValueType* Val = PropAndFunction.GetPropertyAddress<ValueType>())
        {
            *Val = InValue;
        }
    }
 
    const FString& GetPropertyPath() const
    {
        return PropertyPath;
    }
 
    const FName& GetPropertyName() const
    {
        return PropertyName;
    }
 
public:
 
    MOVIESCENE_API static TOptional<UE::MovieScene::FSourcePropertyValue> StaticValue(const UObject* Object, FStringView InPropertyPath);
    MOVIESCENE_API static TOptional<TPair<const FProperty*, UE::MovieScene::FSourcePropertyValue>> StaticPropertyAndValue(const UObject* Object, FStringView InPropertyPath);
 
    template <typename ValueType>
    static TOptional<ValueType> StaticValue(const UObject* Object, FStringView InPropertyPath)
    {
        checkf(Object, TEXT("No object specified"));
 
        FResolvedPropertyAndFunction PropAndFunction = FindPropertyAndFunction(Object, InPropertyPath);
 
        ValueType Value;
        if (TryGetPropertyValue<ValueType>(PropAndFunction, Value))
        {
            return Value;
        }
 
        return TOptional<ValueType>();
    }
 
    static MOVIESCENE_API FProperty* FindProperty(const UObject* Object, FStringView InPropertyPath);
 
private:
 
    template<typename T>
    static void InvokeSetterFunction(UObject* InRuntimeObject, UFunction* Setter, T&& InPropertyValue);
 
    using FCachedProperty = UE::MovieScene::FCachedProperty;
    using FVolatileProperty = UE::MovieScene::FVolatileProperty;
 
    struct FResolvedPropertyAndFunction
    {
        TVariant<FCachedProperty, FVolatileProperty> ResolvedProperty;
        TWeakObjectPtr<UFunction> SetterFunction;
        
        MOVIESCENE_API FProperty* GetValidProperty() const;
 
        MOVIESCENE_API void* GetContainerAddress() const;
 
        template<typename ValueType>
        ValueType* GetPropertyAddress() const
        {
            if (const FCachedProperty* CachedProperty = ResolvedProperty.TryGet<FCachedProperty>())
            {
                return CachedProperty->GetPropertyAddress<ValueType>();
            }
            else if (const FVolatileProperty* VolatileProperty = ResolvedProperty.TryGet<FVolatileProperty>())
            {
                return VolatileProperty->GetPropertyAddress<ValueType>();
            }
            else
            {
                return nullptr;
            }
        }
 
        FResolvedPropertyAndFunction()
            : ResolvedProperty()
            , SetterFunction( nullptr )
        {}
    };
 
    MOVIESCENE_API static FResolvedPropertyAndFunction FindPropertyAndFunction(const UObject* Object, FStringView InPropertyPath);
 
    template <typename ValueType>
    static bool TryGetPropertyValue(const FResolvedPropertyAndFunction& PropAndFunction, ValueType& OutValue)
    {
        if (const ValueType* Value = PropAndFunction.GetPropertyAddress<ValueType>())
        {
            OutValue = *Value;
            return true;
        }
        return false;
    }
 
    MOVIESCENE_API const FResolvedPropertyAndFunction& FindOrAdd(const UObject& InObject);
 
private:
 
    TMap< FObjectKey, FResolvedPropertyAndFunction > RuntimeObjectToFunctionMap;
 
    FString PropertyPath;
 
    FName FunctionName;
 
    FName PropertyName;
 
    friend class FTrackInstancePropertyBindingsTests;
};
 
template<> MOVIESCENE_API void FTrackInstancePropertyBindings::CallFunction<bool>(UObject& InRuntimeObject, TCallTraits<bool>::ParamType PropertyValue);
template<> MOVIESCENE_API bool FTrackInstancePropertyBindings::TryGetPropertyValue<bool>(const FResolvedPropertyAndFunction& PropAndFunction, bool& OutValue);
template<> MOVIESCENE_API void FTrackInstancePropertyBindings::SetCurrentValue<bool>(UObject& Object, TCallTraits<bool>::ParamType InValue);
 
template<> MOVIESCENE_API void FTrackInstancePropertyBindings::CallFunction<UObject*>(UObject& InRuntimeObject, UObject* PropertyValue);
template<> MOVIESCENE_API bool FTrackInstancePropertyBindings::TryGetPropertyValue<UObject*>(const FResolvedPropertyAndFunction& PropAndFunction, UObject*& OutValue);
template<> MOVIESCENE_API void FTrackInstancePropertyBindings::SetCurrentValue<UObject*>(UObject& Object, UObject* InValue);
 
template<typename T>
void FTrackInstancePropertyBindings::InvokeSetterFunction(UObject* InRuntimeObject, UFunction* Setter, T&& InPropertyValue)
{
    // CacheBinding already guarantees that the function has >= 1 parameters
    const int32 ParmsSize = Setter->ParmsSize;
 
    // This should all be const really, but ProcessEvent only takes a non-const void*
    void* InputParameter = const_cast<typename TDecay<T>::Type*>(&InPropertyValue);
 
    // By default we try and use the existing stack value
    uint8* Params = reinterpret_cast<uint8*>(InputParameter);
 
    check(InRuntimeObject && Setter);
    if (Setter->ReturnValueOffset != MAX_uint16 || Setter->NumParms > 0)
    {
        // Function has a return value or multiple parameters, we need to initialize memory for the entire parameter pack
        // We use alloca here (as in UObject::ProcessEvent) to avoid a heap allocation. Alloca memory survives the current function's stack frame.
        Params = reinterpret_cast<uint8*>(FMemory_Alloca(ParmsSize));
 
        bool bFirstProperty = true;
        for (FProperty* Property = Setter->PropertyLink; Property; Property = Property->PropertyLinkNext)
        {
            // Initialize the parameter pack with any param properties that reside in the container
            if (Property->IsInContainer(ParmsSize))
            {
                Property->InitializeValue_InContainer(Params);
 
                // The first encountered property is assumed to be the input value so initialize this with the user-specified value from InPropertyValue
                if (Property->HasAnyPropertyFlags(CPF_Parm) && !Property->HasAnyPropertyFlags(CPF_ReturnParm) && bFirstProperty)
                {
                    const bool bIsValid = ensureMsgf(sizeof(T) == Property->GetElementSize(), TEXT("Property type does not match for Sequencer setter function %s::%s (%" SIZE_T_FMT "bytes != %ibytes"), *InRuntimeObject->GetName(), *Setter->GetName(), sizeof(T), Property->GetElementSize());
                    if (bIsValid)
                    {
                        Property->CopyCompleteValue(Property->ContainerPtrToValuePtr<void>(Params), &InPropertyValue);
                    }
                    else
                    {
                        return;
                    }
                }
                bFirstProperty = false;
            }
        }
    }
 
    // Now we have the parameters set up correctly, call the function
    InRuntimeObject->ProcessEvent(Setter, Params);
}