@woosh/meep-engine 3.46.0 → 3.49.0

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_emit_hierarchy.d.ts

@@ -9,8 +9,8 @@ export const BVH_EMIT_WORKGROUP_SIZE: 64;
  * arena. Root-at-node-0 is what both conventions want, which is why one kernel can serve them.
  *
  * One dispatch of `n` threads with a tail `if`, which is the canonical LBVH formulation: thread `i`
- * always writes leaf `(n-1)+i`, and threads below `n-1` additionally derive internal node `i`'s
- * range and split and wire its two children.
+ * always writes leaf `(n-1)+i`, and threads below `n-1` additionally wire internal node `i`'s two
+ * children, which {@link chunk_bvh_internal_children} derives from its range and split.
  *
  * Barrier-free, atomic-free, subgroup-free, and a pure function of the sorted keys — deliberately,
  * because that is what lets the WGSL emulator execute this kernel point-wise in vitest against the

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_emit_hierarchy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_bvh_emit_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_emit_hierarchy.js"],"names":[],"mappings":"AAgBA,yCAA0C;AAwG1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wCAFU,aAAa,CAMpB;8BA5I2B,+BAA+B"}
+{"version":3,"file":"shader_bvh_emit_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_emit_hierarchy.js"],"names":[],"mappings":"AAeA,yCAA0C;AAgG1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wCAFU,aAAa,CAMpB;8BAnI2B,+BAA+B"}

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_emit_hierarchy.js

@@ -11,8 +11,7 @@ import {
     BVH_NODE_STRIDE_WORDS
 } from "./BVH_BUFFER_LAYOUT.js";
 import { BVH_BUILD_SETTINGS_STRUCT, BVH_NO_ROOT_WORD } from "./BVH_BUILD_SETTINGS_STRUCT.js";
-import { chunk_bvh_determine_range } from "./chunk_bvh_determine_range.js";
-import { chunk_bvh_find_split } from "./chunk_bvh_find_split.js";
+import { chunk_bvh_internal_children } from "./chunk_bvh_internal_children.js";
 
 export const BVH_EMIT_WORKGROUP_SIZE = 64;
 
