melonjs 20.2.0 → 20.4.0

package/build/video/blendmodes.d.ts

@@ -1,107 +1,2 @@
-/**
- * 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

@@ -1 +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"}
+{"version":3,"file":"blendmodes.d.ts","sourceRoot":"","sources":["../../src/video/blendmodes.js"],"names":[],"mappings":"AAmDA;;;;;;GAMG;AACH,0CALW,MAAM,GACJ,OAAO,CAMnB;AAED;;;;;;GAMG;AACH,6CALW,MAAM,GACJ,MAAM,CAMlB;AAED;;;;;;;;;;;;;;GAcG;AACH,yCALW,MAAM,GACJ,MAAM,CAmBlB;AAED;;;;;;GAMG;AACH,2CALW,MAAM,GACJ,OAAO,CAUnB;AAED;;;;;;;;;;;;GAYG;AACH,wCALW,MAAM,GACJ,MAAM,CAMlB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,oCAPW,MAAM,sBACN,OAAO,GACL;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,GAAC,SAAS,CAyC/E;AAjMD;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,4CAeE"}

package/build/video/buffer/index.d.ts

@@ -1,40 +1,2 @@
-/**
- * A renderer-agnostic index buffer.
- * Manages a typed array of vertex indices for indexed drawing.
- * {@link WebGLIndexBuffer} extends this with GL-specific bind/upload operations.
- * @ignore
- */
-export default class IndexBuffer {
-    /**
-     * @param {number} maxIndices - maximum number of indices this buffer can hold
-     * @param {boolean} [useUint32=false] - use Uint32 indices instead of Uint16
-     */
-    constructor(maxIndices: number, useUint32?: boolean);
-    data: Uint16Array<ArrayBuffer> | Uint32Array<ArrayBuffer>;
-    /**
-     * the current number of indices in the buffer
-     * @type {number}
-     */
-    length: number;
-    /**
-     * Fill the buffer with a repeating quad index pattern [0,1,2, 2,1,3, 4,5,6, ...]
-     * @param {number} maxQuads - number of quads to generate indices for
-     */
-    fillQuadPattern(maxQuads: number): void;
-    /**
-     * Reset the index count
-     */
-    clear(): void;
-    /**
-     * Add indices to the buffer, rebased by the given vertex offset
-     * @param {number[]} indices - source indices to add
-     * @param {number} vertexOffset - value to add to each index
-     */
-    add(indices: number[], vertexOffset: number): void;
-    /**
-     * Add pre-computed absolute indices to the buffer (no rebasing)
-     * @param {number[]} indices - absolute index values to add
-     */
-    addRaw(indices: number[]): void;
-}
+
 //# sourceMappingURL=index.d.ts.map

package/build/video/buffer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/video/buffer/index.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;IACC;;;OAGG;IACH,wBAHW,MAAM,cACN,OAAO,EAYjB;IATA,0DAE8B;IAE9B;;;OAGG;IACH,QAFU,MAAM,CAED;IAGhB;;;OAGG;IACH,0BAFW,MAAM,QAYhB;IAED;;OAEG;IACH,cAEC;IAED;;;;OAIG;IACH,aAHW,MAAM,EAAE,gBACR,MAAM,QAOhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAOlB;CACD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/video/buffer/index.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;IACC;;;OAGG;IACH,wBAHW,MAAM,cACN,OAAO,EAYjB;IATA,0DAE8B;IAE9B;;;OAGG;IACH,QAFU,MAAM,CAED;IAGhB;;;OAGG;IACH,0BAFW,MAAM,QAYhB;IAED;;OAEG;IACH,cAEC;IAED;;;;OAIG;IACH,aAHW,MAAM,EAAE,gBACR,MAAM,QAOhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAOlB;CACD"}

package/build/video/buffer/vertex.d.ts

