reze-engine 0.60.1 → 0.60.3

package/src/graph/compile.ts

@@ -8,7 +8,7 @@ import type { Diagnostic, ExposedParam, GraphNode, SocketValue, ShaderGraph } fr
 import { NODE_REGISTRY, canConvert, convert, fmtValue, literalFits } from "./registry"
 import type { NodeSpec, SockT } from "./registry"
 import { assembleModule } from "./slots"
-import type { AlphaMode, RenderClass } from "./render-class"
+import type { AlphaMode, RenderClass, StyleBlend } from "./render-class"
 
 export type CompileOptions = {
   /** Fold exposed params to their defaults as consts (no StyleUniforms binding).
@@ -22,6 +22,8 @@ export type CompileOptions = {
   renderClass?: RenderClass
   /** Alpha-handling axis, orthogonal to renderClass. Default "opaque". */
   alphaMode?: AlphaMode
+  /** How the result meets the frame — see StyleGroup.blend. Default "over". */
+  blend?: StyleBlend
 }
 
 /** UBO slot for one exposed param: write `value` at style.p[vec4Index] (+ component). */
@@ -356,6 +358,6 @@ export function compileGraph(graph: ShaderGraph, opts: CompileOptions = {}): Com
   if (opacity) lines.push(`  let final_opacity = saturate(${outputExpr(opacity, "float")}); // @node:${opacity.node}`)
 
   const fsBody = lines.join("\n")
-  const wgsl = assembleModule(opts.renderClass ?? "auto", opts.alphaMode ?? "opaque", fsBody, usesStyle.current, !!opacity)
+  const wgsl = assembleModule(opts.renderClass ?? "auto", opts.alphaMode ?? "opaque", fsBody, usesStyle.current, !!opacity, opts.blend ?? "over")
   return { ok: true, wgsl, fsBody, slotMap, diagnostics, prunedNodes }
 }

package/src/graph/registry.ts

