@next2d/display 1.18.12 → 2.0.0

package/src/DisplayObject/usecase/DisplayObjectGetFiltersUseCase.js

@@ -0,0 +1,25 @@
+import { execute as displayObjectGetPlaceObjectService } from "../service/DisplayObjectGetPlaceObjectService";
+import { execute as displayObjectBuildFilterService } from "../service/DisplayObjectBuildFilterService";
+/**
+ * @description DisplayObjectのフィルタを返却、存在しない場合はnullを返却
+ *              Return the filter of the DisplayObject, or return null if it does not exist.
+ *
+ * @param  {DisplayObject} display_object
+ * @return {IFilterArray | null}
+ * @method
+ * @protected
+ */
+export const execute = (display_object) => {
+    if (display_object.$filters) {
+        return display_object.$filters;
+    }
+    const placeObject = displayObjectGetPlaceObjectService(display_object);
+    if (placeObject && placeObject.surfaceFilterList) {
+        // build filter
+        if (!placeObject.filters) {
+            placeObject.filters = displayObjectBuildFilterService(placeObject.surfaceFilterList);
+        }
+        return placeObject.filters;
+    }
+    return null;
+};

package/src/DisplayObject/usecase/DisplayObjectGetHeightUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayObject } from "../../DisplayObject";
+/**
+ * @description DisplayObjectの高さを返却
+ *              DisplayObject height returned
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D) => number;

package/src/DisplayObject/usecase/DisplayObjectGetHeightUseCase.js

@@ -0,0 +1,24 @@
+import { $poolBoundsArray } from "../../DisplayObjectUtil";
+import { execute as displayObjectGetCalcBoundsUseCase } from "./DisplayObjectGetCalcBoundsUseCase";
+/**
+ * @description DisplayObjectの高さを返却
+ *              DisplayObject height returned
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export const execute = (display_object) => {
+    const bounds = displayObjectGetCalcBoundsUseCase(display_object);
+    const height = Math.abs(bounds[3] - bounds[1]);
+    $poolBoundsArray(bounds);
+    switch (true) {
+        case height === 0:
+        case height === Infinity:
+        case height === -Infinity:
+            return 0;
+        default:
+            return Math.round(height * 100) / 100;
+    }
+};

package/src/DisplayObject/usecase/DisplayObjectGetMatrixUseCase.d.ts

@@ -0,0 +1,12 @@
+import type { DisplayObject } from "../../DisplayObject";
+import { Matrix } from "@next2d/geom";
+/**
+ * @description DisplayObject の Matrix を取得します。
+ *              Get the Matrix of DisplayObject.
+ *
+ * @param  {D} display_object
+ * @return {Matrix}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D) => Matrix;

package/src/DisplayObject/usecase/DisplayObjectGetMatrixUseCase.js

@@ -0,0 +1,17 @@
+import { Matrix } from "@next2d/geom";
+import { execute as displayObjectGetRawMatrixUseCase } from "./DisplayObjectGetRawMatrixUseCase";
+/**
+ * @description DisplayObject の Matrix を取得します。
+ *              Get the Matrix of DisplayObject.
+ *
+ * @param  {D} display_object
+ * @return {Matrix}
+ * @method
+ * @protected
+ */
+export const execute = (display_object) => {
+    const matrix = displayObjectGetRawMatrixUseCase(display_object);
+    return matrix
+        ? new Matrix(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5])
+        : new Matrix();
+};

package/src/DisplayObject/usecase/DisplayObjectGetRawBoundsUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayObject } from "../../DisplayObject";
+/**
+ * @description matrixを含まないバウンディングボックスを返却
+ *              Return bounding box without matrix
+ *
+ * @param  {DisplayObject} display_object
+ * @return {Float32Array}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D) => Float32Array;

package/src/DisplayObject/usecase/DisplayObjectGetRawBoundsUseCase.js

@@ -0,0 +1,28 @@
+import { execute as displayObjectContainerRawBoundsMatrixUseCase } from "../../DisplayObjectContainer/usecase/DisplayObjectContainerRawBoundsMatrixUseCase";
+import { execute as shapeGetRawBoundsService } from "../../Shape/service/ShapeGetRawBoundsService";
+import { execute as textFieldGetRawBoundsService } from "../../TextField/service/TextFieldGetRawBoundsService";
+import { execute as videoGetRawBoundsService } from "../../Video/service/VideoGetRawBoundsService";
+import { $getBoundsArray } from "../../DisplayObjectUtil";
+/**
+ * @description matrixを含まないバウンディングボックスを返却
+ *              Return bounding box without matrix
+ *
+ * @param  {DisplayObject} display_object
+ * @return {Float32Array}
+ * @method
+ * @protected
+ */
+export const execute = (display_object) => {
+    switch (true) {
+        case display_object.isContainerEnabled:
+            return displayObjectContainerRawBoundsMatrixUseCase(display_object);
+        case display_object.isShape:
+            return shapeGetRawBoundsService(display_object);
+        case display_object.isText:
+            return textFieldGetRawBoundsService(display_object);
+        case display_object.isVideo:
+            return videoGetRawBoundsService(display_object);
+        default:
+            return $getBoundsArray(0, 0, 0, 0);
+    }
+};

