melonjs 18.2.2 → 19.0.0

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

@@ -0,0 +1,32 @@
+/**
+ * A shader effect that desaturates (grayscales) the sprite.
+ * The `intensity` uniform controls how much color is removed
+ * (0.0 = full color, 1.0 = fully grayscale).
+ * Commonly used for disabled states, death effects, or petrification.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * // full grayscale
+ * mySprite.shader = new DesaturateEffect(renderer);
+ * @example
+ * // partial desaturation (50%)
+ * mySprite.shader = new DesaturateEffect(renderer, { intensity: 0.5 });
+ */
+export default class DesaturateEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} 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: import("../webgl_renderer.js").default, options?: {
+        intensity?: number | undefined;
+    });
+    intensity: number;
+    /**
+     * set the desaturation intensity
+     * @param {number} value - desaturation intensity (0.0 = full color, 1.0 = grayscale)
+     */
+    setIntensity(value: number): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=desaturate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"desaturate.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/desaturate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAgBA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;yBA/CwB,oBAAoB"}

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

@@ -0,0 +1,42 @@
+/**
+ * A shader effect that dissolves the sprite using a noise-based threshold.
+ * Pixels are discarded based on a pseudo-random noise pattern as the
+ * `progress` value increases from 0 to 1.
+ * Commonly used for death, spawn, or teleport effects.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * // create a dissolve effect
+ * const dissolve = new DissolveEffect(renderer);
+ * mySprite.shader = 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 {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: import("../webgl_renderer.js").default, options?: {
+        progress?: number | undefined;
+        edgeColor?: number[] | undefined;
+        edgeWidth?: number | undefined;
+    });
+    progress: number;
+    /**
+     * set the dissolve progress
+     * @param {number} value - dissolve progress (0.0 = visible, 1.0 = dissolved)
+     */
+    setProgress(value: number): void;
+    /**
+     * set the edge color
+     * @param {number[]} color - edge color as [r, g, b] (0.0–1.0)
+     */
+    setEdgeColor(color: number[]): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=dissolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dissolve.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/dissolve.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;OAMG;IACH,sBANW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,QAAQ;QACN,SAAS;QACX,SAAS;KACpC,EA0DA;IAPA,iBAAuC;IASxC;;;OAGG;IACH,mBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAIlB;CACD;yBApGwB,oBAAoB"}

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

@@ -0,0 +1,47 @@
+/**
+ * A shader effect that adds a drop shadow beneath the sprite.
+ * Works by sampling the texture at an offset — if the offset position
+ * has an opaque pixel but the current position doesn't, the shadow is drawn.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * // dark shadow offset to the bottom-right
+ * mySprite.shader = new DropShadowEffect(renderer, {
+ *     offsetX: 3.0,
+ *     offsetY: 3.0,
+ *     color: [0.0, 0.0, 0.0],
+ *     opacity: 0.5,
+ * });
+ */
+export default class DropShadowEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @param {number} [options.offsetX=2.0] - shadow x offset in texels
+     * @param {number} [options.offsetY=2.0] - shadow y offset in texels
+     * @param {number[]} [options.color=[0.0, 0.0, 0.0]] - shadow color as [r, g, b] (0.0–1.0)
+     * @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?: {
+        offsetX?: number | undefined;
+        offsetY?: number | undefined;
+        color?: number[] | undefined;
+        opacity?: number | undefined;
+        textureSize?: number[] | undefined;
+    });
+    /**
+     * set the shadow offset
+     * @param {number} x - x offset in texels
+     * @param {number} y - y offset in texels
+     */
+    setOffset(x: number, y: number): void;
+    /**
+     * set the texture size
+     * @param {number} width - texture width in pixels
+     * @param {number} height - texture height in pixels
+     */
+    setTextureSize(width: number, height: number): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=dropShadow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dropShadow.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/dropShadow.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;;;OAQG;IACH,sBARW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,OAAO;QACP,OAAO;QACL,KAAK;QACP,OAAO;QACL,WAAW;KACxC,EAmCA;IAED;;;;OAIG;IACH,aAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAhFwB,oBAAoB"}

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

