poly-extrude 0.0.1 → 0.0.4

package/dist/poly-extrude.js

@@ -1,5 +1,5 @@
 /*!
- * poly-extrude v0.0.1
+ * poly-extrude v0.0.4
   */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
@@ -731,8 +731,9 @@
       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;
@@ -747,30 +748,30 @@
             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] || 1;
-        normals[_i + 1] = n[1] || 1;
-        normals[_i + 2] = n[2] || 1;
+        normals[i] = n[0] || 0;
+        normals[i + 1] = n[1] || 0;
+        normals[i + 2] = n[2] || 0;
+        i += 3;
       }
 
       return normals;
@@ -819,11 +820,14 @@
         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;
@@ -841,39 +845,33 @@
     } // 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);
       }
     }
 
@@ -906,10 +904,7 @@
         });
         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);
@@ -957,29 +952,32 @@
 
       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++;
         }
       }
     }
@@ -1018,7 +1016,10 @@
           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];
@@ -1038,6 +1039,7 @@
           uvs[uOffset + idx2 + 1] = y;
           idx1 += 3;
           idx2 += 2;
+          j++;
         }
       }
 
@@ -1078,8 +1080,10 @@
           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],
@@ -1106,32 +1110,41 @@
         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;
@@ -1154,14 +1167,12 @@
         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) {
@@ -1171,19 +1182,23 @@
           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);
       }
     }
@@ -1204,8 +1219,9 @@
           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],
@@ -1243,6 +1259,8 @@
           leftPoints.push(_op2);
           rightPoints.push(_op);
         }
+
+        i++;
       }
 
       var rAngle = preAngle;
@@ -1311,7 +1329,5 @@
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
-    typeof console !== 'undefined' && console.log('poly-extrude v0.0.1');
-
 }));
 //# sourceMappingURL=poly-extrude.js.map