@next2d/webgl 1.14.20

package/dist/shader/variants/BlendShaderVariantCollection.js

@@ -0,0 +1,239 @@
+import { CanvasToWebGLShader } from "../CanvasToWebGLShader";
+import { VertexShaderSource } from "../vertex/VertexShaderSource";
+import { FragmentShaderSourceTexture } from "../fragment/FragmentShaderSourceTexture";
+import { FragmentShaderSourceBlend } from "../fragment/FragmentShaderSourceBlend";
+import { $getMap } from "@next2d/share";
+/**
+ * @class
+ */
+export class BlendShaderVariantCollection {
+    /**
+     * @param {CanvasToWebGLContext}  context
+     * @param {WebGL2RenderingContext} gl
+     * @constructor
+     * @public
+     */
+    constructor(context, gl) {
+        /**
+         * @type {CanvasToWebGLContext}
+         * @private
+         */
+        this._$context = context;
+        /**
+         * @type {WebGL2RenderingContext}
+         * @private
+         */
+        this._$gl = gl;
+        /**
+         * @type {Map}
+         * @private
+         */
+        this._$collection = $getMap();
+    }
+    /**
+     * @param  {boolean} with_color_transform
+     * @return {CanvasToWebGLShader}
+     * @method
+     * @public
+     */
+    getNormalBlendShader(with_color_transform) {
+        const key = `n${with_color_transform ? "y" : "n"}`;
+        if (this._$collection.has(key)) {
+            const shader = this._$collection.get(key);
+            if (shader) {
+                return shader;
+            }
+        }
+        const shader = new CanvasToWebGLShader(this._$gl, this._$context, VertexShaderSource.BLEND(), FragmentShaderSourceTexture.TEMPLATE(with_color_transform));
+        this._$collection.set(key, shader);
+        return shader;
+    }
+    /**
+     * @return {CanvasToWebGLShader}
+     * @method
+     * @public
+     */
+    getClipShader() {
+        const key = "c";
+        if (this._$collection.has(key)) {
+            const shader = this._$collection.get(key);
+            if (shader) {
+                return shader;
+            }
+        }
+        const shader = new CanvasToWebGLShader(this._$gl, this._$context, VertexShaderSource.BLEND_CLIP(), FragmentShaderSourceTexture.TEMPLATE(false));
+        this._$collection.set(key, shader);
+        return shader;
+    }
+    /**
+     * @param  {string}  operation
+     * @param  {boolean} with_color_transform
+     * @return {CanvasToWebGLShader}
+     * @method
+     * @public
+     */
+    getBlendShader(operation, with_color_transform) {
+        const key = `${operation}${with_color_transform ? "y" : "n"}`;
+        if (this._$collection.has(key)) {
+            const shader = this._$collection.get(key);
+            if (shader) {
+                return shader;
+            }
+        }
+        const shader = new CanvasToWebGLShader(this._$gl, this._$context, VertexShaderSource.BLEND(), FragmentShaderSourceBlend.TEMPLATE(operation, with_color_transform));
+        this._$collection.set(key, shader);
+        return shader;
+    }
+    /**
+     * @param  {WebGLShaderUniform} uniform
+     * @param  {number}  x
+     * @param  {number}  y
+     * @param  {number}  w
+     * @param  {number}  h
+     * @param  {Float32Array} matrix
+     * @param  {number}  render_width
+     * @param  {number}  render_height
+     * @param  {boolean} with_color_transform
+     * @param  {number}  ct0
+     * @param  {number}  ct1
+     * @param  {number}  ct2
+     * @param  {number}  ct3
+     * @param  {number}  ct4
+     * @param  {number}  ct5
+     * @param  {number}  ct6
+     * @param  {number}  ct7
+     * @return {void}
+     * @method
+     * @public
+     */
+    setNormalBlendUniform(uniform, x, y, w, h, matrix, render_width, render_height, with_color_transform, ct0, ct1, ct2, ct3, ct4, ct5, ct6, ct7) {
+        const highp = uniform.highp;
+        // vertex: u_offset
+        highp[0] = x;
+        highp[1] = y;
+        // vertex: u_size
+        highp[2] = w;
+        highp[3] = h;
+        // vertex: u_matrix
+        highp[4] = matrix[0];
+        highp[5] = matrix[1];
+        highp[6] = matrix[2];
+        highp[8] = matrix[3];
+        highp[9] = matrix[4];
+        highp[10] = matrix[5];
+        highp[12] = matrix[6];
+        highp[13] = matrix[7];
+        highp[14] = matrix[8];
+        // vertex: u_viewport
+        highp[7] = render_width;
+        highp[11] = render_height;
+        if (with_color_transform) {
+            const mediump = uniform.mediump;
+            // fragment: u_color_transform_mul
+            mediump[0] = ct0;
+            mediump[1] = ct1;
+            mediump[2] = ct2;
+            mediump[3] = ct3;
+            // fragment: u_color_transform_add
+            mediump[4] = ct4;
+            mediump[5] = ct5;
+            mediump[6] = ct6;
+            mediump[7] = ct7;
+        }
+    }
+    /**
+     * @param  {WebGLShaderUniform} uniform
+     * @param  {number} x
+     * @param  {number} y
+     * @param  {number} w
+     * @param  {number} h
+     * @param  {Float32Array} inverse_matrix
+     * @param  {number} render_width
+     * @param  {number} render_height
+     * @return {void}
+     * @method
+     * @public
+     */
+    setClipUniform(uniform, x, y, w, h, inverse_matrix, render_width, render_height) {
+        const highp = uniform.highp;
+        // vertex: u_offset
+        highp[0] = x;
+        highp[1] = y;
+        // vertex: u_size
+        highp[2] = w;
+        highp[3] = h;
+        // vertex: u_inverse_matrix
+        highp[4] = inverse_matrix[0];
+        highp[5] = inverse_matrix[1];
+        highp[6] = inverse_matrix[2];
+        highp[8] = inverse_matrix[3];
+        highp[9] = inverse_matrix[4];
+        highp[10] = inverse_matrix[5];
+        highp[12] = inverse_matrix[6];
+        highp[13] = inverse_matrix[7];
+        highp[14] = inverse_matrix[8];
+        // vertex: u_viewport
+        highp[7] = render_width;
+        highp[11] = render_height;
+    }
+    /**
+     * @param  {WebGLShaderUniform} uniform
+     * @param  {number}  x
+     * @param  {number}  y
+     * @param  {number}  w
+     * @param  {number}  h
+     * @param  {Float32Array} matrix
+     * @param  {number}  render_width
+     * @param  {number}  render_height
+     * @param  {boolean} with_color_transform
+     * @param  {number}  ct0
+     * @param  {number}  ct1
+     * @param  {number}  ct2
+     * @param  {number}  ct3
+     * @param  {number}  ct4
+     * @param  {number}  ct5
+     * @param  {number}  ct6
+     * @param  {number}  ct7
+     * @return {void}
+     * @method
+     * @public
+     */
+    setBlendUniform(uniform, x, y, w, h, matrix, render_width, render_height, with_color_transform, ct0, ct1, ct2, ct3, ct4, ct5, ct6, ct7) {
+        const textures = uniform.textures;
+        textures[0] = 0;
+        textures[1] = 1;
+        const highp = uniform.highp;
+        // vertex: u_offset
+        highp[0] = x;
+        highp[1] = y;
+        // vertex: u_size
+        highp[2] = w;
+        highp[3] = h;
+        // vertex: u_matrix
+        highp[4] = matrix[0];
+        highp[5] = matrix[1];
+        highp[6] = matrix[2];
+        highp[8] = matrix[3];
+        highp[9] = matrix[4];
+        highp[10] = matrix[5];
+        highp[12] = matrix[6];
+        highp[13] = matrix[7];
+        highp[14] = matrix[8];
+        // vertex: u_viewport
+        highp[7] = render_width;
+        highp[11] = render_height;
+        if (with_color_transform) {
+            const mediump = uniform.mediump;
+            // fragment: u_color_transform_mul
+            mediump[0] = ct0;
+            mediump[1] = ct1;
+            mediump[2] = ct2;
+            mediump[3] = ct3;
+            // fragment: u_color_transform_add
+            mediump[4] = ct4;
+            mediump[5] = ct5;
+            mediump[6] = ct6;
+            mediump[7] = ct7;
+        }
+    }
+}