@@ -79,17 +78,10 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
 
     // n leaves, n-1 internal nodes — the tail thread has only a leaf to write.
     if (i < n - 1u) {
-        let range = bvh_determine_range(&keys, n, i);
+        let children = bvh_internal_children(n, i);
 
-        let first = range.x;
-        let last = range.y;
-
-        let split = bvh_find_split(&keys, n, first, last);
-
-        // A subrange of one element is a leaf; otherwise it is owned by the internal node whose
-        // left boundary sits at that code index.
-        let child_1 = select(split, (n - 1u) + split, split == first);
-        let child_2 = select(split + 1u, (n - 1u) + split + 1u, split + 1u == last);
+        let child_1 = children.x;
+        let child_2 = children.y;
 
         let node_word = bvh_node_word(i);
 
@@ -114,8 +106,7 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
 }
 `, [
     BVH_NULL_NODE_DEFINITION,
-    chunk_bvh_determine_range,
-    chunk_bvh_find_split,
+    chunk_bvh_internal_children,
 ]);
 
 /**
@@ -128,8 +119,8 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
  * arena. Root-at-node-0 is what both conventions want, which is why one kernel can serve them.
  *
  * One dispatch of `n` threads with a tail `if`, which is the canonical LBVH formulation: thread `i`
- * always writes leaf `(n-1)+i`, and threads below `n-1` additionally derive internal node `i`'s
- * range and split and wire its two children.
+ * always writes leaf `(n-1)+i`, and threads below `n-1` additionally wire internal node `i`'s two
+ * children, which {@link chunk_bvh_internal_children} derives from its range and split.
  *
  * Barrier-free, atomic-free, subgroup-free, and a pure function of the sorted keys — deliberately,
  * because that is what lets the WGSL emulator execute this kernel point-wise in vitest against the

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_morton.d.ts

@@ -2,10 +2,9 @@ export const BVH_MORTON_WORKGROUP_SIZE: 64;
 /**
  * Morton code per leaf — pass 1 of {@link graph_bvh_build_lbvh}.
  *
- * The leaf's centroid is quantised to ten bits per axis inside the scene bounds and interleaved
- * into a 30-bit code, matching `v3_morton_encode_bounded` + `v3_morton_encode_normalized` on the
- * CPU term for term (`round(1023 * t)`, zero-extent axes scaled by zero). `values[i] = i` seeds the
- * permutation the sort then carries.
+ * The code itself is {@link chunk_bvh_morton_code}, shared with the one-workgroup build so both
+ * paths sort the same leaves by the same codes. `values[i] = i` seeds the permutation the sort then
+ * carries.
  *
  * Pure per-invocation: no barriers, no atomics, no subgroups — which is what lets the emulator tier
  * run it point-wise against the CPU encoder.

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_morton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_bvh_morton.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_morton.js"],"names":[],"mappings":"AAQA,2CAA4C;AA6D5C;;;;;;;;;;;;GAYG;AACH,gCAFU,aAAa,CAMpB;8BAlF2B,+BAA+B"}
+{"version":3,"file":"shader_bvh_morton.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/bvh/shader_bvh_morton.js"],"names":[],"mappings":"AAQA,2CAA4C;AA6C5C;;;;;;;;;;;GAWG;AACH,gCAFU,aAAa,CAMpB;8BAlE2B,+BAA+B"}

package/src/shade/renderer/gpu_primitive/bvh/shader_bvh_morton.js

@@ -1,10 +1,10 @@
 import { f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { chunk_v3_morton_encode } from "../../shader/chunk/bvh/morton/chunk_v3_morton_encode.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { BVH_BUILD_SETTINGS_STRUCT } from "./BVH_BUILD_SETTINGS_STRUCT.js";
+import { chunk_bvh_morton_code } from "./chunk_bvh_morton_code.js";
 
 export const BVH_MORTON_WORKGROUP_SIZE = 64;
 
@@ -39,41 +39,24 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     let low = vec3<f32>(leaf_bounds[base], leaf_bounds[base + 1u], leaf_bounds[base + 2u]);
     let high = vec3<f32>(leaf_bounds[base + 3u], leaf_bounds[base + 4u], leaf_bounds[base + 5u]);
 
-    let centroid = (low + high) * 0.5;
-
     let scene_low = vec3<f32>(scene_bounds[0], scene_bounds[1], scene_bounds[2]);
     let scene_high = vec3<f32>(scene_bounds[3], scene_bounds[4], scene_bounds[5]);
 
-    let span = scene_high - scene_low;
-
-    // An axis of zero extent contributes nothing to the code, exactly as it does in
-    // v3_morton_encode_bounded — every centroid quantises to 0 along it rather than to a division
-    // by zero.
-    let scale = select(vec3<f32>(0.0), vec3<f32>(1.0) / span, span != vec3<f32>(0.0));
-
-    // The centroid of a leaf box is inside the union of every leaf box by construction, so the
-    // clamp never binds on well-formed input; it is here so that a rounding error at the extreme,
-    // or a NaN-free degenerate box, cannot produce an out-of-range quantised coordinate.
-    let normalized = clamp((centroid - scene_low) * scale, vec3<f32>(0.0), vec3<f32>(1.0));
-
-    let quantised = vec3<u32>(round(normalized * 1023.0));
-
-    keys[i] = v3_morton_encode(quantised.x, quantised.y, quantised.z);
+    keys[i] = bvh_morton_code(low, high, scene_low, scene_high);
 
     // the sort carries this along as the payload, so after it the leaves are in Morton order
     values[i] = i;
 }
 `, [
-    chunk_v3_morton_encode,
+    chunk_bvh_morton_code,
 ]);
 
 /**
  * Morton code per leaf — pass 1 of {@link graph_bvh_build_lbvh}.
  *
- * The leaf's centroid is quantised to ten bits per axis inside the scene bounds and interleaved
- * into a 30-bit code, matching `v3_morton_encode_bounded` + `v3_morton_encode_normalized` on the
- * CPU term for term (`round(1023 * t)`, zero-extent axes scaled by zero). `values[i] = i` seeds the
- * permutation the sort then carries.
+ * The code itself is {@link chunk_bvh_morton_code}, shared with the one-workgroup build so both
+ * paths sort the same leaves by the same codes. `values[i] = i` seeds the permutation the sort then
+ * carries.
  *
  * Pure per-invocation: no barriers, no atomics, no subgroups — which is what lets the emulator tier
  * run it point-wise against the CPU encoder.

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

@@ -1,3 +1,13 @@
+/**
+ * The pipeline {@link build_indirect_compute_dispatch_command} dispatches for these arguments — the
+ * one a pass that builds its command this way offers to a {@link PipelineEnquiry}.
+ *
+ * @param {GPUDevice} device
+ * @param {number} elements_per_workgroup
+ * @param {boolean} fold
+ * @returns {ComputePipelineDescriptor}
+ */
+export function indirect_compute_dispatch_command_pipeline(device: GPUDevice, elements_per_workgroup: number, fold: boolean): ComputePipelineDescriptor;
 /**
  *
  * @param {number} elements_per_workgroup
@@ -21,5 +31,6 @@ export function build_indirect_compute_dispatch_command(elements_per_workgroup:
  */
 export function graph_build_indirect_dispatch_command(graph: FrameGraph, input: number, workgroup_size?: number, fold?: boolean): number;
 export const INDIRECT_COMPUTE_COMMAND_DESCRIPTOR: BufferResourceDescriptor;
