melonjs 20.2.0 → 20.4.0

package/build/video/webgl/buffer/instance_buffer.d.ts

@@ -1,54 +1,2 @@
-/**
- * The GPU half of an {@link InstancedMesh}'s instance records — one
- * `ARRAY_BUFFER` holding the packed per-instance transforms (and the opt-in
- * colour / custom slots), uploaded with `bufferSubData` over only the range
- * the CPU side actually touched.
- *
- * This is the instancing counterpart of {@link RetainedGeometry}: the mesh's
- * geometry is uploaded once and never rewritten, and this buffer carries
- * everything that differs between the copies. Moving one tree in a forest of
- * five thousand therefore re-uploads 48 bytes, not the geometry and not the
- * other 4 999 records.
- *
- * The buffer is sized to the mesh's capacity rather than its live instance
- * count, so growing by one instance does not reallocate on the GPU until the
- * CPU-side array itself grows.
- * @ignore
- */
-export default class WebGLInstanceBuffer {
-    /**
-     * @param {WebGL2RenderingContext} gl - the WebGL context
-     */
-    constructor(gl: WebGL2RenderingContext);
-    gl: WebGL2RenderingContext;
-    /**
-     * the GL buffer holding the packed instance records
-     * @type {WebGLBuffer}
-     */
-    buffer: WebGLBuffer;
-    /**
-     * byte capacity currently allocated on the GPU; a CPU-side array
-     * larger than this forces a full reallocation rather than a sub-update
-     * @type {number}
-     */
-    capacity: number;
-    /**
-     * Push the dirty span of `data` to the GPU.
-     *
-     * Three cases, cheapest last: the CPU array outgrew the allocation (full
-     * `bufferData`), nothing is dirty (no call at all), or a span changed
-     * (one `bufferSubData` covering exactly it).
-     * @param {Float32Array} data - the CPU-side instance records
-     * @param {number} firstFloat - first dirty float offset (inclusive)
-     * @param {number} floatCount - number of dirty floats, 0 when clean
-     * @param {number} usedBytes - bytes of `data` actually in use
-     */
-    upload(data: Float32Array, firstFloat: number, floatCount: number, usedBytes: number): void;
-    /**
-     * Release the GL buffer. Safe to call twice, and on a lost context — the
-     * `isBuffer` probe is itself error-free, whereas deleting a handle whose
-     * context died raises INVALID_OPERATION.
-     */
-    destroy(): void;
-}
+
 //# sourceMappingURL=instance_buffer.d.ts.map

package/build/video/webgl/buffer/instance_buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instance_buffer.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/instance_buffer.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;OAEG;IACH,gBAFW,sBAAsB,EAiBhC;IAdA,2BAAY;IAEZ;;;OAGG;IACH,QAFU,WAAW,CAEU;IAE/B;;;;OAIG;IACH,UAFU,MAAM,CAEC;IAGlB;;;;;;;;;;OAUG;IACH,aALW,YAAY,cACZ,MAAM,cACN,MAAM,aACN,MAAM,QAgChB;IAED;;;;OAIG;IACH,gBASC;CACD"}
+{"version":3,"file":"instance_buffer.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/instance_buffer.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACC;;OAEG;IACH,gBAFW,sBAAsB,EAiBhC;IAdA,2BAAY;IAEZ;;;OAGG;IACH,QAFU,WAAW,CAEU;IAE/B;;;;OAIG;IACH,UAFU,MAAM,CAEC;IAGlB;;;;;;;;;;OAUG;IACH,aALW,YAAY,cACZ,MAAM,cACN,MAAM,aACN,MAAM,QAgChB;IAED;;;;OAIG;IACH,gBASC;CACD"}

package/build/video/webgl/buffer/retained_geometry.d.ts

