@woosh/meep-engine 3.31.0 → 3.33.0

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/shade/renderer/shader/type/serde/write_gpu_typed_buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"write_gpu_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/type/serde/write_gpu_typed_buffer.js"],"names":[],"mappings":"AA0GA;;;;;;GAMG;AACH,0DAJW,YAAY,qBAEV,IAAI,CA+DhB;AAMD;;;;;;GAMG;AACH,2EAHW,WAAW,eACX,MAAM,QA2BhB;6BAnN4B,4CAA4C"}
+{"version":3,"file":"write_gpu_typed_buffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/type/serde/write_gpu_typed_buffer.js"],"names":[],"mappings":"AA0GA;;;;;;GAMG;AACH,0DAJW,YAAY,qBAEV,IAAI,CA+DhB;AAMD;;;;;;GAMG;AACH,2EAHW,WAAW,eACX,MAAM,QAkChB;6BA1N4B,4CAA4C"}

package/src/shade/renderer/shader/type/serde/write_gpu_typed_buffer.js

@@ -203,7 +203,14 @@ export function write_gpu_typed_buffer(
     assert.isNonNegativeInteger(byteOffset, 'byteOffset');
     assert.greaterThanOrEqual(data.byteLength - byteOffset, type.size, "Data buffer is too small");
 
-    scratch_buffer.fromArrayBuffer(data);
+    if (scratch_buffer.data !== data || scratch_buffer.capacity !== data.byteLength) {
+        // Bound afresh only for a buffer it is not bound to already: binding makes a DataView and a
+        // Uint8Array, and a command context's uniforms arrive one after another into the same
+        // upload block. The length is compared as well, so a buffer the scratch grew away from, or
+        // one detached since, is bound anew rather than written through stale views.
+        scratch_buffer.fromArrayBuffer(data);
+    }
+
     scratch_buffer.position = byteOffset;
 
     assert.equal(scratch_buffer.data, data, 'scratch_buffer.buffer !== data'); // sanity check

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"}

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

@@ -1,29 +0,0 @@
-/**
- * Number of joints inlined per skin chain node. Matches the chain
- * granularity used elsewhere in the animation database (8); a 64-bone
- * skeleton fits in 8 blocks and the page iterator parallelizes one
- * thread per block.
- */
-export const JOINTS_PER_SKIN_BLOCK: 8;
-/**
- * Sentinel for the `next` pointer of a tail joint block.
- */
-export const ANIMATION_SKIN_JOINT_BLOCK_NULL: 4294967295;
-/**
- * One node in a skin's linked list of joints. Skins point at a head
- * block; blocks chain forward via {@link next} until a sentinel
- * (`0xFFFFFFFF`). Slots `[0, count)` of `joints` are populated; tail
- * slots are zero-filled placeholders the prep shader skips via the
- * count guard.
- *
- * The block carries {@link skin_matrix_offset} — the absolute write
- * address into the shared `skin_matrices` scratch buffer for slot 0 of
- * this block. Slot `i` of `joints` writes to
- * `skin_matrices[skin_matrix_offset + i]`. Storing the absolute offset
- * per block (rather than a back-pointer to the skin + a per-block joint
- * index) lets the prep shader's per-thread work be a single block load
- * with no further indirection through the skin record.
- */
-export const ANIMATION_SKIN_JOINT_BLOCK_STRUCT: WebGPUStruct;
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
-//# sourceMappingURL=ANIMATION_SKIN_JOINT_BLOCK_STRUCT.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"ANIMATION_SKIN_JOINT_BLOCK_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/animation/ANIMATION_SKIN_JOINT_BLOCK_STRUCT.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,sCAAuC;AAEvC;;GAEG;AACH,yDAA0D;AAE1D;;;;;;;;;;;;;;GAcG;AACH,6DA4BqC;6BA3DR,gCAAgC"}