reze-engine 0.68.3 → 0.68.5

package/src/engine.ts

@@ -43,6 +43,7 @@ import {
   type SimClock,
 } from "./effect-schedule"
 import { parentKeySpan, type ModelParentKey } from "./parent-keys"
+import { JellyEyes, clampStrength, clearJellyEyes, type JellyEyeOptions } from "./jelly-eyes"
 import { NativeHost } from "./unity/host"
 import { NativeLooks, type NativeLook } from "./unity/looks"
 import { NativeStage, type NativeStageLights, type NativeStagePackage, type NativeStageReader } from "./unity/stage"
@@ -427,6 +428,11 @@ export interface MidiNote {
 /** How many character positions an effect can read (viewU[11..14]). Defined
  *  beside the shader that reads them — the layout arithmetic has to agree. */
 const MAX_EFFECT_SUBJECTS = EFFECT_SUBJECTS
+/** The frame's half height (model units) at and past which a camera follow
+ *  takes its full smoothing; closer shots follow more rigidly — see the
+ *  follow in renderWithDelta(). About a full-body shot. */
+const FOLLOW_LAG_FULL_HALF = 8
+
 /** Where a character IS, for an effect that follows them. センター carries a
  *  motion's root movement — walking, jumping — where the model transform only
  *  carries where the model was placed; 全ての親 is the fallback for a model that
@@ -1004,6 +1010,9 @@ interface ModelInstance {
    *  Off drops every draw from the shadow list; on hands it back to the PMX
    *  flag on each material. */
   castShadow: boolean
+  /** Its jelly eyes' springs, or null while its eyes are still — see
+   *  setModelJellyEyes. */
+  jellyEyes: JellyEyes | null
   basePath: string
   assetReader: AssetReader
   gpuBuffers: GPUBuffer[]
@@ -3038,6 +3047,12 @@ export class Engine {
   private cameraFollowSmoothing = 0
   private cameraFollowSeeded = false
   private readonly cameraFollowPos = new Vec3(0, 0, 0)
+  // Turning with the bone (setCameraFollow's `turn`): the bone's facing as yaw
+  // and elevation, eased like the position, whose change each frame is added
+  // to the orbit — so the shot keeps its angle to her face as she turns.
+  private cameraFollowTurn = false
+  private cameraFollowYaw = 0
+  private cameraFollowPitch = 0
   private cameraTargetOffset: Vec3 = new Vec3(0, 0, 0)
 
   private lastFrameTime = performance.now()
@@ -8311,8 +8326,9 @@ export class Engine {
           visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
           buffer: { type: "read-only-storage" },
         },
-        // The model's own light — see setModelFill and setModelSun.
-        { binding: 1, visibility: GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
+        // The model's own light — see setModelFill and setModelSun. VERTEX
+        // too: jelly eyes move the iris in the vertex shader (jelly[] in it).
+        { binding: 1, visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT, buffer: { type: "uniform" } },
       ],
     })
     // group 2: per-material (textures + material uniforms) — bound per draw call.
@@ -10222,8 +10238,13 @@ export class Engine {
     this.cameraTargetOffset.z = offset?.z ?? 0
   }
 
