Drive fragment schema writers by prim path expressions

source/isaaclab/changelog.d/vidurv-descend-nested-fragments.rst

@@ -0,0 +1,9 @@
+Fixed
+^^^^^
+
+* Fixed :func:`~isaaclab.sim.schemas.apply_rigid_body_properties` and
+  :func:`~isaaclab.sim.schemas.apply_mass_properties` stopping at the outermost schema-bearing
+  prim on each branch. On assets with nested rigid-body hierarchies (child links authored under
+  their parent link prims, as produced by the URDF importer in Isaac Sim 6.0 and later), only
+  the outermost link received the fragment properties. The writers now modify every carrier in
+  the subtree, matching the legacy writers' full-subtree traversal.

source/isaaclab/changelog.d/vidurv-regex-fragment-targeting.minor.rst

@@ -0,0 +1,33 @@
+Added
+^^^^^
+
+* Added a trailing ``**`` token to prim path expressions in
+  :func:`~isaaclab.sim.utils.find_matching_prims`, matching a prim and all of its
+  descendants at any depth (instance proxies included).
+* Added per-family target-pattern fields to spawner configurations
+  (e.g. :attr:`~isaaclab.sim.spawners.RigidObjectSpawnerCfg.rigid_props_prim_path`,
+  :attr:`~isaaclab.sim.spawners.from_files.FileCfg.articulation_props_prim_path`),
+  selecting which prims of a spawned asset receive schema fragments. Patterns are
+  relative to the spawn prim; ``None`` keeps the previous behavior.
+* Added ``create_if_missing`` to the fragment schema writers and matching spawner
+  configuration flags (``mass_props_create_if_missing``,
+  ``articulation_props_create_if_missing``, ``joint_drive_props_create_if_missing``)
+  to apply a defining USD API to matched prims that do not carry it.
+
+Changed
+^^^^^^^
+
+* **Breaking:** Changed the fragment schema writers (e.g.
+  :func:`~isaaclab.sim.schemas.apply_rigid_body_properties`) to take a prim path
+  expression instead of traversing the subtree of the input prim. A bare prim path now
+  matches only that prim; pass ``f"{prim_path}/**"`` to recover the previous
+  subtree-wide behavior. Zero matched targets now log a warning and return ``False``
+  instead of raising ``ValueError`` on an invalid path.
+* **Breaking:** Changed the fragment schema writers to no longer apply their defining
+  USD API implicitly on bare prims; pass ``create_if_missing=True`` instead. For
+  articulation roots, anchoring on the spawn prim now requires setting
+  ``articulation_props_prim_path=""`` together with
+  ``articulation_props_create_if_missing=True`` on the spawner configuration.
+* **Breaking:** Changed :func:`~isaaclab.sim.schemas.apply_articulation_root_properties`
+  to raise ``ValueError`` when the expression matches nested articulation roots,
+  instead of silently pruning them; author a single root per articulation.

source/isaaclab/isaaclab/sim/converters/mesh_converter.py

@@ -132,7 +132,9 @@ def _convert_asset(self, cfg: MeshConverterCfg):
                         cfg.collision_props if isinstance(cfg.collision_props, (list, tuple)) else [cfg.collision_props]
                     )
                     if coll_frags and all(isinstance(f, SchemaFragment) for f in coll_frags):
-                        schemas.apply_collision_properties(str(child_mesh_prim.GetPath()), coll_frags, stage=stage)
+                        schemas.apply_collision_properties(
+                            str(child_mesh_prim.GetPath()), coll_frags, create_if_missing=True, stage=stage
+                        )
                     else:
                         schemas.define_collision_properties(
                             prim_path=child_mesh_prim.GetPath(), cfg=cfg.collision_props, stage=stage
@@ -208,14 +210,18 @@ def _convert_asset(self, cfg: MeshConverterCfg):
             # normalize a single fragment to a list so the convenience form routes like a list
             mass_frags = [cfg.mass_props] if isinstance(cfg.mass_props, SchemaFragment) else cfg.mass_props
             if isinstance(mass_frags, (list, tuple)) and all(isinstance(f, SchemaFragment) for f in mass_frags):
-                schemas.apply_mass_properties(str(xform_prim.GetPath()), mass_frags, stage=stage)
+                schemas.apply_mass_properties(
+                    str(xform_prim.GetPath()), mass_frags, create_if_missing=True, stage=stage
+                )
             else:
                 schemas.define_mass_properties(prim_path=xform_prim.GetPath(), cfg=cfg.mass_props, stage=stage)
         # apply rigid body properties (transition shim, remove later: fragment list -> apply_*; legacy cfg -> define_*)
         if cfg.rigid_props is not None:
             rigid_frags = cfg.rigid_props if isinstance(cfg.rigid_props, (list, tuple)) else [cfg.rigid_props]
             if rigid_frags and all(isinstance(f, SchemaFragment) for f in rigid_frags):
-                schemas.apply_rigid_body_properties(str(xform_prim.GetPath()), rigid_frags, stage=stage)
+                schemas.apply_rigid_body_properties(
+                    str(xform_prim.GetPath()), rigid_frags, create_if_missing=True, stage=stage
+                )
             else:
                 schemas.define_rigid_body_properties(prim_path=xform_prim.GetPath(), cfg=cfg.rigid_props, stage=stage)