MovieScenePropertyTraits.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "EntitySystem/MovieScenePropertySystemTypes.h"
#include "EntitySystem/MovieScenePropertyMetaData.h"
#include "EntitySystem/MovieSceneOperationalTypeConversions.h"
#include "EntitySystem/MovieSceneIntermediatePropertyValue.h"
#include "EntitySystem/MovieSceneVariantPropertyTypeIndex.h"
#include "EntitySystem/MovieScenePropertySupport.h"
#include "Channels/MovieSceneUnpackedChannelValues.h"
#include "MovieSceneCommonHelpers.h"
#include "Misc/GeneratedTypeName.h"
 
 
#include "UObject/Class.h"
#include "UObject/UnrealType.h"
#include "UObject/TextProperty.h"
#include "UObject/NoExportTypes.h"
 
class UMovieSceneTrack;
 
 
namespace UE
{
namespace MovieScene
{
 
template<typename PropertyTraits, typename ...CompositeTypes>
struct TVariantPropertyComponentHandler;
 
 
template<typename T>
void UnpackChannelsFromOperational(T&&, const FProperty& Property, FUnpackedChannelValues&)
{
    static_assert(!std::is_same_v<T, T>, "Please implement this function for the necessary types to support unpacking the property type into its constituent channels");
}
 
struct IPropertyTraits
{
    using MetaDataType = TPropertyMetaData<>;
 
    virtual ~IPropertyTraits()
    {
    }
 
    virtual TSubclassOf<UMovieSceneTrack> GetTrackClass(const FProperty* InProperty) const
    {
        return nullptr;
    }
    virtual bool InitializeTrackFromProperty(UMovieSceneTrack* InTrack, const FProperty* InProperty) const
    {
        return false;
    }
};
 
 
template<typename ...UObjectPropertyTypes>
struct TSupportedPropertyTypes
{
 
};
template<typename ...CompositeTypes>
struct TCompositeChannelMapping
{
    
};
 
 
template<typename UObjectPropertyType, typename InMemoryType, bool bInIsComposite = true>
struct TPropertyTraits : IPropertyTraits
{
    static constexpr bool bIsComposite     = bInIsComposite;
    static constexpr bool bNeedsConversion = !std::is_same_v<InMemoryType, UObjectPropertyType>;
 
    using TraitsType          = TPropertyTraits<UObjectPropertyType, InMemoryType, bInIsComposite>;
    using StorageType         = InMemoryType;
    using StorageTypeParam    = typename TCallTraits<StorageType>::ParamType;
 
    FORCEINLINE static bool SupportsProperty(const FProperty& InProperty)
    {
        return TPropertyMatch<UObjectPropertyType>::SupportsProperty(InProperty);
    }
    FORCEINLINE static FIntermediatePropertyValue CoercePropertyValue(const FProperty& InProperty, const FSourcePropertyValue& InPropertyValue)
    {
        StorageType Value;
        ConvertOperationalProperty(*InPropertyValue.Cast<UObjectPropertyType>(), Value);
        return FIntermediatePropertyValue::FromValue(Value);
    }
    FORCEINLINE static void UnpackChannels(const InMemoryType& Value, const FProperty& Property, FUnpackedChannelValues& OutUnpackedValues)
    {
        UnpackChannelsFromOperational(Value, Property, OutUnpackedValues);
    }
 
    FORCEINLINE static void GetObjectPropertyValue(const UObject* InObject, const FCustomPropertyAccessor& BaseCustomAccessor, StorageType& OutValue)
    {
        const TCustomPropertyAccessor<TraitsType>& CustomAccessor = static_cast<const TCustomPropertyAccessor<TraitsType>&>(BaseCustomAccessor);
 
        OutValue = (*CustomAccessor.Functions.Getter)(InObject);
    }
    FORCEINLINE static void GetObjectPropertyValue(const UObject* InObject, uint16 PropertyOffset, StorageType& OutValue)
    {
        const UObjectPropertyType* PropertyAddress = reinterpret_cast<const UObjectPropertyType*>( reinterpret_cast<const uint8*>(InObject) + PropertyOffset );
 
        if constexpr (bNeedsConversion)
        {
            ConvertOperationalProperty(*PropertyAddress, OutValue);
        }
        else
        {
            OutValue = *PropertyAddress;
        }
    }
    FORCEINLINE static void GetObjectPropertyValue(const UObject* InObject, FTrackInstancePropertyBindings* PropertyBindings, StorageType& OutValue)
    {
        if constexpr (bNeedsConversion)
        {
            UObjectPropertyType Value = PropertyBindings->GetCurrentValue<UObjectPropertyType>(*InObject);
            ConvertOperationalProperty(Value, OutValue);
        }
        else
        {
            OutValue = PropertyBindings->GetCurrentValue<UObjectPropertyType>(*InObject);
        }
    }
 
