melonjs 20.3.0 → 20.5.0

package/build/video/canvas/canvas_renderer.d.ts.map

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

package/build/video/canvas_factory.d.ts

@@ -1,25 +1,2 @@
-/**
- * Create and return a new Canvas element (or `OffscreenCanvas` when
- * supported and `returnOffscreenCanvas` is true). The single low-level
- * allocator used by every renderer-side scratch / fallback / render-
- * target canvas in the engine.
- *
- * Lives in its own module (not on `Renderer` directly) to break the
- * circular dependency between `Renderer` and `CanvasRenderTarget` —
- * both can import this helper without referencing each other.
- * `Renderer.createCanvas` re-exposes it as a static method for the
- * public-facing API; internal callers can import it directly.
- *
- * Gates the OffscreenCanvas path on `device.offscreenCanvas` (the
- * vetted capability check — actually instantiates + verifies
- * `getContext("2d")` works inside a try/catch, covering historical
- * Safari quirks).
- * @param {number} width - canvas width in pixels
- * @param {number} height - canvas height in pixels
- * @param {boolean} [returnOffscreenCanvas=false] - return an
- *   `OffscreenCanvas` if the platform supports it
- * @returns {HTMLCanvasElement|OffscreenCanvas} a new canvas of the given size
- * @ignore
- */
-export function createCanvas(width: number, height: number, returnOffscreenCanvas?: boolean): HTMLCanvasElement | OffscreenCanvas;
+
 //# sourceMappingURL=canvas_factory.d.ts.map

