@woosh/meep-engine 3.59.0 → 3.60.1

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":";IAg3DA;;;;;;;;;;;;;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;
     },
 
@@ -1241,7 +1260,9 @@ export const WGSLLanguageCore = {
      *
      * Filtered sample at normalised UV coords. Honours the sampler's
      * address modes and `magFilter`. `coords` length matches the texture
-     * dimensionality. The `level` arg is ignored (no mipmaps).
+     * dimensionality. The `level` reads that level of a bitmap carrying its levels, as `textureLoad`
+     * does, and zero past them; between two levels, a `linear` `mipmapFilter` blends them and any other
+     * takes the nearer. A bitmap carrying none serves every level from itself.
      *
      * @param {import("./CPUBitmapData.js").CPUBitmapData} t
      * @param {import("../../descriptor/texture/SamplerDescriptor.js").SamplerDescriptor | null} sampler
@@ -1256,21 +1277,44 @@ export const WGSLLanguageCore = {
 
         let array_index = undefined;
         let offset = undefined;
+        let level = p3;
 
         if (p5 !== undefined) {
             // (t, s, coords, array_index, level, offset)
             array_index = p3;
+            level = p4;
             offset = p5;
         } else if (p4 === undefined) {
             // (t, s, coords, level)
         } else if (typeof p4 === 'number') {
             // (t, s, coords, array_index, level)
             array_index = p3;
+            level = p4;
         } else {
             // (t, s, coords, level, offset)
             offset = p4;
         }
 
+        if (t.levels?.length > 0 && level !== 0) {
+            const below = Math.max(Math.floor(level), 0);
+            const fraction = level - below;
+
+            if (fraction > 0 && sampler?.mipmapFilter === 'linear') {
+                const a = WGSLLanguageCore.textureSampleLevel(t, sampler, coords, ...(array_index === undefined ? [below] : [array_index, below]), ...(offset === undefined ? [] : [offset]));
+                const b = WGSLLanguageCore.textureSampleLevel(t, sampler, coords, ...(array_index === undefined ? [below + 1] : [array_index, below + 1]), ...(offset === undefined ? [] : [offset]));
+
+                return a.map((v, i) => v + (b[i] - v) * fraction);
+            }
+
+            const source = texture_level(t, fraction > 0.5 ? below + 1 : below);
+
+            if (source === undefined) {
+                return new Float32Array(4);
+            }
+
+            t = source;
+        }
+
         const dim = t.dimensionality;
         // Convert UV (normalised) to texel-space coords expected by
         // cpu_texture_sample. coords for a 1D texture is a scalar in WGSL.
@@ -1584,8 +1628,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 +1641,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,116 @@
+/**
+ * A value that trails another one down: the "ghost" behind a bar's fill that shows how much was just lost.
+ *
+ * The knobs are the three Dota 2 exposes for its hero bars as console variables: a short hold after a drop
+ * (`dota_health_hurt_delay`) and a decay whose length sits between a floor and a ceiling
+ * (`dota_health_hurt_decay_time_min` / `_max`). The defaults, 0.1 s / 0.3 s / 0.8 s, are the values players'
+ * published configs list as Dota's own; Valve does not document them. Everything else here is this class's own
+ * choice, not known Dota behaviour: the decay's length growing linearly with the loss (the whole bar takes the
+ * ceiling), the ease-out curve, and how losses that overlap combine.
+ *
+ * Every drop is a loss with a trail of its own: it holds at the value from before the drop for {@link delay_ms},
+ * then eases down over a length sized by that loss alone. The trail shows the highest of the live losses' trails,
+ * and never less than the target. Because no loss looks at another, a drop is drawn the same whether the trail
+ * was at rest or still moving when it came: a damage tick that lands just before or just after the previous one
+ * has faded looks the same, where a single trail that re-plans has to pick one side of that line.
+ *
+ * Each loss eases toward the lowest the target has been since it happened, never toward the target itself, so a
+ * rise that stays under the trail (regeneration after a hit) cannot lift it. When a later drop lowers that floor,
+ * the rest of the loss's ease is rescaled toward the new floor from where it is, so it does not jump. The trail
+ * is continuous in time and never rises unless the target rises above it; when it does, the trail jumps to the
+ * target and every loss is forgotten.
+ *
+ * A target that is not a finite number is ignored: the trail carries on with what it had, so one bad value cannot
+ * leave it NaN, and its owner animating it forever, for every value after.
+ *
+ * Each loss's start and length are fixed when it happens, so changing the knobs never revives or reshapes a trail
+ * already under way.
+ *
+ * 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 a loss's trail holds before it starts to ease down
+     * @type {number}
+     */
+    delay_ms: number;
+    /**
+     * Length of the ease for the smallest loss; 0 with {@link duration_max_ms} 0 snaps once the hold ends
+     * @type {number}
+     */
+    duration_min_ms: number;
+    /**
+     * Length of the ease for a loss of the whole bar (1); smaller losses take proportionally less, down to
+     * {@link duration_min_ms}
+     * @type {number}
+     */
+    duration_max_ms: number;
+    /**
+     * The target, as last set
+     * @type {number}
+     * @private
+     */
+    private __to;
+    /**
+     * Live losses, {@link LOSS_STRIDE} floats each: when the ease starts (after the hold), the ease's length, the
+     * lowest the target has been since the loss, and how far above that the trail is while u is 1
+     * @type {Float64Array}
+     * @private
+     */
+    private __losses;
+    /**
+     * @type {number}
+     * @private
+     */
+    private __loss_count;
+    /**
+     * Length of the ease for a loss of `gap`, a fraction of the bar
+     * @param {number} gap
+     * @returns {number}
+     * @private
+     */
+    private __duration_for;
+    /**
+     * How much of one loss's ease is left at `time_ms`: 1 while it holds, falling to 0 when the ease is over
+     * @param {number} index
+     * @param {number} time_ms
+     * @returns {number}
+     * @private
+     */
+    private __loss_u;
+    /**
+     * Where one loss's trail is at `time_ms`; an ease-out, fastest at the start of the ease
+     * @param {number} index
+     * @param {number} time_ms
+     * @returns {number}
+     * @private
+     */
+    private __loss_at;
+    /**
+     * @param {number} start
+     * @param {number} duration
+     * @param {number} low
+     * @param {number} amplitude
+     * @private
+     */
+    private __add_loss;
+    /**
+     * 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: the highest of the live losses' trails, and never below the target.
+     * @param {number} time_ms
+     * @returns {number}
+     */
+    sample(time_ms: number): number;
+    /**
+     * Whether the trail shows the 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":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IACI;;;OAGG;IACH,UAFU,MAAM,CAED;IAEf;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,aAAS;IAET;;;;;OAKG;IACH,iBAA6C;IAE7C;;;OAGG;IACH,qBAAiB;IAEjB;;;;;OAKG;IACH,uBAIC;IAED;;;;;;OAMG;IACH,iBAgBC;IAED;;;;;;OAMG;IACH,kBAKC;IAED;;;;;;OAMG;IACH,mBAoBC;IAED;;;;OAIG;IACH,YAHW,MAAM,WACN,MAAM,QAsEhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,OAAO,CAkBnB;CACJ"}