const index = geometry.index; const attributes = geometry.attributes; const positionAttribute = attributes.position; if ( index !== null ) { const start = Math.max( 0, drawRange.start ); const end = Math.min( index.count, ( drawRange.start + drawRange.count ) ); for ( let i = start, l = end - 1; i < l; i += step ) { const a = index.getX( i ); const b = index.getX( i + 1 ); const intersect = checkIntersection( this, raycaster, _ray$1, localThresholdSq, a, b, i ); if ( intersect ) { intersects.push( intersect ); } } if ( this.isLineLoop ) { const a = index.getX( end - 1 ); const b = index.getX( start ); const intersect = checkIntersection( this, raycaster, _ray$1, localThresholdSq, a, b, end - 1 ); if ( intersect ) { intersects.push( intersect ); } } } else { const start = Math.max( 0, drawRange.start ); const end = Math.min( positionAttribute.count, ( drawRange.start + drawRange.count ) ); for ( let i = start, l = end - 1; i < l; i += step ) { const intersect = checkIntersection( this, raycaster, _ray$1, localThresholdSq, i, i + 1, i ); if ( intersect ) { intersects.push( intersect ); } } if ( this.isLineLoop ) { const intersect = checkIntersection( this, raycaster, _ray$1, localThresholdSq, end - 1, start, end - 1 ); if ( intersect ) { intersects.push( intersect ); } } } } /** * Sets the values of {@link Line#morphTargetDictionary} and {@link Line#morphTargetInfluences} * to make sure existing morph targets can influence this 3D object. */ updateMorphTargets() { const geometry = this.geometry; const morphAttributes = geometry.morphAttributes; const keys = Object.keys( morphAttributes ); if ( keys.length > 0 ) { const morphAttribute = morphAttributes[ keys[ 0 ] ]; if ( morphAttribute !== undefined ) { this.morphTargetInfluences = []; this.morphTargetDictionary = {}; for ( let m = 0, ml = morphAttribute.length; m < ml; m ++ ) { const name = morphAttribute[ m ].name || String( m ); this.morphTargetInfluences.push( 0 ); this.morphTargetDictionary[ name ] = m; } } } } } function checkIntersection( object, raycaster, ray, thresholdSq, a, b, i ) { const positionAttribute = object.geometry.attributes.position; _vStart.fromBufferAttribute( positionAttribute, a ); _vEnd.fromBufferAttribute( positionAttribute, b ); const distSq = ray.distanceSqToSegment( _vStart, _vEnd, _intersectPointOnRay, _intersectPointOnSegment ); if ( distSq > thresholdSq ) return; _intersectPointOnRay.applyMatrix4( object.matrixWorld ); // Move back to world space for distance calculation const distance = raycaster.ray.origin.distanceTo( _intersectPointOnRay ); if ( distance < raycaster.near || distance > raycaster.far ) return; return { distance: distance, // What do we want? intersection point on the ray or on the segment?? // point: raycaster.ray.at( distance ), point: _intersectPointOnSegment.clone().applyMatrix4( object.matrixWorld ), index: i, face: null, faceIndex: null, barycoord: null, object: object }; } const _start = /*@__PURE__*/ new Vector3(); const _end = /*@__PURE__*/ new Vector3(); /** * A series of lines drawn between pairs of vertices. * * @augments Line */ class LineSegments extends Line { /** * Constructs a new line segments. * * @param {BufferGeometry} [geometry] - The line geometry. * @param {Material|Array} [material] - The line material. */ constructor( geometry, material ) { super( geometry, material ); /** * This flag can be used for type testing. * * @type {boolean} * @readonly * @default true */ this.isLineSegments = true; this.type = 'LineSegments'; } computeLineDistances() { const geometry = this.geometry; // we assume non-indexed geometry if ( geometry.index === null ) { const positionAttribute = geometry.attributes.position; const lineDistances = []; for ( let i = 0, l = positionAttribute.count; i < l; i += 2 ) { _start.fromBufferAttribute( positionAttribute, i ); _end.fromBufferAttribute( positionAttribute, i + 1 ); lineDistances[ i ] = ( i === 0 ) ? 0 : lineDistances[ i - 1 ]; lineDistances[ i + 1 ] = lineDistances[ i ] + _start.distanceTo( _end ); } geometry.setAttribute( 'lineDistance', new Float32BufferAttribute( lineDistances, 1 ) ); } else { warn( 'LineSegments.computeLineDistances(): Computation only possible with non-indexed BufferGeometry.' ); } return this; } } /** * A continuous line. This is nearly the same as {@link Line} the only difference * is that the last vertex is connected with the first vertex in order to close * the line to form a loop. * * @augments Line */ class LineLoop extends Line { /** * Constructs a new line loop. * *