MeshDescription.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Algo/Accumulate.h"
#include "Algo/Copy.h"
#include "Algo/Find.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/BitArray.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/ContainersFwd.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/StaticArray.h"
#include "Containers/UnrealString.h"
#include "CoreFwd.h"
#include "CoreTypes.h"
#include "HAL/CriticalSection.h"
#include "HAL/PlatformCrt.h"
#include "Math/Box.h"
#include "Math/MathFwd.h"
#include "Math/Plane.h"
#include "Math/Vector.h"
#include "MeshAttributeArray.h"
#include "MeshElementArray.h"
#include "MeshElementContainer.h"
#include "MeshElementIndexer.h"
#include "MeshTypes.h"
#include "Misc/AssertionMacros.h"
#include "Misc/EnumClassFlags.h"
#include "Misc/Guid.h"
#include "Serialization/CustomVersion.h"
#include "Serialization/EditorBulkData.h"
#include "Templates/Tuple.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/EditorObjectVersion.h"
#include "UObject/NameTypes.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ReleaseObjectVersion.h"
 
#include "MeshDescription.generated.h"
 
class FArchive;
class UObject;
struct FElementIDRemappings;
 
enum
{
    //Remove the _MD when FRawMesh will be remove
    MAX_MESH_TEXTURE_COORDS_MD = 8,
};
 
 
using FVertexArray = TMeshElementContainer<FVertexID>;
using FVertexInstanceArray = TMeshElementContainer<FVertexInstanceID>;
using FEdgeArray = TMeshElementContainer<FEdgeID>;
using FUVArray = TMeshElementContainer<FUVID>;
using FTriangleArray = TMeshElementContainer<FTriangleID>;
using FPolygonArray = TMeshElementContainer<FPolygonID>;
using FPolygonGroupArray = TMeshElementContainer<FPolygonGroupID>;
 
template <typename AttributeType> using TVertexAttributesRef = TMeshAttributesRef<FVertexID, AttributeType>;
template <typename AttributeType> using TVertexInstanceAttributesRef = TMeshAttributesRef<FVertexInstanceID, AttributeType>;
template <typename AttributeType> using TEdgeAttributesRef = TMeshAttributesRef<FEdgeID, AttributeType>;
template <typename AttributeType> using TUVAttributesRef = TMeshAttributesRef<FUVID, AttributeType>;
template <typename AttributeType> using TTriangleAttributesRef = TMeshAttributesRef<FTriangleID, AttributeType>;
template <typename AttributeType> using TPolygonAttributesRef = TMeshAttributesRef<FPolygonID, AttributeType>;
template <typename AttributeType> using TPolygonGroupAttributesRef = TMeshAttributesRef<FPolygonGroupID, AttributeType>;
 
template <typename AttributeType> using TVertexAttributesConstRef = TMeshAttributesConstRef<FVertexID, AttributeType>;
template <typename AttributeType> using TVertexInstanceAttributesConstRef = TMeshAttributesConstRef<FVertexInstanceID, AttributeType>;
template <typename AttributeType> using TEdgeAttributesConstRef = TMeshAttributesConstRef<FEdgeID, AttributeType>;
template <typename AttributeType> using TUVAttributesConstRef = TMeshAttributesConstRef<FUVID, AttributeType>;
template <typename AttributeType> using TTriangleAttributesConstRef = TMeshAttributesConstRef<FTriangleID, AttributeType>;
template <typename AttributeType> using TPolygonAttributesConstRef = TMeshAttributesConstRef<FPolygonID, AttributeType>;
template <typename AttributeType> using TPolygonGroupAttributesConstRef = TMeshAttributesConstRef<FPolygonGroupID, AttributeType>;
 
UENUM()
enum class EComputeNTBsOptions : uint32
{
    None = 0x00000000,  // No flags
    Normals = 0x00000001, //Compute the normals
    Tangents = 0x00000002, //Compute the tangents
    WeightedNTBs = 0x00000004, //Use weight angle when computing NTBs to proportionally distribute the vertex instance contribution to the normal/tangent/binormal in a smooth group.    i.e. Weight solve the cylinder problem
};
ENUM_CLASS_FLAGS(EComputeNTBsOptions);
 
 
struct FMeshDescription
{
public:
 
    // Mesh description should be a moveable type.
    // Hence explicitly declare all the below as defaulted, to ensure they will be generated by the compiler.
    MESHDESCRIPTION_API FMeshDescription();
    ~FMeshDescription() = default;
    MESHDESCRIPTION_API FMeshDescription(const FMeshDescription&);
    MESHDESCRIPTION_API FMeshDescription& operator=(const FMeshDescription&);
    FMeshDescription(FMeshDescription&&) = default;
    FMeshDescription& operator=(FMeshDescription&&) = default;
 
    friend FArchive& operator<<(FArchive& Ar, FMeshDescription& MeshDescription)
    {
        MeshDescription.Serialize(Ar);
        return Ar;
    }
 
    // Serialize the mesh description
    MESHDESCRIPTION_API void Serialize(FArchive& Ar);
 
    // Legacy serialization for old assets
    MESHDESCRIPTION_API void SerializeLegacy(FArchive& Ar);
 
    // Empty the meshdescription
    MESHDESCRIPTION_API void Empty();
 
    // Operations on all the indexers
    MESHDESCRIPTION_API void ResetIndexers();
    MESHDESCRIPTION_API void BuildIndexers();
    MESHDESCRIPTION_API void RebuildIndexers();
 
    // Return whether the mesh description is empty
    MESHDESCRIPTION_API bool IsEmpty() const;
 
    FVertexArray& Vertices() { return static_cast<TMeshElementContainer<FVertexID>&>(VertexElements->Get()); }
    const FVertexArray& Vertices() const { return static_cast<const TMeshElementContainer<FVertexID>&>(VertexElements->Get()); }
 
    FVertexInstanceArray& VertexInstances() { return static_cast<TMeshElementContainer<FVertexInstanceID>&>(VertexInstanceElements->Get()); }
    const FVertexInstanceArray& VertexInstances() const { return static_cast<const TMeshElementContainer<FVertexInstanceID>&>(VertexInstanceElements->Get()); }
 
    FEdgeArray& Edges() { return static_cast<TMeshElementContainer<FEdgeID>&>(EdgeElements->Get()); }
    const FEdgeArray& Edges() const { return static_cast<const TMeshElementContainer<FEdgeID>&>(EdgeElements->Get()); }
 
    FUVArray& UVs(int32 Index) { return static_cast<TMeshElementContainer<FUVID>&>(UVElements->Get(Index)); }
    const FUVArray& UVs(int32 Index) const { return static_cast<const TMeshElementContainer<FUVID>&>(UVElements->Get(Index)); }
 
    FTriangleArray& Triangles() { return static_cast<TMeshElementContainer<FTriangleID>&>(TriangleElements->Get()); }
    const FTriangleArray& Triangles() const { return static_cast<const TMeshElementContainer<FTriangleID>&>(TriangleElements->Get()); }
 
    FPolygonArray& Polygons() { return static_cast<TMeshElementContainer<FPolygonID>&>(PolygonElements->Get()); }
    const FPolygonArray& Polygons() const { return static_cast<const TMeshElementContainer<FPolygonID>&>(PolygonElements->Get()); }
 
