MovieScenePropertySystemTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "UObject/Class.h"
#include "UObject/Object.h"
#include "UObject/NameTypes.h"
#include "Templates/SharedPointer.h"
#include "Templates/UnrealTypeTraits.h"
#include "Containers/StringView.h"
#include "EntitySystem/MovieSceneComponentAccessors.h"
#include "EntitySystem/MovieScenePropertyMetaData.h"
 
class UClass;
class FTrackInstancePropertyBindings;
 
 
namespace UE::MovieScene
{
 
struct FCustomPropertyIndex
{
    uint16 Value;
};
 
struct FCompositePropertyTypeID
{
    FCompositePropertyTypeID() : TypeIndex(INDEX_NONE) {}
 
    static FCompositePropertyTypeID FromIndex(int32 Index)
    {
        return FCompositePropertyTypeID{ Index };
    }
 
    int32 AsIndex() const
    {
        return TypeIndex;
    }
 
    explicit operator bool() const
    {
        return TypeIndex != INDEX_NONE;
    }
 
private:
    FCompositePropertyTypeID(int32 InTypeIndex) : TypeIndex(InTypeIndex) {}
 
    friend class FPropertyRegistry;
    int32 TypeIndex;
};
 
 
template<typename PropertyTraits>
struct TCompositePropertyTypeID : FCompositePropertyTypeID
{};
 
namespace Private
{
    template<typename, typename = void>
    constexpr bool PropertyTraitsHaveCustomAccessorStorageType = false;
 
    template<typename T>
    constexpr bool PropertyTraitsHaveCustomAccessorStorageType<T, std::void_t<decltype(sizeof(typename T::CustomAccessorStorageType))>> = true;
 
    template<typename PropertyTraits, bool Custom>
    struct TCustomPropertyAccessorStorageTypeImpl;
 
    template<typename PropertyTraits>
    struct TCustomPropertyAccessorStorageTypeImpl<PropertyTraits, false>
    {
        using Value = typename PropertyTraits::StorageType;
    };
    
    template<typename PropertyTraits>
    struct TCustomPropertyAccessorStorageTypeImpl<PropertyTraits, true>
    {
        using Value = typename PropertyTraits::CustomAccessorStorageType;
    };
    
    template<typename PropertyTraits>
    struct TCustomPropertyAccessorStorageType : TCustomPropertyAccessorStorageTypeImpl<PropertyTraits, PropertyTraitsHaveCustomAccessorStorageType<PropertyTraits>>
    {};
 
    namespace Tests
    {
        struct TestNormal
        {
            using StorageType = bool;
        };
        static_assert(PropertyTraitsHaveCustomAccessorStorageType<TestNormal> == false, "Normal has no custom storage type");
        static_assert(std::is_same_v<TCustomPropertyAccessorStorageType<TestNormal>::Value, bool>, "Normal has bool storage type");
 
        struct TestCustom
        {
            using StorageType = bool;
            using CustomAccessorStorageType = int;
        };
        static_assert(PropertyTraitsHaveCustomAccessorStorageType<TestCustom> == true, "Custom does have custom storage type");
        static_assert(std::is_same_v<TCustomPropertyAccessorStorageType<TestCustom>::Value, int>, "Custom has int storage type");
    }
}
 
template<typename PropertyTraits, typename MetaDataType>
struct TCustomPropertyAccessorFunctionsImpl;
 
template<typename PropertyTraits, typename ...MetaDataTypes>
struct TCustomPropertyAccessorFunctionsImpl<PropertyTraits, TPropertyMetaData<MetaDataTypes...>>
{
    using StorageType = typename Private::TCustomPropertyAccessorStorageType<PropertyTraits>::Value;
    using ParamType   = typename TCallTraits<StorageType>::ParamType;
 
    using GetterFunc = StorageType (*)(const UObject* Object, MetaDataTypes...);
    using SetterFunc = void        (*)(UObject* Object, MetaDataTypes..., ParamType Value);
 
    GetterFunc Getter;
 
    SetterFunc Setter;
};
 
 
template<typename PropertyTraits>
struct TCustomPropertyAccessorFunctions
    : TCustomPropertyAccessorFunctionsImpl<PropertyTraits, TGetPublicPropertyMetaDataT<PropertyTraits>>
{
};
 
struct FCustomPropertyAccessor
{
    UClass* Class;
 
    FName PropertyPath;
 
