Merge branch 'main' into cable-com-origin

Author: jumyungc

CHANGELOG.md

@@ -4,7 +4,9 @@
 
 ### Added
 
+- Add `newton.use_coord_layout_targets` opt-in flag exposing `Model.joint_target_q` / `Control.joint_target_q` shaped `(joint_coord_count,)` (matching `joint_q`) and `joint_target_qd` shaped `(joint_dof_count,)` (matching `joint_qd`); solvers, the actuator library, and `ModelBuilder.finalize()` honor the flag. Defaults to `False` for backwards compatibility; will flip in a future release.
 - Add opt-in `validate_mesh` parameter to `ModelBuilder.add_cloth_mesh()`, `ModelBuilder.add_soft_mesh()`, and `style3d.add_cloth_mesh()` that warns on degenerate geometry; add public `newton.utils.validate_triangle_mesh()` and `newton.utils.validate_tet_mesh()` utilities
+- Warn from `SolverMuJoCo` when a `JointType.FREE` joint has a non-world parent; MuJoCo requires free joints to attach directly to the world.
 - Document loop closure in the articulations concept page, covering the omit-from-`add_articulation` pattern and USD `excludeFromArticulation` with per-solver caveats
 - Add `ViewerGL.show_loading_splash()` / `ViewerGL.hide_loading_splash()` displaying a stylized Newton's-cradle overlay while the GL viewer waits on Warp kernel compilation; raised automatically by `newton.examples.init()` for visible GL viewers
 - Add `viewer.set_picking_linear_only_bodies()` and `viewer.clear_picking_linear_only_bodies()` to mark bodies that should receive only the linear component of mouse-picking force, suppressing offset-induced torque. Selected cable examples use this for capsule bodies to avoid torque-induced instability while preserving linear dragging.
@@ -20,15 +22,19 @@
 - Parse URDF `<material>` colors (inline `<color rgba>` and named material references) during import and apply them to `ModelBuilder.shape_color` for all shape types
 - Add robotics tutorial notebook covering ModelBuilder, solvers, CUDA graphs, IK, and pick-and-place
 - Add `newton.utils.OnnxRuntime`, a graph-capturable ONNX inference engine backed solely by Warp kernels (no `onnxruntime` or `torch` runtime dependency); used by `ControllerNeuralMLP` and `ControllerNeuralLSTM` to load `.onnx` policies. To migrate a TorchScript policy, run `torch.onnx.export(model, dummy_input, "policy.onnx", opset_version=17)` once and point the controllers at the resulting `.onnx` file. The `onnx` package is now an optional extra (`pip install newton[onnx]`); install it explicitly to use the ONNX runtime.
+- Add opt-in `collapse_massless_fixed_root` to URDF and MJCF importers to collapse massless fixed-root chains for maximal-coordinate solvers while preserving topology by default
 - Add USD parsing for `NewtonSiteAPI` to mark shapes as sites.
 - Add `ViewerRTX`, a real-time ray-traced viewer powered by NVIDIA OVRTX.
+- Add functional `newton.intersect_ray()` shape query helper for composing custom raycast sensors
 - Support negative (mirrored) scale on mesh, convex hull, and SDF shapes, so a single `Mesh` instance can be shared across shapes with different signed scales without re-baking
 - Add `newton.utils.ColorSpace`, `color_srgb_to_linear()`, `color_linear_to_srgb()`, and `SensorTiledCamera.RenderConfig.output_color_space` for color-space boundaries
 - Add USD parsing for `NewtonMassAPI`: shell mass model (`newton:massModel`), shell thickness (`newton:shellThickness`), and compact inertia tensor (`newton:inertia`)
+- Add USD parsing for contact response attributes (`ke`, `kd`, `kf`, `ka`) from `NewtonMaterialAPI` on bound materials
 
 ### Changed
 
 - Assign one default visual color to capsule segments generated by `ModelBuilder.add_rod()` or `add_rod_graph()`; pass `color=` to choose an explicit cable color.
