reze-engine 0.66.5 → 0.67.1

package/dist/shaders/passes/composite.js

@@ -97,7 +97,7 @@ override APPLY_GAMMA: bool = true;
 @group(0) @binding(0) var hdrTex: texture_2d<f32>;
 @group(0) @binding(1) var bloomTex: texture_2d<f32>;   // bloomUpTexture mip 0 (full pyramid top)
 @group(0) @binding(2) var bloomSamp: sampler;
-@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 15>;
+@group(0) @binding(3) var<uniform> viewU: array<vec4<f32>, 16>;
 // Aux mask/alpha texture. .r = bloom mask (unused here; bloom blit uses it).
 // .g = accumulated canvas alpha (what hdr.a carried before the HDR format
 // became rg11b10ufloat). We unpremultiply HDR by this alpha for tonemap, then
@@ -119,6 +119,8 @@ override APPLY_GAMMA: bool = true;
 // viewU[9] = (grade slope.rgb, grade flags) — bit 0 the CDL grade(), bit 1 the
 //            scene's own LUT (setStageGrade) — see _rzGradeScene() below.
 // viewU[10] = (camera world position, _) — refreshed with the basis above.
+// viewU[11..14] = the cast's positions (effects; count in viewU[10].w).
+// viewU[15] = (soft curve contrast, _, _, _).
 // invGamma = 1/gamma precomputed on CPU — avoids a per-pixel divide.
 @group(0) @binding(6) var bgEquirect: texture_2d<f32>;
 // The scene pass's own MSAA depth buffer, bound depth-only. NOT an extra
