opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/geometries/ParametricGeometries.js

@@ -0,0 +1,280 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "./ParametricGeometry.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("./ParametricGeometry.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.ParametricGeometry);
+    global.ParametricGeometries = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _ParametricGeometry4) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.ParametricGeometries = void 0;
+
+  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); } }
+
+  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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  /**
+   * Experimenting of primitive geometry creation using Surface Parametric equations
+   */
+  var ParametricGeometries = {
+    klein: function klein(v, u, target) {
+      u *= Math.PI;
+      v *= 2 * Math.PI;
+      u = u * 2;
+      var x, z;
+
+      if (u < Math.PI) {
+        x = 3 * Math.cos(u) * (1 + Math.sin(u)) + 2 * (1 - Math.cos(u) / 2) * Math.cos(u) * Math.cos(v);
+        z = -8 * Math.sin(u) - 2 * (1 - Math.cos(u) / 2) * Math.sin(u) * Math.cos(v);
+      } else {
+        x = 3 * Math.cos(u) * (1 + Math.sin(u)) + 2 * (1 - Math.cos(u) / 2) * Math.cos(v + Math.PI);
+        z = -8 * Math.sin(u);
+      }
+
+      var y = -2 * (1 - Math.cos(u) / 2) * Math.sin(v);
+      target.set(x, y, z);
+    },
+    plane: function plane(width, height) {
+      return function (u, v, target) {
+        var x = u * width;
+        var y = 0;
+        var z = v * height;
+        target.set(x, y, z);
+      };
+    },
+    mobius: function mobius(u, t, target) {
+      // flat mobius strip
+      // http://www.wolframalpha.com/input/?i=M%C3%B6bius+strip+parametric+equations&lk=1&a=ClashPrefs_*Surface.MoebiusStrip.SurfaceProperty.ParametricEquations-
+      u = u - 0.5;
+      var v = 2 * Math.PI * t;
+      var a = 2;
+      var x = Math.cos(v) * (a + u * Math.cos(v / 2));
+      var y = Math.sin(v) * (a + u * Math.cos(v / 2));
+      var z = u * Math.sin(v / 2);
+      target.set(x, y, z);
+    },
+    mobius3d: function mobius3d(u, t, target) {
+      // volumetric mobius strip
+      u *= Math.PI;
+      t *= 2 * Math.PI;
+      u = u * 2;
+      var phi = u / 2;
+      var major = 2.25,
+          a = 0.125,
+          b = 0.65;
+      var x = a * Math.cos(t) * Math.cos(phi) - b * Math.sin(t) * Math.sin(phi);
+      var z = a * Math.cos(t) * Math.sin(phi) + b * Math.sin(t) * Math.cos(phi);
+      var y = (major + x) * Math.sin(u);
+      x = (major + x) * Math.cos(u);
+      target.set(x, y, z);
+    }
+  };
+  /*********************************************
+   *
+   * Parametric Replacement for TubeGeometry
+   *
+   *********************************************/
+
+  _exports.ParametricGeometries = ParametricGeometries;
+
+  ParametricGeometries.TubeGeometry = /*#__PURE__*/function (_ParametricGeometry) {
+    _inherits(TubeGeometry, _ParametricGeometry);
+
+    var _super = _createSuper(TubeGeometry);
+
+    function TubeGeometry(path) {
+      var _this;
+
+      var segments = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 64;
+      var radius = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+      var segmentsRadius = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 8;
+      var closed = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+
+      _classCallCheck(this, TubeGeometry);
+
+      var numpoints = segments + 1;
+      var frames = path.computeFrenetFrames(segments, closed),
+          tangents = frames.tangents,
+          normals = frames.normals,
+          binormals = frames.binormals;
+      var position = new _three.Vector3();
+
+      function ParametricTube(u, v, target) {
+        v *= 2 * Math.PI;
+        var i = Math.floor(u * (numpoints - 1));
+        path.getPointAt(u, position);
+        var normal = normals[i];
+        var binormal = binormals[i];
+        var cx = -radius * Math.cos(v); // TODO: Hack: Negating it so it faces outside.
+
+        var cy = radius * Math.sin(v);
+        position.x += cx * normal.x + cy * binormal.x;
+        position.y += cx * normal.y + cy * binormal.y;
+        position.z += cx * normal.z + cy * binormal.z;
+        target.copy(position);
+      }
+
+      _this = _super.call(this, ParametricTube, segments, segmentsRadius); // proxy internals
+
+      _this.tangents = tangents;
+      _this.normals = normals;
+      _this.binormals = binormals;
+      _this.path = path;
+      _this.segments = segments;
+      _this.radius = radius;
+      _this.segmentsRadius = segmentsRadius;
+      _this.closed = closed;
+      return _this;
+    }
+
+    return _createClass(TubeGeometry);
+  }(_ParametricGeometry4.ParametricGeometry);
+  /*********************************************
+    *
+    * Parametric Replacement for TorusKnotGeometry
+    *
+    *********************************************/
+
+
+  ParametricGeometries.TorusKnotGeometry = /*#__PURE__*/function (_ParametricGeometries) {
+    _inherits(TorusKnotGeometry, _ParametricGeometries);
+
+    var _super2 = _createSuper(TorusKnotGeometry);
+
+    function TorusKnotGeometry() {
+      var _this2;
+
+      var radius = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 200;
+      var tube = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 40;
+      var segmentsT = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 64;
+      var segmentsR = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 8;
+      var p = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 2;
+      var q = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 3;
+
+      _classCallCheck(this, TorusKnotGeometry);
+
+      var TorusKnotCurve = /*#__PURE__*/function (_Curve) {
+        _inherits(TorusKnotCurve, _Curve);
+
+        var _super3 = _createSuper(TorusKnotCurve);
+
+        function TorusKnotCurve() {
+          _classCallCheck(this, TorusKnotCurve);
+
+          return _super3.apply(this, arguments);
+        }
+
+        _createClass(TorusKnotCurve, [{
+          key: "getPoint",
+          value: function getPoint(t) {
+            var optionalTarget = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new _three.Vector3();
+            var point = optionalTarget;
+            t *= Math.PI * 2;
+            var r = 0.5;
+            var x = (1 + r * Math.cos(q * t)) * Math.cos(p * t);
+            var y = (1 + r * Math.cos(q * t)) * Math.sin(p * t);
+            var z = r * Math.sin(q * t);
+            return point.set(x, y, z).multiplyScalar(radius);
+          }
+        }]);
+
+        return TorusKnotCurve;
+      }(_three.Curve);
+
+      var segments = segmentsT;
+      var radiusSegments = segmentsR;
+      var extrudePath = new TorusKnotCurve();
+      _this2 = _super2.call(this, extrudePath, segments, tube, radiusSegments, true, false);
+      _this2.radius = radius;
+      _this2.tube = tube;
+      _this2.segmentsT = segmentsT;
+      _this2.segmentsR = segmentsR;
+      _this2.p = p;
+      _this2.q = q;
+      return _this2;
+    }
+
+    return _createClass(TorusKnotGeometry);
+  }(ParametricGeometries.TubeGeometry);
+  /*********************************************
+    *
+    * Parametric Replacement for SphereGeometry
+    *
+    *********************************************/
+
+
+  ParametricGeometries.SphereGeometry = /*#__PURE__*/function (_ParametricGeometry2) {
+    _inherits(SphereGeometry, _ParametricGeometry2);
+
+    var _super4 = _createSuper(SphereGeometry);
+
+    function SphereGeometry(size, u, v) {
+      _classCallCheck(this, SphereGeometry);
+
+      function sphere(u, v, target) {
+        u *= Math.PI;
+        v *= 2 * Math.PI;
+        var x = size * Math.sin(u) * Math.cos(v);
+        var y = size * Math.sin(u) * Math.sin(v);
+        var z = size * Math.cos(u);
+        target.set(x, y, z);
+      }
+
+      return _super4.call(this, sphere, u, v);
+    }
+
+    return _createClass(SphereGeometry);
+  }(_ParametricGeometry4.ParametricGeometry);
+  /*********************************************
+    *
+    * Parametric Replacement for PlaneGeometry
+    *
+    *********************************************/
+
+
+  ParametricGeometries.PlaneGeometry = /*#__PURE__*/function (_ParametricGeometry3) {
+    _inherits(PlaneGeometry, _ParametricGeometry3);
+
+    var _super5 = _createSuper(PlaneGeometry);
+
+    function PlaneGeometry(width, depth, segmentsWidth, segmentsDepth) {
+      _classCallCheck(this, PlaneGeometry);
+
+      function plane(u, v, target) {
+        var x = u * width;
+        var y = 0;
+        var z = v * depth;
+        target.set(x, y, z);
+      }
+
+      return _super5.call(this, plane, segmentsWidth, segmentsDepth);
+    }
+
+    return _createClass(PlaneGeometry);
+  }(_ParametricGeometry4.ParametricGeometry);
+});

