MeshAttributeArray.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "AttributeArrayContainer.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/Map.h"
#include "Containers/SparseArray.h"
#include "CoreMinimal.h"
#include "Delegates/IntegerSequence.h"
#include "HAL/PlatformCrt.h"
#include "Logging/StructuredLog.h"
#include "Math/Vector.h"
#include "Math/Vector2D.h"
#include "Math/Vector4.h"
#include "MeshElementRemappings.h"
#include "MeshTypes.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Crc.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/TVariant.h"
#include "Serialization/Archive.h"
#include "Templates/CopyQualifiersFromTo.h"
#include "Templates/EnableIf.h"
#include "Templates/IsArray.h"
#include "Templates/Tuple.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "Templates/UnrealTypeTraits.h"
#include "UObject/FortniteMainBranchObjectVersion.h"
#include "UObject/NameTypes.h"
#include "UObject/ReleaseObjectVersion.h"
#include "UObject/UE5MainStreamObjectVersion.h"
 
struct FElementID;
 
 
using AttributeTypes = TTuple
<
    FVector4f,
    FVector3f,
    FVector2f,
    float,
    int32,
    bool,
    FName,
    FTransform
>;
 
 
template <typename Tuple> struct TVariantFromTuple;
 
template <typename... Ts> struct TVariantFromTuple<TTuple<Ts...>> { using Type = TVariant<FEmptyVariantState, Ts...>; };
 
 
template <typename T> struct TIsBulkSerializable { static const bool Value = true; };
template <> struct TIsBulkSerializable<FName> { static const bool Value = false; };
template <> struct TIsBulkSerializable<FTransform> { static const bool Value = false; };
 
 
template <typename AttributeType>
class TMeshAttributeArrayBase
{
public:
    explicit TMeshAttributeArrayBase(uint32 InExtent = 1)
        : Extent(InExtent)
    {}
 
    template <typename T> friend typename TEnableIf<!TIsBulkSerializable<T>::Value, FArchive>::Type& operator<<( FArchive& Ar, TMeshAttributeArrayBase<T>& Array );
    template <typename T> friend typename TEnableIf<TIsBulkSerializable<T>::Value, FArchive>::Type& operator<<( FArchive& Ar, TMeshAttributeArrayBase<T>& Array );
 
    inline int32 Num() const { return Container.Num() / Extent; }
 
    UE_DEPRECATED(5.0, "This method will be removed.")
    inline const AttributeType* GetData() const { return Container.GetData(); }
 
    inline void Initialize(const int32 ElementCount, const AttributeType& Default)
    {
        Container.Reset(ElementCount * Extent);
        if (ElementCount > 0)
        {
            Insert(ElementCount - 1, Default);
        }
    }
 
    void SetNum(const int32 ElementCount, const AttributeType& Default)
    {
        if (int32(ElementCount * Extent) < Container.Num())
        {
            // Setting to a lower number; just truncate the container
            Container.SetNum(ElementCount * Extent);
        }
        else
        {
            // Setting to a higher number; grow the container, inserting default value to end.
            Insert(ElementCount - 1, Default);
        }
    }
 
    uint32 GetHash(uint32 Crc = 0) const
    {
        return FCrc::MemCrc32(Container.GetData(), Container.Num() * sizeof(AttributeType), Crc);
    }
 
    void Insert(const int32 Index, const AttributeType& Default);
 
    void SetToDefault(const int32 Index, const AttributeType& Default)
    {
        for (uint32 I = 0; I < Extent; ++I)
        {
            Container[Index * Extent + I] = Default;
        }
    }
 
    void Remap(const TSparseArray<int32>& IndexRemap, const AttributeType& Default);
 
    UE_DEPRECATED(5.0, "Please use GetElementBase() instead.")
    inline const AttributeType& operator[](const int32 Index) const { return Container[Index]; }
 
    UE_DEPRECATED(5.0, "Please use GetElementBase() instead.")
    inline AttributeType& operator[](const int32 Index) { return Container[Index]; }
 
    inline const AttributeType* GetElementBase(const int32 Index) const { return &Container[Index * Extent]; }
    inline AttributeType* GetElementBase(const int32 Index) { return &Container[Index * Extent]; }
 
    inline uint32 GetExtent() const { return Extent; }
 
protected:
    TArray<AttributeType> Container;
 
    uint32 Extent;
};
 
// We have to manually implement this or else the default behavior will just hash FName ComparisonIndex and Number,
// which aren't deterministic
template<>
inline uint32 TMeshAttributeArrayBase<FName>::GetHash(uint32 Crc) const
{
    for (const FName& Item : Container)
    {
        const FString ItemStr = Item.ToString();
        Crc = FCrc::MemCrc32(*ItemStr, ItemStr.Len() * sizeof(TCHAR), Crc);
    }
    return Crc;
}
 
template <typename AttributeType>
void TMeshAttributeArrayBase<AttributeType>::Insert(const int32 Index, const AttributeType& Default)
{
    int32 EndIndex = (Index + 1) * Extent;
    if (EndIndex > Container.Num())
    {
        // If the index is off the end of the container, add as many elements as required to make it the last valid index.
        int32 StartIndex = Container.AddUninitialized(EndIndex - Container.Num());
        AttributeType* Data = Container.GetData() + StartIndex;
 
        // Construct added elements with the default value passed in
 
        while (StartIndex < EndIndex)
        {
            new(Data) AttributeType(Default);
            StartIndex++;
            Data++;
        }
    }
}
 
template <typename AttributeType>
void TMeshAttributeArrayBase<AttributeType>::Remap(const TSparseArray<int32>& IndexRemap, const AttributeType& Default)
{
    TMeshAttributeArrayBase NewAttributeArray(Extent);
 
    for (typename TSparseArray<int32>::TConstIterator It(IndexRemap); It; ++It)
    {
        const int32 OldElementIndex = It.GetIndex();
        const int32 NewElementIndex = IndexRemap[OldElementIndex];
 
        NewAttributeArray.Insert(NewElementIndex, Default);
        AttributeType* DestElementBase = NewAttributeArray.GetElementBase(NewElementIndex);
        AttributeType* SrcElementBase = GetElementBase(OldElementIndex);
        for (uint32 Index = 0; Index < Extent; ++Index)
        {
            DestElementBase[Index] = MoveTemp(SrcElementBase[Index]);
        }
    }
 
    Container = MoveTemp(NewAttributeArray.Container);
}
 
template <typename T>
inline typename TEnableIf<!TIsBulkSerializable<T>::Value, FArchive>::Type& operator<<( FArchive& Ar, TMeshAttributeArrayBase<T>& Array )
{
    if (Ar.IsLoading() &&
        Ar.CustomVer(FReleaseObjectVersion::GUID) != FReleaseObjectVersion::MeshDescriptionNewFormat &&
        Ar.CustomVer(FUE5MainStreamObjectVersion::GUID) < FUE5MainStreamObjectVersion::MeshDescriptionNewFormat)
    {
        Array.Extent = 1;
    }
    else
    {
        Ar << Array.Extent;
    }
    
    // A little bit prior to skeletal meshes storing their model data as mesh description, FTransform attributes were added but marked,
    // by default, as bulk-serializable, even though FTransform doesn't support it. Therefore, this serialization path only worked on empty 
    // FTransform attributes. However, there are still static mesh assets in the wild that contain empty FTransform attributes, and we need 
    // to be able to successfully load them -- hence this check.
    if constexpr (std::is_same_v<T, FTransform>)
    {
        if (Ar.IsLoading())
        {
            // This version check works because saved UStaticMesh assets set this on their archive, which is then inherited by the
            // mesh description bulk storage.
            const FCustomVersion* PossiblySavedVersion = Ar.GetCustomVersions().GetVersion(FFortniteMainBranchObjectVersion::GUID);
            if (PossiblySavedVersion && PossiblySavedVersion->Version < FFortniteMainBranchObjectVersion::MeshDescriptionForSkeletalMesh)
            {
                Array.Container.BulkSerialize( Ar );
                return Ar;
            }
        }
    }
 
    // Serialize types which aren't bulk serializable, which need to be serialized element-by-element
    Ar << Array.Container;
    return Ar;
}
 
template <typename T>
inline typename TEnableIf<TIsBulkSerializable<T>::Value, FArchive>::Type& operator<<( FArchive& Ar, TMeshAttributeArrayBase<T>& Array )
{
    if (Ar.IsLoading() &&
        Ar.CustomVer(FReleaseObjectVersion::GUID) != FReleaseObjectVersion::MeshDescriptionNewFormat &&
        Ar.CustomVer(FUE5MainStreamObjectVersion::GUID) < FUE5MainStreamObjectVersion::MeshDescriptionNewFormat)
    {
        Array.Extent = 1;
    }
    else
    {
        Ar << Array.Extent;
    }
 
    if( Ar.IsLoading() && Ar.CustomVer( FReleaseObjectVersion::GUID ) < FReleaseObjectVersion::MeshDescriptionNewSerialization )
    {
        // Legacy path for old format attribute arrays. BulkSerialize has a different format from regular serialization.
        Ar << Array.Container;
    }
    else
    {
        // Serialize types which are bulk serializable, i.e. which can be memcpy'd in bulk
        Array.Container.BulkSerialize( Ar );
    }
 
    return Ar;
}
 
 
enum class EMeshAttributeFlags : uint32
{
    None                = 0,
    Lerpable            = (1 << 0),     
    AutoGenerated       = (1 << 1),     
    Mergeable           = (1 << 2),     
    Transient           = (1 << 3),     
    IndexReference      = (1 << 4),     
    Mandatory           = (1 << 5),     
};
 
ENUM_CLASS_FLAGS(EMeshAttributeFlags);
 
 
class FMeshAttributeArraySetBase
{
public:
    inline FMeshAttributeArraySetBase(const uint32 InType, const EMeshAttributeFlags InFlags, const int32 InNumberOfElements, const uint32 InExtent)
        : Type(InType),
          Extent(InExtent),
          NumElements(InNumberOfElements),
          Flags(InFlags)
    {}
 
    virtual ~FMeshAttributeArraySetBase() = default;
    virtual TUniquePtr<FMeshAttributeArraySetBase> Clone() const = 0;
    virtual void Insert(const int32 Index) = 0;
    virtual void Remove(const int32 Index) = 0;
    virtual void Initialize(const int32 Count) = 0;
    virtual void SetNumElements(const int32 Count) = 0;
    virtual uint32 GetHash() const = 0;
    virtual void Serialize(FArchive& Ar) = 0;
    virtual void Remap(const TSparseArray<int32>& IndexRemap) = 0;
 
//  UE_DEPRECATED(5.0, "Please use GetNumChannels().")
    virtual int32 GetNumIndices() const = 0;
//  UE_DEPRECATED(5.0, "Please use SetNumChannels().")
    virtual void SetNumIndices(const int32 NumIndices) = 0;
//  UE_DEPRECATED(5.0, "Please use InsertChannel().")
    virtual void InsertIndex(const int32 Index) = 0;
//  UE_DEPRECATED(5.0, "Please use RemoveChannel().")
    virtual void RemoveIndex(const int32 Index) = 0;
 
