melonjs 20.3.0 → 20.5.0

package/build/video/texture/noise_texture2d.d.ts

@@ -1,4 +1,100 @@
 export default NoiseTexture2d;
+/**
+ * What a {@link NoiseTexture2d} bakes WITH — its own settings, as opposed to
+ * the field's.
+ */
+export type NoiseTexture2dBakeSettings = {
+    /**
+     * - baked texture width in pixels
+     */
+    width?: number;
+    /**
+     * - baked texture height in pixels
+     */
+    height?: number;
+    /**
+     * - an existing {@link Noise} to bake; when omitted
+     * one is built from the forwarded field settings
+     */
+    noise?: Noise;
+    /**
+     * - tile cleanly in both axes
+     */
+    seamless?: boolean;
+    /**
+     * - edge blend band width as a
+     * fraction (0..1) of the smaller dimension, when `seamless`
+     */
+    seamlessBlendSkirt?: number;
+    /**
+     * - invert the noise value (`1 - v`)
+     */
+    invert?: boolean;
+    /**
+     * - encode as a normal map
+     */
+    asNormalMap?: boolean;
+    /**
+     * - normal steepness when `asNormalMap`
+     */
+    bumpStrength?: number;
+    /**
+     * - map the noise
+     * value to a color
+     */
+    colorRamp?: import("../gradient.js").Gradient;
+    /**
+     * - sample in 3D (`getNoise3d`) using an
+     * internal `time` as the third axis, advanced by {@link NoiseTexture2d#update}
+     */
+    animated?: boolean;
+    /**
+     * - animation speed in noise z-units per second
+     * (only used while `animated`)
+     */
+    speed?: number;
+};
+/**
+ * Everything the constructor takes.
+ *
+ * The settings object is handed to {@link Noise} WHOLE when no `noise` instance
+ * is given, so every field setting — `type`, `seed`, `frequency`/`scale`,
+ * `octaves`, `gain`/`persistence`, `lacunarity`, `fractalType`, the domain-warp
+ * settings — belongs here too. Spelling them out a second time is what would
+ * drift; the intersection cannot.
+ */
+export type NoiseTexture2dSettings = NoiseTexture2dBakeSettings & import("../../math/noise.ts").NoiseSettings;
+/**
+ * What a {@link NoiseTexture2d} bakes WITH — its own settings, as opposed to
+ * the field's.
+ * @typedef {object} NoiseTexture2dBakeSettings
+ * @property {number} [width=256] - baked texture width in pixels
+ * @property {number} [height=256] - baked texture height in pixels
+ * @property {Noise} [noise] - an existing {@link Noise} to bake; when omitted
+ * one is built from the forwarded field settings
+ * @property {boolean} [seamless=false] - tile cleanly in both axes
+ * @property {number} [seamlessBlendSkirt=0.1] - edge blend band width as a
+ * fraction (0..1) of the smaller dimension, when `seamless`
+ * @property {boolean} [invert=false] - invert the noise value (`1 - v`)
+ * @property {boolean} [asNormalMap=false] - encode as a normal map
+ * @property {number} [bumpStrength=1] - normal steepness when `asNormalMap`
+ * @property {import("../gradient.js").Gradient} [colorRamp] - map the noise
+ * value to a color
+ * @property {boolean} [animated=false] - sample in 3D (`getNoise3d`) using an
+ * internal `time` as the third axis, advanced by {@link NoiseTexture2d#update}
+ * @property {number} [speed=1] - animation speed in noise z-units per second
+ * (only used while `animated`)
+ */
+/**
+ * Everything the constructor takes.
+ *
+ * The settings object is handed to {@link Noise} WHOLE when no `noise` instance
+ * is given, so every field setting — `type`, `seed`, `frequency`/`scale`,
+ * `octaves`, `gain`/`persistence`, `lacunarity`, `fractalType`, the domain-warp
+ * settings — belongs here too. Spelling them out a second time is what would
+ * drift; the intersection cannot.
+ * @typedef {NoiseTexture2dBakeSettings & import("../../math/noise.ts").NoiseSettings} NoiseTexture2dSettings
+ */
 /**
  * A {@link Texture2d} that bakes a {@link Noise} field into a drawable canvas —
  * usable directly as a sprite image, a normal map, an image layer, or a custom
@@ -41,39 +137,10 @@ export default NoiseTexture2d;
  */
 declare class NoiseTexture2d extends Texture2d {
     /**
-     * @param {object} [settings] - configuration; any {@link Noise} setting
-     * (`type`, `seed`, `frequency`/`scale`, `octaves`, `gain`/`persistence`,
-     * `lacunarity`, `fractalType`, domain-warp settings) is forwarded when no
-     * `noise` instance is given.
-     * @param {number} [settings.width=256] - baked texture width in pixels
-     * @param {number} [settings.height=256] - baked texture height in pixels
-     * @param {Noise} [settings.noise] - an existing {@link Noise} to bake; when
-     * omitted one is built from the forwarded settings
-     * @param {boolean} [settings.seamless=false] - tile cleanly in both axes
-     * @param {number} [settings.seamlessBlendSkirt=0.1] - edge blend band width
-     * as a fraction (0..1) of the smaller dimension, when `seamless`
-     * @param {boolean} [settings.invert=false] - invert the noise value (`1 - v`)
-     * @param {boolean} [settings.asNormalMap=false] - encode as a normal map
-     * @param {number} [settings.bumpStrength=1] - normal steepness when `asNormalMap`
-     * @param {Gradient} [settings.colorRamp] - map the noise value to a color
-     * @param {boolean} [settings.animated=false] - sample in 3D (`getNoise3d`)
-     * using an internal `time` as the third axis, advanced by {@link NoiseTexture2d#update}
-     * @param {number} [settings.speed=1] - animation speed in noise z-units per
-     * second (only used while `animated`)
-     */
-    constructor(settings?: {
-        width?: number | undefined;
-        height?: number | undefined;
-        noise?: Noise | undefined;
-        seamless?: boolean | undefined;
-        seamlessBlendSkirt?: number | undefined;
-        invert?: boolean | undefined;
-        asNormalMap?: boolean | undefined;
-        bumpStrength?: number | undefined;
-        colorRamp?: any;
-        animated?: boolean | undefined;
-        speed?: number | undefined;
-    });
+     * @param {NoiseTexture2dSettings} [settings] - bake settings, plus any
+     * {@link NoiseSettings} for the field itself
+     */
+    constructor(settings?: NoiseTexture2dSettings);
     /** baked texture width in pixels @type {number} */
     width: number;
     /** baked texture height in pixels @type {number} */
@@ -98,15 +165,6 @@ declare class NoiseTexture2d extends Texture2d {
     speed: number;
     /** the current animation time (third sampling axis) @type {number} */
     time: number;
-    /** the baked output canvas (reused across re-bakes) @type {HTMLCanvasElement|null} @ignore */
-    _canvas: HTMLCanvasElement | null;
-    /** reused ImageData scratch (avoids a per-bake allocation) @type {ImageData|null} @ignore */
-    _imageData: ImageData | null;
-    /** reused height-field scratch (avoids a per-bake allocation) @type {Float32Array|null} @ignore */
-    _heights: Float32Array | null;
-    /** content revision, bumped on every bake and stamped on the canvas so
-     * the renderer re-uploads the GPU texture when it changes @type {number} @ignore */
-    _version: number;
     /**
      * The current content revision, bumped on every {@link NoiseTexture2d#bake}.
      * Also stamped on the baked canvas (`getTexture().version`) so the renderer
@@ -132,45 +190,11 @@ declare class NoiseTexture2d extends Texture2d {
      * @returns {NoiseTexture2d} this texture for chaining
      */
     update(dt: number): NoiseTexture2d;
-    /**
-     * Raw noise sample at a texture pixel (2D, or 3D when animated). The time
-     * axis is divided by the noise frequency so that, after `getNoise3d` scales
-     * all coords by frequency, the field evolves at `speed` noise-units/second —
-     * decoupled from the spatial frequency (otherwise low-frequency textures
-     * would animate imperceptibly slowly).
-     * @ignore
-     */
-    _rawNoise(x: any, y: any): number;
-    /**
-     * x-axis seamless blend: in the right skirt band, cross-fade toward the
-     * wrapped (period-shifted) sample so the left and right edges meet.
-     * @ignore
-     */
-    _blendX(x: any, y: any, w: any, sk: any): any;
-    /**
-     * Sample the noise into a `[0, 1]` height field. When `seamless`, a skirt
-     * cross-fade near the far edges blends opposite edges so the texture tiles
-     * with a much-reduced seam.
-     * @returns {Float32Array} the per-pixel height field (length `width*height`)
-     * @ignore
-     */
-    _buildHeightField(): Float32Array;
-    /** @ignore */
-    _writeGrayscale(data: any, heights: any): void;
-    /** @ignore */
-    _writeColorRamp(data: any, heights: any): void;
-    /**
-     * Encode the height field as a tangent-space normal map (RGB), with screen-Y
-     * flipped to normal-map Y-up so it round-trips through the lit shader's
-     * `rgb * 2 - 1` decode. Neighbor samples wrap when `seamless`.
-     * @ignore
-     */
-    _writeNormalMap(data: any, heights: any): void;
     /**
      * @returns {HTMLCanvasElement} the baked texture canvas
      */
     getTexture(): HTMLCanvasElement;
 }
-import Texture2d from "./texture2d.ts";
 import { Noise } from "../../math/noise.ts";
+import Texture2d from "./texture2d.ts";
 //# sourceMappingURL=noise_texture2d.d.ts.map

package/build/video/texture/noise_texture2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"noise_texture2d.d.ts","sourceRoot":"","sources":["../../../src/video/texture/noise_texture2d.js"],"names":[],"mappings":";AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IACC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,uBAhBG;QAA0B,KAAK;QACL,MAAM;QACP,KAAK;QAEH,QAAQ;QACT,kBAAkB;QAEjB,MAAM;QACN,WAAW;QACZ,YAAY;QACV,SAAS;QACV,QAAQ;QAET,KAAK;KAEjC,EA4CA;IAxCA,mDAAmD;IACnD,OADyC,MAAM,CACb;IAClC,oDAAoD;IACpD,QAD0C,MAAM,CACZ;IACpC,0DAA0D;IAC1D,OADiD,KAAK,CAEiB;IACvE,gDAAgD;IAChD,UADqC,OAAO,CACF;IAC1C,2EAA2E;IAC3E,oBADiE,MAAM,CAItE;IACD,6CAA6C;IAC7C,QADkC,OAAO,CACH;IACtC,qEAAqE;IACrE,aAD0D,OAAO,CACjB;IAChD,yDAAyD;IACzD,cAD+C,MAAM,CACL;IAChD,2EAA2E;IAC3E,WAD0D,QAAQ,GAAC,IAAI,CAC5B;IAC3C,4EAA4E;IAC5E,UADiE,OAAO,CAC9B;IAC1C,iEAAiE;IACjE,OADuD,MAAM,CAC7B;IAChC,sEAAsE;IACtE,MAD4D,MAAM,CACrD;IAEb,8FAA8F;IAC9F,SAD4D,iBAAiB,GAAC,IAAI,CAC/D;IACnB,6FAA6F;IAC7F,YADmE,SAAS,GAAC,IAAI,CAC3D;IACtB,mGAAmG;IACnG,UADsE,YAAY,GAAC,IAAI,CACnE;IACpB;wFACoF;IACpF,UADkE,MAAM,CACvD;IAKlB;;;;;OAKG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,QAFa,cAAc,CAiC1B;IAED;;;;;;;;;OASG;IACH,WAHW,MAAM,GACJ,cAAc,CAQ1B;IAED;;;;;;;OAOG;IACH,kCAMC;IAED;;;;OAIG;IACH,8CAOC;IAED;;;;;;OAMG;IACH,qBAHa,YAAY,CA2CxB;IAED,cAAc;IACd,+CASC;IAED,cAAc;IACd,+CAWC;IAED;;;;;OAKG;IACH,+CA+BC;IAED;;OAEG;IACH,cAFa,iBAAiB,CAI7B;CAcD;sBA5VqB,gBAAgB;sBAFhB,qBAAqB"}
+{"version":3,"file":"noise_texture2d.d.ts","sourceRoot":"","sources":["../../../src/video/texture/noise_texture2d.js"],"names":[],"mappings":";;;;;;;;;YAkBc,MAAM;;;;aACN,MAAM;;;;;YACN,KAAK;;;;eAEL,OAAO;;;;;yBACP,MAAM;;;;aAEN,OAAO;;;;kBACP,OAAO;;;;mBACP,MAAM;;;;;gBACN,OAAO,gBAAgB,EAAE,QAAQ;;;;;eAEjC,OAAO;;;;;YAEP,MAAM;;;;;;;;;;;qCAYP,0BAA0B,GAAG,OAAO,qBAAqB,EAAE,aAAa;AA9BrF;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IACC;;;OAGG;IACH,uBAHW,sBAAsB,EA0DhC;IApDA,mDAAmD;IACnD,OADyC,MAAM,CACb;IAClC,oDAAoD;IACpD,QAD0C,MAAM,CACZ;IACpC,0DAA0D;IAC1D,OADiD,KAAK,CAEiB;IACvE,gDAAgD;IAChD,UADqC,OAAO,CACF;IAC1C,2EAA2E;IAC3E,oBADiE,MAAM,CAItE;IACD,6CAA6C;IAC7C,QADkC,OAAO,CACH;IACtC,qEAAqE;IACrE,aAD0D,OAAO,CACjB;IAChD,yDAAyD;IACzD,cAD+C,MAAM,CACL;IAChD,2EAA2E;IAC3E,WAD0D,QAAQ,GAAC,IAAI,CAC5B;IAC3C,4EAA4E;IAC5E,UADiE,OAAO,CAC9B;IAC1C,iEAAiE;IACjE,OADuD,MAAM,CAC7B;IAChC,sEAAsE;IACtE,MAD4D,MAAM,CACrD;IAEb;;;;OAIG;IACH,SAJ2D,iBAAiB,GAAC,IAAI,CAI9D;IACnB;;;;OAIG;IACH,YAJkE,SAAS,GAAC,IAAI,CAI1D;IACtB;;;;OAIG;IACH,UAJqE,YAAY,GAAC,IAAI,CAIlE;IACpB;wFACoF;IACpF,UADkE,MAAM,CACvD;IAKlB;;;;;OAKG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,QAFa,cAAc,CAiC1B;IAED;;;;;;;;;OASG;IACH,WAHW,MAAM,GACJ,cAAc,CAQ1B;IAED;;;;;;;;OAQG;IACH,kCAMC;IAED;;;;;OAKG;IACH,8CAOC;IAED;;;;;;;OAOG;IACH,qBAJa,YAAY,CA4CxB;IAED;;;OAGG;IACH,+CASC;IAED;;;OAGG;IACH,+CAWC;IAED;;;;;;OAMG;IACH,+CA+BC;IAED;;OAEG;IACH,cAFa,iBAAiB,CAI7B;CAcD;sBApYqB,qBAAqB;sBAErB,gBAAgB"}

