opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/misc/RollerCoaster.js

@@ -0,0 +1,489 @@
+(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.RollerCoaster = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.TreesGeometry = _exports.SkyGeometry = _exports.RollerCoasterShadowGeometry = _exports.RollerCoasterLiftersGeometry = _exports.RollerCoasterGeometry = 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 RollerCoasterGeometry = /*#__PURE__*/function (_BufferGeometry) {
+    _inherits(RollerCoasterGeometry, _BufferGeometry);
+
+    var _super = _createSuper(RollerCoasterGeometry);
+
+    function RollerCoasterGeometry(curve, divisions) {
+      var _this;
+
+      _classCallCheck(this, RollerCoasterGeometry);
+
+      _this = _super.call(this);
+      var vertices = [];
+      var normals = [];
+      var colors = [];
+      var color1 = [1, 1, 1];
+      var color2 = [1, 1, 0];
+      var up = new _three.Vector3(0, 1, 0);
+      var forward = new _three.Vector3();
+      var right = new _three.Vector3();
+      var quaternion = new _three.Quaternion();
+      var prevQuaternion = new _three.Quaternion();
+      prevQuaternion.setFromAxisAngle(up, Math.PI / 2);
+      var point = new _three.Vector3();
+      var prevPoint = new _three.Vector3();
+      prevPoint.copy(curve.getPointAt(0)); // shapes
+
+      var step = [new _three.Vector3(-0.225, 0, 0), new _three.Vector3(0, -0.050, 0), new _three.Vector3(0, -0.175, 0), new _three.Vector3(0, -0.050, 0), new _three.Vector3(0.225, 0, 0), new _three.Vector3(0, -0.175, 0)];
+      var PI2 = Math.PI * 2;
+      var sides = 5;
+      var tube1 = [];
+
+      for (var i = 0; i < sides; i++) {
+        var angle = i / sides * PI2;
+        tube1.push(new _three.Vector3(Math.sin(angle) * 0.06, Math.cos(angle) * 0.06, 0));
+      }
+
+      sides = 6;
+      var tube2 = [];
+
+      for (var _i = 0; _i < sides; _i++) {
+        var _angle = _i / sides * PI2;
+
+        tube2.push(new _three.Vector3(Math.sin(_angle) * 0.025, Math.cos(_angle) * 0.025, 0));
+      }
+
+      var vector = new _three.Vector3();
+      var normal = new _three.Vector3();
+
+      function drawShape(shape, color) {
+        normal.set(0, 0, -1).applyQuaternion(quaternion);
+
+        for (var j = 0; j < shape.length; j++) {
+          vector.copy(shape[j]);
+          vector.applyQuaternion(quaternion);
+          vector.add(point);
+          vertices.push(vector.x, vector.y, vector.z);
+          normals.push(normal.x, normal.y, normal.z);
+          colors.push(color[0], color[1], color[2]);
+        }
+
+        normal.set(0, 0, 1).applyQuaternion(quaternion);
+
+        for (var _j = shape.length - 1; _j >= 0; _j--) {
+          vector.copy(shape[_j]);
+          vector.applyQuaternion(quaternion);
+          vector.add(point);
+          vertices.push(vector.x, vector.y, vector.z);
+          normals.push(normal.x, normal.y, normal.z);
+          colors.push(color[0], color[1], color[2]);
+        }
+      }
+
+      var vector1 = new _three.Vector3();
+      var vector2 = new _three.Vector3();
+      var vector3 = new _three.Vector3();
+      var vector4 = new _three.Vector3();
+      var normal1 = new _three.Vector3();
+      var normal2 = new _three.Vector3();
+      var normal3 = new _three.Vector3();
+      var normal4 = new _three.Vector3();
+
+      function extrudeShape(shape, offset, color) {
+        for (var j = 0, jl = shape.length; j < jl; j++) {
+          var point1 = shape[j];
+          var point2 = shape[(j + 1) % jl];
+          vector1.copy(point1).add(offset);
+          vector1.applyQuaternion(quaternion);
+          vector1.add(point);
+          vector2.copy(point2).add(offset);
+          vector2.applyQuaternion(quaternion);
+          vector2.add(point);
+          vector3.copy(point2).add(offset);
+          vector3.applyQuaternion(prevQuaternion);
+          vector3.add(prevPoint);
+          vector4.copy(point1).add(offset);
+          vector4.applyQuaternion(prevQuaternion);
+          vector4.add(prevPoint);
+          vertices.push(vector1.x, vector1.y, vector1.z);
+          vertices.push(vector2.x, vector2.y, vector2.z);
+          vertices.push(vector4.x, vector4.y, vector4.z);
+          vertices.push(vector2.x, vector2.y, vector2.z);
+          vertices.push(vector3.x, vector3.y, vector3.z);
+          vertices.push(vector4.x, vector4.y, vector4.z); //
+
+          normal1.copy(point1);
+          normal1.applyQuaternion(quaternion);
+          normal1.normalize();
+          normal2.copy(point2);
+          normal2.applyQuaternion(quaternion);
+          normal2.normalize();
+          normal3.copy(point2);
+          normal3.applyQuaternion(prevQuaternion);
+          normal3.normalize();
+          normal4.copy(point1);
+          normal4.applyQuaternion(prevQuaternion);
+          normal4.normalize();
+          normals.push(normal1.x, normal1.y, normal1.z);
+          normals.push(normal2.x, normal2.y, normal2.z);
+          normals.push(normal4.x, normal4.y, normal4.z);
+          normals.push(normal2.x, normal2.y, normal2.z);
+          normals.push(normal3.x, normal3.y, normal3.z);
+          normals.push(normal4.x, normal4.y, normal4.z);
+          colors.push(color[0], color[1], color[2]);
+          colors.push(color[0], color[1], color[2]);
+          colors.push(color[0], color[1], color[2]);
+          colors.push(color[0], color[1], color[2]);
+          colors.push(color[0], color[1], color[2]);
+          colors.push(color[0], color[1], color[2]);
+        }
+      }
+
+      var offset = new _three.Vector3();
+
+      for (var _i2 = 1; _i2 <= divisions; _i2++) {
+        point.copy(curve.getPointAt(_i2 / divisions));
+        up.set(0, 1, 0);
+        forward.subVectors(point, prevPoint).normalize();
+        right.crossVectors(up, forward).normalize();
+        up.crossVectors(forward, right);
+
+        var _angle2 = Math.atan2(forward.x, forward.z);
+
+        quaternion.setFromAxisAngle(up, _angle2);
+
+        if (_i2 % 2 === 0) {
+          drawShape(step, color2);
+        }
+
+        extrudeShape(tube1, offset.set(0, -0.125, 0), color2);
+        extrudeShape(tube2, offset.set(0.2, 0, 0), color1);
+        extrudeShape(tube2, offset.set(-0.2, 0, 0), color1);
+        prevPoint.copy(point);
+        prevQuaternion.copy(quaternion);
+      } // console.log( vertices.length );
+
+
+      _this.setAttribute('position', new _three.BufferAttribute(new Float32Array(vertices), 3));
+
+      _this.setAttribute('normal', new _three.BufferAttribute(new Float32Array(normals), 3));
+
+      _this.setAttribute('color', new _three.BufferAttribute(new Float32Array(colors), 3));
+
+      return _this;
+    }
+
+    return _createClass(RollerCoasterGeometry);
+  }(_three.BufferGeometry);
+
+  _exports.RollerCoasterGeometry = RollerCoasterGeometry;
+
+  var RollerCoasterLiftersGeometry = /*#__PURE__*/function (_BufferGeometry2) {
+    _inherits(RollerCoasterLiftersGeometry, _BufferGeometry2);
+
+    var _super2 = _createSuper(RollerCoasterLiftersGeometry);
+
+    function RollerCoasterLiftersGeometry(curve, divisions) {
+      var _this2;
+
+      _classCallCheck(this, RollerCoasterLiftersGeometry);
+
+      _this2 = _super2.call(this);
+      var vertices = [];
+      var normals = [];
+      var quaternion = new _three.Quaternion();
+      var up = new _three.Vector3(0, 1, 0);
+      var point = new _three.Vector3();
+      var tangent = new _three.Vector3(); // shapes
+
+      var tube1 = [new _three.Vector3(0, 0.05, -0.05), new _three.Vector3(0, 0.05, 0.05), new _three.Vector3(0, -0.05, 0)];
+      var tube2 = [new _three.Vector3(-0.05, 0, 0.05), new _three.Vector3(-0.05, 0, -0.05), new _three.Vector3(0.05, 0, 0)];
+      var tube3 = [new _three.Vector3(0.05, 0, -0.05), new _three.Vector3(0.05, 0, 0.05), new _three.Vector3(-0.05, 0, 0)];
+      var vector1 = new _three.Vector3();
+      var vector2 = new _three.Vector3();
+      var vector3 = new _three.Vector3();
+      var vector4 = new _three.Vector3();
+      var normal1 = new _three.Vector3();
+      var normal2 = new _three.Vector3();
+      var normal3 = new _three.Vector3();
+      var normal4 = new _three.Vector3();
+
+      function extrudeShape(shape, fromPoint, toPoint) {
+        for (var j = 0, jl = shape.length; j < jl; j++) {
+          var point1 = shape[j];
+          var point2 = shape[(j + 1) % jl];
+          vector1.copy(point1);
+          vector1.applyQuaternion(quaternion);
+          vector1.add(fromPoint);
+          vector2.copy(point2);
+          vector2.applyQuaternion(quaternion);
+          vector2.add(fromPoint);
+          vector3.copy(point2);
+          vector3.applyQuaternion(quaternion);
+          vector3.add(toPoint);
+          vector4.copy(point1);
+          vector4.applyQuaternion(quaternion);
+          vector4.add(toPoint);
+          vertices.push(vector1.x, vector1.y, vector1.z);
+          vertices.push(vector2.x, vector2.y, vector2.z);
+          vertices.push(vector4.x, vector4.y, vector4.z);
+          vertices.push(vector2.x, vector2.y, vector2.z);
+          vertices.push(vector3.x, vector3.y, vector3.z);
+          vertices.push(vector4.x, vector4.y, vector4.z); //
+
+          normal1.copy(point1);
+          normal1.applyQuaternion(quaternion);
+          normal1.normalize();
+          normal2.copy(point2);
+          normal2.applyQuaternion(quaternion);
+          normal2.normalize();
+          normal3.copy(point2);
+          normal3.applyQuaternion(quaternion);
+          normal3.normalize();
+          normal4.copy(point1);
+          normal4.applyQuaternion(quaternion);
+          normal4.normalize();
+          normals.push(normal1.x, normal1.y, normal1.z);
+          normals.push(normal2.x, normal2.y, normal2.z);
+          normals.push(normal4.x, normal4.y, normal4.z);
+          normals.push(normal2.x, normal2.y, normal2.z);
+          normals.push(normal3.x, normal3.y, normal3.z);
+          normals.push(normal4.x, normal4.y, normal4.z);
+        }
+      }
+
+      var fromPoint = new _three.Vector3();
+      var toPoint = new _three.Vector3();
+
+      for (var i = 1; i <= divisions; i++) {
+        point.copy(curve.getPointAt(i / divisions));
+        tangent.copy(curve.getTangentAt(i / divisions));
+        var angle = Math.atan2(tangent.x, tangent.z);
+        quaternion.setFromAxisAngle(up, angle); //
+
+        if (point.y > 10) {
+          fromPoint.set(-0.75, -0.35, 0);
+          fromPoint.applyQuaternion(quaternion);
+          fromPoint.add(point);
+          toPoint.set(0.75, -0.35, 0);
+          toPoint.applyQuaternion(quaternion);
+          toPoint.add(point);
+          extrudeShape(tube1, fromPoint, toPoint);
+          fromPoint.set(-0.7, -0.3, 0);
+          fromPoint.applyQuaternion(quaternion);
+          fromPoint.add(point);
+          toPoint.set(-0.7, -point.y, 0);
+          toPoint.applyQuaternion(quaternion);
+          toPoint.add(point);
+          extrudeShape(tube2, fromPoint, toPoint);
+          fromPoint.set(0.7, -0.3, 0);
+          fromPoint.applyQuaternion(quaternion);
+          fromPoint.add(point);
+          toPoint.set(0.7, -point.y, 0);
+          toPoint.applyQuaternion(quaternion);
+          toPoint.add(point);
+          extrudeShape(tube3, fromPoint, toPoint);
+        } else {
+          fromPoint.set(0, -0.2, 0);
+          fromPoint.applyQuaternion(quaternion);
+          fromPoint.add(point);
+          toPoint.set(0, -point.y, 0);
+          toPoint.applyQuaternion(quaternion);
+          toPoint.add(point);
+          extrudeShape(tube3, fromPoint, toPoint);
+        }
+      }
+
+      _this2.setAttribute('position', new _three.BufferAttribute(new Float32Array(vertices), 3));
+
+      _this2.setAttribute('normal', new _three.BufferAttribute(new Float32Array(normals), 3));
+
+      return _this2;
+    }
+
+    return _createClass(RollerCoasterLiftersGeometry);
+  }(_three.BufferGeometry);
+
+  _exports.RollerCoasterLiftersGeometry = RollerCoasterLiftersGeometry;
+
+  var RollerCoasterShadowGeometry = /*#__PURE__*/function (_BufferGeometry3) {
+    _inherits(RollerCoasterShadowGeometry, _BufferGeometry3);
+
+    var _super3 = _createSuper(RollerCoasterShadowGeometry);
+
+    function RollerCoasterShadowGeometry(curve, divisions) {
+      var _this3;
+
+      _classCallCheck(this, RollerCoasterShadowGeometry);
+
+      _this3 = _super3.call(this);
+      var vertices = [];
+      var up = new _three.Vector3(0, 1, 0);
+      var forward = new _three.Vector3();
+      var quaternion = new _three.Quaternion();
+      var prevQuaternion = new _three.Quaternion();
+      prevQuaternion.setFromAxisAngle(up, Math.PI / 2);
+      var point = new _three.Vector3();
+      var prevPoint = new _three.Vector3();
+      prevPoint.copy(curve.getPointAt(0));
+      prevPoint.y = 0;
+      var vector1 = new _three.Vector3();
+      var vector2 = new _three.Vector3();
+      var vector3 = new _three.Vector3();
+      var vector4 = new _three.Vector3();
+
+      for (var i = 1; i <= divisions; i++) {
+        point.copy(curve.getPointAt(i / divisions));
+        point.y = 0;
+        forward.subVectors(point, prevPoint);
+        var angle = Math.atan2(forward.x, forward.z);
+        quaternion.setFromAxisAngle(up, angle);
+        vector1.set(-0.3, 0, 0);
+        vector1.applyQuaternion(quaternion);
+        vector1.add(point);
+        vector2.set(0.3, 0, 0);
+        vector2.applyQuaternion(quaternion);
+        vector2.add(point);
+        vector3.set(0.3, 0, 0);
+        vector3.applyQuaternion(prevQuaternion);
+        vector3.add(prevPoint);
+        vector4.set(-0.3, 0, 0);
+        vector4.applyQuaternion(prevQuaternion);
+        vector4.add(prevPoint);
+        vertices.push(vector1.x, vector1.y, vector1.z);
+        vertices.push(vector2.x, vector2.y, vector2.z);
+        vertices.push(vector4.x, vector4.y, vector4.z);
+        vertices.push(vector2.x, vector2.y, vector2.z);
+        vertices.push(vector3.x, vector3.y, vector3.z);
+        vertices.push(vector4.x, vector4.y, vector4.z);
+        prevPoint.copy(point);
+        prevQuaternion.copy(quaternion);
+      }
+
+      _this3.setAttribute('position', new _three.BufferAttribute(new Float32Array(vertices), 3));
+
+      return _this3;
+    }
+
+    return _createClass(RollerCoasterShadowGeometry);
+  }(_three.BufferGeometry);
+
+  _exports.RollerCoasterShadowGeometry = RollerCoasterShadowGeometry;
+
+  var SkyGeometry = /*#__PURE__*/function (_BufferGeometry4) {
+    _inherits(SkyGeometry, _BufferGeometry4);
+
+    var _super4 = _createSuper(SkyGeometry);
+
+    function SkyGeometry() {
+      var _this4;
+
+      _classCallCheck(this, SkyGeometry);
+
+      _this4 = _super4.call(this);
+      var vertices = [];
+
+      for (var i = 0; i < 100; i++) {
+        var x = Math.random() * 800 - 400;
+        var y = Math.random() * 50 + 50;
+        var z = Math.random() * 800 - 400;
+        var size = Math.random() * 40 + 20;
+        vertices.push(x - size, y, z - size);
+        vertices.push(x + size, y, z - size);
+        vertices.push(x - size, y, z + size);
+        vertices.push(x + size, y, z - size);
+        vertices.push(x + size, y, z + size);
+        vertices.push(x - size, y, z + size);
+      }
+
+      _this4.setAttribute('position', new _three.BufferAttribute(new Float32Array(vertices), 3));
+
+      return _this4;
+    }
+
+    return _createClass(SkyGeometry);
+  }(_three.BufferGeometry);
+
+  _exports.SkyGeometry = SkyGeometry;
+
+  var TreesGeometry = /*#__PURE__*/function (_BufferGeometry5) {
+    _inherits(TreesGeometry, _BufferGeometry5);
+
+    var _super5 = _createSuper(TreesGeometry);
+
+    function TreesGeometry(landscape) {
+      var _this5;
+
+      _classCallCheck(this, TreesGeometry);
+
+      _this5 = _super5.call(this);
+      var vertices = [];
+      var colors = [];
+      var raycaster = new _three.Raycaster();
+      raycaster.ray.direction.set(0, -1, 0);
+
+      for (var i = 0; i < 2000; i++) {
+        var x = Math.random() * 500 - 250;
+        var z = Math.random() * 500 - 250;
+        raycaster.ray.origin.set(x, 50, z);
+        var intersections = raycaster.intersectObject(landscape);
+        if (intersections.length === 0) continue;
+        var y = intersections[0].point.y;
+        var height = Math.random() * 5 + 0.5;
+        var angle = Math.random() * Math.PI * 2;
+        vertices.push(x + Math.sin(angle), y, z + Math.cos(angle));
+        vertices.push(x, y + height, z);
+        vertices.push(x + Math.sin(angle + Math.PI), y, z + Math.cos(angle + Math.PI));
+        angle += Math.PI / 2;
+        vertices.push(x + Math.sin(angle), y, z + Math.cos(angle));
+        vertices.push(x, y + height, z);
+        vertices.push(x + Math.sin(angle + Math.PI), y, z + Math.cos(angle + Math.PI));
+        var random = Math.random() * 0.1;
+
+        for (var j = 0; j < 6; j++) {
+          colors.push(0.2 + random, 0.4 + random, 0);
+        }
+      }
+
+      _this5.setAttribute('position', new _three.BufferAttribute(new Float32Array(vertices), 3));
+
+      _this5.setAttribute('color', new _three.BufferAttribute(new Float32Array(colors), 3));
+
+      return _this5;
+    }
+
+    return _createClass(TreesGeometry);
+  }(_three.BufferGeometry);
+
+  _exports.TreesGeometry = TreesGeometry;
+});

