https://register-any-point.github.io/js/three.module.js

154ames where available.
155const NoColorSpace = '';
156const SRGBColorSpace = 'srgb';
157const LinearSRGBColorSpace = 'srgb-linear';
158const DisplayP3ColorSpace = 'display-p3';
159
160const ZeroStencilOp = 0;
161const KeepStencilOp = 7680;
162const ReplaceStencilOp = 7681;
163const IncrementStencilOp = 7682;
164const DecrementStencilOp = 7683;
165const IncrementWrapStencilOp = 34055;
166const DecrementWrapStencilOp = 34056;
167const InvertStencilOp = 5386;
168
169const NeverStencilFunc = 512;
170const LessStencilFunc = 513;
171const EqualStencilFunc = 514;
172const LessEqualStencilFunc = 515;
173const GreaterStencilFunc = 516;
174const NotEqualStencilFunc = 517;
175const GreaterEqualStencilFunc = 518;
176const AlwaysStencilFunc = 519;
177
178const StaticDrawUsage = 35044;
179const DynamicDrawUsage = 35048;
180const StreamDrawUsage = 35040;
181const StaticReadUsage = 35045;
182const DynamicReadUsage = 35049;
183const StreamReadUsage = 35041;
184const StaticCopyUsage = 35046;
185const DynamicCopyUsage = 35050;
186const StreamCopyUsage = 35042;
187
188const GLSL1 = '100';
189const GLSL3 = '300 es';
190
191const _SRGBAFormat = 1035; // fallback for WebGL 1
192
193/**
194 * https://github.com/mrdoob/eventdispatcher.js/
195 */
196
197class EventDispatcher {
198
199	addEventListener( type, listener ) {
200
201		if ( this._listeners === undefined ) this._listeners = {};
202
203		const listeners = this._listeners;
204
205		if ( listeners[ type ] === undefined ) {
206
207			listeners[ type ] = [];
208
209		}
210
211		if ( listeners[ type ].indexOf( listener ) === - 1 ) {
212
213			listeners[ type ].push( listener );
214
215		}
216
217	}
218
219	hasEventListener( type, listener ) {
220
221		if ( this._listeners === undefined ) return false;
222
223		const listeners = this._listeners;
224
225		return listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1;
226
227	}
228
229	removeEventListener( type, listener ) {
230
231		if ( this._listeners === undefined ) return;
232
233		const listeners = this._listeners;
234		const listenerArray = listeners[ type ];
235
236		if ( listenerArray !== undefined ) {
237
238			const index = listenerArray.indexOf( listener );
239
240			if ( index !== - 1 ) {
241
242				listenerArray.splice( index, 1 );
243
244			}
245
246		}
247
248	}
249
250	dispatchEvent( event ) {
251
252		if ( this._listeners === undefined ) return;
253
254		const listeners = this._listeners;
255		const listenerArray = listeners[ event.type ];
256
257		if ( listenerArray !== undefined ) {
258
259			event.target = this;
260
261			// Make a copy, in case listeners are removed while iterating.
262			const array = listenerArray.slice( 0 );
263
264			for ( let i = 0, l = array.length; i < l; i ++ ) {
265
266				array[ i ].call( this, event );
267
268			}
269
270			event.target = null;
271
272		}
273
274	}
275
276}
277
278const _lut = [ '00', '01', '02', '03', '04', '05', '06', '07', '08', '09', '0a', '0b', '0c', '0d', '0e', '0f', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '1a', '1b', '1c', '1d', '1e', '1f', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '2a', '2b', '2c', '2d', '2e', '2f', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '3a', '3b', '3c', '3d', '3e', '3f', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49', '4a', '4b', '4c', '4d', '4e', '4f', '50', '51', '52', '53', '54', '55', '56', '57', '58', '59', '5a', '5b', '5c', '5d', '5e', '5f', '60', '61', '62', '63', '64', '65', '66', '67', '68', '69', '6a', '6b', '6c', '6d', '6e', '6f', '70', '71', '72', '73', '74', '75', '76', '77', '78', '79', '7a', '7b', '7c', '7d', '7e', '7f', '80', '81', '82', '83', '84', '85', '86', '87', '88', '89', '8a', '8b', '8c', '8d', '8e', '8f', '90', '91', '92', '93', '94', '95', '96', '97', '98', '99', '9a', '9b', '9c', '9d', '9e', '9f', 'a0', 'a1', 'a2', 'a3', 'a4', 'a5', 'a6', 'a7', 'a8', 'a9', 'aa', 'ab', 'ac', 'ad', 'ae', 'af', 'b0', 'b1', 'b2', 'b3', 'b4', 'b5', 'b6', 'b7', 'b8', 'b9', 'ba', 'bb', 'bc', 'bd', 'be', 'bf', 'c0', 'c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8', 'c9', 'ca', 'cb', 'cc', 'cd', 'ce', 'cf', 'd0', 'd1', 'd2', 'd3', 'd4', 'd5', 'd6', 'd7', 'd8', 'd9', 'da', 'db', 'dc', 'dd', 'de', 'df', 'e0', 'e1', 'e2', 'e3', 'e4', 'e5', 'e6', 'e7', 'e8', 'e9', 'ea', 'eb', 'ec', 'ed', 'ee', 'ef', 'f0', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'fa', 'fb', 'fc', 'fd', 'fe', 'ff' ];
279
280let _seed = 1234567;
281
282
283const DEG2RAD = Math.PI / 180;
284const RAD2DEG = 180 / Math.PI;
285
286// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
287function generateUUID() {
288
289	const d0 = Math.random() * 0xffffffff | 0;
290	const d1 = Math.random() * 0xffffffff | 0;
291	const d2 = Math.random() * 0xffffffff | 0;
292	const d3 = Math.random() * 0xffffffff | 0;
293	const uuid = _lut[ d0 & 0xff ] + _lut[ d0 >> 8 & 0xff ] + _lut[ d0 >> 16 & 0xff ] + _lut[ d0 >> 24 & 0xff ] + '-' +
294			_lut[ d1 & 0xff ] + _lut[ d1 >> 8 & 0xff ] + '-' + _lut[ d1 >> 16 & 0x0f | 0x40 ] + _lut[ d1 >> 24 & 0xff ] + '-' +
295			_lut[ d2 & 0x3f | 0x80 ] + _lut[ d2 >> 8 & 0xff ] + '-' + _lut[ d2 >> 16 & 0xff ] + _lut[ d2 >> 24 & 0xff ] +
296			_lut[ d3 & 0xff ] + _lut[ d3 >> 8 & 0xff ] + _lut[ d3 >> 16 & 0xff ] + _lut[ d3 >> 24 & 0xff ];
297
298	// .toLowerCase() here flattens concatenated strings to save heap memory space.
299	return uuid.toLowerCase();
300
301}
302
303function clamp( value, min, max ) {
304
305	return Math.max( min, Math.min( max, value ) );
306
307}
308
309// compute euclidean modulo of m % n
310// https://en.wikipedia.org/wiki/Modulo_operation
311function euclideanModulo( n, m ) {
312
313	return ( ( n % m ) + m ) % m;
314
315}
316
317// Linear mapping from range <a1, a2> to range <b1, b2>
318function mapLinear( x, a1, a2, b1, b2 ) {
319
320	return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );
321
322}
323
324// https://www.gamedev.net/tutorials/programming/general-and-gameplay-programming/inverse-lerp-a-super-useful-yet-often-overlooked-function-r5230/
325function inverseLerp( x, y, value ) {
326
327	if ( x !== y ) {
328
329		return ( value - x ) / ( y - x );
330
331	} else {
332
333		return 0;
334
335	}
336
337}
338
339// https://en.wikipedia.org/wiki/Linear_interpolation
340function lerp( x, y, t ) {
341
342	return ( 1 - t ) * x + t * y;
343
344}
345
346// http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
347function damp( x, y, lambda, dt ) {
348
349	return lerp( x, y, 1 - Math.exp( - lambda * dt ) );
350
351}
352
353// https://www.desmos.com/calculator/vcsjnyz7x4
354function pingpong( x, length = 1 ) {
355
356	return length - Math.abs( euclideanModulo( x, length * 2 ) - length );
357
358}
359
360// http://en.wikipedia.org/wiki/Smoothstep
361function smoothstep( x, min, max ) {
362
363	if ( x <= min ) return 0;
364	if ( x >= max ) return 1;
365
366	x = ( x - min ) / ( max - min );
367
368	return x * x * ( 3 - 2 * x );
369
370}
371
372function smootherstep( x, min, max ) {
373
374	if ( x <= min ) return 0;
375	if ( x >= max ) return 1;
376
377	x = ( x - min ) / ( max - min );
378
379	return x * x * x * ( x * ( x * 6 - 15 ) + 10 );
380
381}
382
383// Random integer from <low, high> interval
384function randInt( low, high ) {
385
386	return low + Math.floor( Math.random() * ( high - low + 1 ) );
387
388}
389
390// Random float from <low, high> interval
391function randFloat( low, high ) {
392
393	return low + Math.random() * ( high - low );
394
395}
396
397// Random float from <-range/2, range/2> interval
398function randFloatSpread( range ) {
399
400	return range * ( 0.5 - Math.random() );
401
402}
403

