@woosh/meep-engine 3.58.0 → 3.60.0

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

@@ -3,8 +3,17 @@ import { chunk_get_ibl_radiance } from "../deferred/indirect/chunk_get_ibl_radia
 import {
     chunk_brick4_sample_forward_indirect
 } from "../global_illumination/brick4/gpu/draw/chunk_brick4_sample_forward_indirect.js";
+import { chunk_probe_clipmap_pick } from "../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js";
+import {
+    chunk_probe_clipmap_sample_radiance
+} from "../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js";
 import { INDIRECT_LIGHTING } from "../INDIRECT_LIGHTING.js";
 import { ShadeIndirectLightingMode } from "../ShadeIndirectLightingMode.js";
+import { PI_DECLARATION } from "../shader/chunk/math/PI_DECLARATION.js";
+import { chunk_jitter_from_vectors } from "../shader/chunk/random/chunk_jitter_from_vectors.js";
+import {
+    chunk_resolve_irradiance_sh_to_diffuse
+} from "../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_diffuse.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
 
@@ -19,7 +28,7 @@ import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
    missed on screen falls back to. view_direction points from the surface to the camera.
 
  LPV has no transparent sampling: like the transparent meshes, water uses the environment under it.
- So does the probe clipmap, until it samples its own probes.
+ The probe clipmap gives both from its probes, the environment where none weighs anything.
 */
 
 /**
@@ -59,9 +68,42 @@ fn water_gi_specular(position: vec3<f32>, normal: vec3<f32>, view_direction: vec
 `, [chunk_brick4_sample_forward_indirect]);
 
 /**
- * The water's indirect lighting by the renderer's mode ({@link INDIRECT_LIGHTING}): IBL, LPV and
- * ProbeClipmap {@link chunk_water_gi_ibl}, Brick4 {@link chunk_water_gi_brick4}. A pipeline that links it binds
- * `tEnvironment`, `brick4` and `view`, and reads only its own mode's.
+ * The probe clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.5): each call one pick at the point, jittered by a
+ * hash of the point and the normal, as Brick4's is. The irradiance is π × the picked SH resolved at the normal,
+ * the normal standing in for the view, which the irradiance call has none of. The specular is the probes'
+ * radiance picked by the normal and the view (§9.3). Where no probe weighs anything, each is the environment's.
+ * Reads the probes' group, `view` and `tEnvironment`.
+ * @type {CodeChunk}
+ */
+export const chunk_water_gi_probe_clipmap = CodeChunk.from(/* language=WGSL */ `
+fn water_gi_irradiance(position: vec3<f32>, normal: vec3<f32>) -> vec3<f32> {
+    let probes = probe_clipmap_sample_sh(position, normal, normal, jitter_from_vectors(position, normal));
+
+    if (probes.found) {
+        // the resolve gives E/π
+        return PI * resolve_irradiance_sh_to_diffuse(probes.sh.Y, probes.sh.CoCg, normal);
+    }
+
+    return get_ibl_irradiance(normal);
+}
+
+fn water_gi_specular(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32) -> vec3<f32> {
+    let probes = probe_clipmap_sample_radiance(position, normal, view_direction, roughness, jitter_from_vectors(position, normal));
+
+    if (probes.found) {
+        return probes.radiance;
+    }
+
+    return get_ibl_radiance(view_direction, normal, roughness);
+}
+`, [chunk_probe_clipmap_pick, chunk_probe_clipmap_sample_radiance, chunk_resolve_irradiance_sh_to_diffuse,
+    chunk_jitter_from_vectors, PI_DECLARATION, chunk_get_ibl_irradiance, chunk_get_ibl_radiance]);
+
+/**
+ * The water's indirect lighting by the renderer's mode ({@link INDIRECT_LIGHTING}): IBL and LPV
+ * {@link chunk_water_gi_ibl}, Brick4 {@link chunk_water_gi_brick4}, ProbeClipmap
+ * {@link chunk_water_gi_probe_clipmap}. A pipeline that links it binds `tEnvironment`, `brick4`, the probes'
+ * group and `view`, and reads only its own mode's.
  * @type {CodeChunkChoice}
  */
 export const chunk_water_gi = CodeChunkChoice.from(INDIRECT_LIGHTING);
