@woosh/meep-engine 3.41.0 → 3.43.0

package/src/shade/renderer/geometry/util/geometry_simplify_redundant_topology.js

@@ -2,7 +2,7 @@ import { v3_array_normalize } from "../../../../core/geom/vec3/v3_array_normaliz
 import { v3_cross_array } from "../../../../core/geom/vec3/v3_cross_array.js";
 import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
 import { Attribute } from "../Attribute.js";
-import { Geometry } from "../Geometry.js";
+import { Geometry, GeometryFlags } from "../Geometry.js";
 import { geometry_deduplicate_vertices } from "../geometry_deduplicate_vertices.js";
 import { StandardAttributes } from "../StandardAttributes.js";
 
@@ -363,7 +363,7 @@ function apply_remap_and_compact(source, remap) {
     // Build new geometry with compacted attribute arrays
     const result = new Geometry();
     result.name = source.name;
-    result.flags = source.flags;
+    result.flags = source.flags | GeometryFlags.BoundsNeedUpdate;
 
     for (const src_attr of source.attributes) {
         const stride = src_attr.spec.itemSize;

package/src/shade/renderer/geometry/virtual/format/vgeo_validate_container.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_validate_container.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/format/vgeo_validate_container.js"],"names":[],"mappings":"AA+xDA;;;;;;;;;GASG;AACH,gDAHW,YAAY,GACV,QAAQ,UAAU,EAAE,CAAC,CAqFjC;6BA53D4B,4CAA4C;2BAoD9C,iBAAiB"}
+{"version":3,"file":"vgeo_validate_container.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/format/vgeo_validate_container.js"],"names":[],"mappings":"AAk3DA;;;;;;;;;GASG;AACH,gDAHW,YAAY,GACV,QAAQ,UAAU,EAAE,CAAC,CAuFjC;6BAj9D4B,4CAA4C;2BAoD9C,iBAAiB"}

package/src/shade/renderer/geometry/virtual/format/vgeo_validate_container.js

@@ -381,6 +381,12 @@ function check_header(buffer, out) {
         usable = false;
     }
 
+    if (root_page_offset >= directory_offset) {
+        out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `root_page_offset ${root_page_offset} is not before directory_offset ${directory_offset}`));
+
+        usable = false;
+    }
+
     // Byte 103 was reserved through `format_version` 5 and is `level_count`'s high byte from 6 on,
     // so there is nothing left to check between it and `source_vertex_count`; the read above landed
     // at 104 and the one below expects to start there.
@@ -425,6 +431,63 @@ function check_header(buffer, out) {
     return usable;
 }
 
+/**
+ * @param {BinaryBuffer} buffer with a checked, in-file level table
+ * @param {number} level_count
+ * @param {number} total_clusters
+ * @param {number} total_groups
+ * @param {VGeoDefect[]} out
+ */
+function check_levels(buffer, level_count, total_clusters, total_groups, out) {
+    let counted_clusters = 0;
+    let counted_groups = 0;
+
+    for (let level = 0; level < level_count; level++) {
+        const base = VGEO_HEADER_SIZE + level * VGEO_LEVEL_RECORD_SIZE;
+
+        buffer.position = base;
+
+        const min_error = buffer.readFloat32();
+        const max_error = buffer.readFloat32();
+
+        if (!Number.isFinite(min_error) || min_error < 0) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: min_error ${min_error} must be finite and non-negative`));
+        }
+
+        if (!Number.isFinite(max_error) || max_error < 0) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: max_error ${max_error} must be finite and non-negative`));
+        }
+
+        if (min_error > max_error) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: min_error ${min_error} exceeds max_error ${max_error}`));
+        }
+
+        buffer.position = base + 12;
+
+        const cluster_count = buffer.readUint32();
+        const group_count = buffer.readUint32();
+
+        if (cluster_count === 0) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: cluster_count is 0`));
+        }
+
+        if (group_count === 0) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: group_count is 0`));
+        }
+
+        counted_clusters += cluster_count;
+        counted_groups += group_count;
+    }
+
+    if (counted_clusters !== total_clusters) {
+        out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level table holds ${counted_clusters} clusters, header says ${total_clusters}`));
+    }
+
+    if (counted_groups !== total_groups) {
+        out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level table holds ${counted_groups} groups, header says ${total_groups}`));
+    }
+}
+
 /**
  * @param {BinaryBuffer} buffer whole file
  * @param {VGeoDefect[]} out
@@ -865,6 +928,7 @@ function check_page_nodes(pages, page_groups, page_clusters, out) {
          * @type {Int32Array}
          */
         const group_hits = new Int32Array(groups.length);
+        const node_hits = new Int32Array(nodes.length);
 
         let structural = true;
 
@@ -902,12 +966,31 @@ function check_page_nodes(pages, page_groups, page_clusters, out) {
 
                 structural = false;
             }
+
+            for (let i = 0; i < node.child_count; i++) {
+                node_hits[node.child_first + i]++;
+            }
         });
 
         if (!structural) {
             continue;
         }
 
+        // Strictly forward children with one parent per non-root node form one rooted tree.
+        for (let index = 0; index < nodes.length; index++) {
+            const expected = index === 0 ? 0 : 1;
+
+            if (node_hits[index] !== expected) {
+                out.push(new VGeoDefect(VGEO_DEFECT.PAGE_LAYOUT, `page ${page.page_index} node ${index}: has ${node_hits[index]} incoming node references, expected ${expected}`));
+
+                structural = false;
+            }
+        }
+
+        if (!structural) {
+            continue;
+        }
+
         const unreached = group_hits.reduce((count, hits) => count + (hits === 0 ? 1 : 0), 0);
         const repeated = group_hits.reduce((count, hits) => count + (hits > 1 ? 1 : 0), 0);
 
@@ -1847,6 +1930,8 @@ export async function vgeo_validate_container(buffer) {
     const total_clusters = Number(buffer.readUint64());
     const total_groups = Number(buffer.readUint64());
 
+    check_levels(buffer, level_count, total_clusters, total_groups, out);
+
     buffer.position = VGEO_HEADER_OFFSET.OBJECT_SPHERE;
 
     const object_sphere = read_sphere(buffer);

package/src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUVirtualGeometryRuntime.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAiHI;;;;;;;;;;;;;;;OAeG;IACH;QAd2C,IAAI,EAApC,sBAAsB;QACL,aAAa,GAA9B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QAEW,mBAAmB,GAApC,MAAM;QAEW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QAEW,qBAAqB,GAAtC,MAAM;QACW,aAAa,GAA9B,MAAM;OAgFhB;IAzKD;;;;OAIG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,cAFU,OAAO,CAEG;IAiKpB;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;;OAIG;IACH,gCAEC;IAWD;;;;;;OAMG;IACH,iCAKC;IArBD;;;;OAIG;IACH,4BAEC;IAgBD;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;OAEG;IACH;;;;;;;;MAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH;QAHgC,IAAI,EAAzB,WAAW;QACT,IAAI,CAoChB;IAwBD;;;;;;;;;;OAUG;IACH,cAHW,WAAW,GACT,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,eAFa,WAAW,EAAE,EAAE,CAI3B;IAED;;;;;;;;;OASG;IACH,mBAHW,UAAU,GACR,MAAM,CAkClB;IAED;;;;;;;;;;;;OAYG;IACH,wBAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAJ2B,iBAAiB,EAAjC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACJ,IAAI,CAahB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,aAFa,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAOhB;;CACJ;qCArnBY,OAAO,6BAA6B,EAAE,sBAAsB;0BAC5D,OAAO,kBAAkB,EAAE,WAAW;yBACtC,OAAO,iEAAiE,EAAE,UAAU"}
+{"version":3,"file":"GPUVirtualGeometryRuntime.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAmHI;;;;;;;;;;;;;;;OAeG;IACH;QAd2C,IAAI,EAApC,sBAAsB;QACL,aAAa,GAA9B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QAEW,mBAAmB,GAApC,MAAM;QAEW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QAEW,qBAAqB,GAAtC,MAAM;QACW,aAAa,GAA9B,MAAM;OAgFhB;IA3KD;;;;OAIG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,cAFU,OAAO,CAEG;IAmKpB;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;;OAIG;IACH,gCAEC;IAWD;;;;;;OAMG;IACH,iCAKC;IArBD;;;;OAIG;IACH,4BAEC;IAgBD;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;OAEG;IACH;;;;;;;;MAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH;QAHgC,IAAI,EAAzB,WAAW;QACT,IAAI,CAqChB;IAwBD;;;;;;;;;;OAUG;IACH,cAHW,WAAW,GACT,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,eAFa,WAAW,EAAE,EAAE,CAI3B;IAED;;;;;;;;;OASG;IACH,mBAHW,UAAU,GACR,MAAM,CAkClB;IAED;;;;;;;;;;;;OAYG;IACH,wBAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAJ2B,iBAAiB,EAAjC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACJ,IAAI,CAgBhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,aAFa,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAOhB;;CACJ;qCA3nBY,OAAO,6BAA6B,EAAE,sBAAsB;0BAC5D,OAAO,kBAAkB,EAAE,WAAW;yBACtC,OAAO,iEAAiE,EAAE,UAAU"}

package/src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js

@@ -150,6 +150,8 @@ export class GPUVirtualGeometryRuntime {
      */
     #instance_capacity = 0;
 
+    #collections_declared = false;
+
     /**
      * @type {number}
      */
@@ -414,6 +416,7 @@ export class GPUVirtualGeometryRuntime {
          that runs against it appends nothing rather than appending past the end of a collection
          whose real size it was never told.
          */
+        this.#collections_declared = false;
         this.#instance_capacity = 0;
         this.#meshlet_capacity = 0;
     }
@@ -583,13 +586,16 @@ export class GPUVirtualGeometryRuntime {
         assert.isNonNegativeInteger(instance_capacity, 'instance_capacity');
         assert.isNonNegativeInteger(meshlet_capacity, 'meshlet_capacity');
 
-        this.#instance_capacity = this.#instance_capacity === 0
-            ? instance_capacity
-            : Math.min(this.#instance_capacity, instance_capacity);
+        if (!this.#collections_declared) {
+            this.#instance_capacity = instance_capacity;
+            this.#meshlet_capacity = meshlet_capacity;
+            this.#collections_declared = true;
+
+            return;
+        }
 
-        this.#meshlet_capacity = this.#meshlet_capacity === 0
-            ? meshlet_capacity
-            : Math.min(this.#meshlet_capacity, meshlet_capacity);
+        this.#instance_capacity = Math.min(this.#instance_capacity, instance_capacity);
+        this.#meshlet_capacity = Math.min(this.#meshlet_capacity, meshlet_capacity);
     }
 
     /**

package/src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGeoPageFetcher.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IAgFI;;;;;;OAMG;IACH;QAL4B,YAAY,GAA7B,MAAM;QACuB,WAAW,SAA5B,MAAM;OAS5B;IAED;;OAEG;IACH,2BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,qCAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;;;;;OAOG;IACH,cAPW,mBAAmB,cACnB,MAAM,gBACN,MAAM,cACN,MAAM,WACN,WAAW,GACT,QAAQ,QAAQ,CAAC,CAqB7B;IAED;;;;;;OAMG;IACH,eAHW,mBAAmB,GACjB,MAAM,CAkClB;IAED;;;;;OAKG;IACH,WAFa,IAAI,CAsBhB;;CAgOJ;kCAzdY,OAAO,uCAAuC,EAAE,mBAAmB;uBACnE,OAAO,4BAA4B,EAAE,QAAQ"}
+{"version":3,"file":"VGeoPageFetcher.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IAgFI;;;;;;OAMG;IACH;QAL4B,YAAY,GAA7B,MAAM;QACuB,WAAW,SAA5B,MAAM;OAS5B;IAED;;OAEG;IACH,2BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,qCAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;;;;;OAOG;IACH,cAPW,mBAAmB,cACnB,MAAM,gBACN,MAAM,cACN,MAAM,WACN,WAAW,GACT,QAAQ,QAAQ,CAAC,CA4B7B;IAED;;;;;;OAMG;IACH,eAHW,mBAAmB,GACjB,MAAM,CAkClB;IAED;;;;;OAKG;IACH,WAFa,IAAI,CAsBhB;;CAgOJ;kCAheY,OAAO,uCAAuC,EAAE,mBAAmB;uBACnE,OAAO,4BAA4B,EAAE,QAAQ"}

package/src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.js

@@ -174,6 +174,13 @@ export class VGeoPageFetcher {
             );
         }
 
+        if (signal?.aborted) {
+            return Promise.reject(new VGeoFetchError(
+                `page ${page_index}: the fetch was cancelled`, false,
+                String(signal.reason?.message ?? signal.reason)
+            ));
+        }
+
         if (this.#worker_count > 0 && !this.#no_workers && reader.source.descriptor !== undefined) {
             const worker = this.#worker_for();
 

package/src/shade/renderer/geometry/virtual/runtime/VGeoRuntimeTables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGeoRuntimeTables.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoRuntimeTables.js"],"names":[],"mappings":"AAmBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH;IAmKI;;;;;;;;OAQG;IACH;QAP4B,aAAa,GAA9B,MAAM;QACW,SAAS,GAA1B,MAAM;QAEW,UAAU,GAA3B,MAAM;QACW,YAAY,GAA7B,MAAM;QACW,iBAAiB,GAAlC,MAAM;OA6BhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;OAWG;IACH,8BALW,MAAM,qBACN,MAAM,GACJ,MAAM,CAiDlB;IAED;;;;;;OAMG;IACH,kCAJW,MAAM,GACJ,MAAM,EAAE,CAgDpB;IAED;;;;OAIG;IACH,6BAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,0BAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,qBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;OAGG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;OAQG;IACH,sBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,sBARW,MAAM,QACN,QAAQ,gBACR,MAAM,GACJ,MAAM,CAkFlB;IAED;;;;;OAKG;IACH,qBAHW,QAAQ,GACN,MAAM,CAOlB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;;;OAMG;IACH,uBAHW,MAAM,GACJ,IAAI,MAAM,CAAC,CAIvB;IAED;;;;;;;;;;OAUG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,uBAFa,MAAM,EAAE,CAQpB;IAwWD;;;;;;;;;;;;OAYG;IACH,+BALW,MAAM,SACN,MAAM,cACN,OAAO,GACL,IAAI,CAUhB;IAED;;;;OAIG;IACH,8BAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,GACJ,MAAM,EAAE,CAapB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,MAAM,EAAE,CAOpB;IAED;;;;;;OAMG;IACH,2BAJW,MAAM,gBACN,MAAM,GACJ,OAAO,CAYnB;;CA4DJ;uBAjtCY,OAAO,4BAA4B,EAAE,QAAQ"}
+{"version":3,"file":"VGeoRuntimeTables.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoRuntimeTables.js"],"names":[],"mappings":"AAmBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH;IAmKI;;;;;;;;OAQG;IACH;QAP4B,aAAa,GAA9B,MAAM;QACW,SAAS,GAA1B,MAAM;QAEW,UAAU,GAA3B,MAAM;QACW,YAAY,GAA7B,MAAM;QACW,iBAAiB,GAAlC,MAAM;OA6BhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;OAWG;IACH,8BALW,MAAM,qBACN,MAAM,GACJ,MAAM,CAmDlB;IAED;;;;;;OAMG;IACH,kCAJW,MAAM,GACJ,MAAM,EAAE,CAgDpB;IAED;;;;OAIG;IACH,6BAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,0BAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,qBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;OAGG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;OAQG;IACH,sBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,sBARW,MAAM,QACN,QAAQ,gBACR,MAAM,GACJ,MAAM,CAkFlB;IAED;;;;;OAKG;IACH,qBAHW,QAAQ,GACN,MAAM,CAOlB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;;;OAMG;IACH,uBAHW,MAAM,GACJ,IAAI,MAAM,CAAC,CAIvB;IAED;;;;;;;;;;OAUG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,uBAFa,MAAM,EAAE,CAQpB;IAwWD;;;;;;;;;;;;OAYG;IACH,+BALW,MAAM,SACN,MAAM,cACN,OAAO,GACL,IAAI,CAUhB;IAED;;;;OAIG;IACH,8BAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,GACJ,MAAM,EAAE,CAapB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,MAAM,EAAE,CAOpB;IAED;;;;;;OAMG;IACH,2BAJW,MAAM,gBACN,MAAM,GACJ,OAAO,CAYnB;;CA4DJ;uBAntCY,OAAO,4BAA4B,EAAE,QAAQ"}

package/src/shade/renderer/geometry/virtual/runtime/VGeoRuntimeTables.js

@@ -374,7 +374,7 @@ export class VGeoRuntimeTables {
         assert.isNonNegativeInteger(page_count, 'page_count');
         assert.greaterThan(page_count, 0, 'page_count');
 
-        const recycled = this.#free_geometry_rows.pop();
+        const recycled = this.#free_geometry_rows[this.#free_geometry_rows.length - 1];
 
         const row = recycled ?? this.#geometry_row_high_water;
 
@@ -396,6 +396,8 @@ export class VGeoRuntimeTables {
 
         if (recycled === undefined) {
             this.#geometry_row_high_water = row + 1;
+        } else {
+            this.#free_geometry_rows.pop();
         }
 
         this.#geometry_allocations.set(row, allocation);

package/src/shade/renderer/lightmap/bake/shader_lightmap_denoise_sh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_lightmap_denoise_sh.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/lightmap/bake/shader_lightmap_denoise_sh.js"],"names":[],"mappings":"AA2BA;;;GAGG;AACH,2CAFU,SAAS,CAkCjB;AAyHF,qDAOE;0BAvLwB,oCAAoC;4BAClC,6BAA6B"}
+{"version":3,"file":"shader_lightmap_denoise_sh.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/lightmap/bake/shader_lightmap_denoise_sh.js"],"names":[],"mappings":"AA2BA;;;GAGG;AACH,2CAFU,SAAS,CAyCjB;AAyHF,qDAOE;0BA9LwB,oCAAoC;4BAClC,6BAA6B"}

package/src/shade/renderer/lightmap/bake/shader_lightmap_denoise_sh.js

@@ -39,8 +39,15 @@ fn estimate_sh_similarity(
     // extract dominant luma direction
     // Metro encodes SH coeffcients in axis-aligned way (L11, L1_1, L10) with L00 being in forth position (w)
     
-    let a_luma_direction = a.Y.xyz / a.Y.w;
-    let b_luma_direction = b.Y.xyz / b.Y.w;
+    // Zero DC is black and has no dominant direction.
+    var a_luma_direction = vec3<f32>(0.0);
+    var b_luma_direction = vec3<f32>(0.0);
+    if (a.Y.w != 0.0) {
+        a_luma_direction = a.Y.xyz / a.Y.w;
+    }
+    if (b.Y.w != 0.0) {
+        b_luma_direction = b.Y.xyz / b.Y.w;
+    }
 
     const DIRECTION_PHI = 10.0;
 
@@ -189,4 +196,4 @@ export const shader_lightmap_denoise_sh = ImageShader.from({
         resources,
     }),
     targets: LIGHTMAP_SH_COLOR_TARGETS_DESCRIPTOR
-})
+})

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#261@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#265@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/particles/DESIGN.md

@@ -791,14 +791,18 @@ it is evaluated per pixel (`chunk_particle_lighting`, the model in `chunk_partic
 a vertex need not be on screen, and one quad can span the frustum.
 
 - **Direct light comes from the froxel irradiance volume** (`volumetrics/chunk_volumetrics_irradiance_sh`),
-  which `shader_volumetrics_build_lighting` writes in the loop that lights the fog: every
-  directional, point and spot light at the froxel, shadowed, attenuated by the fog toward it, stored
-  as luma SH2 + constant chroma (Metro's L1 YCoCg, 6 coefficients in two `rgba16float` volumes, since
-  `rg16float` is not a storage format without `texture-formats-tier1`). The volume rides the
-  orchestrator to side channels as `volumetrics_irradiance`. Resolution is the fog's — 16 px tiles
-  and 64 slices — so light and shadow edges inside a particle are soft. idTech 8 builds the same
-  volume in the same pass (Sousa, SIGGRAPH 2025, p.29); Ghost of Tsushima lights particles from its
-  haze grid the same way. Chosen over per-pixel forward shading (UE's most expensive mode, and a
+  which `shader_volumetrics_build_irradiance` writes: every directional, point and spot light at a
+  point jittered through the froxel every frame, shadowed, stored as luma SH2 + constant chroma (Metro's L1 YCoCg, 6 coefficients
+  in two `rgba16float` volumes, since `rg16float` is not a storage format without
+  `texture-formats-tier1`). The volume rides the orchestrator to side channels as
+  `volumetrics_irradiance`. Resolution is the fog's froxel grid — 16 px tiles and 64 slices — so light
+  and shadow edges inside a particle are soft. idTech 8 builds the same volume (Sousa, SIGGRAPH 2025,
+  p.29); Ghost of Tsushima lights particles from its haze grid the same way. idTech 8 builds it in the
+  pass that lights its fog, and this one did too until 2026-10-09, dimming each light by the medium
+  on its way in. That tied particle lighting to the fog's whole chain (media, sun cascades, sky LUTs),
+  so the fog could not be skipped in a scene without volumes. It now has its own pass with no medium
+  in it: a lit particle is lit as the surfaces beside it are, which the deferred and forward paths
+  never dimmed either, and the fog is composited over both. Chosen over per-pixel forward shading (UE's most expensive mode, and a
   flat card lit that way goes black from behind), per-vertex/per-particle lighting (the light
   clusters are screen-space: a point off screen has no light list, the artefact that moved idTech 8
   off it) and a per-particle lighting atlas (DOOM 2016, CoD IW: best-looking, but it needs a
@@ -814,7 +818,7 @@ a vertex need not be on screen, and one quad can span the frustum.
 - **Indirect light is in the same volume**, whatever the renderer's `indirect_lighting_mode`. The
   froxel GI stage (`volumetrics/gi/`) starts the volume with one concrete module per mode — IBL,
   Brick4, LPV — each asking its source what radiance arrives at the froxel's centre, as RGB SH2,
-  and `shader_volumetrics_build_lighting` adds the lights to that. The particle knows no mode: a new
+  and `shader_volumetrics_build_irradiance` adds the lights to that. The particle knows no mode: a new
   GI system is one more module. IBL's source is `GPULightCollection.environment_sh`, the
   environment projected to radiance SH2 when it changes (`shader_project_environment_sh`); Brick4
   interpolates its probes (SH3, truncated) with a zero normal, which weighs every probe of the

package/src/shade/renderer/particles/shaders/chunk_particle_lighting.d.ts

@@ -4,7 +4,7 @@
  * returns what it reflects and transmits (`chunk_particle_lighting_model`), from the froxel
  * irradiance volume (`chunk_volumetrics_irradiance_sh`) at the fragment: the renderer's indirect
  * lighting, whichever mode it runs (the froxel GI stage, `volumetrics/gi/`), plus every directional,
- * point and spot light, shadowed, and attenuated by the fog on its way in. One trilinear read of each
+ * point and spot light, shadowed, as the surfaces around the particle receive them. One trilinear read of each
  * of its two textures, so the cost grows with neither the lights nor the GI; the price is resolution —
  * a froxel is 16 pixels across and a slice deep, and light and shadow edges inside a particle are that
  * soft.

package/src/shade/renderer/particles/shaders/chunk_particle_lighting.js

@@ -10,7 +10,7 @@ import { chunk_particle_lighting_model } from "./chunk_particle_lighting_model.j
  * returns what it reflects and transmits (`chunk_particle_lighting_model`), from the froxel
  * irradiance volume (`chunk_volumetrics_irradiance_sh`) at the fragment: the renderer's indirect
  * lighting, whichever mode it runs (the froxel GI stage, `volumetrics/gi/`), plus every directional,
- * point and spot light, shadowed, and attenuated by the fog on its way in. One trilinear read of each
+ * point and spot light, shadowed, as the surfaces around the particle receive them. One trilinear read of each
  * of its two textures, so the cost grows with neither the lights nor the GI; the price is resolution —
  * a froxel is 16 pixels across and a slice deep, and light and shadow edges inside a particle are that
  * soft.

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#192@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#193@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts

@@ -99,8 +99,9 @@ export type AVBOITSideChannel = {
      * nothing into the volume passes `0`.
      * `volumetrics_irradiance` is what a fragment standing in a froxel is lit by
      * (`chunk_volumetrics_irradiance_sh`), for a channel whose fragments are lit: the renderer's
-     * indirect lighting, whichever mode it runs, and the scene's lights, shadowed and attenuated by
-     * the fog, written by the pass that lights the fog.
+     * indirect lighting, whichever mode it runs, and the scene's lights, shadowed — lit as the
+     * surfaces around it are, with no fog on the way in. Its own pass builds it, whether or not the
+     * scene has fog.
      */
     avboit_draw: (args: {
         graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,sBAA4B,EAAE,OAAO,uCAAuC,EAAE,yBAAyB,CAAC;KACrG,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAKtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAU9D,CAAC,IAAI,EAAE,OAAO,iCAAiC,EAAE,cAAc,KAAK,OAAO"}
+{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,sBAA4B,EAAE,OAAO,uCAAuC,EAAE,yBAAyB,CAAC;KACrG,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAKtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAW9D,CAAC,IAAI,EAAE,OAAO,iCAAiC,EAAE,cAAc,KAAK,OAAO"}

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js

@@ -84,8 +84,9 @@
  *     nothing into the volume passes `0`.
  *     `volumetrics_irradiance` is what a fragment standing in a froxel is lit by
  *     (`chunk_volumetrics_irradiance_sh`), for a channel whose fragments are lit: the renderer's
- *     indirect lighting, whichever mode it runs, and the scene's lights, shadowed and attenuated by
- *     the fog, written by the pass that lights the fog.
+ *     indirect lighting, whichever mode it runs, and the scene's lights, shadowed — lit as the
+ *     surfaces around it are, with no fog on the way in. Its own pass builds it, whether or not the
+ *     scene has fog.
  * @property {(view: import("../../../view/GPUViewContext.js").GPUViewContext) => boolean} [avboit_is_empty] whether the channel would add nothing for this view;
  *     asked before the orchestrator records, and a channel that answers `true` is not asked for
  *     anything else in that frame.

package/src/shade/renderer/scene/GPUSceneContext.d.ts

@@ -38,6 +38,13 @@ export class GPUSceneContext {
      */
     get scene(): Scene;
     get volumetrics(): GPUSceneVolumetrics;
+    /**
+     * Not necessarily current: a reader calls {@link GPUSky#update} first, which does the work the
+     * first time and nothing after.
+     *
+     * @returns {GPUSky}
+     */
+    get sky(): GPUSky;
     /**
      *
      * @returns {GPULightCollection}
@@ -186,7 +193,7 @@ export class GPUSceneContext {
      * Release this context's virtual geometry — everything {@link enable_virtual_geometry} built,
      * so that a host tears a scene down by destroying the renderer and nothing of the streaming loop
      * is left for it to find — then its rows, its database, its TLAS, its lights, its probe volume,
-     * its volumetrics, its volumetric light map, its animation and its skinning: every buffer the
+     * its volumetrics, its sky, its volumetric light map, its animation and its skinning: every buffer the
      * context made. Safe to call twice, and on a context that never enabled virtual geometry.
      */
     destroy(): void;
@@ -205,6 +212,7 @@ export type GPURecordWriter = import("../buffer/table/serde/generate_record_writ
 import { Brick4LightMap } from "../global_illumination/brick4/Brick4LightMap.js";
 import { Scene } from "./Scene.js";
 import { GPUSceneVolumetrics } from "../volumetrics/GPUSceneVolumetrics.js";
+import { GPUSky } from "../atmosphere/GPUSky.js";
 import { GPULightCollection } from "../light/GPULightCollection.js";
 import { GPULightProbeVolume } from "../global_illumination/lpv/GPULightProbeVolume.js";
 import { GPUInstancesAccelerationStructure } from "./GPUInstancesAccelerationStructure.js";

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAoCf;IA/KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA8HD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAiBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAzuBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAsEA;;;;;;;;;GASG;AACH;IA4JI;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAsCf;IAnMD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAgID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAkBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BA9vBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAvBvD,iDAAiD;sBAK1D,YAAY;oCADE,uCAAuC;uBAFpD,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAKrC,wCAAwC;0CAhBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAQrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAfpC,wCAAwC"}

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -11,6 +11,7 @@ import { GPUAnimationManager } from "../animation/GPUAnimationManager.js";
 import { GPUDatabase } from "../buffer/table/GPUDatabase.js";
 import { Brick4LightMap } from "../global_illumination/brick4/Brick4LightMap.js";
 import { GPULightProbeVolume } from "../global_illumination/lpv/GPULightProbeVolume.js";
+import { GPUSky } from "../atmosphere/GPUSky.js";
 import { GPULightCollection } from "../light/GPULightCollection.js";
 import { GPUSceneVolumetrics } from "../volumetrics/GPUSceneVolumetrics.js";
 import { Scene } from "./Scene.js";
@@ -125,6 +126,24 @@ export class GPUSceneContext {
         return this.#volumetrics;
     }
 
+    /**
+     * The atmosphere's LUTs, built once for the scene and read by every view that needs them. They
+     * depend on the atmosphere's constants alone, so no view owns a copy.
+     *
+     * @type {GPUSky}
+     */
+    #sky;
+
+    /**
+     * Not necessarily current: a reader calls {@link GPUSky#update} first, which does the work the
+     * first time and nothing after.
+     *
+     * @returns {GPUSky}
+     */
+    get sky() {
+        return this.#sky;
+    }
+
     /**
      * @type {GPULightCollection}
      */
@@ -253,6 +272,8 @@ export class GPUSceneContext {
             scene.volumetrics
         );
 
+        this.#sky = new GPUSky(graphics);
+
         this.#animation_manager = new GPUAnimationManager(device, `GPUSceneContext[${this.id}]/Animation`, this);
     }
 
@@ -718,7 +739,7 @@ export class GPUSceneContext {
      * Release this context's virtual geometry — everything {@link enable_virtual_geometry} built,
      * so that a host tears a scene down by destroying the renderer and nothing of the streaming loop
      * is left for it to find — then its rows, its database, its TLAS, its lights, its probe volume,
-     * its volumetrics, its volumetric light map, its animation and its skinning: every buffer the
+     * its volumetrics, its sky, its volumetric light map, its animation and its skinning: every buffer the
      * context made. Safe to call twice, and on a context that never enabled virtual geometry.
      */
     destroy() {
@@ -733,6 +754,7 @@ export class GPUSceneContext {
         this.#lights.destroy();
         this.#light_probe_volume.destroy();
         this.#volumetrics.destroy();
+        this.#sky.destroy();
         this.volumetric_light_map.destroy();
         this.#animation_manager.destroy();
         if (this.#skinning !== null) {

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.js

@@ -24,8 +24,9 @@ export const SCENE_DATABASE_SPEC = GPUDatabaseDefinition.from({
 
 SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'node', target_database: SCENE_DATABASE_SPEC,
     target_table: 'transforms', nullable: false, owning: false });
+// Every body has its surface row: any body can carry wave particles, and its bounds are read every frame.
 SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'wave', target_database: SCENE_DATABASE_SPEC,
-    target_table: 'water_waves', nullable: true, owning: true });
+    target_table: 'water_waves', nullable: false, owning: true });
 SCENE_DATABASE_SPEC.add_link({ table: 'water_waves', field: 'node', target_database: SCENE_DATABASE_SPEC,
     target_table: 'transforms', nullable: false, owning: false });
 

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128_inverse.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Unnormalized inverse discrete Fourier transform of 128 complex values, in place:
+ * `x[m] = Σₙ X[n] · e^{+2πi·n·m/128}`.
+ *
+ * Radix-2 decimation in time over a private array: a bit-reversal permutation, then seven butterfly
+ * stages of 64 butterflies each — 448 in all, a fixed budget. One invocation transforms one line, so a
+ * kernel built on it needs no workgroup memory and no barriers.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fft128_inverse: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fft128_inverse.d.ts.map

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128_inverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fft128_inverse.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/fft/chunk_fft128_inverse.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,mCAFU,SAAS,CA8BU;0BAzCH,gCAAgC"}

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128_inverse.js

@@ -0,0 +1,42 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_complex_multiply } from "../complex/chunk_complex_multiply.js";
+
+/**
+ * Unnormalized inverse discrete Fourier transform of 128 complex values, in place:
+ * `x[m] = Σₙ X[n] · e^{+2πi·n·m/128}`.
+ *
+ * Radix-2 decimation in time over a private array: a bit-reversal permutation, then seven butterfly
+ * stages of 64 butterflies each — 448 in all, a fixed budget. One invocation transforms one line, so a
+ * kernel built on it needs no workgroup memory and no barriers.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fft128_inverse = CodeChunk.from(
+    //language=WGSL
+    `
+fn fft128_inverse(data: ptr<function, array<vec2<f32>, 128>>) {
+    for (var i = 0u; i < 128u; i++) {
+        let j = reverseBits(i) >> 25u;
+        if (j > i) {
+            let swap = (*data)[i];
+            (*data)[i] = (*data)[j];
+            (*data)[j] = swap;
+        }
+    }
+    for (var stage = 0u; stage < 7u; stage++) {
+        let span = 1u << stage;
+        // e^{+iπ·offset/span}: the inverse transform's twiddle for a butterfly over 2·span values
+        let turn = 3.14159265358979 / f32(span);
+        for (var k = 0u; k < 64u; k++) {
+            let offset = k & (span - 1u);
+            let i = ((k >> stage) << (stage + 1u)) + offset;
+            let j = i + span;
+            let angle = turn * f32(offset);
+            let t = complex_multiply(vec2<f32>(cos(angle), sin(angle)), (*data)[j]);
+            let u = (*data)[i];
+            (*data)[i] = u + t;
+            (*data)[j] = u - t;
+        }
+    }
+}
+`, [chunk_complex_multiply]);

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128x4_inverse_workgroup.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Four unnormalized inverse discrete Fourier transforms of 128 complex values, cooperatively by a workgroup of
+ * 256 invocations: `x[m] = Σₙ X[n] · e^{+2πi·n·m/128}` for each of the four lines of `fft128x4_lines`.
+ *
+ * The caller writes each line's input in bit-reversed order (`X[n]` at `reverseBits(n) >> 25`), calls
+ * `fft128x4_inverse(lane)` from every invocation in uniform control flow, and reads the output in natural order.
+ * Radix-2 decimation in time: seven stages, each invocation one butterfly of one line a stage, a barrier
+ * between stages. The values live in 4 KiB of workgroup memory instead of a private array per invocation, which
+ * a 128-point line spills to local memory.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_fft128x4_inverse_workgroup: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_fft128x4_inverse_workgroup.d.ts.map

package/src/shade/renderer/shader/chunk/math/fft/chunk_fft128x4_inverse_workgroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_fft128x4_inverse_workgroup.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/math/fft/chunk_fft128x4_inverse_workgroup.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,+CAFU,SAAS,CAyBU;0BAtCH,gCAAgC"}