@woosh/meep-engine 3.31.0 → 3.32.0

package/src/shade/renderer/rasterize/graph_clear_raster_targets.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Clear a rasterization's targets to what its first draw would have cleared them to, for a
+ * rasterization that has no first draw.
+ *
+ * A rasterization clears its targets through the `loadOp` of its first draw, which is its first opaque
+ * bucket's; everything after that loads. A scene with no opaque bucket has no such draw, and a scene
+ * with nothing in it has no draw at all — and no target starts a frame empty, so the frame then reads
+ * whatever it last held. The renderer's own targets outlive the frame: a mesh taken out of the scene
+ * stays in them, and so does the depth an extension wrote over the scene after the rasterizer was done.
+ * A graph transient comes out of a pool holding whatever its last user left, which is what a point
+ * light's cube faces are. This takes that draw's place.
+ *
+ * The clear values are the pass descriptor's own, so what the targets hold afterwards is exactly what
+ * the draw's clear would have left. A viewport short of the whole target fills that rectangle alone —
+ * shadow maps share an atlas, and a clear load op would erase every other map in it.
+ *
+ * @param {object} options
+ * @param {FrameGraph} options.graph
+ * @param {number} options.depth depth texture resource ID
+ * @param {number[]} options.color_targets colour texture resource IDs, in the order of the pass
+ * descriptor's colour attachments
+ * @param {RenderPassDescriptor} options.pass_descriptor the pass whose first draw this stands in for;
+ * the clear values are read off it
+ * @param {number[]} [options.viewport] [x, y, width, height]; a width or height of -1 runs to the edge of
+ * the target, and [0, 0, -1, -1] is the whole target
+ * @returns {{depth: number, color_targets: number[]}} the depth and colour handles, cleared
+ */
+export function graph_clear_raster_targets({ graph, depth, color_targets, pass_descriptor, viewport, }: {
+    graph: FrameGraph;
+    depth: number;
+    color_targets: number[];
+    pass_descriptor: RenderPassDescriptor;
+    viewport?: number[];
+}): {
+    depth: number;
+    color_targets: number[];
+};
+//# sourceMappingURL=graph_clear_raster_targets.d.ts.map

package/src/shade/renderer/rasterize/graph_clear_raster_targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph_clear_raster_targets.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/rasterize/graph_clear_raster_targets.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAV+B,KAAK;IACT,KAAK,EAArB,MAAM;IACY,aAAa,EAA/B,MAAM,EAAE;IAEsB,eAAe;IAE1B,QAAQ,GAA3B,MAAM,EAAE;IAEN;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAC,CA4EpD"}

package/src/shade/renderer/rasterize/graph_clear_raster_targets.js

