reze-engine 0.68.6 → 0.68.8

package/dist/shaders/materials/common.js

@@ -216,36 +216,43 @@ fn _rzCastShadow(wp: vec3f) -> f32 {
 //   jelly     its jelly eyes (Engine.setModelJellyEyes, jelly-eyes.ts), not
 //             lighting but per-model all the same, so it rides here:
 //               [0] left iris centre (bind space), strength — 0 is off
-//               [1] right iris centre, scale bounce (both eyes)
+//               [1] right iris centre, the highlight layers' materialIds
+//                   (a + b·4096, 0 none)
 //               [2] left iris half extents, closure, eye bone (−1 none)
 //               [3] the right's
-//               [4] left squash, 0, clock, shine         [5] the right's
-struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9>, fill: vec4f, jelly: array<vec4f, 6> }
+//               [4] left scale x, y, twist, highlight turn (radians)
+//               [5] the right's
+//               [6] left drift x, y, highlight's own offset x, y (bind units)
+//               [7] the right's
+//               [8] left eye bone's head (the roll's pivot), roll (radians)
+//               [9] the right's
+//               [10] left highlight scale x, y, forward push (bind units), 0
+//               [11] the right's
+struct ObjectLight { layers: vec4u, ambient: vec4f, sh: array<vec4f, 9>, fill: vec4f, jelly: array<vec4f, 12> }
 @group(1) @binding(1) var<uniform> objectLight: ObjectLight;
 
-/** What the glints need to know about a fragment of the eye render class. */
-struct RzJelly {
-  /** Where in the iris this fragment is, in iris radii. */
-  src: vec2f,
-  /** 1 inside the iris, easing to 0 at its rim (0 everywhere when off). */
-  w: f32,
-  closure: f32,
-  shine: f32,
-  /** Scene seconds (wrapped), for the twinkles. */
-  clock: f32,
-};
+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:
- * shrunk about its centre while a lid moves, a little more down than across,
- * grown past rest as it springs back, and swelling as a turn or her motion
- * knocks it — scale only, in place, inside the white, which stays where it is. Vertices take it by
- * their weight on the eye bones (jelly[2].w, jelly[3].w), so nothing else on
- * the face moves.
+ * 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;
@@ -257,134 +264,33 @@ fn rzJellyVertex(p: vec3f, joints: vec4<u32>, nw: vec4f) -> vec3f {
     // 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 st = j[4u + e];
-    // The squash, nearly round: it shrinks both ways, a little more down than
-    // across, so the iris keeps its circle and only leans oval; and the bounce
-    // both eyes share (jelly[1].w). Held under 1.08 so a swell cannot rise
-    // past the upper lid.
-    let k = clamp(vec2f(1.0 - 0.8 * st.x, 1.0 - st.x) + j[1].w, vec2f(0.78, 0.75), vec2f(1.08, 1.08));
-    let moved = c.xy + (p.xy - c.xy) * k;
-    out = vec3f(mix(p.xy, moved, w), p.z);
+    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;
 }
 
