@woosh/meep-engine 3.60.9 → 3.61.1

package/src/shade/renderer/buffer/util/shader_buffer_copy_storage_to_storage.js

@@ -1,44 +1,49 @@
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer holding one u32
-resources.setImmediate("size", u32);
-
-resources.createGroup()
-    .addStorageBuffer("source", WebGPUArray.u32)
-    .addStorageBuffer("destination", WebGPUArray.u32, true)
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${COMPUTE_SHADER_DEFAULT_GROUP_SIZE})
-fn main(
-    @builtin(global_invocation_id) global_id : vec3<u32>
-){
-    let index = global_id.x;
-     
-    if(index >= size){
-        return;
-    }
-    
-    destination[index] = source[index];
-}
-    `
-)
-
-/**
- * Shader is useful for copying buffers where the buffers are missing `GPUBufferUsage.COPY_DST` or `GPUBufferUsage.COPY_SRC`.
- * This is a pure utility shader.
- * @type {ComputeShader}
- */
-export const shader_buffer_copy_storage_to_storage = ComputeShader.from({
-    label: "Copy GPU Buffer/ STORAGE -> STORAGE",
-    body,
-    resources,
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer holding one u32
+resources.setImmediate("size", u32);
+
+resources.createGroup()
+    .addStorageBuffer("source", WebGPUArray.u32)
+    .addStorageBuffer("destination", WebGPUArray.u32, true)
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${COMPUTE_SHADER_DEFAULT_GROUP_SIZE})
+fn main(
+    @builtin(global_invocation_id) global_id : vec3<u32>,
+    @builtin(num_workgroups) group_count : vec3<u32>,
+){
+    // The grid may be smaller than the copy; every lane keeps taking the next word a whole grid on.
+    let stride = group_count.x * ${COMPUTE_SHADER_DEFAULT_GROUP_SIZE}u;
+
+    for (var index = global_id.x; index < size; index += stride) {
+        destination[index] = source[index];
+    }
+}
+    `
+)
+
+/**
+ * Shader is useful for copying buffers where the buffers are missing `GPUBufferUsage.COPY_DST` or `GPUBufferUsage.COPY_SRC`.
+ * This is a pure utility shader.
+ *
+ * Copies the first `size` words. The launch may be smaller than that — a copy longer than
+ * `maxComputeWorkgroupsPerDimension` workgroups has to be — and every lane strides through the rest
+ * by the whole grid, so a caller that clamps the launch still has every word copied.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_buffer_copy_storage_to_storage = ComputeShader.from({
+    label: "Copy GPU Buffer/ STORAGE -> STORAGE",
+    body,
+    resources,
 });

package/src/shade/renderer/material/GPUMaterialManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA4NA;IA4FI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IAlJD;;;;;OAKG;IACH,wBAAkC;IAOlC;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IAsLD;;;;;;;;;;OAUG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,cAAc,EAA9B,MAAM;QAEJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CA4LnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;;OAOG;IACH,wBAHW,aAAa,EAAE,GACb,kBAAkB,EAAE,CAIhC;IAED;;;;OAIG;IACH,uCAEC;IAED;;;;OAIG;IACH,oCAEC;IAuED;;;OAGG;IACH,YAFW,sBAAsB,QAmChC;;CAEJ;8BAh6BY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAtBzE,yBAAyB;mCAjBG,8CAA8C;oCAoBxB,mCAAmC"}
+{"version":3,"file":"GPUMaterialManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/GPUMaterialManager.js"],"names":[],"mappings":"AA8QA;IA4FI;;;;;;;;OAQG;IACH,yCANW,cAAc,oBACd,qBAAqB,YACrB,gBAAgB,qBAChB,qBAAqB,aACrB,iBAAiB,EAiD3B;IAlJD;;;;;OAKG;IACH,wBAAkC;IAOlC;;;OAGG;IACH,UAFU,IAAI,aAAa,EAAE,kBAAkB,CAAC,CAE3B;IAyBrB;;;OAGG;IACH,yCAEC;IAID;;;OAGG;IACH,sBAEC;IA0LD;;;;;;;;;;OAUG;IACH;QAR+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACE,gBAAgB,EAAhC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,cAAc,EAA9B,MAAM;QAEJ;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAmNnF;IAED;;;;OAIG;IACH,iBAHW,aAAa,GACX,kBAAkB,CAqB9B;IAED;;;;;;;;;;;;OAYG;IACH,kBAHW,aAAa,GACX,OAAO,CAyBnB;IAED;;;;OAIG;IACH,gBAaC;IAED;;;;;;;OAOG;IACH,0BAFW,eAAe,QAazB;IAED;;;;;;;;;;;OAWG;IACH,kBAHW,qBAAqB,GACnB,QAAQ,IAAI,CAAC,CAMzB;IAsBD;;;;;;OAMG;IACH,0BAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;OAMG;IACH,wBAHW,aAAa,EAAE,GACb,aAAa,EAAE,CAI3B;IAED;;;;;;;OAOG;IACH,wBAHW,aAAa,EAAE,GACb,kBAAkB,EAAE,CAIhC;IAED;;;;OAIG;IACH,uCAEC;IAED;;;;OAIG;IACH,oCAEC;IA4ED;;;OAGG;IACH,YAFW,sBAAsB,QAmChC;;CAEJ;8BA5+BY,OAAO,0CAA0C,EAAE,eAAe;6BAClE,OAAO,2BAA2B,EAAE,cAAc;yBAIlD,OAAO,2DAA2D,EAAE,UAAU;qCAC9E,OAAO,wCAAwC,EAAE,sBAAsB;oCACvE,OAAO,gDAAgD,EAAE,qBAAqB;+BAC9E,OAAO,gCAAgC,EAAE,gBAAgB;gCACzD,OAAO,yBAAyB,EAAE,iBAAiB;6BACnD,OAAO,8BAA8B,EAAE,cAAc;oCACrD,OAAO,6CAA6C,EAAE,qBAAqB;4BAC3E,OAAO,oBAAoB,EAAE,aAAa;oCAC1C,OAAO,qCAAqC,EAAE,qBAAqB;mCAtBzE,yBAAyB;mCArBG,8CAA8C;oCAwBxB,mCAAmC"}

package/src/shade/renderer/material/GPUMaterialManager.js

@@ -3,9 +3,11 @@ import Signal from "../../../core/events/signal/Signal.js";
 import { BindGroupLayoutDescriptor } from "../../descriptor/binding/BindGroupLayoutDescriptor.js";
 import { BufferBindingLayout } from "../../descriptor/binding/BufferBindingLayout.js";
 import { GPUShaderStage } from "../../descriptor/GPUShaderStage.js";
+import { wgsl_enable_extension } from "../../descriptor/WebGPUExtensionType.js";
 import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js";
 import { TextureDescriptor } from "../../descriptor/texture/TextureDescriptor.js";
+import { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescriptor.js";
 import { TextureResourceDescriptor } from "../../device/graph/TextureResourceDescriptor.js";
 import { BindGroupDescriptor } from "../binding/BindGroupDescriptor.js";
 import { GPUSingleTypeTable } from "../buffer/table/single/GPUSingleTypeTable.js";
@@ -15,6 +17,10 @@ import {
     VIZ_BUFFER_INVALID_MESH_VALUE
 } from "../rasterize/native/viz/VIZ_BUFFER_INVALID_MESH_VALUE.js";
 import { chunk_scene_database_access } from "../scene/chunk_scene_database_access.js";
+import {
+    chunk_subgroup_bitset_or,
+    SUBGROUP_BITSET_OR_NONE
+} from "../shader/chunk/subgroup/chunk_subgroup_bitset_or.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR } from "../texture/DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR.js";
 import { BLACK_PIXEL_TEXTURE } from "../texture/util/BLACK_PIXEL_TEXTURE.js";
@@ -86,6 +92,13 @@ class DrawnMaterialLists {
      * @type {number}
      */
     gbuffer_version = -1;