data/lib-opal/js_wrap/three/geometries/ParametricGeometry.js

@@ -0,0 +1,146 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.ParametricGeometry = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.ParametricGeometry = void 0;
+
+  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); } }
+
+  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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var ParametricGeometry = /*#__PURE__*/function (_BufferGeometry) {
+    _inherits(ParametricGeometry, _BufferGeometry);
+
+    var _super = _createSuper(ParametricGeometry);
+
+    function ParametricGeometry() {
+      var _this;
+
+      var func = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function (u, v, target) {
+        return target.set(u, v, Math.cos(u) * Math.sin(v));
+      };
+      var slices = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 8;
+      var stacks = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 8;
+
+      _classCallCheck(this, ParametricGeometry);
+
+      _this = _super.call(this);
+      _this.type = 'ParametricGeometry';
+      _this.parameters = {
+        func: func,
+        slices: slices,
+        stacks: stacks
+      }; // buffers
+
+      var indices = [];
+      var vertices = [];
+      var normals = [];
+      var uvs = [];
+      var EPS = 0.00001;
+      var normal = new _three.Vector3();
+      var p0 = new _three.Vector3(),
+          p1 = new _three.Vector3();
+      var pu = new _three.Vector3(),
+          pv = new _three.Vector3();
+
+      if (func.length < 3) {
+        console.error('THREE.ParametricGeometry: Function must now modify a Vector3 as third parameter.');
+      } // generate vertices, normals and uvs
+
+
+      var sliceCount = slices + 1;
+
+      for (var i = 0; i <= stacks; i++) {
+        var v = i / stacks;
+
+        for (var j = 0; j <= slices; j++) {
+          var u = j / slices; // vertex
+
+          func(u, v, p0);
+          vertices.push(p0.x, p0.y, p0.z); // normal
+          // approximate tangent vectors via finite differences
+
+          if (u - EPS >= 0) {
+            func(u - EPS, v, p1);
+            pu.subVectors(p0, p1);
+          } else {
+            func(u + EPS, v, p1);
+            pu.subVectors(p1, p0);
+          }
+
+          if (v - EPS >= 0) {
+            func(u, v - EPS, p1);
+            pv.subVectors(p0, p1);
+          } else {
+            func(u, v + EPS, p1);
+            pv.subVectors(p1, p0);
+          } // cross product of tangent vectors returns surface normal
+
+
+          normal.crossVectors(pu, pv).normalize();
+          normals.push(normal.x, normal.y, normal.z); // uv
+
+          uvs.push(u, v);
+        }
+      } // generate indices
+
+
+      for (var _i = 0; _i < stacks; _i++) {
+        for (var _j = 0; _j < slices; _j++) {
+          var a = _i * sliceCount + _j;
+          var b = _i * sliceCount + _j + 1;
+          var c = (_i + 1) * sliceCount + _j + 1;
+          var d = (_i + 1) * sliceCount + _j; // faces one and two
+
+          indices.push(a, b, d);
+          indices.push(b, c, d);
+        }
+      } // build geometry
+
+
+      _this.setIndex(indices);
+
+      _this.setAttribute('position', new _three.Float32BufferAttribute(vertices, 3));
+
+      _this.setAttribute('normal', new _three.Float32BufferAttribute(normals, 3));
+
+      _this.setAttribute('uv', new _three.Float32BufferAttribute(uvs, 2));
+
+      return _this;
+    }
+
+    return _createClass(ParametricGeometry);
+  }(_three.BufferGeometry);
+
+  _exports.ParametricGeometry = ParametricGeometry;
+});

