@woosh/meep-engine 3.11.3 → 3.13.0

package/src/shade/renderer/particles/shaders/shader_particle_simulate.js

@@ -1,5 +1,6 @@
 import { atomic_u32, f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -36,7 +37,22 @@ import { chunk_particle_context, chunk_particle_curve_disabled } from "./chunk_p
 
 export const PARTICLE_SIMULATE_WORKGROUP_SIZE = 64;
 
+/**
+ * Per-dispatch, 12 bytes, read-only — see shader_particle_emit for why the three travel
+ * together rather than as three uniforms.
+ *
+ * @type {WebGPUStruct}
+ */
+const SIMULATE_SETTINGS = WebGPUStruct.from({
+    u_dt: f32,
+    u_time: f32,
+    u_frame: u32,
+}, 'ParticleSimulateSettings');
+
 const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate('settings', SIMULATE_SETTINGS);
+
 resources.createGroup()
     .addStorageBuffer("emitters", WebGPUArray.u32, false)
     .addStorageBuffer("program", WebGPUArray.u32, false)
@@ -45,11 +61,7 @@ resources.createGroup()
     .addStorageBuffer("alive_in", WebGPUArray.u32, false)
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    .addUniform("u_dt", f32)
-    .addUniform("u_time", f32)
-    .addUniform("u_frame", u32);
-
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
 const body = CodeChunk.from(/* wgsl */ `
 const PARTICLE_RECORD_WORDS : u32 = ${PARTICLE_RECORD_WORD_COUNT}u;
 const PARTICLE_HEADER_EMITTER : u32 = ${PARTICLE_RECORD_HEADER_EMITTER}u;
@@ -71,7 +83,7 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
     let em = particle_emitter_read(&emitters, emitter_index);
 
     particle_vm_reset();
-    particle_setup_context(em, slot, u_dt, u_time, 0.0, 0.0, u_frame);
+    particle_setup_context(em, slot, settings.u_dt, settings.u_time, 0.0, 0.0, settings.u_frame);
     particle_vm_execute(
         &program,
         em.update_offset * PARTICLE_INSTRUCTION_WORDS,
@@ -96,5 +108,4 @@ export const shader_particle_simulate = ComputeShader.from({
     label: "Particle Simulate",
     resources,
     body,
-    group_size: [PARTICLE_SIMULATE_WORKGROUP_SIZE, 1, 1],
 });

package/src/shade/renderer/particles/sort/shader_particle_sort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_sort.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/sort/shader_particle_sort.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,8CAA+C;AAyB/C,uDAKG;AA+DH,2DAKG;AA4BH,yDAKG;8BA9J2B,+BAA+B"}
+{"version":3,"file":"shader_particle_sort.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/sort/shader_particle_sort.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,8CAA+C;AAkC/C,uDAIG;AAyEH,2DAIG;AAqCH,yDAIG;8BAvL2B,+BAA+B"}

package/src/shade/renderer/particles/sort/shader_particle_sort.js

@@ -1,5 +1,6 @@
 import { atomic_u32, f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -31,21 +32,30 @@ export const PARTICLE_SORT_WORKGROUP_SIZE = 64;
 
 // --- reset pass ---
 
+/**
+ * Per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer.
+ *
+ * @type {WebGPUStruct}
+ */
+const SORT_RESET_SETTINGS = WebGPUStruct.from({
+    u_bucket_count: u32,
+}, 'ParticleSortResetSettings');
+
 const reset_resources = new ShaderResourceSetDescriptor();
+
+reset_resources.setImmediate('settings', SORT_RESET_SETTINGS);
 reset_resources.createGroup()
     .addStorageBuffer("histogram", WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer("cursor", WebGPUArray.from(atomic_u32), true)
-    .addUniform("u_bucket_count", u32);
-
+    .addStorageBuffer("cursor", WebGPUArray.from(atomic_u32), true);
 const reset_body = CodeChunk.from(/* wgsl */ `
 @compute @workgroup_size(${PARTICLE_SORT_WORKGROUP_SIZE}, 1, 1)
 fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
     let i = gid.x;
     if (i == 0u) {
         // The {count, elements} header the csdldf scan sizes itself from.
-        atomicStore(&histogram[0], u_bucket_count);
+        atomicStore(&histogram[0], settings.u_bucket_count);
     }
-    if (i < u_bucket_count) {
+    if (i < settings.u_bucket_count) {
         atomicStore(&histogram[1u + i], 0u);
         atomicStore(&cursor[i], 0u);
     }
@@ -56,7 +66,6 @@ export const shader_particle_sort_reset = ComputeShader.from({
     label: "Particle Sort Reset",
     resources: reset_resources,
     body: reset_body,
-    group_size: [PARTICLE_SORT_WORKGROUP_SIZE, 1, 1],
 });
 
 const READ_MAT4 = /* wgsl */ `
@@ -72,19 +81,29 @@ fn particle_read_mat4(m : ptr<storage, array<u32>, read>, o : u32) -> mat4x4<f32
 
 // --- histogram pass ---
 
+/**
+ * Per-dispatch, 16 bytes, read-only. Four uniforms meant four transient buffers per sort;
+ * WGSL allows one immediate per entry point, so they travel together.
+ *
+ * @type {WebGPUStruct}
+ */
+const SORT_HISTOGRAM_SETTINGS = WebGPUStruct.from({
+    u_near: f32,
+    u_far: f32,
+    u_bucket_count: u32,
+    u_count: u32,
+}, 'ParticleSortHistogramSettings');
+
 const histogram_resources = new ShaderResourceSetDescriptor();
+
+histogram_resources.setImmediate('settings', SORT_HISTOGRAM_SETTINGS);
 histogram_resources.createGroup()
     .addStorageBuffer("emitters", WebGPUArray.u32, false)
     .addStorageBuffer("pool", WebGPUArray.u32, false)
     .addStorageBuffer("alive", WebGPUArray.u32, false)
     .addStorageBuffer("view_matrix", WebGPUArray.u32, false)
     .addStorageBuffer("keys", WebGPUArray.u32, true)
-    .addStorageBuffer("histogram", WebGPUArray.from(atomic_u32), true)
-    .addUniform("u_near", f32)
-    .addUniform("u_far", f32)
-    .addUniform("u_bucket_count", u32)
-    .addUniform("u_count", u32);
-
+    .addStorageBuffer("histogram", WebGPUArray.from(atomic_u32), true);
 const histogram_body = CodeChunk.from(/* wgsl */ `
 const PARTICLE_RECORD_WORDS : u32 = ${PARTICLE_RECORD_WORD_COUNT}u;
 const PARTICLE_HEADER_EMITTER : u32 = ${PARTICLE_RECORD_HEADER_EMITTER}u;
@@ -95,7 +114,7 @@ ${READ_MAT4}
 @compute @workgroup_size(${PARTICLE_SORT_WORKGROUP_SIZE}, 1, 1)
 fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
     let i = gid.x;
-    if (i >= u_count) { return; }
+    if (i >= settings.u_count) { return; }
 
     let slot = alive[i];
     let base = slot * PARTICLE_RECORD_WORDS;
@@ -111,9 +130,9 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
     let view = particle_read_mat4(&view_matrix, 0u);
     let view_depth = -(view * vec4<f32>(world_pos, 1.0)).z;
 
-    let t = (view_depth - u_near) / max(u_far - u_near, 1e-6);
+    let t = (view_depth - settings.u_near) / max(settings.u_far - settings.u_near, 1e-6);
     let clamped = clamp(1.0 - t, 0.0, 1.0);
-    let bucket = min(u32(clamped * f32(u_bucket_count)), u_bucket_count - 1u);
+    let bucket = min(u32(clamped * f32(settings.u_bucket_count)), settings.u_bucket_count - 1u);
 
     keys[i] = bucket;
     atomicAdd(&histogram[1u + bucket], 1u);
@@ -124,25 +143,33 @@ export const shader_particle_sort_histogram = ComputeShader.from({
     label: "Particle Sort Histogram",
     resources: histogram_resources,
     body: histogram_body,
-    group_size: [PARTICLE_SORT_WORKGROUP_SIZE, 1, 1],
 });
 
 // --- scatter pass ---
 
+/**
+ * Per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer.
+ *
+ * @type {WebGPUStruct}
+ */
+const SORT_SCATTER_SETTINGS = WebGPUStruct.from({
+    u_count: u32,
+}, 'ParticleSortScatterSettings');
+
 const scatter_resources = new ShaderResourceSetDescriptor();
+
+scatter_resources.setImmediate('settings', SORT_SCATTER_SETTINGS);
 scatter_resources.createGroup()
     .addStorageBuffer("keys", WebGPUArray.u32, false)
     .addStorageBuffer("alive", WebGPUArray.u32, false)
     .addStorageBuffer("scanned", WebGPUArray.u32, false)
     .addStorageBuffer("cursor", WebGPUArray.from(atomic_u32), true)
-    .addStorageBuffer("sorted", WebGPUArray.u32, true)
-    .addUniform("u_count", u32);
-
+    .addStorageBuffer("sorted", WebGPUArray.u32, true);
 const scatter_body = CodeChunk.from(/* wgsl */ `
 @compute @workgroup_size(${PARTICLE_SORT_WORKGROUP_SIZE}, 1, 1)
 fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
     let i = gid.x;
-    if (i >= u_count) { return; }
+    if (i >= settings.u_count) { return; }
 
     let bucket = keys[i];
     // Exclusive offset = inclusive prefix sum up to bucket-1. With the count field at index 0 the
@@ -157,5 +184,4 @@ export const shader_particle_sort_scatter = ComputeShader.from({
     label: "Particle Sort Scatter",
     resources: scatter_resources,
     body: scatter_body,
-    group_size: [PARTICLE_SORT_WORKGROUP_SIZE, 1, 1],
 });

package/src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AccumulatingPathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH;IA8EI;;;OAGG;IACH,uCAgBC;IAhGD;;;;OAIG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,wBAFU,MAAM,CAEc;IAE9B;;;;OAIG;IACH,eAFU,OAAO,CAEK;IA+NtB;;;;;;OAMG;IACH,yCAFa,MAAM,CA4JlB;;CACJ"}
+{"version":3,"file":"AccumulatingPathTracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;GAcG;AACH;IA8EI;;;OAGG;IACH,uCAgBC;IAhGD;;;;OAIG;IACH,kBAFU,MAAM,CAEO;IAEvB;;;;OAIG;IACH,wBAFU,MAAM,CAEc;IAE9B;;;;OAIG;IACH,eAFU,OAAO,CAEK;IA+NtB;;;;;;OAMG;IACH,yCAFa,MAAM,CAyJlB;;CACJ"}

package/src/shade/renderer/path_tracer/accumulating/AccumulatingPathTracer.js

@@ -5,7 +5,7 @@ import { PerspectiveCamera } from "../../camera/PerspectiveCamera.js";
 import { GPUTextureContext } from "../../texture/GPUTextureContext.js";
 import { graph_flood_fill } from "./graph_flood_fill.js";
 import { graph_float32rgba_to_float16rgba } from "./graph_float32rgba_to_float16rgba.js";
-import { ACCUMULATING_RT_UNIFORMS_STRUCT, shader_accumulating_path_tracer } from "./shader_accumulating_path_tracer.js";
+import { shader_accumulating_path_tracer } from "./shader_accumulating_path_tracer.js";
 
 
 const RGBA32FLOAT_BYTES_PER_PIXEL = 16;
@@ -359,15 +359,12 @@ export class AccumulatingPathTracer {
                 [output_resource.width, output_resource.height, 1]
             );
 
-            const settings = context.encoder.allocateTransientValueBuffer(
-                ACCUMULATING_RT_UNIFORMS_STRUCT,
-                {
-                    tile_offset: [tile_offset_x, tile_offset_y],
-                    tile_size: tile_size,
-                    random_seed: random_seed,
-                    alpha: alpha,
-                }
-            );
+            const settings = {
+                tile_offset: [tile_offset_x, tile_offset_y],
+                tile_size: tile_size,
+                random_seed: random_seed,
+                alpha: alpha,
+            };
 
             shader_accumulating_path_tracer.dispatch({
                 encoder: context.encoder,

package/src/shade/renderer/path_tracer/accumulating/shader_accumulating_path_tracer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_accumulating_path_tracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/shader_accumulating_path_tracer.js"],"names":[],"mappings":"AAiBA,2DAKG;AA2EH,4DAIG;6BAnG0B,mCAAmC;8BAOlC,+BAA+B"}
+{"version":3,"file":"shader_accumulating_path_tracer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/accumulating/shader_accumulating_path_tracer.js"],"names":[],"mappings":"AAiBA,2DAKG;AA8EH,4DAIG;6BAtG0B,mCAAmC;8BAOlC,+BAA+B"}

package/src/shade/renderer/path_tracer/accumulating/shader_accumulating_path_tracer.js

@@ -22,6 +22,10 @@ export const ACCUMULATING_RT_UNIFORMS_STRUCT = WebGPUStruct.from({
     alpha: f32,
 });
 
+// per-dispatch, 24 bytes, read-only: immediate data rather than a uniform buffer. camera and the
+// material table beside it are scene state and stay bound.
+resources.setImmediate("settings", ACCUMULATING_RT_UNIFORMS_STRUCT);
+
 sr_create_group_RTX(resources);
 
 resources.createGroup()
@@ -33,7 +37,6 @@ resources.createGroup()
     .addTexture("tEnvironment", "unfilterable-float", "2d");
 
 resources.createGroup()
-    .addUniform("settings", ACCUMULATING_RT_UNIFORMS_STRUCT)
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addTexture("history_texture", "unfilterable-float", "2d")
     .addStorageTexture("output_texture", "rgba32float", "2d", "write-only");

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/bloom/shader_bloom_mix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_bloom_mix.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/bloom/shader_bloom_mix.js"],"names":[],"mappings":"AAsCA,2CAYG;4BA/CyB,6BAA6B"}
+{"version":3,"file":"shader_bloom_mix.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/bloom/shader_bloom_mix.js"],"names":[],"mappings":"AAwCA,2CAYG;4BAjDyB,6BAA6B"}