@woosh/meep-engine 3.27.0 → 3.29.0

package/src/shade/renderer/gpu_primitive/indirect/IndirectComputeCommandBuildPass.js

@@ -8,6 +8,46 @@ import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDe
 import { STRUCT_DISPATCH_COMPUTE_COMMAND } from "./STRUCT_DISPATCH_COMPUTE_COMMAND.js";
 
 /**
+ * How a workgroup count that does not fit one dimension is spread over three.
+ *
+ * `maxComputeWorkgroupsPerDimension` is 65,535 on Chrome/Dawn and {@link Renderer#initialize} does
+ * not raise it — an adapter will not hand up more. At the engine's group size of 128 that is
+ * 8,388,480 elements in one dimension, which a real scene passes: a map of a million ordinary mesh
+ * rows expands to twelve million meshlets.
+ *
+ * Neither of the things that happen there is acceptable. A command **over** the limit makes
+ * `dispatchWorkgroupsIndirect` do nothing at all — measured against Dawn on nvidia/lovelace, where
+ * 65,535 workgroups run and 65,536 write not one element, with no validation error and nothing
+ * logged. Clamping it back into range, which is what this pass used to do, is the milder version of
+ * the same thing: a pass that silently covers its first 8,388,480 elements and no more. Neither
+ * moves a counter, because the collection's own `count` is written by a different pass.
+ *
+ * So the count is folded instead: `x` fills to the limit, then `y`, then `z`. Nothing is dropped
+ * and the reachable size becomes 65,535³ groups, which is not a limit anyone will meet.
+ *
+ * **A folded command's shader has to read its index accordingly.** `global_invocation_id.x` only
+ * carries the x dimension, so a shader that keeps using it would run its first 8,388,480 elements
+ * once per `y`, which is worse than dropping the rest. Fold and index are one decision:
+ *
+ * ```wgsl
+ * fn main(
+ *     @builtin(workgroup_id) workgroup_id : vec3<u32>,
+ *     @builtin(num_workgroups) group_count : vec3<u32>,
+ *     @builtin(local_invocation_index) local_index : u32,
+ * ){
+ *     let index = grid3d_to_index(workgroup_id, group_count.xy) * GROUP_SIZEu + local_index;
+ *
+ *     if(index >= count){ return; }
+ * ```
+ *
+ * {@link chunk_grid3d_to_index} is the same flattening the light and decal clusters use, and a
+ * folded grid is exactly a 3D grid whose extents happen to be a dispatch's. When the count fits,
+ * `y` and `z` are 1 and the expression is `global_invocation_id.x` term for term, so a pass under
+ * the ceiling pays nothing for this.
+ *
+ * Folding is opt-in because it is only safe once the shader indexes this way, and most passes
+ * driven by this builder cannot reach the ceiling to begin with — a scene is capped at 3,047,424
+ * mesh rows by the `transforms` table, which is 23,808 groups.
  *
  * @param {PipelineCacheKey} key
  * @returns {ComputePipelineDescriptor}
@@ -17,6 +57,28 @@ function create_pipeline(key) {
     const device = key.device;
     const max_workgroup_count = device.limits.maxComputeWorkgroupsPerDimension;
 
+    //language=WGSL
+    const clamped_dispatch = `
+    // clamp, it's generally better to be wrong than to fail
+    command = ${STRUCT_DISPATCH_COMPUTE_COMMAND.wgsl_ref}(
+        min( ${max_workgroup_count}u, desired_groups ),
+        1u,
+        1u
+    );`;
+
+    //language=WGSL
+    const folded_dispatch = `
+    const LIMIT = ${max_workgroup_count}u;
+
+    // x to the limit, what is left of it in rows of x, what is left of those in slices of x*y
+    let rows = divide_round_up(desired_groups, LIMIT);
+    let slices = divide_round_up(rows, LIMIT);
+
+    command = ${STRUCT_DISPATCH_COMPUTE_COMMAND.wgsl_ref}(
+        min( desired_groups, LIMIT ),
+        min( max( rows, 1u ), LIMIT ),
+        max( slices, 1u )
+    );`;
 
 //language=WGSL
     const shader_code = `
@@ -25,22 +87,22 @@ function create_pipeline(key) {
 @group(0) @binding(0) var<storage, read> input : u32;
 @group(0) @binding(1) var<storage, read_write> command : ${STRUCT_DISPATCH_COMPUTE_COMMAND.wgsl_ref};
 
+fn divide_round_up(value: u32, divisor: u32) -> u32 {
+    return (value + divisor - 1u) / divisor;
+}
+
 @compute @workgroup_size(1, 1, 1)
 fn main(){
 
     let elements_per_group = ${key.elements_per_workgroup}u;
-    let desired_dispatch_x = (input + elements_per_group - 1u) / elements_per_group;
-
-    // clamp, it's generally better to be wrong than to fail
-    let dispatch_x = min( ${max_workgroup_count}, desired_dispatch_x );
-    
-    command = ${STRUCT_DISPATCH_COMPUTE_COMMAND.wgsl_ref}(dispatch_x, 1u, 1u);
+    let desired_groups = divide_round_up(input, elements_per_group);
+${key.fold ? folded_dispatch : clamped_dispatch}
 
 }
         `;
 
     return ComputePipelineDescriptor.simplified({
-        label: "IndirectComputeCommandBuildPass",
+        label: key.fold ? "IndirectComputeCommandBuildPass/folded" : "IndirectComputeCommandBuildPass",
         code:
         shader_code,
         bindings: [[
@@ -64,14 +126,23 @@ class PipelineCacheKey {
      */
     elements_per_workgroup = 256
 
