reze-engine 0.60.4 → 0.61.0

package/src/shaders/lights.ts

@@ -362,6 +362,25 @@ fn rzLightsDiffuse(p: vec3f, n: vec3f) -> vec3f {
   return _rzLightsIrradiance(p, n) * (1.0 / 3.141592653589793);
 }
 
+// ONE WALK PER FRAGMENT. A principled closure walks the lamps for its specular
+// anyway, and every lamp's reach, falloff and cone are the same numbers the
+// diffuse layer needs — so that walk computes both, against the normal the
+// material prelude recorded here, and leaves the diffuse for the epilogue.
+// Walking the grid twice was ~60% of a lit stage's frame.
+var<private> _rzLampN: vec3f;
+var<private> _rzLampDiffuse: vec3f;
+var<private> _rzLampDiffuseSet: bool = false;
+// Set by a closure that shaded the lamps' diffuse itself (a Unity-mode
+// principled, which tints it by its own base) — the epilogue then adds none.
+var<private> _rzLampDiffuseTaken: bool = false;
+
+/** rzLightsDiffuse(p, _rzLampN), taken from a principled walk when one ran. */
+fn rzLightsDiffuseOnce(p: vec3f, n: vec3f) -> vec3f {
+  if (_rzLampDiffuseTaken) { return vec3f(0.0); }
+  if (_rzLampDiffuseSet) { return _rzLampDiffuse; }
+  return rzLightsDiffuse(p, n);
+}
+
 fn _rzLightsIrradiance(p: vec3f, n: vec3f) -> vec3f {
   var acc = vec3f(0.0);
   let count = rzLightCount();

package/src/shaders/materials/common.ts

@@ -54,6 +54,13 @@ struct LightUniforms {
   lights: array<Light, 4>,
   /** Irradiance SH of the HDRI world; [0].w is the on-flag. */
   sh: array<vec4f, 9>,
+  /** The scene fog (Engine.setSceneFog): haze (colour, amount), (distance,
+   *  height), then the second layer the same. Amount 0 is none. */
+  fog: array<vec4f, 4>,
+  /** The cast's shadow on a stage (Engine.setStageCastShadow): colour, amount;
+   *  amount 0 is off. Then the view-projection its map was drawn with. */
+  castShadow: vec4f,
+  castVP: mat4x4f,
 };
 
 // Per-material uniforms. Every material binds this layout even if it ignores fields;
@@ -121,8 +128,19 @@ struct VertexOutput {
    * must agree — a pass that disagrees punches holes through her.
    */
   @location(4) @interpolate(flat) faceT: f32,
+  /** The scene fog's two amounts, computed PER VERTEX as the game does — see
+   *  Engine.setSceneFog — and interpolated across the face. */
+  @location(5) fog: vec2f,
 };
 
+/** One fog layer's amount at a vertex of view depth d and world height y. */
+fn _rzFogAmount(d: f32, y: f32, col: vec4f, p: vec4f) -> f32 {
+  if (col.w <= 0.0) { return 0.0; }
+  let f = clamp(d * p.x + p.y, 0.0, 1.0);
+  let h = clamp((p.z - y) / p.w, -1.0, 1.0);
+  return (1.0 - clamp(f - (1.0 - f) * h, 0.0, 1.0)) * col.w;
+}
+
 // One view-projection per shadow cascade, inner to outer — the volumes built
 // by shadow-cascades.ts, in the same order.
 struct LightVP { viewProj: array<mat4x4f, ${SHADOW_CASCADES.length}>, };
@@ -144,6 +162,30 @@ struct LightVP { viewProj: array<mat4x4f, ${SHADOW_CASCADES.length}>, };
 // has the 1x1 fallback bound here; rzWorldSpecular checks the SH flag and
 // answers with the flat ambient instead, so nothing samples the placeholder.
 @group(0) @binding(8) var worldEnvTexture: texture_2d<f32>;
+// The cast's own shadow map for a stage's floor — see _rzCastShadow.
+@group(0) @binding(10) var castShadowMap: texture_depth_2d;
+
+/**
+ * How much of the cast stands between this point and the stage's shadow
+ * direction, 0–1 — setStageCastShadow. A 5×5 comparison filter at 1.5 texels:
+ * the game blurs its character shadow before laying it, and a single tap reads
+ * as a stencil.
+ */
+fn _rzCastShadow(wp: vec3f) -> f32 {
+  if (light.castShadow.w <= 0.0) { return 0.0; }
+  let c = light.castVP * vec4f(wp, 1.0);
+  let ndc = c.xyz / c.w;
+  if (abs(ndc.x) >= 1.0 || abs(ndc.y) >= 1.0 || ndc.z <= 0.0 || ndc.z >= 1.0) { return 0.0; }
+  let uv = vec2f(ndc.x * 0.5 + 0.5, 0.5 - ndc.y * 0.5);
+  let ts = 1.5 / f32(textureDimensions(castShadowMap).x);
+  var lit = 0.0;
+  for (var y = -2; y <= 2; y++) {
+    for (var x = -2; x <= 2; x++) {
+      lit += textureSampleCompareLevel(castShadowMap, shadowSampler, uv + vec2f(f32(x), f32(y)) * ts, ndc.z - 0.001);
+    }
+  }
+  return 1.0 - lit / 25.0;
+}
 // binding(9) brdfLut is declared inside NODES_WGSL (nodes.ts).
 @group(1) @binding(0) var<storage, read> skinMats: array<mat4x4f>;
 // The light this model takes apart from the scene's — see Engine.setModelFill
@@ -273,6 +315,11 @@ const COMMON_VS_WGSL = /* wgsl */ `
   output.worldPos = skinnedPos.xyz;
   output.restPos = position;
   output.faceT = rz_dissolve_threshold(position);
+  let viewZ = (camera.view * vec4f(skinnedPos.xyz, 1.0)).z;
+  output.fog = vec2f(
+    _rzFogAmount(viewZ, skinnedPos.y, light.fog[0], light.fog[1]),
+    _rzFogAmount(viewZ, skinnedPos.y, light.fog[2], light.fog[3]),
+  );
   return output;
 }
 

package/src/shaders/materials/nodes.ts

@@ -312,6 +312,21 @@ fn point_world_to_camera(p: vec3f) -> vec3f { return (camera.view * vec4f(p, 1.0
  * texture sees no change at all.
  */
 fn rzWorldSpecular(dir: vec3f, roughness: f32) -> vec3f {
+  return rzWorldSpecularLod(dir, roughness, 0.0);
+}
+
+/**
+ * The same, with the blur curve chosen. unity = 0 is the sqrt ramp above; 1 is
+ * Unity's reflection-probe lookup, mip = p·(1.7 − 0.7p)·8 — the curve a game's
+ * glossy floor was tuned under, about a level sharper than sqrt through the
+ * glossy range (roughness 0.1–0.3) and the same by 0.5.
+ *
+ * Its levels map one to one onto this chain's: a cube of N texels a face and an
+ * equirect 4N wide resolve the same angle per texel, so a cube's last level —
+ * one texel a face — is this chain's log2(width/4), and the curve stops there
+ * rather than averaging the whole sky, as the game's does.
+ */
+fn rzWorldSpecularLod(dir: vec3f, roughness: f32, unity: f32) -> vec3f {
   // A SKY TEXTURE, or the best the scene has. The flag is 2 when an HDRI is
   // installed, 1 when the world is a gradient fitted to the same harmonics,
   // and 0 when it is one flat colour — and in the last two cases the ambient
@@ -327,7 +342,9 @@ fn rzWorldSpecular(dir: vec3f, roughness: f32) -> vec3f {
   // sqrt, not linear: mip n covers roughly twice the angle of n-1, so a linear
   // ramp spends most of its travel in the blurry end and a mirror-to-satin
   // sweep happens entirely in the first tenth of the dial.
-  let lod = clamp(sqrt(clamp(roughness, 0.0, 1.0)) * levels, 0.0, levels);
+  let r = clamp(roughness, 0.0, 1.0);
+  let unityLod = min(r * (1.7 - 0.7 * r) * 8.0, max(levels - 2.0, 0.0));
+  let lod = clamp(mix(sqrt(r) * levels, unityLod, unity), 0.0, levels);
   return textureSampleLevel(worldEnvTexture, diffuseSampler, vec2f(u, v), lod).rgb * light.ambientColor.w;
 }
 
@@ -866,6 +883,28 @@ fn bsdf_ggx(N: vec3f, L: vec3f, V: vec3f, NL_in: f32, NV_in: f32, roughness: f32
   return NL * a2 / (D_opti * G);
 }
 
+// URP's direct-light specular, as a game on URP (or a fork of it) shades its
+// lamps and sun: D·V·F folded into a2 / (d²·max(0.1, LoH²)·(4a + 2)), a the
+// SQUARED roughness. Unity folds π into its light units, and a light that came
+// from one reaches this engine with that π restored (see the app's stage
+// loader), so it comes back out here. Returns BRDF × NL, like bsdf_ggx.
+fn bsdf_urp(N: vec3f, L: vec3f, V: vec3f, NL: f32, roughness: f32) -> f32 {
+  let a = max(roughness * roughness, 6.1035156e-5);
+  let a2 = a * a;
+  let H = normalize(L + V);
+  let NH = max(dot(N, H), 0.0);
+  let LH = max(dot(L, H), 0.0);
+  let d = NH * NH * (a2 - 1.0) + 1.00001;
+  return a2 / (d * d * max(0.1, LH * LH) * (a * 4.0 + 2.0)) * NL / EEVEE_PI;
+}
+
+/** The direct-light lobe a principled closure asked for: 0 the engine's own,
+ *  1 URP's (principled's unity_direct). */
+fn _rzDirectLobe(N: vec3f, L: vec3f, V: vec3f, NL: f32, NV: f32, roughness: f32, unity: f32) -> f32 {
+  if (unity > 0.5) { return bsdf_urp(N, L, V, NL, roughness); }
+  return bsdf_ggx(N, L, V, NL, NV, roughness);
+}
+
 // Split-sum DFG LUT — Karis 2013 curve fit stand-in for the 64×64 baked LUT.
 // Returns (lut.x, lut.y) in Blender convention: tint = f0·lut.x + f90·lut.y.
 fn brdf_lut_approx(NV: f32, roughness: f32) -> vec2f {
@@ -997,50 +1036,74 @@ fn principled_specular(ior: f32, level: f32) -> f32 {
 // It walks the light grid a second time — the lamps THIS CELL can see, which
 // is what the grid is for — and with no lamps at all neither walk runs.
 
-fn _rzLampSpecOne(i: u32, p: vec3f, n: vec3f, v: vec3f, ndv: f32, roughness: f32) -> vec3f {
+// The walk also yields the DIFFUSE layer, against the prelude's normal
+// (_rzLampN, not the mapped N) and in the order rzLightsDiffuse sums it, so the
+// epilogue's rzLightsDiffuseOnce is that function's exact answer without a
+// second pass over the grid. See lights.ts.
+struct _RzLampPair { d: vec3f, s: vec3f };
+
+fn _rzLampOne(i: u32, p: vec3f, n: vec3f, v: vec3f, ndv: f32, roughness: f32, unity: f32) -> _RzLampPair {
+  var out = _RzLampPair(vec3f(0.0), vec3f(0.0));
   let pr = _rzLightVec(i, 0u);
   let d = pr.xyz - p;
   let dist = length(d);
-  if (dist >= pr.w) { return vec3f(0.0); }
+  if (dist >= pr.w) { return out; }
   let toLight = d / max(dist, 1e-4);
+  let ndlD = max(dot(_rzLampN, toLight), 0.0);
   let ndl = dot(n, toLight);
-  if (ndl <= 0.0) { return vec3f(0.0); }
+  if (ndlD <= 0.0 && ndl <= 0.0) { return out; }
   let t = clamp(dist / max(pr.w, 1e-4), 0.0, 1.0);
   let t2 = t * t;
   let window = 1.0 - t2 * t2;
   let falloff = window * window / max(dist * dist, RZ_LAMP_NEAR * RZ_LAMP_NEAR);
   let cone = rzLightCone(i);
   let aim = clamp((dot(-toLight, rzLightAim(i)) - cone.x) / max(cone.y - cone.x, 1e-4), 0.0, 1.0);
-  return rzLightColor(i) * (bsdf_ggx(n, toLight, v, ndl, ndv, roughness) * falloff * aim * aim);
+  let c = rzLightColor(i);
+  if (ndlD > 0.0) { out.d = c * (ndlD * falloff * aim * aim); }
+  if (ndl > 0.0) { out.s = c * (_rzDirectLobe(n, toLight, v, ndl, ndv, roughness, unity) * falloff * aim * aim); }
+  return out;
 }
 
-fn _rzLampSpecWord(bits0: u32, base: u32, p: vec3f, n: vec3f, v: vec3f, ndv: f32, roughness: f32) -> vec3f {
-  var acc = vec3f(0.0);
+fn _rzLampWord(bits0: u32, base: u32, p: vec3f, n: vec3f, v: vec3f, ndv: f32, roughness: f32, unity: f32) -> _RzLampPair {
+  var acc = _RzLampPair(vec3f(0.0), vec3f(0.0));
   var bits = bits0;
   loop {
     if (bits == 0u) { break; }
     let i = base + firstTrailingBit(bits);
     bits = bits & (bits - 1u);
-    acc = acc + _rzLampSpecOne(i, p, n, v, ndv, roughness);
+    let one = _rzLampOne(i, p, n, v, ndv, roughness, unity);
+    acc.d = acc.d + one.d;
+    acc.s = acc.s + one.s;
   }
   return acc;
 }
 
-fn rzLampsSpecular(p: vec3f, n: vec3f, v: vec3f, ndv: f32, roughness: f32) -> vec3f {
-  var acc = vec3f(0.0);
+fn rzLampsSpecular(p: vec3f, n: vec3f, v: vec3f, ndv: f32, roughness: f32, unity: f32) -> vec3f {
+  var d = vec3f(0.0);
+  var s = vec3f(0.0);
   let count = rzLightCount();
   let docs = _rzLightDocCount();
   if (docs > 0u) {
     let m = _rzLightCellMask(p);
-    acc = acc + _rzLampSpecWord(m.x, 0u, p, n, v, ndv, roughness) +
-      _rzLampSpecWord(m.y, 32u, p, n, v, ndv, roughness) +
-      _rzLampSpecWord(m.z, 64u, p, n, v, ndv, roughness) +
-      _rzLampSpecWord(m.w, 96u, p, n, v, ndv, roughness);
+    let wx = _rzLampWord(m.x, 0u, p, n, v, ndv, roughness, unity);
+    let wy = _rzLampWord(m.y, 32u, p, n, v, ndv, roughness, unity);
+    let wz = _rzLampWord(m.z, 64u, p, n, v, ndv, roughness, unity);
+    let ww = _rzLampWord(m.w, 96u, p, n, v, ndv, roughness, unity);
+    d = d + wx.d + wy.d + wz.d + ww.d;
+    s = s + wx.s + wy.s + wz.s + ww.s;
   }
   for (var i = docs; i < count; i = i + 1u) {
-    acc = acc + _rzLampSpecOne(i, p, n, v, ndv, roughness);
+    let one = _rzLampOne(i, p, n, v, ndv, roughness, unity);
+    d = d + one.d;
+    s = s + one.s;
   }
-  return acc;
+  // The first closure's walk speaks for the fragment; a second principled in
+  // the same graph shares p and the prelude normal, so its answer is the same.
+  if (!_rzLampDiffuseSet) {
+    _rzLampDiffuse = d * (1.0 / 3.141592653589793);
+    _rzLampDiffuseSet = true;
+  }
+  return s;
 }
 
 struct PrincipledIn {
@@ -1051,6 +1114,8 @@ struct PrincipledIn {
   spec_clamp: f32,
   sheen: f32,
   sheen_tint: f32,
+  reflection_lod: f32,
+  unity_direct: f32,
 };
 
 fn eval_principled(
@@ -1077,9 +1142,12 @@ fn eval_principled(
   // split-sum indirect path, matching EEVEE closure_eval_glossy_lib behavior.
   // The sun, and every lamp that reaches this point. One clamp over the pair:
   // a candle a hand's width from a polished floor is a firefly otherwise.
-  let spec_direct_raw = (bsdf_ggx(N, L, V, NL, NV, p.roughness) * sun_rgb * shadow
-                        + rzLampsSpecular(wp, N, V, NV, p.roughness))
-                       * ltc_brdf_scale_from_lut(lut);
+  // URP's lobe carries its own normalisation, so the LTC rescale that matches
+  // EEVEE's direct light to its split-sum indirect does not apply to it.
+  let direct_scale = select(ltc_brdf_scale_from_lut(lut), 1.0, p.unity_direct > 0.5);
+  let spec_direct_raw = (_rzDirectLobe(N, L, V, NL, NV, p.roughness, p.unity_direct) * sun_rgb * shadow
+                        + rzLampsSpecular(wp, N, V, NV, p.roughness, p.unity_direct))
+                       * direct_scale;
   let spec_direct = min(spec_direct_raw, vec3f(p.spec_clamp));
   // Indirect specular reads the world ALONG THE REFLECTION, at a roughness-
   // picked level — EEVEE's probe_evaluate_world_spec, where the diffuse half
@@ -1088,8 +1156,13 @@ fn eval_principled(
   // roughness, so a chrome rail mirrored what a matte wall did and a stage's
   // metal only ever lost its diffuse. A uniform sky gives the same number
   // either way, so this moves direction, not energy.
-  let spec_indirect = rzWorldSpecular(reflect(-V, N), p.roughness);
-  let spec_radiance = (spec_direct + spec_indirect) * reflection_color;
+  let spec_indirect = rzWorldSpecularLod(reflect(-V, N), p.roughness, p.reflection_lod);
+  // URP tints a lamp's highlight by f0 alone — its D·V·F already folds the
+  // Fresnel in — where the split-sum reflectance grows toward grazing; applied
+  // to the direct term it made a far glossy floor several times brighter than
+  // the game draws it. Reflections keep the split sum either way.
+  let direct_tint = select(reflection_color, f0, p.unity_direct > 0.5);
+  let spec_radiance = spec_direct * direct_tint + spec_indirect * reflection_color;
 
   // Sheen add — when p.sheen=0 the whole term collapses, leaving diffuse_color=base.
   let base_tint = tint_from_color(p.base);
@@ -1099,9 +1172,23 @@ fn eval_principled(
   // diffuse_weight = (1-metallic). Indirect diffuse uses amb (L_w) with no π factor
   // (probe_evaluate_world_diff returns SH-projected radiance, not cosine-convolved).
   let diffuse_weight = 1.0 - p.metallic;
-  let diffuse_radiance = diffuse_color * (sun_rgb * NL * shadow / EEVEE_PI + amb_rgb) * diffuse_weight;
+  var diffuse_radiance = diffuse_color * (sun_rgb * NL * shadow / EEVEE_PI + amb_rgb) * diffuse_weight;
+  // The lamps' diffuse, in Unity mode, as URP shades it: THIS surface's albedo
+  // — its tint and its maps, not the raw texture the epilogue would use —
+  // times 0.96·(1 − metal). X340's floor wears a 0.588 tint the epilogue never
+  // saw, and every lamp on it landed 1.7× too bright.
+  if (p.unity_direct > 0.5 && !_rzLampDiffuseTaken) {
+    diffuse_radiance += p.base * (0.96 * (1.0 - p.metallic)) * rzLightsDiffuseOnce(wp, N);
+    _rzLampDiffuseTaken = true;
+  }
 
-  return diffuse_radiance + spec_radiance;
+  // The cast's shadow on a stage (Unity mode): the game lays its character
+  // shadow over the whole lit surface as a multiply toward the shadow colour.
+  var lit = diffuse_radiance + spec_radiance;
+  if (p.unity_direct > 0.5) {
+    lit = lit * mix(vec3f(1.0), light.castShadow.rgb, _rzCastShadow(wp) * light.castShadow.w);
+  }
+  return lit;
 }
 
 `;

package/src/shaders/passes/composite.ts

@@ -157,7 +157,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>;
@@ -178,6 +179,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.
@@ -306,6 +310,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;
+}
 `
 
 /**
@@ -455,6 +486,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 */ `
@@ -537,7 +569,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/src/shaders/scene-tap.ts