    FPolygonGroupArray& PolygonGroups() { return static_cast<TMeshElementContainer<FPolygonGroupID>&>(PolygonGroupElements->Get()); }
    const FPolygonGroupArray& PolygonGroups() const { return static_cast<const TMeshElementContainer<FPolygonGroupID>&>(PolygonGroupElements->Get()); }
 
    TAttributesSet<FVertexID>& VertexAttributes() { return Vertices().GetAttributes(); }
    const TAttributesSet<FVertexID>& VertexAttributes() const { return Vertices().GetAttributes(); }
 
    TAttributesSet<FVertexInstanceID>& VertexInstanceAttributes() { return VertexInstances().GetAttributes(); }
    const TAttributesSet<FVertexInstanceID>& VertexInstanceAttributes() const { return VertexInstances().GetAttributes(); }
 
    TAttributesSet<FEdgeID>& EdgeAttributes() { return Edges().GetAttributes(); }
    const TAttributesSet<FEdgeID>& EdgeAttributes() const { return Edges().GetAttributes(); }
 
    TAttributesSet<FUVID>& UVAttributes(int32 Index) { return UVs(Index).GetAttributes(); }
    const TAttributesSet<FUVID>& UVAttributes(int32 Index) const { return UVs(Index).GetAttributes(); }
 
    TAttributesSet<FTriangleID>& TriangleAttributes() { return Triangles().GetAttributes(); }
    const TAttributesSet<FTriangleID>& TriangleAttributes() const { return Triangles().GetAttributes(); }
 
    TAttributesSet<FPolygonID>& PolygonAttributes() { return Polygons().GetAttributes(); }
    const TAttributesSet<FPolygonID>& PolygonAttributes() const { return Polygons().GetAttributes(); }
 
    TAttributesSet<FPolygonGroupID>& PolygonGroupAttributes() { return PolygonGroups().GetAttributes(); }
    const TAttributesSet<FPolygonGroupID>& PolygonGroupAttributes() const { return PolygonGroups().GetAttributes(); }
 
    TMap<FName, FMeshElementTypeWrapper>& GetElements() { return Elements; }
    const TMap<FName, FMeshElementTypeWrapper>& GetElements() const { return Elements; }
 
    void SuspendVertexIndexing() { VertexToVertexInstances.Suspend(); VertexToEdges.Suspend(); }
    void SuspendVertexInstanceIndexing() { VertexInstanceToTriangles.Suspend(); }
    void SuspendEdgeIndexing() { EdgeToTriangles.Suspend(); }
    void SuspendPolygonIndexing() { PolygonToTriangles.Suspend(); }
    void SuspendPolygonGroupIndexing() { PolygonGroupToPolygons.Suspend(); PolygonGroupToTriangles.Suspend(); }
    void SuspendUVIndexing() { UVToTriangles.Suspend(); }
 
    void ResumeVertexIndexing() { VertexToVertexInstances.Resume(); VertexToEdges.Resume(); }
    void ResumeVertexInstanceIndexing() { VertexInstanceToTriangles.Resume(); }
    void ResumeEdgeIndexing() { EdgeToTriangles.Resume(); }
    void ResumePolygonIndexing() { PolygonToTriangles.Resume(); }
    void ResumePolygonGroupIndexing() { PolygonGroupToPolygons.Resume(); PolygonGroupToTriangles.Resume(); }
    void ResumeUVIndexing() { UVToTriangles.Resume(); }
 
    void BuildVertexIndexers() { VertexToVertexInstances.Build(); VertexToEdges.Build(); }
    void BuildVertexInstanceIndexers() { VertexInstanceToTriangles.Build(); }
    void BuildEdgeIndexers() { EdgeToTriangles.Build(); }
    void BuildPolygonIndexers() { PolygonToTriangles.Build(); }
    void BuildPolygonGroupIndexers() { PolygonGroupToPolygons.Build(), PolygonGroupToTriangles.Build(); }
 
// Create / remove mesh elements
 
    void ReserveNewVertices(const int32 NumVertices)
    {
        VertexElements->Get().Reserve(VertexElements->Get().Num() + NumVertices);
    }
 
    FVertexID CreateVertex()
    {
        const FVertexID VertexID = VertexElements->Get().Add();
        return VertexID;
    }
 
    void CreateVertexWithID(const FVertexID VertexID)
    {
        VertexElements->Get().Insert(VertexID);
    }
 
    void DeleteVertex(const FVertexID VertexID)
    {
        check(VertexToVertexInstances.Find(VertexID).Num() == 0);
        check(VertexToEdges.Find(VertexID).Num() == 0);
        VertexElements->Get().Remove(VertexID);
        VertexToVertexInstances.RemoveKey(VertexID);
        VertexToEdges.RemoveKey(VertexID);
    }
 
    bool IsVertexValid(const FVertexID VertexID) const
    {
        return VertexElements->Get().IsValid(VertexID);
    }
 
    void ReserveNewVertexInstances(const int32 NumVertexInstances)
    {
        VertexInstanceElements->Get().Reserve(VertexInstanceElements->Get().Num() + NumVertexInstances);
    }
 
    FVertexInstanceID CreateVertexInstance(const FVertexID VertexID)
    {
        const FVertexInstanceID VertexInstanceID = VertexInstanceElements->Get().Add();
        CreateVertexInstance_Internal(VertexInstanceID, VertexID);
        return VertexInstanceID;
    }
 
    void CreateVertexInstanceWithID(const FVertexInstanceID VertexInstanceID, const FVertexID VertexID)
    {
        VertexInstanceElements->Get().Insert(VertexInstanceID);
        CreateVertexInstance_Internal(VertexInstanceID, VertexID);
    }
 
    MESHDESCRIPTION_API void DeleteVertexInstance(const FVertexInstanceID VertexInstanceID, TArray<FVertexID>* InOutOrphanedVerticesPtr = nullptr);
    
    bool IsVertexInstanceValid(const FVertexInstanceID VertexInstanceID) const
    {
        return VertexInstanceElements->Get().IsValid(VertexInstanceID);
    }
 
    void ReserveNewUVs(const int32 NumUVs, const int32 UVChannel = 0)
    {
        UVElements->Get(UVChannel).Reserve(UVElements->Get(UVChannel).Num() + NumUVs);
    }
 
    FUVID CreateUV(const int32 UVChannel = 0)
    {
        const FUVID UVID = UVElements->Get(UVChannel).Add();
        return UVID;
    }
 
    void CreateUVWithID(const FUVID UVID, const int32 UVChannel = 0)
    {
        UVElements->Get(UVChannel).Insert(UVID);
    }
 
    void DeleteUV(const FUVID UVID, const int32 UVChannel = 0)
    {
        check(UVToTriangles.Find(UVID).Num() == 0);
        UVElements->Get(UVChannel).Remove(UVID);
        UVToTriangles.RemoveKey(UVID);
    }
 
    bool IsUVValid(const FUVID UVID, const int32 UVChannel = 0) const
    {
        return UVElements->Get(UVChannel).IsValid(UVID);
    }
 
    void ReserveNewEdges(const int32 NumEdges)
    {
        EdgeElements->Get().Reserve(EdgeElements->Get().Num() + NumEdges);
    }
 