+import { ComputePipelineDescriptor } from "../../../descriptor/pipeline/compute/ComputePipelineDescriptor.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 //# sourceMappingURL=IndirectComputeCommandBuildPass.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IndirectComputeCommandBuildPass.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/indirect/IndirectComputeCommandBuildPass.js"],"names":[],"mappings":"AA+LA;;;;;;;;;;;GAWG;AACH,gFAVW,MAAM,iFAGN,MAAM,oDAEN,MAAM,SACN,OAAO,QAuFjB;AAED;;;;;;;GAOG;AACH,gFALW,MAAM,mBACN,MAAM,SACN,OAAO,GACL,MAAM,CAkClB;AA9ID,2EAIE;yCAxLuC,mDAAmD"}
+{"version":3,"file":"IndirectComputeCommandBuildPass.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/indirect/IndirectComputeCommandBuildPass.js"],"names":[],"mappings":"AAgMA;;;;;;;;GAQG;AACH,sGAJW,MAAM,QACN,OAAO,GACL,yBAAyB,CAIrC;AACD;;;;;;;;;;;GAWG;AACH,gFAVW,MAAM,iFAGN,MAAM,oDAEN,MAAM,SACN,OAAO,QAqFjB;AAED;;;;;;;GAOG;AACH,gFALW,MAAM,mBACN,MAAM,SACN,OAAO,GACL,MAAM,CAkClB;AAzJD,2EAIE;0CAzLwC,mEAAmE;yCACpE,mDAAmD"}

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

@@ -189,6 +189,19 @@ export const INDIRECT_COMPUTE_COMMAND_DESCRIPTOR = BufferResourceDescriptor.from
     GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT
     // note, no clear since the command is fully written out by the pass
 );
