update dexsuite to latest newton

Author: ooctipus

source/isaaclab/isaaclab/renderer/newton_warp_renderer.py

@@ -9,7 +9,7 @@
 import torch
 
 import warp as wp
-from newton.sensors import TiledCameraSensor
+from newton.sensors import SensorTiledCamera
 
 from isaaclab.sim._impl.newton_manager import NewtonManager
 from isaaclab.utils.math import convert_camera_frame_orientation_convention
@@ -49,7 +49,7 @@ def _convert_raw_rgb_tiled(
     This kernel converts it to the tiled format (tiled_height, tiled_width, 4) of uint8.
 
     Args:
-        raw_buffer: Input raw buffer from TiledCameraSensor, shape (num_worlds, num_cameras, width * height) of uint32
+        raw_buffer: Input raw buffer from SensorTiledCamera, shape (num_worlds, num_cameras, width * height) of uint32
         output_buffer: Output buffer in tiled format (tiled_height, tiled_width, 4) of uint8
         image_width: Width of each camera image
         image_height: Height of each camera image
@@ -99,7 +99,7 @@ def _convert_raw_depth_tiled(
     This kernel converts it to the tiled format (tiled_height, tiled_width, 1) of float32.
 
     Args:
-        raw_buffer: Input raw buffer from TiledCameraSensor, shape (num_worlds, num_cameras, width * height) of float32
+        raw_buffer: Input raw buffer from SensorTiledCamera, shape (num_worlds, num_cameras, width * height) of float32
         output_buffer: Output buffer in tiled format (tiled_height, tiled_width, 1) of float32
         image_width: Width of each camera image
         image_height: Height of each camera image
@@ -143,12 +143,12 @@ def initialize(self):
         """Initialize the renderer."""
         self._model = NewtonManager.get_model()
 
-        self._tiled_camera_sensor = TiledCameraSensor(
+        self._tiled_camera_sensor = SensorTiledCamera(
             model=self._model,
             num_cameras=1,  # TODO: currently only supports 1 camera per world
             width=self._width,
             height=self._height,
-            options=TiledCameraSensor.Options(colors_per_shape=True),
+            options=SensorTiledCamera.Options(colors_per_shape=True),
         )
 
         # Note: camera rays will be computed when we have access to TiledCamera
@@ -180,7 +180,7 @@ def set_camera_rays_from_intrinsics(self, intrinsic_matrices: torch.Tensor):
         fov_radians_wp = wp.from_torch(fov_radians_all, dtype=wp.float32)
 
         # Compute camera rays with per-camera FOVs (vectorized)
-        # TiledCameraSensor.compute_pinhole_camera_rays accepts array of FOVs
+        # SensorTiledCamera.compute_pinhole_camera_rays accepts array of FOVs
         self._camera_rays = self._tiled_camera_sensor.compute_pinhole_camera_rays(fov_radians_wp)
 
     def _initialize_output(self):
@@ -238,7 +238,7 @@ def render(
             device=camera_positions_wp.device,
         )
 
-        # Render using TiledCameraSensor
+        # Render using SensorTiledCamera
         self._tiled_camera_sensor.render(
             state=NewtonManager.get_state_0(),  # Use current physics state
             camera_transforms=camera_transforms,

source/isaaclab/isaaclab/sim/_impl/newton_manager.py

@@ -12,7 +12,7 @@
 import warp as wp
 from newton import Axis, Contacts, Control, Model, ModelBuilder, State, eval_fk
 from newton.examples import create_collision_pipeline
-from newton.sensors import ContactSensor as NewtonContactSensor
+from newton.sensors import SensorContact as NewtonContactSensor
 from newton.sensors import populate_contacts
 from newton.solvers import SolverBase, SolverFeatherstone, SolverMuJoCo, SolverNotifyFlags, SolverXPBD
 

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

@@ -389,16 +389,17 @@ def joint_pos_limits(self) -> wp.array(dtype=wp.vec2f):
                 (self._root_view.count, self._root_view.joint_dof_count), dtype=wp.vec2f, device=self.device
             )
 
-        wp.launch(
-            make_joint_pos_limits_from_lower_and_upper_limits,
-            dim=(self._root_view.count, self._root_view.joint_dof_count),
-            inputs=[
-                self._sim_bind_joint_pos_limits_lower,
-                self._sim_bind_joint_pos_limits_upper,
-                self._joint_pos_limits,
-            ],
-            device=self.device,
-        )
+        if self._root_view.joint_dof_count > 0:
+            wp.launch(
+                make_joint_pos_limits_from_lower_and_upper_limits,
+                dim=(self._root_view.count, self._root_view.joint_dof_count),
+                inputs=[
+                    self._sim_bind_joint_pos_limits_lower,
+                    self._sim_bind_joint_pos_limits_upper,
+                    self._joint_pos_limits,
+                ],
+                device=self.device,
+            )
         return self._joint_pos_limits
 
     @property
@@ -927,6 +928,8 @@ def joint_vel(self) -> wp.array(dtype=wp.float32):
     @property
     def joint_acc(self) -> wp.array(dtype=wp.float32):
         """Joint acceleration of all joints. Shape is (num_instances, num_joints)."""
+        if self._root_view.joint_dof_count == 0:
+            return self._joint_acc.data
         if self._joint_acc.timestamp < self._sim_timestamp:
             # note: we use finite differencing to compute acceleration
             wp.launch(
@@ -2239,7 +2242,20 @@ def _create_simulation_bindings(self) -> None:
                 "joint_target_vel", NewtonManager.get_control()
             )[:, 0]
         else:
-            raise ValueError("Number of joints is not supported.")
+            # No joints (e.g., free-floating rigid body) - set bindings to None
+            self._sim_bind_joint_pos_limits_lower = None
+            self._sim_bind_joint_pos_limits_upper = None
+            self._sim_bind_joint_stiffness_sim = None
+            self._sim_bind_joint_damping_sim = None
+            self._sim_bind_joint_armature = None
+            self._sim_bind_joint_friction_coeff = None
+            self._sim_bind_joint_vel_limits_sim = None
+            self._sim_bind_joint_effort_limits_sim = None
+            self._sim_bind_joint_pos = None
+            self._sim_bind_joint_vel = None
+            self._sim_bind_joint_effort = None
+            self._sim_bind_joint_position_target = None
+            self._sim_bind_joint_velocity_target = None
 
     def _create_buffers(self) -> None:
         """Create buffers for the root data."""
@@ -2288,8 +2304,12 @@ def _create_buffers(self) -> None:
         self._computed_effort = wp.zeros((n_view, n_dof), dtype=wp.float32, device=self.device)
         self._applied_effort = wp.zeros((n_view, n_dof), dtype=wp.float32, device=self.device)
         # -- joint properties for the actuator models
-        self._actuator_stiffness = wp.clone(self._sim_bind_joint_stiffness_sim)
-        self._actuator_damping = wp.clone(self._sim_bind_joint_damping_sim)
+        if n_dof > 0:
+            self._actuator_stiffness = wp.clone(self._sim_bind_joint_stiffness_sim)
+            self._actuator_damping = wp.clone(self._sim_bind_joint_damping_sim)
+        else:
+            self._actuator_stiffness = wp.zeros((n_view, 0), dtype=wp.float32, device=self.device)
+            self._actuator_damping = wp.zeros((n_view, 0), dtype=wp.float32, device=self.device)
         # -- other data that are filled based on explicit actuator models
         self._joint_dynamic_friction = wp.zeros((n_view, n_dof), dtype=wp.float32, device=self.device)
         self._joint_viscous_friction = wp.zeros((n_view, n_dof), dtype=wp.float32, device=self.device)
@@ -2299,7 +2319,10 @@ def _create_buffers(self) -> None:
         self._soft_joint_pos_limits = wp.zeros((n_view, n_dof), dtype=wp.vec2f, device=self.device)
 
         # Initialize history for finite differencing
-        self._previous_joint_vel = wp.clone(self._root_view.get_dof_velocities(NewtonManager.get_state_0()))[:, 0]
+        if n_dof > 0:
+            self._previous_joint_vel = wp.clone(self._root_view.get_dof_velocities(NewtonManager.get_state_0()))[:, 0]
+        else:
+            self._previous_joint_vel = wp.zeros((n_view, 0), dtype=wp.float32, device=self.device)
         self._previous_body_com_vel = wp.clone(self._sim_bind_body_com_vel_w)
 
         # Initialize the lazy buffers.

source/isaaclab_tasks/isaaclab_tasks/manager_based/manipulation/dexsuite/config/kuka_allegro/dexsuite_kuka_allegro_vision_env_cfg.py

@@ -171,7 +171,7 @@ class WristImageObsCfg(ObsGroup):
 
 @configclass
 class KukaAllegroSingleCameraMixinCfg(kuka_allegro_dexsuite.KukaAllegroMixinCfg):
-    scene = KukaAllegroSingleTiledCameraSceneCfg(num_envs=4096, env_spacing=3, replicate_physics=True)
+    scene = KukaAllegroSingleTiledCameraSceneCfg(num_envs=4096, env_spacing=0.0, replicate_physics=True)
     observations: KukaAllegroSingleCameraObservationsCfg = KukaAllegroSingleCameraObservationsCfg()
 
     def __post_init__(self: kuka_allegro_dexsuite.DexsuiteKukaAllegroLiftEnvCfg):
@@ -181,7 +181,7 @@ def __post_init__(self: kuka_allegro_dexsuite.DexsuiteKukaAllegroLiftEnvCfg):
 
 @configclass
 class KukaAllegroDuoCameraMixinCfg(kuka_allegro_dexsuite.KukaAllegroMixinCfg):
-    scene = KukaAllegroDuoTiledCameraSceneCfg(num_envs=4096, env_spacing=3, replicate_physics=True)
+    scene = KukaAllegroDuoTiledCameraSceneCfg(num_envs=4096, env_spacing=0.0, replicate_physics=True)
     observations: KukaAllegroDuoCameraObservationsCfg = KukaAllegroDuoCameraObservationsCfg()
 
     def __post_init__(self: kuka_allegro_dexsuite.DexsuiteKukaAllegroLiftEnvCfg):

source/isaaclab_tasks/isaaclab_tasks/manager_based/manipulation/dexsuite/dexsuite_env_cfg.py

@@ -323,14 +323,14 @@ class EventCfg:
     # and gradually introducing full gravity (hard) — the agent learns more smoothly.
     # This removes the need for a special "Lift" reward (often required to push the
     # agent to counter gravity), which has bonus effect of simplifying reward composition overall.
-    # variable_gravity = EventTerm(
-    #     func=mdp.randomize_physics_scene_gravity,
-    #     mode="reset",
-    #     params={
-    #         "gravity_distribution_params": ([0.0, 0.0, 0.0], [0.0, 0.0, 0.0]),
-    #         "operation": "abs",
-    #     },
-    # )
+    variable_gravity = EventTerm(
+        func=mdp.randomize_physics_scene_gravity,
+        mode="reset",
+        params={
+            "gravity_distribution_params": ([0.0, 0.0, 0.0], [0.0, 0.0, 0.0]),
+            "operation": "abs",
+        },
+    )
 
 
 @configclass
@@ -417,7 +417,7 @@ class DexsuiteReorientEnvCfg(ManagerBasedEnvCfg):
     rewards: RewardsCfg = RewardsCfg()
     terminations: TerminationsCfg = TerminationsCfg()
     events: EventCfg = EventCfg()
-    curriculum: CurriculumCfg | None = None
+    curriculum: CurriculumCfg | None = CurriculumCfg()
 
     def __post_init__(self):
         """Post initialization."""