package/src/DisplayObject/usecase/DisplayObjectGetRawColorTransformUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayObject } from "../../DisplayObject";
+/**
+ * @description 現在のフレームのColorTransformを返却、存在しない場合はnullを返却
+ *              Returns the ColorTransform of the current frame, or null if it does not exist.
+ *
+ * @param  {DisplayObject} display_object
+ * @return {Float32Array | null}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D) => Float32Array | null;

package/src/DisplayObject/usecase/DisplayObjectGetRawColorTransformUseCase.js

@@ -0,0 +1,25 @@
+import { execute as displayObjectGetPlaceObjectService } from "../service/DisplayObjectGetPlaceObjectService";
+import { $getFloat32Array8 } from "../../DisplayObjectUtil";
+/**
+ * @description 現在のフレームのColorTransformを返却、存在しない場合はnullを返却
+ *              Returns the ColorTransform of the current frame, or null if it does not exist.
+ *
+ * @param  {DisplayObject} display_object
+ * @return {Float32Array | null}
+ * @method
+ * @protected
+ */
+export const execute = (display_object) => {
+    if (display_object.$colorTransform) {
+        return display_object.$colorTransform.rawData;
+    }
+    const placeObject = displayObjectGetPlaceObjectService(display_object);
+    if (!placeObject || !placeObject.colorTransform) {
+        return null;
+    }
+    if (!placeObject.typedColorTransform) {
+        const colorTransform = placeObject.colorTransform;
+        placeObject.typedColorTransform = $getFloat32Array8(colorTransform[0], colorTransform[1], colorTransform[2], colorTransform[3], colorTransform[4], colorTransform[5], colorTransform[6], colorTransform[7]);
+    }
+    return placeObject.typedColorTransform;
+};

package/src/DisplayObject/usecase/DisplayObjectGetRawMatrixUseCase.d.ts

