GeometryTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Map.h"
#include "Misc/AssertionMacros.h"
 
namespace UE
{
namespace Geometry
{
 
enum class EMeshResult
{
    Ok = 0,
    Failed_NotAVertex = 1,
    Failed_NotATriangle = 2,
    Failed_NotAnEdge = 3,
 
    Failed_BrokenTopology = 10,
    Failed_HitValenceLimit = 11,
 
    Failed_IsBoundaryEdge = 20,
    Failed_FlippedEdgeExists = 21,
    Failed_IsBowtieVertex = 22,
    Failed_InvalidNeighbourhood = 23,       // these are all failures for CollapseEdge
    Failed_FoundDuplicateTriangle = 24,
    Failed_CollapseTetrahedron = 25,
    Failed_CollapseTriangle = 26,
    Failed_NotABoundaryEdge = 27,
    Failed_SameOrientation = 28,
    Failed_CollapseQuad = 29,
 
    Failed_WouldCreateBowtie = 30,
    Failed_VertexAlreadyExists = 31,
    Failed_CannotAllocateVertex = 32,
    Failed_VertexStillReferenced = 33,
 
    Failed_WouldCreateNonmanifoldEdge = 50,
    Failed_TriangleAlreadyExists = 51,
    Failed_CannotAllocateTriangle = 52,
 
    Failed_UnrecoverableError = 1000,
    Failed_Unsupported = 1001
};
 
 
 
enum class EOperationValidationResult
{
    Ok = 0,
    Failed_UnknownReason = 1,
 
    Failed_InvalidTopology = 2
};
 
 
enum class EValidityCheckFailMode 
{ 
    ReturnOnly = 0,
    Check = 1,
    Ensure = 2
};
 
 
 
 
 
template<typename IntType>
struct TIndexMap
{
protected:
    TMap<IntType, IntType> ForwardMap;
    TMap<IntType, IntType> ReverseMap;
    bool bWantForward;
    bool bWantReverse;
 
public:
 
    TIndexMap()
    {
        bWantForward = bWantReverse = true;
    }
 
    void Reset()
    {
        ForwardMap.Reset();
        ReverseMap.Reset();
    }
 
    constexpr IntType UnmappedID() const { return (IntType)-1; }
 
    TMap<IntType, IntType>& GetForwardMap() { return ForwardMap; }
    const TMap<IntType, IntType>& GetForwardMap() const { return ForwardMap; }
 
    TMap<IntType, IntType>& GetReverseMap() { return ReverseMap; }
    const TMap<IntType, IntType>& GetReverseMap() const { return ReverseMap; }
 
    inline void Add(IntType FromID, IntType ToID)
    {
        checkSlow(FromID >= 0 && ToID >= 0);
        ForwardMap.Add(FromID, ToID);
        ReverseMap.Add(ToID, FromID);
    }
 
    inline bool ContainsFrom(IntType FromID) const
    {
        checkSlow(FromID >= 0);
        check(bWantForward);
        return ForwardMap.Contains(FromID);
    }
 
    inline bool ContainsTo(IntType ToID) const
    {
        checkSlow(ToID >= 0);
        check(bWantReverse);
        return ReverseMap.Contains(ToID);
    }
 
 
    inline IntType GetTo(IntType FromID) const
    {
        checkSlow(FromID >= 0);
        check(bWantForward);
        const IntType* FoundVal = ForwardMap.Find(FromID);
        return (FoundVal == nullptr) ? UnmappedID() : *FoundVal;
    }
 
    inline IntType GetFrom(IntType ToID) const
    {
        checkSlow(ToID >= 0);
        check(bWantReverse);
        const IntType* FoundVal = ReverseMap.Find(ToID);
        return (FoundVal == nullptr) ? UnmappedID() : *FoundVal;
    }
 
    inline const IntType* FindTo(IntType FromID) const
    {
        checkSlow(FromID >= 0);
        check(bWantForward);
        return ForwardMap.Find(FromID);
    }
 
    inline const IntType* FindFrom(IntType ToID) const
    {
        checkSlow(ToID >= 0);
        check(bWantReverse);
        return ReverseMap.Find(ToID);
    }
 
 
    void Reserve(int NumElements)
    {
        checkSlow(NumElements >= 0);
        if (bWantForward)
        {
            ForwardMap.Reserve(NumElements);
        }
        if (bWantReverse)
        {
            ReverseMap.Reserve(NumElements);
        }
    }
    
    SIZE_T GetAllocatedSize() const
    {
        return ForwardMap.GetAllocatedSize() + ReverseMap.GetAllocatedSize();
    }
};
 
typedef TIndexMap<int> FIndexMapi;
 
 
} // end namespace UE::Geometry
} // end namespace UE