@woosh/meep-engine 3.60.3 → 3.60.5

package/src/shade/renderer/hiz/chunk_hzb_footprint_x.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The mip 0 reduction's footprint across x, in source texels, by {@link HZB_FOOTPRINT_X}:
+ *
+ * ```wgsl
+ * const HZB_FOOTPRINT_X: i32
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_hzb_footprint_x: CodeChunkChoice;
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_hzb_footprint_x.d.ts.map

package/src/shade/renderer/hiz/chunk_hzb_footprint_x.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_hzb_footprint_x.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/chunk_hzb_footprint_x.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,oCAFU,eAAe,CAEkD;gCAb3C,uCAAuC"}

package/src/shade/renderer/hiz/chunk_hzb_footprint_x.js

@@ -0,0 +1,27 @@
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
+import { HZB_FOOTPRINT_X } from "./HZB_FOOTPRINT_X.js";
+import { HZBFootprint } from "./HZBFootprint.js";
+
+/**
+ * The mip 0 reduction's footprint across x, in source texels, by {@link HZB_FOOTPRINT_X}:
+ *
+ * ```wgsl
+ * const HZB_FOOTPRINT_X: i32
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_hzb_footprint_x = CodeChunkChoice.from(HZB_FOOTPRINT_X);
+
+chunk_hzb_footprint_x.add(HZBFootprint.Two, CodeChunk.from(
+    //language=WGSL
+    `
+const HZB_FOOTPRINT_X: i32 = 2;
+`));
+
+chunk_hzb_footprint_x.add(HZBFootprint.Three, CodeChunk.from(
+    //language=WGSL
+    `
+const HZB_FOOTPRINT_X: i32 = 3;
+`));

