@next2d/webgl 1.14.20

package/dist/CanvasToWebGLContextBlend.d.ts

@@ -0,0 +1,97 @@
+import type { CanvasToWebGLContext } from "./CanvasToWebGLContext";
+import { BlendModeImpl } from "@next2d/interface";
+/**
+ * @class
+ */
+export declare class CanvasToWebGLContextBlend {
+    private readonly _$context;
+    private readonly _$gl;
+    private _$enabled;
+    private _$funcCode;
+    /**
+     * @param {CanvasToWebGLContext} context
+     * @param {WebGL2RenderingContext} gl
+     * @constructor
+     * @public
+     */
+    constructor(context: CanvasToWebGLContext, gl: WebGL2RenderingContext);
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    enable(): void;
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    disable(): void;
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    reset(): void;
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toOneZero(): void;
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toZeroOne(): void;
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toAdd(): void;
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toScreen(): void;
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toAlpha(): void;
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toErase(): void;
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toSourceAtop(): void;
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toSourceIn(): void;
+    /**
+     * @param  {string} operation
+     * @return {void}
+     * @method
+     * @public
+     */
+    toOperation(operation: BlendModeImpl): void;
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    drawImage(image: WebGLTexture, x: number, y: number, w: number, h: number, ct0: number, ct1: number, ct2: number, ct3: number, ct4: number, ct5: number, ct6: number, ct7: number, operation: BlendModeImpl, renderWidth: number, renderHeight: number, matrix: Float32Array, imageSmoothingEnabled: boolean): void;
+}

package/dist/CanvasToWebGLContextBlend.js

