DynamicMesh3.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Port of geometry3cpp DMesh3
 
#pragma once
 
#include "Async/TransactionallySafeMutex.h"
#include "BoxTypes.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/UnrealString.h"
#include "FrameTypes.h"
#include "GeometryTypes.h"
#include "HAL/Platform.h"
#include "IndexTypes.h"
#include "InfoTypes.h"
#include "Math/UnrealMathSSE.h"
#include "Math/Vector.h"
#include "Math/Vector2D.h"
#include "MathUtil.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Optional.h"
#include "Quaternion.h"
#include "Serialization/Archive.h"
#include "Templates/Function.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "Util/CompactMaps.h"
#include "Util/DynamicVector.h"
#include "Util/IndexUtil.h"
#include "Util/IteratorUtil.h"
#include "Util/RefCountVector.h"
#include "Util/SmallListSet.h"
#include "VectorTypes.h"
#include "VectorUtil.h"
 
#include <atomic>
#include <initializer_list>
 
namespace UE
{
namespace Geometry
{
 
class FCompactMaps;
class FDynamicMeshAttributeSet;
class FMeshShapeGenerator;
 
enum class EMeshComponents : uint8
{
    None          = 0,
    VertexNormals = 1,
    VertexColors  = 2,
    VertexUVs     = 4,
    FaceGroups    = 8,
    All           = 15
};
 
class FDynamicMesh3
{
 
// TODO:
//  - Many of the iterators depend on lambda functions, can we replace these with calls to
//    internal/static functions that do the same thing?
//  - CompactInPlace() does not compact VertexEdgeLists
 
public:
    using FEdgeFlipInfo     = DynamicMeshInfo::FEdgeFlipInfo;
    using FEdgeSplitInfo    = DynamicMeshInfo::FEdgeSplitInfo;
    using FEdgeCollapseInfo = DynamicMeshInfo::FEdgeCollapseInfo;
    using FMergeEdgesInfo   = DynamicMeshInfo::FMergeEdgesInfo;
    using FMergeVerticesInfo = DynamicMeshInfo::FMergeVerticesInfo;
    using FPokeTriangleInfo = DynamicMeshInfo::FPokeTriangleInfo;
    using FVertexSplitInfo  = DynamicMeshInfo::FVertexSplitInfo;
 
    // Inline-allocator array types optionally used for mesh queries, to reduce heap allocations
    using FLocalIntArray = TArray<int32, TInlineAllocator<8>>;
    using FLocalBoolArray = TArray<bool, TInlineAllocator<8>>;
 
    struct FEdge
    {
        FIndex2i Vert;
        FIndex2i Tri;
        friend bool operator!=(const FEdge& e0, const FEdge& e1)
        {
            return (e0.Vert != e1.Vert) || (e0.Tri != e1.Tri);
        }
 
        friend FArchive& operator<<(FArchive& Ar, FEdge& E)
        {
            E.Serialize(Ar);
            return Ar;
        }
 
        void Serialize(FArchive& Ar)
        {
            Ar << Vert;
            Ar << Tri;
        }
    };
    constexpr static int InvalidID = IndexConstants::InvalidID;
    constexpr static int NonManifoldID = -2;
    constexpr static int DuplicateTriangleID = -3;
 
    GEOMETRYCORE_API const static FVector3d InvalidVertex;
    constexpr static FIndex3i InvalidTriangle{InvalidID, InvalidID, InvalidID};
    constexpr static FIndex2i InvalidEdge{InvalidID, InvalidID};
 
protected:
    TDynamicVector<FVector3d> Vertices{};
    FRefCountVector VertexRefCounts{};
    TOptional<TDynamicVector<FVector3f>> VertexNormals{};
    TOptional<TDynamicVector<FVector3f>> VertexColors{};
    TOptional<TDynamicVector<FVector2f>> VertexUVs{};
    FSmallListSet VertexEdgeLists;
 
    TDynamicVector<FIndex3i> Triangles;
    FRefCountVector TriangleRefCounts;
    TDynamicVector<FIndex3i> TriangleEdges;
    TOptional<TDynamicVector<int>> TriangleGroups{};
    int GroupIDCounter = 0;
 
    TDynamicVector<FEdge> Edges;
    FRefCountVector EdgeRefCounts;
 
    TUniquePtr<FDynamicMeshAttributeSet> AttributeSet{};
 
protected:
    UE_DEPRECATED(5.7, "bEnableShapeChangeStamp is no longer used. Use SetShapeChangeStampEnabled and HasShapeChangeStampEnabled instead.") 
    bool bEnableShapeChangeStamp = false;
    
    UE_DEPRECATED(5.7, "ShapeChangeStamp is no longer used. Use GetShapeChangeStamp or UpdateChangeStamps instead.") 
    std::atomic<uint32> ShapeChangeStamp = 0;
    UE_DEPRECATED(5.7, "TopologyChangeStamp is no longer used. Use GetTopologyChangeStamp or UpdateChangeStamps instead.") 
    std::atomic<uint32> TopologyChangeStamp = 0;
 
private:
    struct FChangeStamp
    {
        explicit FChangeStamp(bool bInIsEnabled)
            : bIsEnabled(bInIsEnabled)
        {
        }
 
        UE_NONCOPYABLE(FChangeStamp);
 
        bool bIsEnabled = false;
 
        mutable FTransactionallySafeMutex Mutex;
 
        uint32 Value = 1;
 
        void IncrementIfEnabled()
        {
            if (bIsEnabled)
            {
                Mutex.Lock();
                ++Value;
                Mutex.Unlock();
            }
        }
 
        void Set(uint32 NewValue)
        {
            if (bIsEnabled)
            {
                Mutex.Lock();
                Value = NewValue;
                Mutex.Unlock();
            }
        }
 
        uint32 GetValue() const
        {
            uint32 Result = 1; 
 
            if (bIsEnabled)
            {
                Mutex.Lock();
                Result = Value;
                Mutex.Unlock();
            }
 
            return Result;
        }
    };
 
    // Shape change tracking can be problematic in multi-threaded contexts so they're disabled by default. 
    // In fact, it is not suggested that these be used at all. (See comment for SetShapeChangeStampEnabled.)
    FChangeStamp ChangeStampShape{/*bIsEnabled=*/ false};
 
    // Topological change tracking is enabled by default.
    FChangeStamp ChangeStampTopology{/*bIsEnabled=*/ true};
 
public:
    GEOMETRYCORE_API FDynamicMesh3();
 
    GEOMETRYCORE_API FDynamicMesh3(const FDynamicMesh3& CopyMesh);
    GEOMETRYCORE_API FDynamicMesh3(FDynamicMesh3&& MoveMesh);
 
