https://www.eisk.cn/static/2017/js/three.module.js

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

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

836	divide(v) {
837
838		this.x /= v.x;
839		this.y /= v.y;
840
841		return this;
842
843	}
844
845	divideScalar(scalar) {
846
847		return this.multiplyScalar(1 / scalar);
848
849	}
850
851	applyMatrix3(m) {
852
853		const x = this.x, y = this.y;
854		const e = m.elements;
855
856		this.x = e[0] * x + e[3] * y + e[6];
857		this.y = e[1] * x + e[4] * y + e[7];
858
859		return this;
860
861	}
862
863	min(v) {
864
865		this.x = Math.min(this.x, v.x);
866		this.y = Math.min(this.y, v.y);
867
868		return this;
869
870	}
871
872	max(v) {
873
874		this.x = Math.max(this.x, v.x);
875		this.y = Math.max(this.y, v.y);
876
877		return this;
878
879	}
880
881	clamp(min, max) {
882
883		// assumes min < max, componentwise
884
885		this.x = Math.max(min.x, Math.min(max.x, this.x));
886		this.y = Math.max(min.y, Math.min(max.y, this.y));
887
888		return this;
889
890	}
891
892	clampScalar(minVal, maxVal) {
893
894		this.x = Math.max(minVal, Math.min(maxVal, this.x));
895		this.y = Math.max(minVal, Math.min(maxVal, this.y));
896
897		return this;
898
899	}
900
901	clampLength(min, max) {
902
903		const length = this.length();
904
905		return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
906
907	}
908
909	floor() {
910
911		this.x = Math.floor(this.x);
912		this.y = Math.floor(this.y);
913
914		return this;
915
916	}
917
918	ceil() {
919
920		this.x = Math.ceil(this.x);
921		this.y = Math.ceil(this.y);
922
923		return this;
924
925	}
926
927	round() {
928
929		this.x = Math.round(this.x);
930		this.y = Math.round(this.y);
931
932		return this;
933
934	}
935
936	roundToZero() {
937
938		this.x = Math.trunc(this.x);
939		this.y = Math.trunc(this.y);
940
941		return this;
942
943	}
944
945	negate() {
946
947		this.x = - this.x;
948		this.y = - this.y;
949
950		return this;
951
952	}
953
954	dot(v) {
955
956		return this.x * v.x + this.y * v.y;
957
958	}
959
960	cross(v) {
961
962		return this.x * v.y - this.y * v.x;
963
964	}
965
966	lengthSq() {
967
968		return this.x * this.x + this.y * this.y;
969
970	}
971
972	length() {
973
974		return Math.sqrt(this.x * this.x + this.y * this.y);
975
976	}
977
978	manhattanLength() {
979
980		return Math.abs(this.x) + Math.abs(this.y);
981
982	}
983
984	normalize() {
985
986		return this.divideScalar(this.length() || 1);
987
988	}
989
990	angle() {
991
992		// computes the angle in radians with respect to the positive x-axis
993
994		const angle = Math.atan2(- this.y, - this.x) + Math.PI;
995
996		return angle;
997
998	}
999
1000	angleTo(v) {
1001
1002		const denominator = Math.sqrt(this.lengthSq() * v.lengthSq());
1003
1004		if (denominator === 0) return Math.PI / 2;
1005
1006		const theta = this.dot(v) / denominator;
1007
1008		// clamp, to handle numerical problems
1009
1010		return Math.acos(clamp(theta, - 1, 1));
1011
1012	}
1013
1014	distanceTo(v) {
1015
1016		return Math.sqrt(this.distanceToSquared(v));
1017
1018	}
1019
1020	distanceToSquared(v) {
1021
1022		const dx = this.x - v.x, dy = this.y - v.y;
1023		return dx * dx + dy * dy;
1024
1025	}
1026
1027	manhattanDistanceTo(v) {
1028
1029		return Math.abs(this.x - v.x) + Math.abs(this.y - v.y);
1030
1031	}
1032
1033	setLength(length) {
1034
1035		return this.normalize().multiplyScalar(length);
1036
1037	}
1038
1039	lerp(v, alpha) {
1040
1041		this.x += (v.x - this.x) * alpha;
1042		this.y += (v.y - this.y) * alpha;
1043
1044		return this;
1045
1046	}
1047
1048	lerpVectors(v1, v2, alpha) {
1049
1050		this.x = v1.x + (v2.x - v1.x) * alpha;
1051		this.y = v1.y + (v2.y - v1.y) * alpha;
1052
1053		return this;
1054
1055	}
1056
1057	equals(v) {
1058
1059		return ((v.x === this.x) && (v.y === this.y));
1060
1061	}
1062
1063	fromArray(array, offset = 0) {
1064
1065		this.x = array[offset];
1066		this.y = array[offset + 1];
1067
1068		return this;
1069
1070	}
1071
1072	toArray(array = [], offset = 0) {
1073
1074		array[offset] = this.x;
1075		array[offset + 1] = this.y;
1076
1077		return array;
1078
1079	}
1080
1081	fromBufferAttribute(attribute, index) {
1082
1083		this.x = attribute.getX(index);
1084		this.y = attribute.getY(index);
1085
1086		return this;
1087
1088	}
1089
1090	rotateAround(center, angle) {
1091
1092		const c = Math.cos(angle), s = Math.sin(angle);
1093
1094		const x = this.x - center.x;
1095		const y = this.y - center.y;
1096
1097		this.x = x * c - y * s + center.x;
1098		this.y = x * s + y * c + center.y;
1099
1100		return this;
1101
1102	}
1103
1104	random() {
1105
1106		this.x = Math.random();
1107		this.y = Math.random();
1108
1109		return this;
1110
1111	}
1112
1113	*[Symbol.iterator]() {
1114
1115		yield this.x;
1116		yield this.y;
1117
1118	}
1119
1120}
1121
1122class Matrix3 {
1123
1124	constructor(n11, n12, n13, n21, n22, n23, n31, n32, n33) {
1125
1126		Matrix3.prototype.isMatrix3 = true;
1127
1128		this.elements = [
1129
1130			1, 0, 0,
1131			0, 1, 0,
1132			0, 0, 1
1133
1134		];
1135
1136		if (n11 !== undefined) {
1137
1138			this.set(n11, n12, n13, n21, n22, n23, n31, n32, n33);
1139
1140		}
1141
1142	}
1143
1144	set(n11, n12, n13, n21, n22, n23, n31, n32, n33) {
1145
1146		const te = this.elements;
1147
1148		te[0] = n11; te[1] = n21; te[2] = n31;
1149		te[3] = n12; te[4] = n22; te[5] = n32;
1150		te[6] = n13; te[7] = n23; te[8] = n33;
1151
1152		return this;
1153
1154	}
1155
1156	identity() {
1157
1158		this.set(
1159
1160			1, 0, 0,
1161			0, 1, 0,
1162			0, 0, 1
1163
1164		);
1165
1166		return this;
1167
1168	}
1169
1170	copy(m) {
1171
1172		const te = this.elements;
1173		const me = m.elements;
1174
1175		te[0] = me[0]; te[1] = me[1]; te[2] = me[2];
1176		te[3] = me[3]; te[4] = me[4]; te[5] = me[5];
1177		te[6] = me[6]; te[7] = me[7]; te[8] = me[8];
1178
1179		return this;
1180
1181	}
1182
1183	extractBasis(xAxis, yAxis, zAxis) {
1184
1185		xAxis.setFromMatrix3Column(this, 0);
1186		yAxis.setFromMatrix3Column(this, 1);
1187		zAxis.setFromMatrix3Column(this, 2);
1188
1189		return this;
1190
1191	}
1192
1193	setFromMatrix4(m) {
1194
1195		const me = m.elements;
1196
1197		this.set(
1198
1199			me[0], me[4], me[8],
1200			me[1], me[5], me[9],
1201			me[2], me[6], me[10]
1202
1203		);
1204
1205		return this;
1206
1207	}
1208
1209	multiply(m) {
1210
1211		return this.multiplyMatrices(this, m);
1212
1213	}
1214
1215	premultiply(m) {
1216
1217		return this.multiplyMatrices(m, this);
1218
1219	}
1220
1221	multiplyMatrices(a, b) {
1222
1223		const ae = a.elements;
1224		const be = b.elements;
1225		const te = this.elements;
1226
1227		const a11 = ae[0], a12 = ae[3], a13 = ae[6];
1228		const a21 = ae[1], a22 = ae[4], a23 = ae[7];
1229		const a31 = ae[2], a32 = ae[5], a33 = ae[8];
1230
1231		const b11 = be[0], b12 = be[3], b13 = be[6];
1232		const b21 = be[1], b22 = be[4], b23 = be[7];
1233		const b31 = be[2], b32 = be[5], b33 = be[8];
1234
1235		te[0] = a11 * b11 + a12 * b21 + a13 * b31;
1236		te[3] = a11 * b12 + a12 * b22 + a13 * b32;
1237		te[6] = a11 * b13 + a12 * b23 + a13 * b33;
1238
1239		te[1] = a21 * b11 + a22 * b21 + a23 * b31;
1240		te[4] = a21 * b12 + a22 * b22 + a23 * b32;
1241		te[7] = a21 * b13 + a22 * b23 + a23 * b33;
1242
1243		te[2] = a31 * b11 + a32 * b21 + a33 * b31;
1244		te[5] = a31 * b12 + a32 * b22 + a33 * b32;
1245		te[8] = a31 * b13 + a32 * b23 + a33 * b33;
1246
1247		return this;
1248
1249	}
1250
1251	multiplyScalar(s) {
1252
1253		const te = this.elements;
1254
1255		te[0] *= s; te[3] *= s; te[6] *= s;
1256		te[1] *= s; te[4] *= s; te[7] *= s;
1257		te[2] *= s; te[5] *= s; te[8] *= s;
1258
1259		return this;
1260
1261	}
1262
1263	determinant() {
1264
1265		const te = this.elements;
1266
1267		const a = te[0], b = te[1], c = te[2],
1268			d = te[3], e = te[4], f = te[5],
1269			g = te[6], h = te[7], i = te[8];
1270
1271		return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;
1272
1273	}
1274
1275	invert() {
1276
1277		const te = this.elements,
1278
1279			n11 = te[0], n21 = te[1], n31 = te[2],
1280			n12 = te[3], n22 = te[4], n32 = te[5],
1281			n13 = te[6], n23 = te[7], n33 = te[8],
1282
1283			t11 = n33 * n22 - n32 * n23,
1284			t12 = n32 * n13 - n33 * n12,
1285			t13 = n23 * n12 - n22 * n13,
1286
1287			det = n11 * t11 + n21 * t12 + n31 * t13;
1288
1289		if (det === 0) return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0);
1290
1291		const detInv = 1 / det;
1292
1293		te[0] = t11 * detInv;
1294		te[1] = (n31 * n23 - n33 * n21) * detInv;
1295		te[2] = (n32 * n21 - n31 * n22) * detInv;
1296
1297		te[3] = t12 * detInv;
1298		te[4] = (n33 * n11 - n31 * n13) * detInv;
1299		te[5] = (n31 * n12 - n32 * n11) * detInv;
1300
1301		te[6] = t13 * detInv;
1302		te[7] = (n21 * n13 - n23 * n11) * detInv;
1303		te[8] = (n22 * n11 - n21 * n12) * detInv;
1304
1305		return this;
1306
1307	}
1308
1309	transpose() {
1310
1311		let tmp;
1312		const m = this.elements;
1313
1314		tmp = m[1]; m[1] = m[3]; m[3] = tmp;
1315		tmp = m[2]; m[2] = m[6]; m[6] = tmp;
1316		tmp = m[5]; m[5] = m[7]; m[7] = tmp;
1317
1318		return this;
1319
1320	}
1321
1322	getNormalMatrix(matrix4) {
1323
1324		return this.setFromMatrix4(matrix4).invert().transpose();
1325
1326	}
1327
1328	transposeIntoArray(r) {
1329
1330		const m = this.elements;
1331
1332		r[0] = m[0];
1333		r[1] = m[3];
1334		r[2] = m[6];
1335		r[3] = m[1];
1336		r[4] = m[4];
1337		r[5] = m[7];
1338		r[6] = m[2];
1339		r[7] = m[5];
1340		r[8] = m[8];
1341
1342		return this;
1343
1344	}
1345
1346	setUvTransform(tx, ty, sx, sy, rotation, cx, cy) {
1347
1348		const c = Math.cos(rotation);
1349		const s = Math.sin(rotation);
1350
1351		this.set(
1352			sx * c, sx * s, - sx * (c * cx + s * cy) + cx + tx,
1353			- sy * s, sy * c, - sy * (- s * cx + c * cy) + cy + ty,
1354			0, 0, 1
1355		);
1356
1357		return this;
1358
1359	}
1360
1361	//
1362
1363	scale(sx, sy) {
1364
1365		this.premultiply(_m3.makeScale(sx, sy));
1366
1367		return this;
1368
1369	}
1370
1371	rotate(theta) {
1372
1373		this.premultiply(_m3.makeRotation(- theta));
1374
1375		return this;
1376
1377	}
1378
1379	translate(tx, ty) {
1380
1381		this.premultiply(_m3.makeTranslation(tx, ty));
1382
1383		return this;
1384
1385	}
1386
1387	// for 2D Transforms
1388
1389	makeTranslation(x, y) {
1390
1391		if (x.isVector2) {
1392
1393			this.set(
1394
1395				1, 0, x.x,
1396				0, 1, x.y,
1397				0, 0, 1
1398
1399			);
1400
1401		} else {
1402
1403			this.set(
1404
1405				1, 0, x,
1406				0, 1, y,
1407				0, 0, 1
1408
1409			);
1410
1411		}
1412
1413		return this;
1414
1415	}
1416
1417	makeRotation(theta) {
1418
1419		// counterclockwise
1420
1421		const c = Math.cos(theta);
1422		const s = Math.sin(theta);
1423
1424		this.set(
1425
1426			c, - s, 0,
1427			s, c, 0,
1428			0, 0, 1
1429
1430		);
1431
1432		return this;
1433
1434	}
1435
1436	makeScale(x, y) {
1437
1438		this.set(
1439
1440			x, 0, 0,
1441			0, y, 0,
1442			0, 0, 1
1443
1444		);
1445
1446		return this;
1447
1448	}
1449
1450	//
1451
1452	equals(matrix) {
1453
1454		const te = this.elements;
1455		const me = matrix.elements;
1456
1457		for (let i = 0; i < 9; i++) {
1458
1459			if (te[i] !== me[i]) return false;
1460
1461		}
1462
1463		return true;
1464
1465	}
1466
1467	fromArray(array, offset = 0) {
1468
1469		for (let i = 0; i < 9; i++) {
1470
1471			this.elements[i] = array[i + offset];
1472
1473		}
1474
1475		return this;
1476
1477	}
1478
1479	toArray(array = [], offset = 0) {
1480
1481		const te = this.elements;
1482
1483		array[offset] = te[0];
1484		array[offset + 1] = te[1];
1485		array[offset + 2] = te[2];
1486
1487		array[offset + 3] = te[3];
1488		array[offset + 4] = te[4];
1489		array[offset + 5] = te[5];
1490
1491		array[offset + 6] = te[6];
1492		array[offset + 7] = te[7];
1493		array[offset + 8] = te[8];
1494
1495		return array;
1496
1497	}
1498
1499	clone() {
1500
1501		return new this.constructor().fromArray(this.elements);
1502
1503	}
1504
1505}
1506
1507const _m3 = /*@__PURE__*/ new Matrix3();
1508
1509function arrayNeedsUint32(array) {
1510
1511	// assumes larger values usually on last
1512
1513	for (let i = array.length - 1; i >= 0; --i) {
1514
1515		if (array[i] >= 65535) return true; // account for PRIMITIVE_RESTART_FIXED_INDEX, #24565
1516
1517	}
1518
1519	return false;
1520
1521}
1522
1523const TYPED_ARRAYS = {
1524	Int8Array: Int8Array,
1525	Uint8Array: Uint8Array,
1526	Uint8ClampedArray: Uint8ClampedArray,
1527	Int16Array: Int16Array,
1528	Uint16Array: Uint16Array,
1529	Int32Array: Int32Array,
1530	Uint32Array: Uint32Array,
1531	Float32Array: Float32Array,
1532	Float64Array: Float64Array
1533};
1534
1535function getTypedArray(type, buffer) {
1536
1537	return new TYPED_ARRAYS[type](buffer);
1538
1539}
1540
1541function createElementNS(name) {
1542
1543	return document.createElementNS('http://www.w3.org/1999/xhtml', name);
1544
1545}
1546
1547function createCanvasElement() {
1548
1549	const canvas = createElementNS('canvas');
1550	canvas.style.display = 'block';
1551	return canvas;
1552
1553}
1554
1555const _cache = {};
1556
1557function warnOnce(message) {
1558
1559	if (message in _cache) return;
1560
1561	_cache[message] = true;
1562
1563	console.warn(message);
1564
1565}
1566
1567/**
1568 * Matrices converting P3 <-> Rec. 709 primaries, without gamut mapping
1569 * or clipping. Based on W3C specifications for sRGB and Display P3,
1570 * and ICC specifications for the D50 connection space. Values in/out
1571 * are _linear_ sRGB and _linear_ Display P3.
1572 *
1573 * Note that both sRGB and Display P3 use the sRGB transfer functions.
1574 *
1575 * Reference:
1576 * - http://www.russellcottrell.com/photo/matrixCalculator.htm
1577 */
1578
1579const LINEAR_SRGB_TO_LINEAR_DISPLAY_P3 = /*@__PURE__*/ new Matrix3().set(
1580	0.8224621, 0.177538, 0.0,
1581	0.0331941, 0.9668058, 0.0,
1582	0.0170827, 0.0723974, 0.9105199,
1583);
1584
1585const LINEAR_DISPLAY_P3_TO_LINEAR_SRGB = /*@__PURE__*/ new Matrix3().set(
1586	1.2249401, - 0.2249404, 0.0,
1587	- 0.0420569, 1.0420571, 0.0,
1588	- 0.0196376, - 0.0786361, 1.0982735
1589);
1590
1591/**
1592 * Defines supported color spaces by transfer function and primaries,
1593 * and provides conversions to/from the Linear-sRGB reference space.
1594 */
1595const COLOR_SPACES = {
1596	[LinearSRGBColorSpace]: {
1597		transfer: LinearTransfer,
1598		primaries: Rec709Primaries,
1599		toReference: (color) => color,
1600		fromReference: (color) => color,
1601	},
1602	[SRGBColorSpace]: {
1603		transfer: SRGBTransfer,
1604		primaries: Rec709Primaries,
1605		toReference: (color) => color.convertSRGBToLinear(),
1606		fromReference: (color) => color.convertLinearToSRGB(),
1607	},
1608	[LinearDisplayP3ColorSpace]: {
1609		transfer: LinearTransfer,
1610		primaries: P3Primaries,
1611		toReference: (color) => color.applyMatrix3(LINEAR_DISPLAY_P3_TO_LINEAR_SRGB),
1612		fromReference: (color) => color.applyMatrix3(LINEAR_SRGB_TO_LINEAR_DISPLAY_P3),
1613	},
1614	[DisplayP3ColorSpace]: {
1615		transfer: SRGBTransfer,
1616		primaries: P3Primaries,
1617		toReference: (color) => color.convertSRGBToLinear().applyMatrix3(LINEAR_DISPLAY_P3_TO_LINEAR_SRGB),
1618		fromReference: (color) => color.applyMatrix3(LINEAR_SRGB_TO_LINEAR_DISPLAY_P3).convertLinearToSRGB(),
1619	},
1620};
1621
1622const SUPPORTED_WORKING_COLOR_SPACES = new Set([LinearSRGBColorSpace, LinearDisplayP3ColorSpace]);
1623
1624const ColorManagement = {
1625
1626	enabled: true,
1627
1628	_workingColorSpace: LinearSRGBColorSpace,
1629
1630	get workingColorSpace() {
1631
1632		return this._workingColorSpace;
1633
1634	},
1635
1636	set workingColorSpace(colorSpace) {
1637
1638		if (!SUPPORTED_WORKING_COLOR_SPACES.has(colorSpace)) {
1639
1640			throw new Error(`Unsupported working color space, "${colorSpace}".`);
1641
1642		}
1643
1644		this._workingColorSpace = colorSpace;
1645
1646	},
1647
1648	convert: function (color, sourceColorSpace, targetColorSpace) {
1649
1650		if (this.enabled === false || sourceColorSpace === targetColorSpace || !sourceColorSpace || !targetColorSpace) {
1651
1652			return color;
1653
1654		}
1655
1656		const sourceToReference = COLOR_SPACES[sourceColorSpace].toReference;
1657		const targetFromReference = COLOR_SPACES[targetColorSpace].fromReference;
1658
1659		return targetFromReference(sourceToReference(color));
1660
1661	},
1662
1663	fromWorkingColorSpace: function (color, targetColorSpace) {
1664
1665		return this.convert(color, this._workingColorSpace, targetColorSpace);
1666
1667	},
1668
1669	toWorkingColorSpace: function (color, sourceColorSpace) {
1670
1671		return this.convert(color, sourceColorSpace, this._workingColorSpace);
1672
1673	},
1674
1675	getPrimaries: function (colorSpace) {
1676
1677		return COLOR_SPACES[colorSpace].primaries;
1678
1679	},
1680
1681	getTransfer: function (colorSpace) {
1682
1683		if (colorSpace === NoColorSpace) return LinearTransfer;
1684
1685		return COLOR_SPACES[colorSpace].transfer;
1686
1687	},
1688
1689};
1690
1691
1692function SRGBToLinear(c) {
1693
1694	return (c < 0.04045) ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
1695
1696}
1697
1698function LinearToSRGB(c) {
1699
1700	return (c < 0.0031308) ? c * 12.92 : 1.055 * (Math.pow(c, 0.41666)) - 0.055;
1701
1702}
1703
1704let _canvas;
1705
1706class ImageUtils {
1707
1708	static getDataURL(image) {
1709
1710		if (/^data:/i.test(image.src)) {
1711
1712			return image.src;
1713
1714		}
1715
1716		if (typeof HTMLCanvasElement === 'undefined') {
1717
1718			return image.src;
1719
1720		}
1721
1722		let canvas;
1723
1724		if (image instanceof HTMLCanvasElement) {
1725
1726			canvas = image;
1727
1728		} else {
1729
1730			if (_canvas === undefined) _canvas = createElementNS('canvas');
1731
1732			_canvas.width = image.width;
1733			_canvas.height = image.height;
1734
1735			const context = _canvas.getContext('2d');
1736
1737			if (image instanceof ImageData) {
1738
1739				context.putImageData(image, 0, 0);
1740
1741			} else {
1742
1743				context.drawImage(image, 0, 0, image.width, image.height);
1744
1745			}
1746
1747			canvas = _canvas;
1748
1749		}
1750
1751		if (canvas.width > 2048 || canvas.height > 2048) {
1752
1753			console.warn('THREE.ImageUtils.getDataURL: Image converted to jpg for performance reasons', image);
1754
1755			return canvas.toDataURL('image/jpeg', 0.6);
1756
1757		} else {
1758
1759			return canvas.toDataURL('image/png');
1760
1761		}
1762
1763	}
1764
1765	static sRGBToLinear(image) {
1766
1767		if ((typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement) ||
1768			(typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement) ||
1769			(typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap)) {
1770
1771			const canvas = createElementNS('canvas');
1772
1773			canvas.width = image.width;
1774			canvas.height = image.height;
1775
1776			const context = canvas.getContext('2d');
1777			context.drawImage(image, 0, 0, image.width, image.height);
1778
1779			const imageData = context.getImageData(0, 0, image.width, image.height);
1780			const data = imageData.data;
1781
1782			for (let i = 0; i < data.length; i++) {
1783
1784				data[i] = SRGBToLinear(data[i] / 255) * 255;
1785
1786			}
1787
1788			context.putImageData(imageData, 0, 0);
1789
1790			return canvas;
1791
1792		} else if (image.data) {
1793
1794			const data = image.data.slice(0);
1795
1796			for (let i = 0; i < data.length; i++) {
1797
1798				if (data instanceof Uint8Array || data instanceof Uint8ClampedArray) {
1799
1800					data[i] = Math.floor(SRGBToLinear(data[i] / 255) * 255);
1801
1802				} else {
1803
1804					// assuming float
1805
1806					data[i] = SRGBToLinear(data[i]);
1807
1808				}
1809
1810			}
1811
1812			return {
1813				data: data,
1814				width: image.width,
1815				height: image.height
1816			};
1817
1818		} else {
1819
1820			console.warn('THREE.ImageUtils.sRGBToLinear(): Unsupported image type. No color space conversion applied.');
1821			return image;
1822
1823		}
1824
1825	}
1826
1827}
1828
1829let _sourceId = 0;
1830
1831class Source {
1832
1833	constructor(data = null) {
1834
1835		this.isSource = true;
1836
1837		Object.defineProperty(this, 'id', { value: _sourceId++ });
1838
1839		this.uuid = generateUUID();
1840
1841		this.data = data;
1842
1843		this.version = 0;
1844
1845	}
1846
1847	set needsUpdate(value) {
1848
1849		if (value === true) this.version++;
1850
1851	}
1852
1853	toJSON(meta) {
1854
1855		const isRootObject = (meta === undefined || typeof meta === 'string');
1856
1857		if (!isRootObject && meta.images[this.uuid] !== undefined) {
1858
1859			return meta.images[this.uuid];
1860
1861		}
1862
1863		const output = {
1864			uuid: this.uuid,
1865			url: ''
1866		};
1867
1868		const data = this.data;
1869
1870		if (data !== null) {
1871
1872			let url;
1873
1874			if (Array.isArray(data)) {
1875
1876				// cube texture
1877
1878				url = [];
1879
1880				for (let i = 0, l = data.length; i < l; i++) {
1881
1882					if (data[i].isDataTexture) {
1883
1884						url.push(serializeImage(data[i].image));
1885
1886					} else {
1887
1888						url.push(serializeImage(data[i]));
1889
1890					}
1891
1892				}
1893
1894			} else {
1895
1896				// texture
1897
1898				url = serializeImage(data);
1899
1900			}
1901
1902			output.url = url;
1903
1904		}
1905
1906		if (!isRootObject) {
1907
1908			meta.images[this.uuid] = output;
1909
1910		}
1911
1912		return output;
1913
1914	}
1915
1916}
1917
1918function serializeImage(image) {
1919
1920	if ((typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement) ||
1921		(typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement) ||
1922		(typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap)) {
1923
1924		// default images
1925
1926		return ImageUtils.getDataURL(image);
1927
1928	} else {
1929
1930		if (image.data) {
1931
1932			// images of DataTexture
1933
1934			return {
1935				data: Array.from(image.data),
1936				width: image.width,
1937				height: image.height,
1938				type: image.data.constructor.name
1939			};
1940
1941		} else {
1942
1943			console.warn('THREE.Texture: Unable to serialize Texture.');
1944			return {};
1945
1946		}
1947
1948	}
1949
1950}
1951
1952let _textureId = 0;
1953
1954class Texture extends EventDispatcher {
1955
1956	constructor(image = Texture.DEFAULT_IMAGE, mapping = Texture.DEFAULT_MAPPING, wrapS = ClampToEdgeWrapping, wrapT = ClampToEdgeWrapping, magFilter = LinearFilter, minFilter = LinearMipmapLinearFilter, format = RGBAFormat, type = UnsignedByteType, anisotropy = Texture.DEFAULT_ANISOTROPY, colorSpace = NoColorSpace) {
1957
1958		super();
1959
1960		this.isTexture = true;
1961
1962		Object.defineProperty(this, 'id', { value: _textureId++ });
1963
1964		this.uuid = generateUUID();
1965
1966		this.name = '';
1967
1968		this.source = new Source(image);
1969		this.mipmaps = [];
1970
1971		this.mapping = mapping;
1972		this.channel = 0;
1973
1974		this.wrapS = wrapS;
1975		this.wrapT = wrapT;
1976
1977		this.magFilter = magFilter;
1978		this.minFilter = minFilter;
1979
1980		this.anisotropy = anisotropy;
1981
1982		this.format = format;
1983		this.internalFormat = null;
1984		this.type = type;
1985
1986		this.offset = new Vector2(0, 0);
1987		this.repeat = new Vector2(1, 1);
1988		this.center = new Vector2(0, 0);
1989		this.rotation = 0;
1990
1991		this.matrixAutoUpdate = true;
1992		this.matrix = new Matrix3();
1993
1994		this.generateMipmaps = true;
1995		this.premultiplyAlpha = false;
1996		this.flipY = true;
1997		this.unpackAlignment = 4;	// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
1998
1999		if (typeof colorSpace === 'string') {
2000
2001			this.colorSpace = colorSpace;
2002
2003		} else { // @deprecated, r152
2004
2005			warnOnce('THREE.Texture: Property .encoding has been replaced by .colorSpace.');
2006			this.colorSpace = colorSpace === sRGBEncoding ? SRGBColorSpace : NoColorSpace;
2007
2008		}
2009
2010
2011		this.userData = {};
2012
2013		this.version = 0;
2014		this.onUpdate = null;
2015
2016		this.isRenderTargetTexture = false; // indicates whether a texture belongs to a render target or not
2017		this.needsPMREMUpdate = false; // indicates whether this texture should be processed by PMREMGenerator or not (only relevant for render target textures)
2018
2019	}
2020
2021	get image() {
2022
2023		return this.source.data;
2024
2025	}
2026
2027	set image(value = null) {
2028
2029		this.source.data = value;
2030
2031	}
2032
2033	updateMatrix() {
2034
2035		this.matrix.setUvTransform(this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y);
2036
2037	}
2038
2039	clone() {
2040
2041		return new this.constructor().copy(this);
2042
2043	}
2044
2045	copy(source) {
2046
2047		this.name = source.name;
2048
2049		this.source = source.source;
2050		this.mipmaps = source.mipmaps.slice(0);
2051
2052		this.mapping = source.mapping;
2053		this.channel = source.channel;
2054
2055		this.wrapS = source.wrapS;
2056		this.wrapT = source.wrapT;
2057
2058		this.magFilter = source.magFilter;
2059		this.minFilter = source.minFilter;
2060
2061		this.anisotropy = source.anisotropy;
2062
2063		this.format = source.format;
2064		this.internalFormat = source.internalFormat;
2065		this.type = source.type;
2066
2067		this.offset.copy(source.offset);
2068		this.repeat.copy(source.repeat);
2069		this.center.copy(source.center);
2070		this.rotation = source.rotation;
2071
2072		this.matrixAutoUpdate = source.matrixAutoUpdate;
2073		this.matrix.copy(source.matrix);
2074
2075		this.generateMipmaps = source.generateMipmaps;
2076		this.premultiplyAlpha = source.premultiplyAlpha;
2077		this.flipY = source.flipY;
2078		this.unpackAlignment = source.unpackAlignment;
2079		this.colorSpace = source.colorSpace;
2080
2081		this.userData = JSON.parse(JSON.stringify(source.userData));
2082
2083		this.needsUpdate = true;
2084
2085		return this;
2086
2087	}
2088
2089	toJSON(meta) {
2090
2091		const isRootObject = (meta === undefined || typeof meta === 'string');
2092
2093		if (!isRootObject && meta.textures[this.uuid] !== undefined) {
2094
2095			return meta.textures[this.uuid];
2096
2097		}
2098
2099		const output = {
2100
2101			metadata: {
2102				version: 4.6,
2103				type: 'Texture',
2104				generator: 'Texture.toJSON'
2105			},
2106
2107			uuid: this.uuid,
2108			name: this.name,
2109
2110			image: this.source.toJSON(meta).uuid,
2111
2112			mapping: this.mapping,
2113			channel: this.channel,
2114
2115			repeat: [this.repeat.x, this.repeat.y],
2116			offset: [this.offset.x, this.offset.y],
2117			center: [this.center.x, this.center.y],
2118			rotation: this.rotation,
2119
2120			wrap: [this.wrapS, this.wrapT],
2121
2122			format: this.format,
2123			internalFormat: this.internalFormat,
2124			type: this.type,
2125			colorSpace: this.colorSpace,
2126
2127			minFilter: this.minFilter,
2128			magFilter: this.magFilter,
2129			anisotropy: this.anisotropy,
2130
2131			flipY: this.flipY,
2132
2133			generateMipmaps: this.generateMipmaps,
2134			premultiplyAlpha: this.premultiplyAlpha,
2135			unpackAlignment: this.unpackAlignment
2136
2137		};
2138
2139		if (Object.keys(this.userData).length > 0) output.userData = this.userData;
2140
2141		if (!isRootObject) {
2142
2143			meta.textures[this.uuid] = output;
2144
2145		}
2146
2147		return output;
2148
2149	}
2150
2151	dispose() {
2152
2153		this.dispatchEvent({ type: 'dispose' });
2154
2155	}
2156
2157	transformUv(uv) {
2158
2159		if (this.mapping !== UVMapping) return uv;
2160
2161		uv.applyMatrix3(this.matrix);
2162
2163		if (uv.x < 0 || uv.x > 1) {
2164
2165			switch (this.wrapS) {
2166
2167				case RepeatWrapping:
2168
2169					uv.x = uv.x - Math.floor(uv.x);
2170					break;
2171
2172				case ClampToEdgeWrapping:
2173
2174					uv.x = uv.x < 0 ? 0 : 1;
2175					break;
2176
2177				case MirroredRepeatWrapping:
2178
2179					if (Math.abs(Math.floor(uv.x) % 2) === 1) {
2180
2181						uv.x = Math.ceil(uv.x) - uv.x;
2182
2183					} else {
2184
2185						uv.x = uv.x - Math.floor(uv.x);
2186
2187					}
2188
2189					break;
2190
2191			}
2192
2193		}
2194
2195		if (uv.y < 0 || uv.y > 1) {
2196
2197			switch (this.wrapT) {
2198
2199				case RepeatWrapping:
2200
2201					uv.y = uv.y - Math.floor(uv.y);
2202					break;
2203
2204				case ClampToEdgeWrapping:
2205
2206					uv.y = uv.y < 0 ? 0 : 1;
2207					break;
2208
2209				case MirroredRepeatWrapping:
2210
2211					if (Math.abs(Math.floor(uv.y) % 2) === 1) {
2212
2213						uv.y = Math.ceil(uv.y) - uv.y;
2214
2215					} else {
2216
2217						uv.y = uv.y - Math.floor(uv.y);
2218
2219					}
2220
2221					break;
2222
2223			}
2224
2225		}
2226
2227		if (this.flipY) {
2228
2229			uv.y = 1 - uv.y;
2230
2231		}
2232
2233		return uv;
2234
2235	}
2236
2237	set needsUpdate(value) {
2238
2239		if (value === true) {
2240
2241			this.version++;
2242			this.source.needsUpdate = true;
2243
2244		}
2245
2246	}
2247
2248	get encoding() { // @deprecated, r152
2249
2250		warnOnce('THREE.Texture: Property .encoding has been replaced by .colorSpace.');
2251		return this.colorSpace === SRGBColorSpace ? sRGBEncoding : LinearEncoding;
2252
2253	}
2254
2255	set encoding(encoding) { // @deprecated, r152
2256
2257		warnOnce('THREE.Texture: Property .encoding has been replaced by .colorSpace.');
2258		this.colorSpace = encoding === sRGBEncoding ? SRGBColorSpace : NoColorSpace;
2259
2260	}
2261
2262}
2263
2264Texture.DEFAULT_IMAGE = null;
2265Texture.DEFAULT_MAPPING = UVMapping;
2266Texture.DEFAULT_ANISOTROPY = 1;
2267
2268class Vector4 {
2269
2270	constructor(x = 0, y = 0, z = 0, w = 1) {
2271
2272		Vector4.prototype.isVector4 = true;
2273
2274		this.x = x;
2275		this.y = y;
2276		this.z = z;
2277		this.w = w;
2278
2279	}
2280
2281	get width() {
2282
2283		return this.z;
2284
2285	}
2286
2287	set width(value) {
2288
2289		this.z = value;
2290
2291	}
2292
2293	get height() {
2294
2295		return this.w;
2296
2297	}
2298
2299	set height(value) {
2300
2301		this.w = value;
2302
2303	}
2304
2305	set(x, y, z, w) {
2306
2307		this.x = x;
2308		this.y = y;
2309		this.z = z;
2310		this.w = w;
2311
2312		return this;
2313
2314	}
2315
2316	setScalar(scalar) {
2317
2318		this.x = scalar;
2319		this.y = scalar;
2320		this.z = scalar;
2321		this.w = scalar;
2322
2323		return this;
2324
2325	}
2326
2327	setX(x) {
2328
2329		this.x = x;
2330
2331		return this;
2332
2333	}
2334
2335	setY(y) {
2336
2337		this.y = y;
2338
2339		return this;
2340
2341	}
2342
2343	setZ(z) {
2344
2345		this.z = z;
2346
2347		return this;
2348
2349	}
2350
2351	setW(w) {
2352
2353		this.w = w;
2354
2355		return this;
2356
2357	}
2358
2359	setComponent(index, value) {
2360
2361		switch (index) {
2362
2363			case 0: this.x = value; break;
2364			case 1: this.y = value; break;
2365			case 2: this.z = value; break;
2366			case 3: this.w = value; break;
2367			default: throw new Error('index is out of range: ' + index);
2368
2369		}
2370
2371		return this;
2372
2373	}
2374
2375	getComponent(index) {
2376
2377		switch (index) {
2378
2379			case 0: return this.x;
2380			case 1: return this.y;
2381			case 2: return this.z;
2382			case 3: return this.w;
2383			default: throw new Error('index is out of range: ' + index);
2384
2385		}
2386
2387	}
2388
2389	clone() {
2390
2391		return new this.constructor(this.x, this.y, this.z, this.w);
2392
2393	}
2394
2395	copy(v) {
2396
2397		this.x = v.x;
2398		this.y = v.y;
2399		this.z = v.z;
2400		this.w = (v.w !== undefined) ? v.w : 1;
2401
2402		return this;
2403
2404	}
2405
2406	add(v) {
2407
2408		this.x += v.x;
2409		this.y += v.y;
2410		this.z += v.z;
2411		this.w += v.w;
2412
2413		return this;
2414
2415	}
2416
2417	addScalar(s) {
2418
2419		this.x += s;
2420		this.y += s;
2421		this.z += s;
2422		this.w += s;
2423
2424		return this;
2425
2426	}
2427
2428	addVectors(a, b) {
2429
2430		this.x = a.x + b.x;
2431		this.y = a.y + b.y;
2432		this.z = a.z + b.z;
2433		this.w = a.w + b.w;
2434
2435		return this;
2436
2437	}
2438
2439	addScaledVector(v, s) {
2440
2441		this.x += v.x * s;
2442		this.y += v.y * s;
2443		this.z += v.z * s;
2444		this.w += v.w * s;
2445
2446		return this;
2447
2448	}
2449
2450	sub(v) {
2451
2452		this.x -= v.x;
2453		this.y -= v.y;
2454		this.z -= v.z;
2455		this.w -= v.w;
2456
2457		return this;
2458
2459	}
2460
2461	subScalar(s) {
2462
2463		this.x -= s;
2464		this.y -= s;
2465		this.z -= s;
2466		this.w -= s;
2467
2468		return this;
2469
2470	}
2471
2472	subVectors(a, b) {
2473
2474		this.x = a.x - b.x;
2475		this.y = a.y - b.y;
2476		this.z = a.z - b.z;
2477		this.w = a.w - b.w;
2478
2479		return this;
2480
2481	}
2482
2483	multiply(v) {
2484
2485		this.x *= v.x;
2486		this.y *= v.y;
2487		this.z *= v.z;
2488		this.w *= v.w;
2489
2490		return this;
2491
2492	}
2493
2494	multiplyScalar(scalar) {
2495
2496		this.x *= scalar;
2497		this.y *= scalar;
2498		this.z *= scalar;
2499		this.w *= scalar;
2500
2501		return this;
2502
2503	}
2504
2505	applyMatrix4(m) {
2506
2507		const x = this.x, y = this.y, z = this.z, w = this.w;
2508		const e = m.elements;
2509
2510		this.x = e[0] * x + e[4] * y + e[8] * z + e[12] * w;
2511		this.y = e[1] * x + e[5] * y + e[9] * z + e[13] * w;
2512		this.z = e[2] * x + e[6] * y + e[10] * z + e[14] * w;
2513		this.w = e[3] * x + e[7] * y + e[11] * z + e[15] * w;
2514
2515		return this;
2516
2517	}
2518
2519	divideScalar(scalar) {
2520
2521		return this.multiplyScalar(1 / scalar);
2522
2523	}
2524
2525	setAxisAngleFromQuaternion(q) {
2526
2527		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
2528
2529		// q is assumed to be normalized
2530
2531		this.w = 2 * Math.acos(q.w);
2532
2533		const s = Math.sqrt(1 - q.w * q.w);
2534
2535		if (s < 0.0001) {
2536
2537			this.x = 1;
2538			this.y = 0;
2539			this.z = 0;
2540
2541		} else {
2542
2543			this.x = q.x / s;
2544			this.y = q.y / s;
2545			this.z = q.z / s;
2546
2547		}
2548
2549		return this;
2550
2551	}
2552
2553	setAxisAngleFromRotationMatrix(m) {
2554
2555		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm
2556
2557		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
2558
2559		let angle, x, y, z; // variables for result
2560		const epsilon = 0.01,		// margin to allow for rounding errors
2561			epsilon2 = 0.1,		// margin to distinguish between 0 and 180 degrees
2562
2563			te = m.elements,
2564
2565			m11 = te[0], m12 = te[4], m13 = te[8],
2566			m21 = te[1], m22 = te[5], m23 = te[9],
2567			m31 = te[2], m32 = te[6], m33 = te[10];
2568
2569		if ((Math.abs(m12 - m21) < epsilon) &&
2570			(Math.abs(m13 - m31) < epsilon) &&
2571			(Math.abs(m23 - m32) < epsilon)) {
2572
2573			// singularity found
2574			// first check for identity matrix which must have +1 for all terms
2575			// in leading diagonal and zero in other terms
2576
2577			if ((Math.abs(m12 + m21) < epsilon2) &&
2578				(Math.abs(m13 + m31) < epsilon2) &&
2579				(Math.abs(m23 + m32) < epsilon2) &&
2580				(Math.abs(m11 + m22 + m33 - 3) < epsilon2)) {
2581
2582				// this singularity is identity matrix so angle = 0
2583
2584				this.set(1, 0, 0, 0);
2585
2586				return this; // zero angle, arbitrary axis
2587
2588			}
2589
2590			// otherwise this singularity is angle = 180
2591
2592			angle = Math.PI;
2593
2594			const xx = (m11 + 1) / 2;
2595			const yy = (m22 + 1) / 2;
2596			const zz = (m33 + 1) / 2;
2597			const xy = (m12 + m21) / 4;
2598			const xz = (m13 + m31) / 4;
2599			const yz = (m23 + m32) / 4;
2600
2601			if ((xx > yy) && (xx > zz)) {
2602
2603				// m11 is the largest diagonal term
2604
2605				if (xx < epsilon) {
2606
2607					x = 0;
2608					y = 0.707106781;
2609					z = 0.707106781;
2610
2611				} else {
2612
2613					x = Math.sqrt(xx);
2614					y = xy / x;
2615					z = xz / x;
2616
2617				}
2618
2619			} else if (yy > zz) {
2620
2621				// m22 is the largest diagonal term
2622
2623				if (yy < epsilon) {
2624
2625					x = 0.707106781;
2626					y = 0;
2627					z = 0.707106781;
2628
2629				} else {
2630
2631					y = Math.sqrt(yy);
2632					x = xy / y;
2633					z = yz / y;
2634
2635				}
2636
2637			} else {
2638
2639				// m33 is the largest diagonal term so base result on this
2640
2641				if (zz < epsilon) {
2642
2643					x = 0.707106781;
2644					y = 0.707106781;
2645					z = 0;
2646
2647				} else {
2648
2649					z = Math.sqrt(zz);
2650					x = xz / z;
2651					y = yz / z;
2652
2653				}
2654
2655			}
2656
2657			this.set(x, y, z, angle);
2658
2659			return this; // return 180 deg rotation
2660
2661		}
2662
2663		// as we have reached here there are no singularities so we can handle normally
2664
2665		let s = Math.sqrt((m32 - m23) * (m32 - m23) +
2666			(m13 - m31) * (m13 - m31) +
2667			(m21 - m12) * (m21 - m12)); // used to normalize
2668
2669		if (Math.abs(s) < 0.001) s = 1;
2670
2671		// prevent divide by zero, should not happen if matrix is orthogonal and should be
2672		// caught by singularity test above, but I've left it in just in case
2673
2674		this.x = (m32 - m23) / s;
2675		this.y = (m13 - m31) / s;
2676		this.z = (m21 - m12) / s;
2677		this.w = Math.acos((m11 + m22 + m33 - 1) / 2);
2678
2679		return this;
2680
2681	}
2682
2683	min(v) {
2684
2685		this.x = Math.min(this.x, v.x);
2686		this.y = Math.min(this.y, v.y);
2687		this.z = Math.min(this.z, v.z);
2688		this.w = Math.min(this.w, v.w);
2689
2690		return this;
2691
2692	}
2693
2694	max(v) {
2695
2696		this.x = Math.max(this.x, v.x);
2697		this.y = Math.max(this.y, v.y);
2698		this.z = Math.max(this.z, v.z);
2699		this.w = Math.max(this.w, v.w);
2700
2701		return this;
2702
2703	}
2704
2705	clamp(min, max) {
2706
2707		// assumes min < max, componentwise
2708
2709		this.x = Math.max(min.x, Math.min(max.x, this.x));
2710		this.y = Math.max(min.y, Math.min(max.y, this.y));
2711		this.z = Math.max(min.z, Math.min(max.z, this.z));
2712		this.w = Math.max(min.w, Math.min(max.w, this.w));
2713
2714		return this;
2715
2716	}
2717
2718	clampScalar(minVal, maxVal) {
2719
2720		this.x = Math.max(minVal, Math.min(maxVal, this.x));
2721		this.y = Math.max(minVal, Math.min(maxVal, this.y));
2722		this.z = Math.max(minVal, Math.min(maxVal, this.z));
2723		this.w = Math.max(minVal, Math.min(maxVal, this.w));
2724
2725		return this;
2726
2727	}
2728
2729	clampLength(min, max) {
2730
2731		const length = this.length();
2732
2733		return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
2734
2735	}
2736
2737	floor() {
2738
2739		this.x = Math.floor(this.x);
2740		this.y = Math.floor(this.y);
2741		this.z = Math.floor(this.z);
2742		this.w = Math.floor(this.w);
2743
2744		return this;
2745
2746	}
2747
2748	ceil() {
2749
2750		this.x = Math.ceil(this.x);
2751		this.y = Math.ceil(this.y);
2752		this.z = Math.ceil(this.z);
2753		this.w = Math.ceil(this.w);
2754
2755		return this;
2756
2757	}
2758
2759	round() {
2760
2761		this.x = Math.round(this.x);
2762		this.y = Math.round(this.y);
2763		this.z = Math.round(this.z);
2764		this.w = Math.round(this.w);
2765
2766		return this;
2767
2768	}
2769
2770	roundToZero() {
2771
2772		this.x = Math.trunc(this.x);
2773		this.y = Math.trunc(this.y);
2774		this.z = Math.trunc(this.z);
2775		this.w = Math.trunc(this.w);
2776
2777		return this;
2778
2779	}
2780
2781	negate() {
2782
2783		this.x = - this.x;
2784		this.y = - this.y;
2785		this.z = - this.z;
2786		this.w = - this.w;
2787
2788		return this;
2789
2790	}
2791
2792	dot(v) {
2793
2794		return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
2795
2796	}
2797
2798	lengthSq() {
2799
2800		return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
2801
2802	}
2803
2804	length() {
2805
2806		return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w);
2807
2808	}
2809
2810	manhattanLength() {
2811
2812		return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z) + Math.abs(this.w);
2813
2814	}
2815
2816	normalize() {
2817
2818		return this.divideScalar(this.length() || 1);
2819
2820	}
2821
2822	setLength(length) {
2823
2824		return this.normalize().multiplyScalar(length);
2825
2826	}
2827
2828	lerp(v, alpha) {
2829
2830		this.x += (v.x - this.x) * alpha;
2831		this.y += (v.y - this.y) * alpha;
2832		this.z += (v.z - this.z) * alpha;
2833		this.w += (v.w - this.w) * alpha;
2834
2835		return this;
2836
2837	}
2838
2839	lerpVectors(v1, v2, alpha) {
2840
2841		this.x = v1.x + (v2.x - v1.x) * alpha;
2842		this.y = v1.y + (v2.y - v1.y) * alpha;
2843		this.z = v1.z + (v2.z - v1.z) * alpha;
2844		this.w = v1.w + (v2.w - v1.w) * alpha;
2845
2846		return this;
2847
2848	}
2849
2850	equals(v) {
2851
2852		return ((v.x === this.x) && (v.y === this.y) && (v.z === this.z) && (v.w === this.w));
2853
2854	}
2855
2856	fromArray(array, offset = 0) {
2857
2858		this.x = array[offset];
2859		this.y = array[offset + 1];
2860		this.z = array[offset + 2];
2861		this.w = array[offset + 3];
2862
2863		return this;
2864
2865	}
2866
2867	toArray(array = [], offset = 0) {
2868
2869		array[offset] = this.x;
2870		array[offset + 1] = this.y;
2871		array[offset + 2] = this.z;
2872		array[offset + 3] = this.w;
2873
2874		return array;
2875
2876	}
2877
2878	fromBufferAttribute(attribute, index) {
2879
2880		this.x = attribute.getX(index);
2881		this.y = attribute.getY(index);
2882		this.z = attribute.getZ(index);
2883		this.w = attribute.getW(index);
2884
2885		return this;
2886
2887	}
2888
2889	random() {
2890
2891		this.x = Math.random();
2892		this.y = Math.random();
2893		this.z = Math.random();
2894		this.w = Math.random();
2895
2896		return this;
2897
2898	}
2899
2900	*[Symbol.iterator]() {
2901
2902		yield this.x;
2903		yield this.y;
2904		yield this.z;
2905		yield this.w;
2906
2907	}
2908
2909}
2910
2911/*
2912 In options, we can specify:
2913 * Texture parameters for an auto-generated target texture
2914 * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers
2915*/
2916class RenderTarget extends EventDispatcher {
2917
2918	constructor(width = 1, height = 1, options = {}) {
2919
2920		super();
2921
2922		this.isRenderTarget = true;
2923
2924		this.width = width;
2925		this.height = height;
2926		this.depth = 1;
2927
2928		this.scissor = new Vector4(0, 0, width, height);
2929		this.scissorTest = false;
2930
2931		this.viewport = new Vector4(0, 0, width, height);
2932
2933		const image = { width: width, height: height, depth: 1 };
2934
2935		if (options.encoding !== undefined) {
2936
2937			// @deprecated, r152
2938			warnOnce('THREE.WebGLRenderTarget: option.encoding has been replaced by option.colorSpace.');
2939			options.colorSpace = options.encoding === sRGBEncoding ? SRGBColorSpace : NoColorSpace;
2940
2941		}
2942
2943		options = Object.assign({
2944			generateMipmaps: false,
2945			internalFormat: null,
2946			minFilter: LinearFilter,
2947			depthBuffer: true,
2948			stencilBuffer: false,
2949			depthTexture: null,
2950			samples: 0
2951		}, options);
2952
2953		this.texture = new Texture(image, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.colorSpace);
2954		this.texture.isRenderTargetTexture = true;
2955
2956		this.texture.flipY = false;
2957		this.texture.generateMipmaps = options.generateMipmaps;
2958		this.texture.internalFormat = options.internalFormat;
2959
2960		this.depthBuffer = options.depthBuffer;
2961		this.stencilBuffer = options.stencilBuffer;
2962
2963		this.depthTexture = options.depthTexture;
2964
2965		this.samples = options.samples;
2966
2967	}
2968
2969	setSize(width, height, depth = 1) {
2970
2971		if (this.width !== width || this.height !== height || this.depth !== depth) {
2972
2973			this.width = width;
2974			this.height = height;
2975			this.depth = depth;
2976
2977			this.texture.image.width = width;
2978			this.texture.image.height = height;
2979			this.texture.image.depth = depth;
2980
2981			this.dispose();
2982
2983		}
2984
2985		this.viewport.set(0, 0, width, height);
2986		this.scissor.set(0, 0, width, height);
2987
2988	}
2989
2990	clone() {
2991
2992		return new this.constructor().copy(this);
2993
2994	}
2995
2996	copy(source) {
2997
2998		this.width = source.width;
2999		this.height = source.height;
3000		this.depth = source.depth;
3001
3002		this.scissor.copy(source.scissor);
3003		this.scissorTest = source.scissorTest;
3004
3005		this.viewport.copy(source.viewport);
3006
3007		this.texture = source.texture.clone();
3008		this.texture.isRenderTargetTexture = true;
3009
3010		// ensure image object is not shared, see #20328
3011
3012		const image = Object.assign({}, source.texture.image);
3013		this.texture.source = new Source(image);
3014
3015		this.depthBuffer = source.depthBuffer;
3016		this.stencilBuffer = source.stencilBuffer;
3017
3018		if (source.depthTexture !== null) this.depthTexture = source.depthTexture.clone();
3019
3020		this.samples = source.samples;
3021
3022		return this;
3023
3024	}
3025
3026	dispose() {
3027
3028		this.dispatchEvent({ type: 'dispose' });
3029
3030	}
3031
3032}
3033
3034class WebGLRenderTarget extends RenderTarget {
3035
3036	constructor(width = 1, height = 1, options = {}) {
3037
3038		super(width, height, options);
3039
3040		this.isWebGLRenderTarget = true;
3041
3042	}
3043
3044}
3045
3046class DataArrayTexture extends Texture {
3047
3048	constructor(data = null, width = 1, height = 1, depth = 1) {
3049
3050		super(null);
3051
3052		this.isDataArrayTexture = true;
3053
3054		this.image = { data, width, height, depth };
3055
3056		this.magFilter = NearestFilter;
3057		this.minFilter = NearestFilter;
3058
3059		this.wrapR = ClampToEdgeWrapping;
3060
3061		this.generateMipmaps = false;
3062		this.flipY = false;
3063		this.unpackAlignment = 1;
3064
3065	}
3066
3067}
3068
3069class WebGLArrayRenderTarget extends WebGLRenderTarget {
3070
3071	constructor(width = 1, height = 1, depth = 1, options = {}) {
3072
3073		super(width, height, options);
3074
3075		this.isWebGLArrayRenderTarget = true;
3076
3077		this.depth = depth;
3078
3079		this.texture = new DataArrayTexture(null, width, height, depth);
3080
3081		this.texture.isRenderTargetTexture = true;
3082
3083	}
3084
3085}
3086
3087class Data3DTexture extends Texture {
3088
3089	constructor(data = null, width = 1, height = 1, depth = 1) {
3090
3091		// We're going to add .setXXX() methods for setting properties later.
3092		// Users can still set in DataTexture3D directly.
3093		//
3094		//	const texture = new THREE.DataTexture3D( data, width, height, depth );
3095		// 	texture.anisotropy = 16;
3096		//
3097		// See #14839
3098
3099		super(null);
3100
3101		this.isData3DTexture = true;
3102
3103		this.image = { data, width, height, depth };
3104
3105		this.magFilter = NearestFilter;
3106		this.minFilter = NearestFilter;
3107
3108		this.wrapR = ClampToEdgeWrapping;
3109
3110		this.generateMipmaps = false;
3111		this.flipY = false;
3112		this.unpackAlignment = 1;
3113
3114	}
3115
3116}
3117
3118class WebGL3DRenderTarget extends WebGLRenderTarget {
3119
3120	constructor(width = 1, height = 1, depth = 1, options = {}) {
3121
3122		super(width, height, options);
3123
3124		this.isWebGL3DRenderTarget = true;
3125
3126		this.depth = depth;
3127
3128		this.texture = new Data3DTexture(null, width, height, depth);
3129
3130		this.texture.isRenderTargetTexture = true;
3131
3132	}
3133
3134}
3135
3136class WebGLMultipleRenderTargets extends WebGLRenderTarget {
3137
3138	constructor(width = 1, height = 1, count = 1, options = {}) {
3139
3140		super(width, height, options);
3141
3142		this.isWebGLMultipleRenderTargets = true;
3143
3144		const texture = this.texture;
3145
3146		this.texture = [];
3147
3148		for (let i = 0; i < count; i++) {
3149
3150			this.texture[i] = texture.clone();
3151			this.texture[i].isRenderTargetTexture = true;
3152
3153		}
3154
3155	}
3156
3157	setSize(width, height, depth = 1) {
3158
3159		if (this.width !== width || this.height !== height || this.depth !== depth) {
3160
3161			this.width = width;
3162			this.height = height;
3163			this.depth = depth;
3164
3165			for (let i = 0, il = this.texture.length; i < il; i++) {
3166
3167				this.texture[i].image.width = width;
3168				this.texture[i].image.height = height;
3169				this.texture[i].image.depth = depth;
3170
3171			}
3172
3173			this.dispose();
3174
3175		}
3176
3177		this.viewport.set(0, 0, width, height);
3178		this.scissor.set(0, 0, width, height);
3179
3180	}
3181
3182	copy(source) {
3183
3184		this.dispose();
3185
3186		this.width = source.width;
3187		this.height = source.height;
3188		this.depth = source.depth;
3189
3190		this.scissor.copy(source.scissor);
3191		this.scissorTest = source.scissorTest;
3192
3193		this.viewport.copy(source.viewport);
3194
3195		this.depthBuffer = source.depthBuffer;
3196		this.stencilBuffer = source.stencilBuffer;
3197
3198		if (source.depthTexture !== null) this.depthTexture = source.depthTexture.clone();
3199
3200		this.texture.length = 0;
3201
3202		for (let i = 0, il = source.texture.length; i < il; i++) {
3203
3204			this.texture[i] = source.texture[i].clone();
3205			this.texture[i].isRenderTargetTexture = true;
3206
3207		}
3208
3209		return this;
3210
3211	}
3212
3213}
3214
3215class Quaternion {
3216
3217	constructor(x = 0, y = 0, z = 0, w = 1) {
3218
3219		this.isQuaternion = true;
3220
3221		this._x = x;
3222		this._y = y;
3223		this._z = z;
3224		this._w = w;
3225
3226	}
3227
3228	static slerpFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
3229
3230		// fuzz-free, array-based Quaternion SLERP operation
3231
3232		let x0 = src0[srcOffset0 + 0],
3233			y0 = src0[srcOffset0 + 1],
3234			z0 = src0[srcOffset0 + 2],
3235			w0 = src0[srcOffset0 + 3];
3236
3237		const x1 = src1[srcOffset1 + 0],
3238			y1 = src1[srcOffset1 + 1],
3239			z1 = src1[srcOffset1 + 2],
3240			w1 = src1[srcOffset1 + 3];
3241
3242		if (t === 0) {
3243
3244			dst[dstOffset + 0] = x0;
3245			dst[dstOffset + 1] = y0;
3246			dst[dstOffset + 2] = z0;
3247			dst[dstOffset + 3] = w0;
3248			return;
3249
3250		}
3251
3252		if (t === 1) {
3253
3254			dst[dstOffset + 0] = x1;
3255			dst[dstOffset + 1] = y1;
3256			dst[dstOffset + 2] = z1;
3257			dst[dstOffset + 3] = w1;
3258			return;
3259
3260		}
3261
3262		if (w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1) {
3263
3264			let s = 1 - t;
3265			const cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
3266				dir = (cos >= 0 ? 1 : - 1),
3267				sqrSin = 1 - cos * cos;
3268
3269			// Skip the Slerp for tiny steps to avoid numeric problems:
3270			if (sqrSin > Number.EPSILON) {
3271
3272				const sin = Math.sqrt(sqrSin),
3273					len = Math.atan2(sin, cos * dir);
3274
3275				s = Math.sin(s * len) / sin;
3276				t = Math.sin(t * len) / sin;
3277
3278			}
3279
3280			const tDir = t * dir;
3281
3282			x0 = x0 * s + x1 * tDir;
3283			y0 = y0 * s + y1 * tDir;
3284			z0 = z0 * s + z1 * tDir;
3285			w0 = w0 * s + w1 * tDir;
3286
3287			// Normalize in case we just did a lerp:
3288			if (s === 1 - t) {
3289
3290				const f = 1 / Math.sqrt(x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0);
3291
3292				x0 *= f;
3293				y0 *= f;
3294				z0 *= f;
3295				w0 *= f;
3296
3297			}
3298
3299		}
3300
3301		dst[dstOffset] = x0;
3302		dst[dstOffset + 1] = y0;
3303		dst[dstOffset + 2] = z0;
3304		dst[dstOffset + 3] = w0;
3305
3306	}
3307
3308	static multiplyQuaternionsFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1) {
3309
3310		const x0 = src0[srcOffset0];
3311		const y0 = src0[srcOffset0 + 1];
3312		const z0 = src0[srcOffset0 + 2];
3313		const w0 = src0[srcOffset0 + 3];
3314
3315		const x1 = src1[srcOffset1];
3316		const y1 = src1[srcOffset1 + 1];
3317		const z1 = src1[srcOffset1 + 2];
3318		const w1 = src1[srcOffset1 + 3];
3319
3320		dst[dstOffset] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
3321		dst[dstOffset + 1] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
3322		dst[dstOffset + 2] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
3323		dst[dstOffset + 3] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
3324
3325		return dst;
3326
3327	}
3328
3329	get x() {
3330
3331		return this._x;
3332
3333	}
3334
3335	set x(value) {
3336
3337		this._x = value;
3338		this._onChangeCallback();
3339
3340	}
3341
3342	get y() {
3343
3344		return this._y;
3345
3346	}
3347
3348	set y(value) {
3349
3350		this._y = value;
3351		this._onChangeCallback();
3352
3353	}
3354
3355	get z() {
3356
3357		return this._z;
3358
3359	}
3360
3361	set z(value) {
3362
3363		this._z = value;
3364		this._onChangeCallback();
3365
3366	}
3367
3368	get w() {
3369
3370		return this._w;
3371
3372	}
3373
3374	set w(value) {
3375
3376		this._w = value;
3377		this._onChangeCallback();
3378
3379	}
3380
3381	set(x, y, z, w) {
3382
3383		this._x = x;
3384		this._y = y;
3385		this._z = z;
3386		this._w = w;
3387
3388		this._onChangeCallback();
3389
3390		return this;
3391
3392	}
3393
3394	clone() {
3395
3396		return new this.constructor(this._x, this._y, this._z, this._w);
3397
3398	}
3399
3400	copy(quaternion) {
3401
3402		this._x = quaternion.x;
3403		this._y = quaternion.y;
3404		this._z = quaternion.z;
3405		this._w = quaternion.w;
3406
3407		this._onChangeCallback();
3408
3409		return this;
3410
3411	}
3412
3413	setFromEuler(euler, update = true) {
3414
3415		const x = euler._x, y = euler._y, z = euler._z, order = euler._order;
3416
3417		// http://www.mathworks.com/matlabcentral/fileexchange/
3418		// 	20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
3419		//	content/SpinCalc.m
3420
3421		const cos = Math.cos;
3422		const sin = Math.sin;
3423
3424		const c1 = cos(x / 2);
3425		const c2 = cos(y / 2);
3426		const c3 = cos(z / 2);
3427
3428		const s1 = sin(x / 2);
3429		const s2 = sin(y / 2);
3430		const s3 = sin(z / 2);
3431
3432		switch (order) {
3433
3434			case 'XYZ':
3435				this._x = s1 * c2 * c3 + c1 * s2 * s3;
3436				this._y = c1 * s2 * c3 - s1 * c2 * s3;
3437				this._z = c1 * c2 * s3 + s1 * s2 * c3;
3438				this._w = c1 * c2 * c3 - s1 * s2 * s3;
3439				break;
3440
3441			case 'YXZ':
3442				this._x = s1 * c2 * c3 + c1 * s2 * s3;
3443				this._y = c1 * s2 * c3 - s1 * c2 * s3;
3444				this._z = c1 * c2 * s3 - s1 * s2 * c3;
3445				this._w = c1 * c2 * c3 + s1 * s2 * s3;
3446				break;
3447
3448			case 'ZXY':
3449				this._x = s1 * c2 * c3 - c1 * s2 * s3;
3450				this._y = c1 * s2 * c3 + s1 * c2 * s3;
3451				this._z = c1 * c2 * s3 + s1 * s2 * c3;
3452				this._w = c1 * c2 * c3 - s1 * s2 * s3;
3453				break;
3454
3455			case 'ZYX':
3456				this._x = s1 * c2 * c3 - c1 * s2 * s3;
3457				this._y = c1 * s2 * c3 + s1 * c2 * s3;
3458				this._z = c1 * c2 * s3 - s1 * s2 * c3;
3459				this._w = c1 * c2 * c3 + s1 * s2 * s3;
3460				break;
3461
3462			case 'YZX':
3463				this._x = s1 * c2 * c3 + c1 * s2 * s3;
3464				this._y = c1 * s2 * c3 + s1 * c2 * s3;
3465				this._z = c1 * c2 * s3 - s1 * s2 * c3;
3466				this._w = c1 * c2 * c3 - s1 * s2 * s3;
3467				break;
3468
3469			case 'XZY':
3470				this._x = s1 * c2 * c3 - c1 * s2 * s3;
3471				this._y = c1 * s2 * c3 - s1 * c2 * s3;
3472				this._z = c1 * c2 * s3 + s1 * s2 * c3;
3473				this._w = c1 * c2 * c3 + s1 * s2 * s3;
3474				break;
3475
3476			default:
3477				console.warn('THREE.Quaternion: .setFromEuler() encountered an unknown order: ' + order);
3478
3479		}
3480
3481		if (update === true) this._onChangeCallback();
3482
3483		return this;
3484
3485	}
3486
3487	setFromAxisAngle(axis, angle) {
3488
3489		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
3490
3491		// assumes axis is normalized
3492
3493		const halfAngle = angle / 2, s = Math.sin(halfAngle);
3494
3495		this._x = axis.x * s;
3496		this._y = axis.y * s;
3497		this._z = axis.z * s;
3498		this._w = Math.cos(halfAngle);
3499
3500		this._onChangeCallback();
3501
3502		return this;
3503
3504	}
3505
3506	setFromRotationMatrix(m) {
3507
3508		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
3509
3510		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
3511
3512		const te = m.elements,
3513
3514			m11 = te[0], m12 = te[4], m13 = te[8],
3515			m21 = te[1], m22 = te[5], m23 = te[9],
3516			m31 = te[2], m32 = te[6], m33 = te[10],
3517
3518			trace = m11 + m22 + m33;
3519
3520		if (trace > 0) {
3521
3522			const s = 0.5 / Math.sqrt(trace + 1.0);
3523
3524			this._w = 0.25 / s;
3525			this._x = (m32 - m23) * s;
3526			this._y = (m13 - m31) * s;
3527			this._z = (m21 - m12) * s;
3528
3529		} else if (m11 > m22 && m11 > m33) {
3530
3531			const s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);
3532
3533			this._w = (m32 - m23) / s;
3534			this._x = 0.25 * s;
3535			this._y = (m12 + m21) / s;
3536			this._z = (m13 + m31) / s;
3537
3538		} else if (m22 > m33) {
3539
3540			const s = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);
3541
3542			this._w = (m13 - m31) / s;
3543			this._x = (m12 + m21) / s;
3544			this._y = 0.25 * s;
3545			this._z = (m23 + m32) / s;
3546
3547		} else {
3548
3549			const s = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);
3550
3551			this._w = (m21 - m12) / s;
3552			this._x = (m13 + m31) / s;
3553			this._y = (m23 + m32) / s;
3554			this._z = 0.25 * s;
3555
3556		}
3557
3558		this._onChangeCallback();
3559
3560		return this;
3561
3562	}
3563
3564	setFromUnitVectors(vFrom, vTo) {
3565
3566		// assumes direction vectors vFrom and vTo are normalized
3567
3568		let r = vFrom.dot(vTo) + 1;
3569
3570		if (r < Number.EPSILON) {
3571
3572			// vFrom and vTo point in opposite directions
3573
3574			r = 0;
3575
3576			if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
3577
3578				this._x = - vFrom.y;
3579				this._y = vFrom.x;
3580				this._z = 0;
3581				this._w = r;
3582
3583			} else {
3584
3585				this._x = 0;
3586				this._y = - vFrom.z;
3587				this._z = vFrom.y;
3588				this._w = r;
3589
3590			}
3591
3592		} else {
3593
3594			// crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3
3595
3596			this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
3597			this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
3598			this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
3599			this._w = r;
3600
3601		}
3602
3603		return this.normalize();
3604
3605	}
3606
3607	angleTo(q) {
3608
3609		return 2 * Math.acos(Math.abs(clamp(this.dot(q), - 1, 1)));
3610
3611	}
3612
3613	rotateTowards(q, step) {
3614
3615		const angle = this.angleTo(q);
3616
3617		if (angle === 0) return this;
3618
3619		const t = Math.min(1, step / angle);
3620
3621		this.slerp(q, t);
3622
3623		return this;
3624
3625	}
3626
3627	identity() {
3628
3629		return this.set(0, 0, 0, 1);
3630
3631	}
3632
3633	invert() {
3634
3635		// quaternion is assumed to have unit length
3636
3637		return this.conjugate();
3638
3639	}
3640
3641	conjugate() {
3642
3643		this._x *= - 1;
3644		this._y *= - 1;
3645		this._z *= - 1;
3646
3647		this._onChangeCallback();
3648
3649		return this;
3650
3651	}
3652
3653	dot(v) {
3654
3655		return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
3656
3657	}
3658
3659	lengthSq() {
3660
3661		return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
3662
3663	}
3664
3665	length() {
3666
3667		return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w);
3668
3669	}
3670
3671	normalize() {
3672
3673		let l = this.length();
3674
3675		if (l === 0) {
3676
3677			this._x = 0;
3678			this._y = 0;
3679			this._z = 0;
3680			this._w = 1;
3681
3682		} else {
3683
3684			l = 1 / l;
3685
3686			this._x = this._x * l;
3687			this._y = this._y * l;
3688			this._z = this._z * l;
3689			this._w = this._w * l;
3690
3691		}
3692
3693		this._onChangeCallback();
3694
3695		return this;
3696
3697	}
3698
3699	multiply(q) {
3700
3701		return this.multiplyQuaternions(this, q);
3702
3703	}
3704
3705	premultiply(q) {
3706
3707		return this.multiplyQuaternions(q, this);
3708
3709	}
3710
3711	multiplyQuaternions(a, b) {
3712
3713		// from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
3714
3715		const qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;
3716		const qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;
3717
3718		this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
3719		this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
3720		this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
3721		this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
3722
3723		this._onChangeCallback();
3724
3725		return this;
3726
3727	}
3728
3729	slerp(qb, t) {
3730
3731		if (t === 0) return this;
3732		if (t === 1) return this.copy(qb);
3733
3734		const x = this._x, y = this._y, z = this._z, w = this._w;
3735
3736		// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
3737
3738		let cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
3739
3740		if (cosHalfTheta < 0) {
3741
3742			this._w = - qb._w;
3743			this._x = - qb._x;
3744			this._y = - qb._y;
3745			this._z = - qb._z;
3746
3747			cosHalfTheta = - cosHalfTheta;
3748
3749		} else {
3750
3751			this.copy(qb);
3752
3753		}
3754
3755		if (cosHalfTheta >= 1.0) {
3756
3757			this._w = w;
3758			this._x = x;
3759			this._y = y;
3760			this._z = z;
3761
3762			return this;
3763
3764		}
3765
3766		const sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
3767
3768		if (sqrSinHalfTheta <= Number.EPSILON) {
3769
3770			const s = 1 - t;
3771			this._w = s * w + t * this._w;
3772			this._x = s * x + t * this._x;
3773			this._y = s * y + t * this._y;
3774			this._z = s * z + t * this._z;
3775
3776			this.normalize(); // normalize calls _onChangeCallback()
3777
3778			return this;
3779
3780		}
3781
3782		const sinHalfTheta = Math.sqrt(sqrSinHalfTheta);
3783		const halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta);
3784		const ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta,
3785			ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
3786
3787		this._w = (w * ratioA + this._w * ratioB);
3788		this._x = (x * ratioA + this._x * ratioB);
3789		this._y = (y * ratioA + this._y * ratioB);
3790		this._z = (z * ratioA + this._z * ratioB);
3791
3792		this._onChangeCallback();
3793
3794		return this;
3795
3796	}
3797
3798	slerpQuaternions(qa, qb, t) {
3799
3800		return this.copy(qa).slerp(qb, t);
3801
3802	}
3803
3804	random() {
3805
3806		// Derived from http://planning.cs.uiuc.edu/node198.html
3807		// Note, this source uses w, x, y, z ordering,
3808		// so we swap the order below.
3809
3810		const u1 = Math.random();
3811		const sqrt1u1 = Math.sqrt(1 - u1);
3812		const sqrtu1 = Math.sqrt(u1);
3813
3814		const u2 = 2 * Math.PI * Math.random();
3815
3816		const u3 = 2 * Math.PI * Math.random();
3817
3818		return this.set(
3819			sqrt1u1 * Math.cos(u2),
3820			sqrtu1 * Math.sin(u3),
3821			sqrtu1 * Math.cos(u3),
3822			sqrt1u1 * Math.sin(u2),
3823		);
3824
3825	}
3826
3827	equals(quaternion) {
3828
3829		return (quaternion._x === this._x) && (quaternion._y === this._y) && (quaternion._z === this._z) && (quaternion._w === this._w);
3830
3831	}
3832
3833	fromArray(array, offset = 0) {
3834
3835		this._x = array[offset];
3836		this._y = array[offset + 1];
3837		this._z = array[offset + 2];
3838		this._w = array[offset + 3];
3839
3840		this._onChangeCallback();
3841
3842		return this;
3843
3844	}
3845
3846	toArray(array = [], offset = 0) {
3847
3848		array[offset] = this._x;
3849		array[offset + 1] = this._y;
3850		array[offset + 2] = this._z;
3851		array[offset + 3] = this._w;
3852
3853		return array;
3854
3855	}
3856
3857	fromBufferAttribute(attribute, index) {
3858
3859		this._x = attribute.getX(index);
3860		this._y = attribute.getY(index);
3861		this._z = attribute.getZ(index);
3862		this._w = attribute.getW(index);
3863
3864		this._onChangeCallback();
3865
3866		return this;
3867
3868	}
3869
3870	toJSON() {
3871
3872		return this.toArray();
3873
3874	}
3875
3876	_onChange(callback) {
3877
3878		this._onChangeCallback = callback;
3879
3880		return this;
3881
3882	}
3883
3884	_onChangeCallback() { }
3885
3886	*[Symbol.iterator]() {
3887
3888		yield this._x;
3889		yield this._y;
3890		yield this._z;
3891		yield this._w;
3892
3893	}
3894
3895}
3896
3897class Vector3 {
3898
3899	constructor(x = 0, y = 0, z = 0) {
3900
3901		Vector3.prototype.isVector3 = true;
3902
3903		this.x = x;
3904		this.y = y;
3905		this.z = z;
3906
3907	}
3908
3909	set(x, y, z) {
3910
3911		if (z === undefined) z = this.z; // sprite.scale.set(x,y)
3912
3913		this.x = x;
3914		this.y = y;
3915		this.z = z;
3916
3917		return this;
3918
3919	}
3920
3921	setScalar(scalar) {
3922
3923		this.x = scalar;
3924		this.y = scalar;
3925		this.z = scalar;
3926
3927		return this;
3928
3929	}
3930
3931	setX(x) {
3932
3933		this.x = x;
3934
3935		return this;
3936
3937	}
3938
3939	setY(y) {
3940
3941		this.y = y;
3942
3943		return this;
3944
3945	}
3946
3947	setZ(z) {
3948
3949		this.z = z;
3950
3951		return this;
3952
3953	}
3954
3955	setComponent(index, value) {
3956
3957		switch (index) {
3958
3959			case 0: this.x = value; break;
3960			case 1: this.y = value; break;
3961			case 2: this.z = value; break;
3962			default: throw new Error('index is out of range: ' + index);
3963
3964		}
3965
3966		return this;
3967
3968	}
3969
3970	getComponent(index) {
3971
3972		switch (index) {
3973
3974			case 0: return this.x;
3975			case 1: return this.y;
3976			case 2: return this.z;
3977			default: throw new Error('index is out of range: ' + index);
3978
3979		}
3980
3981	}
3982
3983	clone() {
3984
3985		return new this.constructor(this.x, this.y, this.z);
3986
3987	}
3988
3989	copy(v) {
3990
3991		this.x = v.x;
3992		this.y = v.y;
3993		this.z = v.z;
3994
3995		return this;
3996
3997	}
3998
3999	add(v) {
4000
4001		this.x += v.x;
4002		this.y += v.y;
4003		this.z += v.z;
4004
4005		return this;
4006
4007	}
4008
4009	addScalar(s) {
4010
4011		this.x += s;
4012		this.y += s;
4013		this.z += s;
4014
4015		return this;
4016
4017	}
4018
4019	addVectors(a, b) {
4020
4021		this.x = a.x + b.x;
4022		this.y = a.y + b.y;
4023		this.z = a.z + b.z;
4024
4025		return this;
4026
4027	}
4028
4029	addScaledVector(v, s) {
4030
4031		this.x += v.x * s;
4032		this.y += v.y * s;
4033		this.z += v.z * s;
4034
4035		return this;
4036
4037	}
4038
4039	sub(v) {
4040
4041		this.x -= v.x;
4042		this.y -= v.y;
4043		this.z -= v.z;
4044
4045		return this;
4046
4047	}
4048
4049	subScalar(s) {
4050
4051		this.x -= s;
4052		this.y -= s;
4053		this.z -= s;
4054
4055		return this;
4056
4057	}
4058
4059	subVectors(a, b) {
4060
4061		this.x = a.x - b.x;
4062		this.y = a.y - b.y;
4063		this.z = a.z - b.z;
4064
4065		return this;
4066
4067	}
4068
4069	multiply(v) {
4070
4071		this.x *= v.x;
4072		this.y *= v.y;
4073		this.z *= v.z;
4074
4075		return this;
4076
4077	}
4078
4079	multiplyScalar(scalar) {
4080
4081		this.x *= scalar;
4082		this.y *= scalar;
4083		this.z *= scalar;
4084
4085		return this;
4086
4087	}
4088
4089	multiplyVectors(a, b) {
4090
4091		this.x = a.x * b.x;
4092		this.y = a.y * b.y;
4093		this.z = a.z * b.z;
4094
4095		return this;
4096
4097	}
4098
4099	applyEuler(euler) {
4100
4101		return this.applyQuaternion(_quaternion$4.setFromEuler(euler));
4102
4103	}
4104
4105	applyAxisAngle(axis, angle) {
4106
4107		return this.applyQuaternion(_quaternion$4.setFromAxisAngle(axis, angle));
4108
4109	}
4110
4111	applyMatrix3(m) {
4112
4113		const x = this.x, y = this.y, z = this.z;
4114		const e = m.elements;
4115
4116		this.x = e[0] * x + e[3] * y + e[6] * z;
4117		this.y = e[1] * x + e[4] * y + e[7] * z;
4118		this.z = e[2] * x + e[5] * y + e[8] * z;
4119
4120		return this;
4121
4122	}
4123
4124	applyNormalMatrix(m) {
4125
4126		return this.applyMatrix3(m).normalize();
4127
4128	}
4129
4130	applyMatrix4(m) {
4131
4132		const x = this.x, y = this.y, z = this.z;
4133		const e = m.elements;
4134
4135		const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
4136
4137		this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w;
4138		this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w;
4139		this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w;
4140
4141		return this;
4142
4143	}
4144
4145	applyQuaternion(q) {
4146
4147		// quaternion q is assumed to have unit length
4148
4149		const vx = this.x, vy = this.y, vz = this.z;
4150		const qx = q.x, qy = q.y, qz = q.z, qw = q.w;
4151
4152		// t = 2 * cross( q.xyz, v );
4153		const tx = 2 * (qy * vz - qz * vy);
4154		const ty = 2 * (qz * vx - qx * vz);
4155		const tz = 2 * (qx * vy - qy * vx);
4156
4157		// v + q.w * t + cross( q.xyz, t );
4158		this.x = vx + qw * tx + qy * tz - qz * ty;
4159		this.y = vy + qw * ty + qz * tx - qx * tz;
4160		this.z = vz + qw * tz + qx * ty - qy * tx;
4161
4162		return this;
4163
4164	}
4165
4166	project(camera) {
4167
4168		return this.applyMatrix4(camera.matrixWorldInverse).applyMatrix4(camera.projectionMatrix);
4169
4170	}
4171
4172	unproject(camera) {
4173
4174		return this.applyMatrix4(camera.projectionMatrixInverse).applyMatrix4(camera.matrixWorld);
4175
4176	}
4177
4178	transformDirection(m) {
4179
4180		// input: THREE.Matrix4 affine matrix
4181		// vector interpreted as a direction
4182
4183		const x = this.x, y = this.y, z = this.z;
4184		const e = m.elements;
4185
4186		this.x = e[0] * x + e[4] * y + e[8] * z;
4187		this.y = e[1] * x + e[5] * y + e[9] * z;
4188		this.z = e[2] * x + e[6] * y + e[10] * z;
4189
4190		return this.normalize();
4191
4192	}
4193
4194	divide(v) {
4195
4196		this.x /= v.x;
4197		this.y /= v.y;
4198		this.z /= v.z;
4199
4200		return this;
4201
4202	}
4203
4204	divideScalar(scalar) {
4205
4206		return this.multiplyScalar(1 / scalar);
4207
4208	}
4209
4210	min(v) {
4211
4212		this.x = Math.min(this.x, v.x);
4213		this.y = Math.min(this.y, v.y);
4214		this.z = Math.min(this.z, v.z);
4215
4216		return this;
4217
4218	}
4219
4220	max(v) {
4221
4222		this.x = Math.max(this.x, v.x);
4223		this.y = Math.max(this.y, v.y);
4224		this.z = Math.max(this.z, v.z);
4225
4226		return this;
4227
4228	}
4229
4230	clamp(min, max) {
4231
4232		// assumes min < max, componentwise
4233
4234		this.x = Math.max(min.x, Math.min(max.x, this.x));
4235		this.y = Math.max(min.y, Math.min(max.y, this.y));
4236		this.z = Math.max(min.z, Math.min(max.z, this.z));
4237
4238		return this;
4239
4240	}
4241
4242	clampScalar(minVal, maxVal) {
4243
4244		this.x = Math.max(minVal, Math.min(maxVal, this.x));
4245		this.y = Math.max(minVal, Math.min(maxVal, this.y));
4246		this.z = Math.max(minVal, Math.min(maxVal, this.z));
4247
4248		return this;
4249
4250	}
4251
4252	clampLength(min, max) {
4253
4254		const length = this.length();
4255
4256		return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
4257
4258	}
4259
4260	floor() {
4261
4262		this.x = Math.floor(this.x);
4263		this.y = Math.floor(this.y);
4264		this.z = Math.floor(this.z);
4265
4266		return this;
4267
4268	}
4269
4270	ceil() {
4271
4272		this.x = Math.ceil(this.x);
4273		this.y = Math.ceil(this.y);
4274		this.z = Math.ceil(this.z);
4275
4276		return this;
4277
4278	}
4279
4280	round() {
4281
4282		this.x = Math.round(this.x);
4283		this.y = Math.round(this.y);
4284		this.z = Math.round(this.z);
4285
4286		return this;
4287
4288	}
4289
4290	roundToZero() {
4291
4292		this.x = Math.trunc(this.x);
4293		this.y = Math.trunc(this.y);
4294		this.z = Math.trunc(this.z);
4295
4296		return this;
4297
4298	}
4299
4300	negate() {
4301
4302		this.x = - this.x;
4303		this.y = - this.y;
4304		this.z = - this.z;
4305
4306		return this;
4307
4308	}
4309
4310	dot(v) {
4311
4312		return this.x * v.x + this.y * v.y + this.z * v.z;
4313
4314	}
4315
4316	// TODO lengthSquared?
4317
4318	lengthSq() {
4319
4320		return this.x * this.x + this.y * this.y + this.z * this.z;
4321
4322	}
4323
4324	length() {
4325
4326		return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
4327
4328	}
4329
4330	manhattanLength() {
4331
4332		return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z);
4333
4334	}
4335
4336	normalize() {
4337
4338		return this.divideScalar(this.length() || 1);
4339
4340	}
4341
4342	setLength(length) {
4343
4344		return this.normalize().multiplyScalar(length);
4345
4346	}
4347
4348	lerp(v, alpha) {
4349
4350		this.x += (v.x - this.x) * alpha;
4351		this.y += (v.y - this.y) * alpha;
4352		this.z += (v.z - this.z) * alpha;
4353
4354		return this;
4355
4356	}
4357
4358	lerpVectors(v1, v2, alpha) {
4359
4360		this.x = v1.x + (v2.x - v1.x) * alpha;
4361		this.y = v1.y + (v2.y - v1.y) * alpha;
4362		this.z = v1.z + (v2.z - v1.z) * alpha;
4363
4364		return this;
4365
4366	}
4367
4368	cross(v) {
4369
4370		return this.crossVectors(this, v);
4371
4372	}
4373
4374	crossVectors(a, b) {
4375
4376		const ax = a.x, ay = a.y, az = a.z;
4377		const bx = b.x, by = b.y, bz = b.z;
4378
4379		this.x = ay * bz - az * by;
4380		this.y = az * bx - ax * bz;
4381		this.z = ax * by - ay * bx;
4382
4383		return this;
4384
4385	}
4386
4387	projectOnVector(v) {
4388
4389		const denominator = v.lengthSq();
4390
4391		if (denominator === 0) return this.set(0, 0, 0);
4392
4393		const scalar = v.dot(this) / denominator;
4394
4395		return this.copy(v).multiplyScalar(scalar);
4396
4397	}
4398
4399	projectOnPlane(planeNormal) {
4400
4401		_vector$c.copy(this).projectOnVector(planeNormal);
4402
4403		return this.sub(_vector$c);
4404
4405	}
4406
4407	reflect(normal) {
4408
4409		// reflect incident vector off plane orthogonal to normal
4410		// normal is assumed to have unit length
4411
4412		return this.sub(_vector$c.copy(normal).multiplyScalar(2 * this.dot(normal)));
4413
4414	}
4415
4416	angleTo(v) {
4417
4418		const denominator = Math.sqrt(this.lengthSq() * v.lengthSq());
4419
4420		if (denominator === 0) return Math.PI / 2;
4421
4422		const theta = this.dot(v) / denominator;
4423
4424		// clamp, to handle numerical problems
4425
4426		return Math.acos(clamp(theta, - 1, 1));
4427
4428	}
4429
4430	distanceTo(v) {
4431
4432		return Math.sqrt(this.distanceToSquared(v));
4433
4434	}
4435
4436	distanceToSquared(v) {
4437
4438		const dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
4439
4440		return dx * dx + dy * dy + dz * dz;
4441
4442	}
4443
4444	manhattanDistanceTo(v) {
4445
4446		return Math.abs(this.x - v.x) + Math.abs(this.y - v.y) + Math.abs(this.z - v.z);
4447
4448	}
4449
4450	setFromSpherical(s) {
4451
4452		return this.setFromSphericalCoords(s.radius, s.phi, s.theta);
4453
4454	}
4455
4456	setFromSphericalCoords(radius, phi, theta) {
4457
4458		const sinPhiRadius = Math.sin(phi) * radius;
4459
4460		this.x = sinPhiRadius * Math.sin(theta);
4461		this.y = Math.cos(phi) * radius;
4462		this.z = sinPhiRadius * Math.cos(theta);
4463
4464		return this;
4465
4466	}
4467
4468	setFromCylindrical(c) {
4469
4470		return this.setFromCylindricalCoords(c.radius, c.theta, c.y);
4471
4472	}
4473
4474	setFromCylindricalCoords(radius, theta, y) {
4475