@woosh/meep-engine 3.38.0 → 3.39.0

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh3_color_evaluate_vmf.js

@@ -0,0 +1,75 @@
+// GENERATED by tools/codegen/spherical_harmonics/generate_sh_chunks.mjs — do not edit by hand.
+// Regenerate from packages/meep-engine with: node tools/codegen/spherical_harmonics/generate_sh_chunks.mjs
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * A 3-band RGB spherical-harmonic function convolved with a von Mises-Fisher lobe of
+ * concentration `kappa`, evaluated at a unit `direction`:
+ * `sum over l, m of exp(-l(l+1) / (2 kappa)) * Y(l, m)(direction) * sh[l * (l + 1) + m]`.
+ *
+ * The band window is the large-kappa vMF form of Ref-NeRF's integrated directional encoding [VHM*22];
+ * with `kappa = 1 / alpha` it is how Silvennoinen, Sloan, Iwanicki and Nowrouzezahrai encode roughness in
+ * "Spherical Harmonic Exponentials for Efficient Glossy Reflections" (HPG 2025,
+ * https://doi.org/10.1111/cgf.70219, talk: https://www.youtube.com/watch?v=THVMMNZ68iA). Their P and Q
+ * terms are each `exp` of one of these; see `sh_exponential/` beside the environment light code.
+ *
+ * **Not clamped.** Unlike `sh3_color_evaluate`, this returns the signed value: the SH-exponential
+ * representation stores log radiance, where negative is ordinary.
+ *
+ * Coefficients are band-major in the engine's all-positive convention (`sh_index`); per band the
+ * weight is `sh_vmf_window(l, kappa)`, folded here as powers of one `exp`. `kappa` must be > 0;
+ * as it grows the result tends to plain evaluation of `sh`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh3_color_evaluate_vmf = CodeChunk.from(
+    //language=WGSL
+    `
+fn sh3_color_evaluate_vmf(sh: array<vec3<f32>, 9>, direction: vec3<f32>, kappa: f32) -> vec3<f32> {
+    let x = direction.x;
+    let y = direction.y;
+    let z = direction.z;
+
+    // m = 0
+    let q0_0 = 0.28209479177387814;
+    let q1_0 = 0.48860251190291987 * z;
+    let q2_0 = 1.9364916731037085 * z * q1_0 - 1.118033988749895 * q0_0;
+
+    // m = 1, (x + iy)^1
+    let c1 = x;
+    let s1 = y;
+    let q1_1 = 0.48860251190292;
+    let q2_1 = 1.0925484305920792 * z;
+
+    // m = 2, (x + iy)^2
+    let c2 = x * c1 - y * s1;
+    let s2 = x * s1 + y * c1;
+    let q2_2 = 0.5462742152960396;
+
+    // band l is attenuated by exp(-l(l+1) / (2 kappa)) = t^(l(l+1)), t = exp(-1 / (2 kappa)),
+    // built up as w(l) = w(l-1) * t^(2l)
+    let t = exp(-0.5 / kappa);
+    let t2 = t * t;
+    let w1 = t2;
+    let t4 = t2 * t2;
+    let w2 = w1 * t4;
+
+    var result = sh[0] * q0_0;
+
+    result += w1 * (
+        sh[1] * (q1_1 * s1)
+        + sh[2] * (q1_0)
+        + sh[3] * (q1_1 * c1)
+    );
+
+    result += w2 * (
+        sh[4] * (q2_2 * s2)
+        + sh[5] * (q2_1 * s1)
+        + sh[6] * (q2_0)
+        + sh[7] * (q2_1 * c1)
+        + sh[8] * (q2_2 * c2)
+    );
+
+    return result;
+}
+`);

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh4_basis_at.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The 4-band real spherical harmonic basis at a unit direction: 16 values, band-major, index
+ * `l * (l + 1) + m`, in the engine's all-positive convention (the first nine are `sh3_basis_at`).
+ *
+ * Unrolled from the normalized associated Legendre recurrence documented in
+ * `core/geom/3d/sphere/harmonics/sh_basis_at.js`, which is its CPU twin. For one coefficient of any
+ * band, `sh_basis_function`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh4_basis_at: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sh4_basis_at.d.ts.map

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh4_basis_at.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sh4_basis_at.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh4_basis_at.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,iCAFU,SAAS,CAyDhB;0BAnEuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh4_basis_at.js

@@ -0,0 +1,70 @@
+// GENERATED by tools/codegen/spherical_harmonics/generate_sh_chunks.mjs — do not edit by hand.
+// Regenerate from packages/meep-engine with: node tools/codegen/spherical_harmonics/generate_sh_chunks.mjs
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * The 4-band real spherical harmonic basis at a unit direction: 16 values, band-major, index
+ * `l * (l + 1) + m`, in the engine's all-positive convention (the first nine are `sh3_basis_at`).
+ *
+ * Unrolled from the normalized associated Legendre recurrence documented in
+ * `core/geom/3d/sphere/harmonics/sh_basis_at.js`, which is its CPU twin. For one coefficient of any
+ * band, `sh_basis_function`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh4_basis_at = CodeChunk.from(
+    //language=WGSL
+    `
+fn sh4_basis_at(direction: vec3<f32>) -> array<f32, 16> {
+    let x = direction.x;
+    let y = direction.y;
+    let z = direction.z;
+
+    // m = 0
+    let q0_0 = 0.28209479177387814;
+    let q1_0 = 0.48860251190291987 * z;
+    let q2_0 = 1.9364916731037085 * z * q1_0 - 1.118033988749895 * q0_0;
+    let q3_0 = 1.9720265943665387 * z * q2_0 - 1.018350154434631 * q1_0;
+
+    // m = 1, (x + iy)^1
+    let c1 = x;
+    let s1 = y;
+    let q1_1 = 0.48860251190292;
+    let q2_1 = 1.0925484305920792 * z;
+    let q3_1 = 2.091650066335189 * z * q2_1 - 0.9354143466934853 * q1_1;
+
+    // m = 2, (x + iy)^2
+    let c2 = x * c1 - y * s1;
+    let s2 = x * s1 + y * c1;
+    let q2_2 = 0.5462742152960396;
+    let q3_2 = 1.4453057213202773 * z;
+
+    // m = 3, (x + iy)^3
+    let c3 = x * c2 - y * s2;
+    let s3 = x * s2 + y * c2;
+    let q3_3 = 0.5900435899266436;
+
+    return array<f32, 16>(
+        // band 0
+        q0_0,
+        // band 1
+        q1_1 * s1,
+        q1_0,
+        q1_1 * c1,
+        // band 2
+        q2_2 * s2,
+        q2_1 * s1,
+        q2_0,
+        q2_1 * c1,
+        q2_2 * c2,
+        // band 3
+        q3_3 * s3,
+        q3_2 * s2,
+        q3_1 * s1,
+        q3_0,
+        q3_1 * c1,
+        q3_2 * c2,
+        q3_3 * c3
+    );
+}
+`);

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh4_color_evaluate_vmf.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A 4-band RGB spherical-harmonic function convolved with a von Mises-Fisher lobe of
+ * concentration `kappa`, evaluated at a unit `direction`:
+ * `sum over l, m of exp(-l(l+1) / (2 kappa)) * Y(l, m)(direction) * sh[l * (l + 1) + m]`.
+ *
+ * The band window is the large-kappa vMF form of Ref-NeRF's integrated directional encoding [VHM*22];
+ * with `kappa = 1 / alpha` it is how Silvennoinen, Sloan, Iwanicki and Nowrouzezahrai encode roughness in
+ * "Spherical Harmonic Exponentials for Efficient Glossy Reflections" (HPG 2025,
+ * https://doi.org/10.1111/cgf.70219, talk: https://www.youtube.com/watch?v=THVMMNZ68iA). Their P and Q
+ * terms are each `exp` of one of these; see `sh_exponential/` beside the environment light code.
+ *
+ * **Not clamped.** Unlike `sh3_color_evaluate`, this returns the signed value: the SH-exponential
+ * representation stores log radiance, where negative is ordinary.
+ *
+ * Coefficients are band-major in the engine's all-positive convention (`sh_index`); per band the
+ * weight is `sh_vmf_window(l, kappa)`, folded here as powers of one `exp`. `kappa` must be > 0;
+ * as it grows the result tends to plain evaluation of `sh`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh4_color_evaluate_vmf: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sh4_color_evaluate_vmf.d.ts.map

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh4_color_evaluate_vmf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sh4_color_evaluate_vmf.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh4_color_evaluate_vmf.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,2CAFU,SAAS,CAwEhB;0BA5FuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh4_color_evaluate_vmf.js

@@ -0,0 +1,95 @@
+// GENERATED by tools/codegen/spherical_harmonics/generate_sh_chunks.mjs — do not edit by hand.
+// Regenerate from packages/meep-engine with: node tools/codegen/spherical_harmonics/generate_sh_chunks.mjs
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * A 4-band RGB spherical-harmonic function convolved with a von Mises-Fisher lobe of
+ * concentration `kappa`, evaluated at a unit `direction`:
+ * `sum over l, m of exp(-l(l+1) / (2 kappa)) * Y(l, m)(direction) * sh[l * (l + 1) + m]`.
+ *
+ * The band window is the large-kappa vMF form of Ref-NeRF's integrated directional encoding [VHM*22];
+ * with `kappa = 1 / alpha` it is how Silvennoinen, Sloan, Iwanicki and Nowrouzezahrai encode roughness in
+ * "Spherical Harmonic Exponentials for Efficient Glossy Reflections" (HPG 2025,
+ * https://doi.org/10.1111/cgf.70219, talk: https://www.youtube.com/watch?v=THVMMNZ68iA). Their P and Q
+ * terms are each `exp` of one of these; see `sh_exponential/` beside the environment light code.
+ *
+ * **Not clamped.** Unlike `sh3_color_evaluate`, this returns the signed value: the SH-exponential
+ * representation stores log radiance, where negative is ordinary.
+ *
+ * Coefficients are band-major in the engine's all-positive convention (`sh_index`); per band the
+ * weight is `sh_vmf_window(l, kappa)`, folded here as powers of one `exp`. `kappa` must be > 0;
+ * as it grows the result tends to plain evaluation of `sh`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh4_color_evaluate_vmf = CodeChunk.from(
+    //language=WGSL
+    `
+fn sh4_color_evaluate_vmf(sh: array<vec3<f32>, 16>, direction: vec3<f32>, kappa: f32) -> vec3<f32> {
+    let x = direction.x;
+    let y = direction.y;
+    let z = direction.z;
+
+    // m = 0
+    let q0_0 = 0.28209479177387814;
+    let q1_0 = 0.48860251190291987 * z;
+    let q2_0 = 1.9364916731037085 * z * q1_0 - 1.118033988749895 * q0_0;
+    let q3_0 = 1.9720265943665387 * z * q2_0 - 1.018350154434631 * q1_0;
+
+    // m = 1, (x + iy)^1
+    let c1 = x;
+    let s1 = y;
+    let q1_1 = 0.48860251190292;
+    let q2_1 = 1.0925484305920792 * z;
+    let q3_1 = 2.091650066335189 * z * q2_1 - 0.9354143466934853 * q1_1;
+
+    // m = 2, (x + iy)^2
+    let c2 = x * c1 - y * s1;
+    let s2 = x * s1 + y * c1;
+    let q2_2 = 0.5462742152960396;
+    let q3_2 = 1.4453057213202773 * z;
+
+    // m = 3, (x + iy)^3
+    let c3 = x * c2 - y * s2;
+    let s3 = x * s2 + y * c2;
+    let q3_3 = 0.5900435899266436;
+
+    // band l is attenuated by exp(-l(l+1) / (2 kappa)) = t^(l(l+1)), t = exp(-1 / (2 kappa)),
+    // built up as w(l) = w(l-1) * t^(2l)
+    let t = exp(-0.5 / kappa);
+    let t2 = t * t;
+    let w1 = t2;
+    let t4 = t2 * t2;
+    let w2 = w1 * t4;
+    let t6 = t4 * t2;
+    let w3 = w2 * t6;
+
+    var result = sh[0] * q0_0;
+
+    result += w1 * (
+        sh[1] * (q1_1 * s1)
+        + sh[2] * (q1_0)
+        + sh[3] * (q1_1 * c1)
+    );
+
+    result += w2 * (
+        sh[4] * (q2_2 * s2)
+        + sh[5] * (q2_1 * s1)
+        + sh[6] * (q2_0)
+        + sh[7] * (q2_1 * c1)
+        + sh[8] * (q2_2 * c2)
+    );
+
+    result += w3 * (
+        sh[9] * (q3_3 * s3)
+        + sh[10] * (q3_2 * s2)
+        + sh[11] * (q3_1 * s1)
+        + sh[12] * (q3_0)
+        + sh[13] * (q3_1 * c1)
+        + sh[14] * (q3_2 * c2)
+        + sh[15] * (q3_3 * c3)
+    );
+
+    return result;
+}
+`);

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh5_basis_at.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The 5-band real spherical harmonic basis at a unit direction: 25 values, band-major, index
+ * `l * (l + 1) + m`, in the engine's all-positive convention (the first nine are `sh3_basis_at`).
+ *
+ * Unrolled from the normalized associated Legendre recurrence documented in
+ * `core/geom/3d/sphere/harmonics/sh_basis_at.js`, which is its CPU twin. For one coefficient of any
+ * band, `sh_basis_function`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh5_basis_at: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sh5_basis_at.d.ts.map

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh5_basis_at.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sh5_basis_at.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh5_basis_at.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,iCAFU,SAAS,CA4EhB;0BAtFuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh5_basis_at.js

@@ -0,0 +1,89 @@
+// GENERATED by tools/codegen/spherical_harmonics/generate_sh_chunks.mjs — do not edit by hand.
+// Regenerate from packages/meep-engine with: node tools/codegen/spherical_harmonics/generate_sh_chunks.mjs
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * The 5-band real spherical harmonic basis at a unit direction: 25 values, band-major, index
+ * `l * (l + 1) + m`, in the engine's all-positive convention (the first nine are `sh3_basis_at`).
+ *
+ * Unrolled from the normalized associated Legendre recurrence documented in
+ * `core/geom/3d/sphere/harmonics/sh_basis_at.js`, which is its CPU twin. For one coefficient of any
+ * band, `sh_basis_function`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh5_basis_at = CodeChunk.from(
+    //language=WGSL
+    `
+fn sh5_basis_at(direction: vec3<f32>) -> array<f32, 25> {
+    let x = direction.x;
+    let y = direction.y;
+    let z = direction.z;
+
+    // m = 0
+    let q0_0 = 0.28209479177387814;
+    let q1_0 = 0.48860251190291987 * z;
+    let q2_0 = 1.9364916731037085 * z * q1_0 - 1.118033988749895 * q0_0;
+    let q3_0 = 1.9720265943665387 * z * q2_0 - 1.018350154434631 * q1_0;
+    let q4_0 = 1.984313483298443 * z * q3_0 - 1.0062305898749055 * q2_0;
+
+    // m = 1, (x + iy)^1
+    let c1 = x;
+    let s1 = y;
+    let q1_1 = 0.48860251190292;
+    let q2_1 = 1.0925484305920792 * z;
+    let q3_1 = 2.091650066335189 * z * q2_1 - 0.9354143466934853 * q1_1;
+    let q4_1 = 2.04939015319192 * z * q3_1 - 0.9797958971132713 * q2_1;
+
+    // m = 2, (x + iy)^2
+    let c2 = x * c1 - y * s1;
+    let s2 = x * s1 + y * c1;
+    let q2_2 = 0.5462742152960396;
+    let q3_2 = 1.4453057213202773 * z;
+    let q4_2 = 2.29128784747792 * z * q3_2 - 0.8660254037844386 * q2_2;
+
+    // m = 3, (x + iy)^3
+    let c3 = x * c2 - y * s2;
+    let s3 = x * s2 + y * c2;
+    let q3_3 = 0.5900435899266436;
+    let q4_3 = 1.770130769779931 * z;
+
+    // m = 4, (x + iy)^4
+    let c4 = x * c3 - y * s3;
+    let s4 = x * s3 + y * c3;
+    let q4_4 = 0.6258357354491763;
+
+    return array<f32, 25>(
+        // band 0
+        q0_0,
+        // band 1
+        q1_1 * s1,
+        q1_0,
+        q1_1 * c1,
+        // band 2
+        q2_2 * s2,
+        q2_1 * s1,
+        q2_0,
+        q2_1 * c1,
+        q2_2 * c2,
+        // band 3
+        q3_3 * s3,
+        q3_2 * s2,
+        q3_1 * s1,
+        q3_0,
+        q3_1 * c1,
+        q3_2 * c2,
+        q3_3 * c3,
+        // band 4
+        q4_4 * s4,
+        q4_3 * s3,
+        q4_2 * s2,
+        q4_1 * s1,
+        q4_0,
+        q4_1 * c1,
+        q4_2 * c2,
+        q4_3 * c3,
+        q4_4 * c4
+    );
+}
+`);

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh5_color_evaluate_vmf.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A 5-band RGB spherical-harmonic function convolved with a von Mises-Fisher lobe of
+ * concentration `kappa`, evaluated at a unit `direction`:
+ * `sum over l, m of exp(-l(l+1) / (2 kappa)) * Y(l, m)(direction) * sh[l * (l + 1) + m]`.
+ *
+ * The band window is the large-kappa vMF form of Ref-NeRF's integrated directional encoding [VHM*22];
+ * with `kappa = 1 / alpha` it is how Silvennoinen, Sloan, Iwanicki and Nowrouzezahrai encode roughness in
+ * "Spherical Harmonic Exponentials for Efficient Glossy Reflections" (HPG 2025,
+ * https://doi.org/10.1111/cgf.70219, talk: https://www.youtube.com/watch?v=THVMMNZ68iA). Their P and Q
+ * terms are each `exp` of one of these; see `sh_exponential/` beside the environment light code.
+ *
+ * **Not clamped.** Unlike `sh3_color_evaluate`, this returns the signed value: the SH-exponential
+ * representation stores log radiance, where negative is ordinary.
+ *
+ * Coefficients are band-major in the engine's all-positive convention (`sh_index`); per band the
+ * weight is `sh_vmf_window(l, kappa)`, folded here as powers of one `exp`. `kappa` must be > 0;
+ * as it grows the result tends to plain evaluation of `sh`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh5_color_evaluate_vmf: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sh5_color_evaluate_vmf.d.ts.map

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh5_color_evaluate_vmf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sh5_color_evaluate_vmf.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh5_color_evaluate_vmf.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,2CAFU,SAAS,CA+FhB;0BAnHuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh5_color_evaluate_vmf.js

@@ -0,0 +1,118 @@
+// GENERATED by tools/codegen/spherical_harmonics/generate_sh_chunks.mjs — do not edit by hand.
+// Regenerate from packages/meep-engine with: node tools/codegen/spherical_harmonics/generate_sh_chunks.mjs
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * A 5-band RGB spherical-harmonic function convolved with a von Mises-Fisher lobe of
+ * concentration `kappa`, evaluated at a unit `direction`:
+ * `sum over l, m of exp(-l(l+1) / (2 kappa)) * Y(l, m)(direction) * sh[l * (l + 1) + m]`.
+ *
+ * The band window is the large-kappa vMF form of Ref-NeRF's integrated directional encoding [VHM*22];
+ * with `kappa = 1 / alpha` it is how Silvennoinen, Sloan, Iwanicki and Nowrouzezahrai encode roughness in
+ * "Spherical Harmonic Exponentials for Efficient Glossy Reflections" (HPG 2025,
+ * https://doi.org/10.1111/cgf.70219, talk: https://www.youtube.com/watch?v=THVMMNZ68iA). Their P and Q
+ * terms are each `exp` of one of these; see `sh_exponential/` beside the environment light code.
+ *
+ * **Not clamped.** Unlike `sh3_color_evaluate`, this returns the signed value: the SH-exponential
+ * representation stores log radiance, where negative is ordinary.
+ *
+ * Coefficients are band-major in the engine's all-positive convention (`sh_index`); per band the
+ * weight is `sh_vmf_window(l, kappa)`, folded here as powers of one `exp`. `kappa` must be > 0;
+ * as it grows the result tends to plain evaluation of `sh`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh5_color_evaluate_vmf = CodeChunk.from(
+    //language=WGSL
+    `
+fn sh5_color_evaluate_vmf(sh: array<vec3<f32>, 25>, direction: vec3<f32>, kappa: f32) -> vec3<f32> {
+    let x = direction.x;
+    let y = direction.y;
+    let z = direction.z;
+
+    // m = 0
+    let q0_0 = 0.28209479177387814;
+    let q1_0 = 0.48860251190291987 * z;
+    let q2_0 = 1.9364916731037085 * z * q1_0 - 1.118033988749895 * q0_0;
+    let q3_0 = 1.9720265943665387 * z * q2_0 - 1.018350154434631 * q1_0;
+    let q4_0 = 1.984313483298443 * z * q3_0 - 1.0062305898749055 * q2_0;
+
+    // m = 1, (x + iy)^1
+    let c1 = x;
+    let s1 = y;
+    let q1_1 = 0.48860251190292;
+    let q2_1 = 1.0925484305920792 * z;
+    let q3_1 = 2.091650066335189 * z * q2_1 - 0.9354143466934853 * q1_1;
+    let q4_1 = 2.04939015319192 * z * q3_1 - 0.9797958971132713 * q2_1;
+
+    // m = 2, (x + iy)^2
+    let c2 = x * c1 - y * s1;
+    let s2 = x * s1 + y * c1;
+    let q2_2 = 0.5462742152960396;
+    let q3_2 = 1.4453057213202773 * z;
+    let q4_2 = 2.29128784747792 * z * q3_2 - 0.8660254037844386 * q2_2;
+
+    // m = 3, (x + iy)^3
+    let c3 = x * c2 - y * s2;
+    let s3 = x * s2 + y * c2;
+    let q3_3 = 0.5900435899266436;
+    let q4_3 = 1.770130769779931 * z;
+
+    // m = 4, (x + iy)^4
+    let c4 = x * c3 - y * s3;
+    let s4 = x * s3 + y * c3;
+    let q4_4 = 0.6258357354491763;
+
+    // band l is attenuated by exp(-l(l+1) / (2 kappa)) = t^(l(l+1)), t = exp(-1 / (2 kappa)),
+    // built up as w(l) = w(l-1) * t^(2l)
+    let t = exp(-0.5 / kappa);
+    let t2 = t * t;
+    let w1 = t2;
+    let t4 = t2 * t2;
+    let w2 = w1 * t4;
+    let t6 = t4 * t2;
+    let w3 = w2 * t6;
+    let t8 = t6 * t2;
+    let w4 = w3 * t8;
+
+    var result = sh[0] * q0_0;
+
+    result += w1 * (
+        sh[1] * (q1_1 * s1)
+        + sh[2] * (q1_0)
+        + sh[3] * (q1_1 * c1)
+    );
+
+    result += w2 * (
+        sh[4] * (q2_2 * s2)
+        + sh[5] * (q2_1 * s1)
+        + sh[6] * (q2_0)
+        + sh[7] * (q2_1 * c1)
+        + sh[8] * (q2_2 * c2)
+    );
+
+    result += w3 * (
+        sh[9] * (q3_3 * s3)
+        + sh[10] * (q3_2 * s2)
+        + sh[11] * (q3_1 * s1)
+        + sh[12] * (q3_0)
+        + sh[13] * (q3_1 * c1)
+        + sh[14] * (q3_2 * c2)
+        + sh[15] * (q3_3 * c3)
+    );
+
+    result += w4 * (
+        sh[16] * (q4_4 * s4)
+        + sh[17] * (q4_3 * s3)
+        + sh[18] * (q4_2 * s2)
+        + sh[19] * (q4_1 * s1)
+        + sh[20] * (q4_0)
+        + sh[21] * (q4_1 * c1)
+        + sh[22] * (q4_2 * c2)
+        + sh[23] * (q4_3 * c3)
+        + sh[24] * (q4_4 * c4)
+    );
+
+    return result;
+}
+`);

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh6_basis_at.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The 6-band real spherical harmonic basis at a unit direction: 36 values, band-major, index
+ * `l * (l + 1) + m`, in the engine's all-positive convention (the first nine are `sh3_basis_at`).
+ *
+ * Unrolled from the normalized associated Legendre recurrence documented in
+ * `core/geom/3d/sphere/harmonics/sh_basis_at.js`, which is its CPU twin. For one coefficient of any
+ * band, `sh_basis_function`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh6_basis_at: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sh6_basis_at.d.ts.map

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh6_basis_at.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sh6_basis_at.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh6_basis_at.js"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,iCAFU,SAAS,CAkGhB;0BA5GuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/generated/chunk_sh6_basis_at.js

@@ -0,0 +1,111 @@
+// GENERATED by tools/codegen/spherical_harmonics/generate_sh_chunks.mjs — do not edit by hand.
+// Regenerate from packages/meep-engine with: node tools/codegen/spherical_harmonics/generate_sh_chunks.mjs
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * The 6-band real spherical harmonic basis at a unit direction: 36 values, band-major, index
+ * `l * (l + 1) + m`, in the engine's all-positive convention (the first nine are `sh3_basis_at`).
+ *
+ * Unrolled from the normalized associated Legendre recurrence documented in
+ * `core/geom/3d/sphere/harmonics/sh_basis_at.js`, which is its CPU twin. For one coefficient of any
+ * band, `sh_basis_function`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh6_basis_at = CodeChunk.from(
+    //language=WGSL
+    `
+fn sh6_basis_at(direction: vec3<f32>) -> array<f32, 36> {
+    let x = direction.x;
+    let y = direction.y;
+    let z = direction.z;
+
+    // m = 0
+    let q0_0 = 0.28209479177387814;
+    let q1_0 = 0.48860251190291987 * z;
+    let q2_0 = 1.9364916731037085 * z * q1_0 - 1.118033988749895 * q0_0;
+    let q3_0 = 1.9720265943665387 * z * q2_0 - 1.018350154434631 * q1_0;
+    let q4_0 = 1.984313483298443 * z * q3_0 - 1.0062305898749055 * q2_0;
+    let q5_0 = 1.98997487421324 * z * q4_0 - 1.002853072844814 * q3_0;
+
+    // m = 1, (x + iy)^1
+    let c1 = x;
+    let s1 = y;
+    let q1_1 = 0.48860251190292;
+    let q2_1 = 1.0925484305920792 * z;
+    let q3_1 = 2.091650066335189 * z * q2_1 - 0.9354143466934853 * q1_1;
+    let q4_1 = 2.04939015319192 * z * q3_1 - 0.9797958971132713 * q2_1;
+    let q5_1 = 2.03100960115899 * z * q4_1 - 0.991031208965115 * q3_1;
+
+    // m = 2, (x + iy)^2
+    let c2 = x * c1 - y * s1;
+    let s2 = x * s1 + y * c1;
+    let q2_2 = 0.5462742152960396;
+    let q3_2 = 1.4453057213202773 * z;
+    let q4_2 = 2.29128784747792 * z * q3_2 - 0.8660254037844386 * q2_2;
+    let q5_2 = 2.1712405933672376 * z * q4_2 - 0.9476070829586856 * q3_2;
+
+    // m = 3, (x + iy)^3
+    let c3 = x * c2 - y * s2;
+    let s3 = x * s2 + y * c2;
+    let q3_3 = 0.5900435899266436;
+    let q4_3 = 1.770130769779931 * z;
+    let q5_3 = 2.48746859276655 * z * q4_3 - 0.82915619758885 * q3_3;
+
+    // m = 4, (x + iy)^4
+    let c4 = x * c3 - y * s3;
+    let s4 = x * s3 + y * c3;
+    let q4_4 = 0.6258357354491763;
+    let q5_4 = 2.0756623148810416 * z;
+
+    // m = 5, (x + iy)^5
+    let c5 = x * c4 - y * s4;
+    let s5 = x * s4 + y * c4;
+    let q5_5 = 0.6563820568401703;
+
+    return array<f32, 36>(
+        // band 0
+        q0_0,
+        // band 1
+        q1_1 * s1,
+        q1_0,
+        q1_1 * c1,
+        // band 2
+        q2_2 * s2,
+        q2_1 * s1,
+        q2_0,
+        q2_1 * c1,
+        q2_2 * c2,
+        // band 3
+        q3_3 * s3,
+        q3_2 * s2,
+        q3_1 * s1,
+        q3_0,
+        q3_1 * c1,
+        q3_2 * c2,
+        q3_3 * c3,
+        // band 4
+        q4_4 * s4,
+        q4_3 * s3,
+        q4_2 * s2,
+        q4_1 * s1,
+        q4_0,
+        q4_1 * c1,
+        q4_2 * c2,
+        q4_3 * c3,
+        q4_4 * c4,
+        // band 5
+        q5_5 * s5,
+        q5_4 * s4,
+        q5_3 * s3,
+        q5_2 * s2,
+        q5_1 * s1,
+        q5_0,
+        q5_1 * c1,
+        q5_2 * c2,
+        q5_3 * c3,
+        q5_4 * c4,
+        q5_5 * c5
+    );
+}
+`);