@@ -0,0 +1,12 @@
+import type { DisplayObject } from "../../DisplayObject";
+/**
+ * @description DisplayObjectの内部Float32Arrayデータを返却、存在しない場合は固定のFloat32Arrayデータを返却
+ *              Return the internal Float32Array data of the DisplayObject,
+ *              or return a fixed Float32Array data if it does not exist.
+ *
+ * @param  {DisplayObject} display_object
+ * @return {Float32Array | null}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D) => Float32Array | null;

package/src/DisplayObject/usecase/DisplayObjectGetRawMatrixUseCase.js

@@ -0,0 +1,26 @@
+import { execute as displayObjectGetPlaceObjectService } from "../service/DisplayObjectGetPlaceObjectService";
+import { $getFloat32Array6 } from "../../DisplayObjectUtil";
+/**
+ * @description DisplayObjectの内部Float32Arrayデータを返却、存在しない場合は固定のFloat32Arrayデータを返却
+ *              Return the internal Float32Array data of the DisplayObject,
+ *              or return a fixed Float32Array data if it does not exist.
+ *
+ * @param  {DisplayObject} display_object
+ * @return {Float32Array | null}
+ * @method
+ * @protected
+ */
+export const execute = (display_object) => {
+    if (display_object.$matrix) {
+        return display_object.$matrix.rawData;
+    }
+    const placeObject = displayObjectGetPlaceObjectService(display_object);
+    if (!placeObject || !placeObject.matrix) {
+        return null;
+    }
+    if (!placeObject.typedMatrix) {
+        const matrix = placeObject.matrix;
+        placeObject.typedMatrix = $getFloat32Array6(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
+    }
+    return placeObject.typedMatrix;
+};

package/src/DisplayObject/usecase/DisplayObjectGetRotationUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayObject } from "../../DisplayObject";
+/**
+ * @description DisplayObjectの回転角度を返却
+ *              Returns the rotation angle of the DisplayObject
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D) => number;

package/src/DisplayObject/usecase/DisplayObjectGetRotationUseCase.js

@@ -0,0 +1,23 @@
+import { execute as displayObjectGetRawMatrixUseCase } from "../usecase/DisplayObjectGetRawMatrixUseCase";
+/**
+ * @description ラジアンから度に変換するための定数
+ *              Constant for converting radians to degrees
+ *
+ * @type {number}
+ */
+const $Rad2Deg = 180 / Math.PI;
+/**
+ * @description DisplayObjectの回転角度を返却
+ *              Returns the rotation angle of the DisplayObject
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export const execute = (display_object) => {
+    const matrix = display_object.$matrix
+        ? display_object.$matrix.rawData
+        : displayObjectGetRawMatrixUseCase(display_object);
+    return matrix ? Math.atan2(matrix[1], matrix[0]) * $Rad2Deg : 0;
+};

package/src/DisplayObject/usecase/DisplayObjectGetScaleXUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayObject } from "../../DisplayObject";
+/**
+ * @description DisplayObjectのx軸方向の拡大率を返却
+ *              Returns the scaling factor in the x-axis direction of the DisplayObject
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D) => number;

package/src/DisplayObject/usecase/DisplayObjectGetScaleXUseCase.js

@@ -0,0 +1,29 @@
+import { execute as displayObjectGetRawMatrixUseCase } from "../usecase/DisplayObjectGetRawMatrixUseCase";
+/**
+ * @description DisplayObjectのx軸方向の拡大率を返却
+ *              Returns the scaling factor in the x-axis direction of the DisplayObject
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export const execute = (display_object) => {
+    const matrix = display_object.$matrix
+        ? display_object.$matrix.rawData
+        : displayObjectGetRawMatrixUseCase(display_object);
+    if (!matrix) {
+        return 1;
+    }
+    let xScale = Math.sqrt(matrix[0] * matrix[0]
+        + matrix[1] * matrix[1]);
+    if (!Number.isInteger(xScale)) {
+        const value = xScale.toString();
+        const index = value.indexOf("e");
+        if (index !== -1) {
+            xScale = +value.slice(0, index);
+        }
+        xScale = Math.round(xScale * 10000) / 10000;
+    }
+    return 0 > matrix[0] ? xScale * -1 : xScale;
+};

package/src/DisplayObject/usecase/DisplayObjectGetScaleYUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayObject } from "../../DisplayObject";
+/**
+ * @description DisplayObjectのy軸方向の拡大率を返却
+ *              Returns the scaling factor in the y-axis direction of the DisplayObject
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D) => number;

package/src/DisplayObject/usecase/DisplayObjectGetScaleYUseCase.js

@@ -0,0 +1,29 @@
+import { execute as displayObjectGetRawMatrixUseCase } from "../usecase/DisplayObjectGetRawMatrixUseCase";
+/**
+ * @description DisplayObjectのy軸方向の拡大率を返却
+ *              Returns the scaling factor in the y-axis direction of the DisplayObject
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export const execute = (display_object) => {
+    const matrix = display_object.$matrix
+        ? display_object.$matrix.rawData
+        : displayObjectGetRawMatrixUseCase(display_object);
+    if (!matrix) {
+        return 1;
+    }
+    let yScale = Math.sqrt(matrix[2] * matrix[2]
+        + matrix[3] * matrix[3]);
+    if (!Number.isInteger(yScale)) {
+        const value = yScale.toString();
+        const index = value.indexOf("e");
+        if (index !== -1) {
+            yScale = +value.slice(0, index);
+        }
+        yScale = Math.round(yScale * 10000) / 10000;
+    }
+    return 0 > matrix[0] ? yScale * -1 : yScale;
+};

package/src/DisplayObject/usecase/DisplayObjectGetWidthUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayObject } from "../../DisplayObject";
+/**
+ * @description DisplayObjectの幅を返却
+ *              DisplayObject width returned
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D) => number;

package/src/DisplayObject/usecase/DisplayObjectGetWidthUseCase.js

@@ -0,0 +1,24 @@
+import { $poolBoundsArray } from "../../DisplayObjectUtil";
+import { execute as displayObjectGetCalcBoundsUseCase } from "./DisplayObjectGetCalcBoundsUseCase";
+/**
+ * @description DisplayObjectの幅を返却
+ *              DisplayObject width returned
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export const execute = (display_object) => {
+    const bounds = displayObjectGetCalcBoundsUseCase(display_object);
+    const width = Math.abs(bounds[2] - bounds[0]);
+    $poolBoundsArray(bounds);
+    switch (true) {
+        case width === 0:
+        case width === Infinity:
+        case width === -Infinity:
+            return 0;
+        default:
+            return Math.round(width * 100) / 100;
+    }
+};

package/src/DisplayObject/usecase/DisplayObjectGetXUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayObject } from "../../DisplayObject";
+/**
+ * @description DisplayObjectのx座標を返却
+ *              Return x-coordinate of DisplayObject
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D) => number;

package/src/DisplayObject/usecase/DisplayObjectGetXUseCase.js

@@ -0,0 +1,16 @@
+import { execute as displayObjectGetRawMatrixUseCase } from "../usecase/DisplayObjectGetRawMatrixUseCase";
+/**
+ * @description DisplayObjectのx座標を返却
+ *              Return x-coordinate of DisplayObject
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export const execute = (display_object) => {
+    const matrix = display_object.$matrix
+        ? display_object.$matrix.rawData
+        : displayObjectGetRawMatrixUseCase(display_object);
+    return matrix ? matrix[4] : 0;
+};

package/src/DisplayObject/usecase/DisplayObjectGetYUseCase.d.ts

@@ -0,0 +1,11 @@
+import type { DisplayObject } from "../../DisplayObject";
+/**
+ * @description DisplayObjectのy座標を返却
+ *              Return y-coordinate of DisplayObject
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D) => number;

package/src/DisplayObject/usecase/DisplayObjectGetYUseCase.js

@@ -0,0 +1,16 @@
+import { execute as displayObjectGetRawMatrixUseCase } from "../usecase/DisplayObjectGetRawMatrixUseCase";
+/**
+ * @description DisplayObjectのy座標を返却
+ *              Return y-coordinate of DisplayObject
+ *
+ * @param  {DisplayObject} display_object
+ * @return {number}
+ * @method
+ * @protected
+ */
+export const execute = (display_object) => {
+    const matrix = display_object.$matrix
+        ? display_object.$matrix.rawData
+        : displayObjectGetRawMatrixUseCase(display_object);
+    return matrix ? matrix[5] : 0;
+};

