MeshShape: adopt TriMesh internal representation (issue #453)

.github/workflows/publish_dartpy.yml

@@ -98,15 +98,16 @@ jobs:
         uses: mozilla-actions/[email protected]
         with:
           disable_annotations: true
-          # Enable only when GitHub cache backend is available; otherwise skip.
-          use-gha-cache: ${{ env.ACTIONS_CACHE_URL != '' }}
 
       - name: Configure environment for compiler cache
         if: (matrix.skip-on-commit != true) || github.event_name == 'pull_request' || startsWith(github.ref, 'refs/tags/v')
         uses: ./.github/actions/configure-compiler-cache
 
       - name: Build wheel
         if: (matrix.skip-on-commit != true) || github.event_name == 'pull_request' || startsWith(github.ref, 'refs/tags/v')
+        env:
+          # Work around occasional sccache spawn failures on ubuntu-latest + Python 3.14 wheel builds.
+          DART_DISABLE_COMPILER_CACHE: ${{ (matrix.os == 'ubuntu-latest' && matrix.python-version == '314') && 'ON' || 'OFF' }}
         run: pixi run -e py${{ matrix.python-version }}-wheel wheel-build
 
       - name: Repair wheel

AGENTS.md

@@ -5,7 +5,7 @@ This file is a pointer board for agents working in this repository. Keep it conc
 ## Read First
 
 - Architectural, build, and workflow expectations live in `docs/onboarding` (start with `docs/onboarding/ci-cd.md` and `docs/onboarding/build-system.md`).
-- The day-to-day pixi workflow (install, config, build, test) is documented in `docs/onboarding/building.md`.
+- The day-to-day pixi workflow (install, config, build, lint, test) is documented in `docs/onboarding/building.md` and `docs/onboarding/testing.md`.
 - Coding standards, formatting, and contribution flow are in `CONTRIBUTING.md`.
 - Feature‑specific notes belong beside the code (e.g., README in the component directory) or in `docs/`.
 - Unified model loading API (`dart::io`) is documented in `docs/onboarding/io-parsing.md`.

cmake/DARTFindDependencies.cmake

@@ -165,6 +165,15 @@ if(DART_BUILD_GUI)
       ${IMGUI_BACKEND_HEADERS}
     )
 
+    if(WIN32 AND BUILD_SHARED_LIBS)
+      # ImGui does not export symbols by default; ensure an import library is
+      # generated so dart-gui can link against dart-imgui-lib on Windows.
+      set_target_properties(
+        ${imgui_library_name}
+        PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS ON
+      )
+    endif()
+
     # Configure include directories
     # Build tree: use fetched source directory
     # Install tree: use standard include paths (like system-installed imgui)

dart/collision/bullet/BulletCollisionDetector.cpp

@@ -60,6 +60,8 @@
 #include <algorithm>
 #include <vector>
 
