Merge branch 'main' into jumyungc/vbd-cable-isotropic-conditioning

Author: jumyungc

CHANGELOG.md

@@ -54,6 +54,7 @@
 ### Changed
 
 - Decide collider visibility from USD `purpose` and visibility rather than from a bound render material. A collider whose `purpose` resolves to `default` is viewport geometry and is drawn; mark it `guide` to state that it is collision-only. Previously an unrelated visual elsewhere in the scene could make a collider vanish. `force_show_colliders` and `hide_collision_shapes` are unchanged.
+- Require `warp-lang>=1.16.0`; upgrade Warp to version 1.16.0 or later.
 - Disable the implicit positive Dahl-friction defaults in `SolverVBD.register_custom_attributes()` (deprecated in 1.3.0): `vbd:dahl_eps_max` and `vbd:dahl_tau` now default to zero, and Dahl cable friction is enabled only where both are authored positive. Pass `dahl_defaults_enabled=True` to temporarily restore the old defaults; the compatibility mode will be removed in a future release.
 - Keep the authored render mesh when `ModelBuilder.add_usd()` approximates a collider. `physics:approximation` is scoped to collision, so a Mesh that is both render geometry and a collider now imports as an approximated collision shape plus a visual shape carrying the original topology, instead of replacing the render mesh with the approximation. This raises `Model.shape_count` for such prims: iterate on `ShapeFlags.COLLIDE_SHAPES` rather than assuming one shape per collider prim. The visual shape adds no mass and no collision, appends after the originals so existing shape indices and `path_shape_map` entries are unchanged, and is skipped when `load_visual_shapes=False`.
 - Compile tiled camera render kernels with CUDA fast math by default for faster rendering; set `SensorTiledCamera.render_config.enable_fast_math = False` for bit-exact, IEEE-precise output.
@@ -104,6 +105,7 @@
 
 ### Fixed
 
+- Fix MPR returning scale-dependent, excessively deep contacts for small convex shapes on large mesh triangles while preserving triangle-specific shared-edge manifold witnesses.
 - Make deterministic collision pipelines cover hydroelastic contact generation and reduction, including unique reduced-contact sort keys and overflow-safe fixed-point pressure accumulation.
 - Fix `SolverMuJoCo` retaining an invalid external-contact cache when its first step is captured in a CUDA graph. (#3767)
 - Convert `newton:mimicCoef0` from degrees to radians when the mimic follower joint is angular. Assets authored against the old behavior need the value rescaled to degrees.

asv.conf.json

@@ -16,7 +16,7 @@
   "build_command": ["python -m build --wheel -o {build_cache_dir} {build_dir}"],
   "install_command": [
     "in-dir={env_dir} python -m pip install {wheel_file}[dev] --extra-index-url=https://pypi.nvidia.com/",
-    "in-dir={env_dir} python -m pip install warp-lang==1.16.0.dev20260716 mujoco==3.11.0 mujoco-warp==3.11.0 --extra-index-url=https://pypi.nvidia.com/",
+    "in-dir={env_dir} python -m pip install warp-lang==1.16.0 mujoco==3.11.0 mujoco-warp==3.11.0 --extra-index-url=https://pypi.nvidia.com/",
     "python -m pip install torch==2.10.0+cu130 --index-url https://download.pytorch.org/whl/cu130"
   ]
 }

docs/guide/release.rst

@@ -78,6 +78,16 @@ Pre-release planning
      - Select release dependency versions and confirm their availability on
        public PyPI: warp-lang, mujoco, mujoco-warp, newton-usd-schemas.  Land
        release-ready versions on ``main`` before the branch cut when possible.
+   * - ☐
+     - When the stable Warp version for the upcoming Newton release is
+       published before the branch cut, stabilize it on ``main``: replace the
+       dev or RC requirement in ``pyproject.toml`` and the pin in
+       ``asv.conf.json`` with the stable version and regenerate ``uv.lock``.
+       Keep both the NVIDIA ``warp-lang`` package-index override and the ASV
+       ``--extra-index-url=https://pypi.nvidia.com/`` option on ``main`` so it
+       is ready for the next dev-nightly update.  Cut the upcoming release
+       branch after this change; do not apply the new Warp minor version to
+       previously released Newton branches.
    * - ☐
      - Set timeline: code freeze → RC1 → testing window → GA.
    * - ☐

newton/_src/geometry/mpr.py