package/src/DisplayObject/usecase/DisplayObjectHitTestObjectUseCase.d.ts

@@ -0,0 +1,10 @@
+import type { DisplayObject } from "../../DisplayObject";
+/**
+ * @description
+ * @param  {DisplayObject} display_object
+ * @param  {DisplayObject} target_display_object
+ * @return {boolean}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D, target_display_object: D) => boolean;

package/src/DisplayObject/usecase/DisplayObjectHitTestObjectUseCase.js

@@ -0,0 +1,35 @@
+import { execute as displayObjectGetRawBoundsUseCase } from "./DisplayObjectGetRawBoundsUseCase";
+import { execute as displayObjectCalcBoundsMatrixService } from "../service/DisplayObjectCalcBoundsMatrixService";
+import { Matrix } from "@next2d/geom";
+import { $poolBoundsArray } from "../../DisplayObjectUtil";
+/**
+ * @description
+ * @param  {DisplayObject} display_object
+ * @param  {DisplayObject} target_display_object
+ * @return {boolean}
+ * @method
+ * @protected
+ */
+export const execute = (display_object, target_display_object) => {
+    const rawBounds1 = displayObjectGetRawBoundsUseCase(display_object);
+    const matrix1 = display_object.concatenatedMatrix;
+    const bounds1 = displayObjectCalcBoundsMatrixService(rawBounds1[0], rawBounds1[1], rawBounds1[2], rawBounds1[3], matrix1.rawData);
+    // pool
+    $poolBoundsArray(rawBounds1);
+    Matrix.release(matrix1.rawData);
+    const rawBounds2 = displayObjectGetRawBoundsUseCase(target_display_object);
+    const matrix2 = target_display_object.concatenatedMatrix;
+    const bounds2 = displayObjectCalcBoundsMatrixService(rawBounds2[0], rawBounds2[1], rawBounds2[2], rawBounds2[3], matrix2.rawData);
+    // pool
+    $poolBoundsArray(rawBounds2);
+    Matrix.release(matrix2.rawData);
+    // calc
+    const sx = Math.max(bounds1[0], bounds2[0]);
+    const sy = Math.max(bounds1[1], bounds2[1]);
+    const ex = Math.min(bounds1[2], bounds2[2]);
+    const ey = Math.min(bounds1[3], bounds2[3]);
+    // pool
+    $poolBoundsArray(bounds1);
+    $poolBoundsArray(bounds2);
+    return ex - sx >= 0 && ey - sy >= 0;
+};

