@woosh/meep-engine 3.14.6 → 3.16.0

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"}

package/src/shade/renderer/shadow/map/DirectionalLightShadowmap.js

@@ -348,8 +348,14 @@ export class DirectionalLightShadowmap extends Shadowmap {
             camera.far = extents.z1;
 
 
-            camera.transform.rotation.copy(light_rotation);
-            camera.transform.position.copy(cascade_frustum_center);
+            // Vector3 and Quaternion are both Float64Array-backed with indexed access, so the
+            // components read straight out of them. camera.update() recomposes the matrix.
+            camera.transform.setRotation(
+                light_rotation[0], light_rotation[1], light_rotation[2], light_rotation[3]
+            );
+            camera.transform.setTranslation(
+                cascade_frustum_center[0], cascade_frustum_center[1], cascade_frustum_center[2]
+            );
 
 
             camera.update(); // make sure to re-generate view/projection matrices and frustum

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

@@ -1 +1 @@
-{"version":3,"file":"PointLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/PointLightShadowmap.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,oCAFU,MAAM,CAE0B;AAgC1C;;;;;GAKG;AACH;IAEI;;;;;OAKG;IACH,WAFU,MAAM,CAEkB;IAElC,+CAoCC;IAED,wBAOC;CACJ;0BArGyB,gBAAgB"}
+{"version":3,"file":"PointLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/PointLightShadowmap.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,oCAFU,MAAM,CAE0B;AAgC1C;;;;;GAKG;AACH;IAEI;;;;;OAKG;IACH,WAFU,MAAM,CAEkB;IAElC,+CAwCC;IAED,wBAOC;CACJ;0BA1GyB,gBAAgB"}

package/src/shade/renderer/shadow/map/PointLightShadowmap.js

@@ -2,6 +2,7 @@ import { assert } from "../../../../core/assert.js";
 import Vector3 from "../../../../core/geom/Vector3.js";
 import { make_octahedral_point_shadow_record } from "./POINT_SHADOW_TETRAHEDRON_LAYOUT.js";
 import { Shadowmap } from "./Shadowmap.js";
+import { t64_look_rotation } from "../../../../engine/ecs/transform/t64_look_rotation.js";
 
 /**
  * Minimum near-plane distance for point light cube-face cameras, used when `light.near_clip_distance` is 0.
@@ -82,8 +83,12 @@ export class PointLightShadowmap extends Shadowmap {
 
             assert.equal(camera.isPerspectiveCamera, true, 'point-shadow cube face must use a PerspectiveCamera');
 
-            camera.transform.position.set(px, py, pz);
-            camera.transform.rotation.lookRotation(CUBE_FACE_FORWARDS[i], CUBE_FACE_UPS[i]);
+            camera.transform.setTranslation(px, py, pz);
+            t64_look_rotation(
+                camera.transform,
+                CUBE_FACE_FORWARDS[i][0], CUBE_FACE_FORWARDS[i][1], CUBE_FACE_FORWARDS[i][2],
+                CUBE_FACE_UPS[i][0], CUBE_FACE_UPS[i][1], CUBE_FACE_UPS[i][2]
+            );
 
             camera.fov = Math.PI * 0.5;
             camera.aspect = 1;

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

@@ -1 +1 @@
-{"version":3,"file":"SpotLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/SpotLightShadowmap.js"],"names":[],"mappings":"AAUA;IAEI,+CAyCC;IAED;;;MAMC;CACJ;0BA7DyB,gBAAgB"}
+{"version":3,"file":"SpotLightShadowmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/SpotLightShadowmap.js"],"names":[],"mappings":"AAUA;IAEI,+CA6BC;IAED;;;MAMC;CACJ;0BAjDyB,gBAAgB"}