Add MuJoCo tendon support to Newton physics replication

Newton's parse_usd has two interlocking constraints that prevented
MjcTendon prims from being parsed correctly in the multi-env cloner:

1. SchemaResolverMjc.validate_custom_attributes() raises if called on a
   builder that has not had SolverMuJoCo.register_custom_attributes()
   called first.

2. register_custom_attributes registers MJC custom frequencies, which
   triggers Newton's stage-wide custom-frequency traversal (independent
   of ignore_paths). On the main builder, this traversal finds MjcTendon
   prims under /World/envs/... and tries to resolve their joint paths
   against the main builder's empty joint_label (joints are excluded via
   ignore_paths), producing "unknown joint path" warnings and dropping
   all tendons.

Fix: exclude SchemaResolverMjc from the main builder's schema_resolvers.
The main builder loads only scene-level prims (ground, lights) that have
no MjcTendon prims, so the resolver is not needed there. Proto builders
include SchemaResolverMjc and call register_custom_attributes before
add_usd, so Newton correctly resolves MjcTendon joint paths against each
proto's fully populated joint_label. add_builder then propagates the
resolved entries into the main builder (N×T entries for N envs, T
tendons each), which SolverMuJoCo handles natively by filtering on
tendon_world == template_world.

Author: Horde

source/isaaclab_newton/changelog.d/5433.rst

@@ -0,0 +1,33 @@
+Added
+^^^^^
+
+* Added MuJoCo tendon parsing to Newton physics replication.
+  :func:`~isaaclab_newton.cloner.newton_replicate._build_newton_builder_from_mapping`
+  now includes :class:`SchemaResolverMjc` in the proto-builder resolver list and calls
+  ``SolverMuJoCo.register_custom_attributes`` on each proto builder so that
+  ``MjcTendon`` prims (e.g. Shadow Hand fixed tendons) are resolved during
+  ``add_usd`` and propagated into the main builder via ``add_builder``.
+
+Fixed
+^^^^^
+
+* Fixed MuJoCo tendon handling in Newton physics replication
+  (:func:`~isaaclab_newton.cloner.newton_replicate._build_newton_builder_from_mapping`).
+  Two interlocking issues prevented tendons from being included in the replicated model:
+
+  1. ``SchemaResolverMjc`` was included in the main builder's ``schema_resolvers``,
+     which requires ``SolverMuJoCo.register_custom_attributes`` to be called first
+     (or ``validate_custom_attributes`` raises). Calling it on the main builder
+     registered MJC custom frequencies, triggering Newton's stage-wide traversal
+     (independent of ``ignore_paths``) that tried to resolve ``MjcTendon`` joint
+     paths against the main builder's empty ``joint_label``, producing "unknown joint
+     path" warnings and silently dropping all tendons.
+
+  The fix excludes ``SchemaResolverMjc`` from the main builder's ``schema_resolvers``
+  (the main builder loads only scene-level prims with no ``MjcTendon`` prims) and
+  moves it to the proto builders, where ``register_custom_attributes`` is called
+  before ``add_usd`` and the full joint hierarchy is available for resolution.
+  Newton's ``add_builder`` then propagates the resolved tendon entries (with correct
+  joint-index offsets and ``tendon_world`` per environment) into the main builder.
+  The resulting N×T tendon entries across N environments are handled natively by
+  ``SolverMuJoCo``, which filters by ``tendon_world == template_world``.

source/isaaclab_newton/isaaclab_newton/cloner/newton_replicate.py

@@ -10,7 +10,7 @@
 import torch
 import warp as wp
 from newton import ModelBuilder, solvers
-from newton._src.usd.schemas import SchemaResolverNewton, SchemaResolverPhysx
+from newton._src.usd.schemas import SchemaResolverMjc, SchemaResolverNewton, SchemaResolverPhysx
 
 from pxr import Usd, UsdGeom
 
@@ -52,28 +52,48 @@ def _build_newton_builder_from_mapping(
         quaternions = torch.zeros((mapping.size(1), 4), device=mapping.device, dtype=torch.float32)
         quaternions[:, 3] = 1.0
 
-    schema_resolvers = [SchemaResolverNewton(), SchemaResolverPhysx()]
-
+    # Main builder: loads only ground plane, lights, and scene-level prims.
+    # /World/envs (and all source asset paths) are excluded via ignore_paths.
+    #
+    # SchemaResolverMjc is intentionally EXCLUDED here. Two reasons:
+    #   1. SchemaResolverMjc.validate_custom_attributes() raises if
+    #      SolverMuJoCo.register_custom_attributes() has not been called first.
+    #   2. Calling register_custom_attributes on the main builder registers MJC
+    #      custom frequencies, which triggers Newton's stage-wide traversal
+    #      (independent of ignore_paths). That traversal finds MjcTendon prims
+    #      under /World/envs/... and tries to resolve their joint paths against
+    #      the main builder's empty joint_label (no joints were loaded), causing
+    #      "unknown joint path" warnings and silently dropping every tendon.
+    # The main builder only loads scene-level prims (ground, lights) that have
+    # no MjcTendon prims, so SchemaResolverMjc is not needed here.
+    _main_resolvers = [SchemaResolverNewton(), SchemaResolverPhysx()]
     builder = NewtonManager.create_builder(up_axis=up_axis)
     stage_info = builder.add_usd(
         stage,
         ignore_paths=["/World/envs"] + sources,
-        schema_resolvers=schema_resolvers,
+        schema_resolvers=_main_resolvers,
     )
 
+    # Proto resolvers include SchemaResolverMjc so MjcTendon prims are parsed.
+    _proto_resolvers = [SchemaResolverMjc(), SchemaResolverNewton(), SchemaResolverPhysx()]
+
     # 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]
     protos: dict[str, ModelBuilder] = {}
     for src_path in sources:
+        # register_custom_attributes must be called before add_usd so that
+        # SchemaResolverMjc.validate_custom_attributes() passes and Newton's
+        # custom-frequency traversal can resolve MjcTendon joint paths against
+        # this proto's fully populated joint_label.
         p = NewtonManager.create_builder(up_axis=up_axis)
         solvers.SolverMuJoCo.register_custom_attributes(p)
         p.add_usd(
             stage,
             root_path=src_path,
             load_visual_shapes=True,
             skip_mesh_approximation=True,
-            schema_resolvers=schema_resolvers,
+            schema_resolvers=_proto_resolvers,
         )
         if simplify_meshes:
             p.approximate_meshes("convex_hull", keep_visual_shapes=True)
@@ -112,6 +132,12 @@ def _build_newton_builder_from_mapping(
         # end the world context
         builder.end_world()
 
+    # Note: add_builder appends tendon custom-attribute entries from the proto
+    # for each world, giving N×T total entries after N environments. This is
+    # intentional: Newton's SolverMuJoCo reads tendon_world[i] for every entry
+    # and skips any tendon whose world is not the template world (world 0).
+    # No deduplication is needed.
+
     site_index_map = {
         **global_site_map,
         **{label: (None, per_world) for label, per_world in local_site_map.items()},