@@ -0,0 +1,46 @@
+/**
+ * A shader effect that flashes the sprite with a solid color.
+ * Commonly used for hit feedback — flash white when the player takes damage.
+ * The `intensity` uniform controls how much of the flash color is mixed in
+ * (0.0 = original sprite, 1.0 = fully colored).
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * // create a white flash effect
+ * const flash = new FlashEffect(renderer);
+ * mySprite.shader = flash;
+ *
+ * // trigger the flash (e.g. on hit)
+ * flash.setIntensity(1.0);
+ *
+ * // fade it out over time (e.g. in update loop)
+ * flash.setIntensity(flash.intensity - dt / 200);
+ * @example
+ * // red flash
+ * const flash = new FlashEffect(renderer, { color: [1.0, 0.0, 0.0] });
+ */
+export default class FlashEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @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?: {
+        color?: number[] | undefined;
+        intensity?: number | undefined;
+    });
+    intensity: number;
+    /**
+     * set the flash intensity
+     * @param {number} value - flash intensity (0.0 = no flash, 1.0 = fully colored)
+     */
+    setIntensity(value: number): void;
+    /**
+     * set the flash color
+     * @param {number[]} color - flash color as [r, g, b] (0.0–1.0)
+     */
+    setColor(color: number[]): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=flash.d.ts.map

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

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

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

@@ -0,0 +1,48 @@
+/**
+ * A shader effect that adds a colored glow around the sprite.
+ * Similar to OutlineEffect but with a soft, blurred edge instead of a hard line.
+ * Commonly used for power-ups, magic items, or selection highlights.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * // blue glow for a magic item
+ * mySprite.shader = new GlowEffect(renderer, {
+ *     color: [0.2, 0.5, 1.0],
+ *     intensity: 1.5,
+ * });
+ */
+export default class GlowEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @param {number[]} [options.color=[1.0, 1.0, 1.0]] - glow color as [r, g, b] (0.0–1.0)
+     * @param {number} [options.width=3.0] - glow spread in pixels
+     * @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?: {
+        color?: number[] | undefined;
+        width?: number | undefined;
+        intensity?: number | undefined;
+        textureSize?: number[] | undefined;
+    });
+    intensity: number;
+    /**
+     * set the glow color
+     * @param {number[]} color - glow color as [r, g, b] (0.0–1.0)
+     */
+    setColor(color: number[]): void;
+    /**
+     * set the glow intensity
+     * @param {number} value - glow brightness multiplier
+     */
+    setIntensity(value: number): void;
+    /**
+     * set the texture size
+     * @param {number} width - texture width in pixels
+     * @param {number} height - texture height in pixels
+     */
+    setTextureSize(width: number, height: number): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=glow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"glow.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/glow.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;;;OAOG;IACH,sBAPW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;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;yBAxFwB,oBAAoB"}

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

@@ -0,0 +1,37 @@
+/**
+ * A shader effect that simulates a holographic projection with
+ * horizontal scan lines, color shift, and flickering.
+ * Commonly used for sci-fi UI, ghost/spirit characters, or tech displays.
+ * The `time` uniform should be updated each frame for animation.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * const holo = new HologramEffect(renderer);
+ * mySprite.shader = holo;
+ * // update each frame
+ * holo.setTime(performance.now() / 1000);
+ */
+export default class HologramEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @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?: {
+        color?: number[] | undefined;
+        intensity?: number | undefined;
+    });
+    /**
+     * set the current time (call each frame for animation)
+     * @param {number} time - time in seconds
+     */
+    setTime(time: number): void;
+    /**
+     * set the hologram tint color
+     * @param {number[]} color - color as [r, g, b] (0.0–1.0)
+     */
+    setColor(color: number[]): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=hologram.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hologram.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/hologram.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;OAKG;IACH,sBALW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA2B,KAAK;QACP,SAAS;KACpC,EAyBA;IAED;;;OAGG;IACH,cAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBA/DwB,oBAAoB"}

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

@@ -0,0 +1,29 @@
+/**
+ * A shader effect that inverts the colors of the sprite.
+ * Commonly used for damage feedback, negative image, or X-ray effects.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * mySprite.shader = new InvertEffect(renderer);
+ * @example
+ * // partial inversion
+ * mySprite.shader = new InvertEffect(renderer, { intensity: 0.5 });
+ */
+export default class InvertEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @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?: {
+        intensity?: number | undefined;
+    });
+    intensity: number;
+    /**
+     * set the inversion intensity
+     * @param {number} value - inversion intensity (0.0 = original, 1.0 = fully inverted)
+     */
+    setIntensity(value: number): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=invert.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"invert.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/invert.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAgBA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;yBA5CwB,oBAAoB"}

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

