three-stdlib 2.14.1 → 2.14.2

package/lines/LineSegments2.js

@@ -1,162 +1,309 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import { Mesh, Vector3, InstancedInterleavedBuffer, InterleavedBufferAttribute, Vector4, Matrix4, Line3, MathUtils } from 'three';
+import { Vector3, Vector4, Matrix4, Line3, Box3, Sphere, Mesh, InstancedInterleavedBuffer, InterleavedBufferAttribute, MathUtils } from 'three';
 import { LineSegmentsGeometry } from './LineSegmentsGeometry.js';
 import { LineMaterial } from './LineMaterial.js';
 
+const _start = new Vector3();
+
+const _end = new Vector3();
+
+const _start4 = new Vector4();
+
+const _end4 = new Vector4();
+
+const _ssOrigin = new Vector4();
+
+const _ssOrigin3 = new Vector3();
+
+const _mvMatrix = new Matrix4();
+
+const _line = new Line3();
+
+const _closestPoint = new Vector3();
+
+const _box = new Box3();
+
+const _sphere = new Sphere();
+
+const _clipToWorldVector = new Vector4();
+
+let _ray, _instanceStart, _instanceEnd, _lineWidth; // Returns the margin required to expand by in world space given the distance from the camera,
+// line width, resolution, and camera projection
+
+
+function getWorldSpaceHalfWidth(camera, distance, resolution) {
+  // transform into clip space, adjust the x and y values by the pixel width offset, then
+  // transform back into world space to get world offset. Note clip space is [-1, 1] so full
+  // width does not need to be halved.
+  _clipToWorldVector.set(0, 0, -distance, 1.0).applyMatrix4(camera.projectionMatrix);
+
+  _clipToWorldVector.multiplyScalar(1.0 / _clipToWorldVector.w);
+
+  _clipToWorldVector.x = _lineWidth / resolution.width;
+  _clipToWorldVector.y = _lineWidth / resolution.height;
+
+  _clipToWorldVector.applyMatrix4(camera.projectionMatrixInverse);
+
+  _clipToWorldVector.multiplyScalar(1.0 / _clipToWorldVector.w);
+
+  return Math.abs(Math.max(_clipToWorldVector.x, _clipToWorldVector.y));
+}
+
+function raycastWorldUnits(lineSegments, intersects) {
+  for (let i = 0, l = _instanceStart.count; i < l; i++) {
+    _line.start.fromBufferAttribute(_instanceStart, i);
+
+    _line.end.fromBufferAttribute(_instanceEnd, i);
+
+    const pointOnLine = new Vector3();
+    const point = new Vector3();
+
+    _ray.distanceSqToSegment(_line.start, _line.end, point, pointOnLine);
+
+    const isInside = point.distanceTo(pointOnLine) < _lineWidth * 0.5;
+
+    if (isInside) {
+      intersects.push({
+        point,
+        pointOnLine,
+        distance: _ray.origin.distanceTo(point),
+        object: lineSegments,
+        face: null,
+        faceIndex: i,
+        uv: null,
+        uv2: null
+      });
+    }
+  }
+}
+
+function raycastScreenSpace(lineSegments, camera, intersects) {
+  const projectionMatrix = camera.projectionMatrix;
+  const material = lineSegments.material;
+  const resolution = material.resolution;
+  const matrixWorld = lineSegments.matrixWorld;
+  const geometry = lineSegments.geometry;
+  const instanceStart = geometry.attributes.instanceStart;
+  const instanceEnd = geometry.attributes.instanceEnd;
+  const near = -camera.near; //
+  // pick a point 1 unit out along the ray to avoid the ray origin
+  // sitting at the camera origin which will cause "w" to be 0 when
+  // applying the projection matrix.
+
+  _ray.at(1, _ssOrigin); // ndc space [ - 1.0, 1.0 ]
+
+
+  _ssOrigin.w = 1;
+
+  _ssOrigin.applyMatrix4(camera.matrixWorldInverse);
+
+  _ssOrigin.applyMatrix4(projectionMatrix);
+
+  _ssOrigin.multiplyScalar(1 / _ssOrigin.w); // screen space
+
+
+  _ssOrigin.x *= resolution.x / 2;
+  _ssOrigin.y *= resolution.y / 2;
+  _ssOrigin.z = 0;
+
+  _ssOrigin3.copy(_ssOrigin);
+
+  _mvMatrix.multiplyMatrices(camera.matrixWorldInverse, matrixWorld);
+
+  for (let i = 0, l = instanceStart.count; i < l; i++) {
+    _start4.fromBufferAttribute(instanceStart, i);
+
+    _end4.fromBufferAttribute(instanceEnd, i);
+
+    _start4.w = 1;
+    _end4.w = 1; // camera space
+
+    _start4.applyMatrix4(_mvMatrix);
+
+    _end4.applyMatrix4(_mvMatrix); // skip the segment if it's entirely behind the camera
+
+
+    const isBehindCameraNear = _start4.z > near && _end4.z > near;
+
+    if (isBehindCameraNear) {
+      continue;
+    } // trim the segment if it extends behind camera near
+
+
+    if (_start4.z > near) {
+      const deltaDist = _start4.z - _end4.z;
+      const t = (_start4.z - near) / deltaDist;
+
+      _start4.lerp(_end4, t);
+    } else if (_end4.z > near) {
+      const deltaDist = _end4.z - _start4.z;
+      const t = (_end4.z - near) / deltaDist;
+
+      _end4.lerp(_start4, t);
+    } // clip space
+
+
+    _start4.applyMatrix4(projectionMatrix);
+
+    _end4.applyMatrix4(projectionMatrix); // ndc space [ - 1.0, 1.0 ]
+
+
+    _start4.multiplyScalar(1 / _start4.w);
+
+    _end4.multiplyScalar(1 / _end4.w); // screen space
+
+
+    _start4.x *= resolution.x / 2;
+    _start4.y *= resolution.y / 2;
+    _end4.x *= resolution.x / 2;
+    _end4.y *= resolution.y / 2; // create 2d segment
+
+    _line.start.copy(_start4);
+
+    _line.start.z = 0;
+
+    _line.end.copy(_end4);
+
+    _line.end.z = 0; // get closest point on ray to segment
+
+    const param = _line.closestPointToPointParameter(_ssOrigin3, true);
+
+    _line.at(param, _closestPoint); // check if the intersection point is within clip space
+
+
+    const zPos = MathUtils.lerp(_start4.z, _end4.z, param);
+    const isInClipSpace = zPos >= -1 && zPos <= 1;
+
+    const isInside = _ssOrigin3.distanceTo(_closestPoint) < _lineWidth * 0.5;
+
+    if (isInClipSpace && isInside) {
+      _line.start.fromBufferAttribute(instanceStart, i);
+
+      _line.end.fromBufferAttribute(instanceEnd, i);
+
+      _line.start.applyMatrix4(matrixWorld);
+
+      _line.end.applyMatrix4(matrixWorld);
+
+      const pointOnLine = new Vector3();
+      const point = new Vector3();
+
+      _ray.distanceSqToSegment(_line.start, _line.end, point, pointOnLine);
+
+      intersects.push({
+        point: point,
+        pointOnLine: pointOnLine,
+        distance: _ray.origin.distanceTo(point),
+        object: lineSegments,
+        face: null,
+        faceIndex: i,
+        uv: null,
+        uv2: null
+      });
+    }
+  }
+}
+
 class LineSegments2 extends Mesh {
-  constructor(_geometry = new LineSegmentsGeometry(), _material = new LineMaterial({
+  constructor(geometry = new LineSegmentsGeometry(), material = new LineMaterial({
     color: Math.random() * 0xffffff
   })) {
-    super(_geometry, _material);
+    super(geometry, material);
+    this.isLineSegments2 = true;
+    this.type = 'LineSegments2';
+  } // for backwards-compatibility, but could be a method of LineSegmentsGeometry...
 
-    _defineProperty(this, "type", 'LineSegments2');
 
-    _defineProperty(this, "isLineSegments2", true);
+  computeLineDistances() {
+    const geometry = this.geometry;
+    const instanceStart = geometry.attributes.instanceStart;
+    const instanceEnd = geometry.attributes.instanceEnd;
+    const lineDistances = new Float32Array(2 * instanceStart.count);
 
-    _defineProperty(this, "distStart", new Vector3());
+    for (let i = 0, j = 0, l = instanceStart.count; i < l; i++, j += 2) {
+      _start.fromBufferAttribute(instanceStart, i);
 
-    _defineProperty(this, "distEnd", new Vector3());
+      _end.fromBufferAttribute(instanceEnd, i);
 
-    _defineProperty(this, "computeLineDistances", () => {
-      const geometry = this.geometry;
-      const instanceStart = geometry.attributes.instanceStart;
-      const instanceEnd = geometry.attributes.instanceEnd;
-      const lineDistances = new Float32Array(2 * instanceStart.data.count);
+      lineDistances[j] = j === 0 ? 0 : lineDistances[j - 1];
+      lineDistances[j + 1] = lineDistances[j] + _start.distanceTo(_end);
+    }
 
-      for (let i = 0, j = 0, l = instanceStart.data.count; i < l; i++, j += 2) {
-        this.distStart.fromBufferAttribute(instanceStart, i);
-        this.distEnd.fromBufferAttribute(instanceEnd, i);
-        lineDistances[j] = j === 0 ? 0 : lineDistances[j - 1];
-        lineDistances[j + 1] = lineDistances[j] + this.distStart.distanceTo(this.distEnd);
-      }
+    const instanceDistanceBuffer = new InstancedInterleavedBuffer(lineDistances, 2, 1); // d0, d1
 
-      const instanceDistanceBuffer = new InstancedInterleavedBuffer(lineDistances, 2, 1); // d0, d1
+    geometry.setAttribute('instanceDistanceStart', new InterleavedBufferAttribute(instanceDistanceBuffer, 1, 0)); // d0
 
-      geometry.setAttribute('instanceDistanceStart', new InterleavedBufferAttribute(instanceDistanceBuffer, 1, 0)); // d0
+    geometry.setAttribute('instanceDistanceEnd', new InterleavedBufferAttribute(instanceDistanceBuffer, 1, 1)); // d1
 
-      geometry.setAttribute('instanceDistanceEnd', new InterleavedBufferAttribute(instanceDistanceBuffer, 1, 1)); // d1
-
-      return this;
-    });
+    return this;
+  }
 
-    _defineProperty(this, "rayStart", new Vector4());
+  raycast(raycaster, intersects) {
+    const worldUnits = this.material.worldUnits;
+    const camera = raycaster.camera;
 
-    _defineProperty(this, "rayEnd", new Vector4());
+    if (camera === null && !worldUnits) {
+      console.error('LineSegments2: "Raycaster.camera" needs to be set in order to raycast against LineSegments2 while worldUnits is set to false.');
+    }
 
-    _defineProperty(this, "ssOrigin", new Vector4());
+    const threshold = raycaster.params.Line2 !== undefined ? raycaster.params.Line2.threshold || 0 : 0;
+    _ray = raycaster.ray;
+    const matrixWorld = this.matrixWorld;
+    const geometry = this.geometry;
+    const material = this.material;
+    _lineWidth = material.linewidth + threshold;
+    _instanceStart = geometry.attributes.instanceStart;
+    _instanceEnd = geometry.attributes.instanceEnd; // check if we intersect the sphere bounds
 
-    _defineProperty(this, "ssOrigin3", new Vector3());
+    if (geometry.boundingSphere === null) {
+      geometry.computeBoundingSphere();
+    }
 
-    _defineProperty(this, "mvMatrix", new Matrix4());
+    _sphere.copy(geometry.boundingSphere).applyMatrix4(matrixWorld); // increase the sphere bounds by the worst case line screen space width
 
-    _defineProperty(this, "line", new Line3());
 
-    _defineProperty(this, "closestPoint", new Vector3());
+    let sphereMargin;
 
-    _defineProperty(this, "raycast", (raycaster, intersects) => {
-      if (raycaster.camera === null) {
-        console.error('LineSegments2: "Raycaster.camera" needs to be set in order to raycast against LineSegments2.');
-      }
+    if (worldUnits) {
+      sphereMargin = _lineWidth * 0.5;
+    } else {
+      const distanceToSphere = Math.max(camera.near, _sphere.distanceToPoint(_ray.origin));
+      sphereMargin = getWorldSpaceHalfWidth(camera, distanceToSphere, material.resolution);
+    }
 
-      const threshold = 0;
-      const ray = raycaster.ray;
-      const camera = raycaster.camera;
-      const projectionMatrix = camera.projectionMatrix;
-      const geometry = this.geometry;
-      const material = this.material;
-      const resolution = material.resolution;
-      const lineWidth = material.linewidth + threshold;
-      const instanceStart = geometry.attributes.instanceStart;
-      const instanceEnd = geometry.attributes.instanceEnd; // camera forward is negative
+    _sphere.radius += sphereMargin;
 
-      const near = -camera.near; // pick a point 1 unit out along the ray to avoid the ray origin
-      // sitting at the camera origin which will cause "w" to be 0 when
-      // applying the projection matrix.
+    if (_ray.intersectsSphere(_sphere) === false) {
+      return;
+    } // check if we intersect the box bounds
 
-      ray.at(1, this.ssOrigin); // ndc space [ - 1.0, 1.0 ]
 
-      this.ssOrigin.w = 1;
-      this.ssOrigin.applyMatrix4(camera.matrixWorldInverse);
-      this.ssOrigin.applyMatrix4(projectionMatrix);
-      this.ssOrigin.multiplyScalar(1 / this.ssOrigin.w); // screen space
+    if (geometry.boundingBox === null) {
+      geometry.computeBoundingBox();
+    }
 
-      this.ssOrigin.x *= resolution.x / 2;
-      this.ssOrigin.y *= resolution.y / 2;
-      this.ssOrigin.z = 0;
-      this.ssOrigin3.set(this.ssOrigin.x, this.ssOrigin.y, this.ssOrigin.z);
-      const matrixWorld = this.matrixWorld;
-      this.mvMatrix.multiplyMatrices(camera.matrixWorldInverse, matrixWorld);
+    _box.copy(geometry.boundingBox).applyMatrix4(matrixWorld); // increase the box bounds by the worst case line width
 
-      for (let i = 0, l = instanceStart.count; i < l; i++) {
-        this.rayStart.fromBufferAttribute(instanceStart, i);
-        this.rayEnd.fromBufferAttribute(instanceEnd, i);
-        this.rayStart.w = 1;
-        this.rayEnd.w = 1; // camera space
 
-        this.rayStart.applyMatrix4(this.mvMatrix);
-        this.rayEnd.applyMatrix4(this.mvMatrix); // skip the segment if it's entirely behind the camera
+    let boxMargin;
 
-        const isBehindCameraNear = this.rayStart.z > near && this.rayEnd.z > near;
+    if (worldUnits) {
+      boxMargin = _lineWidth * 0.5;
+    } else {
+      const distanceToBox = Math.max(camera.near, _box.distanceToPoint(_ray.origin));
+      boxMargin = getWorldSpaceHalfWidth(camera, distanceToBox, material.resolution);
+    }
 
-        if (isBehindCameraNear) {
-          continue;
-        } // trim the segment if it extends behind camera near
+    _box.expandByScalar(boxMargin);
 
+    if (_ray.intersectsBox(_box) === false) {
+      return;
+    }
 
-        if (this.rayStart.z > near) {
-          const deltaDist = this.rayStart.z - this.rayEnd.z;
-          const t = (this.rayStart.z - near) / deltaDist;
-          this.rayStart.lerp(this.rayEnd, t);
-        } else if (this.rayEnd.z > near) {
-          const deltaDist = this.rayEnd.z - this.rayStart.z;
-          const t = (this.rayEnd.z - near) / deltaDist;
-          this.rayEnd.lerp(this.rayStart, t);
-        } // clip space
-
-
-        this.rayStart.applyMatrix4(projectionMatrix);
-        this.rayEnd.applyMatrix4(projectionMatrix); // ndc space [ - 1.0, 1.0 ]
-
-        this.rayStart.multiplyScalar(1 / this.rayStart.w);
-        this.rayEnd.multiplyScalar(1 / this.rayEnd.w); // screen space
-
-        this.rayStart.x *= resolution.x / 2;
-        this.rayStart.y *= resolution.y / 2;
-        this.rayEnd.x *= resolution.x / 2;
-        this.rayEnd.y *= resolution.y / 2; // create 2d segment
-
-        this.line.start.set(this.rayStart.x, this.rayStart.y, this.rayStart.z);
-        this.line.start.z = 0;
-        this.line.end.set(this.rayEnd.x, this.rayEnd.y, this.rayEnd.z);
-        this.line.end.z = 0; // get closest point on ray to segment
-
-        const param = this.line.closestPointToPointParameter(this.ssOrigin3, true);
-        this.line.at(param, this.closestPoint); // check if the intersection point is within clip space
-
-        const zPos = MathUtils.lerp(this.rayStart.z, this.rayEnd.z, param);
-        const isInClipSpace = zPos >= -1 && zPos <= 1;
-        const isInside = this.ssOrigin3.distanceTo(this.closestPoint) < lineWidth * 0.5;
-
-        if (isInClipSpace && isInside) {
-          this.line.start.fromBufferAttribute(instanceStart, i);
-          this.line.end.fromBufferAttribute(instanceEnd, i);
-          this.line.start.applyMatrix4(matrixWorld);
-          this.line.end.applyMatrix4(matrixWorld);
-          const pointOnLine = new Vector3();
-          const point = new Vector3();
-          ray.distanceSqToSegment(this.line.start, this.line.end, point, pointOnLine);
-          intersects.push({
-            distance: ray.origin.distanceTo(point),
-            point: point,
-            face: null,
-            faceIndex: i,
-            object: this,
-            uv: undefined,
-            pointOnLine
-          });
-        }
-      }
-    });
+    if (worldUnits) {
+      raycastWorldUnits(this, intersects);
+    } else {
+      raycastScreenSpace(this, camera, intersects);
+    }
   }
 
 }

package/lines/LineSegmentsGeometry.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("@babel/runtime/helpers/defineProperty"),e=require("three");function r(t){return t&&"object"==typeof t&&"default"in t?t:{default:t}}var i=r(t);class n extends e.InstancedBufferGeometry{constructor(){super(),i.default(this,"isLineSegmentsGeometry",!0),i.default(this,"type","LineSegmentsGeometry"),i.default(this,"boundingBox",null),i.default(this,"boundingSphere",null),i.default(this,"box",new e.Box3),i.default(this,"vector",new e.Vector3);this.setIndex([0,2,1,2,3,1,2,4,3,4,5,3,4,6,5,6,7,5]),this.setAttribute("position",new e.Float32BufferAttribute([-1,2,0,1,2,0,-1,1,0,1,1,0,-1,0,0,1,0,0,-1,-1,0,1,-1,0],3)),this.setAttribute("uv",new e.Float32BufferAttribute([-1,2,1,2,-1,1,1,1,-1,-1,1,-1,-1,-2,1,-2],2))}applyMatrix4(t){const e=this.attributes.instanceStart,r=this.attributes.instanceEnd;return void 0!==e&&(e.applyMatrix4(t),r.applyMatrix4(t),e.needsUpdate=!0),null!==this.boundingBox&&this.computeBoundingBox(),null!==this.boundingSphere&&this.computeBoundingSphere(),this}setPositions(t){let r;if(t instanceof Float32Array)r=t;else{if(!Array.isArray(t))return console.error("LineSegmentsGeometry.setPosition requires either a Float32Array or regular array of numbers"),this;r=new Float32Array(t)}const i=new e.InstancedInterleavedBuffer(r,6,1);return this.setAttribute("instanceStart",new e.InterleavedBufferAttribute(i,3,0)),this.setAttribute("instanceEnd",new e.InterleavedBufferAttribute(i,3,3)),this.computeBoundingBox(),this.computeBoundingSphere(),this}setColors(t){let r;if(t instanceof Float32Array)r=t;else{if(!Array.isArray(t))return console.error("LineSegmentsGeometry.setColors requires either a Float32Array or regular array of numbers"),this;r=new Float32Array(t)}const i=new e.InstancedInterleavedBuffer(r,6,1);return this.setAttribute("instanceColorStart",new e.InterleavedBufferAttribute(i,3,0)),this.setAttribute("instanceColorEnd",new e.InterleavedBufferAttribute(i,3,3)),this}fromWireframeGeometry(t){return this.setPositions(Array.from(t.attributes.position.array)),this}fromEdgesGeometry(t){return this.setPositions(Array.from(t.attributes.position.array)),this}fromMesh(t){return this.fromWireframeGeometry(new e.WireframeGeometry(t.geometry)),this}fromLineSegments(t){const e=t.geometry;return e.isBufferGeometry&&this.setPositions(Array.from(e.attributes.position.array)),this}computeBoundingBox(){null===this.boundingBox&&(this.boundingBox=new e.Box3);const t=this.attributes.instanceStart,r=this.attributes.instanceEnd;void 0!==t&&void 0!==r&&(this.boundingBox.setFromBufferAttribute(t),this.box.setFromBufferAttribute(r),this.boundingBox.union(this.box))}computeBoundingSphere(){null===this.boundingSphere&&(this.boundingSphere=new e.Sphere),null===this.boundingBox&&this.computeBoundingBox();const t=this.attributes.instanceStart,r=this.attributes.instanceEnd;if(void 0!==t&&void 0!==r){const e=this.boundingSphere.center;this.boundingBox&&this.boundingBox.getCenter(e);let i=0;for(let n=0,s=t.count;n<s;n++)this.vector.fromBufferAttribute(t,n),i=Math.max(i,e.distanceToSquared(this.vector)),this.vector.fromBufferAttribute(r,n),i=Math.max(i,e.distanceToSquared(this.vector));this.boundingSphere.radius=Math.sqrt(i),isNaN(this.boundingSphere.radius)&&console.error("THREE.LineSegmentsGeometry.computeBoundingSphere(): Computed radius is NaN. The instanced position data is likely to have NaN values.",this)}}toJSON(){}}exports.LineSegmentsGeometry=n;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("three");const e=new t.Box3,r=new t.Vector3;class i extends t.InstancedBufferGeometry{constructor(){super(),this.isLineSegmentsGeometry=!0,this.type="LineSegmentsGeometry";this.setIndex([0,2,1,2,3,1,2,4,3,4,5,3,4,6,5,6,7,5]),this.setAttribute("position",new t.Float32BufferAttribute([-1,2,0,1,2,0,-1,1,0,1,1,0,-1,0,0,1,0,0,-1,-1,0,1,-1,0],3)),this.setAttribute("uv",new t.Float32BufferAttribute([-1,2,1,2,-1,1,1,1,-1,-1,1,-1,-1,-2,1,-2],2))}applyMatrix4(t){const e=this.attributes.instanceStart,r=this.attributes.instanceEnd;return void 0!==e&&(e.applyMatrix4(t),r.applyMatrix4(t),e.needsUpdate=!0),null!==this.boundingBox&&this.computeBoundingBox(),null!==this.boundingSphere&&this.computeBoundingSphere(),this}setPositions(e){let r;e instanceof Float32Array?r=e:Array.isArray(e)&&(r=new Float32Array(e));const i=new t.InstancedInterleavedBuffer(r,6,1);return this.setAttribute("instanceStart",new t.InterleavedBufferAttribute(i,3,0)),this.setAttribute("instanceEnd",new t.InterleavedBufferAttribute(i,3,3)),this.computeBoundingBox(),this.computeBoundingSphere(),this}setColors(e){let r;e instanceof Float32Array?r=e:Array.isArray(e)&&(r=new Float32Array(e));const i=new t.InstancedInterleavedBuffer(r,6,1);return this.setAttribute("instanceColorStart",new t.InterleavedBufferAttribute(i,3,0)),this.setAttribute("instanceColorEnd",new t.InterleavedBufferAttribute(i,3,3)),this}fromWireframeGeometry(t){return this.setPositions(t.attributes.position.array),this}fromEdgesGeometry(t){return this.setPositions(t.attributes.position.array),this}fromMesh(e){return this.fromWireframeGeometry(new t.WireframeGeometry(e.geometry)),this}fromLineSegments(t){const e=t.geometry;return this.setPositions(e.attributes.position.array),this}computeBoundingBox(){null===this.boundingBox&&(this.boundingBox=new t.Box3);const r=this.attributes.instanceStart,i=this.attributes.instanceEnd;void 0!==r&&void 0!==i&&(this.boundingBox.setFromBufferAttribute(r),e.setFromBufferAttribute(i),this.boundingBox.union(e))}computeBoundingSphere(){null===this.boundingSphere&&(this.boundingSphere=new t.Sphere),null===this.boundingBox&&this.computeBoundingBox();const e=this.attributes.instanceStart,i=this.attributes.instanceEnd;if(void 0!==e&&void 0!==i){const t=this.boundingSphere.center;this.boundingBox.getCenter(t);let n=0;for(let s=0,o=e.count;s<o;s++)r.fromBufferAttribute(e,s),n=Math.max(n,t.distanceToSquared(r)),r.fromBufferAttribute(i,s),n=Math.max(n,t.distanceToSquared(r));this.boundingSphere.radius=Math.sqrt(n),isNaN(this.boundingSphere.radius)&&console.error("THREE.LineSegmentsGeometry.computeBoundingSphere(): Computed radius is NaN. The instanced position data is likely to have NaN values.",this)}}toJSON(){}applyMatrix(t){return console.warn("THREE.LineSegmentsGeometry: applyMatrix() has been renamed to applyMatrix4()."),this.applyMatrix4(t)}}exports.LineSegmentsGeometry=i;

package/lines/LineSegmentsGeometry.d.ts

@@ -1,21 +1,23 @@
-import { Box3, BufferGeometry, InstancedBufferGeometry, LineSegments, Matrix4, Mesh, Sphere } from 'three';
-declare class LineSegmentsGeometry extends InstancedBufferGeometry {
-    readonly isLineSegmentsGeometry = true;
-    type: string;
-    boundingBox: Box3 | null;
-    boundingSphere: Sphere | null;
+import {
+    EdgesGeometry,
+    InstancedBufferGeometry,
+    LineSegments,
+    Matrix4,
+    Mesh,
+    WireframeGeometry,
+} from 'three';
+
+export class LineSegmentsGeometry extends InstancedBufferGeometry {
     constructor();
+    readonly isLineSegmentsGeometry: true;
+
     applyMatrix4(matrix: Matrix4): this;
-    setPositions(array: number[] | Float32Array): this;
-    setColors(array: number[] | Float32Array): this;
-    fromWireframeGeometry(geometry: BufferGeometry): this;
-    fromEdgesGeometry(geometry: BufferGeometry): this;
-    fromMesh(mesh: Mesh): this;
-    fromLineSegments(lineSegments: LineSegments): this;
-    private box;
     computeBoundingBox(): void;
-    private vector;
     computeBoundingSphere(): void;
-    toJSON(): void;
+    fromEdgesGeometry(geometry: EdgesGeometry): this;
+    fromLineSegments(lineSegments: LineSegments): this;
+    fromMesh(mesh: Mesh): this;
+    fromWireframeGeometry(geometry: WireframeGeometry): this;
+    setColors(array: number[] | Float32Array): this;
+    setPositions(array: number[] | Float32Array): this;
 }
-export { LineSegmentsGeometry };

package/lines/LineSegmentsGeometry.js

@@ -1,22 +1,14 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import { InstancedBufferGeometry, Box3, Vector3, Float32BufferAttribute, InstancedInterleavedBuffer, InterleavedBufferAttribute, WireframeGeometry, Sphere } from 'three';
+import { Box3, Vector3, InstancedBufferGeometry, Float32BufferAttribute, InstancedInterleavedBuffer, InterleavedBufferAttribute, WireframeGeometry, Sphere } from 'three';
+
+const _box = new Box3();
+
+const _vector = new Vector3();
 
 class LineSegmentsGeometry extends InstancedBufferGeometry {
   constructor() {
     super();
-
-    _defineProperty(this, "isLineSegmentsGeometry", true);
-
-    _defineProperty(this, "type", 'LineSegmentsGeometry');
-
-    _defineProperty(this, "boundingBox", null);
-
-    _defineProperty(this, "boundingSphere", null);
-
-    _defineProperty(this, "box", new Box3());
-
-    _defineProperty(this, "vector", new Vector3());
-
+    this.isLineSegmentsGeometry = true;
+    this.type = 'LineSegmentsGeometry';
     const positions = [-1, 2, 0, 1, 2, 0, -1, 1, 0, 1, 1, 0, -1, 0, 0, 1, 0, 0, -1, -1, 0, 1, -1, 0];
     const uvs = [-1, 2, 1, 2, -1, 1, 1, 1, -1, -1, 1, -1, -1, -2, 1, -2];
     const index = [0, 2, 1, 2, 3, 1, 2, 4, 3, 4, 5, 3, 4, 6, 5, 6, 7, 5];
@@ -53,9 +45,6 @@ class LineSegmentsGeometry extends InstancedBufferGeometry {
       lineSegments = array;
     } else if (Array.isArray(array)) {
       lineSegments = new Float32Array(array);
-    } else {
-      console.error('LineSegmentsGeometry.setPosition requires either a Float32Array or regular array of numbers');
-      return this;
     }
 
     const instanceBuffer = new InstancedInterleavedBuffer(lineSegments, 6, 1); // xyz, xyz
@@ -77,9 +66,6 @@ class LineSegmentsGeometry extends InstancedBufferGeometry {
       colors = array;
     } else if (Array.isArray(array)) {
       colors = new Float32Array(array);
-    } else {
-      console.error('LineSegmentsGeometry.setColors requires either a Float32Array or regular array of numbers');
-      return this;
     }
 
     const instanceColorBuffer = new InstancedInterleavedBuffer(colors, 6, 1); // rgb, rgb
@@ -92,27 +78,25 @@ class LineSegmentsGeometry extends InstancedBufferGeometry {
   }
 
   fromWireframeGeometry(geometry) {
-    this.setPositions(Array.from(geometry.attributes.position.array));
+    this.setPositions(geometry.attributes.position.array);
     return this;
   }
 
   fromEdgesGeometry(geometry) {
-    this.setPositions(Array.from(geometry.attributes.position.array));
+    this.setPositions(geometry.attributes.position.array);
     return this;
   }
 
   fromMesh(mesh) {
-    this.fromWireframeGeometry(new WireframeGeometry(mesh.geometry));
+    this.fromWireframeGeometry(new WireframeGeometry(mesh.geometry)); // set colors, maybe
+
     return this;
   }
 
   fromLineSegments(lineSegments) {
     const geometry = lineSegments.geometry;
-
-    if (geometry.isBufferGeometry) {
-      this.setPositions(Array.from(geometry.attributes.position.array)); // assumes non-indexed
-    } // set colors, maybe
-
+    this.setPositions(geometry.attributes.position.array); // assumes non-indexed
+    // set colors, maybe
 
     return this;
   }
@@ -127,8 +111,10 @@ class LineSegmentsGeometry extends InstancedBufferGeometry {
 
     if (start !== undefined && end !== undefined) {
       this.boundingBox.setFromBufferAttribute(start);
-      this.box.setFromBufferAttribute(end);
-      this.boundingBox.union(this.box);
+
+      _box.setFromBufferAttribute(end);
+
+      this.boundingBox.union(_box);
     }
   }
 
@@ -146,18 +132,17 @@ class LineSegmentsGeometry extends InstancedBufferGeometry {
 
     if (start !== undefined && end !== undefined) {
       const center = this.boundingSphere.center;
-
-      if (this.boundingBox) {
-        this.boundingBox.getCenter(center);
-      }
-
+      this.boundingBox.getCenter(center);
       let maxRadiusSq = 0;
 
       for (let i = 0, il = start.count; i < il; i++) {
-        this.vector.fromBufferAttribute(start, i);
-        maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(this.vector));
-        this.vector.fromBufferAttribute(end, i);
-        maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(this.vector));
+        _vector.fromBufferAttribute(start, i);
+
+        maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector));
+
+        _vector.fromBufferAttribute(end, i);
+
+        maxRadiusSq = Math.max(maxRadiusSq, center.distanceToSquared(_vector));
       }
 
       this.boundingSphere.radius = Math.sqrt(maxRadiusSq);
@@ -171,6 +156,11 @@ class LineSegmentsGeometry extends InstancedBufferGeometry {
   toJSON() {// todo
   }
 
+  applyMatrix(matrix) {
+    console.warn('THREE.LineSegmentsGeometry: applyMatrix() has been renamed to applyMatrix4().');
+    return this.applyMatrix4(matrix);
+  }
+
 }
 
 export { LineSegmentsGeometry };

package/lines/Wireframe.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three"),t=require("./LineSegmentsGeometry.cjs.js"),r=require("./LineMaterial.cjs.js");require("@babel/runtime/helpers/defineProperty");var i,n,a=function(i,n){e.Mesh.call(this),this.type="Wireframe",this.geometry=void 0!==i?i:new t.LineSegmentsGeometry,this.material=void 0!==n?n:new r.LineMaterial({color:16777215*Math.random()})};a.prototype=Object.assign(Object.create(e.Mesh.prototype),{constructor:a,isWireframe:!0,computeLineDistances:(i=new e.Vector3,n=new e.Vector3,function(){var t=this.geometry,r=t.attributes.instanceStart,a=t.attributes.instanceEnd,s=new Float32Array(2*r.data.count);for(let e=0,t=0,o=r.data.count;e<o;e++,t+=2)i.fromBufferAttribute(r,e),n.fromBufferAttribute(a,e),s[t]=0===t?0:s[t-1],s[t+1]=s[t]+i.distanceTo(n);var o=new e.InstancedInterleavedBuffer(s,2,1);return t.setAttribute("instanceDistanceStart",new e.InterleavedBufferAttribute(o,1,0)),t.setAttribute("instanceDistanceEnd",new e.InterleavedBufferAttribute(o,1,1)),this})}),exports.Wireframe=a;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three"),t=require("./LineSegmentsGeometry.cjs.js"),r=require("./LineMaterial.cjs.js");const n=new e.Vector3,s=new e.Vector3;class i extends e.Mesh{constructor(e=new t.LineSegmentsGeometry,n=new r.LineMaterial({color:16777215*Math.random()})){super(e,n),this.isWireframe=!0,this.type="Wireframe"}computeLineDistances(){const t=this.geometry,r=t.attributes.instanceStart,i=t.attributes.instanceEnd,a=new Float32Array(2*r.count);for(let e=0,t=0,c=r.count;e<c;e++,t+=2)n.fromBufferAttribute(r,e),s.fromBufferAttribute(i,e),a[t]=0===t?0:a[t-1],a[t+1]=a[t]+n.distanceTo(s);const c=new e.InstancedInterleavedBuffer(a,2,1);return t.setAttribute("instanceDistanceStart",new e.InterleavedBufferAttribute(c,1,0)),t.setAttribute("instanceDistanceEnd",new e.InterleavedBufferAttribute(c,1,1)),this}}exports.Wireframe=i;