@woosh/meep-engine 3.2.0 → 3.4.0

package/src/shade/renderer/gpu_primitive/sort/ffx/shader_scatter_keys_and_values.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shader_scatter_keys_and_values.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/sort/ffx/shader_scatter_keys_and_values.js"],"names":[],"mappings":"AA6UA,2DAIE;8BA7U4B,kCAAkC"}

package/src/shade/renderer/gpu_primitive/sort/ffx/shader_scatter_keys_and_values.js

@@ -1,338 +0,0 @@
-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 { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_safe_load_uint4_umax, chunk_safe_load_uint4_umax_fixed } from "./chunk_safe_load_uint4_umax.js";
-import {
-    BITS_PER_PASS,
-    NUM_BINS,
-    NUMBER_OF_BLOCKS_PER_GROUP,
-    RADIX_SORT_GROUP_SIZE,
-    RADIX_SORT_KEYS_TYPE
-} from "./defs.js";
-
-const ROOT_SIGNATURE_STRUCT = WebGPUStruct.from({
-
-    // Corresponds to ShaderRootConstants
-    BitShiftSize: u32,
-    NumThreadGroups: u32,
-
-    // Corresponds to ShaderConstants.offsets
-    offsets_encodeTaskCounter: u32,
-    offsets_mortonCodes: u32,
-    offsets_mortonCodesSorted: u32,
-    offsets_primIndicesSorted: u32,
-    offsets_tempKeys: u32,
-    offsets_tempVals: u32,
-    offsets_histogram: u32,
-})
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("globals", ROOT_SIGNATURE_STRUCT)
-    .addStorageBuffer("input_keys", RADIX_SORT_KEYS_TYPE)
-    .addStorageBuffer("input_values", RADIX_SORT_KEYS_TYPE)
-    .addStorageBuffer("histogram", WebGPUArray.u32, true)
-    .addStorageBuffer("output_keys", RADIX_SORT_KEYS_TYPE, true)
-    .addStorageBuffer("output_values", RADIX_SORT_KEYS_TYPE, true)
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-// Translated from HLSL to WGSL.
-// u64 support has been removed as requested.
-
-// --- Shader Constants (inferred from HLSL code) ---
-
-const GROUP_SIZE = ${RADIX_SORT_GROUP_SIZE};
-const NUM_BINS = ${NUM_BINS};
-const NUMBER_OF_BLOCKS_PER_GROUP = ${NUMBER_OF_BLOCKS_PER_GROUP};
-const SHARED_KEYS_OFFSET = GROUP_SIZE; // Space for values
-const SHARED_MEM_SIZE = SHARED_KEYS_OFFSET + GROUP_SIZE; // Total size for values and keys
-const SHARED_SCANNED_HISTOGRAM_OFFSET = GROUP_SIZE;
-
-var<workgroup> shared_mem: array<u32, SHARED_MEM_SIZE>;
-
-// explicitly to avoid turning all shared memory atomic
-var<workgroup> atomic_histogram : array<atomic<u32>, NUM_BINS>;
-
-fn group_scan_exclusive(local_id: u32, group_size: u32) {
-    // 1. Up-sweep phase (reduction)
-    for (var stride = 1u; stride <= (group_size >> 1u); stride = stride << 1u) {
-        if (local_id < group_size / (2u * stride)) {
-            let idx1 = 2u * (local_id + 1u) * stride - 1u;
-            let idx2 = (2u * local_id + 1u) * stride - 1u;
-            shared_mem[idx1] = shared_mem[idx1] + shared_mem[idx2];
-        }
-        workgroupBarrier();
-    }
-
-    if (local_id == 0u) {
-        shared_mem[group_size - 1u] = 0u;
-    }
-    workgroupBarrier();
-
-    // 2. Down-sweep phase
-    for (var stride = group_size >> 1u; stride > 0u; stride = stride >> 1u) {
-        if (local_id < group_size / (2u * stride)) {
-            let idx1 = (2u * local_id + 1u) * stride - 1u;
-            let idx2 = 2u * (local_id + 1u) * stride - 1u;
-            let temp = shared_mem[idx1];
-            shared_mem[idx1] = shared_mem[idx2];
-            shared_mem[idx2] = shared_mem[idx2] + temp;
-        }
-        workgroupBarrier();
-    }
-}
-
-fn group_scan_exclusive_sum(local_id: u32, group_size: u32) -> u32{
-    
-    // 1. Up-sweep phase (reduction)
-    for (var stride = 1u; stride <= (group_size >> 1u); stride = stride << 1u) {
-        if (local_id < group_size / (2u * stride)) {
-            let idx1 = 2u * (local_id + 1u) * stride - 1u;
-            let idx2 = (2u * local_id + 1u) * stride - 1u;
-            shared_mem[idx1] = shared_mem[idx1] + shared_mem[idx2];
-        }
-        workgroupBarrier();
-    }
-
-    var sum = shared_mem[group_size - 1u];
-    workgroupBarrier();
-
-    if (local_id == 0u) {
-        shared_mem[group_size - 1u] = 0u;
-    }
-    workgroupBarrier();
-
-    // 2. Down-sweep phase (same as group_scan_exclusive)
-    for (var stride = group_size >> 1u; stride > 0u; stride = stride >> 1u) {
-        if (local_id < group_size / (2u * stride)) {
-            let idx1 = (2u * local_id + 1u) * stride - 1u;
-            let idx2 = 2u * (local_id + 1u) * stride - 1u;
-            let temp = shared_mem[idx1];
-            shared_mem[idx1] = shared_mem[idx2];
-            shared_mem[idx2] = shared_mem[idx2] + temp;
-        }
-        workgroupBarrier();
-    }
-    
-    return sum;
-}
-
-// --- Main Implementation ---
-
-fn scatter_keys_and_values_impl(
-    group_id: u32,
-    local_id: u32,
-    bit_shift_size: u32,
-    num_elements: u32,
-    total_num_groups: u32,
-    input_keys: ptr<storage, ${RADIX_SORT_KEYS_TYPE.wgsl_ref}>,
-    input_values: ptr<storage, ${RADIX_SORT_KEYS_TYPE.wgsl_ref}>,
-    histogram: ptr<storage, array<u32>>,
-    output_keys: ptr<storage, ${RADIX_SORT_KEYS_TYPE.wgsl_ref}>,
-    output_values: ptr<storage, ${RADIX_SORT_KEYS_TYPE.wgsl_ref}>,
-) {
-    let num_elems_per_group = NUMBER_OF_BLOCKS_PER_GROUP * GROUP_SIZE;
-    let num_blocks_total = (num_elements + GROUP_SIZE * 4u - 1u) / (GROUP_SIZE * 4u);
-    let max_blocks = num_blocks_total - group_id * NUMBER_OF_BLOCKS_PER_GROUP;
-    let block_count = min(NUMBER_OF_BLOCKS_PER_GROUP, max_blocks);
-
-    // Copy scanned histogram for the group to local memory for fast indexing
-    if (local_id < NUM_BINS) {
-        let input_histogram_offset = ((group_id + local_id * total_num_groups) );
-        shared_mem[SHARED_SCANNED_HISTOGRAM_OFFSET + local_id] = histogram[input_histogram_offset];
-    }
-    
-    // Make sure everything is up to date
-    workgroupBarrier();
-
-    var load_idx = group_id * num_elems_per_group + local_id;
-    for (var block = 0u; block < block_count; block = block + 1u) {
-        var local_keys = safe_load_uint4_umax(&input_keys, load_idx, num_elements);
-        var local_vals: vec4<u32>;
-        
-        // Generate fixed indices for the first pass to avoid initialising the primitive indices
-        // buffer to 0:N unnecessarily.
-        if (bit_shift_size == 0u) {
-            local_vals = safe_load_uint4_umax_fixed(load_idx, num_elements);
-        } else {
-            local_vals = safe_load_uint4_umax(input_values_offset, load_idx, num_elements);
-        }
-        
-        // Clear the histogram
-        shared_mem[local_id] = 0u;
-        workgroupBarrier();
-
-        for (var bit = 0u; bit <= 2u; bit = bit + 2u) {
-        
-            let b = (local_keys >> (bit_shift_size + bit)) & vec4<u32>(3u);
-            
-            var p: vec4<u32>;
-            p.x = 1u << (8u * b.x);
-            p.y = 1u << (8u * b.y);
-            p.z = 1u << (8u * b.z);
-            p.w = 1u << (8u * b.w);
-
-            var packed_key = p.x + p.y + p.z + p.w;
-            shared_mem[local_id] = packed_key;
-            workgroupBarrier();
-
-            var total = group_scan_exclusive_sum(local_id, GROUP_SIZE);
-            packed_key = shared_mem[local_id];
-            workgroupBarrier();
-
-            total = (total << 8u) + (total << 16u) + (total << 24u);
-            let offset = total + packed_key;
-            
-            let t = p.y + p.x;
-            p.w = p.z + t;
-            p.z = t;
-            p.y = p.x;
-            p.x = 0u;
-            p = p + vec4<u32>(offset);
-            
-            let new_offset = (p >> (b * 8u)) & vec4<u32>(0xFFu);
-
-            shared_mem[SHARED_KEYS_OFFSET + new_offset.x] = local_keys.x;
-            shared_mem[SHARED_KEYS_OFFSET + new_offset.y] = local_keys.y;
-            shared_mem[SHARED_KEYS_OFFSET + new_offset.z] = local_keys.z;
-            shared_mem[SHARED_KEYS_OFFSET + new_offset.w] = local_keys.w;
-            
-            shared_mem[new_offset.x] = local_vals.x;
-            shared_mem[new_offset.y] = local_vals.y;
-            shared_mem[new_offset.z] = local_vals.z;
-            shared_mem[new_offset.w] = local_vals.w;
-            
-            workgroupBarrier();
-            
-            // Reload values back to registers for the second bit pass
-            local_keys.x = shared_mem[SHARED_KEYS_OFFSET + (local_id * 4u)];
-            local_keys.y = shared_mem[SHARED_KEYS_OFFSET + (local_id * 4u) + 1u];
-            local_keys.z = shared_mem[SHARED_KEYS_OFFSET + (local_id * 4u) + 2u];
-            local_keys.w = shared_mem[SHARED_KEYS_OFFSET + (local_id * 4u) + 3u];
-            
-            // Reload values back to registers for the second bit pass
-            local_vals.x = shared_mem[local_id * 4u];
-            local_vals.y = shared_mem[(local_id * 4u) + 1u];
-            local_vals.z = shared_mem[(local_id * 4u) + 2u];
-            local_vals.w = shared_mem[(local_id * 4u) + 3u];
-            
-            workgroupBarrier();
-        }
-        
-        // Clear the histogram
-        if (local_id < NUM_BINS) {
-            atomicStore(&atomic_histogram[local_id], 0u);
-        }
-        
-        workgroupBarrier();
-        
-        // Reconstruct 16 bins histogram
-        let bin = (local_keys >> bit_shift_size) & vec4<u32>(0xFu);
-        atomicAdd(&atomic_histogram[bin.x], 1u);
-        atomicAdd(&atomic_histogram[bin.y], 1u);
-        atomicAdd(&atomic_histogram[bin.z], 1u);
-        atomicAdd(&atomic_histogram[bin.w], 1u);
-        
-        workgroupBarrier();
-
-        var sum = 0u;
-        if (local_id < NUM_BINS) {
-            // 1. Read the final count from the atomic array.
-            sum = atomicLoad(&atomic_histogram[local_id]);
-        }
-        
-        shared_mem[local_id] = sum;
-        
-        workgroupBarrier();
-
-        group_scan_exclusive(local_id, 16u);
-        
-        let key_size = 4u;
-        for(var i = 0u; i < 4u; i++){
-            let offset = i + shared_mem[SHARED_SCANNED_HISTOGRAM_OFFSET + bin[i]] + (local_id * 4u) - shared_mem[bin[i]];
-            if (offset < num_elements) {
-                output_keys[offset] = local_keys[i];
-                output_values[offset] = local_vals[i];
-            }
-        }
-        
-        workgroupBarrier();
-        
-        if ((local_id < NUM_BINS) && (block < (block_count - 1u))) {
-            shared_mem[SHARED_SCANNED_HISTOGRAM_OFFSET + local_id] += sum;
-        }
-        
-        load_idx += GROUP_SIZE;
-    }
-}
-
-
-@compute @workgroup_size(GROUP_SIZE, 1, 1)
-fn scatter_keys_and_values(
-    @builtin(local_invocation_id) local_id_vec: vec3<u32>,
-    @builtin(workgroup_id) group_id_vec: vec3<u32>,
-) {
-    let local_id = local_id_vec.x;
-    let group_id = group_id_vec.x;
-
-    let ENCODE_TASK_COUNTER_PRIM_REFS_OFFSET = 4u;
-    let num_primitives = globals.num_elements;
-    
-    // Passing in 0 for initial primitive indices since we auto-generate them for the first pass
-    let input_values_offset = 0u; 
-    
-    var current_from_keys = &input_keys;
-    var current_from_vals = &input_values;
-    var current_to_keys = &output_keys;
-    var current_to_vals = &output_values;
-
-    if (globals.BitShiftSize > 0u) {
-        // in-place after first pass, I presume
-        current_from_keys = output_keys;
-        current_from_vals = output_values;
-    }
-
-    let BITS_PER_PASS = ${BITS_PER_PASS};
-    let pass_index = globals.BitShiftSize / BITS_PER_PASS;
-    if ((pass_index % 2u) == 1u) {
-        {
-            let t = current_from_keys;
-            current_from_keys = current_to_keys;
-            current_to_keys = t;
-        }
-        {
-            let t = current_from_vals;
-            current_from_vals = current_to_vals;
-            current_to_vals = t;       
-        }
-    }
-    
-    scatter_keys_and_values_impl(
-        group_id,
-        local_id,
-        globals.BitShiftSize,
-        num_primitives,
-        globals.NumThreadGroups, // TODO can infer from 'num_elements'
-        current_from_keys,
-        current_from_vals,
-        histogram,
-        current_to_keys,
-        current_to_vals,
-    );
-}
-    `, [
-        chunk_safe_load_uint4_umax_fixed,
-        chunk_safe_load_uint4_umax,
-    ]
-)
-
-export const shader_scatter_keys_and_values = ComputeShader.from({
-    label: "Scatter Keys and Values",
-    body,
-    resources,
-})

package/src/shade/renderer/gpu_primitive/sort/gaussian_splatting/x.d.ts

@@ -1,7 +0,0 @@
-/**
- * @see https://github.com/JochemL-1952176/WebGPU-Gaussian-Splatting/blob/cb40b7a65407edd87253fecc6ab000fdab09413f/src/shaders/sort.wgsl#L33
- * @type {CodeChunk}
- */
-export const chunk: CodeChunk;
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=x.d.ts.map

package/src/shade/renderer/gpu_primitive/sort/gaussian_splatting/x.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"x.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/sort/gaussian_splatting/x.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,oBAFU,SAAS,CAgQlB;0BApQyB,uCAAuC"}

package/src/shade/renderer/gpu_primitive/sort/gaussian_splatting/x.js

@@ -1,261 +0,0 @@
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-
-/**
- * @see https://github.com/JochemL-1952176/WebGPU-Gaussian-Splatting/blob/cb40b7a65407edd87253fecc6ab000fdab09413f/src/shaders/sort.wgsl#L33
- * @type {CodeChunk}
- */
-export const chunk = CodeChunk.from(
-    //language=WGSL
-    `
-const RADIX_BITS_PER_DIGIT = 8u;
-const RADIX_DIGIT_PLACES = 4u;
-const ENTRIES_PER_INVOCATION = 4u;
-const RADIX_BASE = 1u << RADIX_BITS_PER_DIGIT;
-const RADIX_MASK = RADIX_BASE - 1;
-const WORKGROUP_ENTRIES_BINNING = RADIX_BASE * ENTRIES_PER_INVOCATION;
-
-const STATUS_NOT_READY = 0x00000000u;
-const STATUS_LOCAL = 0x40000000u;
-const STATUS_GLOBAL = 0x80000000u;
-const STATUS_MASK = 0xC0000000u;
-const VALUE_MASK = ~STATUS_MASK;
-
-struct DrawIndirect {
-	vertexCount: u32,
-	instanceCount: atomic<u32>,
-	_baseVertex: u32,
-	_baseInstance: u32,
-};
-
-struct SortingGlobal {
-	digitHistogram: array<array<atomic<u32>, RADIX_BASE>, RADIX_DIGIT_PLACES>,
-	assignmentCounter: atomic<u32>,
-};
-
-@group(0) @binding(2) var<uniform> passIndex: u32;
-@group(0) @binding(3) var<storage, read_write> sorting: SortingGlobal;
-@group(0) @binding(4) var<storage, read_write> statusCounter: array<array<atomic<u32>, RADIX_BASE>, MAX_TILE_COUNT_BINNING>;
-@group(0) @binding(5) var<storage, read_write> drawIndirect: DrawIndirect;
-@group(0) @binding(6) var<storage, read_write> entriesIn: array<Entry>;
-@group(0) @binding(7) var<storage, read_write> entriesOut: array<Entry>;
-
-// Onesweep Radix Sort
-// Based on https://github.com/Lichtso/splatter
-// We use a slower but exact key ranking algorithm
-var<workgroup> localHistogram: array<array<atomic<u32>, RADIX_BASE>, RADIX_DIGIT_PLACES>;
-
-@compute @workgroup_size(RADIX_BASE, RADIX_DIGIT_PLACES)
-fn histogram(
-	@builtin(local_invocation_id) localID: vec3<u32>,
-	@builtin(global_invocation_id) globalID: vec3<u32>,
-) {
-	let thread_index = globalID.x * RADIX_DIGIT_PLACES + globalID.y;
-	let start_entry_index = thread_index * ENTRIES_PER_INVOCATION;
-	let end_entry_index = start_entry_index + ENTRIES_PER_INVOCATION;
-	for (var entry_index = start_entry_index; entry_index < end_entry_index; entry_index += 1u) {
-		let splat_index = entry_index * stride;
-		if (splat_index >= arrayLength(&gaussianData)) { continue; }
-
-		var key: u32 = ~0u; // Stream compaction for frustum culling
-		let pos = readVec3(splat_index + posOffset);
-		var clipPos = cam.projection * cam.view * vec4f(pos, 1);
-		clipPos /= clipPos.w;
-		if (isInFrustum(clipPos.xyz)) {
-			key = bitcast<u32>(1.0 - clipPos.z);
-		}
-
-		entriesOut[entry_index] = Entry(key, entry_index);
-		for (var shift = 0u; shift < RADIX_DIGIT_PLACES; shift += 1u) {
-			let digit = (key >> (shift * RADIX_BITS_PER_DIGIT)) & RADIX_MASK;
-			atomicAdd(&localHistogram[shift][digit], 1u);
-		}
-	}
-	workgroupBarrier();
-
-	atomicAdd(&sorting.digitHistogram[localID.y][localID.x], atomicLoad(&localHistogram[localID.y][localID.x]));
-}
-
-@compute @workgroup_size(1)
-fn exPrefixSum(@builtin(global_invocation_id) globalID: vec3<u32>) {
-    var sum = 0u;
-	for (var digit = 0u; digit < RADIX_BASE; digit += 1u) {
-		sum += atomicExchange(&sorting.digitHistogram[globalID.y][digit], sum);
-	}
-}
-
-const WARPSIZE = 32u;
-const WARPCOUNT = RADIX_BASE / WARPSIZE;
-
-var<workgroup> entries: array<atomic<u32>, WORKGROUP_ENTRIES_BINNING>;
-var<workgroup> scan: array<atomic<u32>, RADIX_BASE>;
-var<workgroup> warpHists: array<array<u32, RADIX_BASE>, WARPCOUNT>;
-var<workgroup> warpKeys: array<array<u32, WARPSIZE>, WARPCOUNT>;
-
-// Blelloch exclusive prefix sum algorithm
-fn exclusiveScan(index: u32) -> u32 {
-	var offset = 1u;
-	for (var d = RADIX_BASE >> 1; d > 0; d >>= 1) {
-		workgroupBarrier();
-		if(index < d) {
-			var leftIndex = offset * (2 * index + 1) - 1;
-			var rightIndex = offset * (2 * index + 2) - 1;
-
-			atomicAdd(&scan[rightIndex], atomicLoad(&scan[leftIndex]));
-		}
-		offset <<= 1;
-	}
-
-	if (index == 0) {
-		atomicStore(&scan[RADIX_BASE - 1], 0);
-	}
-
-	for (var d = 1u; d < RADIX_BASE; d <<= 1) {
-		workgroupBarrier();
-		offset >>= 1;
-		if (index < d) {
-			var leftIndex = offset * (2 * index + 1) - 1;
-			var rightIndex = offset * (2 * index + 2) - 1;
-
-			atomicStore(
-				&scan[leftIndex],
-				atomicAdd(
-					&scan[rightIndex],
-					atomicLoad(&scan[leftIndex])
-				)
-			);
-		}
-	}
-	workgroupBarrier();
-	return atomicLoad(&scan[index]);
-}
-
-@compute @workgroup_size(RADIX_BASE)
-fn bin(@builtin(local_invocation_id) localID: vec3<u32>) {
-	// Draw an assignment number
-	if (localID.x == 0u) {
-		atomicStore(&entries[0], atomicAdd(&sorting.assignmentCounter, 1u));
-	}
-	// Reset histogram
-	atomicStore(&scan[localID.x], 0u);
-	workgroupBarrier();
-
-	let assignment = atomicLoad(&entries[0]);
-	let global_entry_offset = assignment * WORKGROUP_ENTRIES_BINNING;
-	if (localID.x == 0u && (global_entry_offset + WORKGROUP_ENTRIES_BINNING) >= arrayLength(&entriesIn)) {
-		// Last workgroup resets the assignment number for the next pass
-		atomicStore(&sorting.assignmentCounter, 0u);
-	}
-
-	// Load keys from global memory into registers and rank them
-	// Shared memory implementation of warp-level multisplit
-	// taken from https://github.com/googlefonts/compute-shader-101/blob/9f882d8d7d2fad98372d04350020c6cd672c1a72/compute-shader-hello/src/shader.wgsl#L371-L461
-	let warpIdx = localID.x / WARPSIZE;
-	let laneIdx = localID.x % WARPSIZE;
-	var keys: array<u32, ENTRIES_PER_INVOCATION>;
-	var ranks: array<u32, ENTRIES_PER_INVOCATION>;
-	for (var entry_index = 0u; entry_index < ENTRIES_PER_INVOCATION; entry_index += 1u) {
-
-		let idx = global_entry_offset + RADIX_BASE * entry_index + localID.x;
-		var key = ~0u;
-		if (idx < arrayLength(&entriesIn)) {
-			key = entriesIn[idx].key;
-		}
-
-		keys[entry_index] = key;
-		let digit = (key >> (passIndex * RADIX_BITS_PER_DIGIT)) & RADIX_MASK;
-
-		warpKeys[warpIdx][laneIdx] = digit;
-		workgroupBarrier();
-
-		var ballot = 0u;
-		for (var j = 0u; j < WARPSIZE; j++) {
-			if (digit == warpKeys[warpIdx][j]) {
-				ballot |= (1u << j);
-			}
-		}
-
-		let rank = countOneBits(ballot << (31u - laneIdx)) - 1;
-		ranks[entry_index] = warpHists[warpIdx][digit] + rank;
-
-		if (rank == 0u) {
-			warpHists[warpIdx][digit] += countOneBits(ballot);
-		}
-	}
-	workgroupBarrier();
-
-	var local_digit_count = 0u;
-	for (var i = 0u; i < WARPCOUNT; i += 1u) {
-		let temp = warpHists[i][localID.x];
-		warpHists[i][localID.x] = local_digit_count;
-		local_digit_count += temp;
-	}
-	
-	atomicStore(&scan[localID.x], local_digit_count);
-	let local_digit_offset = exclusiveScan(localID.x);
-
-	// Chained scan decoupled lookback
-	atomicStore(&statusCounter[assignment][localID.x], STATUS_LOCAL | local_digit_count);
-	var global_digit_count = 0u;
-	var previous_tile = assignment;
-	while true {
-		if (previous_tile == 0u) {
-			global_digit_count += atomicLoad(&sorting.digitHistogram[passIndex][localID.x]);
-			break;
-		}
-
-		previous_tile -= 1u;
-		var status_counter = STATUS_NOT_READY;
-		while ((status_counter & STATUS_MASK) == STATUS_NOT_READY) {
-			status_counter = atomicLoad(&statusCounter[previous_tile][localID.x]);
-		}
-		
-		global_digit_count += status_counter & VALUE_MASK;
-		if ((status_counter & STATUS_GLOBAL) != 0u) {
-			break;
-		}
-	}
-
-	atomicStore(&statusCounter[assignment][localID.x], STATUS_GLOBAL | (global_digit_count + local_digit_count));
-	if (passIndex == RADIX_DIGIT_PLACES - 1u && localID.x == RADIX_BASE - 2u && (global_entry_offset + WORKGROUP_ENTRIES_BINNING) >= arrayLength(&entriesIn)) {
-		drawIndirect.vertexCount = 4u;
-		atomicStore(&drawIndirect.instanceCount, global_digit_count + local_digit_count);
-	}
-
-	// Scatter keys inside shared memory
-	for (var entry_index = 0u; entry_index < ENTRIES_PER_INVOCATION; entry_index += 1u) {
-		let key = keys[entry_index];
-		let digit = (key >> (passIndex * RADIX_BITS_PER_DIGIT)) & RADIX_MASK;
-		ranks[entry_index] += warpHists[warpIdx][digit] + atomicLoad(&scan[digit]);
-		atomicStore(&entries[ranks[entry_index]], key);
-	}
-	workgroupBarrier();
-
-	// Add global offset
-	atomicStore(&scan[localID.x], global_digit_count - local_digit_offset);
-	workgroupBarrier();
-
-	// Store keys from shared memory into global memory
-	for (var entry_index = 0u; entry_index < ENTRIES_PER_INVOCATION; entry_index += 1u) {
-		let key = atomicLoad(&entries[RADIX_BASE * entry_index + localID.x]);
-		let digit = (key >> (passIndex * RADIX_BITS_PER_DIGIT)) & RADIX_MASK;
-		keys[entry_index] = digit;
-		entriesOut[atomicLoad(&scan[digit]) + RADIX_BASE * entry_index + localID.x].key = key;
-	}
-	workgroupBarrier();
-
-	// Load values from global memory and scatter them inside shared memory
-	for (var entry_index = 0u; entry_index < ENTRIES_PER_INVOCATION; entry_index += 1u) {
-		let value = entriesIn[global_entry_offset + RADIX_BASE * entry_index + localID.x].value;
-		atomicStore(&entries[ranks[entry_index]], value);
-	}
-	workgroupBarrier();
-
-	// Store values from shared memory into global memory
-	for (var entry_index = 0u; entry_index < ENTRIES_PER_INVOCATION; entry_index += 1u) {
-		let value = atomicLoad(&entries[RADIX_BASE * entry_index + localID.x]);
-		let digit = keys[entry_index];
-		entriesOut[atomicLoad(&scan[digit]) + RADIX_BASE * entry_index + localID.x].value = value;
-	}
-}
-    `
-)

package/src/shade/renderer/gpu_primitive/sort/one_sweep/chunk_extract_digit.d.ts

@@ -1,3 +0,0 @@
-export const chunk_extract_digit: CodeChunk;
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_extract_digit.d.ts.map

package/src/shade/renderer/gpu_primitive/sort/one_sweep/chunk_extract_digit.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_extract_digit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/sort/one_sweep/chunk_extract_digit.js"],"names":[],"mappings":"AAGA,4CAUC;0BAbyB,uCAAuC"}

package/src/shade/renderer/gpu_primitive/sort/one_sweep/chunk_extract_digit.js

@@ -1,14 +0,0 @@
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { k_radix } from "./defs.js";
-
-export const chunk_extract_digit = CodeChunk.from(
-    //language=WGSL
-    `
-
-fn ExtractDigit( key:u32, shift:u32) -> u32
-{
-    const RADIX_MASK = ${k_radix - 1};
-    return (key >> shift) & RADIX_MASK;
-}    
-    `
-)

package/src/shade/renderer/gpu_primitive/sort/one_sweep/defs.d.ts

@@ -1,25 +0,0 @@
-/**
- * Number of digit bins
- * @type {number}
- */
-export const k_radix: number;
-export const k_keysPerThread: 15;
-/**
- * (Key width) / RADIX_LOG
- * @type {number}
- */
-export const k_radixPasses: number;
-export const k_partitionSize: 3840;
-/**
- * The size of a GlobalHistogram partition tile.
- * @type {number}
- */
-export const k_globalHistPartitionSize: number;
-/**
- * The number of threads in a global hist threadblock
- * @type {number}
- */
-export const k_globalHistThreads: number;
-export const k_binningThreads: 512;
-export const k_valPartSize: 4096;
-//# sourceMappingURL=defs.d.ts.map

package/src/shade/renderer/gpu_primitive/sort/one_sweep/defs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"defs.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/sort/one_sweep/defs.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sBAFU,MAAM,CAEW;AAC3B,iCAAkC;AAElC;;;GAGG;AACH,4BAFU,MAAM,CAEe;AAC/B,mCAAoC;AACpC;;;GAGG;AACH,wCAFU,MAAM,CAE+B;AAC/C;;;GAGG;AACH,kCAFU,MAAM,CAEuB;AACvC,mCAAoC;AACpC,iCAAkC"}

package/src/shade/renderer/gpu_primitive/sort/one_sweep/defs.js

@@ -1,25 +0,0 @@
-/**
- * Number of digit bins
- * @type {number}
- */
-export const k_radix = 256;
-export const k_keysPerThread = 15;
-
-/**
- * (Key width) / RADIX_LOG
- * @type {number}
- */
-export const k_radixPasses = 4;
-export const k_partitionSize = 3840;
-/**
- * The size of a GlobalHistogram partition tile.
- * @type {number}
- */
-export const k_globalHistPartitionSize = 32768;
-/**
- * The number of threads in a global hist threadblock
- * @type {number}
- */
-export const k_globalHistThreads = 128;
-export const k_binningThreads = 512;
-export const k_valPartSize = 4096;