package/src/DisplayObject/usecase/DisplayObjectHitTestPointUseCase.d.ts

@@ -0,0 +1,14 @@
+import type { DisplayObject } from "../../DisplayObject";
+/**
+ * @description 指定された DisplayObject が指定された座標にヒットしているかどうかを返します
+ *              Returns whether the specified DisplayObject hits the specified coordinates
+ *
+ * @param  {DisplayObject} display_object
+ * @param  {number} x
+ * @param  {number} y
+ * @param  {boolean} [shape_flag=false]
+ * @return {boolean}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D, x: number, y: number, shape_flag?: boolean) => boolean;

package/src/DisplayObject/usecase/DisplayObjectHitTestPointUseCase.js

@@ -0,0 +1,69 @@
+import { execute as displayObjectGetRawBoundsUseCase } from "./DisplayObjectGetRawBoundsUseCase";
+import { execute as displayObjectCalcBoundsMatrixService } from "../service/DisplayObjectCalcBoundsMatrixService";
+import { execute as displayObjectGetRawMatrixUseCase } from "./DisplayObjectGetRawMatrixUseCase";
+import { execute as displayObjectContainerMouseHitUseCase } from "../../DisplayObjectContainer/usecase/DisplayObjectContainerMouseHitUseCase";
+import { execute as shapeHitTestUseCase } from "../../Shape/usecase/ShapeHitTestUseCase";
+import { execute as textFieldHitTestUseCase } from "../../TextField/usecase/TextFieldHitTestUseCase";
+import { execute as videoHitTestUseCase } from "../../Video/usecase/VideoHitTestUseCase";
+import { Rectangle, Point } from "@next2d/geom";
+import { $MATRIX_ARRAY_IDENTITY, $poolBoundsArray, $colorContext } from "../../DisplayObjectUtil";
+/**
+ * @type {IPlayerHitObject}
+ * @private
+ */
+const $hitObject = {
+    "x": 0,
+    "y": 0,
+    "pointer": "",
+    "hit": null
+};
+/**
+ * @description 指定された DisplayObject が指定された座標にヒットしているかどうかを返します
+ *              Returns whether the specified DisplayObject hits the specified coordinates
+ *
+ * @param  {DisplayObject} display_object
+ * @param  {number} x
+ * @param  {number} y
+ * @param  {boolean} [shape_flag=false]
+ * @return {boolean}
+ * @method
+ * @protected
+ */
+export const execute = (display_object, x, y, shape_flag = false) => {
+    if (shape_flag) {
+        const parent = display_object.parent;
+        const matrix = parent
+            ? parent.concatenatedMatrix.rawData
+            : $MATRIX_ARRAY_IDENTITY;
+        $colorContext.setTransform(1, 0, 0, 1, 0, 0);
+        $colorContext.beginPath();
+        $hitObject.x = x;
+        $hitObject.y = y;
+        $hitObject.hit = null;
+        switch (true) {
+            case display_object.isContainerEnabled:
+                return displayObjectContainerMouseHitUseCase(display_object, $colorContext, matrix, $hitObject);
+            case display_object.isShape:
+                return shapeHitTestUseCase(display_object, $colorContext, matrix, $hitObject);
+            case display_object.isText:
+                return textFieldHitTestUseCase(display_object, $colorContext, matrix, $hitObject);
+            case display_object.isVideo:
+                return videoHitTestUseCase(display_object, $colorContext, matrix, $hitObject);
+            default:
+                return false;
+        }
+    }
+    const rawBounds = displayObjectGetRawBoundsUseCase(display_object);
+    const martix = displayObjectGetRawMatrixUseCase(display_object);
+    const bounds = displayObjectCalcBoundsMatrixService(rawBounds[0], rawBounds[1], rawBounds[2], rawBounds[3], martix ? martix : $MATRIX_ARRAY_IDENTITY);
+    // pool
+    $poolBoundsArray(rawBounds);
+    const rectangle = new Rectangle(bounds[0], bounds[1], Math.abs(bounds[2] - bounds[0]), Math.abs(bounds[3] - bounds[1]));
+    // pool
+    $poolBoundsArray(bounds);
+    const parent = display_object.parent;
+    const point = parent
+        ? parent.globalToLocal(new Point(x, y))
+        : new Point(x, y);
+    return rectangle.containsPoint(point);
+};

