@next2d/webgpu 3.0.0

package/src/AtlasManager.js

@@ -0,0 +1,123 @@
+const $MAX_VALUE = Number.MAX_VALUE;
+const $MIN_VALUE = -Number.MAX_VALUE;
+let $activeAtlasIndex = 0;
+export const $setActiveAtlasIndex = (index) => {
+    $activeAtlasIndex = index;
+};
+export const $getActiveAtlasIndex = () => {
+    return $activeAtlasIndex;
+};
+const $atlasAttachmentObjects = [];
+export const $getAtlasAttachmentObjects = () => {
+    return $atlasAttachmentObjects;
+};
+export const $setAtlasAttachmentObject = (attachment_object) => {
+    $atlasAttachmentObjects[$activeAtlasIndex] = attachment_object;
+};
+let $atlasCreator = null;
+export const $setAtlasCreator = (creator) => {
+    $atlasCreator = creator;
+};
+export const $getAtlasAttachmentObject = () => {
+    if (!($activeAtlasIndex in $atlasAttachmentObjects)) {
+        if ($atlasCreator) {
+            const attachment = $atlasCreator($activeAtlasIndex);
+            $setAtlasAttachmentObject(attachment);
+        }
+        else {
+            return null;
+        }
+    }
+    return $atlasAttachmentObjects[$activeAtlasIndex];
+};
+export const $getAtlasAttachmentObjectByIndex = (index) => {
+    if (!(index in $atlasAttachmentObjects)) {
+        return null;
+    }
+    return $atlasAttachmentObjects[index];
+};
+export const $hasAtlasAttachmentObject = () => {
+    return $activeAtlasIndex in $atlasAttachmentObjects;
+};
+export const $rootNodes = [];
+export let $atlasTexture = null;
+export const $setAtlasTexture = (texture_object) => {
+    $atlasTexture = texture_object;
+};
+export const $getAtlasTexture = () => {
+    return $atlasTexture;
+};
+const $transferBounds = [];
+export const $getActiveTransferBounds = (index) => {
+    if (!(index in $transferBounds)) {
+        $transferBounds[index] = new Float32Array([
+            $MAX_VALUE,
+            $MAX_VALUE,
+            $MIN_VALUE,
+            $MIN_VALUE
+        ]);
+    }
+    return $transferBounds[index];
+};
+const $allTransferBounds = [];
+export const $getActiveAllTransferBounds = (index) => {
+    if (!(index in $allTransferBounds)) {
+        $allTransferBounds[index] = new Float32Array([
+            $MAX_VALUE,
+            $MAX_VALUE,
+            $MIN_VALUE,
+            $MIN_VALUE
+        ]);
+    }
+    return $allTransferBounds[index];
+};
+export const $clearTransferBounds = () => {
+    for (let idx = 0; idx < $transferBounds.length; ++idx) {
+        const bounds = $transferBounds[idx];
+        if (!bounds) {
+            continue;
+        }
+        bounds[0] = bounds[1] = $MAX_VALUE;
+        bounds[2] = bounds[3] = $MIN_VALUE;
+    }
+    for (let idx = 0; idx < $allTransferBounds.length; ++idx) {
+        const bounds = $allTransferBounds[idx];
+        if (!bounds) {
+            continue;
+        }
+        bounds[0] = bounds[1] = $MAX_VALUE;
+        bounds[2] = bounds[3] = $MIN_VALUE;
+    }
+};
+let $currentAtlasIndex = 0;
+export const $setCurrentAtlasIndex = (index) => {
+    $currentAtlasIndex = index;
+};
+export const $getCurrentAtlasIndex = () => {
+    return $currentAtlasIndex;
+};
+export const $resetAtlas = () => {
+    $rootNodes.length = 0;
+    $setActiveAtlasIndex(0);
+    for (let idx = 0; idx < $atlasAttachmentObjects.length; idx++) {
+        const attachment = $atlasAttachmentObjects[idx];
+        if (!attachment) {
+            continue;
+        }
+        if (attachment.texture) {
+            attachment.texture.resource.destroy();
+        }
+        if (attachment.stencil) {
+            attachment.stencil.resource.destroy();
+        }
+        if (attachment.msaaTexture) {
+            attachment.msaaTexture.resource.destroy();
+        }
+        if (attachment.msaaStencil) {
+            attachment.msaaStencil.resource.destroy();
+        }
+    }
+    $atlasAttachmentObjects.length = 0;
+    $clearTransferBounds();
+    $setCurrentAtlasIndex(0);
+};

