Use launcher runtime intent for clone decision

Author: ooctipus

source/isaaclab/isaaclab/scene/interactive_scene.py

@@ -36,7 +36,6 @@
 from isaaclab.sim.utils.stage import get_current_stage, get_current_stage_id
 from isaaclab.sim.views import FrameView
 from isaaclab.terrains import TerrainImporter, TerrainImporterCfg
-from isaaclab.utils.version import has_kit
 
 # Note: This is a temporary import for the VisuoTactileSensorCfg class.
 # It will be removed once the VisuoTactileSensor class is added to the core Isaac Lab framework.
@@ -146,7 +145,6 @@ def __init__(self, cfg: InteractiveSceneCfg):
         self.stage_id = get_current_stage_id()
         self.physics_backend = self.sim.physics_manager.__name__.lower()
         requested_viz_types = set(self.sim.resolve_visualizer_types())
-        requested_renderer_types = set(self._cfg_renderer_types())
         if self.physics_backend.startswith("ovphysx"):
             from isaaclab_ovphysx.cloner import ovphysx_replicate
 
@@ -166,13 +164,14 @@ def __init__(self, cfg: InteractiveSceneCfg):
         # prepare cloner for environment replication
         self.env_prim_paths = [f"{self.env_ns}/env_{i}" for i in range(self.cfg.num_envs)]
         is_newton_replicated_scene = self.cfg.replicate_physics and self.physics_backend.startswith("newton")
+        has_ovrtx_renderer = self.sim.has_requested_renderer_type("ovrtx")
 
         self.cloner_cfg = cloner.CloneCfg(
             clone_regex=self.env_regex_ns,
             clone_in_fabric=self.cfg.clone_in_fabric,
             device=self.device,
             physics_clone_fn=physics_clone_fn,
-            clone_usd=not is_newton_replicated_scene or has_kit() or "ovrtx" in requested_renderer_types,
+            clone_usd=not is_newton_replicated_scene or self.sim.runtime_needs_kit() or has_ovrtx_renderer,
         )
 
         # create source prim
@@ -354,17 +353,6 @@ def _aggregate_scene_data_requirements(self, visualizer_types=()) -> None:
         if requirements != current_req:
             self.sim.update_scene_data_requirements(requirements)
 