data/lib-opal/js_wrap/three/misc/TubePainter.js

@@ -0,0 +1,158 @@
+(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.TubePainter = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.TubePainter = TubePainter;
+
+  function TubePainter() {
+    var BUFFER_SIZE = 1000000 * 3;
+    var positions = new _three.BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+    positions.usage = _three.DynamicDrawUsage;
+    var normals = new _three.BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+    normals.usage = _three.DynamicDrawUsage;
+    var colors = new _three.BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+    colors.usage = _three.DynamicDrawUsage;
+    var geometry = new _three.BufferGeometry();
+    geometry.setAttribute('position', positions);
+    geometry.setAttribute('normal', normals);
+    geometry.setAttribute('color', colors);
+    geometry.drawRange.count = 0;
+    var material = new _three.MeshStandardMaterial({
+      vertexColors: true
+    });
+    var mesh = new _three.Mesh(geometry, material);
+    mesh.frustumCulled = false; //
+
+    function getPoints(size) {
+      var PI2 = Math.PI * 2;
+      var sides = 10;
+      var array = [];
+      var radius = 0.01 * size;
+
+      for (var i = 0; i < sides; i++) {
+        var angle = i / sides * PI2;
+        array.push(new _three.Vector3(Math.sin(angle) * radius, Math.cos(angle) * radius, 0));
+      }
+
+      return array;
+    } //
+
+
+    var vector1 = new _three.Vector3();
+    var vector2 = new _three.Vector3();
+    var vector3 = new _three.Vector3();
+    var vector4 = new _three.Vector3();
+    var color = new _three.Color(0xffffff);
+    var size = 1;
+
+    function stroke(position1, position2, matrix1, matrix2) {
+      if (position1.distanceToSquared(position2) === 0) return;
+      var count = geometry.drawRange.count;
+      var points = getPoints(size);
+
+      for (var i = 0, il = points.length; i < il; i++) {
+        var vertex1 = points[i];
+        var vertex2 = points[(i + 1) % il]; // positions
+
+        vector1.copy(vertex1).applyMatrix4(matrix2).add(position2);
+        vector2.copy(vertex2).applyMatrix4(matrix2).add(position2);
+        vector3.copy(vertex2).applyMatrix4(matrix1).add(position1);
+        vector4.copy(vertex1).applyMatrix4(matrix1).add(position1);
+        vector1.toArray(positions.array, (count + 0) * 3);
+        vector2.toArray(positions.array, (count + 1) * 3);
+        vector4.toArray(positions.array, (count + 2) * 3);
+        vector2.toArray(positions.array, (count + 3) * 3);
+        vector3.toArray(positions.array, (count + 4) * 3);
+        vector4.toArray(positions.array, (count + 5) * 3); // normals
+
+        vector1.copy(vertex1).applyMatrix4(matrix2).normalize();
+        vector2.copy(vertex2).applyMatrix4(matrix2).normalize();
+        vector3.copy(vertex2).applyMatrix4(matrix1).normalize();
+        vector4.copy(vertex1).applyMatrix4(matrix1).normalize();
+        vector1.toArray(normals.array, (count + 0) * 3);
+        vector2.toArray(normals.array, (count + 1) * 3);
+        vector4.toArray(normals.array, (count + 2) * 3);
+        vector2.toArray(normals.array, (count + 3) * 3);
+        vector3.toArray(normals.array, (count + 4) * 3);
+        vector4.toArray(normals.array, (count + 5) * 3); // colors
+
+        color.toArray(colors.array, (count + 0) * 3);
+        color.toArray(colors.array, (count + 1) * 3);
+        color.toArray(colors.array, (count + 2) * 3);
+        color.toArray(colors.array, (count + 3) * 3);
+        color.toArray(colors.array, (count + 4) * 3);
+        color.toArray(colors.array, (count + 5) * 3);
+        count += 6;
+      }
+
+      geometry.drawRange.count = count;
+    } //
+
+
+    var up = new _three.Vector3(0, 1, 0);
+    var point1 = new _three.Vector3();
+    var point2 = new _three.Vector3();
+    var matrix1 = new _three.Matrix4();
+    var matrix2 = new _three.Matrix4();
+
+    function moveTo(position) {
+      point1.copy(position);
+      matrix1.lookAt(point2, point1, up);
+      point2.copy(position);
+      matrix2.copy(matrix1);
+    }
+
+    function lineTo(position) {
+      point1.copy(position);
+      matrix1.lookAt(point2, point1, up);
+      stroke(point1, point2, matrix1, matrix2);
+      point2.copy(point1);
+      matrix2.copy(matrix1);
+    }
+
+    function setSize(value) {
+      size = value;
+    } //
+
+
+    var count = 0;
+
+    function update() {
+      var start = count;
+      var end = geometry.drawRange.count;
+      if (start === end) return;
+      positions.updateRange.offset = start * 3;
+      positions.updateRange.count = (end - start) * 3;
+      positions.needsUpdate = true;
+      normals.updateRange.offset = start * 3;
+      normals.updateRange.count = (end - start) * 3;
+      normals.needsUpdate = true;
+      colors.updateRange.offset = start * 3;
+      colors.updateRange.count = (end - start) * 3;
+      colors.needsUpdate = true;
+      count = geometry.drawRange.count;
+    }
+
+    return {
+      mesh: mesh,
+      moveTo: moveTo,
+      lineTo: lineTo,
+      setSize: setSize,
+      update: update
+    };
+  }
+});