package/dist/shader/variants/FilterShaderVariantCollection.d.ts

@@ -0,0 +1,150 @@
+import { CanvasToWebGLShader } from "../CanvasToWebGLShader";
+import type { WebGLShaderUniform } from "../WebGLShaderUniform";
+import type { CanvasToWebGLContext } from "../../CanvasToWebGLContext";
+/**
+ * @class
+ */
+export declare class FilterShaderVariantCollection {
+    private readonly _$context;
+    private readonly _$gl;
+    private readonly _$collection;
+    /**
+     * @param {CanvasToWebGLContext}  context
+     * @param {WebGL2RenderingContext} gl
+     * @constructor
+     * @public
+     */
+    constructor(context: CanvasToWebGLContext, gl: WebGL2RenderingContext);
+    /**
+     * @param  {number}  half_blur
+     * @return {CanvasToWebGLShader}
+     * @method
+     * @public
+     */
+    getBlurFilterShader(half_blur: number): CanvasToWebGLShader;
+    /**
+     * @param  {boolean} transforms_base
+     * @param  {boolean} transforms_blur
+     * @param  {boolean} is_glow
+     * @param  {string}  type
+     * @param  {boolean} knockout
+     * @param  {boolean} applies_strength
+     * @param  {boolean} is_gradient
+     * @return {CanvasToWebGLShader}
+     * @method
+     * @public
+     */
+    getBitmapFilterShader(transforms_base: boolean, transforms_blur: boolean, is_glow: boolean, type: string, knockout: boolean, applies_strength: boolean, is_gradient: boolean): CanvasToWebGLShader;
+    /**
+     * @return {CanvasToWebGLShader}
+     * @method
+     * @public
+     */
+    getColorMatrixFilterShader(): CanvasToWebGLShader;
+    /**
+     * @param  {number}  x
+     * @param  {number}  y
+     * @param  {boolean} preserve_alpha
+     * @param  {boolean} clamp
+     * @return {CanvasToWebGLShader}
+     * @method
+     * @public
+     */
+    getConvolutionFilterShader(x: number, y: number, preserve_alpha: boolean, clamp: boolean): CanvasToWebGLShader;
+    /**
+     * @param  {number} component_x
+     * @param  {number} component_y
+     * @param  {string} mode
+     * @return {CanvasToWebGLShader}
+     * @method
+     * @public
+     */
+    getDisplacementMapFilterShader(component_x: number, component_y: number, mode: string): CanvasToWebGLShader;
+    /**
+     * @param  {WebGLShaderUniform} uniform
+     * @param  {number}  width
+     * @param  {number}  height
+     * @param  {boolean} is_horizontal
+     * @param  {number}  fraction
+     * @param  {number}  samples
+     * @return {void}
+     * @method
+     * @public
+     */
+    setBlurFilterUniform(uniform: WebGLShaderUniform, width: number, height: number, is_horizontal: boolean, fraction: number, samples: number): void;
+    /**
+     * @param {WebGLShaderUniform} uniform
+     * @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 {number}  strength
+     * @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
+     * @param {boolean} transforms_base
+     * @param {boolean} transforms_blur
+     * @param {boolean} applies_strength
+     * @param {boolean} is_gradient
+     * @method
+     * @public
+     */
+    setBitmapFilterUniform(uniform: WebGLShaderUniform, 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, strength: number, color_r1: number, color_g1: number, color_b1: number, color_a1: number, color_r2: number, color_g2: number, color_b2: number, color_a2: number, transforms_base: boolean, transforms_blur: boolean, applies_strength: boolean, is_gradient: boolean): void;
+    /**
+     * @param  {WebGLShaderUniform} uniform
+     * @param  {array} matrix
+     * @return {void}
+     * @method
+     * @public
+     */
+    setColorMatrixFilterUniform(uniform: WebGLShaderUniform, matrix: number[]): void;
+    /**
+     * @param  {WebGLShaderUniform} uniform
+     * @param  {number}  width
+     * @param  {number}  height
+     * @param  {Float32Array} matrix
+     * @param  {number}  divisor
+     * @param  {number}  bias
+     * @param  {boolean} clamp
+     * @param  {number}  color_r
+     * @param  {number}  color_g
+     * @param  {number}  color_b
+     * @param  {number}  color_a
+     * @return {void}
+     * @method
+     * @public
+     */
+    setConvolutionFilterUniform(uniform: WebGLShaderUniform, width: number, height: number, matrix: number[], divisor: number, bias: number, clamp: boolean, color_r: number, color_g: number, color_b: number, color_a: number): void;
+    /**
+     * @param  {WebGLShaderUniform} uniform
+     * @param  {number} map_width
+     * @param  {number} map_height
+     * @param  {number} base_width
+     * @param  {number} base_height
+     * @param  {number} point_x
+     * @param  {number} point_y
+     * @param  {number} scale_x
+     * @param  {number} scale_y
+     * @param  {string} mode
+     * @param  {number} color_r
+     * @param  {number} color_g
+     * @param  {number} color_b
+     * @param  {number} color_a
+     * @return {void}
+     * @method
+     * @public
+     */
+    setDisplacementMapFilterUniform(uniform: WebGLShaderUniform, map_width: number, map_height: number, base_width: number, base_height: number, point_x: number, point_y: number, scale_x: number, scale_y: number, mode: string, color_r: number, color_g: number, color_b: number, color_a: number): void;
+}