@woosh/meep-engine 3.52.0 → 3.54.0

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

@@ -1,100 +1,99 @@
-import { assert } from "../../../core/assert.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-
-/**
- * Idea is to down-sample any kind of texture.
- * Somewhat inspired by AMD's FSR single-pass-downsampler.
- * At present, it is impossible to implement a single-pass downsampler in WebGPU, because you can't bind multiple mips of a storage texture in compute shader.
- *
- * @example
- *  const min = generate_downsampler_code({
- *      type: f32,
- *      initial_value: "1e10"
- *      reduction_code: "output = min( texel.r, output );"
- *  });
- *
- * @param {Object} options
- * @param {WebGPUType} options.type
- * @param {string} options.reduction_code
- * @param {string} options.initial_value
- * @param {CodeChunk[]} [options.dependencies] Additional dependencies, referenced in the reduction code
- * @return {CodeChunk}
- */
-export function generate_downsampler_code({
-                                              type,
-                                              reduction_code,
-                                              initial_value,
-                                              dependencies = [],
-                                          }) {
-
-    assert.isString(initial_value, 'initial_value');
-    assert.isString(reduction_code, 'reduction_code');
-    assert.isArray(dependencies, 'dependencies');
-
-    assert.defined(type, 'type');
-    assert.equal(type.isWebGPUType, true, 'type must be a WebGPUType');
-
-    const deps = [
-        ...dependencies,
-    ];
-
-    if (type.requires_declaration) {
-        deps.push(type.declaration_chunk);
-    }
-
-    // NOTE this code doesn't work when downsampling a portion of image (using setViewport)
-    //      the issue is reliance on `source_resolution` which is the entire source image, not just the portion we're downsampling
-
-    return CodeChunk.from(
-        //language=WGSL
-        `
-@fragment
-fn main(
-    @builtin(position) coord: vec4<f32>,
-    @location(0) uv: vec2<f32>,
-) -> @location(0) ${type.wgsl_ref} {
-    let output_texel_size2 = 0.5 / vec2<f32>(output_resolution);
-    
-    
-    // texel bounds ins in UV space
-    let uv_min = uv - output_texel_size2;
-    let uv_max = uv + output_texel_size2; 
-                                
-    // compute bounds in source texture
-    let source_resolution = textureDimensions(tInput);
-    let source_resolution_f = vec2<f32>(source_resolution);
-    
-    // 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;
-
-    let source_bounds_min = max(
-        vec2<i32>( floor( safe_uv_min * source_resolution_f ) ),
-        vec2<i32>( 0 ),
-    );
-    let source_bounds_max = min(
-        vec2<i32>( ceil( safe_uv_max * source_resolution_f ) ),
-        vec2<i32>( source_resolution - 1 ),
-    );
-    
-    var output:${type.wgsl_ref} = ${initial_value};
-    
-    for( var y = source_bounds_min.y; y <= source_bounds_max.y; y++ ){
-        for( var x = source_bounds_min.x; x <= source_bounds_max.x; x++ ){
-        
-            let texel = textureLoad(tInput, vec2<i32>(x,y), 0);
-           
-            // output will be written using the snippet below
-            ${reduction_code}
-            
-        }
-    }
-    
-    return output;
-}
-`, deps);
-
-}
+import { assert } from "../../../core/assert.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+
+/**
+ * Idea is to down-sample any kind of texture.
+ *
+ * @example
+ *  const min = generate_downsampler_code({
+ *      type: f32,
+ *      initial_value: "1e10"
+ *      reduction_code: "output = min( texel.r, output );"
+ *  });
+ *
+ * @param {Object} options
+ * @param {WebGPUType} options.type
+ * @param {string} options.reduction_code
+ * @param {string} options.initial_value
+ * @param {CodeChunk[]} [options.dependencies] Additional dependencies, referenced in the reduction code
+ * @return {CodeChunk}
+ */
+export function generate_downsampler_code({
+                                              type,
+                                              reduction_code,
+                                              initial_value,
+                                              dependencies = [],
+                                          }) {
+
+    assert.isString(initial_value, 'initial_value');
+    assert.isString(reduction_code, 'reduction_code');
+    assert.isArray(dependencies, 'dependencies');
+
+    assert.defined(type, 'type');
+    assert.equal(type.isWebGPUType, true, 'type must be a WebGPUType');
+
+    const deps = [
+        ...dependencies,
+    ];
+
+    if (type.requires_declaration) {
+        deps.push(type.declaration_chunk);
+    }
+
+    return CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(8, 8, 1)
+fn main(
+    @builtin(global_invocation_id) global_id: vec3<u32>,
+) {
+    if (any(global_id.xy >= output_resolution)) {
+        return;
+    }
+
+    let output_resolution_f = vec2<f32>(output_resolution);
+    let uv = (vec2<f32>(global_id.xy) + 0.5) / output_resolution_f;
+    let output_texel_size2 = 0.5 / output_resolution_f;
+    
+    // texel bounds in UV space
+    let uv_min = uv - output_texel_size2;
+    let uv_max = uv + output_texel_size2; 
+                                
+    // compute bounds in source texture
+    let source_resolution = textureDimensions(tInput);
+    let source_resolution_f = vec2<f32>(source_resolution);
+    
+    // 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;
+
+    let source_bounds_min = max(
+        vec2<i32>( floor( safe_uv_min * source_resolution_f ) ),
+        vec2<i32>( 0 ),
+    );
+    let source_bounds_max = min(
+        vec2<i32>( ceil( safe_uv_max * source_resolution_f ) ),
+        vec2<i32>( source_resolution ),
+    );
+    
+    var output:${type.wgsl_ref} = ${initial_value};
+    
+    for( var y = source_bounds_min.y; y < source_bounds_max.y; y++ ){
+        for( var x = source_bounds_min.x; x < source_bounds_max.x; x++ ){
+        
+            let texel = textureLoad(tInput, vec2<i32>(x,y), 0);
+           
+            // output will be written using the snippet below
+            ${reduction_code}
+            
+        }
+    }
+    
+    textureStore(tOutput, vec2<i32>(global_id.xy), vec4<f32>(output, 0.0, 0.0));
+}
+`, deps);
+
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Picks power-of-two alignments `[align_w, align_h]` for HZB mip 0 within the allowed area bloat.
+ *
+ * Starting from the largest shared power-of-two alignment that fits within `max_bloat`, chases
+ * lowest set bits (`d += d & -d`) along each axis to minimize reduction dispatches, maximize
+ * SPD-covered mips and exact 2:1 (`2x2`) transitions, and push any remaining odd polyphase
+ * transitions to coarser mip levels.
+ *
+ * @param {number} source_w - Source width in pixels.
+ * @param {number} source_h - Source height in pixels.
+ * @param {number} [max_bloat=1.05] - Maximum area multiplier relative to unaligned half-res.
+ * @returns {[number, number]} Power-of-two alignment factors `[align_w, align_h]`.
+ */
+export function hzb_pick_alignment(source_w: number, source_h: number, max_bloat?: number): [number, number];
+//# sourceMappingURL=hzb_pick_alignment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hzb_pick_alignment.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/hzb_pick_alignment.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,6CALW,MAAM,YACN,MAAM,cACN,MAAM,GACJ,CAAC,MAAM,EAAE,MAAM,CAAC,CAoI5B"}

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

@@ -0,0 +1,148 @@
+import { assert } from "../../../core/assert.js";
+import { msb_32 } from "../../../core/binary/msb_32.js";
+import { bitCount } from "../../../core/binary/operations/bitCount.js";
+
+/**
+ * Picks power-of-two alignments `[align_w, align_h]` for HZB mip 0 within the allowed area bloat.
+ *
+ * Starting from the largest shared power-of-two alignment that fits within `max_bloat`, chases
+ * lowest set bits (`d += d & -d`) along each axis to minimize reduction dispatches, maximize
+ * SPD-covered mips and exact 2:1 (`2x2`) transitions, and push any remaining odd polyphase
+ * transitions to coarser mip levels.
+ *
+ * @param {number} source_w - Source width in pixels.
+ * @param {number} source_h - Source height in pixels.
+ * @param {number} [max_bloat=1.05] - Maximum area multiplier relative to unaligned half-res.
+ * @returns {[number, number]} Power-of-two alignment factors `[align_w, align_h]`.
+ */
+export function hzb_pick_alignment(source_w, source_h, max_bloat = 1.05) {
+    assert.greaterThan(max_bloat, 1, 'max_bloat must be greater than 1');
+    assert.isNonNegativeInteger(source_w, 'source_w');
+    assert.isNonNegativeInteger(source_h, 'source_h');
+
+    const half_w = source_w >>> 1;
+    const half_h = source_h >>> 1;
+
+    if (half_w === 0 || half_h === 0) {
+        return [1, 1];
+    }
+
+    const max_area = half_w * half_h * max_bloat;
+
+    let base_align = 1;
+
+    while (base_align < half_w && base_align < half_h) {
+        const next_align = base_align << 1;
+        const mask = next_align - 1;
+
+        const w = (half_w + mask) & ~mask;
+        const h = (half_h + mask) & ~mask;
+
+        if (w * h > max_area) {
+            break;
+        }
+
+        base_align = next_align;
+    }
+
+    const base_mask = base_align - 1;
+    const w0 = (half_w + base_mask) & ~base_mask;
+    const h0 = (half_h + base_mask) & ~base_mask;
+
+    let best_w = w0;
+    let best_h = h0;
+    let best_steps = Infinity;
+    let best_spd_mips = -1;
+    let best_2x2 = -1;
+    let best_odd_axes = Infinity;
+    let best_odd_work = Infinity;
+    let best_area = Infinity;
+
+    for (let w = w0; w * h0 <= max_area; w += (w & -w)) {
+        const msb_w = msb_32(w);
+        const odd_w = w ^ (1 << msb_w);
+
+        for (let h = h0; ; h += (h & -h)) {
+            const area = w * h;
+            if (area > max_area) {
+                break;
+            }
+
+            const msb_h = msb_32(h);
+            const odd_h = h ^ (1 << msb_h);
+            const total_transitions = msb_w > msb_h ? msb_w : msb_h;
+            const odd_any = odd_w | odd_h;
+
+            let steps = 0;
+            let spd_mips = 0;
+            let mip = 0;
+
+            while (mip < total_transitions) {
+                let count = 0;
+                while (count < 4 && (mip + count) < total_transitions && ((odd_any >>> (mip + count)) & 1) === 0) {
+                    count++;
+                }
+                steps++;
+                if (count >= 2) {
+                    spd_mips += count;
+                    mip += count;
+                } else {
+                    mip += 1;
+                }
+            }
+
+            const count_2x2 = total_transitions - bitCount(odd_any);
+            const count_odd_axes = bitCount(odd_w) + bitCount(odd_h);
+
+            let odd_work = 0;
+            let rem = odd_any;
+            while (rem !== 0) {
+                const lsb = rem & -rem;
+                const m = msb_32(lsb);
+                const taps_x = ((odd_w >>> m) & 1) + 2;
+                const taps_y = ((odd_h >>> m) & 1) + 2;
+                const out_w = (w >>> (m + 1)) || 1;
+                const out_h = (h >>> (m + 1)) || 1;
+                odd_work += out_w * out_h * (taps_x * taps_y - 4);
+                rem ^= lsb;
+            }
+
+            const is_better =
+                steps < best_steps ||
+                (steps === best_steps && (
+                    spd_mips > best_spd_mips ||
+                    (spd_mips === best_spd_mips && (
+                        count_2x2 > best_2x2 ||
+                        (count_2x2 === best_2x2 && (
+                            count_odd_axes < best_odd_axes ||
+                            (count_odd_axes === best_odd_axes && (
+                                odd_work < best_odd_work ||
+                                (odd_work === best_odd_work && area < best_area)
+                            ))
+                        ))
+                    ))
+                ));
+
+            if (is_better) {
+                best_w = w;
+                best_h = h;
+                best_steps = steps;
+                best_spd_mips = spd_mips;
+                best_2x2 = count_2x2;
+                best_odd_axes = count_odd_axes;
+                best_odd_work = odd_work;
+                best_area = area;
+            }
+
+            if ((h & (h - 1)) === 0) {
+                break;
+            }
+        }
+
+        if ((w & (w - 1)) === 0) {
+            break;
+        }
+    }
+
+    return [best_w & -best_w, best_h & -best_h];
+}

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

@@ -0,0 +1,28 @@
+/**
+ * @typedef {Object} HZBReductionStep
+ * @property {number} base_mip Source mip level index (0-based).
+ * @property {number} mip_count Number of consecutive mip levels produced in this step (1..4).
+ */
+/**
+ * Plans the sequence of reduction dispatches from HZB mip 0 down to the 1x1 tail.
+ *
+ * Consecutive mip transitions where neither active (> 1) axis is odd halve cleanly by 2x2 and are
+ * coalesced into a single up-to-4-mip SPD dispatch. Any transition from an odd dimension (> 1)
+ * requires the conservative polyphase UV-box kernel (`mip_count = 1`).
+ *
+ * @param {number} width Mip 0 width in texels.
+ * @param {number} height Mip 0 height in texels.
+ * @returns {HZBReductionStep[]}
+ */
+export function hzb_plan_reduction_steps(width: number, height: number): HZBReductionStep[];
+export type HZBReductionStep = {
+    /**
+     * Source mip level index (0-based).
+     */
+    base_mip: number;
+    /**
+     * Number of consecutive mip levels produced in this step (1..4).
+     */
+    mip_count: number;
+};
+//# sourceMappingURL=hzb_plan_reduction_steps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hzb_plan_reduction_steps.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/hzb_plan_reduction_steps.js"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH;;;;;;;;;;GAUG;AACH,gDAJW,MAAM,UACN,MAAM,GACJ,gBAAgB,EAAE,CAuC9B;;;;;cApDa,MAAM;;;;eACN,MAAM"}

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

@@ -0,0 +1,58 @@
+import { assert } from "../../../core/assert.js";
+import { texture_mip_level_count } from "../../util/texture_mip_extent.js";
+
+/**
+ * @typedef {Object} HZBReductionStep
+ * @property {number} base_mip Source mip level index (0-based).
+ * @property {number} mip_count Number of consecutive mip levels produced in this step (1..4).
+ */
+
+/**
+ * Plans the sequence of reduction dispatches from HZB mip 0 down to the 1x1 tail.
+ *
+ * Consecutive mip transitions where neither active (> 1) axis is odd halve cleanly by 2x2 and are
+ * coalesced into a single up-to-4-mip SPD dispatch. Any transition from an odd dimension (> 1)
+ * requires the conservative polyphase UV-box kernel (`mip_count = 1`).
+ *
+ * @param {number} width Mip 0 width in texels.
+ * @param {number} height Mip 0 height in texels.
+ * @returns {HZBReductionStep[]}
+ */
+export function hzb_plan_reduction_steps(width, height) {
+    assert.isPositiveInteger(width, 'width');
+    assert.isPositiveInteger(height, 'height');
+
+    const total_mips = texture_mip_level_count(width, height, 1, "2d");
+
+    /**
+     * @type {HZBReductionStep[]}
+     */
+    const steps = [];
+
+    let mip = 0;
+
+    while (mip < total_mips - 1) {
+        let count = 0;
+
+        while (count < 4 && (mip + count) < total_mips - 1) {
+            const w = Math.max(1, width >>> (mip + count));
+            const h = Math.max(1, height >>> (mip + count));
+
+            if ((w > 1 && (w & 1) !== 0) || (h > 1 && (h & 1) !== 0)) {
+                break;
+            }
+
+            count++;
+        }
+
+        if (count >= 2) {
+            steps.push({ base_mip: mip, mip_count: count });
+            mip += count;
+        } else {
+            steps.push({ base_mip: mip, mip_count: 1 });
+            mip += 1;
+        }
+    }
+
+    return steps;
+}

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

@@ -1,12 +1,12 @@
 /**
  * Initial reduction pass, works with non-power-of-two resolutions as input
- * @type {ImageShader}
+ * @type {ComputeShader}
  */
-export const shader_hzb_reduce_mip0: ImageShader;
+export const shader_hzb_reduce_mip0: ComputeShader;
 /**
  * Mip1+ reduction pass, works with non-power-of-two resolutions as input
- * @type {ImageShader}
+ * @type {ComputeShader}
  */
-export const shader_hzb_reduce_any: ImageShader;
-import { ImageShader } from "../shader/ImageShader.js";
+export const shader_hzb_reduce_any: ComputeShader;
+import { ComputeShader } from "../shader/ComputeShader.js";
 //# sourceMappingURL=shader_hzb_reduce_any.d.ts.map

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,WAAW,CAoBlB;AAGH;;;GAGG;AACH,oCAFU,WAAW,CAmBnB;4BAjE0B,0BAA0B"}
+{"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"}

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

@@ -1,67 +1,57 @@
-import { vec2f, vec2u } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { ImageShader } from "../shader/ImageShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../shader/ShaderDescriptor.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")
-;
-
-
-/**
- * Initial reduction pass, works with non-power-of-two resolutions as input
- * @type {ImageShader}
- */
-export const shader_hzb_reduce_mip0 = new ImageShader({
-    descriptor: ShaderDescriptor.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
-    }),
-    targets: [
-        { format: HZB_TEXTURE_FORMAT }
-    ]
-});
-
-
-/**
- * Mip1+ reduction pass, works with non-power-of-two resolutions as input
- * @type {ImageShader}
- */
-export const shader_hzb_reduce_any = new ImageShader({
-    descriptor: ShaderDescriptor.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
-    }),
-    targets: [
-        { format: HZB_TEXTURE_FORMAT }
-    ]
-})
+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,
+});

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

@@ -1,8 +1,8 @@
 /**
  * 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 {ImageShader}
+ * @type {ComputeShader}
  */
-export const shader_hzb_reduce_mip0_clip: ImageShader;
-import { ImageShader } from "../shader/ImageShader.js";
+export const shader_hzb_reduce_mip0_clip: ComputeShader;
+import { ComputeShader } from "../shader/ComputeShader.js";
 //# sourceMappingURL=shader_hzb_reduce_mip0_clip.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shader_hzb_reduce_mip0_clip.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/shader_hzb_reduce_mip0_clip.js"],"names":[],"mappings":"AAiGA;;;;GAIG;AACH,0CAFU,WAAW,CAWlB;4BA5GyB,0BAA0B"}
+{"version":3,"file":"shader_hzb_reduce_mip0_clip.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/hiz/shader_hzb_reduce_mip0_clip.js"],"names":[],"mappings":"AAqGA;;;;GAIG;AACH,0CAFU,aAAa,CAMpB;8BA3G2B,4BAA4B"}