reze-engine 0.56.6 → 0.56.8

package/src/engine.ts

@@ -30,7 +30,19 @@ import { LTC_MAG_LUT_SIZE, LTC_MAG_LUT_DATA } from "./shaders/ltc_mag_lut"
 import { SHADOW_DEPTH_SHADER_WGSL } from "./shaders/passes/shadow"
 import { ID_DEBUG_SHADER_WGSL } from "./shaders/passes/id-debug"
 import { paramChanged, sampleParamTrack, type ParamKey, type ParamValue } from "./param-track"
-import { effectState, type EffectWindow, advanceSim, type SimClock } from "./effect-schedule"
+import {
+  advanceSim,
+  DISSOLVE_PARAMS,
+  dissolveConstants,
+  dissolveCycleOf,
+  effectState,
+  sampleDissolveCycle,
+  scheduledDissolve,
+  type DissolveCycle,
+  type DissolveTimings,
+  type EffectWindow,
+  type SimClock,
+} from "./effect-schedule"
 import { parentKeySpan, type ModelParentKey } from "./parent-keys"
 import { SHADOW_CASCADES, buildShadowVP } from "./shadow-cascades"
 import { REFLECTION_DEBUG_WGSL, buildMirrorCamera, planeFromPointNormal } from "./reflection"
@@ -745,24 +757,8 @@ interface PickDrawCall {
   bindGroup: GPUBindGroup
 }
 