@@ -1,83 +1,2 @@
-/**
- * A fixed-size vertex array buffer for batching vertex data.
- * Renderer-agnostic — stores vertex data in typed arrays (Float32/Uint32).
- * Batchers must check isFull() and flush before the buffer overflows.
- * @ignore
- */
-export default class VertexArrayBuffer {
-    constructor(vertexSize: any, maxVertex: any);
-    vertexSize: any;
-    maxVertex: any;
-    vertexCount: number;
-    buffer: ArrayBuffer;
-    bufferF32: Float32Array<ArrayBuffer>;
-    bufferU32: Uint32Array<ArrayBuffer>;
-    bufferU8: Uint8Array<ArrayBuffer>;
-    /**
-     * clear the vertex array buffer
-     * @ignore
-     */
-    clear(): void;
-    /**
-     * return true if full
-     * @ignore
-     */
-    isFull(vertex: any): boolean;
-    /**
-     * push a new vertex to the buffer
-     * @param {number} x - x position
-     * @param {number} y - y position
-     * @param {number} z - z position (per-renderable depth; 0 under ortho)
-     * @param {number} u - texture U coordinate (or aNormal.x for primitives)
-     * @param {number} v - texture V coordinate (or aNormal.y for primitives)
-     * @param {number} tint - tint color in UINT32 (argb) format
-     * @param {number} [textureId] - texture unit index for multi-texture batching
-     * @param {number} [normalTextureId] - paired normal-map texture unit index, or `-1` for unlit quads
-     * @ignore
-     */
-    push(x: number, y: number, z: number, u: number, v: number, tint: number, textureId?: number, normalTextureId?: number): this;
-    /**
-     * push a new vertex with all-float data to the buffer
-     * @param {ArrayLike<number>} data - float values for one vertex
-     * @param {number} srcOffset - start index in the source data
-     * @param {number} count - number of floats to copy (should equal vertexSize)
-     * @ignore
-     */
-    pushFloats(data: ArrayLike<number>, srcOffset: number, count: number): this;
-    /**
-     * push a new vertex to the buffer (mesh format: x, y, z, u, v, tint).
-     * Color is unpacked from the ARGB Uint32 input into 4 normalized
-     * `[0, 1]` floats — the mesh batcher's `aColor` attribute is
-     * `FLOAT × 4` rather than `UNSIGNED_BYTE × 4` to avoid NaN-pattern
-     * bit values getting canonicalized on Metal-backed WebGL drivers.
-     * See `mesh_batcher.init` for the rationale.
-     * @ignore
-     */
-    pushMesh(x: any, y: any, z: any, u: any, v: any, tint: any): this;
-    /**
-     * push a new lit-mesh vertex (mesh format + a world-space normal):
-     * x, y, z, u, v, tint, nx, ny, nz. Used by the lit mesh batcher, whose
-     * vertex layout is 12 floats (the 9 of {@link pushMesh} plus `aNormal`).
-     * @ignore
-     */
-    pushMeshLit(x: any, y: any, z: any, u: any, v: any, tint: any, nx: any, ny: any, nz: any): this;
-    /**
-     * return a reference to the data in Float32 format
-     * @ignore
-     */
-    toFloat32(begin: any, end: any): Float32Array<ArrayBuffer>;
-    /**
-     * return a reference to the data in Uint32 format
-     * @ignore
-     */
-    toUint32(begin: any, end: any): Uint32Array<ArrayBuffer>;
-    /**
-     * return a byte-view reference to the data — use this for `gl.bufferData`
-     * uploads to avoid the NaN-canonicalization that some drivers perform
-     * on Float32 uploads of the same backing buffer (see the constructor's
-     * `bufferU8` comment).
-     * @ignore
-     */
-    toUint8(byteBegin: any, byteEnd: any): Uint8Array<ArrayBuffer>;
-}
+
 //# sourceMappingURL=vertex.d.ts.map