    FEdgeID CreateEdge(const FVertexID VertexID0, const FVertexID VertexID1)
    {
        const FEdgeID EdgeID = EdgeElements->Get().Add();
        CreateEdge_Internal(EdgeID, VertexID0, VertexID1);
        return EdgeID;
    }
 
    void CreateEdgeWithID(const FEdgeID EdgeID, const FVertexID VertexID0, const FVertexID VertexID1)
    {
        EdgeElements->Get().Insert(EdgeID);
        CreateEdge_Internal(EdgeID, VertexID0, VertexID1);
    }
 
    MESHDESCRIPTION_API void DeleteEdge(const FEdgeID EdgeID, TArray<FVertexID>* InOutOrphanedVerticesPtr = nullptr);
 
    bool IsEdgeValid(const FEdgeID EdgeID) const
    {
        return EdgeElements->Get().IsValid(EdgeID);
    }
 
    void ReserveNewTriangles(const int32 NumTriangles)
    {
        TriangleElements->Get().Reserve(TriangleElements->Get().Num() + NumTriangles);
    }
 
    FTriangleID CreateTriangle(const FPolygonGroupID PolygonGroupID, TArrayView<const FVertexInstanceID> VertexInstanceIDs, TArray<FEdgeID>* OutEdgeIDs = nullptr)
    {
        const FTriangleID TriangleID = TriangleElements->Get().Add();
        CreateTriangle_Internal(TriangleID, PolygonGroupID, VertexInstanceIDs, OutEdgeIDs);
        return TriangleID;
    }
 
    void CreateTriangleWithID(const FTriangleID TriangleID, const FPolygonGroupID PolygonGroupID, TArrayView<const FVertexInstanceID> VertexInstanceIDs, TArray<FEdgeID>* OutEdgeIDs = nullptr)
    {
        TriangleElements->Get().Insert(TriangleID);
        CreateTriangle_Internal(TriangleID, PolygonGroupID, VertexInstanceIDs, OutEdgeIDs);
    }
 
    MESHDESCRIPTION_API void DeleteTriangle(const FTriangleID TriangleID, TArray<FEdgeID>* InOutOrphanedEdgesPtr = nullptr, TArray<FVertexInstanceID>* InOutOrphanedVertexInstancesPtr = nullptr, TArray<FPolygonGroupID>* InOutOrphanedPolygonGroupsPtr = nullptr);
 
    MESHDESCRIPTION_API void DeleteTriangles(const TArray<FTriangleID>& Triangles);
 
    bool IsTriangleValid(const FTriangleID TriangleID) const
    {
        return TriangleElements->Get().IsValid(TriangleID);
    }
 
    void ReserveNewPolygons(const int32 NumPolygons)
    {
        PolygonElements->Get().Reserve(PolygonElements->Get().Num() + NumPolygons);
    }
 
    FPolygonID CreatePolygon(const FPolygonGroupID PolygonGroupID, TArrayView<const FVertexInstanceID> VertexInstanceIDs, TArray<FEdgeID>* OutEdgeIDs = nullptr)
    {
        const FPolygonID PolygonID = PolygonElements->Get().Add();
        CreatePolygon_Internal(PolygonID, PolygonGroupID, VertexInstanceIDs, OutEdgeIDs);
        return PolygonID;
    }
 
    void CreatePolygonWithID(const FPolygonID PolygonID, const FPolygonGroupID PolygonGroupID, TArrayView<const FVertexInstanceID> VertexInstanceIDs, TArray<FEdgeID>* OutEdgeIDs = nullptr)
    {
        PolygonElements->Get().Insert(PolygonID);
        CreatePolygon_Internal(PolygonID, PolygonGroupID, VertexInstanceIDs, OutEdgeIDs);
    }
 
    MESHDESCRIPTION_API void DeletePolygon(const FPolygonID PolygonID, TArray<FEdgeID>* InOutOrphanedEdgesPtr = nullptr, TArray<FVertexInstanceID>* InOutOrphanedVertexInstancesPtr = nullptr, TArray<FPolygonGroupID>* InOutOrphanedPolygonGroupsPtr = nullptr);
 
    MESHDESCRIPTION_API void DeletePolygons(const TArray<FPolygonID>& Polygons);
 
    bool IsPolygonValid(const FPolygonID PolygonID) const
    {
        return PolygonElements->Get().IsValid(PolygonID);
    }
 
    void ReserveNewPolygonGroups(const int32 NumPolygonGroups)
    {
        PolygonGroupElements->Get().Reserve(PolygonGroupElements->Get().Num() + NumPolygonGroups);
    }
 
    FPolygonGroupID CreatePolygonGroup()
    {
        const FPolygonGroupID PolygonGroupID = PolygonGroupElements->Get().Add();
        return PolygonGroupID;
    }
 
    void CreatePolygonGroupWithID(const FPolygonGroupID PolygonGroupID)
    {
        PolygonGroupElements->Get().Insert(PolygonGroupID);
    }
 
    void DeletePolygonGroup(const FPolygonGroupID PolygonGroupID)
    {
        check(PolygonGroupToPolygons.Find(PolygonGroupID).Num() == 0);
        PolygonGroupElements->Get().Remove(PolygonGroupID);
        PolygonGroupToPolygons.RemoveKey(PolygonGroupID);
        PolygonGroupToTriangles.RemoveKey(PolygonGroupID);
    }
 
    bool IsPolygonGroupValid(const FPolygonGroupID PolygonGroupID) const
    {
        return PolygonGroupElements->Get().IsValid(PolygonGroupID);
    }
 
 
// MeshDescription general functions
 
public:
 
    // Vertex operations
 
    MESHDESCRIPTION_API bool IsVertexOrphaned(const FVertexID VertexID) const;
 
    MESHDESCRIPTION_API FEdgeID GetVertexPairEdge(const FVertexID VertexID0, const FVertexID VertexID1) const;
 
    TArrayView<const FEdgeID> GetVertexConnectedEdgeIDs(const FVertexID VertexID) const
    {
        return VertexToEdges.Find<FEdgeID>(VertexID);
    }
 
    UE_DEPRECATED(4.26, "Please use GetVertexConnectedEdgeIDs instead.")
    TArray<FEdgeID> GetVertexConnectedEdges(const FVertexID VertexID) const
    {
        return TArray<FEdgeID>(GetVertexConnectedEdgeIDs(VertexID));
    }
 
    int32 GetNumVertexConnectedEdges(const FVertexID VertexID) const
    {
        return VertexToEdges.Find(VertexID).Num();
    }
 
    TArrayView<const FVertexInstanceID> GetVertexVertexInstanceIDs(const FVertexID VertexID) const
    {
        return VertexToVertexInstances.Find<FVertexInstanceID>(VertexID);
    }
 
    UE_DEPRECATED(4.26, "Please use GetVertexVertexInstanceIDs instead.")
    TArray<FVertexInstanceID> GetVertexVertexInstances(const FVertexID VertexID) const
    {
        return TArray<FVertexInstanceID>(GetVertexVertexInstanceIDs(VertexID));
    }
 
    int32 GetNumVertexVertexInstances(const FVertexID VertexID) const
    {
        return VertexToVertexInstances.Find(VertexID).Num();
    }
 
