melonjs 20.3.0 → 20.4.0

package/build/video/gpu/instancerecord.d.ts

@@ -1,164 +1,2 @@
-import type { Matrix3d } from "../../math/matrix3d.ts";
-/**
- * The per-instance record shared by both GPU backends (#1508).
- *
- * An instance carries a **row-major 3×4 affine transform** — three `vec4`
- * rows — rather than a full 4×4: the bottom row of an affine matrix is
- * always `(0, 0, 0, 1)`, so storing it would waste 16 bytes and a fourth
- * attribute slot per instance. Two further slots are opt-in, declared once
- * per instanced mesh:
- *
- * The transform occupies 12 floats (48 bytes); a colour slot adds 4 more
- * (16 bytes) when `instanceColors` is declared, and a custom-data slot
- * another 4 when `instanceData` is.
- *
- * Colour is four floats rather than four packed bytes for the same reason
- * `aColor` is on the mesh vertex layout: a packed 4-byte slot can form a
- * NaN bit pattern that Apple's Metal-backed driver canonicalizes on upload,
- * zeroing the bytes the shader reads.
- *
- * The custom slot is deliberately **opaque** — the stock lit shader reads
- * its `rgb` as emissive, while a custom mesh shader is free to read it as a
- * wind phase, an atlas offset or a random seed.
- * @ignore
- */
-/**
- * floats occupied by the 3×4 transform
- * @ignore
- */
-export declare const TRANSFORM_FLOATS = 12;
-/**
- * floats occupied by an optional `vec4` slot
- * @ignore
- */
-export declare const SLOT_FLOATS = 4;
-/**
- * Describes one instanced mesh's record: how wide it is and where each
- * optional slot begins. Offsets are in floats; multiply by 4 for bytes.
- * @ignore
- */
-export interface InstanceRecordLayout {
-    /** floats per instance */
-    floats: number;
-    /** bytes per instance (the vertex-buffer `arrayStride`) */
-    stride: number;
-    /** float offset of the colour slot, or -1 when absent */
-    colorOffset: number;
-    /** float offset of the custom-data slot, or -1 when absent */
-    dataOffset: number;
-    /** whether the colour slot is present */
-    hasColor: boolean;
-    /** whether the custom-data slot is present */
-    hasData: boolean;
-}
-/**
- * Build the record layout for the given opt-in slots.
- * @param hasColor - whether a per-instance colour slot is present
- * @param hasData - whether a per-instance custom `vec4` slot is present
- * @returns the resolved layout
- * @ignore
- */
-export declare function instanceRecordLayout(hasColor: boolean, hasData: boolean): InstanceRecordLayout;
-/**
- * Write a matrix into an instance record as three row-major `vec4` rows.
- *
- * `Matrix3d` stores its values **column-major** (the GL convention —
- * translation lives at `val[12..14]`), so this transposes the upper 3×4 on
- * the way in. The shader transposes back when it rebuilds a `mat4`.
- * @param target - the CPU-side instance buffer
- * @param offset - float offset of this instance's record
- * @param matrix - the transform to write
- * @ignore
- */
-export declare function writeInstanceTransform(target: Float32Array, offset: number, matrix: Matrix3d): void;
-/**
- * Write a translation / rotation / scale triple into an instance record.
- *
- * This is the shape authored instancing arrives in: glTF's
- * `EXT_mesh_gpu_instancing` stores per-instance `TRANSLATION`, `ROTATION`
- * (a quaternion) and `SCALE` accessors rather than matrices. Composing them
- * straight into the record avoids building a `Matrix3d` per instance —
- * a forest of five thousand trees would otherwise allocate five thousand
- * throwaway matrices at load.
- *
- * The rotation is applied first, then scale, then translation (glTF's
- * `T * R * S` convention), and the result is transposed into the record's
- * row-major rows.
- * @param target - the CPU-side instance buffer
- * @param offset - float offset of this instance's record
- * @param tx - translation x
- * @param ty - translation y
- * @param tz - translation z
- * @param qx - rotation quaternion x
- * @param qy - rotation quaternion y
- * @param qz - rotation quaternion z
- * @param qw - rotation quaternion w
- * @param sx - scale x
- * @param sy - scale y
- * @param sz - scale z
- * @ignore
- */
-export declare function writeInstanceTRS(target: Float32Array, offset: number, tx: number, ty: number, tz: number, qx: number, qy: number, qz: number, qw: number, sx: number, sy: number, sz: number): void;
-/**
- * Write an identity transform into an instance record — what a freshly
- * grown slot holds until the caller places it, so an unplaced instance
- * renders at the group origin rather than collapsing onto a zero matrix.
- * @param target - the CPU-side instance buffer
- * @param offset - float offset of this instance's record
- * @ignore
- */
-export declare function writeIdentityTransform(target: Float32Array, offset: number): void;
-/**
- * Read an instance's transform back into a `Matrix3d`, undoing the
- * row-major packing.
- * @param source - the CPU-side instance buffer
- * @param offset - float offset of this instance's record
- * @param out - the matrix to write into
- * @returns `out`
- * @ignore
- */
-export declare function readInstanceTransform(source: Float32Array, offset: number, out: Matrix3d): Matrix3d;
-/**
- * The attribute names an instanced shader declares, in record order. Shared
- * by both backends so the GL attribute records and the WGSL vertex layout
- * describe the same thing.
- * @ignore
- */
-export declare const INSTANCE_ATTRIBUTE_NAMES: {
-    readonly rows: readonly ["aInstanceRow0", "aInstanceRow1", "aInstanceRow2"];
-    readonly color: "aInstanceColor";
-    readonly data: "aInstanceData";
-};
-/**
- * Shader locations for the instance slots, counted from the first location
- * after a tier's geometry attributes.
- *
- * These are **fixed per slot rather than sequential**, so a variant that
- * omits the colour slot does not shift the data slot down. On WebGPU that is
- * what lets one WGSL module text serve every variant — WGSL has no
- * preprocessor to renumber `@location` with — and on WebGL it keeps the two
- * backends describing the same thing.
- * @ignore
- */
-export declare const INSTANCE_SLOT_OFFSETS: {
-    readonly rows: readonly [0, 1, 2];
-    readonly color: 3;
-    readonly data: 4;
-};
-/**
- * Backend-neutral attribute descriptors for an instance record, in the
- * `{name, format, offset}` vocabulary both backends consume.
- * @param layout - the record layout
- * @param baseLocation - first shader location for this record (the location
- * after the tier's geometry attributes). Omit on WebGL, whose attribute
- * locations come from the shader's own declaration order.
- * @returns attribute descriptors covering the whole record
- * @ignore
- */
-export declare function instanceAttributes(layout: InstanceRecordLayout, baseLocation?: number): {
-    name: string;
-    format: string;
-    offset: number;
-    shaderLocation?: number;
-}[];
+export {};
 //# sourceMappingURL=instancerecord.d.ts.map