    GEOMETRYCORE_API const FDynamicMesh3& operator=(const FDynamicMesh3& CopyMesh);
    GEOMETRYCORE_API const FDynamicMesh3& operator=(FDynamicMesh3&& MoveMesh);
 
    GEOMETRYCORE_API virtual ~FDynamicMesh3();
 
 
    GEOMETRYCORE_API explicit FDynamicMesh3(bool bWantNormals, bool bWantColors, bool bWantUVs, bool bWantTriGroups);
    GEOMETRYCORE_API explicit FDynamicMesh3(EMeshComponents flags);
 
    GEOMETRYCORE_API FDynamicMesh3(const FMeshShapeGenerator* Generator);
 
    GEOMETRYCORE_API void Copy(const FDynamicMesh3& CopyMesh, bool bNormals = true, bool bColors = true, bool bUVs = true,
              bool bAttributes = true);
 
    GEOMETRYCORE_API bool Copy(const FMeshShapeGenerator* Generator);
 
    // Tracks how IDs are offset and number of elements appended by a mesh append operation
    struct FAppendInfo
    {
        // Offsets for base mesh element IDs
        int32 VertexOffset = 0, TriangleOffset = 0, EdgeOffset = 0, GroupOffset = 0;
 
        // Offsets for normals/tangents overlay element; will remain zero if the corresponding 'normal layer' is not present
        int32 NormalOverlayOffsets[3]{ 0,0,0 };
 
        // The number appended of each element type -- including 'invalid' slots, i.e. the amount by which MaxID increased
        int32 NumVertex = 0, NumTriangle = 0, NumEdge = 0;
    };
 
    GEOMETRYCORE_API void AppendWithOffsets(const FDynamicMesh3& ToAppend, FAppendInfo* OutAppendInfo = nullptr);
 
    GEOMETRYCORE_API void CompactCopy(const FDynamicMesh3& CopyMesh, bool bNormals = true, bool bColors = true, bool bUVs = true,
                     bool bAttributes = true, FCompactMaps* CompactInfo = nullptr);
 
    GEOMETRYCORE_API void Clear();
 
    GEOMETRYCORE_API void EnableMatchingAttributes(const FDynamicMesh3& ToMatch, bool bClearExisting = true, bool bDiscardExtraAttributes = false);
 
    friend FArchive& operator<<(FArchive& Ar, FDynamicMesh3& Mesh)
    {
        Mesh.Serialize(Ar);
        return Ar;
    }
 
    GEOMETRYCORE_API void Serialize(FArchive& Ar);
 
public:
    int VertexCount() const
    {
        return (int)VertexRefCounts.GetCount();
    }
    int TriangleCount() const
    {
        return (int)TriangleRefCounts.GetCount();
    }
    int EdgeCount() const
    {
        return (int)EdgeRefCounts.GetCount();
    }
 
    int MaxVertexID() const
    {
        return (int)VertexRefCounts.GetMaxIndex();
    }
    int MaxTriangleID() const
    {
        return (int)TriangleRefCounts.GetMaxIndex();
    }
    int MaxEdgeID() const
    {
        return (int)EdgeRefCounts.GetMaxIndex();
    }
    int MaxGroupID() const
    {
        return GroupIDCounter;
    }
 
 
    bool HasVertexNormals() const
    {
        return VertexNormals.IsSet();
    }
    bool HasVertexColors() const
    {
        return VertexColors.IsSet();
    }
    bool HasVertexUVs() const
    {
        return VertexUVs.IsSet();
    }
    bool HasTriangleGroups() const
    {
        return TriangleGroups.IsSet();
    }
    bool HasAttributes() const
    {
        return AttributeSet.IsValid();
    }
 
    GEOMETRYCORE_API int GetComponentsFlags() const;
 
 
    inline bool IsVertex(int VertexID) const
    {
        return VertexRefCounts.IsValid(VertexID);
    }
    inline bool IsReferencedVertex(int VertexID) const
    {
        return VertexID >= 0 && VertexID < (int)VertexRefCounts.GetMaxIndex() &&
            VertexRefCounts.GetRefCount(VertexID) > 1;
    }
    inline bool IsTriangle(int TriangleID) const
    {
        return TriangleRefCounts.IsValid(TriangleID);
    }
    inline bool IsEdge(int EdgeID) const
    {
        return EdgeRefCounts.IsValid(EdgeID);
    }
 
 
 
 
    //
    // Change Tracking support
    // 
    // Note: May someday be removed (see comment for SetShapeChangeStampEnabled) 
    // 
public:
 
    void SetShapeChangeStampEnabled(bool bEnabled)
    {
        ChangeStampShape.bIsEnabled = bEnabled;
    }
 
    void SetTopologyChangeStampEnabled(bool bEnabled)
    {
        ChangeStampTopology.bIsEnabled = bEnabled;
    }
 
    bool HasShapeChangeStampEnabled() const
    {
        return ChangeStampShape.bIsEnabled;
    }
 
    bool HasTopologyChangeStampEnabled() const
    {
        return ChangeStampTopology.bIsEnabled;
    }
 
    void UpdateChangeStamps(bool bShapeChange, bool bTopologyChange)
    {
        if (bShapeChange || bTopologyChange)
        {
            ChangeStampShape.IncrementIfEnabled();
        }
        if (bTopologyChange)
        {
            ChangeStampTopology.IncrementIfEnabled();
        }
    }
 
    inline uint32 GetShapeChangeStamp() const
    {
        ensureMsgf(ChangeStampShape.bIsEnabled, TEXT("Shape change tracking is not enabled on this mesh. Use SetShapeChangeStampEnabled() to enable."));
        return ChangeStampShape.GetValue();
    }
 
    inline uint32 GetTopologyChangeStamp() const
    {
        ensureMsgf(ChangeStampTopology.bIsEnabled, TEXT("Topology change tracking is not enabled on this mesh. Use SetTopologyChangeStampEnabled() to enable."));
        return ChangeStampTopology.GetValue();
    }
 
    inline uint64 GetChangeStamp() const
    {
        return ChangeStampShape.GetValue() + ChangeStampTopology.GetValue();
    }
 
    //
    // Mesh Element Iterators
    //   The functions VertexIndicesItr() / TriangleIndicesItr() / EdgeIndicesItr() allow you to do:
    //      for ( int eid : EdgeIndicesItr() ) { ... }
    //   and other related begin() / end() idioms
public:
    // simplify names for iterations
    typedef typename FRefCountVector::IndexEnumerable vertex_iterator;
    typedef typename FRefCountVector::IndexEnumerable triangle_iterator;
    typedef typename FRefCountVector::IndexEnumerable edge_iterator;
    template<typename T>
    using value_iteration          = FRefCountVector::MappedEnumerable<T>;
    using vtx_triangles_enumerable = TPairExpandEnumerable<FSmallListSet::ValueIterator>;
 
