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,15 @@ 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 has_requested_renderer_type(self, renderer_type: str) -> bool:
+        """Return whether the launcher detected a requested renderer type."""
+        return bool(self.get_setting(f"/isaaclab/runtime/has_{renderer_type}_renderer"))
+
+    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

@@ -13,6 +13,7 @@
 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
@@ -320,22 +321,20 @@ def launch_simulation(
     # 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."
-            )
+    has_ovrtx_renderer = _scan_config(env_cfg, [_is_ovrtx_renderer])[0]
+    if "kit" in early_visualizer_types and 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)
     needs_kit, has_kit_cameras, visualizer_types = compute_kit_requirements(env_cfg, launcher_args)
     visualizer_intent = _compute_visualizer_intent(env_cfg)
+    has_kit_visualizer = "kit" in visualizer_types or visualizer_intent.get("has_kit_visualizer", False)
     _set_visualizer_intent_on_launcher_args(launcher_args, visualizer_intent)
 
     if needs_kit and has_kit_cameras:
@@ -421,7 +420,14 @@ 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:
+
+    settings = get_settings_manager()
+    settings.set_bool("/isaaclab/runtime/needs_kit", bool(needs_kit))
+    settings.set_bool("/isaaclab/runtime/has_kit_cameras", bool(has_kit_cameras))
+    settings.set_bool("/isaaclab/runtime/has_kit_visualizer", bool(has_kit_visualizer))
+    settings.set_bool("/isaaclab/runtime/has_ovrtx_renderer", bool(has_ovrtx_renderer))
+
+    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.