@next2d/webgl 1.14.20

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Next2D
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+@next2d/webgl
+=============
+
+## Installation
+
+```
+npm install @next2d/webgl
+```
+
+## License
+This project is licensed under the [MIT License](https://opensource.org/licenses/MIT) - see the [LICENSE](LICENSE) file for details.

package/dist/BezierConverter.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @class
+ */
+export declare class BezierConverter {
+    readonly _$bezierConverterBuffer: Float32Array;
+    /**
+     * @constructor
+     * @public
+     */
+    constructor();
+    /**
+     * @param  {number} from_x
+     * @param  {number} from_y
+     * @param  {number} cx1
+     * @param  {number} cy1
+     * @param  {number} cx2
+     * @param  {number} cy2
+     * @param  {number} x
+     * @param  {number} y
+     * @return {void}
+     * @method
+     * @public
+     */
+    cubicToQuad(from_x: number, from_y: number, cx1: number, cy1: number, cx2: number, cy2: number, x: number, y: number): void;
+    /**
+     * @description 3次ベジェを、2つの3次ベジェに分割する
+     * @param  {number} p0
+     * @param  {number} p1
+     * @param  {number} p2
+     * @param  {number} p3
+     * @param  {number} p4
+     * @param  {number} p5
+     * @param  {number} p6
+     * @param  {number} p7
+     * @param  {number} offset1
+     * @param  {number} offset2
+     * @return void
+     * @method
+     * @private
+     */
+    _$split2Cubic(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, offset1: number, offset2: number): void;
+    /**
+     * @description 3次ベジェを、2つの2次ベジェに変換する
+     *
+     * @param  {number} p0
+     * @param  {number} p1
+     * @param  {number} p2
+     * @param  {number} p3
+     * @param  {number} p4
+     * @param  {number} p5
+     * @param  {number} p6
+     * @param  {number} p7
+     * @param  {number} offset
+     * @return {void}
+     * @method
+     * @private
+     */
+    _$split2Quad(p0: number, p1: number, p2: number, p3: number, p4: number, p5: number, p6: number, p7: number, offset: number): void;
+}

package/dist/BezierConverter.js

@@ -0,0 +1,106 @@
+import { $Float32Array } from "@next2d/share";
+/**
+ * @class
+ */
+export class BezierConverter {
+    /**
+     * @constructor
+     * @public
+     */
+    constructor() {
+        this._$bezierConverterBuffer = new $Float32Array(32);
+    }
+    /**
+     * @param  {number} from_x
+     * @param  {number} from_y
+     * @param  {number} cx1
+     * @param  {number} cy1
+     * @param  {number} cx2
+     * @param  {number} cy2
+     * @param  {number} x
+     * @param  {number} y
+     * @return {void}
+     * @method
+     * @public
+     */
+    cubicToQuad(from_x, from_y, cx1, cy1, cx2, cy2, x, y) {
+        this._$split2Cubic(from_x, from_y, cx1, cy1, cx2, cy2, x, y, 0, 16);
+        this._$split2Cubic(this._$bezierConverterBuffer[0], this._$bezierConverterBuffer[1], this._$bezierConverterBuffer[2], this._$bezierConverterBuffer[3], this._$bezierConverterBuffer[4], this._$bezierConverterBuffer[5], this._$bezierConverterBuffer[6], this._$bezierConverterBuffer[7], 0, 8);
+        this._$split2Cubic(this._$bezierConverterBuffer[16], this._$bezierConverterBuffer[17], this._$bezierConverterBuffer[18], this._$bezierConverterBuffer[19], this._$bezierConverterBuffer[20], this._$bezierConverterBuffer[21], this._$bezierConverterBuffer[22], this._$bezierConverterBuffer[23], 16, 24);
+        this._$split2Quad(this._$bezierConverterBuffer[0], this._$bezierConverterBuffer[1], this._$bezierConverterBuffer[2], this._$bezierConverterBuffer[3], this._$bezierConverterBuffer[4], this._$bezierConverterBuffer[5], this._$bezierConverterBuffer[6], this._$bezierConverterBuffer[7], 0);
+        this._$split2Quad(this._$bezierConverterBuffer[8], this._$bezierConverterBuffer[9], this._$bezierConverterBuffer[10], this._$bezierConverterBuffer[11], this._$bezierConverterBuffer[12], this._$bezierConverterBuffer[13], this._$bezierConverterBuffer[14], this._$bezierConverterBuffer[15], 8);
+        this._$split2Quad(this._$bezierConverterBuffer[16], this._$bezierConverterBuffer[17], this._$bezierConverterBuffer[18], this._$bezierConverterBuffer[19], this._$bezierConverterBuffer[20], this._$bezierConverterBuffer[21], this._$bezierConverterBuffer[22], this._$bezierConverterBuffer[23], 16);
+        this._$split2Quad(this._$bezierConverterBuffer[24], this._$bezierConverterBuffer[25], this._$bezierConverterBuffer[26], this._$bezierConverterBuffer[27], this._$bezierConverterBuffer[28], this._$bezierConverterBuffer[29], this._$bezierConverterBuffer[30], this._$bezierConverterBuffer[31], 24);
+    }
+    /**
+     * @description 3次ベジェを、2つの3次ベジェに分割する
+     * @param  {number} p0
+     * @param  {number} p1
+     * @param  {number} p2
+     * @param  {number} p3
+     * @param  {number} p4
+     * @param  {number} p5
+     * @param  {number} p6
+     * @param  {number} p7
+     * @param  {number} offset1
+     * @param  {number} offset2
+     * @return void
+     * @method
+     * @private
+     */
+    _$split2Cubic(p0, p1, p2, p3, p4, p5, p6, p7, offset1, offset2) {
+        const mx = (p0 + 3 * (p2 + p4) + p6) * 0.125;
+        const my = (p1 + 3 * (p3 + p5) + p7) * 0.125;
+        const dx = (p6 + p4 - p2 - p0) * 0.125;
+        const dy = (p7 + p5 - p3 - p1) * 0.125;
+        this._$bezierConverterBuffer[offset1] = p0;
+        this._$bezierConverterBuffer[offset1 + 1] = p1;
+        this._$bezierConverterBuffer[offset1 + 2] = (p0 + p2) * 0.5;
+        this._$bezierConverterBuffer[offset1 + 3] = (p1 + p3) * 0.5;
+        this._$bezierConverterBuffer[offset1 + 4] = mx - dx;
+        this._$bezierConverterBuffer[offset1 + 5] = my - dy;
+        this._$bezierConverterBuffer[offset1 + 6] = mx;
+        this._$bezierConverterBuffer[offset1 + 7] = my;
+        this._$bezierConverterBuffer[offset2] = mx;
+        this._$bezierConverterBuffer[offset2 + 1] = my;
+        this._$bezierConverterBuffer[offset2 + 2] = mx + dx;
+        this._$bezierConverterBuffer[offset2 + 3] = my + dy;
+        this._$bezierConverterBuffer[offset2 + 4] = (p4 + p6) * 0.5;
+        this._$bezierConverterBuffer[offset2 + 5] = (p5 + p7) * 0.5;
+        this._$bezierConverterBuffer[offset2 + 6] = p6;
+        this._$bezierConverterBuffer[offset2 + 7] = p7;
+    }
+    /**
+     * @description 3次ベジェを、2つの2次ベジェに変換する
+     *
+     * @param  {number} p0
+     * @param  {number} p1
+     * @param  {number} p2
+     * @param  {number} p3
+     * @param  {number} p4
+     * @param  {number} p5
+     * @param  {number} p6
+     * @param  {number} p7
+     * @param  {number} offset
+     * @return {void}
+     * @method
+     * @private
+     */
+    _$split2Quad(p0, p1, p2, p3, p4, p5, p6, p7, offset) {
+        const mx = (p0 + 3 * (p2 + p4) + p6) * 0.125;
+        const my = (p1 + 3 * (p3 + p5) + p7) * 0.125;
+        // 2次ベジェの始点の値は不要なので含めない
+        // this.result[offset - 2] = p0;
+        // this.result[offset - 1] = p1;
+        this._$bezierConverterBuffer[offset] = p0 * 0.25 + p2 * 0.75;
+        this._$bezierConverterBuffer[offset + 1] = p1 * 0.25 + p3 * 0.75;
+        this._$bezierConverterBuffer[offset + 2] = mx;
+        this._$bezierConverterBuffer[offset + 3] = my;
+        // this.result[offset + 2] = mx;
+        // this.result[offset + 3] = my;
+        this._$bezierConverterBuffer[offset + 4] = p4 * 0.75 + p6 * 0.25;
+        this._$bezierConverterBuffer[offset + 5] = p5 * 0.75 + p7 * 0.25;
+        this._$bezierConverterBuffer[offset + 6] = p6;
+        this._$bezierConverterBuffer[offset + 7] = p7;
+    }
+}

package/dist/CanvasGradientToWebGL.d.ts

@@ -0,0 +1,96 @@
+import type { InterpolationMethodImpl } from "./interface/InterpolationMethodImpl";
+import type { SpreadMethodImpl } from "./interface/SpreadMethodImpl";
+import type { GradientTypeImpl } from "./interface/GradientTypeImpl";
+/**
+ * @class
+ */
+export declare class CanvasGradientToWebGL {
+    private _$rgb;
+    private _$mode;
+    private _$type;
+    private _$focalPointRatio;
+    private readonly _$points;
+    private readonly _$stops;
+    /**
+     * @constructor
+     * @public
+     */
+    constructor();
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    dispose(): void;
+    /**
+     * @member {string}
+     * @readonly
+     * @public
+     */
+    get mode(): SpreadMethodImpl;
+    /**
+     * @member {string}
+     * @readonly
+     * @public
+     */
+    get type(): GradientTypeImpl;
+    /**
+     * @member {string}
+     * @readonly
+     * @public
+     */
+    get rgb(): InterpolationMethodImpl;
+    /**
+     * @member {Float32Array}
+     * @readonly
+     * @public
+     */
+    get points(): Float32Array;
+    /**
+     * @member {number}
+     * @readonly
+     * @public
+     */
+    get focalPointRatio(): number;
+    /**
+     * @member {array}
+     * @readonly
+     * @public
+     */
+    get stops(): any[];
+    /**
+     * @param  {number} x0
+     * @param  {number} y0
+     * @param  {number} x1
+     * @param  {number} y1
+     * @param  {string} [rgb=InterpolationMethod.RGB]
+     * @param  {string} [mode=SpreadMethod.PAD]
+     * @return {CanvasGradientToWebGL}
+     * @method
+     * @public
+     */
+    linear(x0: number, y0: number, x1: number, y1: number, rgb?: InterpolationMethodImpl, mode?: SpreadMethodImpl): CanvasGradientToWebGL;
+    /**
+     * @param  {number} x0
+     * @param  {number} y0
+     * @param  {number} r0
+     * @param  {number} x1
+     * @param  {number} y1
+     * @param  {number} r1
+     * @param  {string} [rgb=InterpolationMethod.RGB]
+     * @param  {string} [mode=SpreadMethod.PAD]
+     * @param  {number} [focal_point_ratio=0]
+     * @return {CanvasGradientToWebGL}
+     * @method
+     * @public
+     */
+    radial(x0: number, y0: number, r0: number, x1: number, y1: number, r1: number, rgb?: InterpolationMethodImpl, mode?: SpreadMethodImpl, focal_point_ratio?: number): CanvasGradientToWebGL;
+    /**
+     * @param  {number} offset
+     * @param  {Float32Array} color
+     * @return {void}
+     * @method
+     * @public
+     */
+    addColorStop(offset: number, color: Float32Array): void;
+}

package/dist/CanvasGradientToWebGL.js

@@ -0,0 +1,181 @@
+import { $getFloat32Array6, $getArray, $clamp, $poolFloat32Array4, $poolFloat32Array6 } from "@next2d/share";
+/**
+ * @class
+ */
+export class CanvasGradientToWebGL {
+    /**
+     * @constructor
+     * @public
+     */
+    constructor() {
+        /**
+         * @type {string}
+         * @default InterpolationMethod.RGB
+         * @private
+         */
+        this._$rgb = "rgb";
+        /**
+         * @type {string}
+         * @default SpreadMethod.PAD
+         * @private
+         */
+        this._$mode = "pad";
+        /**
+         * @type {string}
+         * @default GradientType.LINEAR
+         * @private
+         */
+        this._$type = "linear";
+        /**
+         * @type {number}
+         * @default 0
+         * @private
+         */
+        this._$focalPointRatio = 0;
+        /**
+         * @type {Float32Array}
+         * @private
+         */
+        this._$points = $getFloat32Array6();
+        /**
+         * @type {array}
+         * @private
+         */
+        this._$stops = $getArray();
+    }
+    /**
+     * @return {void}
+     * @method
+     * @public
+     */
+    dispose() {
+        const stops = this._$stops;
+        for (let idx = 0; idx < stops.length; ++idx) {
+            $poolFloat32Array4(stops[idx][1]);
+        }
+        $poolFloat32Array6(this._$points);
+    }
+    /**
+     * @member {string}
+     * @readonly
+     * @public
+     */
+    get mode() {
+        return this._$mode;
+    }
+    /**
+     * @member {string}
+     * @readonly
+     * @public
+     */
+    get type() {
+        return this._$type;
+    }
+    /**
+     * @member {string}
+     * @readonly
+     * @public
+     */
+    get rgb() {
+        return this._$rgb;
+    }
+    /**
+     * @member {Float32Array}
+     * @readonly
+     * @public
+     */
+    get points() {
+        return this._$points;
+    }
+    /**
+     * @member {number}
+     * @readonly
+     * @public
+     */
+    get focalPointRatio() {
+        return this._$focalPointRatio;
+    }
+    /**
+     * @member {array}
+     * @readonly
+     * @public
+     */
+    get stops() {
+        // sort
+        this._$stops.sort((a, b) => {
+            switch (true) {
+                case a[0] > b[0]:
+                    return 1;
+                case b[0] > a[0]:
+                    return -1;
+                default:
+                    return 0;
+            }
+        });
+        return this._$stops;
+    }
+    /**
+     * @param  {number} x0
+     * @param  {number} y0
+     * @param  {number} x1
+     * @param  {number} y1
+     * @param  {string} [rgb=InterpolationMethod.RGB]
+     * @param  {string} [mode=SpreadMethod.PAD]
+     * @return {CanvasGradientToWebGL}
+     * @method
+     * @public
+     */
+    linear(x0, y0, x1, y1, rgb = "rgb", mode = "pad") {
+        this._$type = "linear";
+        this._$points[0] = x0;
+        this._$points[1] = y0;
+        this._$points[2] = x1;
+        this._$points[3] = y1;
+        this._$rgb = rgb;
+        this._$mode = mode;
+        if (this._$stops.length) {
+            this._$stops.length = 0;
+        }
+        return this;
+    }
+    /**
+     * @param  {number} x0
+     * @param  {number} y0
+     * @param  {number} r0
+     * @param  {number} x1
+     * @param  {number} y1
+     * @param  {number} r1
+     * @param  {string} [rgb=InterpolationMethod.RGB]
+     * @param  {string} [mode=SpreadMethod.PAD]
+     * @param  {number} [focal_point_ratio=0]
+     * @return {CanvasGradientToWebGL}
+     * @method
+     * @public
+     */
+    radial(x0, y0, r0, x1, y1, r1, rgb = "rgb", mode = "pad", focal_point_ratio = 0) {
+        this._$type = "radial";
+        this._$points[0] = x0;
+        this._$points[1] = y0;
+        this._$points[2] = r0;
+        this._$points[3] = x1;
+        this._$points[4] = y1;
+        this._$points[5] = r1;
+        this._$rgb = rgb;
+        this._$mode = mode;
+        this._$focalPointRatio = $clamp(focal_point_ratio, -0.975, 0.975, 0);
+        if (this._$stops.length) {
+            this._$stops.length = 0;
+        }
+        return this;
+    }
+    /**
+     * @param  {number} offset
+     * @param  {Float32Array} color
+     * @return {void}
+     * @method
+     * @public
+     */
+    addColorStop(offset, color) {
+        this._$stops.push($getArray(offset, color));
+    }
+}

package/dist/CanvasPatternToWebGL.d.ts

@@ -0,0 +1,39 @@
+import type { CanvasToWebGLContext } from "./CanvasToWebGLContext";
+/**
+ * @class
+ */
+export declare class CanvasPatternToWebGL {
+    private readonly _$context;
+    private readonly _$texture;
+    private readonly _$repeat;
+    private readonly _$colorTransform;
+    /**
+     * @constructor
+     * @public
+     */
+    constructor(context: CanvasToWebGLContext, texture: WebGLTexture, repeat: boolean, color_transform: Float32Array);
+    /**
+     * @return {void}
+     * @method
+     * @private
+     */
+    dispose(): void;
+    /**
+     * @member {WebGLTexture}
+     * @readonly
+     * @public
+     */
+    get texture(): WebGLTexture;
+    /**
+     * @member {boolean}
+     * @readonly
+     * @public
+     */
+    get repeat(): boolean;
+    /**
+     * @member {Float32Array}
+     * @readonly
+     * @public
+     */
+    get colorTransform(): Float32Array;
+}

package/dist/CanvasPatternToWebGL.js

@@ -0,0 +1,66 @@
+/**
+ * @class
+ */
+export class CanvasPatternToWebGL {
+    /**
+     * @constructor
+     * @public
+     */
+    constructor(context, texture, repeat, color_transform) {
+        /**
+         * @type {CanvasToWebGLContext}
+         * @private
+         */
+        this._$context = context;
+        /**
+         * @type {WebGLTexture}
+         * @private
+         */
+        this._$texture = texture;
+        /**
+         * @type {string}
+         * @private
+         */
+        this._$repeat = repeat;
+        /**
+         * @type {Float32Array}
+         * @private
+         */
+        this._$colorTransform = color_transform;
+    }
+    /**
+     * @return {void}
+     * @method
+     * @private
+     */
+    dispose() {
+        this
+            ._$context
+            .frameBuffer
+            .releaseTexture(this._$texture);
+    }
+    /**
+     * @member {WebGLTexture}
+     * @readonly
+     * @public
+     */
+    get texture() {
+        return this._$texture;
+    }
+    /**
+     * @member {boolean}
+     * @readonly
+     * @public
+     */
+    get repeat() {
+        return this._$repeat;
+    }
+    /**
+     * @member {Float32Array}
+     * @readonly
+     * @public
+     */
+    get colorTransform() {
+        return this._$colorTransform;
+    }
+}