    FORCEINLINE static void GetObjectPropertyValue(const UObject* InObject, const FName& PropertyPath, StorageType& OutValue)
    {
        TOptional<UObjectPropertyType> Property = FTrackInstancePropertyBindings::StaticValue<UObjectPropertyType>(InObject, *PropertyPath.ToString());
        if (Property)
        {
            if constexpr (bNeedsConversion)
            {
                ConvertOperationalProperty(Property.GetValue(), OutValue);
            }
            else
            {
                OutValue = Property.GetValue();
            }
        }
    }
 
    FORCEINLINE static void SetObjectPropertyValue(UObject* InObject, const FCustomPropertyAccessor& BaseCustomAccessor, StorageTypeParam InValue)
    {
        const TCustomPropertyAccessor<TraitsType>& CustomAccessor = static_cast<const TCustomPropertyAccessor<TraitsType>&>(BaseCustomAccessor);
        (*CustomAccessor.Functions.Setter)(InObject, InValue);
    }
    FORCEINLINE static void SetObjectPropertyValue(UObject* InObject, uint16 PropertyOffset, StorageTypeParam InValue)
    {
        UObjectPropertyType* PropertyAddress = reinterpret_cast<UObjectPropertyType*>( reinterpret_cast<uint8*>(InObject) + PropertyOffset );
        if constexpr (bNeedsConversion)
        {
            ConvertOperationalProperty(InValue, *PropertyAddress);
        }
        else
        {
            *PropertyAddress = InValue;
        }
    }
    FORCEINLINE static void SetObjectPropertyValue(UObject* InObject, FTrackInstancePropertyBindings* PropertyBindings, StorageTypeParam InValue)
    {
        if constexpr (bNeedsConversion)
        {
            UObjectPropertyType NewValue{};
            ConvertOperationalProperty(InValue, NewValue);
 
            PropertyBindings->CallFunction<UObjectPropertyType>(*InObject, NewValue);
        }
        else
        {
            PropertyBindings->CallFunction<UObjectPropertyType>(*InObject, InValue);
        }
    }
 
    template<typename ...T>
    FORCEINLINE static StorageType CombineComposites(T&&... InComposites)
    {
        return StorageType{ Forward<T>(InComposites)... };
    }
};
 
template<typename StorageType>
struct TDynamicVariantTraitsBase
{
    using StorageTypeParam        = typename TCallTraits<StorageType>::ParamType;
 
    using CastToOperationalPtr    = void(*)(const void*, StorageType&);
    using CastToFinalPtr          = void(*)(StorageTypeParam, void*);
    using RetrieveSlowPropertyPtr = void(*)(const UObject*, FTrackInstancePropertyBindings*, StorageType&);
    using ApplySlowPropertyPtr    = void(*)(UObject*, FTrackInstancePropertyBindings*, StorageTypeParam);
    using InitializeNewTrackPtr   = void(*)(UMovieSceneTrack*, const FProperty*);
 
    UScriptStruct*                Struct              = nullptr;
    TSubclassOf<UMovieSceneTrack> TrackClass          = nullptr;
    CastToOperationalPtr          CastToOperational   = nullptr;
    CastToFinalPtr                CastToFinal         = nullptr;
    RetrieveSlowPropertyPtr       RetrieveSlowProperty= nullptr;
    ApplySlowPropertyPtr          ApplySlowProperty   = nullptr;
    InitializeNewTrackPtr         InitializeNewTrack  = nullptr;
};
 
template<typename UObjectPropertyType, typename StorageType>
struct TDynamicVariantTraits : TDynamicVariantTraitsBase<StorageType>
{
    using StorageTypeParam = typename TCallTraits<StorageType>::ParamType;
 
