poly-extrude 0.11.0 → 0.13.0

package/dist/poly-extrude.js

@@ -1,5 +1,5 @@
 /*!
- * poly-extrude v0.11.0
+ * poly-extrude v0.13.0
   */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
@@ -1993,6 +1993,35 @@
 
       return points;
     }
+    function calLineDistance(line) {
+      var distance = 0;
+
+      for (var i = 0, len = line.length; i < len; i++) {
+        var p1 = line[i],
+            p2 = line[i + 1];
+
+        if (i === 0) {
+          p1.distance = 0;
+        }
+
+        if (p1 && p2) {
+          var x1 = p1[0],
+              y1 = p1[1],
+              z1 = p1[2];
+          var x2 = p2[0],
+              y2 = p2[1],
+              z2 = p2[2];
+          var dx = x1 - x2,
+              dy = y1 - y2,
+              dz = (z1 || 0) - (z2 || 0);
+          var dis = Math.sqrt(dx * dx + dy * dy + dz * dz);
+          distance += dis;
+          p2.distance = distance;
+        }
+      }
+
+      return distance;
+    }
 
     function extrudePolygons(polygons, options) {
       options = Object.assign({}, {
@@ -2216,7 +2245,8 @@
       options = Object.assign({}, {
         depth: 2,
         lineWidth: 1,
-        bottomStickGround: false
+        bottomStickGround: false,
+        pathUV: false
       }, options);
       checkOptions(options);
       var results = lines.map(function (line) {
@@ -2240,7 +2270,9 @@
         lineWidth: 1,
         side: 'left',
         sideDepth: 0,
-        bottomStickGround: false
+        bottomStickGround: false,
+        pathUV: false,
+        isSlope: true
       }, options);
       checkOptions(options);
       var _options = options,
@@ -2297,13 +2329,24 @@
         rz = depths[1];
       }
 
-      var points = [],
-          indices = [],
-          uv = [];
       var leftPoints = result.leftPoints,
           rightPoints = result.rightPoints;
+      var line = result.line;
+      var pathUV = options.pathUV;
+
+      if (pathUV) {
+        calLineDistance(line);
+
+        for (var _i = 0, _len = line.length; _i < _len; _i++) {
+          leftPoints[_i].distance = rightPoints[_i].distance = line[_i].distance;
+        }
+      }
+
       var i = 0,
           len = leftPoints.length;
+      var points = [],
+          indices = [],
+          uv = [];
 
       while (i < len) {
         // top left
@@ -2342,22 +2385,42 @@
 
         if (bottomStickGround) {
           points[idx3 + 2] = 0;
+        } // generate path uv
+
+
+        if (pathUV) {
+          var p = line[i];
+          var uvx = p.distance;
+          var uIndex0 = i * 2;
+          uv[uIndex0] = uvx;
+          uv[uIndex0 + 1] = 1;
+          var uIndex1 = len * 2 + uIndex0;
+          uv[uIndex1] = uvx;
+          uv[uIndex1 + 1] = 0;
+          var uIndex2 = len * 2 * 2 + uIndex0;
+          uv[uIndex2] = uvx;
+          uv[uIndex2 + 1] = 1;
+          var uIndex3 = len * 2 * 2 + len * 2 + uIndex0;
+          uv[uIndex3] = uvx;
+          uv[uIndex3 + 1] = 0;
         }
 
         i++;
       }
 
-      i = 0;
-      len = points.length;
-      var uIndex = uv.length - 1;
+      if (!pathUV) {
+        i = 0;
+        len = points.length;
+        var uIndex = uv.length - 1;
 
-      while (i < len) {
-        var x = points[i],
-            y = points[i + 1];
-        uv[++uIndex] = x;
-        uv[++uIndex] = y; // uvs.push(x, y);
+        while (i < len) {
+          var x = points[i],
+              y = points[i + 1];
+          uv[++uIndex] = x;
+          uv[++uIndex] = y; // uvs.push(x, y);
 
-        i += 3;
+          i += 3;
+        }
       }
 
       i = 0;
@@ -2423,19 +2486,24 @@
       var bottomStickGround = options.bottomStickGround;
       var rings = [leftPoints, rightPoints];
       var depthsEnable = result.depths;
+      var pathUV = options.pathUV;
+      var lineWidth = options.lineWidth;
       var pIndex = points.length - 1;
       var iIndex = indices.length - 1;
+      var uIndex = uv.length - 1;
 
       function addOneSideIndex(v1, v2) {
         var idx = points.length / 3; // let pIndex = points.length - 1;
-        // top
+
+        var v1Depth = depthsEnable ? v1.depth : z;
+        var v2Depth = depthsEnable ? v2.depth : z; // top
 
         points[++pIndex] = v1[0];
         points[++pIndex] = v1[1];
-        points[++pIndex] = (depthsEnable ? v1.depth : z) + v1[2];
+        points[++pIndex] = v1Depth + v1[2];
         points[++pIndex] = v2[0];
         points[++pIndex] = v2[1];
-        points[++pIndex] = (depthsEnable ? v2.depth : z) + v2[2]; // points.push(v1[0], v1[1], (depthsEnable ? v1.depth : z) + v1[2], v2[0], v2[1], (depthsEnable ? v2.depth : z) + v2[2]);
+        points[++pIndex] = v2Depth + v2[2]; // points.push(v1[0], v1[1], (depthsEnable ? v1.depth : z) + v1[2], v2[0], v2[1], (depthsEnable ? v2.depth : z) + v2[2]);
         // bottom
 
         points[++pIndex] = v1[0];
@@ -2456,10 +2524,21 @@
         indices[++iIndex] = d;
         indices[++iIndex] = b; // index.push(a, c, b, c, d, b);
 
-        generateSideWallUV(uv, points, a, b, c, d);
+        if (!pathUV) {
+          generateSideWallUV(uv, points, a, b, c, d);
+        } else {
+          uv[++uIndex] = v1.distance;
+          uv[++uIndex] = v1Depth / lineWidth;
+          uv[++uIndex] = v2.distance;
+          uv[++uIndex] = v2Depth / lineWidth;
+          uv[++uIndex] = v1.distance;
+          uv[++uIndex] = 0;
+          uv[++uIndex] = v2.distance;
+          uv[++uIndex] = 0;
+        }
       }
 
-      for (var i = 0, _len = rings.length; i < _len; i++) {
+      for (var i = 0, _len2 = rings.length; i < _len2; i++) {
         var ring = rings[i];
 
         if (i > 0) {
@@ -2483,9 +2562,9 @@
       var len = leftPoints.length;
       var vs = [rightPoints[0], leftPoints[0], leftPoints[len - 1], rightPoints[len - 1]];
 
-      for (var _i = 0; _i < vs.length; _i += 2) {
-        var _v = vs[_i],
-            _v2 = vs[_i + 1];
+      for (var _i2 = 0; _i2 < vs.length; _i2 += 2) {
+        var _v = vs[_i2],
+            _v2 = vs[_i2 + 1];
         addOneSideIndex(_v, _v2);
       }
     }
@@ -2501,6 +2580,11 @@
     function expandLine(line, options) {
       // let preAngle = 0;
       var radius = options.lineWidth / 2;
+
+      if (options.isSlope) {
+        radius *= 2;
+      }
+
       var points = [],
           leftPoints = [],
           rightPoints = [];
@@ -2582,7 +2666,8 @@
       return {
         offsetPoints: points,
         leftPoints: leftPoints,
-        rightPoints: rightPoints
+        rightPoints: rightPoints,
+        line: line
       };
     } // eslint-disable-next-line no-unused-vars
 
@@ -4574,6 +4659,79 @@
       };
     }
 
+    function plane(width, height, devideW, devideH) {
+      devideW = Math.max(1, devideW);
+      devideH = Math.max(1, devideH);
+      var dx = width / devideW,
+          dy = height / devideH;
+      var minX = -width / 2,
+          maxY = height / 2,
+          minY = -height / 2;
+      var len = (devideW + 1) * (devideH + 1);
+      var position = new Float32Array(len * 3),
+          uv = new Float32Array(len * 2),
+          normal = new Float32Array(len * 3),
+          indices = new Uint32Array(len * 10);
+      var index = 0,
+          uIndex = 0,
+          iIndex = 0;
+
+      for (var j = 0; j <= devideH; j++) {
+        for (var i = 0; i <= devideW; i++) {
+          var x = minX + dx * i;
+          var y = maxY - dy * j;
+          position[index] = x;
+          position[index + 1] = y;
+          position[index + 2] = 0;
+          normal[index] = 0;
+          normal[index + 1] = 0;
+          normal[index + 2] = 1; // position.push(x, y, 0);
+          // normal.push(0, 0, 1);
+
+          var uvx = (x - minX) / width,
+              uvy = (y - minY) / height; // uv.push(uvx, uvy);
+
+          uv[uIndex] = uvx;
+          uv[uIndex + 1] = uvy;
+          index += 3;
+          uIndex += 2;
+
+          if (i < devideW && j < devideH) {
+            var a = j * (devideW + 1) + i,
+                b = a + 1,
+                c = (devideW + 1) * (j + 1) + i,
+                d = c + 1;
+            indices[iIndex] = a;
+            indices[iIndex + 1] = c;
+            indices[iIndex + 2] = b;
+            indices[iIndex + 3] = c;
+            indices[iIndex + 4] = d;
+            indices[iIndex + 5] = b;
+            iIndex += 6; // indexs.push(a, c, b, c, d, b);
+          }
+        }
+      }
+
+      var indexArray = new Uint32Array(iIndex);
+
+      for (var _i = 0, _len = indexArray.length; _i < _len; _i++) {
+        indexArray[_i] = indices[_i];
+      } // for (let j = 0; j < devideH; j++) {
+      //     for (let i = 0; i < devideW; i++) {
+      //         const a = j * (devideW + 1) + i, b = a + 1, c = (devideW + 1) * (j + 1) + i, d = c + 1;
+      //         indexs.push(a, c, b, c, d, b);
+      //     }
+      // }
+
+
+      return {
+        position: position,
+        uv: uv,
+        normal: normal,
+        indices: indexArray
+      };
+    }
+
     exports.cylinder = cylinder;
     exports.expandLine = expandLine;
     exports.expandPaths = expandPaths;
@@ -4582,8 +4740,8 @@
     exports.extrudePolylines = extrudePolylines;
     exports.extrudeSlopes = extrudeSlopes;
     exports.leftOnLine = leftOnLine;
+    exports.plane = plane;
 
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-//# sourceMappingURL=poly-extrude.js.map