    virtual int32 GetNumChannels() const = 0;
    virtual void SetNumChannels(const int32 NumChannels) = 0;
    virtual void InsertChannel(const int32 Index) = 0;
    virtual void RemoveChannel(const int32 Index) = 0;
 
    template <typename T>
    inline bool HasType() const
    {
        return TTupleIndex<T, AttributeTypes>::Value == Type;
    }
 
    inline uint32 GetType() const { return Type; }
 
    inline uint32 GetExtent() const { return Extent; }
 
    inline EMeshAttributeFlags GetFlags() const { return Flags; }
 
    inline void SetFlags(const EMeshAttributeFlags InFlags) { Flags = InFlags; }
 
    inline int32 GetNumElements() const { return NumElements; }
 
protected:
    uint32 Type;
 
    uint32 Extent;
 
    int32 NumElements;
 
    EMeshAttributeFlags Flags;
};
 
 
template <typename AttributeType>
class TMeshAttributeArraySet final : public FMeshAttributeArraySetBase
{
    static_assert(!TIsArray<AttributeType>::Value, "TMeshAttributeArraySet must take a simple type.");
 
    using Super = FMeshAttributeArraySetBase;
 
public:
    inline explicit TMeshAttributeArraySet(const int32 Extent = 1)
        : Super(TTupleIndex<AttributeType, AttributeTypes>::Value, EMeshAttributeFlags::None, 0, Extent)
    {}
 
    inline explicit TMeshAttributeArraySet(const int32 NumberOfChannels, const AttributeType& InDefaultValue, const EMeshAttributeFlags InFlags, const int32 InNumberOfElements, const uint32 Extent)
        : Super(TTupleIndex<AttributeType, AttributeTypes>::Value, InFlags, InNumberOfElements, Extent),
          DefaultValue(InDefaultValue)
    {
        SetNumChannels(NumberOfChannels);
    }
 
    virtual TUniquePtr<FMeshAttributeArraySetBase> Clone() const override
    {
        return MakeUnique<TMeshAttributeArraySet>(*this);
    }
 
    virtual void Insert(const int32 Index) override
    {
        for (TMeshAttributeArrayBase<AttributeType>& ArrayForChannel : ArrayForChannels)
        {
            ArrayForChannel.Insert(Index, DefaultValue);
        }
 
        NumElements = FMath::Max(NumElements, Index + 1);
    }
 
    virtual void Remove(const int32 Index) override
    {
        for (TMeshAttributeArrayBase<AttributeType>& ArrayForChannel : ArrayForChannels)
        {
            ArrayForChannel.SetToDefault(Index, DefaultValue);
        }
    }
 
    virtual void Initialize(const int32 Count) override
    {
        NumElements = Count;
        for (TMeshAttributeArrayBase<AttributeType>& ArrayForChannel : ArrayForChannels)
        {
            ArrayForChannel.Initialize(Count, DefaultValue);
        }
    }
 
    virtual void SetNumElements(const int32 Count) override
    {
        NumElements = Count;
        for (TMeshAttributeArrayBase<AttributeType>& ArrayForChannel : ArrayForChannels)
        {
            ArrayForChannel.SetNum(Count, DefaultValue);
        }
    }
 
    virtual uint32 GetHash() const override
    {
        uint32 CrcResult = 0;
        for (const TMeshAttributeArrayBase<AttributeType>& ArrayForChannel : ArrayForChannels)
        {
            CrcResult = ArrayForChannel.GetHash(CrcResult);
        }
        return CrcResult;
    }
 
    virtual void Serialize(FArchive& Ar) override
    {
        Ar << (*this);
    }
 
    virtual void Remap(const TSparseArray<int32>& IndexRemap) override
    {
        for (TMeshAttributeArrayBase<AttributeType>& ArrayForChannel : ArrayForChannels)
        {
            ArrayForChannel.Remap(IndexRemap, DefaultValue);
            NumElements = ArrayForChannel.Num();
        }
    }
 
    UE_DEPRECATED(5.0, "Please use GetNumChannels().")
    virtual inline int32 GetNumIndices() const override { return GetNumChannels(); }
 
    virtual inline int32 GetNumChannels() const override { return ArrayForChannels.Num(); }
 
    UE_DEPRECATED(5.0, "Please use SetNumChannels().")
    virtual void SetNumIndices(const int32 NumIndices) override { SetNumChannels(NumIndices); }
 
    virtual void SetNumChannels(const int32 NumChannels) override
    {
        if (NumChannels < ArrayForChannels.Num())
        {
            ArrayForChannels.SetNum(NumChannels);
            return;
        }
 
        while (ArrayForChannels.Num() < NumChannels)
        {
            TMeshAttributeArrayBase<AttributeType>& Array = ArrayForChannels.Emplace_GetRef(Extent);
            Array.Initialize(NumElements, DefaultValue);
        }
    }
 
    UE_DEPRECATED(5.0, "Please use InsertChannel().")
    virtual void InsertIndex(const int32 Index) override
    {
        InsertChannel(Index);
    }
 
    virtual void InsertChannel(const int32 Index) override
    {
        TMeshAttributeArrayBase<AttributeType>& Array = ArrayForChannels.EmplaceAt_GetRef(Index, Extent);
        Array.Initialize(NumElements, DefaultValue);
    }
 
    UE_DEPRECATED(5.0, "Please use RemoveChannel().")
    virtual void RemoveIndex(const int32 Index) override
    {
        RemoveChannel(Index);
    }
 
    virtual void RemoveChannel(const int32 Index) override
    {
        ArrayForChannels.RemoveAt(Index);
    }
 
 
    UE_DEPRECATED(5.0, "Please use GetArrayForChannel().")
    inline const TMeshAttributeArrayBase<AttributeType>& GetArrayForIndex( const int32 Index ) const { return ArrayForChannels[ Index ]; }
    UE_DEPRECATED(5.0, "Please use GetArrayForChannel().")
    inline TMeshAttributeArrayBase<AttributeType>& GetArrayForIndex( const int32 Index ) { return ArrayForChannels[ Index ]; }
 
    inline const TMeshAttributeArrayBase<AttributeType>& GetArrayForChannel( const int32 Index ) const { return ArrayForChannels[ Index ]; }
    inline TMeshAttributeArrayBase<AttributeType>& GetArrayForChannel( const int32 Index ) { return ArrayForChannels[ Index ]; }
 
    inline AttributeType GetDefaultValue() const { return DefaultValue; }
 
    friend FArchive& operator<<(FArchive& Ar, TMeshAttributeArraySet& AttributeArraySet)
    {
        Ar << AttributeArraySet.NumElements;
        Ar << AttributeArraySet.ArrayForChannels;
        Ar << AttributeArraySet.DefaultValue;
        Ar << AttributeArraySet.Flags;
 
        return Ar;
    }
 
protected:
    TArray<TMeshAttributeArrayBase<AttributeType>, TInlineAllocator<1>> ArrayForChannels;
 
    AttributeType DefaultValue;
};
 
 
template <typename AttributeType>
class TMeshUnboundedAttributeArraySet final : public FMeshAttributeArraySetBase
{
    using Super = FMeshAttributeArraySetBase;
 
public:
    inline TMeshUnboundedAttributeArraySet()
        : Super(TTupleIndex<AttributeType, AttributeTypes>::Value, EMeshAttributeFlags::None, 0, 0)
    {}
 
    inline explicit TMeshUnboundedAttributeArraySet(const int32 NumberOfChannels, const AttributeType& InDefaultValue, const EMeshAttributeFlags InFlags, const int32 InNumberOfElements)
        : Super(TTupleIndex<AttributeType, AttributeTypes>::Value, InFlags, InNumberOfElements, 0),
        DefaultValue(InDefaultValue)
    {
        SetNumChannels(NumberOfChannels);
    }
 
    virtual TUniquePtr<FMeshAttributeArraySetBase> Clone() const override
    {
        return MakeUnique<TMeshUnboundedAttributeArraySet>(*this);
    }
 
    virtual void Insert(const int32 Index) override
    {
        for (TAttributeArrayContainer<AttributeType>& ArrayForChannel : ArrayForChannels)
        {
            ArrayForChannel.Insert(Index, DefaultValue);
        }
 
        NumElements = FMath::Max(NumElements, Index + 1);
    }
 
    virtual void Remove(const int32 Index) override
    {
        for (TAttributeArrayContainer<AttributeType>& ArrayForChannel : ArrayForChannels)
        {
            ArrayForChannel.SetToDefault(Index, DefaultValue);
        }
    }
 
    virtual void Initialize(const int32 Count) override
    {
        NumElements = Count;
        for (TAttributeArrayContainer<AttributeType>& ArrayForChannel : ArrayForChannels)
        {
            ArrayForChannel.Initialize(Count, DefaultValue);
        }
    }
 
    virtual void SetNumElements(const int32 Count) override
    {
        NumElements = Count;
        for (TAttributeArrayContainer<AttributeType>& ArrayForChannel : ArrayForChannels)
        {
            ArrayForChannel.SetNum(Count, DefaultValue);
        }
    }
 
    virtual uint32 GetHash() const override
    {
        uint32 CrcResult = 0;
        for (const TAttributeArrayContainer<AttributeType>& ArrayForChannel : ArrayForChannels)
        {
            CrcResult = ArrayForChannel.GetHash(CrcResult);
        }
        return CrcResult;
    }
 
    virtual void Serialize(FArchive& Ar) override
    {
        Ar << (*this);
    }
 
    virtual void Remap(const TSparseArray<int32>& IndexRemap) override
    {
        for (TAttributeArrayContainer<AttributeType>& ArrayForChannel : ArrayForChannels)
        {
            ArrayForChannel.Remap(IndexRemap, DefaultValue);
            NumElements = ArrayForChannel.Num();
        }
    }
 
    UE_DEPRECATED(5.0, "Please use GetNumChannels().")
    virtual inline int32 GetNumIndices() const override { return GetNumChannels(); }
 
    virtual inline int32 GetNumChannels() const override { return ArrayForChannels.Num(); }
 
    UE_DEPRECATED(5.0, "Please use SetNumChannels().")
    virtual void SetNumIndices(const int32 NumIndices) override { SetNumChannels(NumIndices); }
 
