melonjs 20.2.0 → 20.4.0

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

@@ -1,106 +1,4 @@
-/**
- * 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";

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

@@ -1 +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,cAiCC;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;8CAlZ4C,yBAAyB;qBAPjD,mBAAmB;sCADF,8BAA8B;yCAO5B,qCAAqC"}
+{"version":3,"file":"orthogonal.d.ts","sourceRoot":"","sources":["../../../../../src/video/webgl/renderers/tmxlayer/orthogonal.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IACC;;OAEG;IACH,sBAFW,aAAa,EA0CvB;IAvCA,wBAAwB;IACxB,0BAAqB;IAUrB,iBAKC;IAMD,yBAA0B;IAI1B,2BAA4B;IAG5B;;;OAGG;IACH,+BAA8B;IAC9B;;;OAGG;IACH,+BAA8B;IAG/B;;;;;;OAMG;IACH,cAiCC;IAED;;;;;;;;;;;OAWG;IACH,eAIC;IAED;;;;;;;;;;OAUG;IACH,eAMC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,gCARW,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,CAiDhD;IAED;;;;;;OAMG;IACH,oBALW,QAAQ,GACN,qBAAqB,CA+BjC;IAED;;;;OAIG;IACH,YAHW,QAAQ,QACR,MAAM,QA0JhB;CACD;8CApa4C,yBAAyB;qBAPjD,mBAAmB;sCADF,8BAA8B;yCAO5B,qCAAqC"}

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

@@ -1,27 +1,2 @@
-/**
- * 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 interpolated 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.
- *
- * GLSL ES 3.00, because the light data arrives in a uniform block and
- * blocks do not exist in ES 1.00 (see #1552). The paired vertex shader
- * `quad-multi-lit.vert` is on the same version — both stages of a program
- * must agree.
- * @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;
+
 //# sourceMappingURL=multitexture-lit.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"multitexture-lit.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/shaders/multitexture-lit.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,0DAJW,MAAM,GACJ,MAAM,CAsGlB"}
+{"version":3,"file":"multitexture-lit.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/shaders/multitexture-lit.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,0DALW,MAAM,GACJ,MAAM,CAuGlB"}

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

@@ -1,10 +1,2 @@
-/**
- * Generates a multi-texture fragment shader source string.
- * Declares individual sampler uniforms (uSampler0..uSamplerN) and uses
- * an if/else chain with 0.5-offset thresholds to select the correct texture unit.
- * @param {number} maxTextures - the number of texture units to support
- * @returns {string} GLSL fragment shader source
- * @ignore
- */
-export function buildMultiTextureFragment(maxTextures: number): string;
+
 //# sourceMappingURL=multitexture.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"multitexture.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/shaders/multitexture.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,uDAJW,MAAM,GACJ,MAAM,CAqClB"}
+{"version":3,"file":"multitexture.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/shaders/multitexture.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,uDALW,MAAM,GACJ,MAAM,CAsClB"}

package/build/video/webgl/texture/store.d.ts

@@ -1,52 +1,3 @@
-/**
- * The WebGL realization of {@link TextureStore}.
- *
- * The shared base owns the policy — source → record, the reuse-or-upload
- * decision, generation and lifetime bookkeeping. This subclass owns the GL
- * calls, and nothing else. Mirrors the `Batcher` / `WebGLBatcher` /
- * `WebGPUBatcher` arrangement: one neutral base, one realization per backend.
- *
- * Two instances exist per renderer: the colour store, which every batcher
- * shares through `WebGLRenderer.textureStore`, and the lit batcher's
- * normal-map store — normal maps live outside the colour `TextureCache`, so
- * their handles are that batcher's to own, but the policy is identical.
- * @augments TextureStore
- * @ignore
- */
-export class WebGLTextureStore extends TextureStore {
-    /**
-     * @param {WebGL2RenderingContext} gl - the owning context
-     * @ignore
-     */
-    constructor(gl: WebGL2RenderingContext);
-    gl: WebGL2RenderingContext;
-    /**
-     * @returns {WebGLTexture} a fresh texture object
-     * @ignore
-     */
-    onCreate(): WebGLTexture;
-    /**
-     * Push the source's pixels.
-     *
-     * Delegated to a per-call closure rather than implemented here, because a
-     * GL upload needs the *batcher's* `createTexture2D`: it binds the target
-     * unit, tracks immutable-storage shape, and swaps the texture object when
-     * the shape changes. None of that is residency, and moving it into the
-     * store would drag the batcher's unit bookkeeping along with it.
-     * @param {WebGLTexture} handle - the existing texture object
-     * @param {object} source - the image/canvas being uploaded
-     * @param {object} record - the resident record
-     * @param {object} options - carries `upload(handle)`
-     * @returns {WebGLTexture} the handle actually used, which may be a
-     * replacement when immutable storage had to be respecified
-     * @ignore
-     */
-    onUpload(handle: WebGLTexture, source: object, record: object, options: object): WebGLTexture;
-    /**
-     * @param {WebGLTexture} handle - the texture object to release
-     * @ignore
-     */
-    onDestroy(handle: WebGLTexture): void;
-}
+
 import { TextureStore } from "./../../gpu/texturestore.js";
 //# sourceMappingURL=store.d.ts.map

