@woosh/meep-engine 3.15.0 → 3.17.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/math/chunk_mod_v3f.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Floored modulo of a `vec3<f32>` by a scalar — GLSL's `mod(x, y)`, which WGSL does not have.
+ *
+ * WGSL's `%` is a *remainder*: it takes the sign of the dividend, so `-1.0 % 289.0` is `-1.0`. A
+ * modulo takes the sign of the divisor, so the same expression is `288.0` here. The two agree for
+ * non-negative input and disagree everywhere else, which is exactly where a lattice hash and a
+ * tiling wrap live — noise sampled left of the origin has negative cell coordinates, and `%` would
+ * fold them onto the wrong side of the period and mirror the field about zero.
+ *
+ * The divisor is a scalar because every caller wraps three components of one axis by one period.
+ * {@link chunk_mod_v3i} is the integer counterpart and takes a vector divisor; the two are not
+ * interchangeable.
+ *
+ * Inherited from the GLSL definition, and worth knowing: for a small negative `value` the quotient
+ * rounds to a whole number and the result can come back as exactly `divisor` rather than `0`. Every
+ * consumer here feeds the result to a hash or to a `floor`, both of which tolerate it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mod_v3f: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mod_v3f.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mod_v3f.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/chunk_mod_v3f.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,4BAFU,SAAS,CAYjB;0BA/BwB,6BAA6B"}

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

@@ -0,0 +1,32 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Floored modulo of a `vec3<f32>` by a scalar — GLSL's `mod(x, y)`, which WGSL does not have.
+ *
+ * WGSL's `%` is a *remainder*: it takes the sign of the dividend, so `-1.0 % 289.0` is `-1.0`. A
+ * modulo takes the sign of the divisor, so the same expression is `288.0` here. The two agree for
+ * non-negative input and disagree everywhere else, which is exactly where a lattice hash and a
+ * tiling wrap live — noise sampled left of the origin has negative cell coordinates, and `%` would
+ * fold them onto the wrong side of the period and mirror the field about zero.
+ *
+ * The divisor is a scalar because every caller wraps three components of one axis by one period.
+ * {@link chunk_mod_v3i} is the integer counterpart and takes a vector divisor; the two are not
+ * interchangeable.
+ *
+ * Inherited from the GLSL definition, and worth knowing: for a small negative `value` the quotient
+ * rounds to a whole number and the result can come back as exactly `divisor` rather than `0`. Every
+ * consumer here feeds the result to a hash or to a `floor`, both of which tolerate it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mod_v3f = CodeChunk.from(
+    //language=WGSL
+    `
+fn mod_v3f(
+    value: vec3<f32>,
+    divisor: f32
+) -> vec3<f32> {
+    return value - floor(value / divisor) * divisor;
+}
+    `
+);

package/src/shade/renderer/shader/chunk/math/chunk_mod_v4f.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Floored modulo of a `vec4<f32>` by a scalar. The four-wide {@link chunk_mod_v3f}; see it for why
+ * WGSL's `%` is not this.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mod_v4f: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mod_v4f.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mod_v4f.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/chunk_mod_v4f.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,4BAFU,SAAS,CAYjB;0BAlBwB,6BAA6B"}

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

@@ -0,0 +1,19 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Floored modulo of a `vec4<f32>` by a scalar. The four-wide {@link chunk_mod_v3f}; see it for why
+ * WGSL's `%` is not this.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mod_v4f = CodeChunk.from(
+    //language=WGSL
+    `
+fn mod_v4f(
+    value: vec4<f32>,
+    divisor: f32
+) -> vec4<f32> {
+    return value - floor(value / divisor) * divisor;
+}
+    `
+);

package/src/shade/renderer/shader/chunk/noise/psrdnoise/README.md