    vertex_iterator VertexIndicesItr() const
    {
        return VertexRefCounts.Indices();
    }
 
    triangle_iterator TriangleIndicesItr() const
    {
        return TriangleRefCounts.Indices();
    }
 
    edge_iterator EdgeIndicesItr() const
    {
        return EdgeRefCounts.Indices();
    }
 
    // TODO: write helper functions that allow us to do these iterations w/o lambdas
 
    FRefCountVector::FilteredEnumerable BoundaryEdgeIndicesItr() const
    {
        return EdgeRefCounts.FilteredIndices([this](int EdgeID) { return Edges[EdgeID].Tri[1] == InvalidID; });
    }
 
    value_iteration<FVector3d> VerticesItr() const
    {
        return VertexRefCounts.MappedIndices<FVector3d>([this](int VertexID) { return Vertices[VertexID]; });
    }
 
    value_iteration<FIndex3i> TrianglesItr() const
    {
        return TriangleRefCounts.MappedIndices<FIndex3i>([this](int TriangleID) { return Triangles[TriangleID]; });
    }
 
    value_iteration<FEdge> EdgesItr() const
    {
        return EdgeRefCounts.MappedIndices<FEdge>([this](int EdgeID) {
            return Edges[EdgeID];
        });
    }
 
    FSmallListSet::MappedValueEnumerable VtxVerticesItr(int VertexID) const
    {
        checkSlow(VertexRefCounts.IsValid(VertexID));
        return VertexEdgeLists.MappedValues(VertexID,
            [VertexID, this](int eid) { return GetOtherEdgeVertex(eid, VertexID); });
    }
 
    void EnumerateVertexVertices(int32 VertexID, TFunctionRef<void(int32)> VertexFunc) const
    {
        checkSlow(VertexRefCounts.IsValid(VertexID));
        VertexEdgeLists.Enumerate(VertexID, [this, &VertexFunc, VertexID](int32 eid)
        {
            VertexFunc(GetOtherEdgeVertex(eid, VertexID));
        });
    }
 
 
    FSmallListSet::ValueEnumerable VtxEdgesItr(int VertexID) const
    {
        checkSlow(VertexRefCounts.IsValid(VertexID));
        return VertexEdgeLists.Values(VertexID);
    }
 
    void EnumerateVertexEdges(int32 VertexID, TFunctionRef<void(int32)> EdgeFunc) const
    {
        checkSlow(VertexRefCounts.IsValid(VertexID));
        VertexEdgeLists.Enumerate(VertexID, EdgeFunc);
    }
 
 
    vtx_triangles_enumerable VtxTrianglesItr(int VertexID) const
    {
        checkSlow(VertexRefCounts.IsValid(VertexID));
        return vtx_triangles_enumerable(VertexEdgeLists.Values(VertexID), [this, VertexID](int EdgeID) {
            return GetOrderedOneRingEdgeTris(VertexID, EdgeID);
        });
    }
 
    GEOMETRYCORE_API void EnumerateVertexTriangles(int32 VertexID, TFunctionRef<void(int32)> ApplyFunc) const;
 
    GEOMETRYCORE_API int32 GetSingleVertexTriangle(int32 VID) const;
 
    GEOMETRYCORE_API void EnumerateEdgeTriangles(int32 EdgeID, TFunctionRef<void(int32)> ApplyFunc) const;
 
 
    //
    // Mesh Construction
    //
public:
    GEOMETRYCORE_API int AppendVertex(const FVertexInfo& VertInfo);
 
    int AppendVertex(const FVector3d& Position)
    {
        return AppendVertex(FVertexInfo(Position));
    }
 
    GEOMETRYCORE_API int AppendVertex(const FDynamicMesh3& SourceMesh, int SourceVertexID);
 
    GEOMETRYCORE_API int AppendTriangle(const FIndex3i& TriVertices, int GroupID = 0);
 
    inline int AppendTriangle(int Vertex0, int Vertex1, int Vertex2, int GroupID = 0)
    {
        return AppendTriangle(FIndex3i(Vertex0, Vertex1, Vertex2), GroupID);
    }
 
    //
    // Support for inserting vertex and triangle at specific IDs. This is a bit tricky
    // because we likely will need to update the free lists in the RefCountVectors, which
    // can be expensive. If you are going to do many inserts (eg inside a loop), wrap in
    // BeginUnsafe / EndUnsafe calls, and pass bUnsafe = true to the InsertX() calls, to
    // the defer free list rebuild until you are done.
    //
 
    virtual void BeginUnsafeVerticesInsert()
    {
        // do nothing...
    }
 
    virtual void EndUnsafeVerticesInsert()
    {
        VertexRefCounts.RebuildFreeList();
    }
 
    GEOMETRYCORE_API EMeshResult InsertVertex(int VertexID, const FVertexInfo& VertInfo, bool bUnsafe = false);
 
    virtual void BeginUnsafeTrianglesInsert()
    {
        // do nothing...
    }
 
    virtual void EndUnsafeTrianglesInsert()
    {
        TriangleRefCounts.RebuildFreeList();
    }
 
    GEOMETRYCORE_API EMeshResult InsertTriangle(int TriangleID, const FIndex3i& TriVertices, int GroupID = 0, bool bUnsafe = false);
 
    //
    // Vertex/Tri/Edge accessors
    //
public:
    inline FVector3d GetVertex(int VertexID) const
    {
        checkSlow(IsVertex(VertexID));
        return Vertices[VertexID];
    }
 
    inline const FVector3d& GetVertexRef(int VertexID) const
    {
        checkSlow(IsVertex(VertexID));
        return Vertices[VertexID];
    }
 
    inline void SetVertex(int VertexID, const FVector3d& vNewPos, bool bTrackChange = true)
    {
        checkSlow(VectorUtil::IsFinite(vNewPos));
        checkSlow(IsVertex(VertexID));
        if (VectorUtil::IsFinite(vNewPos))
        {
            Vertices[VertexID] = vNewPos;
            if (bTrackChange)
            {
                UpdateChangeStamps(true, false);
            }
        }
    }
 
 
    GEOMETRYCORE_API bool GetVertex(int VertexID, FVertexInfo& VertInfo, bool bWantNormals, bool bWantColors, bool bWantUVs) const;
 
    GEOMETRYCORE_API FVertexInfo GetVertexInfo(int VertexID) const;
 
    int GetVtxEdgeCount(int VertexID) const
    {
        return VertexRefCounts.IsValid(VertexID) ? VertexEdgeLists.GetCount(VertexID) : -1;
    }
 
    GEOMETRYCORE_API int GetMaxVtxEdgeCount() const;
 
    inline FIndex3i GetTriangle(int TriangleID) const
    {
        checkSlow(IsTriangle(TriangleID));
        return Triangles[TriangleID];
    }
 
