@next2d/webgpu 3.0.0

package/src/Blend/service/BlendScreenService.js

@@ -0,0 +1,8 @@
+import { $setFuncCode, $funcCode } from "../../Blend";
+export const execute = () => {
+    if ($funcCode !== 301) {
+        $setFuncCode(301);
+        return true;
+    }
+    return false;
+};

package/src/Blend/service/BlendSetModeService.d.ts

@@ -0,0 +1,2 @@
+import type { IBlendMode } from "../../interface/IBlendMode";
+export declare const execute: (mode: IBlendMode) => void;

package/src/Blend/service/BlendSetModeService.js

@@ -0,0 +1,4 @@
+import { $setCurrentBlendMode } from "../../Blend";
+export const execute = (mode) => {
+    $setCurrentBlendMode(mode);
+};

package/src/Blend/usecase/BlendApplyComplexBlendUseCase.d.ts

@@ -0,0 +1,6 @@
+import type { IAttachmentObject } from "../../interface/IAttachmentObject";
+import type { IFilterConfig } from "../../interface/IFilterConfig";
+/**
+ * @description 複雑なブレンドモードを適用
+ */
+export declare const execute: (srcAttachment: IAttachmentObject, dstAttachment: IAttachmentObject, blendMode: string, colorTransform: Float32Array, config: IFilterConfig) => IAttachmentObject;

package/src/Blend/usecase/BlendApplyComplexBlendUseCase.js

@@ -0,0 +1,79 @@
+import { ShaderSource } from "../../Shader/ShaderSource";
+/**
+ * @description プリアロケートされた uniform データ (12 floats = 48 bytes)
+ */
+const $uniform12 = new Float32Array(12);
+/**
+ * @description プリアロケートされた BindGroupEntry 配列 (4 bindings)
+ */
+const $entries4 = [
+    { "binding": 0, "resource": { "buffer": null } },
+    { "binding": 1, "resource": null },
+    { "binding": 2, "resource": null },
+    { "binding": 3, "resource": null }
+];
+/**
+ * @description 複雑なブレンドモードを適用
+ */
+export const execute = (srcAttachment, dstAttachment, blendMode, colorTransform, config) => {
+    const { device, commandEncoder, frameBufferManager, pipelineManager, textureManager } = config;
+    // 出力サイズは両方の大きい方を使用
+    const width = Math.max(srcAttachment.width, dstAttachment.width);
+    const height = Math.max(srcAttachment.height, dstAttachment.height);
+    // 出力アタッチメントを作成
+    const destAttachment = frameBufferManager.createTemporaryAttachment(width, height);
+    // 統一パイプラインを使用
+    const pipeline = pipelineManager.getPipeline("complex_blend");
+    const bindGroupLayout = pipelineManager.getBindGroupLayout("complex_blend");
+    if (!pipeline || !bindGroupLayout) {
+        console.error(`[WebGPU ComplexBlend] Pipeline not found for blend mode: ${blendMode}`);
+        // フォールバック: srcをそのまま返す
+        return srcAttachment;
+    }
+    // サンプラーを作成
+    const sampler = textureManager.createSampler("complex_blend_sampler", true);
+    // ユニフォームバッファを作成
+    // mulColor: vec4<f32> (16 bytes)
+    // addColor: vec4<f32> (16 bytes)
+    // blendMode: f32 + padding: vec3<f32> (16 bytes)
+    // Total: 48 bytes
+    const blendModeIndex = ShaderSource.getBlendModeIndex(blendMode);
+    $uniform12[0] = colorTransform[0];
+    $uniform12[1] = colorTransform[1];
+    $uniform12[2] = colorTransform[2];
+    $uniform12[3] = colorTransform[3];
+    $uniform12[4] = colorTransform[4];
+    $uniform12[5] = colorTransform[5];
+    $uniform12[6] = colorTransform[6];
+    $uniform12[7] = colorTransform[7];
+    $uniform12[8] = blendModeIndex;
+    $uniform12[9] = 0;
+    $uniform12[10] = 0;
+    $uniform12[11] = 0;
+    const uniformBuffer = config.bufferManager
+        ? config.bufferManager.acquireAndWriteUniformBuffer($uniform12)
+        : device.createBuffer({
+            "size": 48,
+            "usage": GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+        });
+    if (!config.bufferManager) {
+        device.queue.writeBuffer(uniformBuffer, 0, $uniform12);
+    }
+    // バインドグループを作成
+    $entries4[0].resource.buffer = uniformBuffer;
+    $entries4[1].resource = sampler;
+    $entries4[2].resource = dstAttachment.texture.view;
+    $entries4[3].resource = srcAttachment.texture.view;
+    const bindGroup = device.createBindGroup({
+        "layout": bindGroupLayout,
+        "entries": $entries4
+    });
+    // レンダーパスを実行
+    const renderPassDescriptor = frameBufferManager.createRenderPassDescriptor(destAttachment.texture.view, 0, 0, 0, 0, "clear");
+    const passEncoder = commandEncoder.beginRenderPass(renderPassDescriptor);
+    passEncoder.setPipeline(pipeline);
+    passEncoder.setBindGroup(0, bindGroup);
+    passEncoder.draw(6, 1, 0, 0);
+    passEncoder.end();
+    return destAttachment;
+};

