@next2d/player 1.14.6 → 1.14.8

package/dist/webgl/shader/fragment/FragmentShaderSourceBlend.js

@@ -0,0 +1,319 @@
+import { FragmentShaderLibrary } from "./FragmentShaderLibrary";
+/**
+ * @class
+ */
+export class FragmentShaderSourceBlend {
+    /**
+     * @param  {string}  operation
+     * @param  {boolean} with_color_transform
+     * @return {string}
+     * @method
+     * @static
+     */
+    static TEMPLATE(operation, with_color_transform) {
+        let blendFunction;
+        switch (operation) {
+            case "subtract":
+                blendFunction = this.FUNCTION_SUBTRACT();
+                break;
+            case "multiply":
+                blendFunction = this.FUNCTION_MULTIPLY();
+                break;
+            case "lighten":
+                blendFunction = this.FUNCTION_LIGHTEN();
+                break;
+            case "darken":
+                blendFunction = this.FUNCTION_DARKEN();
+                break;
+            case "overlay":
+                blendFunction = this.FUNCTION_OVERLAY();
+                break;
+            case "hardlight":
+                blendFunction = this.FUNCTION_HARDLIGHT();
+                break;
+            case "difference":
+                blendFunction = this.FUNCTION_DIFFERENCE();
+                break;
+            case "invert":
+                blendFunction = this.FUNCTION_INVERT();
+                break;
+            default:
+                blendFunction = this.FUNCTION_NORMAL();
+                break;
+        }
+        const colorTransformUniform = with_color_transform
+            ? "uniform vec4 u_mediump[2];"
+            : "";
+        const colorTransformStatement = with_color_transform
+            ? FragmentShaderLibrary.STATEMENT_COLOR_TRANSFORM_ON(0)
+            : "";
+        return `#version 300 es
+precision mediump float;
+
+uniform sampler2D u_textures[2];
+${colorTransformUniform}
+
+in vec2 v_coord;
+out vec4 o_color;
+
+${blendFunction}
+
+void main() {
+    vec4 dst = texture(u_textures[0], v_coord);
+    vec4 src = texture(u_textures[1], v_coord);
+    ${colorTransformStatement}
+    o_color = blend(src, dst);
+}
+
+`;
+    }
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_NORMAL() {
+        return `
+
+vec4 blend (in vec4 src, in vec4 dst) {
+    return src + dst - dst * src.a;
+}
+
+`;
+    }
+    // 各ブレンド式は、前景と背景の両方のアルファを考慮する必要がある
+    // https://odashi.hatenablog.com/entry/20110921/1316610121
+    // https://hakuhin.jp/as3/blend.html
+    //
+    // [基本計算式]
+    // ・色(rgb)はストレートアルファ
+    // ・アルファ(a)が0の場合は例外処理をする
+    // 前景色 a: src.rgb * (src.a * (1.0 - dst.a))
+    // 背景色 b: dst.rgb * (dst.a * (1.0 - src.a))
+    // 合成色 c: mix.rgb * (src.a * dst.a)
+    // 最終結果: a + b + c
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_SUBTRACT() {
+        // [合成色計算式]
+        // dst - src
+        return `
+
+vec4 blend (in vec4 src, in vec4 dst) {
+    if (src.a == 0.0) { return dst; }
+    if (dst.a == 0.0) { return src; }
+
+    vec4 a = src - src * dst.a;
+    vec4 b = dst - dst * src.a;
+
+    src.rgb /= src.a;
+    dst.rgb /= dst.a;
+
+    vec4 c = vec4(dst.rgb - src.rgb, src.a * dst.a);
+    c.rgb *= c.a;
+
+    return a + b + c;
+}
+
+`;
+    }
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_MULTIPLY() {
+        // [合成色計算式]
+        // src * dst
+        return `
+
+vec4 blend (in vec4 src, in vec4 dst) {
+    vec4 a = src - src * dst.a;
+    vec4 b = dst - dst * src.a;
+    vec4 c = src * dst;
+
+    return a + b + c;
+}
+
+`;
+    }
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_LIGHTEN() {
+        // [合成色計算式]
+        // (src > dst) ? src : dst
+        return `
+
+vec4 blend (in vec4 src, in vec4 dst) {
+    if (src.a == 0.0) { return dst; }
+    if (dst.a == 0.0) { return src; }
+
+    vec4 a = src - src * dst.a;
+    vec4 b = dst - dst * src.a;
+
+    src.rgb /= src.a;
+    dst.rgb /= dst.a;
+
+    vec4 c = vec4(mix(src.rgb, dst.rgb, step(src.rgb, dst.rgb)), src.a * dst.a);
+    c.rgb *= c.a;
+
+    return a + b + c;
+}
+
+`;
+    }
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_DARKEN() {
+        // [合成色計算式]
+        // (src < dst) ? src : dst
+        return `
+
+vec4 blend (in vec4 src, in vec4 dst) {
+    if (src.a == 0.0) { return dst; }
+    if (dst.a == 0.0) { return src; }
+
+    vec4 a = src - src * dst.a;
+    vec4 b = dst - dst * src.a;
+
+    src.rgb /= src.a;
+    dst.rgb /= dst.a;
+
+    vec4 c = vec4(mix(src.rgb, dst.rgb, step(dst.rgb, src.rgb)), src.a * dst.a);
+    c.rgb *= c.a;
+
+    return a + b + c;
+}
+
+`;
+    }
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_OVERLAY() {
+        // [合成色計算式]
+        // if (dst < 0.5) {
+        //     return 2.0 * src * dst
+        // } else {
+        //     return 1.0 - 2.0 * (1.0 - src) * (1.0 - dst)
+        // }
+        return `
+
+vec4 blend (in vec4 src, in vec4 dst) {
+    if (src.a == 0.0) { return dst; }
+    if (dst.a == 0.0) { return src; }
+
+    vec4 a = src - src * dst.a;
+    vec4 b = dst - dst * src.a;
+
+    src.rgb /= src.a;
+    dst.rgb /= dst.a;
+
+    vec4 mul = src * dst;
+    vec3 c1 = 2.0 * mul.rgb;
+    vec3 c2 = 2.0 * (src.rgb + dst.rgb - mul.rgb) - 1.0;
+    vec4 c = vec4(mix(c1, c2, step(vec3(0.5), dst.rgb)), mul.a);
+    c.rgb *= c.a;
+
+    return a + b + c;
+}
+
+`;
+    }
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_HARDLIGHT() {
+        // [合成色計算式]
+        // if (src < 0.5) {
+        //     return 2.0 * src * dst
+        // } else {
+        //     return 1.0 - 2.0 * (1.0 - src) * (1.0 - dst)
+        // }
+        return `
+
+vec4 blend (in vec4 src, in vec4 dst) {
+    if (src.a == 0.0) { return dst; }
+    if (dst.a == 0.0) { return src; }
+
+    vec4 a = src - src * dst.a;
+    vec4 b = dst - dst * src.a;
+
+    src.rgb /= src.a;
+    dst.rgb /= dst.a;
+
+    vec4 mul = src * dst;
+    vec3 c1 = 2.0 * mul.rgb;
+    vec3 c2 = 2.0 * (src.rgb + dst.rgb - mul.rgb) - 1.0;
+    vec4 c = vec4(mix(c1, c2, step(vec3(0.5), src.rgb)), mul.a);
+    c.rgb *= c.a;
+
+    return a + b + c;
+}
+
+`;
+    }
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_DIFFERENCE() {
+        // [合成色計算式]
+        // abs(src - dst)
+        return `
+
+vec4 blend (in vec4 src, in vec4 dst) {
+    if (src.a == 0.0) { return dst; }
+    if (dst.a == 0.0) { return src; }
+
+    vec4 a = src - src * dst.a;
+    vec4 b = dst - dst * src.a;
+
+    src.rgb /= src.a;
+    dst.rgb /= dst.a;
+
+    vec4 c = vec4(abs(src.rgb - dst.rgb), src.a * dst.a);
+    c.rgb *= c.a;
+
+    return a + b + c;
+}
+
+`;
+    }
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static FUNCTION_INVERT() {
+        // [基本計算式]
+        // ((1.0 - dst) * src.a) + (dst * (1.0 - src.a))
+        return `
+
+vec4 blend (in vec4 src, in vec4 dst) {
+    if (src.a == 0.0) { return dst; }
+    if (dst.a == 0.0) { return src; }
+
+    vec4 b = dst - dst * src.a;
+    vec4 c = vec4(src.a - dst.rgb * src.a, src.a);
+
+    return b + c;
+}
+
+`;
+    }
+}