package/build/video/texture/parser/aseprite.d.ts

@@ -1,9 +1,2 @@
-/**
- * parse the given data and return a corresponding atlas
- * @param {Object} data - atlas data information. See {@link loader.getJSON}
- * @param {TextureAtlas} textureAtlas - the texture atlas class calling the parser
- * @returns {Object} the corresponding Atlas
- * @ignore
- */
-export function parseAseprite(data: Object, textureAtlas: TextureAtlas): Object;
+
 //# sourceMappingURL=aseprite.d.ts.map

package/build/video/texture/parser/aseprite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aseprite.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/aseprite.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,oCALW,MAAM,gBACN,YAAY,GACV,MAAM,CAsFlB"}
+{"version":3,"file":"aseprite.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/aseprite.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,oCANW,MAAM,gBACN,YAAY,GACV,MAAM,CAuFlB"}

package/build/video/texture/parser/spritesheet.d.ts

@@ -1,9 +1,2 @@
-/**
- * parse the given data and return a corresponding atlas
- * @param {Object} data - atlas data information. See {@link loader.getJSON}
- * @param {TextureAtlas} textureAtlas - the texture atlas class calling the parser
- * @returns {Object} the corresponding Atlas
- * @ignore
- */
-export function parseSpriteSheet(data: Object, textureAtlas: TextureAtlas): Object;
+
 //# sourceMappingURL=spritesheet.d.ts.map

