DynamicMeshEditor.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Port of geometry3Sharp MeshEditor
 
#pragma once
 
#include "DynamicMesh/DynamicMesh3.h"
#include "DynamicMesh/DynamicMeshAttributeSet.h"
#include "EdgeLoop.h"
#include "Util/SparseIndexCollectionTypes.h"
#include "DynamicMesh/MeshIndexMappings.h"
#include "MeshAdapter.h"
 
namespace UE
{
namespace Geometry
{
 
struct FDynamicSubmesh3;
 
struct FDynamicMeshEditResult
{
    TArray<int> NewVertices;
 
    TArray<int> NewTriangles;
    TArray<FIndex2i> NewQuads;
    TArray<TArray<int>> NewPolygons;
 
    TArray<int> NewGroups;
 
    TArray<TArray<int32>> NewNormalOverlayElements;
 
    TArray<int32> NewColorOverlayElements;
 
    void Reset()
    {
        NewVertices.Reset();
        NewTriangles.Reset();
        NewQuads.Reset();
        NewPolygons.Reset();
        NewGroups.Reset();
        NewNormalOverlayElements.Reset();
        NewColorOverlayElements.Reset();
    }
 
    GEOMETRYCORE_API void GetAllTriangles(TArray<int>& TrianglesOut) const;
};
 
 
 
 
class FDynamicMeshEditor
{
public:
    FDynamicMesh3* Mesh;
 
    FDynamicMeshEditor(FDynamicMesh3* MeshIn)
    {
        Mesh = MeshIn;
    }
 
    GEOMETRYCORE_API bool RemoveIsolatedVertices();
 
    // Create and Remove Triangle Functions
 
    GEOMETRYCORE_API bool StitchVertexLoopsMinimal(const TArray<int>& VertexLoop1, const TArray<int>& VertexLoop2, FDynamicMeshEditResult& ResultOut);
 
 
    GEOMETRYCORE_API bool StitchVertexLoopToTriVidPairSequence(
        const TArray<TPair<int32, TPair<int8, int8>>>& TriVidPairs1,
        const TArray<int>& VertexLoop2, FDynamicMeshEditResult& ResultOut);
 
    static GEOMETRYCORE_API bool ConvertLoopToTriVidPairSequence(const FDynamicMesh3& Mesh,
        const TArray<int32>& VidLoop, const TArray<int32>& EdgeLoop,
        TArray<TPair<int32, TPair<int8, int8>>>& TriVertPairsOut);
 
    GEOMETRYCORE_API bool StitchSparselyCorrespondedVertexLoops(const TArray<int>& VertexIDs1, const TArray<int>& MatchedIndices1, const TArray<int>& VertexIDs2, const TArray<int>& MatchedIndices2, FDynamicMeshEditResult& ResultOut, bool bReverseOrientation = false);
 
 
    GEOMETRYCORE_API bool WeldVertexLoops(const TArray<int32>& VertexLoop1, const TArray<int32>& VertexLoop2);
 
 
    GEOMETRYCORE_API bool AddTriangleFan_OrderedVertexLoop(int CenterVertex, const TArray<int>& VertexLoop, int GroupID, FDynamicMeshEditResult& ResultOut);
 
 
    GEOMETRYCORE_API void DuplicateTriangles(const TArray<int>& Triangles, FMeshIndexMappings& IndexMaps, FDynamicMeshEditResult& ResultOut);
 
 
    struct FLoopPairSet
    {
        TArray<int32> OuterVertices;
        TArray<int32> OuterEdges;
 
        TArray<int32> InnerVertices;
        TArray<int32> InnerEdges;
 
        bool bOuterIncludesIsolatedVertices;
    };
 
    GEOMETRYCORE_API bool DisconnectTriangles(const TArray<int>& Triangles, TArray<FLoopPairSet>& LoopSetOut, bool bHandleBoundaryVertices);
 
    GEOMETRYCORE_API bool DisconnectTriangles(const TSet<int>& TriangleSet, const TArray<FEdgeLoop>& BoundaryLoops, TArray<FLoopPairSet>& LoopSetOut, bool bAllowBoundaryVertices);
 
    GEOMETRYCORE_API bool DisconnectTrianglesAlongEdges(const TSet<int32>& Edges, TArray<int32>* AddedVertexIDs = nullptr);
 
 
 
    GEOMETRYCORE_API void DisconnectTriangles(const TArray<int>& Triangles, bool bPreventBowties = true);
 
 
    GEOMETRYCORE_API void SplitBowties(FDynamicMeshEditResult& ResultOut);
 
