reze-engine 0.50.12 → 0.52.0

package/dist/graph/presets/unlit.d.ts

@@ -0,0 +1,3 @@
+import type { ShaderGraph } from "../schema";
+export declare const UNLIT_GRAPH: ShaderGraph;
+//# sourceMappingURL=unlit.d.ts.map

package/dist/graph/presets/unlit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unlit.d.ts","sourceRoot":"","sources":["../../../src/graph/presets/unlit.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,eAAO,MAAM,WAAW,EAAE,WAmBzB,CAAA"}

package/dist/graph/presets/unlit.js

@@ -0,0 +1,34 @@
+// Unlit — the texture, at its own brightness, and nothing else.
+//
+// What FOOTAGE needs. A media plane carries pixels somebody already finished
+// somewhere else: a gradient painted in Photoshop, a title card, a rendered
+// element. Shading it is not a stylistic choice but a mistake — the scene's sun
+// would dim one side of a card that has no side, and the world colour would
+// tint artwork whose colour is the point. Blender's answer is the same one:
+// wire the image straight into an Emission shader and let it out at the value
+// it was authored at.
+//
+// Emission rather than Principled with roughness 1: emission is radiance, so it
+// leaves the light loop entirely instead of being an unusually flat surface
+// inside it. That is also what lets a card sit in front of a lamp without
+// picking up its highlight.
+export const UNLIT_GRAPH = {
+    version: 1,
+    name: "Unlit",
+    tags: ["unlit", "plane"],
+    nodes: [
+        { id: "tex", type: "texture" },
+        // The PMX material colour still multiplies in, so a plane can be tinted or
+        // faded through the same dial every other material uses rather than needing
+        // one of its own.
+        { id: "mat", type: "material_diffuse" },
+        { id: "base", type: "mix/multiply", inputs: { fac: 1.0 } },
+        { id: "emit", type: "emission", inputs: { strength: 1.0 } },
+    ],
+    links: [
+        { from: { node: "tex", socket: "color" }, to: { node: "base", socket: "a" } },
+        { from: { node: "mat", socket: "color" }, to: { node: "base", socket: "b" } },
+        { from: { node: "base", socket: "color" }, to: { node: "emit", socket: "color" } },
+    ],
+    output: { node: "emit", socket: "color" },
+};

package/dist/index.d.ts

@@ -4,6 +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 { compileGraph, validateGraph, assignStyleSlots, type CompileOptions, type CompileResult, type StyleSlot, } from "./graph/compile";
 export type { ShaderGraph, GraphNode, GraphLink, ExposedParam, SocketValue, Diagnostic, } from "./graph/schema";
 export { NODE_REGISTRY, type NodeSpec, type SockT } from "./graph/registry";
@@ -18,6 +19,8 @@ export { BODY_GRAPH } from "./graph/presets/body";
 export { STOCKINGS_GRAPH } from "./graph/presets/stockings";
 export { EYE_GRAPH } from "./graph/presets/eye";
 export { FACE_GRAPH } from "./graph/presets/face";
+export { UNLIT_GRAPH } from "./graph/presets/unlit";
+export { parseDirectives, stripDirectives, DIRECTIVE_LINE, DIRECTIVE_NOTE, type EffectDirectives, type EffectParamDecl, } from "./shaders/directives";
 export { Model, MATERIAL_MORPH_MULTIPLY, MATERIAL_MORPH_ADD, type ClipEventInfo, type RootMotionProfile, type Morph, type Morphing, type BoneMorphOffset, type MaterialMorphOffset, type UvMorphOffset, } from "./model";
 export { Vec3, Quat, Mat4, easeInOut, type EulerOrder } from "./math";
 export type { AnimationClip, AnimationPlayOptions, AnimationProgress, BlendEntry, BoneKeyframe, IkKeyframe, MorphKeyframe, BoneInterpolation, ControlPoint, } from "./animation";

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

@@ -10,6 +10,10 @@ export { LYRIC_ATLAS_MAX_H, LYRIC_ATLAS_MAX_W, parseLRC } from "./shaders/lyrics
 // wants to draw a track, or scrub one, should read the same curve the engine
 // plays rather than reimplementing it a second time.
 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 { compileGraph, validateGraph, assignStyleSlots, } from "./graph/compile";
 export { NODE_REGISTRY } from "./graph/registry";
 export { RENDER_CLASSES } from "./graph/render-class";
@@ -22,6 +26,11 @@ export { BODY_GRAPH } from "./graph/presets/body";
 export { STOCKINGS_GRAPH } from "./graph/presets/stockings";
 export { EYE_GRAPH } from "./graph/presets/eye";
 export { FACE_GRAPH } from "./graph/presets/face";
+export { UNLIT_GRAPH } from "./graph/presets/unlit";
+// What an effect declares, and the source with those lines blanked. Exported
+// because a host builds parameter controls from the declarations and needs the
+// same answer the engine got — two parsers is how they disagree.
+export { parseDirectives, stripDirectives, DIRECTIVE_LINE, DIRECTIVE_NOTE, } from "./shaders/directives";
 export { Model, MATERIAL_MORPH_MULTIPLY, MATERIAL_MORPH_ADD, } from "./model";
 export { Vec3, Quat, Mat4, easeInOut } from "./math";
 export { LocomotionController, } from "./locomotion";

package/dist/shaders/anchor-table.d.ts