    using InitializeNewTrackPtr   = void(*)(UMovieSceneTrack*, const FProperty*);
 
    TDynamicVariantTraits()
    {
        this->Struct               = TBaseStructure<UObjectPropertyType>::Get();
        this->CastToOperational    = CastToOperationalImpl;
        this->CastToFinal          = CastToFinalImpl;
        this->RetrieveSlowProperty = RetrieveSlowPropertyImpl;
        this->ApplySlowProperty    = ApplySlowPropertyImpl;
    }
    TDynamicVariantTraits(UScriptStruct* InStruct)
    {
        this->Struct               = InStruct;
        this->CastToOperational    = CastToOperationalImpl;
        this->CastToFinal          = CastToFinalImpl;
        this->RetrieveSlowProperty = RetrieveSlowPropertyImpl;
        this->ApplySlowProperty    = ApplySlowPropertyImpl;
    }
 
    TDynamicVariantTraits<UObjectPropertyType, StorageType>& SetTrackClass(TSubclassOf<UMovieSceneTrack> InTrackClass)
    {
        this->TrackClass = InTrackClass;
        return *this;
    }
 
    TDynamicVariantTraits<UObjectPropertyType, StorageType>& SetTrackInitializer(InitializeNewTrackPtr InFunc)
    {
        this->InitializeNewTrack = InFunc;
        return *this;
    }
 
    static void CastToOperationalImpl(const void* In, StorageType& OutValue)
    {
        const UObjectPropertyType* PropertyAddress = static_cast<const UObjectPropertyType*>(In);
        ConvertOperationalProperty(*PropertyAddress, OutValue);
    }
    static void CastToFinalImpl(StorageTypeParam InValue, void* Out)
    {
        UObjectPropertyType* PropertyAddress = static_cast<UObjectPropertyType*>(Out);
        ConvertOperationalProperty(InValue, *PropertyAddress);
    }
 
