https://zepetto.com/js/v2/three.module.js

166ames where available.
167const NoColorSpace = '';
168const SRGBColorSpace = 'srgb';
169const LinearSRGBColorSpace = 'srgb-linear';
170const DisplayP3ColorSpace = 'display-p3';
171const LinearDisplayP3ColorSpace = 'display-p3-linear';
172
173const LinearTransfer = 'linear';
174const SRGBTransfer = 'srgb';
175
176const Rec709Primaries = 'rec709';
177const P3Primaries = 'p3';
178
179const ZeroStencilOp = 0;
180const KeepStencilOp = 7680;
181const ReplaceStencilOp = 7681;
182const IncrementStencilOp = 7682;
183const DecrementStencilOp = 7683;
184const IncrementWrapStencilOp = 34055;
185const DecrementWrapStencilOp = 34056;
186const InvertStencilOp = 5386;
187
188const NeverStencilFunc = 512;
189const LessStencilFunc = 513;
190const EqualStencilFunc = 514;
191const LessEqualStencilFunc = 515;
192const GreaterStencilFunc = 516;
193const NotEqualStencilFunc = 517;
194const GreaterEqualStencilFunc = 518;
195const AlwaysStencilFunc = 519;
196
197const NeverCompare = 512;
198const LessCompare = 513;
199const EqualCompare = 514;
200const LessEqualCompare = 515;
201const GreaterCompare = 516;
202const NotEqualCompare = 517;
203const GreaterEqualCompare = 518;
204const AlwaysCompare = 519;
205
206const StaticDrawUsage = 35044;
207const DynamicDrawUsage = 35048;
208const StreamDrawUsage = 35040;
209const StaticReadUsage = 35045;
210const DynamicReadUsage = 35049;
211const StreamReadUsage = 35041;
212const StaticCopyUsage = 35046;
213const DynamicCopyUsage = 35050;
214const StreamCopyUsage = 35042;
215
216const GLSL1 = '100';
217const GLSL3 = '300 es';
218
219const _SRGBAFormat = 1035; // fallback for WebGL 1
220
221const WebGLCoordinateSystem = 2000;
222const WebGPUCoordinateSystem = 2001;
223
224/**
225 * https://github.com/mrdoob/eventdispatcher.js/
226 */
227
228class EventDispatcher {
229
230	addEventListener( type, listener ) {
231
232		if ( this._listeners === undefined ) this._listeners = {};
233
234		const listeners = this._listeners;
235
236		if ( listeners[ type ] === undefined ) {
237
238			listeners[ type ] = [];
239
240		}
241
242		if ( listeners[ type ].indexOf( listener ) === - 1 ) {
243
244			listeners[ type ].push( listener );
245
246		}
247
248	}
249
250	hasEventListener( type, listener ) {
251
252		if ( this._listeners === undefined ) return false;
253
254		const listeners = this._listeners;
255
256		return listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1;
257
258	}
259
260	removeEventListener( type, listener ) {
261
262		if ( this._listeners === undefined ) return;
263
264		const listeners = this._listeners;
265		const listenerArray = listeners[ type ];
266
267		if ( listenerArray !== undefined ) {
268
269			const index = listenerArray.indexOf( listener );
270
271			if ( index !== - 1 ) {
272
273				listenerArray.splice( index, 1 );
274
275			}
276
277		}
278
279	}
280
281	dispatchEvent( event ) {
282
283		if ( this._listeners === undefined ) return;
284
285		const listeners = this._listeners;
286		const listenerArray = listeners[ event.type ];
287
288		if ( listenerArray !== undefined ) {
289
290			event.target = this;
291
292			// Make a copy, in case listeners are removed while iterating.
293			const array = listenerArray.slice( 0 );
294
295			for ( let i = 0, l = array.length; i < l; i ++ ) {
296
297				array[ i ].call( this, event );
298
299			}
300
301			event.target = null;
302
303		}
304
305	}
306
307}
308
309const _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' ];
310
311let _seed = 1234567;
312
313
314const DEG2RAD = Math.PI / 180;
315const RAD2DEG = 180 / Math.PI;
316
317// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
318function generateUUID() {
319
320	const d0 = Math.random() * 0xffffffff | 0;
321	const d1 = Math.random() * 0xffffffff | 0;
322	const d2 = Math.random() * 0xffffffff | 0;
323	const d3 = Math.random() * 0xffffffff | 0;
324	const uuid = _lut[ d0 & 0xff ] + _lut[ d0 >> 8 & 0xff ] + _lut[ d0 >> 16 & 0xff ] + _lut[ d0 >> 24 & 0xff ] + '-' +
325			_lut[ d1 & 0xff ] + _lut[ d1 >> 8 & 0xff ] + '-' + _lut[ d1 >> 16 & 0x0f | 0x40 ] + _lut[ d1 >> 24 & 0xff ] + '-' +
326			_lut[ d2 & 0x3f | 0x80 ] + _lut[ d2 >> 8 & 0xff ] + '-' + _lut[ d2 >> 16 & 0xff ] + _lut[ d2 >> 24 & 0xff ] +
327			_lut[ d3 & 0xff ] + _lut[ d3 >> 8 & 0xff ] + _lut[ d3 >> 16 & 0xff ] + _lut[ d3 >> 24 & 0xff ];
328
329	// .toLowerCase() here flattens concatenated strings to save heap memory space.
330	return uuid.toLowerCase();
331
332}
333
334function clamp( value, min, max ) {
335
336	return Math.max( min, Math.min( max, value ) );
337
338}
339
340// compute euclidean modulo of m % n
341// https://en.wikipedia.org/wiki/Modulo_operation
342function euclideanModulo( n, m ) {
343
344	return ( ( n % m ) + m ) % m;
345
346}
347
348// Linear mapping from range <a1, a2> to range <b1, b2>
349function mapLinear( x, a1, a2, b1, b2 ) {
350
351	return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );
352
353}
354
355// https://www.gamedev.net/tutorials/programming/general-and-gameplay-programming/inverse-lerp-a-super-useful-yet-often-overlooked-function-r5230/
356function inverseLerp( x, y, value ) {
357
358	if ( x !== y ) {
359
360		return ( value - x ) / ( y - x );
361
362	} else {
363
364		return 0;
365
366	}
367
368}
369
370// https://en.wikipedia.org/wiki/Linear_interpolation
371function lerp( x, y, t ) {
372
373	return ( 1 - t ) * x + t * y;
374
375}
376
377// http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
378function damp( x, y, lambda, dt ) {
379
380	return lerp( x, y, 1 - Math.exp( - lambda * dt ) );
381
382}
383
384// https://www.desmos.com/calculator/vcsjnyz7x4
385function pingpong( x, length = 1 ) {
386
387	return length - Math.abs( euclideanModulo( x, length * 2 ) - length );
388
389}
390
391// http://en.wikipedia.org/wiki/Smoothstep
392function smoothstep( x, min, max ) {
393
394	if ( x <= min ) return 0;
395	if ( x >= max ) return 1;
396
397	x = ( x - min ) / ( max - min );
398
399	return x * x * ( 3 - 2 * x );
400
401}
402
403function smootherstep( x, min, max ) {
404
405	if ( x <= min ) return 0;
406	if ( x >= max ) return 1;
407
408	x = ( x - min ) / ( max - min );
409
410	return x * x * x * ( x * ( x * 6 - 15 ) + 10 );
411
412}
413
414// Random integer from <low, high> interval
415function randInt( low, high ) {
416
417	return low + Math.floor( Math.random() * ( high - low + 1 ) );
418
419}
420
421// Random float from <low, high> interval
422function randFloat( low, high ) {
423
424	return low + Math.random() * ( high - low );
425
426}
427
428// Random float from <-range/2, range/2> interval
429function randFloatSpread( range ) {
430
431	return range * ( 0.5 - Math.random() );
432
433}
434

