MRMesh/MRMeshCollidePrecise.h

Go to the documentation of this file.

#pragma once
 
#include "MRId.h"
#include "MRMeshPart.h"
#include "MRPrecisePredicates3.h"
 
#include <functional>
 
namespace MR
{
 
 
struct EdgeTri
{
    EdgeId edge;
    FaceId tri;
    EdgeTri() = default;
    EdgeTri( EdgeId e, FaceId t ) : edge( e ), tri( t ) { }
};
 
inline bool operator==( const EdgeTri& a, const EdgeTri& b )
{
    return a.edge.undirected() == b.edge.undirected() && a.tri == b.tri;
}
 
struct VarEdgeTri
{
    EdgeId edge;
    struct FlaggedTri
    {
        unsigned int isEdgeATriB : 1 = 0;
        unsigned int face : 31 = 0;
        bool operator==( const FlaggedTri& ) const = default;
    } flaggedTri;
 
    [[nodiscard]] FaceId tri() const { return FaceId( flaggedTri.face ); }
    [[nodiscard]] bool isEdgeATriB() const { return bool( flaggedTri.isEdgeATriB ); }
    [[nodiscard]] EdgeTri edgeTri() const { return EdgeTri( edge, tri() ); }
 
    [[nodiscard]] bool valid() const { return edge.valid(); }
    [[nodiscard]] explicit operator bool() const { return edge.valid(); }
 
    VarEdgeTri() = default;
    VarEdgeTri( bool isEdgeATriB, EdgeId e, FaceId t )
    {
        assert( t.valid() );
        edge = e;
        flaggedTri.isEdgeATriB = isEdgeATriB;
        flaggedTri.face = t;
    }
    VarEdgeTri( bool isEdgeATriB, const EdgeTri& et ) : VarEdgeTri( isEdgeATriB, et.edge, et.tri ) {}
 
    [[nodiscard]] bool operator==( const VarEdgeTri& ) const = default;
};
static_assert( sizeof( VarEdgeTri ) == 8 );
 
using PreciseCollisionResult = std::vector<VarEdgeTri>;
 
MRMESH_API PreciseCollisionResult findCollidingEdgeTrisPrecise( const MeshPart & a, const MeshPart & b,
    ConvertToIntVector conv, const AffineXf3f* rigidB2A = nullptr, bool anyIntersection = false );
 
MRMESH_API std::vector<EdgeTri> findSelfCollidingEdgeTrisPrecise( const MeshPart& mp,
    ConvertToIntVector conv, bool anyIntersection = false, const AffineXf3f* rigidB2A = nullptr, int aVertSizes = 0 );
 
MRMESH_API std::vector<EdgeTri> findCollidingEdgeTrisPrecise( 
    const Mesh & a, const std::vector<EdgeId> & edgesA,
    const Mesh & b, const std::vector<FaceId> & facesB,
    ConvertToIntVector conv, const AffineXf3f * rigidB2A = nullptr );
 
MRMESH_API std::vector<EdgeTri> findCollidingEdgeTrisPrecise( 
    const Mesh & a, const std::vector<FaceId> & facesA,
    const Mesh & b, const std::vector<EdgeId> & edgesB,
    ConvertToIntVector conv, const AffineXf3f * rigidB2A = nullptr );
 
MRMESH_API CoordinateConverters getVectorConverters( const MeshPart& a );
 
MRMESH_API CoordinateConverters getVectorConverters( const MeshPart& a, const MeshPart& b,
    const AffineXf3f* rigidB2A = nullptr );
 
 
} // namespace MR