IndexUtil.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Port of geometry3cpp index_util.h
 
#pragma once
 
#include "Containers/Array.h"
#include "GeometryBase.h"
#include "IndexTypes.h"
#include "IntVectorTypes.h"
#include "Math/MathFwd.h"
#include "Math/Vector.h"
#include "Util/DynamicVector.h"
#include "VectorTypes.h"
 
 
namespace IndexUtil
{
    using namespace UE::Geometry;
    using UE::Geometry::FIndex2i;
 
    template<typename T>
    inline bool SamePairUnordered(T a0, T a1, T b0, T b1)
    {
        return (a0 == b0) ?
            (a1 == b1) :
            (a0 == b1 && a1 == b0);
    }
 
 
    inline int FindSharedEdgeVertex(const FIndex2i & EdgeVerts1, const FIndex2i & EdgeVerts2)
    {
        if (EdgeVerts1.A == EdgeVerts2.A)             return EdgeVerts1.A;
        else if (EdgeVerts1.A == EdgeVerts2.B)        return EdgeVerts1.A;
        else if (EdgeVerts1.B == EdgeVerts2.A)        return EdgeVerts1.B;
        else if (EdgeVerts1.B == EdgeVerts2.B)        return EdgeVerts1.B;
        else return IndexConstants::InvalidID;
    }
 
    inline int FindEdgeOtherVertex(const FIndex2i & EdgeVerts, int VertexID)
    {
        if (EdgeVerts.A == VertexID)        return EdgeVerts.B;
        else if (EdgeVerts.B == VertexID)   return EdgeVerts.A;
        else                                return IndexConstants::InvalidID;
    }
 
 
    template<typename T, typename Vec>
    inline int FindTriIndex(T VertexID, const Vec & TriangleVerts)
    {
        if (TriangleVerts[0] == VertexID) return 0;
        if (TriangleVerts[1] == VertexID) return 1;
        if (TriangleVerts[2] == VertexID) return 2;
        return IndexConstants::InvalidID;
    }
 
    template<typename T, typename Vec>
    inline int FindEdgeIndexInTri(T VertexID1, T VertexID2, const Vec & TriangleVerts)
    {
        if (SamePairUnordered(VertexID1, VertexID2, TriangleVerts[0], TriangleVerts[1])) return 0;
        if (SamePairUnordered(VertexID1, VertexID2, TriangleVerts[1], TriangleVerts[2])) return 1;
        if (SamePairUnordered(VertexID1, VertexID2, TriangleVerts[2], TriangleVerts[0])) return 2;
        return IndexConstants::InvalidID;
    }
 
 
    template<typename T, typename Vec>
    inline int FindTriOrderedEdge(T VertexID1, T VertexID2, const Vec & TriangleVerts)
    {
        if (TriangleVerts[0] == VertexID1 && TriangleVerts[1] == VertexID2) return 0;
        if (TriangleVerts[1] == VertexID1 && TriangleVerts[2] == VertexID2) return 1;
        if (TriangleVerts[2] == VertexID1 && TriangleVerts[0] == VertexID2) return 2;
        return IndexConstants::InvalidID;
    }
 
    template<typename T, typename Vec>
    inline int FindTriOtherVtxUnsafe(T VertexID1, T VertexID2, const Vec& TriangleVerts)
    {
        if (TriangleVerts[0] == VertexID1)
        {
            return (TriangleVerts[1] == VertexID2) ? TriangleVerts[2] : TriangleVerts[1];
        }
        else if (TriangleVerts[1] == VertexID1)
        {
            return (TriangleVerts[0] == VertexID2) ? TriangleVerts[2] : TriangleVerts[0];
        }
        else
        {
            return (TriangleVerts[0] == VertexID2) ? TriangleVerts[1] : TriangleVerts[0];
        }
    }
 
 
    template<typename T, typename Vec>
    inline int FindTriOtherVtx(T VertexID1, T VertexID2, const Vec & TriangleVerts)
    {
        for (int j = 0; j < 3; ++j) 
        {
            if (SamePairUnordered(VertexID1, VertexID2, TriangleVerts[j], TriangleVerts[(j + 1) % 3]))
            {
                return TriangleVerts[(j + 2) % 3];
            }
        }
        return IndexConstants::InvalidID;
    }
 
