@next2d/webgl 1.18.12 → 3.0.0

package/src/Mesh/service/MeshFillGenerateService.js

@@ -0,0 +1,197 @@
+/**
+ * @description 塗りのメッシュを生成する
+ *              Generate a fill mesh
+ *
+ * @param  {IPath} vertex
+ * @param  {Float32Array} buffer
+ * @param  {number} index
+ * @param  {number} a
+ * @param  {number} b
+ * @param  {number} c
+ * @param  {number} d
+ * @param  {number} tx
+ * @param  {number} ty
+ * @param  {number} red
+ * @param  {number} green
+ * @param  {number} blue
+ * @param  {number} alpha
+ * @return {number}
+ * @method
+ * @protected
+ */
+export const execute = (vertex, buffer, index, a, b, c, d, tx, ty, red, green, blue, alpha) => {
+    const length = vertex.length - 5;
+    for (let idx = 3; idx < length; idx += 3) {
+        let position = index * 17;
+        if (vertex[idx + 2]) {
+            // 座標A
+            buffer[position++] = vertex[idx - 3];
+            buffer[position++] = vertex[idx - 2];
+            buffer[position++] = 0;
+            buffer[position++] = 0;
+            buffer[position++] = red;
+            buffer[position++] = green;
+            buffer[position++] = blue;
+            buffer[position++] = alpha;
+            buffer[position++] = a;
+            buffer[position++] = b;
+            buffer[position++] = 0;
+            buffer[position++] = c;
+            buffer[position++] = d;
+            buffer[position++] = 0;
+            buffer[position++] = tx;
+            buffer[position++] = ty;
+            buffer[position++] = 0;
+            // 座標B
+            buffer[position++] = vertex[idx];
+            buffer[position++] = vertex[idx + 1];
+            buffer[position++] = 0.5;
+            buffer[position++] = 0;
+            buffer[position++] = red;
+            buffer[position++] = green;
+            buffer[position++] = blue;
+            buffer[position++] = alpha;
+            buffer[position++] = a;
+            buffer[position++] = b;
+            buffer[position++] = 0;
+            buffer[position++] = c;
+            buffer[position++] = d;
+            buffer[position++] = 0;
+            buffer[position++] = tx;
+            buffer[position++] = ty;
+            buffer[position++] = 0;
+            // 座標C
+            buffer[position++] = vertex[idx + 3];
+            buffer[position++] = vertex[idx + 4];
+            buffer[position++] = 1;
+            buffer[position++] = 1;
+            buffer[position++] = red;
+            buffer[position++] = green;
+            buffer[position++] = blue;
+            buffer[position++] = alpha;
+            buffer[position++] = a;
+            buffer[position++] = b;
+            buffer[position++] = 0;
+            buffer[position++] = c;
+            buffer[position++] = d;
+            buffer[position++] = 0;
+            buffer[position++] = tx;
+            buffer[position++] = ty;
+            buffer[position++] = 0;
+        }
+        else if (vertex[idx + 5]) {
+            // 座標A
+            buffer[position++] = vertex[0];
+            buffer[position++] = vertex[1];
+            buffer[position++] = 0.5;
+            buffer[position++] = 0.5;
+            buffer[position++] = red;
+            buffer[position++] = green;
+            buffer[position++] = blue;
+            buffer[position++] = alpha;
+            buffer[position++] = a;
+            buffer[position++] = b;
+            buffer[position++] = 0;
+            buffer[position++] = c;
+            buffer[position++] = d;
+            buffer[position++] = 0;
+            buffer[position++] = tx;
+            buffer[position++] = ty;
+            buffer[position++] = 0;
+            // 座標B
+            buffer[position++] = vertex[idx];
+            buffer[position++] = vertex[idx + 1];
+            buffer[position++] = 0.5;
+            buffer[position++] = 0.5;
+            buffer[position++] = red;
+            buffer[position++] = green;
+            buffer[position++] = blue;
+            buffer[position++] = alpha;
+            buffer[position++] = a;
+            buffer[position++] = b;
+            buffer[position++] = 0;
+            buffer[position++] = c;
+            buffer[position++] = d;
+            buffer[position++] = 0;
+            buffer[position++] = tx;
+            buffer[position++] = ty;
+            buffer[position++] = 0;
+            // 座標C
+            buffer[position++] = vertex[idx + 6];
+            buffer[position++] = vertex[idx + 7];
+            buffer[position++] = 0.5;
+            buffer[position++] = 0.5;
+            buffer[position++] = red;
+            buffer[position++] = green;
+            buffer[position++] = blue;
+            buffer[position++] = alpha;
+            buffer[position++] = a;
+            buffer[position++] = b;
+            buffer[position++] = 0;
+            buffer[position++] = c;
+            buffer[position++] = d;
+            buffer[position++] = 0;
+            buffer[position++] = tx;
+            buffer[position++] = ty;
+            buffer[position++] = 0;
+        }
+        else {
+            // 座標A
+            buffer[position++] = vertex[0];
+            buffer[position++] = vertex[1];
+            buffer[position++] = 0.5;
+            buffer[position++] = 0.5;
+            buffer[position++] = red;
+            buffer[position++] = green;
+            buffer[position++] = blue;
+            buffer[position++] = alpha;
+            buffer[position++] = a;
+            buffer[position++] = b;
+            buffer[position++] = 0;
+            buffer[position++] = c;
+            buffer[position++] = d;
+            buffer[position++] = 0;
+            buffer[position++] = tx;
+            buffer[position++] = ty;
+            buffer[position++] = 0;
+            // 座標B
+            buffer[position++] = vertex[idx];
+            buffer[position++] = vertex[idx + 1];
+            buffer[position++] = 0.5;
+            buffer[position++] = 0.5;
+            buffer[position++] = red;
+            buffer[position++] = green;
+            buffer[position++] = blue;
+            buffer[position++] = alpha;
+            buffer[position++] = a;
+            buffer[position++] = b;
+            buffer[position++] = 0;
+            buffer[position++] = c;
+            buffer[position++] = d;
+            buffer[position++] = 0;
+            buffer[position++] = tx;
+            buffer[position++] = ty;
+            buffer[position++] = 0;
+            // 座標C
+            buffer[position++] = vertex[idx + 3];
+            buffer[position++] = vertex[idx + 4];
+            buffer[position++] = 0.5;
+            buffer[position++] = 0.5;
+            buffer[position++] = red;
+            buffer[position++] = green;
+            buffer[position++] = blue;
+            buffer[position++] = alpha;
+            buffer[position++] = a;
+            buffer[position++] = b;
+            buffer[position++] = 0;
+            buffer[position++] = c;
+            buffer[position++] = d;
+            buffer[position++] = 0;
+            buffer[position++] = tx;
+            buffer[position++] = ty;
+            buffer[position++] = 0;
+        }
+        index += 3;
+    }
+    return index;
+};