    FComponentTypeID AdditionalTag;
};
 
template<typename PropertyTraits>
struct TCustomPropertyAccessor : FCustomPropertyAccessor
{
    TCustomPropertyAccessor(UClass* InClass, FName InPropertyPath, const TCustomPropertyAccessorFunctions<PropertyTraits>& InFunctions)
        : FCustomPropertyAccessor{ InClass, InPropertyPath }
        , Functions(InFunctions)
    {}
 
    TCustomPropertyAccessorFunctions<PropertyTraits> Functions;
};
 
 
struct FCustomAccessorView
{
    FCustomAccessorView()
        : Base(nullptr)
        , ViewNum(0)
        , Stride(0)
    {}
 
    template<typename T, typename Allocator>
    explicit FCustomAccessorView(const TArray<T, Allocator>& InArray)
        : Base(reinterpret_cast<const uint8*>(InArray.GetData()))
        , ViewNum(InArray.Num())
        , Stride(sizeof(T))
    {}
 
    const FCustomPropertyAccessor& operator[](int32 InIndex) const
    {
        return *reinterpret_cast<const FCustomPropertyAccessor*>(Base + InIndex*Stride);
    }
 
    int32 Num() const
    {
        return ViewNum;
    }
 
    int32 FindCustomAccessorIndex(UClass* ClassType, FName PropertyPath) const
    {
        UClass* StopIterationAt = UObject::StaticClass();
 
        while (ClassType != StopIterationAt)
        {
            for (int32 Index = 0; Index < ViewNum; ++Index)
            {
                const FCustomPropertyAccessor& Accessor = (*this)[Index];
                if (Accessor.Class == ClassType && Accessor.PropertyPath == PropertyPath)
                {
                    return Index;
                }
            }
            ClassType = ClassType->GetSuperClass();
        }
 
        return INDEX_NONE;
    }
 
private:
    const uint8* Base;
    int32 ViewNum;
    int32 Stride;
};
 
 
struct ICustomPropertyRegistration
{
    virtual ~ICustomPropertyRegistration() {}
 
    virtual FCustomAccessorView GetAccessors() const = 0;
};
 
#if WITH_EDITOR
MOVIESCENE_API void AddGlobalCustomAccessor(const UClass* ClassType, FName PropertyPath);
MOVIESCENE_API void RemoveGlobalCustomAccessor(const UClass* ClassType, FName PropertyPath);
MOVIESCENE_API bool GlobalCustomAccessorExists(const UClass* ClassType, TStringView<WIDECHAR> PropertyPath);
MOVIESCENE_API bool GlobalCustomAccessorExists(const UClass* ClassType, TStringView<ANSICHAR> PropertyPath);
#endif // WITH_EDITOR
 
template<typename PropertyTraits, int InlineSize = 8>
struct TCustomPropertyRegistration : ICustomPropertyRegistration
{
    using GetterFunc = typename TCustomPropertyAccessorFunctions<PropertyTraits>::GetterFunc;
    using SetterFunc = typename TCustomPropertyAccessorFunctions<PropertyTraits>::SetterFunc;
 
    virtual FCustomAccessorView GetAccessors() const override
    {
        return FCustomAccessorView(CustomAccessors);
    }
 
    void Add(UClass* ClassType, FName PropertyName, GetterFunc Getter, SetterFunc Setter)
    {
        CustomAccessors.Add(TCustomPropertyAccessor<PropertyTraits>{ ClassType, PropertyName, { Getter, Setter } });
#if WITH_EDITOR
        AddGlobalCustomAccessor(ClassType, PropertyName);
#endif
    }
 
    void Remove(UClass* ClassType, FName PropertyName)
    {
        for (int32 Index = CustomAccessors.Num()-1; Index >= 0; --Index)
        {
            TCustomPropertyAccessor<PropertyTraits>& Accessor = CustomAccessors[Index];
            if (Accessor.Class == ClassType && Accessor.PropertyPath == PropertyName)
            {
#if WITH_EDITOR
                RemoveGlobalCustomAccessor(Accessor.Class, Accessor.PropertyPath);
#endif
                // Null out the entry rather than remove it because we don't want to invalidate any cached array indices
                Accessor.Class = nullptr;
                Accessor.PropertyPath = NAME_None;
            }
        }
    }
 
    void RemoveAll(UClass* ClassType)
    {
        for (int32 Index = CustomAccessors.Num()-1; Index >= 0; --Index)
        {
            TCustomPropertyAccessor<PropertyTraits>& Accessor = CustomAccessors[Index];
            if (Accessor.Class == ClassType)
            {
#if WITH_EDITOR
                RemoveGlobalCustomAccessor(Accessor.Class, Accessor.PropertyPath);
#endif
                // Null out the entry rather than remove it because we don't want to invalidate any cached array indices
                Accessor.Class = nullptr;
                Accessor.PropertyPath = NAME_None;
            }
        }
    }
 
protected:
 
