@woosh/meep-engine 3.15.0 → 3.16.0

package/src/shade/renderer/scene/optimization/geometry/internal/match_refit_validate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"match_refit_validate.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/match_refit_validate.js"],"names":[],"mappings":"AAiCA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IAP0B,UAAU;IACV,UAAU;IACC,qBAAqB,EAA/C,IAAI,MAAM,EAAE,MAAM,CAAC;IAC2D,SAAS,EAAvF,OAAO,qDAAqD,EAAE,SAAS;IAC1D,SAAS,EAAtB,MAAM;IACJ,gBAAgB,CAqE5B;AA1HD;;;;;;;;;GASG;AACH,iDAFU,MAAM,CAEuC;;;;;WAqBzC,OAAO;;;;;;kBACP,MAAM"}
+{"version":3,"file":"match_refit_validate.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/match_refit_validate.js"],"names":[],"mappings":"AAiCA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IAP0B,UAAU;IACV,UAAU;IACC,qBAAqB,EAA/C,IAAI,MAAM,EAAE,MAAM,CAAC;IAC+D,SAAS,EAA3F,OAAO,uDAAuD,EAAE,WAAW;IAC9D,SAAS,EAAtB,MAAM;IACJ,gBAAgB,CAqE5B;AA1HD;;;;;;;;;GASG;AACH,iDAFU,MAAM,CAEuC;;;;;WAqBzC,OAAO;;;;;;kBACP,MAAM"}

package/src/shade/renderer/scene/optimization/geometry/internal/match_refit_validate.js