package/src/AttachmentManager/service/AttachmentManagerCreateAttachmentObjectService.d.ts

@@ -0,0 +1,13 @@
+import type { IAttachmentObject } from "../../interface/IAttachmentObject";
+/**
+ * @description 新しいアタッチメントオブジェクトを作成
+ *              Create a new attachment object
+ *
+ * @param  {{ attachmentId: number }} idCounter
+ * @return {IAttachmentObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (idCounter: {
+    attachmentId: number;
+}) => IAttachmentObject;

package/src/AttachmentManager/service/AttachmentManagerCreateAttachmentObjectService.js

@@ -0,0 +1,24 @@
+/**
+ * @description 新しいアタッチメントオブジェクトを作成
+ *              Create a new attachment object
+ *
+ * @param  {{ attachmentId: number }} idCounter
+ * @return {IAttachmentObject}
+ * @method
+ * @protected
+ */
+export const execute = (idCounter) => {
+    return {
+        "id": idCounter.attachmentId++,
+        "width": 0,
+        "height": 0,
+        "clipLevel": 0,
+        "msaa": false,
+        "mask": false,
+        "color": null,
+        "texture": null,
+        "stencil": null,
+        "msaaTexture": null,
+        "msaaStencil": null
+    };
+};

package/src/AttachmentManager/service/AttachmentManagerCreateColorBufferService.d.ts

@@ -0,0 +1,15 @@
+import type { IColorBufferObject } from "../../interface/IColorBufferObject";
+import type { IStencilBufferObject } from "../../interface/IStencilBufferObject";
+/**
+ * @description カラーバッファを新規作成
+ *              Create a new color buffer
+ *
+ * @param  {GPUDevice} device
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {IStencilBufferObject} stencil
+ * @return {IColorBufferObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (device: GPUDevice, width: number, height: number, stencil: IStencilBufferObject) => IColorBufferObject;

package/src/AttachmentManager/service/AttachmentManagerCreateColorBufferService.js

@@ -0,0 +1,31 @@
+/**
+ * @description カラーバッファを新規作成
+ *              Create a new color buffer
+ *
+ * @param  {GPUDevice} device
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {IStencilBufferObject} stencil
+ * @return {IColorBufferObject}
+ * @method
+ * @protected
+ */
+export const execute = (device, width, height, stencil) => {
+    const texture = device.createTexture({
+        "size": { width, height },
+        "format": "rgba8unorm",
+        "usage": GPUTextureUsage.RENDER_ATTACHMENT |
+            GPUTextureUsage.TEXTURE_BINDING |
+            GPUTextureUsage.COPY_SRC |
+            GPUTextureUsage.COPY_DST
+    });
+    return {
+        "resource": texture,
+        "view": texture.createView(),
+        stencil,
+        width,
+        height,
+        "area": width * height,
+        "dirty": false
+    };
+};

package/src/AttachmentManager/service/AttachmentManagerCreateRenderPassDescriptorService.d.ts

@@ -0,0 +1,5 @@
+import type { IAttachmentObject } from "../../interface/IAttachmentObject";
+/**
+ * @description レンダーパスディスクリプタを作成（プリアロケート再利用）
+ */
+export declare const execute: (attachment: IAttachmentObject, r: number, g: number, b: number, a: number, loadOp?: GPULoadOp) => GPURenderPassDescriptor;

package/src/AttachmentManager/service/AttachmentManagerCreateRenderPassDescriptorService.js