@@ -1,83 +1,3 @@
-/**
- * Persistent GPU geometry for one mesh — a vertex buffer, an index buffer
- * and the {@link WebGLVertexState} that binds them together, all uploaded
- * once and re-drawn from VRAM on subsequent frames.
- *
- * This is what makes the mesh path retained rather than immediate: the
- * geometry it holds is in model space and carries no camera, placement or
- * tint information, so moving, rotating, scaling or re-tinting a mesh
- * changes only uniforms and never touches these buffers. They are rewritten
- * only when the geometry itself changes, which the owning mesh signals by
- * bumping its geometry version.
- *
- * Uploads go through a `Uint8Array` view of the float data rather than the
- * `Float32Array` itself: some drivers canonicalize NaN bit patterns on a
- * float upload, which would corrupt packed values. See `VertexArrayBuffer`.
- * @ignore
- */
-export default class RetainedGeometry {
-    /**
-     * @param {WebGL2RenderingContext} gl - the WebGL context
-     * @param {object[]} attributes - the owning batcher's attribute definitions
-     * @param {number} stride - the owning batcher's vertex stride in bytes
-     * @param {Function} resolveLocation - maps an attribute name to its shader location
-     */
-    constructor(gl: WebGL2RenderingContext, attributes: object[], stride: number, resolveLocation: Function);
-    gl: WebGL2RenderingContext;
-    attributes: object[];
-    stride: number;
-    resolveLocation: Function;
-    /**
-     * the GL buffer holding the interleaved model-space vertex data
-     * @type {WebGLBuffer}
-     */
-    vertexBuffer: WebGLBuffer;
-    /**
-     * the GL buffer holding the index data, as authored
-     * @type {WebGLBuffer}
-     */
-    glIndexBuffer: WebGLBuffer;
-    /**
-     * `gl.UNSIGNED_SHORT` or `gl.UNSIGNED_INT`, matching the index array
-     * the mesh supplied — WebGL 2 draws 32-bit indices natively, so a
-     * mesh past 65 535 vertices is still a single draw call.
-     * @type {number}
-     */
-    indexType: number;
-    /**
-     * number of indices to draw
-     * @type {number}
-     */
-    indexCount: number;
-    /**
-     * the mesh geometry version this upload reflects; a mismatch against
-     * the mesh means the buffers are stale and must be rewritten
-     * @type {number}
-     */
-    uploadedVersion: number;
-    /**
-     * the frozen vertex state binding this geometry's buffers
-     * @type {WebGLVertexState}
-     */
-    vertexState: WebGLVertexState;
-    /**
-     * Upload interleaved vertex data and indices, replacing whatever this
-     * geometry held before.
-     * @param {Float32Array} vertexData - interleaved vertex data in the batcher's layout
-     * @param {number} floatCount - how many floats of `vertexData` are in use
-     * @param {Uint16Array|Uint32Array|number[]} indices - the index data, as authored
-     * @param {number} version - the mesh geometry version this data reflects
-     */
-    upload(vertexData: Float32Array, floatCount: number, indices: Uint16Array | Uint32Array | number[], version: number): void;
-    /**
-     * Make this geometry current for drawing.
-     */
-    bind(): void;
-    /**
-     * Release every GL object this geometry owns. Safe to call twice, and on
-     * a lost context.
-     */
-    destroy(): void;
-}
+
 import WebGLVertexState from "./vertexstate.js";
 //# sourceMappingURL=retained_geometry.d.ts.map

package/build/video/webgl/buffer/retained_geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"retained_geometry.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/retained_geometry.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;;;OAKG;IACH,gBALW,sBAAsB,cACtB,MAAM,EAAE,UACR,MAAM,6BA+DhB;IA3DA,2BAAY;IACZ,qBAA4B;IAC5B,eAAoB;IACpB,0BAAsC;IAEtC;;;OAGG;IACH,cAFU,WAAW,CAEgB;IAErC;;;OAGG;IACH,eAFU,WAAW,CAEiB;IAEtC;;;;;OAKG;IACH,WAFU,MAAM,CAEkB;IAElC;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,iBAFU,MAAM,CAES;IAYzB;;;OAGG;IACH,aAFU,gBAAgB,CAQxB;IAGH;;;;;;;OAOG;IACH,mBALW,YAAY,cACZ,MAAM,WACN,WAAW,GAAC,WAAW,GAAC,MAAM,EAAE,WAChC,MAAM,QAsChB;IAED;;OAEG;IACH,aAEC;IAED;;;OAGG;IACH,gBAwBC;CACD;6BA1K4B,kBAAkB"}
+{"version":3,"file":"retained_geometry.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/retained_geometry.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACC;;;;;OAKG;IACH,gBALW,sBAAsB,cACtB,MAAM,EAAE,UACR,MAAM,6BA+DhB;IA3DA,2BAAY;IACZ,qBAA4B;IAC5B,eAAoB;IACpB,0BAAsC;IAEtC;;;OAGG;IACH,cAFU,WAAW,CAEgB;IAErC;;;OAGG;IACH,eAFU,WAAW,CAEiB;IAEtC;;;;;OAKG;IACH,WAFU,MAAM,CAEkB;IAElC;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;;OAIG;IACH,iBAFU,MAAM,CAES;IAYzB;;;OAGG;IACH,aAFU,gBAAgB,CAQxB;IAGH;;;;;;;OAOG;IACH,mBALW,YAAY,cACZ,MAAM,WACN,WAAW,GAAC,WAAW,GAAC,MAAM,EAAE,WAChC,MAAM,QAsChB;IAED;;OAEG;IACH,aAEC;IAED;;;OAGG;IACH,gBAwBC;CACD;6BA3K4B,kBAAkB"}

package/build/video/webgl/buffer/uniformblock.d.ts