-/**
- * The glints' frame for an eye fragment: its place in the iris in iris radii,
- * from the bind-space position, which the jelly moved the iris with — so the
- * glints ride the sloshing iris. Strength 0 gives w 0, which turns them off.
- */
-fn rzJellyEye(rp: vec3f) -> RzJelly {
-  let j = objectLight.jelly;
-  let qL = (rp.xy - j[0].xy) / max(j[2].xy, vec2f(1e-4));
-  let qR = (rp.xy - j[1].xy) / max(j[3].xy, vec2f(1e-4));
-  let right = dot(qR, qR) < dot(qL, qL);
-  let a = select(qL, qR, right);
-  let st = select(j[4], j[5], right);
-  let w = (1.0 - smoothstep(0.85, 1.0, length(a))) * select(0.0, 1.0, j[0].w > 0.0);
-  return RzJelly(a, w, select(j[2].z, j[3].z, right), st.w, j[4].z);
-}
-
-/**
- * The jelly shine, added after the graph: two hard glints where the light
- * would catch a bead — placed by the half vector in the head's frame, so they
- * hold still while the iris turns under them — and the eye brightening while
- * it wobbles. Flat, cel discs rather than a gradient lobe; HDR, so bloom
- * takes them. Shut eyes catch nothing.
- */
-fn rzJellyGlow(jj: RzJelly, tex: vec3f, alpha: f32, v: vec3f, l: vec3f, sun: vec3f, shadow: f32) -> vec3f {
-  let strength = objectLight.jelly[0].w;
-  var right = vec3f(1.0, 0.0, 0.0);
-  var up = vec3f(0.0, 1.0, 0.0);
-  var fwd = vec3f(0.0, 0.0, -1.0);
-  if (material.headBoneIndex >= 0.0) {
-    let hm = skinMats[u32(material.headBoneIndex)];
-    right = normalize(hm[0].xyz);
-    up = normalize(hm[1].xyz);
-    fwd = -normalize(hm[2].xyz);
-  }
-  let h = normalize(l + v);
-  // Held in the middle and lower iris: the top of an iris sits under the upper
-  // lid, and a glint there — or its bloom halo — pokes out over it.
-  var g = vec2f(dot(h, right), dot(h, up)) * 0.6;
-  g = g * min(1.0, 0.25 / max(length(g), 1e-6)) - vec2f(0.0, 0.1);
-  g.y = min(g.y, 0.0);
-  let aa = max(length(fwidth(jj.src)), 1e-4);
-  // A star, not only a disc: the disc with two thin rays through it, the
-  // anime sparkle.
-  let dg = jj.src - g;
-  let rays = max(0.0, 1.0 - abs(dg.y) / 0.018) * (1.0 - smoothstep(0.0, 0.34, abs(dg.x)))
-    + max(0.0, 1.0 - abs(dg.x) / 0.018) * (1.0 - smoothstep(0.0, 0.26, abs(dg.y)));
-  let glint = max(1.0 - smoothstep(0.13 - aa, 0.13 + aa, length(dg)), rays * 0.8);
-  let second = 1.0 - smoothstep(0.07 - aa, 0.07 + aa, distance(jj.src, -0.55 * g + vec2f(0.1, -0.12)));
-  let facing = saturate(dot(fwd, v) * 2.0);
-  let key = clamp(dot(sun, vec3f(0.2126, 0.7152, 0.0722)), 0.3, 2.0);
-  let lit = facing * key * (0.35 + 0.65 * shadow);
-  // HDR, well past 1, so bloom takes them as the hard sparkle of a gem.
-  // Bright enough for bloom to catch, not so bright its halo spreads past the
-  // iris onto the lid.
-  let glints = (glint + 0.8 * second) * lit * (1.8 + 0.8 * jj.shine);
-  // Gone as the lid starts down, not only once shut: a half-closed smile puts
-  // the lid right over where the glint sits.
-  let open = 1.0 - smoothstep(0.1, 0.45, jj.closure);
-  // Only where the eye's own picture is (its alpha), never on the iris's top
-  // rim, and gone as the lid comes down.
-  let solid = smoothstep(0.5, 0.9, alpha);
-  let onEye = solid * (1.0 - smoothstep(0.05, 0.35, jj.src.y));
-  // Light through the jelly: the light enters where the glint is and comes out
-  // the far side, so the iris glows in its own colour in a crescent opposite
-  // the glint — the lit-from-within look of a gem, or a jelly.
-  let r = length(jj.src);
-  // Out the LOWER iris, always — the anime gem's bright underside — leaning
-  // away from the glint; never up, where its bloom would spill on the lid.
-  let away = normalize(vec2f(-g.x * 0.6, -1.0));
-  let crescent = smoothstep(0.15, 0.7, dot(jj.src, away)) * (1.0 - smoothstep(0.8, 1.0, r));
-  let through = tex * crescent * (2.2 + 1.0 * jj.shine) * lit;
-  // And the colour runs deeper: the iris's own hue pushed, never its greys.
-  let lum = dot(tex, vec3f(0.2126, 0.7152, 0.0722));
-  let vivid = max(tex - vec3f(lum), vec3f(0.0)) * 1.2;
-  // The glass over it: a broad soft sheen across the upper iris, under the
-  // lid line, the dome of a bead catching the room.
-  let dome = (1.0 - smoothstep(0.0, 0.5, distance(jj.src * vec2f(0.8, 1.4), vec2f(0.0, 0.2)))) * 0.45 * lit;
-  // Everything that blooms keeps to the lower iris, so no halo reaches the lid.
-  let lower = 1.0 - smoothstep(-0.05, 0.3, jj.src.y);
-  // The cut: soft facets fanning across the lower iris, light split as a cut
-  // stone splits it, turning slowly.
-  let ang = atan2(jj.src.y, jj.src.x);
-  let facets = pow(0.5 + 0.5 * cos(ang * 7.0 + jj.clock * 0.35), 6.0)
-    * smoothstep(0.3, 0.75, r) * (1.0 - smoothstep(0.82, 0.97, r)) * lower;
-  // The rim: a band of its own colour just inside the iris edge, HDR, which
-  // bloom spreads into a glow around the stone.
-  let rim = smoothstep(0.7, 0.84, r) * (1.0 - smoothstep(0.86, 0.97, r)) * lower;
-  // Twinkles: three specks in the lower iris, each flashing now and then on
-  // the scene clock.
-  var twinkle = 0.0;
-  for (var i = 0; i < 3; i++) {
-    let fi = f32(i);
-    let at = vec2f(0.42 * cos(3.6 + fi * 1.1), -0.25 - 0.18 * fi + 0.1 * sin(fi * 2.3));
-    let flash = pow(max(0.0, sin(jj.clock * (1.3 + 0.37 * fi) + fi * 2.1)), 12.0);
-    twinkle += (1.0 - smoothstep(0.0, 0.05 + aa, distance(jj.src, at))) * flash;
-  }
-  let sparkle = (vec3f(glints + twinkle * 2.0) * onEye
-    + tex * facets * 2.5 * lit * solid * (1.0 + 0.6 * jj.shine));
-  // The soft light (sheen, glow through, colour) needs only the eye's picture.
-  let gem = (sparkle + (vec3f(dome) + through + vivid) * solid) * open * jj.w;
-  // The edge, which jj.w (fading out from 0.85) would hide: the glowing rim
-  // band, and a thin glossy line right at the border — light running round
-  // the stone's edge — all the way round, bright below and dim above, where a
-  // halo would reach the lid. Up to the mesh's edge and no further.
-  let on = select(0.0, 1.0, strength > 0.0) * (1.0 - smoothstep(1.0 - aa, 1.0, r));
-  let edgeLine = smoothstep(0.92, 0.955, r) * (1.0 - smoothstep(0.965, 0.995, r));
-  let edgeLit = mix(0.3, 1.0, lower) * lit * (1.0 + 0.6 * jj.shine);
-  let edge = (tex * rim * 2.0 + vec3f(rim * 0.25)) * lit * (1.0 + 0.6 * jj.shine)
-    + (vec3f(0.55) + tex * 0.8) * edgeLine * edgeLit;
-  let border = edge * solid * open * on;
-  // The whole eye shines a little brighter, more while it wobbles — not just
-  // the iris, so this one is not held to it (jj.w).
-  let lift = tex * (0.25 + 0.35 * jj.shine) * select(0.0, 1.0, strength > 0.0);
-  return (gem + border + lift) * min(strength, 1.0);
-}
-
 /** 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/dist/shaders/passes/outline.d.ts.map

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

package/dist/shaders/passes/outline.js

@@ -193,12 +193,22 @@ fn safe_normal2(v: vec2f) -> vec2f {
   let w = max(clipPos.w, 1e-4);
   var ndc: vec2f;
   var coverage = 1.0;
+  // The scene's width dial splits around 1×. Above it, it widens the line
+  // before the minimum, as it always has. Below it, it thins the line AFTER
+  // the minimum: a line held at the minimum is drawn that wide and faded, and
+  // it still writes depth across all of it — so a dial at 0.1× or at 0.0001×
+  // left the same 1.5 px ring for whatever drew or read depth after it, and
+  // the dial did nothing visible. Thinned past the minimum instead, the hull
+  // is genuinely sub-pixel, the multisampling covers only what it covers, and
+  // the line fades with the dial and claims depth only where it is.
+  let widen = max(material.widthScale, 1.0);
+  let thin = min(material.widthScale, 1.0);
   if (material.textured > 0.5) {
     // The game's: a view-space offset of edgeSize world units along the view
     // normal, projected, then each axis held between 1.2 px and 1.2 px ×
     // (1 + _OutlineMaxOffsetMultiplier, 1.5) of a 1920-wide frame; a line the
     // minimum had to push fades by how far it was pushed.
-    let off = viewNormal.xy * material.edgeSize * material.widthScale * outlineNormal.w;
+    let off = viewNormal.xy * material.edgeSize * widen * outlineNormal.w;
     let d1 = vec2f(off.x * camera.projection[0][0], off.y * camera.projection[1][1]) / w;
     // the minimum along the push direction (the game's dir · 2/screen · 1.2)
     let pxNdc = 2.0 / refViewport * 1.2 * safe_normal2(viewNormal.xy);
@@ -210,7 +220,7 @@ fn safe_normal2(v: vec2f) -> vec2f {
     ndc = o * select(vec2f(1.0), sign(d1), abs(d1) > vec2f(0.0));
   } else {
     let breakDepth = RZ_OUTLINE_FULL_FIGURE * camera.projection[1][1];
-    let nearNdc = viewNormal.xy * (material.edgeSize * material.widthScale * outlineNormal.w * 4.0 / refViewport);
+    let nearNdc = viewNormal.xy * (material.edgeSize * widen * outlineNormal.w * 4.0 / refViewport);
     ndc = nearNdc * (min(w, breakDepth) / w);
 
     // Antialiased minimum (the game's _OutlineAntialias): held at the minimum
@@ -224,6 +234,7 @@ fn safe_normal2(v: vec2f) -> vec2f {
       ndc = select(vec2f(0.0), ndc * (minPx / px), px > 1e-6);
     }
   }
+  ndc *= thin;
   output.normal = worldNormal;
   output.coverage = coverage;
   output.position = vec4f(clipPos.xy + ndc * w, clipPos.z, clipPos.w);

package/package.json

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

package/src/engine.ts

@@ -8338,7 +8338,8 @@ export class Engine {
       label: "main per-material bind group layout",
       entries: [
         { binding: 0, visibility: GPUShaderStage.FRAGMENT, texture: {} },
-        { binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+        // VERTEX too: jelly eyes tell a highlight layer by its materialId.
+        { binding: 1, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
         { binding: 2, visibility: GPUShaderStage.FRAGMENT, texture: {} },
         { binding: 3, visibility: GPUShaderStage.FRAGMENT, texture: {} },
         // StyleUniforms for compiled graph shaders (adjust-tier sliders). Hand-written
@@ -13797,9 +13798,8 @@ export class Engine {
 
   /**
    * Jelly eyes: her irises shrink and spring back as her lids move, swell as her
-   * head turns or moves, and wobble back, and shine like a gem — two hard
-   * glints, light glowing through the iris, deeper colour. MMD's 果冻眼, on any
-   * PMX and under any eye graph. Null stills them again.
+   * head turns or moves, and wobble back. MMD's 果冻眼, on any PMX and under
+   * any eye graph. Null stills them again.
    *
    * Driven by her closing morphs (まばたき, the winks) and her head bone, never
    * her eyes' own turn, so eye tracking following the camera leaves it still.
@@ -13902,7 +13902,7 @@ export class Engine {
       if (inst.jellyEyes) {
         inst.jellyEyes.step(deltaTime, inst.model)
         inst.jellyEyes.write(inst.objectLight)
-        this.device.queue.writeBuffer(inst.lightBuffer, 48 * 4, inst.objectLight, 48, 24)
+        this.device.queue.writeBuffer(inst.lightBuffer, 48 * 4, inst.objectLight, 48, 48)
       }
       animMs += performance.now() - tAnim
       // Material morphs ride the same weight change as vertex morphs but land in
@@ -15210,7 +15210,7 @@ export class Engine {
     // the cast on the character layer as well as the default one. Words:
     // layers [0..3], ambient flag [4..7], SH [8..43], fill [44..47], jelly
     // eyes [48..71] — see materials/common.ts.
-    const objectLight = new Float32Array(72)
+    const objectLight = new Float32Array(96)
     new Uint32Array(objectLight.buffer)[0] =
       isStage || isPlane || isProp ? RENDERING_LAYER_DEFAULT : (RENDERING_LAYER_DEFAULT | RENDERING_LAYER_CHARACTER) >>> 0
     const lightBuffer = this.device.createBuffer({

package/src/graph/slots.ts

@@ -57,15 +57,8 @@ const EYE_REAR_GATE = `
   }
 `
 
-// Eye's jelly (Engine.setModelJellyEyes): the vertex shader moves the iris
-// itself; the fragment only adds the glints, computed once the lighting context
-// exists and added in the epilogue after the graph. Off, they are zero.
 const PLAIN_SAMPLE = `  let tex_s = textureSample(diffuseTexture, diffuseSampler, input.uv);
 `
-const EYE_JELLY_SAMPLE = `  let rz_jelly = rzJellyEye(input.restPos);
-${PLAIN_SAMPLE}`
-const EYE_JELLY_GLOW = `  let rz_jelly_glow = rzJellyGlow(rz_jelly, tex_color, tex_s.a, v, l, sun, shadow);
-`
 
 // ── Adjust-tier uniforms — fixed 16-vec4f block (256 B) shared by the single material
 // bind group layout; non-graph draws bind a zero buffer. ──
@@ -114,7 +107,7 @@ function prelude(renderClass: RenderClass, alphaMode: AlphaMode, blend: StyleBle
   const flip =
     renderClass === "eye" ? "" : "\n  n = select(-n, n, dot(n, v) >= 0.0);"
   return `@fragment fn fs(input: VertexOutput) -> FSOut {
-${renderClass === "eye" ? EYE_JELLY_SAMPLE : PLAIN_SAMPLE}  // MMD alpha semantics: material alpha × texture alpha.
+${PLAIN_SAMPLE}  // MMD alpha semantics: material alpha × texture alpha.
   let alpha = material.alpha * tex_s.a;
 ${discard}
 
@@ -161,7 +154,6 @@ ${gate}
   // The normal the lamps' diffuse layer is lit by, for a principled walk to
   // compute it on the way (rzLightsDiffuseOnce). n is final from here on.
   _rzLampN = n;
-${renderClass === "eye" ? EYE_JELLY_GLOW : ""}
 `
 }
 
@@ -214,7 +206,7 @@ function epilogue(renderClass: RenderClass, alphaMode: AlphaMode, hasOpacity: bo
   // it is emission, not a surface colour, so nothing may ramp or shadow it. Zero
   // on every fragment of every material that is not dissolving, which is what
   // keeps this out of the way of a scene that never uses it.
-  const BURN = ` + RZ_BURN_COLOR * rz_burn${renderClass === "eye" ? " + rz_jelly_glow" : ""}`
+  const BURN = ` + RZ_BURN_COLOR * rz_burn`
   // The scene fog, last, as the game lays it over a lit surface; an
   // emission-only graph takes none (the game's effect shaders have no fog).
   // A premultiplied colour takes its fog premultiplied too: the haze a pane