@woosh/meep-engine 3.2.0 → 3.4.0

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

@@ -1 +0,0 @@
-{"version":3,"file":"graph_prefix_scan_csdl.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdl.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,uGAFa,MAAM,CAkFlB"}

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

@@ -1,119 +0,0 @@
-import { assert } from "../../../../../core/assert.js";
-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 { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import {
-    build_indirect_compute_dispatch_command,
-    INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
-} from "../../indirect/IndirectComputeCommandBuildPass.js";
-import {
-    ONE_SWEEP_UNIFORMS_STRUCT,
-    PREFIX_SCAN_NUM_ELEMENTS_PER_GROUP,
-    shader_one_sweep_prefix_scan
-} from "./shader_one_sweep_prefix_scan.js";
-
-
-/**
- * @deprecated use graph_prefix_scan_csdldf instead, as this variant lacks support for hardware without Forward Propagation Guarantee (Apple)
- * ----
- *
- * Indirect pass.
- * Input data is expected to be counts in form:
- * ```wgsl
- *  struct InputData{
- *     count:u32,
- *     elements: array<u32> // counts: [count0, count1, count2, ... countN-1]
- *  }
- * ```
- * Data is modified in-place, elements are replaced with prefix sums.
- * Make sure to set `element_max_count` to be at least equal to the number of elements in the input, otherwise an incomplete scan will be performed.
- * The penalty for `element_max_count` being too big is fairly small, requiring more memory for the pass and a larger `bufferClear` region.
- *
- * @param {FrameGraph} graph
- * @param {number} data buffer resource ID, array<u32> first position must be "count"
- * @param {number} [element_max_count=1,048,576] how many elements might be in the input, this is a limit
- * @param {boolean} [is_inclusive = true]
- * @returns {number} buffer resource ID with prefix sums, this is rewritten input. The first position (count) is untouched.
- */
-export function graph_prefix_scan_csdl({
-                                           graph,
-                                           data,
-                                           element_max_count = 1048576,
-                                           is_inclusive = true,
-                                       }) {
-
-    assert.isNonNegativeInteger(element_max_count, 'element_max_count');
-
-    // TODO run a special prefix scan if element_max_count fits into a single group
-
-
-    const group_count = Math.ceil(element_max_count / PREFIX_SCAN_NUM_ELEMENTS_PER_GROUP);
-
-    const pass_data = {};
-
-    /**
-     *
-     * @param pass_data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute(pass_data, resources, context) {
-
-        const data = resources.get(pass_data.data);
-        const partition_descriptor_buffer = resources.get(pass_data.partition_descriptor_buffer);
-        const command = resources.get(pass_data.command);
-
-        const encoder = context.encoder;
-
-        const MAX_DISPATCH_SIZE = encoder.device.limits.maxComputeWorkgroupsPerDimension;
-
-        if (group_count > MAX_DISPATCH_SIZE) {
-            warn_limited(`group_count(=${group_count} > MAX_DISPATCH_SIZE(=${MAX_DISPATCH_SIZE}). Prefix scan likely incomplete`);
-        }
-
-        build_indirect_compute_dispatch_command(
-            PREFIX_SCAN_NUM_ELEMENTS_PER_GROUP,
-            encoder,
-            data,
-            0,
-            command,
-            0,
-        );
-
-        const uniforms = encoder.allocateTransientValueBuffer(
-            ONE_SWEEP_UNIFORMS_STRUCT,
-            {
-                is_inclusive_scan: is_inclusive ? 1 : 0,
-            }
-        );
-
-        shader_one_sweep_prefix_scan.dispatchIndirect({
-            encoder,
-            command,
-            bindings: {
-                data_buffer: data,
-                partition_descriptor_buffer,
-                uniforms,
-            }
-        })
-
-    }
-
-    const pass = graph.add("prefix sum", pass_data, execute);
-
-    pass.read(data);
-    pass_data.data = pass.write(data);
-
-    pass_data.command = pass.create("command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR);
-
-    // buffer for storing the partition descriptor of each group
-    // +1 for claim counter at position 0
-    const partition_descriptor_buffer_size = (group_count + 1) * u32.size;
-    pass_data.partition_descriptor_buffer = pass.create("partition descriptor buffer", BufferResourceDescriptor.empty(
-        round_up(partition_descriptor_buffer_size, 1024),
-        GPUBufferUsage.STORAGE
-    ));
-
-    return pass_data.data;
-}

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

@@ -1,7 +0,0 @@
-export const ONE_SWEEP_UNIFORMS_STRUCT: WebGPUStruct;
-export const PREFIX_SCAN_NUM_GROUP_THREADS: 256;
-export const PREFIX_SCAN_NUM_ELEMENTS_PER_GROUP: number;
-export const shader_one_sweep_prefix_scan: ComputeShader;
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-//# sourceMappingURL=shader_one_sweep_prefix_scan.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"shader_one_sweep_prefix_scan.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/prefix_sum/v1/shader_one_sweep_prefix_scan.js"],"names":[],"mappings":"AAQA,qDAEG;AAQH,gDAAiD;AACjD,wDAAoF;AAmNpF,yDAIE;6BAxO2B,sCAAsC;8BAGrC,kCAAkC"}

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

@@ -1,235 +0,0 @@
-import { atomic_u32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { COLLECTION_U32_STRUCT_READ } from "../../COLLECTION_U32_STRUCT_READ.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-
-export const ONE_SWEEP_UNIFORMS_STRUCT = WebGPUStruct.from({
-    is_inclusive_scan: u32,
-});
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("uniforms", ONE_SWEEP_UNIFORMS_STRUCT)
-    .addStorageBuffer("data_buffer", COLLECTION_U32_STRUCT_READ, true)
-    .addStorageBuffer("partition_descriptor_buffer", WebGPUArray.from(atomic_u32), true)
-
-export const PREFIX_SCAN_NUM_GROUP_THREADS = 256;
-export const PREFIX_SCAN_NUM_ELEMENTS_PER_GROUP = 2 * PREFIX_SCAN_NUM_GROUP_THREADS;
-/**
- * Translated from HLSL. This is a single-pass, GPU-driven prefix scan
- * using a decoupled look-back algorithm, suitable for datasets of unknown size.
- * @see https://github.com/abecombe/GPUBufferOperators-for-Unity/blob/c8b48d29741d363437c91debe6984549cd6b1a31/Assets/Packages/GPUBufferOperators/Runtime/GPUOneSweepPrefixScan.hlsl
- * @type {CodeChunk}
- */
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-
-// --- Constants ---
-const NUM_GROUP_THREADS = ${PREFIX_SCAN_NUM_GROUP_THREADS};
-const NUM_BANKS = 32u; // register banks count
-const LOG_NUM_BANKS = 5u; // log2(NUM_BANKS)
-
-const FLAG_INVALID = 0u;
-const FLAG_AGGREGATE = 1u;
-const FLAG_PREFIX = 2u;
-
-const PARTITION_DESCRIPTOR_FLAG_MASK = 0x00000003u;
-const PARTITION_DESCRIPTOR_VALUE_SHIFT = 2u;
-
-const NUM_ELEMENTS_PER_GROUP:u32 = ${PREFIX_SCAN_NUM_ELEMENTS_PER_GROUP};
-const NUM_ELEMENTS_PER_GROUP_MINUS_1 = NUM_ELEMENTS_PER_GROUP - 1u;
-
-
-// --- Workgroup Shared Memory ---
-
-// Pre-calculate shared memory array size with bank-conflict padding
-const SMA_NUM_ELEMENTS_PER_GROUP = NUM_ELEMENTS_PER_GROUP + (NUM_ELEMENTS_PER_GROUP >> LOG_NUM_BANKS);
-const S_SCAN_LEN = SMA_NUM_ELEMENTS_PER_GROUP + 1u;
-
-var<workgroup> s_scan: array<u32, S_SCAN_LEN>;
-var<workgroup> s_prev_reduction: u32;
-
-// --- Helper Functions ---
-
-fn conflict_free_offset(n: u32) -> u32 {
-    return n >> LOG_NUM_BANKS;
-}
-
-fn shared_memory_address(n: u32) -> u32 {
-    return n + conflict_free_offset(n);
-}
-
-fn create_partition_descriptor(value: u32, flag: u32) -> u32 {
-    return (value << PARTITION_DESCRIPTOR_VALUE_SHIFT) | flag;
-}
-
-fn get_partition_descriptor_flag(partition_descriptor: u32) -> u32 {
-    return partition_descriptor & PARTITION_DESCRIPTOR_FLAG_MASK;
-}
-
-fn get_partition_descriptor_value(partition_descriptor: u32) -> u32 {
-    return partition_descriptor >> PARTITION_DESCRIPTOR_VALUE_SHIFT;
-}
-
-fn lookback(group_thread_id: u32, partition_index: u32) -> u32 {
-    if (partition_index == 0u) {
-    
-        // Handle the edge case where there's nothing to look back to.
-        if (group_thread_id == 0u) {
-            s_prev_reduction = 0u;
-        }
-        
-    }else{
-
-        if (group_thread_id == 0u) {
-            // Thread 0 does the complex look-back and eventually writes to s_prev_reduction.
-            var prev_reduction = 0u;
-            var look_back_id = partition_index - 1u;            
-            loop {
-                let partition_descriptor = atomicLoad(&partition_descriptor_buffer[look_back_id + 1]);
-                let flag = get_partition_descriptor_flag(partition_descriptor);
-    
-                if (flag != FLAG_INVALID) {
-                    prev_reduction += get_partition_descriptor_value(partition_descriptor);
-                    if (flag == FLAG_PREFIX) {
-                        let value_to_add = create_partition_descriptor(prev_reduction, FLAG_PREFIX - FLAG_AGGREGATE);
-                        atomicAdd(&partition_descriptor_buffer[partition_index + 1], value_to_add);
-                        s_prev_reduction = prev_reduction;
-                        break;
-                    }
-                    look_back_id -= 1u;
-                }
-            }
-        }
-    }
-
-    // Again, all threads wait here until thread 0 finishes the look-back loop.
-    workgroupBarrier();
-
-    // Now all threads can safely read the result calculated by thread 0.
-    return s_prev_reduction;
-}
-
-var<workgroup> sh_partition_index:u32;
-
-fn get_partition_index(group_thread_id: u32) -> u32 {
-
-    if(group_thread_id == 0u) {
-    
-        sh_partition_index = atomicAdd(&partition_descriptor_buffer[0], 1u);
-    
-    }
-    
-    workgroupBarrier();
-    
-    return sh_partition_index;
-}
-
-@compute @workgroup_size(NUM_GROUP_THREADS)
-fn prefix_scan(
-    @builtin(local_invocation_id) local_id: vec3<u32>,
-    @builtin(workgroup_id) workgroup_id: vec3<u32>
-) {
-    let group_thread_id = local_id.x;
-    let partition_index = get_partition_index(group_thread_id);
-    
-    // guard against out-of-bounds access
-    let num_elements = min( data_buffer.count, arrayLength(&data_buffer.elements) );
-    
-    // Each thread handles two values
-    var ai = group_thread_id;
-    var bi = ai + NUM_GROUP_THREADS;
-    
-    let sma_ai_load = shared_memory_address(ai);
-    let sma_bi_load = shared_memory_address(bi);
-
-    let global_ai = group_thread_id + NUM_ELEMENTS_PER_GROUP * partition_index;
-    let global_bi = global_ai + NUM_GROUP_THREADS;
-
-    // Copy input data to shared memory, handling out-of-bounds access
-    s_scan[sma_ai_load] = select(0u, data_buffer.elements[global_ai], global_ai < num_elements);
-    s_scan[sma_bi_load] = select(0u, data_buffer.elements[global_bi], global_bi < num_elements);
-
-    var offset = 1u;
-
-    // Upsweep (reduction) phase
-    for (var du = NUM_ELEMENTS_PER_GROUP >> 1u; du > 0u; du = du >> 1u) {
-        workgroupBarrier();
-        if (group_thread_id < du) {
-            let ai_u = offset * ((group_thread_id << 1u) + 1u) - 1u;
-            let bi_u = offset * ((group_thread_id << 1u) + 2u) - 1u;
-            s_scan[shared_memory_address(bi_u)] += s_scan[shared_memory_address(ai_u)];
-        }
-        offset = offset << 1u;
-    }
-
-    // Save total sum to global memory and clear last element for exclusive scan
-    let sma_last_element = shared_memory_address(NUM_ELEMENTS_PER_GROUP_MINUS_1);
-    if (group_thread_id == 0u) {
-        let group_sum = s_scan[sma_last_element];
-        let flag = select(FLAG_AGGREGATE, FLAG_PREFIX, partition_index == 0u);
-        
-        // NOTE: the slot value must be 0, the exchange is unnecessary
-        // ORIGINAL:
-        // _ = atomicCompareExchangeWeak(&partition_descriptor_buffer[partition_index], 0u, create_partition_descriptor(group_sum, flag));
-        atomicStore(&partition_descriptor_buffer[partition_index + 1], create_partition_descriptor(group_sum, flag)); 
-        
-        s_scan[sma_last_element] = 0u;
-        s_scan[S_SCAN_LEN - 1u] = group_sum; // Store group_sum temporarily
-    }
-
-    let prev_reduction = lookback(group_thread_id, partition_index);
-    
-    // Downsweep phase
-    for (var dd = 1u; dd < NUM_ELEMENTS_PER_GROUP; dd = dd << 1u) {
-        offset = offset >> 1u;
-        
-        if (group_thread_id < dd) {
-        
-            let ai_d = offset * ((group_thread_id << 1u) + 1u) - 1u;
-            let bi_d = offset * ((group_thread_id << 1u) + 2u) - 1u;
-            
-            let sma_ai_d = shared_memory_address(ai_d);
-            let sma_bi_d = shared_memory_address(bi_d);
-
-            let temp = s_scan[sma_ai_d];
-            s_scan[sma_ai_d] = s_scan[sma_bi_d];
-            s_scan[sma_bi_d] += temp;
-            
-        }
-        
-        workgroupBarrier();
-        
-    }
-
-    // For inclusive scan, read from the next element's exclusive scan result
-    if (uniforms.is_inclusive_scan != 0u) {
-        ai = group_thread_id + 1u;
-        bi = ai + NUM_GROUP_THREADS;
-    }
-    
-    let sma_ai_store = shared_memory_address(ai);
-    let sma_bi_store = shared_memory_address(bi);
-
-    // Copy scanned data back to global memory
-    if (global_ai < num_elements) {
-        data_buffer.elements[global_ai] = s_scan[sma_ai_store] + prev_reduction;
-    }
-    if (global_bi < num_elements) {
-        data_buffer.elements[global_bi] = s_scan[sma_bi_store] + prev_reduction;
-    }
-}
-    `
-)
-
-// TODO add subgroup-based version, see https://github.com/abecombe/GPUBufferOperators-for-Unity/commit/434a8e287e922b68b75af007b06c4f04ccbc18a0
-
-export const shader_one_sweep_prefix_scan = ComputeShader.from({
-    label: "OneSweep prefix scan",
-    body,
-    resources,
-})

package/src/shade/renderer/gpu_primitive/sort/NOTES.md

@@ -1,5 +0,0 @@
-Radix Sort
-see https://github.com/GPUOpen-Drivers/gpurt/blob/f734985ebc31f471c376ed0cb217f43bdd40ee17/src/shaders/RadixSort/BitHistogram.hlsl
-
-----
-Currently none of this works

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

@@ -1,7 +0,0 @@
-/**
- * @see https://github.com/b0nes164/GPUSorting/blob/09a6081d964b682bbb58838b83ab75aebe7f4e05/GPUSortingUnity/Shaders/SortCommon.hlsl#L38
- * @type {CodeChunk}
- */
-export const chunk_sort_common: CodeChunk;
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_sort_common.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_sort_common.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/gpu_primitive/sort/chunk_sort_common.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,gCAFU,SAAS,CAkIlB;0BAvIyB,oCAAoC"}

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

@@ -1,136 +0,0 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { k_radix, k_radixPasses } from "./one_sweep/defs.js";
-
-/**
- * @see https://github.com/b0nes164/GPUSorting/blob/09a6081d964b682bbb58838b83ab75aebe7f4e05/GPUSortingUnity/Shaders/SortCommon.hlsl#L38
- * @type {CodeChunk}
- */
-export const chunk_sort_common = CodeChunk.from(
-    //language=WGSL
-    `
-const KEYS_PER_THREAD   = 15u;
-const D_DIM             = 256u;
-const PART_SIZE         = 3840u;
-const D_TOTAL_SMEM      = 4096u;
-
-const MAX_DISPATCH_DIM  = 65535u;  //The max value of any given dispatch dimension
-const RADIX             = ${k_radix};    //Number of digit bins
-const RADIX_MASK        = 255u;    //Mask of digit bins
-const HALF_RADIX        = 128u;    //For smaller waves where bit packing is necessary
-const HALF_MASK         = 127u;    // '' 
-const RADIX_LOG         = 8u;      //log2(RADIX)
-const RADIX_PASSES      = ${k_radixPasses};      //(Key width) / RADIX_LOG
-
-override subgroup_size: u32 = 32;
-var subgroup_index: u32;
-
-struct KeyStruct
-{
-    k:array<u32,KEYS_PER_THREAD>
-};
-
-struct OffsetStruct
-{
-    o:array<u32,KEYS_PER_THREAD>
-};
-
-struct DigitStruct
-{
-    d:array<u32,KEYS_PER_THREAD>
-};
-
-var<workgroup> g_d: array<u32,D_TOTAL_SMEM>; //Shared memory for DigitBinningPass and DownSweep kernels
-
-
-fn WaveGetLaneIndex() -> u32{
-    return subgroup_index;
-}
-
-fn WaveGetLaneCount() -> u32{
-    return subgroup_size;
-}
-
-fn WaveHistsSizeWGE16() -> u32
-{
-    return D_DIM / subgroup_size * RADIX;
-}
-
-fn WaveHistsSizeWLT16() -> u32
-{
-    return D_TOTAL_SMEM;
-}
-
-fn ClearWaveHists( gtid:u32 )
-{
-    const histsEnd = select(WaveHistsSizeWLT16(),WaveHistsSizeWGE16(),subgroup_size >= 16);
-        
-    for (var i = gtid; i < histsEnd; i += D_DIM){
-        g_d[i] = 0;
-    }
-}
-//*****************************************************************************
-//HELPER FUNCTIONS
-//*****************************************************************************
-fn getWaveIndex(gtid:u32) -> u32
-{
-    return gtid / WaveGetLaneCount();
-}
-
-fn SubPartSizeWGE16() -> u32
-{
-    return KEYS_PER_THREAD * WaveGetLaneCount();
-}
-
-fn SharedOffsetWGE16( gtid:u32) -> u32
-{
-    return WaveGetLaneIndex() + getWaveIndex(gtid) * SubPartSizeWGE16();
-}
-
-fn SubPartSizeWLT16( _serialIterations:u32) -> u32
-{
-    return KEYS_PER_THREAD * WaveGetLaneCount() * _serialIterations;
-}
-
-fn SharedOffsetWLT16( gtid:u32 , _serialIterations: u32) -> u32
-{
-    return WaveGetLaneIndex() +
-        (getWaveIndex(gtid) / _serialIterations * SubPartSizeWLT16(_serialIterations)) +
-        (getWaveIndex(gtid) % _serialIterations * WaveGetLaneCount());
-}
-
-fn DeviceOffsetWGE16(gtid:u32, partIndex:u32) -> u32
-{
-    return SharedOffsetWGE16(gtid) + partIndex * PART_SIZE;
-}
-
-//*****************************************************************************
-//FUNCTIONS COMMON TO THE DOWNSWEEP / DIGIT BINNING PASS
-//*****************************************************************************
-//If the size of  a wave is too small, we do not have enough space in
-//shared memory to assign a histogram to each wave, so instead,
-//some operations are peformed serially.
-
-fn LoadKey( key: ptr<function,u32>,  index: u32)
-{
-    *key = b_sort[index];
-}
-
-fn LoadKeysWGE16(gtid:u32, partIndex:u32) -> KeyStruct
-{
-    var keys:KeyStruct;
-    
-    var t = DeviceOffsetWGE16(gtid, partIndex);
-    for (var i:u32 = 0; 
-        i < KEYS_PER_THREAD;
-        i++
-        ){
-        
-        LoadKey(&keys.k[i], t);
-        t += WaveGetLaneCount();
-        
-    }
-    
-    return keys;
-}
-    `
-)

package/src/shade/renderer/gpu_primitive/sort/ffx/chunk_safe_load_uint4_umax.d.ts

@@ -1,18 +0,0 @@
-export const chunk_safe_load_uint4_umax_fixed: CodeChunk;
-/**
- * see https://github.com/GPUOpen-Drivers/gpurt/blob/f734985ebc31f471c376ed0cb217f43bdd40ee17/src/shaders/RadixSort/ScanCommon.hlsli#L96
- * @type {CodeChunk}
- */
-export const chunk_safe_load_uint4_umax: CodeChunk;
-/**
- * see https://github.com/GPUOpen-Drivers/gpurt/blob/f734985ebc31f471c376ed0cb217f43bdd40ee17/src/shaders/RadixSort/ScanCommon.hlsli#L96
- * @type {CodeChunk}
- */
-export const chunk_safe_load_uint4: CodeChunk;
-/**
- * see https://github.com/GPUOpen-Drivers/gpurt/blob/f734985ebc31f471c376ed0cb217f43bdd40ee17/src/shaders/RadixSort/ScanCommon.hlsli#L96
- * @type {CodeChunk}
- */
-export const chunk_safe_store_uint4: CodeChunk;
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-//# sourceMappingURL=chunk_safe_load_uint4_umax.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"chunk_safe_load_uint4_umax.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/gpu_primitive/sort/ffx/chunk_safe_load_uint4_umax.js"],"names":[],"mappings":"AAGA,yDAgBC;AAED;;;GAGG;AACH,yCAFU,SAAS,CA4BlB;AAED;;;GAGG;AACH,oCAFU,SAAS,CAyBlB;AACD;;;GAGG;AACH,qCAFU,SAAS,CAwBlB;0BA1GyB,uCAAuC"}

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

@@ -1,108 +0,0 @@
-import { UINT32_MAX } from "../../../../../core/binary/UINT32_MAX.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-
-export const chunk_safe_load_uint4_umax_fixed = CodeChunk.from(
-    //language=WGSL
-    `
-fn safe_load_uint4_umax_fixed(idx: u32, size_in_ints: u32) -> vec4<u32> {
-    let val = (idx * 4u);
-    var res = vec4<u32>(${UINT32_MAX});
-    if (((idx + 1u) * 4u) <= size_in_ints) {
-        res = vec4<u32>(val, val + 1, val + 2, val + 3);
-    } else {
-        if ((idx * 4u) < size_in_ints) { res.x = val; }
-        if ((idx * 4u) + 1u < size_in_ints) { res.y = val + 1; }
-        if ((idx * 4u) + 2u < size_in_ints) { res.z = val + 2; }
-    }
-    return res;
-}
-    `
-)
-
-/**
- * see https://github.com/GPUOpen-Drivers/gpurt/blob/f734985ebc31f471c376ed0cb217f43bdd40ee17/src/shaders/RadixSort/ScanCommon.hlsli#L96
- * @type {CodeChunk}
- */
-export const chunk_safe_load_uint4_umax = CodeChunk.from(
-    //language=WGSL
-    `
-fn safe_load_uint4_umax(data: ptr<storage,array<u32>>, idx:u32, limit:u32) -> vec4<u32>{
-    
-    var res = vec4<u32>(${UINT32_MAX});
-    
-    let offset = idx; 
-    
-    if(idx + 1 <= limit){
-        res.x = data[idx];
-    }
-    if(idx + 2 <= limit){
-        res.y = data[idx + 1];
-    }
-    if(idx + 3 <= limit){
-        res.z = data[idx + 2];
-    }
-    if(idx + 4 <= limit){
-        res.w = data[idx + 3];
-    }
-    
-    
-    return res;
-}
-    `
-)
-
-/**
- * see https://github.com/GPUOpen-Drivers/gpurt/blob/f734985ebc31f471c376ed0cb217f43bdd40ee17/src/shaders/RadixSort/ScanCommon.hlsli#L96
- * @type {CodeChunk}
- */
-export const chunk_safe_load_uint4 = CodeChunk.from(
-    //language=WGSL
-    `
-fn safe_load_uint4(data: ptr<storage,array<u32>>, idx:u32, limit:u32) -> vec4<u32>{
-    
-    var res = vec4<u32>(0);
-    
-    if(idx + 1 <= limit){
-        res.x = data[idx];
-    }
-    if(idx + 2 <= limit){
-        res.y = data[idx + 1];
-    }
-    if(idx + 3 <= limit){
-        res.z = data[idx + 2];
-    }
-    if(idx + 4 <= limit){
-        res.w = data[idx + 3];
-    }
-    
-    return res;
-}
-    `
-)
-/**
- * see https://github.com/GPUOpen-Drivers/gpurt/blob/f734985ebc31f471c376ed0cb217f43bdd40ee17/src/shaders/RadixSort/ScanCommon.hlsli#L96
- * @type {CodeChunk}
- */
-export const chunk_safe_store_uint4 = CodeChunk.from(
-    //language=WGSL
-    `
-fn safe_store_uint4(data: ptr<storage,array<u32>>, value: vec4u, idx:u32, limit:u32){
-            
-    if(idx + 1 <= limit){
-        data[idx] = value.x;
-    }
-    if(idx + 2 <= limit){
-       data[idx + 1] = value.y;
-    }
-    if(idx + 3 <= limit){
-       data[idx + 2] = value.z;
-    }
-    if(idx + 4 <= limit){
-       data[idx + 3] = value.w;
-    }
-    
-    
-    
-}
-    `
-)

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

@@ -1,35 +0,0 @@
-/**
- * Good value is probably ~16
- * @see https://raw.githubusercontent.com/MircoWerner/VkRadixSort/refs/heads/main/timings/radixsort_multi_1000000.png
- * @type {number}
- */
-export const NUMBER_OF_BLOCKS_PER_GROUP: number;
-/**
- * How many bits are there in a key
- * @type {number}
- */
-export const KEY_BIT_SIZE: number;
-/**
- * How many bits do we handle per pass?
- * @type {number}
- */
-export const BITS_PER_PASS: number;
-/**
- * How many histogram bins do we need?
- * @type {number}
- */
-export const NUM_BINS: number;
-/**
- * compute shader work-group size
- * @type {number}
- */
-export const RADIX_SORT_GROUP_SIZE: number;
-/**
- *
- * @type {WebGPUArray}
- */
-export const RADIX_SORT_KEYS_TYPE: WebGPUArray;
-export const RADIX_SORT_PASS_PARAMETERS_STRUCT: WebGPUStruct;
-import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
-import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-//# sourceMappingURL=defs.d.ts.map