melonjs 19.2.0 → 19.4.0

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

@@ -116,6 +116,12 @@ export class Batcher {
      * called by the WebGL renderer when a batcher becomes the current one
      */
     bind(): void;
+    /**
+     * called by the WebGL renderer when this batcher is being replaced by another.
+     * Disables this batcher's vertex attribute locations so they don't leak across
+     * (otherwise stale stride/offset state can cause INVALID_OPERATION on the next draw).
+     */
+    unbind(): void;
     /**
      * Select the shader to use for compositing
      * @see GLShader

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

@@ -1 +1 @@
-{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/batcher.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IACC;;;;;;;;;;;;;;;OAeG;IACH,sBAfW,aAAa,YAErB;QAA2B,UAAU,EACrC;YAAoC,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACuB,UAAU,EAAvC,OAAO;YACqB,MAAM,EAAlC,MAAM;SACd;QAAyB,MAAM,EAC/B;YAAgC,MAAM,EAA9B,MAAM;YACkB,QAAQ,EAAhC,MAAM;SACd;QAA0B,WAAW;QACV,OAAO;QACR,iBAAiB;KAC7C,EAGA;IAED;;;OAGG;IACH,yCA6HC;IA3HA,cAAwB;IAGxB,QAAqB;IAGrB,gBAA2C;IAE3C;;;OAGG;IACH,oCAA8B;IAE9B;;;OAGG;IACH,oCAA8B;IAE9B;;;;OAIG;IACH,yBAA6B;IAE7B;;;;OAIG;IACH,iCAAoB;IAEpB;;;;;OAKG;IACH,2BAAe;IAEf;;;;;OAKG;IACH,+BAAmB;IAEnB;;;OAGG;IACH,0CAAsB;IAqCtB;;;OAGG;IACH,sCAA0E;IAE1E;;;OAGG;IACH,oCAA+C;IAE/C;;;;OAIG;IACH,+CAA0B;IAE1B;;;;OAIG;IACH,iDAAuB;IAUxB;;;OAGG;IACH,cAUC;IAED;;OAEG;IACH,aAYC;IAED;;;;OAIG;IACH,kBAFW,QAAQ,QAqBlB;IAHE,uCAA4B;IAK/B;;;;;;;OAOG;IACH,mBANW,MAAM,QACN,MAAM,QACN,MAAM,cACN,OAAO,UACP,MAAM,QA+BhB;IAED;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,QAOlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAyEhB;CACD;;qBAhXoB,gBAAgB;8BAFP,wBAAwB;6BACzB,oBAAoB;8BAMtB,2BAA2B;+BADxB,wBAAwB"}
+{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/batcher.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IACC;;;;;;;;;;;;;;;OAeG;IACH,sBAfW,aAAa,YAErB;QAA2B,UAAU,EACrC;YAAoC,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACsB,IAAI,EAAhC,MAAM;YACuB,UAAU,EAAvC,OAAO;YACqB,MAAM,EAAlC,MAAM;SACd;QAAyB,MAAM,EAC/B;YAAgC,MAAM,EAA9B,MAAM;YACkB,QAAQ,EAAhC,MAAM;SACd;QAA0B,WAAW;QACV,OAAO;QACR,iBAAiB;KAC7C,EAGA;IAED;;;OAGG;IACH,yCA6HC;IA3HA,cAAwB;IAGxB,QAAqB;IAGrB,gBAA2C;IAE3C;;;OAGG;IACH,oCAA8B;IAE9B;;;OAGG;IACH,oCAA8B;IAE9B;;;;OAIG;IACH,yBAA6B;IAE7B;;;;OAIG;IACH,iCAAoB;IAEpB;;;;;OAKG;IACH,2BAAe;IAEf;;;;;OAKG;IACH,+BAAmB;IAEnB;;;OAGG;IACH,0CAAsB;IAqCtB;;;OAGG;IACH,sCAA0E;IAE1E;;;OAGG;IACH,oCAA+C;IAE/C;;;;OAIG;IACH,+CAA0B;IAE1B;;;;OAIG;IACH,iDAAuB;IAUxB;;;OAGG;IACH,cAUC;IAED;;OAEG;IACH,aAYC;IAED;;;;OAIG;IACH,eAaC;IAED;;;;OAIG;IACH,kBAFW,QAAQ,QA8BlB;IAHE,uCAA4B;IAK/B;;;;;;;OAOG;IACH,mBANW,MAAM,QACN,MAAM,QACN,MAAM,cACN,OAAO,UACP,MAAM,QA+BhB;IAED;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,QAOlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAyEhB;CACD;;qBA7YoB,gBAAgB;8BAFP,wBAAwB;6BACzB,oBAAoB;8BAMtB,2BAA2B;+BADxB,wBAAwB"}

package/build/video/webgl/batchers/lit_quad_batcher.d.ts

@@ -0,0 +1,109 @@
+/**
+ * additional import for TypeScript
+ * @import {TextureAtlas} from "./../../texture/atlas.js";
+ */
+/**
+ * Lit-aware variant of `QuadBatcher` for the SpriteIlluminator workflow.
+ *
+ * Adds a 5th vertex attribute (`aNormalTextureId`) so each quad knows
+ * which paired normal-map sampler to read, and bundles the per-frame
+ * light uniforms (`uLightPos`, `uLightColor`, `uLightHeight`, `uAmbient`)
+ * that the lit fragment shader iterates.
+ *
+ * Texture-slot capacity is halved relative to `QuadBatcher` because each
+ * sprite may need a paired (color, normal) sampler — color goes to unit
+ * `n`, normal to unit `maxBatchTextures + n`. The `WebGLRenderer` only
+ * dispatches sprites here when the scene actually needs lighting (active
+ * `Light2d` AND the sprite has a `normalMap`); unlit sprites stay on
+ * `QuadBatcher` and pay nothing.
+ * @category Rendering
+ */
+export default class LitQuadBatcher extends QuadBatcher {
+    /**
+     * normal-map texture per color slot — keyed by the same unit index as
+     * `boundTextures`. Used by `addQuad` to detect when a normal-map slot
+     * needs (re-)uploading, mirroring the color-texture cache.
+     * @type {Array<HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap|null>}
+     * @ignore
+     */
+    boundNormalMaps: (ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | null)[] | undefined;
+    /**
+     * Map from a normal-map source image to its GL texture object.
+     * @type {Map<HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap, WebGLTexture>}
+     * @ignore
+     */
+    normalMapTextures: Map<ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas, WebGLTexture> | undefined;
+    _lightCount: number | undefined;
+    _maxLights: number | undefined;
+    /**
+     * Bind the paired normal sampler uniforms (`uNormalSampler0..N-1`)
+     * to texture units `maxBatchTextures..2*maxBatchTextures-1`. Called
+     * from `init` and `reset`.
+     * @ignore
+     */
+    bindNormalSamplers(): void;
+    /**
+     * Upload per-frame Light2d uniforms used by the lit fragment path.
+     * Called once per camera per frame (before the world tree walk).
+     * Lights past `MAX_LIGHTS` are silently ignored.
+     *
+     * Coordinates must be supplied in the same space as the renderer's
+     * pre-projection vertex coords (i.e. camera-local / FBO-local),
+     * matching `Stage.drawLighting`'s convention.
+     * @param {object} uniforms
+     * @param {Float32Array} uniforms.positions - flat array of `[x, y, radius, intensity]` per light, length = 4 * count
+     * @param {Float32Array} uniforms.colors - flat array of `[r, g, b]` per light, length = 3 * count
+     * @param {Float32Array} [uniforms.heights] - flat array of per-light height, length = MAX_LIGHTS
+     * @param {number} uniforms.count - number of lights to render (clamped to MAX_LIGHTS)
+     * @param {number[]} [uniforms.ambient] - `[r, g, b]` ambient floor (0..1 each)
+     */
+    setLightUniforms(uniforms: {
+        positions: Float32Array;
+        colors: Float32Array;
+        heights?: Float32Array<ArrayBufferLike> | undefined;
+        count: number;
+        ambient?: number[] | undefined;
+    }): void;
+    /**
+     * Bind a normal-map image to the given GL texture unit. Uploads on
+     * first use (via `uploadNormalMap`) and rebinds the cached
+     * `WebGLTexture` on subsequent calls. Mirrors the
+     * `bindTexture2D` / `createTexture2D` split used by `MaterialBatcher`,
+     * but for normal-map textures which live outside the color
+     * `TextureCache` (cached per-image in `normalMapTextures`).
+     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} image - normal-map source
+     * @param {number} unit - GL texture unit (already offset by `maxBatchTextures`)
+     */
+    bindNormalMap(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, unit: number): void;
+    /**
+     * Upload a normal-map image to GL and cache the resulting `WebGLTexture`
+     * for future `bindNormalMap` calls. Not meant to be called directly —
+     * `bindNormalMap` invokes this on the first use of a given image.
+     *
+     * `premultipliedAlpha = false` — normal maps store linear-encoded
+     * surface normals; multiplying through alpha would corrupt the
+     * encoding for any non-opaque texel.
+     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} image - normal-map source
+     * @param {number} unit - GL texture unit (already offset by `maxBatchTextures`)
+     */
+    uploadNormalMap(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, unit: number): void;
+    /**
+     * Add a textured quad with optional paired normal map.
+     * @param {TextureAtlas} texture - Source texture atlas
+     * @param {number} x - Destination x-coordinate
+     * @param {number} y - Destination y-coordinate
+     * @param {number} w - Destination width
+     * @param {number} h - Destination height
+     * @param {number} u0 - Texture UV (u0) value
+     * @param {number} v0 - Texture UV (v0) value
+     * @param {number} u1 - Texture UV (u1) value
+     * @param {number} v1 - Texture UV (v1) value
+     * @param {number} tint - tint color (UINT32 argb)
+     * @param {boolean} [reupload=false] - Force the texture to be reuploaded
+     * @param {HTMLImageElement|HTMLCanvasElement|null} [normalMap=null] - paired normal-map (SpriteIlluminator workflow)
+     */
+    addQuad(texture: TextureAtlas, x: number, y: number, w: number, h: number, u0: number, v0: number, u1: number, v1: number, tint: number, reupload?: boolean, normalMap?: HTMLImageElement | HTMLCanvasElement | null): void;
+}
+import QuadBatcher from "./quad_batcher.js";
+import type { TextureAtlas } from "./../../texture/atlas.js";
+//# sourceMappingURL=lit_quad_batcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lit_quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_quad_batcher.js"],"names":[],"mappings":"AAKA;;;GAGG;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IAoEE;;;;;;OAMG;IACH,6GAAmD;IAEnD;;;;OAIG;IACH,uHAAkC;IAElC,gCAAoB;IACpB,+BAA4B;IAK7B;;;;;OAKG;IACH,2BAOC;IAsBD;;;;;;;;;;;;;;OAcG;IACH,2BANG;QAA+B,SAAS,EAAhC,YAAY;QACW,MAAM,EAA7B,YAAY;QACY,OAAO;QACd,KAAK,EAAtB,MAAM;QACc,OAAO;KACrC,QAgBA;IAED;;;;;;;;;OASG;IACH,qBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,QAahB;IAED;;;;;;;;;;OAUG;IACH,uBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,QAiBhB;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAbW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,cACP,gBAAgB,GAAC,iBAAiB,GAAC,IAAI,QA0EjD;CAwDD;wBAtXoC,mBAAmB;kCAIzB,0BAA0B"}

package/build/video/webgl/batchers/material_batcher.d.ts

@@ -57,8 +57,15 @@ export class MaterialBatcher extends Batcher {
     unbindTexture2D(texture?: WebGLTexture, unit?: number): number;
     /**
      * @ignore
+     * @param {TextureAtlas|TextureResource} texture
+     * @param {number} [w] - ignored when the source has its own `width` (the
+     *   common case); kept for the legacy signature where callers passed a
+     *   destination size. Forwarded only as a last-resort default.
+     * @param {number} [h] - same as `w`.
+     * @param {boolean} [force=false]
+     * @param {boolean} [flush=true]
      */
-    uploadTexture(texture: any, w: any, h: any, force?: boolean, flush?: boolean): any;
+    uploadTexture(texture: TextureAtlas | TextureResource, w?: number, h?: number, force?: boolean, flush?: boolean): any;
 }
 import { Batcher } from "./batcher.js";
 import type { TextureAtlas } from "./../../texture/atlas.js";

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

@@ -1 +1 @@
-{"version":3,"file":"material_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/material_batcher.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;;GAIG;AACH;IAQE;;;OAGG;IACH,wBAA4B;IAE5B;;;OAGG;IACH,iCAAuB;IA0BxB;;;;;;;;;;;OAWG;IACH,sBAVW,MAAM,WACN,8DAAM,iBAAiB,GAAC,SAAS,GAAC,UAAU,EAAE,GAAC,YAAY,EAAE,UAC7D,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,uBACN,OAAO,WACP,OAAO,kCACL,YAAY,CAmHxB;IAED;;;OAGG;IACH,yBAFW,YAAY,GAAC,YAAY,QAiBnC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,YAAY,CAIxB;IAED;;;;OAIG;IACH,uBAHW,YAAY,QACZ,MAAM,yBAsBhB;IAED;;;;;OAKG;IACH,0BAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAalB;IAED;;OAEG;IACH,mFAsBC;CACD;wBA7RuB,cAAc;kCAIP,0BAA0B"}
+{"version":3,"file":"material_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/material_batcher.js"],"names":[],"mappings":"AAGA;;;GAGG;AAEH;;;;GAIG;AACH;IAQE;;;OAGG;IACH,wBAA4B;IAE5B;;;OAGG;IACH,iCAAuB;IA0BxB;;;;;;;;;;;OAWG;IACH,sBAVW,MAAM,WACN,8DAAM,iBAAiB,GAAC,SAAS,GAAC,UAAU,EAAE,GAAC,YAAY,EAAE,UAC7D,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,uBACN,OAAO,WACP,OAAO,kCACL,YAAY,CA6IxB;IAED;;;OAGG;IACH,yBAFW,YAAY,GAAC,YAAY,QAiBnC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,YAAY,CAIxB;IAED;;;;OAIG;IACH,uBAHW,YAAY,QACZ,MAAM,yBAsBhB;IAED;;;;;OAKG;IACH,0BAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAalB;IAED;;;;;;;;;OASG;IACH,uBARW,YAAY,GAAC,eAAe,MAC5B,MAAM,MAGN,MAAM,UACN,OAAO,UACP,OAAO,OAiDjB;CACD;wBAvVuB,cAAc;kCAIP,0BAA0B"}

