https://rorybowcott.com/vendor/three/three.module.js

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

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

10061, 1 ) );
1007
1008	}
1009
1010	distanceTo( v ) {
1011
1012		return Math.sqrt( this.distanceToSquared( v ) );
1013
1014	}
1015
1016	distanceToSquared( v ) {
1017
1018		const dx = this.x - v.x, dy = this.y - v.y;
1019		return dx * dx + dy * dy;
1020
1021	}
1022
1023	manhattanDistanceTo( v ) {
1024
1025		return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y );
1026
1027	}
1028
1029	setLength( length ) {
1030
1031		return this.normalize().multiplyScalar( length );
1032
1033	}
1034
1035	lerp( v, alpha ) {
1036
1037		this.x += ( v.x - this.x ) * alpha;
1038		this.y += ( v.y - this.y ) * alpha;
1039
1040		return this;
1041
1042	}
1043
1044	lerpVectors( v1, v2, alpha ) {
1045
1046		this.x = v1.x + ( v2.x - v1.x ) * alpha;
1047		this.y = v1.y + ( v2.y - v1.y ) * alpha;
1048
1049		return this;
1050
1051	}
1052
1053	equals( v ) {
1054
1055		return ( ( v.x === this.x ) && ( v.y === this.y ) );
1056
1057	}
1058
1059	fromArray( array, offset = 0 ) {
1060
1061		this.x = array[ offset ];
1062		this.y = array[ offset + 1 ];
1063
1064		return this;
1065
1066	}
1067
1068	toArray( array = [], offset = 0 ) {
1069
1070		array[ offset ] = this.x;
1071		array[ offset + 1 ] = this.y;
1072
1073		return array;
1074
1075	}
1076
1077	fromBufferAttribute( attribute, index ) {
1078
1079		this.x = attribute.getX( index );
1080		this.y = attribute.getY( index );
1081
1082		return this;
1083
1084	}
1085
1086	rotateAround( center, angle ) {
1087
1088		const c = Math.cos( angle ), s = Math.sin( angle );
1089
1090		const x = this.x - center.x;
1091		const y = this.y - center.y;
1092
1093		this.x = x * c - y * s + center.x;
1094		this.y = x * s + y * c + center.y;
1095
1096		return this;
1097
1098	}
1099
1100	random() {
1101
1102		this.x = Math.random();
1103		this.y = Math.random();
1104
1105		return this;
1106
1107	}
1108
1109	*[ Symbol.iterator ]() {
1110
1111		yield this.x;
1112		yield this.y;
1113
1114	}
1115
1116}
1117
1118class Matrix3 {
1119
1120	constructor( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {
1121
1122		Matrix3.prototype.isMatrix3 = true;
1123
1124		this.elements = [
1125
1126			1, 0, 0,
1127			0, 1, 0,
1128			0, 0, 1
1129
1130		];
1131
1132		if ( n11 !== undefined ) {
1133
1134			this.set( n11, n12, n13, n21, n22, n23, n31, n32, n33 );
1135
1136		}
1137
1138	}
1139
1140	set( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {
1141
1142		const te = this.elements;
1143
1144		te[ 0 ] = n11; te[ 1 ] = n21; te[ 2 ] = n31;
1145		te[ 3 ] = n12; te[ 4 ] = n22; te[ 5 ] = n32;
1146		te[ 6 ] = n13; te[ 7 ] = n23; te[ 8 ] = n33;
1147
1148		return this;
1149
1150	}
1151
1152	identity() {
1153
1154		this.set(
1155
1156			1, 0, 0,
1157			0, 1, 0,
1158			0, 0, 1
1159
1160		);
1161
1162		return this;
1163
1164	}
1165
1166	copy( m ) {
1167
1168		const te = this.elements;
1169		const me = m.elements;
1170
1171		te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ];
1172		te[ 3 ] = me[ 3 ]; te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ];
1173		te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; te[ 8 ] = me[ 8 ];
1174
1175		return this;
1176
1177	}
1178
1179	extractBasis( xAxis, yAxis, zAxis ) {
1180
1181		xAxis.setFromMatrix3Column( this, 0 );
1182		yAxis.setFromMatrix3Column( this, 1 );
1183		zAxis.setFromMatrix3Column( this, 2 );
1184
1185		return this;
1186
1187	}
1188
1189	setFromMatrix4( m ) {
1190
1191		const me = m.elements;
1192
1193		this.set(
1194
1195			me[ 0 ], me[ 4 ], me[ 8 ],
1196			me[ 1 ], me[ 5 ], me[ 9 ],
1197			me[ 2 ], me[ 6 ], me[ 10 ]
1198
1199		);
1200
1201		return this;
1202
1203	}
1204
1205	multiply( m ) {
1206
1207		return this.multiplyMatrices( this, m );
1208
1209	}
1210
1211	premultiply( m ) {
1212
1213		return this.multiplyMatrices( m, this );
1214
1215	}
1216
1217	multiplyMatrices( a, b ) {
1218
1219		const ae = a.elements;
1220		const be = b.elements;
1221		const te = this.elements;
1222
1223		const a11 = ae[ 0 ], a12 = ae[ 3 ], a13 = ae[ 6 ];
1224		const a21 = ae[ 1 ], a22 = ae[ 4 ], a23 = ae[ 7 ];
1225		const a31 = ae[ 2 ], a32 = ae[ 5 ], a33 = ae[ 8 ];
1226
1227		const b11 = be[ 0 ], b12 = be[ 3 ], b13 = be[ 6 ];
1228		const b21 = be[ 1 ], b22 = be[ 4 ], b23 = be[ 7 ];
1229		const b31 = be[ 2 ], b32 = be[ 5 ], b33 = be[ 8 ];
1230
1231		te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31;
1232		te[ 3 ] = a11 * b12 + a12 * b22 + a13 * b32;
1233		te[ 6 ] = a11 * b13 + a12 * b23 + a13 * b33;
1234
1235		te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31;
1236		te[ 4 ] = a21 * b12 + a22 * b22 + a23 * b32;
1237		te[ 7 ] = a21 * b13 + a22 * b23 + a23 * b33;
1238
1239		te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31;
1240		te[ 5 ] = a31 * b12 + a32 * b22 + a33 * b32;
1241		te[ 8 ] = a31 * b13 + a32 * b23 + a33 * b33;
1242
1243		return this;
1244
1245	}
1246
1247	multiplyScalar( s ) {
1248
1249		const te = this.elements;
1250
1251		te[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s;
1252		te[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s;
1253		te[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s;
1254
1255		return this;
1256
1257	}
1258
1259	determinant() {
1260
1261		const te = this.elements;
1262
1263		const a = te[ 0 ], b = te[ 1 ], c = te[ 2 ],
1264			d = te[ 3 ], e = te[ 4 ], f = te[ 5 ],
1265			g = te[ 6 ], h = te[ 7 ], i = te[ 8 ];
1266
1267		return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;
1268
1269	}
1270
1271	invert() {
1272
1273		const te = this.elements,
1274
1275			n11 = te[ 0 ], n21 = te[ 1 ], n31 = te[ 2 ],
1276			n12 = te[ 3 ], n22 = te[ 4 ], n32 = te[ 5 ],
1277			n13 = te[ 6 ], n23 = te[ 7 ], n33 = te[ 8 ],
1278
1279			t11 = n33 * n22 - n32 * n23,
1280			t12 = n32 * n13 - n33 * n12,
1281			t13 = n23 * n12 - n22 * n13,
1282
1283			det = n11 * t11 + n21 * t12 + n31 * t13;
1284
1285		if ( det === 0 ) return this.set( 0, 0, 0, 0, 0, 0, 0, 0, 0 );
1286
1287		const detInv = 1 / det;
1288
1289		te[ 0 ] = t11 * detInv;
1290		te[ 1 ] = ( n31 * n23 - n33 * n21 ) * detInv;
1291		te[ 2 ] = ( n32 * n21 - n31 * n22 ) * detInv;
1292
1293		te[ 3 ] = t12 * detInv;
1294		te[ 4 ] = ( n33 * n11 - n31 * n13 ) * detInv;
1295		te[ 5 ] = ( n31 * n12 - n32 * n11 ) * detInv;
1296
1297		te[ 6 ] = t13 * detInv;
1298		te[ 7 ] = ( n21 * n13 - n23 * n11 ) * detInv;
1299		te[ 8 ] = ( n22 * n11 - n21 * n12 ) * detInv;
1300
1301		return this;
1302
1303	}
1304
1305	transpose() {
1306
1307		let tmp;
1308		const m = this.elements;
1309
1310		tmp = m[ 1 ]; m[ 1 ] = m[ 3 ]; m[ 3 ] = tmp;
1311		tmp = m[ 2 ]; m[ 2 ] = m[ 6 ]; m[ 6 ] = tmp;
1312		tmp = m[ 5 ]; m[ 5 ] = m[ 7 ]; m[ 7 ] = tmp;
1313
1314		return this;
1315
1316	}
1317
1318	getNormalMatrix( matrix4 ) {
1319
1320		return this.setFromMatrix4( matrix4 ).invert().transpose();
1321
1322	}
1323
1324	transposeIntoArray( r ) {
1325
1326		const m = this.elements;
1327
1328		r[ 0 ] = m[ 0 ];
1329		r[ 1 ] = m[ 3 ];
1330		r[ 2 ] = m[ 6 ];
1331		r[ 3 ] = m[ 1 ];
1332		r[ 4 ] = m[ 4 ];
1333		r[ 5 ] = m[ 7 ];
1334		r[ 6 ] = m[ 2 ];
1335		r[ 7 ] = m[ 5 ];
1336		r[ 8 ] = m[ 8 ];
1337
1338		return this;
1339
1340	}
1341
1342	setUvTransform( tx, ty, sx, sy, rotation, cx, cy ) {
1343
1344		const c = Math.cos( rotation );
1345		const s = Math.sin( rotation );
1346
1347		this.set(
1348			sx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx,
1349			- sy * s, sy * c, - sy * ( - s * cx + c * cy ) + cy + ty,
1350			0, 0, 1
1351		);
1352
1353		return this;
1354
1355	}
1356
1357	//
1358
1359	scale( sx, sy ) {
1360
1361		this.premultiply( _m3.makeScale( sx, sy ) );
1362
1363		return this;
1364
1365	}
1366
1367	rotate( theta ) {
1368
1369		this.premultiply( _m3.makeRotation( - theta ) );
1370
1371		return this;
1372
1373	}
1374
1375	translate( tx, ty ) {
1376
1377		this.premultiply( _m3.makeTranslation( tx, ty ) );
1378
1379		return this;
1380
1381	}
1382
1383	// for 2D Transforms
1384
1385	makeTranslation( x, y ) {
1386
1387		if ( x.isVector2 ) {
1388
1389			this.set(
1390
1391				1, 0, x.x,
1392				0, 1, x.y,
1393				0, 0, 1
1394
1395			);
1396
1397		} else {
1398
1399			this.set(
1400
1401				1, 0, x,
1402				0, 1, y,
1403				0, 0, 1
1404
1405			);
1406
1407		}
1408
1409		return this;
1410
1411	}
1412
1413	makeRotation( theta ) {
1414
1415		// counterclockwise
1416
1417		const c = Math.cos( theta );
1418		const s = Math.sin( theta );
1419
1420		this.set(
1421
1422			c, - s, 0,
1423			s, c, 0,
1424			0, 0, 1
1425
1426		);
1427
1428		return this;
1429
1430	}
1431
1432	makeScale( x, y ) {
1433
1434		this.set(
1435
1436			x, 0, 0,
1437			0, y, 0,
1438			0, 0, 1
1439
1440		);
1441
1442		return this;
1443
1444	}
1445
1446	//
1447
1448	equals( matrix ) {
1449
1450		const te = this.elements;
1451		const me = matrix.elements;
1452
1453		for ( let i = 0; i < 9; i ++ ) {
1454
1455			if ( te[ i ] !== me[ i ] ) return false;
1456
1457		}
1458
1459		return true;
1460
1461	}
1462
1463	fromArray( array, offset = 0 ) {
1464
1465		for ( let i = 0; i < 9; i ++ ) {
1466
1467			this.elements[ i ] = array[ i + offset ];
1468
1469		}
1470
1471		return this;
1472
1473	}
1474
1475	toArray( array = [], offset = 0 ) {
1476
1477		const te = this.elements;
1478
1479		array[ offset ] = te[ 0 ];
1480		array[ offset + 1 ] = te[ 1 ];
1481		array[ offset + 2 ] = te[ 2 ];
1482
1483		array[ offset + 3 ] = te[ 3 ];
1484		array[ offset + 4 ] = te[ 4 ];
1485		array[ offset + 5 ] = te[ 5 ];
1486
1487		array[ offset + 6 ] = te[ 6 ];
1488		array[ offset + 7 ] = te[ 7 ];
1489		array[ offset + 8 ] = te[ 8 ];
1490
1491		return array;
1492
1493	}
1494
1495	clone() {
1496
1497		return new this.constructor().fromArray( this.elements );
1498
1499	}
1500
1501}
1502
1503const _m3 = /*@__PURE__*/ new Matrix3();
1504
1505function arrayNeedsUint32( array ) {
1506
1507	// assumes larger values usually on last
1508
1509	for ( let i = array.length - 1; i >= 0; -- i ) {
1510
1511		if ( array[ i ] >= 65535 ) return true; // account for PRIMITIVE_RESTART_FIXED_INDEX, #24565
1512
1513	}
1514
1515	return false;
1516
1517}
1518

1628		transfer: SRGBTransfer,
1629		primaries: Rec709Primaries,
1630		toReference: ( color ) => color.convertSRGBToLinear(),
1631		fromReference: ( color ) => color.convertLinearToSRGB(),
1632	},
1633	[ LinearDisplayP3ColorSpace ]: {
1634		transfer: LinearTransfer,
1635		primaries: P3Primaries,
1636		toReference: ( color ) => color.applyMatrix3( LINEAR_DISPLAY_P3_TO_LINEAR_SRGB ),
1637		fromReference: ( color ) => color.applyMatrix3( LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 ),
1638	},
1639	[ DisplayP3ColorSpace ]: {
1640		transfer: SRGBTransfer,
1641		primaries: P3Primaries,
1642		toReference: ( color ) => color.convertSRGBToLinear().applyMatrix3( LINEAR_DISPLAY_P3_TO_LINEAR_SRGB ),
1643		fromReference: ( color ) => color.applyMatrix3( LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 ).convertLinearToSRGB(),
1644	},
1645};
1646
1647const SUPPORTED_WORKING_COLOR_SPACES = new Set( [ LinearSRGBColorSpace, LinearDisplayP3ColorSpace ] );
1648
1649const ColorManagement = {
1650
1651	enabled: true,
1652
1653	_workingColorSpace: LinearSRGBColorSpace,
1654
1655	get workingColorSpace() {
1656
1657		return this._workingColorSpace;
1658
1659	},
1660
1661	set workingColorSpace( colorSpace ) {
1662
1663		if ( ! SUPPORTED_WORKING_COLOR_SPACES.has( colorSpace ) ) {
1664
1665			throw new Error( `Unsupported working color space, "${ colorSpace }".` );
1666
1667		}
1668
1669		this._workingColorSpace = colorSpace;
1670
1671	},
1672
1673	convert: function ( color, sourceColorSpace, targetColorSpace ) {
1674
1675		if ( this.enabled === false || sourceColorSpace === targetColorSpace || ! sourceColorSpace || ! targetColorSpace ) {
1676
1677			return color;
1678
1679		}
1680
1681		const sourceToReference = COLOR_SPACES[ sourceColorSpace ].toReference;
1682		const targetFromReference = COLOR_SPACES[ targetColorSpace ].fromReference;
1683
1684		return targetFromReference( sourceToReference( color ) );
1685
1686	},
1687
1688	fromWorkingColorSpace: function ( color, targetColorSpace ) {
1689
1690		return this.convert( color, this._workingColorSpace, targetColorSpace );
1691
1692	},
1693
1694	toWorkingColorSpace: function ( color, sourceColorSpace ) {
1695
1696		return this.convert( color, sourceColorSpace, this._workingColorSpace );
1697
1698	},
1699
1700	getPrimaries: function ( colorSpace ) {
1701
1702		return COLOR_SPACES[ colorSpace ].primaries;
1703
1704	},
1705
1706	getTransfer: function ( colorSpace ) {
1707
1708		if ( colorSpace === NoColorSpace ) return LinearTransfer;
1709
1710		return COLOR_SPACES[ colorSpace ].transfer;
1711
1712	},
1713
1714};
1715
1716
1717function SRGBToLinear( c ) {
1718
1719	return ( c < 0.04045 ) ? c * 0.0773993808 : Math.pow( c * 0.9478672986 + 0.0521327014, 2.4 );
1720
1721}
1722
1723function LinearToSRGB( c ) {
1724
1725	return ( c < 0.0031308 ) ? c * 12.92 : 1.055 * ( Math.pow( c, 0.41666 ) ) - 0.055;
1726
1727}
1728
1729let _canvas;
1730
1731class ImageUtils {
1732
1733	static getDataURL( image ) {
1734
1735		if ( /^data:/i.test( image.src ) ) {
1736
1737			return image.src;
1738
1739		}
1740
1741		if ( typeof HTMLCanvasElement === 'undefined' ) {
1742
1743			return image.src;
1744
1745		}
1746
1747		let canvas;
1748
1749		if ( image instanceof HTMLCanvasElement ) {
1750
1751			canvas = image;
1752
1753		} else {
1754
1755			if ( _canvas === undefined ) _canvas = createElementNS( 'canvas' );
1756
1757			_canvas.width = image.width;
1758			_canvas.height = image.height;
1759
1760			const context = _canvas.getContext( '2d' );
1761
1762			if ( image instanceof ImageData ) {
1763
1764				context.putImageData( image, 0, 0 );
1765
1766			} else {
1767
1768				context.drawImage( image, 0, 0, image.width, image.height );
1769
1770			}
1771
1772			canvas = _canvas;
1773
1774		}
1775
1776		if ( canvas.width > 2048 || canvas.height > 2048 ) {
1777
1778			console.warn( 'THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons', image );
1779
1780			return canvas.toDataURL( 'image/jpeg', 0.6 );
1781
1782		} else {
1783
1784			return canvas.toDataURL( 'image/png' );
1785
1786		}
1787
1788	}
1789
1790	static sRGBToLinear( image ) {
1791
1792		if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
1793			( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
1794			( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {
1795
1796			const canvas = createElementNS( 'canvas' );
1797
1798			canvas.width = image.width;
1799			canvas.height = image.height;
1800
1801			const context = canvas.getContext( '2d' );
1802			context.drawImage( image, 0, 0, image.width, image.height );
1803
1804			const imageData = context.getImageData( 0, 0, image.width, image.height );
1805			const data = imageData.data;
1806
1807			for ( let i = 0; i < data.length; i ++ ) {
1808
1809				data[ i ] = SRGBToLinear( data[ i ] / 255 ) * 255;
1810
1811			}
1812
1813			context.putImageData( imageData, 0, 0 );
1814
1815			return canvas;
1816
1817		} else if ( image.data ) {
1818
1819			const data = image.data.slice( 0 );
1820
1821			for ( let i = 0; i < data.length; i ++ ) {
1822
1823				if ( data instanceof Uint8Array || data instanceof Uint8ClampedArray ) {
1824
1825					data[ i ] = Math.floor( SRGBToLinear( data[ i ] / 255 ) * 255 );
1826
1827				} else {
1828
1829					// assuming float
1830
1831					data[ i ] = SRGBToLinear( data[ i ] );
1832
1833				}
1834
1835			}
1836
1837			return {
1838				data: data,
1839				width: image.width,
1840				height: image.height
1841			};
1842
1843		} else {
1844
1845			console.warn( 'THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied.' );
1846			return image;
1847
1848		}
1849
1850	}
1851
1852}
1853
1854let _sourceId = 0;
1855
1856class Source {
1857
1858	constructor( data = null ) {
1859
1860		this.isSource = true;
1861
1862		Object.defineProperty( this, 'id', { value: _sourceId ++ } );
1863
1864		this.uuid = generateUUID();
1865
1866		this.data = data;
1867		this.dataReady = true;
1868
1869		this.version = 0;
1870
1871	}
1872
1873	set needsUpdate( value ) {
1874
1875		if ( value === true ) this.version ++;
1876
1877	}
1878
1879	toJSON( meta ) {
1880
1881		const isRootObject = ( meta === undefined || typeof meta === 'string' );
1882
1883		if ( ! isRootObject && meta.images[ this.uuid ] !== undefined ) {
1884
1885			return meta.images[ this.uuid ];
1886
1887		}
1888
1889		const output = {
1890			uuid: this.uuid,
1891			url: ''
1892		};
1893
1894		const data = this.data;
1895
1896		if ( data !== null ) {
1897
1898			let url;
1899
1900			if ( Array.isArray( data ) ) {
1901
1902				// cube texture
1903
1904				url = [];
1905
1906				for ( let i = 0, l = data.length; i < l; i ++ ) {
1907
1908					if ( data[ i ].isDataTexture ) {
1909
1910						url.push( serializeImage( data[ i ].image ) );
1911
1912					} else {
1913
1914						url.push( serializeImage( data[ i ] ) );
1915
1916					}
1917
1918				}
1919
1920			} else {
1921
1922				// texture
1923
1924				url = serializeImage( data );
1925
1926			}
1927
1928			output.url = url;
1929
1930		}
1931
1932		if ( ! isRootObject ) {
1933
1934			meta.images[ this.uuid ] = output;
1935
1936		}
1937
1938		return output;
1939
1940	}
1941
1942}
1943
1944function serializeImage( image ) {
1945
1946	if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
1947		( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
1948		( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {
1949
1950		// default images
1951
1952		return ImageUtils.getDataURL( image );
1953
1954	} else {
1955
1956		if ( image.data ) {
1957
1958			// images of DataTexture
1959
1960			return {
1961				data: Array.from( image.data ),
1962				width: image.width,
1963				height: image.height,
1964				type: image.data.constructor.name
1965			};
1966
1967		} else {
1968
1969			console.warn( 'THREE.Texture: Unable to serialize Texture.' );
1970			return {};
1971
1972		}
1973
1974	}
1975
1976}
1977
1978let _textureId = 0;
1979
1980class Texture extends EventDispatcher {
1981
1982	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 ) {
1983
1984		super();
1985
1986		this.isTexture = true;
1987
1988		Object.defineProperty( this, 'id', { value: _textureId ++ } );
1989
1990		this.uuid = generateUUID();
1991
1992		this.name = '';
1993
1994		this.source = new Source( image );
1995		this.mipmaps = [];
1996
1997		this.mapping = mapping;
1998		this.channel = 0;
1999
2000		this.wrapS = wrapS;
2001		this.wrapT = wrapT;
2002
2003		this.magFilter = magFilter;
2004		this.minFilter = minFilter;
2005
2006		this.anisotropy = anisotropy;
2007
2008		this.format = format;
2009		this.internalFormat = null;
2010		this.type = type;
2011
2012		this.offset = new Vector2( 0, 0 );
2013		this.repeat = new Vector2( 1, 1 );
2014		this.center = new Vector2( 0, 0 );
2015		this.rotation = 0;
2016
2017		this.matrixAutoUpdate = true;
2018		this.matrix = new Matrix3();
2019
2020		this.generateMipmaps = true;
2021		this.premultiplyAlpha = false;
2022		this.flipY = true;
2023		this.unpackAlignment = 4;	// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
2024
2025		this.colorSpace = colorSpace;
2026
2027		this.userData = {};
2028
2029		this.version = 0;
2030		this.onUpdate = null;
2031
2032		this.isRenderTargetTexture = false; // indicates whether a texture belongs to a render target or not
2033		this.pmremVersion = 0; // indicates whether this texture should be processed by PMREMGenerator or not (only relevant for render target textures)
2034
2035	}
2036
2037	get image() {
2038
2039		return this.source.data;
2040
2041	}
2042
2043	set image( value = null ) {
2044
2045		this.source.data = value;
2046
2047	}
2048
2049	updateMatrix() {
2050
2051		this.matrix.setUvTransform( this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y );
2052
2053	}
2054
2055	clone() {
2056
2057		return new this.constructor().copy( this );
2058
2059	}
2060
2061	copy( source ) {
2062
2063		this.name = source.name;
2064
2065		this.source = source.source;
2066		this.mipmaps = source.mipmaps.slice( 0 );
2067

2068		this.mapping = source.mapping;
2069		this.channel = source.channel;
2070
2071		this.wrapS = source.wrapS;
2072		this.wrapT = source.wrapT;
2073
2074		this.magFilter = source.magFilter;
2075		this.minFilter = source.minFilter;
2076
2077		this.anisotropy = source.anisotropy;
2078
2079		this.format = source.format;
2080		this.internalFormat = source.internalFormat;
2081		this.type = source.type;
2082
2083		this.offset.copy( source.offset );
2084		this.repeat.copy( source.repeat );
2085		this.center.copy( source.center );
2086		this.rotation = source.rotation;
2087
2088		this.matrixAutoUpdate = source.matrixAutoUpdate;
2089		this.matrix.copy( source.matrix );
2090
2091		this.generateMipmaps = source.generateMipmaps;
2092		this.premultiplyAlpha = source.premultiplyAlpha;
2093		this.flipY = source.flipY;
2094		this.unpackAlignment = source.unpackAlignment;
2095		this.colorSpace = source.colorSpace;
2096
2097		this.userData = JSON.parse( JSON.stringify( source.userData ) );
2098
2099		this.needsUpdate = true;
2100
2101		return this;
2102
2103	}
2104
2105	toJSON( meta ) {
2106
2107		const isRootObject = ( meta === undefined || typeof meta === 'string' );
2108
2109		if ( ! isRootObject && meta.textures[ this.uuid ] !== undefined ) {
2110
2111			return meta.textures[ this.uuid ];
2112
2113		}
2114
2115		const output = {
2116
2117			metadata: {
2118				version: 4.6,
2119				type: 'Texture',
2120				generator: 'Texture.toJSON'
2121			},
2122
2123			uuid: this.uuid,
2124			name: this.name,
2125
2126			image: this.source.toJSON( meta ).uuid,
2127
2128			mapping: this.mapping,
2129			channel: this.channel,
2130
2131			repeat: [ this.repeat.x, this.repeat.y ],
2132			offset: [ this.offset.x, this.offset.y ],
2133			center: [ this.center.x, this.center.y ],
2134			rotation: this.rotation,
2135
2136			wrap: [ this.wrapS, this.wrapT ],
2137
2138			format: this.format,
2139			internalFormat: this.internalFormat,
2140			type: this.type,
2141			colorSpace: this.colorSpace,
2142
2143			minFilter: this.minFilter,
2144			magFilter: this.magFilter,
2145			anisotropy: this.anisotropy,
2146
2147			flipY: this.flipY,
2148
2149			generateMipmaps: this.generateMipmaps,
2150			premultiplyAlpha: this.premultiplyAlpha,
2151			unpackAlignment: this.unpackAlignment
2152
2153		};
2154
2155		if ( Object.keys( this.userData ).length > 0 ) output.userData = this.userData;
2156
2157		if ( ! isRootObject ) {
2158
2159			meta.textures[ this.uuid ] = output;
2160
2161		}
2162
2163		return output;
2164
2165	}
2166
2167	dispose() {
2168
2169		this.dispatchEvent( { type: 'dispose' } );
2170
2171	}
2172
2173	transformUv( uv ) {
2174
2175		if ( this.mapping !== UVMapping ) return uv;
2176
2177		uv.applyMatrix3( this.matrix );
2178
2179		if ( uv.x < 0 || uv.x > 1 ) {
2180
2181			switch ( this.wrapS ) {
2182
2183				case RepeatWrapping:
2184
2185					uv.x = uv.x - Math.floor( uv.x );
2186					break;
2187
2188				case ClampToEdgeWrapping:
2189
2190					uv.x = uv.x < 0 ? 0 : 1;
2191					break;
2192
2193				case MirroredRepeatWrapping:
2194
2195					if ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) {
2196
2197						uv.x = Math.ceil( uv.x ) - uv.x;
2198
2199					} else {
2200
2201						uv.x = uv.x - Math.floor( uv.x );
2202
2203					}
2204
2205					break;
2206
2207			}
2208
2209		}
2210
2211		if ( uv.y < 0 || uv.y > 1 ) {
2212
2213			switch ( this.wrapT ) {
2214
2215				case RepeatWrapping:
2216
2217					uv.y = uv.y - Math.floor( uv.y );
2218					break;
2219
2220				case ClampToEdgeWrapping:
2221
2222					uv.y = uv.y < 0 ? 0 : 1;
2223					break;
2224
2225				case MirroredRepeatWrapping:
2226
2227					if ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) {
2228
2229						uv.y = Math.ceil( uv.y ) - uv.y;
2230
2231					} else {
2232
2233						uv.y = uv.y - Math.floor( uv.y );
2234
2235					}
2236
2237					break;
2238
2239			}
2240
2241		}
2242
2243		if ( this.flipY ) {
2244
2245			uv.y = 1 - uv.y;
2246
2247		}
2248
2249		return uv;
2250
2251	}
2252
2253	set needsUpdate( value ) {
2254
2255		if ( value === true ) {
2256
2257			this.version ++;
2258			this.source.needsUpdate = true;
2259
2260		}
2261
2262	}
2263
2264	set needsPMREMUpdate( value ) {
2265
2266		if ( value === true ) {
2267
2268			this.pmremVersion ++

2268;
2269
2270		}
2271
2272	}
2273
2274}
2275
2276Texture.DEFAULT_IMAGE = null;
2277Texture.DEFAULT_MAPPING = UVMapping;
2278Texture.DEFAULT_ANISOTROPY = 1;
2279
2280class Vector4 {
2281
2282	constructor( x = 0, y = 0, z = 0, w = 1 ) {
2283
2284		Vector4.prototype.isVector4 = true;
2285
2286		this.x = x;
2287		this.y = y;
2288		this.z = z;
2289		this.w = w;
2290
2291	}
2292
2293	get width() {
2294
2295		return this.z;
2296
2297	}
2298
2299	set width( value ) {
2300
2301		this.z = value;
2302
2303	}
2304
2305	get height() {
2306
2307		return this.w;
2308
2309	}
2310
2311	set height( value ) {
2312
2313		this.w = value;
2314
2315	}
2316
2317	set( x, y, z, w ) {
2318
2319		this.x = x;
2320		this.y = y;
2321		this.z = z;
2322		this.w = w;
2323
2324		return this;
2325
2326	}
2327
2328	setScalar( scalar ) {
2329
2330		this.x = scalar;
2331		this.y = scalar;
2332		this.z = scalar;
2333		this.w = scalar;
2334
2335		return this;
2336
2337	}
2338
2339	setX( x ) {
2340
2341		this.x = x;
2342
2343		return this;
2344
2345	}
2346
2347	setY( y ) {
2348
2349		this.y = y;
2350
2351		return this;
2352
2353	}
2354
2355	setZ( z ) {
2356
2357		this.z = z;
2358
2359		return this;
2360
2361	}
2362
2363	setW( w ) {
2364
2365		this.w = w;
2366
2367		return this;
2368
2369	}
2370
2371	setComponent( index, value ) {
2372
2373		switch ( index ) {
2374
2375			case 0: this.x = value; break;
2376			case 1: this.y = value; break;
2377			case 2: this.z = value; break;
2378			case 3: this.w = value; break;
2379			default: throw new Error( 'index is out of range: ' + index );
2380
2381		}
2382
2383		return this;
2384
2385	}
2386
2387	getComponent( index ) {
2388
2389		switch ( index ) {
2390
2391			case 0: return this.x;
2392			case 1: return this.y;
2393			case 2: return this.z;
2394			case 3: return this.w;
2395			default: throw new Error( 'index is out of range: ' + index );
2396
2397		}
2398
2399	}
2400
2401	clone() {
2402
2403		return new this.constructor( this.x, this.y, this.z, this.w );
2404
2405	}
2406
2407	copy( v ) {
2408
2409		this.x = v.x;
2410		this.y = v.y;
2411		this.z = v.z;
2412		this.w = ( v.w !== undefined ) ? v.w : 1;
2413
2414		return this;
2415
2416	}
2417
2418	add( v ) {
2419
2420		this.x += v.x;
2421		this.y += v.y;
2422		this.z += v.z;
2423		this.w += v.w;
2424
2425		return this;
2426
2427	}
2428
2429	addScalar( s ) {
2430
2431		this.x += s;
2432		this.y += s;
2433		this.z += s;
2434		this.w += s;
2435
2436		return this;
2437
2438	}
2439
2440	addVectors( a, b ) {
2441
2442		this.x = a.x + b.x;
2443		this.y = a.y + b.y;
2444		this.z = a.z + b.z;
2445		this.w = a.w + b.w;
2446
2447		return this;
2448
2449	}
2450
2451	addScaledVector( v, s ) {
2452
2453		this.x += v.x * s;
2454		this.y += v.y * s;
2455		this.z += v.z * s;
2456		this.w += v.w * s;
2457
2458		return this;
2459
2460	}
2461
2462	sub( v ) {
2463
2464		this.x -= v.x;
2465		this.y -= v.y;
2466		this.z -= v.z;
2467		this.w -= v.w;
2468
2469		return this;
2470
2471	}
2472
2473	subScalar( s ) {
2474
2475		this.x -= s;
2476		this.y -= s;
2477		this.z -= s;
2478		this.w -= s;
2479
2480		return this;
2481
2482	}
2483
2484	subVectors( a, b ) {
2485
2486		this.x = a.x - b.x;
2487		this.y = a.y - b.y;
2488		this.z = a.z - b.z;
2489		this.w = a.w - b.w;
2490
2491		return this;
2492
2493	}
2494
2495	multiply( v ) {
2496
2497		this.x *= v.x;
2498		this.y *= v.y;
2499		this.z *= v.z;
2500		this.w *= v.w;
2501
2502		return this;
2503
2504	}
2505
2506	multiplyScalar( scalar ) {
2507
2508		this.x *= scalar;
2509		this.y *= scalar;
2510		this.z *= scalar;
2511		this.w *= scalar;
2512
2513		return this;
2514
2515	}
2516
2517	applyMatrix4( m ) {
2518
2519		const x = this.x, y = this.y, z = this.z, w = this.w;
2520		const e = m.elements;
2521
2522		this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w;
2523		this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w;
2524		this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w;
2525		this.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w;
2526
2527		return this;
2528
2529	}
2530
2531	divideScalar( scalar ) {
2532
2533		return this.multiplyScalar( 1 / scalar );
2534
2535	}
2536
2537	setAxisAngleFromQuaternion( q ) {
2538
2539		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
2540
2541		// q is assumed to be normalized
2542
2543		this.w = 2 * Math.acos( q.w );
2544
2545		const s = Math.sqrt( 1 - q.w * q.w );
2546
2547		if ( s < 0.0001 ) {
2548
2549			this.x = 1;
2550			this.y = 0;
2551			this.z = 0;
2552
2553		} else {
2554
2555			this.x = q.x / s;
2556			this.y = q.y / s;
2557			this.z = q.z / s;
2558
2559		}
2560
2561		return this;
2562
2563	}
2564
2565	setAxisAngleFromRotationMatrix( m ) {
2566
2567		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm
2568
2569		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
2570
2571		let angle, x, y, z; // variables for result
2572		const epsilon = 0.01,		// margin to allow for rounding errors
2573			epsilon2 = 0.1,		// margin to distinguish between 0 and 180 degrees
2574
2575			te = m.elements,
2576
2577			m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
2578			m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
2579			m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];
2580
2581		if ( ( Math.abs( m12 - m21 ) < epsilon ) &&
2582		     ( Math.abs( m13 - m31 ) < epsilon ) &&
2583		     ( Math.abs( m23 - m32 ) < epsilon ) ) {
2584
2585			// singularity found
2586			// first check for identity matrix which must have +1 for all terms
2587			// in leading diagonal and zero in other terms
2588
2589			if ( ( Math.abs( m12 + m21 ) < epsilon2 ) &&
2590			     ( Math.abs( m13 + m31 ) < epsilon2 ) &&
2591			     ( Math.abs( m23 + m32 ) < epsilon2 ) &&
2592			     ( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) {
2593
2594				// this singularity is identity matrix so angle = 0
2595
2596				this.set( 1, 0, 0, 0 );
2597
2598				return this; // zero angle, arbitrary axis
2599
2600			}
2601
2602			// otherwise this singularity is angle = 180
2603
2604			angle = Math.PI;
2605
2606			const xx = ( m11 + 1 ) / 2;
2607			const yy = ( m22 + 1 ) / 2;
2608			const zz = ( m33 + 1 ) / 2;
2609			const xy = ( m12 + m21 ) / 4;
2610			const xz = ( m13 + m31 ) / 4;
2611			const yz = ( m23 + m32 ) / 4;
2612
2613			if ( ( xx > yy ) && ( xx > zz ) ) {
2614
2615				// m11 is the largest diagonal term
2616
2617				if ( xx < epsilon ) {
2618
2619					x = 0;
2620					y = 0.707106781;
2621					z = 0.707106781;
2622
2623				} else {
2624
2625					x = Math.sqrt( xx );
2626					y = xy / x;
2627					z = xz / x;
2628
2629				}
2630
2631			} else if ( yy > zz ) {
2632
2633				// m22 is the largest diagonal term
2634
2635				if ( yy < epsilon ) {
2636
2637					x = 0.707106781;
2638					y = 0;
2639					z = 0.707106781;
2640
2641				} else {
2642
2643					y = Math.sqrt( yy );
2644					x = xy / y;
2645					z = yz / y;
2646
2647				}
2648
2649			} else {
2650
2651				// m33 is the largest diagonal term so base result on this
2652
2653				if ( zz < epsilon ) {
2654
2655					x = 0.707106781;
2656					y = 0.707106781;
2657					z = 0;
2658
2659				} else {
2660
2661					z = Math.sqrt( zz );
2662					x = xz / z;
2663					y = yz / z;
2664
2665				}
2666
2667			}
2668
2669			this.set( x, y, z, angle );
2670
2671			return this; // return 180 deg rotation
2672
2673		}
2674
2675		// as we have reached here there are no singularities so we can handle normally
2676
2677		let s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) +
2678			( m13 - m31 ) * ( m13 - m31 ) +
2679			( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize
2680
2681		if ( Math.abs( s ) < 0.001 ) s = 1;
2682
2683		// prevent divide by zero, should not happen if matrix is orthogonal and should be
2684		// caught by singularity test above, but I've left it in just in case
2685
2686		this.x = ( m32 - m23 ) / s;
2687		this.y = ( m13 - m31 ) / s;
2688		this.z = ( m21 - m12 ) / s;
2689		this.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 );
2690
2691		return this;
2692
2693	}
2694
2695	min( v ) {
2696
2697		this.x = Math.min( this.x, v.x );
2698		this.y = Math.min( this.y, v.y );
2699		this.z = Math.min( this.z, v.z );
2700		this.w = Math.min( this.w, v.w );
2701
2702		return this;
2703
2704	}
2705
2706	max( v ) {
2707
2708		this.x = Math.max( this.x, v.x );
2709		this.y = Math.max( this.y, v.y );
2710		this.z = Math.max( this.z, v.z );
2711		this.w = Math.max( this.w, v.w );
2712
2713		return this;
2714
2715	}
2716
2717	clamp( min, max ) {
2718
2719		// assumes min < max, componentwise
2720
2721		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
2722		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
2723		this.z = Math.max( min.z, Math.min( max.z, this.z ) );
2724		this.w = Math.max( min.w, Math.min( max.w, this.w ) );
2725
2726		return this;
2727
2728	}
2729
2730	clampScalar( minVal, maxVal ) {
2731
2732		this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
2733		this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
2734		this.z = Math.max( minVal, Math.min( maxVal, this.z ) );
2735		this.w = Math.max( minVal, Math.min( maxVal, this.w ) );
2736
2737		return this;
2738
2739	}
2740
2741	clampLength( min, max ) {
2742
2743		const length = this.length();
2744
2745		return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
2746
2747	}
2748
2749	floor() {
2750
2751		this.x = Math.floor( this.x );
2752		this.y = Math.floor( this.y );
2753		this.z = Math.floor( this.z );
2754		this.w = Math.floor( this.w );
2755
2756		return this;
2757
2758	}
2759
2760	ceil() {
2761
2762		this.x = Math.ceil( this.x );
2763		this.y = Math.ceil( this.y );
2764		this.z = Math.ceil( this.z );
2765		this.w = Math.ceil( this.w );
2766
2767		return this;
2768
2769	}
2770
2771	round() {
2772
2773		this.x = Math.round( this.x );
2774		this.y = Math.round( this.y );
2775		this.z = Math.round( this.z );
2776		this.w = Math.round( this.w );
2777
2778		return this;
2779
2780	}
2781
2782	roundToZero() {
2783
2784		this.x = Math.trunc( this.x );
2785		this.y = Math.trunc( this.y );
2786		this.z = Math.trunc( this.z );
2787		this.w = Math.trunc( this.w );
2788
2789		return this;
2790
2791	}
2792
2793	negate() {
2794
2795		this.x = - this.x;
2796		this.y = - this.y;
2797		this.z = - this.z;
2798		this.w = - this.w;
2799
2800		return this;
2801
2802	}
2803
2804	dot( v ) {
2805
2806		return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
2807
2808	}
2809
2810	lengthSq() {
2811
2812		return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
2813
2814	}
2815
2816	length() {
2817
2818		return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w );
2819
2820	}
2821
2822	manhattanLength() {
2823
2824		return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w );
2825
2826	}
2827
2828	normalize() {
2829
2830		return this.divideScalar( this.length() || 1 );
2831
2832	}
2833
2834	setLength( length ) {
2835
2836		return this.normalize().multiplyScalar( length );
2837
2838	}
2839
2840	lerp( v, alpha ) {
2841
2842		this.x += ( v.x - this.x ) * alpha;
2843		this.y += ( v.y - this.y ) * alpha;
2844		this.z += ( v.z - this.z ) * alpha;
2845		this.w += ( v.w - this.w ) * alpha;
2846
2847		return this;
2848
2849	}
2850
2851	lerpVectors( v1, v2, alpha ) {
2852
2853		this.x = v1.x + ( v2.x - v1.x ) * alpha;
2854		this.y = v1.y + ( v2.y - v1.y ) * alpha;
2855		this.z = v1.z + ( v2.z - v1.z ) * alpha;
2856		this.w = v1.w + ( v2.w - v1.w ) * alpha;
2857
2858		return this;
2859
2860	}
2861
2862	equals( v ) {
2863
2864		return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) );
2865
2866	}
2867
2868	fromArray( array, offset = 0 ) {
2869
2870		this.x = array[ offset ];
2871		this.y = array[ offset + 1 ];
2872		this.z = array[ offset + 2 ];
2873		this.w = array[ offset + 3 ];
2874
2875		return this;
2876
2877	}
2878
2879	toArray( array = [], offset = 0 ) {
2880
2881		array[ offset ] = this.x;
2882		array[ offset + 1 ] = this.y;
2883		array[ offset + 2 ] = this.z;
2884		array[ offset + 3 ] = this.w;
2885
2886		return array;
2887
2888	}
2889
2890	fromBufferAttribute( attribute, index ) {
2891
2892		this.x = attribute.getX( index );
2893		this.y = attribute.getY( index );
2894		this.z = attribute.getZ( index );
2895		this.w = attribute.getW( index );
2896
2897		return this;
2898
2899	}
2900
2901	random() {
2902
2903		this.x = Math.random();
2904		this.y = Math.random();
2905		this.z = Math.random();
2906		this.w = Math.random();
2907
2908		return this;
2909
2910	}
2911
2912	*[ Symbol.iterator ]() {
2913
2914		yield this.x;
2915		yield this.y;
2916		yield this.z;
2917		yield this.w;
2918
2919	}
2920
2921}
2922
2923/*
2924 In options, we can specify:
2925 * Texture parameters for an auto-generated target texture
2926 * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers
2927*/
2928class RenderTarget extends EventDispatcher {
2929
2930	constructor( width = 1, height = 1, options = {} ) {
2931
2932		super();
2933
2934		this.isRenderTarget = true;
2935
2936		this.width = width;
2937		this.height = height;
2938		this.depth = 1;
2939
2940		this.scissor = new Vector4( 0, 0, width, height );
2941		this.scissorTest = false;
2942
2943		this.viewport = new Vector4( 0, 0, width, height );
2944
2945		const image = { width: width, height: height, depth: 1 };
2946
2947		options = Object.assign( {
2948			generateMipmaps: false,
2949			internalFormat: null,
2950			minFilter: LinearFilter,
2951			depthBuffer: true,
2952			stencilBuffer: false,
2953