resolve overlapping beahvior in viewrcfg and visualizercfg

Author: matthewtrepte

source/isaaclab/isaaclab/envs/common.py

@@ -21,7 +21,7 @@
 class ViewerCfg:
     """Configuration of the scene viewport camera."""
 
-    eye: tuple[float, float, float] = (7.5, 7.5, 117.5)
+    eye: tuple[float, float, float] = (7.5, 7.5, 7.5)
     """Initial camera position (in m). Default is (7.5, 7.5, 7.5)."""
 
     lookat: tuple[float, float, float] = (0.0, 0.0, 0.0)
@@ -67,6 +67,7 @@ class ViewerCfg:
     This quantity is only effective if :attr:`origin` is set to "asset_body".
     """
 
+
 ##
 # Types.
 ##

source/isaaclab/isaaclab/envs/manager_based_env.py

@@ -167,7 +167,7 @@ def _init_sim(self):
         # FIXME: This needs to be fixed in the future when we unify the UI functionalities even for
         # non-rendering modes.
         # Initialize when GUI is available OR when visualizers are active (headless rendering)
-        # Visualizers support camera updates via sim.set_camera_view() which forwards to all active visualizers
+        # ViewerCfg camera updates are applied through renderer camera control.
         has_visualizers = bool(self.sim.get_setting("/isaaclab/visualizer/types")) or bool(
             self.sim.get_setting("/isaaclab/video/auto_start_kit")
         )

source/isaaclab/isaaclab/envs/mdp/commands/velocity_command.py

@@ -223,6 +223,7 @@ def _resolve_xy_velocity_to_arrow(self, xy_velocity: torch.Tensor) -> tuple[torc
 
         return arrow_scale, arrow_quat
 
+
 class NormalVelocityCommand(UniformVelocityCommand):
     """Command generator that generates a velocity command in SE(2) from a normal distribution.
 

source/isaaclab/isaaclab/envs/ui/viewport_camera_controller.py

