melonjs 20.1.1 → 20.2.0

package/build/video/blendmodes.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Whether a blend mode needs the shader path rather than fixed-function state.
+ * @param {string} mode - the blend mode to test
+ * @returns {boolean} true when the mode needs the shader path
+ * @ignore
+ */
+export function isAdvancedBlendMode(mode: string): boolean;
+/**
+ * The `uBlendMode` uniform value for an advanced blend mode.
+ * @param {string} mode - the blend mode
+ * @returns {number} the shader's mode index, or -1 when not an advanced mode
+ * @ignore
+ */
+export function advancedBlendModeIndex(mode: string): number;
+/**
+ * Normalize a user-facing blend-mode string to its canonical token: `add` and
+ * `lighter` are spellings of `additive`, and anything unrecognized collapses
+ * to `normal`.
+ *
+ * The six advanced modes normalize to `"normal"` on purpose — that is their
+ * PIPELINE state, since the geometry really does rasterize under ordinary
+ * source-over before the shader composites it. Use {@link isAdvancedBlendMode}
+ * to ask the other question, and {@link reportedBlendMode} for what
+ * `setBlendMode` should tell the caller.
+ * @param {string} mode - blend mode as set through `setBlendMode`
+ * @returns {string} the canonical token
+ * @ignore
+ */
+export function normalizeBlendMode(mode: string): string;
+/**
+ * Whether the engine can honour this blend mode at all, by either route.
+ * @param {string} mode - the blend mode to test
+ * @returns {boolean} false only for a mode no backend implements
+ * @ignore
+ */
+export function isSupportedBlendMode(mode: string): boolean;
+/**
+ * What `setBlendMode` reports back as applied.
+ *
+ * The return value is a capability probe: callers compare it against their
+ * request, and a mismatch means the renderer could not honour the mode. So a
+ * mode that WAS honoured must report itself verbatim — including an alias
+ * like `add`, which shares a pipeline with `additive` but must not come back
+ * under that name — while anything unimplemented reports `"normal"`.
+ * @param {string} mode - the requested blend mode
+ * @returns {string} the mode actually applied
+ * @ignore
+ */
+export function reportedBlendMode(mode: string): string;
+/**
+ * The blend state for a mode, in WebGPU's vocabulary — the neutral form each
+ * backend translates from.
+ *
+ * `srcFactor` depends on whether sources carry premultiplied alpha: a
+ * premultiplied source has already been scaled, so it takes `one` where a
+ * straight one takes `src-alpha`.
+ *
+ * Every mode here is EXACT for a translucent source as well as an opaque one
+ * — `multiply`, `screen` and `exclusion` were long commented as
+ * "approximate", but the algebra works out and measurement agrees. The two
+ * that genuinely could not be expressed this way, `darken` and `lighten`,
+ * moved to the shader path instead of staying approximate.
+ * @param {string} mode - a canonical mode from {@link normalizeBlendMode}
+ * @param {boolean} premultipliedAlpha - whether sources are premultiplied
+ * @returns {{operation: string, srcFactor: string, dstFactor: string}|undefined} the
+ * blend state, or `undefined` for `"none"`, which means replace (no blending)
+ * @ignore
+ */
+export function blendStateFor(mode: string, premultipliedAlpha: boolean): {
+    operation: string;
+    srcFactor: string;
+    dstFactor: string;
+} | undefined;
+/**
+ * The engine's blend-mode registry — one definition of every mode, shared by
+ * all three renderers.
+ *
+ * Blending is described here in **backend-neutral** terms and translated by
+ * each backend: WebGPU consumes these tokens directly (they are its own
+ * vocabulary), WebGL maps them onto `gl.*` enums, and Canvas ignores them
+ * entirely in favour of `globalCompositeOperation`.
+ *
+ * Keeping the table in one place is not tidiness. The two GPU backends
+ * previously each carried their own copy — a `switch` of `blendEquation` /
+ * `blendFunc` calls on one side and a `GPUBlendState` table on the other —
+ * which meant a mode added, removed or corrected on one backend could
+ * silently disagree with the other, and `video.AUTO` would then render the
+ * same scene differently depending on which backend it happened to pick.
+ */
+/**
+ * The CSS blend modes that cannot be expressed as `src * sfactor + dst * dfactor`.
+ *
+ * Fixed-function blending computes one multiply-add per channel, which covers
+ * `multiply`, `screen`, `additive` and `exclusion` — exactly, translucent
+ * sources included. The modes below cannot be reached that way: most need a
+ * per-pixel branch, a division or a `sqrt` on the DESTINATION, and `darken` /
+ * `lighten` need a term the `min` / `max` operations leave no room for.
+ * Neither GPU backend can read the destination in a fragment shader, so all of
+ * them are implemented by capturing the destination to a texture and
+ * compositing in `BlendEffect`.
+ *
+ * The array ORDER is the wire format: the index is the `uBlendMode` uniform
+ * value the shader branches on, so reordering it silently remaps every mode.
+ * @ignore
+ */
+export const ADVANCED_BLEND_MODES: string[];
+//# sourceMappingURL=blendmodes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blendmodes.d.ts","sourceRoot":"","sources":["../../src/video/blendmodes.js"],"names":[],"mappings":"AAkDA;;;;;GAKG;AACH,0CAJW,MAAM,GACJ,OAAO,CAKnB;AAED;;;;;GAKG;AACH,6CAJW,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;;;;;;;;;GAaG;AACH,yCAJW,MAAM,GACJ,MAAM,CAkBlB;AAED;;;;;GAKG;AACH,2CAJW,MAAM,GACJ,OAAO,CASnB;AAED;;;;;;;;;;;GAWG;AACH,wCAJW,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,oCANW,MAAM,sBACN,OAAO,GACL;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,GAAC,SAAS,CAwC/E;AA1LD;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,4CAeE"}

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

@@ -27,7 +27,7 @@ export default class CanvasRenderer extends Renderer {
     setProjection(matrix: Matrix3d): void;
     /**
      * set the current blend mode for this renderer. <br>
-     * All renderers support: <br>
+     * Every renderer supports the full set: <br>
      * - "normal" : draws new content on top of the existing content <br>
      * <img src="../images/normal-blendmode.png" width="180"/> <br>
      * - "add", "additive", or "lighter" : color values are added together <br>
@@ -36,26 +36,30 @@ export default class CanvasRenderer extends Renderer {
      * <img src="../images/multiply-blendmode.png" width="180"/> <br>
      * - "screen" : pixels are inverted, multiplied, and inverted again (opposite of multiply) <br>
      * <img src="../images/screen-blendmode.png" width="180"/> <br>
-     * Canvas (browser-dependent) and WebGL2: <br>
      * - "darken" : retains the darkest pixels of both layers <br>
      * <img src="../images/darken-blendmode.png" width="180"/> <br>
      * - "lighten" : retains the lightest pixels of both layers <br>
      * <img src="../images/lighten-blendmode.png" width="180"/> <br>
-     * Canvas only, browser-dependent (falls back to "normal" if unsupported or in WebGL): <br>
-     * - "overlay" <br>
+     * - "overlay" : multiplies or screens, depending on the backdrop <br>
      * <img src="../images/overlay-blendmode.png" width="180"/> <br>
-     * - "color-dodge" <br>
-     * <img src="../images/color-dodge-blendmode.png" width="180"/> <br>
-     * - "color-burn" <br>
-     * <img src="../images/color-burn-blendmode.png" width="180"/> <br>
-     * - "hard-light" <br>
+     * - "hard-light" : overlay with the layers swapped — a harsh spotlight <br>
      * <img src="../images/hard-light-blendmode.png" width="180"/> <br>
-     * - "soft-light" <br>
+     * - "soft-light" : a diffused spotlight, gentler than hard-light <br>
      * <img src="../images/soft-light-blendmode.png" width="180"/> <br>
-     * - "difference" <br>
+     * - "color-dodge" : brightens the backdrop to reflect the source <br>
+     * <img src="../images/color-dodge-blendmode.png" width="180"/> <br>
+     * - "color-burn" : darkens the backdrop to reflect the source <br>
+     * <img src="../images/color-burn-blendmode.png" width="180"/> <br>
+     * - "difference" : the absolute difference of the two layers <br>
      * <img src="../images/difference-blendmode.png" width="180"/> <br>
-     * - "exclusion" <br>
+     * - "exclusion" : like difference, but lower in contrast <br>
      * <img src="../images/exclusion-blendmode.png" width="180"/> <br>
+     * - "none" : blending disabled — the source replaces the destination
+     * outright, alpha included <br>
+     * A few draw types cannot honour every mode — 3D meshes, and fills using
+     * a {@link Gradient} — and fall back to "normal" with a one-time console
+     * warning. `setBlendMode` returns what it actually applied, so comparing
+     * the result against your request detects that case.
      * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
      * @param {string} [mode="normal"] - blend mode
      * @returns {string} the blend mode actually applied (may differ if the requested mode is unsupported)
@@ -301,24 +305,24 @@ export default class CanvasRenderer extends Renderer {
      * Reset (overrides) the renderer transformation matrix to the
      * identity one, and then apply the given transformation matrix.
      * @param {Matrix2d|Matrix3d|number} a - a matrix to transform by, or the a component to multiply the current matrix by
-     * @param {number} b - the b component to multiply the current matrix by
-     * @param {number} c - the c component to multiply the current matrix by
-     * @param {number} d - the d component to multiply the current matrix by
-     * @param {number} e - the e component to multiply the current matrix by
-     * @param {number} f - the f component to multiply the current matrix by
+     * @param {number} [b] - the b component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [c] - the c component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [d] - the d component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [e] - the e component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [f] - the f component to multiply the current matrix by; omitted when `a` is a matrix
      */
-    setTransform(a: Matrix2d | Matrix3d | number, b: number, c: number, d: number, e: number, f: number): void;
+    setTransform(a: Matrix2d | Matrix3d | number, b?: number, c?: number, d?: number, e?: number, f?: number): void;
     /**
      * Multiply given matrix into the renderer tranformation matrix
      * @see {@link CanvasRenderer.setTransform} which will reset the current transform matrix prior to performing the new transformation
      * @param {Matrix2d|Matrix3d|number} a - a matrix to transform by, or the a component to multiply the current matrix by
-     * @param {number} b - the b component to multiply the current matrix by
-     * @param {number} c - the c component to multiply the current matrix by
-     * @param {number} d - the d component to multiply the current matrix by
-     * @param {number} e - the e component to multiply the current matrix by
-     * @param {number} f - the f component to multiply the current matrix by
+     * @param {number} [b] - the b component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [c] - the c component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [d] - the d component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [e] - the e component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [f] - the f component to multiply the current matrix by; omitted when `a` is a matrix
      */
-    transform(a: Matrix2d | Matrix3d | number, b: number, c: number, d: number, e: number, f: number): void;
+    transform(a: Matrix2d | Matrix3d | number, b?: number, c?: number, d?: number, e?: number, f?: number): void;
     /**
      * A mask limits rendering elements to the shape and position of the given mask object.
      * If the drawing or rendering area is larger than the mask, only the intersecting part of the renderable will be visible.

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/effects/blendEffect.d.ts

@@ -0,0 +1,57 @@
+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

@@ -0,0 +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"}

package/build/video/renderer.d.ts

@@ -447,11 +447,10 @@ declare class Renderer {
      */
     getBlendMode(): string;
     /**
-     * set the current blend mode.
-     * Subclasses (CanvasRenderer, WebGLRenderer, WebGPURenderer once it
-     * lands) implement the actual backend logic.
+     * set the current blend mode. Every renderer supports the same set —
+     * see {@link CanvasRenderer#setBlendMode} for the list and what each does.
      * @param {string} [mode="normal"] - blend mode
-     * @param {boolean} [premultipliedAlpha=true] - whether textures use premultiplied alpha (GPU renderers only)
+     * @param {boolean} [premultipliedAlpha=true] - whether textures use premultiplied alpha
      */
     setBlendMode(mode?: string): void;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/video/renderer.js"],"names":[],"mappings":"AAUA;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;;GAGG;AACH;IA2dC;;;;;;;;;;;;OAYG;IACH,2BANW,MAAM,UACN,MAAM,0BACN,OAAO,GAEL,iBAAiB,GAAC,eAAe,CAI7C;IAED;;;;;;;;;;;;OAYG;IACH,wBAFa,iBAAiB,GAAC,eAAe,CAgB7C;IAtgBD;;OAEG;IACH,sBAFW,mBAAmB,EA4N7B;IAzNA;;;;OAIG;IACH,cAFU,kBAAkB,CAS3B;IAED;;;;OAIG;IACH,iBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,oBAFU,MAAM,CAE6C;IAE7D;;;;OAIG;IACH,YAHU,QAAQ,CAGsD;IAExE;;;;OAIG;IACH,gBAFU,OAAO,CAES;IAE1B;;;;OAIG;IACH,aAFU,MAAM,GAAC,SAAS,CAEE;IAE5B;;;;;;OAMG;IACH,cAHU,QAAQ,GAAC,YAAY,GAAC,SAAS,CAGZ;IAE7B;;;;;OAKG;IACH,mBAHU,gBAAgB,GAAC,IAAI,CAGF;IAE7B;;;OAGG;IACH,QAFU,MAAM,CAEU;IAE1B;;;;;;;;;;OAUG;IACH,MAFU,MAAM,CAEK;IAErB;;;;;OAKG;IACH,mBAFU,WAAW,GAAC,SAAS,CAEG;IAElC;;;;;;;;OAQG;IACH,0BAHU,OAAO,CAGoB;IAErC;;;;;;OAMG;IACH,sBAHU,OAAO,CAGgB;IAEjC;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGc;IAE/B;;;;;;;;;;;;;OAaG;IACH,gBAHU,MAAM,GAAC,MAAM,GAAC,IAAI,CAGF;IAE1B;;;;;;;OAOG;IACH,qBAHU,OAAO,CAGe;IAEhC;;;;;OAKG;IACH,iBAFU,KAAK,CAOd;IAED;;;;OAIG;IACH,aAFU,WAAW,CAEe;IAGpC,oBAAiD;IACjD,mBAA+C;IAC/C,4CAAqD;IAErD;;;;;;;;;OASG;IACH,WAHU,MAAM,CAGE;IAElB;;OAEG;IACH,kBAAkB;IAGlB,2BAAsC;IAGtC,iBAAiB;IAEjB;;;;;;;;OAQG;IACH,kBAFU,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAAC,IAAI,CAEjD;IAE5B;;;;;;;OAOG;IACH,kBAFU,MAAM,CAES;IAU1B,4BANU,MAAM,EAQf;IATD;;OAEG;IACH,wBAFU,MAAM,CAIf;IAoBD,wBAPU,MAAM,EASf;IAhBD;;;;;;;;;OASG;IACH,oBAHU,MAAM,CAKf;IAcD,kBANa,MAAM,EAQlB;IAVD;;;OAGG;IACH,cAFa,MAAM,CAIlB;IAcD,iBANa,MAAM,EAQlB;IAVD;;;OAGG;IACH,aAFa,MAAM,CAIlB;IAMD;;;;;;;;OAQG;IACH,QAFa,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;OAEG;IACH,cAAU;IAEV;;OAEG;IACH,cAAU;IAEV;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,wBAPW,MAAM,eACN,QAAQ,QACR,MAAM,cACN,MAAM,QAqBhB;IADA,kBAA0B;IAG3B;;;;;;;;OAQG;IACH,2BAmDC;IAxCA,qCAA2B;IA0C5B;;;;;;;;;;;;;;;;;OAiBG;IAEH,eAJW,IAAI,gBACJ,QAAQ,QAGW;IAE9B;;OAEG;IACH,cAeC;IAED;;;;OAIG;IACH,gBAAY;IAEZ;;;OAGG;IACH,aAFa,iBAAiB,CAI7B;IAED;;;;;;;;;;OAUG;IACH,oBALW,MAAM,UACN,MAAM,0BACN,OAAO,GACL,iBAAiB,GAAC,eAAe,CAI7C;IAgDD;;;OAGG;IACH,cAFa,wBAAwB,GAAC,qBAAqB,GAAC,gBAAgB,CAI3E;IAED;;;;;;;OAOG;IACH,wCAFa,MAAM,CAYlB;IAED;;;;OAIG;IACH,sCAHW,MAAM,GACJ,OAAO,CAgBnB;IAED;;;;;;;OAOG;IACH,4BAJW,UAAU,GACR,OAAO,CAcnB;IAED;;;;;;OAMG;IAEH,0BAJW,UAAU,QAIO;IAE5B;;;;;;;;;;;;OAYG;IAEH,mBATW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,YAAY,cACZ,OAAO,QAG2C;IAE7D;;;;;;;;OAQG;IAEH,gBANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAGiB;IAElC;;;;OAIG;IACH,0BAAsB;IAEtB;;;;;;;OAOG;IAEH,iBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAGoB;IAErC;;;OAGG;IACH,uBAAmB;IAEnB;;;;OAIG;IAEH,wBAHW,OAAO,QAGQ;IAE1B;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,oBAHW,MAAM,QAKhB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IAEH,0BANW,QAAQ,CAAC,MAAM,CAAC,YAChB,MAAM,eACN,MAAM,eACN,MAAM,QAqBhB;IAPC,wCAA8B;IAShC;;;;;;;;;;;;;;;;;;;;OAoBG;IAEH,iBAJW,MAAM,QAMhB;IAED;;;;;;;;;;;;OAYG;IACH,qBAHW,MAAM,QACN,IAAI,QA4Bd;IAED;;;;OAIG;IAEH,gBAHW,KAAK,GAAC,MAAM,GAAC,QAAQ,QAK/B;IAED;;;OAGG;IACH,YAFa,KAAK,CAIjB;IAED;;;;;;;OAOG;IACH,yBANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,QAAQ,CAIpB;IAED;;;;;;;;;OASG;IACH,yBARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,QAAQ,CAIpB;IAED;;;;;;;;;OASG;IACH,sBARW,MAAM,EAAE,QAsBlB;IAED;;;OAGG;IACH,eAFa,MAAM,EAAE,CAIpB;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAHW,IAAI,GAAC,MAAM,GACT,OAAO,CASnB;IAED;;;;OAIG;IACH,cAHW,MAAM,UACN,MAAM,QAchB;IAED;;;OAGG;IACH,sBAFW,OAAO,QAOjB;IAED;;;;;;;;;;;OAWG;IACH,2BAFa,QAAQ,GAAC,SAAS,CAS9B;IAED;;;;;;OAMG;IACH,wBAFW,MAAM,GAAC,SAAS,GAAC,QAAQ,QAInC;IAED;;;;OAIG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,cAHW,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,GAAC,MAAM,SAC1C,OAAO,QAiFjB;IAED;;;OAGG;IACH,YAFW,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,GAAC,MAAM,QAIpD;IAED;;;;;;OAMG;IACH,UALW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,SAClD,KAAK,GAAC,MAAM,SACZ,MAAM,GACJ,iBAAiB,GAAC,eAAe,CAyB7C;IAED;;;;;;;OAOG;IAEH,YANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAGe;IAEhC;;;OAGG;IACH,uBAAmB;IAEnB;;;OAGG;IACH,aAAS;IAET;;;;OAIG;IACH,gBAAY;IAEZ;;;;OAIG;IAEH,aAJW,MAAM,KACN,MAAM,QAGC;IAElB;;;OAGG;IAEH,cAHW,MAAM,QAGD;IAEhB;;;;OAIG;IAEH,SAJW,MAAM,KACN,MAAM,QAGH;IAEd;;;;OAIG;IAEH,sBAHW,MAAM,QAGO;IAExB;;;;;;;OAOG;IAEH,YANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAGe;IAEhC;;;;;;;;OAQG;IAEH,cAPW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,SACN,OAAO,QAGsB;IAExC;;;;;;;OAOG;IAEH,eANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAGS;IAE1B;;;;;;;;OAQG;IAEH,iBAPW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,OAAO,QAGgB;IAElC;;;;;;;OAOG;IAEH,mBANW,MAAM,UACN,MAAM,QACN,MAAM,QACN,MAAM,QAGwB;IAEzC;;;;;;;;;;;;;;;;;;OAkBG;IAEH,iBAXW,gBAAgB,GAAC,eAAe,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,WAAW,GAAC,eAAe,GAAC,UAAU,MAC1G,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAGkC;IAEnD;;;;;;OAMG;IACH,gBAAY;IAEZ;;;OAGG;IACH,kBAAc;IAEd;;;;OAIG;IACH,cAHW,KAAK,UACL,MAAM,QAMhB;IAED;;;OAGG;IACH,kBAGC;IAED;;;;;;;;;;;;;;;OAeG;IACH,gBAHW,MAAM,QAgBhB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,YACN,MAAM,gBAOhB;IAED;;;;;;;;OAQG;IACH,qBANW,MAAM,YACN,MAAM,gBAOhB;IAED;;;;;;;OAOG;IACH,iBANW,MAAM,YACN,MAAM,gBAOhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IAEH,yBAfG;QAAiC,MAAM;QAIwC,MAAM;eAAlE,MAAM;eAAK,MAAM;mBAAS,MAAM;oBAAU,MAAM;;KAMnE,GAAU,SAAS,CAOrB;CACD;;;;;+BAr2C8B,sCAAsC;yBAL5C,qBAAqB;kCAQb,sCAAsC;mBAXpD,2BAA2B;sBACxB,oBAAoB;wBAMlB,kBAAkB;yBALjB,qBAAqB;0BAavB,8BAA8B;yBAT5B,eAAe;4BAcf,wBAAwB;+BAJrB,8BAA8B;6BAChC,0BAA0B;0BAC7B,yBAAyB;6BACtB,4BAA4B;0CAEf,wBAAwB"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/video/renderer.js"],"names":[],"mappings":"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"}