    inline const FIndex3i& GetTriangleRef(int TriangleID) const
    {
        checkSlow(IsTriangle(TriangleID));
        return Triangles[TriangleID];
    }
 
    inline FIndex3i GetTriEdges(int TriangleID) const
    {
        checkSlow(IsTriangle(TriangleID));
        return TriangleEdges[TriangleID];
    }
 
    inline const FIndex3i& GetTriEdgesRef(int TriangleID) const
    {
        checkSlow(IsTriangle(TriangleID));
        return TriangleEdges[TriangleID];
    }
 
    inline int GetTriEdge(int TriangleID, int j) const
    {
        checkSlow(IsTriangle(TriangleID));
        return TriangleEdges[TriangleID][j];
    }
 
    void EnumerateTriEdgeIDsFromTriID(const int TriID, const TFunctionRef<void(FMeshTriEdgeID TriEdgeID)>& TriEdgeFunc) const
    {
        FIndex3i TriEdges = GetTriEdges(TriID);
        for (int TriEdgesIndex = 0 ; TriEdgesIndex <=2; TriEdgesIndex++)
        {
            EnumerateTriEdgeIDsFromEdgeID(TriEdges[TriEdgesIndex], TriEdgeFunc);
        }
    }
 
    GEOMETRYCORE_API FIndex3i GetTriNeighbourTris(int TriangleID) const;
 
    template<typename VecType>
    inline void GetTriVertices(int TriangleID, VecType& v0, VecType& v1, VecType& v2) const
    {
        const FIndex3i& Triangle = Triangles[TriangleID];
        v0                       = Vertices[Triangle[0]];
        v1                       = Vertices[Triangle[1]];
        v2                       = Vertices[Triangle[2]];
    }
 
    inline FVector3d GetTriVertex(int TriangleID, int j) const
    {
        return Vertices[Triangles[TriangleID][j]];
    }
 
    inline FEdge GetEdge(int EdgeID) const
    {
        checkSlow(IsEdge(EdgeID));
        return Edges[EdgeID];
    }
 
    inline const FEdge& GetEdgeRef(int EdgeID) const
    {
        checkSlow(IsEdge(EdgeID));
        return Edges[EdgeID];
    }
 
    inline FIndex2i GetEdgeV(int EdgeID) const
    {
        checkSlow(IsEdge(EdgeID));
        return Edges[EdgeID].Vert;
    }
 
    inline bool GetEdgeV(int EdgeID, FVector3d& a, FVector3d& b) const
    {
        checkSlow(IsEdge(EdgeID));
 
        const FIndex2i Verts = Edges[EdgeID].Vert;
 
        a = Vertices[Verts[0]];
        b = Vertices[Verts[1]];
 
        return true;
    }
 
    inline FIndex2i GetEdgeT(int EdgeID) const
    {
        checkSlow(IsEdge(EdgeID));
        return Edges[EdgeID].Tri;
    }
 
    GEOMETRYCORE_API FIndex2i GetOrientedBoundaryEdgeV(int EdgeID) const;
 
    inline FMeshTriEdgeID GetTriEdgeIDFromEdgeID(int EdgeID) const
    {
        checkSlow(IsEdge(EdgeID));
        int32 TriIndex = Edges[EdgeID].Tri.A;
        FIndex3i TriEdges = TriangleEdges[TriIndex];
        if (TriEdges.A == EdgeID)
        {
            return FMeshTriEdgeID(TriIndex, 0);
        }
        { 
            return FMeshTriEdgeID(TriIndex, ( TriEdges.B == EdgeID ) ? 1 : 2 );
        }
    }
 
    void EnumerateTriEdgeIDsFromEdgeID(const int32 EdgeID, const TFunctionRef<void(FMeshTriEdgeID TriEdgeID)>& TriEdgeFunc) const
    {
        const FMeshTriEdgeID FirstTriEdgeID = GetTriEdgeIDFromEdgeID(EdgeID); // function gets MeshTriEdgeID for edge included in EdgeTri.A only
        TriEdgeFunc(FirstTriEdgeID);
 
        // have to get MeshTriEdgeID for edge included in EdgeTri.B
        const int OtherTriID = GetEdgeT(EdgeID).B;
        if (OtherTriID != IndexConstants::InvalidID)
        {
            FMeshTriEdgeID SecondTriEdgeID;
            const FIndex3i SecondTriEdges = GetTriEdges(OtherTriID);
            if (SecondTriEdges.A == EdgeID)
            {
                SecondTriEdgeID = FMeshTriEdgeID(OtherTriID, 0);
            }
            else
            {
                SecondTriEdgeID = FMeshTriEdgeID(OtherTriID, ( SecondTriEdges.B == EdgeID ) ? 1 : 2 );
            }
            TriEdgeFunc(SecondTriEdgeID);
        }
    }
 
    //
    // Vertex and Triangle attribute arrays
    //
public:
    GEOMETRYCORE_API void EnableMeshComponents(int MeshComponentsFlags);
 
    GEOMETRYCORE_API void EnableVertexNormals(const FVector3f& InitialNormal);
    GEOMETRYCORE_API void DiscardVertexNormals();
 
    FVector3f GetVertexNormal(int vID) const
    {
        if (HasVertexNormals() == false)
        {
            return FVector3f::UnitY();
        }
        checkSlow(IsVertex(vID));
        const TDynamicVector<FVector3f>& Normals = VertexNormals.GetValue();
        return Normals[vID];
    }
 
    void SetVertexNormal(int vID, const FVector3f& vNewNormal)
    {
        if (HasVertexNormals())
        {
            checkSlow(IsVertex(vID));
            TDynamicVector<FVector3f>& Normals = VertexNormals.GetValue();
            Normals[vID]                       = vNewNormal;
        }
    }
 
    GEOMETRYCORE_API void EnableVertexColors(const FVector3f& InitialColor);
    GEOMETRYCORE_API void DiscardVertexColors();
 
 
    FVector3f GetVertexColor(int vID) const
    {
        if (HasVertexColors() == false)
        {
            return FVector3f::One();
        }
        checkSlow(IsVertex(vID));
 
        const TDynamicVector<FVector3f>& Colors = VertexColors.GetValue();
        return Colors[vID];
    }
 
    void SetVertexColor(int vID, const FVector3f& vNewColor)
    {
        if (HasVertexColors())
        {
            checkSlow(IsVertex(vID));
            TDynamicVector<FVector3f>& Colors = VertexColors.GetValue();
            Colors[vID]                       = vNewColor;
        }
    }
 
    GEOMETRYCORE_API void EnableVertexUVs(const FVector2f& InitialUV);
    GEOMETRYCORE_API void DiscardVertexUVs();
 
