poly-extrude 0.9.0 → 0.11.0

package/dist/poly-extrude.js

@@ -1,5 +1,5 @@
 /*!
- * poly-extrude v0.9.0
+ * poly-extrude v0.11.0
   */
 (function (global, factory) {
     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
@@ -670,2507 +670,2155 @@
 
     var earcut$1 = earcut$2.exports;
 
-    /**
-     * https://github.com/Turfjs/turf/blob/master/packages/turf-boolean-clockwise/index.ts
-     * @param {*} ring
-     * @returns
-     */
-    function isClockwise(ring) {
-      var sum = 0;
-      var i = 1;
-      var prev;
-      var cur;
-      var len = ring.length;
-
-      while (i < len) {
-        prev = cur || ring[0];
-        cur = ring[i];
-        sum += (cur[0] - prev[0]) * (cur[1] + prev[1]);
-        i++;
+    function _defineProperties(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
       }
-
-      return sum > 0;
     }
 
-    function v3Sub(out, v1, v2) {
-      out[0] = v1[0] - v2[0];
-      out[1] = v1[1] - v2[1];
-      out[2] = v1[2] - v2[2];
-      return out;
+    function _createClass(Constructor, protoProps, staticProps) {
+      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+      if (staticProps) _defineProperties(Constructor, staticProps);
+      Object.defineProperty(Constructor, "prototype", {
+        writable: false
+      });
+      return Constructor;
     }
 
-    function v3Normalize(out, v) {
-      var x = v[0];
-      var y = v[1];
-      var z = v[2];
-      var d = Math.sqrt(x * x + y * y + z * z) || 1;
-      out[0] = x / d;
-      out[1] = y / d;
-      out[2] = z / d;
-      return out;
+    function _inheritsLoose(subClass, superClass) {
+      subClass.prototype = Object.create(superClass.prototype);
+      subClass.prototype.constructor = subClass;
+
+      _setPrototypeOf(subClass, superClass);
     }
 
-    function v3Cross(out, v1, v2) {
-      var ax = v1[0],
-          ay = v1[1],
-          az = v1[2],
-          bx = v2[0],
-          by = v2[1],
-          bz = v2[2];
-      out[0] = ay * bz - az * by;
-      out[1] = az * bx - ax * bz;
-      out[2] = ax * by - ay * bx;
-      return out;
+    function _setPrototypeOf(o, p) {
+      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+      };
+      return _setPrototypeOf(o, p);
     }
 
-    function generateNormal(indices, position) {
-      function v3Set(p, a, b, c) {
-        p[0] = a;
-        p[1] = b;
-        p[2] = c;
-      }
+    // code copy from https://github.com/mrdoob/three.js/blob/dev/src/math/Quaternion.js
+    // import { clamp } from './MathUtils.js';
+    var Quaternion = /*#__PURE__*/function () {
+      function Quaternion(x, y, z, w) {
+        if (x === void 0) {
+          x = 0;
+        }
 
-      var p1 = [];
-      var p2 = [];
-      var p3 = [];
-      var v21 = [];
-      var v32 = [];
-      var n = [];
-      var len = indices.length;
-      var normals = new Float32Array(position.length);
-      var f = 0;
+        if (y === void 0) {
+          y = 0;
+        }
 
-      while (f < len) {
-        // const i1 = indices[f++] * 3;
-        // const i2 = indices[f++] * 3;
-        // const i3 = indices[f++] * 3;
-        // const i1 = indices[f];
-        // const i2 = indices[f + 1];
-        // const i3 = indices[f + 2];
-        var a = indices[f],
-            b = indices[f + 1],
-            c = indices[f + 2];
-        var i1 = a * 3,
-            i2 = b * 3,
-            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]);
-        v3Sub(v32, p3, p2);
-        v3Sub(v21, p1, p2);
-        v3Cross(n, v32, v21); // Already be weighted by the triangle area
+        if (z === void 0) {
+          z = 0;
+        }
 
-        for (var _i = 0; _i < 3; _i++) {
-          normals[i1 + _i] += n[_i];
-          normals[i2 + _i] += n[_i];
-          normals[i3 + _i] += n[_i];
+        if (w === void 0) {
+          w = 1;
         }
 
-        f += 3;
+        this.isQuaternion = true;
+        this._x = x;
+        this._y = y;
+        this._z = z;
+        this._w = w;
       }
 
-      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;
-        i += 3;
-      }
+      Quaternion.slerpFlat = function slerpFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
+        // fuzz-free, array-based Quaternion SLERP operation
+        var x0 = src0[srcOffset0 + 0],
+            y0 = src0[srcOffset0 + 1],
+            z0 = src0[srcOffset0 + 2],
+            w0 = src0[srcOffset0 + 3];
+        var x1 = src1[srcOffset1 + 0],
+            y1 = src1[srcOffset1 + 1],
+            z1 = src1[srcOffset1 + 2],
+            w1 = src1[srcOffset1 + 3];
 
-      return normals;
-    }
-    function merge(results) {
-      if (results.length === 1) {
-        var _result = {
-          position: results[0].position,
-          normal: results[0].normal,
-          uv: results[0].uv,
-          indices: results[0].indices,
-          results: results
-        };
-        return _result;
-      }
+        if (t === 0) {
+          dst[dstOffset + 0] = x0;
+          dst[dstOffset + 1] = y0;
+          dst[dstOffset + 2] = z0;
+          dst[dstOffset + 3] = w0;
+          return;
+        }
 
-      var plen = 0,
-          ilen = 0;
+        if (t === 1) {
+          dst[dstOffset + 0] = x1;
+          dst[dstOffset + 1] = y1;
+          dst[dstOffset + 2] = z1;
+          dst[dstOffset + 3] = w1;
+          return;
+        }
 
-      for (var i = 0, len = results.length; i < len; i++) {
-        var _results$i = results[i],
-            position = _results$i.position,
-            indices = _results$i.indices;
-        plen += position.length;
-        ilen += indices.length;
-      }
+        if (w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1) {
+          var s = 1 - t;
+          var cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
+              dir = cos >= 0 ? 1 : -1,
+              sqrSin = 1 - cos * cos; // Skip the Slerp for tiny steps to avoid numeric problems:
 
-      var result = {
-        position: new Float32Array(plen),
-        normal: new Float32Array(plen),
-        uv: new Float32Array(plen / 3 * 2),
-        indices: new Uint32Array(ilen),
-        results: results
-      };
-      var pOffset = 0,
-          pCount = 0,
-          iIdx = 0,
-          uvOffset = 0;
+          if (sqrSin > Number.EPSILON) {
+            var sin = Math.sqrt(sqrSin),
+                len = Math.atan2(sin, cos * dir);
+            s = Math.sin(s * len) / sin;
+            t = Math.sin(t * len) / sin;
+          }
 
-      for (var _i2 = 0, _len = results.length; _i2 < _len; _i2++) {
-        var _results$_i = results[_i2],
-            _position = _results$_i.position,
-            _indices = _results$_i.indices,
-            normal = _results$_i.normal,
-            uv = _results$_i.uv;
-        result.position.set(_position, pOffset);
-        result.normal.set(normal, pOffset);
-        result.uv.set(uv, uvOffset);
-        var j = 0;
-        var len1 = _indices.length;
+          var tDir = t * dir;
+          x0 = x0 * s + x1 * tDir;
+          y0 = y0 * s + y1 * tDir;
+          z0 = z0 * s + z1 * tDir;
+          w0 = w0 * s + w1 * tDir; // Normalize in case we just did a lerp:
 
-        while (j < len1) {
-          var pIndex = _indices[j] + pCount;
-          result.indices[iIdx] = pIndex;
-          iIdx++;
-          j++;
+          if (s === 1 - t) {
+            var f = 1 / Math.sqrt(x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0);
+            x0 *= f;
+            y0 *= f;
+            z0 *= f;
+            w0 *= f;
+          }
         }
 
-        uvOffset += uv.length;
-        pOffset += _position.length;
-        pCount += _position.length / 3;
-      }
-
-      return result;
-    }
-    function radToDeg(rad) {
-      return rad * 180 / Math.PI;
-    }
-    function degToRad(angle) {
-      return angle / 180 * Math.PI;
-    } // https://github.com/mrdoob/three.js/blob/16f13e3b07e31d0e9a00df7c3366bbe0e464588c/src/geometries/ExtrudeGeometry.js?_pjax=%23js-repo-pjax-container#L736
+        dst[dstOffset] = x0;
+        dst[dstOffset + 1] = y0;
+        dst[dstOffset + 2] = z0;
+        dst[dstOffset + 3] = w0;
+      };
 
-    function generateSideWallUV(uvs, vertices, indexA, indexB, indexC, indexD) {
-      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];
-      var uIndex = uvs.length - 1;
-
-      if (Math.abs(a_y - b_y) < Math.abs(a_x - b_x)) {
-        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[++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);
-      }
-    }
+      Quaternion.multiplyQuaternionsFlat = function multiplyQuaternionsFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1) {
+        var x0 = src0[srcOffset0];
+        var y0 = src0[srcOffset0 + 1];
+        var z0 = src0[srcOffset0 + 2];
+        var w0 = src0[srcOffset0 + 3];
+        var x1 = src1[srcOffset1];
+        var y1 = src1[srcOffset1 + 1];
+        var z1 = src1[srcOffset1 + 2];
+        var w1 = src1[srcOffset1 + 3];
+        dst[dstOffset] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
+        dst[dstOffset + 1] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
+        dst[dstOffset + 2] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
+        dst[dstOffset + 3] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
+        return dst;
+      };
 
-    function extrudePolygons(polygons, options) {
-      options = Object.assign({}, {
-        depth: 2
-      }, options);
-      var results = polygons.map(function (polygon) {
-        for (var i = 0, len = polygon.length; i < len; i++) {
-          var ring = polygon[i];
-          validateRing(ring);
+      var _proto = Quaternion.prototype;
 
-          if (i === 0) {
-            if (!isClockwise(ring)) {
-              polygon[i] = ring.reverse();
-            }
-          } else if (isClockwise(ring)) {
-            polygon[i] = ring.reverse();
-          }
+      _proto.set = function set(x, y, z, w) {
+        this._x = x;
+        this._y = y;
+        this._z = z;
+        this._w = w;
 
-          if (isClosedRing(ring)) {
-            ring.splice(ring.length - 1, 1);
-          }
-        }
+        this._onChangeCallback();
 
-        var result = flatVertices(polygon, options);
-        result.polygon = polygon;
-        var triangles = earcut$1(result.flatVertices, result.holes, 2);
-        generateTopAndBottom$1(result, triangles);
-        generateSides$1(result, options);
-        result.position = new Float32Array(result.points);
-        result.indices = new Uint32Array(result.indices);
-        result.uv = new Float32Array(result.uv);
-        result.normal = generateNormal(result.indices, result.position);
-        return result;
-      });
-      var result = merge(results);
-      result.polygons = polygons;
-      return result;
-    }
+        return this;
+      };
 
-    function generateTopAndBottom$1(result, triangles) {
-      var indices = [];
-      var count = result.count;
+      _proto.clone = function clone() {
+        return new this.constructor(this._x, this._y, this._z, this._w);
+      };
 
-      for (var i = 0, len = triangles.length; i < len; i += 3) {
-        // top
-        var a = triangles[i],
-            b = triangles[i + 1],
-            c = triangles[i + 2];
-        indices[i] = a;
-        indices[i + 1] = b;
-        indices[i + 2] = c; // bottom
+      _proto.copy = function copy(quaternion) {
+        this._x = quaternion.x;
+        this._y = quaternion.y;
+        this._z = quaternion.z;
+        this._w = quaternion.w;
 
-        var idx = len + i;
-        var a1 = count + a,
-            b1 = count + b,
-            c1 = count + c;
-        indices[idx] = a1;
-        indices[idx + 1] = b1;
-        indices[idx + 2] = c1;
-      }
+        this._onChangeCallback();
 
-      result.indices = indices;
-    }
+        return this;
+      };
 
-    function generateSides$1(result, options) {
-      var points = result.points,
-          indices = result.indices,
-          polygon = result.polygon,
-          uv = result.uv;
-      var depth = options.depth;
-      var pIndex = points.length - 1;
-      var iIndex = indices.length - 1;
+      _proto.setFromEuler = function setFromEuler(euler, update) {
+        if (update === void 0) {
+          update = true;
+        }
 
-      for (var i = 0, len = polygon.length; i < len; i++) {
-        var ring = polygon[i];
-        var j = 0;
-        var len1 = ring.length;
+        var x = euler._x,
+            y = euler._y,
+            z = euler._z,
+            order = euler._order; // http://www.mathworks.com/matlabcentral/fileexchange/
+        // 20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
+        // content/SpinCalc.m
 
-        while (j < len1) {
-          var v1 = ring[j];
-          var v2 = ring[j + 1];
+        var cos = Math.cos;
+        var sin = Math.sin;
+        var c1 = cos(x / 2);
+        var c2 = cos(y / 2);
+        var c3 = cos(z / 2);
+        var s1 = sin(x / 2);
+        var s2 = sin(y / 2);
+        var s3 = sin(z / 2);
 
-          if (j === len1 - 1) {
-            v2 = ring[0];
-          }
+        switch (order) {
+          case 'XYZ':
+            this._x = s1 * c2 * c3 + c1 * s2 * s3;
+            this._y = c1 * s2 * c3 - s1 * c2 * s3;
+            this._z = c1 * c2 * s3 + s1 * s2 * c3;
+            this._w = c1 * c2 * c3 - s1 * s2 * s3;
+            break;
 
-          var idx = points.length / 3;
-          var x1 = v1[0],
-              y1 = v1[1],
-              z1 = v1[2] || 0,
-              x2 = v2[0],
-              y2 = v2[1],
-              z2 = v2[2] || 0;
-          points[++pIndex] = x1;
-          points[++pIndex] = y1;
-          points[++pIndex] = z1 + depth;
-          points[++pIndex] = x2;
-          points[++pIndex] = y2;
-          points[++pIndex] = z2 + depth;
-          points[++pIndex] = x1;
-          points[++pIndex] = y1;
-          points[++pIndex] = z1;
-          points[++pIndex] = x2;
-          points[++pIndex] = y2;
-          points[++pIndex] = z2; // points.push(x1, y1, z, x2, y2, z, x1, y1, 0, x2, y2, 0);
+          case 'YXZ':
+            this._x = s1 * c2 * c3 + c1 * s2 * s3;
+            this._y = c1 * s2 * c3 - s1 * c2 * s3;
+            this._z = c1 * c2 * s3 - s1 * s2 * c3;
+            this._w = c1 * c2 * c3 + s1 * s2 * s3;
+            break;
 
-          var a = idx + 2,
-              b = idx + 3,
-              c = idx,
-              d = idx + 1; // points.push(p3, p4, p1, p2);
-          // index.push(a, c, b, c, d, b);
+          case 'ZXY':
+            this._x = s1 * c2 * c3 - c1 * s2 * s3;
+            this._y = c1 * s2 * c3 + s1 * c2 * s3;
+            this._z = c1 * c2 * s3 + s1 * s2 * c3;
+            this._w = c1 * c2 * c3 - s1 * s2 * s3;
+            break;
 
-          indices[++iIndex] = a;
-          indices[++iIndex] = c;
-          indices[++iIndex] = b;
-          indices[++iIndex] = c;
-          indices[++iIndex] = d;
-          indices[++iIndex] = b; // index.push(c, d, b);
+          case 'ZYX':
+            this._x = s1 * c2 * c3 - c1 * s2 * s3;
+            this._y = c1 * s2 * c3 + s1 * c2 * s3;
+            this._z = c1 * c2 * s3 - s1 * s2 * c3;
+            this._w = c1 * c2 * c3 + s1 * s2 * s3;
+            break;
 
-          generateSideWallUV(uv, points, a, b, c, d);
-          j++;
-        }
-      }
-    }
+          case 'YZX':
+            this._x = s1 * c2 * c3 + c1 * s2 * s3;
+            this._y = c1 * s2 * c3 + s1 * c2 * s3;
+            this._z = c1 * c2 * s3 - s1 * s2 * c3;
+            this._w = c1 * c2 * c3 - s1 * s2 * s3;
+            break;
 
-    function calPolygonPointsCount(polygon) {
-      var count = 0;
-      var i = 0;
-      var len = polygon.length;
+          case 'XZY':
+            this._x = s1 * c2 * c3 - c1 * s2 * s3;
+            this._y = c1 * s2 * c3 - s1 * c2 * s3;
+            this._z = c1 * c2 * s3 + s1 * s2 * c3;
+            this._w = c1 * c2 * c3 + s1 * s2 * s3;
+            break;
 
-      while (i < len) {
-        count += polygon[i].length;
-        i++;
-      }
+          default:
+            console.warn('THREE.Quaternion: .setFromEuler() encountered an unknown order: ' + order);
+        }
 
-      return count;
-    }
+        if (update === true) this._onChangeCallback();
+        return this;
+      };
 
-    function flatVertices(polygon, options) {
-      var count = calPolygonPointsCount(polygon);
-      var len = polygon.length;
-      var holes = [],
-          flatVertices = new Float32Array(count * 2),
-          points = [],
-          uv = [];
-      var pOffset = count * 3,
-          uOffset = count * 2;
-      var depth = options.depth;
-      var idx0 = 0,
-          idx1 = 0,
-          idx2 = 0;
-
-      for (var i = 0; i < len; i++) {
-        var ring = polygon[i];
+      _proto.setFromAxisAngle = function setFromAxisAngle(axis, angle) {
+        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
+        // assumes axis is normalized
+        var halfAngle = angle / 2,
+            s = Math.sin(halfAngle);
+        this._x = axis.x * s;
+        this._y = axis.y * s;
+        this._z = axis.z * s;
+        this._w = Math.cos(halfAngle);
 
-        if (i > 0) {
-          holes.push(idx0 / 2);
-        }
+        this._onChangeCallback();
 
-        var j = 0;
-        var len1 = ring.length;
+        return this;
+      };
 
-        while (j < len1) {
-          var c = ring[j];
-          var x = c[0],
-              y = c[1],
-              z = c[2] || 0;
-          flatVertices[idx0++] = x;
-          flatVertices[idx0++] = y; // top vertices
+      _proto.setFromRotationMatrix = function setFromRotationMatrix(m) {
+        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
+        // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+        var te = m.elements,
+            m11 = te[0],
+            m12 = te[4],
+            m13 = te[8],
+            m21 = te[1],
+            m22 = te[5],
+            m23 = te[9],
+            m31 = te[2],
+            m32 = te[6],
+            m33 = te[10],
+            trace = m11 + m22 + m33;
 
-          points[idx1] = x;
-          points[idx1 + 1] = y;
-          points[idx1 + 2] = depth + z; // bottom vertices
+        if (trace > 0) {
+          var s = 0.5 / Math.sqrt(trace + 1.0);
+          this._w = 0.25 / s;
+          this._x = (m32 - m23) * s;
+          this._y = (m13 - m31) * s;
+          this._z = (m21 - m12) * s;
+        } else if (m11 > m22 && m11 > m33) {
+          var _s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);
 
-          points[pOffset + idx1] = x;
-          points[pOffset + idx1 + 1] = y;
-          points[pOffset + idx1 + 2] = z;
-          uv[idx2] = x;
-          uv[idx2 + 1] = y;
-          uv[uOffset + idx2] = x;
-          uv[uOffset + idx2 + 1] = y;
-          idx1 += 3;
-          idx2 += 2;
-          j++;
-        }
-      }
+          this._w = (m32 - m23) / _s;
+          this._x = 0.25 * _s;
+          this._y = (m12 + m21) / _s;
+          this._z = (m13 + m31) / _s;
+        } else if (m22 > m33) {
+          var _s2 = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);
 
-      return {
-        flatVertices: flatVertices,
-        holes: holes,
-        points: points,
-        count: count,
-        uv: uv
-      };
-    }
+          this._w = (m13 - m31) / _s2;
+          this._x = (m12 + m21) / _s2;
+          this._y = 0.25 * _s2;
+          this._z = (m23 + m32) / _s2;
+        } else {
+          var _s3 = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);
 
-    function validateRing(ring) {
-      if (!isClosedRing(ring)) {
-        ring.push(ring[0]);
-      }
-    }
+          this._w = (m21 - m12) / _s3;
+          this._x = (m13 + m31) / _s3;
+          this._y = (m23 + m32) / _s3;
+          this._z = 0.25 * _s3;
+        }
 
-    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;
-    }
+        this._onChangeCallback();
 
