melonjs 20.3.0 → 20.5.0

package/build/video/rendertarget/render_target_pool.d.ts

@@ -1,84 +1,3 @@
-/**
- * @import RenderTarget from "./rendertarget.ts";
- */
-/**
- * Manages a pool of {@link RenderTarget} instances for post-effect processing.
- * Renderer-agnostic — the actual RenderTarget creation is delegated to a
- * factory function provided by the renderer (WebGL, WebGPU, etc.).
- *
- * Camera effects use pool indices 0 and 1 (capture + ping-pong); sprite
- * effects use indices 2 and 3, and each NESTED sprite pass (a multi-effect
- * renderable drawn inside another multi-effect renderable) gets its own pair
- * above that (4/5, 6/7, …), tracked by a stack of active bases so begin/end
- * pairs compose like save/restore.
- * Render targets are lazily created and resized to match the required dimensions.
- * @ignore
- */
-export default class RenderTargetPool {
-    /**
-     * @param {function(number, number, boolean=): RenderTarget} factory - creates a RenderTarget with the given width and height; the third argument is `true` for CAPTURE slots (scene rasterization — may be multisampled) and `false` for ping-pong intermediates
-     */
-    constructor(factory: (arg0: number, arg1: number, arg2: boolean | undefined) => RenderTarget);
-    /** @type {function(number, number): RenderTarget} */
-    _factory: (arg0: number, arg1: number) => RenderTarget;
-    /** @type {RenderTarget[]} */
-    _pool: RenderTarget[];
-    /**
-     * active pass bases, innermost last — a STACK, so nested begin/end
-     * pairs unwind correctly (two scalars silently corrupted the pool on
-     * nested passes: the inner end() popped the outer pass's slot)
-     * @type {number[]}
-     */
-    _baseStack: number[];
-    /**
-     * The base index of the innermost active pass, or -1 when none.
-     * @returns {number}
-     */
-    get activeBase(): number;
-    /**
-     * Get or create a render target at the given pool index, resized to the given dimensions.
-     * @param {number} index - pool index
-     * @param {number} width - desired width in pixels
-     * @param {number} height - desired height in pixels
-     * @returns {RenderTarget} the render target
-     */
-    get(index: number, width: number, height: number): RenderTarget;
-    /**
-     * Prepare render targets for a post-effect pass.
-     * Allocates/resizes the capture target and optionally the ping-pong target.
-     * @param {boolean} isCamera - true for camera effects (indices 0+1), false for sprite (indices 2+3)
-     * @param {number} effectCount - number of enabled effects
-     * @param {number} width - target width in pixels
-     * @param {number} height - target height in pixels
-     * @returns {RenderTarget} the capture target (ready to bind)
-     */
-    begin(isCamera: boolean, effectCount: number, width: number, height: number): RenderTarget;
-    /**
-     * Get the capture render target for the current active pass.
-     * @returns {RenderTarget|undefined} the capture target, or undefined if no active pass
-     */
-    getCaptureTarget(): RenderTarget | undefined;
-    /**
-     * Get the ping-pong render target for the current active pass.
-     * @returns {RenderTarget|undefined} the ping-pong target, or undefined if no active pass
-     */
-    getPingPongTarget(): RenderTarget | undefined;
-    /**
-     * End the current pass and restore the previous active base.
-     * Returns the parent render target to rebind (or null for screen).
-     * @returns {RenderTarget|null} the parent target, or null if returning to screen
-     */
-    end(): RenderTarget | null;
-    /**
-     * Resize all existing render targets in the pool to the given dimensions.
-     * @param {number} width - new width in pixels
-     * @param {number} height - new height in pixels
-     */
-    resizeAll(width: number, height: number): void;
-    /**
-     * Destroy all render targets and clear the pool.
-     */
-    destroy(): void;
-}
+
 import type RenderTarget from "./rendertarget.ts";
 //# sourceMappingURL=render_target_pool.d.ts.map

