@woosh/meep-engine 3.60.0 → 3.60.1

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.60.0",
+  "version": "3.60.1",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.d.ts

@@ -4,7 +4,12 @@
  * ray (`PROBE_RAY_NONE`) is past the frame's last. The radiance the ray brings back goes over its light,
  * three half floats:
  *
- * - a **miss** sees the environment along its direction, `sample_environment_color`;
+ * - a **miss** sees the prefiltered environment along its direction, `sample_environment_map`, at the
+ *   roughness whose lobe covers the solid angle of a radiance texel, 4π/n_r². The prefilter's lobe is the
+ *   spherical Gaussian exp(2(N·H − 1)/m²), m the roughness squared, whose integral over the sphere is
+ *   4πm²·(1 − (1 − e^(−k))/k), k = 2/m²: m = 1/n_r to 0.2% at n_r = 16, so the roughness is 1/√n_r. A sun
+ *   a few texels wide at level 0 is then a lobe a texel wide, which a texel's jittered rays all see,
+ *   rather than a point that only some probes' jitter ever lands on;
  * - a **front-face hit** is `emissive + ρ_d·E_dir/π` (D7), its surface from `probe_clipmap_hit_surface`
  *   at the hit's position, the probe's origin plus t along the ray, with the hit's normal, at its
  *   cascade's voxel; E_dir is what trace left in the light;

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_shade.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.js"],"names":[],"mappings":"AAwDA;;;;;;;;;;;;;;;;;GAiBG;AACH,yCAFU,aAAa,CAyDpB;8BAhH2B,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_shade.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,yCAFU,aAAa,CAyDpB;8BAxH2B,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.js

