reze-engine 0.56.5 → 0.56.7

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 } 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";
@@ -1428,6 +1428,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 = {
@@ -3362,6 +3365,10 @@ export class Engine {
             influence: 1,
             window: null,
             weight: 1,
+            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.
@@ -3617,10 +3624,11 @@ export class Engine {
         const renderModule = await compile(buildParticleRenderShader(src, cast), "particle render");
         if (Array.isArray(renderModule))
             return { ok: false, diagnostics: renderModule };
+        // COPY_DST so a scheduled effect can empty its pool when its window starts.
         const buffer = this.device.createBuffer({
             label: "particle pool",
             size: count * PARTICLE_STRIDE,
-            usage: GPUBufferUsage.STORAGE,
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
         });
         const uniform = this.device.createBuffer({
             label: "particle uniforms",
@@ -3870,6 +3878,16 @@ export class Engine {
             const p = e.particles;
             if (!p)
                 continue;
+            const scheduled = e.window !== null;
+            // A scheduled pool that has not moved holds still: a paused transport, or
+            // a time outside every window. A dispatch at dt 0 would still run the
+            // author's step, and not every step is a function of dt.
+            if (scheduled && !e.simReset && e.simStep === 0)
+                continue;
+            // Entering its window, or going back in it: the pool starts empty, and
+            // every slot spawns on this dispatch from the effect's own local time.
+            if (e.simReset)
+                encoder.clearBuffer(p.buffer);
             p.data[0] = this.sceneClock - e.epochScene;
             // The SIMULATION runs at every weight, 0 included — only the draw stops.
             // A scheduled effect that froze while faded out would resume from the
@@ -3878,7 +3896,9 @@ export class Engine {
             p.data[4] = e.weight;
             // Clamped: a backgrounded tab returns with a delta of whole seconds, and an
             // unclamped step flings every particle out of the scene in one frame.
-            p.data[1] = Math.min(0.1, Math.max(0, deltaTime));
+            // A scheduled effect steps by the transport instead, clamped the same way
+            // in advanceSim, so a pause freezes it and an export steps it exactly.
+            p.data[1] = scheduled ? e.simStep : Math.min(0.1, Math.max(0, deltaTime));
             p.counts[2] = p.count;
             p.counts[3] = this.particleFrame++;
             this.device.queue.writeBuffer(p.uniform, 0, p.data.buffer);
@@ -4325,7 +4345,8 @@ export class Engine {
             label: `grid grid ${n}`,
             size: [size, size],
             format: SIM_FORMAT,
-            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING,
+            // RENDER_ATTACHMENT so a scheduled effect can clear it when its window starts.
+            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT,
         });
         const textures = [make(0), make(1)];
         const read = [textures[0].createView(), textures[1].createView()];
@@ -4394,11 +4415,29 @@ export class Engine {
             const grid = e.grid;
             if (!grid)
                 continue;
+            const scheduled = e.window !== null;
+            // Held still like the particles, for the same reason.
+            if (scheduled && !e.simReset && e.simStep === 0)
+                continue;
+            if (e.simReset) {
+                // Back to how install left it: both textures empty and frame 0 again,
+                // the frame an effect seeds its grid on.
+                for (const view of grid.read) {
+                    encoder
+                        .beginRenderPass({
+                        label: "grid reset",
+                        colorAttachments: [{ view, loadOp: "clear", storeOp: "store", clearValue: { r: 0, g: 0, b: 0, a: 0 } }],
+                    })
+                        .end();
+                }
+                grid.frame = 0;
+                grid.parity = 0;
+            }
             grid.data[0] = this.sceneClock - e.epochScene;
             // Clamped like the particle step: a backgrounded tab returns with a delta of
             // whole seconds, and one unclamped step of an advection kernel throws the
             // whole grid off its own edge.
-            grid.data[1] = Math.min(0.1, Math.max(0, deltaTime));
+            grid.data[1] = scheduled ? e.simStep : Math.min(0.1, Math.max(0, deltaTime));
             grid.data[2] = grid.size;
             grid.data[3] = grid.frame++;
             this.device.queue.writeBuffer(grid.uniform, 0, grid.data.buffer);
@@ -4497,6 +4536,12 @@ export class Engine {
         if (!fx)
             return;
         fx.window = windows && windows.length ? windows : null;
+        // Unscheduled forgets where its simulation stood. A changed lane keeps it:
+        // advanceSim restarts the pool only if the window the transport is in now
+        // starts somewhere else, so trimming a block, or turning the influence
+        // that is sent with every lane, does not restart a burst mid-flight.
+        if (!fx.window)
+            fx.sim = { start: null, time: null };
     }
     getEffectSchedule(index) {
         return this.effects[index]?.window ?? null;
@@ -4513,12 +4558,20 @@ export class Engine {
         // Read ONCE: it walks the cast, and every effect wants the same answer.
         const transport = this.transportTime();
         for (const fx of this.effects) {
+            fx.simReset = false;
             if (!fx.window || fx.window.length === 0) {
                 fx.weight = fx.influence;
                 continue;
             }
             const at = effectState(fx.window, fx.influence, transport);
             fx.weight = at.weight;
+            // The particles and the grid carry state from frame to frame, so they get
+            // more than a clock: a restart on entering a window or going back in one,
+            // and a step measured on the transport. See advanceSim.
+            const sim = advanceSim(fx.sim, fx.window, transport);
+            fx.sim = sim.clock;
+            fx.simStep = sim.step;
+            fx.simReset = sim.reset;
             // Its own clock, expressed the way the mounts read it. Every mount
             // derives time from the epoch against sceneClock, so this one write moves
             // the field, the particles, the ribbons, lightEmit and the grid together
@@ -12255,6 +12308,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
@@ -12395,7 +12451,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,
@@ -12864,22 +12919,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
@@ -12892,6 +12931,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;
@@ -12903,26 +12956,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/index.d.ts

@@ -4,7 +4,7 @@ export { parseMidi } from "./midi-loader";
 export { parseHDR, type HdrImage } from "./hdr";
 export { LYRIC_ATLAS_MAX_H, LYRIC_ATLAS_MAX_W, parseLRC, type LyricLine, type LyricRect } from "./shaders/lyrics-api";
 export { sampleParamTrack, type ParamKey, type ParamValue } from "./param-track";
-export { effectState, type EffectWindow, type EffectState } from "./effect-schedule";
+export { activeWindow, advanceSim, effectState, SIM_MAX_STEP, type EffectWindow, type EffectState, type SimClock, } from "./effect-schedule";
 export { parentKeyIndex, type ModelParentKey } from "./parent-keys";
 export { compileGraph, validateGraph, assignStyleSlots, type CompileOptions, type CompileResult, type StyleSlot, } from "./graph/compile";
 export type { ShaderGraph, GraphNode, GraphLink, ExposedParam, SocketValue, Diagnostic, } from "./graph/schema";

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -14,7 +14,7 @@ export { sampleParamTrack } from "./param-track";
 // The strip an effect is scheduled by, and the pure evaluator behind it —
 // exported so a caller can draw a lane against the same numbers the engine
 // renders from, rather than a second copy of the ramp maths.
-export { effectState } from "./effect-schedule";
+export { activeWindow, advanceSim, effectState, SIM_MAX_STEP, } from "./effect-schedule";
 // Who a model hangs from over time, and the lookup behind it — exported so a
 // timeline draws its holds from the same rule the engine switches by.
 export { parentKeyIndex } from "./parent-keys";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reze-engine",
-  "version": "0.56.5",
+  "version": "0.56.7",
   "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

@@ -88,12 +88,7 @@ export function effectState(
   // it keeps "which strip am I in" a question with one answer — but a document
   // can be hand-edited, and "the one most recently entered" is the reading that
   // matches what you would see if they were laid down in order.
-  let window: EffectWindow | null = null
-  for (const w of windows) {
-    if (sceneTime < w.start) continue
-    if (w.end !== undefined && (w.end <= w.start || sceneTime > w.end)) continue
-    if (!window || w.start > window.start) window = w
-  }
+  const window = activeWindow(windows, sceneTime)
   if (!window) return SILENT
 
   const { start, end } = window
@@ -118,3 +113,152 @@ export function effectState(
   // dip toward zero in the middle of a short strip, which is not a fade.
   return { weight: level * clamp01(ramp), time }
 }
+
+/**
+ * The window that holds `sceneTime`: the latest start that contains it, edges
+ * inclusive, an end at or before its start holding nothing. Null outside every
+ * window and for a missing lane. effectState plays this window.
+ */
+export function activeWindow(windows: readonly EffectWindow[] | null, sceneTime: number): EffectWindow | null {
+  if (!windows) return null
+  let window: EffectWindow | null = null
+  for (const w of windows) {
+    if (sceneTime < w.start) continue
+    if (w.end !== undefined && (w.end <= w.start || sceneTime > w.end)) continue
+    if (!window || w.start > window.start) window = w
+  }
+  return window
+}
+
+/** The largest single step a scheduled simulation takes, in seconds. A hitch or
+ *  a scrub forward advances it this far and no further, and restarts nothing. */
+export const SIM_MAX_STEP = 0.1
+
+/** Where a scheduled effect's simulation stood last frame: the start of the
+ *  window it was in, and its own time there. Both null outside every window. */
+export type SimClock = { start: number | null; time: number | null }
+
+/**
+ * One frame of a scheduled effect's simulation: its particle pool and its grid.
+ *
+ * Those carry state from one frame to the next, so the window's clock alone
+ * cannot place them. A burst scheduled at bar 33 has to start there from an
+ * empty pool, and play the same way every time the scene reaches bar 33 —
+ * in the editor, on a loop, and in an export.
+ *
+ * - Entering a window RESTARTS it, from an empty pool and an unseeded grid.
+ * - Time going back inside a window restarts it too: a scrub back or a loop
+ *   wrapping, where what the pool holds is from later.
+ * - Forward, it steps by exactly how far the transport moved, at most
+ *   SIM_MAX_STEP. A paused transport steps it by zero, and an export steps it
+ *   the same way on every render.
+ * - Outside every window it does not step.
+ */
+export function advanceSim(
+  prev: SimClock,
+  windows: readonly EffectWindow[] | null,
+  sceneTime: number,
+): { reset: boolean; step: number; clock: SimClock } {
+  const window = activeWindow(windows, sceneTime)
+  if (!window) return { reset: false, step: 0, clock: { start: null, time: null } }
+  const time = sceneTime - window.start
+  const clock = { start: window.start, time }
+  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
+}