package/src/Mesh/service/MeshFindOverlappingPathsService.d.ts

@@ -0,0 +1,14 @@
+import type { IPath } from "../../interface/IPath";
+/**
+ * @description メッシュのパスの中で指定座標が含まれる線を探す
+ *              Find the lines containing the specified coordinates in the mesh path
+ *
+ * @param  {number} x
+ * @param  {number} y
+ * @param  {number} r
+ * @param  {IPath} paths
+ * @return {number[]}
+ * @method
+ * @protected
+ */
+export declare const execute: (x: number, y: number, r: number, paths: IPath) => number[];

package/src/Mesh/service/MeshFindOverlappingPathsService.js

@@ -0,0 +1,32 @@
+/**
+ * @description メッシュのパスの中で指定座標が含まれる線を探す
+ *              Find the lines containing the specified coordinates in the mesh path
+ *
+ * @param  {number} x
+ * @param  {number} y
+ * @param  {number} r
+ * @param  {IPath} paths
+ * @return {number[]}
+ * @method
+ * @protected
+ */
+export const execute = (x, y, r, paths) => {
+    const points = [];
+    // 浮動小数点誤差を考慮した許容範囲
+    const epsilon = 0.0001;
+    for (let idx = 0; idx < paths.length; idx += 3) {
+        // カーブのコントロール座標ならスキップ
+        if (paths[idx + 2]) {
+            continue;
+        }
+        const dx = paths[idx];
+        const dy = paths[idx + 1];
+        const distance = Math.sqrt(Math.pow(dx - x, 2) + Math.pow(dy - y, 2));
+        // 浮動小数点誤差を考慮した比較
+        if (Math.abs(distance - r) > epsilon) {
+            continue;
+        }
+        points.push(dx, dy);
+    }
+    return points;
+};

package/src/Mesh/service/MeshGenerateCalculateRoundCapService.d.ts

