reze-engine 0.56.6 → 0.56.8

package/dist/engine.js

@@ -20,7 +20,7 @@ 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 } from "./param-track";
-import { effectState, advanceSim } from "./effect-schedule";
+import { advanceSim, DISSOLVE_PARAMS, dissolveConstants, dissolveCycleOf, effectState, sampleDissolveCycle, scheduledDissolve, } from "./effect-schedule";
 import { parentKeySpan } from "./parent-keys";
 import { SHADOW_CASCADES, buildShadowVP } from "./shadow-cascades";
 import { REFLECTION_DEBUG_WGSL, buildMirrorCamera, planeFromPointNormal } from "./reflection";
@@ -896,6 +896,9 @@ export class Engine {
         this.cullCameraArgs = null;
         this.cullShadowArgs = null;
         this.cullMirrorArgs = null;
+        /** 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. */
+        this.groundY = 0;
         this.mirrorPlane = new Float32Array([0, 1, 0, 0]);
         this.mirrorCameraData = new Float32Array(40);
         // proj x mirrorView for the ground's projective sample and the cull planes,
@@ -1428,6 +1431,9 @@ export class Engine {
             this.gizmoDrag = null;
             this.camera?.setInputLocked(false);
         };
+        /** 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. */
+        this.dissolveTouched = new Set();
         this.canvas = canvas;
         const d = DEFAULT_ENGINE_OPTIONS;
         this.world = {
@@ -2147,7 +2153,9 @@ export class Engine {
             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.
@@ -3365,6 +3373,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.
@@ -7782,6 +7791,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,
@@ -7797,7 +7807,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 = {
@@ -7810,7 +7821,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,
         };
     }
@@ -10592,13 +10610,13 @@ export class Engine {
             baseBuf,
         };
     }
-    createGroundGeometry(width = 100, height = 100) {
+    createGroundGeometry(width = 100, height = 100, y = 0) {
         const halfWidth = width / 2;
         const halfHeight = height / 2;
         const vertices = new Float32Array([
             // Bottom-left
             -halfWidth,
-            0,
+            y,
             -halfHeight, // position
             0,
             1,
@@ -10607,7 +10625,7 @@ export class Engine {
             0, // uv
             // Bottom-right
             halfWidth,
-            0,
+            y,
             -halfHeight, // position
             0,
             1,
@@ -10616,7 +10634,7 @@ export class Engine {
             0, // uv
             // Top-right
             halfWidth,
-            0,
+            y,
             halfHeight, // position
             0,
             1,
@@ -10625,7 +10643,7 @@ export class Engine {
             1, // uv
             // Top-left
             -halfWidth,
-            0,
+            y,
             halfHeight, // position
             0,
             1,
@@ -10693,7 +10711,7 @@ export class Engine {
         return this.groundShadowSoftPipeline;
     }
     createShadowGroundResources(opts) {
-        const { diffuseColor, fadeStart, fadeEnd, shadowStrength, gridSpacing, gridLineWidth, gridLineOpacity, gridLineColor, noiseStrength, opacity, mirror, mirrorBlur, shadowSoftness, } = opts;
+        const { diffuseColor, y, fadeStart, fadeEnd, shadowStrength, gridSpacing, gridLineWidth, gridLineOpacity, gridLineColor, noiseStrength, opacity, mirror, mirrorBlur, shadowSoftness, } = opts;
         // Shadow map is already created in setupPipelines()
         // 20 floats: 16 for the original block, then (mirrorBlur, pad, pad, pad)
         // keeping the uniform vec4-aligned.
@@ -10721,6 +10739,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;
@@ -12304,6 +12325,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();
         // Depth of field's entire disabled cost is this branch: depth stays in
@@ -12444,7 +12468,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,
@@ -12913,22 +12936,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
@@ -12941,6 +12948,20 @@ export class Engine {
         inst.model.setEyeTracking(options);
         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, cycle) {
         if (!this.modelInstances.has(modelName))
             return false;
@@ -12952,26 +12973,69 @@ export class Engine {
         this.dissolveCycles.set(modelName, cycle);
         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. */
-    evaluateDissolveCycles() {
-        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;
+    /** The model at one cast slot — the subject rzSubject(index) reads. */
+    castSubjectName(index) {
+        let n = 0;
+        let found = 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. */
+    dissolveTimingsOf(fx, wrote) {
+        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;
+    }
+    /**
+     * 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.
+     */
+    evaluateDissolves() {
+        const want = new Map();
+        const put = (name, v) => 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 = 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 ?? (transport = this.transportTime());
+                put(subject, scheduledDissolve(fx.window, cycle, transport));
             }
-            else if (t >= c.backAt && t < c.doneAt) {
-                v = (t - c.backAt) / Math.max(c.doneAt - c.backAt, 1e-4);
+            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. */
     getModelDissolve(modelName) {

package/dist/shaders/passes/ground.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ground.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground.ts"],"names":[],"mappings":"AAgFA;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,UAAQ,GAAG,MAAM,CAmWrD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,QAAS,CAAA;AACxC,eAAO,MAAM,gBAAgB,QAAS,CAAA;AAEtC;;;oEAGoE;AACpE,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,+oCAiClC,CAAA"}
+{"version":3,"file":"ground.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/ground.ts"],"names":[],"mappings":"AAgFA;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,UAAQ,GAAG,MAAM,CAoWrD;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,QAAS,CAAA;AACxC,eAAO,MAAM,gBAAgB,QAAS,CAAA;AAEtC;;;oEAGoE;AACpE,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB,+oCAiClC,CAAA"}

package/dist/shaders/passes/ground.js

@@ -90,7 +90,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.
@@ -356,20 +356,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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reze-engine",
-  "version": "0.56.6",
+  "version": "0.56.8",
   "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/effect-schedule.ts

@@ -166,3 +166,99 @@ export function advanceSim(
   if (prev.start !== window.start || prev.time === null || time < prev.time) return { reset: true, step: 0, clock }
   return { reset: false, step: Math.min(SIM_MAX_STEP, time - prev.time), clock }
 }
+
+/**
+ * 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
+}
+
+/** The four durations an effect declares, in seconds. */
+export type DissolveTimings = { apart: number; gone: number; back: number; whole: number }
+
+/** Each duration and the name an effect gives it, as a dial or as a constant. */
+export const DISSOLVE_PARAMS = [
+  ["apart", "DISSOLVE_APART"],
+  ["gone", "DISSOLVE_GONE"],
+  ["back", "DISSOLVE_BACK"],
+  ["whole", "DISSOLVE_WHOLE"],
+] as const satisfies readonly (readonly [keyof DissolveTimings, string])[]
+
+/**
+ * The four durations an effect wrote as constants.
+ *
+ * Where an effect declares them as `#param` dials instead, these are absent and
+ * the live dial stands in — which is what lets an author retime a teleport while
+ * watching it.
+ */
+export function dissolveConstants(wgsl: string): DissolveTimings {
+  const one = (name: string): number => {
+    const m = new RegExp(`^\\s*const\\s+${name}\\s*(?::\\s*f32\\s*)?=\\s*(-?[\\d.]+)`, "m").exec(wgsl)
+    const v = m ? Number(m[1]) : 0
+    return Number.isFinite(v) && v > 0 ? v : 0
+  }
+  return { apart: one("DISSOLVE_APART"), gone: one("DISSOLVE_GONE"), back: one("DISSOLVE_BACK"), whole: one("DISSOLVE_WHOLE") }
+}
+
+/**
+ * Four durations as the four moments the engine performs, or null when they add
+ * up to nothing — a period of zero is not a dissolve that never fires, it is a
+ * number everything downstream divides by.
+ *
+ * The cycle STARTS WHOLE: the wait comes first, so it is the gap you see between
+ * teleports rather than a tail nobody can find the start of.
+ */
+export function dissolveCycleOf(t: DissolveTimings): DissolveCycle | null {
+  const apart = Math.max(0, t.apart)
+  const gone = Math.max(0, t.gone)
+  const back = Math.max(0, t.back)
+  const whole = Math.max(0, t.whole)
+  if (apart + gone + back + whole <= 0.01) return null
+  const breakAt = whole
+  const hiddenAt = breakAt + apart
+  const backAt = hiddenAt + gone
+  const doneAt = backAt + back
+  return { period: doneAt, breakAt, hiddenAt, backAt, doneAt }
+}
+
+/** How much of her is there at one moment of a cycle, 1 whole and 0 gone. */
+export function sampleDissolveCycle(c: DissolveCycle, time: number): number {
+  const period = Math.max(c.period, 1e-3)
+  const t = time - Math.floor(time / period) * period
+  if (t >= c.breakAt && t < c.hiddenAt) return 1 - (t - c.breakAt) / Math.max(c.hiddenAt - c.breakAt, 1e-4)
+  if (t >= c.hiddenAt && t < c.backAt) return 0
+  if (t >= c.backAt && t < c.doneAt) return (t - c.backAt) / Math.max(c.doneAt - c.backAt, 1e-4)
+  return 1
+}
+
+/**
+ * A scheduled effect's dissolve: whole outside every window, and inside one the
+ * cycle on that window's own clock.
+ *
+ * THE WINDOW OPENS ON THE DEPARTURE. The cycle itself starts whole, which is
+ * right for an effect that simply repeats, and wrong for a clip someone placed
+ * on a beat: they put it where the teleport happens, not three seconds before
+ * it. So the clip enters at `breakAt`, and the wait becomes the tail the motes
+ * finish falling in.
+ */
+export function scheduledDissolve(
+  windows: readonly EffectWindow[],
+  c: DissolveCycle,
+  transport: number,
+): number {
+  const w = activeWindow(windows, transport)
+  return w ? sampleDissolveCycle(c, transport - w.start + c.breakAt) : 1
+}