@@ -848,7 +848,7 @@ export const NODE_REGISTRY: Record<string, NodeSpec> = {
       const bsdf =
         `eval_principled(PrincipledIn(${a.base_color}, ${a.metallic}, ` +
         `${spec}, ${a.roughness}, ` +
-        `${a.spec_clamp}, ${a.sheen_weight}, ${a.sheen_tint}), ${a.normal}, l, v, sun, amb, shadow)`
+        `${a.spec_clamp}, ${a.sheen_weight}, ${a.sheen_tint}), ${a.normal}, l, v, sun, amb, shadow, input.worldPos)`
       // v2 defaults Emission Strength to 0, which is the overwhelming case. Emit
       // the term only when it can do something, so the common shader carries no
       // dead add and the output stays readable.

package/src/graph/render-class.ts

@@ -11,6 +11,10 @@ export type RenderClass = "auto" | "eye" | "hair"
  *  hashed alpha test (stockings); "opaque" = the standard near-zero threshold discard. */
 export type AlphaMode = "opaque" | "hashed"
 
+/** How a group's colour meets the frame. "over" is the ordinary alpha blend;
+ *  "additive" adds its light and never reads alpha — see StyleGroup.blend. */
+export type StyleBlend = "over" | "additive"
+
 /** Descriptive manifest for hosts (reze-design) so the render-class picker is data-driven
  *  instead of hardcoding strings. The effect implementations stay engine-side; this only
  *  describes them. `pairsWith` = the effect needs a counterpart class present to show. */

package/src/graph/slots.ts

@@ -10,7 +10,7 @@
 import { NODES_WGSL } from "../shaders/materials/nodes"
 import { COMMON_MATERIAL_PRELUDE_WGSL, DISSOLVE_WGSL, commonFsOutWgsl } from "../shaders/materials/common"
 import { sceneIdWriteWgsl } from "../shaders/passes/scene-contract"
-import type { AlphaMode, RenderClass } from "./render-class"
+import type { AlphaMode, RenderClass, StyleBlend } from "./render-class"
 
 // ── Module-scope declarations ──
 // hair: the over-eyes pipeline-override constant (a second pipeline is compiled with
@@ -80,11 +80,19 @@ function decls(renderClass: RenderClass, alphaMode: AlphaMode): string {
 // fs() header up to and including the graph body's context locals. Composed so the
 // hand-written material shaders' local names (tex_color, n, v, l, sun, amb, shadow) are
 // preserved exactly — the registry's context nodes and emit functions reference them.
-function prelude(renderClass: RenderClass, alphaMode: AlphaMode): string {
+function prelude(renderClass: RenderClass, alphaMode: AlphaMode, blend: StyleBlend): string {
+  // ADDITIVE NEVER GATES ON ALPHA. Its blend adds colour and reads no alpha at
+  // all, so a surface painted this way carries its picture in RGB and leaves
+  // alpha at zero — a game's sky layers do exactly that. Discarding on alpha
+  // throws every one of those fragments away before the blend can add them,
+  // which is what made X309's nebula and starfield invisible while its cloud
+  // dome (opaque) came through.
   const discard =
-    alphaMode === "hashed"
-      ? "  if (alpha < hashed_alpha_threshold(input.restPos)) { discard; }"
-      : "  if (alpha < 0.001) { discard; }"
+    blend === "additive"
+      ? ""
+      : alphaMode === "hashed"
+        ? "  if (alpha < hashed_alpha_threshold(input.restPos)) { discard; }"
+        : "  if (alpha < 0.001) { discard; }"
   const gate = renderClass === "eye" ? EYE_REAR_GATE : ""
   // Double-sided shading, winding-independent: a normal pointing away from the
   // camera means we're seeing the surface's other side — flip it. Only genuinely
@@ -143,11 +151,15 @@ ${gate}
 // Tail of fs(): consumes `final_color` + locals, writes FSOut. hashed forces output
 // alpha to 1 (the discard already did the cutout); hair scales alpha for the over-eyes
 // pass when IS_OVER_EYES is compiled true.
-function epilogue(renderClass: RenderClass, alphaMode: AlphaMode, hasOpacity: boolean): string {
+function epilogue(renderClass: RenderClass, alphaMode: AlphaMode, hasOpacity: boolean, blend: StyleBlend): string {
   // A graph that computes its own opacity wins, including over hashed: hashed
   // writes 1 because its discard already decided the cutout, and a graph asking
-  // for a curve is asking for the opposite of a cutout.
-  const alphaBase = hasOpacity ? "final_opacity" : alphaMode === "hashed" ? "1.0" : "alpha"
+  // for a curve is asking for the opposite of a cutout. Additive writes 1 for a
+  // third reason: its colour blend ignores src alpha entirely, so the only thing
+  // alpha still reaches is the aux target's coverage — and a sky layer that
+  // reported zero coverage would be invisible to bloom and to the composite.
+  const alphaBase =
+    blend === "additive" ? "1.0" : hasOpacity ? "final_opacity" : alphaMode === "hashed" ? "1.0" : "alpha"
   // Empty while ids are off, so the epilogue is exactly what it was. The values
   // ride in the per-draw material uniform (see MaterialUniforms), which is what
   // keeps this working through the indirect-draw path.
@@ -202,6 +214,7 @@ export function assembleModule(
   fsBody: string,
   includeStyleUniforms: boolean,
   hasOpacity = false,
+  blend: StyleBlend = "over",
 ): string {
   return (
     NODES_WGSL +
@@ -212,10 +225,10 @@ export function assembleModule(
     commonFsOutWgsl() +
     (includeStyleUniforms ? STYLE_UNIFORMS_WGSL : "") +
     decls(renderClass, alphaMode) +
-    prelude(renderClass, alphaMode) +
+    prelude(renderClass, alphaMode, blend) +
     fsBody +
     "\n" +
-    epilogue(renderClass, alphaMode, hasOpacity) +
+    epilogue(renderClass, alphaMode, hasOpacity, blend) +
     "}\n"
   )
 }

package/src/graph/style-group.ts

@@ -5,7 +5,7 @@
 // the hand-written preset path. See docs/style-groups-spec.md.
 
 import type { Diagnostic, ShaderGraph } from "./schema"
-import type { AlphaMode, RenderClass } from "./render-class"
+import type { AlphaMode, RenderClass, StyleBlend } from "./render-class"
 import type { StyleSlot } from "./compile"
 
 export type StyleGroup = {
@@ -22,6 +22,16 @@ export type StyleGroup = {
   renderClass?: RenderClass
   /** Alpha-handling axis, orthogonal to renderClass. Default "opaque". */
   alphaMode?: AlphaMode
+  /**
+   * How this group's colour meets what is already there. Default "over".
+   *
+   * "additive" is LIGHT rather than matter: the fragment is added to the frame
+   * and its alpha is never read. A game's sky layers are painted this way — a
+   * nebula and a starfield on cylinders round the scene, their alpha 0 across
+   * the whole image because additive blending does not look at it. Laid over,
+   * they are invisible.
+   */
+  blend?: StyleBlend
   /**
    * Extra image maps for this group's shading, up to four.
    *

package/src/index.ts

@@ -69,7 +69,7 @@ export type {
   Diagnostic,
 } from "./graph/schema"
 export { NODE_REGISTRY, type NodeSpec, type SockT } from "./graph/registry"
-export { RENDER_CLASSES, type RenderClass, type AlphaMode, type RenderClassInfo } from "./graph/render-class"
+export { RENDER_CLASSES, type RenderClass, type AlphaMode, type StyleBlend, type RenderClassInfo } from "./graph/render-class"
 export type {
   StyleGroup,
   GroupImage,

package/src/model.ts

@@ -1359,11 +1359,44 @@ export class Model {
       Quat.slerpInto(_eyeOwn, _eyeQuat, w, own)
     }
     if (bothRot) bothRot.setIdentity()
-    // Only these need their world matrices again; nothing hangs off an eye.
-    this.eyeSubset ??= new Int32Array(both !== undefined ? [both, left, right] : [left, right])
+    // The eye bones and everything that follows them — the bones under them
+    // and the bones inheriting from them. Rigs often weight the eyeball to one
+    // of those (左目2, a 付与 child), and a motion keying the eyes left it on
+    // the motion's gaze: the full pass had already run.
+    this.eyeSubset ??= this.eyeFollowers(both !== undefined ? [both, left, right] : [left, right])
     this.computeWorldMatrices(this.eyeSubset)
   }
 
+  /** The seeds, their descendants and their 付与 inheritors, transitively, in
+   *  deform order. */
+  private eyeFollowers(seeds: number[]): Int32Array {
+    const bones = this.skeleton.bones
+    const n = bones.length
+    const affected = new Uint8Array(n)
+    for (const s of seeds) affected[s] = 1
+    let changed = true
+    while (changed) {
+      changed = false
+      for (let k = 0; k < n; k++) {
+        const i = this.deformOrder[k]
+        if (affected[i]) continue
+        const b = bones[i]
+        const ap = b.appendParentIndex
+        const inherits = (b.appendRotate || b.appendMove) && ap !== undefined && ap >= 0 && ap < n && affected[ap]
+        if (inherits || (b.parentIndex >= 0 && affected[b.parentIndex])) {
+          affected[i] = 1
+          changed = true
+        }
+      }
+    }
+    const order: number[] = []
+    for (let k = 0; k < n; k++) {
+      const i = this.deformOrder[k]
+      if (affected[i]) order.push(i)
+    }
+    return Int32Array.from(order)
+  }
+
   /** Compose a constant local rotation onto a bone AFTER every pose source (clip,
    *  blend, tween) each frame — the classic MMD "heel correction": pitch the 足首
    *  bones so a motion authored for flat shoes grounds a heeled model. Persists

package/src/shaders/materials/nodes.ts

@@ -979,6 +979,70 @@ fn principled_specular(ior: f32, level: f32) -> f32 {
   return (r * r * 2.0 * max(level, 0.0)) / 0.08;
 }
 
+// ─── The scene's lamps, on a PBR closure ───────────────────────────
+//
+// A lamp reaches a material as rzLightsDiffuse, added outside the graph and
+// multiplied by the raw texture: Lambert and nothing else, because that layer
+// cannot know what the surface is. On a principled closure it can. A floor at
+// roughness 0.23 under forty candles carries forty glints, and a metal
+// REFLECTS a lamp instead of having it painted on — without this a ported
+// stage is a photograph of itself, lit but never shining.
+//
+// Same reach as _rzLightOne: the inverse square past RZ_LAMP_NEAR, the
+// (1 − (d/R)⁴)² window that makes the radius real, the squared cone. N·L is
+// inside bsdf_ggx. Declared here for bsdf_ggx and resolved against the lights
+// API the material prelude brings; the ground pass takes that API without
+// this file and is untouched.
+//
+// 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 {
+  let pr = _rzLightVec(i, 0u);
+  let d = pr.xyz - p;
+  let dist = length(d);
+  if (dist >= pr.w) { return vec3f(0.0); }
+  let toLight = d / max(dist, 1e-4);
+  let ndl = dot(n, toLight);
+  if (ndl <= 0.0) { return vec3f(0.0); }
+  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);
+}
+
+fn _rzLampSpecWord(bits0: u32, base: u32, p: vec3f, n: vec3f, v: vec3f, ndv: f32, roughness: f32) -> vec3f {
+  var acc = 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);
+  }
+  return acc;
+}
+
+fn rzLampsSpecular(p: vec3f, n: vec3f, v: vec3f, ndv: f32, roughness: f32) -> vec3f {
+  var acc = 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);
+  }
+  for (var i = docs; i < count; i = i + 1u) {
+    acc = acc + _rzLampSpecOne(i, p, n, v, ndv, roughness);
+  }
+  return acc;
+}
+
 struct PrincipledIn {
   base: vec3f,
   metallic: f32,
@@ -992,7 +1056,7 @@ struct PrincipledIn {
 fn eval_principled(
   p: PrincipledIn,
   N: vec3f, L: vec3f, V: vec3f,
-  sun_rgb: vec3f, amb_rgb: vec3f, shadow: f32
+  sun_rgb: vec3f, amb_rgb: vec3f, shadow: f32, wp: vec3f
 ) -> vec3f {
   let NL = max(dot(N, L), 0.0);
   let NV = max(dot(N, V), 1e-4);
@@ -1011,8 +1075,11 @@ fn eval_principled(
   // Direct glossy — bsdf_ggx already includes NL; no F applied here (tinted after
   // accum with reflection_color). ltc_brdf_scale rescales direct to match the
   // split-sum indirect path, matching EEVEE closure_eval_glossy_lib behavior.
-  let spec_direct_raw = bsdf_ggx(N, L, V, NL, NV, p.roughness)
-                       * sun_rgb * shadow * ltc_brdf_scale_from_lut(lut);
+  // 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);
   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

package/src/shaders/passes/scene-contract.ts

@@ -90,6 +90,14 @@ type SceneRenderClass =
    *  cast — a reflection that claimed her object id would seed the distance
    *  field twice and put every silhouette effect's border around the glass. */
   | "mirror"
+  /** A material whose light is ADDED rather than laid over what is behind it.
+   *  A game's sky layers are painted this way — a nebula, a starfield, a band of
+   *  colour on a cylinder round the whole scene — and their alpha is 0 across
+   *  the entire image, because additive blending never reads it: the picture is
+   *  wholly in RGB. Drawn alpha-over they are invisible, which is exactly what
+   *  X309's night sky was. Out of WRITES_ID for the mirror's reason — a sheet of
+   *  light is not an object anything should be able to pick or outline. */
+  | "material-additive"
   /** Particles and ribbons in their default, non-additive mode. */
   | "particle"
   /** Particles declaring `#blend additive` — LIGHT rather than matter, so
@@ -172,6 +180,9 @@ const WRITES_ID = new Set<SceneRenderClass>(["material", "ground"])
 /** The blends each class writes its two attachments with. */
 const BLENDS: Record<Exclude<SceneRenderClass, "depth-prepass">, [GPUBlendState, GPUBlendState]> = {
   material: [ALPHA_OVER, ALPHA_OVER],
+  // The same pair the additive particles use: light into the colour target, and
+  // coverage that still accumulates so bloom and the composite can see it.
+  "material-additive": [ADD_KEEP_ALPHA, ADD_BOTH],
   // PREMULTIPLIED, like the ground and for the same reason: what a mirror
   // writes is a sample of the HDR target, and that target already holds colour
   // premultiplied by its own alpha. Handed to the src-alpha blend it would be