package/build/video/webgl/batchers/quad_batcher.d.ts

@@ -1,3 +1,8 @@
+/**
+ * additional import for TypeScript
+ * @import {TextureAtlas} from "./../../texture/atlas.js";
+ */
+export const V_ARRAY: Vector2d[];
 /**
  * A WebGL Compositor object. This class handles all of the WebGL state<br>
  * Pushes texture regions or shape geometry into WebGL buffers, automatically flushes to GPU
@@ -22,6 +27,18 @@ export default class QuadBatcher extends MaterialBatcher {
      * @ignore
      */
     useMultiTexture: boolean | undefined;
+    /**
+     * (Re-)create the index buffer for quad batching (4 verts + 6 indices per quad).
+     * Called from `init` and `reset` (after context loss).
+     * @ignore
+     */
+    createIndexBuffer(): void;
+    /**
+     * Bind the color sampler uniforms (`uSampler0..uSamplerN-1`) to their
+     * respective texture units. Called from `init` and `reset`.
+     * @ignore
+     */
+    bindColorSamplers(): void;
     /**
      * Select the shader to use for compositing.
      * Multi-texture batching is automatically enabled when the default
@@ -55,10 +72,11 @@ export default class QuadBatcher extends MaterialBatcher {
      * @param {number} u1 - Texture UV (u1) value.
      * @param {number} v1 - Texture UV (v1) value.
      * @param {number} tint - tint color to be applied to the texture in UINT32 (argb) format
-     * @param {boolean} reupload - Force the texture to be reuploaded even if already bound
+     * @param {boolean} [reupload=false] - Force the texture to be reuploaded even if already bound
      */
     addQuad(texture: TextureAtlas, x: number, y: number, w: number, h: number, u0: number, v0: number, u1: number, v1: number, tint: number, reupload?: boolean): void;
 }