@@ -0,0 +1,13 @@
+import type { IPath } from "../../interface/IPath";
+/**
+ * @description 始点、終点から終点の反対側の線の丸みを算出
+ *              Calculate the roundness of the line on the opposite side of the end point from the start point
+ *
+ * @param  {IPath} vertices
+ * @param  {number} r
+ * @param  {IPath[]} rectangles
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (vertices: IPath, r: number, rectangles: IPath[]) => void;

package/src/Mesh/service/MeshGenerateCalculateRoundCapService.js

@@ -0,0 +1,51 @@
+/**
+ * @description 始点、終点から終点の反対側の線の丸みを算出
+ *              Calculate the roundness of the line on the opposite side of the end point from the start point
+ *
+ * @param  {IPath} vertices
+ * @param  {number} r
+ * @param  {IPath[]} rectangles
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (vertices, r, rectangles) => {
+    for (let idx = 0; idx < 2; ++idx) {
+        let sx = 0;
+        let sy = 0;
+        let ex = 0;
+        let ey = 0;
+        if (idx === 0) {
+            sx = vertices[0];
+            sy = vertices[1];
+            ex = vertices[3];
+            ey = vertices[4];
+        }
+        else {
+            sx = vertices[vertices.length - 3];
+            sy = vertices[vertices.length - 2];
+            ex = vertices[vertices.length - 6];
+            ey = vertices[vertices.length - 5];
+        }
+        const dx = ex - sx;
+        const dy = ey - sy;
+        const angleToEnd = Math.atan2(dy, dx);
+        const startAngle = angleToEnd + Math.PI / 2; // 反対側
+        const endAngle = angleToEnd - Math.PI / 2;
+        const segments = 16;
+        const step = (endAngle - startAngle) / segments;
+        const points = [];
+        for (let idx = 0; idx <= segments; idx++) {
+            const t = endAngle + step * idx;
+            const x = sx + r * Math.cos(t);
+            const y = sy + r * Math.sin(t);
+            points.push(x, y, false);
+        }
+        if (idx === 0) {
+            rectangles.unshift(points);
+        }
+        else {
+            rectangles.push(points);
+        }
+    }
+};

package/src/Mesh/service/MeshGenerateCalculateSquareCapService.d.ts

@@ -0,0 +1,13 @@
+import type { IPath } from "../../interface/IPath";
+/**
+ * @description 始点、終点から終点の反対側の矩形のパスを算出
+ *              Calculate the path of the rectangle on the opposite side of the end point from the start point
+ *
+ * @param  {IPath} vertices
+ * @param  {number} r
+ * @param  {IPath[]} rectangles
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (vertices: IPath, r: number, rectangles: IPath[]) => void;

package/src/Mesh/service/MeshGenerateCalculateSquareCapService.js

@@ -0,0 +1,64 @@
+/**
+ * @description 始点、終点から終点の反対側の矩形のパスを算出
+ *              Calculate the path of the rectangle on the opposite side of the end point from the start point
+ *
+ * @param  {IPath} vertices
+ * @param  {number} r
+ * @param  {IPath[]} rectangles
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (vertices, r, rectangles) => {
+    for (let idx = 0; idx < 2; ++idx) {
+        let sx = 0;
+        let sy = 0;
+        let ex = 0;
+        let ey = 0;
+        if (idx === 0) {
+            sx = vertices[0];
+            sy = vertices[1];
+            ex = vertices[3];
+            ey = vertices[4];
+        }
+        else {
+            sx = vertices[vertices.length - 3];
+            sy = vertices[vertices.length - 2];
+            ex = vertices[vertices.length - 6];
+            ey = vertices[vertices.length - 5];
+        }
+        // 「アンカー -> コントロール」のベクトル(dx, dy)
+        const dx = -(ex - sx);
+        const dy = -(ey - sy);
+        // ベクトル(dx, dy) の長さ
+        const length = Math.sqrt(dx * dx + dy * dy);
+        if (length === 0) {
+            // アンカーとコントロールが同じ場合はベクトルが作れない
+            continue;
+        }
+        // 正規化 (長さ1にする)
+        const ux = dx / length;
+        const uy = dy / length;
+        // 矩形キャップの中心点
+        //     → アンカー(ax, ay) から 逆方向ベクトルに r 分進めた場所
+        const cxn = sx + r * ux;
+        const cyn = sy + r * uy;
+        // 垂直ベクトル
+        const vx = -uy;
+        const vy = ux;
+        const points = [
+            cxn + r * ux + r * vx, cyn + r * uy + r * vy, false, // 1
+            cxn + r * ux - r * vx, cyn + r * uy - r * vy, false, // 2
+            cxn - r * ux - r * vx, cyn - r * uy - r * vy, false, // 3
+            cxn + r * ux + r * vx, cyn + r * uy + r * vy, false, // 1
+            cxn - r * ux - r * vx, cyn - r * uy - r * vy, false, // 3
+            cxn - r * ux + r * vx, cyn - r * uy + r * vy, false // 4
+        ];
+        if (idx === 0) {
+            rectangles.unshift(points);
+        }
+        else {
+            rectangles.push(points);
+        }
+    }
+};

package/src/Mesh/service/MeshGetQuadraticBezierPointService.d.ts

@@ -0,0 +1,14 @@
+import type { IPoint } from "../../interface/IPoint";
+/**
+ * @description 二次ベジエ曲線上の座標を計算する
+ *              Calculate the coordinates on the quadratic Bezier curve
+ *
+ * @param  {number} t
+ * @param  {IPoint} start_point
+ * @param  {IPoint} control_point
+ * @param  {IPoint} end_point
+ * @return {IPoint}
+ * @method
+ * @protected
+ */
+export declare const execute: (t: number, start_point: IPoint, control_point: IPoint, end_point: IPoint) => IPoint;

