@next2d/player 1.14.7 → 1.14.8

package/dist/player/index.js

@@ -0,0 +1,40 @@
+"use strict";
+import { $currentPlayer, $initialize, $isSafari, $rendererWorker } from "./util/Util";
+import { Next2D } from "./player/Next2D";
+if (!("next2d" in window)) {
+    console.log("%c Next2D Player %c 1.14.8 %c https://next2d.app", "color: #fff; background: #5f5f5f", "color: #fff; background: #4bc729", "");
+    // @ts-ignore
+    window.next2d = new Next2D([new Promise((resolve) => {
+            if (document.readyState === "loading") {
+                const initialize = () => {
+                    window.removeEventListener("DOMContentLoaded", initialize);
+                    $initialize()
+                        .then(() => {
+                        if ($rendererWorker) {
+                            $rendererWorker.postMessage({
+                                "command": "setSafari",
+                                "isSafari": $isSafari
+                            });
+                        }
+                        $currentPlayer()._$initializeCanvas();
+                        resolve();
+                    });
+                };
+                // @ts-ignore
+                window.addEventListener("DOMContentLoaded", initialize);
+            }
+            else {
+                $initialize()
+                    .then(() => {
+                    if ($rendererWorker) {
+                        $rendererWorker.postMessage({
+                            "command": "setSafari",
+                            "isSafari": $isSafari
+                        });
+                    }
+                    $currentPlayer()._$initializeCanvas();
+                    resolve();
+                });
+            }
+        })]);
+}

package/dist/player/next2d/display/BitmapData.d.ts

@@ -0,0 +1,143 @@
+import type { DisplayObjectImpl } from "../../../interface/DisplayObjectImpl";
+import type { Matrix } from "../geom/Matrix";
+import type { ColorTransform } from "../geom/ColorTransform";
+/**
+ * BitmapData クラスを使用すると、Bitmap オブジェクトのデータ (ピクセル) を処理できます。
+ * BitmapData クラスのメソッドを使用して、任意のサイズの透明または不透明のビットマップイメージを作成し
+ * 実行時に様々な方法で操作できます。
+ *
+ * The BitmapData class lets you work with the data (pixels) of a Bitmap object.
+ * You can use the methods of the BitmapData class to create arbitrarily sized transparent or
+ * opaque bitmap images and manipulate them in various ways at runtime.
+ *
+ * @class
+ * @memberOf next2d.display
+ */
+export declare class BitmapData {
+    private readonly _$instanceId;
+    private _$width;
+    private _$height;
+    _$buffer: Uint8Array | null;
+    private _$image;
+    private _$canvas;
+    private _$pixelBuffer;
+    /**
+     * @param {number} [width=0]
+     * @param {number} [height=0]
+     * @constructor
+     * @public
+     */
+    constructor(width?: number, height?: number);
+    /**
+     * @description 指定されたクラスのストリングを返します。
+     *              Returns the string representation of the specified class.
+     *
+     * @return  {string}
+     * @default [class BitmapData]
+     * @method
+     * @static
+     */
+    static toString(): string;
+    /**
+     * @description 指定されたクラスの空間名を返します。
+     *              Returns the space name of the specified class.
+     *
+     * @return  {string}
+     * @default next2d.display.BitmapData
+     * @const
+     * @static
+     */
+    static get namespace(): string;
+    /**
+     * @description 指定されたオブジェクトのストリングを返します。
+     *              Returns the string representation of the specified object.
+     *
+     * @return  {string}
+     * @default [object BitmapData]
+     * @method
+     * @public
+     */
+    toString(): string;
+    /**
+     * @description 指定されたオブジェクトの空間名を返します。
+     *              Returns the space name of the specified object.
+     *
+     * @return  {string}
+     * @default next2d.display.BitmapData
+     * @const
+     * @public
+     */
+    get namespace(): string;
+    /**
+     * @description ビットマップイメージの高さ（ピクセル単位）です。
+     *              The height of the bitmap image in pixels.
+     *
+     * @return  {number}
+     * @readonly
+     * @public
+     */
+    get height(): number;
+    /**
+     * @description Uint8Arrayを利用して BitmapData を生成します。
+     *              Generates BitmapData using Uint8Array.
+     *
+     * @return {Uint8Array}
+     * @public
+     */
+    get buffer(): Uint8Array | null;
+    set buffer(buffer: Uint8Array | null);
+    /**
+     * @description Imageクラスを利用して BitmapData を生成します。
+     *              Use the Image class to generate BitmapData.
+     *
+     * @return {HTMLImageElement}
+     * @public
+     */
+    get image(): HTMLImageElement | null;
+    set image(image: HTMLImageElement | null);
+    /**
+     * @description Canvasクラス利用して BitmapData を生成します。
+     *              Use the Canvas class to generate BitmapData.
+     *
+     * @return {HTMLCanvasElement}
+     * @public
+     */
+    get canvas(): HTMLCanvasElement | null;
+    set canvas(canvas: HTMLCanvasElement | null);
+    /**
+     * @description ビットマップイメージの幅（ピクセル単位）です。
+     *              The width of the bitmap image in pixels.
+     *
+     * @return  {number}
+     * @readonly
+     * @public
+     */
+    get width(): number;
+    /**
+     * @description 新しいオブジェクトとして、このクラスのクローンを返します。
+     *              含まれるオブジェクトはまったく同じコピーになります。
+     *              Returns a clone of this class as a new object,
+     *              with an exact copy of the contained object.
+     *
+     * @return {BitmapData}
+     * @method
+     * @public
+     */
+    clone(): BitmapData;
+    /**
+     * @member {WebGLTexture}
+     * @method
+     * @private
+     */
+    getTexture(): WebGLTexture | null;
+    /**
+     * @param  {DisplayObject}     source
+     * @param  {Matrix}            [matrix=null]
+     * @param  {ColorTransform}    [color_transform=null]
+     * @param  {HTMLCanvasElement} [canvas=null]
+     * @param  {function}          [callback=null]
+     * @return {void}
+     * @public
+     */
+    draw(source: DisplayObjectImpl<any>, matrix?: Matrix | null, color_transform?: ColorTransform | null, canvas?: HTMLCanvasElement | null, callback?: Function | null): void;
+}