    template <typename Alloc>
    void GetVertexConnectedTriangles(const FVertexID VertexID, TArray<FTriangleID, Alloc>& OutConnectedTriangleIDs) const
    {
        OutConnectedTriangleIDs.Reset(GetNumVertexConnectedTriangles(VertexID));
        for (const FVertexInstanceID& VertexInstanceID : VertexToVertexInstances.Find<FVertexInstanceID>(VertexID))
        {
            TArrayView<const FTriangleID> ConnectedTris = VertexInstanceToTriangles.Find<FTriangleID>(VertexInstanceID);
            OutConnectedTriangleIDs.Append(ConnectedTris.GetData(), ConnectedTris.Num());
        }
    }
 
    template <typename Alloc>
    TArray<FTriangleID, Alloc> GetVertexConnectedTriangles(const FVertexID VertexID) const
    {
        TArray<FTriangleID, Alloc> Result;
        this->GetVertexConnectedTriangles(VertexID, Result);
        return Result;
    }
 
    TArray<FTriangleID> GetVertexConnectedTriangles(const FVertexID VertexID) const
    {
        TArray<FTriangleID> Result;
        this->GetVertexConnectedTriangles(VertexID, Result);
        return Result;
    }
 
    int32 GetNumVertexConnectedTriangles(const FVertexID VertexID) const
    {
        TArrayView<const FVertexInstanceID> VertexInstances = VertexToVertexInstances.Find<FVertexInstanceID>(VertexID);
        return Algo::TransformAccumulate(VertexInstances,
                                         [this](const FVertexInstanceID ID) { return VertexInstanceToTriangles.Find(ID).Num(); },
                                         0);
    }
 
    template <typename Alloc>
    void GetVertexConnectedPolygons(const FVertexID VertexID, TArray<FPolygonID, Alloc>& OutConnectedPolygonIDs) const
    {
        OutConnectedPolygonIDs.Reset();
        for (const FVertexInstanceID& VertexInstanceID : VertexToVertexInstances.Find<FVertexInstanceID>(VertexID))
        {
            for (const FTriangleID& TriangleID : VertexInstanceToTriangles.Find<FTriangleID>(VertexInstanceID))
            {
                OutConnectedPolygonIDs.AddUnique(TrianglePolygons[TriangleID]);
            }
        }
    }
 
    template <typename Alloc>
    TArray<FPolygonID, Alloc> GetVertexConnectedPolygons(const FVertexID VertexID) const
    {
        TArray<FPolygonID, Alloc> Result;
        this->GetVertexConnectedPolygons(VertexID, Result);
        return Result;
    }
 
    TArray<FPolygonID> GetVertexConnectedPolygons(const FVertexID VertexID) const
    {
        TArray<FPolygonID> Result;
        this->GetVertexConnectedPolygons(VertexID, Result);
        return Result;
    }
 
    int32 GetNumVertexConnectedPolygons(const FVertexID VertexID) const
    {
        return GetVertexConnectedPolygons<TInlineAllocator<8>>(VertexID).Num();
    }
 
    template <typename Alloc>
    void GetVertexAdjacentVertices(const FVertexID VertexID, TArray<FVertexID, Alloc>& OutAdjacentVertexIDs) const
    {
        TArrayView<const FEdgeID> ConnectedEdgeIDs = VertexToEdges.Find<FEdgeID>(VertexID);
        OutAdjacentVertexIDs.SetNumUninitialized(ConnectedEdgeIDs.Num());
 
        int32 Index = 0;
        for (const FEdgeID& EdgeID : ConnectedEdgeIDs)
        {
            TArrayView<const FVertexID> EdgeVertexIDs = EdgeVertices[EdgeID];
            OutAdjacentVertexIDs[Index] = (EdgeVertexIDs[0] == VertexID) ? EdgeVertexIDs[1] : EdgeVertexIDs[0];
            Index++;
        }
    }
 
    template <typename Alloc>
    TArray<FVertexID, Alloc> GetVertexAdjacentVertices(const FVertexID VertexID) const
    {
        TArray<FVertexID, Alloc> Result;
        this->GetVertexAdjacentVertices(VertexID, Result);
        return Result;
    }
 
    TArray<FVertexID> GetVertexAdjacentVertices(const FVertexID VertexID) const
    {
        TArray<FVertexID> Result;
        this->GetVertexAdjacentVertices(VertexID, Result);
        return Result;
    }
 
    FVector3f GetVertexPosition(const FVertexID VertexID) const
    {
        return VertexPositions[VertexID];
    }
 
    TVertexAttributesRef<FVector3f> GetVertexPositions()
    {
        return VertexPositions;
    }
 
    TVertexAttributesRef<const FVector3f> GetVertexPositions() const
    {
        return VertexPositions;
    }
 
    // Vertex instance operations
 
    FVertexID GetVertexInstanceVertex(const FVertexInstanceID VertexInstanceID) const
    {
        return VertexInstanceVertices[VertexInstanceID];
    }
 
    MESHDESCRIPTION_API FEdgeID GetVertexInstancePairEdge(const FVertexInstanceID VertexInstanceID0, const FVertexInstanceID VertexInstanceID1) const;
 
    TArrayView<const FTriangleID> GetVertexInstanceConnectedTriangleIDs(const FVertexInstanceID VertexInstanceID) const
    {
        return VertexInstanceToTriangles.Find<FTriangleID>(VertexInstanceID);
    }
 
    UE_DEPRECATED(4.26, "Please use GetVertexInstanceTriangleIDs() instead.")
    TArray<FTriangleID> GetVertexInstanceConnectedTriangles(const FVertexInstanceID VertexInstanceID) const
    {
        return TArray<FTriangleID>(GetVertexInstanceConnectedTriangleIDs(VertexInstanceID));
    }
 
    int32 GetNumVertexInstanceConnectedTriangles(const FVertexInstanceID VertexInstanceID) const
    {
        return VertexInstanceToTriangles.Find(VertexInstanceID).Num();
    }
 
    template <typename Alloc>
    void GetVertexInstanceConnectedPolygons(const FVertexInstanceID VertexInstanceID, TArray<FPolygonID, Alloc>& OutPolygonIDs) const
    {
        OutPolygonIDs.Reset(VertexInstanceToTriangles.Find(VertexInstanceID).Num());
        for (const FTriangleID& TriangleID : VertexInstanceToTriangles.Find<FTriangleID>(VertexInstanceID))
        {
            OutPolygonIDs.AddUnique(TrianglePolygons[TriangleID]);
        }
    }
 
    template <typename Alloc>
    TArray<FPolygonID, Alloc> GetVertexInstanceConnectedPolygons(const FVertexInstanceID VertexInstanceID) const
    {
        TArray<FPolygonID, Alloc> Result;
        this->GetVertexInstanceConnectedPolygons(VertexInstanceID, Result);
        return Result;
    }
 
    TArray<FPolygonID> GetVertexInstanceConnectedPolygons(const FVertexInstanceID VertexInstanceID) const
    {
        TArray<FPolygonID> Result;
        this->GetVertexInstanceConnectedPolygons(VertexInstanceID, Result);
        return Result;
    }
 
    int32 GetNumVertexInstanceConnectedPolygons(const FVertexInstanceID VertexInstanceID) const
    {
        return GetVertexInstanceConnectedPolygons<TInlineAllocator<8>>(VertexInstanceID).Num();
    }
 
 
    // Edge operations
 