package/src/Mesh/service/MeshGetQuadraticBezierPointService.js

@@ -0,0 +1,18 @@
+/**
+ * @description 二次ベジエ曲線上の座標を計算する
+ *              Calculate the coordinates on the quadratic Bezier curve
+ *
+ * @param  {number} t
+ * @param  {IPoint} start_point
+ * @param  {IPoint} control_point
+ * @param  {IPoint} end_point
+ * @return {IPoint}
+ * @method
+ * @protected
+ */
+export const execute = (t, start_point, control_point, end_point) => {
+    return {
+        "x": (1 - t) ** 2 * start_point.x + 2 * (1 - t) * t * control_point.x + t ** 2 * end_point.x,
+        "y": (1 - t) ** 2 * start_point.y + 2 * (1 - t) * t * control_point.y + t ** 2 * end_point.y
+    };
+};

package/src/Mesh/service/MeshGetQuadraticBezierTangentService.d.ts

@@ -0,0 +1,14 @@
+import type { IPoint } from "../../interface/IPoint";
+/**
+ * @description 二次ベジエ曲線上の接線ベクトルを計算する
+ *              Calculate the tangent vector on the quadratic Bezier curve
+ *
+ * @param  {number} t
+ * @param  {IPoint} start_point
+ * @param  {IPoint} control_point
+ * @param  {IPoint} end_point
+ * @return {IPoint}
+ * @method
+ * @protected
+ */
+export declare const execute: (t: number, start_point: IPoint, control_point: IPoint, end_point: IPoint) => IPoint;

package/src/Mesh/service/MeshGetQuadraticBezierTangentService.js

@@ -0,0 +1,18 @@
+/**
+ * @description 二次ベジエ曲線上の接線ベクトルを計算する
+ *              Calculate the tangent vector on the quadratic Bezier curve
+ *
+ * @param  {number} t
+ * @param  {IPoint} start_point
+ * @param  {IPoint} control_point
+ * @param  {IPoint} end_point
+ * @return {IPoint}
+ * @method
+ * @protected
+ */
+export const execute = (t, start_point, control_point, end_point) => {
+    return {
+        "x": 2 * (1 - t) * (control_point.x - start_point.x) + 2 * t * (end_point.x - control_point.x),
+        "y": 2 * (1 - t) * (control_point.y - start_point.y) + 2 * t * (end_point.y - control_point.y)
+    };
+};

package/src/Mesh/service/MeshIsPointInsideRectangleService.d.ts

@@ -0,0 +1,12 @@
+import type { IPath } from "../../interface/IPath";
+/**
+ * @description 矩形内に含まれてない座標を返却
+ *              Returns coordinates that are not included in the rectangle
+ *
+ * @param  {number[]} points
+ * @param  {IPath} rectangle
+ * @return {number[] | null}
+ * @method
+ * @protected
+ */
+export declare const execute: (points: number[], rectangle: IPath) => number[] | null;

package/src/Mesh/service/MeshIsPointInsideRectangleService.js

