melonjs 20.3.0 → 20.5.0

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

@@ -1 +1 @@
-{"version":3,"file":"material_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/material_batcher.js"],"names":[],"mappings":"AAgCA;IACC;;;OAGG;IACH,yCAoDC;IAiCD,6BAPU,MAAM,EASf;IAlBD;;;;;;;;;;;OAWG;IACH,0BAHU,MAAM,CAKf;IA5EA;;;OAGG;IACH,iCAAuB;IAEvB;;;;;;;;;OASG;IACH,oCAA2B;IAwB1B,+CAEC;IAKH;;;;;;;OAOG;IACH,6BAKC;IAsDD;;;;;;;;;;;OAWG;IACH,sBAVW,MAAM,WACN,8DAAM,iBAAiB,GAAC,SAAS,GAAC,UAAU,EAAE,GAAC,YAAY,EAAE,UAC7D,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,uBACN,OAAO,WACP,OAAO,kCACL,YAAY,CAoKxB;IAED;;;OAGG;IACH,yBAFW,YAAY,GAAC,YAAY,QAuCnC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,YAAY,CAIxB;IAED;;;;OAIG;IACH,uBAHW,YAAY,QACZ,MAAM,yBAsBhB;IAED;;;;;OAKG;IACH;;;;;;;;OAQG;IACH,uBAHW,MAAM,QAKhB;IAED,8CAWC;IAED;;;;;;;;;;;OAWG;IACH,qBAHW,MAAM,QAQhB;IAED;;;;;;;;;;;;;;OAcG;IACH,uBAbW,YAAY,GAAC,eAAe,MAC5B,MAAM,MAGN,MAAM,UACN,OAAO,UACP,OAAO,WACP,MAAM,OA2GhB;CACD;6BApkB4B,cAAc;kCAIZ,0BAA0B"}
+{"version":3,"file":"material_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/material_batcher.js"],"names":[],"mappings":"AAkCA;IACC;;;;OAIG;IACH,yCA2DC;IAmCD,6BARU,MAAM,EAUf;IAnBD;;;;;;;;;;;;OAYG;IACH,0BAJU,MAAM,CAMf;IArFA;;;;OAIG;IACH,iCAAuB;IAEvB;;;;;;;;;;OAUG;IACH,oCAA2B;IAyB1B;;;OAGG;IACH,+CAEC;IAKH;;;;;;;;OAQG;IACH,6BAKC;IAyDD;;;;;;;;;;;OAWG;IACH,sBAVW,MAAM,WACN,8DAAM,iBAAiB,GAAC,SAAS,GAAC,UAAU,EAAE,GAAC,YAAY,EAAE,UAC7D,MAAM,WACN,MAAM,MACN,MAAM,MACN,MAAM,uBACN,OAAO,WACP,OAAO,kCACL,YAAY,CAoKxB;IAED;;;OAGG;IACH,yBAFW,YAAY,GAAC,YAAY,QAuCnC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,YAAY,CAIxB;IAED;;;;OAIG;IACH,uBAHW,YAAY,QACZ,MAAM,yBAsBhB;IAED;;;;;OAKG;IACH;;;;;;;;;OASG;IACH,uBAJW,MAAM,QAMhB;IAED,8CAWC;IAED;;;;;;;;;;;;OAYG;IACH,qBAJW,MAAM,QAShB;IAED;;;;;;;;;;;;;;;OAeG;IACH,uBAbW,YAAY,GAAC,eAAe,MAC5B,MAAM,MAGN,MAAM,UACN,OAAO,UACP,OAAO,WACP,MAAM,OA2GhB;CACD;6BArlB4B,cAAc;kCAIZ,0BAA0B"}

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