package/build/video/gpu/instancerecord.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"instancerecord.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/instancerecord.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;GAGG;AACH,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC;;;GAGG;AACH,eAAO,MAAM,WAAW,IAAI,CAAC;AAE7B;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACpC,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,yDAAyD;IACzD,WAAW,EAAE,MAAM,CAAC;IACpB,8DAA8D;IAC9D,UAAU,EAAE,MAAM,CAAC;IACnB,yCAAyC;IACzC,QAAQ,EAAE,OAAO,CAAC;IAClB,8CAA8C;IAC9C,OAAO,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,OAAO,GACd,oBAAoB,CAkBtB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACrC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,QAAQ,GACd,IAAI,CAiBN;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,EACd,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,GACR,IAAI,CA8BN;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACrC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,GACZ,IAAI,CAaN;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACpC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,QAAQ,GACX,QAAQ,CAoBV;AAED;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC;AAEX;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB;;;;CAIxB,CAAC;AAEX;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CACjC,MAAM,EAAE,oBAAoB,EAC5B,YAAY,CAAC,EAAE,MAAM;UASd,MAAM;YACJ,MAAM;YACN,MAAM;qBACG,MAAM;IAsCxB"}
+{"version":3,"file":"instancerecord.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/instancerecord.ts"],"names":[],"mappings":""}

package/build/video/gpu/meshchunk.d.ts

