poly-extrude 0.8.0 → 0.9.0

package/dist/poly-extrude.mjs

@@ -1,5 +1,5 @@
 /*!
- * poly-extrude v0.8.0
+ * poly-extrude v0.9.0
   */
 var earcut$2 = {exports: {}};
 
@@ -862,17 +862,32 @@ function generateSideWallUV(uvs, vertices, indexA, indexB, indexC, indexD) {
   var d_x = vertices[idx4];
   var d_y = vertices[idx4 + 1];
   var d_z = vertices[idx4 + 2];
+  var uIndex = uvs.length - 1;
 
   if (Math.abs(a_y - b_y) < Math.abs(a_x - b_x)) {
-    uvs.push(a_x, 1 - a_z);
-    uvs.push(b_x, 1 - b_z);
-    uvs.push(c_x, 1 - c_z);
-    uvs.push(d_x, 1 - d_z);
+    uvs[++uIndex] = a_x;
+    uvs[++uIndex] = 1 - a_z;
+    uvs[++uIndex] = b_x;
+    uvs[++uIndex] = 1 - b_z;
+    uvs[++uIndex] = c_x;
+    uvs[++uIndex] = 1 - c_z;
+    uvs[++uIndex] = d_x;
+    uvs[++uIndex] = 1 - d_z; // uvs.push(a_x, 1 - a_z);
+    // uvs.push(b_x, 1 - b_z);
+    // uvs.push(c_x, 1 - c_z);
+    // uvs.push(d_x, 1 - d_z);
   } else {
-    uvs.push(a_y, 1 - a_z);
-    uvs.push(b_y, 1 - b_z);
-    uvs.push(c_y, 1 - c_z);
-    uvs.push(d_y, 1 - d_z);
+    uvs[++uIndex] = a_y;
+    uvs[++uIndex] = 1 - a_z;
+    uvs[++uIndex] = b_y;
+    uvs[++uIndex] = 1 - b_z;
+    uvs[++uIndex] = c_y;
+    uvs[++uIndex] = 1 - c_z;
+    uvs[++uIndex] = d_y;
+    uvs[++uIndex] = 1 - d_z; // uvs.push(a_y, 1 - a_z);
+    // uvs.push(b_y, 1 - b_z);
+    // uvs.push(c_y, 1 - c_z);
+    // uvs.push(d_y, 1 - d_z);
   }
 }
 
@@ -904,8 +919,8 @@ function extrudePolygons(polygons, options) {
     generateTopAndBottom$1(result, triangles);
     generateSides$1(result, options);
     result.position = new Float32Array(result.points);
-    result.indices = new Uint32Array(result.index);
-    result.uv = new Float32Array(result.uvs);
+    result.indices = new Uint32Array(result.indices);
+    result.uv = new Float32Array(result.uv);
     result.normal = generateNormal(result.indices, result.position);
     return result;
   });