+
+/**
+ * The pipeline {@link build_indirect_compute_dispatch_command} dispatches for these arguments — the
+ * one a pass that builds its command this way offers to a {@link PipelineEnquiry}.
+ *
+ * @param {GPUDevice} device
+ * @param {number} elements_per_workgroup
+ * @param {boolean} fold
+ * @returns {ComputePipelineDescriptor}
+ */
+export function indirect_compute_dispatch_command_pipeline(device, elements_per_workgroup, fold) {
+    return pipeline_cache.getOrCompute(PipelineCacheKey.from(device, elements_per_workgroup, fold), create_pipeline);
+}
 /**
  *
  * @param {number} elements_per_workgroup
@@ -259,9 +272,7 @@ export function build_indirect_compute_dispatch_command(
 
     }
 
-    const key = PipelineCacheKey.from(device, elements_per_workgroup, fold);
-
-    const pipeline = pipeline_cache.getOrCompute(key, create_pipeline);
+    const pipeline = indirect_compute_dispatch_command_pipeline(device, elements_per_workgroup, fold);
 
     const pass = encoder.constructComputePass({
         pipeline: pipeline,

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

@@ -1,3 +1,12 @@
+/**
+ * The pipeline {@link build_indirect_draw_command} dispatches for this pattern — the one a pass that
+ * builds its draw command this way offers to a {@link PipelineEnquiry}.
+ *
+ * @param {GPUDevice} device
+ * @param {string} pattern
+ * @returns {ComputePipelineDescriptor}
+ */
+export function indirect_draw_command_pipeline(device: GPUDevice, pattern: string): ComputePipelineDescriptor;
 /**
  *
  * @param {GPUDevice} device
@@ -7,4 +16,5 @@
  * @param {GPUBuffer} buffer_command
  */
 export function build_indirect_draw_command(device: GPUDevice, pattern: string, encoder: ShadeGPUCommandContext, buffer_input: GPUBuffer, buffer_command: GPUBuffer): void;
+import { ComputePipelineDescriptor } from "../../../descriptor/pipeline/compute/ComputePipelineDescriptor.js";
 //# sourceMappingURL=build_indirect_draw_command.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"build_indirect_draw_command.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/indirect/build_indirect_draw_command.js"],"names":[],"mappings":"AAuFA;;;;;;;GAOG;AACH,wEALW,MAAM,6FAqBhB"}
+{"version":3,"file":"build_indirect_draw_command.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/indirect/build_indirect_draw_command.js"],"names":[],"mappings":"AAuFA;;;;;;;GAOG;AACH,2EAHW,MAAM,GACJ,yBAAyB,CAIrC;AAED;;;;;;;GAOG;AACH,wEALW,MAAM,6FAmBhB;0CAnHyC,mEAAmE"}

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

