@woosh/meep-engine 3.57.0 → 3.58.0

package/src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUGeometryBVHManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.js"],"names":[],"mappings":"AAkBA;;;GAGG;AAEH;;;;;GAKG;AACH,gDAGG;AAEH;;;;;;;;;;;GAWG;AACH,sCAFU,MAAM,CAEyB;AA0CzC;;;;;;;;;;;;;;GAcG;AACH;IA8JI;;;OAGG;IACH,+BAoDC;IA9MD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,6BAEC;IAuCD;;OAEG;IACH,gCAEC;IAOD;;OAEG;IACH,mCAEC;IAmDD;;OAEG;IACH,gCAEC;IA6ED;;;;OAIG;IACH,iCAEC;IAED,+BAoBC;IAED;;;;;;;;;OASG;IACH,wCAIC;IAED;;;;;;;;;;;;;;OAcG;IACH,cALW,MAAM,UACN,eAAe,GAEb,sBAAsB,CAalC;IA8DD;;;;;;;;;;;;OAYG;IACH,wBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,GAAC,SAAS,CAqB3I;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAU5B;IAED;;;;;;;;;OASG;IACH,0BAFW,WAAW,QAQrB;IAED;;;;;;;;;;;OAWG;IACH,cAHW,MAAM,GACJ,OAAO,CA8BnB;IA8RD;;;;;;;OAOG;IACH,eAOC;IAiID;;;OAGG;IACH,gBAKC;;CACJ;8BAx9BY,OAAO,uBAAuB,EAAE,eAAe;yBAC/C,OAAO,sDAAsD,EAAE,UAAU;6BAbzD,mCAAmC;uCASzB,6BAA6B"}
+{"version":3,"file":"GPUGeometryBVHManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.js"],"names":[],"mappings":"AAkBA;;;GAGG;AAEH;;;;;GAKG;AACH,gDAGG;AAEH;;;;;;;;;;;GAWG;AACH,sCAFU,MAAM,CAEyB;AA0CzC;;;;;;;;;;;;;;GAcG;AACH;IA8JI;;;OAGG;IACH,+BAoDC;IA9MD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,6BAEC;IAuCD;;OAEG;IACH,gCAEC;IAOD;;OAEG;IACH,mCAEC;IAmDD;;OAEG;IACH,gCAEC;IA6ED;;;;OAIG;IACH,iCAEC;IAED,+BAoBC;IAED;;;;;;;;;OASG;IACH,wCAIC;IAED;;;;;;;;;;;;;;OAcG;IACH,cALW,MAAM,UACN,eAAe,GAEb,sBAAsB,CAalC;IA8DD;;;;;;;;;;;;OAYG;IACH,wBAHW,MAAM,GACJ;QAAC,gBAAgB,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,iBAAiB,EAAE,MAAM,CAAA;KAAC,GAAC,SAAS,CAqB3I;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAU5B;IAED;;;;;;;;;OASG;IACH,0BAFW,WAAW,QAQrB;IAED;;;;;;;;;;;OAWG;IACH,cAHW,MAAM,GACJ,OAAO,CA8BnB;IA8RD;;;;;;;OAOG;IACH,eAOC;IAmJD;;;OAGG;IACH,gBAKC;;CACJ;8BA1+BY,OAAO,uBAAuB,EAAE,eAAe;yBAC/C,OAAO,sDAAsD,EAAE,UAAU;6BAbzD,mCAAmC;uCASzB,6BAA6B"}

package/src/shade/renderer/geometry/bvh/GPUGeometryBVHManager.js

@@ -884,6 +884,24 @@ export class GPUGeometryBVHManager {
             return false;
         }
 
+        let has_work = false;
+        for (let i = 0; i < queue_size; i++) {
+            const record = queue.getElementByIndex(i);
+            if (record.released) {
+                has_work = true;
+                break;
+            }
+            const bytes = record.topology.source.bvh;
+            if (bytes !== undefined && bytes.byteLength > 0) {
+                has_work = true;
+                break;
+            }
+        }
+
+        if (!has_work) {
+            return false;
+        }
+
         // `offset` is into the staging buffer the batch is assembled in; `allocation` is the arena
         // region the tree ends up at, filled in once every record's size is known.
         /** @type {{record: GPUGeometryMeshletsBVH, bytes: ArrayBuffer, offset: number, allocation: Allocation}[]} */

package/src/shade/renderer/geometry/bvh/bvh2_derive_topology.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh2_derive_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/bvh2_derive_topology.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;GAiBG;AACH,4CALW,WAAW,GACT;IAAC,OAAO,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,WAAW,CAAA;CAAC,CAuD3D"}
+{"version":3,"file":"bvh2_derive_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/bvh/bvh2_derive_topology.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;GAiBG;AACH,4CALW,WAAW,GACT;IAAC,OAAO,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,WAAW,CAAA;CAAC,CA4D3D"}