@@ -69,4 +111,4 @@ export const chunk_water_gi = CodeChunkChoice.from(INDIRECT_LIGHTING);
 chunk_water_gi.add(ShadeIndirectLightingMode.IBL, chunk_water_gi_ibl);
 chunk_water_gi.add(ShadeIndirectLightingMode.Brick4, chunk_water_gi_brick4);
 chunk_water_gi.add(ShadeIndirectLightingMode.LPV, chunk_water_gi_ibl);
-chunk_water_gi.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_water_gi_ibl);
+chunk_water_gi.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_water_gi_probe_clipmap);

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 "__#271@#execute"(pass: any, resources: any, context: any): void;
+    static "__#273@#execute"(pass: any, resources: any, context: any): void;
     /**
      * @param {object} options
      * @param {GPUDevice} options.device

package/src/shade/renderer/water/shader_water.d.ts

@@ -3,8 +3,9 @@ export function create_water_pipeline(): RenderPipelineDescriptor;
 export function create_water_finalize_pipeline(switches: any): RenderPipelineDescriptor;
 export const WATER_TRACE_STRUCT: WebGPUStruct;
 /**
- * The optics: the lights, the environment, and the light map with the view its sampling jitters by.
- * Every indirect lighting mode's resources, whichever the pipeline's variant reads (`chunk_water_gi`).
+ * The optics: the lights, the environment, the light map and the probe clipmap's probes, with the view
+ * their sampling jitters by. Every indirect lighting mode's resources, whichever the pipeline's variant
+ * reads (`chunk_water_gi`).
  */
 export const WATER_FINALIZE_RESOURCES: ShaderResourceSetDescriptor;
 export const chunk_water_screen_ray: CodeChunk;

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

@@ -1 +1 @@
-{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AAyoBA,kEAAuH;AACvH,gFAAgF;AAChF,wFAEC;AAzlBD,8CAKwB;AAwCxB;;;GAGG;AACH,mEAA8D;AA4O9D,+CAsFmB;AAoMnB,4CAAmG;AACnG,uGAAuG;AACvG,qDACgE;AAChE,0DAAyC;yCA7mBA,8DAA8D;6BAwB1E,gCAAgC;4CAJjB,mDAAmD;0BAPrE,iCAAiC;iCAQ1B,+BAA+B"}
+{"version":3,"file":"shader_water.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/shader_water.js"],"names":[],"mappings":"AA+oBA,kEAAuH;AACvH,gFAAgF;AAChF,wFAEC;AA9lBD,8CAKwB;AAwCxB;;;;GAIG;AACH,mEAA8D;AAgP9D,+CAsFmB;AAoMnB,4CAAmG;AACnG,uGAAuG;AACvG,qDACgE;AAChE,0DAAyC;yCAnnBA,8DAA8D;6BAyB1E,gCAAgC;4CAJjB,mDAAmD;0BAPrE,iCAAiC;iCAQ1B,+BAA+B"}

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

@@ -4,6 +4,7 @@ import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/Rende
 import { CAMERA_RESOURCE } from "../camera/CAMERA_RESOURCE.js";
 import { SHADING_LIGHT_RESOURCE_GROUP } from "../deferred/SHADING_LIGHT_RESOURCE_GROUP.js";
 import { BRICK4_DATA_STRUCT } from "../global_illumination/brick4/gpu/BRICK4_DATA_STRUCT.js";
+import { PROBE_CLIPMAP_SAMPLING_GROUP } from "../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js";
 import { chunk_F_dielectric } from "../shader/chunk/brdf/fresnel/chunk_F_dielectric.js";
 import { chunk_direction_view_to_world } from "../shader/chunk/camera/chunk_direction_view_to_world.js";
 import { chunk_direction_world_to_view } from "../shader/chunk/camera/chunk_direction_world_to_view.js";