404// Deterministic pseudo-random float in the interval [ 0, 1 ]
405function seededRandom( s ) {
406
407	if ( s !== undefined ) _seed = s;
408
409	// Mulberry32 generator
410
411	let t = _seed += 0x6D2B79F5;
412
413	t = Math.imul( t ^ t >>> 15, t | 1 );
414
415	t ^= t + Math.imul( t ^ t >>> 7, t | 61 );
416
417	return ( ( t ^ t >>> 14 ) >>> 0 ) / 4294967296;
418
419}
420
421function degToRad( degrees ) {
422
423	return degrees * DEG2RAD;
424
425}
426
427function radToDeg( radians ) {
428
429	return radians * RAD2DEG;
430
431}
432
433function isPowerOfTwo( value ) {
434
435	return ( value & ( value - 1 ) ) === 0 && value !== 0;
436
437}
438
439function ceilPowerOfTwo( value ) {
440
441	return Math.pow( 2, Math.ceil( Math.log( value ) / Math.LN2 ) );
442
443}
444
445function floorPowerOfTwo( value ) {
446
447	return Math.pow( 2, Math.floor( Math.log( value ) / Math.LN2 ) );
448
449}
450
451function setQuaternionFromProperEuler( q, a, b, c, order ) {
452
453	// Intrinsic Proper Euler Angles - see https://en.wikipedia.org/wiki/Euler_angles
454
455	// rotations are applied to the axes in the order specified by 'order'
456	// rotation by angle 'a' is applied first, then by angle 'b', then by angle 'c'
457	// angles are in radians
458
459	const cos = Math.cos;
460	const sin = Math.sin;
461
462	const c2 = cos( b / 2 );
463	const s2 = sin( b / 2 );
464
465	const c13 = cos( ( a + c ) / 2 );
466	const s13 = sin( ( a + c ) / 2 );
467
468	const c1_3 = cos( ( a - c ) / 2 );
469	const s1_3 = sin( ( a - c ) / 2 );
470
471	const c3_1 = cos( ( c - a ) / 2 );
472	const s3_1 = sin( ( c - a ) / 2 );
473
474	switch ( order ) {
475
476		case 'XYX':
477			q.set( c2 * s13, s2 * c1_3, s2 * s1_3, c2 * c13 );
478			break;
479
480		case 'YZY':
481			q.set( s2 * s1_3, c2 * s13, s2 * c1_3, c2 * c13 );
482			break;
483
484		case 'ZXZ':
485			q.set( s2 * c1_3, s2 * s1_3, c2 * s13, c2 * c13 );
486			break;
487
488		case 'XZX':
489			q.set( c2 * s13, s2 * s3_1, s2 * c3_1, c2 * c13 );
490			break;
491
492		case 'YXY':
493			q.set( s2 * c3_1, c2 * s13, s2 * s3_1, c2 * c13 );
494			break;
495
496		case 'ZYZ':
497			q.set( s2 * s3_1, s2 * c3_1, c2 * s13, c2 * c13 );
498			break;
499
500		default:
501			console.warn( 'THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: ' + order );
502
503	}
504
505}
506
507function denormalize( value, array ) {
508
509	switch ( array.constructor ) {
510
511		case Float32Array:
512
513			return value;
514
515		case Uint16Array:
516
517			return value / 65535.0;
518
519		case Uint8Array:
520
521			return value / 255.0;
522
523		case Int16Array:
524
525			return Math.max( value / 32767.0, - 1.0 );
526
527		case Int8Array:
528
529			return Math.max( value / 127.0, - 1.0 );
530
531		default:
532
533			throw new Error( 'Invalid component type.' );
534
535	}
536
537}
538
539function normalize( value, array ) {
540
541	switch ( array.constructor ) {
542
543		case Float32Array:
544
545			return value;
546
547		case Uint16Array:
548
549			return Math.round( value * 65535.0 );
550
551		case Uint8Array:
552
553			return Math.round( value * 255.0 );
554
555		case Int16Array:
556
557			return Math.round( value * 32767.0 );
558
559		case Int8Array:
560
561			return Math.round( value * 127.0 );
562
563		default:
564
565			throw new Error( 'Invalid component type.' );
566
567	}
568
569}
570
571const MathUtils = {
572	DEG2RAD: DEG2RAD,
573	RAD2DEG: RAD2DEG,
574	generateUUID: generateUUID,
575	clamp: clamp,
576	euclideanModulo: euclideanModulo,
577	mapLinear: mapLinear,
578	inverseLerp: inverseLerp,
579	lerp: lerp,
580	damp: damp,
581	pingpong: pingpong,
582	smoothstep: smoothstep,
583	smootherstep: smootherstep,
584	randInt: randInt,
585	randFloat: randFloat,
586	randFloatSpread: randFloatSpread,
587	seededRandom: seededRandom,
588	degToRad: degToRad,
589	radToDeg: radToDeg,
590	isPowerOfTwo: isPowerOfTwo,
591	ceilPowerOfTwo: ceilPowerOfTwo,
592	floorPowerOfTwo: floorPowerOfTwo,
593	setQuaternionFromProperEuler: setQuaternionFromProperEuler,
594	normalize: normalize,
595	denormalize: denormalize
596};
597
598class Vector2 {
599
600	constructor( x = 0, y = 0 ) {
601
602		Vector2.prototype.isVector2 = true;
603
604		this.x = x;
605		this.y = y;
606
607	}
608
609	get width() {
610
611		return this.x;
612
613	}
614
615	set width( value ) {
616
617		this.x = value;
618
619	}
620
621	get height() {
622
623		return this.y;
624
625	}
626
627	set height( value ) {
628
629		this.y = value;
630
631	}
632
633	set( x, y ) {
634
635		this.x = x;
636		this.y = y;
637
638		return this;
639
640	}
641
642	setScalar( scalar ) {
643
644		this.x = scalar;
645		this.y = scalar;
646
647		return this;
648
649	}
650
651	setX( x ) {
652
653		this.x = x;
654
655		return this;
656
657	}
658
659	setY( y ) {
660
661		this.y = y;
662
663		return this;
664
665	}
666
667	setComponent( index, value ) {
668
669		switch ( index ) {
670
671			case 0: this.x = value; break;
672			case 1: this.y = value; break;
673			default: throw new Error( 'index is out of range: ' + index );
674
675		}
676
677		return this;
678
679	}
680
681	getComponent( index ) {
682
683		switch ( index ) {
684
685			case 0: return this.x;
686			case 1: return this.y;
687			default: throw new Error( 'index is out of range: ' + index );
688
689		}
690
691	}
692
693	clone() {
694
695		return new this.constructor( this.x, this.y );
696
697	}
698
699	copy( v ) {
700
701		this.x = v.x;
702		this.y = v.y;
703
704		return this;
705
706	}
707
708	add( v ) {
709
710		this.x += v.x;
711		this.y += v.y;
712
713		return this;
714
715	}
716
717	addScalar( s ) {
718
719		this.x += s;
720		this.y += s;
721
722		return this;
723
724	}
725
726	addVectors( a, b ) {
727
728		this.x = a.x + b.x;
729		this.y = a.y + b.y;
730
731		return this;
732
733	}
734
735	addScaledVector( v, s ) {
736
737		this.x += v.x * s;
738		this.y += v.y * s;
739
740		return this;
741
742	}
743
744	sub( v ) {
745
746		this.x -= v.x;
747		this.y -= v.y;
748
749		return this;
750
751	}
752
753	subScalar( s ) {
754
755		this.x -= s;
756		this.y -= s;
757
758		return this;
759
760	}
761
762	subVectors( a, b ) {
763
764		this.x = a.x - b.x;
765		this.y = a.y - b.y;
766
767		return this;
768
769	}
770
771	multiply( v ) {
772
773		this.x *= v.x;
774		this.y *= v.y;
775
776		return this;
777
778	}
779
780	multiplyScalar( scalar ) {
781
782		this.x *= scalar;
783		this.y *= scalar;
784
785		return this;
786
787	}
788
789	divide( v ) {
790
791		this.x /= v.x;
792		this.y /= v.y;
793
794		return this;
795
796	}
797
798	divideScalar( scalar ) {
799
800		return this.multiplyScalar( 1 / scalar );
801
802	}
803
804	applyMatrix3( m ) {
805
806		const x = this.x, y = this.y;
807		const e = m.elements;
808
809		this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ];
810		this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ];
811
812		return this;
813
814	}
815
816	min( v ) {
817
818		this.x = Math.min( this.x, v.x );
819		this.y = Math.min( this.y, v.y );
820
821		return this;
822
823	}
824
825	max( v ) {
826
827		this.x = Math.max( this.x, v.x );
828		this.y = Math.max( this.y, v.y );
829
830		return this;
831
832	}
833
834	clamp( min, max ) {
835
836		// assumes min < max, componentwise
837
838		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
839		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
840
841		return this;
842
843	}
844
845	clampScalar( minVal, maxVal ) {
846
847		this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
848		this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
849
850		return this;
851
852	}
853
854	clampLength( min, max ) {
855
856		const length = this.length();
857
858		return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
859
860	}
861
862	floor() {
863
864		this.x = Math.floor( this.x );
865		this.y = Math.floor( this.y );
866
867		return this;
868
869	}
870
871	ceil() {
872
873		this.x = Math.ceil( this.x );
874		this.y = Math.ceil( this.y );
875
876		return this;
877
878	}
879
880	round() {
881
882		this.x = Math.round( this.x );
883		this.y = Math.round( this.y );
884
885		return this;
886
887	}
888
889	roundToZero() {
890
891		this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
892		this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
893
894		return this;
895
896	}
897
898	negate() {
899
900		this.x = - this.x;
901		this.y = - this.y;
902
903		return this;
904
905	}
906
907	dot( v ) {
908
909		return this.x * v.x + this.y * v.y;
910
911	}
912
913	cross( v ) {
914
915		return this.x * v.y - this.y * v.x;
916
917	}
918
919	lengthSq() {
920
921		return this.x * this.x + this.y * this.y;
922
923	}
924
925	length() {
926
927		return Math.sqrt( this.x * this.x + this.y * this.y );
928
929	}
930
931	manhattanLength() {
932
933		return Math.abs( this.x ) + Math.abs( this.y );
934
935	}
936
937	normalize() {
938
939		return this.divideScalar( this.length() || 1 );
940
941	}
942
943	angle() {
944
945		// computes the angle in radians with respect to the positive x-axis
946
947		const angle = Math.atan2( - this.y, - this.x ) + Math.PI;
948
949		return angle;
950
951	}
952
953	distanceTo( v ) {
954
955		return Math.sqrt( this.distanceToSquared( v ) );
956
957	}
958
959	distanceToSquared( v ) {
960
961		const dx = this.x - v.x, dy = this.y - v.y;
962		return dx * dx + dy * dy;
963
964	}
965
966	manhattanDistanceTo( v ) {
967
968		return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y );
969
970	}
971
972	setLength( length ) {
973
974		return this.normalize().multiplyScalar( length );
975
976	}
977
978	lerp( v, alpha ) {
979
980		this.x += ( v.x - this.x ) * alpha;
981		this.y += ( v.y - this.y ) * alpha;
982
983		return this;
984
985	}
986
987	lerpVectors( v1, v2, alpha ) {
988
989		this.x = v1.x + ( v2.x - v1.x ) * alpha;
990		this.y = v1.y + ( v2.y - v1.y ) * alpha;
991
992		return this;
993
994	}
995
996	equals( v ) {
997
998		return ( ( v.x === this.x ) && ( v.y === this.y ) );
999
1000	}
1001
1002	fromArray( array, offset = 0 ) {
1003
1004		this.x = array[ offset ];
1005		this.y = array[ offset + 1 ];
1006
1007		return this;
1008
1009	}
1010
1011	toArray( array = [], offset = 0 ) {
1012
1013		array[ offset ] = this.x;
1014		array[ offset + 1 ] = this.y;
1015
1016		return array;
1017
1018	}
1019
1020	fromBufferAttribute( attribute, index ) {
1021
1022		this.x = attribute.getX( index );
1023		this.y = attribute.getY( index );
1024
1025		return this;
1026
1027	}
1028

