@woosh/meep-engine 3.12.0 → 3.13.0

package/src/shade/renderer/lightmap/bake/shader_lightmap_denoise_sh.js

@@ -1,192 +1,192 @@
-import {
-    VIZ_BUFFER_INVALID_MESH_VALUE
-} from "../../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
-import { ATORUS_UNIFORMS_STRUCT } from "../../postprocess/denoise/fragment_shader_denoise_ao.js";
-import { chunk_filter_gaussian } from "../../shader/chunk/filter/chunk_filter_gaussian.js";
-import {
-    METRO_L1_IRRADIANCE_STRUCT
-} from "../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ImageShader } from "../../shader/ImageShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
-import { chunk_texture_load_sh } from "./chunk_texture_load_sh.js";
-import { LIGHTMAP_SH_COLOR_TARGETS_DESCRIPTOR } from "./LIGHTMAP_SH_COLOR_TARGETS_DESCRIPTOR.js";
-import { LIGHTMAP_SH_FRAGMENT_OUTPUT } from "./LIGHTMAP_SH_FRAGMENT_OUTPUT.js";
-
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.createGroup()
-    .addUniform("settings", ATORUS_UNIFORMS_STRUCT);
-
-resources.createGroup()
-    .addTexture("viz_buffer", "uint")
-    .addTexture("lightmap_Y", "unfilterable-float")
-    .addTexture("lightmap_CoCg", "unfilterable-float")
-
-/**
- * We can use this to derive a single variance value
- * @type {CodeChunk}
- */
-export const chunk_estimate_sh_similarity = CodeChunk.from(
-    //language=WGSL
-    `
-fn estimate_sh_similarity(
-    a: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref},
-    b: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref}
-) -> f32 {
-    // extract dominant luma direction
-    // Metro encodes SH coeffcients in axis-aligned way (L11, L1_1, L10) with L00 being in forth position (w)
-    
-    let a_luma_direction = a.Y.xyz / a.Y.w;
-    let b_luma_direction = b.Y.xyz / b.Y.w;
-
-    const DIRECTION_PHI = 10.0;
-
-    // Soften the direction, so that there is always some similarity. The exponent argument is a
-    // DISTANCE (0 = aligned, 1 = opposite), so aligned directions get the highest weight.
-    let direction_similarity = exp( - max(0.0001, ( 1.0 - dot(a_luma_direction, b_luma_direction) ) * 0.5) / DIRECTION_PHI);
-    
-    const LUMA_PHI = 10.0;
-    
-    let luma_similarity = exp( - max(0.0001, abs( a.Y.w - b.Y.w )) / LUMA_PHI);
-    
-    const COLOR_PHI = 3.0;
-    
-    let color_similarity = exp( min(0.0, -dot(vec2(a.CoCg * a.Y.w), vec2(b.CoCg * b.Y.w))) / COLOR_PHI );
-    
-    return luma_similarity * color_similarity * direction_similarity;
-}
-    `, [
-        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
-    ]
-);
-
-const chunk_edge_stopping_weight = CodeChunk.from(
-    //language=WGSL
-    `
-fn edge_stopping_weight(
-    center_viz: vec2u,
-    sample_viz: vec2u,
-    center_sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref},
-    sample_sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref},
-) -> f32{
-    var result: f32 = 1.0;
-    
-    // different meshes
-    result *= select(0.0,1.0,center_viz.x == sample_viz.x);
-    
-    result *= estimate_sh_similarity(center_sh, sample_sh);
-    
-    return saturate(result);
-}
-    `, [
-        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
-        chunk_estimate_sh_similarity
-    ]
-);
-
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-
-@fragment
-fn main(
-    @builtin(position) coord: vec4<f32>,
-) -> ${LIGHTMAP_SH_FRAGMENT_OUTPUT.wgsl_ref}{
-    let ipos = vec2<i32>(coord.xy);
-    let screen_size = vec2<i32>(textureDimensions(lightmap_Y));
-
-    let center_sh = texture_load_sh(ipos);
-    
-    var accummulated_sample = center_sh;
-    var sum_weight = 1.0;
-    
-    let center_viz = textureLoad(viz_buffer, ipos, 0).rg;
-    
-    if(center_viz.x == ${VIZ_BUFFER_INVALID_MESH_VALUE}){
-        // not a valid sample
-        discard ;
-    }
-    
-    // TODO compute variance and mean
-    //      use similarity measure code for variance
-    
-    // TODO drive blur using variance
-    
-    // TODO use G-buffer to drive world-space edge-weight metric
-    
-    // TODO for texels with very high variance we can relax the directional component (L1 of SH)
-    
-    const KERNEL_SIZE = 7;
-    
-    for(var y = -KERNEL_SIZE; y <= KERNEL_SIZE; y++){
-        for(var x = -KERNEL_SIZE; x <= KERNEL_SIZE; x++){
-            
-            if(x == 0 && y == 0){
-                // skip center sample
-                continue;
-            }
-            
-            let offset = vec2<i32>(x, y);
-                
-            let p      = ipos + offset;
-            let inside = all(p >= vec2(0, 0)) && all(p < screen_size);
-            
-            if(!inside){
-                continue;
-            }
-            
-            const GAUSSIAN_SIGMA =  KERNEL_SIZE*0.25;
-            
-            let kernel = filter_gaussian( GAUSSIAN_SIGMA, f32(x) ) * filter_gaussian( GAUSSIAN_SIGMA, f32(y) );
-            
-            let sample_viz = textureLoad(viz_buffer, p, 0).rg;
-            
-            let sample_sh = texture_load_sh(p);
-            
-            // edge-stopping function
-            let edge_weight = edge_stopping_weight(
-                center_viz,
-                sample_viz,
-                center_sh,
-                sample_sh
-            );
-            
-            let weight = edge_weight * kernel;
-            
-            
-            accummulated_sample.Y += sample_sh.Y * weight;
-            accummulated_sample.CoCg += sample_sh.CoCg * weight;
-            
-            sum_weight += weight;
-            
-        }
-    }
-    
-    accummulated_sample.Y /= sum_weight;
-    accummulated_sample.CoCg /= sum_weight;
-    
-    return ${LIGHTMAP_SH_FRAGMENT_OUTPUT.make({
-        Y:"accummulated_sample.Y",
-        CoCg:"accummulated_sample.CoCg"
-    })};
-}
-`, [
-        chunk_edge_stopping_weight,
-        chunk_texture_load_sh,
-        LIGHTMAP_SH_FRAGMENT_OUTPUT.declaration_chunk,
-        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
-        chunk_filter_gaussian,
-    ]);
-
-export const shader_lightmap_denoise_sh = ImageShader.from({
-    descriptor: ShaderDescriptor.from({
-        label: "Light Map / denoise SH",
-        body,
-        resources,
-    }),
-    targets: LIGHTMAP_SH_COLOR_TARGETS_DESCRIPTOR
+import {
+    VIZ_BUFFER_INVALID_MESH_VALUE
+} from "../../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
+import { ATORUS_UNIFORMS_STRUCT } from "../../postprocess/denoise/fragment_shader_denoise_ao.js";
+import { chunk_filter_gaussian } from "../../shader/chunk/filter/chunk_filter_gaussian.js";
+import {
+    METRO_L1_IRRADIANCE_STRUCT
+} from "../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { chunk_texture_load_sh } from "./chunk_texture_load_sh.js";
+import { LIGHTMAP_SH_COLOR_TARGETS_DESCRIPTOR } from "./LIGHTMAP_SH_COLOR_TARGETS_DESCRIPTOR.js";
+import { LIGHTMAP_SH_FRAGMENT_OUTPUT } from "./LIGHTMAP_SH_FRAGMENT_OUTPUT.js";
+
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-pass, four bytes, read-only: immediate data rather than a uniform buffer
+resources.setImmediate("settings", ATORUS_UNIFORMS_STRUCT);
+
+resources.createGroup()
+    .addTexture("viz_buffer", "uint")
+    .addTexture("lightmap_Y", "unfilterable-float")
+    .addTexture("lightmap_CoCg", "unfilterable-float")
+
+/**
+ * We can use this to derive a single variance value
+ * @type {CodeChunk}
+ */
+export const chunk_estimate_sh_similarity = CodeChunk.from(
+    //language=WGSL
+    `
+fn estimate_sh_similarity(
+    a: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref},
+    b: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref}
+) -> f32 {
+    // extract dominant luma direction
+    // Metro encodes SH coeffcients in axis-aligned way (L11, L1_1, L10) with L00 being in forth position (w)
+    
+    let a_luma_direction = a.Y.xyz / a.Y.w;
+    let b_luma_direction = b.Y.xyz / b.Y.w;
+
+    const DIRECTION_PHI = 10.0;
+
+    // Soften the direction, so that there is always some similarity. The exponent argument is a
+    // DISTANCE (0 = aligned, 1 = opposite), so aligned directions get the highest weight.
+    let direction_similarity = exp( - max(0.0001, ( 1.0 - dot(a_luma_direction, b_luma_direction) ) * 0.5) / DIRECTION_PHI);
+    
+    const LUMA_PHI = 10.0;
+    
+    let luma_similarity = exp( - max(0.0001, abs( a.Y.w - b.Y.w )) / LUMA_PHI);
+    
+    const COLOR_PHI = 3.0;
+    
+    let color_similarity = exp( min(0.0, -dot(vec2(a.CoCg * a.Y.w), vec2(b.CoCg * b.Y.w))) / COLOR_PHI );
+    
+    return luma_similarity * color_similarity * direction_similarity;
+}
+    `, [
+        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
+    ]
+);
+
+const chunk_edge_stopping_weight = CodeChunk.from(
+    //language=WGSL
+    `
+fn edge_stopping_weight(
+    center_viz: vec2u,
+    sample_viz: vec2u,
+    center_sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref},
+    sample_sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref},
+) -> f32{
+    var result: f32 = 1.0;
+    
+    // different meshes
+    result *= select(0.0,1.0,center_viz.x == sample_viz.x);
+    
+    result *= estimate_sh_similarity(center_sh, sample_sh);
+    
+    return saturate(result);
+}
+    `, [
+        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
+        chunk_estimate_sh_similarity
+    ]
+);
+
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+) -> ${LIGHTMAP_SH_FRAGMENT_OUTPUT.wgsl_ref}{
+    let ipos = vec2<i32>(coord.xy);
+    let screen_size = vec2<i32>(textureDimensions(lightmap_Y));
+
+    let center_sh = texture_load_sh(ipos);
+    
+    var accummulated_sample = center_sh;
+    var sum_weight = 1.0;
+    
+    let center_viz = textureLoad(viz_buffer, ipos, 0).rg;
+    
+    if(center_viz.x == ${VIZ_BUFFER_INVALID_MESH_VALUE}){
+        // not a valid sample
+        discard ;
+    }
+    
+    // TODO compute variance and mean
+    //      use similarity measure code for variance
+    
+    // TODO drive blur using variance
+    
+    // TODO use G-buffer to drive world-space edge-weight metric
+    
+    // TODO for texels with very high variance we can relax the directional component (L1 of SH)
+    
+    const KERNEL_SIZE = 7;
+    
+    for(var y = -KERNEL_SIZE; y <= KERNEL_SIZE; y++){
+        for(var x = -KERNEL_SIZE; x <= KERNEL_SIZE; x++){
+            
+            if(x == 0 && y == 0){
+                // skip center sample
+                continue;
+            }
+            
+            let offset = vec2<i32>(x, y);
+                
+            let p      = ipos + offset;
+            let inside = all(p >= vec2(0, 0)) && all(p < screen_size);
+            
+            if(!inside){
+                continue;
+            }
+            
+            const GAUSSIAN_SIGMA =  KERNEL_SIZE*0.25;
+            
+            let kernel = filter_gaussian( GAUSSIAN_SIGMA, f32(x) ) * filter_gaussian( GAUSSIAN_SIGMA, f32(y) );
+            
+            let sample_viz = textureLoad(viz_buffer, p, 0).rg;
+            
+            let sample_sh = texture_load_sh(p);
+            
+            // edge-stopping function
+            let edge_weight = edge_stopping_weight(
+                center_viz,
+                sample_viz,
+                center_sh,
+                sample_sh
+            );
+            
+            let weight = edge_weight * kernel;
+            
+            
+            accummulated_sample.Y += sample_sh.Y * weight;
+            accummulated_sample.CoCg += sample_sh.CoCg * weight;
+            
+            sum_weight += weight;
+            
+        }
+    }
+    
+    accummulated_sample.Y /= sum_weight;
+    accummulated_sample.CoCg /= sum_weight;
+    
+    return ${LIGHTMAP_SH_FRAGMENT_OUTPUT.make({
+        Y:"accummulated_sample.Y",
+        CoCg:"accummulated_sample.CoCg"
+    })};
+}
+`, [
+        chunk_edge_stopping_weight,
+        chunk_texture_load_sh,
+        LIGHTMAP_SH_FRAGMENT_OUTPUT.declaration_chunk,
+        METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
+        chunk_filter_gaussian,
+    ]);
+
+export const shader_lightmap_denoise_sh = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "Light Map / denoise SH",
+        body,
+        resources,
+    }),
+    targets: LIGHTMAP_SH_COLOR_TARGETS_DESCRIPTOR
 })

