reze-engine 0.68.8 → 0.68.9

package/dist/shaders/materials/common.d.ts

@@ -1,3 +1,9 @@
+/** The jelly eyes' vertex move (jelly-eyes.ts). Every pass that places model
+ *  vertices takes it, or a pass that skips it draws the iris where it was —
+ *  the shadow map then shades half the moved iris with its own unmoved copy.
+ *  Reads `objectLight.jelly` and `material.materialId`, which the including
+ *  module declares. */
+export declare const JELLY_VERTEX_WGSL = "\nfn _rzJellyTurn(q: vec2f, a: f32) -> vec2f {\n  let c = cos(a);\n  let s = sin(a);\n  return vec2f(c * q.x - s * q.y, s * q.x + c * q.y);\n}\n\n/**\n * Where the jelly puts an iris vertex. The iris is the part of the eye the eye\n * bones carry, so it is moved as a whole, in bind space before skinning:\n * scaled about its centre (the CPU composes the blink's spring, the lid's\n * press and her motion's knock into one scale), turned and drifted a hair on\n * the spring, brought forward a hair, and rolled about the eye bone with a\n * closing expression \u2014 inside the white, which stays where it is. A highlight\n * layer (this draw's material is one of jelly[1].w's) takes the iris's move,\n * then its own scale, turn and tremble, before the roll. Vertices take it by their weight on the eye bones\n * (jelly[2].w, jelly[3].w), so nothing else on the face moves.\n */\nfn rzJellyVertex(p: vec3f, joints: vec4<u32>, nw: vec4f) -> vec3f {\n  let j = objectLight.jelly;\n  let ids = u32(j[1].w);\n  let mid = u32(material.materialId);\n  let hl = mid > 0u && (mid == (ids & 4095u) || mid == (ids >> 12u));\n  var out = p;\n  for (var e = 0u; e < 2u; e++) {\n    let bone = j[2u + e].w;\n    if (bone < 0.0) { continue; }\n    let b = u32(bone);\n    let w = dot(nw, select(vec4f(0.0), vec4f(1.0), joints == vec4<u32>(b)));\n    if (w <= 0.0) { continue; }\n    let c = j[e].xyz;\n    // A rig that carries both eyes on one bone: each vertex follows its own side.\n    if (j[2].w == j[3].w && e == 0u && distance(p.xy, j[1].xy) < distance(p.xy, j[0].xy)) { continue; }\n    if (j[2].w == j[3].w && e == 1u && distance(p.xy, j[0].xy) <= distance(p.xy, j[1].xy)) { continue; }\n    let t = j[4u + e];\n    let m = j[6u + e];\n    let h = j[10u + e];\n    var q = _rzJellyTurn((p.xy - c.xy) * t.xy, t.z) + m.xy;\n    // Forward is \u2212Z (MMD faces \u2212Z).\n    var push = h.z;\n    if (hl) {\n      // Sliding over the iris's dome on its own, a highlight sheet a hair in\n      // front of it would sink into it where the dome bulges more and the two\n      // fight for depth; so it comes forward by as far as it slid \u2014 a slope of\n      // one, steeper than the dome anywhere it draws.\n      let before = q;\n      q = _rzJellyTurn(q * h.xy, t.w) + m.zw;\n      push += length(q - before);\n    }\n    var moved = vec3f(c.xy + q, p.z - push);\n    let roll = j[8u + e];\n    if (roll.w != 0.0) {\n      let d = moved - roll.xyz;\n      let rd = _rzJellyTurn(d.yz, roll.w);\n      moved = roll.xyz + vec3f(d.x, rd.x, rd.y);\n    }\n    out = mix(p, moved, w);\n  }\n  return out;\n}\n";
 export declare const COMMON_BINDINGS_WGSL: string;
 export declare function commonFsOutWgsl(): string;
 /**

package/dist/shaders/materials/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/shaders/materials/common.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,oBAAoB,QA2ThC,CAAC;AAwHF,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,orMAgHzB,CAAA;AAQD,eAAO,MAAM,4BAA4B,QAC6H,CAAA"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/shaders/materials/common.ts"],"names":[],"mappings":"AA4BA;;;;uBAIuB;AACvB,eAAO,MAAM,iBAAiB,8iFA4D7B,CAAA;AAED,eAAO,MAAM,oBAAoB,QAgQhC,CAAC;AAwHF,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,orMAgHzB,CAAA;AAQD,eAAO,MAAM,4BAA4B,QAC6H,CAAA"}

package/dist/shaders/materials/common.js

@@ -23,6 +23,72 @@ import { WORLD_AMBIENT_WGSL } from "../lights";
 //   group(0): per-frame scene (camera, lights, shadow map, BRDF LUT via nodes.ts)
 //   group(1): per-model skinning
 //   group(2): per-material (diffuse texture + material uniforms)
+/** The jelly eyes' vertex move (jelly-eyes.ts). Every pass that places model
+ *  vertices takes it, or a pass that skips it draws the iris where it was —
+ *  the shadow map then shades half the moved iris with its own unmoved copy.
+ *  Reads `objectLight.jelly` and `material.materialId`, which the including
+ *  module declares. */
+export const JELLY_VERTEX_WGSL = /* wgsl */ `
+fn _rzJellyTurn(q: vec2f, a: f32) -> vec2f {
+  let c = cos(a);
+  let s = sin(a);
+  return vec2f(c * q.x - s * q.y, s * q.x + c * q.y);
+}
+
+/**
+ * Where the jelly puts an iris vertex. The iris is the part of the eye the eye
+ * bones carry, so it is moved as a whole, in bind space before skinning:
+ * scaled about its centre (the CPU composes the blink's spring, the lid's
+ * press and her motion's knock into one scale), turned and drifted a hair on
+ * the spring, brought forward a hair, and rolled about the eye bone with a
+ * closing expression — inside the white, which stays where it is. A highlight
+ * layer (this draw's material is one of jelly[1].w's) takes the iris's move,
+ * then its own scale, turn and tremble, before the roll. Vertices take it by their weight on the eye bones
+ * (jelly[2].w, jelly[3].w), so nothing else on the face moves.
+ */
+fn rzJellyVertex(p: vec3f, joints: vec4<u32>, nw: vec4f) -> vec3f {
+  let j = objectLight.jelly;
+  let ids = u32(j[1].w);
+  let mid = u32(material.materialId);
+  let hl = mid > 0u && (mid == (ids & 4095u) || mid == (ids >> 12u));
+  var out = p;
+  for (var e = 0u; e < 2u; e++) {
+    let bone = j[2u + e].w;
+    if (bone < 0.0) { continue; }
+    let b = u32(bone);
+    let w = dot(nw, select(vec4f(0.0), vec4f(1.0), joints == vec4<u32>(b)));
+    if (w <= 0.0) { continue; }
+    let c = j[e].xyz;
+    // A rig that carries both eyes on one bone: each vertex follows its own side.
+    if (j[2].w == j[3].w && e == 0u && distance(p.xy, j[1].xy) < distance(p.xy, j[0].xy)) { continue; }
+    if (j[2].w == j[3].w && e == 1u && distance(p.xy, j[0].xy) <= distance(p.xy, j[1].xy)) { continue; }
+    let t = j[4u + e];
+    let m = j[6u + e];
+    let h = j[10u + e];
+    var q = _rzJellyTurn((p.xy - c.xy) * t.xy, t.z) + m.xy;
+    // Forward is −Z (MMD faces −Z).
+    var push = h.z;
+    if (hl) {
+      // Sliding over the iris's dome on its own, a highlight sheet a hair in
+      // front of it would sink into it where the dome bulges more and the two
+      // fight for depth; so it comes forward by as far as it slid — a slope of
+      // one, steeper than the dome anywhere it draws.
+      let before = q;
+      q = _rzJellyTurn(q * h.xy, t.w) + m.zw;
+      push += length(q - before);
+    }
+    var moved = vec3f(c.xy + q, p.z - push);
+    let roll = j[8u + e];
+    if (roll.w != 0.0) {
+      let d = moved - roll.xyz;
+      let rd = _rzJellyTurn(d.yz, roll.w);
+      moved = roll.xyz + vec3f(d.x, rd.x, rd.y);
+    }
+    out = mix(p, moved, w);
+  }
+  return out;
+}
+`;
 export const COMMON_BINDINGS_WGSL = /* wgsl */ `
 
 struct CameraUniforms {
@@ -231,66 +297,7 @@ fn _rzCastShadow(wp: vec3f) -> f32 {
 struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9>, fill: vec4f, jelly: array<vec4f, 12> }
 @group(1) @binding(1) var<uniform> objectLight: ObjectLight;
 
-fn _rzJellyTurn(q: vec2f, a: f32) -> vec2f {
-  let c = cos(a);
-  let s = sin(a);
-  return vec2f(c * q.x - s * q.y, s * q.x + c * q.y);
-}
-
-/**
- * Where the jelly puts an iris vertex. The iris is the part of the eye the eye
- * bones carry, so it is moved as a whole, in bind space before skinning:
- * scaled about its centre (the CPU composes the blink's spring, the lid's
- * press and her motion's knock into one scale), turned and drifted a hair on
- * the spring, brought forward a hair, and rolled about the eye bone with a
- * closing expression — inside the white, which stays where it is. A highlight
- * layer (this draw's material is one of jelly[1].w's) takes the iris's move,
- * then its own scale, turn and tremble, before the roll. Vertices take it by their weight on the eye bones
- * (jelly[2].w, jelly[3].w), so nothing else on the face moves.
- */
-fn rzJellyVertex(p: vec3f, joints: vec4<u32>, nw: vec4f) -> vec3f {
-  let j = objectLight.jelly;
-  let ids = u32(j[1].w);
-  let mid = u32(material.materialId);
-  let hl = mid > 0u && (mid == (ids & 4095u) || mid == (ids >> 12u));
-  var out = p;
-  for (var e = 0u; e < 2u; e++) {
-    let bone = j[2u + e].w;
-    if (bone < 0.0) { continue; }
-    let b = u32(bone);
-    let w = dot(nw, select(vec4f(0.0), vec4f(1.0), joints == vec4<u32>(b)));
-    if (w <= 0.0) { continue; }
-    let c = j[e].xyz;
-    // A rig that carries both eyes on one bone: each vertex follows its own side.
-    if (j[2].w == j[3].w && e == 0u && distance(p.xy, j[1].xy) < distance(p.xy, j[0].xy)) { continue; }
-    if (j[2].w == j[3].w && e == 1u && distance(p.xy, j[0].xy) <= distance(p.xy, j[1].xy)) { continue; }
-    let t = j[4u + e];
-    let m = j[6u + e];
-    let h = j[10u + e];
-    var q = _rzJellyTurn((p.xy - c.xy) * t.xy, t.z) + m.xy;
-    // Forward is −Z (MMD faces −Z).
-    var push = h.z;
-    if (hl) {
-      // Sliding over the iris's dome on its own, a highlight sheet a hair in
-      // front of it would sink into it where the dome bulges more and the two
-      // fight for depth; so it comes forward by as far as it slid — a slope of
-      // one, steeper than the dome anywhere it draws.
-      let before = q;
-      q = _rzJellyTurn(q * h.xy, t.w) + m.zw;
-      push += length(q - before);
-    }
-    var moved = vec3f(c.xy + q, p.z - push);
-    let roll = j[8u + e];
-    if (roll.w != 0.0) {
-      let d = moved - roll.xyz;
-      let rd = _rzJellyTurn(d.yz, roll.w);
-      moved = roll.xyz + vec3f(d.x, rd.x, rd.y);
-    }
-    out = mix(p, moved, w);
-  }
-  return out;
-}
-
+${JELLY_VERTEX_WGSL}
 /** The light arriving at a surface of this object facing n: its own ambient
  *  where loaded data gave it one (a stage's probes, a character's), else the
  *  world's. The same polynomial rzWorldAmbient evaluates. */

package/dist/shaders/passes/depth-prepass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"depth-prepass.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/depth-prepass.ts"],"names":[],"mappings":"AAgCA,wBAAgB,2BAA2B,IAAI,MAAM,CA0FpD"}
+{"version":3,"file":"depth-prepass.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/depth-prepass.ts"],"names":[],"mappings":"AAgCA,wBAAgB,2BAA2B,IAAI,MAAM,CAkGpD"}

package/dist/shaders/passes/depth-prepass.js

@@ -26,7 +26,7 @@
 // one: the fragment outputs below depend on whether the device carries the id
 // attachment, and that answer does not exist at import time. The constant could
 // not have taken the outputs at all, which is most of why it did not have them.
-import { DISSOLVE_WGSL } from "../materials/common";
+import { DISSOLVE_WGSL, JELLY_VERTEX_WGSL } from "../materials/common";
 import { sceneFsOutWgsl, sceneIdPadWgsl } from "./scene-contract";
 export function transparentDepthPrepassWgsl() {
     return /* wgsl */ `