@@ -29,11 +29,6 @@
  * @category Rendering
  */
 export default class MeshBatcher extends MaterialBatcher {
-    /**
-     * Initialize the mesh batcher
-     * @ignore
-     */
-    init(renderer: any): void;
     currentAlphaCutoff: any;
     currentEmissiveR: any;
     currentEmissiveG: any;
@@ -47,353 +42,29 @@ export default class MeshBatcher extends MaterialBatcher {
     currentEyeX: any;
     currentEyeY: any;
     currentEyeZ: any;
+    currentFogMode: any;
+    currentFogNear: any;
+    currentFogInvRange: any;
+    currentFogDensity: any;
+    currentFogR: any;
+    currentFogG: any;
+    currentFogB: any;
+    currentFogAxisX: any;
+    currentFogAxisY: any;
+    currentFogAxisZ: any;
+    currentFogBase: any;
     retained: Map<any, any> | undefined;
     instanced: Map<any, any> | undefined;
-    instancedShaders: Map<any, any> | undefined;
-    shadowShader: GLShader | undefined;
+    shaderVariants: Map<any, any> | 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
-     * `aVertex` (3) + `aRegion` (2) + `aColor` (4) = 9 floats. Subclasses
-     * (e.g. {@link LitMeshBatcher}) append their own attributes.
-     * @ignore
-     */
-    _attributeLayout(_renderer: any): {
-        name: string;
-        format: string;
-        offset: number;
-    }[];
-    /**
-     * The shader sources for this batcher (unlit by default). Subclasses
-     * override to supply a lit shader.
-     * @ignore
-     */
-    _shaderSources(): {
-        vertex: any;
-        fragment: any;
-    };
-    /**
-     * Invalidate the per-mesh `uAlphaCutoff` / `uEmissive` caches when the bound
-     * shader (GL program) changes — the new program's uniforms are at their own
-     * defaults, so the next mesh must re-issue them rather than trust the cache.
-     * Mirrors the base batcher's `currentSamplerUnit` reset (same condition), and
-     * matters when a custom mesh shader declaring those uniforms is interleaved
-     * with the built-in one on this batcher (e.g. `drawMesh` swapping a custom
-     * shader in and back out).
-     * @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
-     * matching their {@link MeshBatcher#_attributeLayout} (e.g.
-     * {@link LitMeshBatcher} pushes the world-space normal too).
-     * @param {object} vertexData - the batcher's vertex buffer
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
-     * @param {number} u
-     * @param {number} v
-     * @param {number} color - packed ARGB Uint32
-     * @param {object} _mesh - the source mesh (unused here; for subclasses)
-     * @param {number} _i3 - the source vertex's `index * 3` (for subclasses)
-     * @ignore
-     */
-    _pushVertex(vertexData: object, x: number, y: number, z: number, u: number, v: number, color: number, _mesh: object, _i3: number): void;
-    /**
-     * Add a textured mesh to the batch. When the mesh has a
-     * `vertexColors` array (multi-material OBJ + bound MTL), each
-     * vertex's `aColor` attribute comes from that buffer instead of
-     * the shared `tint` argument — so multi-material rendering needs
-     * 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 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
-     */
-    /**
-     * 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;
+    setPlacementUniforms(modelMatrix: any, tint: any, mesh: any): 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";
+import GLShader from "../glshader.js";
 //# 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":"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"}
+{"version":3,"file":"mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/mesh_batcher.js"],"names":[],"mappings":"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"}

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

@@ -8,16 +8,6 @@
  * @category Rendering
  */
 export default class PrimitiveBatcher extends WebGLBatcher {
-    /**
-     * Initialize the compositor
-     * @ignore
-     */
-    init(renderer: any): void;
-    /**
-     * the current line width applied to the shader uniform
-     * @ignore
-     */
-    currentLineWidth: any;
     /**
      * Draw an array of vertices
      * @param {GLenum} mode - primitive type to render (gl.POINTS, gl.LINE_STRIP, gl.LINE_LOOP, gl.LINES, gl.TRIANGLE_STRIP, gl.TRIANGLE_FAN, gl.TRIANGLES)

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":"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"}
+{"version":3,"file":"primitive_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/primitive_batcher.js"],"names":[],"mappings":"AASA;;;GAGG;AAEH;;;;GAIG;AACH;IACC;;;;OAIG;IACH,0BAiCC;IANA;;;;OAIG;IACH,sBAAyB;IA2B1B;;;;;OAKG;IACH,mBAJW,MAAM,SACN,KAAK,EAAE,gBACP,MAAM,QA2DhB;;CAiID;6BA7Q4B,cAAc;2BAInB,gCAAgC"}

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

@@ -8,36 +8,6 @@
  * @category Rendering
  */
 export default class QuadBatcher extends MaterialBatcher {
-    /**
-     * Initialize the compositor
-     * @ignore
-     */
-    init(renderer: any): void;
-    /**
-     * the maximum number of texture units used for multi-texture batching
-     * @type {number}
-     * @ignore
-     */
-    maxBatchTextures: number | undefined;
-    /**
-     * whether multi-texture batching is currently active
-     * (disabled when a custom ShaderEffect is applied)
-     * @type {boolean}
-     * @ignore
-     */
-    useMultiTexture: boolean | undefined;
-    /**
-     * (Re-)create the index buffer for quad batching (4 verts + 6 indices per quad).
-     * Called from `init` and `reset` (after context loss).
-     * @ignore
-     */
-    createIndexBuffer(): void;
-    /**
-     * Bind the color sampler uniforms (`uSampler0..uSamplerN-1`) to their
-     * respective texture units. Called from `init` and `reset`.
-     * @ignore
-     */
-    bindColorSamplers(): void;
     /**
      * Select the shader to use for compositing.
      * Multi-texture batching is automatically enabled when the default

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":"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"}
+{"version":3,"file":"quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/batchers/quad_batcher.js"],"names":[],"mappings":"AAOA;;;GAGG;AAEH;;;;GAIG;AACH;IACC;;;;OAIG;IACH,0BAyDC;IAxDA;;;;;OAKG;IAMH,qCAA4C;IAmC5C;;;;;;OAMG;IACH,qCAA2B;IAK5B;;;;;OAKG;IACH,0BAmBC;IAED;;;;;OAKG;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,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;gCA3V+B,uBAAuB;kCAIxB,0BAA0B"}

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

@@ -1,38 +1,3 @@
-/**
- * A WebGL Index Buffer — extends {@link IndexBuffer} with GL buffer binding and upload.
- * @ignore
- */
-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 instead of Uint16 (a capacity knob — Uint16 keeps index uploads half the size)
-     */
-    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, maxIndices: number, useUint32?: boolean);
-    gl: WebGLRenderingContext | WebGL2RenderingContext;
-    type: 5123 | 5125;
-    buffer: WebGLBuffer;
-    /**
-     * Upload the current index data to the GPU (for dynamic buffers)
-     */
-    upload(): void;
-    /**
-     * Bind this index buffer
-     */
-    bind(): void;
-    /**
-     * Replace the underlying GL buffer with a fresh one, deleting the old.
-     * Needed on context restore — the old buffer object belongs to the lost
-     * context and every upload through it would silently fail. Also keeps
-     * plain resets leak-free (`deleteBuffer` on a lost-context object is a
-     * harmless no-op).
-     */
-    recreate(): void;
-    /**
-     * Delete the underlying GL buffer. The index buffer must not be used
-     * after calling destroy.
-     */
-    destroy(): void;
-}
+
 import IndexBuffer from "../../buffer/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/index.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;IACC;;;;OAIG;IACH,gBAJW,qBAAqB,GAAC,sBAAsB,cAC5C,MAAM,cACN,OAAO,EAOjB;IAHA,mDAAY;IACZ,kBAA2D;IAC3D,oBAA+B;IAiBhC;;OAEG;IACH,eAOC;IAED;;OAEG;IACH,aAEC;IAED;;;;;;OAMG;IACH,iBAIC;IAED;;;OAGG;IACH,gBAGC;CACD;wBA1EuB,uBAAuB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/index.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;IACC;;;;OAIG;IACH,gBAJW,qBAAqB,GAAC,sBAAsB,cAC5C,MAAM,cACN,OAAO,EAOjB;IAHA,mDAAY;IACZ,kBAA2D;IAC3D,oBAA+B;IAiBhC;;OAEG;IACH,eAOC;IAED;;OAEG;IACH,aAEC;IAED;;;;;;OAMG;IACH,iBAIC;IAED;;;OAGG;IACH,gBAGC;CACD;wBA3EuB,uBAAuB"}

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