package/dist/webgl/shader/fragment/FragmentShaderSourceGradient.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @class
+ */
+export declare class FragmentShaderSourceGradient {
+    /**
+     * @param  {number}  highp_length
+     * @param  {number}  fragment_index
+     * @param  {boolean} is_radial
+     * @param  {boolean} has_focal_point
+     * @param  {string}  spread_method
+     * @return {string}
+     * @method
+     * @static
+     */
+    static TEMPLATE(highp_length: number, fragment_index: number, is_radial: boolean, has_focal_point: boolean, spread_method: string): string;
+    /**
+     * @param  {number} index
+     * @return {string}
+     * @method
+     * @static
+     */
+    static STATEMENT_GRADIENT_TYPE_LINEAR(index: number): string;
+    /**
+     * @param  {number}  index
+     * @param  {boolean} has_focal_point
+     * @return {string}
+     * @method
+     * @static
+     */
+    static STATEMENT_GRADIENT_TYPE_RADIAL(index: number, has_focal_point: boolean): string;
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static STATEMENT_FOCAL_POINT_OFF(): string;
+    /**
+     * @param  {number} index
+     * @return {string}
+     * @method
+     * @static
+     */
+    static STATEMENT_FOCAL_POINT_ON(index: number): string;
+}

package/dist/webgl/shader/fragment/FragmentShaderSourceGradient.js