package/build/video/buffer/vertex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vertex.d.ts","sourceRoot":"","sources":["../../../src/video/buffer/vertex.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;IACC,6CAyBC;IAvBA,gBAA4B;IAE5B,eAA0B;IAE1B,oBAAoB;IAGpB,oBAEC;IAED,qCAA8C;IAC9C,oCAA6C;IAU7C,kCAA2C;IAG5C;;;OAGG;IACH,cAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;;;;;;;;OAWG;IACH,QAVW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,cACN,MAAM,oBACN,MAAM,QA6BhB;IAED;;;;;;OAMG;IACH,iBALW,SAAS,CAAC,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,QAahB;IAED;;;;;;;;OAQG;IACH,kEAgBC;IAED;;;;;OAKG;IACH,gGAoBC;IAED;;;OAGG;IACH,2DAMC;IAED;;;OAGG;IACH,yDAMC;IAED;;;;;;OAMG;IACH,+DAMC;CACD"}
+{"version":3,"file":"vertex.d.ts","sourceRoot":"","sources":["../../../src/video/buffer/vertex.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;IACC,6CAyBC;IAvBA,gBAA4B;IAE5B,eAA0B;IAE1B,oBAAoB;IAGpB,oBAEC;IAED,qCAA8C;IAC9C,oCAA6C;IAU7C,kCAA2C;IAG5C;;;;OAIG;IACH,cAEC;IAED;;;;OAIG;IACH,6BAEC;IAED;;;;;;;;;;;;OAYG;IACH,QAXW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,cACN,MAAM,oBACN,MAAM,QA8BhB;IAED;;;;;;;OAOG;IACH,iBANW,SAAS,CAAC,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,QAchB;IAED;;;;;;;;;OASG;IACH,kEAgBC;IAED;;;;;;OAMG;IACH,gGAoBC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,yDAMC;IAED;;;;;;;OAOG;IACH,+DAMC;CACD"}

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

@@ -16,8 +16,6 @@
 export default class CanvasRenderer extends Renderer {
     cache: TextureCache;
     onGameReset: () => void;
-    _lightCache: WeakMap<object, any> | undefined;
-    _frameTexture: any;
     /**
      * set/change the current projection matrix.
      * In Canvas mode, this applies the ortho projection as a canvas 2D transform
@@ -27,7 +25,7 @@ export default class CanvasRenderer extends Renderer {
     setProjection(matrix: Matrix3d): void;
     /**
      * set the current blend mode for this renderer. <br>
-     * Every renderer supports the full set: <br>
+     * This renderer supports every mode below except `"none"`: <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>
@@ -55,7 +53,10 @@ export default class CanvasRenderer extends Renderer {
      * - "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>
+     * outright, alpha included. **GPU backends only**: there is no
+     * `globalCompositeOperation` that disables blending for the drawn area
+     * alone (`"copy"` clears the rest of the surface), so this renderer falls
+     * back to "normal" and reports it <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
@@ -123,9 +124,6 @@ export default class CanvasRenderer extends Renderer {
      * @param {Mesh} mesh - a Mesh renderable or compatible object
      */
     drawMesh(mesh: Mesh): void;
-    _meshColorCanvas: HTMLCanvasElement | OffscreenCanvas | undefined;
-    _meshColorCtx: RenderingContext | OffscreenCanvasRenderingContext2D | null | undefined;
-    _meshSortBuf: Float64Array<ArrayBuffer> | undefined;
     /**
      * starts a new path by emptying the list of sub-paths. Call this method when you want to create a new path
      * @example
@@ -194,9 +192,9 @@ export default class CanvasRenderer extends Renderer {
      * @param {number} y - The y axis of the coordinate for the rectangle starting point.
      * @param {number} width - The rectangle's width.
      * @param {number} height - The rectangle's height.
-     * @param {number} radius - The corner radius.
+     * @param {number} radii - The corner radius.
      */
-    roundRect(x: number, y: number, width: number, height: number, radii: any): void;
+    roundRect(x: number, y: number, width: number, height: number, radii: number): void;
     /**
      * stroke the given shape or the current defined path
      * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} [shape] - a shape object to stroke
@@ -281,8 +279,6 @@ export default class CanvasRenderer extends Renderer {
      * Draw a point at the specified coordinates
      * @param {number} x
      * @param {number} y
-     * @param {number} width
-     * @param {number} height
      */
     fillPoint(x: number, y: number): void;
     /**
@@ -290,10 +286,6 @@ export default class CanvasRenderer extends Renderer {
      * @returns {number} global alpha value
      */
     getGlobalAlpha(): number;
-    /**
-     * @ignore
-     */
-    set lineJoin(value: string);
     /**
      * sets or returns the shape used to join two line segments where they meet.
      * There are three possible values for this property: "round", "bevel", and "miter"
@@ -323,16 +315,6 @@ export default class CanvasRenderer extends Renderer {
      * @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;
-    /**
-     * 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.
-     * (Note Mask are not preserved through renderer context save and restore and need so be manually cleared)
-     * @see CanvasRenderer#clearMask
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse} [mask] - the shape defining the mask to be applied
-     * @param {boolean} [invert=false] - either the given shape should define what is visible (default) or the opposite
-     */
-    setMask(mask?: Rect | RoundRect | Polygon | Line | Ellipse, invert?: boolean): void;
-    _maskInvertOuterAdded: boolean | undefined;
 }
 import Renderer from "./../renderer.js";
 import TextureCache from "./../texture/cache.js";

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

@@ -3,19 +3,19 @@
  * Commonly used for background defocus, depth-of-field simulation,
  * or UI backdrop blur.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // moderate blur
- * mySprite.shader = new BlurEffect(renderer, { strength: 2.0 });
+ * mySprite.addPostEffect(new BlurEffect(renderer, { strength: 2.0 }));
  */
 export default class BlurEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.strength=1.0] - blur strength in texels
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         strength?: number | undefined;
         textureSize?: number[] | undefined;
     });

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