    FVector2f GetVertexUV(int vID) const
    {
        if (HasVertexUVs() == false)
        {
            return FVector2f::Zero();
        }
        checkSlow(IsVertex(vID));
        const TDynamicVector<FVector2f>& UVs = VertexUVs.GetValue();
        return UVs[vID];
    }
 
    void SetVertexUV(int vID, const FVector2f& vNewUV)
    {
        if (HasVertexUVs())
        {
            checkSlow(IsVertex(vID));
            TDynamicVector<FVector2f>& UVs = VertexUVs.GetValue();
            UVs[vID]                       = vNewUV;
        }
    }
 
    GEOMETRYCORE_API void EnableTriangleGroups(int InitialGroupID = 0);
    GEOMETRYCORE_API void DiscardTriangleGroups();
 
    int AllocateTriangleGroup()
    {
        return GroupIDCounter++;
    }
 
    int GetTriangleGroup(int tID) const
    {
        return (HasTriangleGroups() == false) ? -1 :
                                                (TriangleRefCounts.IsValid(tID) ? TriangleGroups.GetValue()[tID] : 0);
    }
 
    void SetTriangleGroup(int tid, int group_id)
    {
        if (HasTriangleGroups())
        {
            checkSlow(IsTriangle(tid));
            TriangleGroups.GetValue()[tid] = group_id;
            GroupIDCounter                 = FMath::Max(GroupIDCounter, group_id + 1);
        }
    }
 
    FDynamicMeshAttributeSet* Attributes()
    {
        return HasAttributes() ? AttributeSet.Get() : nullptr;
    }
    const FDynamicMeshAttributeSet* Attributes() const
    {
        return HasAttributes() ? AttributeSet.Get() : nullptr;
    }
 
    GEOMETRYCORE_API void EnableAttributes();
    GEOMETRYCORE_API void DiscardAttributes();
 
 
    //
    // topological queries
    //
public:
    inline bool IsBoundaryEdge(int EdgeID) const
    {
        checkSlow(IsEdge(EdgeID));
        return Edges[EdgeID].Tri[1] == InvalidID;
    }
 
    GEOMETRYCORE_API bool IsBoundaryVertex(int VertexID) const;
 
    GEOMETRYCORE_API bool IsBoundaryTriangle(int TriangleID) const;
 
    GEOMETRYCORE_API int FindEdge(int VertexA, int VertexB) const;
 
    GEOMETRYCORE_API int FindEdgeFromTri(int VertexA, int VertexB, int TriangleID) const;
 
    GEOMETRYCORE_API int FindEdgeFromTriPair(int TriangleA, int TriangleB) const;
 
    GEOMETRYCORE_API int FindTriangle(int A, int B, int C) const;
 
    GEOMETRYCORE_API FIndex2i GetEdgeOpposingV(int EdgeID) const;
 
    GEOMETRYCORE_API void GetVtxNbrhood(int EdgeID, int VertexID, int& OtherVertOut, int& OppVert1Out, int& OppVert2Out, int& Tri1Out,
                       int& Tri2Out) const;
 
    GEOMETRYCORE_API int GetVtxBoundaryEdges(int VertexID, int& Edge0Out, int& Edge1Out) const;
 
    template<typename ArrayType = FLocalIntArray>
    GEOMETRYCORE_API int GetAllVtxBoundaryEdges(int VertexID, ArrayType& EdgeListOut) const;
 
    GEOMETRYCORE_API int GetVtxTriangleCount(int VertexID) const;
 
    template<typename ArrayType = FLocalIntArray>
    GEOMETRYCORE_API EMeshResult GetVtxTriangles(int VertexID, ArrayType& TrianglesOut) const;
    
 
    GEOMETRYCORE_API int GetVtxSingleTriangle(int VertexID) const;
 
    template<typename IntArrayType = FLocalIntArray, typename BoolArrayType = FLocalBoolArray>
    GEOMETRYCORE_API EMeshResult GetVtxContiguousTriangles(int VertexID, IntArrayType& TrianglesOut, IntArrayType& ContiguousGroupLengths,
                                          BoolArrayType& GroupIsLoop) const;
 
    GEOMETRYCORE_API bool IsGroupBoundaryEdge(int EdgeID) const;
 
    GEOMETRYCORE_API bool IsGroupBoundaryVertex(int VertexID) const;
 
    GEOMETRYCORE_API bool IsGroupJunctionVertex(int VertexID) const;
 
    GEOMETRYCORE_API bool GetVertexGroups(int VertexID, FIndex4i& GroupsOut) const;
 
    template<typename ArrayType = FLocalIntArray>
    GEOMETRYCORE_API bool GetAllVertexGroups(int VertexID, ArrayType& GroupsOut) const;
 
    GEOMETRYCORE_API bool IsBowtieVertex(int VertexID) const;
 
    bool IsCompact() const
    {
        return VertexRefCounts.IsDense() && EdgeRefCounts.IsDense() && TriangleRefCounts.IsDense();
    }
 
    bool IsCompactV() const
    {
        return VertexRefCounts.IsDense();
    }
 
    bool IsCompactT() const
    {
        return TriangleRefCounts.IsDense();
    }
 
    double CompactMetric() const
    {
        return ((double)VertexCount() / (double)MaxVertexID() + (double)TriangleCount() / (double)MaxTriangleID()) * 0.5;
    }
 
    GEOMETRYCORE_API bool IsClosed() const;
 
 
    //
    // Geometric queries
    //
public:
    GEOMETRYCORE_API FAxisAlignedBox3d GetBounds(bool bParallel = false) const;
 
    GEOMETRYCORE_API FFrame3d GetVertexFrame(int VertexID, bool bFrameNormalY = false, FVector3d* UseNormal = nullptr) const;
 
    GEOMETRYCORE_API FVector3d GetTriNormal(int TriangleID) const;
 
    GEOMETRYCORE_API double GetTriArea(int TriangleID) const;
 
    GEOMETRYCORE_API void GetTriInfo(int TriangleID, FVector3d& Normal, double& Area, FVector3d& Centroid) const;
 
    GEOMETRYCORE_API FVector3d GetTriCentroid(int TriangleID) const;
 
    GEOMETRYCORE_API FVector3d GetTriBaryPoint(int TriangleID, double Bary0, double Bary1, double Bary2) const;
 
    GEOMETRYCORE_API FVector3d GetTriBaryNormal(int TriangleID, double Bary0, double Bary1, double Bary2) const;
 
    GEOMETRYCORE_API void GetTriBaryPoint(int TriangleID, double Bary0, double Bary1, double Bary2, FVertexInfo& VertInfo) const;
 
    GEOMETRYCORE_API FAxisAlignedBox3d GetTriBounds(int TriangleID) const;
 
    GEOMETRYCORE_API FFrame3d GetTriFrame(int TriangleID, int Edge = 0) const;
 