@@ -218,8 +218,8 @@ def update_view_location(self, eye: Sequence[float] | None = None, lookat: Seque
         cam_eye = viewer_origin + self.default_cam_eye
         cam_target = viewer_origin + self.default_cam_lookat
 
-        # set the camera view
-        self._env.sim.set_camera_view(eye=cam_eye, target=cam_target)
+        # set the renderer viewport camera view (does not broadcast to visualizers)
+        self._env.sim.set_renderer_camera_view(eye=cam_eye, target=cam_target, camera_prim_path=self.cfg.cam_prim_path)
 
     """
     Private Functions

source/isaaclab/isaaclab/sim/simulation_context.py

@@ -659,6 +659,25 @@ def set_camera_view(self, eye: tuple, target: tuple) -> None:
         for viz in self._visualizers:
             viz.set_camera_view(eye, target)
 
+    def set_renderer_camera_view(
+        self,
+        eye: tuple[float, float, float] | list[float],
+        target: tuple[float, float, float] | list[float],
+        camera_prim_path: str = "/OmniverseKit_Persp",
+    ) -> None:
+        """Set camera view for renderer/viewport camera only.
+
+        This does not broadcast to visualizers.
+        """
+        try:
+            import isaacsim.core.utils.viewports as isaacsim_viewports
+
+            isaacsim_viewports.set_camera_view(
+                eye=list(eye), target=list(target), camera_prim_path=str(camera_prim_path)
+            )
+        except Exception as exc:
+            logger.debug("[SimulationContext] Renderer camera update skipped: %s", exc)
+
     def forward(self) -> None:
         """Update kinematics without stepping physics."""
         self.physics_manager.forward()

source/isaaclab/isaaclab/visualizers/base_visualizer.py

@@ -189,23 +189,11 @@ def set_camera_view(self, eye: tuple, target: tuple) -> None:
 
     def _resolve_cfg_camera_pose(
         self, visualizer_name: str
-    ) -> tuple[tuple[float, float, float], tuple[float, float, float]] | None:
-        """Resolve camera pose from cfg fields, allowing opt-out via ``None``.
-
-        Returns ``None`` when both cfg camera fields are ``None`` (keep backend
-        default camera) or when only one field is ``None`` (invalid partial pose).
-        """
-        eye = getattr(self.cfg, "eye", None)
-        lookat = getattr(self.cfg, "lookat", None)
-        if eye is None and lookat is None:
-            return None
-        if eye is None or lookat is None:
-            logger.warning(
-                "[%s] eye/lookat must be both set or both None. "
-                "Keeping current camera pose.",
-                visualizer_name,
-            )
-            return None
+    ) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
+        """Resolve camera pose from cfg eye/lookat fields."""
+        del visualizer_name
+        eye = tuple(float(v) for v in getattr(self.cfg, "eye"))
+        lookat = tuple(float(v) for v in getattr(self.cfg, "lookat"))
         return eye, lookat
 
     def _resolve_camera_pose_from_usd_path(

source/isaaclab/isaaclab/visualizers/visualizer_cfg.py

@@ -34,25 +34,17 @@ class VisualizerCfg:
     enable_live_plots: bool = True
     """Enable live plotting of data."""
 
-    eye: tuple[float, float, float] | None = (8.0, 8.0, 3.0)
-    """Initial camera eye position (x, y, z) in world coordinates.
+    eye: tuple[float, float, float] = (8.0, 8.0, 3.0)
+    """Initial camera eye position (x, y, z) in world coordinates."""
 
-    Set to ``None`` (with :attr:`lookat` also set to ``None``) to keep
-    the visualizer's default camera pose.
-    """
-
-    lookat: tuple[float, float, float] | None = (0.0, 0.0, 0.0)
-    """Initial camera look-at point (x, y, z) in world coordinates.
-
-    Set to ``None`` (with :attr:`eye` also set to ``None``) to keep
-    the visualizer's default camera pose.
-    """
+    lookat: tuple[float, float, float] = (0.0, 0.0, 0.0)
+    """Initial camera look-at point (x, y, z) in world coordinates."""
 
-    camera_source: Literal["cfg", "usd_path"] = "cfg"
-    """Camera source mode: 'cfg' uses eye/lookat, 'usd_path' follows a USD camera prim."""
+    cam_source: Literal["cfg", "prim_path"] = "cfg"
+    """Camera source mode: 'cfg' uses eye/lookat, 'prim_path' follows a camera prim."""
 
-    camera_usd_path: str = "/World/envs/env_0/Camera"
-    """Absolute USD path to a camera prim when camera_source='usd_path'."""
+    cam_prim_path: str = "/World/envs/env_0/Camera"
+    """Absolute USD path to a camera prim when cam_source='prim_path'."""
 
     env_filter_mode: Literal["none", "env_ids", "random_n"] = "none"
     """Env filter mode: 'none', 'env_ids', or 'random_n'."""

source/isaaclab_visualizers/isaaclab_visualizers/kit/kit_visualizer.py

@@ -83,7 +83,9 @@ def initialize(self, scene_data_provider: BaseSceneDataProvider) -> None:
             rows=[
                 ("eye", self.cfg.eye),
                 ("lookat", self.cfg.lookat),
-                ("camera_source", self.cfg.camera_source),
+                ("cam_source", self.cfg.cam_source),
+                ("visualizer_camera_prim_path", self.cfg.visualizer_camera_prim_path),
+                ("enable_visualizer_cam", self.cfg.enable_visualizer_cam),
                 ("num_visualized_envs", num_visualized_envs),
                 ("create_viewport", self.cfg.create_viewport),
                 ("headless", self._runtime_headless),
@@ -181,6 +183,9 @@ def set_camera_view(
         if not self._is_initialized:
             logger.debug("[KitVisualizer] set_camera_view() ignored because visualizer is not initialized.")
             return
+        if not self.cfg.enable_visualizer_cam:
+            logger.debug("[KitVisualizer] set_camera_view() ignored because enable_visualizer_cam=False.")
+            return
         self._set_viewport_camera(tuple(eye), tuple(target))
 
     # ---- Viewport + camera ----------------------------------------------------------------
@@ -223,11 +228,17 @@ def _setup_viewport(self, usd_stage) -> None:
             # In headless mode we keep the visualizer active but skip viewport/window setup.
             self._viewport_window = None
             self._viewport_api = None
-            self._controlled_camera_path = "/OmniverseKit_Persp"
+            self._controlled_camera_path = "/OmniverseKit_Persp" if self.cfg.enable_visualizer_cam else None
+            if not self.cfg.enable_visualizer_cam:
+                return
             self._apply_cfg_camera_pose_if_configured()
             return
 
-        if self.cfg.create_viewport and self.cfg.viewport_name:
+        if self.cfg.create_viewport:
+            if not self.cfg.viewport_name.strip():
+                raise RuntimeError(
+                    "[KitVisualizer] viewport_name must be a non-empty string when create_viewport=True."
+                )
             dock_position_name = self.cfg.dock_position.upper()
             dock_position_map = {
                 "LEFT": DockPosition.LEFT,
@@ -247,7 +258,6 @@ def _setup_viewport(self, usd_stage) -> None:
             )
 
             asyncio.ensure_future(self._dock_viewport_async(self.cfg.viewport_name, dock_pos))
-            self._create_and_assign_camera(usd_stage)
         else:
             self._viewport_window = vp_utils.get_active_viewport_window()
 
@@ -256,16 +266,18 @@ def _setup_viewport(self, usd_stage) -> None:
             self._viewport_api = None
             return
         self._viewport_api = self._viewport_window.viewport_api
-        # Pin the camera path we will write to, using the active camera at init time.
-        # This must happen before any _set_viewport_camera() call so the path is known.
-        self._controlled_camera_path = self._viewport_api.get_active_camera() or "/OmniverseKit_Persp"
-        if self.cfg.camera_source == "usd_path":
-            if not self._set_active_camera_path(self.cfg.camera_usd_path):
-                logger.warning(
-                    "[KitVisualizer] camera_usd_path '%s' not found; using configured camera.",
-                    self.cfg.camera_usd_path,
+        if not self.cfg.enable_visualizer_cam:
+            self._controlled_camera_path = None
+            return
+        # Always create/use a dedicated visualizer-controlled camera so we never mutate
+        # existing viewport cameras (e.g. /OmniverseKit_Persp or sensor cameras).
+        self._create_and_assign_camera(usd_stage)
+        if self.cfg.cam_source == "prim_path":
+            if not self._set_active_camera_path(self.cfg.cam_prim_path):
+                raise RuntimeError(
+                    "[KitVisualizer] cam_source='prim_path' requires a valid cam_prim_path. "
+                    f"Camera prim not found: '{self.cfg.cam_prim_path}'."
                 )
-                self._apply_cfg_camera_pose_if_configured()
         else:
             self._apply_cfg_camera_pose_if_configured()
 
@@ -301,8 +313,10 @@ async def _dock_viewport_async(self, viewport_name: str, dock_position) -> None:
             viewport_window.focus()
 
     def _create_and_assign_camera(self, usd_stage) -> None:
-        """Create viewport camera prim (if needed) and set it active."""
-        camera_path = f"/World/Cameras/{self.cfg.viewport_name}_Camera".replace(" ", "_")
+        """Create dedicated visualizer camera prim (if needed) and set it active."""
+        camera_path = self.cfg.visualizer_camera_prim_path
+        if not camera_path:
+            raise RuntimeError("[KitVisualizer] visualizer_camera_prim_path must be a non-empty prim path.")
 
         camera_prim = usd_stage.GetPrimAtPath(camera_path)
         if not camera_prim.IsValid():
@@ -329,19 +343,7 @@ def _set_viewport_camera(self, position: tuple[float, float, float], target: tup
         isaacsim_viewports.set_camera_view(**kwargs)
 
     def _apply_cfg_camera_pose_if_configured(self) -> None:
-        """Apply configured camera pose if both position and target are provided.
-
-        When either field is ``None``, keep the current/default perspective
-        camera transform unchanged.
-        """
-        if self.cfg.eye is None and self.cfg.lookat is None:
-            return
-        if self.cfg.eye is None or self.cfg.lookat is None:
-            logger.warning(
-                "[KitVisualizer] eye/lookat must be both set or both None. "
-                "Keeping current camera pose."
-            )
-            return
+        """Apply configured camera pose from eye/lookat."""
         self._set_viewport_camera(self.cfg.eye, self.cfg.lookat)
 
     def _set_active_camera_path(self, camera_path: str) -> bool:

source/isaaclab_visualizers/isaaclab_visualizers/kit/kit_visualizer_cfg.py

@@ -16,25 +16,21 @@ class KitVisualizerCfg(VisualizerCfg):
     visualizer_type: str = "kit"
     """Type identifier for Kit visualizer."""
 
-    eye: tuple[float, float, float] | None = (8.0, 8.0, 3.0)
-    """Initial camera eye override.
+    viewport_name: str = "Visualizer Viewport"
+    """Viewport name to use when :attr:`create_viewport` is True."""
 
-    If set to ``None`` (with :attr:`lookat` also set to ``None``), the
-    visualizer keeps the current/default perspective camera pose.
-    """
-
-    lookat: tuple[float, float, float] | None = (0.0, 0.0, 0.0)
-    """Initial camera look-at override.
+    create_viewport: bool = False
+    """Create new viewport with specified name and camera pose."""
 
-    If set to ``None`` (with :attr:`eye` also set to ``None``), the
-    visualizer keeps the current/default perspective camera pose.
-    """
+    visualizer_camera_prim_path: str = "/World/Cameras/KitVisualizerCamera"
+    """Dedicated camera prim path controlled by the Kit visualizer."""
 
-    viewport_name: str | None = "Visualizer Viewport"
-    """Viewport name to use. If None, uses active viewport."""
+    enable_visualizer_cam: bool = False
+    """Whether the Kit visualizer should control/bind a dedicated viewport camera.
 
-    create_viewport: bool = False
-    """Create new viewport with specified name and camera pose."""
+    If False, Kit does not create/switch camera prims and ignores visualizer camera control
+    updates (including eye/lookat and cam_source handling).
+    """
 
     headless: bool = False
     """Run without creating viewport windows when supported by the app."""

source/isaaclab_visualizers/isaaclab_visualizers/newton/newton_visualizer.py

@@ -315,8 +315,7 @@ def initialize(self, scene_data_provider: BaseSceneDataProvider) -> None:
             self._viewer.set_model(self._model, max_worlds=max_worlds)
             self._viewer.set_world_offsets((0.0, 0.0, 0.0))
             initial_pose = self._resolve_initial_camera_pose()
-            if initial_pose is not None:
-                self._apply_camera_pose(initial_pose)
+            self._apply_camera_pose(initial_pose)
             self._viewer.up_axis = 2  # Z-up
 
             self._viewer.scaling = 1.0
@@ -345,12 +344,10 @@ def initialize(self, scene_data_provider: BaseSceneDataProvider) -> None:
             rows=[
                 (
                     "eye",
-                    tuple(float(x) for x in self._viewer.camera.pos)
-                    if self._viewer is not None
-                    else self.cfg.eye,
+                    tuple(float(x) for x in self._viewer.camera.pos) if self._viewer is not None else self.cfg.eye,
                 ),
                 ("lookat", self._last_camera_pose[1] if self._last_camera_pose else self.cfg.lookat),
-                ("camera_source", self.cfg.camera_source),
+                ("cam_source", self.cfg.cam_source),
                 ("num_visualized_envs", num_visualized_envs),
                 ("headless", self.cfg.headless),
             ],
@@ -374,7 +371,7 @@ def step(self, dt: float) -> None:
                 self._state = self._scene_data_provider.get_newton_state(self._env_ids)
             return
 
-        if self.cfg.camera_source == "usd_path":
+        if self.cfg.cam_source == "prim_path":
             self._update_camera_from_usd_path()
 
         self._state = self._scene_data_provider.get_newton_state(self._env_ids)
@@ -433,19 +430,19 @@ def is_running(self) -> bool:
             return False
         return self._viewer.is_running()
 
-    def _resolve_initial_camera_pose(self) -> tuple[tuple[float, float, float], tuple[float, float, float]] | None:
+    def _resolve_initial_camera_pose(self) -> tuple[tuple[float, float, float], tuple[float, float, float]]:
         """Resolve initial camera pose from config or USD camera path.
 
         Returns:
-            Camera eye and target tuples, or ``None`` to keep viewer defaults.
+            Camera eye and target tuples.
         """
-        if self.cfg.camera_source == "usd_path":
-            pose = self._resolve_camera_pose_from_usd_path(self.cfg.camera_usd_path)
+        if self.cfg.cam_source == "prim_path":
+            pose = self._resolve_camera_pose_from_usd_path(self.cfg.cam_prim_path)
             if pose is not None:
                 return pose
-            logger.warning(
-                "[NewtonVisualizer] camera_usd_path '%s' not found; using configured camera.",
-                self.cfg.camera_usd_path,
+            raise RuntimeError(
+                "[NewtonVisualizer] cam_source='prim_path' requires a resolvable camera prim path, "
+                f"but no camera pose was found for '{self.cfg.cam_prim_path}'."
             )
         return self._resolve_cfg_camera_pose("NewtonVisualizer")
 
@@ -471,7 +468,7 @@ def _apply_camera_pose(self, pose: tuple[tuple[float, float, float], tuple[float
 
     def _update_camera_from_usd_path(self) -> None:
         """Refresh camera pose from configured USD camera path when it changes."""
-        pose = self._resolve_camera_pose_from_usd_path(self.cfg.camera_usd_path)
+        pose = self._resolve_camera_pose_from_usd_path(self.cfg.cam_prim_path)
         if pose is None:
             return
         if self._last_camera_pose == pose: