poly-extrude 0.13.0 → 0.14.0

package/package.json

@@ -1,48 +1,53 @@
-{
-  "name": "poly-extrude",
-  "version": "0.13.0",
-  "description": "",
-  "main": "dist/poly-extrude.js",
-  "module": "dist/poly-extrude.mjs",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "lint": "eslint src/**/*.js",
-    "build": "npm run lint && cross-env NODE_ENV=prd  rollup -c",
-    "dev": "npm run lint && cross-env NODE_ENV=dev  rollup -c -w"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/deyihu/poly-extrude.git"
-  },
-  "author": "",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/deyihu/poly-extrude/issues"
-  },
-  "homepage": "https://github.com/deyihu/poly-extrude#readme",
-  "devDependencies": {
-    "@babel/core": "^7.17.5",
-    "@babel/preset-env": "^7.16.11",
-    "@rollup/plugin-babel": "^5.3.0",
-    "@rollup/plugin-commonjs": "^21.0.1",
-    "@rollup/plugin-json": "^4.1.0",
-    "@rollup/plugin-node-resolve": "^13.1.3",
-    "cross-env": "^5.1.4",
-    "eslint": "^6.2.2",
-    "eslint-config-standard": "^14.1.0",
-    "eslint-plugin-import": "^2.18.2",
-    "eslint-plugin-node": "^10.0.0",
-    "eslint-plugin-promise": "^4.2.1",
-    "eslint-plugin-standard": "^4.0.1",
-    "rollup": "^2.64.0",
-    "rollup-plugin-terser": "^7.0.2"
-  },
-  "dependencies": {
-    "earcut": "^2.2.4"
-  },
-  "files": [
-    "dist/",
-    "src/",
-    "index.js"
-  ]
-}
+{
+  "name": "poly-extrude",
+  "version": "0.14.0",
+  "description": "extrude polyline/polygon etc",
+  "main": "dist/poly-extrude.js",
+  "module": "dist/poly-extrude.mjs",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "tsc": "npx tsc",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "lint": "eslint src/**/*.js",
+    "build": "npm run lint && npm run tsc  && cross-env NODE_ENV=prd  rollup -c",
+    "dev": "npm run lint && cross-env NODE_ENV=dev  rollup -c -w"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/deyihu/poly-extrude.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/deyihu/poly-extrude/issues"
+  },
+  "homepage": "https://github.com/deyihu/poly-extrude#readme",
+  "devDependencies": {
+    "@babel/core": "^7.17.5",
+    "@babel/preset-env": "^7.16.11",
+    "@rollup/plugin-babel": "^5.3.0",
+    "@rollup/plugin-commonjs": "^21.0.1",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^13.1.3",
+    "@rollup/plugin-typescript": "^8.3.0",
+    "cross-env": "^5.1.4",
+    "eslint": "^6.2.2",
+    "eslint-config-standard": "^14.1.0",
+    "eslint-plugin-import": "^2.18.2",
+    "eslint-plugin-node": "^10.0.0",
+    "eslint-plugin-promise": "^4.2.1",
+    "eslint-plugin-standard": "^4.0.1",
+    "rollup": "^2.64.0",
+    "rollup-plugin-terser": "^7.0.2",
+    "typescript": "^5.7.2",
+    "tslib": "^2.8.1"
+  },
+  "dependencies": {
+    "earcut": "^2.2.4"
+  },
+  "files": [
+    "dist/",
+    "src/",
+    "index.js"
+  ]
+}

package/readme.md