@@ -1,49 +1,2 @@
-/**
- * The versioned-remap vertex dedup shared by the mesh batchers of both
- * backends — pure CPU code, no GPU references (the `lighting/` modules set
- * the precedent for cross-backend sharing).
- *
- * The accumulated mesh path re-indexes each chunk's triangles against a
- * chunk-local vertex range. Dedup uses a "versioned" typed-array remap
- * rather than a `Map`: a `Map` here churned the GC badly, because V8's
- * `Map.clear()` drops the backing table, so re-filling it each chunk
- * reallocated as it grew — and the cost scaled with vertex count (a dense
- * mesh = MBs/sec of garbage). Instead, `remapSlot[orig]` holds the local
- * index assigned to original-vertex `orig` THIS chunk, valid only when
- * `remapStamp[orig] === stamp`. Bumping `stamp` per chunk invalidates every
- * entry in O(1) — no clearing, no allocation. The arrays grow lazily (to a
- * power of two ≥ the largest mesh's vertex count) and are reused.
- *
- * Module-level sharing is safe because a chunk is built synchronously and
- * never re-enters — only one `addMesh` runs at a time, whichever backend
- * (or coexisting renderer) drives it, and no remap state persists across
- * chunks.
- * @ignore
- */
-/**
- * Ensure the versioned-remap scratch arrays can index every vertex of a
- * mesh with `vertexCount` vertices. Grows to the next power of two and
- * reuses thereafter (one-time cost when a larger mesh first appears).
- * @ignore
- */
-export declare function ensureRemapCapacity(vertexCount: number): void;
-/**
- * Start a new chunk: invalidate the whole remap in O(1) and hand back the
- * shared (emptied) chunk-index list. The stamp resets before int32 overflow
- * (~weeks of continuous rendering away), keeping stored stamps valid.
- * @returns the shared chunk-index array, emptied
- * @ignore
- */
-export declare function beginChunk(): number[];
-/**
- * The local index assigned to `origIdx` this chunk, or -1 when the vertex
- * has not been emitted yet.
- * @ignore
- */
-export declare function remapIndex(origIdx: number): number;
-/**
- * Record the local index assigned to `origIdx` for the rest of this chunk.
- * @ignore
- */
-export declare function assignIndex(origIdx: number, localIdx: number): void;
+
 //# sourceMappingURL=meshchunk.d.ts.map

package/build/video/gpu/meshchunk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"meshchunk.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/meshchunk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAOH;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAQ7D;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,IAAI,MAAM,EAAE,CAQrC;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAGnE"}
+{"version":3,"file":"meshchunk.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/meshchunk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG"}

package/build/video/gpu/meshvertex.d.ts

@@ -1,54 +1,2 @@
-/**
- * Retained mesh vertex-data assembly shared by the mesh batchers of both
- * backends — pure CPU code, no GPU references (the `meshchunk.ts` /
- * `lighting/` precedent). Kept in ONE place because the two layouts exist
- * in an unlit and a lit variant on each backend, and the subtle parts —
- * the ARGB unpack order and the lit path's zero-length-normal guard —
- * must never drift between the four call sites.
- *
- * The data deliberately carries no placement, camera or tint information —
- * those are uniforms — so it stays valid for the lifetime of the geometry.
- * @ignore
- */
-/** the minimal mesh surface this module reads — `@ignore` */
-interface RetainedMeshSource {
-    originalVertices: Float32Array;
-    originalNormals?: Float32Array | null;
-    uvs: Float32Array;
-    vertexColors?: Uint32Array | null;
-    vertexCount: number;
-}
-/**
- * a reusable Float32Array of at least `floatCount` floats
- * @ignore
- */
-export declare function retainedScratch(floatCount: number): Float32Array;
-/**
- * Write one mesh's model-space geometry into `out` in the unlit mesh
- * layout — `x, y, z, u, v, r, g, b, a` — striding by `vertexSize`.
- * @param mesh - the mesh to read geometry from
- * @param out - destination scratch, at least `vertexCount × vertexSize` long
- * @param vertexSize - floats per vertex in the hosting batcher's layout
- * @returns number of floats written
- * @ignore
- */
-export declare function buildMeshVertexData(mesh: RetainedMeshSource, out: Float32Array, vertexSize: number): number;
-/**
- * The lit variant: the unlit layout plus the model-space normal —
- * `…, nx, ny, nz` — so lighting can be evaluated after the shader rotates
- * it into world space.
- *
- * A zero-length normal must not reach the shader: it does
- * `normalize(vNormal)`, and normalizing a zero vector is NaN — every
- * fragment touching that vertex goes black or garbage. Degenerate
- * triangles in OBJ/glTF assets produce these, so substitute a unit
- * vector, matching what the CPU projection path does.
- * @param mesh - the mesh to read geometry from
- * @param out - destination scratch, at least `vertexCount × vertexSize` long
- * @param vertexSize - floats per vertex in the hosting batcher's layout
- * @returns number of floats written
- * @ignore
- */
-export declare function buildLitMeshVertexData(mesh: RetainedMeshSource, out: Float32Array, vertexSize: number): number;
-export {};
+
 //# sourceMappingURL=meshvertex.d.ts.map