+- `GeoType.HFIELD` shapes now use a `wp.Mesh` BVH for raycasting (built during `ModelBuilder.finalize()`), replacing the per-thread DDA grid traversal; the raycast kernel signature no longer accepts `shape_heightfield_index`, `heightfield_data`, or `heightfield_elevations` — those arrays are still present on `Model` for collision kernels
 - `ModelBuilder.finalize()` no longer writes the deferred mesh SDF back to `Mesh.sdf` on shared `Mesh` instances. The SDF data is retained on the finalized `Model` (`model.shape_sdf_index`, `model.texture_sdf_data`). Call `Mesh.build_sdf()` directly when you want the SDF stored on a `Mesh`.
 - `ModelBuilder.add_shape_convex_hull()` (and any path producing `GeoType.CONVEX_MESH`) now raises `ValueError` if `ShapeConfig.sdf_*` or `ShapeConfig.is_hydroelastic` are set, matching `add_shape_mesh()`. Build and attach the SDF on the underlying `Mesh` via `Mesh.build_sdf()` instead.
 - Treat `NewtonSDFCollisionAPI` and `NewtonMeshCollisionAPI` as independent collision representations in the USD importer. Co-applying both APIs on the same prim emits a warning and SDF configuration is used. `physics:approximation` (inherited from `PhysicsMeshCollisionAPI`) is ignored on SDF prims with a warning. `ModelBuilder.approximate_meshes()` raises `ValueError` for mesh-replacing methods (`convex_hull`, `coacd`, `vhacd`, `bounding_box`, `bounding_sphere`) when a target shape carries deferred SDF configuration or the `HYDROELASTIC` flag.
@@ -42,22 +48,27 @@
 - Normalize negative scale components to `abs()` in `ModelBuilder.add_shape*` for symmetric primitives (sphere, box, capsule, cylinder, ellipsoid, plane, gaussian); these shapes are point-symmetric so sign flips produce identical geometry. If you relied on a negative scale to flip such a shape, apply the mirror through the shape's transform (`xform`) instead.
 - Reject negative scale components on `ModelBuilder.add_shape_cone()` and heightfield shapes (previously silently accepted, produced invalid geometry). To mirror a cone, apply the flip through the shape's `xform`; to mirror a heightfield, pre-mirror the source height data and pass a positive scale.
 - Change `SensorTiledCamera` default packed `color` and `albedo` outputs to sRGB-encoded bytes so authored display colors render at the expected display brightness; pass `RenderConfig(output_color_space=ColorSpace.LINEAR)` to preserve the previous linear-byte behavior.
-- Bump `newton-usd-schemas` to `>=0.3.0`
+- Bump `newton-usd-schemas` to `>=0.3.1`
 
 ### Deprecated
 
 - Deprecate omitting `body_frame_origin` in `ModelBuilder.add_rod()` and `ModelBuilder.add_rod_graph()`; the implicit behavior still uses the existing start-node body-frame convention during the deprecation window, but the implicit default will change to `body_frame_origin="com"` in a future release. Pass `body_frame_origin="start"` to preserve the legacy frame or `body_frame_origin="com"` to opt into the future COM-centered frame.
