three-stdlib 2.14.1 → 2.15.0

package/lines/LineMaterial.js

@@ -1,5 +1,4 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import { Vector2, ShaderLib, UniformsUtils, UniformsLib, ShaderMaterial, Color } from 'three';
+import { UniformsLib, Vector2, ShaderLib, UniformsUtils, ShaderMaterial } from 'three';
 
 /**
  * parameters = {
@@ -13,32 +12,32 @@ import { Vector2, ShaderLib, UniformsUtils, UniformsLib, ShaderMaterial, Color }
  *  resolution: <Vector2>, // to be set by renderer
  * }
  */
-const LineUniforms = {
+UniformsLib.line = {
+  worldUnits: {
+    value: 1
+  },
   linewidth: {
     value: 1
   },
   resolution: {
     value: new Vector2(1, 1)
   },
+  dashOffset: {
+    value: 0
+  },
   dashScale: {
     value: 1
   },
   dashSize: {
     value: 1
   },
-  dashOffset: {
-    value: 0
-  },
   gapSize: {
     value: 1
-  },
-  // todo FIX - maybe change to totalSize
-  opacity: {
-    value: 1
-  }
+  } // todo FIX - maybe change to totalSize
+
 };
 ShaderLib['line'] = {
-  uniforms: UniformsUtils.merge([UniformsLib.common, UniformsLib.fog, LineUniforms]),
+  uniforms: UniformsUtils.merge([UniformsLib.common, UniformsLib.fog, UniformsLib.line]),
   vertexShader:
   /* glsl */
   `
@@ -57,7 +56,23 @@ ShaderLib['line'] = {
 		attribute vec3 instanceColorStart;
 		attribute vec3 instanceColorEnd;
 
-		varying vec2 vUv;
+		#ifdef WORLD_UNITS
+
+			varying vec4 worldPos;
+			varying vec3 worldStart;
+			varying vec3 worldEnd;
+
+			#ifdef USE_DASH
+
+				varying vec2 vUv;
+
+			#endif
+
+		#else
+
+			varying vec2 vUv;
+
+		#endif
 
 		#ifdef USE_DASH
 
@@ -94,17 +109,27 @@ ShaderLib['line'] = {
 			#ifdef USE_DASH
 
 				vLineDistance = ( position.y < 0.5 ) ? dashScale * instanceDistanceStart : dashScale * instanceDistanceEnd;
+				vUv = uv;
 
 			#endif
 
 			float aspect = resolution.x / resolution.y;
 
-			vUv = uv;
-
 			// camera space
 			vec4 start = modelViewMatrix * vec4( instanceStart, 1.0 );
 			vec4 end = modelViewMatrix * vec4( instanceEnd, 1.0 );
 
+			#ifdef WORLD_UNITS
+
+				worldStart = start.xyz;
+				worldEnd = end.xyz;
+
+			#else
+
+				vUv = uv;
+
+			#endif
+
 			// special case for perspective projection, and segments that terminate either in, or behind, the camera plane
 			// clearly the gpu firmware has a way of addressing this issue when projecting into ndc space
 			// but we need to perform ndc-space calculations in the shader, so we must address this issue directly
@@ -131,50 +156,108 @@ ShaderLib['line'] = {
 			vec4 clipEnd = projectionMatrix * end;
 
 			// ndc space
-			vec2 ndcStart = clipStart.xy / clipStart.w;
-			vec2 ndcEnd = clipEnd.xy / clipEnd.w;
+			vec3 ndcStart = clipStart.xyz / clipStart.w;
+			vec3 ndcEnd = clipEnd.xyz / clipEnd.w;
 
 			// direction
-			vec2 dir = ndcEnd - ndcStart;
+			vec2 dir = ndcEnd.xy - ndcStart.xy;
 
 			// account for clip-space aspect ratio
 			dir.x *= aspect;
 			dir = normalize( dir );
 
-			// perpendicular to dir
-			vec2 offset = vec2( dir.y, - dir.x );
+			#ifdef WORLD_UNITS
 
-			// undo aspect ratio adjustment
-			dir.x /= aspect;
-			offset.x /= aspect;
+				// get the offset direction as perpendicular to the view vector
+				vec3 worldDir = normalize( end.xyz - start.xyz );
+				vec3 offset;
+				if ( position.y < 0.5 ) {
 
-			// sign flip
-			if ( position.x < 0.0 ) offset *= - 1.0;
+					offset = normalize( cross( start.xyz, worldDir ) );
 
-			// endcaps
-			if ( position.y < 0.0 ) {
+				} else {
 
-				offset += - dir;
+					offset = normalize( cross( end.xyz, worldDir ) );
 
-			} else if ( position.y > 1.0 ) {
+				}
 
-				offset += dir;
+				// sign flip
+				if ( position.x < 0.0 ) offset *= - 1.0;
 
-			}
+				float forwardOffset = dot( worldDir, vec3( 0.0, 0.0, 1.0 ) );
+
+				// don't extend the line if we're rendering dashes because we
+				// won't be rendering the endcaps
+				#ifndef USE_DASH
+
+					// extend the line bounds to encompass  endcaps
+					start.xyz += - worldDir * linewidth * 0.5;
+					end.xyz += worldDir * linewidth * 0.5;
+
+					// shift the position of the quad so it hugs the forward edge of the line
+					offset.xy -= dir * forwardOffset;
+					offset.z += 0.5;
+
+				#endif
+
+				// endcaps
+				if ( position.y > 1.0 || position.y < 0.0 ) {
 
-			// adjust for linewidth
-			offset *= linewidth;
+					offset.xy += dir * 2.0 * forwardOffset;
 
-			// adjust for clip-space to screen-space conversion // maybe resolution should be based on viewport ...
-			offset /= resolution.y;
+				}
+
+				// adjust for linewidth
+				offset *= linewidth * 0.5;
+
+				// set the world position
+				worldPos = ( position.y < 0.5 ) ? start : end;
+				worldPos.xyz += offset;
+
+				// project the worldpos
+				vec4 clip = projectionMatrix * worldPos;
+
+				// shift the depth of the projected points so the line
+				// segments overlap neatly
+				vec3 clipPose = ( position.y < 0.5 ) ? ndcStart : ndcEnd;
+				clip.z = clipPose.z * clip.w;
+
+			#else
+
+				vec2 offset = vec2( dir.y, - dir.x );
+				// undo aspect ratio adjustment
+				dir.x /= aspect;
+				offset.x /= aspect;
+
+				// sign flip
+				if ( position.x < 0.0 ) offset *= - 1.0;
+
+				// endcaps
+				if ( position.y < 0.0 ) {
 
-			// select end
-			vec4 clip = ( position.y < 0.5 ) ? clipStart : clipEnd;
+					offset += - dir;
 
-			// back to clip space
-			offset *= clip.w;
+				} else if ( position.y > 1.0 ) {
 
-			clip.xy += offset;
+					offset += dir;
+
+				}
+
+				// adjust for linewidth
+				offset *= linewidth;
+
+				// adjust for clip-space to screen-space conversion // maybe resolution should be based on viewport ...
+				offset /= resolution.y;
+
+				// select end
+				vec4 clip = ( position.y < 0.5 ) ? clipStart : clipEnd;
+
+				// back to clip space
+				offset *= clip.w;
+
+				clip.xy += offset;
+
+			#endif
 
 			gl_Position = clip;
 
@@ -191,24 +274,70 @@ ShaderLib['line'] = {
   `
 		uniform vec3 diffuse;
 		uniform float opacity;
+		uniform float linewidth;
 
 		#ifdef USE_DASH
 
-			uniform float dashSize;
 			uniform float dashOffset;
+			uniform float dashSize;
 			uniform float gapSize;
 
 		#endif
 
 		varying float vLineDistance;
 
+		#ifdef WORLD_UNITS
+
+			varying vec4 worldPos;
+			varying vec3 worldStart;
+			varying vec3 worldEnd;
+
+			#ifdef USE_DASH
+
+				varying vec2 vUv;
+
+			#endif
+
+		#else
+
+			varying vec2 vUv;
+
+		#endif
+
 		#include <common>
 		#include <color_pars_fragment>
 		#include <fog_pars_fragment>
 		#include <logdepthbuf_pars_fragment>
 		#include <clipping_planes_pars_fragment>
 
-		varying vec2 vUv;
+		vec2 closestLineToLine(vec3 p1, vec3 p2, vec3 p3, vec3 p4) {
+
+			float mua;
+			float mub;
+
+			vec3 p13 = p1 - p3;
+			vec3 p43 = p4 - p3;
+
+			vec3 p21 = p2 - p1;
+
+			float d1343 = dot( p13, p43 );
+			float d4321 = dot( p43, p21 );
+			float d1321 = dot( p13, p21 );
+			float d4343 = dot( p43, p43 );
+			float d2121 = dot( p21, p21 );
+
+			float denom = d2121 * d4343 - d4321 * d4321;
+
+			float numer = d1343 * d4321 - d1321 * d4343;
+
+			mua = numer / denom;
+			mua = clamp( mua, 0.0, 1.0 );
+			mub = ( d1343 + d4321 * ( mua ) ) / d4343;
+			mub = clamp( mub, 0.0, 1.0 );
+
+			return vec2( mua, mub );
+
+		}
 
 		void main() {
 
@@ -224,31 +353,67 @@ ShaderLib['line'] = {
 
 			float alpha = opacity;
 
-			#ifdef ALPHA_TO_COVERAGE
+			#ifdef WORLD_UNITS
 
-			// artifacts appear on some hardware if a derivative is taken within a conditional
-			float a = vUv.x;
-			float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
-			float len2 = a * a + b * b;
-			float dlen = fwidth( len2 );
+				// Find the closest points on the view ray and the line segment
+				vec3 rayEnd = normalize( worldPos.xyz ) * 1e5;
+				vec3 lineDir = worldEnd - worldStart;
+				vec2 params = closestLineToLine( worldStart, worldEnd, vec3( 0.0, 0.0, 0.0 ), rayEnd );
 
-			if ( abs( vUv.y ) > 1.0 ) {
+				vec3 p1 = worldStart + lineDir * params.x;
+				vec3 p2 = rayEnd * params.y;
+				vec3 delta = p1 - p2;
+				float len = length( delta );
+				float norm = len / linewidth;
 
-				alpha = 1.0 - smoothstep( 1.0 - dlen, 1.0 + dlen, len2 );
+				#ifndef USE_DASH
 
-			}
+					#ifdef USE_ALPHA_TO_COVERAGE
+
+						float dnorm = fwidth( norm );
+						alpha = 1.0 - smoothstep( 0.5 - dnorm, 0.5 + dnorm, norm );
+
+					#else
+
+						if ( norm > 0.5 ) {
+
+							discard;
+
+						}
+
+					#endif
+
+				#endif
 
 			#else
 
-			if ( abs( vUv.y ) > 1.0 ) {
+				#ifdef USE_ALPHA_TO_COVERAGE
 
-				float a = vUv.x;
-				float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
-				float len2 = a * a + b * b;
+					// artifacts appear on some hardware if a derivative is taken within a conditional
+					float a = vUv.x;
+					float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
+					float len2 = a * a + b * b;
+					float dlen = fwidth( len2 );
 
-				if ( len2 > 1.0 ) discard;
+					if ( abs( vUv.y ) > 1.0 ) {
 
-			}
+						alpha = 1.0 - smoothstep( 1.0 - dlen, 1.0 + dlen, len2 );
+
+					}
+
+				#else
+
+					if ( abs( vUv.y ) > 1.0 ) {
+
+						float a = vUv.x;
+						float b = ( vUv.y > 0.0 ) ? vUv.y - 1.0 : vUv.y + 1.0;
+						float len2 = a * a + b * b;
+
+						if ( len2 > 1.0 ) discard;
+
+					}
+
+				#endif
 
 			#endif
 
@@ -269,39 +434,16 @@ ShaderLib['line'] = {
 };
 
 class LineMaterial extends ShaderMaterial {
-  constructor(parameters = {}) {
+  constructor(parameters) {
     super({
+      type: 'LineMaterial',
       uniforms: UniformsUtils.clone(ShaderLib['line'].uniforms),
       vertexShader: ShaderLib['line'].vertexShader,
       fragmentShader: ShaderLib['line'].fragmentShader,
       clipping: true // required for clipping support
 
     });
-    /**
-     * Everytime I remove this, everything just breaks,
-     * so I'm just gonna leave it here.
-     */
-
-    _defineProperty(this, "isLineMaterial", true);
-
-    _defineProperty(this, "dashed", false);
-
-    _defineProperty(this, "color", new Color(0x000000));
-
-    _defineProperty(this, "lineWidth", 0);
-
-    _defineProperty(this, "dashScale", 0);
-
-    _defineProperty(this, "dashOffset", 0);
-
-    _defineProperty(this, "dashSize", 0);
-
-    _defineProperty(this, "opacity", 0);
-
-    _defineProperty(this, "resolution", new Vector2());
-
-    _defineProperty(this, "alphaToCoverage", false);
-
+    this.isLineMaterial = true;
     Object.defineProperties(this, {
       color: {
         enumerable: true,
@@ -309,8 +451,20 @@ class LineMaterial extends ShaderMaterial {
           return this.uniforms.diffuse.value;
         },
         set: function (value) {
-          const colorObj = new Color(value);
-          this.uniforms.diffuse.value = colorObj.getHex();
+          this.uniforms.diffuse.value = value;
+        }
+      },
+      worldUnits: {
+        enumerable: true,
+        get: function () {
+          return 'WORLD_UNITS' in this.defines;
+        },
+        set: function (value) {
+          if (value === true) {
+            this.defines.WORLD_UNITS = '';
+          } else {
+            delete this.defines.WORLD_UNITS;
+          }
         }
       },
       linewidth: {
@@ -322,6 +476,25 @@ class LineMaterial extends ShaderMaterial {
           this.uniforms.linewidth.value = value;
         }
       },
+      dashed: {
+        enumerable: true,
+        get: function () {
+          return Boolean('USE_DASH' in this.defines);
+        },
+
+        set(value) {
+          if (Boolean(value) !== Boolean('USE_DASH' in this.defines)) {
+            this.needsUpdate = true;
+          }
+
+          if (value === true) {
+            this.defines.USE_DASH = '';
+          } else {
+            delete this.defines.USE_DASH;
+          }
+        }
+
+      },
       dashScale: {
         enumerable: true,
         get: function () {
@@ -379,38 +552,21 @@ class LineMaterial extends ShaderMaterial {
       alphaToCoverage: {
         enumerable: true,
         get: function () {
-          return Boolean('ALPHA_TO_COVERAGE' in this.defines);
+          return Boolean('USE_ALPHA_TO_COVERAGE' in this.defines);
         },
         set: function (value) {
-          if (Boolean(value) !== Boolean('ALPHA_TO_COVERAGE' in this.defines)) {
+          if (Boolean(value) !== Boolean('USE_ALPHA_TO_COVERAGE' in this.defines)) {
             this.needsUpdate = true;
           }
 
-          if (value) {
-            this.defines.ALPHA_TO_COVERAGE = '';
+          if (value === true) {
+            this.defines.USE_ALPHA_TO_COVERAGE = '';
             this.extensions.derivatives = true;
           } else {
-            delete this.defines.ALPHA_TO_COVERAGE;
+            delete this.defines.USE_ALPHA_TO_COVERAGE;
             this.extensions.derivatives = false;
           }
         }
-      },
-      dashed: {
-        enumerable: true,
-        get: function () {
-          return Boolean('USE_DASH' in this.defines);
-        },
-        set: function (value) {
-          if (Boolean(value) !== Boolean('USE_DASH' in this.defines)) {
-            this.needsUpdate = true;
-          }
-
-          if (value) {
-            this.defines.USE_DASH = '';
-          } else {
-            delete this.defines.USE_DASH;
-          }
-        }
       }
     });
     this.setValues(parameters);

package/lines/LineSegments2.cjs.js

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("@babel/runtime/helpers/defineProperty"),i=require("three"),e=require("./LineSegmentsGeometry.cjs.js"),s=require("./LineMaterial.cjs.js");function r(t){return t&&"object"==typeof t&&"default"in t?t:{default:t}}var a=r(t);class n extends i.Mesh{constructor(t=new e.LineSegmentsGeometry,r=new s.LineMaterial({color:16777215*Math.random()})){super(t,r),a.default(this,"type","LineSegments2"),a.default(this,"isLineSegments2",!0),a.default(this,"distStart",new i.Vector3),a.default(this,"distEnd",new i.Vector3),a.default(this,"computeLineDistances",(()=>{const t=this.geometry,e=t.attributes.instanceStart,s=t.attributes.instanceEnd,r=new Float32Array(2*e.data.count);for(let t=0,i=0,a=e.data.count;t<a;t++,i+=2)this.distStart.fromBufferAttribute(e,t),this.distEnd.fromBufferAttribute(s,t),r[i]=0===i?0:r[i-1],r[i+1]=r[i]+this.distStart.distanceTo(this.distEnd);const a=new i.InstancedInterleavedBuffer(r,2,1);return t.setAttribute("instanceDistanceStart",new i.InterleavedBufferAttribute(a,1,0)),t.setAttribute("instanceDistanceEnd",new i.InterleavedBufferAttribute(a,1,1)),this})),a.default(this,"rayStart",new i.Vector4),a.default(this,"rayEnd",new i.Vector4),a.default(this,"ssOrigin",new i.Vector4),a.default(this,"ssOrigin3",new i.Vector3),a.default(this,"mvMatrix",new i.Matrix4),a.default(this,"line",new i.Line3),a.default(this,"closestPoint",new i.Vector3),a.default(this,"raycast",((t,e)=>{null===t.camera&&console.error('LineSegments2: "Raycaster.camera" needs to be set in order to raycast against LineSegments2.');const s=t.ray,r=t.camera,a=r.projectionMatrix,n=this.geometry,h=this.material,l=h.resolution,o=h.linewidth+0,d=n.attributes.instanceStart,y=n.attributes.instanceEnd,c=-r.near;s.at(1,this.ssOrigin),this.ssOrigin.w=1,this.ssOrigin.applyMatrix4(r.matrixWorldInverse),this.ssOrigin.applyMatrix4(a),this.ssOrigin.multiplyScalar(1/this.ssOrigin.w),this.ssOrigin.x*=l.x/2,this.ssOrigin.y*=l.y/2,this.ssOrigin.z=0,this.ssOrigin3.set(this.ssOrigin.x,this.ssOrigin.y,this.ssOrigin.z);const u=this.matrixWorld;this.mvMatrix.multiplyMatrices(r.matrixWorldInverse,u);for(let t=0,r=d.count;t<r;t++){this.rayStart.fromBufferAttribute(d,t),this.rayEnd.fromBufferAttribute(y,t),this.rayStart.w=1,this.rayEnd.w=1,this.rayStart.applyMatrix4(this.mvMatrix),this.rayEnd.applyMatrix4(this.mvMatrix);if(this.rayStart.z>c&&this.rayEnd.z>c)continue;if(this.rayStart.z>c){const t=this.rayStart.z-this.rayEnd.z,i=(this.rayStart.z-c)/t;this.rayStart.lerp(this.rayEnd,i)}else if(this.rayEnd.z>c){const t=this.rayEnd.z-this.rayStart.z,i=(this.rayEnd.z-c)/t;this.rayEnd.lerp(this.rayStart,i)}this.rayStart.applyMatrix4(a),this.rayEnd.applyMatrix4(a),this.rayStart.multiplyScalar(1/this.rayStart.w),this.rayEnd.multiplyScalar(1/this.rayEnd.w),this.rayStart.x*=l.x/2,this.rayStart.y*=l.y/2,this.rayEnd.x*=l.x/2,this.rayEnd.y*=l.y/2,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;const r=this.line.closestPointToPointParameter(this.ssOrigin3,!0);this.line.at(r,this.closestPoint);const n=i.MathUtils.lerp(this.rayStart.z,this.rayEnd.z,r),h=n>=-1&&n<=1,f=this.ssOrigin3.distanceTo(this.closestPoint)<.5*o;if(h&&f){this.line.start.fromBufferAttribute(d,t),this.line.end.fromBufferAttribute(y,t),this.line.start.applyMatrix4(u),this.line.end.applyMatrix4(u);const r=new i.Vector3,a=new i.Vector3;s.distanceSqToSegment(this.line.start,this.line.end,a,r),e.push({distance:s.origin.distanceTo(a),point:a,face:null,faceIndex:t,object:this,uv:void 0,pointOnLine:r})}}}))}}exports.LineSegments2=n;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var t=require("three"),e=require("./LineSegmentsGeometry.cjs.js"),n=require("./LineMaterial.cjs.js");const r=new t.Vector3,i=new t.Vector3,a=new t.Vector4,o=new t.Vector4,s=new t.Vector4,c=new t.Vector3,l=new t.Matrix4,u=new t.Line3,p=new t.Vector3,d=new t.Box3,f=new t.Sphere,m=new t.Vector4;let y,x,w,h;function b(t,e,n){return m.set(0,0,-e,1).applyMatrix4(t.projectionMatrix),m.multiplyScalar(1/m.w),m.x=h/n.width,m.y=h/n.height,m.applyMatrix4(t.projectionMatrixInverse),m.multiplyScalar(1/m.w),Math.abs(Math.max(m.x,m.y))}class M extends t.Mesh{constructor(t=new e.LineSegmentsGeometry,r=new n.LineMaterial({color:16777215*Math.random()})){super(t,r),this.isLineSegments2=!0,this.type="LineSegments2"}computeLineDistances(){const e=this.geometry,n=e.attributes.instanceStart,a=e.attributes.instanceEnd,o=new Float32Array(2*n.count);for(let t=0,e=0,s=n.count;t<s;t++,e+=2)r.fromBufferAttribute(n,t),i.fromBufferAttribute(a,t),o[e]=0===e?0:o[e-1],o[e+1]=o[e]+r.distanceTo(i);const s=new t.InstancedInterleavedBuffer(o,2,1);return e.setAttribute("instanceDistanceStart",new t.InterleavedBufferAttribute(s,1,0)),e.setAttribute("instanceDistanceEnd",new t.InterleavedBufferAttribute(s,1,1)),this}raycast(e,n){const r=this.material.worldUnits,i=e.camera;null!==i||r||console.error('LineSegments2: "Raycaster.camera" needs to be set in order to raycast against LineSegments2 while worldUnits is set to false.');const m=void 0!==e.params.Line2&&e.params.Line2.threshold||0;y=e.ray;const M=this.matrixWorld,S=this.geometry,g=this.material;let B,z;if(h=g.linewidth+m,x=S.attributes.instanceStart,w=S.attributes.instanceEnd,null===S.boundingSphere&&S.computeBoundingSphere(),f.copy(S.boundingSphere).applyMatrix4(M),r)B=.5*h;else{B=b(i,Math.max(i.near,f.distanceToPoint(y.origin)),g.resolution)}if(f.radius+=B,!1!==y.intersectsSphere(f)){if(null===S.boundingBox&&S.computeBoundingBox(),d.copy(S.boundingBox).applyMatrix4(M),r)z=.5*h;else{z=b(i,Math.max(i.near,d.distanceToPoint(y.origin)),g.resolution)}d.expandByScalar(z),!1!==y.intersectsBox(d)&&(r?function(e,n){for(let r=0,i=x.count;r<i;r++){u.start.fromBufferAttribute(x,r),u.end.fromBufferAttribute(w,r);const i=new t.Vector3,a=new t.Vector3;y.distanceSqToSegment(u.start,u.end,a,i),a.distanceTo(i)<.5*h&&n.push({point:a,pointOnLine:i,distance:y.origin.distanceTo(a),object:e,face:null,faceIndex:r,uv:null,uv2:null})}}(this,n):function(e,n,r){const i=n.projectionMatrix,d=e.material.resolution,f=e.matrixWorld,m=e.geometry,x=m.attributes.instanceStart,w=m.attributes.instanceEnd,b=-n.near;y.at(1,s),s.w=1,s.applyMatrix4(n.matrixWorldInverse),s.applyMatrix4(i),s.multiplyScalar(1/s.w),s.x*=d.x/2,s.y*=d.y/2,s.z=0,c.copy(s),l.multiplyMatrices(n.matrixWorldInverse,f);for(let n=0,s=x.count;n<s;n++){if(a.fromBufferAttribute(x,n),o.fromBufferAttribute(w,n),a.w=1,o.w=1,a.applyMatrix4(l),o.applyMatrix4(l),a.z>b&&o.z>b)continue;if(a.z>b){const t=a.z-o.z,e=(a.z-b)/t;a.lerp(o,e)}else if(o.z>b){const t=o.z-a.z,e=(o.z-b)/t;o.lerp(a,e)}a.applyMatrix4(i),o.applyMatrix4(i),a.multiplyScalar(1/a.w),o.multiplyScalar(1/o.w),a.x*=d.x/2,a.y*=d.y/2,o.x*=d.x/2,o.y*=d.y/2,u.start.copy(a),u.start.z=0,u.end.copy(o),u.end.z=0;const s=u.closestPointToPointParameter(c,!0);u.at(s,p);const m=t.MathUtils.lerp(a.z,o.z,s),M=m>=-1&&m<=1,S=c.distanceTo(p)<.5*h;if(M&&S){u.start.fromBufferAttribute(x,n),u.end.fromBufferAttribute(w,n),u.start.applyMatrix4(f),u.end.applyMatrix4(f);const i=new t.Vector3,a=new t.Vector3;y.distanceSqToSegment(u.start,u.end,a,i),r.push({point:a,pointOnLine:i,distance:y.origin.distanceTo(a),object:e,face:null,faceIndex:n,uv:null,uv2:null})}}}(this,i,n))}}}exports.LineSegments2=M;

package/lines/LineSegments2.d.ts

@@ -1,22 +1,14 @@
-import { Mesh, Raycaster, Vector3, Intersection } from 'three';
-import { LineSegmentsGeometry } from '../lines/LineSegmentsGeometry';
-import { LineMaterial } from '../lines/LineMaterial';
-declare class LineSegments2 extends Mesh<LineSegmentsGeometry, LineMaterial> {
-    type: string;
-    private isLineSegments2;
+import { Mesh } from 'three';
+
+import { LineMaterial } from './LineMaterial';
+import { LineSegmentsGeometry } from './LineSegmentsGeometry';
+
+export class LineSegments2 extends Mesh {
+    geometry: LineSegmentsGeometry;
+    material: LineMaterial;
+
     constructor(geometry?: LineSegmentsGeometry, material?: LineMaterial);
-    private distStart;
-    private distEnd;
-    computeLineDistances: () => this;
-    private rayStart;
-    private rayEnd;
-    private ssOrigin;
-    private ssOrigin3;
-    private mvMatrix;
-    private line;
-    private closestPoint;
-    raycast: (raycaster: Raycaster, intersects: Array<Intersection & {
-        pointOnLine: Vector3;
-    }>) => void;
+    readonly isLineSegments2: true;
+
+    computeLineDistances(): this;
 }
-export { LineSegments2 };