@@ -0,0 +1,65 @@
+# psrdnoise
+
+**P**eriodic **s**implex noise with **r**otating gradients and analytic **d**erivatives, by Stefan
+Gustavson and Ian McEwan.
+
+```
+psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan.
+Published under the MIT license.
+https://github.com/stegu/psrdnoise/
+```
+
+Three properties, none of which classic simplex noise has:
+
+- **it tiles.** The lattice is axis-aligned in texture space rather than skewed, so a rectangular
+  period can be imposed on it. Any integer period up to 289 per axis (2-D: even periods in y).
+- **its gradients rotate.** One `alpha` turns every gradient in the field. Animating it swirls the
+  pattern in place instead of crossfading between two fields, which is what flow noise is.
+- **its derivative is exact.** Analytic, and roughly free — the terms are already computed. Curl
+  noise, erosion and normal generation all need it, and a finite difference is both three times the
+  cost and wrong at cell boundaries.
+
+## What is here
+
+| chunk | signature |
+| --- | --- |
+| `psrdnoise2` | `(x: vec2<f32>, period: vec2<f32>, alpha: f32) -> vec3<f32>` |
+| `srdnoise2` | `(x: vec2<f32>, alpha: f32) -> vec3<f32>` |
+| `psrdnoise3` | `(x: vec3<f32>, period: vec3<f32>, alpha: f32) -> vec4<f32>` |
+| `srdnoise3` | `(x: vec3<f32>, alpha: f32) -> vec4<f32>` |
+
+The noise value is in `.x` and the gradient in the remaining components. Upstream returns a struct
+per dimension (`NG2`, `NG3`); packing into a vector instead means no chunk declares a type, so
+nothing that includes one of these has to have the declaration in scope.
+
+The `s*` variants are the non-periodic ones — the same function with the wrap deleted, so a caller
+that never tiles does not pay for the branch. Everything after the lattice is shared with the
+periodic version through `psrdnoise{2,3}_kernel`, which is where the cost of a sample actually is.
+
+Supporting chunks: `psrdnoise2_hash`, `psrdnoise3_permute` (the modulo-289 hashes),
+`psrdnoise3_skew` / `psrdnoise3_unskew` (the lattice transform and its inverse), and
+`math/chunk_mod_v3f` / `chunk_mod_v4f` (GLSL's floored `mod`, which WGSL's remainder `%` is not, and
+which both the hashes and the period wrap need).
+
+## What is not here, and why
+
+- **the value-only variants** (`psrnoise2`, `snoise3`, …). Upstream ships eight functions per
+  dimension because in 2021 it did not trust WGSL's dead-code elimination. Write `.x` and let the
+  compiler drop the derivative; that is what upstream's own GLSL relies on.
+- **the `alpha = 0` wrappers** (`psdnoise2`, `sdnoise3`, …). Pass `0.0`. In 3-D that value is also
+  what selects the cheap gradient path at runtime, so nothing is lost by not naming it.
+- **`FASTROTATION`.** A second gradient rotation, ~10% cheaper but with no shortcut at `alpha = 0`,
+  and it does not agree with the default at `alpha = 0` either. One rotation, one field.
+- **`PERLINGRID`.** An alternative lattice that costs 1% more and constrains every period to a
+  multiple of 3.
+- **`psrddnoise2/3`.** Second derivatives. They return a Hessian on top of the gradient — 6 more
+  floats in 2-D, 6 in 3-D — which no longer fits in a vector return, and nothing here needs them.
+- **`mpsrdnoise2`.** A 16-bit variant, for platforms without `f32`.
+
+## Period, and the 289 in everything
+
+The hash is a permutation polynomial modulo 289 (= 17²), and coordinates congruent modulo 289 hash
+identically. So the field repeats every 289 cells whether or not a period was asked for, a period
+longer than 289 does not tile but corrupts, and the modulus cannot simply be raised: the
+coefficients are sized to keep the polynomial's intermediate products exactly representable in an
+`f32`.

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise2.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Periodic (tiling) 2-D simplex noise with rotating gradients and an analytic derivative.
+ *
+ * Returns `vec3(noise, gradient.x, gradient.y)`: the noise value is in `.x`, in `[-1, 1]`, and
+ * `.yz` is its exact gradient. Ask for only `.x` and the compiler drops the derivative.
+ *
+ * **What tiles.** The lattice is axis-aligned and stretched in y precisely so a rectangular period
+ * can be imposed on it, which ordinary simplex noise's skewed grid cannot do. `period.x` may be any
+ * integer up to 289; `period.y` must be *even* — the hexagonal rows alternate by half a cell, so an
+ * odd y period tiles at twice the number given. Zero or negative on either axis skips the wrap for
+ * that axis, and `vec2(0.0)` on both takes a shortcut worth about 15% by upstream's measurement of
+ * the GLSL. A caller that always passes zero should call {@link chunk_srdnoise2} instead and not pay
+ * for the branch at all. 289 is the hash's modulus, so it is a hard ceiling, not a recommendation.
+ *
+ * **What `alpha` does.** It turns every gradient in the field by that many radians. Animating it
+ * swirls the pattern in place rather than crossfading it — see {@link chunk_psrdnoise2_kernel}.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise2: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_psrdnoise2.d.ts.map

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_psrdnoise2.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise2.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,+BAFU,SAAS,CA2DjB;0BAlFwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise2.js