    GEOMETRYCORE_API double GetTriSolidAngle(int TriangleID, const FVector3d& p) const;
 
    GEOMETRYCORE_API double GetTriInternalAngleR(int TriangleID, int i) const;
 
    GEOMETRYCORE_API FVector3d GetTriInternalAnglesR(int TriangleID) const;
 
    GEOMETRYCORE_API FVector3d GetEdgeNormal(int EdgeID) const;
 
    GEOMETRYCORE_API FVector3d GetEdgePoint(int EdgeID, double ParameterT) const;
 
    GEOMETRYCORE_API void GetVtxOneRingCentroid(int VertexID, FVector3d& CentroidOut) const;
 
    GEOMETRYCORE_API double CalculateWindingNumber(const FVector3d& QueryPoint) const;
 
    //
    // direct buffer access
    //
public:
    const TDynamicVector<FVector3d>& GetVerticesBuffer() const 
    {
        return Vertices;
    }
    const FRefCountVector& GetVerticesRefCounts() const 
    {
        return VertexRefCounts;
    }
    const TDynamicVector<FVector3f>* GetNormalsBuffer() const 
    {
        return HasVertexNormals() ? &VertexNormals.GetValue() : nullptr;
    }
    const TDynamicVector<FVector3f>* GetColorsBuffer() const 
    {
        return HasVertexColors() ? &VertexColors.GetValue() : nullptr;
    }
    const TDynamicVector<FVector2f>* GetUVBuffer() const 
    {
        return HasVertexUVs() ? &VertexUVs.GetValue() : nullptr;
    }
    const TDynamicVector<FIndex3i>& GetTrianglesBuffer() const 
    {
        return Triangles;
    }
    const FRefCountVector& GetTrianglesRefCounts() const
    {
        return TriangleRefCounts;
    }
    const TDynamicVector<int>* GetTriangleGroupsBuffer() const
    {
        return HasTriangleGroups() ? &TriangleGroups.GetValue() : nullptr;
    }
    const TDynamicVector<FEdge>& GetEdgesBuffer() const 
    {
        return Edges;
    }
    const FRefCountVector& GetEdgesRefCounts() const 
    {
        return EdgeRefCounts;
    }
    const FSmallListSet& GetVertexEdges() const 
    {
        return VertexEdgeLists;
    }
    const TDynamicVector<FIndex3i>& GetTriangleEdges() const 
    {
        return TriangleEdges;
    }
    //
    // Mesh Edit operations
    //
public:
    GEOMETRYCORE_API void CompactInPlace(FCompactMaps* CompactInfo = nullptr);
 
    GEOMETRYCORE_API int32 RemoveUnusedVertices();
 
    GEOMETRYCORE_API bool HasUnusedVertices() const;
 
    GEOMETRYCORE_API void ReverseOrientation(bool bFlipNormals = true);
 
    GEOMETRYCORE_API EMeshResult ReverseTriOrientation(int TriangleID);
 
    GEOMETRYCORE_API EMeshResult RemoveVertex(int VertexID, bool bPreserveManifold = false);
 
    GEOMETRYCORE_API EMeshResult RemoveTriangle(int TriangleID, bool bRemoveIsolatedVertices = true, bool bPreserveManifold = false);
 
    GEOMETRYCORE_API virtual EMeshResult SetTriangle(int TriangleID, const FIndex3i& NewVertices, bool bRemoveIsolatedVertices = true);
 
    GEOMETRYCORE_API virtual EMeshResult SplitEdge(int EdgeAB, FEdgeSplitInfo& SplitInfo, double SplitParameterT = 0.5);
 
    GEOMETRYCORE_API EMeshResult SplitEdge(int EdgeVertA, int EdgeVertB, FEdgeSplitInfo& SplitInfo);
 
    GEOMETRYCORE_API virtual EMeshResult FlipEdge(int EdgeAB, FEdgeFlipInfo& FlipInfo);
 
    GEOMETRYCORE_API virtual EMeshResult FlipEdge(int EdgeVertA, int EdgeVertB, FEdgeFlipInfo& FlipInfo);
 
 
    GEOMETRYCORE_API virtual EMeshResult SplitVertex(int VertexID, const TArrayView<const int>& TrianglesToUpdate,
                                    FVertexSplitInfo& SplitInfo);
 
    GEOMETRYCORE_API virtual bool SplitVertexWouldLeaveIsolated(int VertexID, const TArrayView<const int>& TrianglesToUpdate);
 
    struct FCollapseEdgeOptions
    {
        bool bAllowHoleCollapse = false;
        bool bAllowCollapsingInternalEdgeWithBoundaryVertices = false;
        bool bAllowTetrahedronCollapse = false;
    };
    GEOMETRYCORE_API virtual EMeshResult CanCollapseEdge(int vKeep, int vRemove, const FCollapseEdgeOptions& Options) const;
 
    GEOMETRYCORE_API virtual EMeshResult CanCollapseEdge(int vKeep, int vRemove, double EdgeParameterT = 0) const;
 
    GEOMETRYCORE_API virtual EMeshResult CollapseEdge(int KeepVertID, int RemoveVertID, double EdgeParameterT, 
        const FCollapseEdgeOptions& Options, FEdgeCollapseInfo& CollapseInfo);
 
    virtual EMeshResult CollapseEdge(int KeepVertID, int RemoveVertID, const FCollapseEdgeOptions& Options, FEdgeCollapseInfo& CollapseInfo)
    {
        return CollapseEdge(KeepVertID, RemoveVertID, 0, Options, CollapseInfo);
    }
 
    GEOMETRYCORE_API virtual EMeshResult CollapseEdge(int KeepVertID, int RemoveVertID, double EdgeParameterT,
                                     FEdgeCollapseInfo& CollapseInfo);
    virtual EMeshResult CollapseEdge(int KeepVertID, int RemoveVertID, FEdgeCollapseInfo& CollapseInfo)
    {
        return CollapseEdge(KeepVertID, RemoveVertID, 0, CollapseInfo);
    }
 
 
    GEOMETRYCORE_API virtual EMeshResult MergeEdges(int KeepEdgeID, int DiscardEdgeID, double InterpolationT, FMergeEdgesInfo& MergeInfo, bool bCheckValidOrientation = true);
    
    GEOMETRYCORE_API virtual EMeshResult MergeEdges(int KeepEdgeID, int DiscardEdgeID, FMergeEdgesInfo& MergeInfo, bool bCheckValidOrientation=true);
 
    struct FMergeVerticesOptions
    {
        // If false, we disallow vertex merges that attempt to merge one non-boundary vert to a
        //  a non-adjacent vert, even if this is possible through a bowtie. Note that merging
        //  boundary verts to create a bowtie on the boundary is still allowed, as this is a 
        //  common intermediate step when welding edges. 
        bool bAllowNonBoundaryBowtieCreation = false;
    };
 
