MeshBoolean.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// Port of geometry3Sharp MeshBoolean
 
#pragma once
 
#include "MathUtil.h"
#include "VectorTypes.h"
#include "GeometryTypes.h"
 
#include "DynamicMeshEditor.h"
 
#include "Spatial/FastWinding.h"
#include "DynamicMesh/DynamicMeshAABBTree3.h"
 
#include "Util/ProgressCancel.h"
 
 
namespace UE
{
namespace Geometry
{
 
 
 
class FMeshBoolean
{
public:
 
    //
    // Inputs
    //
    const FDynamicMesh3* Meshes[2];
    const FTransformSRT3d Transforms[2];
 
    enum class EBooleanOp
    {
        Union,
        Difference,
        Intersect,
        TrimInside,
        TrimOutside,
        NewGroupInside,
        NewGroupOutside
    };
    EBooleanOp Operation;
    
    
 
    double SnapTolerance = FMathf::ZeroTolerance * 1.0;
 
    bool bCollapseDegenerateEdgesOnCut = true;
    double DegenerateEdgeTolFactor = 1.5;
 
    double WindingThreshold = .5;
 
    bool bPutResultInInputSpace = true;
 
    bool bWeldSharedEdges = true;
 
    bool bTrackAllNewEdges = false;
 
    FProgressCancel* Progress = nullptr;
 
    bool bSimplifyAlongNewEdges = false;
    //
    // Simplification-specific settings (only relevant if bSimplifyAlongNewEdges==true):
    //
    double SimplificationAngleTolerance = .1;
    double TryToImproveTriQualityThreshold = .5;
    bool bPreserveTriangleGroups = true;
    bool bPreserveVertexUVs = true;
    bool bPreserveOverlayUVs = true;
    float UVDistortTolerance = FMathf::ZeroTolerance;
    bool bPreserveVertexNormals = true;
    float NormalDistortTolerance = .01f;
    int PreserveUVsOnlyForMesh = -1;
 
 
 
    //
    // Input & Output (to be modified by algorithm)
    //
 
    // An existing mesh, to be filled with the boolean result
    FDynamicMesh3* Result;
 
    //
    // Output
    //
 
    FTransformSRT3d ResultTransform;
 
    TArray<int> CreatedBoundaryEdges;
 
    TSet<int32> AllNewEdges;
 
    bool bPopulateSecondMeshGroupMap = false;
    FIndexMapi SecondMeshGroupMap;
 
    // If set, will be populated with an array of source mesh indices per TriangleID in the result mesh,
    // indicating if that triangle was from the Meshes[0] or Meshes[1] source.
    // Note: For non-compact meshes, invalid triangle IDs will have arbitrary indices.
    TOptional<TArray<int8>> TrackPerTriangleSourceMesh;
 
public:
 
    FMeshBoolean(const FDynamicMesh3* MeshA, const FTransformSRT3d& TransformA, const FDynamicMesh3* MeshB, const FTransformSRT3d& TransformB,
                 FDynamicMesh3* OutputMesh, EBooleanOp Operation)
        : Meshes{ MeshA, MeshB }, Transforms{ TransformA, TransformB }, Operation(Operation), Result(OutputMesh)
    {
        check(MeshA != nullptr && MeshB != nullptr && OutputMesh != nullptr);
    }
 
    FMeshBoolean(const FDynamicMesh3* MeshA, const FDynamicMesh3* MeshB, FDynamicMesh3* OutputMesh, EBooleanOp Operation)
        : Meshes{ MeshA, MeshB }, Transforms{ FTransformSRT3d::Identity(), FTransformSRT3d::Identity() }, Operation(Operation), Result(OutputMesh)
    {
        check(MeshA != nullptr && MeshB != nullptr && OutputMesh != nullptr);
    }
 
    virtual ~FMeshBoolean()
    {}
    
    EOperationValidationResult Validate()
    {
        // @todo validate inputs
        return EOperationValidationResult::Ok;
    }
 
    GEOMETRYCORE_API bool Compute();
 
    // Data passed to the FCustomInsideMeshTest::IsPointInsideFn
    struct FCustomInsideTestContext
    {
        // AABB Tree for the test mesh; always non-null
        FDynamicMeshAABBTree3* Spatial;
        // Note: OptionalWindingTree will be null when FCustomInsideMeshTest has bRequiresWinding == false
        TFastWindingTree<FDynamicMesh3>* OptionalWindingTree;
    };
 
    // Function type for custom inside/outside query functions
    // Note: If implementing a custom function that needs to access the underlying mesh, it is accessible via Context.Spatial->GetMesh()
    using TestInsideFunctionType = TFunction<bool(const FVector3d& TestPosition, const FCustomInsideTestContext& Context)>;
    struct FCustomInsideMeshTest
    {
        TestInsideFunctionType IsPointInsideFn;
        bool bRequiresWinding = true;
 
        FCustomInsideMeshTest(TestInsideFunctionType IsPointInsideFn, bool bRequiresWinding = true)
            : IsPointInsideFn(IsPointInsideFn), bRequiresWinding(bRequiresWinding)
        {}
    };
 
    GEOMETRYCORE_API bool ComputeWithCustomInside(FCustomInsideMeshTest TestMeshA, FCustomInsideMeshTest TestMeshB);
 
protected:
    virtual bool Cancelled()
    {
        return (Progress == nullptr) ? false : Progress->Cancelled();
    }
 
private:
 
    GEOMETRYCORE_API int FindNearestEdge(const FDynamicMesh3& OnMesh, const TArray<int>& EIDs, FVector3d Pos);
 
    GEOMETRYCORE_API bool MergeEdges(const FMeshIndexMappings& IndexMaps, FDynamicMesh3* CutMesh[2], const TArray<int> CutBoundaryEdges[2], const TMap<int, int>& AllVIDMatches);
 
    GEOMETRYCORE_API void SimplifyAlongNewEdges(int NumMeshesToProcess, FDynamicMesh3* CutMesh[2], TArray<int> CutBoundaryEdges[2], TMap<int, int>& AllVIDMatches);
 
};
 
 
} // end namespace UE::Geometry
} // end namespace UE