+- Deprecate `Model.joint_target_pos` / `Control.joint_target_pos` and `Model.joint_target_vel` / `Control.joint_target_vel` in favor of `joint_target_q` / `joint_target_qd`. The legacy names emit a `DeprecationWarning` and raise `AttributeError` when `newton.use_coord_layout_targets = True`. Set that flag before building a model to switch `joint_target_q` to `joint_coord_count` shape (matching `joint_q`); the default `False` keeps the legacy `joint_dof_count` layout. `ModelBuilder.joint_target_pos` / `ModelBuilder.joint_target_vel` are removed — set per-axis targets via `JointDofConfig.target_pos` / `target_vel` or write directly to `ModelBuilder.joint_target_q` / `joint_target_qd`.
 - Deprecate loading `.pt` / `.pth` (TorchScript) checkpoints via `ControllerNeuralMLP`; the legacy TorchScript / dict-checkpoint path still works (with a `DeprecationWarning`) when PyTorch is installed but will be removed in a future release. `ControllerNeuralLSTM` requires re-exporting to ONNX with the metadata properties documented in its class docstring; pointing it at a `.pt` checkpoint now raises `NotImplementedError` with migration guidance. Convert the MLP checkpoint to ONNX once with `torch.onnx.export(model, dummy_input, "policy.onnx", opset_version=17)` and load the resulting `.onnx` file.
 - Deprecate implicit positive Dahl defaults in `SolverVBD.register_custom_attributes()`. Pass `dahl_defaults_enabled=False` and explicitly author positive `model.vbd.dahl_eps_max` and `model.vbd.dahl_tau` values when Dahl cable friction is desired, instead of relying on registered default values.
+- Deprecate `newton:contact_ke`/`newton:contact_kd`/`newton:contact_kf`/`newton:contact_ka` custom attributes on shape prims; author `newton:contactStiffness`/`newton:contactDamping`/`newton:contactFrictionGain`/`newton:contactAdhesion` on the bound `NewtonMaterialAPI` material instead
+- Deprecate `mjc:solref` on material prims for contact stiffness/damping; author `newton:contactStiffness`/`newton:contactDamping` on the bound `NewtonMaterialAPI` material, or use per-shape `mjc:solref` (`MjcGeomAPI`) which is unchanged
 
 ### Removed
 
+- Remove `SensorRaycast` (deprecated in 1.2); use `SensorTiledCamera` with `SensorTiledCamera.utils.compute_pinhole_camera_rays()` and `create_depth_image_output()` instead
 - Remove `SensorContact.net_force` (deprecated in 1.1.0); use `SensorContact.total_force` and `SensorContact.force_matrix` instead
 - Remove `include_total` parameter from `SensorContact` (deprecated in 1.1.0); use `measure_total` instead
 - Remove `SensorContact.sensing_objs` (deprecated in 1.1.0); use `SensorContact.sensing_obj_idx` and `SensorContact.sensing_obj_type` instead
 - Remove `SensorContact.counterparts` and `SensorContact.reading_indices` (deprecated in 1.1.0); use `SensorContact.counterpart_indices` and `SensorContact.counterpart_type` instead
 - Remove `SensorContact.shape` (deprecated in 1.1.0); use `total_force.shape` / `force_matrix.shape` instead
 - Remove `SensorContact.ObjectType` enum (deprecated in 1.1.0); use the `sensing_obj_type` and `counterpart_type` attributes instead
+- Remove `raycast_kernel_no_hfield`; use `raycast_kernel` instead
 
 ### Fixed
 
@@ -218,6 +229,7 @@
 - Fix MJCF importer creating finite planes from MuJoCo visual half-sizes instead of infinite planes
 - Honor authored `mujoco.solreflimit_mode` even when a non-zero `mujoco.solreflimit` is also present, so the explicit mode (force-space or raw) is authoritative
 - Fix `SolverMuJoCo` CPU backend overwriting `mj_model.body_iquat` with Newton's eigendecomposition result on every `BODY_INERTIAL_PROPERTIES` notify; the compiled principal-axes basis is now preserved, fixing single-contact box equilibrium (incorrect normal force) and stiff WELD-loop instabilities (`Nan, Inf or huge value in QACC`) caused by basis ambiguity on repeated eigenvalues