@@ -42,13 +42,20 @@ struct MaterialUniforms {
   alpha: f32,
   _skip0: vec4f,
   _skip1: vec4f,
-  _skip2: vec3f,
+  _skip2: f32,
+  materialId: f32,
+  _skip3: f32,
   dissolve: f32,
 };
 
 @group(0) @binding(0) var<uniform> camera: CameraUniforms;
 @group(0) @binding(2) var diffuseSampler: sampler;
 @group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
+// The model's ObjectLight, for its jelly eyes: depth goes down where the colour
+// pass will draw the iris.
+struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9>, fill: vec4f, jelly: array<vec4f, 12> }
+@group(1) @binding(1) var<uniform> objectLight: ObjectLight;
+${JELLY_VERTEX_WGSL}
 @group(2) @binding(0) var diffuseTexture: texture_2d<f32>;
 @group(2) @binding(1) var<uniform> material: MaterialUniforms;
 
@@ -72,10 +79,11 @@ struct VSOut {
   @location(3) joints0: vec4<u32>,
   @location(4) weights0: vec4<f32>,
 ) -> VSOut {
-  let pos4 = vec4f(position, 1.0);
   let weightSum = weights0.x + weights0.y + weights0.z + weights0.w;
   let invWeightSum = select(1.0, 1.0 / weightSum, weightSum > 0.0001);
   let w = select(vec4f(1.0, 0.0, 0.0, 0.0), weights0 * invWeightSum, weightSum > 0.0001);
+  var pos4 = vec4f(position, 1.0);
+  if (objectLight.jelly[0].w > 0.0) { pos4 = vec4f(rzJellyVertex(position, joints0, w), 1.0); }
   var skinned = vec4f(0.0);
   for (var i = 0u; i < 4u; i++) {
     skinned += (skinMats[joints0[i]] * pos4) * w[i];

package/dist/shaders/passes/field-blit.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The field layer, drawn INTO the scene.
+ *
+ * Field effects render into their own targets at their own resolution — that
+ * part was always right. What was wrong was where the result landed: the
+ * composite sampled it AFTER tone mapping, which is why a field effect could
+ * never bloom, could never light anything, and tone mapped differently from the
+ * particle and ribbon mounts drawing the same kind of glow.
+ *
+ * Two draws inside the scene pass — background before any geometry, foreground
+ * after all of it — so the bloom pyramid sees field effects and one tone map
+ * covers the whole frame.
+ *
+ * NO DEPTH, neither written nor tested. A foreground is handed the scene's
+ * depth as a parameter and does its own occlusion; testing it here would
+ * occlude it a second time, and a background has nothing to test against.
+ *
+ * COVERAGE IS CLAMPED HERE. Additive field effects SUM their coverage into the
+ * layer (see FIELD_LAYER_BLEND_ADDITIVE), which is what stops the composite's
+ * unpremultiply from dividing colour by nothing — but N additive effects can
+ * sum past 1, and the layer is rgba16float so nothing stopped it on the way in.
+ * A coverage above 1 would darken what the layer is drawn over by more than
+ * fully covering it.
+ */
+export declare function fieldBlitShaderWgsl(): string;
+//# sourceMappingURL=field-blit.d.ts.map

package/dist/shaders/passes/field-blit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-blit.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/field-blit.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAuC5C"}

package/dist/shaders/passes/field-blit.js

@@ -0,0 +1,65 @@
+import { sceneFsOutWgsl } from "./scene-contract";
+/**
+ * The field layer, drawn INTO the scene.
+ *
+ * Field effects render into their own targets at their own resolution — that
+ * part was always right. What was wrong was where the result landed: the
+ * composite sampled it AFTER tone mapping, which is why a field effect could
+ * never bloom, could never light anything, and tone mapped differently from the
+ * particle and ribbon mounts drawing the same kind of glow.
+ *
+ * Two draws inside the scene pass — background before any geometry, foreground
+ * after all of it — so the bloom pyramid sees field effects and one tone map
+ * covers the whole frame.
+ *
+ * NO DEPTH, neither written nor tested. A foreground is handed the scene's
+ * depth as a parameter and does its own occlusion; testing it here would
+ * occlude it a second time, and a background has nothing to test against.
+ *
+ * COVERAGE IS CLAMPED HERE. Additive field effects SUM their coverage into the
+ * layer (see FIELD_LAYER_BLEND_ADDITIVE), which is what stops the composite's
+ * unpremultiply from dividing colour by nothing — but N additive effects can
+ * sum past 1, and the layer is rgba16float so nothing stopped it on the way in.
+ * A coverage above 1 would darken what the layer is drawn over by more than
+ * fully covering it.
+ */
+export function fieldBlitShaderWgsl() {
+    return /* wgsl */ `
+@group(0) @binding(0) var _rzLayer: texture_2d<f32>;
+@group(0) @binding(1) var _rzLayerSamp: sampler;
+// (bloom, _, fullW, fullH). The size is the SCENE target's, not the layer's:
+// the layer is often half resolution, and normalised uv is what makes that
+// invisible.
+@group(0) @binding(2) var<uniform> _rzBlitU: vec4f;
+
+@vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
+  let x = f32((vi & 1u) << 2u) - 1.0;
+  let y = f32((vi & 2u) << 1u) - 1.0;
+  return vec4f(x, y, 0.0, 1.0);
+}
+
+${sceneFsOutWgsl()}
+@fragment fn fs(@builtin(position) fragCoord: vec4f) -> FSOut {
+  var out: FSOut;
+  // Bilinear, because the layer is usually half resolution and the whole point
+  // of that choice is that low-frequency effects upsample invisibly.
+  let uv = fragCoord.xy / max(_rzBlitU.zw, vec2f(1.0));
+  let c = textureSampleLevel(_rzLayer, _rzLayerSamp, uv, 0.0);
+  let cov = clamp(c.a, 0.0, 1.0);
+  // PREMULTIPLIED, and blitted with a premultiplied-over blend — the field
+  // targets have been premultiplied since N effects had to compose into them
+  // associatively. Handing this to the material blend would scale rgb by alpha
+  // a second time and every layer would come out dark.
+  out.color = vec4f(max(c.rgb, vec3f(0.0)), cov);
+  // The aux target: bloom mask, then coverage. THIS is what finally makes
+  // // @bloom mean something on a field effect — the flag has been parsed and
+  // ignored for every mount but particles and ribbons, which is the kind of
+  // author-surface lie the install-time guards exist to kill.
+  //
+  // The mask is written UNWEIGHTED and the blend weights it by src.a — the
+  // convention the materials already follow (they write vec4f(1, 1, 0, alpha)).
+  out.mask = vec4f(_rzBlitU.x, 1.0, 0.0, cov);
+  return out;
+}
+`;
+}

package/dist/shaders/passes/ghosts.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Afterimages — the cast drawn again at the poses it held a moment ago.
+ *
+ * The VERTEX stage is the material one, unchanged: a ghost is the same mesh
+ * skinned by different matrices, and the engine binds a slot of its pose
+ * history where the live skinning matrices would be. Only the fragment is new.
+ *
+ * What a ghost looks like is Elden Ring's phantom: a body you can nearly see
+ * through, drawn by its EDGES. Three of them, all in the tint — the rim where
+ * the surface turns away (the silhouette), and inside it the lines a drawing
+ * would have: where the texture's brightness changes sharply from one pixel to
+ * the next (painted seams, trim, straps) and where the surface itself folds
+ * (the normal turning fast across a pixel). The body under them is the
+ * surface's own colour mixed toward the tint by a dial, at its own opacity.
+ *
+ * Built at first use rather than at import: the output struct depends on
+ * whether the device carries the id attachment, which is probed at init.
+ */
+/** One rank's uniforms, at a 256-byte stride for the dynamic offset. */
+export declare const GHOST_UNIFORM_STRIDE = 256;
+export declare function ghostShaderWgsl(): string;
+//# sourceMappingURL=ghosts.d.ts.map

package/dist/shaders/passes/ghosts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ghosts.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ghosts.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AAEH,wEAAwE;AACxE,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAEvC,wBAAgB,eAAe,IAAI,MAAM,CAqDxC"}

package/dist/shaders/passes/ghosts.js

@@ -0,0 +1,75 @@
+import { NODES_WGSL } from "../materials/nodes";
+import { COMMON_MATERIAL_PRELUDE_WGSL, DISSOLVE_WGSL, commonFsOutWgsl } from "../materials/common";
+import { sceneIdPadWgsl } from "./scene-contract";
+/**
+ * Afterimages — the cast drawn again at the poses it held a moment ago.
+ *
+ * The VERTEX stage is the material one, unchanged: a ghost is the same mesh
+ * skinned by different matrices, and the engine binds a slot of its pose
+ * history where the live skinning matrices would be. Only the fragment is new.
+ *
+ * What a ghost looks like is Elden Ring's phantom: a body you can nearly see
+ * through, drawn by its EDGES. Three of them, all in the tint — the rim where
+ * the surface turns away (the silhouette), and inside it the lines a drawing
+ * would have: where the texture's brightness changes sharply from one pixel to
+ * the next (painted seams, trim, straps) and where the surface itself folds
+ * (the normal turning fast across a pixel). The body under them is the
+ * surface's own colour mixed toward the tint by a dial, at its own opacity.
+ *
+ * Built at first use rather than at import: the output struct depends on
+ * whether the device carries the id attachment, which is probed at init.
+ */
+/** One rank's uniforms, at a 256-byte stride for the dynamic offset. */
+export const GHOST_UNIFORM_STRIDE = 256;
+export function ghostShaderWgsl() {
+    return (NODES_WGSL +
+        COMMON_MATERIAL_PRELUDE_WGSL +
+        commonFsOutWgsl() +
+        DISSOLVE_WGSL +
+        /* wgsl */ `
+struct GhostU {
+  tint: vec3f,
+  tintMix: f32,
+  alpha: f32,
+  glow: f32,
+  lines: f32,
+  body: f32,
+}
+@group(3) @binding(0) var<uniform> ghost: GhostU;
+
+@fragment fn fsGhost(input: VertexOutput) -> FSOut {
+  let tex = textureSample(diffuseTexture, diffuseSampler, input.uv);
+  let base = tex.rgb * material.diffuseColor;
+  let n = safe_normal(input.normal);
+  // Derivatives BEFORE the discard below: they need every pixel of the quad.
+  let lum = dot(base, vec3f(0.2126, 0.7152, 0.0722));
+  let detail = smoothstep(0.02, 0.12, fwidth(lum));
+  let crease = smoothstep(0.08, 0.35, length(fwidth(n)));
+  let cover = material.alpha * tex.a;
+  // Cutouts stay cut: lace and hair cards would otherwise ghost as solid cards.
+  if (cover < 0.1) { discard; }
+  let v = normalize(camera.viewPos - input.worldPos);
+  let turn = 1.0 - abs(dot(n, v));
+  let rim = turn * turn * turn;
+  let edge = rim * ghost.glow + max(detail, crease) * ghost.lines;
+  // The dial arrives as the picked #rrggbb scaled to 0..1 — sRGB. Decoded, so
+  // the colour mixed with the linear surface and added as light is the colour
+  // that was picked.
+  let tint = pow(ghost.tint, vec3f(2.2));
+  let rgb = mix(base, tint, ghost.tintMix) * ghost.body + tint * edge;
+  let a = clamp(ghost.alpha * cover * (ghost.body + edge), 0.0, 1.0);
+  var out: FSOut;
+  out.color = vec4f(rgb, a);
+  out.mask = vec4f(1.0, 1.0, 0.0, a);
+${sceneIdPadWgsl("out")}  return out;
+}
+
+// The cast mark writes stencil only; this satisfies the pass's attachments.
+@fragment fn fsGhostMark(input: VertexOutput) -> FSOut {
+  var out: FSOut;
+  out.color = vec4f(0.0);
+  out.mask = vec4f(0.0);
+${sceneIdPadWgsl("out")}  return out;
+}
+`);
+}

package/dist/shaders/passes/ground-noise.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The tile as 8-bit luminance, plus its mip chain (box-filtered, which is exact
+ * for a repeating texture). Mips are the point as much as the speed: procedural
+ * noise has no mip chain, so at grazing angles it shimmered.
+ */
+export declare function buildGroundNoiseMips(): Uint8Array[];
+//# sourceMappingURL=ground-noise.d.ts.map

package/dist/shaders/passes/ground-noise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ground-noise.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground-noise.ts"],"names":[],"mappings":"AAkDA;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,UAAU,EAAE,CAsCnD"}

package/dist/shaders/passes/ground-noise.js

@@ -0,0 +1,88 @@
+// Bakes the ground's frosted micro-texture into a seamless, mipmapped tile.
+//
+// The shader used to evaluate four octaves of value noise per pixel — sixteen
+// hash rounds — and the ground covers the entire screen as soon as the camera
+// tilts toward the horizon. This produces the same character of pattern once, at
+// load, so the fragment shader pays one filtered fetch instead.
+//
+// SEAMLESS BY CONSTRUCTION. The original hash was not periodic, so a finite
+// crop of it could never tile. Here every octave's lattice wraps at a whole
+// number of cells across the tile, which makes the result repeat exactly at the
+// edges. The pattern is therefore not pixel-identical to the analytic version —
+// it is the same kind of noise, not the same noise. At the default strength of
+// 0.05 it modulates brightness by ±2.5%, where the repeat is not findable by eye.
+import { GROUND_NOISE_RES, GROUND_NOISE_TILE_WORLD } from "./ground";
+/** Lattice cells across the tile at octave 0. The analytic version sampled fbm
+ *  at worldXZ × 3, so a tile spanning 8 world units covers 24 base cells — the
+ *  same spatial frequency the surface had before. */
+const BASE_CELLS = GROUND_NOISE_TILE_WORLD * 3;
+const OCTAVES = 4;
+/** Deterministic lattice hash. Integer coordinates are wrapped by the caller,
+ *  which is what makes the tile seamless. */
+function hash(ix, iy) {
+    let h = Math.imul(ix, 374761393) + Math.imul(iy, 668265263);
+    h = Math.imul(h ^ (h >>> 13), 1274126177);
+    return ((h ^ (h >>> 16)) >>> 0) / 4294967296;
+}
+/** Value noise on a lattice that repeats every `period` cells. */
+function periodicValueNoise(x, y, period) {
+    const ix = Math.floor(x);
+    const iy = Math.floor(y);
+    const fx = x - ix;
+    const fy = y - iy;
+    // Smoothstep weights — same curve the WGSL used.
+    const ux = fx * fx * (3 - 2 * fx);
+    const uy = fy * fy * (3 - 2 * fy);
+    const x0 = ((ix % period) + period) % period;
+    const y0 = ((iy % period) + period) % period;
+    const x1 = (x0 + 1) % period;
+    const y1 = (y0 + 1) % period;
+    const a = hash(x0, y0);
+    const b = hash(x1, y0);
+    const c = hash(x0, y1);
+    const d = hash(x1, y1);
+    return (a + (b - a) * ux) * (1 - uy) + (c + (d - c) * ux) * uy;
+}
+/**
+ * The tile as 8-bit luminance, plus its mip chain (box-filtered, which is exact
+ * for a repeating texture). Mips are the point as much as the speed: procedural
+ * noise has no mip chain, so at grazing angles it shimmered.
+ */
+export function buildGroundNoiseMips() {
+    const levels = [];
+    const res = GROUND_NOISE_RES;
+    const base = new Uint8Array(res * res);
+    for (let py = 0; py < res; py++) {
+        for (let px = 0; px < res; px++) {
+            // Texel centre, in units of octave-0 lattice cells.
+            const x = ((px + 0.5) / res) * BASE_CELLS;
+            const y = ((py + 0.5) / res) * BASE_CELLS;
+            let v = 0;
+            let amp = 0.5;
+            let freq = 1;
+            for (let o = 0; o < OCTAVES; o++) {
+                v += amp * periodicValueNoise(x * freq, y * freq, BASE_CELLS * freq);
+                freq *= 2;
+                amp *= 0.5;
+            }
+            base[py * res + px] = Math.max(0, Math.min(255, Math.round(v * 255)));
+        }
+    }
+    levels.push(base);
+    let src = base;
+    let size = res;
+    while (size > 1) {
+        const half = size >> 1;
+        const dst = new Uint8Array(half * half);
+        for (let y = 0; y < half; y++) {
+            for (let x = 0; x < half; x++) {
+                const s = y * 2 * size + x * 2;
+                dst[y * half + x] = (src[s] + src[s + 1] + src[s + size] + src[s + size + 1] + 2) >> 2;
+            }
+        }
+        levels.push(dst);
+        src = dst;
+        size = half;
+    }
+    return levels;
+}

package/dist/shaders/passes/shadow.d.ts

@@ -1,2 +1,2 @@
-export declare const SHADOW_DEPTH_SHADER_WGSL = "\n\n/** Clump size, in object-space units \u2014 MMD's are roughly centimetres.\n *\n *  Raised from 0.42: at that size the pieces are near enough to speckle that a\n *  departure reads as a fade rather than as a body coming apart, which is the\n *  thing the clumping exists to avoid. Hand-sized pieces are visible ones. */\nconst RZ_DISSOLVE_GRAIN: f32 = 1.2;\n/** How much the clumps pull a fragment off its own grit value \u2014 the whole of\n *  the LOOK, and none of the rate. See rz_dissolve_threshold. */\nconst RZ_DISSOLVE_CLUMP: f32 = 0.6;\n/** Grit cell, as a fraction of a clump. See rz_dissolve_threshold: this is what\n *  keeps a material SMALLER than a clump from having one threshold for all of\n *  it, and it has to be smaller than the SMALLEST material a model carries \u2014\n *  an eye highlight, a button, a buckle \u2014 not merely small. Two and a half\n *  millimetres on a normal model, which is under all of them. */\nconst RZ_DISSOLVE_GRIT: f32 = 0.021;\n/** How wide the glowing front is, in threshold units. Thin: the front is a\n *  rim, and a wide one lights whole limbs at once. */\nconst RZ_DISSOLVE_EDGE: f32 = 0.11;\n/** What the front burns with. Emission, added after lighting and after the\n *  graph \u2014 a colour that ramps or takes a shadow reads as paint, not as heat.\n *  Above 1 on purpose: it is meant to reach the bloom pyramid. Blue-violet,\n *  the same light the motes leaving her are drawn and lit with. */\nconst RZ_BURN_COLOR: vec3f = vec3f(0.45, 0.62, 2.40);\n\nfn rz_dissolve_hash(p: vec3f) -> f32 {\n  // INTEGER, for exactly the reason _hash33 in nodes.ts is, and its comment\n  // says it: above 24 bits an f32 loses the low ones. The float hash this\n  // replaces multiplied three terms into the hundreds of millions and took\n  // fract() of the product \u2014 which past 2^24 is not noise, it is a quantised\n  // staircase, and wherever that staircase landed on zero the threshold was\n  // zero. A surface whose threshold is zero never crosses it: it stays behind\n  // while the rest of her leaves, and it sits inside the burning front the\n  // whole time she is gone. Those were the white pieces that would not go.\n  //\n  // Floored first, unlike _hash33: vec3i() truncates toward zero, so -0.5 and\n  // +0.5 are the same cell, and half this model is at negative x.\n  var h = vec3u(vec3i(floor(p)) + vec3i(32768));\n  h = h * vec3u(1664525u, 1013904223u, 2654435761u);\n  h = (h.yzx ^ h) * vec3u(2246822519u, 3266489917u, 668265263u);\n  h = h ^ (h >> vec3u(16u));\n  return f32((h.x ^ h.y ^ h.z) & 16777215u) * (1.0 / 16777216.0);\n}\n\n/** Value noise over that hash \u2014 smooth within a flake, uncorrelated between. */\nfn rz_dissolve_field(p: vec3f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  let c000 = rz_dissolve_hash(i);\n  let c100 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 0.0));\n  let c010 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 0.0));\n  let c110 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 0.0));\n  let c001 = rz_dissolve_hash(i + vec3f(0.0, 0.0, 1.0));\n  let c101 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 1.0));\n  let c011 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 1.0));\n  let c111 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 1.0));\n  let x00 = mix(c000, c100, u.x);\n  let x10 = mix(c010, c110, u.x);\n  let x01 = mix(c001, c101, u.x);\n  let x11 = mix(c011, c111, u.x);\n  return mix(mix(x00, x10, u.y), mix(x01, x11, u.y), u.z);\n}\n\n/**\n * The threshold this fragment is measured against.\n *\n * NOISE ALONE, so the whole body comes apart at once \u2014 a hand, a shoulder and\n * an ankle all thinning together rather than a line travelling up her. It was\n * tilted by height at first, on the argument that a sweep reads as something\n * happening TO her; what it actually reads as is a wipe, and a wipe has a\n * direction, an edge and a speed the rest of the effect knows nothing about.\n * Everywhere at once is also the honest match for what leaves: the motes are\n * shed from every limb in the same breath.\n *\n * TWO SCALES. Clumps alone meant every fragment of a material SMALLER than one\n * cell shared a single threshold: an eye highlight, a brow, a button, a hair\n * clip. All of it sat inside the glowing front at once, so the piece flashed\n * white as a whole and then popped \u2014 the two things a disintegration must never\n * do. The grit is a per-cell hash at a fraction of the clump, so a part a few\n * millimetres across still comes apart in pieces.\n *\n * THE GRIT IS THE BASE, though, and the clumps only push a fragment off it.\n * That ordering is what makes the dissolve smooth, and it is not obvious: the\n * two used to be WEIGHTED AND ADDED, and a sum is not uniformly distributed\n * however uniform each half is. It piles up in the middle, so most of the\n * surface had a threshold near a half \u2014 all of it went as the dissolve swept\n * through the middle, and what remained was the thin tail near zero. That tail\n * was the second stage everyone could see: a body that mostly vanished, then a\n * scatter of glowing scraps, then nothing.\n *\n * WRAPPED, not added. Offsetting a uniform value and taking fract() leaves it\n * EXACTLY uniform, where scaling a sum back into range only flattens the middle\n * \u2014 measured over four hundred thousand samples, the sum removed 12% of her per\n * step at the halfway mark and 0.1% at each end (a 110x swing), the scaled sum\n * still swung 89x, and the wrap is flat: 5.0% per step from the first flake to\n * the last, a ratio of 1.0.\n *\n * That flatness IS the smoothness. An uneven rate is what produced the two\n * stages you could see \u2014 a body that mostly vanished at once, then a scatter of\n * scraps that took as long again to follow.\n *\n * The clumping survives the wrap: neighbouring fragments share a clump value,\n * so the offset moves them together. What wraps past 1 comes back at 0 and goes\n * at the other end instead, which costs a little speckle in a region and buys\n * an even rate everywhere.\n */\nfn rz_dissolve_threshold(restPos: vec3f) -> f32 {\n  let grit = rz_dissolve_hash(floor(restPos / (RZ_DISSOLVE_GRAIN * RZ_DISSOLVE_GRIT)));\n  let clump = rz_dissolve_field(restPos / RZ_DISSOLVE_GRAIN) - 0.5;\n  return fract(grit + clump * RZ_DISSOLVE_CLUMP);\n}\n\nstruct LightVP { viewProj: mat4x4f, };\n@group(0) @binding(0) var<uniform> lp: LightVP;\n@group(0) @binding(1) var<storage, read> skinMats: array<mat4x4f>;\n@group(0) @binding(2) var texSampler: sampler;\n@group(1) @binding(0) var diffuseTexture: texture_2d<f32>;\n// The head of the material block and the one field at its tail \u2014 the same\n// reach the depth prepass takes, and for the same reason: a shadow cast by a\n// body that is no longer drawn is the tell that the vanishing is a trick.\nstruct MaterialDiffuse {\n  diffuse: vec4f,\n  _skip0: vec4f,\n  _skip1: vec4f,\n  _skip2: vec3f,\n  dissolve: f32,\n};\n@group(1) @binding(1) var<uniform> material: MaterialDiffuse;\n\nstruct VSOut {\n  @builtin(position) position: vec4f,\n  @location(0) uv: vec2f,\n  /** Bind-pose position, for the dissolve test \u2014 object space, as everywhere. */\n  @location(1) restPos: vec3f,\n  /** The triangle's own threshold, flat \u2014 see the material VertexOutput. A\n   *  face that is gone must stop casting, and stop as a whole face. */\n  @location(2) @interpolate(flat) faceT: f32,\n};\n\n@vertex fn vs(@location(0) position: vec3f, @location(1) normal: vec3f, @location(2) uv: vec2f,\n  @location(3) joints0: vec4<u32>, @location(4) weights0: vec4<f32>) -> VSOut {\n  let pos4 = vec4f(position, 1.0);\n  let ws = weights0.x + weights0.y + weights0.z + weights0.w;\n  let inv = select(1.0, 1.0 / ws, ws > 0.0001);\n  let nw = select(vec4f(1.0,0.0,0.0,0.0), weights0 * inv, ws > 0.0001);\n  var sp = vec4f(0.0);\n  for (var i = 0u; i < 4u; i++) { sp += (skinMats[joints0[i]] * pos4) * nw[i]; }\n  var out: VSOut;\n  out.position = lp.viewProj * vec4f(sp.xyz, 1.0);\n  out.uv = uv;\n  out.restPos = position;\n  out.faceT = rz_dissolve_threshold(position);\n  return out;\n}\n\n@fragment fn fs(in: VSOut) {\n  let alpha = textureSample(diffuseTexture, texSampler, in.uv).a * material.diffuse.a;\n  if (alpha < 0.5) { discard; }\n  // The dissolve, run as the colour pass runs it. A flake that is gone stops\n  // casting: without this she leaves a whole shadow standing on the floor while\n  // her body is in the air.\n  if (material.dissolve < 0.9995 && in.faceT > material.dissolve) { discard; }\n}\n";
+export declare const SHADOW_DEPTH_SHADER_WGSL = "\n\n/** Clump size, in object-space units \u2014 MMD's are roughly centimetres.\n *\n *  Raised from 0.42: at that size the pieces are near enough to speckle that a\n *  departure reads as a fade rather than as a body coming apart, which is the\n *  thing the clumping exists to avoid. Hand-sized pieces are visible ones. */\nconst RZ_DISSOLVE_GRAIN: f32 = 1.2;\n/** How much the clumps pull a fragment off its own grit value \u2014 the whole of\n *  the LOOK, and none of the rate. See rz_dissolve_threshold. */\nconst RZ_DISSOLVE_CLUMP: f32 = 0.6;\n/** Grit cell, as a fraction of a clump. See rz_dissolve_threshold: this is what\n *  keeps a material SMALLER than a clump from having one threshold for all of\n *  it, and it has to be smaller than the SMALLEST material a model carries \u2014\n *  an eye highlight, a button, a buckle \u2014 not merely small. Two and a half\n *  millimetres on a normal model, which is under all of them. */\nconst RZ_DISSOLVE_GRIT: f32 = 0.021;\n/** How wide the glowing front is, in threshold units. Thin: the front is a\n *  rim, and a wide one lights whole limbs at once. */\nconst RZ_DISSOLVE_EDGE: f32 = 0.11;\n/** What the front burns with. Emission, added after lighting and after the\n *  graph \u2014 a colour that ramps or takes a shadow reads as paint, not as heat.\n *  Above 1 on purpose: it is meant to reach the bloom pyramid. Blue-violet,\n *  the same light the motes leaving her are drawn and lit with. */\nconst RZ_BURN_COLOR: vec3f = vec3f(0.45, 0.62, 2.40);\n\nfn rz_dissolve_hash(p: vec3f) -> f32 {\n  // INTEGER, for exactly the reason _hash33 in nodes.ts is, and its comment\n  // says it: above 24 bits an f32 loses the low ones. The float hash this\n  // replaces multiplied three terms into the hundreds of millions and took\n  // fract() of the product \u2014 which past 2^24 is not noise, it is a quantised\n  // staircase, and wherever that staircase landed on zero the threshold was\n  // zero. A surface whose threshold is zero never crosses it: it stays behind\n  // while the rest of her leaves, and it sits inside the burning front the\n  // whole time she is gone. Those were the white pieces that would not go.\n  //\n  // Floored first, unlike _hash33: vec3i() truncates toward zero, so -0.5 and\n  // +0.5 are the same cell, and half this model is at negative x.\n  var h = vec3u(vec3i(floor(p)) + vec3i(32768));\n  h = h * vec3u(1664525u, 1013904223u, 2654435761u);\n  h = (h.yzx ^ h) * vec3u(2246822519u, 3266489917u, 668265263u);\n  h = h ^ (h >> vec3u(16u));\n  return f32((h.x ^ h.y ^ h.z) & 16777215u) * (1.0 / 16777216.0);\n}\n\n/** Value noise over that hash \u2014 smooth within a flake, uncorrelated between. */\nfn rz_dissolve_field(p: vec3f) -> f32 {\n  let i = floor(p);\n  let f = fract(p);\n  let u = f * f * (3.0 - 2.0 * f);\n  let c000 = rz_dissolve_hash(i);\n  let c100 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 0.0));\n  let c010 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 0.0));\n  let c110 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 0.0));\n  let c001 = rz_dissolve_hash(i + vec3f(0.0, 0.0, 1.0));\n  let c101 = rz_dissolve_hash(i + vec3f(1.0, 0.0, 1.0));\n  let c011 = rz_dissolve_hash(i + vec3f(0.0, 1.0, 1.0));\n  let c111 = rz_dissolve_hash(i + vec3f(1.0, 1.0, 1.0));\n  let x00 = mix(c000, c100, u.x);\n  let x10 = mix(c010, c110, u.x);\n  let x01 = mix(c001, c101, u.x);\n  let x11 = mix(c011, c111, u.x);\n  return mix(mix(x00, x10, u.y), mix(x01, x11, u.y), u.z);\n}\n\n/**\n * The threshold this fragment is measured against.\n *\n * NOISE ALONE, so the whole body comes apart at once \u2014 a hand, a shoulder and\n * an ankle all thinning together rather than a line travelling up her. It was\n * tilted by height at first, on the argument that a sweep reads as something\n * happening TO her; what it actually reads as is a wipe, and a wipe has a\n * direction, an edge and a speed the rest of the effect knows nothing about.\n * Everywhere at once is also the honest match for what leaves: the motes are\n * shed from every limb in the same breath.\n *\n * TWO SCALES. Clumps alone meant every fragment of a material SMALLER than one\n * cell shared a single threshold: an eye highlight, a brow, a button, a hair\n * clip. All of it sat inside the glowing front at once, so the piece flashed\n * white as a whole and then popped \u2014 the two things a disintegration must never\n * do. The grit is a per-cell hash at a fraction of the clump, so a part a few\n * millimetres across still comes apart in pieces.\n *\n * THE GRIT IS THE BASE, though, and the clumps only push a fragment off it.\n * That ordering is what makes the dissolve smooth, and it is not obvious: the\n * two used to be WEIGHTED AND ADDED, and a sum is not uniformly distributed\n * however uniform each half is. It piles up in the middle, so most of the\n * surface had a threshold near a half \u2014 all of it went as the dissolve swept\n * through the middle, and what remained was the thin tail near zero. That tail\n * was the second stage everyone could see: a body that mostly vanished, then a\n * scatter of glowing scraps, then nothing.\n *\n * WRAPPED, not added. Offsetting a uniform value and taking fract() leaves it\n * EXACTLY uniform, where scaling a sum back into range only flattens the middle\n * \u2014 measured over four hundred thousand samples, the sum removed 12% of her per\n * step at the halfway mark and 0.1% at each end (a 110x swing), the scaled sum\n * still swung 89x, and the wrap is flat: 5.0% per step from the first flake to\n * the last, a ratio of 1.0.\n *\n * That flatness IS the smoothness. An uneven rate is what produced the two\n * stages you could see \u2014 a body that mostly vanished at once, then a scatter of\n * scraps that took as long again to follow.\n *\n * The clumping survives the wrap: neighbouring fragments share a clump value,\n * so the offset moves them together. What wraps past 1 comes back at 0 and goes\n * at the other end instead, which costs a little speckle in a region and buys\n * an even rate everywhere.\n */\nfn rz_dissolve_threshold(restPos: vec3f) -> f32 {\n  let grit = rz_dissolve_hash(floor(restPos / (RZ_DISSOLVE_GRAIN * RZ_DISSOLVE_GRIT)));\n  let clump = rz_dissolve_field(restPos / RZ_DISSOLVE_GRAIN) - 0.5;\n  return fract(grit + clump * RZ_DISSOLVE_CLUMP);\n}\n\nstruct LightVP { viewProj: mat4x4f, };\n@group(0) @binding(0) var<uniform> lp: LightVP;\n@group(0) @binding(1) var<storage, read> skinMats: array<mat4x4f>;\n@group(0) @binding(2) var texSampler: sampler;\n@group(1) @binding(0) var diffuseTexture: texture_2d<f32>;\n// The head of the material block and the one field at its tail \u2014 the same\n// reach the depth prepass takes, and for the same reason: a shadow cast by a\n// body that is no longer drawn is the tell that the vanishing is a trick.\nstruct MaterialDiffuse {\n  diffuse: vec4f,\n  _skip0: vec4f,\n  _skip1: vec4f,\n  _skip2: f32,\n  materialId: f32,\n  _skip3: f32,\n  dissolve: f32,\n};\n@group(1) @binding(1) var<uniform> material: MaterialDiffuse;\n// The model's ObjectLight, for its jelly eyes: the map must hold the iris where\n// the colour pass draws it.\nstruct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9>, fill: vec4f, jelly: array<vec4f, 12> }\n@group(0) @binding(3) var<uniform> objectLight: ObjectLight;\n\nfn _rzJellyTurn(q: vec2f, a: f32) -> vec2f {\n  let c = cos(a);\n  let s = sin(a);\n  return vec2f(c * q.x - s * q.y, s * q.x + c * q.y);\n}\n\n/**\n * Where the jelly puts an iris vertex. The iris is the part of the eye the eye\n * bones carry, so it is moved as a whole, in bind space before skinning:\n * scaled about its centre (the CPU composes the blink's spring, the lid's\n * press and her motion's knock into one scale), turned and drifted a hair on\n * the spring, brought forward a hair, and rolled about the eye bone with a\n * closing expression \u2014 inside the white, which stays where it is. A highlight\n * layer (this draw's material is one of jelly[1].w's) takes the iris's move,\n * then its own scale, turn and tremble, before the roll. Vertices take it by their weight on the eye bones\n * (jelly[2].w, jelly[3].w), so nothing else on the face moves.\n */\nfn rzJellyVertex(p: vec3f, joints: vec4<u32>, nw: vec4f) -> vec3f {\n  let j = objectLight.jelly;\n  let ids = u32(j[1].w);\n  let mid = u32(material.materialId);\n  let hl = mid > 0u && (mid == (ids & 4095u) || mid == (ids >> 12u));\n  var out = p;\n  for (var e = 0u; e < 2u; e++) {\n    let bone = j[2u + e].w;\n    if (bone < 0.0) { continue; }\n    let b = u32(bone);\n    let w = dot(nw, select(vec4f(0.0), vec4f(1.0), joints == vec4<u32>(b)));\n    if (w <= 0.0) { continue; }\n    let c = j[e].xyz;\n    // A rig that carries both eyes on one bone: each vertex follows its own side.\n    if (j[2].w == j[3].w && e == 0u && distance(p.xy, j[1].xy) < distance(p.xy, j[0].xy)) { continue; }\n    if (j[2].w == j[3].w && e == 1u && distance(p.xy, j[0].xy) <= distance(p.xy, j[1].xy)) { continue; }\n    let t = j[4u + e];\n    let m = j[6u + e];\n    let h = j[10u + e];\n    var q = _rzJellyTurn((p.xy - c.xy) * t.xy, t.z) + m.xy;\n    // Forward is \u2212Z (MMD faces \u2212Z).\n    var push = h.z;\n    if (hl) {\n      // Sliding over the iris's dome on its own, a highlight sheet a hair in\n      // front of it would sink into it where the dome bulges more and the two\n      // fight for depth; so it comes forward by as far as it slid \u2014 a slope of\n      // one, steeper than the dome anywhere it draws.\n      let before = q;\n      q = _rzJellyTurn(q * h.xy, t.w) + m.zw;\n      push += length(q - before);\n    }\n    var moved = vec3f(c.xy + q, p.z - push);\n    let roll = j[8u + e];\n    if (roll.w != 0.0) {\n      let d = moved - roll.xyz;\n      let rd = _rzJellyTurn(d.yz, roll.w);\n      moved = roll.xyz + vec3f(d.x, rd.x, rd.y);\n    }\n    out = mix(p, moved, w);\n  }\n  return out;\n}\n\n\nstruct VSOut {\n  @builtin(position) position: vec4f,\n  @location(0) uv: vec2f,\n  /** Bind-pose position, for the dissolve test \u2014 object space, as everywhere. */\n  @location(1) restPos: vec3f,\n  /** The triangle's own threshold, flat \u2014 see the material VertexOutput. A\n   *  face that is gone must stop casting, and stop as a whole face. */\n  @location(2) @interpolate(flat) faceT: f32,\n};\n\n@vertex fn vs(@location(0) position: vec3f, @location(1) normal: vec3f, @location(2) uv: vec2f,\n  @location(3) joints0: vec4<u32>, @location(4) weights0: vec4<f32>) -> VSOut {\n  let ws = weights0.x + weights0.y + weights0.z + weights0.w;\n  let inv = select(1.0, 1.0 / ws, ws > 0.0001);\n  let nw = select(vec4f(1.0,0.0,0.0,0.0), weights0 * inv, ws > 0.0001);\n  var pos4 = vec4f(position, 1.0);\n  if (objectLight.jelly[0].w > 0.0) { pos4 = vec4f(rzJellyVertex(position, joints0, nw), 1.0); }\n  var sp = vec4f(0.0);\n  for (var i = 0u; i < 4u; i++) { sp += (skinMats[joints0[i]] * pos4) * nw[i]; }\n  var out: VSOut;\n  out.position = lp.viewProj * vec4f(sp.xyz, 1.0);\n  out.uv = uv;\n  out.restPos = position;\n  out.faceT = rz_dissolve_threshold(position);\n  return out;\n}\n\n@fragment fn fs(in: VSOut) {\n  let alpha = textureSample(diffuseTexture, texSampler, in.uv).a * material.diffuse.a;\n  if (alpha < 0.5) { discard; }\n  // The dissolve, run as the colour pass runs it. A flake that is gone stops\n  // casting: without this she leaves a whole shadow standing on the floor while\n  // her body is in the air.\n  if (material.dissolve < 0.9995 && in.faceT > material.dissolve) { discard; }\n}\n";
 //# sourceMappingURL=shadow.d.ts.map

package/dist/shaders/passes/shadow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shadow.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/shadow.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,wBAAwB,y1QAqDpC,CAAA"}
+{"version":3,"file":"shadow.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/shadow.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,wBAAwB,uyWA6DpC,CAAA"}

package/dist/shaders/passes/shadow.js

@@ -1,4 +1,4 @@
-import { DISSOLVE_WGSL } from "../materials/common";
+import { DISSOLVE_WGSL, JELLY_VERTEX_WGSL } from "../materials/common";
 // Shadow map depth pass. Skinned VS + alpha-test FS (depth-only attachment, no
 // color targets): texels where diffuse-texture alpha × material alpha fall below
 // the cutoff are discarded, so lace casts lace-shaped shadows and a true veil
@@ -19,10 +19,17 @@ struct MaterialDiffuse {
   diffuse: vec4f,
   _skip0: vec4f,
   _skip1: vec4f,
-  _skip2: vec3f,
+  _skip2: f32,
+  materialId: f32,
+  _skip3: f32,
   dissolve: f32,
 };
 @group(1) @binding(1) var<uniform> material: MaterialDiffuse;
+// The model's ObjectLight, for its jelly eyes: the map must hold the iris where
+// the colour pass draws it.
+struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9>, fill: vec4f, jelly: array<vec4f, 12> }
+@group(0) @binding(3) var<uniform> objectLight: ObjectLight;
+${JELLY_VERTEX_WGSL}
 
 struct VSOut {
   @builtin(position) position: vec4f,
@@ -36,10 +43,11 @@ struct VSOut {
 
 @vertex fn vs(@location(0) position: vec3f, @location(1) normal: vec3f, @location(2) uv: vec2f,
   @location(3) joints0: vec4<u32>, @location(4) weights0: vec4<f32>) -> VSOut {
-  let pos4 = vec4f(position, 1.0);
   let ws = weights0.x + weights0.y + weights0.z + weights0.w;
   let inv = select(1.0, 1.0 / ws, ws > 0.0001);
   let nw = select(vec4f(1.0,0.0,0.0,0.0), weights0 * inv, ws > 0.0001);
+  var pos4 = vec4f(position, 1.0);
+  if (objectLight.jelly[0].w > 0.0) { pos4 = vec4f(rzJellyVertex(position, joints0, nw), 1.0); }
   var sp = vec4f(0.0);
   for (var i = 0u; i < 4u; i++) { sp += (skinMats[joints0[i]] * pos4) * nw[i]; }
   var out: VSOut;

package/dist/shaders/passes/sim.d.ts

@@ -0,0 +1,34 @@
+import { type CastLayout } from "./particles";
+export declare const SIM_MAX = 1024;
+/** rgba16float, ping-ponged. Two of these is the whole memory cost. */
+export declare const SIM_FORMAT: GPUTextureFormat;
+/** `// @sim 256` — the grid's resolution, in texels per side. */
+export declare function parseSimSize(wgsl: string, max: number): number;
+/** Whether this effect drives a grid at all. */
+export declare function simEntryPoint(wgsl: string): boolean;
+/**
+ * `rzSim(uv)`, for a shader that READS the grid rather than steps it.
+ *
+ * Always compiled in, even for an effect with no grid — it then samples a 1×1
+ * of zeroes. An accessor that exists only sometimes is one an author has to
+ * guard, and a missing function is a compile error rather than a blank result.
+ */
+export declare function simReadApi(group: number, tex: number, samp: number, size: number): string;
+/** `rzTime`/`rzDt`, for a module that has no clock of its own — the field pass.
+ *  Same reason as above: a spliced simStep refers to them. */
+export declare function simClockApi(timeExpr: string): string;
+/**
+ * The step shader: one invocation per texel, once per frame.
+ *
+ * The previous grid is bound as a SAMPLED texture and the next as a storage
+ * texture, which is what makes the two different resources and the whole thing
+ * legal — a shader cannot read and write one texture coherently, and the
+ * ping-pong is not an optimisation but the only correct way to do this.
+ *
+ * Sampled rather than only fetched, because advection needs to read BETWEEN
+ * texels: a semi-Lagrangian step asks "what was at the place this parcel came
+ * from", and that place is almost never a texel centre. Point-sampling it is
+ * what turns smoke into a staircase.
+ */
+export declare function buildSimShader(wgsl: string, size: number, _cast: CastLayout): string;
+//# sourceMappingURL=sim.d.ts.map

package/dist/shaders/passes/sim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/sim.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAgC7C,eAAO,MAAM,OAAO,OAAO,CAAA;AAC3B,uEAAuE;AACvE,eAAO,MAAM,UAAU,EAAE,gBAAgC,CAAA;AAEzD,iEAAiE;AACjE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAM9D;AAED,gDAAgD;AAChD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CA6BzF;AAED;8DAC8D;AAC9D,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKpD;AAWD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,MAAM,CAwDpF"}