@next2d/player 1.14.19 → 1.14.21

package/webgl/shader/variants/FilterShaderVariantCollection.js

@@ -1,395 +0,0 @@
-import { CanvasToWebGLShader } from "../CanvasToWebGLShader";
-import { VertexShaderSource } from "../vertex/VertexShaderSource";
-import { FragmentShaderSourceFilter } from "../fragment/filter/FragmentShaderSourceFilter";
-import { FragmentShaderSourceBlurFilter } from "../fragment/filter/FragmentShaderSourceBlurFilter";
-import { FragmentShaderSourceColorMatrixFilter } from "../fragment/filter/FragmentShaderSourceColorMatrixFilter";
-import { FragmentShaderSourceConvolutionFilter } from "../fragment/filter/FragmentShaderSourceConvolutionFilter";
-import { FragmentShaderSourceDisplacementMapFilter } from "../fragment/filter/FragmentShaderSourceDisplacementMapFilter";
-import { $Math, $getMap } from "../../../util/RenderUtil";
-/**
- * @class
- */
-export class FilterShaderVariantCollection {
-    /**
-     * @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  {number}  half_blur
-     * @return {CanvasToWebGLShader}
-     * @method
-     * @public
-     */
-    getBlurFilterShader(half_blur) {
-        const key = `b${half_blur}`;
-        if (this._$collection.has(key)) {
-            const shader = this._$collection.get(key);
-            if (shader) {
-                return shader;
-            }
-        }
-        const shader = new CanvasToWebGLShader(this._$gl, this._$context, VertexShaderSource.TEXTURE(), FragmentShaderSourceBlurFilter.TEMPLATE(half_blur));
-        this._$collection.set(key, shader);
-        return shader;
-    }
-    /**
-     * @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, transforms_blur, is_glow, type, knockout, applies_strength, is_gradient) {
-        const key1 = transforms_base ? "y" : "n";
-        const key2 = transforms_blur ? "y" : "n";
-        const key3 = is_glow ? "y" : "n";
-        const key4 = knockout ? "y" : "n";
-        const key5 = applies_strength ? "y" : "n";
-        const key = `f${key1}${key2}${key3}${type}${key4}${key5}`;
-        if (this._$collection.has(key)) {
-            const shader = this._$collection.get(key);
-            if (shader) {
-                return shader;
-            }
-        }
-        let texturesLength = 1;
-        if (transforms_base) {
-            texturesLength++;
-        }
-        if (is_gradient) {
-            texturesLength++;
-        }
-        let mediumpLength = (transforms_base ? 4 : 0)
-            + (transforms_blur ? 4 : 0)
-            + (applies_strength ? 1 : 0);
-        if (!is_gradient) {
-            mediumpLength += is_glow ? 4 : 8;
-        }
-        mediumpLength = $Math.ceil(mediumpLength / 4);
-        const shader = new CanvasToWebGLShader(this._$gl, this._$context, VertexShaderSource.TEXTURE(), FragmentShaderSourceFilter.TEMPLATE(texturesLength, mediumpLength, transforms_base, transforms_blur, is_glow, type, knockout, applies_strength, is_gradient));
-        this._$collection.set(key, shader);
-        return shader;
-    }
-    /**
-     * @return {CanvasToWebGLShader}
-     * @method
-     * @public
-     */
-    getColorMatrixFilterShader() {
-        const key = "m";
-        if (this._$collection.has(key)) {
-            const shader = this._$collection.get(key);
-            if (shader) {
-                return shader;
-            }
-        }
-        const shader = new CanvasToWebGLShader(this._$gl, this._$context, VertexShaderSource.TEXTURE(), FragmentShaderSourceColorMatrixFilter.TEMPLATE());
-        this._$collection.set(key, shader);
-        return shader;
-    }
-    /**
-     * @param  {number}  x
-     * @param  {number}  y
-     * @param  {boolean} preserve_alpha
-     * @param  {boolean} clamp
-     * @return {CanvasToWebGLShader}
-     * @method
-     * @public
-     */
-    getConvolutionFilterShader(x, y, preserve_alpha, clamp) {
-        const key1 = ("0" + x).slice(-2);
-        const key2 = ("0" + y).slice(-2);
-        const key3 = preserve_alpha ? "y" : "n";
-        const key4 = clamp ? "y" : "n";
-        const key = `c${key1}${key2}${key3}${key4}`;
-        if (this._$collection.has(key)) {
-            const shader = this._$collection.get(key);
-            if (shader) {
-                return shader;
-            }
-        }
-        const mediumpLength = (clamp ? 1 : 2) + $Math.ceil(x * y / 4);
-        const shader = new CanvasToWebGLShader(this._$gl, this._$context, VertexShaderSource.TEXTURE(), FragmentShaderSourceConvolutionFilter.TEMPLATE(mediumpLength, x, y, preserve_alpha, clamp));
-        this._$collection.set(key, shader);
-        return shader;
-    }
-    /**
-     * @param  {number} component_x
-     * @param  {number} component_y
-     * @param  {string} mode
-     * @return {CanvasToWebGLShader}
-     * @method
-     * @public
-     */
-    getDisplacementMapFilterShader(component_x, component_y, mode) {
-        const key = `d${component_x}${component_y}${mode}`;
-        if (this._$collection.has(key)) {
-            const shader = this._$collection.get(key);
-            if (shader) {
-                return shader;
-            }
-        }
-        const mediumpLength = mode === "color" ? 3 : 2;
-        const shader = new CanvasToWebGLShader(this._$gl, this._$context, VertexShaderSource.TEXTURE(), FragmentShaderSourceDisplacementMapFilter.TEMPLATE(mediumpLength, component_x, component_y, mode));
-        this._$collection.set(key, shader);
-        return shader;
-    }
-    /**
-     * @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, width, height, is_horizontal, fraction, samples) {
-        const mediump = uniform.mediump;
-        // fragment: u_offset
-        if (is_horizontal) {
-            mediump[0] = 1 / width;
-            mediump[1] = 0;
-        }
-        else {
-            mediump[0] = 0;
-            mediump[1] = 1 / height;
-        }
-        // fragment: u_fraction
-        mediump[2] = fraction;
-        // fragment: u_samples
-        mediump[3] = samples;
-    }
-    /**
-     * @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, 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, transforms_base, transforms_blur, applies_strength, is_gradient) {
-        let textures;
-        // fragment: u_textures
-        if (transforms_base) {
-            textures = uniform.textures;
-            textures[0] = 0;
-            textures[1] = 1;
-            if (is_gradient) {
-                textures[2] = 2;
-            }
-        }
-        else if (is_gradient) {
-            textures = uniform.textures;
-            textures[0] = 0;
-            textures[1] = 2;
-        }
-        const mediump = uniform.mediump;
-        let i = 0;
-        if (transforms_base) {
-            // fragment: u_uv_scale
-            mediump[i] = width / base_width;
-            mediump[i + 1] = height / base_height;
-            // fragment: u_uv_offset
-            mediump[i + 2] = base_offset_x / base_width;
-            mediump[i + 3] = (height - base_height - base_offset_y) / base_height;
-            i += 4;
-        }
-        if (transforms_blur) {
-            // fragment: u_st_scale
-            mediump[i] = width / blur_width;
-            mediump[i + 1] = height / blur_height;
-            // fragment: u_st_offset
-            mediump[i + 2] = blur_offset_x / blur_width;
-            mediump[i + 3] = (height - blur_height - blur_offset_y) / blur_height;
-            i += 4;
-        }
-        if (is_gradient) {
-            // do nothing
-        }
-        else if (is_glow) {
-            // fragment: u_color
-            mediump[i] = color_r1;
-            mediump[i + 1] = color_g1;
-            mediump[i + 2] = color_b1;
-            mediump[i + 3] = color_a1;
-            i += 4;
-        }
-        else {
-            // fragment: u_highlight_color
-            mediump[i] = color_r1;
-            mediump[i + 1] = color_g1;
-            mediump[i + 2] = color_b1;
-            mediump[i + 3] = color_a1;
-            // fragment: u_shadow_color
-            mediump[i + 4] = color_r2;
-            mediump[i + 5] = color_g2;
-            mediump[i + 6] = color_b2;
-            mediump[i + 7] = color_a2;
-            i += 8;
-        }
-        if (applies_strength) {
-            // fragment: u_strength
-            mediump[i] = strength;
-        }
-    }
-    /**
-     * @param  {WebGLShaderUniform} uniform
-     * @param  {array} matrix
-     * @return {void}
-     * @method
-     * @public
-     */
-    setColorMatrixFilterUniform(uniform, matrix) {
-        const mediump = uniform.mediump;
-        // fragment: u_mul
-        mediump[0] = matrix[0];
-        mediump[1] = matrix[1];
-        mediump[2] = matrix[2];
-        mediump[3] = matrix[3];
-        mediump[4] = matrix[5];
-        mediump[5] = matrix[6];
-        mediump[6] = matrix[7];
-        mediump[7] = matrix[8];
-        mediump[8] = matrix[10];
-        mediump[9] = matrix[11];
-        mediump[10] = matrix[12];
-        mediump[11] = matrix[13];
-        mediump[12] = matrix[15];
-        mediump[13] = matrix[16];
-        mediump[14] = matrix[17];
-        mediump[15] = matrix[18];
-        // fragment: u_add
-        mediump[16] = matrix[4] / 255;
-        mediump[17] = matrix[9] / 255;
-        mediump[18] = matrix[14] / 255;
-        mediump[19] = matrix[19] / 255;
-    }
-    /**
-     * @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, width, height, matrix, divisor, bias, clamp, color_r, color_g, color_b, color_a) {
-        const mediump = uniform.mediump;
-        // fragment: u_rcp_size
-        mediump[0] = 1 / width;
-        mediump[1] = 1 / height;
-        // fragment: u_rcp_divisor
-        mediump[2] = 1 / divisor;
-        // fragment: u_bias
-        mediump[3] = bias / 255;
-        let i = 4;
-        if (!clamp) {
-            // fragment: u_substitute_color
-            mediump[i] = color_r;
-            mediump[i + 1] = color_g;
-            mediump[i + 2] = color_b;
-            mediump[i + 3] = color_a;
-            i += 4;
-        }
-        // fragment: u_matrix
-        const length = matrix.length;
-        for (let j = 0; j < length; j++) {
-            mediump[i++] = matrix[j];
-        }
-    }
-    /**
-     * @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, map_width, map_height, base_width, base_height, point_x, point_y, scale_x, scale_y, mode, color_r, color_g, color_b, color_a) {
-        const textures = uniform.textures;
-        textures[0] = 0;
-        textures[1] = 1;
-        const mediump = uniform.mediump;
-        // fragment: u_uv_to_st_scale
-        mediump[0] = base_width / map_width;
-        mediump[1] = base_height / map_height;
-        // fragment: u_uv_to_st_offset
-        mediump[2] = point_x / map_width;
-        mediump[3] = (base_height - map_height - point_y) / map_height;
-        // fragment: u_scale
-        mediump[4] = scale_x / base_width;
-        mediump[5] = -scale_y / base_height;
-        if (mode === "color") {
-            // fragment: u_substitute_color
-            mediump[8] = color_r;
-            mediump[9] = color_g;
-            mediump[10] = color_b;
-            mediump[11] = color_a;
-        }
-    }
-}

package/webgl/shader/variants/GradientLUTShaderVariantCollection.d.ts

@@ -1,49 +0,0 @@
-import { CanvasToWebGLShader } from "../CanvasToWebGLShader";
-import type { CanvasToWebGLContext } from "../../CanvasToWebGLContext";
-import type { WebGLShaderUniform } from "../WebGLShaderUniform";
-/**
- * @class
- */
-export declare class GradientLUTShaderVariantCollection {
-    private readonly _$context;
-    private readonly _$gl;
-    private readonly _$collection;
-    /**
-     * @param {CanvasToWebGLContext}  context
-     * @param {WebGL2RenderingContext} gl
-     * @constructor
-     * @public
-     */
-    constructor(context: CanvasToWebGLContext, gl: WebGL2RenderingContext);
-    /**
-     * @param  {number}  stops_length
-     * @param  {boolean} is_linear_space
-     * @return {CanvasToWebGLShader}
-     * @method
-     * @public
-     */
-    getGradientLUTShader(stops_length: number, is_linear_space: boolean): CanvasToWebGLShader;
-    /**
-     * @param  {WebGLShaderUniform} uniform
-     * @param  {array} stops
-     * @param  {number} begin
-     * @param  {number} end
-     * @param  {Float32Array} table
-     * @return {void}
-     * @method
-     * @public
-     */
-    setGradientLUTUniformForShape(uniform: WebGLShaderUniform, stops: any[], begin: number, end: number, table: Float32Array): void;
-    /**
-     * @param  {WebGLShaderUniform} uniform
-     * @param  {array}  ratios
-     * @param  {array}  colors
-     * @param  {array}  alphas
-     * @param  {number} begin
-     * @param  {number} end
-     * @return {void}
-     * @method
-     * @public
-     */
-    setGradientLUTUniformForFilter(uniform: WebGLShaderUniform, ratios: number[], colors: number[], alphas: number[], begin: number, end: number): void;
-}

package/webgl/shader/variants/GradientLUTShaderVariantCollection.js

@@ -1,107 +0,0 @@
-import { VertexShaderSource } from "../vertex/VertexShaderSource";
-import { FragmentShaderSourceGradientLUT } from "../fragment/FragmentShaderSourceGradientLUT";
-import { CanvasToWebGLShader } from "../CanvasToWebGLShader";
-import { $Math, $getMap } from "../../../util/RenderUtil";
-/**
- * @class
- */
-export class GradientLUTShaderVariantCollection {
-    /**
-     * @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  {number}  stops_length
-     * @param  {boolean} is_linear_space
-     * @return {CanvasToWebGLShader}
-     * @method
-     * @public
-     */
-    getGradientLUTShader(stops_length, is_linear_space) {
-        const key1 = ("00" + stops_length).slice(-3);
-        const key2 = is_linear_space ? "y" : "n";
-        const key = `l${key1}${key2}`;
-        if (this._$collection.has(key)) {
-            const shader = this._$collection.get(key);
-            if (shader) {
-                return shader;
-            }
-        }
-        const mediumpLength = $Math.ceil(stops_length * 5 / 4);
-        const shader = new CanvasToWebGLShader(this._$gl, this._$context, VertexShaderSource.TEXTURE(), FragmentShaderSourceGradientLUT.TEMPLATE(mediumpLength, stops_length, is_linear_space));
-        this._$collection.set(key, shader);
-        return shader;
-    }
-    /**
-     * @param  {WebGLShaderUniform} uniform
-     * @param  {array} stops
-     * @param  {number} begin
-     * @param  {number} end
-     * @param  {Float32Array} table
-     * @return {void}
-     * @method
-     * @public
-     */
-    setGradientLUTUniformForShape(uniform, stops, begin, end, table) {
-        let i = 0;
-        const mediump = uniform.mediump;
-        // fragment: u_gradient_color
-        for (let j = begin; j < end; j++) {
-            const color = stops[j][1];
-            mediump[i++] = table[color[0]];
-            mediump[i++] = table[color[1]];
-            mediump[i++] = table[color[2]];
-            mediump[i++] = table[color[3]];
-        }
-        // fragment: u_gradient_t
-        for (let j = begin; j < end; j++) {
-            mediump[i++] = stops[j][0];
-        }
-    }
-    /**
-     * @param  {WebGLShaderUniform} uniform
-     * @param  {array}  ratios
-     * @param  {array}  colors
-     * @param  {array}  alphas
-     * @param  {number} begin
-     * @param  {number} end
-     * @return {void}
-     * @method
-     * @public
-     */
-    setGradientLUTUniformForFilter(uniform, ratios, colors, alphas, begin, end) {
-        let i = 0;
-        const mediump = uniform.mediump;
-        // fragment: u_gradient_color
-        for (let j = begin; j < end; j++) {
-            const color = colors[j];
-            mediump[i++] = (color >> 16) / 255;
-            mediump[i++] = (color >> 8 & 0xFF) / 255;
-            mediump[i++] = (color & 0xFF) / 255;
-            mediump[i++] = alphas[j];
-        }
-        // fragment: u_gradient_t
-        for (let j = begin; j < end; j++) {
-            mediump[i++] = ratios[j];
-        }
-    }
-}

package/webgl/shader/variants/GradientShapeShaderVariantCollection.d.ts

@@ -1,61 +0,0 @@
-import { CanvasToWebGLShader } from "../CanvasToWebGLShader";
-import type { CanvasToWebGLContext } from "../../CanvasToWebGLContext";
-import type { WebGLShaderUniform } from "../WebGLShaderUniform";
-import type { CanvasToWebGLContextGrid } from "../../CanvasToWebGLContextGrid";
-/**
- * @class
- */
-export declare class GradientShapeShaderVariantCollection {
-    private readonly _$context;
-    private readonly _$gl;
-    private readonly _$collection;
-    /**
-     * @param {CanvasToWebGLContext}  context
-     * @param {WebGL2RenderingContext} gl
-     * @constructor
-     * @public
-     */
-    constructor(context: CanvasToWebGLContext, gl: WebGL2RenderingContext);
-    /**
-     * @param  {boolean} is_stroke
-     * @param  {boolean} has_grid
-     * @param  {boolean} is_radial
-     * @param  {boolean} has_focal_point
-     * @param  {string}  spread_method
-     * @return {CanvasToWebGLShader}
-     * @method
-     * @public
-     */
-    getGradientShapeShader(is_stroke: boolean, has_grid: boolean, is_radial: boolean, has_focal_point: boolean, spread_method: string): CanvasToWebGLShader;
-    /**
-     * @param  {boolean} is_stroke
-     * @param  {boolean} has_grid
-     * @param  {boolean} is_radial
-     * @param  {boolean} has_focal_point
-     * @param  {string}  spread_method
-     * @return {string}
-     * @method
-     * @private
-     */
-    createCollectionKey(is_stroke: boolean, has_grid: boolean, is_radial: boolean, has_focal_point: boolean, spread_method: string): string;
-    /**
-     * @param  {WebGLShaderUniform} uniform
-     * @param  {boolean} is_stroke
-     * @param  {number}  half_width
-     * @param  {number}  face
-     * @param  {number}  miter_limit
-     * @param  {boolean} has_grid
-     * @param  {Float32Array} matrix
-     * @param  {Float32Array} inverse_matrix
-     * @param  {number}  viewport_width
-     * @param  {number}  viewport_height
-     * @param  {CanvasToWebGLContextGrid} grid
-     * @param  {boolean} is_radial
-     * @param  {Float32Array} points
-     * @param  {number}  focal_point_ratio
-     * @return {void}
-     * @method
-     * @public
-     */
-    setGradientShapeUniform(uniform: WebGLShaderUniform, is_stroke: boolean, half_width: number, face: number, miter_limit: number, has_grid: boolean, matrix: Float32Array, inverse_matrix: Float32Array, viewport_width: number, viewport_height: number, grid: CanvasToWebGLContextGrid, is_radial: boolean, points: Float32Array, focal_point_ratio: number): void;
-}