@woosh/meep-engine 3.60.1 → 3.60.2

package/src/shade/renderer/light/environment/shader_downsample_environment_map.js

@@ -0,0 +1,105 @@
+import {
+    chunk_texture_octahedral_skirt_texel_uv
+} from "../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_texel_uv.js";
+import {
+    chunk_uv_octahedral_unit_decode
+} from "../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addTexture("input", "float")
+    .addStorageTexture("output", "rgba16float")
+;
+
+/**
+ * One level of a skirted octahedral map, half the side of the level it reads: the plain average the
+ * prefilter's filtered importance sampling picks its source texels from.
+ *
+ * Each output texel is the solid-angle-weighted mean of the source texels its footprint overlaps.
+ * A skirted level's interior is not half the one above (1022 → 510, 6 → 2), so the footprint is
+ * 2 + 2/n source texels wide rather than 2, up to 3 at the last level: taps at fixed offsets drift
+ * across the source grid and skip texels, which a bright sun then goes missing through. Weighting
+ * each overlap by its solid angle keeps a level's energy that of the one above. The solid angle is
+ * integrated from the density |d|_1^3 rather than taken from a texel's corners
+ * (chunk_octahedral_solid_angle): a texel the octahedral fold crosses is no pair of spherical
+ * triangles, and a bright one came out 4.7% dim.
+ *
+ * @see https://github.com/EpicGames/UnrealEngine/blob/5.4/Engine/Shaders/Private/ReflectionEnvironmentShaders.usf DownsamplePS
+ * @type {CodeChunk}
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(16,16,1)
+fn main(
+    @builtin(global_invocation_id) global_invocation_id : vec3<u32>,
+){
+    let output_size = textureDimensions(output);
+
+    let output_texel_i = global_invocation_id.xy;
+
+    if(any(output_texel_i >= output_size)){
+        return;
+    }
+
+    // the skirt too: a skirt texel takes its interior twin's uv, so it is that texel, computed again
+    let out_uv = texture_octahedral_skirt_texel_uv(output_texel_i, output_size.x);
+
+    let output_interior = f32(output_size.x - 2u);
+    let input_interior = f32(textureDimensions(input).x - 2u);
+
+    // the footprint in the source's interior texels: [lo, lo + span), span = 2 + 2/n <= 3, so it overlaps at most 4 a side
+    let span = input_interior / output_interior;
+    let lo = floor(out_uv * output_interior) * span;
+    let first = floor(lo);
+
+    var sum = vec4(0.0);
+    var weight_sum = 0.0;
+
+    for (var y = 0u; y < 4u; y++) {
+        let texel_y = first.y + f32(y);
+        let overlap_y = min(texel_y + 1.0, lo.y + span) - max(texel_y, lo.y);
+
+        for (var x = 0u; x < 4u; x++) {
+            let texel_x = first.x + f32(x);
+            let overlap_x = min(texel_x + 1.0, lo.x + span) - max(texel_x, lo.x);
+
+            if (overlap_x <= 0.0 || overlap_y <= 0.0) {
+                continue;
+            }
+
+            // the overlap's solid angle: the octahedron's solid angle per unit area is |d|_1^3 along unit d,
+            // across the folds too, integrated at 2x2 points of the overlap
+            let overlap_lo = vec2(max(texel_x, lo.x), max(texel_y, lo.y));
+            let overlap = vec2(overlap_x, overlap_y);
+            var density = 0.0;
+            for (var k = 0u; k < 4u; k++) {
+                let at = overlap_lo + overlap * (vec2<f32>(f32(k & 1u), f32(k >> 1u)) * 0.5 + 0.25);
+                let l1 = dot(abs(uv_octahedral_unit_decode(at / input_interior)), vec3(1.0));
+                density += l1 * l1 * l1;
+            }
+            let weight = overlap_x * overlap_y * density;
+
+            sum += textureLoad(input, vec2<u32>(vec2(texel_x, texel_y)) + 1u, 0) * weight;
+            weight_sum += weight;
+        }
+    }
+
+    textureStore(output, output_texel_i, sum / weight_sum);
+}
+    `, [
+        chunk_texture_octahedral_skirt_texel_uv,
+        chunk_uv_octahedral_unit_decode,
+    ]
+);
+
+export const shader_downsample_environment_map = new ComputeShader(ShaderDescriptor.from({
+    label: 'Downsample environment map',
+    body,
+    resources
+}));

package/src/shade/renderer/light/environment/sphere_probe_lod_to_roughness.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Host twin of `chunk_sphere_probe_lod_to_roughness`: the linear roughness (blender's "UI roughness")
+ * a filtered level of the environment map is convolved at.
+ *
+ * @see https://projects.blender.org/blender/blender/src/commit/866ef5b468589587395b1ee7480ea75b4c0fbc26/source/blender/draw/engines/eevee_next/shaders/eevee_lightprobe_sphere_mapping_lib.glsl#L113
+ * @param {number} lod in [0, SPHERE_PROBE_MIPMAP_LEVELS - 1]
+ * @returns {number}
+ */
+export function sphere_probe_lod_to_roughness(lod: number): number;
+//# sourceMappingURL=sphere_probe_lod_to_roughness.d.ts.map