@@ -0,0 +1,38 @@
+/**
+ * @description Canvas 2Dコンテキスト（点が矩形内にあるか判定用）
+ */
+const $canvas = new OffscreenCanvas(1, 1);
+const $canvasContext = $canvas.getContext("2d");
+/**
+ * @description 矩形内に含まれてない座標を返却
+ *              Returns coordinates that are not included in the rectangle
+ *
+ * @param  {number[]} points
+ * @param  {IPath} rectangle
+ * @return {number[] | null}
+ * @method
+ * @protected
+ */
+export const execute = (points, rectangle) => {
+    $canvasContext.beginPath();
+    $canvasContext.moveTo(rectangle[0], rectangle[1]);
+    for (let idx = 3; idx < rectangle.length; idx += 3) {
+        if (rectangle[idx + 2]) {
+            $canvasContext.quadraticCurveTo(rectangle[idx], rectangle[idx + 1], rectangle[idx + 3], rectangle[idx + 4]);
+            idx += 3;
+        }
+        else {
+            $canvasContext.lineTo(rectangle[idx], rectangle[idx + 1]);
+        }
+    }
+    $canvasContext.closePath();
+    for (let idx = 0; idx < points.length; idx += 2) {
+        const px = points[idx];
+        const py = points[idx + 1];
+        if ($canvasContext.isPointInPath(px, py)) {
+            continue;
+        }
+        return [px, py];
+    }
+    return null;
+};

package/src/Mesh/service/MeshLerpService.d.ts

@@ -0,0 +1,13 @@
+import type { IPoint } from "../../interface/IPoint";
+/**
+ * @description 線形補間
+ *              Linear interpolation
+ *
+ * @param  {IPoint} pointA
+ * @param  {IPoint} pointB
+ * @param  {number} t
+ * @return {IPoint}
+ * @method
+ * @protected
+ */
+export declare const execute: (pointA: IPoint, pointB: IPoint, t: number) => IPoint;

package/src/Mesh/service/MeshLerpService.js

@@ -0,0 +1,17 @@
+/**
+ * @description 線形補間
+ *              Linear interpolation
+ *
+ * @param  {IPoint} pointA
+ * @param  {IPoint} pointB
+ * @param  {number} t
+ * @return {IPoint}
+ * @method
+ * @protected
+ */
+export const execute = (pointA, pointB, t) => {
+    return {
+        "x": pointA.x + (pointB.x - pointA.x) * t,
+        "y": pointA.y + (pointB.y - pointA.y) * t
+    };
+};

package/src/Mesh/usecase/MeshApproximateOffsetQuadraticUseCase.d.ts

@@ -0,0 +1,14 @@
+import type { IPoint } from "../../interface/IPoint";
+/**
+ * @description 2次ベジエのオフセットを計算する
+ *              Calculate the offset of the quadratic Bezier
+ *
+ * @param  {IPoint} s0
+ * @param  {IPoint} s1
+ * @param  {IPoint} s2
+ * @param  {number} offset
+ * @return {IPoint[]}
+ * @method
+ * @protected
+ */
+export declare const execute: (s0: IPoint, s1: IPoint, s2: IPoint, offset: number) => IPoint[];

package/src/Mesh/usecase/MeshApproximateOffsetQuadraticUseCase.js

@@ -0,0 +1,35 @@
+import { execute as meshGetQuadraticBezierPointService } from "../service/MeshGetQuadraticBezierPointService";
+import { execute as meshGetQuadraticBezierTangentService } from "../service/MeshGetQuadraticBezierTangentService";
+import { execute as meshCalculateNormalizeBezierService } from "../service/MeshCalculateNormalizeBezierService";
+/**
+ * @description 2次ベジエのオフセットを計算する
+ *              Calculate the offset of the quadratic Bezier
+ *
+ * @param  {IPoint} s0
+ * @param  {IPoint} s1
+ * @param  {IPoint} s2
+ * @param  {number} offset
+ * @return {IPoint[]}
+ * @method
+ * @protected
+ */
+export const execute = (s0, s1, s2, offset) => {
+    const tValues = [0, 0.5, 1];
+    const newPoints = [];
+    for (let idx = 0; idx < tValues.length; ++idx) {
+        const t = tValues[idx];
+        const pos = meshGetQuadraticBezierPointService(t, s0, s1, s2);
+        const tan = meshGetQuadraticBezierTangentService(t, s0, s1, s2);
+        // 左方向の法線 = (-dy, dx)
+        const n = meshCalculateNormalizeBezierService({
+            "x": -tan.y,
+            "y": tan.x
+        });
+        newPoints.push({
+            "x": pos.x + n.x * offset,
+            "y": pos.y + n.y * offset
+        });
+    }
+    // [Q0, Q1, Q2]
+    return newPoints;
+};