1029	rotateAround( center, angle ) {
1030
1031		const c = Math.cos( angle ), s = Math.sin( angle );
1032
1033		const x = this.x - center.x;
1034		const y = this.y - center.y;
1035
1036		this.x = x * c - y * s + center.x;
1037		this.y = x * s + y * c + center.y;
1038
1039		return this;
1040
1041	}
1042
1043	random() {
1044
1045		this.x = Math.random();
1046		this.y = Math.random();
1047
1048		return this;
1049
1050	}
1051
1052	*[ Symbol.iterator ]() {
1053
1054		yield this.x;
1055		yield this.y;
1056
1057	}
1058
1059}
1060
1061class Matrix3 {
1062
1063	constructor() {
1064
1065		Matrix3.prototype.isMatrix3 = true;
1066
1067		this.elements = [
1068
1069			1, 0, 0,
1070			0, 1, 0,
1071			0, 0, 1
1072
1073		];
1074
1075	}
1076
1077	set( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {
1078
1079		const te = this.elements;
1080
1081		te[ 0 ] = n11; te[ 1 ] = n21; te[ 2 ] = n31;
1082		te[ 3 ] = n12; te[ 4 ] = n22; te[ 5 ] = n32;
1083		te[ 6 ] = n13; te[ 7 ] = n23; te[ 8 ] = n33;
1084
1085		return this;
1086
1087	}
1088
1089	identity() {
1090
1091		this.set(
1092
1093			1, 0, 0,
1094			0, 1, 0,
1095			0, 0, 1
1096
1097		);
1098
1099		return this;
1100
1101	}
1102
1103	copy( m ) {
1104
1105		const te = this.elements;
1106		const me = m.elements;
1107
1108		te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ];
1109		te[ 3 ] = me[ 3 ]; te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ];
1110		te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; te[ 8 ] = me[ 8 ];
1111
1112		return this;
1113
1114	}
1115
1116	extractBasis( xAxis, yAxis, zAxis ) {
1117
1118		xAxis.setFromMatrix3Column( this, 0 );
1119		yAxis.setFromMatrix3Column( this, 1 );
1120		zAxis.setFromMatrix3Column( this, 2 );
1121
1122		return this;
1123
1124	}
1125
1126	setFromMatrix4( m ) {
1127
1128		const me = m.elements;
1129
1130		this.set(
1131
1132			me[ 0 ], me[ 4 ], me[ 8 ],
1133			me[ 1 ], me[ 5 ], me[ 9 ],
1134			me[ 2 ], me[ 6 ], me[ 10 ]
1135
1136		);
1137
1138		return this;
1139
1140	}
1141
1142	multiply( m ) {
1143
1144		return this.multiplyMatrices( this, m );
1145
1146	}
1147
1148	premultiply( m ) {
1149
1150		return this.multiplyMatrices( m, this );
1151
1152	}
1153
1154	multiplyMatrices( a, b ) {
1155
1156		const ae = a.elements;
1157		const be = b.elements;
1158		const te = this.elements;
1159
1160		const a11 = ae[ 0 ], a12 = ae[ 3 ], a13 = ae[ 6 ];
1161		const a21 = ae[ 1 ], a22 = ae[ 4 ], a23 = ae[ 7 ];
1162		const a31 = ae[ 2 ], a32 = ae[ 5 ], a33 = ae[ 8 ];
1163
1164		const b11 = be[ 0 ], b12 = be[ 3 ], b13 = be[ 6 ];
1165		const b21 = be[ 1 ], b22 = be[ 4 ], b23 = be[ 7 ];
1166		const b31 = be[ 2 ], b32 = be[ 5 ], b33 = be[ 8 ];
1167
1168		te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31;
1169		te[ 3 ] = a11 * b12 + a12 * b22 + a13 * b32;
1170		te[ 6 ] = a11 * b13 + a12 * b23 + a13 * b33;
1171
1172		te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31;
1173		te[ 4 ] = a21 * b12 + a22 * b22 + a23 * b32;
1174		te[ 7 ] = a21 * b13 + a22 * b23 + a23 * b33;
1175
1176		te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31;
1177		te[ 5 ] = a31 * b12 + a32 * b22 + a33 * b32;
1178		te[ 8 ] = a31 * b13 + a32 * b23 + a33 * b33;
1179
1180		return this;
1181
1182	}
1183
1184	multiplyScalar( s ) {
1185
1186		const te = this.elements;
1187
1188		te[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s;
1189		te[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s;
1190		te[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s;
1191
1192		return this;
1193
1194	}
1195
1196	determinant() {
1197
1198		const te = this.elements;
1199
1200		const a = te[ 0 ], b = te[ 1 ], c = te[ 2 ],
1201			d = te[ 3 ], e = te[ 4 ], f = te[ 5 ],
1202			g = te[ 6 ], h = te[ 7 ], i = te[ 8 ];
1203
1204		return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;
1205
1206	}
1207
1208	invert() {
1209
1210		const te = this.elements,
1211
1212			n11 = te[ 0 ], n21 = te[ 1 ], n31 = te[ 2 ],
1213			n12 = te[ 3 ], n22 = te[ 4 ], n32 = te[ 5 ],
1214			n13 = te[ 6 ], n23 = te[ 7 ], n33 = te[ 8 ],
1215
1216			t11 = n33 * n22 - n32 * n23,
1217			t12 = n32 * n13 - n33 * n12,
1218			t13 = n23 * n12 - n22 * n13,
1219
1220			det = n11 * t11 + n21 * t12 + n31 * t13;
1221
1222		if ( det === 0 ) return this.set( 0, 0, 0, 0, 0, 0, 0, 0, 0 );
1223
1224		const detInv = 1 / det;
1225
1226		te[ 0 ] = t11 * detInv;
1227		te[ 1 ] = ( n31 * n23 - n33 * n21 ) * detInv;
1228		te[ 2 ] = ( n32 * n21 - n31 * n22 ) * detInv;
1229
1230		te[ 3 ] = t12 * detInv;
1231		te[ 4 ] = ( n33 * n11 - n31 * n13 ) * detInv;
1232		te[ 5 ] = ( n31 * n12 - n32 * n11 ) * detInv;
1233
1234		te[ 6 ] = t13 * detInv;
1235		te[ 7 ] = ( n21 * n13 - n23 * n11 ) * detInv;
1236		te[ 8 ] = ( n22 * n11 - n21 * n12 ) * detInv;
1237
1238		return this;
1239
1240	}
1241
1242	transpose() {
1243
1244		let tmp;
1245		const m = this.elements;
1246
1247		tmp = m[ 1 ]; m[ 1 ] = m[ 3 ]; m[ 3 ] = tmp;
1248		tmp = m[ 2 ]; m[ 2 ] = m[ 6 ]; m[ 6 ] = tmp;
1249		tmp = m[ 5 ]; m[ 5 ] = m[ 7 ]; m[ 7 ] = tmp;
1250
1251		return this;
1252
1253	}
1254
1255	getNormalMatrix( matrix4 ) {
1256
1257		return this.setFromMatrix4( matrix4 ).invert().transpose();
1258
1259	}
1260
1261	transposeIntoArray( r ) {
1262
1263		const m = this.elements;
1264
1265		r[ 0 ] = m[ 0 ];
1266		r[ 1 ] = m[ 3 ];
1267		r[ 2 ] = m[ 6 ];
1268		r[ 3 ] = m[ 1 ];
1269		r[ 4 ] = m[ 4 ];
1270		r[ 5 ] = m[ 7 ];
1271		r[ 6 ] = m[ 2 ];
1272		r[ 7 ] = m[ 5 ];
1273		r[ 8 ] = m[ 8 ];
1274
1275		return this;
1276
1277	}
1278
1279	setUvTransform( tx, ty, sx, sy, rotation, cx, cy ) {
1280
1281		const c = Math.cos( rotation );
1282		const s = Math.sin( rotation );
1283
1284		this.set(

1285			sx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx,
1286			- sy * s, sy * c, - sy * ( - s * cx + c * cy ) + cy + ty,
1287			0, 0, 1
1288		);
1289
1290		return this;
1291
1292	}
1293
1294	//
1295
1296	scale( sx, sy ) {
1297
1298		this.premultiply( _m3.makeScale( sx, sy ) );
1299
1300		return this;
1301
1302	}
1303
1304	rotate( theta ) {
1305
1306		this.premultiply( _m3.makeRotation( - theta ) );
1307
1308		return this;
1309
1310	}
1311
1312	translate( tx, ty ) {
1313
1314		this.premultiply( _m3.makeTranslation( tx, ty ) );
1315
1316		return this;
1317
1318	}
1319
1320	// for 2D Transforms
1321
1322	makeTranslation( x, y ) {
1323
1324		this.set(
1325
1326			1, 0, x,
1327			0, 1, y,
1328			0, 0, 1
1329
1330		);
1331
1332		return this;
1333
1334	}
1335
1336	makeRotation( theta ) {
1337
1338		// counterclockwise
1339
1340		const c = Math.cos( theta );
1341		const s = Math.sin( theta );
1342
1343		this.set(
1344
1345			c, - s, 0,
1346			s, c, 0,
1347			0, 0, 1
1348
1349		);
1350
1351		return this;
1352
1353	}
1354
1355	makeScale( x, y ) {
1356
1357		this.set(
1358
1359			x, 0, 0,
1360			0, y, 0,
1361			0, 0, 1
1362
1363		);
1364
1365		return this;
1366
1367	}
1368
1369	//
1370
1371	equals( matrix ) {
1372
1373		const te = this.elements;
1374		const me = matrix.elements;
1375
1376		for ( let i = 0; i < 9; i ++ ) {
1377
1378			if ( te[ i ] !== me[ i ] ) return false;
1379
1380		}
1381
1382		return true;
1383
1384	}
1385
1386	fromArray( array, offset = 0 ) {
1387
1388		for ( let i = 0; i < 9; i ++ ) {
1389
1390			this.elements[ i ] = array[ i + offset ];
1391
1392		}
1393
1394		return this;
1395
1396	}
1397
1398	toArray( array = [], offset = 0 ) {
1399
1400		const te = this.elements;
1401
1402		array[ offset ] = te[ 0 ];
1403		array[ offset + 1 ] = te[ 1 ];
1404		array[ offset + 2 ] = te[ 2 ];
1405
1406		array[ offset + 3 ] = te[ 3 ];
1407		array[ offset + 4 ] = te[ 4 ];
1408		array[ offset + 5 ] = te[ 5 ];
1409
1410		array[ offset + 6 ] = te[ 6 ];
1411		array[ offset + 7 ] = te[ 7 ];
1412		array[ offset + 8 ] = te[ 8 ];
1413
1414		return array;
1415
1416	}
1417
1418	clone() {
1419
1420		return new this.constructor().fromArray( this.elements );
1421
1422	}
1423
1424}
1425
1426const _m3 = /*@__PURE__*/ new Matrix3();
1427
1428function arrayNeedsUint32( array ) {
1429
1430	// assumes larger values usually on last
1431
1432	for ( let i = array.length - 1; i >= 0; -- i ) {
1433
1434		if ( array[ i ] >= 65535 ) return true; // account for PRIMITIVE_RESTART_FIXED_INDEX, #24565
1435
1436	}
1437
1438	return false;
1439
1440}
1441
1442const TYPED_ARRAYS = {
1443	Int8Array: Int8Array,
1444	Uint8Array: Uint8Array,
1445	Uint8ClampedArray: Uint8ClampedArray,
1446	Int16Array: Int16Array,
1447	Uint16Array: Uint16Array,
1448	Int32Array: Int32Array,
1449	Uint32Array: Uint32Array,
1450	Float32Array: Float32Array,
1451	Float64Array: Float64Array
1452};
1453
1454function getTypedArray( type, buffer ) {
1455
1456	return new TYPED_ARRAYS[ type ]( buffer );
1457
1458}
1459
1460function createElementNS( name ) {
1461
1462	return document.createElementNS( 'http://www.w3.org/1999/xhtml', name );
1463
1464}
1465
1466class Quaternion {
1467
1468	constructor( x = 0, y = 0, z = 0, w = 1 ) {
1469
1470		this.isQuaternion = true;
1471
1472		this._x = x;
1473		this._y = y;
1474		this._z = z;
1475		this._w = w;
1476
1477	}
1478
1479	static slerpFlat( dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) {
1480
1481		// fuzz-free, array-based Quaternion SLERP operation
1482
1483		let x0 = src0[ srcOffset0 + 0 ],
1484			y0 = src0[ srcOffset0 + 1 ],
1485			z0 = src0[ srcOffset0 + 2 ],
1486			w0 = src0[ srcOffset0 + 3 ];
1487
1488		const x1 = src1[ srcOffset1 + 0 ],
1489			y1 = src1[ srcOffset1 + 1 ],
1490			z1 = src1[ srcOffset1 + 2 ],
1491			w1 = src1[ srcOffset1 + 3 ];
1492
1493		if ( t === 0 ) {
1494
1495			dst[ dstOffset + 0 ] = x0;
1496			dst[ dstOffset + 1 ] = y0;
1497			dst[ dstOffset + 2 ] = z0;
1498			dst[ dstOffset + 3 ] = w0;
1499			return;
1500
1501		}
1502
1503		if ( t === 1 ) {
1504
1505			dst[ dstOffset + 0 ] = x1;
1506			dst[ dstOffset + 1 ] = y1;
1507			dst[ dstOffset + 2 ] = z1;
1508			dst[ dstOffset + 3 ] = w1;
1509			return;
1510
1511		}
1512
1513		if ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) {
1514
1515			let s = 1 - t;
1516			const cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
1517				dir = ( cos >= 0 ? 1 : - 1 ),
1518				sqrSin = 1 - cos * cos;
1519
1520			// Skip the Slerp for tiny steps to avoid numeric problems:
1521			if ( sqrSin > Number.EPSILON ) {
1522
1523				const sin = Math.sqrt( sqrSin ),
1524					len = Math.atan2( sin, cos * dir );
1525
1526				s = Math.sin( s * len ) / sin;
1527				t = Math.sin( t * len ) / sin;
1528
1529			}
1530
1531			const tDir = t * dir;
1532
1533			x0 = x0 * s + x1 * tDir;
1534			y0 = y0 * s + y1 * tDir;
1535			z0 = z0 * s + z1 * tDir;
1536			w0 = w0 * s + w1 * tDir;
1537
1538			// Normalize in case we just did a lerp:
1539			if ( s === 1 - t ) {
1540
1541				const f = 1 / Math.sqrt( x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0 );
1542
1543				x0 *= f;
1544				y0 *= f;
1545				z0 *= f;
1546				w0 *= f;
1547
1548			}
1549
1550		}
1551
1552		dst[ dstOffset ] = x0;
1553		dst[ dstOffset + 1 ] = y0;
1554		dst[ dstOffset + 2 ] = z0;
1555		dst[ dstOffset + 3 ] = w0;
1556
1557	}
1558
1559	static multiplyQuaternionsFlat( dst, dstOffset, src0, srcOffset0, src1, srcOffset1 ) {
1560
1561		const x0 = src0[ srcOffset0 ];
1562		const y0 = src0[ srcOffset0 + 1 ];
1563		const z0 = src0[ srcOffset0 + 2 ];
1564		const w0 = src0[ srcOffset0 + 3 ];
1565
1566		const x1 = src1[ srcOffset1 ];
1567		const y1 = src1[ srcOffset1 + 1 ];
1568		const z1 = src1[ srcOffset1 + 2 ];
1569		const w1 = src1[ srcOffset1 + 3 ];
1570
1571		dst[ dstOffset ] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
1572		dst[ dstOffset + 1 ] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
1573		dst[ dstOffset + 2 ] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
1574		dst[ dstOffset + 3 ] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
1575
1576		return dst;
1577
1578	}
1579
1580	get x() {
1581
1582		return this._x;
1583
1584	}
1585
1586	set x( value ) {
1587
1588		this._x = value;
1589		this._onChangeCallback();
1590
1591	}
1592
1593	get y() {
1594
1595		return this._y;
1596
1597	}
1598
1599	set y( value ) {
1600
1601		this._y = value;
1602		this._onChangeCallback();
1603
1604	}
1605
1606	get z() {
1607
1608		return this._z;
1609
1610	}
1611
1612	set z( value ) {
1613
1614		this._z = value;
1615		this._onChangeCallback();
1616
1617	}
1618
1619	get w() {
1620
1621		return this._w;
1622
1623	}
1624
1625	set w( value ) {
1626
1627		this._w = value;
1628		this._onChangeCallback();
1629
1630	}
1631
1632	set( x, y, z, w ) {
1633
1634		this._x = x;
1635		this._y = y;
1636		this._z = z;
1637		this._w = w;
1638
1639		this._onChangeCallback();
1640
1641		return this;
1642
1643	}
1644
1645	clone() {
1646
1647		return new this.constructor( this._x, this._y, this._z, this._w );
1648
1649	}
1650
1651	copy( quaternion ) {
1652
1653		this._x = quaternion.x;
1654		this._y = quaternion.y;
1655		this._z = quaternion.z;
1656		this._w = quaternion.w;
1657
1658		this._onChangeCallback();
1659
1660		return this;
1661
1662	}
1663
1664	setFromEuler( euler, update ) {
1665
1666		const x = euler._x, y = euler._y, z = euler._z, order = euler._order;
1667
1668		// http://www.mathworks.com/matlabcentral/fileexchange/
1669		// 	20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
1670		//	content/SpinCalc.m
1671
1672		const cos = Math.cos;
1673		const sin = Math.sin;
1674
1675		const c1 = cos( x / 2 );
1676		const c2 = cos( y / 2 );
1677		const c3 = cos( z / 2 );
1678
1679		const s1 = sin( x / 2 );
1680		const s2 = sin( y / 2 );
1681		const s3 = sin( z / 2 );
1682
1683		switch ( order ) {
1684
1685			case 'XYZ':
1686				this._x = s1 * c2 * c3 + c1 * s2 * s3;
1687				this._y = c1 * s2 * c3 - s1 * c2 * s3;
1688				this._z = c1 * c2 * s3 + s1 * s2 * c3;
1689				this._w = c1 * c2 * c3 - s1 * s2 * s3;
1690				break;
1691
1692			case 'YXZ':
1693				this._x = s1 * c2 * c3 + c1 * s2 * s3;
1694				this._y = c1 * s2 * c3 - s1 * c2 * s3;
1695				this._z = c1 * c2 * s3 - s1 * s2 * c3;
1696				this._w = c1 * c2 * c3 + s1 * s2 * s3;
1697				break;
1698
1699			case 'ZXY':
1700				this._x = s1 * c2 * c3 - c1 * s2 * s3;
1701				this._y = c1 * s2 * c3 + s1 * c2 * s3;
1702				this._z = c1 * c2 * s3 + s1 * s2 * c3;
1703				this._w = c1 * c2 * c3 - s1 * s2 * s3;
1704				break;
1705
1706			case 'ZYX':
1707				this._x = s1 * c2 * c3 - c1 * s2 * s3;
1708				this._y = c1 * s2 * c3 + s1 * c2 * s3;
1709				this._z = c1 * c2 * s3 - s1 * s2 * c3;
1710				this._w = c1 * c2 * c3 + s1 * s2 * s3;
1711				break;
1712
1713			case 'YZX':
1714				this._x = s1 * c2 * c3 + c1 * s2 * s3;
1715				this._y = c1 * s2 * c3 + s1 * c2 * s3;
1716				this._z = c1 * c2 * s3 - s1 * s2 * c3;
1717				this._w = c1 * c2 * c3 - s1 * s2 * s3;
1718				break;
1719
1720			case 'XZY':
1721				this._x = s1 * c2 * c3 - c1 * s2 * s3;
1722				this._y = c1 * s2 * c3 - s1 * c2 * s3;
1723				this._z = c1 * c2 * s3 + s1 * s2 * c3;
1724				this._w = c1 * c2 * c3 + s1 * s2 * s3;
1725				break;
1726
1727			default:
1728				console.warn( 'THREE.Quaternion: .setFromEuler() encountered an unknown order: ' + order );
1729
1730		}
1731
1732		if ( update !== false ) this._onChangeCallback();
1733
1734		return this;
1735
1736	}
1737
1738	setFromAxisAngle( axis, angle ) {
1739
1740		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
1741
1742		// assumes axis is normalized
1743
1744		const halfAngle = angle / 2, s = Math.sin( halfAngle );
1745
1746		this._x = axis.x * s;
1747		this._y = axis.y * s;
1748		this._z = axis.z * s;
1749		this._w = Math.cos( halfAngle );
1750
1751		this._onChangeCallback();
1752
1753		return this;
1754
1755	}
1756
1757	setFromRotationMatrix( m ) {
1758
1759		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
1760
1761		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
1762
1763		const te = m.elements,
1764
1765			m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
1766			m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
1767			m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ],
1768
1769			trace = m11 + m22 + m33;
1770
1771		if ( trace > 0 ) {
1772
1773			const s = 0.5 / Math.sqrt( trace + 1.0 );
1774
1775			this._w = 0.25 / s;
1776			this._x = ( m32 - m23 ) * s;
1777			this._y = ( m13 - m31 ) * s;
1778			this._z = ( m21 - m12 ) * s;
1779
1780		} else if ( m11 > m22 && m11 > m33 ) {
1781
1782			const s = 2.0 * Math.sqrt( 1.0 + m11 - m22 - m33 );
1783
1784			this._w = ( m32 - m23 ) / s;
1785			this._x = 0.25 * s;
1786			this._y = ( m12 + m21 ) / s;
1787			this._z = ( m13 + m31 ) / s;
1788
1789		} else if ( m22 > m33 ) {
1790
1791			const s = 2.0 * Math.sqrt( 1.0 + m22 - m11 - m33 );
1792
1793			this._w = ( m13 - m31 ) / s;
1794			this._x = ( m12 + m21 ) / s;
1795			this._y = 0.25 * s;
1796			this._z = ( m23 + m32 ) / s;
1797
1798		} else {
1799
1800			const s = 2.0 * Math.sqrt( 1.0 + m33 - m11 - m22 );
1801
1802			this._w = ( m21 - m12 ) / s;
1803			this._x = ( m13 + m31 ) / s;
1804			this._y = ( m23 + m32 ) / s;
1805			this._z = 0.25 * s;
1806
1807		}
1808
1809		this._onChangeCallback();
1810
1811		return this;
1812
1813	}
1814
1815	setFromUnitVectors( vFrom, vTo ) {
1816
1817		// assumes direction vectors vFrom and vTo are normalized
1818
1819		let r = vFrom.dot( vTo ) + 1;
1820
1821		if ( r < Number.EPSILON ) {
1822
1823			// vFrom and vTo point in opposite directions
1824
1825			r = 0;
1826
1827			if ( Math.abs( vFrom.x ) > Math.abs( vFrom.z ) ) {
1828
1829				this._x = - vFrom.y;
1830				this._y = vFrom.x;
1831				this._z = 0;
1832				this._w = r;
1833
1834			} else {
1835
1836				this._x = 0;
1837				this._y = - vFrom.z;
1838				this._z = vFrom.y;
1839				this._w = r;
1840
1841			}
1842
1843		} else {
1844
1845			// crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3
1846
1847			this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
1848			this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
1849			this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
1850			this._w = r;
1851
1852		}
1853
1854		return this.normalize();
1855
1856	}
1857
1858	angleTo( q ) {
1859
1860		return 2 * Math.acos( Math.abs( clamp( this.dot( q ), - 1, 1 ) ) );
1861
1862	}
1863
1864	rotateTowards( q, step ) {
1865
1866		const angle = this.angleTo( q );
1867
1868		if ( angle === 0 ) return this;
1869
1870		const t = Math.min( 1, step / angle );
1871
1872		this.slerp( q, t );
1873
1874		return this;
1875
1876	}
1877
1878	identity() {
1879
1880		return this.set( 0, 0, 0, 1 );
1881
1882	}
1883
1884	invert() {
1885
1886		// quaternion is assumed to have unit length
1887
1888		return this.conjugate();
1889
1890	}
1891
1892	conjugate() {
1893
1894		this._x *= - 1;
1895		this._y *= - 1;
1896		this._z *= - 1;
1897
1898		this._onChangeCallback();
1899
1900		return this;
1901
1902	}
1903
1904	dot( v ) {
1905
1906		return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
1907
1908	}
1909
1910	lengthSq() {
1911
1912		return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
1913
1914	}
1915
1916	length() {
1917
1918		return Math.sqrt( this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w );
1919
1920	}
1921
1922	normalize() {
1923
1924		let l = this.length();
1925
1926		if ( l === 0 ) {
1927
1928			this._x = 0;
1929			this._y = 0;
1930			this._z = 0;
1931			this._w = 1;
1932
1933		} else {
1934
1935			l = 1 / l;
1936
1937			this._x = this._x * l;
1938			this._y = this._y * l;
1939			this._z = this._z * l;
1940			this._w = this._w * l;
1941
1942		}
1943
1944		this._onChangeCallback();
1945
1946		return this;
1947
1948	}
1949
1950	multiply( q ) {
1951
1952		return this.multiplyQuaternions( this, q );
1953
1954	}
1955
1956	premultiply( q ) {
1957
1958		return this.multiplyQuaternions( q, this );
1959
1960	}
1961
1962	multiplyQuaternions( a, b ) {
1963
1964		// from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
1965
1966		const qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;
1967		const qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;
1968
1969		this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
1970		this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
1971		this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
1972		this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
1973
1974		this._onChangeCallback();
1975
1976		return this;
1977
1978	}
1979
1980	slerp( qb, t ) {
1981
1982		if ( t === 0 ) return this;
1983		if ( t === 1 ) return this.copy( qb );
1984
1985		const x = this._x, y = this._y, z = this._z, w = this._w;
1986
1987		// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
1988
1989		let cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
1990
1991		if ( cosHalfTheta < 0 ) {
1992
1993			this._w = - qb._w;
1994			this._x = - qb._x;
1995			this._y = - qb._y;
1996			this._z = - qb._z;
1997
1998			cosHalfTheta = - cosHalfTheta;
1999
2000		} else {
2001
2002			this.copy( qb );
2003
2004		}
2005
2006		if ( cosHalfTheta >= 1.0 ) {
2007
2008			this._w = w;
2009			this._x = x;
2010			this._y = y;
2011			this._z = z;
2012
2013			return this;
2014
2015		}
2016
2017		const sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
2018
2019		if ( sqrSinHalfTheta <= Number.EPSILON ) {
2020
2021			const s = 1 - t;
2022			this._w = s * w + t * this._w;
2023			this._x = s * x + t * this._x;
2024			this._y = s * y + t * this._y;
2025			this._z = s * z + t * this._z;
2026
2027			this.normalize();
2028			this._onChangeCallback();
2029
2030			return this;
2031
2032		}
2033
2034		const sinHalfTheta = Math.sqrt( sqrSinHalfTheta );
2035		const halfTheta = Math.atan2( sinHalfTheta, cosHalfTheta );
2036		const ratioA = Math.sin( ( 1 - t ) * halfTheta ) / sinHalfTheta,
2037			ratioB = Math.sin( t * halfTheta ) / sinHalfTheta;
2038
2039		this._w = ( w * ratioA + this._w * ratioB );
2040		this._x = ( x * ratioA + this._x * ratioB );
2041		this._y = ( y * ratioA + this._y * ratioB );
2042		this._z = ( z * ratioA + this._z * ratioB );
2043
2044		this._onChangeCallback();
2045
2046		return this;
2047
2048	}
2049
2050	slerpQuaternions( qa, qb, t ) {
2051
2052		return this.copy( qa ).slerp( qb, t );
2053
2054	}
2055
2056	random() {
2057
2058		// Derived from http://planning.cs.uiuc.edu/node198.html
2059		// Note, this source uses w, x, y, z ordering,
2060		// so we swap the order below.
2061
2062		const u1 = Math.random();
2063		const sqrt1u1 = Math.sqrt( 1 - u1 );
2064		const sqrtu1 = Math.sqrt( u1 );
2065
2066		const u2 = 2 * Math.PI * Math.random();
2067
2068		const u3 = 2 * Math.PI * Math.random();
2069
2070		return this.set(
2071			sqrt1u1 * Math.cos( u2 ),
2072			sqrtu1 * Math.sin( u3 ),
2073			sqrtu1 * Math.cos( u3 ),
2074			sqrt1u1 * Math.sin( u2 ),
2075		);
2076
2077	}
2078
2079	equals( quaternion ) {
2080
2081		return ( quaternion._x === this._x ) && ( quaternion._y === this._y ) && ( quaternion._z === this._z ) && ( quaternion._w === this._w );
2082
2083	}
2084
2085	fromArray( array, offset = 0 ) {
2086
2087		this._x = array[ offset ];
2088		this._y = array[ offset + 1 ];
2089		this._z = array[ offset + 2 ];
2090		this._w = array[ offset + 3 ];
2091
2092		this._onChangeCallback();
2093
2094		return this;
2095
2096	}
2097
2098	toArray( array = [], offset = 0 ) {
2099
2100		array[ offset ] = this._x;
2101		array[ offset + 1 ] = this._y;
2102		array[ offset + 2 ] = this._z;
2103		array[ offset + 3 ] = this._w;
2104
2105		return array;
2106
2107	}
2108
2109	fromBufferAttribute( attribute, index ) {
2110
2111		this._x = attribute.getX( index );
2112		this._y = attribute.getY( index );
2113		this._z = attribute.getZ( index );
2114		this._w = attribute.getW( index );
2115
2116		return this;
2117
2118	}
2119
2120	_onChange( callback ) {
2121
2122		this._onChangeCallback = callback;
2123
2124		return this;
2125
2126	}
2127
2128	_onChangeCallback() {}
2129
2130	*[ Symbol.iterator ]() {
2131
2132		yield this._x;
2133		yield this._y;
2134		yield this._z;
2135		yield this._w;
2136
2137	}
2138
2139}
2140
2141class Vector3 {
2142
2143	constructor( x = 0, y = 0, z = 0 ) {
2144
2145		Vector3.prototype.isVector3 = true;
2146
2147		this.x = x;
2148		this.y = y;
2149		this.z = z;
2150
2151	}
2152
2153	set( x, y, z ) {
2154
2155		if ( z === undefined ) z = this.z; // sprite.scale.set(x,y)
2156
2157		this.x = x;
2158		this.y = y;
2159		this.z = z;
2160
2161		return this;
2162
2163	}
2164
2165	setScalar( scalar ) {
2166
2167		this.x = scalar;
2168		this.y = scalar;
2169		this.z = scalar;
2170
2171		return this;
2172
2173	}
2174
2175	setX( x ) {
2176
2177		this.x = x;
2178
2179		return this;
2180
2181	}
2182
2183	setY( y ) {
2184
2185		this.y = y;
2186
2187		return this;
2188
2189	}
2190
2191	setZ( z ) {
2192
2193		this.z = z;
2194
2195		return this;
2196
2197	}
2198
2199	setComponent( index, value ) {
2200
2201		switch ( index ) {
2202
2203			case 0: this.x = value; break;
2204			case 1: this.y = value; break;
2205			case 2: this.z = value; break;
2206			default: throw new Error( 'index is out of range: ' + index );
2207
2208		}
2209
2210		return this;
2211
2212	}
2213
2214	getComponent( index ) {
2215
2216		switch ( index ) {
2217
2218			case 0: return this.x;
2219			case 1: return this.y;
2220			case 2: return this.z;
2221			default: throw new Error( 'index is out of range: ' + index );
2222
2223		}
2224
2225	}
2226
2227	clone() {
2228
2229		return new this.constructor( this.x, this.y, this.z );
2230
2231	}
2232
2233	copy( v ) {
2234
2235		this.x = v.x;
2236		this.y = v.y;
2237		this.z = v.z;
2238
2239		return this;
2240
2241	}
2242
2243	add( v ) {
2244
2245		this.x += v.x;
2246		this.y += v.y;
2247		this.z += v.z;
2248
2249		return this;
2250
2251	}
2252
2253	addScalar( s ) {
2254
2255		this.x += s;
2256		this.y += s;
2257		this.z += s;
2258
2259		return this;
2260
2261	}
2262
2263	addVectors( a, b ) {
2264
2265		this.x = a.x + b.x;
2266		this.y = a.y + b.y;
2267		this.z = a.z + b.z;
2268
2269		return this;
2270
2271	}
2272
2273	addScaledVector( v, s ) {
2274
2275		this.x += v.x * s;
2276		this.y += v.y * s;
2277		this.z += v.z * s;
2278
2279		return this;
2280
2281	}
2282
2283	sub( v ) {
2284
2285		this.x -= v.x;
2286		t

2286his.y -= v.y;
2287		this.z -= v.z;
2288
2289		return this;
2290
2291	}
2292
2293	subScalar( s ) {
2294
2295		this.x -= s;
2296		this.y -= s;
2297		this.z -= s;
2298
2299		return this;
2300
2301	}
2302
2303	subVectors( a, b ) {
2304
2305		this.x = a.x - b.x;
2306		this.y = a.y - b.y;
2307		this.z = a.z - b.z;
2308
2309		return this;
2310
2311	}
2312
2313	multiply( v ) {
2314
2315		this.x *= v.x;
2316		this.y *= v.y;
2317		this.z *= v.z;
2318
2319		return this;
2320
2321	}
2322
2323	multiplyScalar( scalar ) {
2324
2325		this.x *= scalar;
2326		this.y *= scalar;
2327		this.z *= scalar;
2328
2329		return this;
2330
2331	}
2332
2333	multiplyVectors( a, b ) {
2334
2335		this.x = a.x * b.x;
2336		this.y = a.y * b.y;
2337		this.z = a.z * b.z;
2338
2339		return this;
2340
2341	}
2342
2343	applyEuler( euler ) {
2344
2345		return this.applyQuaternion( _quaternion$4.setFromEuler( euler ) );
2346
2347	}
2348
2349	applyAxisAngle( axis, angle ) {
2350
2351		return this.applyQuaternion( _quaternion$4.setFromAxisAngle( axis, angle ) );
2352
2353	}
2354
2355	applyMatrix3( m ) {
2356
2357		const x = this.x, y = this.y, z = this.z;
2358		const e = m.elements;
2359
2360		this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ] * z;
2361		this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ] * z;
2362		this.z = e[ 2 ] * x + e[ 5 ] * y + e[ 8 ] * z;
2363
2364		return this;
2365
2366	}
2367
2368	applyNormalMatrix( m ) {
2369
2370		return this.applyMatrix3( m ).normalize();
2371
2372	}
2373
2374	applyMatrix4( m ) {
2375
2376		const x = this.x, y = this.y, z = this.z;
2377		const e = m.elements;
2378
2379		const w = 1 / ( e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] );
2380
2381		this.x = ( e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] ) * w;
2382		this.y = ( e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] ) * w;
2383		this.z = ( e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] ) * w;
2384
2385		return this;
2386
2387	}
2388
2389	applyQuaternion( q ) {
2390
2391		const x = this.x, y = this.y, z = this.z;
2392		const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
2393
2394		// calculate quat * vector
2395
2396		const ix = qw * x + qy * z - qz * y;
2397		const iy = qw * y + qz * x - qx * z;
2398		const iz = qw * z + qx * y - qy * x;
2399		const iw = - qx * x - qy * y - qz * z;
2400
2401		// calculate result * inverse quat
2402
2403		this.x = ix * qw + iw * - qx + iy * - qz - iz * - qy;
2404		this.y = iy * qw + iw * - qy + iz * - qx - ix * - qz;
2405		this.z = iz * qw + iw * - qz + ix * - qy - iy * - qx;
2406
2407		return this;
2408
2409	}
2410
2411	project( camera ) {
2412
2413		return this.applyMatrix4( camera.matrixWorldInverse ).applyMatrix4( camera.projectionMatrix );
2414
2415	}
2416
2417	unproject( camera ) {
2418
2419		return this.applyMatrix4( camera.projectionMatrixInverse ).applyMatrix4( camera.matrixWorld );
2420
2421	}
2422
2423	transformDirection( m ) {
2424
2425		// input: THREE.Matrix4 affine matrix
2426		// vector interpreted as a direction
2427
2428		const x = this.x, y = this.y, z = this.z;
2429		const e = m.elements;
2430
2431		this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z;
2432		this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z;
2433		this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z;
2434
2435		return this.normalize();
2436
2437	}
2438
2439	divide( v ) {
2440
2441		this.x /= v.x;
2442		this.y /= v.y;
2443		this.z /= v.z;
2444
2445		return this;
2446
2447	}
2448
2449	divideScalar( scalar ) {
2450
2451		return this.multiplyScalar( 1 / scalar );
2452
2453	}
2454
2455	min( v ) {
2456
2457		this.x = Math.min( this.x, v.x );
2458		this.y = Math.min( this.y, v.y );
2459		this.z = Math.min( this.z, v.z );
2460
2461		return this;
2462
2463	}
2464
2465	max( v ) {
2466
2467		this.x = Math.max( this.x, v.x );
2468		this.y = Math.max( this.y, v.y );
2469		this.z = Math.max( this.z, v.z );
2470
2471		return this;
2472
2473	}
2474
2475	clamp( min, max ) {
2476
2477		// assumes min < max, componentwise
2478
2479		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
2480		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
2481		this.z = Math.max( min.z, Math.min( max.z, this.z ) );
2482
2483		return this;
2484
2485	}
2486
2487	clampScalar( minVal, maxVal ) {
2488
2489		this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
2490		this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
2491		this.z = Math.max( minVal, Math.min( maxVal, this.z ) );
2492
2493		return this;
2494
2495	}
2496
2497	clampLength( min, max ) {
2498
2499		const length = this.length();
2500
2501		return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
2502
2503	}
2504
2505	floor() {
2506
2507		this.x = Math.floor( this.x );
2508		this.y = Math.floor( this.y );
2509		this.z = Math.floor( this.z );
2510
2511		return this;
2512
2513	}
2514
2515	ceil() {
2516
2517		this.x = Math.ceil( this.x );
2518		this.y = Math.ceil( this.y );
2519		this.z = Math.ceil( this.z );
2520
2521		return this;
2522
2523	}
2524
2525	round() {
2526
2527		this.x = Math.round( this.x );
2528		this.y = Math.round( this.y );
2529		this.z = Math.round( this.z );
2530
2531		return this;
2532
2533	}
2534
2535	roundToZero() {
2536
2537		this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
2538		this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
2539		this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );
2540
2541		return this;
2542
2543	}
2544
2545	negate() {
2546
2547		this.x = - this.x;
2548		this.y = - this.y;
2549		this.z = - this.z;
2550
2551		return this;
2552
2553	}
2554
2555	dot( v ) {
2556
2557		return this.x * v.x + this.y * v.y + this.z * v.z;
2558
2559	}
2560
2561	// TODO lengthSquared?
2562
2563	lengthSq() {
2564
2565		return this.x * this.x + this.y * this.y + this.z * this.z;
2566
2567	}
2568
2569	length() {
2570
2571		return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );
2572
2573	}
2574
2575	manhattanLength() {
2576
2577		return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z );
2578
2579	}
2580
2581	normalize() {
2582
2583		return this.divideScalar( this.length() || 1 );
2584
2585	}
2586
2587	setLength( length ) {
2588
2589		return this.normalize().multiplyScalar( length );
2590
2591	}
2592
2593	lerp( v, alpha ) {
2594
2595		this.x += ( v.x - this.x ) * alpha;
2596		this.y += ( v.y - this.y ) * alpha;
2597		this.z += ( v.z - this.z ) * alpha;
2598
2599		return this;
2600
2601	}
2602
2603	lerpVectors( v1, v2, alpha ) {
2604
2605		this.x = v1.x + ( v2.x - v1.x ) * alpha;
2606		this.y = v1.y + ( v2.y - v1.y ) * alpha;
2607		this.z = v1.z + ( v2.z - v1.z ) * alpha;
2608
2609		return this;
2610
2611	}
2612
2613	cross( v ) {
2614
2615		return this.crossVectors( this, v );
2616
2617	}
2618
2619	crossVectors( a, b ) {
2620
2621		const ax = a.x, ay = a.y, az = a.z;
2622		const bx = b.x, by = b.y, bz = b.z;
2623
2624		this.x = ay * bz - az * by;
2625		this.y = az * bx - ax * bz;
2626		this.z = ax * by - ay * bx;
2627
2628		return this;
2629
2630	}
2631
2632	projectOnVector( v ) {
2633
2634		const denominator = v.lengthSq();
2635
2636		if ( denominator === 0 ) return this.set( 0, 0, 0 );
2637
2638		const scalar = v.dot( this ) / denominator;
2639
2640		return this.copy( v ).multiplyScalar( scalar );
2641
2642	}
2643
2644	projectOnPlane( planeNormal ) {
2645
2646		_vector$d.copy( this ).projectOnVector( planeNormal );
2647
2648		return this.sub( _vector$d );
2649
2650	}
2651
2652	reflect( normal ) {
2653
2654		// reflect incident vector off plane orthogonal to normal
2655		// normal is assumed to have unit length
2656
2657		return this.sub( _vector$d.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) );
2658
2659	}
2660
2661	angleTo( v ) {
2662
2663		const denominator = Math.sqrt( this.lengthSq() * v.lengthSq() );
2664
2665		if ( denominator === 0 ) return Math.PI / 2;
2666
2667		const theta = this.dot( v ) / denominator;
2668
2669		// clamp, to handle numerical problems
2670
2671		return Math.acos( clamp( theta, - 1, 1 ) );
2672
2673	}
2674
2675	distanceTo( v ) {
2676
2677		return Math.sqrt( this.distanceToSquared( v ) );
2678
2679	}
2680
2681	distanceToSquared( v ) {
2682
2683		const dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
2684
2685		return dx * dx + dy * dy + dz * dz;
2686
2687	}
2688
2689	manhattanDistanceTo( v ) {
2690
2691		return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y ) + Math.abs( this.z - v.z );
2692
2693	}
2694
2695	setFromSpherical( s ) {
2696
2697		return this.setFromSphericalCoords( s.radius, s.phi, s.theta );
2698
2699	}
2700
2701	setFromSphericalCoords( radius, phi, theta ) {
2702
2703		const sinPhiRadius = Math.sin( phi ) * radius;
2704
2705		this.x = sinPhiRadius * Math.sin( theta );
2706		this.y = Math.cos( phi ) * radius;
2707		this.z = sinPhiRadius * Math.cos( theta );
2708
2709		return this;
2710
2711	}
2712
2713	setFromCylindrical( c ) {
2714
2715		return this.setFromCylindricalCoords( c.radius, c.theta, c.y );
2716
2717	}
2718
2719	setFromCylindricalCoords( radius, theta, y ) {
2720