@next2d/display 1.14.20

package/dist/Shape.d.ts

@@ -0,0 +1,164 @@
+import type { LoaderInfo } from "./LoaderInfo";
+import { DisplayObject } from "./DisplayObject";
+import { Graphics } from "./Graphics";
+import { CanvasToWebGLContext } from "@next2d/webgl";
+import { BoundsImpl, ShapeCharacterImpl, ParentImpl, DictionaryTagImpl, PlayerHitObjectImpl, Character } from "@next2d/interface";
+/**
+ * Shape クラスには、Graphics クラスからメソッドにアクセスできる graphics プロパティがあります。
+ *
+ * The Shape class includes a graphics property,
+ * which lets you access methods from the Graphics class.
+ *
+ * @class
+ * @memberOf next2d.display
+ * @extends  DisplayObject
+ */
+export declare class Shape extends DisplayObject {
+    private _$graphics;
+    private _$bounds;
+    private _$bitmapId;
+    private _$src;
+    /**
+     * @constructor
+     * @public
+     */
+    constructor();
+    /**
+     * @description 指定されたクラスのストリングを返します。
+     *              Returns the string representation of the specified class.
+     *
+     * @return  {string}
+     * @default [class Shape]
+     * @method
+     * @static
+     */
+    static toString(): string;
+    /**
+     * @description 指定されたクラスの空間名を返します。
+     *              Returns the space name of the specified class.
+     *
+     * @return  {string}
+     * @default next2d.display.Shape
+     * @const
+     * @static
+     */
+    static get namespace(): string;
+    /**
+     * @description 指定されたオブジェクトのストリングを返します。
+     *              Returns the string representation of the specified object.
+     *
+     * @return  {string}
+     * @default [object Shape]
+     * @method
+     * @public
+     */
+    toString(): string;
+    /**
+     * @description 指定されたオブジェクトの空間名を返します。
+     *              Returns the space name of the specified object.
+     *
+     * @return  {string}
+     * @default next2d.display.Shape
+     * @const
+     * @public
+     */
+    get namespace(): string;
+    /**
+     * @description ベクターの描画コマンドが発生するこのスプライトに属する Graphics オブジェクトを指定します。
+     *              Specifies the Graphics object that belongs to this sprite
+     *              where vector drawing commands can occur.
+     *
+     * @member  {Graphics}
+     * @readonly
+     * @public
+     */
+    get graphics(): Graphics;
+    /**
+     * @description 指定されたパスから画像を読み込み、Graphicsを生成します
+     *              Reads images from the specified path and generates Graphics.
+     *
+     * @member  {string}
+     * @readonly
+     * @public
+     */
+    get src(): string;
+    set src(src: string);
+    /**
+     * @param  {object} character
+     * @param  {LoaderInfo} loaderInfo
+     * @return {void}
+     * @method
+     * @private
+     */
+    _$buildCharacter(character: Character<ShapeCharacterImpl>, loaderInfo: LoaderInfo): void;
+    /**
+     * @return {void}
+     * @method
+     * @private
+     */
+    _$createWorkerInstance(): void;
+    /**
+     * @param  {object} character
+     * @return {void}
+     * @method
+     * @protected
+     */
+    _$sync(character: ShapeCharacterImpl): void;
+    /**
+     * @param  {object} tag
+     * @param  {DisplayObjectContainer} parent
+     * @return {object}
+     * @method
+     * @private
+     */
+    _$build(tag: DictionaryTagImpl, parent: ParentImpl<any>): ShapeCharacterImpl;
+    /**
+     * @param   {Float32Array} [matrix=null]
+     * @returns {object}
+     * @method
+     * @private
+     */
+    _$getBounds(matrix?: Float32Array | null): BoundsImpl;
+    /**
+     * @param  {CanvasToWebGLContext} context
+     * @param  {Float32Array} matrix
+     * @param  {Float32Array} color_transform
+     * @return {void}
+     * @method
+     * @private
+     */
+    _$draw(context: CanvasToWebGLContext, matrix: Float32Array, color_transform: Float32Array): void;
+    /**
+     * @param   {CanvasToWebGLContext} context
+     * @param   {Float32Array} matrix
+     * @returns {void}
+     * @method
+     * @private
+     */
+    _$clip(context: CanvasToWebGLContext, matrix: Float32Array): void;
+    /**
+     * @param  {CanvasRenderingContext2D} context
+     * @param  {Float32Array} matrix
+     * @param  {object}  options
+     * @return {boolean}
+     * @method
+     * @private
+     */
+    _$mouseHit(context: CanvasRenderingContext2D, matrix: Float32Array, options: PlayerHitObjectImpl): boolean;
+    /**
+     * @param  {CanvasRenderingContext2D} context
+     * @param  {Float32Array} matrix
+     * @param  {object}  options
+     * @param  {boolean} [is_clip=false]
+     * @return {boolean}
+     * @method
+     * @private
+     */
+    _$hit(context: CanvasRenderingContext2D, matrix: Float32Array, options: PlayerHitObjectImpl, is_clip?: boolean): boolean;
+    /**
+     * @return {void}
+     * @method
+     * @private
+     */
+    _$postProperty(): void;
+}

