Address PR review: split MDPs, revert asset setters, use view-level APIs

- Revert all friction/restitution/material setter additions from Newton
  and PhysX asset classes (9 files). Material property operations stay
  at the view level.
- Split randomize_rigid_body_material into backend-specific classes:
  PhysX uses bucket-based 3-tuple materials via root_view; Newton
  samples friction/restitution continuously per shape via view-level
  attribute bindings.
- Convert randomize_rigid_body_com from function to ManagerTermBase
  class with cached defaults for repeatable randomization.
- Split randomize_rigid_body_collider_offsets into backend-specific
  classes: PhysX uses rest/contact offsets; Newton maps to
  shape_margin/shape_gap.
- Add BaseRigidObjectCollection support to randomize_rigid_body_inertia.
- Fix _physics_sim_view bug (was incorrectly using root_view).
- Restore shape-count validation in PhysX material init.
- Rewrite all tests to use view-level APIs instead of asset setters.
- Un-skip Newton rigid object material tests; skip friction/restitution
  behavior tests that are incompatible with MuJoCo physics model.
- Remove stale Newton/PhysX changelog entries, rewrite isaaclab entry.

Author: AntoineRichard

source/isaaclab/docs/CHANGELOG.rst

@@ -8,20 +8,24 @@ Added
 ^^^^^
 
 * Added :class:`~isaaclab.envs.mdp.randomize_rigid_body_inertia` event term for
-  randomizing body inertia tensors. Supports diagonal-only and full 3x3 modes.
+  randomizing body inertia tensors independently of mass. Supports diagonal-only
+  (Ixx, Iyy, Izz) and full 3x3 modes.
 
 Changed
 ^^^^^^^
 
-* Updated :class:`~isaaclab.envs.mdp.randomize_rigid_body_material` to use
-  backend-specific APIs (PhysX 3-tuple vs Newton separate friction/restitution).
+* Split :class:`~isaaclab.envs.mdp.randomize_rigid_body_material` into
+  backend-specific implementations. PhysX uses bucket-based 3-tuple materials via the
+  tensor API; Newton samples friction and restitution continuously per shape via
+  view-level attribute bindings.
+* Converted :func:`~isaaclab.envs.mdp.randomize_rigid_body_com` from a plain function
+  to a :class:`~isaaclab.managers.ManagerTermBase` class with repeatable randomization
+  from cached defaults. Newton passes position-only (vec3); PhysX passes full pose
+  (pos + quat).
 * Converted :func:`~isaaclab.envs.mdp.randomize_rigid_body_collider_offsets` from a
-  plain function to a :class:`~isaaclab.managers.ManagerTermBase` class with automatic
-  backend detection. PhysX uses rest/contact offsets directly; Newton maps them to
-  ``shape_margin`` and ``shape_gap``.
-* Updated :func:`~isaaclab.envs.mdp.randomize_rigid_body_com` to detect the active
-  physics backend and pass position-only (vec3) for Newton vs full pose (pos + quat)
-  for PhysX.
+  plain function to a :class:`~isaaclab.managers.ManagerTermBase` class with
+  backend-specific implementations. PhysX uses rest/contact offsets directly; Newton
+  maps them to ``shape_margin`` and ``shape_gap``.
 
 
 4.5.30 (2026-04-13)

source/isaaclab/isaaclab/envs/mdp/events.py

@@ -22,6 +22,7 @@ Added
   registration, wildcard body matching, and zero-copy transform views.
 
 
+
 0.5.10 (2026-04-05)
 ~~~~~~~~~~~~~~~~~~~
 

source/isaaclab_newton/docs/CHANGELOG.rst

@@ -169,11 +169,6 @@ def num_shapes_per_body(self) -> list[int]:
                 self._num_shapes_per_body.append(len(shapes))
         return self._num_shapes_per_body
 
-    @property
-    def num_shapes(self) -> int:
-        """Total number of collision shapes in the articulation."""
-        return self.data._num_shapes
-
     @property
     def joint_names(self) -> list[str]:
         """Ordered names of joints in articulation."""