    GEOMETRYCORE_API virtual EMeshResult MergeVertices(int KeepVid, int DiscardVid, double InterpolationT, 
        const FMergeVerticesOptions& Options, FMergeVerticesInfo& MergeInfo);
 
    virtual EMeshResult MergeVertices(int KeepVid, int DiscardVid, double InterpolationT, FMergeVerticesInfo& MergeInfo)
    {
        return MergeVertices(KeepVid, DiscardVid, InterpolationT, FMergeVerticesOptions(), MergeInfo);
    }
 
    virtual EMeshResult MergeVertices(int KeepVid, int DiscardVid, FMergeVerticesInfo& MergeInfo)
    {
        return MergeVertices(KeepVid, DiscardVid, 0, FMergeVerticesOptions(), MergeInfo);
    }
 
    GEOMETRYCORE_API virtual EMeshResult PokeTriangle(int TriangleID, const FVector3d& BaryCoordinates, FPokeTriangleInfo& PokeInfo);
 
    virtual EMeshResult PokeTriangle(int TriangleID, FPokeTriangleInfo& PokeInfo)
    {
        return PokeTriangle(TriangleID, FVector3d::One() / 3.0, PokeInfo);
    }
 
    //
    // Debug utility functions
    //
public:
    GEOMETRYCORE_API virtual FString MeshInfoString() const;
    
    GEOMETRYCORE_API SIZE_T GetByteCount() const;
 
    struct FSameAsOptions
    {
        bool bCheckConnectivity = true;
        bool bCheckEdgeIDs = false;
        bool bCheckNormals = false;
        bool bCheckColors = false;
        bool bCheckUVs = false;
        bool bCheckGroups = false;
        bool bCheckAttributes = false;
 
        // Ignore gaps and padding in the data layout, i.e. the exact index is irrelevant as long as valid entries are equal in value and in the same order.
        bool bIgnoreDataLayout = false;
 
        // comparisons check for smaller or equal than this value. used on on 32-bit floating point checks
        float EpsilonFloat { TMathUtil<float>::Epsilon };
 
        // comparisons check for smaller or equal than this value. used for 64-bit comparisons, such as on points.
        double EpsilonDouble { static_cast<double>(TMathUtil<float>::Epsilon) };
    };
 
    struct FMeshDifferenceInfo
    {
        // Reasons for difference between meshes
        enum class EReason
        {
            Unknown,
            VertexCount,
            TriangleCount,
            EdgeCount,
            Vertex,
            Triangle,
            Edge,
            Connectivity,
            Normal,
            Color,
            UV,
            Group,
            Attribute
        };
        EReason Reason = EReason::Unknown;
 
        // May contain further detail on the difference
        FString Detail;
 
        // Types of element ID that could be set below
        enum class EIDType
        {
            None,
            Vertex,
            Triangle,
            Edge
        };
 
        // ID in this mesh of element where the difference was found, or InvalidID if not applicable
        int32 ID = InvalidID;
        // ID in the compared-against mesh where the difference was found, or InvalidID if not applicable
        int32 OtherID = InvalidID;
        // Type of element that the ID references
        EIDType IDType = EIDType::None;
 
        // Helpers to set different ID types
        void SetVID(int32 VID, int32 OtherVID = InvalidID)
        {
            ID = VID;
            OtherID = OtherVID;
            IDType = EIDType::Vertex;
        }
        void SetTID(int32 TID, int32 OtherTID = InvalidID)
        {
            ID = TID;
            OtherID = OtherTID;
            IDType = EIDType::Triangle;
        }
        void SetEID(int32 EID, int32 OtherEID = InvalidID)
        {
            ID = EID;
            OtherID = OtherEID;
            IDType = EIDType::Edge;
        }
    };
 
    GEOMETRYCORE_API virtual bool IsSameAs(const FDynamicMesh3& OtherMesh, const FSameAsOptions& Options) const;
    GEOMETRYCORE_API virtual bool IsSameAs(const FDynamicMesh3& OtherMesh, const FSameAsOptions& Options, FMeshDifferenceInfo& OutMeshDifferenceInfo) const;
private:
    GEOMETRYCORE_API bool IsSameAs_Helper(const FDynamicMesh3& OtherMesh, const FSameAsOptions& Options, FMeshDifferenceInfo* OutMeshDifferenceInfo = nullptr) const;
public:
 
    struct FValidityOptions
    {
        bool bAllowNonManifoldVertices             = false;
        bool bAllowAdjacentFacesReverseOrientation = false;
 
        FValidityOptions(bool bAllowNonManifoldVertices = false, bool bAllowAdjacentFacesReverseOrientation = false)
            : bAllowNonManifoldVertices(bAllowNonManifoldVertices)
            , bAllowAdjacentFacesReverseOrientation(bAllowAdjacentFacesReverseOrientation)
        {}
 
        static FValidityOptions Permissive()
        {
            FValidityOptions ToRet;
            ToRet.bAllowAdjacentFacesReverseOrientation = true;
            ToRet.bAllowNonManifoldVertices             = true;
            return ToRet;
        }
    };
 
    GEOMETRYCORE_API virtual bool CheckValidity(FValidityOptions ValidityOptions = FValidityOptions(),
                               EValidityCheckFailMode FailMode  = EValidityCheckFailMode::Check) const;
 
    //
    // Internal functions
    //
protected:
    inline void SetTriangleInternal(int TriangleID, int v0, int v1, int v2)
    {
        Triangles[TriangleID] = FIndex3i(v0, v1, v2);
    }
    inline void SetTriangleEdgesInternal(int TriangleID, int e0, int e1, int e2)
    {
        TriangleEdges[TriangleID] = FIndex3i(e0, e1, e2);
    }
 
    inline int AddEdgeInternal(int vA, int vB, int tA, int tB = InvalidID)
    {
        if (vB < vA) {
            int t = vB; vB = vA; vA = t;
        }
        int eid = EdgeRefCounts.Allocate();
        Edges.InsertAt(FEdge{ {vA, vB},{tA, tB} }, eid);
        VertexEdgeLists.Insert(vA, eid);
        VertexEdgeLists.Insert(vB, eid);
        return eid;
 
    }
    GEOMETRYCORE_API int AddTriangleInternal(int a, int b, int c, int e0, int e1, int e2);
 
    inline int ReplaceTriangleVertex(int TriangleID, int vOld, int vNew)
    {
        FIndex3i& Triangle = Triangles[TriangleID];
        for (int i : {0, 1, 2})
        {
            if (Triangle[i] == vOld)
            {
                Triangle[i] = vNew;
                return 0;
            }
        }
        return -1;
    }
 