    virtual void SetNumChannels(const int32 NumChannels) override
    {
        if (NumChannels < ArrayForChannels.Num())
        {
            ArrayForChannels.SetNum(NumChannels);
            return;
        }
 
        while (ArrayForChannels.Num() < NumChannels)
        {
            TAttributeArrayContainer<AttributeType>& Array = ArrayForChannels.Emplace_GetRef(DefaultValue);
            Array.Initialize(NumElements, DefaultValue);
        }
    }
 
    UE_DEPRECATED(5.0, "Please use InsertChannel().")
    virtual void InsertIndex(const int32 Index) override
    {
        InsertChannel(Index);
    }
 
    virtual void InsertChannel(const int32 Index) override
    {
        TAttributeArrayContainer<AttributeType>& Array = ArrayForChannels.EmplaceAt_GetRef(Index, DefaultValue);
        Array.Initialize(NumElements, DefaultValue);
    }
 
    UE_DEPRECATED(5.0, "Please use RemoveChannel().")
    virtual void RemoveIndex(const int32 Index) override
    {
        RemoveChannel(Index);
    }
 
    virtual void RemoveChannel(const int32 Index) override
    {
        ArrayForChannels.RemoveAt(Index);
    }
 
    inline const TAttributeArrayContainer<AttributeType>& GetArrayForChannel( const int32 Index ) const { return ArrayForChannels[ Index ]; }
    inline TAttributeArrayContainer<AttributeType>& GetArrayForChannel( const int32 Index ) { return ArrayForChannels[ Index ]; }
 
    inline AttributeType GetDefaultValue() const { return DefaultValue; }
 
    friend FArchive& operator<<(FArchive& Ar, TMeshUnboundedAttributeArraySet& AttributeArraySet)
    {
        Ar << AttributeArraySet.NumElements;
        Ar << AttributeArraySet.ArrayForChannels;
        Ar << AttributeArraySet.DefaultValue;
        Ar << AttributeArraySet.Flags;
 
        return Ar;
    }
 
protected:
    TArray<TAttributeArrayContainer<AttributeType>, TInlineAllocator<1>> ArrayForChannels;
 
    AttributeType DefaultValue;
};
 
 
template <typename T>
struct TMeshAttributesRefTypeBase
{
    using AttributeType = T;
    using RealAttributeType = std::conditional_t<TIsDerivedFrom<AttributeType, FElementID>::Value, int32, AttributeType>;
};
 
template <typename T>
struct TMeshAttributesRefType : TMeshAttributesRefTypeBase<T>
{
    static const uint32 MinExpectedExtent = 1;
    static const uint32 MaxExpectedExtent = 1;
    using RefType = T;
    using ConstRefType = const T;
    using NonConstRefType = std::remove_cv_t<T>;
};
 
template <typename T>
struct TMeshAttributesRefType<TArrayView<T>> : TMeshAttributesRefTypeBase<T>
{
    static const uint32 MinExpectedExtent = 0;
    static const uint32 MaxExpectedExtent = 0xFFFFFFFF;
    using RefType = TArrayView<T>;
    using ConstRefType = TArrayView<const T>;
    using NonConstRefType = TArrayView<std::remove_cv_t<T>>;
};
 
template <typename T>
struct TMeshAttributesRefType<TArrayAttribute<T>> : TMeshAttributesRefTypeBase<T>
{
    static const uint32 MinExpectedExtent = 0;
    static const uint32 MaxExpectedExtent = 0;
    using RefType = TArrayAttribute<T>;
    using ConstRefType = TArrayAttribute<const T>;
    using NonConstRefType = TArrayAttribute<std::remove_cv_t<T>>;
};
 
 
template <typename T>
struct TMeshAttributesRegisterType : TMeshAttributesRefType<T>
{
    static const uint32 Extent = 1;
};
 
template <typename T, SIZE_T N>
struct TMeshAttributesRegisterType<T[N]> : TMeshAttributesRefType<TArrayView<T>>
{
    static const uint32 Extent = N;
};
 
template <typename T>
struct TMeshAttributesRegisterType<T[]> : TMeshAttributesRefType<TArrayAttribute<T>>
{
    static const uint32 Extent = 0;
};
 
 
 
template <typename ElementIDType, typename AttributeType>
class TMeshAttributesRef;
 
template <typename ElementIDType, typename AttributeType>
using TMeshAttributesConstRef = TMeshAttributesRef<ElementIDType, typename TMeshAttributesRefType<AttributeType>::ConstRefType>;
 
template <typename AttributeType>
using TMeshAttributesArray = TMeshAttributesRef<int32, AttributeType>;
 
template <typename AttributeType>
using TMeshAttributesConstArray = TMeshAttributesRef<int32, typename TMeshAttributesRefType<AttributeType>::ConstRefType>;
 
 
// This is the default implementation which handles simple attributes, i.e. those of a simple type T.
// There are partial specializations which handle compound attributes below, i.e. those accessed via TArrayView<T> or TAttributeArray<T>
template <typename ElementIDType, typename AttributeType>
class TMeshAttributesRef
{
    template <typename T, typename U> friend class TMeshAttributesRef;
 
public:
    using BaseArrayType = TCopyQualifiersFromTo_T<AttributeType, FMeshAttributeArraySetBase>;
    using ArrayType = TCopyQualifiersFromTo_T<AttributeType, TMeshAttributeArraySet<std::remove_cv_t<AttributeType>>>;
 
    explicit TMeshAttributesRef(BaseArrayType* InArrayPtr = nullptr, uint32 InExtent = 1)
        : ArrayPtr(InArrayPtr)
    {}
 
    template <typename SrcAttributeType,
              typename DestAttributeType = AttributeType,
              typename TEnableIf<std::is_const_v<DestAttributeType>, int>::Type = 0,
              typename TEnableIf<!std::is_const_v<SrcAttributeType>, int>::Type = 0>
    TMeshAttributesRef(const TMeshAttributesRef<ElementIDType, SrcAttributeType>& InRef)
        : ArrayPtr(InRef.ArrayPtr)
    {}
 
    template <typename IDType = ElementIDType,
              typename TEnableIf<!std::is_same_v<IDType, int32>, int>::Type = 0>
    TMeshAttributesRef(const TMeshAttributesRef<int32, AttributeType>& InRef)
        : ArrayPtr(InRef.ArrayPtr)
    {}
 
    template <typename SrcAttributeType,
              typename DestAttributeType = AttributeType,
              typename IDType = ElementIDType,
              typename TEnableIf<!std::is_same_v<IDType, int32>, int>::Type = 0,
              typename TEnableIf<std::is_const_v<DestAttributeType>, int>::Type = 0,
              typename TEnableIf<!std::is_const_v<SrcAttributeType>, int>::Type = 0>
    TMeshAttributesRef(const TMeshAttributesRef<int32, SrcAttributeType>& InRef)
        : ArrayPtr(InRef.ArrayPtr)
    {}
 
    template <typename T = ElementIDType, typename TEnableIf<TIsDerivedFrom<T, FElementID>::Value, int>::Type = 0>
    AttributeType& operator[](const ElementIDType ElementID) const
    {
        return static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(0).GetElementBase(ElementID.GetValue())[0];
    }
 
    template <typename T = ElementIDType, typename TEnableIf<TIsDerivedFrom<T, FElementID>::Value, int>::Type = 0>
    AttributeType Get(const ElementIDType ElementID, const int32 Channel = 0) const
    {
        return static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).GetElementBase(ElementID.GetValue())[0];
    }
 
    AttributeType& operator[](int32 ElementIndex) const
    {
        return static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(0).GetElementBase(ElementIndex)[0];
    }
 
    AttributeType Get(int32 ElementIndex, const int32 Channel = 0) const
    {
        return static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).GetElementBase(ElementIndex)[0];
    }
 
    TArrayView<AttributeType> GetArrayView(int32 ElementIndex, const int32 Channel = 0) const
    {
        return TArrayView<AttributeType>(static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).GetElementBase(ElementIndex), 1);
    }
 
    TArrayView<AttributeType> GetRawArray(const int32 AttributeChannel = 0) const
    {
        if (ArrayPtr == nullptr || GetNumElements() == 0)
        {
            return TArrayView<AttributeType>();
        }
 
        AttributeType* Element = static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(AttributeChannel).GetElementBase(0);
        return TArrayView<AttributeType>(Element, GetNumElements());
    }
 
    bool IsValid() const { return (ArrayPtr != nullptr); }
 
    AttributeType GetDefaultValue() const { return static_cast<ArrayType*>(ArrayPtr)->GetDefaultValue(); }
 
    UE_DEPRECATED(5.0, "Please use GetNumChannels().")
    int32 GetNumIndices() const
    {
        return static_cast<ArrayType*>(ArrayPtr)->ArrayType::GetNumChannels();  // note: override virtual dispatch
    }
 
    int32 GetNumChannels() const
    {
        return static_cast<ArrayType*>(ArrayPtr)->ArrayType::GetNumChannels();  // note: override virtual dispatch
    }
 
    int32 GetNumElements() const
    {
        return ArrayPtr->GetNumElements();
    }
 
    EMeshAttributeFlags GetFlags() const { return ArrayPtr->GetFlags(); }
 
    uint32 GetExtent() const { return 1; }
 
    template <typename T = ElementIDType, typename TEnableIf<TIsDerivedFrom<T, FElementID>::Value, int>::Type = 0>
    void Set(const ElementIDType ElementID, const AttributeType& Value) const
    {
        static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(0).GetElementBase(ElementID.GetValue())[0] = Value;
    }
 
    template <typename T = ElementIDType, typename TEnableIf<TIsDerivedFrom<T, FElementID>::Value, int>::Type = 0>
    void Set(const ElementIDType ElementID, const int32 Channel, const AttributeType& Value) const
    {
        static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).GetElementBase(ElementID.GetValue())[0] = Value;
    }
 
    void Set(int32 ElementIndex, const AttributeType& Value) const
    {
        static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(0).GetElementBase(ElementIndex)[0] = Value;
    }
 
    void Set(int32 ElementIndex, const int32 Channel, const AttributeType& Value) const
    {
        static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).GetElementBase(ElementIndex)[0] = Value;
    }
 
    void SetArrayView(int32 ElementIndex, TArrayView<const AttributeType> Value) const
    {
        check(Value.Num() == 1);
        static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(0).GetElementBase(ElementIndex)[0] = Value[0];
    }
 
    void SetArrayView(int32 ElementIndex, const int32 Channel, TArrayView<const AttributeType> Value) const
    {
        check(Value.Num() == 1);
        static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).GetElementBase(ElementIndex)[0] = Value[0];
    }
 
    void Copy(TMeshAttributesRef<ElementIDType, const AttributeType> Src, const int32 DestChannel = 0, const int32 SrcChannel = 0);
 
    UE_DEPRECATED(5.0, "Please use SetNumChannels().")
    void SetNumIndices(const int32 NumChannels) const
    {
        static_cast<ArrayType*>(ArrayPtr)->ArrayType::SetNumChannels(NumChannels);  // note: override virtual dispatch
    }
 
    void SetNumChannels(const int32 NumChannels) const
    {
        static_cast<ArrayType*>(ArrayPtr)->ArrayType::SetNumChannels(NumChannels);  // note: override virtual dispatch
    }
 
    UE_DEPRECATED(5.0, "Please use InsertChannel().")
    void InsertIndex(const int32 Index) const
    {
        static_cast<ArrayType*>(ArrayPtr)->ArrayType::InsertChannel(Index);     // note: override virtual dispatch
    }
 
    void InsertChannel(const int32 Channel) const
    {
        static_cast<ArrayType*>(ArrayPtr)->ArrayType::InsertChannel(Channel);       // note: override virtual dispatch
    }
 
    UE_DEPRECATED(5.0, "Please use RemoveChannel().")
    void RemoveIndex(const int32 Index) const
    {
        static_cast<ArrayType*>(ArrayPtr)->ArrayType::RemoveChannel(Index);     // note: override virtual dispatch
    }
 
    void RemoveChannel(const int32 Channel) const
    {
        static_cast<ArrayType*>(ArrayPtr)->ArrayType::RemoveChannel(Channel);       // note: override virtual dispatch
    }
 