package/src/DisplayObject/usecase/DisplayObjectIsMaskReflectedInDisplayUseCase.d.ts

@@ -0,0 +1,16 @@
+import type { DisplayObject } from "../../DisplayObject";
+/**
+ * @description DisplayObjectのマスク描画範囲を計算して、マスク描画が実行可能かどうかを返します。
+ *              Calculate the mask drawing area of DisplayObject and return whether the mask drawing is executable.
+ *
+ * @param  {DisplayObject} display_object
+ * @param  {Float32Array} matrix
+ * @param  {number} renderer_width
+ * @param  {number} renderer_height
+ * @param  {number} point_x
+ * @param  {number} point_y
+ * @return {boolean}
+ * @method
+ * @protected
+ */
+export declare const execute: <D extends DisplayObject>(display_object: D, matrix: Float32Array, renderer_width: number, renderer_height: number, point_x: number, point_y: number) => Float32Array | null;

package/src/DisplayObject/usecase/DisplayObjectIsMaskReflectedInDisplayUseCase.js

@@ -0,0 +1,59 @@
+import { execute as shapeCalcBoundsMatrixUseCase } from "../../Shape/usecase/ShapeCalcBoundsMatrixUseCase";
+import { execute as textFieldCalcBoundsMatrixUseCase } from "../../TextField/usecase/TextFieldCalcBoundsMatrixUseCase";
+import { execute as videoCalcBoundsMatrixUseCase } from "../../Video/usecase/VideoCalcBoundsMatrixUseCase";
+import { execute as displayObjectContainerCalcBoundsMatrixUseCase } from "../../DisplayObjectContainer/usecase/DisplayObjectContainerCalcBoundsMatrixUseCase";
+/**
+ * @description DisplayObjectのマスク描画範囲を計算して、マスク描画が実行可能かどうかを返します。
+ *              Calculate the mask drawing area of DisplayObject and return whether the mask drawing is executable.
+ *
+ * @param  {DisplayObject} display_object
+ * @param  {Float32Array} matrix
+ * @param  {number} renderer_width
+ * @param  {number} renderer_height
+ * @param  {number} point_x
+ * @param  {number} point_y
+ * @return {boolean}
+ * @method
+ * @protected
+ */
+export const execute = (display_object, matrix, renderer_width, renderer_height, point_x, point_y) => {
+    let bounds = null;
+    switch (true) {
+        case display_object.isContainerEnabled:
+            bounds = displayObjectContainerCalcBoundsMatrixUseCase(display_object, matrix);
+            break;
+        case display_object.isShape:
+            bounds = shapeCalcBoundsMatrixUseCase(display_object, matrix);
+            break;
+        case display_object.isText:
+            bounds = textFieldCalcBoundsMatrixUseCase(display_object, matrix);
+            break;
+        case display_object.isVideo:
+            bounds = videoCalcBoundsMatrixUseCase(display_object, matrix);
+            break;
+        default:
+            break;
+    }
+    if (!bounds) {
+        return null;
+    }
+    const xMin = bounds[0];
+    const xMax = bounds[2];
+    const width = Math.abs(xMax - xMin);
+    if (!width) {
+        return null;
+    }
+    const yMin = bounds[1];
+    const yMax = bounds[3];
+    const height = Math.abs(yMax - yMin);
+    if (!height) {
+        return null;
+    }
+    if (point_x > xMin + width
+        || point_y > yMin + height
+        || xMin > renderer_width
+        || yMin > renderer_height) {
+        return null;
+    }
+    return bounds;
+};