@woosh/meep-engine 3.60.2 → 3.60.4

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

@@ -0,0 +1,119 @@
+import { assert } from "../../../../core/assert.js";
+import { cone_cosine_from_roughness } from "../../../../core/math/physics/brdf/cone_cosine_from_roughness.js";
+import { BSDF_ROUGHNESS_MINIMUM } from "./DEFINES.js";
+import { sphere_probe_lod_to_roughness } from "./sphere_probe_lod_to_roughness.js";
+
+/**
+ * Samples per texel of level 1. They read a Gaussian-blurred copy of level 0, so the count sets how
+ * fine that blur can be and how much of the lobe is the lobe's own. Measured on a 1024 map against
+ * level 1 from 8192 point taps (sun lobe 1.315° rms): 64 → sky rms error 0.092, sun 1.345°, a bright
+ * texel's share 0.998 ± 0.008; 128 → 0.057, 1.342°, 0.998 ± 0.003, never above 1.
+ * @type {number}
+ */
+export const LEVEL_1_SAMPLE_COUNT = 128;
+
+/**
+ * Gaussian σ per spacing of the points it is sampled at. A Gaussian sampled on a lattice of spacing Δ
+ * sums to its integral up to its first alias, 2 exp(-2π² σ²/Δ²): 1e-4 at 0.7. Holds both for the
+ * blurred level's own texels and for level 1's samples reading it.
+ * @type {number}
+ */
+const SIGMA_PER_SPACING = 0.7;
+
+/**
+ * A Gaussian's weight past 3 σ is under 1.2% of its peak, and its share of the integral in 2D under 1.2%.
+ * @type {number}
+ */
+const RADIUS_IN_SIGMA = 3;
+
+/**
+ * Side of one texel of an octahedral level, as an angle. A skirted level of side `size` holds an
+ * n = size - 2 square over 4π steradians, but its texels are not alike: the octahedron's solid angle
+ * per unit area of the square is 1 / |p|^3, |p| from 1 at its vertices to 1/√3 at its face centres,
+ * so a texel covers 1 to 3√3 times the area-mean density π.
+ *
+ * @param {number} size
+ * @returns {{mean: number, min: number, max: number}}
+ */
+function octahedral_texel_angle(size) {
+    const mean = Math.sqrt(4 * Math.PI) / (size - 2);
+
+    return {
+        mean,
+        min: mean * Math.sqrt(1 / Math.PI),
+        max: mean * Math.sqrt(3 * Math.sqrt(3) / Math.PI),
+    };
+}
+
+/**
+ * How level 1 of a map of side `map_size` is filtered.
+ *
+ * Level 1's samples are uniform in its cone, so each stands for Ω_s = Ω_cone / N. They read a copy of
+ * level 0 blurred by a Gaussian of σ = 0.7 · max(√Ω_s, the copy's largest texel), wide enough that
+ * neither the samples nor the copy's texels alias. The copy is level 0 averaged down to level 1's
+ * size when that leaves the lobe room for the blur, else level 0's own size.
+ *
+ * The lobe exp(2 (N·H - 1) / r^4) is a Gaussian of variance 2 r^4 an axis (N·H = cos(θ/2)), and
+ * Gaussians add variances, so it is narrowed by what the copy adds: the blur, and the bilinear tent
+ * across the copy's texels beyond the one across level 0's. It narrows to the minimum roughness when
+ * the map's texels are coarser than the lobe itself, and level 1 is then the blur alone.
+ *
+ * @param {number} map_size side of the map's level 0
+ * @returns {{
+ *   blurred_size: number,
+ *   average_first: boolean,
+ *   sigma: number,
+ *   radius: number,
+ *   lobe_roughness: number,
+ * }} `average_first`: the copy is level 0 averaged to level 1's size before the blur; `sigma` the
+ * blur still to apply (radians), past what averaging adds; `radius` in the copy's texels
+ */
+export function environment_level_1_blur_plan(map_size) {
+    assert.isNonNegativeInteger(map_size, 'map_size');
+    assert.greaterThanOrEqual(map_size, 6, 'a level 1 needs at least 3 texels');
+
+    const roughness = Math.max(sphere_probe_lod_to_roughness(1), BSDF_ROUGHNESS_MINIMUM);
+    const lobe_variance = 2 * roughness ** 4;
+
+    const cone_solid_angle = 2 * Math.PI * (1 - cone_cosine_from_roughness(roughness));
+    const sample_spacing = Math.sqrt(cone_solid_angle / LEVEL_1_SAMPLE_COUNT);
+
+    const level_0 = octahedral_texel_angle(map_size);
+
+    function plan(blurred_size, average_first) {
+        const texel = octahedral_texel_angle(blurred_size);
+
+        const total = (SIGMA_PER_SPACING * Math.max(sample_spacing, texel.max)) ** 2;
+
+        // averaging boxes a texel of the copy, s^2 / 12 an axis
+        const averaged = average_first ? texel.mean ** 2 / 12 : 0;
+        const sigma = Math.sqrt(total - averaged);
+
+        // a bilinear tent across texels of side s is s^2 / 6 an axis; level 0's own is in the lobe already
+        const bilinear = (texel.mean ** 2 - level_0.mean ** 2) / 6;
+
+        return {
+            blurred_size,
+            average_first,
+            sigma,
+            radius: Math.ceil(RADIUS_IN_SIGMA * sigma / texel.min),
+            lobe_variance: lobe_variance - total - bilinear,
+        };
+    }
+
+    let chosen = plan(map_size >> 1, true);
+
+    if (chosen.lobe_variance <= 0) {
+        chosen = plan(map_size, false);
+    }
+
+    const minimum_variance = 2 * BSDF_ROUGHNESS_MINIMUM ** 4;
+
+    return {
+        blurred_size: chosen.blurred_size,
+        average_first: chosen.average_first,
+        sigma: chosen.sigma,
+        radius: chosen.radius,
+        lobe_roughness: Math.sqrt(Math.sqrt(Math.max(chosen.lobe_variance, minimum_variance) / 2)),
+    };
+}

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

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
 /**
  * Offer the pipelines {@link execute_filter_environment_map} dispatches — see {@link PipelineEnquiry}.
  *
@@ -5,21 +8,26 @@
  */
 export function enquire_filter_environment_map_pipelines(enquiry: PipelineEnquiry): void;
 /**
- * The plain averages of a map's level 0 the prefilter's level 1 samples from: level 1 down as far as
- * its samples reach, as a texture of their own, so the map keeps its levels 1.. for the filtered
- * result. Nothing reads them after the prefilter, so a frame graph holds them transiently.
+ * The scratch levels the prefilter's level 1 reads through: level 0 blurred by a Gaussian, and the
+ * plain average it is blurred from when the plan averages first. Textures of their own, so the map
+ * keeps its levels 1.. for the filtered result; nothing reads them after the prefilter, so a frame
+ * graph holds them transiently.
  *
  * @param {number} map_size side of the map's level 0
- * @returns {TextureResourceDescriptor}
+ * @returns {{averaged: TextureResourceDescriptor|null, blurred: TextureResourceDescriptor}}
  */