-    def _cfg_renderer_types(self) -> list[str]:
-        """Return renderer type names declared by scene cfg entries before sensors are constructed."""
-        cfg_fields = InteractiveSceneCfg.__dataclass_fields__
-        renderer_types: list[str] = []
-        for asset_cfg in (v for k, v in self.cfg.__dict__.items() if k not in cfg_fields and v is not None):
-            cfgs = asset_cfg.rigid_objects.values() if isinstance(asset_cfg, RigidObjectCollectionCfg) else [asset_cfg]
-            for cfg in cfgs:
-                if (rcfg := getattr(cfg, "renderer_cfg", None)) is not None:
-                    renderer_types.append(getattr(rcfg, "renderer_type", "default"))
-        return renderer_types
-
     def _sensor_renderer_types(self) -> list[str]:
         """Return renderer type names used by scene sensors (skipping any without a renderer cfg)."""
         return [

source/isaaclab/isaaclab/sim/simulation_context.py

@@ -529,6 +529,22 @@ def resolve_visualizer_types(self) -> list[str]:
             visualizer_cfgs = [visualizer_cfgs]
         return [cfg.visualizer_type for cfg in visualizer_cfgs if getattr(cfg, "visualizer_type", None)]
 
+    def resolve_renderer_types(self) -> list[str]:
+        """Return renderer type names predetermined by the simulation launcher."""
+        requested = self.get_setting("/isaaclab/runtime/renderer_types")
+        if not isinstance(requested, str) or not requested.strip():
+            return []
+        return [value for chunk in requested.split(",") for value in chunk.split() if value]
+
+    def has_requested_renderer_type(self, renderer_type: str) -> bool:
+        """Return whether the launcher detected a requested renderer type."""
+        return renderer_type in self.resolve_renderer_types()
+
+    def runtime_needs_kit(self) -> bool:
+        """Return the launcher-predetermined Kit requirement, falling back to active Kit state."""
+        needs_kit = self.get_setting("/isaaclab/runtime/needs_kit")
+        return has_kit() if needs_kit is None else bool(needs_kit)
+
     def _resolve_visualizer_cfgs(self) -> list[Any]:
         """Resolve final visualizer configs from cfg and optional CLI override.
 

source/isaaclab_tasks/isaaclab_tasks/utils/sim_launcher.py

@@ -9,10 +9,11 @@
 
 import argparse
 import logging
-from collections.abc import Callable, Generator
+from collections.abc import Callable, Generator, Iterable, Mapping
 from contextlib import contextmanager
 from typing import Any
 
+from isaaclab.app.settings_manager import get_settings_manager
 from isaaclab.physics.physics_manager_cfg import PhysicsCfg
 from isaaclab.renderers.renderer_cfg import RendererCfg
 from isaaclab.sensors.camera.camera_cfg import CameraCfg
@@ -31,6 +32,17 @@ def add_launcher_args(parser: argparse.ArgumentParser) -> None:
     AppLauncher.add_app_launcher_args(parser)
 
 
+def _iter_config_children(node) -> Iterable[Any]:
+    if isinstance(node, Mapping):
+        return node.values()
+    if isinstance(node, (list, tuple)):
+        return node
+    try:
+        return vars(node).values()
+    except TypeError:
+        return ()
+
+
 def _scan_config(cfg, predicates: list[Callable[[Any], bool]]) -> list[bool]:
     """Recursively walk *cfg* and evaluate each predicate on every node.
 
@@ -53,11 +65,7 @@ def _visit(node):
             if not results[i] and pred(node):
                 results[i] = True
 
-        try:
-            children = vars(node)
-        except TypeError:
-            return
-        for child in children.values():
+        for child in _iter_config_children(node):
             if child is None or isinstance(child, (int, float, str, bool)):
                 continue
             _visit(child)
@@ -66,6 +74,64 @@ def _visit(node):
     return results
 
 
+def _collect_renderer_types(cfg) -> set[str]:
+    """Return renderer type names declared in the resolved runtime config."""
+    renderer_types: set[str] = set()
+    visited: set[int] = set()
+
+    def _visit(node):
+        node_id = id(node)
+        if node_id in visited:
+            return
+        visited.add(node_id)
+
+        if isinstance(node, RendererCfg):
+            renderer_types.add(getattr(node, "renderer_type", "default"))
+            return
+
+        for child in _iter_config_children(node):
+            if child is None or isinstance(child, (int, float, str, bool)):
+                continue
+            _visit(child)
+
+    _visit(cfg)
+    return renderer_types
+
+
+def _compute_runtime_intent(env_cfg, launcher_args: argparse.Namespace | dict | None = None) -> dict[str, Any]:
+    """Compute backend, renderer, and visualizer intent from the resolved env config."""
+    is_kitless, has_kit_cameras, has_kit_physics, has_ovrtx_renderer, has_ovphysx_physics = _scan_config(
+        env_cfg, [_is_kitless_physics, _is_kit_camera, _is_kit_physics, _is_ovrtx_renderer, _is_ovphysx_physics]
+    )
+    renderer_types = _collect_renderer_types(env_cfg)
+    visualizer_types = _get_visualizer_types(launcher_args)
+    visualizer_intent = _compute_visualizer_intent(env_cfg)
+    has_kit_visualizer = "kit" in visualizer_types or visualizer_intent.get("has_kit_visualizer", False)
+    needs_kit = has_kit_cameras or not is_kitless or "kit" in visualizer_types
+    return {
+        "needs_kit": needs_kit,
+        "has_kit_cameras": has_kit_cameras,
+        "has_kit_physics": has_kit_physics,
+        "has_kit_visualizer": has_kit_visualizer,
+        "has_ovrtx_renderer": has_ovrtx_renderer or "ovrtx" in renderer_types,
+        "has_ovphysx_physics": has_ovphysx_physics,
+        "renderer_types": renderer_types,
+        "visualizer_types": visualizer_types,
+        "visualizer_intent": visualizer_intent,
+    }
+
+
+def _sync_runtime_intent_settings(runtime_intent: dict[str, Any]) -> None:
+    """Persist launcher runtime intent for SimulationContext readers."""
+    settings = get_settings_manager()
+    renderer_types = sorted(str(v) for v in runtime_intent.get("renderer_types", set()) if str(v))
+    settings.set_bool("/isaaclab/runtime/needs_kit", bool(runtime_intent.get("needs_kit", False)))
+    settings.set_bool("/isaaclab/runtime/has_kit_cameras", bool(runtime_intent.get("has_kit_cameras", False)))
+    settings.set_bool("/isaaclab/runtime/has_kit_visualizer", bool(runtime_intent.get("has_kit_visualizer", False)))
+    settings.set_bool("/isaaclab/runtime/has_ovrtx_renderer", bool(runtime_intent.get("has_ovrtx_renderer", False)))
+    settings.set_string("/isaaclab/runtime/renderer_types", " ".join(renderer_types))
+
+
 def _is_kitless_physics(node) -> bool:
     """True when the node is a kitless physics config (Newton or OvPhysX)."""
     return isinstance(node, PhysicsCfg) and type(node).__name__ in ("NewtonCfg", "OvPhysxCfg")
@@ -165,12 +231,12 @@ def compute_kit_requirements(
     Returns:
         (needs_kit, has_kit_cameras, visualizer_types)
     """
-    is_kitless, has_kit_cameras = _scan_config(env_cfg, [_is_kitless_physics, _is_kit_camera])
-    needs_kit = has_kit_cameras or not is_kitless
-    visualizer_types = _get_visualizer_types(launcher_args)
-    if "kit" in visualizer_types:
-        needs_kit = True
-    return needs_kit, has_kit_cameras, visualizer_types
+    runtime_intent = _compute_runtime_intent(env_cfg, launcher_args)
+    return (
+        bool(runtime_intent["needs_kit"]),
+        bool(runtime_intent["has_kit_cameras"]),
+        set(runtime_intent["visualizer_types"]),
+    )
 
 
 def validate_runtime_compatibility(
@@ -194,12 +260,14 @@ def validate_runtime_compatibility(
         ValueError: If the OVRTX renderer is combined with Kit-based physics or the
             Kit visualizer, or if OvPhysX physics is combined with the Kit visualizer.
     """
-    has_kit_physics, has_ovrtx_renderer, has_ovphysx_physics = _scan_config(
-        env_cfg, [_is_kit_physics, _is_ovrtx_renderer, _is_ovphysx_physics]
-    )
-    visualizer_intent = _compute_visualizer_intent(env_cfg)
-    visualizer_types = _get_visualizer_types(launcher_args)
-    has_kit_visualizer = "kit" in visualizer_types or visualizer_intent.get("has_kit_visualizer", False)
+    _validate_runtime_compatibility_from_intent(_compute_runtime_intent(env_cfg, launcher_args))
+
+
+def _validate_runtime_compatibility_from_intent(runtime_intent: dict[str, Any]) -> None:
+    has_kit_physics = bool(runtime_intent["has_kit_physics"])
+    has_ovrtx_renderer = bool(runtime_intent["has_ovrtx_renderer"])
+    has_ovphysx_physics = bool(runtime_intent["has_ovphysx_physics"])
+    has_kit_visualizer = bool(runtime_intent["has_kit_visualizer"])
 
     if has_ovphysx_physics and has_kit_visualizer:
         raise ValueError(
@@ -319,23 +387,26 @@ def launch_simulation(
     # ovrtx and Kit ship the same RTX hydra libraries under conflicting USD namespaces;
     # loading both in the same process causes a dynamic-linker crash.  Use
     # --visualizer newton instead, which is compatible with ovrtx presets.
-    early_visualizer_types = _get_visualizer_types(launcher_args)
-    if "kit" in early_visualizer_types:
-        has_ovrtx = _scan_config(
-            env_cfg, [lambda node: isinstance(node, RendererCfg) and getattr(node, "renderer_type", None) == "ovrtx"]
-        )[0]
-        if has_ovrtx:
-            raise ValueError(
-                "[launch_simulation] '--visualizer kit' is incompatible with 'ovrtx_renderer'. "
-                "Both Kit (Isaac Sim) and ovrtx ship conflicting RTX hydra libraries "
-                "(librtx.hydra.so, liblegacy.hydra.so) compiled against different USD namespaces, "
-                "which causes a dynamic-linker crash when loaded into the same process. "
-                "Use '--visualizer newton' instead, which is fully compatible with ovrtx presets."
-            )
+    runtime_intent = _compute_runtime_intent(env_cfg, launcher_args)
+    early_visualizer_types = set(runtime_intent["visualizer_types"])
+    if "kit" in early_visualizer_types and runtime_intent["has_ovrtx_renderer"]:
+        raise ValueError(
+            "[launch_simulation] '--visualizer kit' is incompatible with 'ovrtx_renderer'. "
+            "Both Kit (Isaac Sim) and ovrtx ship conflicting RTX hydra libraries "
+            "(librtx.hydra.so, liblegacy.hydra.so) compiled against different USD namespaces, "
+            "which causes a dynamic-linker crash when loaded into the same process. "
+            "Use '--visualizer newton' instead, which is fully compatible with ovrtx presets."
+        )
 
-    validate_runtime_compatibility(env_cfg, launcher_args)
+    _validate_runtime_compatibility_from_intent(runtime_intent)
     needs_kit, has_kit_cameras, visualizer_types = compute_kit_requirements(env_cfg, launcher_args)
-    visualizer_intent = _compute_visualizer_intent(env_cfg)
+    visualizer_intent = runtime_intent["visualizer_intent"]
+    runtime_intent["needs_kit"] = needs_kit
+    runtime_intent["has_kit_cameras"] = has_kit_cameras
+    runtime_intent["has_kit_visualizer"] = "kit" in visualizer_types or visualizer_intent.get(
+        "has_kit_visualizer", False
+    )
+    runtime_intent["visualizer_types"] = visualizer_types
     _set_visualizer_intent_on_launcher_args(launcher_args, visualizer_intent)
 
     if needs_kit and has_kit_cameras:
@@ -421,7 +492,11 @@ def launch_simulation(
             if sim_cfg is not None and hasattr(app_launcher, "device"):
                 sim_cfg.device = app_launcher.device
             close_fn = app_launcher.app.close
-    elif visualizer_types or visualizer_explicit_none:
+        _sync_runtime_intent_settings(runtime_intent)
+    else:
+        _sync_runtime_intent_settings(runtime_intent)
+
+    if not needs_kit and (visualizer_types or visualizer_explicit_none):
         # Newton path without Kit: AppLauncher is skipped, so manually store the visualizer
         # selection in SettingsManager (works in standalone mode via plain dict) so that
         # SimulationContext._get_cli_visualizer_types() can find it.