@@ -1 +1 @@
-{"version":3,"file":"blur.d.ts","sourceRoot":"","sources":["../../../src/video/effects/blur.js"],"names":[],"mappings":"AA4BA;;;;;;;;;GASG;AACH;IACC;;;;;OAKG;IACH,qCAHG;QAAyB,QAAQ;QACN,WAAW;KACxC,EA8BA;IALA,iBAAuC;IAOxC;;;OAGG;IACH,sBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA7FwB,mBAAmB"}
+{"version":3,"file":"blur.d.ts","sourceRoot":"","sources":["../../../src/video/effects/blur.js"],"names":[],"mappings":"AA4BA;;;;;;;;;GASG;AACH;IACC;;;;;OAKG;IACH,sBALW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,QAAQ;QACN,WAAW;KACxC,EA8BA;IALA,iBAAuC;IAOxC;;;OAGG;IACH,sBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA7FwB,mBAAmB"}

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

@@ -3,22 +3,22 @@
  * chromatic aberration (color fringe) effect. Commonly used for
  * impact feedback, glitch effects, or damage indicators.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // subtle chromatic aberration
- * mySprite.shader = new ChromaticAberrationEffect(renderer, { offset: 2.0 });
+ * mySprite.addPostEffect(new ChromaticAberrationEffect(renderer, { offset: 2.0 }));
  * @example
  * // strong glitch effect
- * mySprite.shader = new ChromaticAberrationEffect(renderer, { offset: 5.0 });
+ * mySprite.addPostEffect(new ChromaticAberrationEffect(renderer, { offset: 5.0 }));
  */
 export default class ChromaticAberrationEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.offset=3.0] - channel offset in texels
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         offset?: number | undefined;
         textureSize?: number[] | undefined;
     });

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