private:
    BaseArrayType* ArrayPtr;
};
 
template <typename ElementIDType, typename AttributeType>
void TMeshAttributesRef<ElementIDType, AttributeType>::Copy(TMeshAttributesRef<ElementIDType, const AttributeType> Src, const int32 DestChannel, const int32 SrcChannel)
{
    check(Src.IsValid());
    const TMeshAttributeArrayBase<AttributeType>& SrcArray = static_cast<const ArrayType*>(Src.ArrayPtr)->GetArrayForChannel(SrcChannel);
    TMeshAttributeArrayBase<AttributeType>& DestArray = static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(DestChannel);
    const int32 Num = FMath::Min(SrcArray.Num(), DestArray.Num());
    for (int32 Index = 0; Index < Num; Index++)
    {
        DestArray.GetElementBase(Index)[0] = SrcArray.GetElementBase(Index)[0];
    }
}
 
 
template <typename ElementIDType, typename AttributeType>
class TMeshAttributesRef<ElementIDType, TArrayView<AttributeType>>
{
    template <typename T, typename U> friend class TMeshAttributesRef;
 
public:
    using BaseArrayType = TCopyQualifiersFromTo_T<AttributeType, FMeshAttributeArraySetBase>;
    using BoundedArrayType = TCopyQualifiersFromTo_T<AttributeType, TMeshAttributeArraySet<std::remove_cv_t<AttributeType>>>;
    using UnboundedArrayType = TCopyQualifiersFromTo_T<AttributeType, TMeshUnboundedAttributeArraySet<std::remove_cv_t<AttributeType>>>;
 
    explicit TMeshAttributesRef(BaseArrayType* InArrayPtr = nullptr, uint32 InExtent = 1)
        : ArrayPtr(InArrayPtr),
          Extent(InExtent)
    {}
 
    template <typename SrcAttributeType,
              typename DestAttributeType = AttributeType,
              typename TEnableIf<std::is_const_v<DestAttributeType>, int>::Type = 0,
              typename TEnableIf<!std::is_const_v<SrcAttributeType>, int>::Type = 0>
    TMeshAttributesRef(const TMeshAttributesRef<ElementIDType, TArrayView<SrcAttributeType>>& InRef)
        : ArrayPtr(InRef.ArrayPtr),
          Extent(InRef.Extent)
    {}
 
    template <typename IDType = ElementIDType,
              typename TEnableIf<!std::is_same_v<IDType, int32>, int>::Type = 0>
    TMeshAttributesRef(const TMeshAttributesRef<int32, TArrayView<AttributeType>>& InRef)
        : ArrayPtr(InRef.ArrayPtr),
          Extent(InRef.Extent)
    {}
 
    template <typename SrcAttributeType,
              typename DestAttributeType = AttributeType,
              typename IDType = ElementIDType,
              typename TEnableIf<!std::is_same_v<IDType, int32>, int>::Type = 0,
              typename TEnableIf<std::is_const_v<DestAttributeType>, int>::Type = 0,
              typename TEnableIf<!std::is_const_v<SrcAttributeType>, int>::Type = 0>
    TMeshAttributesRef(const TMeshAttributesRef<int32, TArrayView<SrcAttributeType>>& InRef)
        : ArrayPtr(InRef.ArrayPtr),
          Extent(InRef.Extent)
    {}
 
 
    template <typename T = ElementIDType, typename TEnableIf<TIsDerivedFrom<T, FElementID>::Value, int>::Type = 0>
    TArrayView<AttributeType> operator[](const ElementIDType ElementID) const
    {
        if (Extent > 0)
        {
            AttributeType* Element = static_cast<BoundedArrayType*>(ArrayPtr)->GetArrayForChannel(0).GetElementBase(ElementID.GetValue());
            return TArrayView<AttributeType>(Element, Extent);
        }
        else
        {
            return static_cast<UnboundedArrayType*>(ArrayPtr)->GetArrayForChannel(0).Get(ElementID.GetValue());
        }
    }
 
    template <typename T = ElementIDType, typename TEnableIf<TIsDerivedFrom<T, FElementID>::Value, int>::Type = 0>
    TArrayView<AttributeType> Get(const ElementIDType ElementID, const int32 Channel = 0) const
    {
        if (Extent > 0)
        {
            AttributeType* Element = static_cast<BoundedArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).GetElementBase(ElementID.GetValue());
            return TArrayView<AttributeType>(Element, Extent);
        }
        else
        {
            return static_cast<UnboundedArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).Get(ElementID.GetValue());
        }
    }
 
    TArrayView<AttributeType> operator[](int32 ElementIndex) const
    {
        if (Extent > 0)
        {
            AttributeType* Element = static_cast<BoundedArrayType*>(ArrayPtr)->GetArrayForChannel(0).GetElementBase(ElementIndex);
            return TArrayView<AttributeType>(Element, Extent);
        }
        else
        {
            return static_cast<UnboundedArrayType*>(ArrayPtr)->GetArrayForChannel(0).Get(ElementIndex);
        }
    }
 
    TArrayView<AttributeType> Get(int32 ElementIndex, const int32 Channel = 0) const
    {
        if (Extent > 0)
        {
            AttributeType* Element = static_cast<BoundedArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).GetElementBase(ElementIndex);
            return TArrayView<AttributeType>(Element, Extent);
        }
        else
        {
            return static_cast<UnboundedArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).Get(ElementIndex);
        }
    }
 
    TArrayView<AttributeType> GetArrayView(int32 ElementIndex, const int32 Channel = 0) const
    {
        if (Extent > 0)
        {
            return TArrayView<AttributeType>(static_cast<BoundedArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).GetElementBase(ElementIndex), Extent);
        }
        else
        {
            return static_cast<UnboundedArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).Get(ElementIndex);
        }
    }
 
    TArrayView<AttributeType> GetRawArray(const int32 ChannelIndex = 0) const
    {
        // Can't get the attribute set raw array for unbounded arrays because they are chunked
        check(Extent > 0);
 
        if (ArrayPtr == nullptr || GetNumElements() == 0)
        {
            return TArrayView<AttributeType>();
        }
 
        AttributeType* Element = static_cast<BoundedArrayType*>(ArrayPtr)->GetArrayForChannel(ChannelIndex).GetElementBase(0);
        return TArrayView<AttributeType>(Element, GetNumElements() * Extent);
    }
 
    bool IsValid() const { return (ArrayPtr != nullptr); }
 
    AttributeType GetDefaultValue() const { return static_cast<BoundedArrayType*>(ArrayPtr)->GetDefaultValue(); }
 
    UE_DEPRECATED(5.0, "Please use GetNumChannels().")
    int32 GetNumIndices() const
    {
        return ArrayPtr->GetNumChannels();
    }
 
    int32 GetNumChannels() const
    {
        return ArrayPtr->GetNumChannels();
    }
 
    int32 GetNumElements() const
    {
        return ArrayPtr->GetNumElements();
    }
 
    EMeshAttributeFlags GetFlags() const { return ArrayPtr->GetFlags(); }
 
    uint32 GetExtent() const { return Extent; }
 
    template <typename T = ElementIDType, typename TEnableIf<TIsDerivedFrom<T, FElementID>::Value, int>::Type = 0>
    void Set(const ElementIDType ElementID, TArrayView<const AttributeType> Value) const
    {
        TArrayView<AttributeType> Elements = Get(ElementID);
        check(Value.Num() == Elements.Num());
        for (uint32 Index = 0; Index < Extent; Index++)
        {
            Elements[Index] = Value[Index];
        }
    }
 
    template <typename T = ElementIDType, typename TEnableIf<TIsDerivedFrom<T, FElementID>::Value, int>::Type = 0>
    void Set(const ElementIDType ElementID, const int32 Channel, TArrayView<const AttributeType> Value) const
    {
        TArrayView<AttributeType> Elements = Get(ElementID, Channel);
        check(Value.Num() == Elements.Num());
        for (uint32 Index = 0; Index < Extent; Index++)
        {
            Elements[Index] = Value[Index];
        }
    }
 
    void Set(int32 ElementIndex, TArrayView<const AttributeType> Value) const
    {
        TArrayView<AttributeType> Elements = Get(ElementIndex);
        check(Value.Num() == Elements.Num());
        for (uint32 Index = 0; Index < Extent; Index++)
        {
            Elements[Index] = Value[Index];
        }
    }
 
    void Set(int32 ElementIndex, const int32 Channel, TArrayView<const AttributeType> Value) const
    {
        TArrayView<AttributeType> Elements = Get(ElementIndex, Channel);
        check(Value.Num() == Elements.Num());
        for (uint32 Index = 0; Index < Extent; Index++)
        {
            Elements[Index] = Value[Index];
        }
    }
 
    void SetArrayView(int32 ElementIndex, TArrayView<const AttributeType> Value) const
    {
        Set(ElementIndex, Value);
    }
 
    void SetArrayView(int32 ElementIndex, const int32 Channel, TArrayView<const AttributeType> Value) const
    {
        Set(ElementIndex, Channel, Value);
    }
 
    void Copy(TMeshAttributesConstRef<ElementIDType, TArrayView<AttributeType>> Src, const int32 DestChannel = 0, const int32 SrcChannel = 0);
 
    UE_DEPRECATED(5.0, "Please use SetNumChannels().")
    void SetNumIndices(const int32 NumChannels) const
    {
        ArrayPtr->SetNumChannels(NumChannels);
    }
 
    void SetNumChannels(const int32 NumChannels) const
    {
        ArrayPtr->SetNumChannels(NumChannels);
    }
 
    UE_DEPRECATED(5.0, "Please use InsertChannel().")
    void InsertIndex(const int32 Index) const
    {
        ArrayPtr->InsertChannel(Index);
    }
 
    void InsertChannel(const int32 Channel) const
    {
        ArrayPtr->InsertChannel(Channel);
    }
 
    UE_DEPRECATED(5.0, "Please use RemoveChannel().")
    void RemoveIndex(const int32 Index) const
    {
        ArrayPtr->RemoveChannel(Index);
    }
 
    void RemoveChannel(const int32 Channel) const
    {
        ArrayPtr->RemoveChannel(Channel);
    }
 