    void SplitBowties(int VertexID, TArray<int32>* NewVertices = nullptr)
    {
        TArray<int> Triangles, ContiguousGroupLengths;
        TArray<bool> GroupIsLoop;
        SplitBowtiesInternal(VertexID, Triangles, ContiguousGroupLengths, GroupIsLoop, NewVertices);
    }
 
private:
    // Internal version of split bowties that takes some arrays for reusable storage
    GEOMETRYCORE_API void SplitBowtiesInternal(int VertexID, TArray<int>& Triangles, TArray<int>& ContiguousGroupLengths, TArray<bool>& GroupIsLoop, TArray<int32>* NewVertices = nullptr);
public:
 
    void SplitBowties(int VertexID, FDynamicMeshEditResult& ResultOut)
    {
        SplitBowties(VertexID, &ResultOut.NewVertices);
    }
 
    GEOMETRYCORE_API void SplitBowtiesAtTriangles(const TArray<int32>& TriangleIDs, FDynamicMeshEditResult& ResultOut);
 
    enum class EDuplicateTriBehavior : uint8
    {
        EnsureContinue,         
        EnsureAbort, UseExisting, Replace
    };
 
    GEOMETRYCORE_API bool ReinsertSubmesh(const FDynamicSubmesh3& Submesh, FOptionallySparseIndexMap& SubToNewV, TArray<int>* NewTris = nullptr,
                         EDuplicateTriBehavior DuplicateBehavior = EDuplicateTriBehavior::EnsureAbort);
 
    GEOMETRYCORE_API bool RemoveTriangles(const TArray<int>& Triangles, bool bRemoveIsolatedVerts);
 
 
    GEOMETRYCORE_API int RemoveSmallComponents(double MinVolume, double MinArea = 0.0, int MinTriangleCount = 0);
 
 
    GEOMETRYCORE_API bool RemoveTriangles(const TArray<int>& Triangles, bool bRemoveIsolatedVerts, TFunctionRef<void(int)> OnRemoveTriFunc);
 
 
    // Normal utility functions
 
    GEOMETRYCORE_API void ReverseTriangleOrientations(const TArray<int>& Triangles, bool bInvertNormals);
 
    GEOMETRYCORE_API void InvertTriangleNormals(const TArray<int>& Triangles);
 
 
    GEOMETRYCORE_API FVector3f ComputeAndSetQuadNormal(const FIndex2i& QuadTris, bool bIsPlanar = false);
 
 
    GEOMETRYCORE_API void SetQuadNormals(const FIndex2i& QuadTris, const FVector3f& Normal);
 
    GEOMETRYCORE_API void SetTriangleNormals(const TArray<int>& Triangles, const FVector3f& Normal);
 
    GEOMETRYCORE_API void SetTriangleNormals(const TArray<int>& Triangles);
 
    GEOMETRYCORE_API void SetTubeNormals(const TArray<int>& Triangles, const TArray<int>& VertexIDs1, const TArray<int>& MatchedIndices1, const TArray<int>& VertexIDs2, const TArray<int>& MatchedIndices2, bool bReverseNormals = false);
 
 
    // UV utility functions
 
 
    GEOMETRYCORE_API void SetQuadUVsFromProjection(const FIndex2i& QuadTris, const FFrame3d& ProjectionFrame, float UVScaleFactor = 1.0f, const FVector2f& UVTranslation = FVector2f::Zero(), int UVLayerIndex = 0);
 
    GEOMETRYCORE_API void SetTriangleUVsFromProjection(const TArray<int32>& Triangles, const FFrame3d& ProjectionFrame, 
        float UVScaleFactor = 1.0f, const FVector2f& UVTranslation = FVector2f::Zero(), bool bShiftToOrigin = true, int32 UVLayerIndex = 0);
 
    GEOMETRYCORE_API void SetTriangleUVsFromProjection(const TArray<int>& Triangles, const FFrame3d& ProjectionFrame, 
        const FVector2f& UVScale = FVector2f::One(), const FVector2f& UVTranslation = FVector2f::Zero(), int UVLayerIndex = 0,
        bool bShiftToOrigin = true, bool bNormalizeBeforeScaling = false);
 
    GEOMETRYCORE_API void SetGeneralTubeUVs(const TArray<int>& Triangles, const TArray<int>& VertexIDs1, const TArray<int>& MatchedIndices1, const TArray<int>& VertexIDs2, const TArray<int>& MatchedIndices2, const TArray<float>& UValues, const FVector3f& VDir, float UVScaleFactor = 1.0f, const FVector2f& UVTranslation = FVector2f::Zero(), int UVLayerIndex = 0);
 
    GEOMETRYCORE_API void RescaleAttributeUVs(float UVScale = 1.0f, bool bWorldSpace = false, int UVLayerIndex = 0, TOptional<FTransformSRT3d> ToWorld = TOptional<FTransformSRT3d>());
 
 
    // mesh element copying / duplication
 
 
    GEOMETRYCORE_API int FindOrCreateDuplicateVertex(int VertexID, FMeshIndexMappings& IndexMaps, FDynamicMeshEditResult& ResultOut);
 