@@ -0,0 +1,114 @@
+/**
+ * @class
+ */
+export class FragmentShaderSourceGradient {
+    /**
+     * @param  {number}  highp_length
+     * @param  {number}  fragment_index
+     * @param  {boolean} is_radial
+     * @param  {boolean} has_focal_point
+     * @param  {string}  spread_method
+     * @return {string}
+     * @method
+     * @static
+     */
+    static TEMPLATE(highp_length, fragment_index, is_radial, has_focal_point, spread_method) {
+        const gradientTypeStatement = is_radial
+            ? this.STATEMENT_GRADIENT_TYPE_RADIAL(fragment_index, has_focal_point)
+            : this.STATEMENT_GRADIENT_TYPE_LINEAR(fragment_index);
+        let spread_methodExpression;
+        switch (spread_method) {
+            case "reflect":
+                spread_methodExpression = "1.0 - abs(fract(t * 0.5) * 2.0 - 1.0)";
+                break;
+            case "repeat":
+                spread_methodExpression = "fract(t)";
+                break;
+            default:
+                spread_methodExpression = "clamp(t, 0.0, 1.0)";
+                break;
+        }
+        return `#version 300 es
+precision highp float;
+
+uniform sampler2D u_texture;
+uniform vec4 u_highp[${highp_length}];
+
+in vec2 v_uv;
+out vec4 o_color;
+
+void main() {
+    vec2 p = v_uv;
+    ${gradientTypeStatement}
+    t = ${spread_methodExpression};
+    o_color = texture(u_texture, vec2(t, 0.5));
+}
+
+`;
+    }
+    /**
+     * @param  {number} index
+     * @return {string}
+     * @method
+     * @static
+     */
+    static STATEMENT_GRADIENT_TYPE_LINEAR(index) {
+        return `
+    vec2 a = u_highp[${index}].xy;
+    vec2 b = u_highp[${index}].zw;
+
+    vec2 ab = b - a;
+    vec2 ap = p - a;
+
+    float t = dot(ab, ap) / dot(ab, ab);
+`;
+    }
+    /**
+     * @param  {number}  index
+     * @param  {boolean} has_focal_point
+     * @return {string}
+     * @method
+     * @static
+     */
+    static STATEMENT_GRADIENT_TYPE_RADIAL(index, has_focal_point) {
+        const focalPointStatement = has_focal_point
+            ? this.STATEMENT_FOCAL_POINT_ON(index)
+            : this.STATEMENT_FOCAL_POINT_OFF();
+        return `
+    float radius = u_highp[${index}][0];
+
+    vec2 coord = p / radius;
+    ${focalPointStatement}
+`;
+    }
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static STATEMENT_FOCAL_POINT_OFF() {
+        return `
+    float t = length(coord);
+`;
+    }
+    /**
+     * @param  {number} index
+     * @return {string}
+     * @method
+     * @static
+     */
+    static STATEMENT_FOCAL_POINT_ON(index) {
+        return `
+    vec2 focal = vec2(u_highp[${index}][1], 0.0);
+
+    vec2 dir = normalize(coord - focal);
+
+    float a = dot(dir, dir);
+    float b = 2.0 * dot(dir, focal);
+    float c = dot(focal, focal) - 1.0;
+    float x = (-b + sqrt(b * b - 4.0 * a * c)) / (2.0 * a);
+
+    float t = distance(focal, coord) / distance(focal, focal + dir * x);
+`;
+    }
+}