    bool IsEdgeInternal(const FEdgeID EdgeID) const
    {
        TArrayView<const FTriangleID> ConnectedTriangles = EdgeToTriangles.Find<FTriangleID>(EdgeID);
        return ConnectedTriangles.Num() == 2 &&
               TrianglePolygons[ConnectedTriangles[0]] == TrianglePolygons[ConnectedTriangles[1]];
    }
 
    bool IsEdgeInternalToPolygon(const FEdgeID EdgeID, const FPolygonID PolygonID) const
    {
        TArrayView<const FTriangleID> ConnectedTriangles = EdgeToTriangles.Find<FTriangleID>(EdgeID);
        return ConnectedTriangles.Num() == 2 &&
               TrianglePolygons[ConnectedTriangles[0]] == PolygonID &&
               TrianglePolygons[ConnectedTriangles[1]] == PolygonID;
    }
 
    TArrayView<const FTriangleID> GetEdgeConnectedTriangleIDs(const FEdgeID EdgeID) const
    {
        return EdgeToTriangles.Find<FTriangleID>(EdgeID);
    }
 
    UE_DEPRECATED(4.26, "Please use GetEdgeConnectedTriangleIDs() instead.")
    TArray<FTriangleID> GetEdgeConnectedTriangles(const FEdgeID EdgeID) const
    {
        return TArray<FTriangleID>(GetEdgeConnectedTriangleIDs(EdgeID));
    }
 
    int32 GetNumEdgeConnectedTriangles(const FEdgeID EdgeID) const
    {
        return EdgeToTriangles.Find(EdgeID).Num();
    }
 
    template <typename Alloc>
    void GetEdgeConnectedPolygons(const FEdgeID EdgeID, TArray<FPolygonID, Alloc>& OutPolygonIDs) const
    {
        OutPolygonIDs.Reset(EdgeToTriangles.Find(EdgeID).Num());
        for (const FTriangleID& TriangleID : EdgeToTriangles.Find<FTriangleID>(EdgeID))
        {
            OutPolygonIDs.AddUnique(TrianglePolygons[TriangleID]);
        }
    }
 
    template <typename Alloc>
    TArray<FPolygonID, Alloc> GetEdgeConnectedPolygons(const FEdgeID EdgeID) const
    {
        TArray<FPolygonID, Alloc> Result;
        this->GetEdgeConnectedPolygons(EdgeID, Result);
        return Result;
    }
 
    TArray<FPolygonID> GetEdgeConnectedPolygons(const FEdgeID EdgeID) const
    {
        TArray<FPolygonID> Result;
        this->GetEdgeConnectedPolygons(EdgeID, Result);
        return Result;
    }
 
    int32 GetNumEdgeConnectedPolygons(const FEdgeID EdgeID) const
    {
        return GetEdgeConnectedPolygons<TInlineAllocator<8>>(EdgeID).Num();
    }
 
    FVertexID GetEdgeVertex(const FEdgeID EdgeID, int32 VertexNumber) const
    {
        check(VertexNumber == 0 || VertexNumber == 1);
        TArrayView<const FVertexID> EdgeVertexIDs = EdgeVertices[EdgeID];
        return EdgeVertexIDs[VertexNumber];
    }
 
    TArrayView<const FVertexID> GetEdgeVertices(const FEdgeID EdgeID) const
    {
        return EdgeVertices[EdgeID];
    }
 
 
    // Triangle operations
 
    FPolygonID GetTrianglePolygon(const FTriangleID TriangleID) const
    {
        return TrianglePolygons[TriangleID];
    }
 
    FPolygonGroupID GetTrianglePolygonGroup(const FTriangleID TriangleID) const
    {
        return TrianglePolygonGroups[TriangleID];
    }
 
    bool IsTrianglePartOfNgon(const FTriangleID TriangleID) const
    {
        return PolygonToTriangles.Find(TrianglePolygons[TriangleID]).Num() > 1;
    }
 
    TArrayView<const FVertexInstanceID> GetTriangleVertexInstances(const FTriangleID TriangleID) const
    {
        return TriangleVertexInstances[TriangleID];
    }
 
    FVertexInstanceID GetTriangleVertexInstance(const FTriangleID TriangleID, const int32 Index) const
    {
        check(Index >= 0 && Index < 3);
        TArrayView<const FVertexInstanceID> TriVertexInstanceIDs = TriangleVertexInstances[TriangleID];
        return TriVertexInstanceIDs[Index];
    }
 
    UE_DEPRECATED(4.26, "Use the other form of GetTriangleVertices")
    void GetTriangleVertices(const FTriangleID TriangleID, TArrayView<FVertexID> OutVertexIDs) const
    {
        check(OutVertexIDs.Num() >= 3);
        TArrayView<const FVertexID> TriVerts = TriangleVertices[TriangleID];
        for (int32 Index = 0; Index < 3; ++Index)
        {
            OutVertexIDs[Index] = TriVerts[Index];
        }
    }
 
    TArrayView<const FVertexID> GetTriangleVertices(const FTriangleID TriangleID) const
    {
        return TriangleVertices[TriangleID];
    }
 
    UE_DEPRECATED(4.26, "Use the other form of GetTriangleEdges")
    void GetTriangleEdges(const FTriangleID TriangleID, TArrayView<FEdgeID> OutEdgeIDs) const
    {
        check(OutEdgeIDs.Num() >= 3);
        TArrayView<const FEdgeID> TriEdges = TriangleEdges[TriangleID];
        for (int32 Index = 0; Index < 3; ++Index)
        {
            OutEdgeIDs[Index] = TriEdges[Index];
        }
    }
 
    TArrayView<FEdgeID> GetTriangleEdges(const FTriangleID TriangleID) const
    {
        return TriangleEdges[TriangleID];
    }
 
    template <typename Alloc>
    void GetTriangleAdjacentTriangles(const FTriangleID TriangleID, TArray<FTriangleID, Alloc>& OutTriangleIDs) const
    {
        OutTriangleIDs.Reset();
        for (const FEdgeID& EdgeID : GetTriangleEdges(TriangleID))
        {
            for (const int32& TriangleIndex : EdgeToTriangles.Find(EdgeID))
            {
                FTriangleID OtherTriangleID(TriangleIndex);
                if (OtherTriangleID != TriangleID)
                {
                    OutTriangleIDs.Add(OtherTriangleID);
                }
            }
        }
    }
 
    template <typename Alloc>
    TArray<FTriangleID, Alloc> GetTriangleAdjacentTriangles(const FTriangleID TriangleID) const
    {
        TArray<FTriangleID, Alloc> Result;
        this->GetTriangleAdjacentTriangles(TriangleID, Result);
        return Result;
    }
 
    TArray<FTriangleID> GetTriangleAdjacentTriangles(const FTriangleID TriangleID) const
    {
        TArray<FTriangleID> Result;
        this->GetTriangleAdjacentTriangles(TriangleID, Result);
        return Result;
    }
 
    TArrayView<FUVID> GetTriangleUVIndices(const FTriangleID TriangleID, int32 UVChannel = 0) const
    {
        return TriangleUVs.Get(TriangleID, UVChannel);
    }
 
    FVertexInstanceID GetVertexInstanceForTriangleVertex(const FTriangleID TriangleID, const FVertexID VertexID) const
    {
        const FVertexInstanceID* VertexInstanceIDPtr = Algo::FindByPredicate(
            GetTriangleVertexInstances(TriangleID),
            [this, VertexID](const FVertexInstanceID VertexInstanceID) { return (GetVertexInstanceVertex(VertexInstanceID) == VertexID); });
 
        return VertexInstanceIDPtr ? *VertexInstanceIDPtr : FVertexInstanceID(INDEX_NONE);
    }
 