-/**
- * A repeating dissolve, in seconds within one cycle.
- *
- * Four moments rather than a duration and a delay: every one of them is a thing
- * you can see happen, and an author tuning this is watching for exactly those
- * four frames.
- */
-export interface DissolveCycle {
-  period: number
-  /** She starts to come apart. */
-  breakAt: number
-  /** Fully gone. */
-  hiddenAt: number
-  /** She starts to come back. */
-  backAt: number
-  /** Whole again. */
-  doneAt: number
-}
+/** Authored in effect-schedule, beside the evaluator that performs it. */
+export type { DissolveCycle }
 
 interface ModelInstance {
   name: string
@@ -1540,6 +1536,12 @@ interface EffectInstance {
   simStep: number
   /** Empty the particle pool and the grid before this frame's step. */
   simReset: boolean
+  /**
+   * The four durations this effect's `#dissolve` takes the cast apart over, as
+   * its source wrote them. Null unless it declared one. A dial of the same name
+   * wins over the constant — see dissolveTimingsOf.
+   */
+  dissolve: DissolveTimings | null
   /** This effect's OWN clock, as a uniform the field shader reads. Per effect
    *  because the shared one (viewU[6].x) is measured from the first installed
    *  effect's epoch, so everything later started mid-stream. Null when the
@@ -2140,6 +2142,9 @@ export class Engine {
   // because two planes would need two of every attachment below. Which one is
   // in force is mirrorPlane, refreshed by updateMirrorCamera.
   private static readonly GROUND_PLANE: readonly number[] = [0, 1, 0, 0]
+  /** Where addGround put the floor. The mirror reflects across it, so a raised
+   *  floor that kept y = 0 would reflect the scene into the wrong plane. */
+  private groundY = 0
   private mirrorPlane = new Float32Array([0, 1, 0, 0])
   private mirrorCameraData = new Float32Array(40)
   private mirrorCameraBuffer!: GPUBuffer
@@ -3290,7 +3295,9 @@ export class Engine {
       const m = this.mirrorSurfaceModel
       planeFromPointNormal(m[12], m[13], m[14], m[8], m[9], m[10], this.mirrorPlane)
     } else {
+      // The floor's own plane: up, offset to wherever addGround put it.
       this.mirrorPlane.set(Engine.GROUND_PLANE)
+      this.mirrorPlane[3] = -this.groundY
     }
     // The ground inside the mirror pass clips against this same plane — a
     // mirror shows nothing behind itself, and the floor is what is behind one.
@@ -4557,6 +4564,7 @@ export class Engine {
         sim: { start: null, time: null },
         simStep: 0,
         simReset: false,
+        dissolve: d.dissolve ? dissolveConstants(authored) : null,
         // Its OWN resolution, no longer the scene's: an effect that never asked
         // for full res is not promoted because a neighbour did.
         // FULL RESOLUTION UNLESS TOLD OTHERWISE.
@@ -9204,6 +9212,15 @@ export class Engine {
   addGround(options?: {
     width?: number
     height?: number
+    /**
+     * Where the plane sits on Y, in world units. 0 (default) is MMD's floor.
+     *
+     * A framing offset, not a stage: a camera motion authored for a taller or
+     * shorter character fits by moving the model and the floor together, which
+     * is cheaper than retiming the shot. What stands ON the floor does not
+     * follow it — the physics floor is model space, at the figure's own feet.
+     */
+    y?: number
     diffuseColor?: Vec3
     fadeStart?: number
     fadeEnd?: number
@@ -9243,6 +9260,7 @@ export class Engine {
     const opts = {
       width: 160,
       height: 160,
+      y: 0,
       diffuseColor: new Vec3(0.9, 0.1, 1.0),
       fadeStart: 10.0,
       fadeEnd: 80.0,
@@ -9258,7 +9276,8 @@ export class Engine {
       shadowSoftness: 0,
       ...options,
     }
-    this.createGroundGeometry(opts.width, opts.height)
+    this.groundY = opts.y
+    this.createGroundGeometry(opts.width, opts.height, opts.y)
     this.createShadowGroundResources(opts)
     this.hasGround = true
     this.groundDrawCall = {
@@ -9271,7 +9290,14 @@ export class Engine {
       // The ground belongs to no model instance, so it is not in the cull list —
       // cullIndex -1 leaves renderGround unconditional. Its box is filled in
       // anyway rather than left a lie for whoever reads this next.
-      bounds: new Float32Array([-opts.width / 2, 0, -opts.height / 2, opts.width / 2, 0, opts.height / 2]),
+      bounds: new Float32Array([
+        -opts.width / 2,
+        opts.y,
+        -opts.height / 2,
+        opts.width / 2,
+        opts.y,
+        opts.height / 2,
+      ]),
       cullIndex: -1,
     }
   }
@@ -12316,14 +12342,14 @@ export class Engine {
     }
   }
 
-  private createGroundGeometry(width: number = 100, height: number = 100) {
+  private createGroundGeometry(width: number = 100, height: number = 100, y: number = 0) {
     const halfWidth = width / 2
     const halfHeight = height / 2
 
     const vertices = new Float32Array([
       // Bottom-left
       -halfWidth,
-      0,
+      y,
       -halfHeight, // position
       0,
       1,
@@ -12333,7 +12359,7 @@ export class Engine {
 
       // Bottom-right
       halfWidth,
-      0,
+      y,
       -halfHeight, // position
       0,
       1,
@@ -12343,7 +12369,7 @@ export class Engine {
 
       // Top-right
       halfWidth,
-      0,
+      y,
       halfHeight, // position
       0,
       1,
@@ -12353,7 +12379,7 @@ export class Engine {
 
       // Top-left
       -halfWidth,
-      0,
+      y,
       halfHeight, // position
       0,
       1,
@@ -12433,6 +12459,7 @@ export class Engine {
 
   private createShadowGroundResources(opts: {
     diffuseColor: Vec3
+    y: number
     fadeStart: number
     fadeEnd: number
     shadowStrength: number
@@ -12448,6 +12475,7 @@ export class Engine {
   }) {
     const {
       diffuseColor,
+      y,
       fadeStart,
       fadeEnd,
       shadowStrength,
@@ -12488,6 +12516,9 @@ export class Engine {
     // gb[18] — shadow edge softness. Was padding; the shader reads it as the
     // Vogel disk's radius, and 0 takes the sharp nine-tap path unchanged.
     gb[18] = Math.min(Math.max(shadowSoftness, 0), 1)
+    // gb[19] — the floor's height. Was padding; the mirror branch reflects the
+    // eye across it, and a hardcoded 0 slid the reflection off a raised floor.
+    gb[19] = y
     // Which variant the draw picks. Zero is the sharp shader, which is the one
     // that existed before softness did.
     this.groundSoft = gb[18] > 0
@@ -14390,6 +14421,9 @@ export class Engine {
       if (pose) this.camera.setVmdPose(pose)
     }
 
+    // Before the cast is written, which carries every subject's dissolve to the
+    // effects reading it.
+    this.evaluateDissolves()
     this.updateCameraUniforms()
     this.updateShadowLightVP()
 
@@ -14531,7 +14565,6 @@ export class Engine {
     // and a grid stepped after them is one frame stale in everything that used it.
     // Material parameters on the scene clock, before anything reads their
     // uniforms this frame.
-    this.evaluateDissolveCycles()
     this.evaluateParamTracks()
     // FIRST among the things that read an effect, because every one of them
     // reads what this writes: the sim's clock, the particle uniform's weight,
@@ -15012,22 +15045,6 @@ export class Engine {
     return true
   }
 
-  /**
-   * A repeating dissolve, on the scene clock.
-   *
-   * The alternative was a host calling setModelDissolve every frame, and it is
-   * the wrong shape twice: an exported take stepped at another rate would land
-   * on different values than the preview did, and the effect drawing the sparks
-   * would be reading a number some other clock wrote. Here the engine samples it
-   * where it samples everything else time-driven, so a take reproduces exactly
-   * and rzSubject().dissolve is the same value the material shell used on that
-   * very frame.
-   *
-   * The five numbers are seconds within one cycle: when she starts to go, when
-   * she is fully gone, when she starts to come back, and when she is whole. The
-   * gaps between them are the timing, and the hold between the middle two is how
-   * long she is away.
-   */
   /**
    * Eyes on the camera, per model — see Model.setEyeTracking. Live: solved
    * every frame against wherever the camera is, orbit or motion alike. Null
@@ -15040,6 +15057,20 @@ export class Engine {
     return true
   }
 
+  /**
+   * A repeating dissolve on one model, on the scene clock.
+   *
+   * The alternative was a host calling setModelDissolve every frame, and it is
+   * the wrong shape twice: an exported take stepped at another rate would land
+   * on different values than the preview did, and the effect drawing the sparks
+   * would be reading a number some other clock wrote. Here the engine samples it
+   * where it samples everything else time-driven, so a take reproduces exactly
+   * and rzSubject().dissolve is the same value the material shell used on that
+   * very frame.
+   *
+   * An effect that declares `#dissolve` needs none of this: it carries its own
+   * cycle and follows its own clips — see evaluateDissolves.
+   */
   setModelDissolveCycle(modelName: string, cycle: DissolveCycle | null): boolean {
     if (!this.modelInstances.has(modelName)) return false
     if (!cycle) {
@@ -15050,23 +15081,65 @@ export class Engine {
     return true
   }
 
-  /** Every dissolve cycle, at the current scene clock. Once per frame, before
-   *  the cast is written and long before any effect reads it. */
-  private evaluateDissolveCycles(): void {
-    if (this.dissolveCycles.size === 0) return
-    for (const [name, c] of this.dissolveCycles) {
-      const period = Math.max(c.period, 1e-3)
-      const t = this.sceneClock - Math.floor(this.sceneClock / period) * period
-      let v = 1
-      if (t >= c.breakAt && t < c.hiddenAt) {
-        v = 1 - (t - c.breakAt) / Math.max(c.hiddenAt - c.breakAt, 1e-4)
-      } else if (t >= c.hiddenAt && t < c.backAt) {
-        v = 0
-      } else if (t >= c.backAt && t < c.doneAt) {
-        v = (t - c.backAt) / Math.max(c.doneAt - c.backAt, 1e-4)
+  /** The model at one cast slot — the subject rzSubject(index) reads. */
+  private castSubjectName(index: number): string | null {
+    let n = 0
+    let found: string | null = null
+    this.forEachInstance((inst) => {
+      if (found !== null || n >= MAX_EFFECT_SUBJECTS || inst.isStage || inst.isPlane || inst.isProp) return
+      if (n === index) found = inst.name
+      n++
+    })
+    return found
+  }
+
+  /** One effect's four durations: its dials where it declares them, the
+   *  constants it wrote where it does not. */
+  private dissolveTimingsOf(fx: EffectInstance, wrote: DissolveTimings): DissolveTimings {
+    const t = { ...wrote }
+    for (const [key, name] of DISSOLVE_PARAMS) {
+      const slot = fx.paramLayout.get(name)
+      if (slot) t[key] = Math.max(0, fx.paramsData[slot.offset])
+    }
+    return t
+  }
+
+  /** Models this wrote a dissolve onto last frame, so one nothing asks for any
+   *  more comes back whole instead of holding wherever it was left. */
+  private dissolveTouched = new Set<string>()
+
+  /**
+   * Every dissolve, once a frame, before the cast is written — so the value a
+   * mote reads as rzSubject(i).dissolve is the one her materials wore on that
+   * very frame, rather than the one they wore on the last.
+   *
+   * Two things ask for one. A cycle set on a model (setModelDissolveCycle) runs
+   * on the scene clock and repeats, as it always has. An effect declaring
+   * `#dissolve` takes subject 0 apart on ITS OWN terms: scheduled, the cycle on
+   * each clip's clock with her whole between clips; unscheduled, the same
+   * repeating cycle as before. Where both ask, the more dissolved wins — two
+   * answers about one body, and half a body is not one of them.
+   */
+  private evaluateDissolves(): void {
+    const want = new Map<string, number>()
+    const put = (name: string, v: number) => want.set(name, Math.min(want.get(name) ?? 1, v))
+    for (const [name, c] of this.dissolveCycles) put(name, sampleDissolveCycle(c, this.sceneClock))
+    let transport: number | null = null
+    for (const fx of this.effects) {
+      if (!fx.dissolve) continue
+      const cycle = dissolveCycleOf(this.dissolveTimingsOf(fx, fx.dissolve))
+      const subject = this.castSubjectName(0)
+      if (!cycle || !subject) continue
+      if (fx.window && fx.window.length > 0) {
+        transport ??= this.transportTime()
+        put(subject, scheduledDissolve(fx.window, cycle, transport))
+      } else {
+        put(subject, sampleDissolveCycle(cycle, this.sceneClock))
       }
-      this.setModelDissolve(name, v)
     }
+    for (const name of this.dissolveTouched) if (!want.has(name)) this.setModelDissolve(name, 1)
+    this.dissolveTouched = new Set(want.keys())
+    for (const [name, v] of want) this.setModelDissolve(name, v)
   }
 
   /** What setModelDissolve last set, or 1 for a model that has never dissolved. */

package/src/shaders/passes/ground.ts

@@ -94,7 +94,7 @@ struct GroundShadowMat {
   gridLineColor: vec3f, mirror: f32,
   // farCascade: 1 while a stage is loaded, 0 otherwise. See the branch below —
   // with no stage the far map is never drawn into, so its taps are known.
-  mirrorBlur: f32, farCascade: f32, shadowSoftness: f32, _mb2: f32,
+  mirrorBlur: f32, farCascade: f32, shadowSoftness: f32, groundY: f32,
   // Every shadow caster in one sphere, refreshed per frame. w = radius; 0 means
   // nothing casts, negative means "do not use this" (a rigid caster has no
   // sphere, so a scene with a stage keeps the taps). See rzShadowPossible.
@@ -362,20 +362,21 @@ ${pcfWgsl("shadowMap", "suv_c", "material.pcfTexel", "compareZ", "acc", "    ",
       // shared projection's pair (viewZ = projB / (z - projA); the formula
       // inverts both depth conventions, see the composite's linearDepth), and
       // reconstruct the reflected image point along the ray from the MIRRORED
-      // eye through this fragment. The plane is y = 0, so mirroring the eye
-      // and the camera forward is a sign flip on y, and the image point's
-      // depth below the plane IS the reflected object's height above it.
+      // eye through this fragment. Mirroring across the floor's own plane is a
+      // sign flip on y about that height (the forward vector is a direction, so
+      // it flips alone), and the image point's depth below the plane IS the
+      // reflected object's height above it.
       let dims = vec2f(textureDimensions(mirrorDepth));
       let texel = clamp(vec2i(muv * dims), vec2i(0), vec2i(dims) - vec2i(1));
       let z = textureLoad(mirrorDepth, texel, 0);
       let viewZ = clamp(mirrorVP.params.y / (z - mirrorVP.params.x), 0.05, 100000.0);
-      let eyeM = vec3f(camera.viewPos.x, -camera.viewPos.y, camera.viewPos.z);
+      let eyeM = vec3f(camera.viewPos.x, 2.0 * material.groundY - camera.viewPos.y, camera.viewPos.z);
       let fwd = vec3f(camera.view[0][2], camera.view[1][2], camera.view[2][2]);
       let fwdM = vec3f(fwd.x, -fwd.y, fwd.z);
       let toFrag = i.worldPos - eyeM;
       let dir = toFrag * inverseSqrt(max(dot(toFrag, toFrag), 1e-8));
       let t = viewZ / max(dot(dir, fwdM), 1e-4);
-      let height = max(-(eyeM.y + dir.y * t), 0.0);
+      let height = max(material.groundY - (eyeM.y + dir.y * t), 0.0);
       // Full softness by BLUR_SPAN units above the floor — about a character's
       // height. The hardware clamps the level, so the nominal 5.0 needs no
       // knowledge of the real chain length, and blur 0 reads exactly level 0.