@next2d/webgl 1.18.12 → 3.0.0

package/src/Context/usecase/ContextContainerEndLayerUseCase.js

@@ -0,0 +1,171 @@
+import { $containerLayerStack } from "./ContextContainerBeginLayerUseCase";
+import { execute as frameBufferManagerGetTextureFromBoundsUseCase } from "../../FrameBufferManager/usecase/FrameBufferManagerGetTextureFromBoundsUseCase";
+import { execute as frameBufferManagerReleaseAttachmentObjectUseCase } from "../../FrameBufferManager/usecase/FrameBufferManagerReleaseAttachmentObjectUseCase";
+import { execute as blendDrawFilterToMainUseCase } from "../../Blend/usecase/BlendDrawFilterToMainUseCase";
+import { execute as textureManagerReleaseTextureObjectUseCase } from "../../TextureManager/usecase/TextureManagerReleaseTextureObjectUseCase";
+import { execute as filterApplyBlurFilterUseCase } from "../../Filter/BlurFilter/usecase/FilterApplyBlurFilterUseCase";
+import { execute as filterApplyBevelFilterUseCase } from "../../Filter/BevelFilter/usecase/FilterApplyBevelFilterUseCase";
+import { execute as filterApplyColorMatrixFilterUseCase } from "../../Filter/ColorMatrixFilter/usecase/FilterApplyColorMatrixFilterUseCase";
+import { execute as filterApplyConvolutionFilterUseCase } from "../../Filter/ConvolutionFilter/usecase/FilterApplyConvolutionFilterUseCase";
+import { execute as filterApplyDisplacementMapFilterUseCase } from "../../Filter/DisplacementMapFilter/usecase/FilterApplyDisplacementMapFilterUseCase";
+import { execute as filterApplyDropShadowFilterUseCase } from "../../Filter/DropShadowFilter/usecase/FilterApplyDropShadowFilterUseCase";
+import { execute as filterApplyGlowFilterUseCase } from "../../Filter/GlowFilter/usecase/FilterApplyGlowFilterUseCase";
+import { execute as filterApplyGradientBevelFilterUseCase } from "../../Filter/GradientBevelFilter/usecase/FilterApplyGradientBevelFilterUseCase";
+import { execute as filterApplyGradientGlowFilterUseCase } from "../../Filter/GradientGlowFilter/usecase/FilterApplyGradientGlowFilterUseCase";
+import { $offset } from "../../Filter";
+import { $cacheStore } from "@next2d/cache";
+import { $context, $devicePixelRatio } from "../../WebGLUtil";
+/**
+ * @description ColorMatrixFilter用の再利用可能なバッファ
+ *              Reusable buffer for ColorMatrixFilter
+ *
+ * @type {Float32Array}
+ * @private
+ */
+const $colorMatrixBuffer = new Float32Array(20);
+/**
+ * @description コンテナのフィルター/ブレンド用レイヤーを終了し、結果を元のメインに合成します。
+ *              End the container layer and composite the result back to the original main.
+ *
+ * @param  {IBlendMode} blend_mode
+ * @param  {Float32Array} matrix
+ * @param  {Float32Array | null} color_transform
+ * @param  {boolean} use_filter
+ * @param  {Float32Array | null} filter_bounds
+ * @param  {Float32Array | null} filter_params
+ * @param  {string} unique_key
+ * @param  {string} filter_key
+ * @return {void}
+ * @method
+ * @public
+ */
+export const execute = (blend_mode, matrix, color_transform, use_filter, filter_bounds, filter_params, unique_key, filter_key) => {
+    // 一時アタッチメントへの描画をフラッシュ
+    $context.drawArraysInstanced();
+    const layerAttachment = $context.$mainAttachmentObject;
+    let textureObject = null;
+    if (use_filter && filter_bounds && filter_params) {
+        // containerEndLayerが呼ばれる＝ディスプレイレイヤーがコンテンツ変更を検出して再レンダリングを要求
+        // 常に新鮮なテクスチャを抽出してフィルターを適用する
+        // （キャッシュはディスプレイレイヤーのcontainerDrawCachedFilterで管理）
+        // レイヤーが有効な間にテクスチャを切り出し（リリース前に実行）
+        textureObject = frameBufferManagerGetTextureFromBoundsUseCase(0, 0, layerAttachment.width, layerAttachment.height);
+        // mainを復元
+        $context.$mainAttachmentObject = $containerLayerStack.pop();
+        // 一時アタッチメントを解放
+        frameBufferManagerReleaseAttachmentObjectUseCase(layerAttachment);
+        // メインのアタッチメントをバインド（currentAttachmentObjectを更新）
+        $context.bind($context.$mainAttachmentObject);
+        // フィルターチェーンを適用
+        $offset.x = 0;
+        $offset.y = 0;
+        for (let idx = 0; filter_params.length > idx;) {
+            const type = filter_params[idx++];
+            switch (type) {
+                case 0: // BevelFilter
+                    textureObject = filterApplyBevelFilterUseCase(textureObject, matrix, filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], Boolean(filter_params[idx++]));
+                    break;
+                case 1: // BlurFilter
+                    textureObject = filterApplyBlurFilterUseCase(textureObject, matrix, filter_params[idx++], filter_params[idx++], filter_params[idx++]);
+                    break;
+                case 2: // ColorMatrixFilter
+                    for (let i = 0; i < 20; ++i) {
+                        $colorMatrixBuffer[i] = filter_params[idx++];
+                    }
+                    textureObject = filterApplyColorMatrixFilterUseCase(textureObject, $colorMatrixBuffer);
+                    break;
+                case 3: // ConvolutionFilter
+                    {
+                        const matrixX = filter_params[idx++];
+                        const matrixY = filter_params[idx++];
+                        const length = matrixX * matrixY;
+                        const convMatrix = filter_params.subarray(idx, idx + length);
+                        idx += length;
+                        textureObject = filterApplyConvolutionFilterUseCase(textureObject, matrixX, matrixY, convMatrix, filter_params[idx++], filter_params[idx++], Boolean(filter_params[idx++]), Boolean(filter_params[idx++]), filter_params[idx++], filter_params[idx++]);
+                    }
+                    break;
+                case 4: // DisplacementMapFilter
+                    {
+                        const length = filter_params[idx++];
+                        const buffer = new Uint8Array(length);
+                        buffer.set(filter_params.subarray(idx, idx + length));
+                        idx += length;
+                        textureObject = filterApplyDisplacementMapFilterUseCase(textureObject, buffer, filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++]);
+                    }
+                    break;
+                case 5: // DropShadowFilter
+                    textureObject = filterApplyDropShadowFilterUseCase(textureObject, matrix, filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], Boolean(filter_params[idx++]), Boolean(filter_params[idx++]), Boolean(filter_params[idx++]));
+                    break;
+                case 6: // GlowFilter
+                    textureObject = filterApplyGlowFilterUseCase(textureObject, matrix, filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], Boolean(filter_params[idx++]), Boolean(filter_params[idx++]));
+                    break;
+                case 7: // GradientBevelFilter
+                    {
+                        const distance = filter_params[idx++];
+                        const angle = filter_params[idx++];
+                        let length = filter_params[idx++];
+                        const colors = filter_params.subarray(idx, idx + length);
+                        idx += length;
+                        length = filter_params[idx++];
+                        const alphas = filter_params.subarray(idx, idx + length);
+                        idx += length;
+                        length = filter_params[idx++];
+                        const ratios = filter_params.subarray(idx, idx + length);
+                        idx += length;
+                        textureObject = filterApplyGradientBevelFilterUseCase(textureObject, matrix, distance, angle, colors, alphas, ratios, filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], Boolean(filter_params[idx++]));
+                    }
+                    break;
+                case 8: // GradientGlowFilter
+                    {
+                        const distance = filter_params[idx++];
+                        const angle = filter_params[idx++];
+                        let length = filter_params[idx++];
+                        const colors = filter_params.subarray(idx, idx + length);
+                        idx += length;
+                        length = filter_params[idx++];
+                        const alphas = filter_params.subarray(idx, idx + length);
+                        idx += length;
+                        length = filter_params[idx++];
+                        const ratios = filter_params.subarray(idx, idx + length);
+                        idx += length;
+                        textureObject = filterApplyGradientGlowFilterUseCase(textureObject, matrix, distance, angle, colors, alphas, ratios, filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], filter_params[idx++], Boolean(filter_params[idx++]));
+                    }
+                    break;
+            }
+        }
+        // キャッシュに保存
+        if (unique_key) {
+            $cacheStore.set(unique_key, "fKey", filter_key);
+            $cacheStore.set(unique_key, "fTexture", textureObject);
+        }
+        // フィルター結果をメインに描画
+        if (textureObject) {
+            const scaleX = Math.sqrt(matrix[0] * matrix[0] + matrix[1] * matrix[1]);
+            const scaleY = Math.sqrt(matrix[2] * matrix[2] + matrix[3] * matrix[3]);
+            const devicePixelRatio = $devicePixelRatio;
+            const boundsXMin = filter_bounds[0] * (scaleX / devicePixelRatio);
+            const boundsYMin = filter_bounds[1] * (scaleY / devicePixelRatio);
+            $context.reset();
+            $context.globalCompositeOperation = blend_mode;
+            blendDrawFilterToMainUseCase(textureObject, color_transform, boundsXMin + matrix[4], boundsYMin + matrix[5]);
+        }
+    }
+    else {
+        // ブレンドのみの場合：テクスチャを取得
+        textureObject = frameBufferManagerGetTextureFromBoundsUseCase(0, 0, layerAttachment.width, layerAttachment.height);
+        // mainを復元
+        $context.$mainAttachmentObject = $containerLayerStack.pop();
+        // 一時アタッチメントを解放
+        frameBufferManagerReleaseAttachmentObjectUseCase(layerAttachment);
+        // メインのアタッチメントをバインド（currentAttachmentObjectを更新）
+        $context.bind($context.$mainAttachmentObject);
+        if (textureObject) {
+            $context.reset();
+            $context.globalCompositeOperation = blend_mode;
+            blendDrawFilterToMainUseCase(textureObject, color_transform, matrix[4], matrix[5]);
+            textureManagerReleaseTextureObjectUseCase(textureObject);
+        }
+    }
+    // メインのアタッチメントをバインド
+    $context.bind($context.$mainAttachmentObject);
+};