package/build/video/canvas_factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canvas_factory.d.ts","sourceRoot":"","sources":["../../src/video/canvas_factory.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,oCAPW,MAAM,UACN,MAAM,0BACN,OAAO,GAEL,iBAAiB,GAAC,eAAe,CAsB7C"}
+{"version":3,"file":"canvas_factory.d.ts","sourceRoot":"","sources":["../../src/video/canvas_factory.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,oCARW,MAAM,UACN,MAAM,0BACN,OAAO,GAEL,iBAAiB,GAAC,eAAe,CAuB7C"}

package/build/video/effects/blendEffect.d.ts

@@ -1,57 +1,3 @@
 export const wgslFragment: "\nstruct BlendUniforms {\n\tuBlendMode : f32,\n};\n@group(3) @binding(0) var<uniform> fx : BlendUniforms;\n@group(3) @binding(1) var backdrop : texture_2d<f32>;\n@group(3) @binding(2) var backdrop_sampler : sampler;\n\n// HardLight(Cb, Cs) \u2014 also the kernel for Overlay, which the W3C spec\n// defines as HardLight with the arguments swapped\nfn ME_hardLight(b : vec3f, s : vec3f) -> vec3f {\n\tlet lo = 2.0 * b * s;\n\tlet hi = 1.0 - 2.0 * (1.0 - b) * (1.0 - s);\n\treturn mix(lo, hi, step(vec3f(0.5), s));\n}\n\nfn ME_softLight(b : vec3f, s : vec3f) -> vec3f {\n\tlet d = mix(((16.0 * b - 12.0) * b + 4.0) * b, sqrt(b), step(vec3f(0.25), b));\n\tlet lo = b - (1.0 - 2.0 * s) * b * (1.0 - b);\n\tlet hi = b + (2.0 * s - 1.0) * (d - b);\n\treturn mix(lo, hi, step(vec3f(0.5), s));\n}\n\n// Cb == 0 wins over Cs == 1, so it is applied last\nfn ME_colorDodge(b : vec3f, s : vec3f) -> vec3f {\n\tvar r = min(vec3f(1.0), b / max(1.0 - s, vec3f(1e-4)));\n\tr = mix(r, vec3f(1.0), step(vec3f(1.0), s));\n\treturn mix(r, vec3f(0.0), step(b, vec3f(0.0)));\n}\n\n// Cb == 1 wins over Cs == 0, so it is applied last\nfn ME_colorBurn(b : vec3f, s : vec3f) -> vec3f {\n\tvar r = 1.0 - min(vec3f(1.0), (1.0 - b) / max(s, vec3f(1e-4)));\n\tr = mix(r, vec3f(0.0), step(s, vec3f(0.0)));\n\treturn mix(r, vec3f(1.0), step(vec3f(1.0), b));\n}\n\nfn ME_blend(b : vec3f, s : vec3f) -> vec3f {\n\tif (fx.uBlendMode < 0.5) { return abs(b - s); }\n\tif (fx.uBlendMode < 1.5) { return ME_hardLight(s, b); }\n\tif (fx.uBlendMode < 2.5) { return ME_hardLight(b, s); }\n\tif (fx.uBlendMode < 3.5) { return ME_colorDodge(b, s); }\n\tif (fx.uBlendMode < 4.5) { return ME_colorBurn(b, s); }\n\tif (fx.uBlendMode < 5.5) { return ME_softLight(b, s); }\n\tif (fx.uBlendMode < 6.5) { return min(b, s); }\n\treturn max(b, s);\n}\n\nfn apply(color : vec4f, uv : vec2f) -> vec4f {\n\t// sampled BEFORE any branch, so plain textureSampleLevel is safe here\n\tlet Cb = textureSampleLevel(backdrop, backdrop_sampler, screen_uv, 0.0).rgb;\n\tlet a = color.a;\n\tlet Cs = color.rgb / max(a, 1e-4);\n\tlet B = clamp(ME_blend(Cb, Cs), vec3f(0.0), vec3f(1.0));\n\treturn vec4f(a * B, a);\n}\n";
-/**
- * The compositing shader behind the six CSS blend modes that fixed-function
- * blending cannot express: `overlay`, `hard-light`, `color-dodge`,
- * `color-burn`, `soft-light` and `difference`.
- *
- * Internal — owned by the renderer, one instance per renderer, never
- * constructed or configured by user code. A game selects a mode the ordinary
- * way (`sprite.blendMode = "overlay"`, or `renderer.setBlendMode("overlay")`)
- * and the renderer drives this effect from there.
- *
- * ### How it composites
- *
- * The renderer captures the destination, renders the draw to an offscreen
- * target, then blits that target through this effect. Everything arriving in
- * `color` is PREMULTIPLIED (the offscreen was drawn source-over into a
- * transparent clear), while the W3C formulas are defined on straight colour —
- * so the body un-premultiplies, blends, and re-premultiplies.
- *
- * Emitting premultiplied and letting ordinary source-over run the composite
- * yields `as*B + (1-as)*Cb` and a correct output alpha for free. It also keeps
- * the premultiplied invariant `rgb <= a` — a texel with `rgb > a` is undefined
- * and diverges across browsers — which is why `B` is clamped even though all
- * six formulas land in `[0,1]` analytically.
- *
- * The backdrop is treated as opaque (`ab = 1`). The GL capture is an RGB
- * texture so that is true by construction there; the WebGPU capture preserves
- * alpha and is deliberately ignored, so the two backends agree.
- *
- * ### Why not the `: screen_texture` builtin
- *
- * That annotation wires the sampler to the renderer's SHARED capture slot,
- * which `drawImage` already refreshes on behalf of any custom shader that
- * samples the screen. A renderable carrying an advanced blend mode AND a
- * screen-sampling {@link ShaderEffect} would then have the two fighting over
- * one texture. This declares a plain sampler instead and the renderer binds
- * its own capture, so the two are independent. Referencing `screen_uv` still
- * activates that varying on its own.
- * @see {@link https://www.w3.org/TR/compositing-1/#blending}
- * @ignore
- */
-export default class BlendEffect extends ShaderEffect {
-    /**
-     * @param {import("../webgl/webgl_renderer.js").default|import("../webgpu/webgpu_renderer.js").default} renderer - the renderer that owns this effect
-     */
-    constructor(renderer: import("../webgl/webgl_renderer.js").default | import("../webgpu/webgpu_renderer.js").default);
-    /**
-     * Select which of the six formulas the shader evaluates.
-     * @param {string} mode - one of the modes in {@link ADVANCED_BLEND_MODES}
-     * @returns {boolean} false when the mode is not an advanced blend mode, in
-     * which case the uniform is left untouched
-     * @ignore
-     */
-    setBlendMode(mode: string): boolean;
-}
 import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=blendEffect.d.ts.map

package/build/video/effects/blendEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blendEffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/blendEffect.js"],"names":[],"mappings":"AAgBA,soEAwDE;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IACC;;OAEG;IACH,sBAFW,OAAO,4BAA4B,EAAE,OAAO,GAAC,OAAO,8BAA8B,EAAE,OAAO,EA4DrG;IAED;;;;;;OAMG;IACH,mBALW,MAAM,GACJ,OAAO,CAWnB;CACD;yBAhMwB,mBAAmB"}
+{"version":3,"file":"blendEffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/blendEffect.js"],"names":[],"mappings":"AAgBA,soEAwDE;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IACC;;OAEG;IACH,sBAFW,OAAO,4BAA4B,EAAE,OAAO,GAAC,OAAO,8BAA8B,EAAE,OAAO,EA4DrG;IAED;;;;;;;OAOG;IACH,mBANW,MAAM,GACJ,OAAO,CAYnB;CACD;yBAlMwB,mBAAmB"}

package/build/video/effects/colorMatrix.d.ts

@@ -22,16 +22,6 @@ export default class ColorMatrixEffect extends ShaderEffect {
     constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         matrix?: ColorMatrix | undefined;
     });