@@ -0,0 +1,49 @@
+/**
+ * A shader effect that draws a colored outline around the sprite.
+ * Works by sampling neighboring pixels — if any neighbor is opaque but the
+ * current pixel is transparent, it draws the outline color.
+ * Commonly used for selection highlights, hover states, or collectible glow.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * // yellow outline for selection
+ * mySprite.shader = new OutlineEffect(renderer, {
+ *     color: [1.0, 1.0, 0.0],
+ *     width: 2.0,
+ * });
+ * @example
+ * // remove the effect
+ * mySprite.shader = undefined;
+ */
+export default class OutlineEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @param {number[]} [options.color=[1.0, 1.0, 1.0]] - outline color as [r, g, b] (0.0–1.0)
+     * @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?: {
+        color?: number[] | undefined;
+        width?: number | undefined;
+        textureSize?: number[] | undefined;
+    });
+    /**
+     * set the outline color
+     * @param {number[]} color - outline color as [r, g, b] (0.0–1.0)
+     */
+    setColor(color: number[]): void;
+    /**
+     * set the outline width
+     * @param {number} width - outline width in pixels
+     */
+    setWidth(width: number): void;
+    /**
+     * set the texture size for accurate outline width calculation
+     * @param {number} width - texture width in pixels
+     * @param {number} height - texture height in pixels
+     */
+    setTextureSize(width: number, height: number): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=outline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/outline.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;;;;OAMG;IACH,sBANW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;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;yBA1FwB,oBAAoB"}

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

@@ -0,0 +1,38 @@
+/**
+ * A shader effect that pixelates the sprite by snapping UV coordinates
+ * to a grid. Commonly used for teleport effects, transitions, or retro styling.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * // moderate pixelation
+ * mySprite.shader = new PixelateEffect(renderer, { size: 8.0 });
+ * @example
+ * // animate the pixelation (e.g. for teleport)
+ * pixelate.setSize(pixelate.size + dt / 50);
+ */
+export default class PixelateEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @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?: {
+        size?: number | undefined;
+        textureSize?: number[] | undefined;
+    });
+    size: number;
+    /**
+     * set the pixel size
+     * @param {number} size - pixel size in texels
+     */
+    setSize(size: number): void;
+    /**
+     * set the texture size
+     * @param {number} width - texture width in pixels
+     * @param {number} height - texture height in pixels
+     */
+    setTextureSize(width: number, height: number): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=pixelate.d.ts.map

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

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

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

@@ -0,0 +1,47 @@
+/**
+ * A shader effect that overlays horizontal scanlines on the sprite.
+ * Can optionally add barrel distortion and vignette for a full CRT monitor look.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * // simple scanlines
+ * mySprite.shader = new ScanlineEffect(renderer, { opacity: 0.3 });
+ * @example
+ * // full CRT look with curvature and vignette
+ * mySprite.shader = new ScanlineEffect(renderer, {
+ *     opacity: 0.3,
+ *     curvature: 0.02,
+ *     vignetteStrength: 0.3,
+ * });
+ */
+export default class ScanlineEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @param {number} [options.opacity=0.25] - scanline darkness (0.0 = invisible, 1.0 = fully black lines)
+     * @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?: {
+        opacity?: number | undefined;
+        curvature?: number | undefined;
+        vignetteStrength?: number | undefined;
+    });
+    /**
+     * set the scanline opacity
+     * @param {number} opacity - scanline darkness (0.0–1.0)
+     */
+    setOpacity(opacity: number): void;
+    /**
+     * set the barrel curvature strength
+     * @param {number} curvature - distortion amount (0.0 = flat)
+     */
+    setCurvature(curvature: number): void;
+    /**
+     * set the vignette strength
+     * @param {number} strength - edge darkening (0.0 = none)
+     */
+    setVignetteStrength(strength: number): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=scanline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scanline.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/scanline.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;;;OAMG;IACH,sBANW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;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;yBA3FwB,oBAAoB"}

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