-  /** Souls-style follow cam: orbit center tracks a model bone each frame. Shorthand for setCameraTarget(model, boneName, offset). */
-  setCameraFollow(model: Model | null, boneName?: string, offset?: Vec3, smoothing?: number): void {
+  /**
+   * Souls-style follow cam: orbit center tracks a model bone each frame.
+   * Shorthand for setCameraTarget(model, boneName, offset). With `turn`, the
+   * orbit also turns with her face (the head bone) — the camera keeps its
+   * angle to her face as she turns and nods, and a drag still orbits on top.
+   */
+  setCameraFollow(model: Model | null, boneName?: string, offset?: Vec3, smoothing?: number, turn?: boolean): void {
     // Panning sets the very thing the follow overwrites each frame, so it is
     // goes to the offset for as long as the shot is riding a bone. See Camera.panSink.
     this.camera.panSink = model !== null ? this.cameraTargetOffset : null
@@ -10239,6 +10260,7 @@ export class Engine {
     // Handheld feel: seconds for the camera to close ~63% of the gap to the
     // bone (exponential, frame-rate independent). 0 = rigid instant follow.
     this.cameraFollowSmoothing = Math.max(0, smoothing ?? 0)
+    this.cameraFollowTurn = turn ?? false
     this.cameraFollowSeeded = false
   }
 
@@ -10400,6 +10422,49 @@ export class Engine {
     }
   }
 
+  /**
+   * The follow's turn: her FACE's direction — the head bone (頭), whatever bone
+   * the position rides, since an eye under eye tracking turns back toward the
+   * camera as the face turns and so never points anywhere new. MMD rests facing
+   * −Z, so forward is its negated third column, placed by the model's
+   * rotation (the followed bone stands in on a rig with no 頭) — as yaw and
+   * elevation, eased by the follow's own lag, and each frame's change added to
+   * the orbit (alpha turns with the yaw, beta with the elevation) and to the
+   * offset (turned about the vertical, so a framing off to her side stays at
+   * her side). Seeds without moving the camera, on the frame the follow is
+   * (re)bound — cameraFollowSeeded, cleared there, is set right after this.
+   */
+  private turnWithFollowBone(m: Model, tau: number, deltaTime: number): void {
+    const w = m.getBoneWorldMatrix("頭") ?? m.getBoneWorldMatrix(this.cameraTargetBoneName)
+    if (!w) return
+    const fwd = new Vec3(-w[8], -w[9], -w[10])
+    Quat.rotateVecInto(m.rotation, fwd, fwd)
+    const len = Math.hypot(fwd.x, fwd.y, fwd.z)
+    if (len < 1e-6) return
+    const yaw = Math.atan2(fwd.x, fwd.z)
+    const pitch = Math.asin(Math.max(-1, Math.min(1, fwd.y / len)))
+    if (!this.cameraFollowSeeded) {
+      this.cameraFollowYaw = yaw
+      this.cameraFollowPitch = pitch
+      return
+    }
+    const wrap = (a: number) => a - 2 * Math.PI * Math.round(a / (2 * Math.PI))
+    const k = tau > 0 ? 1 - Math.exp(-deltaTime / tau) : 1
+    const dYaw = wrap(yaw - this.cameraFollowYaw) * k
+    const dPitch = (pitch - this.cameraFollowPitch) * k
+    this.cameraFollowYaw = wrap(this.cameraFollowYaw + dYaw)
+    this.cameraFollowPitch += dPitch
+    const cam = this.camera
+    cam.alpha += dYaw
+    cam.beta = Math.max(0.01, Math.min(Math.PI - 0.01, cam.beta - dPitch))
+    const o = this.cameraTargetOffset
+    const c = Math.cos(dYaw)
+    const sn = Math.sin(dYaw)
+    const ox = o.x
+    o.x = ox * c + o.z * sn
+    o.z = -ox * sn + o.z * c
+  }
+
   /** True while the orbit target is riding a model bone (setCameraFollow). */
   isCameraFollowing(): boolean {
     return this.cameraTargetModel !== null
@@ -13730,6 +13795,39 @@ export class Engine {
     return true
   }
 
+  /**
+   * 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.
+   *
+   * 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.
+   * The springs step on the scene clock, so an export bounces exactly as the
+   * screen did. The iris only scales in place (see jelly-eyes.ts).
+   */
+  setModelJellyEyes(modelName: string, options: JellyEyeOptions | null): boolean {
+    const inst = this.modelInstances.get(modelName)
+    if (!inst || !this.device) return false
+    if (!options) {
+      inst.jellyEyes = null
+      clearJellyEyes(inst.objectLight)
+      this.device.queue.writeBuffer(inst.lightBuffer, 0, inst.objectLight)
+      return true
+    }
+    if (inst.jellyEyes) {
+      inst.jellyEyes.strength = clampStrength(options.strength)
+      inst.jellyEyes.idle = options.idle ?? true
+    }
+    else inst.jellyEyes = new JellyEyes(inst.model, options)
+    return true
+  }
+
+  getModelJellyEyes(modelName: string): Required<JellyEyeOptions> | null {
+    const jelly = this.modelInstances.get(modelName)?.jellyEyes
+    return jelly ? { strength: jelly.strength, idle: jelly.idle } : null
+  }
+
   getModelCastShadow(modelName: string): boolean {
     return this.modelInstances.get(modelName)?.castShadow ?? true
   }
@@ -13800,6 +13898,12 @@ export class Engine {
         verticesChanged = inst.model.update(deltaTime, inst.isStage || inst.isPlane ? false : this.ikEnabled)
         inst.skinMatricesDirty = true
       }
+      // After the pose, so the springs read this frame's blink and eye turn.
+      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)
+      }
       animMs += performance.now() - tAnim
       // Material morphs ride the same weight change as vertex morphs but land in
       // uniform buffers, so they consume their own flag — a model whose only