package/build/video/webgl/texture/store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/texture/store.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;OAGG;IACH,gBAHW,sBAAsB,EAMhC;IADA,2BAAY;IAGb;;;OAGG;IACH,YAHa,YAAY,CAKxB;IAED;;;;;;;;;;;;;;;OAeG;IACH,iBARW,YAAY,UACZ,MAAM,UACN,MAAM,WACN,MAAM,GACJ,YAAY,CAMxB;IAED;;;OAGG;IACH,kBAHW,YAAY,QAKtB;CACD;6BA9D4B,6BAA6B"}
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/texture/store.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;OAIG;IACH,gBAJW,sBAAsB,EAOhC;IADA,2BAAY;IAGb;;;;OAIG;IACH,YAJa,YAAY,CAMxB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,iBATW,YAAY,UACZ,MAAM,UACN,MAAM,WACN,MAAM,GACJ,YAAY,CAOxB;IAED;;;;OAIG;IACH,kBAJW,YAAY,QAMtB;CACD;6BAnE4B,6BAA6B"}

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

@@ -1,12 +1,2 @@
-/**
- * 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): {};
+
 //# sourceMappingURL=attributes.d.ts.map

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;;;;;;;;;GASG;AACH,4DAmBC"}
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/attributes.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,4DAmBC"}

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

@@ -1,37 +1,2 @@
-/**
- * Resolve the texture-unit pool this renderer will use.
- *
- * Clamping happens ONCE, at renderer construction, before the batchers and the
- * `TextureCache` are built — every consumer derives from the result, so the
- * batchers' sampler counts and the cache's capacity cannot disagree. A setting
- * above what the device reports is clamped down rather than honoured: declaring
- * more `sampler2D` uniforms than the device has units fails to link, and a link
- * failure at startup is not a useful way to learn about a typo.
- * @param {number} deviceMax - the device's `MAX_TEXTURE_IMAGE_UNITS`
- * @param {"auto"|number} [setting="auto"] - the `maxTextures` application setting
- * @returns {number} the pool size, at least 1 and never above `deviceMax`
- * @ignore
- */
-export function resolveMaxTextures(deviceMax: number, setting?: "auto" | number): number;
-/**
- * Default ceiling applied when `maxTextures` is `"auto"`.
- *
- * There is no spec maximum to defer to — WebGL 2 / GLES 3.0 only set a
- * *minimum* of 16 for `MAX_TEXTURE_IMAGE_UNITS`, and an implementation may
- * report any value at or above it. What actually limits us is that the
- * multi-texture fragment shader unrolls one sampler and one branch per unit
- * (see `buildMultiTextureFragment`), so a very wide pool costs compile time
- * and register pressure, and historically some drivers mis-compile the widest
- * ladders. 32 covers current desktop and mobile hardware while staying a
- * conservative default; raise or lower it with the `maxTextures` setting.
- * @ignore
- */
-export const AUTO_MAX_TEXTURES: 32;
-/**
- * Smallest pool the engine will resolve to. A lit quad occupies a colour slot
- * and a normal-map slot simultaneously, so anything narrower makes the two ids
- * collide and the sprite samples its own albedo as a normal map.
- * @ignore
- */
-export const MIN_MAX_TEXTURES: 2;
+
 //# sourceMappingURL=maxtextures.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"maxtextures.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/maxtextures.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;GAaG;AACH,8CALW,MAAM,YACN,MAAM,GAAC,MAAM,GACX,MAAM,CAgBlB;AAlDD;;;;;;;;;;;;GAYG;AACH,gCAAiC,EAAE,CAAC;AAEpC;;;;;GAKG;AACH,+BAAgC,CAAC,CAAC"}