private:
    BaseArrayType* ArrayPtr;
    uint32 Extent;
};
 
template <typename ElementIDType, typename AttributeType>
void TMeshAttributesRef<ElementIDType, TArrayView<AttributeType>>::Copy(TMeshAttributesConstRef<ElementIDType, TArrayView<AttributeType>> Src, const int32 DestChannel, const int32 SrcChannel)
{
    check(Extent > 0);
    check(Src.IsValid());
    check(Src.Extent == Extent);
    const TMeshAttributeArrayBase<AttributeType>& SrcArray = static_cast<const BoundedArrayType*>(Src.ArrayPtr)->GetArrayForChannel(SrcChannel);
    TMeshAttributeArrayBase<AttributeType>& DestArray = static_cast<BoundedArrayType*>(ArrayPtr)->GetArrayForChannel(DestChannel);
    const int32 Num = FMath::Min(SrcArray.Num(), DestArray.Num());
    for (int32 Index = 0; Index < Num; Index++)
    {
        for (uint32 Count = 0; Count < Extent; Count++)
        {
            DestArray.GetElementBase(Index)[Count] = SrcArray.GetElementBase(Index)[Count];
        }
    }
}
 
 
template <typename ElementIDType, typename AttributeType>
class TMeshAttributesRef<ElementIDType, TArrayAttribute<AttributeType>>
{
    template <typename T, typename U> friend class TMeshAttributesRef;
 
public:
    using BaseArrayType = TCopyQualifiersFromTo_T<AttributeType, FMeshAttributeArraySetBase>;
    using ArrayType = TCopyQualifiersFromTo_T<AttributeType, TMeshUnboundedAttributeArraySet<std::remove_cv_t<AttributeType>>>;
 
    explicit TMeshAttributesRef(BaseArrayType* InArrayPtr = nullptr, uint32 InExtent = 0)
        : ArrayPtr(InArrayPtr)
    {}
 
    template <typename SrcAttributeType,
              typename DestAttributeType = AttributeType,
              typename TEnableIf<std::is_const_v<DestAttributeType>, int>::Type = 0,
              typename TEnableIf<!std::is_const_v<SrcAttributeType>, int>::Type = 0>
    TMeshAttributesRef(const TMeshAttributesRef<ElementIDType, TArrayAttribute<SrcAttributeType>>& InRef)
        : ArrayPtr(InRef.ArrayPtr)
    {}
 
    template <typename IDType = ElementIDType,
              typename TEnableIf<!std::is_same_v<IDType, int32>, int>::Type = 0>
    TMeshAttributesRef(const TMeshAttributesRef<int32, TArrayAttribute<AttributeType>>& InRef)
        : ArrayPtr(InRef.ArrayPtr)
    {}
 
    template <typename SrcAttributeType,
              typename DestAttributeType = AttributeType,
              typename IDType = ElementIDType,
              typename TEnableIf<!std::is_same_v<IDType, int32>, int>::Type = 0,
              typename TEnableIf<std::is_const_v<DestAttributeType>, int>::Type = 0,
              typename TEnableIf<!std::is_const_v<SrcAttributeType>, int>::Type = 0>
    TMeshAttributesRef(const TMeshAttributesRef<int32, TArrayAttribute<SrcAttributeType>>& InRef)
        : ArrayPtr(InRef.ArrayPtr)
    {}
 
 
    template <typename T = ElementIDType, typename TEnableIf<TIsDerivedFrom<T, FElementID>::Value, int>::Type = 0>
    TArrayAttribute<AttributeType> operator[](const ElementIDType ElementID) const
    {
        return TArrayAttribute<AttributeType>(static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(0), ElementID.GetValue());
    }
 
    template <typename T = ElementIDType, typename TEnableIf<TIsDerivedFrom<T, FElementID>::Value, int>::Type = 0>
    TArrayAttribute<AttributeType> Get(const ElementIDType ElementID, const int32 Channel = 0) const
    {
        return TArrayAttribute<AttributeType>(static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(Channel), ElementID.GetValue());
    }
 
    TArrayAttribute<AttributeType> operator[](int32 ElementIndex) const
    {
        return TArrayAttribute<AttributeType>(static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(0), ElementIndex);
    }
 
    TArrayAttribute<AttributeType> Get(int32 ElementIndex, const int32 Channel = 0) const
    {
        return TArrayAttribute<AttributeType>(static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(Channel), ElementIndex);
    }
 
    TArrayView<AttributeType> GetArrayView(int32 ElementIndex, const int32 Channel = 0) const
    {
        return Get(ElementIndex, Channel).ToArrayView();
    }
 
    const TAttributeArrayContainer<AttributeType>* GetRawArray(const int32 AttributeChannel = 0) const
    {
        if (ArrayPtr == nullptr || GetNumElements() == 0)
        {
            return nullptr;
        }
 
        return &static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(AttributeChannel);
    }
 
    bool IsValid() const { return (ArrayPtr != nullptr); }
 
    AttributeType GetDefaultValue() const { return static_cast<ArrayType*>(ArrayPtr)->GetDefaultValue(); }
 
    int32 GetNumChannels() const
    {
        return static_cast<ArrayType*>(ArrayPtr)->ArrayType::GetNumChannels();  // note: override virtual dispatch
    }
 
    int32 GetNumElements() const
    {
        return ArrayPtr->GetNumElements();
    }
 
    EMeshAttributeFlags GetFlags() const { return ArrayPtr->GetFlags(); }
 
    template <typename T = ElementIDType, typename TEnableIf<TIsDerivedFrom<T, FElementID>::Value, int>::Type = 0>
    void Set(const ElementIDType ElementID, TArrayAttribute<const AttributeType> Value) const
    {
        static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(0).Set(ElementID.GetValue(), Value.ToArrayView());
    }
 
    template <typename T = ElementIDType, typename TEnableIf<TIsDerivedFrom<T, FElementID>::Value, int>::Type = 0>
    void Set(const ElementIDType ElementID, const int32 Channel, TArrayAttribute<const AttributeType> Value) const
    {
        static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).Set(ElementID.GetValue(), Value.ToArrayView());
    }
 
    void Set(int32 ElementIndex, TArrayAttribute<const AttributeType> Value) const
    {
        static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(0).Set(ElementIndex, Value.ToArrayView());
    }
 
    void Set(int32 ElementIndex, const int32 Channel, TArrayAttribute<const AttributeType> Value) const
    {
        static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).Set(ElementIndex, Value.ToArrayView());
    }
 
    void SetArrayView(int32 ElementIndex, TArrayView<const AttributeType> Value) const
    {
        static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(0).Set(ElementIndex, Value);
    }
 
    void SetArrayView(int32 ElementIndex, const int32 Channel, TArrayView<const AttributeType> Value) const
    {
        static_cast<ArrayType*>(ArrayPtr)->GetArrayForChannel(Channel).Set(ElementIndex, Value);
    }
 
    void Copy(TMeshAttributesConstRef<ElementIDType, TArrayAttribute<AttributeType>> Src, const int32 DestChannel = 0, const int32 SrcChannel = 0);
 
    void SetNumChannels(const int32 NumChannels) const
    {
        static_cast<ArrayType*>(ArrayPtr)->ArrayType::SetNumChannels(NumChannels);  // note: override virtual dispatch
    }
 
    void InsertChannel(const int32 Index) const
    {
        static_cast<ArrayType*>(ArrayPtr)->ArrayType::InsertChannel(Index);     // note: override virtual dispatch
    }
 
    void RemoveChannel(const int32 Index) const
    {
        static_cast<ArrayType*>(ArrayPtr)->ArrayType::RemoveChannel(Index);     // note: override virtual dispatch
    }
 
private:
    BaseArrayType* ArrayPtr;
};
 
 
class FAttributesSetEntry
{
public:
    FAttributesSetEntry() = default;
 
    template <typename AttributeType>
    FAttributesSetEntry(const int32 NumberOfChannels, const AttributeType& Default, const EMeshAttributeFlags Flags, const int32 NumElements, const int32 Extent)
    {
        if (Extent > 0)
        {
            Ptr = MakeUnique<TMeshAttributeArraySet<AttributeType>>(NumberOfChannels, Default, Flags, NumElements, Extent);
        }
        else
        {
            Ptr = MakeUnique<TMeshUnboundedAttributeArraySet<AttributeType>>(NumberOfChannels, Default, Flags, NumElements);
        }
    }
 
    ~FAttributesSetEntry() = default;
 
    FAttributesSetEntry(const FAttributesSetEntry& Other)
        : Ptr(Other.Ptr ? Other.Ptr->Clone() : nullptr)
    {}
 
    FAttributesSetEntry(FAttributesSetEntry&&) = default;
 
    FAttributesSetEntry& operator=(const FAttributesSetEntry& Other)
    {
        FAttributesSetEntry Temp(Other);
        Swap(*this, Temp);
        return *this;
    }
 
    FAttributesSetEntry& operator=(FAttributesSetEntry&&) = default;
 
    inline const FMeshAttributeArraySetBase* Get() const { return Ptr.Get(); }
    inline const FMeshAttributeArraySetBase* operator->() const { return Ptr.Get(); }
    inline const FMeshAttributeArraySetBase& operator*() const { return *Ptr; }
    inline FMeshAttributeArraySetBase* Get() { return Ptr.Get(); }
    inline FMeshAttributeArraySetBase* operator->() { return Ptr.Get(); }
    inline FMeshAttributeArraySetBase& operator*() { return *Ptr; }
 
