opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/helpers/PositionalAudioHelper.js

@@ -0,0 +1,138 @@
+(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.PositionalAudioHelper = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.PositionalAudioHelper = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 _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 PositionalAudioHelper = /*#__PURE__*/function (_Line) {
+    _inherits(PositionalAudioHelper, _Line);
+
+    var _super = _createSuper(PositionalAudioHelper);
+
+    function PositionalAudioHelper(audio) {
+      var _this;
+
+      var range = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var divisionsInnerAngle = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 16;
+      var divisionsOuterAngle = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 2;
+
+      _classCallCheck(this, PositionalAudioHelper);
+
+      var geometry = new _three.BufferGeometry();
+      var divisions = divisionsInnerAngle + divisionsOuterAngle * 2;
+      var positions = new Float32Array((divisions * 3 + 3) * 3);
+      geometry.setAttribute('position', new _three.BufferAttribute(positions, 3));
+      var materialInnerAngle = new _three.LineBasicMaterial({
+        color: 0x00ff00
+      });
+      var materialOuterAngle = new _three.LineBasicMaterial({
+        color: 0xffff00
+      });
+      _this = _super.call(this, geometry, [materialOuterAngle, materialInnerAngle]);
+      _this.audio = audio;
+      _this.range = range;
+      _this.divisionsInnerAngle = divisionsInnerAngle;
+      _this.divisionsOuterAngle = divisionsOuterAngle;
+      _this.type = 'PositionalAudioHelper';
+
+      _this.update();
+
+      return _this;
+    }
+
+    _createClass(PositionalAudioHelper, [{
+      key: "update",
+      value: function update() {
+        var audio = this.audio;
+        var range = this.range;
+        var divisionsInnerAngle = this.divisionsInnerAngle;
+        var divisionsOuterAngle = this.divisionsOuterAngle;
+
+        var coneInnerAngle = _three.MathUtils.degToRad(audio.panner.coneInnerAngle);
+
+        var coneOuterAngle = _three.MathUtils.degToRad(audio.panner.coneOuterAngle);
+
+        var halfConeInnerAngle = coneInnerAngle / 2;
+        var halfConeOuterAngle = coneOuterAngle / 2;
+        var start = 0;
+        var count = 0;
+        var i;
+        var stride;
+        var geometry = this.geometry;
+        var positionAttribute = geometry.attributes.position;
+        geometry.clearGroups(); //
+
+        function generateSegment(from, to, divisions, materialIndex) {
+          var step = (to - from) / divisions;
+          positionAttribute.setXYZ(start, 0, 0, 0);
+          count++;
+
+          for (i = from; i < to; i += step) {
+            stride = start + count;
+            positionAttribute.setXYZ(stride, Math.sin(i) * range, 0, Math.cos(i) * range);
+            positionAttribute.setXYZ(stride + 1, Math.sin(Math.min(i + step, to)) * range, 0, Math.cos(Math.min(i + step, to)) * range);
+            positionAttribute.setXYZ(stride + 2, 0, 0, 0);
+            count += 3;
+          }
+
+          geometry.addGroup(start, count, materialIndex);
+          start += count;
+          count = 0;
+        } //
+
+
+        generateSegment(-halfConeOuterAngle, -halfConeInnerAngle, divisionsOuterAngle, 0);
+        generateSegment(-halfConeInnerAngle, halfConeInnerAngle, divisionsInnerAngle, 1);
+        generateSegment(halfConeInnerAngle, halfConeOuterAngle, divisionsOuterAngle, 0); //
+
+        positionAttribute.needsUpdate = true;
+        if (coneInnerAngle === coneOuterAngle) this.material[0].visible = false;
+      }
+    }, {
+      key: "dispose",
+      value: function dispose() {
+        this.geometry.dispose();
+        this.material[0].dispose();
+        this.material[1].dispose();
+      }
+    }]);
+
+    return PositionalAudioHelper;
+  }(_three.Line);
+
+  _exports.PositionalAudioHelper = PositionalAudioHelper;
+});

data/lib-opal/js_wrap/three/helpers/RectAreaLightHelper.js