package/src/shade/renderer/light/environment/sphere_probe_lod_to_roughness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sphere_probe_lod_to_roughness.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/sphere_probe_lod_to_roughness.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,mDAHW,MAAM,GACJ,MAAM,CAclB"}

package/src/shade/renderer/light/environment/sphere_probe_lod_to_roughness.js

@@ -0,0 +1,23 @@
+import { SPHERE_PROBE_MIP_MAX_ROUGHNESS, SPHERE_PROBE_MIPMAP_LEVELS } from "./DEFINES.js";
+
+/**
+ * Host twin of `chunk_sphere_probe_lod_to_roughness`: the linear roughness (blender's "UI roughness")
+ * a filtered level of the environment map is convolved at.
+ *
+ * @see https://projects.blender.org/blender/blender/src/commit/866ef5b468589587395b1ee7480ea75b4c0fbc26/source/blender/draw/engines/eevee_next/shaders/eevee_lightprobe_sphere_mapping_lib.glsl#L113
+ * @param {number} lod in [0, SPHERE_PROBE_MIPMAP_LEVELS - 1]
+ * @returns {number}
+ */
+export function sphere_probe_lod_to_roughness(lod) {
+    const a = lod / (SPHERE_PROBE_MIPMAP_LEVELS - 1);
+
+    // factors of the ratio and of its square root, see chunk_roughness_to_mip_ratio
+    const b = 0.6;
+    const c = 0.4;
+
+    const c2 = c * c;
+
+    const ratio = (-Math.sqrt(4.0 * a * b * c2 + c2 * c2) + 2.0 * a * b + c2) / (2.0 * b * b);
+
+    return ratio * SPHERE_PROBE_MIP_MAX_ROUGHNESS;
+}

package/src/shade/renderer/shader/chunk/light/probe/chunk_probe_visibility_weight.d.ts

@@ -11,10 +11,14 @@
  * - `probe_visibility_chebyshev`: the chance the point is not occluded from the probe, by Chebyshev's
  *   inequality over the probe's depth moments (mean, mean of squares) toward it, the distance in the
  *   moments' own units; 1 nearer than the mean. The variance is held off zero.