+
+    /**
+     * One past the highest material id in {@link gbuffer}, 0 when it is empty.
+     *
+     * @type {number}
+     */
+    gbuffer_id_bound = 0;
 }
 
 /**
@@ -149,10 +162,80 @@ const MATERIAL_BUFFER_BIND_GROUP_1_LAYOUT_DESCRIPTOR = BindGroupLayoutDescriptor
             binding: 0,
             visibility: GPUShaderStage.FRAGMENT,
             buffer: BufferBindingLayout.readOnlyStorage
+        },
+        {
+            binding: 1,
+            visibility: GPUShaderStage.FRAGMENT,
+            buffer: BufferBindingLayout.storage
         }
     ]
 });
 
+/**
+ * The material-depth pass's fragment stage: writes the material id of each pixel as its depth, for
+ * the G-buffer pass to test against, and marks in `material_seen` every material that holds a pixel.
+ *
+ * @type {CodeChunk}
+ */
+const material_depth_fragment = CodeChunk.from(
+    // language=WGSL
+    `
+        @group(0) @binding(0) var mesh_texture: texture_2d<u32>;
+        @group(1) @binding(0) var<storage, read> scene_database: array<u32>;
+        @group(1) @binding(1) var<storage, read_write> material_seen: array<atomic<u32>>;
+
+        struct Outputs{
+            @builtin(frag_depth) depth:f32,
+        }
+
+        @fragment
+        fn main(
+            @builtin(position) coord : vec4<f32>
+        ) -> Outputs {
+
+            let pixel = vec2<u32>(coord.xy);
+
+            var material = ${SUBGROUP_BITSET_OR_NONE}u;
+
+            // a helper invocation past the edge of the target holds no material, so it marks nothing
+            if(all(pixel < textureDimensions(mesh_texture))){
+                let mesh_id = textureLoad(
+                    mesh_texture,
+                    pixel,
+                    0
+                ).r;
+
+                if(mesh_id != ${VIZ_BUFFER_INVALID_MESH_VALUE}){
+                    material = scene_read_mesh(&scene_database, mesh_id).material;
+                }
+            }
+
+            // the G-buffer pass draws only the materials marked here
+            subgroup_bitset_or(&material_seen, material);
+
+            if(material == ${SUBGROUP_BITSET_OR_NONE}u){
+                return Outputs(1.0);
+            }
+
+            return Outputs(
+                f32(material)/16777216
+            );
+        }
+    `,
+    [chunk_scene_database_access, chunk_subgroup_bitset_or]
+);
+
+/**
+ * @param {{text: string, extensions: string[]}} compiled
+ * @returns {string} `compiled.text` after the `enable` directives its extensions need
+ */
+function wgsl_with_enables(compiled) {
+    return [
+        ...compiled.extensions.map(extension => `enable ${wgsl_enable_extension(extension)};`),
+        compiled.text
+    ].join("\n");
+}
+
 const material_buffer_pipeline_descriptor = RenderPipelineDescriptor.from({
     layout: {
         bindGroupLayouts: [
@@ -168,40 +251,7 @@ const material_buffer_pipeline_descriptor = RenderPipelineDescriptor.from({
     fragment: {
         module: {
             label: 'MeshDepth writer',
-            // language=WGSL
-            code: CodeChunk.from(
-                `
-                    @group(0) @binding(0) var mesh_texture: texture_2d<u32>;
-                    @group(1) @binding(0) var<storage, read> scene_database: array<u32>;
-
-                    struct Outputs{
-                        @builtin(frag_depth) depth:f32,
-                    }
-
-                    @fragment
-                    fn main(
-                        @builtin(position) coord : vec4<f32>
-                    ) -> Outputs {
-
-                        let mesh_id = textureLoad(
-                            mesh_texture,
-                            vec2<i32>(coord.xy),
-                            0
-                        ).r;
-
-                        if(mesh_id == ${VIZ_BUFFER_INVALID_MESH_VALUE}){
-                            return Outputs(1.0);
-                        }
-
-                        let mesh = scene_read_mesh(&scene_database, mesh_id);
-
-                        return Outputs(
-                            f32(mesh.material)/16777216
-                        );
-                    }
-                    `,
-                [chunk_scene_database_access]
-            ).compile().text
+            code: wgsl_with_enables(material_depth_fragment.compile())
         },
     },
     depthStencil: {
@@ -406,12 +456,15 @@ export class GPUMaterialManager {
      * @param {GPUViewContext} view
      * @param {GPUTextureContext} mesh_texture
      * @param {GPUTextureContext} material_depth_texture
+     * @param {GPUBufferBinding} material_seen zeroed, a bit per material id, set for each material
+     *   that holds a pixel
      */
     #prepare_material_depth_buffer(
         encoder,
         view,
         mesh_texture,
         material_depth_texture,
+        material_seen,
     ) {
 
         const pass = encoder.beginRenderPass({
@@ -449,6 +502,7 @@ export class GPUMaterialManager {
             MATERIAL_BUFFER_BIND_GROUP_1_LAYOUT_DESCRIPTOR,
             [
                 { buffer: view.scene.scene_database_buffer },
+                material_seen,
             ]
         ));
 
@@ -501,6 +555,13 @@ export class GPUMaterialManager {
 
             const material_depth = resources.get(data.material_depth);
 
+            // the pool may hand over a larger buffer than asked for; past the size asked for, it is
+            // not cleared
+            const material_seen = {
+                buffer: resources.get(data.material_seen),
+                size: data.material_seen_size,
+            };
+
             const encoder = context.encoder;
 
             encoder.pushDebugGroup("Material Draw")
@@ -513,6 +574,7 @@ export class GPUMaterialManager {
                 view,
                 viz_mesh,
                 material_depth,
+                material_seen,
             );
 
             const pass = encoder.beginRenderPass({
@@ -559,6 +621,7 @@ export class GPUMaterialManager {
                         viz_mesh.obtainView(),
                         { buffer: view.uniform_buffer.buffer },
                         { buffer: view.camera.buffer.buffer },
+                        material_seen,
                     ]
                 )
             );
@@ -600,7 +663,8 @@ export class GPUMaterialManager {
 
                 pass.setBindGroup(0, material_ctx.material_binding);
 
-                // the id rides in the instance index — the vertex stage binds nothing
+                // the id rides in the instance index; a material with no pixel in the view draws a
+                // triangle of no area, see material_gbuffer_vertex_shader_code
                 pass.draw(3, 1, 0, material_ctx.material_id);
             }
 
@@ -651,6 +715,19 @@ export class GPUMaterialManager {
             })
         );
 
+        // a bit for every id the list holds now; one that joins before the pass runs is past the end
+        // and drawn as though seen
+        this.#gbuffer_contexts(view.scene.drawn_materials);
+
+        const id_bound = this.#lists_of(view.scene.drawn_materials).gbuffer_id_bound;
+        const material_seen_words = Math.max(1, Math.ceil(id_bound / 32));
+
+        pass_data.material_seen_size = material_seen_words * 4;
+        pass_data.material_seen = pass.create(
+            'material seen',
+            BufferResourceDescriptor.empty(pass_data.material_seen_size, GPUBufferUsage.STORAGE)
+        );
+
         return {
             g_pbr: pass_data.g_pbr,
             g_normal: pass_data.g_normal,
@@ -867,6 +944,8 @@ export class GPUMaterialManager {
 
             contexts.length = 0;
 
+            let id_bound = 0;
+
             for (let i = 0; i < sorted.length; i++) {
                 const material = sorted[i];
 
@@ -882,8 +961,11 @@ export class GPUMaterialManager {
                 }
 
                 contexts.push(material_ctx);
+
+                id_bound = Math.max(id_bound, material_ctx.material_id + 1);
             }
 
+            lists.gbuffer_id_bound = id_bound;
             lists.gbuffer_version = this.#list_version;
         }
 

package/src/shade/renderer/material/standard/fragment_gbuffer.d.ts

@@ -10,7 +10,7 @@ export function add_g_buffer_viz_resources(group: ShaderResourceGroupDescriptor)
  * The resource set of a G-buffer pipeline whose group 0 is `material_group`.
  *
  * The group is the template's own and brings its own visibility — fragment only, because the shared
- * vertex stage binds nothing.
+ * vertex stage binds nothing of group 0.
  *
  * @param {ShaderResourceGroupDescriptor} material_group
  * @returns {ShaderResourceSetDescriptor}
@@ -51,7 +51,7 @@ export function build_gbuffer_laydown(surface: CodeChunk, derivatives: CodeChunk
 export function build_gbuffer_fragment_body(surface: CodeChunk): CodeChunk;
 /**
  * The G-buffer pipeline of a template: its group 0 and surface function around the shared body,
- * after the shared binding-free vertex stage.
+ * after the shared vertex stage.
  *
  * @param {Object} options
  * @param {string} options.label

package/src/shade/renderer/material/standard/fragment_gbuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AA2EA;;;;;;GAMG;AACH,kDAHW,6BAA6B,GAC3B,6BAA6B,CASzC;AAoBD;;;;;;;;GAQG;AACH,+DAHW,6BAA6B,GAC3B,2BAA2B,CAUvC;AASD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CALW,SAAS,eACT,SAAS,GAEP,SAAS,CA+OrB;AAgBD;;;;;;GAMG;AACH,qDAHW,SAAS,GACP,SAAS,CAerB;AAED;;;;;;;;;GASG;AACH;IAL2B,KAAK,EAArB,MAAM;IACiC,cAAc,EAArD,6BAA6B;IACV,OAAO,EAA1B,SAAS;IACP,wBAAwB,CAUpC;AAED;;;;;;;GAOG;AACH,8DAJW,MAAM,UACN,gBAAgB,GACd,wBAAwB,CA4BpC;AArbD;;;GAGG;AAGH;;;;;;;;;GASG;AACH,qCAFU,6BAA6B,CAEmC;AAwB1E;;;;GAIG;AACH,uCAFU,6BAA6B,CAEqC;AAgC5E;;;;GAIG;AACH,wCAFU,2BAA2B,CAEoE;AAyQzG;;;;;GAKG;AACH,4CAFU,SAAS,CAQhB;AAgFH;;;;GAIG;AACH,6BAFU,gBAAgB,CAMvB;8CAzc2C,wDAAwD;4CAC1D,sDAAsD;0BAFxE,oCAAoC;yCAxCrB,iEAAiE;iCA2CzE,kCAAkC"}
+{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AAkFA;;;;;;GAMG;AACH,kDAHW,6BAA6B,GAC3B,6BAA6B,CASzC;AAoBD;;;;;;;;GAQG;AACH,+DAHW,6BAA6B,GAC3B,2BAA2B,CAUvC;AASD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CALW,SAAS,eACT,SAAS,GAEP,SAAS,CA+OrB;AAgBD;;;;;;GAMG;AACH,qDAHW,SAAS,GACP,SAAS,CAerB;AAED;;;;;;;;;GASG;AACH;IAL2B,KAAK,EAArB,MAAM;IACiC,cAAc,EAArD,6BAA6B;IACV,OAAO,EAA1B,SAAS;IACP,wBAAwB,CAUpC;AAED;;;;;;;GAOG;AACH,8DAJW,MAAM,UACN,gBAAgB,GACd,wBAAwB,CA4BpC;AA3bD;;;GAGG;AAGH;;;;;;;;;GASG;AACH,qCAFU,6BAA6B,CAEmC;AA8B1E;;;;GAIG;AACH,uCAFU,6BAA6B,CAEqC;AAgC5E;;;;GAIG;AACH,wCAFU,2BAA2B,CAEoE;AAyQzG;;;;;GAKG;AACH,4CAFU,SAAS,CAQhB;AAgFH;;;;GAIG;AACH,6BAFU,gBAAgB,CAMvB;8CA/c2C,wDAAwD;4CAC1D,sDAAsD;0BAFxE,oCAAoC;yCAxCrB,iEAAiE;iCA2CzE,kCAAkC"}

package/src/shade/renderer/material/standard/fragment_gbuffer.js

@@ -1,3 +1,4 @@
+import { assert } from "../../../../core/assert.js";
 import { GPUShaderStage } from "../../../descriptor/GPUShaderStage.js";
 import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { G_BUFFER_COLOR_TARGETS } from "../../gbuffer/G_BUFFER_COLOR_TARGETS.js";
@@ -46,7 +47,7 @@ import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
 import { VIEW_UNIFORM_STRUCT } from "../../view/VIEW_UNIFORM_STRUCT.js";
 import { chunk_material_surface_contract } from "../template/chunk_material_surface.js";
 import { chunk_standard_material_surface } from "./chunk_standard_material_surface.js";
-import { material_gbuffer_vertex_shader_code } from "./material_gbuffer_vertex.js";
+import { MATERIAL_SEEN_BINDING, material_gbuffer_vertex_shader_code } from "./material_gbuffer_vertex.js";
 import { SHADING_MATERIAL_RESOURCE_GROUP } from "./SHADING_MATERIAL_RESOURCE_GROUP.js";
 
 /**
@@ -73,6 +74,12 @@ add_g_buffer_viz_resources(g_buffer_viz_resources);
 
 g_buffer_viz_resources.addVisibility(GPUShaderStage.FRAGMENT);
 
+// which materials hold a pixel of the view, a bit per material id; the shared vertex stage reads it
+g_buffer_viz_resources.addStorageBuffer("material_seen", WebGPUArray.from(u32));
+g_buffer_viz_resources.get("material_seen").addVisibility(GPUShaderStage.VERTEX);
+
+assert.equal(g_buffer_viz_resources.get("material_seen").binding_index, MATERIAL_SEEN_BINDING, "material_seen binding");
+
 /**
  * Declare in `group` what {@link build_gbuffer_laydown} reads of the visibility buffer and the
  * view that drew it: the first four bindings of group 1, under the names the body reads them by.
@@ -111,7 +118,7 @@ g_buffer_scene_resources.addVisibility(GPUShaderStage.FRAGMENT);
  * The resource set of a G-buffer pipeline whose group 0 is `material_group`.
  *
  * The group is the template's own and brings its own visibility — fragment only, because the shared
- * vertex stage binds nothing.
+ * vertex stage binds nothing of group 0.
  *
  * @param {ShaderResourceGroupDescriptor} material_group
  * @returns {ShaderResourceSetDescriptor}
@@ -434,7 +441,7 @@ fn main(
 
 /**
  * The G-buffer pipeline of a template: its group 0 and surface function around the shared body,
- * after the shared binding-free vertex stage.
+ * after the shared vertex stage.
  *
  * @param {Object} options
  * @param {string} options.label

package/src/shade/renderer/material/standard/material_gbuffer_vertex.d.ts

@@ -1,11 +1,23 @@
+/**
+ * Group 1 binding of the material-seen bitset the shared G-buffer vertex stage reads: bit
+ * `id & 31` of word `id >> 5` is set when material `id` holds a pixel of the view.
+ *
+ * @type {number}
+ */
+export const MATERIAL_SEEN_BINDING: number;
 /**
  * Shared vertex stage of every material template's G-buffer pipeline: a fullscreen triangle placed
  * at depth `material.id / 2^24`, matched against the material-depth mask with `depthCompare: 'equal'`
  * so the fragment stage only runs on this material's pixels.
  *
- * **It binds nothing.** The material id rides in the instance index — the material pass draws
- * `draw(3, 1, 0, id)` — so a template's group 0 can be laid out however the template needs, and is
- * visible to the fragment stage alone. A direct draw's `firstInstance` needs no device feature.
+ * The material id rides in the instance index — the material pass draws `draw(3, 1, 0, id)` — so a
+ * template's group 0 can be laid out however the template needs, and is visible to the fragment
+ * stage alone. A direct draw's `firstInstance` needs no device feature.
+ *
+ * A material that holds no pixel of the view — its bit clear in `material_seen`, of the shared group
+ * 1 — gets all three corners on one point: a triangle of no area, which rasterizes nothing, so the
+ * draw costs three vertex invocations rather than a fullscreen pass of depth tests. An id past the
+ * end of the bitset is drawn.
  *
  * `id / 16777216` is the expression the material-depth pass writes, and a division by a power of two
  * is exact for every id below 2^24, so the two meet at depth-equal.

package/src/shade/renderer/material/standard/material_gbuffer_vertex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"material_gbuffer_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/material_gbuffer_vertex.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,kDAFU,MAAM,CA6BE"}
+{"version":3,"file":"material_gbuffer_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/material_gbuffer_vertex.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;;;;;;;;;;;;;;;GAkBG;AACH,kDAFU,MAAM,CAqCE"}

package/src/shade/renderer/material/standard/material_gbuffer_vertex.js

@@ -1,13 +1,26 @@
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 
+/**
+ * Group 1 binding of the material-seen bitset the shared G-buffer vertex stage reads: bit
+ * `id & 31` of word `id >> 5` is set when material `id` holds a pixel of the view.
+ *
+ * @type {number}
+ */
+export const MATERIAL_SEEN_BINDING = 4;
+
 /**
  * Shared vertex stage of every material template's G-buffer pipeline: a fullscreen triangle placed
  * at depth `material.id / 2^24`, matched against the material-depth mask with `depthCompare: 'equal'`
  * so the fragment stage only runs on this material's pixels.
  *
- * **It binds nothing.** The material id rides in the instance index — the material pass draws
- * `draw(3, 1, 0, id)` — so a template's group 0 can be laid out however the template needs, and is
- * visible to the fragment stage alone. A direct draw's `firstInstance` needs no device feature.
+ * The material id rides in the instance index — the material pass draws `draw(3, 1, 0, id)` — so a
+ * template's group 0 can be laid out however the template needs, and is visible to the fragment
+ * stage alone. A direct draw's `firstInstance` needs no device feature.
+ *
+ * A material that holds no pixel of the view — its bit clear in `material_seen`, of the shared group
+ * 1 — gets all three corners on one point: a triangle of no area, which rasterizes nothing, so the
+ * draw costs three vertex invocations rather than a fullscreen pass of depth tests. An id past the
+ * end of the bitset is drawn.
  *
  * `id / 16777216` is the expression the material-depth pass writes, and a division by a power of two
  * is exact for every id below 2^24, so the two meet at depth-equal.
@@ -17,6 +30,8 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 export const material_gbuffer_vertex_shader_code = CodeChunk.from(
 // language=WGSL
     `
+@group(1) @binding(${MATERIAL_SEEN_BINDING}) var<storage, read> material_seen: array<u32>;
+
 const pos : array< vec2<f32>, 3 > = array< vec2<f32>, 3 >(
   vec2<f32>(-1.0, -1.0),
   vec2<f32>(3.0, -1.0),
@@ -35,7 +50,13 @@ fn main(
 
   var out: VertexOutput;
 
-  let ndc = pos[id];
+  let word = material_id >> 5u;
+
+  // an id past the bitset was not counted, so it is drawn as though seen
+  let seen = word >= arrayLength(&material_seen)
+    || (material_seen[word] & (1u << (material_id & 31u))) != 0u;
+
+  let ndc = select(pos[0], pos[id], seen);
 
   out.position = vec4<f32>(ndc, f32(material_id)/16777216 , 1.0);
 

package/src/shade/renderer/particles/GPUParticleSystem.d.ts

@@ -100,6 +100,17 @@
  * and a set of accumulators that are sums — so the particles need no depth ordering at all, and
  * none is ever built.
  *
+ * ## Capacity
+ *
+ * {@link capacity} may be set at any time and takes effect on the next {@link execute}, which is
+ * where every buffer it sizes is replaced — never while a recorded graph may still read the old
+ * ones. Growing keeps every live particle: the pool and the free list are copied into the larger
+ * buffers and the new slots pushed onto the free list. Shrinking keeps every live particle the
+ * smaller pool can hold: a particle in a slot past the new capacity moves into a free slot below
+ * it, and when there are more particles than slots, the excess is dropped. A particle that moves
+ * reads a new `PARTICLE_INDEX`, and the frame that applies a shrink rebuilds the simulation order
+ * from the moved list before it simulates.
+ *
  * ## Allocation
  *
  * The per-frame path allocates the frame graph's records and nothing else: emitter rows are
@@ -130,11 +141,6 @@ export class GPUParticleSystem {
      * @type {import("../scene/GPUSceneContext.js").GPUSceneContext}
      */
     scene_context: import("../scene/GPUSceneContext.js").GPUSceneContext;
-    /**
-     * Maximum number of simultaneously live particles.
-     * @type {number}
-     */
-    capacity: number;
     /**
      * @type {EmitterRegistry}
      */
@@ -175,6 +181,18 @@ export class GPUParticleSystem {
      * @type {object}
      */
     buffers: object;
+    /**
+     * Raise or lower the number of particles the pool holds. Applied by the next {@link execute};
+     * see the class doc for what happens to the particles already live.
+     *
+     * @param {number} value
+     */
+    set capacity(value: number);
+    /**
+     * Maximum number of simultaneously live particles.
+     * @returns {number}
+     */
+    get capacity(): number;
     /**
      * The buffer the emitter table lives in — what every emitter-reading pass binds.
      * @returns {GPUBuffer}

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

@@ -1 +1 @@
-{"version":3,"file":"GPUParticleSystem.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/GPUParticleSystem.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"GPUParticleSystem.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/GPUParticleSystem.js"],"names":[],"mappings":"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"}