[OVPHYSX] Articulation rewrite (data class + asset class + kernels)

scripts/run_ovphysx.sh

@@ -3,6 +3,14 @@
 # Use when ovphysx is installed into Kit's Python.
 #
 # Usage: ./scripts/run_ovphysx.sh [your_script.py or -m pytest ...]
+#
+# CI note: the OVPhysX wheel's device mode is a process-global C++/Carbonite
+# static (gap G5 in docs/superpowers/specs/2026-04-28-ovphysx-wheel-gaps-for-marco.md).
+# To exercise both CPU and GPU coverage, invoke this script TWICE in separate
+# processes -- e.g.
+#   ./scripts/run_ovphysx.sh -m pytest <path> -k 'cpu'
+#   ./scripts/run_ovphysx.sh -m pytest <path> -k 'cuda:0'
+# A single invocation locks to whichever device is requested first.
 set -e
 
 ISAACLAB_PATH="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"

source/isaaclab/test/assets/test_articulation_iface.py

@@ -20,16 +20,33 @@
 from unittest.mock import MagicMock
 
 # When running kitless (e.g., ovphysx backend via run_ovphysx.sh), AppLauncher
-# will try to boot Kit and hang. Skip it entirely when LD_PRELOAD is cleared
-# (the signature of run_ovphysx.sh) or when EXP_PATH is not set.
-_kitless = os.environ.get("LD_PRELOAD", "") == "" and "EXP_PATH" not in os.environ
+# will try to boot Kit and hang. Skip it entirely: run_ovphysx.sh sets
+# LD_PRELOAD to the ovphysx libcarb.so, which is the signature of a kitless
+# ovphysx run. Also guard the case where neither LD_PRELOAD nor EXP_PATH is
+# set (bare Python, no Kit at all).
+_kitless = "ovphysx" in os.environ.get("LD_PRELOAD", "") or (
+    os.environ.get("LD_PRELOAD", "") == "" and "EXP_PATH" not in os.environ
+)
 
 if not _kitless:
     from isaaclab.app import AppLauncher
 
     simulation_app = AppLauncher(headless=True).app
 else:
     simulation_app = None
+    # Stub out the Kit/Omniverse modules that are not present under
+    # run_ovphysx.sh (pxr, carb, omni, omni.kit[.app] are real on PYTHONPATH).
+    # ``omni`` is a real namespace package, so missing submodules also need
+    # to be installed as attributes on it -- ``sys.modules`` alone is not
+    # enough because attribute access on the real ``omni`` won't fall
+    # through to ``sys.modules``.
+    import omni as _omni
+
+    for _mod in ("physics", "physics.tensors", "physx", "timeline", "usd"):
+        _stub = MagicMock()
+        sys.modules[f"omni.{_mod}"] = _stub
+        # Bind the leaf attribute so that ``omni.<leaf>`` resolves.
+        setattr(_omni, _mod.split(".", 1)[0], _stub)
     for _mod in ("isaacsim.core", "isaacsim.core.simulation_manager"):
         sys.modules.setdefault(_mod, MagicMock())
 