    MESHDESCRIPTION_API void ReverseTriangleFacing(const FTriangleID TriangleID);
 
    MESHDESCRIPTION_API void SetTriangleUVIndices(const FTriangleID TriangleID, TArrayView<const FUVID> UVIDs, int32 UVChannel = 0);
 
    // Polygon operations
 
    TArrayView<const FTriangleID> GetPolygonTriangles(const FPolygonID PolygonID) const
    {
        return PolygonToTriangles.Find<FTriangleID>(PolygonID);
    }
 
    UE_DEPRECATED(4.26, "Please use GetPolygonTriangles() instead.")
    TArray<FTriangleID> GetPolygonTriangleIDs(const FPolygonID PolygonID) const
    {
        return TArray<FTriangleID>(GetPolygonTriangles(PolygonID));
    }
 
    int32 GetNumPolygonTriangles(const FPolygonID PolygonID) const
    {
        return PolygonToTriangles.Find(PolygonID).Num();
    }
 
    template <typename Alloc>
    void GetPolygonVertexInstances(const FPolygonID PolygonID, TArray<FVertexInstanceID, Alloc>& OutVertexInstanceIDs) const
    {
        OutVertexInstanceIDs.SetNumUninitialized(GetNumPolygonVertices(PolygonID));
        TArrayView<const FTriangleID> Tris = PolygonToTriangles.Find<FTriangleID>(PolygonID);
        if (Tris.Num() == 1)
        {
            OutVertexInstanceIDs = TriangleVertexInstances[Tris[0]];
        }
        else
        {
            TArray<TTuple<int32, int32>, TInlineAllocator<8>> Result;
            Result.SetNumUninitialized(Tris.Num() + 2);
            FindPolygonPerimeter(Tris, Result);
            for (int32 Index = 0; Index < Result.Num(); Index++)
            {
                FTriangleID TriangleID = Tris[Result[Index].Get<0>()];
                int32 VertexInstanceNumber = Result[Index].Get<1>();
                OutVertexInstanceIDs[Index] = TriangleVertexInstances[TriangleID][VertexInstanceNumber];
            }
        }
    }
 
    template <typename Alloc>
    TArray<FVertexInstanceID, Alloc> GetPolygonVertexInstances(const FPolygonID PolygonID) const
    {
        TArray<FVertexInstanceID, Alloc> Result;
        this->GetPolygonVertexInstances(PolygonID, Result);
        return Result;
    }
 
    TArray<FVertexInstanceID> GetPolygonVertexInstances(const FPolygonID PolygonID) const
    {
        TArray<FVertexInstanceID> Result;
        this->GetPolygonVertexInstances(PolygonID, Result);
        return Result;
    }
 
    int32 GetNumPolygonVertices(const FPolygonID PolygonID) const
    {
        TArrayView<const FTriangleID> Tris = PolygonToTriangles.Find<FTriangleID>(PolygonID);
        return Tris.Num() + 2;
    }
 
    template <typename Alloc>
    void GetPolygonVertices(const FPolygonID PolygonID, TArray<FVertexID, Alloc>& OutVertexIDs) const
    {
        OutVertexIDs.SetNumUninitialized(GetNumPolygonVertices(PolygonID));
        TArrayView<const FTriangleID> Tris = PolygonToTriangles.Find<FTriangleID>(PolygonID);
        if (Tris.Num() == 1)
        {
            OutVertexIDs = TriangleVertices[Tris[0]];
        }
        else
        {
            TArray<TTuple<int32, int32>, TInlineAllocator<8>> Result;
            Result.SetNumUninitialized(Tris.Num() + 2);
            FindPolygonPerimeter(Tris, Result);
            for (int32 Index = 0; Index < Result.Num(); Index++)
            {
                FTriangleID TriangleID = Tris[Result[Index].Get<0>()];
                int32 VertexNumber = Result[Index].Get<1>();
                OutVertexIDs[Index] = TriangleVertices[TriangleID][VertexNumber];
            }
        }
    }
 
    template <typename Alloc>
    TArray<FVertexID, Alloc> GetPolygonVertices(const FPolygonID PolygonID) const
    {
        TArray<FVertexID, Alloc> Result;
        this->GetPolygonVertices(PolygonID, Result);
        return Result;
    }
 
    TArray<FVertexID> GetPolygonVertices(const FPolygonID PolygonID) const
    {
        TArray<FVertexID> Result;
        this->GetPolygonVertices(PolygonID, Result);
        return Result;
    }
 
    template <typename Alloc>
    void GetPolygonPerimeterEdges(const FPolygonID PolygonID, TArray<FEdgeID, Alloc>& OutEdgeIDs) const
    {
        OutEdgeIDs.SetNumUninitialized(GetNumPolygonVertices(PolygonID));
        TArrayView<const FTriangleID> Tris = PolygonToTriangles.Find<FTriangleID>(PolygonID);
        if (Tris.Num() == 1)
        {
            OutEdgeIDs = TriangleEdges[Tris[0]];
        }
        else
        {
            TArray<TTuple<int32, int32>, TInlineAllocator<8>> Result;
            Result.SetNumUninitialized(Tris.Num() + 2);
            FindPolygonPerimeter(Tris, Result);
            for (int32 Index = 0; Index < Result.Num(); Index++)
            {
                FTriangleID TriangleID = Tris[Result[Index].Get<0>()];
                int32 EdgeNumber = Result[Index].Get<1>();
                OutEdgeIDs[Index] = TriangleEdges[TriangleID][EdgeNumber];
            }
        }
    }
 
    template <typename Alloc>
    TArray<FEdgeID, Alloc> GetPolygonPerimeterEdges(const FPolygonID PolygonID) const
    {
        TArray<FEdgeID, Alloc> Result;
        this->GetPolygonPerimeterEdges(PolygonID, Result);
        return Result;
    }
 
    TArray<FEdgeID> GetPolygonPerimeterEdges(const FPolygonID PolygonID) const
    {
        TArray<FEdgeID> Result;
        this->GetPolygonPerimeterEdges(PolygonID, Result);
        return Result;
    }
 
    template <typename Alloc>
    void GetPolygonInternalEdges(const FPolygonID PolygonID, TArray<FEdgeID, Alloc>& OutEdgeIDs) const
    {
        OutEdgeIDs.Reset(GetNumPolygonVertices(PolygonID) - 3);
        if (GetNumPolygonVertices(PolygonID) > 3)
        {
            TArray<FVertexInstanceID> VertexInstanceIDs = GetPolygonVertexInstances(PolygonID);
            for (const FVertexInstanceID& VertexInstanceID : VertexInstanceIDs)
            {
                for (const FEdgeID& EdgeID : GetVertexConnectedEdgeIDs(GetVertexInstanceVertex(VertexInstanceID)))
                {
                    if (!OutEdgeIDs.Contains(EdgeID) && IsEdgeInternalToPolygon(EdgeID, PolygonID))
                    {
                        OutEdgeIDs.Add(EdgeID);
                    }
                }
            }
        }
    }
 
