poly-extrude 0.0.2 → 0.0.5

package/dist/poly-extrude.mjs

@@ -1,5 +1,5 @@
 /*!
- * poly-extrude v0.0.2
+ * poly-extrude v0.0.5
   */
 var earcut$2 = {exports: {}};
 
@@ -725,8 +725,9 @@ function generateNormal(indices, position) {
   var n = [];
   var len = indices.length;
   var normals = new Float32Array(position.length);
+  var f = 0;
 
-  for (var f = 0; f < len; f += 3) {
+  while (f < len) {
     // const i1 = indices[f++] * 3;
     // const i2 = indices[f++] * 3;
     // const i3 = indices[f++] * 3;
@@ -741,30 +742,30 @@ function generateNormal(indices, position) {
         i3 = c * 3;
     v3Set(p1, position[i1], position[i1 + 1], position[i1 + 2]);
     v3Set(p2, position[i2], position[i2 + 1], position[i2 + 2]);
-    v3Set(p3, position[i3], position[i3 + 1], position[i3 + 2]); // pA.fromBufferAttribute(positionAttribute, vA);
-    // pB.fromBufferAttribute(positionAttribute, vB);
-    // pC.fromBufferAttribute(positionAttribute, vC);
-    // cb.subVectors(pC, pB);
-    // ab.subVectors(pA, pB);
-    // cb.cross(ab);
-
+    v3Set(p3, position[i3], position[i3 + 1], position[i3 + 2]);
     v3Sub(v32, p3, p2);
     v3Sub(v21, p1, p2);
     v3Cross(n, v32, v21); // Already be weighted by the triangle area
 
-    for (var i = 0; i < 3; i++) {
-      normals[i1 + i] += n[i];
-      normals[i2 + i] += n[i];
-      normals[i3 + i] += n[i];
+    for (var _i = 0; _i < 3; _i++) {
+      normals[i1 + _i] += n[_i];
+      normals[i2 + _i] += n[_i];
+      normals[i3 + _i] += n[_i];
     }
+
+    f += 3;
   }
 
-  for (var _i = 0; _i < normals.length; _i += 3) {
-    v3Set(n, normals[_i], normals[_i + 1], normals[_i + 2]);
+  var i = 0;
+  var l = normals.length;
+
+  while (i < l) {
+    v3Set(n, normals[i], normals[i + 1], normals[i + 2]);
     v3Normalize(n, n);
-    normals[_i] = n[0] || 0;
-    normals[_i + 1] = n[1] || 0;
-    normals[_i + 2] = n[2] || 0;
+    normals[i] = n[0] || 0;
+    normals[i + 1] = n[1] || 0;
+    normals[i + 2] = n[2] || 0;
+    i += 3;
   }
 
   return normals;
@@ -813,11 +814,14 @@ function merge(results) {
     result.position.set(_position, pOffset);
     result.normal.set(normal, pOffset);
     result.uv.set(uv, uvOffset);
+    var j = 0;
+    var len1 = _indices.length;
 
-    for (var j = 0, len1 = _indices.length; j < len1; j++) {
+    while (j < len1) {
       var pIndex = _indices[j] + pCount;
       result.indices[iIdx] = pIndex;
       iIdx++;
+      j++;
     }
 
     uvOffset += uv.length;
@@ -835,39 +839,33 @@ function degToRad(angle) {
 } // https://github.com/mrdoob/three.js/blob/16f13e3b07e31d0e9a00df7c3366bbe0e464588c/src/geometries/ExtrudeGeometry.js?_pjax=%23js-repo-pjax-container#L736
 
 function generateSideWallUV(uvs, vertices, indexA, indexB, indexC, indexD) {
-  var a_x = vertices[indexA * 3];
-  var a_y = vertices[indexA * 3 + 1];
-  var a_z = vertices[indexA * 3 + 2];
-  var b_x = vertices[indexB * 3];
-  var b_y = vertices[indexB * 3 + 1];
-  var b_z = vertices[indexB * 3 + 2];
-  var c_x = vertices[indexC * 3];
-  var c_y = vertices[indexC * 3 + 1];
-  var c_z = vertices[indexC * 3 + 2];
-  var d_x = vertices[indexD * 3];
-  var d_y = vertices[indexD * 3 + 1];
-  var d_z = vertices[indexD * 3 + 2];
+  var idx1 = indexA * 3,
+      idx2 = indexB * 3,
+      idx3 = indexC * 3,
+      idx4 = indexD * 3;
+  var a_x = vertices[idx1];
+  var a_y = vertices[idx1 + 1];
+  var a_z = vertices[idx1 + 2];
+  var b_x = vertices[idx2];
+  var b_y = vertices[idx2 + 1];
+  var b_z = vertices[idx2 + 2];
+  var c_x = vertices[idx3];
+  var c_y = vertices[idx3 + 1];
+  var c_z = vertices[idx3 + 2];
+  var d_x = vertices[idx4];
+  var d_y = vertices[idx4 + 1];
+  var d_z = vertices[idx4 + 2];
 
   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); // return [
-    //     new Vector2(a_x, 1 - a_z),
-    //     new Vector2(b_x, 1 - b_z),
-    //     new Vector2(c_x, 1 - c_z),
-    //     new Vector2(d_x, 1 - d_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); // return [
-    //     new Vector2(a_y, 1 - a_z),
-    //     new Vector2(b_y, 1 - b_z),
-    //     new Vector2(c_y, 1 - c_z),
-    //     new Vector2(d_y, 1 - d_z)
-    // ];
+    uvs.push(d_y, 1 - d_z);
   }
 }
 
@@ -876,34 +874,26 @@ function extrudePolygons(polygons, options) {
     depth: 2
   }, options);
   var results = polygons.map(function (polygon) {
-    if (!isClockwise(polygon[0])) {
-      polygon[0] = polygon[0].reverse();
-    }
+    for (var i = 0, len = polygon.length; i < len; i++) {
+      var ring = polygon[i];
+      valiateRing(ring);
 
-    polygon.slice(1, Infinity).forEach(function (coordinates, index) {
-      if (isClockwise(coordinates)) {
-        polygon[index + 1] = coordinates.reverse();
+      if (i === 0) {
+        if (!isClockwise(ring)) {
+          polygon[i] = ring.reverse();
+        }
+      } else if (isClockwise(ring)) {
+        polygon[i] = ring.reverse();
       }
-    });
-    polygon.forEach(function (ring) {
-      var len = ring.length;
-      var _ring$ = ring[0],
-          x1 = _ring$[0],
-          y1 = _ring$[1],
-          _ring = ring[len - 1],
-          x2 = _ring[0],
-          y2 = _ring[1];
-
-      if (x1 === x2 && y1 === y2) {
-        ring.splice(len - 1, 1);
+
+      if (isClosedRing(ring)) {
+        ring.splice(ring.length - 1, 1);
       }
-    });
+    }
+
     var result = flatVertices(polygon, options);
     result.polygon = polygon;
-    var time = 'earcut';
-    console.time(time);
     var triangles = earcut$1(result.flatVertices, result.holes, 2);
-    console.timeEnd(time);
     generateTopAndBottom$1(result, triangles);
     generateSides$1(result, options);
     result.position = new Float32Array(result.points);
@@ -951,29 +941,32 @@ function generateSides$1(result, options) {
 
   for (var i = 0, len = polygon.length; i < len; i++) {
     var ring = polygon[i];
+    var j = 0;
+    var len1 = ring.length;
 
-    for (var j = 0, len1 = ring.length; j < len1; j++) {
+    while (j < len1) {
       var v1 = ring[j];
       var v2 = ring[j + 1];
 
       if (j === len1 - 1) {
         v2 = ring[0];
-      } // const p1 = [v1[0], v1[1], options.depth],
-      //     p2 = [v2[0], v2[1], options.depth],
-      //     p3 = [v1[0], v1[1], 0],
-      //     p4 = [v2[0], v2[1], 0];
-
+      }
 
       var idx = points.length / 3;
-      points.push(v1[0], v1[1], 0, v2[0], v2[1], 0, v1[0], v1[1], z, v2[0], v2[1], z);
+      var x1 = v1[0],
+          y1 = v1[1],
+          x2 = v2[0],
+          y2 = v2[1];
+      points.push(x1, y1, 0, x2, y2, 0, x1, y1, z, x2, y2, z);
       var a = idx,
           b = idx + 1,
           c = idx + 2,
           d = idx + 3; // points.push(p3, p4, p1, p2);
 
-      index.push(a, c, b);
-      index.push(c, d, b);
+      index.push(a, c, b, c, d, b); // index.push(c, d, b);
+
       generateSideWallUV(uvs, points, a, b, c, d);
+      j++;
     }
   }
 }
@@ -1012,7 +1005,10 @@ function flatVertices(polygon, options) {
       holes.push(idx0 / 2);
     }
 
-    for (var j = 0, len1 = ring.length; j < len1; j++) {
+    var j = 0;
+    var len1 = ring.length;
+
+    while (j < len1) {
       var c = ring[j];
       var x = c[0],
           y = c[1];
@@ -1032,6 +1028,7 @@ function flatVertices(polygon, options) {
       uvs[uOffset + idx2 + 1] = y;
       idx1 += 3;
       idx2 += 2;
+      j++;
     }
   }
 
@@ -1044,6 +1041,23 @@ function flatVertices(polygon, options) {
   };
 }
 
+function valiateRing(ring) {
+  if (!isClosedRing(ring)) {
+    ring.push(ring[0]);
+  }
+}
+
+function isClosedRing(ring) {
+  var len = ring.length;
+  var _ring$ = ring[0],
+      x1 = _ring$[0],
+      y1 = _ring$[1],
+      _ring = ring[len - 1],
+      x2 = _ring[0],
+      y2 = _ring[1];
+  return x1 === x2 && y1 === y2;
+}
+
 function extrudePolylines(lines, options) {
   options = Object.assign({}, {
     depth: 2,
@@ -1072,8 +1086,10 @@ function generateTopAndBottom(result, options) {
       uvs = [];
   var leftPoints = result.leftPoints,
       rightPoints = result.rightPoints;
+  var i = 0,
+      len = leftPoints.length;
 
-  for (var i = 0, len = leftPoints.length; i < len; i++) {
+  while (i < len) {
     // top left
     var idx0 = i * 3;
     var _leftPoints$i = leftPoints[i],
@@ -1100,32 +1116,41 @@ function generateTopAndBottom(result, options) {
     points[idx3] = x2;
     points[idx3 + 1] = y2;
     points[idx3 + 2] = 0;
+    i++;
   }
 
-  for (var _i = 0, _len = points.length; _i < _len; _i += 3) {
-    var x = points[_i],
-        y = points[_i + 1];
+  i = 0;
+  len = points.length;
+
+  while (i < len) {
+    var x = points[i],
+        y = points[i + 1];
     uvs.push(x, y);
+    i += 3;
   }
 
-  for (var _i2 = 0, _len2 = leftPoints.length; _i2 < _len2 - 1; _i2++) {
+  i = 0;
+  len = leftPoints.length;
+
+  while (i < len - 1) {
     // top
     // left1 left2 right1,right2
-    var a1 = _i2,
-        b1 = _i2 + 1,
-        c1 = a1 + _len2,
-        d1 = b1 + _len2;
+    var a1 = i,
+        b1 = i + 1,
+        c1 = a1 + len,
+        d1 = b1 + len;
     index.push(a1, c1, b1);
     index.push(c1, d1, b1); // bottom
     // left1 left2 right1,right2
 
-    var len2 = _len2 * 2;
-    var a2 = _i2 + len2,
+    var len2 = len * 2;
+    var a2 = i + len2,
         b2 = a2 + 1,
-        c2 = a2 + _len2,
-        d2 = b2 + _len2;
+        c2 = a2 + len,
+        d2 = b2 + len;
     index.push(a2, c2, b2);
     index.push(c2, d2, b2);
+    i++;
   }
 
   result.index = index;
@@ -1148,14 +1173,12 @@ function generateSides(result, options) {
     var a = idx,
         b = idx + 1,
         c = idx + 2,
-        d = idx + 3; // points.push(p3, p4, p1, p2);
-
-    index.push(a, c, b);
-    index.push(c, d, b);
+        d = idx + 3;
+    index.push(a, c, b, c, d, b);
     generateSideWallUV(uvs, points, a, b, c, d);
   }
 
-  for (var i = 0, _len3 = rings.length; i < _len3; i++) {
+  for (var i = 0, _len = rings.length; i < _len; i++) {
     var ring = rings[i];
 
     if (i > 0) {
@@ -1165,19 +1188,23 @@ function generateSides(result, options) {
       ring = ring.reverse();
     }
 
-    for (var j = 0, len1 = ring.length - 1; j < len1; j++) {
+    var j = 0;
+    var len1 = ring.length - 1;
+
+    while (j < len1) {
       var v1 = ring[j];
       var v2 = ring[j + 1];
       addOneSideIndex(v1, v2);
+      j++;
     }
   }
 
   var len = leftPoints.length;
   var vs = [rightPoints[0], leftPoints[0], leftPoints[len - 1], rightPoints[len - 1]];
 
-  for (var _i3 = 0; _i3 < vs.length; _i3 += 2) {
-    var _v = vs[_i3],
-        _v2 = vs[_i3 + 1];
+  for (var _i = 0; _i < vs.length; _i += 2) {
+    var _v = vs[_i],
+        _v2 = vs[_i + 1];
     addOneSideIndex(_v, _v2);
   }
 }
@@ -1198,8 +1225,9 @@ function expandLine(line, options) {
       leftPoints = [],
       rightPoints = [];
   var len = line.length;
+  var i = 0;
 
-  for (var i = 0; i < len - 1; i++) {
+  while (i < len - 1) {
     var _p = line[i],
         _p2 = line[i + 1];
     var dy = _p2[1] - _p[1],
@@ -1237,6 +1265,8 @@ function expandLine(line, options) {
       leftPoints.push(_op2);
       rightPoints.push(_op);
     }
+
+    i++;
   }
 
   var rAngle = preAngle;
@@ -1301,5 +1331,3 @@ function leftOnLine(p, p1, p2) {
 }
 
 export { extrudePolygons, extrudePolylines };
-
-typeof console !== 'undefined' && console.log('poly-extrude v0.0.2');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poly-extrude",
-  "version": "0.0.2",
+  "version": "0.0.5",
   "description": "",
   "main": "dist/poly-extrude.js",
   "module": "dist/poly-extrude.mjs",

package/src/polygon.js

@@ -5,27 +5,23 @@ import { generateNormal, generateSideWallUV, isClockwise, merge } from './util';
 export function extrudePolygons(polygons, options) {
     options = Object.assign({}, { depth: 2 }, options);
     const results = polygons.map(polygon => {
-        if (!isClockwise(polygon[0])) {
-            polygon[0] = polygon[0].reverse();
-        }
-        polygon.slice(1, Infinity).forEach((coordinates, index) => {
-            if (isClockwise(coordinates)) {
-                polygon[index + 1] = coordinates.reverse();
+        for (let i = 0, len = polygon.length; i < len; i++) {
+            const ring = polygon[i];
+            valiateRing(ring);
+            if (i === 0) {
+                if (!isClockwise(ring)) {
+                    polygon[i] = ring.reverse();
+                }
+            } else if (isClockwise(ring)) {
+                polygon[i] = ring.reverse();
             }
-        });
-        polygon.forEach(ring => {
-            const len = ring.length;
-            const [x1, y1] = ring[0], [x2, y2] = ring[len - 1];
-            if (x1 === x2 && y1 === y2) {
-                ring.splice(len - 1, 1);
+            if (isClosedRing(ring)) {
+                ring.splice(ring.length - 1, 1);
             }
-        });
+        }
         const result = flatVertices(polygon, options);
         result.polygon = polygon;
-        const time = 'earcut';
-        console.time(time);
         const triangles = earcut(result.flatVertices, result.holes, 2);
-        console.timeEnd(time);
         generateTopAndBottom(result, triangles);
         generateSides(result, options);
         result.position = new Float32Array(result.points);
@@ -64,24 +60,24 @@ function generateSides(result, options) {
     const z = options.depth;
     for (let i = 0, len = polygon.length; i < len; i++) {
         const ring = polygon[i];
-        for (let j = 0, len1 = ring.length; j < len1; j++) {
+        let j = 0;
+        const len1 = ring.length;
+        while (j < len1) {
             const v1 = ring[j];
             let v2 = ring[j + 1];
             if (j === len1 - 1) {
                 v2 = ring[0];
             }
-            // const p1 = [v1[0], v1[1], options.depth],
-            //     p2 = [v2[0], v2[1], options.depth],
-            //     p3 = [v1[0], v1[1], 0],
-            //     p4 = [v2[0], v2[1], 0];
             const idx = points.length / 3;
-            points.push(v1[0], v1[1], 0, v2[0], v2[1], 0, v1[0], v1[1], z, v2[0], v2[1], z);
+            const x1 = v1[0], y1 = v1[1], x2 = v2[0], y2 = v2[1];
+            points.push(x1, y1, 0, x2, y2, 0, x1, y1, z, x2, y2, z);
             const a = idx, b = idx + 1, c = idx + 2, d = idx + 3;
             // points.push(p3, p4, p1, p2);
-            index.push(a, c, b);
-            index.push(c, d, b);
+            index.push(a, c, b, c, d, b);
+            // index.push(c, d, b);
 
             generateSideWallUV(uvs, points, a, b, c, d);
+            j++;
         }
     }
 }
@@ -110,7 +106,9 @@ function flatVertices(polygon, options) {
         if (i > 0) {
             holes.push(idx0 / 2);
         }
-        for (let j = 0, len1 = ring.length; j < len1; j++) {
+        let j = 0;
+        const len1 = ring.length;
+        while (j < len1) {
             const c = ring[j];
             const x = c[0], y = c[1];
 
@@ -135,6 +133,7 @@ function flatVertices(polygon, options) {
 
             idx1 += 3;
             idx2 += 2;
+            j++;
         }
     }
     return {
@@ -146,3 +145,15 @@ function flatVertices(polygon, options) {
     };
 
 }
+
+function valiateRing(ring) {
+    if (!isClosedRing(ring)) {
+        ring.push(ring[0]);
+    }
+}
+
+function isClosedRing(ring) {
+    const len = ring.length;
+    const [x1, y1] = ring[0], [x2, y2] = ring[len - 1];
+    return (x1 === x2 && y1 === y2);
+}

package/src/polyline.js

@@ -22,7 +22,8 @@ function generateTopAndBottom(result, options) {
     const z = options.depth;
     const points = [], index = [], uvs = [];
     const { leftPoints, rightPoints } = result;
-    for (let i = 0, len = leftPoints.length; i < len; i++) {
+    let i = 0, len = leftPoints.length;
+    while (i < len) {
         // top left
         const idx0 = i * 3;
         const [x1, y1] = leftPoints[i];
@@ -48,12 +49,19 @@ function generateTopAndBottom(result, options) {
         points[idx3] = x2;
         points[idx3 + 1] = y2;
         points[idx3 + 2] = 0;
+
+        i++;
     }
-    for (let i = 0, len = points.length; i < len; i += 3) {
+    i = 0;
+    len = points.length;
+    while (i < len) {
         const x = points[i], y = points[i + 1];
         uvs.push(x, y);
+        i += 3;
     }
-    for (let i = 0, len = leftPoints.length; i < len - 1; i++) {
+    i = 0;
+    len = leftPoints.length;
+    while (i < len - 1) {
         // top
         // left1 left2 right1,right2
         const a1 = i, b1 = i + 1, c1 = a1 + len, d1 = b1 + len;
@@ -66,6 +74,7 @@ function generateTopAndBottom(result, options) {
         const a2 = i + len2, b2 = a2 + 1, c2 = a2 + len, d2 = b2 + len;
         index.push(a2, c2, b2);
         index.push(c2, d2, b2);
+        i++;
     }
     result.index = index;
     result.points = points;
@@ -76,13 +85,12 @@ function generateSides(result, options) {
     const { points, index, leftPoints, rightPoints, uvs } = result;
     const z = options.depth;
     const rings = [leftPoints, rightPoints];
+
     function addOneSideIndex(v1, v2) {
         const idx = points.length / 3;
         points.push(v1[0], v1[1], 0, v2[0], v2[1], 0, v1[0], v1[1], z, v2[0], v2[1], z);
         const a = idx, b = idx + 1, c = idx + 2, d = idx + 3;
-        // points.push(p3, p4, p1, p2);
-        index.push(a, c, b);
-        index.push(c, d, b);
+        index.push(a, c, b, c, d, b);
         generateSideWallUV(uvs, points, a, b, c, d);
     }
 
@@ -94,10 +102,13 @@ function generateSides(result, options) {
             });
             ring = ring.reverse();
         }
-        for (let j = 0, len1 = ring.length - 1; j < len1; j++) {
+        let j = 0;
+        const len1 = ring.length - 1;
+        while (j < len1) {
             const v1 = ring[j];
             const v2 = ring[j + 1];
             addOneSideIndex(v1, v2);
+            j++;
         }
     }
     const len = leftPoints.length;
@@ -115,7 +126,8 @@ function expandLine(line, options) {
     const radius = options.lineWidth / 2;
     const points = [], leftPoints = [], rightPoints = [];
     const len = line.length;
-    for (let i = 0; i < len - 1; i++) {
+    let i = 0;
+    while (i < len - 1) {
         const p1 = line[i],
             p2 = line[i + 1];
         const dy = p2[1] - p1[1],
@@ -146,6 +158,7 @@ function expandLine(line, options) {
             leftPoints.push(op2);
             rightPoints.push(op1);
         }
+        i++;
     }
     let rAngle = preAngle;
     rAngle -= 90;