    static void RetrieveSlowPropertyImpl(const UObject* InObject, FTrackInstancePropertyBindings* PropertyBindings, StorageType& OutValue)
    {
        UObjectPropertyType Value = PropertyBindings->GetCurrentValue<UObjectPropertyType>(*InObject);
        ConvertOperationalProperty(Value, OutValue);
    }
    static void ApplySlowPropertyImpl(UObject* InObject, FTrackInstancePropertyBindings* PropertyBindings, StorageTypeParam InValue)
    {
        UObjectPropertyType NewValue{};
        ConvertOperationalProperty(InValue, NewValue);
 
        PropertyBindings->CallFunction<UObjectPropertyType>(*InObject, NewValue);
    }
};
 
template<typename InMemoryType, typename ...UObjectPropertyTypes>
struct TVariantPropertyTraits
    : IPropertyTraits
{
    static constexpr int32 CompileTimeNum = sizeof...(UObjectPropertyTypes);
    static constexpr bool  bIsComposite   = true;
 
    using StorageType    = InMemoryType;
    using StorageTypeParam = typename TCallTraits<StorageType>::ParamType;
 
    using MetaDataType   = TPropertyMetaData<FVariantPropertyTypeIndex>;
    using PublicMetaData = TPropertyMetaData<>;
 
    using TraitsType     = TVariantPropertyTraits<StorageType, UObjectPropertyTypes...>;
 
    static bool SupportsProperty(const FProperty& InProperty)
    {
        FVariantPropertyTypeIndex Unused;
        return ComputeVariantIndex(InProperty, Unused);
    }
 
    static bool ComputeVariantIndex(const FProperty& Property, FVariantPropertyTypeIndex& OutTypeIndex)
    {
        using FuncDef = bool (*)(const FProperty& InProperty);
        static constexpr FuncDef Funcs[] = { &TPropertyMatch<UObjectPropertyTypes>::SupportsProperty... };
 
        for (int32 Index = 0; Index < CompileTimeNum; ++Index)
        {
            if (Funcs[Index](Property))
            {
                OutTypeIndex.Index = Index;
                return true;
            }
        }
        return false;
    }
 
    static FIntermediatePropertyValue CoercePropertyValue(const FProperty& InProperty, const FSourcePropertyValue& InPropertyValue)
    {
        FVariantPropertyTypeIndex VariantIndex;
 
        const bool bIsSupported = ComputeVariantIndex(InProperty, VariantIndex);
        check(bIsSupported);
 
        using FuncDef = FIntermediatePropertyValue (*)(const FProperty& InProperty, const FSourcePropertyValue& InPropertyValue);
        static constexpr FuncDef Funcs[] = { &TPropertyTraits<UObjectPropertyTypes, StorageType>::CoercePropertyValue... };
 
        return CoercePropertyValueChecked(InProperty, VariantIndex, InPropertyValue);
    }
 
    static FIntermediatePropertyValue CoercePropertyValueChecked(const FProperty& InProperty, FVariantPropertyTypeIndex VariantIndex, const FSourcePropertyValue& InPropertyValue)
    {
        using FuncDef = FIntermediatePropertyValue (*)(const FProperty& InProperty, const FSourcePropertyValue& InPropertyValue);
        static constexpr FuncDef Funcs[] = { &TPropertyTraits<UObjectPropertyTypes, StorageType>::CoercePropertyValue... };
 
        return Funcs[VariantIndex.Index](InProperty, InPropertyValue);
    }
 
    static void UnpackChannels(const InMemoryType& Value, const FProperty& Property, FUnpackedChannelValues& OutUnpackedValues)
    {
        UnpackChannelsFromOperational(Value, Property, OutUnpackedValues);
    }
 
    template<typename ...Composites>
    static TVariantPropertyComponentHandler<TraitsType, Composites...> MakeHandler()
    {
        return TVariantPropertyComponentHandler<TraitsType, Composites...>();
    }
 
    static bool NeedsMetaData()
    {
        return sizeof...(UObjectPropertyTypes) > 1;
    }
 
    static void GetObjectPropertyValue(const UObject* InObject, FVariantPropertyTypeIndex VariantTypeIndex, const FCustomPropertyAccessor& BaseCustomAccessor, StorageType& OutValue)
    {
        const TCustomPropertyAccessor<TraitsType>& CustomAccessor = static_cast<const TCustomPropertyAccessor<TraitsType>&>(BaseCustomAccessor);
 
        OutValue = (*CustomAccessor.Functions.Getter)(InObject);
    }
 
    static void GetObjectPropertyValue(const UObject* InObject, FVariantPropertyTypeIndex VariantTypeIndex, uint16 PropertyOffset, StorageType& OutValue)
    {
        using FuncDef = void (*)(const UObject*, uint16, StorageType&);
        static constexpr FuncDef Funcs[] = { &TPropertyTraits<UObjectPropertyTypes, StorageType>::GetObjectPropertyValue... };
 
        if (VariantTypeIndex.Index >= 0 && VariantTypeIndex.Index < CompileTimeNum)
        {
            Funcs[VariantTypeIndex.Index](InObject, PropertyOffset, OutValue);
        }
    }
    static void GetObjectPropertyValue(const UObject* InObject, FVariantPropertyTypeIndex VariantTypeIndex, FTrackInstancePropertyBindings* PropertyBindings, StorageType& OutValue)
    {
        using FuncDef = void (*)(const UObject*, FTrackInstancePropertyBindings*, StorageType&);
        static constexpr FuncDef Funcs[] = { &TPropertyTraits<UObjectPropertyTypes, StorageType>::GetObjectPropertyValue... };
 
        if (VariantTypeIndex.Index >= 0 && VariantTypeIndex.Index < CompileTimeNum)
        {
            Funcs[VariantTypeIndex.Index](InObject, PropertyBindings, OutValue);
        }
    }
 
    static void SetObjectPropertyValue(UObject* InObject, FVariantPropertyTypeIndex VariantTypeIndex, const FCustomPropertyAccessor& BaseCustomAccessor, StorageTypeParam InValue)
    {
        const TCustomPropertyAccessor<TraitsType>& CustomAccessor = static_cast<const TCustomPropertyAccessor<TraitsType>&>(BaseCustomAccessor);
        (*CustomAccessor.Functions.Setter)(InObject, InValue);
    }
    static void SetObjectPropertyValue(UObject* InObject, FVariantPropertyTypeIndex VariantTypeIndex, uint16 PropertyOffset, StorageTypeParam InValue)
    {
        using FuncDef = void (*)(UObject*, uint16, StorageTypeParam);
        static constexpr FuncDef Funcs[] = { &TPropertyTraits<UObjectPropertyTypes, StorageType>::SetObjectPropertyValue... };
 
        if (VariantTypeIndex.Index >= 0 && VariantTypeIndex.Index < CompileTimeNum)
        {
            Funcs[VariantTypeIndex.Index](InObject, PropertyOffset, InValue);
        }
    }
    static void SetObjectPropertyValue(UObject* InObject, FVariantPropertyTypeIndex VariantTypeIndex, FTrackInstancePropertyBindings* PropertyBindings, StorageTypeParam InValue)
    {
        using FuncDef = void (*)(UObject*, FTrackInstancePropertyBindings*, StorageTypeParam);
        static constexpr FuncDef Funcs[] = { &TPropertyTraits<UObjectPropertyTypes, StorageType>::SetObjectPropertyValue... };
 
        if (VariantTypeIndex.Index >= 0 && VariantTypeIndex.Index < CompileTimeNum)
        {
            Funcs[VariantTypeIndex.Index](InObject, PropertyBindings, InValue);
        }
    }
 
    template<typename ...T>
    static StorageType CombineComposites(FVariantPropertyTypeIndex VariantTypeIndex, T&&... InComposites)
    {
        return StorageType{ Forward<T>(InComposites)... };
    }
};
 
 
template<typename InMemoryType, typename ...UObjectPropertyTypes>
struct TDynamicVariantPropertyTraits : IPropertyTraits
{
    using StaticTraits     = TVariantPropertyTraits<InMemoryType, UObjectPropertyTypes...>;
    using TraitsType       = TDynamicVariantPropertyTraits<InMemoryType, UObjectPropertyTypes...>;
    using StorageType      = InMemoryType;
    using StorageTypeParam = typename TCallTraits<StorageType>::ParamType;
 