    template <typename Alloc>
    TArray<FEdgeID, Alloc> GetPolygonInternalEdges(const FPolygonID PolygonID) const
    {
        TArray<FEdgeID, Alloc> Result;
        this->GetPolygonInternalEdges(PolygonID, Result);
        return Result;
    }
 
    TArray<FEdgeID> GetPolygonInternalEdges(const FPolygonID PolygonID) const
    {
        TArray<FEdgeID> Result;
        this->GetPolygonInternalEdges(PolygonID, Result);
        return Result;
    }
 
    int32 GetNumPolygonInternalEdges(const FPolygonID PolygonID) const
    {
        return PolygonToTriangles.Find(PolygonID).Num() - 1;
    }
 
    template <typename Alloc>
    void GetPolygonAdjacentPolygons(const FPolygonID PolygonID, TArray<FPolygonID, Alloc>& OutPolygonIDs) const
    {
        OutPolygonIDs.Reset();
        for (const FEdgeID& EdgeID : GetPolygonPerimeterEdges<TInlineAllocator<16>>(PolygonID))
        {
            for (const FPolygonID& OtherPolygonID : GetEdgeConnectedPolygons<TInlineAllocator<8>>(EdgeID))
            {
                if (OtherPolygonID != PolygonID)
                {
                    OutPolygonIDs.Add(OtherPolygonID);
                }
            }
        }
    }
 
    template <typename Alloc>
    TArray<FPolygonID, Alloc> GetPolygonAdjacentPolygons(const FPolygonID PolygonID) const
    {
        TArray<FPolygonID, Alloc> Result;
        this->GetPolygonAdjacentPolygons(PolygonID, Result);
        return Result;
    }
 
    TArray<FPolygonID> GetPolygonAdjacentPolygons(const FPolygonID PolygonID) const
    {
        TArray<FPolygonID> Result;
        this->GetPolygonAdjacentPolygons(PolygonID, Result);
        return Result;
    }
 
    FPolygonGroupID GetPolygonPolygonGroup(const FPolygonID PolygonID) const
    {
        return PolygonPolygonGroups[PolygonID];
    }
 
    FVertexInstanceID GetVertexInstanceForPolygonVertex(const FPolygonID PolygonID, const FVertexID VertexID) const
    {
        TArray<FVertexInstanceID> VertexInstanceIDs = GetPolygonVertexInstances(PolygonID);
        const FVertexInstanceID* VertexInstanceIDPtr = VertexInstanceIDs.FindByPredicate(
            [this, VertexID](const FVertexInstanceID VertexInstanceID) { return (GetVertexInstanceVertex(VertexInstanceID) == VertexID); });
 
        return VertexInstanceIDPtr ? *VertexInstanceIDPtr : FVertexInstanceID(INDEX_NONE);
    }
 
    MESHDESCRIPTION_API void SetPolygonVertexInstance(const FPolygonID PolygonID, const int32 PerimeterIndex, const FVertexInstanceID VertexInstanceID);
    MESHDESCRIPTION_API void SetPolygonVertexInstances(const FPolygonID PolygonID, TArrayView<const FVertexInstanceID> VertexInstanceIDs);
 
    void SetPolygonPolygonGroup(const FPolygonID PolygonID, const FPolygonGroupID PolygonGroupID)
    {
        FPolygonGroupID OldPolygonGroupID = PolygonPolygonGroups[PolygonID];
        PolygonGroupToPolygons.RemoveReferenceFromKey(OldPolygonGroupID, PolygonID);
 
        PolygonPolygonGroups[PolygonID] = PolygonGroupID;
        PolygonGroupToPolygons.AddReferenceToKey(PolygonGroupID, PolygonID);
 
        for (const int32& TriangleIndex: PolygonToTriangles.Find(PolygonID))
        {
            const FTriangleID TriangleID(TriangleIndex);
            check(TrianglePolygonGroups[TriangleID] == OldPolygonGroupID);
            PolygonGroupToTriangles.RemoveReferenceFromKey(OldPolygonGroupID, TriangleID);
 
            TrianglePolygonGroups[TriangleID] = PolygonGroupID;
            PolygonGroupToTriangles.AddReferenceToKey(PolygonGroupID, TriangleID);
        }
    }
 
    MESHDESCRIPTION_API void ReversePolygonFacing(const FPolygonID PolygonID);
 
    MESHDESCRIPTION_API void FindPolygonPerimeter(TArrayView<const FTriangleID> Triangles, TArrayView<TTuple<int32, int32>> Result) const;
    MESHDESCRIPTION_API void FindPolygonPerimeter(const FPolygonID PolygonID, TArrayView<FEdgeID> Edges) const;
 
    MESHDESCRIPTION_API void ComputePolygonTriangulation(const FPolygonID PolygonID);
 
    MESHDESCRIPTION_API void SplitPolygon(FPolygonID PolygonID);
 
 
    // Polygon group operations
 
    TArrayView<const FPolygonID> GetPolygonGroupPolygonIDs(const FPolygonGroupID PolygonGroupID) const
    {
        return PolygonGroupToPolygons.Find<FPolygonID>(PolygonGroupID);
    }
 
    UE_DEPRECATED(4.26, "Please use GetPolygonGroupPolygonIDs() instead.")
    TArray<FPolygonID> GetPolygonGroupPolygons(const FPolygonGroupID PolygonGroupID) const
    {
        return TArray<FPolygonID>(GetPolygonGroupPolygonIDs(PolygonGroupID));
    }
 
    TArrayView<const FTriangleID> GetPolygonGroupTriangles(const FPolygonGroupID PolygonGroupID) const
    {
        return PolygonGroupToTriangles.Find<FTriangleID>(PolygonGroupID);
    }
 
    int32 GetNumPolygonGroupPolygons(const FPolygonGroupID PolygonGroupID) const
    {
        return PolygonGroupToPolygons.Find(PolygonGroupID).Num();
    }
 
    int32 GetNumPolygonGroupTriangles(const FPolygonGroupID PolygonGroupID) const
    {
        return PolygonGroupToTriangles.Find(PolygonGroupID).Num();
    }
 
    MESHDESCRIPTION_API void RemapPolygonGroups(const TMap<FPolygonGroupID, FPolygonGroupID>& Remap);
    
    MESHDESCRIPTION_API void TransferPolygonGroup(FPolygonGroupID SourceID, FPolygonGroupID DestinationID);
 
    // Whole mesh operations
 
    MESHDESCRIPTION_API bool NeedsCompact() const;
 
    MESHDESCRIPTION_API void Compact( FElementIDRemappings& OutRemappings );
 
    MESHDESCRIPTION_API void Remap( const FElementIDRemappings& Remappings );
 
    int32 GetNumUVElementChannels() const { return UVElements->GetNumChannels(); }
 
    MESHDESCRIPTION_API void SetNumUVChannels(const int32 NumUVChannels);
 
    MESHDESCRIPTION_API FBoxSphereBounds GetBounds() const;
 
    MESHDESCRIPTION_API void TriangulateMesh();
 
    MESHDESCRIPTION_API void ReverseAllPolygonFacing();
 
    MESHDESCRIPTION_API float GetTriangleCornerAngleForVertex(const FTriangleID TriangleID, const FVertexID VertexID) const;
    MESHDESCRIPTION_API float GetPolygonCornerAngleForVertex(const FPolygonID PolygonID, const FVertexID VertexID) const;
 
