@woosh/meep-engine 3.61.1 → 3.61.3

package/src/shade/renderer/water/chunk_water_gi.d.ts

@@ -12,7 +12,7 @@ export const chunk_water_gi_ibl: CodeChunk;
 export const chunk_water_gi_brick4: CodeChunk;
 /**
  * The probe clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.5): each call one pick at the point, jittered by a
- * hash of the point and the normal, as Brick4's is. The irradiance is π × the picked SH resolved at the normal,
+ * hash of the point and the normal, as Brick4's is. The irradiance is the picked SH resolved at the normal,
  * the normal standing in for the view, which the irradiance call has none of. The specular is the probes'
  * radiance picked by the normal and the view (§9.3). Where no probe weighs anything, each is the environment's.
  * Reads the probes' group, `view` and `tEnvironment`.

package/src/shade/renderer/water/chunk_water_gi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_gi.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_gi.js"],"names":[],"mappings":"AAiCA;;;;GAIG;AACH,iCAFU,SAAS,CAUoC;AAEvD;;;;GAIG;AACH,oCAFU,SAAS,CAgBwB;AAE3C;;;;;;;GAOG;AACH,2CAFU,SAAS,CAwB+E;AAElG;;;;;;GAMG;AACH,6BAFU,eAAe,CAE6C;0BA5F5C,iCAAiC;gCAC3B,uCAAuC"}
+{"version":3,"file":"chunk_water_gi.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_gi.js"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,iCAFU,SAAS,CAUoC;AAEvD;;;;GAIG;AACH,oCAFU,SAAS,CAgBwB;AAE3C;;;;;;;GAOG;AACH,2CAFU,SAAS,CAuB+D;AAElF;;;;;;GAMG;AACH,6BAFU,eAAe,CAE6C;0BA3F5C,iCAAiC;gCAC3B,uCAAuC"}

package/src/shade/renderer/water/chunk_water_gi.js

@@ -9,11 +9,10 @@ import {
 } from "../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js";
 import { INDIRECT_LIGHTING } from "../INDIRECT_LIGHTING.js";
 import { ShadeIndirectLightingMode } from "../ShadeIndirectLightingMode.js";
-import { PI_DECLARATION } from "../shader/chunk/math/PI_DECLARATION.js";
 import { chunk_jitter_from_vectors } from "../shader/chunk/random/chunk_jitter_from_vectors.js";
 import {
-    chunk_resolve_irradiance_sh_to_diffuse
-} from "../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_diffuse.js";
+    chunk_sh3_color_get_irradiance_at
+} from "../shader/chunk/spherical_harmonics/chunk_sh3_color_get_irradiance_at.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
 
@@ -69,7 +68,7 @@ fn water_gi_specular(position: vec3<f32>, normal: vec3<f32>, view_direction: vec
 
 /**
  * The probe clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.5): each call one pick at the point, jittered by a
- * hash of the point and the normal, as Brick4's is. The irradiance is π × the picked SH resolved at the normal,
+ * hash of the point and the normal, as Brick4's is. The irradiance is the picked SH resolved at the normal,
  * the normal standing in for the view, which the irradiance call has none of. The specular is the probes'
  * radiance picked by the normal and the view (§9.3). Where no probe weighs anything, each is the environment's.
  * Reads the probes' group, `view` and `tEnvironment`.
@@ -80,8 +79,7 @@ fn water_gi_irradiance(position: vec3<f32>, normal: vec3<f32>) -> vec3<f32> {
     let probes = probe_clipmap_sample_sh(position, normal, normal, jitter_from_vectors(position, normal));
 
     if (probes.found) {
-        // the resolve gives E/π
-        return PI * resolve_irradiance_sh_to_diffuse(probes.sh.Y, probes.sh.CoCg, normal);
+        return sh3_color_get_irradiance_at(normal, probes.sh);
     }
 
     return get_ibl_irradiance(normal);
@@ -96,8 +94,8 @@ fn water_gi_specular(position: vec3<f32>, normal: vec3<f32>, view_direction: vec
 
     return get_ibl_radiance(view_direction, normal, roughness);
 }
-`, [chunk_probe_clipmap_pick, chunk_probe_clipmap_sample_radiance, chunk_resolve_irradiance_sh_to_diffuse,
-    chunk_jitter_from_vectors, PI_DECLARATION, chunk_get_ibl_irradiance, chunk_get_ibl_radiance]);
+`, [chunk_probe_clipmap_pick, chunk_probe_clipmap_sample_radiance, chunk_sh3_color_get_irradiance_at,
+    chunk_jitter_from_vectors, chunk_get_ibl_irradiance, chunk_get_ibl_radiance]);
 
 /**
  * The water's indirect lighting by the renderer's mode ({@link INDIRECT_LIGHTING}): IBL and LPV

package/src/shade/renderer/water/query/GPUWaterQueries.d.ts

@@ -24,7 +24,7 @@ export class GPUWaterQueries {
      * @param {PipelineEnquiry} enquiry
      */
     static enquirePipelines(enquiry: PipelineEnquiry): void;