@@ -0,0 +1,42 @@
+const $clearValue = { "r": 0, "g": 0, "b": 0, "a": 0 };
+const $colorAttachment = {
+    "view": null,
+    "loadOp": "clear",
+    "storeOp": "store",
+    "clearValue": $clearValue
+};
+const $depthStencilAttachment = {
+    "view": null,
+    "depthLoadOp": "clear",
+    "depthStoreOp": "store",
+    "depthClearValue": 1.0,
+    "stencilLoadOp": "clear",
+    "stencilStoreOp": "store",
+    "stencilClearValue": 0
+};
+const $descriptor = {
+    "colorAttachments": [$colorAttachment]
+};
+/**
+ * @description レンダーパスディスクリプタを作成（プリアロケート再利用）
+ */
+export const execute = (attachment, r, g, b, a, loadOp = "clear") => {
+    const colorView = attachment.color?.view ?? attachment.texture?.view;
+    if (!colorView) {
+        throw new Error("No color view available for render pass");
+    }
+    $colorAttachment.view = colorView;
+    $colorAttachment.loadOp = loadOp;
+    $clearValue.r = r;
+    $clearValue.g = g;
+    $clearValue.b = b;
+    $clearValue.a = a;
+    if (attachment.stencil?.view) {
+        $depthStencilAttachment.view = attachment.stencil.view;
+        $descriptor.depthStencilAttachment = $depthStencilAttachment;
+    }
+    else {
+        $descriptor.depthStencilAttachment = undefined;
+    }
+    return $descriptor;
+};

package/src/AttachmentManager/service/AttachmentManagerCreateStencilBufferService.d.ts

@@ -0,0 +1,16 @@
+import type { IStencilBufferObject } from "../../interface/IStencilBufferObject";
+/**
+ * @description ステンシルバッファを新規作成
+ *              Create a new stencil buffer
+ *
+ * @param  {GPUDevice} device
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {{ stencilId: number }} idCounter
+ * @return {IStencilBufferObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (device: GPUDevice, width: number, height: number, idCounter: {
+    stencilId: number;
+}) => IStencilBufferObject;

package/src/AttachmentManager/service/AttachmentManagerCreateStencilBufferService.js

@@ -0,0 +1,28 @@
+/**
+ * @description ステンシルバッファを新規作成
+ *              Create a new stencil buffer
+ *
+ * @param  {GPUDevice} device
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {{ stencilId: number }} idCounter
+ * @return {IStencilBufferObject}
+ * @method
+ * @protected
+ */
+export const execute = (device, width, height, idCounter) => {
+    const texture = device.createTexture({
+        "size": { width, height },
+        "format": "depth24plus-stencil8",
+        "usage": GPUTextureUsage.RENDER_ATTACHMENT
+    });
+    return {
+        "id": idCounter.stencilId++,
+        "resource": texture,
+        "view": texture.createView(),
+        width,
+        height,
+        "area": width * height,
+        "dirty": false
+    };
+};

package/src/AttachmentManager/service/AttachmentManagerCreateTextureObjectService.d.ts