+{"version":3,"file":"maxtextures.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/maxtextures.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;GAcG;AACH,8CANW,MAAM,YACN,MAAM,GAAC,MAAM,GACX,MAAM,CAiBlB;AArDD;;;;;;;;;;;;;GAaG;AACH,gCAAiC,EAAE,CAAC;AAEpC;;;;;;GAMG;AACH,+BAAgC,CAAC,CAAC"}

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

@@ -1,15 +1,2 @@
-/**
- * set precision for the given shader source
- * won't do anything if the precision is already specified
- * @ignore
- */
-export function setPrecision(src: any, precision: any): any;
-/**
- * return the best shader precision for this device, up to the requested cap.
- * @ignore
- * @param {WebGLRenderingContext} gl - the current WebGL context
- * @param {boolean} [highPrecision=true] - if false, cap at "mediump" even when "highp" is available
- * @returns {string} "lowp", "mediump", or "highp"
- */
-export function getMaxShaderPrecision(gl: WebGLRenderingContext, highPrecision?: boolean): string;
+
 //# sourceMappingURL=precision.d.ts.map

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,4DA+BC;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;;;;;GAKG;AACH,4DA+BC;AAED;;;;;;;GAOG;AACH,0CAJW,qBAAqB,kBACrB,OAAO,GACL,MAAM,CAoBlB"}

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

@@ -1,6 +1,2 @@
-/**
- * Compile GLSL into a shader object
- * @ignore
- */
-export function compileProgram(gl: any, vertex: any, fragment: any, attributes: any): any;
+
 //# sourceMappingURL=program.d.ts.map

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

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

@@ -1,69 +1,2 @@
-/**
- * WebGL 2 sampler objects, deduplicated by their state.
- *
- * GL bakes wrap and filter into the texture *object*, which is why the same
- * image drawn at two repeat modes historically needed two texture units AND
- * two uploads (#1448). Sampler objects — core in GLES 3.0, and unconditionally
- * available since 20.0 dropped WebGL 1 — move that state out of the texture and
- * onto the unit, exactly as the WebGPU backend already separates `GPUTexture`
- * from `GPUSampler`.
- *
- * That separation is what lets texture residency be keyed by **source alone**:
- * one upload serves every variant, and the variant rides the sampler. Slot
- * assignment stays per `(source, variant)`, because a bound sampler applies to
- * a unit and a unit carries one at a time.
- *
- * Deliberately mirrors `WebGPUTextureStore.getSampler(filter, repeat, mipmaps)`
- * — same key, same dedup, so the two backends stay legible side by side.
- * @ignore
- */
-export class GLSamplerCache {
-    /**
-     * @param {WebGL2RenderingContext} gl - the owning context
-     * @ignore
-     */
-    constructor(gl: WebGL2RenderingContext);
-    gl: WebGL2RenderingContext;
-    /** @type {Map<string, WebGLSampler>} */
-    samplers: Map<string, WebGLSampler>;
-    lastFilter: number;
-    lastRepeat: any;
-    lastMipmap: any;
-    lastSampler: WebGLSampler | null;
-    /** @type {Array<WebGLSampler|null>} */
-    bound: Array<WebGLSampler | null>;
-    /**
-     * The sampler for a filter/wrap/mip combination, created once and reused.
-     *
-     * There are only a handful of live combinations in any scene — two filters
-     * times four repeat modes — so this Map stays tiny however many textures a
-     * game loads.
-     * @param {number} filter - `gl.NEAREST` or `gl.LINEAR`
-     * @param {string} [repeat="no-repeat"] - canvas-style repeat mode
-     * @param {boolean} [mipmap=false] - sample the mip chain (trilinear)
-     * @returns {WebGLSampler} the shared sampler
-     * @ignore
-     */
-    get(filter: number, repeat?: string, mipmap?: boolean): WebGLSampler;
-    /**
-     * Bind a sampler to a texture unit, or unbind with `null`.
-     *
-     * A bound sampler overrides the texture object's own parameters entirely,
-     * which is what makes one texture usable at several variants at once.
-     * @param {number} unit - the texture unit
-     * @param {WebGLSampler|null} sampler - the sampler, or `null` to fall back
-     * to the texture's own state
-     * @ignore
-     */
-    bind(unit: number, sampler: WebGLSampler | null): void;
-    /**
-     * Delete every sampler. Called on context loss — the GL objects died with
-     * the context, so this only drops our side of the bookkeeping and lets the
-     * next `get` mint fresh ones.
-     * @param {boolean} [destroy=false] - whether to `deleteSampler` first
-     * (orderly teardown; skip it for a lost context)
-     * @ignore
-     */
-    releaseAll(destroy?: boolean): void;
-}
+
 //# sourceMappingURL=samplercache.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"samplercache.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/samplercache.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACC;;;OAGG;IACH,gBAHW,sBAAsB,EAmBhC;IAfA,2BAAY;IACZ,wCAAwC;IACxC,UADW,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CACX;IAKzB,mBAAoB;IACpB,gBAAsB;IACtB,gBAAsB;IACtB,iCAAuB;IAGvB,uCAAuC;IACvC,OADW,KAAK,CAAC,YAAY,GAAC,IAAI,CAAC,CACpB;IAGhB;;;;;;;;;;;OAWG;IACH,YANW,MAAM,WACN,MAAM,WACN,OAAO,GACL,YAAY,CAsCxB;IAED;;;;;;;;;OASG;IACH,WALW,MAAM,WACN,YAAY,GAAC,IAAI,QAU3B;IAED;;;;;;;OAOG;IACH,qBAJW,OAAO,QAiBjB;CACD"}
