Fixes the rendering logic inside the environment classes (#515)

Fixes #476

The parameter substeps in the Simulation config had no influence on the
rendering frequency.
Additionally, app.update was not properly called when initializing the
stage due to the render method overload. This led to problems when
modifying the render interval.

- Merged physics stepping and rendering inside the step method in the
simulation config.
- Renamed substeps to render_interval in the simulation config.
- Updated all the tasks

## Type of change

- Breaking change (fix or feature that would cause existing
functionality to not work as expected)

## Checklist

- [x] I have run the [`pre-commit` checks](https://pre-commit.com/) with
`./isaaclab.sh --format`
- [ ] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] I have run all the tests with `./isaaclab.sh --test` and they pass
- [x] I have updated the changelog and the corresponding version in the
extension's `config/extension.toml` file
- [x] I have added my name to the `CONTRIBUTORS.md` or my name already
exists there

Author: David Hoeller

source/extensions/omni.isaac.lab/config/extension.toml

@@ -1,7 +1,7 @@
 [package]
 
 # Note: Semantic Versioning is used: https://semver.org/
-version = "0.17.13"
+version = "0.18.0"
 
 # Description
 title = "Isaac Lab framework for Robot Learning"

source/extensions/omni.isaac.lab/docs/CHANGELOG.rst

@@ -1,6 +1,22 @@
 Changelog
 ---------
 
+0.18.0 (2024-06-13)
+~~~~~~~~~~~~~~~~~~~~
+
+Fixed
+^^^^^
+
+* Fixed the rendering logic to render at the specified interval. Earlier, the substep parameter had no effect and rendering
+  would happen once every env.step() when active.
+
+Changed
+^^^^^^^
+
+* Renamed :attr:`omni.isaac.lab.sim.SimulationCfg.substeps` to :attr:`omni.isaac.lab.sim.SimulationCfg.render_interval`.
+  The render logic is now integrated in the decimation loop of the environment.
+
+
 0.17.13 (2024-06-13)
 ~~~~~~~~~~~~~~~~~~~~
 

source/extensions/omni.isaac.lab/omni/isaac/lab/envs/direct_rl_env.py

@@ -16,6 +16,7 @@
 from collections.abc import Sequence
 from typing import Any, ClassVar
 
+import carb
 import omni.isaac.core.utils.torch as torch_utils
 import omni.kit.app
 from omni.isaac.version import get_version
@@ -91,11 +92,19 @@ def __init__(self, cfg: DirectRLEnvCfg, render_mode: str | None = None, **kwargs
         print("[INFO]: Base environment:")
         print(f"\tEnvironment device    : {self.device}")
         print(f"\tPhysics step-size     : {self.physics_dt}")
-        print(f"\tRendering step-size   : {self.physics_dt * self.cfg.sim.substeps}")
+        print(f"\tRendering step-size   : {self.physics_dt * self.cfg.sim.render_interval}")
         print(f"\tEnvironment step-size : {self.step_dt}")
         print(f"\tPhysics GPU pipeline  : {self.cfg.sim.use_gpu_pipeline}")
         print(f"\tPhysics GPU simulation: {self.cfg.sim.physx.use_gpu}")
 
+        if self.cfg.sim.render_interval < self.cfg.decimation:
+            msg = (
+                f"The render interval ({self.cfg.sim.render_interval}) is smaller than the decimation "
+                f"({self.cfg.decimation}). Multiple multiple render calls will happen for each environment step."
+                "If this is not intended, set the render interval to be equal to the decimation."
+            )
+            carb.log_warn(msg)
+
         # generate scene
         with Timer("[INFO]: Time taken for scene creation"):
             self.scene = InteractiveScene(self.cfg.scene)
@@ -146,6 +155,8 @@ def __init__(self, cfg: DirectRLEnvCfg, render_mode: str | None = None, **kwargs
         self.extras = {}
 
         # initialize data and constants
+        # -- counter for simulation steps
+        self._sim_step_counter = 0
         # -- counter for curriculum
         self.common_step_counter = 0
         # -- init buffers
@@ -270,17 +281,18 @@ def step(self, action: torch.Tensor) -> VecEnvStepReturn:
         self._pre_physics_step(action)
         # perform physics stepping
         for _ in range(self.cfg.decimation):
+            self._sim_step_counter += 1
             # set actions into buffers
             self._apply_action()
             # set actions into simulator
             self.scene.write_data_to_sim()
+            render = self._sim_step_counter % self.cfg.sim.render_interval == 0 and (
+                self.sim.has_gui() or self.sim.has_rtx_sensors()
+            )
             # simulate
-            self.sim.step(render=False)
+            self.sim.step(render=render)
             # update buffers at sim dt
             self.scene.update(dt=self.physics_dt)
-        # perform rendering if gui is enabled
-        if self.sim.has_gui() or self.sim.has_rtx_sensors():
-            self.sim.render()
 
         # post-step:
         # -- update env counters (used for curriculum generation)

source/extensions/omni.isaac.lab/omni/isaac/lab/envs/manager_based_env.py

@@ -87,11 +87,22 @@ def __init__(self, cfg: ManagerBasedEnvCfg):
         print("[INFO]: Base environment:")
         print(f"\tEnvironment device    : {self.device}")
         print(f"\tPhysics step-size     : {self.physics_dt}")
-        print(f"\tRendering step-size   : {self.physics_dt * self.cfg.sim.substeps}")
+        print(f"\tRendering step-size   : {self.physics_dt * self.cfg.sim.render_interval}")
         print(f"\tEnvironment step-size : {self.step_dt}")
         print(f"\tPhysics GPU pipeline  : {self.cfg.sim.use_gpu_pipeline}")
         print(f"\tPhysics GPU simulation: {self.cfg.sim.physx.use_gpu}")
 
+        if self.cfg.sim.render_interval < self.cfg.decimation:
+            msg = (
+                f"The render interval ({self.cfg.sim.render_interval}) is smaller than the decimation "
+                f"({self.cfg.decimation}). Multiple multiple render calls will happen for each environment step. "
+                "If this is not intended, set the render interval to be equal to the decimation."
+            )
+            carb.log_warn(msg)
+
+        # counter for simulation steps
+        self._sim_step_counter = 0
+
         # generate scene
         with Timer("[INFO]: Time taken for scene creation"):
             self.scene = InteractiveScene(self.cfg.scene)
@@ -253,17 +264,18 @@ def step(self, action: torch.Tensor) -> tuple[VecEnvObs, dict]:
         self.action_manager.process_action(action)
         # perform physics stepping
         for _ in range(self.cfg.decimation):
+            self._sim_step_counter += 1
             # set actions into buffers
             self.action_manager.apply_action()
             # set actions into simulator
             self.scene.write_data_to_sim()
+            render = self._sim_step_counter % self.cfg.sim.render_interval == 0 and (
+                self.sim.has_gui() or self.sim.has_rtx_sensors()
+            )
             # simulate
-            self.sim.step(render=False)
+            self.sim.step(render=render)
             # update buffers at sim dt
             self.scene.update(dt=self.physics_dt)
-        # perform rendering if gui is enabled
-        if self.sim.has_gui() or self.sim.has_rtx_sensors():
-            self.sim.render()
 
         # post-step: step interval event
         if "interval" in self.event_manager.available_modes:

source/extensions/omni.isaac.lab/omni/isaac/lab/envs/manager_based_rl_env.py

@@ -154,17 +154,18 @@ def step(self, action: torch.Tensor) -> VecEnvStepReturn:
         self.action_manager.process_action(action)
         # perform physics stepping
         for _ in range(self.cfg.decimation):
+            self._sim_step_counter += 1
             # set actions into buffers
             self.action_manager.apply_action()
             # set actions into simulator
             self.scene.write_data_to_sim()
+            render = self._sim_step_counter % self.cfg.sim.render_interval == 0 and (
+                self.sim.has_gui() or self.sim.has_rtx_sensors()
+            )
             # simulate
-            self.sim.step(render=False)
+            self.sim.step(render=render)
             # update buffers at sim dt
             self.scene.update(dt=self.physics_dt)
-        # perform rendering if gui is enabled
-        if self.sim.has_gui() or self.sim.has_rtx_sensors():
-            self.sim.render()
 
         # post-step:
         # -- update env counters (used for curriculum generation)

source/extensions/omni.isaac.lab/omni/isaac/lab/sim/simulation_cfg.py

@@ -168,7 +168,7 @@ class SimulationCfg:
     dt: float = 1.0 / 60.0
     """The physics simulation time-step (in seconds). Default is 0.0167 seconds."""
 
-    substeps: int = 1
+    render_interval: int = 1
     """The number of physics simulation steps per rendering step. Default is 1."""
 
     gravity: tuple[float, float, float] = (0.0, 0.0, -9.81)

source/extensions/omni.isaac.lab/omni/isaac/lab/sim/simulation_context.py

@@ -214,7 +214,7 @@ def __init__(self, cfg: SimulationCfg | None = None):
         super().__init__(
             stage_units_in_meters=1.0,
             physics_dt=self.cfg.dt,
-            rendering_dt=self.cfg.dt * self.cfg.substeps,
+            rendering_dt=self.cfg.dt * self.cfg.render_interval,
             backend="torch",
             sim_params=sim_params,
             physics_prim_path=self.cfg.physics_prim_path,
@@ -384,14 +384,14 @@ def reset(self, soft: bool = False):
                 self.render()
 
     def step(self, render: bool = True):
-        """Steps the physics simulation with the pre-defined time-step.
+        """Steps the simulation.
 
         .. note::
             This function blocks if the timeline is paused. It only returns when the timeline is playing.
 
         Args:
             render: Whether to render the scene after stepping the physics simulation.
-                If set to False, the scene is not rendered and only the physics simulation is stepped.
+                    If set to False, the scene is not rendered and only the physics simulation is stepped.
         """
         # check if the simulation timeline is paused. in that case keep stepping until it is playing
         if not self.is_playing():
@@ -467,6 +467,11 @@ async def reset_async(self, soft: bool = False):
 
     def _init_stage(self, *args, **kwargs) -> Usd.Stage:
         _ = super()._init_stage(*args, **kwargs)
+        # a stage update here is needed for the case when physics_dt != rendering_dt, otherwise the app crashes
+        # when in headless mode
+        self.set_setting("/app/player/playSimulations", False)
+        self._app.update()
+        self.set_setting("/app/player/playSimulations", True)
         # set additional physx parameters and bind material
         self._set_additional_physx_params()
         # load flatcache/fabric interface

source/extensions/omni.isaac.lab/test/assets/check_fixed_base_assets.py

@@ -144,7 +144,7 @@ def main():
     """Main function."""
 
     # Initialize the simulation context
-    sim = sim_utils.SimulationContext(sim_utils.SimulationCfg(dt=0.01, substeps=1))
+    sim = sim_utils.SimulationContext(sim_utils.SimulationCfg(dt=0.01))
     # Set main camera
     sim.set_camera_view(eye=[2.5, 2.5, 2.5], target=[0.0, 0.0, 0.0])
     # design scene

source/extensions/omni.isaac.lab/test/markers/check_markers_visibility.py

@@ -128,7 +128,7 @@ def main():
     """Main function."""
 
     # Initialize the simulation context
-    sim_cfg = sim_utils.SimulationCfg(dt=0.005, substeps=1)
+    sim_cfg = sim_utils.SimulationCfg(dt=0.005)
     sim = sim_utils.SimulationContext(sim_cfg)
     # Set main camera
     sim.set_camera_view(eye=[3.5, 3.5, 3.5], target=[0.0, 0.0, 0.0])

source/extensions/omni.isaac.lab/test/sensors/test_contact_sensor.py

@@ -9,10 +9,8 @@
 
 from omni.isaac.lab.app import AppLauncher, run_tests
 
-HEADLESS = True
-
 # launch omniverse app
-app_launcher = AppLauncher(headless=HEADLESS)
+app_launcher = AppLauncher(headless=True)
 simulation_app = app_launcher.app
 
 """Rest everything follows."""
@@ -467,7 +465,7 @@ def _perform_sim_step(self) -> None:
         # write data to simulation
         self.scene.write_data_to_sim()
         # simulate
-        self.sim.step(render=not HEADLESS)
+        self.sim.step(render=False)
         # update buffers at sim dt
         self.scene.update(dt=self.sim_dt)