@@ -0,0 +1,17 @@
+import type { ITextureObject } from "../../interface/ITextureObject";
+/**
+ * @description テクスチャオブジェクトを新規作成
+ *              Create a new texture object
+ *
+ * @param  {GPUDevice} device
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {boolean} smooth
+ * @param  {{ textureId: number }} idCounter
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (device: GPUDevice, width: number, height: number, smooth: boolean, idCounter: {
+    textureId: number;
+}) => ITextureObject;

package/src/AttachmentManager/service/AttachmentManagerCreateTextureObjectService.js

@@ -0,0 +1,33 @@
+/**
+ * @description テクスチャオブジェクトを新規作成
+ *              Create a new texture object
+ *
+ * @param  {GPUDevice} device
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {boolean} smooth
+ * @param  {{ textureId: number }} idCounter
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export const execute = (device, width, height, smooth, idCounter) => {
+    const texture = device.createTexture({
+        "size": { width, height },
+        "format": "rgba8unorm",
+        "usage": GPUTextureUsage.RENDER_ATTACHMENT |
+            GPUTextureUsage.TEXTURE_BINDING |
+            GPUTextureUsage.COPY_SRC |
+            GPUTextureUsage.COPY_DST
+    });
+    const view = texture.createView();
+    return {
+        "id": idCounter.textureId++,
+        "resource": texture,
+        view,
+        width,
+        height,
+        "area": width * height,
+        smooth
+    };
+};

package/src/AttachmentManager/service/AttachmentManagerGetColorBufferService.d.ts

@@ -0,0 +1,16 @@
+import type { IColorBufferObject } from "../../interface/IColorBufferObject";
+import type { IStencilBufferObject } from "../../interface/IStencilBufferObject";
+/**
+ * @description カラーバッファを取得（プールから再利用または新規作成）
+ *              Get color buffer from pool or create new one
+ *
+ * @param  {GPUDevice} device
+ * @param  {IColorBufferObject[]} colorBufferPool
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {IStencilBufferObject} stencil
+ * @return {IColorBufferObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (device: GPUDevice, colorBufferPool: IColorBufferObject[], width: number, height: number, stencil: IStencilBufferObject) => IColorBufferObject;

package/src/AttachmentManager/service/AttachmentManagerGetColorBufferService.js

@@ -0,0 +1,28 @@
+import { execute as attachmentManagerCreateColorBufferService } from "./AttachmentManagerCreateColorBufferService";
+/**
+ * @description カラーバッファを取得（プールから再利用または新規作成）
+ *              Get color buffer from pool or create new one
+ *
+ * @param  {GPUDevice} device
+ * @param  {IColorBufferObject[]} colorBufferPool
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {IStencilBufferObject} stencil
+ * @return {IColorBufferObject}
+ * @method
+ * @protected
+ */
+export const execute = (device, colorBufferPool, width, height, stencil) => {
+    // プールから適切なサイズのものを検索
+    for (let i = 0; i < colorBufferPool.length; i++) {
+        const buffer = colorBufferPool[i];
+        if (buffer.width >= width && buffer.height >= height) {
+            colorBufferPool.splice(i, 1);
+            buffer.stencil = stencil;
+            buffer.dirty = false;
+            return buffer;
+        }
+    }
+    // 新規作成
+    return attachmentManagerCreateColorBufferService(device, width, height, stencil);
+};

package/src/AttachmentManager/service/AttachmentManagerGetStencilBufferService.d.ts

@@ -0,0 +1,17 @@
+import type { IStencilBufferObject } from "../../interface/IStencilBufferObject";
+/**
+ * @description ステンシルバッファを取得（プールから再利用または新規作成）
+ *              Get stencil buffer from pool or create new one
+ *
+ * @param  {GPUDevice} device
+ * @param  {IStencilBufferObject[]} stencilBufferPool
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {{ stencilId: number }} idCounter
+ * @return {IStencilBufferObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (device: GPUDevice, stencilBufferPool: IStencilBufferObject[], width: number, height: number, idCounter: {
+    stencilId: number;
+}) => IStencilBufferObject;

package/src/AttachmentManager/service/AttachmentManagerGetStencilBufferService.js

@@ -0,0 +1,27 @@
+import { execute as attachmentManagerCreateStencilBufferService } from "./AttachmentManagerCreateStencilBufferService";
+/**
+ * @description ステンシルバッファを取得（プールから再利用または新規作成）
+ *              Get stencil buffer from pool or create new one
+ *
+ * @param  {GPUDevice} device
+ * @param  {IStencilBufferObject[]} stencilBufferPool
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {{ stencilId: number }} idCounter
+ * @return {IStencilBufferObject}
+ * @method
+ * @protected
+ */
+export const execute = (device, stencilBufferPool, width, height, idCounter) => {
+    // プールから適切なサイズのものを検索
+    for (let i = 0; i < stencilBufferPool.length; i++) {
+        const buffer = stencilBufferPool[i];
+        if (buffer.width >= width && buffer.height >= height) {
+            stencilBufferPool.splice(i, 1);
+            buffer.dirty = false;
+            return buffer;
+        }
+    }
+    // 新規作成
+    return attachmentManagerCreateStencilBufferService(device, width, height, idCounter);
+};

package/src/AttachmentManager/service/AttachmentManagerGetTextureService.d.ts