-    function checkOptions(options) {
-      options.lineWidth = Math.max(0, options.lineWidth);
-      options.depth = Math.max(0, options.depth);
-      options.sideDepth = Math.max(0, options.sideDepth);
-    }
+        return this;
+      };
 
-    function extrudePolylines(lines, options) {
-      options = Object.assign({}, {
-        depth: 2,
-        lineWidth: 1,
-        bottomStickGround: false
-      }, options);
-      checkOptions(options);
-      var results = lines.map(function (line) {
-        var result = expandLine(line, options);
-        result.line = line;
-        generateTopAndBottom(result, options);
-        generateSides(result, options);
-        result.position = new Float32Array(result.points);
-        result.indices = new Uint32Array(result.indices);
-        result.uv = new Float32Array(result.uv);
-        result.normal = generateNormal(result.indices, result.position);
-        return result;
-      });
-      var result = merge(results);
-      result.lines = lines;
-      return result;
-    }
-    function extrudeSlopes(lines, options) {
-      options = Object.assign({}, {
-        depth: 2,
-        lineWidth: 1,
-        side: 'left',
-        sideDepth: 0,
-        bottomStickGround: false
-      }, options);
-      checkOptions(options);
-      var _options = options,
-          depth = _options.depth,
-          side = _options.side,
-          sideDepth = _options.sideDepth;
-      var results = lines.map(function (line) {
-        var tempResult = expandLine(line, options);
-        tempResult.line = line;
-        var leftPoints = tempResult.leftPoints,
-            rightPoints = tempResult.rightPoints;
-        var result = {
-          line: line
-        };
-        var depths;
+      _proto.setFromUnitVectors = function setFromUnitVectors(vFrom, vTo) {
+        // assumes direction vectors vFrom and vTo are normalized
+        var r = vFrom.dot(vTo) + 1;
 
-        for (var i = 0, len = line.length; i < len; i++) {
-          line[i][2] = line[i][2] || 0;
-        }
+        if (r < Number.EPSILON) {
+          // vFrom and vTo point in opposite directions
+          r = 0;
 
-        if (side === 'left') {
-          result.leftPoints = leftPoints;
-          result.rightPoints = line;
-          depths = [sideDepth, depth];
+          if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
+            this._x = -vFrom.y;
+            this._y = vFrom.x;
+            this._z = 0;
+            this._w = r;
+          } else {
+            this._x = 0;
+            this._y = -vFrom.z;
+            this._z = vFrom.y;
+            this._w = r;
+          }
         } else {
-          result.leftPoints = line;
-          result.rightPoints = rightPoints;
-          depths = [depth, sideDepth];
+          // crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3
+          this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
+          this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
+          this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
+          this._w = r;
         }
 
-        result.depths = depths;
-        generateTopAndBottom(result, options);
-        generateSides(result, options);
-        result.position = new Float32Array(result.points);
-        result.indices = new Uint32Array(result.indices);
-        result.uv = new Float32Array(result.uv);
-        result.normal = generateNormal(result.indices, result.position);
-        return result;
-      });
-      var result = merge(results);
-      result.lines = lines;
-      return result;
-    }
+        return this.normalize();
+      } // angleTo(q) {
+      //     return 2 * Math.acos(Math.abs(clamp(this.dot(q), -1, 1)));
+      // }
+      ;
 
-    function generateTopAndBottom(result, options) {
-      var bottomStickGround = options.bottomStickGround;
-      var z = options.depth;
-      var depths = result.depths;
-      var lz = z,
-          rz = z;
+      _proto.rotateTowards = function rotateTowards(q, step) {
+        var angle = this.angleTo(q);
+        if (angle === 0) return this;
+        var t = Math.min(1, step / angle);
+        this.slerp(q, t);
+        return this;
+      };
 
-      if (depths) {
-        lz = depths[0];
-        rz = depths[1];
-      }
+      _proto.identity = function identity() {
+        return this.set(0, 0, 0, 1);
+      };
 
-      var points = [],
-          indices = [],
-          uv = [];
-      var leftPoints = result.leftPoints,
-          rightPoints = result.rightPoints;
-      var i = 0,
-          len = leftPoints.length;
+      _proto.invert = function invert() {
+        // quaternion is assumed to have unit length
+        return this.conjugate();
+      };
 
-      while (i < len) {
-        // top left
-        var idx0 = i * 3;
-        var _leftPoints$i = leftPoints[i],
-            x1 = _leftPoints$i[0],
-            y1 = _leftPoints$i[1],
-            z1 = _leftPoints$i[2];
-        points[idx0] = x1;
-        points[idx0 + 1] = y1;
-        points[idx0 + 2] = lz + z1; // top right
+      _proto.conjugate = function conjugate() {
+        this._x *= -1;
+        this._y *= -1;
+        this._z *= -1;
 
-        var _rightPoints$i = rightPoints[i],
-            x2 = _rightPoints$i[0],
-            y2 = _rightPoints$i[1],
-            z2 = _rightPoints$i[2];
-        var idx1 = len * 3 + idx0;
-        points[idx1] = x2;
-        points[idx1 + 1] = y2;
-        points[idx1 + 2] = rz + z2; // bottom left
+        this._onChangeCallback();
 
-        var idx2 = len * 2 * 3 + idx0;
-        points[idx2] = x1;
-        points[idx2 + 1] = y1;
-        points[idx2 + 2] = z1;
+        return this;
+      };
 
-        if (bottomStickGround) {
-          points[idx2 + 2] = 0;
-        } // bottom right
+      _proto.dot = function dot(v) {
+        return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
+      };
 
+      _proto.lengthSq = function lengthSq() {
+        return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
+      };
 
-        var idx3 = len * 2 * 3 + len * 3 + idx0;
-        points[idx3] = x2;
-        points[idx3 + 1] = y2;
-        points[idx3 + 2] = z2;
+      _proto.length = function length() {
+        return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w);
+      };
 
-        if (bottomStickGround) {
-          points[idx3 + 2] = 0;
+      _proto.normalize = function normalize() {
+        var l = this.length();
+
+        if (l === 0) {
+          this._x = 0;
+          this._y = 0;
+          this._z = 0;
+          this._w = 1;
+        } else {
+          l = 1 / l;
+          this._x = this._x * l;
+          this._y = this._y * l;
+          this._z = this._z * l;
+          this._w = this._w * l;
         }
 
-        i++;
-      }
+        this._onChangeCallback();
 
-      i = 0;
-      len = points.length;
-      var uIndex = uv.length - 1;
+        return this;
+      };
 
-      while (i < len) {
-        var x = points[i],
-            y = points[i + 1];
-        uv[++uIndex] = x;
-        uv[++uIndex] = y; // uvs.push(x, y);
+      _proto.multiply = function multiply(q) {
+        return this.multiplyQuaternions(this, q);
+      };
 
-        i += 3;
-      }
+      _proto.premultiply = function premultiply(q) {
+        return this.multiplyQuaternions(q, this);
+      };
 
-      i = 0;
-      len = leftPoints.length;
-      var iIndex = indices.length - 1;
+      _proto.multiplyQuaternions = function multiplyQuaternions(a, b) {
+        // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
+        var qax = a._x,
+            qay = a._y,
+            qaz = a._z,
+            qaw = a._w;
+        var qbx = b._x,
+            qby = b._y,
+            qbz = b._z,
+            qbw = b._w;
+        this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
+        this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
+        this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
+        this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
 
-      while (i < len - 1) {
-        // top
-        // left1 left2 right1,right2
-        var a1 = i,
-            b1 = i + 1,
-            c1 = a1 + len,
-            d1 = b1 + len;
-        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
+        this._onChangeCallback();
 
-        var len2 = len * 2;
-        var a2 = i + len2,
-            b2 = a2 + 1,
-            c2 = a2 + len,
-            d2 = b2 + len;
-        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);
+        return this;
+      };
 
-        i++;
-      }
+      _proto.slerp = function slerp(qb, t) {
+        if (t === 0) return this;
+        if (t === 1) return this.copy(qb);
+        var x = this._x,
+            y = this._y,
+            z = this._z,
+            w = this._w; // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
 
-      result.indices = indices;
-      result.points = points;
-      result.uv = uv;
+        var cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
 
-      if (depths) {
-        len = leftPoints.length;
-        i = 0;
+        if (cosHalfTheta < 0) {
+          this._w = -qb._w;
+          this._x = -qb._x;
+          this._y = -qb._y;
+          this._z = -qb._z;
+          cosHalfTheta = -cosHalfTheta;
+        } else {
+          this.copy(qb);
+        }
 
-        while (i < len) {
-          leftPoints[i].depth = lz;
-          rightPoints[i].depth = rz;
-          i++;
+        if (cosHalfTheta >= 1.0) {
+          this._w = w;
+          this._x = x;
+          this._y = y;
+          this._z = z;
+          return this;
         }
-      }
-    }
 
-    function generateSides(result, options) {
-      var points = result.points,
-          indices = result.indices,
-          leftPoints = result.leftPoints,
-          rightPoints = result.rightPoints,
-          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;
+        var sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
 
-      function addOneSideIndex(v1, v2) {
-        var idx = points.length / 3; // let pIndex = points.length - 1;
-        // top
+        if (sqrSinHalfTheta <= Number.EPSILON) {
+          var s = 1 - t;
+          this._w = s * w + t * this._w;
+          this._x = s * x + t * this._x;
+          this._y = s * y + t * this._y;
+          this._z = s * z + t * this._z;
+          this.normalize(); // normalize calls _onChangeCallback()
 
-        points[++pIndex] = v1[0];
-        points[++pIndex] = v1[1];
-        points[++pIndex] = (depthsEnable ? v1.depth : z) + 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]);
-        // bottom
+          return this;
+        }
 
-        points[++pIndex] = v1[0];
-        points[++pIndex] = v1[1];
-        points[++pIndex] = bottomStickGround ? 0 : v1[2];
-        points[++pIndex] = v2[0];
-        points[++pIndex] = v2[1];
-        points[++pIndex] = bottomStickGround ? 0 : v2[2]; // points.push(v1[0], v1[1], v1[2], v2[0], v2[1], v2[2]);
+        var sinHalfTheta = Math.sqrt(sqrSinHalfTheta);
+        var halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta);
+        var ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta,
+            ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
+        this._w = w * ratioA + this._w * ratioB;
+        this._x = x * ratioA + this._x * ratioB;
+        this._y = y * ratioA + this._y * ratioB;
+        this._z = z * ratioA + this._z * ratioB;
 
-        var a = idx + 2,
-            b = idx + 3,
-            c = idx,
-            d = idx + 1;
-        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);
+        this._onChangeCallback();
 
-        generateSideWallUV(uv, points, a, b, c, d);
-      }
+        return this;
+      };
 