package/src/Context/usecase/ContextDrawElementUseCase.d.ts

@@ -0,0 +1,12 @@
+import type { Node } from "@next2d/texture-packer";
+/**
+ * @description OffscreenCanvasを描画します。
+ *              Draw OffscreenCanvas.
+ *
+ * @param  {Node} node
+ * @param  {OffscreenCanvas | ImageBitmap} element
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (node: Node, element: OffscreenCanvas | ImageBitmap) => void;

package/src/Context/usecase/ContextDrawElementUseCase.js

@@ -0,0 +1,26 @@
+import { execute as textureManagerCreateFromCanvasUseCase } from "../../TextureManager/usecase/TextureManagerCreateFromCanvasUseCase";
+import { execute as textureManagerReleaseTextureObjectUseCase } from "../../TextureManager/usecase/TextureManagerReleaseTextureObjectUseCase";
+import { execute as variantsBlendTextureShaderService } from "../../Shader/Variants/Blend/service/VariantsBlendTextureShaderService";
+import { execute as shaderManagerSetTextureUniformService } from "../../Shader/ShaderManager/service/ShaderManagerSetTextureUniformService";
+import { execute as shaderManagerDrawTextureUseCase } from "../../Shader/ShaderManager/usecase/ShaderManagerDrawTextureUseCase";
+import { execute as blendResetService } from "../../Blend/service/BlendResetService";
+/**
+ * @description OffscreenCanvasを描画します。
+ *              Draw OffscreenCanvas.
+ *
+ * @param  {Node} node
+ * @param  {OffscreenCanvas | ImageBitmap} element
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (node, element) => {
+    const textureObject = textureManagerCreateFromCanvasUseCase(node.w, node.h, element);
+    const shaderManager = variantsBlendTextureShaderService();
+    shaderManagerSetTextureUniformService(shaderManager, node.w, node.h);
+    // テクスチャを描画
+    blendResetService();
+    shaderManagerDrawTextureUseCase(shaderManager);
+    // テクスチャオブジェクトを解放
+    textureManagerReleaseTextureObjectUseCase(textureObject);
+};

package/src/Context/usecase/ContextDrawFillUseCase.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @description Contextのパスコマンドの塗り実行します。
+ *              Execute Context path command painting.
+ *
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: () => void;

package/src/Context/usecase/ContextDrawFillUseCase.js

@@ -0,0 +1,73 @@
+import { execute as vertexArrayObjectBindFillMeshUseCase } from "../../VertexArrayObject/usecase/VertexArrayObjectBindFillMeshUseCase";
+import { execute as vertexArrayObjectReleaseVertexArrayObjectService } from "../../VertexArrayObject/service/VertexArrayObjectReleaseVertexArrayObjectService";
+import { execute as contextNormalFillUseCase } from "./ContextNormalFillUseCase";
+import { execute as contextLinearGradientFillUseCase } from "./ContextLinearGradientFillUseCase";
+import { execute as contextRadialGradientFillUseCase } from "./ContextRadialGradientFillUseCase";
+import { execute as contextPatternBitmapFillUseCase } from "./ContextPatternBitmapFillUseCase";
+import { execute as stencilResetService } from "../../Stencil/service/StencilResetService";
+import { $gl, $enableStencilTest, $disableStencilTest } from "../../WebGLUtil";
+import { $terminateGrid, $gridDataMap } from "../../Grid";
+import { $fillBufferIndexes, $fillTypes, $clearFillBufferSetting } from "../../Mesh";
+/**
+ * @description Contextのパスコマンドの塗り実行します。
+ *              Execute Context path command painting.
+ *
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = () => {
+    const fillVertexArrayObject = vertexArrayObjectBindFillMeshUseCase();
+    // mask on（frontFaceはContext初期化時にCCW固定）
+    $enableStencilTest();
+    $gl.stencilMask(0xff);
+    // Reset stencil cache at the start of fill processing
+    stencilResetService();
+    let fillOffset = 0;
+    let gridData = null;
+    for (let idx = 0; idx < $fillTypes.length; idx++) {
+        if ($gridDataMap.has(idx)) {
+            gridData = $gridDataMap.get(idx);
+        }
+        const type = $fillTypes[idx];
+        switch (type) {
+            case "fill": // 通常のShapeの塗り
+                {
+                    const count = $fillBufferIndexes.shift();
+                    contextNormalFillUseCase(fillVertexArrayObject, fillOffset, count, gridData);
+                    fillOffset += count;
+                }
+                break;
+            case "linear": // 線形グラデーションの塗り
+                {
+                    const count = $fillBufferIndexes.shift();
+                    contextLinearGradientFillUseCase(fillVertexArrayObject, fillOffset, count, gridData);
+                    fillOffset += count;
+                }
+                break;
+            case "radial": // 円形グラデーションの塗り
+                {
+                    const count = $fillBufferIndexes.shift();
+                    contextRadialGradientFillUseCase(fillVertexArrayObject, fillOffset, count, gridData);
+                    fillOffset += count;
+                }
+                break;
+            case "bitmap": // 画像の塗りつぶし
+                {
+                    const count = $fillBufferIndexes.shift();
+                    contextPatternBitmapFillUseCase(fillVertexArrayObject, fillOffset, count, gridData);
+                    fillOffset += count;
+                }
+                break;
+        }
+    }
+    // mask off
+    $disableStencilTest();
+    // Reset stencil cache after disabling stencil test
+    stencilResetService();
+    // release vertex array
+    vertexArrayObjectReleaseVertexArrayObjectService(fillVertexArrayObject);
+    // 設定値を初期化
+    $clearFillBufferSetting();
+    $terminateGrid();
+};

package/src/Context/usecase/ContextDrawPixelsUseCase.d.ts

@@ -0,0 +1,12 @@
+import type { Node } from "@next2d/texture-packer";
+/**
+ * @description ピクセルを描画します。
+ *              Draw pixels.
+ *
+ * @param  {Node} node
+ * @param  {Uint8Array} pixels
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (node: Node, pixels: Uint8Array) => void;

package/src/Context/usecase/ContextDrawPixelsUseCase.js

@@ -0,0 +1,26 @@
+import { execute as textureManagerCreateFromPixelsUseCase } from "../../TextureManager/usecase/TextureManagerCreateFromPixelsUseCase";
+import { execute as textureManagerReleaseTextureObjectUseCase } from "../../TextureManager/usecase/TextureManagerReleaseTextureObjectUseCase";
+import { execute as variantsBlendTextureShaderService } from "../../Shader/Variants/Blend/service/VariantsBlendTextureShaderService";
+import { execute as shaderManagerSetTextureUniformService } from "../../Shader/ShaderManager/service/ShaderManagerSetTextureUniformService";
+import { execute as shaderManagerDrawTextureUseCase } from "../../Shader/ShaderManager/usecase/ShaderManagerDrawTextureUseCase";
+import { execute as blendResetService } from "../../Blend/service/BlendResetService";
+/**
+ * @description ピクセルを描画します。
+ *              Draw pixels.
+ *
+ * @param  {Node} node
+ * @param  {Uint8Array} pixels
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (node, pixels) => {
+    const textureObject = textureManagerCreateFromPixelsUseCase(node.w, node.h, pixels);
+    const shaderManager = variantsBlendTextureShaderService();
+    shaderManagerSetTextureUniformService(shaderManager, node.w, node.h);
+    // テクスチャを描画
+    blendResetService();
+    shaderManagerDrawTextureUseCase(shaderManager);
+    // テクスチャオブジェクトを解放
+    textureManagerReleaseTextureObjectUseCase(textureObject);
+};

package/src/Context/usecase/ContextFillUseCase.d.ts

@@ -0,0 +1,10 @@
+import type { IFillType } from "../../interface/IFillType";
+/**
+ * @description Contextのパスコマンドの塗り実行します。
+ *              Execute Context path command painting.
+ *
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (type: IFillType) => void;

package/src/Context/usecase/ContextFillUseCase.js

@@ -0,0 +1,23 @@
+import { $getVertices } from "../../PathCommand";
+import { execute as meshFillGenerateUseCase } from "../../Mesh/usecase/MeshFillGenerateUseCase";
+import { $addFillBuffer, $fillTypes, $fillBufferIndexes } from "../../Mesh";
+/**
+ * @description Contextのパスコマンドの塗り実行します。
+ *              Execute Context path command painting.
+ *
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (type) => {
+    const vertices = $getVertices();
+    if (!vertices.length) {
+        return;
+    }
+    // 塗りの種類を追加
+    $fillTypes.push(type);
+    const mesh = meshFillGenerateUseCase(vertices);
+    $addFillBuffer(mesh.buffer);
+    // 塗りのインデックスを追加
+    $fillBufferIndexes.push(mesh.indexCount);
+};

package/src/Context/usecase/ContextGradientFillUseCase.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @description グラデーション塗りを描画
+ *              Draw a gradient fill
+ *
+ * @param  {number} type
+ * @param  {array} stops
+ * @param  {Float32Array} matrix
+ * @param  {number} spread
+ * @param  {number} interpolation
+ * @param  {number} focal
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (type: number, stops: number[], matrix: Float32Array, spread: number, interpolation: number, focal: number) => void;

package/src/Context/usecase/ContextGradientFillUseCase.js

@@ -0,0 +1,34 @@
+import { $getVertices } from "../../PathCommand";
+import { execute as meshFillGenerateUseCase } from "../../Mesh/usecase/MeshFillGenerateUseCase";
+import { $gradientData } from "../../Gradient";
+import { $addFillBuffer, $fillTypes, $fillBufferIndexes } from "../../Mesh";
+/**
+ * @description グラデーション塗りを描画
+ *              Draw a gradient fill
+ *
+ * @param  {number} type
+ * @param  {array} stops
+ * @param  {Float32Array} matrix
+ * @param  {number} spread
+ * @param  {number} interpolation
+ * @param  {number} focal
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (type, stops, matrix, spread, interpolation, focal) => {
+    const vertices = $getVertices();
+    if (!vertices.length) {
+        return;
+    }
+    // 塗りの種類を追加
+    $fillTypes.push(type === 0 ? "linear" : "radial");
+    const fillMesh = meshFillGenerateUseCase(vertices);
+    $addFillBuffer(fillMesh.buffer);
+    // 塗りのインデックスを追加
+    $fillBufferIndexes.push(fillMesh.indexCount);
+    $gradientData.push(stops, matrix, spread, interpolation);
+    if (type === 1) {
+        $gradientData.push(focal);
+    }
+};

package/src/Context/usecase/ContextGradientStrokeUseCase.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @description 線のグラデーションを実行
+ *              Execute gradient of line
+ *
+ * @param  {number} type
+ * @param  {array} stops
+ * @param  {Float32Array} matrix
+ * @param  {number} spread
+ * @param  {number} interpolation
+ * @param  {number} focal
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (type: number, stops: number[], matrix: Float32Array, spread: number, interpolation: number, focal: number) => void;

package/src/Context/usecase/ContextGradientStrokeUseCase.js

@@ -0,0 +1,34 @@
+import { $getVertices } from "../../PathCommand";
+import { execute as meshStrokeGenerateUseCase } from "../../Mesh/usecase/MeshStrokeGenerateUseCase";
+import { $gradientData } from "../../Gradient";
+import { $addFillBuffer, $fillTypes, $fillBufferIndexes } from "../../Mesh";
+/**
+ * @description 線のグラデーションを実行
+ *              Execute gradient of line
+ *
+ * @param  {number} type
+ * @param  {array} stops
+ * @param  {Float32Array} matrix
+ * @param  {number} spread
+ * @param  {number} interpolation
+ * @param  {number} focal
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (type, stops, matrix, spread, interpolation, focal) => {
+    const vertices = $getVertices(true);
+    if (!vertices.length) {
+        return;
+    }
+    // 塗りの種類を追加
+    $fillTypes.push(type === 0 ? "linear" : "radial");
+    const mesh = meshStrokeGenerateUseCase(vertices);
+    $addFillBuffer(mesh.buffer);
+    // 塗りのインデックスを追加
+    $fillBufferIndexes.push(mesh.indexCount);
+    $gradientData.push(stops, matrix, spread, interpolation);
+    if (type === 1) {
+        $gradientData.push(focal);
+    }
+};

package/src/Context/usecase/ContextLinearGradientFillUseCase.d.ts

@@ -0,0 +1,14 @@
+import type { IVertexArrayObject } from "../../interface/IVertexArrayObject";
+/**
+ * @description 線形グラデーションのシェーダーを実行します。
+ *              Execute the linear gradient shader.
+ *
+ * @param  {IVertexArrayObject} vertex_array_object
+ * @param  {number} offset
+ * @param  {number} index_count
+ * @param  {Float32Array | null} [grid_data=null]
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (vertex_array_object: IVertexArrayObject, offset: number, index_count: number, grid_data: Float32Array | null) => void;

package/src/Context/usecase/ContextLinearGradientFillUseCase.js

@@ -0,0 +1,58 @@
+import { execute as gradientLUTGenerateShapeTextureUseCase } from "../../Shader/GradientLUTGenerator/usecase/GradientLUTGenerateShapeTextureUseCase";
+import { execute as textureManagerBind0UseCase } from "../../TextureManager/usecase/TextureManagerBind0UseCase";
+import { execute as variantsShapeMaskShaderService } from "../../Shader/Variants/Shape/service/VariantsShapeMaskShaderService";
+import { execute as shaderManagerSetMaskUniformService } from "../../Shader/ShaderManager/service/ShaderManagerSetMaskUniformService";
+import { execute as shaderManagerFillUseCase } from "../../Shader/ShaderManager/usecase/ShaderManagerFillUseCase";
+import { execute as variantsGradientShapeShaderUseCase } from "../../Shader/Variants/Gradient/usecase/VariantsGradientShapeShaderUseCase";
+import { execute as shaderManagerSetGradientFillUniformService } from "../../Shader/ShaderManager/service/ShaderManagerSetGradientFillUniformService";
+import { execute as stencilSetMaskModeService } from "../../Stencil/service/StencilSetMaskModeService";
+import { execute as stencilSetFillModeService } from "../../Stencil/service/StencilSetFillModeService";
+import { execute as stencilEnableSampleAlphaToCoverageService } from "../../Stencil/service/StencilEnableSampleAlphaToCoverageService";
+import { execute as stencilDisableSampleAlphaToCoverageService } from "../../Stencil/service/StencilDisableSampleAlphaToCoverageService";
+import { execute as stencilResetService } from "../../Stencil/service/StencilResetService";
+import { $gradientData } from "../../Gradient";
+import { $gl, $linearGradientXY, $inverseMatrix, $context, $poolFloat32Array6, $poolFloat32Array4, $enableStencilTest, $disableStencilTest } from "../../WebGLUtil";
+/**
+ * @description 線形グラデーションのシェーダーを実行します。
+ *              Execute the linear gradient shader.
+ *
+ * @param  {IVertexArrayObject} vertex_array_object
+ * @param  {number} offset
+ * @param  {number} index_count
+ * @param  {Float32Array | null} [grid_data=null]
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (vertex_array_object, offset, index_count, grid_data) => {
+    const stops = $gradientData.shift();
+    const matrix = $gradientData.shift();
+    const spread = $gradientData.shift();
+    const interpolation = $gradientData.shift();
+    // Reset stencil cache before disabling stencil test
+    stencilResetService();
+    $disableStencilTest();
+    const textureObject = gradientLUTGenerateShapeTextureUseCase(stops, interpolation);
+    textureManagerBind0UseCase(textureObject);
+    $enableStencilTest();
+    $gl.stencilMask(0xff);
+    // mask setting (cached)
+    stencilSetMaskModeService();
+    const useGrid = !!grid_data;
+    const coverageShader = variantsShapeMaskShaderService(useGrid);
+    if (grid_data) {
+        shaderManagerSetMaskUniformService(coverageShader, grid_data);
+    }
+    stencilEnableSampleAlphaToCoverageService();
+    shaderManagerFillUseCase(coverageShader, vertex_array_object, offset, index_count);
+    stencilDisableSampleAlphaToCoverageService();
+    // draw shape setting (cached)
+    stencilSetFillModeService();
+    const shaderManager = variantsGradientShapeShaderUseCase(false, false, spread, useGrid);
+    const points = $linearGradientXY(matrix);
+    const inverseMatrix = $inverseMatrix($context.$matrix);
+    shaderManagerSetGradientFillUniformService(shaderManager, 0, $context.$matrix, inverseMatrix, 0, points, grid_data);
+    $poolFloat32Array4(points);
+    $poolFloat32Array6(inverseMatrix);
+    shaderManagerFillUseCase(shaderManager, vertex_array_object, offset, index_count);
+};

package/src/Context/usecase/ContextNormalFillUseCase.d.ts

@@ -0,0 +1,14 @@
+import type { IVertexArrayObject } from "../../interface/IVertexArrayObject";
+/**
+ * @description 塗りのシェーダーを実行します。
+ *              Execute the fill shader.
+ *
+ * @param  {IVertexArrayObject} vertex_array_object
+ * @param  {number} offset
+ * @param  {number} index_count
+ * @param  {Float32Array | null} [grid_data=null]
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (vertex_array_object: IVertexArrayObject, offset: number, index_count: number, grid_data: Float32Array | null) => void;

package/src/Context/usecase/ContextNormalFillUseCase.js

@@ -0,0 +1,40 @@
+import { execute as variantsShapeMaskShaderService } from "../../Shader/Variants/Shape/service/VariantsShapeMaskShaderService";
+import { execute as shaderManagerSetMaskUniformService } from "../../Shader/ShaderManager/service/ShaderManagerSetMaskUniformService";
+import { execute as shaderManagerFillUseCase } from "../../Shader/ShaderManager/usecase/ShaderManagerFillUseCase";
+import { execute as variantsShapeSolidColorShaderService } from "../../Shader/Variants/Shape/service/VariantsShapeSolidColorShaderService";
+import { execute as shaderManagerSetFillUniformService } from "../../Shader/ShaderManager/service/ShaderManagerSetFillUniformService";
+import { execute as stencilSetMaskModeService } from "../../Stencil/service/StencilSetMaskModeService";
+import { execute as stencilSetFillModeService } from "../../Stencil/service/StencilSetFillModeService";
+import { execute as stencilEnableSampleAlphaToCoverageService } from "../../Stencil/service/StencilEnableSampleAlphaToCoverageService";
+import { execute as stencilDisableSampleAlphaToCoverageService } from "../../Stencil/service/StencilDisableSampleAlphaToCoverageService";
+/**
+ * @description 塗りのシェーダーを実行します。
+ *              Execute the fill shader.
+ *
+ * @param  {IVertexArrayObject} vertex_array_object
+ * @param  {number} offset
+ * @param  {number} index_count
+ * @param  {Float32Array | null} [grid_data=null]
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (vertex_array_object, offset, index_count, grid_data) => {
+    // mask setting (cached)
+    stencilSetMaskModeService();
+    const useGrid = !!grid_data;
+    const coverageShader = variantsShapeMaskShaderService(useGrid);
+    if (grid_data) {
+        shaderManagerSetMaskUniformService(coverageShader, grid_data);
+    }
+    stencilEnableSampleAlphaToCoverageService();
+    shaderManagerFillUseCase(coverageShader, vertex_array_object, offset, index_count);
+    stencilDisableSampleAlphaToCoverageService();
+    // draw shape setting (cached)
+    stencilSetFillModeService();
+    const shaderManager = variantsShapeSolidColorShaderService(useGrid);
+    if (grid_data) {
+        shaderManagerSetFillUniformService(shaderManager, grid_data);
+    }
+    shaderManagerFillUseCase(shaderManager, vertex_array_object, offset, index_count);
+};

package/src/Context/usecase/ContextPatternBitmapFillUseCase.d.ts

@@ -0,0 +1,14 @@
+import type { IVertexArrayObject } from "../../interface/IVertexArrayObject";
+/**
+ * @description ビットマップパターンのシェーダーを実行します。
+ *              Execute the bitmap pattern shader.
+ *
+ * @param  {IVertexArrayObject} vertex_array_object
+ * @param  {number} offset
+ * @param  {number} index_count
+ * @param  {Float32Array | null} [grid_data=null]
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (vertex_array_object: IVertexArrayObject, offset: number, index_count: number, grid_data: Float32Array | null) => void;