package/src/Blend/usecase/BlendOperationUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { IBlendMode } from "../../interface/IBlendMode";
+/**
+ * @description 設定されたブレンドモードへ切り替える
+ *              Switch to the set blend mode
+ *
+ * @param  {IBlendMode} operation
+ * @return {boolean} ブレンドモードが変更されたかどうか
+ * @method
+ * @protected
+ */
+export declare const execute: (operation: IBlendMode) => boolean;

package/src/Blend/usecase/BlendOperationUseCase.js

@@ -0,0 +1,31 @@
+import { execute as blendAddService } from "../service/BlendAddService";
+import { execute as blendResetService } from "../service/BlendResetService";
+import { execute as blendScreenService } from "../service/BlendScreenService";
+import { execute as blendAlphaService } from "../service/BlendAlphaService";
+import { execute as blendEraseService } from "../service/BlendEraseService";
+import { execute as blendOneZeroService } from "../service/BlendOneZeroService";
+/**
+ * @description 設定されたブレンドモードへ切り替える
+ *              Switch to the set blend mode
+ *
+ * @param  {IBlendMode} operation
+ * @return {boolean} ブレンドモードが変更されたかどうか
+ * @method
+ * @protected
+ */
+export const execute = (operation) => {
+    switch (operation) {
+        case "add":
+            return blendAddService();
+        case "screen":
+            return blendScreenService();
+        case "alpha":
+            return blendAlphaService();
+        case "erase":
+            return blendEraseService();
+        case "copy":
+            return blendOneZeroService();
+        default:
+            return blendResetService();
+    }
+};

package/src/Blend.d.ts

@@ -0,0 +1,8 @@
+import type { IBlendMode } from "./interface/IBlendMode";
+import type { IBlendState } from "./interface/IBlendState";
+export type { IBlendState };
+export declare let $currentBlendMode: IBlendMode;
+export declare let $funcCode: number;
+export declare const $setCurrentBlendMode: (blend_mode: IBlendMode) => void;
+export declare const $setFuncCode: (code: number) => void;
+export declare const $getBlendState: (mode: IBlendMode) => IBlendState;

package/src/Blend.js

@@ -0,0 +1,91 @@
+export let $currentBlendMode = "normal";
+export let $funcCode = 0;
+export const $setCurrentBlendMode = (blend_mode) => {
+    $currentBlendMode = blend_mode;
+};
+export const $setFuncCode = (code) => {
+    $funcCode = code;
+};
+export const $getBlendState = (mode) => {
+    switch (mode) {
+        case "add":
+            return {
+                "color": {
+                    "srcFactor": "one",
+                    "dstFactor": "one",
+                    "operation": "add"
+                },
+                "alpha": {
+                    "srcFactor": "one",
+                    "dstFactor": "one-minus-src-alpha",
+                    "operation": "add"
+                }
+            };
+        case "screen":
+            return {
+                "color": {
+                    "srcFactor": "one-minus-dst",
+                    "dstFactor": "one",
+                    "operation": "add"
+                },
+                "alpha": {
+                    "srcFactor": "one",
+                    "dstFactor": "one-minus-src-alpha",
+                    "operation": "add"
+                }
+            };
+        case "alpha":
+            return {
+                "color": {
+                    "srcFactor": "zero",
+                    "dstFactor": "src-alpha",
+                    "operation": "add"
+                },
+                "alpha": {
+                    "srcFactor": "zero",
+                    "dstFactor": "src-alpha",
+                    "operation": "add"
+                }
+            };
+        case "erase":
+            return {
+                "color": {
+                    "srcFactor": "zero",
+                    "dstFactor": "one-minus-src-alpha",
+                    "operation": "add"
+                },
+                "alpha": {
+                    "srcFactor": "zero",
+                    "dstFactor": "one-minus-src-alpha",
+                    "operation": "add"
+                }
+            };
+        case "copy":
+            return {
+                "color": {
+                    "srcFactor": "one",
+                    "dstFactor": "zero",
+                    "operation": "add"
+                },
+                "alpha": {
+                    "srcFactor": "one",
+                    "dstFactor": "zero",
+                    "operation": "add"
+                }
+            };
+        // normal and default
+        default:
+            return {
+                "color": {
+                    "srcFactor": "one",
+                    "dstFactor": "one-minus-src-alpha",
+                    "operation": "add"
+                },
+                "alpha": {
+                    "srcFactor": "one",
+                    "dstFactor": "one-minus-src-alpha",
+                    "operation": "add"
+                }
+            };
+    }
+};