-      for (var i = 0, _len = rings.length; i < _len; i++) {
-        var ring = rings[i];
+      _proto.slerpQuaternions = function slerpQuaternions(qa, qb, t) {
+        return this.copy(qa).slerp(qb, t);
+      };
 
-        if (i > 0) {
-          ring = ring.map(function (p) {
-            return p;
-          });
-          ring = ring.reverse();
-        }
+      _proto.random = function random() {
+        // sets this quaternion to a uniform random unit quaternnion
+        // Ken Shoemake
+        // Uniform random rotations
+        // D. Kirk, editor, Graphics Gems III, pages 124-132. Academic Press, New York, 1992.
+        var theta1 = 2 * Math.PI * Math.random();
+        var theta2 = 2 * Math.PI * Math.random();
+        var x0 = Math.random();
+        var r1 = Math.sqrt(1 - x0);
+        var r2 = Math.sqrt(x0);
+        return this.set(r1 * Math.sin(theta1), r1 * Math.cos(theta1), r2 * Math.sin(theta2), r2 * Math.cos(theta2));
+      };
 
-        var j = 0;
-        var len1 = ring.length - 1;
+      _proto.equals = function equals(quaternion) {
+        return quaternion._x === this._x && quaternion._y === this._y && quaternion._z === this._z && quaternion._w === this._w;
+      };
 
-        while (j < len1) {
-          var v1 = ring[j];
-          var v2 = ring[j + 1];
-          addOneSideIndex(v1, v2);
-          j++;
-        }
-      }
+      _proto.fromArray = function fromArray(array, offset) {
+        if (offset === void 0) {
+          offset = 0;
+        }
 
-      var len = leftPoints.length;
-      var vs = [rightPoints[0], leftPoints[0], leftPoints[len - 1], rightPoints[len - 1]];
+        this._x = array[offset];
+        this._y = array[offset + 1];
+        this._z = array[offset + 2];
+        this._w = array[offset + 3];
 
-      for (var _i = 0; _i < vs.length; _i += 2) {
-        var _v = vs[_i],
-            _v2 = vs[_i + 1];
-        addOneSideIndex(_v, _v2);
-      }
-    }
+        this._onChangeCallback();
 
-    var TEMPV1 = {
-      x: 0,
-      y: 0
-    },
-        TEMPV2 = {
-      x: 0,
-      y: 0
-    };
-    function expandLine(line, options) {
-      // let preAngle = 0;
-      var radius = options.lineWidth / 2;
-      var points = [],
-          leftPoints = [],
-          rightPoints = [];
-      var len = line.length;
-      var i = 0;
+        return this;
+      };
 
-      while (i < len) {
-        var p1 = line[i],
-            p2 = line[i + 1];
-        var currentp = line[i]; // last vertex
+      _proto.toArray = function toArray(array, offset) {
+        if (array === void 0) {
+          array = [];
+        }
 
-        if (i === len - 1) {
-          p1 = line[len - 2];
-          p2 = line[len - 1];
+        if (offset === void 0) {
+          offset = 0;
         }
 
-        var dy = p2[1] - p1[1],
-            dx = p2[0] - p1[0];
-        var rAngle = 0;
-        var rad = Math.atan(dy / dx);
-        var angle = radToDeg(rad); // preAngle = angle;
+        array[offset] = this._x;
+        array[offset + 1] = this._y;
+        array[offset + 2] = this._z;
+        array[offset + 3] = this._w;
+        return array;
+      };
 
-        if (i === 0 || i === len - 1) {
-          rAngle = angle;
-          rAngle -= 90;
-        } else {
-          // 至少3个顶点才会触发
-          var p0 = line[i - 1];
-          TEMPV1.x = p0[0] - p1[0];
-          TEMPV1.y = p0[1] - p1[1];
-          TEMPV2.x = p2[0] - p1[0];
-          TEMPV2.y = p2[1] - p1[1];
-          var vAngle = getAngle(TEMPV1, TEMPV2);
-          rAngle = angle - vAngle / 2;
-        }
+      _proto.fromBufferAttribute = function fromBufferAttribute(attribute, index) {
+        this._x = attribute.getX(index);
+        this._y = attribute.getY(index);
+        this._z = attribute.getZ(index);
+        this._w = attribute.getW(index);
 
-        var rRad = degToRad(rAngle);
-        var p3 = currentp;
-        var x = Math.cos(rRad) + p3[0],
-            y = Math.sin(rRad) + p3[1];
-        var p4 = [x, y];
+        this._onChangeCallback();
 
-        var _translateLine = translateLine(p1, p2, radius),
-            line1 = _translateLine[0],
-            line2 = _translateLine[1];
+        return this;
+      };
 
-        var op1 = lineIntersection(line1[0], line1[1], p3, p4);
-        var op2 = lineIntersection(line2[0], line2[1], p3, p4); // 平行，回头路
+      _proto.toJSON = function toJSON() {
+        return this.toArray();
+      };
 
-        if (!op1 || !op2) {
-          var len1 = points.length;
-          var point1 = points[len1 - 2];
-          var point2 = points[len1 - 1];
+      _proto._onChange = function _onChange(callback) {
+        this._onChangeCallback = callback;
+        return this;
+      };
 
-          if (!point1 || !point2) {
-            continue;
-          }
+      _proto._onChangeCallback = function _onChangeCallback() {} // * [Symbol.iterator]() {
+      //     yield this._x;
+      //     yield this._y;
+      //     yield this._z;
+      //     yield this._w;
+      // }
+      ;
 
-          op1 = [point1[0], point1[1]];
-          op2 = [point2[0], point2[1]];
-        }
+      _createClass(Quaternion, [{
+        key: "x",
+        get: function get() {
+          return this._x;
+        },
+        set: function set(value) {
+          this._x = value;
 
-        op1[2] = currentp[2] || 0;
-        op2[2] = currentp[2] || 0; // const [op1, op2] = calOffsetPoint(rRad, radius, p1);
+          this._onChangeCallback();
+        }
+      }, {
+        key: "y",
+        get: function get() {
+          return this._y;
+        },
+        set: function set(value) {
+          this._y = value;
 
-        points.push(op1, op2);
+          this._onChangeCallback();
+        }
+      }, {
+        key: "z",
+        get: function get() {
+          return this._z;
+        },
+        set: function set(value) {
+          this._z = value;
 
-        if (leftOnLine(op1, p1, p2)) {
-          leftPoints.push(op1);
-          rightPoints.push(op2);
-        } else {
-          leftPoints.push(op2);
-          rightPoints.push(op1);
+          this._onChangeCallback();
         }
+      }, {
+        key: "w",
+        get: function get() {
+          return this._w;
+        },
+        set: function set(value) {
+          this._w = value;
 
-        i++;
-      }
+          this._onChangeCallback();
+        }
+      }]);
 
-      return {
-        offsetPoints: points,
-        leftPoints: leftPoints,
-        rightPoints: rightPoints
-      };
-    } // eslint-disable-next-line no-unused-vars
+      return Quaternion;
+    }();
 
-    var getAngle = function getAngle(_ref, _ref2) {
-      var x1 = _ref.x,
-          y1 = _ref.y;
-      var x2 = _ref2.x,
-          y2 = _ref2.y;
-      var dot = x1 * x2 + y1 * y2;
-      var det = x1 * y2 - y1 * x2;
-      var angle = Math.atan2(det, dot) / Math.PI * 180;
-      return (angle + 360) % 360;
-    };
+    // import * as MathUtils from './MathUtils.js';
 
-    function leftOnLine(p, p1, p2) {
-      var x1 = p1[0],
-          y1 = p1[1];
-      var x2 = p2[0],
-          y2 = p2[1];
-      var x = p[0],
-          y = p[1];
-      return (y1 - y2) * x + (x2 - x1) * y + x1 * y2 - x2 * y1 > 0;
-    }
-    /**
-     * 平移线
-     * @param {*} p1
-     * @param {*} p2
-     * @param {*} distance
-     * @returns
-     */
+    var _quaternion = new Quaternion();
 
-    function translateLine(p1, p2, distance) {
-      var dy = p2[1] - p1[1],
-          dx = p2[0] - p1[0];
-      var rad = Math.atan2(dy, dx);
-      var rad1 = rad + Math.PI / 2;
-      var offsetX = Math.cos(rad1) * distance,
-          offsetY = Math.sin(rad1) * distance;
-      var tp1 = [p1[0] + offsetX, p1[1] + offsetY];
-      var tp2 = [p2[0] + offsetX, p2[1] + offsetY];
-      var rad2 = rad - Math.PI / 2;
-      offsetX = Math.cos(rad2) * distance;
-      offsetY = Math.sin(rad2) * distance;
-      var tp3 = [p1[0] + offsetX, p1[1] + offsetY];
-      var tp4 = [p2[0] + offsetX, p2[1] + offsetY];
-      return [[tp1, tp2], [tp3, tp4]];
-    }
-    /**
-     * 直线交点
-     * @param {*} p1
-     * @param {*} p2
-     * @param {*} p3
-     * @param {*} p4
-     * @returns
-     */
+    var Vector3 = /*#__PURE__*/function () {
+      function Vector3(x, y, z) {
+        if (x === void 0) {
+          x = 0;
+        }
 
+        if (y === void 0) {
+          y = 0;
+        }
 
-    function lineIntersection(p1, p2, p3, p4) {
-      var dx1 = p2[0] - p1[0],
-          dy1 = p2[1] - p1[1];
-      var dx2 = p4[0] - p3[0],
-          dy2 = p4[1] - p3[1];
+        if (z === void 0) {
+          z = 0;
+        }
 
-      if (dx1 === 0 && dx2 === 0) {
-        return null;
+        this.x = x;
+        this.y = y;
+        this.z = z;
       }
 
-      if (dy1 === 0 && dy2 === 0) {
-        return null;
-      }
+      var _proto = Vector3.prototype;
 
-      var k1 = dy1 / dx1;
-      var k2 = dy2 / dx2;
-      var b1 = p1[1] - k1 * p1[0];
-      var b2 = p3[1] - k2 * p3[0];
-      var x, y;
+      _proto.set = function set(x, y, z) {
+        if (z === undefined) z = this.z; // sprite.scale.set(x,y)
 
-      if (dx1 === 0) {
-        x = p1[0];
-        y = k2 * x + b2;
-      } else if (dx2 === 0) {
-        x = p3[0];
-        y = k1 * x + b1;
-      } else if (dy1 === 0) {
-        y = p1[1];
-        x = (y - b2) / k2;
-      } else if (dy2 === 0) {
-        y = p3[1];
-        x = (y - b1) / k1;
-      } else {
-        x = (b2 - b1) / (k1 - k2);
-        y = k1 * x + b1;
-      }
-
-      return [x, y];
-    }
-
-    function cylinder(point, options) {
-      if (options === void 0) {
-        options = {};
-      }
-
-      options = Object.assign({}, {
-        radius: 1,
-        height: 2,
-        radialSegments: 6
-      }, options);
-      var radialSegments = Math.round(Math.max(4, options.radialSegments));
-      var _options = options,
-          radius = _options.radius,
-          height = _options.height;
-      var aRad = 360 / radialSegments / 360 * Math.PI * 2;
-      var circlePointsLen = radialSegments + 1;
-      var points = new Float32Array(circlePointsLen * 3 * 2);
-      var centerx = point[0],
-          centery = point[1];
-      var idx = 0,
-          uIdx = 0;
-      var offset = circlePointsLen * 3,
-          uOffset = circlePointsLen * 2;
-      var indices = [],
-          uv = [];
-      var iIndex = indices.length - 1;
-
-      for (var i = -1; i < radialSegments; i++) {
-        var rad = aRad * i;
-        var 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;
-        var 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];
-      var pointsLen = points.length;
-      points[pointsLen - 3] = points[0];
-      points[pointsLen - 2] = points[1];
-      points[pointsLen - 1] = height;
-      var indicesLen = indices.length; // top indices
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        return this;
+      } // setScalar(scalar) {
+      //     this.x = scalar;
+      //     this.y = scalar;
+      //     this.z = scalar;
+      //     return this;
+      // }
+      // setX(x) {
+      //     this.x = x;
+      //     return this;
+      // }
+      // setY(y) {
+      //     this.y = y;
+      //     return this;
+      // }
+      // setZ(z) {
+      //     this.z = z;
+      //     return this;
+      // }
+      // setComponent(index, value) {
+      //     switch (index) {
+      //         case 0: this.x = value; break;
+      //         case 1: this.y = value; break;
+      //         case 2: this.z = value; break;
+      //         default: throw new Error('index is out of range: ' + index);
+      //     }
+      //     return this;
+      // }
+      // getComponent(index) {
+      //     switch (index) {
+      //         case 0: return this.x;
+      //         case 1: return this.y;
+      //         case 2: return this.z;
+      //         default: throw new Error('index is out of range: ' + index);
+      //     }
+      // }
+      ;
 
-      iIndex = indices.length - 1;
+      _proto.clone = function clone() {
+        return new this.constructor(this.x, this.y, this.z);
+      };
 
-      for (var _i = 0; _i < indicesLen; _i++) {
-        var index = indices[_i];
-        indices[++iIndex] = index + circlePointsLen; // indices.push(index + circlePointsLen);
-      }
+      _proto.copy = function copy(v) {
+        this.x = v.x;
+        this.y = v.y;
+        this.z = v.z;
+        return this;
+      };
 
-      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;
+      _proto.add = function add(v) {
+        this.x += v.x;
+        this.y += v.y;
+        this.z += v.z;
+        return this;
+      };
 
-      for (var _i2 = 0, len = points.length / 2; _i2 < len - 3; _i2 += 3) {
-        var x1 = points[_i2],
-            y1 = points[_i2 + 1],
-            x2 = points[_i2 + 3],
-            y2 = points[_i2 + 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;
-        var a = idx + 2,
-            b = idx + 3,
-            c = idx,
-            d = idx + 1; // indices.push(a, c, b, c, d, b);
+      _proto.addScalar = function addScalar(s) {
+        this.x += s;
+        this.y += s;
+        this.z += s;
+        return this;
+      };
 
-        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);
+      _proto.addVectors = function addVectors(a, b) {
+        this.x = a.x + b.x;
+        this.y = a.y + b.y;
+        this.z = a.z + b.z;
+        return this;
+      };
 
-        idx += 4;
-        var 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);
+      _proto.addScaledVector = function addScaledVector(v, s) {
+        this.x += v.x * s;
+        this.y += v.y * s;
+        this.z += v.z * s;
+        return this;
+      };
 
-        uIdx++;
-      }
+      _proto.sub = function sub(v) {
+        this.x -= v.x;
+        this.y -= v.y;
+        this.z -= v.z;
+        return this;
+      };
 
-      var position = new Float32Array(points.length + sidePoints.length);
-      position.set(points, 0);
-      position.set(sidePoints, points.length);
-      var normal = generateNormal(indices, position);
-      return {
-        points: points,
-        indices: new Uint32Array(indices),
-        position: position,
-        normal: normal,
-        uv: new Float32Array(uv)
+      _proto.subScalar = function subScalar(s) {
+        this.x -= s;
+        this.y -= s;
+        this.z -= s;
+        return this;
       };
-    }
 
-    function _regeneratorRuntime() {
-      /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+      _proto.subVectors = function subVectors(a, b) {
+        this.x = a.x - b.x;
+        this.y = a.y - b.y;
+        this.z = a.z - b.z;
+        return this;
+      };
 
-      _regeneratorRuntime = function () {
-        return exports;
+      _proto.multiply = function multiply(v) {
+        this.x *= v.x;
+        this.y *= v.y;
+        this.z *= v.z;
+        return this;
       };
 
-      var exports = {},
-          Op = Object.prototype,
-          hasOwn = Op.hasOwnProperty,
-          $Symbol = "function" == typeof Symbol ? Symbol : {},
-          iteratorSymbol = $Symbol.iterator || "@@iterator",
-          asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator",
-          toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
-
-      function define(obj, key, value) {
-        return Object.defineProperty(obj, key, {
-          value: value,
-          enumerable: !0,
-          configurable: !0,
-          writable: !0
-        }), obj[key];
-      }
+      _proto.multiplyScalar = function multiplyScalar(scalar) {
+        this.x *= scalar;
+        this.y *= scalar;
+        this.z *= scalar;
+        return this;
+      };
 
-      try {
-        define({}, "");
-      } catch (err) {
-        define = function (obj, key, value) {
-          return obj[key] = value;
-        };
-      }
+      _proto.multiplyVectors = function multiplyVectors(a, b) {
+        this.x = a.x * b.x;
+        this.y = a.y * b.y;
+        this.z = a.z * b.z;
+        return this;
+      } // applyEuler(euler) {
+      //     return this.applyQuaternion(_quaternion.setFromEuler(euler));
+      // }
+      ;
 
-      function wrap(innerFn, outerFn, self, tryLocsList) {
-        var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,
-            generator = Object.create(protoGenerator.prototype),
-            context = new Context(tryLocsList || []);
-        return generator._invoke = function (innerFn, self, context) {
-          var state = "suspendedStart";
-          return function (method, arg) {
-            if ("executing" === state) throw new Error("Generator is already running");
-
-            if ("completed" === state) {
-              if ("throw" === method) throw arg;
-              return doneResult();
-            }
-
-            for (context.method = method, context.arg = arg;;) {
-              var delegate = context.delegate;
-
-              if (delegate) {
-                var delegateResult = maybeInvokeDelegate(delegate, context);
-
-                if (delegateResult) {
-                  if (delegateResult === ContinueSentinel) continue;
-                  return delegateResult;
-                }
-              }
-
-              if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) {
-                if ("suspendedStart" === state) throw state = "completed", context.arg;
-                context.dispatchException(context.arg);
-              } else "return" === context.method && context.abrupt("return", context.arg);
-              state = "executing";
-              var record = tryCatch(innerFn, self, context);
-
-              if ("normal" === record.type) {
-                if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue;
-                return {
-                  value: record.arg,
-                  done: context.done
-                };
-              }
-
-              "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg);
-            }
-          };
-        }(innerFn, self, context), generator;
-      }
-
-      function tryCatch(fn, obj, arg) {
-        try {
-          return {
-            type: "normal",
-            arg: fn.call(obj, arg)
-          };
-        } catch (err) {
-          return {
-            type: "throw",
-            arg: err
-          };
-        }
-      }
-
-      exports.wrap = wrap;
-      var ContinueSentinel = {};
-
-      function Generator() {}
-
-      function GeneratorFunction() {}
-
-      function GeneratorFunctionPrototype() {}
+      _proto.applyAxisAngle = function applyAxisAngle(axis, angle) {
+        return this.applyQuaternion(_quaternion.setFromAxisAngle(axis, angle));
+      } // applyMatrix3(m) {
+      //     const x = this.x, y = this.y, z = this.z;
+      //     const e = m.elements;
+      //     this.x = e[0] * x + e[3] * y + e[6] * z;
+      //     this.y = e[1] * x + e[4] * y + e[7] * z;
+      //     this.z = e[2] * x + e[5] * y + e[8] * z;
+      //     return this;
+      // }
+      // applyNormalMatrix(m) {
+      //     return this.applyMatrix3(m).normalize();
+      // }
+      ;
 
-      var IteratorPrototype = {};
-      define(IteratorPrototype, iteratorSymbol, function () {
+      _proto.applyMatrix4 = function applyMatrix4(m) {
+        var x = this.x,
+            y = this.y,
+            z = this.z;
+        var e = m.elements;
+        var w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
+        this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w;
+        this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w;
+        this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w;
         return this;
-      });
-      var getProto = Object.getPrototypeOf,
-          NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-      NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);
-      var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
-
-      function defineIteratorMethods(prototype) {
-        ["next", "throw", "return"].forEach(function (method) {
-          define(prototype, method, function (arg) {
-            return this._invoke(method, arg);
-          });
-        });
-      }
-
-      function AsyncIterator(generator, PromiseImpl) {
-        function invoke(method, arg, resolve, reject) {
-          var record = tryCatch(generator[method], generator, arg);
-
-          if ("throw" !== record.type) {
-            var result = record.arg,
-                value = result.value;
-            return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) {
-              invoke("next", value, resolve, reject);
-            }, function (err) {
-              invoke("throw", err, resolve, reject);
-            }) : PromiseImpl.resolve(value).then(function (unwrapped) {
-              result.value = unwrapped, resolve(result);
-            }, function (error) {
-              return invoke("throw", error, resolve, reject);
-            });
-          }
-
-          reject(record.arg);
-        }
-
-        var previousPromise;
-
-        this._invoke = function (method, arg) {
-          function callInvokeWithMethodAndArg() {
-            return new PromiseImpl(function (resolve, reject) {
-              invoke(method, arg, resolve, reject);
-            });
-          }
-
-          return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
-        };
-      }
-
-      function maybeInvokeDelegate(delegate, context) {
-        var method = delegate.iterator[context.method];
-
-        if (undefined === method) {
-          if (context.delegate = null, "throw" === context.method) {
-            if (delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method)) return ContinueSentinel;
-            context.method = "throw", context.arg = new TypeError("The iterator does not provide a 'throw' method");
-          }
-
-          return ContinueSentinel;
-        }
-
-        var record = tryCatch(method, delegate.iterator, context.arg);
-        if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel;
-        var info = record.arg;
-        return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel);
-      }
-
-      function pushTryEntry(locs) {
-        var entry = {
-          tryLoc: locs[0]
-        };
-        1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);
-      }
-
-      function resetTryEntry(entry) {
-        var record = entry.completion || {};
-        record.type = "normal", delete record.arg, entry.completion = record;
-      }
-
-      function Context(tryLocsList) {
-        this.tryEntries = [{
-          tryLoc: "root"
-        }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);
-      }
-
-      function values(iterable) {
-        if (iterable) {
-          var iteratorMethod = iterable[iteratorSymbol];
-          if (iteratorMethod) return iteratorMethod.call(iterable);
-          if ("function" == typeof iterable.next) return iterable;
-
-          if (!isNaN(iterable.length)) {
-            var i = -1,
-                next = function next() {
-              for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;
-
-              return next.value = undefined, next.done = !0, next;
-            };
-
-            return next.next = next;
-          }
-        }
+      };
 