+{"version":3,"file":"samplercache.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/samplercache.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACC;;;;OAIG;IACH,gBAJW,sBAAsB,EAoBhC;IAfA,2BAAY;IACZ,wCAAwC;IACxC,UADW,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CACX;IAKzB,mBAAoB;IACpB,gBAAsB;IACtB,gBAAsB;IACtB,iCAAuB;IAGvB,uCAAuC;IACvC,OADW,KAAK,CAAC,YAAY,GAAC,IAAI,CAAC,CACpB;IAGhB;;;;;;;;;;;;OAYG;IACH,YAPW,MAAM,WACN,MAAM,WACN,OAAO,GACL,YAAY,CAuCxB;IAED;;;;;;;;;;OAUG;IACH,WANW,MAAM,WACN,YAAY,GAAC,IAAI,QAW3B;IAED;;;;;;;;OAQG;IACH,qBALW,OAAO,QAkBjB;CACD"}

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

@@ -1,22 +1,2 @@
-/**
- * clean the given source from space, comments, etc...
- * @ignore
- */
-export function minify(src: any): any;
-/**
- * Prepend preprocessor defines to a GLSL source, respecting `#version`.
- *
- * `#version` must be the very first statement of a GLSL ES 3.00 shader —
- * anything before it, including a `#define`, is a compile error. So defines
- * go immediately *after* that line when one is present, and at the top when
- * it is not (GLSL ES 1.00 sources declare no version).
- *
- * Used to compile shader variants from one source: the optional parts are
- * `#ifdef`-guarded, and the variant is what defines are injected here.
- * @param {string} source - the shader source
- * @param {string} defines - `#define` lines, each newline-terminated
- * @returns {string} the source with the defines injected
- * @ignore
- */
-export function injectDefines(source: string, defines: string): string;
+
 //# sourceMappingURL=string.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/string.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sCAWC;AAED;;;;;;;;;;;;;;GAcG;AACH,sCALW,MAAM,WACN,MAAM,GACJ,MAAM,CAoBlB"}
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/string.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,sCAWC;AAED;;;;;;;;;;;;;;;GAeG;AACH,sCANW,MAAM,WACN,MAAM,GACJ,MAAM,CAqBlB"}

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