@@ -85,6 +85,18 @@ const pipeline_cache = new Cache({
 
 const command_buffer_size = STRUCT_UNINDEXED_DRAW_COMMAND.aligned_size;
 
+/**
+ * The pipeline {@link build_indirect_draw_command} dispatches for this pattern — the one a pass that
+ * builds its draw command this way offers to a {@link PipelineEnquiry}.
+ *
+ * @param {GPUDevice} device
+ * @param {string} pattern
+ * @returns {ComputePipelineDescriptor}
+ */
+export function indirect_draw_command_pipeline(device, pattern) {
+    return pipeline_cache.getOrCompute(PipelineCacheKey.from(device, pattern), create_pipeline);
+}
+
 /**
  *
  * @param {GPUDevice} device
@@ -94,9 +106,7 @@ const command_buffer_size = STRUCT_UNINDEXED_DRAW_COMMAND.aligned_size;
  * @param {GPUBuffer} buffer_command
  */
 export function build_indirect_draw_command(device, pattern, encoder, buffer_input, buffer_command) {
-    const key = PipelineCacheKey.from(device, pattern);
-
-    const pipeline = pipeline_cache.getOrCompute(key, create_pipeline);
+    const pipeline = indirect_draw_command_pipeline(device, pattern);
 
     const pass = encoder.constructComputePass({
         pipeline: pipeline,

package/src/shade/renderer/gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import("../../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
 /**
  * A transient {@link graph_prefix_scan_csdldf} output for up to `element_max_count` elements: the count, padded to 16
  * bytes, then the sums in whole vec4 blocks. The scan writes the count itself, so nothing needs clearing.
@@ -6,6 +9,12 @@
  * @returns {BufferResourceDescriptor}
  */
 export function prefix_scan_csdldf_output_descriptor(element_max_count: number): BufferResourceDescriptor;
+/**
+ * Offer the pipelines {@link graph_prefix_scan_csdldf} dispatches — see {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_prefix_scan_csdldf_pipelines(enquiry: PipelineEnquiry): void;
 /**
  * Indirect pass.
  * Inclusive prefix sums of `input` into `output`.
@@ -39,5 +48,6 @@ export function graph_prefix_scan_csdldf({ graph, input, output, element_max_cou
     output: number;
     element_max_count?: number;
 }): number;
+export type PipelineEnquiry = import("../../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 import { BufferResourceDescriptor } from "../../../../device/graph/BufferResourceDescriptor.js";
 //# sourceMappingURL=graph_prefix_scan_csdldf.d.ts.map

package/src/shade/renderer/gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_prefix_scan_csdldf.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AACH,wEAHW,MAAM,GACJ,wBAAwB,CAMpC;AAGD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAP+B,KAAK;IACT,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IAEW,iBAAiB,GAAlC,MAAM;IACJ,MAAM,CAwElB;yCA3HwC,sDAAsD"}
+{"version":3,"file":"graph_prefix_scan_csdldf.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js"],"names":[],"mappings":"AAeA;;GAEG;AAEH;;;;;;GAMG;AACH,wEAHW,MAAM,GACJ,wBAAwB,CAMpC;AAGD;;;;GAIG;AACH,8DAFW,eAAe,QAKzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAP+B,KAAK;IACT,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IAEW,iBAAiB,GAAlC,MAAM;IACJ,MAAM,CAwElB;8BA5HY,OAAO,gDAAgD,EAAE,eAAe;yCAb5C,sDAAsD"}

package/src/shade/renderer/gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js

@@ -13,6 +13,10 @@ import {
     shader_prefix_scan_csdldf_prepare
 } from "./shader_prefix_scan_csdldf.js";
 
+/**
+ * @typedef {import("../../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+
 /**
  * A transient {@link graph_prefix_scan_csdldf} output for up to `element_max_count` elements: the count, padded to 16
  * bytes, then the sums in whole vec4 blocks. The scan writes the count itself, so nothing needs clearing.
@@ -27,6 +31,16 @@ export function prefix_scan_csdldf_output_descriptor(element_max_count) {
 }
 
 
+/**
+ * Offer the pipelines {@link graph_prefix_scan_csdldf} dispatches — see {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_prefix_scan_csdldf_pipelines(enquiry) {
+    enquiry.compute.push(shader_prefix_scan_csdldf_prepare.pipeline);
+    enquiry.compute.push(shader_prefix_scan_csdldf.pipeline);
+}
+
 /**
  * Indirect pass.
  * Inclusive prefix sums of `input` into `output`.

package/src/shade/renderer/gpu_primitive/sort/chunk_sort_bitonic_comparator.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The index arithmetic of a bitonic sorting network, as pure functions, so the emulator tier can
+ * check it against what a sorting network has to be. The barrier-carrying loop that runs the
+ * network is {@link chunk_sort_bitonic_workgroup}.
+ *
+ * The network over `size` slots (a power of two) runs its steps in order:
+ * `block = 2, 4, ..., size`, and inside each block `stride = block / 2, ..., 1`. Every step is
+ * `size / 2` comparators that touch disjoint slots, so a step's comparators can run in any order
+ * or all at once.
+ *
+ * - `sort_bitonic_comparator(pair, block, stride)` gives the two slots comparator `pair` of that
+ *   step joins: they are `stride` apart and inside one `block`. The slot the smaller element
+ *   belongs in comes first. Blocks alternate direction until the last step, where `block == size`
+ *   and every comparator ascends.
+ * - `sort_pair_less` is the order sorted by: key first, then value. With every value distinct, it
+ *   is a total order and the network's output is unique. Seeding each value with its element's
+ *   input index makes that output exactly the stable sort by key, so an unstable network gives
+ *   the same answer an LSD radix sort does.
+ * - `sort_bitonic_size(count)` is the network a sort of `count` elements runs: the smallest power
+ *   of two holding them, and 1 for a count of 0 or 1, which has no steps.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sort_bitonic_comparator: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sort_bitonic_comparator.d.ts.map

package/src/shade/renderer/gpu_primitive/sort/chunk_sort_bitonic_comparator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sort_bitonic_comparator.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/chunk_sort_bitonic_comparator.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,4CAFU,SAAS,CA4BhB;0BAnDuB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/sort/chunk_sort_bitonic_comparator.js

@@ -0,0 +1,52 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * The index arithmetic of a bitonic sorting network, as pure functions, so the emulator tier can
+ * check it against what a sorting network has to be. The barrier-carrying loop that runs the
+ * network is {@link chunk_sort_bitonic_workgroup}.
+ *
+ * The network over `size` slots (a power of two) runs its steps in order:
+ * `block = 2, 4, ..., size`, and inside each block `stride = block / 2, ..., 1`. Every step is
+ * `size / 2` comparators that touch disjoint slots, so a step's comparators can run in any order
+ * or all at once.
+ *
+ * - `sort_bitonic_comparator(pair, block, stride)` gives the two slots comparator `pair` of that
+ *   step joins: they are `stride` apart and inside one `block`. The slot the smaller element
+ *   belongs in comes first. Blocks alternate direction until the last step, where `block == size`
+ *   and every comparator ascends.
+ * - `sort_pair_less` is the order sorted by: key first, then value. With every value distinct, it
+ *   is a total order and the network's output is unique. Seeding each value with its element's
+ *   input index makes that output exactly the stable sort by key, so an unstable network gives
+ *   the same answer an LSD radix sort does.
+ * - `sort_bitonic_size(count)` is the network a sort of `count` elements runs: the smallest power
+ *   of two holding them, and 1 for a count of 0 or 1, which has no steps.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sort_bitonic_comparator = CodeChunk.from(
+    //language=WGSL
+    `
+fn sort_bitonic_comparator(pair: u32, block: u32, stride: u32) -> vec2<u32> {
+    // spread the pair index around a zero at the stride's bit
+    let low = ((pair & ~(stride - 1u)) << 1u) | (pair & (stride - 1u));
+    let high = low | stride;
+
+    if ((low & block) == 0u) {
+        return vec2<u32>(low, high);
+    }
+
+    return vec2<u32>(high, low);
+}
+
+fn sort_pair_less(key_a: u32, value_a: u32, key_b: u32, value_b: u32) -> bool {
+    return key_a < key_b || (key_a == key_b && value_a < value_b);
+}
+
+fn sort_bitonic_size(count: u32) -> u32 {
+    if (count <= 1u) {
+        return 1u;
+    }
+
+    return 1u << (32u - countLeadingZeros(count - 1u));
+}
+`);

package/src/shade/renderer/gpu_primitive/sort/chunk_sort_bitonic_workgroup.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Sort up to one tile of `(key, value)` pairs in workgroup memory with a bitonic network, by
+ * {@link sort_pair_less}: ascending by key, then by value. Seed each value with its element's index
+ * and that is a stable sort by key. That is the order {@link graph_radix_sort} produces, so a
+ * caller can swap a one-workgroup sort for the multi-pass one and get the same permutation.
+ *
+ * `sort_bitonic_workgroup(thread_id, count)` sorts slots `[0, count)` of the module-scope workgroup
+ * arrays `keys` and `values`. It reads them by name, as {@link chunk_bvh_refit_climb} reads its
+ * arrays. Each array holds at least {@link SORT_TILE_SIZE} `u32`s and the caller has written the
+ * first `count` of each. The workgroup is {@link SORT_WORKGROUP_SIZE} threads and `thread_id` is
+ * `local_invocation_index`. The sort fences the caller's writes itself, and returns behind a
+ * barrier with the sorted pairs readable by every thread.
+ *
+ * The network spans {@link sort_bitonic_size}`(count)` slots. The ones past `count` are padded with
+ * the largest pair, `(0xffffffff, 0xffffffff)`, which sorts behind every real one. A real pair
+ * equal to it would be indistinguishable from padding, so values below `0xffffffff` are the
+ * caller's contract.
+ *
+ * Why bitonic and not the radix sort's own in-tile split. The scatter's stable binary split
+ * ({@link chunk_sort_rank}) sorts one bit per round in place, and each round is a workgroup scan
+ * of about fifteen barriers. A 30-bit key is thirty rounds, about 450 barriers, at any count. This
+ * network is `log2(size) * (log2(size) + 1) / 2` steps of one barrier each: 55 at a full tile and
+ * 10 at 16 elements. Each thread does at most {@link PAIRS_PER_THREAD} compare-exchanges per step.
+ * Every loop's trip count comes from `count` and the tile constants. Call this from
+ * workgroup-uniform control flow with a uniform `count`, because the steps' barriers sit under
+ * loops bounded by it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sort_bitonic_workgroup: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sort_bitonic_workgroup.d.ts.map

package/src/shade/renderer/gpu_primitive/sort/chunk_sort_bitonic_workgroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sort_bitonic_workgroup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/chunk_sort_bitonic_workgroup.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,2CAFU,SAAS,CAmDhB;0BAxFuB,oCAAoC"}

package/src/shade/renderer/gpu_primitive/sort/chunk_sort_bitonic_workgroup.js

@@ -0,0 +1,89 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_sort_bitonic_comparator } from "./chunk_sort_bitonic_comparator.js";
+import { SORT_KEYS_PER_THREAD, SORT_TILE_SIZE, SORT_WORKGROUP_SIZE } from "./defs.js";
+
+/**
+ * Comparators each thread runs per network step: a step over a full tile has `SORT_TILE_SIZE / 2`.
+ * @type {number}
+ */
+const PAIRS_PER_THREAD = SORT_TILE_SIZE / (2 * SORT_WORKGROUP_SIZE);
+
+/**
+ * Sort up to one tile of `(key, value)` pairs in workgroup memory with a bitonic network, by
+ * {@link sort_pair_less}: ascending by key, then by value. Seed each value with its element's index
+ * and that is a stable sort by key. That is the order {@link graph_radix_sort} produces, so a
+ * caller can swap a one-workgroup sort for the multi-pass one and get the same permutation.
+ *
+ * `sort_bitonic_workgroup(thread_id, count)` sorts slots `[0, count)` of the module-scope workgroup
+ * arrays `keys` and `values`. It reads them by name, as {@link chunk_bvh_refit_climb} reads its
+ * arrays. Each array holds at least {@link SORT_TILE_SIZE} `u32`s and the caller has written the
+ * first `count` of each. The workgroup is {@link SORT_WORKGROUP_SIZE} threads and `thread_id` is
+ * `local_invocation_index`. The sort fences the caller's writes itself, and returns behind a
+ * barrier with the sorted pairs readable by every thread.
+ *
+ * The network spans {@link sort_bitonic_size}`(count)` slots. The ones past `count` are padded with
+ * the largest pair, `(0xffffffff, 0xffffffff)`, which sorts behind every real one. A real pair
+ * equal to it would be indistinguishable from padding, so values below `0xffffffff` are the
+ * caller's contract.
+ *
+ * Why bitonic and not the radix sort's own in-tile split. The scatter's stable binary split
+ * ({@link chunk_sort_rank}) sorts one bit per round in place, and each round is a workgroup scan
+ * of about fifteen barriers. A 30-bit key is thirty rounds, about 450 barriers, at any count. This
+ * network is `log2(size) * (log2(size) + 1) / 2` steps of one barrier each: 55 at a full tile and
+ * 10 at 16 elements. Each thread does at most {@link PAIRS_PER_THREAD} compare-exchanges per step.
+ * Every loop's trip count comes from `count` and the tile constants. Call this from
+ * workgroup-uniform control flow with a uniform `count`, because the steps' barriers sit under
+ * loops bounded by it.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sort_bitonic_workgroup = CodeChunk.from(
+    //language=WGSL
+    `
+fn sort_bitonic_workgroup(thread_id: u32, count: u32) {
+    let size = sort_bitonic_size(min(count, ${SORT_TILE_SIZE}u));
+
+    for (var k = 0u; k < ${SORT_KEYS_PER_THREAD}u; k += 1u) {
+        let slot = k * ${SORT_WORKGROUP_SIZE}u + thread_id;
+
+        if (slot >= count && slot < size) {
+            keys[slot] = 0xffffffffu;
+            values[slot] = 0xffffffffu;
+        }
+    }
+
+    workgroupBarrier();
+
+    let pair_count = size >> 1u;
+
+    for (var block = 2u; block <= size; block <<= 1u) {
+        for (var stride = block >> 1u; stride > 0u; stride >>= 1u) {
+
+            for (var k = 0u; k < ${PAIRS_PER_THREAD}u; k += 1u) {
+                let pair = k * ${SORT_WORKGROUP_SIZE}u + thread_id;
+
+                if (pair < pair_count) {
+                    let slots = sort_bitonic_comparator(pair, block, stride);
+
+                    let key_low = keys[slots.x];
+                    let value_low = values[slots.x];
+                    let key_high = keys[slots.y];
+                    let value_high = values[slots.y];
+
+                    if (sort_pair_less(key_high, value_high, key_low, value_low)) {
+                        keys[slots.x] = key_high;
+                        values[slots.x] = value_high;
+                        keys[slots.y] = key_low;
+                        values[slots.y] = value_low;
+                    }
+                }
+            }
+
+            // a step's comparators are disjoint; the next step's are not disjoint from this one's
+            workgroupBarrier();
+        }
+    }
+}
+`, [
+    chunk_sort_bitonic_comparator,
+]);

package/src/shade/renderer/gpu_primitive/sort/graph_radix_sort.d.ts

@@ -1,3 +1,12 @@
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+/**
+ * Offer the pipelines {@link graph_radix_sort} dispatches — see {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_radix_sort_pipelines(enquiry: PipelineEnquiry): void;
 /**
  * Key-value LSD radix sort, reduce-then-scan, built on the CSDLDF spine.
  *
@@ -40,4 +49,5 @@ export function graph_radix_sort({ graph, keys, values, element_count, }: {
     keys: number;
     values: number;
 };
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 //# sourceMappingURL=graph_radix_sort.d.ts.map

package/src/shade/renderer/gpu_primitive/sort/graph_radix_sort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_radix_sort.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/graph_radix_sort.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAN+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,aAAa,EAA7B,MAAM;IACJ;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,CA+JxC"}
+{"version":3,"file":"graph_radix_sort.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/graph_radix_sort.js"],"names":[],"mappings":"AAcA;;GAEG;AAEH;;;;GAIG;AACH,sDAFW,eAAe,QAMzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IAN+B,KAAK;IACT,IAAI,EAApB,MAAM;IACU,MAAM,EAAtB,MAAM;IACU,aAAa,EAA7B,MAAM;IACJ;IAAC,IAAI,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,CA+JxC;8BA5MY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/gpu_primitive/sort/graph_radix_sort.js

@@ -3,11 +3,30 @@ import { round_up } from "../../../../core/math/round_up.js";
 import { warn_limited } from "../../../util/warn_limited.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { graph_create_buffer } from "../../shader/graph/graph_create_buffer.js";
-import { graph_prefix_scan_csdldf, prefix_scan_csdldf_output_descriptor } from "../prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import {
+    enquire_prefix_scan_csdldf_pipelines,
+    graph_prefix_scan_csdldf,
+    prefix_scan_csdldf_output_descriptor
+} from "../prefix_sum/v1/graph_prefix_scan_csdldf.js";
 import { RADIX, RADIX_LOG, RADIX_PASSES, SORT_TILE_SIZE, SPINE_HEADER_WORDS } from "./defs.js";
 import { shader_radix_sort_histogram } from "./shader_radix_sort_histogram.js";
 import { shader_radix_sort_scatter } from "./shader_radix_sort_scatter.js";
 
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+
+/**
+ * Offer the pipelines {@link graph_radix_sort} dispatches — see {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_radix_sort_pipelines(enquiry) {
+    enquiry.compute.push(shader_radix_sort_histogram.pipeline);
+    enquire_prefix_scan_csdldf_pipelines(enquiry);
+    enquiry.compute.push(shader_radix_sort_scatter.pipeline);
+}
+
 /**
  * Key-value LSD radix sort, reduce-then-scan, built on the CSDLDF spine.
  *

package/src/shade/renderer/gpu_primitive/test/gpu_test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gpu_test.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/test/gpu_test.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,sCAJW,MAAM,cAEL,QAAQ,IAAI,CAAC,CA+DxB"}
+{"version":3,"file":"gpu_test.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/test/gpu_test.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,sCAJW,MAAM,cAEL,QAAQ,IAAI,CAAC,CAyDxB"}