package/dist/player/next2d/display/BitmapData.js

@@ -0,0 +1,390 @@
+import { DisplayObjectContainer } from "./DisplayObjectContainer";
+import { $getInstanceId } from "../../util/Global";
+import { $bitmapDrawMap, $currentPlayer, $poolColorTransform, $poolMatrix, $postContainerWorker, $rendererWorker } from "../../util/Util";
+import { $COLOR_ARRAY_IDENTITY, $getArray, $MATRIX_ARRAY_IDENTITY, $multiplicationMatrix, $poolArray } from "../../util/RenderUtil";
+/**
+ * BitmapData クラスを使用すると、Bitmap オブジェクトのデータ (ピクセル) を処理できます。
+ * BitmapData クラスのメソッドを使用して、任意のサイズの透明または不透明のビットマップイメージを作成し
+ * 実行時に様々な方法で操作できます。
+ *
+ * The BitmapData class lets you work with the data (pixels) of a Bitmap object.
+ * You can use the methods of the BitmapData class to create arbitrarily sized transparent or
+ * opaque bitmap images and manipulate them in various ways at runtime.
+ *
+ * @class
+ * @memberOf next2d.display
+ */
+export class BitmapData {
+    _$instanceId;
+    _$width;
+    _$height;
+    _$buffer;
+    _$image;
+    _$canvas;
+    _$pixelBuffer;
+    /**
+     * @param {number} [width=0]
+     * @param {number} [height=0]
+     * @constructor
+     * @public
+     */
+    constructor(width = 0, height = 0) {
+        /**
+         * @type {number}
+         * @private
+         */
+        this._$instanceId = $getInstanceId();
+        /**
+         * @type {number}
+         * @default 0
+         * @private
+         */
+        this._$width = width | 0;
+        /**
+         * @type {number}
+         * @default 0
+         * @private
+         */
+        this._$height = height | 0;
+        /**
+         * @type {Uint8Array}
+         * @default null
+         * @private
+         */
+        this._$buffer = null;
+        /**
+         * @type {HTMLImageElement}
+         * @default null
+         * @private
+         */
+        this._$image = null;
+        /**
+         * @type {HTMLCanvasElement}
+         * @default null
+         * @private
+         */
+        this._$canvas = null;
+        /**
+         * @type {WebGLBuffer}
+         * @type {null}
+         * @private
+         */
+        this._$pixelBuffer = null;
+    }
+    /**
+     * @description 指定されたクラスのストリングを返します。
+     *              Returns the string representation of the specified class.
+     *
+     * @return  {string}
+     * @default [class BitmapData]
+     * @method
+     * @static
+     */
+    static toString() {
+        return "[class BitmapData]";
+    }
+    /**
+     * @description 指定されたクラスの空間名を返します。
+     *              Returns the space name of the specified class.
+     *
+     * @return  {string}
+     * @default next2d.display.BitmapData
+     * @const
+     * @static
+     */
+    static get namespace() {
+        return "next2d.display.BitmapData";
+    }
+    /**
+     * @description 指定されたオブジェクトのストリングを返します。
+     *              Returns the string representation of the specified object.
+     *
+     * @return  {string}
+     * @default [object BitmapData]
+     * @method
+     * @public
+     */
+    toString() {
+        return "[object BitmapData]";
+    }
+    /**
+     * @description 指定されたオブジェクトの空間名を返します。
+     *              Returns the space name of the specified object.
+     *
+     * @return  {string}
+     * @default next2d.display.BitmapData
+     * @const
+     * @public
+     */
+    get namespace() {
+        return "next2d.display.BitmapData";
+    }
+    /**
+     * @description ビットマップイメージの高さ（ピクセル単位）です。
+     *              The height of the bitmap image in pixels.
+     *
+     * @return  {number}
+     * @readonly
+     * @public
+     */
+    get height() {
+        return this._$height;
+    }
+    /**
+     * @description Uint8Arrayを利用して BitmapData を生成します。
+     *              Generates BitmapData using Uint8Array.
+     *
+     * @return {Uint8Array}
+     * @public
+     */
+    get buffer() {
+        return this._$buffer;
+    }
+    set buffer(buffer) {
+        this._$buffer = buffer;
+    }
+    /**
+     * @description Imageクラスを利用して BitmapData を生成します。
+     *              Use the Image class to generate BitmapData.
+     *
+     * @return {HTMLImageElement}
+     * @public
+     */
+    get image() {
+        return this._$image;
+    }
+    set image(image) {
+        this._$canvas = null;
+        this._$image = image;
+        if (!image) {
+            return;
+        }
+        this._$width = image.width;
+        this._$height = image.height;
+    }
+    /**
+     * @description Canvasクラス利用して BitmapData を生成します。
+     *              Use the Canvas class to generate BitmapData.
+     *
+     * @return {HTMLCanvasElement}
+     * @public
+     */
+    get canvas() {
+        return this._$canvas;
+    }
+    set canvas(canvas) {
+        this._$image = null;
+        this._$canvas = canvas;
+        if (!canvas) {
+            return;
+        }
+        this._$width = canvas.width;
+        this._$height = canvas.height;
+    }
+    /**
+     * @description ビットマップイメージの幅（ピクセル単位）です。
+     *              The width of the bitmap image in pixels.
+     *
+     * @return  {number}
+     * @readonly
+     * @public
+     */
+    get width() {
+        return this._$width;
+    }
+    /**
+     * @description 新しいオブジェクトとして、このクラスのクローンを返します。
+     *              含まれるオブジェクトはまったく同じコピーになります。
+     *              Returns a clone of this class as a new object,
+     *              with an exact copy of the contained object.
+     *
+     * @return {BitmapData}
+     * @method
+     * @public
+     */
+    clone() {
+        const bitmapData = new BitmapData(this.width, this.height);
+        if (this._$image !== null || this._$canvas !== null) {
+            const player = $currentPlayer();
+            const cacheStore = player.cacheStore;
+            const canvas = cacheStore.getCanvas();
+            canvas.width = this.width;
+            canvas.height = this.height;
+            const context = canvas.getContext("2d");
+            if (!context) {
+                throw new Error("the context is null.");
+            }
+            // @ts-ignore
+            context.drawImage(this._$image || this._$canvas, 0, 0);
+            bitmapData.canvas = canvas;
+        }
+        else if (this._$buffer !== null) {
+            bitmapData._$buffer = this._$buffer.slice();
+        }
+        return bitmapData;
+    }
+    /**
+     * @member {WebGLTexture}
+     * @method
+     * @private
+     */
+    getTexture() {
+        const { width, height } = this;
+        if (!width || !height) {
+            return null;
+        }
+        const player = $currentPlayer();
+        const context = player.context;
+        if (!context) {
+            throw new Error("the context is null.");
+        }
+        if (this._$image !== null) {
+            return context
+                .frameBuffer
+                .createTextureFromImage(this._$image);
+        }
+        if (this._$canvas !== null) {
+            return context
+                .frameBuffer
+                .createTextureFromCanvas(this._$canvas);
+        }
+        if (this._$buffer !== null) {
+            return context
+                .frameBuffer
+                .createTextureFromPixels(width, height, this._$buffer, true);
+        }
+        return null;
+    }
+    /**
+     * @param  {DisplayObject}     source
+     * @param  {Matrix}            [matrix=null]
+     * @param  {ColorTransform}    [color_transform=null]
+     * @param  {HTMLCanvasElement} [canvas=null]
+     * @param  {function}          [callback=null]
+     * @return {void}
+     * @public
+     */
+    draw(source, matrix = null, color_transform = null, canvas = null, callback = null) {
+        const { width, height } = this;
+        if (!width || !height) {
+            return;
+        }
+        const player = $currentPlayer();
+        const cacheWidth = player._$width;
+        const cacheHeight = player._$height;
+        const resize = width > cacheWidth || height > cacheHeight;
+        if (resize) {
+            player._$width = width;
+            player._$height = height;
+            player._$resizeCanvas(width, height, player.scaleX);
+        }
+        const colorTransform = color_transform
+            ? color_transform._$colorTransform
+            : $COLOR_ARRAY_IDENTITY;
+        let tMatrix = matrix
+            ? matrix._$matrix
+            : $MATRIX_ARRAY_IDENTITY;
+        if (matrix) {
+            const matrix = source._$transform.matrix;
+            matrix.invert();
+            tMatrix = $multiplicationMatrix(tMatrix, matrix._$matrix);
+            $poolMatrix(matrix);
+        }
+        if (!canvas) {
+            canvas = player.cacheStore.getCanvas();
+        }
+        if ($rendererWorker) {
+            if (!source._$stage) {
+                if (source instanceof DisplayObjectContainer) {
+                    if ($postContainerWorker) {
+                        $postContainerWorker(source);
+                    }
+                }
+                else {
+                    source._$createWorkerInstance();
+                    source._$postProperty();
+                }
+            }
+            canvas.width = width;
+            canvas.height = height;
+            const context = canvas.getContext("2d");
+            if (!context) {
+                throw new Error("the context is null.");
+            }
+            context.setTransform(1, 0, 0, 1, 0, 0);
+            context.clearRect(0, 0, width, height);
+            const instanceId = source._$instanceId;
+            $bitmapDrawMap.set(instanceId, {
+                "source": source,
+                "context": context,
+                "callback": callback
+            });
+            const options = $getArray();
+            const message = {
+                "command": "bitmapDraw",
+                "sourceId": instanceId,
+                "width": width,
+                "height": height
+            };
+            if (tMatrix[0] !== 1 || tMatrix[1] !== 0
+                || tMatrix[2] !== 0 || tMatrix[3] !== 1
+                || tMatrix[4] !== 0 || tMatrix[5] !== 0) {
+                message.matrix = tMatrix.slice();
+                options.push(message.matrix.buffer);
+            }
+            if (colorTransform[0] !== 1 || colorTransform[1] !== 1
+                || colorTransform[2] !== 1 || colorTransform[3] !== 1
+                || colorTransform[4] !== 0 || colorTransform[5] !== 0
+                || colorTransform[6] !== 0 || colorTransform[7] !== 0) {
+                message.colorTransform = colorTransform.slice();
+                options.push(message.colorTransform.buffer);
+            }
+            $rendererWorker.postMessage(message, options);
+            $poolArray(options);
+        }
+        else {
+            const context = player.context;
+            if (!context) {
+                throw new Error("the context is null.");
+            }
+            const manager = context.frameBuffer;
+            const currentAttachment = manager.currentAttachment;
+            context._$bind(player._$attachment);
+            // reset
+            context.reset();
+            context.setTransform(1, 0, 0, 1, 0, 0);
+            context.clearRect(0, 0, player._$width, player._$height);
+            context.beginPath();
+            source._$draw(context, tMatrix, colorTransform);
+            const texture = manager
+                .getTextureFromCurrentAttachment();
+            // reset and draw to main canvas
+            manager.unbind();
+            context.reset();
+            context.setTransform(1, 0, 0, 1, 0, 0);
+            context.clearRect(0, 0, texture.width + 1, texture.height + 1);
+            context.drawImage(texture, 0, 0, texture.width, texture.height);
+            canvas.width = width;
+            canvas.height = height;
+            const ctx = canvas.getContext("2d");
+            if (!ctx) {
+                return;
+            }
+            ctx.setTransform(1, 0, 0, 1, 0, 0);
+            ctx.clearRect(0, 0, width, height);
+            ctx.drawImage(player.canvas, 0, 0);
+            if (currentAttachment) {
+                context._$bind(currentAttachment);
+            }
+            if (callback) {
+                callback(canvas);
+            }
+        }
+        if (matrix) {
+            $poolMatrix(matrix);
+        }
+        if (color_transform) {
+            $poolColorTransform(color_transform);
+        }
+    }
+}