complete renaming

Author: matthewtrepte

docs/source/how-to/configure_rendering.rst

@@ -19,8 +19,8 @@ Selecting a Rendering Mode Profile
 
 Rendering mode can be selected in two ways:
 
-1. Set ``rendering_quality`` in a visualizer config, which selects an entry from
-   :attr:`~sim.SimulationCfg.rendering_quality_cfgs`.
+1. Set the visualizer profile selector field ``rendering_mode``, which selects an entry from
+   :attr:`~sim.SimulationCfg.rendering_mode_cfgs`.
 
    .. code-block:: python
 
@@ -30,21 +30,21 @@ Rendering mode can be selected in two ways:
       sim_cfg = sim_utils.SimulationCfg(
           visualizer_cfgs=[
               KitVisualizerCfg(
-                  rendering_quality="performance",
+                  rendering_mode="performance",
               ),
           ],
       )
 
 2. Use the ``--rendering_mode`` CLI argument, which takes precedence over
-   ``visualizer_cfg.rendering_quality``.
+   ``visualizer_cfg.rendering_mode``.
 
    .. code-block:: bash
 
       ./isaaclab.sh -p scripts/tutorials/00_sim/set_rendering_mode.py --rendering_mode {performance/balanced/quality}
 
 Notes:
 
-* If ``rendering_quality=None`` for a visualizer, Isaac Lab does not apply rendering overrides
+* If ``rendering_mode=None`` for a visualizer, Isaac Lab does not apply rendering overrides
   for that visualizer, and backend/native defaults (for Kit, USD-authored settings) are used.
 * ``--rendering_mode`` is the supported CLI entry point.
 

source/isaaclab/isaaclab/rendering_mode/rendering_mode_utils.py

@@ -3,7 +3,7 @@
 #
 # SPDX-License-Identifier: BSD-3-Clause
 
-"""Utility helpers for applying rendering quality profiles."""
+"""Utility helpers for applying rendering mode profiles."""
 
 from __future__ import annotations
 
@@ -20,10 +20,10 @@ def apply_kit_rendering_preset(set_setting: Any, preset_name: str) -> None:
         set_setting(key, value)
 
 
-def apply_kit_rendering_quality_cfg(set_setting: Any, quality_cfg: RenderingModeCfg) -> None:
-    """Apply kit-specific quality fields."""
-    if quality_cfg.rendering_mode_preset:
-        apply_kit_rendering_preset(set_setting, quality_cfg.rendering_mode_preset)
+def apply_kit_rendering_mode_cfg(set_setting: Any, mode_cfg: RenderingModeCfg) -> None:
+    """Apply kit-specific rendering mode fields."""
+    if mode_cfg.rendering_mode_preset:
+        apply_kit_rendering_preset(set_setting, mode_cfg.rendering_mode_preset)
 
     field_to_carb = {
         "kit_enable_translucency": "/rtx/translucency/enabled",
@@ -39,21 +39,21 @@ def apply_kit_rendering_quality_cfg(set_setting: Any, quality_cfg: RenderingMode
         "kit_dome_light_upper_lower_strategy": "/rtx/domeLight/upperLowerStrategy",
     }
     for field_name, carb_key in field_to_carb.items():
-        value = getattr(quality_cfg, field_name, None)
+        value = getattr(mode_cfg, field_name, None)
         if value is not None:
             set_setting(carb_key, value)
 
-    if quality_cfg.kit_antialiasing_mode is not None:
+    if mode_cfg.kit_antialiasing_mode is not None:
         try:
             import omni.replicator.core as rep
 
-            rep.settings.set_render_rtx_realtime(antialiasing=quality_cfg.kit_antialiasing_mode)
+            rep.settings.set_render_rtx_realtime(antialiasing=mode_cfg.kit_antialiasing_mode)
         except Exception:
             pass
 
 
-def apply_newton_quality_cfg_to_visualizer_cfg(visualizer_cfg: Any, quality_cfg: RenderingModeCfg) -> None:
-    """Apply Newton quality values to a visualizer cfg object."""
+def apply_newton_mode_cfg_to_visualizer_cfg(visualizer_cfg: Any, mode_cfg: RenderingModeCfg) -> None:
+    """Apply Newton rendering mode values to a visualizer cfg object."""
     override_fields = {
         "newton_enable_shadows": "enable_shadows",
         "newton_enable_sky": "enable_sky",
@@ -62,102 +62,102 @@ def apply_newton_quality_cfg_to_visualizer_cfg(visualizer_cfg: Any, quality_cfg:
         "newton_sky_lower_color": "sky_lower_color",
         "newton_light_color": "light_color",
     }
-    for quality_field, viz_field in override_fields.items():
-        value = getattr(quality_cfg, quality_field, None)
+    for mode_field, viz_field in override_fields.items():
+        value = getattr(mode_cfg, mode_field, None)
         if value is not None and hasattr(visualizer_cfg, viz_field):
             setattr(visualizer_cfg, viz_field, value)
 
 
-def apply_newton_quality_cfg_to_viewer(viewer: Any, quality_cfg: RenderingModeCfg) -> None:
-    """Apply Newton quality values to a live Newton viewer renderer, if available."""
+def apply_newton_mode_cfg_to_viewer(viewer: Any, mode_cfg: RenderingModeCfg) -> None:
+    """Apply Newton rendering mode values to a live Newton viewer renderer, if available."""
     if viewer is None or not hasattr(viewer, "renderer"):
         return
 
-    if quality_cfg.newton_enable_shadows is not None:
-        viewer.renderer.draw_shadows = quality_cfg.newton_enable_shadows
-    if quality_cfg.newton_enable_sky is not None:
-        viewer.renderer.draw_sky = quality_cfg.newton_enable_sky
-    if quality_cfg.newton_enable_wireframe is not None:
-        viewer.renderer.draw_wireframe = quality_cfg.newton_enable_wireframe
-    if quality_cfg.newton_sky_upper_color is not None:
-        viewer.renderer.sky_upper = quality_cfg.newton_sky_upper_color
-    if quality_cfg.newton_sky_lower_color is not None:
-        viewer.renderer.sky_lower = quality_cfg.newton_sky_lower_color
-    if quality_cfg.newton_light_color is not None:
-        viewer.renderer._light_color = quality_cfg.newton_light_color
-
-
-def resolve_rendering_quality_name_for_visualizer_cfg(get_setting: Any, visualizer_cfg: Any) -> str | None:
-    """Resolve effective quality profile name for a visualizer cfg."""
-    cli_quality_explicit = bool(get_setting("/isaaclab/rendering/rendering_mode/explicit"))
-    cli_quality = get_setting("/isaaclab/rendering/rendering_mode")
-    if cli_quality_explicit:
-        return cli_quality if cli_quality else None
-    quality_name = getattr(visualizer_cfg, "rendering_quality", None)
-    return quality_name if quality_name else None
-
-
-def resolve_rendering_quality_cfg(
-    quality_name: str | None, quality_cfgs: dict[str, RenderingModeCfg], logger: Any
+    if mode_cfg.newton_enable_shadows is not None:
+        viewer.renderer.draw_shadows = mode_cfg.newton_enable_shadows
+    if mode_cfg.newton_enable_sky is not None:
+        viewer.renderer.draw_sky = mode_cfg.newton_enable_sky
+    if mode_cfg.newton_enable_wireframe is not None:
+        viewer.renderer.draw_wireframe = mode_cfg.newton_enable_wireframe
+    if mode_cfg.newton_sky_upper_color is not None:
+        viewer.renderer.sky_upper = mode_cfg.newton_sky_upper_color
+    if mode_cfg.newton_sky_lower_color is not None:
+        viewer.renderer.sky_lower = mode_cfg.newton_sky_lower_color
+    if mode_cfg.newton_light_color is not None:
+        viewer.renderer._light_color = mode_cfg.newton_light_color
+
+
+def resolve_rendering_mode_name_for_visualizer_cfg(get_setting: Any, visualizer_cfg: Any) -> str | None:
+    """Resolve effective rendering mode profile name for a visualizer cfg."""
+    cli_mode_explicit = bool(get_setting("/isaaclab/rendering/rendering_mode/explicit"))
+    cli_mode = get_setting("/isaaclab/rendering/rendering_mode")
+    if cli_mode_explicit:
+        return cli_mode if cli_mode else None
+    mode_name = getattr(visualizer_cfg, "rendering_mode", None)
+    return mode_name if mode_name else None
+
+
+def resolve_rendering_mode_cfg(
+    mode_name: str | None, mode_cfgs: dict[str, RenderingModeCfg], logger: Any
 ) -> RenderingModeCfg | None:
-    """Fetch quality cfg by name and log if missing."""
-    if not quality_name:
+    """Fetch rendering mode cfg by name and log if missing."""
+    if not mode_name:
         return None
-    quality_cfg = quality_cfgs.get(quality_name)
-    if quality_cfg is None:
+    mode_cfg = mode_cfgs.get(mode_name)
+    if mode_cfg is None:
         logger.warning(
-            "[SimulationContext] Rendering quality '%s' not found in SimulationCfg.rendering_quality_cfgs.",
-            quality_name,
+            "[SimulationContext] Rendering mode '%s' not found in SimulationCfg.rendering_mode_cfgs.",
+            mode_name,
         )
         return None
-    return quality_cfg
+    return mode_cfg
 
 
-def apply_quality_profile_to_visualizer_cfg(
+def apply_mode_profile_to_visualizer_cfg(
     get_setting: Any,
     set_setting: Any,
     visualizer_cfg: Any,
-    quality_cfgs: dict[str, RenderingModeCfg],
+    mode_cfgs: dict[str, RenderingModeCfg],
     logger: Any,
 ) -> None:
-    """Resolve and apply quality profile to a visualizer config."""
-    quality_name = resolve_rendering_quality_name_for_visualizer_cfg(get_setting, visualizer_cfg)
-    quality_cfg = resolve_rendering_quality_cfg(quality_name, quality_cfgs, logger)
-    if quality_cfg is None:
+    """Resolve and apply rendering mode profile to a visualizer config."""
+    mode_name = resolve_rendering_mode_name_for_visualizer_cfg(get_setting, visualizer_cfg)
+    mode_cfg = resolve_rendering_mode_cfg(mode_name, mode_cfgs, logger)
+    if mode_cfg is None:
         return
 
     visualizer_type = getattr(visualizer_cfg, "visualizer_type", None)
     if visualizer_type == "kit":
-        apply_kit_rendering_quality_cfg(set_setting, quality_cfg)
+        apply_kit_rendering_mode_cfg(set_setting, mode_cfg)
     elif visualizer_type == "newton":
-        apply_newton_quality_cfg_to_visualizer_cfg(visualizer_cfg, quality_cfg)
+        apply_newton_mode_cfg_to_visualizer_cfg(visualizer_cfg, mode_cfg)
 
 
-def apply_runtime_quality_profile_to_visualizer(
+def apply_runtime_mode_profile_to_visualizer(
     get_setting: Any,
     set_setting: Any,
     viz: Any,
-    visualizer_quality_keys: dict[int, str | None],
-    quality_cfgs: dict[str, RenderingModeCfg],
+    visualizer_mode_keys: dict[int, str | None],
+    mode_cfgs: dict[str, RenderingModeCfg],
     logger: Any,
     force: bool = False,
 ) -> None:
-    """Resolve and apply runtime quality profile to an active visualizer."""
-    quality_name = resolve_rendering_quality_name_for_visualizer_cfg(get_setting, viz.cfg)
+    """Resolve and apply runtime rendering mode profile to an active visualizer."""
+    mode_name = resolve_rendering_mode_name_for_visualizer_cfg(get_setting, viz.cfg)
     viz_id = id(viz)
-    if not force and visualizer_quality_keys.get(viz_id) == quality_name:
+    if not force and visualizer_mode_keys.get(viz_id) == mode_name:
         return
 
-    quality_cfg = resolve_rendering_quality_cfg(quality_name, quality_cfgs, logger)
-    if quality_cfg is None:
-        visualizer_quality_keys[viz_id] = quality_name
+    mode_cfg = resolve_rendering_mode_cfg(mode_name, mode_cfgs, logger)
+    if mode_cfg is None:
+        visualizer_mode_keys[viz_id] = mode_name
         return
 
     viz_type = getattr(viz.cfg, "visualizer_type", None)
     if viz_type == "kit":
-        apply_kit_rendering_quality_cfg(set_setting, quality_cfg)
+        apply_kit_rendering_mode_cfg(set_setting, mode_cfg)
     elif viz_type == "newton":
-        apply_newton_quality_cfg_to_visualizer_cfg(viz.cfg, quality_cfg)
-        apply_newton_quality_cfg_to_viewer(getattr(viz, "_viewer", None), quality_cfg)
+        apply_newton_mode_cfg_to_visualizer_cfg(viz.cfg, mode_cfg)
+        apply_newton_mode_cfg_to_viewer(getattr(viz, "_viewer", None), mode_cfg)
 
-    visualizer_quality_keys[viz_id] = quality_name
+    visualizer_mode_keys[viz_id] = mode_name

source/isaaclab/isaaclab/sim/simulation_cfg.py

@@ -93,12 +93,12 @@ class SimulationCfg:
     a different config (e.g., NewtonManagerCfg) to use a different physics backend.
     """
 
-    rendering_quality_cfgs: dict[str, RenderingModeCfg] = {
+    rendering_mode_cfgs: dict[str, RenderingModeCfg] = {
         "performance": RenderingModeCfg(rendering_mode_preset="performance"),
         "balanced": RenderingModeCfg(rendering_mode_preset="balanced"),
         "quality": RenderingModeCfg(rendering_mode_preset="quality"),
     }
-    """Named rendering quality profiles available to visualizers/renderers."""
+    """Named rendering mode profiles available to visualizers/renderers."""
 
     create_stage_in_memory: bool = False
     """If stage is first created in memory. Default is False.

source/isaaclab/isaaclab/sim/simulation_context.py

@@ -296,18 +296,18 @@ def _apply_quality_profile_to_visualizer_cfg(self, visualizer_cfg: Any) -> None:
             self.get_setting,
             self.set_setting,
             visualizer_cfg,
-            quality_cfgs,
+            mode_cfgs,
             logger,
         )
 
-    def _apply_runtime_quality_profile_to_visualizer(self, viz: Visualizer, force: bool = False) -> None:
-        quality_cfgs = getattr(self.cfg, "rendering_quality_cfgs", None) or {}
-        apply_runtime_quality_profile_to_visualizer(
+    def _apply_runtime_mode_profile_to_visualizer(self, viz: Visualizer, force: bool = False) -> None:
+        mode_cfgs = getattr(self.cfg, "rendering_mode_cfgs", None) or {}
+        apply_runtime_mode_profile_to_visualizer(
             self.get_setting,
             self.set_setting,
             viz,
-            self._visualizer_quality_keys,
-            quality_cfgs,
+            self._visualizer_mode_keys,
+            mode_cfgs,
             logger,
             force=force,
         )
@@ -588,10 +588,10 @@ def initialize_visualizers(self) -> None:
 
         for cfg in visualizer_cfgs:
             try:
-                self._apply_quality_profile_to_visualizer_cfg(cfg)
+                self._apply_mode_profile_to_visualizer_cfg(cfg)
                 visualizer = cfg.create_visualizer()
                 visualizer.initialize(self._scene_data_provider)
-                self._apply_runtime_quality_profile_to_visualizer(visualizer, force=True)
+                self._apply_runtime_mode_profile_to_visualizer(visualizer, force=True)
                 self._visualizers.append(visualizer)
             except Exception as exc:
                 if cli_explicit:
@@ -733,7 +733,7 @@ def update_visualizers(self, dt: float) -> None:
 
         for viz in visualizers_to_remove:
             try:
-                self._visualizer_quality_keys.pop(id(viz), None)
+                self._visualizer_mode_keys.pop(id(viz), None)
                 viz.close()
                 self._visualizers.remove(viz)
                 logger.info("Removed visualizer: %s", type(viz).__name__)
@@ -808,7 +808,7 @@ def clear_instance(cls) -> None:
 
             # Close all visualizers
             for viz in cls._instance._visualizers:
-                cls._instance._visualizer_quality_keys.pop(id(viz), None)
+                cls._instance._visualizer_mode_keys.pop(id(viz), None)
                 viz.close()
             cls._instance._visualizers.clear()
             if cls._instance._scene_data_provider is not None:

source/isaaclab/test/sim/test_simulation_render_config.py

@@ -87,7 +87,7 @@ def test_render_cfg():
 
 # @pytest.mark.isaacsim_ci
 def test_render_cfg_presets():
-    """Test that quality presets are applied and can be overridden via RenderingModeCfg."""
+    """Test that rendering mode presets are applied and can be overridden via RenderingModeCfg."""
 
     # user-friendly field override
     dlss_mode = ("/rtx/post/dlss/execMode", 5)
@@ -101,13 +101,13 @@ def test_render_cfg_presets():
         preset_dict = get_kit_rendering_preset(rendering_mode)
 
         profile_name = f"profile_{rendering_mode}"
-        quality_cfg = RenderingModeCfg(
+        mode_cfg = RenderingModeCfg(
             rendering_mode_preset=rendering_mode,
             kit_dlss_mode=dlss_mode[1],
         )
         cfg = SimulationCfg(
-            rendering_quality_cfgs={profile_name: quality_cfg},
-            visualizer_cfgs=KitVisualizerCfg(rendering_quality=profile_name),
+            rendering_mode_cfgs={profile_name: mode_cfg},
+            visualizer_cfgs=KitVisualizerCfg(rendering_mode=profile_name),
         )
 
         sim = SimulationContext(cfg)
@@ -137,9 +137,9 @@ def test_render_cfg_presets():
 
 @pytest.mark.skip(reason="Timeline not stopped")
 # @pytest.mark.isaacsim_ci
-def test_rendering_quality_cfg_field_overrides():
+def test_rendering_mode_cfg_field_overrides():
     """Test that explicit RenderingModeCfg fields map to carb settings."""
-    quality_cfg = RenderingModeCfg(
+    mode_cfg = RenderingModeCfg(
         kit_enable_translucency=True,
         kit_enable_reflections=True,
         kit_enable_global_illumination=True,
@@ -153,8 +153,8 @@ def test_rendering_quality_cfg_field_overrides():
         kit_enable_ambient_occlusion=True,
     )
     cfg = SimulationCfg(
-        rendering_quality_cfgs={"custom": quality_cfg},
-        visualizer_cfgs=KitVisualizerCfg(rendering_quality="custom"),
+        rendering_mode_cfgs={"custom": mode_cfg},
+        visualizer_cfgs=KitVisualizerCfg(rendering_mode="custom"),
     )
     sim = SimulationContext(cfg)
     sim.reset()

source/isaaclab_physx/isaaclab_physx/renderers/rtx_renderer_cfg.py

@@ -18,4 +18,4 @@ class RTXRendererCfg(RendererCfg):
     """
 
     renderer_type: str = "rtx"
-    rendering_quality: str | None = None
+    rendering_mode: str | None = None