-export function environment_map_averages_descriptor(map_size: number): TextureResourceDescriptor;
+export function environment_map_scratch_descriptors(map_size: number): {
+    averaged: TextureResourceDescriptor | null;
+    blurred: TextureResourceDescriptor;
+};
 /**
  *
  * @param {GPUTextureContext} map
- * @param {GPUTextureContext} averages described by {@link environment_map_averages_descriptor}
+ * @param {GPUTextureContext|null} averaged described by {@link environment_map_scratch_descriptors}
+ * @param {GPUTextureContext} blurred described by {@link environment_map_scratch_descriptors}
  * @param {ShadeGPUCommandContext} encoder
  */
-export function execute_filter_environment_map(map: GPUTextureContext, averages: GPUTextureContext, encoder: ShadeGPUCommandContext): void;
+export function execute_filter_environment_map(map: GPUTextureContext, averaged: GPUTextureContext | null, blurred: GPUTextureContext, encoder: ShadeGPUCommandContext): void;
 export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
 //# sourceMappingURL=execute_filter_environment_map.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"execute_filter_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/execute_filter_environment_map.js"],"names":[],"mappings":"AAuBA;;;;GAIG;AACH,kEAFW,eAAe,QAMzB;AAsBD;;;;;;;GAOG;AACH,8DAHW,MAAM,GACJ,yBAAyB,CAyBrC;AAED;;;;;GAKG;AACH,2IA0GC;8BAzLY,OAAO,6CAA6C,EAAE,eAAe;0CAZxC,oDAAoD"}