package/src/BufferManager/service/BufferManagerCreateIndirectBufferService.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @description Indirect Bufferを作成
+ *              Create Indirect Buffer for draw indirect commands
+ *
+ * Indirect Drawingにより、CPUからのdraw呼び出しオーバーヘッドを削減。
+ * GPU側でドローコールのパラメータを決定可能。
+ *
+ * @param {GPUDevice} device - WebGPU device
+ * @param {number} vertex_count - 頂点数
+ * @param {number} instance_count - インスタンス数
+ * @param {number} first_vertex - 開始頂点インデックス
+ * @param {number} first_instance - 開始インスタンスインデックス
+ * @return {GPUBuffer} 作成されたIndirect Buffer
+ */
+export declare const execute: (device: GPUDevice, vertex_count: number, instance_count: number, first_vertex?: number, first_instance?: number) => GPUBuffer;

package/src/BufferManager/service/BufferManagerCreateIndirectBufferService.js

@@ -0,0 +1,37 @@
+/**
+ * @description Indirect Bufferを作成
+ *              Create Indirect Buffer for draw indirect commands
+ *
+ * Indirect Drawingにより、CPUからのdraw呼び出しオーバーヘッドを削減。
+ * GPU側でドローコールのパラメータを決定可能。
+ *
+ * @param {GPUDevice} device - WebGPU device
+ * @param {number} vertex_count - 頂点数
+ * @param {number} instance_count - インスタンス数
+ * @param {number} first_vertex - 開始頂点インデックス
+ * @param {number} first_instance - 開始インスタンスインデックス
+ * @return {GPUBuffer} 作成されたIndirect Buffer
+ */
+export const execute = (device, vertex_count, instance_count, first_vertex = 0, first_instance = 0) => {
+    // Indirect bufferのフォーマット（非インデックス描画用）:
+    // - vertexCount: u32
+    // - instanceCount: u32
+    // - firstVertex: u32
+    // - firstInstance: u32
+    // 合計16バイト
+    const indirectData = new Uint32Array([
+        vertex_count,
+        instance_count,
+        first_vertex,
+        first_instance
+    ]);
+    const buffer = device.createBuffer({
+        "size": indirectData.byteLength,
+        "usage": GPUBufferUsage.INDIRECT | GPUBufferUsage.COPY_DST,
+        "mappedAtCreation": true,
+        "label": "indirect_buffer"
+    });
+    new Uint32Array(buffer.getMappedRange()).set(indirectData);
+    buffer.unmap();
+    return buffer;
+};

package/src/BufferManager/service/BufferManagerCreateRectVerticesService.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @description 矩形の頂点データを作成
+ *              Create rect vertices data
+ *
+ * @param  {number} x
+ * @param  {number} y
+ * @param  {number} width
+ * @param  {number} height
+ * @return {Float32Array}
+ * @method
+ * @protected
+ */
+export declare const execute: (x: number, y: number, width: number, height: number) => Float32Array;

package/src/BufferManager/service/BufferManagerCreateRectVerticesService.js

