Patch caller sensor _num_envs from OvPhysxFrameView

Under OVPhysX's clone_usd=False scenes (the default for InteractiveScene),
USD only holds env_0 -- env_1..N are physics-layer clones via physx.clone().
SensorBase.__init__ derives _num_envs from len(find_matching_prims(...)) so
any FrameView-using sensor (RayCaster, MultiMeshRayCaster, Camera) sees
_num_envs=1 even when the scene has many envs. The sensor's
_reset_mask_torch is then sized 1, and the first reset(env_ids=[0..N-1])
triggers a CUDA assert from out-of-bounds indexing.

Walk the call stack at construction time to capture the sensor that owns
this view, then at the end of _initialize_impl re-allocate its env-sized
buffers (_ALL_ENV_MASK, _reset_mask + torch view, _is_outdated, _timestamp,
_timestamp_last_update) to match the OVPhysX RIGID_BODY_POSE binding's
row count. Duck-typed -- works for any SensorBase subclass without an
isaaclab.sensors import dependency. Mirrors the local fix the OVPhysX
ContactSensor already applies to itself at contact_sensor.py:240-248.

This is a hack confined to the OVPhysX backend. A cleaner long-term fix
would source _num_envs from InteractiveScene.num_envs (or move the
under-cloning behaviour to be opt-in for rendering rather than backend-
keyed), but both are larger changes that touch core IsaacLab.

Verified: Anymal-D rough velocity env with presets=ovphysx + 64 envs
now initializes past env.reset() without the CUDA assert.

Author: AntoineRichard

source/isaaclab_ovphysx/isaaclab_ovphysx/sim/views/ovphysx_frame_view.py

@@ -9,6 +9,7 @@
 
 import logging
 import re
+import sys
 from typing import Any
 
 import warp as wp
@@ -23,6 +24,19 @@
 
 from isaaclab_ovphysx.physics import OvPhysxManager
 
+# Attributes that ``SensorBase.__init__`` sizes from ``len(_parent_prims)`` and
+# that must be re-allocated when an :class:`OvPhysxFrameView` discovers a larger
+# binding count under ``clone_usd=False``. Used by :meth:`_patch_caller_sensor`.
+_SENSOR_BASE_ENV_SIZED_ATTRS = (
+    "_num_envs",
+    "_ALL_ENV_MASK",
+    "_reset_mask",
+    "_reset_mask_torch",
+    "_is_outdated",
+    "_timestamp",
+    "_timestamp_last_update",
+)
+
 logger = logging.getLogger(__name__)
 
 WORLD_BODY_INDEX = -1
@@ -318,6 +332,12 @@ def __init__(self, prim_path: str, device: str = "cpu", stage: Usd.Stage | None
         # Lazy USD view for scales / visibility.
         self._usd_view: UsdFrameView | None = None
 
+        # HACK: Capture the caller sensor (if any) so we can patch its env-sized
+        # buffers once the binding count is known. Required because
+        # ``SensorBase.__init__`` sizes ``_num_envs`` from ``find_matching_prims``
+        # which returns only env_0 under OVPhysX's ``clone_usd=False`` scenes.
+        self._caller_sensor = self._find_caller_sensor()
+
         # Try synchronous init; defer to PHYSICS_READY if the PhysX instance is not yet alive.
         physx = self._try_get_physx()
         if physx is not None:
@@ -334,6 +354,55 @@ def _try_get_physx() -> Any | None:
         """Return the active OVPhysX ``PhysX`` instance, or ``None`` if not yet created."""
         return OvPhysxManager.get_physx_instance()
 
+    @staticmethod
+    def _find_caller_sensor() -> Any | None:
+        """Walk the call stack to find a ``SensorBase``-like instance that owns this view.
+
+        Duck-typed: any object on the stack that exposes the full set of
+        env-sized attributes that ``SensorBase.__init__`` allocates is treated
+        as a sensor. Returns ``None`` when the view is constructed outside a
+        sensor (e.g. directly by user code or via scene ``extras``).
+        """
+        frame = sys._getframe(1)
+        while frame is not None:
+            candidate = frame.f_locals.get("self")
+            if candidate is not None and all(hasattr(candidate, attr) for attr in _SENSOR_BASE_ENV_SIZED_ATTRS):
+                return candidate
+            frame = frame.f_back
+        return None
+
+    def _patch_caller_sensor_env_count(self) -> None:
+        """Re-allocate the caller sensor's env-sized buffers to match the binding count.
+
+        HACK: Works around ``SensorBase.__init__`` deriving ``_num_envs`` from
+        ``len(_parent_prims)`` -- under OVPhysX's ``clone_usd=False`` scenes only
+        env_0 exists in USD, so the sensor sees ``_num_envs = 1`` while the
+        underlying RIGID_BODY_POSE binding correctly exposes all envs. Without
+        this patch, any sensor that calls ``reset(env_ids=[0..N-1])`` indexes
+        past its 1-element ``_reset_mask_torch`` and triggers a CUDA assert.
+
+        Mirrors the local fix the OVPhysX ``ContactSensor`` applies to itself at
+        ``contact_sensor.py:240-248``.
+        """
+        sensor = self._caller_sensor
+        if sensor is None or sensor._num_envs == self.count:
+            return
+        new_count = self.count
+        device = sensor._device
+        sensor._num_envs = new_count
+        sensor._ALL_ENV_MASK = wp.ones((new_count,), dtype=wp.bool, device=device)
+        sensor._reset_mask = wp.zeros((new_count,), dtype=wp.bool, device=device)
+        sensor._reset_mask_torch = wp.to_torch(sensor._reset_mask)
+        sensor._is_outdated = wp.ones(new_count, dtype=wp.bool, device=device)
+        sensor._timestamp = wp.zeros(new_count, dtype=wp.float32, device=device)
+        sensor._timestamp_last_update = wp.zeros_like(sensor._timestamp)
+        logger.info(
+            "OvPhysxFrameView: resized %s._num_envs from prior value to %d to match "
+            "OVPhysX binding count (clone_usd=False scene).",
+            type(sensor).__name__,
+            new_count,
+        )
+
     def _on_physics_ready(self, _event) -> None:
         """Callback invoked when the OVPhysX ``PhysX`` instance becomes available."""
         physx = self._try_get_physx()
@@ -473,6 +542,11 @@ def _initialize_impl(self, physx: Any) -> None:
         self._local_pos_ta = ProxyArray(self._local_pos_buf)
         self._local_quat_ta = ProxyArray(self._local_quat_buf)
 
+        # 8. HACK: patch the caller sensor's env-sized buffers if it derived
+        #    its env count from the (under-counting) USD prim list. See
+        #    :meth:`_patch_caller_sensor_env_count` for context.
+        self._patch_caller_sensor_env_count()
+
     def _resolve_rigid_body_ancestor(
         self,
         prim: Usd.Prim,