@woosh/meep-engine 3.11.3 → 3.13.0

package/src/shade/renderer/buffer/graph_inspect_gpu_buffer.js

@@ -1,137 +1,137 @@
-import { assert } from "../../../core/assert.js";
-import { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescriptor.js";
-import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { inspect_gpu_buffer_typed } from "./inspect_gpu_buffer_typed.js";
-import { shader_buffer_copy_storage_to_storage } from "./util/shader_buffer_copy_storage_to_storage.js";
-
-/**
- *
- * @param {FrameGraph} graph
- * @param {number} buffer
- * @param {WebGPUType} type
- * @param {number} [offset] byte offset where to start reading
- * @param {number} [count] optional number of members of given type to read, if not specified will read the entire buffer
- * @param {function([])} callback
- */
-export function graph_inspect_gpu_buffer({
-                                             graph,
-                                             buffer,
-                                             type,
-                                             offset = 0,
-                                             count,
-                                             callback
-                                         }) {
-
-
-    /**
-     *
-     * @param data
-     * @param {FramePassResources} resources
-     * @param {GraphicsExecutionContext} context
-     */
-    function execute(data, resources, context) {
-        /**
-         * @type {GPUBuffer}
-         */
-        let source = resources.get(data.input);
-
-        const graphics = context.graphics;
-
-        let copy_size;
-        if (count !== undefined) {
-            assert.isNonNegativeInteger(count, 'count');
-            copy_size = count * type.size;
-        } else {
-            copy_size = source.size - offset;
-        }
-
-        let _offset = offset;
-
-
-        // take a snapshot of the buffer
-
-        let destination_buffer;
-        const encoder = context.encoder;
-
-        if (
-            (source.usage & GPUBufferUsage.COPY_SRC) === 0
-            && (source.usage & GPUBufferUsage.STORAGE) !== 0
-            && copy_size % 4 === 0
-        ) {
-            // does not qualify for .copyBufferToBuffer
-            // use a shader to copy to a qualifying buffer instead
-            // TODO check if possible overflow might happen when size is not a multiple of 4
-
-            const tmp = graphics.buffer_allocator_main.get(BufferResourceDescriptor.from(
-                copy_size,
-                GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
-            ))
-
-            const word_count = Math.ceil(copy_size / 4);
-            // size in 32-bit words
-            const u_size = encoder.allocateTransientValueBuffer(u32, word_count);
-            shader_buffer_copy_storage_to_storage.dispatchLinear({
-                encoder: encoder,
-                bindings: {
-                    source: {
-                        buffer: source,
-                        offset,
-                        size: copy_size,
-                    },
-                    destination: {
-                        buffer: tmp,
-                        offset: 0,
-                        size: copy_size,
-                    },
-                    size: u_size,
-                },
-                element_count:word_count,
-            });
-
-            source = tmp;
-            _offset = 0;
-
-            encoder.onFinished.addOne(() => graphics.buffer_allocator_main.release(tmp));
-        }
-
-        const descriptor = BufferResourceDescriptor.from(
-            copy_size,
-            GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
-        );
-
-        destination_buffer = graphics.buffer_allocator_main.get(descriptor)
-        encoder.copyBufferToBuffer(source, _offset, destination_buffer, 0, copy_size);
-
-
-        // get results once encoder is submitted
-        encoder.onFinished.addOne(() => {
-
-            const p = inspect_gpu_buffer_typed({
-                buffer: destination_buffer,
-                device: context.graphics.device,
-                type,
-                offset: 0,
-                // the pooled buffer can be larger than the copy; deriving the count from
-                // its size would hand the callback phantom rows of stale pooled bytes
-                count: count ?? Math.floor(copy_size / type.size),
-            });
-
-            p
-                .then(callback)
-                .finally(() => {
-                    graphics.buffer_allocator_main.release(destination_buffer)
-                });
-        });
-
-
-    }
-
-
-    const pass_data = {};
-    const pass = graph.add("inspect typed buffer", pass_data, execute);
-
-    pass_data.input = pass.read(buffer);
-    pass.make_side_effect(); // force pass to run
-
-    return pass_data.input;
+import { assert } from "../../../core/assert.js";
+import { BufferResourceDescriptor } from "../../device/graph/BufferResourceDescriptor.js";
+import { u32 } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { inspect_gpu_buffer_typed } from "./inspect_gpu_buffer_typed.js";
+import { shader_buffer_copy_storage_to_storage } from "./util/shader_buffer_copy_storage_to_storage.js";
+
+/**
+ *
+ * @param {FrameGraph} graph
+ * @param {number} buffer
+ * @param {WebGPUType} type
+ * @param {number} [offset] byte offset where to start reading
+ * @param {number} [count] optional number of members of given type to read, if not specified will read the entire buffer
+ * @param {function([])} callback
+ */
+export function graph_inspect_gpu_buffer({
+                                             graph,
+                                             buffer,
+                                             type,
+                                             offset = 0,
+                                             count,
+                                             callback
+                                         }) {
+
+
+    /**
+     *
+     * @param data
+     * @param {FramePassResources} resources
+     * @param {GraphicsExecutionContext} context
+     */
+    function execute(data, resources, context) {
+        /**
+         * @type {GPUBuffer}
+         */
+        let source = resources.get(data.input);
+
+        const graphics = context.graphics;
+
+        let copy_size;
+        if (count !== undefined) {
+            assert.isNonNegativeInteger(count, 'count');
+            copy_size = count * type.size;
+        } else {
+            copy_size = source.size - offset;
+        }
+
+        let _offset = offset;
+
+
+        // take a snapshot of the buffer
+
+        let destination_buffer;
+        const encoder = context.encoder;
+
+        if (
+            (source.usage & GPUBufferUsage.COPY_SRC) === 0
+            && (source.usage & GPUBufferUsage.STORAGE) !== 0
+            && copy_size % 4 === 0
+        ) {
+            // does not qualify for .copyBufferToBuffer
+            // use a shader to copy to a qualifying buffer instead
+            // TODO check if possible overflow might happen when size is not a multiple of 4
+
+            const tmp = graphics.buffer_allocator_main.get(BufferResourceDescriptor.from(
+                copy_size,
+                GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,
+            ))
+
+            const word_count = Math.ceil(copy_size / 4);
+            // size in 32-bit words
+            const u_size = word_count;
+            shader_buffer_copy_storage_to_storage.dispatchThreads({
+                encoder: encoder,
+                bindings: {
+                    source: {
+                        buffer: source,
+                        offset,
+                        size: copy_size,
+                    },
+                    destination: {
+                        buffer: tmp,
+                        offset: 0,
+                        size: copy_size,
+                    },
+                    size: u_size,
+                },
+                thread_count_x:word_count,
+            });
+
+            source = tmp;
+            _offset = 0;
+
+            encoder.onFinished.addOne(() => graphics.buffer_allocator_main.release(tmp));
+        }
+
+        const descriptor = BufferResourceDescriptor.from(
+            copy_size,
+            GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
+        );
+
+        destination_buffer = graphics.buffer_allocator_main.get(descriptor)
+        encoder.copyBufferToBuffer(source, _offset, destination_buffer, 0, copy_size);
+
+
+        // get results once encoder is submitted
+        encoder.onFinished.addOne(() => {
+
+            const p = inspect_gpu_buffer_typed({
+                buffer: destination_buffer,
+                device: context.graphics.device,
+                type,
+                offset: 0,
+                // the pooled buffer can be larger than the copy; deriving the count from
+                // its size would hand the callback phantom rows of stale pooled bytes
+                count: count ?? Math.floor(copy_size / type.size),
+            });
+
+            p
+                .then(callback)
+                .finally(() => {
+                    graphics.buffer_allocator_main.release(destination_buffer)
+                });
+        });
+
+
+    }
+
+
+    const pass_data = {};
+    const pass = graph.add("inspect typed buffer", pass_data, execute);
+
+    pass_data.input = pass.read(buffer);
+    pass.make_side_effect(); // force pass to run
+
+    return pass_data.input;
 }

package/src/shade/renderer/buffer/table/GPUDatabase.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUDatabase.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabase.js"],"names":[],"mappings":"AAuCA;;;;;;;;;GASG;AACH;IA0EI;;;;;OAKG;IACH,4FAqEC;IAnJD;;;OAGG;IACH,kCAAW;IAEX;;;;OAIG;IACH,QAFU,oBAAe,CAElB;IASP;;;OAGG;IACH,kBAAO;IAyCP;;OAEG;IACH,8BAEC;IA+ED;;;;;OAKG;IACH,UAHW,MAAM,GACJ,qBAAc,SAAS,CAUnC;IAGD;;;;;OAKG;IACH,gCAEC;IAoPD;;;OAGG;IACH,8CAoIC;IA2DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,2BAJW,MAAM,GACJ,QAAQ,KAAG,CAAC,CA6HxB;IAED;;;;;;;OAOG;IACH,+BAJW,MAAM,iBACN,MAAM,GACJ,YAAU,CAkCtB;IAED;;;OAGG;IACH,+BAQC;IAED;;OAEG;IACH,gBAIC;;CACJ;8BAh2B6B,oBAAoB"}
+{"version":3,"file":"GPUDatabase.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/GPUDatabase.js"],"names":[],"mappings":"AAmCA;;;;;;;;;GASG;AACH;IA0EI;;;;;OAKG;IACH,4FAqEC;IAnJD;;;OAGG;IACH,kCAAW;IAEX;;;;OAIG;IACH,QAFU,oBAAe,CAElB;IASP;;;OAGG;IACH,kBAAO;IAyCP;;OAEG;IACH,8BAEC;IA+ED;;;;;OAKG;IACH,UAHW,MAAM,GACJ,qBAAc,SAAS,CAUnC;IAGD;;;;;OAKG;IACH,gCAEC;IAoPD;;;OAGG;IACH,8CAkIC;IA2DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,2BAJW,MAAM,GACJ,QAAQ,KAAG,CAAC,CA6HxB;IAED;;;;;;;OAOG;IACH,+BAJW,MAAM,iBACN,MAAM,GACJ,YAAU,CAkCtB;IAED;;;OAGG;IACH,+BAQC;IAED;;OAEG;IACH,gBAIC;;CACJ;8BA91B6B,oBAAoB"}

package/src/shade/renderer/buffer/table/GPUDatabase.js

@@ -10,11 +10,7 @@ import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { inspect_gpu_buffer } from "../inspect_gpu_buffer.js";
 import { inspect_gpu_buffer_typed } from "../inspect_gpu_buffer_typed.js";
 import { GPU_DATABASE_BUFFER_ELEMENT_TYPE } from "./GPU_DATABASE_BUFFER_ELEMENT_TYPE.js";
-import { GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE } from "./GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE.js";
-import {
-    gpu_table_element_upload_shader,
-    GPU_TABLE_UPLOAD_SETTINGS_STRUCT
-} from "./gpu_table_element_upload_shader.js";
+import { gpu_table_element_upload_shader } from "./gpu_table_element_upload_shader.js";
 import { GPUPageMetadata } from "./GPUPageMetadata.js";
 import { GPUTypedTable } from "./GPUTypedTable.js";
 import { PageBufferPool } from "./PageBufferPool.js";
@@ -545,21 +541,19 @@ export class GPUDatabase {
 
                 assert.isNonNegativeInteger(chunk_count, 'chunk_count');
 
-                const settings = encoder.allocateTransientValueBuffer(
-                    GPU_TABLE_UPLOAD_SETTINGS_STRUCT,
-                    {
-                        count: chunk_count,
-                        // record_size is read by the upload shader as a count of
-                        // GPU_DATABASE_BUFFER_ELEMENT_TYPE (u32) units. Records
-                        // are stored at type.size stride (no record-level padding),
-                        // with WGSL alignment applied within fields and array elements.
-                        record_size: table_descriptor.packed_element_size_bytes / GPU_DATABASE_BUFFER_ELEMENT_TYPE.size,
-                        elements_per_page: table_descriptor.elements_per_page,
-                        page_lookup_address: table_descriptor.page_lookup_address,
-                        page_header_words: table_descriptor.page_header_words,
-                        page_limit: table_descriptor.page_limit,
-                    }
-                );
+                // immediate data — a plain value written straight into the pass, not a buffer
+                const settings = {
+                    count: chunk_count,
+                    // record_size is read by the upload shader as a count of
+                    // GPU_DATABASE_BUFFER_ELEMENT_TYPE (u32) units. Records
+                    // are stored at type.size stride (no record-level padding),
+                    // with WGSL alignment applied within fields and array elements.
+                    record_size: table_descriptor.packed_element_size_bytes / GPU_DATABASE_BUFFER_ELEMENT_TYPE.size,
+                    elements_per_page: table_descriptor.elements_per_page,
+                    page_lookup_address: table_descriptor.page_lookup_address,
+                    page_header_words: table_descriptor.page_header_words,
+                    page_limit: table_descriptor.page_limit,
+                };
 
                 const upload_buffer = encoder.allocateTransientBufferAndLoad(
                     upload_data.data,
@@ -568,14 +562,14 @@ export class GPUDatabase {
                     chunk_byte_size
                 );
 
-                gpu_table_element_upload_shader.dispatch({
+                gpu_table_element_upload_shader.dispatchThreads({
                     encoder,
                     bindings: {
                         settings,
                         upload_buffer,
                         database: this.buffer,
                     },
-                    group_count_x: Math.ceil(chunk_count / GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE),
+                    thread_count_x: chunk_count,
                 });
 
                 elements_uploaded += chunk_count;

package/src/shade/renderer/buffer/table/gpu_table_element_upload_shader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gpu_table_element_upload_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/gpu_table_element_upload_shader.js"],"names":[],"mappings":"AASA,4DAkBG;AAQH,4DA+CG;6BAhF0B,mCAAmC;8BAElC,+BAA+B"}
+{"version":3,"file":"gpu_table_element_upload_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/table/gpu_table_element_upload_shader.js"],"names":[],"mappings":"AASA,4DAkBG;AAaH,4DA+CG;6BArF0B,mCAAmC;8BAElC,+BAA+B"}

package/src/shade/renderer/buffer/table/gpu_table_element_upload_shader.js

@@ -28,10 +28,15 @@ export const GPU_TABLE_UPLOAD_SETTINGS_STRUCT = WebGPUStruct.from({
 });
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, 24 bytes, read-only: immediate data rather than a uniform buffer. The upload is
+// chunked, so a uniform paid for a transient buffer, a mapped staging buffer and a
+// copyBufferToBuffer once per chunk, to carry six integers that are known on the CPU at encode time.
+resources.setImmediate('settings', GPU_TABLE_UPLOAD_SETTINGS_STRUCT);
+
 resources.createGroup()
     .addStorageBuffer('upload_buffer', WebGPUArray.from(GPU_DATABASE_BUFFER_ELEMENT_TYPE), false)
-    .addStorageBuffer('database', WebGPUArray.from(GPU_DATABASE_BUFFER_ELEMENT_TYPE), true)
-    .addUniform('settings', GPU_TABLE_UPLOAD_SETTINGS_STRUCT);
+    .addStorageBuffer('database', WebGPUArray.from(GPU_DATABASE_BUFFER_ELEMENT_TYPE), true);
 
 export const gpu_table_element_upload_shader = ComputeShader.from({
     label: `GPUTypedTable/Upload elements`,

package/src/shade/renderer/buffer/table/single/GPUSingleTypeTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSingleTypeTable.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/buffer/table/single/GPUSingleTypeTable.js"],"names":[],"mappings":"AAiEA;;;GAGG;AACH;IAsCI;;;;;OAKG;IACH,uDAkBC;IA7DD;;;OAGG;IACH,0BAAK;IAEL;;;OAGG;IACH,2BAAM;IAEN;;;OAGG;IACH,sBAA2E;IAE3E;;;OAGG;IACH,kBAAyB;IAOzB;;;OAGG;IACH,+BAEC;IA4BD;;;OAGG;IACH,WAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,WAHW,MAAM,kBAsChB;IAED;;;;OAIG;IACH,aAHW,MAAM,OAiBhB;IAuCD;;;OAGG;IACH,kDA+CC;IAED,0BAQC;IAED,gBAEC;;CACJ"}
+{"version":3,"file":"GPUSingleTypeTable.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/buffer/table/single/GPUSingleTypeTable.js"],"names":[],"mappings":"AAsEA;;;GAGG;AACH;IAsCI;;;;;OAKG;IACH,uDAkBC;IA7DD;;;OAGG;IACH,0BAAK;IAEL;;;OAGG;IACH,2BAAM;IAEN;;;OAGG;IACH,sBAA2E;IAE3E;;;OAGG;IACH,kBAAyB;IAOzB;;;OAGG;IACH,+BAEC;IA4BD;;;OAGG;IACH,WAFW,MAAM,QAQhB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,WAHW,MAAM,kBAsChB;IAED;;;;OAIG;IACH,aAHW,MAAM,OAiBhB;IAuCD;;;OAGG;IACH,kDAgDC;IAED,0BAQC;IAED,gBAEC;;CACJ"}

package/src/shade/renderer/buffer/table/single/GPUSingleTypeTable.js

@@ -27,8 +27,13 @@ const UPDATE_SETTINGS_STRUCT = WebGPUStruct.from({
 });
 
 const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, eight bytes, read-only: immediate data rather than a uniform buffer, which cost a
+// transient buffer, a mapped staging buffer and a copyBufferToBuffer to carry two integers already
+// known on the CPU
+resources.setImmediate('settings', UPDATE_SETTINGS_STRUCT);
+
 resources.createGroup()
-    .addUniform('settings', UPDATE_SETTINGS_STRUCT)
     .addStorageBuffer('upload_buffer', WebGPUArray.from(u32), false)
     .addStorageBuffer('destination', WebGPUArray.from(u32), true);
 
@@ -274,10 +279,11 @@ export class GPUSingleTypeTable {
 
         assert.isNonNegativeInteger(count, 'count');
 
-        const settings = command_ctx.allocateTransientValueBuffer(UPDATE_SETTINGS_STRUCT, {
+        // immediate data — a plain value written straight into the pass, not a buffer
+        const settings = {
             count,
             record_size: this.type.aligned_size / u32.size,
-        });
+        };
 
         const upload_buffer = command_ctx.allocateTransientBufferAndLoad(
             this.upload_buffer.data,
@@ -286,9 +292,9 @@ export class GPUSingleTypeTable {
             this.upload_buffer.position
         );
 
-        update_shader.dispatch({
+        update_shader.dispatchThreads({
             encoder: command_ctx,
-            group_count_x: Math.ceil(count / GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE),
+            thread_count_x: count,
             bindings: {
                 settings,
                 upload_buffer,

package/src/shade/renderer/buffer/util/shader_buffer_copy_storage_to_storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_buffer_copy_storage_to_storage.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/util/shader_buffer_copy_storage_to_storage.js"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,oDAFU,aAAa,CAOpB;8BAtC2B,+BAA+B"}
+{"version":3,"file":"shader_buffer_copy_storage_to_storage.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/util/shader_buffer_copy_storage_to_storage.js"],"names":[],"mappings":"AAkCA;;;;GAIG;AACH,oDAFU,aAAa,CAMpB;8BAvC2B,+BAA+B"}

package/src/shade/renderer/buffer/util/shader_buffer_copy_storage_to_storage.js

@@ -1,43 +1,44 @@
-import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-
-const resources = new ShaderResourceSetDescriptor();
-
-resources.createGroup()
-    .addStorageBuffer("source", WebGPUArray.u32)
-    .addStorageBuffer("destination", WebGPUArray.u32, true)
-    .addUniform("size", u32)
-
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-@compute @workgroup_size(${COMPUTE_SHADER_DEFAULT_GROUP_SIZE})
-fn main(
-    @builtin(global_invocation_id) global_id : vec3<u32>
-){
-    let index = global_id.x;
-     
-    if(index >= size){
-        return;
-    }
-    
-    destination[index] = source[index];
-}
-    `
-)
-
-/**
- * Shader is useful for copying buffers where the buffers are missing `GPUBufferUsage.COPY_DST` or `GPUBufferUsage.COPY_SRC`.
- * This is a pure utility shader.
- * @type {ComputeShader}
- */
-export const shader_buffer_copy_storage_to_storage = ComputeShader.from({
-    label: "Copy GPU Buffer/ STORAGE -> STORAGE",
-    body,
-    resources,
-    group_size: [COMPUTE_SHADER_DEFAULT_GROUP_SIZE]
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer holding one u32
+resources.setImmediate("size", u32);
+
+resources.createGroup()
+    .addStorageBuffer("source", WebGPUArray.u32)
+    .addStorageBuffer("destination", WebGPUArray.u32, true)
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@compute @workgroup_size(${COMPUTE_SHADER_DEFAULT_GROUP_SIZE})
+fn main(
+    @builtin(global_invocation_id) global_id : vec3<u32>
+){
+    let index = global_id.x;
+     
+    if(index >= size){
+        return;
+    }
+    
+    destination[index] = source[index];
+}
+    `
+)
+
+/**
+ * Shader is useful for copying buffers where the buffers are missing `GPUBufferUsage.COPY_DST` or `GPUBufferUsage.COPY_SRC`.
+ * This is a pure utility shader.
+ * @type {ComputeShader}
+ */
+export const shader_buffer_copy_storage_to_storage = ComputeShader.from({
+    label: "Copy GPU Buffer/ STORAGE -> STORAGE",
+    body,
+    resources,
 });

package/src/shade/renderer/buffer/util/shader_buffer_intra_copy_regions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_buffer_intra_copy_regions.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/util/shader_buffer_intra_copy_regions.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,kDAAmD;AAEnD;;;;GAIG;AACH,2DAI4B;AAmC5B;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DAKG;6BAjF0B,mCAAmC;8BAElC,+BAA+B"}
+{"version":3,"file":"shader_buffer_intra_copy_regions.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/buffer/util/shader_buffer_intra_copy_regions.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,kDAAmD;AAEnD;;;;GAIG;AACH,2DAI4B;AAmC5B;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DAIG;6BAhF0B,mCAAmC;8BAElC,+BAA+B"}