package/build/video/gpu/meshvertex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"meshvertex.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/meshvertex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,6DAA6D;AAC7D,UAAU,kBAAkB;IAC3B,gBAAgB,EAAE,YAAY,CAAC;IAC/B,eAAe,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACtC,GAAG,EAAE,YAAY,CAAC;IAClB,YAAY,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;CACpB;AASD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY,CAKhE;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAClC,IAAI,EAAE,kBAAkB,EACxB,GAAG,EAAE,YAAY,EACjB,UAAU,EAAE,MAAM,GAChB,MAAM,CAsBR;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,kBAAkB,EACxB,GAAG,EAAE,YAAY,EACjB,UAAU,EAAE,MAAM,GAChB,MAAM,CAmCR"}
+{"version":3,"file":"meshvertex.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/meshvertex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG"}

package/build/video/gpu/primitives.d.ts

@@ -1,60 +1,2 @@
-/**
- * Primitive-batcher geometry assembly shared by both backends — pure CPU
- * code, no GPU references (the `meshchunk.ts` / `meshvertex.ts`
- * precedent). The vertex layout is the primitive tier's 6-float
- * `x, y, z, nx, ny, packed-color` stream on both backends.
- * @ignore
- */
-/** the minimal vertex-buffer surface this module writes — `@ignore` */
-interface PrimitiveVertexData {
-    push(x: number, y: number, z: number, nx: number, ny: number, color: number): void;
-    isFull(count: number): boolean;
-}
-/** a 4×4 column-major transform (Matrix3d-shaped) — `@ignore` */
-interface MatrixLike {
-    val: Float32Array;
-    isIdentity(): boolean;
-}
-interface PointLike {
-    x: number;
-    y: number;
-}
-/**
- * Push `verts[start..end)` into the vertex buffer, transformed by the
- * given view matrix. The caller guarantees the range fits.
- *
- * The transform includes the z column (m[8] / m[9] / m[10] / m[14]) so
- * Camera3d's view matrix (X/Y-axis rotation) actually rotates the
- * primitive in 3D. For 2D matrices those slots are identity, so output
- * (x, y, z) is bit-identical to the legacy 2D-only multiply.
- * @ignore
- */
-export declare function pushPrimitiveRange(vertexData: PrimitiveVertexData, viewMatrix: MatrixLike, verts: PointLike[], start: number, end: number, colorUint32: number, z: number): void;
-/**
- * Expand line pairs into triangles with perpendicular normals. The vertex
- * shader offsets each vertex by `aNormal * uLineWidth * 0.5`, producing
- * thick lines without manual geometry expansion in the renderer. The
- * caller has already switched its draw mode to triangles.
- *
- * Each line pair expands to 2 triangles (6 vertices) — capacity is
- * checked per pair through the `flush` callback, so a dashed/long
- * thick-line path larger than the whole buffer flushes mid-shape instead
- * of silently dropping the out-of-range writes (pairs are independent
- * quads, so a mid-shape flush is invisible).
- *
- * The view matrix is applied (z column included) without mutating the
- * inputs. Note: the perpendicular normal is computed in pre-projection
- * world space, which appears non-perpendicular under perspective — a
- * known limitation shared by both backends.
- * @param vertexData - destination vertex stream
- * @param viewMatrix - the current view matrix
- * @param verts - line vertices in pairs [from, to, from, to, ...]
- * @param vertexCount - number of vertices to consume
- * @param colorUint32 - packed line color
- * @param z - the current renderer depth
- * @param flush - drains the vertex buffer when a pair no longer fits
- * @ignore
- */
-export declare function expandLinesToTriangles(vertexData: PrimitiveVertexData, viewMatrix: MatrixLike, verts: PointLike[], vertexCount: number, colorUint32: number, z: number, flush: () => void): void;
-export {};
+
 //# sourceMappingURL=primitives.d.ts.map

package/build/video/gpu/primitives.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/primitives.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,uEAAuE;AACvE,UAAU,mBAAmB;IAC5B,IAAI,CACH,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,EAAE,EAAE,MAAM,EACV,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,GACX,IAAI,CAAC;IACR,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;CAC/B;AAED,iEAAiE;AACjE,UAAU,UAAU;IACnB,GAAG,EAAE,YAAY,CAAC;IAClB,UAAU,IAAI,OAAO,CAAC;CACtB;AAED,UAAU,SAAS;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CACjC,UAAU,EAAE,mBAAmB,EAC/B,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,SAAS,EAAE,EAClB,KAAK,EAAE,MAAM,EACb,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,EACnB,CAAC,EAAE,MAAM,GACP,IAAI,CAsBN;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,sBAAsB,CACrC,UAAU,EAAE,mBAAmB,EAC/B,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,SAAS,EAAE,EAClB,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,CAAC,EAAE,MAAM,EACT,KAAK,EAAE,MAAM,IAAI,GACf,IAAI,CAuDN"}
+{"version":3,"file":"primitives.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/primitives.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG"}

package/build/video/gpu/quadcorners.d.ts