    inline explicit operator bool() const { return Ptr.IsValid(); }
    inline bool operator!() const { return !Ptr.IsValid(); }
 
    void CreateArrayOfType(const uint32 Type, const uint32 Extent);
 
    friend FArchive& operator<<(FArchive& Ar, FAttributesSetEntry& Entry);
 
private:
    TUniquePtr<FMeshAttributeArraySetBase> Ptr;
};
 
 
class FAttributesSetBase
{
public:
    FAttributesSetBase()
        : NumElements(0)
    {}
 
    template <typename T>
    TMeshAttributesArray<typename TMeshAttributesRegisterType<T>::RefType> RegisterAttributeInternal(
        const FName AttributeName,
        const int32 NumberOfChannels = 1,
        const typename TMeshAttributesRegisterType<T>::RealAttributeType& Default = typename TMeshAttributesRegisterType<T>::RealAttributeType(),
        const EMeshAttributeFlags Flags = EMeshAttributeFlags::None)
    {
        using AttributeType = typename TMeshAttributesRegisterType<T>::AttributeType;
        using RealAttributeType = typename TMeshAttributesRegisterType<T>::RealAttributeType;
        using RefType = typename TMeshAttributesRegisterType<T>::RefType;
        const uint32 Extent = TMeshAttributesRegisterType<T>::Extent;
 
        if (FAttributesSetEntry* ArraySetPtr = Map.Find(AttributeName))
        {
            if ((*ArraySetPtr)->HasType<RealAttributeType>() && (*ArraySetPtr)->GetExtent() == Extent)
            {
                (*ArraySetPtr)->SetNumChannels(NumberOfChannels);
                (*ArraySetPtr)->SetFlags(Flags);
                return TMeshAttributesArray<RefType>(ArraySetPtr->Get(), Extent);
            }
            else
            {
                Map.Remove(AttributeName);
            }
        }
 
        FAttributesSetEntry& Entry = Map.Emplace(AttributeName, FAttributesSetEntry(NumberOfChannels, Default, Flags, NumElements, Extent));
        return TMeshAttributesArray<RefType>(Entry.Get(), Extent);
    }
 
    template <typename T,
              typename TEnableIf<!TIsArray<T>::Value, int>::Type = 0>
    TMeshAttributesArray<typename TMeshAttributesRegisterType<T>::RefType> RegisterAttribute(
        const FName AttributeName,
        const int32 NumberOfChannels = 1,
        const T& Default = T(),
        const EMeshAttributeFlags Flags = EMeshAttributeFlags::None)
    {
        return this->RegisterAttributeInternal<T>(AttributeName, NumberOfChannels, Default, Flags);
    }
 
    template <typename T,
              typename TEnableIf<TIsArray<T>::Value, int>::Type = 0>
    TMeshAttributesArray<typename TMeshAttributesRegisterType<T>::RefType> RegisterAttribute(
        const FName AttributeName,
        const int32 NumberOfChannels = 1,
        const typename TMeshAttributesRegisterType<T>::RealAttributeType& Default = typename TMeshAttributesRegisterType<T>::RealAttributeType(),
        const EMeshAttributeFlags Flags = EMeshAttributeFlags::None)
    {
        return this->RegisterAttributeInternal<T>(AttributeName, NumberOfChannels, Default, Flags);
    }
 
    template <typename T,
              typename TEnableIf<std::is_same_v<typename TMeshAttributesRegisterType<T>::RealAttributeType, int>, int>::Type = 0>
    TMeshAttributesArray<typename TMeshAttributesRegisterType<T>::RefType> RegisterIndexAttribute(
        const FName AttributeName,
        const int32 NumberOfChannels = 1,
        const EMeshAttributeFlags Flags = EMeshAttributeFlags::None)
    {
        return this->RegisterAttributeInternal<T>(AttributeName, NumberOfChannels, int32(INDEX_NONE), Flags | EMeshAttributeFlags::IndexReference);
    }
 
    void UnregisterAttribute(const FName AttributeName)
    {
        Map.Remove(AttributeName);
    }
 
    bool HasAttribute(const FName AttributeName) const
    {
        return Map.Contains(AttributeName);
    }
 
    template <typename T>
    bool HasAttributeOfType(const FName AttributeName) const
    {
        using RealAttributeType = typename TMeshAttributesRefType<T>::RealAttributeType;
 
        if (const FAttributesSetEntry* ArraySetPtr = Map.Find(AttributeName))
        {
            return (*ArraySetPtr)->HasType<RealAttributeType>() &&
                   (*ArraySetPtr)->GetExtent() >= TMeshAttributesRefType<T>::MinExpectedExtent &&
                   (*ArraySetPtr)->GetExtent() <= TMeshAttributesRefType<T>::MaxExpectedExtent;
        }
 
        return false;
    }
 
    void Initialize(const int32 Count)
    {
        NumElements = Count;
        for (auto& MapEntry : Map)
        {
            MapEntry.Value->Initialize(Count);
        }
    }
 
    void SetNumElements(const int32 Count)
    {
        NumElements = Count;
        for (auto& MapEntry : Map)
        {
            MapEntry.Value->SetNumElements(Count);
        }
    }
 
    int32 GetNumElements() const
    {
        return NumElements;
    }
 
    void Remap(const TSparseArray<int32>& IndexRemap);
 
    template <typename Allocator>
    void GetAttributeNames(TArray<FName, Allocator>& OutAttributeNames) const
    {
        Map.GetKeys(OutAttributeNames);
    }
 
    bool DoesAttributeHaveAnyFlags(const FName AttributeName, EMeshAttributeFlags AttributeFlags) const
    {
        if (const FAttributesSetEntry* ArraySetPtr = Map.Find(AttributeName))
        {
            return EnumHasAnyFlags((*ArraySetPtr)->GetFlags(), AttributeFlags);
        }
 
        return false;
    }
 
    bool DoesAttributeHaveAllFlags(const FName AttributeName, EMeshAttributeFlags AttributeFlags) const
    {
        if (const FAttributesSetEntry* ArraySetPtr = Map.Find(AttributeName))
        {
            return EnumHasAllFlags((*ArraySetPtr)->GetFlags(), AttributeFlags);
        }
 
        return false;
    }
 
    uint32 GetHash(const FName AttributeName) const
    {
        if (const FAttributesSetEntry* ArraySetPtr = Map.Find(AttributeName))
        {
            return (*ArraySetPtr)->GetHash();
        }
        return 0;
    }
 
    void Insert(const int32 Index)
    {
        NumElements = FMath::Max(NumElements, Index + 1);
 
        for (auto& MapEntry : Map)
        {
            MapEntry.Value->Insert(Index);
 
#if DO_CHECK
            // Log out some more debug info when this fails, as it's failing in public builds with no known repro
            if (MapEntry.Value->GetNumElements() != NumElements)
            {
                UE_LOGFMT(LogMeshDescription, Error, "NumElements mismatch in FAttributesSetBase::Insert");
                UE_LOGFMT(LogMeshDescription, Error, "NumElements: {NumElements}", NumElements);
                UE_LOGFMT(LogMeshDescription, Error, "Index: {Index}", Index);
                UE_LOGFMT(LogMeshDescription, Error, "Mismatched attribute: {Attribute}\n", MapEntry.Key.ToString());
 
                for (const TPair<FName, FAttributesSetEntry>& Pair : Map)
                {
                    UE_LOGFMT(LogMeshDescription, Error, "Attribute {Attribute} NumElements: {NumElements}\n", Pair.Key.ToString(), Pair.Value->GetNumElements());
                }
 
                // Add some info to the assert message anyway, in case the logs are suppressed
                checkf(false, TEXT("NumElements mismatch in FAttributesSetBase::Insert: %s: %i != %i"), *MapEntry.Key.ToString(), MapEntry.Value->GetNumElements(), NumElements);
            }
#endif
        }
    }
 
    void Remove(const int32 Index)
    {
        for (auto& MapEntry : Map)
        {
            MapEntry.Value->Remove(Index);
        }
    }
 
    template <typename T>
    TMeshAttributesConstRef<int32, typename TMeshAttributesRefType<T>::ConstRefType> GetAttributesRef(const FName AttributeName) const
    {
        using RefType = typename TMeshAttributesRefType<T>::ConstRefType;
 
        if (const FAttributesSetEntry* ArraySetPtr = this->Map.Find(AttributeName))
        {
            using AttributeType = typename TMeshAttributesRefType<T>::AttributeType;
            using RealAttributeType = typename TMeshAttributesRefType<T>::RealAttributeType;
 
            if ((*ArraySetPtr)->HasType<RealAttributeType>())
            {
                uint32 ActualExtent = (*ArraySetPtr)->GetExtent();
                if (ActualExtent >= TMeshAttributesRefType<T>::MinExpectedExtent && ActualExtent <= TMeshAttributesRefType<T>::MaxExpectedExtent)
                {
                    return TMeshAttributesConstRef<int32, RefType>(ArraySetPtr->Get(), ActualExtent);
                }
            }
        }
 
        return TMeshAttributesConstRef<int32, RefType>();
    }
 
    template <typename T>
    TMeshAttributesRef<int32, typename TMeshAttributesRefType<T>::RefType> GetAttributesRef(const FName AttributeName)
    {
        using RefType = typename TMeshAttributesRefType<T>::RefType;
 
        if (FAttributesSetEntry* ArraySetPtr = this->Map.Find(AttributeName))
        {
            using AttributeType = typename TMeshAttributesRefType<T>::AttributeType;
            using RealAttributeType = typename TMeshAttributesRefType<T>::RealAttributeType;
 
            if ((*ArraySetPtr)->HasType<RealAttributeType>())
            {
                uint32 ActualExtent = (*ArraySetPtr)->GetExtent();
                if (ActualExtent >= TMeshAttributesRefType<T>::MinExpectedExtent && ActualExtent <= TMeshAttributesRefType<T>::MaxExpectedExtent)
                {
                    return TMeshAttributesRef<int32, RefType>(ArraySetPtr->Get(), ActualExtent);
                }
            }
        }
 
        return TMeshAttributesRef<int32, RefType>();
    }
 
    void AppendAttributesFrom(const FAttributesSetBase& OtherAttributesSet);
 
protected:
    friend MESHDESCRIPTION_API FArchive& operator<<(FArchive& Ar, FAttributesSetBase& AttributesSet);
 
    template <typename T>
    friend void SerializeLegacy(FArchive& Ar, FAttributesSetBase& AttributesSet);
 
    TMap<FName, FAttributesSetEntry> Map;
 
