@woosh/meep-engine 3.59.0 → 3.60.0

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The multi-scale mean estimator (MSME) of a stream of RGB samples: a long mean that blends slowly while the
+ * stream is steady and noisy, and catches up with a short mean once the two disagree by more than the stream's
+ * deviation explains. Barré-Brisebois et al., *Hybrid Rendering for Real-Time Ray Tracing*, Ray Tracing Gems
+ * (2019) ch. 25; Enshrouded's probes (Kolesik, GPC 2024) keep it a texel.
+ *
+ * ```wgsl
+ * fn multiscale_mean_seed(sample: vec3f) -> MultiscaleMean
+ * fn multiscale_mean_add(e: MultiscaleMean, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool) -> MultiscaleMean
+ * ```
+ *
+ * `MultiscaleMean` is {@link MULTISCALE_MEAN_STRUCT}.
+ *
+ * - **Seed**: both means at the first sample, nothing of variance, no blend reduction, an inconsistency of one,
+ *   as WickedEngine's surfels seed it.
+ * - **Clip**: a sample past `0.1 + short_mean + 8·deviation` a channel is held there, a firefly. The 0.1 is
+ *   the reference's, in the radiance's own units. A caller whose variance does not yet rest on a window of
+ *   samples passes `clip` false: there is no spread to clip to.
+ * - **Short mean**: blended by `short_blend`; the variance by `variance_blend`, the reference's half of it, so
+ *   that its window outlasts the short mean's.
+ * - **Long mean**: blended by the catch-up, `smoothstep(relative · max(0.02, inconsistency − 0.2))` held to
+ *   [1/256, 1], times the blend reduction, and at least `mean_blend_min`. `relative` is the luminance of the
+ *   means' gap over the deviation; the inconsistency its smoothed history; the reduction the luminance of half
+ *   the short mean over the deviation, held to [1/32, 1], a noisy stream's longer window. The inconsistency
+ *   follows by `short_blend`, where the reference's 0.08 a sample stands at its default short blend of 0.08.
+ * - **The reduction follows by the reference's 0.1 a sample**, whatever the short blend. The catch-up takes the
+ *   last sample's reduction, so following by a large short blend (rare samples) it would track each one: the
+ *   long mean's weight would rise after the bright samples it is about to fall back from, and it settles low.
+ *   Measured through the probe accumulate pass (2026-10-29, the emulator, samples of mean 1 and deviation 1,
+ *   four streams averaged): 7, 18, 28 and 39% low at short blends of 0.55, 0.63, 0.78 and 0.9 that way; 2, 3,
+ *   7 and 15% at 0.1 a sample, with the same step response.
+ *
+ * Measured on a CPU model (2026-10-29, 200 runs averaged), against an exponential mean of the short blend, over
+ * samples that are 0 or twice the mean, a ray of two lit: at a short blend of 1/4 the long mean wanders 0.19 of
+ * the mean against 0.38, and reaches 90% of a tripling in 14 samples against 9; at 1/8, 0.077 against 0.25, in
+ * 88 against 18. An exponential mean as steady takes 35 and 197. Over a noiseless stream it takes a step about
+ * twice as slowly as the short blend, the clip holding the first samples past the step.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_multiscale_mean: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_multiscale_mean.d.ts.map

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_multiscale_mean.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,oCAFU,SAAS,CA4CZ;0BAtFmB,6BAA6B"}

package/src/shade/renderer/shader/chunk/filter/chunk_multiscale_mean.js