package/build/video/rendertarget/render_target_pool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render_target_pool.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/render_target_pool.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH;IACC;;OAEG;IACH,qBAFW,CAAS,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,EAAE,IAAQ,EAAR,OAAO,YAAC,KAAG,YAAY,EAc1D;IAXA,qDAAqD;IACrD,UADW,CAAS,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,KAAG,YAAY,CAC1B;IACvB,6BAA6B;IAC7B,OADW,YAAY,EAAE,CACV;IACf;;;;;OAKG;IACH,YAFU,MAAM,EAAE,CAEE;IAGrB;;;OAGG;IACH,kBAFa,MAAM,CAMlB;IAED;;;;;;OAMG;IACH,WALW,MAAM,SACN,MAAM,UACN,MAAM,GACJ,YAAY,CAaxB;IAED;;;;;;;;OAQG;IACH,gBANW,OAAO,eACP,MAAM,SACN,MAAM,UACN,MAAM,GACJ,YAAY,CAuBxB;IAED;;;OAGG;IACH,oBAFa,YAAY,GAAC,SAAS,CAQlC;IAED;;;OAGG;IACH,qBAFa,YAAY,GAAC,SAAS,CAQlC;IAED;;;;OAIG;IACH,OAFa,YAAY,GAAC,IAAI,CAS7B;IAED;;;;OAIG;IACH,iBAHW,MAAM,UACN,MAAM,QAQhB;IAED;;OAEG;IACH,gBAQC;CACD;8BA/J4B,mBAAmB"}
+{"version":3,"file":"render_target_pool.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/render_target_pool.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH;IACC;;OAEG;IACH,qBAFW,CAAS,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,EAAE,IAAQ,EAAR,OAAO,YAAC,KAAG,YAAY,EAwB1D;IArBA;;;;OAIG;IACH,UAJU,CAAS,IAAM,EAAN,MAAM,EAAE,IAAM,EAAN,MAAM,KAAG,YAAY,CAIzB;IACvB;;;;OAIG;IACH,OAJU,YAAY,EAAE,CAIT;IACf;;;;;;;OAOG;IACH,YAJU,MAAM,EAAE,CAIE;IAGrB;;;OAGG;IACH,kBAFa,MAAM,CAMlB;IAED;;;;;;OAMG;IACH,WALW,MAAM,SACN,MAAM,UACN,MAAM,GACJ,YAAY,CAaxB;IAED;;;;;;;;OAQG;IACH,gBANW,OAAO,eACP,MAAM,SACN,MAAM,UACN,MAAM,GACJ,YAAY,CAuBxB;IAED;;;OAGG;IACH,oBAFa,YAAY,GAAC,SAAS,CAQlC;IAED;;;OAGG;IACH,qBAFa,YAAY,GAAC,SAAS,CAQlC;IAED;;;;OAIG;IACH,OAFa,YAAY,GAAC,IAAI,CAS7B;IAED;;;;OAIG;IACH,iBAHW,MAAM,UACN,MAAM,QAQhB;IAED;;OAEG;IACH,gBAQC;CACD;8BA1K4B,mBAAmB"}

package/build/video/rendertarget/webglrendertarget.d.ts

@@ -1,66 +1,3 @@
-/**
- * A WebGL Framebuffer Object (FBO) render target for offscreen rendering.
- * Used by the post-processing pipeline to render a camera's output to a texture,
- * which can then be drawn to the screen through a post-process shader.
- * @augments RenderTarget
- * @ignore
- */
-export default class WebGLRenderTarget extends RenderTarget {
-    /**
-     * @param {WebGLRenderingContext|WebGL2RenderingContext} gl - the WebGL context
-     * @param {number} width - initial width in pixels
-     * @param {number} height - initial height in pixels
-     */
-    /**
-     * @param {WebGLRenderingContext|WebGL2RenderingContext} gl - the WebGL context
-     * @param {number} width - initial width in pixels
-     * @param {number} height - initial height in pixels
-     * @param {object} [options] - target options
-     * @param {number} [options.samples=0] - MSAA sample count for the scene
-     * rasterization. When > 0 the target keeps a multisampled render FBO
-     * (color + depth-stencil renderbuffers) that draws rasterize into, and
-     * resolves it into the sampleable texture via `blitFramebuffer` on
-     * {@link WebGLRenderTarget#resolve} (called automatically by `unbind`).
-     */
-    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, width: number, height: number, options?: {
-        samples?: number | undefined;
-    });
-    gl: WebGLRenderingContext | WebGL2RenderingContext;
-    /**
-     * MSAA sample count of the render half (0 = single-sampled)
-     * @type {number}
-     */
-    samples: number;
-    _needsResolve: boolean;
-    framebuffer: WebGLFramebuffer;
-    depthStencilBuffer: WebGLRenderbuffer;
-    renderFramebuffer: WebGLFramebuffer | null;
-    colorRenderbuffer: WebGLRenderbuffer | null;
-    /**
-     * (Re)create the sampleable color texture with immutable storage
-     * (`texStorage2D` — the driver skips completeness validation and the
-     * layout is explicit) and attach it to the resolve framebuffer.
-     * Immutable storage can never be respecified, so a resize replaces the
-     * texture object. Caller manages ACTIVE_TEXTURE save/restore.
-     * @ignore
-     */
-    _allocateColorTexture(width: any, height: any): void;
-    texture: WebGLTexture | null | undefined;
-    /**
-     * (Re)attach the depth/stencil renderbuffer at the given size and
-     * update `_hasStencil` based on the resulting framebuffer status.
-     * Falls back to depth-only when packed depth+stencil fails; warns
-     * once if even depth-only is incomplete.
-     * @ignore
-     */
-    _applyDepthStencil(width: any, height: any): void;
-    _hasStencil: boolean | undefined;
-    /**
-     * Resolve the multisampled render half into the sampleable texture
-     * (no-op when single-sampled or already resolved). Leaves no
-     * framebuffer bound — callers rebind what they need.
-     */
-    resolve(): void;
-}
+
 import RenderTarget from "./rendertarget.ts";
 //# sourceMappingURL=webglrendertarget.d.ts.map