@@ -1,81 +1,2 @@
-/**
- * A uniform buffer bound to a named block in one or more shader programs.
- *
- * Uniform arrays are charged against `MAX_FRAGMENT_UNIFORM_VECTORS`, a
- * driver-reported budget that is small on weak devices. A uniform buffer is
- * charged against `MAX_UNIFORM_BLOCK_SIZE` instead — guaranteed at least
- * 16 KB, typically 64 KB — so bulk per-frame data stops competing with
- * everything else the shader declares.
- *
- * Data is staged in a `Float32Array` and uploaded with `bufferSubData`, so
- * only the live prefix crosses the bus. Uploads are skipped entirely when the
- * staged bytes have not changed, which preserves the property the uniform
- * cache gives today: a scene whose lights are static costs nothing per frame.
- *
- * ## Context loss
- *
- * A block binding is program state, not buffer state, and every program is
- * recompiled on restore — so the binding has to be re-established afterwards
- * or the shader reads an unbound block and renders black. Callers re-bind
- * lazily, whenever the program they last bound is no longer the current one;
- * that covers a context restore without anyone subscribing to an event. The
- * buffer itself needs no recovery hook — the renderer re-runs each batcher's
- * `init()` on restore, which releases this block and builds a new one.
- * @ignore
- */
-export default class UniformBlock {
-    /**
-     * @param {WebGL2RenderingContext} gl - the rendering context
-     * @param {number} floats - capacity in floats
-     * @param {number} bindingPoint - the indexed binding point to occupy
-     */
-    constructor(gl: WebGL2RenderingContext, floats: number, bindingPoint: number);
-    gl: WebGL2RenderingContext;
-    /**
-     * staging buffer; callers write into this then call `upload`
-     * @type {Float32Array}
-     */
-    data: Float32Array;
-    /**
-     * mirror of what was last uploaded, so an unchanged frame can skip the
-     * `bufferSubData` entirely
-     * @type {Float32Array}
-     */
-    _uploaded: Float32Array;
-    /** nothing has been uploaded yet, so the mirror is not yet valid */
-    _everUploaded: boolean;
-    /** live length of the last upload; -1 until there has been one */
-    _uploadedLength: number;
-    /** @type {number} */
-    bindingPoint: number;
-    /** @type {WebGLBuffer|null} */
-    buffer: WebGLBuffer | null;
-    /**
-     * Point a program's named block at this buffer's binding point.
-     *
-     * Safe to call repeatedly — after a context restore the program is a new
-     * object and must be re-bound, and there is no way to ask whether it
-     * already was.
-     * @param {WebGLProgram} program - the linked program
-     * @param {string} blockName - the block's name in GLSL
-     * @returns {boolean} `false` when the program does not declare the block
-     */
-    bindTo(program: WebGLProgram, blockName: string): boolean;
-    /**
-     * Upload the first `floats` entries of {@link UniformBlock#data}.
-     *
-     * Compares against the previous upload first and does nothing when the
-     * bytes are identical. Uniform writes are already skipped when unchanged
-     * (`utils/uniforms.js`), so uploading unconditionally here would make a
-     * static scene more expensive than it was before the buffer existed.
-     * @param {number} floats - how many floats of the staging buffer are live
-     * @returns {boolean} whether anything was actually sent to the GPU
-     */
-    upload(floats: number): boolean;
-    /**
-     * Release the GL buffer. Safe to call twice, and on a lost context.
-     */
-    destroy(): void;
-    #private;
-}
+
 //# sourceMappingURL=uniformblock.d.ts.map

package/build/video/webgl/buffer/uniformblock.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uniformblock.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/uniformblock.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;;;OAIG;IACH,gBAJW,sBAAsB,UACtB,MAAM,gBACN,MAAM,EAkChB;IA/BA,2BAAY;IAEZ;;;OAGG;IACH,MAFU,YAAY,CAEc;IAEpC;;;;OAIG;IACH,WAFU,YAAY,CAEmB;IAEzC,oEAAoE;IACpE,uBAA0B;IAE1B,kEAAkE;IAClE,wBAAyB;IAEzB,qBAAqB;IACrB,cADW,MAAM,CACe;IAEhC,+BAA+B;IAC/B,QADW,WAAW,GAAC,IAAI,CACI;IAQhC;;;;;;;;;OASG;IACH,gBAJW,YAAY,aACZ,MAAM,GACJ,OAAO,CAanB;IAED;;;;;;;;;OASG;IACH,eAHW,MAAM,GACJ,OAAO,CAmBnB;IAoBD;;OAEG;IACH,gBAYC;;CACD"}
+{"version":3,"file":"uniformblock.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/uniformblock.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IACC;;;;OAIG;IACH,gBAJW,sBAAsB,UACtB,MAAM,gBACN,MAAM,EA+DhB;IA5DA,2BAAY;IAEZ;;;OAGG;IACH,MAFU,YAAY,CAEc;IAEpC;;;;;;OAMG;IACH,WAJU,YAAY,CAImB;IAEzC;;;;OAIG;IACH,uBAA0B;IAE1B;;;;OAIG;IACH,wBAAyB;IAEzB,qBAAqB;IACrB,cADW,MAAM,CACe;IAEhC;;;;;;;;;;;;;;;;OAgBG;IACH,eAJU,OAAO,CAAC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAIlB;IAElC,+BAA+B;IAC/B,QADW,WAAW,GAAC,IAAI,CACI;IAQhC;;;;;;;;;;;OAWG;IACH,gBAJW,YAAY,aACZ,MAAM,GACJ,OAAO,CAyBnB;IAED;;;;;;;;;OASG;IACH,eAHW,MAAM,GACJ,OAAO,CAmBnB;IAqBD;;OAEG;IACH,gBAYC;;CACD"}