@@ -0,0 +1,105 @@
+import { assert } from "../../../core/assert.js";
+import { texture_fill_rectangle } from "../texture/util/texture_fill_rectangle.js";
+
+/**
+ * Clear a rasterization's targets to what its first draw would have cleared them to, for a
+ * rasterization that has no first draw.
+ *
+ * A rasterization clears its targets through the `loadOp` of its first draw, which is its first opaque
+ * bucket's; everything after that loads. A scene with no opaque bucket has no such draw, and a scene
+ * with nothing in it has no draw at all — and no target starts a frame empty, so the frame then reads
+ * whatever it last held. The renderer's own targets outlive the frame: a mesh taken out of the scene
+ * stays in them, and so does the depth an extension wrote over the scene after the rasterizer was done.
+ * A graph transient comes out of a pool holding whatever its last user left, which is what a point
+ * light's cube faces are. This takes that draw's place.
+ *
+ * The clear values are the pass descriptor's own, so what the targets hold afterwards is exactly what
+ * the draw's clear would have left. A viewport short of the whole target fills that rectangle alone —
+ * shadow maps share an atlas, and a clear load op would erase every other map in it.
+ *
+ * @param {object} options
+ * @param {FrameGraph} options.graph
+ * @param {number} options.depth depth texture resource ID
+ * @param {number[]} options.color_targets colour texture resource IDs, in the order of the pass
+ * descriptor's colour attachments
+ * @param {RenderPassDescriptor} options.pass_descriptor the pass whose first draw this stands in for;
+ * the clear values are read off it
+ * @param {number[]} [options.viewport] [x, y, width, height]; a width or height of -1 runs to the edge of
+ * the target, and [0, 0, -1, -1] is the whole target
+ * @returns {{depth: number, color_targets: number[]}} the depth and colour handles, cleared
+ */
+export function graph_clear_raster_targets({
+                                               graph,
+                                               depth,
+                                               color_targets,
+                                               pass_descriptor,
+                                               viewport = [0, 0, -1, -1],
+                                           }) {
+    assert.defined(graph, 'graph');
+    assert.isNonNegativeInteger(depth, 'depth');
+    assert.isArray(color_targets, 'color_targets');
+    assert.equal(pass_descriptor.isRenderPassDescriptor, true, "pass_descriptor must be a RenderPassDescriptor");
+    assert.equal(color_targets.length, pass_descriptor.colorAttachments.length, 'one colour target per colour attachment of the pass');
+
+    /**
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+        const encoder = context.encoder;
+
+        /**
+         * @type {GPUTextureContext}
+         */
+        const depth_texture = resources.get(data.depth);
+
+        /**
+         * @type {GPUTextureContext[]}
+         */
+        const color_textures = data.color_targets.map(id => resources.get(id));
+
+        const x = viewport[0];
+        const y = viewport[1];
+        const width = viewport[2] >= 0 ? viewport[2] : depth_texture.width - x;
+        const height = viewport[3] >= 0 ? viewport[3] : depth_texture.height - y;
+
+        const is_whole_target = x === 0 && y === 0 && width === depth_texture.width && height === depth_texture.height;
+
+        if (is_whole_target) {
+            const gpu_descriptor = pass_descriptor.toGPU({
+                colorTargets: color_textures,
+                depthTarget: depth_texture,
+                loadOp: "clear",
+                storeOp: "store",
+            });
+
+            // not the draw's pipeline label: nothing is drawn
+            gpu_descriptor.label = "Clear rasterization targets";
+
+            encoder.beginRenderPass(gpu_descriptor).end();
+
+            return;
+        }
+
+        const rectangle = [x, y, width, height];
+
+        for (let i = 0; i < color_textures.length; i++) {
+            texture_fill_rectangle(encoder, color_textures[i], rectangle, pass_descriptor.colorAttachments[i].clearValue);
+        }
+
+        texture_fill_rectangle(encoder, depth_texture, rectangle, [pass_descriptor.depthStencilAttachment.depthClearValue]);
+    }
+
+    const data = {};
+
+    const pass = graph.add("clear raster targets", data, execute);
+
+    data.depth = pass.write(depth);
+    data.color_targets = color_targets.map(pass.write, pass);
+
+    return {
+        depth: data.depth,
+        color_targets: data.color_targets,
+    };
+}

package/src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.d.ts

@@ -12,7 +12,7 @@
  * @param {Set<number>} active_buckets IDs of buckets that have any materials that are active.
  * @param {number[]} [viewport] optional viewport definition, if not provided, will use the entire render target. Useful for drawing multiple views into the same render target.
  * @param {Readonly<Record<number, GPUCullMode>>} [cull_policy] side→cullMode mapping; defaults to {@link CullPolicy.Standard}