package/src/shade/renderer/lightmap/bake/tile/shader_lightmap_accummulate_tile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_lightmap_accummulate_tile.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/lightmap/bake/tile/shader_lightmap_accummulate_tile.js"],"names":[],"mappings":"AAoDA,2DA8BE;4BA7E0B,gCAAgC"}
+{"version":3,"file":"shader_lightmap_accummulate_tile.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/lightmap/bake/tile/shader_lightmap_accummulate_tile.js"],"names":[],"mappings":"AAuDA,2DA8BE;4BAhF0B,gCAAgC"}

package/src/shade/renderer/lightmap/bake/tile/shader_lightmap_accummulate_tile.js

@@ -1,83 +1,86 @@
-import { vec2u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../../../material/resident/INDIRECT_MATERIAL_ARRAY_TYPE.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ImageShader } from "../../../shader/ImageShader.js";
-import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
-import { sr_create_group_RTX } from "../../../geometry/sr_create_group_RTX.js";
-
-const PUSH_CONSTANTS = WebGPUStruct.from({
-    /**
-     * Offset into the light map where the tile maps onto
-     */
-    offset: vec2u,
-
-});
-
-const resources = new ShaderResourceSetDescriptor();
-
-sr_create_group_RTX(resources);
-
-resources.createGroup()
-    .addUniform("materials", INDIRECT_MATERIAL_ARRAY_TYPE)
-    .addTexture("textures", "unfilterable-float", "2d-array")
-    .addTexture("tNoise", "uint")
-
-resources.createGroup()
-    .addStorageBuffer("light_data", WebGPUArray.u32)
-    .addTexture("tEnvironment", "unfilterable-float", "2d")
-
-resources.createGroup()
-    .addUniform("settings", PUSH_CONSTANTS)
-    .addTexture("viz_buffer", "uint") // [mesh, triangle]
-
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-
-@fragment
-fn main(
-    @builtin(position) coord: vec4<f32>,
-) -> @location(0) vec4<f32>{
-    
-    let ipos = vec2<i32>(coord.xy);
-    
-    
-}
-    `
-);
-
-export const shader_lightmap_accummulate_tile = ImageShader.from({
-    descriptor: ShaderDescriptor.from({
-        label: "Lightmap accummulate tile",
-        body,
-        resources,
-    }),
-    targets: [
-        // Y
-        {
-            format: "rgba32float",
-            blend: {
-                color: {
-                    operation: "add",
-                    srcFactor: "one",
-                    dstFactor: "one",
-                }
-            }
-        },
-        // CoCg
-        {
-            format: "rg32float",
-            blend: {
-                color: {
-                    operation: "add",
-                    srcFactor: "one",
-                    dstFactor: "one",
-                }
-            }
-        }
-    ]
+import { vec2u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { INDIRECT_MATERIAL_ARRAY_TYPE } from "../../../material/resident/INDIRECT_MATERIAL_ARRAY_TYPE.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ImageShader } from "../../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { sr_create_group_RTX } from "../../../geometry/sr_create_group_RTX.js";
+
+const PUSH_CONSTANTS = WebGPUStruct.from({
+    /**
+     * Offset into the light map where the tile maps onto
+     */
+    offset: vec2u,
+
+});
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, eight bytes, read-only: immediate data rather than a uniform buffer. The material
+// table beside it is scene state and stays bound.
+resources.setImmediate("settings", PUSH_CONSTANTS);
+
+sr_create_group_RTX(resources);
+
+resources.createGroup()
+    .addUniform("materials", INDIRECT_MATERIAL_ARRAY_TYPE)
+    .addTexture("textures", "unfilterable-float", "2d-array")
+    .addTexture("tNoise", "uint")
+
+resources.createGroup()
+    .addStorageBuffer("light_data", WebGPUArray.u32)
+    .addTexture("tEnvironment", "unfilterable-float", "2d")
+
+resources.createGroup()
+    .addTexture("viz_buffer", "uint") // [mesh, triangle]
+
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+) -> @location(0) vec4<f32>{
+    
+    let ipos = vec2<i32>(coord.xy);
+    
+    
+}
+    `
+);
+
+export const shader_lightmap_accummulate_tile = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "Lightmap accummulate tile",
+        body,
+        resources,
+    }),
+    targets: [
+        // Y
+        {
+            format: "rgba32float",
+            blend: {
+                color: {
+                    operation: "add",
+                    srcFactor: "one",
+                    dstFactor: "one",
+                }
+            }
+        },
+        // CoCg
+        {
+            format: "rg32float",
+            blend: {
+                color: {
+                    operation: "add",
+                    srcFactor: "one",
+                    dstFactor: "one",
+                }
+            }
+        }
+    ]
 })

