@woosh/meep-engine 3.60.4 → 3.60.6

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

@@ -1,350 +1,405 @@
-import { assert } from "../../../core/assert.js";
-import { max2 } from "../../../core/math/max2.js";
-import { round_up } from "../../../core/math/round_up.js";
-import { TextureDescriptor } from "../../descriptor/texture/TextureDescriptor.js";
-import { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
-import { texture_mip_level_count } from "../../util/texture_mip_extent.js";
-import { hzb_pick_alignment } from "./hzb_pick_alignment.js";
-import { hzb_plan_reduction_steps } from "./hzb_plan_reduction_steps.js";
-import { HZB_TEXTURE_FORMAT } from "./HZB_TEXTURE_FORMAT.js";
-import { shader_hzb_reduce_any, shader_hzb_reduce_mip0 } from "./shader_hzb_reduce_any.js";
-import { shader_hzb_reduce_mip0_clip } from "./shader_hzb_reduce_mip0_clip.js";
-import { shader_hzb_spd_2, shader_hzb_spd_3, shader_hzb_spd_4 } from "./shader_hzb_spd.js";
-
-/**
- * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
- * @typedef {import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
- * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
- * @typedef {import("../texture/GPUTextureContext.js").GPUTextureContext} GPUTextureContext
- * @typedef {import("./hzb_plan_reduction_steps.js").HZBReductionStep} HZBReductionStep
- */
-
-export class HierarchicalZBuffer {
-
-    /**
-     * @type {GPUTextureContext}
-     */
-    #texture;
-
-    /**
-     * @type {string|GPUTextureFormat}
-     */
-    #format = HZB_TEXTURE_FORMAT
-
-    /**
-     * Precomputed reduction schedule from mip 0 to the 1x1 tail for the current HZB dimensions.
-     * @type {HZBReductionStep[]}
-     */
-    #steps = [];
-
-    /**
-     * Offer the pipelines {@link build} dispatches — see {@link PipelineEnquiry}.
-     *
-     * @param {PipelineEnquiry} enquiry
-     */
-    static enquirePipelines(enquiry) {
-        enquiry.compute.push(
-            shader_hzb_reduce_mip0.pipeline,
-            shader_hzb_reduce_mip0_clip.pipeline,
-            shader_hzb_reduce_any.pipeline,
-            shader_hzb_spd_2.pipeline,
-            shader_hzb_spd_3.pipeline,
-            shader_hzb_spd_4.pipeline,
-        );
-    }
-
-    /**
-     *
-     * @returns {GPUTextureContext}
-     */
-    get texture() {
-        return this.#texture;
-    }
-
-
-    /**
-     * @type {GraphicsContext}
-     */
-    #graphics;
-
-    /**
-     *
-     * @type {number[]}
-     */
-    #viewport_size = [1, 1];
-
-    /**
-     *
-     * @param {GraphicsContext} graphics
-     */
-    constructor(graphics) {
-        this.#graphics = graphics;
-
-        this.#texture = graphics.textures.contextFromDescriptor(TextureDescriptor.from({
-            label: "Hierarchical Z Buffer",
-            format: this.#format,
-            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING,
-            mipLevelCount: 1,
-            size: [1, 1]
-        }));
-
-
-    }
-
-    /**
-     * @param {number} mip
-     * @returns {GPUTextureView}
-     */
-    #obtain_mip_view(mip) {
-        return this.#texture.obtainView(TextureViewDescriptor.from({
-            baseMipLevel: mip,
-            mipLevelCount: 1,
-            dimension: "2d",
-            baseArrayLayer: 0,
-            arrayLayerCount: 1
-        }));
-    }
-
-    /**
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {GPUTextureContext} source
-     * @param {number[]} [source_offset] [x0,y0]
-     */
-    build(
-        encoder,
-        source,
-        source_offset
-    ) {
-
-        assert.defined(encoder, 'encoder');
-        assert.notNull(encoder, 'encoder');
-        assert.equal(encoder.isGPUCommandContext, true, 'encoder is not a GPUCommandContext')
-
-        assert.defined(source, 'source');
-        assert.notNull(source, 'source');
-        assert.equal(source.isGPUTextureContext, true, 'source is not a GPUTextureContext')
-
-        // the first pass is special, we need to read from source texture and write to first mip level of hzb
-
-        const texture = this.#texture;
-
-        assert.equal(texture.isDestroyed, false, 'texture is destroyed');
-
-        let source_view = source.obtainView(TextureViewDescriptor.from({
-            baseMipLevel: 0,
-            mipLevelCount: 1,
-            dimension: "2d",
-            baseArrayLayer: 0,
-            arrayLayerCount: 1
-        }));
-
-        const destination_view = this.#obtain_mip_view(0);
-
-        const viewport_size = this.#viewport_size;
-
-        const is_clipped_variant = source_offset !== undefined
-            && (
-                (
-                    source_offset[0] !== 0
-                    || source_offset[1] !== 0
-                )
-                || (
-                    viewport_size[0] !== source.width
-                    || viewport_size[1] !== source.height
-                )
-            );
-
-        if (is_clipped_variant) {
-            // special case for clip region
-            const mip0_resolution = this.#mip_resolution(0);
-
-            shader_hzb_reduce_mip0_clip.dispatchThreads({
-                encoder,
-                bindings: {
-                    tInput: source_view,
-                    tOutput: destination_view,
-                    settings: {
-                        clip_region: [
-                            source_offset[0], source_offset[1],
-                            viewport_size[0], viewport_size[1],
-                        ],
-                        output_resolution: mip0_resolution,
-                    },
-                },
-                thread_count_x: mip0_resolution[0],
-                thread_count_y: mip0_resolution[1],
-            });
-        } else {
-
-            this.#do_reduction_pass(encoder, shader_hzb_reduce_mip0, source_view, destination_view, 0);
-        }
-
-        source_view = destination_view;
-
-        const steps = this.#steps;
-        const step_count = steps.length;
-
-        for (let s = 0; s < step_count; s++) {
-            const { base_mip, mip_count } = steps[s];
-
-            if (mip_count === 1) {
-                const target_mip = base_mip + 1;
-                const out_view = this.#obtain_mip_view(target_mip);
-
-                this.#do_reduction_pass(encoder, shader_hzb_reduce_any, source_view, out_view, target_mip);
-
-                source_view = out_view;
-            } else {
-                const out1 = this.#obtain_mip_view(base_mip + 1);
-                const out2 = this.#obtain_mip_view(base_mip + 2);
-                const out1_res = this.#mip_resolution(base_mip + 1);
-                const group_count_x = (out1_res[0] + 15) >>> 4;
-                const group_count_y = (out1_res[1] + 15) >>> 4;
-
-                if (mip_count === 2) {
-                    shader_hzb_spd_2.dispatch({
-                        encoder,
-                        bindings: { tInput: source_view, tOut1: out1, tOut2: out2 },
-                        group_count_x,
-                        group_count_y,
-                    });
-                    source_view = out2;
-                } else if (mip_count === 3) {
-                    const out3 = this.#obtain_mip_view(base_mip + 3);
-                    shader_hzb_spd_3.dispatch({
-                        encoder,
-                        bindings: { tInput: source_view, tOut1: out1, tOut2: out2, tOut3: out3 },
-                        group_count_x,
-                        group_count_y,
-                    });
-                    source_view = out3;
-                } else {
-                    const out3 = this.#obtain_mip_view(base_mip + 3);
-                    const out4 = this.#obtain_mip_view(base_mip + 4);
-                    shader_hzb_spd_4.dispatch({
-                        encoder,
-                        bindings: { tInput: source_view, tOut1: out1, tOut2: out2, tOut3: out3, tOut4: out4 },
-                        group_count_x,
-                        group_count_y,
-                    });
-                    source_view = out4;
-                }
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {ComputeShader} shader
-     * @param {GPUTextureView} source_view
-     * @param {GPUTextureView} destination_view
-     * @param {number} index
-     */
-    #do_reduction_pass(
-        encoder,
-        shader,
-        source_view,
-        destination_view,
-        index
-    ) {
-        const output_resolution = this.#mip_resolution(index);
-
-        shader.dispatchThreads({
-            encoder,
-            bindings: {
-                tInput: source_view,
-                tOutput: destination_view,
-                output_resolution,
-            },
-            thread_count_x: output_resolution[0],
-            thread_count_y: output_resolution[1],
-        });
-
-    }
-
-    /**
-     * Scratch for {@link #mip_resolution}. The value is serialised into the pass's immediate bytes
-     * before the next call, so one array can serve every mip.
-     *
-     * @type {number[]}
-     */
-    #mip_resolution_scratch = [1, 1];
-
-    /**
-     * Size of mip `index` of the HZB, which is what the reduction pass writing into it needs to know.
-     *
-     * Each mip halves the one above it, floored at one texel — the same walk that used to be
-     * precomputed into a uniform buffer of every mip's resolution and bound at a per-mip dynamic
-     * offset. As immediate data there is nothing to precompute into.
-     *
-     * @param {number} index
-     * @returns {number[]}
-     */
-    #mip_resolution(index) {
-        const size = this.#texture.size;
-
-        const out = this.#mip_resolution_scratch;
-
-        out[0] = max2(1, size[0] >>> index);
-        out[1] = max2(1, size[1] >>> index);
-
-        return out;
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     */
-    setViewportSize(x, y) {
-        assert.isNonNegativeInteger(x, 'x');
-        assert.isNonNegativeInteger(y, 'y');
-
-        this.#viewport_size[0] = x;
-        this.#viewport_size[1] = y;
-
-        const base_w = Math.max(x >>> 1, 1);
-        const base_h = Math.max(y >>> 1, 1);
-
-        const [align_w, align_h] = hzb_pick_alignment(x, y, 1.05);
-
-        const hzb_w = round_up(base_w, align_w);
-        const hzb_h = round_up(base_h, align_h);
-
-        this.#resize(hzb_w, hzb_h);
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     */
-    #resize(
-        x,
-        y
-    ) {
-
-        const texture = this.#texture;
-        const size = texture.size;
-
-        if (size[0] === x && size[1] === y) {
-            // no size change
-            return;
-        }
-
-        // a screen-space depth pyramid, 2D always
-        const mip_count = texture_mip_level_count(x, y, 1, "2d");
-
-        texture.descriptor.mipLevelCount = mip_count;
-
-        texture.resize(x, y);
-
-        this.#steps = hzb_plan_reduction_steps(x, y);
-    }
-
-    destroy() {
-        this.#texture.destroy();
-    }
-}
+import { assert } from "../../../core/assert.js";
+import { max2 } from "../../../core/math/max2.js";
+import { round_up } from "../../../core/math/round_up.js";
+import { TextureDescriptor } from "../../descriptor/texture/TextureDescriptor.js";
+import { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
+import { texture_mip_level_count } from "../../util/texture_mip_extent.js";
+import { ShaderSwitchSet } from "../shader/compiler/ShaderSwitchSet.js";
+import { HZB_FOOTPRINT_X } from "./HZB_FOOTPRINT_X.js";
+import { HZB_FOOTPRINT_Y } from "./HZB_FOOTPRINT_Y.js";
+import { HZBFootprint } from "./HZBFootprint.js";
+import { hzb_footprint_texels } from "./hzb_footprint_texels.js";
+import { hzb_pick_alignment } from "./hzb_pick_alignment.js";
+import { hzb_plan_reduction_steps } from "./hzb_plan_reduction_steps.js";
+import { HZB_TEXTURE_FORMAT } from "./HZB_TEXTURE_FORMAT.js";
+import { shader_hzb_reduce_any } from "./shader_hzb_reduce_any.js";
+import { shader_hzb_reduce_mip0 } from "./shader_hzb_reduce_mip0.js";
+import { shader_hzb_spd_2, shader_hzb_spd_3, shader_hzb_spd_4 } from "./shader_hzb_spd.js";
+
+/**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ * @typedef {import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
+ * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
+ * @typedef {import("../texture/GPUTextureContext.js").GPUTextureContext} GPUTextureContext
+ * @typedef {import("./hzb_plan_reduction_steps.js").HZBReductionStep} HZBReductionStep
+ */
+
+/**
+ * Every footprint mip 0 can be reduced with, 2x2, 3x2, 2x3 and 3x3.
+ * @type {ShaderSwitchSet[]}
+ */
+const MIP0_FOOTPRINTS = [
+    ShaderSwitchSet.EMPTY,
+    ShaderSwitchSet.EMPTY.with(HZB_FOOTPRINT_X, HZBFootprint.Three),
+    ShaderSwitchSet.EMPTY.with(HZB_FOOTPRINT_Y, HZBFootprint.Three),
+    ShaderSwitchSet.EMPTY.with(HZB_FOOTPRINT_X, HZBFootprint.Three).with(HZB_FOOTPRINT_Y, HZBFootprint.Three),
+];
+
+/**
+ * The footprint mip 0 is reduced with along one axis: the widest of any of its texels.
+ *
+ * @param {number} source_size viewport texels on the axis
+ * @param {number} output_size mip 0 texels on the axis
+ * @returns {HZBFootprint}
+ */
+function mip0_footprint(source_size, output_size) {
+    const texels = hzb_footprint_texels(source_size, output_size);
+
+    // mip 0 is never smaller than half the viewport, which keeps every footprint within 3
+    assert.lessThanOrEqual(texels, 3, `footprint of ${output_size} HZB texels over ${source_size}`);
+
+    return texels <= 2 ? HZBFootprint.Two : HZBFootprint.Three;
+}
+
+export class HierarchicalZBuffer {
+
+    /**
+     * @type {GPUTextureContext}
+     */
+    #texture;
+
+    /**
+     * @type {string|GPUTextureFormat}
+     */
+    #format = HZB_TEXTURE_FORMAT
+
+    /**
+     * Precomputed reduction schedule from mip 0 to the 1x1 tail for the current HZB dimensions.
+     * @type {HZBReductionStep[]}
+     */
+    #steps = [];
+
+    /**
+     * The footprint mip 0 is reduced with, for the current viewport and mip 0 size.
+     * @type {ShaderSwitchSet}
+     */
+    #mip0_footprint = ShaderSwitchSet.EMPTY;
+
+    /**
+     * Scratch for mip 0's immediates, serialised into the pass's immediate bytes before the next build,
+     * as {@link #mip_resolution_scratch} is.
+     *
+     * @type {{clip_region: number[], output_resolution: number[]}}
+     */
+    #mip0_settings = { clip_region: [0, 0, 1, 1], output_resolution: [1, 1] };
+
+    /**
+     * Offer the pipelines {@link build} dispatches — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        for (let i = 0; i < MIP0_FOOTPRINTS.length; i++) {
+            enquiry.compute.push(shader_hzb_reduce_mip0.variant(MIP0_FOOTPRINTS[i]).pipeline);
+        }
+
+        enquiry.compute.push(
+            shader_hzb_reduce_any.pipeline,
+            shader_hzb_spd_2.pipeline,
+            shader_hzb_spd_3.pipeline,
+            shader_hzb_spd_4.pipeline,
+        );
+    }
+
+    /**
+     *
+     * @returns {GPUTextureContext}
+     */
+    get texture() {
+        return this.#texture;
+    }
+
+
+    /**
+     * @type {GraphicsContext}
+     */
+    #graphics;
+
+    /**
+     *
+     * @type {number[]}
+     */
+    #viewport_size = [1, 1];
+
+    /**
+     *
+     * @param {GraphicsContext} graphics
+     */
+    constructor(graphics) {
+        this.#graphics = graphics;
+
+        this.#texture = graphics.textures.contextFromDescriptor(TextureDescriptor.from({
+            label: "Hierarchical Z Buffer",
+            format: this.#format,
+            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.STORAGE_BINDING,
+            mipLevelCount: 1,
+            size: [1, 1]
+        }));
+
+
+    }
+
+    /**
+     * @param {number} mip
+     * @returns {GPUTextureView}
+     */
+    #obtain_mip_view(mip) {
+        return this.#texture.obtainView(TextureViewDescriptor.from({
+            baseMipLevel: mip,
+            mipLevelCount: 1,
+            dimension: "2d",
+            baseArrayLayer: 0,
+            arrayLayerCount: 1
+        }));
+    }
+
+    /**
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {GPUTextureContext} source
+     * @param {number[]} [source_offset] [x0,y0]
+     */
+    build(
+        encoder,
+        source,
+        source_offset
+    ) {
+
+        assert.defined(encoder, 'encoder');
+        assert.notNull(encoder, 'encoder');
+        assert.equal(encoder.isGPUCommandContext, true, 'encoder is not a GPUCommandContext')
+
+        assert.defined(source, 'source');
+        assert.notNull(source, 'source');
+        assert.equal(source.isGPUTextureContext, true, 'source is not a GPUTextureContext')
+
+        // the first pass is special, we need to read from source texture and write to first mip level of hzb
+
+        const texture = this.#texture;
+
+        assert.equal(texture.isDestroyed, false, 'texture is destroyed');
+
+        let source_view = source.obtainView(TextureViewDescriptor.from({
+            baseMipLevel: 0,
+            mipLevelCount: 1,
+            dimension: "2d",
+            baseArrayLayer: 0,
+            arrayLayerCount: 1
+        }));
+
+        const destination_view = this.#obtain_mip_view(0);
+
+        const viewport_size = this.#viewport_size;
+
+        // the viewport's region of the source: all of it for a camera, a slot of the atlas for a shadow map
+        const region_x = source_offset !== undefined ? source_offset[0] : 0;
+        const region_y = source_offset !== undefined ? source_offset[1] : 0;
+
+        assert.lessThanOrEqual(region_x + viewport_size[0], source.width, 'viewport region past the source\'s width');
+        assert.lessThanOrEqual(region_y + viewport_size[1], source.height, 'viewport region past the source\'s height');
+
+        const mip0_resolution = this.#mip_resolution(0);
+
+        const settings = this.#mip0_settings;
+        const clip_region = settings.clip_region;
+
+        clip_region[0] = region_x;
+        clip_region[1] = region_y;
+        clip_region[2] = viewport_size[0];
+        clip_region[3] = viewport_size[1];
+
+        settings.output_resolution = mip0_resolution;
+
+        shader_hzb_reduce_mip0.variant(this.#mip0_footprint).dispatchThreads({
+            encoder,
+            bindings: {
+                tInput: source_view,
+                tOutput: destination_view,
+                settings,
+            },
+            thread_count_x: mip0_resolution[0],
+            thread_count_y: mip0_resolution[1],
+        });
+
+        source_view = destination_view;
+
+        const steps = this.#steps;
+        const step_count = steps.length;
+
+        for (let s = 0; s < step_count; s++) {
+            const { base_mip, mip_count } = steps[s];
+
+            if (mip_count === 1) {
+                const target_mip = base_mip + 1;
+                const out_view = this.#obtain_mip_view(target_mip);
+
+                this.#do_reduction_pass(encoder, shader_hzb_reduce_any, source_view, out_view, target_mip);
+
+                source_view = out_view;
+            } else {
+                const out1 = this.#obtain_mip_view(base_mip + 1);
+                const out2 = this.#obtain_mip_view(base_mip + 2);
+                const out1_res = this.#mip_resolution(base_mip + 1);
+                const group_count_x = (out1_res[0] + 15) >>> 4;
+                const group_count_y = (out1_res[1] + 15) >>> 4;
+
+                if (mip_count === 2) {
+                    shader_hzb_spd_2.dispatch({
+                        encoder,
+                        bindings: { tInput: source_view, tOut1: out1, tOut2: out2 },
+                        group_count_x,
+                        group_count_y,
+                    });
+                    source_view = out2;
+                } else if (mip_count === 3) {
+                    const out3 = this.#obtain_mip_view(base_mip + 3);
+                    shader_hzb_spd_3.dispatch({
+                        encoder,
+                        bindings: { tInput: source_view, tOut1: out1, tOut2: out2, tOut3: out3 },
+                        group_count_x,
+                        group_count_y,
+                    });
+                    source_view = out3;
+                } else {
+                    const out3 = this.#obtain_mip_view(base_mip + 3);
+                    const out4 = this.#obtain_mip_view(base_mip + 4);
+                    shader_hzb_spd_4.dispatch({
+                        encoder,
+                        bindings: { tInput: source_view, tOut1: out1, tOut2: out2, tOut3: out3, tOut4: out4 },
+                        group_count_x,
+                        group_count_y,
+                    });
+                    source_view = out4;
+                }
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {ComputeShader} shader
+     * @param {GPUTextureView} source_view
+     * @param {GPUTextureView} destination_view
+     * @param {number} index
+     */
+    #do_reduction_pass(
+        encoder,
+        shader,
+        source_view,
+        destination_view,
+        index
+    ) {
+        const output_resolution = this.#mip_resolution(index);
+
+        shader.dispatchThreads({
+            encoder,
+            bindings: {
+                tInput: source_view,
+                tOutput: destination_view,
+                output_resolution,
+            },
+            thread_count_x: output_resolution[0],
+            thread_count_y: output_resolution[1],
+        });
+
+    }
+
+    /**
+     * Scratch for {@link #mip_resolution}. The value is serialised into the pass's immediate bytes
+     * before the next call, so one array can serve every mip.
+     *
+     * @type {number[]}
+     */
+    #mip_resolution_scratch = [1, 1];
+
+    /**
+     * Size of mip `index` of the HZB, which is what the reduction pass writing into it needs to know.
+     *
+     * Each mip halves the one above it, floored at one texel — the same walk that used to be
+     * precomputed into a uniform buffer of every mip's resolution and bound at a per-mip dynamic
+     * offset. As immediate data there is nothing to precompute into.
+     *
+     * @param {number} index
+     * @returns {number[]}
+     */
+    #mip_resolution(index) {
+        const size = this.#texture.size;
+
+        const out = this.#mip_resolution_scratch;
+
+        out[0] = max2(1, size[0] >>> index);
+        out[1] = max2(1, size[1] >>> index);
+
+        return out;
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     */
+    setViewportSize(x, y) {
+        assert.isNonNegativeInteger(x, 'x');
+        assert.isNonNegativeInteger(y, 'y');
+        // an empty viewport has no depth to reduce, and mip 0 clamps its reads to a region it would not have
+        assert.greaterThan(x, 0, 'x');
+        assert.greaterThan(y, 0, 'y');
+
+        const viewport_size = this.#viewport_size;
+
+        if (viewport_size[0] === x && viewport_size[1] === y) {
+            // no size change; a shadow map's view is resized every frame
+            return;
+        }
+
+        viewport_size[0] = x;
+        viewport_size[1] = y;
+
+        const base_w = Math.max(x >>> 1, 1);
+        const base_h = Math.max(y >>> 1, 1);
+
+        const [align_w, align_h] = hzb_pick_alignment(x, y, 1.05);
+
+        const hzb_w = round_up(base_w, align_w);
+        const hzb_h = round_up(base_h, align_h);
+
+        this.#resize(hzb_w, hzb_h);
+
+        this.#mip0_footprint = ShaderSwitchSet.EMPTY
+            .with(HZB_FOOTPRINT_X, mip0_footprint(x, hzb_w))
+            .with(HZB_FOOTPRINT_Y, mip0_footprint(y, hzb_h));
+    }
+
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     */
+    #resize(
+        x,
+        y
+    ) {
+
+        const texture = this.#texture;
+        const size = texture.size;
+
+        if (size[0] === x && size[1] === y) {
+            // no size change
+            return;
+        }
+
+        // a screen-space depth pyramid, 2D always
+        const mip_count = texture_mip_level_count(x, y, 1, "2d");
+
+        texture.descriptor.mipLevelCount = mip_count;
+
+        texture.resize(x, y);
+
+        this.#steps = hzb_plan_reduction_steps(x, y);
+    }
+
+    destroy() {
+        this.#texture.destroy();
+    }
+}