package/build/video/texture/parser/spritesheet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spritesheet.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/spritesheet.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,uCALW,MAAM,gBACN,YAAY,GACV,MAAM,CA2ElB"}
+{"version":3,"file":"spritesheet.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/spritesheet.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,uCANW,MAAM,gBACN,YAAY,GACV,MAAM,CA4ElB"}

package/build/video/texture/parser/texturepacker.d.ts

@@ -1,9 +1,2 @@
-/**
- * parse the given data and return a corresponding atlas
- * @param {Object} data - atlas data information. See {@link loader.getJSON}
- * @param {TextureAtlas} textureAtlas - the texture atlas class calling the parser
- * @returns {Object} the corresponding Atlas
- * @ignore
- */
-export function parseTexturePacker(data: Object, textureAtlas: TextureAtlas): Object;
+
 //# sourceMappingURL=texturepacker.d.ts.map

package/build/video/texture/parser/texturepacker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texturepacker.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/texturepacker.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,yCALW,MAAM,gBACN,YAAY,GACV,MAAM,CAwDlB"}
+{"version":3,"file":"texturepacker.d.ts","sourceRoot":"","sources":["../../../../src/video/texture/parser/texturepacker.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH,yCANW,MAAM,gBACN,YAAY,GACV,MAAM,CAyDlB"}

package/build/video/texture/resource.d.ts

@@ -52,13 +52,6 @@ export class TextureResource {
     filter: number | undefined;
     sources: Map<string, this>;
     activeAtlas: string;
-    /**
-     * Returns the upload "source" the batcher hands to `createTexture2D`.
-     * For a resource this is the resource itself — `createTexture2D`
-     * dispatches to `resource.upload(context, target)`.
-     * @ignore
-     */
-    getTexture(): this;
     /**
      * Issue the backend-specific upload call (`gl.texImage2D` on WebGL,
      * the WebGPU equivalent once that renderer lands) that places this
@@ -115,7 +108,5 @@ export class BufferTextureResource extends TextureResource {
     data: ArrayBufferView;
     /** @type {string} */
     format: string;
-    /** @ignore */
-    upload(context: any, target: any): void;
 }
 //# sourceMappingURL=resource.d.ts.map

package/build/video/texture/resource.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../../src/video/texture/resource.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;;;;;;;OAQG;IACH,qEAPG;QAAwB,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACY,kBAAkB;QAClB,MAAM;QACN,MAAM;KAElC,EAsBA;IAdA,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB,sBAAsB;IACtB,oBADW,OAAO,CAC0B;IAC5C,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB,+BAA+B;IAC/B,QADW,MAAM,GAAC,SAAS,CACP;IAGpB,2BAA2C;IAC3C,oBAA4B;IAG7B;;;;;OAKG;IACH,mBAEC;IAED;;;;;;;;;;OAUG;IAEH,gBANW,qBAAqB,GAAC,sBAAsB,UAE5C,MAAM,QAMhB;CACD;AAED;;;;;;;;;;;;GAYG;AACH;IACC;;;;;;;;;;;;;;;;OAgBG;IACH,kBAhBW,eAAe,WAIvB;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,kBAAkB;QAClB,MAAM;QACN,MAAM;QACI,MAAM;KAM5C,EAOA;IAJA,8BAA8B;IAC9B,MADW,eAAe,CACV;IAChB,qBAAqB;IACrB,QADW,MAAM,CACsB;IAGxC,cAAc;IACd,wCAoCC;CACD"}
+{"version":3,"file":"resource.d.ts","sourceRoot":"","sources":["../../../src/video/texture/resource.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;;;;;;;OAQG;IACH,qEAPG;QAAwB,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACY,kBAAkB;QAClB,MAAM;QACN,MAAM;KAElC,EAsBA;IAdA,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB,sBAAsB;IACtB,oBADW,OAAO,CAC0B;IAC5C,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB,+BAA+B;IAC/B,QADW,MAAM,GAAC,SAAS,CACP;IAGpB,2BAA2C;IAC3C,oBAA4B;IAG7B;;;;;;OAMG;IACH,mBAEC;IAED;;;;;;;;;;OAUG;IAEH,gBANW,qBAAqB,GAAC,sBAAsB,UAE5C,MAAM,QAMhB;CACD;AAED;;;;;;;;;;;;GAYG;AACH;IACC;;;;;;;;;;;;;;;;OAgBG;IACH,kBAhBW,eAAe,WAIvB;QAAyB,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACY,kBAAkB;QAClB,MAAM;QACN,MAAM;QACI,MAAM;KAM5C,EAOA;IAJA,8BAA8B;IAC9B,MADW,eAAe,CACV;IAChB,qBAAqB;IACrB,QADW,MAAM,CACsB;IAGxC;;;OAGG;IACH,wCAoCC;CACD"}

package/build/video/texture/texture2d.d.ts

@@ -1,8 +1,3 @@
-/**
- * Compile-time-only brand key; no runtime value can hold it.
- * @ignore
- */
-declare const gpuResidentBrand: unique symbol;
 /**
  * An opaque, GPU-resident texture backing — the source a GPU-resident
  * {@link Texture2d} resolves to (for example the framebuffer copy
@@ -17,11 +12,6 @@ declare const gpuResidentBrand: unique symbol;
  * {@link Texture2dSource} (and {@link Texture2d#getTexture}) honestly typed.
  */
 export interface GPUResidentTexture {
-    /**
-     * Phantom nominal brand — never present at runtime.
-     * @ignore
-     */
-    readonly [gpuResidentBrand]: true;
 }
 /**
  * The backing source a {@link Texture2d} resolves to through
@@ -79,5 +69,4 @@ export default abstract class Texture2d {
      */
     destroy(): void;
 }
-export {};
 //# sourceMappingURL=texture2d.d.ts.map

package/build/video/texture/texture2d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texture2d.d.ts","sourceRoot":"","sources":["../../../src/video/texture/texture2d.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,OAAO,CAAC,MAAM,gBAAgB,EAAE,OAAO,MAAM,CAAC;AAE9C;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;OAGG;IACH,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAE,IAAI,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GACxB,iBAAiB,GACjB,gBAAgB,GAChB,eAAe,GACf,WAAW,GACX,kBAAkB,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,SAAS;IACtC;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,IAAI,eAAe;IAEtC;;;;;;;;;OASG;IACH,OAAO,IAAI,IAAI;CAGf"}
+{"version":3,"file":"texture2d.d.ts","sourceRoot":"","sources":["../../../src/video/texture/texture2d.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,kBAAkB;CAOlC;AAED;;;;GAIG;AACH,MAAM,MAAM,eAAe,GACxB,iBAAiB,GACjB,gBAAgB,GAChB,eAAe,GACf,WAAW,GACX,kBAAkB,CAAC;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,SAAS;IACtC;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,IAAI,eAAe;IAEtC;;;;;;;;;OASG;IACH,OAAO,IAAI,IAAI;CAGf"}

package/build/video/utils/autodetect.d.ts

@@ -1,8 +1,4 @@
-/**
- * Auto-detect the best renderer to use
- * @ignore
- */
-export function autoDetectRenderer(options: any): CanvasRenderer | WebGLRenderer;
+
 import CanvasRenderer from "../canvas/canvas_renderer";
 import WebGLRenderer from "../webgl/webgl_renderer";
 //# sourceMappingURL=autodetect.d.ts.map

package/build/video/utils/autodetect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"autodetect.d.ts","sourceRoot":"","sources":["../../../src/video/utils/autodetect.js"],"names":[],"mappings":"AAkCA;;;GAGG;AACH,iFAeC;2BApD0B,2BAA2B;0BAC5B,yBAAyB"}
+{"version":3,"file":"autodetect.d.ts","sourceRoot":"","sources":["../../../src/video/utils/autodetect.js"],"names":[],"mappings":"AAkCA;;;;GAIG;AACH,iFAeC;2BArD0B,2BAA2B;0BAC5B,yBAAyB"}

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

@@ -115,62 +115,7 @@ export class WebGLBatcher extends Batcher {
      * @type {boolean}
      */
     useIndexBuffer: boolean | undefined;
-    /**
-     * the GL vertex buffer object (own buffer for indexed batchers, null for shared)
-     * @type {WebGLBuffer|null}
-     * @ignore
-     */
-    glVertexBuffer: WebGLBuffer | null | undefined;
-    /**
-     * the dynamic index buffer (only for indexed batchers)
-     * @type {WebGLIndexBuffer|null}
-     * @ignore
-     */
-    indexBuffer: WebGLIndexBuffer | null | undefined;
-    /**
-     * The GL buffer this batcher uploads its vertex data into: its own
-     * buffer for indexed (mesh-family) batchers, otherwise the renderer's
-     * shared one.
-     * @type {WebGLBuffer}
-     * @ignore
-     */
-    get uploadBuffer(): WebGLBuffer;
-    /**
-     * (Re)build this batcher's {@link WebGLVertexState} — the frozen vertex
-     * buffer layout (`attributes` + `stride`) realized as a GL vertex array
-     * object bound to this batcher's upload buffer and, for indexed
-     * batchers, its index buffer.
-     *
-     * Every shader hosted by this batcher must declare a prefix of that
-     * layout, in layout order (see {@link validateShaderLocations}) — the
-     * locations are frozen here at the default shader's mapping.
-     * @ignore
-     */
-    createVertexState(): void;
-    /**
-     * Validate (once per shader) that a hosted shader's attribute locations
-     * match this batcher's frozen vertex state. The engine's analogue of
-     * WebGPU's pipeline-creation validation: locations are bound in vertex
-     * source declaration order, so every shader hosted by this batcher must
-     * declare a prefix of the batcher's attribute layout, in layout order.
-     * A mismatched shader silently reads wrong vertex data — warn loudly.
-     * @ignore
-     */
-    validateShaderLocations(shader: any): void;
     validatedShaders: WeakSet<object> | undefined;
-    /**
-     * Ensure the draw about to be recorded runs on THIS batcher's program.
-     * Normally `bind()` guaranteed that, but an `ONCONTEXT_RESTORED`
-     * emission recompiles every live GLShader — each replaying its uniform
-     * snapshot on its OWN program — leaving whichever recompiled last
-     * really bound while the renderer's cache still named another. The
-     * renderer invalidates its program cache on that event, so this
-     * pointer compare re-issues `useProgram` exactly when the drift
-     * happened and costs two loads otherwise. Called by every flush path
-     * (the base and the quad override).
-     * @ignore
-     */
-    syncProgram(): 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":"AASA;;;;;;GAMG;AAEH;;;;;;;GAOG;AACH;IAgBC;;;OAGG;IACH,sBAHW,aAAa,YACb,MAAM,EAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,eAfW,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,QA+IA;IAzIA,QAAqB;IAGrB,iCAA2C;IAE3C;;;OAGG;IACH,oCAA8B;IAE9B;;;OAGG;IACH,oCAA8B;IAoY/B;;OAEG;IACH,gBAFW,QAAQ,GAAC,MAAM,EASzB;IAxBD;;;;;;;;;OASG;IACH,YAHU,MAAM,CAKf;IAxXC,iDAAuB;IAGxB;;;;OAIG;IACH,iCAAoB;IAEpB;;;;;OAKG;IACH,2BAAe;IAEf;;;;;OAKG;IACH,+BAAmB;IAEnB;;;OAGG;IACH,0CAAsB;IA4CtB;;;OAGG;IACH,sCAA0E;IAE1E;;;OAGG;IACH,oCAA+C;IAE/C;;;;OAIG;IACH,+CAA0B;IAE1B;;;;OAIG;IACH,iDAAuB;IAgBxB;;;;;;OAMG;IACH,oBAHU,WAAW,CAKpB;IAED;;;;;;;;;;OAUG;IACH,0BAiBC;IAkGD;;;;;;;;OAQG;IACH,2CA0BC;IAxBC,8CAAqC;IA0BvC;;;;;;;;;;;OAWG;IACH,oBAaC;IAED;;;;OAIG;IACH,kBAFW,QAAQ,QAuBlB;IAHE,uCAA4B;IAmB/B;;OAEG;IACH,oBAFW,QAAQ,GAAC,MAAM,EAIzB;IAnBD;;;;;;;;;OASG;IACH,gBAHU,QAAQ,CAKjB;IAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,mBAPW,MAAM,GAAC,MAAM,SACb,MAAM,GAAC,YAAY,SACnB,MAAM,GAAC,MAAM,eACb,OAAO,WACP,MAAM,wBA4BhB;IAiJD;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,QAOlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAqEhB;;CACD;;wBAhxB6C,sBAAsB;+BAUtC,wBAAwB;8BAC3B,2BAA2B;qBAPjC,gBAAgB;8BASV,uBAAuB;6BAVrB,0BAA0B;8BAJzB,wBAAwB;6BAGzB,oBAAoB;kCAUlB,2BAA2B"}
+{"version":3,"file":"batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/batcher.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AAEH;;;;;;;GAOG;AACH;IAkBC;;;OAGG;IACH,sBAHW,aAAa,YACb,MAAM,EAKhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,eAfW,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,QAiJA;IA3IA,QAAqB;IAGrB,iCAA2C;IAE3C;;;OAGG;IACH,oCAA8B;IAE9B;;;OAGG;IACH,oCAA8B;IA4Y/B;;OAEG;IACH,gBAFW,QAAQ,GAAC,MAAM,EASzB;IAxBD;;;;;;;;;OASG;IACH,YAHU,MAAM,CAKf;IAhYC,iDAAuB;IAGxB;;;;OAIG;IACH,iCAAoB;IAEpB;;;;;OAKG;IACH,2BAAe;IAEf;;;;;OAKG;IACH,+BAAmB;IAEnB;;;OAGG;IACH,0CAAsB;IA4CtB;;;OAGG;IACH,sCAA0E;IAE1E;;;OAGG;IACH,oCAA+C;IAE/C;;;;;OAKG;IACH,+CAA0B;IAE1B;;;;;OAKG;IACH,iDAAuB;IAgBxB;;;;;;;OAOG;IACH,oBAJU,WAAW,CAMpB;IAED;;;;;;;;;;;OAWG;IACH,0BAiBC;IAoGD;;;;;;;;;OASG;IACH,2CA0BC;IAxBC,8CAAqC;IA0BvC;;;;;;;;;;;;OAYG;IACH,oBAaC;IAED;;;;OAIG;IACH,kBAFW,QAAQ,QAuBlB;IAHE,uCAA4B;IAmB/B;;OAEG;IACH,oBAFW,QAAQ,GAAC,MAAM,EAIzB;IAnBD;;;;;;;;;OASG;IACH,gBAHU,QAAQ,CAKjB;IAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,mBAPW,MAAM,GAAC,MAAM,SACb,MAAM,GAAC,YAAY,SACnB,MAAM,GAAC,MAAM,eACb,OAAO,WACP,MAAM,wBA4BhB;IAoJD;;;OAGG;IACH,sBAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,QAOlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAqEhB;;CACD;;wBA7xB6C,sBAAsB;+BAUtC,wBAAwB;8BAC3B,2BAA2B;qBAPjC,gBAAgB;8BASV,uBAAuB;6BAVrB,0BAA0B;8BAJzB,wBAAwB;6BAGzB,oBAAoB;kCAUlB,2BAA2B"}

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

@@ -12,20 +12,6 @@
  */
 export default class LitMeshBatcher extends MeshBatcher {
     lightBlock: UniformBlock | undefined;
-    _lightBlockProgram: any;
-    /**
-     * Point the active program's `Light3dBlock` at our uniform buffer.
-     *
-     * A block binding is program state, so it has to be re-established
-     * whenever the program changes: a context restore recompiles it, `init`
-     * re-runs on reset, and `useShader` can swap one in without a batcher
-     * transition. Comparing against the program we last bound covers all
-     * three — a pointer compare in the steady state.
-     * @ignore
-     */
-    _bindLightBlock(): void;
-    /** push the 12-float lit vertex, appending the mesh's world-space normal. @ignore */
-    _pushVertex(vertexData: any, x: any, y: any, z: any, u: any, v: any, color: any, mesh: any, i3: any): void;
 }
 import MeshBatcher from "./mesh_batcher.js";
 import UniformBlock from "../buffer/uniformblock.js";

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

@@ -1 +1 @@
-{"version":3,"file":"lit_mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_mesh_batcher.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;GAWG;AACH;IAuBE,qCAIC;IACD,wBAA8B;IAO/B;;;;;;;;;OASG;IACH,wBAQC;IAyCD,qFAAqF;IACrF,2GAaC;CA4DD;wBApMuB,mBAAmB;yBAPlB,2BAA2B"}
+{"version":3,"file":"lit_mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_mesh_batcher.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;GAWG;AACH;IA6BE,qCAIC;IACD;;;OAGG;IACH,wBAA8B;IAO/B;;;;;;;;;;OAUG;IACH,wBAQC;IAsDD;;;;OAIG;IACH,2GAaC;CA8DD;wBAlOuB,mBAAmB;yBAPlB,2BAA2B"}

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

@@ -18,54 +18,8 @@
  * @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;
-    /**
-     * Per-slot content `version` of the normal map currently bound there. An
-     * animated source keeps a stable canvas reference across re-bakes but
-     * bumps its `version`, so `addQuad` compares this (not just the reference)
-     * to know when to re-bind/re-upload. `-1` = nothing bound.
-     * @type {number[]}
-     * @ignore
-     */
-    boundNormalVersions: number[] | undefined;
     normalStore: WebGLTextureStore | undefined;
-    /**
-     * Which slot in the shared pool each normal-map source currently holds.
-     * Normal maps are not in the color `TextureCache` (they are raw sources
-     * with their own GL textures), so their unit assignment is tracked here
-     * while the unit itself comes from the same allocator the colors use.
-     * @type {Map<HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap, number>}
-     * @ignore
-     */
-    normalUnits: Map<ImageBitmap | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas, number> | undefined;
-    _cacheEpoch: any;
-    _lightCount: number | undefined;
-    _maxLights: number | undefined;
     lightBlock: UniformBlock | undefined;
-    _lightBlockProgram: any;
-    _onTexture2dDestroyed: ((source: any) => void) | null | undefined;
-    /**
-     * Point the active program's `Light2dBlock` at our uniform buffer.
-     *
-     * A block binding is *program* state, and the program can change under us
-     * in three ways: a context restore recompiles it, `setBatcher` can host a
-     * {@link ShaderEffect} on this batcher, and `init` re-runs on reset. Rather
-     * than hook each of those, re-bind whenever the program is not the one we
-     * last bound — a pointer compare per `bind`, and self-healing.
-     *
-     * A hosted `ShaderEffect` is a plain unlit ES 1.00 program with no light
-     * block, so `bindTo` reports failure and we simply record it, leaving the
-     * next real lit program to bind normally.
-     * @ignore
-     */
-    _bindLightBlock(): void;
     /**
      * Release the cached GL texture uploaded for the given normal-map source
      * and clear any slot bookkeeping referencing it. Safe to call for images
@@ -112,32 +66,6 @@ export default class LitQuadBatcher extends QuadBatcher {
      * @param {number} unit - GL texture unit the normal map is resolved to
      */
     bindNormalMap(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, unit: number): void;
-    /**
-     * Drop a normal map's slot claim and hand the unit back to the allocator.
-     *
-     * A normal map claims its unit through `allocateTextureUnit()`, which has no
-     * key to release against — so without this the unit stayed marked used for
-     * the rest of the session and the pool drained monotonically as normal maps
-     * came and went, until something forced a full reset.
-     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} image - normal-map source
-     * @ignore
-     */
-    releaseNormalUnit(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap): void;
-    /**
-     * Resolve a normal-map source to its slot in the shared pool, uploading and
-     * binding it if it is not already resident.
-     *
-     * A version-only bump (an animated source re-baking into the same canvas
-     * reference) re-uploads into the same GL handle and needs no flush —
-     * `version` only changes between frames, and the batch is flushed at every
-     * frame/camera boundary, so no in-flight vertex references stale content.
-     * A DIFFERENT source landing on a live slot does need the pending vertices
-     * drawn first.
-     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} normalMap - the source
-     * @returns {number} the slot to write into `aNormalTextureId`
-     * @ignore
-     */
-    resolveNormalUnit(normalMap: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap): number;
     /**
      * Add a textured quad with optional paired normal map.
      * @param {TextureAtlas} texture - Source texture atlas

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

@@ -1 +1 @@
-{"version":3,"file":"lit_quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_quad_batcher.js"],"names":[],"mappings":"AAcA;;;GAGG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IA8DE;;;;;;OAMG;IACH,6GAAiD;IAEjD;;;;;;;OAOG;IACH,0CAAmD;IAmBnD,2CAAiD;IAEjD;;;;;;;OAOG;IACH,2GAA4B;IAC5B,iBAAoB;IAEpB,gCAAoB;IACpB,+BAA4B;IAkB5B,qCAIC;IACD,wBAA8B;IAW7B,kEAEC;IAoCH;;;;;;;;;;;;;OAaG;IACH,wBAQC;IAED;;;;;OAKG;IACH,sBAFW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAaxE;IA8ED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,2BANG;QAA+B,SAAS,EAAhC,YAAY;QACW,MAAM,EAA7B,YAAY;QACY,OAAO;QACd,KAAK,EAAtB,MAAM;QACc,OAAO;KACrC,QAMA;IAED;;;;;;;;;OASG;IACH,qBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,QAqChB;IAED;;;;;;;;;OASG;IACH,yBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAaxE;IAED;;;;;;;;;;;;;OAaG;IACH,6BAJW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAC5D,MAAM,CAsClB;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,QAsIjD;CA+DD;wBA3qBuB,mBAAmB;kCADT,qBAAqB;yBAT9B,2BAA2B;kCAcrB,0BAA0B"}
+{"version":3,"file":"lit_quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/lit_quad_batcher.js"],"names":[],"mappings":"AAcA;;;GAGG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IA+DE;;;;;;;OAOG;IACH,6GAAiD;IAEjD;;;;;;;;OAQG;IACH,0CAAmD;IAoBnD,2CAAiD;IAEjD;;;;;;;;OAQG;IACH,2GAA4B;IAC5B;;;OAGG;IACH,iBAAoB;IAEpB;;;OAGG;IACH,gCAAoB;IACpB;;;OAGG;IACH,+BAA4B;IAuB5B,qCAIC;IACD;;;OAGG;IACH,wBAA8B;IAW7B,kEAEC;IAsCH;;;;;;;;;;;;;;OAcG;IACH,wBAQC;IAED;;;;;OAKG;IACH,sBAFW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAaxE;IAiFD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,2BANG;QAA+B,SAAS,EAAhC,YAAY;QACW,MAAM,EAA7B,YAAY;QACY,OAAO;QACd,KAAK,EAAtB,MAAM;QACc,OAAO;KACrC,QAMA;IAED;;;;;;;;;OASG;IACH,qBAHW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAC9D,MAAM,QAqChB;IAED;;;;;;;;;;OAUG;IACH,yBAJW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,QAcxE;IAED;;;;;;;;;;;;;;OAcG;IACH,6BALW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAC5D,MAAM,CAuClB;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,QAsIjD;CA+DD;wBA7sBuB,mBAAmB;kCADT,qBAAqB;yBAT9B,2BAA2B;kCAcrB,0BAA0B"}

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

@@ -1,49 +1,5 @@
 export class MaterialBatcher extends WebGLBatcher {
-    /**
-     * Initialize the textured batcher
-     * @ignore
-     */
-    init(renderer: any, settings: any): void;
     set currentTextureUnit(unit: number);
-    /**
-     * The GL texture unit currently active (`gl.activeTexture`). Tracked on
-     * the RENDERER, not per batcher: the active unit is global GL state
-     * shared by every batcher instance, and a per-batcher copy desyncs as
-     * soon as another batcher (or a blit, or an FBO pass) moves the active
-     * unit — the stale copy then lets `bindTexture2D` skip `gl.activeTexture`
-     * and bind (or upload) a texture onto whatever unit is REALLY active.
-     * Symptom was video force-re-uploads overwriting a mesh texture with
-     * video frames after a mesh pass.
-     * @type {number}
-     * @ignore
-     */
-    get currentTextureUnit(): number;
-    /**
-     * bound textures by unit
-     * @ignore
-     */
-    boundTextures: any[] | undefined;
-    /**
-     * Units whose texture CONTENT changed since the last upload (a
-     * canvas re-bake announced via `CanvasRenderTarget.invalidate`).
-     * Consumed by {@link MaterialBatcher#uploadTexture}, which then
-     * re-uploads INTO the existing texture — with immutable storage a
-     * same-shape re-upload is a pure `texSubImage2D`, so a ticking
-     * Text / gradient re-bake never re-allocates.
-     * @type {Set<number>}
-     * @ignore
-     */
-    dirtyUnits: Set<number> | undefined;
-    _onCacheReset: (() => void) | null | undefined;
-    /**
-     * Drop every cached texture binding after a {@link GPU_TEXTURE_CACHE_RESET}
-     * (the shared texture cache reassigned units — our per-unit view is stale).
-     * Subclasses that pair extra samplers to units (lit normal maps) override to
-     * forget those too; without that they'd assume the extra texture is still
-     * resident and skip re-binding it after the reset.
-     * @ignore
-     */
-    _onTextureCacheReset(): void;
     /**
      * Create a WebGL texture from an image
      * @param {number} unit - Destination texture unit
@@ -74,52 +30,7 @@ export class MaterialBatcher extends WebGLBatcher {
      * @param {number} unit - Texture unit to which the given texture is bound
      */
     bindTexture2D(texture: WebGLTexture, unit: number, flush?: boolean): void;
-    /**
-     * unbind the given WebGL texture, forcing it to be reuploaded
-     * @param {WebGLTexture} [texture] - a WebGL texture
-     * @param {number} [unit] - Texture unit to unbind from
-     * @returns {number} unit the unit number that was associated with the given texture
-     */
-    /**
-     * Announce that the SOURCE content behind `unit` changed (same object,
-     * new pixels — a canvas re-bake): the next {@link MaterialBatcher#uploadTexture}
-     * for it re-uploads into the existing texture in place instead of
-     * discarding it. The allocation-preserving counterpart of
-     * {@link MaterialBatcher#unbindTexture2D}.
-     * @param {number} unit - the texture unit whose content is stale
-     * @ignore
-     */
-    markTextureDirty(unit: number): void;
     unbindTexture2D(texture: any, unit: any): any;
-    /**
-     * Forget whatever texture this batcher believes is bound to `unit`, so the
-     * next bind to it re-issues the GL bind. Used when a GL texture unit is
-     * clobbered OUTSIDE this batcher's own accounting — e.g.
-     * {@link WebGLRenderer#toFrameTexture}, which binds its capture to a scratch
-     * unit directly (not via the shared texture cache), so a different batcher's
-     * unit cache would otherwise skip a needed re-bind. Subclasses that pair
-     * extra samplers to the same unit (lit normal maps) override to drop those
-     * too.
-     * @param {number} unit - the GL texture unit to invalidate
-     * @ignore
-     */
-    invalidateUnit(unit: number): void;
-    /**
-     * @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]
-     * @param {string} [repeat] - per-use wrap-mode override (a mesh's
-     *   `textureRepeat`, #1503) — sampled with this wrap without mutating
-     *   the shared atlas's `repeat`. The texture-unit cache keys by
-     *   `(source, repeat)`, so each wrap gets its own unit + GL texture.
-     *   Omit to use `texture.repeat`.
-     */
-    uploadTexture(texture: TextureAtlas | TextureResource, w?: number, h?: number, force?: boolean, flush?: boolean, repeat?: string): any;
 }
 import { WebGLBatcher } from "./batcher.js";
 import type { TextureAtlas } from "./../../texture/atlas.js";