@woosh/meep-engine 3.11.3 → 3.12.0

package/src/shade/renderer/path_tracer/graph_path_trace_scene.js

@@ -1,185 +1,185 @@
-import { assert } from "../../../core/assert.js";
-import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
-import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
-import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
-import { chunk_camera_ray_from_uv } from "../shader/chunk/geometry/ray/chunk_camera_ray_from_uv.js";
-import { F32_MAX_DEFINITION } from "../shader/chunk/math/F32_MAX_DEFINITION.js";
-import { chunk_hammersley_2d } from "../shader/chunk/noise/chunk_hammersley_2d.js";
-import { chunk_random } from "../shader/chunk/random/chunk_random.js";
-import { chunk_random_initialize } from "../shader/chunk/random/chunk_random_initialize.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { sr_create_group_RTX } from "../geometry/sr_create_group_RTX.js";
-import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../material/resident/INDIRECT_MATERIAL_ARRAY_TYPE.js";
-import { chunk_render_trace_path } from "./shader/chunk_render_trace_path.js";
-
-const RAY_TRACING_UNIFORMS_STRUCT = WebGPUStruct.from({
-    random_seed: u32
-});
-
-const resources = new ShaderResourceSetDescriptor();
-
-sr_create_group_RTX(resources);
-
-resources.createGroup()
-    .addUniform("materials", INDIRECT_MATERIAL_ARRAY_TYPE)
-    .addTexture("textures", "unfilterable-float", "2d-array")
-
-resources.createGroup()
-    .addStorageBuffer("light_data", WebGPUArray.u32)
-    .addTexture("tEnvironment", "unfilterable-float", "2d")
-
-resources.createGroup()
-    .addUniform("common_uniforms", RAY_TRACING_UNIFORMS_STRUCT)
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    .addStorageTexture("output_texture", "rgba16float", "2d", "write-only")
-;
-
-const body = CodeChunk.from(
-//language=WGSL
-    `
-@compute @workgroup_size(8,8,1)
-fn main(@builtin(global_invocation_id) invocation_id : vec3<u32>){
-    let viewport_dimensions = textureDimensions(output_texture);
-
-    if (any(invocation_id.xy >= viewport_dimensions)){
-        return;
-    }
-    
-    random_initialize(invocation_id, vec3(common_uniforms.random_seed));
-    
-    let uv = vec2f(invocation_id.xy) / vec2f(viewport_dimensions);
-    let pixel_uv_size = 1.0 / vec2f(viewport_dimensions);
-    
-    const BOUNCE_LIMIT = 3;
-    const SAMPLE_LIMIT = 32;
-    
-    var irradiance = vec3(0.0);
-    
-    for(var sample_index=0u; sample_index < SAMPLE_LIMIT; sample_index++){
-    
-        // construct ray
-        
-        var jitter = hammersley_2d(sample_index, SAMPLE_LIMIT);
-        
-        let uv_coordinate = uv + jitter * pixel_uv_size;
-        
-        var ray = camera_ray_from_uv(vec2(uv_coordinate.x, uv_coordinate.y), camera);
-        
-        ray.tmax = F32_MAX; // TODO set based on "far" clipping plane from camera
-                            
-        irradiance += render_trace_path(ray, BOUNCE_LIMIT).irradiance;
-    }
-    
-    var output = irradiance / SAMPLE_LIMIT;
-           
-    textureStore(output_texture, invocation_id.xy, vec4(output, 1));
-}
-`, [
-        F32_MAX_DEFINITION,
-        chunk_camera_ray_from_uv,
-        chunk_hammersley_2d,
-        chunk_random_initialize,
-        chunk_random,
-        chunk_render_trace_path,
-    ]);
-
-const shader = ComputeShader.from({
-    label: 'Path Tracer',
-    resources,
-    body
-})
-
-
-/**
- *
- * @param {FrameGraph} graph
- * @param {GPUViewContext} view
- * @returns {number}
- */
-export function graph_path_trace_scene({
-                                           graph,
-                                           view,
-                                       }) {
-
-    assert.defined(graph, 'graph');
-
-    assert.defined(view, 'view');
-    assert.equal(view.isGPUViewContext, true, '"view" must be a GPUViewContext');
-
-
-    const pass_data = {};
-
-    /**
-     *
-     * @param data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute(data, resources, context) {
-
-        const graphics = context.graphics;
-
-        const r_materials = graphics.materials_resident;
-
-        const scene_ctx = view.scene;
-
-        r_materials.ensure_scene_materials(scene_ctx.scene);
-        r_materials.update();
-
-        const geometries = scene_ctx.geometries;
-
-        /**
-         * @type {GPUTextureContext}
-         */
-        const output_texture = resources.get(data.output);
-
-        const rt_uniforms = context.encoder.allocateTransientBufferAndLoad(new Uint32Array([0]).buffer, GPUBufferUsage.UNIFORM);
-
-        shader.dispatch({
-            encoder: context.encoder,
-
-            group_count_x: Math.ceil(output_texture.width / 8),
-            group_count_y: Math.ceil(output_texture.height / 8),
-
-            bindings: {
-                materials: r_materials.buffer_materials,
-                textures: r_materials.textureView,
-
-                //
-                tlas: scene_ctx.tlas.buffer,
-                blas_lookup: geometries.blas.buffer_metadata,
-                blas_data: geometries.blas.buffer_data,
-                scene_database: scene_ctx.scene_database_buffer,
-                geometries: geometries.buffer_metadata,
-
-                meshlet_data: geometries.meshlets.buffer_data,
-                meshlet_metadata: geometries.meshlets.buffer_metadata,
-
-                //
-                light_data: scene_ctx.lights.buffer_data,
-                tEnvironment: view.scene.lights.environment.obtainView(),
-
-                common_uniforms: rt_uniforms,
-                camera: view.camera.gpu_buffer,
-                output_texture: output_texture.obtainView()
-            }
-        });
-
-
-    }
-
-    const builder = graph.add('path trace scene', pass_data, execute);
-
-    pass_data.output = builder.create("output", TextureResourceDescriptor.from({
-        resolution: view.resolution,
-        format: 'rgba16float',
-        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING
-    }));
-
-
-    return pass_data.output;
+import { assert } from "../../../core/assert.js";
+import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
+import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_camera_ray_from_uv } from "../shader/chunk/geometry/ray/chunk_camera_ray_from_uv.js";
+import { F32_MAX_DEFINITION } from "../shader/chunk/math/F32_MAX_DEFINITION.js";
+import { chunk_hammersley_2d } from "../shader/chunk/noise/chunk_hammersley_2d.js";
+import { chunk_random } from "../shader/chunk/random/chunk_random.js";
+import { chunk_random_initialize } from "../shader/chunk/random/chunk_random_initialize.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { sr_create_group_RTX } from "../geometry/sr_create_group_RTX.js";
+import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../material/resident/INDIRECT_MATERIAL_ARRAY_TYPE.js";
+import { chunk_render_trace_path } from "./shader/chunk_render_trace_path.js";
+
+const RAY_TRACING_UNIFORMS_STRUCT = WebGPUStruct.from({
+    random_seed: u32
+});
+
+const resources = new ShaderResourceSetDescriptor();
+
+sr_create_group_RTX(resources);
+
+resources.createGroup()
+    .addUniform("materials", INDIRECT_MATERIAL_ARRAY_TYPE)
+    .addTexture("textures", "unfilterable-float", "2d-array")
+
+resources.createGroup()
+    .addStorageBuffer("light_data", WebGPUArray.u32)
+    .addTexture("tEnvironment", "unfilterable-float", "2d")
+
+resources.createGroup()
+    .addUniform("common_uniforms", RAY_TRACING_UNIFORMS_STRUCT)
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addStorageTexture("output_texture", "rgba16float", "2d", "write-only")
+;
+
+const body = CodeChunk.from(
+//language=WGSL
+    `
+@compute @workgroup_size(8,8,1)
+fn main(@builtin(global_invocation_id) invocation_id : vec3<u32>){
+    let viewport_dimensions = textureDimensions(output_texture);
+
+    if (any(invocation_id.xy >= viewport_dimensions)){
+        return;
+    }
+    
+    random_initialize(invocation_id, vec3(common_uniforms.random_seed));
+    
+    let uv = vec2f(invocation_id.xy) / vec2f(viewport_dimensions);
+    let pixel_uv_size = 1.0 / vec2f(viewport_dimensions);
+    
+    const BOUNCE_LIMIT = 3;
+    const SAMPLE_LIMIT = 32;
+    
+    var irradiance = vec3(0.0);
+    
+    for(var sample_index=0u; sample_index < SAMPLE_LIMIT; sample_index++){
+    
+        // construct ray
+        
+        var jitter = hammersley_2d(sample_index, SAMPLE_LIMIT);
+        
+        let uv_coordinate = uv + jitter * pixel_uv_size;
+        
+        var ray = camera_ray_from_uv(vec2(uv_coordinate.x, uv_coordinate.y), camera);
+        
+        ray.tmax = F32_MAX; // TODO set based on "far" clipping plane from camera
+                            
+        irradiance += render_trace_path(ray, BOUNCE_LIMIT).irradiance;
+    }
+    
+    var output = irradiance / SAMPLE_LIMIT;
+           
+    textureStore(output_texture, invocation_id.xy, vec4(output, 1));
+}
+`, [
+        F32_MAX_DEFINITION,
+        chunk_camera_ray_from_uv,
+        chunk_hammersley_2d,
+        chunk_random_initialize,
+        chunk_random,
+        chunk_render_trace_path,
+    ]);
+
+const shader = ComputeShader.from({
+    label: 'Path Tracer',
+    resources,
+    body
+})
+
+
+/**
+ *
+ * @param {FrameGraph} graph
+ * @param {GPUViewContext} view
+ * @returns {number}
+ */
+export function graph_path_trace_scene({
+                                           graph,
+                                           view,
+                                       }) {
+
+    assert.defined(graph, 'graph');
+
+    assert.defined(view, 'view');
+    assert.equal(view.isGPUViewContext, true, '"view" must be a GPUViewContext');
+
+
+    const pass_data = {};
+
+    /**
+     *
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+
+        const graphics = context.graphics;
+
+        const r_materials = graphics.materials_resident;
+
+        const scene_ctx = view.scene;
+
+        r_materials.ensure_scene_materials(scene_ctx.scene);
+        r_materials.update();
+
+        const geometries = scene_ctx.geometries;
+
+        /**
+         * @type {GPUTextureContext}
+         */
+        const output_texture = resources.get(data.output);
+
+        const rt_uniforms = context.encoder.allocateTransientBufferAndLoad(new Uint32Array([0]).buffer, GPUBufferUsage.UNIFORM);
+
+        shader.dispatchThreads({
+            encoder: context.encoder,
+
+            thread_count_x: output_texture.width,
+            thread_count_y: output_texture.height,
+
+            bindings: {
+                materials: r_materials.buffer_materials,
+                textures: r_materials.textureView,
+
+                //
+                tlas: scene_ctx.tlas.buffer,
+                blas_lookup: geometries.blas.buffer_metadata,
+                blas_data: geometries.blas.buffer_data,
+                scene_database: scene_ctx.scene_database_buffer,
+                geometries: geometries.buffer_metadata,
+
+                meshlet_data: geometries.meshlets.buffer_data,
+                meshlet_metadata: geometries.meshlets.buffer_metadata,
+
+                //
+                light_data: scene_ctx.lights.buffer_data,
+                tEnvironment: view.scene.lights.environment.obtainView(),
+
+                common_uniforms: rt_uniforms,
+                camera: view.camera.gpu_buffer,
+                output_texture: output_texture.obtainView()
+            }
+        });
+
+
+    }
+
+    const builder = graph.add('path trace scene', pass_data, execute);
+
+    pass_data.output = builder.create("output", TextureResourceDescriptor.from({
+        resolution: view.resolution,
+        format: 'rgba16float',
+        usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING
+    }));
+
+
+    return pass_data.output;
 }