@@ -0,0 +1,23 @@
+/**
+ * @description 矩形の頂点データを作成
+ *              Create rect vertices data
+ *
+ * @param  {number} x
+ * @param  {number} y
+ * @param  {number} width
+ * @param  {number} height
+ * @return {Float32Array}
+ * @method
+ * @protected
+ */
+export const execute = (x, y, width, height) => {
+    return new Float32Array([
+        // Position (x, y), TexCoord (u, v)
+        x, y, 0.0, 0.0,
+        x + width, y, 1.0, 0.0,
+        x, y + height, 0.0, 1.0,
+        x + width, y, 1.0, 0.0,
+        x + width, y + height, 1.0, 1.0,
+        x, y + height, 0.0, 1.0
+    ]);
+};

package/src/BufferManager/service/BufferManagerCreateStorageBufferService.d.ts

@@ -0,0 +1,17 @@
+import type { IStorageBufferConfig } from "../../interface/IStorageBufferConfig";
+/**
+ * @description Storage Bufferを作成
+ *              Create Storage Buffer for efficient instance data
+ *
+ * Storage Bufferは大きなデータの動的更新に最適。
+ * Vertex Bufferと比較して：
+ * - より大きなサイズをサポート
+ * - 動的更新が効率的
+ * - Compute Shaderでも使用可能
+ * - Vertex Bufferとしても使用可能（VERTEXフラグ付き）
+ *
+ * @param {GPUDevice} device - WebGPU device
+ * @param {IStorageBufferConfig} config - バッファ設定
+ * @return {GPUBuffer} 作成されたStorage Buffer
+ */
+export declare const execute: (device: GPUDevice, config: IStorageBufferConfig) => GPUBuffer;

package/src/BufferManager/service/BufferManagerCreateStorageBufferService.js

@@ -0,0 +1,23 @@
+/**
+ * @description Storage Bufferを作成
+ *              Create Storage Buffer for efficient instance data
+ *
+ * Storage Bufferは大きなデータの動的更新に最適。
+ * Vertex Bufferと比較して：
+ * - より大きなサイズをサポート
+ * - 動的更新が効率的
+ * - Compute Shaderでも使用可能
+ * - Vertex Bufferとしても使用可能（VERTEXフラグ付き）
+ *
+ * @param {GPUDevice} device - WebGPU device
+ * @param {IStorageBufferConfig} config - バッファ設定
+ * @return {GPUBuffer} 作成されたStorage Buffer
+ */
+export const execute = (device, config) => {
+    const buffer = device.createBuffer({
+        "size": config.size,
+        "usage": config.usage | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX,
+        "label": config.label || "storage_buffer"
+    });
+    return buffer;
+};

package/src/BufferManager/service/BufferManagerReleaseUniformBufferService.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @description ユニフォームバッファをプールに返却
+ *              Release uniform buffer back to pool
+ *              バケット化されたMap<number, GPUBuffer[]>にO(1)で返却
+ *
+ * @param  {Map<number, GPUBuffer[]>} buckets - サイズ別バケットMap
+ * @param  {GPUBuffer} buffer
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (buckets: Map<number, GPUBuffer[]>, buffer: GPUBuffer) => void;

package/src/BufferManager/service/BufferManagerReleaseUniformBufferService.js