package/src/Mesh/usecase/MeshCalculateCurveRectangleUseCase.d.ts

@@ -0,0 +1,15 @@
+import type { IPath } from "../../interface/IPath";
+import type { IPoint } from "../../interface/IPoint";
+/**
+ * @description カーブの矩形を計算する
+ *              Calculate curve rectangle
+ *
+ * @param  {IPoint} start_point
+ * @param  {IPoint} control_point
+ * @param  {IPoint} end_point
+ * @param  {number} thickness
+ * @return {IPath}
+ * @memthod
+ * @protected
+ */
+export declare const execute: (start_point: IPoint, control_point: IPoint, end_point: IPoint, thickness: number) => IPath;

package/src/Mesh/usecase/MeshCalculateCurveRectangleUseCase.js

@@ -0,0 +1,51 @@
+import { execute as meshSplitBezierMultipleTimesUseCase } from "./MeshSplitBezierMultipleTimesUseCase";
+import { execute as meshApproximateOffsetQuadraticUseCase } from "./MeshApproximateOffsetQuadraticUseCase";
+/**
+ * @description カーブの矩形を計算する
+ *              Calculate curve rectangle
+ *
+ * @param  {IPoint} start_point
+ * @param  {IPoint} control_point
+ * @param  {IPoint} end_point
+ * @param  {number} thickness
+ * @return {IPath}
+ * @memthod
+ * @protected
+ */
+export const execute = (start_point, control_point, end_point, thickness) => {
+    const segments = meshSplitBezierMultipleTimesUseCase(start_point, control_point, end_point, 5);
+    // "左右" にオフセットした2次ベジエを作る
+    // { leftCurves: [...], rightCurves: [...] } の形で保持する
+    // leftCurves[i] = [Q0, Q1, Q2] (2次ベジエの3点)
+    // rightCurves[i] = [Q0, Q1, Q2]
+    const leftCurves = [];
+    const rightCurves = [];
+    for (let idx = 0; idx < segments.length; ++idx) {
+        const [s0, s1, s2] = segments[idx];
+        // +offset と -offset を作成
+        leftCurves.push(meshApproximateOffsetQuadraticUseCase(s0, s1, s2, +thickness));
+        rightCurves.push(meshApproximateOffsetQuadraticUseCase(s0, s1, s2, -thickness));
+    }
+    // 左サイドの最初のサブカーブ始点
+    const leftStart = leftCurves[0][0];
+    const paths = [leftStart.x, leftStart.y, false];
+    // 左サイドの最終サブカーブ終了点 → 右サイドの最終サブカーブ終了点へ移動
+    for (let idx = 0; idx < leftCurves.length; ++idx) {
+        const curves = leftCurves[idx];
+        paths.push(curves[1].x, curves[1].y, true, curves[2].x, curves[2].y, false);
+    }
+    const reversedRight = [...rightCurves].reverse();
+    for (let idx = 0; idx < reversedRight.length; ++idx) {
+        const [q0, q1, q2] = reversedRight[idx];
+        reversedRight[idx] = [q2, q1, q0]; // [Q2, Q1, Q0]
+    }
+    // 右サイドの最初のサブカーブ始点
+    const rightEnd = reversedRight[0][0];
+    paths.push(rightEnd.x, rightEnd.y, false);
+    // 右サイドの最終サブカーブ終了点 → 左サイドの最終サブカーブ終了点へ移動
+    for (let idx = 0; idx < reversedRight.length; ++idx) {
+        const curves = reversedRight[idx];
+        paths.push(curves[1].x, curves[1].y, true, curves[2].x, curves[2].y, false);
+    }
+    return paths;
+};

package/src/Mesh/usecase/MeshCalculateLineRectangleUseCase.d.ts

@@ -0,0 +1,14 @@
+import type { IPath } from "../../interface/IPath";
+import type { IPoint } from "../../interface/IPoint";
+/**
+ * @description 直線の矩形を計算
+ *              Calculate the rectangle of a line
+ *
+ * @param  {IPoint} start_point
+ * @param  {IPoint} end_point
+ * @param  {number} thickness
+ * @return {IPath}
+ * @method
+ * @protected
+ */
+export declare const execute: (start_point: IPoint, end_point: IPoint, thickness: number) => IPath;