@woosh/meep-engine 3.31.0 → 3.32.0

package/src/shade/renderer/dynamic/GPUDynamicMeshRenderer.js

@@ -30,6 +30,11 @@ export class GPUDynamicMeshRenderer {
      * Set before the first draw. Changing it later rebuilds the pipeline, which is cheap but not
      * free, and the whole batch moves together — this is a property of the pass, not of a mesh.
      *
+     * Solid content belongs at `FramePhase.AfterLighting`, with the depth {@link graph_draw} hands
+     * back published: transparency runs after that phase and tests against that depth, so glass in
+     * front of the batch covers it. At `AfterTransparency` the glass is already resolved, and the
+     * batch is drawn over it.
+     *
      * @type {boolean}
      */
     opaque = false;
@@ -52,11 +57,16 @@ export class GPUDynamicMeshRenderer {
     /**
      * Record the draws into `graph`, over the colour it is given.
      *
-     * When {@link opaque} is set the pass writes the depth it is given. That write lands in the
-     * same physical texture the handle names — a written handle is a renamed clone of one resource,
-     * not a second one — so a later pass reading the handle the caller still holds sees the depth
-     * this pass left. Only the colour is threaded back, because that is what an injected pass is
-     * allowed to replace.
+     * **Both handles come back, and the caller publishes both** — into `SceneColor` and
+     * `ViewTextures` from an extension. The colour is always replaced. The depth is replaced when
+     * {@link opaque} is set, since the pass writes it; otherwise it comes back as it was given.
+     *
+     * A written handle is a renamed clone of the same texture, so a pass that goes on reading the
+     * depth handle it held before this draw is reading a version this pass has superseded.
+     * `FrameGraph.validate` refuses that, and the frame fails to compile in a development build.
+     * A stripped build reads the right contents only because passes run in the order they were
+     * recorded. So every reader of the scene depth after this draw has to be handed the new handle:
+     * depth of field, motion blur, the NSS upscaler, the next extension along.
      *
      * @param {object} args
      * @param {FrameGraph} args.graph
@@ -64,7 +74,7 @@ export class GPUDynamicMeshRenderer {
      * @param {number} args.color colour resource handle to draw over
      * @param {number} args.depth scene depth, written when {@link opaque} and otherwise only tested
      * @param {GPUBuffer} args.camera
-     * @returns {number} the colour handle after the draws
+     * @returns {{color: number, depth: number}} the colour and depth handles after the draws
      */
     graph_draw({ graph, batch, color, depth, camera }) {
         assert.defined(graph, 'graph');
@@ -86,7 +96,10 @@ export class GPUDynamicMeshRenderer {
         data.depth = data.opaque ? pass.write(depth) : pass.read(depth);
         data.color = pass.write(pass.read(color));
 
-        return data.color;
+        return {
+            color: data.color,
+            depth: data.depth,
+        };
     }
 
     /**

package/src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.d.ts

@@ -1,4 +1,9 @@
 /**
+ * Needs meshoptimizer's WASM, which instantiates asynchronously at import. A build before it has
+ * fails inside the vendored module, on an instance that is not there yet, with a message about
+ * `exports` that names nothing the caller did — so await `MeshoptClusterizer.ready` before the
+ * first call.
+ *
  * @param {RowFirstTable} result_metadata
  * @param {BinaryBuffer} result_data
  * @param {number[]} input_index Index array

package/src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry_to_meshlets_meshoptimizer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,2HAPW,MAAM,EAAE,qBACR,MAAM,gBACN,MAAM,oBACN,YAAY,yBACZ,MAAM,2BACN,MAAM,QAkDhB"}
+{"version":3,"file":"geometry_to_meshlets_meshoptimizer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;GAcG;AACH,2HAPW,MAAM,EAAE,qBACR,MAAM,gBACN,MAAM,oBACN,YAAY,yBACZ,MAAM,2BACN,MAAM,QAmDhB"}

package/src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.js

@@ -1,7 +1,25 @@
+import { assert } from "../../../../../../core/assert.js";
 import { MeshoptClusterizer } from "./meshopt_clusterizer.js";
 import { meshopt_optimizeMeshlet } from "./meshopt_optimizeMeshlet.js";
 
 /**
+ * Whether meshoptimizer's WASM has landed. The vendored module instantiates it asynchronously at
+ * import and exposes only the promise, so this holds the promise's outcome for the assertion below.
+ *
+ * @type {boolean}
+ */
+let clusterizer_ready = false;
+
+MeshoptClusterizer.ready?.then(() => {
+    clusterizer_ready = true;
+});
+
+/**
+ * Needs meshoptimizer's WASM, which instantiates asynchronously at import. A build before it has
+ * fails inside the vendored module, on an instance that is not there yet, with a message about
+ * `exports` that names nothing the caller did — so await `MeshoptClusterizer.ready` before the
+ * first call.
+ *
  * @param {RowFirstTable} result_metadata
  * @param {BinaryBuffer} result_data
  * @param {number[]} input_index Index array
@@ -21,6 +39,7 @@ export function geometry_to_meshlets_meshoptimizer(
     meshlet_vertex_limit = 64,
     meshlet_triangle_limit = 64,
 ) {
+    assert.ok(clusterizer_ready, 'meshoptimizer is not ready; await MeshoptClusterizer.ready');
 
     const meshlets = MeshoptClusterizer.buildMeshlets(input_index, vertex_positions, 3, meshlet_vertex_limit, meshlet_triangle_limit, 0.0);
 

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#250@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#251@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#184@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#185@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/rasterize/bucket/rasterization_has_opaque_bucket.d.ts

@@ -9,7 +9,9 @@
  * and every pixel the alpha-tested pass did not cover keeping last frame's mesh and triangle ids for
  * the deferred shading to resolve as real surfaces.
  *
- * This is what lets the composer hand the clear to the first pass that will actually run.
+ * The composers used this to hand the clear to the first alpha-tested draw, which left a scene with
+ * no draw of either kind uncleared. They no longer ask: the opaque loop knows whether it drew, and
+ * when it did not, `graph_clear_raster_targets` clears in its first draw's place.
  *
  * @param {Set<number>} active_buckets bucket ids any material in the scene asks for
  * @returns {boolean}

package/src/shade/renderer/rasterize/bucket/rasterization_has_opaque_bucket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rasterization_has_opaque_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/rasterization_has_opaque_bucket.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,gEANW,IAAI,MAAM,CAAC,GACT,OAAO,CAWnB"}
+{"version":3,"file":"rasterization_has_opaque_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/rasterization_has_opaque_bucket.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,gEANW,IAAI,MAAM,CAAC,GACT,OAAO,CAWnB"}

package/src/shade/renderer/rasterize/bucket/rasterization_has_opaque_bucket.js

@@ -11,7 +11,9 @@ import { rasterization_opaque_buckets } from "./rasterization_opaque_buckets.js"
  * and every pixel the alpha-tested pass did not cover keeping last frame's mesh and triangle ids for
  * the deferred shading to resolve as real surfaces.
  *
- * This is what lets the composer hand the clear to the first pass that will actually run.
+ * The composers used this to hand the clear to the first alpha-tested draw, which left a scene with
+ * no draw of either kind uncleared. They no longer ask: the opaque loop knows whether it drew, and
+ * when it did not, `graph_clear_raster_targets` clears in its first draw's place.
  *
  * @param {Set<number>} active_buckets bucket ids any material in the scene asks for
  * @returns {boolean}

package/src/shade/renderer/rasterize/expand/bucket/mesh/shader_instances_rasterization_bucket_sort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_instances_rasterization_bucket_sort.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/rasterize/expand/bucket/mesh/shader_instances_rasterization_bucket_sort.js"],"names":[],"mappings":"AAiBA,yEAGG;AAgEH,uEAIE;6BAtF2B,yCAAyC;8BAMxC,qCAAqC"}
+{"version":3,"file":"shader_instances_rasterization_bucket_sort.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/rasterize/expand/bucket/mesh/shader_instances_rasterization_bucket_sort.js"],"names":[],"mappings":"AAkBA,yEAGG;AA6GH,uEAIE;6BAnI2B,yCAAyC;8BAMxC,qCAAqC"}

package/src/shade/renderer/rasterize/expand/bucket/mesh/shader_instances_rasterization_bucket_sort.js

@@ -1,89 +1,135 @@
-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 { COLLECTION_U32_STRUCT_READ } from "../../../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
-import { MATERIAL_METADATA_STRUCT } from "../../../../material/MATERIAL_METADATA_STRUCT.js";
-import { chunk_scene_database_access } from "../../../../scene/chunk_scene_database_access.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";
-import { chunk_rasterization_material_bucket } from "../chunk_rasterization_material_bucket.js";
-import { RASTERIZATION_BUCKET_LIMIT } from "../RASTERIZATION_BUCKET_LIMIT.js";
-import {
-    RASTERIZATION_BUCKET_SORT_OUTPUT_HEADER_STRUCT_WRITE
-} from "../RASTERIZATION_BUCKET_SORT_OUTPUT_HEADER_STRUCT_WRITE.js";
-
-
-export const RASTERIZATION_BUCKET_SORT_OUTPUT_STRUCT_WRITE = WebGPUStruct.from({
-    headers: RASTERIZATION_BUCKET_SORT_OUTPUT_HEADER_STRUCT_WRITE,
-    elements: WebGPUArray.u32
-});
-
-const OFFSETS_TYPE = WebGPUArray.from(u32, RASTERIZATION_BUCKET_LIMIT);
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addStorageBuffer("scene_database", WebGPUArray.from(u32))
-    .addStorageBuffer("materials", WebGPUArray.from(MATERIAL_METADATA_STRUCT))
-
-resources.createGroup()
-    .addStorageBuffer("input", COLLECTION_U32_STRUCT_READ)
-    .addStorageBuffer("offsets", OFFSETS_TYPE)
-    .addStorageBuffer("output", RASTERIZATION_BUCKET_SORT_OUTPUT_STRUCT_WRITE, 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;
-    
-    let input_size = min(input.count, arrayLength(&input.elements));
-    
-    if(index >= input_size){
-        return;
-    }
-    
-    let mesh_index = input.elements[index];
-
-    let mesh = scene_read_mesh(&scene_database, mesh_index);
-
-    let material = materials[mesh.material];
-    
-    let bucket_index = rasterization_material_bucket(
-        material.transparency_mode,
-        material.draw_mode,
-        material.draw_side
-    );
-    
-    let element_offset = atomicAdd(&output.headers[bucket_index].count, 1u);
-    
-    let bucket_offset = offsets[bucket_index];
-    
-    if(element_offset == 0u){
-        // first element in bucket, write offset as well
-        output.headers[bucket_index].offset = bucket_offset;
-    }
-    
-    let output_offset = bucket_offset + element_offset;
-    
-    if(output_offset < arrayLength(&output.elements)){
-        // guard against out-of-bounds access
-        output.elements[output_offset] = mesh_index;
-    }
-    
-}
-    `, [
-        chunk_rasterization_material_bucket,
-        chunk_scene_database_access,
-    ]
-);
-
-export const shader_instances_rasterization_bucket_sort = ComputeShader.from({
-    label: 'Rasterization bucket sort',
-    resources,
-    body,
+import { assert } from "../../../../../../core/assert.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 { COLLECTION_U32_STRUCT_READ } from "../../../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { MATERIAL_METADATA_STRUCT } from "../../../../material/MATERIAL_METADATA_STRUCT.js";
+import { chunk_scene_database_access } from "../../../../scene/chunk_scene_database_access.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";
+import { chunk_rasterization_material_bucket } from "../chunk_rasterization_material_bucket.js";
+import { RASTERIZATION_BUCKET_LIMIT } from "../RASTERIZATION_BUCKET_LIMIT.js";
+import {
+    RASTERIZATION_BUCKET_SORT_OUTPUT_HEADER_STRUCT_WRITE
+} from "../RASTERIZATION_BUCKET_SORT_OUTPUT_HEADER_STRUCT_WRITE.js";
+
+
+export const RASTERIZATION_BUCKET_SORT_OUTPUT_STRUCT_WRITE = WebGPUStruct.from({
+    headers: RASTERIZATION_BUCKET_SORT_OUTPUT_HEADER_STRUCT_WRITE,
+    elements: WebGPUArray.u32
+});
+
+const OFFSETS_TYPE = WebGPUArray.from(u32, RASTERIZATION_BUCKET_LIMIT);
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addStorageBuffer("scene_database", WebGPUArray.from(u32))
+    .addStorageBuffer("materials", WebGPUArray.from(MATERIAL_METADATA_STRUCT))
+
+resources.createGroup()
+    .addStorageBuffer("input", COLLECTION_U32_STRUCT_READ)
+    .addStorageBuffer("offsets", OFFSETS_TYPE)
+    .addStorageBuffer("output", RASTERIZATION_BUCKET_SORT_OUTPUT_STRUCT_WRITE, true)
+
+
+const GROUP_SIZE = COMPUTE_SHADER_DEFAULT_GROUP_SIZE;
+
+// one lane per bucket makes the workgroup's claims
+assert.lessThanOrEqual(RASTERIZATION_BUCKET_LIMIT, GROUP_SIZE);
+
+/**
+ * Every element used to claim its slot with an `atomicAdd(&output.headers[bucket].count, 1u)` of
+ * its own. The address comes from the material, so nothing aggregated it, and every survivor of a
+ * view queued on its bucket's one counter: 0.47-0.80 ns a survivor, the largest non-raster pass of
+ * a view.
+ *
+ * Instead each lane ranks itself within its workgroup, in workgroup memory, and one lane per bucket
+ * claims the workgroup's whole run with a single global atomic. Measured on a 4090 against
+ * aggregating per subgroup (a ballot per bit of the bucket index, one atomic per bucket a wave
+ * holds), at 2M rows: 62 against 63 us for 1.48M elements of one bucket, 13 against 22 us for
+ * the main view's 774K, and 62 against 107 us for the 1.48M with six buckets to a wave. Waves on
+ * mixed content hold several buckets, and a workgroup claims each of them a quarter as often.
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+var<workgroup> wg_count: array<atomic<u32>, ${RASTERIZATION_BUCKET_LIMIT}>;
+var<workgroup> wg_base: array<u32, ${RASTERIZATION_BUCKET_LIMIT}>;
+    
+@compute @workgroup_size(${GROUP_SIZE})
+fn main(
+    @builtin(global_invocation_id) global_id : vec3<u32>,
+    @builtin(local_invocation_index) local_index : u32,
+){
+    
+    let index = global_id.x;
+    
+    let input_size = min(input.count, arrayLength(&input.elements));
+    
+    // a lane past the input does not return: every lane of the workgroup has to reach the barriers
+    let valid = index < input_size;
+    
+    var mesh_index = 0u;
+    var bucket_index = 0u;
+    var rank = 0u;
+    
+    if(valid){
+        mesh_index = input.elements[index];
+    
+        let mesh = scene_read_mesh(&scene_database, mesh_index);
+    
+        let material = materials[mesh.material];
+    
+        bucket_index = rasterization_material_bucket(
+            material.transparency_mode,
+            material.draw_mode,
+            material.draw_side
+        );
+    
+        // this element's place in the workgroup's run of its bucket
+        rank = atomicAdd(&wg_count[bucket_index], 1u);
+    }
+    
+    workgroupBarrier();
+    
+    // one lane per bucket claims the workgroup's whole run with one atomic
+    if(local_index < ${RASTERIZATION_BUCKET_LIMIT}u){
+        let run_length = atomicLoad(&wg_count[local_index]);
+    
+        if(run_length > 0u){
+            let run_offset = atomicAdd(&output.headers[local_index].count, run_length);
+    
+            if(run_offset == 0u){
+                // first element in bucket, write offset as well
+                output.headers[local_index].offset = offsets[local_index];
+            }
+    
+            wg_base[local_index] = run_offset;
+        }
+    }
+    
+    workgroupBarrier();
+    
+    if(valid){
+        let output_offset = offsets[bucket_index] + wg_base[bucket_index] + rank;
+    
+        if(output_offset < arrayLength(&output.elements)){
+            // guard against out-of-bounds access
+            output.elements[output_offset] = mesh_index;
+        }
+    }
+    
+}
+    `, [
+        chunk_rasterization_material_bucket,
+        chunk_scene_database_access,
+    ]
+);
+
+export const shader_instances_rasterization_bucket_sort = ComputeShader.from({
+    label: 'Rasterization bucket sort',
+    resources,
+    body,
 })

package/src/shade/renderer/rasterize/expand/bucket/meshlet/shader_meshlets_rasterization_bucket_sort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlets_rasterization_bucket_sort.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/rasterize/expand/bucket/meshlet/shader_meshlets_rasterization_bucket_sort.js"],"names":[],"mappings":"AA2FA,sEAIE;8BAtF4B,qCAAqC"}
+{"version":3,"file":"shader_meshlets_rasterization_bucket_sort.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/rasterize/expand/bucket/meshlet/shader_meshlets_rasterization_bucket_sort.js"],"names":[],"mappings":"AA0HA,sEAIE;8BApH4B,qCAAqC"}

package/src/shade/renderer/rasterize/expand/bucket/meshlet/shader_meshlets_rasterization_bucket_sort.js

@@ -1,3 +1,4 @@
+import { assert } from "../../../../../../core/assert.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";
@@ -33,52 +34,82 @@ resources.createGroup()
     .addStorageBuffer("output", RASTERIZATION_MESHLET_BUCKET_SORT_OUTPUT_STRUCT_WRITE, true)
 
 
+const GROUP_SIZE = COMPUTE_SHADER_DEFAULT_GROUP_SIZE;
+
+// one lane per bucket makes the workgroup's claims
+assert.lessThanOrEqual(RASTERIZATION_BUCKET_LIMIT, GROUP_SIZE);
+
+/**
+ * The meshlet twin of {@link shader_instances_rasterization_bucket_sort}: the same workgroup
+ * histogram, for the same reason.
+ */
 const body = CodeChunk.from(
     //language=WGSL
     `
-@compute @workgroup_size(${COMPUTE_SHADER_DEFAULT_GROUP_SIZE})
+var<workgroup> wg_count: array<atomic<u32>, ${RASTERIZATION_BUCKET_LIMIT}>;
+var<workgroup> wg_base: array<u32, ${RASTERIZATION_BUCKET_LIMIT}>;
+    
+@compute @workgroup_size(${GROUP_SIZE})
 fn main(
     @builtin(workgroup_id) workgroup_id : vec3<u32>,
     @builtin(local_invocation_index) local_index : u32,
 ){
-
+    
     // folded dispatch — see IndirectComputeCommandBuildPass
-    let index = folded_workgroup_index(workgroup_id) * ${COMPUTE_SHADER_DEFAULT_GROUP_SIZE}u + local_index;
+    let index = folded_workgroup_index(workgroup_id) * ${GROUP_SIZE}u + local_index;
     
     let input_size = min(input.count, arrayLength(&input.elements));
     
-    if(index >= input_size){
-        return;
+    // a lane past the input does not return: every lane of the workgroup has to reach the barriers
+    let valid = index < input_size;
+    
+    var bucket_index = 0u;
+    var rank = 0u;
+    
+    if(valid){
+        let mesh_index = input.elements[index].mesh;
+    
+        let mesh = scene_read_mesh(&scene_database, mesh_index);
+    
+        let material = materials[mesh.material];
+    
+        bucket_index = rasterization_material_bucket(
+            material.transparency_mode,
+            material.draw_mode,
+            material.draw_side
+        );
+    
+        // this element's place in the workgroup's run of its bucket
+        rank = atomicAdd(&wg_count[bucket_index], 1u);
     }
     
-    let meshlet_def = input.elements[index];
-
-    let mesh_index = meshlet_def.mesh;
-
-    let mesh = scene_read_mesh(&scene_database, mesh_index);
-
-    let material = materials[mesh.material];
+    workgroupBarrier();
     
-    let bucket_index = rasterization_material_bucket(
-        material.transparency_mode,
-        material.draw_mode,
-        material.draw_side
-    );
+    // one lane per bucket claims the workgroup's whole run with one atomic
+    if(local_index < ${RASTERIZATION_BUCKET_LIMIT}u){
+        let run_length = atomicLoad(&wg_count[local_index]);
     
-    let element_offset = atomicAdd(&output.headers[bucket_index].count, 1u);
+        if(run_length > 0u){
+            let run_offset = atomicAdd(&output.headers[local_index].count, run_length);
     
-    let bucket_offset = offsets[bucket_index];
+            if(run_offset == 0u){
+                // first element in bucket, write offset as well
+                output.headers[local_index].offset = offsets[local_index];
+            }
     
-    if(element_offset == 0u){
-        // first element in bucket, write offset as well
-        output.headers[bucket_index].offset = bucket_offset;
+            wg_base[local_index] = run_offset;
+        }
     }
     
-    let output_offset = bucket_offset + element_offset;
+    workgroupBarrier();
+    
+    if(valid){
+        let output_offset = offsets[bucket_index] + wg_base[bucket_index] + rank;
     
-    if(output_offset < arrayLength(&output.elements)){
-        // guard against out-of-bounds access
-        output.elements[output_offset] = meshlet_def;
+        if(output_offset < arrayLength(&output.elements)){
+            // guard against out-of-bounds access
+            output.elements[output_offset] = input.elements[index];
+        }
     }
     
 }

package/src/shade/renderer/rasterize/fast/graph_rasterize_scene_fast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_rasterize_scene_fast.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/fast/graph_rasterize_scene_fast.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AACH;;;;;;;IAFa;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAC,CA0J3D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAJ+B,KAAK;IACC,GAAG;IACA,MAAM;SA8C7C"}
+{"version":3,"file":"graph_rasterize_scene_fast.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/fast/graph_rasterize_scene_fast.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AACH;;;;;;;IAFa;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,EAAE,CAAA;CAAC,CAkK3D;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAJ+B,KAAK;IACC,GAAG;IACA,MAAM;SA8C7C"}

package/src/shade/renderer/rasterize/fast/graph_rasterize_scene_fast.js

@@ -13,8 +13,8 @@ import { graph_vgeo_expand_if_enabled } from "../../geometry/virtual/runtime/gra
 import { RasterizationCollectionType } from "../expand/RasterizationCollectionType.js";
 import { construct_primitive_state } from "../bucket/construct_primitive_state.js";
 import { rasterization_opaque_buckets } from "../bucket/rasterization_opaque_buckets.js";
-import { rasterization_has_opaque_bucket } from "../bucket/rasterization_has_opaque_bucket.js";
 import { graph_mesh_frustum_cull } from "../compute/graph_mesh_frustum_cull.js";
+import { graph_clear_raster_targets } from "../graph_clear_raster_targets.js";
 import { graph_rasterize_meshes_alpha_tested } from "../native/graph_rasterize_meshes_alpha_tested.js";
 import { graph_extract_meshes_from_bucket } from "./graph_extract_meshes_from_bucket.js";
 
@@ -122,29 +122,39 @@ export function graph_rasterize_scene_fast_raw({
         is_first_draw = false;
     }
 
-    // alpha-tested: reuse the existing native pass but skip HZB filtering by passing hzb=-1
-    if (job.alpha_tested_pass !== undefined) {
-        /**
-         * The opaque path's first draw is the only thing that clears the visibility-buffer colour
-         * attachments and the depth attachment — the clear values live on the opaque pass descriptor
-         * and reach the targets through its `loadOp`, and every pass after it is recorded with
-         * `load`. When the scene has no opaque bucket that draw never happens, so the first pass that
-         * does run owns the clear. The alpha-tested descriptor carries the same clear values
-         * (`[0,0,0,0]`, VIZ_BUFFER_INVALID_MESH_VALUE, DEPTH_BACKGROUND_VALUE), so handing it over
-         * changes nothing about what the targets are cleared to.
-         *
-         * Wherever an opaque bucket exists — nearly every scene — this starts true and every call
-         * below asks for `false`, exactly as before.
-         */
-        let targets_cleared = rasterization_has_opaque_bucket(active_buckets);
+    if (is_first_draw) {
+        /*
+         No opaque bucket, so no draw above cleared the target, and the rectangle holds whatever was
+         there before: in the atlas, the shadow of whatever was in the scene then; in a point light's
+         cube, which is a pooled transient, whatever the pool's last user left. The clear goes in the
+         first draw's place, and everything after this loads.
+        */
+        const cleared = graph_clear_raster_targets({
+            graph,
+            depth: target_depth,
+            color_targets: targets_color,
+            pass_descriptor: job.opaque_pass,
+            viewport,
+        });
 
+        target_depth = cleared.depth;
+        targets_color = cleared.color_targets;
+    }
 
+    // alpha-tested: reuse the existing native pass but skip HZB filtering by passing hzb=-1
+    if (job.alpha_tested_pass !== undefined) {
+        /*
+         Both alpha-tested passes load, never clear: the targets were cleared above, by the first
+         opaque draw or in its place. The clear used to be handed to the first alpha-tested draw, which
+         left a scene with neither kind of draw — nothing in it, or only transparent surfaces — with
+         nothing clearing at all.
+        */
         const alpha_tested_front = graph_rasterize_meshes_alpha_tested({
             graph,
             buckets: gr_render_buckets,
             view_ctx: view_ctx,
             render_pass_descriptor: job.alpha_tested_pass,
-            clear_target: !targets_cleared,
+            clear_target: false,
             side: ShadeDrawSide.Front,
             cull_policy: job.cull_policy,
             limits,
@@ -157,14 +167,13 @@ export function graph_rasterize_scene_fast_raw({
 
         target_depth = alpha_tested_front.depth;
         targets_color = alpha_tested_front.color_targets;
-        targets_cleared = targets_cleared || alpha_tested_front.executed;
 
         const alpha_tested_double = graph_rasterize_meshes_alpha_tested({
             graph,
             buckets: gr_render_buckets,
             view_ctx: view_ctx,
             render_pass_descriptor: job.alpha_tested_pass,
-            clear_target: !targets_cleared,
+            clear_target: false,
             side: ShadeDrawSide.Double,
             cull_policy: job.cull_policy,
             limits,
@@ -177,7 +186,6 @@ export function graph_rasterize_scene_fast_raw({
 
         target_depth = alpha_tested_double.depth;
         targets_color = alpha_tested_double.color_targets;
-        targets_cleared = targets_cleared || alpha_tested_double.executed;
     }
 
     return {target_depth, targets_color};