package/build/video/rendertarget/canvasrendertarget.d.ts

@@ -82,6 +82,7 @@ declare class CanvasRenderTarget extends RenderTarget {
      * @ignore
      */
     destroy(renderer?: CanvasRenderer | WebGLRenderer): void;
+    #private;
 }
 import RenderTarget from "./rendertarget.ts";
 import type CanvasRenderer from "./../canvas/canvas_renderer.js";

package/build/video/rendertarget/canvasrendertarget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"canvasrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/canvasrendertarget.js"],"names":[],"mappings":";AA6EA;;;;;;GAMG;AACH;IACC;;;;;;;;;OASG;IACH,mBATW,MAAM,UACN,MAAM,eAEd;QAA4B,OAAO;QACN,WAAW;QACX,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAoCA;IAhCA;;;;;;;;;;;;;;;;;MAAkE;IASjE,YAA+B;IAUhC,aAA0D;IAGzD;;;;OAIG;IACH,cAHU,MAAM,CAGK;IAOvB;;OAEG;IACH,4CAGC;IAUD;;;OAGG;IACH,sBAFW,OAAO,QAwBjB;IAYD;;;;;;;;OAQG;IACH,gBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,SAAS,CAUrB;IAoDD;;;;OAIG;IACH,qBAFW,cAAc,GAAC,aAAa,QAyBtC;IAfC,mBAEC;IAeH;;;;OAIG;IACH,mBAHW,cAAc,GAAC,aAAa,QAyCtC;CA2BD;yBAhWwB,mBAAmB;gCAIb,gCAAgC;+BACjC,8BAA8B"}
+{"version":3,"file":"canvasrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/canvasrendertarget.js"],"names":[],"mappings":";AA6EA;;;;;;GAMG;AACH;IACC;;;;;;;;;OASG;IACH,mBATW,MAAM,UACN,MAAM,eAEd;QAA4B,OAAO;QACN,WAAW;QACX,eAAe;QACf,kBAAkB;QAClB,SAAS;KACxC,EAoCA;IAhCA;;;;;;;;;;;;;;;;;MAAkE;IASjE,YAA+B;IAUhC,aAA0D;IAGzD;;;;OAIG;IACH,cAHU,MAAM,CAGK;IAOvB;;OAEG;IACH,4CAGC;IAUD;;;OAGG;IACH,sBAFW,OAAO,QAwBjB;IAYD;;;;;;;;OAQG;IACH,gBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,GACJ,SAAS,CAUrB;IAoDD;;;;OAIG;IACH,qBAFW,cAAc,GAAC,aAAa,QAsBtC;IAWC,mBAEC;IAeH;;;;OAIG;IACH,mBAHW,cAAc,GAAC,aAAa,QAyCtC;;CA2BD;yBAvXwB,mBAAmB;gCAIb,gCAAgC;+BACjC,8BAA8B"}

