three-stdlib 2.15.1 → 2.16.0

package/misc/RollerCoaster.mjs

@@ -0,0 +1,346 @@
+import { BufferGeometry, Vector3, Quaternion, BufferAttribute, Raycaster } from "three";
+var RollerCoasterGeometry = function(curve, divisions) {
+  BufferGeometry.call(this);
+  var vertices = [];
+  var normals = [];
+  var colors = [];
+  var color1 = [1, 1, 1];
+  var color2 = [1, 1, 0];
+  var up = new Vector3(0, 1, 0);
+  var forward = new Vector3();
+  var right = new Vector3();
+  var quaternion = new Quaternion();
+  var prevQuaternion = new Quaternion();
+  prevQuaternion.setFromAxisAngle(up, Math.PI / 2);
+  var point = new Vector3();
+  var prevPoint = new Vector3();
+  prevPoint.copy(curve.getPointAt(0));
+  var step = [
+    new Vector3(-0.225, 0, 0),
+    new Vector3(0, -0.05, 0),
+    new Vector3(0, -0.175, 0),
+    new Vector3(0, -0.05, 0),
+    new Vector3(0.225, 0, 0),
+    new Vector3(0, -0.175, 0)
+  ];
+  var PI2 = Math.PI * 2;
+  var sides = 5;
+  var tube1 = [];
+  for (let i = 0; i < sides; i++) {
+    var angle = i / sides * PI2;
+    tube1.push(new Vector3(Math.sin(angle) * 0.06, Math.cos(angle) * 0.06, 0));
+  }
+  var sides = 6;
+  var tube2 = [];
+  for (let i = 0; i < sides; i++) {
+    var angle = i / sides * PI2;
+    tube2.push(new Vector3(Math.sin(angle) * 0.025, Math.cos(angle) * 0.025, 0));
+  }
+  var vector = new Vector3();
+  var normal = new Vector3();
+  function drawShape(shape, color) {
+    normal.set(0, 0, -1).applyQuaternion(quaternion);
+    for (let 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 (let 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 Vector3();
+  var vector2 = new Vector3();
+  var vector3 = new Vector3();
+  var vector4 = new Vector3();
+  var normal1 = new Vector3();
+  var normal2 = new Vector3();
+  var normal3 = new Vector3();
+  var normal4 = new Vector3();
+  function extrudeShape(shape, offset2, color) {
+    for (let j = 0, jl = shape.length; j < jl; j++) {
+      var point1 = shape[j];
+      var point2 = shape[(j + 1) % jl];
+      vector1.copy(point1).add(offset2);
+      vector1.applyQuaternion(quaternion);
+      vector1.add(point);
+      vector2.copy(point2).add(offset2);
+      vector2.applyQuaternion(quaternion);
+      vector2.add(point);
+      vector3.copy(point2).add(offset2);
+      vector3.applyQuaternion(prevQuaternion);
+      vector3.add(prevPoint);
+      vector4.copy(point1).add(offset2);
+      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 Vector3();
+  for (let i = 1; i <= divisions; i++) {
+    point.copy(curve.getPointAt(i / divisions));
+    up.set(0, 1, 0);
+    forward.subVectors(point, prevPoint).normalize();
+    right.crossVectors(up, forward).normalize();
+    up.crossVectors(forward, right);
+    var angle = Math.atan2(forward.x, forward.z);
+    quaternion.setFromAxisAngle(up, angle);
+    if (i % 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);
+  }
+  this.setAttribute("position", new BufferAttribute(new Float32Array(vertices), 3));
+  this.setAttribute("normal", new BufferAttribute(new Float32Array(normals), 3));
+  this.setAttribute("color", new BufferAttribute(new Float32Array(colors), 3));
+};
+RollerCoasterGeometry.prototype = Object.create(BufferGeometry.prototype);
+var RollerCoasterLiftersGeometry = function(curve, divisions) {
+  BufferGeometry.call(this);
+  var vertices = [];
+  var normals = [];
+  var quaternion = new Quaternion();
+  var up = new Vector3(0, 1, 0);
+  var point = new Vector3();
+  var tangent = new Vector3();
+  var tube1 = [new Vector3(0, 0.05, -0.05), new Vector3(0, 0.05, 0.05), new Vector3(0, -0.05, 0)];
+  var tube2 = [new Vector3(-0.05, 0, 0.05), new Vector3(-0.05, 0, -0.05), new Vector3(0.05, 0, 0)];
+  var tube3 = [new Vector3(0.05, 0, -0.05), new Vector3(0.05, 0, 0.05), new Vector3(-0.05, 0, 0)];
+  var vector1 = new Vector3();
+  var vector2 = new Vector3();
+  var vector3 = new Vector3();
+  var vector4 = new Vector3();
+  var normal1 = new Vector3();
+  var normal2 = new Vector3();
+  var normal3 = new Vector3();
+  var normal4 = new Vector3();
+  function extrudeShape(shape, fromPoint2, toPoint2) {
+    for (let 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(fromPoint2);
+      vector2.copy(point2);
+      vector2.applyQuaternion(quaternion);
+      vector2.add(fromPoint2);
+      vector3.copy(point2);
+      vector3.applyQuaternion(quaternion);
+      vector3.add(toPoint2);
+      vector4.copy(point1);
+      vector4.applyQuaternion(quaternion);
+      vector4.add(toPoint2);
+      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 Vector3();
+  var toPoint = new Vector3();
+  for (let 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);
+    }
+  }
+  this.setAttribute("position", new BufferAttribute(new Float32Array(vertices), 3));
+  this.setAttribute("normal", new BufferAttribute(new Float32Array(normals), 3));
+};
+RollerCoasterLiftersGeometry.prototype = Object.create(BufferGeometry.prototype);
+var RollerCoasterShadowGeometry = function(curve, divisions) {
+  BufferGeometry.call(this);
+  var vertices = [];
+  var up = new Vector3(0, 1, 0);
+  var forward = new Vector3();
+  var quaternion = new Quaternion();
+  var prevQuaternion = new Quaternion();
+  prevQuaternion.setFromAxisAngle(up, Math.PI / 2);
+  var point = new Vector3();
+  var prevPoint = new Vector3();
+  prevPoint.copy(curve.getPointAt(0));
+  prevPoint.y = 0;
+  var vector1 = new Vector3();
+  var vector2 = new Vector3();
+  var vector3 = new Vector3();
+  var vector4 = new Vector3();
+  for (let 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);
+  }
+  this.setAttribute("position", new BufferAttribute(new Float32Array(vertices), 3));
+};
+RollerCoasterShadowGeometry.prototype = Object.create(BufferGeometry.prototype);
+var SkyGeometry = function() {
+  BufferGeometry.call(this);
+  var vertices = [];
+  for (let 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);
+  }
+  this.setAttribute("position", new BufferAttribute(new Float32Array(vertices), 3));
+};
+SkyGeometry.prototype = Object.create(BufferGeometry.prototype);
+var TreesGeometry = function(landscape) {
+  BufferGeometry.call(this);
+  var vertices = [];
+  var colors = [];
+  var raycaster = new Raycaster();
+  raycaster.ray.direction.set(0, -1, 0);
+  for (let i = 0; i < 2e3; 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 (let j = 0; j < 6; j++) {
+      colors.push(0.2 + random, 0.4 + random, 0);
+    }
+  }
+  this.setAttribute("position", new BufferAttribute(new Float32Array(vertices), 3));
+  this.setAttribute("color", new BufferAttribute(new Float32Array(colors), 3));
+};
+TreesGeometry.prototype = Object.create(BufferGeometry.prototype);
+export {
+  RollerCoasterGeometry,
+  RollerCoasterLiftersGeometry,
+  RollerCoasterShadowGeometry,
+  SkyGeometry,
+  TreesGeometry
+};

package/misc/TubePainter.js

@@ -1,103 +1,90 @@
-import { BufferAttribute, DynamicDrawUsage, BufferGeometry, MeshStandardMaterial, Mesh, Vector3, Color, Matrix4 } from 'three';
-
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
 function TubePainter() {
-  const BUFFER_SIZE = 1000000 * 3;
-  const positions = new BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
-  positions.usage = DynamicDrawUsage;
-  const normals = new BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
-  normals.usage = DynamicDrawUsage;
-  const colors = new BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
-  colors.usage = DynamicDrawUsage;
-  const geometry = new BufferGeometry();
-  geometry.setAttribute('position', positions);
-  geometry.setAttribute('normal', normals);
-  geometry.setAttribute('color', colors);
+  const BUFFER_SIZE = 1e6 * 3;
+  const positions = new THREE.BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+  positions.usage = THREE.DynamicDrawUsage;
+  const normals = new THREE.BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+  normals.usage = THREE.DynamicDrawUsage;
+  const colors = new THREE.BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+  colors.usage = THREE.DynamicDrawUsage;
+  const geometry = new THREE.BufferGeometry();
+  geometry.setAttribute("position", positions);
+  geometry.setAttribute("normal", normals);
+  geometry.setAttribute("color", colors);
   geometry.drawRange.count = 0;
-  const material = new MeshStandardMaterial({
+  const material = new THREE.MeshStandardMaterial({
     vertexColors: true
   });
-  const mesh = new Mesh(geometry, material);
-  mesh.frustumCulled = false; //
-
-  function getPoints(size) {
+  const mesh = new THREE.Mesh(geometry, material);
+  mesh.frustumCulled = false;
+  function getPoints(size2) {
     const PI2 = Math.PI * 2;
     const sides = 10;
     const array = [];
-    const radius = 0.01 * size;
-
+    const radius = 0.01 * size2;
     for (let i = 0; i < sides; i++) {
       const angle = i / sides * PI2;
-      array.push(new Vector3(Math.sin(angle) * radius, Math.cos(angle) * radius, 0));
+      array.push(new THREE.Vector3(Math.sin(angle) * radius, Math.cos(angle) * radius, 0));
     }
-
     return array;
-  } //
-
-
-  const vector1 = new Vector3();
-  const vector2 = new Vector3();
-  const vector3 = new Vector3();
-  const vector4 = new Vector3();
-  const color = new Color(0xffffff);
+  }
+  const vector1 = new THREE.Vector3();
+  const vector2 = new THREE.Vector3();
+  const vector3 = new THREE.Vector3();
+  const vector4 = new THREE.Vector3();
+  const color = new THREE.Color(16777215);
   let size = 1;
-
-  function stroke(position1, position2, matrix1, matrix2) {
-    if (position1.distanceToSquared(position2) === 0) return;
-    let count = geometry.drawRange.count;
+  function stroke(position1, position2, matrix12, matrix22) {
+    if (position1.distanceToSquared(position2) === 0)
+      return;
+    let count2 = geometry.drawRange.count;
     const points = getPoints(size);
-
     for (let i = 0, il = points.length; i < il; i++) {
       const vertex1 = points[i];
-      const 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;
+      const vertex2 = points[(i + 1) % il];
+      vector1.copy(vertex1).applyMatrix4(matrix22).add(position2);
+      vector2.copy(vertex2).applyMatrix4(matrix22).add(position2);
+      vector3.copy(vertex2).applyMatrix4(matrix12).add(position1);
+      vector4.copy(vertex1).applyMatrix4(matrix12).add(position1);
+      vector1.toArray(positions.array, (count2 + 0) * 3);
+      vector2.toArray(positions.array, (count2 + 1) * 3);
+      vector4.toArray(positions.array, (count2 + 2) * 3);
+      vector2.toArray(positions.array, (count2 + 3) * 3);
+      vector3.toArray(positions.array, (count2 + 4) * 3);
+      vector4.toArray(positions.array, (count2 + 5) * 3);
+      vector1.copy(vertex1).applyMatrix4(matrix22).normalize();
+      vector2.copy(vertex2).applyMatrix4(matrix22).normalize();
+      vector3.copy(vertex2).applyMatrix4(matrix12).normalize();
+      vector4.copy(vertex1).applyMatrix4(matrix12).normalize();
+      vector1.toArray(normals.array, (count2 + 0) * 3);
+      vector2.toArray(normals.array, (count2 + 1) * 3);
+      vector4.toArray(normals.array, (count2 + 2) * 3);
+      vector2.toArray(normals.array, (count2 + 3) * 3);
+      vector3.toArray(normals.array, (count2 + 4) * 3);
+      vector4.toArray(normals.array, (count2 + 5) * 3);
+      color.toArray(colors.array, (count2 + 0) * 3);
+      color.toArray(colors.array, (count2 + 1) * 3);
+      color.toArray(colors.array, (count2 + 2) * 3);
+      color.toArray(colors.array, (count2 + 3) * 3);
+      color.toArray(colors.array, (count2 + 4) * 3);
+      color.toArray(colors.array, (count2 + 5) * 3);
+      count2 += 6;
     }
-
-    geometry.drawRange.count = count;
-  } //
-
-
-  const up = new Vector3(0, 1, 0);
-  const point1 = new Vector3();
-  const point2 = new Vector3();
-  const matrix1 = new Matrix4();
-  const matrix2 = new Matrix4();
-
+    geometry.drawRange.count = count2;
+  }
+  const up = new THREE.Vector3(0, 1, 0);
+  const point1 = new THREE.Vector3();
+  const point2 = new THREE.Vector3();
+  const matrix1 = new THREE.Matrix4();
+  const 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);
@@ -105,18 +92,15 @@ function TubePainter() {
     point2.copy(point1);
     matrix2.copy(matrix1);
   }
-
   function setSize(value) {
     size = value;
-  } //
-
-
+  }
   let count = 0;
-
   function update() {
     const start = count;
     const end = geometry.drawRange.count;
-    if (start === end) return;
+    if (start === end)
+      return;
     positions.updateRange.offset = start * 3;
     positions.updateRange.count = (end - start) * 3;
     positions.needsUpdate = true;
@@ -128,14 +112,12 @@ function TubePainter() {
     colors.needsUpdate = true;
     count = geometry.drawRange.count;
   }
-
   return {
-    mesh: mesh,
-    moveTo: moveTo,
-    lineTo: lineTo,
-    setSize: setSize,
-    update: update
+    mesh,
+    moveTo,
+    lineTo,
+    setSize,
+    update
   };
 }
-
-export { TubePainter };
+exports.TubePainter = TubePainter;

package/misc/TubePainter.mjs

@@ -0,0 +1,123 @@
+import { BufferAttribute, DynamicDrawUsage, BufferGeometry, MeshStandardMaterial, Mesh, Vector3, Color, Matrix4 } from "three";
+function TubePainter() {
+  const BUFFER_SIZE = 1e6 * 3;
+  const positions = new BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+  positions.usage = DynamicDrawUsage;
+  const normals = new BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+  normals.usage = DynamicDrawUsage;
+  const colors = new BufferAttribute(new Float32Array(BUFFER_SIZE), 3);
+  colors.usage = DynamicDrawUsage;
+  const geometry = new BufferGeometry();
+  geometry.setAttribute("position", positions);
+  geometry.setAttribute("normal", normals);
+  geometry.setAttribute("color", colors);
+  geometry.drawRange.count = 0;
+  const material = new MeshStandardMaterial({
+    vertexColors: true
+  });
+  const mesh = new Mesh(geometry, material);
+  mesh.frustumCulled = false;
+  function getPoints(size2) {
+    const PI2 = Math.PI * 2;
+    const sides = 10;
+    const array = [];
+    const radius = 0.01 * size2;
+    for (let i = 0; i < sides; i++) {
+      const angle = i / sides * PI2;
+      array.push(new Vector3(Math.sin(angle) * radius, Math.cos(angle) * radius, 0));
+    }
+    return array;
+  }
+  const vector1 = new Vector3();
+  const vector2 = new Vector3();
+  const vector3 = new Vector3();
+  const vector4 = new Vector3();
+  const color = new Color(16777215);
+  let size = 1;
+  function stroke(position1, position2, matrix12, matrix22) {
+    if (position1.distanceToSquared(position2) === 0)
+      return;
+    let count2 = geometry.drawRange.count;
+    const points = getPoints(size);
+    for (let i = 0, il = points.length; i < il; i++) {
+      const vertex1 = points[i];
+      const vertex2 = points[(i + 1) % il];
+      vector1.copy(vertex1).applyMatrix4(matrix22).add(position2);
+      vector2.copy(vertex2).applyMatrix4(matrix22).add(position2);
+      vector3.copy(vertex2).applyMatrix4(matrix12).add(position1);
+      vector4.copy(vertex1).applyMatrix4(matrix12).add(position1);
+      vector1.toArray(positions.array, (count2 + 0) * 3);
+      vector2.toArray(positions.array, (count2 + 1) * 3);
+      vector4.toArray(positions.array, (count2 + 2) * 3);
+      vector2.toArray(positions.array, (count2 + 3) * 3);
+      vector3.toArray(positions.array, (count2 + 4) * 3);
+      vector4.toArray(positions.array, (count2 + 5) * 3);
+      vector1.copy(vertex1).applyMatrix4(matrix22).normalize();
+      vector2.copy(vertex2).applyMatrix4(matrix22).normalize();
+      vector3.copy(vertex2).applyMatrix4(matrix12).normalize();
+      vector4.copy(vertex1).applyMatrix4(matrix12).normalize();
+      vector1.toArray(normals.array, (count2 + 0) * 3);
+      vector2.toArray(normals.array, (count2 + 1) * 3);
+      vector4.toArray(normals.array, (count2 + 2) * 3);
+      vector2.toArray(normals.array, (count2 + 3) * 3);
+      vector3.toArray(normals.array, (count2 + 4) * 3);
+      vector4.toArray(normals.array, (count2 + 5) * 3);
+      color.toArray(colors.array, (count2 + 0) * 3);
+      color.toArray(colors.array, (count2 + 1) * 3);
+      color.toArray(colors.array, (count2 + 2) * 3);
+      color.toArray(colors.array, (count2 + 3) * 3);
+      color.toArray(colors.array, (count2 + 4) * 3);
+      color.toArray(colors.array, (count2 + 5) * 3);
+      count2 += 6;
+    }
+    geometry.drawRange.count = count2;
+  }
+  const up = new Vector3(0, 1, 0);
+  const point1 = new Vector3();
+  const point2 = new Vector3();
+  const matrix1 = new Matrix4();
+  const matrix2 = new 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;
+  }
+  let count = 0;
+  function update() {
+    const start = count;
+    const 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,
+    moveTo,
+    lineTo,
+    setSize,
+    update
+  };
+}
+export {
+  TubePainter
+};