melonjs 19.9.1 → 20.0.0

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

@@ -5,10 +5,14 @@
  * Owns mesh-mode GL state ownership (since 19.7 / #1468):
  *
  * - {@link MeshBatcher#bind} enters mesh mode — enables `DEPTH_TEST` +
- *   `LEQUAL` + `depthMask`, disables `BLEND`, and runs a one-shot
- *   `clearDepth(1.0) + clear(DEPTH_BUFFER_BIT)` if the active target's
- *   depth attachment is still dirty. Subsequent mesh draws against the
- *   same target rely on the accumulated depth buffer.
+ *   `LEQUAL` + `depthMask`, disables `BLEND`.
+ * - {@link MeshBatcher#updatePassState} runs the one-shot
+ *   `clearDepth(1.0) + clear(DEPTH_BUFFER_BIT)` when the active target's
+ *   depth attachment is still dirty, immediately before a draw rather than
+ *   on entry — `bind()` fires on a batcher *transition*, not once a frame,
+ *   so a scene made only of meshes would otherwise never clear again after
+ *   its first frame. Subsequent draws against the same target rely on the
+ *   accumulated depth buffer.
  * - {@link MeshBatcher#unbind} exits mesh mode — restores non-mesh
  *   defaults (`BLEND` on, `DEPTH_TEST` off, `depthMask` false) that the
  *   2D rendering paths assume.
@@ -18,7 +22,8 @@
  *   framebuffer's attachments change identity.
  *
  * The WebGLRenderer doesn't know any of this — `setBatcher("mesh")` calls
- * `bind()` and the batcher sets up its own pass. Same lifecycle ports
+ * `bind()` and the batcher sets up its own pass, refreshing whatever is
+ * per-draw as it goes. Same lifecycle ports
  * cleanly to a future WebGPU renderer: `bind()` becomes "begin a
  * depth-enabled `RenderPassEncoder`", `unbind()` ends it.
  * @category Rendering
@@ -33,6 +38,23 @@ export default class MeshBatcher extends MaterialBatcher {
     currentEmissiveR: any;
     currentEmissiveG: any;
     currentEmissiveB: any;
+    currentShininess: any;
+    currentSpecularR: any;
+    currentSpecularG: any;
+    currentSpecularB: any;
+    currentAlphaMapUnit: any;
+    currentHasAlphaMap: any;
+    currentEyeX: any;
+    currentEyeY: any;
+    currentEyeZ: any;
+    retained: Map<any, any> | undefined;
+    instanced: Map<any, any> | undefined;
+    instancedShaders: Map<any, any> | undefined;
+    shadowShader: GLShader | undefined;
+    currentTintValue: any;
+    trilinearTextures: WeakSet<object> | undefined;
+    anisotropicExt: any;
+    maxAnisotropy: number | undefined;
     _onTargetChanged: ((emitter: any) => void) | null | undefined;
     /**
      * The vertex attribute layout. The base (unlit) mesh batcher is
@@ -40,11 +62,9 @@ export default class MeshBatcher extends MaterialBatcher {
      * (e.g. {@link LitMeshBatcher}) append their own attributes.
      * @ignore
      */
-    _attributeLayout(renderer: any): {
+    _attributeLayout(_renderer: any): {
         name: string;
-        size: number;
-        type: any;
-        normalized: boolean;
+        format: string;
         offset: number;
     }[];
     /**
@@ -67,6 +87,31 @@ export default class MeshBatcher extends MaterialBatcher {
      * @ignore
      */
     useShader(shader: any): void;
+    /**
+     * Refresh pass-scoped state, immediately before a draw.
+     *
+     * This exists because `bind()` is *not* a per-frame hook. `setBatcher`
+     * returns early when the requested batcher is already current, so a scene
+     * that draws nothing but meshes — no sprites, no UI, no unlit geometry to
+     * force a switch — binds once and never again. Anything set up in `bind()`
+     * then freezes at its first-frame value.
+     *
+     * The depth clear is one such thing. `renderer._meshDepthDirty` is re-armed
+     * every time the render target changes (frame-start `clear()`, FBO
+     * bind/unbind), but a flag nobody reads is a flag that does nothing: left in
+     * `bind()` it would stay armed forever and the depth attachment would carry
+     * the first frame's values for the life of the scene, occluding geometry as
+     * the camera moved. Consuming it here runs the clear once per target, which
+     * is what the flag always meant. {@link LitMeshBatcher} extends this with
+     * its light data, which had the same problem.
+     *
+     * Cheap by construction: one boolean test per draw in the common case.
+     * `depthMask` is guaranteed true here — `bind()` sets it and only `unbind()`
+     * clears it, so this batcher being current implies a writable depth buffer,
+     * without which `gl.clear(DEPTH_BUFFER_BIT)` would silently do nothing.
+     * @ignore
+     */
+    updatePassState(): void;
     /**
      * Write one vertex into the buffer. The base (unlit) layout is
      * `x, y, z, u, v, color`. Subclasses override to append per-vertex data
@@ -92,14 +137,263 @@ export default class MeshBatcher extends MaterialBatcher {
      * no extra draw calls per material vs single-material (large
      * meshes still get chunked across multiple flushes to fit the
      * vertex/index buffer limits — same behavior as single-material).
-     * The shared `tint` is then multiplied into each vertex color
-     * CPU-side (via `mulPackedARGB`, before `pushMesh`), preserving
-     * runtime flash / fade / team-color effects — the mesh shader
-     * itself just does `texture * aColor`, no extra uniform.
+     * The runtime `tint` is applied by the shader through the `uTint`
+     * uniform rather than being multiplied into each vertex color, so
+     * flash / fade / team-color effects never touch vertex data.
      * @param {object} mesh - a Mesh object with vertices, uvs, indices, and texture properties
      * @param {number} tint - tint color in UINT32 (argb) format
      */
-    addMesh(mesh: object, tint: number): void;
+    /**
+     * Issue the per-draw placement uniforms: where the geometry sits
+     * (`uModelMatrix`), where the camera is (`uViewMatrix`), and the colour
+     * it is tinted with (`uTint`).
+     *
+     * Keeping these as uniforms rather than baking them into vertex data is
+     * what lets geometry be uploaded once and reused: moving, rotating,
+     * scaling or re-tinting a mesh changes only these values.
+     *
+     * Each set is guarded on the uniform actually being declared, because
+     * `GLShader.setUniform` throws on an unknown name and a custom mesh
+     * shader need not declare all of them.
+     * @param {Matrix3d} modelMatrix - the mesh's own placement, or identity when its vertices are already positioned
+     * @param {number} tint - tint colour in UINT32 (argb) format
+     * @ignore
+     */
+    /**
+     * Write one mesh's model-space geometry into `out` in this batcher's
+     * vertex layout, returning how many floats were written.
+     *
+     * The data deliberately carries no placement, camera or tint information
+     * — those are uniforms — so it stays valid for the lifetime of the
+     * geometry. Subclasses override to append their own per-vertex data.
+     * @param {object} mesh - the mesh to read geometry from
+     * @param {Float32Array} out - destination scratch, at least `vertexCount × vertexSize` long
+     * @returns {number} number of floats written
+     * @ignore
+     */
+    buildRetainedVertexData(mesh: object, out: Float32Array): number;
+    /**
+     * Get this mesh's retained geometry, building or refreshing it when the
+     * mesh's geometry version has moved on.
+     * @param {object} mesh - the mesh whose geometry is wanted
+     * @returns {RetainedGeometry} up-to-date geometry for the mesh
+     * @ignore
+     */
+    retainedGeometryFor(mesh: object): RetainedGeometry;
+    /**
+     * Draw a mesh from its retained geometry: bind the persistent buffers and
+     * issue one indexed draw, with placement supplied entirely by uniforms.
+     *
+     * Unlike {@link addMesh} this accumulates nothing and never chunks — the
+     * whole mesh is one draw call regardless of size, except for a
+     * multi-material model whose materials carry different diffuse textures:
+     * that draws one indexed range per entry in {@link Mesh#textureGroups}
+     * (#1573), over the same buffers, with only the sampler moving between
+     * them.
+     * @param {object} mesh - the mesh to draw
+     * @param {Matrix3d} modelMatrix - where the mesh sits in the world
+     * @param {number} tint - tint colour in UINT32 (argb) format
+     * @ignore
+     */
+    drawRetainedMesh(mesh: object, modelMatrix: Matrix3d, tint: number): void;
+    /**
+     * Enter the blended mesh draw state: alpha blending on, depth test still
+     * on, depth WRITES off (#1515).
+     *
+     * The blend function is set explicitly rather than through
+     * `renderer.setBlendMode`. That method short-circuits when the mode is
+     * unchanged, and `MeshBatcher.bind()` has already disabled `GL_BLEND`
+     * behind that cache's back — so asking for the mode the cache already
+     * claims would leave blending off and the draw opaque. Merely calling
+     * `setBlendEnabled(true)` is no better: it inherits whatever function the
+     * last 2D draw left, and under `"additive"` a dark shadow would *brighten*
+     * the ground.
+     * @ignore
+     */
+    beginBlendedDraw(): void;
+    /**
+     * Leave the blended draw state, restoring mesh mode exactly as
+     * {@link MeshBatcher#bind} left it.
+     *
+     * The blend FUNCTION is put back too, not just the enable bit. This draw
+     * overwrote it without touching `renderer.currentBlendMode`, so a later 2D
+     * draw asking for the mode the cache already claims would short-circuit
+     * and silently inherit this one's function. Re-issuing through
+     * `setBlendMode` with the cache invalidated restores both, and leaves the
+     * cache reading exactly what it read before.
+     * @ignore
+     */
+    endBlendedDraw(): void;
+    /**
+     * Get (building or refreshing as needed) the GPU state one instanced mesh
+     * draws from: its retained prototype geometry, its instance buffer, and
+     * the vertex state binding the two together.
+     *
+     * The vertex state is rebuilt only when a buffer object it references is
+     * replaced — a growing instance set reallocates, a merely-edited one does
+     * not — because a vertex array holding a deleted buffer keeps it alive per
+     * the GL spec and silently draws stale data.
+     * @param {InstancedMesh} mesh - the mesh to draw
+     * @returns {object} `{geometry, instances, vertexState}`
+     * @ignore
+     */
+    instancedStateFor(mesh: InstancedMesh): object;
+    /**
+     * The instanced shader for a given record layout, compiled on first use.
+     *
+     * Variants are source permutations rather than runtime branches: the
+     * optional slots are `#ifdef`-guarded, so a mesh that declares neither
+     * costs no unused attributes and no dead code. `minify` deliberately
+     * preserves newlines so the directives survive it.
+     * @param {object} layout - the instance record layout
+     * @returns {GLShader} the shader for that combination
+     * @ignore
+     */
+    instancedShaderFor(layout: object): GLShader;
+    /**
+     * The instanced shader sources for this batcher (unlit by default).
+     * Subclasses override to supply the lit pair.
+     * @ignore
+     */
+    _instancedShaderSources(): {
+        vertex: any;
+        fragment: any;
+    };
+    /**
+     * Resolve an instance record layout into GL attribute records, in the
+     * `{name, size, type, normalized, offset}` shape the vertex state wants.
+     * Every slot is a `float32x4`.
+     * @param {object} layout - the instance record layout
+     * @returns {object[]} attribute records
+     * @ignore
+     */
+    _instanceAttributeRecords(layout: object): object[];
+    /**
+     * Draw every visible instance of a mesh in one call.
+     *
+     * The geometry is bound once and the GPU walks the instance buffer,
+     * advancing the per-instance attributes one record per copy. Placement of
+     * the *group* still rides the ordinary uniforms, so moving the whole set
+     * costs one matrix and re-uploads nothing.
+     * @param {InstancedMesh} mesh - the mesh to draw
+     * @param {Matrix3d} modelMatrix - where the group sits in the world
+     * @param {number} tint - tint colour in UINT32 (argb) format
+     * @ignore
+     */
+    drawInstancedMesh(mesh: InstancedMesh, modelMatrix: Matrix3d, tint: number): void;
+    _instancedShaderWarned: boolean | undefined;
+    /**
+     * The instanced ground-shadow program (#1515), compiled on first use.
+     *
+     * ONE shader, not a variant per record layout: it reads only the three
+     * transform rows, so `hasColor` / `hasData` make no difference to it —
+     * which is also what stops a forest with per-instance colour and emissive
+     * from getting coloured, glowing shadows.
+     * @returns {GLShader} the shadow program
+     * @ignore
+     */
+    instancedShadowShader(): GLShader;
+    /**
+     * The vertex state pairing the SHARED shadow quad's geometry with this
+     * mesh's own instance records.
+     *
+     * Kept in its own slot with its own staleness fields rather than reusing
+     * the main pass's: that one keys on `builtGeometry` and `builtShader`, and
+     * the shadow pass differs in both, so sharing a slot would make the two
+     * passes rebuild each other's vertex array on every single draw.
+     *
+     * The instance buffer itself IS shared — the main pass already uploaded
+     * it this frame, so this adds no upload.
+     * @param {InstancedMesh} mesh - the mesh casting the shadows
+     * @param {object} quadGeometry - the shared shadow quad's retained geometry
+     * @returns {object} the per-mesh instanced state, with `shadowVertexState` built
+     * @ignore
+     */
+    instancedShadowStateFor(mesh: InstancedMesh, quadGeometry: object): object;
+    /**
+     * Draw one flat blob per instance, in a single call, from the same
+     * instance buffer the mesh itself drew from (#1515).
+     * @param {InstancedMesh} mesh - the mesh casting the shadows
+     * @param {Matrix3d} shadowMatrix - the group matrix, flattened onto the ground
+     * @param {number} tint - tint colour in UINT32 (argb) format
+     * @param {object} quad - the shared shadow quad mesh
+     * @ignore
+     */
+    drawInstancedShadow(mesh: InstancedMesh, shadowMatrix: Matrix3d, tint: number, quad: object): void;
+    /**
+     * Release the instance buffer and vertex state held for one mesh, if any.
+     * @param {object} mesh - the mesh whose instance state should be freed
+     * @ignore
+     */
+    releaseInstanced(mesh: object): void;
+    /**
+     * Release every instance buffer this batcher holds.
+     * @ignore
+     */
+    releaseAllInstanced(): void;
+    /**
+     * Release the retained geometry held for one mesh, if any.
+     * @param {object} mesh - the mesh whose geometry should be freed
+     * @ignore
+     */
+    releaseRetained(mesh: object): void;
+    /**
+     * Release every retained geometry this batcher holds.
+     * @ignore
+     */
+    releaseAllRetained(): void;
+    /**
+     * In addition to the attribute-layout check, warn once when a shader
+     * hosted on this batcher declares none of the placement uniforms.
+     *
+     * Mesh geometry is now uploaded in model space, so a shader that only
+     * declares `uProjectionMatrix` — which is what every mesh shader needed
+     * before, and what {@link ShaderEffect} still generates — will draw the
+     * mesh at its untransformed origin with no camera applied. That renders
+     * as "the model vanished" rather than as an error, so say so explicitly.
+     * @param {GLShader} shader - the shader about to be hosted
+     * @ignore
+     */
+    validateShaderLocations(shader: GLShader): void;
+    setPlacementUniforms(modelMatrix: any, tint: any): void;
+    /**
+     * Bind a mesh's material state: its texture (honouring the mesh's own
+     * `textureRepeat` wrap override) and the guarded `uAlphaCutoff` /
+     * `uEmissive` uniforms.
+     *
+     * Shared by the accumulated and retained draw paths so material changes
+     * take effect immediately either way, without touching geometry.
+     * @param {object} mesh - the mesh whose material should be applied
+     * @param {TextureAtlas} [texture] - bind this texture instead of the mesh's
+     * own — how a multi-material model's per-material `map_Kd` reaches the
+     * sampler, one draw range at a time (#1573). Everything else here is a
+     * property of the mesh, not of the material group.
+     * @returns {number} the texture unit the material landed on
+     * @ignore
+     */
+    applyMeshMaterial(mesh: object, texture?: TextureAtlas): number;
+    /**
+     * Point `uSampler` at a texture unit, if it moved and if the current
+     * shader has a sampler at all — a custom mesh shader that never samples
+     * (vertex colours only) declares none, and `setUniform` throws on an
+     * unknown name.
+     * @param {number} unit - the texture unit to sample from
+     * @ignore
+     */
+    bindSamplerUnit(unit: number): void;
+    addMesh(mesh: any, tint: any): void;
+    /**
+     * Accumulate one index range of a mesh into the batch, chunking triangles
+     * across flushes as the vertex / index buffers fill.
+     * @param {object} mesh - a Mesh with vertices, uvs, indices, texture
+     * @param {number} from - first index to accumulate
+     * @param {number} length - how many indices to accumulate
+     * @ignore
+     */
+    accumulateRange(mesh: object, from: number, length: number): void;
 }
 import { MaterialBatcher } from "./material_batcher.js";
+import GLShader from "../glshader.js";
+import RetainedGeometry from "../buffer/retained_geometry.js";
+import { Matrix3d } from "../../../math/matrix3d.ts";
 //# sourceMappingURL=mesh_batcher.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/mesh_batcher.js"],"names":[],"mappings":"AAyFA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;;OAGG;IACH,0BAsCC;IA5BA,wBAA4B;IAI5B,sBAA0B;IAC1B,sBAA0B;IAC1B,sBAA0B;IAYzB,8DAOC;IAKH;;;;;OAKG;IACH;;;;;;QAgCC;IAED;;;;OAIG;IACH;;;MAEC;IAED;;;;;;;;;OASG;IACH,6BAWC;IAyDD;;;;;;;;;;;;;;;OAeG;IACH,wBAXW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,SACN,MAAM,OACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;;OAcG;IACH,cAHW,MAAM,QACN,MAAM,QA+JhB;CACD;gCA3d+B,uBAAuB"}
+{"version":3,"file":"mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/mesh_batcher.js"],"names":[],"mappings":"AAqDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IACC;;;OAGG;IACH,0BAiHC;IAvGA,wBAA4B;IAI5B,sBAA0B;IAC1B,sBAA0B;IAC1B,sBAA0B;IAI1B,sBAA0B;IAC1B,sBAA0B;IAC1B,sBAA0B;IAC1B,sBAA0B;IAI1B,yBAA6B;IAC7B,wBAA4B;IAI5B,iBAA6B;IAC7B,iBAA6B;IAC7B,iBAA6B;IAQ7B,oCAAyB;IAQzB,qCAA0B;IAS1B,4CAAiC;IAQjC,mCAA6B;IAO7B,sBAAiC;IAKjC,+CAAsC;IAMtC,oBAAuE;IACvE,kCAKI;IAYH,8DAOC;IAKH;;;;;OAKG;IACH;;;;QA0BC;IAED;;;;OAIG;IACH;;;MAEC;IAED;;;;;;;;;OASG;IACH,6BAcC;IAgED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,wBAOC;IAcD;;;;;;;;;;;;;;;OAeG;IACH,wBAXW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,MAAM,SACN,MAAM,OACN,MAAM,QAKhB;IAED;;;;;;;;;;;;;OAaG;IACH;;;;;;;;;;;;;;;OAeG;IACH;;;;;;;;;;;OAWG;IACH,8BALW,MAAM,OACN,YAAY,GACV,MAAM,CAMlB;IAED;;;;;;OAMG;IACH,0BAJW,MAAM,GACJ,gBAAgB,CAuB5B;IAED;;;;;;;;;;;;;;OAcG;IACH,uBALW,MAAM,eACN,QAAQ,QACR,MAAM,QAgFhB;IAED;;;;;;;;;;;;;OAaG;IACH,yBAYC;IAED;;;;;;;;;;;OAWG;IACH,uBAWC;IAED;;;;;;;;;;;;OAYG;IACH,wBAJW,aAAa,GACX,MAAM,CAqFlB;IAED;;;;;;;;;;OAUG;IACH,2BAJW,MAAM,GACJ,QAAQ,CAuBpB;IAED;;;;OAIG;IACH;;;MAEC;IAED;;;;;;;OAOG;IACH,kCAJW,MAAM,GACJ,MAAM,EAAE,CAcpB;IAED;;;;;;;;;;;OAWG;IACH,wBALW,aAAa,eACb,QAAQ,QACR,MAAM,QA2EhB;IAlDC,4CAAkC;IAoDpC;;;;;;;;;OASG;IACH,yBAHa,QAAQ,CAqBpB;IAED;;;;;;;;;;;;;;;OAeG;IACH,8BALW,aAAa,gBACb,MAAM,GACJ,MAAM,CAmElB;IAED;;;;;;;;OAQG;IACH,0BANW,aAAa,gBACb,QAAQ,QACR,MAAM,QACN,MAAM,QA+BhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,QAWhB;IAED;;;OAGG;IACH,4BAOC;IAED;;;;OAIG;IACH,sBAHW,MAAM,QAUhB;IAED;;;OAGG;IACH,2BAMC;IAED;;;;;;;;;;;OAWG;IACH,gCAHW,QAAQ,QAqBlB;IAED,wDA6CC;IAED;;;;;;;;;;;;;;OAcG;IACH,wBARW,MAAM,YACN,YAAY,GAIV,MAAM,CAyKlB;IAED;;;;;;;OAOG;IACH,sBAHW,MAAM,QAWhB;IAED,oCAyBC;IAED;;;;;;;OAOG;IACH,sBALW,MAAM,QACN,MAAM,UACN,MAAM,QAqFhB;CACD;gCA56C+B,uBAAuB;qBANlC,gBAAgB;6BAFR,gCAAgC;yBAXpC,2BAA2B"}

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

@@ -7,7 +7,7 @@
  * Pushes texture regions or shape geometry into WebGL buffers, automatically flushes to GPU
  * @category Rendering
  */
-export default class PrimitiveBatcher extends Batcher {
+export default class PrimitiveBatcher extends WebGLBatcher {
     /**
      * Initialize the compositor
      * @ignore
@@ -27,6 +27,6 @@ export default class PrimitiveBatcher extends Batcher {
     drawVertices(mode: GLenum, verts: Point[], vertexCount?: number): void;
     #private;
 }
-import { Batcher } from "./batcher.js";
+import { WebGLBatcher } from "./batcher.js";
 import type { Point } from "./../../../geometries/point.ts";
 //# sourceMappingURL=primitive_batcher.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"primitive_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/primitive_batcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BAsCC;IALA;;;OAGG;IACH,sBAAyB;IA0B1B;;;;;OAKG;IACH,mBAJW,MAAM,SACN,KAAK,EAAE,gBACP,MAAM,QAoDhB;;CAyMD;wBAjVuB,cAAc;2BAId,gCAAgC"}
+{"version":3,"file":"primitive_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/primitive_batcher.js"],"names":[],"mappings":"AASA;;;GAGG;AAEH;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BAgCC;IALA;;;OAGG;IACH,sBAAyB;IA0B1B;;;;;OAKG;IACH,mBAJW,MAAM,SACN,KAAK,EAAE,gBACP,MAAM,QA2DhB;;CA8HD;6BAvQ4B,cAAc;2BAInB,gCAAgC"}

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

@@ -2,7 +2,6 @@
  * additional import for TypeScript
  * @import {TextureAtlas} from "./../../texture/atlas.js";
  */
-export const V_ARRAY: Vector3d[];
 /**
  * A WebGL Compositor object. This class handles all of the WebGL state<br>
  * Pushes texture regions or shape geometry into WebGL buffers, automatically flushes to GPU
@@ -76,7 +75,6 @@ export default class QuadBatcher extends MaterialBatcher {
      */
     addQuad(texture: TextureAtlas, x: number, y: number, w: number, h: number, u0: number, v0: number, u1: number, v1: number, tint: number, reupload?: boolean): void;
 }
-import { Vector3d } from "../../../math/vector3d.ts";
 import { MaterialBatcher } from "./material_batcher.js";
 import type { TextureAtlas } from "./../../texture/atlas.js";
 //# sourceMappingURL=quad_batcher.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/quad_batcher.js"],"names":[],"mappings":"AAMA;;;GAGG;AAUH,iCAKE;AAEF;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BA0DC;IAzDA;;;;OAIG;IACH,qCAA0D;IA2C1D;;;;;OAKG;IACH,qCAA2B;IAK5B;;;;OAIG;IACH,0BAcC;IAED;;;;OAIG;IACH,0BAIC;IAED;;;;;;;OAOG;IACH,kBAFW,QAAQ,GAAC,YAAY,QAK/B;IAyDD;;;;;;;;;;OAUG;IACH,oBAPW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,QAAQ,GAAC,YAAY,QAkE/B;IAED;;;;;;;;;;;;;OAaG;IACH,iBAZW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,QAwEjB;CACD;yBAtWwB,2BAA2B;gCAIpB,uBAAuB;kCAIxB,0BAA0B"}
+{"version":3,"file":"quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/quad_batcher.js"],"names":[],"mappings":"AAOA;;;GAGG;AAEH;;;;GAIG;AACH;IACC;;;OAGG;IACH,0BAuDC;IAtDA;;;;OAIG;IAMH,qCAA4C;IAmC5C;;;;;OAKG;IACH,qCAA2B;IAK5B;;;;OAIG;IACH,0BAmBC;IAED;;;;OAIG;IACH,0BAIC;IAED;;;;;;;OAOG;IACH,kBAFW,QAAQ,GAAC,YAAY,QAK/B;IAwDD;;;;;;;;;;OAUG;IACH,oBAPW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,QAAQ,GAAC,YAAY,QAoE/B;IAED;;;;;;;;;;;;;OAaG;IACH,iBAZW,YAAY,KACZ,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,QAuEjB;CACD;gCArV+B,uBAAuB;kCAIxB,0BAA0B"}

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

@@ -6,7 +6,7 @@ export default class WebGLIndexBuffer extends IndexBuffer {
     /**
      * @param {WebGLRenderingContext|WebGL2RenderingContext} gl - the WebGL context
      * @param {number} maxIndices - maximum number of indices this buffer can hold
-     * @param {boolean} [useUint32=false] - use Uint32 indices (WebGL2) instead of Uint16 (WebGL1)
+     * @param {boolean} [useUint32=false] - use Uint32 indices instead of Uint16 (a capacity knob — Uint16 keeps index uploads half the size)
      */
     constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, maxIndices: number, useUint32?: boolean);
     gl: WebGLRenderingContext | WebGL2RenderingContext;

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

@@ -0,0 +1,54 @@
+/**
+ * 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

@@ -0,0 +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"}

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

@@ -0,0 +1,83 @@
+/**
+ * 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

@@ -0,0 +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"}

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

@@ -0,0 +1,81 @@
+/**
+ * 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

@@ -0,0 +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"}