# 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 """Launch Isaac Sim Simulator first.""" from isaaclab.app import AppLauncher # launch omniverse app simulation_app = AppLauncher(headless=True).app """Rest everything follows.""" import math import warnings import pytest from isaaclab_physx.sim.schemas import ( ArticulationRootPropertiesCfg as ArticulationRootDeprecatedAliasCfg, ) from isaaclab_physx.sim.schemas import ( CollisionPropertiesCfg as PhysxCollisionPropertiesCfgAlias, ) from isaaclab_physx.sim.schemas import ( PhysxArticulationRootPropertiesCfg, PhysxCollisionPropertiesCfg, PhysxJointDrivePropertiesCfg, PhysxRigidBodyPropertiesCfg, ) from isaaclab_physx.sim.spawners.materials import PhysxRigidBodyMaterialCfg, RigidBodyMaterialCfg from pxr import UsdPhysics import isaaclab.sim as sim_utils import isaaclab.sim.schemas as schemas from isaaclab.sim import SimulationCfg, SimulationContext from isaaclab.sim.spawners.materials import RigidBodyMaterialBaseCfg, spawn_rigid_body_material from isaaclab.utils.assets import ISAAC_NUCLEUS_DIR from isaaclab.utils.string import to_camel_case @pytest.fixture def setup_simulation(): """Fixture to set up and tear down the simulation context.""" # Create a new stage sim_utils.create_new_stage() # Simulation time-step dt = 0.1 # Load kit helper sim = SimulationContext(SimulationCfg(dt=dt)) # Set some default values for test arti_cfg = schemas.ArticulationRootPropertiesCfg( enabled_self_collisions=False, articulation_enabled=True, solver_position_iteration_count=4, solver_velocity_iteration_count=1, sleep_threshold=1.0, stabilization_threshold=5.0, fix_root_link=False, ) rigid_cfg = PhysxRigidBodyPropertiesCfg( rigid_body_enabled=True, kinematic_enabled=False, disable_gravity=False, linear_damping=0.1, angular_damping=0.5, max_linear_velocity=1000.0, max_angular_velocity=1000.0, max_depenetration_velocity=10.0, max_contact_impulse=10.0, enable_gyroscopic_forces=True, retain_accelerations=True, solver_position_iteration_count=8, solver_velocity_iteration_count=1, sleep_threshold=1.0, stabilization_threshold=6.0, ) collision_cfg = schemas.CollisionPropertiesCfg( collision_enabled=True, contact_offset=0.05, rest_offset=0.001, min_torsional_patch_radius=0.1, torsional_patch_radius=1.0, ) mass_cfg = schemas.MassPropertiesCfg(mass=1.0, density=100.0) joint_cfg = PhysxJointDrivePropertiesCfg( drive_type="acceleration", max_force=80.0, max_joint_velocity=10.0, stiffness=10.0, damping=0.1 ) yield sim, arti_cfg, rigid_cfg, collision_cfg, mass_cfg, joint_cfg # Teardown sim._disable_app_control_on_stop_handle = True # prevent timeout sim.stop() sim.clear_instance() @pytest.mark.isaacsim_ci def test_valid_properties_cfg(setup_simulation): """Test that all the config instances have non-None values. This is to ensure that we check that all the properties of the schema are set. """ sim, arti_cfg, rigid_cfg, collision_cfg, mass_cfg, joint_cfg = setup_simulation # deprecation aliases are nulled by __post_init__ after forwarding to the canonical # field; exclude them from the all-non-None check. deprecation_aliases = {"max_velocity", "max_effort"} for cfg in [arti_cfg, rigid_cfg, collision_cfg, mass_cfg, joint_cfg]: for k, v in cfg.__dict__.items(): # skip class-metadata keys (``_usd_*``) and deprecation aliases nulled in __post_init__ if k.startswith("_") or k in deprecation_aliases: continue assert v is not None, f"{cfg.__class__.__name__}:{k} is None. Please make sure schemas are valid." @pytest.mark.isaacsim_ci def test_max_joint_velocity_on_base_cfg(setup_simulation): """Setting ``max_joint_velocity`` on the base ``JointDriveBaseCfg`` must author ``physxJoint:maxJointVelocity`` on the prim, identical to setting it on the deprecated PhysX subclass. Regression test for the Path 2 placement rule: ``max_joint_velocity`` is the only USD path to ``Model.joint_velocity_limit`` and lives on the base. """ sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() base_cfg = schemas.JointDriveBaseCfg( drive_type="acceleration", max_force=80.0, max_joint_velocity=10.0, stiffness=10.0, damping=0.1, ) # spawn a minimal articulation with a revolute joint, then write properties. sim_utils.create_prim("/World/Articulation", prim_type="Xform") sim_utils.create_prim("/World/Articulation/body0", prim_type="Cube") sim_utils.create_prim("/World/Articulation/body1", prim_type="Cube") UsdPhysics.RevoluteJoint.Define(stage, "/World/Articulation/joint_0") prim_path = "/World/Articulation/joint_0" # use unwrapped function (no parent traversal) so this returns the inner bool schemas.modify_joint_drive_properties.__wrapped__(prim_path, base_cfg) # Revolute drives convert rad/s -> deg/s; check the authored value. attr = stage.GetPrimAtPath(prim_path).GetAttribute("physxJoint:maxJointVelocity") assert attr.IsValid(), "physxJoint:maxJointVelocity was not authored on the prim" expected_deg_per_sec = 10.0 * 180.0 / math.pi assert attr.Get() == pytest.approx(expected_deg_per_sec, rel=1e-6) @pytest.mark.isaacsim_ci def test_max_velocity_deprecation_alias(setup_simulation): """Legacy ``max_velocity`` kwarg must forward to ``max_joint_velocity`` and emit a ``DeprecationWarning``. Behavior must match setting ``max_joint_velocity`` directly. """ sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() with pytest.warns(DeprecationWarning, match="max_velocity"): base_cfg = schemas.JointDriveBaseCfg( drive_type="acceleration", max_force=80.0, max_velocity=10.0, stiffness=10.0, damping=0.1, ) assert base_cfg.max_joint_velocity == 10.0 assert base_cfg.max_velocity is None sim_utils.create_prim("/World/Articulation_dep", prim_type="Xform") sim_utils.create_prim("/World/Articulation_dep/body0", prim_type="Cube") sim_utils.create_prim("/World/Articulation_dep/body1", prim_type="Cube") UsdPhysics.RevoluteJoint.Define(stage, "/World/Articulation_dep/joint_0") prim_path = "/World/Articulation_dep/joint_0" schemas.modify_joint_drive_properties.__wrapped__(prim_path, base_cfg) attr = stage.GetPrimAtPath(prim_path).GetAttribute("physxJoint:maxJointVelocity") assert attr.IsValid() assert attr.Get() == pytest.approx(10.0 * 180.0 / math.pi, rel=1e-6) @pytest.mark.isaacsim_ci def test_max_effort_deprecation_alias(setup_simulation): """Legacy ``max_effort`` kwarg must forward to ``max_force`` and emit a ``DeprecationWarning``. Behavior must match setting ``max_force`` directly. """ sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() with pytest.warns(DeprecationWarning, match="max_effort"): base_cfg = schemas.JointDriveBaseCfg( drive_type="acceleration", max_effort=42.0, stiffness=10.0, damping=0.1, ) assert base_cfg.max_force == 42.0 assert base_cfg.max_effort is None sim_utils.create_prim("/World/Articulation_eff", prim_type="Xform") sim_utils.create_prim("/World/Articulation_eff/body0", prim_type="Cube") sim_utils.create_prim("/World/Articulation_eff/body1", prim_type="Cube") UsdPhysics.PrismaticJoint.Define(stage, "/World/Articulation_eff/joint_0") prim_path = "/World/Articulation_eff/joint_0" schemas.modify_joint_drive_properties.__wrapped__(prim_path, base_cfg) attr = stage.GetPrimAtPath(prim_path).GetAttribute("drive:linear:physics:maxForce") assert attr.IsValid() assert attr.Get() == pytest.approx(42.0, rel=1e-6) @pytest.mark.isaacsim_ci def test_joint_drive_base_no_physx_schema_when_max_joint_velocity_unset(setup_simulation): """Regression: setting only UsdPhysics drive fields on JointDriveBaseCfg must NOT cause PhysxJointAPI to be applied to the prim. Without this, Newton-targeted users get PhysX schemas stamped on every joint.""" sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() base_cfg = schemas.JointDriveBaseCfg( drive_type="acceleration", max_force=80.0, stiffness=10.0, damping=0.1, # max_joint_velocity intentionally left None ) sim_utils.create_prim("/World/Articulation", prim_type="Xform") sim_utils.create_prim("/World/Articulation/body0", prim_type="Cube") sim_utils.create_prim("/World/Articulation/body1", prim_type="Cube") UsdPhysics.RevoluteJoint.Define(stage, "/World/Articulation/joint_0") prim_path = "/World/Articulation/joint_0" schemas.modify_joint_drive_properties.__wrapped__(prim_path, base_cfg) applied = stage.GetPrimAtPath(prim_path).GetAppliedSchemas() assert "PhysxJointAPI" not in applied, ( f"PhysxJointAPI should not be applied when max_velocity is None; got {list(applied)}" ) @pytest.mark.isaacsim_ci def test_disable_gravity_on_base_cfg(setup_simulation): """Setting disable_gravity on the base RigidBodyBaseCfg must author physxRigidBody:disableGravity on the prim. PhysX honors per-body; Newton currently honors at scene level (partial), documented in field docstring. Regression test for the consumption-gated placement rule.""" sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() base_cfg = schemas.RigidBodyBaseCfg( rigid_body_enabled=True, kinematic_enabled=False, disable_gravity=True, ) sim_utils.create_prim("/World/cube_dg", prim_type="Cube", translation=(0.0, 0.0, 0.62)) schemas.define_rigid_body_properties("/World/cube_dg", base_cfg) prim_path = "/World/cube_dg" attr = stage.GetPrimAtPath(prim_path).GetAttribute("physxRigidBody:disableGravity") assert attr.IsValid(), "physxRigidBody:disableGravity was not authored on the prim" assert attr.Get() is True applied = stage.GetPrimAtPath(prim_path).GetAppliedSchemas() assert "PhysxRigidBodyAPI" in applied, ( f"PhysxRigidBodyAPI must be applied when disable_gravity is set; got {list(applied)}" ) @pytest.mark.isaacsim_ci def test_physx_rigid_body_no_physx_schema_when_all_physx_fields_none(setup_simulation): """Regression: PhysxRigidBodyPropertiesCfg with all PhysX-specific fields left as None must NOT cause PhysxRigidBodyAPI to be applied to the prim. The user only authored UsdPhysics-standard fields; the PhysX schema should not be stamped onto a Newton-targeted asset.""" sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() cfg = PhysxRigidBodyPropertiesCfg( rigid_body_enabled=True, kinematic_enabled=False, # every PhysX field intentionally left None ) sim_utils.create_prim("/World/cube_no_physx", prim_type="Cube", translation=(0.0, 0.0, 0.62)) schemas.define_rigid_body_properties("/World/cube_no_physx", cfg) prim_path = "/World/cube_no_physx" applied = stage.GetPrimAtPath(prim_path).GetAppliedSchemas() assert "PhysxRigidBodyAPI" not in applied, ( f"PhysxRigidBodyAPI should not be applied when no PhysX fields are set; got {list(applied)}" ) @pytest.mark.isaacsim_ci def test_rigid_body_material_base_cfg(setup_simulation): """Setting only UsdPhysics fields on RigidBodyMaterialBaseCfg must author the three friction/restitution attrs and must NOT apply PhysxMaterialAPI.""" sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() cfg = RigidBodyMaterialBaseCfg(static_friction=0.7, dynamic_friction=0.6, restitution=0.1) prim_path = "/World/Looks/BaseMaterial" spawn_rigid_body_material.__wrapped__(prim_path, cfg) prim = stage.GetPrimAtPath(prim_path) assert prim.GetAttribute("physics:staticFriction").Get() == pytest.approx(0.7) assert prim.GetAttribute("physics:dynamicFriction").Get() == pytest.approx(0.6) assert prim.GetAttribute("physics:restitution").Get() == pytest.approx(0.1) applied = prim.GetAppliedSchemas() assert "PhysxMaterialAPI" not in applied, ( f"PhysxMaterialAPI must not be applied for the base cfg; got {list(applied)}" ) @pytest.mark.isaacsim_ci def test_physx_rigid_body_material_cfg(setup_simulation): """Setting a PhysX-namespaced field on PhysxRigidBodyMaterialCfg must author the namespaced attribute AND apply PhysxMaterialAPI.""" sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() cfg = PhysxRigidBodyMaterialCfg(static_friction=0.7, compliant_contact_stiffness=100.0) prim_path = "/World/Looks/PhysxMaterial" spawn_rigid_body_material.__wrapped__(prim_path, cfg) prim = stage.GetPrimAtPath(prim_path) assert prim.GetAttribute("physics:staticFriction").Get() == pytest.approx(0.7) assert prim.GetAttribute("physxMaterial:compliantContactStiffness").Get() == pytest.approx(100.0) applied = prim.GetAppliedSchemas() assert "PhysxMaterialAPI" in applied, ( f"PhysxMaterialAPI must be applied when a PhysX field is set; got {list(applied)}" ) @pytest.mark.isaacsim_ci def test_rigid_body_material_deprecation_alias(setup_simulation): """Instantiating the legacy ``RigidBodyMaterialCfg`` name emits exactly one ``DeprecationWarning`` whose message references the 5.0 removal target.""" with warnings.catch_warnings(record=True) as caught: warnings.simplefilter("always") RigidBodyMaterialCfg() deprecations = [w for w in caught if issubclass(w.category, DeprecationWarning)] assert len(deprecations) == 1, f"expected exactly one DeprecationWarning, got {len(deprecations)}" assert "5.0" in str(deprecations[0].message) @pytest.mark.isaacsim_ci def test_collision_base_cfg_writes_physx_namespaced_attrs(setup_simulation): """Setting ``contact_offset`` / ``rest_offset`` on the base ``CollisionBaseCfg`` must author the ``physxCollision:*`` attributes AND apply ``PhysxCollisionAPI``. Newton's importer consumes them via the PhysX bridge resolver.""" sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() base_cfg = schemas.CollisionBaseCfg(collision_enabled=True, contact_offset=0.05, rest_offset=0.001) sim_utils.create_prim("/World/cube_co", prim_type="Cube", translation=(0.0, 0.0, 0.62)) schemas.define_collision_properties("/World/cube_co", base_cfg) prim = stage.GetPrimAtPath("/World/cube_co") assert prim.GetAttribute("physxCollision:contactOffset").Get() == pytest.approx(0.05) assert prim.GetAttribute("physxCollision:restOffset").Get() == pytest.approx(0.001) applied = prim.GetAppliedSchemas() assert "PhysxCollisionAPI" in applied, ( f"PhysxCollisionAPI must be applied when contact_offset/rest_offset are set; got {list(applied)}" ) @pytest.mark.isaacsim_ci def test_collision_base_cfg_no_physx_schema_when_only_usd_field_set(setup_simulation): """Regression: setting only ``collision_enabled`` on ``CollisionBaseCfg`` must NOT cause ``PhysxCollisionAPI`` to be applied. The user only authored a UsdPhysics-standard field; the PhysX schema should not be stamped onto a Newton-targeted prim.""" sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() base_cfg = schemas.CollisionBaseCfg(collision_enabled=True) sim_utils.create_prim("/World/cube_co_only", prim_type="Cube", translation=(0.0, 0.0, 0.62)) schemas.define_collision_properties("/World/cube_co_only", base_cfg) prim = stage.GetPrimAtPath("/World/cube_co_only") assert prim.GetAttribute("physics:collisionEnabled").Get() is True applied = prim.GetAppliedSchemas() assert "PhysxCollisionAPI" not in applied, ( f"PhysxCollisionAPI should not be applied when only collision_enabled is set; got {list(applied)}" ) @pytest.mark.isaacsim_ci def test_physx_collision_cfg_writes_torsional_patch(setup_simulation): """Setting ``torsional_patch_radius`` on ``PhysxCollisionPropertiesCfg`` must author the ``physxCollision:torsionalPatchRadius`` attribute AND apply ``PhysxCollisionAPI``.""" sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() cfg = PhysxCollisionPropertiesCfg(torsional_patch_radius=1.0) sim_utils.create_prim("/World/cube_tpr", prim_type="Cube", translation=(0.0, 0.0, 0.62)) schemas.define_collision_properties("/World/cube_tpr", cfg) prim = stage.GetPrimAtPath("/World/cube_tpr") assert prim.GetAttribute("physxCollision:torsionalPatchRadius").Get() == pytest.approx(1.0) applied = prim.GetAppliedSchemas() assert "PhysxCollisionAPI" in applied @pytest.mark.isaacsim_ci def test_collision_deprecation_alias(setup_simulation): """Instantiating the legacy ``CollisionPropertiesCfg`` name emits exactly one ``DeprecationWarning`` whose message references the 5.0 removal target.""" with warnings.catch_warnings(record=True) as caught: warnings.simplefilter("always") PhysxCollisionPropertiesCfgAlias() deprecations = [w for w in caught if issubclass(w.category, DeprecationWarning)] assert len(deprecations) == 1, f"expected exactly one DeprecationWarning, got {len(deprecations)}" assert "5.0" in str(deprecations[0].message) @pytest.mark.isaacsim_ci def test_articulation_root_base_cfg_writes_articulation_enabled(setup_simulation): """Setting ``articulation_enabled`` on the base ``ArticulationRootBaseCfg`` must author ``physxArticulation:articulationEnabled`` AND apply ``PhysxArticulationAPI``. The PhysX namespace is honored at sim time by PhysX and as a spawn-time guard by the IL Newton wrapper.""" sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() base_cfg = schemas.ArticulationRootBaseCfg(articulation_enabled=False) sim_utils.create_prim("/World/arti_ae", prim_type="Xform") schemas.define_articulation_root_properties("/World/arti_ae", base_cfg) prim = stage.GetPrimAtPath("/World/arti_ae") assert prim.GetAttribute("physxArticulation:articulationEnabled").Get() is False applied = prim.GetAppliedSchemas() assert "PhysxArticulationAPI" in applied, ( f"PhysxArticulationAPI must be applied when articulation_enabled is set; got {list(applied)}" ) @pytest.mark.isaacsim_ci def test_articulation_root_base_no_physx_schema_when_only_fix_root_link_set(setup_simulation): """Regression: setting only ``fix_root_link`` on ``ArticulationRootBaseCfg`` must NOT cause ``PhysxArticulationAPI`` to be applied. ``fix_root_link`` is a writer-side flag materializing ``UsdPhysics.FixedJoint``; it does not author any PhysX-namespaced attribute. Newton-targeted prims that only set ``fix_root_link`` should not receive ``PhysxArticulationAPI`` stamping.""" sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() base_cfg = schemas.ArticulationRootBaseCfg(fix_root_link=False) sim_utils.create_prim("/World/arti_frl", prim_type="Xform") schemas.define_articulation_root_properties("/World/arti_frl", base_cfg) prim = stage.GetPrimAtPath("/World/arti_frl") applied = prim.GetAppliedSchemas() assert "PhysxArticulationAPI" not in applied, ( f"PhysxArticulationAPI should not be applied when only fix_root_link is set; got {list(applied)}" ) @pytest.mark.isaacsim_ci def test_physx_articulation_root_writes_self_collisions(setup_simulation): """Setting ``enabled_self_collisions`` on ``PhysxArticulationRootPropertiesCfg`` must author ``physxArticulation:enabledSelfCollisions`` AND apply ``PhysxArticulationAPI``.""" sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() cfg = PhysxArticulationRootPropertiesCfg(enabled_self_collisions=True) sim_utils.create_prim("/World/arti_sc", prim_type="Xform") schemas.define_articulation_root_properties("/World/arti_sc", cfg) prim = stage.GetPrimAtPath("/World/arti_sc") assert prim.GetAttribute("physxArticulation:enabledSelfCollisions").Get() is True applied = prim.GetAppliedSchemas() assert "PhysxArticulationAPI" in applied @pytest.mark.isaacsim_ci def test_articulation_root_deprecation_alias(setup_simulation): """Instantiating the legacy ``ArticulationRootPropertiesCfg`` name emits exactly one ``DeprecationWarning`` whose message references the 5.0 removal target.""" with warnings.catch_warnings(record=True) as caught: warnings.simplefilter("always") ArticulationRootDeprecatedAliasCfg() deprecations = [w for w in caught if issubclass(w.category, DeprecationWarning)] assert len(deprecations) == 1, f"expected exactly one DeprecationWarning, got {len(deprecations)}" assert "5.0" in str(deprecations[0].message) @pytest.mark.isaacsim_ci def test_mesh_collision_base_cfg_writes_approximation_token(setup_simulation): """``MeshCollisionBaseCfg(mesh_approximation_name="boundingCube")`` authors ``physics:approximation`` via ``UsdPhysics.MeshCollisionAPI``. No PhysX cooking schema is applied because the base class declares no PhysX namespace.""" from pxr import UsdGeom sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() UsdGeom.Mesh.Define(stage, "/World/mesh_base") cfg = schemas.MeshCollisionBaseCfg(mesh_approximation_name="boundingCube") schemas.define_mesh_collision_properties("/World/mesh_base", cfg) prim = stage.GetPrimAtPath("/World/mesh_base") assert prim.GetAttribute("physics:approximation").Get() == "boundingCube" applied = prim.GetAppliedSchemas() # The standard UsdPhysics.MeshCollisionAPI is registered under # ``PhysicsMeshCollisionAPI`` in the prim's applied-schema list. assert any("MeshCollisionAPI" in s for s in applied), ( f"a MeshCollisionAPI schema must be applied; got {list(applied)}" ) # no PhysX cooking schema applied for the base class assert not any(s.startswith("Physx") and "Mesh" in s for s in applied), ( f"no PhysX mesh schema should be applied for the base class; got {list(applied)}" ) @pytest.mark.isaacsim_ci def test_physx_convex_hull_writes_tuning_attrs(setup_simulation): """Setting tuning fields on ``PhysxConvexHullPropertiesCfg`` authors the ``physxConvexHullCollision:*`` namespaced attributes AND applies ``PhysxConvexHullCollisionAPI``.""" from isaaclab_physx.sim.schemas import PhysxConvexHullPropertiesCfg from pxr import UsdGeom sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() UsdGeom.Mesh.Define(stage, "/World/mesh_ch") cfg = PhysxConvexHullPropertiesCfg(hull_vertex_limit=64, min_thickness=0.001) schemas.define_mesh_collision_properties("/World/mesh_ch", cfg) prim = stage.GetPrimAtPath("/World/mesh_ch") assert prim.GetAttribute("physics:approximation").Get() == "convexHull" assert prim.GetAttribute("physxConvexHullCollision:hullVertexLimit").Get() == 64 assert prim.GetAttribute("physxConvexHullCollision:minThickness").Get() == pytest.approx(0.001) applied = prim.GetAppliedSchemas() assert "PhysxConvexHullCollisionAPI" in applied @pytest.mark.isaacsim_ci def test_physx_convex_hull_no_physx_schema_when_no_tuning_fields_set(setup_simulation): """Regression: ``PhysxConvexHullPropertiesCfg()`` with all tuning fields None must NOT apply ``PhysxConvexHullCollisionAPI``. The approximation token is still authored on the standard ``UsdPhysics.MeshCollisionAPI``.""" from isaaclab_physx.sim.schemas import PhysxConvexHullPropertiesCfg from pxr import UsdGeom sim, _, _, _, _, _ = setup_simulation stage = sim_utils.get_current_stage() UsdGeom.Mesh.Define(stage, "/World/mesh_ch_default") cfg = PhysxConvexHullPropertiesCfg() schemas.define_mesh_collision_properties("/World/mesh_ch_default", cfg) prim = stage.GetPrimAtPath("/World/mesh_ch_default") assert prim.GetAttribute("physics:approximation").Get() == "convexHull" applied = prim.GetAppliedSchemas() assert "PhysxConvexHullCollisionAPI" not in applied, ( f"PhysxConvexHullCollisionAPI should not be applied without tuning fields; got {list(applied)}" ) @pytest.mark.isaacsim_ci def test_bounding_cube_default_token(setup_simulation): """``BoundingCubePropertiesCfg()`` defaults to the ``boundingCube`` token.""" cfg = schemas.BoundingCubePropertiesCfg() assert cfg.mesh_approximation_name == "boundingCube" @pytest.mark.isaacsim_ci @pytest.mark.parametrize( "name", [ "MeshCollisionPropertiesCfg", "ConvexHullPropertiesCfg", "ConvexDecompositionPropertiesCfg", "TriangleMeshPropertiesCfg", "TriangleMeshSimplificationPropertiesCfg", "SDFMeshPropertiesCfg", ], ) def test_mesh_collision_deprecation_aliases(setup_simulation, name): """Each legacy mesh-collision class name emits exactly one DeprecationWarning on instantiation and the warning message references the 5.0 removal target.""" from isaaclab_physx.sim.schemas import schemas_cfg as physx_cfg cls = getattr(physx_cfg, name) with warnings.catch_warnings(record=True) as caught: warnings.simplefilter("always") cls() deprecations = [w for w in caught if issubclass(w.category, DeprecationWarning)] assert len(deprecations) == 1, f"{name}: expected one DeprecationWarning, got {len(deprecations)}" assert "5.0" in str(deprecations[0].message) @pytest.mark.isaacsim_ci def test_physx_fixed_tendon_relocation(setup_simulation): """``PhysxFixedTendonPropertiesCfg`` is importable from :mod:`isaaclab_physx.sim.schemas` and round-trips its fields.""" from isaaclab_physx.sim.schemas import PhysxFixedTendonPropertiesCfg cfg = PhysxFixedTendonPropertiesCfg( tendon_enabled=True, stiffness=10.0, damping=0.5, limit_stiffness=1.0, offset=0.1, rest_length=0.2, ) assert cfg.tendon_enabled is True assert cfg.stiffness == 10.0 assert cfg.damping == 0.5 assert cfg.limit_stiffness == 1.0 assert cfg.offset == 0.1 assert cfg.rest_length == 0.2 @pytest.mark.isaacsim_ci def test_fixed_tendon_deprecation_alias(setup_simulation): """Instantiating the legacy ``FixedTendonPropertiesCfg`` (via the shim) emits exactly one ``DeprecationWarning`` whose message references the 5.0 removal target.""" cls = schemas.FixedTendonPropertiesCfg with warnings.catch_warnings(record=True) as caught: warnings.simplefilter("always") cls() deprecations = [w for w in caught if issubclass(w.category, DeprecationWarning)] assert len(deprecations) == 1, f"expected one DeprecationWarning, got {len(deprecations)}" assert "5.0" in str(deprecations[0].message) @pytest.mark.isaacsim_ci def test_physx_spatial_tendon_relocation(setup_simulation): """``PhysxSpatialTendonPropertiesCfg`` is importable from :mod:`isaaclab_physx.sim.schemas` and round-trips its fields.""" from isaaclab_physx.sim.schemas import PhysxSpatialTendonPropertiesCfg cfg = PhysxSpatialTendonPropertiesCfg( tendon_enabled=True, stiffness=20.0, damping=0.25, limit_stiffness=2.0, offset=0.05, ) assert cfg.tendon_enabled is True assert cfg.stiffness == 20.0 assert cfg.damping == 0.25 assert cfg.limit_stiffness == 2.0 assert cfg.offset == 0.05 @pytest.mark.isaacsim_ci def test_spatial_tendon_deprecation_alias(setup_simulation): """Instantiating the legacy ``SpatialTendonPropertiesCfg`` (via the shim) emits exactly one ``DeprecationWarning`` whose message references the 5.0 removal target.""" cls = schemas.SpatialTendonPropertiesCfg with warnings.catch_warnings(record=True) as caught: warnings.simplefilter("always") cls() deprecations = [w for w in caught if issubclass(w.category, DeprecationWarning)] assert len(deprecations) == 1, f"expected one DeprecationWarning, got {len(deprecations)}" assert "5.0" in str(deprecations[0].message) @pytest.mark.isaacsim_ci def test_usd_api_physx_api_attrs_deprecated(setup_simulation): """Reading ``cfg.usd_api`` and ``cfg.physx_api`` on the new mesh cfgs emits a DeprecationWarning and returns the legacy-mapped string value.""" from isaaclab_physx.sim.schemas import PhysxConvexHullPropertiesCfg cfg = PhysxConvexHullPropertiesCfg() with warnings.catch_warnings(record=True) as caught: warnings.simplefilter("always") usd_api_value = cfg.usd_api assert any(issubclass(w.category, DeprecationWarning) for w in caught) assert usd_api_value == "MeshCollisionAPI" with warnings.catch_warnings(record=True) as caught: warnings.simplefilter("always") physx_api_value = cfg.physx_api assert any(issubclass(w.category, DeprecationWarning) for w in caught) assert physx_api_value == "PhysxConvexHullCollisionAPI" @pytest.mark.isaacsim_ci def test_modify_properties_on_invalid_prim(setup_simulation): """Test modifying properties on a prim that does not exist.""" sim, _, rigid_cfg, _, _, _ = setup_simulation # set properties with pytest.raises(ValueError): schemas.modify_rigid_body_properties("/World/asset_xyz", rigid_cfg) @pytest.mark.isaacsim_ci def test_modify_properties_on_articulation_instanced_usd(setup_simulation): """Test modifying properties on articulation instanced usd. In this case, modifying collision properties on the articulation instanced usd will fail. """ sim, arti_cfg, rigid_cfg, collision_cfg, mass_cfg, joint_cfg = setup_simulation # spawn asset to the stage asset_usd_file = f"{ISAAC_NUCLEUS_DIR}/Robots/ANYbotics/anymal_c/anymal_c.usd" if "4.5" in ISAAC_NUCLEUS_DIR: asset_usd_file = asset_usd_file.replace("http", "https").replace("4.5", "5.0") sim_utils.create_prim("/World/asset_instanced", usd_path=asset_usd_file, translation=(0.0, 0.0, 0.62)) # set properties on the asset and check all properties are set schemas.modify_articulation_root_properties("/World/asset_instanced", arti_cfg) schemas.modify_rigid_body_properties("/World/asset_instanced", rigid_cfg) schemas.modify_mass_properties("/World/asset_instanced", mass_cfg) schemas.modify_joint_drive_properties("/World/asset_instanced", joint_cfg) # validate the properties _validate_articulation_properties_on_prim("/World/asset_instanced/base", arti_cfg, False) _validate_rigid_body_properties_on_prim("/World/asset_instanced", rigid_cfg) _validate_mass_properties_on_prim("/World/asset_instanced", mass_cfg) _validate_joint_drive_properties_on_prim("/World/asset_instanced", joint_cfg) # make a fixed joint arti_cfg.fix_root_link = True schemas.modify_articulation_root_properties("/World/asset_instanced", arti_cfg) @pytest.mark.isaacsim_ci def test_modify_properties_on_articulation_usd(setup_simulation): """Test setting properties on articulation usd.""" sim, arti_cfg, rigid_cfg, collision_cfg, mass_cfg, joint_cfg = setup_simulation # spawn asset to the stage asset_usd_file = f"{ISAAC_NUCLEUS_DIR}/Robots/FrankaRobotics/FrankaPanda/franka.usd" if "4.5" in ISAAC_NUCLEUS_DIR: asset_usd_file = asset_usd_file.replace("http", "https").replace("4.5", "5.0") sim_utils.create_prim("/World/asset", usd_path=asset_usd_file, translation=(0.0, 0.0, 0.62)) # set properties on the asset and check all properties are set schemas.modify_articulation_root_properties("/World/asset", arti_cfg) schemas.modify_rigid_body_properties("/World/asset", rigid_cfg) schemas.modify_collision_properties("/World/asset", collision_cfg) schemas.modify_mass_properties("/World/asset", mass_cfg) schemas.modify_joint_drive_properties("/World/asset", joint_cfg) # validate the properties _validate_articulation_properties_on_prim("/World/asset", arti_cfg, True) _validate_rigid_body_properties_on_prim("/World/asset", rigid_cfg) _validate_collision_properties_on_prim("/World/asset", collision_cfg) _validate_mass_properties_on_prim("/World/asset", mass_cfg) _validate_joint_drive_properties_on_prim("/World/asset", joint_cfg) # make a fixed joint arti_cfg.fix_root_link = True schemas.modify_articulation_root_properties("/World/asset", arti_cfg) # validate the properties _validate_articulation_properties_on_prim("/World/asset", arti_cfg, True) @pytest.mark.isaacsim_ci def test_defining_rigid_body_properties_on_prim(setup_simulation): """Test defining rigid body properties on a prim.""" sim, _, rigid_cfg, collision_cfg, mass_cfg, _ = setup_simulation # create a prim sim_utils.create_prim("/World/parent", prim_type="XForm") # spawn a prim sim_utils.create_prim("/World/cube1", prim_type="Cube", translation=(0.0, 0.0, 0.62)) # set properties on the asset and check all properties are set schemas.define_rigid_body_properties("/World/cube1", rigid_cfg) schemas.define_collision_properties("/World/cube1", collision_cfg) schemas.define_mass_properties("/World/cube1", mass_cfg) # validate the properties _validate_rigid_body_properties_on_prim("/World/cube1", rigid_cfg) _validate_collision_properties_on_prim("/World/cube1", collision_cfg) _validate_mass_properties_on_prim("/World/cube1", mass_cfg) # spawn another prim sim_utils.create_prim("/World/cube2", prim_type="Cube", translation=(1.0, 1.0, 0.62)) # set properties on the asset and check all properties are set schemas.define_rigid_body_properties("/World/cube2", rigid_cfg) schemas.define_collision_properties("/World/cube2", collision_cfg) # validate the properties _validate_rigid_body_properties_on_prim("/World/cube2", rigid_cfg) _validate_collision_properties_on_prim("/World/cube2", collision_cfg) # check if we can play sim.reset() for _ in range(100): sim.step() @pytest.mark.isaacsim_ci def test_defining_articulation_properties_on_prim(setup_simulation): """Test defining articulation properties on a prim.""" sim, arti_cfg, rigid_cfg, collision_cfg, mass_cfg, _ = setup_simulation # create a parent articulation sim_utils.create_prim("/World/parent", prim_type="Xform") schemas.define_articulation_root_properties("/World/parent", arti_cfg) # validate the properties _validate_articulation_properties_on_prim("/World/parent", arti_cfg, False) # create a child articulation sim_utils.create_prim("/World/parent/child", prim_type="Cube", translation=(0.0, 0.0, 0.62)) schemas.define_rigid_body_properties("/World/parent/child", rigid_cfg) schemas.define_mass_properties("/World/parent/child", mass_cfg) # check if we can play sim.reset() for _ in range(100): sim.step() @pytest.mark.isaacsim_ci def test_multi_instance_schema_detection_on_tendon_joints(setup_simulation): """Test that multi-instance PhysX tendon schemas are correctly detected via substring matching. Multi-instance schemas (e.g. PhysxTendonAxisAPI, PhysxTendonAxisRootAPI) appear in GetAppliedSchemas() as 'SchemaName:instanceName' (e.g. 'PhysxTendonAxisAPI:inst0'). An exact ``in list`` check fails because 'PhysxTendonAxisAPI' != 'PhysxTendonAxisAPI:inst0'. This test ensures the substring-based detection used by modify_joint_drive_properties and modify_fixed_tendon_properties handles multi-instance schemas correctly. We call the unwrapped functions directly (via ``__wrapped__``) to bypass the ``@apply_nested`` decorator, which traverses children and does not return the inner function's bool result. """ sim, _, _, _, _, joint_cfg = setup_simulation stage = sim_utils.get_current_stage() # unwrap to get the raw functions that return bool _modify_joint_drive = schemas.modify_joint_drive_properties.__wrapped__ _modify_fixed_tendon = schemas.modify_fixed_tendon_properties.__wrapped__ # -- set up two body prims connected by a revolute joint sim_utils.create_prim("/World/tendon_test", prim_type="Xform") sim_utils.create_prim("/World/tendon_test/body0", prim_type="Cube") sim_utils.create_prim("/World/tendon_test/body1", prim_type="Cube") joint = UsdPhysics.RevoluteJoint.Define(stage, "/World/tendon_test/body1/joint0") joint_prim = joint.GetPrim() # -- 1) Joint with only tendon child schema (no root) -> drive should be SKIPPED joint_prim.AddAppliedSchema("PhysxTendonAxisAPI:inst0") applied = joint_prim.GetAppliedSchemas() assert any("PhysxTendonAxisAPI" in s for s in applied), "Multi-instance schema not found via substring" assert "PhysxTendonAxisAPI" not in applied, "Exact match should NOT find multi-instance schema" result = _modify_joint_drive(joint_prim.GetPrimPath().pathString, joint_cfg) assert result is False, "Tendon child joint should be skipped (return False)" # -- 2) Joint with both child AND root tendon schema -> drive should NOT be skipped joint_prim.AddAppliedSchema("PhysxTendonAxisRootAPI:inst0") applied = joint_prim.GetAppliedSchemas() assert any("PhysxTendonAxisRootAPI" in s for s in applied) assert "PhysxTendonAxisRootAPI" not in applied, "Exact match should NOT find multi-instance schema" result = _modify_joint_drive(joint_prim.GetPrimPath().pathString, joint_cfg) assert result is True, "Tendon root joint should NOT be skipped" # -- 3) modify_fixed_tendon_properties should detect multi-instance root schema tendon_cfg = schemas.FixedTendonPropertiesCfg(stiffness=10.0, damping=0.1) result = _modify_fixed_tendon(joint_prim.GetPrimPath().pathString, tendon_cfg) assert result is True, "Prim with PhysxTendonAxisRootAPI:inst0 should be detected" # -- 4) Prim WITHOUT any tendon root schema -> modify_fixed_tendon should return False sim_utils.create_prim("/World/tendon_test/body2", prim_type="Cube") no_tendon_joint = UsdPhysics.RevoluteJoint.Define(stage, "/World/tendon_test/body2/joint1") result = _modify_fixed_tendon(no_tendon_joint.GetPrim().GetPrimPath().pathString, tendon_cfg) assert result is False, "Prim without tendon root schema should return False" """ Helper functions. """ def _validate_articulation_properties_on_prim( prim_path: str, arti_cfg, has_default_fixed_root: bool, verbose: bool = False ): """Validate the articulation properties on the prim. If :attr:`has_default_fixed_root` is True, then the asset already has a fixed root link. This is used to check the expected behavior of the fixed root link configuration. """ # Obtain stage handle stage = sim_utils.get_current_stage() # the root prim root_prim = stage.GetPrimAtPath(prim_path) # check articulation properties are set correctly for attr_name, attr_value in arti_cfg.__dict__.items(): # skip class metadata and names we know are not present if attr_name.startswith("_") or attr_name == "func": continue # handle fixed root link if attr_name == "fix_root_link" and attr_value is not None: # obtain the fixed joint prim fixed_joint_prim = sim_utils.find_global_fixed_joint_prim(prim_path) # if asset does not have a fixed root link then check if the joint is created if not has_default_fixed_root: if attr_value: assert fixed_joint_prim is not None else: assert fixed_joint_prim is None else: # check a joint exists assert fixed_joint_prim is not None # check if the joint is enabled or disabled is_enabled = fixed_joint_prim.GetJointEnabledAttr().Get() assert is_enabled == attr_value # skip the rest of the checks continue # convert attribute name in prim to cfg name prim_prop_name = f"physxArticulation:{to_camel_case(attr_name, to='cC')}" # validate the values assert root_prim.GetAttribute(prim_prop_name).Get() == pytest.approx(attr_value, abs=1e-5), ( f"Failed setting for {prim_prop_name}" ) def _validate_rigid_body_properties_on_prim(prim_path: str, rigid_cfg, verbose: bool = False): """Validate the rigid body properties on the prim. Note: Right now this function exploits the hierarchy in the asset to check the properties. This is not a fool-proof way of checking the properties. """ # Obtain stage handle stage = sim_utils.get_current_stage() # the root prim root_prim = stage.GetPrimAtPath(prim_path) # check rigid body properties are set correctly for link_prim in root_prim.GetChildren(): if UsdPhysics.RigidBodyAPI(link_prim): for attr_name, attr_value in rigid_cfg.__dict__.items(): # skip class metadata and names we know are not present if attr_name.startswith("_") or attr_name in [ "func", "rigid_body_enabled", "kinematic_enabled", ]: continue # convert attribute name in prim to cfg name prim_prop_name = f"physxRigidBody:{to_camel_case(attr_name, to='cC')}" # validate the values assert link_prim.GetAttribute(prim_prop_name).Get() == pytest.approx(attr_value, abs=1e-5), ( f"Failed setting for {prim_prop_name}" ) elif verbose: print(f"Skipping prim {link_prim.GetPrimPath()} as it is not a rigid body.") def _validate_collision_properties_on_prim(prim_path: str, collision_cfg, verbose: bool = False): """Validate the collision properties on the prim. Note: Right now this function exploits the hierarchy in the asset to check the properties. This is not a fool-proof way of checking the properties. """ # Obtain stage handle stage = sim_utils.get_current_stage() # the root prim root_prim = stage.GetPrimAtPath(prim_path) # check collision properties are set correctly for link_prim in root_prim.GetChildren(): for mesh_prim in link_prim.GetChildren(): if UsdPhysics.CollisionAPI(mesh_prim): for attr_name, attr_value in collision_cfg.__dict__.items(): # skip names we know are not present and class-metadata keys if attr_name.startswith("_") or attr_name in ["func", "collision_enabled"]: continue # convert attribute name in prim to cfg name prim_prop_name = f"physxCollision:{to_camel_case(attr_name, to='cC')}" # validate the values assert mesh_prim.GetAttribute(prim_prop_name).Get() == pytest.approx(attr_value, abs=1e-5), ( f"Failed setting for {prim_prop_name}" ) elif verbose: print(f"Skipping prim {mesh_prim.GetPrimPath()} as it is not a collision mesh.") def _validate_mass_properties_on_prim(prim_path: str, mass_cfg, verbose: bool = False): """Validate the mass properties on the prim. Note: Right now this function exploits the hierarchy in the asset to check the properties. This is not a fool-proof way of checking the properties. """ # Obtain stage handle stage = sim_utils.get_current_stage() # the root prim root_prim = stage.GetPrimAtPath(prim_path) # check rigid body mass properties are set correctly for link_prim in root_prim.GetChildren(): if UsdPhysics.MassAPI(link_prim): for attr_name, attr_value in mass_cfg.__dict__.items(): # skip names we know are not present and class-metadata keys if attr_name in ["func"] or attr_name.startswith("_"): continue # print(link_prim.GetProperties()) prim_prop_name = f"physics:{to_camel_case(attr_name, to='cC')}" # validate the values assert link_prim.GetAttribute(prim_prop_name).Get() == pytest.approx(attr_value, abs=1e-5), ( f"Failed setting for {prim_prop_name}" ) elif verbose: print(f"Skipping prim {link_prim.GetPrimPath()} as it is not a mass api.") def _validate_joint_drive_properties_on_prim(prim_path: str, joint_cfg, verbose: bool = False): """Validate the mass properties on the prim. Note: Right now this function exploits the hierarchy in the asset to check the properties. This is not a fool-proof way of checking the properties. """ # Obtain stage handle stage = sim_utils.get_current_stage() # the root prim root_prim = stage.GetPrimAtPath(prim_path) # check joint drive properties are set correctly for link_prim in root_prim.GetAllChildren(): for joint_prim in link_prim.GetChildren(): if joint_prim.IsA(UsdPhysics.PrismaticJoint) or joint_prim.IsA(UsdPhysics.RevoluteJoint): # check it has drive API assert joint_prim.HasAPI(UsdPhysics.DriveAPI) # iterate over the joint properties for attr_name, attr_value in joint_cfg.__dict__.items(): # skip class metadata and names we know are not present on the USD prim if attr_name.startswith("_") or attr_name in ["func", "ensure_drives_exist"]: continue # resolve the drive (linear or angular) drive_model = "linear" if joint_prim.IsA(UsdPhysics.PrismaticJoint) else "angular" # manually check joint type since it is a string type if attr_name == "drive_type": prim_attr_name = f"drive:{drive_model}:physics:type" # check the value assert attr_value == joint_prim.GetAttribute(prim_attr_name).Get() continue # non-string attributes if attr_name == "max_joint_velocity": prim_attr_name = "physxJoint:maxJointVelocity" else: prim_attr_name = f"drive:{drive_model}:physics:{to_camel_case(attr_name, to='cC')}" # obtain value from USD API (for angular, these follow degrees unit) prim_attr_value = joint_prim.GetAttribute(prim_attr_name).Get() # for angular drives, we expect user to set in radians # the values reported by USD are in degrees if drive_model == "angular": if attr_name == "max_joint_velocity": # deg / s --> rad / s prim_attr_value = prim_attr_value * math.pi / 180.0 elif attr_name in ["stiffness", "damping"]: # N-m/deg or N-m-s/deg --> N-m/rad or N-m-s/rad prim_attr_value = prim_attr_value * 180.0 / math.pi # validate the values assert prim_attr_value == pytest.approx(attr_value, abs=1e-5), ( f"Failed setting for {prim_attr_name}" ) elif verbose: print(f"Skipping prim {joint_prim.GetPrimPath()} as it is not a joint drive api.")