+- Fix `SolverMuJoCo` honoring force-space `shape_material_ke` / `shape_material_kd` for contacts (`use_mujoco_contacts=False`); authored `mjc:solref` is preserved via new `mujoco.solref` / `mujoco.solref_mode` per-shape custom attributes. Force-space scaling is unsupported on `use_mujoco_contacts=True` and the MuJoCo CPU backend.
 - Fix USD custom-frequency parsing to respect `ModelBuilder.add_usd(root_path=...)`, avoiding rows from sibling subtrees
 - Fix USD import of joint limit stiffness/damping from `MjcJointAPI`: `SchemaResolverMjc` now reads the schema-correct `mjc:solreflimit` attribute instead of the generic `mjc:solref`, which was never authored on joints
 - Fix MJCF importer in `compiler.angle="degree"` mode: (1) stop multiplying joint `damping`/`stiffness` by `180/π` (MuJoCo stores these in `N·m·s/rad` and `N·m/rad` regardless of `angle`); (2) stop `deg2rad`-scaling the default `±MAXVAL` sentinel for joints without an explicit `range=`, which was turning unlimited hinges into bounded joints with `~1.75e8 rad` range

asv/benchmarks/benchmark_mujoco.py

@@ -23,6 +23,21 @@
 from newton.sensors import SensorContact
 from newton.utils import EventTracer
 
