https://www.laserboost.com/img/3d/three.js

183	const ObjectSpaceNormalMap = 1;
184	const ZeroStencilOp = 0;
185	const KeepStencilOp = 7680;
186	const ReplaceStencilOp = 7681;
187	const IncrementStencilOp = 7682;
188	const DecrementStencilOp = 7683;
189	const IncrementWrapStencilOp = 34055;
190	const DecrementWrapStencilOp = 34056;
191	const InvertStencilOp = 5386;
192	const NeverStencilFunc = 512;
193	const LessStencilFunc = 513;
194	const EqualStencilFunc = 514;
195	const LessEqualStencilFunc = 515;
196	const GreaterStencilFunc = 516;
197	const NotEqualStencilFunc = 517;
198	const GreaterEqualStencilFunc = 518;
199	const AlwaysStencilFunc = 519;
200	const StaticDrawUsage = 35044;
201	const DynamicDrawUsage = 35048;
202	const StreamDrawUsage = 35040;
203	const StaticReadUsage = 35045;
204	const DynamicReadUsage = 35049;
205	const StreamReadUsage = 35041;
206	const StaticCopyUsage = 35046;
207	const DynamicCopyUsage = 35050;
208	const StreamCopyUsage = 35042;
209	const GLSL1 = '100';
210	const GLSL3 = '300 es';
211
212	/**
213	 * https://github.com/mrdoob/eventdispatcher.js/
214	 */
215	class EventDispatcher {
216		addEventListener(type, listener) {
217			if (this._listeners === undefined) this._listeners = {};
218			const listeners = this._listeners;
219
220			if (listeners[type] === undefined) {
221				listeners[type] = [];
222			}
223
224			if (listeners[type].indexOf(listener) === -1) {
225				listeners[type].push(listener);
226			}
227		}
228
229		hasEventListener(type, listener) {
230			if (this._listeners === undefined) return false;
231			const listeners = this._listeners;
232			return listeners[type] !== undefined && listeners[type].indexOf(listener) !== -1;
233		}
234
235		removeEventListener(type, listener) {
236			if (this._listeners === undefined) return;
237			const listeners = this._listeners;
238			const listenerArray = listeners[type];
239
240			if (listenerArray !== undefined) {
241				const index = listenerArray.indexOf(listener);
242
243				if (index !== -1) {
244					listenerArray.splice(index, 1);
245				}
246			}
247		}
248
249		dispatchEvent(event) {
250			if (this._listeners === undefined) return;
251			const listeners = this._listeners;
252			const listenerArray = listeners[event.type];
253
254			if (listenerArray !== undefined) {
255				event.target = this; // Make a copy, in case listeners are removed while iterating.
256
257				const array = listenerArray.slice(0);
258
259				for (let i = 0, l = array.length; i < l; i++) {
260					array[i].call(this, event);
261				}
262
263				event.target = null;
264			}
265		}
266
267	}
268
269	const _lut = [];
270
271	for (let i = 0; i < 256; i++) {
272		_lut[i] = (i < 16 ? '0' : '') + i.toString(16);
273	}
274
275	let _seed = 1234567;
276	const DEG2RAD = Math.PI / 180;
277	const RAD2DEG = 180 / Math.PI; // http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
278
279	function generateUUID() {
280		const d0 = Math.random() * 0xffffffff | 0;
281		const d1 = Math.random() * 0xffffffff | 0;
282		const d2 = Math.random() * 0xffffffff | 0;
283		const d3 = Math.random() * 0xffffffff | 0;
284		const uuid = _lut[d0 & 0xff] + _lut[d0 >> 8 & 0xff] + _lut[d0 >> 16 & 0xff] + _lut[d0 >> 24 & 0xff] + '-' + _lut[d1 & 0xff] + _lut[d1 >> 8 & 0xff] + '-' + _lut[d1 >> 16 & 0x0f | 0x40] + _lut[d1 >> 24 & 0xff] + '-' + _lut[d2 & 0x3f | 0x80] + _lut[d2 >> 8 & 0xff] + '-' + _lut[d2 >> 16 & 0xff] + _lut[d2 >> 24 & 0xff] + _lut[d3 & 0xff] + _lut[d3 >> 8 & 0xff] + _lut[d3 >> 16 & 0xff] + _lut[d3 >> 24 & 0xff]; // .toUpperCase() here flattens concatenated strings to save heap memory space.
285
286		return uuid.toUpperCase();
287	}
288
289	function clamp(value, min, max) {
290		return Math.max(min, Math.min(max, value));
291	} // compute euclidian modulo of m % n
292	// https://en.wikipedia.org/wiki/Modulo_operation
293
294
295	function euclideanModulo(n, m) {
296		return (n % m + m) % m;
297	} // Linear mapping from range <a1, a2> to range <b1, b2>
298
299
300	function mapLinear(x, a1, a2, b1, b2) {
301		return b1 + (x - a1) * (b2 - b1) / (a2 - a1);
302	} // https://www.gamedev.net/tutorials/programming/general-and-gameplay-programming/inverse-lerp-a-super-useful-yet-often-overlooked-function-r5230/
303
304
305	function inverseLerp(x, y, value) {
306		if (x !== y) {
307			return (value - x) / (y - x);
308		} else {
309			return 0;
310		}
311	} // https://en.wikipedia.org/wiki/Linear_interpolation
312
313
314	function lerp(x, y, t) {
315		return (1 - t) * x + t * y;
316	} // http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/
317
318
319	function damp(x, y, lambda, dt) {
320		return lerp(x, y, 1 - Math.exp(-lambda * dt));
321	} // https://www.desmos.com/calculator/vcsjnyz7x4
322
323
324	function pingpong(x, length = 1) {
325		return length - Math.abs(euclideanModulo(x, length * 2) - length);
326	} // http://en.wikipedia.org/wiki/Smoothstep
327
328
329	function smoothstep(x, min, max) {
330		if (x <= min) return 0;
331		if (x >= max) return 1;
332		x = (x - min) / (max - min);
333		return x * x * (3 - 2 * x);
334	}
335
336	function smootherstep(x, min, max) {
337		if (x <= min) return 0;
338		if (x >= max) return 1;
339		x = (x - min) / (max - min);
340		return x * x * x * (x * (x * 6 - 15) + 10);
341	} // Random integer from <low, high> interval
342
343
344	function randInt(low, high) {
345		return low + Math.floor(Math.random() * (high - low + 1));
346	} // Random float from <low, high> interval
347
348
349	function randFloat(low, high) {
350		return low + Math.random() * (high - low);
351	} // Random float from <-range/2, range/2> interval
352
353
354	function randFloatSpread(range) {
355		return range * (0.5 - Math.random());
356	}