data/lib-opal/js_wrap/three/geometries/RoundedBoxGeometry.js

@@ -0,0 +1,183 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.RoundedBoxGeometry = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.RoundedBoxGeometry = void 0;
+
+  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); } }
+
+  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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var _tempNormal = new _three.Vector3();
+
+  function getUv(faceDirVector, normal, uvAxis, projectionAxis, radius, sideLength) {
+    var totArcLength = 2 * Math.PI * radius / 4; // length of the planes between the arcs on each axis
+
+    var centerLength = Math.max(sideLength - 2 * radius, 0);
+    var halfArc = Math.PI / 4; // Get the vector projected onto the Y plane
+
+    _tempNormal.copy(normal);
+
+    _tempNormal[projectionAxis] = 0;
+
+    _tempNormal.normalize(); // total amount of UV space alloted to a single arc
+
+
+    var arcUvRatio = 0.5 * totArcLength / (totArcLength + centerLength); // the distance along one arc the point is at
+
+    var arcAngleRatio = 1.0 - _tempNormal.angleTo(faceDirVector) / halfArc;
+
+    if (Math.sign(_tempNormal[uvAxis]) === 1) {
+      return arcAngleRatio * arcUvRatio;
+    } else {
+      // total amount of UV space alloted to the plane between the arcs
+      var lenUv = centerLength / (totArcLength + centerLength);
+      return lenUv + arcUvRatio + arcUvRatio * (1.0 - arcAngleRatio);
+    }
+  }
+
+  var RoundedBoxGeometry = /*#__PURE__*/function (_BoxGeometry) {
+    _inherits(RoundedBoxGeometry, _BoxGeometry);
+
+    var _super = _createSuper(RoundedBoxGeometry);
+
+    function RoundedBoxGeometry() {
+      var _this;
+
+      var width = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      var height = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var depth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+      var segments = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 2;
+      var radius = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0.1;
+
+      _classCallCheck(this, RoundedBoxGeometry);
+
+      // ensure segments is odd so we have a plane connecting the rounded corners
+      segments = segments * 2 + 1; // ensure radius isn't bigger than shortest side
+
+      radius = Math.min(width / 2, height / 2, depth / 2, radius);
+      _this = _super.call(this, 1, 1, 1, segments, segments, segments); // if we just have one segment we're the same as a regular box
+
+      if (segments === 1) return _possibleConstructorReturn(_this);
+
+      var geometry2 = _this.toNonIndexed();
+
+      _this.index = null;
+      _this.attributes.position = geometry2.attributes.position;
+      _this.attributes.normal = geometry2.attributes.normal;
+      _this.attributes.uv = geometry2.attributes.uv; //
+
+      var position = new _three.Vector3();
+      var normal = new _three.Vector3();
+      var box = new _three.Vector3(width, height, depth).divideScalar(2).subScalar(radius);
+      var positions = _this.attributes.position.array;
+      var normals = _this.attributes.normal.array;
+      var uvs = _this.attributes.uv.array;
+      var faceTris = positions.length / 6;
+      var faceDirVector = new _three.Vector3();
+      var halfSegmentSize = 0.5 / segments;
+
+      for (var i = 0, j = 0; i < positions.length; i += 3, j += 2) {
+        position.fromArray(positions, i);
+        normal.copy(position);
+        normal.x -= Math.sign(normal.x) * halfSegmentSize;
+        normal.y -= Math.sign(normal.y) * halfSegmentSize;
+        normal.z -= Math.sign(normal.z) * halfSegmentSize;
+        normal.normalize();
+        positions[i + 0] = box.x * Math.sign(position.x) + normal.x * radius;
+        positions[i + 1] = box.y * Math.sign(position.y) + normal.y * radius;
+        positions[i + 2] = box.z * Math.sign(position.z) + normal.z * radius;
+        normals[i + 0] = normal.x;
+        normals[i + 1] = normal.y;
+        normals[i + 2] = normal.z;
+        var side = Math.floor(i / faceTris);
+
+        switch (side) {
+          case 0:
+            // right
+            // generate UVs along Z then Y
+            faceDirVector.set(1, 0, 0);
+            uvs[j + 0] = getUv(faceDirVector, normal, 'z', 'y', radius, depth);
+            uvs[j + 1] = 1.0 - getUv(faceDirVector, normal, 'y', 'z', radius, height);
+            break;
+
+          case 1:
+            // left
+            // generate UVs along Z then Y
+            faceDirVector.set(-1, 0, 0);
+            uvs[j + 0] = 1.0 - getUv(faceDirVector, normal, 'z', 'y', radius, depth);
+            uvs[j + 1] = 1.0 - getUv(faceDirVector, normal, 'y', 'z', radius, height);
+            break;
+
+          case 2:
+            // top
+            // generate UVs along X then Z
+            faceDirVector.set(0, 1, 0);
+            uvs[j + 0] = 1.0 - getUv(faceDirVector, normal, 'x', 'z', radius, width);
+            uvs[j + 1] = getUv(faceDirVector, normal, 'z', 'x', radius, depth);
+            break;
+
+          case 3:
+            // bottom
+            // generate UVs along X then Z
+            faceDirVector.set(0, -1, 0);
+            uvs[j + 0] = 1.0 - getUv(faceDirVector, normal, 'x', 'z', radius, width);
+            uvs[j + 1] = 1.0 - getUv(faceDirVector, normal, 'z', 'x', radius, depth);
+            break;
+
+          case 4:
+            // front
+            // generate UVs along X then Y
+            faceDirVector.set(0, 0, 1);
+            uvs[j + 0] = 1.0 - getUv(faceDirVector, normal, 'x', 'y', radius, width);
+            uvs[j + 1] = 1.0 - getUv(faceDirVector, normal, 'y', 'x', radius, height);
+            break;
+
+          case 5:
+            // back
+            // generate UVs along X then Y
+            faceDirVector.set(0, 0, -1);
+            uvs[j + 0] = getUv(faceDirVector, normal, 'x', 'y', radius, width);
+            uvs[j + 1] = 1.0 - getUv(faceDirVector, normal, 'y', 'x', radius, height);
+            break;
+        }
+      }
+
+      return _this;
+    }
+
+    return _createClass(RoundedBoxGeometry);
+  }(_three.BoxGeometry);
+
+  _exports.RoundedBoxGeometry = RoundedBoxGeometry;
+});