@next2d/webgl 1.18.12 → 3.0.0

package/src/Context.js

@@ -0,0 +1,388 @@
+import { execute as beginPath } from "./PathCommand/service/PathCommandBeginPathService";
+import { execute as moveTo } from "./PathCommand/usecase/PathCommandMoveToUseCase";
+import { execute as lineTo } from "./PathCommand/usecase/PathCommandLineToUseCase";
+import { execute as quadraticCurveTo } from "./PathCommand/usecase/PathCommandQuadraticCurveToUseCase";
+import { execute as closePath } from "./PathCommand/usecase/PathCommandClosePathUseCase";
+import { execute as arc } from "./PathCommand/usecase/PathCommandArcUseCase";
+import { execute as bezierCurveTo } from "./PathCommand/usecase/PathCommandBezierCurveToUseCase";
+import { execute as contextUpdateBackgroundColorService } from "./Context/service/ContextUpdateBackgroundColorService";
+import { execute as contextFillBackgroundColorService } from "./Context/service/ContextFillBackgroundColorService";
+import { execute as contextResizeUseCase } from "./Context/usecase/ContextResizeUseCase";
+import { execute as contextClearRectUseCase } from "./Context/usecase/ContextClearRectUseCase";
+import { execute as contextBindUseCase } from "./Context/usecase/ContextBindUseCase";
+import { execute as contextSaveService } from "./Context/service/ContextSaveService";
+import { execute as contextRestoreService } from "./Context/service/ContextRestoreService";
+import { execute as contextSetTransformService } from "./Context/service/ContextSetTransformService";
+import { execute as contextTransformService } from "./Context/service/ContextTransformService";
+import { execute as contextResetService } from "./Context/service/ContextResetService";
+import { execute as contextResetStyleService } from "./Context/service/ContextResetStyleService";
+import { execute as contextBeginNodeRenderingService } from "./Context/service/ContextBeginNodeRenderingService";
+import { execute as contextEndNodeRenderingService } from "./Context/service/ContextEndNodeRenderingService";
+import { execute as contextFillUseCase } from "./Context/usecase/ContextFillUseCase";
+import { execute as contextGradientFillUseCase } from "./Context/usecase/ContextGradientFillUseCase";
+import { execute as contextGradientStrokeUseCase } from "./Context/usecase/ContextGradientStrokeUseCase";
+import { execute as contextUseGridService } from "./Context/service/ContextUseGridService";
+import { execute as contextClipUseCase } from "./Context/usecase/ContextClipUseCase";
+import { execute as atlasManagerCreateNodeService } from "./AtlasManager/service/AtlasManagerCreateNodeService";
+import { execute as atlasManagerRemoveNodeService } from "./AtlasManager/service/AtlasManagerRemoveNodeService";
+import { execute as blnedDrawDisplayObjectUseCase } from "./Blend/usecase/BlnedDrawDisplayObjectUseCase";
+import { execute as blnedClearArraysInstancedUseCase } from "./Blend/usecase/BlnedClearArraysInstancedUseCase";
+import { execute as blnedDrawArraysInstancedUseCase } from "./Blend/usecase/BlnedDrawArraysInstancedUseCase";
+import { execute as vertexArrayObjectBootUseCase } from "./VertexArrayObject/usecase/VertexArrayObjectBootUseCase";
+import { execute as frameBufferManagerTransferMainCanvasService } from "./FrameBufferManager/service/FrameBufferManagerTransferMainCanvasService";
+import { execute as blendBootUseCase } from "./Blend/usecase/BlendBootUseCase";
+import { execute as maskBeginMaskService } from "./Mask/service/MaskBeginMaskService";
+import { execute as maskSetMaskBoundsService } from "./Mask/service/MaskSetMaskBoundsService";
+import { execute as maskEndMaskService } from "./Mask/service/MaskEndMaskService";
+import { execute as maskLeaveMaskUseCase } from "./Mask/usecase/MaskLeaveMaskUseCase";
+import { execute as contextDrawPixelsUseCase } from "./Context/usecase/ContextDrawPixelsUseCase";
+import { execute as contextDrawElementUseCase } from "./Context/usecase/ContextDrawElementUseCase";
+import { execute as contextBitmapFillUseCase } from "./Context/usecase/ContextBitmapFillUseCase";
+import { execute as contextBitmapStrokeUseCase } from "./Context/usecase/ContextBitmapStrokeUseCase";
+import { execute as contextStrokeUseCase } from "./Context/usecase/ContextStrokeUseCase";
+import { execute as contextApplyFilterUseCase } from "./Context/usecase/ContextApplyFilterUseCase";
+import { execute as contextContainerBeginLayerUseCase } from "./Context/usecase/ContextContainerBeginLayerUseCase";
+import { execute as contextContainerEndLayerUseCase } from "./Context/usecase/ContextContainerEndLayerUseCase";
+import { execute as contextContainerDrawCachedFilterUseCase } from "./Context/usecase/ContextContainerDrawCachedFilterUseCase";
+import { execute as contextUpdateTransferBoundsService } from "./Context/service/ContextUpdateTransferBoundsService";
+import { execute as contextDrawFillUseCase } from "./Context/usecase/ContextDrawFillUseCase";
+import { execute as contextCreateImageBitmapService } from "./Context/service/ContextCreateImageBitmapService";
+import { $setGradientLUTGeneratorMaxLength } from "./Shader/GradientLUTGenerator";
+import { $getAtlasAttachmentObject, $clearTransferBounds, $getAtlasTextureObject } from "./AtlasManager";
+import { $setReadFrameBuffer, $setDrawFrameBuffer, $currentAttachment, $setAtlasFrameBuffer, $setBitmapFrameBuffer } from "./FrameBufferManager";
+import { $setRenderMaxSize, $setWebGL2RenderingContext, $setSamples, $getFloat32Array9, $getArray, $setContext, $setDevicePixelRatio } from "./WebGLUtil";
+export class Context {
+    constructor(gl, samples, device_pixel_ratio = 1) {
+        Object.defineProperty(this, "$stack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "$matrix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "$clearColorR", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "$clearColorG", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "$clearColorB", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "$clearColorA", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "$mainAttachmentObject", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "$stackAttachmentObject", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "globalAlpha", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "globalCompositeOperation", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "imageSmoothingEnabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "$fillStyle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "$strokeStyle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "maskBounds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "thickness", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "caps", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "joints", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "miterLimit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "newDrawState", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        $setWebGL2RenderingContext(gl);
+        $setRenderMaxSize(gl.getParameter(gl.MAX_TEXTURE_SIZE));
+        $setSamples(samples);
+        $setDevicePixelRatio(device_pixel_ratio);
+        this.$stack = $getArray();
+        this.$stackAttachmentObject = $getArray();
+        this.$matrix = $getFloat32Array9(1, 0, 0, 0, 1, 0, 0, 0, 1);
+        // bakground color
+        this.$clearColorR = 0;
+        this.$clearColorG = 0;
+        this.$clearColorB = 0;
+        this.$clearColorA = 0;
+        // stroke
+        this.thickness = 1;
+        this.caps = 0;
+        this.joints = 2;
+        this.miterLimit = 0;
+        // メインのアタッチメントオブジェクト
+        this.$mainAttachmentObject = null;
+        // グローバルアルファ、合成モード、イメージのスムージング設定
+        this.globalAlpha = 1;
+        this.globalCompositeOperation = "normal";
+        this.imageSmoothingEnabled = false;
+        // 塗りつぶしタイプ、ストロークタイプ
+        this.$fillStyle = new Float32Array([1, 1, 1, 1]);
+        this.$strokeStyle = new Float32Array([1, 1, 1, 1]);
+        // マスクの描画範囲
+        this.maskBounds = {
+            "xMin": 0,
+            "yMin": 0,
+            "xMax": 0,
+            "yMax": 0
+        };
+        // WebTextureの設定
+        gl.pixelStorei(gl.UNPACK_ALIGNMENT, 1);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+        // 初期化時に1回だけ設定するステート
+        gl.clearColor(0, 0, 0, 0);
+        gl.frontFace(gl.CCW);
+        // FrameBufferManagerの初期起動
+        $setReadFrameBuffer(gl);
+        $setDrawFrameBuffer(gl);
+        $setAtlasFrameBuffer(gl, $getAtlasTextureObject());
+        $setBitmapFrameBuffer(gl);
+        // VertexArrayObjectの初期起動
+        vertexArrayObjectBootUseCase(gl);
+        // ブレンドモードを起動する
+        blendBootUseCase();
+        // グラデーションの最大長を設定
+        $setGradientLUTGeneratorMaxLength(gl);
+        // コンテキストをセット
+        $setContext(this);
+    }
+    clearTransferBounds() {
+        $clearTransferBounds();
+    }
+    updateBackgroundColor(red, green, blue, alpha) {
+        contextUpdateBackgroundColorService(this, red, green, blue, alpha);
+    }
+    fillBackgroundColor() {
+        contextFillBackgroundColorService(this.$clearColorR, this.$clearColorG, this.$clearColorB, this.$clearColorA);
+    }
+    resize(width, height, cache_clear = true) {
+        contextResizeUseCase(this, width, height, cache_clear);
+    }
+    clearRect(x, y, w, h) {
+        contextClearRectUseCase(x, y, w, h);
+    }
+    bind(attachment_object) {
+        contextBindUseCase(this, attachment_object);
+    }
+    save() {
+        contextSaveService(this);
+    }
+    restore() {
+        contextRestoreService(this);
+    }
+    setTransform(a, b, c, d, e, f) {
+        contextSetTransformService(this.$matrix, a, b, c, d, e, f);
+    }
+    transform(a, b, c, d, e, f) {
+        contextTransformService(this, a, b, c, d, e, f);
+    }
+    reset() {
+        contextResetService(this);
+    }
+    beginPath() {
+        // reset color style
+        contextResetStyleService(this);
+        // begin path
+        beginPath();
+    }
+    moveTo(x, y) {
+        moveTo(x, y);
+    }
+    lineTo(x, y) {
+        lineTo(x, y);
+    }
+    quadraticCurveTo(cx, cy, x, y) {
+        quadraticCurveTo(cx, cy, x, y);
+    }
+    fillStyle(red, green, blue, alpha) {
+        this.$fillStyle[0] = red;
+        this.$fillStyle[1] = green;
+        this.$fillStyle[2] = blue;
+        this.$fillStyle[3] = alpha;
+    }
+    strokeStyle(red, green, blue, alpha) {
+        this.$strokeStyle[0] = red;
+        this.$strokeStyle[1] = green;
+        this.$strokeStyle[2] = blue;
+        this.$strokeStyle[3] = alpha;
+    }
+    closePath() {
+        closePath();
+    }
+    arc(x, y, radius) {
+        arc(x, y, radius);
+    }
+    bezierCurveTo(cx1, cy1, cx2, cy2, x, y) {
+        bezierCurveTo(cx1, cy1, cx2, cy2, x, y);
+    }
+    fill() {
+        contextFillUseCase("fill");
+    }
+    gradientFill(type, stops, matrix, spread, interpolation, focal) {
+        contextGradientFillUseCase(type, stops, matrix, spread, interpolation, focal);
+    }
+    bitmapFill(pixels, matrix, width, height, repeat, smooth) {
+        contextBitmapFillUseCase(pixels, matrix, width, height, repeat, smooth);
+    }
+    stroke() {
+        contextStrokeUseCase();
+    }
+    gradientStroke(type, stops, matrix, spread, interpolation, focal) {
+        contextGradientStrokeUseCase(type, stops, matrix, spread, interpolation, focal);
+    }
+    bitmapStroke(pixels, matrix, width, height, repeat, smooth) {
+        contextBitmapStrokeUseCase(pixels, matrix, width, height, repeat, smooth);
+    }
+    clip() {
+        contextClipUseCase();
+    }
+    get currentAttachmentObject() {
+        return $currentAttachment;
+    }
+    get atlasAttachmentObject() {
+        return $getAtlasAttachmentObject();
+    }
+    createNode(width, height) {
+        return atlasManagerCreateNodeService(width, height);
+    }
+    removeNode(node) {
+        atlasManagerRemoveNodeService(node);
+    }
+    beginNodeRendering(node) {
+        this.newDrawState = true;
+        contextUpdateTransferBoundsService(node);
+        contextBeginNodeRenderingService(node.x, node.y, node.w, node.h);
+    }
+    endNodeRendering() {
+        contextEndNodeRenderingService();
+    }
+    drawFill() {
+        contextDrawFillUseCase();
+    }
+    drawDisplayObject(node, x_min, y_min, x_max, y_max, color_transform) {
+        contextUpdateTransferBoundsService(node);
+        blnedDrawDisplayObjectUseCase(node, x_min, y_min, x_max, y_max, color_transform);
+    }
+    drawArraysInstanced() {
+        blnedDrawArraysInstancedUseCase();
+    }
+    clearArraysInstanced() {
+        blnedClearArraysInstancedUseCase();
+    }
+    transferMainCanvas() {
+        frameBufferManagerTransferMainCanvasService();
+    }
+    drawPixels(node, pixels) {
+        contextDrawPixelsUseCase(node, pixels);
+    }
+    drawElement(node, element, _flipY = false) {
+        contextDrawElementUseCase(node, element);
+    }
+    beginMask() {
+        maskBeginMaskService();
+    }
+    setMaskBounds(x_min, y_min, x_max, y_max) {
+        maskSetMaskBoundsService(x_min, y_min, x_max, y_max);
+    }
+    endMask() {
+        maskEndMaskService();
+    }
+    leaveMask() {
+        this.drawArraysInstanced();
+        maskLeaveMaskUseCase();
+    }
+    useGrid(grid_data) {
+        contextUseGridService(grid_data);
+    }
+    applyFilter(node, unique_key, updated, width, height, is_bitmap, matrix, color_transform, blend_mode, bounds, params) {
+        this.drawArraysInstanced();
+        contextApplyFilterUseCase(node, unique_key, updated, width, height, is_bitmap, matrix, color_transform, blend_mode, bounds, params);
+    }
+    containerBeginLayer(width, height) {
+        this.drawArraysInstanced();
+        contextContainerBeginLayerUseCase(width, height);
+    }
+    containerEndLayer(blend_mode, matrix, color_transform, use_filter, filter_bounds, filter_params, unique_key, filter_key) {
+        contextContainerEndLayerUseCase(blend_mode, matrix, color_transform, use_filter, filter_bounds, filter_params, unique_key, filter_key);
+    }
+    containerDrawCachedFilter(blend_mode, matrix, color_transform, filter_bounds, unique_key, filter_key) {
+        contextContainerDrawCachedFilterUseCase(blend_mode, matrix, color_transform, filter_bounds, unique_key, filter_key);
+    }
+    async createImageBitmap(width, height) {
+        return await contextCreateImageBitmapService(width, height);
+    }
+}

package/src/Filter/BevelFilter/usecase/FilterApplyBevelFilterUseCase.d.ts

@@ -0,0 +1,22 @@
+import type { ITextureObject } from "../../../interface/ITextureObject";
+/**
+ *
+ * @param  {ITextureObject} texture_object
+ * @param  {Float32Array} matrix
+ * @param  {number} distance
+ * @param  {number} angle
+ * @param  {number} highlight_color
+ * @param  {number} highlight_alpha
+ * @param  {number} shadow_color
+ * @param  {number} shadow_alpha
+ * @param  {number} blur_x
+ * @param  {number} blur_y
+ * @param  {number} strength
+ * @param  {number} quality
+ * @param  {number} type
+ * @param  {boolean} knockout
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (texture_object: ITextureObject, matrix: Float32Array, distance?: number, angle?: number, highlight_color?: number, highlight_alpha?: number, shadow_color?: number, shadow_alpha?: number, blur_x?: number, blur_y?: number, strength?: number, quality?: number, type?: number, knockout?: boolean) => ITextureObject;

package/src/Filter/BevelFilter/usecase/FilterApplyBevelFilterUseCase.js

@@ -0,0 +1,105 @@
+import { execute as frameBufferManagerGetAttachmentObjectUseCase } from "../../../FrameBufferManager/usecase/FrameBufferManagerGetAttachmentObjectUseCase";
+import { execute as textureManagerBind0UseCase } from "../../../TextureManager/usecase/TextureManagerBind0UseCase";
+import { execute as shaderManagerDrawTextureUseCase } from "../../../Shader/ShaderManager/usecase/ShaderManagerDrawTextureUseCase";
+import { execute as variantsBlendTextureShaderService } from "../../../Shader/Variants/Blend/service/VariantsBlendTextureShaderService";
+import { execute as shaderManagerSetTextureUniformService } from "../../../Shader/ShaderManager/service/ShaderManagerSetTextureUniformService";
+import { execute as blendEraseService } from "../../../Blend/service/BlendEraseService";
+import { execute as blendResetService } from "../../../Blend/service/BlendResetService";
+import { execute as filterApplyBlurFilterUseCase } from "../../BlurFilter/usecase/FilterApplyBlurFilterUseCase";
+import { execute as frameBufferManagerReleaseAttachmentObjectUseCase } from "../../../FrameBufferManager/usecase/FrameBufferManagerReleaseAttachmentObjectUseCase";
+import { execute as filterApplyBitmapFilterUseCase } from "../../BitmapFilter/usecase/FilterApplyBitmapFilterUseCase";
+import { execute as textureManagerReleaseTextureObjectUseCase } from "../../../TextureManager/usecase/TextureManagerReleaseTextureObjectUseCase";
+import { $offset, $intToR, $intToG, $intToB } from "../../../Filter";
+import { $devicePixelRatio, $context } from "../../../WebGLUtil";
+/**
+ * @type {number}
+ * @private
+ */
+const $Deg2Rad = Math.PI / 180;
+/**
+ *
+ * @param  {ITextureObject} texture_object
+ * @param  {Float32Array} matrix
+ * @param  {number} distance
+ * @param  {number} angle
+ * @param  {number} highlight_color
+ * @param  {number} highlight_alpha
+ * @param  {number} shadow_color
+ * @param  {number} shadow_alpha
+ * @param  {number} blur_x
+ * @param  {number} blur_y
+ * @param  {number} strength
+ * @param  {number} quality
+ * @param  {number} type
+ * @param  {boolean} knockout
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export const execute = (texture_object, matrix, distance = 4, angle = 45, highlight_color = 0xffffff, highlight_alpha = 1, shadow_color = 0, shadow_alpha = 1, blur_x = 4, blur_y = 4, strength = 1, quality = 1, type = 0, knockout = false) => {
+    const baseWidth = texture_object.width;
+    const baseHeight = texture_object.height;
+    const baseOffsetX = $offset.x;
+    const baseOffsetY = $offset.y;
+    const xScale = Math.sqrt(matrix[0] * matrix[0] + matrix[1] * matrix[1]);
+    const yScale = Math.sqrt(matrix[2] * matrix[2] + matrix[3] * matrix[3]);
+    // pointer
+    const devicePixelRatio = $devicePixelRatio;
+    const radian = angle * $Deg2Rad;
+    const x = Math.cos(radian) * distance * (xScale / devicePixelRatio);
+    const y = Math.sin(radian) * distance * (yScale / devicePixelRatio);
+    const currentAttachmentObject = $context.currentAttachmentObject;
+    const attachmentObject = frameBufferManagerGetAttachmentObjectUseCase(baseWidth, baseHeight, false);
+    $context.bind(attachmentObject);
+    $context.reset();
+    $context.setTransform(1, 0, 0, 1, 0, 0);
+    textureManagerBind0UseCase(texture_object);
+    const shaderManager = variantsBlendTextureShaderService();
+    shaderManagerSetTextureUniformService(shaderManager, texture_object.width, texture_object.height);
+    shaderManagerDrawTextureUseCase(shaderManager);
+    $context.setTransform(1, 0, 0, 1, x * 2, y * 2);
+    blendEraseService();
+    shaderManagerSetTextureUniformService(shaderManager, texture_object.width, texture_object.height);
+    shaderManagerDrawTextureUseCase(shaderManager);
+    blendResetService();
+    const bevelBaseTextureObject = attachmentObject.texture;
+    if (currentAttachmentObject) {
+        $context.bind(currentAttachmentObject);
+    }
+    const blurTextureObject = filterApplyBlurFilterUseCase(bevelBaseTextureObject, matrix, blur_x, blur_y, quality, false);
+    frameBufferManagerReleaseAttachmentObjectUseCase(attachmentObject);
+    const blurWidth = blurTextureObject.width;
+    const blurHeight = blurTextureObject.height;
+    const bevelWidth = Math.ceil(blurWidth + Math.abs(x) * 2);
+    const bevelHeight = Math.ceil(blurHeight + Math.abs(y) * 2);
+    // bevel filter buffer
+    let typeName = "";
+    switch (type) {
+        case 0:
+            typeName = "full";
+            break;
+        case 1:
+            typeName = "inner";
+            break;
+        case 2:
+            typeName = "outer";
+            break;
+    }
+    const isInner = typeName === "inner";
+    const width = isInner ? baseWidth : bevelWidth;
+    const height = isInner ? baseHeight : bevelHeight;
+    const absX = Math.abs(x);
+    const absY = Math.abs(y);
+    const blurOffsetX = (blurWidth - baseWidth) / 2;
+    const blurOffsetY = (blurHeight - baseHeight) / 2;
+    const baseTextureX = isInner ? 0 : absX + blurOffsetX;
+    const baseTextureY = isInner ? 0 : absY + blurOffsetY;
+    const blurTextureX = isInner ? -blurOffsetX - x : absX - x;
+    const blurTextureY = isInner ? -blurOffsetY - y : absY - y;
+    const textureObject = filterApplyBitmapFilterUseCase(texture_object, blurTextureObject, width, height, baseWidth, baseHeight, baseTextureX, baseTextureY, blurWidth, blurHeight, blurTextureX, blurTextureY, false, typeName, knockout, strength, null, null, null, $intToR(highlight_color, highlight_alpha, true), $intToG(highlight_color, highlight_alpha, true), $intToB(highlight_color, highlight_alpha, true), highlight_alpha, $intToR(shadow_color, shadow_alpha, true), $intToG(shadow_color, shadow_alpha, true), $intToB(shadow_color, shadow_alpha, true), shadow_alpha);
+    $offset.x = baseOffsetX + baseTextureX;
+    $offset.y = baseOffsetY + baseTextureY;
+    textureManagerReleaseTextureObjectUseCase(texture_object);
+    textureManagerReleaseTextureObjectUseCase(blurTextureObject);
+    return textureObject;
+};

package/src/Filter/BitmapFilter/usecase/FilterApplyBitmapFilterUseCase.d.ts

@@ -0,0 +1,37 @@
+import type { ITextureObject } from "../../../interface/ITextureObject";
+/**
+ * @description BitmapFilterを適用する
+ *              Apply BitmapFilter
+ *
+ * @param  {ITextureObject} texture_object
+ * @param  {ITextureObject} blur_texture_object
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {number} base_width
+ * @param  {number} base_height
+ * @param  {number} base_offset_x
+ * @param  {number} base_offset_y
+ * @param  {number} blur_width
+ * @param  {number} blur_height
+ * @param  {number} blur_offset_x
+ * @param  {number} blur_offset_y
+ * @param  {boolean} is_glow
+ * @param  {string} type
+ * @param  {boolean} knockout
+ * @param  {number} strength
+ * @param  {Float32Array | null} ratios
+ * @param  {Float32Array | null} colors
+ * @param  {Float32Array | null} alphas
+ * @param  {number} color_r1
+ * @param  {number} color_g1
+ * @param  {number} color_b1
+ * @param  {number} color_a1
+ * @param  {number} color_r2
+ * @param  {number} color_g2
+ * @param  {number} color_b2
+ * @param  {number} color_a2
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (texture_object: ITextureObject, blur_texture_object: ITextureObject, width: number, height: number, base_width: number, base_height: number, base_offset_x: number, base_offset_y: number, blur_width: number, blur_height: number, blur_offset_x: number, blur_offset_y: number, is_glow: boolean, type: string, knockout: boolean, strength: number, ratios?: Float32Array | null, colors?: Float32Array | null, alphas?: Float32Array | null, color_r1?: number, color_g1?: number, color_b1?: number, color_a1?: number, color_r2?: number, color_g2?: number, color_b2?: number, color_a2?: number) => ITextureObject;

package/src/Filter/BitmapFilter/usecase/FilterApplyBitmapFilterUseCase.js

@@ -0,0 +1,108 @@
+import { execute as frameBufferManagerGetAttachmentObjectUseCase } from "../../../FrameBufferManager/usecase/FrameBufferManagerGetAttachmentObjectUseCase";
+import { execute as textureManagerBind01UseCase } from "../../../TextureManager/usecase/TextureManagerBind01UseCase";
+import { execute as textureManagerBind0UseCase } from "../../../TextureManager/usecase/TextureManagerBind0UseCase";
+import { execute as textureManagerBind02UseCase } from "../../../TextureManager/usecase/TextureManagerBind02UseCase";
+import { execute as textureManagerBind012UseCase } from "../../../TextureManager/usecase/TextureManagerBind012UseCase";
+import { execute as blendOneZeroService } from "../../../Blend/service/BlendOneZeroService";
+import { execute as blendSourceInService } from "../../../Blend/service/BlendSourceInService";
+import { execute as blendSourceAtopService } from "../../../Blend/service/BlendSourceAtopService";
+import { execute as blendResetService } from "../../../Blend/service/BlendResetService";
+import { execute as variantsBitmapFilterShaderService } from "../../../Shader/Variants/Filter/service/VariantsBitmapFilterShaderService";
+import { execute as shaderManagerDrawTextureUseCase } from "../../../Shader/ShaderManager/usecase/ShaderManagerDrawTextureUseCase";
+import { execute as shaderManagerSetBitmapFilterUniformService } from "../../../Shader/ShaderManager/service/ShaderManagerSetBitmapFilterUniformService";
+import { execute as frameBufferManagerReleaseAttachmentObjectUseCase } from "../../../FrameBufferManager/usecase/FrameBufferManagerReleaseAttachmentObjectUseCase";
+import { execute as variantsBlendTextureShaderService } from "../../../Shader/Variants/Blend/service/VariantsBlendTextureShaderService";
+import { execute as shaderManagerSetTextureUniformService } from "../../../Shader/ShaderManager/service/ShaderManagerSetTextureUniformService";
+import { execute as gradientLUTGenerateFilterTextureUseCase } from "../../../Shader/GradientLUTGenerator/usecase/GradientLUTGenerateFilterTextureUseCase";
+import { $context } from "../../../WebGLUtil";
+/**
+ * @description BitmapFilterを適用する
+ *              Apply BitmapFilter
+ *
+ * @param  {ITextureObject} texture_object
+ * @param  {ITextureObject} blur_texture_object
+ * @param  {number} width
+ * @param  {number} height
+ * @param  {number} base_width
+ * @param  {number} base_height
+ * @param  {number} base_offset_x
+ * @param  {number} base_offset_y
+ * @param  {number} blur_width
+ * @param  {number} blur_height
+ * @param  {number} blur_offset_x
+ * @param  {number} blur_offset_y
+ * @param  {boolean} is_glow
+ * @param  {string} type
+ * @param  {boolean} knockout
+ * @param  {number} strength
+ * @param  {Float32Array | null} ratios
+ * @param  {Float32Array | null} colors
+ * @param  {Float32Array | null} alphas
+ * @param  {number} color_r1
+ * @param  {number} color_g1
+ * @param  {number} color_b1
+ * @param  {number} color_a1
+ * @param  {number} color_r2
+ * @param  {number} color_g2
+ * @param  {number} color_b2
+ * @param  {number} color_a2
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export const execute = (texture_object, blur_texture_object, width, height, base_width, base_height, base_offset_x, base_offset_y, blur_width, blur_height, blur_offset_x, blur_offset_y, is_glow, type, knockout, strength, ratios = null, colors = null, alphas = null, color_r1 = 0, color_g1 = 0, color_b1 = 0, color_a1 = 0, color_r2 = 0, color_g2 = 0, color_b2 = 0, color_a2 = 0) => {
+    const currentAttachmentObject = $context.currentAttachmentObject;
+    const attachmentObject = frameBufferManagerGetAttachmentObjectUseCase(width, height, false);
+    $context.bind(attachmentObject);
+    const isInner = type === "inner";
+    const isGradient = ratios !== null && colors !== null && alphas !== null;
+    let gradientTextureObject = null;
+    if (isGradient) {
+        gradientTextureObject = gradientLUTGenerateFilterTextureUseCase(ratios, colors, alphas);
+    }
+    if (isInner) {
+        $context.reset();
+        $context.setTransform(1, 0, 0, 1, 0, 0);
+        textureManagerBind0UseCase(texture_object, true);
+        const shaderManager = variantsBlendTextureShaderService();
+        shaderManagerSetTextureUniformService(shaderManager, texture_object.width, texture_object.height);
+        shaderManagerDrawTextureUseCase(shaderManager);
+        if (isGradient && gradientTextureObject) {
+            textureManagerBind02UseCase(blur_texture_object, gradientTextureObject, true);
+        }
+        else {
+            textureManagerBind0UseCase(blur_texture_object, true);
+        }
+    }
+    else {
+        if (isGradient && gradientTextureObject) {
+            textureManagerBind012UseCase(blur_texture_object, texture_object, gradientTextureObject, true);
+        }
+        else {
+            textureManagerBind01UseCase(blur_texture_object, texture_object, true);
+        }
+    }
+    const transformsBase = !(isInner || type === "full" && knockout);
+    const transformsBlur = !(width === blur_width && height === blur_height && blur_offset_x === 0 && blur_offset_y === 0);
+    const appliesStrength = !(strength === 1);
+    if (!isInner) {
+        blendOneZeroService();
+    }
+    else if (knockout) {
+        blendSourceInService();
+    }
+    else {
+        blendSourceAtopService();
+    }
+    const shaderManager = variantsBitmapFilterShaderService(transformsBase, transformsBlur, is_glow, type, knockout, appliesStrength, isGradient);
+    shaderManagerSetBitmapFilterUniformService(shaderManager, width, height, base_width, base_height, base_offset_x, base_offset_y, blur_width, blur_height, blur_offset_x, blur_offset_y, is_glow, strength, color_r1, color_g1, color_b1, color_a1, color_r2, color_g2, color_b2, color_a2, transformsBase, transformsBlur, appliesStrength, isGradient);
+    shaderManagerDrawTextureUseCase(shaderManager);
+    const textureObject = attachmentObject.texture;
+    frameBufferManagerReleaseAttachmentObjectUseCase(attachmentObject, false);
+    // ブレンドモードをリセット
+    blendResetService();
+    if (currentAttachmentObject) {
+        $context.bind(currentAttachmentObject);
+    }
+    return textureObject;
+};