@@ -1 +1 @@
-{"version":3,"file":"chromaticAberration.d.ts","sourceRoot":"","sources":["../../../src/video/effects/chromaticAberration.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;OAKG;IACH,qCAHG;QAAyB,MAAM;QACJ,WAAW;KACxC,EAuBA;IALA,eAAmC;IAOpC;;;OAGG;IACH,kBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAlFwB,mBAAmB"}
+{"version":3,"file":"chromaticAberration.d.ts","sourceRoot":"","sources":["../../../src/video/effects/chromaticAberration.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;OAKG;IACH,sBALW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,MAAM;QACJ,WAAW;KACxC,EAuBA;IALA,eAAmC;IAOpC;;;OAGG;IACH,kBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAlFwB,mBAAmB"}

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

@@ -2,36 +2,26 @@
  * A shader effect that applies a 4x4 color transformation matrix.
  * Provides chainable color adjustment methods that automatically update the GPU uniform.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // desaturate a sprite
- * mySprite.shader = new ColorMatrixEffect(renderer).saturate(0.0);
+ * mySprite.addPostEffect(new ColorMatrixEffect(renderer).saturate(0.0));
  * @example
  * // combine brightness + contrast on a camera
- * camera.shader = new ColorMatrixEffect(renderer).brightness(1.3).contrast(1.5);
+ * camera.addPostEffect(new ColorMatrixEffect(renderer).brightness(1.3).contrast(1.5));
  * @example
  * // update dynamically
  * effect.reset().brightness(1.5).saturate(0.5);
  */
 export default class ColorMatrixEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {ColorMatrix} [options.matrix] - an initial color matrix. Defaults to identity.
      */
-    constructor(renderer: any, options?: {
+    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,qCAFG;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/desaturate.d.ts

@@ -2,21 +2,21 @@
  * A shader effect that desaturates (grayscales) the sprite.
  * Commonly used for disabled states, death effects, or petrification.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // full grayscale
- * mySprite.shader = new DesaturateEffect(renderer);
+ * mySprite.addPostEffect(new DesaturateEffect(renderer));
  * @example
  * // partial desaturation (50%)
- * mySprite.shader = new DesaturateEffect(renderer, { intensity: 0.5 });
+ * mySprite.addPostEffect(new DesaturateEffect(renderer, { intensity: 0.5 }));
  */
 export default class DesaturateEffect extends ColorMatrixEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.intensity=1.0] - desaturation intensity (0.0 = full color, 1.0 = grayscale)
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         intensity?: number | undefined;
     });
     intensity: number;

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

@@ -1 +1 @@
-{"version":3,"file":"desaturate.d.ts","sourceRoot":"","sources":["../../../src/video/effects/desaturate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IACC;;;;OAIG;IACH,qCAFG;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAnC6B,kBAAkB"}
+{"version":3,"file":"desaturate.d.ts","sourceRoot":"","sources":["../../../src/video/effects/desaturate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAnC6B,kBAAkB"}

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

@@ -4,24 +4,24 @@
  * `progress` value increases from 0 to 1.
  * Commonly used for death, spawn, or teleport effects.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // create a dissolve effect
  * const dissolve = new DissolveEffect(renderer);
- * mySprite.shader = dissolve;
+ * mySprite.addPostEffect(dissolve);
  *
  * // animate the dissolve (0 = fully visible, 1 = fully dissolved)
  * dissolve.setProgress(0.5);
  */
 export default class DissolveEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.progress=0.0] - dissolve progress (0.0 = visible, 1.0 = dissolved)
      * @param {number[]} [options.edgeColor=[1.0, 0.5, 0.0]] - color of the dissolve edge
      * @param {number} [options.edgeWidth=0.1] - width of the colored edge (0.0–1.0)
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         progress?: number | undefined;
         edgeColor?: number[] | undefined;
         edgeWidth?: number | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"dissolve.d.ts","sourceRoot":"","sources":["../../../src/video/effects/dissolve.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;OAMG;IACH,qCAJG;QAAyB,QAAQ;QACN,SAAS;QACX,SAAS;KACpC,EA0DA;IAPA,iBAAuC;IASxC;;;OAGG;IACH,mBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAIlB;CACD;yBAhKwB,mBAAmB"}
+{"version":3,"file":"dissolve.d.ts","sourceRoot":"","sources":["../../../src/video/effects/dissolve.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;OAMG;IACH,sBANW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,QAAQ;QACN,SAAS;QACX,SAAS;KACpC,EA0DA;IAPA,iBAAuC;IASxC;;;OAGG;IACH,mBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAIlB;CACD;yBAhKwB,mBAAmB"}