ray and this sprite. * * @param {Raycaster} raycaster - The raycaster. * @param {Array} intersects - The target array that holds the intersection points. */ raycast( raycaster, intersects ) { if ( raycaster.camera === null ) { error( 'Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.' ); } _worldScale.setFromMatrixScale( this.matrixWorld ); _viewWorldMatrix.copy( raycaster.camera.matrixWorld ); this.modelViewMatrix.multiplyMatrices( raycaster.camera.matrixWorldInverse, this.matrixWorld ); _mvPosition.setFromMatrixPosition( this.modelViewMatrix ); if ( raycaster.camera.isPerspectiveCamera && this.material.sizeAttenuation === false ) { _worldScale.multiplyScalar( - _mvPosition.z ); } const rotation = this.material.rotation; let sin, cos; if ( rotation !== 0 ) { cos = Math.cos( rotation ); sin = Math.sin( rotation ); } const center = this.center; transformVertex( _vA$1.set( -0.5, -0.5, 0 ), _mvPosition, center, _worldScale, sin, cos ); transformVertex( _vB$1.set( 0.5, -0.5, 0 ), _mvPosition, center, _worldScale, sin, cos ); transformVertex( _vC$1.set( 0.5, 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos ); _uvA.set( 0, 0 ); _uvB.set( 1, 0 ); _uvC.set( 1, 1 ); // check first triangle let intersect = raycaster.ray.intersectTriangle( _vA$1, _vB$1, _vC$1, false, _intersectPoint ); if ( intersect === null ) { // check second triangle transformVertex( _vB$1.set( -0.5, 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos ); _uvB.set( 0, 1 ); intersect = raycaster.ray.intersectTriangle( _vA$1, _vC$1, _vB$1, false, _intersectPoint ); if ( intersect === null ) { return; } } const distance = raycaster.ray.origin.distanceTo( _intersectPoint ); if ( distance < raycaster.near || distance > raycaster.far ) return; intersects.push( { distance: distance, point: _intersectPoint.clone(), uv: Triangle.getInterpolation( _intersectPoint, _vA$1, _vB$1, _vC$1, _uvA, _uvB, _uvC, new Vector2() ), face: null, object: this } ); } copy( source, recursive ) { super.copy( source, recursive ); if ( source.center !== undefined ) this.center.copy( source.center ); this.material = source.material; return this; } } function transformVertex( vertexPosition, mvPosition, center, scale, sin, cos ) { // compute position in camera space _alignedPosition.subVectors( vertexPosition, center ).addScalar( 0.5 ).multiply( scale ); // to check if rotation is not zero if ( sin !== undefined ) { _rotatedPosition.x = ( cos * _alignedPosition.x ) - ( sin * _alignedPosition.y ); _rotatedPosition.y = ( sin * _alignedPosition.x ) + ( cos * _alignedPosition.y ); } else { _rotatedPosition.copy( _alignedPosition ); } vertexPosition.copy( mvPosition ); vertexPosition.x += _rotatedPosition.x; vertexPosition.y += _rotatedPosition.y; // transform to world space vertexPosition.applyMatrix4( _viewWorldMatrix ); } const _v1$2 = /*@__PURE__*/ new Vector3(); const _v2$1 = /*@__PURE__*/ new Vector3(); /** * A component for providing a basic Level of Detail (LOD) mechanism. * * Every LOD level is associated with an object, and rendering can be switched * between them at the distances specified. Typically you would create, say, * three meshes, one for far away (low detail), one for mid range (medium * detail) and one for close up (high detail). * * ```js * const lod = new THREE.LOD(); * const material = new THREE.MeshBasicMaterial( { color: 0xffff00 } ); * * //Create spheres with 3 levels of detail and create new LOD levels for them * for( let i = 0; i < 3; i++ ) { * * const geometry = new THREE.IcosahedronGeometry( 10, 3 - i ); * const mesh = new THREE.Mesh( geometry, material ); * lod.addLevel( mesh, i * 75 ); * * } * * scene.add( lod ); * ``` * * @augments Object3D */ class LOD extends Object3D { /** * Constructs a new LOD. */ constructor() { super(); /** * This flag can be used for type testing. * * @type {boolean} * @readonly * @default true */ this.isLOD = true; /** * The current LOD index. * * @private * @type {number} * @default 0 */ this._currentLevel = 0; this.type = 'LOD'; Object.defineProperties( this, { /** * This array holds the LOD levels. * * @name LOD#levels * @type {Array<{object:Object3D,distance:number,hysteresis:number}>} */ levels: { enumerable: true, value: [] } } ); /** * Whether the LOD object is updated automatically by the renderer per frame * or not. If set to `false`, you have to call {@link LOD#update} in the * render loop by yourself. * * @type {boolean} * @default true */ this.autoUpdate = true; } copy( source ) { super.copy( source, false ); const levels = source.levels; for ( let i = 0, l = levels.length; i < l; i ++ ) {