package/src/shade/renderer/particles/graph_particles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_particles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;IApBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,GAAG;QACI,QAAQ;QACR,OAAO;QACP,SAAS;QACT,IAAI;QACJ,UAAU;QACV,WAAW;QACX,IAAI;QACJ,QAAQ;QACR,cAAc;QACd,aAAa;QACb,SAAS;;IAChB,QAAQ,EAAvB,MAAM;IACS,KAAK;QACC,EAAE,EAAvB,MAAM;QACe,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;QACe,WAAW,EAAhC,MAAM;;;;;;;;EAoFhB"}
+{"version":3,"file":"graph_particles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;IApBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,GAAG;QACI,QAAQ;QACR,OAAO;QACP,SAAS;QACT,IAAI;QACJ,UAAU;QACV,WAAW;QACX,IAAI;QACJ,QAAQ;QACR,cAAc;QACd,aAAa;QACb,SAAS;;IAChB,QAAQ,EAAvB,MAAM;IACS,KAAK;QACC,EAAE,EAAvB,MAAM;QACe,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;QACe,WAAW,EAAhC,MAAM;;;;;;;;EAsFhB"}

package/src/shade/renderer/particles/graph_particles.js

@@ -92,8 +92,10 @@ export function graph_particles({ graph, gpu, capacity, frame }) {
             bindings: {
                 emitters: gr_emitters, program: gr_program, vm_constants: gr_constants,
                 pool, spawn_requests: gr_spawn, alive_out: alive_write, dead, counters,
-                u_dt: frame.dt, u_time: frame.time, u_frame: frame.index,
-                u_count: frame.spawn_count, u_capacity: capacity,
+                settings: {
+                    u_dt: frame.dt, u_time: frame.time, u_frame: frame.index,
+                    u_count: frame.spawn_count, u_capacity: capacity,
+                },
             },
             group_count: [Math.ceil(frame.spawn_count / PARTICLE_EMIT_WORKGROUP_SIZE), 1, 1],
         });