- * @returns {{instances_maybe:number, meshlets_maybe:number, depth:number, color_targets:number[]}} the "maybe visible" sets, and the depth and colour handles produced by the rasterization
+ * @returns {{instances_maybe:number, meshlets_maybe:number, depth:number, color_targets:number[]}} the "maybe visible" sets, and the depth and colour handles produced by the rasterization — cleared whether or not any bucket drew
  */
 export function graph_rasterize_partial_opaque({ graph, buckets, view, render_pass_descriptor, limits, depth, raster_color_targets, hzb, viewport, active_buckets, cull_policy, }: FrameGraph): {
     instances_maybe: number;

package/src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_partial_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;GAeG;AACH,gMAFa;IAAC,eAAe,EAAC,MAAM,CAAC;IAAC,cAAc,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAgMjG"}
+{"version":3,"file":"graph_rasterize_partial_opaque.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;GAeG;AACH,gMAFa;IAAC,eAAe,EAAC,MAAM,CAAC;IAAC,cAAc,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,aAAa,EAAC,MAAM,EAAE,CAAA;CAAC,CAmNjG"}

package/src/shade/renderer/rasterize/standard/graph_rasterize_partial_opaque.js

@@ -21,6 +21,7 @@ import { MeshletFilter2WayPassData, pass_filter_meshlets_2way } from "../expand/
 import { RasterizationCollectionType } from "../expand/RasterizationCollectionType.js";
 import { construct_primitive_state, CullPolicy } from "../bucket/construct_primitive_state.js";
 import { rasterization_opaque_buckets } from "../bucket/rasterization_opaque_buckets.js";
+import { graph_clear_raster_targets } from "../graph_clear_raster_targets.js";
 
 /**
  *
@@ -36,7 +37,7 @@ import { rasterization_opaque_buckets } from "../bucket/rasterization_opaque_buc
  * @param {Set<number>} active_buckets IDs of buckets that have any materials that are active.
  * @param {number[]} [viewport] optional viewport definition, if not provided, will use the entire render target. Useful for drawing multiple views into the same render target.
  * @param {Readonly<Record<number, GPUCullMode>>} [cull_policy] side→cullMode mapping; defaults to {@link CullPolicy.Standard}
- * @returns {{instances_maybe:number, meshlets_maybe:number, depth:number, color_targets:number[]}} the "maybe visible" sets, and the depth and colour handles produced by the rasterization
+ * @returns {{instances_maybe:number, meshlets_maybe:number, depth:number, color_targets:number[]}} the "maybe visible" sets, and the depth and colour handles produced by the rasterization — cleared whether or not any bucket drew
  */
 export function graph_rasterize_partial_opaque({
                                                    graph,
@@ -219,6 +220,25 @@ export function graph_rasterize_partial_opaque({
         is_first_draw = false;
     }
 
+    if (is_first_draw) {
+        /*
+         No opaque bucket, so no draw above cleared the targets, and they still hold what they held the
+         last time this view drew into them — they are the renderer's own and outlive the frame. The
+         HZB is built from this depth next and everything after this loads, so the clear goes here, in
+         the first draw's place, before anything reads.
+        */
+        const cleared = graph_clear_raster_targets({
+            graph,
+            depth: viz_depth,
+            color_targets: raster_color_targets,
+            pass_descriptor: render_pass_descriptor,
+            viewport,
+        });
+
+        viz_depth = cleared.depth;
+        raster_color_targets = cleared.color_targets;
+    }
+
     // at this point we have rendered all occluders, and the uncertain cases are all stored in the "maybe" set
 
     // will be appended to in further passes

package/src/shade/renderer/rasterize/standard/graph_rasterize_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_scene.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;GAWG;AACH;IAN+B,KAAK;IACC,GAAG;IACA,MAAM;IACjC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAC,CA0NrE"}
+{"version":3,"file":"graph_rasterize_scene.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/standard/graph_rasterize_scene.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;GAWG;AACH;IAN+B,KAAK;IACC,GAAG;IACA,MAAM;IACjC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAC,CAmNrE"}

package/src/shade/renderer/rasterize/standard/graph_rasterize_scene.js

@@ -11,7 +11,6 @@ import { RasterizationCollectionType } from "../expand/RasterizationCollectionTy
 import { graph_rasterize_meshes_alpha_tested } from "../native/graph_rasterize_meshes_alpha_tested.js";
 import { graph_rasterize_partial_opaque } from "./graph_rasterize_partial_opaque.js";
 import { graph_rasterize_remaining_opaque } from "./graph_rasterize_remaining_opaque.js";
-import { rasterization_has_opaque_bucket } from "../bucket/rasterization_has_opaque_bucket.js";
 
 /**
  * TODO:
@@ -156,27 +155,22 @@ export function graph_rasterize_scene({
 
 
     if (job.alpha_tested_pass !== undefined) {
-        /**
-         * The opaque path's first draw is the only thing that clears the visibility-buffer colour
-         * attachments and the depth attachment — the clear values live on the opaque pass descriptor
-         * and reach the targets through its `loadOp`, and every pass after it is recorded with
-         * `load`. When the scene has no opaque bucket that draw never happens, so the first pass that
-         * does run owns the clear. The alpha-tested descriptor carries the same clear values
-         * (`[0,0,0,0]`, VIZ_BUFFER_INVALID_MESH_VALUE, DEPTH_BACKGROUND_VALUE), so handing it over
-         * changes nothing about what the targets are cleared to.
-         *
-         * Wherever an opaque bucket exists — nearly every scene — this starts true and every call
-         * below asks for `false`, exactly as before.
-         */
-        let targets_cleared = rasterization_has_opaque_bucket(active_buckets);
-
-
+        /*
+         Both alpha-tested passes load, never clear: the targets were cleared before the HZB above was
+         built from them — by the first opaque draw, or in a scene with no opaque bucket by the clear
+         `graph_rasterize_partial_opaque` records in that draw's place.
+
+         The clear used to be handed to the first alpha-tested draw instead. That left the HZB built
+         from an uncleared depth whenever there was no opaque bucket, and when there was no
+         alpha-tested draw either — a scene with nothing in it, or only transparent surfaces — nothing
+         cleared at all, and the frame inherited the targets as they were left.
+        */
         const alpha_tested_front = graph_rasterize_meshes_alpha_tested({
             graph,
             buckets: gr_render_buckets,
             view_ctx,
             render_pass_descriptor: job.alpha_tested_pass,
-            clear_target: !targets_cleared,
+            clear_target: false,
             side: ShadeDrawSide.Front,
             cull_policy: job.cull_policy,
             limits,
@@ -189,14 +183,13 @@ export function graph_rasterize_scene({
 
         gr_texture_depth = alpha_tested_front.depth;
         raster_color_targets = alpha_tested_front.color_targets;
-        targets_cleared = targets_cleared || alpha_tested_front.executed;
 
         const alpha_tested_double = graph_rasterize_meshes_alpha_tested({
             graph,
             buckets: gr_render_buckets,
             view_ctx,
             render_pass_descriptor: job.alpha_tested_pass,
-            clear_target: !targets_cleared,
+            clear_target: false,
             side: ShadeDrawSide.Double,
             cull_policy: job.cull_policy,
             limits,
@@ -209,7 +202,6 @@ export function graph_rasterize_scene({
 
         gr_texture_depth = alpha_tested_double.depth;
         raster_color_targets = alpha_tested_double.color_targets;
-        targets_cleared = targets_cleared || alpha_tested_double.executed;
 
         if (alpha_tested_front.executed || alpha_tested_double.executed) {
 

package/src/shade/renderer/shader/graph/graph_import_typed_buffer.d.ts

@@ -3,7 +3,8 @@
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {WebGPUType} options.type type of the buffer
- * @param {*} options.value actual value to store in the imported buffer
+ * @param {*} options.value actual value to store in the imported buffer. Give every field: one left
+ *        out is skipped, not zeroed, so it holds whatever bytes the upload memory held before
  * @param {string} [options.label] optional name for the new resource, if not specified will assume name of the type
  * @param {GPUBufferUsage|number} options.usage
  * @returns {number}

package/src/shade/renderer/shader/graph/graph_import_typed_buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_import_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/graph/graph_import_typed_buffer.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IArB+B,KAAK;IACL,IAAI;IACb,KAAK;IACC,KAAK,GAAtB,MAAM;IACyB,KAAK,EAApC,iBAAe,MAAM;IACnB,MAAM,CAkFlB"}
+{"version":3,"file":"graph_import_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/graph/graph_import_typed_buffer.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAtB+B,KAAK;IACL,IAAI;IACb,KAAK;IAEC,KAAK,GAAtB,MAAM;IACyB,KAAK,EAApC,iBAAe,MAAM;IACnB,MAAM,CAqElB"}

package/src/shade/renderer/shader/graph/graph_import_typed_buffer.js

@@ -1,13 +1,13 @@
 import { assert } from "../../../../core/assert.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
-import { write_gpu_typed_buffer } from "../type/serde/write_gpu_typed_buffer.js";
 
 /**
  *
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {WebGPUType} options.type type of the buffer
- * @param {*} options.value actual value to store in the imported buffer
+ * @param {*} options.value actual value to store in the imported buffer. Give every field: one left
+ *        out is skipped, not zeroed, so it holds whatever bytes the upload memory held before
  * @param {string} [options.label] optional name for the new resource, if not specified will assume name of the type
  * @param {GPUBufferUsage|number} options.usage
  * @returns {number}
@@ -52,32 +52,19 @@ export function graph_import_typed_buffer({
     function execute(data, resources, context) {
         const gpu_buffer = resources.get(data.buffer);
 
-        const encoder = context.encoder;
-
-        // TODO this is pretty inefficient, figure out a way to skip needing 2 buffers
-        // [AG - 2025/09/13] - Using a transient buffer and a queue.writeBuffer resulted in garbage being written.
-        //                     No idea why currently, creating a new buffer works for now, but the underlying issue is not resolved
-
-        const _size = type.size;
-        const buffer = encoder.device.createBuffer({
-            label: "Import typed buffer/ temp buffer",
-            size: _size,
-            usage: GPUBufferUsage.COPY_SRC,
-            mappedAtCreation: true
-        });
-
-        const mapped = buffer.getMappedRange();
-
-        write_gpu_typed_buffer(value, type, mapped);
-        buffer.unmap();
-        // Copy is necessary to ensure a correct device timeline
-
-        encoder.copyBufferToBuffer(buffer, 0, gpu_buffer, 0, _size);
-
-        encoder.onFinished.addOne(() => {
-
-            buffer.destroy();
-        })
+        /*
+         Recorded in order, where this pass runs — never `queue.writeBuffer`.
+
+         The resource is a frame graph transient, and the pool hands a transient out again as soon
+         as its last user in the frame has run, so this buffer may have held another resource
+         earlier in the same submission, written by a pass recorded before this one. A queue write
+         lands ahead of the whole submission, that earlier pass's write executes after it, and the
+         reader gets the earlier pass's bytes. That is the garbage this import wrote in 2025, twice:
+         queue-writing the resource itself, then queue-writing a transient from the same pool and
+         copying from that. A mapped buffer created for every call hid it, at a create and a destroy
+         per import per frame.
+        */
+        context.encoder.writeValueBuffer(gpu_buffer, 0, type, value);
     }
 
     const pass = graph.add("import_typed_buffer", data, execute);

package/src/core/geom/3d/atlas/atlas_bench_lib.d.ts

@@ -1,73 +0,0 @@
-/** Flat n×n plane in z=0. Single planar region => one chart, zero stretch. */
-export function soup_plane(n: any): any[];
-/** Deterministic gently-bumpy terrain (curved, smooth, no RNG). */
-export function soup_terrain(n: any, amplitude: any): any[];
-/** Dense bumpy terrain decimated by the production simplifier -> irregular, over-segmenting asset. */
-export function soup_decimated_terrain(n: any, amplitude: any, error: any): number[];
-/** UV sphere (fanned poles, no degenerate tris). Smooth closed surface. */
-export function soup_uv_sphere(rings: any, sectors: any): any[];
-/** Upper hemisphere cap (intrinsic positive curvature -> MUST distort under any flattening). */
-export function soup_hemisphere(rings: any, sectors: any): any[];
-/** Open cylinder side (no caps): a DEVELOPABLE surface — should flatten to a flat strip with ~zero stretch. */
-export function soup_cylinder_open(radial: any, rings: any, height: any, radius: any): any[];
-/** Open cone side (no base): DEVELOPABLE — flattens to a circular sector with ~zero stretch. */
-export function soup_cone_open(radial: any, rings: any, height: any, radius: any): any[];
-/** Torus: irregular, curved charts (a packing stress fixture). */
-export function soup_torus(rings: any, sides: any, R: any, rr: any): any[];
-/** Grid of unit cubes (each cube => 6 charts at 90°; a chart-count fixture). */
-export function soup_cube_field(count: any): any[];
-export function build_mesh(soup: any): BinaryTopology;
-/**
- * Per-run chart-quality metrics. `charts` are finalized charts (each with
- * `surface_area`, `parametric_area`, `type`, and solved `uv`).
- *
- * @param {Chart[]} charts
- * @returns {object} chart_count, ortho/lscm/piecewise counts, area-weighted
- *   mean_stretch, max_stretch, p50/p90/p99 of per-chart worst stretch,
- *   tail_count + tail_area_frac (charts above TAIL_STRETCH), degenerate count.
- */
-export function chart_metrics(charts: Chart[]): object;
-/** Total 3D length of edges cut between different charts (texture seams) + fraction of interior length. */
-export function seam_metrics(mesh: any, charts: any): {
-    seam_len: number;
-    seam_pct: number;
-    interior_len: number;
-};
-/**
- * Run the full pipeline once and return the metric panel. Always rebuilds the
- * mesh from the soup so packing-only A/Bs are independent (pack mutates uv).
- *
- * @param {number[]} soup triangle soup
- * @param {object} [computeOpts] atlas_compute_charts options
- * @param {object} [packOpts] atlas_pack_charts options
- * @returns {object} flattened metric panel
- */
-export function measure(soup: number[], computeOpts?: object, packOpts?: object): object;
-/** Median wall-clock of `fn` over a time budget, with warmup. */
-export function time_median(fn: any, budget_ms?: number, warmup?: number): any;
-/**
- * A/B: measure baseline vs candidate on the same fixture and return both panels
- * plus per-key deltas. The caller asserts the expected direction (the gate).
- *
- * @param {number[]} soup
- * @param {{compute?:object, pack?:object}} a baseline options
- * @param {{compute?:object, pack?:object}} b candidate options
- * @returns {{base:object, cand:object, delta:object}}
- */
-export function ab(soup: number[], a: {
-    compute?: object;
-    pack?: object;
-}, b: {
-    compute?: object;
-    pack?: object;
-}): {
-    base: object;
-    cand: object;
-    delta: object;
-};
-/** Compact one-line metric panel for console output. */
-export function fmt(m: any): string;
-/** Charts whose worst (L∞) per-triangle stretch exceeds this count as the "high-distortion tail". */
-export const TAIL_STRETCH: 2;
-import { BinaryTopology } from "../topology/struct/binary/BinaryTopology.js";
-//# sourceMappingURL=atlas_bench_lib.d.ts.map

package/src/core/geom/3d/atlas/atlas_bench_lib.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atlas_bench_lib.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/atlas/atlas_bench_lib.js"],"names":[],"mappings":"AAoCA,8EAA8E;AAC9E,0CAKC;AAED,mEAAmE;AACnE,4DAMC;AAED,sGAAsG;AACtG,qFAIC;AAED,2EAA2E;AAC3E,gEAYC;AAED,gGAAgG;AAChG,iEAYC;AAED,+GAA+G;AAC/G,6FAQC;AAED,gGAAgG;AAChG,yFAUC;AAED,kEAAkE;AAClE,2EASC;AAED,gFAAgF;AAChF,mDAWC;AAED,sDAIC;AA8BD;;;;;;;;GAQG;AACH,sCALW,OAAO,GACL,MAAM,CA0ClB;AAED,2GAA2G;AAC3G;;;;EAsBC;AAGD;;;;;;;;GAQG;AACH,8BALW,MAAM,EAAE,gBACR,MAAM,aACN,MAAM,GACJ,MAAM,CAgBlB;AAED,iEAAiE;AACjE,+EAWC;AAED;;;;;;;;GAQG;AACH,yBALW,MAAM,EAAE,KACR;IAAC,OAAO,CAAC,EAAC,MAAM,CAAC;IAAC,IAAI,CAAC,EAAC,MAAM,CAAA;CAAC,KAC/B;IAAC,OAAO,CAAC,EAAC,MAAM,CAAC;IAAC,IAAI,CAAC,EAAC,MAAM,CAAA;CAAC,GAC7B;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,KAAK,EAAC,MAAM,CAAA;CAAC,CAUpD;AAED,wDAAwD;AACxD,oCAMC;AApJD,qGAAqG;AACrG,6BAAgC;+BAvKa,6CAA6C"}

package/src/engine/graphics3/terrain/GPUTerrainSplatRenderer.d.ts

@@ -1,59 +0,0 @@
-/**
- * Draws one terrain's splat and grid overlay into the G-buffer's albedo.
- *
- * Two passes: this frame's tables and any changed textures are uploaded, and the composite reads
- * the albedo the material pass wrote and writes a replacement — publishing into
- * {@link GBufferTextures} (D23) is what carries it downstream. One renderer per terrain, owned by the system's
- * entry for it, because every texture here is the terrain's own.
- */
-export class GPUTerrainSplatRenderer {
-    /**
-     * Record this terrain's splat into the frame and hand the replacement albedo back through the
-     * context.
-     *
-     * @param {object} args
-     * @param {FrameContext} args.frame
-     * @param {Uint32Array} args.rows 1 where a mesh row belongs to this terrain
-     * @param {number} args.row_count rows in use — one past the highest row marked
-     * @param {Float32Array} args.scales two floats per layer, the legacy `materialScalesMap`
-     * @param {number} args.layer_count
-     * @param {Float32Array} args.world_to_terrain inverse of the terrain entity's world matrix
-     * @param {number[]} args.inv_world_size `1 / (size × gridScale)` per axis
-     * @param {number[]} args.grid_transform scale xy, offset zw
-     * @param {number[]} args.grid_resolution the terrain's size in cells
-     * @param {{data: Uint8Array, width: number, height: number, depth: number, version: number}} args.weights
-     * @param {{data: Uint8Array, width: number, height: number, depth: number, version: number}} args.layer_image
-     * @param {Sampler2D} args.overlay the per-cell rgba map
-     * @param {Sampler2D} args.sprite the cell sprite, rgba
-     */
-    graph_draw({ frame, rows, row_count, scales, layer_count, world_to_terrain, inv_world_size, grid_transform, grid_resolution, weights, layer_image, overlay, sprite }: {
-        frame: FrameContext;
-        rows: Uint32Array;
-        row_count: number;
-        scales: Float32Array;
-        layer_count: number;
-        world_to_terrain: Float32Array;
-        inv_world_size: number[];
-        grid_transform: number[];
-        grid_resolution: number[];
-        weights: {
-            data: Uint8Array;
-            width: number;
-            height: number;
-            depth: number;
-            version: number;
-        };
-        layer_image: {
-            data: Uint8Array;
-            width: number;
-            height: number;
-            depth: number;
-            version: number;
-        };
-        overlay: Sampler2D;
-        sprite: Sampler2D;
-    }): void;
-    destroy(): void;
-    #private;
-}
-//# sourceMappingURL=GPUTerrainSplatRenderer.d.ts.map

package/src/engine/graphics3/terrain/GPUTerrainSplatRenderer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GPUTerrainSplatRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/terrain/GPUTerrainSplatRenderer.js"],"names":[],"mappings":"AA6EA;;;;;;;GAOG;AACH;IAyCI;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAd8B,KAAK;QACN,IAAI,EAAtB,WAAW;QACE,SAAS,EAAtB,MAAM;QACa,MAAM,EAAzB,YAAY;QACC,WAAW,EAAxB,MAAM;QACa,gBAAgB,EAAnC,YAAY;QACG,cAAc,EAA7B,MAAM,EAAE;QACO,cAAc,EAA7B,MAAM,EAAE;QACO,eAAe,EAA9B,MAAM,EAAE;QACgF,OAAO,EAA/F;YAAC,IAAI,EAAE,UAAU,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAC;QACO,WAAW,EAAnG;YAAC,IAAI,EAAE,UAAU,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAC;QACjE,OAAO;QACP,MAAM;aAgEhC;IAyND,gBAwBC;;CACJ"}

package/src/engine/graphics3/terrain/pack_terrain_row_table.d.ts

@@ -1,22 +0,0 @@
-/**
- * The lookup the splat pass reads a visibility-buffer mesh row through: one word per row, 1 for a
- * row that is a tile of this terrain, 0 for anything else.
- *
- * A tile is an entity, and its row is the entity's, one on — so the table is sized by the highest
- * tile entity and the rows in between belong to whatever else the level holds. Whether a row has
- * been written yet is not this table's business: a row the scene has not placed is in no pixel of
- * the visibility buffer, and marking it costs nothing.
- *
- * @param {object} args
- * @param {Map<*, number>} args.tiles the terrain's tile entities, by whatever spawned them
- * @param {Uint32Array} args.table the previous frame's table, reused when it is long enough
- * @returns {{table: Uint32Array, size: number}} the table and how much of it is meaningful
- */
-export function pack_terrain_row_table({ tiles, table }: {
-    tiles: Map<any, number>;
-    table: Uint32Array;
-}): {
-    table: Uint32Array;
-    size: number;
-};
-//# sourceMappingURL=pack_terrain_row_table.d.ts.map

package/src/engine/graphics3/terrain/pack_terrain_row_table.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pack_terrain_row_table.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/terrain/pack_terrain_row_table.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH;IAJgC,KAAK,EAA1B,SAAO,MAAM,CAAC;IACI,KAAK,EAAvB,WAAW;IACT;IAAC,KAAK,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAiC9C"}

package/src/engine/graphics3/terrain/shader_terrain_splat.d.ts

@@ -1,26 +0,0 @@
-export const TERRAIN_SPLAT_SETTINGS: WebGPUStruct;
-/**
- * Reads the G-buffer's albedo, paints the terrain's splat mix and grid overlay into every pixel
- * the visibility buffer attributes to a terrain tile, and writes a new albedo.
- *
- * **This is the decal architecture keyed on a different thing (D40).** A pass after the opaque
- * geometry on the in/out G-buffer D23 opened — but where a decal asks a froxel walk whether a
- * world position is inside an oriented box, this pass asks the visibility buffer which mesh the
- * pixel came from. The classification is exact and costs one load: no second geometry pass, no
- * depth-equal redraw, no bounds test a unit standing on the ground would fail.
- *
- * **Only the albedo is replaced.** The legacy splat material forced roughness 1 and metalness 0,
- * which is what the tile's own material already writes into the PBR target during the material
- * pass; the normals are the tile geometry's own. What the splat changes is colour, so colour is
- * the one target this pass touches — the other three handles pass through untouched.
- *
- * **Linear space throughout, by format rather than by arithmetic** (§U3): the layer array and both
- * overlay textures are uploaded sRGB, so their samplers decode before filtering, the mix and the
- * grid tint multiply happen on linear values, and nothing here decodes or encodes anything.
- *
- * @type {ImageShader}
- */
-export const shader_terrain_splat: ImageShader;
-import { WebGPUStruct } from "../../../shade/renderer/shader/type/WebGPUStruct.js";
-import { ImageShader } from "../../../shade/renderer/shader/ImageShader.js";
-//# sourceMappingURL=shader_terrain_splat.d.ts.map

package/src/engine/graphics3/terrain/shader_terrain_splat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_terrain_splat.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/terrain/shader_terrain_splat.js"],"names":[],"mappings":"AAuBA,kDA+BG;AAkIH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,mCAFU,WAAW,CAWlB;6BAnM0B,qDAAqD;4BAPtD,+CAA+C"}

package/src/shade/renderer/animation/ANIMATION_BOUND_TRACK_GROUP_STRUCT.d.ts

@@ -1,25 +0,0 @@
-/**
- * Number of bound tracks inlined into a single group node. Picked so a
- * node fits comfortably in a cache line or two — three u32s per binding
- * times eight, plus the count + next + clip header, ~104 bytes total.
- */
-export const TRACKS_PER_GROUP_NODE: 8;
-/**
- * Sentinel for the `next` pointer of a tail group node and for clips with
- * no bindings.
- */
-export const ANIMATION_BOUND_TRACK_GROUP_NULL: 4294967295;
-/**
- * One node in a bound clip's linked list of bound tracks. Each clip points
- * at a head node; nodes chain forward via {@link next} until a sentinel
- * (`0xFFFFFFFF`). Slots `[0, count)` of `bindings` are populated; tail
- * slots are zeroed and ignored.
- *
- * The dispatch model is one thread per group node, not one per binding —
- * each thread iterates its node's `count` bindings and applies them under
- * the back-referenced clip's time. The `clip` back-pointer makes that
- * dispatch possible without walking the chain from the clip end.
- */
-export const ANIMATION_BOUND_TRACK_GROUP_STRUCT: WebGPUStruct;
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
-//# sourceMappingURL=ANIMATION_BOUND_TRACK_GROUP_STRUCT.d.ts.map

package/src/shade/renderer/animation/ANIMATION_BOUND_TRACK_GROUP_STRUCT.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ANIMATION_BOUND_TRACK_GROUP_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/ANIMATION_BOUND_TRACK_GROUP_STRUCT.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,sCAAuC;AAEvC;;;GAGG;AACH,0DAA2D;AAE3D;;;;;;;;;;GAUG;AACH,8DA2B+B;6BAtDF,gCAAgC"}

package/src/shade/renderer/animation/ANIMATION_KEYFRAME_BLOCK_STRUCT.d.ts

@@ -1,26 +0,0 @@
-/**
- * Number of keyframes inlined into a single block. Eight 16-byte
- * keyframes plus the count + next header keeps a node at 136 bytes and
- * lets the curve evaluator amortize the pointer-chase across multiple
- * samples.
- */
-export const KEYFRAMES_PER_BLOCK: 8;
-/**
- * Sentinel for the `next` pointer of a tail keyframe block.
- */
-export const ANIMATION_KEYFRAME_BLOCK_NULL: 4294967295;
-/**
- * One node in a curve's linked list of keyframes. Curves point at a head
- * block; blocks chain forward via {@link next} until a sentinel
- * (`0xFFFFFFFF`). Slots `[0, count)` of `keyframes` are populated in
- * ascending time order; tail slots are zeroed and ignored.
- *
- * Replaces the previous "all keyframes for one curve are a contiguous run
- * in `animation_keyframes`" arrangement: that constraint forced an
- * append-only monotonic counter and made it impossible to grow a curve
- * after creation. With block chaining each curve allocates blocks
- * independently of every other curve.
- */
-export const ANIMATION_KEYFRAME_BLOCK_STRUCT: WebGPUStruct;
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
-//# sourceMappingURL=ANIMATION_KEYFRAME_BLOCK_STRUCT.d.ts.map

package/src/shade/renderer/animation/ANIMATION_KEYFRAME_BLOCK_STRUCT.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ANIMATION_KEYFRAME_BLOCK_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/ANIMATION_KEYFRAME_BLOCK_STRUCT.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,oCAAqC;AAErC;;GAEG;AACH,uDAAwD;AAExD;;;;;;;;;;;GAWG;AACH,2DAmB6B;6BA/CA,gCAAgC"}