@@ -1,11 +1,2 @@
-import type { Matrix3d } from "../../math/matrix3d.ts";
-import { Vector3d } from "../../math/vector3d.ts";
-/**
- * Set the four corners of an axis-aligned quad and transform them by `m`
- * (skipped when `m` is null/identity — the common untransformed case).
- * Returns the shared corner pool, valid until the next call:
- * `[topLeft, topRight, bottomLeft, bottomRight]`.
- * @ignore
- */
-export declare function transformQuadCorners(m: Matrix3d | null | undefined, x: number, y: number, w: number, h: number, z: number): Vector3d[];
+export {};
 //# sourceMappingURL=quadcorners.d.ts.map

package/build/video/gpu/quadcorners.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quadcorners.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/quadcorners.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAyBlD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CACnC,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,SAAS,EAC9B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACP,QAAQ,EAAE,CAYZ"}
+{"version":3,"file":"quadcorners.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/quadcorners.ts"],"names":[],"mappings":""}

package/build/video/gpu/textureslots.d.ts

@@ -1,122 +1,2 @@
-/**
- * Backend-neutral texture slot assignment.
- *
- * Both GPU backends solve the same problem — "many textures, one draw call" —
- * by giving each texture a small integer slot that the fragment shader selects
- * on per-vertex. Only the *resource* differs: a WebGL texture unit, or an entry
- * in a WebGPU material bind group. The assignment policy (who gets a slot, what
- * happens when they run out, what is dropped) is identical, and used to be
- * written twice — `TextureCache.allocateTextureUnit` on one side,
- * `WebGPUQuadBatcher.segmentSlotFor` on the other — which is how the two drifted.
- *
- * This class owns that policy and nothing else. It never touches a GL unit or a
- * bind group; the caller supplies the binding through the callbacks. That keeps
- * it pure, so the same test suite proves both backends behave alike.
- * @ignore
- */
-export class TextureSlotTable {
-    /**
-     * @param {object} options - table configuration
-     * @param {number} options.capacity - number of slots, `[0, capacity)`
-     * @param {Function} [options.onOverflow] - called when a new key arrives with
-     * no slot free. The caller must turn the pending work into GPU work (flush)
-     * before the table reassigns slots out from under it.
-     * @param {Function} [options.onEvict] - called with each slot index as it is
-     * dropped, so the caller can forget its binding for that slot
-     * @param {Function} [options.isReserved] - optional predicate; a slot it
-     * approves is held out of assignment entirely (WebGL parks `ShaderEffect`
-     * extra samplers on high units this way). Reservations survive a reset.
-     * @ignore
-     */
-    constructor({ capacity, onOverflow, onEvict, isReserved }?: {
-        capacity: number;
-        onOverflow?: Function | undefined;
-        onEvict?: Function | undefined;
-        isReserved?: Function | undefined;
-    });
-    /** @type {Map<string, number>} key → slot */
-    slots: Map<string, number>;
-    /** @type {Set<number>} occupied slot indices */
-    used: Set<number>;
-    capacity: number;
-    onOverflow: Function | undefined;
-    onEvict: Function | undefined;
-    isReserved: Function | undefined;
-    /**
-     * How many slots are currently taken.
-     *
-     * Occupancy, NOT the key map: slots claimed through {@link claim} carry no
-     * key at all (the WebGL cache allocates that way), so counting keys would
-     * report an empty table while every unit was in use.
-     * @returns {number} the number of occupied slots
-     * @ignore
-     */
-    get size(): number;
-    /**
-     * Resize the table. Shrinking evicts every assignment at or above the new
-     * capacity; growing keeps everything. Called on context restore / device
-     * change, where the resolved limit can differ from the previous one.
-     * @param {number} capacity - the new slot count
-     * @ignore
-     */
-    setCapacity(capacity: number): void;
-    /**
-     * The slot this key already holds, without assigning one. Use when a miss
-     * should not trigger an overflow (probing, debug, bookkeeping).
-     * @param {string} key - the slot key
-     * @returns {number|undefined} the assigned slot, or `undefined`
-     * @ignore
-     */
-    peek(key: string): number | undefined;
-    /**
-     * The lowest assignable slot, or `-1` when every one is taken or reserved.
-     * Bounded by `capacity` on purpose: a caller that reserves every slot must
-     * get an answer rather than an infinite scan.
-     * @returns {number} a free slot index, or -1
-     * @ignore
-     */
-    freeSlot(): number;
-    /**
-     * Resolve a key to its slot, assigning one if needed.
-     *
-     * On exhaustion this calls `onOverflow` (the caller flushes) and then drops
-     * every assignment, so the incoming key starts a fresh set — the behaviour
-     * both backends already had. The eviction step is deliberately the only
-     * policy here: replacing this wipe with something finer (see #1586) changes
-     * both backends at once, which is the point of sharing it.
-     * @param {string} key - identifies the texture *and* the sampling state it
-     * needs, since two draws of one image under different filter/wrap settings
-     * cannot share a slot
-     * @returns {number} the slot to write into the vertex stream
-     * @ignore
-     */
-    slotFor(key: string): number;
-    /**
-     * Take a slot without associating a key with it.
-     *
-     * The WebGL cache resolves textures to units through its own source-keyed
-     * index (a source can hold one unit per wrap mode it was sampled with), so
-     * it needs the *policy* — free-slot search honoring reservations, and the
-     * flush-then-evict behaviour on exhaustion — without the key map. WebGPU's
-     * batcher keys directly and goes through {@link slotFor}, which is this plus
-     * the mapping. Both therefore overflow on the same rule.
-     * @returns {number} the claimed slot
-     * @ignore
-     */
-    claim(): number;
-    /**
-     * Drop a single assignment, freeing its slot. Reservations are untouched —
-     * they are owned by whoever reserved them, not by the table.
-     * @param {string} key - the slot key to release
-     * @returns {boolean} whether the key held a slot
-     * @ignore
-     */
-    release(key: string): boolean;
-    /**
-     * Drop every assignment. `onEvict` fires once per slot that was live, so a
-     * caller tracking bindings per slot can forget exactly those.
-     * @ignore
-     */
-    reset(): void;
-}
+
 //# sourceMappingURL=textureslots.d.ts.map