@@ -0,0 +1,32 @@
+/**
+ * @description バケットあたりの最大プールサイズ
+ *              Maximum pool size per bucket
+ * @type {number}
+ * @const
+ */
+const MAX_BUCKET_SIZE = 32;
+/**
+ * @description ユニフォームバッファをプールに返却
+ *              Release uniform buffer back to pool
+ *              バケット化されたMap<number, GPUBuffer[]>にO(1)で返却
+ *
+ * @param  {Map<number, GPUBuffer[]>} buckets - サイズ別バケットMap
+ * @param  {GPUBuffer} buffer
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (buckets, buffer) => {
+    const size = buffer.size;
+    let bucket = buckets.get(size);
+    if (!bucket) {
+        bucket = [];
+        buckets.set(size, bucket);
+    }
+    if (bucket.length >= MAX_BUCKET_SIZE) {
+        // バケットが満杯の場合、このバッファを破棄
+        buffer.destroy();
+        return;
+    }
+    bucket.push(buffer);
+};

package/src/BufferManager/service/BufferManagerReleaseVertexBufferService.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @description 頂点バッファをプールに返却
+ *              Release vertex buffer back to pool
+ *              バケット化されたMap<number, GPUBuffer[]>にO(1)で返却
+ *
+ * @param  {Map<number, GPUBuffer[]>} buckets - サイズ別バケットMap
+ * @param  {GPUBuffer} buffer
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (buckets: Map<number, GPUBuffer[]>, buffer: GPUBuffer) => void;

package/src/BufferManager/service/BufferManagerReleaseVertexBufferService.js

@@ -0,0 +1,32 @@
+/**
+ * @description バケットあたりの最大プールサイズ
+ *              Maximum pool size per bucket
+ * @type {number}
+ * @const
+ */
+const MAX_BUCKET_SIZE = 32;
+/**
+ * @description 頂点バッファをプールに返却
+ *              Release vertex buffer back to pool
+ *              バケット化されたMap<number, GPUBuffer[]>にO(1)で返却
+ *
+ * @param  {Map<number, GPUBuffer[]>} buckets - サイズ別バケットMap
+ * @param  {GPUBuffer} buffer
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (buckets, buffer) => {
+    const size = buffer.size;
+    let bucket = buckets.get(size);
+    if (!bucket) {
+        bucket = [];
+        buckets.set(size, bucket);
+    }
+    if (bucket.length >= MAX_BUCKET_SIZE) {
+        // バケットが満杯の場合、このバッファを破棄
+        buffer.destroy();
+        return;
+    }
+    bucket.push(buffer);
+};

package/src/BufferManager/service/BufferManagerUpdateIndirectBufferService.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @description Indirect Bufferを更新
+ *              Update Indirect Buffer with new parameters
+ *
+ * @param {GPUDevice} device - WebGPU device
+ * @param {GPUBuffer} buffer - 更新するバッファ
+ * @param {number} vertex_count - 頂点数
+ * @param {number} instance_count - インスタンス数
+ * @param {number} first_vertex - 開始頂点インデックス
+ * @param {number} first_instance - 開始インスタンスインデックス
+ */
+export declare const execute: (device: GPUDevice, buffer: GPUBuffer, vertex_count: number, instance_count: number, first_vertex?: number, first_instance?: number) => void;

package/src/BufferManager/service/BufferManagerUpdateIndirectBufferService.js

@@ -0,0 +1,20 @@
+/**
+ * @description Indirect Bufferを更新
+ *              Update Indirect Buffer with new parameters
+ *
+ * @param {GPUDevice} device - WebGPU device
+ * @param {GPUBuffer} buffer - 更新するバッファ
+ * @param {number} vertex_count - 頂点数
+ * @param {number} instance_count - インスタンス数
+ * @param {number} first_vertex - 開始頂点インデックス
+ * @param {number} first_instance - 開始インスタンスインデックス
+ */
+export const execute = (device, buffer, vertex_count, instance_count, first_vertex = 0, first_instance = 0) => {
+    const indirectData = new Uint32Array([
+        vertex_count,
+        instance_count,
+        first_vertex,
+        first_instance
+    ]);
+    device.queue.writeBuffer(buffer, 0, indirectData);
+};

package/src/BufferManager/service/BufferManagerUpperPowerOfTwoService.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @description 2のべき乗に切り上げ
+ *              Round up to the next power of two
+ *
+ * @param  {number} v
+ * @return {number}
+ * @method
+ * @protected
+ */
+export declare const execute: (v: number) => number;

package/src/BufferManager/service/BufferManagerUpperPowerOfTwoService.js

@@ -0,0 +1,18 @@
+/**
+ * @description 2のべき乗に切り上げ
+ *              Round up to the next power of two
+ *
+ * @param  {number} v
+ * @return {number}
+ * @method
+ * @protected
+ */
+export const execute = (v) => {
+    v--;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    return v + 1;
+};

package/src/BufferManager/usecase/BufferManagerAcquireStorageBufferUseCase.d.ts

@@ -0,0 +1,15 @@
+import type { IPooledStorageBuffer } from "../../interface/IStorageBufferConfig";
+/**
+ * @description プールからStorage Bufferを取得（または新規作成）
+ *              Acquire Storage Buffer from pool or create new one
+ *
+ * メモリアロケーションを最小化するため、
+ * 使用済みのバッファを再利用する。
+ *
+ * @param {GPUDevice} device - WebGPU device
+ * @param {IPooledStorageBuffer[]} pool - Storage Bufferプール
+ * @param {number} required_size - 必要なサイズ（バイト）
+ * @param {number} current_frame - 現在のフレーム番号
+ * @return {GPUBuffer} 取得されたStorage Buffer
+ */
+export declare const execute: (device: GPUDevice, pool: IPooledStorageBuffer[], required_size: number, current_frame: number) => GPUBuffer;