    using MetaDataType   = TPropertyMetaData<FVariantPropertyTypeIndex>;
    using PublicMetaData = TPropertyMetaData<>;
 
    static constexpr bool  bIsComposite   = true;
 
    TArray<TDynamicVariantTraitsBase<StorageType>> DynamicTraits;
 
    bool NeedsMetaData() const
    {
        return sizeof...(UObjectPropertyTypes) + DynamicTraits.Num() > 1;
    }
 
    static void UnpackChannels(const InMemoryType& Value, const FProperty& Property, FUnpackedChannelValues& OutUnpackedValues)
    {
        StaticTraits::UnpackChannels(Value, Property, OutUnpackedValues);
    }
 
    template<typename ...Composites>
    static TVariantPropertyComponentHandler<TraitsType, Composites...> MakeHandler()
    {
        return TVariantPropertyComponentHandler<TraitsType, Composites...>();
    }
 
    virtual TSubclassOf<UMovieSceneTrack> GetTrackClass(const FProperty* InProperty) const override
    {
        if (const FStructProperty* StructProperty = CastField<const FStructProperty>(InProperty))
        {
            const TDynamicVariantTraitsBase<StorageType>* Variant = Algo::FindBy(DynamicTraits, StructProperty->Struct, &TDynamicVariantTraitsBase<StorageType>::Struct);
            if (Variant)
            {
                return Variant->TrackClass;
            }
        }
        return nullptr;
    }
    virtual bool InitializeTrackFromProperty(UMovieSceneTrack* InTrack, const FProperty* InProperty) const override
    {
        if (const FStructProperty* StructProperty = CastField<const FStructProperty>(InProperty))
        {
            const TDynamicVariantTraitsBase<StorageType>* Variant = Algo::FindBy(DynamicTraits, StructProperty->Struct, &TDynamicVariantTraitsBase<StorageType>::Struct);
            if (Variant && Variant->InitializeNewTrack)
            {
                (*Variant->InitializeNewTrack)(InTrack, InProperty);
                return true;
            }
        }
        return false;
    }
 