package/build/video/webgl/buffer/vertexstate.d.ts

@@ -1,101 +1,2 @@
-/**
- * A WebGL Vertex State — a Vertex Array Object owning a frozen vertex
- * buffer layout: one `vertexAttribPointer` / `enableVertexAttribArray` per
- * attribute against a given vertex buffer, plus the ELEMENT_ARRAY_BUFFER
- * binding when the geometry is indexed.
- *
- * This is the engine's `GPUVertexState` analogue, and the layout it is built
- * from is a `GPUVertexBufferLayout[]`: a list of buffer groups, each with its
- * own buffer, `arrayStride` and `stepMode`. Attributes in a `"vertex"` group
- * advance once per vertex (the ordinary case); attributes in an
- * `"instance"` group advance once per *instance*, which is what
- * `drawElementsInstanced` reads to stamp out N copies of one geometry.
- * The layout is immutable once built, exactly like a vertex layout baked
- * into a render pipeline.
- *
- * Attribute divisors are vertex-array state, so a fresh VAO starts with every
- * divisor at 0 and `build()` creates one each time — an instanced layout can
- * therefore never leak its divisors into an unrelated vertex state, and the
- * single-buffer path issues no `vertexAttribDivisor` calls at all.
- *
- * Every method that mutates GL binding state saves and restores the live
- * bindings itself, so building or rebuilding one vertex state can never
- * disturb whichever one is mid-frame. Callers never touch
- * `bindVertexArray` directly.
- * @ignore
- */
-export default class WebGLVertexState {
-    /**
-     * Accepts either shape — the single-buffer one (`attributes` + `stride` +
-     * `buffer`) or a list of buffer groups (`buffers`). They are equivalent;
-     * the former is the latter with one `"vertex"` group.
-     * @param {WebGL2RenderingContext} gl - the WebGL context
-     * @param {object} descriptor - the vertex layout to realize
-     * @param {object[]} [descriptor.attributes] - attribute definitions (`name`, `size`, `type`, `normalized`, `offset`)
-     * @param {number} [descriptor.stride] - size of a single vertex in bytes (`arrayStride`)
-     * @param {WebGLBuffer} [descriptor.buffer] - the vertex buffer the attribute pointers read from
-     * @param {object[]} [descriptor.buffers] - buffer groups, each `{buffer, stride, attributes, stepMode}` where `stepMode` is `"vertex"` (default) or `"instance"`
-     * @param {Function} descriptor.resolveLocation - maps an attribute name to its shader location (`-1` when absent)
-     * @param {WebGLIndexBuffer} [descriptor.indexBuffer] - index buffer to capture, for indexed geometry
-     */
-    constructor(gl: WebGL2RenderingContext, descriptor: {
-        attributes?: object[] | undefined;
-        stride?: number | undefined;
-        buffer?: WebGLBuffer | undefined;
-        buffers?: object[] | undefined;
-        resolveLocation: Function;
-        indexBuffer?: any;
-    });
-    gl: WebGL2RenderingContext;
-    descriptor: {
-        attributes?: object[] | undefined;
-        stride?: number | undefined;
-        buffer?: WebGLBuffer | undefined;
-        buffers?: object[] | undefined;
-        resolveLocation: Function;
-        indexBuffer?: WebGLIndexBuffer;
-    };
-    /**
-     * the underlying GL vertex array object
-     * @type {WebGLVertexArrayObject}
-     */
-    handle: WebGLVertexArrayObject;
-    /**
-     * (Re)build the vertex array object from this state's descriptor,
-     * replacing any previous one. Called on construction and from every
-     * buffer-recreation path — a vertex state referencing a deleted buffer
-     * keeps it alive per the GL spec and draws stale data.
-     * @param {object} [changes] - descriptor fields to replace first (e.g. recreated `buffer` / `buffers` / `indexBuffer`)
-     */
-    build(changes?: object): void;
-    /**
-     * Capture an ELEMENT_ARRAY_BUFFER binding into this vertex state.
-     * Used when an index buffer is (re)created after the state was built —
-     * the quad batchers' static pattern buffer — since that binding is
-     * vertex-array state and would otherwise land in whichever state
-     * happens to be bound.
-     * @param {WebGLIndexBuffer} indexBuffer - the index buffer to capture
-     * @param {Function} [fill] - optional work to run with this state bound (buffer creation/upload)
-     */
-    captureIndexBuffer(indexBuffer: WebGLIndexBuffer, fill?: Function): void;
-    /**
-     * Make this vertex state current. One call restores the entire frozen
-     * layout — the WebGL analogue of `setPipeline` + `setVertexBuffer` +
-     * `setIndexBuffer`.
-     */
-    bind(): void;
-    /**
-     * Delete the underlying vertex array object, if any. Idempotent, and
-     * safe on a lost context: deleting an object belonging to a lost
-     * context would queue `INVALID_OPERATION` (deletion counts as *using*
-     * it — only the `is*` queries are exempt), so probe first.
-     */
-    release(): void;
-    /**
-     * Release the vertex array object. The vertex state must not be used
-     * after calling destroy.
-     */
-    destroy(): void;
-    #private;
-}
+
 //# sourceMappingURL=vertexstate.d.ts.map