+{"version":3,"file":"execute_filter_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/execute_filter_environment_map.js"],"names":[],"mappings":"AAUA;;GAEG;AAEH;;;;GAIG;AACH,kEAFW,eAAe,QAOzB;AAcD;;;;;;;;GAQG;AACH,8DAHW,MAAM,GACJ;IAAC,QAAQ,EAAE,yBAAyB,GAAC,IAAI,CAAC;IAAC,OAAO,EAAE,yBAAyB,CAAA;CAAC,CAS1F;AAED;;;;;;GAMG;AACH,iFAJW,oBAAkB,IAAI,qEA2HhC;8BA3KY,OAAO,6CAA6C,EAAE,eAAe;0CATxC,oDAAoD"}

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

@@ -1,26 +1,17 @@
 import { assert } from "../../../../core/assert.js";
 import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
 import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
-import { cone_cosine_from_roughness } from "../../../../core/math/physics/brdf/cone_cosine_from_roughness.js";
-import { BSDF_ROUGHNESS_MINIMUM, SPHERE_PROBE_MIPMAP_LEVELS } from "./DEFINES.js";
+import { SPHERE_PROBE_MIPMAP_LEVELS } from "./DEFINES.js";
+import { environment_level_1_blur_plan } from "./environment_level_1_blur_plan.js";
+import { shader_blur_environment_map } from "./shader_blur_environment_map.js";
 import { shader_convolve_reflection_map } from "./shader_convolve_reflection_map.js";
-import {
-    CONVOLVE_FROM_AVERAGES_SAMPLE_COUNT,
-    shader_convolve_reflection_map_from_averages
-} from "./shader_convolve_reflection_map_from_averages.js";
+import { shader_convolve_reflection_map_from_blurred } from "./shader_convolve_reflection_map_from_blurred.js";
 import { shader_downsample_environment_map } from "./shader_downsample_environment_map.js";
-import { sphere_probe_lod_to_roughness } from "./sphere_probe_lod_to_roughness.js";
 
 /**
  * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  */
 
-/**
- * The smallest side a skirted level of the averages goes down to: two interior texels.
- * @type {number}
- */
-const AVERAGES_MIN_SIZE = 4;
-
 /**
  * Offer the pipelines {@link execute_filter_environment_map} dispatches — see {@link PipelineEnquiry}.
  *
@@ -28,76 +19,56 @@ const AVERAGES_MIN_SIZE = 4;
  */
 export function enquire_filter_environment_map_pipelines(enquiry) {
     enquiry.compute.push(shader_downsample_environment_map.pipeline);
-    enquiry.compute.push(shader_convolve_reflection_map_from_averages.pipeline);
+    enquiry.compute.push(shader_blur_environment_map.pipeline);
+    enquiry.compute.push(shader_convolve_reflection_map_from_blurred.pipeline);
     enquiry.compute.push(shader_convolve_reflection_map.pipeline);
 }
 
 /**
- * How many averages level 1's samples reach. A sample reads the level whose texel is the solid angle
- * it stands for, and the coarsest it asks for is where the octahedron's texels are smallest
- * (|d|_1 = 1): the lod `shader_convolve_reflection_map_from_averages` takes, at its largest. 3 for a
- * 1024 map, one more for each doubling.
- *
- * @param {number} map_size side of the map's level 0
- * @returns {number}
- */
-function averages_read_by_level_1(map_size) {
-    const roughness = Math.max(sphere_probe_lod_to_roughness(1), BSDF_ROUGHNESS_MINIMUM);
-    const cone_solid_angle = 2 * Math.PI * (1 - cone_cosine_from_roughness(roughness));
-    const sample_solid_angle = cone_solid_angle / CONVOLVE_FROM_AVERAGES_SAMPLE_COUNT;
-
-    const interior = map_size - 2;
-    const smallest_texel_solid_angle = 4 / (interior * interior);
-
-    return Math.max(1, Math.ceil(0.5 * Math.log2(sample_solid_angle / smallest_texel_solid_angle)));
-}
-
-/**
- * The plain averages of a map's level 0 the prefilter's level 1 samples from: level 1 down as far as
- * its samples reach, as a texture of their own, so the map keeps its levels 1.. for the filtered
- * result. Nothing reads them after the prefilter, so a frame graph holds them transiently.
- *
- * @param {number} map_size side of the map's level 0
+ * @param {number} size
  * @returns {TextureResourceDescriptor}
  */
