Detect collisions of two meshes

Following code presents example of finding collision triangles of two meshes

• C++

  #include "MRMesh/MRMakeSphereMesh.h"
  #include "MRMesh/MRMesh.h"
  #include "MRMesh/MRMatrix3.h"
  #include "MRMesh/MRAffineXf.h"
  #include "MRMesh/MRMeshCollide.h"
  #include <iostream>
   
  int main()
  {
      auto meshA = MR::makeUVSphere(); // make mesh A
      auto meshB = MR::makeUVSphere(); // make mesh B
      meshB.transform( MR::AffineXf3f::translation( MR::Vector3f( 0.1f, 0.1f, 0.1f ) ) ); // shift mesh B for better demonstration
   
      auto collidingFacePairs = MR::findCollidingTriangles( meshA, meshB ); // find each pair of colliding faces
      for ( const auto [fa, fb] : collidingFacePairs )
          std::cout << int( fa ) << " " << int( fb ) << "\n"; // print each pair of colliding faces
   
      auto [collidingFaceBitSetA, collidingFaceBitSetB] = MR::findCollidingTriangleBitsets( meshA, meshB ); // find bitsets of colliding faces
      std::cout << collidingFaceBitSetA.count() << "\n"; // print number of colliding faces from mesh A
      std::cout << collidingFaceBitSetB.count() << "\n"; // print number of colliding faces from mesh B
   
   
      auto isColliding = !MR::findCollidingTriangles( meshA, meshB, nullptr, true ).empty(); // fast check if mesh A and mesh B collide
      std::cout << isColliding << "\n";
      return 0;
  }

• Python

  from meshlib import mrmeshpy as mm
   
  meshA = mm.makeUVSphere() # make mesh A
  meshB = mm.makeUVSphere() # make mesh B
  meshB.transform(mm.AffineXf3f.translation(mm.Vector3f(0.1,0.1,0.1))) # shift mesh B for better demonstration
   
  collidingFacePairs = mm.findCollidingTriangles(meshA,meshB) # find each pair of colliding faces
  for fp in collidingFacePairs:
      print(fp.aFace,fp.bFace) # print each pair of colliding faces
   
  collidingFaceBitSetA,collidingFaceBitSetB = mm.findCollidingTriangleBitsets(meshA,meshB) # find bitsets of colliding faces
  print(collidingFaceBitSetA.count()) # print number of colliding faces from mesh A
  print(collidingFaceBitSetB.count()) # print number of colliding faces from mesh B
   
  isColliding = not mm.findCollidingTriangles(meshA,meshB,firstIntersectionOnly=True).empty() # fast check if mesh A and mesh B collide
  print(isColliding)

• C

  #include "MRCMesh/MRMakeSphereMesh.h"
  #include "MRCMesh/MRAffineXf.h"
  #include "MRCMesh/MRMesh.h"
  #include "MRCMesh/MRMeshPart.h"
  #include "MRCMesh/MRMeshCollide.h"
  #include "MRCMesh/MRFaceFace.h"
  #include "MRCMesh/MRBitSet.h"
  #include <MRCMisc/std_vector_MR_FaceFace.h>
  #include <MRCMisc/std_pair_MR_FaceBitSet_MR_FaceBitSet.h>
  #include <MRCMisc/std_string.h>
   
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
   
  int main( void )
  {
      int rc = EXIT_FAILURE;
   
      MR_Mesh* meshA = MR_makeUVSphere( NULL, NULL, NULL ); // make mesh A
      MR_Mesh* meshB = MR_makeUVSphere( NULL, NULL, NULL ); // make mesh B
      MR_Vector3f shift = MR_Vector3f_Construct_3( 0.1f, 0.1f, 0.1f );
      MR_AffineXf3f xf = MR_AffineXf3f_translation( &shift );
      MR_Mesh_transform( meshB, &xf, NULL ); // shift mesh B for better demonstration
   
      MR_MeshPart* mpA = MR_MeshPart_Construct( meshA, NULL );
      MR_MeshPart* mpB = MR_MeshPart_Construct( meshB, NULL );
   
      MR_std_vector_MR_FaceFace* collidingFacePairs = MR_findCollidingTriangles( mpA, mpB, NULL, NULL ); // find each pair of colliding faces
   
      for ( MR_uint64_t i = 0; i < MR_std_vector_MR_FaceFace_Size( collidingFacePairs ); ++i )
      {
          // print each pair of colliding faces
          MR_FaceFace* ff = MR_std_vector_MR_FaceFace_At( collidingFacePairs, i );
          fprintf( stdout, "%d %d\n", *MR_FaceId_get( MR_FaceFace_Get_aFace( ff ) ), *MR_FaceId_get( MR_FaceFace_Get_bFace( ff ) ) );
      }
   
      // find bitsets of colliding faces
      MR_std_pair_MR_FaceBitSet_MR_FaceBitSet* collidingBitSets = MR_findCollidingTriangleBitsets( mpA, mpB, NULL );
   
      MR_uint64_t numColA = MR_BitSet_count(
          MR_FaceBitSet_UpcastTo_MR_BitSet(
              MR_std_pair_MR_FaceBitSet_MR_FaceBitSet_First( collidingBitSets ) ) );
      MR_uint64_t numColB = MR_BitSet_count(
          MR_FaceBitSet_UpcastTo_MR_BitSet(
              MR_std_pair_MR_FaceBitSet_MR_FaceBitSet_Second( collidingBitSets ) ) );
      fprintf( stdout, "%d\n", numColA ); // print number of colliding faces from mesh A
      fprintf( stdout, "%d\n", numColB ); // print number of colliding faces from mesh B
   
   
      // fast check if mesh A and mesh B collide
      bool firstIntersectionsOnly = true;
      MR_std_vector_MR_FaceFace* fastCheck = MR_findCollidingTriangles( mpA, mpB, NULL, &firstIntersectionsOnly );
      bool isColliding = !MR_std_vector_MR_FaceFace_IsEmpty( fastCheck );
      if ( isColliding )
          fprintf( stdout, "true\n" );
      else
          fprintf( stdout, "false\n" );
   
      MR_std_vector_MR_FaceFace_Destroy( fastCheck );
      MR_std_pair_MR_FaceBitSet_MR_FaceBitSet_Destroy( collidingBitSets );
      MR_std_vector_MR_FaceFace_Destroy( collidingFacePairs );
   
      MR_MeshPart_Destroy( mpB );
      MR_MeshPart_Destroy( mpA );
   
      MR_Mesh_Destroy( meshB );
      MR_Mesh_Destroy( meshA );
   
      rc = EXIT_SUCCESS;
      return rc;
  }