melonjs 19.9.1 → 20.0.0

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

@@ -15,12 +15,9 @@
  */
 export default class CanvasRenderer extends Renderer {
     cache: TextureCache;
+    onGameReset: () => void;
     _lightCache: WeakMap<object, any> | undefined;
     _frameTexture: any;
-    /**
-     * Reset the canvas transform to identity
-     */
-    resetTransform(): void;
     /**
      * set/change the current projection matrix.
      * In Canvas mode, this applies the ortho projection as a canvas 2D transform
@@ -101,6 +98,27 @@ export default class CanvasRenderer extends Renderer {
      * @see CanvasRenderer#createPattern
      */
     drawPattern(pattern: CanvasPattern, x: number, y: number, width: number, height: number): void;
+    /**
+     * Draw a textured triangle mesh.
+     * Uses per-triangle affine texture mapping with back-to-front depth
+     * sorting (painter's algorithm) and optional backface culling.
+     * Note: the painter's algorithm works well for convex shapes but
+     * may produce visual artifacts with concave or self-overlapping
+     * geometry (e.g. a torus), as Canvas 2D has no hardware depth
+     * buffer. Use the WebGL renderer for correct depth ordering on
+     * complex meshes.
+     *
+     * Multi-material meshes (`mesh.vertexColors` present) render here
+     * via per-triangle solid fill — each triangle's three vertices
+     * share one baked material color, so we read `vertexColors[v0]`
+     * and use it as the triangle's fillStyle, multiplied by
+     * `currentTint`. The single shared texture (typically the 1×1
+     * white-pixel fallback for Kd-only models) is bypassed in that
+     * path. Canvas can't do per-material textures; if you need that,
+     * use the WebGL 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;
@@ -301,18 +319,6 @@ export default class CanvasRenderer extends Renderer {
      * @param {number} f - the f component to multiply the current matrix by
      */
     transform(a: Matrix2d | Matrix3d | number, b: number, c: number, d: number, e: number, f: number): void;
-    /**
-     * clip the given region from the original canvas. Once a region is clipped,
-     * all future drawing will be limited to the clipped region.
-     * You can however save the current region using the save(),
-     * and restore it (with the restore() method) any time in the future.
-     * (<u>this is an experimental feature !</u>)
-     * @param {number} x
-     * @param {number} y
-     * @param {number} width
-     * @param {number} height
-     */
-    clipRect(x: number, y: number, width: number, height: 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/{webgl/effects → effects}/blur.d.ts

@@ -15,7 +15,7 @@ export default class BlurEffect extends ShaderEffect {
      * @param {number} [options.strength=1.0] - blur strength in texels
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         strength?: number | undefined;
         textureSize?: number[] | undefined;
     });
@@ -32,5 +32,5 @@ export default class BlurEffect extends ShaderEffect {
      */
     setTextureSize(width: number, height: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=blur.d.ts.map

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

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

package/build/video/{webgl/effects → effects}/chromaticAberration.d.ts

@@ -18,7 +18,7 @@ export default class ChromaticAberrationEffect extends ShaderEffect {
      * @param {number} [options.offset=3.0] - channel offset in texels
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         offset?: number | undefined;
         textureSize?: number[] | undefined;
     });
@@ -35,5 +35,5 @@ export default class ChromaticAberrationEffect extends ShaderEffect {
      */
     setTextureSize(width: number, height: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=chromaticAberration.d.ts.map

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

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

package/build/video/{webgl/effects → effects}/colorMatrix.d.ts

@@ -19,7 +19,7 @@ export default class ColorMatrixEffect extends ShaderEffect {
      * @param {object} [options] - effect options
      * @param {ColorMatrix} [options.matrix] - an initial color matrix. Defaults to identity.
      */
-    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         matrix?: ColorMatrix | undefined;
     });
     /**
@@ -87,6 +87,6 @@ export default class ColorMatrixEffect extends ShaderEffect {
      */
     transform(...args: number[]): this;
 }
-import ShaderEffect from "../shadereffect.js";
-import { ColorMatrix } from "../../../math/color_matrix.ts";
+import ShaderEffect from "./shadereffect.js";
+import { ColorMatrix } from "../../math/color_matrix.ts";
 //# sourceMappingURL=colorMatrix.d.ts.map

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

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

package/build/video/{webgl/effects → effects}/desaturate.d.ts

@@ -16,7 +16,7 @@ export default class DesaturateEffect extends ColorMatrixEffect {
      * @param {object} [options] - effect options
      * @param {number} [options.intensity=1.0] - desaturation intensity (0.0 = full color, 1.0 = grayscale)
      */
-    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         intensity?: number | undefined;
     });
     intensity: number;

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

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

package/build/video/{webgl/effects → effects}/dissolve.d.ts

@@ -21,7 +21,7 @@ export default class DissolveEffect extends ShaderEffect {
      * @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: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         progress?: number | undefined;
         edgeColor?: number[] | undefined;
         edgeWidth?: number | undefined;
@@ -38,5 +38,5 @@ export default class DissolveEffect extends ShaderEffect {
      */
     setEdgeColor(color: number[]): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=dissolve.d.ts.map

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

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

package/build/video/{webgl/effects → effects}/dropShadow.d.ts

@@ -23,7 +23,7 @@ export default class DropShadowEffect extends ShaderEffect {
      * @param {number} [options.opacity=0.5] - shadow opacity (0.0–1.0)
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         offsetX?: number | undefined;
         offsetY?: number | undefined;
         color?: number[] | undefined;
@@ -43,5 +43,5 @@ export default class DropShadowEffect extends ShaderEffect {
      */
     setTextureSize(width: number, height: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=dropShadow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dropShadow.d.ts","sourceRoot":"","sources":["../../../src/video/effects/dropShadow.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;;;OAQG;IACH,qCANG;QAAyB,OAAO;QACP,OAAO;QACL,KAAK;QACP,OAAO;QACL,WAAW;KACxC,EA0CA;IAED;;;;OAIG;IACH,aAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAvHwB,mBAAmB"}

package/build/video/{webgl/effects → effects}/flash.d.ts

@@ -26,7 +26,7 @@ export default class FlashEffect extends ShaderEffect {
      * @param {number[]} [options.color=[1.0, 1.0, 1.0]] - flash color as [r, g, b] (0.0–1.0)
      * @param {number} [options.intensity=0.0] - initial flash intensity (0.0–1.0)
      */
-    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         color?: number[] | undefined;
         intensity?: number | undefined;
     });
@@ -42,5 +42,5 @@ export default class FlashEffect extends ShaderEffect {
      */
     setColor(color: number[]): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=flash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flash.d.ts","sourceRoot":"","sources":["../../../src/video/effects/flash.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACC;;;;;OAKG;IACH,qCAHG;QAA2B,KAAK;QACP,SAAS;KACpC,EAkBA;IAJA,kBAAyC;IAM1C;;;OAGG;IACH,oBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBA/EwB,mBAAmB"}

package/build/video/{webgl/effects → effects}/glow.d.ts

@@ -20,7 +20,7 @@ export default class GlowEffect extends ShaderEffect {
      * @param {number} [options.intensity=1.0] - glow brightness multiplier
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         color?: number[] | undefined;
         width?: number | undefined;
         intensity?: number | undefined;
@@ -44,5 +44,5 @@ export default class GlowEffect extends ShaderEffect {
      */
     setTextureSize(width: number, height: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=glow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"glow.d.ts","sourceRoot":"","sources":["../../../src/video/effects/glow.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;;;OAOG;IACH,qCALG;QAA2B,KAAK;QACP,KAAK;QACL,SAAS;QACP,WAAW;KACxC,EAsCA;IANA,kBAAyC;IAQ1C;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAtHwB,mBAAmB"}

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

@@ -0,0 +1,18 @@
+/**
+ * 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

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

package/build/video/{webgl/effects → effects}/hologram.d.ts

@@ -18,7 +18,7 @@ export default class HologramEffect extends ShaderEffect {
      * @param {number[]} [options.color=[0.1, 0.7, 1.0]] - hologram tint color [r, g, b]
      * @param {number} [options.intensity=0.5] - effect intensity (0.0–1.0)
      */
-    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         color?: number[] | undefined;
         intensity?: number | undefined;
     });
@@ -28,5 +28,5 @@ export default class HologramEffect extends ShaderEffect {
      */
     setColor(color: number[]): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=hologram.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hologram.d.ts","sourceRoot":"","sources":["../../../src/video/effects/hologram.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;OAKG;IACH,qCAHG;QAA2B,KAAK;QACP,SAAS;KACpC,EAyBA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBA7EwB,mBAAmB"}

package/build/video/{webgl/effects → effects}/invert.d.ts

@@ -15,7 +15,7 @@ export default class InvertEffect extends ColorMatrixEffect {
      * @param {object} [options] - effect options
      * @param {number} [options.intensity=1.0] - inversion intensity (0.0 = original, 1.0 = fully inverted)
      */
-    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         intensity?: number | undefined;
     });
     intensity: number;

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

@@ -0,0 +1 @@
+{"version":3,"file":"invert.d.ts","sourceRoot":"","sources":["../../../src/video/effects/invert.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IACC;;;;OAIG;IACH,qCAFG;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAlC6B,kBAAkB"}

package/build/video/{webgl/effects → effects}/outline.d.ts

@@ -23,7 +23,7 @@ export default class OutlineEffect extends ShaderEffect {
      * @param {number} [options.width=1.0] - outline width in pixels
      * @param {number[]} [options.textureSize] - texture dimensions [width, height] (defaults to renderer size)
      */
-    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         color?: number[] | undefined;
         width?: number | undefined;
         textureSize?: number[] | undefined;
@@ -45,5 +45,5 @@ export default class OutlineEffect extends ShaderEffect {
      */
     setTextureSize(width: number, height: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=outline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../../src/video/effects/outline.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;;;;OAMG;IACH,qCAJG;QAA2B,KAAK;QACP,KAAK;QACH,WAAW;KACxC,EAsCA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA1HwB,mBAAmB"}

package/build/video/{webgl/effects → effects}/pixelate.d.ts

@@ -17,7 +17,7 @@ export default class PixelateEffect extends ShaderEffect {
      * @param {number} [options.size=4.0] - pixel size in texels (higher = more pixelated)
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         size?: number | undefined;
         textureSize?: number[] | undefined;
     });
@@ -34,5 +34,5 @@ export default class PixelateEffect extends ShaderEffect {
      */
     setTextureSize(width: number, height: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=pixelate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pixelate.d.ts","sourceRoot":"","sources":["../../../src/video/effects/pixelate.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;GAWG;AACH;IACC;;;;;OAKG;IACH,qCAHG;QAAyB,IAAI;QACF,WAAW;KACxC,EAoBA;IALA,aAA+B;IAOhC;;;OAGG;IACH,cAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA3EwB,mBAAmB"}

package/build/video/{webgl/effects → effects}/radialGradient.d.ts

@@ -1,6 +1,6 @@
 /**
  * additional import for TypeScript
- * @import { Color } from "../../../math/color.ts";
+ * @import { Color } from "../../math/color.ts";
  * @import { default as WebGLRenderer } from "../webgl_renderer.js";
  */
 /**
@@ -99,7 +99,6 @@ export default class RadialGradientEffect extends ShaderEffect {
      */
     setIntensity(intensity: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
-import type { Color } from "../../../math/color.ts";
-import type { default as WebGLRenderer } from "../webgl_renderer.js";
+import ShaderEffect from "./shadereffect.js";
+import type { Color } from "../../math/color.ts";
 //# sourceMappingURL=radialGradient.d.ts.map

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

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

package/build/video/{webgl/effects → effects}/scanline.d.ts

@@ -22,7 +22,7 @@ export default class ScanlineEffect extends ShaderEffect {
      * @param {number} [options.curvature=0.0] - barrel distortion strength (0.0 = flat, 0.02 = subtle CRT curve)
      * @param {number} [options.vignetteStrength=0.0] - edge darkening strength (0.0 = none, 0.3 = subtle)
      */
-    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         opacity?: number | undefined;
         curvature?: number | undefined;
         vignetteStrength?: number | undefined;
@@ -43,5 +43,5 @@ export default class ScanlineEffect extends ShaderEffect {
      */
     setVignetteStrength(strength: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=scanline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scanline.d.ts","sourceRoot":"","sources":["../../../src/video/effects/scanline.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;;;OAMG;IACH,qCAJG;QAAyB,OAAO;QACP,SAAS;QACT,gBAAgB;KAC3C,EAyCA;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,8BAFW,MAAM,QAIhB;CACD;yBAnIwB,mBAAmB"}

package/build/video/{webgl/effects → effects}/sepia.d.ts

@@ -14,7 +14,7 @@ export default class SepiaEffect extends ColorMatrixEffect {
      * @param {object} [options] - effect options
      * @param {number} [options.intensity=1.0] - sepia intensity (0.0 = original, 1.0 = full sepia)
      */
-    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+    constructor(renderer: any, options?: {
         intensity?: number | undefined;
     });
     intensity: number;

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

@@ -0,0 +1 @@
+{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../src/video/effects/sepia.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IACC;;;;OAIG;IACH,qCAFG;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAjC6B,kBAAkB"}

package/build/video/{webgl → effects}/shadereffect.d.ts

@@ -2,9 +2,90 @@
  * 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.
- * In Canvas mode, the shader is silently disabled (all methods become no-ops).
+ *
+ * ## 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
+ * mySprite.shader = 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.shader.setUniform("uStrength", 0.5); // sets either backend
+ * @example
  * // create a grayscale effect
  * mySprite.shader = new ShaderEffect(renderer, `
  *     vec4 apply(vec4 color, vec2 uv) {
@@ -44,13 +125,21 @@
  */
 export default class ShaderEffect {
     /**
-     * @param {WebGLRenderer|CanvasRenderer} renderer - the current renderer instance
-     * @param {string} fragmentBody - GLSL code containing a `vec4 apply(vec4 color, vec2 uv)` function
-     *   that receives the sampled pixel color and UV coordinates, and returns the modified color.
-     *   You can declare additional `uniform` variables before the `apply()` function.
-     * @param {string} [precision=auto detected] - float precision ('lowp', 'mediump' or 'highp')
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {string|{glsl?: string, wgsl?: string}} body - the effect body:
+     *   a GLSL string (containing a `vec4 apply(vec4 color, vec2 uv)` function —
+     *   unchanged from previous versions), or an object carrying one body per
+     *   shading language (`glsl` and/or `wgsl`, the WGSL body defining
+     *   `fn apply(color : vec4f, uv : vec2f) -> vec4f`). The renderer picks the
+     *   body matching its {@link Renderer#shaderLanguage}; when no matching body
+     *   exists the effect warns once and stays disabled (`enabled === false`),
+     *   exactly like the Canvas renderer.
+     * @param {string} [precision=auto detected] - float precision ('lowp', 'mediump' or 'highp'), GLSL only
      */
-    constructor(renderer: WebGLRenderer | CanvasRenderer, fragmentBody: string, precision?: string);
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, body: string | {
+        glsl?: string;
+        wgsl?: string;
+    }, precision?: string);
     /**
      * whether this effect is active (false in Canvas mode, false after
      * {@link destroy}, and false while the WebGL context is suspended
@@ -89,14 +178,25 @@ export default class ShaderEffect {
      */
     _renderer: any;
     /**
-     * the construction "recipe" (fragment body + precision), kept so
+     * the construction "recipe" (body + precision), kept VERBATIM so
      * {@link clone} can compile an independent copy. Stored before the
-     * Canvas-mode early return so cloning behaves consistently there too.
+     * disabled-stub early return so cloning behaves consistently there too.
      * @ignore
      */
-    _fragmentBody: string;
+    _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
@@ -108,16 +208,11 @@ export default class ShaderEffect {
         repeat: string;
     }>;
     /** @ignore */
-    _hasNoiseUV: boolean | undefined;
+    _hasNoiseUV: any;
     /** @ignore */
     _shader: GLShader | 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)
-     * @ignore
-     */
-    _extraTextures: Map<any, any> | undefined;
+    /** @ignore */
+    wgslRealization: WGSLEffectRealization | undefined;
     /** @private */
     private _onContextLost;
     _enabledBeforeSuspend: boolean | undefined;
@@ -153,6 +248,20 @@ 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
@@ -170,14 +279,12 @@ export default class ShaderEffect {
     _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. Captures are NPOT (canvas-sized), which
-     * WebGL 1 cannot repeat — warn once and keep the clamp there. The unit is
-     * force-activated first: the batcher's bind may have been skipped as
-     * redundant while the GL active unit points elsewhere.
+     * 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;
-    _captureWrapWarned: boolean | undefined;
     /**
      * 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,
@@ -192,7 +299,7 @@ export default class ShaderEffect {
      * drawable source. No-op in Canvas mode.
      * @param {string} name - the `sampler2D` uniform name declared in the fragment
      * @param {Texture2d|HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} image - the texture: an engine texture asset, or a raw drawable source
-     * @param {"repeat"|"repeat-x"|"repeat-y"|"no-repeat"} [repeat="no-repeat"] - wrap mode; use `"repeat"` for a tiled/scrolled texture (power-of-two size under WebGL 1)
+     * @param {"repeat"|"repeat-x"|"repeat-y"|"no-repeat"} [repeat="no-repeat"] - wrap mode; use `"repeat"` for a tiled/scrolled texture
      * @returns {ShaderEffect} this effect for chaining
      * @example
      * // "water": distort the sprite by a static noise texture scrolled over time
@@ -269,6 +376,7 @@ export default class ShaderEffect {
      */
     destroy(): void;
 }
-import GLShader from "./glshader.js";
+import GLShader from "../webgl/glshader.js";
+import WGSLEffectRealization from "./wgsl_realization.js";
 import Texture2d from "../texture/texture2d.ts";
 //# sourceMappingURL=shadereffect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shadereffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shadereffect.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4HG;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;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,SARa,YAAY,CAqDxB;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;qBA34BoB,sBAAsB;kCAET,uBAAuB;sBAHnC,yBAAyB"}