    TArray<TCustomPropertyAccessor<PropertyTraits>, TInlineAllocator<InlineSize>> CustomAccessors;
};
 
template<typename InPropertyTraits>
struct TPropertyComponents
{
    using MetaDataType = typename InPropertyTraits::MetaDataType;
 
    FComponentTypeID PropertyTag;
    TComponentTypeID<typename InPropertyTraits::StorageType> InitialValue;
 
    TPropertyMetaDataComponents<typename InPropertyTraits::MetaDataType> MetaDataComponents;
 
    TCompositePropertyTypeID<InPropertyTraits> CompositeID;
 
    InPropertyTraits PropertyTraits;
};
 
template<typename PropertyTraits, typename MetaDataType>
struct TSetPropertyValuesImpl;
 
 
 
template<typename PropertyTraits, typename ...MetaDataTypes>
struct TSetPropertyValuesImpl<PropertyTraits, TPropertyMetaData<MetaDataTypes...>>
{
    using StorageType = typename PropertyTraits::StorageType;
    using InParamType = typename TCallTraits<typename PropertyTraits::StorageType>::ParamType;
 
    explicit TSetPropertyValuesImpl(const PropertyTraits* InTraits, const ICustomPropertyRegistration* InCustomProperties)
        : Traits(InTraits)
        , CustomProperties(InCustomProperties)
    {
        if (CustomProperties)
        {
            CustomAccessors = CustomProperties->GetAccessors();
        }
    }
 
    void ForEachEntity(UObject* InObject, FCustomPropertyIndex CustomIndex, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, InParamType ValueToSet) const;
 
    void ForEachEntity(UObject* InObject, uint16 PropertyOffset, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, InParamType ValueToSet) const;
 
 
    void ForEachEntity(UObject* InObject, const TSharedPtr<FTrackInstancePropertyBindings>& PropertyBindings, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, InParamType ValueToSet) const;
 
public:
 
    using FThreeWayAccessor  = TMultiReadOptional<FCustomPropertyIndex, uint16, TSharedPtr<FTrackInstancePropertyBindings>>;
    using FTwoWayAccessor    = TMultiReadOptional<uint16, TSharedPtr<FTrackInstancePropertyBindings>>;
 
    void ForEachAllocation(const FEntityAllocation* Allocation, TRead<UObject*> BoundObjectComponents, FThreeWayAccessor ResolvedPropertyComponents, TRead<MetaDataTypes>... MetaDataComponents, TRead<StorageType> PropertyValueComponents) const;
 
 
    void ForEachAllocation(const FEntityAllocation* Allocation, TRead<UObject*> BoundObjectComponents, FTwoWayAccessor ResolvedPropertyComponents, TRead<MetaDataTypes>... MetaDataComponents, TRead<StorageType> PropertyValueComponents) const;
 
private:
 
    const PropertyTraits* Traits;
    const ICustomPropertyRegistration* CustomProperties;
    FCustomAccessorView CustomAccessors;
};
 
 
template<typename PropertyTraits>
struct TSetPropertyValues : TSetPropertyValuesImpl<PropertyTraits, typename PropertyTraits::MetaDataType>
{
    using ParamType = typename TCallTraits<typename PropertyTraits::StorageType>::ParamType;
 
    explicit TSetPropertyValues(const PropertyTraits* InTraits, const ICustomPropertyRegistration* InCustomProperties)
        : TSetPropertyValuesImpl<PropertyTraits, typename PropertyTraits::MetaDataType>(InTraits, InCustomProperties)
    {}
};
 
 
 
 
template<typename PropertyTraits, typename MetaDataType>
struct TGetPropertyValuesImpl;
 
 
 
template<typename PropertyTraits, typename ...MetaDataTypes>
struct TGetPropertyValuesImpl<PropertyTraits, TPropertyMetaData<MetaDataTypes...>>
{
    using StorageType = typename PropertyTraits::StorageType;
 
    explicit TGetPropertyValuesImpl(const PropertyTraits* InTraits, const ICustomPropertyRegistration* InCustomProperties)
        : Traits(InTraits)
        , CustomProperties(InCustomProperties)
    {
        if (CustomProperties)
        {
            CustomAccessors = CustomProperties->GetAccessors();
        }
    }
 
    void ForEachEntity(UObject* InObject, FCustomPropertyIndex CustomPropertyIndex, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, StorageType& OutValue) const;
 
