Remove redundant wp.static wrappers and fix a uint32 overflow (#3657)

Author: shi-eric

CHANGELOG.md

@@ -104,7 +104,7 @@
 - Report malformed MJCF free-joint and inertial inputs with deterministic validation errors, and ignore MJCF mesh geom `size` lengths consistently.
 - Fix MJCF imports ignoring material and inline RGBA colors on primitive geoms.
 - Fix Style3D solver divergence caused by isolated vertices.
-- Fix compiler warnings about overflowing int32 constants when compiling SDF texture and `SensorTiledCamera` render kernels.
+- Fix compiler warnings about overflowing int32 constants when compiling SDF texture and `SensorTiledCamera` kernels.
 - Fix USD site import to discover sites beneath non-visual containers, collider prims, and instanceable rigid-body prims independently of `load_visual_shapes`; the reworked traversal also speeds up import of scenes with many nested `Xform` or instance prims.
 - Fix `SolverFeatherstone` BALL joints to apply passive `joint_damping` on all three angular DOFs.
 - Fix excessive memory usage when importing MJCF or URDF models containing many visual-only shapes with self-collisions disabled.

newton/_src/geometry/sdf_hydroelastic.py

@@ -171,7 +171,7 @@ def mc_calc_face_texture(
         p_0 = wp.vec3f(corner_offsets_table[v_idx_from])
         p_1 = wp.vec3f(corner_offsets_table[v_idx_to])
         val_diff = wp.float32(val_1 - val_0)
-        if wp.abs(val_diff) < wp.static(MC_EDGE_VAL_DIFF_EPS):
+        if wp.abs(val_diff) < MC_EDGE_VAL_DIFF_EPS:
             t = float(0.5)
         else:
             # Clamp t away from cube corners to prevent vertex collapse when
@@ -194,7 +194,7 @@ def mc_calc_face_texture(
 
     n = wp.cross(face_verts[1] - face_verts[0], face_verts[2] - face_verts[0])
     n_sq = wp.dot(n, n)
-    if n_sq < wp.static(MC_DEGENERATE_N_SQ_EPS):
+    if n_sq < MC_DEGENERATE_N_SQ_EPS:
         # Degenerate triangle — return zero area with a valid (non-NaN) normal.
         area = 0.0
         normal = wp.vec3(0.0, 0.0, 1.0)

newton/_src/geometry/sdf_mc.py

@@ -195,14 +195,14 @@ def mc_calc_face(
         p_0 = wp.vec3f(corner_offsets_table[v_idx_from])
         p_1 = wp.vec3f(corner_offsets_table[v_idx_to])
         val_diff = wp.float32(val_1 - val_0)
-        if wp.abs(val_diff) < wp.static(MC_EDGE_VAL_DIFF_EPS):
+        if wp.abs(val_diff) < MC_EDGE_VAL_DIFF_EPS:
             p = 0.5 * (p_0 + p_1)
         else:
             # Clamp t away from cube corners to prevent vertex collapse when
             # corner values are near zero (e.g. at SDF ridge boundaries).
             # Without the clamp, t close to 0 or 1 places multiple vertices
             # at the same corner, producing degenerate (zero-area) triangles.
-            t = wp.clamp((isovalue - val_0) / val_diff, wp.static(MC_EDGE_CLAMP_MIN), wp.static(MC_EDGE_CLAMP_MAX))
+            t = wp.clamp((isovalue - val_0) / val_diff, MC_EDGE_CLAMP_MIN, MC_EDGE_CLAMP_MAX)
             p = p_0 + t * (p_1 - p_0)
         vol_idx = p + int_to_vec3f(x_id, y_id, z_id)
         p_scaled = wp.volume_index_to_world(sdf_a, vol_idx)
@@ -216,7 +216,7 @@ def mc_calc_face(
 
     n = wp.cross(face_verts[1] - face_verts[0], face_verts[2] - face_verts[0])
     n_sq = wp.dot(n, n)
-    if n_sq < wp.static(MC_DEGENERATE_N_SQ_EPS):
+    if n_sq < MC_DEGENERATE_N_SQ_EPS:
         # Degenerate triangle — return zero area with a valid (non-NaN) normal.
         area = 0.0
         normal = wp.vec3(0.0, 0.0, 1.0)

newton/_src/geometry/sdf_texture.py

@@ -856,7 +856,7 @@ def _read_cell_corners(
     ty = loc.ty
     tz = loc.tz
 
-    if loc.start_slot >= wp.static(SLOT_LINEAR):
+    if loc.start_slot >= SLOT_LINEAR:
         cx = float(loc.x_base)
         cy = float(loc.y_base)
         cz = float(loc.z_base)
@@ -951,7 +951,7 @@ def texture_sample_sdf_at_voxel(
 
     start_slot = sdf.subgrid_start_slots[x_base, y_base, z_base]
 
-    if start_slot < wp.static(SLOT_LINEAR):
+    if start_slot < SLOT_LINEAR:
         block_x = float(start_slot & wp.uint32(0x3FF))
         block_y = float((start_slot >> wp.uint32(10)) & wp.uint32(0x3FF))
         block_z = float((start_slot >> wp.uint32(20)) & wp.uint32(0x3FF))
@@ -1023,7 +1023,7 @@ def texture_sample_sdf(
     ty = loc.ty
     tz = loc.tz
 
-    if loc.start_slot >= wp.static(SLOT_LINEAR):
+    if loc.start_slot >= SLOT_LINEAR:
         cx = float(loc.x_base)
         cy = float(loc.y_base)
         cz = float(loc.z_base)
@@ -1107,7 +1107,7 @@ def texture_sample_sdf_hw(
 
     sdf_val = float(0.0)
 
-    if loc.start_slot >= wp.static(SLOT_LINEAR):
+    if loc.start_slot >= SLOT_LINEAR:
         # ``cx + tx + 0.5`` lands at the centre of voxel (cx, cy, cz) and
         # ``+tx`` walks toward (cx+1, ...). The HW filter returns the
         # interpolated value in one fetch.
@@ -2526,10 +2526,10 @@ def _generate_isomesh_texture_kernel(
             p_0 = wp.vec3f(corner_offsets_table[v_from])
             p_1 = wp.vec3f(corner_offsets_table[v_to])
             val_diff = val_1 - val_0
-            if wp.abs(val_diff) < wp.static(MC_EDGE_VAL_DIFF_EPS):
+            if wp.abs(val_diff) < MC_EDGE_VAL_DIFF_EPS:
                 p = 0.5 * (p_0 + p_1)
             else:
-                t = wp.clamp((isovalue - val_0) / val_diff, wp.static(MC_EDGE_CLAMP_MIN), wp.static(MC_EDGE_CLAMP_MAX))
+                t = wp.clamp((isovalue - val_0) / val_diff, MC_EDGE_CLAMP_MIN, MC_EDGE_CLAMP_MAX)
                 p = p_0 + t * (p_1 - p_0)
             vol_idx = p + wp.vec3(float(x_id), float(y_id), float(z_id))
             local_pos = sdf.sdf_box_lower + wp.cw_mul(vol_idx, sdf.voxel_size)

newton/_src/geometry/sdf_utils.py

@@ -1521,10 +1521,10 @@ def _generate_dense_mc_kernel(
             p_0 = wp.vec3f(corner_offsets_table[ev[0]])
             p_1 = wp.vec3f(corner_offsets_table[ev[1]])
             val_diff = val_1 - val_0
-            if wp.abs(val_diff) < wp.static(MC_EDGE_VAL_DIFF_EPS):
+            if wp.abs(val_diff) < MC_EDGE_VAL_DIFF_EPS:
                 p = 0.5 * (p_0 + p_1)
             else:
-                t = wp.clamp((0.0 - val_0) / val_diff, wp.static(MC_EDGE_CLAMP_MIN), wp.static(MC_EDGE_CLAMP_MAX))
+                t = wp.clamp((0.0 - val_0) / val_diff, MC_EDGE_CLAMP_MIN, MC_EDGE_CLAMP_MAX)
                 p = p_0 + t * (p_1 - p_0)
             local = base + p
             face_verts[vi] = wp.vec3(
@@ -1534,7 +1534,7 @@ def _generate_dense_mc_kernel(
             )
         n = wp.cross(face_verts[1] - face_verts[0], face_verts[2] - face_verts[0])
         n_sq = wp.dot(n, n)
-        if n_sq < wp.static(MC_DEGENERATE_N_SQ_EPS):
+        if n_sq < MC_DEGENERATE_N_SQ_EPS:
             normal = wp.vec3(0.0, 0.0, 1.0)
         else:
             normal = n / wp.sqrt(n_sq)

newton/_src/sensors/warp_raytrace/utils.py

@@ -18,6 +18,10 @@
 if TYPE_CHECKING:
     from .render_context import RenderContext
 
+# Knuth multiplicative hash constant (2^32 / golden ratio).
+# Typed uint32 so kernel codegen doesn't overflow an int32 constant.
+HASH_MULTIPLIER = wp.uint32(2654435761)
+
 
 def _resolve_fisheye_image_size(
     axis: str,
@@ -225,7 +229,7 @@ def unpack_shape_index_hash_to_rgba_kernel(
     # Knuth multiplicative hash, masked to 24 bits. ``idx + 1`` keeps shape 0
     # away from the all-zero hash that collides with the miss color; the
     # miss sentinel ``0xFFFFFFFF`` wraps back to 0 and intentionally renders black.
-    h = ((idx + wp.uint32(1)) * wp.uint32(2654435761)) & wp.uint32(0xFFFFFF)
+    h = ((idx + wp.uint32(1)) * HASH_MULTIPLIER) & wp.uint32(0xFFFFFF)
     out[n, y, x, 0] = wp.uint8((h >> wp.uint32(16)) & wp.uint32(0xFF))
     out[n, y, x, 1] = wp.uint8((h >> wp.uint32(8)) & wp.uint32(0xFF))
     out[n, y, x, 2] = wp.uint8(h & wp.uint32(0xFF))