@@ -271,20 +288,27 @@ def create_ovphysx_articulation(
     object.__setattr__(articulation, "_num_spatial_tendons", num_spatial_tendons)
 
     # Create ArticulationData
-    data = OvPhysxArticulationData(mock_bindings.bindings, device)
-    data._num_instances = num_instances
-    data._num_joints = num_joints
-    data._num_bodies = num_bodies
-    data._num_fixed_tendons = num_fixed_tendons
-    data._num_spatial_tendons = num_spatial_tendons
+    data = OvPhysxArticulationData(
+        mock_bindings.bindings,
+        device,
+        num_instances=num_instances,
+        num_bodies=num_bodies,
+        num_joints=num_joints,
+        num_fixed_tendons=num_fixed_tendons,
+        num_spatial_tendons=num_spatial_tendons,
+        body_names=body_names,
+        joint_names=joint_names,
+        fixed_tendon_names=fixed_tendon_names,
+        spatial_tendon_names=spatial_tendon_names,
+    )
     data._is_fixed_base = False
-    data.body_names = body_names
-    data.joint_names = joint_names
-    data.fixed_tendon_names = fixed_tendon_names
-    data.spatial_tendon_names = spatial_tendon_names
-    data._create_buffers()
     object.__setattr__(articulation, "_data", data)
 
+    # Allocate the articulation-side index/mask caches and wrench buffer that
+    # _initialize_impl would normally populate.  Wrench composers created here
+    # are immediately overwritten by the mocks below.
+    articulation._create_buffers()
+
     # Wrench composers
     mock_inst_wrench = MockWrenchComposer(articulation)
     mock_perm_wrench = MockWrenchComposer(articulation)

source/isaaclab/test/assets/test_rigid_object_iface.py

@@ -13,16 +13,42 @@
 The setup is a bit convoluted so that we can run these tests without requiring Isaac Sim or GPU simulation.
 """
 
-"""Launch Isaac Sim Simulator first."""
+"""Launch Isaac Sim Simulator first (when available)."""
 
-from isaaclab.app import AppLauncher
-
-HEADLESS = True
+import os
+import sys
+from unittest.mock import MagicMock
 
-# launch omniverse app
-simulation_app = AppLauncher(headless=True).app
+# When running kitless (e.g., ovphysx backend via run_ovphysx.sh), AppLauncher
+# will try to boot Kit and hang. Skip it entirely: run_ovphysx.sh sets
+# LD_PRELOAD to the ovphysx libcarb.so, which is the signature of a kitless
+# ovphysx run. Also guard the case where neither LD_PRELOAD nor EXP_PATH is
+# set (bare Python, no Kit at all).
+_kitless = "ovphysx" in os.environ.get("LD_PRELOAD", "") or (
+    os.environ.get("LD_PRELOAD", "") == "" and "EXP_PATH" not in os.environ
+)
 
-from unittest.mock import MagicMock
+if not _kitless:
+    from isaaclab.app import AppLauncher
+
+    simulation_app = AppLauncher(headless=True).app
+else:
+    simulation_app = None
+    # Stub out the Kit/Omniverse modules that are not present under
+    # run_ovphysx.sh (pxr, carb, omni, omni.kit[.app] are real on PYTHONPATH).
+    # ``omni`` is a real namespace package, so missing submodules also need
+    # to be installed as attributes on it -- ``sys.modules`` alone is not
+    # enough because attribute access on the real ``omni`` won't fall
+    # through to ``sys.modules``.
+    import omni as _omni
+
+    for _mod in ("physics", "physics.tensors", "physx", "timeline", "usd"):
+        _stub = MagicMock()
+        sys.modules[f"omni.{_mod}"] = _stub
+        # Bind the leaf attribute so that ``omni.<leaf>`` resolves.
+        setattr(_omni, _mod.split(".", 1)[0], _stub)
+    for _mod in ("isaacsim.core", "isaacsim.core.simulation_manager"):
+        sys.modules.setdefault(_mod, MagicMock())
 
 import numpy as np
 import pytest
@@ -66,6 +92,15 @@
 except ImportError:
     pass
 
+try:
+    from isaaclab_ovphysx.assets.rigid_object.rigid_object import RigidObject as OvPhysxRigidObject
+    from isaaclab_ovphysx.assets.rigid_object.rigid_object_data import RigidObjectData as OvPhysxRigidObjectData
+    from isaaclab_ovphysx.test.mock_interfaces.views import MockOvPhysxBindingSet
+
+    BACKENDS.append("ovphysx")
+except (ImportError, AttributeError):
+    pass
+
 
 def create_physx_rigid_object(
     num_instances: int = 2,
@@ -206,6 +241,62 @@ def create_newton_rigid_object(
     return rigid_object, mock_view
 
 
+def create_ovphysx_rigid_object(
+    num_instances: int = 2,
+    device: str = "cuda:0",
+):
+    """Create a test OvPhysX RigidObject instance with mocked tensor bindings."""
+    body_names = ["base_link"]
+
+    obj = object.__new__(OvPhysxRigidObject)
+
+    obj.cfg = RigidObjectCfg(prim_path="/World/object")
+
+    # Create mock binding set
+    mock_bindings = MockOvPhysxBindingSet(
+        num_instances=num_instances,
+        num_joints=0,
+        num_bodies=1,
+        body_names=body_names,
+        asset_kind="rigid_object",
+    )
+    mock_bindings.set_random_data()
+
+    object.__setattr__(obj, "_device", device)
+    object.__setattr__(obj, "_ovphysx", MagicMock())
+    object.__setattr__(obj, "_bindings", mock_bindings.bindings)
+    object.__setattr__(obj, "_num_instances", num_instances)
+    object.__setattr__(obj, "_num_bodies", 1)
+    object.__setattr__(obj, "_body_names", body_names)
+
+    # Create RigidObjectData
+    data = OvPhysxRigidObjectData(mock_bindings.bindings, device)
+    data.num_instances = num_instances
+    data.num_bodies = 1
+    data._is_primed = True
+    object.__setattr__(obj, "_data", data)
+
+    # Build the buffers RigidObject normally allocates in _initialize_impl
+    # (_ALL_INDICES, _ALL_*_MASK, pinned CPU staging buffers, wrench buf).
+    # _create_buffers also instantiates real WrenchComposers; those get
+    # replaced with mocks just below.
+    obj._create_buffers()
+
+    # Replace the real wrench composers with mocks for iface coverage.
+    mock_inst_wrench = MockWrenchComposer(obj)
+    mock_perm_wrench = MockWrenchComposer(obj)
+    object.__setattr__(obj, "_instantaneous_wrench_composer", mock_inst_wrench)
+    object.__setattr__(obj, "_permanent_wrench_composer", mock_perm_wrench)
+
+    # Prevent __del__ / _clear_callbacks from raising
+    object.__setattr__(obj, "_initialize_handle", None)
+    object.__setattr__(obj, "_invalidate_initialize_handle", None)
+    object.__setattr__(obj, "_prim_deletion_handle", None)
+    object.__setattr__(obj, "_debug_vis_handle", None)
+
+    return obj, mock_bindings
+
+
 def create_mock_rigid_object(
     num_instances: int = 2,
     device: str = "cuda:0",
@@ -226,6 +317,8 @@ def get_rigid_object(
 ):
     if backend == "physx":
         return create_physx_rigid_object(num_instances, device)
+    elif backend == "ovphysx":
+        return create_ovphysx_rigid_object(num_instances, device)
     elif backend == "newton":
         return create_newton_rigid_object(num_instances, device)
     elif backend.lower() == "mock":

source/isaaclab_ovphysx/changelog.d/antoiner-feat-ovphysx_articulation.minor.rst

@@ -0,0 +1,109 @@
+Added
+^^^^^
+
+* Added :class:`~isaaclab_ovphysx.assets.Articulation` and
+  :class:`~isaaclab_ovphysx.assets.ArticulationData` for multi-DOF articulated
+  robots against the OVPhysX backend, satisfying the
+  :class:`~isaaclab.assets.BaseArticulation` and
+  :class:`~isaaclab.assets.BaseArticulationData` contracts. Public surface
+  matches the PhysX/Newton conventions: kwarg-only ``write_*_to_sim_index`` /
+  ``write_*_to_sim_mask`` writers and ``set_*_index`` / ``set_*_mask`` setters
+  for root state, joint state, joint properties, body properties, joint
+  command targets, fixed/spatial tendon properties, and external wrenches via
+  :attr:`~isaaclab_ovphysx.assets.Articulation.instantaneous_wrench_composer`
+  / :attr:`~isaaclab_ovphysx.assets.Articulation.permanent_wrench_composer`.
+  The full IsaacLab actuator pipeline (``compute`` /
+  ``_apply_actuator_model`` / ``_process_actuators_cfg``) is implemented on
+  top of the wheel's ``DOF_ACTUATION_FORCE`` /
+  ``DOF_POSITION_TARGET`` / ``DOF_VELOCITY_TARGET`` bindings.
+* Added articulation-specific Warp kernels in
+  :mod:`isaaclab_ovphysx.assets.articulation.kernels`: soft-limit refresh,
+  default-joint-pos clamp, friction-component scatter (index + mask
+  variants).  Six articulation kernels were also folded into the shared
+  :mod:`isaaclab_ovphysx.assets.kernels` module for reuse with
+  :class:`~isaaclab_ovphysx.assets.RigidObject` and
+  :class:`~isaaclab_ovphysx.assets.RigidObjectCollection`.
+* Added init-time validation in
+  :meth:`~isaaclab_ovphysx.assets.Articulation._initialize_impl` that raises
+  ``RuntimeError`` when ``cfg.prim_path`` resolves to no
+  ``UsdPhysics.ArticulationRootAPI`` prim or to multiple roots, and
+  ``ValueError`` (via :meth:`_validate_cfg`) when any default joint
+  position is outside ``[lower, upper]`` or any default joint velocity
+  exceeds the per-joint maximum.  Mirrors the PhysX backend.
+* Added support for ``cfg.articulation_root_prim_path`` in
+  :meth:`~isaaclab_ovphysx.assets.Articulation._initialize_impl`: when the
+  user supplies an explicit subpath the binding pattern is extended
+  directly instead of running the auto-discovery walk, and a
+  ``RuntimeError`` is raised when the resulting expression resolves to no
+  prim in the USD stage.
+
+Changed
+^^^^^^^
+
+* **Breaking:** Renamed ``Articulation`` write/set methods to the dual
+  ``*_index`` / ``*_mask`` form and dropped the legacy ``full_data``
+  flag.  Index methods accept partial data shaped
+  ``(len(env_ids), len(joint_or_body_ids), ...)``; mask methods accept
+  full-shape data and a ``wp.bool`` mask.  All keyword-only arguments live
+  after ``*,``; no positional fall-through.  Migration: replace
+  ``write_X_to_sim(..., from_mask=True)`` with ``write_X_to_sim_mask(..., mask=...)``.
+* **Breaking:** Removed the ``_write_body_state`` plumbing layer.
+  Deprecated state-writer shims (``write_root_state_to_sim``,
+  ``write_root_com_state_to_sim``, ``write_root_link_state_to_sim``,
+  joint-state equivalents) now call the public ``write_*_to_sim_index``
+  methods directly.  Behaviour is preserved.
+* Changed ``Articulation.root_view`` to return the per-tensor-type bindings
+  dict (``self._bindings``).  The OVPhysX wheel does not expose a single
+  ``ArticulationView`` object; callers that previously walked
+  ``root_view.shared_metatype`` / ``root_view.max_dofs`` should read from
+  :attr:`~isaaclab_ovphysx.assets.Articulation.num_joints` /
+  :attr:`~isaaclab_ovphysx.assets.Articulation.num_bodies` /
+  :attr:`~isaaclab_ovphysx.assets.Articulation.body_names` /
+  :attr:`~isaaclab_ovphysx.assets.Articulation.joint_names` instead.
+* Changed every ``ArticulationData`` public property to return a
+  :class:`~isaaclab.utils.ProxyArray` (warp + torch dual view); raw
+  ``wp.array`` is reserved for one-shot config buffers.  Eager
+  ``TimestampedBufferWarp`` allocation in :meth:`_create_buffers` makes
+  every buffer a single source of truth — no
+  ``_invalidate_caches`` / ``_ensure_*_buffers`` machinery.
+* Changed ``Articulation`` body and DOF property writers to honor the
+  wheel's actual binding device.  Tensor-type membership in
+  :data:`isaaclab_ovphysx.tensor_types._CPU_ONLY_TYPES` now reflects what
+  the wheel exposes: ``BODY_MASS``, ``BODY_COM_POSE``, ``BODY_INERTIA``,
+  ``DOF_STIFFNESS``, ``DOF_DAMPING``, ``DOF_LIMIT``, ``DOF_MAX_VELOCITY``,
+  ``DOF_MAX_FORCE``, ``DOF_ARMATURE``, ``DOF_FRICTION_PROPERTIES`` are
+  CPU-only (write goes through pinned-host staging); fixed and spatial
+  tendon bindings write directly from sim-device buffers.
+* Changed :meth:`~isaaclab_ovphysx.assets.Articulation.write_joint_friction_coefficient_to_sim_index`
+  / ``_mask`` to accept ``joint_dynamic_friction_coeff`` and
+  ``joint_viscous_friction_coeff`` keyword arguments (each
+  ``float | torch.Tensor | wp.array | None``).  ``None`` preserves the
+  existing component on the wheel; matches the PhysX backend.
+* Changed :meth:`~isaaclab_ovphysx.assets.Articulation.write_joint_position_limit_to_sim_index`
+  / ``_mask`` to clamp ``default_joint_pos`` and refresh
+  ``soft_joint_pos_limits`` when the new hard limits invalidate the
+  defaults, matching the PhysX backend (with a
+  ``warn_limit_violation`` log).
+* Changed every fixed/spatial tendon ``set_*_index`` / ``set_*_mask`` setter
+  to accept a scalar :class:`float` for the value argument; broadcast is
+  materialized via :meth:`_broadcast_scalar_to_2d`.  Mirrors PhysX.
+* Implemented the previously stubbed
+  :meth:`~isaaclab_ovphysx.assets.Articulation.write_fixed_tendon_properties_to_sim_index`
+  / ``_mask`` and
+  :meth:`~isaaclab_ovphysx.assets.Articulation.write_spatial_tendon_properties_to_sim_index`
+  / ``_mask``: each iterates the per-tensor bindings since the OVPhysX
+  wheel has no batch ``set_*_tendon_properties`` setter.
+
+Removed
+^^^^^^^
+
+* **Breaking:** Removed the ``full_data`` keyword-argument from every
+  ``Articulation`` ``*_index`` writer/setter.  Index methods now strictly
+  accept partial data; full-data callers should use the matching
+  ``*_mask`` overload.
+* Removed the stop-gap :mod:`isaaclab_ovphysx.assets.kernels_old` module;
+  the six articulation kernels it housed
+  (``_compose_root_com_pose``, ``_compute_heading``, ``_copy_first_body``,
+  ``_projected_gravity``, ``_world_vel_to_body_ang``,
+  ``_world_vel_to_body_lin``) are now in
+  :mod:`isaaclab_ovphysx.assets.kernels`.

source/isaaclab_ovphysx/changelog.d/antoiner-feat-ovphysx_rigidobject.minor.rst

@@ -0,0 +1,50 @@
+Added
+^^^^^
+
+* Added :class:`~isaaclab_ovphysx.assets.RigidObject` and
+  :class:`~isaaclab_ovphysx.assets.RigidObjectData` for single-actor rigid-body
+  simulation against the OVPhysX backend, satisfying the
+  :class:`~isaaclab.assets.BaseRigidObject` and
+  :class:`~isaaclab.assets.BaseRigidObjectData` contracts. Public surface
+  matches the PhysX/Newton conventions: ``write_root_*_to_sim_index`` /
+  ``write_root_*_to_sim_mask`` writers (link- and com-frame variants),
+  ``set_masses_*``, ``set_coms_*``, ``set_inertias_*`` setters, and the
+  external-wrench composers exposed via
+  :meth:`~isaaclab_ovphysx.assets.RigidObject.set_external_force_and_torque`.
+* Added the ``RIGID_BODY_*`` :class:`TensorType` aliases in
+  :mod:`isaaclab_ovphysx.tensor_types` (``POSE``, ``VELOCITY``, ``WRENCH``,
+  ``MASS``, ``COM_POSE``, ``INERTIA``; plus ``ACCELERATION``, ``INV_MASS``,
+  ``INV_INERTIA`` declared for forward compatibility once the wheel ships
+  them).
+* Added :class:`~isaaclab_ovphysx.assets.kernels` as a shared Warp-kernel
+  module (frame conversions, state concatenation, finite-difference
+  acceleration, index- and mask-style scatter writers) consumed by both the
+  rigid-object and articulation assets.
+* Added USD prim-scan validation in
+  :meth:`~isaaclab_ovphysx.assets.RigidObject._initialize_impl`: a clear
+  ``RuntimeError`` is raised when ``cfg.prim_path`` resolves to no
+  ``UsdPhysics.RigidBodyAPI`` prim, multiple rigid-body prims, or a prim with
+  an enabled ``UsdPhysics.ArticulationRootAPI``.
+
+Changed
+^^^^^^^
+
+* Changed :meth:`~isaaclab_ovphysx.physics.OvPhysxManager._release_physx` to
+  perform a soft reset (``physx.reset()``) and keep the cached
+  :class:`ovphysx.PhysX` reference alive across
+  :class:`~isaaclab.sim.SimulationContext` lifetimes, instead of dropping the
+  reference and triggering the wheel's dual-Carbonite static-destructor race.
+  :meth:`~isaaclab_ovphysx.physics.OvPhysxManager._warmup_and_load` now reuses
+  the cached instance on subsequent calls.
+* Changed :meth:`~isaaclab_ovphysx.physics.OvPhysxManager._warmup_and_load` to
+  raise a clear ``RuntimeError`` when a later
+  :class:`~isaaclab.sim.SimulationContext` requests a different device than
+  the one the process is locked to, surfacing the wheel's process-global
+  device-mode lock as a Python error before
+  :exc:`ovphysx.types.PhysXDeviceError` would fire.
+* Changed :meth:`~isaaclab_ovphysx.physics.OvPhysxManager._configure_physx_scene_prim`
+  to apply the ``UsdPhysics.PhysxSceneAPI`` schema and
+  ``enableSceneQuerySupport`` on both CPU and GPU; GPU-only attributes
+  (``enableGPUDynamics``, ``broadphaseType``, the ``gpu*`` capacity attributes
+  from :class:`~isaaclab_ovphysx.physics.OvPhysxCfg`) remain gated on
+  ``device == "gpu"``.

source/isaaclab_ovphysx/isaaclab_ovphysx/assets/__init__.pyi

@@ -6,6 +6,9 @@
 __all__ = [
     "Articulation",
     "ArticulationData",
+    "RigidObject",
+    "RigidObjectData",
 ]
 
 from .articulation import Articulation, ArticulationData
+from .rigid_object import RigidObject, RigidObjectData