package/build/video/gpu/textureslots.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"textureslots.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/textureslots.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;;;;;;;;;OAYG;IACH,4DAXG;QAAwB,QAAQ,EAAxB,MAAM;QACa,UAAU;QAGV,OAAO;QAEP,UAAU;KAGrC,EAWF;IARA,6CAA6C;IAC7C,OADW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CACR;IACtB,gDAAgD;IAChD,MADW,GAAG,CAAC,MAAM,CAAC,CACD;IACrB,iBAA6B;IAC7B,iCAA4B;IAC5B,8BAAsB;IACtB,iCAA4B;IAG7B;;;;;;;;OAQG;IACH,YAHa,MAAM,CAKlB;IAED;;;;;;OAMG;IACH,sBAHW,MAAM,QAoBhB;IAED;;;;;;OAMG;IACH,UAJW,MAAM,GACJ,MAAM,GAAC,SAAS,CAK5B;IAED;;;;;;OAMG;IACH,YAHa,MAAM,CAUlB;IAED;;;;;;;;;;;;;OAaG;IACH,aANW,MAAM,GAGJ,MAAM,CAWlB;IAED;;;;;;;;;;;OAWG;IACH,SAHa,MAAM,CAsBlB;IAED;;;;;;OAMG;IACH,aAJW,MAAM,GACJ,OAAO,CAYnB;IAED;;;;OAIG;IACH,cAQC;CACD"}
+{"version":3,"file":"textureslots.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/textureslots.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;;;;;;;;;;;OAaG;IACH,4DAZG;QAAwB,QAAQ,EAAxB,MAAM;QACa,UAAU;QAGV,OAAO;QAEP,UAAU;KAGrC,EAYF;IARA,6CAA6C;IAC7C,OADW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CACR;IACtB,gDAAgD;IAChD,MADW,GAAG,CAAC,MAAM,CAAC,CACD;IACrB,iBAA6B;IAC7B,iCAA4B;IAC5B,8BAAsB;IACtB,iCAA4B;IAG7B;;;;;;;;;OASG;IACH,YAJa,MAAM,CAMlB;IAED;;;;;;;OAOG;IACH,sBAJW,MAAM,QAqBhB;IAED;;;;;;;OAOG;IACH,UALW,MAAM,GACJ,MAAM,GAAC,SAAS,CAM5B;IAED;;;;;;;OAOG;IACH,YAJa,MAAM,CAWlB;IAED;;;;;;;;;;;;;;OAcG;IACH,aAPW,MAAM,GAGJ,MAAM,CAYlB;IAED;;;;;;;;;;;;OAYG;IACH,SAJa,MAAM,CAuBlB;IAED;;;;;;;OAOG;IACH,aALW,MAAM,GACJ,OAAO,CAanB;IAED;;;;;OAKG;IACH,cAQC;CACD"}

package/build/video/gpu/texturestore.d.ts