    GEOMETRYCORE_API int FindOrCreateDuplicateGroup(int TriangleID, FMeshIndexMappings& IndexMaps, FDynamicMeshEditResult& ResultOut);
 
    GEOMETRYCORE_API int FindOrCreateDuplicateUV(int ElementID, int UVLayerIndex, FMeshIndexMappings& IndexMaps);
 
    GEOMETRYCORE_API int FindOrCreateDuplicateNormal(int ElementID, int NormalLayerIndex, FMeshIndexMappings& IndexMaps, FDynamicMeshEditResult* ResultOut = nullptr);
 
    GEOMETRYCORE_API int FindOrCreateDuplicateColor(int ElementID, FMeshIndexMappings& IndexMaps, FDynamicMeshEditResult* ResultOut);
    
    GEOMETRYCORE_API void CopyAttributes(int FromTriangleID, int ToTriangleID, FMeshIndexMappings& IndexMaps, FDynamicMeshEditResult& ResultOut);
 
 
 
 
    GEOMETRYCORE_API void AppendMesh(const FDynamicMesh3* AppendMesh, FMeshIndexMappings& IndexMapsOut, 
        TFunction<FVector3d(int, const FVector3d&)> PositionTransform = nullptr,
        TFunction<FVector3d(int, const FVector3d&)> NormalTransform = nullptr,
        bool bReverseOrientation = false);
 
    GEOMETRYCORE_API void AppendMesh(const TTriangleMeshAdapter<double>* AppendMesh, FMeshIndexMappings& IndexMapsOut,
        TFunction<FVector3d(int, const FVector3d&)> PositionTransform = nullptr);
 
 
    GEOMETRYCORE_API void AppendNormals(const FDynamicMesh3* AppendMesh,
        const FDynamicMeshNormalOverlay* FromNormals, FDynamicMeshNormalOverlay* ToNormals,
        const FIndexMapi& VertexMap, const FIndexMapi& TriangleMap,
        TFunction<FVector3d(int, const FVector3d&)> NormalTransform,
        FIndexMapi& NormalMapOut);
 
 
    GEOMETRYCORE_API void AppendUVs(const FDynamicMesh3* AppendMesh,
        const FDynamicMeshUVOverlay* FromUVs, FDynamicMeshUVOverlay* ToUVs,
        const FIndexMapi& VertexMap, const FIndexMapi& TriangleMap,
        FIndexMapi& UVMapOut);
 
    GEOMETRYCORE_API void AppendColors(const FDynamicMesh3* AppendMesh,
        const FDynamicMeshColorOverlay* FromOverlay, FDynamicMeshColorOverlay* ToOverlay,
        const FIndexMapi& VertexMap, const FIndexMapi& TriangleMap,
        FIndexMapi& ColorMapOut);
 
 
 
    template <typename RealType, int ElementSize>
    GEOMETRYCORE_API void AppendElementSubset(
        const FDynamicMesh3* FromMesh,
        const TSet<int>& TriangleROI,
        const TSet<int>& VertexROI,
        const TDynamicMeshOverlay<RealType, ElementSize>* FromOverlay,
        TDynamicMeshOverlay<RealType, ElementSize>* ToOverlay);
 
 
 
    GEOMETRYCORE_API void AppendTriangles(const FDynamicMesh3* SourceMesh, const TArrayView<const int>& SourceTriangles, FMeshIndexMappings& IndexMaps, FDynamicMeshEditResult& ResultOut, bool bComputeTriangleMap = true);
 
    static GEOMETRYCORE_API bool SplitMesh(const FDynamicMesh3* SourceMesh, TArray<FDynamicMesh3>& SplitMeshes, TFunctionRef<int(int)> TriIDToMeshID, int DeleteMeshID = -1, TArray<int32>* MeshIDPerSplitMesh = nullptr, bool bSortByMeshID = false);
 
    static GEOMETRYCORE_API bool RemoveSeamsAtEdges(const TSet<int32>& EidsToRemoveAsSeams, TDynamicMeshOverlay<float, 2>* Overlay);
    static GEOMETRYCORE_API bool RemoveSeamsAtEdges(const TSet<int32>& EidsToRemoveAsSeams, TDynamicMeshOverlay<float, 3>* Overlay);
 
    static GEOMETRYCORE_API bool CreateSeamsAtEdges(const TSet<int32>& EidsToMakeIntoSeams, TDynamicMeshOverlay<float, 2>* Overlay, TArray<int32>* AddedElementIDs = nullptr);
    static GEOMETRYCORE_API bool CreateSeamsAtEdges(const TSet<int32>& EidsToMakeIntoSeams, TDynamicMeshOverlay<float, 3>* Overlay, TArray<int32>* AddedElementIDs = nullptr);
 
};
 
 
} // end namespace UE::Geometry
} // end namespace UE