reze-engine 0.55.15 → 0.56.0

package/src/model.ts

@@ -1164,11 +1164,53 @@ export class Model {
     return this.eyeTracking !== null
   }
 
-  /** Where the eyes are on, as a unit direction from between them in model
-   *  space — or null while they are the motion's own. See RzSubject.gaze. */
+  /**
+   * Where she looks: a unit direction in model space, or null for a model
+   * without eye bones. See RzSubject.gaze.
+   *
+   * Exact while the eyes are on something (setEyeTracking). Otherwise the
+   * motion's own eye turn UNDONE THROUGH THE RANGE MAP: an eye bone turns a
+   * fraction of the way toward what it looks at — on an anime face a few
+   * degrees of bone read as a long look, which is why the map exists — and
+   * this gives back the whole of it, so a beam or a light can go where the
+   * eye visibly looks rather than down the bone's axis. The inverse of the
+   * map the eyes would be under, both eyes averaged.
+   */
   getGaze(): Vec3 | null {
-    if (this.eyeTracking === null || !this.gazeDirSet) return null
-    return new Vec3(this.gazeDir.x, this.gazeDir.y, this.gazeDir.z)
+    if (this.eyeTracking !== null && this.gazeDirSet) return new Vec3(this.gazeDir.x, this.gazeDir.y, this.gazeDir.z)
+    const ni = this.runtimeSkeleton.nameIndex
+    const head = ni["頭"]
+    const left = ni["左目"]
+    const right = ni["右目"]
+    if (head === undefined || left === undefined || right === undefined) return null
+    const worldMats = this.runtimeSkeleton.worldMatrices
+    const hm = worldMats[head].values
+    const hx = _eyeHx.setXYZ(hm[0], hm[1], hm[2]).normalizeInPlace()
+    const hy = _eyeHy.setXYZ(hm[4], hm[5], hm[6]).normalizeInPlace()
+    const hz = _eyeHz.setXYZ(hm[8], hm[9], hm[10]).normalizeInPlace()
+    const range = this.eyeTracking?.range ?? 20
+    const deg = 180 / Math.PI
+    let yaw = 0
+    let pitch = 0
+    for (let e = 0; e < 2; e++) {
+      const em = worldMats[e === 0 ? left : right].values
+      // The eye looks down its local -Z: the third column, negated.
+      const ax = _eyeDir.setXYZ(-em[8], -em[9], -em[10]).normalizeInPlace()
+      const lx = ax.x * hx.x + ax.y * hx.y + ax.z * hx.z
+      const ly = ax.x * hy.x + ax.y * hy.y + ax.z * hy.z
+      const lz = -(ax.x * hz.x + ax.y * hz.y + ax.z * hz.z)
+      const y = Math.atan2(lx, lz) * deg
+      const p = Math.asin(Math.max(-1, Math.min(1, ly))) * deg
+      // rangeMap ran 75° onto `range` and 45° onto its fractions; this runs back.
+      yaw += Math.max(-75, Math.min(75, (y * 75) / range)) * 0.5
+      pitch += (p > 0 ? Math.min(45, (p * 45) / (0.22 * range)) : Math.max(-45, (p * 45) / (0.3 * range))) * 0.5
+    }
+    const ry = yaw / deg
+    const rp = pitch / deg
+    const x = Math.sin(ry) * Math.cos(rp)
+    const y = Math.sin(rp)
+    const z = -Math.cos(ry) * Math.cos(rp)
+    return new Vec3(hx.x * x + hy.x * y + hz.x * z, hx.y * x + hy.y * y + hz.y * z, hx.z * x + hy.z * y + hz.z * z).normalizeInPlace()
   }
 
   /** Where the eyes look, in MODEL space. Set each frame before update();

package/src/overlay.ts

@@ -502,11 +502,6 @@ export const OVERLAY_STYLE = {
 
   /** Stroke for the material borders drawn over the mesh wireframe. */
   seamStrokePx: 3,