+import { Vector2d } from "../../../math/vector2d.ts";
 import { MaterialBatcher } from "./material_batcher.js";
 import type { TextureAtlas } from "./../../texture/atlas.js";
 //# sourceMappingURL=quad_batcher.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/quad_batcher.js"],"names":[],"mappings":"AAmBA;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BAkEC;IAjEA;;;;OAIG;IACH,qCAA0D;IA4C1D;;;;;OAKG;IACH,qCAA2B;IAY5B;;;;;;;OAOG;IACH,kBAFW,QAAQ,GAAC,YAAY,QAK/B;IAgED;;;;;;;;;;OAUG;IACH,oBAPW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,QAAQ,GAAC,YAAY,QA4B/B;IAED;;;;;;;;;;;;;OAaG;IACH,iBAZW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,QAqDjB;CACD;gCAjR+B,uBAAuB;kCAIxB,0BAA0B"}
+{"version":3,"file":"quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/quad_batcher.js"],"names":[],"mappings":"AAMA;;;GAGG;AAMH,iCAKE;AAEF;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BAwDC;IAvDA;;;;OAIG;IACH,qCAA0D;IAyC1D;;;;;OAKG;IACH,qCAA2B;IAK5B;;;;OAIG;IACH,0BAQC;IAED;;;;OAIG;IACH,0BAIC;IAED;;;;;;;OAOG;IACH,kBAFW,QAAQ,GAAC,YAAY,QAK/B;IAoDD;;;;;;;;;;OAUG;IACH,oBAPW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,QAAQ,GAAC,YAAY,QAoD/B;IAED;;;;;;;;;;;;;OAaG;IACH,iBAZW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,QAqDjB;CACD;yBApTwB,2BAA2B;gCAIpB,uBAAuB;kCAIxB,0BAA0B"}

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

