https://inchbyinch.ru/local/templates/inch/js/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

1519const TYPED_ARRAYS = {
1520	Int8Array: Int8Array,
1521	Uint8Array: Uint8Array,
1522	Uint8ClampedArray: Uint8ClampedArray,
1523	Int16Array: Int16Array,
1524	Uint16Array: Uint16Array,
1525	Int32Array: Int32Array,
1526	Uint32Array: Uint32Array,
1527	Float32Array: Float32Array,
1528	Float64Array: Float64Array
1529};
1530
1531function getTypedArray( type, buffer ) {
1532
1533	return new TYPED_ARRAYS[ type ]( buffer );
1534
1535}
1536
1537function createElementNS( name ) {
1538
1539	return document.createElementNS( 'http://www.w3.org/1999/xhtml', name );
1540
1541}
1542
1543function createCanvasElement() {
1544
1545	const canvas = createElementNS( 'canvas' );
1546	canvas.style.display = 'block';
1547	return canvas;
1548
1549}
1550
1551const _cache = {};
1552
1553function warnOnce( message ) {
1554
1555	if ( message in _cache ) return;
1556
1557	_cache[ message ] = true;
1558
1559	console.warn( message );
1560
1561}
1562
1563/**
1564 * Matrices converting P3 <-> Rec. 709 primaries, without gamut mapping
1565 * or clipping. Based on W3C specifications for sRGB and Display P3,
1566 * and ICC specifications for the D50 connection space. Values in/out
1567 * are _linear_ sRGB and _linear_ Display P3.
1568 *
1569 * Note that both sRGB and Display P3 use the sRGB transfer functions.
1570 *
1571 * Reference:
1572 * - http://www.russellcottrell.com/photo/matrixCalculator.htm
1573 */
1574
1575const LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 = /*@__PURE__*/ new Matrix3().set(
1576	0.8224621, 0.177538, 0.0,
1577	0.0331941, 0.9668058, 0.0,
1578	0.0170827, 0.0723974, 0.9105199,
1579);
1580
1581const LINEAR_DISPLAY_P3_TO_LINEAR_SRGB = /*@__PURE__*/ new Matrix3().set(
1582	1.2249401, - 0.2249404, 0.0,
1583	- 0.0420569, 1.0420571, 0.0,
1584	- 0.0196376, - 0.0786361, 1.0982735
1585);
1586
1587/**
1588 * Defines supported color spaces by transfer function and primaries,
1589 * and provides conversions to/from the Linear-sRGB reference space.
1590 */
1591const COLOR_SPACES = {
1592	[ LinearSRGBColorSpace ]: {
1593		transfer: LinearTransfer,
1594		primaries: Rec709Primaries,
1595		toReference: ( color ) => color,
1596		fromReference: ( color ) => color,
1597	},
1598	[ SRGBColorSpace ]: {
1599		transfer: SRGBTransfer,
1600		primaries: Rec709Primaries,
1601		toReference: ( color ) => color.convertSRGBToLinear(),
1602		fromReference: ( color ) => color.convertLinearToSRGB(),
1603	},
1604	[ LinearDisplayP3ColorSpace ]: {
1605		transfer: LinearTransfer,
1606		primaries: P3Primaries,
1607		toReference: ( color ) => color.applyMatrix3( LINEAR_DISPLAY_P3_TO_LINEAR_SRGB ),
1608		fromReference: ( color ) => color.applyMatrix3( LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 ),
1609	},
1610	[ DisplayP3ColorSpace ]: {
1611		transfer: SRGBTransfer,
1612		primaries: P3Primaries,
1613		toReference: ( color ) => color.convertSRGBToLinear().applyMatrix3( LINEAR_DISPLAY_P3_TO_LINEAR_SRGB ),
1614		fromReference: ( color ) => color.applyMatrix3( LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 ).convertLinearToSRGB(),
1615	},
1616};
1617
1618const SUPPORTED_WORKING_COLOR_SPACES = new Set( [ LinearSRGBColorSpace, LinearDisplayP3ColorSpace ] );
1619
1620const ColorManagement = {
1621
1622	enabled: true,
1623
1624	_workingColorSpace: LinearSRGBColorSpace,
1625
1626	get workingColorSpace() {
1627
1628		return this._workingColorSpace;
1629
1630	},
1631
1632	set workingColorSpace( colorSpace ) {
1633
1634		if ( ! SUPPORTED_WORKING_COLOR_SPACES.has( colorSpace ) ) {
1635
1636			throw new Error( `Unsupported working color space, "${ colorSpace }".` );
1637
1638		}
1639
1640		this._workingColorSpace = colorSpace;
1641
1642	},
1643
1644	convert: function ( color, sourceColorSpace, targetColorSpace ) {
1645
1646		if ( this.enabled === false || sourceColorSpace === targetColorSpace || ! sourceColorSpace || ! targetColorSpace ) {
1647
1648			return color;
1649
1650		}
1651
1652		const sourceToReference = COLOR_SPACES[ sourceColorSpace ].toReference;
1653		const targetFromReference = COLOR_SPACES[ targetColorSpace ].fromReference;
1654
1655		return targetFromReference( sourceToReference( color ) );
1656
1657	},
1658
1659	fromWorkingColorSpace: function ( color, targetColorSpace ) {
1660
1661		return this.convert( color, this._workingColorSpace, targetColorSpace );
1662
1663	},
1664
1665	toWorkingColorSpace: function ( color, sourceColorSpace ) {
1666
1667		return this.convert( color, sourceColorSpace, this._workingColorSpace );
1668
1669	},
1670
1671	getPrimaries: function ( colorSpace ) {
1672
1673		return COLOR_SPACES[ colorSpace ].primaries;
1674
1675	},
1676
1677	getTransfer: function ( colorSpace ) {
1678
1679		if ( colorSpace === NoColorSpace ) return LinearTransfer;
1680
1681		return COLOR_SPACES[ colorSpace ].transfer;
1682
1683	},
1684
1685};
1686
1687
1688function SRGBToLinear( c ) {
1689
1690	return ( c < 0.04045 ) ? c * 0.0773993808 : Math.pow( c * 0.9478672986 + 0.0521327014, 2.4 );
1691
1692}
1693
1694function LinearToSRGB( c ) {
1695
1696	return ( c < 0.0031308 ) ? c * 12.92 : 1.055 * ( Math.pow( c, 0.41666 ) ) - 0.055;
1697
1698}
1699
1700let _canvas;
1701
1702class ImageUtils {
1703
1704	static getDataURL( image ) {
1705
1706		if ( /^data:/i.test( image.src ) ) {
1707
1708			return image.src;
1709
1710		}
1711
1712		if ( typeof HTMLCanvasElement === 'undefined' ) {
1713
1714			return image.src;
1715
1716		}
1717
1718		let canvas;
1719
1720		if ( image instanceof HTMLCanvasElement ) {
1721
1722			canvas = image;
1723
1724		} else {
1725
1726			if ( _canvas === undefined ) _canvas = createElementNS( 'canvas' );
1727
1728			_canvas.width = image.width;
1729			_canvas.height = image.height;
1730
1731			const context = _canvas.getContext( '2d' );
1732
1733			if ( image instanceof ImageData ) {
1734
1735				context.putImageData( image, 0, 0 );
1736
1737			} else {
1738
1739				context.drawImage( image, 0, 0, image.width, image.height );
1740
1741			}
1742
1743			canvas = _canvas;
1744
1745		}
1746
1747		if ( canvas.width > 2048 || canvas.height > 2048 ) {
1748
1749			console.warn( 'THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons', image );
1750
1751			return canvas.toDataURL( 'image/jpeg', 0.6 );
1752
1753		} else {
1754
1755			return canvas.toDataURL( 'image/png' );
1756
1757		}
1758
1759	}
1760
1761	static sRGBToLinear( image ) {
1762
1763		if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
1764			( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
1765			( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {
1766
1767			const canvas = createElementNS( 'canvas' );
1768
1769			canvas.width = image.width;
1770			canvas.height = image.height;
1771
1772			const context = canvas.getContext( '2d' );
1773			context.drawImage( image, 0, 0, image.width, image.height );
1774
1775			const imageData = context.getImageData( 0, 0, image.width, image.height );
1776			const data = imageData.data;
1777
1778			for ( let i = 0; i < data.length; i ++ ) {
1779
1780				data[ i ] = SRGBToLinear( data[ i ] / 255 ) * 255;
1781
1782			}
1783
1784			context.putImageData( imageData, 0, 0 );
1785
1786			return canvas;
1787
1788		} else if ( image.data ) {
1789
1790			const data = image.data.slice( 0 );
1791
1792			for ( let i = 0; i < data.length; i ++ ) {
1793
1794				if ( data instanceof Uint8Array || data instanceof Uint8ClampedArray ) {
1795
1796					data[ i ] = Math.floor( SRGBToLinear( data[ i ] / 255 ) * 255 );
1797
1798				} else {
1799
1800					// assuming float
1801
1802					data[ i ] = SRGBToLinear( data[ i ] );
1803
1804				}
1805
1806			}
1807
1808			return {
1809				data: data,
1810				width: image.width,
1811				height: image.height
1812			};
1813
1814		} else {
1815
1816			console.warn( 'THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied.' );
1817			return image;
1818
1819		}
1820
1821	}
1822
1823}
1824
1825let _sourceId = 0;
1826
1827class Source {
1828
1829	constructor( data = null ) {
1830
1831		this.isSource = true;
1832
1833		Object.defineProperty( this, 'id', { value: _sourceId ++ } );
1834
1835		this.uuid = generateUUID();
1836
1837		this.data = data;
1838		this.dataReady = true;
1839
1840		this.version = 0;
1841
1842	}
1843
1844	set needsUpdate( value ) {
1845
1846		if ( value === true ) this.version ++;
1847
1848	}
1849
1850	toJSON( meta ) {
1851
1852		const isRootObject = ( meta === undefined || typeof meta === 'string' );
1853
1854		if ( ! isRootObject && meta.images[ this.uuid ] !== undefined ) {
1855
1856			return meta.images[ this.uuid ];
1857
1858		}
1859
1860		const output = {
1861			uuid: this.uuid,
1862			url: ''
1863		};
1864
1865		const data = this.data;
1866
1867		if ( data !== null ) {
1868
1869			let url;
1870
1871			if ( Array.isArray( data ) ) {
1872
1873				// cube texture
1874
1875				url = [];
1876
1877				for ( let i = 0, l = data.length; i < l; i ++ ) {
1878
1879					if ( data[ i ].isDataTexture ) {
1880
1881						url.push( serializeImage( data[ i ].image ) );
1882
1883					} else {
1884
1885						url.push( serializeImage( data[ i ] ) );
1886
1887					}
1888
1889				}
1890
1891			} else {
1892
1893				// texture
1894
1895				url = serializeImage( data );
1896
1897			}
1898
1899			output.url = url;
1900
1901		}
1902
1903		if ( ! isRootObject ) {
1904
1905			meta.images[ this.uuid ] = output;
1906
1907		}
1908
1909		return output;
1910
1911	}
1912
1913}
1914
1915function serializeImage( image ) {
1916
1917	if ( ( typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement ) ||
1918		( typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement ) ||
1919		( typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap ) ) {
1920
1921		// default images
1922
1923		return ImageUtils.getDataURL( image );
1924
1925	} else {
1926
1927		if ( image.data ) {
1928
1929			// images of DataTexture
1930
1931			return {
1932				data: Array.from( image.data ),
1933				width: image.width,
1934				height: image.height,
1935				type: image.data.constructor.name
1936			};
1937
1938		} else {
1939
1940			console.warn( 'THREE.Texture: Unable to serialize Texture.' );
1941			return {};
1942
1943		}
1944
1945	}
1946
1947}
1948
1949let _textureId = 0;
1950
1951class Texture extends EventDispatcher {
1952
1953	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 ) {
1954
1955		super();
1956
1957		this.isTexture = true;
1958
1959		Object.defineProperty( this, 'id', { value: _textureId ++ } );
1960
1961		this.uuid = generateUUID();
1962
1963		this.name = '';
1964
1965		this.source = new Source( image );
1966		this.mipmaps = [];
1967
1968		this.mapping = mapping;
1969		this.channel = 0;
1970
1971		this.wrapS = wrapS;
1972		this.wrapT = wrapT;
1973
1974		this.magFilter = magFilter;
1975		this.minFilter = minFilter;
1976
1977		this.anisotropy = anisotropy;
1978
1979		this.format = format;
1980		this.internalFormat = null;
1981		this.type = type;
1982
1983		this.offset = new Vector2( 0, 0 );
1984		this.repeat = new Vector2( 1, 1 );
1985		this.center = new Vector2( 0, 0 );
1986		this.rotation = 0;
1987
1988		this.matrixAutoUpdate = true;
1989		this.matrix = new Matrix3();
1990
1991		this.generateMipmaps = true;
1992		this.premultiplyAlpha = false;
1993		this.flipY = true;
1994		this.unpackAlignment = 4;	// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
1995
1996		this.colorSpace = colorSpace;
1997
1998		this.userData = {};
1999
2000		this.version = 0;
2001		this.onUpdate = null;
2002
2003		this.isRenderTargetTexture = false; // indicates whether a texture belongs to a render target or not
2004		this.pmremVersion = 0; // indicates whether this texture should be processed by PMREMGenerator or not (only relevant for render target textures)
2005
2006	}
2007
2008	get image() {
2009
2010		return this.source.data;
2011
2012	}
2013
2014	set image( value = null ) {
2015
2016		this.source.data = value;
2017
2018	}
2019
2020	updateMatrix() {
2021
2022		this.matrix.setUvTransform( this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y );
2023
2024	}
2025
2026	clone() {
2027
2028		return new this.constructor().copy( this );
2029
2030	}
2031
2032	copy( source ) {
2033
2034		this.name = source.name;
2035
2036		this.source = source.source;
2037		this.mipmaps = source.mipmaps.slice( 0 );
2038
2039		this.mapping = source.mapping;
2040		this.channel = source.channel;
2041
2042		this.wrapS = source.wrapS;
2043		this.wrapT = source.wrapT;
2044
2045		this.magFilter = source.magFilter;
2046		this.minFilter = source.minFilter;
2047
2048		this.anisotropy = source.anisotropy;
2049
2050		this.format = source.format;
2051		this.internalFormat = source.internalFormat;
2052		this.type = source.type;
2053
2054		this.offset.copy( source.offset );
2055		this.repeat.copy( source.repeat );
2056		this.center.copy( source.center );
2057		this.rotation = source.rotation;
2058
2059		this.matrixAutoUpdate = source.matrixAutoUpdate;
2060		this.matrix.copy( source.matrix );
2061
2062		this.generateMipmaps = source.generateMipmaps;
2063		this.premultiplyAlpha = source.premultiplyAlpha;
2064		this.flipY = source.flipY;
2065		this.unpackAlignment = source.unpackAlignment;
2066		this.colorSpace = source.colorSpace;
2067
2068		this.userData = JSON.parse( JSON.stringify( source.userData ) );
2069
2070		this.needsUpdate = true;
2071
2072		return this;
2073
2074	}
2075
2076	toJSON( meta ) {
2077
2078		const isRootObject = ( meta === undefined || typeof meta === 'string' );
2079
2080		if ( ! isRootObject && meta.textures[ this.uuid ] !== undefined ) {
2081
2082			return meta.textures[ this.uuid ];
2083
2084		}
2085
2086		const output = {
2087
2088			metadata: {
2089				version: 4.6,
2090				type: 'Texture',
2091				generator: 'Texture.toJSON'
2092			},
2093
2094			uuid: this.uuid,
2095			name: this.name,
2096
2097			image: this.source.toJSON( meta ).uuid,
2098
2099			mapping: this.mapping,
2100			channel: this.channel,
2101
2102			repeat: [ this.repeat.x, this.repeat.y ],
2103			offset: [ this.offset.x, this.offset.y ],
2104			center: [ this.center.x, this.center.y ],
2105			rotation: this.rotation,
2106
2107			wrap: [ this.wrapS, this.wrapT ],
2108
2109			format: this.format,
2110			internalFormat: this.internalFormat,
2111			type: this.type,
2112			colorSpace: this.colorSpace,
2113
2114			minFilter: this.minFilter,
2115			magFilter: this.magFilter,
2116			anisotropy: this.anisotropy,
2117
2118			flipY: this.flipY,
2119
2120			generateMipmaps: this.generateMipmaps,
2121			premultiplyAlpha: this.premultiplyAlpha,
2122			unpackAlignment: this.unpackAlignment
2123
2124		};
2125
2126		if ( Object.keys( this.userData ).length > 0 ) output.userData = this.userData;
2127
2128		if ( ! isRootObject ) {
2129
2130			meta.textures[ this.uuid ] = output;
2131
2132		}
2133
2134		return output;
2135
2136	}
2137
2138	dispose() {
2139
2140		this.dispatchEvent( { type: 'dispose' } );
2141
2142	}
2143
2144	transformUv( uv ) {
2145
2146		if ( this.mapping !== UVMapping ) return uv;
2147
2148		uv.applyMatrix3( this.matrix );
2149
2150		if ( uv.x < 0 || uv.x > 1 ) {
2151
2152			switch ( this.wrapS ) {
2153
2154				case RepeatWrapping:
2155
2156					uv.x = uv.x - Math.floor( uv.x );
2157					break;
2158

2159				case ClampToEdgeWrapping:
2160
2161					uv.x = uv.x < 0 ? 0 : 1;
2162					break;
2163
2164				case MirroredRepeatWrapping:
2165
2166					if ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) {
2167
2168						uv.x = Math.ceil( uv.x ) - uv.x;
2169
2170					} else {
2171
2172						uv.x = uv.x - Math.floor( uv.x );
2173
2174					}
2175
2176					break;
2177
2178			}
2179
2180		}
2181
2182		if ( uv.y < 0 || uv.y > 1 ) {
2183
2184			switch ( this.wrapT ) {
2185
2186				case RepeatWrapping:
2187
2188					uv.y = uv.y - Math.floor( uv.y );
2189					break;
2190
2191				case ClampToEdgeWrapping:
2192
2193					uv.y = uv.y < 0 ? 0 : 1;
2194					break;
2195
2196				case MirroredRepeatWrapping:
2197
2198					if ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) {
2199
2200						uv.y = Math.ceil( uv.y ) - uv.y;
2201
2202					} else {
2203
2204						uv.y = uv.y - Math.floor( uv.y );
2205
2206					}
2207
2208					break;
2209
2210			}
2211
2212		}
2213
2214		if ( this.flipY ) {
2215
2216			uv.y = 1 - uv.y;
2217
2218		}
2219
2220		return uv;
2221
2222	}
2223
2224	set needsUpdate( value ) {
2225
2226		if ( value === true ) {
2227
2228			this.version ++;
2229			this.source.needsUpdate = true;
2230
2231		}
2232
2233	}
2234
2235	set needsPMREMUpdate( value ) {
2236
2237		if ( value === true ) {
2238
2239			this.pmremVersion ++

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