@woosh/meep-engine 3.60.5 → 3.60.7

package/src/shade/renderer/water/GPUWaterRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAqBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAmB7B;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;MAyIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CAyBJ;gCAtX+B,uCAAuC"}
+{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAsBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAmB7B;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;MAyIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CAyBJ;gCAvX+B,uCAAuC"}

package/src/shade/renderer/water/GPUWaterRenderer.js

@@ -18,6 +18,7 @@ import { create_water_finalize_pipeline, create_water_pipeline, WATER_FINALIZE_R
 import { WATER_BAND_SAMPLER } from "./surface/GPUWaterSurface.js";
 import { shader_water_background_copy, shader_water_debug, shader_water_draw,
     shader_water_occupancy, shader_water_splat } from "./shader_water_avboit.js";
+import { ceilPowerOfTwo } from "../../../core/binary/operations/ceilPowerOfTwo.js";
 
 /** Production water channel. Only AVBOIT's shared resolve composites its radiance. */
 export class GPUWaterRenderer {
@@ -118,7 +119,7 @@ export class GPUWaterRenderer {
         // statistics words: candidates, interior, boundary, flat triangles (sized by the scene, not grown), patches
         const keys = { candidates: 0, interior: 1, boundary: 2, patches: 4 };
         for (const [key, i] of Object.entries(keys)) {
-            if (totals[i] > budgets[key]) { budgets[key] = 2 ** Math.ceil(Math.log2(totals[i] * 1.25)); }
+            if (totals[i] > budgets[key]) { budgets[key] = ceilPowerOfTwo(Math.ceil(totals[i] * 1.25)); }
         }
     }
 

package/src/shade/renderer/water/query/GPUWaterQueries.d.ts

@@ -24,7 +24,7 @@ export class GPUWaterQueries {
      * @param {PipelineEnquiry} enquiry
      */
     static enquirePipelines(enquiry: PipelineEnquiry): void;
-    static "__#275@#execute"(pass: any, resources: any, context: any): void;
+    static "__#277@#execute"(pass: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/water/surface/lod/shader_water_lod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_water_lod.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/lod/shader_water_lod.js"],"names":[],"mappings":"AA8BA,sHAAsH;AACtH,4CAA6C;AAC7C,6CAA8C;AAC9C,4CAA6C;AAC7C,sFAAsF;AACtF,iDAAkD;AAClD,iDAAkD;AAClD,kFAAkF;AAClF,8CAA+C;AAC/C,oFAAoF;AACpF,qCAAsC;AAEtC;;;;GAIG;AACH,kDASK;AAEL,kHAAkH;AAClH,0CAA2C;AAC3C,0EAA0E;AAC1E,+CAA+E;AAE/E,yGAAyG;AACzG,wCAAyC;AAEzC,wEAAwE;AACxE;;;;;GAA+F;AAE/F;;;;GAIG;AACH,sDAEwB;AAExB;;;;GAIG;AACH,mDAE4B;AAE5B;;;GAGG;AACH,2CAA4C;AA0I5C;;;;;;GAMG;AACH,oDAuD0E;AAsD1E;;;;;GAKG;AACH,uDAkCsH;AAWtH;;;GAGG;AACH,mDAYoE;AAIpE,kFAAkF;AAClF,+CAAgD;AAiBhD;;;;;;;GAOG;AACH,wDAqF0C;AAiB1C;;;;;;;GAOG;AACH,mDAqEmF;AAInF,oEAAoE;AACpE;IACI,6EAA6E;;IAE7E,oCAAoC;;IAEpC,0EAA0E;;IAE1E,qCAAqC;;IAErC,oDAAoD;;IAEpD,iCAAiC;;GAElC;AACH,0CAA2C;AA4B3C;;;GAGG;AACH,+DAcM;AASN,mHAAmH;AACnH,2DA4BmC;6BA7rBN,sCAAsC;AAuFnE,+CAIgD;8BAxGlB,kCAAkC;AA2GhE,kDAgG6G;AAkF7G,8FAA8F;AAC9F,+CAmCsH;0BAhU5F,uCAAuC"}
+{"version":3,"file":"shader_water_lod.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/lod/shader_water_lod.js"],"names":[],"mappings":"AA6BA,sHAAsH;AACtH,4CAA6C;AAC7C,6CAA8C;AAC9C,4CAA6C;AAC7C,sFAAsF;AACtF,iDAAkD;AAClD,iDAAkD;AAClD,kFAAkF;AAClF,8CAA+C;AAC/C,oFAAoF;AACpF,qCAAsC;AAEtC;;;;GAIG;AACH,kDASK;AAEL,kHAAkH;AAClH,0CAA2C;AAC3C,0EAA0E;AAC1E,+CAA+E;AAE/E,yGAAyG;AACzG,wCAAyC;AAEzC,wEAAwE;AACxE;;;;;GAA+F;AAE/F;;;;GAIG;AACH,sDAEwB;AAExB;;;;GAIG;AACH,mDAE4B;AAE5B;;;GAGG;AACH,2CAA4C;AA0I5C;;;;;;GAMG;AACH,oDAuD0E;AAsD1E;;;;;GAKG;AACH,uDAkCsH;AAWtH;;;GAGG;AACH,mDAYoE;AAIpE,kFAAkF;AAClF,+CAAgD;AAiBhD;;;;;;;GAOG;AACH,wDAqF0C;AAiB1C;;;;;;;GAOG;AACH,mDAqEmF;AAInF,oEAAoE;AACpE;IACI,6EAA6E;;IAE7E,oCAAoC;;IAEpC,0EAA0E;;IAE1E,qCAAqC;;IAErC,oDAAoD;;IAEpD,iCAAiC;;GAElC;AACH,0CAA2C;AA2B3C;;;GAGG;AACH,+DAc0D;AAS1D,mHAAmH;AACnH,2DA4BqF;6BA5rBxD,sCAAsC;AAuFnE,+CAIgD;8BAzGlB,kCAAkC;AA4GhE,kDAgG6G;AAkF7G,8FAA8F;AAC9F,+CAmCsH;0BAjU5F,uCAAuC"}

package/src/shade/renderer/water/surface/lod/shader_water_lod.js

@@ -3,9 +3,7 @@ import { GEOMETRY_METADATA_STRUCT } from "../../../geometry/GEOMETRY_METADATA_ST
 import { GEOMETRY_MESHLET_TRIANGLE_LIMIT } from "../../../geometry/meshlet/GEOMETRY_MESHLET_TRIANGLE_LIMIT.js";
 import { MESHLET_METADATA_STRUCT } from "../../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
 import { COLLECTION_U32_STRUCT_READ } from "../../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
-import {
-    WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION
-} from "../../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
+import { chunk_folded_dispatch } from "../../../gpu_primitive/indirect/chunk_folded_dispatch.js";
 import { MESHLET_COLLECTION_STRUCT } from "../../../rasterize/MESHLET_COLLECTION_STRUCT.js";
 import { chunk_scene_database_access } from "../../../scene/chunk_scene_database_access.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
@@ -17,6 +15,7 @@ import { chunk_mat3_inverse } from "../../../shader/chunk/geometry/mat3/chunk_ma
 import { chunk_mat4_linear_determinant } from "../../../shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.js";
 import { chunk_read_meshlet_vertex_by_draw_index } from "../../../shader/chunk/geometry/meshlet/chunk_read_meshlet_vertex_by_draw_index.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { chunk_divide_round_up_u32 } from "../../../shader/chunk/math/chunk_divide_round_up_u32.js";
 import { chunk_lower_bound_branchless } from "../../../shader/chunk/math/chunk_lower_bound_branchless.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { atomic_u32, f32, u32, vec2i } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
@@ -642,11 +641,10 @@ export const WATER_LOD_COMMAND_BYTES = 160;
 
 const fold = `
 fn water_lod_dispatch(at: u32, groups: u32) {
-    const LIMIT = ${WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION}u;
-    let rows = (groups + LIMIT - 1u) / LIMIT;
-    commands[at] = min(groups, LIMIT);
-    commands[at + 1u] = max(min(rows, LIMIT), 1u);
-    commands[at + 2u] = max((rows + LIMIT - 1u) / LIMIT, 1u);
+    let folded = folded_dispatch(groups);
+    commands[at] = folded.x;
+    commands[at + 1u] = folded.y;
+    commands[at + 2u] = folded.z;
 }
 fn water_lod_total(sums_count: u32, last: u32) -> u32 { return select(0u, last, sums_count > 0u); }
 fn water_lod_draw(list: u32, count: u32, vertices: u32, first: u32) {
@@ -679,12 +677,12 @@ fn main() {
     let flats = water_lod_total(flat_sums.count, flat_sums.elements[max(flat_sums.count, 1u) - 1u]);
     statistics[0] = total;
     statistics[3] = flats;
-    water_lod_dispatch(${WaterLodCommand.Candidates / 4}u, (min(total, limits.candidates) + 63u) / 64u);
+    water_lod_dispatch(${WaterLodCommand.Candidates / 4}u, divide_round_up_u32(min(total, limits.candidates), 64u));
     let drawn = min(flats, limits.triangles);
-    water_lod_dispatch(${WaterLodCommand.Flats / 4}u, (drawn + 63u) / 64u);
+    water_lod_dispatch(${WaterLodCommand.Flats / 4}u, divide_round_up_u32(drawn, 64u));
     water_lod_draw(${WaterLodList.Triangle}u, drawn, ${WATER_LOD_TRIANGLE_VERTICES}u, ${WATER_LOD_TRIANGLE_FIRST_VERTEX}u);
 }
-`) });
+`, [chunk_folded_dispatch, chunk_divide_round_up_u32]) });
 
 const draw_command_resources = new ShaderResourceSetDescriptor();
 draw_command_resources.createGroup()
@@ -700,7 +698,7 @@ ${fold}
 fn water_lod_list(list: u32, total: u32, budget: u32, vertices: u32, first: u32) {
     statistics[1u + list] = total;
     let count = min(total, budget);
-    water_lod_dispatch(${WaterLodCommand.Cells / 4}u + 4u * list, (count + 63u) / 64u);
+    water_lod_dispatch(${WaterLodCommand.Cells / 4}u + 4u * list, divide_round_up_u32(count, 64u));
     water_lod_draw(list, count, vertices, first);
 }
 
@@ -714,7 +712,7 @@ fn main() {
     let patches = water_lod_list_span(&sums.elements, sums.count, 2u).y;
     statistics[4] = patches;
     let count = min(patches, limits.patches);
-    water_lod_dispatch(${WaterLodCommand.PatchCells / 4}u, (count + 63u) / 64u);
+    water_lod_dispatch(${WaterLodCommand.PatchCells / 4}u, divide_round_up_u32(count, 64u));
     let draw = ${WaterLodCommand.PatchDraw / 4}u;
     commands[draw] = ${WATER_LOD_PATCH_INDICES.length}u;
     commands[draw + 1u] = count;
@@ -722,6 +720,6 @@ fn main() {
     commands[draw + 3u] = ${WATER_LOD_PATCH_FIRST_VERTEX}u;
     commands[draw + 4u] = 0u;
 }
-`, [chunk_water_lod_list_sums]) });
+`, [chunk_water_lod_list_sums, chunk_folded_dispatch, chunk_divide_round_up_u32]) });
 
 export { chunk_water_lod_candidate, chunk_water_lod_source };

package/src/shade/renderer/water/surface/particles/GPUWaterParticles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterParticles.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/GPUWaterParticles.js"],"names":[],"mappings":"AAkCA,kHAAkH;AAClH,+CAAgD;AAUhD;;;;GAIG;AACH;IAwBI,uFAAuF;IACvF,yBAAuC;IACvC,kGAAkG;IAClG,yBAAuC;IACvC,uGAAuG;IACvG,6BAA+C;IAC/C,mEAAmE;IACnE,2BAAyD;IACzD,uBAAyC;IAEzC;;;;;;;;;;;OAWG;IACH,qCALW,MAAM,QACN,MAAM,UACK,OAAO,8CAA8C,EAAE,sBAAsB,KAAE,IAAI,GAAC,IAAI,CA4D7G;IAED,gBAeC;IAED;;;;;;;;;;;;;;;OAeG;IACH;QATyG,KAAK,EAAnG,OAAO,iEAAiE,EAAE,UAAU;QACpE,KAAK,EAArB,MAAM;QACa,KAAK;QACL,QAAQ;QACR,SAAS;QACT,QAAQ;QACX,YAAY,EAA5B,MAAM;QACU,EAAE,EAAlB,MAAM;aA8FhB;;CACJ"}
+{"version":3,"file":"GPUWaterParticles.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/GPUWaterParticles.js"],"names":[],"mappings":"AAmCA,kHAAkH;AAClH,+CAAgD;AAEhD;;;;GAIG;AACH;IAwBI,uFAAuF;IACvF,yBAAuC;IACvC,kGAAkG;IAClG,yBAAuC;IACvC,uGAAuG;IACvG,6BAA+C;IAC/C,mEAAmE;IACnE,2BAAyD;IACzD,uBAAyC;IAEzC;;;;;;;;;;;OAWG;IACH,qCALW,MAAM,QACN,MAAM,UACK,OAAO,8CAA8C,EAAE,sBAAsB,KAAE,IAAI,GAAC,IAAI,CA4D7G;IAED,gBAeC;IAED;;;;;;;;;;;;;;;OAeG;IACH;QATyG,KAAK,EAAnG,OAAO,iEAAiE,EAAE,UAAU;QACpE,KAAK,EAArB,MAAM;QACa,KAAK;QACL,QAAQ;QACR,SAAS;QACT,QAAQ;QACX,YAAY,EAA5B,MAAM;QACU,EAAE,EAAlB,MAAM;aA8FhB;;CACJ"}

package/src/shade/renderer/water/surface/particles/GPUWaterParticles.js

@@ -31,18 +31,11 @@ import {
     WATER_PARTICLE_CROWD_WORDS,
     WATER_PARTICLE_NEST_WORDS
 } from "./shader_water_particles.js";
+import { ceilPowerOfTwo } from "../../../../../core/binary/operations/ceilPowerOfTwo.js";
 
 /** The longest step a particle takes in one frame, seconds: a stalled tab does not fling fronts across a lake. */
 export const WATER_PARTICLE_STEP_LIMIT = 1 / 15;
 
-/**
- * @param {number} value
- * @returns {number} the smallest power of two at least value
- */
-function power_of_two_at_least(value) {
-    return 2 ** Math.ceil(Math.log2(Math.max(value, 1)));
-}
-
 /**
  * The wave particles of every water body of a scene, on the device (WATER_SURFACE_SIMULATION_PLAN_2026_10_06.md
  * §5.4): ping-pong particle arrays, and each frame's hash of them for the surface sampler. Counts never leave
@@ -101,7 +94,7 @@ export class GPUWaterParticles {
             this.dispose();
             this.#device = device;
             this.#capacity = capacity;
-            this.#table_limit = power_of_two_at_least(2 * WATER_PARTICLE_CORNERS * capacity);
+            this.#table_limit = ceilPowerOfTwo(2 * WATER_PARTICLE_CORNERS * capacity);
             const buffer = (label, size, usage = 0) => device.createBuffer({ label: `Water / particles ${label}`,
                 size: Math.max(16, size), usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | usage });
             const array_size = 16 + capacity * WATER_PARTICLE_STRUCT.size;

package/src/shade/renderer/water/surface/particles/chunk_water_particle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_particle.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/chunk_water_particle.js"],"names":[],"mappings":"AAKA;;;GAGG;AACH,uCAAwC;AAKxC,yHAAyH;AACzH,gDAAkD;AAElD;;;;;;;;;;;;GAYG;AACH,8CAIE;AAKF,+GAA+G;AAC/G,oDAAqD;AAErD,qHAAqH;AACrH,uDAAwD;AAExD,wEAAwE;AACxE,qDAAsD;AAEtD,wFAAwF;AACxF,yCAA2G;AAE3G;;;;;;;;;;;;;;;;;;;GAmBG;AACH,mCAFU,SAAS,CAgP6G;0BArTtG,uCAAuC"}
+{"version":3,"file":"chunk_water_particle.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/water/surface/particles/chunk_water_particle.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,uCAAwC;AAKxC,yHAAyH;AACzH,gDAAkD;AAElD;;;;;;;;;;;;GAYG;AACH,8CAIE;AAKF,+GAA+G;AAC/G,oDAAqD;AAErD,qHAAqH;AACrH,uDAAwD;AAExD,wEAAwE;AACxE,qDAAsD;AAEtD,wFAAwF;AACxF,yCAA2G;AAE3G;;;;;;;;;;;;;;;;;;;GAmBG;AACH,mCAFU,SAAS,CAgP6G;0BAtTtG,uCAAuC"}

package/src/shade/renderer/water/surface/particles/chunk_water_particle.js

@@ -2,6 +2,7 @@ import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { chunk_pcg3d } from "../../../shader/chunk/random/pcg/chunk_pcg3d.js";
 import { WATER_PARTICLE_ENTRY_STRUCT, WATER_PARTICLE_STRUCT } from "./WATER_PARTICLE_STRUCT.js";
 import { chunk_water_spectrum } from "../spectrum/chunk_water_spectrum.js";
+import { ceil_log2 } from "../../../../../core/binary/operations/ceil_log2.js";
 
 /**
  * Levels of the particle hash: cell sizes 4 mm · 2^level, so supports up to 256 m, which a 2 m splash's stretched
@@ -10,7 +11,7 @@ import { chunk_water_spectrum } from "../spectrum/chunk_water_spectrum.js";
 export const WATER_PARTICLE_LEVELS = 18;
 
 /** Bits of a hash key that hold the level, below the body's row. */
-const WATER_PARTICLE_LEVEL_BITS = Math.ceil(Math.log2(WATER_PARTICLE_LEVELS));
+const WATER_PARTICLE_LEVEL_BITS = ceil_log2(WATER_PARTICLE_LEVELS);
 
 /** Cell size of level 0, metres. A particle sits at the smallest level whose cell is at least its support's diameter. */
 export const WATER_PARTICLE_LEVEL0_CELL = 1 / 256;

package/src/shade/renderer/wind/WIND_FIELD.d.ts

@@ -8,7 +8,9 @@
  * a reader takes it through the atmosphere identity (`chunk_wind_field_sample`).
  */
 /**
- * Cascades the field holds at most: the clipmap table it is selected through.
+ * Cascades the field holds at most: the rows of its windows and its read records, which sit in
+ * {@link WIND_FIELD_STRUCT}, the one uniform every reader binds and the host writes whole each frame.
+ * The wind's own figure, not the shared clipmap table's, which is a uniform of its own.
  * @type {number}
  */
 export const WIND_FIELD_CASCADE_LIMIT: number;

package/src/shade/renderer/wind/WIND_FIELD.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WIND_FIELD.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/WIND_FIELD.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AAEH;;;GAGG;AACH,uCAFU,MAAM,CAE4C;AAE5D;;;;;;;;;;;;GAYG;AACH,sDAAoD;AAEpD;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;;;;;;;GAUG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;GAIG;AACH,4CAFU,OAAO,+CAA+C,EAAE,iBAAiB,CAEf"}
+{"version":3,"file":"WIND_FIELD.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/WIND_FIELD.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,uCAFU,MAAM,CAE2B;AAE3C;;;;;;;;;;;;GAYG;AACH,sDAAoD;AAEpD;;;;GAIG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;;;;;;;;GAUG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;GAIG;AACH,4CAFU,OAAO,+CAA+C,EAAE,iBAAiB,CAEf"}

package/src/shade/renderer/wind/WIND_FIELD.js

@@ -1,4 +1,3 @@
-import { CLIPMAP_LEVEL_LIMIT } from "../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../texture/SAMPLER_LINEAR_UPSCALE.js";
 
 /**
@@ -12,10 +11,12 @@ import { SAMPLER_LINEAR_UPSCALE } from "../texture/SAMPLER_LINEAR_UPSCALE.js";
  */
 
 /**
- * Cascades the field holds at most: the clipmap table it is selected through.
+ * Cascades the field holds at most: the rows of its windows and its read records, which sit in
+ * {@link WIND_FIELD_STRUCT}, the one uniform every reader binds and the host writes whole each frame.
+ * The wind's own figure, not the shared clipmap table's, which is a uniform of its own.
  * @type {number}
  */
-export const WIND_FIELD_CASCADE_LIMIT = CLIPMAP_LEVEL_LIMIT;
+export const WIND_FIELD_CASCADE_LIMIT = 16;
 
 /**
  * A tile's texel format.

package/src/shade/renderer/wind/WIND_FIELD_STRUCT.d.ts

@@ -5,6 +5,12 @@
  * @type {WebGPUStruct}
  */
 export const WIND_CASCADE_STRUCT: WebGPUStruct;
+/**
+ * The cascades' windows, finest first, as a field of {@link WIND_FIELD_STRUCT}: clipmap levels, walked
+ * with `clipmap_level_select`.
+ * @type {WebGPUArray}
+ */
+export const WIND_LEVEL_ARRAY: WebGPUArray;
 /**
  * The cascades' read records, finest first, as a field of {@link WIND_FIELD_STRUCT}.
  * @type {WebGPUArray}
@@ -17,8 +23,8 @@ export const WIND_CASCADE_ARRAY: WebGPUArray;
  * Cascade `c` (finest first, below `cascade_count`) is two rows at index `c`:
  * - `levels[c]`: its window as a clipmap level (`CLIPMAP_LEVEL_STRUCT`) — the world cell at
  *   window-local 0 (`corner`, in the cascade's cells), the cell's edge in metres (`cell_size`), and
- *   the window's cells on each axis (`size`). A world corner is `corner · cell_size`. The table is
- *   the shared clipmap module's, so `clipmap_select_finest` walks it as it is;
+ *   the window's cells on each axis (`size`). A world corner is `corner · cell_size`. Its rows are
+ *   the shared clipmap module's, so `clipmap_level_select` tests each as it is;
  * - `cascades[c]`: its tile and its decay ({@link WIND_CASCADE_STRUCT}).
  *
  * Rows at and past `cascade_count` are never read.

package/src/shade/renderer/wind/WIND_FIELD_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WIND_FIELD_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/WIND_FIELD_STRUCT.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,kCAFU,YAAY,CAgBJ;AAElB;;;GAGG;AACH,iCAFU,WAAW,CAE6E;AAElG;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gCAFU,YAAY,CAQN;6BAzDa,gCAAgC;4BADjC,+BAA+B"}
+{"version":3,"file":"WIND_FIELD_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/WIND_FIELD_STRUCT.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,kCAFU,YAAY,CAgBJ;AAElB;;;;GAIG;AACH,+BAFU,WAAW,CAE4E;AAEjG;;;GAGG;AACH,iCAFU,WAAW,CAE6E;AAElG;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gCAFU,YAAY,CAQN;6BAhEa,gCAAgC;4BADjC,+BAA+B"}

package/src/shade/renderer/wind/WIND_FIELD_STRUCT.js

@@ -1,4 +1,4 @@
-import { CLIPMAP_LEVEL_ARRAY } from "../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
+import { CLIPMAP_LEVEL_STRUCT } from "../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { f32, u32, vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
@@ -26,6 +26,13 @@ export const WIND_CASCADE_STRUCT = WebGPUStruct.from({
     decay: f32,
 }, "WindCascade");
 
+/**
+ * The cascades' windows, finest first, as a field of {@link WIND_FIELD_STRUCT}: clipmap levels, walked
+ * with `clipmap_level_select`.
+ * @type {WebGPUArray}
+ */
+export const WIND_LEVEL_ARRAY = WebGPUArray.from(CLIPMAP_LEVEL_STRUCT, WIND_FIELD_CASCADE_LIMIT);
+
 /**
  * The cascades' read records, finest first, as a field of {@link WIND_FIELD_STRUCT}.
  * @type {WebGPUArray}
@@ -39,8 +46,8 @@ export const WIND_CASCADE_ARRAY = WebGPUArray.from(WIND_CASCADE_STRUCT, WIND_FIE
  * Cascade `c` (finest first, below `cascade_count`) is two rows at index `c`:
  * - `levels[c]`: its window as a clipmap level (`CLIPMAP_LEVEL_STRUCT`) — the world cell at
  *   window-local 0 (`corner`, in the cascade's cells), the cell's edge in metres (`cell_size`), and
- *   the window's cells on each axis (`size`). A world corner is `corner · cell_size`. The table is
- *   the shared clipmap module's, so `clipmap_select_finest` walks it as it is;
+ *   the window's cells on each axis (`size`). A world corner is `corner · cell_size`. Its rows are
+ *   the shared clipmap module's, so `clipmap_level_select` tests each as it is;
  * - `cascades[c]`: its tile and its decay ({@link WIND_CASCADE_STRUCT}).
  *
  * Rows at and past `cascade_count` are never read.
@@ -53,7 +60,7 @@ export const WIND_CASCADE_ARRAY = WebGPUArray.from(WIND_CASCADE_STRUCT, WIND_FIE
  * @type {WebGPUStruct}
  */
 export const WIND_FIELD_STRUCT = WebGPUStruct.from({
-    levels: CLIPMAP_LEVEL_ARRAY,
+    levels: WIND_LEVEL_ARRAY,
     cascades: WIND_CASCADE_ARRAY,
     far_velocity: vec3f,
     cascade_count: u32,

package/src/shade/renderer/wind/chunk_wind_field_sample_cascades.d.ts

@@ -7,8 +7,8 @@
  * {@link wind_field_add_resources} declares them.
  *
  * **The read:**
- * - `clipmap_select_finest` walks the cascades' windows, finest first, and the first holding the point
- *   answers, with how far into its edge band of {@link WIND_FIELD_BAND_WIDTH} cells the point is;
+ * - the cascades' windows are walked finest first, each by `clipmap_level_select`, and the first holding
+ *   the point answers, with how far into its edge band of {@link WIND_FIELD_BAND_WIDTH} cells the point is;
  * - a cascade's read is the atmosphere identity, `v_far(t) + tap · k_c`: one trilinear tap of its tile,
  *   which holds `v − v_far(t_s,c)` at cell centres, times its decay;
  * - in the band, a second read blends in linearly, all of it on the window's face: the parent's

package/src/shade/renderer/wind/chunk_wind_field_sample_cascades.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_wind_field_sample_cascades.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/chunk_wind_field_sample_cascades.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,+CAFU,SAAS,CAmDjB;0BA1FwB,iCAAiC"}
+{"version":3,"file":"chunk_wind_field_sample_cascades.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/wind/chunk_wind_field_sample_cascades.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,+CAFU,SAAS,CA4DjB;0BAnGwB,iCAAiC"}

package/src/shade/renderer/wind/chunk_wind_field_sample_cascades.js

@@ -1,6 +1,6 @@
 import { chunk_clipmap_select_finest } from "../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { WIND_FIELD_BAND_WIDTH } from "./WIND_FIELD.js";
+import { WIND_FIELD_BAND_WIDTH, WIND_FIELD_CASCADE_LIMIT } from "./WIND_FIELD.js";
 import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
 
 /**
@@ -12,8 +12,8 @@ import { WIND_FIELD_STRUCT } from "./WIND_FIELD_STRUCT.js";
  * {@link wind_field_add_resources} declares them.
  *
  * **The read:**
- * - `clipmap_select_finest` walks the cascades' windows, finest first, and the first holding the point
- *   answers, with how far into its edge band of {@link WIND_FIELD_BAND_WIDTH} cells the point is;
+ * - the cascades' windows are walked finest first, each by `clipmap_level_select`, and the first holding
+ *   the point answers, with how far into its edge band of {@link WIND_FIELD_BAND_WIDTH} cells the point is;
  * - a cascade's read is the atmosphere identity, `v_far(t) + tap · k_c`: one trilinear tap of its tile,
  *   which holds `v − v_far(t_s,c)` at cell centres, times its decay;
  * - in the band, a second read blends in linearly, all of it on the window's face: the parent's
@@ -62,7 +62,16 @@ fn wind_field_cascade_read(c: u32, position_ws: vec3<f32>) -> vec3<f32> {
 fn wind_field_sample(position_ws: vec3<f32>) -> vec3<f32> {
     let count = wind_field.cascade_count;
 
-    let selection = clipmap_select_finest(&wind_field.levels, count, position_ws, WIND_FIELD_BAND_WIDTH);
+    var selection = ClipmapSelection(CLIPMAP_LEVEL_NONE, 0.0);
+
+    for (var i = 0u; i < min(count, ${WIND_FIELD_CASCADE_LIMIT}u); i++) {
+        let weight = clipmap_level_select(wind_field.levels[i], position_ws, WIND_FIELD_BAND_WIDTH);
+
+        if (weight >= 0.0) {
+            selection = ClipmapSelection(i, weight);
+            break;
+        }
+    }
 
     if (selection.level == CLIPMAP_LEVEL_NONE) {
         return wind_field.far_velocity;

package/src/shade/util/texture_mip_extent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"texture_mip_extent.d.ts","sourceRoot":"","sources":["../../../../src/shade/util/texture_mip_extent.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,uCAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,0CARW,MAAM,UACN,MAAM,mBACN,MAAM,aACN,sBAAoB,MAAM,SAC1B,MAAM,GACJ,MAAM,EAAE,CAYpB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,+CANW,MAAM,UACN,MAAM,mBACN,MAAM,aACN,sBAAoB,MAAM,GACxB,MAAM,CA0BlB"}
+{"version":3,"file":"texture_mip_extent.d.ts","sourceRoot":"","sources":["../../../../src/shade/util/texture_mip_extent.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,uCAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,0CARW,MAAM,UACN,MAAM,mBACN,MAAM,aACN,sBAAoB,MAAM,SAC1B,MAAM,GACJ,MAAM,EAAE,CAYpB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,+CANW,MAAM,UACN,MAAM,mBACN,MAAM,aACN,sBAAoB,MAAM,GACxB,MAAM,CA0BlB"}

package/src/shade/util/texture_mip_extent.js

@@ -1,87 +1,88 @@
-import { assert } from "../../core/assert.js";
-
-/**
- * One dimension of a texture at `level`.
- *
- * Halving, floored at 1 — a 1024-wide texture is still 1 texel wide at level 10 and at level 20.
- * Trivial, and re-derived in enough places that getting it wrong is a real event rather than a
- * hypothetical one.
- *
- * @param {number} size texels, at the base level
- * @param {number} level
- * @returns {number} texels, at `level`
- */
-export function texture_mip_size(size, level) {
-    return Math.max(size >> level, 1);
-}
-
-/**
- * The extent of a texture at `level`.
- *
- * **Only a 3D texture's depth halves.** The third component of an array texture is a layer count,
- * and every layer carries every mip — so it does not shrink with the others. That single distinction
- * is the reason this exists as a named thing: written out by hand it reads as an obvious `>> level`
- * on all three components, and that mistake under-reported a six-layer cube map's memory by close to
- * half and would have uploaded its levels at the wrong extent.
- *
- * @param {number} width texels, at the base level
- * @param {number} height texels, at the base level
- * @param {number} depth_or_layers depth for a 3D texture, layer count otherwise
- * @param {GPUTextureDimension|string} dimension
- * @param {number} level
- * @returns {number[]} `[width, height, depthOrArrayLayers]` at `level`, in the shape
- * `GPUExtent3D` takes
- */
-export function texture_mip_extent(width, height, depth_or_layers, dimension, level) {
-    assert.isString(dimension, 'dimension');
-    assert.isNonNegativeInteger(level, 'level');
-
-    return [
-        texture_mip_size(width, level),
-        texture_mip_size(height, level),
-        dimension === "3d" ? texture_mip_size(depth_or_layers, level) : depth_or_layers,
-    ];
-}
-
-/**
- * The number of levels in a texture's full mip chain.
- *
- * The count that {@link texture_mip_extent} implies: the chain runs until every halving axis has
- * reached 1, so it is as long as the longest axis that halves. **Only a 3D texture's depth halves**
- * — the same distinction, one derivative up. Written as `max(width, height)` it silently truncates
- * every volume deeper than it is wide: a 4x4x16 has five levels and that reading gives three, while
- * `texture_mip_extent` will happily report the extent of all five.
- *
- * A zero-sized texture has no levels. Any other size has at least one, which is what the `+ 1` is.
- *
- * @param {number} width texels, at the base level
- * @param {number} height texels, at the base level
- * @param {number} depth_or_layers depth for a 3D texture, layer count otherwise
- * @param {GPUTextureDimension|string} dimension
- * @returns {number}
- */
-export function texture_mip_level_count(width, height, depth_or_layers, dimension) {
-    assert.isString(dimension, 'dimension');
-
-    assert.isNumber(width, 'width');
-    assert.isNumber(height, 'height');
-    assert.isNumber(depth_or_layers, 'depth_or_layers');
-
-    assert.notNaN(width, 'width');
-    assert.notNaN(height, 'height');
-    assert.notNaN(depth_or_layers, 'depth_or_layers');
-
-    assert.greaterThanOrEqual(width, 0, 'width');
-    assert.greaterThanOrEqual(height, 0, 'height');
-    assert.greaterThanOrEqual(depth_or_layers, 0, 'depth_or_layers');
-
-    const longest = dimension === "3d"
-        ? Math.max(width, height, depth_or_layers)
-        : Math.max(width, height);
-
-    if (longest === 0) {
-        return 0;
-    }
-
-    return Math.floor(Math.log2(longest)) + 1;
-}
+import { assert } from "../../core/assert.js";
+import { msb_32 } from "../../core/binary/msb_32.js";
+
+/**
+ * One dimension of a texture at `level`.
+ *
+ * Halving, floored at 1 — a 1024-wide texture is still 1 texel wide at level 10 and at level 20.
+ * Trivial, and re-derived in enough places that getting it wrong is a real event rather than a
+ * hypothetical one.
+ *
+ * @param {number} size texels, at the base level
+ * @param {number} level
+ * @returns {number} texels, at `level`
+ */
+export function texture_mip_size(size, level) {
+    return Math.max(size >> level, 1);
+}
+
+/**
+ * The extent of a texture at `level`.
+ *
+ * **Only a 3D texture's depth halves.** The third component of an array texture is a layer count,
+ * and every layer carries every mip — so it does not shrink with the others. That single distinction
+ * is the reason this exists as a named thing: written out by hand it reads as an obvious `>> level`
+ * on all three components, and that mistake under-reported a six-layer cube map's memory by close to
+ * half and would have uploaded its levels at the wrong extent.
+ *
+ * @param {number} width texels, at the base level
+ * @param {number} height texels, at the base level
+ * @param {number} depth_or_layers depth for a 3D texture, layer count otherwise
+ * @param {GPUTextureDimension|string} dimension
+ * @param {number} level
+ * @returns {number[]} `[width, height, depthOrArrayLayers]` at `level`, in the shape
+ * `GPUExtent3D` takes
+ */
+export function texture_mip_extent(width, height, depth_or_layers, dimension, level) {
+    assert.isString(dimension, 'dimension');
+    assert.isNonNegativeInteger(level, 'level');
+
+    return [
+        texture_mip_size(width, level),
+        texture_mip_size(height, level),
+        dimension === "3d" ? texture_mip_size(depth_or_layers, level) : depth_or_layers,
+    ];
+}
+
+/**
+ * The number of levels in a texture's full mip chain.
+ *
+ * The count that {@link texture_mip_extent} implies: the chain runs until every halving axis has
+ * reached 1, so it is as long as the longest axis that halves. **Only a 3D texture's depth halves**
+ * — the same distinction, one derivative up. Written as `max(width, height)` it silently truncates
+ * every volume deeper than it is wide: a 4x4x16 has five levels and that reading gives three, while
+ * `texture_mip_extent` will happily report the extent of all five.
+ *
+ * A zero-sized texture has no levels. Any other size has at least one, which is what the `+ 1` is.
+ *
+ * @param {number} width texels, at the base level
+ * @param {number} height texels, at the base level
+ * @param {number} depth_or_layers depth for a 3D texture, layer count otherwise
+ * @param {GPUTextureDimension|string} dimension
+ * @returns {number}
+ */
+export function texture_mip_level_count(width, height, depth_or_layers, dimension) {
+    assert.isString(dimension, 'dimension');
+
+    assert.isNumber(width, 'width');
+    assert.isNumber(height, 'height');
+    assert.isNumber(depth_or_layers, 'depth_or_layers');
+
+    assert.notNaN(width, 'width');
+    assert.notNaN(height, 'height');
+    assert.notNaN(depth_or_layers, 'depth_or_layers');
+
+    assert.greaterThanOrEqual(width, 0, 'width');
+    assert.greaterThanOrEqual(height, 0, 'height');
+    assert.greaterThanOrEqual(depth_or_layers, 0, 'depth_or_layers');
+
+    const longest = dimension === "3d"
+        ? Math.max(width, height, depth_or_layers)
+        : Math.max(width, height);
+
+    if (longest === 0) {
+        return 0;
+    }
+
+    return msb_32(longest) + 1;
+}

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAg3DA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAk3DA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}

package/src/shade/wgsl/emulator/WGSLLanguageCore.js

@@ -1,6 +1,8 @@
 import { assert } from "../../../core/assert.js";
 import { cpu_texture_gather, evaluate_gpu_compare_function } from "./cpu_texture_gather.js";
 import { cpu_texture_sample } from "./cpu_texture_sample.js";
+import { msb_32 } from "../../../core/binary/msb_32.js";
+import { ctz32 } from "../../../core/binary/ctz32.js";
 
 /**
  * Default sampler descriptor for `textureSample` / `textureSampleLevel`
@@ -728,7 +730,7 @@ export const WGSLLanguageCore = {
     countLeadingZeros: (e) => unop(e, x => Math.clz32(x)),
 
     /** `countTrailingZeros(e)` — number of consecutive zero bits below the least significant set bit; 32 for 0. */
-    countTrailingZeros: (e) => unop(e, x => (x === 0 ? 32 : 31 - Math.clz32(x & -x))),
+    countTrailingZeros: (e) => unop(e, x => ctz32(x)),
 
     /** `countOneBits(e)` — population count. */
     countOneBits: (e) => unop(e, x => {
@@ -744,10 +746,10 @@ export const WGSLLanguageCore = {
     }),
 
     /** `firstLeadingBit(e)` — index of the most significant set bit; `0xffffffff` for 0 (u32 reading). */
-    firstLeadingBit: (e) => unop(e, x => (x === 0 ? 0xffffffff : 31 - Math.clz32(x))),
+    firstLeadingBit: (e) => unop(e, x => (x === 0 ? 0xffffffff : msb_32(x))),
 
     /** `firstLeadingBit(e: u32)` — as above; named so the compiler can pick it by operand type. */
-    firstLeadingBit_u32: (e) => unop(e, x => (x === 0 ? 0xffffffff : 31 - Math.clz32(x >>> 0))),
+    firstLeadingBit_u32: (e) => unop(e, x => (x === 0 ? 0xffffffff : msb_32(x))),
 
     /**
      * `firstLeadingBit(e: i32)` — the position of the most significant bit DIFFERENT from the sign
@@ -765,17 +767,17 @@ export const WGSLLanguageCore = {
         }
 
         // for a negative value the search is for the most significant ZERO
-        return 31 - Math.clz32((v < 0 ? ~v : v) >>> 0);
+        return msb_32(v < 0 ? ~v : v);
     }),
 
     /** `firstTrailingBit(e)` — index of the least significant set bit; `0xffffffff` for 0. */
-    firstTrailingBit: (e) => unop(e, x => (x === 0 ? 0xffffffff : 31 - Math.clz32(x & -x))),
+    firstTrailingBit: (e) => unop(e, x => (x === 0 ? 0xffffffff : ctz32(x))),
 
     /** `firstTrailingBit(e: u32)` — as above. */
-    firstTrailingBit_u32: (e) => unop(e, x => (x === 0 ? 0xffffffff : 31 - Math.clz32(x & -x))),
+    firstTrailingBit_u32: (e) => unop(e, x => (x === 0 ? 0xffffffff : ctz32(x))),
 
     /** `firstTrailingBit(e: i32)` — as above, but the "no bit" answer is -1, in this type's sign. */
-    firstTrailingBit_i32: (e) => unop(e, x => ((x | 0) === 0 ? -1 : 31 - Math.clz32(x & -x))),
+    firstTrailingBit_i32: (e) => unop(e, x => ((x | 0) === 0 ? -1 : ctz32(x))),
 
     /** `reverseBits(e)` — reverse the order of all 32 bits. */
     reverseBits: (e) => unop(e, x => {

package/src/format/image/avif/av1/util/ceil_log2.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ceil_log2.d.ts","sourceRoot":"","sources":["../../../../../../../src/format/image/avif/av1/util/ceil_log2.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,6BAPW,MAAM,GACJ,MAAM,CAYlB"}