@next2d/webgl 1.18.12 → 2.0.0

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;

package/src/Mesh/usecase/MeshCalculateLineRectangleUseCase.js

@@ -0,0 +1,42 @@
+import { execute as meshCalculateNormalVectorService } from "../service/MeshCalculateNormalVectorService";
+/**
+ * @description 直線の矩形を計算
+ *              Calculate the rectangle of a line
+ *
+ * @param  {IPoint} start_point
+ * @param  {IPoint} end_point
+ * @param  {number} thickness
+ * @return {IPath}
+ * @method
+ * @protected
+ */
+export const execute = (start_point, end_point, thickness) => {
+    const vector = {
+        "x": end_point.x - start_point.x,
+        "y": end_point.y - start_point.y
+    };
+    const normal = meshCalculateNormalVectorService(vector.x, vector.y, thickness);
+    const shiftedUpStart = {
+        "x": start_point.x + normal.x,
+        "y": start_point.y + normal.y
+    };
+    const shiftedUpEnd = {
+        "x": end_point.x + normal.x,
+        "y": end_point.y + normal.y
+    };
+    const shiftedDownStart = {
+        "x": start_point.x - normal.x,
+        "y": start_point.y - normal.y
+    };
+    const shiftedDownEnd = {
+        "x": end_point.x - normal.x,
+        "y": end_point.y - normal.y
+    };
+    return [
+        shiftedUpStart.x, shiftedUpStart.y, false,
+        shiftedUpEnd.x, shiftedUpEnd.y, false,
+        shiftedDownEnd.x, shiftedDownEnd.y, false,
+        shiftedDownStart.x, shiftedDownStart.y, false,
+        shiftedUpStart.x, shiftedUpStart.y, false
+    ];
+};

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

@@ -0,0 +1,12 @@
+import type { IPath } from "../../interface/IPath";
+import type { IFillMesh } from "../../interface/IFillMesh";
+/**
+ * @description 塗りのメッシュを生成する
+ *              Generate a fill mesh
+ *
+ * @param  {IPath[]} vertices
+ * @return {IFillMesh}
+ * @method
+ * @protected
+ */
+export declare const execute: (vertices: IPath[], style?: "fill" | "stroke") => IFillMesh;

package/src/Mesh/usecase/MeshFillGenerateUseCase.js

@@ -0,0 +1,42 @@
+import { execute as meshFillGenerateService } from "../service/MeshFillGenerateService";
+import { $context, $getViewportWidth, $getViewportHeight } from "../../WebGLUtil";
+/**
+ * @description 塗りのメッシュを生成する
+ *              Generate a fill mesh
+ *
+ * @param  {IPath[]} vertices
+ * @return {IFillMesh}
+ * @method
+ * @protected
+ */
+export const execute = (vertices, style = "fill") => {
+    const colorStyle = style === "fill"
+        ? $context.$fillStyle
+        : $context.$strokeStyle;
+    const red = colorStyle[0];
+    const green = colorStyle[1];
+    const blue = colorStyle[2];
+    const alpha = colorStyle[3];
+    const matrix = $context.$matrix;
+    const width = $getViewportWidth();
+    const height = $getViewportHeight();
+    const a = matrix[0] / width;
+    const c = matrix[3] / width;
+    const tx = matrix[6] / width;
+    const b = matrix[1] / height;
+    const d = matrix[4] / height;
+    const ty = matrix[7] / height;
+    let length = 0;
+    for (let idx = 0; idx < vertices.length; ++idx) {
+        length += (vertices[idx].length / 3 - 2) * 51;
+    }
+    const buffer = new Float32Array(length);
+    let currentIndex = 0;
+    for (let idx = 0; idx < vertices.length; ++idx) {
+        currentIndex = meshFillGenerateService(vertices[idx], buffer, currentIndex, a, b, c, d, tx, ty, red, green, blue, alpha);
+    }
+    return {
+        "buffer": buffer,
+        "indexCount": currentIndex
+    };
+};

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

