init bug fix for stale renderer images after reset w/o kit viz

Author: matthewtrepte

source/isaaclab/isaaclab/envs/common.py

@@ -38,7 +38,7 @@ class ViewerCfg:
     """
 
     origin_type: Literal["world", "env", "asset_root", "asset_body"] = "world"
-    """The frame in which the camera eye and lookat are defined in. Default is "world".
+    """The frame in which the camera position (eye) and target (lookat) are defined in. Default is "world".
 
     Available options are:
 

source/isaaclab/isaaclab/envs/manager_based_env.py

@@ -168,9 +168,7 @@ def _init_sim(self):
         # non-rendering modes.
         # Initialize when GUI is available OR when visualizers are active (headless rendering)
         # 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")
-        )
+        has_visualizers = self.sim.has_active_visualizers()
         if self.sim.has_gui or has_visualizers:
             self.viewport_camera_controller = ViewportCameraController(self, self.cfg.viewer)
         else:

source/isaaclab/isaaclab/sim/simulation_context.py

@@ -190,6 +190,10 @@ def __init__(self, cfg: SimulationCfg | None = None):
 
         # Monotonic physics-step counter used by camera sensors for
         self._physics_step_count: int = 0
+        # Monotonic render-generation counter. This increments whenever render()
+        # is executed and lets downstream camera freshness logic distinguish
+        # render/reset transitions that occur without advancing physics steps.
+        self._render_generation: int = 0
 
         type(self)._instance = self  # Mark as valid singleton only after successful init
 
@@ -339,6 +343,16 @@ def has_offscreen_render(self) -> bool:
         """Returns whether offscreen rendering is enabled (cached at init)."""
         return self._has_offscreen_render
 
+    def has_active_visualizers(self) -> bool:
+        """Return whether any visualizer path is active for rendering/camera control."""
+        return bool(self.get_setting("/isaaclab/visualizer/types")) or bool(
+            self.get_setting("/isaaclab/video/auto_start_kit")
+        )
+
+    def can_render_rgb_array(self) -> bool:
+        """Return whether rgb-array rendering is currently available."""
+        return self.has_gui or self.has_offscreen_render or self.has_active_visualizers()
+
     @property
     def is_rendering(self) -> bool:
         """Returns whether rendering is active (GUI, RTX sensors, visualizers, or XR)."""
@@ -354,6 +368,11 @@ def get_physics_dt(self) -> float:
         """Returns the physics time step."""
         return self.physics_manager.get_physics_dt()
 
+    @property
+    def render_generation(self) -> int:
+        """Returns a monotonic counter for render() executions."""
+        return self._render_generation
+
     def _create_default_visualizer_configs(self, requested_visualizers: list[str]) -> list:
         """Create default visualizer configs for requested types.
 
@@ -725,6 +744,7 @@ def render(self, mode: int | None = None) -> None:
         """
         self.physics_manager.pre_render()
         self.update_visualizers(self.get_rendering_dt())
+        self._render_generation += 1
 
         # Call render callbacks
         if hasattr(self, "_render_callbacks"):

source/isaaclab_physx/isaaclab_physx/renderers/isaac_rtx_renderer_utils.py

@@ -14,11 +14,11 @@
 
 logger = logging.getLogger(__name__)
 
-# Module-level dedup stamp: tracks the last (sim instance, physics step) at
+# Module-level dedup stamp: tracks the last (sim instance, physics step, render generation) at
 # which Kit's ``app.update()`` was pumped.  Keyed on ``id(sim)`` so that a
 # new ``SimulationContext`` (e.g. in a new test) automatically invalidates
 # any stale stamp from a previous instance.
-_last_render_update_key: tuple[int, int] = (0, -1)
+_last_render_update_key: tuple[int, int, int] = (0, -1, -1)
 
 # ---------------------------------------------------------------------------
 # RTX streaming status tracking
@@ -91,19 +91,19 @@ def _wait_for_streaming_complete() -> None:
 
 
 def ensure_isaac_rtx_render_update() -> None:
-    """Ensure the Isaac RTX renderer has been pumped for the current physics step.
+    """Ensure the Isaac RTX renderer has been pumped for the current sim step.
 
     This keeps the Kit-specific ``app.update()`` logic inside the renderers
     package rather than in the backend-agnostic ``SimulationContext``.
 
     Safe to call from multiple ``Camera`` / ``TiledCamera`` instances per step —
     only the first call triggers ``app.update()``.  Subsequent calls are no-ops
     because the module-level ``_last_render_update_key`` already matches the
-    current ``(id(sim), step_count)`` pair.
+    current ``(id(sim), step_count, render_generation)`` tuple.
 
-    The key is a ``(sim_instance_id, step_count)`` tuple so that creating a new
-    ``SimulationContext`` (e.g. in a subsequent test) automatically invalidates
-    any stale stamp left over from a previous instance.
+    The key is a ``(sim_instance_id, step_count, render_generation)`` tuple so that:
+    - creating a new ``SimulationContext`` invalidates stale stamps, and
+    - render/reset transitions that do not advance physics step count still force a fresh update.
 
     If RTX texture/geometry streaming is in progress, additional
     ``app.update()`` calls are pumped until the streaming subsystem reports
@@ -120,7 +120,8 @@ def ensure_isaac_rtx_render_update() -> None:
     if sim is None:
         return
 
-    key = (id(sim), sim._physics_step_count)
+    render_generation = getattr(sim, "render_generation", getattr(sim, "_render_generation", 0))
+    key = (id(sim), sim._physics_step_count, render_generation)
     if _last_render_update_key == key:
         return  # Already pumped this step (by another camera or a visualizer)