@@ -0,0 +1,105 @@
+/**
+ * additional import for TypeScript
+ * @import { Color } from "../../../math/color.ts";
+ * @import { default as WebGLRenderer } from "../webgl_renderer.js";
+ */
+/**
+ * A procedural radial-gradient shader effect: solid color at the center
+ * fading linearly to fully transparent at the edge of the host quad.
+ * The falloff is naturally elliptical for non-square quads.
+ *
+ * **UV-space caveat.** The `apply(color, uv)` function receives
+ * `vRegion` — the atlas UVs of the host quad. The falloff math
+ * (`length(uv * 2 - 1)`) assumes those UVs span `[0, 1] × [0, 1]`,
+ * which is true when the quad samples a full-rect texture (a
+ * dedicated 1×1 white pixel, a non-atlased Sprite, an FBO blit, or
+ * the engine-provided light atlas used by `WebGLRenderer.drawLight`).
+ * If you attach this effect to a Sprite that uses a *sub-region* of a
+ * larger atlas, `uv` will be in `[u0..u1] × [v0..v1]` and the radial
+ * center will be misplaced. For atlas-based renderables, set the
+ * effect's `uColor`/`uIntensity` and pair it with a Sprite whose
+ * texture covers a full atlas, or use a Sprite created from a
+ * standalone image.
+ *
+ * The falloff curve is **linear** (`f = clamp(1 - d, 0, 1)`) to match
+ * the Canvas 2D `createRadialGradient` two-stop output exactly. Output
+ * is premultiplied so the result composes correctly under additive
+ * (`"lighter"`) blending across overlapping quads.
+ *
+ * Color & intensity come from **two stacked sources**, multiplied
+ * together: the `uColor`/`uIntensity` uniforms (set per-effect via
+ * `setColor` / `setIntensity` — the natural API for a single-instance
+ * shader attached to a renderable) AND the per-vertex tint coming
+ * through `aColor` (used by `WebGLRenderer.drawLight` to encode each
+ * light's color + intensity in the vertex stream so multiple lights
+ * sharing this shader can batch into a single draw call). For typical
+ * standalone usage the per-vertex tint is `(1,1,1,1)` and the uniforms
+ * drive the look; for the Light2d batching path the uniforms stay at
+ * defaults and the tint carries everything.
+ * @category Effects
+ * @example
+ * // Soft white spot, 50% peak alpha at center
+ * const spot = new RadialGradientEffect(renderer, { intensity: 0.5 });
+ * @example
+ * // Tinted hotspot — orange center, full brightness, sized via the
+ * // host quad's bounds
+ * const hot = new RadialGradientEffect(renderer, {
+ *     color: new Color(255, 128, 64),
+ *     intensity: 1.0,
+ * });
+ * hot.setIntensity(2.0); // pulse brighter at runtime
+ * @example
+ * // Pickup highlight — attach to any Renderable so it renders inside
+ * // the renderable's bounding rect (anchorPoint applies). Combine with
+ * // `blendMode = "lighter"` for the additive glow look.
+ * pickup.shader = new RadialGradientEffect(renderer, {
+ *     color: new Color(120, 255, 200), // mint green
+ *     intensity: 0.8,
+ * });
+ * pickup.blendMode = "lighter";
+ * @example
+ * // Damage / impact indicator — short-lived elliptical flash on hit.
+ * // The quad's width/height drive the falloff aspect for free.
+ * const flash = new RadialGradientEffect(renderer, {
+ *     color: new Color(255, 32, 32),
+ *     intensity: 1.5,
+ * });
+ * // animate intensity to fade out
+ * tween.to({ intensity: 0 }, 200).onUpdate((s) => flash.setIntensity(s.intensity));
+ * @example
+ * // Debug overlay — draw a soft circle wherever the player is to mark
+ * // a trigger zone, without baking a texture per zone.
+ * const zoneMarker = new RadialGradientEffect(renderer, {
+ *     color: new Color(80, 160, 255),
+ *     intensity: 0.4,
+ * });
+ */
+export default class RadialGradientEffect extends ShaderEffect {
+    /**
+     * @param {WebGLRenderer} renderer - the current renderer instance
+     * @param {object} [options] - initial uniform values
+     * @param {Color} [options.color] - center color (0..255 RGB); defaults to white
+     * @param {number} [options.intensity=1] - peak alpha at the center (0..1+)
+     */
+    constructor(renderer: WebGLRenderer, options?: {
+        color?: Color | undefined;
+        intensity?: number | undefined;
+    });
+    _colorBuf: Float32Array<ArrayBuffer>;
+    /**
+     * Set the center color. RGB only — alpha is ignored (the radial
+     * falloff supplies the per-pixel alpha).
+     * @param {Color} color - 0..255 RGB color
+     */
+    setColor(color: Color): void;
+    /**
+     * Set the peak intensity. Acts as a brightness multiplier on the
+     * falloff curve; values above 1 over-saturate the center of the gradient.
+     * @param {number} intensity - 0..1+ multiplier
+     */
+    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";
+//# sourceMappingURL=radialGradient.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"radialGradient.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/radialGradient.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH;IACC;;;;;OAKG;IACH,sBALW,aAAa,YAErB;QAAwB,KAAK;QACJ,SAAS;KACpC,EA0CA;IAZA,qCAAoC;IAcrC;;;;OAIG;IACH,gBAFW,KAAK,QAOf;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;CACD;yBArJwB,oBAAoB;2BAInB,wBAAwB;8CACL,sBAAsB"}

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

@@ -1 +1 @@
-{"version":3,"file":"glshader.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/glshader.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,gBA1BW,qBAAqB,UACrB,MAAM,YACN,MAAM,cACN,MAAM,EAyEhB;IAjDA;;;OAGG;IACH,IAFU,qBAAqB,CAEnB;IAEZ;;;OAGG;IACH,QAFU,MAAM,CAKf;IAED;;;OAGG;IACH,UAFU,MAAM,CAKf;IAED;;;OAGG;IACH,YAFU,KAAK,EAAE,CAEiC;IAElD;;;OAGG;IACH,SAFU,YAAY,CAOrB;IAED;;;OAGG;IACH,UAFU,MAAM,CAE8B;IAM/C;;OAEG;IACH,aAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,KAAK,CASjB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,YAAY,QAiB7B;IAED;;;;;OAKG;IACH,wBAJW,qBAAqB,cACrB,MAAM,EAAE,UACR,MAAM,QAsBhB;IAED;;OAEG;IACH,gBAQC;CACD"}
+{"version":3,"file":"glshader.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/glshader.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,gBA1BW,qBAAqB,UACrB,MAAM,YACN,MAAM,cACN,MAAM,EAyEhB;IAjDA;;;OAGG;IACH,IAFU,qBAAqB,CAEnB;IAEZ;;;OAGG;IACH,QAFU,MAAM,CAKf;IAED;;;OAGG;IACH,UAFU,MAAM,CAKf;IAED;;;OAGG;IACH,YAFU,KAAK,EAAE,CAEiC;IAElD;;;OAGG;IACH,SAFU,YAAY,CAOrB;IAED;;;OAGG;IACH,UAFU,MAAM,CAE8B;IAM/C;;OAEG;IACH,aAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,KAAK,CASjB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,YAAY,QAiB7B;IAED;;;;;OAKG;IACH,wBAJW,qBAAqB,cACrB,MAAM,EAAE,UACR,MAAM,QAmBhB;IAED;;OAEG;IACH,gBAQC;CACD"}

package/build/video/webgl/lighting/constants.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Constants shared between the lit fragment shader (`multitexture-lit.js`),
+ * the lit batcher (`LitQuadBatcher`), and the uniform packer (`pack.ts`).
+ * Kept in a tiny standalone module so the three consumers don't depend on
+ * each other transitively for a single integer.
+ */
+/**
+ * Maximum number of `Light2d` instances the lit fragment shader supports
+ * concurrently per draw call. Lights past this index are ignored. Sized
+ * to keep the GLSL uniform arrays comfortably within WebGL1 limits.
+ */
+export declare const MAX_LIGHTS = 8;
+//# sourceMappingURL=constants.d.ts.map

package/build/video/webgl/lighting/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/lighting/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;GAIG;AACH,eAAO,MAAM,UAAU,IAAI,CAAC"}

package/build/video/webgl/lighting/pack.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Per-frame scratch buffer for `packLights()`. Pre-allocates one entry
+ * per light slot so the per-camera-per-frame upload doesn't allocate.
+ */
+export interface LightUniformScratch {
+    positions: Float32Array;
+    colors: Float32Array;
+    heights: Float32Array;
+    ambient: number[];
+}
+/**
+ * Result of `packLights()` — typed-array views into the scratch plus the
+ * actual count. `WebGLRenderer.setLightUniforms` forwards this to
+ * `LitQuadBatcher.setLightUniforms` for upload.
+ */
+export interface LightUniforms extends LightUniformScratch {
+    count: number;
+}
+/**
+ * Allocate a fresh scratch buffer sized for `MAX_LIGHTS` slots. One per
+ * renderer is enough; reuse across frames.
+ */
+export declare function createLightUniformScratch(): LightUniformScratch;
+/**
+ * Light2d-shaped duck-type — anything `packLights()` reads from. Avoids
+ * importing `Light2d` directly (keeps this module renderer-agnostic).
+ */
+interface LightLike {
+    getBounds(): {
+        centerX: number;
+        centerY: number;
+        width: number;
+        height: number;
+    };
+    intensity: number;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    lightHeight: number;
+}
+/** Color-shaped duck-type for the ambient floor. */
+interface ColorLike {
+    r: number;
+    g: number;
+    b: number;
+}
+/**
+ * Pack the active scene lights into the scratch buffer in a shape the
+ * lit fragment shader uploads directly.
+ *
+ * Light positions are translated from world-space (where
+ * `light.getBounds().centerX/Y` lives) into the renderer's
+ * pre-projection coords by subtracting `(translateX, translateY)` —
+ * the same translate `Camera2d.draw()` applies to the world container.
+ * This matches what `Stage.drawLighting` does for the cutout pass, so
+ * the lit fragment's `lightPos - vWorldPos` math lines up with the
+ * camera's view.
+ *
+ * Lights past `MAX_LIGHTS` (8) are silently dropped. Unused slots are
+ * zero-filled so stale data from a previous frame can't leak into the
+ * shader.
+ *
+ * Pure function: deterministic given the same inputs, no I/O, scratch
+ * is the only mutable target.
+ * @param lights - active lights iterable (e.g. `Stage._activeLights`); falsy treated as empty
+ * @param ambient - ambient floor color (0..255 RGB); falsy treated as black
+ * @param translateX - world-to-screen X translate (matches `Camera2d.draw()`)
+ * @param translateY - world-to-screen Y translate
+ * @param scratch - pre-allocated scratch (see `createLightUniformScratch`)
+ * @returns the scratch with `count` filled in
+ */
+export declare function packLights(lights: Iterable<LightLike> | null | undefined, ambient: ColorLike | null | undefined, translateX: number, translateY: number, scratch: LightUniformScratch): LightUniforms;
+export {};
+//# sourceMappingURL=pack.d.ts.map

package/build/video/webgl/lighting/pack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/lighting/pack.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IACnC,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAc,SAAQ,mBAAmB;IACzD,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,mBAAmB,CAO/D;AAED;;;GAGG;AACH,UAAU,SAAS;IAClB,SAAS,IAAI;QACZ,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KACf,CAAC;IACF,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,oDAAoD;AACpD,UAAU,SAAS;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,UAAU,CACzB,MAAM,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,IAAI,GAAG,SAAS,EAC9C,OAAO,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,EACrC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,mBAAmB,GAC1B,aAAa,CA4Cf"}

package/build/video/webgl/renderers/tmxlayer/orthogonal.d.ts

@@ -0,0 +1,108 @@
+/**
+ * GPU-accelerated renderer for orthogonal TMX tile layers (WebGL2). Draws
+ * the visible region of a layer as one screen-aligned quad per tileset
+ * referenced by the layer — the fragment shader samples a per-layer GID
+ * index texture and the tileset atlas, eliminating the per-tile draw
+ * loop. The visible rect, GID range, tile size, opacity, and tint are
+ * pushed as uniforms; the index texture is uploaded once at activation
+ * and re-uploaded only when `layer.dataVersion` changes (mutations from
+ * `setTile`/`clearTile`).
+ *
+ * The per-layer index texture is a `BufferTextureResource` flowing
+ * through the standard `TextureCache` / batcher path — same lane as
+ * every other texture in the engine. Dynamic unit allocation, correct
+ * `boundTextures` bookkeeping, and per-resource premultiplied-alpha /
+ * filter all come for free; nothing here pokes `gl.bindTexture` or
+ * `gl.activeTexture` directly.
+ *
+ * Cache lifecycle: one `BufferTextureResource` per `TMXLayer`. Tile
+ * layers don't come and go individually — they only churn on game reset
+ * — so the cache is freed in bulk via `reset()`, called from
+ * `WebGLRenderer.reset()` (which the `GAME_RESET` event already
+ * triggers).
+ *
+ * @ignore
+ */
+export default class OrthogonalTMXLayerGPURenderer {
+    /**
+     * @param {WebGLRenderer} renderer - the WebGL renderer instance
+     */
+    constructor(renderer: WebGLRenderer);
+    renderer: WebGLRenderer;
+    gl: WebGLRenderingContext;
+    shader: GLShader;
+    resources: Map<any, any>;
+    animLookups: Map<any, any>;
+    _v2: Float32Array<ArrayBuffer>;
+    _v4: Float32Array<ArrayBuffer>;
+    /**
+     * Free every cached per-layer index texture and empty the local
+     * resource map. Called from `WebGLRenderer.reset()` (which
+     * `GAME_RESET` triggers) so each level transition starts clean.
+     * @ignore
+     */
+    reset(): void;
+    /**
+     * Write a `vec2` uniform without allocating a fresh Float32Array per
+     * call. Both components flow into the shared `_v2` scratch buffer,
+     * which `setUniform` reads synchronously and forwards to
+     * `gl.uniform2fv` — so reusing the buffer across calls is safe.
+     * @param {string} name
+     * @param {number} x
+     * @param {number} y
+     * @private
+     */
+    private _setV2;
+    /**
+     * `vec4` counterpart to {@link _setV2}.
+     * @param {string} name
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} w
+     * @private
+     */
+    private _setV4;
+    /**
+     * Get-or-create the per-tileset animation-lookup entry. Returns
+     * `undefined` for tilesets that have no animated tiles (the shader's
+     * `uAnimEnabled` uniform is then set to 0 and the lookup texture is
+     * not bound).
+     *
+     * The entry holds a `tileCount × 1` RGBA8 `BufferTextureResource`
+     * where texel `localId` encodes the CURRENT frame's local id as
+     * `R = lo byte, G = hi byte` (same encoding as the GID index
+     * texture). Each call walks `tileset.animations` and rewrites
+     * dirty texels — `tileset.update(dt)` (driven by the layer) advances
+     * `anim.cur.tileid` independently of this renderer.
+     *
+     * @param {object} tileset
+     * @param {number} tileCount - tiles in the tileset's atlas grid
+     *   (`atlasCols * atlasRows`)
+     * @returns {{resource: BufferTextureResource, data: Uint8Array,
+     *   tileCount: number, dirty: boolean}|undefined}
+     */
+    _getOrUpdateAnimLookup(tileset: object, tileCount: number): {
+        resource: BufferTextureResource;
+        data: Uint8Array;
+        tileCount: number;
+        dirty: boolean;
+    } | undefined;
+    /**
+     * Get-or-create the per-layer index `BufferTextureResource`.
+     * @param {TMXLayer} layer
+     * @returns {BufferTextureResource}
+     */
+    _getResource(layer: TMXLayer): BufferTextureResource;
+    /**
+     * Draw an orthogonal TMX layer through the shader path.
+     * @param {TMXLayer} layer
+     * @param {object} rect - the visible viewport rect (world coords)
+     */
+    draw(layer: TMXLayer, rect: object): void;
+}
+import type { default as WebGLRenderer } from "../../webgl_renderer.js";
+import GLShader from "../../glshader.js";
+import { BufferTextureResource } from "../../../texture/resource.js";
+import type { default as TMXLayer } from "../../../../level/tiled/TMXLayer.js";
+//# sourceMappingURL=orthogonal.d.ts.map

package/build/video/webgl/renderers/tmxlayer/orthogonal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orthogonal.d.ts","sourceRoot":"","sources":["../../../../../src/video/webgl/renderers/tmxlayer/orthogonal.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;OAEG;IACH,sBAFW,aAAa,EAkCvB;IA/BA,wBAAwB;IACxB,0BAAqB;IAUrB,iBAKC;IAMD,yBAA0B;IAI1B,2BAA4B;IAG5B,+BAA8B;IAC9B,+BAA8B;IAG/B;;;;;OAKG;IACH,cAyBC;IAED;;;;;;;;;OASG;IACH,eAIC;IAED;;;;;;;;OAQG;IACH,eAMC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,gCANW,MAAM,aACN,MAAM,GAEJ;QAAC,QAAQ,EAAE,qBAAqB,CAAC;QAAC,IAAI,EAAE,UAAU,CAAC;QAC3D,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAC,GAAC,SAAS,CA+ChD;IAED;;;;OAIG;IACH,oBAHW,QAAQ,GACN,qBAAqB,CA6BjC;IAED;;;;OAIG;IACH,YAHW,QAAQ,QACR,MAAM,QA0JhB;CACD;8CA1Y4C,yBAAyB;qBAPjD,mBAAmB;sCADF,8BAA8B;yCAO5B,qCAAqC"}

package/build/video/webgl/shaders/multitexture-lit.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Generate the fragment shader for `LitQuadBatcher` — the SpriteIlluminator
+ * path that supports per-pixel normal-map lighting from up to `MAX_LIGHTS`
+ * point lights.
+ *
+ * Sprites without a `normalMap` push `aNormalTextureId = -1` and take the
+ * unlit fast path inside this same shader (sample color, multiply by
+ * vertex color, return) so lit and unlit sprites can share the lit batch
+ * when they coexist with active lights. The cost vs the truly-unlit
+ * `QuadBatcher` shader is one varying read + one comparison per fragment.
+ *
+ * The light's "height above the sprite plane" is encoded as a small
+ * fraction of the light's radius (default `0.075`) so that lights
+ * exactly at a fragment's screen position don't produce degenerate
+ * flat shading.
+ * @param {number} maxTextures - the number of color/normal texture units to support
+ * @returns {string} GLSL fragment shader source
+ * @ignore
+ */
+export function buildLitMultiTextureFragment(maxTextures: number): string;
+export { MAX_LIGHTS };
+import { MAX_LIGHTS } from "../lighting/constants.ts";
+//# sourceMappingURL=multitexture-lit.d.ts.map

package/build/video/webgl/shaders/multitexture-lit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multitexture-lit.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/shaders/multitexture-lit.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;GAkBG;AACH,0DAJW,MAAM,GACJ,MAAM,CAiFlB;;2BAjI0B,0BAA0B"}

package/build/video/webgl/utils/attributes.d.ts

@@ -1,4 +1,11 @@
 /**
+ * Pick out every vertex attribute name from a shader source, regardless of
+ * GLSL version. GLSL 1.00 marks attributes with the `attribute` storage
+ * qualifier; GLSL ES 3.00 reuses `in` at file scope for the same purpose
+ * (and `in` inside function parameter lists, which we exclude by requiring
+ * the qualifier to start at the beginning of a line). Skipping the 3.00
+ * form leaves the shader with no bound vertex data and the rasterizer
+ * silently degenerates every triangle.
  * @ignore
  */
 export function extractAttributes(gl: any, shader: any): {};

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

@@ -1 +1 @@
-{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/attributes.js"],"names":[],"mappings":"AAAA;;GAEG;AACH,4DAYC"}
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/attributes.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,4DAmBC"}

package/build/video/webgl/utils/precision.d.ts

@@ -1,5 +1,5 @@
 /**
- * set precision for the fiven shader source
+ * set precision for the given shader source
  * won't do anything if the precision is already specified
  * @ignore
  */

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

@@ -1 +1 @@
-{"version":3,"file":"precision.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/precision.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,4DAKC;AAED;;;;;;GAMG;AACH,0CAJW,qBAAqB,kBACrB,OAAO,GACL,MAAM,CAoBlB"}
+{"version":3,"file":"precision.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/precision.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,4DA+BC;AAED;;;;;;GAMG;AACH,0CAJW,qBAAqB,kBACrB,OAAO,GACL,MAAM,CAoBlB"}

package/build/video/webgl/utils/uniforms.d.ts

@@ -1,4 +1,17 @@
 /**
+ * Build the `uniforms` proxy object for a compiled shader program.
+ *
+ * Each detected uniform gets a defineProperty getter (returns its
+ * `WebGLUniformLocation`) and a setter that pushes the value to GL. The
+ * setter caches the last value it sent and skips the underlying
+ * `gl.uniform*` call when the incoming value matches — uniform writes are
+ * cheap individually, but a typical per-frame draw pass sets a dozen of
+ * them per shader, and most are layer-lifetime constants (`uMapSize`,
+ * `uCellSize`, `uOpacity`, projection matrix on idle frames, etc.).
+ *
+ * Cache scope is per-shader: each `GLShader` calls `extractUniforms` once
+ * and gets its own closure-captured `cache` map, so caches don't leak
+ * across programs.
  * @ignore
  */
 export function extractUniforms(gl: any, shader: any): {};

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

@@ -1 +1 @@
-{"version":3,"file":"uniforms.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/uniforms.js"],"names":[],"mappings":"AAuBA;;GAEG;AACH,0DAuDC"}
+{"version":3,"file":"uniforms.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/uniforms.js"],"names":[],"mappings":"AA0FA;;;;;;;;;;;;;;;GAeG;AACH,0DAmEC"}