@@ -230,33 +230,53 @@ def geometric_center(
             center_b_local = 0.5 * (min_b + max_b)
 
         center_b_world = position_b + wp.quat_rotate(orientation_b, center_b_local)
+        center_b_to_a = center_a - center_b_world
 
         if geom_a.shape_type == int(GeoTypeEx.TRIANGLE) or geom_a.shape_type == int(GeoTypeEx.TRIANGLE_PRISM):
-            # Project shape B's center onto the triangle for a starting
-            # point near the contact region — this dramatically improves
-            # MPR convergence for large triangles.
-            #
-            # Blend 1% toward the centroid so the point is strictly in the
-            # face interior.  This does NOT prevent an MPR degeneracy (MPR
-            # works fine from an edge point); it improves *manifold quality*.
-            # When shape B projects onto a shared mesh edge, both adjacent
-            # triangles get the same v0, producing MPR witness points biased
-            # toward the edge.  The manifold builder (multicontact.py) uses
-            # these witness points as its center for perturbed support
-            # mapping, so edge-biased centers cause overlapping contact
-            # polygons across the two triangles instead of distinct ones —
-            # resulting in asymmetric force distribution and spurious torque.
-            # The 1% nudge gives each triangle a unique v0 pulled toward its
-            # own interior, yielding well-separated manifold centers.
+            # Start near the local contact region.  A small centroid bias keeps
+            # adjacent triangles' manifold witnesses distinct at a shared
+            # edge, but bound it by the normal center-to-plane distance so a
+            # large face cannot turn the initial MPR ray nearly tangential.
             tri_a = wp.vec3(0.0, 0.0, 0.0)
             tri_b = geom_a.scale
             tri_c = geom_a.auxiliary
+            face_normal = wp.cross(tri_b - tri_a, tri_c - tri_a)
+            face_normal_length_sq = wp.length_sq(face_normal)
             proj = closest_point_on_triangle(center_b_world, tri_a, tri_b, tri_c)
-            centroid = (tri_a + tri_b + tri_c) / 3.0
-            center_a = proj + 0.01 * (centroid - proj)
+
+            if face_normal_length_sq >= 1.0e-20:
+                face_normal_length = wp.sqrt(face_normal_length_sq)
+                face_normal_unit = face_normal / face_normal_length
+                signed_plane_distance = wp.dot(center_b_world - tri_a, face_normal_unit)
+                plane_proj = center_b_world - signed_plane_distance * face_normal_unit
+
+                # Reconstruct face-region offsets directly.  Subtracting two
+                # large, nearby positions can otherwise leave a spurious
+                # tangential component in the initial MPR ray.
+                inside_face = (
+                    wp.dot(wp.cross(tri_b - tri_a, plane_proj - tri_a), face_normal) >= 0.0
+                    and wp.dot(wp.cross(tri_c - tri_b, plane_proj - tri_b), face_normal) >= 0.0
+                    and wp.dot(wp.cross(tri_a - tri_c, plane_proj - tri_c), face_normal) >= 0.0
+                )
+                if inside_face:
+                    proj = plane_proj
+                    center_b_to_a = -signed_plane_distance * face_normal_unit
+                else:
+                    center_b_to_a = proj - center_b_world
+
+                centroid = (tri_a + tri_b + tri_c) / 3.0
+                to_centroid = centroid - proj
+                to_centroid -= wp.dot(to_centroid, face_normal_unit) * face_normal_unit
+                distance_to_centroid = wp.length(to_centroid)
+                if distance_to_centroid > 1.0e-12:
+                    nudge_distance = 0.01 * wp.min(distance_to_centroid, wp.abs(signed_plane_distance))
+                    center_b_to_a += to_centroid * (nudge_distance / distance_to_centroid)
+
+            else:
+                center_b_to_a = proj - center_b_world
 
         center.B = center_b_world
-        center.BtoA = center_a - center_b_world
+        center.BtoA = center_b_to_a
 
         return center
 
@@ -335,20 +355,44 @@ def solve_mpr_core(
 
         normal = v0.BtoA
         if wp.length_sq(normal) < NUMERIC_EPSILON:
-            # Centers coincide — probe three orthogonal directions and
-            # pick the one with the largest Minkowski support, giving
-            # MPR the most room to find a valid portal.
-            best_dot = float(-1.0e30)
-            best_dir = wp.vec3(1.0, 0.0, 0.0)
-            for axis_idx in range(3):
-                probe = wp.vec3(0.0, 0.0, 0.0)
-                probe[axis_idx] = 1.0
-                sv = minkowski_support(geom_a, geom_b, probe, orientation_b, position_b, extend, data_provider)
-                d = wp.dot(sv.BtoA, probe)
-                if d > best_dot:
-                    best_dot = d
-                    best_dir = probe
-            v0.BtoA = best_dir * 1e-05
+            used_triangle_fallback = bool(False)
+            if geom_a.shape_type == int(GeoTypeEx.TRIANGLE) or geom_a.shape_type == int(GeoTypeEx.TRIANGLE_PRISM):
+                tri_a = wp.vec3(0.0, 0.0, 0.0)
+                tri_b = geom_a.scale
+                tri_c = geom_a.auxiliary
+                face_normal = wp.cross(tri_b - tri_a, tri_c - tri_a)
+                face_normal_length_sq = wp.length_sq(face_normal)
+                if face_normal_length_sq >= 1.0e-20:
+                    face_normal = face_normal / wp.sqrt(face_normal_length_sq)
+                    proj = closest_point_on_triangle(v0.B, tri_a, tri_b, tri_c)
+                    centroid = (tri_a + tri_b + tri_c) / 3.0
+                    to_centroid = centroid - proj
+                    to_centroid -= wp.dot(to_centroid, face_normal) * face_normal
+                    to_centroid_length_sq = wp.length_sq(to_centroid)
+
+                    # Use the face normal for coincident triangle/convex
+                    # centers, retaining a small triangle-specific bias.
+                    fallback_dir = -face_normal
+                    if wp.dot(v0.B - proj, face_normal) < 0.0:
+                        fallback_dir = face_normal
+                    if to_centroid_length_sq > 1.0e-20:
+                        fallback_dir += 0.01 * to_centroid / wp.sqrt(to_centroid_length_sq)
+                    v0.BtoA = wp.normalize(fallback_dir) * 1.0e-5
+                    used_triangle_fallback = True
+
+            if not used_triangle_fallback:
+                # Probe three axes and use the direction with most support.
+                best_dot = float(-1.0e30)
+                best_dir = wp.vec3(1.0, 0.0, 0.0)
+                for axis_idx in range(3):
+                    probe = wp.vec3(0.0, 0.0, 0.0)
+                    probe[axis_idx] = 1.0
+                    sv = minkowski_support(geom_a, geom_b, probe, orientation_b, position_b, extend, data_provider)
+                    d = wp.dot(sv.BtoA, probe)
+                    if d > best_dot:
+                        best_dot = d
+                        best_dir = probe
+                v0.BtoA = best_dir * 1e-05
 
         normal = -v0.BtoA