https://www.fromsoftware.jp/jp/static/js/lib/threejs/three/build/three.module.js

1// Polyfills
2
3if ( Number.EPSILON === undefined ) {
4
5	Number.EPSILON = Math.pow( 2, - 52 );
6
7}
8
9if ( Number.isInteger === undefined ) {
10
11	// Missing in IE
12	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
13
14	Number.isInteger = function ( value ) {
15
16		return typeof value === 'number' && isFinite( value ) && Math.floor( value ) === value;
17
18	};
19
20}
21
22//
23
24if ( Math.sign === undefined ) {
25
26	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign
27
28	Math.sign = function ( x ) {
29
30		return ( x < 0 ) ? - 1 : ( x > 0 ) ? 1 : + x;
31
32	};
33
34}
35
36if ( 'name' in Function.prototype === false ) {
37
38	// Missing in IE
39	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
40
41	Object.defineProperty( Function.prototype, 'name', {
42
43		get: function () {
44
45			return this.toString().match( /^\s*function\s*([^\(\s]*)/ )[ 1 ];
46
47		}
48
49	} );
50
51}
52
53if ( Object.assign === undefined ) {
54
55	// Missing in IE
56	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
57
58	Object.assign = function ( target ) {
59
60		if ( target === undefined || target === null ) {
61
62			throw new TypeError( 'Cannot convert undefined or null to object' );
63
64		}
65
66		var output = Object( target );
67
68		for ( var index = 1; index < arguments.length; index ++ ) {
69
70			var source = arguments[ index ];
71
72			if ( source !== undefined && source !== null ) {
73
74				for ( var nextKey in source ) {
75
76					if ( Object.prototype.hasOwnProperty.call( source, nextKey ) ) {
77
78						output[ nextKey ] = source[ nextKey ];
79
80					}
81
82				}
83
84			}
85
86		}
87
88		return output;
89
90	};
91
92}
93
94var REVISION = '116';
95var MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2, ROTATE: 0, DOLLY: 1, PAN: 2 };
96var TOUCH = { ROTATE: 0, PAN: 1, DOLLY_PAN: 2, DOLLY_ROTATE: 3 };
97var CullFaceNone = 0;
98var CullFaceBack = 1;
99var CullFaceFront = 2;
100var CullFaceFrontBack = 3;
101var FrontFaceDirectionCW = 0;
102var FrontFaceDirectionCCW = 1;
103var BasicShadowMap = 0;
104var PCFShadowMap = 1;
105var PCFSoftShadowMap = 2;
106var VSMShadowMap = 3;
107var FrontSide = 0;
108var BackSide = 1;
109var DoubleSide = 2;
110var FlatShading = 1;
111var SmoothShading = 2;
112var NoBlending = 0;
113var NormalBlending = 1;
114var AdditiveBlending = 2;
115var SubtractiveBlending = 3;
116var MultiplyBlending = 4;
117var CustomBlending = 5;
118var AddEquation = 100;
119var SubtractEquation = 101;
120var ReverseSubtractEquation = 102;
121var MinEquation = 103;
122var MaxEquation = 104;
123var ZeroFactor = 200;
124var OneFactor = 201;
125var SrcColorFactor = 202;
126var OneMinusSrcColorFactor = 203;
127var SrcAlphaFactor = 204;
128var OneMinusSrcAlphaFactor = 205;
129var DstAlphaFactor = 206;
130var OneMinusDstAlphaFactor = 207;
131var DstColorFactor = 208;
132var OneMinusDstColorFactor = 209;
133var SrcAlphaSaturateFactor = 210;
134var NeverDepth = 0;
135var AlwaysDepth = 1;
136var LessDepth = 2;
137var LessEqualDepth = 3;
138var EqualDepth = 4;
139var GreaterEqualDepth = 5;
140var GreaterDepth = 6;
141var NotEqualDepth = 7;
142var MultiplyOperation = 0;
143var MixOperation = 1;
144var AddOperation = 2;
145var NoToneMapping = 0;
146var LinearToneMapping = 1;
147var ReinhardToneMapping = 2;
148var Uncharted2ToneMapping = 3;
149var CineonToneMapping = 4;
150var ACESFilmicToneMapping = 5;
151
152var UVMapping = 300;
153var CubeReflectionMapping = 301;
154var CubeRefractionMapping = 302;
155var EquirectangularReflectionMapping = 303;
156var EquirectangularRefractionMapping = 304;
157var SphericalReflectionMapping = 305;
158var CubeUVReflectionMapping = 306;
159var CubeUVRefractionMapping = 307;
160var RepeatWrapping = 1000;
161var ClampToEdgeWrapping = 1001;
162var MirroredRepeatWrapping = 1002;
163var NearestFilter = 1003;
164var NearestMipmapNearestFilter = 1004;
165var NearestMipMapNearestFilter = 1004;
166var NearestMipmapLinearFilter = 1005;
167var NearestMipMapLinearFilter = 1005;
168var LinearFilter = 1006;
169var LinearMipmapNearestFilter = 1007;
170var LinearMipMapNearestFilter = 1007;
171var LinearMipmapLinearFilter = 1008;
172var LinearMipMapLinearFilter = 1008;
173var UnsignedByteType = 1009;
174var ByteType = 1010;
175var ShortType = 1011;
176var UnsignedShortType = 1012;
177var IntType = 1013;
178var UnsignedIntType = 1014;
179var FloatType = 1015;
180var HalfFloatType = 1016;
181var UnsignedShort4444Type = 1017;
182var UnsignedShort5551Type = 1018;
183var UnsignedShort565Type = 1019;
184var UnsignedInt248Type = 1020;
185var AlphaFormat = 1021;
186var RGBFormat = 1022;
187var RGBAFormat = 1023;
188var LuminanceFormat = 1024;
189var LuminanceAlphaFormat = 1025;
190var RGBEFormat = RGBAFormat;
191var DepthFormat = 1026;
192var DepthStencilFormat = 1027;
193var RedFormat = 1028;
194var RedIntegerFormat = 1029;
195var RGFormat = 1030;
196var RGIntegerFormat = 1031;
197var RGBIntegerFormat = 1032;
198var RGBAIntegerFormat = 1033;
199
200var RGB_S3TC_DXT1_Format = 33776;
201var RGBA_S3TC_DXT1_Format = 33777;
202var RGBA_S3TC_DXT3_Format = 33778;
203var RGBA_S3TC_DXT5_Format = 33779;
204var RGB_PVRTC_4BPPV1_Format = 35840;
205var RGB_PVRTC_2BPPV1_Format = 35841;
206var RGBA_PVRTC_4BPPV1_Format = 35842;
207var RGBA_PVRTC_2BPPV1_Format = 35843;
208var RGB_ETC1_Format = 36196;
209var RGB_ETC2_Format = 37492;
210var RGBA_ETC2_EAC_Format = 37496;
211var RGBA_ASTC_4x4_Format = 37808;
212var RGBA_ASTC_5x4_Format = 37809;
213var RGBA_ASTC_5x5_Format = 37810;
214var RGBA_ASTC_6x5_Format = 37811;
215var RGBA_ASTC_6x6_Format = 37812;
216var RGBA_ASTC_8x5_Format = 37813;
217var RGBA_ASTC_8x6_Format = 37814;
218var RGBA_ASTC_8x8_Format = 37815;
219var RGBA_ASTC_10x5_Format = 37816;
220var RGBA_ASTC_10x6_Format = 37817;
221var RGBA_ASTC_10x8_Format = 37818;
222var RGBA_ASTC_10x10_Format = 37819;
223var RGBA_ASTC_12x10_Format = 37820;
224var RGBA_ASTC_12x12_Format = 37821;
225var RGBA_BPTC_Format = 36492;
226var SRGB8_ALPHA8_ASTC_4x4_Format = 37840;
227var SRGB8_ALPHA8_ASTC_5x4_Format = 37841;
228var SRGB8_ALPHA8_ASTC_5x5_Format = 37842;
229var SRGB8_ALPHA8_ASTC_6x5_Format = 37843;
230var SRGB8_ALPHA8_ASTC_6x6_Format = 37844;
231var SRGB8_ALPHA8_ASTC_8x5_Format = 37845;
232var SRGB8_ALPHA8_ASTC_8x6_Format = 37846;
233var SRGB8_ALPHA8_ASTC_8x8_Format = 37847;
234var SRGB8_ALPHA8_ASTC_10x5_Format = 37848;
235var SRGB8_ALPHA8_ASTC_10x6_Format = 37849;
236var SRGB8_ALPHA8_ASTC_10x8_Format = 37850;
237var SRGB8_ALPHA8_ASTC_10x10_Format = 37851;
238var SRGB8_ALPHA8_ASTC_12x10_Format = 37852;
239var SRGB8_ALPHA8_ASTC_12x12_Format = 37853;
240var LoopOnce = 2200;
241var LoopRepeat = 2201;
242var LoopPingPong = 2202;
243var InterpolateDiscrete = 2300;
244var InterpolateLinear = 2301;
245var InterpolateSmooth = 2302;
246var ZeroCurvatureEnding = 2400;
247var ZeroSlopeEnding = 2401;
248var WrapAroundEnding = 2402;
249var NormalAnimationBlendMode = 2500;
250var AdditiveAnimationBlendMode = 2501;
251var TrianglesDrawMode = 0;
252var TriangleStripDrawMode = 1;
253var TriangleFanDrawMode = 2;
254var LinearEncoding = 3000;
255var sRGBEncoding = 3001;
256var GammaEncoding = 3007;
257var RGBEEncoding = 3002;
258var LogLuvEncoding = 3003;
259var RGBM7Encoding = 3004;
260var RGBM16Encoding = 3005;
261var RGBDEncoding = 3006;
262var BasicDepthPacking = 3200;
263var RGBADepthPacking = 3201;
264var TangentSpaceNormalMap = 0;
265var ObjectSpaceNormalMap = 1;
266
267var ZeroStencilOp = 0;
268var KeepStencilOp = 7680;
269var ReplaceStencilOp = 7681;
270var IncrementStencilOp = 7682;
271var DecrementStencilOp = 7683;
272var IncrementWrapStencilOp = 34055;
273var DecrementWrapStencilOp = 34056;
274var InvertStencilOp = 5386;
275
276var NeverStencilFunc = 512;
277var LessStencilFunc = 513;
278var EqualStencilFunc = 514;
279var LessEqualStencilFunc = 515;
280var GreaterStencilFunc = 516;
281var NotEqualStencilFunc = 517;
282var GreaterEqualStencilFunc = 518;
283var AlwaysStencilFunc = 519;
284
285var StaticDrawUsage = 35044;
286var DynamicDrawUsage = 35048;
287var StreamDrawUsage = 35040;
288var StaticReadUsage = 35045;
289var DynamicReadUsage = 35049;
290var StreamReadUsage = 35041;
291var StaticCopyUsage = 35046;
292var DynamicCopyUsage = 35050;
293var StreamCopyUsage = 35042;
294
295/**
296 * https://github.com/mrdoob/eventdispatcher.js/
297 */
298
299function EventDispatcher() {}
300
301Object.assign( EventDispatcher.prototype, {
302
303	addEventListener: function ( type, listener ) {
304
305		if ( this._listeners === undefined ) this._listeners = {};
306
307		var listeners = this._listeners;
308
309		if ( listeners[ type ] === undefined ) {
310
311			listeners[ type ] = [];
312
313		}
314
315		if ( listeners[ type ].indexOf( listener ) === - 1 ) {
316
317			listeners[ type ].push( listener );
318
319		}
320
321	},
322
323	hasEventListener: function ( type, listener ) {
324
325		if ( this._listeners === undefined ) return false;

326
327		var listeners = this._listeners;
328
329		return listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1;
330
331	},
332
333	removeEventListener: function ( type, listener ) {
334
335		if ( this._listeners === undefined ) return;
336
337		var listeners = this._listeners;
338		var listenerArray = listeners[ type ];
339
340		if ( listenerArray !== undefined ) {
341
342			var index = listenerArray.indexOf( listener );
343
344			if ( index !== - 1 ) {
345
346				listenerArray.splice( index, 1 );
347
348			}
349
350		}
351
352	},
353
354	dispatchEvent: function ( event ) {
355
356		if ( this._listeners === undefined ) return;
357
358		var listeners = this._listeners;
359		var listenerArray = listeners[ event.type ];
360
361		if ( listenerArray !== undefined ) {
362
363			event.target = this;
364
365			// Make a copy, in case listeners are removed while iterating.
366			var array = listenerArray.slice( 0 );
367
368			for ( var i = 0, l = array.length; i < l; i ++ ) {
369
370				array[ i ].call( this, event );
371
372			}
373
374		}
375
376	}
377
378} );
379
380/**
381 * @author alteredq / http://alteredqualia.com/
382 * @author mrdoob / http://mrdoob.com/
383 * @author WestLangley / http://github.com/WestLangley
384 * @author thezwap
385 */
386
387var _lut = [];
388
389for ( var i = 0; i < 256; i ++ ) {
390
391	_lut[ i ] = ( i < 16 ? '0' : '' ) + ( i ).toString( 16 );
392
393}
394
395var MathUtils = {
396
397	DEG2RAD: Math.PI / 180,
398	RAD2DEG: 180 / Math.PI,
399
400	generateUUID: function () {
401
402		// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/21963136#21963136
403
404		var d0 = Math.random() * 0xffffffff | 0;
405		var d1 = Math.random() * 0xffffffff | 0;
406		var d2 = Math.random() * 0xffffffff | 0;
407		var d3 = Math.random() * 0xffffffff | 0;
408		var uuid = _lut[ d0 & 0xff ] + _lut[ d0 >> 8 & 0xff ] + _lut[ d0 >> 16 & 0xff ] + _lut[ d0 >> 24 & 0xff ] + '-' +
409			_lut[ d1 & 0xff ] + _lut[ d1 >> 8 & 0xff ] + '-' + _lut[ d1 >> 16 & 0x0f | 0x40 ] + _lut[ d1 >> 24 & 0xff ] + '-' +
410			_lut[ d2 & 0x3f | 0x80 ] + _lut[ d2 >> 8 & 0xff ] + '-' + _lut[ d2 >> 16 & 0xff ] + _lut[ d2 >> 24 & 0xff ] +
411			_lut[ d3 & 0xff ] + _lut[ d3 >> 8 & 0xff ] + _lut[ d3 >> 16 & 0xff ] + _lut[ d3 >> 24 & 0xff ];
412
413		// .toUpperCase() here flattens concatenated strings to save heap memory space.
414		return uuid.toUpperCase();
415
416	},
417
418	clamp: function ( value, min, max ) {
419
420		return Math.max( min, Math.min( max, value ) );
421
422	},
423
424	// compute euclidian modulo of m % n
425	// https://en.wikipedia.org/wiki/Modulo_operation
426
427	euclideanModulo: function ( n, m ) {
428
429		return ( ( n % m ) + m ) % m;
430
431	},
432
433	// Linear mapping from range <a1, a2> to range <b1, b2>
434
435	mapLinear: function ( x, a1, a2, b1, b2 ) {
436
437		return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );
438
439	},
440
441	// https://en.wikipedia.org/wiki/Linear_interpolation
442
443	lerp: function ( x, y, t ) {
444
445		return ( 1 - t ) * x + t * y;
446
447	},
448
449	// http://en.wikipedia.org/wiki/Smoothstep
450
451	smoothstep: function ( x, min, max ) {
452
453		if ( x <= min ) return 0;
454		if ( x >= max ) return 1;
455
456		x = ( x - min ) / ( max - min );
457
458		return x * x * ( 3 - 2 * x );
459
460	},
461
462	smootherstep: function ( x, min, max ) {
463
464		if ( x <= min ) return 0;
465		if ( x >= max ) return 1;
466
467		x = ( x - min ) / ( max - min );
468
469		return x * x * x * ( x * ( x * 6 - 15 ) + 10 );
470
471	},
472
473	// Random integer from <low, high> interval
474
475	randInt: function ( low, high ) {
476
477		return low + Math.floor( Math.random() * ( high - low + 1 ) );
478
479	},
480
481	// Random float from <low, high> interval
482
483	randFloat: function ( low, high ) {
484
485		return low + Math.random() * ( high - low );
486
487	},
488
489	// Random float from <-range/2, range/2> interval
490
491	randFloatSpread: function ( range ) {
492
493		return range * ( 0.5 - Math.random() );
494
495	},
496
497	degToRad: function ( degrees ) {
498
499		return degrees * MathUtils.DEG2RAD;
500
501	},
502
503	radToDeg: function ( radians ) {
504
505		return radians * MathUtils.RAD2DEG;
506
507	},
508
509	isPowerOfTwo: function ( value ) {
510
511		return ( value & ( value - 1 ) ) === 0 && value !== 0;
512
513	},
514
515	ceilPowerOfTwo: function ( value ) {
516
517		return Math.pow( 2, Math.ceil( Math.log( value ) / Math.LN2 ) );
518
519	},
520
521	floorPowerOfTwo: function ( value ) {
522
523		return Math.pow( 2, Math.floor( Math.log( value ) / Math.LN2 ) );
524
525	},
526
527	setQuaternionFromProperEuler: function ( q, a, b, c, order ) {
528
529		// Intrinsic Proper Euler Angles - see https://en.wikipedia.org/wiki/Euler_angles
530
531		// rotations are applied to the axes in the order specified by 'order'
532		// rotation by angle 'a' is applied first, then by angle 'b', then by angle 'c'
533		// angles are in radians
534
535		var cos = Math.cos;
536		var sin = Math.sin;
537
538		var c2 = cos( b / 2 );
539		var s2 = sin( b / 2 );
540
541		var c13 = cos( ( a + c ) / 2 );
542		var s13 = sin( ( a + c ) / 2 );
543
544		var c1_3 = cos( ( a - c ) / 2 );
545		var s1_3 = sin( ( a - c ) / 2 );
546
547		var c3_1 = cos( ( c - a ) / 2 );
548		var s3_1 = sin( ( c - a ) / 2 );
549
550		switch ( order ) {
551
552			case 'XYX':
553				q.set( c2 * s13, s2 * c1_3, s2 * s1_3, c2 * c13 );
554				break;
555
556			case 'YZY':
557				q.set( s2 * s1_3, c2 * s13, s2 * c1_3, c2 * c13 );
558				break;
559
560			case 'ZXZ':
561				q.set( s2 * c1_3, s2 * s1_3, c2 * s13, c2 * c13 );
562				break;
563
564			case 'XZX':
565				q.set( c2 * s13, s2 * s3_1, s2 * c3_1, c2 * c13 );
566				break;
567
568			case 'YXY':
569				q.set( s2 * c3_1, c2 * s13, s2 * s3_1, c2 * c13 );
570				break;
571
572			case 'ZYZ':
573				q.set( s2 * s3_1, s2 * c3_1, c2 * s13, c2 * c13 );
574				break;
575
576			default:
577				console.warn( 'THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: ' + order );
578
579		}
580
581	}
582
583};
584
585/**
586 * @author mrdoob / http://mrdoob.com/
587 * @author philogb / http://blog.thejit.org/
588 * @author egraether / http://egraether.com/
589 * @author zz85 / http://www.lab4games.net/zz85/blog
590 */
591
592function Vector2( x, y ) {
593
594	this.x = x || 0;
595	this.y = y || 0;
596
597}
598
599Object.defineProperties( Vector2.prototype, {
600
601	"width": {
602
603		get: function () {
604
605			return this.x;
606
607		},
608
609		set: function ( value ) {
610
611			this.x = value;
612
613		}
614
615	},
616
617	"height": {
618
619		get: function () {
620
621			return this.y;
622
623		},
624
625		set: function ( value ) {
626
627			this.y = value;
628
629		}
630
631	}
632
633} );
634
635Object.assign( Vector2.prototype, {
636
637	isVector2: true,
638
639	set: function ( x, y ) {
640
641		this.x = x;
642		this.y = y;
643
644		return this;
645
646	},
647
648	setScalar: function ( scalar ) {
649
650		this.x = scalar;
651		this.y = scalar;
652
653		return this;
654
655	},
656
657	setX: function ( x ) {
658
659		this.x = x;
660
661		return this;
662
663	},
664
665	setY: function ( y ) {
666
667		this.y = y;
668
669		return this;
670
671	},
672
673	setComponent: function ( index, value ) {
674
675		switch ( index ) {
676
677			case 0: this.x = value; break;
678			case 1: this.y = value; break;
679			default: throw new Error( 'index is out of range: ' + index );
680
681		}
682
683		return this;
684
685	},
686
687	getComponent: function ( index ) {
688
689		switch ( index ) {
690
691			case 0: return this.x;
692			case 1: return this.y;
693			default: throw new Error( 'index is out of range: ' + index );
694
695		}
696
697	},
698
699	clone: function () {
700
701		return new this.constructor( this.x, this.y );
702
703	},
704
705	copy: function ( v ) {
706
707		this.x = v.x;
708		this.y = v.y;
709
710		return this;
711
712	},
713
714	add: function ( v, w ) {
715
716		if ( w !== undefined ) {
717
718			console.warn( 'THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
719			return this.addVectors( v, w );
720
721		}
722
723		this.x += v.x;
724		this.y += v.y;
725
726		return this;
727
728	},
729
730	addScalar: function ( s ) {
731
732		this.x += s;
733		this.y += s;
734
735		return this;
736
737	},
738
739	addVectors: function ( a, b ) {
740
741		this.x = a.x + b.x;
742		this.y = a.y + b.y;
743
744		return this;
745
746	},
747
748	addScaledVector: function ( v, s ) {
749
750		this.x += v.x * s;
751		this.y += v.y * s;
752
753		return this;
754
755	},
756
757	sub: function ( v, w ) {
758
759		if ( w !== undefined ) {
760
761			console.warn( 'THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
762			return this.subVectors( v, w );
763
764		}
765
766		this.x -= v.x;
767		this.y -= v.y;
768
769		return this;
770
771	},
772
773	subScalar: function ( s ) {
774
775		this.x -= s;
776		this.y -= s;
777
778		return this;
779
780	},
781
782	subVectors: function ( a, b ) {
783
784		this.x = a.x - b.x;
785		this.y = a.y - b.y;
786
787		return this;
788
789	},
790
791	multiply: function ( v ) {
792
793		this.x *= v.x;
794		this.y *= v.y;
795
796		return this;
797
798	},
799
800	multiplyScalar: function ( scalar ) {
801
802		this.x *= scalar;
803		this.y *= scalar;
804
805		return this;
806
807	},
808
809	divide: function ( v ) {
810
811		this.x /= v.x;
812		this.y /= v.y;
813
814		return this;
815
816	},
817
818	divideScalar: function ( scalar ) {
819
820		return this.multiplyScalar( 1 / scalar );
821
822	},
823
824	applyMatrix3: function ( m ) {
825
826		var x = this.x, y = this.y;
827		var e = m.elements;
828
829		this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ];
830		this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ];
831
832		return this;
833
834	},
835
836	min: function ( v ) {
837
838		this.x = Math.min( this.x, v.x );
839		this.y = Math.min( this.y, v.y );
840
841		return this;
842
843	},
844
845	max: function ( v ) {
846
847		this.x = Math.max( this.x, v.x );
848		this.y = Math.max( this.y, v.y );
849
850		return this;
851
852	},
853
854	clamp: function ( min, max ) {
855
856		// assumes min < max, componentwise
857
858		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
859		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
860
861		return this;
862
863	},
864
865	clampScalar: function ( minVal, maxVal ) {
866
867		this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
868		this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
869
870		return this;
871
872	},
873
874	clampLength: function ( min, max ) {
875
876		var length = this.length();
877
878		return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
879
880	},
881
882	floor: function () {
883
884		this.x = Math.floor( this.x );
885		this.y = Math.floor( this.y );
886
887		return this;
888
889	},
890
891	ceil: function () {
892
893		this.x = Math.ceil( this.x );
894		this.y = Math.ceil( this.y );
895
896		return this;
897
898	},
899
900	round: function () {
901
902		this.x = Math.round( this.x );
903		this.y = Math.round( this.y );
904
905		return this;
906
907	},
908
909	roundToZero: function () {
910
911		this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
912		this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
913
914		return this;
915
916	},
917
918	negate: function () {
919
920		this.x = - this.x;
921		this.y = - this.y;
922
923		return this;
924
925	},
926
927	dot: function ( v ) {
928
929		return this.x * v.x + this.y * v.y;
930
931	},
932
933	cross: function ( v ) {
934
935		return this.x * v.y - this.y * v.x;
936
937	},
938
939	lengthSq: function () {
940
941		return this.x * this.x + this.y * this.y;
942
943	},
944
945	length: function () {
946
947		return Math.sqrt( this.x * this.x + this.y * this.y );
948
949	},
950
951	manhattanLength: function () {
952
953		return Math.abs( this.x ) + Math.abs( this.y );
954
955	},
956
957	normalize: function () {
958
959		return this.divideScalar( this.length() || 1 );
960
961	},
962
963	angle: function () {
964
965		// computes the angle in radians with respect to the positive x-axis
966
967		var angle = Math.atan2( - this.y, - this.x ) + Math.PI;
968
969		return angle;
970
971	},
972
973	distanceTo: function ( v ) {
974
975		return Math.sqrt( this.distanceToSquared( v ) );
976
977	},
978
979	distanceToSquared: function ( v ) {
980
981		var dx = this.x - v.x, dy = this.y - v.y;
982		return dx * dx + dy * dy;
983
984	},
985
986	manhattanDistanceTo: function ( v ) {
987
988		return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y );
989
990	},
991
992	setLength: function ( length ) {
993
994		return this.normalize().multiplyScalar( length );
995
996	},
997
998	lerp: function ( v, alpha ) {
999
1000		this.x += ( v.x - this.x ) * alpha;
1001		this.y += ( v.y - this.y ) * alpha;
1002
1003		return this;
1004
1005	},
1006
1007	lerpVectors: function ( v1, v2, alpha ) {
1008
1009		return this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
1010
1011	},
1012
1013	equals: function ( v ) {
1014
1015		return ( ( v.x === this.x ) && ( v.y === this.y ) );
1016
1017	},
1018
1019	fromArray: function ( array, offset ) {
1020
1021		if ( offset === undefined ) offset = 0;
1022
1023		this.x = array[ offset ];
1024		this.y = array[ offset + 1 ];
1025
1026		return this;
1027
1028	},
1029
1030	toArray: function ( array, offset ) {
1031
1032		if ( array === undefined ) array = [];
1033		if ( offset === undefined ) offset = 0;
1034
1035		array[ offset ] = this.x;
1036		array[ offset + 1 ] = this.y;
1037
1038		return array;
1039
1040	},
1041
1042	fromBufferAttribute: function ( attribute, index, offset ) {
1043
1044		if ( offset !== undefined ) {
1045
1046			console.warn( 'THREE.Vector2: offset has been removed from .fromBufferAttribute().' );
1047
1048		}
1049
1050		this.x = attribute.getX( index );
1051		this.y = attribute.getY( index );
1052
1053		return this;
1054
1055	},
1056

1057	rotateAround: function ( center, angle ) {
1058
1059		var c = Math.cos( angle ), s = Math.sin( angle );
1060
1061		var x = this.x - center.x;
1062		var y = this.y - center.y;
1063
1064		this.x = x * c - y * s + center.x;
1065		this.y = x * s + y * c + center.y;
1066
1067		return this;
1068
1069	},
1070
1071	random: function () {
1072
1073		this.x = Math.random();
1074		this.y = Math.random();
1075
1076		return this;
1077
1078	}
1079
1080} );
1081
1082/**
1083 * @author alteredq / http://alteredqualia.com/
1084 * @author WestLangley / http://github.com/WestLangley
1085 * @author bhouston / http://clara.io
1086 * @author tschw
1087 */
1088
1089function Matrix3() {
1090
1091	this.elements = [
1092
1093		1, 0, 0,
1094		0, 1, 0,
1095		0, 0, 1
1096
1097	];
1098
1099	if ( arguments.length > 0 ) {
1100
1101		console.error( 'THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.' );
1102
1103	}
1104
1105}
1106
1107Object.assign( Matrix3.prototype, {
1108
1109	isMatrix3: true,
1110
1111	set: function ( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {
1112
1113		var te = this.elements;
1114
1115		te[ 0 ] = n11; te[ 1 ] = n21; te[ 2 ] = n31;
1116		te[ 3 ] = n12; te[ 4 ] = n22; te[ 5 ] = n32;
1117		te[ 6 ] = n13; te[ 7 ] = n23; te[ 8 ] = n33;
1118
1119		return this;
1120
1121	},
1122
1123	identity: function () {
1124
1125		this.set(
1126
1127			1, 0, 0,
1128			0, 1, 0,
1129			0, 0, 1
1130
1131		);
1132
1133		return this;
1134
1135	},
1136
1137	clone: function () {
1138
1139		return new this.constructor().fromArray( this.elements );
1140
1141	},
1142
1143	copy: function ( m ) {
1144
1145		var te = this.elements;
1146		var me = m.elements;
1147
1148		te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ];
1149		te[ 3 ] = me[ 3 ]; te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ];
1150		te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; te[ 8 ] = me[ 8 ];
1151
1152		return this;
1153
1154	},
1155
1156	extractBasis: function ( xAxis, yAxis, zAxis ) {
1157
1158		xAxis.setFromMatrix3Column( this, 0 );
1159		yAxis.setFromMatrix3Column( this, 1 );
1160		zAxis.setFromMatrix3Column( this, 2 );
1161
1162		return this;
1163
1164	},
1165
1166	setFromMatrix4: function ( m ) {
1167
1168		var me = m.elements;
1169
1170		this.set(
1171
1172			me[ 0 ], me[ 4 ], me[ 8 ],
1173			me[ 1 ], me[ 5 ], me[ 9 ],
1174			me[ 2 ], me[ 6 ], me[ 10 ]
1175
1176		);
1177
1178		return this;
1179
1180	},
1181
1182	multiply: function ( m ) {
1183
1184		return this.multiplyMatrices( this, m );
1185
1186	},
1187
1188	premultiply: function ( m ) {
1189
1190		return this.multiplyMatrices( m, this );
1191
1192	},
1193
1194	multiplyMatrices: function ( a, b ) {
1195
1196		var ae = a.elements;
1197		var be = b.elements;
1198		var te = this.elements;
1199
1200		var a11 = ae[ 0 ], a12 = ae[ 3 ], a13 = ae[ 6 ];
1201		var a21 = ae[ 1 ], a22 = ae[ 4 ], a23 = ae[ 7 ];
1202		var a31 = ae[ 2 ], a32 = ae[ 5 ], a33 = ae[ 8 ];
1203
1204		var b11 = be[ 0 ], b12 = be[ 3 ], b13 = be[ 6 ];
1205		var b21 = be[ 1 ], b22 = be[ 4 ], b23 = be[ 7 ];
1206		var b31 = be[ 2 ], b32 = be[ 5 ], b33 = be[ 8 ];
1207
1208		te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31;
1209		te[ 3 ] = a11 * b12 + a12 * b22 + a13 * b32;
1210		te[ 6 ] = a11 * b13 + a12 * b23 + a13 * b33;
1211
1212		te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31;
1213		te[ 4 ] = a21 * b12 + a22 * b22 + a23 * b32;
1214		te[ 7 ] = a21 * b13 + a22 * b23 + a23 * b33;
1215
1216		te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31;
1217		te[ 5 ] = a31 * b12 + a32 * b22 + a33 * b32;
1218		te[ 8 ] = a31 * b13 + a32 * b23 + a33 * b33;
1219
1220		return this;
1221
1222	},
1223
1224	multiplyScalar: function ( s ) {
1225
1226		var te = this.elements;
1227
1228		te[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s;
1229		te[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s;
1230		te[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s;
1231
1232		return this;
1233
1234	},
1235
1236	determinant: function () {
1237
1238		var te = this.elements;
1239
1240		var a = te[ 0 ], b = te[ 1 ], c = te[ 2 ],
1241			d = te[ 3 ], e = te[ 4 ], f = te[ 5 ],
1242			g = te[ 6 ], h = te[ 7 ], i = te[ 8 ];
1243
1244		return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;
1245
1246	},
1247
1248	getInverse: function ( matrix, throwOnDegenerate ) {
1249
1250		if ( throwOnDegenerate !== undefined ) {
1251
1252			console.warn( "THREE.Matrix3: .getInverse() can no longer be configured to throw on degenerate." );
1253
1254		}
1255
1256		var me = matrix.elements,
1257			te = this.elements,
1258
1259			n11 = me[ 0 ], n21 = me[ 1 ], n31 = me[ 2 ],
1260			n12 = me[ 3 ], n22 = me[ 4 ], n32 = me[ 5 ],
1261			n13 = me[ 6 ], n23 = me[ 7 ], n33 = me[ 8 ],
1262
1263			t11 = n33 * n22 - n32 * n23,
1264			t12 = n32 * n13 - n33 * n12,
1265			t13 = n23 * n12 - n22 * n13,
1266
1267			det = n11 * t11 + n21 * t12 + n31 * t13;
1268
1269		if ( det === 0 ) return this.set( 0, 0, 0, 0, 0, 0, 0, 0, 0 );
1270
1271		var detInv = 1 / det;
1272
1273		te[ 0 ] = t11 * detInv;
1274		te[ 1 ] = ( n31 * n23 - n33 * n21 ) * detInv;
1275		te[ 2 ] = ( n32 * n21 - n31 * n22 ) * detInv;
1276
1277		te[ 3 ] = t12 * detInv;
1278		te[ 4 ] = ( n33 * n11 - n31 * n13 ) * detInv;
1279		te[ 5 ] = ( n31 * n12 - n32 * n11 ) * detInv;
1280
1281		te[ 6 ] = t13 * detInv;
1282		te[ 7 ] = ( n21 * n13 - n23 * n11 ) * detInv;
1283		te[ 8 ] = ( n22 * n11 - n21 * n12 ) * detInv;
1284
1285		return this;
1286
1287	},
1288
1289	transpose: function () {
1290
1291		var tmp, m = this.elements;
1292
1293		tmp = m[ 1 ]; m[ 1 ] = m[ 3 ];

1293 m[ 3 ] = tmp;
1294		tmp = m[ 2 ]; m[ 2 ] = m[ 6 ]; m[ 6 ] = tmp;
1295		tmp = m[ 5 ]; m[ 5 ] = m[ 7 ]; m[ 7 ] = tmp;
1296
1297		return this;
1298
1299	},
1300
1301	getNormalMatrix: function ( matrix4 ) {
1302
1303		return this.setFromMatrix4( matrix4 ).getInverse( this ).transpose();
1304
1305	},
1306
1307	transposeIntoArray: function ( r ) {
1308
1309		var m = this.elements;
1310
1311		r[ 0 ] = m[ 0 ];
1312		r[ 1 ] = m[ 3 ];
1313		r[ 2 ] = m[ 6 ];
1314		r[ 3 ] = m[ 1 ];
1315		r[ 4 ] = m[ 4 ];
1316		r[ 5 ] = m[ 7 ];
1317		r[ 6 ] = m[ 2 ];
1318		r[ 7 ] = m[ 5 ];
1319		r[ 8 ] = m[ 8 ];
1320
1321		return this;
1322
1323	},
1324
1325	setUvTransform: function ( tx, ty, sx, sy, rotation, cx, cy ) {
1326
1327		var c = Math.cos( rotation );
1328		var s = Math.sin( rotation );
1329
1330		this.set(
1331			sx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx,
1332			- sy * s, sy * c, - sy * ( - s * cx + c * cy ) + cy + ty,
1333			0, 0, 1
1334		);
1335
1336	},
1337
1338	scale: function ( sx, sy ) {
1339
1340		var te = this.elements;
1341
1342		te[ 0 ] *= sx; te[ 3 ] *= sx; te[ 6 ] *= sx;
1343		te[ 1 ] *= sy; te[ 4 ] *= sy; te[ 7 ] *= sy;
1344
1345		return this;
1346
1347	},
1348
1349	rotate: function ( theta ) {
1350
1351		var c = Math.cos( theta );
1352		var s = Math.sin( theta );
1353
1354		var te = this.elements;
1355
1356		var a11 = te[ 0 ], a12 = te[ 3 ], a13 = te[ 6 ];
1357		var a21 = te[ 1 ], a22 = te[ 4 ], a23 = te[ 7 ];
1358
1359		te[ 0 ] = c * a11 + s * a21;
1360		te[ 3 ] = c * a12 + s * a22;
1361		te[ 6 ] = c * a13 + s * a23;
1362
1363		te[ 1 ] = - s * a11 + c * a21;
1364		te[ 4 ] = - s * a12 + c * a22;
1365		te[ 7 ] = - s * a13 + c * a23;
1366
1367		return this;
1368
1369	},
1370
1371	translate: function ( tx, ty ) {
1372
1373		var te = this.elements;
1374
1375		te[ 0 ] += tx * te[ 2 ]; te[ 3 ] += tx * te[ 5 ]; te[ 6 ] += tx * te[ 8 ];
1376		te[ 1 ] += ty * te[ 2 ]; te[ 4 ] += ty * te[ 5 ]; te[ 7 ] += ty * te[ 8 ];
1377
1378		return this;
1379
1380	},
1381
1382	equals: function ( matrix ) {
1383
1384		var te = this.elements;
1385		var me = matrix.elements;
1386
1387		for ( var i = 0; i < 9; i ++ ) {
1388
1389			if ( te[ i ] !== me[ i ] ) return false;
1390
1391		}
1392
1393		return true;
1394
1395	},
1396
1397	fromArray: function ( array, offset ) {
1398
1399		if ( offset === undefined ) offset = 0;
1400
1401		for ( var i = 0; i < 9; i ++ ) {
1402
1403			this.elements[ i ] = array[ i + offset ];
1404
1405		}
1406
1407		return this;
1408
1409	},
1410
1411	toArray: function ( array, offset ) {
1412
1413		if ( array === undefined ) array = [];
1414		if ( offset === undefined ) offset = 0;
1415
1416		var te = this.elements;
1417
1418		array[ offset ] = te[ 0 ];
1419		array[ offset + 1 ] = te[ 1 ];
1420		array[ offset + 2 ] = te[ 2 ];
1421
1422		array[ offset + 3 ] = te[ 3 ];
1423		array[ offset + 4 ] = te[ 4 ];
1424		array[ offset + 5 ] = te[ 5 ];
1425
1426		array[ offset + 6 ] = te[ 6 ];
1427		array[ offset + 7 ] = te[ 7 ];
1428		array[ offset + 8 ] = te[ 8 ];
1429
1430		return array;
1431
1432	}
1433
1434} );
1435
1436/**
1437 * @author mrdoob / http://mrdoob.com/
1438 * @author alteredq / http://alteredqualia.com/
1439 * @author szimek / https://github.com/szimek/
1440 */
1441
1442var _canvas;
1443
1444var ImageUtils = {
1445
1446	getDataURL: function ( image ) {
1447
1448		var canvas;
1449
1450		if ( typeof HTMLCanvasElement == 'undefined' ) {
1451
1452			return image.src;
1453
1454		} else if ( image instanceof HTMLCanvasElement ) {
1455
1456			canvas = image;
1457
1458		} else {
1459
1460			if ( _canvas === undefined ) _canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );
1461
1462			_canvas.width = image.width;
1463			_canvas.height = image.height;
1464
1465			var context = _canvas.getContext( '2d' );
1466
1467			if ( image instanceof ImageData ) {
1468
1469				context.putImageData( image, 0, 0 );
1470
1471			} else {
1472
1473				context.drawImage( image, 0, 0, image.width, image.height );
1474
1475			}
1476
1477			canvas = _canvas;
1478
1479		}
1480
1481		if ( canvas.width > 2048 || canvas.height > 2048 ) {
1482
1483			return canvas.toDataURL( 'image/jpeg', 0.6 );
1484
1485		} else {
1486
1487			return canvas.toDataURL( 'image/png' );
1488
1489		}
1490
1491	}
1492
1493};
1494
1495/**
1496 * @author mrdoob / http://mrdoob.com/
1497 * @author alteredq / http://alteredqualia.com/
1498 * @author szimek / https://github.com/szimek/
1499 */
1500
1501var textureId = 0;
1502
1503function Texture( image, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) {
1504
1505	Object.defineProperty( this, 'id', { value: textureId ++ } );
1506
1507	this.uuid = MathUtils.generateUUID();
1508
1509	this.name = '';
1510
1511	this.image = image !== undefined ? image : Texture.DEFAULT_IMAGE;
1512	this.mipmaps = [];
1513
1514	this.mapping = mapping !== undefined ? mapping : Texture.DEFAULT_MAPPING;
1515
1516	this.wrapS = wrapS !== undefined ? wrapS : ClampToEdgeWrapping;
1517	this.wrapT = wrapT !== undefined ? wrapT : ClampToEdgeWrapping;
1518
1519	this.magFilter = magFilter !== undefined ? magFilter : LinearFilter;
1520	this.minFilter = minFilter !== undefined ? minFilter : LinearMipmapLinearFilter;
1521
1522	this.anisotropy = anisotropy !== undefined ? anisotropy : 1;
1523
1524	this.format = format !== undefined ? format : RGBAFormat;
1525	this.internalFormat = null;
1526	this.type = type !== undefined ? type : UnsignedByteType;
1527
1528	this.offset = new Vector2( 0, 0 );
1529	this.repeat = new Vector2( 1, 1 );
1530	this.center = new Vector2( 0, 0 );
1531	this.rotation = 0;
1532
1533	this.matrixAutoUpdate = true;
1534	this.matrix = new Matrix3();
1535
1536	this.generateMipmaps = true;
1537	this.premultiplyAlpha = false;
1538	this.flipY = true;
1539	this.unpackAlignment = 4;	// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
1540
1541	// Values of encoding !== THREE.LinearEncoding only supported on map, envMap and emissiveMap.
1542	//
1543	// Also changing the encoding after already used by a Material will not automatically make the Material
1544	// update. You need to explicitly call Material.needsUpdate to trigger it to recompile.
1545	this.encoding = encoding !== undefined ? encoding : LinearEncoding;
1546
1547	this.version = 0;
1548	this.onUpdate = null;
1549
1550}
1551
1552Texture.DEFAULT_IMAGE = undefined;
1553Texture.DEFAULT_MAPPING = UVMapping;
1554
1555Texture.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {
1556
1557	constructor: Texture,
1558
1559	isTexture: true,
1560
1561	updateMatrix: function () {
1562
1563		this.matrix.setUvTransform( this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y );
1564
1565	},
1566
1567	clone: function () {
1568
1569		return new this.constructor().copy( this );
1570
1571	},
1572
1573	copy: function ( source ) {
1574
1575		this.name = source.name;
1576
1577		this.image = source.image;
1578		this.mipmaps = source.mipmaps.slice( 0 );
1579
1580		this.mapping = source.mapping;
1581
1582		this.wrapS = source.wrapS;
1583		this.wrapT = source.wrapT;
1584
1585		this.magFilter = source.magFilter;
1586		this.minFilter = source.minFilter;
1587
1588		this.anisotropy = source.anisotropy;
1589
1590		this.format = source.format;
1591		this.internalFormat = source.internalFormat;
1592		this.type = source.type;
1593
1594		this.offset.copy( source.offset );
1595		this.repeat.copy( source.repeat );
1596		this.center.copy( source.center );
1597		this.rotation = source.rotation;
1598
1599		this.matrixAutoUpdate = source.matrixAutoUpdate;
1600		this.matrix.copy( source.matrix );
1601
1602		this.generateMipmaps = source.generateMipmaps;
1603		this.premultiplyAlpha = source.premultiplyAlpha;
1604		this.flipY = source.flipY;
1605		this.unpackAlignment = source.unpackAlignment;
1606		this.encoding = source.encoding;
1607
1608		return this;
1609
1610	},
1611
1612	toJSON: function ( meta ) {
1613
1614		var isRootObject = ( meta === undefined || typeof meta === 'string' );
1615
1616		if ( ! isRootObject && meta.textures[ this.uuid ] !== undefined ) {
1617
1618			return meta.textures[ this.uuid ];
1619
1620		}
1621
1622		var output = {
1623
1624			metadata: {
1625				version: 4.5,
1626				type: 'Texture',
1627				generator: 'Texture.toJSON'
1628			},
1629
1630			uuid: this.uuid,
1631			name: this.name,
1632
1633			mapping: this.mapping,
1634
1635			repeat: [ this.repeat.x, this.repeat.y ],
1636			offset: [ this.offset.x, this.offset.y ],
1637			center: [ this.center.x, this.center.y ],
1638			rotation: this.rotation,
1639
1640			wrap: [ this.wrapS, this.wrapT ],
1641
1642			format: this.format,
1643			type: this.type,
1644			encoding: this.encoding,
1645
1646			minFilter: this.minFilter,
1647			magFilter: this.magFilter,
1648			anisotropy: this.anisotropy,
1649
1650			flipY: this.flipY,
1651
1652			premultiplyAlpha: this.premultiplyAlpha,
1653			unpackAlignment: this.unpackAlignment
1654
1655		};
1656
1657		if ( this.image !== undefined ) {
1658
1659			// TODO: Move to THREE.Image
1660
1661			var image = this.image;
1662
1663			if ( image.uuid === undefined ) {
1664
1665				image.uuid = MathUtils.generateUUID(); // UGH
1666
1667			}
1668
1669			if ( ! isRootObject && meta.images[ image.uuid ] === undefined ) {
1670
1671				var url;
1672
1673				if ( Array.isArray( image ) ) {
1674
1675					// process array of images e.g. CubeTexture
1676
1677					url = [];
1678
1679					for ( var i = 0, l = image.length; i < l; i ++ ) {
1680
1681						url.push( ImageUtils.getDataURL( image[ i ] ) );
1682
1683					}
1684
1685				} else {
1686
1687					// process single image
1688
1689					url = ImageUtils.getDataURL( image );
1690
1691				}
1692
1693				meta.images[ image.uuid ] = {
1694					uuid: image.uuid,
1695					url: url
1696				};
1697
1698			}
1699
1700			output.image = image.uuid;
1701
1702		}
1703
1704		if ( ! isRootObject ) {
1705
1706			meta.textures[ this.uuid ] = output;
1707
1708		}
1709
1710		return output;
1711
1712	},
1713
1714	dispose: function () {
1715
1716		this.dispatchEvent( { type: 'dispose' } );
1717
1718	},
1719
1720	transformUv: function ( uv ) {
1721
1722		if ( this.mapping !== UVMapping ) return uv;
1723
1724		uv.applyMatrix3( this.matrix );
1725
1726		if ( uv.x < 0 || uv.x > 1 ) {
1727
1728			switch ( this.wrapS ) {
1729
1730				case RepeatWrapping:
1731
1732					uv.x = uv.x - Math.floor( uv.x );
1733					break;
1734

1735				case ClampToEdgeWrapping:
1736
1737					uv.x = uv.x < 0 ? 0 : 1;
1738					break;
1739
1740				case MirroredRepeatWrapping:
1741
1742					if ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) {
1743
1744						uv.x = Math.ceil( uv.x ) - uv.x;
1745
1746					} else {
1747
1748						uv.x = uv.x - Math.floor( uv.x );
1749
1750					}
1751
1752					break;
1753
1754			}
1755
1756		}
1757
1758		if ( uv.y < 0 || uv.y > 1 ) {
1759
1760			switch ( this.wrapT ) {
1761
1762				case RepeatWrapping:
1763
1764					uv.y = uv.y - Math.floor( uv.y );
1765					break;
1766
1767				case ClampToEdgeWrapping:
1768
1769					uv.y = uv.y < 0 ? 0 : 1;
1770					break;
1771
1772				case MirroredRepeatWrapping:
1773
1774					if ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) {
1775
1776						uv.y = Math.ceil( uv.y ) - uv.y;
1777
1778					} else {
1779
1780						uv.y = uv.y - Math.floor( uv.y );
1781
1782					}
1783
1784					break;
1785
1786			}
1787
1788		}
1789
1790		if ( this.flipY ) {
1791
1792			uv.y = 1 - uv.y;
1793
1794		}
1795
1796		return uv;
1797
1798	}
1799
1800} );
1801
1802Object.defineProperty( Texture.prototype, "needsUpdate", {
1803
1804	set: function ( value ) {
1805
1806		if ( value === true ) this.version ++;
1807
1808	}
1809
1810} );
1811
1812/**
1813 * @author supereggbert / http://www.paulbrunt.co.uk/
1814 * @author philogb / http://blog.thejit.org/
1815 * @author mikael emtinger / http://gomo.se/
1816 * @author egraether / http://egraether.com/
1817 * @author WestLangley / http://github.com/WestLangley
1818 */
1819
1820function Vector4( x, y, z, w ) {
1821
1822	this.x = x || 0;
1823	this.y = y || 0;
1824	this.z = z || 0;
1825	this.w = ( w !== undefined ) ? w : 1;
1826
1827}
1828
1829Object.defineProperties( Vector4.prototype, {
1830
1831	"width": {
1832
1833		get: function () {
1834
1835			return this.z;
1836
1837		},
1838
1839		set: function ( value ) {
1840
1841			this.z = value;
1842
1843		}
1844
1845	},
1846
1847	"height": {
1848
1849		get: function () {
1850
1851			return this.w;
1852
1853		},
1854
1855		set: function ( value ) {
1856
1857			this.w = value;
1858
1859		}
1860
1861	}
1862
1863} );
1864
1865Object.assign( Vector4.prototype, {
1866
1867	isVector4: true,
1868
1869	set: function ( x, y, z, w ) {
1870
1871		this.x = x;
1872		this.y = y;
1873		this.z = z;
1874		this.w = w;
1875
1876		return this;
1877
1878	},
1879
1880	setScalar: function ( scalar ) {
1881
1882		this.x = scalar;
1883		this.y = scalar;
1884		this.z = scalar;
1885		this.w = scalar;
1886
1887		return this;
1888
1889	},
1890
1891	setX: function ( x ) {
1892
1893		this.x = x;
1894
1895		return this;
1896
1897	},
1898
1899	setY: function ( y ) {
1900
1901		this.y = y;
1902
1903		return this;
1904
1905	},
1906
1907	setZ: function ( z ) {
1908
1909		this.z = z;
1910
1911		return this;
1912
1913	},
1914
1915	setW: function ( w ) {
1916
1917		this.w = w;
1918
1919		return this;
1920
1921	},
1922
1923	setComponent: function ( index, value ) {
1924
1925		switch ( index ) {
1926
1927			case 0: this.x = value; break;
1928			case 1: this.y = value; break;
1929			case 2: this.z = value; break;
1930			case 3: this.w = value; break;
1931			default: throw new Error( 'index is out of range: ' + index );
1932
1933		}
1934
1935		return this;
1936
1937	},
1938
1939	getComponent: function ( index ) {
1940
1941		switch ( index ) {
1942
1943			case 0: return this.x;
1944			case 1: return this.y;
1945			case 2: return this.z;
1946			case 3: return this.w;
1947			default: throw new Error( 'index is out of range: ' + index );
1948
1949		}
1950
1951	},
1952
1953	clone: function () {
1954
1955		return new this.constructor( this.x, this.y, this.z, this.w );
1956
1957	},
1958
1959	copy: function ( v ) {
1960
1961		this.x = v.x;
1962		this.y = v.y;
1963		this.z = v.z;
1964		this.w = ( v.w !== undefined ) ? v.w : 1;
1965
1966		return this;
1967
1968	},
1969
1970	add: function ( v, w ) {
1971
1972		if ( w !== undefined ) {
1973
1974			console.warn( 'THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
1975			return this.addVectors( v, w );
1976
1977		}
1978
1979		this.x += v.x;
1980		this.y += v.y;
1981		this.z += v.z;
1982		this.w += v.w;
1983
1984		return this;
1985
1986	},
1987
1988	addScalar: function ( s ) {
1989
1990		this.x += s;
1991		this.y += s;
1992		this.z += s;
1993		this.w += s;
1994
1995		return this;
1996
1997	},
1998
1999	addVectors: function ( a, b ) {
2000
2001		this.x = a.x + b.x;
2002		this.y = a.y + b.y;
2003		this.z = a.z + b.z;
2004		this.w = a.w + b.w;
2005
2006		return this;
2007
2008	},
2009
2010	addScaledVector: function ( v, s ) {
2011
2012		this.x += v.x * s;
2013		this.y += v.y * s;
2014		this.z += v.z * s;
2015		this.w += v.w * s;
2016
2017		return this;
2018
2019	},
2020
2021	sub: function ( v, w ) {
2022
2023		if ( w !== undefined ) {
2024
2025			console.warn( 'THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
2026			return this.subVectors( v, w );
2027
2028		}
2029
2030		this.x -= v.x;
2031		this.y -= v.y;
2032		this.z -= v.z;
2033		this.w -= v.w;
2034
2035		return this;
2036
2037	},
2038
2039	subScalar: function ( s ) {
2040
2041		this.x -= s;
2042		this.y -= s;
2043		this.z -= s;
2044		this.w -= s;
2045
2046		return this;
2047
2048	},
2049
2050	subVectors: function ( a, b ) {
2051
2052		this.x = a.x - b.x;
2053		this.y = a.y - b.y;
2054		this.z = a.z - b.z;
2055		this.w = a.w - b.w;
2056
2057		return this;
2058
2059	},
2060
2061	multiplyScalar: function ( scalar ) {
2062
2063		this.x *= scalar;
2064		this.y *= scalar;
2065		this.z *= scalar;
2066		this.w *= scalar;
2067
2068		return this;
2069
2070	},
2071
2072	applyMatrix4: function ( m ) {
2073
2074		var x = this.x, y = this.y, z = this.z, w = this.w;
2075		var e = m.elements;
2076
2077		this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w;
2078		this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w;
2079		this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w;
2080		this.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w;
2081
2082		return this;
2083
2084	},
2085
2086	divideScalar: function ( scalar ) {
2087
2088		return this.multiplyScalar( 1 / scalar );
2089
2090	},
2091
2092	setAxisAngleFromQuaternion: function ( q ) {
2093
2094		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
2095
2096		// q is assumed to be normalized
2097
2098		this.w = 2 * Math.acos( q.w );
2099

2100		var s = Math.sqrt( 1 - q.w * q.w );
2101
2102		if ( s < 0.0001 ) {
2103
2104			this.x = 1;
2105			this.y = 0;
2106			this.z = 0;
2107
2108		} else {
2109
2110			this.x = q.x / s;
2111			this.y = q.y / s;
2112			this.z = q.z / s;
2113
2114		}
2115
2116		return this;
2117
2118	},
2119
2120	setAxisAngleFromRotationMatrix: function ( m ) {
2121
2122		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm
2123
2124		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
2125
2126		var angle, x, y, z,		// variables for result
2127			epsilon = 0.01,		// margin to allow for rounding errors
2128			epsilon2 = 0.1,		// margin to distinguish between 0 and 180 degrees
2129
2130			te = m.elements,
2131
2132			m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
2133			m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
2134			m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];
2135
2136		if ( ( Math.abs( m12 - m21 ) < epsilon ) &&
2137		     ( Math.abs( m13 - m31 ) < epsilon ) &&
2138		     ( Math.abs( m23 - m32 ) < epsilon ) ) {
2139
2140			// singularity found
2141			// first check for identity matrix which must have +1 for all terms
2142			// in leading diagonal and zero in other terms
2143
2144			if ( ( Math.abs( m12 + m21 ) < epsilon2 ) &&
2145			     ( Math.abs( m13 + m31 ) < epsilon2 ) &&
2146			     ( Math.abs( m23 + m32 ) < epsilon2 ) &&
2147			     ( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) {
2148
2149				// this singularity is identity matrix so angle = 0
2150
2151				this.set( 1, 0, 0, 0 );
2152
2153				return this; // zero angle, arbitrary axis
2154
2155			}
2156
2157			// otherwise this singularity is angle = 180
2158
2159			angle = Math.PI;
2160
2161			var xx = ( m11 + 1 ) / 2;
2162			var yy = ( m22 + 1 ) / 2;
2163			var zz = ( m33 + 1 ) / 2;
2164			var xy = ( m12 + m21 ) / 4;
2165			var xz = ( m13 + m31 ) / 4;
2166			var yz = ( m23 + m32 ) / 4;
2167
2168			if ( ( xx > yy ) && ( xx > zz ) ) {
2169
2170				// m11 is the largest diagonal term
2171
2172				if ( xx < epsilon ) {
2173
2174					x = 0;
2175					y = 0.707106781;
2176					z = 0.707106781;
2177
2178				} else {
2179
2180					x = Math.sqrt( xx );
2181					y = xy / x;
2182					z = xz / x;
2183
2184				}
2185
2186			} else if ( yy > zz ) {
2187
2188				// m22 is the largest diagonal term
2189
2190				if ( yy < epsilon ) {
2191
2192					x = 0.707106781;
2193					y = 0;
2194					z = 0.707106781;
2195
2196				} else {
2197
2198					y = Math.sqrt( yy );
2199					x = xy / y;
2200					z = yz / y;
2201
2202				}
2203
2204			} else {
2205
2206				// m33 is the largest diagonal term so base result on this
2207
2208				if ( zz < epsilon ) {
2209
2210					x = 0.707106781;
2211					y = 0.707106781;
2212					z = 0;
2213
2214				} else {
2215
2216					z = Math.sqrt( zz );
2217					x = xz / z;
2218					y = yz / z;
2219
2220				}
2221
2222			}
2223
2224			this.set( x, y, z, angle );
2225
2226			return this; // return 180 deg rotation
2227
2228		}
2229
2230		// as we have reached here there are no singularities so we can handle normally
2231
2232		var s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) +
2233		                   ( m13 - m31 ) * ( m13 - m31 ) +
2234		                   ( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize
2235
2236		if ( Math.abs( s ) < 0.001 ) s = 1;
2237
2238		// prevent divide by zero, should not happen if matrix is orthogonal and should be
2239		// caught by singularity test above, but I've left it in just in case
2240
2241		this.x = ( m32 - m23 ) / s;
2242		this.y = ( m13 - m31 ) / s;
2243		this.z = ( m21 - m12 ) / s;
2244		this.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 );
2245
2246		return this;
2247
2248	},
2249
2250	min: function ( v ) {
2251
2252		this.x = Math.min( this.x, v.x );
2253		this.y = Math.min( this.y, v.y );
2254		this.z = Math.min( this.z, v.z );
2255		this.w = Math.min( this.w, v.w );
2256
2257		return this;
2258
2259	},
2260
2261	max: function ( v ) {
2262
2263		this.x = Math.max( this.x, v.x );
2264		this.y = Math.max( this.y, v.y );
2265		this.z = Math.max( this.z, v.z );
2266		this.w = Math.max( this.w, v.w );
2267
2268		return this;
2269
2270	},
2271
2272	clamp: function ( min, max ) {
2273
2274		// assumes min < max, componentwise
2275
2276		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
2277		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
2278		this.z = Math.max( min.z, Math.min( max.z, this.z ) );
2279		this.w = Math.max( min.w, Math.min( max.w, this.w ) );
2280
2281		return this;
2282
2283	},
2284
2285	clampScalar: function ( minVal, maxVal ) {
2286
2287		this.x = Math.max( minVal, Math.min( maxVal, this.x ) );
2288		this.y = Math.max( minVal, Math.min( maxVal, this.y ) );
2289		this.z = Math.max( minVal, Math.min( maxVal, this.z ) );
2290		this.w = Math.max( minVal, Math.min( maxVal, this.w ) );
2291
2292		return this;
2293
2294	},
2295
2296	clampLength: function ( min, max ) {
2297
2298		var length = this.length();
2299
2300		return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
2301
2302	},
2303
2304	floor: function () {
2305
2306		this.x = Math.floor( this.x );
2307		this.y = Math.floor( this.y );
2308		this.z = Math.floor( this.z );
2309		this.w = Math.floor( this.w );
2310
2311		return this;
2312
2313	},
2314
2315	ceil: function () {
2316
2317		this.x = Math.ceil( this.x );
2318		this.y = Math.ceil( this.y );

2319		this.z = Math.ceil( this.z );
2320		this.w = Math.ceil( this.w );
2321
2322		return this;
2323
2324	},
2325
2326	round: function () {
2327
2328		this.x = Math.round( this.x );
2329		this.y = Math.round( this.y );
2330		this.z = Math.round( this.z );
2331		this.w = Math.round( this.w );
2332
2333		return this;
2334
2335	},
2336
2337	roundToZero: function () {
2338
2339		this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
2340		this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
2341		this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );
2342		this.w = ( this.w < 0 ) ? Math.ceil( this.w ) : Math.floor( this.w );
2343
2344		return this;
2345
2346	},
2347
2348	negate: function () {
2349
2350		this.x = - this.x;
2351		this.y = - this.y;
2352		this.z = - this.z;
2353		this.w = - this.w;
2354
2355		return this;
2356
2357	},
2358
2359	dot: function ( v ) {
2360
2361		return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
2362
2363	},
2364
2365	lengthSq: function () {
2366
2367		return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
2368
2369	},
2370
2371	length: function () {
2372
2373		return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w );
2374
2375	},
2376
2377	manhattanLength: function () {
2378
2379		return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w );
2380
2381	},
2382
2383	normalize: function () {
2384
2385		return this.divideScalar( this.length() || 1 );
2386
2387	},
2388
2389	setLength: function ( length ) {
2390
2391		return this.normalize().multiplyScalar( length );
2392
2393	},
2394
2395	lerp: function ( v, alpha ) {
2396
2397		this.x += ( v.x - this.x ) * alpha;
2398		this.y += ( v.y - this.y ) * alpha;
2399		this.z += ( v.z - this.z ) * alpha;
2400		this.w += ( v.w - this.w ) * alpha;
2401
2402		return this;
2403
2404	},
2405
2406	lerpVectors: function ( v1, v2, alpha ) {
2407
2408		return this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
2409
2410	},
2411
2412	equals: function ( v ) {
2413
2414		return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) );
2415
2416	},
2417
2418	fromArray: function ( array, offset ) {
2419
2420		if ( offset === undefined ) offset = 0;
2421
2422		this.x = array[ offset ];
2423		this.y = array[ offset + 1 ];
2424		this.z = array[ offset + 2 ];
2425		this.w = array[ offset + 3 ];
2426
2427		return this;
2428
2429	},
2430
2431	toArray: function ( array, offset ) {
2432
2433		if ( array === undefined ) array = [];
2434		if ( offset === undefined ) offset = 0;
2435
2436		array[ offset ] = this.x;
2437		array[ offset + 1 ] = this.y;
2438		array[ offset + 2 ] = this.z;
2439		array[ offset + 3 ] = this.w;
2440
2441		return array;
2442
2443	},
2444
2445	fromBufferAttribute: function ( attribute, index, offset ) {
2446
2447		if ( offset !== undefined ) {
2448
2449			console.warn( 'THREE.Vector4: offset has been removed from .fromBufferAttribute().' );
2450
2451		}
2452
2453		this.x = attribute.getX( index );
2454		this.y = attribute.getY( index );
2455		this.z = attribute.getZ( index );
2456		this.w = attribute.getW( index );
2457
2458		return this;
2459
2460	},
2461
2462	random: function () {
2463
2464		this.x = Math.random();
2465		this.y = Math.random();
2466		this.z = Math.random();
2467		this.w = Math.random();
2468
2469		return this;
2470
2471	}
2472
2473} );
2474
2475/**
2476 * @author szimek / https://github.com/szimek/
2477 * @author alteredq / http://alteredqualia.com/
2478 * @author Marius Kintel / https://github.com/kintel
2479 */
2480
2481/*
2482 In options, we can specify:
2483 * Texture parameters for an auto-generated target texture
2484 * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers
2485*/
2486function WebGLRenderTarget( width, height, options ) {
2487
2488	this.width = width;
2489	this.height = height;
2490
2491	this.scissor = new Vector4( 0, 0, width, height );
2492	this.scissorTest = false;
2493
2494	this.viewport = new Vector4( 0, 0, width, height );
2495
2496	options = options || {};
2497
2498	this.texture = new Texture( undefined, options.mapping, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.encoding );
2499
2500	this.texture.image = {};
2501	this.texture.image.width = width;
2502	this.texture.image.height = height;
2503
2504	this.texture.generateMipmaps = options.generateMipmaps !== undefined ? options.generateMipmaps : false;
2505	this.texture.minFilter = options.minFilter !== undefined ? options.minFilter : LinearFilter;
2506
2507	this.depthBuffer = options.depthBuffer !== undefined ? options.depthBuffer : true;
2508	this.stencilBuffer = options.stencilBuffer !== undefined ? options.stencilBuffer : true;
2509	this.depthTexture = options.depthTexture !== undefined ? options.depthTexture : null;
2510
2511}
2512