-    /**
-     * the internal color matrix
-     * @ignore
-     */
-    _matrix: ColorMatrix;
-    /**
-     * Push the current matrix values to the GPU.
-     * @ignore
-     */
-    _syncUniform(): void;
     /**
      * Reset the color matrix to identity (no color change).
      * @returns {this} this instance for chaining

package/build/video/effects/colorMatrix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"colorMatrix.d.ts","sourceRoot":"","sources":["../../../src/video/effects/colorMatrix.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAA8B,MAAM;KACtC,EAkBA;IANA;;;OAGG;IACH,qBAAkD;IAInD;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,SAFa,IAAI,CAMhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,WAAW,GACT,IAAI,CAMhB;IAED;;;;;OAKG;IACH,mBAHc,MAAM,EAAA,GACP,IAAI,CAMhB;CACD;yBAjKwB,mBAAmB;4BADhB,4BAA4B"}
+{"version":3,"file":"colorMatrix.d.ts","sourceRoot":"","sources":["../../../src/video/effects/colorMatrix.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAA8B,MAAM;KACtC,EAmBA;IAPA;;;;OAIG;IACH,qBAAkD;IAInD;;;;OAIG;IACH,qBAEC;IAED;;;OAGG;IACH,SAFa,IAAI,CAMhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,WAAW,GACT,IAAI,CAMhB;IAED;;;;;OAKG;IACH,mBAHc,MAAM,EAAA,GACP,IAAI,CAMhB;CACD;yBAnKwB,mBAAmB;4BADhB,4BAA4B"}

package/build/video/effects/glsl_realization.d.ts

@@ -1,18 +1,2 @@
-/**
- * Assemble the complete GLSL program sources for a ShaderEffect fragment
- * body: parse the builtins, build the vertex variant, and wrap the user's
- * `apply()` with the texture-sampling boilerplate.
- * @param {string} fragmentBody - the user body (GLSL, `vec4 apply(vec4, vec2)` convention)
- * @returns {{vertex: string, fragment: string, screenTextures: Array<{name: string, repeat: string}>, noiseUV: boolean}} the assembled sources + builtin usage
- * @ignore
- */
-export function buildGLSLProgram(fragmentBody: string): {
-    vertex: string;
-    fragment: string;
-    screenTextures: Array<{
-        name: string;
-        repeat: string;
-    }>;
-    noiseUV: boolean;
-};
+
 //# sourceMappingURL=glsl_realization.d.ts.map

package/build/video/effects/glsl_realization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glsl_realization.d.ts","sourceRoot":"","sources":["../../../src/video/effects/glsl_realization.js"],"names":[],"mappings":"AAiHA;;;;;;;GAOG;AACH,+CAJW,MAAM,GACJ;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,CA6BvH"}
+{"version":3,"file":"glsl_realization.d.ts","sourceRoot":"","sources":["../../../src/video/effects/glsl_realization.js"],"names":[],"mappings":"AAoHA;;;;;;;;GAQG;AACH,+CALW,MAAM,GACJ;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,CAoCvH"}

package/build/video/effects/mesh_splice.d.ts

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=mesh_splice.d.ts.map

package/build/video/effects/mesh_splice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh_splice.d.ts","sourceRoot":"","sources":["../../../src/video/effects/mesh_splice.js"],"names":[],"mappings":"AA4EA;;;;;;;;;;;;GAYG;AACH,6CAPW,MAAM,+BAEN,MAAM,GACJ,MAAM,GAAC,IAAI,CAmCvB;AAED;;;;;;GAMG;AACH,yCALW,MAAM,GACJ,OAAO,CAWnB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qCANW,MAAM,QACN,MAAM,GACJ,MAAM,GAAC,IAAI,CAgBvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,kCANW,MAAM,SACN,MAAM,GACJ,MAAM,CAWlB"}

package/build/video/effects/radialGradient.d.ts

@@ -85,7 +85,6 @@ export default class RadialGradientEffect extends ShaderEffect {
         color?: Color | undefined;
         intensity?: number | undefined;
     });