-  /** Stroke for the material under the pointer — the same self-occluding reveal
-   *  a pick draws, layered over the section-wide view rather than replacing it,
-   *  and heavier than either a pick's own edges or a seam so it still pops out
-   *  of a view that already has two other things drawn in it. */
-  hoverStrokePx: 4,
   /** How strongly the triangulation draws under those borders.
    *
    *  Both at full strength is one undifferentiated field of yellow — forty

package/src/reflection.ts

@@ -2,18 +2,34 @@
 // shadow-cascades precedent.
 //
 // A planar reflection is not a second camera aimed by hand; it is the SAME
-// camera with the world reflected about the floor plane. Fold the reflection
+// camera with the world reflected about the mirror's plane. Fold the reflection
 // into the view matrix and everything downstream is untouched: world positions
 // stay TRUE world positions, so sun, shadows and positional lights evaluate at
 // the unmirrored point — which is exactly what a mirror shows, an object lit
 // as it is, seen from a mirrored eye. The only other value that must mirror is
 // the eye itself, because specular reads the view direction from it.
 //
-// Winding: a reflection has determinant -1, so triangle orientation flips.
-// Every scene-pass pipeline that draws into the mirror culls "none", which is
-// what makes this legal without a flipped-frontFace pipeline set. The OUTLINE
-// culls "back" and is therefore skipped in the mirror — its hull would face
-// the wrong way and ink over the model.
+// The plane is carried as (n, d) with n a UNIT normal and the surface at
+// n·p + d = 0 — general from the start, because a mirror standing on the floor
+// is the ordinary case and a floor is only the one plane that happens to be
+// horizontal. The ground is (0, 1, 0, 0).
+//
+// WINDING: a reflection has determinant -1, so triangle orientation flips, and
+// any pipeline that culls a face culls the WRONG one in the mirror pass.
+//
+// This note used to claim every scene-pass pipeline culls "none". That was
+// never true, and each exception cost a round of "the mirror looks broken":
+//
+//   ground   culls "back"  -> the floor vanished whole, and with it the grid
+//                             and the received shadow, since the shadow is a
+//                             layer of the ground shader
+//   outline  culls "back"  -> no ink line on the reflection at all
+//   eye      culls "front" -> the back of the eyeball kept, its front discarded
+//
+// All three now build a mirror twin with the cull answered (the ground goes to
+// "none", the outline to "front", the eye to "back"). Anything ADDED to the
+// scene pass with a cullMode must do the same — grep cullMode in engine.ts,
+// which is the whole list.
 
 /**
  * The debug view: the reflection target drawn over the finished frame — the
@@ -44,20 +60,66 @@ struct VSOut { @builtin(position) pos: vec4f, @location(0) uv: vec2f, };
 `
 
 /**
- * Reflection about the horizontal plane y = h, column-major.
+ * A plane as the mirror wants it: 4 numbers, (nx, ny, nz, d), surface at
+ * n·p + d = 0.
+ *
+ * Written into a caller-owned array rather than returned, because the engine
+ * holds one per mirror and rebuilds it whenever the mirror moves — which is
+ * every frame a gizmo is being dragged.
+ *
+ * `n` is normalized here rather than trusted: it arrives from a rotated quad's
+ * basis, and a scale baked into that basis would otherwise scale `d` against
+ * it and put the plane somewhere else entirely.
+ */
+export function planeFromPointNormal(
+  px: number, py: number, pz: number,
+  nx: number, ny: number, nz: number,
+  out: Float32Array,
+): Float32Array {
+  const len = Math.hypot(nx, ny, nz) || 1
+  const x = nx / len
+  const y = ny / len
+  const z = nz / len
+  out[0] = x
+  out[1] = y
+  out[2] = z
+  // d places the plane through the point: n·p + d = 0.
+  out[3] = -(x * px + y * py + z * pz)
+  return out
+}
+
+/**
+ * The Householder reflection about (n, d), column-major.
  *
- *   p' = (x, 2h - y, z)
+ *   p' = p - 2 (n·p + d) n
  */
