Support OVPhysX in randomize_rigid_body_collider_offsets MDP event (#7569)

# Description

> **Stacked on #7563.** This branch needs the `REST_OFFSET` /
`CONTACT_OFFSET` / `RIGID_BODY_*_OFFSET` aliases and the CPU-only
routing for those tensor types that #7563 adds. Review/merge that first;
this diff collapses to a single commit once it lands, at which point the
base should be retargeted to `develop`.

`randomize_rigid_body_collider_offsets` had no OVPhysX implementation.
Its backend dispatch tested only for `"newton"` and fell through a bare
`else` to `_RandomizeRigidBodyColliderOffsetsPhysx`, which calls
`get_rest_offsets` / `get_contact_offsets` / `set_rest_offsets` /
`set_contact_offsets` on `asset.root_view`. On OVPhysX that view is an
`OvPhysxView`, which defines none of them, so adding the term to a
config raised `AttributeError` during `OvPhysxManager.reset()` (via
`PHYSICS_READY`) and the environment never built. The error surfaced
from inside the PhysX implementation, so it did not name the unsupported
backend either.

Found by the OVQA agent harness on Isaac-Cartpole (release/3.0.0,
ovphysx 0.5.11). No shipped task uses the term today, so this is latent
rather than a live regression.

**Fix**

- New `_RandomizeRigidBodyColliderOffsetsOvPhysx`, mirroring the PhysX
variant. OVPhysX runs the PhysX solver, so rest/contact offsets are
written directly, per collision shape, through the asset's
`OvPhysxView`: `REST_OFFSET` / `CONTACT_OFFSET` for articulations,
`RIGID_BODY_REST_OFFSET` / `RIGID_BODY_CONTACT_OFFSET` for rigid
objects. Both bindings are CPU-resident `[N, S]` buffers, so the full
tensor is read-modify-written on the host with the selected envs as
write indices.
- Dispatch now matches `randomize_rigid_body_material` in the same file:
`ovphysxmanager` first (it contains the substring `physx`), then Newton,
then PhysX, and a `ValueError` naming the manager for anything else
instead of silently selecting PhysX.
- Docstring lists OVPhysX as a supported backend.

**Note on write order**

PhysX enforces `restOffset < contactOffset` and on OVPhysX a violating
`setRestOffset` is only logged, not raised. The term writes rest before
contact, same as the PhysX variant, so raising both above a small
authored contact offset can silently skip the rest write. Kept for PhysX
parity; flagging in case we want to reorder in both backends.

**Verification**

New
`source/isaaclab_ov/test/test_randomize_rigid_body_collider_offsets_mdp.py`
drives the public term (stubbed `cfg` / `env` / `asset_cfg`) against a
real OVPhysX `RigidObject` and `Articulation`, so the dispatch itself is
covered. It reproduced the reported `AttributeError` before the fix.
Assertions: selected envs land in the sampled range, unselected envs are
untouched, and omitting one distribution leaves that offset alone.
Passes on `cuda:0` and `cpu` (separate processes, ovphysx device lock).
PhysX and Newton paths are unchanged.

Dependencies: #7563.

Fixes # (no tracking issue; reported by the OVQA agent harness)

## Type of change

- Bug fix (non-breaking change which fixes an issue)

## Release backport

- [x] <!-- backport-active-release --> Backport this pull request to the
active release branch after it merges into `develop`

## Screenshots

Not applicable: no visual change.

## Checklist

Docker and GPU tests run on demand. Push the commits you want tested,
then
comment `run-ci` on the pull request.

- [x] I have read and understood the [contribution
guidelines](https://isaac-sim.github.io/IsaacLab/main/source/refs/contributing.html)
- [x] I have run the [`pre-commit` checks](https://pre-commit.com/) with
`./isaaclab.sh --format`
- [x] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] I have added a changelog fragment under
`source/<pkg>/changelog.d/` for every touched package (do **not** edit
`CHANGELOG.rst` or bump `extension.toml` — CI handles that)
- [x] I have added my name to the `CONTRIBUTORS.md` or my name already
exists there

---------

Co-authored-by: Kelly Guo <kellyg@nvidia.com>

(cherry picked from commit 1b182e7)

Author: AntoineRichard

source/isaaclab/changelog.d/antoiner-fix-ovphysx-collider-offsets.minor.rst

@@ -0,0 +1,9 @@
+Added
+^^^^^
+
+* Added OVPhysX backend support to :class:`~isaaclab.envs.mdp.events.randomize_rigid_body_collider_offsets`.
+  The term previously fell through to the PhysX implementation on OVPhysX and raised ``AttributeError``
+  during environment construction, because :class:`~isaaclab_ov.sim.views.OvPhysxView` has none of the
+  PhysX ``root_view`` offset accessors. Rest and contact offsets are now written per collision shape through
+  the asset's view. An unrecognised physics manager now raises ``ValueError`` naming the backend instead of
+  silently selecting the PhysX implementation.

source/isaaclab/isaaclab/envs/mdp/events.py

@@ -1045,6 +1045,78 @@ def __call__(
             self.asset.root_view.set_contact_offsets(wp.from_torch(contact_offset), wp_env_ids)
 
 
+class _RandomizeRigidBodyColliderOffsetsOvPhysx:
+    """OVPhysX backend implementation for collider offset randomization.
+
+    OVPhysX runs the PhysX solver, so rest and contact offsets are written directly, per collision
+    shape, through the asset's :class:`~isaaclab_ov.sim.views.OvPhysxView`. Articulations use the
+    articulation offset bindings and rigid objects the rigid-body ones; both are CPU-resident
+    ``[N, S]`` buffers, so the full tensor is read-modify-written on the host with the selected
+    environments as write indices.
+    """
+
+    def __init__(self, asset: RigidObject | Articulation):
+        import isaaclab_ov.tensor_types as ovphysx_tt  # noqa: PLC0415
+
+        from isaaclab.assets import BaseArticulation  # noqa: PLC0415
+
+        self.asset = asset
+        if isinstance(asset, BaseArticulation):
+            self._rest_offset_type = ovphysx_tt.REST_OFFSET
+            self._contact_offset_type = ovphysx_tt.CONTACT_OFFSET
+        else:
+            self._rest_offset_type = ovphysx_tt.RIGID_BODY_REST_OFFSET
+            self._contact_offset_type = ovphysx_tt.RIGID_BODY_CONTACT_OFFSET
+        self.default_rest_offsets = wp.to_torch(asset.root_view.get_attribute(self._rest_offset_type)).clone()
+        self.default_contact_offsets = wp.to_torch(asset.root_view.get_attribute(self._contact_offset_type)).clone()
+
+    def __call__(
+        self,
+        env: ManagerBasedEnv,
+        env_ids: torch.Tensor | None,
+        asset_cfg: SceneEntityCfg,
+        rest_offset_distribution_params: tuple[float, float] | None = None,
+        contact_offset_distribution_params: tuple[float, float] | None = None,
+        distribution: Literal["uniform", "log_uniform", "gaussian"] = "uniform",
+    ):
+        if env_ids is None:
+            env_ids = torch.arange(env.scene.num_envs, device="cpu", dtype=torch.int32)
+        else:
+            env_ids = env_ids.to(device="cpu", dtype=torch.int32)
+        wp_env_ids = wp.from_torch(env_ids, dtype=wp.int32)
+
+        if rest_offset_distribution_params is not None:
+            rest_offset = self.default_rest_offsets.clone()
+            rest_offset = _randomize_prop_by_op(
+                rest_offset,
+                rest_offset_distribution_params,
+                None,
+                slice(None),
+                operation="abs",
+                distribution=distribution,
+            )
+            # the wheel requires a full-shaped source buffer even for indexed writes
+            self.asset.root_view.set_attribute(
+                self._rest_offset_type, wp.from_torch(rest_offset.contiguous(), dtype=wp.float32), indices=wp_env_ids
+            )
+
+        if contact_offset_distribution_params is not None:
+            contact_offset = self.default_contact_offsets.clone()
+            contact_offset = _randomize_prop_by_op(
+                contact_offset,
+                contact_offset_distribution_params,
+                None,
+                slice(None),
+                operation="abs",
+                distribution=distribution,
+            )
+            self.asset.root_view.set_attribute(
+                self._contact_offset_type,
+                wp.from_torch(contact_offset.contiguous(), dtype=wp.float32),
+                indices=wp_env_ids,
+            )
+
+
 class _RandomizeRigidBodyColliderOffsetsNewton:
     """Newton backend implementation for collider offset randomization.
 
@@ -1129,11 +1201,13 @@ class randomize_rigid_body_collider_offsets(ManagerTermBase):
     This function allows randomizing the collider parameters of the asset, such as rest and contact offsets.
     These correspond to the physics engine collider properties that affect collision checking.
 
-    Automatically detects the active physics backend (PhysX or Newton) and delegates to
+    Automatically detects the active physics backend (PhysX, OVPhysX or Newton) and delegates to
     the appropriate backend-specific implementation:
 
     - **PhysX**: Uses rest offset and contact offset directly via the PhysX tensor API
       (``root_view.set_rest_offsets`` / ``root_view.set_contact_offsets``).
+    - **OVPhysX**: Uses rest offset and contact offset directly, written per collision shape
+      through the asset's :class:`~isaaclab_ov.sim.views.OvPhysxView`.
     - **Newton**: Maps PhysX concepts to Newton's geometry properties. PhysX ``rest_offset``
       maps to Newton ``shape_margin``, and PhysX ``contact_offset`` is converted to Newton
       ``shape_gap`` via ``gap = contact_offset - margin``.
@@ -1143,7 +1217,7 @@ class randomize_rigid_body_collider_offsets(ManagerTermBase):
     provided for a particular property, the function does not modify it.
 
     .. tip::
-        This function uses CPU tensors (PhysX) or GPU tensors (Newton) to assign the collision
+        This function uses CPU tensors (PhysX, OVPhysX) or GPU tensors (Newton) to assign the collision
         properties. It is recommended to use this function only during the initialization of
         the environment.
     """
@@ -1171,12 +1245,19 @@ def __init__(self, cfg: EventTermCfg, env: ManagerBasedEnv):
                 f" '{self.asset_cfg.name}' with type: '{type(self.asset)}'."
             )
 
-        # detect physics backend and instantiate the appropriate implementation
+        # detect physics backend and instantiate the appropriate implementation.
+        # Check ``ovphysxmanager`` first: it contains the substring ``physx`` so would otherwise
+        # be routed to the PhysX impl, whose ``root_view`` offset accessors do not exist on
+        # OVPhysX's ``OvPhysxView`` (see ``randomize_rigid_body_material``).
         manager_name = env.sim.physics_manager.__name__.lower()
-        if "newton" in manager_name:
+        if manager_name == "ovphysxmanager":
+            self._impl = _RandomizeRigidBodyColliderOffsetsOvPhysx(self.asset)
+        elif "newton" in manager_name:
             self._impl = _RandomizeRigidBodyColliderOffsetsNewton(self.asset)
-        else:
+        elif "physx" in manager_name:
             self._impl = _RandomizeRigidBodyColliderOffsetsPhysx(self.asset)
+        else:
+            raise ValueError(f"Unsupported physics manager for randomize_rigid_body_collider_offsets: {manager_name!r}")
 
     def __call__(
         self,

source/isaaclab_ov/changelog.d/antoiner-fix-ovphysx-collider-offsets.skip

@@ -0,0 +1 @@
+Test-only coverage for the OVPhysX package.

source/isaaclab_ov/test/test_randomize_rigid_body_collider_offsets_mdp.py

@@ -0,0 +1,185 @@
+# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
+# All rights reserved.
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+"""Real-backend test for the OVPhysX branch of the ``randomize_rigid_body_collider_offsets`` MDP term.
+
+Drives the public :class:`isaaclab.envs.mdp.events.randomize_rigid_body_collider_offsets` term against
+a real OVPhysX :class:`~isaaclab_ov.assets.RigidObject` and :class:`~isaaclab_ov.assets.Articulation`, so
+the backend dispatch itself is exercised (it previously fell through to the PhysX implementation, whose
+``root_view`` accessors do not exist on :class:`~isaaclab_ov.sim.views.OvPhysxView`). The ``cfg`` /
+``env`` / ``asset_cfg`` inputs are stubbed: the term only reads ``cfg.params["asset_cfg"]``,
+``env.scene[...]``, ``env.scene.num_envs`` and ``env.sim.physics_manager``.
+
+Kitless; run once per device (``-k cpu`` / ``-k 'cuda:0'``) -- the ovphysx runtime binds the
+device mode process-globally (see the asset tests' module docstring).
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+import torch
+import warp as wp
+
+pytest.importorskip("ovphysx.types", reason="ovphysx wheel not installed")
+
+from isaaclab_ov import tensor_types as TT  # noqa: E402
+from isaaclab_ov.assets import Articulation, RigidObject  # noqa: E402
+from isaaclab_ov.physics import OvPhysxCfg  # noqa: E402
+
+import isaaclab.sim as sim_utils  # noqa: E402
+from isaaclab.assets import RigidObjectCfg  # noqa: E402
+from isaaclab.envs.mdp.events import randomize_rigid_body_collider_offsets  # noqa: E402
+from isaaclab.sim import SimulationCfg, build_simulation_context  # noqa: E402
+from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR  # noqa: E402
+
+from isaaclab_assets import CARTPOLE_CFG  # isort:skip  # noqa: E402
+
+wp.init()
+
+pytestmark = pytest.mark.device_split
+
+_LOCKED_DEVICE: list[str | None] = [None]
+
+REST_RANGE = (0.0002, 0.0006)  # below the 1 mm default contact offset: PhysX rejects rest >= contact
+CONTACT_RANGE = (0.03, 0.05)
+EPS = 1e-6
+
+
+@pytest.fixture(autouse=True)
+def _ovphysx_skip_other_device(request):
+    """Skip parametrized tests on the device the session is not pinned to (process-global lock)."""
+    callspec = getattr(request.node, "callspec", None)
+    device = callspec.params.get("device") if callspec is not None else None
+    if device is None:
+        return
+    locked = _LOCKED_DEVICE[0]
+    if locked is None:
+        _LOCKED_DEVICE[0] = device
+        return
+    if device != locked:
+        pytest.skip(
+            f"ovphysx process-global device lock is held by '{locked}'; cannot run '{device}' "
+            "tests in the same session.  Run pytest twice (once per device) for full coverage."
+        )
+
+
+def _ovphysx_sim_context(device: str, **kwargs):
+    """Build a simulation context that dispatches to the OVPhysX manager."""
+    sim_cfg = SimulationCfg(physics=OvPhysxCfg(), device=device, dt=1.0 / 60.0, gravity=(0.0, 0.0, -9.81))
+    return build_simulation_context(device=device, sim_cfg=sim_cfg, **kwargs)
+
+
+class _SceneStub(dict):
+    """Minimal ``InteractiveScene`` stand-in: name lookup plus ``num_envs``."""
+
+    def __init__(self, num_envs: int, **assets):
+        super().__init__(**assets)
+        self.num_envs = num_envs
+
+
+def _make_env(sim, num_envs: int, **assets) -> SimpleNamespace:
+    return _make_env_from_scene(sim, _SceneStub(num_envs, **assets))
+
+
+def _make_env_from_scene(sim, scene: _SceneStub) -> SimpleNamespace:
+    return SimpleNamespace(sim=sim, scene=scene, num_envs=scene.num_envs, device=sim.device)
+
+
+def _make_cubes(num_cubes: int) -> RigidObject:
+    """Spawn ``num_cubes`` rigid-body cubes as a single RigidObject."""
+    for i in range(num_cubes):
+        sim_utils.create_prim(f"/World/Env_{i}", "Xform", translation=(i * 1.0, 0.0, 1.0))
+    cfg = RigidObjectCfg(
+        prim_path="/World/Env_[^/]+/Object",
+        spawn=sim_utils.UsdFileCfg(usd_path=f"{ISAAC_NUCLEUS_DIR}/Props/Blocks/DexCube/dex_cube_instanceable.usd"),
+        init_state=RigidObjectCfg.InitialStateCfg(pos=(0.0, 0.0, 1.0)),
+    )
+    return RigidObject(cfg=cfg)
+
+
+def _make_cartpoles(num_envs: int) -> Articulation:
+    """Spawn ``num_envs`` cartpoles as a single Articulation."""
+    for i in range(num_envs):
+        sim_utils.create_prim(f"/World/Env_{i}", "Xform", translation=(i * 2.5, 0.0, 0.0))
+    return Articulation(cfg=CARTPOLE_CFG.replace(prim_path="/World/Env_[^/]+/Robot"))
+
+
+def _read_offsets(asset, rest_type, contact_type) -> tuple[torch.Tensor, torch.Tensor]:
+    rest = wp.to_torch(asset.root_view.get_attribute(rest_type)).clone()
+    contact = wp.to_torch(asset.root_view.get_attribute(contact_type)).clone()
+    return rest, contact
+
+
+def _assert_randomized_rows(before: torch.Tensor, after: torch.Tensor, rows: list[int], value_range) -> None:
+    """Selected rows land within ``value_range``; all other rows are untouched."""
+    lo, hi = value_range
+    selected = after[rows]
+    assert (selected >= lo - EPS).all() and (selected <= hi + EPS).all(), selected
+    untouched = [i for i in range(before.shape[0]) if i not in rows]
+    torch.testing.assert_close(after[untouched], before[untouched])
+
+
+@pytest.mark.parametrize("device", ["cuda:0", "cpu"])
+def test_rigid_object_offsets_randomized_for_selected_envs(device):
+    """The term must dispatch to an OVPhysX implementation and write rigid-body rest/contact offsets."""
+    num_cubes = 3
+    with _ovphysx_sim_context(device=device, auto_add_lighting=True) as sim:
+        cube_object = _make_cubes(num_cubes)
+        sim.reset()
+
+        asset_cfg = SimpleNamespace(name="cube", body_ids=slice(None))
+        env = _make_env(sim, num_cubes, cube=cube_object)
+        term = randomize_rigid_body_collider_offsets(SimpleNamespace(params={"asset_cfg": asset_cfg}), env)
+
+        rest_before, contact_before = _read_offsets(
+            cube_object, TT.RIGID_BODY_REST_OFFSET, TT.RIGID_BODY_CONTACT_OFFSET
+        )
+        assert rest_before.shape[0] == num_cubes
+        # sanity: the sampling ranges must be disjoint from the authored defaults or the test proves nothing
+        assert not ((rest_before >= REST_RANGE[0]) & (rest_before <= REST_RANGE[1])).any()
+        assert not ((contact_before >= CONTACT_RANGE[0]) & (contact_before <= CONTACT_RANGE[1])).any()
+
+        env_ids = torch.tensor([0, 2], device=device)
+        term(
+            env,
+            env_ids,
+            asset_cfg,
+            rest_offset_distribution_params=REST_RANGE,
+            contact_offset_distribution_params=CONTACT_RANGE,
+        )
+
+        rest_after, contact_after = _read_offsets(cube_object, TT.RIGID_BODY_REST_OFFSET, TT.RIGID_BODY_CONTACT_OFFSET)
+        _assert_randomized_rows(rest_before, rest_after, [0, 2], REST_RANGE)
+        _assert_randomized_rows(contact_before, contact_after, [0, 2], CONTACT_RANGE)
+
+
+@pytest.mark.parametrize("device", ["cuda:0", "cpu"])
+def test_articulation_offsets_randomized_for_all_envs(device):
+    """The articulation path writes per-shape rest/contact offsets on every env when ``env_ids`` is None."""
+    num_envs = 2
+    with _ovphysx_sim_context(device=device, auto_add_lighting=True) as sim:
+        articulation = _make_cartpoles(num_envs)
+        sim.reset()
+
+        asset_cfg = SimpleNamespace(name="robot", body_ids=slice(None))
+        env = _make_env(sim, num_envs, robot=articulation)
+        term = randomize_rigid_body_collider_offsets(SimpleNamespace(params={"asset_cfg": asset_cfg}), env)
+
+        rest_before, contact_before = _read_offsets(articulation, TT.REST_OFFSET, TT.CONTACT_OFFSET)
+        assert rest_before.shape[0] == num_envs
+        assert not ((rest_before >= REST_RANGE[0]) & (rest_before <= REST_RANGE[1])).any()
+        assert not ((contact_before >= CONTACT_RANGE[0]) & (contact_before <= CONTACT_RANGE[1])).any()
+
+        # only rest offsets requested: contact offsets must stay untouched
+        term(env, None, asset_cfg, rest_offset_distribution_params=REST_RANGE)
+        rest_after, contact_after = _read_offsets(articulation, TT.REST_OFFSET, TT.CONTACT_OFFSET)
+        _assert_randomized_rows(rest_before, rest_after, list(range(num_envs)), REST_RANGE)
+        torch.testing.assert_close(contact_after, contact_before)
+
+        term(env, None, asset_cfg, contact_offset_distribution_params=CONTACT_RANGE)
+        _, contact_after = _read_offsets(articulation, TT.REST_OFFSET, TT.CONTACT_OFFSET)
+        _assert_randomized_rows(contact_before, contact_after, list(range(num_envs)), CONTACT_RANGE)