@@ -0,0 +1,18 @@
+import type { ITextureObject } from "../../interface/ITextureObject";
+/**
+ * @description テクスチャオブジェクトを取得（プールから再利用または新規作成）
+ *              Get texture object from pool or create new one
+ *
+ * @param  {GPUDevice} device
+ * @param  {Map<string, ITextureObject[]>} texturePool
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {boolean} smooth
+ * @param  {{ textureId: number }} idCounter
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (device: GPUDevice, texturePool: Map<string, ITextureObject[]>, width: number, height: number, smooth: boolean, idCounter: {
+    textureId: number;
+}) => ITextureObject;

package/src/AttachmentManager/service/AttachmentManagerGetTextureService.js

@@ -0,0 +1,27 @@
+import { execute as attachmentManagerCreateTextureObjectService } from "./AttachmentManagerCreateTextureObjectService";
+/**
+ * @description テクスチャオブジェクトを取得（プールから再利用または新規作成）
+ *              Get texture object from pool or create new one
+ *
+ * @param  {GPUDevice} device
+ * @param  {Map<string, ITextureObject[]>} texturePool
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {boolean} smooth
+ * @param  {{ textureId: number }} idCounter
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export const execute = (device, texturePool, width, height, smooth, idCounter) => {
+    const key = `${width}x${height}_${smooth ? "smooth" : "nearest"}`;
+    // プールから再利用
+    if (texturePool.has(key)) {
+        const pool = texturePool.get(key);
+        if (pool.length > 0) {
+            return pool.pop();
+        }
+    }
+    // 新規作成
+    return attachmentManagerCreateTextureObjectService(device, width, height, smooth, idCounter);
+};

package/src/AttachmentManager/service/AttachmentManagerReleaseTextureService.d.ts

@@ -0,0 +1,12 @@
+import type { ITextureObject } from "../../interface/ITextureObject";
+/**
+ * @description テクスチャをプールに返却
+ *              Release texture back to pool
+ *
+ * @param  {Map<string, ITextureObject[]>} texturePool
+ * @param  {ITextureObject} textureObject
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (texturePool: Map<string, ITextureObject[]>, textureObject: ITextureObject) => void;

package/src/AttachmentManager/service/AttachmentManagerReleaseTextureService.js

@@ -0,0 +1,17 @@
+/**
+ * @description テクスチャをプールに返却
+ *              Release texture back to pool
+ *
+ * @param  {Map<string, ITextureObject[]>} texturePool
+ * @param  {ITextureObject} textureObject
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (texturePool, textureObject) => {
+    const key = `${textureObject.width}x${textureObject.height}_${textureObject.smooth ? "smooth" : "nearest"}`;
+    if (!texturePool.has(key)) {
+        texturePool.set(key, []);
+    }
+    texturePool.get(key).push(textureObject);
+};

package/src/AttachmentManager/usecase/AttachmentManagerGetAttachmentObjectUseCase.d.ts

@@ -0,0 +1,26 @@
+import type { IAttachmentObject } from "../../interface/IAttachmentObject";
+import type { ITextureObject } from "../../interface/ITextureObject";
+import type { IColorBufferObject } from "../../interface/IColorBufferObject";
+import type { IStencilBufferObject } from "../../interface/IStencilBufferObject";
+/**
+ * @description アタッチメントオブジェクトを取得
+ *              Get attachment object
+ *
+ * @param  {GPUDevice} device
+ * @param  {IAttachmentObject[]} attachmentPool
+ * @param  {Map<string, ITextureObject[]>} texturePool
+ * @param  {IColorBufferObject[]} colorBufferPool
+ * @param  {IStencilBufferObject[]} stencilBufferPool
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {boolean} msaa
+ * @param  {{ attachmentId: number, textureId: number, stencilId: number }} idCounter
+ * @return {IAttachmentObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (device: GPUDevice, attachmentPool: IAttachmentObject[], texturePool: Map<string, ITextureObject[]>, colorBufferPool: IColorBufferObject[], stencilBufferPool: IStencilBufferObject[], width: number, height: number, msaa: boolean, idCounter: {
+    attachmentId: number;
+    textureId: number;
+    stencilId: number;
+}) => IAttachmentObject;

package/src/AttachmentManager/usecase/AttachmentManagerGetAttachmentObjectUseCase.js

@@ -0,0 +1,43 @@
+import { execute as attachmentManagerCreateAttachmentObjectService } from "../service/AttachmentManagerCreateAttachmentObjectService";
+import { execute as attachmentManagerGetStencilBufferService } from "../service/AttachmentManagerGetStencilBufferService";
+import { execute as attachmentManagerGetColorBufferService } from "../service/AttachmentManagerGetColorBufferService";
+import { execute as attachmentManagerGetTextureService } from "../service/AttachmentManagerGetTextureService";
+/**
+ * @description アタッチメントオブジェクトを取得
+ *              Get attachment object
+ *
+ * @param  {GPUDevice} device
+ * @param  {IAttachmentObject[]} attachmentPool
+ * @param  {Map<string, ITextureObject[]>} texturePool
+ * @param  {IColorBufferObject[]} colorBufferPool
+ * @param  {IStencilBufferObject[]} stencilBufferPool
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {boolean} msaa
+ * @param  {{ attachmentId: number, textureId: number, stencilId: number }} idCounter
+ * @return {IAttachmentObject}
+ * @method
+ * @protected
+ */
+export const execute = (device, attachmentPool, texturePool, colorBufferPool, stencilBufferPool, width, height, msaa, idCounter) => {
+    // プールから再利用
+    const attachment = attachmentPool.length > 0
+        ? attachmentPool.pop()
+        : attachmentManagerCreateAttachmentObjectService(idCounter);
+    // サイズとフラグを更新
+    attachment.width = width;
+    attachment.height = height;
+    attachment.msaa = msaa;
+    attachment.mask = false;
+    attachment.clipLevel = 0;
+    // ステンシルバッファを取得または作成
+    const stencil = attachmentManagerGetStencilBufferService(device, stencilBufferPool, width, height, idCounter);
+    // カラーバッファを取得または作成（ステンシルを参照）
+    const color = attachmentManagerGetColorBufferService(device, colorBufferPool, width, height, stencil);
+    attachment.color = color;
+    attachment.stencil = stencil;
+    // テクスチャを取得
+    const texture = attachmentManagerGetTextureService(device, texturePool, width, height, true, idCounter);
+    attachment.texture = texture;
+    return attachment;
+};