    void ForEachEntity(UObject* InObject, uint16 PropertyOffset, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, StorageType& OutValue) const;
 
    void ForEachEntity(UObject* InObject, const TSharedPtr<FTrackInstancePropertyBindings>& PropertyBindings, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, StorageType& OutValue) const;
 
public:
 
    using FThreeWayAccessor  = TMultiReadOptional<FCustomPropertyIndex, uint16, TSharedPtr<FTrackInstancePropertyBindings>>;
    using FTwoWayAccessor    = TMultiReadOptional<uint16, TSharedPtr<FTrackInstancePropertyBindings>>;
 
 
    void ForEachAllocation(const FEntityAllocation* Allocation, TRead<UObject*> BoundObjectComponents, FThreeWayAccessor ResolvedPropertyComponents, TRead<MetaDataTypes>... MetaDataComponents, TWrite<StorageType> OutValueComponents) const;
 
 
    void ForEachAllocation(const FEntityAllocation* Allocation, TRead<UObject*> BoundObjectComponents, FTwoWayAccessor ResolvedPropertyComponents, TRead<MetaDataTypes>... MetaDataComponents, TWrite<StorageType> OutValueComponents) const;
 
private:
 
    const PropertyTraits* Traits;
    const ICustomPropertyRegistration* CustomProperties;
    FCustomAccessorView CustomAccessors;
};
 
 
template<typename PropertyTraits>
struct TGetPropertyValues : TGetPropertyValuesImpl<PropertyTraits, typename PropertyTraits::MetaDataType>
{
    explicit TGetPropertyValues(const PropertyTraits* InTraits, const ICustomPropertyRegistration* InCustomProperties)
        : TGetPropertyValuesImpl<PropertyTraits, typename PropertyTraits::MetaDataType>(InTraits, InCustomProperties)
    {}
};
 
 
 
template<typename PropertyTraits, typename MetaDataType, typename... CompositeTypes>
struct TSetCompositePropertyValuesImpl;
 
template<typename PropertyTraits, typename... MetaDataTypes, typename... CompositeTypes>
struct TSetCompositePropertyValuesImpl<PropertyTraits, TPropertyMetaData<MetaDataTypes...>, CompositeTypes...>
{
    using StorageType = typename PropertyTraits::StorageType;
 
    explicit TSetCompositePropertyValuesImpl(const PropertyTraits* InTraits, const ICustomPropertyRegistration* InCustomProperties)
        : Traits(InTraits)
        , CustomProperties(InCustomProperties)
    {
        if (CustomProperties)
        {
            CustomAccessors = CustomProperties->GetAccessors();
        }
    }
 
    void ForEachEntity(UObject* InObject, FCustomPropertyIndex CustomPropertyIndex, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, typename TCallTraits<CompositeTypes>::ParamType... CompositeResults) const;
 
 
    void ForEachEntity(UObject* InObject, uint16 PropertyOffset, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, typename TCallTraits<CompositeTypes>::ParamType... CompositeResults) const;
 
 
    void ForEachEntity(UObject* InObject, const TSharedPtr<FTrackInstancePropertyBindings>& PropertyBindings, typename TCallTraits<MetaDataTypes>::ParamType... MetaData, typename TCallTraits<CompositeTypes>::ParamType... CompositeResults) const;
 
public:
 
    using FThreeWayAccessor  = TMultiReadOptional<FCustomPropertyIndex, uint16, TSharedPtr<FTrackInstancePropertyBindings>>;
    using FTwoWayAccessor    = TMultiReadOptional<uint16, TSharedPtr<FTrackInstancePropertyBindings>>;
 
 
    void ForEachAllocation(const FEntityAllocation* Allocation, TRead<UObject*> BoundObjectComponents, FThreeWayAccessor ResolvedPropertyComponents, TRead<MetaDataTypes>... InMetaData, TRead<CompositeTypes>... VariadicComponents) const;
 
 
    void ForEachAllocation(const FEntityAllocation* Allocation, TRead<UObject*> BoundObjectComponents, FTwoWayAccessor ResolvedPropertyComponents, TRead<MetaDataTypes>... InMetaData, TRead<CompositeTypes>... VariadicComponents) const;
 
private:
 
    const PropertyTraits* Traits;
    const ICustomPropertyRegistration* CustomProperties;
    FCustomAccessorView CustomAccessors;
};
 
template<typename PropertyTraits, typename ...CompositeTypes>
using TSetCompositePropertyValues = TSetCompositePropertyValuesImpl<PropertyTraits, typename PropertyTraits::MetaDataType, CompositeTypes...>;
 
 
} // namespace UE::MovieScene