reze-engine 0.68.5 → 0.68.7

package/dist/shaders/materials/common.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/shaders/materials/common.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,oBAAoB,QAkXhC,CAAC;AAwHF,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,orMAgHzB,CAAA;AAQD,eAAO,MAAM,4BAA4B,QAC6H,CAAA"}
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/shaders/materials/common.ts"],"names":[],"mappings":"AA4BA,eAAO,MAAM,oBAAoB,QA2ThC,CAAC;AAwHF,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,aAAa,orMAgHzB,CAAA;AAQD,eAAO,MAAM,4BAA4B,QAC6H,CAAA"}

package/dist/shaders/materials/common.js

@@ -216,34 +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, 0, 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,
-};
+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;
@@ -255,97 +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);
-}
-
-/**
- * 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);
-  let glint = 1.0 - smoothstep(0.16 - aa, 0.16 + aa, distance(jj.src, g));
-  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);
-  let away = -normalize(g + vec2f(0.0, -1e-3));
-  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;
-  // The glints keep off the iris's top; the soft light (sheen, glow through,
-  // colour) has no halo to spill, so it only needs the eye's own picture.
-  let gem = (vec3f(glints) * onEye + (vec3f(dome) + through + vivid) * solid) * open * jj.w;
-  // 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 + 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reze-engine",
-  "version": "0.68.5",
+  "version": "0.68.7",
   "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