@@ -0,0 +1,15 @@
+import type { IPath } from "../../interface/IPath";
+/**
+ * @description 線と線の繋ぎ目を繋ぐ
+ *              Connect the connection between lines
+ *
+ * @param  {number} x
+ * @param  {number} y
+ * @param  {number} r
+ * @param  {IPath[]} rectangles
+ * @param  {boolean} [is_last=false]
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (x: number, y: number, r: number, rectangles: IPath[], is_last?: boolean) => void;

package/src/Mesh/usecase/MeshGenerateCalculateBevelJoinUseCase.js

@@ -0,0 +1,40 @@
+import { execute as meshFindOverlappingPathsUseCase } from "../service/MeshFindOverlappingPathsService";
+import { execute as meshIsPointInsideRectangleService } from "../service/MeshIsPointInsideRectangleService";
+/**
+ * @description 線と線の繋ぎ目を繋ぐ
+ *              Connect the connection between lines
+ *
+ * @param  {number} x
+ * @param  {number} y
+ * @param  {number} r
+ * @param  {IPath[]} rectangles
+ * @param  {boolean} [is_last=false]
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (x, y, r, rectangles, is_last = false) => {
+    const indexA = is_last ? 0 : rectangles.length - 1;
+    const indexB = is_last ? rectangles.length - 1 : rectangles.length - 2;
+    const pathsA = meshFindOverlappingPathsUseCase(x, y, r, rectangles[indexA]);
+    const pathsB = meshFindOverlappingPathsUseCase(x, y, r, rectangles[indexB]);
+    // パスが並行であれば終了
+    if (pathsA[0] === pathsB[0] && pathsA[1] === pathsB[1]
+        || pathsA[0] === pathsB[2] && pathsA[1] === pathsB[3]) {
+        return;
+    }
+    const pointA = meshIsPointInsideRectangleService(pathsA, rectangles[indexB]);
+    if (!pointA) {
+        return;
+    }
+    const pointB = meshIsPointInsideRectangleService(pathsB, rectangles[indexA]);
+    if (!pointB) {
+        return;
+    }
+    rectangles.splice(-1, 0, [
+        x, y, false,
+        pointA[0], pointA[1], false,
+        pointB[0], pointB[1], false,
+        x, y, false
+    ]);
+};

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

@@ -0,0 +1,17 @@
+import type { IPath } from "../../interface/IPath";
+import type { IPoint } from "../../interface/IPoint";
+/**
+ * @description 線と線の繋ぎ目をmiterで繋ぐ
+ *              Connect the connection between lines with miter
+ *
+ * @param  {IPoint} start_point
+ * @param  {IPoint} end_point
+ * @param  {IPoint} prev_point
+ * @param  {number} r
+ * @param  {IPath[]} rectangles
+ * @param  {boolean} [is_last=false]
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (start_point: IPoint, end_point: IPoint, prev_point: IPoint, r: number, rectangles: IPath[], is_last?: boolean) => void;

package/src/Mesh/usecase/MeshGenerateCalculateMiterJoinUseCase.js

@@ -0,0 +1,70 @@
+import { execute as meshFindOverlappingPathsUseCase } from "../service/MeshFindOverlappingPathsService";
+import { execute as meshIsPointInsideRectangleService } from "../service/MeshIsPointInsideRectangleService";
+/**
+ * @description 線と線の繋ぎ目をmiterで繋ぐ
+ *              Connect the connection between lines with miter
+ *
+ * @param  {IPoint} start_point
+ * @param  {IPoint} end_point
+ * @param  {IPoint} prev_point
+ * @param  {number} r
+ * @param  {IPath[]} rectangles
+ * @param  {boolean} [is_last=false]
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (start_point, end_point, prev_point, r, rectangles, is_last = false) => {
+    const indexA = is_last ? 0 : rectangles.length - 1;
+    const indexB = is_last ? rectangles.length - 1 : rectangles.length - 2;
+    const pathsA = meshFindOverlappingPathsUseCase(start_point.x, start_point.y, r, rectangles[indexA]);
+    const pathsB = meshFindOverlappingPathsUseCase(start_point.x, start_point.y, r, rectangles[indexB]);
+    // パスが並行であれば終了
+    if (pathsA[0] === pathsB[0] && pathsA[1] === pathsB[1]
+        || pathsA[0] === pathsB[2] && pathsA[1] === pathsB[3]) {
+        return;
+    }
+    const pointA = meshIsPointInsideRectangleService(pathsA, rectangles[indexB]);
+    if (!pointA) {
+        return;
+    }
+    const pointB = meshIsPointInsideRectangleService(pathsB, rectangles[indexA]);
+    if (!pointB) {
+        return;
+    }
+    const aVx = end_point.x - start_point.x;
+    const aVy = end_point.y - start_point.y;
+    const lengthA = Math.hypot(aVx, aVy);
+    const normalizeA = {
+        "x": aVx / lengthA,
+        "y": aVy / lengthA
+    };
+    const bVx = prev_point.x - start_point.x;
+    const bVy = prev_point.y - start_point.y;
+    const lengthB = Math.hypot(bVx, bVy);
+    const normalizeB = {
+        "x": bVx / lengthB,
+        "y": bVy / lengthB
+    };
+    const d1x = normalizeA.x, d1y = normalizeA.y;
+    const d2x = normalizeB.x, d2y = normalizeB.y;
+    const denom = d1x * d2y - d1y * d2x;
+    if (denom === 0) {
+        rectangles.splice(-1, 0, [
+            start_point.x, start_point.y, false,
+            pointA[0], pointA[1], false,
+            pointB[0], pointB[1], false
+        ]);
+    }
+    const t = ((pointB[0] - pointA[0]) * d2y - (pointB[1] - pointA[1]) * d2x) / denom;
+    const ix = pointA[0] + t * d1x;
+    const iy = pointA[1] + t * d1y;
+    rectangles.splice(-1, 0, [
+        start_point.x, start_point.y, false,
+        pointA[0], pointA[1], false,
+        ix, iy, false,
+        start_point.x, start_point.y, false,
+        pointB[0], pointB[1], false,
+        ix, iy, false
+    ]);
+};

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

@@ -0,0 +1,15 @@
+import type { IPath } from "../../interface/IPath";
+/**
+ * @description 線と線の繋ぎ目を丸くする
+ *              Make the connection between lines round
+ *
+ * @param  {number} x
+ * @param  {number} y
+ * @param  {number} r
+ * @param  {IPath[]} rectangles
+ * @param  {boolean} [is_last=false]
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const execute: (x: number, y: number, r: number, rectangles: IPath[], is_last?: boolean) => void;

package/src/Mesh/usecase/MeshGenerateCalculateRoundJoinUseCase.js

@@ -0,0 +1,51 @@
+import { execute as meshFindOverlappingPathsService } from "../service/MeshFindOverlappingPathsService";
+import { execute as meshIsPointInsideRectangleService } from "../service/MeshIsPointInsideRectangleService";
+/**
+ * @description 線と線の繋ぎ目を丸くする
+ *              Make the connection between lines round
+ *
+ * @param  {number} x
+ * @param  {number} y
+ * @param  {number} r
+ * @param  {IPath[]} rectangles
+ * @param  {boolean} [is_last=false]
+ * @return {void}
+ * @method
+ * @protected
+ */
+export const execute = (x, y, r, rectangles, is_last = false) => {
+    const indexA = is_last ? 0 : rectangles.length - 1;
+    const indexB = is_last ? rectangles.length - 1 : rectangles.length - 2;
+    const pathsA = meshFindOverlappingPathsService(x, y, r, rectangles[indexA]);
+    const pathsB = meshFindOverlappingPathsService(x, y, r, rectangles[indexB]);
+    const pointA = meshIsPointInsideRectangleService(pathsA, rectangles[indexB]);
+    // 接続点が矩形の内部にある場合は終了
+    if (!pointA) {
+        return;
+    }
+    const pointB = meshIsPointInsideRectangleService(pathsB, rectangles[indexA]);
+    // 接続点が矩形の内部にある場合は終了
+    if (!pointB) {
+        return;
+    }
+    const angleA = Math.atan2(pointA[1] - y, pointA[0] - x);
+    const angleB = Math.atan2(pointB[1] - y, pointB[0] - x);
+    // 角度差を正規化して180度以下にする
+    let angleDiff = angleB - angleA;
+    if (angleDiff > Math.PI) {
+        angleDiff -= 2 * Math.PI;
+    }
+    else if (angleDiff < -Math.PI) {
+        angleDiff += 2 * Math.PI;
+    }
+    const segment = 8;
+    const step = angleDiff / segment;
+    const points = [x, y, false];
+    for (let idx = 0; idx <= segment; idx++) {
+        const angle = angleA + idx * step;
+        const dx = x + r * Math.cos(angle);
+        const dy = y + r * Math.sin(angle);
+        points.push(dx, dy, false);
+    }
+    rectangles.splice(-1, 0, points);
+};

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

