@woosh/meep-engine 3.60.0 → 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/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,19 @@ export class GhostTrail {
      */
     set(target: number, time_ms: number): void;
     /**
-     * Where the trail is at a given time; never below its 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: 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 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,cAFW,MAAM,QAShB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,OAAO,CAkBnB;CACJ"}