@@ -0,0 +1,115 @@
+(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.RectAreaLightHelper = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.RectAreaLightHelper = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 _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); }
+
+  /**
+   *  This helper must be added as a child of the light
+   */
+  var RectAreaLightHelper = /*#__PURE__*/function (_Line) {
+    _inherits(RectAreaLightHelper, _Line);
+
+    var _super = _createSuper(RectAreaLightHelper);
+
+    function RectAreaLightHelper(light, color) {
+      var _this;
+
+      _classCallCheck(this, RectAreaLightHelper);
+
+      var positions = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, -1, 0, 1, 1, 0];
+      var geometry = new _three.BufferGeometry();
+      geometry.setAttribute('position', new _three.Float32BufferAttribute(positions, 3));
+      geometry.computeBoundingSphere();
+      var material = new _three.LineBasicMaterial({
+        fog: false
+      });
+      _this = _super.call(this, geometry, material);
+      _this.light = light;
+      _this.color = color; // optional hardwired color for the helper
+
+      _this.type = 'RectAreaLightHelper'; //
+
+      var positions2 = [1, 1, 0, -1, 1, 0, -1, -1, 0, 1, 1, 0, -1, -1, 0, 1, -1, 0];
+      var geometry2 = new _three.BufferGeometry();
+      geometry2.setAttribute('position', new _three.Float32BufferAttribute(positions2, 3));
+      geometry2.computeBoundingSphere();
+
+      _this.add(new _three.Mesh(geometry2, new _three.MeshBasicMaterial({
+        side: _three.BackSide,
+        fog: false
+      })));
+
+      return _this;
+    }
+
+    _createClass(RectAreaLightHelper, [{
+      key: "updateMatrixWorld",
+      value: function updateMatrixWorld() {
+        this.scale.set(0.5 * this.light.width, 0.5 * this.light.height, 1);
+
+        if (this.color !== undefined) {
+          this.material.color.set(this.color);
+          this.children[0].material.color.set(this.color);
+        } else {
+          this.material.color.copy(this.light.color).multiplyScalar(this.light.intensity); // prevent hue shift
+
+          var c = this.material.color;
+          var max = Math.max(c.r, c.g, c.b);
+          if (max > 1) c.multiplyScalar(1 / max);
+          this.children[0].material.color.copy(this.material.color);
+        } // ignore world scale on light
+
+
+        this.matrixWorld.extractRotation(this.light.matrixWorld).scale(this.scale).copyPosition(this.light.matrixWorld);
+        this.children[0].matrixWorld.copy(this.matrixWorld);
+      }
+    }, {
+      key: "dispose",
+      value: function dispose() {
+        this.geometry.dispose();
+        this.material.dispose();
+        this.children[0].geometry.dispose();
+        this.children[0].material.dispose();
+      }
+    }]);
+
+    return RectAreaLightHelper;
+  }(_three.Line);
+
+  _exports.RectAreaLightHelper = RectAreaLightHelper;
+});

data/lib-opal/js_wrap/three/helpers/VertexNormalsHelper.js

@@ -0,0 +1,131 @@
+(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.VertexNormalsHelper = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.VertexNormalsHelper = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 _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 _v1 = new _three.Vector3();
+
+  var _v2 = new _three.Vector3();
+
+  var _normalMatrix = new _three.Matrix3();
+
+  var VertexNormalsHelper = /*#__PURE__*/function (_LineSegments) {
+    _inherits(VertexNormalsHelper, _LineSegments);
+
+    var _super = _createSuper(VertexNormalsHelper);
+
+    function VertexNormalsHelper(object) {
+      var _this;
+
+      var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var color = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0xff0000;
+
+      _classCallCheck(this, VertexNormalsHelper);
+
+      var nNormals = 0;
+      var objGeometry = object.geometry;
+
+      if (objGeometry && objGeometry.isGeometry) {
+        console.error('THREE.VertexNormalsHelper no longer supports Geometry. Use BufferGeometry instead.');
+        return _possibleConstructorReturn(_this);
+      } else if (objGeometry && objGeometry.isBufferGeometry) {
+        nNormals = objGeometry.attributes.normal.count;
+      } //
+
+
+      var geometry = new _three.BufferGeometry();
+      var positions = new _three.Float32BufferAttribute(nNormals * 2 * 3, 3);
+      geometry.setAttribute('position', positions);
+      _this = _super.call(this, geometry, new _three.LineBasicMaterial({
+        color: color,
+        toneMapped: false
+      }));
+      _this.object = object;
+      _this.size = size;
+      _this.type = 'VertexNormalsHelper'; //
+
+      _this.matrixAutoUpdate = false;
+
+      _this.update();
+
+      return _this;
+    }
+
+    _createClass(VertexNormalsHelper, [{
+      key: "update",
+      value: function update() {
+        this.object.updateMatrixWorld(true);
+
+        _normalMatrix.getNormalMatrix(this.object.matrixWorld);
+
+        var matrixWorld = this.object.matrixWorld;
+        var position = this.geometry.attributes.position; //
+
+        var objGeometry = this.object.geometry;
+
+        if (objGeometry && objGeometry.isGeometry) {
+          console.error('THREE.VertexNormalsHelper no longer supports Geometry. Use BufferGeometry instead.');
+          return;
+        } else if (objGeometry && objGeometry.isBufferGeometry) {
+          var objPos = objGeometry.attributes.position;
+          var objNorm = objGeometry.attributes.normal;
+          var idx = 0; // for simplicity, ignore index and drawcalls, and render every normal
+
+          for (var j = 0, jl = objPos.count; j < jl; j++) {
+            _v1.set(objPos.getX(j), objPos.getY(j), objPos.getZ(j)).applyMatrix4(matrixWorld);
+
+            _v2.set(objNorm.getX(j), objNorm.getY(j), objNorm.getZ(j));
+
+            _v2.applyMatrix3(_normalMatrix).normalize().multiplyScalar(this.size).add(_v1);
+
+            position.setXYZ(idx, _v1.x, _v1.y, _v1.z);
+            idx = idx + 1;
+            position.setXYZ(idx, _v2.x, _v2.y, _v2.z);
+            idx = idx + 1;
+          }
+        }
+
+        position.needsUpdate = true;
+      }
+    }]);
+
+    return VertexNormalsHelper;
+  }(_three.LineSegments);
+
+  _exports.VertexNormalsHelper = VertexNormalsHelper;
+});

