reze-engine 0.60.4 → 0.61.0

package/dist/shaders/materials/stockings.js

@@ -0,0 +1,122 @@
+// M_Stockings — 仿深空之眼渲染预设v1.0_by_小绿毛猫 "M_Stockings". A bbox-gradient ×
+// facing-rim mask drives a Mix Shader between an HSV-boosted emission and a sheen
+// Principled BSDF. Wyman hashed-alpha testing replaces the graph's Alpha=0.95 (which
+// would require TAA to hide the dither dots across every pixel).
+import { NODES_WGSL } from "./nodes";
+import { COMMON_MATERIAL_PRELUDE_WGSL } from "./common";
+export const STOCKINGS_SHADER_WGSL = /* wgsl */ `
+
+${NODES_WGSL}
+${COMMON_MATERIAL_PRELUDE_WGSL}
+
+// Principled params from dump (Alpha=0.95 intentionally dropped — see hash note below).
+const STOCK_METALLIC: f32 = 0.1;
+const STOCK_SPECULAR: f32 = 1.0;
+const STOCK_ROUGHNESS: f32 = 0.5;
+const STOCK_SHEEN: f32 = 0.7017999887466431;
+const STOCK_SHEEN_TINT: f32 = 0.5;
+// NPR mask ramps
+const STOCK_RAMP002_P1: f32 = 0.9565;  // EASE [0→black, 0.9565→white]
+const STOCK_RAMPFACE_P1: f32 = 0.5435; // EASE [0→black, 0.5435→white]
+const STOCK_LW_BLEND: f32 = 0.4;       // Layer Weight Blend
+
+// Wyman & McGuire "Hashed Alpha Testing" (2017) — object-space hash with derivative-aware
+// pixel-scale selection, matches Blender EEVEE prepass_frag.glsl::hashed_alpha_threshold.
+// Key property: dither pattern is stable in object space (doesn't swim) and stays at
+// one-pixel frequency regardless of view distance, which makes it tolerable without TAA.
+// The hash grid is fed the bind-pose restPos (not worldPos), so the dots stay pinned to
+// the fabric even under root (センター) motion — worldPos would crawl across the surface.
+// Since MMD skinning is rigid, length(dpdx(restPos)) == length(dpdx(worldPos)), so the
+// pixel-scale selection is unaffected by the space change.
+// Grid samples reuse the PCG _hash33 from nodes.ts (integer-lattice inputs, Metal-friendly)
+// instead of a fract(sin()) hash — sin compiles to a slow transcendental on Apple's Metal
+// backend and this runs per-fragment on every stockings pixel.
+fn _hash3d_wm(a: vec3f) -> f32 {
+  return _hash33(a).x * 0.5 + 0.5;
+}
+fn hashed_alpha_threshold(co: vec3f) -> f32 {
+  let alphaHashScale: f32 = 1.0;
+  let max_deriv = max(length(dpdx(co)), length(dpdy(co)));
+  let pix_scale = 1.0 / max(alphaHashScale * max_deriv, 1e-6);
+  let pix_scale_log = log2(pix_scale);
+  let px_lo = exp2(floor(pix_scale_log));
+  let px_hi = exp2(ceil(pix_scale_log));
+  let a_lo = _hash3d_wm(floor(px_lo * co));
+  let a_hi = _hash3d_wm(floor(px_hi * co));
+  let fac = fract(pix_scale_log);
+  let x = mix(a_lo, a_hi, fac);
+  // CDF remap so discard-probability = (1 - alpha) uniformly across scale transitions
+  let a = min(fac, 1.0 - fac);
+  let one_a = 1.0 - a;
+  let denom = 1.0 / max(2.0 * a * one_a, 1e-6);
+  let one_x = 1.0 - x;
+  let case_lo = (x * x) * denom;
+  let case_mid = (x - 0.5 * a) / max(one_a, 1e-6);
+  let case_hi = 1.0 - (one_x * one_x) * denom;
+  var threshold = select(case_hi, select(case_lo, case_mid, x >= a), x < one_a);
+  return clamp(threshold, 1e-6, 1.0);
+}
+
+// Smoothstep-based EASE ramp (Blender VALTORGB EASE) — 2 stops, saturate+smoothstep between
+fn ramp_ease_s(f: f32, p0: f32, p1: f32) -> f32 {
+  let t = saturate((f - p0) / max(p1 - p0, 1e-6));
+  return t * t * (3.0 - 2.0 * t);
+}
+
+@fragment fn fs(input: VertexOutput) -> FSOut {
+  let n = safe_normal(input.normal);
+  let v = normalize(camera.viewPos - input.worldPos);
+  let l = -light.lights[0].direction.xyz;
+  let sun = light.lights[0].color.xyz * light.lights[0].color.w;
+  let amb = light.ambientColor.xyz;
+  let shadow = sampleShadow(input.worldPos, n);
+
+  let tex_s = textureSample(diffuseTexture, diffuseSampler, input.uv);
+  let tex_rgb = tex_s.rgb;
+  // Alpha HASHED (Blender EEVEE "Hashed" blend mode) per preset author's note — self-overlap
+  // on the stockings produces sort cracks under alpha blend. Wyman-style object-space hash +
+  // depth-write is sort-independent. NOTE: Principled.Alpha=0.95 from the dump is DROPPED;
+  // it relies on TAA to smooth the 5%-everywhere dither, and without TAA it shows as a
+  // pervasive dot pattern. Hash now gates only on texture/material alpha.
+  let combined_alpha = material.alpha * tex_s.a;
+  if (combined_alpha < hashed_alpha_threshold(input.restPos)) { discard; }
+
+  // ═══ NPR MASK ═══ TEX_COORD.Generated → Mapping(Rot=0,π/2,π/2, Loc=(1,1,1)) → Gradient.
+  // The Blender mapping reduces to gradient.x = 1 - input.y (rot swaps axes, loc offsets).
+  // We approximate Generated with UV since Y-up PMX has no object bbox in pipeline state.
+  let gen_coord = vec3f(input.uv, 0.0);
+  let mapped = mapping_point(gen_coord, vec3f(1.0), vec3f(0.0, 1.5708, 1.5708), vec3f(1.0));
+  let gradient = tex_gradient_linear(mapped);
+
+  // Ramp.001 LINEAR [0→black, 0.5→white, 1.0→black] — triangular peak at 0.5
+  let ramp001 = 1.0 - abs(2.0 * gradient - 1.0);
+  let ramp002 = ramp_ease_s(ramp001, 0.0, STOCK_RAMP002_P1);
+
+  let facing = layer_weight_facing(STOCK_LW_BLEND, n, v);
+  let ramp_face = ramp_ease_s(facing, 0.0, STOCK_RAMPFACE_P1);
+
+  // Mix.001: MIX blend Fac=0.5, A=white, B=ramp_face
+  let mix001 = mix(1.0, ramp_face, 0.5);
+  // Mix: LIGHTEN blend Fac=0.5, A=mix001, B=ramp002
+  let lighten = max(mix001, ramp002);
+  let mask = mix(mix001, lighten, 0.5);
+
+  // ═══ EMISSION SHADER ═══ Hue=0.5 (identity), Sat=1.0, Val=5.0 (5× brightness), Fac=1.
+  let emission = hue_sat_id(1.0, 5.0, 1.0, tex_rgb);
+
+  // ═══ PRINCIPLED BSDF with sheen ═══ metallic=0.1, sheen=0.7, sheen_tint=0.5.
+  let principled = eval_principled(
+    PrincipledIn(tex_rgb, STOCK_METALLIC, STOCK_SPECULAR, STOCK_ROUGHNESS, 1e30, STOCK_SHEEN, STOCK_SHEEN_TINT),
+    n, l, v, sun, amb, shadow
+  );
+
+  // MIX SHADER: Shader=Emission, Shader_001=Principled, Fac=mask
+  let final_color = mix(emission, principled, mask);
+
+  var out: FSOut;
+  out.color = vec4f(final_color, 1.0);
+  out.mask = vec4f(1.0, 1.0, 0.0, out.color.a);
+  return out;
+}
+
+`;

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