435// Deterministic pseudo-random float in the interval [ 0, 1 ]
436function seededRandom( s ) {
437
438	if ( s !== undefined ) _seed = s;
439
440	// Mulberry32 generator
441
442	let t = _seed += 0x6D2B79F5;
443
444	t = Math.imul( t ^ t >>> 15, t | 1 );
445
446	t ^= t + Math.imul( t ^ t >>> 7, t | 61 );
447
448	return ( ( t ^ t >>> 14 ) >>> 0 ) / 4294967296;
449
450}
451
452function degToRad( degrees ) {
453
454	return degrees * DEG2RAD;
455
456}
457
458function radToDeg( radians ) {
459
460	return radians * RAD2DEG;
461
462}
463
464function isPowerOfTwo( value ) {
465
466	return ( value & ( value - 1 ) ) === 0 && value !== 0;
467
468}
469
470function ceilPowerOfTwo( value ) {
471
472	return Math.pow( 2, Math.ceil( Math.log( value ) / Math.LN2 ) );
473
474}
475
476function floorPowerOfTwo( value ) {
477
478	return Math.pow( 2, Math.floor( Math.log( value ) / Math.LN2 ) );
479
480}
481
482function setQuaternionFromProperEuler( q, a, b, c, order ) {
483
484	// Intrinsic Proper Euler Angles - see https://en.wikipedia.org/wiki/Euler_angles
485
486	// rotations are applied to the axes in the order specified by 'order'
487	// rotation by angle 'a' is applied first, then by angle 'b', then by angle 'c'
488	// angles are in radians
489
490	const cos = Math.cos;
491	const sin = Math.sin;
492
493	const c2 = cos( b / 2 );
494	const s2 = sin( b / 2 );
495
496	const c13 = cos( ( a + c ) / 2 );
497	const s13 = sin( ( a + c ) / 2 );
498
499	const c1_3 = cos( ( a - c ) / 2 );
500	const s1_3 = sin( ( a - c ) / 2 );
501
502	const c3_1 = cos( ( c - a ) / 2 );
503	const s3_1 = sin( ( c - a ) / 2 );
504
505	switch ( order ) {
506
507		case 'XYX':
508			q.set( c2 * s13, s2 * c1_3, s2 * s1_3, c2 * c13 );
509			break;
510
511		case 'YZY':
512			q.set( s2 * s1_3, c2 * s13, s2 * c1_3, c2 * c13 );
513			break;
514
515		case 'ZXZ':
516			q.set( s2 * c1_3, s2 * s1_3, c2 * s13, c2 * c13 );
517			break;
518
519		case 'XZX':
520			q.set( c2 * s13, s2 * s3_1, s2 * c3_1, c2 * c13 );
521			break;
522
523		case 'YXY':
524			q.set( s2 * c3_1, c2 * s13, s2 * s3_1, c2 * c13 );
525			break;
526
527		case 'ZYZ':
528			q.set( s2 * s3_1, s2 * c3_1, c2 * s13, c2 * c13 );
529			break;
530
531		default:
532			console.warn( 'THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: ' + order );
533
534	}
535
536}
537
538function denormalize( value, array ) {
539
540	switch ( array.constructor ) {
541
542		case Float32Array:
543
544			return value;
545
546		case Uint32Array:
547
548			return value / 4294967295.0;
549
550		case Uint16Array:
551
552			return value / 65535.0;
553
554		case Uint8Array:
555
556			return value / 255.0;
557
558		case Int32Array:
559
560			return Math.max( value / 2147483647.0, - 1.0 );
561
562		case Int16Array:
563
564			return Math.max( value / 32767.0, - 1.0 );
565
566		case Int8Array:
567
568			return Math.max( value / 127.0, - 1.0 );
569
570		default:
571
572			throw new Error( 'Invalid component type.' );
573
574	}
575
576}
577
578function normalize( value, array ) {
579
580	switch ( array.constructor ) {
581
582		case Float32Array:
583
584			return value;
585
586		case Uint32Array:
587
588			return Math.round( value * 4294967295.0 );
589
590		case Uint16Array:
591
592			return Math.round( value * 65535.0 );
593
594		case Uint8Array:
595
596			return Math.round( value * 255.0 );
597
598		case Int32Array:
599
600			return Math.round( value * 2147483647.0 );
601
602		case Int16Array:
603
604			return Math.round( value * 32767.0 );
605
606		case Int8Array:
607
608			return Math.round( value * 127.0 );
609
610		default:
611
612			throw new Error( 'Invalid component type.' );
613
614	}
615
616}
617
618const MathUtils = {
619	DEG2RAD: DEG2RAD,
620	RAD2DEG: RAD2DEG,
621	generateUUID: generateUUID,
622	clamp: clamp,
623	euclideanModulo: euclideanModulo,
624	mapLinear: mapLinear,
625	inverseLerp: inverseLerp,
626	lerp: lerp,
627	damp: damp,
628	pingpong: pingpong,
629	smoothstep: smoothstep,
630	smootherstep: smootherstep,
631	randInt: randInt,
632	randFloat: randFloat,
633	randFloatSpread: randFloatSpread,
634	seededRandom: seededRandom,
635	degToRad: degToRad,
636	radToDeg: radToDeg,
637	isPowerOfTwo: isPowerOfTwo,
638	ceilPowerOfTwo: ceilPowerOfTwo,
639	floorPowerOfTwo: floorPowerOfTwo,
640	setQuaternionFromProperEuler: setQuaternionFromProperEuler,
641	normalize: normalize,
642	denormalize: denormalize
643};
644
645class Vector2 {
646
647	constructor( x = 0, y = 0 ) {
648
649		Vector2.prototype.isVector2 = true;
650
651		this.x = x;
652		this.y = y;
653
654	}
655
656	get width() {
657
658		return this.x;
659
660	}
661
662	set width( value ) {
663
664		this.x = value;
665
666	}
667
668	get height() {
669
670		return this.y;
671
672	}
673
674	set height( value ) {
675
676		this.y = value;
677
678	}
679
680	set( x, y ) {
681
682		this.x = x;
683		this.y = y;
684
685		return this;
686
687	}
688
689	setScalar( scalar ) {
690
691		this.x = scalar;
692		this.y = scalar;
693
694		return this;
695
696	}
697
698	setX( x ) {
699
700		this.x = x;
701
702		return this;
703
704	}
705
706	setY( y ) {
707
708		this.y = y;
709
710		return this;
711
712	}
713
714	setComponent( index, value ) {
715
716		switch ( index ) {
717
718			case 0: this.x = value; break;
719			case 1: this.y = value; break;
720			default: throw new Error( 'index is out of range: ' + index );
721
722		}
723
724		return this;
725
726	}
727
728	getComponent( index ) {
729
730		switch ( index ) {
731
732			case 0: return this.x;
733			case 1: return this.y;
734			default: throw new Error( 'index is out of range: ' + index );
735
736		}
737
738	}
739
740	clone() {
741
742		return new this.constructor( this.x, this.y );
743
744	}
745
746	copy( v ) {
747
748		this.x = v.x;
749		this.y = v.y;
750
751		return this;
752
753	}
754
755	add( v ) {
756
757		this.x += v.x;
758		this.y += v.y;
759
760		return this;
761
762	}
763
764	addScalar( s ) {
765
766		this.x += s;
767		this.y += s;
768
769		return this;
770
771	}
772
773	addVectors( a, b ) {
774
775		this.x = a.x + b.x;
776		this.y = a.y + b.y;
777
778		return this;
779
780	}
781
782	addScaledVector( v, s ) {
783
784		this.x += v.x * s;
785		this.y += v.y * s;
786
787		return this;
788
789	}
790
791	sub( v ) {
792
793		this.x -= v.x;
794		this.y -= v.y;
795
796		return this;
797
798	}
799
800	subScalar( s ) {
801
802		this.x -= s;
803		this.y -= s;
804
805		return this;
806
807	}
808
809	subVectors( a, b ) {
810
811		this.x = a.x - b.x;
812		this.y = a.y - b.y;
813
814		return this;
815
816	}
817
818	multiply( v ) {
819
820		this.x *= v.x;
821		this.y *= v.y;
822
823		return this;
824
825	}
826
827	multiplyScalar( scalar ) {
828
829		this.x *= scalar;
830		this.y *= scalar;
831
832		return this;
833
834	}
835

836	divide( v ) {
837
838		this.x /= v.x;
839		this.y /= v.y;
840
841		return this;
842
843	}
844
845	divideScalar( scalar ) {
846
847		return this.multiplyScalar( 1 / scalar );
848
849	}
850
851	applyMatrix3( m ) {
852
853		const x = this.x, y = this.y;
854		const e = m.elements;
855
856		this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ];
857		this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ];
858
859		return this;
860
861	}
862
863	min( v ) {
864
865		this.x = Math.min( this.x, v.x );
866		this.y = Math.min( this.y, v.y );
867
868		return this;
869
870	}
871
872	max( v ) {
873
874		this.x = Math.max( this.x, v.x );
875		this.y = Math.max( this.y, v.y );
876
877		return this;
878
879	}
880
881	clamp( min, max ) {
882
883		// assumes min < max, componentwise
884
885		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
886		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
887
888		return this;
889
890	}
891
892	clampScalar( minVal, maxVal ) {
893
894		this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
895		this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
896
897		return this;
898
899	}
900
901	clampLength( min, max ) {
902
903		const length = this.length();
904
905		return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
906
907	}
908
909	floor() {
910
911		this.x = Math.floor( this.x );
912		this.y = Math.floor( this.y );
913
914		return this;
915
916	}
917
918	ceil() {
919
920		this.x = Math.ceil( this.x );
921		this.y = Math.ceil( this.y );
922
923		return this;
924
925	}
926
927	round() {
928
929		this.x = Math.round( this.x );
930		this.y = Math.round( this.y );
931
932		return this;
933
934	}
935
936	roundToZero() {
937
938		this.x = Math.trunc( this.x );
939		this.y = Math.trunc( this.y );
940
941		return this;
942
943	}
944
945	negate() {
946
947		this.x = - this.x;
948		this.y = - this.y;
949
950		return this;
951
952	}
953
954	dot( v ) {
955
956		return this.x * v.x + this.y * v.y;
957
958	}
959
960	cross( v ) {
961
962		return this.x * v.y - this.y * v.x;
963
964	}
965
966	lengthSq() {
967
968		return this.x * this.x + this.y * this.y;
969
970	}
971
972	length() {
973
974		return Math.sqrt( this.x * this.x + this.y * this.y );
975
976	}
977
978	manhattanLength() {
979
980		return Math.abs( this.x ) + Math.abs( this.y );
981
982	}
983
984	normalize() {
985
986		return this.divideScalar( this.length() || 1 );
987
988	}
989
990	angle() {
991
992		// computes the angle in radians with respect to the positive x-axis
993
994		const angle = Math.atan2( - this.y, - this.x ) + Math.PI;
995
996		return angle;
997
998	}
999
1000	angleTo( v ) {
1001
1002		const denominator = Math.sqrt( this.lengthSq() * v.lengthSq() );
1003
1004		if ( denominator === 0 ) return Math.PI / 2;
1005
1006		const theta = this.dot( v ) / denominator;
1007
1008		// clamp, to handle numerical problems
1009
1010		return Math.acos( clamp( theta, - 1, 1 ) );
1011
1012	}
1013
1014	distanceTo( v ) {
1015
1016		return Math.sqrt( this.distanceToSquared( v ) );
1017
1018	}
1019
1020	distanceToSquared( v ) {
1021
1022		const dx = this.x - v.x, dy = this.y - v.y;
1023		return dx * dx + dy * dy;
1024
1025	}
1026
1027	manhattanDistanceTo( v ) {
1028
1029		return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y );
1030
1031	}
1032
1033	setLength( length ) {
1034
1035		return this.normalize().multiplyScalar( length );
1036
1037	}
1038
1039	lerp( v, alpha ) {
1040
1041		this.x += ( v.x - this.x ) * alpha;
1042		this.y += ( v.y - this.y ) * alpha;
1043
1044		return this;
1045
1046	}
1047
1048	lerpVectors( v1, v2, alpha ) {
1049
1050		this.x = v1.x + ( v2.x - v1.x ) * alpha;
1051		this.y = v1.y + ( v2.y - v1.y ) * alpha;
1052
1053		return this;
1054
1055	}
1056
1057	equals( v ) {
1058
1059		return ( ( v.x === this.x ) && ( v.y === this.y ) );
1060
1061	}
1062
1063	fromArray( array, offset = 0 ) {
1064
1065		this.x = array[ offset ];
1066		this.y = array[ offset + 1 ];
1067
1068		return this;
1069
1070	}
1071
1072	toArray( array = [], offset = 0 ) {
1073
1074		array[ offset ] = this.x;
1075		array[ offset + 1 ] = this.y;
1076
1077		return array;
1078
1079	}
1080
1081	fromBufferAttribute( attribute, index ) {
1082
1083		this.x = attribute.getX( index );
1084		this.y = attribute.getY( index );
1085
1086		return this;
1087
1088	}
1089
1090	rotateAround( center, angle ) {
1091
1092		const c = Math.cos( angle ), s = Math.sin( angle );
1093
1094		const x = this.x - center.x;
1095		const y = this.y - center.y;
1096
1097		this.x = x * c - y * s + center.x;
1098		this.y = x * s + y * c + center.y;
1099
1100		return this;
1101
1102	}
1103
1104	random() {
1105
1106		this.x = Math.random();
1107		this.y = Math.random();
1108
1109		return this;
1110
1111	}
1112
1113	*[ Symbol.iterator ]() {
1114
1115		yield this.x;
1116		yield this.y;
1117
1118	}
1119
1120}
1121
1122class Matrix3 {
1123
1124	constructor( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {
1125
1126		Matrix3.prototype.isMatrix3 = true;
1127
1128		this.elements = [
1129
1130			1, 0, 0,
1131			0, 1, 0,
1132			0, 0, 1
1133
1134		];
1135
1136		if ( n11 !== undefined ) {
1137
1138			this.set( n11, n12, n13, n21, n22, n23, n31, n32, n33 );
1139
1140		}
1141
1142	}
1143
1144	set( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {
1145
1146		const te = this.elements;
1147
1148		te[ 0 ] = n11; te[ 1 ] = n21; te[ 2 ] = n31;
1149		te[ 3 ] = n12; te[ 4 ] = n22; te[ 5 ] = n32;
1150		te[ 6 ] = n13; te[ 7 ] = n23; te[ 8 ] = n33;
1151
1152		return this;
1153
1154	}
1155
1156	identity() {
1157
1158		this.set(
1159
1160			1, 0, 0,
1161			0, 1, 0,
1162			0, 0, 1
1163
1164		);
1165
1166		return this;
1167
1168	}
1169
1170	copy( m ) {
1171
1172		const te = this.elements;
1173		const me = m.elements;
1174
1175		te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ];
1176		te[ 3 ] = me[ 3 ]; te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ];
1177		te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; te[ 8 ] = me[ 8 ];
1178
1179		return this;
1180
1181	}
1182
1183	extractBasis( xAxis, yAxis, zAxis ) {
1184
1185		xAxis.setFromMatrix3Column( this, 0 );
1186		yAxis.setFromMatrix3Column( this, 1 );
1187		zAxis.setFromMatrix3Column( this, 2 );
1188
1189		return this;
1190
1191	}
1192
1193	setFromMatrix4( m ) {
1194
1195		const me = m.elements;
1196
1197		this.set(
1198
1199			me[ 0 ], me[ 4 ], me[ 8 ],
1200			me[ 1 ], me[ 5 ], me[ 9 ],
1201			me[ 2 ], me[ 6 ], me[ 10 ]
1202
1203		);
1204
1205		return this;
1206
1207	}
1208
1209	multiply( m ) {
1210
1211		return this.multiplyMatrices( this, m );
1212
1213	}
1214
1215	premultiply( m ) {
1216
1217		return this.multiplyMatrices( m, this );
1218
1219	}
1220
1221	multiplyMatrices( a, b ) {
1222
1223		const ae = a.elements;
1224		const be = b.elements;
1225		const te = this.elements;
1226
1227		const a11 = ae[ 0 ], a12 = ae[ 3 ], a13 = ae[ 6 ];
1228		const a21 = ae[ 1 ], a22 = ae[ 4 ], a23 = ae[ 7 ];
1229		const a31 = ae[ 2 ], a32 = ae[ 5 ], a33 = ae[ 8 ];
1230
1231		const b11 = be[ 0 ], b12 = be[ 3 ], b13 = be[ 6 ];
1232		const b21 = be[ 1 ], b22 = be[ 4 ], b23 = be[ 7 ];
1233		const b31 = be[ 2 ], b32 = be[ 5 ], b33 = be[ 8 ];
1234
1235		te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31;
1236		te[ 3 ] = a11 * b12 + a12 * b22 + a13 * b32;
1237		te[ 6 ] = a11 * b13 + a12 * b23 + a13 * b33;
1238
1239		te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31;
1240		te[ 4 ] = a21 * b12 + a22 * b22 + a23 * b32;
1241		te[ 7 ] = a21 * b13 + a22 * b23 + a23 * b33;
1242
1243		te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31;
1244		te[ 5 ] = a31 * b12 + a32 * b22 + a33 * b32;
1245		te[ 8 ] = a31 * b13 + a32 * b23 + a33 * b33;
1246
1247		return this;
1248
1249	}
1250
1251	multiplyScalar( s ) {
1252
1253		const te = this.elements;
1254
1255		te[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s;
1256		te[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s;
1257		te[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s;
1258
1259		return this;
1260
1261	}
1262
1263	determinant() {
1264
1265		const te = this.elements;
1266
1267		const a = te[ 0 ], b = te[ 1 ], c = te[ 2 ],
1268			d = te[ 3 ], e = te[ 4 ], f = te[ 5 ],

1269			g = te[ 6 ], h = te[ 7 ], i = te[ 8 ];
1270
1271		return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;
1272
1273	}
1274
1275	invert() {
1276
1277		const te = this.elements,
1278
1279			n11 = te[ 0 ], n21 = te[ 1 ], n31 = te[ 2 ],
1280			n12 = te[ 3 ], n22 = te[ 4 ], n32 = te[ 5 ],
1281			n13 = te[ 6 ], n23 = te[ 7 ], n33 = te[ 8 ],
1282
1283			t11 = n33 * n22 - n32 * n23,
1284			t12 = n32 * n13 - n33 * n12,
1285			t13 = n23 * n12 - n22 * n13,
1286
1287			det = n11 * t11 + n21 * t12 + n31 * t13;
1288
1289		if ( det === 0 ) return this.set( 0, 0, 0, 0, 0, 0, 0, 0, 0 );
1290
1291		const detInv = 1 / det;
1292
1293		te[ 0 ] = t11 * detInv;
1294		te[ 1 ] = ( n31 * n23 - n33 * n21 ) * detInv;
1295		te[ 2 ] = ( n32 * n21 - n31 * n22 ) * detInv;
1296
1297		te[ 3 ] = t12 * detInv;
1298		te[ 4 ] = ( n33 * n11 - n31 * n13 ) * detInv;
1299		te[ 5 ] = ( n31 * n12 - n32 * n11 ) * detInv;
1300
1301		te[ 6 ] = t13 * detInv;
1302		te[ 7 ] = ( n21 * n13 - n23 * n11 ) * detInv;
1303		te[ 8 ] = ( n22 * n11 - n21 * n12 ) * detInv;
1304
1305		return this;
1306
1307	}
1308
1309	transpose() {
1310
1311		let tmp;
1312		const m = this.elements;
1313
1314		tmp = m[ 1 ]; m[ 1 ] = m[ 3 ]; m[ 3 ] = tmp;
1315		tmp = m[ 2 ]; m[ 2 ] = m[ 6 ]; m[ 6 ] = tmp;
1316		tmp = m[ 5 ]; m[ 5 ] = m[ 7 ]; m[ 7 ] = tmp;
1317
1318		return this;
1319
1320	}
1321
1322	getNormalMatrix( matrix4 ) {
1323
1324		return this.setFromMatrix4( matrix4 ).invert().transpose();
1325
1326	}
1327
1328	transposeIntoArray( r ) {
1329
1330		const m = this.elements;
1331
1332		r[ 0 ] = m[ 0 ];
1333		r[ 1 ] = m[ 3 ];
1334		r[ 2 ] = m[ 6 ];
1335		r[ 3 ] = m[ 1 ];
1336		r[ 4 ] = m[ 4 ];
1337		r[ 5 ] = m[ 7 ];
1338		r[ 6 ] = m[ 2 ];
1339		r[ 7 ] = m[ 5 ];
1340		r[ 8 ] = m[ 8 ];
1341
1342		return this;
1343
1344	}
1345
1346	setUvTransform( tx, ty, sx, sy, rotation, cx, cy ) {
1347
1348		const c = Math.cos( rotation );
1349		const s = Math.sin( rotation );
1350
1351		this.set(
1352			sx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx,
1353			- sy * s, sy * c, - sy * ( - s * cx + c * cy ) + cy + ty,
1354			0, 0, 1
1355		);
1356
1357		return this;
1358
1359	}
1360
1361	//
1362
1363	scale( sx, sy ) {
1364
1365		this.premultiply( _m3.makeScale( sx, sy ) );
1366
1367		return this;
1368
1369	}
1370
1371	rotate( theta ) {
1372
1373		this.premultiply( _m3.makeRotation( - theta ) );
1374
1375		return this;
1376
1377	}
1378
1379	translate( tx, ty ) {
1380
1381		this.premultiply( _m3.makeTranslation( tx, ty ) );
1382
1383		return this;
1384
1385	}
1386
1387	// for 2D Transforms
1388
1389	makeTranslation( x, y ) {
1390
1391		if ( x.isVector2 ) {
1392
1393			this.set(
1394
1395				1, 0, x.x,
1396				0, 1, x.y,
1397				0, 0, 1
1398
1399			);
1400
1401		} else {
1402
1403			this.set(
1404
1405				1, 0, x,
1406				0, 1, y,
1407				0, 0, 1
1408
1409			);
1410
1411		}
1412
1413		return this;
1414
1415	}
1416
1417	makeRotation( theta ) {
1418
1419		// counterclockwise
1420
1421		const c = Math.cos( theta );
1422		const s = Math.sin( theta );
1423
1424		this.set(
1425
1426			c, - s, 0,
1427			s, c, 0,
1428			0, 0, 1
1429
1430		);
1431
1432		return this;
1433
1434	}
1435
1436	makeScale( x, y ) {
1437
1438		this.set(
1439
1440			x, 0, 0,
1441			0, y, 0,
1442			0, 0, 1
1443
1444		);
1445
1446		return this;
1447
1448	}
1449
1450	//
1451
1452	equals( matrix ) {
1453
1454		const te = this.elements;
1455		const me = matrix.elements;
1456
1457		for ( let i = 0; i < 9; i ++ ) {
1458
1459			if ( te[ i ] !== me[ i ] ) return false;
1460
1461		}
1462
1463		return true;
1464
1465	}
1466
1467	fromArray( array, offset = 0 ) {
1468
1469		for ( let i = 0; i < 9; i ++ ) {
1470
1471			this.elements[ i ] = array[ i + offset ];
1472
1473		}
1474
1475		return this;
1476
1477	}
1478
1479	toArray( array = [], offset = 0 ) {
1480
1481		const te = this.elements;
1482
1483		array[ offset ] = te[ 0 ];
1484		array[ offset + 1 ] = te[ 1 ];
1485		array[ offset + 2 ] = te[ 2 ];
1486
1487		array[ offset + 3 ] = te[ 3 ];
1488		array[ offset + 4 ] = te[ 4 ];
1489		array[ offset + 5 ] = te[ 5 ];
1490
1491		array[ offset + 6 ] = te[ 6 ];
1492		array[ offset + 7 ] = te[ 7 ];
1493		array[ offset + 8 ] = te[ 8 ];
1494
1495		return array;
1496
1497	}
1498
1499	clone() {
1500
1501		return new this.constructor().fromArray( this.elements );
1502
1503	}
1504
1505}
1506
1507const _m3 = /*@__PURE__*/ new Matrix3();
1508
1509function arrayNeedsUint32( array ) {
1510
1511	// assumes larger values usually on last
1512
1513	for ( let i = array.length - 1; i >= 0; -- i ) {
1514
1515		if ( array[ i ] >= 65535 ) return true; // account for PRIMITIVE_RESTART_FIXED_INDEX, #24565
1516
1517	}
1518
1519	return false;
1520
1521}
1522
1523const TYPED_ARRAYS = {
1524	Int8Array: Int8Array,
1525	Uint8Array: Uint8Array,
1526	Uint8ClampedArray: Uint8ClampedArray,
1527	Int16Array: Int16Array,
1528	Uint16Array: Uint16Array,
1529	Int32Array: Int32Array,
1530	Uint32Array: Uint32Array,
1531	Float32Array: Float32Array,
1532	Float64Array: Float64Array
1533};
1534
1535function getTypedArray( type, buffer ) {
1536
1537	return new TYPED_ARRAYS[ type ]( buffer );
1538
1539}
1540
1541function createElementNS( name ) {
1542
1543	return document.createElementNS( 'http://www.w3.org/1999/xhtml', name );
1544
1545}
1546
1547function createCanvasElement() {
1548
1549	const canvas = createElementNS( 'canvas' );
1550	canvas.style.display = 'block';
1551	return canvas;
1552
1553}
1554
1555const _cache = {};
1556
1557function warnOnce( message ) {
1558
1559	if ( message in _cache ) return;
1560

1561	_cache[ message ] = true;
1562
1563	console.warn( message );
1564
1565}
1566
1567/**
1568 * Matrices converting P3 <-> Rec. 709 primaries, without gamut mapping
1569 * or clipping. Based on W3C specifications for sRGB and Display P3,
1570 * and ICC specifications for the D50 connection space. Values in/out
1571 * are _linear_ sRGB and _linear_ Display P3.
1572 *
1573 * Note that both sRGB and Display P3 use the sRGB transfer functions.
1574 *
1575 * Reference:
1576 * - http://www.russellcottrell.com/photo/matrixCalculator.htm
1577 */
1578
1579const LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 = /*@__PURE__*/ new Matrix3().set(
1580	0.8224621, 0.177538, 0.0,
1581	0.0331941, 0.9668058, 0.0,
1582	0.0170827, 0.0723974, 0.9105199,
1583);
1584
1585const LINEAR_DISPLAY_P3_TO_LINEAR_SRGB = /*@__PURE__*/ new Matrix3().set(
1586	1.2249401, - 0.2249404, 0.0,
1587	- 0.0420569, 1.0420571, 0.0,
1588	- 0.0196376, - 0.0786361, 1.0982735
1589);
1590
1591/**
1592 * Defines supported color spaces by transfer function and primaries,
1593 * and provides conversions to/from the Linear-sRGB reference space.
1594 */
1595const COLOR_SPACES = {
1596	[ LinearSRGBColorSpace ]: {
1597		transfer: LinearTransfer,
1598		primaries: Rec709Primaries,
1599		toReference: ( color ) => color,
1600		fromReference: ( color ) => color,
1601	},
1602	[ SRGBColorSpace ]: {
1603		transfer: SRGBTransfer,
1604		primaries: Rec709Primaries,
1605		toReference: ( color ) => color.convertSRGBToLinear(),
1606		fromReference: ( color ) => color.convertLinearToSRGB(),
1607	},
1608	[ LinearDisplayP3ColorSpace ]: {
1609		transfer: LinearTransfer,
1610		primaries: P3Primaries,
1611		toReference: ( color ) => color.applyMatrix3( LINEAR_DISPLAY_P3_TO_LINEAR_SRGB ),
1612		fromReference: ( color ) => color.applyMatrix3( LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 ),
1613	},
1614	[ DisplayP3ColorSpace ]: {
1615		transfer: SRGBTransfer,
1616		primaries: P3Primaries,
1617		toReference: ( color ) => color.convertSRGBToLinear().applyMatrix3( LINEAR_DISPLAY_P3_TO_LINEAR_SRGB ),
1618		fromReference: ( color ) => color.applyMatrix3( LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 ).convertLinearToSRGB(),
1619	},
1620};
1621
1622const SUPPORTED_WORKING_COLOR_SPACES = new Set( [ LinearSRGBColorSpace, LinearDisplayP3ColorSpace ] );
1623
1624const ColorManagement = {
1625
1626	enabled: true,
1627
1628	_workingColorSpace: LinearSRGBColorSpace,
1629
1630	get workingColorSpace() {
1631
1632		return this._workingColorSpace;
1633
1634	},
1635
1636	set workingColorSpace( colorSpace ) {
1637
1638		if ( ! SUPPORTED_WORKING_COLOR_SPACES.has( colorSpace ) ) {
1639
1640			throw new Error( `Unsupported working color space, "${ colorSpace }".` );
1641
1642		}
1643
1644		this._workingColorSpace = colorSpace;
1645
1646	},
1647
1648	convert: function ( color, sourceColorSpace, targetColorSpace ) {
1649
1650		if ( this.enabled === false || sourceColorSpace === targetColorSpace || ! sourceColorSpace || ! targetColorSpace ) {
1651
1652			return color;
1653
1654		}
1655
1656		const sourceToReference = COLOR_SPACES[ sourceColorSpace ].toReference;
1657		const targetFromReference = COLOR_SPACES[ targetColorSpace ].fromReference;
1658
1659		return targetFromReference( sourceToReference( color ) );
1660
1661	},
1662
1663	fromWorkingColorSpace: function ( color, targetColorSpace ) {
1664
1665		return this.convert( color, this._workingColorSpace, targetColorSpace );
1666
1667	},
1668
1669	toWorkingColorSpace: function ( color, sourceColorSpace ) {
1670
1671		return this.convert( color, sourceColorSpace, this._workingColorSpace );
1672
1673	},
1674
1675	getPrimaries: function ( colorSpace ) {
1676
1677		return COLOR_SPACES[ colorSpace ].primaries;
1678
1679	},
1680
1681	getTransfer: function ( colorSpace ) {
1682
1683		if ( colorSpace === NoColorSpace ) return LinearTransfer;
1684
1685		return COLOR_SPACES[ colorSpace ].transfer;
1686
1687	},
1688
1689};
1690
1691
1692function SRGBToLinear( c ) {
1693
1694	return ( c < 0.04045 ) ? c * 0.0773993808 : Math.pow( c * 0.9478672986 + 0.0521327014, 2.4 );
1695
1696}
1697
1698function LinearToSRGB( c ) {
1699
1700	return ( c < 0.0031308 ) ? c * 12.92 : 1.055 * ( Math.pow( c, 0.41666 ) ) - 0.055;
1701
1702}
1703
1704let _canvas;
1705
1706class ImageUtils {
1707
1708	static getDataURL( image ) {
1709
1710		if ( /^data:/i.test( image.src ) ) {
1711
1712			return image.src;
1713
1714		}
1715
1716		if ( typeof HTMLCanvasElement === 'undefined' ) {
1717
1718			return image.src;
1719
1720		}
1721
1722		let canvas;
1723
1724		if ( image instanceof HTMLCanvasElement ) {
1725
1726			canvas = image;
1727
1728		} else {
1729
1730			if ( _canvas === undefined ) _canvas = createElementNS( 'canvas' );
1731
1732			_canvas.width = image.width;
1733			_canvas.height = image.height;
1734
1735			const context = _canvas.getContext( '2d' );
1736
1737			if ( image instanceof ImageData ) {
1738
1739				context.putImageData( image, 0, 0 );
1740
1741			} else {
1742
1743				context.drawImage( image, 0, 0, image.width, image.height );
1744
1745			}
1746
1747			canvas = _canvas;
1748
1749		}
1750
1751		if ( canvas.width > 2048 || canvas.height > 2048 ) {
1752
1753			console.warn( 'THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons', image );
1754
1755			return canvas.toDataURL( 'image/jpeg', 0.6 );
1756
1757		} else {
1758
1759			return canvas.toDataURL( 'image/png' );
1760
1761		}
1762
1763	}
1764
1765	static sRGBToLinear( image ) {
1766
1767		if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
1768			( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
1769			( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {
1770
1771			const canvas = createElementNS( 'canvas' );
1772
1773			canvas.width = image.width;
1774			canvas.height = image.height;
1775
1776			const context = canvas.getContext( '2d' );
1777			context.drawImage( image, 0, 0, image.width, image.height );
1778
1779			const imageData = context.getImageData( 0, 0, image.width, image.height );
1780			const data = imageData.data;
1781
1782			for ( let i = 0; i < data.length; i ++ ) {
1783
1784				data[ i ] = SRGBToLinear( data[ i ] / 255 ) * 255;
1785
1786			}
1787
1788			context.putImageData( imageData, 0, 0 );
1789
1790			return canvas;
1791
1792		} else if ( image.data ) {
1793
1794			const data = image.data.slice( 0 );
1795
1796			for ( let i = 0; i < data.length; i ++ ) {
1797
1798				if ( data instanceof Uint8Array || data instanceof Uint8ClampedArray ) {
1799
1800					data[ i ] = Math.floor( SRGBToLinear( data[ i ] / 255 ) * 255 );
1801
1802				} else {
1803
1804					// assuming float
1805
1806					data[ i ] = SRGBToLinear( data[ i ] );
1807
1808				}
1809
1810			}
1811
1812			return {
1813				data: data,
1814				width: image.width,
1815				height: image.height
1816			};
1817
1818		} else {
1819
1820			console.warn( 'THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied.' );
1821			return image;
1822
1823		}
1824
1825	}
1826
1827}
1828
1829let _sourceId = 0;
1830
1831class Source {
1832
1833	constructor( data = null ) {
1834
1835		this.isSource = true;
1836
1837		Object.defineProperty( this, 'id', { value: _sourceId ++ } );
1838
1839		this.uuid = generateUUID();
1840
1841		this.data = data;
1842
1843		this.version = 0;
1844
1845	}
1846
1847	set needsUpdate( value ) {
1848
1849		if ( value === true ) this.version ++;
1850
1851	}
1852
1853	toJSON( meta ) {
1854
1855		const isRootObject = ( meta === undefined || typeof meta === 'string' );
1856
1857		if ( ! isRootObject && meta.images[ this.uuid ] !== undefined ) {
1858
1859			return meta.images[ this.uuid ];
1860
1861		}
1862
1863		const output = {
1864			uuid: this.uuid,
1865			url: ''
1866		};
1867
1868		const data = this.data;
1869
1870		if ( data !== null ) {
1871
1872			let url;
1873
1874			if ( Array.isArray( data ) ) {
1875
1876				// cube texture
1877
1878				url = [];
1879
1880				for ( let i = 0, l = data.length; i < l; i ++ ) {
1881
1882					if ( data[ i ].isDataTexture ) {
1883
1884						url.push( serializeImage( data[ i ].image ) );
1885
1886					} else {
1887
1888						url.push( serializeImage( data[ i ] ) );
1889
1890					}
1891
1892				}
1893
1894			} else {
1895
1896				// texture
1897
1898				url = serializeImage( data );
1899
1900			}
1901
1902			output.url = url;
1903
1904		}
1905
1906		if ( ! isRootObject ) {
1907
1908			meta.images[ this.uuid ] = output;
1909
1910		}
1911
1912		return output;
1913
1914	}
1915
1916}
1917
1918function serializeImage( image ) {
1919
1920	if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
1921		( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
1922		( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {
1923
1924		// default images
1925
1926		return ImageUtils.getDataURL( image );
1927
1928	} else {
1929
1930		if ( image.data ) {
1931
1932			// images of DataTexture
1933
1934			return {
1935				data: Array.from( image.data ),
1936				width: image.width,
1937				height: image.height,
1938				type: image.data.constructor.name
1939			};
1940
1941		} else {
1942
1943			console.warn( 'THREE.Texture: Unable to serialize Texture.' );
1944			return {};
1945
1946		}
1947
1948	}
1949
1950}
1951
1952let _textureId = 0;
1953

1954class Texture extends EventDispatcher {
1955
1956	constructor( image = Texture.DEFAULT_IMAGE, mapping = Texture.DEFAULT_MAPPING, wrapS = ClampToEdgeWrapping, wrapT = ClampToEdgeWrapping, magFilter = LinearFilter, minFilter = LinearMipmapLinearFilter, format = RGBAFormat, type = UnsignedByteType, anisotropy = Texture.DEFAULT_ANISOTROPY, colorSpace = NoColorSpace ) {
1957
1958		super();
1959
1960		this.isTexture = true;
1961
1962		Object.defineProperty( this, 'id', { value: _textureId ++ } );
1963
1964		this.uuid = generateUUID();
1965
1966		this.name = '';
1967
1968		this.source = new Source( image );
1969		this.mipmaps = [];
1970
1971		this.mapping = mapping;
1972		this.channel = 0;
1973
1974		this.wrapS = wrapS;
1975		this.wrapT = wrapT;
1976
1977		this.magFilter = magFilter;
1978		this.minFilter = minFilter;
1979
1980		this.anisotropy = anisotropy;
1981
1982		this.format = format;
1983		this.internalFormat = null;
1984		this.type = type;
1985
1986		this.offset = new Vector2( 0, 0 );
1987		this.repeat = new Vector2( 1, 1 );
1988		this.center = new Vector2( 0, 0 );
1989		this.rotation = 0;
1990
1991		this.matrixAutoUpdate = true;
1992		this.matrix = new Matrix3();
1993
1994		this.generateMipmaps = true;
1995		this.premultiplyAlpha = false;
1996		this.flipY = true;
1997		this.unpackAlignment = 4;	// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
1998
1999		if ( typeof colorSpace === 'string' ) {
2000
2001			this.colorSpace = colorSpace;
2002
2003		} else { // @deprecated, r152
2004
2005			warnOnce( 'THREE.Texture: Property .encoding has been replaced by .colorSpace.' );
2006			this.colorSpace = colorSpace === sRGBEncoding ? SRGBColorSpace : NoColorSpace;
2007
2008		}
2009
2010
2011		this.userData = {};
2012
2013		this.version = 0;
2014		this.onUpdate = null;
2015
2016		this.isRenderTargetTexture = false; // indicates whether a texture belongs to a render target or not
2017		this.needsPMREMUpdate = false; // indicates whether this texture should be processed by PMREMGenerator or not (only relevant for render target textures)
2018
2019	}
2020
2021	get image() {
2022
2023		return this.source.data;
2024
2025	}
2026
2027	set image( value = null ) {
2028
2029		this.source.data = value;
2030
2031	}
2032
2033	updateMatrix() {
2034
2035		this.matrix.setUvTransform( this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y );
2036
2037	}
2038
2039	clone() {
2040
2041		return new this.constructor().copy( this );
2042
2043	}
2044
2045	copy( source ) {
2046
2047		this.name = source.name;
2048
2049		this.source = source.source;
2050		this.mipmaps = source.mipmaps.slice( 0 );
2051
2052		this.mapping = source.mapping;
2053		this.channel = source.channel;
2054
2055		this.wrapS = source.wrapS;
2056		this.wrapT = source.wrapT;
2057
2058		this.magFilter = source.magFilter;
2059		this.minFilter = source.minFilter;
2060
2061		this.anisotropy = source.anisotropy;
2062
2063		this.format = source.format;
2064		this.internalFormat = source.internalFormat;
2065		this.type = source.type;
2066
2067		this.offset.copy( source.offset );
2068		this.repeat.copy( source.repeat );
2069		this.center.copy( source.center );
2070		this.rotation = source.rotation;
2071
2072		this.matrixAutoUpdate = source.matrixAutoUpdate;
2073		this.matrix.copy( source.matrix );
2074
2075		this.generateMipmaps = source.generateMipmaps;
2076		this.premultiplyAlpha = source.premultiplyAlpha;
2077		this.flipY = source.flipY;
2078		this.unpackAlignment = source.unpackAlignment;
2079		this.colorSpace = source.colorSpace;
2080
2081		this.userData = JSON.parse( JSON.stringify( source.userData ) );
2082
2083		this.needsUpdate = true;
2084
2085		return this;
2086
2087	}
2088
2089	toJSON( meta ) {
2090
2091		const isRootObject = ( meta === undefined || typeof meta === 'string' );
2092
2093		if ( ! isRootObject && meta.textures[ this.uuid ] !== undefined ) {
2094
2095			return meta.textures[ this.uuid ];
2096
2097		}
2098
2099		const output = {
2100
2101			metadata: {
2102				version: 4.6,
2103				type: 'Texture',
2104				generator: 'Texture.toJSON'
2105			},
2106
2107			uuid: this.uuid,
2108			name: this.name,
2109
2110			image: this.source.toJSON( meta ).uuid,
2111
2112			mapping: this.mapping,
2113			channel: this.channel,
2114
2115			repeat: [ this.repeat.x, this.repeat.y ],
2116			offset: [ this.offset.x, this.offset.y ],
2117			center: [ this.center.x, this.center.y ],
2118			rotation: this.rotation,
2119
2120			wrap: [ this.wrapS, this.wrapT ],
2121
2122			format: this.format,
2123			internalFormat: this.internalFormat,
2124			type: this.type,
2125			colorSpace: this.colorSpace,
2126
2127			minFilter: this.minFilter,
2128			magFilter: this.magFilter,
2129			anisotropy: this.anisotropy,
2130
2131			flipY: this.flipY,
2132
2133			generateMipmaps: this.generateMipmaps,
2134			premultiplyAlpha: this.premultiplyAlpha,
2135			unpackAlignment: this.unpackAlignment
2136
2137		};
2138
2139		if ( Object.keys( this.userData ).length > 0 ) output.userData = this.userData;
2140
2141		if ( ! isRootObject ) {
2142
2143			meta.textures[ this.uuid ] = output;
2144
2145		}
2146
2147		return output;
2148
2149	}
2150
2151	dispose() {
2152
2153		this.dispatchEvent( { type: 'dispose' } );
2154
2155	}
2156
2157	transformUv( uv ) {
2158
2159		if ( this.mapping !== UVMapping ) return uv;
2160
2161		uv.applyMatrix3( this.matrix );
2162
2163		if ( uv.x < 0 || uv.x > 1 ) {
2164
2165			switch ( this.wrapS ) {
2166
2167				case RepeatWrapping:
2168
2169					uv.x = uv.x - Math.floor( uv.x );
2170					break;
2171
2172				case ClampToEdgeWrapping:
2173
2174					uv.x = uv.x < 0 ? 0 : 1;
2175					break;
2176
2177				case MirroredRepeatWrapping:
2178
2179					if ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) {
2180
2181						uv.x = Math.ceil( uv.x ) - uv.x;
2182
2183					} else {
2184
2185						uv.x = uv.x - Math.floor( uv.x );
2186
2187					}
2188
2189					break;
2190
2191			}
2192
2193		}
2194
2195		if ( uv.y < 0 || uv.y > 1 ) {
2196
2197			switch ( this.wrapT ) {
2198
2199				case RepeatWrapping:
2200
2201					uv.y = uv.y - Math.floor( uv.y );
2202					break;
2203
2204				case ClampToEdgeWrapping:
2205
2206					uv.y = uv.y < 0 ? 0 : 1;
2207					break;
2208
2209				case MirroredRepeatWrapping:
2210
2211					if ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) {
2212
2213						uv.y = Math.ceil( uv.y ) - uv.y;
2214
2215					} else {
2216
2217						uv.y = uv.y - Math.floor( uv.y );
2218
2219					}
2220
2221					break;
2222
2223			}
2224
2225		}
2226
2227		if ( this.flipY ) {
2228
2229			uv.y = 1 - uv.y;
2230
2231		}
2232
2233		return uv;
2234
2235	}
2236
2237	set needsUpdate( value ) {
2238
2239		if ( value === true ) {
2240
2241			this.version ++;
2242			this.source.needsUpdate = true;
2243
2244		}
2245
2246	}
2247
2248	get encoding() { // @deprecated, r152
2249
2250		warnOnce( 'THREE.Texture: Property .encoding has been replaced by .colorSpace.' );
2251		return this.colorSpace === SRGBColorSpace ? sRGBEncoding : LinearEncoding;
2252
2253	}
2254
2255	set encoding( encoding ) { // @deprecated, r152
2256
2257		warnOnce( 'THREE.Texture: Property .encoding has been replaced by .colorSpace.' );
2258		this.colorSpace = encoding === sRGBEncoding ? SRGBColorSpace : NoColorSpace;
2259
2260	}
2261
2262}
2263
2264Texture.DEFAULT_IMAGE = null;
2265Texture.DEFAULT_MAPPING = UVMapping;
2266Texture.DEFAULT_ANISOTROPY = 1;
2267
2268class Vector4 {
2269
2270	constructor( x = 0, y = 0, z = 0, w = 1 ) {
2271
2272		Vector4.prototype.isVector4 = true;
2273
2274		this.x = x;
2275		this.y = y;
2276		this.z = z;
2277		this.w = w;
2278
2279	}
2280
2281	get width() {
2282
2283		return this.z;
2284
2285	}
2286
2287	set width( value ) {
2288
2289		this.z = value;
2290
2291	}
2292
2293	get height() {
2294
2295		return this.w;
2296
2297	}
2298
2299	set height( value ) {
2300
2301		this.w = value;
2302
2303	}
2304
2305	set( x, y, z, w ) {
2306
2307		this.x = x;
2308		this.y = y;
2309		this.z = z;
2310		this.w = w;
2311
2312		return this;
2313
2314	}
2315
2316	setScalar( scalar ) {
2317
2318		this.x = scalar;
2319		this.y = scalar;
2320		this.z = scalar;
2321		this.w = scalar;
2322
2323		return this;
2324
2325	}
2326
2327	setX( x ) {
2328
2329		this.x = x;
2330
2331		return this;
2332
2333	}
2334
2335	setY( y ) {
2336
2337		this.y = y;
2338
2339		return this;
2340
2341	}
2342
2343	setZ( z ) {
2344
2345		this.z = z;
2346
2347		return this;
2348
2349	}
2350
2351	setW( w ) {
2352
2353		this.w = w;
2354
2355		return this;
2356
2357	}
2358
2359	setComponent( index, value ) {
2360
2361		switch ( index ) {
2362
2363			case 0: this.x = value; break;
2364			case 1: this.y = value; break;
2365			case 2: this.z = value; break;
2366			case 3: this.w = value; break;
2367			default: throw new Error( 'index is out of range: ' + index );
2368
2369		}
2370
2371		return this;
2372
2373	}
2374
2375	getComponent( index ) {
2376
2377		switch ( index ) {
2378
2379			case 0: return this.x;
2380			case 1: return this.y;
2381			case 2: return this.z;
2382			case 3: return this.w;
2383			default: throw new Error( 'index is out of range: ' + index );
2384
2385		}
2386
2387	}
2388
2389	clone() {
2390
2391		return new this.constructor( this.x, this.y, this.z, this.w );
2392
2393	}
2394
2395	copy( v ) {
2396
2397		this.x = v.x;
2398		this.y = v.y;
2399		this.z = v.z;
2400		this.w = ( v.w !== undefined ) ? v.w : 1;
2401
2402		return this;
2403
2404	}
2405
2406	add( v ) {
2407
2408		this.x += v.x;
2409		this.y += v.y;
2410		this.z += v.z;
2411		this.w += v.w;
2412
2413		return this;
2414
2415	}
2416
2417	addScalar( s ) {
2418
2419		this.x += s;
2420		this.y += s;
2421		this.z += s;
2422		this.w += s;
2423
2424		return this;
2425
2426	}
2427
2428	addVectors( a, b ) {
2429
2430		this.x = a.x + b.x;
2431		this.y = a.y + b.y;
2432		this.z = a.z + b.z;
2433		this.w = a.w + b.w;
2434
2435		return this;
2436
2437	}
2438
2439	addScaledVector( v, s ) {
2440
2441		this.x += v.x * s;
2442		this.y += v.y * s;
2443		this.z += v.z * s;
2444		this.w += v.w * s;
2445
2446		return this;
2447
2448	}
2449
2450	sub( v ) {
2451
2452		this.x -= v.x;
2453		this.y -= v.y;
2454		this.z -= v.z;
2455		this.w -= v.w;
2456
2457		return this;
2458
2459	}
2460
2461	subScalar( s ) {
2462
2463		this.x -= s;
2464		this.y -= s;
2465		this.z -= s;
2466		this.w -= s;
2467
2468		return this;
2469
2470	}
2471
2472	subVectors( a, b ) {
2473
2474		this.x = a.x - b.x;
2475		this.y = a.y - b.y;
2476		this.z = a.z - b.z;
2477		this.w = a.w - b.w;
2478
2479		return this;
2480
2481	}
2482
2483	multiply( v ) {
2484
2485		this.x *= v.x;
2486		this.y *= v.y;
2487		this.z *= v.z;
2488		this.w *= v.w;
2489
2490		return this;
2491
2492	}
2493
2494	multiplyScalar( scalar ) {
2495
2496		this.x *= scalar;
2497		this.y *= scalar;
2498		this.z *= scalar;
2499		this.w *= scalar;
2500
2501		return this;
2502
2503	}
2504

2505	applyMatrix4( m ) {
2506
2507		const x = this.x, y = this.y, z = this.z, w = this.w;
2508		const e = m.elements;
2509
2510		this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w;
2511		this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w;
2512		this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w;
2513		this.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w;
2514
2515		return this;
2516
2517	}
2518
2519	divideScalar( scalar ) {
2520
2521		return this.multiplyScalar( 1 / scalar );
2522
2523	}
2524
2525	setAxisAngleFromQuaternion( q ) {
2526
2527		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
2528
2529		// q is assumed to be normalized
2530
2531		this.w = 2 * Math.acos( q.w );
2532
2533		const s = Math.sqrt( 1 - q.w * q.w );
2534
2535		if ( s < 0.0001 ) {
2536
2537			this.x = 1;
2538			this.y = 0;
2539			this.z = 0;
2540
2541		} else {
2542
2543			this.x = q.x / s;
2544			this.y = q.y / s;
2545			this.z = q.z / s;
2546
2547		}
2548
2549		return this;
2550
2551	}
2552
2553	setAxisAngleFromRotationMatrix( m ) {
2554
2555		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm
2556
2557		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
2558
2559		let angle, x, y, z; // variables for result
2560		const epsilon = 0.01,		// margin to allow for rounding errors
2561			epsilon2 = 0.1,		// margin to distinguish between 0 and 180 degrees
2562
2563			te = m.elements,
2564
2565			m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
2566			m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
2567			m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];
2568
2569		if ( ( Math.abs( m12 - m21 ) < epsilon ) &&
2570		     ( Math.abs( m13 - m31 ) < epsilon ) &&
2571		     ( Math.abs( m23 - m32 ) < epsilon ) ) {
2572
2573			// singularity found
2574			// first check for identity matrix which must have +1 for all terms
2575			// in leading diagonal and zero in other terms
2576
2577			if ( ( Math.abs( m12 + m21 ) < epsilon2 ) &&
2578			     ( Math.abs( m13 + m31 ) < epsilon2 ) &&
2579			     ( Math.abs( m23 + m32 ) < epsilon2 ) &&
2580			     ( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) {
2581
2582				// this singularity is identity matrix so angle = 0
2583
2584				this.set( 1, 0, 0, 0 );
2585
2586				return this; // zero angle, arbitrary axis
2587
2588			}
2589
2590			// otherwise this singularity is angle = 180
2591
2592			angle = Math.PI;
2593
2594			const xx = ( m11 + 1 ) / 2;
2595			const yy = ( m22 + 1 ) / 2;
2596			const zz = ( m33 + 1 ) / 2;
2597			const xy = ( m12 + m21 ) / 4;
2598			const xz = ( m13 + m31 ) / 4;
2599			const yz = ( m23 + m32 ) / 4;
2600
2601			if ( ( xx > yy ) && ( xx > zz ) ) {
2602
2603				// m11 is the largest diagonal term
2604
2605				if ( xx < epsilon ) {
2606
2607					x = 0;
2608					y = 0.707106781;
2609					z = 0.707106781;
2610
2611				} else {
2612
2613					x = Math.sqrt( xx );
2614					y = xy / x;
2615					z = xz / x;
2616
2617				}
2618
2619			} else if ( yy > zz ) {
2620
2621				// m22 is the largest diagonal term
2622
2623				if ( yy < epsilon ) {
2624
2625					x = 0.707106781;
2626					y = 0;
2627					z = 0.707106781;
2628
2629				} else {
2630
2631					y = Math.sqrt( yy );
2632					x = xy / y;
2633					z = yz / y;
2634
2635				}
2636
2637			} else {
2638
2639				// m33 is the largest diagonal term so base result on this
2640
2641				if ( zz < epsilon ) {
2642
2643					x = 0.707106781;
2644					y = 0.707106781;
2645					z = 0;
2646
2647				} else {
2648
2649					z = Math.sqrt( zz );
2650					x = xz / z;
2651					y = yz / z;
2652
2653				}
2654
2655			}
2656
2657			this.set( x, y, z, angle );
2658
2659			return this; // return 180 deg rotation
2660
2661		}
2662
2663		// as we have reached here there are no singularities so we can handle normally
2664
2665		let s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) +
2666			( m13 - m31 ) * ( m13 - m31 ) +
2667			( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize
2668
2669		if ( Math.abs( s ) < 0.001 ) s = 1;
2670
2671		// prevent divide by zero, should not happen if matrix is orthogonal and should be
2672		// caught by singularity test above, but I've left it in just in case
2673
2674		this.x = ( m32 - m23 ) / s;
2675		this.y = ( m13 - m31 ) / s;
2676		this.z = ( m21 - m12 ) / s;
2677		this.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 );
2678
2679		return this;
2680
2681	}
2682
2683	min( v ) {
2684
2685		this.x = Math.min( this.x, v.x );
2686		this.y = Math.min( this.y, v.y );
2687		this.z = Math.min( this.z, v.z );
2688		this.w = Math.min( this.w, v.w );
2689
2690		return this;
2691
2692	}
2693
2694	max( v ) {
2695
2696		this.x = Math.max( this.x, v.x );
2697		this.y = Math.max( this.y, v.y );
2698		this.z = Math.max( this.z, v.z );
2699		this.w = Math.max( this.w, v.w );
2700
2701		return this;
2702
2703	}
2704
2705	clamp( min, max ) {
2706
2707		// assumes min < max, componentwise
2708
2709		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
2710		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
2711		this.z = Math.max( min.z, Math.min( max.z, this.z ) );
2712		this.w = Math.max( min.w, Math.min( max.w, this.w ) );
2713
2714		return this;
2715
2716	}
2717
2718	clampScalar( minVal, maxVal ) {
2719
2720		this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
2721		this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
2722		this.z = Math.max( minVal, Math.min( maxVal, this.z ) );
2723		this.w = Math.max( minVal, Math.min( maxVal, this.w ) );
2724
2725		return this;
2726
2727	}
2728
2729	clampLength( min, max ) {
2730
2731		const length = this.length();
2732
2733		return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
2734
2735	}
2736
2737	floor() {
2738
2739		this.x = Math.floor( this.x );
2740		this.y = Math.floor( this.y );
2741		this.z = Math.floor( this.z );
2742		this.w = Math.floor( this.w );
2743
2744		return this;
2745
2746	}
2747
2748	ceil() {
2749
2750		this.x = Math.ceil( this.x );
2751		this.y = Math.ceil( this.y );
2752		this.z = Math.ceil( this.z );
2753		this.w = Math.ceil( this.w );
2754
2755		return this;
2756
2757	}
2758
2759	round() {
2760
2761		this.x = Math.round( this.x );
2762		this.y = Math.round( this.y );
2763		this.z = Math.round( this.z );
2764		this.w = Math.round( this.w );
2765
2766		return this;
2767
2768	}
2769
2770	roundToZero() {
2771
2772		this.x = Math.trunc( this.x );
2773		this.y = Math.trunc( this.y );
2774		this.z = Math.trunc( this.z );
2775		this.w = Math.trunc( this.w );
2776
2777		return this;
2778
2779	}
2780
2781	negate() {
2782
2783		this.x = - this.x;
2784		this.y = - this.y;
2785		this.z = - this.z;
2786		this.w = - this.w;
2787
2788		return this;
2789
2790	}
2791
2792	dot( v ) {
2793
2794		return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
2795
2796	}
2797
2798	lengthSq() {
2799
2800		return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
2801
2802	}
2803
2804	length() {
2805
2806		return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w );
2807
2808	}
2809
2810	manhattanLength() {
2811
2812		return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w );
2813
2814	}
2815
2816	normalize() {
2817
2818		return this.divideScalar( this.length() || 1 );
2819
2820	}
2821
2822	setLength( length ) {
2823
2824		return this.normalize().multiplyScalar( length );
2825
2826	}
2827
2828	lerp( v, alpha ) {
2829
2830		this.x += ( v.x - this.x ) * alpha;
2831		this.y += ( v.y - this.y ) * alpha;
2832		this.z += ( v.z - this.z ) * alpha;
2833		this.w += ( v.w - this.w ) * alpha;
2834
2835		return this;
2836
2837	}
2838
2839	lerpVectors( v1, v2, alpha ) {
2840
2841		this.x = v1.x + ( v2.x - v1.x ) * alpha;
2842		this.y = v1.y + ( v2.y - v1.y ) * alpha;
2843		this.z = v1.z + ( v2.z - v1.z ) * alpha;
2844		this.w = v1.w + ( v2.w - v1.w ) * alpha;
2845
2846		return this;
2847
2848	}
2849
2850	equals( v ) {
2851
2852		return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) );
2853
2854	}
2855
2856	fromArray( array, offset = 0 ) {
2857
2858		this.x = array[ offset ];
2859		this.y = array[ offset + 1 ];
2860		this.z = array[ offset + 2 ];
2861		this.w = array[ offset + 3 ];
2862
2863		return this;
2864
2865	}
2866
2867	toArray( array = [], offset = 0 ) {
2868
2869		array[ offset ] = this.x;
2870		array[ offset + 1 ] = this.y;
2871		array[ offset + 2 ] = this.z;
2872		array[ offset + 3 ] = this.w;
2873
2874		return array;
2875
2876	}
2877
2878	fromBufferAttribute( attribute, index ) {
2879
2880		this.x = attribute.getX( index );
2881		this.y = attribute.getY( index );
2882		this.z = attribute.getZ( index );
2883		this.w = attribute.getW( index );
2884
2885		return this;
2886
2887	}
2888
2889	random() {
2890
2891		this.x = Math.random();
2892		this.y = Math.random();
2893		this.z = Math.random();
2894		this.w = Math.random();
2895
2896		return this;
2897
2898	}
2899
2900	*[ Symbol.iterator ]() {
2901
2902		yield this.x;
2903		yield this.y;
2904		yield this.z;
2905		yield this.w;
2906
2907	}
2908
2909}
2910
2911/*
2912 In options, we can specify:
2913 * Texture parameters for an auto-generated target texture
2914 * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers
2915*/
2916class RenderTarget extends EventDispatcher {
2917
2918	constructor( width = 1, height = 1, options = {} ) {
2919
2920		super();
2921
2922		this.isRenderTarget = true;
2923
2924		this.width = width;
2925		this.height = height;
2926		this.depth = 1;
2927
2928		this.scissor = new Vector4( 0, 0, width, height );
2929		this.scissorTest = false;
2930
2931		this.viewport = new Vector4( 0, 0, width, height );
2932
2933		const image = { width: width, height: height, depth: 1 };
2934
2935		if ( options.encoding !== undefined ) {
2936
2937			// @deprecated, r152
2938			warnOnce( 'THREE.WebGLRenderTarget: option.encoding has been replaced by option.colorSpace.' );
2939			options.colorSpace = options.encoding === sRGBEncoding ? SRGBColorSpace : NoColorSpace;
2940
2941		}
2942
2943		options = Object.assign( {
2944			generateMipmaps: false,
2945			internalFormat: null,
2946			minFilter: LinearFilter,
2947			depthBuffer: true,
2948			stencilBuffer: false,
2949			depthTexture: null,
2950			samples: 0
2951		}, options );
2952
2953		this.texture = new Texture( image, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.colorSpace );
2954		this.texture.isRenderTargetTexture = true;
2955
2956		this.texture.flipY = false;
2957		this.texture.generateMipmaps = options.generateMipmaps;
2958		this.texture.internalFormat = options.internalFormat;
2959
2960		this.depthBuffer = options.depthBuffer;
2961		this.stencilBuffer = options.stencilBuffer;
2962
2963		this.depthTexture = options.depthTexture;
2964
2965		this.samples = options.samples;
2966
2967	}
2968
2969	setSize( width, height, depth = 1 ) {
2970
2971		if ( this.width !== width || this.height !== height || this.depth !== depth ) {
2972
2973			this.width = width;
2974			this.height = height;
2975			this.depth = depth;
2976
2977			this.texture.image.width = width;
2978			this.texture.image.height = height;
2979			this.texture.image.depth = depth;
2980
2981			this.dispose();
2982
2983		}
2984
2985		this.viewport.set( 0, 0, width, height );
2986		this.scissor.set( 0, 0, width, height );
2987
2988	}
2989
2990	clone() {
2991
2992		return new this.constructor().copy( this );
2993
2994	}
2995
2996	copy( source ) {
2997
2998		this.width = source.width;
2999		this.height = source.height;
3000		this.depth = source.depth;
3001
3002		this.scissor.copy( source.scissor );
3003		this.scissorTest = source.scissorTest;
3004
3005		this.viewport.copy( source.viewport );
3006
3007		this.texture = source.texture.clone();
3008		this.texture.isRenderTargetTexture = true;
3009
3010		// ensure image object is not shared, see #20328
3011
3012		const image = Object.assign( {}, source.texture.image );
3013		this.texture.source = new Source( image );
3014
3015		this.depthBuffer = source.depthBuffer;
3016		this.stencilBuffer = source.stencilBuffer;
3017
3018		if ( source.depthTexture !== null ) this.depthTexture = source.depthTexture.clone();
3019
3020		this.samples = source.samples;
3021
3022		return this;
3023
3024	}
3025
3026	dispose() {
3027
3028		this.dispatchEvent( { type: 'dispose' } );
3029
3030	}
3031
3032}
3033
3034class WebGLRenderTarget extends RenderTarget {
3035
3036	constructor( width = 1, height = 1, options = {} ) {
3037
3038		super( width, height, options );
3039
3040		this.isWebGLRenderTarget = true;
3041
3042	}
3043
3044}
3045
3046class DataArrayTexture extends Texture {
3047
3048	constructor( data = null, width = 1, height = 1, depth = 1 ) {
3049
3050		super( null );
3051
3052		this.isDataArrayTexture = true;
3053
3054		this.image = { data, width, height, depth };
3055
3056		this.magFilter = NearestFilter;
3057		this.minFilter = NearestFilter;
3058
3059		this.wrapR = ClampToEdgeWrapping;
3060
3061		this.generateMipmaps = false;
3062		this.flipY = false;
3063		this.unpackAlignment = 1;
3064
3065	}
3066
3067}
3068
3069class WebGLArrayRenderTarget extends WebGLRenderTarget {
3070
3071	constructor( width = 1, height = 1, depth = 1, options = {} ) {
3072
3073		super( width, height, options );
3074
3075		this.isWebGLArrayRenderTarget = true;
3076
3077		this.depth = depth;
3078
3079		this.texture = new DataArrayTexture( null, width, height, depth );
3080
3081		this.texture.isRenderTargetTexture = true;
3082
3083	}
3084
3085}
3086
3087class Data3DTexture extends Texture {
3088
3089	constructor( data = null, width = 1, height = 1, depth = 1 ) {
3090
3091		// We're going to add .setXXX() methods for setting properties later.
3092		// Users can still set in DataTexture3D directly.
3093		//
3094		//	const texture = new THREE.DataTexture3D( data, width, height, depth );
3095		// 	texture.anisotropy = 16;
3096		//
3097		// See #14839
3098
3099		super( null );
3100
3101		this.isData3DTexture = true;
3102
3103		this.image = { data, width, height, depth };
3104
3105		this.magFilter = NearestFilter;
3106		this.minFilter = NearestFilter;
3107
3108		this.wrapR = ClampToEdgeWrapping;
3109
3110		this.generateMipmaps = false;
3111		this.flipY = false;
3112		this.unpackAlignment = 1;
3113
3114	}
3115
3116}
3117
3118class WebGL3DRenderTarget extends WebGLRenderTarget {
3119
3120	constructor( width = 1, height = 1, depth = 1, options = {} ) {
3121
3122		super( width, height, options );
3123
3124		this.isWebGL3DRenderTarget = true;
3125
3126		this.depth = depth;
3127
3128		this.texture = new Data3DTexture( null, width, height, depth );
3129
3130		this.texture.isRenderTargetTexture = true;
3131
3132	}
3133
3134}
3135
3136class WebGLMultipleRenderTargets extends WebGLRenderTarget {
3137
3138	constructor( width = 1, height = 1, count = 1, options = {} ) {
3139
3140		super( width, height, options );
3141
3142		this.isWebGLMultipleRenderTargets = true;
3143
3144		const texture = this.texture;
3145
3146		this.texture = [];
3147
3148		for ( let i = 0; i < count; i ++ ) {
3149
3150			this.texture[ i ] = texture.clone();
3151			this.texture[ i ].isRenderTargetTexture = true;
3152
3153		}
3154
3155	}
3156
3157	setSize( width, height, depth = 1 ) {
3158
3159		if ( this.width !== width || this.height !== height || this.depth !== depth ) {
3160
3161			this.width = width;
3162			this.height = height;
3163			this.depth = depth;
3164
3165			for ( let i = 0, il = this.texture.length; i < il; i ++ ) {
3166
3167				this.texture[ i ].image.width = width;
3168				this.texture[ i ].image.height = height;
3169				this.texture[ i ].image.depth = depth;
3170
3171			}
3172
3173			this.dispose();
3174
3175		}
3176
3177		this.viewport.set( 0, 0, width, height );
3178		this.scissor.set( 0, 0, width, height );
3179
3180	}
3181
3182	copy( source ) {
3183
3184		this.dispose();
3185
3186		this.width = source.width;
3187		this.height = source.height;
3188		this.depth = source.depth;
3189
3190		this.scissor.copy( source.scissor );
3191		this.scissorTest = source.scissorTest;
3192
3193		this.viewport.copy( source.viewport );
3194
3195		this.depthBuffer = source.depthBuffer;
3196		this.stencilBuffer = source.stencilBuffer;
3197
3198		if ( source.depthTexture !== null ) this.depthTexture = source.depthTexture.clone();
3199
3200		this.texture.length = 0;
3201
3202		for ( let i = 0, il = source.texture.length; i < il; i ++ ) {
3203
3204			this.texture[ i ] = source.texture[ i ].clone();
3205			this.texture[ i ].isRenderTargetTexture = true;
3206
3207		}
3208
3209		return this;
3210
3211	}
3212
3213}
3214
3215class Quaternion {
3216
3217	constructor( x = 0, y = 0, z = 0, w = 1 ) {
3218
3219		this.isQuaternion = true;
3220
3221		this._x = x;
3222		this._y = y;
3223		this._z = z;
3224		this._w = w;
3225
3226	}
3227
3228	static slerpFlat( dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) {
3229
3230		// fuzz-free, array-based Quaternion SLERP operation
3231
3232		let x0 = src0[ srcOffset0 + 0 ],
3233			y0 = src0[ srcOffset0 + 1 ],
3234			z0 = src0[ srcOffset0 + 2 ],
3235			w0 = src0[ srcOffset0 + 3 ];
3236
3237		const x1 = src1[ srcOffset1 + 0 ],
3238			y1 = src1[ srcOffset1 + 1 ],
3239			z1 = src1[ srcOffset1 + 2 ],
3240			w1 = src1[ srcOffset1 + 3 ];
3241
3242		if ( t === 0 ) {
3243
3244			dst[ dstOffset + 0 ] = x0;
3245			dst[ dstOffset + 1 ] = y0;
3246			dst[ dstOffset + 2 ] = z0;
3247			dst[ dstOffset + 3 ] = w0;
3248			return;
3249
3250		}
3251
3252		if ( t === 1 ) {
3253
3254			dst[ dstOffset + 0 ] = x1;
3255			dst[ dstOffset + 1 ] = y1;
3256			dst[ dstOffset + 2 ] = z1;
3257			dst[ dstOffset + 3 ] = w1;
3258			return;
3259
3260		}
3261
3262		if ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) {
3263
3264			let s = 1 - t;
3265			const cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
3266				dir = ( cos >= 0 ? 1 : - 1 ),
3267				sqrSin = 1 - cos * cos;
3268
3269			// Skip the Slerp for tiny steps to avoid numeric problems:
3270			if ( sqrSin > Number.EPSILON ) {
3271
3272				const sin = Math.sqrt( sqrSin ),
3273					len = Math.atan2( sin, cos * dir );
3274
3275				s = Math.sin( s * len ) / sin;
3276				t = Math.sin( t * len ) / sin;
3277
3278			}
3279
3280			const tDir = t * dir;
3281
3282			x0 = x0 * s + x1 * tDir;
3283			y0 = y0 * s + y1 * tDir;
3284			z0 = z0 * s + z1 * tDir;
3285			w0 = w0 * s + w1 * tDir;
3286
3287			// Normalize in case we just did a lerp:
3288			if ( s === 1 - t ) {
3289
3290				const f = 1 / Math.sqrt( x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0 );
3291
3292				x0 *= f;
3293				y0 *= f;
3294				z0 *= f;
3295				w0 *= f;
3296
3297			}
3298
3299		}
3300
3301		dst[ dstOffset ] = x0;
3302		dst[ dstOffset + 1 ] = y0;
3303		dst[ dstOffset + 2 ] = z0;
3304		dst[ dstOffset + 3 ] = w0;
3305
3306	}
3307
3308	static multiplyQuaternionsFlat( dst, dstOffset, src0, srcOffset0, src1, srcOffset1 ) {
3309
3310		const x0 = src0[ srcOffset0 ];
3311		const y0 = src0[ srcOffset0 + 1 ];
3312		const z0 = src0[ srcOffset0 + 2 ];
3313		const w0 = src0[ srcOffset0 + 3 ];
3314
3315		const x1 = src1[ srcOffset1 ];
3316		const y1 = src1[ srcOffset1 + 1 ];
3317		const z1 = src1[ srcOffset1 + 2 ];
3318		const w1 = src1[ srcOffset1 + 3 ];
3319
3320		dst[ dstOffset ] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
3321		dst[ dstOffset + 1 ] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
3322		dst[ dstOffset + 2 ] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
3323		dst[ dstOffset + 3 ] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
3324
3325		return dst;
3326
3327	}
3328
3329	get x() {
3330
3331		return this._x;
3332
3333	}
3334
3335	set x( value ) {
3336
3337		this._x = value;
3338		this._onChangeCallback();
3339
3340	}
3341
3342	get y() {
3343
3344		return this._y;
3345
3346	}
3347
3348	set y( value ) {
3349
3350		this._y = value;
3351		this._onChangeCallback();
3352
3353	}
3354
3355	get z() {
3356
3357		return this._z;
3358
3359	}
3360
3361	set z( value ) {
3362
3363		this._z = value;
3364		this._onChangeCallback();
3365
3366	}
3367
3368	get w() {
3369
3370		return this._w;
3371
3372	}
3373
3374	set w( value ) {
3375
3376		this._w = value;
3377		this._onChangeCallback();
3378
3379	}
3380
3381	set( x, y, z, w ) {
3382
3383		this._x = x;
3384		this._y = y;
3385		this._z = z;
3386		this._w = w;
3387
3388		this._onChangeCallback();
3389
3390		return this;
3391
3392	}
3393
3394	clone() {
3395
3396		return new this.constructor( this._x, this._y, this._z, this._w );
3397
3398	}
3399
3400	copy( quaternion ) {
3401
3402		this._x = quaternion.x;
3403		this._y = quaternion.y;
3404		this._z = quaternion.z;
3405		this._w = quaternion.w;
3406
3407		this._onChangeCallback();
3408
3409		return this;
3410
3411	}
3412
3413	setFromEuler( euler, update = true ) {
3414
3415		const x = euler._x, y = euler._y, z = euler._z, order = euler._order;
3416
3417		// http://www.mathworks.com/matlabcentral/fileexchange/
3418		// 	20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
3419		//	content/SpinCalc.m
3420
3421		const cos = Math.cos;
3422		const sin = Math.sin;
3423
3424		const c1 = cos( x / 2 );
3425		const c2 = cos( y / 2 );
3426		const c3 = cos( z / 2 );
3427
3428		const s1 = sin( x / 2 );
3429		const s2 = sin( y / 2 );
3430		const s3 = sin( z / 2 );
3431
3432		switch ( order ) {
3433
3434			case 'XYZ':
3435				this._x = s1 * c2 * c3 + c1 * s2 * s3;
3436				this._y = c1 * s2 * c3 - s1 * c2 * s3;
3437				this._z = c1 * c2 * s3 + s1 * s2 * c3;
3438				this._w = c1 * c2 * c3 - s1 * s2 * s3;
3439				break;
3440
3441			case 'YXZ':
3442				this._x = s1 * c2 * c3 + c1 * s2 * s3;
3443				this._y = c1 * s2 * c3 - s1 * c2 * s3;
3444				this._z = c1 * c2 * s3 - s1 * s2 * c3;
3445				this._w = c1 * c2 * c3 + s1 * s2 * s3;
3446				break;
3447
3448			case 'ZXY':
3449				this._x = s1 * c2 * c3 - c1 * s2 * s3;
3450				this._y = c1 * s2 * c3 + s1 * c2 * s3;
3451				this._z = c1 * c2 * s3 + s1 * s2 * c3;
3452				this._w = c1 * c2 * c3 - s1 * s2 * s3;
3453				break;
3454
3455			case 'ZYX':
3456				this._x = s1 * c2 * c3 - c1 * s2 * s3;
3457				this._y = c1 * s2 * c3 + s1 * c2 * s3;
3458				this._z = c1 * c2 * s3 - s1 * s2 * c3;
3459				this._w = c1 * c2 * c3 + s1 * s2 * s3;
3460				break;
3461
3462			case 'YZX':
3463				this._x = s1 * c2 * c3 + c1 * s2 * s3;
3464				this._y = c1 * s2 * c3 + s1 * c2 * s3;
3465				this._z = c1 * c2 * s3 - s1 * s2 * c3;
3466				this._w = c1 * c2 * c3 - s1 * s2 * s3;
3467				break;
3468
3469			case 'XZY':
3470				this._x = s1 * c2 * c3 - c1 * s2 * s3;
3471				this._y = c1 * s2 * c3 - s1 * c2 * s3;
3472				this._z = c1 * c2 * s3 + s1 * s2 * c3;
3473				this._w = c1 * c2 * c3 + s1 * s2 * s3;
3474				break;
3475
3476			default:
3477				console.warn( 'THREE.Quaternion: .setFromEuler() encountered an unknown order: ' + order );
3478
3479		}
3480
3481		if ( update === true ) this._onChangeCallback();
3482
3483		return this;
3484
3485	}
3486
3487	setFromAxisAngle( axis, angle ) {
3488
3489		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
3490
3491		// assumes axis is normalized
3492
3493		const halfAngle = angle / 2, s = Math.sin( halfAngle );
3494
3495		this._x = axis.x * s;
3496		this._y = axis.y * s;
3497		this._z = axis.z * s;
3498		this._w = Math.cos( halfAngle );
3499
3500		this._onChangeCallback();
3501
3502		return this;
3503
3504	}
3505
3506	setFromRotationMatrix( m ) {
3507
3508		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
3509
3510		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
3511
3512		const te = m.elements,
3513
3514			m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
3515			m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
3516			m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ],
3517
3518			trace = m11 + m22 + m33;
3519
3520		if ( trace > 0 ) {
3521
3522			const s = 0.5 / Math.sqrt( trace + 1.0 );
3523
3524			this._w = 0.25 / s;
3525			this._x = ( m32 - m23 ) * s;
3526			this._y = ( m13 - m31 ) * s;
3527			this._z = ( m21 - m12 ) * s;
3528
3529		} else if ( m11 > m22 && m11 > m33 ) {
3530
3531			const s = 2.0 * Math.sqrt( 1.0 + m11 - m22 - m33 );
3532
3533			this._w = ( m32 - m23 ) / s;
3534			this._x = 0.25 * s;
3535			this._y = ( m12 + m21 ) / s;
3536			this._z = ( m13 + m31 ) / s;
3537
3538		} else if ( m22 > m33 ) {
3539
3540			const s = 2.0 * Math.sqrt( 1.0 + m22 - m11 - m33 );
3541
3542			this._w = ( m13 - m31 ) / s;
3543			this._x = ( m12 + m21 ) / s;
3544			this._y = 0.25 * s;
3545			this._z = ( m23 + m32 ) / s;
3546
3547		} else {
3548
3549			const s = 2.0 * Math.sqrt( 1.0 + m33 - m11 - m22 );
3550
3551			this._w = ( m21 - m12 ) / s;
3552			this._x = ( m13 + m31 ) / s;
3553			this._y = ( m23 + m32 ) / s;
3554			this._z = 0.25 * s;
3555
3556		}
3557
3558		this._onChangeCallback();
3559
3560		return this;
3561
3562	}
3563
3564	setFromUnitVectors( vFrom, vTo ) {
3565
3566		// assumes direction vectors vFrom and vTo are normalized
3567
3568		let r = vFrom.dot( vTo ) + 1;
3569
3570		if ( r < Number.EPSILON ) {
3571
3572			// vFrom and vTo point in opposite directions
3573
3574			r = 0;
3575
3576			if ( Math.abs( vFrom.x ) > Math.abs( vFrom.z ) ) {
3577
3578				this._x = - vFrom.y;
3579				this._y = vFrom.x;
3580				this._z = 0;
3581				this._w = r;
3582
3583			} else {
3584
3585				this._x = 0;
3586				this._y = - vFrom.z;
3587				this._z = vFrom.y;
3588				this._w = r;
3589
3590			}
3591
3592		} else {
3593
3594			// crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3
3595
3596			this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
3597			this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
3598			this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
3599			this._w = r;
3600
3601		}
3602
3603		return this.normalize();
3604
3605	}
3606
3607	angleTo( q ) {
3608
3609		return 2 * Math.acos( Math.abs( clamp( this.dot( q ), - 1, 1 ) ) );
3610
3611	}
3612
3613	rotateTowards( q, step ) {
3614
3615		const angle = this.angleTo( q );
3616
3617		if ( angle === 0 ) return this;
3618
3619		const t = Math.min( 1, step / angle );
3620
3621		this.slerp( q, t );
3622
3623		return this;
3624
3625	}
3626
3627	identity() {
3628
3629		return this.set( 0, 0, 0, 1 );
3630
3631	}
3632
3633	invert() {
3634
3635		// quaternion is assumed to have unit length
3636
3637		return this.conjugate();
3638
3639	}
3640
3641	conjugate() {
3642
3643		this._x *= - 1;
3644		this._y *= - 1;
3645		this._z *= - 1;
3646
3647		this._onChangeCallback();
3648
3649		return this;
3650
3651	}
3652
3653	dot( v ) {
3654
3655		return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
3656
3657	}
3658
3659	lengthSq() {
3660
3661		return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
3662
3663	}
3664
3665	length() {
3666
3667		return Math.sqrt( this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w );
3668
3669	}
3670
3671	normalize() {
3672
3673		let l = this.length();
3674
3675		if ( l === 0 ) {
3676
3677			this._x = 0;
3678			this._y = 0;
3679			this._z = 0;
3680			this._w = 1;
3681
3682		} else {
3683
3684			l = 1 / l;
3685
3686			this._x = this._x * l;
3687			this._y = this._y * l;
3688			this._z = this._z * l;
3689			this._w = this._w * l;
3690
3691		}
3692
3693		this._onChangeCallback();
3694
3695		return this;
3696
3697	}
3698
3699	multiply( q ) {
3700
3701		return this.multiplyQuaternions( this, q );
3702
3703	}
3704
3705	premultiply( q ) {
3706
3707		return this.multiplyQuaternions( q, this );
3708
3709	}
3710
3711	multiplyQuaternions( a, b ) {
3712
3713		// from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
3714
3715		const qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;
3716		const qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;
3717
3718		this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
3719		this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
3720		this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
3721		this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
3722
3723		this._onChangeCallback();
3724
3725		return this;
3726
3727	}
3728
3729	slerp( qb, t ) {
3730
3731		if ( t === 0 ) return this;
3732		if ( t === 1 ) return this.copy( qb );
3733
3734		const x = this._x, y = this._y, z = this._z, w = this._w;
3735
3736		// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
3737
3738		let cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
3739
3740		if ( cosHalfTheta < 0 ) {
3741
3742			this._w = - qb._w;
3743			this._x = - qb._x;
3744			this._y = - qb._y;
3745			this._z = - qb._z;
3746
3747			cosHalfTheta = - cosHalfTheta;
3748
3749		} else {
3750
3751			this.copy( qb );
3752
3753		}
3754
3755		if ( cosHalfTheta >= 1.0 ) {
3756
3757			this._w = w;
3758			this._x = x;
3759			this._y = y;
3760			this._z = z;
3761
3762			return this;
3763
3764		}
3765
3766		const sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
3767
3768		if ( sqrSinHalfTheta <= Number.EPSILON ) {
3769
3770			const s = 1 - t;
3771			this._w = s * w + t * this._w;
3772			this._x = s * x + t * this._x;
3773			this._y = s * y + t * this._y;
3774			this._z = s * z + t * this._z;
3775
3776			this.normalize(); // normalize calls _onChangeCallback()
3777
3778			return this;
3779
3780		}
3781
3782		const sinHalfTheta = Math.sqrt( sqrSinHalfTheta );
3783		const halfTheta = Math.atan2( sinHalfTheta, cosHalfTheta );
3784		const ratioA = Math.sin( ( 1 - t ) * halfTheta ) / sinHalfTheta,
3785			ratioB = Math.sin( t * halfTheta ) / sinHalfTheta;
3786
3787		this._w = ( w * ratioA + this._w * ratioB );
3788		this._x = ( x * ratioA + this._x * ratioB );
3789		this._y = ( y * ratioA + this._y * ratioB );
3790		this._z = ( z * ratioA + this._z * ratioB );
3791
3792		this._onChangeCallback();
3793
3794		return this;
3795
3796	}
3797
3798	slerpQuaternions( qa, qb, t ) {
3799
3800		return this.copy( qa ).slerp( qb, t );
3801
3802	}
3803
3804	random() {
3805
3806		// Derived from http://planning.cs.uiuc.edu/node198.html
3807		// Note, this source uses w, x, y, z ordering,
3808		// so we swap the order below.
3809
3810		const u1 = Math.random();
3811		const sqrt1u1 = Math.sqrt( 1 - u1 );
3812		const sqrtu1 = Math.sqrt( u1 );
3813
3814		const u2 = 2 * Math.PI * Math.random();
3815
3816		const u3 = 2 * Math.PI * Math.random();
3817
3818		return this.set(
3819			sqrt1u1 * Math.cos( u2 ),
3820			sqrtu1 * Math.sin( u3 ),
3821			sqrtu1 * Math.cos( u3 ),
3822			sqrt1u1 * Math.sin( u2 ),
3823		);
3824
3825	}
3826
3827	equals( quaternion ) {
3828
3829		return ( quaternion._x === this._x ) && ( quaternion._y === this._y ) && ( quaternion._z === this._z ) && ( quaternion._w === this._w );
3830
3831	}
3832
3833	fromArray( array, offset = 0 ) {
3834
3835		this._x = array[ offset ];
3836		this._y = array[ offset + 1 ];
3837		this._z = array[ offset + 2 ];
3838		this._w = array[ offset + 3 ];
3839
3840		this._onChangeCallback();
3841
3842		return this;
3843
3844	}
3845
3846	toArray( array = [], offset = 0 ) {
3847
3848		array[ offset ] = this._x;
3849		array[ offset + 1 ] = this._y;
3850		array[ offset + 2 ] = this._z;
3851		array[ offset + 3 ] = this._w;
3852
3853		return array;
3854
3855	}
3856
3857	fromBufferAttribute( attribute, index ) {
3858
3859		this._x = attribute.getX( index );
3860		this._y = attribute.getY( index );
3861		this._z = attribute.getZ( index );
3862		this._w = attribute.getW( index );
3863
3864		this._onChangeCallback();
3865
3866		return this;
3867
3868	}
3869
3870	toJSON() {
3871
3872		return this.toArray();
3873
3874	}
3875
3876	_onChange( callback ) {
3877
3878		this._onChangeCallback = callback;
3879
3880		return this;
3881
3882	}
3883
3884	_onChangeCallback() {}
3885
3886	*[ Symbol.iterator ]() {
3887
3888		yield this._x;
3889		yield this._y;
3890		yield this._z;
3891		yield this._w;
3892
3893	}
3894
3895}
3896
3897class Vector3 {
3898
3899	constructor( x = 0, y = 0, z = 0 ) {
3900
3901		Vector3.prototype.isVector3 = true;
3902
3903		this.x = x;
3904		this.y = y;
3905		this.z = z;
3906
3907	}
3908
3909	set( x, y, z ) {
3910
3911		if ( z === undefined ) z = this.z; // sprite.scale.set(x,y)
3912
3913		this.x = x;
3914		this.y = y;
3915		this.z = z;
3916
3917		return this;
3918
3919	}
3920
3921	setScalar( scalar ) {
3922
3923		this.x = scalar;
3924		this.y = scalar;
3925		this.z = scalar;
3926
3927		return this;
3928
3929	}
3930
3931	setX( x ) {
3932
3933		this.x = x;
3934
3935		return this;
3936
3937	}
3938
3939	setY( y ) {
3940
3941		this.y = y;
3942
3943		return this;
3944
3945	}
3946
3947	setZ( z ) {
3948
3949		this.z = z;
3950
3951		return this;
3952
3953	}
3954
3955	setComponent( index, value ) {
3956
3957		switch ( index ) {
3958
3959			case 0: this.x = value; break;
3960			case 1: this.y = value; break;
3961			case 2: this.z = value; break;
3962			default: throw new Error( 'index is out of range: ' + index );
3963
3964		}
3965
3966		return this;
3967
3968	}
3969
3970	getComponent( index ) {
3971
3972		switch ( index ) {
3973
3974			case 0: return this.x;
3975			case 1: return this.y;
3976			case 2: return this.z;
3977			default: throw new Error( 'index is out of range: ' + index );
3978
3979		}
3980
3981	}
3982
3983	clone() {
3984
3985		return new this.constructor( this.x, this.y, this.z );
3986
3987	}
3988
3989	copy( v ) {
3990
3991		this.x = v.x;
3992		this.y = v.y;
3993		this.z = v.z;
3994
3995		return this;
3996
3997	}
3998
3999	add( v ) {
4000
4001		this.x += v.x;
4002		this.y += v.y;
4003		this.z += v.z;
4004
4005		return this;
4006
4007	}
4008
4009	addScalar( s ) {
4010
4011		this.x += s;
4012		this.y += s;
4013		this.z += s;
4014
4015		return this;
4016
4017	}
4018
4019	addVectors( a, b ) {
4020
4021		this.x = a.x + b.x;
4022		this.y = a.y + b.y;
4023		this.z = a.z + b.z;
4024
4025		return this;
4026
4027	}
4028
4029	addScaledVector( v, s ) {
4030
4031		this.x += v.x * s;
4032		this.y += v.y * s;
4033		this.z += v.z * s;
4034
4035		return this;
4036
4037	}
4038
4039	sub( v ) {
4040
4041		this.x -= v.x;
4042		this.y -= v.y;
4043		this.z -= v.z;
4044
4045		return this;
4046
4047	}
4048
4049	subScalar( s ) {
4050
4051		this.x -= s;
4052		this.y -= s;
4053		this.z -= s;
4054
4055		return this;
4056
4057	}
4058
4059	subVectors( a, b ) {
4060
4061		this.x = a.x - b.x;
4062		this.y = a.y - b.y;
4063		this.z = a.z - b.z;
4064
4065		return this;
4066
4067	}
4068
4069	multiply( v ) {
4070
4071		this.x *= v.x;
4072		this.y *= v.y;
4073		this.z *= v.z;
4074
4075		return this;
4076
4077	}
4078
4079	multiplyScalar( scalar ) {
4080
4081		this.x *= scalar;
4082		this.y *= scalar;
4083		this.z *= scalar;
4084
4085		return this;
4086
4087	}
4088
4089	multiplyVectors( a, b ) {
4090
4091		this.x = a.x * b.x;
4092		this.y = a.y * b.y;
4093		this.z = a.z * b.z;
4094
4095		return this;
4096
4097	}
4098
4099	applyEuler( euler ) {
4100
4101		return this.applyQuaternion( _quaternion$4.setFromEuler( euler ) );
4102
4103	}
4104
4105	applyAxisAngle( axis, angle ) {
4106
4107		return this.applyQuaternion( _quaternion$4.setFromAxisAngle( axis, angle ) );
4108
4109	}
4110
4111	applyMatrix3( m ) {
4112
4113		const x = this.x, y = this.y, z = this.z;
4114		const e = m.elements;
4115
4116		this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ] * z;
4117		this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ] * z;
4118		this.z = e[ 2 ] * x + e[ 5 ] * y + e[ 8 ] * z;
4119
4120		return this;
4121
4122	}
4123
4124	applyNormalMatrix( m ) {
4125
4126		return this.applyMatrix3( m ).normalize();
4127
4128	}
4129
4130	applyMatrix4( m ) {
4131
4132		const x = this.x, y = this.y, z = this.z;
4133		const e = m.elements;
4134
4135		const w = 1 / ( e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] );
4136
4137		this.x = ( e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] ) * w;
4138		this.y = ( e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] ) * w;
4139		this.z = ( e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] ) * w;
4140
4141		return this;
4142
4143	}
4144
4145	applyQuaternion( q ) {
4146
4147		// quaternion q is assumed to have unit length
4148
4149		const vx = this.x, vy = this.y, vz = this.z;
4150		const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
4151
4152		// t = 2 * cross( q.xyz, v );
4153		const tx = 2 * ( qy * vz - qz * vy );
4154		const ty = 2 * ( qz * vx - qx * vz );
4155		const tz = 2 * ( qx * vy - qy * vx );
4156
4157		// v + q.w * t + cross( q.xyz, t );
4158		this.x = vx + qw * tx + qy * tz - qz * ty;
4159		this.y = vy + qw * ty + qz * tx - qx * tz;
4160		this.z = vz + qw * tz + qx * ty - qy * tx;
4161
4162		return this;
4163
4164	}
4165
4166	project( camera ) {
4167
4168		return this.applyMatrix4( camera.matrixWorldInverse ).applyMatrix4( camera.projectionMatrix );
4169
4170	}
4171
4172	unproject( camera ) {
4173
4174		return this.applyMatrix4( camera.projectionMatrixInverse ).applyMatrix4( camera.matrixWorld );
4175
4176	}
4177
4178	transformDirection( m ) {
4179
4180		// input: THREE.Matrix4 affine matrix
4181		// vector interpreted as a direction
4182
4183		const x = this.x, y = this.y, z = this.z;
4184		const e = m.elements;
4185
4186		this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z;
4187		this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z;
4188		this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z;
4189
4190		return this.normalize();
4191
4192	}
4193
4194	divide( v ) {
4195
4196		this.x /= v.x;
4197		this.y /= v.y;
4198		this.z /= v.z;
4199
4200		return this;
4201
4202	}
4203
4204	divideScalar( scalar ) {
4205
4206		return this.multiplyScalar( 1 / scalar );
4207
4208	}
4209
4210	min( v ) {
4211
4212		this.x = Math.min( this.x, v.x );
4213		this.y = Math.min( this.y, v.y );
4214		this.z = Math.min( this.z, v.z );
4215
4216		return this;
4217
4218	}
4219
4220	max( v ) {
4221
4222		this.x = Math.max( this.x, v.x );
4223		this.y = Math.max( this.y, v.y );
4224		this.z = Math.max( this.z, v.z );
4225
4226		return this;
4227
4228	}
4229
4230	clamp( min, max ) {
4231
4232		// assumes min < max, componentwise
4233
4234		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
4235		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
4236		this.z = Math.max( min.z, Math.min( max.z, this.z ) );
4237
4238		return this;
4239
4240	}
4241
4242	clampScalar( minVal, maxVal ) {
4243
4244		this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
4245		this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
4246		this.z = Math.max( minVal, Math.min( maxVal, this.z ) );
4247
4248		return this;
4249
4250	}
4251
4252	clampLength( min, max ) {
4253
4254		const length = this.length();
4255
4256		return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
4257
4258	}
4259
4260	floor() {
4261
4262		this.x = Math.floor( this.x );
4263		this.y = Math.floor( this.y );
4264		this.z = Math.floor( this.z );
4265
4266		return this;
4267
4268	}
4269
4270	ceil() {
4271
4272		this.x = Math.ceil( this.x );
4273		this.y = Math.ceil( this.y );
4274		this.z = Math.ceil( this.z );
4275
4276		return this;
4277
4278	}
4279
4280	round() {
4281
4282		this.x = Math.round( this.x );
4283		this.y = Math.round( this.y );
4284		this.z = Math.round( this.z );
4285
4286		return this;
4287
4288	}
4289
4290	roundToZero() {
4291
4292		this.x = Math.trunc( this.x );
4293		this.y = Math.trunc( this.y );
4294		this.z = Math.trunc( this.z );
4295
4296		return this;
4297
4298	}
4299
4300	negate() {
4301
4302		this.x = - this.x;
4303		this.y = - this.y;
4304		this.z = - this.z;
4305
4306		return this;
4307
4308	}
4309
4310	dot( v ) {
4311
4312		return this.x * v.x + this.y * v.y + this.z * v.z;
4313
4314	}
4315
4316	// TODO lengthSquared?
4317
4318	lengthSq() {
4319
4320		return this.x * this.x + this.y * this.y + this.z * this.z;
4321
4322	}
4323
4324	length() {
4325
4326		return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );
4327
4328	}
4329
4330	manhattanLength() {
4331
4332		return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z );
4333
4334	}
4335
4336	normalize() {
4337
4338		return this.divideScalar( this.length() || 1 );
4339
4340	}
4341
4342	setLength( length ) {
4343
4344		return this.normalize().multiplyScalar( length );
4345
4346	}
4347
4348	lerp( v, alpha ) {
4349
4350		this.x += ( v.x - this.x ) * alpha;
4351		this.y += ( v.y - this.y ) * alpha;
4352		this.z += ( v.z - this.z ) * alpha;
4353
4354		return this;
4355
4356	}
4357
4358	lerpVectors( v1, v2, alpha ) {
4359
4360		this.x = v1.x + ( v2.x - v1.x ) * alpha;
4361		this.y = v1.y + ( v2.y - v1.y ) * alpha;
4362		this.z = v1.z + ( v2.z - v1.z ) * alpha;
4363
4364		return this;
4365
4366	}
4367
4368	cross( v ) {
4369
4370		return this.crossVectors( this, v );
4371
4372	}
4373
4374	crossVectors( a, b ) {
4375
4376		const ax = a.x, ay = a.y, az = a.z;
4377		const bx = b.x, by = b.y, bz = b.z;
4378
4379		this.x = ay * bz - az * by;
4380		this.y = az * bx - ax * bz;
4381		this.z = ax * by - ay * bx;
4382
4383		return this;
4384
4385	}
4386
4387	projectOnVector( v ) {
4388
4389		const denominator = v.lengthSq();
4390
4391		if ( denominator === 0 ) return this.set( 0, 0, 0 );
4392
4393		const scalar = v.dot( this ) / denominator;
4394
4395		return this.copy( v ).multiplyScalar( scalar );
4396
4397	}
4398
4399	projectOnPlane( planeNormal ) {
4400
4401		_vector$c.copy( this ).projectOnVector( planeNormal );
4402
4403		return this.sub( _vector$c );
4404
4405	}
4406
4407	reflect( normal ) {
4408
4409		// reflect incident vector off plane orthogonal to normal
4410		// normal is assumed to have unit length
4411
4412		return this.sub( _vector$c.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) );
4413
4414	}
4415
4416	angleTo( v ) {
4417
4418		const denominator = Math.sqrt( this.lengthSq() * v.lengthSq() );
4419
4420		if ( denominator === 0 ) return Math.PI / 2;
4421
4422		const theta = this.dot( v ) / denominator;
4423
4424		// clamp, to handle numerical problems
4425
4426		return Math.acos( clamp( theta, - 1, 1 ) );
4427
4428	}
4429
4430	distanceTo( v ) {
4431
4432		return Math.sqrt( this.distanceToSquared( v ) );
4433
4434	}
4435
4436	distanceToSquared( v ) {
4437
4438		const dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
4439
4440		return dx * dx + dy * dy + dz * dz;
4441
4442	}
4443
4444	manhattanDistanceTo( v ) {
4445
4446		return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y ) + Math.abs( this.z - v.z );
4447
4448	}
4449
4450	setFromSpherical( s ) {
4451
4452		return this.setFromSphericalCoords( s.radius, s.phi, s.theta );
4453
4454	}
4455
4456	setFromSphericalCoords( radius, phi, theta ) {
4457
4458		const sinPhiRadius = Math.sin( phi ) * radius;
4459
4460		this.x = sinPhiRadius * Math.sin( theta );
4461		this.y = Math.cos( phi ) * radius;
4462		this.z = sinPhiRadius * Math.cos( theta );
4463
4464		return this;
4465
4466	}
4467
4468	setFromCylindrical( c ) {
4469
4470		return this.setFromCylindricalCoords( c.radius, c.theta, c.y );
4471
4472	}
4473
4474	setFromCylindricalCoords( radius, theta, y ) {
4475