@next2d/webgl 1.14.20

package/dist/shader/WebGLShaderUniform.js

@@ -0,0 +1,165 @@
+import { $getMap, $Float32Array, $Int32Array } from "@next2d/share";
+/**
+ * @class
+ */
+export class WebGLShaderUniform {
+    /**
+     * @param {WebGL2RenderingContext} gl
+     * @param {WebGLProgram} program
+     * @constructor
+     * @public
+     */
+    constructor(gl, program) {
+        /**
+         * @type {WebGL2RenderingContext}
+         * @private
+         */
+        this._$gl = gl;
+        /**
+         * @type {array}
+         * @private
+         */
+        this._$array = [];
+        /**
+         * @type {Map}
+         * @private
+         */
+        this._$map = $getMap();
+        const activeUniforms = this._$gl.getProgramParameter(program, this._$gl.ACTIVE_UNIFORMS);
+        for (let i = 0; i < activeUniforms; i++) {
+            const info = this._$gl.getActiveUniform(program, i);
+            if (!info) {
+                throw new Error("the WebGLActiveInfo is null.");
+            }
+            const name = info.name.endsWith("[0]")
+                ? info.name.slice(0, -3)
+                : info.name;
+            const location = this._$gl.getUniformLocation(program, name);
+            if (!location) {
+                throw new Error("the WebGLUniformLocation is null.");
+            }
+            // WebGLの仕様でuniformのint型のデフォルト値は0に設定されるため、
+            // sampler2D（size=1）の値の更新は不要
+            if (info.type === this._$gl.SAMPLER_2D && info.size === 1) {
+                continue;
+            }
+            const data = {};
+            switch (info.type) {
+                // uniformの値の設定は、gl.uniform4[fi]v()が最速のため、
+                // 可能な限りFloat32Arrayに値をパックして転送するようにする
+                case this._$gl.FLOAT_VEC4:
+                    data.method = this._$gl.uniform4fv.bind(this._$gl, location);
+                    data.array = new $Float32Array(4 * info.size);
+                    data.assign = -1;
+                    break;
+                case this._$gl.INT_VEC4:
+                    data.method = this._$gl.uniform4iv.bind(this._$gl, location);
+                    data.array = new $Int32Array(4 * info.size);
+                    data.assign = -1;
+                    break;
+                // uniformの値の設定は、programに保持されるため、
+                // sampler2Dは一度だけ設定するようにする
+                case this._$gl.SAMPLER_2D:
+                    data.method = this._$gl.uniform1iv.bind(this._$gl, location);
+                    data.array = new $Int32Array(info.size);
+                    data.assign = 1;
+                    break;
+                case this._$gl.FLOAT:
+                case this._$gl.FLOAT_VEC2:
+                case this._$gl.FLOAT_VEC3:
+                case this._$gl.FLOAT_MAT2:
+                case this._$gl.FLOAT_MAT3:
+                case this._$gl.FLOAT_MAT4:
+                case this._$gl.INT:
+                case this._$gl.INT_VEC2:
+                case this._$gl.INT_VEC3:
+                default:
+                    throw new Error("Use gl.FLOAT_VEC4 or gl.INT_VEC4 instead");
+            }
+            this._$array.push(data);
+            this._$map.set(name, data);
+        }
+    }
+    /**
+     * @param  {string} name
+     * @return {Int32Array|Float32Array}
+     * @method
+     * @public
+     */
+    getArray(name) {
+        const data = this._$map.get(name);
+        if (!data || !data.array) {
+            throw new Error("the UniformData is null.");
+        }
+        return data.array;
+    }
+    /**
+     * @member {Int32Array|Float32Array}
+     * @readonly
+     * @public
+     */
+    get textures() {
+        const data = this._$map.get("u_textures");
+        if (!data || !data.array) {
+            throw new Error("the UniformData is null.");
+        }
+        return data.array;
+    }
+    /**
+     * @member {Int32Array|Float32Array}
+     * @readonly
+     * @public
+     */
+    get highp() {
+        const data = this._$map.get("u_highp");
+        if (!data || !data.array) {
+            throw new Error("the UniformData is null.");
+        }
+        return data.array;
+    }
+    /**
+     * @member {Int32Array|Float32Array}
+     * @readonly
+     * @public
+     */
+    get mediump() {
+        const data = this._$map.get("u_mediump");
+        if (!data || !data.array) {
+            throw new Error("the UniformData is null.");
+        }
+        return data.array;
+    }
+    /**
+     * @member {Int32Array|Float32Array}
+     * @readonly
+     * @public
+     */
+    get integer() {
+        const data = this._$map.get("u_integer");
+        if (!data || !data.array) {
+            throw new Error("the UniformData is null.");
+        }
+        return data.array;
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    bindUniforms() {
+        const length = this._$array.length;
+        for (let i = 0; i < length; i++) {
+            const data = this._$array[i];
+            if (data.method === undefined || data.assign === undefined) {
+                continue;
+            }
+            if (data.assign < 0) {
+                data.method(data.array);
+            }
+            else if (data.assign > 0) {
+                data.assign--;
+                data.method(data.array);
+            }
+        }
+    }
+}

package/dist/shader/fragment/FragmentShaderLibrary.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @class
+ */
+export declare class FragmentShaderLibrary {
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_IS_INSIDE(): string;
+    /**
+     * @param  {number} mediump_index
+     * @return {string}
+     * @method
+     * @static
+     */
+    static STATEMENT_COLOR_TRANSFORM_ON(mediump_index: number): string;
+}

package/dist/shader/fragment/FragmentShaderLibrary.js

@@ -0,0 +1,35 @@
+/**
+ * @class
+ */
+export class FragmentShaderLibrary {
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_IS_INSIDE() {
+        return `
+
+float isInside(in vec2 uv) {
+    return step(4.0, dot(step(vec4(0.0, uv.x, 0.0, uv.y), vec4(uv.x, 1.0, uv.y, 1.0)), vec4(1.0)));
+}
+
+`;
+    }
+    /**
+     * @param  {number} mediump_index
+     * @return {string}
+     * @method
+     * @static
+     */
+    static STATEMENT_COLOR_TRANSFORM_ON(mediump_index) {
+        return `
+    vec4 mul = u_mediump[${mediump_index}];
+    vec4 add = u_mediump[${mediump_index + 1}];
+
+    src.rgb /= max(0.0001, src.a);
+    src = clamp(src * mul + add, 0.0, 1.0);
+    src.rgb *= src.a;
+`;
+    }
+}

package/dist/shader/fragment/FragmentShaderSource.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @class
+ */
+export declare class FragmentShaderSource {
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static SOLID_COLOR(): string;
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static BITMAP_CLIPPED(): string;
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static BITMAP_PATTERN(): string;
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static MASK(): string;
+}

package/dist/shader/fragment/FragmentShaderSource.js

@@ -0,0 +1,99 @@
+import { FragmentShaderLibrary } from "./FragmentShaderLibrary";
+/**
+ * @class
+ */
+export class FragmentShaderSource {
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static SOLID_COLOR() {
+        return `#version 300 es
+precision mediump float;
+
+uniform vec4 u_mediump;
+
+out vec4 o_color;
+
+void main() {
+    o_color = vec4(u_mediump.rgb * u_mediump.a, u_mediump.a);
+}
+
+`;
+    }
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static BITMAP_CLIPPED() {
+        return `#version 300 es
+precision mediump float;
+
+uniform sampler2D u_texture;
+uniform vec4 u_mediump[3];
+
+in vec2 v_uv;
+out vec4 o_color;
+
+void main() {
+    vec2 uv = vec2(v_uv.x, u_mediump[0].y - v_uv.y) / u_mediump[0].xy;
+
+    vec4 src = texture(u_texture, uv);
+    ${FragmentShaderLibrary.STATEMENT_COLOR_TRANSFORM_ON(1)}
+    o_color = src;
+}`;
+    }
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static BITMAP_PATTERN() {
+        return `#version 300 es
+precision mediump float;
+
+uniform sampler2D u_texture;
+uniform vec4 u_mediump[3];
+
+in vec2 v_uv;
+out vec4 o_color;
+
+void main() {
+    vec2 uv = fract(vec2(v_uv.x, -v_uv.y) / u_mediump[0].xy);
+    
+    vec4 src = texture(u_texture, uv);
+    ${FragmentShaderLibrary.STATEMENT_COLOR_TRANSFORM_ON(1)}
+    o_color = src;
+}`;
+    }
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static MASK() {
+        return `#version 300 es
+precision mediump float;
+
+in vec2 v_bezier;
+out vec4 o_color;
+
+void main() {
+    vec2 px = dFdx(v_bezier);
+    vec2 py = dFdy(v_bezier);
+
+    vec2 f = (2.0 * v_bezier.x) * vec2(px.x, py.x) - vec2(px.y, py.y);
+    float alpha = 0.5 - (v_bezier.x * v_bezier.x - v_bezier.y) / length(f);
+
+    if (alpha > 0.0) {
+        o_color = vec4(min(alpha, 1.0));
+    } else {
+        discard;
+    }    
+}
+
+`;
+    }
+}

package/dist/shader/fragment/FragmentShaderSourceBlend.d.ts

@@ -0,0 +1,67 @@
+/**
+ * @class
+ */
+export declare class FragmentShaderSourceBlend {
+    /**
+     * @param  {string}  operation
+     * @param  {boolean} with_color_transform
+     * @return {string}
+     * @method
+     * @static
+     */
+    static TEMPLATE(operation: string, with_color_transform: boolean): string;
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_NORMAL(): string;
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_SUBTRACT(): string;
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_MULTIPLY(): string;
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_LIGHTEN(): string;
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_DARKEN(): string;
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_OVERLAY(): string;
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_HARDLIGHT(): string;
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_DIFFERENCE(): string;
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_INVERT(): string;
+}