@@ -0,0 +1,12 @@
+import type { IPath } from "../../interface/IPath";
+/**
+ * @description 線の外周を算出して塗りのフォーマットで返却
+ *              Calculate the outer circumference of the line and return it in the format of the fill
+ *
+ * @param  {IPath} vertices
+ * @param  {number} thickness
+ * @return {IPath[]}
+ * @method
+ * @protected
+ */
+export declare const execute: (vertices: IPath, thickness: number) => IPath[];

package/src/Mesh/usecase/MeshGenerateStrokeOutlineUseCase.js

@@ -0,0 +1,108 @@
+import { execute as meshCalculateLineRectangleUseCase } from "./MeshCalculateLineRectangleUseCase";
+import { execute as meshCalculateCurveRectangleUseCase } from "./MeshCalculateCurveRectangleUseCase";
+import { execute as meshGenerateCalculateRoundJoinUseCase } from "./MeshGenerateCalculateRoundJoinUseCase";
+import { execute as meshGenerateCalculateBevelJoinUseCase } from "./MeshGenerateCalculateBevelJoinUseCase";
+import { execute as meshGenerateCalculateRoundCapService } from "../service/MeshGenerateCalculateRoundCapService";
+import { execute as meshGenerateCalculateSquareCapService } from "../service/MeshGenerateCalculateSquareCapService";
+import { execute as meshGenerateCalculateMiterJoinUseCase } from "../usecase/MeshGenerateCalculateMiterJoinUseCase";
+import { $context } from "../../WebGLUtil";
+/**
+ * @description 線の外周を算出して塗りのフォーマットで返却
+ *              Calculate the outer circumference of the line and return it in the format of the fill
+ *
+ * @param  {IPath} vertices
+ * @param  {number} thickness
+ * @return {IPath[]}
+ * @method
+ * @protected
+ */
+export const execute = (vertices, thickness) => {
+    const startPoint = {
+        "x": vertices[0],
+        "y": vertices[1]
+    };
+    const controlPoint = {
+        "x": 0,
+        "y": 0
+    };
+    const endPoint = {
+        "x": 0,
+        "y": 0
+    };
+    const prevPoint = {
+        "x": 0,
+        "y": 0
+    };
+    const rectangles = [];
+    for (let idx = 3; idx < vertices.length; idx += 3) {
+        const x = vertices[idx];
+        const y = vertices[idx + 1];
+        if (vertices[idx + 2]) {
+            controlPoint.x = x;
+            controlPoint.y = y;
+            continue;
+        }
+        endPoint.x = x;
+        endPoint.y = y;
+        if (vertices[idx - 1]) {
+            rectangles.push(meshCalculateCurveRectangleUseCase(startPoint, controlPoint, endPoint, thickness));
+        }
+        else {
+            rectangles.push(meshCalculateLineRectangleUseCase(startPoint, endPoint, thickness));
+        }
+        if (rectangles.length > 1) {
+            switch ($context.joints) {
+                case 0: // bevel
+                    meshGenerateCalculateBevelJoinUseCase(startPoint.x, startPoint.y, thickness, rectangles);
+                    break;
+                case 1: // miter
+                    prevPoint.x = vertices[idx - 6];
+                    prevPoint.y = vertices[idx - 5];
+                    meshGenerateCalculateMiterJoinUseCase(startPoint, endPoint, prevPoint, thickness, rectangles);
+                    break;
+                case 2: // round
+                    meshGenerateCalculateRoundJoinUseCase(startPoint.x, startPoint.y, thickness, rectangles);
+                    break;
+            }
+        }
+        startPoint.x = endPoint.x;
+        startPoint.y = endPoint.y;
+    }
+    if (vertices[0] === vertices[vertices.length - 3]
+        && vertices[1] === vertices[vertices.length - 2]) {
+        // 始点と終点が繋がっている時はjointsの設定を適用
+        switch ($context.joints) {
+            case 0: // bevel
+                meshGenerateCalculateBevelJoinUseCase(startPoint.x, startPoint.y, thickness, rectangles, true);
+                break;
+            case 1: // miter
+                startPoint.x = vertices[0];
+                startPoint.y = vertices[1];
+                endPoint.x = vertices[3];
+                endPoint.y = vertices[4];
+                prevPoint.x = vertices[vertices.length - 6];
+                prevPoint.y = vertices[vertices.length - 5];
+                meshGenerateCalculateMiterJoinUseCase(startPoint, endPoint, prevPoint, thickness, rectangles, true);
+                break;
+            case 2: // round
+                meshGenerateCalculateRoundJoinUseCase(startPoint.x, startPoint.y, thickness, rectangles, true);
+                break;
+            default:
+                break;
+        }
+    }
+    else {
+        // 始点と終点が繋がってない時はcapsの設定を適用
+        switch ($context.caps) {
+            case 1: // round
+                meshGenerateCalculateRoundCapService(vertices, thickness, rectangles);
+                break;
+            case 2: // square:
+                meshGenerateCalculateSquareCapService(vertices, thickness, rectangles);
+                break;
+            default:
+                break;
+        }
+    }
+    return rectangles;
+};

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

