@woosh/meep-engine 3.11.3 → 3.13.0

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;
 }