package/dist/webgl/shader/fragment/FragmentShaderSourceGradientLUT.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @class
+ */
+export declare class FragmentShaderSourceGradientLUT {
+    /**
+     * @param  {number}  mediump_length
+     * @param  {number}  stops_length
+     * @param  {boolean} is_linear_space
+     * @return {string}
+     * @method
+     * @static
+     */
+    static TEMPLATE(mediump_length: number, stops_length: number, is_linear_space: boolean): string;
+}

package/dist/webgl/shader/fragment/FragmentShaderSourceGradientLUT.js

@@ -0,0 +1,58 @@
+import { $Math } from "../../../player/util/RenderUtil";
+/**
+ * @class
+ */
+export class FragmentShaderSourceGradientLUT {
+    /**
+     * @param  {number}  mediump_length
+     * @param  {number}  stops_length
+     * @param  {boolean} is_linear_space
+     * @return {string}
+     * @method
+     * @static
+     */
+    static TEMPLATE(mediump_length, stops_length, is_linear_space) {
+        let loopStatement = "";
+        for (let i = 1; i < stops_length; i++) {
+            const i0 = i - 1;
+            const i1 = i;
+            const t0 = `u_mediump[${stops_length + $Math.floor(i0 / 4)}][${i0 % 4}]`;
+            const t1 = `u_mediump[${stops_length + $Math.floor(i1 / 4)}][${i1 % 4}]`;
+            const c0 = `u_mediump[${i0}]`;
+            const c1 = `u_mediump[${i1}]`;
+            loopStatement += `
+    if (t <= ${t1}) {
+        return mix(${c0}, ${c1}, (t - ${t0}) / (${t1} - ${t0}));
+    }
+`;
+        }
+        const colorSpaceStatement = is_linear_space
+            ? "color = pow(color, vec4(0.45454545));"
+            : "";
+        return `#version 300 es
+precision mediump float;
+
+uniform vec4 u_mediump[${mediump_length}];
+
+in vec2 v_coord;
+out vec4 o_color;
+
+vec4 getGradientColor(in float t) {
+    if (t <= u_mediump[${stops_length}][0]) {
+        return u_mediump[0];
+    }
+    ${loopStatement}
+    return u_mediump[${stops_length - 1}];
+}
+
+void main() {
+    vec4 color = getGradientColor(v_coord.x);
+    ${colorSpaceStatement}
+    color.rgb *= color.a;
+
+    o_color = color;
+}
+
+`;
+    }
+}

package/dist/webgl/shader/fragment/FragmentShaderSourceTexture.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @class
+ */
+export declare class FragmentShaderSourceTexture {
+    /**
+     * @param  {boolean} with_color_transform
+     * @return {string}
+     * @method
+     * @static
+     */
+    static TEMPLATE(with_color_transform: boolean): string;
+}