package/src/BufferManager/usecase/BufferManagerAcquireStorageBufferUseCase.js

@@ -0,0 +1,51 @@
+import { execute as createStorageBufferService } from "../service/BufferManagerCreateStorageBufferService";
+/**
+ * @description プールからStorage Bufferを取得（または新規作成）
+ *              Acquire Storage Buffer from pool or create new one
+ *
+ * メモリアロケーションを最小化するため、
+ * 使用済みのバッファを再利用する。
+ *
+ * @param {GPUDevice} device - WebGPU device
+ * @param {IPooledStorageBuffer[]} pool - Storage Bufferプール
+ * @param {number} required_size - 必要なサイズ（バイト）
+ * @param {number} current_frame - 現在のフレーム番号
+ * @return {GPUBuffer} 取得されたStorage Buffer
+ */
+export const execute = (device, pool, required_size, current_frame) => {
+    // アライメントを考慮（256バイト境界）
+    const alignedSize = Math.ceil(required_size / 256) * 256;
+    // プールから適切なサイズの未使用バッファを検索
+    // 最もサイズが近いバッファを選択（メモリ効率）
+    let bestMatch = null;
+    let bestSizeDiff = Infinity;
+    for (const entry of pool) {
+        if (!entry.inUse && entry.size >= alignedSize) {
+            const sizeDiff = entry.size - alignedSize;
+            if (sizeDiff < bestSizeDiff) {
+                bestMatch = entry;
+                bestSizeDiff = sizeDiff;
+            }
+        }
+    }
+    if (bestMatch) {
+        bestMatch.inUse = true;
+        bestMatch.lastUsedFrame = current_frame;
+        return bestMatch.buffer;
+    }
+    // 適切なバッファがない場合は新規作成
+    // 将来の再利用のために少し大きめに確保
+    const createSize = Math.max(alignedSize, 16384); // 最小16KB
+    const buffer = createStorageBufferService(device, {
+        "size": createSize,
+        "usage": GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUBufferUsage.VERTEX,
+        "label": `storage_buffer_${pool.length}`
+    });
+    pool.push({
+        "buffer": buffer,
+        "size": createSize,
+        "inUse": true,
+        "lastUsedFrame": current_frame
+    });
+    return buffer;
+};

package/src/BufferManager/usecase/BufferManagerAcquireUniformBufferUseCase.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @description プールからユニフォームバッファを取得（または新規作成）
+ *              Acquire uniform buffer from pool (or create new)
+ *              バケット化されたMap<number, GPUBuffer[]>からO(1)で取得
+ *
+ * @param  {GPUDevice} device
+ * @param  {Map<number, GPUBuffer[]>} buckets - サイズ別バケットMap
+ * @param  {number} required_size - 必要なバイトサイズ
+ * @return {GPUBuffer}
+ * @method
+ * @protected
+ */
+export declare const execute: (device: GPUDevice, buckets: Map<number, GPUBuffer[]>, required_size: number) => GPUBuffer;

package/src/BufferManager/usecase/BufferManagerAcquireUniformBufferUseCase.js

@@ -0,0 +1,26 @@
+/**
+ * @description プールからユニフォームバッファを取得（または新規作成）
+ *              Acquire uniform buffer from pool (or create new)
+ *              バケット化されたMap<number, GPUBuffer[]>からO(1)で取得
+ *
+ * @param  {GPUDevice} device
+ * @param  {Map<number, GPUBuffer[]>} buckets - サイズ別バケットMap
+ * @param  {number} required_size - 必要なバイトサイズ
+ * @return {GPUBuffer}
+ * @method
+ * @protected
+ */
+export const execute = (device, buckets, required_size) => {
+    // 16バイトアライメント
+    const alignedSize = Math.ceil(required_size / 16) * 16;
+    // バケットからバッファを取得（O(1)）
+    const bucket = buckets.get(alignedSize);
+    if (bucket && bucket.length > 0) {
+        return bucket.pop();
+    }
+    // 新規作成
+    return device.createBuffer({
+        "size": alignedSize,
+        "usage": GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST
+    });
+};