@@ -0,0 +1,299 @@
+import { $Math, $Number, $inverseMatrix } from "@next2d/share";
+/**
+ * @class
+ */
+export class CanvasToWebGLContextBlend {
+    /**
+     * @param {CanvasToWebGLContext} context
+     * @param {WebGL2RenderingContext} gl
+     * @constructor
+     * @public
+     */
+    constructor(context, gl) {
+        /**
+         * @type {CanvasToWebGLContext}
+         * @private
+         */
+        this._$context = context;
+        /**
+         * @type {WebGL2RenderingContext}
+         * @private
+         */
+        this._$gl = gl;
+        /**
+         * @type {boolean}
+         * @default false
+         * @private
+         */
+        this._$enabled = false;
+        /**
+         * @type {number}
+         * @default 600
+         * @private
+         */
+        this._$funcCode = 600;
+        // start
+        this.enable();
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    enable() {
+        if (!this._$enabled) {
+            this._$enabled = true;
+            this._$gl.enable(this._$gl.BLEND);
+        }
+        this.reset();
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    disable() {
+        if (this._$enabled) {
+            this._$enabled = false;
+            this._$gl.disable(this._$gl.BLEND);
+        }
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    reset() {
+        if (this._$funcCode !== 613) {
+            this._$funcCode = 613;
+            this._$gl.blendFunc(this._$gl.ONE, this._$gl.ONE_MINUS_SRC_ALPHA);
+        }
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toOneZero() {
+        if (this._$funcCode !== 610) {
+            this._$funcCode = 610;
+            this._$gl.blendFunc(this._$gl.ONE, this._$gl.ZERO);
+        }
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toZeroOne() {
+        if (this._$funcCode !== 601) {
+            this._$funcCode = 601;
+            this._$gl.blendFuncSeparate(this._$gl.ZERO, this._$gl.ONE, this._$gl.ONE, this._$gl.ZERO);
+        }
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toAdd() {
+        if (this._$funcCode !== 611) {
+            this._$funcCode = 611;
+            this._$gl.blendFunc(this._$gl.ONE, this._$gl.ONE);
+        }
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toScreen() {
+        if (this._$funcCode !== 641) {
+            this._$funcCode = 641;
+            this._$gl.blendFunc(this._$gl.ONE_MINUS_DST_COLOR, this._$gl.ONE);
+        }
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toAlpha() {
+        if (this._$funcCode !== 606) {
+            this._$funcCode = 606;
+            this._$gl.blendFunc(this._$gl.ZERO, this._$gl.SRC_ALPHA);
+        }
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toErase() {
+        if (this._$funcCode !== 603) {
+            this._$funcCode = 603;
+            this._$gl.blendFunc(this._$gl.ZERO, this._$gl.ONE_MINUS_SRC_ALPHA);
+        }
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toSourceAtop() {
+        if (this._$funcCode !== 673) {
+            this._$funcCode = 673;
+            this._$gl.blendFunc(this._$gl.DST_ALPHA, this._$gl.ONE_MINUS_SRC_ALPHA);
+        }
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    toSourceIn() {
+        if (this._$funcCode !== 670) {
+            this._$funcCode = 670;
+            this._$gl.blendFunc(this._$gl.DST_ALPHA, this._$gl.ZERO);
+        }
+    }
+    /**
+     * @param  {string} operation
+     * @return {void}
+     * @method
+     * @public
+     */
+    toOperation(operation) {
+        switch (operation) {
+            case "add":
+                this.toAdd();
+                break;
+            case "screen":
+                this.toScreen();
+                break;
+            case "alpha":
+                this.toAlpha();
+                break;
+            case "erase":
+                this.toErase();
+                break;
+            case "copy":
+                this.toOneZero();
+                break;
+            default:
+                this.reset();
+                break;
+        }
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    drawImage(image, x, y, w, h, ct0, ct1, ct2, ct3, ct4, ct5, ct6, ct7, operation, renderWidth, renderHeight, matrix, imageSmoothingEnabled) {
+        const manager = this._$context.frameBuffer;
+        const currentBuffer = manager.currentAttachment;
+        const withCT = ct0 !== 1 || ct1 !== 1 || ct2 !== 1 || ct3 !== 1 ||
+            ct4 !== 0 || ct5 !== 0 || ct6 !== 0 || ct7 !== 0;
+        const variants = this._$context.shaderList.blendShaderVariants;
+        switch (operation) {
+            case "normal":
+            case "layer":
+            case "add":
+            case "screen":
+            case "alpha":
+            case "erase":
+            case "copy":
+                {
+                    manager.textureManager.bind0(image, imageSmoothingEnabled);
+                    const shader = variants.getNormalBlendShader(withCT);
+                    variants.setNormalBlendUniform(shader.uniform, x, y, w, h, matrix, renderWidth, renderHeight, withCT, ct0, ct1, ct2, ct3, ct4, ct5, ct6, ct7);
+                    const a = matrix[0];
+                    const b = matrix[1];
+                    const c = matrix[3];
+                    const d = matrix[4];
+                    const tx = matrix[6];
+                    const ty = matrix[7];
+                    if (a !== 1 || b !== 0 || c !== 0 || d !== 1) {
+                        const left = x;
+                        const right = x + w;
+                        const top = y;
+                        const bottom = y + h;
+                        const x0 = +(right * a + bottom * c + tx);
+                        const x1 = +(right * a + top * c + tx);
+                        const x2 = +(left * a + bottom * c + tx);
+                        const x3 = +(left * a + top * c + tx);
+                        const y0 = +(right * b + bottom * d + ty);
+                        const y1 = +(right * b + top * d + ty);
+                        const y2 = +(left * b + bottom * d + ty);
+                        const y3 = +(left * b + top * d + ty);
+                        const no = $Number.MAX_VALUE;
+                        const xMin = +$Math.min($Math.min($Math.min($Math.min(no, x0), x1), x2), x3);
+                        const xMax = +$Math.max($Math.max($Math.max($Math.max(-no, x0), x1), x2), x3);
+                        const yMin = +$Math.min($Math.min($Math.min($Math.min(no, y0), y1), y2), y3);
+                        const yMax = +$Math.max($Math.max($Math.max($Math.max(-no, y0), y1), y2), y3);
+                        const sx = $Math.max(0, xMin);
+                        const sy = $Math.max(0, yMin);
+                        const sw = $Math.min($Math.max(0, renderWidth - sx), $Math.ceil($Math.abs(xMax - xMin)));
+                        const sh = $Math.min($Math.max(0, renderHeight - sy), $Math.ceil($Math.abs(yMax - yMin)));
+                        if (!sw || !sh) {
+                            return;
+                        }
+                        this._$gl.enable(this._$gl.SCISSOR_TEST);
+                        this._$gl.scissor(sx, $Math.max(0, renderHeight - (sy + sh)), sw + 1, sh + 1);
+                    }
+                    else {
+                        const sx = $Math.max(0, x + tx);
+                        const sy = $Math.max(0, y + ty);
+                        const sw = $Math.min($Math.max(0, renderWidth - sx), w);
+                        const sh = $Math.min($Math.max(0, renderHeight - sy), h);
+                        if (!sw || !sh) {
+                            return;
+                        }
+                        this._$gl.enable(this._$gl.SCISSOR_TEST);
+                        this._$gl.scissor(sx, Math.max(0, renderHeight - (sy + sh)), sw + 1, sh + 1);
+                    }
+                    this.toOperation(operation);
+                    shader._$drawImage();
+                    this._$gl.disable(this._$gl.SCISSOR_TEST);
+                }
+                break;
+            default:
+                {
+                    const sx = Math.max(0, x + matrix[6]);
+                    const sy = Math.max(0, y + matrix[7]);
+                    const sw = Math.min(Math.max(0, renderWidth - sx), w);
+                    const sh = Math.min(Math.max(0, renderHeight - sy), h);
+                    if (!sw || !sh) {
+                        return;
+                    }
+                    const texture = manager.getTextureFromCurrentAttachment();
+                    const backTextureAttachment = this
+                        ._$context
+                        .frameBuffer
+                        .createTextureAttachment(w, h);
+                    this._$context._$bind(backTextureAttachment);
+                    manager.textureManager.bind0(texture);
+                    const clipShader = variants.getClipShader();
+                    const clipUniform = clipShader.uniform;
+                    variants.setClipUniform(clipUniform, x, y, w, h, $inverseMatrix(matrix), renderWidth, renderHeight);
+                    this.reset();
+                    clipShader._$drawImage();
+                    const backTexture = manager
+                        .getTextureFromCurrentAttachment();
+                    this._$context._$bind(currentBuffer);
+                    manager.textureManager.bind01(backTexture, image, imageSmoothingEnabled);
+                    const shader = variants
+                        .getBlendShader(operation, withCT);
+                    variants.setBlendUniform(shader.uniform, x, y, w, h, matrix, renderWidth, renderHeight, withCT, ct0, ct1, ct2, ct3, ct4, ct5, ct6, ct7);
+                    this._$gl.enable(this._$gl.SCISSOR_TEST);
+                    this._$gl.scissor(sx, Math.max(0, renderHeight - (sy + sh)), sw, sh);
+                    this.toOneZero();
+                    shader._$drawImage();
+                    this._$gl.disable(this._$gl.SCISSOR_TEST);
+                    manager.releaseAttachment(backTextureAttachment, true);
+                }
+                break;
+        }
+    }
+}

package/dist/CanvasToWebGLContextGrid.d.ts

@@ -0,0 +1,74 @@
+import type { BoundsImpl } from "./interface/BoundsImpl";
+import type { GridImpl } from "./interface/GridImpl";
+/**
+ * @class
+ */
+export declare class CanvasToWebGLContextGrid {
+    enabled: boolean;
+    parentMatrixA: number;
+    parentMatrixB: number;
+    parentMatrixC: number;
+    parentMatrixD: number;
+    parentMatrixE: number;
+    parentMatrixF: number;
+    parentMatrixG: number;
+    parentMatrixH: number;
+    parentMatrixI: number;
+    ancestorMatrixA: number;
+    ancestorMatrixB: number;
+    ancestorMatrixC: number;
+    ancestorMatrixD: number;
+    ancestorMatrixE: number;
+    ancestorMatrixF: number;
+    ancestorMatrixG: number;
+    ancestorMatrixH: number;
+    ancestorMatrixI: number;
+    parentViewportX: number;
+    parentViewportY: number;
+    parentViewportW: number;
+    parentViewportH: number;
+    minXST: number;
+    minYST: number;
+    minXPQ: number;
+    minYPQ: number;
+    maxXST: number;
+    maxYST: number;
+    maxXPQ: number;
+    maxYPQ: number;
+    /**
+     * @constructor
+     * @public
+     */
+    constructor();
+    /**
+     * @param  {number} x
+     * @param  {number} y
+     * @param  {number} width
+     * @param  {number} height
+     * @param  {object} bounds
+     * @param  {object} grid
+     * @param  {number} same_scale
+     * @param  {number} parentA
+     * @param  {number} parentB
+     * @param  {number} parentC
+     * @param  {number} parentD
+     * @param  {number} parentE
+     * @param  {number} parentF
+     * @param  {number} ancestorA
+     * @param  {number} ancestorB
+     * @param  {number} ancestorC
+     * @param  {number} ancestorD
+     * @param  {number} ancestorE
+     * @param  {number} ancestorF
+     * @return {void}
+     * @method
+     * @public
+     */
+    enable(x: number, y: number, width: number, height: number, bounds: BoundsImpl, grid: GridImpl, same_scale: number, parentA: number, parentB: number, parentC: number, parentD: number, parentE: number, parentF: number, ancestorA: number, ancestorB: number, ancestorC: number, ancestorD: number, ancestorE: number, ancestorF: number): void;
+    /**
+     * @return void
+     * @method
+     * @public
+     */
+    disable(): void;
+}