Modeled and textured in Blender, then configured rigid-body physics,
joint constraints, grasp poses, and semantic metadata using the NVIDIA SimReady Add-on.

Color

Semantic Segmentation

Normal

Depth

All four sensor modalities are rendered via `newton.sensors.SensorTiledCamera`,
reading the exact same USD model instance as the physics solver.
This guarantees zero-drift alignment between semantic ground truth and kinematic states,
validating the asset's machine-readability.

Fully compliant with NVIDIA SimReady Exporter & Validator rulesets.
Guaranteeing native compatibility with Omniverse and Isaac Sim ecosystems.

NVIDIA's autochecker catches syntax and format compliance, but it can't verify physical accuracy. Even though this asset passed the official NVIDIA SimReady checker, running it in the Newton engine uncovered mesh interpenetration with inverted opening/closing as well as drawer zero-point offsets.

Finding 1 : Initial position offset of the model after importing into Newton

Before: Exporter output localPos1 = (0,0,0), causing cabinet displacement

After: localPos1 = W₁⁻¹ · (W₀ · localPos0), cabinet restored to correct position/alignment.

def align_joint_frames(stage, joints):
    
    cache = UsdGeom.XformCache()
    fixed = []

    for prim in joints:
        joint = UsdPhysics.Joint(prim)
        b0 = joint.GetBody0Rel().GetTargets() if joint.GetBody0Rel() else []
        b1 = joint.GetBody1Rel().GetTargets() if joint.GetBody1Rel() else []

        if not b1:
            continue

        child = stage.GetPrimAtPath(b1[0])
        if not (child and child.IsValid()):
            continue

        w1 = cache.GetLocalToWorldTransform(child)

        p0 = joint.GetLocalPos0Attr().Get() or Gf.Vec3f(0, 0, 0)
        r0 = joint.GetLocalRot0Attr().Get() or Gf.Quatf(1, 0, 0, 0)

        if b0:
            parent = stage.GetPrimAtPath(b0[0])
            w0 = cache.GetLocalToWorldTransform(parent)
            anchor = _frame(p0, r0) * w0
        else: 
            anchor = w1
            joint.CreateLocalPos0Attr().Set(Gf.Vec3f(*anchor.ExtractTranslation()))
            q = anchor.ExtractRotationQuat()
            joint.CreateLocalRot0Attr().Set(
                Gf.Quatf(float(q.GetReal()), Gf.Vec3f(*[float(v) for v in q.GetImaginary()])))

        local = anchor * w1.GetInverse()
        new_p = Gf.Vec3f(*local.ExtractTranslation())
        q = local.ExtractRotationQuat()
        new_r = Gf.Quatf(float(q.GetReal()),
                         Gf.Vec3f(*[float(v) for v in q.GetImaginary()]))

        old_p = joint.GetLocalPos1Attr().Get() or Gf.Vec3f(0, 0, 0)
        shift = (Gf.Vec3d(*new_p) - Gf.Vec3d(*old_p)).GetLength()
        joint.CreateLocalPos1Attr().Set(new_p)
        joint.CreateLocalRot1Attr().Set(new_r)

        if shift > 1e-6:
            fixed.append((prim.GetName(), old_p, new_p, shift))
            print(f"  {prim.GetName()}: localPos1 "
                  f"({old_p[0]:+.4f},{old_p[1]:+.4f},{old_p[2]:+.4f}) -> "
                  f"({new_p[0]:+.4f},{new_p[1]:+.4f},{new_p[2]:+.4f})   "
                  f"rest-pose error was {shift * 1000:.1f} mm")
        else:
            print(f"  {prim.GetName()}: already consistent")

    return fixed

python script for the issue

Finding 2: The drawer bounces back when pushed in, with varying severity across different engines.

Applying an 8 N push force, the drawer overshoot the 0.30 m joint limit:
by a default of 88.5 mm in MuJoCo, and 17.2 mm in Newton Featherstone.
While the limit position itself can be unified in the asset,
solver parameters vary across different engines.
Ultimately, adjusting the joint limit damping in Newton successfully mitigated the bounce-back.

Final Exported Assets

Two asset variants are generated from a single Blender file. The Generic and PhysX versions adhere to NVIDIA’s official sample dual-directory standard, with the only distinction being collision approximation (convexHull vs. sdf).

Link to download: https://drive.google.com/drive/folders/13cucqE6sKDCMZR7mZgWIhaHDkq9e2M4P?usp=sharing

02
Deformable Asset: Thin-Shell