    bool ComputeVariantIndex(const FProperty& InProperty, FVariantPropertyTypeIndex& OutTypeIndex) const
    {
        if (StaticTraits::ComputeVariantIndex(InProperty, OutTypeIndex))
        {
            return true;
        }
 
        if (const FStructProperty* StructProperty = CastField<const FStructProperty>(&InProperty))
        {
            for (int32 DynamicIndex = 0; DynamicIndex < DynamicTraits.Num(); ++DynamicIndex)
            {
                if (StructProperty->Struct == DynamicTraits[DynamicIndex].Struct)
                {
                    OutTypeIndex.Index = StaticTraits::CompileTimeNum + DynamicIndex;
                    return true;
                }
            }
        }
        return false;
    }
    bool SupportsProperty(const FProperty& InProperty) const
    {
        FVariantPropertyTypeIndex Unused;
        return ComputeVariantIndex(InProperty, Unused);
    }
    FIntermediatePropertyValue CoercePropertyValue(const FProperty& InProperty, const FSourcePropertyValue& InPropertyValue) const
    {
        FVariantPropertyTypeIndex StaticVariantIndex;
        if (StaticTraits::ComputeVariantIndex(InProperty, StaticVariantIndex))
        {
            return StaticTraits::CoercePropertyValueChecked(InProperty, StaticVariantIndex, InPropertyValue);
        }
 
        check(DynamicTraits.Num() > 0);
 
        const FStructProperty* StructProperty = CastFieldChecked<const FStructProperty>(&InProperty);
 
        for (int32 DynamicIndex = 0; DynamicIndex < DynamicTraits.Num()-1; ++DynamicIndex)
        {
            if (StructProperty->Struct == DynamicTraits[DynamicIndex].Struct)
            {
                StorageType NewValue;
                DynamicTraits[DynamicIndex].CastToOperational(InPropertyValue.Get(), NewValue);
                return FIntermediatePropertyValue::FromValue(NewValue);
            }
        }
 
        check(StructProperty->Struct == DynamicTraits.Last().Struct);
 
        StorageType NewValue;
        DynamicTraits.Last().CastToOperational(InPropertyValue.Get(), NewValue);
        return FIntermediatePropertyValue::FromValue(NewValue);
    }
 
    void AddDynamicType(const TDynamicVariantTraitsBase<StorageType>& Variant)
    {
        DynamicTraits.Emplace(Variant);
    }
 
    void GetObjectPropertyValue(const UObject* InObject, FVariantPropertyTypeIndex VariantTypeIndex, uint16 PropertyOffset, StorageType& OutValue) const
    {
        if (VariantTypeIndex.Index >= StaticTraits::CompileTimeNum)
        {
            const int32 DynamicIndex = int32(VariantTypeIndex.Index) - StaticTraits::CompileTimeNum;
            if (DynamicTraits.IsValidIndex(DynamicIndex))
            {
                const void* PropertyAddress = reinterpret_cast<const uint8*>(InObject) + PropertyOffset;
                DynamicTraits[DynamicIndex].CastToOperational(PropertyAddress, OutValue);
            }
        }
        else
        {
            StaticTraits::GetObjectPropertyValue(InObject, VariantTypeIndex, PropertyOffset, OutValue);
        }
    }
    void GetObjectPropertyValue(const UObject* InObject, FVariantPropertyTypeIndex VariantTypeIndex, FTrackInstancePropertyBindings* PropertyBindings, StorageType& OutValue) const
    {
        if (VariantTypeIndex.Index >= StaticTraits::CompileTimeNum)
        {
            const int32 DynamicIndex = int32(VariantTypeIndex.Index) - StaticTraits::CompileTimeNum;
            if (DynamicTraits.IsValidIndex(DynamicIndex))
            {
                DynamicTraits[DynamicIndex].RetrieveSlowProperty(InObject, PropertyBindings, OutValue);
            }
        }
        else
        {
            StaticTraits::GetObjectPropertyValue(InObject, VariantTypeIndex, PropertyBindings, OutValue);
        }
    }
 
    static void GetObjectPropertyValue(const UObject* InObject, FVariantPropertyTypeIndex VariantTypeIndex, const FCustomPropertyAccessor& BaseCustomAccessor, StorageType& OutValue)
    {
        const TCustomPropertyAccessor<TraitsType>& CustomAccessor = static_cast<const TCustomPropertyAccessor<TraitsType>&>(BaseCustomAccessor);
 
        OutValue = (*CustomAccessor.Functions.Getter)(InObject);
    }
 