-        return {
-          next: doneResult
-        };
-      }
+      _proto.applyQuaternion = function applyQuaternion(q) {
+        var x = this.x,
+            y = this.y,
+            z = this.z;
+        var qx = q.x,
+            qy = q.y,
+            qz = q.z,
+            qw = q.w; // calculate quat * vector
 
-      function doneResult() {
-        return {
-          value: undefined,
-          done: !0
-        };
-      }
+        var ix = qw * x + qy * z - qz * y;
+        var iy = qw * y + qz * x - qx * z;
+        var iz = qw * z + qx * y - qy * x;
+        var iw = -qx * x - qy * y - qz * z; // calculate result * inverse quat
 
-      return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, "constructor", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) {
-        var ctor = "function" == typeof genFun && genFun.constructor;
-        return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name));
-      }, exports.mark = function (genFun) {
-        return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun;
-      }, exports.awrap = function (arg) {
-        return {
-          __await: arg
-        };
-      }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
-        return this;
-      }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
-        void 0 === PromiseImpl && (PromiseImpl = Promise);
-        var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
-        return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
-          return result.done ? result.value : iter.next();
-        });
-      }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () {
+        this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+        this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+        this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
         return this;
-      }), define(Gp, "toString", function () {
-        return "[object Generator]";
-      }), exports.keys = function (object) {
-        var keys = [];
-
-        for (var key in object) keys.push(key);
-
-        return keys.reverse(), function next() {
-          for (; keys.length;) {
-            var key = keys.pop();
-            if (key in object) return next.value = key, next.done = !1, next;
-          }
-
-          return next.done = !0, next;
-        };
-      }, exports.values = values, Context.prototype = {
-        constructor: Context,
-        reset: function (skipTempReset) {
-          if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);
-        },
-        stop: function () {
-          this.done = !0;
-          var rootRecord = this.tryEntries[0].completion;
-          if ("throw" === rootRecord.type) throw rootRecord.arg;
-          return this.rval;
-        },
-        dispatchException: function (exception) {
-          if (this.done) throw exception;
-          var context = this;
-
-          function handle(loc, caught) {
-            return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught;
-          }
-
-          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-            var entry = this.tryEntries[i],
-                record = entry.completion;
-            if ("root" === entry.tryLoc) return handle("end");
-
-            if (entry.tryLoc <= this.prev) {
-              var hasCatch = hasOwn.call(entry, "catchLoc"),
-                  hasFinally = hasOwn.call(entry, "finallyLoc");
-
-              if (hasCatch && hasFinally) {
-                if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
-                if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
-              } else if (hasCatch) {
-                if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);
-              } else {
-                if (!hasFinally) throw new Error("try statement without catch or finally");
-                if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);
-              }
-            }
-          }
-        },
-        abrupt: function (type, arg) {
-          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-            var entry = this.tryEntries[i];
-
-            if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
-              var finallyEntry = entry;
-              break;
-            }
-          }
-
-          finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);
-          var record = finallyEntry ? finallyEntry.completion : {};
-          return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);
-        },
-        complete: function (record, afterLoc) {
-          if ("throw" === record.type) throw record.arg;
-          return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;
-        },
-        finish: function (finallyLoc) {
-          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-            var entry = this.tryEntries[i];
-            if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;
-          }
-        },
-        catch: function (tryLoc) {
-          for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-            var entry = this.tryEntries[i];
-
-            if (entry.tryLoc === tryLoc) {
-              var record = entry.completion;
-
-              if ("throw" === record.type) {
-                var thrown = record.arg;
-                resetTryEntry(entry);
-              }
-
-              return thrown;
-            }
-          }
-
-          throw new Error("illegal catch attempt");
-        },
-        delegateYield: function (iterable, resultName, nextLoc) {
-          return this.delegate = {
-            iterator: values(iterable),
-            resultName: resultName,
-            nextLoc: nextLoc
-          }, "next" === this.method && (this.arg = undefined), ContinueSentinel;
-        }
-      }, exports;
-    }
-
-    function _defineProperties(target, props) {
-      for (var i = 0; i < props.length; i++) {
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-      }
-    }
+      } // project(camera) {
+      //     return this.applyMatrix4(camera.matrixWorldInverse).applyMatrix4(camera.projectionMatrix);
+      // }
+      // unproject(camera) {
+      //     return this.applyMatrix4(camera.projectionMatrixInverse).applyMatrix4(camera.matrixWorld);
+      // }
+      // transformDirection(m) {
+      //     // input: THREE.Matrix4 affine matrix
+      //     // vector interpreted as a direction
+      //     const x = this.x, y = this.y, z = this.z;
+      //     const e = m.elements;
+      //     this.x = e[0] * x + e[4] * y + e[8] * z;
+      //     this.y = e[1] * x + e[5] * y + e[9] * z;
+      //     this.z = e[2] * x + e[6] * y + e[10] * z;
+      //     return this.normalize();
+      // }
+      ;
 
-    function _createClass(Constructor, protoProps, staticProps) {
-      if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-      if (staticProps) _defineProperties(Constructor, staticProps);
-      Object.defineProperty(Constructor, "prototype", {
-        writable: false
-      });
-      return Constructor;
-    }
+      _proto.divide = function divide(v) {
+        this.x /= v.x;
+        this.y /= v.y;
+        this.z /= v.z;
+        return this;
+      };
 
-    function _inheritsLoose(subClass, superClass) {
-      subClass.prototype = Object.create(superClass.prototype);
-      subClass.prototype.constructor = subClass;
+      _proto.divideScalar = function divideScalar(scalar) {
+        return this.multiplyScalar(1 / scalar);
+      };
 
-      _setPrototypeOf(subClass, superClass);
-    }
+      _proto.min = function min(v) {
+        this.x = Math.min(this.x, v.x);
+        this.y = Math.min(this.y, v.y);
+        this.z = Math.min(this.z, v.z);
+        return this;
+      };
 
-    function _setPrototypeOf(o, p) {
-      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
-        o.__proto__ = p;
-        return o;
+      _proto.max = function max(v) {
+        this.x = Math.max(this.x, v.x);
+        this.y = Math.max(this.y, v.y);
+        this.z = Math.max(this.z, v.z);
+        return this;
       };
-      return _setPrototypeOf(o, p);
-    }
 