@@ -202,7 +202,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/dist/graph/presets/pool_floor.d.ts

@@ -1,3 +0,0 @@
-import type { ShaderGraph } from "../schema";
-export declare const POOL_FLOOR_GRAPH: ShaderGraph;
-//# sourceMappingURL=pool_floor.d.ts.map

package/dist/graph/presets/pool_floor.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pool_floor.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/pool_floor.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,gBAAgB,EAAE,WA6B9B,CAAA"}

package/dist/graph/presets/pool_floor.js

@@ -1,42 +0,0 @@
-// Pool floor — the tiled bottom seen through water, with caustics on it.
-//
-// The other half of a pool, and the half that does most of the work. A water
-// surface can be tuned for a long time without the shot reading as a pool;
-// putting the focused-light web on the FLOOR is what settles it, because that
-// is the cue a photograph actually carries. It is a floor material, so it is
-// applied to the tile under the water rather than to the water itself.
-//
-// Caustics land between the albedo and the shading deliberately: they are
-// light, so they should still be dimmed by the floor's own shadow rather than
-// glowing through it. That is the difference between water-focused sun and a
-// decal.
-export const POOL_FLOOR_GRAPH = {
-    version: 1,
-    name: "Pool floor",
-    tags: ["stage", "water", "pool"],
-    nodes: [
-        { id: "tex", type: "texture" },
-        { id: "mat", type: "material_diffuse" },
-        { id: "base", type: "mix/multiply", inputs: { fac: 1.0 } },
-        { id: "caust", type: "caustics" },
-        {
-            id: "principled",
-            type: "principled",
-            inputs: { metallic: 0.0, specular_ior_level: 0.4, roughness: 0.45, spec_clamp: 10.0, sheen_weight: 0.0, sheen_tint: 0.0 },
-        },
-    ],
-    links: [
-        { from: { node: "tex", socket: "color" }, to: { node: "base", socket: "a" } },
-        { from: { node: "mat", socket: "color" }, to: { node: "base", socket: "b" } },
-        { from: { node: "base", socket: "color" }, to: { node: "caust", socket: "color" } },
-        { from: { node: "caust", socket: "color" }, to: { node: "principled", socket: "base_color" } },
-    ],
-    output: { node: "principled", socket: "color" },
-    params: [
-        { id: "tint", label: "Light tint", target: { node: "caust", socket: "tint" }, kind: "color", default: [1.0, 1.0, 1.0] },
-        { id: "scale", label: "Caustic scale", target: { node: "caust", socket: "scale" }, kind: "float", min: 0.01, max: 1, default: 0.12 },
-        { id: "speed", label: "Caustic speed", target: { node: "caust", socket: "speed" }, kind: "float", min: 0, max: 1, default: 0.15 },
-        { id: "strength", label: "Caustic strength", target: { node: "caust", socket: "strength" }, kind: "float", min: 0, max: 3, default: 0.6 },
-        { id: "fade", label: "Depth fade", target: { node: "caust", socket: "fade" }, kind: "float", min: 1, max: 200, default: 30 },
-    ],
-};