package/src/shade/renderer/hiz/chunk_hzb_footprint_y.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The mip 0 reduction's footprint across y, in source texels, by {@link HZB_FOOTPRINT_Y}:
+ *
+ * ```wgsl
+ * const HZB_FOOTPRINT_Y: i32
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_hzb_footprint_y: CodeChunkChoice;
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_hzb_footprint_y.d.ts.map

package/src/shade/renderer/hiz/chunk_hzb_footprint_y.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_hzb_footprint_y.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/chunk_hzb_footprint_y.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,oCAFU,eAAe,CAEkD;gCAb3C,uCAAuC"}

package/src/shade/renderer/hiz/chunk_hzb_footprint_y.js

@@ -0,0 +1,27 @@
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
+import { HZB_FOOTPRINT_Y } from "./HZB_FOOTPRINT_Y.js";
+import { HZBFootprint } from "./HZBFootprint.js";
+
+/**
+ * The mip 0 reduction's footprint across y, in source texels, by {@link HZB_FOOTPRINT_Y}:
+ *
+ * ```wgsl
+ * const HZB_FOOTPRINT_Y: i32
+ * ```
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_hzb_footprint_y = CodeChunkChoice.from(HZB_FOOTPRINT_Y);
+
+chunk_hzb_footprint_y.add(HZBFootprint.Two, CodeChunk.from(
+    //language=WGSL
+    `
+const HZB_FOOTPRINT_Y: i32 = 2;
+`));
+
+chunk_hzb_footprint_y.add(HZBFootprint.Three, CodeChunk.from(
+    //language=WGSL
+    `
+const HZB_FOOTPRINT_Y: i32 = 3;
+`));

package/src/shade/renderer/hiz/hzb_footprint_texels.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The widest footprint, in source texels along one axis, of any HZB texel when `output_size` texels cover
+ * `source_size`: HZB texel `i` covers `[i·s/o, (i+1)·s/o)` and reduces every source texel that span
+ * touches, clipped to the source.
+ *
+ * An upper bound on the footprints {@link shader_hzb_reduce_mip0} reads, whose bounds are this span
+ * nudged inward by a float epsilon.
+ *
+ * @param {number} source_size source texels on the axis
+ * @param {number} output_size HZB mip 0 texels on the axis
+ * @returns {number}
+ */
+export function hzb_footprint_texels(source_size: number, output_size: number): number;
+//# sourceMappingURL=hzb_footprint_texels.d.ts.map

package/src/shade/renderer/hiz/hzb_footprint_texels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hzb_footprint_texels.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/hzb_footprint_texels.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,kDAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAqBlB"}

package/src/shade/renderer/hiz/hzb_footprint_texels.js

@@ -0,0 +1,34 @@
+import { assert } from "../../../core/assert.js";
+
+/**
+ * The widest footprint, in source texels along one axis, of any HZB texel when `output_size` texels cover
+ * `source_size`: HZB texel `i` covers `[i·s/o, (i+1)·s/o)` and reduces every source texel that span
+ * touches, clipped to the source.
+ *
+ * An upper bound on the footprints {@link shader_hzb_reduce_mip0} reads, whose bounds are this span
+ * nudged inward by a float epsilon.
+ *
+ * @param {number} source_size source texels on the axis
+ * @param {number} output_size HZB mip 0 texels on the axis
+ * @returns {number}
+ */
+export function hzb_footprint_texels(source_size, output_size) {
+    assert.isNonNegativeInteger(source_size, 'source_size');
+    assert.isNonNegativeInteger(output_size, 'output_size');
+    assert.greaterThan(output_size, 0, 'output_size');
+
+    let widest = 0;
+
+    for (let i = 0; i < output_size; i++) {
+        const first = Math.floor(i * source_size / output_size);
+        const end = Math.min(Math.ceil((i + 1) * source_size / output_size), source_size);
+
+        const width = end - first;
+
+        if (width > widest) {
+            widest = width;
+        }
+    }
+
+    return widest;
+}

package/src/shade/renderer/hiz/shader_hzb_reduce_any.d.ts

@@ -1,8 +1,3 @@
-/**
- * Initial reduction pass, works with non-power-of-two resolutions as input
- * @type {ComputeShader}
- */
-export const shader_hzb_reduce_mip0: ComputeShader;
 /**
  * Mip1+ reduction pass, works with non-power-of-two resolutions as input
  * @type {ComputeShader}

package/src/shade/renderer/hiz/shader_hzb_reduce_any.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_hzb_reduce_any.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/shader_hzb_reduce_any.js"],"names":[],"mappings":"AAoBA;;;GAGG;AACH,qCAFU,aAAa,CAepB;AAGH;;;GAGG;AACH,oCAFU,aAAa,CAcpB;8BAvD2B,4BAA4B"}
+{"version":3,"file":"shader_hzb_reduce_any.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/shader_hzb_reduce_any.js"],"names":[],"mappings":"AAoBA;;;GAGG;AACH,oCAFU,aAAa,CAcpB;8BAnC2B,4BAA4B"}

package/src/shade/renderer/hiz/shader_hzb_reduce_any.js

@@ -1,57 +1,37 @@
-import { vec2f, vec2u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { generate_downsampler_code } from "./generate_downsampler_code.js";
-
-import { HZB_TEXTURE_FORMAT } from "./HZB_TEXTURE_FORMAT.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-pass, eight bytes, read-only: immediate data rather than a uniform buffer. The reduction
-// walks the mip chain a pass at a time and every pass wants a different resolution, which used to
-// mean a persistent table of them bound at a per-mip dynamic offset.
-resources.setImmediate("output_resolution", vec2u);
-
-resources.createGroup()
-    .addTexture("tInput", "unfilterable-float")
-    .addStorageTexture("tOutput", HZB_TEXTURE_FORMAT, "2d", "write-only")
-;
-
-
-/**
- * Initial reduction pass, works with non-power-of-two resolutions as input
- * @type {ComputeShader}
- */
-export const shader_hzb_reduce_mip0 = ComputeShader.from({
-    label: 'HZB / reduce mip0',
-    // NOTE: we reduce from depth, so texel read happens from the .R (X) channel for both min and max.
-    body: generate_downsampler_code({
-        type: vec2f,
-        initial_value: 'vec2( 1.0, 0.0 )',
-        //language=WGSL
-        reduction_code: `
-        output.x = min(texel.x, output.x);
-        output.y = max(texel.x, output.y);
-        `,
-    }),
-    resources,
-});
-
-
-/**
- * Mip1+ reduction pass, works with non-power-of-two resolutions as input
- * @type {ComputeShader}
- */
-export const shader_hzb_reduce_any = ComputeShader.from({
-    label: 'HZB / reduce any resolution',
-    body: generate_downsampler_code({
-        type: vec2f,
-        initial_value: 'vec2( 1.0, 0.0 )',
-        //language=WGSL
-        reduction_code: `
-        output.x = min(texel.x, output.x);
-        output.y = max(texel.y, output.y);
-        `,
-    }),
-    resources,
-});
+import { vec2f, vec2u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { generate_downsampler_code } from "./generate_downsampler_code.js";
+
+import { HZB_TEXTURE_FORMAT } from "./HZB_TEXTURE_FORMAT.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-pass, eight bytes, read-only: immediate data rather than a uniform buffer. The reduction
+// walks the mip chain a pass at a time and every pass wants a different resolution, which used to
+// mean a persistent table of them bound at a per-mip dynamic offset.
+resources.setImmediate("output_resolution", vec2u);
+
+resources.createGroup()
+    .addTexture("tInput", "unfilterable-float")
+    .addStorageTexture("tOutput", HZB_TEXTURE_FORMAT, "2d", "write-only")
+;
+
+
+/**
+ * Mip1+ reduction pass, works with non-power-of-two resolutions as input
+ * @type {ComputeShader}
+ */
+export const shader_hzb_reduce_any = ComputeShader.from({
+    label: 'HZB / reduce any resolution',
+    body: generate_downsampler_code({
+        type: vec2f,
+        initial_value: 'vec2( 1.0, 0.0 )',
+        //language=WGSL
+        reduction_code: `
+        output.x = min(texel.x, output.x);
+        output.y = max(texel.y, output.y);
+        `,
+    }),
+    resources,
+});

package/src/shade/renderer/hiz/shader_hzb_reduce_mip0.d.ts

@@ -0,0 +1,11 @@
+/**
+ * First reduction: depth of a region of the source (`settings.clip_region`) into the HZB's mip 0, min in
+ * R and max in G. The region is the whole viewport for a camera, and a slot of the atlas for a shadow
+ * map. Each HZB texel reduces every source texel its area overlaps, a footprint of
+ * {@link HZB_FOOTPRINT_X} by {@link HZB_FOOTPRINT_Y} texels at most.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_hzb_reduce_mip0: ComputeShader;
+import { ComputeShader } from "../shader/ComputeShader.js";
+//# sourceMappingURL=shader_hzb_reduce_mip0.d.ts.map

package/src/shade/renderer/hiz/shader_hzb_reduce_mip0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_hzb_reduce_mip0.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/shader_hzb_reduce_mip0.js"],"names":[],"mappings":"AA2GA;;;;;;;GAOG;AACH,qCAFU,aAAa,CAMpB;8BApH2B,4BAA4B"}

package/src/shade/renderer/hiz/{shader_hzb_reduce_mip0_clip.js → shader_hzb_reduce_mip0.js}

@@ -1,111 +1,120 @@
-import { vec2u, vec4u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { HZB_TEXTURE_FORMAT } from "./HZB_TEXTURE_FORMAT.js";
-
-/**
- * Per-pass, 24 bytes, read-only.
- *
- * `clip_region` and `output_resolution` were two uniforms, so two buffers per pass. WGSL allows one
- * immediate per entry point, so carrying them as immediate data means carrying them together.
- *
- * @type {WebGPUStruct}
- */
-const HZB_CLIP_SETTINGS = WebGPUStruct.from({
-    // x, y, width, height
-    clip_region: vec4u,
-    output_resolution: vec2u,
-}, 'HzbClipSettings');
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.setImmediate("settings", HZB_CLIP_SETTINGS);
-
-resources.createGroup()
-    .addTexture("tInput", "unfilterable-float")
-    .addStorageTexture("tOutput", HZB_TEXTURE_FORMAT, "2d", "write-only")
-;
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(16, 16)
-fn main(
-    @builtin(global_invocation_id) global_id: vec3<u32>,
-) {
-    if (any(global_id.xy >= settings.output_resolution)) {
-        return;
-    }
-
-    // 1. Calculate the UV bounds of the current *output* pixel.
-    //    We use the output resolution to determine how wide one pixel is in UV space.
-    let output_resolution_f = vec2<f32>(settings.output_resolution);
-    let uv = (vec2<f32>(global_id.xy) + 0.5) / output_resolution_f;
-    let output_pixel_size2 = 0.5 / output_resolution_f;
-    let uv_min = uv - output_pixel_size2;
-    let uv_max = uv + output_pixel_size2; 
-
-    // minor epsilon to avoid float rounding errors
-    const EPSILON = 1e-6;
-    
-    // Nudge the bounds slightly inward to absorb floating-point drift
-    let safe_uv_min = uv_min + EPSILON;
-    let safe_uv_max = uv_max - EPSILON;
-    
-    // 2. Convert UV bounds to Source Texel coordinates (float).
-    //    We map the 0..1 UVs to the size of the source clip region.
-    let source_size = vec2<f32>(settings.clip_region.zw);
-    let texel_min_f = safe_uv_min * source_size;
-    let texel_max_f = safe_uv_max * source_size;
-
-    // 3. Convert to Integer Loop Bounds.
-    //    Floor the min to find the first pixel.
-    //    Ceil the max to find the exclusive upper bound.
-    //    Example (5px -> 2px):
-    //      Output Px 0 covers UV 0.0-0.5 -> Source 0.0 to 2.5
-    //      Floor(0.0) = 0. Ceil(2.5) = 3. Loop 0, 1, 2. (Pixel 2 is partially covered)
-    //      Output Px 1 covers UV 0.5-1.0 -> Source 2.5 to 5.0
-    //      Floor(2.5) = 2. Ceil(5.0) = 5. Loop 2, 3, 4. (Pixel 2 is partially covered again)
-    let bound_min = vec2<i32>(floor(texel_min_f));
-    let bound_max = vec2<i32>(ceil(texel_max_f));
-
-    // 4. Clamp bounds to the clip region size to be safe.
-    let limit = vec2<i32>(settings.clip_region.zw);
-    
-    let start = max(bound_min, vec2<i32>(0)) + vec2<i32>(settings.clip_region.xy);
-    let end   = min(bound_max, limit) + vec2<i32>(settings.clip_region.xy);
-
-    var output = vec2<f32>(1.0, 0.0); // Initialize min/max
-
-    // 5. Loop. Note strict usage of < end (exclusive) and i32 types.
-    for (var y = start.y; y < end.y; y++) {
-        for (var x = start.x; x < end.x; x++) {
-            
-            // Add the clip region offset (atlas support)
-            let load_coord = vec2<i32>(x, y);
-
-            let v = textureLoad(tInput, load_coord, 0).r;
-            
-            output.x = min(output.x, v);
-            output.y = max(output.y, v);
-        }
-    }
-    
-    textureStore(tOutput, vec2<i32>(global_id.xy), vec4<f32>(output, 0.0, 0.0));
-}
-    `, [
-    ]
-)
-
-/**
- * Same as standard first mip reduction, but with a clipping region.
- * Primarily used for shadow maps where shadows are atlased into a single texture
- * @type {ComputeShader}
- */
-export const shader_hzb_reduce_mip0_clip = ComputeShader.from({
-    label: 'HZB / reduce mip0 with clip',
-    resources,
-    body,
-});
+import { vec2u, vec4u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_hzb_footprint_x } from "./chunk_hzb_footprint_x.js";
+import { chunk_hzb_footprint_y } from "./chunk_hzb_footprint_y.js";
+import { HZB_TEXTURE_FORMAT } from "./HZB_TEXTURE_FORMAT.js";
+
+/**
+ * Per-pass, 24 bytes, read-only.
+ *
+ * `clip_region` and `output_resolution` were two uniforms, so two buffers per pass. WGSL allows one
+ * immediate per entry point, so carrying them as immediate data means carrying them together.
+ *
+ * @type {WebGPUStruct}
+ */
+const HZB_CLIP_SETTINGS = WebGPUStruct.from({
+    // x, y, width, height
+    clip_region: vec4u,
+    output_resolution: vec2u,
+}, 'HzbClipSettings');
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", HZB_CLIP_SETTINGS);
+
+resources.createGroup()
+    .addTexture("tInput", "unfilterable-float")
+    .addStorageTexture("tOutput", HZB_TEXTURE_FORMAT, "2d", "write-only")
+;
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(16, 16)
+fn main(
+    @builtin(global_invocation_id) global_id: vec3<u32>,
+) {
+    if (any(global_id.xy >= settings.output_resolution)) {
+        return;
+    }
+
+    // 1. Calculate the UV bounds of the current *output* pixel.
+    //    We use the output resolution to determine how wide one pixel is in UV space.
+    let output_resolution_f = vec2<f32>(settings.output_resolution);
+    let uv = (vec2<f32>(global_id.xy) + 0.5) / output_resolution_f;
+    let output_pixel_size2 = 0.5 / output_resolution_f;
+    let uv_min = uv - output_pixel_size2;
+    let uv_max = uv + output_pixel_size2;
+
+    // minor epsilon to avoid float rounding errors
+    const EPSILON = 1e-6;
+
+    // Nudge the bounds slightly inward to absorb floating-point drift
+    let safe_uv_min = uv_min + EPSILON;
+    let safe_uv_max = uv_max - EPSILON;
+
+    // 2. Convert UV bounds to Source Texel coordinates (float).
+    //    We map the 0..1 UVs to the size of the source clip region.
+    let source_size = vec2<f32>(settings.clip_region.zw);
+    let texel_min_f = safe_uv_min * source_size;
+    let texel_max_f = safe_uv_max * source_size;
+
+    // 3. Convert to Integer Bounds.
+    //    Floor the min to find the first pixel.
+    //    Ceil the max to find the exclusive upper bound.
+    //    Example (5px -> 2px):
+    //      Output Px 0 covers UV 0.0-0.5 -> Source 0.0 to 2.5
+    //      Floor(0.0) = 0. Ceil(2.5) = 3. Pixels 0, 1, 2. (Pixel 2 is partially covered)
+    //      Output Px 1 covers UV 0.5-1.0 -> Source 2.5 to 5.0
+    //      Floor(2.5) = 2. Ceil(5.0) = 5. Pixels 2, 3, 4. (Pixel 2 is partially covered again)
+    let bound_min = vec2<i32>(floor(texel_min_f));
+    let bound_max = vec2<i32>(ceil(texel_max_f));
+
+    // 4. Clamp bounds to the clip region size to be safe.
+    let limit = vec2<i32>(settings.clip_region.zw);
+
+    let start = max(bound_min, vec2<i32>(0)) + vec2<i32>(settings.clip_region.xy);
+    let end   = min(bound_max, limit) + vec2<i32>(settings.clip_region.xy);
+
+    // 5. Read the footprint, HZB_FOOTPRINT_X by HZB_FOOTPRINT_Y texels: the widest footprint of this
+    //    dispatch on each axis. A narrower one repeats its last texel, which min/max ignores.
+    let last = end - vec2<i32>(1);
+
+    var output = vec2<f32>(1.0, 0.0); // Initialize min/max
+
+    for (var j = 0; j < HZB_FOOTPRINT_Y; j++) {
+        for (var i = 0; i < HZB_FOOTPRINT_X; i++) {
+
+            let load_coord = min(start + vec2<i32>(i, j), last);
+
+            let v = textureLoad(tInput, load_coord, 0).r;
+
+            output.x = min(output.x, v);
+            output.y = max(output.y, v);
+        }
+    }
+
+    textureStore(tOutput, vec2<i32>(global_id.xy), vec4<f32>(output, 0.0, 0.0));
+}
+    `, [
+        chunk_hzb_footprint_x,
+        chunk_hzb_footprint_y,
+    ]
+)
+
+/**
+ * First reduction: depth of a region of the source (`settings.clip_region`) into the HZB's mip 0, min in
+ * R and max in G. The region is the whole viewport for a camera, and a slot of the atlas for a shadow
+ * map. Each HZB texel reduces every source texel its area overlaps, a footprint of
+ * {@link HZB_FOOTPRINT_X} by {@link HZB_FOOTPRINT_Y} texels at most.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_hzb_reduce_mip0 = ComputeShader.from({
+    label: 'HZB / reduce mip0',
+    resources,
+    body,
+});

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

@@ -0,0 +1,39 @@
+/**
+ * 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: number): {
+    blurred_size: number;
+    average_first: boolean;
+    sigma: number;
+    radius: number;
+    lobe_roughness: number;
+};
+/**
+ * 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: number;
+//# sourceMappingURL=environment_level_1_blur_plan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"environment_level_1_blur_plan.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/environment_level_1_blur_plan.js"],"names":[],"mappings":"AA+CA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wDAVW,MAAM,GACJ;IACZ,YAAgB,EAAE,MAAM,CAAC;IACzB,aAAiB,EAAE,OAAO,CAAC;IAC3B,KAAS,EAAE,MAAM,CAAC;IAClB,MAAU,EAAE,MAAM,CAAC;IACnB,cAAkB,EAAE,MAAM,CAAC;CACxB,CAmDH;AAjHD;;;;;;GAMG;AACH,mCAFU,MAAM,CAEwB"}