@@ -53,7 +53,7 @@ function ensure_capacity(count) {
  * @param {Geometry} args.geometry_a
  * @param {Geometry} args.geometry_b
  * @param {Map<number, number>} args.vertex_correspondence vertex_a → vertex_b
- * @param {import("../../../../../../engine/ecs/transform/Transform.js").Transform} args.transform Updated in place.
+ * @param {import("../../../../../../engine/ecs/transform/Transform64.js").Transform64} args.transform Updated in place.
  * @param {number} args.threshold
  * @returns {ValidationResult}
  */
@@ -107,7 +107,7 @@ export function match_refit_and_validate({
     // winding and renders inside-out under the fixed-cull rasterizer — treat it
     // like a residual failure.
     const scale = transform.scale;
-    if (scale.x * scale.y * scale.z < 0) {
+    if (scale[0] * scale[1] * scale[2] < 0) {
         return { valid: false, max_residual: 0 };
     }
 

package/src/shade/renderer/scene/optimization/geometry/internal/match_solve_transform.d.ts

@@ -25,10 +25,10 @@
  * @param {ArrayLike<number>} target_positions packed positions (count*3)
  * @param {ArrayLike<number>} source_positions packed positions (count*3)
  * @param {number} count                       number of paired correspondences
- * @param {Transform} out
+ * @param {Transform64} out
  * @returns {void}
  */
-export function match_solve_transform(target_normals: ArrayLike<number>, source_normals: ArrayLike<number>, target_positions: ArrayLike<number>, source_positions: ArrayLike<number>, count: number, out: Transform): void;
+export function match_solve_transform(target_normals: ArrayLike<number>, source_normals: ArrayLike<number>, target_positions: ArrayLike<number>, source_positions: ArrayLike<number>, count: number, out: Transform64): void;
 /**
  * Fit `y_target = R · s · y_source + t` with a *single uniform* scale (no
  * per-axis fit). This is the pre-step-3 algorithm — exposed for tests that
@@ -44,22 +44,22 @@ export function match_solve_transform(target_normals: ArrayLike<number>, source_
  * @param {ArrayLike<number>} target_positions
  * @param {ArrayLike<number>} source_positions
  * @param {number} count
- * @param {Transform} out
+ * @param {Transform64} out
  * @returns {void}
  */
-export function match_solve_transform_uniform_only(target_normals: ArrayLike<number>, source_normals: ArrayLike<number>, target_positions: ArrayLike<number>, source_positions: ArrayLike<number>, count: number, out: Transform): void;
+export function match_solve_transform_uniform_only(target_normals: ArrayLike<number>, source_normals: ArrayLike<number>, target_positions: ArrayLike<number>, source_positions: ArrayLike<number>, count: number, out: Transform64): void;
 /**
  * Apply a fitted transform to a single source-side position, producing the
  * predicted target-side position. Order: scale (per-axis, in source frame)
  * → rotate → translate.
  *
- * @param {Transform} transform
+ * @param {Transform64} transform
  * @param {number} sx
  * @param {number} sy
  * @param {number} sz
  * @param {Vector3} out
  */
-export function apply_match_transform(transform: Transform, sx: number, sy: number, sz: number, out: Vector3): void;
-import { Transform } from "../../../../../../engine/ecs/transform/Transform.js";
+export function apply_match_transform(transform: Transform64, sx: number, sy: number, sz: number, out: Vector3): void;
+import { Transform64 } from "../../../../../../engine/ecs/transform/Transform64.js";
 import Vector3 from "../../../../../../core/geom/Vector3.js";
 //# sourceMappingURL=match_solve_transform.d.ts.map

package/src/shade/renderer/scene/optimization/geometry/internal/match_solve_transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"match_solve_transform.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/match_solve_transform.js"],"names":[],"mappings":"AAoEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,sDARW,UAAU,MAAM,CAAC,kBACjB,UAAU,MAAM,CAAC,oBACjB,UAAU,MAAM,CAAC,oBACjB,UAAU,MAAM,CAAC,SACjB,MAAM,OACN,SAAS,GACP,IAAI,CAkGhB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,mEARW,UAAU,MAAM,CAAC,kBACjB,UAAU,MAAM,CAAC,oBACjB,UAAU,MAAM,CAAC,oBACjB,UAAU,MAAM,CAAC,SACjB,MAAM,OACN,SAAS,GACP,IAAI,CA0DhB;AAqMD;;;;;;;;;;GAUG;AACH,iDANW,SAAS,MACT,MAAM,MACN,MAAM,MACN,MAAM,OACN,OAAO,QAcjB;0BAreyB,qDAAqD;oBAD3D,wCAAwC"}
+{"version":3,"file":"match_solve_transform.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/scene/optimization/geometry/internal/match_solve_transform.js"],"names":[],"mappings":"AAyEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,sDARW,UAAU,MAAM,CAAC,kBACjB,UAAU,MAAM,CAAC,oBACjB,UAAU,MAAM,CAAC,oBACjB,UAAU,MAAM,CAAC,SACjB,MAAM,OACN,WAAW,GACT,IAAI,CAkGhB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,mEARW,UAAU,MAAM,CAAC,kBACjB,UAAU,MAAM,CAAC,oBACjB,UAAU,MAAM,CAAC,oBACjB,UAAU,MAAM,CAAC,SACjB,MAAM,OACN,WAAW,GACT,IAAI,CAwDhB;AAwMD;;;;;;;;;;GAUG;AACH,iDANW,WAAW,MACX,MAAM,MACN,MAAM,MACN,MAAM,OACN,OAAO,QAgBjB;4BA1eM,uDAAuD;oBAL1C,wCAAwC"}

package/src/shade/renderer/scene/optimization/geometry/internal/match_solve_transform.js

@@ -1,24 +1,30 @@
-import Quaternion from "../../../../../../core/geom/Quaternion.js";
 import {
     v3_rigid_align_paired_unit_vectors
 } from "../../../../../../core/geom/vec3/v3_rigid_align_paired_unit_vectors.js";
 import Vector3 from "../../../../../../core/geom/Vector3.js";
-import { Transform } from "../../../../../../engine/ecs/transform/Transform.js";
+import { v3_quaternion_apply } from "../../../../../../core/geom/vec3/v3_quaternion_apply.js";
+import {
+    Transform64,
+    TRANSFORM64_TRANSLATION_OFFSET
+} from "../../../../../../engine/ecs/transform/Transform64.js";
 
 /**
- * The fitted transform is a meep `Transform`. The forward model
+ * The fitted transform is a meep `Transform64`. The forward model
  * `y_target = R · diag(s) · y_source + t` matches meep's TRS apply convention
  * exactly (scale-then-rotate-then-translate), which is why the dedup direction
- * is canonical→instance — the resulting `Transform` plugs straight into the
+ * is canonical→instance — the resulting `Transform64` plugs straight into the
  * render pipeline without inversion or polar decomposition.
  *
- * Solver internals write the rotation via index setters on `transform.rotation`,
- * and the per-axis scale + translation via direct `.x/.y/.z` field assignment
- * on `transform.scale` and `transform.position`. Those paths bypass the
- * `onChanged` signal — the matrix is not auto-recomposed inside the solver's
- * inner loops. Callers that need the matrix can call `transform.updateMatrix()`
- * afterwards; the dedup pipeline only needs the field values (the meep
- * Transform produced for render in stage F is built fresh).
+ * Solver internals write straight into the transform's buffer: the rotation through the
+ * length-4 view the alignment solver fills, the per-axis scale through a length-3 view, and
+ * the translation by index. On a `Transform64` that is how the type is meant to be written -
+ * it recomposes nothing on its own, so the matrix stays whatever it was until a caller asks
+ * for `updateMatrix()`. The solver's inner loops never need it, and the dedup pipeline reads
+ * only the component values (the transform produced for render in stage F is built fresh).
+ *
+ * This code already worked this way against the old `Transform`, deliberately bypassing its
+ * `onChanged` signal to keep matrix recomposition out of the inner loops. On `Transform64`
+ * that is the type's contract rather than something done behind its back.
  */
 
 /**
@@ -37,8 +43,7 @@ const ALTMIN_MAX_ITERATIONS = 16;
  */
 const ALTMIN_SCALE_TOLERANCE = 1e-9;
 
-const scratch_v3 = new Vector3();
-const scratch_q = new Quaternion();
+const scratch_v3 = new Float64Array(3);
 
 // Scratch holds the Horn-solve input: paired unit normals + paired unit-
 // length centered position-direction vectors. JS numbers are Float64, so
@@ -93,7 +98,7 @@ function ensure_centered_capacity(count) {
  * @param {ArrayLike<number>} target_positions packed positions (count*3)
  * @param {ArrayLike<number>} source_positions packed positions (count*3)
  * @param {number} count                       number of paired correspondences
- * @param {Transform} out
+ * @param {Transform64} out
  * @returns {void}
  */
 export function match_solve_transform(
@@ -155,15 +160,15 @@ export function match_solve_transform(
     const uniform_s = fit_uniform_scale(
         target_centered, source_centered, count, rotation
     );
-    scale.x = uniform_s;
-    scale.y = uniform_s;
-    scale.z = uniform_s;
+    scale[0] = uniform_s;
+    scale[1] = uniform_s;
+    scale[2] = uniform_s;
 
     // ── Phase 2: alternating minimization on per-axis scale ──
     for (let iter = 0; iter < ALTMIN_MAX_ITERATIONS; iter++) {
-        const s_x_old = scale.x;
-        const s_y_old = scale.y;
-        const s_z_old = scale.z;
+        const s_x_old = scale[0];
+        const s_y_old = scale[1];
+        const s_z_old = scale[2];
 
         fit_per_axis_scale(
             target_centered, source_centered, count, rotation, scale
@@ -181,9 +186,9 @@ export function match_solve_transform(
             );
         }
 
-        const ds = Math.abs(scale.x - s_x_old)
-            + Math.abs(scale.y - s_y_old)
-            + Math.abs(scale.z - s_z_old);
+        const ds = Math.abs(scale[0] - s_x_old)
+            + Math.abs(scale[1] - s_y_old)
+            + Math.abs(scale[2] - s_z_old);
         if (ds < ALTMIN_SCALE_TOLERANCE) break;
     }
 
@@ -209,7 +214,7 @@ export function match_solve_transform(
  * @param {ArrayLike<number>} target_positions
  * @param {ArrayLike<number>} source_positions
  * @param {number} count
- * @param {Transform} out
+ * @param {Transform64} out
  * @returns {void}
  */
 export function match_solve_transform_uniform_only(
@@ -259,9 +264,7 @@ export function match_solve_transform_uniform_only(
     const uniform_s = fit_uniform_scale(
         target_centered, source_centered, count, out.rotation
     );
-    out.scale.x = uniform_s;
-    out.scale.y = uniform_s;
-    out.scale.z = uniform_s;
+    out.setScale(uniform_s, uniform_s, uniform_s);
 
     write_translation_from_means(
         mean_s_x, mean_s_y, mean_s_z,
@@ -279,23 +282,24 @@ export function match_solve_transform_uniform_only(
  * @param {number} mean_t_x
  * @param {number} mean_t_y
  * @param {number} mean_t_z
- * @param {Transform} out
+ * @param {Transform64} out
  */
 function write_translation_from_means(
     mean_s_x, mean_s_y, mean_s_z,
     mean_t_x, mean_t_y, mean_t_z,
     out
 ) {
-    scratch_v3.set(
-        mean_s_x * out.scale.x,
-        mean_s_y * out.scale.y,
-        mean_s_z * out.scale.z
+    v3_quaternion_apply(
+        scratch_v3, 0,
+        mean_s_x * out.scale_x,
+        mean_s_y * out.scale_y,
+        mean_s_z * out.scale_z,
+        out.rotation_x, out.rotation_y, out.rotation_z, out.rotation_w
     );
-    scratch_v3.applyQuaternion(out.rotation);
 
-    out.position.x = mean_t_x - scratch_v3.x;
-    out.position.y = mean_t_y - scratch_v3.y;
-    out.position.z = mean_t_z - scratch_v3.z;
+    out[TRANSFORM64_TRANSLATION_OFFSET] = mean_t_x - scratch_v3[0];
+    out[TRANSFORM64_TRANSLATION_OFFSET + 1] = mean_t_y - scratch_v3[1];
+    out[TRANSFORM64_TRANSLATION_OFFSET + 2] = mean_t_z - scratch_v3[2];
 }
 
 /**
@@ -353,7 +357,7 @@ function fit_rotation_scaled(
     const target_dirs = scratch_target_dirs;
     const source_dirs = scratch_source_dirs;
 
-    const sx = scale.x, sy = scale.y, sz = scale.z;
+    const sx = scale[0], sy = scale[1], sz = scale[2];
 
     for (let i = 0; i < count; i++) {
         const i3 = i * 3;
@@ -387,40 +391,41 @@ function fit_per_axis_scale(
     rotation,
     out_scale
 ) {
-    // R^T applied to a vector is the inverse rotation — clone into scratch and
-    // conjugate so we don't disturb the live `rotation` quaternion.
-    scratch_q.x = rotation.x;
-    scratch_q.y = rotation.y;
-    scratch_q.z = rotation.z;
-    scratch_q.w = rotation.w;
-    scratch_q.conjugate(); // R^T
+    // R^T applied to a vector is the inverse rotation. For a unit quaternion the conjugate
+    // is the negated vector part, held here as four scalars so the live `rotation` view is
+    // left alone and nothing is allocated per call.
+    const cq_x = -rotation[0];
+    const cq_y = -rotation[1];
+    const cq_z = -rotation[2];
+    const cq_w = rotation[3];
 
     let num_x = 0, num_y = 0, num_z = 0;
     let den_x = 0, den_y = 0, den_z = 0;
 
     for (let i = 0; i < count; i++) {
         const i3 = i * 3;
-        scratch_v3.set(
-            target_centered[i3], target_centered[i3 + 1], target_centered[i3 + 2]
-        );
-        scratch_v3.applyQuaternion(scratch_q); // q = R^T · b
+        v3_quaternion_apply(
+            scratch_v3, 0,
+            target_centered[i3], target_centered[i3 + 1], target_centered[i3 + 2],
+            cq_x, cq_y, cq_z, cq_w
+        ); // q = R^T · b
 
         const ax = source_centered[i3];
         const ay = source_centered[i3 + 1];
         const az = source_centered[i3 + 2];
 
-        num_x += ax * scratch_v3.x;
-        num_y += ay * scratch_v3.y;
-        num_z += az * scratch_v3.z;
+        num_x += ax * scratch_v3[0];
+        num_y += ay * scratch_v3[1];
+        num_z += az * scratch_v3[2];
 
         den_x += ax * ax;
         den_y += ay * ay;
         den_z += az * az;
     }
 
-    out_scale.x = den_x > 1e-20 ? num_x / den_x : 1;
-    out_scale.y = den_y > 1e-20 ? num_y / den_y : 1;
-    out_scale.z = den_z > 1e-20 ? num_z / den_z : 1;
+    out_scale[0] = den_x > 1e-20 ? num_x / den_x : 1;
+    out_scale[1] = den_y > 1e-20 ? num_y / den_y : 1;
+    out_scale[2] = den_z > 1e-20 ? num_z / den_z : 1;
 }
 
 /**
@@ -433,14 +438,15 @@ function fit_uniform_scale(target_centered, source_centered, count, rotation) {
 
     for (let i = 0; i < count; i++) {
         const i3 = i * 3;
-        scratch_v3.set(
-            source_centered[i3], source_centered[i3 + 1], source_centered[i3 + 2]
-        );
-        scratch_v3.applyQuaternion(rotation); // q = R · a
+        v3_quaternion_apply(
+            scratch_v3, 0,
+            source_centered[i3], source_centered[i3 + 1], source_centered[i3 + 2],
+            rotation[0], rotation[1], rotation[2], rotation[3]
+        ); // q = R · a
 
-        const qx = scratch_v3.x;
-        const qy = scratch_v3.y;
-        const qz = scratch_v3.z;
+        const qx = scratch_v3[0];
+        const qy = scratch_v3[1];
+        const qz = scratch_v3[2];
 
         num += qx * target_centered[i3]
              + qy * target_centered[i3 + 1]
@@ -470,23 +476,25 @@ function write_unit_dir(dirs, j, x, y, z) {
  * predicted target-side position. Order: scale (per-axis, in source frame)
  * → rotate → translate.
  *
- * @param {Transform} transform
+ * @param {Transform64} transform
  * @param {number} sx
  * @param {number} sy
  * @param {number} sz
  * @param {Vector3} out
  */
 export function apply_match_transform(transform, sx, sy, sz, out) {
-    out.set(
-        sx * transform.scale.x,
-        sy * transform.scale.y,
-        sz * transform.scale.z
+    v3_quaternion_apply(
+        scratch_v3, 0,
+        sx * transform.scale_x,
+        sy * transform.scale_y,
+        sz * transform.scale_z,
+        transform.rotation_x, transform.rotation_y, transform.rotation_z, transform.rotation_w
     );
 
-    out.applyQuaternion(transform.rotation);
-
-    out.x += transform.position.x;
-    out.y += transform.position.y;
-    out.z += transform.position.z;
+    out.set(
+        scratch_v3[0] + transform.translation_x,
+        scratch_v3[1] + transform.translation_y,
+        scratch_v3[2] + transform.translation_z
+    );
 }
 

package/src/shade/renderer/shader/chunk/math/chunk_lower_bound_branchless.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lower_bound_branchless.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/chunk_lower_bound_branchless.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,2CAFU,SAAS,CA6ClB;0BA5DyB,6BAA6B"}
+{"version":3,"file":"chunk_lower_bound_branchless.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/chunk_lower_bound_branchless.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,2CAFU,SAAS,CA+ClB;0BA9DyB,6BAA6B"}

package/src/shade/renderer/shader/chunk/math/chunk_lower_bound_branchless.js

@@ -46,7 +46,9 @@ fn lower_bound_branchless(
             break;
         }
 
-        let mid = low + (high - low) / 2u;
+        // A shift, not \`/ 2u\`: the same integer on a device, and the WGSL emulator's \`/\` is float
+        // division, which would hand a fractional index to the array below.
+        let mid = low + ((high - low) >> 1u);
         let mid_val = haystack[mid];
 
         let is_less = mid_val < needle;

package/src/shade/renderer/shader/chunk/random/chunk_hash_to_float01.d.ts

@@ -1,7 +1,17 @@
 /**
- * Converts a 0..MAX_U32 value to a float in [0,1) range
- * Primarily used for hashing
- * https://github.com/nvpro-samples/vk_raytrace/blob/ca07abfa081eca0d0eb8d4f45a52fd59033bffab/shaders/random.glsl#L101
+ * Converts a 0..MAX_U32 value to a float in [0,1) range.
+ * Primarily used for hashing.
+ *
+ * Takes the top 24 bits of the hash onto a 2^-24 grid. The multiply is by a power of two and the
+ * integer is below 2^24, so every value is exact — no rounding, and the distribution is exactly
+ * uniform over the grid.
+ *
+ * The classic alternative, `bitcast<f32>(0x3f800000 | (hash >> 9)) - 1.0`, is equally exact and
+ * equally uniform but consumes only 23 bits, halving the number of distinct outputs (and topping
+ * out at 1 - 2^-23) for the same three instructions. There is no reason to give up the bit: the
+ * bitcast trick exists to dodge an integer-to-float conversion that modern GPUs do in one
+ * instruction anyway.
+ *
  * @type {CodeChunk}
  */
 export const chunk_hash_to_float01: CodeChunk;

package/src/shade/renderer/shader/chunk/random/chunk_hash_to_float01.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_hash_to_float01.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/random/chunk_hash_to_float01.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,oCAFU,SAAS,CASlB;0BAfyB,6BAA6B"}
+{"version":3,"file":"chunk_hash_to_float01.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/random/chunk_hash_to_float01.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,oCAFU,SAAS,CASlB;0BAzByB,6BAA6B"}

package/src/shade/renderer/shader/chunk/random/chunk_hash_to_float01.js

@@ -1,16 +1,26 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 
 /**
- * Converts a 0..MAX_U32 value to a float in [0,1) range
- * Primarily used for hashing
- * https://github.com/nvpro-samples/vk_raytrace/blob/ca07abfa081eca0d0eb8d4f45a52fd59033bffab/shaders/random.glsl#L101
+ * Converts a 0..MAX_U32 value to a float in [0,1) range.
+ * Primarily used for hashing.
+ *
+ * Takes the top 24 bits of the hash onto a 2^-24 grid. The multiply is by a power of two and the
+ * integer is below 2^24, so every value is exact — no rounding, and the distribution is exactly
+ * uniform over the grid.
+ *
+ * The classic alternative, `bitcast<f32>(0x3f800000 | (hash >> 9)) - 1.0`, is equally exact and
+ * equally uniform but consumes only 23 bits, halving the number of distinct outputs (and topping
+ * out at 1 - 2^-23) for the same three instructions. There is no reason to give up the bit: the
+ * bitcast trick exists to dodge an integer-to-float conversion that modern GPUs do in one
+ * instruction anyway.
+ *
  * @type {CodeChunk}
  */
 export const chunk_hash_to_float01 = CodeChunk.from(
     //language=WGSL
     `
 fn hash_to_float01( hash:u32 ) -> f32{
-    return bitcast<f32>(0x3f800000 | (hash >> 9)) - 1.0f;
+    return f32( hash >> 8u ) * (1.0 / 16777216.0);
 }
     `
-)
+)

package/src/shade/renderer/shader/chunk/random/chunk_random_uint.d.ts

@@ -1,4 +1,12 @@
 /**
+ * The next value from the global PCG-RXS-M-XS-32 stream, seeded by `random_initialize()`.
+ *
+ * `rnd_state` holds the raw LCG state and each draw is the output permutation of it. Collapsing the
+ * two — `rnd_state = pcg(rnd_state)`, carrying the permuted output as the state — passes every
+ * distribution test but gives up the LCG's guaranteed 2^32 period: the output permutation is a
+ * bijection, so chaining it walks the cycles of a fixed permutation and a seed can land in a short
+ * one. Keep the state and the output distinct.
+ *
  * @see https://www.pcg-random.org/
  * @type {CodeChunk}
  */

package/src/shade/renderer/shader/chunk/random/chunk_random_uint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_random_uint.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/random/chunk_random_uint.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,gCAFU,SAAS,CAejB;0BArBwB,6BAA6B"}
+{"version":3,"file":"chunk_random_uint.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/random/chunk_random_uint.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;GAWG;AACH,gCAFU,SAAS,CAgBjB;0BA/BwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/random/chunk_random_uint.js

@@ -1,8 +1,17 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { chunk_random_variable_declaration } from "./chunk_random_variable_declaration.js";
-import { chunk_pcg } from "./pcg/chunk_pcg.js";
+import { chunk_pcg_advance } from "./pcg/chunk_pcg_advance.js";
+import { chunk_pcg_output } from "./pcg/chunk_pcg_output.js";
 
 /**
+ * The next value from the global PCG-RXS-M-XS-32 stream, seeded by `random_initialize()`.
+ *
+ * `rnd_state` holds the raw LCG state and each draw is the output permutation of it. Collapsing the
+ * two — `rnd_state = pcg(rnd_state)`, carrying the permuted output as the state — passes every
+ * distribution test but gives up the LCG's guaranteed 2^32 period: the output permutation is a
+ * bijection, so chaining it walks the cycles of a fixed permutation and a seed can land in a short
+ * one. Keep the state and the output distinct.
+ *
  * @see https://www.pcg-random.org/
  * @type {CodeChunk}
  */
@@ -10,13 +19,14 @@ export const chunk_random_uint = CodeChunk.from(
     //language=WGSL
     `
 fn random_uint() -> u32{
-  rnd_state = pcg(rnd_state);
+  rnd_state = pcg_advance(rnd_state);
   
-  return rnd_state;
+  return pcg_output(rnd_state);
 }
     `,
     [
         chunk_random_variable_declaration,
-        chunk_pcg,
+        chunk_pcg_advance,
+        chunk_pcg_output,
     ]
-);
+);

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg.d.ts

@@ -1,4 +1,11 @@
 /**
+ * PCG-RXS-M-XS-32 as a one-shot hash: advance an LCG from `v` and permute the result.
+ *
+ * Use this to hash an arbitrary value. A generator that draws a *sequence* should instead keep its
+ * own state, step it with {@link chunk_pcg_advance} and permute with {@link chunk_pcg_output} —
+ * chaining `pcg` into itself makes the output double as the state, which costs the LCG's guaranteed
+ * 2^32 period.
+ *
  * @see https://www.pcg-random.org/
  * @type {CodeChunk}
  */

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_pcg.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/random/pcg/chunk_pcg.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAFU,SAAS,CAclB;0BAlByB,gCAAgC"}
+{"version":3,"file":"chunk_pcg.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/random/pcg/chunk_pcg.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,wBAFU,SAAS,CAelB;0BA5ByB,gCAAgC"}

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg.js

@@ -1,6 +1,15 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_pcg_advance } from "./chunk_pcg_advance.js";
+import { chunk_pcg_output } from "./chunk_pcg_output.js";
 
 /**
+ * PCG-RXS-M-XS-32 as a one-shot hash: advance an LCG from `v` and permute the result.
+ *
+ * Use this to hash an arbitrary value. A generator that draws a *sequence* should instead keep its
+ * own state, step it with {@link chunk_pcg_advance} and permute with {@link chunk_pcg_output} —
+ * chaining `pcg` into itself makes the output double as the state, which costs the LCG's guaranteed
+ * 2^32 period.
+ *
  * @see https://www.pcg-random.org/
  * @type {CodeChunk}
  */
@@ -9,11 +18,12 @@ export const chunk_pcg = CodeChunk.from(
     `
 fn pcg(v: u32) -> u32 {
 
-  let state = v * 747796405u + 2891336453u;
-  let word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
-  
-  return (word >> 22u) ^ word;
-  
+  return pcg_output(pcg_advance(v));
+
 }
-    `
-)
+    `,
+    [
+        chunk_pcg_advance,
+        chunk_pcg_output,
+    ]
+)

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_advance.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The LCG state step of PCG-RXS-M-XS-32 — `state -> state * 747796405 + 2891336453`.
+ *
+ * Split out from {@link chunk_pcg} so a generator that keeps a running state can advance it and
+ * hold onto the result. That distinction matters: iterating the *state* through this LCG has a
+ * guaranteed period of 2^32, whereas feeding the permuted output ({@link chunk_pcg_output}) back in
+ * as the next state degenerates into a walk over the cycles of a fixed permutation, whose length
+ * depends on where the seed lands. Stateful generators (`random_uint`, the particle VM) advance
+ * this and permute for output; one-shot hashing of an arbitrary value still wants the fused
+ * {@link chunk_pcg}.
+ *
+ * @see https://www.pcg-random.org/
+ * @type {CodeChunk}
+ */
+export const chunk_pcg_advance: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_pcg_advance.d.ts.map

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_advance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_pcg_advance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_advance.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,gCAFU,SAAS,CAWlB;0BAzByB,gCAAgC"}

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_advance.js

@@ -0,0 +1,26 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * The LCG state step of PCG-RXS-M-XS-32 — `state -> state * 747796405 + 2891336453`.
+ *
+ * Split out from {@link chunk_pcg} so a generator that keeps a running state can advance it and
+ * hold onto the result. That distinction matters: iterating the *state* through this LCG has a
+ * guaranteed period of 2^32, whereas feeding the permuted output ({@link chunk_pcg_output}) back in
+ * as the next state degenerates into a walk over the cycles of a fixed permutation, whose length
+ * depends on where the seed lands. Stateful generators (`random_uint`, the particle VM) advance
+ * this and permute for output; one-shot hashing of an arbitrary value still wants the fused
+ * {@link chunk_pcg}.
+ *
+ * @see https://www.pcg-random.org/
+ * @type {CodeChunk}
+ */
+export const chunk_pcg_advance = CodeChunk.from(
+    //language=WGSL
+    `
+fn pcg_advance(state: u32) -> u32 {
+
+  return state * 747796405u + 2891336453u;
+
+}
+    `
+)

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_output.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The RXS-M-XS output permutation of PCG-RXS-M-XS-32: a random-xorshift, multiply, xorshift
+ * scramble that turns a raw LCG state into a well-mixed u32.
+ *
+ * This is a bijection by construction — which is exactly why it must not be used to carry the
+ * generator's state. Split out from {@link chunk_pcg} so a stateful generator can advance its state
+ * with {@link chunk_pcg_advance} and derive each output from it without the two roles collapsing
+ * into one value.
+ *
+ * @see https://www.pcg-random.org/
+ * @type {CodeChunk}
+ */
+export const chunk_pcg_output: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_pcg_output.d.ts.map

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_pcg_output.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_output.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,+BAFU,SAAS,CAalB;0BAzByB,gCAAgC"}

package/src/shade/renderer/shader/chunk/random/pcg/chunk_pcg_output.js

@@ -0,0 +1,26 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * The RXS-M-XS output permutation of PCG-RXS-M-XS-32: a random-xorshift, multiply, xorshift
+ * scramble that turns a raw LCG state into a well-mixed u32.
+ *
+ * This is a bijection by construction — which is exactly why it must not be used to carry the
+ * generator's state. Split out from {@link chunk_pcg} so a stateful generator can advance its state
+ * with {@link chunk_pcg_advance} and derive each output from it without the two roles collapsing
+ * into one value.
+ *
+ * @see https://www.pcg-random.org/
+ * @type {CodeChunk}
+ */
+export const chunk_pcg_output = CodeChunk.from(
+    //language=WGSL
+    `
+fn pcg_output(state: u32) -> u32 {
+
+  let word = ((state >> ((state >> 28u) + 4u)) ^ state) * 277803737u;
+
+  return (word >> 22u) ^ word;
+
+}
+    `
+)

package/src/shade/renderer/shadow/map/DirectionalLightShadowmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DirectionalLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/DirectionalLightShadowmap.js"],"names":[],"mappings":"AAkGA;IACI;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB,qBAAuD;IAEvD,+CA+PC;IAED,qBAYC;CAEJ;0BArWyB,gBAAgB"}
+{"version":3,"file":"DirectionalLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/DirectionalLightShadowmap.js"],"names":[],"mappings":"AAkGA;IACI;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB,qBAAuD;IAEvD,+CAqQC;IAED,qBAYC;CAEJ;0BA3WyB,gBAAgB"}