@@ -1,4 +1,3 @@
-import { chunk_sample_environment_color } from "../../../atmosphere/chunk_sample_environment_color.js";
 import {
     MESH_CARD_ALBEDO_RESOURCE,
     MESH_CARD_EMISSIVE_RESOURCE,
@@ -11,6 +10,7 @@ import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "../../../light/environment/ENV
 import { SCENE_DATABASE_RESOURCE } from "../../../scene/SCENE_DATABASE_RESOURCE.js";
 import { chunk_rgbe9995_decode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js";
 import { chunk_rgbe9995_encode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.js";
+import { chunk_sample_environment_map } from "../../../shader/chunk/texture/sample/chunk_sample_environment_map.js";
 import { chunk_uv_octahedral_unit_decode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
 import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
@@ -32,9 +32,12 @@ import {
     PROBE_TRACE_READ_RESOURCE
 } from "./chunk_probe_clipmap.js";
 import { PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
+import { PROBE_TRACE_SETTINGS } from "./shader_probe_clipmap_trace.js";
 
 const resources = new ShaderResourceSetDescriptor();
 
+resources.setImmediate("settings", PROBE_TRACE_SETTINGS);
+
 resources.createGroup()
     .add(PROBE_TRACE_READ_RESOURCE)
     .add(PROBE_ORIGINS_READ_RESOURCE)
@@ -60,7 +63,12 @@ resources.createGroup()
  * ray (`PROBE_RAY_NONE`) is past the frame's last. The radiance the ray brings back goes over its light,
  * three half floats:
  *
- * - a **miss** sees the environment along its direction, `sample_environment_color`;
+ * - a **miss** sees the prefiltered environment along its direction, `sample_environment_map`, at the
+ *   roughness whose lobe covers the solid angle of a radiance texel, 4π/n_r². The prefilter's lobe is the
+ *   spherical Gaussian exp(2(N·H − 1)/m²), m the roughness squared, whose integral over the sphere is
+ *   4πm²·(1 − (1 − e^(−k))/k), k = 2/m²: m = 1/n_r to 0.2% at n_r = 16, so the roughness is 1/√n_r. A sun
+ *   a few texels wide at level 0 is then a lobe a texel wide, which a texel's jittered rays all see,
+ *   rather than a point that only some probes' jitter ever lands on;
  * - a **front-face hit** is `emissive + ρ_d·E_dir/π` (D7), its surface from `probe_clipmap_hit_surface`
  *   at the hit's position, the probe's origin plus t along the ray, with the hit's normal, at its
  *   cascade's voxel; E_dir is what trace left in the light;
@@ -96,7 +104,7 @@ fn main(
     var albedo = vec3<f32>(0.0);
 
     if (kind == ${BRICK_TRACE_MISS}u) {
-        radiance = sample_environment_color(tEnvironment, sEnvironment, direction);
+        radiance = sample_environment_map(tEnvironment, sEnvironment, direction, inverseSqrt(f32(settings.radiance_resolution)));
     } else if (kind == ${BRICK_TRACE_HIT}u && (record.flags & PROBE_RAY_BACK_FACE) == 0u) {
         let k = record.flags >> PROBE_RAY_PROBE_SHIFT;
         let origin = probe_clipmap_ray_origin(probe_origins[k], probe_trace.elements[k], record.direction);
@@ -121,7 +129,7 @@ fn main(
             chunk_probe_clipmap_ray_origin,
             chunk_folded_workgroup_index,
             chunk_uv_octahedral_unit_decode,
-            chunk_sample_environment_color,
+            chunk_sample_environment_map,
             chunk_probe_clipmap_hit_surface,
             chunk_rgbe9995_decode,
             chunk_rgbe9995_encode,

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":";IAu1DA;;;;;;;;;;;;;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

@@ -1260,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
@@ -1275,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.

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

@@ -1,39 +1,99 @@
 /**
  * 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.
+ * 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 the trail holds after a drop before it starts to move
+     * How long a loss's trail holds before it starts to ease down
      * @type {number}
      */
     delay_ms: number;
     /**
-     * How long the ease from the held value down to the target takes; 0 snaps once the hold ends
+     * Length of the ease for the smallest loss; 0 with {@link duration_max_ms} 0 snaps once the hold ends
      * @type {number}
      */
-    duration_ms: 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}
-     * @private
      */
-    private __from;
+    duration_max_ms: number;
     /**
+     * The target, as last set
      * @type {number}
      * @private
      */
     private __to;
     /**
-     * When the current hold began
+     * 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 __drop_time;
+    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
@@ -41,13 +101,13 @@ export class GhostTrail {
      */
     set(target: number, time_ms: number): void;
     /**
-     * Where the trail is at a given time; never below its target.
+     * 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 has reached its target and will not move until {@link set} is called again
+     * Whether the trail shows the target and will not move until {@link set} is called again
      * @param {number} time_ms
      * @returns {boolean}
      */

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

@@ -1 +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"}
+{"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"}

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

@@ -1,98 +1,280 @@
-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;
-    }
-}
+import { assert } from "../../../../core/assert.js";
+import { clamp01 } from "../../../../core/math/clamp01.js";
+
+/**
+ * Floats per loss in {@link GhostTrail}'s store: [start, duration, low, amplitude]. A loss's trail is
+ * `low + amplitude * u²`, where u runs from 1 (held, and at the start of the ease) to 0 (the ease is over).
+ * @type {number}
+ */
+const LOSS_STRIDE = 4;
+
+/**
+ * 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 = 100;
+
+    /**
+     * 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 = 300;
+
+    /**
+     * 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 = 800;
+
+    /**
+     * The target, as last set
+     * @type {number}
+     * @private
+     */
+    __to = 0;
+
+    /**
+     * 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
+     */
+    __losses = new Float64Array(LOSS_STRIDE * 8);
+
+    /**
+     * @type {number}
+     * @private
+     */
+    __loss_count = 0;
+
+    /**
+     * Length of the ease for a loss of `gap`, a fraction of the bar
+     * @param {number} gap
+     * @returns {number}
+     * @private
+     */
+    __duration_for(gap) {
+        const min = this.duration_min_ms;
+
+        return min + (this.duration_max_ms - min) * clamp01(gap);
+    }
+
+    /**
+     * 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
+     */
+    __loss_u(index, time_ms) {
+        const losses = this.__losses;
+        const offset = index * LOSS_STRIDE;
+
+        const elapsed = time_ms - losses[offset];
+        const duration = losses[offset + 1];
+
+        if (elapsed < 0) {
+            return 1;
+        }
+
+        if (elapsed >= duration) {
+            return 0;
+        }
+
+        return 1 - elapsed / duration;
+    }
+
+    /**
+     * 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
+     */
+    __loss_at(index, time_ms) {
+        const offset = index * LOSS_STRIDE;
+        const u = this.__loss_u(index, time_ms);
+
+        return this.__losses[offset + 2] + this.__losses[offset + 3] * u * u;
+    }
+
+    /**
+     * @param {number} start
+     * @param {number} duration
+     * @param {number} low
+     * @param {number} amplitude
+     * @private
+     */
+    __add_loss(start, duration, low, amplitude) {
+        const count = this.__loss_count;
+
+        if ((count + 1) * LOSS_STRIDE > this.__losses.length) {
+            const grown = new Float64Array(this.__losses.length * 2);
+
+            grown.set(this.__losses);
+
+            this.__losses = grown;
+        }
+
+        const losses = this.__losses;
+        const offset = count * LOSS_STRIDE;
+
+        losses[offset] = start;
+        losses[offset + 1] = duration;
+        losses[offset + 2] = low;
+        losses[offset + 3] = amplitude;
+
+        this.__loss_count = count + 1;
+    }
+
+    /**
+     * Tell the trail its target's new value.
+     * @param {number} target
+     * @param {number} time_ms
+     */
+    set(target, time_ms) {
+        // the knobs are public and may change between calls, so they are checked where they are read
+        assert.isFinite(this.delay_ms, 'delay_ms');
+        assert.greaterThanOrEqual(this.delay_ms, 0, 'delay_ms must not be negative');
+        assert.isFinite(this.duration_max_ms, 'duration_max_ms');
+        assert.greaterThanOrEqual(this.duration_min_ms, 0, 'duration_min_ms must not be negative');
+        assert.greaterThanOrEqual(this.duration_max_ms, this.duration_min_ms, 'duration_max_ms must not be under duration_min_ms');
+        assert.isFinite(time_ms, 'time_ms');
+
+        if (!Number.isFinite(target)) {
+            return;
+        }
+
+        if (target >= this.sample(time_ms)) {
+            // a rise to or above the trail: jump to it, and forget every loss
+            this.__to = target;
+            this.__loss_count = 0;
+
+            return;
+        }
+
+        // drop the losses whose ease is over (each rests at its low, which is never above the target); for the rest,
+        // if the target went under the low, lower it and rescale what is left of the ease so the trail is where it was
+        const losses = this.__losses;
+        const count = this.__loss_count;
+
+        let kept = 0;
+
+        for (let i = 0; i < count; i++) {
+            const offset = i * LOSS_STRIDE;
+
+            const u = this.__loss_u(i, time_ms);
+
+            if (u <= 0) {
+                continue;
+            }
+
+            let low = losses[offset + 2];
+            let amplitude = losses[offset + 3];
+
+            if (target < low) {
+                // where the trail is now, kept: low + amplitude * u² before and after. u > 0 here, and the
+                // product amplitude * u² stays at most the trail's height over the new low however small u is
+                const value = low + amplitude * u * u;
+
+                low = target;
+                amplitude = (value - low) / (u * u);
+            }
+
+            const kept_offset = kept * LOSS_STRIDE;
+
+            losses[kept_offset] = losses[offset];
+            losses[kept_offset + 1] = losses[offset + 1];
+            losses[kept_offset + 2] = low;
+            losses[kept_offset + 3] = amplitude;
+
+            kept++;
+        }
+
+        this.__loss_count = kept;
+
+        const before = this.__to;
+
+        if (target < before) {
+            this.__add_loss(time_ms + this.delay_ms, this.__duration_for(before - target), target, before - target);
+        }
+
+        this.__to = target;
+    }
+
+    /**
+     * 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) {
+        let value = this.__to;
+
+        const count = this.__loss_count;
+
+        for (let i = 0; i < count; i++) {
+            const v = this.__loss_at(i, time_ms);
+
+            if (v > value) {
+                value = v;
+            }
+        }
+
+        return value;
+    }
+
+    /**
+     * 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) {
+        const to = this.__to;
+        const losses = this.__losses;
+        const count = this.__loss_count;
+
+        for (let i = 0; i < count; i++) {
+            const offset = i * LOSS_STRIDE;
+
+            // a loss still easing and still above the target; one at or under it stays there, since its trail
+            // only falls and the target holds until the next set
+            if (time_ms < losses[offset] + losses[offset + 1] && this.__loss_at(i, time_ms) > to) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

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

@@ -18,10 +18,12 @@ export class SegmentedResourceBarView extends View {
      * @param {string[]} [options.classList]
      * @param {{unit:number, class_name:string, width_px:number, min_spacing_px:number}[]} [options.tiers] notch tiers, finest first; see {@link SegmentTier}
      * @param {{count:number, group:number}|null} [options.cells] draw `count` cells instead of notches, in groups of `group` (0 for none)
-     * @param {number} [options.ghost_delay_ms=450] how long the ghost holds after a drop
-     * @param {number} [options.ghost_duration_ms=350] how long the ghost then takes to catch up; 0 under prefers-reduced-motion
+     * @param {number} [options.ghost_delay_ms=100] how long the ghost holds after a drop; see {@link GhostTrail}
+     * @param {number} [options.ghost_duration_min_ms=300] how long the ghost takes to close the smallest loss
+     * @param {number} [options.ghost_duration_max_ms=800] how long it takes to close a loss of the whole bar; both
+     *  durations are 0 under prefers-reduced-motion, so the ghost holds, then snaps
      */
-    constructor({ values, max, classList, tiers, cells, ghost_delay_ms, ghost_duration_ms }: {
+    constructor({ values, max, classList, tiers, cells, ghost_delay_ms, ghost_duration_min_ms, ghost_duration_max_ms }: {
         values: (Vector1 | ObservedInteger)[];
         max?: Vector1 | ObservedInteger | ReactiveExpression;
         classList?: string[];
@@ -36,7 +38,8 @@ export class SegmentedResourceBarView extends View {
             group: number;
         } | null;
         ghost_delay_ms?: number;
-        ghost_duration_ms?: number;
+        ghost_duration_min_ms?: number;
+        ghost_duration_max_ms?: number;
     });
     /**
      *
@@ -69,7 +72,12 @@ export class SegmentedResourceBarView extends View {
      * @type {number}
      * @private
      */
-    private __ghost_duration_ms;
+    private __ghost_duration_min_ms;
+    /**
+     * @type {number}
+     * @private
+     */
+    private __ghost_duration_max_ms;
     /**
      * Total fill as a fraction of max, as last drawn
      * @type {number}

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

@@ -1 +1 @@
-{"version":3,"file":"SegmentedResourceBarView.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SegmentedResourceBarView.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;GAUG;AACH;IACI;;;;;;;;;;OAUG;IACH;QARgD,MAAM,EAA3C,CAAC,OAAO,kBAAgB,CAAC,EAAE;QAC0B,GAAG,GAAxD,OAAO,uCAAmC;QACvB,SAAS,GAA5B,MAAM,EAAE;QAC6E,KAAK,GAA1F;YAAC,IAAI,EAAC,MAAM,CAAC;YAAC,UAAU,EAAC,MAAM,CAAC;YAAC,QAAQ,EAAC,MAAM,CAAC;YAAC,cAAc,EAAC,MAAM,CAAA;SAAC,EAAE;QAC9B,KAAK,GAAjD;YAAC,KAAK,EAAC,MAAM,CAAC;YAAC,KAAK,EAAC,MAAM,CAAA;SAAC,GAAC,IAAI;QAChB,cAAc,GAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;OAsQhB;IA9OG;;;;OAIG;IACH,yBAA8B;IAE9B;;;;OAIG;IACH,oBAAsB;IAEtB;;;OAGG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,gBAA+B;IAG/B;;;OAGG;IACH,4BAA4C;IAE5C;;;;OAIG;IACH,yBAAyB;IAEzB;;;OAGG;IACH,yBAAgH;IAEhH;;;;OAIG;IACH,oBAAuB;IAie3B;;OAEG;IACH,4BASC;IAzeG,yBAA4B;IAC5B,mBAAmB;IA8bvB;;OAEG;IACH,wBAQC;IArcG,oBAAsB;IACtB,sBAAwB;IACxB,sBAAwB;IACxB,6BAA+B;IAE/B;;;;OAIG;IACH,gBAAkC;IAElC;;;OAGG;IACH,YAFU,qBAAqB,CAEH;IAG5B,mBAAuC;IASvC;;;OAGG;IACH,mBAA+C;IAG/C;;;OAGG;IACH,sBAAuB;IAEvB;;;OAGG;IACH,yBAA0B;IAE1B;;;OAGG;IACH,wBAAyB;IACzB,uCAA8B;IAC9B,wCAA+B;IAC/B,0BAAqE;IAGrE,gCAA2E;IAC3E,iCAA4E;IAkBxE;;;;OAIG;IACH,oBAAgD;IA8BpD;;;OAGG;IACH,gBAFU,QAAQ,CAsChB;IAWF;;;;OAIG;IACH,uBAA2C;IAuC/C,eAGC;IAED,wBAGC;IAED;;;OAGG;IACH,uBAmDC;IAED;;;;;;OAMG;IACH,wBAoCC;IAED;;;;;OAKG;IACH,sBAkBC;IAED,mBAwCC;IAED;;;;OAIG;IACH,eAaC;IAED;;;;OAIG;IACH,qBA6BC;IAeD;;;;OAIG;IACH,mCAUC;CAeJ;iBAxnBgB,kBAAkB;iBALlB,0CAA0C;qBAGtC,6BAA6B;oBAF9B,kCAAkC"}
+{"version":3,"file":"SegmentedResourceBarView.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SegmentedResourceBarView.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;GAUG;AACH;IACI;;;;;;;;;;;;OAYG;IACH;QAVgD,MAAM,EAA3C,CAAC,OAAO,kBAAgB,CAAC,EAAE;QAC0B,GAAG,GAAxD,OAAO,uCAAmC;QACvB,SAAS,GAA5B,MAAM,EAAE;QAC6E,KAAK,GAA1F;YAAC,IAAI,EAAC,MAAM,CAAC;YAAC,UAAU,EAAC,MAAM,CAAC;YAAC,QAAQ,EAAC,MAAM,CAAC;YAAC,cAAc,EAAC,MAAM,CAAA;SAAC,EAAE;QAC9B,KAAK,GAAjD;YAAC,KAAK,EAAC,MAAM,CAAC;YAAC,KAAK,EAAC,MAAM,CAAA;SAAC,GAAC,IAAI;QAChB,cAAc,GAA/B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QACW,qBAAqB,GAAtC,MAAM;OAiRhB;IApPG;;;;OAIG;IACH,yBAA8B;IAE9B;;;;OAIG;IACH,oBAAsB;IAEtB;;;OAGG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,gBAAoB;IAEpB;;;OAGG;IACH,gBAA+B;IAG/B;;;OAGG;IACH,gCAAoD;IAEpD;;;OAGG;IACH,gCAAoD;IAEpD;;;;OAIG;IACH,yBAAyB;IAEzB;;;OAGG;IACH,yBAAgH;IAEhH;;;;OAIG;IACH,oBAAuB;IAoe3B;;OAEG;IACH,4BASC;IA5eG,yBAA4B;IAC5B,mBAAmB;IAicvB;;OAEG;IACH,wBAQC;IAxcG,oBAAsB;IACtB,sBAAwB;IACxB,sBAAwB;IACxB,6BAA+B;IAE/B;;;;OAIG;IACH,gBAAkC;IAElC;;;OAGG;IACH,YAFU,qBAAqB,CAEH;IAG5B,mBAAuC;IASvC;;;OAGG;IACH,mBAA+C;IAG/C;;;OAGG;IACH,sBAAuB;IAEvB;;;OAGG;IACH,yBAA0B;IAE1B;;;OAGG;IACH,wBAAyB;IACzB,uCAA8B;IAC9B,wCAA+B;IAC/B,0BAAqE;IAGrE,gCAA2E;IAC3E,iCAA4E;IAkBxE;;;;OAIG;IACH,oBAAgD;IA8BpD;;;OAGG;IACH,gBAFU,QAAQ,CAsChB;IAWF;;;;OAIG;IACH,uBAA2C;IAuC/C,eAGC;IAED,wBAGC;IAED;;;OAGG;IACH,uBAmDC;IAED;;;;;;OAMG;IACH,wBAoCC;IAED;;;;;OAKG;IACH,sBAkBC;IAED,mBA2CC;IAED;;;;OAIG;IACH,eAaC;IAED;;;;OAIG;IACH,qBA6BC;IAeD;;;;OAIG;IACH,mCAUC;CAeJ;iBAvoBgB,kBAAkB;iBALlB,0CAA0C;qBAGtC,6BAA6B;oBAF9B,kCAAkC"}

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

@@ -60,8 +60,10 @@ export class SegmentedResourceBarView extends View {
      * @param {string[]} [options.classList]
      * @param {{unit:number, class_name:string, width_px:number, min_spacing_px:number}[]} [options.tiers] notch tiers, finest first; see {@link SegmentTier}
      * @param {{count:number, group:number}|null} [options.cells] draw `count` cells instead of notches, in groups of `group` (0 for none)
-     * @param {number} [options.ghost_delay_ms=450] how long the ghost holds after a drop
-     * @param {number} [options.ghost_duration_ms=350] how long the ghost then takes to catch up; 0 under prefers-reduced-motion
+     * @param {number} [options.ghost_delay_ms=100] how long the ghost holds after a drop; see {@link GhostTrail}
+     * @param {number} [options.ghost_duration_min_ms=300] how long the ghost takes to close the smallest loss
+     * @param {number} [options.ghost_duration_max_ms=800] how long it takes to close a loss of the whole bar; both
+     *  durations are 0 under prefers-reduced-motion, so the ghost holds, then snaps
      */
     constructor({
                     values,
@@ -69,16 +71,20 @@ export class SegmentedResourceBarView extends View {
                     classList = [],
                     tiers = SEGMENT_TIERS_DEFAULT,
                     cells = null,
-                    ghost_delay_ms = 450,
-                    ghost_duration_ms = 350
+                    ghost_delay_ms = 100,
+                    ghost_duration_min_ms = 300,
+                    ghost_duration_max_ms = 800
                 }) {
         super();
 
         assert.isArray(values, 'values');
         assert.defined(max, 'max');
         assert.isArray(tiers, 'tiers');
-        assert.isNumber(ghost_delay_ms, 'ghost_delay_ms');
-        assert.isNumber(ghost_duration_ms, 'ghost_duration_ms');
+        assert.isFinite(ghost_delay_ms, 'ghost_delay_ms');
+        assert.greaterThanOrEqual(ghost_delay_ms, 0, 'ghost_delay_ms must not be negative');
+        assert.isFinite(ghost_duration_max_ms, 'ghost_duration_max_ms');
+        assert.greaterThanOrEqual(ghost_duration_min_ms, 0, 'ghost_duration_min_ms must not be negative');
+        assert.greaterThanOrEqual(ghost_duration_max_ms, ghost_duration_min_ms, 'ghost_duration_max_ms must not be under ghost_duration_min_ms');
 
         if (cells !== null) {
             assert.isNonNegativeInteger(cells.count, 'cells.count');
@@ -122,7 +128,13 @@ export class SegmentedResourceBarView extends View {
          * @type {number}
          * @private
          */
-        this.__ghost_duration_ms = ghost_duration_ms;
+        this.__ghost_duration_min_ms = ghost_duration_min_ms;
+
+        /**
+         * @type {number}
+         * @private
+         */
+        this.__ghost_duration_max_ms = ghost_duration_max_ms;
 
         /**
          * Total fill as a fraction of max, as last drawn
@@ -531,7 +543,10 @@ export class SegmentedResourceBarView extends View {
 
         const ghost = this.__ghost;
 
-        ghost.duration_ms = this.__reduced_motion !== null && this.__reduced_motion.matches ? 0 : this.__ghost_duration_ms;
+        const reduced_motion = this.__reduced_motion !== null && this.__reduced_motion.matches;
+
+        ghost.duration_min_ms = reduced_motion ? 0 : this.__ghost_duration_min_ms;
+        ghost.duration_max_ms = reduced_motion ? 0 : this.__ghost_duration_max_ms;
         ghost.set(total_fraction, now);
 
         this.__draw(now);