https://www.stillmakingstuff.com/js/lib/three.module.js

140const SIGNED_RED_RGTC1_Format = 36284;
141const RED_GREEN_RGTC2_Format = 36285;
142const SIGNED_RED_GREEN_RGTC2_Format = 36286;
143const LoopOnce = 2200;
144const LoopRepeat = 2201;
145const LoopPingPong = 2202;
146const InterpolateDiscrete = 2300;
147const InterpolateLinear = 2301;
148const InterpolateSmooth = 2302;
149const ZeroCurvatureEnding = 2400;
150const ZeroSlopeEnding = 2401;
151const WrapAroundEnding = 2402;
152const NormalAnimationBlendMode = 2500;
153const AdditiveAnimationBlendMode = 2501;
154const TrianglesDrawMode = 0;
155const TriangleStripDrawMode = 1;
156const TriangleFanDrawMode = 2;
157/** @deprecated Use LinearSRGBColorSpace or NoColorSpace in three.js r152+. */
158const LinearEncoding = 3000;
159/** @deprecated Use SRGBColorSpace in three.js r152+. */
160const sRGBEncoding = 3001;
161const BasicDepthPacking = 3200;
162const RGBADepthPacking = 3201;
163const TangentSpaceNormalMap = 0;
164const ObjectSpaceNormalMap = 1;
165
166// Color space string identifiers, matching CSS Color Module Level 4 and WebGPU names 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, - 

10101, 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;

2258
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