@@ -96,14 +97,19 @@ function water_resources(finalize = false) {
 const resources = water_resources();
 
 /**
- * The optics: the lights, the environment, and the light map with the view its sampling jitters by.
- * Every indirect lighting mode's resources, whichever the pipeline's variant reads (`chunk_water_gi`).
+ * The optics: the lights, the environment, the light map and the probe clipmap's probes, with the view
+ * their sampling jitters by. Every indirect lighting mode's resources, whichever the pipeline's variant
+ * reads (`chunk_water_gi`).
  */
 export const WATER_FINALIZE_RESOURCES = water_resources(true);
 WATER_FINALIZE_RESOURCES.addGroup(SHADING_LIGHT_RESOURCE_GROUP);
-WATER_FINALIZE_RESOURCES.createGroup()
+const WATER_INDIRECT_GROUP = WATER_FINALIZE_RESOURCES.createGroup()
     .addStorageBuffer("brick4", BRICK4_DATA_STRUCT, false)
     .addUniform("view", VIEW_UNIFORM_STRUCT);
+// their owner binds them in every mode
+for (const declaration of PROBE_CLIPMAP_SAMPLING_GROUP.resources) {
+    WATER_INDIRECT_GROUP.add(declaration);
+}
 
 const surface_body = CodeChunk.from(/* language=WGSL */ `
 struct WaterVertexOut {

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

@@ -42,7 +42,7 @@ export class GPUSceneWind {
      * @param {number} capacity
      * @returns {GPUTileAtlas3D}
      */
-    static "__#173@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
+    static "__#169@#make_atlas"(device: GPUDevice, content: ArrayLike<number>, capacity: number): GPUTileAtlas3D;
     /**
      * @param {GPUDevice} device
      */

package/src/shade/wgsl/emulator/CPUBitmapData.d.ts

@@ -126,6 +126,25 @@ export class CPUBitmapData {
      * @type {boolean}
      */
     is_depth: boolean;
+    /**
+     * The texture's mip levels past its first, finest first: level `k` is `levels[k - 1]`, and this
+     * bitmap is level 0. Each level's extent is its own bitmap's, so a caller says which axes halve —
+     * an array texture's layers do not, a volume's depth does.
+     *
+     * Empty by default: a texture whose mipmaps are not modelled, every level a shader names reading
+     * this bitmap, as the emulator always did. One that carries levels serves each from its own, and a
+     * level past them reads zero, as robust access may on a device.
+     *
+     * @type {CPUBitmapData[]}
+     */
+    levels: CPUBitmapData[];
+    /**
+     * The bitmap holding mip `level`; see {@link levels}.
+     *
+     * @param {number} level
+     * @returns {CPUBitmapData|undefined} undefined for a level past those carried
+     */
+    level(level: number): CPUBitmapData | undefined;
     /** @returns {number} */
     get width(): number;
     /** @returns {number} */

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

@@ -1 +1 @@
-{"version":3,"file":"CPUBitmapData.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/CPUBitmapData.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAgJI;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,yBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,yBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,uBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;;;;OAQG;IACH,sBALW,MAAM,WACN,MAAM,UACN,MAAM,GACJ,aAAa,CAQzB;IA3MD;;;;;;OAMG;IACH,kBANW,UAAU,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,EAmBhB;IA3DD;;;OAGG;IACH,MAFU,YAAY,kBAAkB,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,EAAE,CAE1H;IAEL;;;OAGG;IACH,WAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;;;;;;;;;;;OAaG;IACH,UAFU,OAAO,CAEA;IA4BjB,wBAAwB;IACxB,oBAAoC;IACpC,wBAAwB;IACxB,qBAAqC;IACrC,wBAAwB;IACxB,oBAAoC;IAEpC;;;;;;;;;OASG;IACH,gCAIC;IAED;;;;;;;OAOG;IACH,gBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;;;;;OASG;IACH,QANW,MAAM,KACN,MAAM,KACN,MAAM,OACN,UAAU,MAAM,CAAC,GAAG;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,eAC3C,MAAM,QAWhB;IAED;;;;;;;;;OASG;IACH,SANW,MAAM,KACN,MAAM,KACN,MAAM,OACN,UAAU,MAAM,CAAC,eACjB,MAAM,QAQhB;CAwGJ"}
+{"version":3,"file":"CPUBitmapData.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/CPUBitmapData.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IA2KI;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,yBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,yBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,uBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,wBALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;OAKG;IACH,0BALW,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,iBAIhB;IAED;;;;;;;;OAQG;IACH,sBALW,MAAM,WACN,MAAM,UACN,MAAM,GACJ,aAAa,CAQzB;IA3MD;;;;;;OAMG;IACH,kBANW,UAAU,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,WACN,MAAM,UACN,MAAM,EAmBhB;IAtFD;;;OAGG;IACH,MAFU,YAAY,kBAAkB,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,WAAW,GAAG,MAAM,EAAE,CAE1H;IAEL;;;OAGG;IACH,WAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;;;;;;;;;;;OAaG;IACH,UAFU,OAAO,CAEA;IAEjB;;;;;;;;;;OAUG;IACH,QAFU,aAAa,EAAE,CAEb;IAEZ;;;;;OAKG;IACH,aAHW,MAAM,GACJ,aAAa,GAAC,SAAS,CAQnC;IA4BD,wBAAwB;IACxB,oBAAoC;IACpC,wBAAwB;IACxB,qBAAqC;IACrC,wBAAwB;IACxB,oBAAoC;IAEpC;;;;;;;;;OASG;IACH,gCAIC;IAED;;;;;;;OAOG;IACH,gBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB;IAED;;;;;;;;;OASG;IACH,QANW,MAAM,KACN,MAAM,KACN,MAAM,OACN,UAAU,MAAM,CAAC,GAAG;QAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,eAC3C,MAAM,QAWhB;IAED;;;;;;;;;OASG;IACH,SANW,MAAM,KACN,MAAM,KACN,MAAM,OACN,UAAU,MAAM,CAAC,eACjB,MAAM,QAQhB;CAwGJ"}

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

@@ -58,6 +58,33 @@ export class CPUBitmapData {
      */
     is_depth = false;
 
+    /**
+     * The texture's mip levels past its first, finest first: level `k` is `levels[k - 1]`, and this
+     * bitmap is level 0. Each level's extent is its own bitmap's, so a caller says which axes halve —
+     * an array texture's layers do not, a volume's depth does.
+     *
+     * Empty by default: a texture whose mipmaps are not modelled, every level a shader names reading
+     * this bitmap, as the emulator always did. One that carries levels serves each from its own, and a
+     * level past them reads zero, as robust access may on a device.
+     *
+     * @type {CPUBitmapData[]}
+     */
+    levels = [];
+
+    /**
+     * The bitmap holding mip `level`; see {@link levels}.
+     *
+     * @param {number} level
+     * @returns {CPUBitmapData|undefined} undefined for a level past those carried
+     */
+    level(level) {
+        if (level === 0 || this.levels.length === 0) {
+            return this;
+        }
+
+        return this.levels[level - 1];
+    }
+
     /**
      * @param {ArrayLike<number>} data
      * @param {number} item_size

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":";IAk0DA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAu1DA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}

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

@@ -26,6 +26,18 @@ const FALLBACK_LINEAR_CLAMP_SAMPLER = Object.freeze({
  * @param {import("./CPUBitmapData.js").CPUBitmapData} texture
  * @returns {number[]}
  */
+/**
+ * The bitmap holding mip `level` of texture `t` — `t` itself at level 0, so whatever a spec binds in
+ * place of a {@link CPUBitmapData} still serves its one level; see `CPUBitmapData.levels`.
+ *
+ * @param {import("./CPUBitmapData.js").CPUBitmapData} t
+ * @param {number} level
+ * @returns {import("./CPUBitmapData.js").CPUBitmapData|undefined} undefined past the levels `t` carries
+ */
+function texture_level(t, level) {
+    return level === 0 ? t : t.level(level);
+}
+
 /**
  * How many axes a texel coordinate addresses: a scalar for a 1D texture, a vector of the texture's
  * dimension otherwise. WGSL makes a coordinate match the texture's declaration, so this is the
@@ -1182,8 +1194,9 @@ export const WGSLLanguageCore = {
     // load and store builtins count the axes of their coordinate, and `textureDimensions` is
     // compiled to the variant its declaration selects. Sampling routes through
     // `cpu_texture_sample`, which honours the bound `SamplerDescriptor`'s
-    // address modes and filter. Mipmaps are not modelled (LOD 0 only) -
-    // see cpu_texture_sample header for details.
+    // address modes and filter. Sampling reads LOD 0 only - see cpu_texture_sample
+    // header for details. `textureLoad` and `textureDimensions` read the level they
+    // name of a bitmap that carries its levels (`CPUBitmapData.levels`).
     // ---------------------------------------------------------------------
 
     /**
@@ -1199,9 +1212,13 @@ export const WGSLLanguageCore = {
      * as such. Handing that code a vec4 would turn every use into a component-wise broadcast that
      * neither throws nor matches the device.
      *
+     * The level named reads that level of a bitmap carrying its levels, and zero past them; a bitmap
+     * carrying none serves every level from itself (`CPUBitmapData.levels`).
+     *
      * @param {import("./CPUBitmapData.js").CPUBitmapData} t
      * @param {Int32Array | Uint32Array | number[] | number} coords
-     * @param {number} [_level] - ignored, mipmaps are not modelled
+     * @param {number} [_level_or_index] - the level, or the array index in the four-argument form
+     * @param {number} [_array_level] - the level in the four-argument form
      * @returns {Float32Array | number}
      */
     textureLoad(t, coords, _level_or_index = 0, _array_level = undefined) {
@@ -1218,20 +1235,22 @@ export const WGSLLanguageCore = {
          CPUBitmapData, exactly like a 3D texture; only the call shape tells them apart.
         */
         const z = (_array_level !== undefined ? _level_or_index : (dim >= 3 ? coords[2] : 0)) | 0;
+        const level = texture_level(t, (_array_level !== undefined ? _array_level : _level_or_index) | 0);
         const item_size = t.item_size;
-        const out_of_bounds = x < 0 || x >= t.size[0] || y < 0 || y >= t.size[1] || z < 0 || z >= t.size[2];
+        const out_of_bounds = level === undefined
+            || x < 0 || x >= level.size[0] || y < 0 || y >= level.size[1] || z < 0 || z >= level.size[2];
 
         if (t.is_depth === true) {
-            return out_of_bounds ? 0.0 : t.data[t.pixel_offset(x, y, z)];
+            return out_of_bounds ? 0.0 : level.data[level.pixel_offset(x, y, z)];
         }
 
         if (item_size < 4) out[3] = 1.0;
         if (out_of_bounds) {
             return out;
         }
-        const base = t.pixel_offset(x, y, z);
+        const base = level.pixel_offset(x, y, z);
         const n = Math.min(item_size, 4);
-        for (let i = 0; i < n; i++) out[i] = t.data[base + i];
+        for (let i = 0; i < n; i++) out[i] = level.data[base + i];
         return out;
     },
 
@@ -1584,8 +1603,8 @@ export const WGSLLanguageCore = {
         t.write(x, y, z, value_or_index);
     },
 
-    // CPUBitmapData models one stored mip level.
-    textureNumLevels(_t) { return 1; },
+    // the levels the bitmap carries, itself the first (`CPUBitmapData.levels`)
+    textureNumLevels(t) { return 1 + t.levels.length; },
 
     /*
      `textureDimensions(t, level)` comes in three variants, one per number of components it returns,
@@ -1597,35 +1616,37 @@ export const WGSLLanguageCore = {
     /**
      * `textureDimensions` of a `texture_1d` or `texture_storage_1d`.
      * @param {import("./CPUBitmapData.js").CPUBitmapData} t
-     * @param {number} [_level] - ignored, mipmaps are not modelled
+     * @param {number} [level] - of a bitmap carrying its levels; see `CPUBitmapData.levels`
      * @returns {number}
      */
-    textureDimensions_1d(t, _level = 0) {
+    textureDimensions_1d(t, level = 0) {
         assert.defined(t, 'texture');
-        return t.size[0];
+        return texture_level(t, level).size[0];
     },
 
     /**
      * `textureDimensions` of a 2D, array, cube or multisampled texture. An array texture's layers
      * are not part of it.
      * @param {import("./CPUBitmapData.js").CPUBitmapData} t
-     * @param {number} [_level] - ignored, mipmaps are not modelled
+     * @param {number} [level] - of a bitmap carrying its levels; see `CPUBitmapData.levels`
      * @returns {Uint32Array}
      */
-    textureDimensions_2d(t, _level = 0) {
+    textureDimensions_2d(t, level = 0) {
         assert.defined(t, 'texture');
-        return new Uint32Array([t.size[0], t.size[1]]);
+        const size = texture_level(t, level).size;
+        return new Uint32Array([size[0], size[1]]);
     },
 
     /**
      * `textureDimensions` of a `texture_3d` or `texture_storage_3d`.
      * @param {import("./CPUBitmapData.js").CPUBitmapData} t
-     * @param {number} [_level] - ignored, mipmaps are not modelled
+     * @param {number} [level] - of a bitmap carrying its levels; see `CPUBitmapData.levels`
      * @returns {Uint32Array}
      */
-    textureDimensions_3d(t, _level = 0) {
+    textureDimensions_3d(t, level = 0) {
         assert.defined(t, 'texture');
-        return new Uint32Array([t.size[0], t.size[1], t.size[2]]);
+        const size = texture_level(t, level).size;
+        return new Uint32Array([size[0], size[1], size[2]]);
     },
 
     // ---------------------------------------------------------------------

package/src/view/elements/progress/segmented/GhostTrail.d.ts

@@ -0,0 +1,56 @@
+/**
+ * A value that trails another one down: the "ghost" behind a bar's fill that shows how much was just lost.
+ *
+ * When the target drops, the trail holds where it was for {@link delay_ms}, then eases down to the target over
+ * {@link duration_ms}. A further drop while it holds or eases restarts the hold from wherever the trail is. When
+ * the target rises above the trail, the trail jumps to it at once.
+ *
+ * Time is passed in, in milliseconds on any monotonic clock, so the trail can be driven and checked without one.
+ */
+export class GhostTrail {
+    /**
+     * How long the trail holds after a drop before it starts to move
+     * @type {number}
+     */
+    delay_ms: number;
+    /**
+     * How long the ease from the held value down to the target takes; 0 snaps once the hold ends
+     * @type {number}
+     */
+    duration_ms: number;
+    /**
+     * @type {number}
+     * @private
+     */
+    private __from;
+    /**
+     * @type {number}
+     * @private
+     */
+    private __to;
+    /**
+     * When the current hold began
+     * @type {number}
+     * @private
+     */
+    private __drop_time;
+    /**
+     * Tell the trail its target's new value.
+     * @param {number} target
+     * @param {number} time_ms
+     */
+    set(target: number, time_ms: number): void;
+    /**
+     * Where the trail is at a given time; never below its target.
+     * @param {number} time_ms
+     * @returns {number}
+     */
+    sample(time_ms: number): number;
+    /**
+     * Whether the trail has reached its target and will not move until {@link set} is called again
+     * @param {number} time_ms
+     * @returns {boolean}
+     */
+    is_settled(time_ms: number): boolean;
+}
+//# sourceMappingURL=GhostTrail.d.ts.map

package/src/view/elements/progress/segmented/GhostTrail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GhostTrail.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/GhostTrail.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH;IACI;;;OAGG;IACH,UAFU,MAAM,CAED;IAEf;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,eAAW;IAEX;;;OAGG;IACH,aAAS;IAET;;;;OAIG;IACH,oBAAgB;IAEhB;;;;OAIG;IACH,YAHW,MAAM,WACN,MAAM,QAahB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAM,CAuBlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,OAAO,CAInB;CACJ"}

package/src/view/elements/progress/segmented/GhostTrail.js

@@ -0,0 +1,98 @@
+import { smoothStep } from "../../../../core/math/smoothStep.js";
+
+/**
+ * A value that trails another one down: the "ghost" behind a bar's fill that shows how much was just lost.
+ *
+ * When the target drops, the trail holds where it was for {@link delay_ms}, then eases down to the target over
+ * {@link duration_ms}. A further drop while it holds or eases restarts the hold from wherever the trail is. When
+ * the target rises above the trail, the trail jumps to it at once.
+ *
+ * Time is passed in, in milliseconds on any monotonic clock, so the trail can be driven and checked without one.
+ */
+export class GhostTrail {
+    /**
+     * How long the trail holds after a drop before it starts to move
+     * @type {number}
+     */
+    delay_ms = 450;
+
+    /**
+     * How long the ease from the held value down to the target takes; 0 snaps once the hold ends
+     * @type {number}
+     */
+    duration_ms = 350;
+
+    /**
+     * @type {number}
+     * @private
+     */
+    __from = 0;
+
+    /**
+     * @type {number}
+     * @private
+     */
+    __to = 0;
+
+    /**
+     * When the current hold began
+     * @type {number}
+     * @private
+     */
+    __drop_time = 0;
+
+    /**
+     * Tell the trail its target's new value.
+     * @param {number} target
+     * @param {number} time_ms
+     */
+    set(target, time_ms) {
+        const current = this.sample(time_ms);
+
+        if (target >= current) {
+            this.__from = target;
+            this.__to = target;
+        } else {
+            this.__from = current;
+            this.__to = target;
+            this.__drop_time = time_ms;
+        }
+    }
+
+    /**
+     * Where the trail is at a given time; never below its target.
+     * @param {number} time_ms
+     * @returns {number}
+     */
+    sample(time_ms) {
+        const from = this.__from;
+        const to = this.__to;
+
+        if (from === to) {
+            return to;
+        }
+
+        const start = this.__drop_time + this.delay_ms;
+
+        if (time_ms < start) {
+            return from;
+        }
+
+        const end = start + this.duration_ms;
+
+        if (time_ms >= end) {
+            return to;
+        }
+
+        return from + (to - from) * smoothStep(start, end, time_ms);
+    }
+
+    /**
+     * Whether the trail has reached its target and will not move until {@link set} is called again
+     * @param {number} time_ms
+     * @returns {boolean}
+     */
+    is_settled(time_ms) {
+        return this.__from === this.__to || time_ms >= this.__drop_time + this.delay_ms + this.duration_ms;
+    }
+}

package/src/view/elements/progress/segmented/RESOURCE_BAR_SEGMENTS.d.ts

@@ -1,5 +1,7 @@
 /**
- *
+ * @deprecated {@link SegmentedResourceBarView} no longer reads this: its canvas notches gave way to DOM notches
+ * styled by `segmented-resource-bar.css`, and this ladder's tiers changed meaning with the bar's max. Pass
+ * {@link SegmentTier}s as `tiers`, or rely on {@link SEGMENT_TIERS_DEFAULT}.
  * @type {SegmentDefinition[]}
  */
 export const RESOURCE_BAR_SEGMENTS: SegmentDefinition[];

package/src/view/elements/progress/segmented/RESOURCE_BAR_SEGMENTS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RESOURCE_BAR_SEGMENTS.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/RESOURCE_BAR_SEGMENTS.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oCAFU,iBAAiB,EAAE,CAiL3B;kCArLgC,wBAAwB"}
+{"version":3,"file":"RESOURCE_BAR_SEGMENTS.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/RESOURCE_BAR_SEGMENTS.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,oCAFU,iBAAiB,EAAE,CAiL3B;kCAvLgC,wBAAwB"}

package/src/view/elements/progress/segmented/RESOURCE_BAR_SEGMENTS.js

@@ -1,7 +1,9 @@
 import { SegmentDefinition } from "./SegmentDefinition.js";
 
 /**
- *
+ * @deprecated {@link SegmentedResourceBarView} no longer reads this: its canvas notches gave way to DOM notches
+ * styled by `segmented-resource-bar.css`, and this ladder's tiers changed meaning with the bar's max. Pass
+ * {@link SegmentTier}s as `tiers`, or rely on {@link SEGMENT_TIERS_DEFAULT}.
  * @type {SegmentDefinition[]}
  */
 export const RESOURCE_BAR_SEGMENTS = [

package/src/view/elements/progress/segmented/SEGMENT_TIERS_DEFAULT.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Decade ladder a {@link SegmentedResourceBarView} uses when given no tiers: a short notch every 10, a full one
+ * every 100, a wide one every 1000. Each marks the same amount on every bar; the finer ones drop out on bars
+ * where they would crowd. The class names are styled by `segmented-resource-bar.css`, and a caller's own tiers
+ * may reuse them.
+ *
+ * @type {SegmentTier[]}
+ */
+export const SEGMENT_TIERS_DEFAULT: SegmentTier[];
+import { SegmentTier } from "./SegmentTier.js";
+//# sourceMappingURL=SEGMENT_TIERS_DEFAULT.d.ts.map

package/src/view/elements/progress/segmented/SEGMENT_TIERS_DEFAULT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SEGMENT_TIERS_DEFAULT.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SEGMENT_TIERS_DEFAULT.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,oCAFU,WAAW,EAAE,CAMrB;4BAd0B,kBAAkB"}

package/src/view/elements/progress/segmented/SEGMENT_TIERS_DEFAULT.js

@@ -0,0 +1,15 @@
+import { SegmentTier } from "./SegmentTier.js";
+
+/**
+ * Decade ladder a {@link SegmentedResourceBarView} uses when given no tiers: a short notch every 10, a full one
+ * every 100, a wide one every 1000. Each marks the same amount on every bar; the finer ones drop out on bars
+ * where they would crowd. The class names are styled by `segmented-resource-bar.css`, and a caller's own tiers
+ * may reuse them.
+ *
+ * @type {SegmentTier[]}
+ */
+export const SEGMENT_TIERS_DEFAULT = [
+    SegmentTier.from(10, 'segment-tier-minor', 1, 4),
+    SegmentTier.from(100, 'segment-tier-major', 1, 3),
+    SegmentTier.from(1000, 'segment-tier-super', 2, 0),
+];

package/src/view/elements/progress/segmented/SegmentDefinition.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @deprecated a canvas-drawn notch, which {@link SegmentedResourceBarView} no longer uses; see {@link SegmentTier}
+ */
 export class SegmentDefinition {
     /**
      * @return {SegmentDefinition}

package/src/view/elements/progress/segmented/SegmentDefinition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SegmentDefinition.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SegmentDefinition.js"],"names":[],"mappings":"AAAA;IAaI;;;;OAIG;IACH,mBAHW,MAAM,kCADL,iBAAiB,CAW5B;IAxBD,cAAU;IAEV;;;;;OAKG;IACH,UAJW,wBAAwB,KACxB,MAAM,UACN,MAAM,QAIhB;CAeJ"}
+{"version":3,"file":"SegmentDefinition.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SegmentDefinition.js"],"names":[],"mappings":"AAAA;;GAEG;AACH;IAaI;;;;OAIG;IACH,mBAHW,MAAM,kCADL,iBAAiB,CAW5B;IAxBD,cAAU;IAEV;;;;;OAKG;IACH,UAJW,wBAAwB,KACxB,MAAM,UACN,MAAM,QAIhB;CAeJ"}

package/src/view/elements/progress/segmented/SegmentDefinition.js

@@ -1,3 +1,6 @@
+/**
+ * @deprecated a canvas-drawn notch, which {@link SegmentedResourceBarView} no longer uses; see {@link SegmentTier}
+ */
 export class SegmentDefinition {
     value = 0;
 

package/src/view/elements/progress/segmented/SegmentTier.d.ts

@@ -0,0 +1,38 @@
+/**
+ * One level of notch on a {@link SegmentedResourceBarView}.
+ *
+ * A tier has a fixed meaning: it marks every multiple of {@link unit} that no coarser tier marks, on every
+ * bar, whatever the bar's max. A tier is dropped when its notches would sit closer than
+ * {@link min_spacing_px} on screen, finest first.
+ */
+export class SegmentTier {
+    /**
+     * @param {number} unit
+     * @param {string} class_name
+     * @param {number} width_px
+     * @param {number} min_spacing_px
+     * @returns {SegmentTier}
+     */
+    static from(unit: number, class_name: string, width_px: number, min_spacing_px: number): SegmentTier;
+    /**
+     * Amount between two notches of this tier, in the bar's own units (e.g. 100 hit points)
+     * @type {number}
+     */
+    unit: number;
+    /**
+     * CSS class every notch of this tier carries; the stylesheet owns its colour, height and highlight
+     * @type {string}
+     */
+    class_name: string;
+    /**
+     * Notch width in CSS pixels, scaled by the whole part of the device pixel ratio so it stays whole device pixels
+     * @type {number}
+     */
+    width_px: number;
+    /**
+     * Below this on-screen spacing between neighbouring notches, in CSS pixels, the tier is dropped
+     * @type {number}
+     */
+    min_spacing_px: number;
+}
+//# sourceMappingURL=SegmentTier.d.ts.map

package/src/view/elements/progress/segmented/SegmentTier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SegmentTier.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SegmentTier.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH;IAyBI;;;;;;OAMG;IACH,kBANW,MAAM,cACN,MAAM,YACN,MAAM,kBACN,MAAM,GACJ,WAAW,CAWvB;IAxCD;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,YAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,gBAFU,MAAM,CAEG;CAmBtB"}