@@ -2273,168 +2268,6 @@ def set_inertias_mask(
         # tell the physics engine that some of the body properties have been updated
         SimulationManager.add_model_change(SolverNotifyFlags.BODY_INERTIAL_PROPERTIES)
 
-    def set_friction_index(
-        self,
-        *,
-        friction: torch.Tensor | wp.array,
-        shape_ids: Sequence[int] | torch.Tensor | wp.array | None = None,
-        env_ids: Sequence[int] | torch.Tensor | wp.array | None = None,
-    ) -> None:
-        """Set friction coefficient (mu) for collision shapes using indices.
-
-        .. note::
-            This method expects partial data.
-
-        .. tip::
-            Both the index and mask methods have dedicated optimized implementations. Performance is similar for both.
-            However, to allow graphed pipelines, the mask method must be used.
-
-        Args:
-            friction: Friction coefficient for shapes. Shape is (len(env_ids), len(shape_ids)).
-            shape_ids: Shape indices. If None, all shapes are updated.
-            env_ids: Environment indices. If None, all environments are updated.
-        """
-        # resolve all indices
-        env_ids = self._resolve_env_ids(env_ids)
-        shape_ids = self._resolve_shape_ids(shape_ids)
-        self.assert_shape_and_dtype(friction, (env_ids.shape[0], shape_ids.shape[0]), wp.float32, "friction")
-        # Warp kernels can ingest torch tensors directly, so we don't need to convert to warp arrays here.
-        wp.launch(
-            shared_kernels.write_2d_data_to_buffer_with_indices,
-            dim=(env_ids.shape[0], shape_ids.shape[0]),
-            inputs=[
-                friction,
-                env_ids,
-                shape_ids,
-            ],
-            outputs=[
-                self.data._sim_bind_shape_material_mu,
-            ],
-            device=self.device,
-        )
-        # tell the physics engine that some of the shape properties have been updated
-        SimulationManager.add_model_change(SolverNotifyFlags.SHAPE_PROPERTIES)
-
-    def set_friction_mask(
-        self,
-        *,
-        friction: torch.Tensor | wp.array,
-        env_mask: wp.array | None = None,
-    ) -> None:
-        """Set friction coefficient (mu) for collision shapes using masks.
-
-        .. note::
-            This method expects full data.
-
-        .. tip::
-            Both the index and mask methods have dedicated optimized implementations. Performance is similar for both.
-            However, to allow graphed pipelines, the mask method must be used.
-
-        Args:
-            friction: Friction coefficient for all shapes. Shape is (num_instances, num_shapes).
-            env_mask: Environment mask. If None, then all the instances are updated. Shape is (num_instances,).
-        """
-        # resolve masks
-        env_mask = self._resolve_mask(env_mask, self._ALL_ENV_MASK)
-        shape_mask = self._ALL_SHAPE_MASK
-        self.assert_shape_and_dtype_mask(friction, (env_mask, shape_mask), wp.float32, "friction")
-        wp.launch(
-            shared_kernels.write_2d_data_to_buffer_with_mask,
-            dim=(env_mask.shape[0], shape_mask.shape[0]),
-            inputs=[
-                friction,
-                env_mask,
-                shape_mask,
-            ],
-            outputs=[
-                self.data._sim_bind_shape_material_mu,
-            ],
-            device=self.device,
-        )
-        # tell the physics engine that some of the shape properties have been updated
-        SimulationManager.add_model_change(SolverNotifyFlags.SHAPE_PROPERTIES)
-
-    def set_restitution_index(
-        self,
-        *,
-        restitution: torch.Tensor | wp.array,
-        shape_ids: Sequence[int] | torch.Tensor | wp.array | None = None,
-        env_ids: Sequence[int] | torch.Tensor | wp.array | None = None,
-    ) -> None:
-        """Set restitution coefficient for collision shapes using indices.
-
-        .. note::
-            This method expects partial data.
-
-        .. tip::
-            Both the index and mask methods have dedicated optimized implementations. Performance is similar for both.
-            However, to allow graphed pipelines, the mask method must be used.
-
-        Args:
-            restitution: Restitution coefficient for shapes. Shape is (len(env_ids), len(shape_ids)).
-            shape_ids: Shape indices. If None, all shapes are updated.
-            env_ids: Environment indices. If None, all environments are updated.
-        """
-        # resolve all indices
-        env_ids = self._resolve_env_ids(env_ids)
-        shape_ids = self._resolve_shape_ids(shape_ids)
-        self.assert_shape_and_dtype(restitution, (env_ids.shape[0], shape_ids.shape[0]), wp.float32, "restitution")
-        # Warp kernels can ingest torch tensors directly, so we don't need to convert to warp arrays here.
-        wp.launch(
-            shared_kernels.write_2d_data_to_buffer_with_indices,
-            dim=(env_ids.shape[0], shape_ids.shape[0]),
-            inputs=[
-                restitution,
-                env_ids,
-                shape_ids,
-            ],
-            outputs=[
-                self.data._sim_bind_shape_material_restitution,
-            ],
-            device=self.device,
-        )
-        # tell the physics engine that some of the shape properties have been updated
-        SimulationManager.add_model_change(SolverNotifyFlags.SHAPE_PROPERTIES)
-
-    def set_restitution_mask(
-        self,
-        *,
-        restitution: torch.Tensor | wp.array,
-        env_mask: wp.array | None = None,
-    ) -> None:
-        """Set restitution coefficient for collision shapes using masks.
-
-        .. note::
-            This method expects full data.
-
-        .. tip::
-            Both the index and mask methods have dedicated optimized implementations. Performance is similar for both.
-            However, to allow graphed pipelines, the mask method must be used.
-
-        Args:
-            restitution: Restitution coefficient for all shapes. Shape is (num_instances, num_shapes).
-            env_mask: Environment mask. If None, then all the instances are updated. Shape is (num_instances,).
-        """
-        # resolve masks
-        env_mask = self._resolve_mask(env_mask, self._ALL_ENV_MASK)
-        shape_mask = self._ALL_SHAPE_MASK
-        self.assert_shape_and_dtype_mask(restitution, (env_mask, shape_mask), wp.float32, "restitution")
-        wp.launch(
-            shared_kernels.write_2d_data_to_buffer_with_mask,
-            dim=(env_mask.shape[0], shape_mask.shape[0]),
-            inputs=[
-                restitution,
-                env_mask,
-                shape_mask,
-            ],
-            outputs=[
-                self.data._sim_bind_shape_material_restitution,
-            ],
-            device=self.device,
-        )
-        # tell the physics engine that some of the shape properties have been updated
-        SimulationManager.add_model_change(SolverNotifyFlags.SHAPE_PROPERTIES)
-
     def set_joint_position_target_index(
         self,
         *,
@@ -3401,8 +3234,6 @@ def _create_buffers(self):
         self._ALL_JOINT_MASK = wp.ones((self.num_joints,), dtype=wp.bool, device=self.device)
         self._ALL_BODY_INDICES = wp.array(np.arange(self.num_bodies, dtype=np.int32), device=self.device)
         self._ALL_BODY_MASK = wp.ones((self.num_bodies,), dtype=wp.bool, device=self.device)
-        self._ALL_SHAPE_INDICES = wp.array(np.arange(self.num_shapes, dtype=np.int32), device=self.device)
-        self._ALL_SHAPE_MASK = wp.ones((self.num_shapes,), dtype=wp.bool, device=self.device)
         self._ALL_FIXED_TENDON_INDICES = wp.array(np.arange(self.num_fixed_tendons, dtype=np.int32), device=self.device)
         self._ALL_FIXED_TENDON_MASK = wp.ones((self.num_fixed_tendons,), dtype=wp.bool, device=self.device)
         self._ALL_SPATIAL_TENDON_INDICES = wp.array(
@@ -3900,21 +3731,6 @@ def _resolve_body_ids(self, body_ids: Sequence[int] | torch.Tensor | wp.array |
             return self._ALL_BODY_INDICES
         return body_ids
 
-    def _resolve_shape_ids(self, shape_ids: Sequence[int] | torch.Tensor | wp.array | None) -> wp.array | torch.Tensor:
-        """Resolve shape indices to a warp array or tensor.
-
-        Args:
-            shape_ids: Shape indices. If None, then all indices are used.
-
-        Returns:
-            A warp array of shape indices or a tensor of shape indices.
-        """
-        if (shape_ids is None) or (shape_ids == slice(None)):
-            return self._ALL_SHAPE_INDICES
-        elif isinstance(shape_ids, list):
-            return wp.array(shape_ids, dtype=wp.int32, device=self.device)
-        return shape_ids
-
     def _resolve_fixed_tendon_ids(
         self, tendon_ids: Sequence[int] | torch.Tensor | wp.array | None
     ) -> wp.array | torch.Tensor:

source/isaaclab_newton/isaaclab_newton/assets/articulation/articulation.py

@@ -1323,16 +1323,6 @@ def _create_simulation_bindings(self) -> None:
             self._sim_bind_joint_velocity_target = wp.zeros(
                 (self._num_instances, 0), dtype=wp.float32, device=self.device
             )
-        # -- shape material properties (for collision shapes)
-        self._sim_bind_shape_material_mu = self._root_view.get_attribute(
-            "shape_material_mu", SimulationManager.get_model()
-        )[:, 0]
-        self._sim_bind_shape_material_restitution = self._root_view.get_attribute(
-            "shape_material_restitution", SimulationManager.get_model()
-        )[:, 0]
-        self._num_shapes = (
-            self._sim_bind_shape_material_mu.shape[1] if len(self._sim_bind_shape_material_mu.shape) > 1 else 1
-        )
 
     def _create_buffers(self) -> None:
         """Create buffers for the root data."""