-    // code copy from https://github.com/mrdoob/three.js/blob/dev/src/math/Quaternion.js
-    // import { clamp } from './MathUtils.js';
-    var Quaternion = /*#__PURE__*/function (_Symbol$iterator) {
-      function Quaternion(x, y, z, w) {
-        if (x === void 0) {
-          x = 0;
-        }
+      _proto.clamp = function clamp(min, max) {
+        // assumes min < max, componentwise
+        this.x = Math.max(min.x, Math.min(max.x, this.x));
+        this.y = Math.max(min.y, Math.min(max.y, this.y));
+        this.z = Math.max(min.z, Math.min(max.z, this.z));
+        return this;
+      };
 
-        if (y === void 0) {
-          y = 0;
-        }
+      _proto.clampScalar = function clampScalar(minVal, maxVal) {
+        this.x = Math.max(minVal, Math.min(maxVal, this.x));
+        this.y = Math.max(minVal, Math.min(maxVal, this.y));
+        this.z = Math.max(minVal, Math.min(maxVal, this.z));
+        return this;
+      };
 
-        if (z === void 0) {
-          z = 0;
-        }
+      _proto.clampLength = function clampLength(min, max) {
+        var length = this.length();
+        return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
+      } // floor() {
+      //     this.x = Math.floor(this.x);
+      //     this.y = Math.floor(this.y);
+      //     this.z = Math.floor(this.z);
+      //     return this;
+      // }
+      // ceil() {
+      //     this.x = Math.ceil(this.x);
+      //     this.y = Math.ceil(this.y);
+      //     this.z = Math.ceil(this.z);
+      //     return this;
+      // }
+      // round() {
+      //     this.x = Math.round(this.x);
+      //     this.y = Math.round(this.y);
+      //     this.z = Math.round(this.z);
+      //     return this;
+      // }
+      // roundToZero() {
+      //     this.x = (this.x < 0) ? Math.ceil(this.x) : Math.floor(this.x);
+      //     this.y = (this.y < 0) ? Math.ceil(this.y) : Math.floor(this.y);
+      //     this.z = (this.z < 0) ? Math.ceil(this.z) : Math.floor(this.z);
+      //     return this;
+      // }
+      // negate() {
+      //     this.x = -this.x;
+      //     this.y = -this.y;
+      //     this.z = -this.z;
+      //     return this;
+      // }
+      ;
 
-        if (w === void 0) {
-          w = 1;
-        }
+      _proto.dot = function dot(v) {
+        return this.x * v.x + this.y * v.y + this.z * v.z;
+      } // TODO lengthSquared?
+      ;
 
-        this.isQuaternion = true;
-        this._x = x;
-        this._y = y;
-        this._z = z;
-        this._w = w;
-      }
+      _proto.lengthSq = function lengthSq() {
+        return this.x * this.x + this.y * this.y + this.z * this.z;
+      };
 
-      Quaternion.slerpFlat = function slerpFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
-        // fuzz-free, array-based Quaternion SLERP operation
-        var x0 = src0[srcOffset0 + 0],
-            y0 = src0[srcOffset0 + 1],
-            z0 = src0[srcOffset0 + 2],
-            w0 = src0[srcOffset0 + 3];
-        var x1 = src1[srcOffset1 + 0],
-            y1 = src1[srcOffset1 + 1],
-            z1 = src1[srcOffset1 + 2],
-            w1 = src1[srcOffset1 + 3];
+      _proto.length = function length() {
+        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
+      } // manhattanLength() {
+      //     return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z);
+      // }
+      ;
 
-        if (t === 0) {
-          dst[dstOffset + 0] = x0;
-          dst[dstOffset + 1] = y0;
-          dst[dstOffset + 2] = z0;
-          dst[dstOffset + 3] = w0;
-          return;
-        }
+      _proto.normalize = function normalize() {
+        return this.divideScalar(this.length() || 1);
+      };
 
-        if (t === 1) {
-          dst[dstOffset + 0] = x1;
-          dst[dstOffset + 1] = y1;
-          dst[dstOffset + 2] = z1;
-          dst[dstOffset + 3] = w1;
-          return;
-        }
+      _proto.setLength = function setLength(length) {
+        return this.normalize().multiplyScalar(length);
+      };
 
-        if (w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1) {
-          var s = 1 - t;
-          var cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
-              dir = cos >= 0 ? 1 : -1,
-              sqrSin = 1 - cos * cos; // Skip the Slerp for tiny steps to avoid numeric problems:
+      _proto.lerp = function lerp(v, alpha) {
+        this.x += (v.x - this.x) * alpha;
+        this.y += (v.y - this.y) * alpha;
+        this.z += (v.z - this.z) * alpha;
+        return this;
+      };
 
-          if (sqrSin > Number.EPSILON) {
-            var sin = Math.sqrt(sqrSin),
-                len = Math.atan2(sin, cos * dir);
-            s = Math.sin(s * len) / sin;
-            t = Math.sin(t * len) / sin;
-          }
+      _proto.lerpVectors = function lerpVectors(v1, v2, alpha) {
+        this.x = v1.x + (v2.x - v1.x) * alpha;
+        this.y = v1.y + (v2.y - v1.y) * alpha;
+        this.z = v1.z + (v2.z - v1.z) * alpha;
+        return this;
+      };
 
-          var tDir = t * dir;
-          x0 = x0 * s + x1 * tDir;
-          y0 = y0 * s + y1 * tDir;
-          z0 = z0 * s + z1 * tDir;
-          w0 = w0 * s + w1 * tDir; // Normalize in case we just did a lerp:
+      _proto.cross = function cross(v) {
+        return this.crossVectors(this, v);
+      };
 
-          if (s === 1 - t) {
-            var f = 1 / Math.sqrt(x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0);
-            x0 *= f;
-            y0 *= f;
-            z0 *= f;
-            w0 *= f;
-          }
-        }
+      _proto.crossVectors = function crossVectors(a, b) {
+        var ax = a.x,
+            ay = a.y,
+            az = a.z;
+        var bx = b.x,
+            by = b.y,
+            bz = b.z;
+        this.x = ay * bz - az * by;
+        this.y = az * bx - ax * bz;
+        this.z = ax * by - ay * bx;
+        return this;
+      } // projectOnVector(v) {
+      //     const denominator = v.lengthSq();
+      //     if (denominator === 0) return this.set(0, 0, 0);
+      //     const scalar = v.dot(this) / denominator;
+      //     return this.copy(v).multiplyScalar(scalar);
+      // }
+      // projectOnPlane(planeNormal) {
+      //     _vector.copy(this).projectOnVector(planeNormal);
+      //     return this.sub(_vector);
+      // }
+      // reflect(normal) {
+      //     // reflect incident vector off plane orthogonal to normal
+      //     // normal is assumed to have unit length
+      //     return this.sub(_vector.copy(normal).multiplyScalar(2 * this.dot(normal)));
+      // }
+      // angleTo(v) {
+      //     const denominator = Math.sqrt(this.lengthSq() * v.lengthSq());
+      //     if (denominator === 0) return Math.PI / 2;
+      //     const theta = this.dot(v) / denominator;
+      //     // clamp, to handle numerical problems
+      //     return Math.acos(MathUtils.clamp(theta, -1, 1));
+      // }
+      ;
 
-        dst[dstOffset] = x0;
-        dst[dstOffset + 1] = y0;
-        dst[dstOffset + 2] = z0;
-        dst[dstOffset + 3] = w0;
-      };
+      _proto.distanceTo = function distanceTo(v) {
+        return Math.sqrt(this.distanceToSquared(v));
+      } // distanceToSquared(v) {
+      //     const dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
+      //     return dx * dx + dy * dy + dz * dz;
+      // }
+      // manhattanDistanceTo(v) {
+      //     return Math.abs(this.x - v.x) + Math.abs(this.y - v.y) + Math.abs(this.z - v.z);
+      // }
+      // setFromSpherical(s) {
+      //     return this.setFromSphericalCoords(s.radius, s.phi, s.theta);
+      // }
+      // setFromSphericalCoords(radius, phi, theta) {
+      //     const sinPhiRadius = Math.sin(phi) * radius;
+      //     this.x = sinPhiRadius * Math.sin(theta);
+      //     this.y = Math.cos(phi) * radius;
+      //     this.z = sinPhiRadius * Math.cos(theta);
+      //     return this;
+      // }
+      // setFromCylindrical(c) {
+      //     return this.setFromCylindricalCoords(c.radius, c.theta, c.y);
+      // }
+      // setFromCylindricalCoords(radius, theta, y) {
+      //     this.x = radius * Math.sin(theta);
+      //     this.y = y;
+      //     this.z = radius * Math.cos(theta);
+      //     return this;
+      // }
+      // setFromMatrixPosition(m) {
+      //     const e = m.elements;
+      //     this.x = e[12];
+      //     this.y = e[13];
+      //     this.z = e[14];
+      //     return this;
+      // }
+      // setFromMatrixScale(m) {
+      //     const sx = this.setFromMatrixColumn(m, 0).length();
+      //     const sy = this.setFromMatrixColumn(m, 1).length();
+      //     const sz = this.setFromMatrixColumn(m, 2).length();
+      //     this.x = sx;
+      //     this.y = sy;
+      //     this.z = sz;
+      //     return this;
+      // }
+      // setFromMatrixColumn(m, index) {
+      //     return this.fromArray(m.elements, index * 4);
+      // }
+      // setFromMatrix3Column(m, index) {
+      //     return this.fromArray(m.elements, index * 3);
+      // }
+      // setFromEuler(e) {
+      //     this.x = e._x;
+      //     this.y = e._y;
+      //     this.z = e._z;
+      //     return this;
+      // }
+      // setFromColor(c) {
+      //     this.x = c.r;
+      //     this.y = c.g;
+      //     this.z = c.b;
+      //     return this;
+      // }
+      ;
 
-      Quaternion.multiplyQuaternionsFlat = function multiplyQuaternionsFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1) {
-        var x0 = src0[srcOffset0];
-        var y0 = src0[srcOffset0 + 1];
-        var z0 = src0[srcOffset0 + 2];
-        var w0 = src0[srcOffset0 + 3];
-        var x1 = src1[srcOffset1];
-        var y1 = src1[srcOffset1 + 1];
-        var z1 = src1[srcOffset1 + 2];
-        var w1 = src1[srcOffset1 + 3];
-        dst[dstOffset] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
-        dst[dstOffset + 1] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
-        dst[dstOffset + 2] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
-        dst[dstOffset + 3] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
-        return dst;
+      _proto.equals = function equals(v) {
+        return v.x === this.x && v.y === this.y && v.z === this.z;
       };
 
-      var _proto = Quaternion.prototype;
-
-      _proto.set = function set(x, y, z, w) {
-        this._x = x;
-        this._y = y;
-        this._z = z;
-        this._w = w;
+      _proto.fromArray = function fromArray(array, offset) {
+        if (offset === void 0) {
+          offset = 0;
+        }
 
-        this._onChangeCallback();
+        this.x = array[offset];
+        this.y = array[offset + 1];
+        this.z = array[offset + 2];
+        return this;
+      } // toArray(array = [], offset = 0) {
+      //     array[offset] = this.x;
+      //     array[offset + 1] = this.y;
+      //     array[offset + 2] = this.z;
+      //     return array;
+      // }
+      // fromBufferAttribute(attribute, index) {
+      //     this.x = attribute.getX(index);
+      //     this.y = attribute.getY(index);
+      //     this.z = attribute.getZ(index);
+      //     return this;
+      // }
+      ;
 
+      _proto.random = function random() {
+        this.x = Math.random();
+        this.y = Math.random();
+        this.z = Math.random();
         return this;
-      };
+      } // randomDirection() {
+      //     // Derived from https://mathworld.wolfram.com/SpherePointPicking.html
+      //     const u = (Math.random() - 0.5) * 2;
+      //     const t = Math.random() * Math.PI * 2;
+      //     const f = Math.sqrt(1 - u ** 2);
+      //     this.x = f * Math.cos(t);
+      //     this.y = f * Math.sin(t);
+      //     this.z = u;
+      //     return this;
+      // }
+      ;
 
-      _proto.clone = function clone() {
-        return new this.constructor(this._x, this._y, this._z, this._w);
-      };
+      return Vector3;
+    }();
 
-      _proto.copy = function copy(quaternion) {
-        this._x = quaternion.x;
-        this._y = quaternion.y;
-        this._z = quaternion.z;
-        this._w = quaternion.w;
+    /**
+     * https://github.com/Turfjs/turf/blob/master/packages/turf-boolean-clockwise/index.ts
+     * @param {*} ring
+     * @returns
+     */
 
-        this._onChangeCallback();
+    function isClockwise(ring) {
+      var sum = 0;
+      var i = 1;
+      var prev;
+      var cur;
+      var len = ring.length;
 
-        return this;
-      };
+      while (i < len) {
+        prev = cur || ring[0];
+        cur = ring[i];
+        sum += (cur[0] - prev[0]) * (cur[1] + prev[1]);
+        i++;
+      }
 
-      _proto.setFromEuler = function setFromEuler(euler, update) {
-        if (update === void 0) {
-          update = true;
-        }
+      return sum > 0;
+    }
 
-        var x = euler._x,
-            y = euler._y,
-            z = euler._z,
-            order = euler._order; // http://www.mathworks.com/matlabcentral/fileexchange/
-        // 20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
-        // content/SpinCalc.m
+    function v3Sub(out, v1, v2) {
+      out[0] = v1[0] - v2[0];
+      out[1] = v1[1] - v2[1];
+      out[2] = v1[2] - v2[2];
+      return out;
+    }
 
-        var cos = Math.cos;
-        var sin = Math.sin;
-        var c1 = cos(x / 2);
-        var c2 = cos(y / 2);
-        var c3 = cos(z / 2);
-        var s1 = sin(x / 2);
-        var s2 = sin(y / 2);
-        var s3 = sin(z / 2);
+    function v3Normalize(out, v) {
+      var x = v[0];
+      var y = v[1];
+      var z = v[2];
+      var d = Math.sqrt(x * x + y * y + z * z) || 1;
+      out[0] = x / d;
+      out[1] = y / d;
+      out[2] = z / d;
+      return out;
+    }
 
-        switch (order) {
-          case 'XYZ':
-            this._x = s1 * c2 * c3 + c1 * s2 * s3;
-            this._y = c1 * s2 * c3 - s1 * c2 * s3;
-            this._z = c1 * c2 * s3 + s1 * s2 * c3;
-            this._w = c1 * c2 * c3 - s1 * s2 * s3;
-            break;
+    function v3Cross(out, v1, v2) {
+      var ax = v1[0],
+          ay = v1[1],
+          az = v1[2],
+          bx = v2[0],
+          by = v2[1],
+          bz = v2[2];
+      out[0] = ay * bz - az * by;
+      out[1] = az * bx - ax * bz;
+      out[2] = ax * by - ay * bx;
+      return out;
+    }
 
-          case 'YXZ':
-            this._x = s1 * c2 * c3 + c1 * s2 * s3;
-            this._y = c1 * s2 * c3 - s1 * c2 * s3;
-            this._z = c1 * c2 * s3 - s1 * s2 * c3;
-            this._w = c1 * c2 * c3 + s1 * s2 * s3;
-            break;
+    function generateNormal(indices, position) {
+      function v3Set(p, a, b, c) {
+        p[0] = a;
+        p[1] = b;
+        p[2] = c;
+      }
 
-          case 'ZXY':
-            this._x = s1 * c2 * c3 - c1 * s2 * s3;
-            this._y = c1 * s2 * c3 + s1 * c2 * s3;
-            this._z = c1 * c2 * s3 + s1 * s2 * c3;
-            this._w = c1 * c2 * c3 - s1 * s2 * s3;
-            break;
+      var p1 = [];
+      var p2 = [];
+      var p3 = [];
+      var v21 = [];
+      var v32 = [];
+      var n = [];
+      var len = indices.length;
+      var normals = new Float32Array(position.length);
+      var f = 0;
 
-          case 'ZYX':
-            this._x = s1 * c2 * c3 - c1 * s2 * s3;
-            this._y = c1 * s2 * c3 + s1 * c2 * s3;
-            this._z = c1 * c2 * s3 - s1 * s2 * c3;
-            this._w = c1 * c2 * c3 + s1 * s2 * s3;
-            break;
+      while (f < len) {
+        // const i1 = indices[f++] * 3;
+        // const i2 = indices[f++] * 3;
+        // const i3 = indices[f++] * 3;
+        // const i1 = indices[f];
+        // const i2 = indices[f + 1];
+        // const i3 = indices[f + 2];
+        var a = indices[f],
+            b = indices[f + 1],
+            c = indices[f + 2];
+        var i1 = a * 3,
+            i2 = b * 3,
+            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]);
+        v3Sub(v32, p3, p2);
+        v3Sub(v21, p1, p2);
+        v3Cross(n, v32, v21); // Already be weighted by the triangle area
 
-          case 'YZX':
-            this._x = s1 * c2 * c3 + c1 * s2 * s3;
-            this._y = c1 * s2 * c3 + s1 * c2 * s3;
-            this._z = c1 * c2 * s3 - s1 * s2 * c3;
-            this._w = c1 * c2 * c3 - s1 * s2 * s3;
-            break;
+        for (var _i = 0; _i < 3; _i++) {
+          normals[i1 + _i] += n[_i];
+          normals[i2 + _i] += n[_i];
+          normals[i3 + _i] += n[_i];
+        }
 
-          case 'XZY':
-            this._x = s1 * c2 * c3 - c1 * s2 * s3;
-            this._y = c1 * s2 * c3 - s1 * c2 * s3;
-            this._z = c1 * c2 * s3 + s1 * s2 * c3;
-            this._w = c1 * c2 * c3 + s1 * s2 * s3;
-            break;
+        f += 3;
+      }
 
-          default:
-            console.warn('THREE.Quaternion: .setFromEuler() encountered an unknown order: ' + order);
-        }
+      var i = 0;
+      var l = normals.length;
 
-        if (update === true) this._onChangeCallback();
-        return this;
-      };
+      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;
+        i += 3;
+      }
 
-      _proto.setFromAxisAngle = function setFromAxisAngle(axis, angle) {
-        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
-        // assumes axis is normalized
-        var halfAngle = angle / 2,
-            s = Math.sin(halfAngle);
-        this._x = axis.x * s;
-        this._y = axis.y * s;
-        this._z = axis.z * s;
-        this._w = Math.cos(halfAngle);
+      return normals;
+    }
+    function merge(results) {
+      if (results.length === 1) {
+        var _result = {
+          position: results[0].position,
+          normal: results[0].normal,
+          uv: results[0].uv,
+          indices: results[0].indices,
+          results: results
+        };
+        return _result;
+      }
 
-        this._onChangeCallback();
+      var plen = 0,
+          ilen = 0;
 
-        return this;
+      for (var i = 0, len = results.length; i < len; i++) {
+        var _results$i = results[i],
+            position = _results$i.position,
+            indices = _results$i.indices;
+        plen += position.length;
+        ilen += indices.length;
+      }
+
+      var result = {
+        position: new Float32Array(plen),
+        normal: new Float32Array(plen),
+        uv: new Float32Array(plen / 3 * 2),
+        indices: new Uint32Array(ilen),
+        results: results
       };
+      var pOffset = 0,
+          pCount = 0,
+          iIdx = 0,
+          uvOffset = 0;
 
-      _proto.setFromRotationMatrix = function setFromRotationMatrix(m) {
-        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
-        // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
-        var te = m.elements,
-            m11 = te[0],
-            m12 = te[4],
-            m13 = te[8],
-            m21 = te[1],
-            m22 = te[5],
-            m23 = te[9],
-            m31 = te[2],
-            m32 = te[6],
-            m33 = te[10],
-            trace = m11 + m22 + m33;
+      for (var _i2 = 0, _len = results.length; _i2 < _len; _i2++) {
+        var _results$_i = results[_i2],
+            _position = _results$_i.position,
+            _indices = _results$_i.indices,
+            normal = _results$_i.normal,
+            uv = _results$_i.uv;
+        result.position.set(_position, pOffset);
+        result.normal.set(normal, pOffset);
+        result.uv.set(uv, uvOffset);
+        var j = 0;
+        var len1 = _indices.length;
 
-        if (trace > 0) {
-          var s = 0.5 / Math.sqrt(trace + 1.0);
-          this._w = 0.25 / s;
-          this._x = (m32 - m23) * s;
-          this._y = (m13 - m31) * s;
-          this._z = (m21 - m12) * s;
-        } else if (m11 > m22 && m11 > m33) {
-          var _s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);
+        while (j < len1) {
+          var pIndex = _indices[j] + pCount;
+          result.indices[iIdx] = pIndex;
+          iIdx++;
+          j++;
+        }
 
-          this._w = (m32 - m23) / _s;
-          this._x = 0.25 * _s;
-          this._y = (m12 + m21) / _s;
-          this._z = (m13 + m31) / _s;
-        } else if (m22 > m33) {
-          var _s2 = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);
+        uvOffset += uv.length;
+        pOffset += _position.length;
+        pCount += _position.length / 3;
+      }
 
-          this._w = (m13 - m31) / _s2;
-          this._x = (m12 + m21) / _s2;
-          this._y = 0.25 * _s2;
-          this._z = (m23 + m32) / _s2;
-        } else {
-          var _s3 = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);
+      return result;
+    }
+    function radToDeg(rad) {
+      return rad * 180 / Math.PI;
+    }
+    function degToRad(angle) {
+      return angle / 180 * Math.PI;
+    } // https://github.com/mrdoob/three.js/blob/16f13e3b07e31d0e9a00df7c3366bbe0e464588c/src/geometries/ExtrudeGeometry.js?_pjax=%23js-repo-pjax-container#L736
 
