Add manager-based counterparts for handover and camera tasks

Rebuilt from the reviewed lump so the handover and camera manager
counterparts land with the review round folded in:

- Backend scene presets declare only backend-specific fields; shared
  invariants live as inner-class defaults.
- Single-consumer scene helper cfgs are nested in their consumers.
- Reset events use torch.zeros_like for the pose buffers.
- The value-parity test covers reset-noise distributions and the
  timeout max-successes contract.
- The camera manager cfg inherits the shared command/reward/termination
  sections from the state manager cfg instead of re-declaring them.

Lump review commits folded: 792e400, 42675b6, 1f05f85,
173e9dc, 2727616, 1732493, 3659a33, ee272c9.

Author: hujc7

source/isaaclab_tasks/changelog.d/task-cleanup-dex-part11.minor.rst

@@ -0,0 +1,8 @@
+Added
+^^^^^
+
+* Added manager-based counterparts for the Shadow handover and Shadow camera
+  reorientation tasks, completing the manager coverage of the dexterous task
+  families.
+* Added Direct-vs-manager scalar value-parity checks for the dexterous task
+  families.

source/isaaclab_tasks/isaaclab_tasks/core/handover/__init__.py

@@ -15,6 +15,16 @@
 # Register Gym environments.
 ##
 
+gym.register(
+    id="Isaac-Shadow-Handover",
+    entry_point="isaaclab.envs:ManagerBasedRLEnv",
+    disable_env_checker=True,
+    kwargs={
+        "env_cfg_entry_point": f"{__name__}.handover_manager_env_cfg:HandoverManagerEnvCfg",
+        "rsl_rl_cfg_entry_point": f"{agents.__name__}.rsl_rl_ppo_cfg:HandoverPPORunnerCfg",
+    },
+)
+
 gym.register(
     id="Isaac-Shadow-Handover-Direct",
     entry_point=f"{__name__}.handover_env:HandoverEnv",

source/isaaclab_tasks/isaaclab_tasks/core/handover/handover_manager_env_cfg.py

@@ -0,0 +1,195 @@
+# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Manager-based counterpart of the Shadow Hand handover task."""
+
+import isaaclab.sim as sim_utils
+from isaaclab.assets import AssetBaseCfg
+from isaaclab.envs import ManagerBasedRLEnvCfg
+from isaaclab.managers import EventTermCfg as EventTerm
+from isaaclab.managers import ObservationGroupCfg as ObsGroup
+from isaaclab.managers import ObservationTermCfg as ObsTerm
+from isaaclab.managers import RewardTermCfg as RewTerm
+from isaaclab.managers import SceneEntityCfg
+from isaaclab.managers import TerminationTermCfg as DoneTerm
+from isaaclab.scene import InteractiveSceneCfg
+from isaaclab.utils.configclass import configclass
+
+import isaaclab_tasks.core.handover.mdp as mdp
+from isaaclab_tasks.core.handover.handover_env_cfg import (
+    LEFT_HAND_CFG,
+    RIGHT_HAND_CFG,
+    HandoverTaskCfgBase,
+    ObjectCfg,
+)
+from isaaclab_tasks.core.handover.handover_task_base import (
+    ACTUATED_JOINT_NAMES_PRESET,
+    FINGERTIP_BODY_NAMES,
+)
+from isaaclab_tasks.utils import PresetCfg
+
+
+@configclass
+class HandoverManagerSceneCfg(PresetCfg):
+    """Backend-specific scene cloning settings for handover."""
+
+    @configclass
+    class SceneCfg(InteractiveSceneCfg):
+        """Scene shared by the handover Manager backend alternatives."""
+
+        num_envs = 2048
+        env_spacing = 1.5
+        replicate_physics = True
+
+        ground = AssetBaseCfg(
+            prim_path="/World/ground",
+            spawn=sim_utils.GroundPlaneCfg(),
+        )
+        right_hand: PresetCfg = RIGHT_HAND_CFG
+        left_hand: PresetCfg = LEFT_HAND_CFG
+        object: ObjectCfg = ObjectCfg()
+        light = AssetBaseCfg(
+            prim_path="/World/Light",
+            spawn=sim_utils.DomeLightCfg(intensity=2000.0, color=(0.75, 0.75, 0.75)),
+        )
+
+    physx = SceneCfg(clone_in_fabric=True)
+    newton_mjwarp = SceneCfg(clone_in_fabric=False)
+    ovphysx = physx
+    default = physx
+
+
+@configclass
+class CommandsCfg:
+    """Handover goal command."""
+
+    object_pose = mdp.HandoverCommandCfg(asset_name="object", debug_vis=True)
+
+
+@configclass
+class ActionsCfg:
+    """Two-hand action terms, ordered right then left like the Direct adapter."""
+
+    right_hand = mdp.EMAJointPositionToLimitsActionCfg(
+        asset_name="right_hand",
+        joint_names=ACTUATED_JOINT_NAMES_PRESET,
+        alpha=1.0,
+        rescale_to_limits=True,
+    )
+    left_hand = mdp.EMAJointPositionToLimitsActionCfg(
+        asset_name="left_hand",
+        joint_names=ACTUATED_JOINT_NAMES_PRESET,
+        alpha=1.0,
+        rescale_to_limits=True,
+    )
+
+
+def _hand_entity(name: str) -> SceneEntityCfg:
+    return SceneEntityCfg(name, joint_names=".*")
+
+
+def _fingertip_entity(name: str) -> SceneEntityCfg:
+    return SceneEntityCfg(name, body_names=FINGERTIP_BODY_NAMES)
+
+
+@configclass
+class ObservationsCfg:
+    """Single-agent observations matching the Direct MARL adapter."""
+
+    @configclass
+    class PolicyCfg(ObsGroup):
+        # Right agent: 133 hand dimensions followed by 24 object/goal dimensions.
+        # soft limits equal the hard limits here: soft_joint_pos_limits_factor defaults to 1.0
+        right_joint_pos = ObsTerm(func=mdp.joint_pos_limit_normalized, params={"asset_cfg": _hand_entity("right_hand")})
+        right_joint_vel = ObsTerm(func=mdp.joint_vel, scale=0.2, params={"asset_cfg": _hand_entity("right_hand")})
+        right_fingertip_pos = ObsTerm(func=mdp.fingertip_pos, params={"asset_cfg": _fingertip_entity("right_hand")})
+        right_fingertip_quat = ObsTerm(func=mdp.fingertip_quat, params={"asset_cfg": _fingertip_entity("right_hand")})
+        right_fingertip_vel = ObsTerm(func=mdp.fingertip_vel, params={"asset_cfg": _fingertip_entity("right_hand")})
+        right_action = ObsTerm(func=mdp.hand_action, params={"action_name": "right_hand"})
+        right_object_goal = ObsTerm(
+            func=mdp.object_goal,
+            params={"command_name": "object_pose", "object_cfg": SceneEntityCfg("object"), "vel_obs_scale": 0.2},
+        )
+
+        # Left agent: the same 157-dimensional layout.
+        # soft limits equal the hard limits here: soft_joint_pos_limits_factor defaults to 1.0
+        left_joint_pos = ObsTerm(func=mdp.joint_pos_limit_normalized, params={"asset_cfg": _hand_entity("left_hand")})
+        left_joint_vel = ObsTerm(func=mdp.joint_vel, scale=0.2, params={"asset_cfg": _hand_entity("left_hand")})
+        left_fingertip_pos = ObsTerm(func=mdp.fingertip_pos, params={"asset_cfg": _fingertip_entity("left_hand")})
+        left_fingertip_quat = ObsTerm(func=mdp.fingertip_quat, params={"asset_cfg": _fingertip_entity("left_hand")})
+        left_fingertip_vel = ObsTerm(func=mdp.fingertip_vel, params={"asset_cfg": _fingertip_entity("left_hand")})
+        left_action = ObsTerm(func=mdp.hand_action, params={"action_name": "left_hand"})
+        left_object_goal = ObsTerm(
+            func=mdp.object_goal,
+            params={"command_name": "object_pose", "object_cfg": SceneEntityCfg("object"), "vel_obs_scale": 0.2},
+        )
+
+        def __post_init__(self):
+            self.enable_corruption = False
+            self.concatenate_terms = True
+
+    policy: PolicyCfg = PolicyCfg()
+
+
+@configclass
+class EventCfg:
+    """Reset distributions matching the Direct handover environment."""
+
+    reset_handover = EventTerm(
+        func=mdp.reset_handover_state,
+        mode="reset",
+        params={
+            "position_noise": 0.01,
+            "joint_position_noise": 0.2,
+            "joint_velocity_noise": 0.0,
+            "action_names": ("right_hand", "left_hand"),
+        },
+    )
+
+
+@configclass
+class RewardsCfg:
+    """Summed two-agent reward exposed by the Direct single-agent adapter."""
+
+    handover = RewTerm(
+        func=mdp.HandoverReward,
+        weight=1.0,
+        params={
+            "command_name": "object_pose",
+            "distance_scale": 20.0,
+            "success_distance_threshold": 0.1,
+            "object_cfg": SceneEntityCfg("object"),
+        },
+    )
+
+
+@configclass
+class TerminationsCfg:
+    """Termination conditions matching the Direct single-agent adapter."""
+
+    object_out_of_reach = DoneTerm(
+        func=mdp.root_height_below_minimum,
+        params={"minimum_height": 0.24, "asset_cfg": SceneEntityCfg("object")},
+    )
+    time_out = DoneTerm(func=mdp.time_out, time_out=True)
+
+
+@configclass
+class HandoverManagerEnvCfg(HandoverTaskCfgBase, ManagerBasedRLEnvCfg):
+    """Manager-based handover environment matching the Direct RSL-RL view."""
+
+    scene: HandoverManagerSceneCfg = HandoverManagerSceneCfg()
+    observations: ObservationsCfg = ObservationsCfg()
+    actions: ActionsCfg = ActionsCfg()
+    commands: CommandsCfg = CommandsCfg()
+    rewards: RewardsCfg = RewardsCfg()
+    terminations: TerminationsCfg = TerminationsCfg()
+    events: EventCfg = EventCfg()
+
+    def __post_init__(self):
+        self.decimation = 2
+        self.episode_length_s = 7.5
+        self.sim.render_interval = self.decimation
+        self.viewer.eye = (2.0, 2.0, 2.0)

source/isaaclab_tasks/isaaclab_tasks/core/handover/mdp/__init__.pyi

@@ -4,9 +4,27 @@
 # SPDX-License-Identifier: BSD-3-Clause
 
 __all__ = [
+    "HandoverCommand",
+    "HandoverCommandCfg",
+    "reset_handover_state",
+    "fingertip_pos",
+    "fingertip_quat",
+    "fingertip_vel",
+    "hand_action",
+    "object_goal",
+    "HandoverReward",
     "handover_reward",
     "evaluate_handover_success",
 ]
 
-from .rewards import evaluate_handover_success, handover_reward
+from .commands import HandoverCommand, HandoverCommandCfg
+from .events import reset_handover_state
+from .observations import (
+    fingertip_pos,
+    fingertip_quat,
+    fingertip_vel,
+    hand_action,
+    object_goal,
+)
+from .rewards import HandoverReward, evaluate_handover_success, handover_reward
 from isaaclab.envs.mdp import *

source/isaaclab_tasks/isaaclab_tasks/core/handover/mdp/commands.py

@@ -0,0 +1,96 @@
+# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Goal-pose command for the manager-based handover task."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from dataclasses import MISSING
+from typing import TYPE_CHECKING
+
+import torch
+
+import isaaclab.utils.math as math_utils
+from isaaclab.managers import CommandTerm, CommandTermCfg
+from isaaclab.markers import VisualizationMarkers, VisualizationMarkersCfg
+from isaaclab.utils.configclass import configclass
+
+from isaaclab_tasks.core.handover.handover_task_base import GOAL_MARKER_CFG, GOAL_POSITION_OFFSET
+
+if TYPE_CHECKING:
+    from isaaclab.assets import RigidObject
+    from isaaclab.envs import ManagerBasedRLEnv
+
+
+class HandoverCommand(CommandTerm):
+    """Sample the fixed-position, random-orientation handover goal pose."""
+
+    cfg: HandoverCommandCfg
+
+    def __init__(self, cfg: HandoverCommandCfg, env: ManagerBasedRLEnv):
+        super().__init__(cfg, env)
+        self._object: RigidObject = env.scene[cfg.asset_name]
+        offset = torch.tensor(cfg.position_offset, dtype=torch.float, device=self.device)
+        self.pos_command_e = self._object.data.default_root_pose.torch[:, :3] + offset
+        self.quat_command_w = torch.zeros(self.num_envs, 4, device=self.device)
+        self.quat_command_w[:, 3] = 1.0  # identity quaternion in (x, y, z, w) layout
+        # persistent (num_envs, 7) pose command: the position half is static and written once
+        # here, the quaternion half is refreshed by _resample_command; `command` returns this
+        # buffer directly instead of allocating a torch.cat every call
+        self._command_buf = torch.cat((self.pos_command_e, self.quat_command_w), dim=-1)
+        self._x_unit = torch.tensor([1.0, 0.0, 0.0], device=self.device).repeat(self.num_envs, 1)
+        self._y_unit = torch.tensor([0.0, 1.0, 0.0], device=self.device).repeat(self.num_envs, 1)
+
+    @property
+    def command(self) -> torch.Tensor:
+        """Goal pose in the environment frame [m, unit quaternion].
+
+        The returned tensor is a persistent buffer refreshed in place; consumers that
+        store it across steps must copy it.
+        """
+        return self._command_buf
+
+    def _update_metrics(self) -> None:
+        pass
+
+    def _resample_command(self, env_ids: Sequence[int]) -> None:
+        random_values = 2.0 * torch.rand((len(env_ids), 2), device=self.device) - 1.0
+        self.quat_command_w[env_ids] = math_utils.quat_mul(
+            math_utils.quat_from_angle_axis(random_values[:, 0] * torch.pi, self._x_unit[env_ids]),
+            math_utils.quat_from_angle_axis(random_values[:, 1] * torch.pi, self._y_unit[env_ids]),
+        )
+        # keep the persistent pose-command buffer current (position half is static)
+        self._command_buf[env_ids, 3:] = self.quat_command_w[env_ids]
+
+    def _update_command(self) -> None:
+        pass
+
+    def _set_debug_vis_impl(self, debug_vis: bool) -> None:
+        if debug_vis:
+            if not hasattr(self, "_goal_visualizer"):
+                self._goal_visualizer = VisualizationMarkers(self.cfg.goal_visualizer_cfg)
+            self._goal_visualizer.set_visibility(True)
+        elif hasattr(self, "_goal_visualizer"):
+            self._goal_visualizer.set_visibility(False)
+
+    def _debug_vis_callback(self, event) -> None:
+        del event
+        self._goal_visualizer.visualize(
+            translations=self.pos_command_e + self._env.scene.env_origins,
+            orientations=self.quat_command_w,
+        )
+
+
+@configclass
+class HandoverCommandCfg(CommandTermCfg):
+    """Configuration for :class:`HandoverCommand`."""
+
+    class_type: type[HandoverCommand] = HandoverCommand
+    resampling_time_range: tuple[float, float] = (1.0e6, 1.0e6)
+    asset_name: str = MISSING
+    position_offset: tuple[float, float, float] = GOAL_POSITION_OFFSET
+    """Goal-position offset from the object's default position [m]."""
+    goal_visualizer_cfg: VisualizationMarkersCfg = GOAL_MARKER_CFG.replace(prim_path="/Visuals/Command/goal_marker")