@@ -0,0 +1,14 @@
+import type { IPoint } from "../../interface/IPoint";
+/**
+ * @description ベジェ曲線を指定回数分割する
+ *              Divides a Bezier curve a specified number of times
+ *
+ * @param {IPoint} start_point
+ * @param {IPoint} control_point
+ * @param {IPoint} end_point
+ * @param {number} [n = 4]
+ * @return {Array<IPoint[]>}
+ * @method
+ * @protected
+ */
+export declare const execute: (start_point: IPoint, control_point: IPoint, end_point: IPoint, n?: number) => Array<IPoint[]>;

package/src/Mesh/usecase/MeshSplitBezierMultipleTimesUseCase.js

@@ -0,0 +1,32 @@
+import { execute as meshSplitQuadraticBezierUseCase } from "./MeshSplitQuadraticBezierUseCase";
+/**
+ * @description ベジェ曲線を指定回数分割する
+ *              Divides a Bezier curve a specified number of times
+ *
+ * @param {IPoint} start_point
+ * @param {IPoint} control_point
+ * @param {IPoint} end_point
+ * @param {number} [n = 4]
+ * @return {Array<IPoint[]>}
+ * @method
+ * @protected
+ */
+export const execute = (start_point, control_point, end_point, n = 4) => {
+    // 初期リスト：1本だけ
+    let segments = [[start_point, control_point, end_point]];
+    for (let idx = 0; idx < n; ++idx) {
+        const newSegments = [];
+        for (let idx = 0; idx < segments.length; ++idx) {
+            const seg = segments[idx];
+            if (!seg) {
+                continue;
+            }
+            // seg = [s0, s1, s2]
+            const splitted = meshSplitQuadraticBezierUseCase(seg[0], seg[1], seg[2], 0.5);
+            newSegments.push(splitted[0], splitted[1]);
+        }
+        segments = newSegments;
+    }
+    // segmentsには 2^n 本の [x,y]が入る
+    return segments; // [[p0,p1,p2], [p0,p1,p2], ...]
+};

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