-export function reflectionAboutY(h: number): Float32Array {
-  // prettier-ignore
-  return new Float32Array([
-    1, 0, 0, 0,
-    0, -1, 0, 0,
-    0, 0, 1, 0,
-    0, 2 * h, 0, 1,
-  ])
+export function reflectionAboutPlane(plane: ArrayLike<number>, out?: Float32Array): Float32Array {
+  const nx = plane[0], ny = plane[1], nz = plane[2], d = plane[3]
+  const m = out ?? new Float32Array(16)
+  m[0] = 1 - 2 * nx * nx
+  m[1] = -2 * ny * nx
+  m[2] = -2 * nz * nx
+  m[3] = 0
+  m[4] = -2 * nx * ny
+  m[5] = 1 - 2 * ny * ny
+  m[6] = -2 * nz * ny
+  m[7] = 0
+  m[8] = -2 * nx * nz
+  m[9] = -2 * ny * nz
+  m[10] = 1 - 2 * nz * nz
+  m[11] = 0
+  m[12] = -2 * d * nx
+  m[13] = -2 * d * ny
+  m[14] = -2 * d * nz
+  m[15] = 1
+  return m
 }
 
+/** Scratch for the product below — this module is called once per mirror per
+ *  frame and allocating a matrix each time is a garbage-collector visit for
+ *  nothing. */
+const R = new Float32Array(16)
+
 /**
  * Fill a camera-uniform block for the mirror pass from the live one.
  *
@@ -69,26 +131,30 @@ export function reflectionAboutY(h: number): Float32Array {
  * view' = view × R (column-vector convention, matching `projection * view *
  * pos` in the vertex shaders); projection unchanged; eye reflected.
  */
-export function buildMirrorCamera(camera: Float32Array, planeY: number, out: Float32Array): Float32Array {
-  const v = camera
-  const h = planeY
-  // view × R where R = reflectionAboutY(h). R only touches column 1 (scaled by
-  // -1) and adds 2h·col1 to the translation — write the product directly
-  // rather than through a generic multiply, so the arithmetic is exact and the
-  // cost is a handful of ops.
-  for (let i = 0; i < 16; i++) out[i] = v[i]
-  out[4] = -v[4]
-  out[5] = -v[5]
-  out[6] = -v[6]
-  out[7] = -v[7]
-  out[12] = v[12] + 2 * h * v[4]
-  out[13] = v[13] + 2 * h * v[5]
-  out[14] = v[14] + 2 * h * v[6]
-  out[15] = v[15] + 2 * h * v[7]
-  for (let i = 16; i < 32; i++) out[i] = v[i]
-  out[32] = v[32]
-  out[33] = 2 * h - v[33]
-  out[34] = v[34]
-  out[35] = v[35]
+export function buildMirrorCamera(
+  camera: Float32Array,
+  plane: ArrayLike<number>,
+  out: Float32Array,
+): Float32Array {
+  reflectionAboutPlane(plane, R)
+  // view × R, column-major: out.col_j = Σ_k view.col_k · R[j*4 + k].
+  for (let j = 0; j < 4; j++) {
+    const b0 = R[j * 4 + 0], b1 = R[j * 4 + 1], b2 = R[j * 4 + 2], b3 = R[j * 4 + 3]
+    for (let r = 0; r < 4; r++) {
+      out[j * 4 + r] =
+        camera[0 + r] * b0 + camera[4 + r] * b1 + camera[8 + r] * b2 + camera[12 + r] * b3
+    }
+  }
+  for (let i = 16; i < 32; i++) out[i] = camera[i]
+  // The eye through the same reflection, so specular reads the mirrored view
+  // direction. Written from the plane directly rather than through R: it is one
+  // dot product, and going via the matrix would round-trip it through nine
+  // multiplies to reach the same number.
+  const nx = plane[0], ny = plane[1], nz = plane[2], d = plane[3]
+  const t = 2 * (nx * camera[32] + ny * camera[33] + nz * camera[34] + d)
+  out[32] = camera[32] - t * nx
+  out[33] = camera[33] - t * ny
+  out[34] = camera[34] - t * nz
+  out[35] = camera[35]
   return out
 }

package/src/shaders/cast-api.ts

@@ -56,12 +56,13 @@ struct RzSubject {
    */
   dissolve: f32,
   /**
-   * Where she is LOOKING, when her eyes are on something (Engine.setEyeTracking):
-   * a unit direction from between the eyes toward it, in world space. The eyes
-   * themselves turn only part of the way there by design, so an effect that
-   * should go where the gaze goes — a beam, a light — takes this rather than
-   * an eye bone's axis. Zero, with looking false, while the eyes are the
-   * motion's own.
+   * Where she LOOKS: a unit direction from between the eyes, in world space.
+   * Exact while her eyes are on something (Engine.setEyeTracking); otherwise
+   * the motion's own eye turn undone through the range map — an eye bone
+   * turns a fraction of the way toward what it looks at, and this gives back
+   * the whole of it. An effect that should go where the look goes — a beam,
+   * a light — takes this rather than an eye bone's axis, and it holds in
+   * either mode. Zero, with looking false, only for a model without eyes.
    */
   gaze: vec3f,
   looking: bool,

package/src/shaders/directives.ts

@@ -55,6 +55,21 @@ export type EffectDirectives = {
   bloom: boolean
   /** This effect takes the cast apart — the host reads the timing. */
   dissolve: boolean
+  /**
+   * This effect IS a mirror: a plane in the scene showing a true reflection of
+   * it, folded and re-rendered by the engine.
+   *
+   * A mount with no shader, and the second of them — `#lights` was the first.
+   * The reasoning is identical: a planar reflection re-renders every model from
+   * a folded camera, which is a PASS, and no mount is a pass. So the effect
+   * declares the mirror and the engine reflects, exactly as a lighting rig
+   * declares lamps and the engine shades.
+   *
+   * The plane comes from the effect's own `#param` dials, by name — see the
+   * engine's MIRROR_DIALS. That is what makes it an effect rather than a switch:
+   * it publishes, forks, schedules and fades like every other one.
+   */
+  mirror: boolean
   /**
    * How long ONE firing of this effect lasts, in seconds. 0 = undeclared.
    *
@@ -84,6 +99,7 @@ const SPEC = {
   grid: 1,
   bloom: 0,
   dissolve: 0,
+  mirror: 0,
   duration: 1,
 } as const
 
@@ -139,6 +155,7 @@ export function parseDirectives(wgsl: string): DirectiveResult {
     grid: 0,
     bloom: false,
     dissolve: false,
+    mirror: false,
     duration: 0,
   }
   const errors: string[] = []
@@ -235,6 +252,9 @@ export function parseDirectives(wgsl: string): DirectiveResult {
       case "dissolve":
         d.dissolve = true
         return
+      case "mirror":
+        d.mirror = true
+        return
       case "duration": {
         // SECONDS, like every other time a directive states (see #dissolve).
         // The document above works in frames and converts once; an author

package/src/shaders/passes/ground.ts

@@ -123,6 +123,26 @@ struct MirrorVP { viewProj: mat4x4f, params: vec4f, };
 // The frost noise, PRE-BAKED — see GROUND_NOISE_BAKE_WGSL below. Sampled with
 // the repeat sampler already at binding 10.
 @group(0) @binding(12) var noiseTex: texture_2d<f32>;
+// The mirror pass's resolved aux. .g is accumulated alpha — the reflection's
+// coverage. It lives here rather than in the colour target's own alpha because
+// the HDR format is rg11b10ufloat wherever the device allows it, and that
+// format has no alpha channel at all.
+@group(0) @binding(13) var mirrorMask: texture_2d<f32>;
+// THE MIRROR'S OWN PLANE, and whether this draw is the one inside the mirror
+// pass. A mirror shows nothing behind itself, and the floor is the geometry
+// most often behind one: stand a pane up and half the floor is behind it, lay
+// it facing UP and the whole floor is. Without this the reflection carries a
+// grid that the mirror cannot see.
+//
+// A uniform rather than a branch on some global, because the two ground bind
+// groups already differ — the camera's binds a block set to 0 and the
+// mirror's binds the live plane. No per-pass write, and nothing to get wrong
+// about which pass is running.
+// The flag is named on, not active: WGSL RESERVES active, and a reserved
+// word in a struct field fails the whole module — taking the ground
+// pipeline, and every style group and effect compiled after it, with it.
+struct MirrorClip { plane: vec4f, on: f32, _p0: f32, _p1: f32, _p2: f32, };
+@group(0) @binding(14) var<uniform> clip: MirrorClip;
 ${WORLD_AMBIENT_WGSL}
 ${lightsApi(0, 6)}
 
@@ -137,6 +157,14 @@ ${sceneFsOutWgsl()}@fragment fn fs(i: VO) -> FSOut {
   let gp = i.worldPos.xz / material.gridSpacing;
   let gridDeriv = fwidth(gp);
 
+  // The clip, straight after the derivatives and before anything else branches.
+  // EPSILON rather than zero: a pane lying flat on the floor is coplanar with
+  // it, and a floor reflecting itself at zero distance is z-fighting, not a
+  // reflection.
+  if (clip.on > 0.5 && dot(clip.plane.xyz, i.worldPos) + clip.plane.w < 0.01) {
+    discard;
+  }
+
   var out: FSOut;
   let n = normalize(i.normal);
   let centerDist = length(i.worldPos.xz);
@@ -315,6 +343,11 @@ ${pcfWgsl("shadowMap", "suv_c", "material.pcfTexel", "compareZ", "acc", "    ",
   // independence the grid won earlier. The branch is on a uniform, so the
   // whole cost vanishes for the scenes that leave it off.
   var reflShadowed = vec3f(0.0);
+  // How much of this texel the reflection pass actually covered. The target
+  // clears TRANSPARENT, so this is 1 where something reflected and 0 over the
+  // empty sky — which is what stops a floor mirror from painting the backdrop
+  // onto itself and wiping out the ground's own colour.
+  var reflA = 0.0;
   if (material.mirror > 0.0) {
     let mc = mirrorVP.viewProj * vec4f(i.worldPos, 1.0);
     let mndc = mc.xyz / max(mc.w, 1e-6);
@@ -349,10 +382,11 @@ ${pcfWgsl("shadowMap", "suv_c", "material.pcfTexel", "compareZ", "acc", "    ",
       let BLUR_SPAN = 14.0;
       lod = material.mirrorBlur * 5.0 * clamp(height / BLUR_SPAN, 0.0, 1.0);
     }
-    let refl = textureSampleLevel(mirrorTex, linearSampler, muv, lod).rgb;
+    let refl = textureSampleLevel(mirrorTex, linearSampler, muv, lod);
     // Still under the received shadow: a polished floor in shade shows a dim
     // reflection, and a mirror that ignored the shadow would glow in it.
-    reflShadowed = refl * (1.0 - dark * 0.65);
+    reflShadowed = refl.rgb * (1.0 - dark * 0.65);
+    reflA = textureSampleLevel(mirrorMask, linearSampler, muv, 0.0).g;
   }
   // THREE LAYERS, composited premultiplied, bottom to top: the shadow the
   // catcher receives, the ground surface, and the grid.
@@ -364,15 +398,17 @@ ${pcfWgsl("shadowMap", "suv_c", "material.pcfTexel", "compareZ", "acc", "    ",
   // alpha, and the grid is simply on or off.
   let surfA = edgeFade * material.opacity;
   let gridA = gridLine * material.gridLineOpacity * edgeFade;
-  // The mirror is opaque across the ground's extent when on — it always shows
-  // SOMETHING, because the backdrop rides in the reflection target itself.
-  let mirrA = material.mirror * edgeFade;
+  // The mirror covers only what it actually REFLECTS. The backdrop no longer
+  // rides in the reflection target — it clears transparent — so the floor keeps
+  // its own colour everywhere the cast is not standing, which is the difference
+  // between an MMD stage floor and a mirror of the sky.
+  let mirrA = material.mirror * edgeFade * reflA;
   // As opacity drops the received shadow becomes a translucent dark layer
   // (Blender's Shadow Catcher), so models still feel grounded on a photo or a
   // 360 backdrop. Colourless by construction: it darkens by covering. The
   // MIRROR subsumes it: the reflection already carries the received shadow,
   // and a catcher stacked on top would darken the same shadow twice.
-  let catchA = dark * 0.65 * edgeFade * (1.0 - material.opacity) * (1.0 - material.mirror);
+  let catchA = dark * 0.65 * edgeFade * (1.0 - material.opacity) * (1.0 - mirrA);
 
   // FOUR LAYERS, premultiplied, bottom to top: reflection, received shadow,
   // ground surface, grid. Each with its own coverage, none scaling another —