@@ -97,7 +97,7 @@ type CompositeEffectSource = {
  * Depends on `viewU` and `_rzCast` being declared by the including module, and
  * on nothing else: no textures, no samplers.
  */
-export declare const EFFECT_SCENE_API = "\n// \u2500\u2500 The effect API \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Named rz*, for the engine. The prefix earns its place twice: user code is\n// concatenated into THIS module, so an unprefixed rzAnchor() would collide with\n// exactly the helper an author would write, and the old bg* prefix stopped being\n// true in 0.41.0 when effects gained a mount over the finished frame.\n//\n// The bg* names below are permanent aliases, not a deprecation with an end date.\n// A published link is immutable, so a scene pinned to a bg* effect has to keep\n// compiling forever. They are one-line and inlined; no new function gets one.\n\n/** Canvas size in pixels \u2014 for aspect correction. */\nfn rzResolution() -> vec2f { return viewU[6].zw; }\n\n/** The camera's world position. */\nfn rzCameraPos() -> vec3f { return viewU[10].xyz; }\n\n/** How many characters the SCENE holds, up to four \u2014 the number the cast api\n *  narrows to this effect's own subjects. See subjectMaskApi. */\nfn _rzCastLive() -> i32 { return i32(viewU[10].w); }\n\n/**\n * A world point as the camera sees it: xy the uv it lands on, z its distance\n * along the VIEW AXIS in metres.\n *\n * The exact inverse of the ray this pass builds per pixel, so it is the cheap way\n * to work with anything anchored in the world. Marching a curve or a trail in 3D\n * costs a distance evaluation per sample per pixel; projecting its points once\n * and measuring in 2D costs a subtraction, which is the difference between a\n * ribbon that runs at 4K and one that does not.\n *\n * z is directly comparable to the depth handed to foreground(), so occlusion is\n * a single test: draw where your z is nearer than the scene's. It is returned\n * SIGNED and unclamped \u2014 behind the camera is negative, and worth rejecting\n * before you use the uv, which is meaningless there.\n */\nfn rzProject(p: vec3f) -> vec3f {\n  let d = p - viewU[10].xyz;\n  let z = dot(d, viewU[5].xyz);\n  // Guard only the divide. z itself is returned as it is, so the caller can see\n  // the sign; clamping it here would put points behind the lens on the horizon.\n  let inv = 1.0 / select(z, 1e-4, z < 1e-4);\n  let ndc = vec2f(dot(d, viewU[3].xyz) * inv / viewU[3].w, dot(d, viewU[4].xyz) * inv / viewU[4].w);\n  return vec3f(ndc * 0.5 + 0.5, z);\n}\n\nfn rzCamPos() -> vec3f { return rzCameraPos(); }\nfn rzCameraRight() -> vec3f { return viewU[3].xyz; }\nfn rzCameraUp() -> vec3f { return viewU[4].xyz; }\nfn rzCameraForward() -> vec3f { return viewU[5].xyz; }\n\n// The cast \u2014 subjects, anchors, trails \u2014 is CAST_API, shared verbatim with the\n// particle and trail modules. It used to be written out here, a second time, and\n// the two copies had drifted: this one had rzAnchor and that one did not.\n\nconst RZ_SUBJECTS: i32 = 4;\nconst RZ_SAMPLES: i32 = 128;\n/** The anchor ADDRESS SPACE \u2014 how many an effect may declare, not how many it\n *  did. RZ_TRAIL_SLOTS is the per-effect number and is not this one; the two\n *  being one number was the old trail bug. */\nconst RZ_MAX_ANCHORS: i32 = 48;\nconst RZ_TRAIL_SAMPLES: i32 = 128;\n\nstruct RzSubject {\n  /** On the FLOOR, under the body \u2014 where a ring or a magic circle belongs. */\n  root: vec3f,\n  /** At the hips, the middle of the body \u2014 where an aura belongs. */\n  center: vec3f,\n  /** Bounding sphere: xyz centre, w radius. Deliberately generous \u2014 cull with it. */\n  bounds: vec4f,\n  /**\n   * How much of this character is still THERE: 1 whole, 0 gone.\n   *\n   * What setModelDissolve last set on them, which the material pass has already\n   * acted on by the time an effect runs \u2014 so an effect drawing what LEAVES a\n   * dissolving body (sparks, ash, a ghost) reads the same number the body was\n   * taken apart with, rather than keeping a clock of its own and hoping the two\n   * agree. 1 on a scene that never dissolves anybody.\n   */\n  dissolve: f32,\n  /**\n   * Where she LOOKS: a unit direction from between the eyes, in world space.\n   * Exact while her eyes are on something (Engine.setEyeTracking); otherwise\n   * the motion's own eye turn undone through the range map \u2014 an eye bone\n   * turns a fraction of the way toward what it looks at, and this gives back\n   * the whole of it. An effect that should go where the look goes \u2014 a beam,\n   * a light \u2014 takes this rather than an eye bone's axis, and it holds in\n   * either mode. Zero, with looking false, only for a model without eyes.\n   */\n  gaze: vec3f,\n  looking: bool,\n  /** False past the end of the cast, and every field is then zero. */\n  valid: bool,\n}\n\nstruct RzAnchor {\n  pos: vec3f,\n  /** World units per second, from the previous frame. Direction for a trail,\n   *  magnitude for anything that should react to how hard someone is moving. */\n  vel: vec3f,\n  /** The bone's forward axis \u2014 which way a foot points, where a head looks. */\n  fwd: vec3f,\n  /** False when this rig has no such bone. Check it: the alternative is drawing\n   *  a hand effect at the world origin on every model that spells it differently. */\n  valid: bool,\n}\n\n/**\n * How many characters THIS EFFECT is on, up to four.\n *\n * Not how many the scene holds. An effect applies to the whole cast unless the\n * scene says otherwise (Engine.setEffectSubjects), and where it says otherwise\n * this counts only the models named \u2014 so an effect aimed at one dancer sees one\n * subject, at index 0, and an author who wrote a loop over the cast gets the\n * targeting for free.\n *\n * Which is the whole design: the FILTER IS IN THE INDEX SPACE, not in the\n * shaders. There is no mask an effect can read, because an effect asking \"am I\n * allowed on this one\" is an effect that can get the answer wrong, and 18 of the\n * shipped built-ins would have had to be rewritten to ask at all.\n */\nfn rzSubjectCount() -> i32 {\n  let live = _rzCastLive();\n  let mask = _rzSubjectMask();\n  var n = 0;\n  for (var i = 0; i < live; i++) {\n    if ((mask & (1u << u32(i))) != 0u) { n++; }\n  }\n  return n;\n}\n\n/** This effect's i-th subject \u2192 the scene's slot, or -1 past its own count.\n *  Every accessor below goes through it, which is what keeps one effect's\n *  subject 1 from being another's. */\nfn _rzSubjectSlot(i: i32) -> i32 {\n  if (i < 0) { return -1; }\n  let live = _rzCastLive();\n  let mask = _rzSubjectMask();\n  var n = 0;\n  for (var s = 0; s < live; s++) {\n    if ((mask & (1u << u32(s))) == 0u) { continue; }\n    if (n == i) { return s; }\n    n++;\n  }\n  return -1;\n}\n\n/** Which model this is, stable across a scene \u2014 for per-subject variation. */\nfn rzSubjectId(i: i32) -> u32 {\n  let g = _rzSubjectSlot(i);\n  if (g < 0) { return 0u; }\n  return u32(_rzCast[g * 4 + 1].w);\n}\n\nfn rzSubject(i: i32) -> RzSubject {\n  var s: RzSubject;\n  let g = _rzSubjectSlot(i);\n  s.valid = g >= 0;\n  if (!s.valid) { return s; }\n  let b = g * 4;\n  s.root = _rzCast[b].xyz;\n  s.dissolve = _rzCast[b].w;\n  s.center = _rzCast[b + 1].xyz;\n  s.bounds = _rzCast[b + 2];\n  s.gaze = _rzCast[b + 3].xyz;\n  s.looking = _rzCast[b + 3].w > 0.5;\n  return s;\n}\n\n/**\n * Where a named bone is, this frame.\n *\n * The slot is the author's own: the Nth #anchor in their file, in the order\n * they wrote them. _rzSlot turns that into the scene's address, which is what\n * keeps two effects that both anchor to a wrist from reading each other's.\n */\nfn rzAnchor(subject: i32, slot: i32) -> RzAnchor {\n  var a: RzAnchor;\n  a.valid = false;\n  let g = _rzSlot(slot);\n  let s = _rzSubjectSlot(subject);\n  if (s < 0 || g < 0 || g >= RZ_MAX_ANCHORS) { return a; }\n  let b = 16 + (g * 4 + s) * 3;\n  a.valid = _rzCast[b].w > 0.5;\n  a.pos = _rzCast[b].xyz;\n  a.vel = _rzCast[b + 1].xyz;\n  a.fwd = _rzCast[b + 2].xyz;\n  return a;\n}\n\n/**\n * How many samples of a path are recorded \u2014 0 for an anchor that asked for no\n * trail, and for one that has not moved yet.\n *\n * Bounded by the anchor cap, NOT by how many anchors asked for a trail. Those\n * are different index spaces: storage is addressed by anchor slot, so an\n * untrailed #anchor followed by a trailed one put the trail at index 1 with a\n * bound of 1 and rzTrail returned zero \u2014 a ribbon that silently did not draw.\n */\nfn rzTrailCount(subject: i32, slot: i32) -> i32 {\n  let g = _rzSlot(slot);\n  let s = _rzSubjectSlot(subject);\n  if (s < 0 || g < 0 || g >= RZ_MAX_ANCHORS) { return 0; }\n  return i32(_rzCast[16 + (g * 4 + s) * 3 + 2].w);\n}\n\n/** Sample i of a path: xyz where it was, w how many seconds ago. i = 0 is now. */\nfn rzTrail(subject: i32, slot: i32, i: i32) -> vec4f {\n  let n = rzTrailCount(subject, slot);\n  if (i < 0 || i >= n) { return vec4f(0.0); }\n  let base = 592 + (_rzSlot(slot) * 4 + _rzSubjectSlot(subject)) * RZ_TRAIL_SAMPLES;\n  return _rzCast[base + i];\n}\n\n\n// The hashes, the noise and rzFalloff \u2014 EFFECT_MATH_API, the same text the\n// particle and trail modules get. The field module used to be missing most of\n// it, so a helper an author wrote for one mount failed to compile in another\n// for no reason visible in the file.\n\nfn rzHash11(x: f32) -> f32 {\n  var p = fract(x * 0.1031);\n  p = p * (p + 33.33);\n  return fract(p * (p + p));\n}\nfn rzHash21(p: vec2f) -> f32 {\n  var p3 = fract(vec3f(p.x, p.y, p.x) * 0.1031);\n  p3 = p3 + dot(p3, p3.yzx + 33.33);\n  return fract((p3.x + p3.y) * p3.z);\n}\n/** Three independent randoms from one seed \u2014 the usual need when spawning. */\nfn rzHash13(x: f32) -> vec3f {\n  return vec3f(rzHash11(x), rzHash11(x + 17.13), rzHash11(x + 41.71));\n}\n/**\n * Compact-support falloff: 1 at the centre, exactly 0 at r, smooth between.\n *\n * It reaches exactly zero rather than merely getting small, because a glow that\n * never quite ends has to be culled somewhere, and culling it wherever it looks\n * close enough is what put a visible hard edge on the first halo effect.\n */\nfn rzFalloff(d: f32, r: f32) -> f32 {\n  let x = clamp(d / max(r, 1e-6), 0.0, 1.0);\n  let f = 1.0 - x;\n  return f * f * f;\n}\nfn rzHash31(p: vec3f) -> f32 {\n  var p3 = fract(p * 0.1031);\n  p3 = p3 + dot(p3, p3.zyx + 31.32);\n  return fract((p3.x + p3.y) * p3.z);\n}\nfn rzValueNoise(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 n000 = rzHash31(i);\n  let n100 = rzHash31(i + vec3f(1.0, 0.0, 0.0));\n  let n010 = rzHash31(i + vec3f(0.0, 1.0, 0.0));\n  let n110 = rzHash31(i + vec3f(1.0, 1.0, 0.0));\n  let n001 = rzHash31(i + vec3f(0.0, 0.0, 1.0));\n  let n101 = rzHash31(i + vec3f(1.0, 0.0, 1.0));\n  let n011 = rzHash31(i + vec3f(0.0, 1.0, 1.0));\n  let n111 = rzHash31(i + vec3f(1.0, 1.0, 1.0));\n  let x00 = mix(n000, n100, u.x);\n  let x10 = mix(n010, n110, u.x);\n  let x01 = mix(n001, n101, u.x);\n  let x11 = mix(n011, n111, u.x);\n  return mix(mix(x00, x10, u.y), mix(x01, x11, u.y), u.z);\n}\n/** Divergence-free flow \u2014 the field a wisp of smoke follows without a solver. */\nfn rzCurlNoise(p: vec3f) -> vec3f {\n  let e = 0.1;\n  let dx = vec3f(e, 0.0, 0.0);\n  let dy = vec3f(0.0, e, 0.0);\n  let dz = vec3f(0.0, 0.0, e);\n  let x0 = rzValueNoise(p - dx); let x1 = rzValueNoise(p + dx);\n  let y0 = rzValueNoise(p - dy); let y1 = rzValueNoise(p + dy);\n  let z0 = rzValueNoise(p - dz); let z1 = rzValueNoise(p + dz);\n  return normalize(vec3f((y1 - y0) - (z1 - z0), (z1 - z0) - (x1 - x0), (x1 - x0) - (y1 - y0)) + vec3f(1e-6));\n}\n\nstruct Particle {\n  pos: vec3f,\n  age: f32,\n  vel: vec3f,\n  life: f32,\n  size: f32,\n  rot: f32,\n  seed: f32,\n  // Aspect along the direction of travel. 1 or less is a square billboard; a\n  // raindrop is 10 or 20. Zero-initialised, so an effect that never sets it gets\n  // the square it expects.\n  stretch: f32,\n}\n\n\n\nfn bgResolution() -> vec2f { return rzResolution(); }\nfn bgCameraPos() -> vec3f { return rzCameraPos(); }\nfn bgSubjectCount() -> i32 { return rzSubjectCount(); }\n\n/**\n * Where a character IS, in world space \u2014 at the hips, not on the floor.\n *\n * An effect that wants to RESPOND to the cast \u2014 a glow that follows someone,\n * dust kicked up where they are \u2014 needs to know where they are, and the ray and\n * the depth cannot tell it: they describe the pixel, not the scene.\n *\n * The value is model.position + \u30BB\u30F3\u30BF\u30FC + \u5168\u3066\u306E\u89AA. \u30BB\u30F3\u30BF\u30FC sits at hip\n * height on every standard MMD rig, so this is a point in the middle of the\n * body. It is NOT the contact point: a ripple drawn here appears at the waist.\n * Ground effects want the .xz of this and their own floor height, which is what\n * the effects that shipped against it already do.\n *\n * The comment here used to claim it was \"between the feet on the floor\", which\n * is where that habit came from. Left as it is regardless of the name: a\n * published link is immutable, so every shared scene pinning an effect that\n * reads this depends on it meaning exactly what it has always meant.\n *\n * Clamped rather than bounds-checked: an effect looping past the count reads the\n * last subject instead of sampling whatever follows the array, which is a wrong\n * ripple rather than an undefined one.\n *\n * THE INDEX IS THE EFFECT'S OWN, like every other cast accessor \u2014 Dry Ice, Water,\n * Holy Light and Bloody Ash all read this one and all of them should place their\n * fog, their ripple and their shaft under the model the scene aimed them at. The\n * mapping is the identity for an effect aimed at nobody in particular, which is\n * every scene published before one could be aimed.\n */\nfn rzSubjectHip(i: i32) -> vec3f { return viewU[11 + clamp(_rzSubjectSlot(i), 0, 3)].xyz; }\n\nfn bgSubjectPos(i: i32) -> vec3f { return rzSubjectHip(i); }\n\n/** Where in the WORLD the scene drew this pixel \u2014 the depth handed to\n *  foreground() turned into a place. Without it an effect can only think in\n *  distances from the lens, which is no use to anything that belongs somewhere:\n *  fog lying on the ground has to know where the ground is.\n *\n *  depth measures along the VIEW AXIS, not along the ray, so it is divided by\n *  the ray's projection onto camera-forward before being walked out. At the far\n *  plane (nothing drawn) this lands a very long way off, which is what a sky\n *  should do to anything reading it. */\nfn rzWorldPos(ray: vec3f, depth: f32) -> vec3f {\n  let axis = max(dot(normalize(ray), viewU[5].xyz), 1e-4);\n  return rzCameraPos() + normalize(ray) * (depth / axis);\n}\n\nfn bgWorldPos(ray: vec3f, depth: f32) -> vec3f { return rzWorldPos(ray, depth); }\n\n/** What an effect returns for one of its lights. */\nstruct RzLight {\n  pos: vec3f,\n  color: vec3f,\n  intensity: f32,\n  radius: f32,\n}\n\n\n/** Color grading, applied to the tonemapped SCENE (not the background \u2014 see the\n *  call site). The core is ASC CDL, the film-industry interchange standard:\n *\n *      out = (in \u00B7 slope + offset) ^ power        then saturation  (SOP \u2192 SAT)\n *\n *  Using the real standard rather than invented controls means a look authored\n *  here maps onto any grading tool. slope/offset/power are derived on the CPU\n *  from the UI's shadow/midtone/highlight colors (see setColorGrading), so the\n *  per-pixel cost is one mul-add, one pow, one lerp. */\nfn grade(c: vec3f) -> vec3f {\n  var x = pow(max(c * viewU[9].xyz + viewU[7].xyz, vec3f(0.0)), viewU[8].xyz);\n  // Contrast pivots on 0.5 \u2014 display-referred midpoint, since we grade post-Filmic.\n  x = (x - vec3f(0.5)) * viewU[7].w + vec3f(0.5);\n  // Rec.709 luma, matching the ASC SAT node.\n  let luma = dot(x, vec3f(0.2126, 0.7152, 0.0722));\n  return max(mix(vec3f(luma), x, viewU[8].w), vec3f(0.0));\n}\n";
+export declare const EFFECT_SCENE_API = "\n// \u2500\u2500 The effect API \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n//\n// Named rz*, for the engine. The prefix earns its place twice: user code is\n// concatenated into THIS module, so an unprefixed rzAnchor() would collide with\n// exactly the helper an author would write, and the old bg* prefix stopped being\n// true in 0.41.0 when effects gained a mount over the finished frame.\n//\n// The bg* names below are permanent aliases, not a deprecation with an end date.\n// A published link is immutable, so a scene pinned to a bg* effect has to keep\n// compiling forever. They are one-line and inlined; no new function gets one.\n\n/** Canvas size in pixels \u2014 for aspect correction. */\nfn rzResolution() -> vec2f { return viewU[6].zw; }\n\n/** The camera's world position. */\nfn rzCameraPos() -> vec3f { return viewU[10].xyz; }\n\n/** How many characters the SCENE holds, up to four \u2014 the number the cast api\n *  narrows to this effect's own subjects. See subjectMaskApi. */\nfn _rzCastLive() -> i32 { return i32(viewU[10].w); }\n\n/**\n * A world point as the camera sees it: xy the uv it lands on, z its distance\n * along the VIEW AXIS in metres.\n *\n * The exact inverse of the ray this pass builds per pixel, so it is the cheap way\n * to work with anything anchored in the world. Marching a curve or a trail in 3D\n * costs a distance evaluation per sample per pixel; projecting its points once\n * and measuring in 2D costs a subtraction, which is the difference between a\n * ribbon that runs at 4K and one that does not.\n *\n * z is directly comparable to the depth handed to foreground(), so occlusion is\n * a single test: draw where your z is nearer than the scene's. It is returned\n * SIGNED and unclamped \u2014 behind the camera is negative, and worth rejecting\n * before you use the uv, which is meaningless there.\n */\nfn rzProject(p: vec3f) -> vec3f {\n  let d = p - viewU[10].xyz;\n  let z = dot(d, viewU[5].xyz);\n  // Guard only the divide. z itself is returned as it is, so the caller can see\n  // the sign; clamping it here would put points behind the lens on the horizon.\n  let inv = 1.0 / select(z, 1e-4, z < 1e-4);\n  let ndc = vec2f(dot(d, viewU[3].xyz) * inv / viewU[3].w, dot(d, viewU[4].xyz) * inv / viewU[4].w);\n  return vec3f(ndc * 0.5 + 0.5, z);\n}\n\nfn rzCamPos() -> vec3f { return rzCameraPos(); }\nfn rzCameraRight() -> vec3f { return viewU[3].xyz; }\nfn rzCameraUp() -> vec3f { return viewU[4].xyz; }\nfn rzCameraForward() -> vec3f { return viewU[5].xyz; }\n\n// The cast \u2014 subjects, anchors, trails \u2014 is CAST_API, shared verbatim with the\n// particle and trail modules. It used to be written out here, a second time, and\n// the two copies had drifted: this one had rzAnchor and that one did not.\n\nconst RZ_SUBJECTS: i32 = 4;\nconst RZ_SAMPLES: i32 = 128;\n/** The anchor ADDRESS SPACE \u2014 how many an effect may declare, not how many it\n *  did. RZ_TRAIL_SLOTS is the per-effect number and is not this one; the two\n *  being one number was the old trail bug. */\nconst RZ_MAX_ANCHORS: i32 = 48;\nconst RZ_TRAIL_SAMPLES: i32 = 128;\n\nstruct RzSubject {\n  /** On the FLOOR, under the body \u2014 where a ring or a magic circle belongs. */\n  root: vec3f,\n  /** At the hips, the middle of the body \u2014 where an aura belongs. */\n  center: vec3f,\n  /** Bounding sphere: xyz centre, w radius. Deliberately generous \u2014 cull with it. */\n  bounds: vec4f,\n  /**\n   * How much of this character is still THERE: 1 whole, 0 gone.\n   *\n   * What setModelDissolve last set on them, which the material pass has already\n   * acted on by the time an effect runs \u2014 so an effect drawing what LEAVES a\n   * dissolving body (sparks, ash, a ghost) reads the same number the body was\n   * taken apart with, rather than keeping a clock of its own and hoping the two\n   * agree. 1 on a scene that never dissolves anybody.\n   */\n  dissolve: f32,\n  /**\n   * Where she LOOKS: a unit direction from between the eyes, in world space.\n   * Exact while her eyes are on something (Engine.setEyeTracking); otherwise\n   * the motion's own eye turn undone through the range map \u2014 an eye bone\n   * turns a fraction of the way toward what it looks at, and this gives back\n   * the whole of it. An effect that should go where the look goes \u2014 a beam,\n   * a light \u2014 takes this rather than an eye bone's axis, and it holds in\n   * either mode. Zero, with looking false, only for a model without eyes.\n   */\n  gaze: vec3f,\n  looking: bool,\n  /** False past the end of the cast, and every field is then zero. */\n  valid: bool,\n}\n\nstruct RzAnchor {\n  pos: vec3f,\n  /** World units per second, from the previous frame. Direction for a trail,\n   *  magnitude for anything that should react to how hard someone is moving. */\n  vel: vec3f,\n  /** The bone's forward axis \u2014 which way a foot points, where a head looks. */\n  fwd: vec3f,\n  /** False when this rig has no such bone. Check it: the alternative is drawing\n   *  a hand effect at the world origin on every model that spells it differently. */\n  valid: bool,\n}\n\n/**\n * How many characters THIS EFFECT is on, up to four.\n *\n * Not how many the scene holds. An effect applies to the whole cast unless the\n * scene says otherwise (Engine.setEffectSubjects), and where it says otherwise\n * this counts only the models named \u2014 so an effect aimed at one dancer sees one\n * subject, at index 0, and an author who wrote a loop over the cast gets the\n * targeting for free.\n *\n * Which is the whole design: the FILTER IS IN THE INDEX SPACE, not in the\n * shaders. There is no mask an effect can read, because an effect asking \"am I\n * allowed on this one\" is an effect that can get the answer wrong, and 18 of the\n * shipped built-ins would have had to be rewritten to ask at all.\n */\nfn rzSubjectCount() -> i32 {\n  let live = _rzCastLive();\n  let mask = _rzSubjectMask();\n  var n = 0;\n  for (var i = 0; i < live; i++) {\n    if ((mask & (1u << u32(i))) != 0u) { n++; }\n  }\n  return n;\n}\n\n/** This effect's i-th subject \u2192 the scene's slot, or -1 past its own count.\n *  Every accessor below goes through it, which is what keeps one effect's\n *  subject 1 from being another's. */\nfn _rzSubjectSlot(i: i32) -> i32 {\n  if (i < 0) { return -1; }\n  let live = _rzCastLive();\n  let mask = _rzSubjectMask();\n  var n = 0;\n  for (var s = 0; s < live; s++) {\n    if ((mask & (1u << u32(s))) == 0u) { continue; }\n    if (n == i) { return s; }\n    n++;\n  }\n  return -1;\n}\n\n/** Which model this is, stable across a scene \u2014 for per-subject variation. */\nfn rzSubjectId(i: i32) -> u32 {\n  let g = _rzSubjectSlot(i);\n  if (g < 0) { return 0u; }\n  return u32(_rzCast[g * 4 + 1].w);\n}\n\nfn rzSubject(i: i32) -> RzSubject {\n  var s: RzSubject;\n  let g = _rzSubjectSlot(i);\n  s.valid = g >= 0;\n  if (!s.valid) { return s; }\n  let b = g * 4;\n  s.root = _rzCast[b].xyz;\n  s.dissolve = _rzCast[b].w;\n  s.center = _rzCast[b + 1].xyz;\n  s.bounds = _rzCast[b + 2];\n  s.gaze = _rzCast[b + 3].xyz;\n  s.looking = _rzCast[b + 3].w > 0.5;\n  return s;\n}\n\n/**\n * Where a named bone is, this frame.\n *\n * The slot is the author's own: the Nth #anchor in their file, in the order\n * they wrote them. _rzSlot turns that into the scene's address, which is what\n * keeps two effects that both anchor to a wrist from reading each other's.\n */\nfn rzAnchor(subject: i32, slot: i32) -> RzAnchor {\n  var a: RzAnchor;\n  a.valid = false;\n  let g = _rzSlot(slot);\n  let s = _rzSubjectSlot(subject);\n  if (s < 0 || g < 0 || g >= RZ_MAX_ANCHORS) { return a; }\n  let b = 16 + (g * 4 + s) * 3;\n  a.valid = _rzCast[b].w > 0.5;\n  a.pos = _rzCast[b].xyz;\n  a.vel = _rzCast[b + 1].xyz;\n  a.fwd = _rzCast[b + 2].xyz;\n  return a;\n}\n\n/**\n * How many samples of a path are recorded \u2014 0 for an anchor that asked for no\n * trail, and for one that has not moved yet.\n *\n * Bounded by the anchor cap, NOT by how many anchors asked for a trail. Those\n * are different index spaces: storage is addressed by anchor slot, so an\n * untrailed #anchor followed by a trailed one put the trail at index 1 with a\n * bound of 1 and rzTrail returned zero \u2014 a ribbon that silently did not draw.\n */\nfn rzTrailCount(subject: i32, slot: i32) -> i32 {\n  let g = _rzSlot(slot);\n  let s = _rzSubjectSlot(subject);\n  if (s < 0 || g < 0 || g >= RZ_MAX_ANCHORS) { return 0; }\n  return i32(_rzCast[16 + (g * 4 + s) * 3 + 2].w);\n}\n\n/** Sample i of a path: xyz where it was, w how many seconds ago. i = 0 is now. */\nfn rzTrail(subject: i32, slot: i32, i: i32) -> vec4f {\n  let n = rzTrailCount(subject, slot);\n  if (i < 0 || i >= n) { return vec4f(0.0); }\n  let base = 592 + (_rzSlot(slot) * 4 + _rzSubjectSlot(subject)) * RZ_TRAIL_SAMPLES;\n  return _rzCast[base + i];\n}\n\n\n// The hashes, the noise and rzFalloff \u2014 EFFECT_MATH_API, the same text the\n// particle and trail modules get. The field module used to be missing most of\n// it, so a helper an author wrote for one mount failed to compile in another\n// for no reason visible in the file.\n\nfn rzHash11(x: f32) -> f32 {\n  var p = fract(x * 0.1031);\n  p = p * (p + 33.33);\n  return fract(p * (p + p));\n}\nfn rzHash21(p: vec2f) -> f32 {\n  var p3 = fract(vec3f(p.x, p.y, p.x) * 0.1031);\n  p3 = p3 + dot(p3, p3.yzx + 33.33);\n  return fract((p3.x + p3.y) * p3.z);\n}\n/** Three independent randoms from one seed \u2014 the usual need when spawning. */\nfn rzHash13(x: f32) -> vec3f {\n  return vec3f(rzHash11(x), rzHash11(x + 17.13), rzHash11(x + 41.71));\n}\n/**\n * Compact-support falloff: 1 at the centre, exactly 0 at r, smooth between.\n *\n * It reaches exactly zero rather than merely getting small, because a glow that\n * never quite ends has to be culled somewhere, and culling it wherever it looks\n * close enough is what put a visible hard edge on the first halo effect.\n */\nfn rzFalloff(d: f32, r: f32) -> f32 {\n  let x = clamp(d / max(r, 1e-6), 0.0, 1.0);\n  let f = 1.0 - x;\n  return f * f * f;\n}\nfn rzHash31(p: vec3f) -> f32 {\n  var p3 = fract(p * 0.1031);\n  p3 = p3 + dot(p3, p3.zyx + 31.32);\n  return fract((p3.x + p3.y) * p3.z);\n}\nfn rzValueNoise(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 n000 = rzHash31(i);\n  let n100 = rzHash31(i + vec3f(1.0, 0.0, 0.0));\n  let n010 = rzHash31(i + vec3f(0.0, 1.0, 0.0));\n  let n110 = rzHash31(i + vec3f(1.0, 1.0, 0.0));\n  let n001 = rzHash31(i + vec3f(0.0, 0.0, 1.0));\n  let n101 = rzHash31(i + vec3f(1.0, 0.0, 1.0));\n  let n011 = rzHash31(i + vec3f(0.0, 1.0, 1.0));\n  let n111 = rzHash31(i + vec3f(1.0, 1.0, 1.0));\n  let x00 = mix(n000, n100, u.x);\n  let x10 = mix(n010, n110, u.x);\n  let x01 = mix(n001, n101, u.x);\n  let x11 = mix(n011, n111, u.x);\n  return mix(mix(x00, x10, u.y), mix(x01, x11, u.y), u.z);\n}\n/** Divergence-free flow \u2014 the field a wisp of smoke follows without a solver. */\nfn rzCurlNoise(p: vec3f) -> vec3f {\n  let e = 0.1;\n  let dx = vec3f(e, 0.0, 0.0);\n  let dy = vec3f(0.0, e, 0.0);\n  let dz = vec3f(0.0, 0.0, e);\n  let x0 = rzValueNoise(p - dx); let x1 = rzValueNoise(p + dx);\n  let y0 = rzValueNoise(p - dy); let y1 = rzValueNoise(p + dy);\n  let z0 = rzValueNoise(p - dz); let z1 = rzValueNoise(p + dz);\n  return normalize(vec3f((y1 - y0) - (z1 - z0), (z1 - z0) - (x1 - x0), (x1 - x0) - (y1 - y0)) + vec3f(1e-6));\n}\n\nstruct Particle {\n  pos: vec3f,\n  age: f32,\n  vel: vec3f,\n  life: f32,\n  size: f32,\n  rot: f32,\n  seed: f32,\n  // Aspect along the direction of travel. 1 or less is a square billboard; a\n  // raindrop is 10 or 20. Zero-initialised, so an effect that never sets it gets\n  // the square it expects.\n  stretch: f32,\n}\n\n\n\nfn bgResolution() -> vec2f { return rzResolution(); }\nfn bgCameraPos() -> vec3f { return rzCameraPos(); }\nfn bgSubjectCount() -> i32 { return rzSubjectCount(); }\n\n/**\n * Where a character IS, in world space \u2014 at the hips, not on the floor.\n *\n * An effect that wants to RESPOND to the cast \u2014 a glow that follows someone,\n * dust kicked up where they are \u2014 needs to know where they are, and the ray and\n * the depth cannot tell it: they describe the pixel, not the scene.\n *\n * The value is model.position + \u30BB\u30F3\u30BF\u30FC + \u5168\u3066\u306E\u89AA. \u30BB\u30F3\u30BF\u30FC sits at hip\n * height on every standard MMD rig, so this is a point in the middle of the\n * body. It is NOT the contact point: a ripple drawn here appears at the waist.\n * Ground effects want the .xz of this and their own floor height, which is what\n * the effects that shipped against it already do.\n *\n * The comment here used to claim it was \"between the feet on the floor\", which\n * is where that habit came from. Left as it is regardless of the name: a\n * published link is immutable, so every shared scene pinning an effect that\n * reads this depends on it meaning exactly what it has always meant.\n *\n * Clamped rather than bounds-checked: an effect looping past the count reads the\n * last subject instead of sampling whatever follows the array, which is a wrong\n * ripple rather than an undefined one.\n *\n * THE INDEX IS THE EFFECT'S OWN, like every other cast accessor \u2014 Dry Ice, Water,\n * Holy Light and Bloody Ash all read this one and all of them should place their\n * fog, their ripple and their shaft under the model the scene aimed them at. The\n * mapping is the identity for an effect aimed at nobody in particular, which is\n * every scene published before one could be aimed.\n */\nfn rzSubjectHip(i: i32) -> vec3f { return viewU[11 + clamp(_rzSubjectSlot(i), 0, 3)].xyz; }\n\nfn bgSubjectPos(i: i32) -> vec3f { return rzSubjectHip(i); }\n\n/** Where in the WORLD the scene drew this pixel \u2014 the depth handed to\n *  foreground() turned into a place. Without it an effect can only think in\n *  distances from the lens, which is no use to anything that belongs somewhere:\n *  fog lying on the ground has to know where the ground is.\n *\n *  depth measures along the VIEW AXIS, not along the ray, so it is divided by\n *  the ray's projection onto camera-forward before being walked out. At the far\n *  plane (nothing drawn) this lands a very long way off, which is what a sky\n *  should do to anything reading it. */\nfn rzWorldPos(ray: vec3f, depth: f32) -> vec3f {\n  let axis = max(dot(normalize(ray), viewU[5].xyz), 1e-4);\n  return rzCameraPos() + normalize(ray) * (depth / axis);\n}\n\nfn bgWorldPos(ray: vec3f, depth: f32) -> vec3f { return rzWorldPos(ray, depth); }\n\n/** What an effect returns for one of its lights. */\nstruct RzLight {\n  pos: vec3f,\n  color: vec3f,\n  intensity: f32,\n  radius: f32,\n}\n\n\n/** Color grading, applied to the tonemapped SCENE (not the background \u2014 see the\n *  call site). The core is ASC CDL, the film-industry interchange standard:\n *\n *      out = (in \u00B7 slope + offset) ^ power        then saturation  (SOP \u2192 SAT)\n *\n *  Using the real standard rather than invented controls means a look authored\n *  here maps onto any grading tool. slope/offset/power are derived on the CPU\n *  from the UI's shadow/midtone/highlight colors (see setColorGrading), so the\n *  per-pixel cost is one mul-add, one pow, one lerp. */\nfn grade(c: vec3f) -> vec3f {\n  var x = pow(max(c * viewU[9].xyz + viewU[7].xyz, vec3f(0.0)), viewU[8].xyz);\n  // Contrast pivots on 0.5 \u2014 display-referred midpoint, since we grade post-Filmic.\n  x = (x - vec3f(0.5)) * viewU[7].w + vec3f(0.5);\n  // Rec.709 luma, matching the ASC SAT node.\n  let luma = dot(x, vec3f(0.2126, 0.7152, 0.0722));\n  return max(mix(vec3f(luma), x, viewU[8].w), vec3f(0.0));\n}\n\n";
 export declare function buildCompositeShader(effect?: CompositeEffectSource | null): string;
 /**
  * The field pass: the user's background/foreground mounts at half resolution,

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

@@ -1 +1 @@
-{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/composite.ts"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAgC+B;AAC/B;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,EAAE,CAIhG;AAID,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAEzG,KAAK,qBAAqB,GAAG;IAC3B,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAA;IACZ,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAA;IAClB,4DAA4D;IAC5D,aAAa,EAAE,OAAO,CAAA;IACtB,oEAAoE;IACpE,aAAa,EAAE,OAAO,CAAA;IACtB;6DACyD;IACzD,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,gFAAgF;IAChF,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAA;IAChB;mFAC+E;IAC/E,GAAG,CAAC,EAAE,OAAO,CAAA;IACb;;;yEAGqE;IACrE,UAAU,EAAE,MAAM,CAAA;IAClB;;8EAE0E;IAC1E,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;CACjB,CAAA;AA+LD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,+ufAsI5B,CAAA;AA8MD,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,IAAI,GAAG,MAAM,CAclF;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,qBAAqB,GAAG,MAAM,CA0GtE;AAED,iFAAiF;AACjF,eAAO,MAAM,qBAAqB,QAA6B,CAAA"}
+{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/composite.ts"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAgC+B;AAC/B;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,EAAE,CAIhG;AAID,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAEzG,KAAK,qBAAqB,GAAG;IAC3B,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAA;IACZ,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAA;IAClB,4DAA4D;IAC5D,aAAa,EAAE,OAAO,CAAA;IACtB,oEAAoE;IACpE,aAAa,EAAE,OAAO,CAAA;IACtB;6DACyD;IACzD,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,gFAAgF;IAChF,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAA;IAChB;mFAC+E;IAC/E,GAAG,CAAC,EAAE,OAAO,CAAA;IACb;;;yEAGqE;IACrE,UAAU,EAAE,MAAM,CAAA;IAClB;;8EAE0E;IAC1E,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;CACjB,CAAA;AA8ND;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,ivfAuI5B,CAAA;AA8MD,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,IAAI,GAAG,MAAM,CAclF;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,qBAAqB,GAAG,MAAM,CA0GtE;AAED,iFAAiF;AACjF,eAAO,MAAM,qBAAqB,QAA6B,CAAA"}

package/dist/shaders/passes/composite.js

@@ -123,7 +123,8 @@ override APPLY_GAMMA: bool = true;
 //            per frame while skybox/effect active.
 // viewU[6] = (time seconds, view transform id, canvas width, canvas height).
 // viewU[7] = (grade offset.rgb, contrast);  viewU[8] = (grade power.rgb, saturation);
-// viewU[9] = (grade slope.rgb, grade on/off) — see grade() below.
+// 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.
 // invGamma = 1/gamma precomputed on CPU — avoids a per-pixel divide.
 @group(0) @binding(6) var bgEquirect: texture_2d<f32>;
@@ -144,6 +145,9 @@ override APPLY_GAMMA: bool = true;
 // Blender's AgX, as the 57³ lookup it ships as rather than a reconstruction of
 // it. Sampled in the log-encoded E-Gamut space the cube expects — see agxTransform.
 @group(0) @binding(10) var agxLut: texture_3d<f32>;
+// The scene's own colour grade, as a cube — see _rzStageGrade. sRGB-encoded
+// storage, so what a sample returns is already linear.
+@group(0) @binding(12) var stageGradeLut: texture_3d<f32>;
 // The cast, as data. Read through rzSubject/rzAnchor below — the LAYOUT IS NOT
 // STABLE and never will be, because it depends on what each effect declared.
 // Reading it directly is the one thing that would freeze it forever.
@@ -272,6 +276,33 @@ fn viewTransform(c: vec3f) -> vec3f {
   if (mode > 0.5) { return vec3f(srgb_encode(c.r), srgb_encode(c.g), srgb_encode(c.b)); }
   return vec3f(filmic(c.r), filmic(c.g), filmic(c.b));
 }
+
+fn _rzSrgbDecode(x: f32) -> f32 {
+  let c = max(x, 0.0);
+  return select(pow((c + 0.055) / 1.055, 2.4), c / 12.92, c <= 0.04045);
+}
+
+/** The grade a scene arrived with — a game's, baked to a cube by its converter
+ *  (setStageGrade). Looked up the way that game's final pass looks it up: the
+ *  formed colour, linear, clamped to the cube, with texel centres at the ends,
+ *  and trilinear between. The lookup is the whole grade; it has no dials. */
+fn _rzStageGrade(c: vec3f) -> vec3f {
+  let lin = clamp(vec3f(_rzSrgbDecode(c.r), _rzSrgbDecode(c.g), _rzSrgbDecode(c.b)), vec3f(0.0), vec3f(1.0));
+  let n = f32(textureDimensions(stageGradeLut).x);
+  let graded = textureSampleLevel(stageGradeLut, bloomSamp, lin * ((n - 1.0) / n) + 0.5 / n, 0.0).rgb;
+  return vec3f(srgb_encode(graded.r), srgb_encode(graded.g), srgb_encode(graded.b));
+}
+
+/** Both grades, in order: the scene's own first, as the room was graded, then
+ *  the author's CDL on top of it. Each is behind its own flag bit in viewU[9].w
+ *  so a scene with neither pays one uniform branch. */
+fn _rzGradeScene(c: vec3f) -> vec3f {
+  let flags = u32(viewU[9].w);
+  var x = c;
+  if ((flags & 2u) != 0u) { x = _rzStageGrade(x); }
+  if ((flags & 1u) != 0u) { x = grade(x); }
+  return x;
+}
 `;
 /**
  * The scene half of the effect API — camera, projection, cast, trails.
@@ -420,6 +451,7 @@ fn grade(c: vec3f) -> vec3f {
   let luma = dot(x, vec3f(0.2126, 0.7152, 0.0722));
   return max(mix(vec3f(luma), x, viewU[8].w), vec3f(0.0));
 }
+
 `;
 const COMPOSITE_BODY = /* wgsl */ `
 @vertex fn vs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
@@ -501,7 +533,7 @@ const COMPOSITE_BODY = /* wgsl */ `
   // load-bearing — leaves green-screen mode's key color unshifted so chroma
   // keying still works. Skipped entirely when the grade is neutral.
   if (viewU[9].w > 0.5) {
-    disp = grade(disp);
+    disp = _rzGradeScene(disp);
   }
   if (APPLY_GAMMA) {
     disp = pow(disp, vec3f(viewU[0].y));

package/dist/shaders/passes/physics-debug.d.ts

@@ -0,0 +1,2 @@
+export declare const PHYSICS_DEBUG_SHADER_WGSL = "\nstruct CameraUniforms {\n  view: mat4x4f,\n  projection: mat4x4f,\n  viewPos: vec3f,\n  _pad: f32,\n};\n\n@group(0) @binding(0) var<uniform> camera: CameraUniforms;\n\noverride SHAPE_KIND: u32 = 0u;\noverride SOLID_ALPHA: f32 = 1.0;\n\nstruct VsIn {\n  @location(0) unit: vec4f,       // xyz = unit pos; w = capsule axial anchor\n  @location(1) modelCol0: vec4f,\n  @location(2) modelCol1: vec4f,\n  @location(3) modelCol2: vec4f,\n  @location(4) modelCol3: vec4f,\n  @location(5) size: vec4f,       // xyz = size; w unused\n  @location(6) color: vec4f,\n};\n\nstruct VsOut {\n  @builtin(position) pos: vec4f,\n  @location(0) color: vec4f,\n};\n\n@vertex\nfn vsMain(in: VsIn) -> VsOut {\n  let model = mat4x4f(in.modelCol0, in.modelCol1, in.modelCol2, in.modelCol3);\n  var local: vec3f;\n  if (SHAPE_KIND == 1u) {\n    local = in.unit.xyz * in.size.xyz;\n  } else if (SHAPE_KIND == 2u) {\n    // PMX capsule: size.x = radius, size.y = full cylinder height. Bullet 2.x's\n    // btCapsuleShape(radius, height) stores height/2 internally, so the actual\n    // collision cylinder spans \u00B1size.y/2 \u2014 halve here to match.\n    let r = in.size.x;\n    let halfH = in.size.y * 0.5;\n    local = vec3f(in.unit.x * r, in.unit.y * r + halfH * in.unit.w, in.unit.z * r);\n  } else {\n    local = in.unit.xyz * in.size.x;\n  }\n  let world = model * vec4f(local, 1.0);\n  var out: VsOut;\n  out.pos = camera.projection * camera.view * world;\n  out.color = in.color;\n  return out;\n}\n\n@fragment\nfn fsMain(in: VsOut) -> @location(0) vec4f {\n  return vec4f(in.color.rgb, in.color.a * SOLID_ALPHA);\n}\n";
+//# sourceMappingURL=physics-debug.d.ts.map

package/dist/shaders/passes/physics-debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"physics-debug.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/physics-debug.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,yBAAyB,2kDAuDrC,CAAA"}

package/dist/shaders/passes/physics-debug.js

@@ -0,0 +1,69 @@
+// Wireframe + solid overlay for physics rigid bodies (sphere / box / capsule).
+// Rendered in its own pass after composite, straight to the swapchain — no
+// MSAA, no depth, no MRT — so it sits cleanly on top of the tonemapped scene
+// regardless of camera angle, model occlusion, or the composite alpha gate.
+//
+//   SHAPE_KIND   0 = sphere   → unit-sphere line/tri primitive scaled by size.x (radius)
+//                1 = box      → unit cube ±1 scaled by size.xyz (half-extents)
+//                2 = capsule  → unit cap+ring with per-vertex `axial` (-1/0/+1)
+//                               that lifts cap rings/arcs ±halfHeight along Y;
+//                               XZ scales by size.x (radius), Y by size.y/2.
+//   SOLID_ALPHA  fragment alpha multiplier. Wireframe pipelines leave this at
+//                1.0 for crisp edges; solid pipelines set it to ~0.2 so the fill
+//                stays gentle under stacked bodies.
+export const PHYSICS_DEBUG_SHADER_WGSL = /* wgsl */ `
+struct CameraUniforms {
+  view: mat4x4f,
+  projection: mat4x4f,
+  viewPos: vec3f,
+  _pad: f32,
+};
+
+@group(0) @binding(0) var<uniform> camera: CameraUniforms;
+
+override SHAPE_KIND: u32 = 0u;
+override SOLID_ALPHA: f32 = 1.0;
+
+struct VsIn {
+  @location(0) unit: vec4f,       // xyz = unit pos; w = capsule axial anchor
+  @location(1) modelCol0: vec4f,
+  @location(2) modelCol1: vec4f,
+  @location(3) modelCol2: vec4f,
+  @location(4) modelCol3: vec4f,
+  @location(5) size: vec4f,       // xyz = size; w unused
+  @location(6) color: vec4f,
+};
+
+struct VsOut {
+  @builtin(position) pos: vec4f,
+  @location(0) color: vec4f,
+};
+
+@vertex
+fn vsMain(in: VsIn) -> VsOut {
+  let model = mat4x4f(in.modelCol0, in.modelCol1, in.modelCol2, in.modelCol3);
+  var local: vec3f;
+  if (SHAPE_KIND == 1u) {
+    local = in.unit.xyz * in.size.xyz;
+  } else if (SHAPE_KIND == 2u) {
+    // PMX capsule: size.x = radius, size.y = full cylinder height. Bullet 2.x's
+    // btCapsuleShape(radius, height) stores height/2 internally, so the actual
+    // collision cylinder spans ±size.y/2 — halve here to match.
+    let r = in.size.x;
+    let halfH = in.size.y * 0.5;
+    local = vec3f(in.unit.x * r, in.unit.y * r + halfH * in.unit.w, in.unit.z * r);
+  } else {
+    local = in.unit.xyz * in.size.x;
+  }
+  let world = model * vec4f(local, 1.0);
+  var out: VsOut;
+  out.pos = camera.projection * camera.view * world;
+  out.color = in.color;
+  return out;
+}
+
+@fragment
+fn fsMain(in: VsOut) -> @location(0) vec4f {
+  return vec4f(in.color.rgb, in.color.a * SOLID_ALPHA);
+}
+`;

package/dist/shaders/scene-tap.js

@@ -196,7 +196,7 @@ fn rzSceneHit(uv: vec2f) -> bool {
  */
 fn rzSceneDisplay(uv: vec2f) -> vec3f {
   var c = max(viewTransform(rzScene(uv) * exp2(viewU[0].x)), vec3f(0.0));
-  if (viewU[9].w > 0.5) { c = grade(c); }
+  if (viewU[9].w > 0.5) { c = _rzGradeScene(c); }
   return pow(max(c, vec3f(0.0)), vec3f(viewU[0].y));
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reze-engine",
-  "version": "0.60.4",
+  "version": "0.61.0",
   "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",