-    _colorBuf: Float32Array<ArrayBuffer>;
     /**
      * Set the center color. RGB only — alpha is ignored (the radial
      * falloff supplies the per-pixel alpha).

package/build/video/effects/radialGradient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"radialGradient.d.ts","sourceRoot":"","sources":["../../../src/video/effects/radialGradient.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH;IACC;;;;;OAKG;IACH,+CAHG;QAAwB,KAAK;QACJ,SAAS;KACpC,EA2DA;IAZA,qCAAoC;IAcrC;;;;OAIG;IACH,gBAFW,KAAK,QAOf;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;CACD;yBAtKwB,mBAAmB;2BAIlB,qBAAqB"}
+{"version":3,"file":"radialGradient.d.ts","sourceRoot":"","sources":["../../../src/video/effects/radialGradient.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH;IACC;;;;;OAKG;IACH,+CAHG;QAAwB,KAAK;QACJ,SAAS;KACpC,EA+DA;IAhBA;;;OAGG;IACH,qCAAoC;IAcrC;;;;OAIG;IACH,gBAFW,KAAK,QAOf;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;CACD;yBA1KwB,mBAAmB;2BAIlB,qBAAqB"}

package/build/video/effects/shadereffect.d.ts

@@ -1,129 +1,3 @@
-/**
- * A simplified shader class for applying custom fragment effects to renderables.
- * Only requires a fragment `apply()` function — the vertex shader, uniforms, and
- * texture sampling boilerplate are handled automatically.
- *
- * ## Dual-language bodies
- *
- * An effect body is written in the active renderer's shading language:
- * GLSL on the WebGL renderer, WGSL on the WebGPU renderer. Pass a plain
- * string for a GLSL-only effect (the historical form), or one body per
- * language for an effect that runs on both backends:
- *
- * ```js
- * new ShaderEffect(renderer, { glsl: glslBody, wgsl: wgslBody });
- * ```
- *
- * The renderer compiles the body matching its
- * {@link Renderer#shaderLanguage}. When no matching body exists — a
- * GLSL-only effect on the WebGPU renderer, any effect on the Canvas
- * renderer — the effect warns once and stays **disabled**
- * (`enabled === false`, every method a safe no-op): the scene renders
- * without the effect, it never breaks.
- *
- * ## The WGSL convention
- *
- * A WGSL body mirrors the GLSL one — declarations plus an apply function,
- * compiled verbatim inside engine boilerplate:
- *
- * - `fn apply(color : vec4f, uv : vec2f) -> vec4f` — required; receives
- *   the sampled, tinted pixel and its UV, returns the modified color.
- * - Uniforms are the members of ONE struct bound as
- *   `@group(3) @binding(0) var<uniform> fx : MyUniforms;` — member names
- *   are the {@link ShaderEffect#setUniform} names, so a dual-language
- *   effect uses the same uniform names in both bodies and one
- *   `setUniform` call serves both. Supported member types: `f32`, `i32`,
- *   `u32`, `vec2f`, `vec3f`, `vec4f`, `mat3x3f`, `mat4x4f`,
- *   `array<vec4f, N>`.
- * - Extra {@link ShaderEffect#setTexture} samplers are texture/sampler
- *   pairs at explicit consecutive group-3 bindings (from 1):
- *   `@group(3) @binding(1) var uNoise : texture_2d<f32>;`
- *   `@group(3) @binding(2) var uNoiseSampler : sampler;`
- * - The source texture is available as `uTexture` with `uSampler`
- *   (`textureSample(uTexture, uSampler, uv)` — the WGSL spelling of
- *   GLSL's `texture2D(uSampler, uv)`), and the interpolated tint as
- *   `vColor`, under the same names as the GLSL side.
- * - The shader builtins keep their names: `screen_uv`, `noise_uv`, and
- *   `screen_texture` — sampled through `screen_sampler` (clamped) or
- *   `screen_sampler_repeat` (wrapping), replacing the GLSL
- *   `: screen_texture(repeat)` annotation.
- * - Porting note: a texture sampled after a non-uniform `return` or
- *   inside a varying branch must use
- *   `textureSampleLevel(uTexture, uSampler, uv, 0.0)` (a WGSL
- *   uniform-control-flow rule; identical output for sprite textures).
- *
- * ## Directional UV arithmetic (`uUVYDir`)
- *
- * The vertical orientation of `apply()`'s UV space depends on the draw
- * path: sampling the sprite directly, `uv.y` grows downward, but the
- * WebGL multi-effect (pooled) path composites through capture FBOs whose
- * rows are bottom-up — there `uv.y` grows upward. A body that offsets its
- * sampling coordinate vertically (a drop shadow, a directional smear)
- * would render mirrored on that path. Declare a `float uUVYDir` uniform
- * (WGSL: `uUVYDir : f32` in the uniform struct) and multiply vertical UV
- * offsets by it: the renderer feeds `+1` where `uv.y` grows downward —
- * including every WebGPU path — and `-1` on the WebGL pooled path, so
- * "down" stays down everywhere. Initialize it to `1.0` with `setUniform`;
- * bodies that don't declare it are unaffected. The built-in
- * {@link DropShadowEffect} is the reference use.
- * @category Rendering
- * @example
- * // one effect, both backends: dual-language body
- * const fx = new ShaderEffect(renderer, {
- *     glsl: `
- *         uniform float uStrength;
- *         vec4 apply(vec4 color, vec2 uv) {
- *             return vec4(color.rgb * uStrength, color.a);
- *         }
- *     `,
- *     wgsl: `
- *         struct Fx { uStrength : f32, };
- *         @group(3) @binding(0) var<uniform> fx : Fx;
- *         fn apply(color : vec4f, uv : vec2f) -> vec4f {
- *             return vec4f(color.rgb * fx.uStrength, color.a);
- *         }
- *     `,
- * });
- * mySprite.addPostEffect(fx);
- * fx.setUniform("uStrength", 0.5); // sets either backend
- * @example
- * // create a grayscale effect
- * mySprite.addPostEffect(new ShaderEffect(renderer, `
- *     vec4 apply(vec4 color, vec2 uv) {
- *         float gray = dot(color.rgb, vec3(0.299, 0.587, 0.114));
- *         return vec4(vec3(gray), color.a);
- *     }
- * `));
- * @example
- * // create an effect with a custom uniform
- * const pulse = new ShaderEffect(renderer, `
- *     uniform float uTime;
- *     vec4 apply(vec4 color, vec2 uv) {
- *         float brightness = 0.8 + 0.2 * sin(uTime * 3.0);
- *         return vec4(color.rgb * brightness, color.a);
- *     }
- * `);
- * mySprite.addPostEffect(pulse);
- * // update the uniform each frame
- * pulse.setUniform("uTime", time);
- * @example
- * // Shader builtins — no JS plumbing, no UV math:
- * // `: screen_texture` keeps the sampler filled with everything drawn so
- * // far (a back-buffer copy; one screen copy per draw of the effect),
- * // `screen_uv` is this fragment's 0..1 screen position, and `noise_uv`
- * // runs 0..1 across the sprite regardless of its atlas frame.
- * const water = new ShaderEffect(renderer, `
- *     uniform sampler2D uNoise;
- *     uniform sampler2D screenTex : screen_texture;
- *     uniform float uTime;
- *     vec4 apply(vec4 color, vec2 uv) {
- *         vec2 flow = texture2D(uNoise, noise_uv + uTime * 0.25).rg;
- *         vec4 refracted = texture2D(screenTex, screen_uv + flow * 0.005);
- *         return refracted * texture2D(uSampler, uv + flow * 0.005);
- *     }
- * `);
- * water.setTexture("uNoise", noiseTexture.getTexture(), "repeat");
- */
 export default class ShaderEffect {
     /**
      * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
@@ -170,61 +44,22 @@ export default class ShaderEffect {
      * @default false
      */
     shared: boolean;
-    /**
-     * the renderer this effect was created for — kept so destroy and
-     * context-loss can release the texture units reserved on its cache
-     * for extra samplers ({@link setTexture}), and so {@link clone} can
-     * compile an independent copy
-     * @ignore
-     */
-    _renderer: any;
-    /**
-     * the construction "recipe" (body + precision), kept VERBATIM so
-     * {@link clone} can compile an independent copy. Stored before the
-     * disabled-stub early return so cloning behaves consistently there too.
-     * @ignore
-     */
-    _fragmentBody: string | {
-        glsl?: string;
-        wgsl?: string;
-    };
-    /** @ignore */
-    _precision: string | undefined;
-    /**
-     * extra texture samplers bound via {@link setTexture}, keyed by the
-     * uniform name → `{ image, repeat, tex }` (`tex` is the uploaded GL
-     * texture, created lazily on first draw; unused on WebGPU, where the
-     * bind group is built lazily instead)
-     * @ignore
-     */
-    _extraTextures: Map<any, any> | undefined;
-    /**
-     * samplers annotated `: screen_texture` — the renderer checks this to
-     * know when to refresh the shared frame capture before the effect draws
-     * @type {Array<{name: string, repeat: string}>}
-     * @ignore
-     */
-    _screenTextureUniforms: Array<{
-        name: string;
-        repeat: string;
-    }>;
-    /** @ignore */
-    _hasNoiseUV: any;
-    /** @ignore */
-    _shader: GLShader | undefined;
-    /** @ignore */
-    wgslRealization: WGSLEffectRealization | undefined;
-    /** @private */
-    private _onContextLost;
-    _enabledBeforeSuspend: boolean | undefined;
-    /** @private */
-    private _onContextRestored;
     /**
      * Set the uniform to the given value
      * @param {string} name - the uniform name
-     * @param {object|Float32Array} value - the value to assign to that uniform
+     * @param {number|boolean|number[]|Float32Array|object} value - the value to assign to that
+     * uniform. Scalars (`float`, `int`, `bool`) take a number or a boolean;
+     * vectors and matrices take an array, a `Float32Array`, or any object
+     * exposing `toArray()` — which is every {@link Vector2d},
+     * {@link Vector3d}, {@link Color} and {@link Matrix3d}.
+     * @example
+     * // a scalar the body declares as `uniform float uStrength;`
+     * fx.setUniform("uStrength", 0.5);
+     * // a vec3 — an array, or anything with toArray()
+     * fx.setUniform("uTint", [1.0, 0.82, 0.55]);
+     * fx.setUniform("uOrigin", new me.Vector2d(0.5, 0.5));
      */
-    setUniform(name: string, value: object | Float32Array): void;
+    setUniform(name: string, value: number | boolean | number[] | Float32Array | object): void;
     /**
      * Set the shader's `uTime` uniform (elapsed time, in seconds). A convenience
      * over `setUniform("uTime", ...)`; call it once per frame from your update
@@ -249,43 +84,6 @@ export default class ShaderEffect {
      * flow.setTime(me.timer.getTime() / 1000);
      */
     setTime(seconds: number): ShaderEffect;
-    /**
-     * Feed the UV y-direction of the space `apply()` is about to run in:
-     * `+1` where `uv.y` grows downward (direct sprite sampling, and every
-     * WebGPU path), `-1` on the WebGL pooled-blit path, whose capture FBOs
-     * are bottom-up — there, y-directional UV arithmetic inside a body
-     * runs vertically mirrored unless compensated. Directional bodies
-     * (DropShadow) declare a `uUVYDir` uniform and multiply their y
-     * offsets with it, so "down" means down on every path of every
-     * backend. A silent no-op for bodies that don't declare the uniform.
-     * @param {number} dir - +1 (uv.y grows downward) or -1 (upward)
-     * @ignore
-     */
-    _setUVYDir(dir: number): void;
-    _uvYDir: any;
-    /**
-     * Feed the `noise_uv` builtin's frame rect for the object about to draw:
-     * the source texture dimensions, the destination (object) dimensions, and
-     * the frame's top-left UV origin. Called by the quad batchers per draw;
-     * a no-op unless this effect's fragment actually uses `noise_uv` (the
-     * `ME_*` uniforms only exist — and are only active — then).
-     * @param {number} sourceWidth - source texture width in pixels
-     * @param {number} sourceHeight - source texture height in pixels
-     * @param {number} objectWidth - destination (object) width in pixels
-     * @param {number} objectHeight - destination (object) height in pixels
-     * @param {number} u0 - the frame's left UV coordinate (flip-normalized)
-     * @param {number} v0 - the frame's top UV coordinate (flip-normalized)
-     * @ignore
-     */
-    _setNoiseUVRect(sourceWidth: number, sourceHeight: number, objectWidth: number, objectHeight: number, u0: number, v0: number): void;
-    /**
-     * Apply the wrap mode a `: screen_texture(<repeat>)` annotation asked for
-     * onto the live capture handle. The unit is force-activated first: the
-     * batcher's bind may have been skipped as redundant while the GL active
-     * unit points elsewhere.
-     * @ignore
-     */
-    _applyCaptureWrap(batcher: any, glTex: any, entry: any): void;
     /**
      * Bind an **extra** texture to a named `sampler2D` uniform in this shader, so
      * a custom effect can read a *second* texture — a noise map, mask, gradient,
@@ -318,17 +116,6 @@ export default class ShaderEffect {
      * water.setTime(me.timer.getTime() / 1000);
      */
     setTexture(name: string, image: Texture2d | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, repeat?: "repeat" | "repeat-x" | "repeat-y" | "no-repeat"): ShaderEffect;
-    /**
-     * (Re)bind this effect's extra textures ({@link setTexture}) to reserved GL
-     * texture units and point their sampler uniforms at them. Called by the
-     * renderer right after this effect's shader is bound — for both the
-     * post-effect blit and the single-effect `customShader` sprite path — so the
-     * bindings survive the batcher's rotating color-texture pool.
-     * @param {object} batcher - the active batcher (owns the GL texture units)
-     * @ignore
-     */
-    _prepareTextures(batcher: object): void;
-    _textureOverflowWarned: boolean | undefined;
     /**
      * Create an independent copy of this effect, compiled as its own GL
      * program. Use it when several renderables need the same effect with
@@ -355,22 +142,6 @@ export default class ShaderEffect {
      * bossFlash.setUniform("uIntensity", 0.9);
      */
     clone(): ShaderEffect;
-    /** @ignore */
-    bind(): void;
-    /** @ignore */
-    getAttribLocation(name: any): number;
-    /** @ignore */
-    setVertexAttributes(gl: any, attributes: any, stride: any): void;
-    /** @ignore */
-    get program(): WebGLProgram | null;
-    /** @ignore */
-    get vertex(): any;
-    /** @ignore */
-    get fragment(): any;
-    /** @ignore */
-    get attributes(): {};
-    /** @ignore */
-    get uniforms(): object;
     /**
      * destroy this shader effect. Idempotent — calling destroy twice
      * is safe. Unsubscribes from the renderer's context-lost / restored

package/build/video/effects/shadereffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shadereffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shadereffect.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6HG;AACH;IAiCC;;;;;;;;;;;OAWG;IACH,sBAXW,aAAa,GAAC,cAAc,GAAC,cAAc,QAC3C,MAAM,GAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,cAQrC,MAAM,EAqHhB;IA/JD;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGC;IAElB;;;;;;;;;;OAUG;IACH,QAHU,OAAO,CAGF;IAed;;;;;;OAMG;IACH,eAAyB;IAEzB;;;;;OAKG;IACH;eA1ByB,MAAM;eAAS,MAAM;MA0BrB;IACzB,cAAc;IACd,+BAA2B;IAoB3B;;;;;;OAMG;IACH,0CAA+B;IAQ9B;;;;;OAKG;IACH,wBAHU,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAGK;IACpD,cAAc;IACd,iBAAkC;IAElC,cAAc;IACd,8BAKC;IAyBD,cAAc;IACd,mDAAkC;IAsBpC,eAAe;IACf,uBAkBC;IAbA,2CAAyC;IAe1C,eAAe;IACf,2BAQC;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,GAAC,YAAY,QAmB7B;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iBAbW,MAAM,GACJ,YAAY,CAuCxB;IAED;;;;;;;;;;;OAWG;IACH,gBAHW,MAAM,QAqBhB;IATC,aAAkB;IAWpB;;;;;;;;;;;;;OAaG;IACH,6BARW,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,MACN,MAAM,MACN,MAAM,QAoDhB;IAED;;;;;;OAMG;IACH,8DAaC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,iBAnBW,MAAM,SACN,SAAS,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,WACxE,QAAQ,GAAC,UAAU,GAAC,UAAU,GAAC,WAAW,GACxC,YAAY,CA0GxB;IAED;;;;;;;;OAQG;IACH,0BAHW,MAAM,QA2FhB;IA3DI,4CAAkC;IA6DvC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SATa,YAAY,CAsDxB;IAKD,cAAc;IACd,aAIC;IAED,cAAc;IACd,qCAIC;IAED,cAAc;IACd,iEAIC;IAED,cAAc;IACd,mCAEC;IAED,cAAc;IACd,kBAEC;IAED,cAAc;IACd,oBAEC;IAED,cAAc;IACd,qBAEC;IAED,cAAc;IACd,uBAEC;IAED;;;;OAIG;IACH,gBAyCC;CACD;qBA74BoB,sBAAsB;kCAET,uBAAuB;sBAHnC,yBAAyB"}
+{"version":3,"file":"shadereffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shadereffect.js"],"names":[],"mappings":"AAiJA;IAiCC;;;;;;;;;;;OAWG;IACH,sBAXW,aAAa,GAAC,cAAc,GAAC,cAAc,QAC3C,MAAM,GAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,cAQrC,MAAM,EAiKhB;IA3MD;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGC;IAElB;;;;;;;;;;OAUG;IACH,QAHU,OAAO,CAGF;IAed;;;;;;;OAOG;IACH,eAAyB;IAEzB;;;;;;OAMG;IACH;eA5ByB,MAAM;eAAS,MAAM;MA4BrB;IACzB;;;OAGG;IACH,+BAA2B;IAoB3B;;;;;;;OAOG;IACH,0CAA+B;IAE/B;;;;;OAKG;IACH,0CAA+B;IAE/B;;;;OAIG;IACH,8BAAgC;IAQ/B;;;;;;OAMG;IACH,wBAJU,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAIK;IACpD;;;OAGG;IACH,iBAAkC;IAClC;;;;;;OAMG;IACH,eAA6B;IAC7B;;;OAGG;IACH,mBAAqC;IAErC;;;OAGG;IACH,8BAKC;IAyBD;;;OAGG;IACH,mDAAkC;IAsBpC;;;;OAIG;IACH,uBAsBC;IAjBA;;;OAGG;IACH,2CAAyC;IAe1C;;;;OAIG;IACH,2BAQC;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAbW,MAAM,SACN,MAAM,GAAC,OAAO,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC,MAAM,QAsCrD;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iBAbW,MAAM,GACJ,YAAY,CAoDxB;IAED;;;;;;;;;;;;OAYG;IACH,gBAJW,MAAM,QA0BhB;IAbC;;;OAGG;IACH,aAAkB;IAWpB;;;;;;;;;;;;;;OAcG;IACH,6BATW,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,MACN,MAAM,MACN,MAAM,QAqDhB;IAED;;;;;;;OAOG;IACH,8DAaC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,iBAnBW,MAAM,SACN,SAAS,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,WACxE,QAAQ,GAAC,UAAU,GAAC,UAAU,GAAC,WAAW,GACxC,YAAY,CA0GxB;IAED;;;;;;;;;OASG;IACH,0BAJW,MAAM,QAgGhB;IA/DI;;;OAGG;IACH,4CAAkC;IA6DvC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SATa,YAAY,CAsDxB;IAKD;;;OAGG;IACH,aAIC;IAED;;;OAGG;IACH,qCAIC;IAED;;;OAGG;IACH,iEAIC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,kBAEC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAyCC;CACD;qBAjhCoB,sBAAsB;kCAET,uBAAuB;sBAHnC,yBAAyB"}

package/build/video/effects/wgsl/layout.d.ts

@@ -1,28 +1,2 @@
-/**
- * normalize the `vecN<f32>` / `matCxR<f32>` spellings onto the short forms
- * used as TYPE_LAYOUT keys
- * @param {string} type - a WGSL type token
- * @returns {string} the canonical spelling
- * @ignore
- */
-export function normalizeWGSLType(type: string): string;
-/**
- * Compute the uniform-buffer layout for a parsed struct member list.
- * @param {Array<{name: string, type: string}>} members - struct members in declaration order
- * @returns {{map: Map<string, {offset: number, size: number, type: string}>, size: number}|null}
- *   the name → placement map and the total (16-byte-rounded) struct size,
- *   or `null` when a member type is unsupported
- * @ignore
- */
-export function computeUniformLayout(members: Array<{
-    name: string;
-    type: string;
-}>): {
-    map: Map<string, {
-        offset: number;
-        size: number;
-        type: string;
-    }>;
-    size: number;
-} | null;
+
 //# sourceMappingURL=layout.d.ts.map

package/build/video/effects/wgsl/layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/layout.js"],"names":[],"mappings":"AAqCA;;;;;;GAMG;AACH,wCAJW,MAAM,GACJ,MAAM,CAQlB;AAUD;;;;;;;GAOG;AACH,8CANW,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAC,GACjC;IAAC,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GAAC,IAAI,CAuB/F"}
+{"version":3,"file":"layout.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/layout.js"],"names":[],"mappings":"AAuCA;;;;;;;GAOG;AACH,wCALW,MAAM,GACJ,MAAM,CASlB;AAWD;;;;;;;;GAQG;AACH,8CAPW,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAAC,GACjC;IAAC,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GAAC,IAAI,CAwB/F"}