@@ -217,7 +219,7 @@ fn srgb_encode(x: f32) -> f32 {
  * The game's ACES branch is off in every scene measured.
  */
 fn softTransform(c: vec3f) -> vec3f {
-  let t = pow(max(vec3f(1.0) - exp(-2.5 * max(c, vec3f(0.0))), vec3f(0.0)), vec3f(1.4));
+  let t = pow(max(vec3f(1.0) - exp(-2.5 * max(c, vec3f(0.0))), vec3f(0.0)), vec3f(viewU[15].x));
   return vec3f(srgb_encode(t.r), srgb_encode(t.g), srgb_encode(t.b));
 }
 

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/outline.d.ts

@@ -12,5 +12,12 @@ export declare const RZ_OUTLINE_WIDTH_OFFSET = 24;
 /** Where the scene-wide colour override sits, in bytes: rgb and a weight, 0
  *  for the material's own edge colour (Engine.setOutlineColor). */
 export declare const RZ_OUTLINE_COLOR_OFFSET = 32;
+/** Where a style graph's outline (ShaderGraph.outline) sits, in bytes: the
+ *  textured flag at 28, then its shadow colour at 48. Unset, a hull draws its
+ *  PMX edge colour flat, as MMD does. */
+export declare const RZ_OUTLINE_TEXTURED_OFFSET = 28;
+export declare const RZ_OUTLINE_SHADOW_OFFSET = 48;
+/** The hull's own block, in floats. */
+export declare const RZ_OUTLINE_UNIFORM_FLOATS = 16;
 export declare function outlineShaderWgsl(): string;
 //# sourceMappingURL=outline.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/outline.ts"],"names":[],"mappings":"AAqBA;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAA;AAC5C;yCACyC;AACzC,eAAO,MAAM,uBAAuB,KAAK,CAAA;AACzC;mEACmE;AACnE,eAAO,MAAM,uBAAuB,KAAK,CAAA;AAEzC,wBAAgB,iBAAiB,IAAI,MAAM,CAoM1C"}
+{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/outline.ts"],"names":[],"mappings":"AAqBA;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,KAAK,CAAA;AAC5C;yCACyC;AACzC,eAAO,MAAM,uBAAuB,KAAK,CAAA;AACzC;mEACmE;AACnE,eAAO,MAAM,uBAAuB,KAAK,CAAA;AACzC;;yCAEyC;AACzC,eAAO,MAAM,0BAA0B,KAAK,CAAA;AAC5C,eAAO,MAAM,wBAAwB,KAAK,CAAA;AAC1C,uCAAuC;AACvC,eAAO,MAAM,yBAAyB,KAAK,CAAA;AAE3C,wBAAgB,iBAAiB,IAAI,MAAM,CAgP1C"}

package/dist/shaders/passes/outline.js

@@ -30,6 +30,13 @@ export const RZ_OUTLINE_WIDTH_OFFSET = 24;
 /** Where the scene-wide colour override sits, in bytes: rgb and a weight, 0
  *  for the material's own edge colour (Engine.setOutlineColor). */
 export const RZ_OUTLINE_COLOR_OFFSET = 32;
+/** Where a style graph's outline (ShaderGraph.outline) sits, in bytes: the
+ *  textured flag at 28, then its shadow colour at 48. Unset, a hull draws its
+ *  PMX edge colour flat, as MMD does. */
+export const RZ_OUTLINE_TEXTURED_OFFSET = 28;
+export const RZ_OUTLINE_SHADOW_OFFSET = 48;
+/** The hull's own block, in floats. */
+export const RZ_OUTLINE_UNIFORM_FLOATS = 16;
 export function outlineShaderWgsl() {
     return /* wgsl */ `
 ${DISSOLVE_WGSL}
@@ -59,17 +66,30 @@ struct MaterialUniforms {
    *  scales the author's edgeSize rather than replacing it, so a model's thin
    *  and thick lines keep their proportion. */
   widthScale: f32,
-  _padding3: f32,
+  /** 1: a style graph's outline, the game's (Uber pass "Outline"): edgeSize is
+   *  a world width, held between 1.2 and 3 px of a 1920-wide frame, and the
+   *  colour is the picture × lerp(shadowColor, edgeColor, the key's
+   *  half-Lambert). 0: the PMX edge, flat. */
+  textured: f32,
   /** The scene's colour in place of edgeColor.rgb, by .a (0 or 1). The
    *  material's own alpha still holds — a line its author made sheer stays so. */
   colorOverride: vec4f,
+  shadowColor: vec4f,
 };
 
+struct OutlineLight { direction: vec4f, color: vec4f, };
+/** The head of the scene's light block: the key is lights[0]. */
+struct OutlineLights { ambientColor: vec4f, lights: array<OutlineLight, 4>, };
+
 @group(0) @binding(0) var<uniform> camera: CameraUniforms;
 @group(0) @binding(1) var edgeSampler: sampler;
+@group(0) @binding(2) var<uniform> light: OutlineLights;
 @group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
 @group(2) @binding(0) var<uniform> material: MaterialUniforms;
 @group(2) @binding(1) var diffuseTexture: texture_2d<f32>;
+/** A look's outline tint (ShaderGraph.outline.tint): one of its images, white
+ *  when it names none. */
+@group(2) @binding(2) var tintTexture: texture_2d<f32>;
 
 struct VertexOutput {
   @builtin(position) position: vec4f,
@@ -84,6 +104,7 @@ struct VertexOutput {
   /** How much of a pixel-wide line this one really is (1 = all of it): a line
    *  held at the minimum width fades by what it was short. */
   @location(3) coverage: f32,
+  @location(4) normal: vec3f,
 };
 
 /**
@@ -106,6 +127,11 @@ const RZ_OUTLINE_FULL_FIGURE = 12.5;
  *  the shortfall, so far lines thin out without aliasing into dashes. */
 const RZ_OUTLINE_MIN_PX = 1.5;
 
+fn safe_normal2(v: vec2f) -> vec2f {
+  let l = length(v);
+  return select(vec2f(0.0), v / l, l > 1e-6);
+}
+
 @vertex fn vs(
   @location(0) position: vec3f,
   @location(1) normal: vec3f,
@@ -165,21 +191,40 @@ const RZ_OUTLINE_MIN_PX = 1.5;
   // once the frame is taller than a figure. The PMX per-vertex edge scale
   // multiplies it all, as vertex colour alpha does in the game.
   let w = max(clipPos.w, 1e-4);
-  let breakDepth = RZ_OUTLINE_FULL_FIGURE * camera.projection[1][1];
-  let nearNdc = viewNormal.xy * (material.edgeSize * material.widthScale * outlineNormal.w * 4.0 / refViewport);
-  var ndc = nearNdc * (min(w, breakDepth) / w);
-
-  // Antialiased minimum (the game's _OutlineAntialias): held at the minimum
-  // width and faded by the shortfall, never thinner. The game fades by
-  // sqrt(coverage.x · coverage.y), per axis; for one width that is the ratio
-  // itself.
-  let px = length(ndc * deviceViewport * 0.5);
-  let minPx = RZ_OUTLINE_MIN_PX * max(1.0, camera.viewportHeight / 1080.0);
+  var ndc: vec2f;
   var coverage = 1.0;
-  if (px < minPx) {
-    coverage = px / minPx;
-    ndc = select(vec2f(0.0), ndc * (minPx / px), px > 1e-6);
+  if (material.textured > 0.5) {
+    // The game's: a view-space offset of edgeSize world units along the view
+    // normal, projected, then each axis held between 1.2 px and 1.2 px ×
+    // (1 + _OutlineMaxOffsetMultiplier, 1.5) of a 1920-wide frame; a line the
+    // minimum had to push fades by how far it was pushed.
+    let off = viewNormal.xy * material.edgeSize * material.widthScale * outlineNormal.w;
+    let d1 = vec2f(off.x * camera.projection[0][0], off.y * camera.projection[1][1]) / w;
+    // the minimum along the push direction (the game's dir · 2/screen · 1.2)
+    let pxNdc = 2.0 / refViewport * 1.2 * safe_normal2(viewNormal.xy);
+    let mx = abs(pxNdc) * 2.5;
+    let o = min(mx, max(abs(d1), abs(pxNdc)));
+    // fadeOut = min(length(saturate(off − |d1|))·75, 1), on clip offsets (× w)
+    // in game units: w here is MMD units, 8 to the game's metre
+    coverage = 1.0 - min(length(saturate((o - abs(d1)) * w / 8.0)) * 75.0, 1.0);
+    ndc = o * select(vec2f(1.0), sign(d1), abs(d1) > vec2f(0.0));
+  } else {
+    let breakDepth = RZ_OUTLINE_FULL_FIGURE * camera.projection[1][1];
+    let nearNdc = viewNormal.xy * (material.edgeSize * material.widthScale * outlineNormal.w * 4.0 / refViewport);
+    ndc = nearNdc * (min(w, breakDepth) / w);
+
+    // Antialiased minimum (the game's _OutlineAntialias): held at the minimum
+    // width and faded by the shortfall, never thinner. The game fades by
+    // sqrt(coverage.x · coverage.y), per axis; for one width that is the ratio
+    // itself.
+    let px = length(ndc * deviceViewport * 0.5);
+    let minPx = RZ_OUTLINE_MIN_PX * max(1.0, camera.viewportHeight / 1080.0);
+    if (px < minPx) {
+      coverage = px / minPx;
+      ndc = select(vec2f(0.0), ndc * (minPx / px), px > 1e-6);
+    }
   }
+  output.normal = worldNormal;
   output.coverage = coverage;
   output.position = vec4f(clipPos.xy + ndc * w, clipPos.z, clipPos.w);
   output.uv = uv;
@@ -211,7 +256,8 @@ ${sceneFsOutWgsl({ name: "FSOut", aux: "mask" })}
   // bind-pose position — three passes, one rule, or they disagree about which
   // pieces are still there.
   if (material.dissolve < 0.9995 && input.faceT > material.dissolve) { discard; }
-  let texA = textureSample(diffuseTexture, edgeSampler, input.uv).a;
+  let tex = textureSample(diffuseTexture, edgeSampler, input.uv);
+  let texA = tex.a;
   if (texA < 0.05) {
     discard;
   }
@@ -220,7 +266,12 @@ ${sceneFsOutWgsl({ name: "FSOut", aux: "mask" })}
   // alpha above), it is drawn right after the surface it traces so what lies
   // under a faded line is already there, and 4× MSAA would quantize a fade to
   // four steps.
-  let rgb = mix(material.edgeColor.rgb, material.colorOverride.rgb, material.colorOverride.a);
+  var rgb = mix(material.edgeColor.rgb, material.colorOverride.rgb, material.colorOverride.a);
+  if (material.textured > 0.5) {
+    let lit = dot(-light.lights[0].direction.xyz, normalize(input.normal)) * 0.5 + 0.5;
+    let tint = textureSample(tintTexture, edgeSampler, input.uv).rgb;
+    rgb = tex.rgb * tint * mix(material.shadowColor.rgb, rgb, lit);
+  }
   out.color = vec4f(rgb, material.edgeColor.a * texA * input.coverage);
   out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
 ${sceneIdPadWgsl("out")}  return out;

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