reze-engine 0.68.4 → 0.68.6

package/src/shaders/materials/common.ts

@@ -222,7 +222,7 @@ fn _rzCastShadow(wp: vec3f) -> f32 {
 //               [1] right iris centre, scale bounce (both eyes)
 //               [2] left iris half extents, closure, eye bone (−1 none)
 //               [3] the right's
-//               [4] left squash, 0, 0, shine             [5] 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> }
 @group(1) @binding(1) var<uniform> objectLight: ObjectLight;
 
@@ -234,12 +234,14 @@ struct RzJelly {
   w: f32,
   closure: f32,
   shine: f32,
+  /** Scene seconds (wrapped), for the twinkles. */
+  clock: f32,
 };
 
 /**
  * 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:
- * flattened about its centre while the eye closes, bulging across as jelly does,
+ * 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
@@ -259,10 +261,11 @@ fn rzJellyVertex(p: vec3f, joints: vec4<u32>, nw: vec4f) -> vec3f {
     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 blink's squash, as jelly gives: flattened down, it bulges across
-    // (and a stretch thins it), and the bounce both eyes share (jelly[1].w).
-    // Height is held under 1.06 so a swell cannot rise past the upper lid.
-    let k = clamp(vec2f(1.0 + 0.45 * st.x, 1.0 - st.x) + j[1].w, vec2f(0.9, 0.78), vec2f(1.1, 1.06));
+    // 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);
   }
@@ -282,7 +285,7 @@ fn rzJellyEye(rp: vec3f) -> RzJelly {
   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);
+  return RzJelly(a, w, select(j[2].z, j[3].z, right), st.w, j[4].z);
 }
 
 /**
@@ -304,37 +307,85 @@ fn rzJellyGlow(jj: RzJelly, tex: vec3f, alpha: f32, v: vec3f, l: vec3f, sun: vec
     fwd = -normalize(hm[2].xyz);
   }
   let h = normalize(l + v);
-  // Held near the middle of the iris, a little low: the top of an iris sits
-  // under the upper lid, and a glint there pokes out over it.
+  // 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.3 / max(length(g), 1e-6)) - vec2f(0.0, 0.08);
+  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));
+  // 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.
-  let glints = (glint + 0.8 * second) * lit * (2.6 + 1.6 * jj.shine);
-  let open = 1.0 - smoothstep(0.3, 0.8, jj.closure);
+  // 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 onEye = smoothstep(0.5, 0.9, alpha) * (1.0 - smoothstep(0.35, 0.6, jj.src.y));
+  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));
+  // 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 * (0.9 + 0.6 * jj.shine) * lit;
+  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)) * 0.7;
-  let gem = (vec3f(glints) + through + vivid) * open * onEye * jj.w;
+  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.15 + 0.35 * jj.shine) * select(0.0, 1.0, strength > 0.0);
-  return (gem + lift) * min(strength, 1.0);
+  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