package/build/video/webgl/buffer/vertexstate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vertexstate.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/vertexstate.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IACC;;;;;;;;;;;;OAYG;IACH,gBATW,sBAAsB,cAE9B;QAA8B,UAAU;QACZ,MAAM;QACD,MAAM;QACT,OAAO;QACR,eAAe;QACN,WAAW;KACnD,EAUA;IARA,2BAAY;IACZ;;;;;;sBAJU,gBAAgB;MAIE;IAC5B;;;OAGG;IACH,QAFU,sBAAsB,CAEd;IAyBnB;;;;;;OAMG;IACH,gBAFW,MAAM,QA4EhB;IAED;;;;;;;;OAQG;IACH,gCAHW,gBAAgB,yBAa1B;IAED;;;;OAIG;IACH,aAEC;IAED;;;;;OAKG;IACH,gBAOC;IAED;;;OAGG;IACH,gBAGC;;CACD"}
+{"version":3,"file":"vertexstate.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/vertexstate.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IACC;;;;;;;;;;;;OAYG;IACH,gBATW,sBAAsB,cAE9B;QAA8B,UAAU;QACZ,MAAM;QACD,MAAM;QACT,OAAO;QACR,eAAe;QACN,WAAW;KACnD,EAUA;IARA,2BAAY;IACZ;;;;;;sBAJU,gBAAgB;MAIE;IAC5B;;;OAGG;IACH,QAFU,sBAAsB,CAEd;IA6BnB;;;;;;OAMG;IACH,gBAFW,MAAM,QA4EhB;IAED;;;;;;;;OAQG;IACH,gCAHW,gBAAgB,yBAa1B;IAED;;;;OAIG;IACH,aAEC;IAED;;;;;OAKG;IACH,gBAOC;IAED;;;OAGG;IACH,gBAGC;;CACD"}

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