@@ -111,7 +113,7 @@ export function graph_particles({ graph, gpu, capacity, frame }) {
             bindings: {
                 emitters: gr_emitters, program: gr_program, vm_constants: gr_constants,
                 pool, alive_in: gr_alive_read, alive_out: alive_write, dead, counters,
-                u_dt: frame.dt, u_time: frame.time, u_frame: frame.index,
+                settings: { u_dt: frame.dt, u_time: frame.time, u_frame: frame.index },
             },
             command: gr_dispatch,
         });

package/src/shade/renderer/particles/prototypeParticleSystem.js

@@ -177,7 +177,6 @@ async function main() {
         if (requests.length > 0) device.queue.writeBuffer(spawnRequests, 0, requests);
 
         const cmd = ShadeGPUCommandContext.create(graphics);
-        const u = (type, value) => cmd.allocateTransientValueBuffer(type, value, GPUBufferUsage.UNIFORM);
         const colorView = context.getCurrentTexture().createView();
 
         // --- geometry pass: clear colour + reverse-Z depth (far = 0), lit, writes depth ---
@@ -196,19 +195,19 @@ async function main() {
         if (requests.length > 0) {
             shader_particle_emit.dispatchThreads({
                 encoder: cmd,
-                bindings: { emitters, program, vm_constants: constants, pool, spawn_requests: spawnRequests, alive_out: aliveWrite, dead, counters, u_dt: u(f32, dt), u_time: u(f32, now / 1000), u_frame: u(u32, system.frame), u_count: u(u32, requests.length), u_capacity: u(u32, CAPACITY) },
+                bindings: { emitters, program, vm_constants: constants, pool, spawn_requests: spawnRequests, alive_out: aliveWrite, dead, counters, settings: { u_dt: dt, u_time: now / 1000, u_frame: system.frame, u_count: requests.length, u_capacity: CAPACITY } },
                 thread_count_x: requests.length,
             });
         }
         shader_particle_simulate.dispatchIndirect({
             encoder: cmd,
-            bindings: { emitters, program, vm_constants: constants, pool, alive_in: aliveRead, alive_out: aliveWrite, dead, counters, u_dt: u(f32, dt), u_time: u(f32, now / 1000), u_frame: u(u32, system.frame) },
+            bindings: { emitters, program, vm_constants: constants, pool, alive_in: aliveRead, alive_out: aliveWrite, dead, counters, settings: { u_dt: dt, u_time: now / 1000, u_frame: system.frame } },
             command: dispatchArgs,
         });
         // Snapshot the final alive count (next frame's simulate input) + write this frame's draw args.
         shader_particle_build_indirect.dispatch({
             encoder: cmd,
-            bindings: { counters, dispatch_args: dispatchArgs, draw_args: drawArgs, u_workgroup_size: u(u32, PARTICLE_SIMULATE_WORKGROUP_SIZE) },
+            bindings: { counters, dispatch_args: dispatchArgs, draw_args: drawArgs, u_workgroup_size: PARTICLE_SIMULATE_WORKGROUP_SIZE },
             group_count_x: 1,
         });
 

package/src/shade/renderer/particles/shaders/shader_particle_emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;GAYG;AAEH,2CAHU,aAAa,CAGwB;AA+E/C,iDAIG;8BAlH2B,+BAA+B"}
+{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;GAYG;AAEH,2CAHU,aAAa,CAGwB;AA6F/C,iDAIG;8BAhI2B,+BAA+B"}