@next2d/webgpu 3.0.4 → 3.1.0

package/src/TextureManager.js

@@ -1,7 +1,14 @@
 import { execute as textureManagerInitializeSamplersService } from "./TextureManager/service/TextureManagerInitializeSamplersService";
-import { execute as textureManagerCreateTextureFromPixelsUseCase } from "./TextureManager/usecase/TextureManagerCreateTextureFromPixelsUseCase";
-import { execute as textureManagerCreateTextureFromImageBitmapUseCase } from "./TextureManager/usecase/TextureManagerCreateTextureFromImageBitmapUseCase";
+/**
+ * @description テクスチャとサンプラーの管理クラス
+ *              Manager class for textures and samplers
+ */
 export class TextureManager {
+    /**
+     * @description TextureManagerのコンストラクタ
+     *              Constructor for TextureManager
+     * @param {GPUDevice} device - WebGPUデバイス / WebGPU device
+     */
     constructor(device) {
         Object.defineProperty(this, "device", {
             enumerable: true,
@@ -26,6 +33,15 @@ export class TextureManager {
         this.samplers = new Map();
         textureManagerInitializeSamplersService(device, this.samplers);
     }
+    /**
+     * @description 新しいGPUテクスチャを作成する
+     *              Create a new GPU texture
+     * @param  {string}           name   - テクスチャ名 / Texture name
+     * @param  {number}           width  - テクスチャの幅 / Texture width
+     * @param  {number}           height - テクスチャの高さ / Texture height
+     * @param  {GPUTextureFormat} [format="rgba8unorm"] - テクスチャフォーマット / Texture format
+     * @return {GPUTexture}
+     */
     createTexture(name, width, height, format = "rgba8unorm") {
         const texture = this.device.createTexture({
             "size": { width, height },
@@ -37,24 +53,22 @@ export class TextureManager {
         this.textures.set(name, texture);
         return texture;
     }
-    createTextureFromPixels(name, pixels, width, height) {
-        return textureManagerCreateTextureFromPixelsUseCase(this.device, this.textures, name, pixels, width, height);
-    }
-    createTextureFromImageBitmap(name, imageBitmap) {
-        return textureManagerCreateTextureFromImageBitmapUseCase(this.device, this.textures, name, imageBitmap);
-    }
-    updateTexture(name, pixels, width, height) {
-        const texture = this.textures.get(name);
-        if (texture) {
-            this.device.queue.writeTexture({ texture }, pixels.buffer, { "bytesPerRow": width * 4, "offset": pixels.byteOffset }, { width, height });
-        }
-    }
+    /**
+     * @description 名前でテクスチャを取得する
+     *              Get a texture by name
+     * @param  {string} name - テクスチャ名 / Texture name
+     * @return {GPUTexture | undefined}
+     */
     getTexture(name) {
         return this.textures.get(name);
     }
-    getSampler(name) {
-        return this.samplers.get(name);
-    }
+    /**
+     * @description サンプラーを作成する（既存の場合は返却）
+     *              Create a sampler (returns existing if found)
+     * @param  {string}  name            - サンプラー名 / Sampler name
+     * @param  {boolean} [smooth=true]   - スムージングを有効にするか / Whether to enable smoothing
+     * @return {GPUSampler}
+     */
     createSampler(name, smooth = true) {
         const existing = this.samplers.get(name);
         if (existing) {
@@ -70,13 +84,11 @@ export class TextureManager {
         this.samplers.set(name, sampler);
         return sampler;
     }
-    destroyTexture(name) {
-        const texture = this.textures.get(name);
-        if (texture) {
-            texture.destroy();
-            this.textures.delete(name);
-        }
-    }
+    /**
+     * @description 全テクスチャとサンプラーを破棄する
+     *              Dispose all textures and samplers
+     * @return {void}
+     */
     dispose() {
         for (const texture of this.textures.values()) {
             texture.destroy();

package/src/TexturePool/service/TexturePoolCleanupService.d.ts

@@ -3,12 +3,12 @@ import type { ITexturePoolBuckets } from "../../interface/IPooledTexture";
  * @description 古いプールエントリをクリーンアップ（バケットMap版 LRU回収）
  *              Cleanup old pool entries (bucket Map version, LRU eviction)
  *
- * @param  {ITexturePoolBuckets} buckets
- * @param  {number} currentFrame
+ * @param  {ITexturePoolBuckets} buckets - テクスチャプールバケット
+ * @param  {number} current_frame - 現在のフレーム番号
  * @param  {number} threshold - フレーム数閾値
- * @param  {number[]} totalCount - [0]に現在の合計数を格納
+ * @param  {number[]} total_count - [0]に現在の合計数を格納
  * @return {void}
  * @method
  * @protected
  */
-export declare const execute: (buckets: ITexturePoolBuckets, currentFrame: number, threshold: number, totalCount: number[]) => void;
+export declare const execute: (buckets: ITexturePoolBuckets, current_frame: number, threshold: number, total_count: number[]) => void;

package/src/TexturePool/service/TexturePoolCleanupService.js

@@ -2,23 +2,23 @@
  * @description 古いプールエントリをクリーンアップ（バケットMap版 LRU回収）
  *              Cleanup old pool entries (bucket Map version, LRU eviction)
  *
- * @param  {ITexturePoolBuckets} buckets
- * @param  {number} currentFrame
+ * @param  {ITexturePoolBuckets} buckets - テクスチャプールバケット
+ * @param  {number} current_frame - 現在のフレーム番号
  * @param  {number} threshold - フレーム数閾値
- * @param  {number[]} totalCount - [0]に現在の合計数を格納
+ * @param  {number[]} total_count - [0]に現在の合計数を格納
  * @return {void}
  * @method
  * @protected
  */
-export const execute = (buckets, currentFrame, threshold, totalCount) => {
-    const frameThreshold = currentFrame - threshold;
+export const execute = (buckets, current_frame, threshold, total_count) => {
+    const frameThreshold = current_frame - threshold;
     for (const [key, bucket] of buckets) {
         for (let i = bucket.length - 1; i >= 0; i--) {
             const entry = bucket[i];
             if (!entry.inUse && entry.lastUsedFrame < frameThreshold) {
                 entry.texture.destroy();
                 bucket.splice(i, 1);
-                totalCount[0]--;
+                total_count[0]--;
             }
         }
         if (bucket.length === 0) {

package/src/TexturePool/service/TexturePoolReleaseService.d.ts

@@ -3,11 +3,11 @@ import type { ITexturePoolBuckets } from "../../interface/IPooledTexture";
  * @description テクスチャをプールに返却（バケットMap版）
  *              Release texture back to pool (bucket Map version)
  *
- * @param  {ITexturePoolBuckets} buckets
- * @param  {GPUTexture} texture
- * @param  {number} currentFrame
+ * @param  {ITexturePoolBuckets} buckets - テクスチャプールバケット
+ * @param  {GPUTexture} texture - 返却するテクスチャ
+ * @param  {number} current_frame - 現在のフレーム番号
  * @return {void}
  * @method
  * @protected
  */
-export declare const execute: (buckets: ITexturePoolBuckets, texture: GPUTexture, currentFrame: number) => void;
+export declare const execute: (buckets: ITexturePoolBuckets, texture: GPUTexture, current_frame: number) => void;

package/src/TexturePool/service/TexturePoolReleaseService.js

@@ -2,19 +2,19 @@
  * @description テクスチャをプールに返却（バケットMap版）
  *              Release texture back to pool (bucket Map version)
  *
- * @param  {ITexturePoolBuckets} buckets
- * @param  {GPUTexture} texture
- * @param  {number} currentFrame
+ * @param  {ITexturePoolBuckets} buckets - テクスチャプールバケット
+ * @param  {GPUTexture} texture - 返却するテクスチャ
+ * @param  {number} current_frame - 現在のフレーム番号
  * @return {void}
  * @method
  * @protected
  */
-export const execute = (buckets, texture, currentFrame) => {
+export const execute = (buckets, texture, current_frame) => {
     for (const bucket of buckets.values()) {
         for (let i = 0; i < bucket.length; i++) {
             if (bucket[i].texture === texture) {
                 bucket[i].inUse = false;
-                bucket[i].lastUsedFrame = currentFrame;
+                bucket[i].lastUsedFrame = current_frame;
                 return;
             }
         }

package/src/TexturePool/usecase/TexturePoolAcquireUseCase.d.ts

@@ -3,17 +3,17 @@ import type { ITexturePoolBuckets } from "../../interface/IPooledTexture";
  * @description テクスチャを取得または作成（バケットMap検索）
  *              Acquire texture from pool or create new one (bucket Map lookup)
  *
- * @param  {GPUDevice} device
- * @param  {ITexturePoolBuckets} buckets
- * @param  {number} width
- * @param  {number} height
- * @param  {GPUTextureFormat} format
- * @param  {GPUTextureUsageFlags} usage
- * @param  {number} currentFrame
- * @param  {number} maxPoolSize
- * @param  {number[]} totalCount - [0]に現在の合計数を格納
+ * @param  {GPUDevice} device - GPUデバイス
+ * @param  {ITexturePoolBuckets} buckets - テクスチャプールバケット
+ * @param  {number} width - テクスチャ幅
+ * @param  {number} height - テクスチャ高さ
+ * @param  {GPUTextureFormat} format - テクスチャフォーマット
+ * @param  {GPUTextureUsageFlags} usage - テクスチャ使用フラグ
+ * @param  {number} current_frame - 現在のフレーム番号
+ * @param  {number} max_pool_size - プールの最大サイズ
+ * @param  {number[]} total_count - [0]に現在の合計数を格納
  * @return {GPUTexture}
  * @method
  * @protected
  */
-export declare const execute: (device: GPUDevice, buckets: ITexturePoolBuckets, width: number, height: number, format: GPUTextureFormat, usage: GPUTextureUsageFlags, currentFrame: number, maxPoolSize: number, totalCount: number[]) => GPUTexture;
+export declare const execute: (device: GPUDevice, buckets: ITexturePoolBuckets, width: number, height: number, format: GPUTextureFormat, usage: GPUTextureUsageFlags, current_frame: number, max_pool_size: number, total_count: number[]) => GPUTexture;

package/src/TexturePool/usecase/TexturePoolAcquireUseCase.js

@@ -1,9 +1,10 @@
 /**
  * @description バケットキーを生成（exactサイズ + フォーマット）
+ *              Build bucket key from exact size and format
  *
- * @param  {number} width
- * @param  {number} height
- * @param  {GPUTextureFormat} format
+ * @param  {number} width - テクスチャ幅
+ * @param  {number} height - テクスチャ高さ
+ * @param  {GPUTextureFormat} format - テクスチャフォーマット
  * @return {string}
  */
 const buildKey = (width, height, format) => {
@@ -13,20 +14,20 @@ const buildKey = (width, height, format) => {
  * @description テクスチャを取得または作成（バケットMap検索）
  *              Acquire texture from pool or create new one (bucket Map lookup)
  *
- * @param  {GPUDevice} device
- * @param  {ITexturePoolBuckets} buckets
- * @param  {number} width
- * @param  {number} height
- * @param  {GPUTextureFormat} format
- * @param  {GPUTextureUsageFlags} usage
- * @param  {number} currentFrame
- * @param  {number} maxPoolSize
- * @param  {number[]} totalCount - [0]に現在の合計数を格納
+ * @param  {GPUDevice} device - GPUデバイス
+ * @param  {ITexturePoolBuckets} buckets - テクスチャプールバケット
+ * @param  {number} width - テクスチャ幅
+ * @param  {number} height - テクスチャ高さ
+ * @param  {GPUTextureFormat} format - テクスチャフォーマット
+ * @param  {GPUTextureUsageFlags} usage - テクスチャ使用フラグ
+ * @param  {number} current_frame - 現在のフレーム番号
+ * @param  {number} max_pool_size - プールの最大サイズ
+ * @param  {number[]} total_count - [0]に現在の合計数を格納
  * @return {GPUTexture}
  * @method
  * @protected
  */
-export const execute = (device, buckets, width, height, format, usage, currentFrame, maxPoolSize, totalCount) => {
+export const execute = (device, buckets, width, height, format, usage, current_frame, max_pool_size, total_count) => {
     const key = buildKey(width, height, format);
     // バケットから未使用テクスチャを検索（O(1)バケット + O(n)バケット内走査）
     const bucket = buckets.get(key);
@@ -35,13 +36,13 @@ export const execute = (device, buckets, width, height, format, usage, currentFr
             const entry = bucket[i];
             if (!entry.inUse) {
                 entry.inUse = true;
-                entry.lastUsedFrame = currentFrame;
+                entry.lastUsedFrame = current_frame;
                 return entry.texture;
             }
         }
     }
     // プールが満杯なら最も古い未使用エントリを削除（LRU回収）
-    if (totalCount[0] >= maxPoolSize) {
+    if (total_count[0] >= max_pool_size) {
         let oldestFrame = Infinity;
         let oldestKey = "";
         let oldestIdx = -1;
@@ -62,7 +63,7 @@ export const execute = (device, buckets, width, height, format, usage, currentFr
             if (bEntries.length === 0) {
                 buckets.delete(oldestKey);
             }
-            totalCount[0]--;
+            total_count[0]--;
         }
     }
     // exactサイズで新規作成
@@ -76,7 +77,7 @@ export const execute = (device, buckets, width, height, format, usage, currentFr
         width,
         height,
         format,
-        "lastUsedFrame": currentFrame,
+        "lastUsedFrame": current_frame,
         "inUse": true
     };
     if (bucket) {
@@ -85,6 +86,6 @@ export const execute = (device, buckets, width, height, format, usage, currentFr
     else {
         buckets.set(key, [entry]);
     }
-    totalCount[0]++;
+    total_count[0]++;
     return texture;
 };

package/src/TexturePool.d.ts

@@ -7,63 +7,64 @@
  *              LRUベースで未使用テクスチャを回収。
  */
 export declare class TexturePool {
+    /**
+     * @description WebGPUデバイスの参照
+     *              Reference to the WebGPU device
+     * @type {GPUDevice}
+     */
     private device;
+    /**
+     * @description Power-of-2バケットによるテクスチャプール
+     *              Texture pool organized by power-of-2 buckets
+     * @type {ITexturePoolBuckets}
+     */
     private buckets;
+    /**
+     * @description 現在のフレーム番号
+     *              Current frame number for LRU tracking
+     * @type {number}
+     */
     private currentFrame;
+    /**
+     * @description プール内のテクスチャ総数
+     *              Total count of textures in the pool
+     * @type {number[]}
+     */
     private totalCount;
     /**
-     * @param {GPUDevice} device
+     * @description テクスチャプールを生成する
+     *              Create a new texture pool instance
+     * @param {GPUDevice} device - WebGPUデバイス / WebGPU device
      * @constructor
      */
     constructor(device: GPUDevice);
     /**
-     * @description フレーム開始時に呼び出し
+     * @description フレーム開始時に呼び出し、定期的にプールをクリーンアップする
+     *              Called at the beginning of each frame; periodically cleans up the pool
      * @return {void}
      */
     beginFrame(): void;
     /**
-     * @description テクスチャを取得または作成
-     * @param {number} width - テクスチャの幅
-     * @param {number} height - テクスチャの高さ
-     * @param {GPUTextureFormat} format - テクスチャフォーマット
-     * @param {GPUTextureUsageFlags} usage - テクスチャ使用フラグ
+     * @description テクスチャを取得または作成する
+     *              Acquire a texture from the pool or create a new one
+     * @param {number} width - テクスチャの幅 / texture width
+     * @param {number} height - テクスチャの高さ / texture height
+     * @param {GPUTextureFormat} format - テクスチャフォーマット / texture format
+     * @param {GPUTextureUsageFlags} usage - テクスチャ使用フラグ / texture usage flags
      * @return {GPUTexture}
      */
     acquire(width: number, height: number, format?: GPUTextureFormat, usage?: GPUTextureUsageFlags): GPUTexture;
     /**
-     * @description テクスチャをプールに返却
-     * @param {GPUTexture} texture - 返却するテクスチャ
+     * @description テクスチャをプールに返却する
+     *              Release a texture back to the pool for reuse
+     * @param {GPUTexture} texture - 返却するテクスチャ / texture to release
      * @return {void}
      */
     release(texture: GPUTexture): void;
     /**
-     * @description プール統計を取得
-     * @return {{ total: number, inUse: number, available: number }}
-     */
-    getStats(): {
-        total: number;
-        inUse: number;
-        available: number;
-    };
-    /**
-     * @description 解放
+     * @description 全テクスチャを破棄しプールを解放する
+     *              Destroy all textures and dispose of the pool
      * @return {void}
      */
     dispose(): void;
 }
-/**
- * @description テクスチャプールを初期化
- * @param {GPUDevice} device
- * @return {void}
- */
-export declare const initTexturePool: (device: GPUDevice) => void;
-/**
- * @description テクスチャプールを取得
- * @return {TexturePool | null}
- */
-export declare const getTexturePool: () => TexturePool | null;
-/**
- * @description テクスチャプールをクリア
- * @return {void}
- */
-export declare const clearTexturePool: () => void;

package/src/TexturePool.js

@@ -3,12 +3,16 @@ import { execute as texturePoolReleaseService } from "./TexturePool/service/Text
 import { execute as texturePoolCleanupService } from "./TexturePool/service/TexturePoolCleanupService";
 /**
  * @description プールの最大サイズ
+ *              Maximum pool size for texture reuse
+ * @type {number}
  */
-const MAX_POOL_SIZE = 32;
+const $MAX_POOL_SIZE = 32;
 /**
  * @description キャッシュのクリーンアップ閾値（フレーム数）
+ *              Cache cleanup threshold in frames (3 seconds at 60FPS)
+ * @type {number}
  */
-const CACHE_CLEANUP_THRESHOLD = 180; // 3秒（60FPS想定）
+const $CACHE_CLEANUP_THRESHOLD = 180;
 /**
  * @description テクスチャプールマネージャー（Power-of-2バケット版）
  *              Texture pool manager for WebGPU optimization
@@ -19,28 +23,50 @@ const CACHE_CLEANUP_THRESHOLD = 180; // 3秒（60FPS想定）
  */
 export class TexturePool {
     /**
-     * @param {GPUDevice} device
+     * @description テクスチャプールを生成する
+     *              Create a new texture pool instance
+     * @param {GPUDevice} device - WebGPUデバイス / WebGPU device
      * @constructor
      */
     constructor(device) {
+        /**
+         * @description WebGPUデバイスの参照
+         *              Reference to the WebGPU device
+         * @type {GPUDevice}
+         */
         Object.defineProperty(this, "device", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * @description Power-of-2バケットによるテクスチャプール
+         *              Texture pool organized by power-of-2 buckets
+         * @type {ITexturePoolBuckets}
+         */
         Object.defineProperty(this, "buckets", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * @description 現在のフレーム番号
+         *              Current frame number for LRU tracking
+         * @type {number}
+         */
         Object.defineProperty(this, "currentFrame", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        /**
+         * @description プール内のテクスチャ総数
+         *              Total count of textures in the pool
+         * @type {number[]}
+         */
         Object.defineProperty(this, "totalCount", {
             enumerable: true,
             configurable: true,
@@ -53,62 +79,43 @@ export class TexturePool {
         this.totalCount = [0];
     }
     /**
-     * @description フレーム開始時に呼び出し
+     * @description フレーム開始時に呼び出し、定期的にプールをクリーンアップする
+     *              Called at the beginning of each frame; periodically cleans up the pool
      * @return {void}
      */
     beginFrame() {
         this.currentFrame++;
         // 定期的にプールをクリーンアップ（LRU回収）
         if (this.currentFrame % 60 === 0) {
-            texturePoolCleanupService(this.buckets, this.currentFrame, CACHE_CLEANUP_THRESHOLD, this.totalCount);
+            texturePoolCleanupService(this.buckets, this.currentFrame, $CACHE_CLEANUP_THRESHOLD, this.totalCount);
         }
     }
     /**
-     * @description テクスチャを取得または作成
-     * @param {number} width - テクスチャの幅
-     * @param {number} height - テクスチャの高さ
-     * @param {GPUTextureFormat} format - テクスチャフォーマット
-     * @param {GPUTextureUsageFlags} usage - テクスチャ使用フラグ
+     * @description テクスチャを取得または作成する
+     *              Acquire a texture from the pool or create a new one
+     * @param {number} width - テクスチャの幅 / texture width
+     * @param {number} height - テクスチャの高さ / texture height
+     * @param {GPUTextureFormat} format - テクスチャフォーマット / texture format
+     * @param {GPUTextureUsageFlags} usage - テクスチャ使用フラグ / texture usage flags
      * @return {GPUTexture}
      */
     acquire(width, height, format = "rgba8unorm", usage = GPUTextureUsage.TEXTURE_BINDING |
         GPUTextureUsage.COPY_DST |
         GPUTextureUsage.RENDER_ATTACHMENT) {
-        return texturePoolAcquireUseCase(this.device, this.buckets, width, height, format, usage, this.currentFrame, MAX_POOL_SIZE, this.totalCount);
+        return texturePoolAcquireUseCase(this.device, this.buckets, width, height, format, usage, this.currentFrame, $MAX_POOL_SIZE, this.totalCount);
     }
     /**
-     * @description テクスチャをプールに返却
-     * @param {GPUTexture} texture - 返却するテクスチャ
+     * @description テクスチャをプールに返却する
+     *              Release a texture back to the pool for reuse
+     * @param {GPUTexture} texture - 返却するテクスチャ / texture to release
      * @return {void}
      */
     release(texture) {
         texturePoolReleaseService(this.buckets, texture, this.currentFrame);
     }
     /**
-     * @description プール統計を取得
-     * @return {{ total: number, inUse: number, available: number }}
-     */
-    getStats() {
-        let inUse = 0;
-        let available = 0;
-        for (const bucket of this.buckets.values()) {
-            for (const entry of bucket) {
-                if (entry.inUse) {
-                    inUse++;
-                }
-                else {
-                    available++;
-                }
-            }
-        }
-        return {
-            "total": this.totalCount[0],
-            inUse,
-            available
-        };
-    }
-    /**
-     * @description 解放
+     * @description 全テクスチャを破棄しプールを解放する
+     *              Destroy all textures and dispose of the pool
      * @return {void}
      */
     dispose() {
@@ -121,31 +128,3 @@ export class TexturePool {
         this.totalCount[0] = 0;
     }
 }
-/**
- * @description グローバルテクスチャプールインスタンス
- */
-let $texturePool = null;
-/**
- * @description テクスチャプールを初期化
- * @param {GPUDevice} device
- * @return {void}
- */
-export const initTexturePool = (device) => {
-    $texturePool = new TexturePool(device);
-};
-/**
- * @description テクスチャプールを取得
- * @return {TexturePool | null}
- */
-export const getTexturePool = () => {
-    return $texturePool;
-};
-/**
- * @description テクスチャプールをクリア
- * @return {void}
- */
-export const clearTexturePool = () => {
-    if ($texturePool) {
-        $texturePool.dispose();
-    }
-};