-    static "__#279@#execute"(pass: any, resources: any, context: any): void;
+    static "__#281@#execute"(pass: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/wind/GPUSceneWind.d.ts

@@ -42,7 +42,7 @@ export class GPUSceneWind {
      * @param {number} capacity
      * @returns {GPUTileAtlas3D}
      */
-    static "__#169@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
+    static "__#174@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
     /**
      * @param {GPUDevice} device
      */

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAs3DA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAk6DA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}

package/src/shade/wgsl/emulator/WGSLLanguageCore.js

@@ -99,11 +99,26 @@ const BITCAST_F16 = new Float16Array(BITCAST_BUFFER);
  * @returns {*}
  */
 function makeVec(TypedArrayCtor, size, args) {
-    if (args.length === 0) {
+    const n = args.length;
+    if (n === 0) {
         return new TypedArrayCtor(size);
     }
+    if (n === size && typeof args[0] === 'number') {
+        let all_num = true;
+        for (let k = 1; k < n; k++) {
+            if (typeof args[k] !== 'number') {
+                all_num = false;
+                break;
+            }
+        }
+        if (all_num) {
+            const out = new TypedArrayCtor(size);
+            for (let k = 0; k < size; k++) out[k] = args[k];
+            return out;
+        }
+    }
     // Single scalar → broadcast.
-    if (args.length === 1 && typeof args[0] === 'number') {
+    if (n === 1 && typeof args[0] === 'number') {
         const v = args[0];
         const out = new TypedArrayCtor(size);
         for (let i = 0; i < size; i++) out[i] = v;
@@ -112,7 +127,8 @@ function makeVec(TypedArrayCtor, size, args) {
     // Otherwise flatten.
     const out = new TypedArrayCtor(size);
     let i = 0;
-    for (const a of args) {
+    for (let k = 0; k < n; k++) {
+        const a = args[k];
         if (typeof a === 'number' || typeof a === 'boolean') {
             out[i++] = +a;
         } else if (a != null && typeof a.length === 'number') {
@@ -213,7 +229,31 @@ function is_vec(v) {
  * @param {function(number, number): number} op
  * @returns {*}
  */
+const op_add = (x, y) => x + y;
+const op_sub = (x, y) => x - y;
+const op_mul = (x, y) => x * y;
+const op_div = (x, y) => x / y;
+const op_add_f32 = (x, y) => Math.fround(x + y);
+const op_sub_f32 = (x, y) => Math.fround(x - y);
+const op_mul_f32 = (x, y) => Math.fround(x * y);
+const op_div_f32 = (x, y) => Math.fround(x / y);
+const op_add_f16 = (x, y) => round_f16(x + y);
+const op_sub_f16 = (x, y) => round_f16(x - y);
+const op_mul_f16 = (x, y) => round_f16(x * y);
+const op_div_f16 = (x, y) => round_f16(x / y);
+const op_rem = (x, y) => x % y;
+const op_idiv = (x, y) => Math.trunc(x / y);
+const op_add_u32 = (x, y) => (x + y) >>> 0;
+const op_sub_u32 = (x, y) => (x - y) >>> 0;
+const op_mul_u32 = (x, y) => Math.imul(x, y) >>> 0;
+const op_add_i32 = (x, y) => (x + y) | 0;
+const op_sub_i32 = (x, y) => (x - y) | 0;
+const op_mul_i32 = (x, y) => Math.imul(x, y) | 0;
+
 function binop(a, b, op) {
+    if (typeof a === "number" && typeof b === "number") {
+        return op(a, b);
+    }
     const a_vec = is_vec(a);
     const b_vec = is_vec(b);
 
@@ -302,7 +342,7 @@ function round_ties_to_even(x) {
 }
 
 function unop(a, op) {
-    if (!is_vec(a)) {
+    if (typeof a === "number" || !is_vec(a)) {
         return op(a);
     }
     const out = new a.constructor(a.length);
@@ -321,15 +361,15 @@ function unop(a, op) {
  * @returns {*}
  */
 function ternop(a, b, c, op) {
-    if (is_vec(a) || is_vec(b) || is_vec(c)) {
-        const length = (is_vec(a) ? a.length : (is_vec(b) ? b.length : c.length));
-        const ctor = (is_vec(a) ? a.constructor : (is_vec(b) ? b.constructor : c.constructor));
-        const out = new ctor(length);
+    const a_vec = is_vec(a);
+    const b_vec = is_vec(b);
+    const c_vec = is_vec(c);
+    if (a_vec || b_vec || c_vec) {
+        const ref = a_vec ? a : (b_vec ? b : c);
+        const length = ref.length;
+        const out = new ref.constructor(length);
         for (let i = 0; i < length; i++) {
-            const ai = is_vec(a) ? a[i] : a;
-            const bi = is_vec(b) ? b[i] : b;
-            const ci = is_vec(c) ? c[i] : c;
-            out[i] = op(ai, bi, ci);
+            out[i] = op(a_vec ? a[i] : a, b_vec ? b[i] : b, c_vec ? c[i] : c);
         }
         return out;
     }
@@ -358,6 +398,10 @@ function ternop(a, b, c, op) {
  * @returns {*}
  */
 function copy_value(value) {
+    if (typeof value !== "object" || value === null) {
+        return value;
+    }
+
     if (ArrayBuffer.isView(value)) {
         return value.slice();
     }
@@ -606,10 +650,10 @@ export const WGSLLanguageCore = {
     // Arithmetic helpers (work on scalars and vectors element-wise)
     // ---------------------------------------------------------------------
 
-    add: (a, b) => binop(a, b, (x, y) => x + y),
-    sub: (a, b) => binop(a, b, (x, y) => x - y),
-    mul: (a, b) => binop(a, b, (x, y) => x * y),
-    div: (a, b) => binop(a, b, (x, y) => x / y),
+    add: (a, b) => typeof a === "number" && typeof b === "number" ? a + b : binop(a, b, op_add),
+    sub: (a, b) => typeof a === "number" && typeof b === "number" ? a - b : binop(a, b, op_sub),
+    mul: (a, b) => typeof a === "number" && typeof b === "number" ? a * b : binop(a, b, op_mul),
+    div: (a, b) => typeof a === "number" && typeof b === "number" ? a / b : binop(a, b, op_div),
 
     /*
      The same four at f32, for a SCALAR whose type the compiler knows is f32.
@@ -632,23 +676,23 @@ export const WGSLLanguageCore = {
      runtime. `Math.fround` of a vector is NaN, and binop is already idempotent here: a vec lane is
      rounded and then stored into the Float32Array that would have rounded it anyway.
     */
-    add_f32: (a, b) => binop(a, b, (x, y) => Math.fround(x + y)),
-    sub_f32: (a, b) => binop(a, b, (x, y) => Math.fround(x - y)),
-    mul_f32: (a, b) => binop(a, b, (x, y) => Math.fround(x * y)),
-    div_f32: (a, b) => binop(a, b, (x, y) => Math.fround(x / y)),
+    add_f32: (a, b) => typeof a === "number" && typeof b === "number" ? Math.fround(a + b) : binop(a, b, op_add_f32),
+    sub_f32: (a, b) => typeof a === "number" && typeof b === "number" ? Math.fround(a - b) : binop(a, b, op_sub_f32),
+    mul_f32: (a, b) => typeof a === "number" && typeof b === "number" ? Math.fround(a * b) : binop(a, b, op_mul_f32),
+    div_f32: (a, b) => typeof a === "number" && typeof b === "number" ? Math.fround(a / b) : binop(a, b, op_div_f32),
 
     // The same four at f16, for a SCALAR whose type the compiler knows is f16. Without these,
     // scalar f16 arithmetic ran in f64 (`16000.0h * 8.0h` evaluated to 128000 instead of +Infinity,
     // and `1e-3h * 1e-3h` evaluated to 1e-6 instead of underflowing in binary16).
-    add_f16: (a, b) => binop(a, b, (x, y) => round_f16(x + y)),
-    sub_f16: (a, b) => binop(a, b, (x, y) => round_f16(x - y)),
-    mul_f16: (a, b) => binop(a, b, (x, y) => round_f16(x * y)),
-    div_f16: (a, b) => binop(a, b, (x, y) => round_f16(x / y)),
-    rem: (a, b) => binop(a, b, (x, y) => x % y),
+    add_f16: (a, b) => typeof a === "number" && typeof b === "number" ? round_f16(a + b) : binop(a, b, op_add_f16),
+    sub_f16: (a, b) => typeof a === "number" && typeof b === "number" ? round_f16(a - b) : binop(a, b, op_sub_f16),
+    mul_f16: (a, b) => typeof a === "number" && typeof b === "number" ? round_f16(a * b) : binop(a, b, op_mul_f16),
+    div_f16: (a, b) => typeof a === "number" && typeof b === "number" ? round_f16(a / b) : binop(a, b, op_div_f16),
+    rem: (a, b) => typeof a === "number" && typeof b === "number" ? a % b : binop(a, b, op_rem),
 
     // Integer division — truncates toward zero, matching WGSL `/` semantics on integer types.
     // The compiler routes `/` through `idiv` when both operands' tracked types are integer.
-    idiv: (a, b) => binop(a, b, (x, y) => Math.trunc(x / y)),
+    idiv: (a, b) => typeof a === "number" && typeof b === "number" ? Math.trunc(a / b) : binop(a, b, op_idiv),
 
     // WGSL integer arithmetic wraps at 32 bits; JS numbers grow instead. Without wrapping, any
     // hash or PRNG that multiplies by a large odd constant leaves the u32 range within a step or
@@ -658,13 +702,13 @@ export const WGSLLanguageCore = {
     //
     // The compiler routes `+` / `-` / `*` here only when the result type is known to be an integer,
     // so float math never reaches these.
-    add_u32: (a, b) => binop(a, b, (x, y) => (x + y) >>> 0),
-    sub_u32: (a, b) => binop(a, b, (x, y) => (x - y) >>> 0),
-    mul_u32: (a, b) => binop(a, b, (x, y) => Math.imul(x, y) >>> 0),
+    add_u32: (a, b) => typeof a === "number" && typeof b === "number" ? (a + b) >>> 0 : binop(a, b, op_add_u32),
+    sub_u32: (a, b) => typeof a === "number" && typeof b === "number" ? (a - b) >>> 0 : binop(a, b, op_sub_u32),
+    mul_u32: (a, b) => typeof a === "number" && typeof b === "number" ? Math.imul(a, b) >>> 0 : binop(a, b, op_mul_u32),
 
-    add_i32: (a, b) => binop(a, b, (x, y) => (x + y) | 0),
-    sub_i32: (a, b) => binop(a, b, (x, y) => (x - y) | 0),
-    mul_i32: (a, b) => binop(a, b, (x, y) => Math.imul(x, y) | 0),
+    add_i32: (a, b) => typeof a === "number" && typeof b === "number" ? (a + b) | 0 : binop(a, b, op_add_i32),
+    sub_i32: (a, b) => typeof a === "number" && typeof b === "number" ? (a - b) | 0 : binop(a, b, op_sub_i32),
+    mul_i32: (a, b) => typeof a === "number" && typeof b === "number" ? Math.imul(a, b) | 0 : binop(a, b, op_mul_i32),
 
     // Element-wise bitwise / shift helpers. JS's raw `&` / `|` / `^` / `<<` / `>>` work on
     // scalars but not typed arrays (they coerce the array to a number → NaN), so the compiler

package/src/core/math/hash/squirrel3.d.ts

@@ -1,17 +0,0 @@
-/**
- * Based on Squirrel3 hash function by Squirrel Eiserloh
- *
- * NOTE: every step is wrapping u32 arithmetic, matching the WGSL twin `chunk_hash_squirrel3` bit
- * for bit. This used to multiply with plain `*`, which is a double multiply - `hash * 0x1B56C4E9`
- * exceeds 2^53 for any int32-sized hash, so the low bits the following `hash ^= hash >> 8` mixes
- * were rounded away before they were used. The result set bit 31 in exactly zero of 200,000
- * outputs, half the codomain unreachable, and disagreed with the GPU on every value. An in-file
- * comment used to blame the algorithm for the resulting low entropy; it was this port.
- *
- * @deprecated prefer {@link lowbias32}, as the WGSL chunk already says of its own twin
- * @see GDC 2017 presentation on "Math for Game Programmers: Noise-Based RNG"
- * @param {number} value expected to be an integer, if not - it will be truncated to such
- * @returns {number} unsigned 32-bit integer
- */
-export function squirrel3(value: number): number;
-//# sourceMappingURL=squirrel3.d.ts.map

package/src/core/math/hash/squirrel3.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"squirrel3.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/squirrel3.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,iCAHW,MAAM,GACJ,MAAM,CAYlB"}

package/src/core/math/hash/squirrel3.js

@@ -1,30 +0,0 @@
-const BIT_NOISE1 = 0xB5297A4D;
-const BIT_NOISE2 = 0x68E31DA4;
-const BIT_NOISE3 = 0x1B56C4E9;
-
-/**
- * Based on Squirrel3 hash function by Squirrel Eiserloh
- *
- * NOTE: every step is wrapping u32 arithmetic, matching the WGSL twin `chunk_hash_squirrel3` bit
- * for bit. This used to multiply with plain `*`, which is a double multiply - `hash * 0x1B56C4E9`
- * exceeds 2^53 for any int32-sized hash, so the low bits the following `hash ^= hash >> 8` mixes
- * were rounded away before they were used. The result set bit 31 in exactly zero of 200,000
- * outputs, half the codomain unreachable, and disagreed with the GPU on every value. An in-file
- * comment used to blame the algorithm for the resulting low entropy; it was this port.
- *
- * @deprecated prefer {@link lowbias32}, as the WGSL chunk already says of its own twin
- * @see GDC 2017 presentation on "Math for Game Programmers: Noise-Based RNG"
- * @param {number} value expected to be an integer, if not - it will be truncated to such
- * @returns {number} unsigned 32-bit integer
- */
-export function squirrel3(value) {
-    let hash = Math.imul(value, BIT_NOISE1);
-
-    hash ^= (hash >>> 8);
-    hash = (hash + BIT_NOISE2) | 0;
-    hash ^= (hash << 8);
-    hash = Math.imul(hash, BIT_NOISE3);
-    hash ^= (hash >>> 8);
-
-    return hash >>> 0;
-}

package/src/shade/renderer/geometry/sdf/cards/GPUMeshCardSets.d.ts

@@ -1,213 +0,0 @@
-/**
- * s_e: the largest component of a material's emissive factor, which the capture stores emissive
- * over. 0 for a material that emits nothing, or that has no emissive factor.
- *
- * @param {ShadeMaterial} material
- * @returns {number}
- */
-export function mesh_card_emissive_scale_of(material: ShadeMaterial): number;
-/**
- * Most pages a frame's capture may take: a workgroup a page, in one dispatch row.
- * @type {number}
- */
-export const MESH_CARD_CAPTURE_BUDGET_MAX: number;
-/**
- * Card sets (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.5): one (geometry, material) pair's capture of
- * its geometry's card layout, by card set id, the storage of which {@link GPUGeometrySDFManager}
- * keeps beside its fields and layouts.
- *
- * - A card set's pages are a run of tiles of the card atlas, one a page of the layout, in the
- *   layout's order, from page_base. The layout's column tables are the geometry's, shared by every
- *   card set of it, so a card set needs no page table of its own.
- * - The atlas is two `rgba8unorm` planes of 8×8 tiles ({@link GPUTileAtlas2D}): √(diffuse albedo)
- *   and depth; emissive / s_e and 0.
- * - Its record (`MESH_CARD_SET_STRUCT`) is written when a capture starts.
- *
- * **Lifetime.** {@link acquire} makes a card set for a pair and {@link release} gives it back; the
- * caller keeps one per pair. A card set of an aliased geometry ({@link alias}) is its source's: it
- * captures the source's layout through the source's meshlets. A card set waits until its geometry's layout is placed
- * ({@link set_layout}), is then captured, and turns resident ({@link onResident}) on the frame its
- * last page is recorded: the capture's writes come before any later pass reads it. A layout that
- * goes ({@link drop_layout}) withdraws its card sets ({@link onWithdrawn}) back to waiting.
- *
- * **Capture** ({@link graph_capture}, once a frame) takes at most `budget` pages, first captures in
- * the order they were asked for, then recaptures in the order queued. A card set's pages may span
- * frames. {@link recapture} queues a resident card set again, which reads its last capture until the
- * new one is done; a card set whose capture is under way starts it again.
- *
- * **Modes** ({@link capture_mode}). A traced card set is a run of pages, a thread a texel. A
- * rastered one is taken whole: its cards are drawn into a region of a scratch, a cell a card, and its
- * pages scattered from there into the atlas; the frame's last one may take the budget past its end.
- */
-export class GPUMeshCardSets {
-    /**
-     * @param {GPUDevice} device
-     */
-    constructor(device: GPUDevice);
-    /**
-     * Sent with a card set id when its first capture is recorded in full.
-     * @type {Signal<number>}
-     */
-    onResident: any;
-    /**
-     * Sent with a resident card set's id when its layout goes; it waits for the next.
-     * @type {Signal<number>}
-     */
-    onWithdrawn: any;
-    /**
-     * Card sets given out.
-     * @returns {number}
-     */
-    get count(): number;
-    /**
-     * @returns {number}
-     */
-    get resident_count(): number;
-    /**
-     * Recaptures asked of resident card sets, and of captures under way restarted.
-     * @returns {number}
-     */
-    get recaptures_requested(): number;
-    /**
-     * Pages the captures have recorded.
-     * @returns {number}
-     */
-    get pages_captured(): number;
-    /**
-     * Whether a frame's capture has anything to do: pages queued, or card sets turned resident with
-     * nothing to capture, still to be announced.
-     * @returns {boolean}
-     */
-    get has_pending_capture(): boolean;
-    /**
-     * Pages waiting for capture over every queue.
-     * @returns {number}
-     */
-    get pages_queued(): number;
-    /**
-     * A change captures every card set again in the new mode: resident ones read their last capture
-     * until it is done, and captures under way start again.
-     *
-     * @param {MeshCardCaptureMode} mode
-     */
-    set capture_mode(mode: number);
-    /**
-     * @returns {MeshCardCaptureMode}
-     */
-    get capture_mode(): number;
-    /**
-     * Whether readers may use the card set: captured at least once, and its layout still there.
-     *
-     * @param {number} id
-     * @returns {boolean}
-     */
-    is_resident(id: number): boolean;
-    /**
-     * The card set's geometry id.
-     *
-     * @param {number} id
-     * @returns {number}
-     */
-    geometry_of(id: number): number;
-    /**
-     * Every card set's record, by id. Replaced when it grows; take it each frame.
-     * @returns {GPUBuffer}
-     */
-    get records(): GPUBuffer;
-    /**
-     * The card atlas: plane 0 holds √(diffuse albedo) and depth, plane 1 emissive / s_e.
-     * @returns {GPUTileAtlas2D}
-     */
-    get atlas(): GPUTileAtlas2D;
-    /**
-     * A card set for a pair. The caller keeps one per pair.
-     *
-     * @param {number} geometry the geometry id the pair draws; an aliased one's card set captures its source's
-     *     layout ({@link alias})
-     * @param {ShadeMaterial} material
-     * @returns {number} card set id
-     */
-    acquire(geometry: number, material: ShadeMaterial): number;
-    /**
-     * @param {number} id
-     */
-    release(id: number): void;
-    /**
-     * The card set's material has changed (its version moved): capture it again. A resident card set
-     * reads its last capture until the new one is done.
-     *
-     * @param {number} id
-     */
-    recapture(id: number): void;
-    /**
-     * A geometry's layout is placed, with `pages` pages: its card sets can be captured.
-     *
-     * @param {number} geometry
-     * @param {number} pages
-     * @param {number} side texels a side of the layout's largest card: its grid's longest axis in
-     *        voxels, plus one, the lattice having a point at either end
-     */
-    set_layout(geometry: number, pages: number, side: number): void;
-    /**
-     * A geometry's layout is gone: its card sets wait for the next.
-     *
-     * @param {number} geometry
-     */
-    drop_layout(geometry: number): void;
-    /**
-     * The geometry `clone` is drawn as `source` from here on: its card sets, and those acquired for it after, capture
-     * `source`'s layout through `source`'s meshlets, the two being in one local space. A card set of `clone` waits
-     * for `source`'s layout, as one acquired for `source` does.
-     *
-     * @param {number} clone
-     * @param {number} source
-     */
-    alias(clone: number, source: number): void;
-    /**
-     * `clone` is no longer aliased: card sets acquired for it from here on capture its own layout. Those it has keep
-     * capturing its source's until they are given back.
-     *
-     * @param {number} clone
-     */
-    unalias(clone: number): void;
-    /**
-     * Record the frame's capture: at most `budget` pages. Records nothing when nothing waits. Card
-     * sets whose first capture this completes are resident from here, and {@link onResident} is sent
-     * for each.
-     *
-     * @param {Object} options
-     * @param {FrameGraph} options.graph
-     * @param {number} options.budget pages captured at most, `card_capture_budget`
-     * @param {number} options.arena graph handle of the arena, as the frame's bake left it
-     * @param {GPUBuffer} options.headers
-     * @param {GPUResidentMaterialContext} options.materials what the trace shades with: each traced
-     *        material is made resident, and the rows committed, before the trace is recorded
-     * @param {GPUMaterialManager} options.material_contexts what the raster draws with: each
-     *        material's template and bind group
-     * @param {Object} options.blas the geometry bindings `ray_query_blas_nearest` reads, whose
-     *        geometry and meshlet buffers the raster pulls vertices from
-     */
-    graph_capture({ graph, budget, arena, headers, materials, material_contexts, blas }: {
-        graph: FrameGraph;
-        budget: number;
-        arena: number;
-        headers: GPUBuffer;
-        materials: GPUResidentMaterialContext;
-        material_contexts: GPUMaterialManager;
-        blas: any;
-    }): void;
-    /**
-     * @returns {number} bytes
-     */
-    get gpu_memory_usage(): number;
-    destroy(): void;
-    #private;
-}
-export type FrameGraph = import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-export type ShadeMaterial = import("../../../material/ShadeMaterial.js").ShadeMaterial;
-export type GPUResidentMaterialContext = import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext;
-export type GPUMaterialManager = import("../../../material/GPUMaterialManager.js").GPUMaterialManager;
-export type GPUMaterialContext = import("../../../material/GPUMaterialContext.js").GPUMaterialContext;
-export type Allocation = import("../../../../../core/binary/allocator/OffsetAllocator.js").Allocation;
-import { GPUTileAtlas2D } from "../../../texture/atlas/GPUTileAtlas2D.js";
-//# sourceMappingURL=GPUMeshCardSets.d.ts.map

package/src/shade/renderer/geometry/sdf/cards/GPUMeshCardSets.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GPUMeshCardSets.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/cards/GPUMeshCardSets.js"],"names":[],"mappings":"AAyEA;;;;;;GAMG;AACH,sDAHW,aAAa,GACX,MAAM,CAUlB;AApCD;;;GAGG;AACH,2CAFU,MAAM,CAEmF;AA0DnG;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAiMI;;OAEG;IACH,+BAIC;IAjMD;;;OAGG;IACH,gBAA0B;IAE1B;;;OAGG;IACH,iBAA2B;IAyL3B;;;OAGG;IACH,oBAUC;IAED;;OAEG;IACH,6BAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;OAIG;IACH,mCAIC;IAED;;;OAGG;IACH,2BAcC;IASD;;;;;OAKG;IACH,+BAgBC;IA7BD;;OAEG;IACH,2BAEC;IA0BD;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,yBAIC;IAED;;;OAGG;IACH,4BAIC;IAED;;;;;;;OAOG;IACH,kBALW,MAAM,YAEN,aAAa,GACX,MAAM,CAiClB;IAED;;OAEG;IACH,YAFW,MAAM,QA2BhB;IAED;;;;;OAKG;IACH,cAFW,MAAM,QAqBhB;IAED;;;;;;;OAOG;IACH,qBALW,MAAM,SACN,MAAM,QACN,MAAM,QAqBhB;IAED;;;;OAIG;IACH,sBAFW,MAAM,QA+BhB;IAED;;;;;;;OAOG;IACH,aAHW,MAAM,UACN,MAAM,QAoChB;IAED;;;;;OAKG;IACH,eAFW,MAAM,QAIhB;IA0SD;;;;;;;;;;;;;;;;OAgBG;IACH;QAX+B,KAAK,EAAzB,UAAU;QACM,MAAM,EAAtB,MAAM;QACU,KAAK,EAArB,MAAM;QACa,OAAO;QACU,SAAS,EAA7C,0BAA0B;QAEE,iBAAiB,EAA7C,kBAAkB;QAEF,IAAI;aAsG9B;IAiTD;;OAEG;IACH,+BAuBC;IAED,gBAoBC;;CACJ;yBA95CY,OAAO,iEAAiE,EAAE,UAAU;4BACpF,OAAO,oCAAoC,EAAE,aAAa;yCAC1D,OAAO,0DAA0D,EAAE,0BAA0B;iCAC7F,OAAO,yCAAyC,EAAE,kBAAkB;iCACpE,OAAO,yCAAyC,EAAE,kBAAkB;yBACpE,OAAO,yDAAyD,EAAE,UAAU;+BAxB1D,0CAA0C"}