@@ -0,0 +1,87 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_rgb_to_luminance } from "../color/chunk_rgb_to_luminance.js";
+import { MULTISCALE_MEAN_STRUCT } from "./MULTISCALE_MEAN_STRUCT.js";
+
+/**
+ * The multi-scale mean estimator (MSME) of a stream of RGB samples: a long mean that blends slowly while the
+ * stream is steady and noisy, and catches up with a short mean once the two disagree by more than the stream's
+ * deviation explains. Barré-Brisebois et al., *Hybrid Rendering for Real-Time Ray Tracing*, Ray Tracing Gems
+ * (2019) ch. 25; Enshrouded's probes (Kolesik, GPC 2024) keep it a texel.
+ *
+ * ```wgsl
+ * fn multiscale_mean_seed(sample: vec3f) -> MultiscaleMean
+ * fn multiscale_mean_add(e: MultiscaleMean, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool) -> MultiscaleMean
+ * ```
+ *
+ * `MultiscaleMean` is {@link MULTISCALE_MEAN_STRUCT}.
+ *
+ * - **Seed**: both means at the first sample, nothing of variance, no blend reduction, an inconsistency of one,
+ *   as WickedEngine's surfels seed it.
+ * - **Clip**: a sample past `0.1 + short_mean + 8·deviation` a channel is held there, a firefly. The 0.1 is
+ *   the reference's, in the radiance's own units. A caller whose variance does not yet rest on a window of
+ *   samples passes `clip` false: there is no spread to clip to.
+ * - **Short mean**: blended by `short_blend`; the variance by `variance_blend`, the reference's half of it, so
+ *   that its window outlasts the short mean's.
+ * - **Long mean**: blended by the catch-up, `smoothstep(relative · max(0.02, inconsistency − 0.2))` held to
+ *   [1/256, 1], times the blend reduction, and at least `mean_blend_min`. `relative` is the luminance of the
+ *   means' gap over the deviation; the inconsistency its smoothed history; the reduction the luminance of half
+ *   the short mean over the deviation, held to [1/32, 1], a noisy stream's longer window. The inconsistency
+ *   follows by `short_blend`, where the reference's 0.08 a sample stands at its default short blend of 0.08.
+ * - **The reduction follows by the reference's 0.1 a sample**, whatever the short blend. The catch-up takes the
+ *   last sample's reduction, so following by a large short blend (rare samples) it would track each one: the
+ *   long mean's weight would rise after the bright samples it is about to fall back from, and it settles low.
+ *   Measured through the probe accumulate pass (2026-10-29, the emulator, samples of mean 1 and deviation 1,
+ *   four streams averaged): 7, 18, 28 and 39% low at short blends of 0.55, 0.63, 0.78 and 0.9 that way; 2, 3,
+ *   7 and 15% at 0.1 a sample, with the same step response.
+ *
+ * Measured on a CPU model (2026-10-29, 200 runs averaged), against an exponential mean of the short blend, over
+ * samples that are 0 or twice the mean, a ray of two lit: at a short blend of 1/4 the long mean wanders 0.19 of
+ * the mean against 0.38, and reaches 90% of a tripling in 14 samples against 9; at 1/8, 0.077 against 0.25, in
+ * 88 against 18. An exponential mean as steady takes 35 and 197. Over a noiseless stream it takes a step about
+ * twice as slowly as the short blend, the clip holding the first samples past the step.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_multiscale_mean = CodeChunk.from(
+    //language=WGSL
+    `
+fn multiscale_mean_seed(sample: vec3f) -> ${MULTISCALE_MEAN_STRUCT.wgsl_ref} {
+    return ${MULTISCALE_MEAN_STRUCT.make({
+        mean: 'sample',
+        short_mean: 'sample',
+        variance: 'vec3f(0.0)',
+        reduction: '0.0',
+        inconsistency: '1.0',
+    })};
+}
+
+fn multiscale_mean_add(e: ${MULTISCALE_MEAN_STRUCT.wgsl_ref}, sample: vec3f, short_blend: f32, variance_blend: f32, mean_blend_min: f32, clip: bool) -> ${MULTISCALE_MEAN_STRUCT.wgsl_ref} {
+    var y = sample;
+
+    if (clip) {
+        y = min(y, 0.1 + e.short_mean + 8.0 * sqrt(max(vec3f(1e-5), e.variance)));
+    }
+
+    let delta = y - e.short_mean;
+    let short_mean = mix(e.short_mean, y, short_blend);
+    let variance = mix(e.variance, delta * (y - short_mean), variance_blend);
+    let deviation = sqrt(max(vec3f(1e-5), variance));
+
+    let relative = rgb_to_luminance(abs(e.mean - short_mean) / deviation);
+    let inconsistency = mix(e.inconsistency, relative, short_blend);
+    let reduction = clamp(rgb_to_luminance(0.5 * short_mean / deviation), 1.0 / 32.0, 1.0);
+
+    let catch_up = clamp(smoothstep(0.0, 1.0, relative * max(0.02, inconsistency - 0.2)), 1.0 / 256.0, 1.0) * e.reduction;
+
+    return ${MULTISCALE_MEAN_STRUCT.make({
+        mean: 'mix(e.mean, y, max(saturate(catch_up), mean_blend_min))',
+        short_mean: 'short_mean',
+        variance: 'variance',
+        reduction: 'mix(e.reduction, reduction, 0.1)',
+        inconsistency: 'inconsistency',
+    })};
+}
+`, [
+        chunk_rgb_to_luminance,
+        MULTISCALE_MEAN_STRUCT.declaration_chunk,
+    ]);

package/src/shade/renderer/shader/chunk/noise/r/chunk_r2_canonical.d.ts

@@ -1,2 +1,8 @@
-export {};
+/**
+ We are sampling an R2 sequence - see http://extremelearning.com.au/unreasonable-effectiveness-of-quasirandom-sequences/
+ @see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/vaGTAO.hlsl#L74C71-L74C112
+ * @type {CodeChunk}
+ */
+export const chunk_r2_canonical: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_r2_canonical.d.ts.map