-    static from(device, elements_per_workgroup = 256) {
+    /**
+     * Whether a count past one dimension's limit is spread over `y` and `z` rather than clamped
+     * away. See {@link create_pipeline} — the shader it drives has to index for it.
+     * @type {boolean}
+     */
+    fold = false;
+
+    static from(device, elements_per_workgroup = 256, fold = false) {
         assert.defined(device, 'device');
         assert.isNonNegativeInteger(elements_per_workgroup, 'workgroup_size');
+        assert.isBoolean(fold, 'fold');
 
         const r = new PipelineCacheKey();
 
         r.device = device;
         r.elements_per_workgroup = elements_per_workgroup;
+        r.fold = fold;
 
         return r;
     }
@@ -79,11 +150,12 @@ class PipelineCacheKey {
     equals(other) {
         return this.device === other.device
             && this.elements_per_workgroup === other.elements_per_workgroup
+            && this.fold === other.fold
             ;
     }
 
     hash() {
-        return this.elements_per_workgroup;
+        return this.elements_per_workgroup * 2 + (this.fold ? 1 : 0);
     }
 }
 
@@ -114,6 +186,9 @@ export const INDIRECT_COMPUTE_COMMAND_DESCRIPTOR = BufferResourceDescriptor.from
  * @param {number} buffer_input_offset where to start reading from, in bytes
  * @param {GPUBuffer} buffer_command
  * @param {number} buffer_command_offset where to start writing at, in bytes
+ * @param {boolean} [fold] spread a count past one dimension's limit over `y` and `z` instead of
+ *        clamping it away. Only for a shader that reads its index through
+ *        {@link chunk_grid3d_to_index} — see {@link create_pipeline}.
  */
 export function build_indirect_compute_dispatch_command(
     elements_per_workgroup,
@@ -122,6 +197,7 @@ export function build_indirect_compute_dispatch_command(
     buffer_input_offset,
     buffer_command,
     buffer_command_offset,
+    fold = false,
 ) {
     assert.defined(encoder, 'encoder');
     assert.notNull(encoder, 'encoder');
@@ -172,7 +248,7 @@ export function build_indirect_compute_dispatch_command(
 
     }
 
-    const key = PipelineCacheKey.from(device, elements_per_workgroup);
+    const key = PipelineCacheKey.from(device, elements_per_workgroup, fold);
 
     const pipeline = pipeline_cache.getOrCompute(key, create_pipeline);
 
@@ -204,9 +280,10 @@ export function build_indirect_compute_dispatch_command(
  * @param {FrameGraph} graph
  * @param {number} input input buffer ID
  * @param {number} [workgroup_size]
+ * @param {boolean} [fold] see {@link build_indirect_compute_dispatch_command}
  * @returns {number}
  */
-export function graph_build_indirect_dispatch_command(graph, input, workgroup_size = 256) {
+export function graph_build_indirect_dispatch_command(graph, input, workgroup_size = 256, fold = false) {
     const data = new IndirectComputeDispatchPassData();
 
     /**
@@ -226,7 +303,8 @@ export function graph_build_indirect_dispatch_command(graph, input, workgroup_si
             buffer_input,
             0,
             buffer_command,
-            0
+            0,
+            fold,
         );
     };
 

package/src/shade/renderer/gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Workgroups per dimension that **every** WebGPU device allows.
+ *
+ * `maxComputeWorkgroupsPerDimension` has this as its default, and a device may only report more,
+ * never less — so a shader that writes an indirect dispatch command can fold against this literal
+ * and be certain the command is in range wherever it runs, without the device's own figure having
+ * to reach it through a binding.
+ *
+ * Folding sooner than a particular device would have needed costs nothing: the extents are only
+ * how the workgroups are arranged, and the shaders on the other side flatten them back with
+ * {@link chunk_grid3d_to_index} whatever they are. It is the other direction that is
+ * unrecoverable — a command over the device's limit does not run at all, and nothing reports it.
+ *
+ * {@link build_indirect_compute_dispatch_command} does not use this: it builds its pipeline per
+ * device and inlines the real figure. This is for {@link shader_prefix_sum_to_command}, which is a
+ * shared {@link ComputeShader} compiled once and cannot.
+ *
+ * @see https://www.w3.org/TR/webgpu/#limits
+ * @type {number}
+ */
+export const WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION: number;
+//# sourceMappingURL=WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.d.ts.map

package/src/shade/renderer/gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qEAFU,MAAM,CAE4D"}

package/src/shade/renderer/gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js

@@ -0,0 +1,21 @@
+/**
+ * Workgroups per dimension that **every** WebGPU device allows.
+ *
+ * `maxComputeWorkgroupsPerDimension` has this as its default, and a device may only report more,
+ * never less — so a shader that writes an indirect dispatch command can fold against this literal
+ * and be certain the command is in range wherever it runs, without the device's own figure having
+ * to reach it through a binding.
+ *
+ * Folding sooner than a particular device would have needed costs nothing: the extents are only
+ * how the workgroups are arranged, and the shaders on the other side flatten them back with
+ * {@link chunk_grid3d_to_index} whatever they are. It is the other direction that is
+ * unrecoverable — a command over the device's limit does not run at all, and nothing reports it.
+ *
+ * {@link build_indirect_compute_dispatch_command} does not use this: it builds its pipeline per
+ * device and inlines the real figure. This is for {@link shader_prefix_sum_to_command}, which is a
+ * shared {@link ComputeShader} compiled once and cannot.
+ *
+ * @see https://www.w3.org/TR/webgpu/#limits
+ * @type {number}
+ */
+export const WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION = 65535;

package/src/shade/renderer/loader/gltf/load_gltf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load_gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/load_gltf.js"],"names":[],"mappings":"AAqIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,sDATW,YAAY,aAGZ,MAAM,iBACN,MAAM,kBACN;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,QAgDlD;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,+BAdW,MAAM;IAEgB,YAAY;IAGN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IAGF,eAAe,GAA/C,qBAAqB;IAGpB,QAAQ,WAAW,CAAC,CA+0B/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCARW,MAAM;IAEgB,YAAY;IACN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IACF,eAAe,GAA/C,qBAAqB;IACnB,QAAQ,QAAQ,CAAC,CAU7B;4BAtlC2B,mBAAmB;yBAUtB,gBAAgB"}
+{"version":3,"file":"load_gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/load_gltf.js"],"names":[],"mappings":"AAmIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,sDATW,YAAY,aAGZ,MAAM,iBACN,MAAM,kBACN;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,QAgDlD;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,+BAdW,MAAM;IAEgB,YAAY;IAGN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IAGF,eAAe,GAA/C,qBAAqB;IAGpB,QAAQ,WAAW,CAAC,CA8zB/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCARW,MAAM;IAEgB,YAAY;IACN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IACF,eAAe,GAA/C,qBAAqB;IACnB,QAAQ,QAAQ,CAAC,CAU7B;4BApkC2B,mBAAmB;yBAStB,gBAAgB"}

package/src/shade/renderer/loader/gltf/load_gltf.js

@@ -9,7 +9,6 @@ import { clamp01 } from "../../../../core/math/clamp01.js";
 import { computeObjectHash } from "../../../../core/math/hash/computeObjectHash.js";
 import { inverseLerp } from "../../../../core/math/inverseLerp.js";
 import { objectDeepEquals } from "../../../../core/model/object/objectDeepEquals.js";
-import { number_format_by_thousands } from "../../../../core/primitives/numbers/number_format_by_thousands.js";
 import { AnimationInterpolationKind } from "../../../../engine/animation/clip/AnimationInterpolationKind.js";
 import { curve_from_track_data } from "../../../../engine/animation/clip/curve_from_track_data.js";
 import { AnimationCurve } from "../../../../engine/animation/curve/AnimationCurve.js";
@@ -35,7 +34,6 @@ import { ShadeImage } from "../../texture/source/ShadeImage.js";
 import { SceneBundle } from "../SceneBundle.js";
 import { SceneNode } from "../SceneNode.js";
 import { coalesce_array_duplicates } from "../../../../format/scene/gltf/coalesce_array_duplicates.js";
-import { fix_up_material_sides } from "./fix_up_material_sides.js";
 import { GLTF_COMPONENT_TYPE } from "../../../../format/scene/gltf/gltf_component_type.js";
 import { gltf_create_material } from "./gltf_create_material.js";
 import { gltf_create_texture } from "./gltf_create_texture.js";
@@ -1092,25 +1090,8 @@ export function load_gltf(url, { assetManager, scope, fileMap, texture_support }
         return bundle;
     }
 
-    /**
-     * @param {SceneBundle} bundle
-     */
-    function fix_scene_material_sidedness(bundle) {
-        const meshes = bundle.nodes.filter(node => node.geometry !== null);
-
-        const { geometries_modified: fixed_count, primitives_delta } = fix_up_material_sides(meshes);
-
-        if (fixed_count > 0) {
-            console.warn(`Fixed ${fixed_count} geometries in accordance with material sidedness. Primitives added: ${number_format_by_thousands(primitives_delta)}`);
-        }
-
-        return bundle;
-    }
-
-
     return load_gltf_document(url, { assetManager, scope, fileMap, texture_support })
         .then(process)
-        // .then(fix_scene_material_sidedness)
         // .then(prepare_lightmap)
         ;
 }

package/src/shade/renderer/material/chunk_material_draw_side.d.ts

@@ -0,0 +1,14 @@
+/**
+ * What a {@link ShadeDrawSide} means once `Back` stopped being a pipeline state of its own.
+ *
+ * A back-sided material is a front-sided one drawn with its winding reversed: the vertex shader
+ * emits each triangle's corners in the opposite order and the fixed-function rasterizer, still
+ * culling back faces, keeps the surface's back. That is what lets both share a bucket — see
+ * `chunk_rasterization_material_bucket` — and it is the same mechanism a reflected instance uses,
+ * so the two compose by exclusive-or.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_material_draw_side: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_material_draw_side.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_material_draw_side.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/material/chunk_material_draw_side.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,uCAFU,SAAS,CAqBb;0BAjCoB,iCAAiC"}

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

@@ -0,0 +1,34 @@
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ShadeDrawSide } from "./ShadeDrawSide.js";
+
+/**
+ * What a {@link ShadeDrawSide} means once `Back` stopped being a pipeline state of its own.
+ *
+ * A back-sided material is a front-sided one drawn with its winding reversed: the vertex shader
+ * emits each triangle's corners in the opposite order and the fixed-function rasterizer, still
+ * culling back faces, keeps the surface's back. That is what lets both share a bucket — see
+ * `chunk_rasterization_material_bucket` — and it is the same mechanism a reflected instance uses,
+ * so the two compose by exclusive-or.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_material_draw_side = CodeChunk.from(
+    //language=WGSL
+    `
+/**
+ * Whether the material asks for the back face, and therefore for reversed winding.
+ */
+fn material_draws_back_side( draw_side: u32 ) -> bool{
+    return draw_side == ${ShadeDrawSide.Back}u;
+}
+
+/**
+ * Whether the fragment is looking at the front of the surface.
+ *
+ * Not \`front_facing\`: that is the rasterizer's answer about the winding the vertex shader
+ * emitted, and a back-sided material emitted it reversed on purpose.
+ */
+fn material_fragment_faces_front( front_facing: bool, draw_side: u32 ) -> bool{
+    return front_facing != material_draws_back_side(draw_side);
+}
+`, [])

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":"AA6EA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAR6B,OAAO,GAAzB,MAAM;IACW,GAAG,EAApB,MAAM;IACW,MAAM,EAAvB,MAAM;IACW,OAAO,EAAxB,MAAM;IACW,QAAQ,EAAzB,MAAM;kBACN,SAAS,EAAE,GACT,SAAS,CAkOrB;AAjRD,oEAA2E;AAI3E,oIAEG;AASH,sIAEG;AAyQH,8CAIE;0BA1SwB,oCAAoC;4CAClB,sDAAsD;iCACjE,kCAAkC"}
+{"version":3,"file":"fragment_gbuffer.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/material/standard/fragment_gbuffer.js"],"names":[],"mappings":"AA8EA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAR6B,OAAO,GAAzB,MAAM;IACW,GAAG,EAApB,MAAM;IACW,MAAM,EAAvB,MAAM;IACW,OAAO,EAAxB,MAAM;IACW,QAAQ,EAAzB,MAAM;kBACN,SAAS,EAAE,GACT,SAAS,CAwOrB;AAvRD,oEAA2E;AAI3E,oIAEG;AASH,sIAEG;AA+QH,8CAIE;0BAhTwB,oCAAoC;4CAClB,sDAAsD;iCACjE,kCAAkC"}

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

@@ -6,6 +6,7 @@ import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
 import { GEOMETRY_ATTRIBUTE_DATA_TYPE } from "../../geometry/GEOMETRY_ATTRIBUTE_DATA_TYPE.js";
 import { GEOMETRY_METADATA_STRUCT } from "../../geometry/GEOMETRY_METADATA_STRUCT.js";
 import { MESHLET_METADATA_STRUCT } from "../../geometry/meshlet/encoding/MESHLET_METADATA_STRUCT.js";
+import { chunk_node3d_flags } from "../../scene/chunk_node3d_flags.js";
 import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
 import { RENDER_GLOBAL_MIP_BIAS } from "../../postprocess/taa/RENDER_GLOBAL_MIP_BIAS.js";
 import { chunk_barycentric_full } from "../../shader/chunk/geometry/triangle/chunk_barycentric_full.js";
@@ -225,7 +226,12 @@ fn main(
     );
 
     // Get tangent handedness from the provoking vertex (0).
-    let geometry_tangent_handedness = vertex_0.tangent.w;
+    // a reflection changes the tangent frame's handedness — see NODE3D_GLOBAL_FLAG_MIRRORED
+    let geometry_tangent_handedness = select(
+        vertex_0.tangent.w,
+        -vertex_0.tangent.w,
+        node3d_global_is_mirrored(node)
+    );
 
     let geometry_color = interpolate_attribute_3f32(
         vertex_0.color,
@@ -316,6 +322,7 @@ fn main(
         chunk_rgbe9995_encode,
         chunk_dither_color_8bit_triangle_noise,
         chunk_scene_database_access,
+        chunk_node3d_flags,
 
         ...extra_chunks,
     ]

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":"AAYA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AAuD3B,iDAIG;6BA3G0B,mCAAmC;8BAGlC,+BAA+B"}
+{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AA2D3B,iDAIG;6BAhH0B,mCAAmC;8BAIlC,+BAA+B"}

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

@@ -3,6 +3,7 @@ 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 { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
+import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -52,9 +53,8 @@ export const EMIT_SETTINGS = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
-// TODO(chrome-153): uniform, not immediate — Dawn 153 overwrites immediate data on
-//      dispatchWorkgroupsIndirect, so this reads garbage. The graph pass turns the plain
-//      value into a transient uniform, so no call site changes.
+resources.setImmediate('settings', EMIT_SETTINGS);
+
 resources.createGroup()
     .addStorageBuffer("scene_database", WebGPUArray.u32, false)
     .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
@@ -63,9 +63,7 @@ resources.createGroup()
     .addStorageBuffer("pool", WebGPUArray.u32, true)
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    // last in the group, so the storage bindings keep the indices the specs read by
-    .addUniform('settings', EMIT_SETTINGS);
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
 
 const body = CodeChunk.from(
     /* language=wgsl */
@@ -74,8 +72,14 @@ const COUNTER_ALIVE : u32 = ${PARTICLE_COUNTER.ALIVE}u;
 const COUNTER_DEAD : u32 = ${PARTICLE_COUNTER.DEAD}u;
 
 @compute @workgroup_size(${PARTICLE_EMIT_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
-    let i = gid.x;
+fn main(
+    @builtin(workgroup_id) workgroup_id : vec3<u32>,
+    @builtin(num_workgroups) group_count : vec3<u32>,
+    @builtin(local_invocation_index) local_index : u32,
+) {
+    // shader_prefix_sum_to_command folds its count over three dimensions, so the newborn this lane
+    // belongs to is the flattened workgroup, not gid.x. Identical while y and z are 1.
+    let i = grid3d_to_index(workgroup_id, group_count.xy) * ${PARTICLE_EMIT_WORKGROUP_SIZE}u + local_index;
 
     let assignment = particle_emit_assignment(&spawn_prefix.elements, spawn_prefix.count, i);
     if (!assignment.valid) { return; }
@@ -99,6 +103,7 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
     alive_out[a] = slot;
 }
 `, [
+    chunk_grid3d_to_index,
     chunk_particle_emit_step,
     chunk_particle_vm_registers_fast,
 ]);

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":";AAuDA;;;;;GAKG;AACH,gCAFU,YAAY,CAMS;AAyD/B,qDAIG;iDAvH8C,yBAAyB;6BAJ7C,mCAAmC;8BAClC,+BAA+B"}
+{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":";AAuDA;;;;;GAKG;AACH,gCAFU,YAAY,CAMS;AAsD/B,qDAIG;iDApH8C,yBAAyB;6BAJ7C,mCAAmC;8BAClC,+BAA+B"}

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

@@ -67,9 +67,8 @@ export const SIMULATE_SETTINGS = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
-// TODO(chrome-153): uniform, not immediate — Dawn 153 overwrites immediate data on
-//      dispatchWorkgroupsIndirect, so this reads garbage. The graph pass turns the plain
-//      value into a transient uniform, so no call site changes.
+resources.setImmediate('settings', SIMULATE_SETTINGS);
+
 resources.createGroup()
     .addStorageBuffer("scene_database", WebGPUArray.u32, false)
     .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
@@ -78,9 +77,7 @@ resources.createGroup()
     .addStorageBuffer("sim_list", WebGPUArray.u32, false)
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    // last in the group, so the storage bindings keep the indices the specs read by
-    .addUniform('settings', SIMULATE_SETTINGS);
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
 
 
 const body = CodeChunk.from(/* language=wgsl */ `

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AA8BA;;;GAGG;AACH,0CAFU,SAAS,CA8FlB;AAED,mDAsHC;0BA/NyB,oCAAoC"}
+{"version":3,"file":"chunk_sample_material_data.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js"],"names":[],"mappings":"AAiCA;;;GAGG;AACH,0CAFU,SAAS,CA8FlB;AAED,mDA+HC;0BAxOyB,oCAAoC"}

package/src/shade/renderer/path_tracer/shader/chunk_sample_material_data.js

@@ -1,4 +1,7 @@
 import { chunk_compute_normal_matrix_from_m4 } from "../../shader/chunk/geometry/mat4/chunk_compute_normal_matrix_from_m4.js";
+import {
+    chunk_mat4_linear_determinant
+} from "../../shader/chunk/geometry/mat4/chunk_mat4_linear_determinant.js";
 import { chunk_decode_tangent_normal } from "../../shader/chunk/geometry/normal/chunk_decode_tangent_normal.js";
 import { chunk_F_Hauber } from "../../shader/chunk/brdf/fresnel/chunk_F_Hauber.js";
 import {
@@ -201,7 +204,15 @@ fn sample_material_data(
         world_face_normal = -world_face_normal;
     }
 
-    let world_tangent_frame = build_orthonormal_matrix_nt(world_vertex_normal, vec4(world_tangent, geometry_tangent.w));
+    // a reflection changes the tangent frame's handedness — see NODE3D_GLOBAL_FLAG_MIRRORED.
+    // No node here: the tracer is handed a matrix, so the sign comes off the matrix.
+    let tangent_handedness = select(
+        geometry_tangent.w,
+        -geometry_tangent.w,
+        mat4_linear_determinant(instance_transform) < 0.0
+    );
+
+    let world_tangent_frame = build_orthonormal_matrix_nt(world_vertex_normal, vec4(world_tangent, tangent_handedness));
 
     var normal_sample = decode_tangent_normal(indirect_sample_texture(material.texture_normal, material.sampler_normal, uv));
     
@@ -238,6 +249,7 @@ fn sample_material_data(
         chunk_interpolate_attribute_3f32,
         chunk_interpolate_attribute_4f32,
         chunk_compute_normal_matrix_from_m4,
+        chunk_mat4_linear_determinant,
         chunk_build_orthonormal_matrix_nt,
         chunk_decode_tangent_normal,
         chunk_compute_triangle_face_normal,

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

@@ -9,9 +9,14 @@ export function construct_primitive_state(draw_mode: ShadeDrawMode, side: ShadeD
 /**
  * Named cull-mode lookup tables, keyed by {@link ShadeDrawSide }.
  *
- *  - `Standard` is the main-pass mapping: a `Front`-sided material renders its front face
- *    (cull back), `Back` renders its back face (cull front), `Double` renders both.
- *  - `Reversed` flips sided materials so the *back* face is what gets drawn. This is the
+ * `Front` and `Back` map to the same cull mode, because the winding they differ by is the
+ * vertex shader's to reverse — see `chunk_triangle_list_reverse_winding`. That is what lets
+ * them share a bucket, and it is why nothing here needs a fourth entry for the *instance's*
+ * handedness either.
+ *
+ *  - `Standard` is the main-pass mapping: a one-sided material renders the face its winding
+ *    presents (cull back), `Double` renders both.
+ *  - `Reversed` culls the other way, so the *back* face is what gets drawn. This is the
  *    standard "back-face shadow casting" / "front-face culling for shadow casters"
  *    technique — shadow callers select this policy so the surface written into the shadow
  *    map sits behind the lit surface, eliminating self-shadow acne on the lit side and
@@ -21,12 +26,21 @@ export function construct_primitive_state(draw_mode: ShadeDrawMode, side: ShadeD
 export type CullPolicy = Readonly<Record<number, GPUCullMode>>;
 export namespace CullPolicy {
     let Standard: Readonly<{
-        [x: number]: "none" | "back" | "front";
+        [x: number]: "none" | "back";
     }>;
     let Reversed: Readonly<{
-        [x: number]: "none" | "back" | "front";
+        [x: number]: "none" | "front";
     }>;
 }
+/**
+ * One {@link ShadeDrawSide} per rasterization bucket — the sides that still differ once `Back`
+ * is drawn as a reversed `Front`. Callers that enumerate buckets iterate this rather than the
+ * enum, so a `Back`-sided material is picked up by the `Front` pass rather than by a pass of
+ * its own that would repeat the whole expansion chain for it.
+ *
+ * @type {ReadonlyArray<ShadeDrawSide>}
+ */
+export const RASTERIZATION_BUCKET_SIDES: ReadonlyArray<ShadeDrawSide>;
 import { ShadeDrawMode } from "../../material/ShadeDrawMode.js";
 import { ShadeDrawSide } from "../../material/ShadeDrawSide.js";
 import { PrimitiveState } from "../../../descriptor/pipeline/render/PrimitiveState.js";

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

@@ -1 +1 @@
-{"version":3,"file":"construct_primitive_state.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/construct_primitive_state.js"],"names":[],"mappings":"AAoCA;;;;;;GAMG;AACH,qDALW,aAAa,QACb,aAAa,gBACb,SAAS,OAAO,MAAM,cAAc,CAAC,GACnC,cAAc,CAgB1B;;;;;;;;;;;;;yBApCS,SAAS,OAAO,MAAM,cAAc,CAAC;;;;;;;;;8BApBjB,iCAAiC;8BACjC,iCAAiC;+BAFhC,uDAAuD"}
+{"version":3,"file":"construct_primitive_state.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/construct_primitive_state.js"],"names":[],"mappings":"AAsDA;;;;;;GAMG;AACH,qDALW,aAAa,QACb,aAAa,gBACb,SAAS,OAAO,MAAM,cAAc,CAAC,GACnC,cAAc,CAgB1B;;;;;;;;;;;;;;;;;;yBAjDS,SAAS,OAAO,MAAM,cAAc,CAAC;;;;;;;;;AAe/C;;;;;;;GAOG;AACH,yCAFU,cAAc,aAAa,CAAC,CAKnC;8BAnD2B,iCAAiC;8BACjC,iCAAiC;+BAFhC,uDAAuD"}

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

@@ -10,9 +10,14 @@ const lut_topology = {
 /**
  * Named cull-mode lookup tables, keyed by {@link ShadeDrawSide}.
  *
- *  - `Standard` is the main-pass mapping: a `Front`-sided material renders its front face
- *    (cull back), `Back` renders its back face (cull front), `Double` renders both.
- *  - `Reversed` flips sided materials so the *back* face is what gets drawn. This is the
+ * `Front` and `Back` map to the same cull mode, because the winding they differ by is the
+ * vertex shader's to reverse — see `chunk_triangle_list_reverse_winding`. That is what lets
+ * them share a bucket, and it is why nothing here needs a fourth entry for the *instance's*
+ * handedness either.
+ *
+ *  - `Standard` is the main-pass mapping: a one-sided material renders the face its winding
+ *    presents (cull back), `Double` renders both.
+ *  - `Reversed` culls the other way, so the *back* face is what gets drawn. This is the
  *    standard "back-face shadow casting" / "front-face culling for shadow casters"
  *    technique — shadow callers select this policy so the surface written into the shadow
  *    map sits behind the lit surface, eliminating self-shadow acne on the lit side and
@@ -24,16 +29,29 @@ const lut_topology = {
 export const CullPolicy = {
     Standard: Object.freeze({
         [ShadeDrawSide.Front]:  'back',
-        [ShadeDrawSide.Back]:   'front',
+        [ShadeDrawSide.Back]:   'back',
         [ShadeDrawSide.Double]: 'none',
     }),
     Reversed: Object.freeze({
         [ShadeDrawSide.Front]:  'front',
-        [ShadeDrawSide.Back]:   'back',
+        [ShadeDrawSide.Back]:   'front',
         [ShadeDrawSide.Double]: 'none',
     }),
 };
 
+/**
+ * One {@link ShadeDrawSide} per rasterization bucket — the sides that still differ once `Back`
+ * is drawn as a reversed `Front`. Callers that enumerate buckets iterate this rather than the
+ * enum, so a `Back`-sided material is picked up by the `Front` pass rather than by a pass of
+ * its own that would repeat the whole expansion chain for it.
+ *
+ * @type {ReadonlyArray<ShadeDrawSide>}
+ */
+export const RASTERIZATION_BUCKET_SIDES = Object.freeze([
+    ShadeDrawSide.Front,
+    ShadeDrawSide.Double,
+]);
+
 /**
  *
  * @param {ShadeDrawMode} draw_mode

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

@@ -1 +1 @@
-{"version":3,"file":"filter_materials_by_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/filter_materials_by_bucket.js"],"names":[],"mappings":"AAKA;;;;;;;;;;GAUG;AACH,mDATW,eAAe,iBACf,MAAM,cACN,gBAAgB,aAChB,aAAa,aACb,aAAa,aACb,eAAe,SACf,MAAM,GACJ,MAAM,CAsClB;iCAjDgC,oCAAoC;8BAFvC,iCAAiC;8BACjC,iCAAiC"}
+{"version":3,"file":"filter_materials_by_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/filter_materials_by_bucket.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,mDATW,eAAe,iBACf,MAAM,cACN,gBAAgB,aAChB,aAAa,aACb,aAAa,aACb,eAAe,SACf,MAAM,GACJ,MAAM,CA4ClB;iCAxDgC,oCAAoC;8BAFvC,iCAAiC;8BACjC,iCAAiC"}