Fix VisACD selection propagation through Spawn

embodichain/lab/sim/shapes.py

@@ -65,7 +65,11 @@ class MeshCollisionCfg:
     """Maximum hull count for ``convex_decomposition``; must be at least two."""
 
     acd_method: Literal["visacd", "coacd", "vhacd"] | None = None
-    """Approximate-convex-decomposition implementation."""
+    """Approximate-convex-decomposition implementation.
+
+    ``None`` selects ``visacd`` when compiling mesh collision geometry.
+    VisACD requires a DexSim build with CUDA/OptiX support.
+    """
 
     sdf_resolution: int | None = None
     """Maximum SDF grid resolution; valid only for the ``sdf`` strategy."""

embodichain/lab/sim/spawn/descriptors.py

@@ -302,14 +302,18 @@ def rigid_desc_from_cfg(
             newton_solver_type=newton_solver_type,
         )
     )
-    geometry, approximation, max_hulls = _compile_geometry(cfg)
+    geometry, approximation, max_hulls, acd_method = _compile_geometry(cfg)
     material_ref, material_entry = _compile_visual_material(
         uid, cfg.shape.visual_material
     )
     collision = CollisionDesc.from_geometry(
         geometry,
         approximation=approximation,
     )
+    if approximation == CollisionApproximation.CONVEX_DECOMPOSITION:
+        # Construct the declared field rather than attaching a dynamic attribute
+        # that older DexSim versions would silently ignore during cooking.
+        collision = replace(collision, decomp_algorithm=acd_method)
     collision.enable_collision = physics.collision_enabled
     collision.decomp_max_hulls = max_hulls
     collision.dexsim = _compile_default_collision(physics)
@@ -1581,7 +1585,7 @@ def _compile_newton_collision(
 
 def _compile_geometry(
     cfg: RigidObjectCfg,
-) -> tuple[GeometryDesc, CollisionApproximation, int]:
+) -> tuple[GeometryDesc, CollisionApproximation, int, str]:
     shape = cfg.shape
     if isinstance(shape, MeshCfg):
         geometry = _mesh_geometry_from_cfg(shape, segment_name=cfg.uid or "mesh")
@@ -1604,10 +1608,10 @@ def _compile_geometry(
         # RigidObject after Spawn has created the file-backed mesh.
         if (
             collision_cfg.approximation == "convex_decomposition"
-            and acd_method not in ("visacd", "coacd")
+            and acd_method not in ("visacd", "coacd", "vhacd")
         ):
             raise ValueError(
-                "Spawn supports only acd_method='visacd' or 'coacd' "
+                "Spawn supports only acd_method='visacd', 'coacd', or 'vhacd' "
                 "for convex_decomposition."
             )
         if collision_cfg.sdf_resolution is not None:
@@ -1620,13 +1624,14 @@ def _compile_geometry(
             geometry,
             approximation,
             max(1, max_hulls),
+            acd_method,
         )
 
     if isinstance(shape, CubeCfg):
         size = tuple(float(value) for value in shape.size)
         if len(size) != 3 or any(value <= 0 for value in size):
             raise ValueError("CubeCfg.size must contain three positive values.")
-        return GeometryDesc.cube(size), CollisionApproximation.NONE, 1
+        return GeometryDesc.cube(size), CollisionApproximation.NONE, 1, "coacd"
 
     if isinstance(shape, SphereCfg):
         if shape.radius <= 0:
@@ -1635,6 +1640,7 @@ def _compile_geometry(
             GeometryDesc.sphere(float(shape.radius)),
             CollisionApproximation.NONE,
             1,
+            "coacd",
         )
 
     raise NotImplementedError(

tests/sim/spawn/test_descriptors.py

@@ -1010,6 +1010,35 @@ def test_dynamic_triangle_mesh_collision_is_rejected_before_spawn() -> None:
         rigid_desc_from_cfg(cfg)
 
 
+@pytest.mark.parametrize(
+    ("method", "expected"),
+    [(None, "visacd"), ("visacd", "visacd"), ("coacd", "coacd"), ("vhacd", "vhacd")],
+)
+def test_spawn_forwards_convex_decomposition_algorithm(
+    method: str | None, expected: str
+) -> None:
+    cfg = RigidObjectCfg.from_dict(
+        {
+            "uid": "mesh",
+            "shape": {
+                "shape_type": "Mesh",
+                "fpath": "mesh.glb",
+                "collision": {
+                    "approximation": "convex_decomposition",
+                    "max_hulls": 8,
+                    "acd_method": method,
+                },
+            },
+        }
+    )
+    descriptor, _ = rigid_desc_from_cfg(cfg)
+
+    collision = descriptor.collisions[0]
+    assert collision.approximation == CollisionApproximation.CONVEX_DECOMPOSITION
+    assert collision.decomp_max_hulls == 8
+    assert collision.decomp_algorithm == expected
+
+
 def test_spawn_rejects_unsupported_convex_decomposition_method() -> None:
     cfg = RigidObjectCfg(
         uid="mesh",
@@ -1018,12 +1047,13 @@ def test_spawn_rejects_unsupported_convex_decomposition_method() -> None:
             collision=MeshCollisionCfg(
                 approximation="convex_decomposition",
                 max_hulls=4,
-                acd_method="vhacd",
+                acd_method="coacd",
             ),
         ),
     )
 
-    with pytest.raises(ValueError, match="acd_method='visacd' or 'coacd'"):
+    cfg.shape.collision.acd_method = "invalid"
+    with pytest.raises(ValueError, match="acd_method"):
         rigid_desc_from_cfg(cfg)