2513WebGLRenderTarget.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {
2514
2515	constructor: WebGLRenderTarget,
2516
2517	isWebGLRenderTarget: true,
2518
2519	setSize: function ( width, height ) {
2520
2521		if ( this.width !== width || this.height !== height ) {
2522
2523			this.width = width;
2524			this.height = height;
2525
2526			this.texture.image.width = width;
2527			this.texture.image.height = height;
2528
2529			this.dispose();
2530
2531		}
2532
2533		this.viewport.set( 0, 0, width, height );
2534		this.scissor.set( 0, 0, width, height );
2535
2536	},
2537
2538	clone: function () {
2539
2540		return new this.constructor().copy( this );
2541
2542	},
2543
2544	copy: function ( source ) {
2545
2546		this.width = source.width;
2547		this.height = source.height;
2548
2549		this.viewport.copy( source.viewport );
2550
2551		this.texture = source.texture.clone();
2552
2553		this.depthBuffer = source.depthBuffer;
2554		this.stencilBuffer = source.stencilBuffer;
2555		this.depthTexture = source.depthTexture;
2556
2557		return this;
2558
2559	},
2560
2561	dispose: function () {
2562
2563		this.dispatchEvent( { type: 'dispose' } );
2564
2565	}
2566
2567} );
2568
2569/**
2570 * @author Mugen87 / https://github.com/Mugen87
2571 * @author Matt DesLauriers / @mattdesl
2572 */
2573
2574function WebGLMultisampleRenderTarget( width, height, options ) {
2575
2576	WebGLRenderTarget.call( this, width, height, options );
2577
2578	this.samples = 4;
2579
2580}
2581
2582WebGLMultisampleRenderTarget.prototype = Object.assign( Object.create( WebGLRenderTarget.prototype ), {
2583
2584	constructor: WebGLMultisampleRenderTarget,
2585
2586	isWebGLMultisampleRenderTarget: true,
2587
2588	copy: function ( source ) {
2589
2590		WebGLRenderTarget.prototype.copy.call( this, source );
2591
2592		this.samples = source.samples;
2593
2594		return this;
2595
2596	}
2597
2598} );
2599
2600/**
2601 * @author mikael emtinger / http://gomo.se/
2602 * @author alteredq / http://alteredqualia.com/
2603 * @author WestLangley / http://github.com/WestLangley
2604 * @author bhouston / http://clara.io
2605 */
2606
2607function Quaternion( x, y, z, w ) {
2608
2609	this._x = x || 0;
2610	this._y = y || 0;
2611	this._z = z || 0;
2612	this._w = ( w !== undefined ) ? w : 1;
2613
2614}
2615
2616Object.assign( Quaternion, {
2617
2618	slerp: function ( qa, qb, qm, t ) {
2619
2620		return qm.copy( qa ).slerp( qb, t );
2621
2622	},
2623
2624	slerpFlat: function ( dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) {
2625
2626		// fuzz-free, array-based Quaternion SLERP operation
2627
2628		var x0 = src0[ srcOffset0 + 0 ],
2629			y0 = src0[ srcOffset0 + 1 ],
2630			z0 = src0[ srcOffset0 + 2 ],
2631			w0 = src0[ srcOffset0 + 3 ],
2632
2633			x1 = src1[ srcOffset1 + 0 ],
2634			y1 = src1[ srcOffset1 + 1 ],
2635			z1 = src1[ srcOffset1 + 2 ],
2636			w1 = src1[ srcOffset1 + 3 ];
2637
2638		if ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) {
2639
2640			var s = 1 - t,
2641
2642				cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
2643
2644				dir = ( cos >= 0 ? 1 : - 1 ),
2645				sqrSin = 1 - cos * cos;
2646
2647			// Skip the Slerp for tiny steps to avoid numeric problems:
2648			if ( sqrSin > Number.EPSILON ) {
2649
2650				var sin = Math.sqrt( sqrSin ),
2651					len = Math.atan2( sin, cos * dir );
2652
2653				s = Math.sin( s * len ) / sin;
2654				t = Math.sin( t * len ) / sin;
2655
2656			}
2657
2658			var tDir = t * dir;
2659
2660			x0 = x0 * s + x1 * tDir;
2661			y0 = y0 * s + y1 * tDir;
2662			z0 = z0 * s + z1 * tDir;
2663			w0 = w0 * s + w1 * tDir;
2664
2665			// Normalize in case we just did a lerp:
2666			if ( s === 1 - t ) {
2667
2668				var f = 1 / Math.sqrt( x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0 );
2669
2670				x0 *= f;
2671				y0 *= f;
2672				z0 *= f;
2673				w0 *= f;
2674
2675			}
2676
2677		}
2678
2679		dst[ dstOffset ] = x0;
2680		dst[ dstOffset + 1 ] = y0;
2681		dst[ dstOffset + 2 ] = z0;
2682		dst[ dstOffset + 3 ] = w0;
2683
2684	},
2685
2686	multiplyQuaternionsFlat: function ( dst, dstOffset, src0, srcOffset0, src1, srcOffset1 ) {
2687
2688		var x0 = src0[ srcOffset0 ];
2689		var y0 = src0[ srcOffset0 + 1 ];
2690		var z0 = src0[ srcOffset0 + 2 ];
2691		var w0 = src0[ srcOffset0 + 3 ];
2692
2693		var x1 = src1[ srcOffset1 ];
2694		var y1 = src1[ srcOffset1 + 1 ];
2695		var z1 = src1[ srcOffset1 + 2 ];
2696		var w1 = src1[ srcOffset1 + 3 ];
2697
2698		dst[ dstOffset ] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
2699		dst[ dstOffset + 1 ] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
2700		dst[ dstOffset + 2 ] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
2701		dst[ dstOffset + 3 ] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
2702
2703		return dst;
2704
2705	}
2706
2707} );
2708
2709Object.defineProperties( Quaternion.prototype, {
2710
2711	x: {
2712
2713		get: function () {
2714
2715			return this._x;
2716
2717		},
2718
2719		set: function ( value ) {
2720
2721			this._x = value;
2722			this._onChangeCallback();
2723
2724		}
2725
2726	},
2727
2728	y: {
2729
2730		get: function () {
2731
2732			return this._y;
2733
2734		},
2735
2736		set: function ( value ) {
2737
2738			this._y = value;
2739			this._onChangeCallback();
2740
2741		}
2742
2743	},
2744