Strip env_1..N from the USD handed to physx.add_usd

InteractiveScene now USD-replicates every env's asset subtree for all
backends (clone_usd=True from the previous commit), but OvPhysxManager
was still handing the full N-env stage to physx.add_usd. The wheel
loaded all N USD-defined bodies as independent prims, so the subsequent
physx.clone() ran onto already-populated targets and never produced the
clone-lineage that the wheel's create_tensor_binding fast path expects.
At 4096 envs this turned every binding-creation call into a multi-second
USD enumeration -- the hang in articulation init.

Re-shape _warmup_and_load to export an env_0-scoped USD file:

1. Export the full stage to disk (existing flatten-and-write).
2. Re-open the exported file as an Sdf.Layer.
3. Delete every /World/envs/env_<i>  prim spec for i != 0 from the layer.
4. Re-export.

The live USD stage held by SimulationContext is untouched -- sensors
(RayCaster, Camera, ContactSensor discovery) still see N envs and
discover _num_envs = N correctly. Only the file passed to the wheel is
scoped to env_0 + globals. physx.clone() then repopulates env_1..N at
the physics layer with proper lineage, and create_tensor_binding walks a
1-USD-path result that auto-extends across the N clones -- the fast
path that clone_usd=False used to give us implicitly.

Net effect: keeps the previous commit's clone_usd=True flip (sensor
parity across backends) while restoring OVPhysX's per-env scaling. No
test changes required; the FrameView/ContactSensor suite stays at
27/27 pass on CPU.

Author: AntoineRichard

source/isaaclab_ovphysx/isaaclab_ovphysx/physics/ovphysx_manager.py

@@ -374,6 +374,64 @@ def get_scene_data_backend(cls) -> SceneDataBackend:
     # Internal helpers
     # ------------------------------------------------------------------
 
+    @staticmethod
+    def _export_env0_only_stage(sim_stage: Any, target_file: str) -> None:
+        """Export the simulation stage to ``target_file`` with env_1..N stripped.
+
+        Writes a USD file containing every prim under the live stage **except**
+        ``/World/envs/env_<i>`` for ``i != 0``. Globals (``/physicsScene``,
+        ``/World/ground``, lights, materials, etc.) and ``/World/envs/env_0`` are
+        retained.  ``physx.clone()`` is then expected to repopulate env_1..N at
+        the physics layer with proper clone lineage so that subsequent
+        ``create_tensor_binding`` calls hit the wheel's fast path.
+
+        Implementation: export the full stage to disk, then re-open the result
+        as an :class:`Sdf.Layer` and delete env_1..N prim specs in place.  This
+        avoids mutating the live stage (which other consumers -- sensors,
+        visualizers -- still see in its full N-env form).
+
+        Args:
+            sim_stage: Live USD stage held by ``SimulationContext``.
+            target_file: Output ``.usda`` file path.  Overwritten if it exists.
+        """
+        from pxr import Sdf  # noqa: PLC0415
+
+        # Step 1: full flatten-export of the live stage.  We pass the full file
+        # to ``Sdf.Layer.OpenAsAnonymous`` so the edits below don't write back
+        # to the source layer on disk.
+        sim_stage.Export(target_file)
+
+        # Step 2: open the exported file as an editable Sdf layer and delete
+        # ``/World/envs/env_<digits>`` children for digits != 0.  Walking the
+        # ``/World/envs`` ``PrimSpec``'s ``nameChildren`` keeps us scoped to
+        # the env-namespace and leaves the rest of the stage untouched.
+        layer = Sdf.Layer.FindOrOpen(target_file)
+        if layer is None:
+            raise RuntimeError(
+                f"OvPhysxManager: failed to re-open exported USD layer at {target_file!r} for env-scoping."
+            )
+        envs_spec = layer.GetPrimAtPath("/World/envs")
+        if envs_spec is None or not envs_spec:
+            # No /World/envs in the stage (single-env or non-IsaacLab scene); nothing to scope.
+            logger.debug("OvPhysxManager: no /World/envs prim — exported stage as-is.")
+            return
+
+        env_name_re = re.compile(r"^env_(\d+)$")
+        names_to_remove = [
+            child_name
+            for child_name in list(envs_spec.nameChildren.keys())
+            if (match := env_name_re.match(child_name)) and match.group(1) != "0"
+        ]
+        for child_name in names_to_remove:
+            del envs_spec.nameChildren[child_name]
+
+        if names_to_remove:
+            layer.Export(target_file)
+            logger.info(
+                "OvPhysxManager: stripped %d env_<i!=0> subtrees from exported USD (kept env_0 + globals)",
+                len(names_to_remove),
+            )
+
     @classmethod
     def _warmup_and_load(cls) -> None:
         """Export the USD stage and load it into the ovphysx runtime.
@@ -417,11 +475,27 @@ def _warmup_and_load(cls) -> None:
             cls._configure_physx_scene_prim(scene_prim, PhysicsManager._cfg, ovphysx_device)
 
         # Export the current USD stage to a temporary file so ovphysx can load it.
+        #
+        # When ``InteractiveScene`` runs with ``clone_usd=True``, the live USD
+        # stage carries env_0..N's full asset subtrees as authored copies.
+        # Handing that stage to ``physx.add_usd`` would make the wheel ingest
+        # all 4096 envs as independent USD-defined bodies, defeating the
+        # ``physx.clone()`` fast path and turning every subsequent
+        # ``create_tensor_binding`` call into an O(N) USD enumeration -- the
+        # hang you'd see at large env counts.
+        #
+        # The workaround: strip ``/World/envs/env_<i>`` for i != 0 from the
+        # exported file before handing it to the wheel.  Sensors that read
+        # USD directly (RayCaster, Camera, ContactSensor discovery) still see
+        # the full N-env stage; only the wheel-side physics ingestion is
+        # scoped to env_0, and ``physx.clone()`` re-populates env_1..N in
+        # the physics runtime with proper clone lineage (which is what the
+        # binding fast path expects).
         cls._tmp_dir = tempfile.TemporaryDirectory(prefix="isaaclab_ovphysx_")
         stage_file = os.path.join(cls._tmp_dir.name, "scene.usda")
-        sim.stage.Export(stage_file)
+        cls._export_env0_only_stage(sim.stage, stage_file)
         cls._stage_path = stage_file
-        logger.info("OvPhysxManager: exported USD stage to %s", stage_file)
+        logger.info("OvPhysxManager: exported env_0-scoped USD stage to %s", stage_file)
 
         if cls._physx is None:
             cls._construct_physx(ovphysx_device, gpu_index)