+_NEW_LAYOUT_AVAILABLE = hasattr(newton, "use_coord_layout_targets")
+
+
+def _target_q(obj):
+    """Resolve the joint-position-target array across pre/post #2556 layouts.
+
+    On pre-PR Newton (no ``joint_target_q``) falls back to ``joint_target_pos``.
+    Used by the benchmark harness so ``asv compare`` works against both refs.
+    """
+    target = getattr(obj, "joint_target_q", None)
+    if target is None:
+        target = getattr(obj, "joint_target_pos", None)
+    return target
+
+
 ROBOT_CONFIGS = {
     "humanoid": {
         "solver": "newton",
@@ -241,7 +256,11 @@ def _setup_allegro(articulation_builder):
     for i in range(articulation_builder.joint_dof_count):
         articulation_builder.joint_target_ke[i] = 150
         articulation_builder.joint_target_kd[i] = 5
-        articulation_builder.joint_target_pos[i] = 0.0
+    if _NEW_LAYOUT_AVAILABLE:
+        articulation_builder.joint_target_q[:] = articulation_builder.joint_q
+    else:
+        for i in range(articulation_builder.joint_dof_count):
+            articulation_builder.joint_target_pos[i] = 0.0
     root_dofs = 1
 
     return root_dofs
@@ -289,6 +308,8 @@ def __init__(
         ls_parallel=None,
         cone=None,
     ):
+        if _NEW_LAYOUT_AVAILABLE:
+            newton.use_coord_layout_targets = True
         fps = 600
         self.sim_time = 0.0
         self.benchmark_time = 0.0
@@ -340,6 +361,17 @@ def __init__(
         self.state_0, self.state_1 = self.model.state(), self.model.state()
         newton.eval_fk(self.model, self.model.joint_q, self.model.joint_qd, self.state_0)
 
+        self._quat_target_q_offsets: list[int] = []
+        target_q = _target_q(self.model)
+        if target_q is not None and target_q.shape[0] == self.model.joint_coord_count:
+            joint_types = self.model.joint_type.numpy()
+            q_starts = self.model.joint_q_start.numpy()
+            for j, jt in enumerate(joint_types):
+                if jt == int(newton.JointType.BALL):
+                    self._quat_target_q_offsets.append(int(q_starts[j]))
+                elif jt in (int(newton.JointType.FREE), int(newton.JointType.DISTANCE)):
+                    self._quat_target_q_offsets.append(int(q_starts[j]) + 3)
+
         self.sensor_contact = None
         sensing_bodies = ROBOT_CONFIGS.get(robot, {}).get("sensing_bodies", None)
         if sensing_bodies is not None:
@@ -373,8 +405,13 @@ def simulate(self):
 
     def step(self):
         if self.actuation == "random":
-            joint_target = wp.array(self.rng.uniform(-1.0, 1.0, size=self.model.joint_dof_count), dtype=wp.float32)
-            wp.copy(self.control.joint_target_pos, joint_target)
+            target_q = _target_q(self.control)
+            target_size = target_q.shape[0]
+            samples = self.rng.uniform(-1.0, 1.0, size=target_size).astype(np.float32)
+            for offset in self._quat_target_q_offsets:
+                samples[offset : offset + 4] = (0.0, 0.0, 0.0, 1.0)
+            joint_target = wp.array(samples, dtype=wp.float32)
+            wp.copy(target_q, joint_target)
 
         wp.synchronize_device()
         start_time = time.time()

asv/benchmarks/simulation/bench_mujoco.py

@@ -14,8 +14,9 @@
 parent_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
 sys.path.append(parent_dir)
 
-from benchmark_mujoco import Example
+from benchmark_mujoco import Example, _target_q
 
+import newton
 from newton.utils import EventTracer
 
 
@@ -26,6 +27,33 @@ def apply_random_control(state: wp.uint32, joint_target: wp.array[float]):
     joint_target[tid] = wp.randf(state) * 2.0 - 1.0
 
 
+@wp.kernel
+def restore_target_quat_identity(joint_target: wp.array[float], quat_offsets: wp.array[int]):
+    i = wp.tid()
+    o = quat_offsets[i]
+    joint_target[o + 0] = 0.0
+    joint_target[o + 1] = 0.0
+    joint_target[o + 2] = 0.0
+    joint_target[o + 3] = 1.0
+
+
+def _free_ball_quat_offsets(model) -> list[int]:
+    """Coord-space indices of the quaternion slot of every FREE/BALL/DISTANCE
+    joint in ``model.joint_target_q`` (empty under the legacy DOF layout)."""
+    offsets: list[int] = []
+    target_q = _target_q(model)
+    if target_q is None or target_q.shape[0] != model.joint_coord_count:
+        return offsets
+    joint_types = model.joint_type.numpy()
+    q_starts = model.joint_q_start.numpy()
+    for j, jt in enumerate(joint_types):
+        if jt == int(newton.JointType.BALL):
+            offsets.append(int(q_starts[j]))
+        elif jt in (int(newton.JointType.FREE), int(newton.JointType.DISTANCE)):
+            offsets.append(int(q_starts[j]) + 3)
+    return offsets
+
+
 class _FastBenchmark:
     """Utility base class for fast benchmarks."""
 
@@ -63,15 +91,25 @@ def setup(self):
             raise SkipNotImplemented
         else:
             state = wp.rand_init(self.example.seed)
+            target_q = _target_q(self.example.control)
+            quat_offsets = _free_ball_quat_offsets(self.example.model)
+            quat_offsets_wp = wp.array(quat_offsets, dtype=int, device=target_q.device) if quat_offsets else None
             with wp.ScopedCapture() as capture:
                 wp.launch(
                     apply_random_control,
-                    dim=(self.example.model.joint_dof_count,),
+                    dim=(target_q.shape[0],),
                     inputs=[state],
-                    outputs=[self.example.control.joint_target_pos],
+                    outputs=[target_q],
                 )
+                if quat_offsets_wp is not None:
+                    wp.launch(
+                        restore_target_quat_identity,
+                        dim=(quat_offsets_wp.shape[0],),
+                        inputs=[target_q, quat_offsets_wp],
+                    )
                 self.example.simulate()
             self.graph = capture.graph
+            self._quat_offsets_wp = quat_offsets_wp
 
         wp.synchronize_device()
 

docs/api/newton.rst

@@ -71,6 +71,7 @@ newton
    eval_ik
    eval_jacobian
    eval_mass_matrix
+   intersect_ray
 
 .. rubric:: Constants
 
@@ -83,3 +84,5 @@ newton
      - ``10000000000.0``
    * - ``__version__``
      - ``1.3.0.dev0``
+   * - ``use_coord_layout_targets``
+     - ``False``

docs/api/newton_sensors.rst

@@ -16,5 +16,4 @@ newton.sensors
    SensorContact
    SensorFrameTransform
    SensorIMU
-   SensorRaycast
    SensorTiledCamera