Physics materials embedded in rigid-object USDs are created per environment with replicate_physics=True (64K PhysX material limit)

[sri299792458]

Is it expected that, with replicate_physics=True, a physics material authored inside a standalone rigid body USD is created once per environment, while the same material inside an articulation is created once and shared from env_0?

We hit this when running 32,768 environments in one process with two objects per environment whose USD binds its own physics material to the collider:

[Error] [omni.physx.plugin] PhysX error: PxPhysics::createMaterial: limit of 64K materials reached., FILE /builds/omniverse/physics/physx/source/physx/src/NpPhysics.cpp, LINE 637

After this error sim.reset() stalls instead of raising.

The material PhysX assigned to the same collider in different environments, read back with omni.physx.get_physxunittests_interface().get_materials_paths(collider) (4 environments), and the result at 32,768 environments with two cubes each:

Case	env_0	env_1	env_3	32,768 envs
Material embedded in a rigid body, replicate_physics=True	env_0/CubeA/PhysicsMaterial	env_1/CubeA/PhysicsMaterial	env_3/CubeA/PhysicsMaterial	material limit error
Same, with PhysicsArticulationRootAPI on the body (one-body articulation)	env_0/CubeA/PhysicsMaterial	env_0/CubeA/PhysicsMaterial	env_0/CubeA/PhysicsMaterial	OK
Same articulation, replicate_physics=False	env_0/...	env_1/...	env_3/...	material limit error
No embedded material; colliders bound to one material at /World/Materials/Shared	/World/Materials/Shared	/World/Materials/Shared	/World/Materials/Shared	OK

Where the material sits in the asset (inside or outside the rigid-body prim) and whether it is bound with the physics purpose or the all-purpose binding make no difference; only articulation vs. rigid body and replicate_physics change the result. #930 and #941 report the same error, but caused by per-shape material randomization (solved by the bucketing in randomize_rigid_body_material); no randomization is involved here.

If this is expected:

1. Could it be documented, for example next to the 64K-material note in randomize_rigid_body_material?
2. Is there a recommended way to give USD-file assets a shared physics material? MeshCfg and ShapeCfg accept an absolute physics_material_path, but UsdFileCfg has no equivalent. Binding the colliders to one material under /World/Materials (last row) works.

Reproduction

The script below generates its own 6 cm cube USD:

./isaaclab.sh -p material_replication_repro.py --headless --case embedded                  # material limit error
./isaaclab.sh -p material_replication_repro.py --headless --case global                    # OK
./isaaclab.sh -p material_replication_repro.py --headless --case articulation              # OK
./isaaclab.sh -p material_replication_repro.py --headless --case articulation_noreplicate  # material limit error
# add "--num_envs 4 --probe" to print the material assigned in env_0 / env_1 / env_N-1

material_replication_repro.py

"""Minimal reproduction: physics materials embedded in a standalone rigid body USD are created once PER ENVIRONMENT under
replicate_physics=True, while the same material inside an articulation is shared from env_0.

Each environment holds two copies of a 6 cm cube (a standalone rigid body) generated by this script. Cases:
  embedded                  cube USD contains its own physics material (bound to its collider); replicate_physics=True
  global                    cube USD has no material; every collider is bound to ONE material at /World/Materials/Shared
  articulation              as 'embedded', plus PhysicsArticulationRootAPI on the cube (one-body articulation)
  articulation_noreplicate  as 'articulation', with replicate_physics=False
With --probe, prints which material PhysX assigned to the first cube's collider in envs 0, 1 and N-1
(omni.physx unit-test interface get_materials_paths).
"""
import argparse
import os
import tempfile

from isaaclab.app import AppLauncher

parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("--case", required=True, choices=["embedded", "global", "articulation", "articulation_noreplicate"])
parser.add_argument("--num_envs", type=int, default=32768)
parser.add_argument("--probe", action="store_true")
AppLauncher.add_app_launcher_args(parser)
args = parser.parse_args()
app = AppLauncher(args).app

import omni.physx
from pxr import Gf, Sdf, Usd, UsdGeom, UsdPhysics, UsdShade

import isaaclab.sim as sim_utils
from isaaclab.assets import AssetBaseCfg
from isaaclab.scene import InteractiveScene, InteractiveSceneCfg
from isaaclab.utils import configclass


def make_cube_usd(path: str, embedded_material: bool, articulation_root: bool) -> None:
    stage = Usd.Stage.CreateNew(path)
    UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
    UsdGeom.SetStageMetersPerUnit(stage, 1.0)
    body = UsdGeom.Xform.Define(stage, "/Cube").GetPrim()
    stage.SetDefaultPrim(body)
    UsdPhysics.RigidBodyAPI.Apply(body)
    UsdPhysics.MassAPI.Apply(body).CreateMassAttr(0.1)
    if articulation_root:
        UsdPhysics.ArticulationRootAPI.Apply(body)
    collider = UsdGeom.Cube.Define(stage, "/Cube/collider")
    collider.CreateSizeAttr(0.06)
    UsdPhysics.CollisionAPI.Apply(collider.GetPrim())
    if embedded_material:
        material = UsdShade.Material.Define(stage, "/Cube/PhysicsMaterial")
        material_api = UsdPhysics.MaterialAPI.Apply(material.GetPrim())
        material_api.CreateStaticFrictionAttr(1.0)
        material_api.CreateDynamicFrictionAttr(0.9)
        UsdShade.MaterialBindingAPI.Apply(collider.GetPrim()).Bind(material, materialPurpose="physics")
    stage.GetRootLayer().Save()


