reze-engine 0.68.8 → 0.68.9

package/src/graph/slots.ts

@@ -102,13 +102,14 @@ function prelude(renderClass: RenderClass, alphaMode: AlphaMode, blend: StyleBle
   // camera-averted fragments change (front surfaces have dot(n,v) > 0 and are
   // untouched), unlike a front_facing test, which PMX's clockwise winding
   // inverts. Fixes inner skirt linings (裙子白1-style flipped-normal copies)
-  // shading near-black through sheer outer layers. Eye is exempt: it FRONT-culls
-  // by design, so its visible fragments are back faces with intended normals.
+  // shading near-black through sheer outer layers. Eye is exempt: its normals
+  // shade as authored.
   const flip =
     renderClass === "eye" ? "" : "\n  n = select(-n, n, dot(n, v) >= 0.0);"
   return `@fragment fn fs(input: VertexOutput) -> FSOut {
-${PLAIN_SAMPLE}  // MMD alpha semantics: material alpha × texture alpha.
-  let alpha = material.alpha * tex_s.a;
+${PLAIN_SAMPLE}  // MMD alpha semantics: material alpha × texture alpha, capped at 1 as MMD
+  // does (a PMX can author alpha above 1; blended, it burns the material white).
+  let alpha = saturate(material.alpha * tex_s.a);
 ${discard}
 
   // ── Dissolve ──

package/src/jelly-eyes.ts

@@ -90,23 +90,23 @@ const HL_SCALE_MIN = 0.85
 const HL_SCALE_MAX = 1.2
 // The roll: while a closing expression holds, the iris turns about its eye
 // bone's X axis (左目/右目, the eyeball's centre), rolling down with the lid —
-// the angle at weight 1, and simultaneous expressions add. And it comes
-// forward a little (iris radii) with the expression and with the spring, so
-// the roll does not sink it into the white. The MME rolls with the lid
-// exactly, which the lid hides; here the roll follows on a spring of the same
-// pace and decay as the blink's, so as the eye opens the iris swings up past
-// rest and wobbles back, where it can be seen.
+// the angle at weight 1, and simultaneous expressions add. It comes forward
+// only with the spring (iris radii): pushed with the expression as well, a
+// shut eye's iris came through a lid set close in front of it (白里黑子). The MME rolls with the lid
+// exactly, which the lid hides; here the roll follows on a spring twice the
+// blink's pace with its decay, so as the eye opens the iris swings up past rest
+// and wobbles back, where it can be seen. At the blink's own pace it trailed
+// the opening lid and swung a third of an iris past centre: a jump.
 const ROLL: Record<string, number> = {
   まばたき: -15, blink: -15, Blink: -15, eye_close: -15, Fcl_EYE_Close: -15, はぅ: -15, 笑い: -5,
   ウィンク: -5, ｳｨﾝｸ: -5, wink: -5, Wink: -5, ウィンク２: -15, ｳｨﾝｸ２: -15, blink_L: -15, Fcl_EYE_Close_L: -15,
   ウィンク右: -5, ｳｨﾝｸ右: -5, wink_R: -5, Wink_R: -5, ウィンク２右: -15, ｳｨﾝｸ２右: -15, blink_R: -15, Fcl_EYE_Close_R: -15,
 }
-const ROLL_HZ = SPRING_HZ
-const ROLL_ZETA = Math.LN2 / HALF_LIFE / (2 * Math.PI * SPRING_HZ)
-// How much of the spring's swing about the expression angle shows: the whole
-// of it carried the iris up most of its radius after a blink.
-const ROLL_SWING = 0.4
-const PUSH_EXPRESSION = 0.15
+const ROLL_HZ = 6
+const ROLL_ZETA = Math.LN2 / HALF_LIFE / (2 * Math.PI * ROLL_HZ)
+// How much of the spring's swing about the expression angle shows: a
+// twenty-fifth of an iris radius past centre after a blink.
+const ROLL_SWING = 0.25
 const PUSH_ELASTIC = 0.04
 // A highlight sheet by name, for rigs that keep it on its own material.
 const HIGHLIGHT = /ハイライト|ﾊｲﾗｲﾄ|高光|highlight|hilight|(^|[^a-z])hl([^a-z]|$)/i
@@ -288,10 +288,23 @@ export class JellyEyes {
     const l = index("左目")
     const r = index("右目")
     this.headBone = index("頭")
-    const names = model.getMorphing().morphs.map((m) => m.name)
-    const find = (list: string[]) => list.map((n) => names.indexOf(n)).filter((i) => i >= 0)
+    const all = model.getMorphing().morphs
+    const names = all.map((m) => m.name)
+    // The weights read are resolved, so a group whose every target is named
+    // (Reze's まばたき is ウィンク２ + ウィンク２右) arrives through its
+    // leaves; counted as well, a blink rolled the iris twice as far.
+    const known = new Set([...BOTH, ...LEFT, ...RIGHT])
+    const resolved = (i: number) => {
+      const refs = all[i].groupReferences
+      return !!refs?.length && refs.every((r) => known.has(names[r.morphIndex]))
+    }
+    const morphIndex = (n: string) => {
+      const i = names.indexOf(n)
+      return i >= 0 && !resolved(i) ? i : -1
+    }
+    const find = (list: string[]) => list.map(morphIndex).filter((i) => i >= 0)
     this.morphs = [find(BOTH), find(LEFT), find(RIGHT)]
-    const rolls = (list: string[]) => list.map((n) => ({ morph: names.indexOf(n), deg: ROLL[n] ?? 0 })).filter((r) => r.morph >= 0 && r.deg !== 0)
+    const rolls = (list: string[]) => list.map((n) => ({ morph: morphIndex(n), deg: ROLL[n] ?? 0 })).filter((r) => r.morph >= 0 && r.deg !== 0)
     this.rolls = [rolls([...BOTH, ...LEFT]), rolls([...BOTH, ...RIGHT])]
     this.rest = findIrises(model, l, r, both)
     // The bone that carries each iris, which may be under the eye bone.
@@ -423,7 +436,7 @@ export class JellyEyes {
       const pivot = rest.pivot
       o.set(pivot ? [pivot[0], pivot[1], pivot[2], (this.roll[e] + (s.roll - this.roll[e]) * ROLL_SWING) * DEG * g] : [0, 0, 0, 0], 80 + e * 4)
       const hs = (k: 0 | 1) => Math.max(HL_SCALE_MIN, Math.min(HL_SCALE_MAX, 1 + x * HL_SCALE[k] * g))
-      o.set([hs(0), hs(1), (s.closure * PUSH_EXPRESSION + Math.min(Math.abs(x), SPRING_LIMIT) * PUSH_ELASTIC) * r * g, 0], 88 + e * 4)
+      o.set([hs(0), hs(1), Math.min(Math.abs(x), SPRING_LIMIT) * PUSH_ELASTIC * r * g, 0], 88 + e * 4)
     }
   }
 
@@ -550,6 +563,11 @@ function blink(s: EyeState, dt: number): void {
  * As draw ids (1-based over the materials that draw, as the engine numbers
  * MaterialUniforms.materialId), at most two. A rig whose highlight is painted
  * into the iris has none, and only the iris moves.
+ *
+ * A layer drawn on vertices an earlier layer already uses is a copy of that
+ * layer (白里黑子's ☆ and ❤ are star and heart irises on the iris's own
+ * vertices), so it moves with it. Slid as a highlight, a copy of the dome sits
+ * in front of the iris on one half, flipping sides with the tremble.
  */
 function findHighlights(model: Model, rest: [EyeRest, EyeRest]): number[] {
   const materials = model.getMaterials?.() ?? []
@@ -557,6 +575,7 @@ function findHighlights(model: Model, rest: [EyeRest, EyeRest]): number[] {
   const iris = new Set([...rest[0].verts, ...rest[1].verts])
   if (!materials.length || !indices.length || !iris.size) return []
   const layers: { id: number; name: string; minX: number; maxX: number; minY: number; maxY: number }[] = []
+  const used = new Set<number>()
   let start = 0
   let id = 0
   for (const m of materials) {
@@ -564,16 +583,21 @@ function findHighlights(model: Model, rest: [EyeRest, EyeRest]): number[] {
     if (count === 0) continue
     id++
     let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity
+    let copy = true
+    const mine: number[] = []
     for (let k = start; k < start + count; k++) {
       const v = indices[k]
       if (!iris.has(v)) continue
+      if (!used.has(v)) copy = false
+      mine.push(v)
       minX = Math.min(minX, positions[v * 3])
       maxX = Math.max(maxX, positions[v * 3])
       minY = Math.min(minY, positions[v * 3 + 1])
       maxY = Math.max(maxY, positions[v * 3 + 1])
     }
     start += count
-    if (minX <= maxX) layers.push({ id, name: m.name, minX, maxX, minY, maxY })
+    for (const v of mine) used.add(v)
+    if (minX <= maxX && !copy) layers.push({ id, name: m.name, minX, maxX, minY, maxY })
   }
   const out: number[] = []
   layers.forEach((l, i) => {

package/src/shaders/materials/common.ts

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

package/src/shaders/passes/depth-prepass.ts

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

package/src/shaders/passes/shadow.ts

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