package/build/video/effects/wgsl/parse.d.ts

@@ -1,9 +1,2 @@
-/**
- * Parse a WGSL effect body's declarations.
- * @param {string} body - the user WGSL body
- * @returns {object} `{ok: true, layout, structSize, uniformVar, textures, builtins, maxUserBinding}`
- *   or `{ok: false, error}`
- * @ignore
- */
-export function parseWGSLBody(body: string): object;
+
 //# sourceMappingURL=parse.d.ts.map

package/build/video/effects/wgsl/parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/parse.js"],"names":[],"mappings":"AAoHA;;;;;;GAMG;AACH,oCALW,MAAM,GACJ,MAAM,CAqKlB"}
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/parse.js"],"names":[],"mappings":"AAwHA;;;;;;;GAOG;AACH,oCANW,MAAM,GACJ,MAAM,CAsKlB"}

package/build/video/effects/wgsl/scaffold.d.ts

@@ -1,43 +1,2 @@
-/**
- * WGSL module assembly for a ShaderEffect body — the WGSL counterpart of
- * `glsl_realization.js`'s source templating. The user body is embedded
- * VERBATIM (WGSL module-scope declarations are order-independent); the
- * scaffold contributes the vertex/fragment entry points over the frozen
- * 28-byte quad layout, the frame-globals and material groups, and the
- * builtin declarations the parser detected.
- *
- * Frozen conventions carried over from the core quad shader:
- * - clip-z remap `(z + w) * 0.5` (GL-convention [-w, w] → WebGPU [0, w])
- * - packed-ARGB attribute read as (B,G,R,A) → `.bgr * .a` premultiply
- * - `screen_uv` is y-down (`0.5 - ndc.y * 0.5`): WebGPU texture row 0 is
- *   the top, so the capture is sampled without any flip
- * @ignore
- */
-/**
- * builtin group-3 bindings are assigned ABOVE the highest user binding so
- * they can never collide: ME uniform first, then the capture texture and
- * its sampler variants
- * @param {object} parsed - the parseWGSLBody result
- * @returns {{me: number, screenTexture: number, screenSamplerClamp: number, screenSamplerRepeat: number}}
- *   assigned binding indices (-1 when the builtin is unused)
- * @ignore
- */
-export function assignBuiltinBindings(parsed: object): {
-    me: number;
-    screenTexture: number;
-    screenSamplerClamp: number;
-    screenSamplerRepeat: number;
-};
-/**
- * Assemble the complete WGSL module for an effect body.
- * @param {string} body - the user WGSL body (embedded verbatim)
- * @param {object} parsed - the parseWGSLBody result
- * @returns {{code: string, bindings: object}} the module text and the
- *   builtin binding assignment (consumed when building the bind group)
- * @ignore
- */
-export function buildWGSLModule(body: string, parsed: object): {
-    code: string;
-    bindings: object;
-};
+
 //# sourceMappingURL=scaffold.d.ts.map

package/build/video/effects/wgsl/scaffold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/scaffold.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;GAQG;AACH,8CALW,MAAM,GACJ;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,mBAAmB,EAAE,MAAM,CAAA;CAAC,CA0BxG;AAED;;;;;;;GAOG;AACH,sCANW,MAAM,UACN,MAAM,GACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAyG5C"}
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/scaffold.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;GASG;AACH,8CANW,MAAM,GACJ;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,mBAAmB,EAAE,MAAM,CAAA;CAAC,CA2BxG;AAED;;;;;;;;GAQG;AACH,sCAPW,MAAM,UACN,MAAM,GACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CA0G5C"}