Fix SDF config bugs: skip redundant rebuilds, respect hydro patterns, protect non-replicate path

1. _build_sdf_on_mesh: return early when mesh.sdf already exists
   instead of clearing and rebuilding. Prevents N redundant SDF
   rebuilds when envs share mesh objects by reference.

2. _create_sdf_collision_from_visual: respect HydroelasticCfg
   shape_patterns when creating collision shapes from visual meshes.
   Previously applied hydroelastic unconditionally.

3. instantiate_builder_from_stage: use skip_mesh_approximation=True
   and selective convex hull approximation (same as newton_replicate
   path) to preserve triangle meshes needed for SDF.

4. Update test_sdf_config.py: test now expects no-op when SDF
   already exists on mesh.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: vidurv-nvidia

source/isaaclab_newton/isaaclab_newton/physics/newton_manager.py

@@ -392,7 +392,7 @@ def _build_sdf_on_mesh(mesh, sdf_cfg, res_overrides, label: str):
         if mesh is None:
             return
         if mesh.sdf is not None:
-            mesh.clear_sdf()
+            return  # SDF already built (shared by reference from prototype)
         resolution = sdf_cfg.max_resolution
         if res_overrides is not None:
             for pat, res in res_overrides:
@@ -431,18 +431,9 @@ def _create_sdf_collision_from_visual(
             if builder.shape_flags[si] & ShapeFlags.COLLIDE_SHAPES and builder.shape_body[si] in matched_bodies:
                 bodies_with_collision.add(builder.shape_body[si])
 
-        shape_cfg_kwargs = dict(
-            density=0.0,
-            has_shape_collision=True,
-            has_particle_collision=True,
-            is_visible=False,
-        )
-        if sdf_cfg.margin is not None:
-            shape_cfg_kwargs["margin"] = sdf_cfg.margin
-        if hydro_cfg is not None:
-            shape_cfg_kwargs["is_hydroelastic"] = True
-            shape_cfg_kwargs["kh"] = hydro_cfg.k_hydro
-        sdf_shape_cfg = ModelBuilder.ShapeConfig(**shape_cfg_kwargs)
+        hydro_patterns = None
+        if hydro_cfg is not None and hydro_cfg.shape_patterns is not None:
+            hydro_patterns = [re.compile(p) for p in hydro_cfg.shape_patterns]
 
         num_added = 0
         num_hydro = 0
@@ -461,16 +452,35 @@ def _create_sdf_collision_from_visual(
             cls._build_sdf_on_mesh(mesh, sdf_cfg, res_overrides, builder.shape_label[visual_si])
 
             body_lbl = builder.body_label[body_idx]
+            shape_label = f"{body_lbl}/sdf_collision"
+
+            # Check if this shape should get hydroelastic (respecting hydro shape_patterns)
+            apply_hydro = hydro_cfg is not None and (
+                hydro_patterns is None or any(p.search(shape_label) for p in hydro_patterns)
+            )
+
+            shape_cfg_kwargs = dict(
+                density=0.0,
+                has_shape_collision=True,
+                has_particle_collision=True,
+                is_visible=False,
+            )
+            if sdf_cfg.margin is not None:
+                shape_cfg_kwargs["margin"] = sdf_cfg.margin
+            if apply_hydro:
+                shape_cfg_kwargs["is_hydroelastic"] = True
+                shape_cfg_kwargs["kh"] = hydro_cfg.k_hydro
+
             builder.add_shape_mesh(
                 body=body_idx,
                 xform=builder.shape_transform[visual_si],
                 mesh=mesh,
                 scale=builder.shape_scale[visual_si],
-                cfg=sdf_shape_cfg,
-                label=f"{body_lbl}/sdf_collision",
+                cfg=ModelBuilder.ShapeConfig(**shape_cfg_kwargs),
+                label=shape_label,
             )
             num_added += 1
-            if hydro_cfg is not None:
+            if apply_hydro:
                 num_hydro += 1
 
         return num_added, num_hydro
@@ -703,14 +713,49 @@ def instantiate_builder_from_stage(cls):
             builder.add_usd(stage, ignore_paths=ignore_paths, schema_resolvers=schema_resolvers)
 
             # Build a prototype from the first env (all envs assumed identical)
+            # Use skip_mesh_approximation + load_visual_shapes to preserve
+            # triangle meshes needed for SDF (same as newton_replicate path).
             _, proto_path = env_paths[0]
             proto = ModelBuilder(up_axis=up_axis)
             proto.add_usd(
                 stage,
                 root_path=proto_path,
+                load_visual_shapes=True,
+                skip_mesh_approximation=True,
                 schema_resolvers=schema_resolvers,
             )
 
+            # Approximate non-SDF meshes with convex hulls (preserves SDF meshes)
+            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
+
+            if has_sdf_patterns:
+                from newton import GeoType
+
+                sdf_bodies: set[int] = set()
+                if body_pats is not None:
+                    for bi in range(len(proto.body_label)):
+                        if any(pat.search(proto.body_label[bi]) for pat in body_pats):
+                            sdf_bodies.add(bi)
+                approx_indices = []
+                for i in range(len(proto.shape_type)):
+                    if proto.shape_type[i] != GeoType.MESH:
+                        continue
+                    if proto.shape_body[i] in sdf_bodies:
+                        continue
+                    if shape_pats is not None:
+                        lbl = proto.shape_label[i] if i < len(proto.shape_label) else ""
+                        if any(pat.search(lbl) for pat in shape_pats):
+                            continue
+                    approx_indices.append(i)
+                if approx_indices:
+                    proto.approximate_meshes("convex_hull", shape_indices=approx_indices, keep_visual_shapes=True)
+            else:
+                proto.approximate_meshes("convex_hull", keep_visual_shapes=True)
+
             # Add each env as a separate Newton world
             xform_cache = UsdGeom.XformCache()
             for _, env_path in env_paths:

source/isaaclab_newton/test/physics/test_sdf_config.py

@@ -42,8 +42,8 @@ def test_builds_sdf_with_max_resolution(self):
 
         mesh.build_sdf.assert_called_once_with(narrow_band_range=(-0.1, 0.1), max_resolution=128)
 
-    def test_clears_existing_sdf_before_rebuild(self):
-        """Existing SDF on mesh is cleared before building a new one."""
+    def test_skips_rebuild_when_sdf_already_exists(self):
+        """Existing SDF on mesh is preserved (shared by reference from prototype)."""
         from isaaclab_newton.physics.newton_manager import NewtonManager
 
         mesh = MagicMock()
@@ -52,8 +52,8 @@ def test_clears_existing_sdf_before_rebuild(self):
 
         NewtonManager._build_sdf_on_mesh(mesh, sdf_cfg, None, "test_label")
 
-        mesh.clear_sdf.assert_called_once()
-        mesh.build_sdf.assert_called_once()
+        mesh.clear_sdf.assert_not_called()
+        mesh.build_sdf.assert_not_called()
 
     def test_target_voxel_size_takes_precedence(self):
         """When target_voxel_size is set, it is passed alongside max_resolution."""