package/src/AttachmentManager/usecase/AttachmentManagerReleaseAttachmentUseCase.d.ts

@@ -0,0 +1,18 @@
+import type { IAttachmentObject } from "../../interface/IAttachmentObject";
+import type { ITextureObject } from "../../interface/ITextureObject";
+import type { IColorBufferObject } from "../../interface/IColorBufferObject";
+import type { IStencilBufferObject } from "../../interface/IStencilBufferObject";
+/**
+ * @description アタッチメントを解放してプールに返却
+ *              Release attachment and return to pool
+ *
+ * @param  {IAttachmentObject[]} attachmentPool
+ * @param  {Map<string, ITextureObject[]>} texturePool
+ * @param  {IColorBufferObject[]} colorBufferPool
+ * @param  {IStencilBufferObject[]} stencilBufferPool
+ * @param  {IAttachmentObject} attachment
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (attachmentPool: IAttachmentObject[], texturePool: Map<string, ITextureObject[]>, colorBufferPool: IColorBufferObject[], stencilBufferPool: IStencilBufferObject[], attachment: IAttachmentObject) => void;

package/src/AttachmentManager/usecase/AttachmentManagerReleaseAttachmentUseCase.js

@@ -0,0 +1,33 @@
+import { execute as attachmentManagerReleaseTextureService } from "../service/AttachmentManagerReleaseTextureService";
+/**
+ * @description アタッチメントを解放してプールに返却
+ *              Release attachment and return to pool
+ *
+ * @param  {IAttachmentObject[]} attachmentPool
+ * @param  {Map<string, ITextureObject[]>} texturePool
+ * @param  {IColorBufferObject[]} colorBufferPool
+ * @param  {IStencilBufferObject[]} stencilBufferPool
+ * @param  {IAttachmentObject} attachment
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (attachmentPool, texturePool, colorBufferPool, stencilBufferPool, attachment) => {
+    // テクスチャをプールに返却
+    if (attachment.texture) {
+        attachmentManagerReleaseTextureService(texturePool, attachment.texture);
+        attachment.texture = null;
+    }
+    // カラーバッファをプールに返却
+    if (attachment.color) {
+        colorBufferPool.push(attachment.color);
+        attachment.color = null;
+    }
+    // ステンシルバッファをプールに返却
+    if (attachment.stencil) {
+        stencilBufferPool.push(attachment.stencil);
+        attachment.stencil = null;
+    }
+    // アタッチメントをプールに返却
+    attachmentPool.push(attachment);
+};