    MESHDESCRIPTION_API FBox ComputeBoundingBox() const;
 
private:
 
    MESHDESCRIPTION_API FPlane ComputePolygonPlane(TArrayView<const FVertexInstanceID> PerimeterVertexInstanceIDs) const;
    MESHDESCRIPTION_API FVector ComputePolygonNormal(TArrayView<const FVertexInstanceID> PerimeterVertexInstanceIDs) const;
 
private:
 
    MESHDESCRIPTION_API void Initialize();
    MESHDESCRIPTION_API void InitializeIndexers();
    MESHDESCRIPTION_API void Cache();
 
    MESHDESCRIPTION_API void CreateVertexInstance_Internal(const FVertexInstanceID VertexInstanceID, const FVertexID VertexID);
    MESHDESCRIPTION_API void CreateEdge_Internal(const FEdgeID EdgeID, const FVertexID VertexID0, const FVertexID VertexID1);
    MESHDESCRIPTION_API void CreateTriangle_Internal(const FTriangleID TriangleID, const FPolygonGroupID PolygonGroupID, TArrayView<const FVertexInstanceID> VertexInstanceIDs, TArray<FEdgeID>* OutEdgeIDs);
    MESHDESCRIPTION_API void CreatePolygon_Internal(const FPolygonID PolygonID, const FPolygonGroupID PolygonGroupID, TArrayView<const FVertexInstanceID> VertexInstanceIDs, TArray<FEdgeID>* OutEdgeIDs);
    MESHDESCRIPTION_API void CreatePolygonTriangles(const FPolygonID PolygonID, TArrayView<const FVertexInstanceID> VertexInstanceIDs);
    MESHDESCRIPTION_API void RemovePolygonTriangles(const FPolygonID PolygonID);
 
    template <template <typename...> class TContainer>
    void DeleteVertexInstance_Internal(const FVertexInstanceID VertexInstanceID, TContainer<FVertexID>* InOutOrphanedVerticesPtr = nullptr);
    template <template <typename...> class TContainer>
    void DeleteEdge_Internal(const FEdgeID EdgeID, TContainer<FVertexID>* InOutOrphanedVerticesPtr = nullptr);
    template <template <typename...> class TContainer>
    void DeleteTriangle_Internal(const FTriangleID TriangleID, TContainer<FEdgeID>* InOutOrphanedEdgesPtr = nullptr, TContainer<FVertexInstanceID>* InOutOrphanedVertexInstancesPtr = nullptr, TContainer<FPolygonGroupID>* InOutOrphanedPolygonGroupsPtr = nullptr);
    template <template <typename...> class TContainer>
    void DeletePolygon_Internal(const FPolygonID PolygonID, TContainer<FEdgeID>* InOutOrphanedEdgesPtr = nullptr, TContainer<FVertexInstanceID>* InOutOrphanedVertexInstancesPtr = nullptr, TContainer<FPolygonGroupID>* InOutOrphanedPolygonGroupsPtr = nullptr);
 
    MESHDESCRIPTION_API void FixUpElementIDs(const FElementIDRemappings& Remappings);
 
    template <class T>
    void AddUnique(TArray<T>& Container, const T& Item)
    {
        Container.AddUnique(Item);
    }
 
    template <class T>
    void AddUnique(TSet<T>& Container, const T& Item)
    {
        Container.Add(Item);
    }
 
public:
    static MESHDESCRIPTION_API FName VerticesName;
    static MESHDESCRIPTION_API FName VertexInstancesName;
    static MESHDESCRIPTION_API FName UVsName;
    static MESHDESCRIPTION_API FName EdgesName;
    static MESHDESCRIPTION_API FName TrianglesName;
    static MESHDESCRIPTION_API FName PolygonsName;
    static MESHDESCRIPTION_API FName PolygonGroupsName;
 
private:
    TMap<FName, FMeshElementTypeWrapper> Elements;
 
    FMeshElementChannels* VertexElements;
    FMeshElementChannels* VertexInstanceElements;
    FMeshElementChannels* UVElements;
    FMeshElementChannels* EdgeElements;
    FMeshElementChannels* TriangleElements;
    FMeshElementChannels* PolygonElements;
    FMeshElementChannels* PolygonGroupElements;
 
    TMeshAttributesArray<FVertexID> VertexInstanceVertices;
    TMeshAttributesArray<TArrayView<FVertexID>> EdgeVertices;
    TMeshAttributesArray<TArrayView<FVertexInstanceID>> TriangleVertexInstances;
    TMeshAttributesArray<FPolygonID> TrianglePolygons;
    TMeshAttributesArray<TArrayView<FEdgeID>> TriangleEdges;
    TMeshAttributesArray<TArrayView<FVertexID>> TriangleVertices;
    TMeshAttributesArray<TArrayView<FUVID>> TriangleUVs;
    TMeshAttributesArray<FPolygonGroupID> TrianglePolygonGroups;
    TMeshAttributesArray<FPolygonGroupID> PolygonPolygonGroups;
    TMeshAttributesArray<FVector3f> VertexPositions;
 
    // The indexers are all mutable because they may be rebuilt during what is essentially a get operation
    mutable FMeshElementIndexer VertexToVertexInstances;
    mutable FMeshElementIndexer VertexToEdges;
    mutable FMeshElementIndexer VertexInstanceToTriangles;
    mutable FMeshElementIndexer EdgeToTriangles;
    mutable FMeshElementIndexer UVToTriangles;
    mutable FMeshElementIndexer PolygonToTriangles;
    mutable FMeshElementIndexer PolygonGroupToTriangles;
    mutable FMeshElementIndexer PolygonGroupToPolygons;
};
 
#if WITH_EDITORONLY_DATA
 
struct FMeshDescriptionBulkData
{
public:
    FMeshDescriptionBulkData()
        : bBulkDataUpdated(false)
        , bGuidIsHash(false)
    {
    }
 
    MESHDESCRIPTION_API void Serialize(FArchive& Ar, UObject* Owner);
 
    MESHDESCRIPTION_API void SaveMeshDescription(FMeshDescription& MeshDescription);
 
    MESHDESCRIPTION_API void LoadMeshDescription(FMeshDescription& MeshDescription);
 
    MESHDESCRIPTION_API void Empty();
 
    bool IsEmpty() const { return !BulkData.HasPayloadData(); }
 
    MESHDESCRIPTION_API FString GetIdString() const;
 
    MESHDESCRIPTION_API void UseHashAsGuid();
 
    int64 GetBulkDataSize() { return BulkData.GetPayloadSize(); }
 
    static MESHDESCRIPTION_API TConstArrayView<FGuid> GetMeshDescriptionCustomVersions();
 
private:
    MESHDESCRIPTION_API void UpdateMeshDescriptionFormat();
 
#if WITH_EDITOR
    FRWLock       BulkDataLock;
#endif
    UE::Serialization::FEditorBulkData BulkData;
 
    FGuid Guid;
 
    MESHDESCRIPTION_API FGuid GetHash() const;
 
    FCustomVersionContainer CustomVersions;
    FPackageFileVersion UEVersion;
    int32 LicenseeUEVersion;
 
 
    bool bBulkDataUpdated;
 
    bool bGuidIsHash;
};
#endif // WITH_EDITORONLY_DATA