@@ -35,7 +35,7 @@ export declare function buildAnchorTable(requests: AnchorRequest[][], max: numbe
  * TRAILED anchor, so its instance index counts 0,1,2… over trailed anchors only
  * — while the cast buffer is addressed by DECLARATION slot. Those coincide
  * exactly when every anchor is trailed, which is true of all 14 library effects
- * and is why this stayed latent: declare `@anchor 頭` then `@anchor 左手首 trail`
+ * and is why this stayed latent: declare `#anchor 頭` then `#anchor 左手首 trail`
  * and ribbon 0 asked for the trail of 頭, which has none, so the ribbon silently
  * did not draw.
  *

package/dist/shaders/anchor-table.js

@@ -73,7 +73,7 @@ export function buildAnchorTable(requests, max) {
  * TRAILED anchor, so its instance index counts 0,1,2… over trailed anchors only
  * — while the cast buffer is addressed by DECLARATION slot. Those coincide
  * exactly when every anchor is trailed, which is true of all 14 library effects
- * and is why this stayed latent: declare `@anchor 頭` then `@anchor 左手首 trail`
+ * and is why this stayed latent: declare `#anchor 頭` then `#anchor 左手首 trail`
  * and ribbon 0 asked for the trail of 頭, which has none, so the ribbon silently
  * did not draw.
  *
@@ -108,7 +108,7 @@ ${cases}
  * folds away.
  */
 export function anchorAliasWgsl(alias) {
-    // NO @anchor AT ALL. Every slot is unmapped, and rzAnchor() must report
+    // NO #anchor AT ALL. Every slot is unmapped, and rzAnchor() must report
     // .valid false for all of them.
     //
     // This used to fall through to the identity branch below — `[].every()` is
@@ -120,7 +120,7 @@ export function anchorAliasWgsl(alias) {
     // reading.
     if (alias.length === 0) {
         return `
-/** No @anchor in this effect: every slot is unmapped, so rzAnchor() is invalid
+/** No #anchor in this effect: every slot is unmapped, so rzAnchor() is invalid
  *  rather than reading whichever bone another effect declared first. */
 fn _rzSlot(local: i32) -> i32 { return -1; }
 `;

package/dist/shaders/cast-api.d.ts

@@ -1,2 +1,2 @@
-export declare const CAST_API = "\nconst RZ_SUBJECTS: i32 = 4;\nconst RZ_SAMPLES: i32 = 128;\n/** The anchor ADDRESS SPACE \u2014 how many an effect may declare, not how many it\n *  did. RZ_TRAIL_SLOTS is the per-effect number and is not this one; the two\n *  being one number was the old trail bug. */\nconst RZ_MAX_ANCHORS: i32 = 16;\nconst RZ_TRAIL_SAMPLES: i32 = 128;\n\nstruct RzSubject {\n  /** On the FLOOR, under the body \u2014 where a ring or a magic circle belongs. */\n  root: vec3f,\n  /** At the hips, the middle of the body \u2014 where an aura belongs. */\n  center: vec3f,\n  /** Bounding sphere: xyz centre, w radius. Deliberately generous \u2014 cull with it. */\n  bounds: vec4f,\n  /**\n   * How much of this character is still THERE: 1 whole, 0 gone.\n   *\n   * What setModelDissolve last set on them, which the material pass has already\n   * acted on by the time an effect runs \u2014 so an effect drawing what LEAVES a\n   * dissolving body (sparks, ash, a ghost) reads the same number the body was\n   * taken apart with, rather than keeping a clock of its own and hoping the two\n   * agree. 1 on a scene that never dissolves anybody.\n   */\n  dissolve: f32,\n  /** False past the end of the cast, and every field is then zero. */\n  valid: bool,\n}\n\nstruct RzAnchor {\n  pos: vec3f,\n  /** World units per second, from the previous frame. Direction for a trail,\n   *  magnitude for anything that should react to how hard someone is moving. */\n  vel: vec3f,\n  /** The bone's forward axis \u2014 which way a foot points, where a head looks. */\n  fwd: vec3f,\n  /** False when this rig has no such bone. Check it: the alternative is drawing\n   *  a hand effect at the world origin on every model that spells it differently. */\n  valid: bool,\n}\n\n/** Which model this is, stable across a scene \u2014 for per-subject variation. */\nfn rzSubjectId(i: i32) -> u32 {\n  if (i < 0 || i >= rzSubjectCount()) { return 0u; }\n  return u32(_rzCast[i * 3 + 1].w);\n}\n\nfn rzSubject(i: i32) -> RzSubject {\n  var s: RzSubject;\n  s.valid = i >= 0 && i < rzSubjectCount();\n  if (!s.valid) { return s; }\n  let b = i * 3;\n  s.root = _rzCast[b].xyz;\n  s.dissolve = _rzCast[b].w;\n  s.center = _rzCast[b + 1].xyz;\n  s.bounds = _rzCast[b + 2];\n  return s;\n}\n\n/**\n * Where a named bone is, this frame.\n *\n * The slot is the author's own: the Nth @anchor in their file, in the order\n * they wrote them. _rzSlot turns that into the scene's address, which is what\n * keeps two effects that both anchor to a wrist from reading each other's.\n */\nfn rzAnchor(subject: i32, slot: i32) -> RzAnchor {\n  var a: RzAnchor;\n  a.valid = false;\n  let g = _rzSlot(slot);\n  if (subject < 0 || subject >= rzSubjectCount() || g < 0 || g >= RZ_MAX_ANCHORS) { return a; }\n  let b = 12 + (g * 4 + subject) * 3;\n  a.valid = _rzCast[b].w > 0.5;\n  a.pos = _rzCast[b].xyz;\n  a.vel = _rzCast[b + 1].xyz;\n  a.fwd = _rzCast[b + 2].xyz;\n  return a;\n}\n\n/**\n * How many samples of a path are recorded \u2014 0 for an anchor that asked for no\n * trail, and for one that has not moved yet.\n *\n * Bounded by the anchor cap, NOT by how many anchors asked for a trail. Those\n * are different index spaces: storage is addressed by anchor slot, so an\n * untrailed @anchor followed by a trailed one put the trail at index 1 with a\n * bound of 1 and rzTrail returned zero \u2014 a ribbon that silently did not draw.\n */\nfn rzTrailCount(subject: i32, slot: i32) -> i32 {\n  let g = _rzSlot(slot);\n  if (subject < 0 || subject >= rzSubjectCount() || g < 0 || g >= RZ_MAX_ANCHORS) { return 0; }\n  return i32(_rzCast[12 + (g * 4 + subject) * 3 + 2].w);\n}\n\n/** Sample i of a path: xyz where it was, w how many seconds ago. i = 0 is now. */\nfn rzTrail(subject: i32, slot: i32, i: i32) -> vec4f {\n  let n = rzTrailCount(subject, slot);\n  if (i < 0 || i >= n) { return vec4f(0.0); }\n  let base = 204 + (_rzSlot(slot) * 4 + subject) * RZ_TRAIL_SAMPLES;\n  return _rzCast[base + i];\n}\n";
+export declare const CAST_API = "\nconst RZ_SUBJECTS: i32 = 4;\nconst RZ_SAMPLES: i32 = 128;\n/** The anchor ADDRESS SPACE \u2014 how many an effect may declare, not how many it\n *  did. RZ_TRAIL_SLOTS is the per-effect number and is not this one; the two\n *  being one number was the old trail bug. */\nconst RZ_MAX_ANCHORS: i32 = 16;\nconst RZ_TRAIL_SAMPLES: i32 = 128;\n\nstruct RzSubject {\n  /** On the FLOOR, under the body \u2014 where a ring or a magic circle belongs. */\n  root: vec3f,\n  /** At the hips, the middle of the body \u2014 where an aura belongs. */\n  center: vec3f,\n  /** Bounding sphere: xyz centre, w radius. Deliberately generous \u2014 cull with it. */\n  bounds: vec4f,\n  /**\n   * How much of this character is still THERE: 1 whole, 0 gone.\n   *\n   * What setModelDissolve last set on them, which the material pass has already\n   * acted on by the time an effect runs \u2014 so an effect drawing what LEAVES a\n   * dissolving body (sparks, ash, a ghost) reads the same number the body was\n   * taken apart with, rather than keeping a clock of its own and hoping the two\n   * agree. 1 on a scene that never dissolves anybody.\n   */\n  dissolve: f32,\n  /** False past the end of the cast, and every field is then zero. */\n  valid: bool,\n}\n\nstruct RzAnchor {\n  pos: vec3f,\n  /** World units per second, from the previous frame. Direction for a trail,\n   *  magnitude for anything that should react to how hard someone is moving. */\n  vel: vec3f,\n  /** The bone's forward axis \u2014 which way a foot points, where a head looks. */\n  fwd: vec3f,\n  /** False when this rig has no such bone. Check it: the alternative is drawing\n   *  a hand effect at the world origin on every model that spells it differently. */\n  valid: bool,\n}\n\n/** Which model this is, stable across a scene \u2014 for per-subject variation. */\nfn rzSubjectId(i: i32) -> u32 {\n  if (i < 0 || i >= rzSubjectCount()) { return 0u; }\n  return u32(_rzCast[i * 3 + 1].w);\n}\n\nfn rzSubject(i: i32) -> RzSubject {\n  var s: RzSubject;\n  s.valid = i >= 0 && i < rzSubjectCount();\n  if (!s.valid) { return s; }\n  let b = i * 3;\n  s.root = _rzCast[b].xyz;\n  s.dissolve = _rzCast[b].w;\n  s.center = _rzCast[b + 1].xyz;\n  s.bounds = _rzCast[b + 2];\n  return s;\n}\n\n/**\n * Where a named bone is, this frame.\n *\n * The slot is the author's own: the Nth #anchor in their file, in the order\n * they wrote them. _rzSlot turns that into the scene's address, which is what\n * keeps two effects that both anchor to a wrist from reading each other's.\n */\nfn rzAnchor(subject: i32, slot: i32) -> RzAnchor {\n  var a: RzAnchor;\n  a.valid = false;\n  let g = _rzSlot(slot);\n  if (subject < 0 || subject >= rzSubjectCount() || g < 0 || g >= RZ_MAX_ANCHORS) { return a; }\n  let b = 12 + (g * 4 + subject) * 3;\n  a.valid = _rzCast[b].w > 0.5;\n  a.pos = _rzCast[b].xyz;\n  a.vel = _rzCast[b + 1].xyz;\n  a.fwd = _rzCast[b + 2].xyz;\n  return a;\n}\n\n/**\n * How many samples of a path are recorded \u2014 0 for an anchor that asked for no\n * trail, and for one that has not moved yet.\n *\n * Bounded by the anchor cap, NOT by how many anchors asked for a trail. Those\n * are different index spaces: storage is addressed by anchor slot, so an\n * untrailed #anchor followed by a trailed one put the trail at index 1 with a\n * bound of 1 and rzTrail returned zero \u2014 a ribbon that silently did not draw.\n */\nfn rzTrailCount(subject: i32, slot: i32) -> i32 {\n  let g = _rzSlot(slot);\n  if (subject < 0 || subject >= rzSubjectCount() || g < 0 || g >= RZ_MAX_ANCHORS) { return 0; }\n  return i32(_rzCast[12 + (g * 4 + subject) * 3 + 2].w);\n}\n\n/** Sample i of a path: xyz where it was, w how many seconds ago. i = 0 is now. */\nfn rzTrail(subject: i32, slot: i32, i: i32) -> vec4f {\n  let n = rzTrailCount(subject, slot);\n  if (i < 0 || i >= n) { return vec4f(0.0); }\n  let base = 204 + (_rzSlot(slot) * 4 + subject) * RZ_TRAIL_SAMPLES;\n  return _rzCast[base + i];\n}\n";
 //# sourceMappingURL=cast-api.d.ts.map

package/dist/shaders/cast-api.js

@@ -90,7 +90,7 @@ fn rzSubject(i: i32) -> RzSubject {
 /**
  * Where a named bone is, this frame.
  *
- * The slot is the author's own: the Nth @anchor in their file, in the order
+ * The slot is the author's own: the Nth #anchor in their file, in the order
  * they wrote them. _rzSlot turns that into the scene's address, which is what
  * keeps two effects that both anchor to a wrist from reading each other's.
  */
@@ -113,7 +113,7 @@ fn rzAnchor(subject: i32, slot: i32) -> RzAnchor {
  *
  * Bounded by the anchor cap, NOT by how many anchors asked for a trail. Those
  * are different index spaces: storage is addressed by anchor slot, so an
- * untrailed @anchor followed by a trailed one put the trail at index 1 with a
+ * untrailed #anchor followed by a trailed one put the trail at index 1 with a
  * bound of 1 and rzTrail returned zero — a ribbon that silently did not draw.
  */
 fn rzTrailCount(subject: i32, slot: i32) -> i32 {

package/dist/shaders/directives.d.ts

@@ -0,0 +1,73 @@
+/** A knob an effect exposes, for a host to build a control from. */
+export type EffectParamDecl = {
+    name: string;
+    kind: "float" | "color" | "vec3";
+    /** Numbers for float/vec3; `#rrggbb` for a colour, which the host converts. */
+    value: number | [number, number, number] | string;
+    /** float only, and only when the author gave a range. */
+    min?: number;
+    max?: number;
+};
+export type EffectDirectives = {
+    /** Bones this effect follows, in declaration order — slot 0 is the first. */
+    anchors: {
+        bone: string;
+        trail: boolean;
+    }[];
+    params: EffectParamDecl[];
+    /** Field layer: 0 full, 1 half. Full unless `#halfres` says otherwise. */
+    fieldLayer: 0 | 1;
+    /** The field layer composites additively rather than over. */
+    additiveLayer: boolean;
+    /** Particle blend, which is a different axis from the field layer's. */
+    particleBlend: "alpha" | "additive";
+    particles: number;
+    lights: number;
+    grid: number;
+    bloom: boolean;
+    /** This effect takes the cast apart — the host reads the timing. */
+    dissolve: boolean;
+    /**
+     * How long ONE firing of this effect lasts, in seconds. 0 = undeclared.
+     *
+     * An effect is one of two things, and only its author knows which. A HIT has
+     * an arc — a circle flares, peaks and is gone — and its length is a fact
+     * about it, the way a video clip's length is a fact about the file. An
+     * AMBIENT effect (stars, fog, rain) has no length at all; it is a condition
+     * the scene is in.
+     *
+     * Declaring it is what lets a host place the effect instead of making someone
+     * construct it: dropping a hit on the timeline gives a strip already the
+     * right size, and an effect that declares nothing spans the scene. Every
+     * timeline works this way — a clip arrives at its own duration.
+     */
+    duration: number;
+};
+/** A line that declares something, and what it declares. Exported because an
+ *  editor highlights by the same rule the parser reads by — a highlighter with
+ *  its own idea of what counts is one that paints a line as configuration that
+ *  the engine then ignores. */
+export declare const DIRECTIVE_LINE: RegExp;
+/**
+ * Split a directive's arguments from a trailing note.
+ *
+ * `#anchor 左手首 trail — her sword hand` is one line doing two jobs, and
+ * refusing it is what made the old spelling dangerous: the note is the natural
+ * thing to write, so it has to be the accepted thing to write.
+ */
+export declare const DIRECTIVE_NOTE: RegExp;
+export type DirectiveResult = {
+    directives: EffectDirectives;
+    errors: string[];
+};
+/** Read every declaration in a source. Errors name the line, one-based. */
+export declare function parseDirectives(wgsl: string): DirectiveResult;
+/**
+ * The source as the compiler should see it: every directive line blanked.
+ *
+ * Blanked rather than removed so line numbers survive — a diagnostic points at
+ * the line the author is looking at, which is the whole reason the engine
+ * rebases them in the first place.
+ */
+export declare function stripDirectives(wgsl: string): string;
+//# sourceMappingURL=directives.d.ts.map

package/dist/shaders/directives.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"directives.d.ts","sourceRoot":"","sources":["../../src/shaders/directives.ts"],"names":[],"mappings":"AA8BA,oEAAoE;AACpE,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,CAAA;IAChC,+EAA+E;IAC/E,KAAK,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,CAAA;IACjD,yDAAyD;IACzD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,6EAA6E;IAC7E,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;IAC3C,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,0EAA0E;IAC1E,UAAU,EAAE,CAAC,GAAG,CAAC,CAAA;IACjB,8DAA8D;IAC9D,aAAa,EAAE,OAAO,CAAA;IACtB,wEAAwE;IACxE,aAAa,EAAE,OAAO,GAAG,UAAU,CAAA;IACnC,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,OAAO,CAAA;IACd,oEAAoE;IACpE,QAAQ,EAAE,OAAO,CAAA;IACjB;;;;;;;;;;;;;OAaG;IACH,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAiBD;;;+BAG+B;AAC/B,eAAO,MAAM,cAAc,QAAmC,CAAA;AAG9D;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,QAA8B,CAAA;AAmBzD,MAAM,MAAM,eAAe,GAAG;IAAE,UAAU,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAAA;AAEhF,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAqJ7D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKpD"}

package/dist/shaders/directives.js

@@ -0,0 +1,238 @@
+// What an effect DECLARES about itself — parsed once, in one place.
+//
+// An effect file is WGSL plus a handful of lines that configure how the engine
+// mounts it: which resolution it draws at, how it blends, which bones it
+// follows, what knobs it exposes. Those lines are not comments. They decide
+// whether the file gets what it asks for, and the failure they used to have was
+// the worst kind available.
+//
+// WHY `#` AND NOT `// @`. The old spelling put directives inside comments,
+// which meant two things. Authors read them as comments and wrote notes on the
+// same line — every parser was anchored to end-of-line, so the note silently
+// unmade the directive, and three shipped effects ran at half the resolution
+// their own first line said they needed while a fourth quietly stopped being
+// additive. Nothing failed and nothing was reported, because nothing had been
+// declared to fail. And it could not be fixed by being strict: a comment
+// beginning with `@` is a legitimate thing to write, so an unrecognised one can
+// only ever be a warning.
+//
+// WGSL has no `#` syntax of its own. A line starting with `#` is therefore
+// unambiguously ours, an unknown one is an ERROR rather than a guess, and the
+// sigil is the one every shader author already reads as "directive" from
+// `#pragma`. The cost usually quoted for this — that the file stops being valid
+// WGSL — is not a cost we pay: an effect calls rzSubject, rzTrail and reads
+// `params`, none of which exist until the engine splices them in, so these
+// files have never compiled anywhere else.
+//
+// STRIPPED BY BLANKING, not by deleting: the compiler sees an empty line where
+// each directive was, so every diagnostic's line number still points at the
+// line the author is looking at.
+/** Every directive, with how many words follow it. `rest` means free-form. */
+const SPEC = {
+    anchor: "rest",
+    param: "rest",
+    halfres: 0,
+    layer: 1,
+    blend: 1,
+    particles: 1,
+    lights: 1,
+    grid: 1,
+    bloom: 0,
+    dissolve: 0,
+    duration: 1,
+};
+/** A line that declares something, and what it declares. Exported because an
+ *  editor highlights by the same rule the parser reads by — a highlighter with
+ *  its own idea of what counts is one that paints a line as configuration that
+ *  the engine then ignores. */
+export const DIRECTIVE_LINE = /^[ \t]*#([a-zA-Z]+)[ \t]*(.*)$/;
+const LINE = DIRECTIVE_LINE;
+/**
+ * Split a directive's arguments from a trailing note.
+ *
+ * `#anchor 左手首 trail — her sword hand` is one line doing two jobs, and
+ * refusing it is what made the old spelling dangerous: the note is the natural
+ * thing to write, so it has to be the accepted thing to write.
+ */
+export const DIRECTIVE_NOTE = /(?:^|\s)(?:—|--|\/\/|#)\s/;
+function argsOf(rest) {
+    // `^` as well as `\s`: the tag's own trailing space is eaten by LINE, so a
+    // note can begin at the very first character — which is what
+    // `#halfres — glyph edges` looks like by the time it reaches here.
+    const note = rest.search(DIRECTIVE_NOTE);
+    return (note >= 0 ? rest.slice(0, note) : rest).trim().split(/\s+/).filter(Boolean);
+}
+/** A number, or null. Empty is NULL, not zero: `Number("")` is 0, so a missing
+ *  default silently became a real one — an author who wrote `#param float D`
+ *  and meant to finish the line got a knob quietly pinned at zero. */
+const num = (s) => {
+    if (!s || !s.trim())
+        return null;
+    const v = Number(s);
+    return Number.isFinite(v) ? v : null;
+};
+/** Read every declaration in a source. Errors name the line, one-based. */
+export function parseDirectives(wgsl) {
+    const d = {
+        anchors: [],
+        params: [],
+        // FULL unless asked otherwise — the default is what an author gets for
+        // saying nothing, so it has to be the answer that cannot silently ruin an
+        // effect. `#halfres` is a claim about being cheap, which is a claim only
+        // the author can make.
+        fieldLayer: 0,
+        additiveLayer: false,
+        particleBlend: "alpha",
+        particles: 0,
+        lights: 0,
+        grid: 0,
+        bloom: false,
+        dissolve: false,
+        duration: 0,
+    };
+    const errors = [];
+    const lines = wgsl.split("\n");
+    lines.forEach((line, i) => {
+        const m = LINE.exec(line);
+        if (!m)
+            return;
+        const at = `line ${i + 1}`;
+        const tag = m[1].toLowerCase();
+        if (!(tag in SPEC)) {
+            errors.push(`${at}: #${m[1]} is not a directive. Known: ${Object.keys(SPEC).map((k) => `#${k}`).join(", ")}`);
+            return;
+        }
+        const args = argsOf(m[2]);
+        const want = SPEC[tag];
+        if (want !== "rest" && args.length !== want) {
+            errors.push(`${at}: #${tag} takes ${want} argument${want === 1 ? "" : "s"}, got ${args.length}`);
+            return;
+        }
+        switch (tag) {
+            case "anchor": {
+                if (args.length < 1 || args.length > 2 || (args[1] && args[1] !== "trail")) {
+                    errors.push(`${at}: #anchor takes a bone name and optionally the word "trail"`);
+                    return;
+                }
+                d.anchors.push({ bone: args[0], trail: args[1] === "trail" });
+                return;
+            }
+            case "param": {
+                const [kind, name, ...rest] = args;
+                if (!name || !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+                    errors.push(`${at}: #param needs a WGSL identifier for a name`);
+                    return;
+                }
+                if (kind === "color") {
+                    if (!/^#[0-9a-fA-F]{6}$/.test(rest[0] ?? "")) {
+                        errors.push(`${at}: #param color ${name} needs a default like #3b82f6`);
+                        return;
+                    }
+                    d.params.push({ name, kind: "color", value: rest[0] });
+                    return;
+                }
+                if (kind === "vec3") {
+                    const v = rest.slice(0, 3).map(num);
+                    if (v.length !== 3 || v.some((x) => x === null)) {
+                        errors.push(`${at}: #param vec3 ${name} needs three numbers`);
+                        return;
+                    }
+                    d.params.push({ name, kind: "vec3", value: v });
+                    return;
+                }
+                if (kind === "float") {
+                    const v = num(rest[0]);
+                    if (v === null) {
+                        errors.push(`${at}: #param float ${name} needs a default`);
+                        return;
+                    }
+                    const lo = num(rest[1]);
+                    const hi = num(rest[2]);
+                    // A range is optional and all-or-nothing: half of one is a slider
+                    // with an end nobody chose.
+                    if ((rest[1] !== undefined) !== (rest[2] !== undefined) || (rest[1] !== undefined && (lo === null || hi === null))) {
+                        errors.push(`${at}: #param float ${name} takes both a min and a max, or neither`);
+                        return;
+                    }
+                    d.params.push({ name, kind: "float", value: v, ...(lo !== null && hi !== null ? { min: lo, max: hi } : {}) });
+                    return;
+                }
+                errors.push(`${at}: #param kind must be float, color or vec3`);
+                return;
+            }
+            case "halfres":
+                d.fieldLayer = 1;
+                return;
+            case "layer":
+                if (args[0] !== "additive") {
+                    errors.push(`${at}: #layer takes "additive" — over is the default`);
+                    return;
+                }
+                d.additiveLayer = true;
+                return;
+            case "blend":
+                if (args[0] !== "additive") {
+                    errors.push(`${at}: #blend takes "additive" — alpha is the default`);
+                    return;
+                }
+                d.particleBlend = "additive";
+                return;
+            case "bloom":
+                d.bloom = true;
+                return;
+            case "dissolve":
+                d.dissolve = true;
+                return;
+            case "duration": {
+                // SECONDS, like every other time a directive states (see #dissolve).
+                // The document above works in frames and converts once; an author
+                // writing a shader is thinking about how long a flare takes, not about
+                // MMD's frame rate.
+                const n = num(args[0]);
+                if (n === null || n <= 0) {
+                    errors.push(`${at}: #duration takes a length in seconds`);
+                    return;
+                }
+                d.duration = n;
+                return;
+            }
+            default: {
+                // The three that take a count.
+                const n = num(args[0]);
+                if (n === null || n < 0) {
+                    errors.push(`${at}: #${tag} takes a number`);
+                    return;
+                }
+                if (tag === "particles")
+                    d.particles = n;
+                else if (tag === "lights")
+                    d.lights = n;
+                else if (tag === "grid")
+                    d.grid = n;
+                return;
+            }
+        }
+    });
+    // Duplicates are an author editing one line and forgetting another; last-wins
+    // is a coin toss they never see resolved.
+    const names = new Set();
+    for (const p of d.params) {
+        if (names.has(p.name))
+            errors.push(`#param ${p.name} is declared twice`);
+        names.add(p.name);
+    }
+    return { directives: d, errors };
+}
+/**
+ * The source as the compiler should see it: every directive line blanked.
+ *
+ * Blanked rather than removed so line numbers survive — a diagnostic points at
+ * the line the author is looking at, which is the whole reason the engine
+ * rebases them in the first place.
+ */
+export function stripDirectives(wgsl) {
+    return wgsl
+        .split("\n")
+        .map((line) => (LINE.test(line) ? "" : line))
+        .join("\n");
+}

package/dist/shaders/lights.d.ts

@@ -12,16 +12,6 @@ export declare const LIGHT_STRIDE = 8;
 export declare const MAX_LIGHTS = 16;
 /** Floats in the whole buffer. */
 export declare const LIGHTS_FLOATS: number;
-/**
- * `// @lights 3` — how many lights this effect emits.
- *
- * Declared, like every other mount: what the file says is what gets allocated,
- * so an effect that emits none costs no slots and nobody pays for a cap they
- * did not ask for. Clamped rather than rejected, the same choice `@particles`
- * makes — an author asking for a hundred gets the most the engine will give and
- * a scene that still runs.
- */
-export declare function parseLightCount(wgsl: string, max: number): number;
 /**
  * The RzLight struct, declared in EVERY module a user's source is spliced into.
  *

package/dist/shaders/lights.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lights.d.ts","sourceRoot":"","sources":["../../src/shaders/lights.ts"],"names":[],"mappings":"AAgCA;yEACyE;AACzE,eAAO,MAAM,YAAY,IAAI,CAAA;AAC7B,+CAA+C;AAC/C,eAAO,MAAM,YAAY,IAAI,CAAA;AAC7B;;;;;GAKG;AACH,eAAO,MAAM,UAAU,KAAK,CAAA;AAC5B,kCAAkC;AAClC,eAAO,MAAM,aAAa,QAA2C,CAAA;AAErE;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAIjE;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,qJAQhC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,idAa9B,CAAA;AAED,8CAA8C;AAC9C,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAC3B,MAAM,CAqER;AAED,6EAA6E;AAC7E,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAkEhE"}
+{"version":3,"file":"lights.d.ts","sourceRoot":"","sources":["../../src/shaders/lights.ts"],"names":[],"mappings":"AAgCA;yEACyE;AACzE,eAAO,MAAM,YAAY,IAAI,CAAA;AAC7B,+CAA+C;AAC/C,eAAO,MAAM,YAAY,IAAI,CAAA;AAC7B;;;;;GAKG;AACH,eAAO,MAAM,UAAU,KAAK,CAAA;AAC5B,kCAAkC;AAClC,eAAO,MAAM,aAAa,QAA2C,CAAA;AAErE;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,qJAQhC,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,idAa9B,CAAA;AAED,8CAA8C;AAC9C,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAElD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,GAC3B,MAAM,CA4ER;AAED,6EAA6E;AAC7E,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAkEhE"}

package/dist/shaders/lights.js

@@ -42,21 +42,6 @@ export const LIGHT_STRIDE = 8;
 export const MAX_LIGHTS = 16;
 /** Floats in the whole buffer. */
 export const LIGHTS_FLOATS = LIGHT_HEADER + MAX_LIGHTS * LIGHT_STRIDE;
-/**
- * `// @lights 3` — how many lights this effect emits.
- *
- * Declared, like every other mount: what the file says is what gets allocated,
- * so an effect that emits none costs no slots and nobody pays for a cap they
- * did not ask for. Clamped rather than rejected, the same choice `@particles`
- * makes — an author asking for a hundred gets the most the engine will give and
- * a scene that still runs.
- */
-export function parseLightCount(wgsl, max) {
-    const m = /^\s*\/\/\s*@lights\s+(\d+)\s*$/m.exec(wgsl);
-    if (!m)
-        return 0;
-    return Math.max(1, Math.min(max, parseInt(m[1], 10)));
-}
 /**
  * The RzLight struct, declared in EVERY module a user's source is spliced into.
  *
@@ -134,8 +119,8 @@ export function buildLightEmitShader(wgsl, sceneApi, cast) {
 // read_write HERE and read-only in the material shaders. Different passes, so
 // the two never coexist: this compute runs before the scene pass that reads it.
 @group(0) @binding(0) var<storage, read_write> _rzLightsOut: array<f32>;
-// (time, base slot, count, _) — see buildLightEmitShader on why the base is
-// here and not in the text.
+// (time, base slot, count, weight) — see buildLightEmitShader on why the base
+// is here and not in the text.
 @group(0) @binding(1) var<uniform> _rzLightU: vec4f;
 // The camera block and the cast — the two buffers the scene API reads. Same
 // contents the field and grid modules bind, so an effect's lightEmit sees the
@@ -185,12 +170,19 @@ fn lightEmitMain(@builtin(global_invocation_id) gid: vec3u) {
   let finite = l.pos.x == l.pos.x && l.pos.y == l.pos.y && l.pos.z == l.pos.z &&
     l.radius == l.radius && l.intensity == l.intensity &&
     l.color.x == l.color.x && l.color.y == l.color.y && l.color.z == l.color.z;
-  let c = select(vec3f(0.0), max(l.color * l.intensity, vec3f(0.0)), finite);
+  // Weight rides along with the sanitisation, which is already the one place
+  // this buffer is written: a lamp at half weight is half as bright, and one
+  // at zero never reaches here because the dispatch is skipped.
+  let c = select(vec3f(0.0), max(l.color * l.intensity, vec3f(0.0)), finite) * _rzLightU.w;
   let b = ${LIGHT_HEADER}u + (u32(_rzLightU.y) + i) * ${LIGHT_STRIDE}u;
   _rzLightsOut[b] = select(0.0, l.pos.x, finite);
   _rzLightsOut[b + 1u] = select(0.0, l.pos.y, finite);
   _rzLightsOut[b + 2u] = select(0.0, l.pos.z, finite);
-  _rzLightsOut[b + 3u] = select(0.0, max(l.radius, 0.0), finite);
+  // Radius goes to zero when the effect is OFF, and is left alone at every
+  // weight above it. Scaling it with the fade would shrink a dimming lamp's
+  // reach, which is a different thing than dimming it; zeroing it at nothing
+  // is what lets a material's distance cull drop the slot entirely.
+  _rzLightsOut[b + 3u] = select(0.0, max(l.radius, 0.0), finite && _rzLightU.w > 0.0);
   // Colour carries intensity, exactly as the CPU writer stores it — one product,
   // one place, so the two producers cannot disagree about what a slot means.
   _rzLightsOut[b + 4u] = c.x;

package/dist/shaders/lyrics-api.d.ts

@@ -5,8 +5,17 @@ export declare const LYRICS_FLOATS: number;
 /** Bounds on the line atlas the host packs rasterised lines into. It is sized
  *  to the track that arrives rather than allocated at the maximum: a scene with
  *  no lyrics carries a 1×1 placeholder, and a song's atlas is as tall as its
- *  own lines need. 8192 is the smallest texture dimension WebGPU guarantees. */
-export declare const LYRIC_ATLAS_MAX_W = 2048;
+ *  own lines need. 8192 is the smallest texture dimension WebGPU guarantees.
+ *
+ *  WIDTH IS WHAT DECIDES SHARPNESS on a long line. A lyric spans most of the
+ *  frame — the shipped effect leaves 6% a side — so at 4K it is drawn across
+ *  some 3400 pixels, and 2048 could only ever be stretched to cover them. That
+ *  is the stair-stepped text on a 4K render, and no row height fixes it: the
+ *  line is already as wide as the sheet. 1080p never showed it, because 1690
+ *  pixels of line fit inside 2048. The atlas is r8unorm, one byte a texel, and
+ *  only ever as wide as its own longest line — so this ceiling costs nothing
+ *  until a song actually needs it. */
+export declare const LYRIC_ATLAS_MAX_W = 4096;
 export declare const LYRIC_ATLAS_MAX_H = 8192;
 export type LyricLine = {
     /** Seconds on the scene clock. */

package/dist/shaders/lyrics-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lyrics-api.d.ts","sourceRoot":"","sources":["../../src/shaders/lyrics-api.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,eAAe,MAAM,CAAA;AAClC,eAAO,MAAM,YAAY,IAAI,CAAA;AAC7B,eAAO,MAAM,YAAY,IAAI,CAAA;AAC7B,eAAO,MAAM,aAAa,QAAgD,CAAA;AAE1E;;;gFAGgF;AAChF,eAAO,MAAM,iBAAiB,OAAO,CAAA;AACrC,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC,MAAM,MAAM,SAAS,GAAG;IACtB,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,8EAA8E;IAC9E,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,iFAAiF;AACjF,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAExD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,CA+BpD;AAED,6EAA6E;AAC7E,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,KAAK,CAAC,EAAE,SAAS,EAAE,GAAG,YAAY,CAAC,WAAW,CAAC,CAkB7F;AAED,oFAAoF;AACpF,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAsDhE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAgC5F"}
+{"version":3,"file":"lyrics-api.d.ts","sourceRoot":"","sources":["../../src/shaders/lyrics-api.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,eAAe,MAAM,CAAA;AAClC,eAAO,MAAM,YAAY,IAAI,CAAA;AAC7B,eAAO,MAAM,YAAY,IAAI,CAAA;AAC7B,eAAO,MAAM,aAAa,QAAgD,CAAA;AAE1E;;;;;;;;;;;;sCAYsC;AACtC,eAAO,MAAM,iBAAiB,OAAO,CAAA;AACrC,eAAO,MAAM,iBAAiB,OAAO,CAAA;AAErC,MAAM,MAAM,SAAS,GAAG;IACtB,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAA;IACb,8EAA8E;IAC9E,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,iFAAiF;AACjF,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAExD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,EAAE,CA+BpD;AAED,6EAA6E;AAC7E,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,KAAK,CAAC,EAAE,SAAS,EAAE,GAAG,YAAY,CAAC,WAAW,CAAC,CAkB7F;AAED,oFAAoF;AACpF,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAsDhE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAgC5F"}

package/dist/shaders/lyrics-api.js

@@ -26,8 +26,17 @@ export const LYRICS_FLOATS = LYRIC_HEADER + LYRIC_LINES_MAX * LYRIC_STRIDE;
 /** Bounds on the line atlas the host packs rasterised lines into. It is sized
  *  to the track that arrives rather than allocated at the maximum: a scene with
  *  no lyrics carries a 1×1 placeholder, and a song's atlas is as tall as its
- *  own lines need. 8192 is the smallest texture dimension WebGPU guarantees. */
-export const LYRIC_ATLAS_MAX_W = 2048;
+ *  own lines need. 8192 is the smallest texture dimension WebGPU guarantees.
+ *
+ *  WIDTH IS WHAT DECIDES SHARPNESS on a long line. A lyric spans most of the
+ *  frame — the shipped effect leaves 6% a side — so at 4K it is drawn across
+ *  some 3400 pixels, and 2048 could only ever be stretched to cover them. That
+ *  is the stair-stepped text on a 4K render, and no row height fixes it: the
+ *  line is already as wide as the sheet. 1080p never showed it, because 1690
+ *  pixels of line fit inside 2048. The atlas is r8unorm, one byte a texel, and
+ *  only ever as wide as its own longest line — so this ceiling costs nothing
+ *  until a song actually needs it. */
+export const LYRIC_ATLAS_MAX_W = 4096;
 export const LYRIC_ATLAS_MAX_H = 8192;
 /**
  * Parse an .lrc file: `[mm:ss.xx]` tags (several per line share the text),