@@ -1,139 +1,2 @@
-/**
- * Backend-neutral texture residency.
- *
- * There are two separate questions about a texture, and conflating them is
- * what makes a GPU renderer re-upload work it already has:
- *
- * - **which slot is it in, for this draw?** — transient, per-batch, bounded by
- *   the shader's sampler count. That is {@link TextureSlotTable}.
- * - **does it exist on the GPU, and is its content current?** — persistent,
- *   per-source, bounded by disposal. That is this class.
- *
- * The WebGL backend used to answer both with one field (`boundTextures[unit]`),
- * so dropping a slot assignment destroyed the texture handle and the next draw
- * rebuilt it from scratch — a full re-upload and mip regeneration per quad,
- * once past the batching limit.
- *
- * This class owns the source → record index, the reuse-or-upload decision, and
- * the lifetime bookkeeping. It touches no GL or WebGPU API: each backend
- * supplies `onCreate` / `onUpload` / `onDestroy`, exactly as the slot table
- * takes its binding through callbacks. That keeps the decision logic identical
- * on both backends and testable without a device.
- * @ignore
- */
-export class TextureStore {
-    /**
-     * @param {object} [options] - store configuration
-     * @param {Function} [options.onCreate] - `(source, options) => handle`, allocate
-     * the backing GPU texture for a source seen for the first time
-     * @param {Function} [options.onUpload] - `(handle, source, record, options) => handle`,
-     * push the source's current content. May return a *replacement* handle when
-     * the shape changed and the old one cannot be respecified (immutable
-     * storage); returning nothing keeps the existing handle.
-     * @param {Function} [options.onDestroy] - `(handle, source)`, release the
-     * GPU texture. Called exactly once per handle.
-     * @ignore
-     */
-    constructor({ onCreate, onUpload, onDestroy }?: {
-        onCreate?: Function | undefined;
-        onUpload?: Function | undefined;
-        onDestroy?: Function | undefined;
-    });
-    /** @type {Map<object, {handle: *, version: number, generation: number}>} */
-    records: Map<object, {
-        handle: any;
-        version: number;
-        generation: number;
-    }>;
-    /**
-     * Allocate the backing GPU texture for a source seen for the first time.
-     * @param {object} source - the image/canvas/resource
-     * @param {object} options - the resolve options
-     * @returns {*} the new handle
-     * @ignore
-     */
-    onCreate(source: object, options: object): any;
-    /**
-     * Push the source's current content. May return a REPLACEMENT handle when
-     * the shape changed and the old one cannot be respecified.
-     * @param {*} handle - the existing handle
-     * @param {object} source - the image/canvas/resource
-     * @param {object} record - the resident record
-     * @param {object} options - the resolve options
-     * @returns {*} a replacement handle, or nothing to keep the existing one
-     * @ignore
-     */
-    onUpload(handle: any, source: object, record: object, options: object): any;
-    /**
-     * Release a GPU texture. Called exactly once per handle.
-     * @param {*} handle - the handle to release
-     * @param {object} source - the source it belonged to
-     * @ignore
-     */
-    onDestroy(handle: any, source: object): void;
-    generation: number;
-    /**
-     * how many sources are currently resident
-     * @returns {number} the record count
-     * @ignore
-     */
-    get size(): number;
-    /**
-     * The live record for a source, uploading only when it is genuinely needed:
-     * the source has never been seen, its content changed, its handle predates
-     * the current context, or the caller forced it.
-     *
-     * A texture that merely moved to a different slot is NOT a reason to upload
-     * — that is the whole point of separating residency from slot assignment.
-     * @param {object} source - the image/canvas/resource backing the texture
-     * @param {object} [options] - resolution options
-     * @param {number} [options.version=0] - the source's content revision; a
-     * change from the recorded value forces a re-upload
-     * @param {boolean} [options.force=false] - re-upload regardless
-     * @returns {{handle: *, version: number, generation: number, uploaded: boolean}}
-     * the record, with `uploaded` reporting whether this call did GPU work
-     * @ignore
-     */
-    getResidentRecord(source: object, options?: {
-        version?: number | undefined;
-        force?: boolean | undefined;
-    }): {
-        handle: any;
-        version: number;
-        generation: number;
-        uploaded: boolean;
-    };
-    /**
-     * The record for a source without resolving one, for callers that must not
-     * trigger GPU work (bookkeeping, debug, invalidation checks).
-     * @param {object} source - the source to look up
-     * @returns {object|undefined} the record, or `undefined`
-     * @ignore
-     */
-    peek(source: object): object | undefined;
-    /**
-     * Release the GPU texture for one source. Driven by the source going away
-     * — never by a slot being reassigned, which is exactly the coupling this
-     * class exists to break.
-     * @param {object} source - the disposed source
-     * @returns {boolean} whether a record was held
-     * @ignore
-     */
-    destroyTexture(source: object): boolean;
-    /**
-     * Drop every record and bump the generation. Called on context or device
-     * loss.
-     *
-     * This CLEARS the store in place — callers must never respond to a restore
-     * by constructing a replacement store. Doing so orphans every handle the
-     * old one was tracking, so the *second* loss leaks everything it had
-     * accumulated since the first. Both WebGL batchers re-run `init()` on
-     * restore, which is precisely how that mistake gets made here.
-     * @param {boolean} [destroy=false] - whether to release the handles first.
-     * Leave `false` for a lost context (the GPU objects are already gone);
-     * pass `true` for an orderly teardown.
-     * @ignore
-     */
-    releaseAll(destroy?: boolean): void;
-}
+
 //# sourceMappingURL=texturestore.d.ts.map