package/src/shade/renderer/geometry/bvh/bvh2_derive_topology.js

@@ -64,8 +64,13 @@ export function bvh2_derive_topology(nodes) {
 
         const child_2 = words[base + BVH_NODE_CHILD_2_WORD];
 
+        assert.greaterThan(child_1, 0, 'child_1 must be a non-root node');
+        assert.greaterThan(child_2, 0, 'child_2 must be a non-root node');
         assert.lessThan(child_1, node_count, 'child_1 out of range');
         assert.lessThan(child_2, node_count, 'child_2 out of range');
+        assert.notEqual(child_1, child_2, 'internal node children must be distinct');
+        assert.equal(parents[child_1], BVH_NULL_NODE, 'child_1 already has a parent');
+        assert.equal(parents[child_2], BVH_NULL_NODE, 'child_2 already has a parent');
 
         parents[child_1] = node;
         parents[child_2] = node;

package/src/shade/renderer/geometry/mesh_compute_surface_area.js

@@ -1,5 +1,5 @@
-import { decompose_matrix_4_array } from "../../../core/geom/3d/mat4/decompose_matrix_4_array.js";
-import { compute_triangle_area_3d } from "../../../core/geom/3d/triangle/compute_triangle_area_3d.js";
+import { m4_decompose } from "../../../core/geom/3d/mat4/m4_decompose.js";
+import { tri3_area } from "../../../core/geom/3d/triangle/tri3_area.js";
 import Quaternion from "../../../core/geom/Quaternion.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { StandardAttributes } from "./StandardAttributes.js";
@@ -19,7 +19,7 @@ export function mesh_compute_surface_area(transform, geometry) {
     const index_count = geometry.getIndexCount();
 
     const scale = new Vector3();
-    decompose_matrix_4_array(transform, new Vector3(), new Quaternion(), scale);
+    m4_decompose(transform, new Vector3(), new Quaternion(), scale);
 
     const scale_x = scale.x;
     const scale_y = scale.y;
@@ -43,7 +43,7 @@ export function mesh_compute_surface_area(transform, geometry) {
         const v2_y = p[c + 1] * scale_y;
         const v2_z = p[c + 2] * scale_z;
 
-        result += compute_triangle_area_3d(
+        result += tri3_area(
             v0_x, v0_y, v0_z,
             v1_x, v1_y, v1_z,
             v2_x, v2_y, v2_z,

package/src/shade/renderer/geometry/meshlet/MeshletBatch.d.ts

@@ -28,6 +28,11 @@ export class MeshletBatch {
      * @return {number}
      */
     get count(): number;
+    /**
+     * Total number of triangles encoded across all meshlets in the batch.
+     * @returns {number}
+     */
+    get primitive_count(): number;
     /**
      *
      * @returns {number}

package/src/shade/renderer/geometry/meshlet/MeshletBatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshletBatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/MeshletBatch.js"],"names":[],"mappings":"AA4DA;;GAEG;AACH;IAiBI;;;OAGG;IACH,oCAGC;IAXD,+BAEC;IA6BD;;;OAGG;IACH,wCAGC;IAfD;;;OAGG;IACH,mCAEC;IAqBD;;;OAGG;IACH,yBAEC;IAdD;;;OAGG;IACH,oBAEC;IAUD;;;OAGG;IACH,QAFa,MAAM,CASlB;IAED;;;OAGG;IACH,cAFW,YAAY,WAQtB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAiHlB;IAED;;;OAGG;IACH,iBAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACL,EAAE,CAeb;IAED;;;OAGG;IACH,yBAFW,MAAM;;;;MAgChB;IA4LD,qBA+BC;IAED;;;OAGG;IACH,gBAFW,QAAQ,QASlB;IAIL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;uBA9hBY,OAAO,gBAAgB,EAAE,QAAQ"}
+{"version":3,"file":"MeshletBatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/MeshletBatch.js"],"names":[],"mappings":"AA4DA;;GAEG;AACH;IAiBI;;;OAGG;IACH,oCAGC;IAXD,+BAEC;IA6BD;;;OAGG;IACH,wCAGC;IAfD;;;OAGG;IACH,mCAEC;IAuBD;;;OAGG;IACH,yBAEC;IAdD;;;OAGG;IACH,oBAEC;IAUD;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,QAFa,MAAM,CASlB;IAED;;;OAGG;IACH,cAFW,YAAY,WAQtB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAiHlB;IAED;;;OAGG;IACH,iBAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACL,EAAE,CAeb;IAED;;;OAGG;IACH,yBAFW,MAAM;;;;MAgChB;IAiMD,qBA+BC;IAED;;;OAGG;IACH,gBAFW,QAAQ,QASlB;IAIL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;uBA7iBY,OAAO,gBAAgB,EAAE,QAAQ"}

package/src/shade/renderer/geometry/meshlet/MeshletBatch.js

@@ -116,6 +116,8 @@ export class MeshletBatch {
 
     #count = 0;
 
+    #primitive_count = 0;
+
     /**
      * Number of meshlets in the batch
      * @return {number}
@@ -132,6 +134,14 @@ export class MeshletBatch {
         this.#count = value;
     }
 
+    /**
+     * Total number of triangles encoded across all meshlets in the batch.
+     * @returns {number}
+     */
+    get primitive_count() {
+        return this.#primitive_count;
+    }
+
     /**
      *
      * @returns {number}
@@ -383,6 +393,8 @@ export class MeshletBatch {
 
         const initial_bounds_box = geometry.bounding_box;
 
+        let total_primitive_count = 0;
+
         for (let i = 0; i < meshlet_count; i++) {
             const [
                 p_vertex_offset,
@@ -391,6 +403,8 @@ export class MeshletBatch {
                 p_triangle_count,
             ] = metadata_table.readRow(i);
 
+            total_primitive_count += p_triangle_count;
+
             const metadata = {
                 // actual bounding box is computed later (build_bounds)
                 bounds_box: initial_bounds_box,
@@ -513,6 +527,7 @@ export class MeshletBatch {
         }
 
         this.#count = meshlet_count;
+        this.#primitive_count = total_primitive_count;
 
         encoded_metadata_buffer.trim();
         this.metadata_buffer = encoded_metadata_buffer.data;

package/src/shade/renderer/geometry/meshlet_batch_to_bvh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"meshlet_batch_to_bvh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/meshlet_batch_to_bvh.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH;IANwB,GAAG;IACM,QAAQ;IACR,YAAY,EAAlC,YAAY;IACI,eAAe,EAA/B,MAAM;IACW,YAAY,GAA7B,MAAM;SA4NhB"}
+{"version":3,"file":"meshlet_batch_to_bvh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/meshlet_batch_to_bvh.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH;IANwB,GAAG;IACM,QAAQ;IACR,YAAY,EAAlC,YAAY;IACI,eAAe,EAA/B,MAAM;IACW,YAAY,GAA7B,MAAM;SAqOhB"}

package/src/shade/renderer/geometry/meshlet_batch_to_bvh.js

@@ -32,23 +32,46 @@ export function meshlet_batch_to_bvh({
 
     const meshlet_count = meshlets.count;
 
-    // we assume that the total number of triangles is the same in the meshlet batch
-    // this *should* be true.
-    const node_leaf_count = primitive_count;
+    bvh.release_all();
 
+    if (meshlet_count === 0) {
+        bvh.root = NULL_NODE;
+        bvh.trim();
+        return;
+    }
 
-    const node_bin_count = max2(0, node_leaf_count - 1);
+    // order meshlet indices by morton codes and count actual triangles in the batch
+    const meshlet_morton_codes = new Uint32Array(meshlet_count);
+    let node_leaf_count = 0;
 
-    const node_total_count = node_leaf_count + node_bin_count;
+    for (let i = 0; i < meshlet_count; i++) {
 
-    bvh.release_all();
+        const header = meshlets.read_header(i);
+
+        node_leaf_count += header.primitive_count;
+
+        const bb = header.bounds_box;
+
+        const center_x = (bb[0] + bb[3]) * 0.5;
+        const center_y = (bb[1] + bb[4]) * 0.5;
+        const center_z = (bb[2] + bb[5]) * 0.5;
+
+        meshlet_morton_codes[i] = v3_morton_encode_bounded(
+            center_x, center_y, center_z,
+            bounding_box,
+        );
+    }
 
     if (node_leaf_count === 0) {
-        // special case, should not happen in practice
         bvh.root = NULL_NODE;
+        bvh.trim();
         return;
     }
 
+    const node_bin_count = max2(0, node_leaf_count - 1);
+
+    const node_total_count = node_leaf_count + node_bin_count;
+
     bvh.allocate_linear(node_total_count);
 
     const partial_tree_nodes = new Uint32Array(meshlet_count);
@@ -73,25 +96,6 @@ export function meshlet_batch_to_bvh({
             bottom_tree_node_pool[i] = node;
         }
 
-
-        // order meshlet indices by morton codes
-        const meshlet_morton_codes = new Uint32Array(meshlet_count);
-        for (let i = 0; i < meshlet_count; i++) {
-
-            const header = meshlets.read_header(i);
-
-            const bb = header.bounds_box;
-
-            const center_x = (bb[0] + bb[3]) * 0.5;
-            const center_y = (bb[1] + bb[4]) * 0.5;
-            const center_z = (bb[2] + bb[5]) * 0.5;
-
-            meshlet_morton_codes[i] = v3_morton_encode_bounded(
-                center_x, center_y, center_z,
-                bounding_box,
-            );
-        }
-
         const sorted_indices = new Uint32Array(meshlet_count);
         for (let i = 0; i < meshlet_count; i++) {
             sorted_indices[i] = i;
@@ -114,6 +118,8 @@ export function meshlet_batch_to_bvh({
 
             const meshlet_triangle_count = meshlet_header.primitive_count;
 
+            assert.greaterThan(meshlet_triangle_count, 0, 'meshlet_triangle_count');
+
             for (let triangle_index = 0; triangle_index < meshlet_triangle_count; triangle_index++) {
 
                 const index3 = triangle_index * 3;
@@ -173,6 +179,7 @@ export function meshlet_batch_to_bvh({
             partial_tree_nodes[i] = bottom_tree_node_scratch[0];
         }
 
+        assert.equal(bottom_tree_node_cursor, bottom_tree_node_count, 'bottom_tree_node_cursor !== bottom_tree_node_count');
     }
 
     // ===========
@@ -216,6 +223,8 @@ export function meshlet_batch_to_bvh({
 
         }
 
+        assert.equal(top_tree_node_cursor, top_tree_node_count, 'top_tree_node_cursor !== top_tree_node_count');
+
         const root = partial_tree_nodes[0];
 
         assert.equal(root, 0, 'root must be node 0');

package/src/shade/renderer/geometry/meshlet_geometry_build_from_geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"meshlet_geometry_build_from_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/meshlet_geometry_build_from_geometry.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+EAJW,eAAe,GACb,eAAe,CAqC3B;gCA/D+B,sBAAsB"}
+{"version":3,"file":"meshlet_geometry_build_from_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/meshlet_geometry_build_from_geometry.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+EAJW,eAAe,GACb,eAAe,CAsC3B;gCAhE+B,sBAAsB"}

package/src/shade/renderer/geometry/meshlet_geometry_build_from_geometry.js

@@ -48,13 +48,14 @@ export function meshlet_geometry_build_from_geometry(geometry, out = new Meshlet
     geometry.computeBoundingSphereFromBox();
 
     out.name = geometry.name;
-    out.primitive_count = geometry.getPrimitiveCount();
     out.bounding_box.set(geometry.bounding_box);
     out.bounding_sphere.set(geometry.bounding_sphere);
 
     out.meshlets.build(geometry);
     out.meshlets.compress();
 
+    out.primitive_count = out.meshlets.primitive_count;
+
     out.bvh = blas_from_meshlets(
         out.meshlets,
         out.primitive_count,

package/src/shade/renderer/geometry/normals/decode_octahedral_u32_to_normal.d.ts

@@ -0,0 +1,13 @@
+/**
+ * CPU port of the WGSL `decode_vertex_normal` chunk: unpacks a single `u32` (two 16-bit unorms of
+ * Z-pole octahedral UV, produced by `encode_vertex_normal` on the GPU or
+ * `encode_normals_to_octahedral_u32` on the CPU) into a normalized 3D vector `(nx, ny, nz)`.
+ *
+ * @see chunk_decode_vertex_normal
+ * @see encode_normals_to_octahedral_u32
+ * @param {number[]|Float32Array|Float64Array} output
+ * @param {number} output_offset
+ * @param {number} encoded_u32
+ */
+export function decode_octahedral_u32_to_normal(output: number[] | Float32Array | Float64Array, output_offset: number, encoded_u32: number): void;
+//# sourceMappingURL=decode_octahedral_u32_to_normal.d.ts.map

package/src/shade/renderer/geometry/normals/decode_octahedral_u32_to_normal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode_octahedral_u32_to_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/normals/decode_octahedral_u32_to_normal.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,wDAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,eACN,MAAM,QAmBhB"}

package/src/shade/renderer/geometry/normals/decode_octahedral_u32_to_normal.js

@@ -0,0 +1,33 @@
+import { UINT16_MAX } from "../../../../core/binary/UINT16_MAX.js";
+
+const INV_UINT16_MAX = 1 / UINT16_MAX;
+
+/**
+ * CPU port of the WGSL `decode_vertex_normal` chunk: unpacks a single `u32` (two 16-bit unorms of
+ * Z-pole octahedral UV, produced by `encode_vertex_normal` on the GPU or
+ * `encode_normals_to_octahedral_u32` on the CPU) into a normalized 3D vector `(nx, ny, nz)`.
+ *
+ * @see chunk_decode_vertex_normal
+ * @see encode_normals_to_octahedral_u32
+ * @param {number[]|Float32Array|Float64Array} output
+ * @param {number} output_offset
+ * @param {number} encoded_u32
+ */
+export function decode_octahedral_u32_to_normal(output, output_offset, encoded_u32) {
+    const u = (encoded_u32 & 0xFFFF) * INV_UINT16_MAX;
+    const v = (encoded_u32 >>> 16) * INV_UINT16_MAX;
+
+    let x = u * 2 - 1;
+    let y = v * 2 - 1;
+    const z = 1 - Math.abs(x) - Math.abs(y);
+
+    const t = Math.max(-z, 0);
+    x += x > 0 ? -t : t;
+    y += y > 0 ? -t : t;
+
+    const m = 1 / Math.sqrt(x * x + y * y + z * z);
+
+    output[output_offset] = x * m;
+    output[output_offset + 1] = y * m;
+    output[output_offset + 2] = z * m;
+}

package/src/shade/renderer/geometry/normals/geometry_build_tangents.js

@@ -1,4 +1,4 @@
-import { v3_array_add_in_place } from "../../../../core/geom/vec3/v3_array_add_in_place.js";
+import { v3_add } from "../../../../core/geom/vec3/v3_add.js";
 import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
 import { v3_length } from "../../../../core/geom/vec3/v3_length.js";
 import { build_tangent_from_normal } from "./build_tangent_from_normal.js";
@@ -106,13 +106,13 @@ export function geometry_build_tangents(
         const bitangent_y = (vc_y * s1 - vb_y * s2) * r;
         const bitangent_z = (vc_z * s1 - vb_z * s2) * r;
 
-        v3_array_add_in_place(triangle_tangent, a3, tangent_x, tangent_y, tangent_z);
-        v3_array_add_in_place(triangle_tangent, b3, tangent_x, tangent_y, tangent_z);
-        v3_array_add_in_place(triangle_tangent, c3, tangent_x, tangent_y, tangent_z);
+        v3_add(triangle_tangent, a3, tangent_x, tangent_y, tangent_z);
+        v3_add(triangle_tangent, b3, tangent_x, tangent_y, tangent_z);
+        v3_add(triangle_tangent, c3, tangent_x, tangent_y, tangent_z);
 
-        v3_array_add_in_place(triangle_bitangent, a3, bitangent_x, bitangent_y, bitangent_z);
-        v3_array_add_in_place(triangle_bitangent, b3, bitangent_x, bitangent_y, bitangent_z);
-        v3_array_add_in_place(triangle_bitangent, c3, bitangent_x, bitangent_y, bitangent_z);
+        v3_add(triangle_bitangent, a3, bitangent_x, bitangent_y, bitangent_z);
+        v3_add(triangle_bitangent, b3, bitangent_x, bitangent_y, bitangent_z);
+        v3_add(triangle_bitangent, c3, bitangent_x, bitangent_y, bitangent_z);
 
     }
 

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.d.ts

@@ -1,75 +1,219 @@
 /**
- * Per-geometry signed distance fields, one {@link DEFAULT_MESH_RESOLUTION}³ `r32float` tile each, in
- * a {@link GPUTileAtlas3D}.
+ * Most bricks a frame's take may hand out: evaluate and store run {@link MESH_SDF_GROUPS_PER_BRICK}
+ * workgroups a brick in one dispatch row.
+ * @type {number}
+ */
+export const MESH_SDF_BAKE_BUDGET_MAX: number;
+/**
+ * Per-geometry sparse signed distance fields (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6): bricks of 8³
+ * `r8unorm` texels on 7³ voxels, in size classes with levels ({@link MeshSDFLayout}), baked on the
+ * device from the geometry's BLAS and kept by geometry id for as long as something holds the
+ * geometry.
+ *
+ * **Lifetime.** {@link acquire} and {@link release} count holders per geometry id. The first holder
+ * queues a bake; the last one going leaves the cache in place until {@link trim}, which only a user of
+ * the caches calls, so a cache outlives a mode that stops using it and is there when the mode comes
+ * back (D28). {@link forget} drops a geometry the geometry manager has let go of, whatever holds it.
+ * {@link alias} points a skinned clone's id at its source's cache, which readers follow.
+ *
+ * **Side.** A holder says whether it draws both sides of the geometry. A field is baked two-sided
+ * while any of its holders does: its vote then counts no back face, so nothing is inside it (UE 5.4's
+ * rule, which takes the side from the material). A field whose holders' side has changed since its
+ * bake is baked again at the next bake, so holds moved within a frame bake nothing; a field no one
+ * holds keeps the side it has.
  *
- * **A slot is its geometry's id.** The build shader reads `blas_lookup[slot]` and every reader
- * addresses a geometry's tile by that id, so slots are claimed in order and never freed: the
- * atlas's n-th allocation is slot n.
+ * **The bake** ({@link graph_bake}, once a frame) admits queued geometries in request order whose
+ * trees are resident, while the ring has room for every brick they could queue, and runs free,
+ * classify, take, evaluate and store (`bake/`). At most `budget` bricks are evaluated a frame. The
+ * device logs each geometry it completes; the log is read back, and the host turns the header
+ * resident and sends {@link onBaked}. A take held back by the free slots is logged too, and the atlas
+ * and its slot stack double.
  *
- * **No border.** Every reader loads texels with `textureLoad` and clamps the far neighbour of its
- * trilinear tap to the tile's last texel (`sdf_texture_region_sample_linear_uv`), and the texture
- * is bound `unfilterable-float`, so no read leaves its tile. A skirt would be dead texels, and the
- * atlas's skirt is a wrap besides — the far side of a mesh is not the continuation of its near side.
+ * **Cards** (§6.5): a geometry turned resident has its cards placed by the next bake that has room
+ * (`cards/`), in a range sized for any layout of its grid. The placement is logged with the columns
+ * and pages it took; on that readback the geometry gets a range of exactly that size, and the next bake
+ * moves the layout into it and gives the placement's range back. The layout then reaches
+ * {@link cards}, whose card sets — one per (geometry, material) pair — are captured after the bake,
+ * `capture_budget` pages a frame.
+ *
+ * **Readers** bind {@link headers}, {@link indirection}, {@link texture} and {@link MESH_SDF_SAMPLER}
+ * (see {@link write_bindings}) and sample through `mesh_sdf_sample`, which only a resident header
+ * should be given to.
+ *
+ * Device storage is made on first use: a renderer that never asks for a cache allocates nothing.
  */
 export class GPUGeometrySDFManager {
     /**
-     *
      * @param {GPUDevice} device
+     * @param {GPUGeometryManager} geometries whose ids the caches are kept by, and whose trees the bake reads
      */
-    constructor(device: GPUDevice);
+    constructor(device: GPUDevice, geometries: GPUGeometryManager);
     /**
-     * Allocate slots through {@link ensureCapacity} and {@link build_slots}, never on the atlas
-     * directly: a slot handed out of order would no longer be its geometry's id.
-     * @return {GPUTileAtlas3D}
+     * Sent with a geometry id when its cache turns resident, on the frame its completion is read back.
+     * @type {Signal<number>}
      */
-    get atlas(): GPUTileAtlas3D;
+    onBaked: any;
     /**
-     * Individual SDF textures are written here. Replaced when the atlas grows, so take a view after
-     * {@link build_slots}, never across it.
-     * @return {import("../../texture/GPUTextureContext.js").GPUTextureContext}
+     * The card sets: one capture of a geometry's layout per (geometry, material) pair, which their
+     * user acquires and releases. Layouts reach it as they are placed.
+     * @returns {GPUMeshCardSets}
      */
-    get texture(): import("../../texture/GPUTextureContext.js").GPUTextureContext;
+    get cards(): GPUMeshCardSets;
     /**
-     * Resolution in SDF texels for a single geometry along each axis — the tile is a cube — which is
-     * also the stride between tiles: the atlas holds them with no border.
-     * @return {number}
+     * Level 0's voxel, in the geometry's local units, and the bricks per axis past which it grows. A
+     * change rebakes every cache.
+     *
+     * @param {number} voxel_size
+     * @param {number} max_bricks even, at least 2
      */
-    get tile_resolution(): number;
+    configure(voxel_size: number, max_bricks: number): void;
     /**
-     * Tiles along x, y and z — x and y are what `tile_atlas_slot_origin` takes to place a slot. Read it
-     * after {@link build_slots}: when the atlas widens, x or y changes and every tile moves.
-     * @return {number[]}
+     * @returns {number}
      */
-    get atlas_resolution_in_tiles(): number[];
+    get voxel_size(): number;
     /**
-     * Slots the texture holds now.
-     * @return {number}
+     * @returns {number}
      */
-    get capacity(): number;
+    get max_bricks(): number;
     /**
-     * Claim every slot below `min_capacity`, growing the atlas as it fills.
+     * One more holder of a geometry's cache; the first queues its bake.
      *
-     * @param {number} min_capacity
+     * @param {GPUGeometryMetadata} record
+     * @param {boolean} two_sided whether the holder draws both sides of the geometry
      */
-    ensureCapacity(min_capacity: number): void;
-    destroy(): void;
+    acquire(record: GPUGeometryMetadata, two_sided: boolean): void;
     /**
+     * One holder fewer. The cache stays until {@link trim}.
      *
-     * @param {ShadeGPUCommandContext} command_ctx
-     * @param {number[]} slot_indices
-     * @param {GPUGeometryManager} geometries
+     * @param {GPUGeometryMetadata} record
+     * @param {boolean} two_sided as the holder acquired it
+     */
+    release(record: GPUGeometryMetadata, two_sided: boolean): void;
+    /**
+     * Drop the cache of every geometry whose last holder went since the last trim, and is still gone.
+     */
+    trim(): void;
+    /**
+     * The geometry manager has let a geometry go: its cache, or its alias, goes now, whatever holds
+     * it.
+     *
+     * @param {GPUGeometryMetadata} record
+     */
+    forget(record: GPUGeometryMetadata): void;
+    /**
+     * Readers of `clone` read `source`'s cache: the hook for a skinned clone, whose unskinned shape is
+     * its source's (§6.3). Written once; it follows the source through its bake.
+     *
+     * @param {GPUGeometryMetadata} clone
+     * @param {GPUGeometryMetadata} source
+     */
+    alias(clone: GPUGeometryMetadata, source: GPUGeometryMetadata): void;
+    /**
+     * What a reader finds in the geometry's header.
+     *
+     * @param {GPUGeometryMetadata} record
+     * @returns {MeshSDFState}
+     */
+    state_of(record: GPUGeometryMetadata): MeshSDFState;
+    /**
+     * Geometries whose layout was coarsened by the cap, of those baked: coarser than asked.
+     * @returns {number}
+     */
+    get coarsened_count(): number;
+    /**
+     * @returns {number}
+     */
+    get resident_count(): number;
+    /**
+     * Geometries admitted and not yet complete.
+     * @returns {number}
      */
-    build_slots(command_ctx: ShadeGPUCommandContext, slot_indices: number[], geometries: GPUGeometryManager): void;
+    get baking_count(): number;
     /**
-     * Downloads raw data for a given slot. Mainly for debugging.
-     * @param {number} slot
-     * @return {Promise<Float32Array>}
+     * Geometries requested and not yet admitted.
+     * @returns {number}
      */
-    download_slot(slot: number): Promise<Float32Array>;
+    get queued_count(): number;
+    /**
+     * Frames whose take the free slots held back, as read back.
+     * @returns {number}
+     */
+    get starved_frames(): number;
+    /**
+     * Bricks evaluate has been handed, as read back: classify's survivors, stale ones included.
+     * @returns {number}
+     */
+    get bricks_evaluated(): number;
+    /**
+     * Free slots of the atlas before the last take read back.
+     * @returns {number}
+     */
+    get free_slots(): number;
+    /**
+     * Frames whose bake was skipped because its log could not be read back.
+     * @returns {number}
+     */
+    get skipped_frames(): number;
+    /**
+     * Slots the brick atlas holds.
+     * @returns {number}
+     */
+    get slot_capacity(): number;
+    /**
+     * Every geometry's header, by geometry id. Replaced when it grows; take it each frame.
+     * @returns {GPUBuffer}
+     */
+    get headers(): GPUBuffer;
+    /**
+     * Every brick's entry: a slot or EMPTY. Replaced when it grows; take it each frame.
+     * @returns {GPUBuffer}
+     */
+    get indirection(): GPUBuffer;
+    /**
+     * The brick atlas, `r8unorm`. Replaced when it grows; take a view each frame.
+     * @returns {import("../../texture/GPUTextureContext.js").GPUTextureContext}
+     */
+    get texture(): import("../../texture/GPUTextureContext.js").GPUTextureContext;
+    /**
+     * Put what `mesh_sdf_sample` and `mesh_sdf_header` read into a reader's bindings, under the names
+     * they take.
+     *
+     * @param {Object} bindings
+     * @returns {Object} bindings
+     */
+    write_bindings(bindings: any): any;
+    /**
+     * @returns {number} bytes
+     */
+    get gpu_memory_usage(): number;
+    /**
+     * Record the frame's bake: queue again what is held for the other side than it was baked for, free
+     * what was given back, classify what is admitted, take, evaluate and store up to `budget` bricks,
+     * place the cards of what turned resident and move placed layouts into their ranges. Then, with a
+     * `capture_budget`, capture up to that many pages of card sets. Records nothing when there is
+     * nothing to do.
+     *
+     * @param {Object} options
+     * @param {FrameGraph} options.graph
+     * @param {number} options.budget bricks evaluated at most, `mesh_sdf_bake_budget`
+     * @param {number} [options.capture_budget] card pages captured at most, `card_capture_budget`; 0
+     *        captures nothing
+     * @param {GPUResidentMaterialContext|null} [options.materials] what the capture shades with, as it
+     *        stands this frame; needed with a `capture_budget`
+     */
+    graph_bake({ graph, budget, capture_budget, materials }: {
+        graph: FrameGraph;
+        budget: number;
+        capture_budget?: number;
+        materials?: GPUResidentMaterialContext | null;
+    }): void;
+    destroy(): void;
     #private;
 }
-export type ShadeGPUCommandContext = import("../../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext;
+export type FrameGraph = import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
 export type GPUGeometryManager = import("../GPUGeometryManager.js").GPUGeometryManager;
-export type GPUGeometryBVHManager = import("../bvh/GPUGeometryBVHManager.js").GPUGeometryBVHManager;
-import { GPUTileAtlas3D } from "../../texture/atlas/GPUTileAtlas3D.js";
+export type GPUGeometryMetadata = import("../GPUGeometryMetadata.js").GPUGeometryMetadata;
+export type GPUResidentMaterialContext = import("../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext;
+import { GPUMeshCardSets } from "./cards/GPUMeshCardSets.js";
+import { MeshSDFState } from "./MESH_SDF.js";
 //# sourceMappingURL=GPUGeometrySDFManager.d.ts.map

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUGeometrySDFManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;GAYG;AACH;IAaI;;;OAGG;IACH,+BAgBC;IAED;;;;OAIG;IACH,4BAEC;IAED;;;;OAIG;IACH,8EAEC;IAED;;;;OAIG;IACH,8BAEC;IAED;;;;OAIG;IACH,0CASC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,6BAFW,MAAM,QAYhB;IAED,gBAEC;IAGD;;;;;OAKG;IACH,yBAJW,sBAAsB,gBACtB,MAAM,EAAE,cACR,kBAAkB,QA4D5B;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACL,QAAQ,YAAY,CAAC,CAKhC;;CACJ;qCA7NY,OAAO,2CAA2C,EAAE,sBAAsB;iCAC1E,OAAO,0BAA0B,EAAE,kBAAkB;oCACrD,OAAO,iCAAiC,EAAE,qBAAqB;+BAP7C,uCAAuC"}
+{"version":3,"file":"GPUGeometrySDFManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js"],"names":[],"mappings":"AAqIA;;;;GAIG;AACH,uCAFU,MAAM,CAEuH;AAgDvI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH;IAwPI;;;OAGG;IACH,2CAFW,kBAAkB,EAS5B;IAvPD;;;OAGG;IACH,aAAuB;IAqPvB;;;;OAIG;IACH,6BAEC;IAED;;;;;;OAMG;IACH,sBAHW,MAAM,cACN,MAAM,QAmChB;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,yBAEC;IAED;;;;;OAKG;IACH,gBAHW,mBAAmB,aACnB,OAAO,QAsBjB;IAED;;;;;OAKG;IACH,gBAHW,mBAAmB,aACnB,OAAO,QAqBjB;IAED;;OAEG;IACH,aAYC;IAED;;;;;OAKG;IACH,eAFW,mBAAmB,QAe7B;IAED;;;;;;OAMG;IACH,aAHW,mBAAmB,UACnB,mBAAmB,QA0B7B;IAQD;;;;;OAKG;IACH,iBAHW,mBAAmB,GACjB,YAAY,CAaxB;IAED;;;OAGG;IACH,8BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAUC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,+BAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;OAGG;IACH,4BAEC;IAED;;;OAGG;IACH,yBAIC;IAED;;;OAGG;IACH,6BAIC;IAED;;;OAGG;IACH,8EAIC;IAED;;;;;;OAMG;IACH,mCAOC;IAED;;OAEG;IACH,+BAcC;IAED;;;;;;;;;;;;;;OAcG;IACH;QAP+B,KAAK,EAAzB,UAAU;QACM,MAAM,EAAtB,MAAM;QACW,cAAc,GAA/B,MAAM;QAEoC,SAAS,GAAnD,0BAA0B,GAAC,IAAI;aA+DzC;IAk+BD,gBAsBC;;CACJ;yBA91DY,OAAO,8DAA8D,EAAE,UAAU;iCACjF,OAAO,0BAA0B,EAAE,kBAAkB;kCACrD,OAAO,2BAA2B,EAAE,mBAAmB;yCACvD,OAAO,uDAAuD,EAAE,0BAA0B;gCAjBzC,4BAA4B;6BAQtC,eAAe"}