melonjs 20.3.0 → 20.5.0

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"}