- * - `probe_visibility_weight`: a smooth back-face term, a "wrap shading" ((n·d + 1)/2)² + 0.2 that keeps
- *   probes behind small details in play, times the visibility; then held off zero, and crushed below
- *   0.2 along a continuous cubic, since a little light reads as more than it is. The trilinear weight
- *   is the caller's, after the crush.
+ * - `probe_visibility_weight`: a smooth back-face term, a "wrap shading" ((n·d + 1)/2)², times the
+ *   visibility; then held off zero, and crushed below 0.2 along a continuous cubic, since a little light
+ *   reads as more than it is. The trilinear weight is the caller's, after the crush.
+ * - DDGI adds 0.2 to the wrap term to keep probes behind small details in play. That floor is left out:
+ *   a probe behind a thin wall, past its depth's mean at a grazing angle, passes Chebyshev at 0.94–0.97,
+ *   and the floor alone held it at ≈0.25, just above the crush. On Sponza's outer wall such probes took
+ *   11% of the pick, 32% where the wall sits 0.15 of a spacing past a lattice plane, a dark lattice of
+ *   blotches; without the floor 0.1% and 0.6%.
  *
  * @type {CodeChunk}
  */

package/src/shade/renderer/shader/chunk/light/probe/chunk_probe_visibility_weight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_visibility_weight.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/probe/chunk_probe_visibility_weight.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4CAFU,SAAS,CAiChB;0BArDuB,gCAAgC"}
+{"version":3,"file":"chunk_probe_visibility_weight.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/probe/chunk_probe_visibility_weight.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,4CAFU,SAAS,CAiChB;0BAzDuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/probe/chunk_probe_visibility_weight.js

@@ -13,10 +13,14 @@ import { CodeChunk } from "../../../compiler/CodeChunk.js";
  * - `probe_visibility_chebyshev`: the chance the point is not occluded from the probe, by Chebyshev's
  *   inequality over the probe's depth moments (mean, mean of squares) toward it, the distance in the
  *   moments' own units; 1 nearer than the mean. The variance is held off zero.
- * - `probe_visibility_weight`: a smooth back-face term, a "wrap shading" ((n·d + 1)/2)² + 0.2 that keeps
- *   probes behind small details in play, times the visibility; then held off zero, and crushed below
- *   0.2 along a continuous cubic, since a little light reads as more than it is. The trilinear weight
- *   is the caller's, after the crush.
+ * - `probe_visibility_weight`: a smooth back-face term, a "wrap shading" ((n·d + 1)/2)², times the
+ *   visibility; then held off zero, and crushed below 0.2 along a continuous cubic, since a little light
+ *   reads as more than it is. The trilinear weight is the caller's, after the crush.
+ * - DDGI adds 0.2 to the wrap term to keep probes behind small details in play. That floor is left out:
+ *   a probe behind a thin wall, past its depth's mean at a grazing angle, passes Chebyshev at 0.94–0.97,
+ *   and the floor alone held it at ≈0.25, just above the crush. On Sponza's outer wall such probes took
+ *   11% of the pick, 32% where the wall sits 0.15 of a spacing past a lattice plane, a dark lattice of
+ *   blotches; without the floor 0.1% and 0.6%.
  *
  * @type {CodeChunk}
  */
@@ -39,7 +43,7 @@ fn probe_visibility_weight(direction_to_probe: vec3<f32>, normal: vec3<f32>, vis
     // the small offset keeps a probe exactly behind the surface from going to zero
     let backface = max(0.0001, (dot(direction_to_probe, normal) + 1.0) * 0.5);
 
-    var weight = (backface * backface + 0.2) * visibility;
+    var weight = backface * backface * visibility;
 
     weight = max(1e-6, weight);
 

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

@@ -100,6 +100,12 @@ export class GhostTrail {
      * @param {number} time_ms
      */
     set(target: number, time_ms: number): void;
+    /**
+     * Stand the trail at `target` with nothing lost: every loss forgotten, whatever was showing. For a target that
+     * moved without anything being lost, such as the same amount out of a raised maximum.
+     * @param {number} target
+     */
+    reset(target: 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

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":"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"}
+{"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,cAFW,MAAM,QAShB;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

@@ -234,6 +234,20 @@ export class GhostTrail {
         this.__to = target;
     }
 
+    /**
+     * Stand the trail at `target` with nothing lost: every loss forgotten, whatever was showing. For a target that
+     * moved without anything being lost, such as the same amount out of a raised maximum.
+     * @param {number} target
+     */
+    reset(target) {
+        if (!Number.isFinite(target)) {
+            return;
+        }
+
+        this.__to = target;
+        this.__loss_count = 0;
+    }
+
     /**
      * Where the trail is at a given time: the highest of the live losses' trails, and never below the target.
      * @param {number} time_ms

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

@@ -3,11 +3,18 @@
  * a ghost behind the fill trails a drop so the loss stays readable for a moment.
  *
  * Two modes:
- * - notches (default): a continuous fill, with a notch at every multiple of each {@link SegmentTier}'s unit;
- * - cells (`cells` given): `count` separate cells with exact, identical gaps, for counting rounds and the like.
+ * - notches (default): a continuous fill, with a notch at every multiple of each {@link SegmentTier}'s unit. Each
+ *   tier is one layer the width of the bar (`.notch.<class_name>`), which CSS paints — colour, height — and a mask
+ *   cuts to that tier's notches;
+ * - cells (`cells` given): `count` separate cells with exact, identical gaps, for counting rounds and the like. One
+ *   strip (`.cell-strip`, the empty cells' colour) holding a `.cell-ghost` and a `.cell-fill`, cut into cells by a
+ *   mask; the fill and ghost end on a cell's edge, or part way across one that is filling.
  *
- * Notches and cells sit on whole device pixels at any pixel ratio and under a CSS scale. Colours, notch heights
- * and the ghost are styled by `segmented-resource-bar.css` through `--segmented-bar-*` custom properties.
+ * The masks are drawn in whole device pixels and the layers they cut placed so those pixels land on the screen's,
+ * at any pixel ratio and under a CSS scale: every notch of a tier is the same width and every gap the same, at
+ * 125% as at 100%. Colours, notch heights and the ghost are styled by `segmented-resource-bar.css` through
+ * `--segmented-bar-*` custom properties. Where masks cannot be drawn (no canvas, as under jsdom) the layers are
+ * placed but uncut.
  */
 export class SegmentedResourceBarView extends View {
     /**
@@ -105,16 +112,34 @@ export class SegmentedResourceBarView extends View {
      * @private
      */
     private __animate_ghost;
+    /**
+     * The max moved since the fill was last drawn: the next fill resets the ghost rather than trailing a loss
+     * @type {boolean}
+     * @private
+     */
+    private __max_moved;
     __built_max: number;
     __built_width: number;
     __built_ratio: number;
     __built_origin_phase: number;
     /**
-     * scratch for {@link segment_notch_place}
-     * @type {Float64Array}
+     * Cell mode: the cells as last laid out across {@link __el_strip}, or null before the bar has been measured
+     * @type {SegmentCellLayout|null}
+     * @private
+     */
+    private __cell_layout;
+    /**
+     * Device pixels per CSS pixel the cells were laid out at
+     * @type {number}
+     * @private
+     */
+    private __cell_ratio;
+    /**
+     * scratch: [x, width, ...] device-pixel columns for a mask
+     * @type {number[]}
      * @private
      */
-    private __place;
+    private __columns;
     /**
      *
      * @type {List<NumericInterval>}
@@ -132,20 +157,19 @@ export class SegmentedResourceBarView extends View {
      */
     private __value_fills;
     /**
+     * Notch mode: one layer per tier, the whole bar wide, styled by the tier's class and masked to its notches
      * @type {HTMLElement[]}
      * @private
      */
-    private __notch_elements;
+    private __tier_layers;
     /**
-     * @type {HTMLElement[]}
+     * Cell mode: the strip the cells are cut from by a mask, and the ghost and fill drawn along it
+     * @type {HTMLElement|null}
      * @private
      */
-    private __cell_elements;
-    __cell_fill_elements: HTMLDivElement[];
-    __cell_ghost_elements: HTMLDivElement[];
-    __cell_states: Uint8Array;
-    __cell_fill_drawn: Float64Array;
-    __cell_ghost_drawn: Float64Array;
+    private __el_strip;
+    __el_cell_ghost: HTMLDivElement;
+    __el_cell_fill: HTMLDivElement;
     /**
      * The notches' own box; what they are positioned in and what is measured to place them
      * @type {HTMLElement}
@@ -168,19 +192,31 @@ export class SegmentedResourceBarView extends View {
     /**
      * Place the notches or cells again, if the max, the bar's width (by {@link REBUILD_WIDTH_THRESHOLD_PX} or more),
      * its pixel ratio or the device-pixel phase of its left edge has moved since they were last placed.
+     *
+     * Both are drawn as a mask in whole device pixels over a layer CSS paints (see {@link segment_mask_url}): a DOM
+     * box per notch or cell cannot be put on the device-pixel grid at a fractional pixel ratio, where Chrome paints
+     * a row of equal 1 px gaps as 1, 2, 1, 2... whatever positions it is given (measured at 125% and 150%).
      */
     updateSegments(): void;
+    /**
+     * @param {HTMLElement} el
+     * @param {number} width_device
+     * @param {number} shift_px
+     * @param {number} ratio
+     * @private
+     */
+    private __place_layer;
     /**
      * @param {number} max
-     * @param {number} width
-     * @param {number} left
+     * @param {number} width_device
+     * @param {number} shift_px
      * @param {number} ratio
      * @private
      */
     private __place_notches;
     /**
-     * @param {number} width
-     * @param {number} left
+     * @param {number} width_device
+     * @param {number} shift_px
      * @param {number} ratio
      * @private
      */

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;;;;;;;;;;;;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"}
+{"version":3,"file":"SegmentedResourceBarView.d.ts","sourceRoot":"","sources":["../../../../../../src/view/elements/progress/segmented/SegmentedResourceBarView.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;;;GAiBG;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;OAyShB;IA5QG;;;;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;IAgiB3B;;OAEG;IACH,4BASC;IAxiBG,yBAA4B;IAC5B,mBAAmB;IA6fvB;;OAEG;IACH,wBAQC;IArgBG;;;;OAIG;IACH,oBAAwB;IAGxB,oBAAsB;IACtB,sBAAwB;IACxB,sBAAwB;IACxB,6BAA+B;IAE/B;;;;OAIG;IACH,sBAAyB;IAEzB;;;;OAIG;IACH,qBAAqB;IAErB;;;;OAIG;IACH,kBAAmB;IAEnB;;;OAGG;IACH,YAFU,qBAAqB,CAEH;IAG5B,mBAAuC;IASvC;;;OAGG;IACH,mBAA+C;IAG/C;;;OAGG;IACH,sBAAuB;IAEvB;;;;OAIG;IACH,sBAAuB;IAEvB;;;;OAIG;IACH,mBAAsB;IACtB,gCAA2B;IAC3B,+BAA0B;IAkBtB;;;;OAIG;IACH,oBAAgD;IAoCpD;;;OAGG;IACH,gBAFU,QAAQ,CAsChB;IAWF;;;;OAIG;IACH,uBAA2C;IAuC/C,eAGC;IAED,wBAMC;IAED;;;;;;;OAOG;IACH,uBA4DC;IAED;;;;;;OAMG;IACH,sBAKC;IAED;;;;;;OAMG;IACH,wBA2CC;IAED;;;;;OAKG;IACH,sBAoBC;IAED,mBAiDC;IAED;;;;OAIG;IACH,eAaC;IAED;;;;OAIG;IACH,qBAoBC;IAeD;;;;OAIG;IACH,mCAUC;CAeJ;iBA5rBgB,kBAAkB;iBALlB,0CAA0C;qBAGtC,6BAA6B;oBAF9B,kCAAkC"}