Currently, there is no official SimReady profile for deformable assets. As a result, this asset meets the following benchmarks: a correct Initial State generated from 2D patterns instead of pre-draped meshes, effectively calibrated material parameters, and stable simulation with support for robotic grasping.

The cloth simulation result of the Blender cloth modifier on the mannequin serves as an external reference.
When fed into Newton and SolverStyle3D with identical 2D patterns and RGBench knit parameters,
the final rest states show minimal discrepancy (9 mm),
which primarily stems from differences in mesh resolution.

The knit fabric parameters (areal density: 190 g/m², stretch stiffness: 25,000 g/s², bending stiffness: 200, thickness: 0.5 mm)
were obtained from empirical fabric measurement data in RGBench (Hu et al., 2025).

The rest state is correct
(A cloth asset is only correct when its rest state is the fully unstressed one. That state is the datum the solver measures internal stress and deformation against.)

Per-triangle comparison of rest areas, after loading in Newton:
| stored rest area - 2D pattern area | = 9.1e-13 ← effectively zero; identical
| stored rest area - 3D surface area | = 2.3e-05 ← a whole triangle's worth of area

The first is at the limit of floating-point precision; the second is roughly the area of one entire triangle.
The stored rest area is therefore correct: it is taken from the 2D pattern.

SolverStyle3D

SolverVBD

To achieve more realistic cloth behavior, I initially adjusted the mesh density,
fabric thickness, and bending stiffness in Style3D.
However, after multiple iterations and failures, the fabric simulation remained unsatisfactory,
even when pushing parameters beyond the bounds supported by RGBench empirical data.
Hence, while maintaining identical assets, grasping trajectories,
and camera angles, I switched to the VBD solver.
VBD’s simulation stability, wrinkle detail, and visual realism aligned closely with expectations.
However, because the VBD API lacks `panel_verts`,
its initial state defaults to the input 3D mesh rather than the 2D pattern.
As a result, its performance does not rely on a stress-free rest state baseline.

Final Exported Assets

Link to download: https://drive.google.com/drive/folders/1w0IjEnvt8citu-n1MWq2Uri67K_0nb_A?usp=sharing

References
[1] Hu, W., Tang, X., E, Y., Li, Y., Shu, Z., Li, W., Wang, H., Yang, R. Real Garment Benchmark (RGBench): A Comprehensive Benchmark for Robotic Garment Manipulation featuring a High-Fidelity Scalable Simulator. arXiv:2511.06434, 2025. https://arxiv.org/abs/2511.06434

[2] Chen, A. H., Liu, Z., Yang, Y., Yuksel, C. Vertex Block Descent. ACM Transactions on Graphics 43(4), 2024. https://doi.org/10.1145/3658179 · arXiv:2403.06321

[3] Yu, B., Cordier, F., Seo, H. Inverse Garment and Pattern Modeling with a Differentiable Simulator. Computer Graphics Forum, 2024. https://doi.org/10.1111/cgf.15249 · arXiv:2403.06841

[4] Newton Physics. Newton: An open-source, GPU-accelerated physics simulation engine built upon NVIDIA Warp. NVIDIA / Google DeepMind / Disney Research, Linux Foundation project. https://github.com/newton-physics/newton

[5] ASTM International. ASTM D1388-14: Standard Test Method for Stiffness of Fabrics. Option A, cantilever test.

[6] NVIDIA. Omni Physics Deformable Schema. Omniverse Kit documentation. https://docs.omniverse.nvidia.com/kit/docs/omni_physics/latest/dev_guide/deformables/omniphysics_deformable_schema.html

[7] Isaac Lab. [Proposal] Add Newton deformable object API with coupled rigid-deformable simulation. Issue #5285, 2026-04-15.
[8] NVIDIA. Train a Quadruped Locomotion Policy and Simulate Cloth Manipulation with NVIDIA Isaac Lab and Newton. NVIDIA Technical Blog, 2026. https://developer.nvidia.com/blog/train-a-quadruped-locomotion-policy-and-simulate-cloth-manipulation-with-nvidia-isaac-lab-and-newton/

[9] NVIDIA. SimReady Specification. Profile :nv_core/sr_specs/docs/profiles/profiles.toml

03
Simulated Robotic Interaction

The ultimate goal of creating thess assets is to enable robot simulation training.

Have a Franka robotic arm open and close a drawer in an Isaac Sim warehouse scene.

In Newton, rewrite the grasping sequence to fold a custom T-shirt asset using a Franka robot arm. Pure friction-based grasping without attachments (neither Newton nor Isaac Sim currently supports attaching deformable bodies to articulation rigid bodies)

Thank you!