package/dist/graph/presets/water.d.ts

@@ -1,3 +0,0 @@
-import type { ShaderGraph } from "../schema";
-export declare const WATER_GRAPH: ShaderGraph;
-//# sourceMappingURL=water.d.ts.map

package/dist/graph/presets/water.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"water.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/water.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,WAAW,EAAE,WAgBzB,CAAA"}

package/dist/graph/presets/water.js

@@ -1,31 +0,0 @@
-// Water — a planar reflection, rippled, seen through Fresnel.
-//
-// Put a stage's water materials in a style group carrying this graph and the
-// pool starts reflecting. The reflection itself is the engine's mirror pass,
-// which this is the only graph to read; everything else here is the shaping
-// that keeps it from reading as a mirror laid flat in the floor.
-//
-// The exposed params are the ones worth a slider while judging a shot. Scale
-// and speed are the ripple; a real pool's surface is slow and broad, so both
-// defaults sit low. Tint is the water's own colour — a game rip carries that
-// in its material, and the converter hands it straight over.
-//
-// How see-through the water is belongs to the MATERIAL's alpha, not to this
-// graph, which is where every other group's coverage comes from too.
-export const WATER_GRAPH = {
-    version: 1,
-    name: "Water",
-    tags: ["water", "stage"],
-    nodes: [{ id: "water", type: "water" }],
-    links: [],
-    output: { node: "water", socket: "color" },
-    params: [
-        { id: "tint", label: "Tint", target: { node: "water", socket: "tint" }, kind: "color", default: [0.04, 0.62, 0.66] },
-        { id: "scale", label: "Ripple scale", target: { node: "water", socket: "scale" }, kind: "float", min: 0.01, max: 1, default: 0.18 },
-        { id: "speed", label: "Ripple speed", target: { node: "water", socket: "speed" }, kind: "float", min: 0, max: 1, default: 0.12 },
-        { id: "strength", label: "Ripple depth", target: { node: "water", socket: "strength" }, kind: "float", min: 0, max: 2, default: 0.7 },
-        { id: "blur", label: "Reflection blur", target: { node: "water", socket: "blur" }, kind: "float", min: 0, max: 1, default: 0.25 },
-        { id: "mirroring", label: "Mirroring", target: { node: "water", socket: "mirroring" }, kind: "float", min: 0, max: 1, default: 0.20 },
-        { id: "sparkle", label: "Sparkle", target: { node: "water", socket: "sparkle" }, kind: "float", min: 0, max: 4, default: 1.0 },
-    ],
-};