package/build/video/gpu/texturestore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texturestore.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/texturestore.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IACC;;;;;;;;;;;OAWG;IACH,gDAVG;QAA2B,QAAQ;QAER,QAAQ;QAIR,SAAS;KAEpC,EAuBF;IApBA,4EAA4E;IAC5E,SADW,GAAG,CAAC,MAAM,EAAE;QAAC,MAAM,EAAE,GAAC,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAAC,CAChD;IAqBzB;;;;;;OAMG;IACH,iBALW,MAAM,WACN,MAAM,GACJ,GAAC,CAOb;IAED;;;;;;;;;OASG;IACH,iBAPW,GAAC,UACD,MAAM,UACN,MAAM,WACN,MAAM,GACJ,GAAC,CASb;IAED;;;;;OAKG;IACH,kBAJW,GAAC,UACD,MAAM,QAMhB;IA3CA,mBAAmB;IA6CpB;;;;OAIG;IACH,YAHa,MAAM,CAKlB;IAED;;;;;;;;;;;;;;;OAeG;IACH,0BATW,MAAM,YAEd;QAAyB,OAAO;QAEN,KAAK;KAC/B,GAAU;QAAC,MAAM,EAAE,GAAC,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAC,CAqC/E;IAED;;;;;;OAMG;IACH,aAJW,MAAM,GACJ,MAAM,GAAC,SAAS,CAK5B;IAED;;;;;;;OAOG;IACH,uBAJW,MAAM,GACJ,OAAO,CAanB;IAED;;;;;;;;;;;;;OAaG;IACH,qBALW,OAAO,QAejB;CACD"}
+{"version":3,"file":"texturestore.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/texturestore.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACC;;;;;;;;;;;;OAYG;IACH,gDAXG;QAA2B,QAAQ;QAER,QAAQ;QAIR,SAAS;KAEpC,EAwBF;IApBA,4EAA4E;IAC5E,SADW,GAAG,CAAC,MAAM,EAAE;QAAC,MAAM,EAAE,GAAC,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAAC,CAChD;IAqBzB;;;;;;;OAOG;IACH,iBANW,MAAM,WACN,MAAM,GACJ,GAAC,CAQb;IAED;;;;;;;;;;OAUG;IACH,iBARW,GAAC,UACD,MAAM,UACN,MAAM,WACN,MAAM,GACJ,GAAC,CAUb;IAED;;;;;;OAMG;IACH,kBALW,GAAC,UACD,MAAM,QAOhB;IA9CA,mBAAmB;IAgDpB;;;;;OAKG;IACH,YAJa,MAAM,CAMlB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,0BAVW,MAAM,YAEd;QAAyB,OAAO;QAEN,KAAK;KAC/B,GAAU;QAAC,MAAM,EAAE,GAAC,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAC,CAsC/E;IAED;;;;;;;OAOG;IACH,aALW,MAAM,GACJ,MAAM,GAAC,SAAS,CAM5B;IAED;;;;;;;;OAQG;IACH,uBALW,MAAM,GACJ,OAAO,CAcnB;IAED;;;;;;;;;;;;;;OAcG;IACH,qBANW,OAAO,QAgBjB;CACD"}

package/build/video/gpu/topology.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"topology.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/topology.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,MAAM,QAAQ,GACjB,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,WAAW,GACX,eAAe,GACf,gBAAgB,GAChB,cAAc,CAAC;AAElB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,uFAMQ,CAAC;AAgBzC;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAE9D"}
+{"version":3,"file":"topology.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/topology.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,MAAM,QAAQ,GACjB,YAAY,GACZ,WAAW,GACX,YAAY,GACZ,WAAW,GACX,eAAe,GACf,gBAAgB,GAChB,cAAc,CAAC;AAElB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,uFAMQ,CAAC;AAiBzC;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAE9D"}