package/src/shade/renderer/shader/chunk/noise/r/chunk_r2_canonical.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_r2_canonical.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/noise/r/chunk_r2_canonical.js"],"names":[],"mappings":""}
+{"version":3,"file":"chunk_r2_canonical.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/noise/r/chunk_r2_canonical.js"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,iCAFU,SAAS,CASjB;0BAdwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/noise/r/chunk_r2_canonical.js

@@ -5,7 +5,7 @@ import { CodeChunk } from "../../../compiler/CodeChunk.js";
  @see https://github.com/GameTechDev/XeGTAO/blob/a5b1686c7ea37788eeb3576b5be47f7c03db532c/Source/Rendering/Shaders/vaGTAO.hlsl#L74C71-L74C112
  * @type {CodeChunk}
  */
-const chunk_r2_canonical = CodeChunk.from(
+export const chunk_r2_canonical = CodeChunk.from(
     //language=WGSL
     `
 fn r2_canonical(index:u32) -> vec2<f32> {

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_reserve_workgroup.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Claim a run of a workgroup list's places for each lane, one atomic per subgroup: the subgroup sums
+ * the lanes' `count`s, its first active lane adds the sum to `counter` with one `atomicAdd`, and each
+ * lane takes its run at its exclusive prefix over the subgroup.
+ *
+ * `fn subgroup_reserve_workgroup(counter: ptr<workgroup, atomic<u32>>, count: u32) -> u32`
+ *
+ * Returns the first place of the lane's run, `count` long; a lane that asks for none gets where its
+ * run would have been. Nothing is bounded here: the counter rises past whatever the list holds, and
+ * the caller decides what a place past its capacity means.
+ *
+ * Every lane of the subgroup calls it, asking or not, from subgroup-uniform control flow. Runs of
+ * different subgroups land in whatever order their atomics do. Nothing here assumes how subgroups map
+ * onto `local_invocation_index`.
+ *
+ * @see chunk_subgroup_append_slot for a list in storage, a place a lane
+ * @type {CodeChunk}
+ */
+export const chunk_subgroup_reserve_workgroup: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_subgroup_reserve_workgroup.d.ts.map

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_reserve_workgroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_subgroup_reserve_workgroup.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_reserve_workgroup.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,+CAFU,SAAS,CAoBhB;0BAtCuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_reserve_workgroup.js

@@ -0,0 +1,42 @@
+import { WebGPUExtensionType } from "../../../../descriptor/WebGPUExtensionType.js";
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Claim a run of a workgroup list's places for each lane, one atomic per subgroup: the subgroup sums
+ * the lanes' `count`s, its first active lane adds the sum to `counter` with one `atomicAdd`, and each
+ * lane takes its run at its exclusive prefix over the subgroup.
+ *
+ * `fn subgroup_reserve_workgroup(counter: ptr<workgroup, atomic<u32>>, count: u32) -> u32`
+ *
+ * Returns the first place of the lane's run, `count` long; a lane that asks for none gets where its
+ * run would have been. Nothing is bounded here: the counter rises past whatever the list holds, and
+ * the caller decides what a place past its capacity means.
+ *
+ * Every lane of the subgroup calls it, asking or not, from subgroup-uniform control flow. Runs of
+ * different subgroups land in whatever order their atomics do. Nothing here assumes how subgroups map
+ * onto `local_invocation_index`.
+ *
+ * @see chunk_subgroup_append_slot for a list in storage, a place a lane
+ * @type {CodeChunk}
+ */
+export const chunk_subgroup_reserve_workgroup = CodeChunk.from(
+    //language=WGSL
+    `
+fn subgroup_reserve_workgroup(counter: ptr<workgroup, atomic<u32>>, count: u32) -> u32 {
+    let offset = subgroupExclusiveAdd(count);
+    let total = subgroupAdd(count);
+
+    // elected before the branch, which then holds no subgroup operation and may be non-uniform
+    let elected = subgroupElect();
+
+    var base = 0u;
+
+    if (elected && total > 0u) {
+        base = atomicAdd(counter, total);
+    }
+
+    return subgroupBroadcastFirst(base) + offset;
+}
+`);
+
+chunk_subgroup_reserve_workgroup.addExtension(WebGPUExtensionType.Subgroups);

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"}