CompactMaps.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Index remapping struct extracted from Dynamic Mesh for more general use
 
#pragma once
 
#include "Containers/Array.h"
 
#include "IndexTypes.h"
 
namespace UE
{
namespace Geometry
{
class FCompactMaps
{
    TArray<int32> VertMap;
    TArray<int32> TriMap;
 
public:
    constexpr static int32 InvalidID = IndexConstants::InvalidID;
 
    void SetIdentity(int32 NumVertMappings, int32 NumTriMappings)
    {
        SetIdentityVertexMap(NumVertMappings);
        SetIdentityTriangleMap(NumTriMappings);
    }
 
    void SetIdentityVertexMap(int32 NumVertMappings)
    {
        VertMap.SetNumUninitialized(NumVertMappings);
        for (int32 i = 0; i < NumVertMappings; ++i)
        {
            VertMap[i] = i;
        }
    }
 
    void SetIdentityTriangleMap(int32 NumTriMappings)
    {
        TriMap.SetNumUninitialized(NumTriMappings);
        for (int32 i = 0; i < NumTriMappings; ++i)
        {
            TriMap[i] = i;
        }
    }
 
    void Reset(int32 NumVertMappings, int32 NumTriMappings, bool bInitializeWithInvalidID)
    {
        ResetVertexMap(NumVertMappings, bInitializeWithInvalidID);
        ResetTriangleMap(NumTriMappings, bInitializeWithInvalidID);
    }
 
    void ResetVertexMap(int32 NumVertMappings, bool bInitializeWithInvalidID)
    {
        VertMap.SetNumUninitialized(NumVertMappings);
        if (bInitializeWithInvalidID)
        {
            for (int32 i = 0; i < NumVertMappings; i++)
            {
                VertMap[i] = InvalidID;
            }
        }
    }
 
    void ResetTriangleMap(int32 NumTriMappings, bool bInitializeWithInvalidID)
    {
        TriMap.SetNumUninitialized(NumTriMappings);
        if (bInitializeWithInvalidID)
        {
            for (int32 i = 0; i < NumTriMappings; ++i)
            {
                TriMap[i] = InvalidID;
            }
        }
    }
 
    void Reset()
    {
        VertMap.Reset();
        TriMap.Reset();
    }
 
    bool VertexMapIsSet() const
    {
        return !VertMap.IsEmpty();
    }
 
    bool TriangleMapIsSet() const
    {
        return !TriMap.IsEmpty();
    }
 
    int32 NumVertexMappings() const
    {
        return VertMap.Num();
    }
 
    int32 NumTriangleMappings() const
    {
        return TriMap.Num();
    }
 
    void SetVertexMapping(int32 FromID, int32 ToID)
    {
        checkSlow(FromID >= ToID);
        VertMap[FromID] = ToID;
    }
 
    void SetTriangleMapping(int32 FromID, int32 ToID)
    {
        checkSlow(FromID >= ToID);
        TriMap[FromID] = ToID;
    }
 
    int32 GetVertexMapping(int32 FromID) const
    {
        return VertMap[FromID];
    }
 
    FIndex3i GetVertexMapping(FIndex3i FromIDs) const
    {
        return {VertMap[FromIDs[0]], VertMap[FromIDs[1]], VertMap[FromIDs[2]]};
    }
 
    int32 GetTriangleMapping(int32 FromID) const
    {
        return TriMap[FromID];
    }
 
    bool Validate() const
    {
        for (int32 Idx = 0; Idx < VertMap.Num(); Idx++)
        {
            if (VertMap[Idx] > Idx)
            {
                return false;
            }
        }
        for (int32 Idx = 0; Idx < TriMap.Num(); Idx++)
        {
            if (TriMap[Idx] > Idx)
            {
                return false;
            }
        }
        return true;
    }
};
} // end namespace UE::Geometry
} // end namespace UE