    void SetObjectPropertyValue(UObject* InObject, FVariantPropertyTypeIndex VariantTypeIndex, uint16 PropertyOffset, StorageTypeParam InValue) const
    {
        if (VariantTypeIndex.Index >= StaticTraits::CompileTimeNum)
        {
            const int32 DynamicIndex = int32(VariantTypeIndex.Index) - StaticTraits::CompileTimeNum;
            if (DynamicTraits.IsValidIndex(DynamicIndex))
            {
                void* PropertyAddress = reinterpret_cast<uint8*>(InObject) + PropertyOffset;
                DynamicTraits[DynamicIndex].CastToFinal(InValue, PropertyAddress);
            }
        }
        else
        {
            StaticTraits::SetObjectPropertyValue(InObject, VariantTypeIndex, PropertyOffset, InValue);
        }
    }
    void SetObjectPropertyValue(UObject* InObject, FVariantPropertyTypeIndex VariantTypeIndex, FTrackInstancePropertyBindings* PropertyBindings, StorageTypeParam InValue) const
    {
        if (VariantTypeIndex.Index >= StaticTraits::CompileTimeNum)
        {
            const int32 DynamicIndex = int32(VariantTypeIndex.Index) - StaticTraits::CompileTimeNum;
            if (DynamicTraits.IsValidIndex(DynamicIndex))
            {
                DynamicTraits[DynamicIndex].ApplySlowProperty(InObject, PropertyBindings, InValue);
            }
        }
        else
        {
            StaticTraits::SetObjectPropertyValue(InObject, VariantTypeIndex, PropertyBindings, InValue);
        }
    }
 
    static void SetObjectPropertyValue(UObject* InObject, FVariantPropertyTypeIndex VariantTypeIndex, const FCustomPropertyAccessor& BaseCustomAccessor, StorageTypeParam InValue)
    {
        const TCustomPropertyAccessor<TraitsType>& CustomAccessor = static_cast<const TCustomPropertyAccessor<TraitsType>&>(BaseCustomAccessor);
        (*CustomAccessor.Functions.Setter)(InObject, InValue);
    }
 
    template<typename ...T>
    static StorageType CombineComposites(FVariantPropertyTypeIndex VariantTypeIndex, T&&... InComposites)
    {
        return StorageType{ Forward<T>(InComposites)... };
    }
};
 
 
 
template<typename RuntimeType, typename ...MetaDataTypes>
struct TRuntimePropertyTraits
{
    using StorageType      = RuntimeType;
    using StorageTypeParam = typename TCallTraits<StorageType>::ParamType;
    using MetaDataType     = TPropertyMetaData<MetaDataTypes...>;
 
 
    static void GetObjectPropertyValue(const UObject* InObject, const FCustomPropertyAccessor& BaseCustomAccessor, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, StorageType& OutValue)
    {}
 
    static void GetObjectPropertyValue(const UObject* InObject, uint16 PropertyOffset, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, StorageType& OutValue)
    {}
 
    static void GetObjectPropertyValue(const UObject* InObject, FTrackInstancePropertyBindings* PropertyBindings, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, StorageType& OutValue)
    {}
 
    static void GetObjectPropertyValue(const UObject* InObject, const FName& PropertyPath, StorageType& OutValue)
    {}
 
    static void SetObjectPropertyValue(UObject* InObject, const FCustomPropertyAccessor& BaseCustomAccessor, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, StorageTypeParam InValue)
    {}
 
    static void SetObjectPropertyValue(UObject* InObject, uint16 PropertyOffset, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, StorageTypeParam InValue)
    {}
 
    static void SetObjectPropertyValue(UObject* InObject, FTrackInstancePropertyBindings* PropertyBindings, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, StorageTypeParam InValue)
    {}
};
 
 
 
template<typename UObjectPropertyType, bool bInIsComposite = true>
using TDirectPropertyTraits = TPropertyTraits<UObjectPropertyType, UObjectPropertyType, bInIsComposite>;
 
template<typename UObjectPropertyType, typename InMemoryType, bool bInIsComposite = true>
struct UE_DEPRECATED(5.4, "Please use TPropertyTraits directly.") TIndirectPropertyTraits : TPropertyTraits<UObjectPropertyType, InMemoryType, bInIsComposite>
{};
 
 
} // namespace MovieScene
} // namespace UE