-          this._w = (m21 - m12) / _s3;
-          this._x = (m13 + m31) / _s3;
-          this._y = (m23 + m32) / _s3;
-          this._z = 0.25 * _s3;
-        }
+    function generateSideWallUV(uvs, vertices, indexA, indexB, indexC, indexD) {
+      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];
+      var uIndex = uvs.length - 1;
 
-        this._onChangeCallback();
+      if (Math.abs(a_y - b_y) < Math.abs(a_x - b_x)) {
+        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[++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);
+      }
+    }
+    function line2Vectors(line) {
+      var points = [];
 
-        return this;
-      };
+      for (var i = 0, len = line.length; i < len; i++) {
+        var p = line[i];
+        var x = p[0],
+            y = p[1],
+            z = p[2];
+        var v = new Vector3(x, y, z || 0);
+        points[i] = v;
+      }
 
-      _proto.setFromUnitVectors = function setFromUnitVectors(vFrom, vTo) {
-        // assumes direction vectors vFrom and vTo are normalized
-        var r = vFrom.dot(vTo) + 1;
+      return points;
+    }
 
-        if (r < Number.EPSILON) {
-          // vFrom and vTo point in opposite directions
-          r = 0;
+    function extrudePolygons(polygons, options) {
+      options = Object.assign({}, {
+        depth: 2
+      }, options);
+      var results = polygons.map(function (polygon) {
+        for (var i = 0, len = polygon.length; i < len; i++) {
+          var ring = polygon[i];
+          validateRing(ring);
 
-          if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
-            this._x = -vFrom.y;
-            this._y = vFrom.x;
-            this._z = 0;
-            this._w = r;
-          } else {
-            this._x = 0;
-            this._y = -vFrom.z;
-            this._z = vFrom.y;
-            this._w = r;
+          if (i === 0) {
+            if (!isClockwise(ring)) {
+              polygon[i] = ring.reverse();
+            }
+          } else if (isClockwise(ring)) {
+            polygon[i] = ring.reverse();
+          }
+
+          if (isClosedRing(ring)) {
+            ring.splice(ring.length - 1, 1);
           }
-        } else {
-          // crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3
-          this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
-          this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
-          this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
-          this._w = r;
         }
 
-        return this.normalize();
-      } // angleTo(q) {
-      //     return 2 * Math.acos(Math.abs(clamp(this.dot(q), -1, 1)));
-      // }
-      ;
+        var result = flatVertices(polygon, options);
+        result.polygon = polygon;
+        var triangles = earcut$1(result.flatVertices, result.holes, 2);
+        generateTopAndBottom$1(result, triangles);
+        generateSides$1(result, options);
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
+        result.normal = generateNormal(result.indices, result.position);
+        return result;
+      });
+      var result = merge(results);
+      result.polygons = polygons;
+      return result;
+    }
 
-      _proto.rotateTowards = function rotateTowards(q, step) {
-        var angle = this.angleTo(q);
-        if (angle === 0) return this;
-        var t = Math.min(1, step / angle);
-        this.slerp(q, t);
-        return this;
-      };
+    function generateTopAndBottom$1(result, triangles) {
+      var indices = [];
+      var count = result.count;
 
-      _proto.identity = function identity() {
-        return this.set(0, 0, 0, 1);
-      };
+      for (var i = 0, len = triangles.length; i < len; i += 3) {
+        // top
+        var a = triangles[i],
+            b = triangles[i + 1],
+            c = triangles[i + 2];
+        indices[i] = a;
+        indices[i + 1] = b;
+        indices[i + 2] = c; // bottom
 
-      _proto.invert = function invert() {
-        // quaternion is assumed to have unit length
-        return this.conjugate();
-      };
+        var idx = len + i;
+        var a1 = count + a,
+            b1 = count + b,
+            c1 = count + c;
+        indices[idx] = a1;
+        indices[idx + 1] = b1;
+        indices[idx + 2] = c1;
+      }
 
-      _proto.conjugate = function conjugate() {
-        this._x *= -1;
-        this._y *= -1;
-        this._z *= -1;
+      result.indices = indices;
+    }
 
-        this._onChangeCallback();
+    function generateSides$1(result, options) {
+      var points = result.points,
+          indices = result.indices,
+          polygon = result.polygon,
+          uv = result.uv;
+      var depth = options.depth;
+      var pIndex = points.length - 1;
+      var iIndex = indices.length - 1;
+
+      for (var i = 0, len = polygon.length; i < len; i++) {
+        var ring = polygon[i];
+        var j = 0;
+        var len1 = ring.length;
 
-        return this;
-      };
+        while (j < len1) {
+          var v1 = ring[j];
+          var v2 = ring[j + 1];
 
-      _proto.dot = function dot(v) {
-        return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
-      };
+          if (j === len1 - 1) {
+            v2 = ring[0];
+          }
 
-      _proto.lengthSq = function lengthSq() {
-        return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
-      };
+          var idx = points.length / 3;
+          var x1 = v1[0],
+              y1 = v1[1],
+              z1 = v1[2] || 0,
+              x2 = v2[0],
+              y2 = v2[1],
+              z2 = v2[2] || 0;
+          points[++pIndex] = x1;
+          points[++pIndex] = y1;
+          points[++pIndex] = z1 + depth;
+          points[++pIndex] = x2;
+          points[++pIndex] = y2;
+          points[++pIndex] = z2 + depth;
+          points[++pIndex] = x1;
+          points[++pIndex] = y1;
+          points[++pIndex] = z1;
+          points[++pIndex] = x2;
+          points[++pIndex] = y2;
+          points[++pIndex] = z2; // points.push(x1, y1, z, x2, y2, z, x1, y1, 0, x2, y2, 0);
 
-      _proto.length = function length() {
-        return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w);
-      };
+          var a = idx + 2,
+              b = idx + 3,
+              c = idx,
+              d = idx + 1; // points.push(p3, p4, p1, p2);
+          // index.push(a, c, b, c, d, b);
 
-      _proto.normalize = function normalize() {
-        var l = this.length();
+          indices[++iIndex] = a;
+          indices[++iIndex] = c;
+          indices[++iIndex] = b;
+          indices[++iIndex] = c;
+          indices[++iIndex] = d;
+          indices[++iIndex] = b; // index.push(c, d, b);
 
-        if (l === 0) {
-          this._x = 0;
-          this._y = 0;
-          this._z = 0;
-          this._w = 1;
-        } else {
-          l = 1 / l;
-          this._x = this._x * l;
-          this._y = this._y * l;
-          this._z = this._z * l;
-          this._w = this._w * l;
+          generateSideWallUV(uv, points, a, b, c, d);
+          j++;
         }
+      }
+    }
 
-        this._onChangeCallback();
-
-        return this;
-      };
+    function calPolygonPointsCount(polygon) {
+      var count = 0;
+      var i = 0;
+      var len = polygon.length;
 
-      _proto.multiply = function multiply(q) {
-        return this.multiplyQuaternions(this, q);
-      };
+      while (i < len) {
+        count += polygon[i].length;
+        i++;
+      }
 
-      _proto.premultiply = function premultiply(q) {
-        return this.multiplyQuaternions(q, this);
-      };
+      return count;
+    }
 
-      _proto.multiplyQuaternions = function multiplyQuaternions(a, b) {
-        // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
-        var qax = a._x,
-            qay = a._y,
-            qaz = a._z,
-            qaw = a._w;
-        var qbx = b._x,
-            qby = b._y,
-            qbz = b._z,
-            qbw = b._w;
-        this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
-        this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
-        this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
-        this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
+    function flatVertices(polygon, options) {
+      var count = calPolygonPointsCount(polygon);
+      var len = polygon.length;
+      var holes = [],
+          flatVertices = new Float32Array(count * 2),
+          points = [],
+          uv = [];
+      var pOffset = count * 3,
+          uOffset = count * 2;
+      var depth = options.depth;
+      var idx0 = 0,
+          idx1 = 0,
+          idx2 = 0;
 
-        this._onChangeCallback();
+      for (var i = 0; i < len; i++) {
+        var ring = polygon[i];
 
-        return this;
-      };
+        if (i > 0) {
+          holes.push(idx0 / 2);
+        }
 
-      _proto.slerp = function slerp(qb, t) {
-        if (t === 0) return this;
-        if (t === 1) return this.copy(qb);
-        var x = this._x,
-            y = this._y,
-            z = this._z,
-            w = this._w; // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
+        var j = 0;
+        var len1 = ring.length;
 
-        var cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
+        while (j < len1) {
+          var c = ring[j];
+          var x = c[0],
+              y = c[1],
+              z = c[2] || 0;
+          flatVertices[idx0++] = x;
+          flatVertices[idx0++] = y; // top vertices
 
-        if (cosHalfTheta < 0) {
-          this._w = -qb._w;
-          this._x = -qb._x;
-          this._y = -qb._y;
-          this._z = -qb._z;
-          cosHalfTheta = -cosHalfTheta;
-        } else {
-          this.copy(qb);
-        }
+          points[idx1] = x;
+          points[idx1 + 1] = y;
+          points[idx1 + 2] = depth + z; // bottom vertices
 
-        if (cosHalfTheta >= 1.0) {
-          this._w = w;
-          this._x = x;
-          this._y = y;
-          this._z = z;
-          return this;
+          points[pOffset + idx1] = x;
+          points[pOffset + idx1 + 1] = y;
+          points[pOffset + idx1 + 2] = z;
+          uv[idx2] = x;
+          uv[idx2 + 1] = y;
+          uv[uOffset + idx2] = x;
+          uv[uOffset + idx2 + 1] = y;
+          idx1 += 3;
+          idx2 += 2;
+          j++;
         }
+      }
 
-        var sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
+      return {
+        flatVertices: flatVertices,
+        holes: holes,
+        points: points,
+        count: count,
+        uv: uv
+      };
+    }
 
-        if (sqrSinHalfTheta <= Number.EPSILON) {
-          var s = 1 - t;
-          this._w = s * w + t * this._w;
-          this._x = s * x + t * this._x;
-          this._y = s * y + t * this._y;
-          this._z = s * z + t * this._z;
-          this.normalize(); // normalize calls _onChangeCallback()
+    function validateRing(ring) {
+      if (!isClosedRing(ring)) {
+        ring.push(ring[0]);
+      }
+    }
 
-          return this;
-        }
+    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;
+    }
 
-        var sinHalfTheta = Math.sqrt(sqrSinHalfTheta);
-        var halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta);
-        var ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta,
-            ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
-        this._w = w * ratioA + this._w * ratioB;
-        this._x = x * ratioA + this._x * ratioB;
-        this._y = y * ratioA + this._y * ratioB;
-        this._z = z * ratioA + this._z * ratioB;
+    function checkOptions(options) {
+      options.lineWidth = Math.max(0, options.lineWidth);
+      options.depth = Math.max(0, options.depth);
+      options.sideDepth = Math.max(0, options.sideDepth);
+    }
 
-        this._onChangeCallback();
+    function extrudePolylines(lines, options) {
+      options = Object.assign({}, {
+        depth: 2,
+        lineWidth: 1,
+        bottomStickGround: false
+      }, options);
+      checkOptions(options);
+      var results = lines.map(function (line) {
+        var result = expandLine(line, options);
+        result.line = line;
+        generateTopAndBottom(result, options);
+        generateSides(result, options);
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
+        result.normal = generateNormal(result.indices, result.position);
+        return result;
+      });
+      var result = merge(results);
+      result.lines = lines;
+      return result;
+    }
+    function extrudeSlopes(lines, options) {
+      options = Object.assign({}, {
+        depth: 2,
+        lineWidth: 1,
+        side: 'left',
+        sideDepth: 0,
+        bottomStickGround: false
+      }, options);
+      checkOptions(options);
+      var _options = options,
+          depth = _options.depth,
+          side = _options.side,
+          sideDepth = _options.sideDepth;
+      var results = lines.map(function (line) {
+        var tempResult = expandLine(line, options);
+        tempResult.line = line;
+        var leftPoints = tempResult.leftPoints,
+            rightPoints = tempResult.rightPoints;
+        var result = {
+          line: line
+        };
+        var depths;
 
-        return this;
-      };
+        for (var i = 0, len = line.length; i < len; i++) {
+          line[i][2] = line[i][2] || 0;
+        }
 
-      _proto.slerpQuaternions = function slerpQuaternions(qa, qb, t) {
-        return this.copy(qa).slerp(qb, t);
-      };
+        if (side === 'left') {
+          result.leftPoints = leftPoints;
+          result.rightPoints = line;
+          depths = [sideDepth, depth];
+        } else {
+          result.leftPoints = line;
+          result.rightPoints = rightPoints;
+          depths = [depth, sideDepth];
+        }
 
-      _proto.random = function random() {
-        // sets this quaternion to a uniform random unit quaternnion
-        // Ken Shoemake
-        // Uniform random rotations
-        // D. Kirk, editor, Graphics Gems III, pages 124-132. Academic Press, New York, 1992.
-        var theta1 = 2 * Math.PI * Math.random();
-        var theta2 = 2 * Math.PI * Math.random();
-        var x0 = Math.random();
-        var r1 = Math.sqrt(1 - x0);
-        var r2 = Math.sqrt(x0);
-        return this.set(r1 * Math.sin(theta1), r1 * Math.cos(theta1), r2 * Math.sin(theta2), r2 * Math.cos(theta2));
-      };
+        result.depths = depths;
+        generateTopAndBottom(result, options);
+        generateSides(result, options);
+        result.position = new Float32Array(result.points);
+        result.indices = new Uint32Array(result.indices);
+        result.uv = new Float32Array(result.uv);
+        result.normal = generateNormal(result.indices, result.position);
+        return result;
+      });
+      var result = merge(results);
+      result.lines = lines;
+      return result;
+    }
 