package/build/video/rendertarget/webglrendertarget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webglrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/webglrendertarget.js"],"names":[],"mappings":"AA2EA;;;;;;GAMG;AACH;IACC;;;;OAIG;IACH;;;;;;;;;;OAUG;IACH,gBAVW,qBAAqB,GAAC,sBAAsB,SAC5C,MAAM,UACN,MAAM,YAEd;QAAyB,OAAO;KAKlC,EAgEA;IA7DA,mDAAY;IAIZ;;;OAGG;IACH,SAFU,MAAM,CAEmB;IAGnC,uBAA0B;IAI1B,8BAAyC;IAWzC,sCAAiD;IAKhD,2CAA+C;IAC/C,4CAAgD;IA+BlD;;;;;;;OAOG;IACH,qDAqBC;IAhBA,yCAAiC;IAkBlC;;;;;;OAMG;IACH,kDAmBC;IAVA,iCAAoC;IA0BrC;;;;OAIG;IACH,gBAqBC;CAuID;yBA9YwB,mBAAmB"}
+{"version":3,"file":"webglrendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/webglrendertarget.js"],"names":[],"mappings":"AA4EA;;;;;;;GAOG;AACH;IACC;;;;OAIG;IACH;;;;;;;;;;OAUG;IACH,gBAVW,qBAAqB,GAAC,sBAAsB,SAC5C,MAAM,UACN,MAAM,YAEd;QAAyB,OAAO;KAKlC,EAoEA;IAjEA,mDAAY;IAIZ;;;OAGG;IACH,SAFU,MAAM,CAEmB;IAGnC;;;OAGG;IACH,uBAA0B;IAI1B,8BAAyC;IAWzC,sCAAiD;IAKhD,2CAA+C;IAC/C,4CAAgD;IA+BlD;;;;;;;;OAQG;IACH,qDAqBC;IAhBA,yCAAiC;IAkBlC;;;;;;;OAOG;IACH,kDAuBC;IAdA;;;OAGG;IACH,iCAAoC;IA0BrC;;;;OAIG;IACH,gBAqBC;CAuID;yBA1ZwB,mBAAmB"}

package/build/video/rendertarget/webgpurendertarget.d.ts