asset_dir = tempfile.mkdtemp(prefix="material_repro_")
cube_usd = os.path.join(asset_dir, "cube.usda")
make_cube_usd(cube_usd, embedded_material=args.case != "global", articulation_root=args.case.startswith("articulation"))


@configclass
class SceneCfg(InteractiveSceneCfg):
    ground = AssetBaseCfg(prim_path="/World/ground", spawn=sim_utils.GroundPlaneCfg())
    cube_a = AssetBaseCfg(prim_path="{ENV_REGEX_NS}/CubeA", spawn=sim_utils.UsdFileCfg(usd_path=cube_usd),
                          init_state=AssetBaseCfg.InitialStateCfg(pos=(0.0, 0.0, 0.03)))
    cube_b = AssetBaseCfg(prim_path="{ENV_REGEX_NS}/CubeB", spawn=sim_utils.UsdFileCfg(usd_path=cube_usd),
                          init_state=AssetBaseCfg.InitialStateCfg(pos=(0.2, 0.0, 0.03)))


sim = sim_utils.SimulationContext(sim_utils.SimulationCfg(dt=1 / 120, device=args.device))
scene = InteractiveScene(SceneCfg(num_envs=args.num_envs, env_spacing=1.5,
                                  replicate_physics=args.case != "articulation_noreplicate"))
stage = sim.stage
if args.case == "global":
    # one material outside /World/envs, bound to every environment's colliders (plain Usd/UsdShade calls, no Sdf.ChangeBlock)
    shared = UsdShade.Material.Define(stage, "/World/Materials/Shared")
    shared_api = UsdPhysics.MaterialAPI.Apply(shared.GetPrim())
    shared_api.CreateStaticFrictionAttr(1.0)
    shared_api.CreateDynamicFrictionAttr(0.9)
    for env in stage.GetPrimAtPath("/World/envs").GetChildren():
        for name in ("CubeA", "CubeB"):
            UsdShade.MaterialBindingAPI.Apply(stage.GetPrimAtPath(f"{env.GetPath()}/{name}/collider")).Bind(
                shared, materialPurpose="physics")
print(f"[repro] case={args.case} num_envs={args.num_envs} cubes_per_env=2 -> calling sim.reset()", flush=True)
sim.reset()
for _ in range(10):
    sim.step()
print(f"[repro] case={args.case}: sim.reset() and 10 steps completed", flush=True)
if args.probe:
    tests = omni.physx.get_physxunittests_interface()
    for env_id in (0, 1, args.num_envs - 1):
        collider = f"/World/envs/env_{env_id}/CubeA/collider"
        print(f"[repro] {collider} -> {[str(p) for p in tests.get_materials_paths(collider)]}", flush=True)
app.close()

Versions

• Isaac Lab Version: main @ 3e73d6d (isaaclab 0.54.3); the replicate_physics path in interactive_scene.py is unchanged on current main
• Isaac Sim Version: 5.1.0 (pip)
• GPU: NVIDIA RTX A6000, driver 550.54.15
• OS: Ubuntu 22.04

[Wahaj18]

Yes — with replicate_physics=True, that split is expected for how PhysX materials get registered today.

replicate_physics=True tells the cloner/physics parser that every env is a copy of env_0, so articulations (and their physics materials) can be shared from the template. A standalone rigid body whose USD carries its own PhysicsMaterial still ends up as a distinct material prim per env (env_N/.../PhysicsMaterial). At 32 768 envs × 2 cubes you are already past PhysX’s hard cap of 64 000 unique materials, which is the same limit called out next to randomize_rigid_body_material’s num_buckets note in Isaac Lab. After that error, sim.reset() stalling instead of raising is ugly, but it matches what others hit in #930 / #941 once the material table is exhausted.

Your four cases line up with that:

Setup	What PhysX sees
Embedded material on a plain rigid USD, replicate_physics=True	One new material per env → blows the 64K cap at large num_envs
Same asset with PhysicsArticulationRootAPI, replicate_physics=True	Shared from env_0 → OK
Articulation, replicate_physics=False	Per-env materials again → same cap
Colliders bound to one material under /World/Materials/...	Single shared material → OK

Recommended pattern for USD-file assets

Until UsdFileCfg grows something like MeshCfg.physics_material_path, keep one physics material outside the env namespace and bind the colliders to it (your last row). That is the approach that scales with replicate_physics=True. Alternatives that also work:

1. Author the asset without an embedded physics material, then bind /World/Materials/Shared after spawn (as in your repro’s global case).
2. If you need the body for cloning tricks, the one-body articulation root trick you found is a valid way to opt into the shared-material path — a bit awkward as a general API, but it explains why that row stayed under the limit.
3. For domain randomization, keep using randomize_rigid_body_material with a small num_buckets so you never mint one material per shape × env.

Documenting this next to the existing 64K note (and calling out that embedded materials in rigid UsdFileCfg assets are not shared under replicate_physics=True) would save the next person a long weekend. I think a short note under multi-asset / replicate_physics plus a one-liner on UsdFileCfg (“no physics_material_path; bind a shared material under /World”) would be enough.