@@ -15104,9 +15208,9 @@ export class Engine {
 
     // Its ObjectLight: the world's ambient, and the layers its kind draws on —
     // 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] — see
-    // materials/common.ts.
-    const objectLight = new Float32Array(48)
+    // 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)
     new Uint32Array(objectLight.buffer)[0] =
       isStage || isPlane || isProp ? RENDERING_LAYER_DEFAULT : (RENDERING_LAYER_DEFAULT | RENDERING_LAYER_CHARACTER) >>> 0
     const lightBuffer = this.device.createBuffer({
@@ -15142,6 +15246,7 @@ export class Engine {
       model,
       simulateWhileHidden: false,
       castShadow: true,
+      jellyEyes: null,
       basePath,
       assetReader,
       gpuBuffers,
@@ -17397,8 +17502,16 @@ export class Engine {
           py += pos.y
           pz += pos.z
         }
-        const tau = this.cameraFollowSmoothing
+        // The lag scales with how much the shot holds. Eased, the pivot trails
+        // the bone by its speed × tau — nothing in a full-body shot, but in a
+        // close-up of her eye it is most of the frame, and the eye swims out
+        // of it as she moves. So: the full handheld lag once the frame is
+        // FOLLOW_LAG_FULL_HALF tall (half height, model units — about a
+        // full-body shot), shrinking linearly to rigid as the shot closes in.
+        const half = this.camera.radius * Math.tan(this.camera.fov / 2)
+        const tau = this.cameraFollowSmoothing * Math.min(1, half / FOLLOW_LAG_FULL_HALF)
         const f = this.cameraFollowPos
+        if (this.cameraFollowTurn) this.turnWithFollowBone(m, tau, deltaTime)
         if (tau > 0 && this.cameraFollowSeeded) {
           // Exponential lag toward the bone: the handheld-camera feel. The
           // orbit pivot trails the target and eases in, never snapping.

package/src/graph/slots.ts

@@ -57,6 +57,16 @@ 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. ──
 const STYLE_UNIFORMS_WGSL = `struct StyleUniforms { p: array<vec4f, 16> };
@@ -104,8 +114,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 {
-  let tex_s = textureSample(diffuseTexture, diffuseSampler, input.uv);
-  // MMD alpha semantics: material alpha × texture alpha.
+${renderClass === "eye" ? EYE_JELLY_SAMPLE : PLAIN_SAMPLE}  // MMD alpha semantics: material alpha × texture alpha.
   let alpha = material.alpha * tex_s.a;
 ${discard}
 
@@ -152,7 +161,7 @@ ${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 : ""}
 `
 }
 
@@ -205,7 +214,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`
+  const BURN = ` + RZ_BURN_COLOR * rz_burn${renderClass === "eye" ? " + rz_jelly_glow" : ""}`
   // 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

package/src/index.ts

@@ -220,6 +220,7 @@ export {
  */
 export { EFFECT_MATH_API, PARTICLE_STRUCT_WGSL } from "./shaders/passes/hosted-api"
 export type { EyeTrackingOptions } from "./model"
+export type { JellyEyeOptions } from "./jelly-eyes"
 
 /**
  * The game's own materials (src/unity): a stage package drawn by its translated