    inline int FindTriOtherVtx(int VertexID1, int VertexID2, const TDynamicVector<FIndex3i> & TriIndexArray, int TriangleIndex)
    {
        const FIndex3i& Triangle = TriIndexArray[TriangleIndex];
        for (int j = 0; j < 3; ++j)
        {
            if (SamePairUnordered(VertexID1, VertexID2, Triangle[j], Triangle[(j+1)%3]))
            {
                return Triangle[((j + 2) % 3)];
            }
        }
        return IndexConstants::InvalidID;
    }
 
 
 
    template<typename T, typename Vec>
    inline int FindTriOtherIndex(T VertexID1, T VertexID2, const Vec & TriangleVerts)
    {
        for (int j = 0; j < 3; ++j) 
        {
            if (SamePairUnordered(VertexID1, VertexID2, TriangleVerts[j], TriangleVerts[(j + 1) % 3]))
            {
                return (j + 2) % 3;
            }
        }
        return IndexConstants::InvalidID;
    }
 
 
    inline int GetOtherTriIndex(int i0, int i1)
    {
        // @todo can we do this with a formula? I don't see it right now.
        static const int values[4] = { 0, 2, 1, 0 };
        return values[i0+i1];
    }
 
 
    template<typename T, typename Vec>
    inline bool OrientTriEdge(T & Vertex1, T & Vertex2, const Vec & TriangleVerts)
    {
        if (Vertex1 == TriangleVerts[0]) 
        {
            if (TriangleVerts[2] == Vertex2) 
            {
                T Temp = Vertex1; Vertex1 = Vertex2; Vertex2 = Temp;
                return true;
            }
        }
        else if (Vertex1 == TriangleVerts[1]) 
        {
            if (TriangleVerts[0] == Vertex2) 
            {
                T Temp = Vertex1; Vertex1 = Vertex2; Vertex2 = Temp;
                return true;
            }
        }
        else if (Vertex1 == TriangleVerts[2]) 
        {
            if (TriangleVerts[1] == Vertex2) 
            {
                T Temp = Vertex1; Vertex1 = Vertex2; Vertex2 = Temp;
                return true;
            }
        }
        return false;
    }
 
 
    template<typename T, typename Vec>
    inline int OrientTriEdgeAndFindOtherVtx(T & Vertex1, T & Vertex2, const Vec & TriangleVerts)
    {
        for (int j = 0; j < 3; ++j) 
        {
            if (SamePairUnordered(Vertex1, Vertex2, TriangleVerts[j], TriangleVerts[(j + 1) % 3]))
            {
                Vertex1 = TriangleVerts[j];
                Vertex2 = TriangleVerts[(j + 1) % 3];
                return TriangleVerts[(j + 2) % 3];
            }
        }
        return IndexConstants::InvalidID;
    }
 
 
    template<typename Func>
    void ApplyMap(FIndex3i & Val, Func MapFunc)
    {
        Val[0] = MapFunc[Val[0]];
        Val[1] = MapFunc[Val[1]];
        Val[2] = MapFunc[Val[2]];
    }
 
    template<typename T, typename Func>
    void ApplyMap(UE::Math::TVector<T> & Val, Func MapFunc)
    {
        Val[0] = MapFunc[Val[0]];
        Val[1] = MapFunc[Val[1]];
        Val[2] = MapFunc[Val[2]];
    }
 
 
    template<typename Func>
    FIndex3i ApplyMap(const FIndex3i & Val, Func MapFunc)
    {
        return FIndex3i(MapFunc[Val[0]], MapFunc[Val[1]], MapFunc[Val[2]]);
    }
 
 
    template<typename T, typename Func>
    UE::Math::TVector<T> ApplyMap(const UE::Math::TVector<T> & Val, Func MapFunc)
    {
        return UE::Math::TVector<T>(MapFunc[Val[0]], MapFunc[Val[1]], MapFunc[Val[2]]);
    }
    
    template<typename T, typename Func>
    bool ArrayCheck(const TArray<T>& ToCheck, Func CheckFn)
    {
        for (const T& Value : ToCheck)
        {
            if (!CheckFn(Value))
            {
                return false;
            }
        }
        return true;
    }
 
    extern GEOMETRYCORE_API const FVector2i GridOffsets4[4];
 
    extern GEOMETRYCORE_API const FVector2i GridOffsets8[8];
 
    extern GEOMETRYCORE_API const FVector3i GridOffsets6[6];
 
    extern GEOMETRYCORE_API const FVector3i GridOffsets26[26];
 
    extern GEOMETRYCORE_API const int BoxFaces[6][4];
 
    extern GEOMETRYCORE_API const FVector2i BoxFacesUV[4];
 
    extern GEOMETRYCORE_API const int BoxFaceNormals[6];
 
 
    // @todo other index array constants
}