@@ -1,24 +1,2 @@
-/**
- * Normalize a draw mode to its GL enum.
- *
- * Accepts either vocabulary and always returns a number, so callers can keep
- * comparing modes numerically. This matters more than it looks: a topology
- * string that reaches a GL draw call is coerced to `NaN` and then to `0`,
- * which *is* `POINTS` — so a missed translation does not throw, it silently
- * renders the batch as points.
- * @param {WebGL2RenderingContext} gl - the rendering context
- * @param {string|GLenum} value - a topology name or a GL primitive enum
- * @returns {GLenum} the GL primitive mode
- * @throws {Error} when `value` is neither a known topology nor a number
- * @ignore
- */
-export function resolveTopology(gl: WebGL2RenderingContext, value: string | GLenum): GLenum;
-/**
- * Name a GL primitive mode in the neutral vocabulary.
- * @param {WebGL2RenderingContext} gl - the rendering context
- * @param {GLenum} mode - a GL primitive mode
- * @returns {string|undefined} the topology name, or `undefined` for an unknown mode
- * @ignore
- */
-export function topologyFromGL(gl: WebGL2RenderingContext, mode: GLenum): string | undefined;
+
 //# sourceMappingURL=topology.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"topology.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/topology.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;GAaG;AACH,oCANW,sBAAsB,SACtB,MAAM,GAAC,MAAM,GACX,MAAM,CA0BlB;AAED;;;;;;GAMG;AACH,mCALW,sBAAsB,QACtB,MAAM,GACJ,MAAM,GAAC,SAAS,CAa5B"}
+{"version":3,"file":"topology.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/topology.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;GAcG;AACH,oCAPW,sBAAsB,SACtB,MAAM,GAAC,MAAM,GACX,MAAM,CA2BlB;AAED;;;;;;;GAOG;AACH,mCANW,sBAAsB,QACtB,MAAM,GACJ,MAAM,GAAC,SAAS,CAc5B"}

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

@@ -1,26 +1,2 @@
-/**
- * Capture the current value into the cache slot so future `setUniform`
- * calls can short-circuit. Reuses the existing slot (and its allocation)
- * when the length matches — only a length change or a first capture
- * allocates a fresh array.
- * @ignore
- */
-export function captureValue(prev: any, val: any): any;
-/**
- * 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): {};
+
 //# sourceMappingURL=uniforms.d.ts.map

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":"AA6DA;;;;;;GAMG;AACH,uDAoBC;AAED;;;;;;;;;;;;;;;GAeG;AACH,0DAmEC"}
+{"version":3,"file":"uniforms.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/uniforms.js"],"names":[],"mappings":"AA+DA;;;;;;;GAOG;AACH,uDAoBC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,0DAmEC"}

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

@@ -1,27 +1,2 @@
-/**
- * The GL enum a vertex format's components are read as.
- * @param {WebGL2RenderingContext} gl - the rendering context
- * @param {string} format - a supported vertex format name
- * @returns {GLenum} the matching component type
- * @throws {Error} when `format` is not a supported format name
- * @ignore
- */
-export function glTypeForFormat(gl: WebGL2RenderingContext, format: string): GLenum;
-/**
- * Name a WebGL attribute description in the neutral vocabulary.
- *
- * Returns `undefined` when the combination has no name — three-component 8-
- * and 16-bit types, for instance, which the GPU vocabulary simply does not
- * define. That absence is deliberate and meaningful: a made-up name would
- * travel into a backend that cannot honour it and fail there, far from the
- * layout that produced it. An attribute with no portable format is still
- * perfectly valid on the WebGL path.
- * @param {WebGL2RenderingContext} gl - the rendering context
- * @param {number} size - component count (1-4)
- * @param {GLenum} type - component type
- * @param {boolean} normalized - whether integers are scaled into `[0, 1]` / `[-1, 1]`
- * @returns {string|undefined} the format name, or `undefined` when none exists
- * @ignore
- */
-export function formatFromGL(gl: WebGL2RenderingContext, size: number, type: GLenum, normalized: boolean): string | undefined;
+
 //# sourceMappingURL=vertexformat.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"vertexformat.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/vertexformat.js"],"names":[],"mappings":"AAgCA;;;;;;;GAOG;AACH,oCANW,sBAAsB,UACtB,MAAM,GACJ,MAAM,CAOlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,iCAPW,sBAAsB,QACtB,MAAM,QACN,MAAM,cACN,OAAO,GACL,MAAM,GAAC,SAAS,CAwC5B"}
+{"version":3,"file":"vertexformat.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/utils/vertexformat.js"],"names":[],"mappings":"AAkCA;;;;;;;;GAQG;AACH,oCAPW,sBAAsB,UACtB,MAAM,GACJ,MAAM,CAQlB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,iCARW,sBAAsB,QACtB,MAAM,QACN,MAAM,cACN,OAAO,GACL,MAAM,GAAC,SAAS,CAyC5B"}