    inline void AllocateEdgesList(int VertexID)
    {
        if (VertexID < (int)VertexEdgeLists.Size())
        {
            VertexEdgeLists.Clear(VertexID);
        }
        VertexEdgeLists.AllocateAt(VertexID);
    }
 
    template<typename ArrayType = FLocalIntArray>
    void GetVertexEdgesList(int VertexID, ArrayType& EdgesOut) const
    {
        for (int eid : VertexEdgeLists.Values(VertexID))
        {
            EdgesOut.Add(eid);
        }
    }
 
    inline void SetEdgeVerticesInternal(int EdgeID, int a, int b)
    {
        if (a > b)
        {
            Swap(a,b);
        }
        Edges[EdgeID].Vert[0] = a;
        Edges[EdgeID].Vert[1] = b;
    }
 
    inline void SetEdgeTrianglesInternal(int EdgeID, int t0, int t1)
    {
        Edges[EdgeID].Tri[0] = t0;
        Edges[EdgeID].Tri[1] = t1;
    }
 
    GEOMETRYCORE_API int ReplaceEdgeVertex(int EdgeID, int vOld, int vNew);
    GEOMETRYCORE_API int ReplaceEdgeTriangle(int EdgeID, int tOld, int tNew);
    GEOMETRYCORE_API int ReplaceTriangleEdge(int EdgeID, int eOld, int eNew);
 
    inline bool TriangleHasVertex(int TriangleID, int VertexID) const
    {
        return Triangles[TriangleID][0] == VertexID || Triangles[TriangleID][1] == VertexID ||
            Triangles[TriangleID][2] == VertexID;
    }
 
    inline bool TriHasNeighbourTri(int CheckTriID, int NbrTriID) const
    {
        return EdgeHasTriangle(TriangleEdges[CheckTriID][0], NbrTriID) ||
            EdgeHasTriangle(TriangleEdges[CheckTriID][1], NbrTriID) ||
            EdgeHasTriangle(TriangleEdges[CheckTriID][2], NbrTriID);
    }
 
    inline bool TriHasSequentialVertices(int TriangleID, int vA, int vB) const
    {
        const FIndex3i& Tri = Triangles[TriangleID];
        return ((Tri.A == vA && Tri.B == vB) || (Tri.B == vA && Tri.C == vB) || (Tri.C == vA && Tri.A == vB));
    }
 
    GEOMETRYCORE_API int FindTriangleEdge(int TriangleID, int vA, int vB) const;
 
    GEOMETRYCORE_API int32 FindEdgeInternal(int32 vA, int32 vB, bool& bIsBoundary) const;
 
    inline bool EdgeHasVertex(int EdgeID, int VertexID) const
    {
        const FIndex2i Verts = Edges[EdgeID].Vert;
        return (Verts[0] == VertexID) || (Verts[1] == VertexID);
    }
    inline bool EdgeHasTriangle(int EdgeID, int TriangleID) const
    {
        const FIndex2i Tris = Edges[EdgeID].Tri;
        return (Tris[0] == TriangleID) || (Tris[1] == TriangleID);
    }
 
    inline int GetOtherEdgeVertex(int EdgeID, int VertexID) const
    {
        const FIndex2i Verts = Edges[EdgeID].Vert;
        return (Verts[0] == VertexID) ? Verts[1] : ((Verts[1] == VertexID) ? Verts[0] : InvalidID);
    }
    inline int GetOtherEdgeTriangle(int EdgeID, int TriangleID) const
    {
        const FIndex2i Tris = Edges[EdgeID].Tri;
        return (Tris[0] == TriangleID) ? Tris[1] : ((Tris[1] == TriangleID) ? Tris[0] : InvalidID);
    }
 
    inline void AddTriangleEdge(int TriangleID, int v0, int v1, int j, int EdgeID)
    {
        FIndex3i& TriEdges = TriangleEdges.ElementAt(TriangleID, FIndex3i(InvalidID, InvalidID, InvalidID));
        if (EdgeID != InvalidID)
        {
            Edges[EdgeID].Tri[1] = TriangleID;
            TriEdges[j] = EdgeID;
        }
        else
        {
            TriEdges[j] = AddEdgeInternal(v0, v1, TriangleID);
        }
    }
 
    // utility function that returns one or two triangles of edge, used to enumerate vertex one-ring triangles
    // The logic is a bit tricky to follow without drawing it out on paper, but this will only return
    // each triangle once, for the 'outgoing' edge from the vertex, and each triangle only has one such edge
    // at any vertex (including boundary triangles)
    inline FIndex2i GetOrderedOneRingEdgeTris(int VertexID, int EdgeID) const
    {
        const FIndex2i Tris = Edges[EdgeID].Tri;
 
        int vOther = GetOtherEdgeVertex(EdgeID, VertexID);
        int et1    = Tris[1];
        et1        = (et1 != InvalidID && TriHasSequentialVertices(et1, VertexID, vOther)) ? et1 : InvalidID;
        int et0    = Tris[0];
        return TriHasSequentialVertices(et0, VertexID, vOther) ? FIndex2i(et0, et1) : FIndex2i(et1, InvalidID);
    }
 
 
    GEOMETRYCORE_API void ReverseTriOrientationInternal(int TriangleID);
 
    template<int Variant>
    void SerializeInternal(FArchive& Ar, void* Ptr);
 
    /* We keep this version of CanCollapseEdge internal because the CollapseInfo struct may only be partially filled out by the function */
    GEOMETRYCORE_API virtual EMeshResult CanCollapseEdgeInternal(int vKeep, int vRemove, double collapse_t, FEdgeCollapseInfo* OutCollapseInfo) const;
private:
    GEOMETRYCORE_API virtual EMeshResult CanCollapseEdgeInternal(int vKeep, int vRemove, double collapse_t,
        const FCollapseEdgeOptions& Options, FEdgeCollapseInfo* OutCollapseInfo) const;
 
    friend class FDynamicMeshAttributeSet;
    friend class FDynamicMeshBulkEdit;
};
 
 
 
 
namespace Debug
{
    /*
     * Store a copy of Mesh in a global Debug Meshes TMap<DebugMeshName, Mesh>.
     * The mesh will exist until the Engine exits, unless FetchDebugMesh or ClearAllDebugMeshes removes it
     */
    GEOMETRYCORE_API void StashDebugMesh(const FDynamicMesh3& Mesh, FString DebugMeshName);
 
    GEOMETRYCORE_API bool FetchDebugMesh(FString DebugMeshName, FDynamicMesh3& MeshOut, bool bClear);
 
    GEOMETRYCORE_API void ClearAllDebugMeshes();
}
 
 
 
} // end namespace UE::Geometry
} // end namespace UE
 
template<> struct TCanBulkSerialize<UE::Geometry::FDynamicMesh3::FEdge> { enum { Value = true }; };