@@ -0,0 +1,14 @@
+import type { IPoint } from "../../interface/IPoint";
+/**
+ * @description 二次ベジェ曲線を分割する
+ *              Split a quadratic Bezier curve
+ *
+ * @param  {IPoint} start_point
+ * @param  {IPoint} control_point
+ * @param  {IPoint} end_point
+ * @param  {number} [t = 0.5]
+ * @return {Array<IPoint[]>}
+ * @method
+ * @protected
+ */
+export declare const execute: (start_point: IPoint, control_point: IPoint, end_point: IPoint, t?: number) => Array<IPoint[]>;

package/src/Mesh/usecase/MeshSplitQuadraticBezierUseCase.js

@@ -0,0 +1,28 @@
+import { execute as meshLerpService } from "../service/MeshLerpService";
+/**
+ * @description 二次ベジェ曲線を分割する
+ *              Split a quadratic Bezier curve
+ *
+ * @param  {IPoint} start_point
+ * @param  {IPoint} control_point
+ * @param  {IPoint} end_point
+ * @param  {number} [t = 0.5]
+ * @return {Array<IPoint[]>}
+ * @method
+ * @protected
+ */
+export const execute = (start_point, control_point, end_point, t = 0.5) => {
+    // 二次ベジエ曲線の分割
+    // M0  = lerp(P0, P1, t)
+    // M1  = lerp(P1, P2, t)
+    // M01 = lerp(M0, M1, t)
+    const M0 = meshLerpService(start_point, control_point, t);
+    const M1 = meshLerpService(control_point, end_point, t);
+    const M01 = meshLerpService(M0, M1, t);
+    // 左サブ (0...t): [P0,  M0, M01]
+    // 右サブ (t...1): [M01, M1, P2]
+    return [
+        [start_point, M0, M01],
+        [M01, M1, end_point]
+    ];
+};

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