package/dist/webgl/shader/fragment/FragmentShaderSourceTexture.js

@@ -0,0 +1,36 @@
+import { FragmentShaderLibrary } from "./FragmentShaderLibrary";
+/**
+ * @class
+ */
+export class FragmentShaderSourceTexture {
+    /**
+     * @param  {boolean} with_color_transform
+     * @return {string}
+     * @method
+     * @static
+     */
+    static TEMPLATE(with_color_transform) {
+        const colorTransformUniform = with_color_transform
+            ? "uniform vec4 u_mediump[2];"
+            : "";
+        const colorTransformStatement = with_color_transform
+            ? FragmentShaderLibrary.STATEMENT_COLOR_TRANSFORM_ON(0)
+            : "";
+        return `#version 300 es
+precision mediump float;
+
+uniform sampler2D u_texture;
+${colorTransformUniform}
+
+in vec2 v_coord;
+out vec4 o_color;
+
+void main() {
+    vec4 src = texture(u_texture, v_coord);
+    ${colorTransformStatement}
+    o_color = src;
+}
+
+`;
+    }
+}

package/dist/webgl/shader/fragment/filter/FragmentShaderSourceBlurFilter.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @class
+ */
+export declare class FragmentShaderSourceBlurFilter {
+    /**
+     * @param  {number} half_blur
+     * @return {string}
+     * @method
+     * @static
+     */
+    static TEMPLATE(half_blur: number): string;
+}

package/dist/webgl/shader/fragment/filter/FragmentShaderSourceBlurFilter.js

@@ -0,0 +1,42 @@
+/**
+ * @class
+ */
+export class FragmentShaderSourceBlurFilter {
+    /**
+     * @param  {number} half_blur
+     * @return {string}
+     * @method
+     * @static
+     */
+    static TEMPLATE(half_blur) {
+        const halfBlurFixed = half_blur.toFixed(1);
+        return `#version 300 es
+precision mediump float;
+
+uniform sampler2D u_texture;
+uniform vec4 u_mediump;
+
+in vec2 v_coord;
+out vec4 o_color;
+
+void main() {
+    vec2  offset   = u_mediump.xy;
+    float fraction = u_mediump.z;
+    float samples  = u_mediump.w;
+    
+    vec4 color = texture(u_texture, v_coord);
+
+    for (float i = 1.0; i < ${halfBlurFixed}; i += 1.0) {
+        color += texture(u_texture, v_coord + offset * i);
+        color += texture(u_texture, v_coord - offset * i);
+    }
+    color += texture(u_texture, v_coord + offset * ${halfBlurFixed}) * fraction;
+    color += texture(u_texture, v_coord - offset * ${halfBlurFixed}) * fraction;
+    color /= samples;
+
+    o_color = color;
+}
+
+`;
+    }
+}

package/dist/webgl/shader/fragment/filter/FragmentShaderSourceColorMatrixFilter.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @class
+ */
+export declare class FragmentShaderSourceColorMatrixFilter {
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static TEMPLATE(): string;
+}

package/dist/webgl/shader/fragment/filter/FragmentShaderSourceColorMatrixFilter.js

@@ -0,0 +1,35 @@
+/**
+ * @class
+ */
+export class FragmentShaderSourceColorMatrixFilter {
+    /**
+     * @return {string}
+     * @method
+     * @static
+     */
+    static TEMPLATE() {
+        return `#version 300 es
+precision mediump float;
+
+uniform sampler2D u_texture;
+uniform vec4 u_mediump[5];
+
+in vec2 v_coord;
+out vec4 o_color;
+
+void main() {
+    mat4 mul = mat4(u_mediump[0], u_mediump[1], u_mediump[2], u_mediump[3]);
+    vec4 add = u_mediump[4];
+    
+    vec4 color = texture(u_texture, v_coord);
+
+    color.rgb /= max(0.0001, color.a);
+    color = clamp(color * mul + add, 0.0, 1.0);
+    color.rgb *= color.a;
+
+    o_color = color;
+}
+
+`;
+    }
+}