@@ -0,0 +1,83 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_mod_v3f } from "../../math/chunk_mod_v3f.js";
+import { chunk_psrdnoise2_kernel } from "./chunk_psrdnoise2_kernel.js";
+
+/**
+ * Periodic (tiling) 2-D simplex noise with rotating gradients and an analytic derivative.
+ *
+ * Returns `vec3(noise, gradient.x, gradient.y)`: the noise value is in `.x`, in `[-1, 1]`, and
+ * `.yz` is its exact gradient. Ask for only `.x` and the compiler drops the derivative.
+ *
+ * **What tiles.** The lattice is axis-aligned and stretched in y precisely so a rectangular period
+ * can be imposed on it, which ordinary simplex noise's skewed grid cannot do. `period.x` may be any
+ * integer up to 289; `period.y` must be *even* — the hexagonal rows alternate by half a cell, so an
+ * odd y period tiles at twice the number given. Zero or negative on either axis skips the wrap for
+ * that axis, and `vec2(0.0)` on both takes a shortcut worth about 15% by upstream's measurement of
+ * the GLSL. A caller that always passes zero should call {@link chunk_srdnoise2} instead and not pay
+ * for the branch at all. 289 is the hash's modulus, so it is a hard ceiling, not a recommendation.
+ *
+ * **What `alpha` does.** It turns every gradient in the field by that many radians. Animating it
+ * swirls the pattern in place rather than crossfading it — see {@link chunk_psrdnoise2_kernel}.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise2 = CodeChunk.from(
+    //language=WGSL
+    `
+fn psrdnoise2(
+    x: vec2<f32>,
+    period: vec2<f32>,
+    alpha: f32
+) -> vec3<f32> {
+    // into simplex space — an axis-aligned hexagonal grid, stretched in y so it can tile
+    let uv = vec2<f32>(x.x + x.y * 0.5, x.y);
+
+    // which simplex we are in. i0 is the base corner, o1 the offset to the second: the cell is a
+    // rhombus split along its diagonal, and which half we are in decides which corner joins
+    let i0 = floor(uv);
+    let f0 = uv - i0;
+    let o1 = select(vec2<f32>(0.0, 1.0), vec2<f32>(1.0, 0.0), f0.x > f0.y);
+
+    let i1 = i0 + o1;
+    let i2 = i0 + vec2<f32>(1.0);
+
+    // the three corners back in texture space
+    let v0 = vec2<f32>(i0.x - i0.y * 0.5, i0.y);
+    let v1 = vec2<f32>(v0.x + o1.x - o1.y * 0.5, v0.y + o1.y);
+    let v2 = vec2<f32>(v0.x + 0.5, v0.y + 1.0);
+
+    var iu = vec3<f32>(i0.x, i1.x, i2.x);
+    var iv = vec3<f32>(i0.y, i1.y, i2.y);
+
+    if (any(period > vec2<f32>(0.0))) {
+        // the wrap has to happen in texture space, where the period is rectangular, and the corners
+        // then go back to simplex space to be hashed. Only the hash inputs move; the offsets below
+        // stay measured from the unwrapped corners, which is what keeps the field continuous
+        // across the seam
+        var xw = vec3<f32>(v0.x, v1.x, v2.x);
+        var yw = vec3<f32>(v0.y, v1.y, v2.y);
+
+        if (period.x > 0.0) {
+            xw = mod_v3f(xw, period.x);
+        }
+
+        if (period.y > 0.0) {
+            yw = mod_v3f(yw, period.y);
+        }
+
+        // xw + 0.5*yw is the skew back to simplex space, where the corners are integer lattice
+        // points — but the wrap leaves them a hair off one, so the trailing +0.5 under the floor
+        // rounds to nearest rather than truncating into the neighbouring cell
+        iu = floor(xw + 0.5 * yw + 0.5);
+        iv = floor(yw + 0.5);
+    }
+
+    return psrdnoise2_kernel(iu, iv, x - v0, x - v1, x - v2, alpha);
+}
+    `, [
+        chunk_mod_v3f,
+        chunk_psrdnoise2_kernel,
+    ]
+);

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise2_hash.d.ts

@@ -0,0 +1,25 @@
+/**
+ * One pseudo-random value per corner of a 2-D simplex, from the corner's lattice coordinates.
+ *
+ * Permutation polynomials modulo 289, composed — the "mod289" hash of the Perlin/McEwan noise
+ * lineage, evaluated on all three corners at once. The modulus is what bounds the period: coordinates
+ * congruent modulo 289 hash the same, so the noise field repeats every 289 cells whether or not a
+ * period was asked for, and a period larger than that cannot be represented.
+ *
+ * `289` is `17²`, and the coefficients are sized so the intermediate products stay inside the range
+ * an `f32` represents exactly — which is why the modulus cannot simply be raised to lengthen the
+ * period. They are not free parameters: what the hash owes its caller is that the three corners of a
+ * cell get three unrelated values and that the whole of `[0, 289)` is reached, and its spec checks
+ * both rather than trusting the constants.
+ *
+ * The two coordinate arguments are transposed with respect to the corners: `iu` holds the u
+ * coordinate of all three corners and `iv` the v coordinate, which is the layout the caller already
+ * has and what makes this three hashes for the price of one.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise2_hash: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_psrdnoise2_hash.d.ts.map

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise2_hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_psrdnoise2_hash.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise2_hash.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oCAFU,SAAS,CAkBjB;0BAzCwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/noise/psrdnoise/chunk_psrdnoise2_hash.js

@@ -0,0 +1,42 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_mod_v3f } from "../../math/chunk_mod_v3f.js";
+
+/**
+ * One pseudo-random value per corner of a 2-D simplex, from the corner's lattice coordinates.
+ *
+ * Permutation polynomials modulo 289, composed — the "mod289" hash of the Perlin/McEwan noise
+ * lineage, evaluated on all three corners at once. The modulus is what bounds the period: coordinates
+ * congruent modulo 289 hash the same, so the noise field repeats every 289 cells whether or not a
+ * period was asked for, and a period larger than that cannot be represented.
+ *
+ * `289` is `17²`, and the coefficients are sized so the intermediate products stay inside the range
+ * an `f32` represents exactly — which is why the modulus cannot simply be raised to lengthen the
+ * period. They are not free parameters: what the hash owes its caller is that the three corners of a
+ * cell get three unrelated values and that the whole of `[0, 289)` is reached, and its spec checks
+ * both rather than trusting the constants.
+ *
+ * The two coordinate arguments are transposed with respect to the corners: `iu` holds the u
+ * coordinate of all three corners and `iv` the v coordinate, which is the layout the caller already
+ * has and what makes this three hashes for the price of one.
+ *
+ * psrdnoise (c) 2021 Stefan Gustavson and Ian McEwan. Published under the MIT license.
+ * @see https://github.com/stegu/psrdnoise/
+ * @type {CodeChunk}
+ */
+export const chunk_psrdnoise2_hash = CodeChunk.from(
+    //language=WGSL
+    `
+fn psrdnoise2_hash(
+    iu: vec3<f32>,
+    iv: vec3<f32>
+) -> vec3<f32> {
+    var hash = mod_v3f(iu, 289.0);
+
+    hash = mod_v3f((hash * 51.0 + 2.0) * hash + iv, 289.0);
+
+    return mod_v3f((hash * 34.0 + 10.0) * hash, 289.0);
+}
+    `, [
+        chunk_mod_v3f,
+    ]
+);