@woosh/meep-engine 3.60.5 → 3.60.7

package/src/shade/renderer/shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CLIPMAP_LEVEL_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;;;;;GAOG;AACH,mCAFU,YAAY,CAeH;AAEnB;;;GAGG;AACH,kCAFU,WAAW,CAE0E;6BAnClE,4BAA4B;4BAD7B,2BAA2B"}
+{"version":3,"file":"CLIPMAP_LEVEL_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,mCAFU,YAAY,CAeH;AAEnB;;;;;GAKG;AACH,kCAFU,MAAM,CAEqH;AAErI;;;GAGG;AACH,kCAFU,WAAW,CAE0E;6BArClE,4BAA4B;4BAD7B,2BAA2B"}

package/src/shade/renderer/shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js

@@ -1,13 +1,8 @@
+import { WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE } from "../../../gpu_primitive/WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE.js";
 import { f32, vec3i } from "../../type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../type/WebGPUArray.js";
 import { WebGPUStruct } from "../../type/WebGPUStruct.js";
 
-/**
- * Levels a clipmap table holds at most, and how far `clipmap_select_finest` walks.
- * @type {number}
- */
-export const CLIPMAP_LEVEL_LIMIT = 16;
-
 /**
  * One level of a clipmap as a shader reads it: the level's window, and how big its cell is. Levels
  * sit finest first in a {@link CLIPMAP_LEVEL_ARRAY}.
@@ -32,7 +27,15 @@ export const CLIPMAP_LEVEL_STRUCT = WebGPUStruct.from({
 }, "ClipmapLevel");
 
 /**
- * A clipmap's table of levels, as a field of the uniform that carries it.
+ * Levels a clipmap table holds: as many as fill the uniform binding every device allows, 2,048. The
+ * table is a uniform, whose length its type fixes, so this is the most levels any clipmap can have;
+ * a walk over it stops at the clipmap's own count, and a writer uploads only the levels it has.
+ * @type {number}
+ */
+export const CLIPMAP_LEVEL_LIMIT = Math.floor(WEBGPU_GUARANTEED_MAX_UNIFORM_BUFFER_BINDING_SIZE / CLIPMAP_LEVEL_STRUCT.aligned_size);
+
+/**
+ * A clipmap's table of levels, a uniform of its own, {@link CLIPMAP_LEVEL_LIMIT} long.
  * @type {WebGPUArray}
  */
 export const CLIPMAP_LEVEL_ARRAY = WebGPUArray.from(CLIPMAP_LEVEL_STRUCT, CLIPMAP_LEVEL_LIMIT);

package/src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_key.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared key packing/unpacking and stacked 3D indirection texel coordinates for clipmap cascades
+ * of cubic window resolution `resolution`:
+ *
+ * ```wgsl
+ * fn clipmap_key(cascade: u32, storage: vec3<u32>, resolution: u32) -> u32
+ * fn clipmap_key_cascade(key: u32, resolution: u32) -> u32
+ * fn clipmap_key_storage(key: u32, resolution: u32) -> vec3<u32>
+ * fn clipmap_stacked_texel(cascade: u32, storage: vec3<u32>, resolution: u32) -> vec3<u32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_clipmap_key: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_clipmap_key.d.ts.map

package/src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_clipmap_key.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_key.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,gCAFU,SAAS,CAqBjB;0BAlCwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_key.js

@@ -0,0 +1,35 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Shared key packing/unpacking and stacked 3D indirection texel coordinates for clipmap cascades
+ * of cubic window resolution `resolution`:
+ *
+ * ```wgsl
+ * fn clipmap_key(cascade: u32, storage: vec3<u32>, resolution: u32) -> u32
+ * fn clipmap_key_cascade(key: u32, resolution: u32) -> u32
+ * fn clipmap_key_storage(key: u32, resolution: u32) -> vec3<u32>
+ * fn clipmap_stacked_texel(cascade: u32, storage: vec3<u32>, resolution: u32) -> vec3<u32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_clipmap_key = CodeChunk.from(
+    //language=WGSL
+    `
+fn clipmap_key(cascade: u32, storage: vec3<u32>, resolution: u32) -> u32 {
+    return (cascade * resolution + storage.z) * resolution * resolution + storage.y * resolution + storage.x;
+}
+
+fn clipmap_key_cascade(key: u32, resolution: u32) -> u32 {
+    return key / (resolution * resolution * resolution);
+}
+
+fn clipmap_key_storage(key: u32, resolution: u32) -> vec3<u32> {
+    return vec3<u32>(key % resolution, (key / resolution) % resolution, (key / (resolution * resolution)) % resolution);
+}
+
+fn clipmap_stacked_texel(cascade: u32, storage: vec3<u32>, resolution: u32) -> vec3<u32> {
+    return vec3<u32>(storage.x, storage.y, storage.z + cascade * resolution);
+}
+`
+);