@@ -0,0 +1,12 @@
+import type { IFillMesh } from "../../interface/IFillMesh";
+import type { IPath } from "../../interface/IPath";
+/**
+ * @description ストロークのメッシュを生成
+ *              Generate a stroke mesh
+ *
+ * @param  {IPath[]} vertices
+ * @return {IFillMesh}
+ * @method
+ * @protected
+ */
+export declare const execute: (vertices: IPath[]) => IFillMesh;

package/src/Mesh/usecase/MeshStrokeGenerateUseCase.js

@@ -0,0 +1,21 @@
+import { execute as meshGenerateStrokeOutlineUseCase } from "./MeshGenerateStrokeOutlineUseCase";
+import { execute as meshFillGenerateUseCase } from "./MeshFillGenerateUseCase";
+import { $context } from "../../WebGLUtil";
+/**
+ * @description ストロークのメッシュを生成
+ *              Generate a stroke mesh
+ *
+ * @param  {IPath[]} vertices
+ * @return {IFillMesh}
+ * @method
+ * @protected
+ */
+export const execute = (vertices) => {
+    const thickness = $context.thickness / 2;
+    const fillVertices = [];
+    for (let idx = 0; idx < vertices.length; ++idx) {
+        const vertex = meshGenerateStrokeOutlineUseCase(vertices[idx], thickness);
+        fillVertices.push(...vertex);
+    }
+    return meshFillGenerateUseCase(fillVertices, "stroke");
+};

package/src/Mesh.d.ts

@@ -0,0 +1,64 @@
+import type { IFillType } from "./interface/IFillType";
+/**
+ * @description 指定された値を2の累乗に切り上げます。
+ *              Rounds the specified value up to a power of two.
+ *
+ * @param  {number} v
+ * @return {number}
+ * @method
+ * @protected
+ */
+export declare const $upperPowerOfTwo: (v: number) => number;
+/**
+ * @description バッファを埋めるデータを返却
+ *              Returns the data to fill the buffer
+ *
+ * @return {Float32Array}
+ * @method
+ * @protected
+ */
+export declare const $getFillBuffer: () => Float32Array;
+/**
+ * @description バッファを埋めるデータのオフセットを返却
+ *              Returns the offset of the data to fill the buffer
+ *
+ * @return {number}
+ * @method
+ * @protected
+ */
+export declare const $getFillBufferOffset: () => number;
+/**
+ * @description バッファを埋めるデータを設定
+ *              Set the data to fill the buffer
+ *
+ * @param  {Float32Array} buffer
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const $addFillBuffer: (buffer: Float32Array) => void;
+/**
+ * @description バッファを頂点数の配列
+ *              Array of the number of vertices in the buffer
+ *
+ * @type {number[]}
+ * @protected
+ */
+export declare const $fillBufferIndexes: number[];
+/**
+ * @description 塗りの種類の配列
+ *              Array of fill types
+ *
+ * @type {IFillType[]}
+ * @protected
+ */
+export declare const $fillTypes: IFillType[];
+/**
+ * @description 頂点情報の設定値を初期化
+ *              Initializes the setting value of the vertex information
+ *
+ * @return {void}
+ * @method
+ * @protected
+ */
+export declare const $clearFillBufferSetting: () => void;