393		const c2 = cos(b / 2);
394		const s2 = sin(b / 2);
395		const c13 = cos((a + c) / 2);
396		const s13 = sin((a + c) / 2);
397		const c1_3 = cos((a - c) / 2);
398		const s1_3 = sin((a - c) / 2);
399		const c3_1 = cos((c - a) / 2);
400		const s3_1 = sin((c - a) / 2);
401
402		switch (order) {
403			case 'XYX':
404				q.set(c2 * s13, s2 * c1_3, s2 * s1_3, c2 * c13);
405				break;
406
407			case 'YZY':
408				q.set(s2 * s1_3, c2 * s13, s2 * c1_3, c2 * c13);
409				break;
410
411			case 'ZXZ':
412				q.set(s2 * c1_3, s2 * s1_3, c2 * s13, c2 * c13);
413				break;
414
415			case 'XZX':
416				q.set(c2 * s13, s2 * s3_1, s2 * c3_1, c2 * c13);
417				break;
418
419			case 'YXY':
420				q.set(s2 * c3_1, c2 * s13, s2 * s3_1, c2 * c13);
421				break;
422
423			case 'ZYZ':
424				q.set(s2 * s3_1, s2 * c3_1, c2 * s13, c2 * c13);
425				break;
426
427			default:
428				console.warn('THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: ' + order);
429		}
430	}
431
432	var MathUtils = /*#__PURE__*/Object.freeze({
433		__proto__: null,
434		DEG2RAD: DEG2RAD,
435		RAD2DEG: RAD2DEG,
436		generateUUID: generateUUID,
437		clamp: clamp,
438		euclideanModulo: euclideanModulo,
439		mapLinear: mapLinear,
440		inverseLerp: inverseLerp,
441		lerp: lerp,
442		damp: damp,
443		pingpong: pingpong,
444		smoothstep: smoothstep,
445		smootherstep: smootherstep,
446		randInt: randInt,
447		randFloat: randFloat,
448		randFloatSpread: randFloatSpread,
449		seededRandom: seededRandom,
450		degToRad: degToRad,
451		radToDeg: radToDeg,
452		isPowerOfTwo: isPowerOfTwo,
453		ceilPowerOfTwo: ceilPowerOfTwo,
454		floorPowerOfTwo: floorPowerOfTwo,
455		setQuaternionFromProperEuler: setQuaternionFromProperEuler
456	});
457
458	class Vector2 {
459		constructor(x = 0, y = 0) {
460			this.x = x;
461			this.y = y;
462		}
463
464		get width() {
465			return this.x;
466		}
467
468		set width(value) {
469			this.x = value;
470		}
471
472		get height() {
473			return this.y;
474		}
475
476		set height(value) {
477			this.y = value;
478		}
479
480		set(x, y) {
481			this.x = x;
482			this.y = y;
483			return this;
484		}
485
486		setScalar(scalar) {
487			this.x = scalar;
488			this.y = scalar;
489			return this;
490		}
491
492		setX(x) {
493			this.x = x;
494			return this;
495		}
496
497		setY(y) {
498			this.y = y;
499			return this;
500		}
501
502		setComponent(index, value) {
503			switch (index) {
504				case 0:
505					this.x = value;
506					break;
507
508				case 1:
509					this.y = value;
510					break;
511
512				default:
513					throw new Error('index is out of range: ' + index);
514			}
515
516			return this;
517		}
518
519		getComponent(index) {
520			switch (index) {
521				case 0:
522					return this.x;
523
524				case 1:
525					return this.y;
526
527				default:
528					throw new Error('index is out of range: ' + index);
529			}
530		}
531
532		clone() {
533			return new this.constructor(this.x, this.y);
534		}
535
536		copy(v) {
537			this.x = v.x;
538			this.y = v.y;
539			return this;
540		}
541
542		add(v, w) {
543			if (w !== undefined) {
544				console.warn('THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.');
545				return this.addVectors(v, w);
546			}
547
548			this.x += v.x;
549			this.y += v.y;
550			return this;
551		}
552
553		addScalar(s) {
554			this.x += s;
555			this.y += s;
556			return this;
557		}
558
559		addVectors(a, b) {
560			this.x = a.x + b.x;
561			this.y = a.y + b.y;
562			return this;
563		}
564
565		addScaledVector(v, s) {
566			this.x += v.x * s;
567			this.y += v.y * s;
568			return this;
569		}
570
571		sub(v, w) {
572			if (w !== undefined) {
573				console.warn('THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.');
574				return this.subVectors(v, w);
575			}
576
577			this.x -= v.x;
578			this.y -= v.y;
579			return this;
580		}
581
582		subScalar(s) {
583			this.x -= s;
584			this.y -= s;
585			return this;
586		}
587
588		subVectors(a, b) {
589			this.x = a.x - b.x;
590			this.y = a.y - b.y;
591			return this;
592		}
593
594		multiply(v) {
595			this.x *= v.x;
596			this.y *= v.y;
597			return this;
598		}
599
600		multiplyScalar(scalar) {
601			this.x *= scalar;
602			this.y *= scalar;
603			return this;
604		}
605
606		divide(v) {
607			this.x /= v.x;
608			this.y /= v.y;
609			return this;
610		}
611
612		divideScalar(scalar) {
613			return this.multiplyScalar(1 / scalar);
614		}
615
616		applyMatrix3(m) {
617			const x = this.x,
618						y = this.y;
619			const e = m.elements;
620			this.x = e[0] * x + e[3] * y + e[6];
621			this.y = e[1] * x + e[4] * y + e[7];
622			return this;
623		}
624
625		min(v) {
626			this.x = Math.min(this.x, v.x);
627			this.y = Math.min(this.y, v.y);
628			return this;
629		}
630
631		max(v) {
632			this.x = Math.max(this.x, v.x);
633			this.y = Math.max(this.y, v.y);
634			return this;
635		}
636
637		clamp(min, max) {
638			// assumes min < max, componentwise
639			this.x = Math.max(min.x, Math.min(max.x, this.x));
640			this.y = Math.max(min.y, Math.min(max.y, this.y));
641			return this;
642		}
643
644		clampScalar(minVal, maxVal) {
645			this.x = Math.max(minVal, Math.min(maxVal, this.x));
646			this.y = Math.max(minVal, Math.min(maxVal, this.y));
647			return this;
648		}
649
650		clampLength(min, max) {
651			const length = this.length();
652			return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
653		}
654
655		floor() {
656			this.x = Math.floor(this.x);
657			this.y = Math.floor(this.y);
658			return this;
659		}
660
661		ceil() {
662			this.x = Math.ceil(this.x);
663			this.y = Math.ceil(this.y);
664			return this;
665		}
666
667		round() {
668			this.x = Math.round(this.x);
669			this.y = Math.round(this.y);
670			return this;
671		}
672
673		roundToZero() {
674			this.x = this.x < 0 ? Math.ceil(this.x) : Math.floor(this.x);
675			this.y = this.y < 0 ? Math.ceil(this.y) : Math.floor(this.y);
676			return this;
677		}
678
679		negate() {
680			this.x = -this.x;
681			this.y = -this.y;
682			return this;
683		}
684
685		dot(v) {
686			return this.x * v.x + this.y * v.y;
687		}
688
689		cross(v) {
690			return this.x * v.y - this.y * v.x;
691		}
692
693		lengthSq() {
694			return this.x * this.x + this.y * this.y;
695		}
696
697		length() {
698			return Math.sqrt(this.x * this.x + this.y * this.y);
699		}
700
701		manhattanLength() {
702			return Math.abs(this.x) + Math.abs(this.y);
703		}
704
705		normalize() {
706			return this.divideScalar(this.length() || 1);
707		}
708
709		angle() {
710			// computes the angle in radians with respect to the positive x-axis
711			const angle = Math.atan2(-this.y, -this.x) + Math.PI;
712			return angle;
713		}
714
715		distanceTo(v) {
716			return Math.sqrt(this.distanceToSquared(v));
717		}
718
719		distanceToSquared(v) {
720			const dx = this.x - v.x,
721						dy = this.y - v.y;
722			return dx * dx + dy * dy;
723		}
724
725		manhattanDistanceTo(v) {
726			return Math.abs(this.x - v.x) + Math.abs(this.y - v.y);
727		}
728
729		setLength(length) {
730			return this.normalize().multiplyScalar(length);
731		}
732
733		lerp(v, alpha) {
734			this.x += (v.x - this.x) * alpha;
735			this.y += (v.y - this.y) * alpha;
736			return this;
737		}
738
739		lerpVectors(v1, v2, alpha) {
740			this.x = v1.x + (v2.x - v1.x) * alpha;
741			this.y = v1.y + (v2.y - v1.y) * alpha;
742			return this;
743		}
744
745		equals(v) {
746			return v.x === this.x && v.y === this.y;
747		}
748
749		fromArray(array, offset = 0) {
750			this.x = array[offset];
751			this.y = array[offset + 1];
752			return this;
753		}
754
755		toArray(array = [], offset = 0) {
756			array[offset] = this.x;
757			array[offset + 1] = this.y;
758			return array;
759		}
760
761		fromBufferAttribute(attribute, index, offset) {
762			if (offset !== undefined) {
763				console.warn('THREE.Vector2: offset has been removed from .fromBufferAttribute().');
764			}
765
766			this.x = attribute.getX(index);
767			this.y = attribute.getY(index);
768			return this;
769		}
770
771		rotateAround(center, angle) {
772			const c = Math.cos(angle),
773						s = Math.sin(angle);
774			const x = this.x - center.x;
775			const y = this.y - center.y;
776			this.x = x * c - y * s + center.x;
777			this.y = x * s + y * c + center.y;
778			return this;
779		}
780
781		random() {
782			this.x = Math.random();
783			this.y = Math.random();
784			return this;
785		}
786
787		*[Symbol.iterator]() {
788			yield this.x;
789			yield this.y;
790		}
791
792	}
793
794	Vector2.prototype.isVector2 = true;
795
796	class Matrix3 {
797		constructor() {
798			this.elements = [1, 0, 0, 0, 1, 0, 0, 0, 1];
799
800			if (arguments.length > 0) {
801				console.error('THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.');
802			}
803		}
804
805		set(n11, n12, n13, n21, n22, n23, n31, n32, n33) {
806			const te = this.elements;
807			te[0] = n11;
808			te[1] = n21;
809			te[2] = n31;
810			te[3] = n12;
811			te[4] = n22;
812			te[5] = n32;
813			te[6] = n13;
814			te[7] = n23;
815			te[8] = n33;
816			return this;
817		}
818
819		identity() {
820			this.set(1, 0, 0, 0, 1, 0, 0, 0, 1);
821			return this;
822		}
823
824		copy(m) {
825			const te = this.elements;
826			const me = m.elements;
827			te[0] = me[0];
828			te[1] = me[1];
829			te[2] = me[2];
830			te[3] = me[3];
831			te[4] = me[4];
832			te[5] = me[5];
833			te[6] = me[6];
834			te[7] = me[7];
835			te[8] = me[8];
836			return this;
837		}
838
839		extractBasis(xAxis, yAxis, zAxis) {
840			xAxis.setFromMatrix3Column(this, 0);
841			yAxis.setFromMatrix3Column(this, 1);
842			zAxis.setFromMatrix3Column(this, 2);
843			return this;
844		}
845
846		setFromMatrix4(m) {
847			const me = m.elements;
848			this.set(me[0], me[4], me[8], me[1], me[5], me[9], me[2], me[6], me[10]);
849			return this;
850		}
851
852		multiply(m) {
853			return this.multiplyMatrices(this, m);
854		}
855
856		premultiply(m) {
857			return this.multiplyMatrices(m, this);
858		}
859
860		multiplyMatrices(a, b) {
861			const ae = a.elements;
862			const be = b.elements;
863			const te = this.elements;
864			const a11 = ae[0],
865						a12 = ae[3],
866						a13 = ae[6];
867			const a21 = ae[1],
868						a22 = ae[4],
869						a23 = ae[7];
870			const a31 = ae[2],
871						a32 = ae[5],
872						a33 = ae[8];
873			const b11 = be[0],
874						b12 = be[3],
875						b13 = be[6];
876			const b21 = be[1],
877						b22 = be[4],
878						b23 = be[7];
879			const b31 = be[2],
880						b32 = be[5],
881						b33 = be[8];
882			te[0] = a11 * b11 + a12 * b21 + a13 * b31;
883			te[3] = a11 * b12 + a12 * b22 + a13 * b32;
884			te[6] = a11 * b13 + a12 * b23 + a13 * b33;
885			te[1] = a21 * b11 + a22 * b21 + a23 * b31;
886			te[4] = a21 * b12 + a22 * b22 + a23 * b32;
887			te[7] = a21 * b13 + a22 * b23 + a23 * b33;
888			te[2] = a31 * b11 + a32 * b21 + a33 * b31;
889			te[5] = a31 * b12 + a32 * b22 + a33 * b32;
890			te[8] = a31 * b13 + a32 * b23 + a33 * b33;
891			return this;
892		}
893
894		multiplyScalar(s) {
895			const te = this.elements;
896			te[0] *= s;
897			te[3] *= s;
898			te[6] *= s;
899			te[1] *= s;
900			te[4] *= s;
901			te[7] *= s;
902			te[2] *= s;
903			te[5] *= s;
904			te[8] *= s;
905			return this;
906		}
907
908		determinant() {
909			const te = this.elements;
910			const a = te[0],
911						b = te[1],
912						c = te[2],
913						d = te[3],
914						e = te[4],
915						f = te[5],
916						g = te[6],
917						h = te[7],
918						i = te[8];
919			return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;
920		}
921
922		invert() {
923			const te = this.elements,
924						n11 = te[0],
925						n21 = te[1],
926						n31 = te[2],
927						n12 = te[3],
928						n22 = te[4],
929						n32 = te[5],
930						n13 = te[6],
931						n23 = te[7],
932						n33 = te[8],
933						t11 = n33 * n22 - n32 * n23,
934						t12 = n32 * n13 - n33 * n12,
935						t13 = n23 * n12 - n22 * n13,
936						det = n11 * t11 + n21 * t12 + n31 * t13;
937			if (det === 0) return this.set(0, 0, 0, 0, 0, 0, 0, 0, 0);
938			const detInv = 1 / det;
939			te[0] = t11 * detInv;
940			te[1] = (n31 * n23 - n33 * n21) * detInv;
941			te[2] = (n32 * n21 - n31 * n22) * detInv;
942			te[3] = t12 * detInv;
943			te[4] = (n33 * n11 - n31 * n13) * detInv;
944			te[5] = (n31 * n12 - n32 * n11) * detInv;
945			te[6] = t13 * detInv;
946			te[7] = (n21 * n13 - n23 * n11) * detInv;
947			te[8] = (n22 * n11 - n21 * n12) * detInv;
948			return this;
949		}
950
951		transpose() {
952			let tmp;
953			const m = this.elements;
954			tmp = m[1];
955			m[1] = m[3];
956			m[3] = tmp;
957			tmp = m[2];
958			m[2] = m[6];
959			m[6] = tmp;
960			tmp = m[5];
961			m[5] = m[7];
962			m[7] = tmp;
963			return this;
964		}
965
966		getNormalMatrix(matrix4) {
967			return this.setFromMatrix4(matrix4).invert().transpose();
968		}
969
970		transposeIntoArray(r) {
971			const m = this.elements;
972			r[0] = m[0];
973			r[1] = m[3];
974			r[2] = m[6];
975			r[3] = m[1];
976			r[4] = m[4];
977			r[5] = m[7];
978			r[6] = m[2];
979			r[7] = m[5];
980			r[8] = m[8];
981			return this;
982		}
983
984		setUvTransform(tx, ty, sx, sy, rotation, cx, cy) {
985			const c = Math.cos(rotation);
986			const s = Math.sin(rotation);

1175			this.flipY = true;
1176			this.unpackAlignment = 4; // valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
1177			// Values of encoding !== THREE.LinearEncoding only supported on map, envMap and emissiveMap.
1178			//
1179			// Also changing the encoding after already used by a Material will not automatically make the Material
1180			// update. You need to explicitly call Material.needsUpdate to trigger it to recompile.
1181
1182			this.encoding = encoding;
1183			this.userData = {};
1184			this.version = 0;
1185			this.onUpdate = null;
1186			this.isRenderTargetTexture = false;
1187		}
1188
1189		updateMatrix() {
1190			this.matrix.setUvTransform(this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y);
1191		}
1192
1193		clone() {
1194			return new this.constructor().copy(this);
1195		}
1196
1197		copy(source) {
1198			this.name = source.name;
1199			this.image = source.image;
1200			this.mipmaps = source.mipmaps.slice(0);
1201			this.mapping = source.mapping;
1202			this.wrapS = source.wrapS;
1203			this.wrapT = source.wrapT;
1204			this.magFilter = source.magFilter;
1205			this.minFilter = source.minFilter;
1206			this.anisotropy = source.anisotropy;
1207			this.format = source.format;
1208			this.internalFormat = source.internalFormat;
1209			this.type = source.type;
1210			this.offset.copy(source.offset);
1211			this.repeat.copy(source.repeat);
1212			this.center.copy(source.center);
1213			this.rotation = source.rotation;
1214			this.matrixAutoUpdate = source.matrixAutoUpdate;
1215			this.matrix.copy(source.matrix);
1216			this.generateMipmaps = source.generateMipmaps;
1217			this.premultiplyAlpha = source.premultiplyAlpha;
1218			this.flipY = source.flipY;
1219			this.unpackAlignment = source.unpackAlignment;
1220			this.encoding = source.encoding;
1221			this.userData = JSON.parse(JSON.stringify(source.userData));
1222			return this;
1223		}
1224
1225		toJSON(meta) {
1226			const isRootObject = meta === undefined || typeof meta === 'string';
1227
1228			if (!isRootObject && meta.textures[this.uuid] !== undefined) {
1229				return meta.textures[this.uuid];
1230			}
1231
1232			const output = {
1233				metadata: {
1234					version: 4.5,
1235					type: 'Texture',
1236					generator: 'Texture.toJSON'
1237				},
1238				uuid: this.uuid,
1239				name: this.name,
1240				mapping: this.mapping,
1241				repeat: [this.repeat.x, this.repeat.y],
1242				offset: [this.offset.x, this.offset.y],
1243				center: [this.center.x, this.center.y],
1244				rotation: this.rotation,
1245				wrap: [this.wrapS, this.wrapT],
1246				format: this.format,
1247				type: this.type,
1248				encoding: this.encoding,
1249				minFilter: this.minFilter,
1250				magFilter: this.magFilter,
1251				anisotropy: this.anisotropy,
1252				flipY: this.flipY,
1253				premultiplyAlpha: this.premultiplyAlpha,
1254				unpackAlignment: this.unpackAlignment
1255			};
1256
1257			if (this.image !== undefined) {
1258				// TODO: Move to THREE.Image
1259				const image = this.image;
1260
1261				if (image.uuid === undefined) {
1262					image.uuid = generateUUID(); // UGH
1263				}
1264
1265				if (!isRootObject && meta.images[image.uuid] === undefined) {
1266					let url;
1267
1268					if (Array.isArray(image)) {
1269						// process array of images e.g. CubeTexture
1270						url = [];
1271
1272						for (let i = 0, l = image.length; i < l; i++) {
1273							// check cube texture with data textures
1274							if (image[i].isDataTexture) {
1275								url.push(serializeImage(image[i].image));
1276							} else {
1277								url.push(serializeImage(image[i]));
1278							}
1279						}
1280					} else {
1281						// process single image
1282						url = serializeImage(image);
1283					}
1284
1285					meta.images[image.uuid] = {
1286						uuid: image.uuid,
1287						url: url
1288					};
1289				}
1290
1291				output.image = image.uuid;
1292			}
1293
1294			if (JSON.stringify(this.userData) !== '{}') output.userData = this.userData;
1295
1296			if (!isRootObject) {
1297				meta.textures[this.uuid] = output;
1298			}
1299
1300			return output;
1301		}
1302
1303		dispose() {
1304			this.dispatchEvent({
1305				type: 'dispose'
1306			});
1307		}
1308
1309		transformUv(uv) {
1310			if (this.mapping !== UVMapping) return uv;
1311			uv.applyMatrix3(this.matrix);
1312
1313			if (uv.x < 0 || uv.x > 1) {
1314				switch (this.wrapS) {
1315					case RepeatWrapping:
1316						uv.x = uv.x - Math.floor(uv.x);
1317						break;
1318
1319					case ClampToEdgeWrapping:
1320						uv.x = uv.x < 0 ? 0 : 1;
1321						break;
1322
1323					case MirroredRepeatWrapping:
1324						if (Math.abs(Math.floor(uv.x) % 2) === 1) {
1325							uv.x = Math.ceil(uv.x) - uv.x;
1326						} else {
1327							uv.x = uv.x - Math.floor(uv.x);
1328						}
1329
1330						break;
1331				}
1332			}
1333
1334			if (uv.y < 0 || uv.y > 1) {
1335				switch (this.wrapT) {
1336					case RepeatWrapping:
1337						uv.y = uv.y - Math.floor(uv.y);
1338						break;
1339
1340					case ClampToEdgeWrapping:
1341						uv.y = uv.y < 0 ? 0 : 1;
1342						break;
1343
1344					case MirroredRepeatWrapping:
1345						if (Math.abs(Math.floor(uv.y) % 2) === 1) {
1346							uv.y = Math.ceil(uv.y) - uv.y;
1347						} else {
1348							uv.y = uv.y - Math.floor(uv.y);
1349						}
1350
1351						break;
1352				}
1353			}
1354
1355			if (this.flipY) {
1356				uv.y = 1 - uv.y;
1357			}
1358
1359			return uv;
1360		}
1361
1362		set needsUpdate(value) {
1363			if (value === true) this.version++;
1364		}
1365
1366	}
1367
1368	Texture.DEFAULT_IMAGE = undefined;
1369	Texture.DEFAULT_MAPPING = UVMapping;
1370	Texture.prototype.isTexture = true;
1371
1372	function serializeImage(image) {
1373		if (typeof HTMLImageElement !== 'undefined' && image instanceof HTMLImageElement || typeof HTMLCanvasElement !== 'undefined' && image instanceof HTMLCanvasElement || typeof ImageBitmap !== 'undefined' && image instanceof ImageBitmap) {
1374			// default images
1375			return ImageUtils.getDataURL(image);
1376		} else {
1377			if (image.data) {
1378				// images of DataTexture
1379				return {
1380					data: Array.prototype.slice.call(image.data),
1381					width: image.width,
1382					height: image.height,
1383					type: image.data.constructor.name
1384				};
1385			} else {
1386				console.warn('THREE.Texture: Unable to serialize Texture.');
1387				return {};
1388			}
1389		}
1390	}
1391
1392	class Vector4 {
1393		constructor(x = 0, y = 0, z = 0, w = 1) {
1394			this.x = x;
1395			this.y = y;
1396			this.z = z;
1397			this.w = w;
1398		}
1399
1400		get width() {
1401			return this.z;
1402		}
1403
1404		set width(value) {
1405			this.z = value;
1406		}
1407
1408		get height() {
1409			return this.w;
1410		}
1411
1412		set height(value) {
1413			this.w = value;
1414		}
1415
1416		set(x, y, z, w) {
1417			this.x = x;
1418			this.y = y;
1419			this.z = z;
1420			this.w = w;
1421			return this;
1422		}
1423
1424		setScalar(scalar) {
1425			this.x = scalar;
1426			this.y = scalar;
1427			this.z = scalar;
1428			this.w = scalar;
1429			return this;
1430		}
1431
1432		setX(x) {
1433			this.x = x;
1434			return this;
1435		}
1436
1437		setY(y) {
1438			this.y = y;
1439			return this;
1440		}
1441
1442		setZ(z) {
1443			this.z = z;
1444			return this;
1445		}
1446
1447		setW(w) {
1448			this.w = w;
1449			return this;
1450		}
1451
1452		setComponent(index, value) {
1453			switch (index) {
1454				case 0:
1455					this.x = value;
1456					break;
1457
1458				case 1:
1459					this.y = value;
1460					break;
1461
1462				case 2:
1463					this.z = value;
1464					break;
1465
1466				case 3:
1467					this.w = value;
1468					break;
1469
1470				default:
1471					throw new Error('index is out of range: ' + index);
1472			}
1473
1474			return this;
1475		}
1476
1477		getComponent(index) {
1478			switch (index) {
1479				case 0:
1480					return this.x;
1481
1482				case 1:
1483					return this.y;
1484
1485				case 2:
1486					return this.z;
1487
1488				case 3:
1489					return this.w;
1490
1491				default:
1492					throw new Error('index is out of range: ' + index);
1493			}
1494		}
1495
1496		clone() {
1497			return new this.constructor(this.x, this.y, this.z, this.w);
1498		}
1499
1500		copy(v) {
1501			this.x = v.x;
1502			this.y = v.y;
1503			this.z = v.z;
1504			this.w = v.w !== undefined ? v.w : 1;
1505			return this;
1506		}
1507
1508		add(v, w) {
1509			if (w !== undefined) {
1510				console.warn('THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead.');
1511				return this.addVectors(v, w);
1512			}
1513
1514			this.x += v.x;
1515			this.y += v.y;
1516			this.z += v.z;
1517			this.w += v.w;
1518			return this;
1519		}
1520
1521		addScalar(s) {
1522			this.x += s;
1523			this.y += s;
1524			this.z += s;
1525			this.w += s;
1526			return this;
1527		}
1528
1529		addVectors(a, b) {
1530			this.x = a.x + b.x;
1531			this.y = a.y + b.y;
1532			this.z = a.z + b.z;
1533			this.w = a.w + b.w;
1534			return this;
1535		}
1536
1537		addScaledVector(v, s) {
1538			this.x += v.x * s;
1539			this.y += v.y * s;
1540			this.z += v.z * s;
1541			this.w += v.w * s;
1542			return this;
1543		}
1544
1545		sub(v, w) {
1546			if (w !== undefined) {
1547				console.warn('THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.');
1548				return this.subVectors(v, w);
1549			}
1550
1551			this.x -= v.x;
1552			this.y -= v.y;
1553			this.z -= v.z;
1554			this.w -= v.w;
1555			return this;
1556		}
1557
1558		subScalar(s) {
1559			this.x -= s;
1560			this.y -= s;
1561			this.z -= s;
1562			this.w -= s;
1563			return this;
1564		}
1565
1566		subVectors(a, b) {
1567			this.x = a.x - b.x;
1568			this.y = a.y - b.y;
1569			this.z = a.z - b.z;
1570			this.w = a.w - b.w;
1571			return this;
1572		}
1573
1574		multiply(v) {
1575			this.x *= v.x;
1576			this.y *= v.y;
1577			this.z *= v.z;
1578			this.w *= v.w;
1579			return this;
1580		}
1581
1582		multiplyScalar(scalar) {
1583			this.x *= scalar;
1584			this.y *= scalar;
1585			this.z *= scalar;
1586			this.w *= scalar;
1587			return this;
1588		}
1589
1590		applyMatrix4(m) {
1591			const x = this.x,
1592						y = this.y,
1593						z = this.z,
1594						w = this.w;
1595			const e = m.elements;
1596			this.x = e[0] * x + e[4] * y + e[8] * z + e[12] * w;
1597			this.y = e[1] * x + e[5] * y + e[9] * z + e[13] * w;
1598			this.z = e[2] * x + e[6] * y + e[10] * z + e[14] * w;
1599			this.w = e[3] * x + e[7] * y + e[11] * z + e[15] * w;
1600			return this;
1601		}
1602
1603		divideScalar(scalar) {
1604			return this.multiplyScalar(1 / scalar);
1605		}
1606
1607		setAxisAngleFromQuaternion(q) {
1608			// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
1609			// q is assumed to be normalized
1610			this.w = 2 * Math.acos(q.w);
1611			const s = Math.sqrt(1 - q.w * q.w);
1612
1613			if (s < 0.0001) {
1614				this.x = 1;
1615				this.y = 0;
1616				this.z = 0;
1617			} else {
1618				this.x = q.x / s;
1619				this.y = q.y / s;
1620				this.z = q.z / s;
1621			}
1622
1623			return this;
1624		}
1625
1626		setAxisAngleFromRotationMatrix(m) {
1627			// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm
1628			// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
1629			let angle, x, y, z; // variables for result
1630
1631			const epsilon = 0.01,
1632						// margin to allow for rounding errors
1633			epsilon2 = 0.1,
1634						// margin to distinguish between 0 and 180 degrees
1635			te = m.elements,
1636						m11 = te[0],
1637						m12 = te[4],
1638						m13 = te[8],
1639						m21 = te[1],
1640						m22 = te[5],
1641						m23 = te[9],
1642						m31 = te[2],
1643						m32 = te[6],
1644						m33 = te[10];
1645
1646			if (Math.abs(m12 - m21) < epsilon && Math.abs(m13 - m31) < epsilon && Math.abs(m23 - m32) < epsilon) {
1647				// singularity found
1648				// first check for identity matrix which must have +1 for all terms
1649				// in leading diagonal and zero in other terms
1650				if (Math.abs(m12 + m21) < epsilon2 && Math.abs(m13 + m31) < epsilon2 && Math.abs(m23 + m32) < epsilon2 && Math.abs(m11 + m22 + m33 - 3) < epsilon2) {
1651					// this singularity is identity matrix so angle = 0
1652					this.set(1, 0, 0, 0);
1653					return this; // zero angle, arbitrary axis
1654				} // otherwise this singularity is angle = 180
1655
1656
1657				angle = Math.PI;
1658				const xx = (m11 + 1) / 2;
1659				const yy = (m22 + 1) / 2;
1660				const zz = (m33 + 1) / 2;
1661				const xy = (m12 + m21) / 4;
1662				const xz = (m13 + m31) / 4;
1663				const yz = (m23 + m32) / 4;
1664
1665				if (xx > yy && xx > zz) {
1666					// m11 is the largest diagonal term
1667					if (xx < epsilon) {
1668						x = 0;
1669						y = 0.707106781;
1670						z = 0.707106781;
1671					} else {
1672						x = Math.sqrt(xx);
1673						y = xy / x;
1674						z = xz / x;
1675					}
1676				} else if (yy > zz) {
1677					// m22 is the largest diagonal term
1678					if (yy < epsilon) {
1679						x = 0.707106781;
1680						y = 0;
1681						z = 0.707106781;
1682					} else {
1683						y = Math.sqrt(yy);
1684						x = xy / y;
1685						z = yz / y;
1686					}
1687				} else {
1688					// m33 is the largest diagonal term so base result on this
1689					if (zz < epsilon) {
1690						x = 0.707106781;
1691						y = 0.707106781;
1692						z = 0;
1693					} else {
1694						z = Math.sqrt(zz);
1695						x = xz / z;
1696						y = yz / z;
1697					}
1698				}
1699
1700				this.set(x, y, z, angle);
1701				return this; // return 180 deg rotation
1702			} // as we have reached here there are no singularities so we can handle normally
1703
1704
1705			let s = Math.sqrt((m32 - m23) * (m32 - m23) + (m13 - m31) * (m13 - m31) + (m21 - m12) * (m21 - m12)); // used to normalize
1706
1707			if (Math.abs(s) < 0.001) s = 1; // prevent divide by zero, should not happen if matrix is orthogonal and should be
1708			// caught by singularity test above, but I've left it in just in case
1709
1710			this.x = (m32 - m23) / s;
1711			this.y = (m13 - m31) / s;
1712			this.z = (m21 - m12) / s;
1713			this.w = Math.acos((m11 + m22 + m33 - 1) / 2);
1714			return this;
1715		}
1716
1717		min(v) {
1718			this.x = Math.min(this.x, v.x);
1719			this.y = Math.min(this.y, v.y);
1720			this.z = Math.min(this.z, v.z);
1721			this.w = Math.min(this.w, v.w);
1722			return this;
1723		}
1724
1725		max(v) {
1726			this.x = Math.max(this.x, v.x);
1727			this.y = Math.max(this.y, v.y);
1728			this.z = Math.max(this.z, v.z);
1729			this.w = Math.max(this.w, v.w);
1730			return this;
1731		}
1732
1733		clamp(min, max) {
1734			// assumes min < max, componentwise
1735			this.x = Math.max(min.x, Math.min(max.x, this.x));
1736			this.y = Math.max(min.y, Math.min(max.y, this.y));
1737			this.z = Math.max(min.z, Math.min(max.z, this.z));
1738			this.w = Math.max(min.w, Math.min(max.w, this.w));
1739			return this;
1740		}
1741
1742		clampScalar(minVal, maxVal) {
1743			this.x = Math.max(minVal, Math.min(maxVal, this.x));
1744			this.y = Math.max(minVal, Math.min(maxVal, this.y));
1745			this.z = Math.max(minVal, Math.min(maxVal, this.z));
1746			this.w = Math.max(minVal, Math.min(maxVal, this.w));
1747			return this;
1748		}
1749
1750		clampLength(min, max) {
1751			const length = this.length();
1752			return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
1753		}
1754
1755		floor() {
1756			this.x = Math.floor(this.x);
1757			this.y = Math.floor(this.y);
1758			this.z = Math.floor(this.z);
1759			this.w = Math.floor(this.w);
1760			return this;
1761		}
1762
1763		ceil() {
1764			this.x = Math.ceil(this.x);
1765			this.y = Math.ceil(this.y);

2029			this.useRenderbuffer = this.useRenderToTexture === false;
2030		}
2031
2032		copy(source) {
2033			super.copy.call(this, source);
2034			this.samples = source.samples;
2035			this.useRenderToTexture = source.useRenderToTexture;
2036			this.useRenderbuffer = source.useRenderbuffer;
2037			return this;
2038		}
2039
2040	}
2041
2042	WebGLMultisampleRenderTarget.prototype.isWebGLMultisampleRenderTarget = true;
2043
2044	class Quaternion {
2045		constructor(x = 0, y = 0, z = 0, w = 1) {
2046			this._x = x;
2047			this._y = y;
2048			this._z = z;
2049			this._w = w;
2050		}
2051
2052		static slerp(qa, qb, qm, t) {
2053			console.warn('THREE.Quaternion: Static .slerp() has been deprecated. Use qm.slerpQuaternions( qa, qb, t ) instead.');
2054			return qm.slerpQuaternions(qa, qb, t);
2055		}
2056
2057		static slerpFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t) {
2058			// fuzz-free, array-based Quaternion SLERP operation
2059			let x0 = src0[srcOffset0 + 0],
2060					y0 = src0[srcOffset0 + 1],
2061					z0 = src0[srcOffset0 + 2],
2062					w0 = src0[srcOffset0 + 3];
2063			const x1 = src1[srcOffset1 + 0],
2064						y1 = src1[srcOffset1 + 1],
2065						z1 = src1[srcOffset1 + 2],
2066						w1 = src1[srcOffset1 + 3];
2067
2068			if (t === 0) {
2069				dst[dstOffset + 0] = x0;
2070				dst[dstOffset + 1] = y0;
2071				dst[dstOffset + 2] = z0;
2072				dst[dstOffset + 3] = w0;
2073				return;
2074			}
2075
2076			if (t === 1) {
2077				dst[dstOffset + 0] = x1;
2078				dst[dstOffset + 1] = y1;
2079				dst[dstOffset + 2] = z1;
2080				dst[dstOffset + 3] = w1;
2081				return;
2082			}
2083
2084			if (w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1) {
2085				let s = 1 - t;
2086				const cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
2087							dir = cos >= 0 ? 1 : -1,
2088							sqrSin = 1 - cos * cos; // Skip the Slerp for tiny steps to avoid numeric problems:
2089
2090				if (sqrSin > Number.EPSILON) {
2091					const sin = Math.sqrt(sqrSin),
2092								len = Math.atan2(sin, cos * dir);
2093					s = Math.sin(s * len) / sin;
2094					t = Math.sin(t * len) / sin;
2095				}
2096
2097				const tDir = t * dir;
2098				x0 = x0 * s + x1 * tDir;
2099				y0 = y0 * s + y1 * tDir;
2100				z0 = z0 * s + z1 * tDir;
2101				w0 = w0 * s + w1 * tDir; // Normalize in case we just did a lerp:
2102
2103				if (s === 1 - t) {
2104					const f = 1 / Math.sqrt(x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0);
2105					x0 *= f;
2106					y0 *= f;
2107					z0 *= f;
2108					w0 *= f;
2109				}
2110			}
2111
2112			dst[dstOffset] = x0;
2113			dst[dstOffset + 1] = y0;
2114			dst[dstOffset + 2] = z0;
2115			dst[dstOffset + 3] = w0;
2116		}
2117
2118		static multiplyQuaternionsFlat(dst, dstOffset, src0, srcOffset0, src1, srcOffset1) {
2119			const x0 = src0[srcOffset0];
2120			const y0 = src0[srcOffset0 + 1];
2121			const z0 = src0[srcOffset0 + 2];
2122			const w0 = src0[srcOffset0 + 3];
2123			const x1 = src1[srcOffset1];
2124			const y1 = src1[srcOffset1 + 1];
2125			const z1 = src1[srcOffset1 + 2];
2126			const w1 = src1[srcOffset1 + 3];
2127			dst[dstOffset] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
2128			dst[dstOffset + 1] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
2129			dst[dstOffset + 2] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
2130			dst[dstOffset + 3] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
2131			return dst;
2132		}
2133
2134		get x() {
2135			return this._x;
2136		}
2137
2138		set x(value) {
2139			this._x = value;
2140
2141			this._onChangeCallback();
2142		}
2143
2144		get y() {
2145			return this._y;
2146		}
2147
2148		set y(value) {
2149			this._y = value;
2150
2151			this._onChangeCallback();
2152		}
2153
2154		get z() {
2155			return this._z;
2156		}
2157
2158		set z(value) {
2159			this._z = value;
2160
2161			this._onChangeCallback();
2162		}
2163
2164		get w() {
2165			return this._w;
2166		}
2167
2168		set w(value) {
2169			this._w = value;
2170
2171			this._onChangeCallback();
2172		}
2173
2174		set(x, y, z, w) {
2175			this._x = x;
2176			this._y = y;
2177			this._z = z;
2178			this._w = w;
2179
2180			this._onChangeCallback();
2181
2182			return this;
2183		}
2184
2185		clone() {
2186			return new this.constructor(this._x, this._y, this._z, this._w);
2187		}
2188
2189		copy(quaternion) {
2190			this._x = quaternion.x;
2191			this._y = quaternion.y;
2192			this._z = quaternion.z;
2193			this._w = quaternion.w;
2194
2195			this._onChangeCallback();
2196
2197			return this;
2198		}
2199
2200		setFromEuler(euler, update) {
2201			if (!(euler && euler.isEuler)) {
2202				throw new Error('THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.');
2203			}
2204
2205			const x = euler._x,
2206						y = euler._y,
2207						z = euler._z,
2208						order = euler._order; // http://www.mathworks.com/matlabcentral/fileexchange/
2209			// 	20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
2210			//	content/SpinCalc.m
2211
2212			const cos = Math.cos;
2213			const sin = Math.sin;
2214			const c1 = cos(x / 2);
2215			const c2 = cos(y / 2);
2216			const c3 = cos(z / 2);
2217			const s1 = sin(x / 2);
2218			const s2 = sin(y / 2);
2219			const s3 = sin(z / 2);
2220
2221			switch (order) {
2222				case 'XYZ':
2223					this._x = s1 * c2 * c3 + c1 * s2 * s3;
2224					this._y = c1 * s2 * c3 - s1 * c2 * s3;
2225					this._z = c1 * c2 * s3 + s1 * s2 * c3;
2226					this._w = c1 * c2 * c3 - s1 * s2 * s3;
2227					break;
2228
2229				case 'YXZ':
2230					this._x = s1 * c2 * c3 + c1 * s2 * s3;
2231					this._y = c1 * s2 * c3 - s1 * c2 * s3;
2232					this._z = c1 * c2 * s3 - s1 * s2 * c3;
2233					this._w = c1 * c2 * c3 + s1 * s2 * s3;
2234					break;
2235
2236				case 'ZXY':
2237					this._x = s1 * c2 * c3 - c1 * s2 * s3;
2238					this._y = c1 * s2 * c3 + s1 * c2 * s3;
2239					this._z = c1 * c2 * s3 + s1 * s2 * c3;
2240					this._w = c1 * c2 * c3 - s1 * s2 * s3;
2241					break;
2242
2243				case 'ZYX':
2244					this._x = s1 * c2 * c3 - c1 * s2 * s3;
2245					this._y = c1 * s2 * c3 + s1 * c2 * s3;
2246					this._z = c1 * c2 * s3 - s1 * s2 * c3;
2247					this._w = c1 * c2 * c3 + s1 * s2 * s3;
2248					break;
2249
2250				case 'YZX':
2251					this._x = s1 * c2 * c3 + c1 * s2 * s3;
2252					this._y = c1 * s2 * c3 + s1 * c2 * s3;
2253					this._z = c1 * c2 * s3 - s1 * s2 * c3;
2254					this._w = c1 * c2 * c3 - s1 * s2 * s3;
2255					break;
2256
2257				case 'XZY':
2258					this._x = s1 * c2 * c3 - c1 * s2 * s3;
2259					this._y = c1 * s2 * c3 - s1 * c2 * s3;
2260					this._z = c1 * c2 * s3 + s1 * s2 * c3;
2261					this._w = c1 * c2 * c3 + s1 * s2 * s3;
2262					break;
2263
2264				default:
2265					console.warn('THREE.Quaternion: .setFromEuler() encountered an unknown order: ' + order);
2266			}
2267
2268			if (update !== false) this._onChangeCallback();
2269			return this;
2270		}
2271
2272		setFromAxisAngle(axis, angle) {
2273			// http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
2274			// assumes axis is normalized
2275			const halfAngle = angle / 2,
2276						s = Math.sin(halfAngle);
2277			this._x = axis.x * s;
2278			this._y = axis.y * s;
2279			this._z = axis.z * s;
2280			this._w = Math.cos(halfAngle);
2281
2282			this._onChangeCallback();
2283
2284			return this;
2285		}
2286
2287		setFromRotationMatrix(m) {
2288			// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
2289			// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
2290			const te = m.elements,
2291						m11 = te[0],
2292						m12 = te[4],
2293						m13 = te[8],
2294						m21 = te[1],
2295						m22 = te[5],
2296						m23 = te[9],
2297						m31 = te[2],
2298						m32 = te[6],
2299						m33 = te[10],
2300						trace = m11 + m22 + m33;
2301
2302			if (trace > 0) {
2303				const s = 0.5 / Math.sqrt(trace + 1.0);
2304				this._w = 0.25 / s;
2305				this._x = (m32 - m23) * s;
2306				this._y = (m13 - m31) * s;
2307				this._z = (m21 - m12) * s;
2308			} else if (m11 > m22 && m11 > m33) {
2309				const s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);
2310				this._w = (m32 - m23) / s;
2311				this._x = 0.25 * s;
2312				this._y = (m12 + m21) / s;
2313				this._z = (m13 + m31) / s;
2314			} else if (m22 > m33) {
2315				const s = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);
2316				this._w = (m13 - m31) / s;
2317				this._x = (m12 + m21) / s;
2318				this._y = 0.25 * s;
2319				this._z = (m23 + m32) / s;
2320			} else {
2321				const s = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);
2322				this._w = (m21 - m12) / s;
2323				this._x = (m13 + m31) / s;
2324				this._y = (m23 + m32) / s;
2325				this._z = 0.25 * s;
2326			}
2327
2328			this._onChangeCallback();
2329
2330			return this;
2331		}
2332
2333		setFromUnitVectors(vFrom, vTo) {
2334			// assumes direction vectors vFrom and vTo are normalized
2335			let r = vFrom.dot(vTo) + 1;
2336
2337			if (r < Number.EPSILON) {
2338				// vFrom and vTo point in opposite directions
2339				r = 0;
2340
2341				if (Math.abs(vFrom.x) > Math.abs(vFrom.z)) {
2342					this._x = -vFrom.y;
2343					this._y = vFrom.x;
2344					this._z = 0;
2345					this._w = r;
2346				} else {
2347					this._x = 0;
2348					this._y = -vFrom.z;
2349					this._z = vFrom.y;
2350					this._w = r;
2351				}
2352			} else {
2353				// crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3
2354				this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
2355				this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
2356				this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
2357				this._w = r;
2358			}
2359
2360			return this.normalize();
2361		}
2362
2363		angleTo(q) {
2364			return 2 * Math.acos(Math.abs(clamp(this.dot(q), -1, 1)));
2365		}
2366
2367		rotateTowards(q, step) {
2368			const angle = this.angleTo(q);
2369			if (angle === 0) return this;
2370			const t = Math.min(1, step / angle);
2371			this.slerp(q, t);
2372			return this;
2373		}
2374
2375		identity() {
2376			return this.set(0, 0, 0, 1);
2377		}
2378
2379		invert() {
2380			// quaternion is assumed to have unit length
2381			return this.conjugate();
2382		}
2383
2384		conjugate() {
2385			this._x *= -1;
2386			this._y *= -1;
2387			this._z *= -1;
2388
2389			this._onChangeCallback();
2390
2391			return this;
2392		}
2393
2394		dot(v) {
2395			return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
2396		}
2397
2398		lengthSq() {
2399			return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
2400		}
2401
2402		length() {
2403			return Math.sqrt(this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w);
2404		}
2405
2406		normalize() {
2407			let l = this.length();
2408
2409			if (l === 0) {
2410				this._x = 0;
2411				this._y = 0;
2412				this._z = 0;
2413				this._w = 1;
2414			} else {
2415				l = 1 / l;
2416				this._x = this._x * l;
2417				this._y = this._y * l;
2418				this._z = this._z * l;
2419				this._w = this._w * l;
2420			}
2421
2422			this._onChangeCallback();
2423
2424			return this;
2425		}
2426
2427		multiply(q, p) {
2428			if (p !== undefined) {
2429				console.warn('THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead.');
2430				return this.multiplyQuaternions(q, p);
2431			}
2432
2433			return this.multiplyQuaternions(this, q);
2434		}
2435
2436		premultiply(q) {
2437			return this.multiplyQuaternions(q, this);
2438		}
2439
2440		multiplyQuaternions(a, b) {
2441			// from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
2442			const qax = a._x,
2443						qay = a._y,
2444						qaz = a._z,
2445						qaw = a._w;
2446			const qbx = b._x,
2447						qby = b._y,
2448						qbz = b._z,
2449						qbw = b._w;
2450			this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
2451			this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
2452			this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
2453			this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
2454
2455			this._onChangeCallback();
2456
2457			return this;
2458		}
2459
2460		slerp(qb, t) {
2461			if (t === 0) return this;
2462			if (t === 1) return this.copy(qb);
2463			const x = this._x,
2464						y = this._y,
2465						z = this._z,
2466						w = this._w; // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
2467
2468			let cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
2469
2470			if (cosHalfTheta < 0) {
2471				this._w = -qb._w;
2472				this._x = -qb._x;
2473				this._y = -qb._y;
2474				this._z = -qb._z;
2475				cosHalfTheta = -cosHalfTheta;
2476			} else {
2477				this.copy(qb);
2478			}
2479
2480			if (cosHalfTheta >= 1.0) {
2481				this._w = w;
2482				this._x = x;
2483				this._y = y;
2484				this._z = z;
2485				return this;
2486			}
2487
2488			const sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
2489
2490			if (sqrSinHalfTheta <= Number.EPSILON) {
2491				const s = 1 - t;
2492				this._w = s * w + t * this._w;
2493				this._x = s * x + t * this._x;
2494				this._y = s * y + t * this._y;
2495				this._z = s * z + t * this._z;
2496				this.normalize();
2497
2498				this._onChangeCallback();
2499
2500				return this;
2501			}
2502
2503			const sinHalfTheta = Math.sqrt(sqrSinHalfTheta);
2504			const halfTheta = Math.atan2(sinHalfTheta, cosHalfTheta);
2505			const ratioA = Math.sin((1 - t) * halfTheta) / sinHalfTheta,
2506						ratioB = Math.sin(t * halfTheta) / sinHalfTheta;
2507			this._w = w * ratioA + this._w * ratioB;
2508			this._x = x * ratioA + this._x * ratioB;
2509			this._y = y * ratioA + this._y * ratioB;
2510			this._z = z * ratioA + this._z * ratioB;
2511
2512			this._onChangeCallback();
2513
2514			return this;
2515		}
2516
2517		slerpQuaternions(qa, qb, t) {
2518			this.copy(qa).slerp(qb, t);
2519		}
2520
2521		random() {
2522			// Derived from http://planning.cs.uiuc.edu/node198.html
2523			// Note, this source uses w, x, y, z ordering,
2524			// so we swap the order below.
2525			const u1 = Math.random();
2526			const sqrt1u1 = Math.sqrt(1 - u1);
2527			const sqrtu1 = Math.sqrt(u1);
2528			const u2 = 2 * Math.PI * Math.random();
2529			const u3 = 2 * Math.PI * Math.random();
2530			return this.set(sqrt1u1 * Math.cos(u2), sqrtu1 * Math.sin(u3), sqrtu1 * Math.cos(u3), sqrt1u1 * Math.sin(u2));
2531		}
2532
2533		equals(quaternion) {
2534			return quaternion._x === this._x && quaternion._y === this._y && quaternion._z === this._z && quaternion._w === this._w;
2535		}
2536
2537		fromArray(array, offset = 0) {
2538			this._x = array[offset];
2539			this._y = array[offset + 1];
2540			this._z = array[offset + 2];
2541			this._w = array[offset + 3];
2542
2543			this._onChangeCallback();
2544
2545			return this;
2546		}
2547
2548		toArray(array = [], offset = 0) {
2549			array[offset] = this._x;
2550			array[offset + 1] = this._y;
2551			array[offset + 2] = this._z;
2552			array[offset + 3] = this._w;
2553			return array;
2554		}
2555
2556		fromBufferAttribute(attribute, index) {
2557			this._x = attribute.getX(index);
2558			this._y = attribute.getY(index);
2559			this._z = attribute.getZ(index);
2560			this._w = attribute.getW(index);
2561			return this;
2562		}
2563
2564		_onChange(callback) {
2565			this._onChangeCallback = callback;
2566			return this;
2567		}
2568
2569		_onChangeCallback() {}
2570
2571	}
2572
2573	Quaternion.prototype.isQuaternion = true;
2574
2575	class Vector3 {
2576		constructor(x = 0, y = 0, z = 0) {
2577			this.x = x;
2578			this.y = y;
2579			this.z = z;
2580		}
2581
2582		set(x, y, z) {
2583			if (z === undefined) z = this.z; // sprite.scale.set(x,y)
2584
2585			this.x = x;
2586			this.y = y;
2587			this.z = z;
2588			return this;
2589		}
2590
2591		setScalar(scalar) {
2592			this.x = scalar;
2593			this.y = scalar;
2594			this.z = scalar;
2595			return this;
2596		}
2597
2598		setX(x) {
2599			this.x = x;
2600			return this;
2601		}
2602
2603		setY(y) {
2604			this.y = y;
2605			return this;
2606		}
2607
2608		setZ(z) {
2609			this.z = z;
2610			return this;
2611		}
2612
2613		setComponent(index, value) {
2614			switch (index) {
2615				case 0:
2616					this.x = value;
2617					break;
2618
2619				case 1:
2620					this.y = value;
2621					break;
2622
2623				case 2:
2624					this.z = value;
2625					break;
2626
2627				default:
2628					throw new Error('index is out of range: ' + index);
2629			}
2630
2631			return this;
2632		}
2633
2634		getComponent(index) {
2635			switch (index) {
2636				case 0:
2637					return this.x;
2638
2639				case 1:
2640					return this.y;
2641
2642				case 2:
2643					return this.z;
2644
2645				default:
2646					throw new Error('index is out of range: ' + index);
2647			}
2648		}
2649
2650		clone() {
2651			return new this.constructor(this.x, this.y, this.z);
2652		}
2653
2654		copy(v) {
2655			this.x = v.x;
2656			this.y = v.y;
2657			this.z = v.z;
2658			return this;
2659		}
2660
2661		add(v, w) {
2662			if (w !== undefined) {
2663				console.warn('THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead.');
2664				return this.addVectors(v, w);
2665			}
2666
2667			this.x += v.x;
2668			this.y += v.y;
2669			this.z += v.z;
2670			return this;
2671		}
2672
2673		addScalar(s) {
2674			this.x += s;
2675			this.y += s;
2676			this.z += s;
2677			return this;
2678		}
2679
2680		addVectors(a, b) {
2681			this.x = a.x + b.x;
2682			this.y = a.y + b.y;
2683			this.z = a.z + b.z;
2684			return this;
2685		}
2686
2687		addScaledVector(v, s) {
2688			this.x += v.x * s;
2689			this.y += v.y * s;
2690			this.z += v.z * s;
2691			return this;
2692		}
2693
2694		sub(v, w) {
2695			if (w !== undefined) {
2696				console.warn('THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.');
2697				return this.subVectors(v, w);
2698			}
2699
2700			this.x -= v.x;
2701			this.y -= v.y;
2702			this.z -= v.z;
2703			return this;
2704		}
2705
2706		subScalar(s) {
2707			this.x -= s;
2708			this.y -= s;
2709			this.z -= s;
2710			return this;
2711		}
2712
2713		subVectors(a, b) {
2714			this.x = a.x - b.x;
2715			this.y = a.y - b.y;
2716			this.z = a.z - b.z;
2717			return this;
2718		}
2719
2720		multiply(v, w) {
2721			if (w !== undefined) {
2722				console.warn('THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.');
2723				return this.multiplyVectors(v, w);
2724			}
2725
2726			this.x *= v.x;
2727			this.y *= v.y;
2728			this.z *= v.z;
2729			return this;
2730		}
2731
2732		multiplyScalar(scalar) {
2733			this.x *= scalar;
2734			this.y *= scalar;
2735			this.z *= scalar;
2736			return this;
2737		}
2738
2739		multiplyVectors(a, b) {
2740			this.x = a.x * b.x;
2741			this.y = a.y * b.y;
2742			this.z = a.z * b.z;
2743			return this;
2744		}
2745
2746		applyEuler(euler) {
2747			if (!(euler && euler.isEuler)) {
2748				console.error('THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.');
2749			}
2750
2751			return this.applyQuaternion(_quaternion$4.setFromEuler(euler));
2752		}
2753
2754		applyAxisAngle(axis, angle) {
2755			return this.applyQuaternion(_quaternion$4.setFromAxisAngle(axis, angle));
2756		}
2757
2758		applyMatrix3(m) {
2759			const x = this.x,
2760						y = this.y,
2761						z = this.z;
2762			const e = m.elements;
2763			this.x = e[0] * x + e[3] * y + e[6] * z;
2764			this.y = e[1] * x + e[4] * y + e[7] * z;
2765			this.z = e[2] * x + e[5] * y + e[8] * z;
2766			return this;
2767		}
2768
2769		applyNormalMatrix(m) {
2770			return this.applyMatrix3(m).normalize();
2771		}
2772
2773		applyMatrix4(m) {
2774			const x = this.x,
2775						y = this.y,
2776						z = this.z;
2777			const e = m.elements;
2778			const w = 1 / (e[3] * x + e[7] * y + e[11] * z + e[15]);
2779			this.x = (e[0] * x + e[4] * y + e[8] * z + e[12]) * w;
2780			this.y = (e[1] * x + e[5] * y + e[9] * z + e[13]) * w;
2781			this.z = (e[2] * x + e[6] * y + e[10] * z + e[14]) * w;
2782			return this;
2783		}
2784
2785		applyQuaternion(q) {
2786			const x = this.x,
2787						y = this.y,
2788						z = this.z;
2789			const qx = q.x,
2790						qy = q.y,
2791						qz = q.z,
2792						qw = q.w; // calculate quat * vector
2793
2794			const ix = qw * x + qy * z - qz * y;
2795			const iy = qw * y + qz * x - qx * z;
2796			const iz = qw * z + qx * y - qy * x;
2797			const iw = -qx * x - qy * y - qz * z; // calculate result * inverse quat
2798
2799			this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
2800			this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
2801			this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
2802			return this;
2803		}
2804
2805		project(camera) {
2806			return this.applyMatrix4(camera.matrixWorldInverse).applyMatrix4(camera.projectionMatrix);
2807		}
2808
2809		unproject(camera) {
2810			return this.applyMatrix4(camera.projectionMatrixInverse).applyMatrix4(camera.matrixWorld);
2811		}
2812
2813		transformDirection(m) {
2814			// input: THREE.Matrix4 affine matrix
2815			// vector interpreted as a direction
2816			const x = this.x,
2817						y = this.y,
2818						z = this.z;
2819			const e = m.elements;
2820			this.x = e[0] * x + e[4] * y + e[8] * z;
2821			this.y = e[1] * x + e[5] * y + e[9] * z;
2822			this.z = e[2] * x + e[6] * y + e[10] * z;
2823			return this.normalize();
2824		}
2825
2826		divide(v) {
2827			this.x /= v.x;
2828			this.y /= v.y;
2829			this.z /= v.z;
2830			return this;
2831		}
2832
2833		divideScalar(scalar) {
2834			return this.multiplyScalar(1 / scalar);
2835		}
2836
2837		min(v) {
2838			this.x = Math.min(this.x, v.x);
2839			this.y = Math.min(this.y, v.y);
2840			this.z = Math.min(this.z, v.z);
2841			return this;
2842		}
2843
2844		max(v) {
2845			this.x = Math.max(this.x, v.x);
2846			this.y = Math.max(this.y, v.y);
2847			this.z = Math.max(this.z, v.z);
2848			return this;
2849		}
2850
2851		clamp(min, max) {
2852			// assumes min < max, componentwise
2853			this.x = Math.max(min.x, Math.min(max.x, this.x));
2854			this.y = Math.max(min.y, Math.min(max.y, this.y));
2855			this.z = Math.max(min.z, Math.min(max.z, this.z));
2856			return this;
2857		}
2858
2859		clampScalar(minVal, maxVal) {
2860			this.x = Math.max(minVal, Math.min(maxVal, this.x));
2861			this.y = Math.max(minVal, Math.min(maxVal, this.y));
2862			this.z = Math.max(minVal, Math.min(maxVal, this.z));
2863			return this;
2864		}
2865
2866		clampLength(min, max) {
2867			const length = this.length();
2868			return this.divideScalar(length || 1).multiplyScalar(Math.max(min, Math.min(max, length)));
2869		}
2870
2871		floor() {
2872			this.x = Math.floor(this.x);
2873			this.y = Math.floor(this.y);
2874			this.z = Math.floor(this.z);
2875			return this;
2876		}
2877
2878		ceil() {
2879			this.x = Math.ceil(this.x);
2880			this.y = Math.ceil(this.y);
2881			this.z = Math.ceil(this.z);
2882			return this;
2883		}
2884
2885		round() {
2886			this.x = Math.round(this.x);
2887			this.y = Math.round(this.y);
2888			this.z = Math.round(this.z);
2889			return this;
2890		}
2891
2892		roundToZero() {
2893			this.x = this.x < 0 ? Math.ceil(this.x) : Math.floor(this.x);
2894			this.y = this.y < 0 ? Math.ceil(this.y) : Math.floor(this.y);
2895			this.z = this.z < 0 ? Math.ceil(this.z) : Math.floor(this.z);
2896			return this;
2897		}
2898
2899		negate() {
2900			this.x = -this.x;
2901			this.y = -this.y;
2902			this.z = -this.z;
2903			return this;
2904		}
2905
2906		dot(v) {
2907			return this.x * v.x + this.y * v.y + this.z * v.z;
2908		} // TODO lengthSquared?
2909
2910
2911		lengthSq() {
2912			return this.x * this.x + this.y * this.y + this.z * this.z;
2913		}
2914
2915		length() {
2916			return Math.sqrt(this.x * this.x + this.y * this.y + this.z * this.z);
2917		}
2918
2919		manhattanLength() {
2920			return Math.abs(this.x) + Math.abs(this.y) + Math.abs(this.z);
2921		}
2922
2923		normalize() {
2924			return this.divideScalar(this.length() || 1);
2925		}
2926
2927		setLength(length) {
2928			return this.normalize().multiplyScalar(length);
2929		}
2930
2931		lerp(v, alpha) {
2932			this.x += (v.x - this.x) * alpha;
2933			this.y += (v.y - this.y) * alpha;
2934			this.z += (v.z - this.z) * alpha;
2935			return this;
2936		}
2937
2938		lerpVectors(v1, v2, alpha) {
2939			this.x = v1.x + (v2.x - v1.x) * alpha;
2940			this.y = v1.y + (v2.y - v1.y) * alpha;
2941			this.z = v1.z + (v2.z - v1.z) * alpha;
2942			return this;
2943		}
2944
2945		cross(v, w) {
2946			if (w !== undefined) {
2947				console.warn('THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.');
2948				return this.crossVectors(v, w);
2949			}
2950
2951			return this.crossVectors(this, v);
2952		}
2953
2954		crossVectors(a, b) {
2955			const ax = a.x,
2956						ay = a.y,
2957						az = a.z;
2958			const bx = b.x,
2959						by = b.y,
2960						bz = b.z;
2961			this.x = ay * bz - az * by;
2962			this.y = az * bx - ax * bz;
2963			this.z = ax * by - ay * bx;
2964			return this;
2965		}
2966
2967		projectOnVector(v) {
2968			const denominator = v.lengthSq();
2969			if (denominator === 0) return this.set(0, 0, 0);
2970			const scalar = v.dot(this) / denominator;
2971			return this.copy(v).multiplyScalar(scalar);
2972		}
2973
2974		projectOnPlane(planeNormal) {
2975			_vector$c.copy(this).projectOnVector(planeNormal);
2976
2977			return this.sub(_vector$c);
2978		}
2979
2980		reflect(normal) {
2981			// reflect incident vector off plane orthogonal to normal
2982			// normal is assumed to have unit length
2983			return this.sub(_vector$c.copy(normal).multiplyScalar(2 * this.dot(normal)));
2984		}
2985
2986		angleTo(v) {
2987			const denominator = Math.sqrt(this.lengthSq() * v.lengthSq());
2988			if (denominator === 0) return Math.PI / 2;
2989			const theta = this.dot(v) / denominator; // clamp, to handle numerical problems
2990
2991			return Math.acos(clamp(theta, -1, 1));
2992		}
2993
2994		distanceTo(v) {
2995			return Math.sqrt(this.distanceToSquared(v));
2996		}
2997
2998		distanceToSquared(v) {
2999			const dx = this.x - v.x,
3000						dy = this.y - v.y,
3001						dz = this.z - v.z;
3002			return dx * dx + dy * dy + dz * dz;
3003		}
3004
3005		manhattanDistanceTo(v) {
3006			return Math.abs(this.x - v.x) + Math.abs(this.y - v.y) + Math.abs(this.z - v.z);
3007		}
3008
3009		setFromSpherical(s) {
3010			return this.setFromSphericalCoords(s.radius, s.phi, s.theta);
3011		}
3012
3013		setFromSphericalCoords(radius, phi, theta) {
3014			const sinPhiRadius = Math.sin(phi) * radius;
3015			this.x = sinPhiRadius * Math.sin(theta);
3016			this.y = Math.cos(phi) * radius;
3017			this.z = sinPhiRadius * Math.cos(theta);
3018			return this;
3019		}
3020
3021		setFromCylindrical(c) {
3022			return this.setFromCylindricalCoords(c.radius, c.theta, c.y);
3023		}
3024
3025		setFromCylindricalCoords(radius, theta, y) {
3026			this.x = radius * Math.sin(theta);
3027			this.y = y;
3028			this.z = radius * Math.cos(theta);
3029			return this;
3030		}
3031
3032		setFromMatrixPosition(m) {
3033			const e = m.elements;
3034			this.x = e[12];
3035			this.y = e[13];
3036			this.z = e[14];
3037			return this;
3038		}
3039
3040		setFromMatrixScale(m) {
3041			const sx = this.setFromMatrixColumn(m, 0).length();
3042			const sy = this.setFromMatrixColumn(m, 1).length();
3043			const sz = this.setFromMatrixColumn(m, 2).length();
3044			this.x = sx;
3045			this.y = sy;
3046			this.z = sz;
3047			return this;
3048		}
3049
3050		setFromMatrixColumn(m, index) {
3051			return this.fromArray(m.elements, index * 4);
3052		}
3053
3054		setFromMatrix3Column(m, index) {
3055			return this.fromArray(m.elements, index * 3);
3056		}
3057
3058		equals(v) {
3059			return v.x === this.x && v.y === this.y && v.z === this.z;
3060		}
3061
3062		fromArray(array, offset = 0) {
3063			this.x = array[offset];
3064			this.y = array[offset + 1];
3065			this.z = array[offset + 2];
3066			return this;
3067		}
3068
3069		toArray(array = [], offset = 0) {
3070			array[offset] = this.x;
3071			array[offset + 1] = this.y;
3072			array[offset + 2] = this.z;
3073			return array;
3074		}
3075
3076		fromBufferAttribute(attribute, index, offset) {
3077			if (offset !== undefined) {
3078				console.warn('THREE.Vector3: offset has been removed from .fromBufferAttribute().');
3079			}
3080
3081			this.x = attribute.getX(index);
3082			this.y = attribute.getY(index);
3083			this.z = attribute.getZ(index);
3084			return this;
3085		}
3086
3087		random() {
3088			this.x = Math.random();
3089			this.y = Math.random();
3090			this.z = Math.random();
3091			return this;
3092		}
3093
3094		randomDirection() {
3095			// Derived from https://mathworld.wolfram.com/SpherePointPicking.html
3096			const u = (Math.random() - 0.5) * 2;
3097			const t = Math.random() * Math.PI * 2;
3098			const f = Math.sqrt(1 - u ** 2);
3099			this.x = f * Math.cos(t);
3100			this.y = f * Math.sin(t);
3101			this.z = u;
3102			return this;
3103		}
3104
3105		*[Symbol.iterator]() {
3106			yield this.x;
3107			yield this.y;
3108			yield this.z;
3109		}
3110
3111	}
3112
3113	Vector3.prototype.isVector3 = true;
3114
3115	const _vector$c = /*@__PURE__*/new Vector3();
3116
3117	const _quaternion$4 = /*@__PURE__*/new Quaternion();
3118
3119	class Box3 {
3120		constructor(min = new Vector3(+Infinity, +Infinity, +Infinity), max = new Vector3(-Infinity, -Infinity, -Infinity)) {
3121			this.min = min;
3122			this.max = max;
3123		}
3124
3125		set(min, max) {
3126			this.min.copy(min);
3127			this.max.copy(max);
3128			return this;
3129		}
3130
3131		setFromArray(array) {
3132			let minX = +Infinity;
3133			let minY = +Infinity;
3134			let minZ = +Infinity;
3135			let maxX = -Infinity;
3136			let maxY = -Infinity;
3137			let maxZ = -Infinity;
3138
3139			for (let i = 0, l = array.length; i < l; i += 3) {
3140				const x = array[i];
3141				const y = array[i + 1];
3142				const z = array[i + 2];
3143				if (x < minX) minX = x;
3144				if (y < minY) minY = y;
3145				if (z < minZ) minZ = z;
3146				if (x > maxX) maxX = x;
3147				if (y > maxY) maxY = y;
3148				if (z > maxZ) maxZ = z;
3149			}
3150
3151			this.min.set(minX, minY, minZ);
3152			this.max.set(maxX, maxY, maxZ);
3153			return this;
3154		}
3155
3156		setFromBufferAttribute(attribute) {
3157			let minX = +Infinity;
3158			let minY = +Infinity;
3159			let minZ = +Infinity;
3160			let maxX = -Infinity;
3161			let maxY = -Infinity;
3162			let maxZ = -Infinity;
3163
3164			for (let i = 0, l = attribute.count; i < l; i++) {
3165				const x = attribute.getX(i);
3166				const y = attribute.getY(i);
3167				const z = attribute.getZ(i);
3168				if (x < minX) minX = x;
3169				if (y < minY) minY = y;
3170				if (z < minZ) minZ = z;
3171				if (x > maxX) maxX = x;
3172				if (y > maxY) maxY = y;
3173				if (z > maxZ) maxZ = z;
3174			}
3175
3176			this.min.set(minX, minY, minZ);
3177			this.max.set(maxX, maxY, maxZ);
3178			return this;
3179		}
3180
3181		setFromPoints(points) {
3182			this.makeEmpty();
3183
3184			for (let i = 0, il = points.length; i < il; i++) {
3185				this.expandByPoint(points[i]);
3186			}
3187
3188			return this;
3189		}
3190
3191		setFromCenterAndSize(center, size) {
3192			const halfSize = _vector$b.copy(size).multiplyScalar(0.5);
3193
3194			this.min.copy(center).sub(halfSize);
3195			this.max.copy(center).add(halfSize);
3196			return this;
3197		}
3198
3199		setFromObject(object) {
3200			this.makeEmpty();
3201			return this.expandByObject(object);
3202		}
3203
3204		clone() {
3205			return new this.constructor().copy(this);
3206		}
3207
3208		copy(box) {
3209			this.min.copy(box.min);
3210			this.max.copy(box.max);
3211			return this;
3212		}
3213
3214		makeEmpty() {
3215			this.min.x = this.min.y = this.min.z = +Infinity;
3216			this.max.x = this.max.y = this.max.z = -Infinity;
3217			return this;
3218		}
3219
3220		isEmpty() {
3221			// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
3222			return this.max.x < this.min.x || this.max.y < this.min.y || this.max.z < this.min.z;
3223		}
3224
3225		getCenter(target) {
3226			return this.isEmpty() ? target.set(0, 0, 0) : target.addVectors(this.min, this.max).multiplyScalar(0.5);
3227		}
3228
3229		getSize(target) {
3230			return this.isEmpty() ? target.set(0, 0, 0) : target.subVectors(this.max, this.min);
3231		}
3232
3233		expandByPoint(point) {
3234			this.min.min(point);
3235			this.max.max(point);
3236			return this;
3237		}
3238
3239		expandByVector(vector) {
3240			this.min.sub(vector);
3241			this.max.add(vector);
3242			return this;
3243		}
3244
3245		expandByScalar(scalar) {
3246			this.min.addScalar(-scalar);
3247			this.max.addScalar(scalar);
3248			return this;
3249		}
3250
3251		expandByObject(object) {
3252			// Computes the world-axis-aligned bounding box of an object (including its children),
3253			// accounting for both the object's, and children's, world transforms
3254			object.updateWorldMatrix(false, false);
3255			const geometry = object.geometry;
3256
3257			if (geometry !== undefined) {
3258				if (geometry.boundingBox === null) {
3259					geometry.computeBoundingBox();
3260				}
3261
3262				_box$3.copy(geometry.boundingBox);
3263
3264				_box$3.applyMatrix4(object.matrixWorld);
3265
3266				this.union(_box$3);
3267			}
3268
3269			const children = object.children;
3270
3271			for (let i = 0, l = children.length; i < l; i++) {
3272				this.expandByObject(children[i]);
3273			}
3274
3275			return this;
3276		}
3277
3278		containsPoint(point) {
3279			return point.x < this.min.x || point.x > this.max.x || point.y < this.min.y || point.y > this.max.y || point.z < this.min.z || point.z > this.max.z ? false : true;
3280		}
3281
3282		containsBox(box) {
3283			return this.min.x <= box.min.x && box.max.x <= this.max.x && this.min.y <= box.min.y && box.max.y <= this.max.y && this.min.z <= box.min.z && box.max.z <= this.max.z;
3284		}
3285
3286		getParameter(point, target) {
3287			// This can potentially have a divide by zero if the box
3288			// has a size dimension of 0.
3289			return target.set((point.x - this.min.x) / (this.max.x - this.min.x), (point.y - this.min.y) / (this.max.y - this.min.y), (point.z - this.min.z) / (this.max.z - this.min.z));
3290		}
3291
3292		intersectsBox(box) {
3293			// using 6 splitting planes to rule out intersections.
3294			return box.max.x < this.min.x || box.min.x > this.max.x || box.max.y < this.min.y || box.min.y > this.max.y || box.max.z < this.min.z || box.min.z > this.max.z ? false : true;
3295		}
3296
3297		intersectsSphere(sphere) {
3298			// Find the point on the AABB closest to the sphere center.
3299			this.clampPoint(sphere.center, _vector$b); // If that point is inside the sphere, the AABB and sphere intersect.
3300
3301			return _vector$b.distanceToSquared(sphere.center) <= sphere.radius * sphere.radius;
3302		}
3303
3304		intersectsPlane(plane) {
3305			// We compute the minimum and maximum dot product values. If those values
3306			// are on the same side (back or front) of the plane, then there is no intersection.
3307			let min, max;
3308
3309			if (plane.normal.x > 0) {
3310				min = plane.normal.x * this.min.x;
3311				max = plane.normal.x * this.max.x;
3312			} else {
3313				min = plane.normal.x * this.max.x;
3314				max = plane.normal.x * this.min.x;
3315			}
3316
3317			if (plane.normal.y > 0) {
3318				min += plane.normal.y * this.min.y;
3319				max += plane.normal.y * this.max.y;
3320			} else {
3321				min += plane.normal.y * this.max.y;
3322				max += plane.normal.y * this.min.y;
3323			}
3324
3325			if (plane.normal.z > 0) {
3326				min += plane.normal.z * this.min.z;
3327				max += plane.normal.z * this.max.z;
3328			} else {
3329				min += plane.normal.z * this.max.z;
3330				max += plane.normal.z * this.min.z;
3331			}
3332
3333			return min <= -plane.constant && max >= -plane.constant;
3334		}
3335
3336		intersectsTriangle(triangle) {
3337			if (this.isEmpty()) {
3338				return false;
3339			} // compute box center and extents
3340
3341
3342			this.getCenter(_center);
3343
3344			_extents.subVectors(this.max, _center); // translate triangle to aabb origin
3345
3346
3347			_v0$2.subVectors(triangle.a, _center);
3348
3349			_v1$7.subVectors(triangle.b, _center);
3350
3351			_v2$3.subVectors(triangle.c, _center); // compute edge vectors for triangle
3352
3353
3354			_f0.subVectors(_v1$7, _v0$2);
3355
3356			_f1.subVectors(_v2$3, _v1$7);
3357
3358			_f2.subVectors(_v0$2, _v2$3); // test against axes that are given by cross product combinations of the edges of the triangle and the edges of the aabb
3359			// make an axis testing of each of the 3 sides of the aabb against each of the 3 sides of the triangle = 9 axis of separation
3360			// axis_ij = u_i x f_j (u0, u1, u2 = face normals of aabb = x,y,z axes vectors since aabb is axis aligned)
3361
3362
3363			let axes = [0, -_f0.z, _f0.y, 0, -_f1.z, _f1.y, 0, -_f2.z, _f2.y, _f0.z, 0, -_f0.x, _f1.z, 0, -_f1.x, _f2.z, 0, -_f2.x, -_f0.y, _f0.x, 0, -_f1.y, _f1.x, 0, -_f2.y, _f2.x, 0];
3364
3365			if (!satForAxes(axes, _v0$2, _v1$7, _v2$3, _extents)) {
3366				return false;