Fix hull inertia winding and floor, and the movable_joints cycle (discussion #2)

README.md

@@ -166,6 +166,9 @@ In a file with joints, the loader raises any part's inertia below 1e-4 kg·m² t
 than the source says, and it no longer shakes or goes NaN. Set `jointed_part_inertia_floor` to change the value. Files
 with one rigid body use 1e-6 kg·m² (`inertia_floor`).
 
+A part with a mass but no inertia in the file gets its inertia from its hulls, scaled to that mass. This applies to
+2,026 parts.
+
 43 files across the categories were simulated at 60 fps with 8 substeps. 42 of them were compared with their SimReady USD:
 
 | Check | Result |
@@ -227,6 +230,12 @@ Two joints in the USD are left out because they hold nothing: the fixed joint of
 
 ## Changelog
 
+- 2026-11-03: Fixed the loader's inertia for parts with no inertia in the file. qhull does not orient its hull
+  triangles, so Newton's signed-volume integral cancelled most of the volume and the median part was 63 times off on
+  one axis (reported by jayscambler in discussion #2). Triangles of these hulls now face outward; collision-only hulls
+  are unchanged. These parts now also get the inertia floor, and flat parts with no hull volume (29 buttons and
+  hinges) keep the file's mass instead of ending with zero mass and inertia. `checks.movable_joints` no longer recurses forever on the loop-closing joints of
+  `instrument_adams_pliers_b01`. The GLB files do not change.
 - 2026-11-01: Added collision hulls that keep concave parts hollow, joint drives and the inertia of small parts.
   Added a loader for NVIDIA Newton. The set grows by 0.17%. Meshes, materials and textures do not change.
 - 2026-10-29: Added physics from the USD files: rigid bodies, mass, physics materials and 5,550 joints, as

newton_loader/simready_newton/checks.py

@@ -158,8 +158,11 @@ def movable_joints(model):
     for joint_index in range(model.joint_count):
         children_of_body.setdefault(int(parents[joint_index]), []).append(int(children[joint_index]))
 
-    def subtree_mass(body):
-        return float(masses[body]) + sum(subtree_mass(child) for child in children_of_body.get(body, []))
+    def subtree_mass(body, visited=frozenset()):
+        # Loop-closing joints stay in the model, so the parent-to-child map can have a cycle (adams pliers).
+        visited = visited | {body}
+        children_left = [child for child in children_of_body.get(body, []) if child not in visited]
+        return float(masses[body]) + sum(subtree_mass(child, visited) for child in children_left)
 
     gravity = 9.81
     centers = model.body_com.numpy()

newton_loader/simready_newton/loader.py

@@ -196,9 +196,17 @@ def _hull_mesh(vertices_body, compute_inertia):
     """A Newton mesh for a convex point set: triangles from qhull, so Newton gets a closed surface."""
     points = numpy.asarray(vertices_body, dtype=numpy.float64)
     try:
-        triangles = ConvexHull(points).simplices
+        hull = ConvexHull(points)
     except Exception:
-        triangles = ConvexHull(points, qhull_options="QJ").simplices
+        hull = ConvexHull(points, qhull_options="QJ")
+    triangles = hull.simplices.copy()
+    if compute_inertia:
+        # qhull does not orient its simplices, and Newton's inertia is a signed-volume integral that needs every
+        # triangle facing outward. Collision-only hulls keep qhull's order so contacts stay as released.
+        for index, (triangle, equation) in enumerate(zip(triangles, hull.equations)):
+            first, second, third = points[triangle]
+            if numpy.dot(numpy.cross(second - first, third - first), equation[:3]) < 0:
+                triangles[index] = triangle[[0, 2, 1]]
     return newton.Mesh(points.astype(numpy.float32), triangles.flatten(), compute_inertia=compute_inertia)
 
 
@@ -316,7 +324,7 @@ def add_simready_glb(
                 label=f"{loaded.name}/{glb.nodes[body_node].get('name', body_node)}",
             )
     for node_index, (mass, center) in needs_scaling.items():
-        _scale_computed_mass(builder, index_by_node[node_index], mass, center)
+        _scale_computed_mass(builder, index_by_node[node_index], mass, center, body_inertia_floor)
 
     joints = _collect_joints(glb, world_by_node, parent_by_node, body_node_set)
     bodies_by_mass = sorted(body_nodes, key=lambda node: -mass_by_node[node])
@@ -353,15 +361,19 @@ def add_simready_glb(
     return loaded
 
 
-def _scale_computed_mass(builder, body_index, mass, center):
+def _scale_computed_mass(builder, body_index, mass, center, inertia_floor):
     """Hulls gave a shape for the inertia. The file's mass and center of mass, when present, are still the truth."""
     computed_mass = builder.body_mass[body_index]
-    if mass > 0 and computed_mass > 0:
-        factor = mass / computed_mass
+    if mass > 0:
+        inertia = numpy.array(builder.body_inertia[body_index], dtype=numpy.float64).reshape(3, 3)
+        # A flat hull (a button, a decal) has no volume, so it gives no mass to scale and keeps only the floor.
+        inertia = inertia * (mass / computed_mass) if computed_mass > 0 else numpy.zeros((3, 3))
+        principal, axes = numpy.linalg.eigh(inertia)
+        inertia = axes @ numpy.diag(numpy.maximum(principal, inertia_floor)) @ axes.T
         builder.body_mass[body_index] = mass
         builder.body_inv_mass[body_index] = 1.0 / mass
-        builder.body_inertia[body_index] = builder.body_inertia[body_index] * factor
-        builder.body_inv_inertia[body_index] = builder.body_inv_inertia[body_index] * (1.0 / factor)
+        builder.body_inertia[body_index] = warp.mat33(*inertia.flatten())
+        builder.body_inv_inertia[body_index] = warp.mat33(*numpy.linalg.pinv(inertia).flatten())
     if center is not None:
         builder.body_com[body_index] = warp.vec3(*center)