+#include <cmath>
+
 namespace dart {
 namespace collision {
 
@@ -91,17 +93,15 @@ std::unique_ptr<btCollisionShape> createBulletEllipsoidMesh(
 std::unique_ptr<btCollisionShape> createBulletEllipsoidMultiSphere(
     const Eigen::Vector3d& radii);
 
-std::unique_ptr<btCollisionShape> createBulletCollisionShapeFromAssimpScene(
-    const Eigen::Vector3d& scale, const aiScene* scene);
-
-std::unique_ptr<btCollisionShape> createBulletCollisionShapeFromAssimpMesh(
-    const aiMesh* mesh);
+std::unique_ptr<btCollisionShape> createBulletCollisionShapeFromTriMesh(
+    const Eigen::Vector3d& scale,
+    const std::shared_ptr<math::TriMesh<double>>& mesh);
 
 template <typename HeightmapShapeT>
 std::unique_ptr<BulletCollisionShape> createBulletCollisionShapeFromHeightmap(
     const HeightmapShapeT* heightMap);
 
-bool isConvex(const aiMesh* mesh, float threshold = 0.001);
+bool isConvex(const math::TriMesh<double>& mesh, float threshold = 0.001f);
 
 } // anonymous namespace
 
@@ -649,17 +649,19 @@ BulletCollisionDetector::createBulletCollisionShape(
         std::move(bulletCollisionShape));
   } else if (const auto shapeMesh = shape->as<MeshShape>()) {
     const auto scale = shapeMesh->getScale();
-    const auto mesh = shapeMesh->getMesh();
+    const auto triMesh = shapeMesh->getTriMesh();
 
     auto bulletCollisionShape
-        = createBulletCollisionShapeFromAssimpScene(scale, mesh);
+        = createBulletCollisionShapeFromTriMesh(scale, triMesh);
 
     return std::make_unique<BulletCollisionShape>(
         std::move(bulletCollisionShape));
   } else if (const auto softMeshShape = shape->as<SoftMeshShape>()) {
-    const auto mesh = softMeshShape->getAssimpMesh();
+    const auto triMesh = softMeshShape->getTriMesh();
+    const Eigen::Vector3d scale = Eigen::Vector3d::Ones();
 
-    auto bulletCollisionShape = createBulletCollisionShapeFromAssimpMesh(mesh);
+    auto bulletCollisionShape
+        = createBulletCollisionShapeFromTriMesh(scale, triMesh);
 
     return std::make_unique<BulletCollisionShape>(
         std::move(bulletCollisionShape));
@@ -1015,62 +1017,40 @@ std::unique_ptr<btCollisionShape> createBulletEllipsoidMultiSphere(
 }
 
 //==============================================================================
-std::unique_ptr<btCollisionShape> createBulletCollisionShapeFromAssimpScene(
-    const Eigen::Vector3d& scale, const aiScene* scene)
+std::unique_ptr<btCollisionShape> createBulletCollisionShapeFromTriMesh(
+    const Eigen::Vector3d& scale,
+    const std::shared_ptr<math::TriMesh<double>>& mesh)
 {
-  auto triMesh = new btTriangleMesh();
-
-  for (auto i = 0u; i < scene->mNumMeshes; ++i) {
-    for (auto j = 0u; j < scene->mMeshes[i]->mNumFaces; ++j) {
-      btVector3 vertices[3];
-      for (auto k = 0u; k < 3; ++k) {
-        const aiVector3D& vertex
-            = scene->mMeshes[i]
-                  ->mVertices[scene->mMeshes[i]->mFaces[j].mIndices[k]];
-        vertices[k] = btVector3(
-            vertex.x * scale[0], vertex.y * scale[1], vertex.z * scale[2]);
-      }
-      triMesh->addTriangle(vertices[0], vertices[1], vertices[2]);
-    }
-  }
-  const bool makeConvexMesh
-      = scene->mNumMeshes == 1 && isConvex(scene->mMeshes[0]);
-  if (makeConvexMesh) {
-    auto convexMeshShape = std::make_unique<btConvexTriangleMeshShape>(triMesh);
-    convexMeshShape->setMargin(0.0f);
-    convexMeshShape->setUserPointer(triMesh);
-    return convexMeshShape;
-  } else {
-    auto gimpactMeshShape = std::make_unique<btGImpactMeshShape>(triMesh);
-    gimpactMeshShape->updateBound();
-    gimpactMeshShape->setUserPointer(triMesh);
-    return gimpactMeshShape;
+  if (!mesh) {
+    return nullptr;
   }
-}
 
-//==============================================================================
-std::unique_ptr<btCollisionShape> createBulletCollisionShapeFromAssimpMesh(
-    const aiMesh* mesh)
-{
   auto triMesh = new btTriangleMesh();
 
-  for (auto i = 0u; i < mesh->mNumFaces; ++i) {
-    btVector3 vertices[3];
-    for (auto j = 0u; j < 3; ++j) {
-      const aiVector3D& vertex = mesh->mVertices[mesh->mFaces[i].mIndices[j]];
-      vertices[j] = btVector3(vertex.x, vertex.y, vertex.z);
+  const auto& vertices = mesh->getVertices();
+  const auto& triangles = mesh->getTriangles();
+
+  for (const auto& triangle : triangles) {
+    btVector3 btVertices[3];
+    for (auto k = 0u; k < 3; ++k) {
+      const auto& vertex = vertices[triangle[k]];
+      btVertices[k] = btVector3(
+          vertex.x() * scale[0], vertex.y() * scale[1], vertex.z() * scale[2]);
     }
-    triMesh->addTriangle(vertices[0], vertices[1], vertices[2]);
+    triMesh->addTriangle(btVertices[0], btVertices[1], btVertices[2]);
   }
 
-  const bool makeConvexMesh = isConvex(mesh);
+  const bool makeConvexMesh = isConvex(*mesh);
+
   if (makeConvexMesh) {
     auto convexMeshShape = std::make_unique<btConvexTriangleMeshShape>(triMesh);
     convexMeshShape->setMargin(0.0f);
+    convexMeshShape->setUserPointer(triMesh);
     return convexMeshShape;
   } else {
     auto gimpactMeshShape = std::make_unique<btGImpactMeshShape>(triMesh);
     gimpactMeshShape->updateBound();
+    gimpactMeshShape->setUserPointer(triMesh);
     return gimpactMeshShape;
   }
 }
@@ -1144,43 +1124,54 @@ std::unique_ptr<BulletCollisionShape> createBulletCollisionShapeFromHeightmap(
 }
 
 //==============================================================================
-bool isConvex(const aiMesh* mesh, float threshold)
+bool isConvex(const math::TriMesh<double>& mesh, float threshold)
 {
-  // Check whether all the other vertices on the mesh is on the internal side of
-  // the face, assuming that the direction of the normal of the face is pointing
-  // external side.
+  // Check whether all the other vertices on the mesh are on the internal side
+  // of the face, assuming that the direction of the normal of the face is
+  // pointing to the external side.
   //
   // Reference: https://stackoverflow.com/a/40056279/3122234
+  const auto& points = mesh.getVertices();
+  const auto& triangles = mesh.getTriangles();
+
+  if (points.empty() || triangles.empty()) {
+    return false;
+  }
 
-  const auto points = mesh->mVertices;
   btVector3 vertices[3];
-  for (auto i = 0u; i < mesh->mNumFaces; ++i) {
+  for (const auto& triangle : triangles) {
     for (auto j = 0u; j < 3; ++j) {
-      const aiVector3D& vertex = mesh->mVertices[mesh->mFaces[i].mIndices[j]];
-      vertices[j] = btVector3(vertex.x, vertex.y, vertex.z);
+      const auto& vertex = points[triangle[j]];
+      vertices[j] = btVector3(vertex.x(), vertex.y(), vertex.z());
     }
     const btVector3& A = vertices[0];
     const btVector3 B = vertices[1] - A;
     const btVector3 C = vertices[2] - A;
 
-    const btVector3 BCNorm = B.cross(C).normalized();
+    const btVector3 BCNormRaw = B.cross(C);
+    const btScalar normSquared = BCNormRaw.length2();
+    if (normSquared <= btScalar(0.0)) {
+      continue;
+    }
+    const btVector3 BCNorm = BCNormRaw / btSqrt(normSquared);
 
-    const float checkPoint
-        = btVector3(
-              points[0].x - A.x(), points[0].y - A.y(), points[0].z - A.z())
-              .dot(BCNorm);
+    const float checkPoint = btVector3(
+                                 points[0].x() - A.x(),
+                                 points[0].y() - A.y(),
+                                 points[0].z() - A.z())
+                                 .dot(BCNorm);
 
-    for (auto j = 0u; j < mesh->mNumVertices; ++j) {
-      float dist
-          = btVector3(
-                points[j].x - A.x(), points[j].y - A.y(), points[j].z - A.z())
+    for (const auto& point : points) {
+      const float dist
+          = btVector3(point.x() - A.x(), point.y() - A.y(), point.z() - A.z())
                 .dot(BCNorm);
       if ((std::abs(checkPoint) > threshold) && (std::abs(dist) > threshold)
           && (checkPoint * dist < 0.0f)) {
         return false;
       }
     }
   }
+
   return true;
 }
 

dart/collision/bullet/BulletCollisionDetector.hpp

@@ -38,8 +38,6 @@
 #include <dart/collision/bullet/BulletCollisionShape.hpp>
 #include <dart/collision/bullet/BulletInclude.hpp>
 
-#include <assimp/scene.h>
-
 #include <unordered_map>
 #include <vector>
 

dart/collision/fcl/CollisionShapes.hpp

@@ -39,43 +39,13 @@
 
 #include <dart/math/Constants.hpp>
 
-#include <assimp/scene.h>
-
 #include <cmath>
 
 namespace dart {
 namespace collision {
 
-template <class BV>
-::fcl::BVHModel<BV>* createMesh(
-    double _scaleX,
-    double _scaleY,
-    double _scaleZ,
-    const aiScene* _mesh,
-    const dart::collision::fcl::Transform3& _transform)
-{
-  DART_ASSERT(_mesh);
-  ::fcl::BVHModel<BV>* model = new ::fcl::BVHModel<BV>;
-  model->beginModel();
-
-  for (unsigned int i = 0; i < _mesh->mNumMeshes; i++) {
-    for (unsigned int j = 0; j < _mesh->mMeshes[i]->mNumFaces; j++) {
-      dart::collision::fcl::Vector3 vertices[3];
-      for (unsigned int k = 0; k < 3; k++) {
-        const aiVector3D& vertex
-            = _mesh->mMeshes[i]
-                  ->mVertices[_mesh->mMeshes[i]->mFaces[j].mIndices[k]];
-        vertices[k] = dart::collision::fcl::Vector3(
-            vertex.x * _scaleX, vertex.y * _scaleY, vertex.z * _scaleZ);
-        vertices[k] = dart::collision::fcl::transform(_transform, vertices[k]);
-      }
-      model->addTriangle(vertices[0], vertices[1], vertices[2]);
-    }
-  }
-
-  model->endModel();
-  return model;
-}
+// Deprecated aiScene-based createMesh removed - use TriMesh-based alternatives
+// in FCLCollisionDetector instead
 
 template <class BV>
 ::fcl::BVHModel<BV>* createEllipsoid(