package/src/shade/renderer/postprocess/denoise/graph_atorus_denoise_luma.js

@@ -1,120 +1,120 @@
-import { assert } from "../../../../core/assert.js";
-import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
-import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
-import { create_full_quad_pipeline_descriptor } from "../../shader/fullscreen/create_full_quad_pipeline_descriptor.js";
-import { ATORUS_UNIFORMS_STRUCT, fragment_shader_denoise_ao } from "./fragment_shader_denoise_ao.js";
-
-const render_pipeline_descriptor_denoise = create_full_quad_pipeline_descriptor({
-    label: "A-torus Denoise",
-    fragment_code: fragment_shader_denoise_ao.compile(),
-    layout: fragment_shader_denoise_ao.resources.generatePipelineLayout(GPUShaderStage.FRAGMENT),
-    targets: [
-        {
-            format: "rg16float"
-        }
-    ]
-});
-
-/**
- *
- * @param {FrameGraph} graph
- * @param {number} input_luma
- * @param {number} input_depth
- * @param {number} input_normal
- * @param {number} [iterations]
- * @param {number} input_mip_level what mip level to read input resources at, needed for denoising half-resolution render targets
- * @param {number[]} resolution
- * @returns {number}
- */
-export function graph_atorus_denoise_luma({
-                                              graph,
-                                              input_luma = -1,
-                                              input_depth = -1,
-                                              input_normal = -1,
-                                              iterations = 3,
-                                              input_mip_level = 0,
-                                              resolution
-                                          }) {
-
-    assert.isNonNegativeInteger(input_mip_level, 'input_mip_level');
-
-    let input = input_luma;
-
-    for (let i = 0; i < iterations; i++) {
-
-        const denoise_data = {};
-
-        const denoise_iteration = i;
-
-        /**
-         *
-         * @param data
-         * @param {FramePassResources} resources
-         * @param {GraphicsExecutionContext} context
-         */
-        function pass_denoise(data, resources, context) {
-
-            const texture_depth = resources.get(data.input_depth);
-            const texture_normal = resources.get(data.input_normal);
-            const texture_luminance = resources.get(data.input_luminance);
-
-            const output = resources.get(data.output);
-
-            const encoder = context.encoder;
-
-            const buffer_settings = encoder.allocateTransientValueBuffer(
-                ATORUS_UNIFORMS_STRUCT,
-                {
-                    // with 3 iterations this gives us step sizes of: 1, 2, 4
-                    // this is based on AMD's shadow denoiser presentation
-                    step_size: 1 << denoise_iteration,
-                },
-                GPUBufferUsage.UNIFORM
-            );
-
-            const input_view_descriptor = TextureViewDescriptor.from({
-                baseMipLevel: input_mip_level,
-                mipLevelCount: 1
-            });
-
-            const pass = encoder.constructRenderPass({
-                pipeline: render_pipeline_descriptor_denoise,
-                bindings: fragment_shader_denoise_ao.resources.generateBindings({
-                    tInput: texture_luminance.obtainView(),
-                    tDepth: texture_depth.obtainView(input_view_descriptor),
-                    tNormal: texture_normal.obtainView(input_view_descriptor),
-                    settings: buffer_settings
-                }),
-                colorAttachments: [
-                    {
-                        loadOp: "clear",
-                        storeOp: "store",
-                        clearValue: [0, 0, 0, 0],
-                        view: output.obtainView()
-                    }
-                ]
-            });
-
-            pass.draw(3);
-
-            pass.end();
-        }
-
-        const denoise_builder = graph.add(`Spatial Denoise ${(i + 1)}/${iterations}`, denoise_data, pass_denoise);
-
-        denoise_data.input_depth = denoise_builder.read(input_depth);
-        denoise_data.input_normal = denoise_builder.read(input_normal);
-        denoise_data.input_luminance = denoise_builder.read(input);
-
-        input = denoise_builder.create("denoised", TextureResourceDescriptor.from({
-            resolution: resolution,
-            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT,
-            format: "rg16float",
-        }));
-
-        denoise_data.output = input;
-
-    }
-
-    return input;
+import { assert } from "../../../../core/assert.js";
+import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
+import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
+import { create_full_quad_pipeline_descriptor } from "../../shader/fullscreen/create_full_quad_pipeline_descriptor.js";
+import { ATORUS_UNIFORMS_STRUCT, fragment_shader_denoise_ao } from "./fragment_shader_denoise_ao.js";
+
+const render_pipeline_descriptor_denoise = create_full_quad_pipeline_descriptor({
+    label: "A-torus Denoise",
+    fragment_code: fragment_shader_denoise_ao.source,
+    layout: fragment_shader_denoise_ao.resources.generatePipelineLayout(GPUShaderStage.FRAGMENT),
+    targets: [
+        {
+            format: "rg16float"
+        }
+    ]
+});
+
+/**
+ *
+ * @param {FrameGraph} graph
+ * @param {number} input_luma
+ * @param {number} input_depth
+ * @param {number} input_normal
+ * @param {number} [iterations]
+ * @param {number} input_mip_level what mip level to read input resources at, needed for denoising half-resolution render targets
+ * @param {number[]} resolution
+ * @returns {number}
+ */
+export function graph_atorus_denoise_luma({
+                                              graph,
+                                              input_luma = -1,
+                                              input_depth = -1,
+                                              input_normal = -1,
+                                              iterations = 3,
+                                              input_mip_level = 0,
+                                              resolution
+                                          }) {
+
+    assert.isNonNegativeInteger(input_mip_level, 'input_mip_level');
+
+    let input = input_luma;
+
+    for (let i = 0; i < iterations; i++) {
+
+        const denoise_data = {};
+
+        const denoise_iteration = i;
+
+        /**
+         *
+         * @param data
+         * @param {FramePassResources} resources
+         * @param {GraphicsExecutionContext} context
+         */
+        function pass_denoise(data, resources, context) {
+
+            const texture_depth = resources.get(data.input_depth);
+            const texture_normal = resources.get(data.input_normal);
+            const texture_luminance = resources.get(data.input_luminance);
+
+            const output = resources.get(data.output);
+
+            const encoder = context.encoder;
+
+            const buffer_settings = encoder.allocateTransientValueBuffer(
+                ATORUS_UNIFORMS_STRUCT,
+                {
+                    // with 3 iterations this gives us step sizes of: 1, 2, 4
+                    // this is based on AMD's shadow denoiser presentation
+                    step_size: 1 << denoise_iteration,
+                },
+                GPUBufferUsage.UNIFORM
+            );
+
+            const input_view_descriptor = TextureViewDescriptor.from({
+                baseMipLevel: input_mip_level,
+                mipLevelCount: 1
+            });
+
+            const pass = encoder.constructRenderPass({
+                pipeline: render_pipeline_descriptor_denoise,
+                bindings: fragment_shader_denoise_ao.resources.generateBindings({
+                    tInput: texture_luminance.obtainView(),
+                    tDepth: texture_depth.obtainView(input_view_descriptor),
+                    tNormal: texture_normal.obtainView(input_view_descriptor),
+                    settings: buffer_settings
+                }),
+                colorAttachments: [
+                    {
+                        loadOp: "clear",
+                        storeOp: "store",
+                        clearValue: [0, 0, 0, 0],
+                        view: output.obtainView()
+                    }
+                ]
+            });
+
+            pass.draw(3);
+
+            pass.end();
+        }
+
+        const denoise_builder = graph.add(`Spatial Denoise ${(i + 1)}/${iterations}`, denoise_data, pass_denoise);
+
+        denoise_data.input_depth = denoise_builder.read(input_depth);
+        denoise_data.input_normal = denoise_builder.read(input_normal);
+        denoise_data.input_luminance = denoise_builder.read(input);
+
+        input = denoise_builder.create("denoised", TextureResourceDescriptor.from({
+            resolution: resolution,
+            usage: GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.RENDER_ATTACHMENT,
+            format: "rg16float",
+        }));
+
+        denoise_data.output = input;
+
+    }
+
+    return input;
 }

package/src/shade/renderer/postprocess/dof/raymarch/graph_postprocess_dof.js

@@ -216,11 +216,10 @@ function dof_compute_march_pass(graph, shader, label, tColorCoc, stbn_vec2, tTil
         // Dispatch needs a real buffer, not a plain value, for the uniform.
         const dof_buffer = encoder.allocateTransientValueBuffer(DOF_SETTINGS_STRUCT, settings);
 
-        shader.dispatch({
+        shader.dispatchThreads({
             encoder,
-            group_count_x: Math.ceil(resolution[0] / 8),
-            group_count_y: Math.ceil(resolution[1] / 8),
-            group_count_z: 1,
+            thread_count_x: resolution[0],
+            thread_count_y: resolution[1],
             bindings: {
                 tColorCoc: resources.get(data.tColorCoc),
                 tSTBN_vec2: stbn_vec2,

package/src/shade/renderer/postprocess/dof/raymarch/shader_dof_raymarch_compute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_dof_raymarch_compute.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/dof/raymarch/shader_dof_raymarch_compute.js"],"names":[],"mappings":"AAuOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,0CAFU,aAAa,CAOpB;8BAtQ2B,kCAAkC"}
+{"version":3,"file":"shader_dof_raymarch_compute.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/dof/raymarch/shader_dof_raymarch_compute.js"],"names":[],"mappings":"AAuOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,0CAFU,aAAa,CAMpB;8BArQ2B,kCAAkC"}