package/src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_select_finest.d.ts

@@ -2,14 +2,17 @@
  * The finest level of a clipmap whose window holds a world point, and how far into that window's
  * edge band the point is.
  *
- * Walks the first `count` levels of the table, finest first, at most {@link CLIPMAP_LEVEL_LIMIT}; the
- * first whose window holds the cell the point is in answers. Its `edge_weight` is the point's distance
+ * Walks the first `count` levels of the table, finest first; the first whose window holds the cell the
+ * point is in answers. Its `edge_weight` is the point's distance
  * to the window's nearest face, in the level's cells, through a linear ramp: 0 at `band_width` cells
  * or deeper, 1 on the face. It is how much a reader blends toward the next coarser source — the
  * parent level, or whatever stands outside the coarsest. `band_width` is positive.
  *
  * A point no level holds answers `CLIPMAP_LEVEL_NONE`, with a weight of 0.
  *
+ * `clipmap_level_select` is one level's test, for a table that is not a {@link CLIPMAP_LEVEL_ARRAY} of its
+ * own: the edge weight of a point the level's window holds, or a negative one for a point it does not.
+ *
  * The CPU twin is `clipmap_select_finest` in `core/geom/clipmap/`.
  *
  * @type {CodeChunk}

package/src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_select_finest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_clipmap_select_finest.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_select_finest.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH,0CAFU,SAAS,CAoDjB;0BAtEwB,6BAA6B"}
+{"version":3,"file":"chunk_clipmap_select_finest.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_select_finest.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;GAkBG;AACH,0CAFU,SAAS,CA0DjB;0BA/EwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/clipmap/chunk_clipmap_select_finest.js

@@ -6,14 +6,17 @@ import { chunk_clipmap_contains } from "./chunk_clipmap_contains.js";
  * The finest level of a clipmap whose window holds a world point, and how far into that window's
  * edge band the point is.
  *
- * Walks the first `count` levels of the table, finest first, at most {@link CLIPMAP_LEVEL_LIMIT}; the
- * first whose window holds the cell the point is in answers. Its `edge_weight` is the point's distance
+ * Walks the first `count` levels of the table, finest first; the first whose window holds the cell the
+ * point is in answers. Its `edge_weight` is the point's distance
  * to the window's nearest face, in the level's cells, through a linear ramp: 0 at `band_width` cells
  * or deeper, 1 on the face. It is how much a reader blends toward the next coarser source — the
  * parent level, or whatever stands outside the coarsest. `band_width` is positive.
  *
  * A point no level holds answers `CLIPMAP_LEVEL_NONE`, with a weight of 0.
  *
+ * `clipmap_level_select` is one level's test, for a table that is not a {@link CLIPMAP_LEVEL_ARRAY} of its
+ * own: the edge weight of a point the level's window holds, or a negative one for a point it does not.
+ *
  * The CPU twin is `clipmap_select_finest` in `core/geom/clipmap/`.
  *
  * @type {CodeChunk}
@@ -30,6 +33,25 @@ struct ClipmapSelection {
     edge_weight: f32,
 }
 
+fn clipmap_level_select(level: ClipmapLevel, position_ws: vec3f, band_width: f32) -> f32 {
+    // the point in the level's cells
+    let position_cells = position_ws / level.cell_size;
+
+    if (!clipmap_contains(vec3<i32>(floor(position_cells)), level.corner, level.size)) {
+        return -1.0;
+    }
+
+    let from_corner = position_cells - vec3f(level.corner);
+    let to_far_corner = vec3f(level.size) - from_corner;
+
+    let edge = min(
+        min(min(from_corner.x, from_corner.y), from_corner.z),
+        min(min(to_far_corner.x, to_far_corner.y), to_far_corner.z)
+    );
+
+    return saturate(1.0 - edge / band_width);
+}
+
 fn clipmap_select_finest(
     levels: ptr<uniform, ${CLIPMAP_LEVEL_ARRAY.wgsl_ref}>,
     count: u32,
@@ -42,24 +64,11 @@ fn clipmap_select_finest(
             break;
         }
 
-        let level = (*levels)[i];
-
-        // the point in the level's cells
-        let position_cells = position_ws / level.cell_size;
+        let weight = clipmap_level_select((*levels)[i], position_ws, band_width);
 
-        if (!clipmap_contains(vec3<i32>(floor(position_cells)), level.corner, level.size)) {
-            continue;
+        if (weight >= 0.0) {
+            return ClipmapSelection(i, weight);
         }
-
-        let from_corner = position_cells - vec3f(level.corner);
-        let to_far_corner = vec3f(level.size) - from_corner;
-
-        let edge = min(
-            min(min(from_corner.x, from_corner.y), from_corner.z),
-            min(min(to_far_corner.x, to_far_corner.y), to_far_corner.z)
-        );
-
-        return ClipmapSelection(i, saturate(1.0 - edge / band_width));
     }
 
     return ClipmapSelection(CLIPMAP_LEVEL_NONE, 0.0);

package/src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh2_color_get_irradiance_at.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sh2_color_get_irradiance_at.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh2_color_get_irradiance_at.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,gDAFU,SAAS,CAqBhB;0BAzBuB,6BAA6B"}
+{"version":3,"file":"chunk_sh2_color_get_irradiance_at.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh2_color_get_irradiance_at.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,gDAFU,SAAS,CAUhB;0BAfuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh2_color_get_irradiance_at.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_sh2_color_irradiance } from "./chunk_sh2_color_irradiance.js";
 
 /**
  * Kernel is cosine convolved
@@ -8,19 +9,8 @@ export const chunk_sh2_color_get_irradiance_at = CodeChunk.from(
     //language=WGSL
     `
 fn sh2_color_get_irradiance_at(normal: vec3<f32>, coefficients: array< vec3<f32>, 4 >) -> vec3<f32>{
-    // normal is assumed to have unit length
-    let x = normal.x;
-    let y = normal.y;
-    let z = normal.z;
-
-    // band 0
-    var result = coefficients[0] * 0.8862269254527579;
-
-    // band 1
-    result += coefficients[1] * 1.0233267079464885 * y;
-    result += coefficients[2] * 1.0233267079464885 * z;
-    result += coefficients[3] * 1.0233267079464885 * x;
-
-    return max(vec3(0),result);
+    return max(vec3(0), sh2_color_irradiance(normal, coefficients));
 }
-`);
+`, [
+    chunk_sh2_color_irradiance,
+]);

package/src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh3_convolve_with_cosine_kernel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sh3_convolve_with_cosine_kernel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh3_convolve_with_cosine_kernel.js"],"names":[],"mappings":"AAMA,8DAuBG;AAEH,oEA4CC;0BA3EyB,6BAA6B"}
+{"version":3,"file":"chunk_sh3_convolve_with_cosine_kernel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh3_convolve_with_cosine_kernel.js"],"names":[],"mappings":"AAOA,8DAQG;AAEH,oEA4CC;0BA7DyB,6BAA6B"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh3_convolve_with_cosine_kernel.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_sh3_convolve_with_zh } from "./chunk_sh3_convolve_with_zh.js";
 
 const sh_cosineA0 = Math.PI;
 const sh_cosineA1 = (2.0 * Math.PI) / 3.0;
@@ -8,26 +9,11 @@ export const chunk_sh3_convolve_with_cosine_kernel = CodeChunk.from(
     //language=WGSL
     `
 fn sh3_convolve_with_cosine_kernel(sh: array<f32,9>) -> array<f32, 9>{
-    return array<f32,9>(
-    
-        // band 0
-        sh[0]*${sh_cosineA0},
-        
-        // band 1
-        sh[1]*${sh_cosineA1},
-        sh[2]*${sh_cosineA1},
-        sh[3]*${sh_cosineA1},
-        
-        // band 2
-        sh[4]*${sh_cosineA2},
-        sh[5]*${sh_cosineA2},
-        sh[6]*${sh_cosineA2},
-        sh[7]*${sh_cosineA2},
-        sh[8]*${sh_cosineA2},
-        
-    );
+    return sh3_convolve_with_zh(sh, vec3<f32>(${sh_cosineA0}, ${sh_cosineA1}, ${sh_cosineA2}));
 }
-`);
+`, [
+    chunk_sh3_convolve_with_zh,
+]);
 
 export const chunk_sh3_color_convolve_with_cosine_kernel = CodeChunk.from(
     //language=WGSL

package/src/shade/renderer/shader/chunk/spherical_harmonics/dering/chunk_sh3_windowing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sh3_windowing.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/dering/chunk_sh3_windowing.js"],"names":[],"mappings":"AAIA,4CA4BO;0BAhCmB,gCAAgC"}
+{"version":3,"file":"chunk_sh3_windowing.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/dering/chunk_sh3_windowing.js"],"names":[],"mappings":"AAIA,4CASO;0BAbmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/dering/chunk_sh3_windowing.js

@@ -1,34 +1,15 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { chunk_sh_index } from "../chunk_sh_index.js";
+import { chunk_sh3_convolve_with_zh } from "../chunk_sh3_convolve_with_zh.js";
 import { chunk_sinc_window } from "./chunk_sinc_window.js";
 
 export const chunk_sh3_windowing = CodeChunk.from(
     //language=WGSL
     `
 fn sh3_windowing( f:array<f32, 9>, cutoff:f32 ) -> array<f32, 9>{
-
-    // scale each band individually
-    let w0 = 1.0; //first band is always unchanged
-    let w1 = sinc_window(1, cutoff);
-    let w2 = sinc_window(2, cutoff);
-    
-    return array<f32,9>(
-        // band 0
-        f[0] * w0,
-        // band 1
-        f[1] * w1,
-        f[2] * w1,
-        f[3] * w1,
-        // band 2
-        f[4] * w2,
-        f[5] * w2,
-        f[6] * w2,
-        f[7] * w2,
-        f[8] * w2,
-    );
+    return sh3_convolve_with_zh(f, vec3<f32>(1.0, sinc_window(1, cutoff), sinc_window(2, cutoff)));
 }
 `, [
+        chunk_sh3_convolve_with_zh,
         chunk_sinc_window,
-        chunk_sh_index,
     ]);
 

package/src/shade/renderer/shadow/map/ShadowmapDrawSelector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShadowmapDrawSelector.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/ShadowmapDrawSelector.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IACI;;;;OAIG;IACH,UAFU,WAAW,CAEP;IAEd;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;;;OAMG;IACH,sBAFU,MAAM,CAES;IAEzB;;;;;OAKG;IACH,sBAFU,OAAO,CAEY;IAsC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,mBALW,WAAW,eAEX,MAAM,gBACN,MAAM,QAkFhB;;CACJ"}
+{"version":3,"file":"ShadowmapDrawSelector.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/ShadowmapDrawSelector.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IACI;;;;OAIG;IACH,UAFU,WAAW,CAEP;IAEd;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;;;OAMG;IACH,sBAFU,MAAM,CAES;IAEzB;;;;;OAKG;IACH,sBAFU,OAAO,CAEY;IAsC7B;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,mBALW,WAAW,eAEX,MAAM,gBACN,MAAM,QAkFhB;;CACJ"}

package/src/shade/renderer/shadow/map/ShadowmapDrawSelector.js

@@ -1,5 +1,6 @@
 import { IndexedFloatMaxHeap } from "../../../../core/collection/heap/IndexedFloatMaxHeap.js";
 import { compute_shadowmap_update_score } from "./shadowmap_update_score.js";
+import { ceilPowerOfTwo } from "../../../../core/binary/operations/ceilPowerOfTwo.js";
 
 /**
  * Picks which shadowmaps get rasterized this frame, given a view budget.
@@ -92,7 +93,7 @@ export class ShadowmapDrawSelector {
             return;
         }
 
-        const capacity = Math.max(64, 1 << (32 - Math.clz32(count - 1)));
+        const capacity = Math.max(64, ceilPowerOfTwo(count));
 
         this.#heap = new IndexedFloatMaxHeap(capacity);
         this.#heap_capacity = capacity;

package/src/shade/renderer/volumetrics/chunk_volumetrics_sun_shadow_group_list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_volumetrics_sun_shadow_group_list.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_volumetrics_sun_shadow_group_list.js"],"names":[],"mappings":"AAQA;;;;;;;GAOG;AACH,oDAFU,YAAY,CAKkB;AAExC;;;;;GAKG;AACH,kDAFU,YAAY,CAKgB;AAEtC;;;;;;;;;;GAUG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;;;;;;;GAUG;AACH,2DAFU,MAAM,CAE+C;AAE/D;;;;;GAKG;AACH,uDAFU,MAAM,CAE0C;AAE1D;;;;;;;GAOG;AACH,sDAFU,SAAS,CA8EjB;6BAnJ2B,gCAAgC;0BAFnC,iCAAiC"}
+{"version":3,"file":"chunk_volumetrics_sun_shadow_group_list.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_volumetrics_sun_shadow_group_list.js"],"names":[],"mappings":"AASA;;;;;;;GAOG;AACH,oDAFU,YAAY,CAKkB;AAExC;;;;;GAKG;AACH,kDAFU,YAAY,CAKgB;AAEtC;;;;;;;;;;GAUG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;;;;;;;GAUG;AACH,2DAFU,MAAM,CAE+C;AAE/D;;;;;GAKG;AACH,uDAFU,MAAM,CAE0C;AAE1D;;;;;;;GAOG;AACH,sDAFU,SAAS,CA+EjB;6BApJ2B,gCAAgC;0BAFnC,iCAAiC"}