data/lib-opal/js_wrap/three/helpers/VertexTangentsHelper.js

@@ -0,0 +1,118 @@
+(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.VertexTangentsHelper = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.VertexTangentsHelper = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  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 _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 _v1 = new _three.Vector3();
+
+  var _v2 = new _three.Vector3();
+
+  var VertexTangentsHelper = /*#__PURE__*/function (_LineSegments) {
+    _inherits(VertexTangentsHelper, _LineSegments);
+
+    var _super = _createSuper(VertexTangentsHelper);
+
+    function VertexTangentsHelper(object) {
+      var _this;
+
+      var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+      var color = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0x00ffff;
+
+      _classCallCheck(this, VertexTangentsHelper);
+
+      var objGeometry = object.geometry;
+
+      if (!(objGeometry && objGeometry.isBufferGeometry)) {
+        console.error('THREE.VertexTangentsHelper: geometry not an instance of THREE.BufferGeometry.', objGeometry);
+        return _possibleConstructorReturn(_this);
+      }
+
+      var nTangents = objGeometry.attributes.tangent.count; //
+
+      var geometry = new _three.BufferGeometry();
+      var positions = new _three.Float32BufferAttribute(nTangents * 2 * 3, 3);
+      geometry.setAttribute('position', positions);
+      _this = _super.call(this, geometry, new _three.LineBasicMaterial({
+        color: color,
+        toneMapped: false
+      }));
+      _this.object = object;
+      _this.size = size;
+      _this.type = 'VertexTangentsHelper'; //
+
+      _this.matrixAutoUpdate = false;
+
+      _this.update();
+
+      return _this;
+    }
+
+    _createClass(VertexTangentsHelper, [{
+      key: "update",
+      value: function update() {
+        this.object.updateMatrixWorld(true);
+        var matrixWorld = this.object.matrixWorld;
+        var position = this.geometry.attributes.position; //
+
+        var objGeometry = this.object.geometry;
+        var objPos = objGeometry.attributes.position;
+        var objTan = objGeometry.attributes.tangent;
+        var idx = 0; // for simplicity, ignore index and drawcalls, and render every tangent
+
+        for (var j = 0, jl = objPos.count; j < jl; j++) {
+          _v1.set(objPos.getX(j), objPos.getY(j), objPos.getZ(j)).applyMatrix4(matrixWorld);
+
+          _v2.set(objTan.getX(j), objTan.getY(j), objTan.getZ(j));
+
+          _v2.transformDirection(matrixWorld).multiplyScalar(this.size).add(_v1);
+
+          position.setXYZ(idx, _v1.x, _v1.y, _v1.z);
+          idx = idx + 1;
+          position.setXYZ(idx, _v2.x, _v2.y, _v2.z);
+          idx = idx + 1;
+        }
+
+        position.needsUpdate = true;
+      }
+    }]);
+
+    return VertexTangentsHelper;
+  }(_three.LineSegments);
+
+  _exports.VertexTangentsHelper = VertexTangentsHelper;
+});