package/dist/Shape.js

@@ -0,0 +1,509 @@
+import { DisplayObject } from "./DisplayObject";
+import { Graphics } from "./Graphics";
+import { BitmapData } from "./BitmapData";
+import { Rectangle } from "@next2d/geom";
+import { Event } from "@next2d/events";
+import { $MATRIX_HIT_ARRAY_IDENTITY, $rendererWorker } from "@next2d/util";
+import { $getArray, $poolArray, $getFloat32Array6, $getBoundsObject, $poolBoundsObject, $multiplicationMatrix, $boundsMatrix, $poolFloat32Array6, $multiplicationColor, $clamp, $poolFloat32Array8, $Math, $COLOR_ARRAY_IDENTITY } from "@next2d/share";
+/**
+ * Shape クラスには、Graphics クラスからメソッドにアクセスできる graphics プロパティがあります。
+ *
+ * The Shape class includes a graphics property,
+ * which lets you access methods from the Graphics class.
+ *
+ * @class
+ * @memberOf next2d.display
+ * @extends  DisplayObject
+ */
+export class Shape extends DisplayObject {
+    /**
+     * @constructor
+     * @public
+     */
+    constructor() {
+        super();
+        /**
+         * @type {Graphics}
+         * @default null
+         * @private
+         */
+        this._$graphics = null;
+        /**
+         * @type {object}
+         * @default null
+         * @private
+         */
+        this._$bounds = null;
+        /**
+         * @type {number}
+         * @default 0
+         * @private
+         */
+        this._$bitmapId = 0;
+        /**
+         * @type {string}
+         * @default ""
+         * @private
+         */
+        this._$src = "";
+    }
+    /**
+     * @description 指定されたクラスのストリングを返します。
+     *              Returns the string representation of the specified class.
+     *
+     * @return  {string}
+     * @default [class Shape]
+     * @method
+     * @static
+     */
+    static toString() {
+        return "[class Shape]";
+    }
+    /**
+     * @description 指定されたクラスの空間名を返します。
+     *              Returns the space name of the specified class.
+     *
+     * @return  {string}
+     * @default next2d.display.Shape
+     * @const
+     * @static
+     */
+    static get namespace() {
+        return "next2d.display.Shape";
+    }
+    /**
+     * @description 指定されたオブジェクトのストリングを返します。
+     *              Returns the string representation of the specified object.
+     *
+     * @return  {string}
+     * @default [object Shape]
+     * @method
+     * @public
+     */
+    toString() {
+        return "[object Shape]";
+    }
+    /**
+     * @description 指定されたオブジェクトの空間名を返します。
+     *              Returns the space name of the specified object.
+     *
+     * @return  {string}
+     * @default next2d.display.Shape
+     * @const
+     * @public
+     */
+    get namespace() {
+        return "next2d.display.Shape";
+    }
+    /**
+     * @description ベクターの描画コマンドが発生するこのスプライトに属する Graphics オブジェクトを指定します。
+     *              Specifies the Graphics object that belongs to this sprite
+     *              where vector drawing commands can occur.
+     *
+     * @member  {Graphics}
+     * @readonly
+     * @public
+     */
+    get graphics() {
+        if (!this._$graphics) {
+            this._$graphics = new Graphics(this);
+        }
+        return this._$graphics;
+    }
+    /**
+     * @description 指定されたパスから画像を読み込み、Graphicsを生成します
+     *              Reads images from the specified path and generates Graphics.
+     *
+     * @member  {string}
+     * @readonly
+     * @public
+     */
+    get src() {
+        return this._$src;
+    }
+    set src(src) {
+        const image = new Image();
+        image.addEventListener("load", () => {
+            const width = image.width;
+            const height = image.height;
+            const bitmapData = new BitmapData(width, height);
+            bitmapData.image = image;
+            this
+                .graphics
+                .beginBitmapFill(bitmapData)
+                .drawRect(0, 0, width, height);
+            if (this.hasEventListener(Event.LOAD)) {
+                this.dispatchEvent(new Event(Event.LOAD));
+            }
+        });
+        this._$src = image.src = src;
+    }
+    /**
+     * @param  {object} character
+     * @param  {LoaderInfo} loaderInfo
+     * @return {void}
+     * @method
+     * @private
+     */
+    _$buildCharacter(character, loaderInfo) {
+        const graphics = this.graphics;
+        if (!loaderInfo._$data) {
+            throw new Error("the loaderInfo data is null.");
+        }
+        if (character.recodes) {
+            switch (true) {
+                case character.bitmapId > 0:
+                    {
+                        this._$bitmapId = character.bitmapId;
+                        const bitmap = loaderInfo
+                            ._$data
+                            .characters[character.bitmapId];
+                        if (!bitmap.buffer) {
+                            throw new Error("the bitmap buffer is null.");
+                        }
+                        const width = $Math.abs(bitmap.bounds.xMax - bitmap.bounds.xMin);
+                        const height = $Math.abs(bitmap.bounds.yMax - bitmap.bounds.yMin);
+                        const bitmapData = new BitmapData(width, height);
+                        if (!bitmap._$buffer) {
+                            bitmap._$buffer = new Uint8Array(bitmap.buffer);
+                            $poolArray(bitmap.buffer);
+                            bitmap.buffer = null;
+                        }
+                        bitmapData.buffer = bitmap._$buffer.slice();
+                        // setup
+                        graphics._$recode = $getArray();
+                        // clone
+                        const recodes = character.recodes;
+                        if (recodes[recodes.length - 1] === Graphics.END_FILL) {
+                            const length = recodes.length - 6;
+                            for (let idx = 0; idx < length; ++idx) {
+                                graphics._$recode.push(recodes[idx]);
+                            }
+                            // add Bitmap Fill
+                            graphics._$recode.push(Graphics.BITMAP_FILL, bitmapData, null, "repeat", false);
+                        }
+                        else {
+                            const width = recodes[recodes.length - 9];
+                            const caps = recodes[recodes.length - 8];
+                            const joints = recodes[recodes.length - 7];
+                            const miterLimit = recodes[recodes.length - 6];
+                            const length = recodes.length - 10;
+                            for (let idx = 0; idx < length; ++idx) {
+                                graphics._$recode.push(recodes[idx]);
+                            }
+                            graphics._$recode.push(Graphics.BITMAP_STROKE, width, caps, joints, miterLimit, bitmapData, $getFloat32Array6(1, 0, 0, 1, character.bounds.xMin, character.bounds.yMin), "repeat", false);
+                        }
+                    }
+                    break;
+                case character.inBitmap:
+                    {
+                        // setup
+                        graphics._$recode = $getArray();
+                        const recodes = character.recodes;
+                        for (let idx = 0; idx < recodes.length; ++idx) {
+                            const value = recodes[idx];
+                            graphics._$recode[idx] = value;
+                            if (typeof value !== "object") {
+                                continue;
+                            }
+                            if (!value.buffer) {
+                                continue;
+                            }
+                            const bitmapData = new BitmapData(value.width, value.height);
+                            bitmapData.buffer = new Uint8Array(value.buffer);
+                            graphics._$recode[idx++] = bitmapData;
+                            const matrix = recodes[idx];
+                            graphics._$recode[idx] = $getFloat32Array6(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
+                        }
+                    }
+                    break;
+                default:
+                    graphics._$recode = character.recodes.slice(0);
+                    break;
+            }
+        }
+        else {
+            const width = $Math.abs(character.bounds.xMax - character.bounds.xMin);
+            const height = $Math.abs(character.bounds.yMax - character.bounds.yMin);
+            const bitmapData = new BitmapData(width, height);
+            if (!character._$buffer) {
+                if (!character.buffer) {
+                    throw new Error("the bitmap buffer is null.");
+                }
+                character._$buffer = new Uint8Array(character.buffer);
+                $poolArray(character.buffer);
+                character.buffer = null;
+            }
+            bitmapData.buffer = character._$buffer.slice(0);
+            graphics
+                .beginBitmapFill(bitmapData, null, false)
+                .drawRect(0, 0, width, height);
+        }
+        graphics._$maxAlpha = 1;
+        graphics._$canDraw = true;
+        graphics._$xMin = character.bounds.xMin;
+        graphics._$xMax = character.bounds.xMax;
+        graphics._$yMin = character.bounds.yMin;
+        graphics._$yMax = character.bounds.yMax;
+        // 9-scale
+        if (character.grid) {
+            this._$scale9Grid = new Rectangle(character.grid.x, character.grid.y, character.grid.w, character.grid.h);
+        }
+        if ($rendererWorker && this._$stage) {
+            this._$createWorkerInstance();
+        }
+    }
+    /**
+     * @return {void}
+     * @method
+     * @private
+     */
+    _$createWorkerInstance() {
+        if (this._$created || !$rendererWorker) {
+            return;
+        }
+        this._$created = true;
+        const options = $getArray();
+        const bounds = this._$getBounds();
+        const message = {
+            "command": "createShape",
+            "instanceId": this._$instanceId,
+            "parentId": this._$parent ? this._$parent._$instanceId : -1,
+            "maxAlpha": 0,
+            "canDraw": false,
+            "xMin": bounds.xMin,
+            "yMin": bounds.yMin,
+            "xMax": bounds.xMax,
+            "yMax": bounds.yMax
+        };
+        const graphics = this._$graphics;
+        if (graphics) {
+            const recodes = graphics._$getRecodes();
+            if (recodes.length
+                && graphics._$maxAlpha > 0
+                && graphics._$canDraw) {
+                message.maxAlpha = graphics._$maxAlpha;
+                message.canDraw = graphics._$canDraw;
+                message.recodes = recodes;
+                options.push(recodes.buffer);
+            }
+        }
+        if (this._$characterId > -1) {
+            message.characterId = this._$characterId;
+        }
+        if (this._$loaderInfo) {
+            message.loaderInfoId = this._$loaderInfo._$id;
+        }
+        if (this._$scale9Grid) {
+            message.grid = {
+                "x": this._$scale9Grid.x,
+                "y": this._$scale9Grid.y,
+                "w": this._$scale9Grid.width,
+                "h": this._$scale9Grid.height
+            };
+        }
+        $rendererWorker.postMessage(message, options);
+    }
+    /**
+     * @param  {object} character
+     * @return {void}
+     * @method
+     * @protected
+     */
+    _$sync(character) {
+        if (this._$loaderInfo) {
+            this._$buildCharacter(character, this._$loaderInfo);
+        }
+    }
+    /**
+     * @param  {object} tag
+     * @param  {DisplayObjectContainer} parent
+     * @return {object}
+     * @method
+     * @private
+     */
+    _$build(tag, parent) {
+        const character = this
+            ._$baseBuild(tag, parent);
+        this._$buildCharacter(character, parent._$loaderInfo);
+        return character;
+    }
+    /**
+     * @param   {Float32Array} [matrix=null]
+     * @returns {object}
+     * @method
+     * @private
+     */
+    _$getBounds(matrix = null) {
+        if (!this._$graphics) {
+            return $getBoundsObject(0, 0, 0, 0);
+        }
+        const baseBounds = this._$graphics._$getBounds();
+        if (!matrix) {
+            return baseBounds;
+        }
+        let multiMatrix = matrix;
+        const rawMatrix = this._$transform._$rawMatrix();
+        if (rawMatrix[0] !== 1 || rawMatrix[1] !== 0
+            || rawMatrix[2] !== 0 || rawMatrix[3] !== 1
+            || rawMatrix[4] !== 0 || rawMatrix[5] !== 0) {
+            multiMatrix = $multiplicationMatrix(matrix, rawMatrix);
+        }
+        const bounds = $boundsMatrix(baseBounds, multiMatrix);
+        $poolBoundsObject(baseBounds);
+        if (multiMatrix !== matrix) {
+            $poolFloat32Array6(multiMatrix);
+        }
+        return bounds;
+    }
+    /**
+     * @param  {CanvasToWebGLContext} context
+     * @param  {Float32Array} matrix
+     * @param  {Float32Array} color_transform
+     * @return {void}
+     * @method
+     * @private
+     */
+    _$draw(context, matrix, color_transform) {
+        if (!this._$visible) {
+            return;
+        }
+        if (!this._$graphics || !this._$graphics._$canDraw) {
+            return;
+        }
+        let multiColor = color_transform;
+        const rawColor = this._$transform._$rawColorTransform();
+        if (rawColor !== $COLOR_ARRAY_IDENTITY
+            && rawColor[0] !== 1 || rawColor[1] !== 1
+            || rawColor[2] !== 1 || rawColor[3] !== 1
+            || rawColor[4] !== 0 || rawColor[5] !== 0
+            || rawColor[6] !== 0 || rawColor[7] !== 0) {
+            multiColor = $multiplicationColor(color_transform, rawColor);
+        }
+        const alpha = $clamp(multiColor[3] + multiColor[7] / 255, 0, 1, 0);
+        if (!alpha) {
+            if (multiColor !== color_transform) {
+                $poolFloat32Array8(multiColor);
+            }
+            return;
+        }
+        const filters = this._$filters || this.filters;
+        const blendMode = this._$blendMode || this.blendMode;
+        let multiMatrix = matrix;
+        const rawMatrix = this._$transform._$rawMatrix();
+        if (rawMatrix !== $MATRIX_HIT_ARRAY_IDENTITY
+            && rawMatrix[0] !== 1 || rawMatrix[1] !== 0
+            || rawMatrix[2] !== 0 || rawMatrix[3] !== 1
+            || rawMatrix[4] !== 0 || rawMatrix[5] !== 0) {
+            multiMatrix = $multiplicationMatrix(matrix, rawMatrix);
+        }
+        this
+            ._$graphics
+            ._$draw(context, multiMatrix, multiColor, blendMode, filters);
+        if (multiMatrix !== matrix) {
+            $poolFloat32Array6(multiMatrix);
+        }
+        if (multiColor !== color_transform) {
+            $poolFloat32Array8(multiColor);
+        }
+    }
+    /**
+     * @param   {CanvasToWebGLContext} context
+     * @param   {Float32Array} matrix
+     * @returns {void}
+     * @method
+     * @private
+     */
+    _$clip(context, matrix) {
+        if (!this._$graphics) {
+            return;
+        }
+        let multiMatrix = matrix;
+        const rawMatrix = this._$transform._$rawMatrix();
+        if (rawMatrix[0] !== 1 || rawMatrix[1] !== 0
+            || rawMatrix[2] !== 0 || rawMatrix[3] !== 1
+            || rawMatrix[4] !== 0 || rawMatrix[5] !== 0) {
+            multiMatrix = $multiplicationMatrix(matrix, rawMatrix);
+        }
+        this._$graphics._$clip(context, multiMatrix);
+        if (multiMatrix !== matrix) {
+            $poolFloat32Array6(multiMatrix);
+        }
+    }
+    /**
+     * @param  {CanvasRenderingContext2D} context
+     * @param  {Float32Array} matrix
+     * @param  {object}  options
+     * @return {boolean}
+     * @method
+     * @private
+     */
+    _$mouseHit(context, matrix, options) {
+        if (!this._$visible) {
+            return false;
+        }
+        return this._$hit(context, matrix, options);
+    }
+    /**
+     * @param  {CanvasRenderingContext2D} context
+     * @param  {Float32Array} matrix
+     * @param  {object}  options
+     * @param  {boolean} [is_clip=false]
+     * @return {boolean}
+     * @method
+     * @private
+     */
+    _$hit(context, matrix, options, is_clip = false) {
+        let hit = false;
+        const graphics = this._$graphics;
+        if (graphics
+            && graphics._$canDraw
+            && graphics._$getBounds()) {
+            let multiMatrix = matrix;
+            const rawMatrix = this._$transform._$rawMatrix();
+            if (rawMatrix[0] !== 1 || rawMatrix[1] !== 0
+                || rawMatrix[2] !== 0 || rawMatrix[3] !== 1
+                || rawMatrix[4] !== 0 || rawMatrix[5] !== 0) {
+                multiMatrix = $multiplicationMatrix(matrix, rawMatrix);
+            }
+            hit = graphics._$hit(context, multiMatrix, options, is_clip);
+            if (multiMatrix !== matrix) {
+                $poolFloat32Array6(multiMatrix);
+            }
+        }
+        return hit;
+    }
+    /**
+     * @return {void}
+     * @method
+     * @private
+     */
+    _$postProperty() {
+        if (!$rendererWorker) {
+            return;
+        }
+        const message = this._$createMessage();
+        const graphics = this._$graphics;
+        if (graphics && !graphics._$buffer) {
+            message.maxAlpha = graphics._$maxAlpha;
+            message.canDraw = graphics._$canDraw;
+            const recodes = graphics._$getRecodes();
+            message.recodes = recodes;
+            const options = $getArray(recodes.buffer);
+            const bounds = this._$getBounds();
+            message.xMin = bounds.xMin;
+            message.yMin = bounds.yMin;
+            message.xMax = bounds.xMax;
+            message.yMax = bounds.yMax;
+            $rendererWorker
+                .postMessage(message, options);
+            $poolArray(options);
+        }
+        else {
+            $rendererWorker
+                .postMessage(message);
+        }
+        this._$posted = true;
+        this._$updated = false;
+    }
+}