-export function environment_map_averages_descriptor(map_size) {
-    assert.isNonNegativeInteger(map_size, 'map_size');
-
-    const size = map_size >> 1;
-
-    let available = 0;
-    for (let s = size; s >= AVERAGES_MIN_SIZE; s >>= 1) {
-        available++;
-    }
-
-    assert.greaterThanOrEqual(available, 1, 'environment map too small to average');
-
-    const mipLevelCount = Math.min(available, averages_read_by_level_1(map_size));
-
-    const descriptor = TextureResourceDescriptor.from({
+function scratch_level_descriptor(size) {
+    return TextureResourceDescriptor.from({
         resolution: [size, size],
         format: "rgba16float",
         usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING,
     });
+}
 
-    descriptor.mipLevelCount = mipLevelCount;
+/**
+ * The scratch levels the prefilter's level 1 reads through: level 0 blurred by a Gaussian, and the
+ * plain average it is blurred from when the plan averages first. Textures of their own, so the map
+ * keeps its levels 1.. for the filtered result; nothing reads them after the prefilter, so a frame
+ * graph holds them transiently.
+ *
+ * @param {number} map_size side of the map's level 0
+ * @returns {{averaged: TextureResourceDescriptor|null, blurred: TextureResourceDescriptor}}
+ */
+export function environment_map_scratch_descriptors(map_size) {
+    const plan = environment_level_1_blur_plan(map_size);
 
-    return descriptor;
+    return {
+        averaged: plan.average_first ? scratch_level_descriptor(plan.blurred_size) : null,
+        blurred: scratch_level_descriptor(plan.blurred_size),
+    };
 }
 
 /**
  *
  * @param {GPUTextureContext} map
- * @param {GPUTextureContext} averages described by {@link environment_map_averages_descriptor}
+ * @param {GPUTextureContext|null} averaged described by {@link environment_map_scratch_descriptors}
+ * @param {GPUTextureContext} blurred described by {@link environment_map_scratch_descriptors}
  * @param {ShadeGPUCommandContext} encoder
  */
 export function execute_filter_environment_map(
     map,
-    averages,
+    averaged,
+    blurred,
     encoder
 ) {
     assert.defined(map);
-    assert.defined(averages);
+    assert.defined(blurred);
     assert.defined(encoder);
 
     /*
@@ -121,35 +92,50 @@ export function execute_filter_environment_map(
         return;
     }
 
-    const level_0 = map.obtainView(TextureViewDescriptor.from({
+    const plan = environment_level_1_blur_plan(map.size[0]);
+
+    assert.equal(blurred.size[0], plan.blurred_size, 'blurred level is not the size the plan blurs at');
+
+    const single_level = TextureViewDescriptor.from({
         baseMipLevel: 0,
         mipLevelCount: 1,
-    }));
+    });
 
-    // the averages, each from the one above it, the first from level 0
-    const average_levels = averages.descriptor.mipLevelCount;
+    const level_0 = map.obtainView(single_level);
+    const blurred_group_count = Math.max(1, Math.ceil(plan.blurred_size / 16));
 
-    for (let i = 0; i < average_levels; i++) {
-        const target_size = averages.size[0] >> i;
-        const group_count = Math.max(1, Math.ceil(target_size / 16));
+    let unblurred = level_0;
+
+    if (plan.average_first) {
+        assert.defined(averaged, 'averaged');
 
         shader_downsample_environment_map.dispatch({
             encoder,
-            group_count_x: group_count,
-            group_count_y: group_count,
+            group_count_x: blurred_group_count,
+            group_count_y: blurred_group_count,
             bindings: {
-                input: i === 0 ? level_0 : averages.obtainView(TextureViewDescriptor.from({
-                    baseMipLevel: i - 1,
-                    mipLevelCount: 1,
-                })),
-                output: averages.obtainView(TextureViewDescriptor.from({
-                    baseMipLevel: i,
-                    mipLevelCount: 1
-                }))
+                input: level_0,
+                output: averaged.obtainView(single_level)
             }
         });
+
+        unblurred = averaged.obtainView(single_level);
     }
 
+    shader_blur_environment_map.dispatch({
+        encoder,
+        group_count_x: blurred_group_count,
+        group_count_y: blurred_group_count,
+        bindings: {
+            settings: {
+                inverse_two_sigma_squared: 1 / (2 * plan.sigma * plan.sigma),
+                radius: plan.radius,
+            },
+            input: unblurred,
+            output: blurred.obtainView(single_level)
+        }
+    });
+
     for (let i = 1; i < mips; i++) {
         const target_width = map.size[0] >> i;
         const target_height = map.size[1] >> i;
@@ -165,17 +151,14 @@ export function execute_filter_environment_map(
         }));
 
         if (i === 1) {
-            // from level 0 and its averages: level 0 is too fine for the taps that cover level 1's cone
-            shader_convolve_reflection_map_from_averages.dispatch({
+            // level 0 is too fine for the taps that cover level 1's cone; its blurred copy is not
+            shader_convolve_reflection_map_from_blurred.dispatch({
                 encoder,
                 group_count_x: dispatch_x,
                 group_count_y: dispatch_y,
                 bindings: {
-                    level_0,
-                    averages: averages.obtainView(TextureViewDescriptor.from({
-                        baseMipLevel: 0,
-                        mipLevelCount: average_levels,
-                    })),
+                    lobe_roughness: plan.lobe_roughness,
+                    blurred: blurred.obtainView(single_level),
                     output
                 }
             });

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

@@ -1 +1 @@
-{"version":3,"file":"graph_filter_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/graph_filter_environment_map.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH;IAJ+B,KAAK,EAAzB,UAAU;IACM,GAAG,EAAnB,MAAM;IACJ,MAAM,CAmClB;AAED;;;;;;GAMG;AACH,6GAYC;2BApE0B,8DAA8D"}
+{"version":3,"file":"graph_filter_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/graph_filter_environment_map.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH;IAJ+B,KAAK,EAAzB,UAAU;IACM,GAAG,EAAnB,MAAM;IACJ,MAAM,CA4ClB;AAED;;;;;;GAMG;AACH,6GAYC;2BA7E0B,8DAA8D"}

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

@@ -1,7 +1,7 @@
 import { FrameGraph } from "../../../../engine/graphics/render/frame_graph/FrameGraph.js";
 import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
 import {
-    environment_map_averages_descriptor,
+    environment_map_scratch_descriptors,
     execute_filter_environment_map
 } from "./execute_filter_environment_map.js";
 
@@ -32,17 +32,26 @@ export function graph_filter_environment_map({
          */
         const map = resources.get(data.map);
 
-        execute_filter_environment_map(map, resources.get(data.averages), context.encoder);
+        execute_filter_environment_map(
+            map,
+            data.averaged === undefined ? null : resources.get(data.averaged),
+            resources.get(data.blurred),
+            context.encoder
+        );
 
     }
 
     const builder = graph.add("filter env map", data, execute);
 
     data.map = builder.read(map);
-    data.averages = builder.create(
-        "env map averages",
-        environment_map_averages_descriptor(graph.getDescriptor(map).resolution[0])
-    );
+
+    const scratch = environment_map_scratch_descriptors(graph.getDescriptor(map).resolution[0]);
+
+    if (scratch.averaged !== null) {
+        data.averaged = builder.create("env map averaged", scratch.averaged);
+    }
+
+    data.blurred = builder.create("env map blurred", scratch.blurred);
 
     return builder.write(map);
 }

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

@@ -0,0 +1,3 @@
+export const shader_blur_environment_map: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_blur_environment_map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_blur_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_blur_environment_map.js"],"names":[],"mappings":"AA0GA,wDAII;8BAvG0B,+BAA+B"}

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

@@ -0,0 +1,111 @@
+import {
+    chunk_uv_octahedral_unit_decode
+} from "../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import {
+    chunk_texture_octahedral_wrap_texel_coordinates
+} from "../../shader/chunk/texture/octahedral/chunk_texture_octahedral_wrap_texel_coordinates.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";
+import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+const BLUR_SETTINGS = WebGPUStruct.from({
+    // 1 / (2 σ²), σ in radians
+    inverse_two_sigma_squared: f32,
+    // texels either side, enough for 3 σ where the octahedron's texels are smallest
+    radius: u32,
+}, 'EnvironmentBlurSettings');
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", BLUR_SETTINGS);
+
+resources.createGroup()
+    .addTexture("input", "float")
+    .addStorageTexture("output", "rgba16float")
+;
+
+/**
+ * A skirted octahedral level blurred by a Gaussian on the sphere, into a level of the same size:
+ * each texel the mean of the texels within `radius`, weighted by exp(-θ² / 2σ²) of the angle θ
+ * between them and by their solid angle. The octahedral square wraps at its edges, so the kernel is
+ * the same on either side of a fold.
+ *
+ * A Gaussian, not a box, because level 1 reads this through a lobe that is itself a Gaussian, and
+ * the two compose into a Gaussian whose variance is the sum: the lobe narrows by exactly what the
+ * blur adds (see environment_level_1_blur_plan).
+ *
+ * @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;
+    }
+
+    let interior = i32(output_size.x) - 2;
+
+    // the skirt too: a skirt texel takes its interior twin, so it is that texel, computed again
+    let centre = texture_octahedral_wrap_texel_coordinates(vec2<i32>(output_texel_i) - 1, interior);
+    let centre_direction = uv_octahedral_unit_decode((vec2<f32>(centre) + 0.5) / f32(interior));
+
+    let radius = i32(settings.radius);
+
+    var sum = vec4(0.0);
+    var weight_sum = 0.0;
+
+    for (var y = -radius; y <= radius; y++) {
+        for (var x = -radius; x <= radius; x++) {
+            let unwrapped = vec2<i32>(centre) + vec2(x, y);
+            let texel = texture_octahedral_wrap_texel_coordinates(unwrapped, interior);
+
+            // near the middle of the square's edge the fold maps the window onto itself, so a tap that
+            // wraps can land on a texel the window reaches directly: count every texel once
+            let wrapped = any(unwrapped < vec2(0)) || any(unwrapped >= vec2(interior));
+            let in_window = all(abs(vec2<i32>(texel) - vec2<i32>(centre)) <= vec2(radius));
+
+            if (wrapped && in_window) {
+                continue;
+            }
+
+            let direction = uv_octahedral_unit_decode((vec2<f32>(texel) + 0.5) / f32(interior));
+
+            // θ² from the chord c: θ = 2 asin(c / 2), so θ² = c² + c⁴ / 12 + ...
+            let chord = direction - centre_direction;
+            let chord_squared = dot(chord, chord);
+            let theta_squared = chord_squared * (1.0 + chord_squared / 12.0);
+
+            // the octahedron's solid angle per unit area of the square is |d|_1^3 along unit d
+            let l1 = dot(abs(direction), vec3(1.0));
+
+            let weight = exp(-theta_squared * settings.inverse_two_sigma_squared) * l1 * l1 * l1;
+
+            sum += textureLoad(input, texel + 1u, 0) * weight;
+            weight_sum += weight;
+        }
+    }
+
+    textureStore(output, output_texel_i, sum / weight_sum);
+}
+    `, [
+        chunk_texture_octahedral_wrap_texel_coordinates,
+        chunk_uv_octahedral_unit_decode,
+    ]
+);
+
+export const shader_blur_environment_map = new ComputeShader(ShaderDescriptor.from({
+    label: 'Blur environment map',
+    body,
+    resources
+}));

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

@@ -0,0 +1,3 @@
+export const shader_convolve_reflection_map_from_blurred: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_convolve_reflection_map_from_blurred.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_convolve_reflection_map_from_blurred.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_convolve_reflection_map_from_blurred.js"],"names":[],"mappings":"AA2HA,wEAII;8BA7G0B,+BAA+B"}