@woosh/meep-engine 3.12.0 → 3.13.0

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

@@ -1 +1 @@
-{"version":3,"file":"execute_filter_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/execute_filter_environment_map.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,8GAoCC"}
+{"version":3,"file":"execute_filter_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/execute_filter_environment_map.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,8GAoCC"}

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

@@ -1,6 +1,5 @@
 import { assert } from "../../../../core/assert.js";
 import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { shader_convolve_reflection_map } from "./shader_convolve_reflection_map.js";
 
 /**
@@ -32,7 +31,7 @@ export function execute_filter_environment_map(
             group_count_x: dispatch_x,
             group_count_y: dispatch_y,
             bindings: {
-                read_lod: encoder.allocateTransientValueBuffer(u32, i - 1),
+                read_lod: i - 1,
                 input: map.obtainView(TextureViewDescriptor.from({
                     baseMipLevel: i - 1,
                     mipLevelCount: 1,

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

@@ -1 +1 @@
-{"version":3,"file":"shader_convolve_reflection_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_convolve_reflection_map.js"],"names":[],"mappings":"AAwHA,2DAII;8BA1G0B,+BAA+B"}
+{"version":3,"file":"shader_convolve_reflection_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_convolve_reflection_map.js"],"names":[],"mappings":"AA6HA,2DAII;8BA/G0B,+BAA+B"}

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

@@ -25,8 +25,13 @@ import { chunk_sphere_probe_lod_to_roughness } from "./chunk_sphere_probe_lod_to
 import { BSDF_ROUGHNESS_MINIMUM } from "./DEFINES.js";
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer. The convolve
+// walks the mip chain one dispatch at a time, so a buffer was allocated and filled per level to
+// carry a single mip index.
+resources.setImmediate("read_lod", "u32");
+
 resources.createGroup()
-    .addUniform("read_lod", "u32")
     .addTexture("input")
     .addStorageTexture("output", "rgba16float")
 ;

package/src/shade/renderer/lightmap/bake/raster/graph_draw_lightmap_viz_buffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_draw_lightmap_viz_buffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/lightmap/bake/raster/graph_draw_lightmap_viz_buffer.js"],"names":[],"mappings":"AA8CA;;;;;;;GAOG;AACH,8FAFa,MAAM,CAuKlB"}
+{"version":3,"file":"graph_draw_lightmap_viz_buffer.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/lightmap/bake/raster/graph_draw_lightmap_viz_buffer.js"],"names":[],"mappings":"AA8CA;;;;;;;GAOG;AACH,8FAFa,MAAM,CAsLlB"}

package/src/shade/renderer/lightmap/bake/raster/graph_draw_lightmap_viz_buffer.js

@@ -1,220 +1,235 @@
-import { assert } from "../../../../../core/assert.js";
-import { vec2f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import {
-    VIZ_BUFFER_INVALID_MESH_VALUE
-} from "../../../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
-import { DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR } from "../../../texture/DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR.js";
-import {
-    lightmap_to_viz_buffer_resources,
-    shader_lightmap_to_viz_buffer,
-    shader_lightmap_to_viz_buffer_points,
-    shader_lightmap_to_viz_buffer_wireframe
-} from "./shader_lightmap_to_viz_buffer.js";
-
-const offsets =
-    [
-        { x: -2, y: -2 },
-        { x: 2, y: -2 },
-        { x: -2, y: 2 },
-        { x: 2, y: 2 },
-
-        { x: -1, y: -2 },
-        { x: 1, y: -2 },
-        { x: -2, y: -1 },
-        { x: 2, y: -1 },
-        { x: -2, y: 1 },
-        { x: 2, y: 1 },
-        { x: -1, y: 2 },
-        { x: 1, y: 2 },
-
-        { x: -2, y: 0 },
-        { x: 2, y: 0 },
-        { x: 0, y: -2 },
-        { x: 0, y: 2 },
-
-        { x: -1, y: -1 },
-        { x: 1, y: -1 },
-        { x: -1, y: 1 },
-        { x: 1, y: 1 },
-        { x: -1, y: 0 },
-        { x: 1, y: 0 },
-        { x: 0, y: -1 },
-        { x: 0, y: 1 },
-
-        { x: 0, y: 0 },
-    ];
-
-/**
- *
- * @param {FrameGraph} graph
- * @param {number} output Viz buffer texture
- * @param {GPUSceneContext} scene
- * @param {boolean} [force]
- * @returns {number} written output ID
- */
-export function graph_draw_lightmap_viz_buffer({
-                                                   graph,
-                                                   output,
-                                                   scene,
-                                                   force = false,
-                                               }) {
-    assert.defined(scene, 'scene');
-    assert.defined(graph, 'graph');
-    assert.isNonNegativeInteger(output, 'output');
-
-
-    const data = {};
-
-    /**
-     *
-     * @param data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute(data, resources, context) {
-
-        const meshes = scene.scene.instances.instances;
-
-        const mesh_count = meshes.length;
-
-        if (mesh_count <= 0) {
-            // nothing to do
-            return;
-        }
-
-        /**
-         * @type {GPUTextureContext}
-         */
-        const viz_buffer = resources.get(data.viz_buffer);
-
-
-        const bindings = lightmap_to_viz_buffer_resources.generateBindings({
-            uv_offset: context.encoder.allocateTransientValueBuffer(vec2f, [
-                0,
-                0,
-            ], GPUBufferUsage.UNIFORM),
-            scene_database: scene.scene_database_buffer,
-            geometries: scene.geometries.buffer_metadata,
-        });
-
-        /*
-         We perform conservative rasterization by
-            1. First drawing all vertices to make sure that extreme corners are painted in
-            2. Draw wireframe, outlining each edge, this ensures that tiny edges are occupying at least 1 pixel
-            3. Finally, draw triangles as normal
-         */
-
-        const viz_buffer_view = viz_buffer.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR);
-
-        // points
-        {
-            const pass = context.encoder.constructRenderPass({
-                pipeline: shader_lightmap_to_viz_buffer_points,
-                bindings,
-                colorAttachments: [
-                    {
-                        loadOp: "clear",
-                        storeOp: "store",
-                        clearValue: [VIZ_BUFFER_INVALID_MESH_VALUE, VIZ_BUFFER_INVALID_MESH_VALUE, 0, 0],
-                        view: viz_buffer_view
-                    }
-                ]
-            });
-
-            for (let i = 0; i < mesh_count; i++) {
-                const mesh = meshes[i];
-                const geometry = mesh.geometry;
-
-                const mesh_id = i;
-
-                pass.draw(
-                    geometry.getVertexCount(),
-                    1,
-                    0,
-                    mesh_id
-                );
-            }
-
-            pass.end();
-        }
-
-        // Lines
-        {
-
-            const pass = context.encoder.constructRenderPass({
-                pipeline: shader_lightmap_to_viz_buffer_wireframe,
-                bindings,
-                colorAttachments: [
-                    {
-                        loadOp: "load",
-                        storeOp: "store",
-                        clearValue: [VIZ_BUFFER_INVALID_MESH_VALUE, VIZ_BUFFER_INVALID_MESH_VALUE, 0, 0],
-                        view: viz_buffer_view
-                    }
-                ]
-            });
-
-            for (let i = 0; i < mesh_count; i++) {
-                const mesh = meshes[i];
-                const geometry = mesh.geometry;
-
-                const mesh_id = i;
-
-                // line-list: 3 edges x 2 vertices per triangle = 6 per triangle, i.e. 2x the
-                // index count — with only getIndexCount() vertices half the triangles got no edges
-                pass.draw(
-                    geometry.getIndexCount() * 2,
-                    1,
-                    0,
-                    mesh_id
-                );
-            }
-
-            pass.end();
-        }
-
-        // triangles
-        {
-
-            const pass = context.encoder.constructRenderPass({
-                pipeline: shader_lightmap_to_viz_buffer,
-                bindings,
-                colorAttachments: [
-                    {
-                        loadOp: "load",
-                        storeOp: "store",
-                        clearValue: [VIZ_BUFFER_INVALID_MESH_VALUE, VIZ_BUFFER_INVALID_MESH_VALUE, 0, 0],
-                        view: viz_buffer_view
-                    }
-                ]
-            });
-
-            for (let i = 0; i < mesh_count; i++) {
-                const mesh = meshes[i];
-                const geometry = mesh.geometry;
-
-                const mesh_id = i;
-
-                pass.draw(
-                    geometry.getIndexCount(),
-                    1,
-                    0,
-                    mesh_id
-                );
-            }
-
-            pass.end();
-        }
-    }
-
-    const pass = graph.add("Draw lightmap viz buffer", data, execute);
-
-    if (force) {
-        // force this pass to run regardless of network structure
-        pass.make_side_effect();
-    }
-
-    data.viz_buffer = pass.write(output);
-
-    return data.viz_buffer;
+import { assert } from "../../../../../core/assert.js";
+import { vec2f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import {
+    VIZ_BUFFER_INVALID_MESH_VALUE
+} from "../../../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
+import { DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR } from "../../../texture/DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR.js";
+import {
+    lightmap_to_viz_buffer_resources,
+    shader_lightmap_to_viz_buffer,
+    shader_lightmap_to_viz_buffer_points,
+    shader_lightmap_to_viz_buffer_wireframe
+} from "./shader_lightmap_to_viz_buffer.js";
+
+const offsets =
+    [
+        { x: -2, y: -2 },
+        { x: 2, y: -2 },
+        { x: -2, y: 2 },
+        { x: 2, y: 2 },
+
+        { x: -1, y: -2 },
+        { x: 1, y: -2 },
+        { x: -2, y: -1 },
+        { x: 2, y: -1 },
+        { x: -2, y: 1 },
+        { x: 2, y: 1 },
+        { x: -1, y: 2 },
+        { x: 1, y: 2 },
+
+        { x: -2, y: 0 },
+        { x: 2, y: 0 },
+        { x: 0, y: -2 },
+        { x: 0, y: 2 },
+
+        { x: -1, y: -1 },
+        { x: 1, y: -1 },
+        { x: -1, y: 1 },
+        { x: 1, y: 1 },
+        { x: -1, y: 0 },
+        { x: 1, y: 0 },
+        { x: 0, y: -1 },
+        { x: 0, y: 1 },
+
+        { x: 0, y: 0 },
+    ];
+
+/**
+ *
+ * @param {FrameGraph} graph
+ * @param {number} output Viz buffer texture
+ * @param {GPUSceneContext} scene
+ * @param {boolean} [force]
+ * @returns {number} written output ID
+ */
+export function graph_draw_lightmap_viz_buffer({
+                                                   graph,
+                                                   output,
+                                                   scene,
+                                                   force = false,
+                                               }) {
+    assert.defined(scene, 'scene');
+    assert.defined(graph, 'graph');
+    assert.isNonNegativeInteger(output, 'output');
+
+
+    const data = {};
+
+    /**
+     *
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+
+        const meshes = scene.scene.instances.instances;
+
+        const mesh_count = meshes.length;
+
+        if (mesh_count <= 0) {
+            // nothing to do
+            return;
+        }
+
+        /**
+         * @type {GPUTextureContext}
+         */
+        const viz_buffer = resources.get(data.viz_buffer);
+
+
+        const binding_values = {
+            uv_offset: [0, 0],
+            scene_database: scene.scene_database_buffer,
+            geometries: scene.geometries.buffer_metadata,
+        };
+
+        const bindings = lightmap_to_viz_buffer_resources.generateBindings(binding_values);
+
+
+        /*
+         We perform conservative rasterization by
+            1. First drawing all vertices to make sure that extreme corners are painted in
+            2. Draw wireframe, outlining each edge, this ensures that tiny edges are occupying at least 1 pixel
+            3. Finally, draw triangles as normal
+         */
+
+        const viz_buffer_view = viz_buffer.obtainView(DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR);
+
+        // points
+        {
+            const pass = context.encoder.constructRenderPass({
+                pipeline: shader_lightmap_to_viz_buffer_points,
+                bindings,
+                // built by hand rather than through ImageShader.draw, so the immediate `uv_offset`
+                // is written here. Per pass rather than hoisted: the encoder serialises into one
+                // reusable buffer, so a value written once would go stale if anything else wrote an
+                // immediate between these passes.
+                immediate: context.encoder.writeImmediate(lightmap_to_viz_buffer_resources, binding_values),
+                colorAttachments: [
+                    {
+                        loadOp: "clear",
+                        storeOp: "store",
+                        clearValue: [VIZ_BUFFER_INVALID_MESH_VALUE, VIZ_BUFFER_INVALID_MESH_VALUE, 0, 0],
+                        view: viz_buffer_view
+                    }
+                ]
+            });
+
+            for (let i = 0; i < mesh_count; i++) {
+                const mesh = meshes[i];
+                const geometry = mesh.geometry;
+
+                const mesh_id = i;
+
+                pass.draw(
+                    geometry.getVertexCount(),
+                    1,
+                    0,
+                    mesh_id
+                );
+            }
+
+            pass.end();
+        }
+
+        // Lines
+        {
+
+            const pass = context.encoder.constructRenderPass({
+                pipeline: shader_lightmap_to_viz_buffer_wireframe,
+                bindings,
+                // built by hand rather than through ImageShader.draw, so the immediate `uv_offset`
+                // is written here. Per pass rather than hoisted: the encoder serialises into one
+                // reusable buffer, so a value written once would go stale if anything else wrote an
+                // immediate between these passes.
+                immediate: context.encoder.writeImmediate(lightmap_to_viz_buffer_resources, binding_values),
+                colorAttachments: [
+                    {
+                        loadOp: "load",
+                        storeOp: "store",
+                        clearValue: [VIZ_BUFFER_INVALID_MESH_VALUE, VIZ_BUFFER_INVALID_MESH_VALUE, 0, 0],
+                        view: viz_buffer_view
+                    }
+                ]
+            });
+
+            for (let i = 0; i < mesh_count; i++) {
+                const mesh = meshes[i];
+                const geometry = mesh.geometry;
+
+                const mesh_id = i;
+
+                // line-list: 3 edges x 2 vertices per triangle = 6 per triangle, i.e. 2x the
+                // index count — with only getIndexCount() vertices half the triangles got no edges
+                pass.draw(
+                    geometry.getIndexCount() * 2,
+                    1,
+                    0,
+                    mesh_id
+                );
+            }
+
+            pass.end();
+        }
+
+        // triangles
+        {
+
+            const pass = context.encoder.constructRenderPass({
+                pipeline: shader_lightmap_to_viz_buffer,
+                bindings,
+                // built by hand rather than through ImageShader.draw, so the immediate `uv_offset`
+                // is written here. Per pass rather than hoisted: the encoder serialises into one
+                // reusable buffer, so a value written once would go stale if anything else wrote an
+                // immediate between these passes.
+                immediate: context.encoder.writeImmediate(lightmap_to_viz_buffer_resources, binding_values),
+                colorAttachments: [
+                    {
+                        loadOp: "load",
+                        storeOp: "store",
+                        clearValue: [VIZ_BUFFER_INVALID_MESH_VALUE, VIZ_BUFFER_INVALID_MESH_VALUE, 0, 0],
+                        view: viz_buffer_view
+                    }
+                ]
+            });
+
+            for (let i = 0; i < mesh_count; i++) {
+                const mesh = meshes[i];
+                const geometry = mesh.geometry;
+
+                const mesh_id = i;
+
+                pass.draw(
+                    geometry.getIndexCount(),
+                    1,
+                    0,
+                    mesh_id
+                );
+            }
+
+            pass.end();
+        }
+    }
+
+    const pass = graph.add("Draw lightmap viz buffer", data, execute);
+
+    if (force) {
+        // force this pass to run regardless of network structure
+        pass.make_side_effect();
+    }
+
+    data.viz_buffer = pass.write(output);
+
+    return data.viz_buffer;
 }

package/src/shade/renderer/lightmap/bake/raster/shader_lightmap_to_viz_buffer.js

@@ -21,9 +21,9 @@ import { chunk_lightmap_geometry_uv_to_atlas } from "../../chunk_lightmap_geomet
 
 
 export const lightmap_to_viz_buffer_resources = new ShaderResourceSetDescriptor()
-lightmap_to_viz_buffer_resources.createGroup()
-    .addUniform("uv_offset", "vec2f");
 
+// per-draw, eight bytes, read-only: immediate data rather than a uniform buffer
+lightmap_to_viz_buffer_resources.setImmediate("uv_offset", "vec2f");
 lightmap_to_viz_buffer_resources.createGroup()
     .addStorageBuffer("scene_database", WebGPUArray.from(u32))
     .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT))