@woosh/meep-engine 3.12.0 → 3.13.0

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

@@ -1,320 +1,326 @@
-import { assert } from "../../../../../core/assert.js";
-import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
-import { BitSet } from "../../../../../core/binary/BitSet.js";
-import { platform_compute_endianness } from "../../../../../core/binary/platform_compute_endianness.js";
-import { round_up } from "../../../../../core/math/round_up.js";
-import { KILOBYTE } from "../../../../../core/science/units/memory/KILOBYTE.js";
-import { write_wgsl_type_value } from "../../../shader/type/serde/write_gpu_typed_buffer.js";
-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 { inspect_gpu_buffer_typed } from "../../inspect_gpu_buffer_typed.js";
-import { GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE } from "../GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE.js";
-
-const UPLOAD_BUFFER_LIMIT = 64 * KILOBYTE;
-const INITIAL_BUFFER_SIZE = 4 * KILOBYTE;
-
-// how many recent upload records set() scans for an existing record with the same id
-// (see GPUTypedTable's constant of the same name)
-const UPLOAD_BUFFER_DEDUP_LOOKBACK = 256;
-
-const UPDATE_SETTINGS_STRUCT = WebGPUStruct.from({
-    count: u32,
-    record_size: u32,
-});
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform('settings', UPDATE_SETTINGS_STRUCT)
-    .addStorageBuffer('upload_buffer', WebGPUArray.from(u32), false)
-    .addStorageBuffer('destination', WebGPUArray.from(u32), true);
-
-const update_shader = ComputeShader.from({
-    label: 'GPUSingleTypeTable.update',
-    body: CodeChunk.from(
-        //language=WGSL
-        `
-@compute @workgroup_size(${GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE},1,1)
-fn main(@builtin(global_invocation_id) global_id : vec3<u32>){
-    let buffer_index = global_id.x;
-    
-    if(buffer_index >= settings.count){
-        return;
-    }
-    
-    let upload_record_offset = buffer_index * ( settings.record_size + 1u );
-    
-    let element_id = upload_buffer[upload_record_offset];
-    
-    let read_offset = upload_record_offset + 1u;
-    let write_offset = element_id * settings.record_size;
-    
-    // copy data
-    for(var i = 0u; i < settings.record_size; i++){
-        // TODO these is a race condition, if the buffer is updated while we are copying, we will overwrite the data
-        destination[write_offset + i] = upload_buffer[read_offset + i];
-    }
-}
-       `
-    ),
-    resources
-});
-
-/**
- * Fully GPU-resident key-value dictionary. The keys are 32-bit unsigned integers.
- * @see {GPUDatabase}
- */
-export class GPUSingleTypeTable {
-    /**
-     * @type {WebGPUType}
-     * @readonly
-     */
-    type;
-
-    /**
-     * @type {GPUBuffer}
-     * @readonly
-     */
-    buffer
-
-    /**
-     * @private
-     * @type {BinaryBuffer}
-     */
-    upload_buffer = BinaryBuffer.fromEndianness(platform_compute_endianness());
-
-    /**
-     * @private
-     * @type {BitSet}
-     */
-    occupancy = new BitSet();
-
-    /**
-     * @type {GPUDevice}
-     */
-    #device
-
-    /**
-     *
-     * @return {number} in bytes
-     */
-    get gpu_memory_usage() {
-        return this.buffer.size;
-    }
-
-    /**
-     *
-     * @param {GPUDevice} device
-     * @param {WebGPUType} type
-     * @param {number} [initial_size] in bytes
-     */
-    constructor({
-                    device,
-                    type,
-                    initial_size = INITIAL_BUFFER_SIZE
-                }) {
-        assert.defined(device, 'device');
-        assert.defined(type, 'type');
-        assert.isNonNegativeInteger(initial_size, 'initial_size');
-
-        this.#device = device;
-        this.type = type;
-
-        this.buffer = device.createBuffer({
-            size: round_up(Math.max(1, initial_size), this.type.aligned_size),
-            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
-            mappedAtCreation: false
-        });
-
-    }
-
-    /**
-     *
-     * @param {number} id
-     */
-    remove(id) {
-        assert.isNonNegativeInteger(id, 'id');
-
-        this.occupancy.set(id, false);
-
-        // TODO zero out the slot?
-    }
-
-    /**
-     * Get the next empty slot. Not reserved, use {@link set} to reserve.
-     * @return {number}
-     */
-    next() {
-        return this.occupancy.nextClearBit(0);
-    }
-
-    /**
-     * @template T
-     * @param {number} id
-     * @param {T} value
-     */
-    set(id, value) {
-        assert.isNonNegativeInteger(id, 'id');
-
-        this.occupancy.set(id, true);
-
-        const upload_buffer = this.upload_buffer;
-
-        // records are laid out at fixed strides: [u32 id, value], rounded up
-        const stride = this.type.aligned_size + u32.size;
-        const tail = upload_buffer.position;
-
-        // Dedupe against recent records: each record is consumed by its own thread in a
-        // single update dispatch, so two records for the same id would race
-        // (last-writer-wins, non-deterministic). Overwrite the previous value in place.
-        const max_lookback = Math.min(
-            UPLOAD_BUFFER_DEDUP_LOOKBACK,
-            Math.floor(tail / stride),
-        );
-
-        for (let i = 1; i <= max_lookback; i++) {
-            const candidate_start = tail - i * stride;
-            upload_buffer.position = candidate_start;
-            if (upload_buffer.readUint32() === id) {
-                write_wgsl_type_value(value, upload_buffer, this.type);
-                upload_buffer.position = tail;
-                return;
-            }
-        }
-
-        upload_buffer.position = tail;
-        upload_buffer.writeUint32(id);
-        write_wgsl_type_value(value, upload_buffer, this.type);
-
-        upload_buffer.position = round_up(upload_buffer.position, stride);
-
-    }
-
-    /**
-     * @template T
-     * @param {number} id
-     * @returns {T}
-     */
-    async get(id) {
-        assert.isNonNegativeInteger(id, 'id');
-
-        const type = this.type;
-
-        const values = await inspect_gpu_buffer_typed({
-            buffer: this.buffer,
-            device: this.#device,
-            type,
-            offset: id * type.aligned_size,
-            count: 1
-        });
-
-        return values[0];
-    }
-
-    /**
-     *
-     * @param {ShadeGPUCommandContext} encoder
-     * @param {number} count
-     */
-    #update_capacity(encoder, count) {
-        const existing_buffer = this.buffer;
-        const alignment = this.type.aligned_size;
-        const needed_size_bytes = count * alignment;
-
-        if (existing_buffer.size >= needed_size_bytes) {
-            // TODO shrink buffer when too small
-            return;
-        }
-
-        const GROW_FACTOR = 1.25;
-
-        const new_size = Math.max(
-            needed_size_bytes,
-            round_up(existing_buffer.size * GROW_FACTOR, alignment)
-        );
-
-        const new_buffer = this.#device.createBuffer({
-            size: new_size,
-            usage: existing_buffer.usage,
-            mappedAtCreation: false
-        });
-
-        encoder.copyBufferToBuffer(existing_buffer, 0, new_buffer, 0, existing_buffer.size);
-
-        encoder.onFinished.add(() => {
-            existing_buffer.destroy();
-        });
-
-        this.buffer = new_buffer;
-    }
-
-    /**
-     *
-     * @param {ShadeGPUCommandContext} command_ctx
-     */
-    update(command_ctx) {
-        assert.defined(command_ctx, 'command_ctx');
-        assert.equal(command_ctx.isGPUCommandContext, true, 'command_ctx.isGPUCommandContext !== true');
-
-
-        if (this.upload_buffer.position === 0) {
-            // nothing to do
-            return;
-        }
-
-        // resize the buffer if necessary.
-        const min_capacity = this.occupancy.size();
-        this.#update_capacity(command_ctx, min_capacity);
-
-        // execute copy shader.
-        const count = this.upload_buffer.position / (this.type.aligned_size + u32.size);
-
-        assert.isNonNegativeInteger(count, 'count');
-
-        const settings = command_ctx.allocateTransientValueBuffer(UPDATE_SETTINGS_STRUCT, {
-            count,
-            record_size: this.type.aligned_size / u32.size,
-        });
-
-        const upload_buffer = command_ctx.allocateTransientBufferAndLoad(
-            this.upload_buffer.data,
-            GPUBufferUsage.STORAGE,
-            0,
-            this.upload_buffer.position
-        );
-
-        update_shader.dispatchThreads({
-            encoder: command_ctx,
-            thread_count_x: count,
-            bindings: {
-                settings,
-                upload_buffer,
-                destination: this.buffer,
-            }
-        })
-
-        // drop upload buffer
-        this.upload_buffer.position = 0;
-        if (this.upload_buffer.capacity > UPLOAD_BUFFER_LIMIT) {
-            // release memory held by upload buffer
-            this.upload_buffer.setCapacity(UPLOAD_BUFFER_LIMIT);
-        }
-    }
-
-    async debug_dump() {
-        return inspect_gpu_buffer_typed({
-            buffer: this.buffer,
-            device: this.#device,
-            type: this.type,
-            offset: 0,
-            count: this.occupancy.size(),
-        });
-    }
-
-    destroy() {
-        this.buffer.destroy();
-    }
+import { assert } from "../../../../../core/assert.js";
+import { BinaryBuffer } from "../../../../../core/binary/BinaryBuffer.js";
+import { BitSet } from "../../../../../core/binary/BitSet.js";
+import { platform_compute_endianness } from "../../../../../core/binary/platform_compute_endianness.js";
+import { round_up } from "../../../../../core/math/round_up.js";
+import { KILOBYTE } from "../../../../../core/science/units/memory/KILOBYTE.js";
+import { write_wgsl_type_value } from "../../../shader/type/serde/write_gpu_typed_buffer.js";
+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 { inspect_gpu_buffer_typed } from "../../inspect_gpu_buffer_typed.js";
+import { GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE } from "../GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE.js";
+
+const UPLOAD_BUFFER_LIMIT = 64 * KILOBYTE;
+const INITIAL_BUFFER_SIZE = 4 * KILOBYTE;
+
+// how many recent upload records set() scans for an existing record with the same id
+// (see GPUTypedTable's constant of the same name)
+const UPLOAD_BUFFER_DEDUP_LOOKBACK = 256;
+
+const UPDATE_SETTINGS_STRUCT = WebGPUStruct.from({
+    count: u32,
+    record_size: u32,
+});
+
+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()
+    .addStorageBuffer('upload_buffer', WebGPUArray.from(u32), false)
+    .addStorageBuffer('destination', WebGPUArray.from(u32), true);
+
+const update_shader = ComputeShader.from({
+    label: 'GPUSingleTypeTable.update',
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${GPU_DATABASE_UPLOAD_DISPATCH_GROUP_SIZE},1,1)
+fn main(@builtin(global_invocation_id) global_id : vec3<u32>){
+    let buffer_index = global_id.x;
+    
+    if(buffer_index >= settings.count){
+        return;
+    }
+    
+    let upload_record_offset = buffer_index * ( settings.record_size + 1u );
+    
+    let element_id = upload_buffer[upload_record_offset];
+    
+    let read_offset = upload_record_offset + 1u;
+    let write_offset = element_id * settings.record_size;
+    
+    // copy data
+    for(var i = 0u; i < settings.record_size; i++){
+        // TODO these is a race condition, if the buffer is updated while we are copying, we will overwrite the data
+        destination[write_offset + i] = upload_buffer[read_offset + i];
+    }
+}
+       `
+    ),
+    resources
+});
+
+/**
+ * Fully GPU-resident key-value dictionary. The keys are 32-bit unsigned integers.
+ * @see {GPUDatabase}
+ */
+export class GPUSingleTypeTable {
+    /**
+     * @type {WebGPUType}
+     * @readonly
+     */
+    type;
+
+    /**
+     * @type {GPUBuffer}
+     * @readonly
+     */
+    buffer
+
+    /**
+     * @private
+     * @type {BinaryBuffer}
+     */
+    upload_buffer = BinaryBuffer.fromEndianness(platform_compute_endianness());
+
+    /**
+     * @private
+     * @type {BitSet}
+     */
+    occupancy = new BitSet();
+
+    /**
+     * @type {GPUDevice}
+     */
+    #device
+
+    /**
+     *
+     * @return {number} in bytes
+     */
+    get gpu_memory_usage() {
+        return this.buffer.size;
+    }
+
+    /**
+     *
+     * @param {GPUDevice} device
+     * @param {WebGPUType} type
+     * @param {number} [initial_size] in bytes
+     */
+    constructor({
+                    device,
+                    type,
+                    initial_size = INITIAL_BUFFER_SIZE
+                }) {
+        assert.defined(device, 'device');
+        assert.defined(type, 'type');
+        assert.isNonNegativeInteger(initial_size, 'initial_size');
+
+        this.#device = device;
+        this.type = type;
+
+        this.buffer = device.createBuffer({
+            size: round_up(Math.max(1, initial_size), this.type.aligned_size),
+            usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST,
+            mappedAtCreation: false
+        });
+
+    }
+
+    /**
+     *
+     * @param {number} id
+     */
+    remove(id) {
+        assert.isNonNegativeInteger(id, 'id');
+
+        this.occupancy.set(id, false);
+
+        // TODO zero out the slot?
+    }
+
+    /**
+     * Get the next empty slot. Not reserved, use {@link set} to reserve.
+     * @return {number}
+     */
+    next() {
+        return this.occupancy.nextClearBit(0);
+    }
+
+    /**
+     * @template T
+     * @param {number} id
+     * @param {T} value
+     */
+    set(id, value) {
+        assert.isNonNegativeInteger(id, 'id');
+
+        this.occupancy.set(id, true);
+
+        const upload_buffer = this.upload_buffer;
+
+        // records are laid out at fixed strides: [u32 id, value], rounded up
+        const stride = this.type.aligned_size + u32.size;
+        const tail = upload_buffer.position;
+
+        // Dedupe against recent records: each record is consumed by its own thread in a
+        // single update dispatch, so two records for the same id would race
+        // (last-writer-wins, non-deterministic). Overwrite the previous value in place.
+        const max_lookback = Math.min(
+            UPLOAD_BUFFER_DEDUP_LOOKBACK,
+            Math.floor(tail / stride),
+        );
+
+        for (let i = 1; i <= max_lookback; i++) {
+            const candidate_start = tail - i * stride;
+            upload_buffer.position = candidate_start;
+            if (upload_buffer.readUint32() === id) {
+                write_wgsl_type_value(value, upload_buffer, this.type);
+                upload_buffer.position = tail;
+                return;
+            }
+        }
+
+        upload_buffer.position = tail;
+        upload_buffer.writeUint32(id);
+        write_wgsl_type_value(value, upload_buffer, this.type);
+
+        upload_buffer.position = round_up(upload_buffer.position, stride);
+
+    }
+
+    /**
+     * @template T
+     * @param {number} id
+     * @returns {T}
+     */
+    async get(id) {
+        assert.isNonNegativeInteger(id, 'id');
+
+        const type = this.type;
+
+        const values = await inspect_gpu_buffer_typed({
+            buffer: this.buffer,
+            device: this.#device,
+            type,
+            offset: id * type.aligned_size,
+            count: 1
+        });
+
+        return values[0];
+    }
+
+    /**
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     * @param {number} count
+     */
+    #update_capacity(encoder, count) {
+        const existing_buffer = this.buffer;
+        const alignment = this.type.aligned_size;
+        const needed_size_bytes = count * alignment;
+
+        if (existing_buffer.size >= needed_size_bytes) {
+            // TODO shrink buffer when too small
+            return;
+        }
+
+        const GROW_FACTOR = 1.25;
+
+        const new_size = Math.max(
+            needed_size_bytes,
+            round_up(existing_buffer.size * GROW_FACTOR, alignment)
+        );
+
+        const new_buffer = this.#device.createBuffer({
+            size: new_size,
+            usage: existing_buffer.usage,
+            mappedAtCreation: false
+        });
+
+        encoder.copyBufferToBuffer(existing_buffer, 0, new_buffer, 0, existing_buffer.size);
+
+        encoder.onFinished.add(() => {
+            existing_buffer.destroy();
+        });
+
+        this.buffer = new_buffer;
+    }
+
+    /**
+     *
+     * @param {ShadeGPUCommandContext} command_ctx
+     */
+    update(command_ctx) {
+        assert.defined(command_ctx, 'command_ctx');
+        assert.equal(command_ctx.isGPUCommandContext, true, 'command_ctx.isGPUCommandContext !== true');
+
+
+        if (this.upload_buffer.position === 0) {
+            // nothing to do
+            return;
+        }
+
+        // resize the buffer if necessary.
+        const min_capacity = this.occupancy.size();
+        this.#update_capacity(command_ctx, min_capacity);
+
+        // execute copy shader.
+        const count = this.upload_buffer.position / (this.type.aligned_size + u32.size);
+
+        assert.isNonNegativeInteger(count, 'count');
+
+        // 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,
+            GPUBufferUsage.STORAGE,
+            0,
+            this.upload_buffer.position
+        );
+
+        update_shader.dispatchThreads({
+            encoder: command_ctx,
+            thread_count_x: count,
+            bindings: {
+                settings,
+                upload_buffer,
+                destination: this.buffer,
+            }
+        })
+
+        // drop upload buffer
+        this.upload_buffer.position = 0;
+        if (this.upload_buffer.capacity > UPLOAD_BUFFER_LIMIT) {
+            // release memory held by upload buffer
+            this.upload_buffer.setCapacity(UPLOAD_BUFFER_LIMIT);
+        }
+    }
+
+    async debug_dump() {
+        return inspect_gpu_buffer_typed({
+            buffer: this.buffer,
+            device: this.#device,
+            type: this.type,
+            offset: 0,
+            count: this.occupancy.size(),
+        });
+    }
+
+    destroy() {
+        this.buffer.destroy();
+    }
 }

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,CAMpB;8BArC2B,+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"}