package/dist/physics/autofit.d.ts

@@ -1,147 +0,0 @@
-import { type Rigidbody } from "./types";
-import type { Skinning } from "../model";
-/**
- * Supplementary colliders fitted to the mesh a PMX rigid body fails to cover.
- *
- * PMX body proxies are bodies of revolution — 下半身 is a capsule lying
- * transversely across the hips, so its cross-section is a circle. A pelvis seen
- * from the side is not a circle, and across every rig measured the butt sits
- * 0.18–0.71 units OUTSIDE that capsule while the front is flush or inside. That
- * gap is where a skirt goes through a character: the cloth is resting correctly
- * on the collider it was given, and the collider stops half a unit short of the
- * skin.
- *
- * A rest offset cannot close it (see RigidBodyStore.restOffset) — it is one
- * scalar on a radially symmetric shape, and the error is asymmetric. Measured
- * on 托特's run cycle, the offset that clears the butt is 0.5, which is simply
- * the size of the missing geometry, and at that value the skirt stands off the
- * front and hips by the same 0.5.
- *
- * So fit the missing piece instead: take each bone-following body's own skinned
- * vertices, find the ones that escape its shape in a concentrated lobe, and fit
- * a capsule to that lobe. That is the fix riggers apply by hand, derived from
- * the mesh rather than guessed.
- *
- * Measured on 托特's run cycle, counting butt vertices swallowed by a cloth
- * body: 32.4 per frame with nothing, 30.9 with a 0.02 rest offset, 12.4 with
- * this pass, 10.4 with both.
- */
-export interface AutoFitOptions {
-    /** A vertex counts as protruding past this much (model units). Below it the
-     *  mesh is within authoring tolerance of the proxy and needs no help. */
-    minProtrusion?: number;
-    /**
-     * Ignore vertices further out than this multiple of the source shape's
-     * RADIUS (its smallest characteristic dimension).
-     *
-     * A coarse first cut at keeping hair and loose clothing out — anything
-     * standing further off the proxy than the proxy is wide is not skin. The
-     * discriminator that actually does the work is minConcentration.
-     */
-    maxProtrusionRatio?: number;
-    /** Fewer protruding vertices than this and it is a spike, not a region. */
-    minVertices?: number;
-    /**
-     * Per-axis quantile the fitted lobe's extent is clipped to, each end. A
-     * handful of stray vertices (a weight-painting slip, a seam) would otherwise
-     * stretch the capsule far past the surface everyone can see.
-     */
-    quantile?: number;
-    /** Skip the fit unless the capsule actually reaches this far past what is
-     *  already covered — otherwise it adds solver rows for nothing. */
-    minGain?: number;
-    /** How tightly the kept lobe's outward directions must agree, 0–1. A loose
-     *  sanity check; the real discriminator is minConcentration. */
-    minDirectionality?: number;
-    /** Vertices outside the dominant lobe, by this cosine, are not part of the
-     *  feature being fitted. */
-    lobeCos?: number;
-    /**
-     * How much deeper the fitted lobe must be than protrusion typically is on
-     * this body, averaged over the vertices that protrude at all.
-     *
-     * This is the guard that separates "the proxy is missing a lobe" from "the
-     * proxy is not a proxy for this mesh at all". A pelvis escapes its capsule by
-     * 0.53 at the back and 0.14 at the front, so the back lobe stands well clear
-     * of the average. Hair escapes the skull by a similar depth in every
-     * direction, so its deepest lobe is no deeper than typical and the ratio sits
-     * near 1. See the note at the meanProtrusion computation for what this
-     * deliberately refuses to fit.
-     *
-     * Without it the pass fits the hairstyle — measured on 托特, 頭 reports
-     * 3653 of 4669 vertices outside its capsule, and the fitted shape was a crate
-     * around the whole head. No threshold on depth or vertex count tells those
-     * two cases apart; concentration does.
-     */
-    minConcentration?: number;
-    /**
-     * How many capsules may be fitted to one body, each against what the previous
-     * ones already cover.
-     *
-     * One capsule inscribed in a lobe does not fill it — on 托特's butt a single
-     * fit removed 58% of the clipping and left the rest at the edges the capsule
-     * could not reach. Each further pass re-measures protrusion against the
-     * original shape UNION everything fitted so far, so it lands on whatever is
-     * still exposed instead of re-fitting the same bulge.
-     */
-    maxShapesPerBody?: number;
-    /**
-     * Quantile of the lobe's perpendicular spread used as the capsule radius.
-     *
-     * The clip-versus-float dial, and the one to reach for if a result looks
-     * wrong. Lower hugs the body: less standoff in idle, more clipping left. 1.0
-     * encloses the lobe entirely, which is what produced a visibly hovering
-     * skirt on 托特.
-     */
-    radiusQuantile?: number;
-    /**
-     * Fit only the deepest part of each lobe: points at least this fraction of
-     * the lobe's own maximum protrusion.
-     *
-     * A lobe tapers to nothing at its edges, and a capsule sized to span the
-     * whole thing has to be fat enough to reach the edges too. Fitting the deep
-     * core keeps each capsule small and lets a later pass handle the shallows
-     * with its own, which is both tighter and closer to what the surface is
-     * actually doing.
-     */
-    lobeDepthFraction?: number;
-}
-/** What the pass decided for one source body — surfaced so a rig can be
- *  inspected rather than silently rebuilt underneath its author. */
-export interface AutoFitResult {
-    /** Index of the body in the input array that this supplements. */
-    sourceIndex: number;
-    sourceName: string;
-    /** Vertices dominated by that body's bone, and how many were outside it. */
-    vertexCount: number;
-    protrudingCount: number;
-    /** Furthest any kept vertex sat outside the source shape. */
-    maxProtrusion: number;
-    /** How far the fitted capsule reaches past what was already covered. */
-    gain: number;
-    /** Length of the kept lobe's mean outward direction, 0–1. */
-    directionality: number;
-    /** Lobe depth over the body's average protrusion. See minConcentration. */
-    concentration: number;
-    /**
-     * Furthest the capsule's newly exposed surface sits from the skin it was
-     * fitted to — the amount cloth resting on it will stand off the body at the
-     * worst point, and the number to watch if a result looks puffy. Only the part
-     * reaching outside the source shape is measured; the rest is buried.
-     */
-    overshoot: number;
-    body: Rigidbody;
-}
-/**
- * Fit supplementary colliders for every bone-following body whose own mesh
- * escapes it.
- *
- * `vertices` is the model's interleaved vertex buffer (stride 8, position
- * first) and `skinning` its joints/weights — both in PMX bind pose, the same
- * space as `shapePosition` / `shapeRotation`, so nothing has to be skinned.
- *
- * Returns one entry per body it chose to supplement; the caller appends
- * `.body` to the rigid body list before constructing RezePhysics.
- */
-export declare function fitSupplementaryColliders(rigidbodies: Rigidbody[], vertices: Float32Array, skinning: Skinning, options?: AutoFitOptions): AutoFitResult[];
-//# sourceMappingURL=autofit.d.ts.map

package/dist/physics/autofit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"autofit.d.ts","sourceRoot":"","sources":["../../src/physics/autofit.ts"],"names":[],"mappings":"AACA,OAAO,EAAiC,KAAK,SAAS,EAAE,MAAM,SAAS,CAAA;AACvE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,WAAW,cAAc;IAC7B;6EACyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,2EAA2E;IAC3E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;uEACmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;oEACgE;IAChE,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;gCAC4B;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;;;;;;;;;;;;;OAgBG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;;;;;;;OASG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAC3B;AA2BD;oEACoE;AACpE,MAAM,WAAW,aAAa;IAC5B,kEAAkE;IAClE,WAAW,EAAE,MAAM,CAAA;IACnB,UAAU,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAA;IACnB,eAAe,EAAE,MAAM,CAAA;IACvB,6DAA6D;IAC7D,aAAa,EAAE,MAAM,CAAA;IACrB,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAA;IACtB,2EAA2E;IAC3E,aAAa,EAAE,MAAM,CAAA;IACrB;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,SAAS,CAAA;CAChB;AAID;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,SAAS,EAAE,EACxB,QAAQ,EAAE,YAAY,EACtB,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,cAAmB,GAC3B,aAAa,EAAE,CA4CjB"}