@@ -915,7 +930,7 @@ function extrudePolygons(polygons, options) {
 }
 
 function generateTopAndBottom$1(result, triangles) {
-  var index = [];
+  var indices = [];
   var count = result.count;
 
   for (var i = 0, len = triangles.length; i < len; i += 3) {
@@ -923,30 +938,30 @@ function generateTopAndBottom$1(result, triangles) {
     var a = triangles[i],
         b = triangles[i + 1],
         c = triangles[i + 2];
-    index[i] = a;
-    index[i + 1] = b;
-    index[i + 2] = c; // bottom
+    indices[i] = a;
+    indices[i + 1] = b;
+    indices[i + 2] = c; // bottom
 
     var idx = len + i;
     var a1 = count + a,
         b1 = count + b,
         c1 = count + c;
-    index[idx] = a1;
-    index[idx + 1] = b1;
-    index[idx + 2] = c1;
+    indices[idx] = a1;
+    indices[idx + 1] = b1;
+    indices[idx + 2] = c1;
   }
 
-  result.index = index;
+  result.indices = indices;
 }
 
 function generateSides$1(result, options) {
   var points = result.points,
-      index = result.index,
+      indices = result.indices,
       polygon = result.polygon,
-      uvs = result.uvs;
+      uv = result.uv;
   var depth = options.depth;
   var pIndex = points.length - 1;
-  var iIndex = index.length - 1;
+  var iIndex = indices.length - 1;
 
   for (var i = 0, len = polygon.length; i < len; i++) {
     var ring = polygon[i];
@@ -987,14 +1002,14 @@ function generateSides$1(result, options) {
           d = idx + 1; // points.push(p3, p4, p1, p2);
       // index.push(a, c, b, c, d, b);
 
-      index[++iIndex] = a;
-      index[++iIndex] = c;
-      index[++iIndex] = b;
-      index[++iIndex] = c;
-      index[++iIndex] = d;
-      index[++iIndex] = b; // index.push(c, d, b);
+      indices[++iIndex] = a;
+      indices[++iIndex] = c;
+      indices[++iIndex] = b;
+      indices[++iIndex] = c;
+      indices[++iIndex] = d;
+      indices[++iIndex] = b; // index.push(c, d, b);
 
-      generateSideWallUV(uvs, points, a, b, c, d);
+      generateSideWallUV(uv, points, a, b, c, d);
       j++;
     }
   }
@@ -1019,7 +1034,7 @@ function flatVertices(polygon, options) {
   var holes = [],
       flatVertices = new Float32Array(count * 2),
       points = [],
-      uvs = [];
+      uv = [];
   var pOffset = count * 3,
       uOffset = count * 2;
   var depth = options.depth;
@@ -1052,10 +1067,10 @@ function flatVertices(polygon, options) {
       points[pOffset + idx1] = x;
       points[pOffset + idx1 + 1] = y;
       points[pOffset + idx1 + 2] = z;
-      uvs[idx2] = x;
-      uvs[idx2 + 1] = y;
-      uvs[uOffset + idx2] = x;
-      uvs[uOffset + idx2 + 1] = y;
+      uv[idx2] = x;
+      uv[idx2 + 1] = y;
+      uv[uOffset + idx2] = x;
+      uv[uOffset + idx2 + 1] = y;
       idx1 += 3;
       idx2 += 2;
       j++;
@@ -1067,7 +1082,7 @@ function flatVertices(polygon, options) {
     holes: holes,
     points: points,
     count: count,
-    uvs: uvs
+    uv: uv
   };
 }
 
@@ -1107,8 +1122,8 @@ function extrudePolylines(lines, options) {
     generateTopAndBottom(result, options);
     generateSides(result, options);
     result.position = new Float32Array(result.points);
-    result.indices = new Uint32Array(result.index);
-    result.uv = new Float32Array(result.uvs);
+    result.indices = new Uint32Array(result.indices);
+    result.uv = new Float32Array(result.uv);
     result.normal = generateNormal(result.indices, result.position);
     return result;
   });
@@ -1157,8 +1172,8 @@ function extrudeSlopes(lines, options) {
     generateTopAndBottom(result, options);
     generateSides(result, options);
     result.position = new Float32Array(result.points);
-    result.indices = new Uint32Array(result.index);
-    result.uv = new Float32Array(result.uvs);
+    result.indices = new Uint32Array(result.indices);
+    result.uv = new Float32Array(result.uv);
     result.normal = generateNormal(result.indices, result.position);
     return result;
   });
@@ -1180,8 +1195,8 @@ function generateTopAndBottom(result, options) {
   }
 
   var points = [],
-      index = [],
-      uvs = [];
+      indices = [],
+      uv = [];
   var leftPoints = result.leftPoints,
       rightPoints = result.rightPoints;
   var i = 0,
@@ -1231,16 +1246,20 @@ function generateTopAndBottom(result, options) {
 
   i = 0;
   len = points.length;
+  var uIndex = uv.length - 1;
 
   while (i < len) {
     var x = points[i],
         y = points[i + 1];
-    uvs.push(x, y);
+    uv[++uIndex] = x;
+    uv[++uIndex] = y; // uvs.push(x, y);
+
     i += 3;
   }
 
   i = 0;
   len = leftPoints.length;
+  var iIndex = indices.length - 1;
 
   while (i < len - 1) {
     // top
@@ -1249,8 +1268,14 @@ function generateTopAndBottom(result, options) {
         b1 = i + 1,
         c1 = a1 + len,
         d1 = b1 + len;
-    index.push(a1, c1, b1);
-    index.push(c1, d1, b1); // bottom
+    indices[++iIndex] = a1;
+    indices[++iIndex] = c1;
+    indices[++iIndex] = b1;
+    indices[++iIndex] = c1;
+    indices[++iIndex] = d1;
+    indices[++iIndex] = b1; // index.push(a1, c1, b1);
+    // index.push(c1, d1, b1);
+    // bottom
     // left1 left2 right1,right2
 
     var len2 = len * 2;
@@ -1258,14 +1283,20 @@ function generateTopAndBottom(result, options) {
         b2 = a2 + 1,
         c2 = a2 + len,
         d2 = b2 + len;
-    index.push(a2, c2, b2);
-    index.push(c2, d2, b2);
+    indices[++iIndex] = a2;
+    indices[++iIndex] = c2;
+    indices[++iIndex] = b2;
+    indices[++iIndex] = c2;
+    indices[++iIndex] = d2;
+    indices[++iIndex] = b2; // index.push(a2, c2, b2);
+    // index.push(c2, d2, b2);
+
     i++;
   }
 
-  result.index = index;
+  result.indices = indices;
   result.points = points;
-  result.uvs = uvs;
+  result.uv = uv;
 
   if (depths) {
     len = leftPoints.length;
@@ -1281,18 +1312,20 @@ function generateTopAndBottom(result, options) {
 
 function generateSides(result, options) {
   var points = result.points,
-      index = result.index,
+      indices = result.indices,
       leftPoints = result.leftPoints,
       rightPoints = result.rightPoints,
-      uvs = result.uvs;
+      uv = result.uv;
   var z = options.depth;
   var bottomStickGround = options.bottomStickGround;
   var rings = [leftPoints, rightPoints];
   var depthsEnable = result.depths;
+  var pIndex = points.length - 1;
+  var iIndex = indices.length - 1;
 
   function addOneSideIndex(v1, v2) {
-    var idx = points.length / 3;
-    var pIndex = points.length - 1; // top
+    var idx = points.length / 3; // let pIndex = points.length - 1;
+    // top
 
     points[++pIndex] = v1[0];
     points[++pIndex] = v1[1];
@@ -1313,8 +1346,14 @@ function generateSides(result, options) {
         b = idx + 3,
         c = idx,
         d = idx + 1;
-    index.push(a, c, b, c, d, b);
-    generateSideWallUV(uvs, points, a, b, c, d);
+    indices[++iIndex] = a;
+    indices[++iIndex] = c;
+    indices[++iIndex] = b;
+    indices[++iIndex] = c;
+    indices[++iIndex] = d;
+    indices[++iIndex] = b; // index.push(a, c, b, c, d, b);
+
+    generateSideWallUV(uv, points, a, b, c, d);
   }
 
   for (var i = 0, _len = rings.length; i < _len; i++) {
@@ -1562,7 +1601,8 @@ function cylinder(point, options) {
   var offset = circlePointsLen * 3,
       uOffset = circlePointsLen * 2;
   var indices = [],
-      uvs = [];
+      uv = [];
+  var iIndex = indices.length - 1;
 
   for (var i = -1; i < radialSegments; i++) {
     var rad = aRad * i;
@@ -1580,16 +1620,19 @@ function cylinder(point, options) {
         v = 0;
     u = 0.5 + x / radius / 2;
     v = 0.5 + y / radius / 2;
-    uvs[uIdx] = u;
-    uvs[uIdx + 1] = v;
-    uvs[uIdx + uOffset] = u;
-    uvs[uIdx + 1 + uOffset] = v;
+    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.push(0, i - 1, i);
+      indices[++iIndex] = 0;
+      indices[++iIndex] = i - 1;
+      indices[++iIndex] = i;
     }
   }
 
@@ -1603,15 +1646,19 @@ function cylinder(point, options) {
   points[pointsLen - 1] = height;
   var indicesLen = indices.length; // top indices
 
+  iIndex = indices.length - 1;
+
   for (var _i = 0; _i < indicesLen; _i++) {
     var index = indices[_i];
-    indices.push(index + circlePointsLen);
+    indices[++iIndex] = index + circlePointsLen; // indices.push(index + circlePointsLen);
   }
 
   var sidePoints = new Float32Array((circlePointsLen * 3 * 2 - 6) * 2);
   var pIndex = -1;
   idx = circlePointsLen * 2;
   uIdx = 0;
+  iIndex = indices.length - 1;
+  var uvIndex = uv.length - 1;
 
   for (var _i2 = 0, len = points.length / 2; _i2 < len - 3; _i2 += 3) {
     var x1 = points[_i2],
@@ -1635,11 +1682,25 @@ function cylinder(point, options) {
         c = idx,
         d = idx + 1; // indices.push(a, c, b, c, d, b);
 
-    indices.push(c, a, d, a, b, d);
+    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;
     var u1 = uIdx / circlePointsLen,
         u2 = (uIdx + 1) / circlePointsLen;
-    uvs.push(u1, height / radius / 2, u2, height / radius / 2, u1, 0, u2, 0);
+    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++;
   }
 
@@ -1652,7 +1713,7 @@ function cylinder(point, options) {
     indices: new Uint32Array(indices),
     position: position,
     normal: normal,
-    uv: new Float32Array(uvs)
+    uv: new Float32Array(uv)
   };
 }
 
@@ -4415,9 +4476,9 @@ function expandPaths(lines, options) {
     pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP$1);
     var result = generatePathVertexData(pathPointList, options);
     result.line = line;
-    result.position = new Float32Array(result.points);
-    result.indices = new Uint32Array(result.index);
-    result.uv = new Float32Array(result.uvs);
+    result.position = new Float32Array(result.position);
+    result.indices = new Uint32Array(result.indices);
+    result.uv = new Float32Array(result.uv);
     result.normal = new Float32Array(result.normal);
     return result;
   });
@@ -4455,6 +4516,10 @@ function generatePathVertexData(pathPointList, options) {
   var rightOffset = new Vector3();
   var tempPoint1 = new Vector3();
   var tempPoint2 = new Vector3();
+  var pIndex = position.length - 1;
+  var nIndex = normal.length - 1;
+  var uIndex = uv.length - 1;
+  var iIndex = indices.length - 1;
 
   function addVertices(pathPoint) {
     var first = position.length === 0;
@@ -4505,31 +4570,135 @@ function generatePathVertexData(pathPointList, options) {
       tempPoint2.copy(dir).setLength(_dist).add(tempPoint1);
 
       if (sideOffset > 0) {
-        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
-        );
+        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.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);
+        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.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
-        );
+        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.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);
+        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;
       }
 
-      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.push(uvDist - sharpUvOffset, 0, uvDist - sharpUvOffset, 1, uvDist, 0, uvDist, 1, uvDist + sharpUvOffset, 0, uvDist + sharpUvOffset, 1); // if (generateUv2) {
+      for (var 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,
@@ -4540,9 +4709,34 @@ function generatePathVertexData(pathPointList, options) {
       //     );
       // }
     } else {
-      position.push(left.x, left.y, left.z, right.x, right.y, right.z);
-      normal.push(up.x, up.y, up.z, up.x, up.y, up.z);
-      uv.push(uvDist, 0, uvDist, 1); // if (generateUv2) {
+      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
@@ -4552,7 +4746,16 @@ function generatePathVertexData(pathPointList, options) {
       verticesCount += 2;
 
       if (!first) {
-        indices.push(verticesCount - 2, verticesCount - 4, verticesCount - 3, verticesCount - 2, verticesCount - 3, verticesCount - 1);
+        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;
       }
     }
@@ -4581,10 +4784,10 @@ function generatePathVertexData(pathPointList, options) {
   }
 
   return {
-    points: position,
+    position: position,
     normal: normal,
-    uvs: uv,
-    index: indices,
+    uv: uv,
+    indices: indices,
     count: count
   };
 }
@@ -4609,8 +4812,8 @@ function expandTubes(lines, options) {
     var result = generateTubeVertexData(pathPointList, options);
     result.line = line;
     result.position = new Float32Array(result.points);
-    result.indices = new Uint32Array(result.index);
-    result.uv = new Float32Array(result.uvs);
+    result.indices = new Uint32Array(result.indices);
+    result.uv = new Float32Array(result.uv);
     result.normal = new Float32Array(result.normal);
     return result;
   });
@@ -4637,9 +4840,9 @@ function generateTubeVertexData(pathPointList, options) {
 
   var points = [];
   var normal = [];
-  var uvs = []; // const uv2 = [];
+  var uv = []; // const uv2 = [];
 
-  var index = [];
+  var indices = [];
   var verticesCount = 0;
   var normalDir = new Vector3();
   var pIndex = -1;
@@ -4666,8 +4869,8 @@ function generateTubeVertexData(pathPointList, options) {
       normal[++nIndex] = normalDir.x;
       normal[++nIndex] = normalDir.y;
       normal[++nIndex] = normalDir.z;
-      uvs[++uIndex] = uvDist;
-      uvs[++uIndex] = i / radialSegments; // uvs.push(uvDist, r / radialSegments);
+      uv[++uIndex] = uvDist;
+      uv[++uIndex] = i / radialSegments; // uvs.push(uvDist, r / radialSegments);
       // if (generateUv2) {
       //     uv2.push(uvDist2, r / radialSegments);
       // }
@@ -4680,12 +4883,12 @@ function generateTubeVertexData(pathPointList, options) {
       var begin2 = verticesCount - (radialSegments + 1);
 
       for (var _i = 0; _i < radialSegments; _i++) {
-        index[++iIndex] = begin2 + _i;
-        index[++iIndex] = begin1 + _i;
-        index[++iIndex] = begin1 + _i + 1;
-        index[++iIndex] = begin2 + _i;
-        index[++iIndex] = begin1 + _i + 1;
-        index[++iIndex] = begin2 + _i + 1; // index.push(
+        indices[++iIndex] = begin2 + _i;
+        indices[++iIndex] = begin1 + _i;
+        indices[++iIndex] = begin1 + _i + 1;
+        indices[++iIndex] = begin2 + _i;
+        indices[++iIndex] = begin1 + _i + 1;
+        indices[++iIndex] = begin2 + _i + 1; // index.push(
         //     begin2 + i,
         //     begin1 + i,
         //     begin1 + i + 1,
@@ -4720,9 +4923,9 @@ function generateTubeVertexData(pathPointList, options) {
   return {
     points: points,
     normal: normal,
-    uvs: uvs,
+    uv: uv,
     // uv2,
-    index: index,
+    indices: indices,
     count: count
   };
 }