Adding Hydroelastic and SDF collision configuration to IsaacLab

source/isaaclab_newton/config/extension.toml

@@ -1,7 +1,7 @@
 [package]
 
 # Note: Semantic Versioning is used: https://semver.org/
-version = "0.5.9"
+version = "0.5.10"
 
 # Description
 title = "Newton simulation interfaces for IsaacLab core package"

source/isaaclab_newton/docs/CHANGELOG.rst

@@ -1,6 +1,25 @@
 Changelog
 ---------
 
+0.5.10 (2026-04-02)
+~~~~~~~~~~~~~~~~~~~
+
+Added
+^^^^^
+
+* Added :class:`~isaaclab_newton.physics.NewtonCollisionPipelineCfg` for configuring
+  Newton's collision pipeline parameters (broad phase, contact limits, triangle pairs).
+  Set via :attr:`~isaaclab_newton.physics.NewtonCfg.collision_cfg`.
+* Added :class:`~isaaclab_newton.physics.SDFCfg` for configuring SDF-based mesh
+  collisions via Newton's ``mesh.build_sdf()`` API. Supports per-body and per-shape
+  regex pattern matching, per-pattern resolution overrides, and optional creation of
+  collision shapes from visual meshes.
+* Added :class:`~isaaclab_newton.physics.HydroelasticCfg` for distributed surface
+  contacts computed via SDF overlap with marching cubes.
+* Added SDF pattern skip in the Newton cloner to preserve original triangle
+  meshes for shapes that will use SDF collision.
+
+
 0.5.9 (2026-03-16)
 ~~~~~~~~~~~~~~~~~~
 

source/isaaclab_newton/isaaclab_newton/cloner/newton_replicate.py

@@ -5,15 +5,17 @@
 
 from __future__ import annotations
 
+import re
 from collections.abc import Callable
 
 import torch
 import warp as wp
-from newton import ModelBuilder, solvers
+from newton import GeoType, ModelBuilder, solvers
 from newton._src.usd.schemas import SchemaResolverNewton, SchemaResolverPhysx
 
 from pxr import Usd, UsdGeom
 
+from isaaclab.physics import PhysicsManager
 from isaaclab.physics.scene_data_requirements import VisualizerPrebuiltArtifacts
 
 from isaaclab_newton.physics import NewtonManager
@@ -62,6 +64,17 @@ def _build_newton_builder_from_mapping(
     # The prototype is built from env_0 in absolute world coordinates.
     # add_builder xforms are deltas from env_0 so positions don't get double-counted.
     env0_pos = positions[0]
+
+    # SDF collision requires original triangle meshes for mesh.build_sdf().
+    # Convex hull approximation destroys the source geometry, so shapes
+    # matching SDF patterns must be excluded from approximation here.
+    # _apply_sdf_config() builds the SDF on each prototype after approximation.
+    cfg = PhysicsManager._cfg
+    sdf_cfg = getattr(cfg, "sdf_cfg", None) if cfg is not None else None
+    body_pats = [re.compile(x) for x in sdf_cfg.body_patterns] if sdf_cfg and sdf_cfg.body_patterns else None
+    shape_pats = [re.compile(x) for x in sdf_cfg.shape_patterns] if sdf_cfg and sdf_cfg.shape_patterns else None
+    has_sdf_patterns = body_pats is not None or shape_pats is not None
+
     protos: dict[str, ModelBuilder] = {}
     for src_path in sources:
         p = ModelBuilder(up_axis=up_axis)
@@ -74,7 +87,33 @@ def _build_newton_builder_from_mapping(
             schema_resolvers=schema_resolvers,
         )
         if simplify_meshes:
-            p.approximate_meshes("convex_hull", keep_visual_shapes=True)
+            if has_sdf_patterns:
+                sdf_bodies: set[int] = set()
+                if body_pats is not None:
+                    for bi in range(len(p.body_label)):
+                        if any(pat.search(p.body_label[bi]) for pat in body_pats):
+                            sdf_bodies.add(bi)
+
+                approx_indices = []
+                for i in range(len(p.shape_type)):
+                    if p.shape_type[i] != GeoType.MESH:
+                        continue
+                    # Skip shapes that will use SDF (matched by body or shape pattern)
+                    if p.shape_body[i] in sdf_bodies:
+                        continue
+                    if shape_pats is not None:
+                        lbl = p.shape_label[i] if i < len(p.shape_label) else ""
+                        if any(pat.search(lbl) for pat in shape_pats):
+                            continue
+                    approx_indices.append(i)
+                if approx_indices:
+                    p.approximate_meshes("convex_hull", shape_indices=approx_indices, keep_visual_shapes=True)
+            else:
+                p.approximate_meshes("convex_hull", keep_visual_shapes=True)
+        # Build SDF on prototype before add_builder copies it N times.
+        # Mesh objects are shared by reference, so SDF is built once and
+        # all environments inherit it.
+        NewtonManager._apply_sdf_config(p)
         protos[src_path] = p
 
     # create a separate world for each environment (heterogeneous spawning)

source/isaaclab_newton/isaaclab_newton/physics/__init__.pyi

@@ -5,12 +5,24 @@
 
 __all__ = [
     "FeatherstoneSolverCfg",
+    "HydroelasticCfg",
     "MJWarpSolverCfg",
     "NewtonCfg",
+    "NewtonCollisionPipelineCfg",
     "NewtonManager",
     "NewtonSolverCfg",
+    "SDFCfg",
     "XPBDSolverCfg",
 ]
 
 from .newton_manager import NewtonManager
-from .newton_manager_cfg import FeatherstoneSolverCfg, MJWarpSolverCfg, NewtonCfg, NewtonSolverCfg, XPBDSolverCfg
+from .newton_manager_cfg import (
+    FeatherstoneSolverCfg,
+    HydroelasticCfg,
+    MJWarpSolverCfg,
+    NewtonCfg,
+    NewtonCollisionPipelineCfg,
+    NewtonSolverCfg,
+    SDFCfg,
+    XPBDSolverCfg,
+)