-      _proto.equals = function equals(quaternion) {
-        return quaternion._x === this._x && quaternion._y === this._y && quaternion._z === this._z && quaternion._w === this._w;
-      };
+    function generateTopAndBottom(result, options) {
+      var bottomStickGround = options.bottomStickGround;
+      var z = options.depth;
+      var depths = result.depths;
+      var lz = z,
+          rz = z;
 
-      _proto.fromArray = function fromArray(array, offset) {
-        if (offset === void 0) {
-          offset = 0;
-        }
+      if (depths) {
+        lz = depths[0];
+        rz = depths[1];
+      }
 
-        this._x = array[offset];
-        this._y = array[offset + 1];
-        this._z = array[offset + 2];
-        this._w = array[offset + 3];
+      var points = [],
+          indices = [],
+          uv = [];
+      var leftPoints = result.leftPoints,
+          rightPoints = result.rightPoints;
+      var i = 0,
+          len = leftPoints.length;
 
-        this._onChangeCallback();
+      while (i < len) {
+        // top left
+        var idx0 = i * 3;
+        var _leftPoints$i = leftPoints[i],
+            x1 = _leftPoints$i[0],
+            y1 = _leftPoints$i[1],
+            z1 = _leftPoints$i[2];
+        points[idx0] = x1;
+        points[idx0 + 1] = y1;
+        points[idx0 + 2] = lz + z1; // top right
 
-        return this;
-      };
+        var _rightPoints$i = rightPoints[i],
+            x2 = _rightPoints$i[0],
+            y2 = _rightPoints$i[1],
+            z2 = _rightPoints$i[2];
+        var idx1 = len * 3 + idx0;
+        points[idx1] = x2;
+        points[idx1 + 1] = y2;
+        points[idx1 + 2] = rz + z2; // bottom left
 
-      _proto.toArray = function toArray(array, offset) {
-        if (array === void 0) {
-          array = [];
-        }
+        var idx2 = len * 2 * 3 + idx0;
+        points[idx2] = x1;
+        points[idx2 + 1] = y1;
+        points[idx2 + 2] = z1;
 
-        if (offset === void 0) {
-          offset = 0;
-        }
+        if (bottomStickGround) {
+          points[idx2 + 2] = 0;
+        } // bottom right
 
-        array[offset] = this._x;
-        array[offset + 1] = this._y;
-        array[offset + 2] = this._z;
-        array[offset + 3] = this._w;
-        return array;
-      };
 
-      _proto.fromBufferAttribute = function fromBufferAttribute(attribute, index) {
-        this._x = attribute.getX(index);
-        this._y = attribute.getY(index);
-        this._z = attribute.getZ(index);
-        this._w = attribute.getW(index);
+        var idx3 = len * 2 * 3 + len * 3 + idx0;
+        points[idx3] = x2;
+        points[idx3 + 1] = y2;
+        points[idx3 + 2] = z2;
 
-        this._onChangeCallback();
+        if (bottomStickGround) {
+          points[idx3 + 2] = 0;
+        }
 
-        return this;
-      };
+        i++;
+      }
 
-      _proto.toJSON = function toJSON() {
-        return this.toArray();
-      };
+      i = 0;
+      len = points.length;
+      var uIndex = uv.length - 1;
 
-      _proto._onChange = function _onChange(callback) {
-        this._onChangeCallback = callback;
-        return this;
-      };
+      while (i < len) {
+        var x = points[i],
+            y = points[i + 1];
+        uv[++uIndex] = x;
+        uv[++uIndex] = y; // uvs.push(x, y);
 
-      _proto._onChangeCallback = function _onChangeCallback() {};
+        i += 3;
+      }
 
-      _proto[_Symbol$iterator] = /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                _context.next = 2;
-                return this._x;
+      i = 0;
+      len = leftPoints.length;
+      var iIndex = indices.length - 1;
 
-              case 2:
-                _context.next = 4;
-                return this._y;
+      while (i < len - 1) {
+        // top
+        // left1 left2 right1,right2
+        var a1 = i,
+            b1 = i + 1,
+            c1 = a1 + len,
+            d1 = b1 + len;
+        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
 
-              case 4:
-                _context.next = 6;
-                return this._z;
+        var len2 = len * 2;
+        var a2 = i + len2,
+            b2 = a2 + 1,
+            c2 = a2 + len,
+            d2 = b2 + len;
+        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);
 
-              case 6:
-                _context.next = 8;
-                return this._w;
+        i++;
+      }
 
-              case 8:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      });
+      result.indices = indices;
+      result.points = points;
+      result.uv = uv;
 
-      _createClass(Quaternion, [{
-        key: "x",
-        get: function get() {
-          return this._x;
-        },
-        set: function set(value) {
-          this._x = value;
+      if (depths) {
+        len = leftPoints.length;
+        i = 0;
 
-          this._onChangeCallback();
+        while (i < len) {
+          leftPoints[i].depth = lz;
+          rightPoints[i].depth = rz;
+          i++;
         }
-      }, {
-        key: "y",
-        get: function get() {
-          return this._y;
-        },
-        set: function set(value) {
-          this._y = value;
+      }
+    }
 
-          this._onChangeCallback();
-        }
-      }, {
-        key: "z",
-        get: function get() {
-          return this._z;
-        },
-        set: function set(value) {
-          this._z = value;
+    function generateSides(result, options) {
+      var points = result.points,
+          indices = result.indices,
+          leftPoints = result.leftPoints,
+          rightPoints = result.rightPoints,
+          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;
 
-          this._onChangeCallback();
-        }
-      }, {
-        key: "w",
-        get: function get() {
-          return this._w;
-        },
-        set: function set(value) {
-          this._w = value;
+      function addOneSideIndex(v1, v2) {
+        var idx = points.length / 3; // let pIndex = points.length - 1;
+        // top
 
-          this._onChangeCallback();
-        }
-      }]);
+        points[++pIndex] = v1[0];
+        points[++pIndex] = v1[1];
+        points[++pIndex] = (depthsEnable ? v1.depth : z) + 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]);
+        // bottom
+
+        points[++pIndex] = v1[0];
+        points[++pIndex] = v1[1];
+        points[++pIndex] = bottomStickGround ? 0 : v1[2];
+        points[++pIndex] = v2[0];
+        points[++pIndex] = v2[1];
+        points[++pIndex] = bottomStickGround ? 0 : v2[2]; // points.push(v1[0], v1[1], v1[2], v2[0], v2[1], v2[2]);
 
-      return Quaternion;
-    }(Symbol.iterator);
+        var a = idx + 2,
+            b = idx + 3,
+            c = idx,
+            d = idx + 1;
+        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);
 
-    // import * as MathUtils from './MathUtils.js';
+        generateSideWallUV(uv, points, a, b, c, d);
+      }
 