@@ -19,6 +19,7 @@ Extrude polygons/polylines. Born in [maptalks.three](https://github.com/maptalks
 [![](./gallery/slope.png)](https://deyihu.github.io/poly-extrude/test/slope.html)<br>
 
 [![](./gallery/tube.png)](https://deyihu.github.io/poly-extrude/test/tube.html)<br>
+[![](./gallery/terrain.png)](https://deyihu.github.io/poly-extrude/test/terrain.html)<br>
 
 ## Install
 
@@ -43,7 +44,8 @@ npm i poly-extrude
       cylinder,
       expandPaths,
       extrudeSlopes,
-      expandTubes
+      expandTubes,
+      plane
   } from 'poly-extrude';
 
   //if you use cdn,the namespace is polyextrude
@@ -133,6 +135,8 @@ npm i poly-extrude
 * `options.bottomStickGround`  Is the bottom attached to the ground 
 * `options.pathUV`  generate Path UV
 
+[extrudePolylines pathUV demo](https://deyihu.github.io/poly-extrude/test/line-pathuv.html)
+
 ```js
    const result = extrudePolylines(polylines, {
        depth: 2,
@@ -212,6 +216,9 @@ const {
 * `options.bottomStickGround` Is the bottom attached to the ground
 * `options.pathUV`  generate Path UV
 
+
+[extrudeSlopes pathUV demo](https://deyihu.github.io/poly-extrude/test/slope-pathuv.html)
+
 ```js
 const result = extrudeSlopes(polylines, {
 
@@ -267,8 +274,11 @@ const {
 * `devideW`
 * `devideH`
 
+[plane demo](https://deyihu.github.io/poly-extrude/test/plane.html)  
+[custom terrain demo](https://deyihu.github.io/poly-extrude/test/terrain.html)
+
 ```js
-const result = plane(100,100,10,10);
+const result = plane(100, 100, 10, 10);
 const {
 
     positon,

package/src/cylinder.ts

@@ -0,0 +1,124 @@
+import { ResultType } from './type';
+import { generateNormal } from './util';
+
+type CylinderOptions = {
+    radius?: number;
+    height?: number;
+    radialSegments?: number;
+}
+
+type CylinderResult = ResultType & {
+    points: Float32Array
+}
+
+export function cylinder(point: [number, number], options?: CylinderOptions): CylinderResult {
+    options = Object.assign({}, { radius: 1, height: 2, radialSegments: 6 }, options);
+    const radialSegments = Math.round(Math.max(4, options.radialSegments as number));
+    let { radius, height } = options;
+    radius = (radius as number);
+    height = (height as number);
+    const aRad = 360 / radialSegments / 360 * Math.PI * 2;
+    const circlePointsLen = (radialSegments + 1);
+    const points = new Float32Array(circlePointsLen * 3 * 2);
+    const [centerx, centery] = point;
+    let idx = 0, uIdx = 0;
+    const offset = circlePointsLen * 3, uOffset = circlePointsLen * 2;
+    const indices: number[] = [], uv: number[] = [];
+    let iIndex = indices.length - 1;
+    for (let i = -1; i < radialSegments; i++) {
+        const rad = aRad * i;
+        const x = Math.cos(rad) * radius + centerx, y = Math.sin(rad) * radius + centery;
+        // bottom vertices
+        points[idx] = x;
+        points[idx + 1] = y;
+        points[idx + 2] = 0;
+
+        // top vertices
+        points[idx + offset] = x;
+        points[idx + 1 + offset] = y;
+        points[idx + 2 + offset] = height;
+
+        let u = 0, v = 0;
+        u = 0.5 + x / radius / 2;
+        v = 0.5 + y / radius / 2;
+        uv[uIdx] = u;
+        uv[uIdx + 1] = v;
+        uv[uIdx + uOffset] = u;
+        uv[uIdx + 1 + uOffset] = v;
+
+        idx += 3;
+        uIdx += 2;
+        if (i > 1) {
+            // bottom indices
+            // indices.push(0, i - 1, i);
+            indices[++iIndex] = 0;
+            indices[++iIndex] = i - 1;
+            indices[++iIndex] = i;
+        }
+    }
+    idx -= 3;
+    points[idx] = points[0];
+    points[idx + 1] = points[1];
+    points[idx + 2] = points[2];
+    const pointsLen = points.length;
+    points[pointsLen - 3] = points[0];
+    points[pointsLen - 2] = points[1];
+    points[pointsLen - 1] = height;
+
+    const indicesLen = indices.length;
+    // top indices
+    iIndex = indices.length - 1;
+    for (let i = 0; i < indicesLen; i++) {
+        const index = indices[i];
+        indices[++iIndex] = index + circlePointsLen;
+        // indices.push(index + circlePointsLen);
+    }
+
+    const sidePoints = new Float32Array((circlePointsLen * 3 * 2 - 6) * 2);
+    let pIndex = -1;
+    idx = circlePointsLen * 2;
+    uIdx = 0;
+    iIndex = indices.length - 1;
+    let uvIndex = uv.length - 1;
+    for (let i = 0, len = points.length / 2; i < len - 3; i += 3) {
+        const x1 = points[i], y1 = points[i + 1], x2 = points[i + 3], y2 = points[i + 4];
+        sidePoints[++pIndex] = x1;
+        sidePoints[++pIndex] = y1;
+        sidePoints[++pIndex] = height;
+        sidePoints[++pIndex] = x2;
+        sidePoints[++pIndex] = y2;
+        sidePoints[++pIndex] = height;
+        sidePoints[++pIndex] = x1;
+        sidePoints[++pIndex] = y1;
+        sidePoints[++pIndex] = 0;
+        sidePoints[++pIndex] = x2;
+        sidePoints[++pIndex] = y2;
+        sidePoints[++pIndex] = 0;
+        const a = idx + 2, b = idx + 3, c = idx, d = idx + 1;
+        // indices.push(a, c, b, c, d, b);
+        indices[++iIndex] = c;
+        indices[++iIndex] = a;
+        indices[++iIndex] = d;
+        indices[++iIndex] = a;
+        indices[++iIndex] = b;
+        indices[++iIndex] = d;
+        // indices.push(c, a, d, a, b, d);
+        idx += 4;
+        const u1 = uIdx / circlePointsLen, u2 = (uIdx + 1) / circlePointsLen;
+        uv[++uvIndex] = u1;
+        uv[++uvIndex] = height / radius / 2;
+        uv[++uvIndex] = u2;
+        uv[++uvIndex] = height / radius / 2;
+        uv[++uvIndex] = u1;
+        uv[++uvIndex] = 0;
+        uv[++uvIndex] = u2;
+        uv[++uvIndex] = 0;
+        // uvs.push(u1, height / radius / 2, u2, height / radius / 2, u1, 0, u2, 0);
+        uIdx++;
+    }
+    const position = new Float32Array(points.length + sidePoints.length);
+    position.set(points, 0);
+    position.set(sidePoints, points.length);
+    const normal = generateNormal(indices, position);
+    return { points, indices: new Uint32Array(indices), position, normal, uv: new Float32Array(uv) };
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+import { extrudePolygons } from './polygon';
+import { extrudePolylines, expandLine, leftOnLine, extrudeSlopes } from './polyline';
+import { cylinder } from './cylinder';
+import { expandPaths } from './path';
+import { expandTubes } from './tube';
+import { plane } from './plane';
+export { extrudePolygons, extrudePolylines, extrudeSlopes, expandLine, leftOnLine, cylinder, expandPaths, expandTubes, plane };

package/src/path.ts

@@ -0,0 +1,385 @@
+import { Vector3 } from './math/Vector3';
+import { PathPoint } from './path/PathPoint';
+import { PathPointList } from './path/PathPointList';
+import { PolylineType, ResultType } from './type';
+import { line2Vectors, merge } from './util';
+const UP = new Vector3(0, 0, 1);
+
+const right = new Vector3();
+const left = new Vector3();
+
+// for sharp corners
+const leftOffset = new Vector3();
+const rightOffset = new Vector3();
+const tempPoint1 = new Vector3();
+const tempPoint2 = new Vector3();
+
+type PathsOptions = {
+    lineWidth?: number;
+    cornerRadius?: number;
+    cornerSplit?: number;
+}
+
+type PathsResult = ResultType & {
+    lines: Array<PolylineType>;
+}
+
+export function expandPaths(lines: Array<PolylineType>, options?: PathsOptions): PathsResult {
+    options = Object.assign({}, { lineWidth: 1, cornerRadius: 0, cornerSplit: 10 }, options);
+    const results = lines.map(line => {
+        const points = line2Vectors(line);
+        const pathPointList = new PathPointList();
+        //@ts-ignore
+        pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP);
+        const params = generatePathVertexData(pathPointList, options);
+
+        const result = {
+            position: new Float32Array(params.position),
+            indices: new Uint32Array(params.indices),
+            uv: new Float32Array(params.uv),
+            normal: new Float32Array(params.normal),
+            line,
+            count: params.count
+        }
+        return result;
+    });
+    const result = merge(results) as PathsResult;
+    result.lines = lines;
+    return result;
+}
+
+// Vertex Data Generate Functions
+// code copy from https://github.com/shawn0326/three.path/blob/master/src/PathGeometry.js
+function generatePathVertexData(pathPointList, options: PathsOptions) {
+    const width = options.lineWidth || 0.1;
+    const progress = 1;
+    const side = 'both';
+
+    const halfWidth = width / 2;
+    const sideWidth = (side !== 'both' ? width / 2 : width);
+    const totalDistance = pathPointList.distance();
+    const progressDistance = progress * totalDistance;
+
+    let count = 0;
+
+    // modify data
+    const position: number[] = [];
+    const normal: number[] = [];
+    const uv: number[] = [];
+    const indices: number[] = [];
+    let verticesCount = 0;
+
+    if (totalDistance === 0) {
+        return {
+            position: position,
+            normal,
+            uv: uv,
+            indices: indices,
+            count
+        }
+    }
+
+    const sharpUvOffset = halfWidth / sideWidth;
+    // const sharpUvOffset2 = halfWidth / totalDistance;
+
+
+    let pIndex = position.length - 1;
+    let nIndex = normal.length - 1;
+    let uIndex = uv.length - 1;
+    let iIndex = indices.length - 1;
+    function addVertices(pathPoint) {
+        const first = position.length === 0;
+        const sharpCorner = pathPoint.sharp && !first;
+
+        const uvDist = pathPoint.dist / sideWidth;
+        // const uvDist2 = pathPoint.dist / totalDistance;
+
+        const dir = pathPoint.dir;
+        const up = pathPoint.up;
+        const _right = pathPoint.right;
+
+        //@ts-ignore
+        if (side !== 'left') {
+            right.copy(_right).multiplyScalar(halfWidth * pathPoint.widthScale);
+        } else {
+            right.set(0, 0, 0);
+        }
+        //@ts-ignore
+        if (side !== 'right') {
+            left.copy(_right).multiplyScalar(-halfWidth * pathPoint.widthScale);
+        } else {
+            left.set(0, 0, 0);
+        }
+
+        right.add(pathPoint.pos);
+        left.add(pathPoint.pos);
+
+        if (sharpCorner) {
+            leftOffset.fromArray(position, position.length - 6).sub(left);
+            rightOffset.fromArray(position, position.length - 3).sub(right);
+
+            const leftDist = leftOffset.length();
+            const rightDist = rightOffset.length();
+
+            const sideOffset = leftDist - rightDist;
+            let longerOffset, longEdge;
+
+            if (sideOffset > 0) {
+                longerOffset = leftOffset;
+                longEdge = left;
+            } else {
+                longerOffset = rightOffset;
+                longEdge = right;
+            }
+
+            tempPoint1.copy(longerOffset).setLength(Math.abs(sideOffset)).add(longEdge);
+
+            // eslint-disable-next-line prefer-const
+            let _cos = tempPoint2.copy(longEdge).sub(tempPoint1).normalize().dot(dir);
+            // eslint-disable-next-line prefer-const
+            let _len = tempPoint2.copy(longEdge).sub(tempPoint1).length();
+            // eslint-disable-next-line prefer-const
+            let _dist = _cos * _len * 2;
+
+            tempPoint2.copy(dir).setLength(_dist).add(tempPoint1);
+
+            if (sideOffset > 0) {
+                position[++pIndex] = tempPoint1.x;
+                position[++pIndex] = tempPoint1.y;
+                position[++pIndex] = tempPoint1.z;
+                position[++pIndex] = right.x;
+                position[++pIndex] = right.y;
+                position[++pIndex] = right.z;
+                position[++pIndex] = left.x;
+                position[++pIndex] = left.y;
+                position[++pIndex] = left.z;
+                position[++pIndex] = right.x;
+                position[++pIndex] = right.y;
+                position[++pIndex] = right.z;
+                position[++pIndex] = tempPoint2.x;
+                position[++pIndex] = tempPoint2.y;
+                position[++pIndex] = tempPoint2.z;
+                position[++pIndex] = right.x;
+                position[++pIndex] = right.y;
+                position[++pIndex] = right.z;
+                // position.push(
+                //     tempPoint1.x, tempPoint1.y, tempPoint1.z, // 6
+                //     right.x, right.y, right.z, // 5
+                //     left.x, left.y, left.z, // 4
+                //     right.x, right.y, right.z, // 3
+                //     tempPoint2.x, tempPoint2.y, tempPoint2.z, // 2
+                //     right.x, right.y, right.z // 1
+                // );
+
+                verticesCount += 6;
+
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 8;
+                indices[++iIndex] = verticesCount - 7;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 7;
+                indices[++iIndex] = verticesCount - 5;
+                indices[++iIndex] = verticesCount - 4;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 5;
+                indices[++iIndex] = verticesCount - 2;
+                indices[++iIndex] = verticesCount - 4;
+                indices[++iIndex] = verticesCount - 1;
+
+                // indices.push(
+                //     verticesCount - 6, verticesCount - 8, verticesCount - 7,
+                //     verticesCount - 6, verticesCount - 7, verticesCount - 5,
+
+                //     verticesCount - 4, verticesCount - 6, verticesCount - 5,
+                //     verticesCount - 2, verticesCount - 4, verticesCount - 1
+                // );
+
+                count += 12;
+            } else {
+                position[++pIndex] = left.x;
+                position[++pIndex] = left.y;
+                position[++pIndex] = left.z;
+                position[++pIndex] = tempPoint1.x;
+                position[++pIndex] = tempPoint1.y;
+                position[++pIndex] = tempPoint1.z;
+                position[++pIndex] = left.x;
+                position[++pIndex] = left.y;
+                position[++pIndex] = left.z;
+                position[++pIndex] = right.x;
+                position[++pIndex] = right.y;
+                position[++pIndex] = right.z;
+                position[++pIndex] = left.x;
+                position[++pIndex] = left.y;
+                position[++pIndex] = left.z;
+                position[++pIndex] = tempPoint2.x;
+                position[++pIndex] = tempPoint2.y;
+                position[++pIndex] = tempPoint2.z;
+                // position.push(
+                //     left.x, left.y, left.z, // 6
+                //     tempPoint1.x, tempPoint1.y, tempPoint1.z, // 5
+                //     left.x, left.y, left.z, // 4
+                //     right.x, right.y, right.z, // 3
+                //     left.x, left.y, left.z, // 2
+                //     tempPoint2.x, tempPoint2.y, tempPoint2.z // 1
+                // );
+
+                verticesCount += 6;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 8;
+                indices[++iIndex] = verticesCount - 7;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 7;
+                indices[++iIndex] = verticesCount - 5;
+                indices[++iIndex] = verticesCount - 6;
+                indices[++iIndex] = verticesCount - 5;
+                indices[++iIndex] = verticesCount - 3;
+                indices[++iIndex] = verticesCount - 2;
+                indices[++iIndex] = verticesCount - 3;
+                indices[++iIndex] = verticesCount - 1;
+
+                // indices.push(
+                //     verticesCount - 6, verticesCount - 8, verticesCount - 7,
+                //     verticesCount - 6, verticesCount - 7, verticesCount - 5,
+
+                //     verticesCount - 6, verticesCount - 5, verticesCount - 3,
+                //     verticesCount - 2, verticesCount - 3, verticesCount - 1
+                // );
+
+                count += 12;
+            }
+            for (let i = 0; i < 6; i++) {
+                normal[++nIndex] = up.x;
+                normal[++nIndex] = up.y;
+                normal[++nIndex] = up.z;
+            }
+
+            // normal.push(
+            //     up.x, up.y, up.z,
+            //     up.x, up.y, up.z,
+            //     up.x, up.y, up.z,
+            //     up.x, up.y, up.z,
+            //     up.x, up.y, up.z,
+            //     up.x, up.y, up.z
+            // );
+
+            uv[++uIndex] = uvDist - sharpUvOffset;
+            uv[++uIndex] = 0;
+            uv[++uIndex] = uvDist - sharpUvOffset;
+            uv[++uIndex] = 1;
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = 0;
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = 1;
+            uv[++uIndex] = uvDist + sharpUvOffset;
+            uv[++uIndex] = 0;
+            uv[++uIndex] = uvDist + sharpUvOffset;
+            uv[++uIndex] = 1;
+            // uv.push(
+            //     uvDist - sharpUvOffset, 0,
+            //     uvDist - sharpUvOffset, 1,
+            //     uvDist, 0,
+            //     uvDist, 1,
+            //     uvDist + sharpUvOffset, 0,
+            //     uvDist + sharpUvOffset, 1
+            // );
+
+            // if (generateUv2) {
+            //     uv2.push(
+            //         uvDist2 - sharpUvOffset2, 0,
+            //         uvDist2 - sharpUvOffset2, 1,
+            //         uvDist2, 0,
+            //         uvDist2, 1,
+            //         uvDist2 + sharpUvOffset2, 0,
+            //         uvDist2 + sharpUvOffset2, 1
+            //     );
+            // }
+        } else {
+            position[++pIndex] = left.x;
+            position[++pIndex] = left.y;
+            position[++pIndex] = left.z;
+            position[++pIndex] = right.x;
+            position[++pIndex] = right.y;
+            position[++pIndex] = right.z;
+            // position.push(
+            //     left.x, left.y, left.z,
+            //     right.x, right.y, right.z
+            // );
+
+            normal[++nIndex] = up.x;
+            normal[++nIndex] = up.y;
+            normal[++nIndex] = up.z;
+            normal[++nIndex] = up.x;
+            normal[++nIndex] = up.y;
+            normal[++nIndex] = up.z;
+            // normal.push(
+            //     up.x, up.y, up.z,
+            //     up.x, up.y, up.z
+            // );
+
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = 0;
+            uv[++uIndex] = uvDist;
+            uv[++uIndex] = 1;
+            // uv.push(
+            //     uvDist, 0,
+            //     uvDist, 1
+            // );
+
+            // if (generateUv2) {
+            //     uv2.push(
+            //         uvDist2, 0,
+            //         uvDist2, 1
+            //     );
+            // }
+
+            verticesCount += 2;
+
+            if (!first) {
+                indices[++iIndex] = verticesCount - 2;
+                indices[++iIndex] = verticesCount - 4;
+                indices[++iIndex] = verticesCount - 3;
+                indices[++iIndex] = verticesCount - 2;
+                indices[++iIndex] = verticesCount - 3;
+                indices[++iIndex] = verticesCount - 1;
+                // indices.push(
+                //     verticesCount - 2, verticesCount - 4, verticesCount - 3,
+                //     verticesCount - 2, verticesCount - 3, verticesCount - 1
+                // );
+
+                count += 6;
+            }
+        }
+    }
+
+    let lastPoint;
+
+    if (progressDistance > 0) {
+        for (let i = 0; i < pathPointList.count; i++) {
+            const pathPoint = pathPointList.array[i];
+
+            if (pathPoint.dist > progressDistance) {
+                const prevPoint = pathPointList.array[i - 1];
+                lastPoint = new PathPoint();
+
+                // linear lerp for progress
+                const alpha = (progressDistance - prevPoint.dist) / (pathPoint.dist - prevPoint.dist);
+                lastPoint.lerpPathPoints(prevPoint, pathPoint, alpha);
+
+                addVertices(lastPoint);
+                break;
+            } else {
+                addVertices(pathPoint);
+            }
+        }
+    } else {
+        lastPoint = pathPointList.array[0];
+    }
+
+    return {
+        position: position,
+        normal,
+        uv: uv,
+        indices: indices,
+        count
+    };
+}