@@ -0,0 +1,28 @@
+/**
+ * A shader effect that applies a warm sepia (vintage photo) tone to the sprite.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * mySprite.shader = new SepiaEffect(renderer);
+ * @example
+ * // partial sepia
+ * mySprite.shader = new SepiaEffect(renderer, { intensity: 0.5 });
+ */
+export default class SepiaEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @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?: {
+        intensity?: number | undefined;
+    });
+    intensity: number;
+    /**
+     * set the sepia intensity
+     * @param {number} value - sepia intensity (0.0 = original, 1.0 = full sepia)
+     */
+    setIntensity(value: number): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=sepia.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/sepia.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAmBA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;yBA9CwB,oBAAoB"}

package/build/video/webgl/effects/tintPulse.d.ts

@@ -0,0 +1,43 @@
+/**
+ * A shader effect that pulses a color overlay on the sprite.
+ * Commonly used for status effects — poison green, freeze blue, fire red.
+ * The `time` uniform should be updated each frame for the pulse animation.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * // poison pulse
+ * const poison = new TintPulseEffect(renderer, {
+ *     color: [0.0, 1.0, 0.0],
+ *     speed: 3.0,
+ * });
+ * mySprite.shader = poison;
+ *
+ * // update each frame
+ * poison.setTime(timer.getTime() / 1000);
+ */
+export default class TintPulseEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @param {number[]} [options.color=[1.0, 0.0, 0.0]] - pulse color as [r, g, b] (0.0–1.0)
+     * @param {number} [options.speed=2.0] - pulse speed (oscillations per second)
+     * @param {number} [options.intensity=0.3] - maximum tint strength (0.0–1.0)
+     */
+    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+        color?: number[] | undefined;
+        speed?: number | undefined;
+        intensity?: number | undefined;
+    });
+    /**
+     * set the current time (call each frame for animation)
+     * @param {number} time - time in seconds
+     */
+    setTime(time: number): void;
+    /**
+     * set the pulse color
+     * @param {number[]} color - pulse color as [r, g, b] (0.0–1.0)
+     */
+    setColor(color: number[]): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=tintPulse.d.ts.map

package/build/video/webgl/effects/tintPulse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tintPulse.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/tintPulse.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;;;;OAMG;IACH,sBANW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA2B,KAAK;QACP,KAAK;QACL,SAAS;KACpC,EAqBA;IAED;;;OAGG;IACH,cAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBAhEwB,oBAAoB"}

package/build/video/webgl/effects/wave.d.ts

@@ -0,0 +1,43 @@
+/**
+ * A shader effect that applies a sine wave distortion to the sprite.
+ * Commonly used for underwater, heat haze, or dream sequence effects.
+ * The `time` uniform should be updated each frame for animation.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * const wave = new WaveEffect(renderer, { amplitude: 0.01, frequency: 10.0 });
+ * mySprite.shader = wave;
+ * // update each frame
+ * wave.setTime(performance.now() / 1000);
+ */
+export default class WaveEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @param {number} [options.amplitude=0.01] - wave displacement strength (in UV space, 0.01 = subtle)
+     * @param {number} [options.frequency=10.0] - number of waves across the sprite
+     * @param {number} [options.speed=2.0] - wave animation speed
+     */
+    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+        amplitude?: number | undefined;
+        frequency?: number | undefined;
+        speed?: number | undefined;
+    });
+    /**
+     * set the current time (call each frame for animation)
+     * @param {number} time - time in seconds
+     */
+    setTime(time: number): void;
+    /**
+     * set the wave amplitude
+     * @param {number} amplitude - displacement strength in UV space
+     */
+    setAmplitude(amplitude: number): void;
+    /**
+     * set the wave frequency
+     * @param {number} frequency - number of waves
+     */
+    setFrequency(frequency: number): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=wave.d.ts.map

package/build/video/webgl/effects/wave.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wave.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/wave.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IACC;;;;;;OAMG;IACH,sBANW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;QACT,SAAS;QACT,KAAK;KAChC,EAqBA;IAED;;;OAGG;IACH,cAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;CACD;yBAnEwB,oBAAoB"}

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,0FA4CC"}
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/program.js"],"names":[],"mappings":"AAeA;;;GAGG;AACH,0FA2CC"}