reze-engine 0.51.0 → 0.53.0

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

@@ -1 +1 @@
-{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/composite.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAgC+B;AAC/B;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,EAAE,CAIhG;AAID,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAEzG,KAAK,qBAAqB,GAAG;IAC3B,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAA;IACZ,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAA;IAClB,4DAA4D;IAC5D,aAAa,EAAE,OAAO,CAAA;IACtB,oEAAoE;IACpE,aAAa,EAAE,OAAO,CAAA;IACtB,mEAAmE;IACnE,QAAQ,EAAE,MAAM,CAAA;IAChB;mFAC+E;IAC/E,GAAG,CAAC,EAAE,OAAO,CAAA;IACb;;;yEAGqE;IACrE,UAAU,EAAE,MAAM,CAAA;IAClB;;8EAE0E;IAC1E,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;CACjB,CAAA;AA6LD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,yqaA+H5B,CAAA;AA4LD,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,IAAI,GAAG,MAAM,CAQlF;AAuDD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,qBAAqB,GAAG,MAAM,CAqEtE;AAED,iFAAiF;AACjF,eAAO,MAAM,qBAAqB,QAA6B,CAAA"}
+{"version":3,"file":"composite.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/composite.ts"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAgC+B;AAC/B;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,EAAE,CAIhG;AAID,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAA;AAEzG,KAAK,qBAAqB,GAAG;IAC3B,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAA;IACZ,kFAAkF;IAClF,UAAU,EAAE,MAAM,CAAA;IAClB,4DAA4D;IAC5D,aAAa,EAAE,OAAO,CAAA;IACtB,oEAAoE;IACpE,aAAa,EAAE,OAAO,CAAA;IACtB,gEAAgE;IAChE,QAAQ,EAAE,MAAM,CAAA;IAChB;mFAC+E;IAC/E,GAAG,CAAC,EAAE,OAAO,CAAA;IACb;;;yEAGqE;IACrE,UAAU,EAAE,MAAM,CAAA;IAClB;;8EAE0E;IAC1E,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;CACjB,CAAA;AA6LD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,yqaA+H5B,CAAA;AA4LD,wBAAgB,oBAAoB,CAAC,MAAM,CAAC,EAAE,qBAAqB,GAAG,IAAI,GAAG,MAAM,CAQlF;AAuDD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,qBAAqB,GAAG,MAAM,CA4EtE;AAED,iFAAiF;AACjF,eAAO,MAAM,qBAAqB,QAA6B,CAAA"}

package/dist/shaders/passes/composite.js

@@ -56,13 +56,13 @@ import { gridReadApi } from "./grid";
 /**
  * The bones an effect asked for, in declaration order — the slots rzAnchor reads.
  *
- *     // @anchor 左手首 trail
- *     // @anchor 頭
+ *     #anchor 左手首 trail
+ *     #anchor 頭
  *
  * A declaration in the source, like the mounts: what a file names is what gets
  * resolved and uploaded, so naming none costs nothing and nobody pays for a
  * rig's other five hundred bones. Anchored to the start of a line so that
- * writing the word @anchor in ordinary prose does not silently add a slot —
+ * writing the word #anchor in ordinary prose does not silently add a slot —
  * which would shift every slot after it.
  *
  * `trail` additionally keeps that bone's recent PATH, for rzTrail. Opt-in
@@ -73,7 +73,7 @@ import { gridReadApi } from "./grid";
  * not have simply reports invalid.
  */
 export function parseEffectAnchors(wgsl, max) {
-    return [...wgsl.matchAll(/^[ \t]*\/\/[ \t]*@anchor[ \t]+(\S+)([ \t]+trail)?[ \t]*$/gm)]
+    return [...wgsl.matchAll(/^[ \t]*\/\/[ \t]*#anchor[ \t]+(\S+)([ \t]+trail)?[ \t]*$/gm)]
         .map((m) => ({ bone: m[1], trail: m[2] !== undefined }))
         .slice(0, max);
 }
@@ -691,7 +691,7 @@ export function buildFieldShader(effect) {
  * whose lightEmit read its own epoch disagreed with its own background()
  * about what time it was. One buffer per effect, one answer.
  */
-@group(0) @binding(22) var<uniform> _rzFieldClock: vec4f;
+@group(0) @binding(22) var<uniform> _rzFieldClock: vec4f;   // (time, weight, _, _)
 
 @vertex fn fieldVs(@builtin(vertex_index) vi: u32) -> @builtin(position) vec4f {
   let x = f32((vi & 1u) << 2u) - 1.0;
@@ -715,6 +715,13 @@ struct FieldOut {
   out.fg = vec4f(0.0);
   ${bgLine}
   ${fgLine}
+  // WEIGHT, applied where the author cannot decline it.
+  //
+  // Alpha only: both field blends multiply the fragment's colour by src-alpha,
+  // so this is the fade for the alpha-over layer and the additive one alike.
+  // Scaling colour as well would fade as the square.
+  out.bg.a *= _rzFieldClock.y;
+  out.fg.a *= _rzFieldClock.y;
   return out;
 }
 `);

package/dist/shaders/passes/grid.d.ts

@@ -2,8 +2,6 @@ import { type CastLayout } from "./particles";
 export declare const GRID_MAX = 1024;
 /** rgba16float, ping-ponged. Two of these is the whole memory cost. */
 export declare const SIM_FORMAT: GPUTextureFormat;
-/** `// @grid 256` — the grid's resolution, in texels per side. */
-export declare function parseGridSize(wgsl: string, max: number): number;
 /** Whether this effect drives a grid at all. */
 export declare function gridEntryPoint(wgsl: string): boolean;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/grid.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAiC7C,eAAO,MAAM,QAAQ,OAAO,CAAA;AAC5B,uEAAuE;AACvE,eAAO,MAAM,UAAU,EAAE,gBAAgC,CAAA;AAEzD,kEAAkE;AAClE,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAM/D;AAED,gDAAgD;AAChD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CA6B1F;AAWD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA6DnF"}
+{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/grid.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAiC7C,eAAO,MAAM,QAAQ,OAAO,CAAA;AAC5B,uEAAuE;AACvE,eAAO,MAAM,UAAU,EAAE,gBAAgC,CAAA;AAEzD,gDAAgD;AAChD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CA6B1F;AAWD;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA6DnF"}

package/dist/shaders/passes/grid.js

@@ -36,15 +36,6 @@ import { clockApi, trailSlotsApi, viewportApi } from "./hosted-api";
 export const GRID_MAX = 1024;
 /** rgba16float, ping-ponged. Two of these is the whole memory cost. */
 export const SIM_FORMAT = "rgba16float";
-/** `// @grid 256` — the grid's resolution, in texels per side. */
-export function parseGridSize(wgsl, max) {
-    const m = /^\s*\/\/\s*@grid\s+(\d+)\s*$/m.exec(wgsl);
-    if (!m)
-        return 0;
-    // Clamped rather than rejected, as the particle count is: an author asking for
-    // 4096 gets the most the engine will give and a scene that still runs.
-    return Math.max(8, Math.min(max, parseInt(m[1], 10)));
-}
 /** Whether this effect drives a grid at all. */
 export function gridEntryPoint(wgsl) {
     return /\bfn\s+gridStep\s*\(/.test(wgsl);

package/dist/shaders/passes/particles.d.ts

@@ -26,12 +26,6 @@ type ParticleSource = {
 };
 /** Bytes per particle. Explicitly padded — see the struct below. */
 export declare const PARTICLE_STRIDE = 48;
-/** `// @particles 4096` — how many live at once. */
-export declare function parseParticleCount(wgsl: string, max: number): number;
-/** `// @bloom` — opt in to the bloom pyramid. Sparks want it; rain does not. */
-export declare function parseParticleBloom(wgsl: string): boolean;
-/** `// @blend additive` — default is straight alpha. */
-export declare function parseParticleBlend(wgsl: string): ParticleBlend;
 /** Does the source define the particle contract? All three are required together. */
 export declare function particleEntryPoints(wgsl: string): {
     init: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"particles.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/particles.ts"],"names":[],"mappings":"AAyBA,sEAAsE;AACtE,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAA;IACb;;mFAE+E;IAC/E,UAAU,EAAE,MAAM,CAAA;IAClB,+EAA+E;IAC/E,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAiCD,qDAAqD;AACrD,KAAK,aAAa,GAAG,OAAO,GAAG,UAAU,CAAA;AAEzC,KAAK,cAAc,GAAG;IACpB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,aAAa,CAAA;IACpB,qEAAqE;IACrE,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,oEAAoE;AACpE,eAAO,MAAM,eAAe,KAAK,CAAA;AAkDjC,oDAAoD;AACpD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAOpE;AAED,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED,wDAAwD;AACxD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAE9D;AAED,qFAAqF;AACrF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAMlG;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA0CxF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAgHvF"}
+{"version":3,"file":"particles.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/particles.ts"],"names":[],"mappings":"AAyBA,sEAAsE;AACtE,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,iFAAiF;IACjF,KAAK,EAAE,MAAM,CAAA;IACb;;mFAE+E;IAC/E,UAAU,EAAE,MAAM,CAAA;IAClB,+EAA+E;IAC/E,KAAK,EAAE,MAAM,EAAE,CAAA;CAChB,CAAA;AAiCD,qDAAqD;AACrD,KAAK,aAAa,GAAG,OAAO,GAAG,UAAU,CAAA;AAEzC,KAAK,cAAc,GAAG;IACpB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,aAAa,CAAA;IACpB,qEAAqE;IACrE,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED,oEAAoE;AACpE,eAAO,MAAM,eAAe,KAAK,CAAA;AAuDjC,qFAAqF;AACrF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAMlG;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CA0CxF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAyHvF"}

package/dist/shaders/passes/particles.js

@@ -51,6 +51,11 @@ struct ParticleU {
   dt: f32,
   count: u32,
   frame: u32,
+  /** The effect's evaluated influence, applied at the one output site below. */
+  weight: f32,
+  _pad0: f32,
+  _pad1: f32,
+  _pad2: f32,
 }
 `;
 /**
@@ -81,24 +86,6 @@ fn rzProject(p: vec3f) -> vec3f {
 }
 fn rzCamPos() -> vec3f { return cam.camPos; }
 `;
-/** `// @particles 4096` — how many live at once. */
-export function parseParticleCount(wgsl, max) {
-    const m = /^\s*\/\/\s*@particles\s+(\d+)\s*$/m.exec(wgsl);
-    if (!m)
-        return 0;
-    // Clamped rather than rejected: an author asking for a million gets the most
-    // the engine will give and a scene that still runs, which is a better failure
-    // than a compile error naming a number they had no way to know.
-    return Math.max(1, Math.min(max, parseInt(m[1], 10)));
-}
-/** `// @bloom` — opt in to the bloom pyramid. Sparks want it; rain does not. */
-export function parseParticleBloom(wgsl) {
-    return /^\s*\/\/\s*@bloom\s*$/m.test(wgsl);
-}
-/** `// @blend additive` — default is straight alpha. */
-export function parseParticleBlend(wgsl) {
-    return /^\s*\/\/\s*@blend\s+additive\s*$/m.test(wgsl) ? "additive" : "alpha";
-}
 /** Does the source define the particle contract? All three are required together. */
 export function particleEntryPoints(wgsl) {
     return {
@@ -256,7 +243,16 @@ ${sceneIdFieldWgsl()}}
 @fragment
 fn fs(in: VSOut) -> FSOut {
   let p = particles[in.id];
-  let c = particleShade(p, in.uv);
+  // WEIGHT IS APPLIED HERE, on the author's result, before anything reads it.
+  //
+  // Alpha alone, and that is not a shortcut: this fragment is premultiplied
+  // two lines down, so scaling alpha scales the colour with it — and where the
+  // target blends additively the premultiply is what carries the fade. One
+  // multiply is the correct fade for both particle targets.
+  var c = particleShade(p, in.uv);
+  c.a *= pu.weight;
+  // Weight 0 therefore discards every fragment, so an effect faded out costs
+  // nothing past the vertex stage even on the frame the draw is still issued.
   if (c.a <= 0.0) { discard; }
   var out: FSOut;
   // PREMULTIPLIED: the scene's colour target blends with srcFactor \"one\", so a

package/dist/shaders/passes/scene-contract.d.ts

@@ -61,7 +61,7 @@ type SceneRenderClass =
  | "outline"
 /** Particles and ribbons in their default, non-additive mode. */
  | "particle"
-/** Particles declaring `// @blend additive` — LIGHT rather than matter, so
+/** Particles declaring `#blend additive` — LIGHT rather than matter, so
  *  colour sums and alpha is left alone: a glow must not claim coverage it
  *  never occluded. The aux target sums with it, which is what lets an
  *  additive effect reach the bloom gate at all. */

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

@@ -1 +1 @@
-{"version":3,"file":"trails.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/trails.ts"],"names":[],"mappings":"AAyBA,KAAK,WAAW,GAAG;IACjB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAA;IACb;oEACgE;IAChE,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,8DAA8D;IAC9D,KAAK,EAAE,OAAO,GAAG,UAAU,CAAA;IAC3B,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAKjF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE;IACJ,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,EAAE,CAAA;IACf;;;;kFAI8E;IAC9E,SAAS,EAAE,OAAO,CAAA;CACnB,GACA,MAAM,CAwUR"}
+{"version":3,"file":"trails.d.ts","sourceRoot":"","sources":["../../../src/shaders/passes/trails.ts"],"names":[],"mappings":"AAyBA,KAAK,WAAW,GAAG;IACjB,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAA;IACb;oEACgE;IAChE,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,8DAA8D;IAC9D,KAAK,EAAE,OAAO,GAAG,UAAU,CAAA;IAC3B,KAAK,EAAE,OAAO,CAAA;CACf,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAA;AAEnC,6EAA6E;AAC7E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAKjF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE;IACJ,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,EAAE,CAAA;IACf;;;;kFAI8E;IAC9E,SAAS,EAAE,OAAO,CAAA;CACnB,GACA,MAAM,CA6UR"}

package/dist/shaders/passes/trails.js

@@ -83,7 +83,8 @@ struct TrailU {
   // model is added or removed, and recompiling every trail shader for that
   // would be absurd.
   subjects: f32,
-  _pad1: f32,
+  /** The effect's evaluated influence, applied at the one output site below. */
+  weight: f32,
   _pad2: f32,
 }
 @group(0) @binding(0) var<storage, read> _rzCast: array<vec4f>;
@@ -353,15 +354,19 @@ fn fs(in: VSOut) -> TrailFSOut {
   // hardware does it, correctly and for free, and the reversed-Z trap that
   // needed its own regression test goes with it.
   let c = trailShade(in.uv.x, in.uv.y, in.age, in.weight, i32(in.slot));
-  if (c.a <= 0.0) { discard; }
+  // THE EFFECT'S weight, not the ribbon's — in.weight above is the strand's
+  // own taper and belongs to the author. This one is the scheduler's, and it
+  // scales alpha because the target below multiplies colour by src-alpha.
+  let a = c.a * tu.weight;
+  if (a <= 0.0) { discard; }
   var o: TrailFSOut;
   // STRAIGHT colour into an ADDITIVE target, which reverses the old MAX rule
   // deliberately: max existed so parallel strands could not double into bright
   // dashes on a layer composited after tone mapping. In HDR before bloom,
   // overlapping light SHOULD sum — that is what neon does — and the tone
   // mapper is what keeps the sum from clipping.
-  o.color = vec4f(c.rgb, c.a);
-  o.aux = vec4f(${src.bloom ? "1.0" : "0.0"}, 1.0, 0.0, c.a);
+  o.color = vec4f(c.rgb, a);
+  o.aux = vec4f(${src.bloom ? "1.0" : "0.0"}, 1.0, 0.0, a);
 ${sceneIdPadWgsl("o")}  return o;
 }
 `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reze-engine",
-  "version": "0.51.0",
+  "version": "0.53.0",
   "description": "A lightweight WebGPU engine for real-time 3D MMD/PMX model rendering",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -41,4 +41,4 @@
     "@types/node": "^20",
     "typescript": "^5"
   }
-}
+}

package/src/effect-schedule.ts

@@ -0,0 +1,120 @@
+/**
+ * WHEN an effect is on, and how much of it.
+ *
+ * The engine evaluates this, not the app, and that is not an arbitrary split.
+ * Everything time-driven that lives above the engine has to be ticked by every
+ * loop that renders — playback, offline export, a warm-up pass — and the export
+ * loop already carries a scar about it: a score-driven effect once exported a
+ * still keyboard while the rest of the scene animated, because that loop
+ * advanced the audio clock and forgot the score's. A schedule evaluated where
+ * the scene clock advances cannot be forgotten by anyone.
+ *
+ * It is also where the three references put it. Unity's Timeline evaluates clip
+ * ease in its playable graph, Unreal's Sequencer evaluates section easing, and
+ * Blender's NLA evaluates strip influence — in all three the editor only edits
+ * the data. This is that.
+ *
+ * SECONDS, because that is the engine's clock. The document above works in
+ * MMD's 30fps frames and converts on the way in; nothing here knows the render
+ * rate, which is what lets a 60Hz preview and a 30 or 60fps export agree about
+ * which beat an effect lands on.
+ *
+ * The model is Blender's NLA strip, minus what needs a strip STACK: no
+ * extrapolation modes (outside a window is off, always), no auto-blend (it
+ * derives from neighbouring strips, and effects have a lane each), no repeat or
+ * scale (an author who wants a cycle can wrap their own clock).
+ *
+ * PURE, in its own file, for the reason param-track.ts is: everything else in
+ * this feature needs a GPU and this needs one number, so the edge cases can be
+ * tested exhaustively. They are where it goes wrong, and a wrong one is a beat
+ * missed in a video someone posts.
+ */
+
+/** One strip on an effect's LANE — and a lane holds as many as you place.
+ *  Seconds throughout. */
+export type EffectWindow = {
+  /** When it comes alive, and where its own clock reads zero. */
+  start: number
+  /** When it stops. Omitted = it runs to the end of the scene. */
+  end?: number
+  /** Ramp up over this long from `start`. Omitted or 0 is a HARD CUT, which is
+   *  the right answer for a flash and the wrong one for a glow. */
+  blendIn?: number
+  /** Ramp down over this long back from `end`. Needs an `end` to measure from:
+   *  an effect with no end has nothing to ramp toward. */
+  blendOut?: number
+}
+
+/** What an effect is doing at one instant: a weight for its mounts, and where
+ *  its own clock has reached. */
+export type EffectState = { weight: number; time: number }
+
+/** Off, and stopped at its own beginning. */
+const SILENT: EffectState = { weight: 0, time: 0 }
+
+const clamp01 = (n: number) => (n < 0 ? 0 : n > 1 ? 1 : Number.isFinite(n) ? n : 0)
+
+/**
+ * One effect's state at one moment of the scene.
+ *
+ * `influence` is the level it reaches INSIDE the window — Blender's word and
+ * Blender's meaning. The blends ramp toward it rather than toward 1, so a
+ * permanently half-strength effect and a scheduled one are the same dial
+ * instead of two that can disagree.
+ *
+ * LINEAR ramps, matching the NLA's. A curve is a better default for light and a
+ * worse one for everything else, and there is no control to shape it with — a
+ * curve nobody asked for is worse than a plain one. If eased blends are ever
+ * wanted they belong as a property ON the window, which is the same call
+ * param-track.ts made about bezier keys.
+ */
+export function effectState(
+  windows: readonly EffectWindow[] | null,
+  influence: number,
+  sceneTime: number,
+): EffectState {
+  const level = clamp01(influence)
+  // UNSCHEDULED RUNS WITH THE SCENE, on the scene's own clock — so an effect
+  // nobody has scheduled behaves exactly as it did before windows existed.
+  if (!windows || windows.length === 0) return { weight: level, time: sceneTime }
+
+  // A LANE HOLDS MANY STRIPS, which is what lets one effect fire more than
+  // once. Each entry restarts the effect's own clock at its own start, so a hit
+  // placed at bar 8 and again at bar 24 plays its opening both times rather
+  // than resuming halfway through itself.
+  //
+  // The LATEST start that contains the time wins. Strips on one lane are not
+  // meant to overlap — that is the rule every NLE enforces within a track, and
+  // 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
+  }
+  if (!window) return SILENT
+
+  const { start, end } = window
+  // The picker above already rejected an empty strip (an end at or before the
+  // start, reachable by dragging one edge past the other) and anything the
+  // time is outside of, so from here the strip is live and has a real length.
+
+  // ITS OWN CLOCK, from its entry. This is the reason the window owns the clock
+  // rather than being a visibility flag beside it: an effect entering at bar 33
+  // should play its own opening, not join the scene four minutes in.
+  const time = sceneTime - start
+
+  let ramp = 1
+  const fadeIn = window.blendIn ?? 0
+  if (fadeIn > 0) ramp = Math.min(ramp, time / fadeIn)
+  const fadeOut = end !== undefined ? (window.blendOut ?? 0) : 0
+  if (fadeOut > 0) ramp = Math.min(ramp, (end! - sceneTime) / fadeOut)
+
+  // The MINIMUM of the two ramps, so blends that overlap degrade instead of
+  // break: set both longer than the strip and it becomes a triangle — dimmer
+  // than asked for, still smooth, never out of range. Multiplying them would
+  // dip toward zero in the middle of a short strip, which is not a fade.
+  return { weight: level * clamp01(ramp), time }
+}