    int32 NumElements;
};
 
 
template <typename ElementIDType>
class TAttributesSet final : public FAttributesSetBase
{
    using FAttributesSetBase::Insert;
    using FAttributesSetBase::Remove;
 
public:
    template <typename T>
    TMeshAttributesConstRef<ElementIDType, typename TMeshAttributesRefType<T>::ConstRefType> GetAttributesRef(const FName AttributeName) const
    {
        using RefType = typename TMeshAttributesRefType<T>::ConstRefType;
 
        if (const FAttributesSetEntry* ArraySetPtr = this->Map.Find(AttributeName))
        {
            using AttributeType = typename TMeshAttributesRefType<T>::AttributeType;
            using RealAttributeType = typename TMeshAttributesRefType<T>::RealAttributeType;
 
            if ((*ArraySetPtr)->HasType<RealAttributeType>())
            {
                uint32 ActualExtent = (*ArraySetPtr)->GetExtent();
                if (ActualExtent >= TMeshAttributesRefType<T>::MinExpectedExtent && ActualExtent <= TMeshAttributesRefType<T>::MaxExpectedExtent)
                {
                    return TMeshAttributesConstRef<ElementIDType, RefType>(ArraySetPtr->Get(), ActualExtent);
                }
            }
        }
 
        return TMeshAttributesConstRef<ElementIDType, RefType>();
    }
 
    // Non-const version
    template <typename T>
    TMeshAttributesRef<ElementIDType, typename TMeshAttributesRefType<T>::RefType> GetAttributesRef(const FName AttributeName)
    {
        using RefType = typename TMeshAttributesRefType<T>::RefType;
 
        if (FAttributesSetEntry* ArraySetPtr = this->Map.Find(AttributeName))
        {
            using AttributeType = typename TMeshAttributesRefType<T>::AttributeType;
            using RealAttributeType = typename TMeshAttributesRefType<T>::RealAttributeType;
 
            if ((*ArraySetPtr)->HasType<RealAttributeType>())
            {
                uint32 ActualExtent = (*ArraySetPtr)->GetExtent();
                if (ActualExtent >= TMeshAttributesRefType<T>::MinExpectedExtent && ActualExtent <= TMeshAttributesRefType<T>::MaxExpectedExtent)
                {
                    return TMeshAttributesRef<ElementIDType, RefType>(ArraySetPtr->Get(), ActualExtent);
                }
            }
        }
 
        return TMeshAttributesRef<ElementIDType, RefType>();
    }
 
 
    UE_DEPRECATED(5.0, "Please use GetAttributeChannelCount() instead.")
    int32 GetAttributeIndexCount(const FName AttributeName) const
    {
        return GetAttributeChannelCount(AttributeName);
    }
 
    int32 GetAttributeChannelCount(const FName AttributeName) const
    {
        if (const FAttributesSetEntry* ArraySetPtr = this->Map.Find(AttributeName))
        {
            return (*ArraySetPtr)->GetNumChannels();
        }
 
        return 0;
    }
 
    template <typename AttributeType>
    UE_DEPRECATED(5.0, "Please use GetAttributeChannelCount() instead.")
    int32 GetAttributeIndexCount(const FName AttributeName) const
    {
        if (const FAttributesSetEntry* ArraySetPtr = this->Map.Find(AttributeName))
        {
            if ((*ArraySetPtr)->HasType<AttributeType>())
            {
                using ArrayType = TMeshAttributeArraySet<AttributeType>;
                return static_cast<const ArrayType*>( ArraySetPtr->Get() )->ArrayType::GetNumChannels();    // note: override virtual dispatch
            }
        }
 
        return 0;
    }
 
    UE_DEPRECATED(5.0, "Please use SetAttributeChannelCount() instead.")
    void SetAttributeIndexCount(const FName AttributeName, const int32 NumChannels)
    {
        SetAttributeChannelCount(AttributeName, NumChannels);
    }
 
    void SetAttributeChannelCount(const FName AttributeName, const int32 NumChannels)
    {
        if (FAttributesSetEntry* ArraySetPtr = this->Map.Find(AttributeName))
        {
            (*ArraySetPtr)->SetNumChannels(NumChannels);
        }
    }
 
    template <typename AttributeType>
    UE_DEPRECATED(5.0, "Please use untemplated SetAttributeChannelCount() instead.")
    void SetAttributeIndexCount(const FName AttributeName, const int32 NumIndices)
    {
        if (FAttributesSetEntry* ArraySetPtr = this->Map.Find(AttributeName))
        {
            if ((*ArraySetPtr)->HasType<AttributeType>())
            {
                using ArrayType = TMeshAttributeArraySet<AttributeType>;
                static_cast<ArrayType*>(ArraySetPtr->Get())->ArrayType::SetNumChannels(NumIndices); // note: override virtual dispatch
            }
        }
    }
 
    UE_DEPRECATED(5.0, "Please use InsertAttributeChannel() instead.")
    void InsertAttributeIndex(const FName AttributeName, const int32 Index)
    {
        InsertAttributeChannel(AttributeName, Index);
    }
 
    void InsertAttributeChannel(const FName AttributeName, const int32 Index)
    {
        if (FAttributesSetEntry* ArraySetPtr = this->Map.Find(AttributeName))
        {
            (*ArraySetPtr)->InsertChannel(Index);
        }
    }
 
    template <typename AttributeType>
    UE_DEPRECATED(5.0, "Please use untemplated InsertAttributeIndexCount() instead.")
    void InsertAttributeIndex(const FName AttributeName, const int32 Index)
    {
        if (FAttributesSetEntry* ArraySetPtr = this->Map.Find(AttributeName))
        {
            if ((*ArraySetPtr)->HasType<AttributeType>())
            {
                using ArrayType = TMeshAttributeArraySet<AttributeType>;
                static_cast<ArrayType*>(ArraySetPtr->Get())->ArrayType::InsertChannel(Index);   // note: override virtual dispatch
            }
        }
    }
 
    UE_DEPRECATED(5.0, "Please use RemoveAttributeChannel() instead.")
    void RemoveAttributeIndex(const FName AttributeName, const int32 Index)
    {
        RemoveAttributeChannel(AttributeName, Index);
    }
 
    void RemoveAttributeChannel(const FName AttributeName, const int32 Index)
    {
        if (FAttributesSetEntry* ArraySetPtr = this->Map.Find(AttributeName))
        {
            (*ArraySetPtr)->RemoveChannel(Index);
        }
    }
 
    template <typename AttributeType>
    UE_DEPRECATED(5.0, "Please use untemplated RemoveAttributeIndexCount() instead.")
    void RemoveAttributeIndex(const FName AttributeName, const int32 Index)
    {
        if (FAttributesSetEntry* ArraySetPtr = this->Map.Find(AttributeName))
        {
            if ((*ArraySetPtr)->HasType<AttributeType>())
            {
                using ArrayType = TMeshAttributeArraySet<AttributeType>;
                static_cast<ArrayType*>(ArraySetPtr->Get())->ArrayType::RemoveChannel(Index);   // note: override virtual dispatch
            }
        }
    }
 
    template <typename T>
    T GetAttribute(const ElementIDType ElementID, const FName AttributeName, const int32 AttributeChannel = 0) const
    {
        using RefType = typename TMeshAttributesRefType<T>::ConstRefType;
        using AttributeType = typename TMeshAttributesRefType<T>::AttributeType;
        using RealAttributeType = typename TMeshAttributesRefType<T>::RealAttributeType;
 
        const FMeshAttributeArraySetBase* ArraySetPtr = this->Map.FindChecked(AttributeName).Get();
        uint32 ActualExtent = ArraySetPtr->GetExtent();
        check(ArraySetPtr->HasType<RealAttributeType>());
        check(ActualExtent >= TMeshAttributesRefType<AttributeType>::MinExpectedExtent && ActualExtent <= TMeshAttributesRefType<AttributeType>::MaxExpectedExtent);
 
        TMeshAttributesConstRef<FElementID, RefType> Ref(ArraySetPtr, ActualExtent);
        return Ref.Get(ElementID, AttributeChannel);
    }
 
 
    template <typename T>
    void SetAttribute(const ElementIDType ElementID, const FName AttributeName, const int32 AttributeChannel, const T& AttributeValue)
    {
        using NonConstRefType = typename TMeshAttributesRefType<T>::NonConstRefType;
        using AttributeType = typename TMeshAttributesRefType<T>::AttributeType;
        using RealAttributeType = typename TMeshAttributesRefType<T>::RealAttributeType;
 
        FMeshAttributeArraySetBase* ArraySetPtr = this->Map.FindChecked(AttributeName).Get();
        uint32 ActualExtent = ArraySetPtr->GetExtent();
        check(ArraySetPtr->HasType<std::remove_cv_t<RealAttributeType>>());
        check(ActualExtent >= TMeshAttributesRefType<AttributeType>::MinExpectedExtent && ActualExtent <= TMeshAttributesRefType<AttributeType>::MaxExpectedExtent);
 
        TMeshAttributesRef<FElementID, NonConstRefType> Ref(ArraySetPtr, ActualExtent);
        return Ref.Set(ElementID, AttributeChannel, AttributeValue);
    }
 
 
 
    inline void Insert(const ElementIDType ElementID)
    {
        this->Insert(ElementID.GetValue());
    }
 
    inline void Remove(const ElementIDType ElementID)
    {
        this->Remove(ElementID.GetValue());
    }
 
    template <typename ForEachFunc> void ForEach(ForEachFunc Func);
 
    template <typename ForEachFunc> void ForEach(ForEachFunc Func) const;
 
    template <typename AttributeType, typename ForEachFunc> void ForEachByType(ForEachFunc Func);
    
    template <typename AttributeType, typename ForEachFunc> void ForEachByType(ForEachFunc Func) const;
};
 
 
template <typename FnType, uint32 Size>
struct TJumpTable
{
    template <typename... T>
    explicit constexpr TJumpTable( T... Ts ) : Fns{ Ts... } {}
 
    FnType* Fns[Size];
};
 
 
 
namespace ForEachImpl
{
    // Declare type of jump table used to dispatch functions
    template <typename ElementIDType, typename ForEachFunc>
    using JumpTableType = TJumpTable<void(FName, ForEachFunc, FMeshAttributeArraySetBase*), TTupleArity<AttributeTypes>::Value>;
 
