@woosh/meep-engine 3.47.0 → 3.49.0

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

@@ -1,281 +1,294 @@
-import { assert } from "../../../core/assert.js";
-import { max2 } from "../../../core/math/max2.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_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";
-
-/**
- * @typedef {import("../../device/ShadeGPUCommandContext.js").ShadeGPUCommandContext} ShadeGPUCommandContext
- * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
- * @typedef {import("../texture/GPUTextureContext.js").GPUTextureContext} GPUTextureContext
- */
-
-export class HierarchicalZBuffer {
-
-    /**
-     * @type {GPUTextureContext}
-     */
-    #texture;
-
-    /**
-     * @type {string|GPUTextureFormat}
-     */
-    #format = HZB_TEXTURE_FORMAT
-
-    /**
-     *
-     * @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.RENDER_ATTACHMENT,
-            mipLevelCount: 1,
-            size: [1, 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');
-
-        const mipLevelCount = texture.descriptor.mipLevelCount;
-
-        let source_view = source.obtainView(TextureViewDescriptor.from({
-            baseMipLevel: 0,
-            mipLevelCount: 1,
-            dimension: "2d",
-            baseArrayLayer: 0,
-            arrayLayerCount: 1
-        }));
-
-        const destination_view = texture.obtainView(TextureViewDescriptor.from({
-            baseMipLevel: 0,
-            mipLevelCount: 1,
-            dimension: "2d",
-            baseArrayLayer: 0,
-            arrayLayerCount: 1
-        }));
-
-        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
-
-            shader_hzb_reduce_mip0_clip.draw({
-                encoder,
-                bindings: {
-                    tInput: source_view,
-                    settings: {
-                        clip_region: [
-                            source_offset[0], source_offset[1],
-                            viewport_size[0], viewport_size[1],
-                        ],
-                        output_resolution: this.#mip_resolution(0),
-                    },
-                },
-                colorAttachments: [{
-                    view: destination_view,
-                    loadOp: 'clear',
-                    storeOp: 'store'
-                }]
-            })
-        } else {
-
-            this.#do_reduction_pass(encoder, shader_hzb_reduce_mip0, source_view, destination_view, 0);
-        }
-
-        source_view = destination_view;
-
-        for (let i = 1; i < mipLevelCount; i++) {
-
-            const destination_view = texture.obtainView(TextureViewDescriptor.from({
-                baseMipLevel: i,
-                mipLevelCount: 1,
-                dimension: "2d",
-                baseArrayLayer: 0,
-                arrayLayerCount: 1
-            }));
-
-            this.#do_reduction_pass(encoder, shader_hzb_reduce_any, source_view, destination_view, i);
-
-            // swap
-            source_view = destination_view;
-        }
-    }
-
-    /**
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {ImageShader} shader
-     * @param {GPUTextureView} source_view
-     * @param {GPUTextureView} destination_view
-     * @param {number} index
-     * @param {number[]} [viewport]
-     */
-    #do_reduction_pass(
-        encoder,
-        shader,
-        source_view,
-        destination_view,
-        index,
-        viewport
-    ) {
-
-        shader.draw({
-            encoder,
-            bindings: {
-                tInput: source_view,
-                output_resolution: this.#mip_resolution(index),
-            },
-            colorAttachments: [
-                {
-                    view: destination_view,
-                    loadOp: 'clear',
-                    storeOp: 'store'
-                }
-            ],
-            viewport
-        })
-
-    }
-
-    /**
-     * 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 hzb_w = Math.max(x >>> 1, 1);
-        const hzb_h = Math.max(y >>> 1, 1);
-
-        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);
-    }
-
-    destroy() {
-        this.#texture.destroy();
-    }
-}
+import { assert } from "../../../core/assert.js";
+import { max2 } from "../../../core/math/max2.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_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";
+
+/**
+ * @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
+ */
+
+export class HierarchicalZBuffer {
+
+    /**
+     * @type {GPUTextureContext}
+     */
+    #texture;
+
+    /**
+     * @type {string|GPUTextureFormat}
+     */
+    #format = HZB_TEXTURE_FORMAT
+
+    /**
+     * Offer the pipelines {@link build} draws with — see {@link PipelineEnquiry}. A viewport that
+     * clips part of its source draws mip 0 with {@link shader_hzb_reduce_mip0_clip} instead, which
+     * is left to the frame that does that.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        enquiry.render.push(shader_hzb_reduce_mip0.pipeline);
+        enquiry.render.push(shader_hzb_reduce_any.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.RENDER_ATTACHMENT,
+            mipLevelCount: 1,
+            size: [1, 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');
+
+        const mipLevelCount = texture.descriptor.mipLevelCount;
+
+        let source_view = source.obtainView(TextureViewDescriptor.from({
+            baseMipLevel: 0,
+            mipLevelCount: 1,
+            dimension: "2d",
+            baseArrayLayer: 0,
+            arrayLayerCount: 1
+        }));
+
+        const destination_view = texture.obtainView(TextureViewDescriptor.from({
+            baseMipLevel: 0,
+            mipLevelCount: 1,
+            dimension: "2d",
+            baseArrayLayer: 0,
+            arrayLayerCount: 1
+        }));
+
+        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
+
+            shader_hzb_reduce_mip0_clip.draw({
+                encoder,
+                bindings: {
+                    tInput: source_view,
+                    settings: {
+                        clip_region: [
+                            source_offset[0], source_offset[1],
+                            viewport_size[0], viewport_size[1],
+                        ],
+                        output_resolution: this.#mip_resolution(0),
+                    },
+                },
+                colorAttachments: [{
+                    view: destination_view,
+                    loadOp: 'clear',
+                    storeOp: 'store'
+                }]
+            })
+        } else {
+
+            this.#do_reduction_pass(encoder, shader_hzb_reduce_mip0, source_view, destination_view, 0);
+        }
+
+        source_view = destination_view;
+
+        for (let i = 1; i < mipLevelCount; i++) {
+
+            const destination_view = texture.obtainView(TextureViewDescriptor.from({
+                baseMipLevel: i,
+                mipLevelCount: 1,
+                dimension: "2d",
+                baseArrayLayer: 0,
+                arrayLayerCount: 1
+            }));
+
+            this.#do_reduction_pass(encoder, shader_hzb_reduce_any, source_view, destination_view, i);
+
+            // swap
+            source_view = destination_view;
+        }
+    }
+
+    /**
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {ImageShader} shader
+     * @param {GPUTextureView} source_view
+     * @param {GPUTextureView} destination_view
+     * @param {number} index
+     * @param {number[]} [viewport]
+     */
+    #do_reduction_pass(
+        encoder,
+        shader,
+        source_view,
+        destination_view,
+        index,
+        viewport
+    ) {
+
+        shader.draw({
+            encoder,
+            bindings: {
+                tInput: source_view,
+                output_resolution: this.#mip_resolution(index),
+            },
+            colorAttachments: [
+                {
+                    view: destination_view,
+                    loadOp: 'clear',
+                    storeOp: 'store'
+                }
+            ],
+            viewport
+        })
+
+    }
+
+    /**
+     * 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 hzb_w = Math.max(x >>> 1, 1);
+        const hzb_h = Math.max(y >>> 1, 1);
+
+        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);
+    }
+
+    destroy() {
+        this.#texture.destroy();
+    }
+}

package/src/shade/renderer/light/GPULightCollection.d.ts

@@ -1,4 +1,11 @@
 export class GPULightCollection {
+    /**
+     * Offer the pipelines a scene's lights are updated with — the environment map's filtering and
+     * projection, and the pose refresh — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      *
      * @param {GraphicsContext} graphics
@@ -78,6 +85,7 @@ export class GPULightCollection {
     destroy(): void;
     #private;
 }
+export type PipelineEnquiry = import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;
 export type GPUSceneContext = import("../scene/GPUSceneContext.js").GPUSceneContext;
 export type LightCollection = import("./LightCollection.js").LightCollection;

package/src/shade/renderer/light/GPULightCollection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/GPULightCollection.js"],"names":[],"mappings":"AA2CA;IAmJI;;;;;;OAMG;IACH,sBALW,eAAe,aACf,eAAe,EAqCzB;IApLD;;;OAGG;IACH,6DAEC;IAeD;;OAEG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,6BAEC;IAED;;;;;;;OAOG;IACH,qFAEC;IAWD;;OAEG;IACH,+CAEC;IAgDD;;;OAGG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAGD,4BAKC;IAgID;;;OAGG;IACH,YAFW,eAAe,QA8BzB;IAED;;;;;;;;;OASG;IACH,gBAFW,OAAO,+BAA+B,EAAE,YAAY,QAkC9D;IAED;;;;;;OAMG;IACH,uBAHW,sBAAsB,mCAyBhC;IAwED,gBASC;;CACJ;8BAneY,OAAO,uBAAuB,EAAE,eAAe;8BAC/C,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,sBAAsB,EAAE,eAAe;4BArB/B,gCAAgC;yCACnB,2CAA2C;kCAClD,iCAAiC;uCAH5B,wCAAwC"}
+{"version":3,"file":"GPULightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/GPULightCollection.js"],"names":[],"mappings":"AA+CA;IAEI;;;;;OAKG;IACH,iCAFW,eAAe,QAMzB;IAoJD;;;;;;OAMG;IACH,sBALW,eAAe,aACf,eAAe,EAqCzB;IApLD;;;OAGG;IACH,6DAEC;IAeD;;OAEG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,6BAEC;IAED;;;;;;;OAOG;IACH,qFAEC;IAWD;;OAEG;IACH,+CAEC;IAgDD;;;OAGG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAGD,4BAKC;IAgID;;;OAGG;IACH,YAFW,eAAe,QA8BzB;IAED;;;;;;;;;OASG;IACH,gBAFW,OAAO,+BAA+B,EAAE,YAAY,QAkC9D;IAED;;;;;;OAMG;IACH,uBAHW,sBAAsB,mCAyBhC;IAwED,gBASC;;CACJ;8BAjfY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;8BAC/C,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,sBAAsB,EAAE,eAAe;4BAzB/B,gCAAgC;yCACnB,2CAA2C;kCAClD,iCAAiC;uCAH5B,wCAAwC"}

package/src/shade/renderer/light/GPULightCollection.js

@@ -6,7 +6,10 @@ import { GPUSceneShadowmapContext } from "../shadow/map/GPUSceneShadowmapContext
 import { GPUTextureContext } from "../texture/GPUTextureContext.js";
 import { texture_mip_level_count } from "../../util/texture_mip_extent.js";
 import { texture_write_to_gpu } from "../texture/texture_write_to_gpu.js";
-import { execute_filter_environment_map } from "./environment/execute_filter_environment_map.js";
+import {
+    enquire_filter_environment_map_pipelines,
+    execute_filter_environment_map
+} from "./environment/execute_filter_environment_map.js";
 import { ENVIRONMENT_SH_TYPE, shader_project_environment_sh } from "./environment/shader_project_environment_sh.js";
 import { LIGHT_DATABASE_SPEC } from "./LIGHT_DATABASE_SPEC.js";
 import { light_record_directional } from "./model/io/light_record_directional.js";
@@ -20,6 +23,7 @@ import {
 } from "./shader_refresh_light_poses.js";
 
 /**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
  * @typedef {import("../scene/GPUSceneContext.js").GPUSceneContext} GPUSceneContext
  * @typedef {import("./LightCollection.js").LightCollection} LightCollection
@@ -43,6 +47,19 @@ const MAX_DIRECTIONAL_LIGHTS = 32;
 
 export class GPULightCollection {
 
+    /**
+     * Offer the pipelines a scene's lights are updated with — the environment map's filtering and
+     * projection, and the pose refresh — see {@link PipelineEnquiry}.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        enquire_filter_environment_map_pipelines(enquiry);
+        enquiry.compute.push(shader_project_environment_sh.pipeline);
+        enquiry.compute.push(shader_refresh_light_poses.pipeline);
+    }
+
+
     /**
      * @type {LightCollection}
      */

package/src/shade/renderer/light/cluster/cull/graph_cull_lights.d.ts

@@ -1,3 +1,10 @@
+/**
+ * Offer the pipelines {@link graph_cull_lights} dispatches when the scene has point or spot lights —
+ * see {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_cull_lights_pipelines(enquiry: PipelineEnquiry): void;
 /**
  *
  * @param {Object} options
@@ -12,4 +19,5 @@ export function graph_cull_lights({ graph, lights, camera, hzb, }: {
     camera: GPUCameraContext;
     hzb: number;
 }): number;
+export type PipelineEnquiry = import("../../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 //# sourceMappingURL=graph_cull_lights.d.ts.map