package/build/video/webgl/batchers/batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/batcher.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AAEH;;;;;;;GAOG;AACH;IAgBC;;;OAGG;IACH,sBAHW,aAAa,YACb,MAAM,EAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,eAfW,aAAa,YAErB;QAA2B,UAAU,EACrC;YAAoC,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACuB,UAAU,EAAvC,OAAO;YACqB,MAAM,EAAlC,MAAM;SACd;QAAyB,MAAM,EAC/B;YAAgC,MAAM,EAA9B,MAAM;YACkB,QAAQ,EAAhC,MAAM;SACd;QAA0B,WAAW;QACV,OAAO;QACR,iBAAiB;KAC7C,QA+IA;IAzIA,QAAqB;IAGrB,iCAA2C;IAE3C;;;OAGG;IACH,oCAA8B;IAE9B;;;OAGG;IACH,oCAA8B;IA2X/B;;OAEG;IACH,gBAFW,QAAQ,GAAC,MAAM,EASzB;IAxBD;;;;;;;;;OASG;IACH,YAHU,MAAM,CAKf;IA/WC,iDAAuB;IAGxB;;;;OAIG;IACH,iCAAoB;IAEpB;;;;;OAKG;IACH,2BAAe;IAEf;;;;;OAKG;IACH,+BAAmB;IAEnB;;;OAGG;IACH,0CAAsB;IA4CtB;;;OAGG;IACH,sCAA0E;IAE1E;;;OAGG;IACH,oCAA+C;IAE/C;;;;OAIG;IACH,+CAA0B;IAE1B;;;;OAIG;IACH,iDAAuB;IAgBxB;;;;;;OAMG;IACH,oBAHU,WAAW,CAKpB;IAED;;;;;;;;;;OAUG;IACH,0BAiBC;IAyFD;;;;;;;;OAQG;IACH,2CA0BC;IAxBC,8CAAqC;IA0BvC;;;;;;;;;;;OAWG;IACH,oBAaC;IAED;;;;OAIG;IACH,kBAFW,QAAQ,QAuBlB;IAHE,uCAA4B;IAmB/B;;OAEG;IACH,oBAFW,QAAQ,GAAC,MAAM,EAIzB;IAnBD;;;;;;;;;OASG;IACH,gBAHU,QAAQ,CAKjB;IAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,mBAPW,MAAM,GAAC,MAAM,SACb,MAAM,GAAC,YAAY,SACnB,MAAM,GAAC,MAAM,eACb,OAAO,WACP,MAAM,wBA4BhB;IAiJD;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,QAOlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAqEhB;;CACD;;wBAvwB6C,sBAAsB;+BAUtC,wBAAwB;8BAC3B,2BAA2B;qBAPjC,gBAAgB;8BASV,uBAAuB;6BAVrB,0BAA0B;8BAJzB,wBAAwB;6BAGzB,oBAAoB;kCAUlB,2BAA2B"}
+{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/batcher.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AAEH;;;;;;;GAOG;AACH;IAgBC;;;OAGG;IACH,sBAHW,aAAa,YACb,MAAM,EAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,eAfW,aAAa,YAErB;QAA2B,UAAU,EACrC;YAAoC,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACuB,UAAU,EAAvC,OAAO;YACqB,MAAM,EAAlC,MAAM;SACd;QAAyB,MAAM,EAC/B;YAAgC,MAAM,EAA9B,MAAM;YACkB,QAAQ,EAAhC,MAAM;SACd;QAA0B,WAAW;QACV,OAAO;QACR,iBAAiB;KAC7C,QA+IA;IAzIA,QAAqB;IAGrB,iCAA2C;IAE3C;;;OAGG;IACH,oCAA8B;IAE9B;;;OAGG;IACH,oCAA8B;IAoY/B;;OAEG;IACH,gBAFW,QAAQ,GAAC,MAAM,EASzB;IAxBD;;;;;;;;;OASG;IACH,YAHU,MAAM,CAKf;IAxXC,iDAAuB;IAGxB;;;;OAIG;IACH,iCAAoB;IAEpB;;;;;OAKG;IACH,2BAAe;IAEf;;;;;OAKG;IACH,+BAAmB;IAEnB;;;OAGG;IACH,0CAAsB;IA4CtB;;;OAGG;IACH,sCAA0E;IAE1E;;;OAGG;IACH,oCAA+C;IAE/C;;;;OAIG;IACH,+CAA0B;IAE1B;;;;OAIG;IACH,iDAAuB;IAgBxB;;;;;;OAMG;IACH,oBAHU,WAAW,CAKpB;IAED;;;;;;;;;;OAUG;IACH,0BAiBC;IAkGD;;;;;;;;OAQG;IACH,2CA0BC;IAxBC,8CAAqC;IA0BvC;;;;;;;;;;;OAWG;IACH,oBAaC;IAED;;;;OAIG;IACH,kBAFW,QAAQ,QAuBlB;IAHE,uCAA4B;IAmB/B;;OAEG;IACH,oBAFW,QAAQ,GAAC,MAAM,EAIzB;IAnBD;;;;;;;;;OASG;IACH,gBAHU,QAAQ,CAKjB;IAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,mBAPW,MAAM,GAAC,MAAM,SACb,MAAM,GAAC,YAAY,SACnB,MAAM,GAAC,MAAM,eACb,OAAO,WACP,MAAM,wBA4BhB;IAiJD;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,QAOlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAqEhB;;CACD;;wBAhxB6C,sBAAsB;+BAUtC,wBAAwB;8BAC3B,2BAA2B;qBAPjC,gBAAgB;8BASV,uBAAuB;6BAVrB,0BAA0B;8BAJzB,wBAAwB;6BAGzB,oBAAoB;kCAUlB,2BAA2B"}

package/build/video/webgl/glshader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glshader.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/glshader.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,iBAtCW,qBAAqB,UAGrB,MAAM,GAAC,MAAM,aAGb,MAAM,cACN,MAAM,EAiKhB;IArHA;;;OAGG;IACH,IAFU,qBAAqB,CAEnB;IAEZ;;;;;OAKG;IACH,kBAHU,OAAO,CAIwD;IAEzE;;;;;OAKG;IACH,mBAHU,OAAO,CAGuB;IAExC;;;OAGG;IACH,MAFU,MAAM,GAAC,SAAS,CAEV;IAEhB;;;;OAIG;IACH,OAFU,MAAM,GAAC,SAAS,CAER;IAIlB,mBAAqB;IAKrB;;;MAAwD;IAWxD;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGK;IAEtB;;;;;;;;;OASG;IACH,QAHU,OAAO,CAGE;IAEnB;;;;;;;;;;OAUG;IACH,oBAHU,OAAO,CAGK;IAGtB,+BAA2B;IAC3B,oCAA+B;IAC/B,+BAA2B;IAG3B,mBAAwC;IAMtC,sBAAmB;IACnB,iBAAoB;IACpB,qBAAsB;IAgBzB;;;;;;OAMG;IACH,iBA0CC;IAzCA,YAGC;IACD,cAGC;IAoCF;;;;;OAKG;IACH,uBAgBC;IAED;;;;;OAKG;IACH,2BAMC;IAED;;OAEG;IACH,aAMC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,KAAK,CAcjB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,YAAY,QA4C7B;IAED;;;;;;;;;;;;;OAaG;IACH,wBAJW,qBAAqB,cACrB,MAAM,EAAE,UACR,MAAM,QAmBhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,SAFa,QAAQ,CA8BpB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,oBATW,MAAM,QACN,MAAM,oBACN,kBAAkB,EAAE,mBACpB,MAAM,GACJ,MAAM,GAAC,IAAI,CAgFvB;IAED;;;;;OAKG;IACH,gBAkCC;CACD"}
+{"version":3,"file":"glshader.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/glshader.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,iBAtCW,qBAAqB,UAGrB,MAAM,GAAC,MAAM,aAGb,MAAM,cACN,MAAM,EAiKhB;IArHA;;;OAGG;IACH,IAFU,qBAAqB,CAEnB;IAEZ;;;;;OAKG;IACH,kBAHU,OAAO,CAIwD;IAEzE;;;;;OAKG;IACH,mBAHU,OAAO,CAGuB;IAExC;;;OAGG;IACH,MAFU,MAAM,GAAC,SAAS,CAEV;IAEhB;;;;OAIG;IACH,OAFU,MAAM,GAAC,SAAS,CAER;IAIlB,mBAAqB;IAKrB;;;MAAwD;IAWxD;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGK;IAEtB;;;;;;;;;OASG;IACH,QAHU,OAAO,CAGE;IAEnB;;;;;;;;;;OAUG;IACH,oBAHU,OAAO,CAGK;IAGtB,+BAA2B;IAC3B,oCAA+B;IAC/B,+BAA2B;IAG3B,mBAAwC;IAMtC,sBAAmB;IACnB,iBAAoB;IACpB,qBAAsB;IAgBzB;;;;;;OAMG;IACH,iBA0CC;IAzCA,YAGC;IACD,cAGC;IAoCF;;;;;OAKG;IACH,uBAgBC;IAED;;;;;OAKG;IACH,2BAMC;IAED;;OAEG;IACH,aAcC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,KAAK,CAcjB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,YAAY,QA4C7B;IAED;;;;;;;;;;;;;OAaG;IACH,wBAJW,qBAAqB,cACrB,MAAM,EAAE,UACR,MAAM,QAmBhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,SAFa,QAAQ,CA8BpB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,oBATW,MAAM,QACN,MAAM,oBACN,kBAAkB,EAAE,mBACpB,MAAM,GACJ,MAAM,GAAC,IAAI,CAgFvB;IAED;;;;;OAKG;IACH,gBAkCC;CACD"}

package/build/video/webgl/utils/program.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/program.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH,0FA2CC"}
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/program.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH,0FA8CC"}

package/build/video/webgl/webgl_renderer.d.ts

@@ -24,6 +24,34 @@ export default class WebGLRenderer extends Renderer {
      */
     _effectProjectionStack: Matrix3d;
     _effectPassDepth: number;
+    /**
+     * Advanced-blend state. The six CSS modes fixed-function cannot
+     * express are composited by capturing the destination, rendering the
+     * draw to an offscreen target, and blitting that through
+     * {@link BlendEffect}. All of it is created lazily — a game that
+     * never asks for an advanced mode pays nothing.
+     *
+     * `_advancedBlendBusy` is a DEPTH, not a flag: the bracket nests
+     * inside itself (the composite blit re-enters `setBatcher`, and
+     * `toFrameTexture` does too), so a boolean would be cleared by the
+     * inner scope while the outer one is still running.
+     * @ignore
+     */
+    _advancedBlendEffect: BlendEffect | undefined;
+    /** @ignore */
+    _advancedBlendCapture: any;
+    /** @ignore */
+    _advancedBlendTarget: WebGLRenderTarget | undefined;
+    /** @ignore */
+    _advancedBlendOpen: boolean;
+    /** @ignore */
+    _advancedBlendBusy: number;
+    /** @ignore */
+    _advancedBlendParent: import("../rendertarget/rendertarget.ts").default | null | undefined;
+    /** @ignore */
+    _advancedBlendStencil: boolean;
+    /** @ignore */
+    _advancedBlendWarned: Set<any>;
     /**
      * sets or returns the shape used to join two line segments where they meet.
      * Out of the three possible values for this property: "round", "bevel", and "miter", only "round" is supported for now in WebGL
@@ -105,11 +133,26 @@ export default class WebGLRenderer extends Renderer {
      * @type {WebGLBatcher}
      */
     currentBatcher: WebGLBatcher;
+    set currentProgram(value: WebGLProgram | undefined);
     /**
-     * a reference to the current shader program used by the renderer
-     * @type {WebGLProgram}
+     * Returns the WebGLContext instance for the renderer
+     * return a reference to the system 2d Context
+     * @returns {WebGLRenderingContext} the current WebGL context
      */
-    currentProgram: WebGLProgram;
+    /**
+     * The shader program the GL context actually has bound.
+     *
+     * Backed by the CONTEXT rather than by a field on this renderer, because
+     * `GLShader` binds programs too — writing a uniform calls `useProgram`,
+     * and a freshly linked program is left bound — and it is constructed with
+     * a bare `gl`, so it cannot reach a renderer-owned cache. A field here
+     * would silently drift out of step with GL, and every batcher that
+     * compares against it (`syncProgram`, the mesh and primitive paths) would
+     * skip a rebind it actually needed, drawing a pending batch through the
+     * wrong program.
+     * @type {WebGLProgram|undefined}
+     */
+    get currentProgram(): WebGLProgram | undefined;
     /**
      * the GL texture unit currently active (`gl.activeTexture`) — global
      * GL state, so tracked once per renderer and shared by every batcher
@@ -163,7 +206,7 @@ export default class WebGLRenderer extends Renderer {
     deleteMeshGeometry(mesh: object): void;
     _lightShader: RadialGradientEffect | undefined;
     _lightAtlas: TextureAtlas | undefined;
-    _frameTexture: FrameTexture | undefined;
+    _frameTexture: any;
     _orthogonalTMXGPURenderer: OrthogonalTMXLayerGPURenderer | null | undefined;
     /**
      * Draw a TMX tile layer through whichever path the layer's `renderMode`
@@ -255,6 +298,8 @@ export default class WebGLRenderer extends Renderer {
      * @ignore
      */
     _getLightAtlas(): TextureAtlas;
+    /** @ignore */
+    _toFrameTexture(options?: {}): any;
     /**
      * The renderer-owned shared frame-capture slot, minted lazily so it has a
      * stable identity from the moment an effect is constructed — before the
@@ -283,6 +328,37 @@ export default class WebGLRenderer extends Renderer {
     invalidateTextureUnit(unit: number, except?: WebGLBatcher): void;
     /** @ignore */
     endPostEffect(renderable: any): void;
+    /**
+     * Say once, per excluded path and mode, that an advanced blend mode is
+     * falling back to `"normal"`. A silent data-dependent fallback is exactly
+     * what the advanced-blend work exists to remove, so the exclusions are
+     * loud.
+     * @param {string} what - the excluded path, named for the message
+     * @ignore
+     */
+    _warnAdvancedBlendFallback(what: string): void;
+    /**
+     * Close a pending advanced-blend bracket, if one is open and we are not
+     * already inside the bracket machinery. The safe form to call from any
+     * path that is about to disturb the destination.
+     * @ignore
+     */
+    _drainAdvancedBlend(): void;
+    /**
+     * Open an advanced-blend bracket: capture the destination, then redirect
+     * this draw into an offscreen target. Closed by {@link _closeAdvancedBlend}
+     * at the next draw, flush or clear.
+     * @returns {boolean} false when the effect could not be realized, in which
+     * case the draw proceeds unbracketed (plain source-over)
+     * @ignore
+     */
+    _openAdvancedBlend(): boolean;
+    /**
+     * Close an advanced-blend bracket: drain the offscreen, return to the
+     * parent target, and composite through {@link BlendEffect}.
+     * @ignore
+     */
+    _closeAdvancedBlend(): void;
     /**
      * Clears the gl context with the given color.
      * @param {Color|string} [color="#000000"] - CSS color.
@@ -448,15 +524,10 @@ export default class WebGLRenderer extends Renderer {
      * add a straight line from the current point to the start of the current sub-path. If the shape has already been closed or has only one point, this function does nothing
      */
     closePath(): void;
-    /**
-     * Returns the WebGLContext instance for the renderer
-     * return a reference to the system 2d Context
-     * @returns {WebGLRenderingContext} the current WebGL context
-     */
     getContext(): WebGLRenderingContext;
     /**
      * set the current blend mode for this renderer. <br>
-     * All renderers support: <br>
+     * Every renderer supports the full set: <br>
      * - "normal" : draws new content on top of the existing content <br>
      * <img src="../images/normal-blendmode.png" width="180"/> <br>
      * - "add", "additive", or "lighter" : color values are added together <br>
@@ -465,19 +536,33 @@ export default class WebGLRenderer extends Renderer {
      * <img src="../images/multiply-blendmode.png" width="180"/> <br>
      * - "screen" : pixels are inverted, multiplied, and inverted again (opposite of multiply) <br>
      * <img src="../images/screen-blendmode.png" width="180"/> <br>
-     * WebGL2 additionally supports: <br>
      * - "darken" : retains the darkest pixels of both layers <br>
      * <img src="../images/darken-blendmode.png" width="180"/> <br>
      * - "lighten" : retains the lightest pixels of both layers <br>
      * <img src="../images/lighten-blendmode.png" width="180"/> <br>
+     * - "overlay" : multiplies or screens, depending on the backdrop <br>
+     * <img src="../images/overlay-blendmode.png" width="180"/> <br>
+     * - "hard-light" : overlay with the layers swapped — a harsh spotlight <br>
+     * <img src="../images/hard-light-blendmode.png" width="180"/> <br>
+     * - "soft-light" : a diffused spotlight, gentler than hard-light <br>
+     * <img src="../images/soft-light-blendmode.png" width="180"/> <br>
+     * - "color-dodge" : brightens the backdrop to reflect the source <br>
+     * <img src="../images/color-dodge-blendmode.png" width="180"/> <br>
+     * - "color-burn" : darkens the backdrop to reflect the source <br>
+     * <img src="../images/color-burn-blendmode.png" width="180"/> <br>
+     * - "difference" : the absolute difference of the two layers <br>
+     * <img src="../images/difference-blendmode.png" width="180"/> <br>
+     * - "exclusion" : like difference, but lower in contrast <br>
+     * <img src="../images/exclusion-blendmode.png" width="180"/> <br>
      * - "none" : blending disabled — the source replaces the destination
-     * outright, alpha included (matches the WebGPU renderer's "none") <br>
-     * Other CSS blend modes ("overlay", "color-dodge", "color-burn", "hard-light", "soft-light",
-     * "difference", "exclusion") may be supported by the Canvas renderer (browser-dependent)
-     * and will always fall back to "normal" in WebGL. <br>
+     * outright, alpha included <br>
+     * A few draw types cannot honour every mode — 3D meshes, and fills using
+     * a {@link Gradient} — and fall back to "normal" with a one-time console
+     * warning. `setBlendMode` returns what it actually applied, so comparing
+     * the result against your request detects that case.
      * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
      * @param {string} [mode="normal"] - blend mode
-     * @param {boolean} [premultipliedAlpha=true] - whether textures use premultiplied alpha (affects source blend factor)
+     * @param {boolean} [premultipliedAlpha=true] - whether textures use premultiplied alpha (affects the source blend factor)
      * @returns {string} the blend mode actually applied (may differ if the requested mode is unsupported)
      */
     setBlendMode(mode?: string, premultipliedAlpha?: boolean): string;
@@ -580,24 +665,24 @@ export default class WebGLRenderer extends Renderer {
      * Reset (overrides) the renderer transformation matrix to the
      * identity one, and then apply the given transformation matrix.
      * @param {Matrix2d|Matrix3d|number} a - a matrix to transform by, or the a component to multiply the current matrix by
-     * @param {number} b - the b component to multiply the current matrix by
-     * @param {number} c - the c component to multiply the current matrix by
-     * @param {number} d - the d component to multiply the current matrix by
-     * @param {number} e - the e component to multiply the current matrix by
-     * @param {number} f - the f component to multiply the current matrix by
+     * @param {number} [b] - the b component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [c] - the c component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [d] - the d component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [e] - the e component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [f] - the f component to multiply the current matrix by; omitted when `a` is a matrix
      */
-    setTransform(a: Matrix2d | Matrix3d | number, b: number, c: number, d: number, e: number, f: number): void;
+    setTransform(a: Matrix2d | Matrix3d | number, b?: number, c?: number, d?: number, e?: number, f?: number): void;
     /**
      * Multiply given matrix into the renderer tranformation matrix
      * @see {@link WebGLRenderer.setTransform} which will reset the current transform matrix prior to performing the new transformation
      * @param {Matrix2d|Matrix3d|number} a - a matrix to transform by, or the a component to multiply the current matrix by
-     * @param {number} b - the b component to multiply the current matrix by
-     * @param {number} c - the c component to multiply the current matrix by
-     * @param {number} d - the d component to multiply the current matrix by
-     * @param {number} e - the e component to multiply the current matrix by
-     * @param {number} f - the f component to multiply the current matrix by
+     * @param {number} [b] - the b component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [c] - the c component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [d] - the d component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [e] - the e component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [f] - the f component to multiply the current matrix by; omitted when `a` is a matrix
      */
-    transform(a: Matrix2d | Matrix3d | number, b: number, c: number, d: number, e: number, f: number): void;
+    transform(a: Matrix2d | Matrix3d | number, b?: number, c?: number, d?: number, e?: number, f?: number): void;
     /**
      * A mask limits rendering elements to the shape and position of the given mask object.
      * If the drawing or rendering area is larger than the mask, only the intersecting part of the renderable will be visible.
@@ -613,14 +698,16 @@ export default class WebGLRenderer extends Renderer {
 import Renderer from "./../renderer.js";
 import RenderTargetPool from "../rendertarget/render_target_pool.js";
 import { Matrix3d } from "../../math/matrix3d.ts";
+import BlendEffect from "../effects/blendEffect.js";
+import WebGLRenderTarget from "../rendertarget/webglrendertarget.js";
 import { GLSamplerCache } from "./utils/samplercache.js";
 import { Bounds } from "../../physics/bounds.ts";
 import { WebGLBatcher } from "./batchers/batcher.js";
 import TextureCache from "./../texture/cache.js";
 import RadialGradientEffect from "../effects/radialGradient.js";
 import { TextureAtlas } from "./../texture/atlas.js";
-import { FrameTexture } from "./../texture/frametexture.js";
 import OrthogonalTMXLayerGPURenderer from "./renderers/tmxlayer/orthogonal.js";
+import { FrameTexture } from "./../texture/frametexture.js";
 import { Color } from "./../../math/color.ts";
 import type { Rect } from "./../../geometries/rectangle.ts";
 import type { RoundRect } from "./../../geometries/roundrect.ts";