@next2d/webgl 1.18.12 → 2.0.0

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 { $getDevicePixelRatio, $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 = $getDevicePixelRatio();
+    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;
+};

package/src/Filter/BlurFilter/usecase/FilterApplyBlurFilterUseCase.d.ts

@@ -0,0 +1,16 @@
+import type { ITextureObject } from "../../../interface/ITextureObject";
+/**
+ * @description ぼかしフィルターを適用します。
+ *              Apply the blur filter.
+ *
+ * @param  {ITextureObject} texture_object
+ * @param  {Float32Array} matrix
+ * @param  {number} [blur_x=4]
+ * @param  {number} [blur_y=4]
+ * @param  {number} [quality=1]
+ * @param  {boolean} [removed=false]
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (texture_object: ITextureObject, matrix: Float32Array, blur_x?: number, blur_y?: number, quality?: number, removed?: boolean) => ITextureObject;

package/src/Filter/BlurFilter/usecase/FilterApplyBlurFilterUseCase.js

@@ -0,0 +1,134 @@
+import { execute as frameBufferManagerGetAttachmentObjectUseCase } from "../../../FrameBufferManager/usecase/FrameBufferManagerGetAttachmentObjectUseCase";
+import { execute as variantsBlendMatrixTextureShaderService } from "../../../Shader/Variants/Blend/service/VariantsBlendMatrixTextureShaderService";
+import { execute as shaderManagerSetMatrixTextureUniformService } from "../../../Shader/ShaderManager/service/ShaderManagerSetMatrixTextureUniformService";
+import { execute as shaderManagerDrawTextureUseCase } from "../../../Shader/ShaderManager/usecase/ShaderManagerDrawTextureUseCase";
+import { execute as textureManagerBind0UseCase } from "../../../TextureManager/usecase/TextureManagerBind0UseCase";
+import { execute as filterApplyDirectionalBlurFilterUseCase } from "../../../Filter/BlurFilter/usecase/FilterApplyDirectionalBlurFilterUseCase";
+import { execute as frameBufferManagerReleaseAttachmentObjectUseCase } from "../../../FrameBufferManager/usecase/FrameBufferManagerReleaseAttachmentObjectUseCase";
+import { execute as textureManagerReleaseTextureObjectUseCase } from "../../../TextureManager/usecase/TextureManagerReleaseTextureObjectUseCase";
+import { execute as blendOneZeroService } from "../../../Blend/service/BlendOneZeroService";
+import { execute as blendResetService } from "../../../Blend/service/BlendResetService";
+import { $offset } from "../../../Filter";
+import { $context, $getDevicePixelRatio } from "../../../WebGLUtil";
+/**
+ * @type {number[]}
+ * @constant
+ */
+const $STEP = [0.5, 1.05, 1.4, 1.55, 1.75, 1.9, 2, 2.15, 2.2, 2.3, 2.5, 3, 3, 3.5, 3.5];
+/**
+ * @description ぼかしフィルターを適用します。
+ *              Apply the blur filter.
+ *
+ * @param  {ITextureObject} texture_object
+ * @param  {Float32Array} matrix
+ * @param  {number} [blur_x=4]
+ * @param  {number} [blur_y=4]
+ * @param  {number} [quality=1]
+ * @param  {boolean} [removed=false]
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export const execute = (texture_object, matrix, blur_x = 4, blur_y = 4, quality = 1, removed = true) => {
+    const currentAttachmentObject = $context.currentAttachmentObject;
+    const xScale = Math.sqrt(matrix[0] * matrix[0] + matrix[1] * matrix[1]);
+    const yScale = Math.sqrt(matrix[2] * matrix[2] + matrix[3] * matrix[3]);
+    const devicePixelRatio = $getDevicePixelRatio();
+    const baseBlurX = blur_x * (xScale / devicePixelRatio);
+    const baseBlurY = blur_y * (yScale / devicePixelRatio);
+    const step = $STEP[quality - 1];
+    const dx = Math.round(baseBlurX * step);
+    const dy = Math.round(baseBlurY * step);
+    $offset.x += dx;
+    $offset.y += dy;
+    const width = texture_object.width + dx * 2;
+    const height = texture_object.height + dy * 2;
+    let bufferScaleX = 1;
+    let bufferScaleY = 1;
+    if (baseBlurX > 128) {
+        bufferScaleX = 0.0625;
+    }
+    else if (baseBlurX > 64) {
+        bufferScaleX = 0.125;
+    }
+    else if (baseBlurX > 32) {
+        bufferScaleX = 0.25;
+    }
+    else if (baseBlurX > 16) {
+        bufferScaleX = 0.5;
+    }
+    if (baseBlurY > 128) {
+        bufferScaleY = 0.0625;
+    }
+    else if (baseBlurY > 64) {
+        bufferScaleY = 0.125;
+    }
+    else if (baseBlurY > 32) {
+        bufferScaleY = 0.25;
+    }
+    else if (baseBlurY > 16) {
+        bufferScaleY = 0.5;
+    }
+    const bufferWidth = Math.ceil(width * bufferScaleX);
+    const bufferHeight = Math.ceil(height * bufferScaleY);
+    const attachmentObject0 = frameBufferManagerGetAttachmentObjectUseCase(bufferWidth, bufferHeight, false);
+    const attachmentObject1 = frameBufferManagerGetAttachmentObjectUseCase(bufferWidth, bufferHeight, false);
+    const attachments = [attachmentObject0, attachmentObject1];
+    // 描画元のテクスチャをattachmentObject0に描画
+    $context.bind(attachmentObject0);
+    $context.reset();
+    $context.setTransform(bufferScaleX, 0, 0, bufferScaleY, dx * bufferScaleX, dy * bufferScaleY);
+    textureManagerBind0UseCase(texture_object);
+    const shaderManager = variantsBlendMatrixTextureShaderService();
+    shaderManagerSetMatrixTextureUniformService(shaderManager, texture_object.width, texture_object.height);
+    shaderManagerDrawTextureUseCase(shaderManager);
+    // 描画元のテクスチャを解放
+    if (removed) {
+        textureManagerReleaseTextureObjectUseCase(texture_object);
+    }
+    const bufferBlurX = baseBlurX * bufferScaleX;
+    const bufferBlurY = baseBlurY * bufferScaleY;
+    let attachmentIndex = 0;
+    let textureObject = attachmentObject0.texture;
+    textureManagerBind0UseCase(textureObject, true);
+    blendOneZeroService();
+    for (let q = 0; q < quality; ++q) {
+        if (blur_x > 0) {
+            attachmentIndex = (attachmentIndex + 1) % 2;
+            const attachmentObject = attachments[attachmentIndex];
+            $context.bind(attachmentObject);
+            filterApplyDirectionalBlurFilterUseCase(textureObject, true, bufferBlurX);
+            textureObject = attachmentObject.texture;
+        }
+        if (blur_y > 0) {
+            attachmentIndex = (attachmentIndex + 1) % 2;
+            const attachmentObject = attachments[attachmentIndex];
+            $context.bind(attachmentObject);
+            filterApplyDirectionalBlurFilterUseCase(textureObject, false, bufferBlurY);
+            textureObject = attachmentObject.texture;
+        }
+    }
+    blendResetService();
+    if (bufferScaleX !== 1 || bufferScaleY !== 1) {
+        const attachmentObject = frameBufferManagerGetAttachmentObjectUseCase(width, height, false);
+        $context.bind(attachmentObject);
+        $context.setTransform(1 / bufferScaleX, 0, 0, 1 / bufferScaleY, 0, 0);
+        textureManagerBind0UseCase(textureObject, true);
+        shaderManagerSetMatrixTextureUniformService(shaderManager, textureObject.width, textureObject.height);
+        shaderManagerDrawTextureUseCase(shaderManager);
+        textureObject = attachmentObject.texture;
+        frameBufferManagerReleaseAttachmentObjectUseCase(attachments[0]);
+        frameBufferManagerReleaseAttachmentObjectUseCase(attachments[1]);
+        frameBufferManagerReleaseAttachmentObjectUseCase(attachmentObject, false);
+    }
+    else {
+        attachmentIndex = (attachmentIndex + 1) % 2;
+        frameBufferManagerReleaseAttachmentObjectUseCase(attachments[attachmentIndex]);
+        attachmentIndex = (attachmentIndex + 1) % 2;
+        frameBufferManagerReleaseAttachmentObjectUseCase(attachments[attachmentIndex], false);
+    }
+    if (currentAttachmentObject) {
+        $context.bind(currentAttachmentObject);
+    }
+    return textureObject;
+};

package/src/Filter/BlurFilter/usecase/FilterApplyDirectionalBlurFilterUseCase.d.ts

@@ -0,0 +1,13 @@
+import type { ITextureObject } from "../../../interface/ITextureObject";
+/**
+ * @description 指定方向にぼかしフィルターを適用します。
+ *              Apply the blur filter in the specified direction.
+ *
+ * @param  {ITextureObject} texture_object
+ * @param  {boolean} is_horizontal
+ * @param  {number} blur
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (texture_object: ITextureObject, is_horizontal: boolean, blur: number) => void;

package/src/Filter/BlurFilter/usecase/FilterApplyDirectionalBlurFilterUseCase.js

@@ -0,0 +1,24 @@
+import { execute as textureManagerBind0UseCase } from "../../../TextureManager/usecase/TextureManagerBind0UseCase";
+import { execute as variantsBlurFilterShaderService } from "../../../Shader/Variants/Filter/service/VariantsBlurFilterShaderService";
+import { execute as shaderManagerSetBlurFilterUniformService } from "../../../Shader/ShaderManager/service/ShaderManagerSetBlurFilterUniformService";
+import { execute as shaderManagerDrawTextureUseCase } from "../../../Shader/ShaderManager/usecase/ShaderManagerDrawTextureUseCase";
+/**
+ * @description 指定方向にぼかしフィルターを適用します。
+ *              Apply the blur filter in the specified direction.
+ *
+ * @param  {ITextureObject} texture_object
+ * @param  {boolean} is_horizontal
+ * @param  {number} blur
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (texture_object, is_horizontal, blur) => {
+    textureManagerBind0UseCase(texture_object, true);
+    const halfBlur = Math.ceil(blur * 0.5);
+    const fraction = 1 - (halfBlur - blur * 0.5);
+    const samples = 1 + blur;
+    const shaderManager = variantsBlurFilterShaderService(halfBlur);
+    shaderManagerSetBlurFilterUniformService(shaderManager, texture_object.width, texture_object.height, is_horizontal, fraction, samples);
+    shaderManagerDrawTextureUseCase(shaderManager);
+};

package/src/Filter/ColorMatrixFilter/usecase/FilterApplyColorMatrixFilterUseCase.d.ts

@@ -0,0 +1,12 @@
+import type { ITextureObject } from "../../../interface/ITextureObject";
+/**
+ * @description カラーマトリックスフィルターを適用します。
+ *              Apply the color matrix filter.
+ *
+ * @param  {ITextureObject} texture_object
+ * @param  {Float32Array} matrix
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (texture_object: ITextureObject, matrix: Float32Array) => ITextureObject;

package/src/Filter/ColorMatrixFilter/usecase/FilterApplyColorMatrixFilterUseCase.js

@@ -0,0 +1,38 @@
+import { $context } from "../../../WebGLUtil";
+import { execute as frameBufferManagerGetAttachmentObjectUseCase } from "../../../FrameBufferManager/usecase/FrameBufferManagerGetAttachmentObjectUseCase";
+import { execute as textureManagerBind0UseCase } from "../../../TextureManager/usecase/TextureManagerBind0UseCase";
+import { execute as frameBufferManagerReleaseAttachmentObjectUseCase } from "../../../FrameBufferManager/usecase/FrameBufferManagerReleaseAttachmentObjectUseCase";
+import { execute as textureManagerReleaseTextureObjectUseCase } from "../../../TextureManager/usecase/TextureManagerReleaseTextureObjectUseCase";
+import { execute as variantsColorMatrixFilterShaderService } from "../../../Shader/Variants/Filter/service/VariantsColorMatrixFilterShaderService";
+import { execute as shaderManagerSetColorMatrixFilterUniformService } from "../../../Shader/ShaderManager/service/ShaderManagerSetColorMatrixFilterUniformService";
+import { execute as shaderManagerDrawTextureUseCase } from "../../../Shader/ShaderManager/usecase/ShaderManagerDrawTextureUseCase";
+import { execute as blendResetService } from "../../../Blend/service/BlendResetService";
+/**
+ * @description カラーマトリックスフィルターを適用します。
+ *              Apply the color matrix filter.
+ *
+ * @param  {ITextureObject} texture_object
+ * @param  {Float32Array} matrix
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export const execute = (texture_object, matrix) => {
+    const currentAttachmentObject = $context.currentAttachmentObject;
+    const attachmentObject = frameBufferManagerGetAttachmentObjectUseCase(texture_object.width, texture_object.height, false);
+    $context.bind(attachmentObject);
+    $context.reset();
+    $context.setTransform(1, 0, 0, 1, 0, 0);
+    textureManagerBind0UseCase(texture_object);
+    blendResetService();
+    const shaderManager = variantsColorMatrixFilterShaderService();
+    shaderManagerSetColorMatrixFilterUniformService(shaderManager, matrix);
+    shaderManagerDrawTextureUseCase(shaderManager);
+    const textureObject = attachmentObject.texture;
+    textureManagerReleaseTextureObjectUseCase(texture_object);
+    frameBufferManagerReleaseAttachmentObjectUseCase(attachmentObject, false);
+    if (currentAttachmentObject) {
+        $context.bind(currentAttachmentObject);
+    }
+    return textureObject;
+};

package/src/Filter/ConvolutionFilter/usecase/FilterApplyConvolutionFilterUseCase.d.ts

@@ -0,0 +1,20 @@
+import type { ITextureObject } from "../../../interface/ITextureObject";
+/**
+ * @description コンボリューション・フィルタを適用する
+ *              Apply convolution filter
+ *
+ * @param  {ITextureObject} texture_object
+ * @param  {number} matrix_x
+ * @param  {number} matrix_y
+ * @param  {Float32Array} matrix
+ * @param  {number} divisor
+ * @param  {number} bias
+ * @param  {boolean} preserve_alpha
+ * @param  {boolean} clamp
+ * @param  {number} color
+ * @param  {number} alpha
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (texture_object: ITextureObject, matrix_x: number | undefined, matrix_y: number | undefined, matrix: Float32Array, divisor?: number, bias?: number, preserve_alpha?: boolean, clamp?: boolean, color?: number, alpha?: number) => ITextureObject;

package/src/Filter/ConvolutionFilter/usecase/FilterApplyConvolutionFilterUseCase.js

@@ -0,0 +1,49 @@
+import { execute as frameBufferManagerGetAttachmentObjectUseCase } from "../../../FrameBufferManager/usecase/FrameBufferManagerGetAttachmentObjectUseCase";
+import { execute as textureManagerBind0UseCase } from "../../../TextureManager/usecase/TextureManagerBind0UseCase";
+import { execute as frameBufferManagerReleaseAttachmentObjectUseCase } from "../../../FrameBufferManager/usecase/FrameBufferManagerReleaseAttachmentObjectUseCase";
+import { execute as textureManagerReleaseTextureObjectUseCase } from "../../../TextureManager/usecase/TextureManagerReleaseTextureObjectUseCase";
+import { execute as variantsConvolutionFilterShaderService } from "../../../Shader/Variants/Filter/service/VariantsConvolutionFilterShaderService";
+import { execute as shaderManagerSetConvolutionFilterUniformService } from "../../../Shader/ShaderManager/service/ShaderManagerSetConvolutionFilterUniformService";
+import { execute as shaderManagerDrawTextureUseCase } from "../../../Shader/ShaderManager/usecase/ShaderManagerDrawTextureUseCase";
+import { execute as blendResetService } from "../../../Blend/service/BlendResetService";
+import { $context } from "../../../WebGLUtil";
+import { $intToR, $intToG, $intToB } from "../../../Filter";
+/**
+ * @description コンボリューション・フィルタを適用する
+ *              Apply convolution filter
+ *
+ * @param  {ITextureObject} texture_object
+ * @param  {number} matrix_x
+ * @param  {number} matrix_y
+ * @param  {Float32Array} matrix
+ * @param  {number} divisor
+ * @param  {number} bias
+ * @param  {boolean} preserve_alpha
+ * @param  {boolean} clamp
+ * @param  {number} color
+ * @param  {number} alpha
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export const execute = (texture_object, matrix_x = 0, matrix_y = 0, matrix, divisor = 1, bias = 0, preserve_alpha = true, clamp = true, color = 0, alpha = 0) => {
+    const currentAttachmentObject = $context.currentAttachmentObject;
+    const width = texture_object.width;
+    const height = texture_object.height;
+    const attachmentObject = frameBufferManagerGetAttachmentObjectUseCase(width, height, false);
+    $context.bind(attachmentObject);
+    $context.reset();
+    $context.setTransform(1, 0, 0, 1, 0, 0);
+    textureManagerBind0UseCase(texture_object, true);
+    blendResetService();
+    const shaderManager = variantsConvolutionFilterShaderService(matrix_x, matrix_y, preserve_alpha, clamp);
+    shaderManagerSetConvolutionFilterUniformService(shaderManager, width, height, matrix, divisor, bias, clamp, $intToR(color, alpha, false), $intToG(color, alpha, false), $intToB(color, alpha, false), alpha);
+    shaderManagerDrawTextureUseCase(shaderManager);
+    const textureObject = attachmentObject.texture;
+    textureManagerReleaseTextureObjectUseCase(texture_object);
+    frameBufferManagerReleaseAttachmentObjectUseCase(attachmentObject, false);
+    if (currentAttachmentObject) {
+        $context.bind(currentAttachmentObject);
+    }
+    return textureObject;
+};

package/src/Filter/DisplacementMapFilter/usecase/FilterApplyDisplacementMapFilterUseCase.d.ts

@@ -0,0 +1,24 @@
+import type { ITextureObject } from "../../../interface/ITextureObject";
+/**
+ * @description ディスプレイスメントマップ・フィルタを適用する
+ *              Apply displacement map filter
+ *
+ * @param  {ITextureObject} texture_object
+ * @param  {Float32Array} matrix
+ * @param  {Uint8Array} bitmap_buffer
+ * @param  {number} bitmap_width
+ * @param  {number} bitmap_height
+ * @param  {number} map_point_x
+ * @param  {number} map_point_y
+ * @param  {number} component_x
+ * @param  {number} component_y
+ * @param  {number} scale_x
+ * @param  {number} scale_y
+ * @param  {number} mode
+ * @param  {number} color
+ * @param  {number} alpha
+ * @return {ITextureObject}
+ * @method
+ * @protected
+ */
+export declare const execute: (texture_object: ITextureObject, matrix: Float32Array, bitmap_buffer: Uint8Array, bitmap_width?: number, bitmap_height?: number, map_point_x?: number, map_point_y?: number, component_x?: number, component_y?: number, scale_x?: number, scale_y?: number, mode?: number, color?: number, alpha?: number) => ITextureObject;