@@ -60,11 +60,11 @@ export default class GLShader {
      * @example
      * // a dual-backend custom mesh shader: the same object hosts on
      * // whichever GPU renderer is active (gl is undefined on WebGPU)
-     * myMesh.shader = new me.GLShader(app.renderer.gl, {
+     * myMesh.addPostEffect(new me.GLShader(app.renderer.gl, {
      *     vertex: toonVertexGLSL,
      *     fragment: toonFragmentGLSL,
      *     wgsl: toonModuleWGSL,
-     * });
+     * }));
      */
     constructor(gl?: WebGLRenderingContext, vertex: string | object, fragment?: string, precision?: string);
     /**
@@ -98,10 +98,6 @@ export default class GLShader {
      */
     label: string | undefined;
     wgslValid: boolean;
-    _wgslRegistrations: {
-        epoch: number;
-        keys: Map<any, any>;
-    };
     /**
      * `true` once {@link destroy} has been called. After this flag is
      * `true`, every method on the shader is a silent no-op — callers
@@ -134,37 +130,11 @@ export default class GLShader {
      * @readonly
      */
     readonly suspended: boolean;
-    _sourceVertex: string | object;
-    _sourceFragment: string | undefined;
-    _precision: string | undefined;
-    _uniformCache: any;
     program: WebGLProgram;
     uniforms: object;
     attributes: number[];
-    /**
-     * (Re)compile the shader program against `this.gl` from the
-     * preserved source. Called from the constructor and from
-     * {@link _onContextRestored}. Replays any cached uniform values
-     * against the freshly-extracted uniforms proxy.
-     * @private
-     */
-    private _compile;
     vertex: any;
     fragment: any;
-    /**
-     * Handler for {@link ONCONTEXT_LOST}. Tears down the GL program
-     * but preserves the shader source + cached uniform values so the
-     * shader can be transparently rebuilt on context restore.
-     * @private
-     */
-    private _onContextLost;
-    /**
-     * Handler for {@link ONCONTEXT_RESTORED}. Re-compiles and
-     * re-links the shader against the new GL context, then replays
-     * any cached uniform values via {@link _compile}.
-     * @private
-     */
-    private _onContextRestored;
     /**
      * Installs this shader program as part of current rendering state
      */
@@ -216,25 +186,6 @@ export default class GLShader {
      * @returns {GLShader} a new, caller-owned shader (`shared === false`)
      */
     clone(): GLShader;
-    /**
-     * Register this shader's WGSL module as a pipeline family for one
-     * hosting mesh batcher, against that host's positional group-layout
-     * list and frozen vertex layout. Registered once per host per device
-     * generation; the module text is namespaced by the host key so the
-     * same shader yields distinct families (distinct pipeline layouts) on
-     * the unlit and lit hosts. Asynchronous WGSL validation errors flip
-     * {@link GLShader#wgslValid} and the host falls back to its built-in
-     * shading (warn-and-degrade, never fatal).
-     * @param {object} cache - the WebGPU renderer's pipeline cache
-     * @param {string} host - the hosting family's vertex-layout key
-     * @param {GPUBindGroupLayout[]} bindGroupLayouts - the host's group list
-     * @param {string} vertexLayoutKey - the host's registered vertex layout
-     * @returns {string|null} the family key to pass to the pipeline cache's
-     *   `get`, or null when the module failed validation on this device
-     *   generation (the host then uses its built-in family)
-     * @ignore
-     */
-    registerWGSL(cache: object, host: string, bindGroupLayouts: GPUBindGroupLayout[], vertexLayoutKey: string): string | null;
     /**
      * destroy this shader objects resources (program, attributes, uniforms).
      * Idempotent — calling destroy twice (or after a context-lost suspend)

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

@@ -1 +1 @@
-{"version":3,"file":"glshader.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/glshader.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,iBAtCW,qBAAqB,UAGrB,MAAM,GAAC,MAAM,aAGb,MAAM,cACN,MAAM,EAiKhB;IArHA;;;OAGG;IACH,IAFU,qBAAqB,CAEnB;IAEZ;;;;;OAKG;IACH,kBAHU,OAAO,CAIwD;IAEzE;;;;;OAKG;IACH,mBAHU,OAAO,CAGuB;IAExC;;;OAGG;IACH,MAFU,MAAM,GAAC,SAAS,CAEV;IAEhB;;;;OAIG;IACH,OAFU,MAAM,GAAC,SAAS,CAER;IAIlB,mBAAqB;IAKrB;;;MAAwD;IAWxD;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGK;IAEtB;;;;;;;;;OASG;IACH,QAHU,OAAO,CAGE;IAEnB;;;;;;;;;;OAUG;IACH,oBAHU,OAAO,CAGK;IAGtB,+BAA2B;IAC3B,oCAA+B;IAC/B,+BAA2B;IAG3B,mBAAwC;IAMtC,sBAAmB;IACnB,iBAAoB;IACpB,qBAAsB;IAgBzB;;;;;;OAMG;IACH,iBA0CC;IAzCA,YAGC;IACD,cAGC;IAoCF;;;;;OAKG;IACH,uBAgBC;IAED;;;;;OAKG;IACH,2BAMC;IAED;;OAEG;IACH,aAcC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,KAAK,CAcjB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,YAAY,QA4C7B;IAED;;;;;;;;;;;;;OAaG;IACH,wBAJW,qBAAqB,cACrB,MAAM,EAAE,UACR,MAAM,QAmBhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,SAFa,QAAQ,CA8BpB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,oBATW,MAAM,QACN,MAAM,oBACN,kBAAkB,EAAE,mBACpB,MAAM,GACJ,MAAM,GAAC,IAAI,CAgFvB;IAED;;;;;OAKG;IACH,gBAkCC;CACD"}
+{"version":3,"file":"glshader.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/glshader.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,iBAtCW,qBAAqB,UAGrB,MAAM,GAAC,MAAM,aAGb,MAAM,cACN,MAAM,EAqLhB;IAzIA;;;OAGG;IACH,IAFU,qBAAqB,CAEnB;IAEZ;;;;;OAKG;IACH,kBAHU,OAAO,CAIwD;IAEzE;;;;;OAKG;IACH,mBAHU,OAAO,CAGuB;IAExC;;;OAGG;IACH,MAFU,MAAM,GAAC,SAAS,CAEV;IAEhB;;;;OAIG;IACH,OAFU,MAAM,GAAC,SAAS,CAER;IAIlB,mBAAqB;IAKrB;;;OAGG;IACH;;;MAAwD;IAWxD;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGK;IAEtB;;;;;;;;;OASG;IACH,QAHU,OAAO,CAGE;IAEnB;;;;;;;;;;OAUG;IACH,oBAHU,OAAO,CAGK;IAGtB;;;OAGG;IACH,+BAA2B;IAC3B;;;OAGG;IACH,oCAA+B;IAC/B;;;OAGG;IACH,+BAA2B;IAG3B;;;OAGG;IACH,mBAAwC;IAMtC,sBAAmB;IACnB,iBAAoB;IACpB,qBAAsB;IAgBzB;;;;;;;;OAQG;IACH,iBA0CC;IAzCA,YAGC;IACD,cAGC;IAoCF;;;;;;;OAOG;IACH,uBAgBC;IAED;;;;;;;OAOG;IACH,2BAMC;IAED;;OAEG;IACH,aAcC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,KAAK,CAcjB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,YAAY,QA4C7B;IAED;;;;;;;;;;;;;OAaG;IACH,wBAJW,qBAAqB,cACrB,MAAM,EAAE,UACR,MAAM,QAmBhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,SAFa,QAAQ,CA8BpB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,oBAVW,MAAM,QACN,MAAM,oBACN,kBAAkB,EAAE,mBACpB,MAAM,GACJ,MAAM,GAAC,IAAI,CAiFvB;IAED;;;;;OAKG;IACH,gBAkCC;CACD"}

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

@@ -1,48 +1,2 @@
-import type { Light3d } from "../../../lighting/light3d.ts";
-/**
- * Uniform-ready packing of the active 3D lights for the mesh-lit shader.
- * @ignore
- */
-export interface PackedMeshLighting {
-    /** number of active shaded lights, clamped to `MAX_LIGHTS`. */
-    count: number;
-    /**
-     * `MAX_LIGHTS × 4` — `[x, y, z, range]` per light; `range` is `-1` for
-     * directional lights (the shader's type sentinel).
-     */
-    posRange: Float32Array;
-    /**
-     * `MAX_LIGHTS × 4` — `[dx, dy, dz, cos(outerConeAngle)]` per light;
-     * `cosOuter` is `-1` when no cone applies (directional carries the
-     * pre-negated surface→light vector, point carries no direction).
-     */
-    dirCone: Float32Array;
-    /**
-     * `MAX_LIGHTS × 4` — `[r, g, b, cos(innerConeAngle)]` per light,
-     * color premultiplied by intensity.
-     */
-    colorInner: Float32Array;
-    /** the summed ambient color (RGB, 0..1+). */
-    ambient: Float32Array;
-}
-/**
- * Pack an iterable of {@link Light3d} (e.g. the active `Stage`'s 3D-light set)
- * into the std140-ready arrays the mesh-lit shader reads:
- * - **directional** lights contribute a surface→light direction (negated
- *   travel direction, normalized) + a color premultiplied by intensity.
- *   Re-normalized here so a direction mutated at runtime without
- *   re-normalizing still shades correctly.
- * - **point** lights contribute their world position, `range` (quadratic
- *   falloff over the range — the Light2d model) and premultiplied color.
- * - **spot** lights add their travel direction and the cone cosines
- *   (`innerConeAngle` clamped just inside `outerConeAngle`, so the
- *   smoothstep denominator never collapses).
- * - **ambient** lights are summed into a single flat ambient color.
- *
- * The same buffers are returned each call (overwritten in place).
- * @param lights - iterable of lights, or `null`/`undefined` (treated as empty)
- * @returns the packed lighting (reused instance)
- * @ignore
- */
-export declare function packMeshLights(lights: Iterable<Light3d> | null | undefined): PackedMeshLighting;
+export {};
 //# sourceMappingURL=pack3d.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"pack3d.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/lighting/pack3d.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,8BAA8B,CAAC;AAG5D;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAClC,+DAA+D;IAC/D,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,QAAQ,EAAE,YAAY,CAAC;IACvB;;;;OAIG;IACH,OAAO,EAAE,YAAY,CAAC;IACtB;;;OAGG;IACH,UAAU,EAAE,YAAY,CAAC;IACzB,6CAA6C;IAC7C,OAAO,EAAE,YAAY,CAAC;CACtB;AAgBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAC7B,MAAM,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,GAC1C,kBAAkB,CAuFpB"}
+{"version":3,"file":"pack3d.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/lighting/pack3d.ts"],"names":[],"mappings":""}

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

@@ -1,110 +1,2 @@
-/**
- * Header, occupying two `vec4`s before the light array begins.
- *
- * ```glsl
- * int  count;     // offset 0
- * vec3 ambient;   // offset 16 — a vec3 aligns to 16, so it cannot share
- * ```
- *
- * `count` is written as a float and read back with `int(...)` in the
- * shader. Declaring it `int` in the block would be tidier, but mixing int
- * and float members means the staging buffer can no longer be a single
- * `Float32Array` view, and the cast is free on every GPU that matters.
- * @ignore
- */
-export declare const HEADER_FLOATS: number;
-/**
- * floats occupied by one light: two `vec4`s
- * @ignore
- */
-export declare const LIGHT_FLOATS: number;
-/**
- * total floats in a light block, header included
- * @ignore
- */
-export declare const BLOCK_FLOATS: number;
-/**
- * total bytes in a light block
- * @ignore
- */
-export declare const BLOCK_BYTES: number;
-/**
- * Lay out 2D (`Light2d`) data.
- *
- * ```glsl
- * struct Light2dData {
- *   vec4 posRadiusIntensity;  // x, y, radius, intensity
- *   vec4 colorHeight;         // r, g, b, lightHeight
- * };
- * ```
- * @param out - staging buffer, at least `BLOCK_FLOATS` long
- * @param packed - what {@link packLights} produced
- * @param packed.count - number of live lights, clamped to `MAX_LIGHTS`
- * @param packed.positions - `[x, y, radius, intensity]` per light
- * @param packed.colors - `[r, g, b]` per light, 0..1 per channel
- * @param packed.heights - per-light height; absent means 0
- * @param packed.ambient - `[r, g, b]` ambient floor; absent means black
- * @returns how many floats of `out` are live, for a partial upload
- * @ignore
- */
-export declare function writeLight2dBlock(out: Float32Array, packed: {
-    count: number;
-    positions: Float32Array;
-    colors: Float32Array;
-    heights?: Float32Array;
-    ambient?: ArrayLike<number>;
-}): number;
-/**
- * floats occupied by one 3D light: three `vec4`s. The 3D block grew from
- * two when point/spot shading landed (#1536) — a spot light needs position
- * + range + direction + both cone cosines + color, which cannot fold into
- * two vec4s' padding. The 2D block keeps its two-vec4 stride.
- * @ignore
- */
-export declare const LIGHT3D_FLOATS: number;
-/**
- * total floats in a 3D light block, header included
- * @ignore
- */
-export declare const BLOCK3D_FLOATS: number;
-/**
- * total bytes in a 3D light block
- * @ignore
- */
-export declare const BLOCK3D_BYTES: number;
-/**
- * Lay out 3D (`Light3d`) data.
- *
- * ```glsl
- * struct Light3dData {
- *   vec4 posRange;    // x, y, z = world position · w = range;
- *                     //   w < 0 marks a DIRECTIONAL light (xyz unused)
- *   vec4 dirCone;     // x, y, z = direction · w = cos(outerConeAngle);
- *                     //   w = -1 marks "no cone" (directional dir is the
- *                     //   pre-negated surface→light vector; a point light
- *                     //   carries no direction)
- *   vec4 colorInner;  // r, g, b = color × intensity · w = cos(innerConeAngle)
- * };
- * ```
- *
- * The type is inferred from the sentinels rather than a tag slot:
- * `posRange.w < 0` → directional; otherwise positional, with a cone
- * applied when `dirCone.w > -1`.
- * @param out - staging buffer, at least `BLOCK3D_FLOATS` long
- * @param packed - what {@link packMeshLights} produced
- * @param packed.count - number of live lights, clamped to `MAX_LIGHTS`
- * @param packed.posRange - `[x, y, z, range]` per light (range -1 for directional)
- * @param packed.dirCone - `[dx, dy, dz, cosOuter]` per light (cosOuter -1 for none)
- * @param packed.colorInner - `[r, g, b, cosInner]` per light
- * @param packed.ambient - `[r, g, b]` ambient floor; absent means black
- * @returns how many floats of `out` are live, for a partial upload
- * @ignore
- */
-export declare function writeLight3dBlock(out: Float32Array, packed: {
-    count: number;
-    posRange: Float32Array;
-    dirCone: Float32Array;
-    colorInner: Float32Array;
-    ambient?: ArrayLike<number>;
-}): number;
+export {};
 //# sourceMappingURL=std140.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"std140.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/lighting/std140.ts"],"names":[],"mappings":"AAsCA;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,QAAW,CAAC;AAEtC;;;GAGG;AACH,eAAO,MAAM,YAAY,QAAW,CAAC;AAErC;;;GAGG;AACH,eAAO,MAAM,YAAY,QAA4C,CAAC;AAEtE;;;GAGG;AACH,eAAO,MAAM,WAAW,QAAgD,CAAC;AA0BzE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAChC,GAAG,EAAE,YAAY,EACjB,MAAM,EAAE;IACP,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,CAAC,EAAE,YAAY,CAAC;IACvB,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CAC5B,GACC,MAAM,CAkCR;AAED;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,QAAW,CAAC;AAEvC;;;GAGG;AACH,eAAO,MAAM,cAAc,QAA8C,CAAC;AAE1E;;;GAGG;AACH,eAAO,MAAM,aAAa,QAAkD,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,iBAAiB,CAChC,GAAG,EAAE,YAAY,EACjB,MAAM,EAAE;IACP,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,YAAY,CAAC;IACvB,OAAO,EAAE,YAAY,CAAC;IACtB,UAAU,EAAE,YAAY,CAAC;IACzB,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CAC5B,GACC,MAAM,CA4BR"}
+{"version":3,"file":"std140.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/lighting/std140.ts"],"names":[],"mappings":""}