    // Define dispatch function
    template <typename ElementIDType, typename ForEachFunc, uint32 I>
    static void Dispatch(FName Name, ForEachFunc Fn, FMeshAttributeArraySetBase* Attributes)
    {
        using AttributeType = typename TTupleElement<I, AttributeTypes>::Type;
        if (Attributes->GetExtent() == 0)
        {
            Fn(Name, TMeshAttributesRef<ElementIDType, TArrayAttribute<AttributeType>>(static_cast<TMeshUnboundedAttributeArraySet<AttributeType>*>(Attributes)));
        }
        else if (Attributes->GetExtent() == 1)
        {
            Fn(Name, TMeshAttributesRef<ElementIDType, AttributeType>(static_cast<TMeshAttributeArraySet<AttributeType>*>(Attributes)));
        }
        else
        {
            Fn(Name, TMeshAttributesRef<ElementIDType, TArrayView<AttributeType>>(static_cast<TMeshAttributeArraySet<AttributeType>*>(Attributes), Attributes->GetExtent()));
        }
    }
 
    // Build ForEach jump table at compile time, a separate instantiation of Dispatch for each attribute type
    template <typename ElementIDType, typename ForEachFunc, uint32... Is>
    static constexpr JumpTableType<ElementIDType, ForEachFunc> MakeJumpTable(TIntegerSequence< uint32, Is...>)
    {
        return JumpTableType<ElementIDType, ForEachFunc>(Dispatch<ElementIDType, ForEachFunc, Is>...);
    }
}
 
template <typename ElementIDType>
template <typename ForEachFunc>
void TAttributesSet<ElementIDType>::ForEach(ForEachFunc Func)
{
    // Construct compile-time jump table for dispatching ForEachImpl::Dispatch() by the attribute type at runtime
    static constexpr ForEachImpl::JumpTableType<ElementIDType, ForEachFunc>
        JumpTable = ForEachImpl::MakeJumpTable<ElementIDType, ForEachFunc>(TMakeIntegerSequence<uint32, TTupleArity<AttributeTypes>::Value>());
 
    for (auto& MapEntry : this->Map)
    {
        const uint32 Type = MapEntry.Value->GetType();
        JumpTable.Fns[Type](MapEntry.Key, Func, MapEntry.Value.Get());
    }
}
 
 
namespace ForEachConstImpl
{
    // Declare type of jump table used to dispatch functions
    template <typename ElementIDType, typename ForEachFunc>
    using JumpTableType = TJumpTable<void(FName, ForEachFunc, const FMeshAttributeArraySetBase*), TTupleArity<AttributeTypes>::Value>;
 
    // Define dispatch function
    template <typename ElementIDType, typename ForEachFunc, uint32 I>
    static void Dispatch(FName Name, ForEachFunc Fn, const FMeshAttributeArraySetBase* Attributes)
    {
        using AttributeType = typename TTupleElement<I, AttributeTypes>::Type;
        if (Attributes->GetExtent() == 0)
        {
            Fn(Name, TMeshAttributesConstRef<ElementIDType, TArrayAttribute<const AttributeType>>(static_cast<const TMeshUnboundedAttributeArraySet<AttributeType>*>(Attributes)));
        }
        else if (Attributes->GetExtent() == 1)
        {
            Fn(Name, TMeshAttributesConstRef<ElementIDType, AttributeType>(static_cast<const TMeshAttributeArraySet<AttributeType>*>(Attributes)));
        }
        else
        {
            Fn(Name, TMeshAttributesConstRef<ElementIDType, TArrayView<const AttributeType>>(static_cast<const TMeshAttributeArraySet<AttributeType>*>(Attributes), Attributes->GetExtent()));
        }
    }
 
    // Build ForEach jump table at compile time, a separate instantiation of Dispatch for each attribute type
    template <typename ElementIDType, typename ForEachFunc, uint32... Is>
    static constexpr JumpTableType<ElementIDType, ForEachFunc> MakeJumpTable(TIntegerSequence< uint32, Is...>)
    {
        return JumpTableType<ElementIDType, ForEachFunc>(Dispatch<ElementIDType, ForEachFunc, Is>...);
    }
}
 
template <typename ElementIDType>
template <typename ForEachFunc>
void TAttributesSet<ElementIDType>::ForEach(ForEachFunc Func) const
{
    // Construct compile-time jump table for dispatching ForEachImpl::Dispatch() by the attribute type at runtime
    static constexpr ForEachConstImpl::JumpTableType<ElementIDType, ForEachFunc>
        JumpTable = ForEachConstImpl::MakeJumpTable<ElementIDType, ForEachFunc>(TMakeIntegerSequence<uint32, TTupleArity<AttributeTypes>::Value>());
 
    for (const auto& MapEntry : this->Map)
    {
        const uint32 Type = MapEntry.Value->GetType();
        JumpTable.Fns[Type](MapEntry.Key, Func, MapEntry.Value.Get());
    }
}
 
 
namespace ForEachByTypeImpl
{
    template<typename ElementIDType, typename AttributeType, typename ForEachFunc>
    struct DispatchFunctor
    {
        void operator()(FName Name, ForEachFunc Fn, FMeshAttributeArraySetBase* Attributes)
        {
            if (TTupleIndex<AttributeType, AttributeTypes>::Value == Attributes->GetType() && Attributes->GetExtent() == 1)
            {
                Fn(Name, TMeshAttributesRef<ElementIDType, AttributeType>(static_cast<TMeshAttributeArraySet<AttributeType>*>(Attributes)));
            }
        }
    };
 
    template<typename ElementIDType,  typename AttributeType, typename ForEachFunc>
    struct DispatchFunctor<ElementIDType, TArrayView<AttributeType>, ForEachFunc>
    {
        void operator()(FName Name, ForEachFunc Fn, FMeshAttributeArraySetBase* Attributes)
        {
            if (TTupleIndex<AttributeType, AttributeTypes>::Value == Attributes->GetType() && Attributes->GetExtent() >= 1)
            {
                Fn(Name, TMeshAttributesRef<ElementIDType, TArrayView<AttributeType>>(static_cast<TMeshAttributeArraySet<AttributeType>*>(Attributes), Attributes->GetExtent()));
            }
        }
    };
 
    template<typename ElementIDType, typename AttributeType, typename ForEachFunc>
    struct DispatchFunctor<ElementIDType, TArrayAttribute<AttributeType>, ForEachFunc>
    {
        void operator()(FName Name, ForEachFunc Fn, FMeshAttributeArraySetBase* Attributes)
        {
            if (TTupleIndex<AttributeType, AttributeTypes>::Value == Attributes->GetType() && Attributes->GetExtent() == 0)
            {
                Fn(Name, TMeshAttributesRef<ElementIDType, TArrayAttribute<AttributeType>>(static_cast<TMeshUnboundedAttributeArraySet<AttributeType>*>(Attributes)));
            }
        }
    };
    
    template<typename ElementIDType, typename AttributeType, typename ForEachFunc>
    struct ConstDispatchFunctor
    {
        void operator()(FName Name, ForEachFunc Fn, const FMeshAttributeArraySetBase* Attributes)
        {
            if (TTupleIndex<AttributeType, AttributeTypes>::Value == Attributes->GetType() && Attributes->GetExtent() == 1)
            {
                Fn(Name, TMeshAttributesConstRef<ElementIDType, AttributeType>(static_cast<const TMeshAttributeArraySet<AttributeType>*>(Attributes)));
            }
        }
    };
 
    template<typename ElementIDType,  typename AttributeType, typename ForEachFunc>
    struct ConstDispatchFunctor<ElementIDType, TArrayView<AttributeType>, ForEachFunc>
    {
        void operator()(FName Name, ForEachFunc Fn, const FMeshAttributeArraySetBase* Attributes)
        {
            if (TTupleIndex<AttributeType, AttributeTypes>::Value == Attributes->GetType() && Attributes->GetExtent() >= 1)
            {
                Fn(Name, TMeshAttributesConstRef<ElementIDType, TArrayView<const AttributeType>>(static_cast<const TMeshAttributeArraySet<AttributeType>*>(Attributes), Attributes->GetExtent()));
            }
        }
    };
 
    template<typename ElementIDType, typename AttributeType, typename ForEachFunc>
    struct ConstDispatchFunctor<ElementIDType, TArrayAttribute<AttributeType>, ForEachFunc>
    {
        void operator()(FName Name, ForEachFunc Fn, const FMeshAttributeArraySetBase* Attributes)
        {
            if (TTupleIndex<AttributeType, AttributeTypes>::Value == Attributes->GetType() && Attributes->GetExtent() == 0)
            {
                Fn(Name, TMeshAttributesConstRef<ElementIDType, TArrayAttribute<const AttributeType>>(static_cast<const TMeshUnboundedAttributeArraySet<AttributeType>*>(Attributes)));
            }
        }
    };}
 
template <typename ElementIDType>
template < typename AttributeType, typename ForEachFunc>
void TAttributesSet<ElementIDType>::ForEachByType(ForEachFunc Func)
{
    for (auto& MapEntry : this->Map)
    {
        ForEachByTypeImpl::DispatchFunctor<ElementIDType, std::remove_const_t<AttributeType>, ForEachFunc>()(MapEntry.Key, Func, MapEntry.Value.Get());
    }
}
 
template <typename ElementIDType>
template < typename AttributeType, typename ForEachFunc>
void TAttributesSet<ElementIDType>::ForEachByType(ForEachFunc Func) const
{
    for (const auto& MapEntry : this->Map)
    {
        ForEachByTypeImpl::ConstDispatchFunctor<ElementIDType, std::remove_const_t<AttributeType>, ForEachFunc>()(MapEntry.Key, Func, MapEntry.Value.Get());
    }
}
 
 
namespace CreateTypeImpl
{
    // Declare type of jump table used to dispatch functions
    using JumpTableType = TJumpTable<TUniquePtr<FMeshAttributeArraySetBase>(uint32), TTupleArity<AttributeTypes>::Value>;
 
    // Define dispatch function
    template <uint32 I>
    static TUniquePtr<FMeshAttributeArraySetBase> Dispatch(uint32 Extent)
    {
        using AttributeType = typename TTupleElement<I, AttributeTypes>::Type;
        if (Extent > 0)
        {
            return MakeUnique<TMeshAttributeArraySet<AttributeType>>(Extent);
        }
        else
        {
            return MakeUnique<TMeshUnboundedAttributeArraySet<AttributeType>>();
        }
    }
 
    // Build RegisterAttributeOfType jump table at compile time, a separate instantiation of Dispatch for each attribute type
    template <uint32... Is>
    static constexpr JumpTableType MakeJumpTable(TIntegerSequence< uint32, Is...>)
    {
        return JumpTableType(Dispatch<Is>...);
    }
}
 
inline void FAttributesSetEntry::CreateArrayOfType(const uint32 Type, const uint32 Extent)
{
    static constexpr CreateTypeImpl::JumpTableType JumpTable = CreateTypeImpl::MakeJumpTable(TMakeIntegerSequence<uint32, TTupleArity<AttributeTypes>::Value>());
    Ptr = JumpTable.Fns[Type](Extent);
}