-    var _quaternion = new Quaternion();
+      for (var i = 0, _len = rings.length; i < _len; i++) {
+        var ring = rings[i];
 
-    var Vector3 = /*#__PURE__*/function () {
-      function Vector3(x, y, z) {
-        if (x === void 0) {
-          x = 0;
+        if (i > 0) {
+          ring = ring.map(function (p) {
+            return p;
+          });
+          ring = ring.reverse();
         }
 
-        if (y === void 0) {
-          y = 0;
-        }
+        var j = 0;
+        var len1 = ring.length - 1;
 
-        if (z === void 0) {
-          z = 0;
+        while (j < len1) {
+          var v1 = ring[j];
+          var v2 = ring[j + 1];
+          addOneSideIndex(v1, v2);
+          j++;
         }
-
-        this.x = x;
-        this.y = y;
-        this.z = z;
       }
 
-      var _proto = Vector3.prototype;
-
-      _proto.set = function set(x, y, z) {
-        if (z === undefined) z = this.z; // sprite.scale.set(x,y)
-
-        this.x = x;
-        this.y = y;
-        this.z = z;
-        return this;
-      } // setScalar(scalar) {
-      //     this.x = scalar;
-      //     this.y = scalar;
-      //     this.z = scalar;
-      //     return this;
-      // }
-      // setX(x) {
-      //     this.x = x;
-      //     return this;
-      // }
-      // setY(y) {
-      //     this.y = y;
-      //     return this;
-      // }
-      // setZ(z) {
-      //     this.z = z;
-      //     return this;
-      // }
-      // setComponent(index, value) {
-      //     switch (index) {
-      //         case 0: this.x = value; break;
-      //         case 1: this.y = value; break;
-      //         case 2: this.z = value; break;
-      //         default: throw new Error('index is out of range: ' + index);
-      //     }
-      //     return this;
-      // }
-      // getComponent(index) {
-      //     switch (index) {
-      //         case 0: return this.x;
-      //         case 1: return this.y;
-      //         case 2: return this.z;
-      //         default: throw new Error('index is out of range: ' + index);
-      //     }
-      // }
-      ;
-
-      _proto.clone = function clone() {
-        return new this.constructor(this.x, this.y, this.z);
-      };
-
-      _proto.copy = function copy(v) {
-        this.x = v.x;
-        this.y = v.y;
-        this.z = v.z;
-        return this;
-      };
-
-      _proto.add = function add(v) {
-        this.x += v.x;
-        this.y += v.y;
-        this.z += v.z;
-        return this;
-      };
+      var len = leftPoints.length;
+      var vs = [rightPoints[0], leftPoints[0], leftPoints[len - 1], rightPoints[len - 1]];
 
-      _proto.addScalar = function addScalar(s) {
-        this.x += s;
-        this.y += s;
-        this.z += s;
-        return this;
-      };
+      for (var _i = 0; _i < vs.length; _i += 2) {
+        var _v = vs[_i],
+            _v2 = vs[_i + 1];
+        addOneSideIndex(_v, _v2);
+      }
+    }
 
-      _proto.addVectors = function addVectors(a, b) {
-        this.x = a.x + b.x;
-        this.y = a.y + b.y;
-        this.z = a.z + b.z;
-        return this;
-      };
+    var TEMPV1 = {
+      x: 0,
+      y: 0
+    },
+        TEMPV2 = {
+      x: 0,
+      y: 0
+    };
+    function expandLine(line, options) {
+      // let preAngle = 0;
+      var radius = options.lineWidth / 2;
+      var points = [],
+          leftPoints = [],
+          rightPoints = [];
+      var len = line.length;
+      var i = 0;
 
-      _proto.addScaledVector = function addScaledVector(v, s) {
-        this.x += v.x * s;
-        this.y += v.y * s;
-        this.z += v.z * s;
-        return this;
-      };
+      while (i < len) {
+        var p1 = line[i],
+            p2 = line[i + 1];
+        var currentp = line[i]; // last vertex
 
-      _proto.sub = function sub(v) {
-        this.x -= v.x;
-        this.y -= v.y;
-        this.z -= v.z;
-        return this;
-      };
+        if (i === len - 1) {
+          p1 = line[len - 2];
+          p2 = line[len - 1];
+        }
 
-      _proto.subScalar = function subScalar(s) {
-        this.x -= s;
-        this.y -= s;
-        this.z -= s;
-        return this;
-      };
+        var dy = p2[1] - p1[1],
+            dx = p2[0] - p1[0];
+        var rAngle = 0;
+        var rad = Math.atan(dy / dx);
+        var angle = radToDeg(rad); // preAngle = angle;
 
-      _proto.subVectors = function subVectors(a, b) {
-        this.x = a.x - b.x;
-        this.y = a.y - b.y;
-        this.z = a.z - b.z;
-        return this;
-      };
+        if (i === 0 || i === len - 1) {
+          rAngle = angle;
+          rAngle -= 90;
+        } else {
+          // 至少3个顶点才会触发
+          var p0 = line[i - 1];
+          TEMPV1.x = p0[0] - p1[0];
+          TEMPV1.y = p0[1] - p1[1];
+          TEMPV2.x = p2[0] - p1[0];
+          TEMPV2.y = p2[1] - p1[1];
+          var vAngle = getAngle(TEMPV1, TEMPV2);
+          rAngle = angle - vAngle / 2;
+        }
 
-      _proto.multiply = function multiply(v) {
-        this.x *= v.x;
-        this.y *= v.y;
-        this.z *= v.z;
-        return this;
-      };
+        var rRad = degToRad(rAngle);
+        var p3 = currentp;
+        var x = Math.cos(rRad) + p3[0],
+            y = Math.sin(rRad) + p3[1];
+        var p4 = [x, y];
 
-      _proto.multiplyScalar = function multiplyScalar(scalar) {
-        this.x *= scalar;
-        this.y *= scalar;
-        this.z *= scalar;
-        return this;
-      };
+        var _translateLine = translateLine(p1, p2, radius),
+            line1 = _translateLine[0],
+            line2 = _translateLine[1];
 
-      _proto.multiplyVectors = function multiplyVectors(a, b) {
-        this.x = a.x * b.x;
-        this.y = a.y * b.y;
-        this.z = a.z * b.z;
-        return this;
-      } // applyEuler(euler) {
-      //     return this.applyQuaternion(_quaternion.setFromEuler(euler));
-      // }
-      ;
+        var op1 = lineIntersection(line1[0], line1[1], p3, p4);
+        var op2 = lineIntersection(line2[0], line2[1], p3, p4); // 平行，回头路
 
-      _proto.applyAxisAngle = function applyAxisAngle(axis, angle) {
-        return this.applyQuaternion(_quaternion.setFromAxisAngle(axis, angle));
-      } // applyMatrix3(m) {
-      //     const x = this.x, y = this.y, z = this.z;
-      //     const e = m.elements;
-      //     this.x = e[0] * x + e[3] * y + e[6] * z;
-      //     this.y = e[1] * x + e[4] * y + e[7] * z;
-      //     this.z = e[2] * x + e[5] * y + e[8] * z;
-      //     return this;
-      // }
-      // applyNormalMatrix(m) {
-      //     return this.applyMatrix3(m).normalize();
-      // }
-      ;
+        if (!op1 || !op2) {
+          var len1 = points.length;
+          var point1 = points[len1 - 2];
+          var point2 = points[len1 - 1];
 
-      _proto.applyMatrix4 = function applyMatrix4(m) {
-        var x = this.x,
-            y = this.y,
-            z = this.z;
-        var e = m.elements;
-        var w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
-        this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w;
-        this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w;
-        this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w;
-        return this;
-      };
+          if (!point1 || !point2) {
+            continue;
+          }
 
-      _proto.applyQuaternion = function applyQuaternion(q) {
-        var x = this.x,
-            y = this.y,
-            z = this.z;
-        var qx = q.x,
-            qy = q.y,
-            qz = q.z,
-            qw = q.w; // calculate quat * vector
+          op1 = [point1[0], point1[1]];
+          op2 = [point2[0], point2[1]];
+        }
 
-        var ix = qw * x + qy * z - qz * y;
-        var iy = qw * y + qz * x - qx * z;
-        var iz = qw * z + qx * y - qy * x;
-        var iw = -qx * x - qy * y - qz * z; // calculate result * inverse quat
+        op1[2] = currentp[2] || 0;
+        op2[2] = currentp[2] || 0; // const [op1, op2] = calOffsetPoint(rRad, radius, p1);
 
-        this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
-        this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
-        this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
-        return this;
-      } // project(camera) {
-      //     return this.applyMatrix4(camera.matrixWorldInverse).applyMatrix4(camera.projectionMatrix);
-      // }
-      // unproject(camera) {
-      //     return this.applyMatrix4(camera.projectionMatrixInverse).applyMatrix4(camera.matrixWorld);
-      // }
-      // transformDirection(m) {
-      //     // input: THREE.Matrix4 affine matrix
-      //     // vector interpreted as a direction
-      //     const x = this.x, y = this.y, z = this.z;
-      //     const e = m.elements;
-      //     this.x = e[0] * x + e[4] * y + e[8] * z;
-      //     this.y = e[1] * x + e[5] * y + e[9] * z;
-      //     this.z = e[2] * x + e[6] * y + e[10] * z;
-      //     return this.normalize();
-      // }
-      ;
+        points.push(op1, op2);
 
-      _proto.divide = function divide(v) {
-        this.x /= v.x;
-        this.y /= v.y;
-        this.z /= v.z;
-        return this;
-      };
+        if (leftOnLine(op1, p1, p2)) {
+          leftPoints.push(op1);
+          rightPoints.push(op2);
+        } else {
+          leftPoints.push(op2);
+          rightPoints.push(op1);
+        }
 
-      _proto.divideScalar = function divideScalar(scalar) {
-        return this.multiplyScalar(1 / scalar);
-      };
+        i++;
+      }
 
-      _proto.min = function min(v) {
-        this.x = Math.min(this.x, v.x);
-        this.y = Math.min(this.y, v.y);
-        this.z = Math.min(this.z, v.z);
-        return this;
+      return {
+        offsetPoints: points,
+        leftPoints: leftPoints,
+        rightPoints: rightPoints
       };
+    } // eslint-disable-next-line no-unused-vars
 
-      _proto.max = function max(v) {
-        this.x = Math.max(this.x, v.x);
-        this.y = Math.max(this.y, v.y);
-        this.z = Math.max(this.z, v.z);
-        return this;
-      };
+    var getAngle = function getAngle(_ref, _ref2) {
+      var x1 = _ref.x,
+          y1 = _ref.y;
+      var x2 = _ref2.x,
+          y2 = _ref2.y;
+      var dot = x1 * x2 + y1 * y2;
+      var det = x1 * y2 - y1 * x2;
+      var angle = Math.atan2(det, dot) / Math.PI * 180;
+      return (angle + 360) % 360;
+    };
 
-      _proto.clamp = function clamp(min, max) {
-        // assumes min < max, componentwise
-        this.x = Math.max(min.x, Math.min(max.x, this.x));
-        this.y = Math.max(min.y, Math.min(max.y, this.y));
-        this.z = Math.max(min.z, Math.min(max.z, this.z));
-        return this;
-      };
+    function leftOnLine(p, p1, p2) {
+      var x1 = p1[0],
+          y1 = p1[1];
+      var x2 = p2[0],
+          y2 = p2[1];
+      var x = p[0],
+          y = p[1];
+      return (y1 - y2) * x + (x2 - x1) * y + x1 * y2 - x2 * y1 > 0;
+    }
+    /**
+     * 平移线
+     * @param {*} p1
+     * @param {*} p2
+     * @param {*} distance
+     * @returns
+     */
 
-      _proto.clampScalar = function clampScalar(minVal, maxVal) {
-        this.x = Math.max(minVal, Math.min(maxVal, this.x));
-        this.y = Math.max(minVal, Math.min(maxVal, this.y));
-        this.z = Math.max(minVal, Math.min(maxVal, this.z));
-        return this;
-      };
+    function translateLine(p1, p2, distance) {
+      var dy = p2[1] - p1[1],
+          dx = p2[0] - p1[0];
+      var rad = Math.atan2(dy, dx);
+      var rad1 = rad + Math.PI / 2;
+      var offsetX = Math.cos(rad1) * distance,
+          offsetY = Math.sin(rad1) * distance;
+      var tp1 = [p1[0] + offsetX, p1[1] + offsetY];
+      var tp2 = [p2[0] + offsetX, p2[1] + offsetY];
+      var rad2 = rad - Math.PI / 2;
+      offsetX = Math.cos(rad2) * distance;
+      offsetY = Math.sin(rad2) * distance;
+      var tp3 = [p1[0] + offsetX, p1[1] + offsetY];
+      var tp4 = [p2[0] + offsetX, p2[1] + offsetY];
+      return [[tp1, tp2], [tp3, tp4]];
+    }
+    /**
+     * 直线交点
+     * @param {*} p1
+     * @param {*} p2
+     * @param {*} p3
+     * @param {*} p4
+     * @returns
+     */
 
-      _proto.clampLength = function clampLength(min, max) {
-        var length = this.length();
-        return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
-      } // floor() {
-      //     this.x = Math.floor(this.x);
-      //     this.y = Math.floor(this.y);
-      //     this.z = Math.floor(this.z);
-      //     return this;
-      // }
-      // ceil() {
-      //     this.x = Math.ceil(this.x);
-      //     this.y = Math.ceil(this.y);
-      //     this.z = Math.ceil(this.z);
-      //     return this;
-      // }
-      // round() {
-      //     this.x = Math.round(this.x);
-      //     this.y = Math.round(this.y);
-      //     this.z = Math.round(this.z);
-      //     return this;
-      // }
-      // roundToZero() {
-      //     this.x = (this.x < 0) ? Math.ceil(this.x) : Math.floor(this.x);
-      //     this.y = (this.y < 0) ? Math.ceil(this.y) : Math.floor(this.y);
-      //     this.z = (this.z < 0) ? Math.ceil(this.z) : Math.floor(this.z);
-      //     return this;
-      // }
-      // negate() {
-      //     this.x = -this.x;
-      //     this.y = -this.y;
-      //     this.z = -this.z;
-      //     return this;
-      // }
-      ;
 
-      _proto.dot = function dot(v) {
-        return this.x * v.x + this.y * v.y + this.z * v.z;
-      } // TODO lengthSquared?
-      ;
+    function lineIntersection(p1, p2, p3, p4) {
+      var dx1 = p2[0] - p1[0],
+          dy1 = p2[1] - p1[1];
+      var dx2 = p4[0] - p3[0],
+          dy2 = p4[1] - p3[1];
 
-      _proto.lengthSq = function lengthSq() {
-        return this.x * this.x + this.y * this.y + this.z * this.z;
-      };
+      if (dx1 === 0 && dx2 === 0) {
+        return null;
+      }
 
-      _proto.length = function length() {
-        return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
-      } // manhattanLength() {
-      //     return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z);
-      // }
-      ;
+      if (dy1 === 0 && dy2 === 0) {
+        return null;
+      }
 
-      _proto.normalize = function normalize() {
-        return this.divideScalar(this.length() || 1);
-      };
+      var k1 = dy1 / dx1;
+      var k2 = dy2 / dx2;
+      var b1 = p1[1] - k1 * p1[0];
+      var b2 = p3[1] - k2 * p3[0];
+      var x, y;
+
+      if (dx1 === 0) {
+        x = p1[0];
+        y = k2 * x + b2;
+      } else if (dx2 === 0) {
+        x = p3[0];
+        y = k1 * x + b1;
+      } else if (dy1 === 0) {
+        y = p1[1];
+        x = (y - b2) / k2;
+      } else if (dy2 === 0) {
+        y = p3[1];
+        x = (y - b1) / k1;
+      } else {
+        x = (b2 - b1) / (k1 - k2);
+        y = k1 * x + b1;
+      }
+
+      return [x, y];
+    }
+
+    function cylinder(point, options) {
+      if (options === void 0) {
+        options = {};
+      }
+
+      options = Object.assign({}, {
+        radius: 1,
+        height: 2,
+        radialSegments: 6
+      }, options);
+      var radialSegments = Math.round(Math.max(4, options.radialSegments));
+      var _options = options,
+          radius = _options.radius,
+          height = _options.height;
+      var aRad = 360 / radialSegments / 360 * Math.PI * 2;
+      var circlePointsLen = radialSegments + 1;
+      var points = new Float32Array(circlePointsLen * 3 * 2);
+      var centerx = point[0],
+          centery = point[1];
+      var idx = 0,
+          uIdx = 0;
+      var offset = circlePointsLen * 3,
+          uOffset = circlePointsLen * 2;
+      var indices = [],
+          uv = [];
+      var iIndex = indices.length - 1;
+
+      for (var i = -1; i < radialSegments; i++) {
+        var rad = aRad * i;
+        var x = Math.cos(rad) * radius + centerx,
+            y = Math.sin(rad) * radius + centery; // bottom vertices
 
-      _proto.setLength = function setLength(length) {
-        return this.normalize().multiplyScalar(length);
-      };
+        points[idx] = x;
+        points[idx + 1] = y;
+        points[idx + 2] = 0; // top vertices
 
-      _proto.lerp = function lerp(v, alpha) {
-        this.x += (v.x - this.x) * alpha;
-        this.y += (v.y - this.y) * alpha;
-        this.z += (v.z - this.z) * alpha;
-        return this;
-      };
+        points[idx + offset] = x;
+        points[idx + 1 + offset] = y;
+        points[idx + 2 + offset] = height;
+        var 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;
 
-      _proto.lerpVectors = function lerpVectors(v1, v2, alpha) {
-        this.x = v1.x + (v2.x - v1.x) * alpha;
-        this.y = v1.y + (v2.y - v1.y) * alpha;
-        this.z = v1.z + (v2.z - v1.z) * alpha;
-        return this;
-      };
+        if (i > 1) {
+          // bottom indices
+          // indices.push(0, i - 1, i);
+          indices[++iIndex] = 0;
+          indices[++iIndex] = i - 1;
+          indices[++iIndex] = i;
+        }
+      }
 
-      _proto.cross = function cross(v) {
-        return this.crossVectors(this, v);
-      };
+      idx -= 3;
+      points[idx] = points[0];
+      points[idx + 1] = points[1];
+      points[idx + 2] = points[2];
+      var pointsLen = points.length;
+      points[pointsLen - 3] = points[0];
+      points[pointsLen - 2] = points[1];
+      points[pointsLen - 1] = height;
+      var indicesLen = indices.length; // top indices
 
-      _proto.crossVectors = function crossVectors(a, b) {
-        var ax = a.x,
-            ay = a.y,
-            az = a.z;
-        var bx = b.x,
-            by = b.y,
-            bz = b.z;
-        this.x = ay * bz - az * by;
-        this.y = az * bx - ax * bz;
-        this.z = ax * by - ay * bx;
-        return this;
-      } // projectOnVector(v) {
-      //     const denominator = v.lengthSq();
-      //     if (denominator === 0) return this.set(0, 0, 0);
-      //     const scalar = v.dot(this) / denominator;
-      //     return this.copy(v).multiplyScalar(scalar);
-      // }
-      // projectOnPlane(planeNormal) {
-      //     _vector.copy(this).projectOnVector(planeNormal);
-      //     return this.sub(_vector);
-      // }
-      // reflect(normal) {
-      //     // reflect incident vector off plane orthogonal to normal
-      //     // normal is assumed to have unit length
-      //     return this.sub(_vector.copy(normal).multiplyScalar(2 * this.dot(normal)));
-      // }
-      // angleTo(v) {
-      //     const denominator = Math.sqrt(this.lengthSq() * v.lengthSq());
-      //     if (denominator === 0) return Math.PI / 2;
-      //     const theta = this.dot(v) / denominator;
-      //     // clamp, to handle numerical problems
-      //     return Math.acos(MathUtils.clamp(theta, -1, 1));
-      // }
-      ;
+      iIndex = indices.length - 1;
 
-      _proto.distanceTo = function distanceTo(v) {
-        return Math.sqrt(this.distanceToSquared(v));
-      } // distanceToSquared(v) {
-      //     const dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
-      //     return dx * dx + dy * dy + dz * dz;
-      // }
-      // manhattanDistanceTo(v) {
-      //     return Math.abs(this.x - v.x) + Math.abs(this.y - v.y) + Math.abs(this.z - v.z);
-      // }
-      // setFromSpherical(s) {
-      //     return this.setFromSphericalCoords(s.radius, s.phi, s.theta);
-      // }
-      // setFromSphericalCoords(radius, phi, theta) {
-      //     const sinPhiRadius = Math.sin(phi) * radius;
-      //     this.x = sinPhiRadius * Math.sin(theta);
-      //     this.y = Math.cos(phi) * radius;
-      //     this.z = sinPhiRadius * Math.cos(theta);
-      //     return this;
-      // }
-      // setFromCylindrical(c) {
-      //     return this.setFromCylindricalCoords(c.radius, c.theta, c.y);
-      // }
-      // setFromCylindricalCoords(radius, theta, y) {
-      //     this.x = radius * Math.sin(theta);
-      //     this.y = y;
-      //     this.z = radius * Math.cos(theta);
-      //     return this;
-      // }
-      // setFromMatrixPosition(m) {
-      //     const e = m.elements;
-      //     this.x = e[12];
-      //     this.y = e[13];
-      //     this.z = e[14];
-      //     return this;
-      // }
-      // setFromMatrixScale(m) {
-      //     const sx = this.setFromMatrixColumn(m, 0).length();
-      //     const sy = this.setFromMatrixColumn(m, 1).length();
-      //     const sz = this.setFromMatrixColumn(m, 2).length();
-      //     this.x = sx;
-      //     this.y = sy;
-      //     this.z = sz;
-      //     return this;
-      // }
-      // setFromMatrixColumn(m, index) {
-      //     return this.fromArray(m.elements, index * 4);
-      // }
-      // setFromMatrix3Column(m, index) {
-      //     return this.fromArray(m.elements, index * 3);
-      // }
-      // setFromEuler(e) {
-      //     this.x = e._x;
-      //     this.y = e._y;
-      //     this.z = e._z;
-      //     return this;
-      // }
-      // setFromColor(c) {
-      //     this.x = c.r;
-      //     this.y = c.g;
-      //     this.z = c.b;
-      //     return this;
-      // }
-      ;
+      for (var _i = 0; _i < indicesLen; _i++) {
+        var index = indices[_i];
+        indices[++iIndex] = index + circlePointsLen; // indices.push(index + circlePointsLen);
+      }
 
-      _proto.equals = function equals(v) {
-        return v.x === this.x && v.y === this.y && v.z === this.z;
-      };
+      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;
 
-      _proto.fromArray = function fromArray(array, offset) {
-        if (offset === void 0) {
-          offset = 0;
-        }
+      for (var _i2 = 0, len = points.length / 2; _i2 < len - 3; _i2 += 3) {
+        var x1 = points[_i2],
+            y1 = points[_i2 + 1],
+            x2 = points[_i2 + 3],
+            y2 = points[_i2 + 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;
+        var a = idx + 2,
+            b = idx + 3,
+            c = idx,
+            d = idx + 1; // indices.push(a, c, b, c, d, b);
 
-        this.x = array[offset];
-        this.y = array[offset + 1];
-        this.z = array[offset + 2];
-        return this;
-      } // toArray(array = [], offset = 0) {
-      //     array[offset] = this.x;
-      //     array[offset + 1] = this.y;
-      //     array[offset + 2] = this.z;
-      //     return array;
-      // }
-      // fromBufferAttribute(attribute, index) {
-      //     this.x = attribute.getX(index);
-      //     this.y = attribute.getY(index);
-      //     this.z = attribute.getZ(index);
-      //     return this;
-      // }
-      ;
+        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);
 
-      _proto.random = function random() {
-        this.x = Math.random();
-        this.y = Math.random();
-        this.z = Math.random();
-        return this;
-      } // randomDirection() {
-      //     // Derived from https://mathworld.wolfram.com/SpherePointPicking.html
-      //     const u = (Math.random() - 0.5) * 2;
-      //     const t = Math.random() * Math.PI * 2;
-      //     const f = Math.sqrt(1 - u ** 2);
-      //     this.x = f * Math.cos(t);
-      //     this.y = f * Math.sin(t);
-      //     this.z = u;
-      //     return this;
-      // }
-      ;
+        idx += 4;
+        var 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);
 
-      return Vector3;
-    }();
+        uIdx++;
+      }
+
+      var position = new Float32Array(points.length + sidePoints.length);
+      position.set(points, 0);
+      position.set(sidePoints, points.length);
+      var normal = generateNormal(indices, position);
+      return {
+        points: points,
+        indices: new Uint32Array(indices),
+        position: position,
+        normal: normal,
+        uv: new Float32Array(uv)
+      };
+    }
 
     /* eslint-disable no-tabs */
     /**
@@ -4465,6 +4113,13 @@
     }();
 
     var UP$1 = new Vector3(0, 0, 1);
+    var right = new Vector3();
+    var left = new Vector3(); // for sharp corners
+
+    var leftOffset = new Vector3();
+    var rightOffset = new Vector3();
+    var tempPoint1 = new Vector3();
+    var tempPoint2 = new Vector3();
     function expandPaths(lines, options) {
       options = Object.assign({}, {
         lineWidth: 1,
@@ -4472,12 +4127,7 @@
         cornerSplit: 10
       }, options);
       var results = lines.map(function (line) {
-        var points = line.map(function (p) {
-          var x = p[0],
-              y = p[1],
-              z = p[2];
-          return new Vector3(x, y, z || 0);
-        });
+        var points = line2Vectors(line);
         var pathPointList = new PathPointList();
         pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP$1);
         var result = generatePathVertexData(pathPointList, options);
@@ -4515,13 +4165,6 @@
       var uv = [];
       var indices = [];
       var verticesCount = 0;
-      var right = new Vector3();
-      var left = new Vector3(); // for sharp corners
-
-      var leftOffset = new Vector3();
-      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;
@@ -4799,6 +4442,7 @@
     }
 
     var UP = new Vector3(0, 0, 1);
+    var normalDir = new Vector3();
     function expandTubes(lines, options) {
       options = Object.assign({}, {
         radius: 1,
@@ -4807,12 +4451,7 @@
         startRad: -Math.PI / 4
       }, options);
       var results = lines.map(function (line) {
-        var points = line.map(function (p) {
-          var x = p[0],
-              y = p[1],
-              z = p[2];
-          return new Vector3(x, y, z || 0);
-        });
+        var points = line2Vectors(line);
         var pathPointList = new PathPointList();
         pathPointList.set(points, options.cornerRadius, options.cornerSplit, UP);
         var result = generateTubeVertexData(pathPointList, options);
@@ -4850,7 +4489,6 @@
 
       var indices = [];
       var verticesCount = 0;
-      var normalDir = new Vector3();
       var pIndex = -1;
       var nIndex = -1;
       var uIndex = -1;