@@ -54,14 +54,6 @@ export default class WebGPURenderTarget extends RenderTarget {
     materialBindGroup: GPUBindGroup | null;
     materialBindGroupGeneration: number;
     pendingClear: boolean;
-    /**
-     * The group-1 (material) bind group sampling this target with a linear
-     * clamp sampler — what the effect blit binds as its source. Rebuilt
-     * lazily when the backing texture was reallocated.
-     * @returns {GPUBindGroup} the bind group
-     * @ignore
-     */
-    getMaterialBindGroup(): GPUBindGroup;
     /**
      * Synchronous readback is impossible under WebGPU — use
      * {@link WebGPURenderTarget#readPixels}.

package/build/video/rendertarget/webgpurendertarget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgpurendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/webgpurendertarget.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,8BAA8B,EAAE,OAAO,SAC9C,MAAM,UACN,MAAM,gBAsChB;IAlCA,yDAAwB;IAGxB;;;;;;;OAOG;IACH,aAFU,MAAM,CAE2B;IAC3C,8BAA8B;IAC9B,SADW,UAAU,GAAC,IAAI,CACP;IACnB,kCAAkC;IAClC,WADW,cAAc,GAAC,IAAI,CACT;IACrB,iFAAiF;IACjF,aAD8D,UAAU,GAAC,IAAI,CACtD;IACvB,kCAAkC;IAClC,UADW,cAAc,GAAC,IAAI,CACV;IACpB;;;;OAIG;IACH,YAFU,MAAM,CAEG;IAGnB,uCAA6B;IAC7B,oCAAqC;IAErC,sBAAyB;IA+E1B;;;;;;OAMG;IACH,wBAHa,YAAY,CAuBxB;IAED;;;;;OAKG;IACH,8BAIC;IAED;;;;;;;OAOG;IACH,eANW,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAyD9B;CAqBD;yBA3QwB,mBAAmB"}
+{"version":3,"file":"webgpurendertarget.d.ts","sourceRoot":"","sources":["../../../src/video/rendertarget/webgpurendertarget.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,8BAA8B,EAAE,OAAO,SAC9C,MAAM,UACN,MAAM,gBAsChB;IAlCA,yDAAwB;IAGxB;;;;;;;OAOG;IACH,aAFU,MAAM,CAE2B;IAC3C,8BAA8B;IAC9B,SADW,UAAU,GAAC,IAAI,CACP;IACnB,kCAAkC;IAClC,WADW,cAAc,GAAC,IAAI,CACT;IACrB,iFAAiF;IACjF,aAD8D,UAAU,GAAC,IAAI,CACtD;IACvB,kCAAkC;IAClC,UADW,cAAc,GAAC,IAAI,CACV;IACpB;;;;OAIG;IACH,YAFU,MAAM,CAEG;IAGnB,uCAA6B;IAC7B,oCAAqC;IAErC,sBAAyB;IA+E1B;;;;;;;OAOG;IACH,wBAJa,YAAY,CAwBxB;IAED;;;;;OAKG;IACH,8BAIC;IAED;;;;;;;OAOG;IACH,eANW,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAyD9B;CAqBD;yBA5QwB,mBAAmB"}

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

@@ -1,36 +1,4 @@
-/**
- * additional import for TypeScript
- * @import NineSliceSprite from "./../../renderable/nineslicesprite.js";
- */
-/**
- * create a simple 1 frame texture atlas based on the given parameters
- * @ignore
- */
-export function createAtlas(width: any, height: any, name?: string, repeat?: string): {
-    meta: {
-        app: string;
-        size: {
-            w: any;
-            h: any;
-        };
-        repeat: string;
-        image: string;
-    };
-    frames: {
-        filename: string;
-        frame: {
-            x: number;
-            y: number;
-            w: any;
-            h: any;
-        };
-    }[];
-};
-/**
- * return a string that identifies the texture atlas type
- * @ignore
- */
-export function identifyFormat(app: any): "melonJS" | "texturepacker" | "shoebox" | "aseprite";
+
 /**
  * A Texture atlas class, currently supports : <br>
  * - [TexturePacker]{@link http://www.codeandweb.com/texturepacker/} : through JSON export (standard and multipack texture atlas) <br>
@@ -78,48 +46,6 @@ export class TextureAtlas extends Texture2d {
      * );
      */
     constructor(atlases: object | object[], src?: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | CompressedImage | string | OffscreenCanvas[] | HTMLImageElement[] | HTMLCanvasElement[] | string[], options?: boolean | object);
-    /**
-     * to identify the atlas format (e.g. texture packer)
-     * @ignore
-     */
-    format: string | null;
-    /**
-     * the texture source(s) itself
-     * @type {Map}
-     * @ignore
-     */
-    sources: Map<any, any>;
-    /**
-     * paired normal-map source(s), keyed identically to `sources`.
-     * Populated from the constructor's `options.normalMap`. Used by
-     * the WebGL renderer's lit pipeline for per-pixel lighting.
-     * @type {Map}
-     * @ignore
-     */
-    normalSources: Map<any, any>;
-    /**
-     * the atlas dictionnaries
-     * @type {Map}
-     * @ignore
-     */
-    atlases: Map<any, any>;
-    /**
-     * the default "active" atlas (used for multiAtlas)
-     * @type {Map}
-     * @ignore
-     */
-    activeAtlas: Map<any, any>;
-    /**
-     * UV lookup cache to avoid per-frame string allocation in drawImage
-     * @ignore
-     */
-    _uvCache: {
-        sx: number;
-        sy: number;
-        sw: number;
-        sh: number;
-        uvs: null;
-    };
     repeat: any;
     /**
      * return the default or specified atlas dictionnary

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

@@ -1 +1 @@
-{"version":3,"file":"atlas.d.ts","sourceRoot":"","sources":["../../../src/video/texture/atlas.js"],"names":[],"mappings":"AAmBA;;;GAGG;AAEH;;;GAGG;AACH;;;;;;;;;;;;;;;;;;;EAoBC;AAED;;;GAGG;AACH,+FAYC;AAED;;;;;;;;;;GAUG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,qBAjCW,MAAM,GAAC,MAAM,EAAE,QACf,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,eAAe,GAAC,MAAM,GAAC,eAAe,EAAE,GAAC,gBAAgB,EAAE,GAAC,iBAAiB,EAAE,GAAC,MAAM,EAAE,YAC3I,OAAO,GAAC,MAAM,EAuOxB;IAjMA;;;OAGG;IACH,sBAAkB;IAElB;;;;OAIG;IACH,uBAAwB;IAExB;;;;;;OAMG;IACH,6BAA8B;IAE9B;;;;OAIG;IACH,uBAAwB;IAExB;;;;OAIG;IACH,2BAA4B;IAE5B;;;OAGG;IACH;;;;;;MAA6D;IAW1D,YAA8C;IAgJlD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;OAGG;IACH,aAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,gBAAgB,GAAC,iBAAiB,CAQ9C;IAED;;;;;;OAMG;IACH,0BAHW,MAAM,GACJ,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAAC,IAAI,CAU/E;IAED;;;;;;;;OAQG;IACH,gBAPW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAsBlB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;;;;OAOG;IACH,aANW,MAAM,GAAC,MAAM,OACb,MAAM,OACN,MAAM,OACN,MAAM,GACJ,YAAY,CAsCxB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,QACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,YAAY,CA2BxB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,2BA1BW,MAAM,aACN,MAAM,cACN,OAAO,GACL,MAAM,GAAC,eAAe,CAqClC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,6BAnBW,MAAM,EAAE,GAAC,MAAM,EAAE,GAGf,MAAM,CAkFlB;IAED,2DAiDC;CACD;sBArsBqB,gBAAgB;mBANnB,8BAA8B;iCAmBjB,uCAAuC"}
+{"version":3,"file":"atlas.d.ts","sourceRoot":"","sources":["../../../src/video/texture/atlas.js"],"names":[],"mappings":"AAuBA;;;GAGG;AAEH;;;;GAIG;AACH;;;;;;;;;;;;;;;;;;;EAoBC;AAED;;;;GAIG;AACH,+FAYC;AAED;;;;;;;;;;GAUG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,qBAjCW,MAAM,GAAC,MAAM,EAAE,QACf,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,eAAe,GAAC,MAAM,GAAC,eAAe,EAAE,GAAC,gBAAgB,EAAE,GAAC,iBAAiB,EAAE,GAAC,MAAM,EAAE,YAC3I,OAAO,GAAC,MAAM,EA6OxB;IAvMA;;;;OAIG;IACH,sBAAkB;IAElB;;;;;OAKG;IACH,uBAAwB;IAExB;;;;;;;OAOG;IACH,6BAA8B;IAE9B;;;;;OAKG;IACH,uBAAwB;IAExB;;;;;OAKG;IACH,2BAA4B;IAE5B;;;;OAIG;IACH;;;;;;MAA6D;IAW1D,YAA8C;IAgJlD;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAM,CAQlB;IAED;;;OAGG;IACH,aAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,gBAAgB,GAAC,iBAAiB,CAQ9C;IAED;;;;;;OAMG;IACH,0BAHW,MAAM,GACJ,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAAC,IAAI,CAU/E;IAED;;;;;;;;OAQG;IACH,gBAPW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAsBlB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAiBlB;IAED;;;;;;;OAOG;IACH,aANW,MAAM,GAAC,MAAM,OACb,MAAM,OACN,MAAM,OACN,MAAM,GACJ,YAAY,CAsCxB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,QACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,YAAY,CA2BxB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,2BA1BW,MAAM,aACN,MAAM,cACN,OAAO,GACL,MAAM,GAAC,eAAe,CAqClC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,6BAnBW,MAAM,EAAE,GAAC,MAAM,EAAE,GAGf,MAAM,CAkFlB;IAED,2DAiDC;CACD;sBAjtBqB,gBAAgB;mBANnB,8BAA8B;iCAuBjB,uCAAuC"}

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

@@ -1,140 +1,4 @@
 export default TextureCache;
-/**
- * a basic texture cache object
- * @ignore
- */
-declare class TextureCache {
-    /**
-     * @ignore
-     */
-    constructor(renderer: any, max_size?: number);
-    renderer: any;
-    cache: ArrayMultimap;
-    tinted: Map<any, any>;
-    units: Map<any, any>;
-    slotTable: TextureSlotTable;
-    reservedUnits: Map<any, any>;
-    /**
-     * Which texture units are currently taken. This is the slot table's own
-     * occupancy set, exposed under the name it has always had — seeding or
-     * clearing it drives the allocator directly.
-     * @returns {Set<number>} the occupied units
-     * @ignore
-     */
-    get usedUnits(): Set<number>;
-    set max_size(size: number);
-    /**
-     * How many texture units this cache may hand out. Backed by the slot
-     * table's capacity, so assigning it (tests narrow it to force exhaustion,
-     * and a context restore can resolve a different device limit) re-sizes the
-     * allocator rather than leaving the two disagreeing.
-     * @returns {number} the unit count
-     * @ignore
-     */
-    get max_size(): number;
-    /**
-     * @ignore
-     */
-    clear(): void;
-    /**
-     * @ignore
-     */
-    allocateTextureUnit(): number;
-    /**
-     * Reserve a texture unit so {@link allocateTextureUnit} never hands it to a
-     * color texture — used by `ShaderEffect.setTexture` to hold high units for
-     * its extra samplers. Reference-counted, so a unit shared by several effects
-     * stays reserved until the last one releases it.
-     * @param {number} unit - the texture unit to reserve
-     * @ignore
-     */
-    reserveUnit(unit: number): void;
-    /**
-     * Release a unit previously held by {@link reserveUnit}. The unit becomes
-     * allocatable again once its last holder releases it.
-     * @param {number} unit - the texture unit to release
-     * @ignore
-     */
-    releaseUnit(unit: number): void;
-    /**
-     * Reset all texture unit assignments without clearing the texture cache.
-     * Used by multi-texture batching when the shader's sampler range is exceeded.
-     * @ignore
-     */
-    resetUnitAssignments(): void;
-    /**
-     * @ignore
-     *
-     * Frees the single `(source, repeat)` unit matching the texture's
-     * current `repeat` field — deliberately granular, so freeing one live
-     * consumer (e.g. one of two patterns with different repeats over the
-     * same image) never evicts the other's unit. When a SOURCE goes away
-     * entirely, use {@link freeAllUnits} instead — a source can hold units
-     * under several repeat modes (per-mesh `textureRepeat` overrides,
-     * #1503) that this granular free would leave pinned.
-     */
-    freeTextureUnit(texture: any): void;
-    /**
-     * @ignore
-     *
-     * Free every texture unit allocated for the texture's source, across
-     * ALL repeat modes. A single source can hold several `(source, repeat)`
-     * units — patterns with different repeats over one image, or meshes
-     * sampling one image with per-mesh `textureRepeat` overrides (#1503) —
-     * and the source going away invalidates all of them at once.
-     */
-    freeAllUnits(texture: any): void;
-    /**
-     * @ignore
-     * @param {string} [repeat] - overrides the texture's own `repeat` for the
-     * unit lookup — sampler state per use (a mesh's `textureRepeat`), so one
-     * source can be sampled with several wrap modes without mutating the
-     * shared atlas (#1503). Omit to use `texture.repeat`.
-     *
-     * Hot-path note: `getUnit` / `peekUnit` are called per-texture per-draw,
-     * so the `(source, repeat)` lookup is inlined here rather than going
-     * through a helper that allocates a `{source, repeat}` object per call.
-     */
-    getUnit(texture: any, repeat?: string): any;
-    /**
-     * @ignore
-     * return every texture unit allocated for the given texture's source,
-     * across ALL repeat modes — the unload-time counterpart of the per-use
-     * `getUnit(texture, repeat)` override (#1503): a single source can hold
-     * one unit per wrap mode it was sampled with, and per-repeat `peekUnit`
-     * lookups would only ever find the one matching the texture's current
-     * `repeat` field. Not a hot path (allocates the result array).
-     */
-    peekAllUnits(texture: any): any[];
-    /**
-     * @ignore
-     * return the texture unit for the given texture, or -1 if not allocated
-     * @param {string} [repeat] - same per-use wrap override as {@link getUnit}
-     */
-    peekUnit(texture: any, repeat?: string): any;
-    /**
-     * @ignore
-     * cache the textureAltas for the given image
-     */
-    set(image: any, textureAtlas: any): void;
-    /**
-     * @ignore
-     */
-    has(image: any): boolean;
-    /**
-     * @ignore
-     * return the textureAltas for the given image
-     */
-    get(image: any, atlas: any): any;
-    /**
-     * @ignore
-     */
-    delete(image: any): void;
-    /**
-     * @ignore
-     */
-    tint(src: any, color: any): any;
-}
 import { ArrayMultimap } from "../../utils/array-multimap.js";
 import { TextureSlotTable } from "../gpu/textureslots.js";
 //# sourceMappingURL=cache.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/video/texture/cache.js"],"names":[],"mappings":";AAgBA;;;GAGG;AACH;IACC;;OAEG;IACH,8CAgDC;IA9CA,cAAwB;IAExB,qBAAgC;IAChC,sBAAuB;IAavB,qBAAsB;IAOtB,4BAeE;IAMF,6BAA8B;IAI/B;;;;;;OAMG;IACH,iBAHa,GAAG,CAAC,MAAM,CAAC,CAKvB;IAcD,mBAPa,MAAM,EASlB;IAdD;;;;;;;OAOG;IACH,gBAHa,MAAM,CAKlB;IAMD;;OAEG;IACH,cAKC;IAED;;OAEG;IACH,8BAIC;IAED;;;;;;;OAOG;IACH,kBAHW,MAAM,QAKhB;IAED;;;;;OAKG;IACH,kBAHW,MAAM,QAUhB;IAED;;;;OAIG;IACH,6BAIC;IAED;;;;;;;;;;OAUG;IACH,oCAaC;IAED;;;;;;;;OAQG;IACH,iCASC;IAED;;;;;;;;;;OAUG;IACH,+BATW,MAAM,OAuBhB;IAED;;;;;;;;OAQG;IACH,kCAIC;IAED;;;;OAIG;IACH,gCAFW,MAAM,OAShB;IAED;;;OAGG;IACH,yCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;OAGG;IACH,iCAmCC;IAED;;OAEG;IACH,yBAkBC;IAED;;OAEG;IACH,gCAcC;CACD;8BApW6B,+BAA+B;iCAE5B,wBAAwB"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../../src/video/texture/cache.js"],"names":[],"mappings":";AAgBA;;;;GAIG;AACH;IACC;;;OAGG;IACH,8CAgDC;IA9CA,cAAwB;IAExB,qBAAgC;IAChC,sBAAuB;IAavB,qBAAsB;IAOtB,4BAeE;IAMF,6BAA8B;IAI/B;;;;;;;OAOG;IACH,iBAJa,GAAG,CAAC,MAAM,CAAC,CAMvB;IAeD,mBARa,MAAM,EAUlB;IAfD;;;;;;;;OAQG;IACH,gBAJa,MAAM,CAMlB;IAMD;;;OAGG;IACH,cAKC;IAED;;;OAGG;IACH,8BAIC;IAED;;;;;;;;OAQG;IACH,kBAJW,MAAM,QAMhB;IAED;;;;;;OAMG;IACH,kBAJW,MAAM,QAWhB;IAED;;;;;OAKG;IACH,6BAIC;IAED;;;;;;;;;;;OAWG;IACH,oCAaC;IAED;;;;;;;;;OASG;IACH,iCASC;IAED;;;;;;;;;;;OAWG;IACH,+BATW,MAAM,OAuBhB;IAED;;;;;;;;;OASG;IACH,kCAIC;IAED;;;;;OAKG;IACH,gCAFW,MAAM,OAShB;IAED;;;;OAIG;IACH,yCAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,iCAmCC;IAED;;;OAGG;IACH,yBAkBC;IAED;;;OAGG;IACH,gCAcC;CACD;8BAvX6B,+BAA+B;iCAE5B,wBAAwB"}

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

@@ -1,73 +1,3 @@
-/**
- * A GPU-resident texture holding a captured frame — the value returned by
- * {@link WebGLRenderer#toFrameTexture}. Its backing is a live `WebGLTexture`
- * that the renderer refreshes **in place** on each capture, so a shader that
- * has bound it once (via {@link ShaderEffect#setTexture}) keeps sampling the
- * latest frame with no re-bind.
- *
- * Not part of the public class surface: obtain instances from
- * `renderer.toFrameTexture()` and treat them as opaque {@link Texture2d}
- * values. The `isGPUResident` flag is the discriminant `setTexture` uses to
- * take its live-bind path (bind the existing handle) instead of uploading a
- * static copy.
- * @augments Texture2d
- * @ignore
- */
-export class FrameTexture extends Texture2d {
-    /**
-     * @param {WebGLRenderer} renderer - the owning renderer (for the GL context)
-     * @param {number} width - capture width in pixels
-     * @param {number} height - capture height in pixels
-     */
-    constructor(renderer: WebGLRenderer, width: number, height: number);
-    _renderer: WebGLRenderer;
-    /** @type {number} */
-    width: number;
-    /** @type {number} */
-    height: number;
-    /**
-     * the live backing texture, (re)filled by `renderer.toFrameTexture` and
-     * bound (never re-uploaded) by consumers
-     * @type {WebGLTexture|null}
-     */
-    glTexture: WebGLTexture | null;
-    /**
-     * marks this as a live GPU-resident source — see {@link ShaderEffect#setTexture}
-     * @type {boolean}
-     */
-    isGPUResident: boolean;
-    /**
-     * The opaque GPU-resident backing — itself.
-     * @returns {FrameTexture}
-     */
-    getTexture(): FrameTexture;
-}
-/**
- * The Canvas-renderer counterpart of {@link FrameTexture}: a captured frame
- * backed by an offscreen `<canvas>` copy of the drawing buffer, keeping the
- * `toFrameTexture` family renderer-complete. A drawable source (not
- * GPU-resident), so it flows through the normal image path; custom shaders
- * don't run under the Canvas renderer, so this exists for API parity and
- * CPU-side reuse (e.g. drawing the captured frame back onto the scene).
- * @augments Texture2d
- * @ignore
- */
-export class CanvasFrameTexture extends Texture2d {
-    /**
-     * @param {HTMLCanvasElement|OffscreenCanvas} canvas - the backing copy
-     */
-    constructor(canvas: HTMLCanvasElement | OffscreenCanvas);
-    /** @type {HTMLCanvasElement|OffscreenCanvas} */
-    canvas: HTMLCanvasElement | OffscreenCanvas;
-    /** @type {number} */
-    width: number;
-    /** @type {number} */
-    height: number;
-    /**
-     * The backing canvas copy.
-     * @returns {HTMLCanvasElement|OffscreenCanvas}
-     */
-    getTexture(): HTMLCanvasElement | OffscreenCanvas;
-}
+
 import Texture2d from "./texture2d.ts";
 //# sourceMappingURL=frametexture.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"frametexture.d.ts","sourceRoot":"","sources":["../../../src/video/texture/frametexture.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,SACb,MAAM,UACN,MAAM,EAoBhB;IAhBA,yBAAyB;IACzB,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB;;;;OAIG;IACH,WAFU,YAAY,GAAC,IAAI,CAEN;IACrB;;;OAGG;IACH,eAFU,OAAO,CAEQ;IAG1B;;;OAGG;IACH,cAFa,YAAY,CAIxB;CAaD;AAED;;;;;;;;;GASG;AACH;IACC;;OAEG;IACH,oBAFW,iBAAiB,GAAC,eAAe,EAU3C;IANA,gDAAgD;IAChD,QADW,iBAAiB,GAAC,eAAe,CACxB;IACpB,qBAAqB;IACrB,OADW,MAAM,CACQ;IACzB,qBAAqB;IACrB,QADW,MAAM,CACU;IAG5B;;;OAGG;IACH,cAFa,iBAAiB,GAAC,eAAe,CAI7C;CACD;sBA/FqB,gBAAgB"}
+{"version":3,"file":"frametexture.d.ts","sourceRoot":"","sources":["../../../src/video/texture/frametexture.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,SACb,MAAM,UACN,MAAM,EAwBhB;IApBA;;;OAGG;IACH,yBAAyB;IACzB,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,qBAAqB;IACrB,QADW,MAAM,CACG;IACpB;;;;OAIG;IACH,WAFU,YAAY,GAAC,IAAI,CAEN;IACrB;;;OAGG;IACH,eAFU,OAAO,CAEQ;IAG1B;;;OAGG;IACH,cAFa,YAAY,CAIxB;CAaD;AAED;;;;;;;;;;GAUG;AACH;IACC;;OAEG;IACH,oBAFW,iBAAiB,GAAC,eAAe,EAU3C;IANA,gDAAgD;IAChD,QADW,iBAAiB,GAAC,eAAe,CACxB;IACpB,qBAAqB;IACrB,OADW,MAAM,CACQ;IACzB,qBAAqB;IACrB,QADW,MAAM,CACU;IAG5B;;;OAGG;IACH,cAFa,iBAAiB,GAAC,eAAe,CAI7C;CACD;sBArGqB,gBAAgB"}