Web Inspector: Add three.js in preparation for layer visualization.
[WebKit-https.git] / Source / WebInspectorUI / UserInterface / External / three.js / three.js
1 (function (global, factory) {
2     typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
3     typeof define === 'function' && define.amd ? define(['exports'], factory) :
4     (factory((global.THREE = global.THREE || {})));
5 }(this, (function (exports) { 'use strict';
6
7     // Polyfills
8
9     if ( Number.EPSILON === undefined ) {
10
11         Number.EPSILON = Math.pow( 2, - 52 );
12
13     }
14
15     if ( Number.isInteger === undefined ) {
16
17         // Missing in IE
18         // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
19
20         Number.isInteger = function ( value ) {
21
22             return typeof value === 'number' && isFinite( value ) && Math.floor( value ) === value;
23
24         };
25
26     }
27
28     //
29
30     if ( Math.sign === undefined ) {
31
32         // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign
33
34         Math.sign = function ( x ) {
35
36             return ( x < 0 ) ? - 1 : ( x > 0 ) ? 1 : + x;
37
38         };
39
40     }
41
42     if ( Function.prototype.name === undefined ) {
43
44         // Missing in IE
45         // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
46
47         Object.defineProperty( Function.prototype, 'name', {
48
49             get: function () {
50
51                 return this.toString().match( /^\s*function\s*([^\(\s]*)/ )[ 1 ];
52
53             }
54
55         } );
56
57     }
58
59     if ( Object.assign === undefined ) {
60
61         // Missing in IE
62         // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
63
64         ( function () {
65
66             Object.assign = function ( target ) {
67
68                 'use strict';
69
70                 if ( target === undefined || target === null ) {
71
72                     throw new TypeError( 'Cannot convert undefined or null to object' );
73
74                 }
75
76                 var output = Object( target );
77
78                 for ( var index = 1; index < arguments.length; index ++ ) {
79
80                     var source = arguments[ index ];
81
82                     if ( source !== undefined && source !== null ) {
83
84                         for ( var nextKey in source ) {
85
86                             if ( Object.prototype.hasOwnProperty.call( source, nextKey ) ) {
87
88                                 output[ nextKey ] = source[ nextKey ];
89
90                             }
91
92                         }
93
94                     }
95
96                 }
97
98                 return output;
99
100             };
101
102         } )();
103
104     }
105
106     /**
107      * https://github.com/mrdoob/eventdispatcher.js/
108      */
109
110     function EventDispatcher() {}
111
112     Object.assign( EventDispatcher.prototype, {
113
114         addEventListener: function ( type, listener ) {
115
116             if ( this._listeners === undefined ) this._listeners = {};
117
118             var listeners = this._listeners;
119
120             if ( listeners[ type ] === undefined ) {
121
122                 listeners[ type ] = [];
123
124             }
125
126             if ( listeners[ type ].indexOf( listener ) === - 1 ) {
127
128                 listeners[ type ].push( listener );
129
130             }
131
132         },
133
134         hasEventListener: function ( type, listener ) {
135
136             if ( this._listeners === undefined ) return false;
137
138             var listeners = this._listeners;
139
140             return listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1;
141
142         },
143
144         removeEventListener: function ( type, listener ) {
145
146             if ( this._listeners === undefined ) return;
147
148             var listeners = this._listeners;
149             var listenerArray = listeners[ type ];
150
151             if ( listenerArray !== undefined ) {
152
153                 var index = listenerArray.indexOf( listener );
154
155                 if ( index !== - 1 ) {
156
157                     listenerArray.splice( index, 1 );
158
159                 }
160
161             }
162
163         },
164
165         dispatchEvent: function ( event ) {
166
167             if ( this._listeners === undefined ) return;
168
169             var listeners = this._listeners;
170             var listenerArray = listeners[ event.type ];
171
172             if ( listenerArray !== undefined ) {
173
174                 event.target = this;
175
176                 var array = listenerArray.slice( 0 );
177
178                 for ( var i = 0, l = array.length; i < l; i ++ ) {
179
180                     array[ i ].call( this, event );
181
182                 }
183
184             }
185
186         }
187
188     } );
189
190     var REVISION = '86';
191     var MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2 };
192     var CullFaceNone = 0;
193     var CullFaceBack = 1;
194     var CullFaceFront = 2;
195     var CullFaceFrontBack = 3;
196     var FrontFaceDirectionCW = 0;
197     var FrontFaceDirectionCCW = 1;
198     var BasicShadowMap = 0;
199     var PCFShadowMap = 1;
200     var PCFSoftShadowMap = 2;
201     var FrontSide = 0;
202     var BackSide = 1;
203     var DoubleSide = 2;
204     var FlatShading = 1;
205     var SmoothShading = 2;
206     var NoColors = 0;
207     var FaceColors = 1;
208     var VertexColors = 2;
209     var NoBlending = 0;
210     var NormalBlending = 1;
211     var AdditiveBlending = 2;
212     var SubtractiveBlending = 3;
213     var MultiplyBlending = 4;
214     var CustomBlending = 5;
215     var AddEquation = 100;
216     var SubtractEquation = 101;
217     var ReverseSubtractEquation = 102;
218     var MinEquation = 103;
219     var MaxEquation = 104;
220     var ZeroFactor = 200;
221     var OneFactor = 201;
222     var SrcColorFactor = 202;
223     var OneMinusSrcColorFactor = 203;
224     var SrcAlphaFactor = 204;
225     var OneMinusSrcAlphaFactor = 205;
226     var DstAlphaFactor = 206;
227     var OneMinusDstAlphaFactor = 207;
228     var DstColorFactor = 208;
229     var OneMinusDstColorFactor = 209;
230     var SrcAlphaSaturateFactor = 210;
231     var NeverDepth = 0;
232     var AlwaysDepth = 1;
233     var LessDepth = 2;
234     var LessEqualDepth = 3;
235     var EqualDepth = 4;
236     var GreaterEqualDepth = 5;
237     var GreaterDepth = 6;
238     var NotEqualDepth = 7;
239     var MultiplyOperation = 0;
240     var MixOperation = 1;
241     var AddOperation = 2;
242     var NoToneMapping = 0;
243     var LinearToneMapping = 1;
244     var ReinhardToneMapping = 2;
245     var Uncharted2ToneMapping = 3;
246     var CineonToneMapping = 4;
247     var UVMapping = 300;
248     var CubeReflectionMapping = 301;
249     var CubeRefractionMapping = 302;
250     var EquirectangularReflectionMapping = 303;
251     var EquirectangularRefractionMapping = 304;
252     var SphericalReflectionMapping = 305;
253     var CubeUVReflectionMapping = 306;
254     var CubeUVRefractionMapping = 307;
255     var RepeatWrapping = 1000;
256     var ClampToEdgeWrapping = 1001;
257     var MirroredRepeatWrapping = 1002;
258     var NearestFilter = 1003;
259     var NearestMipMapNearestFilter = 1004;
260     var NearestMipMapLinearFilter = 1005;
261     var LinearFilter = 1006;
262     var LinearMipMapNearestFilter = 1007;
263     var LinearMipMapLinearFilter = 1008;
264     var UnsignedByteType = 1009;
265     var ByteType = 1010;
266     var ShortType = 1011;
267     var UnsignedShortType = 1012;
268     var IntType = 1013;
269     var UnsignedIntType = 1014;
270     var FloatType = 1015;
271     var HalfFloatType = 1016;
272     var UnsignedShort4444Type = 1017;
273     var UnsignedShort5551Type = 1018;
274     var UnsignedShort565Type = 1019;
275     var UnsignedInt248Type = 1020;
276     var AlphaFormat = 1021;
277     var RGBFormat = 1022;
278     var RGBAFormat = 1023;
279     var LuminanceFormat = 1024;
280     var LuminanceAlphaFormat = 1025;
281     var RGBEFormat = RGBAFormat;
282     var DepthFormat = 1026;
283     var DepthStencilFormat = 1027;
284     var RGB_S3TC_DXT1_Format = 2001;
285     var RGBA_S3TC_DXT1_Format = 2002;
286     var RGBA_S3TC_DXT3_Format = 2003;
287     var RGBA_S3TC_DXT5_Format = 2004;
288     var RGB_PVRTC_4BPPV1_Format = 2100;
289     var RGB_PVRTC_2BPPV1_Format = 2101;
290     var RGBA_PVRTC_4BPPV1_Format = 2102;
291     var RGBA_PVRTC_2BPPV1_Format = 2103;
292     var RGB_ETC1_Format = 2151;
293     var LoopOnce = 2200;
294     var LoopRepeat = 2201;
295     var LoopPingPong = 2202;
296     var InterpolateDiscrete = 2300;
297     var InterpolateLinear = 2301;
298     var InterpolateSmooth = 2302;
299     var ZeroCurvatureEnding = 2400;
300     var ZeroSlopeEnding = 2401;
301     var WrapAroundEnding = 2402;
302     var TrianglesDrawMode = 0;
303     var TriangleStripDrawMode = 1;
304     var TriangleFanDrawMode = 2;
305     var LinearEncoding = 3000;
306     var sRGBEncoding = 3001;
307     var GammaEncoding = 3007;
308     var RGBEEncoding = 3002;
309     var LogLuvEncoding = 3003;
310     var RGBM7Encoding = 3004;
311     var RGBM16Encoding = 3005;
312     var RGBDEncoding = 3006;
313     var BasicDepthPacking = 3200;
314     var RGBADepthPacking = 3201;
315
316     /**
317      * @author alteredq / http://alteredqualia.com/
318      * @author mrdoob / http://mrdoob.com/
319      */
320
321     var _Math = {
322
323         DEG2RAD: Math.PI / 180,
324         RAD2DEG: 180 / Math.PI,
325
326         generateUUID: function () {
327
328             // http://www.broofa.com/Tools/Math.uuid.htm
329
330             var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split( '' );
331             var uuid = new Array( 36 );
332             var rnd = 0, r;
333
334             return function generateUUID() {
335
336                 for ( var i = 0; i < 36; i ++ ) {
337
338                     if ( i === 8 || i === 13 || i === 18 || i === 23 ) {
339
340                         uuid[ i ] = '-';
341
342                     } else if ( i === 14 ) {
343
344                         uuid[ i ] = '4';
345
346                     } else {
347
348                         if ( rnd <= 0x02 ) rnd = 0x2000000 + ( Math.random() * 0x1000000 ) | 0;
349                         r = rnd & 0xf;
350                         rnd = rnd >> 4;
351                         uuid[ i ] = chars[ ( i === 19 ) ? ( r & 0x3 ) | 0x8 : r ];
352
353                     }
354
355                 }
356
357                 return uuid.join( '' );
358
359             };
360
361         }(),
362
363         clamp: function ( value, min, max ) {
364
365             return Math.max( min, Math.min( max, value ) );
366
367         },
368
369         // compute euclidian modulo of m % n
370         // https://en.wikipedia.org/wiki/Modulo_operation
371
372         euclideanModulo: function ( n, m ) {
373
374             return ( ( n % m ) + m ) % m;
375
376         },
377
378         // Linear mapping from range <a1, a2> to range <b1, b2>
379
380         mapLinear: function ( x, a1, a2, b1, b2 ) {
381
382             return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );
383
384         },
385
386         // https://en.wikipedia.org/wiki/Linear_interpolation
387
388         lerp: function ( x, y, t ) {
389
390             return ( 1 - t ) * x + t * y;
391
392         },
393
394         // http://en.wikipedia.org/wiki/Smoothstep
395
396         smoothstep: function ( x, min, max ) {
397
398             if ( x <= min ) return 0;
399             if ( x >= max ) return 1;
400
401             x = ( x - min ) / ( max - min );
402
403             return x * x * ( 3 - 2 * x );
404
405         },
406
407         smootherstep: function ( x, min, max ) {
408
409             if ( x <= min ) return 0;
410             if ( x >= max ) return 1;
411
412             x = ( x - min ) / ( max - min );
413
414             return x * x * x * ( x * ( x * 6 - 15 ) + 10 );
415
416         },
417
418         // Random integer from <low, high> interval
419
420         randInt: function ( low, high ) {
421
422             return low + Math.floor( Math.random() * ( high - low + 1 ) );
423
424         },
425
426         // Random float from <low, high> interval
427
428         randFloat: function ( low, high ) {
429
430             return low + Math.random() * ( high - low );
431
432         },
433
434         // Random float from <-range/2, range/2> interval
435
436         randFloatSpread: function ( range ) {
437
438             return range * ( 0.5 - Math.random() );
439
440         },
441
442         degToRad: function ( degrees ) {
443
444             return degrees * _Math.DEG2RAD;
445
446         },
447
448         radToDeg: function ( radians ) {
449
450             return radians * _Math.RAD2DEG;
451
452         },
453
454         isPowerOfTwo: function ( value ) {
455
456             return ( value & ( value - 1 ) ) === 0 && value !== 0;
457
458         },
459
460         nearestPowerOfTwo: function ( value ) {
461
462             return Math.pow( 2, Math.round( Math.log( value ) / Math.LN2 ) );
463
464         },
465
466         nextPowerOfTwo: function ( value ) {
467
468             value --;
469             value |= value >> 1;
470             value |= value >> 2;
471             value |= value >> 4;
472             value |= value >> 8;
473             value |= value >> 16;
474             value ++;
475
476             return value;
477
478         }
479
480     };
481
482     /**
483      * @author mrdoob / http://mrdoob.com/
484      * @author philogb / http://blog.thejit.org/
485      * @author egraether / http://egraether.com/
486      * @author zz85 / http://www.lab4games.net/zz85/blog
487      */
488
489     function Vector2( x, y ) {
490
491         this.x = x || 0;
492         this.y = y || 0;
493
494     }
495
496     Object.defineProperties( Vector2.prototype, {
497
498         "width" : {
499
500             get: function () {
501
502                 return this.x;
503
504             },
505
506             set: function ( value ) {
507
508                 this.x = value;
509
510             }
511
512         },
513
514         "height" : {
515
516             get: function () {
517
518                 return this.y;
519
520             },
521
522             set: function ( value ) {
523
524                 this.y = value;
525
526             }
527
528         }
529
530     } );
531
532     Object.assign( Vector2.prototype, {
533
534         isVector2: true,
535
536         set: function ( x, y ) {
537
538             this.x = x;
539             this.y = y;
540
541             return this;
542
543         },
544
545         setScalar: function ( scalar ) {
546
547             this.x = scalar;
548             this.y = scalar;
549
550             return this;
551
552         },
553
554         setX: function ( x ) {
555
556             this.x = x;
557
558             return this;
559
560         },
561
562         setY: function ( y ) {
563
564             this.y = y;
565
566             return this;
567
568         },
569
570         setComponent: function ( index, value ) {
571
572             switch ( index ) {
573
574                 case 0: this.x = value; break;
575                 case 1: this.y = value; break;
576                 default: throw new Error( 'index is out of range: ' + index );
577
578             }
579
580             return this;
581
582         },
583
584         getComponent: function ( index ) {
585
586             switch ( index ) {
587
588                 case 0: return this.x;
589                 case 1: return this.y;
590                 default: throw new Error( 'index is out of range: ' + index );
591
592             }
593
594         },
595
596         clone: function () {
597
598             return new this.constructor( this.x, this.y );
599
600         },
601
602         copy: function ( v ) {
603
604             this.x = v.x;
605             this.y = v.y;
606
607             return this;
608
609         },
610
611         add: function ( v, w ) {
612
613             if ( w !== undefined ) {
614
615                 console.warn( 'THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
616                 return this.addVectors( v, w );
617
618             }
619
620             this.x += v.x;
621             this.y += v.y;
622
623             return this;
624
625         },
626
627         addScalar: function ( s ) {
628
629             this.x += s;
630             this.y += s;
631
632             return this;
633
634         },
635
636         addVectors: function ( a, b ) {
637
638             this.x = a.x + b.x;
639             this.y = a.y + b.y;
640
641             return this;
642
643         },
644
645         addScaledVector: function ( v, s ) {
646
647             this.x += v.x * s;
648             this.y += v.y * s;
649
650             return this;
651
652         },
653
654         sub: function ( v, w ) {
655
656             if ( w !== undefined ) {
657
658                 console.warn( 'THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
659                 return this.subVectors( v, w );
660
661             }
662
663             this.x -= v.x;
664             this.y -= v.y;
665
666             return this;
667
668         },
669
670         subScalar: function ( s ) {
671
672             this.x -= s;
673             this.y -= s;
674
675             return this;
676
677         },
678
679         subVectors: function ( a, b ) {
680
681             this.x = a.x - b.x;
682             this.y = a.y - b.y;
683
684             return this;
685
686         },
687
688         multiply: function ( v ) {
689
690             this.x *= v.x;
691             this.y *= v.y;
692
693             return this;
694
695         },
696
697         multiplyScalar: function ( scalar ) {
698
699             this.x *= scalar;
700             this.y *= scalar;
701
702             return this;
703
704         },
705
706         divide: function ( v ) {
707
708             this.x /= v.x;
709             this.y /= v.y;
710
711             return this;
712
713         },
714
715         divideScalar: function ( scalar ) {
716
717             return this.multiplyScalar( 1 / scalar );
718
719         },
720
721         min: function ( v ) {
722
723             this.x = Math.min( this.x, v.x );
724             this.y = Math.min( this.y, v.y );
725
726             return this;
727
728         },
729
730         max: function ( v ) {
731
732             this.x = Math.max( this.x, v.x );
733             this.y = Math.max( this.y, v.y );
734
735             return this;
736
737         },
738
739         clamp: function ( min, max ) {
740
741             // assumes min < max, componentwise
742
743             this.x = Math.max( min.x, Math.min( max.x, this.x ) );
744             this.y = Math.max( min.y, Math.min( max.y, this.y ) );
745
746             return this;
747
748         },
749
750         clampScalar: function () {
751
752             var min = new Vector2();
753             var max = new Vector2();
754
755             return function clampScalar( minVal, maxVal ) {
756
757                 min.set( minVal, minVal );
758                 max.set( maxVal, maxVal );
759
760                 return this.clamp( min, max );
761
762             };
763
764         }(),
765
766         clampLength: function ( min, max ) {
767
768             var length = this.length();
769
770             return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
771
772         },
773
774         floor: function () {
775
776             this.x = Math.floor( this.x );
777             this.y = Math.floor( this.y );
778
779             return this;
780
781         },
782
783         ceil: function () {
784
785             this.x = Math.ceil( this.x );
786             this.y = Math.ceil( this.y );
787
788             return this;
789
790         },
791
792         round: function () {
793
794             this.x = Math.round( this.x );
795             this.y = Math.round( this.y );
796
797             return this;
798
799         },
800
801         roundToZero: function () {
802
803             this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
804             this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
805
806             return this;
807
808         },
809
810         negate: function () {
811
812             this.x = - this.x;
813             this.y = - this.y;
814
815             return this;
816
817         },
818
819         dot: function ( v ) {
820
821             return this.x * v.x + this.y * v.y;
822
823         },
824
825         lengthSq: function () {
826
827             return this.x * this.x + this.y * this.y;
828
829         },
830
831         length: function () {
832
833             return Math.sqrt( this.x * this.x + this.y * this.y );
834
835         },
836
837         lengthManhattan: function() {
838
839             return Math.abs( this.x ) + Math.abs( this.y );
840
841         },
842
843         normalize: function () {
844
845             return this.divideScalar( this.length() || 1 );
846
847         },
848
849         angle: function () {
850
851             // computes the angle in radians with respect to the positive x-axis
852
853             var angle = Math.atan2( this.y, this.x );
854
855             if ( angle < 0 ) angle += 2 * Math.PI;
856
857             return angle;
858
859         },
860
861         distanceTo: function ( v ) {
862
863             return Math.sqrt( this.distanceToSquared( v ) );
864
865         },
866
867         distanceToSquared: function ( v ) {
868
869             var dx = this.x - v.x, dy = this.y - v.y;
870             return dx * dx + dy * dy;
871
872         },
873
874         distanceToManhattan: function ( v ) {
875
876             return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y );
877
878         },
879
880         setLength: function ( length ) {
881
882             return this.normalize().multiplyScalar( length );
883
884         },
885
886         lerp: function ( v, alpha ) {
887
888             this.x += ( v.x - this.x ) * alpha;
889             this.y += ( v.y - this.y ) * alpha;
890
891             return this;
892
893         },
894
895         lerpVectors: function ( v1, v2, alpha ) {
896
897             return this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
898
899         },
900
901         equals: function ( v ) {
902
903             return ( ( v.x === this.x ) && ( v.y === this.y ) );
904
905         },
906
907         fromArray: function ( array, offset ) {
908
909             if ( offset === undefined ) offset = 0;
910
911             this.x = array[ offset ];
912             this.y = array[ offset + 1 ];
913
914             return this;
915
916         },
917
918         toArray: function ( array, offset ) {
919
920             if ( array === undefined ) array = [];
921             if ( offset === undefined ) offset = 0;
922
923             array[ offset ] = this.x;
924             array[ offset + 1 ] = this.y;
925
926             return array;
927
928         },
929
930         fromBufferAttribute: function ( attribute, index, offset ) {
931
932             if ( offset !== undefined ) {
933
934                 console.warn( 'THREE.Vector2: offset has been removed from .fromBufferAttribute().' );
935
936             }
937
938             this.x = attribute.getX( index );
939             this.y = attribute.getY( index );
940
941             return this;
942
943         },
944
945         rotateAround: function ( center, angle ) {
946
947             var c = Math.cos( angle ), s = Math.sin( angle );
948
949             var x = this.x - center.x;
950             var y = this.y - center.y;
951
952             this.x = x * c - y * s + center.x;
953             this.y = x * s + y * c + center.y;
954
955             return this;
956
957         }
958
959     } );
960
961     /**
962      * @author mrdoob / http://mrdoob.com/
963      * @author alteredq / http://alteredqualia.com/
964      * @author szimek / https://github.com/szimek/
965      */
966
967     var textureId = 0;
968
969     function Texture( image, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) {
970
971         Object.defineProperty( this, 'id', { value: textureId ++ } );
972
973         this.uuid = _Math.generateUUID();
974
975         this.name = '';
976
977         this.image = image !== undefined ? image : Texture.DEFAULT_IMAGE;
978         this.mipmaps = [];
979
980         this.mapping = mapping !== undefined ? mapping : Texture.DEFAULT_MAPPING;
981
982         this.wrapS = wrapS !== undefined ? wrapS : ClampToEdgeWrapping;
983         this.wrapT = wrapT !== undefined ? wrapT : ClampToEdgeWrapping;
984
985         this.magFilter = magFilter !== undefined ? magFilter : LinearFilter;
986         this.minFilter = minFilter !== undefined ? minFilter : LinearMipMapLinearFilter;
987
988         this.anisotropy = anisotropy !== undefined ? anisotropy : 1;
989
990         this.format = format !== undefined ? format : RGBAFormat;
991         this.type = type !== undefined ? type : UnsignedByteType;
992
993         this.offset = new Vector2( 0, 0 );
994         this.repeat = new Vector2( 1, 1 );
995
996         this.generateMipmaps = true;
997         this.premultiplyAlpha = false;
998         this.flipY = true;
999         this.unpackAlignment = 4;   // valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
1000
1001         // Values of encoding !== THREE.LinearEncoding only supported on map, envMap and emissiveMap.
1002         //
1003         // Also changing the encoding after already used by a Material will not automatically make the Material
1004         // update.  You need to explicitly call Material.needsUpdate to trigger it to recompile.
1005         this.encoding = encoding !== undefined ? encoding : LinearEncoding;
1006
1007         this.version = 0;
1008         this.onUpdate = null;
1009
1010     }
1011
1012     Texture.DEFAULT_IMAGE = undefined;
1013     Texture.DEFAULT_MAPPING = UVMapping;
1014
1015     Object.defineProperty( Texture.prototype, "needsUpdate", {
1016
1017         set: function ( value ) {
1018
1019             if ( value === true ) this.version ++;
1020
1021         }
1022
1023     } );
1024
1025     Object.assign( Texture.prototype, EventDispatcher.prototype, {
1026
1027         constructor: Texture,
1028
1029         isTexture: true,
1030
1031         clone: function () {
1032
1033             return new this.constructor().copy( this );
1034
1035         },
1036
1037         copy: function ( source ) {
1038
1039             this.name = source.name;
1040
1041             this.image = source.image;
1042             this.mipmaps = source.mipmaps.slice( 0 );
1043
1044             this.mapping = source.mapping;
1045
1046             this.wrapS = source.wrapS;
1047             this.wrapT = source.wrapT;
1048
1049             this.magFilter = source.magFilter;
1050             this.minFilter = source.minFilter;
1051
1052             this.anisotropy = source.anisotropy;
1053
1054             this.format = source.format;
1055             this.type = source.type;
1056
1057             this.offset.copy( source.offset );
1058             this.repeat.copy( source.repeat );
1059
1060             this.generateMipmaps = source.generateMipmaps;
1061             this.premultiplyAlpha = source.premultiplyAlpha;
1062             this.flipY = source.flipY;
1063             this.unpackAlignment = source.unpackAlignment;
1064             this.encoding = source.encoding;
1065
1066             return this;
1067
1068         },
1069
1070         toJSON: function ( meta ) {
1071
1072             if ( meta.textures[ this.uuid ] !== undefined ) {
1073
1074                 return meta.textures[ this.uuid ];
1075
1076             }
1077
1078             function getDataURL( image ) {
1079
1080                 var canvas;
1081
1082                 if ( image.toDataURL !== undefined ) {
1083
1084                     canvas = image;
1085
1086                 } else {
1087
1088                     canvas = document.createElementNS( 'http://www.w3.org/1999/xhtml', 'canvas' );
1089                     canvas.width = image.width;
1090                     canvas.height = image.height;
1091
1092                     canvas.getContext( '2d' ).drawImage( image, 0, 0, image.width, image.height );
1093
1094                 }
1095
1096                 if ( canvas.width > 2048 || canvas.height > 2048 ) {
1097
1098                     return canvas.toDataURL( 'image/jpeg', 0.6 );
1099
1100                 } else {
1101
1102                     return canvas.toDataURL( 'image/png' );
1103
1104                 }
1105
1106             }
1107
1108             var output = {
1109                 metadata: {
1110                     version: 4.5,
1111                     type: 'Texture',
1112                     generator: 'Texture.toJSON'
1113                 },
1114
1115                 uuid: this.uuid,
1116                 name: this.name,
1117
1118                 mapping: this.mapping,
1119
1120                 repeat: [ this.repeat.x, this.repeat.y ],
1121                 offset: [ this.offset.x, this.offset.y ],
1122                 wrap: [ this.wrapS, this.wrapT ],
1123
1124                 minFilter: this.minFilter,
1125                 magFilter: this.magFilter,
1126                 anisotropy: this.anisotropy,
1127
1128                 flipY: this.flipY
1129             };
1130
1131             if ( this.image !== undefined ) {
1132
1133                 // TODO: Move to THREE.Image
1134
1135                 var image = this.image;
1136
1137                 if ( image.uuid === undefined ) {
1138
1139                     image.uuid = _Math.generateUUID(); // UGH
1140
1141                 }
1142
1143                 if ( meta.images[ image.uuid ] === undefined ) {
1144
1145                     meta.images[ image.uuid ] = {
1146                         uuid: image.uuid,
1147                         url: getDataURL( image )
1148                     };
1149
1150                 }
1151
1152                 output.image = image.uuid;
1153
1154             }
1155
1156             meta.textures[ this.uuid ] = output;
1157
1158             return output;
1159
1160         },
1161
1162         dispose: function () {
1163
1164             this.dispatchEvent( { type: 'dispose' } );
1165
1166         },
1167
1168         transformUv: function ( uv ) {
1169
1170             if ( this.mapping !== UVMapping ) return;
1171
1172             uv.multiply( this.repeat );
1173             uv.add( this.offset );
1174
1175             if ( uv.x < 0 || uv.x > 1 ) {
1176
1177                 switch ( this.wrapS ) {
1178
1179                     case RepeatWrapping:
1180
1181                         uv.x = uv.x - Math.floor( uv.x );
1182                         break;
1183
1184                     case ClampToEdgeWrapping:
1185
1186                         uv.x = uv.x < 0 ? 0 : 1;
1187                         break;
1188
1189                     case MirroredRepeatWrapping:
1190
1191                         if ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) {
1192
1193                             uv.x = Math.ceil( uv.x ) - uv.x;
1194
1195                         } else {
1196
1197                             uv.x = uv.x - Math.floor( uv.x );
1198
1199                         }
1200                         break;
1201
1202                 }
1203
1204             }
1205
1206             if ( uv.y < 0 || uv.y > 1 ) {
1207
1208                 switch ( this.wrapT ) {
1209
1210                     case RepeatWrapping:
1211
1212                         uv.y = uv.y - Math.floor( uv.y );
1213                         break;
1214
1215                     case ClampToEdgeWrapping:
1216
1217                         uv.y = uv.y < 0 ? 0 : 1;
1218                         break;
1219
1220                     case MirroredRepeatWrapping:
1221
1222                         if ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) {
1223
1224                             uv.y = Math.ceil( uv.y ) - uv.y;
1225
1226                         } else {
1227
1228                             uv.y = uv.y - Math.floor( uv.y );
1229
1230                         }
1231                         break;
1232
1233                 }
1234
1235             }
1236
1237             if ( this.flipY ) {
1238
1239                 uv.y = 1 - uv.y;
1240
1241             }
1242
1243         }
1244
1245     } );
1246
1247     /**
1248      * @author supereggbert / http://www.paulbrunt.co.uk/
1249      * @author philogb / http://blog.thejit.org/
1250      * @author mikael emtinger / http://gomo.se/
1251      * @author egraether / http://egraether.com/
1252      * @author WestLangley / http://github.com/WestLangley
1253      */
1254
1255     function Vector4( x, y, z, w ) {
1256
1257         this.x = x || 0;
1258         this.y = y || 0;
1259         this.z = z || 0;
1260         this.w = ( w !== undefined ) ? w : 1;
1261
1262     }
1263
1264     Object.assign( Vector4.prototype, {
1265
1266         isVector4: true,
1267
1268         set: function ( x, y, z, w ) {
1269
1270             this.x = x;
1271             this.y = y;
1272             this.z = z;
1273             this.w = w;
1274
1275             return this;
1276
1277         },
1278
1279         setScalar: function ( scalar ) {
1280
1281             this.x = scalar;
1282             this.y = scalar;
1283             this.z = scalar;
1284             this.w = scalar;
1285
1286             return this;
1287
1288         },
1289
1290         setX: function ( x ) {
1291
1292             this.x = x;
1293
1294             return this;
1295
1296         },
1297
1298         setY: function ( y ) {
1299
1300             this.y = y;
1301
1302             return this;
1303
1304         },
1305
1306         setZ: function ( z ) {
1307
1308             this.z = z;
1309
1310             return this;
1311
1312         },
1313
1314         setW: function ( w ) {
1315
1316             this.w = w;
1317
1318             return this;
1319
1320         },
1321
1322         setComponent: function ( index, value ) {
1323
1324             switch ( index ) {
1325
1326                 case 0: this.x = value; break;
1327                 case 1: this.y = value; break;
1328                 case 2: this.z = value; break;
1329                 case 3: this.w = value; break;
1330                 default: throw new Error( 'index is out of range: ' + index );
1331
1332             }
1333
1334             return this;
1335
1336         },
1337
1338         getComponent: function ( index ) {
1339
1340             switch ( index ) {
1341
1342                 case 0: return this.x;
1343                 case 1: return this.y;
1344                 case 2: return this.z;
1345                 case 3: return this.w;
1346                 default: throw new Error( 'index is out of range: ' + index );
1347
1348             }
1349
1350         },
1351
1352         clone: function () {
1353
1354             return new this.constructor( this.x, this.y, this.z, this.w );
1355
1356         },
1357
1358         copy: function ( v ) {
1359
1360             this.x = v.x;
1361             this.y = v.y;
1362             this.z = v.z;
1363             this.w = ( v.w !== undefined ) ? v.w : 1;
1364
1365             return this;
1366
1367         },
1368
1369         add: function ( v, w ) {
1370
1371             if ( w !== undefined ) {
1372
1373                 console.warn( 'THREE.Vector4: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
1374                 return this.addVectors( v, w );
1375
1376             }
1377
1378             this.x += v.x;
1379             this.y += v.y;
1380             this.z += v.z;
1381             this.w += v.w;
1382
1383             return this;
1384
1385         },
1386
1387         addScalar: function ( s ) {
1388
1389             this.x += s;
1390             this.y += s;
1391             this.z += s;
1392             this.w += s;
1393
1394             return this;
1395
1396         },
1397
1398         addVectors: function ( a, b ) {
1399
1400             this.x = a.x + b.x;
1401             this.y = a.y + b.y;
1402             this.z = a.z + b.z;
1403             this.w = a.w + b.w;
1404
1405             return this;
1406
1407         },
1408
1409         addScaledVector: function ( v, s ) {
1410
1411             this.x += v.x * s;
1412             this.y += v.y * s;
1413             this.z += v.z * s;
1414             this.w += v.w * s;
1415
1416             return this;
1417
1418         },
1419
1420         sub: function ( v, w ) {
1421
1422             if ( w !== undefined ) {
1423
1424                 console.warn( 'THREE.Vector4: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
1425                 return this.subVectors( v, w );
1426
1427             }
1428
1429             this.x -= v.x;
1430             this.y -= v.y;
1431             this.z -= v.z;
1432             this.w -= v.w;
1433
1434             return this;
1435
1436         },
1437
1438         subScalar: function ( s ) {
1439
1440             this.x -= s;
1441             this.y -= s;
1442             this.z -= s;
1443             this.w -= s;
1444
1445             return this;
1446
1447         },
1448
1449         subVectors: function ( a, b ) {
1450
1451             this.x = a.x - b.x;
1452             this.y = a.y - b.y;
1453             this.z = a.z - b.z;
1454             this.w = a.w - b.w;
1455
1456             return this;
1457
1458         },
1459
1460         multiplyScalar: function ( scalar ) {
1461
1462             this.x *= scalar;
1463             this.y *= scalar;
1464             this.z *= scalar;
1465             this.w *= scalar;
1466
1467             return this;
1468
1469         },
1470
1471         applyMatrix4: function ( m ) {
1472
1473             var x = this.x, y = this.y, z = this.z, w = this.w;
1474             var e = m.elements;
1475
1476             this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w;
1477             this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w;
1478             this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w;
1479             this.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w;
1480
1481             return this;
1482
1483         },
1484
1485         divideScalar: function ( scalar ) {
1486
1487             return this.multiplyScalar( 1 / scalar );
1488
1489         },
1490
1491         setAxisAngleFromQuaternion: function ( q ) {
1492
1493             // http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
1494
1495             // q is assumed to be normalized
1496
1497             this.w = 2 * Math.acos( q.w );
1498
1499             var s = Math.sqrt( 1 - q.w * q.w );
1500
1501             if ( s < 0.0001 ) {
1502
1503                  this.x = 1;
1504                  this.y = 0;
1505                  this.z = 0;
1506
1507             } else {
1508
1509                  this.x = q.x / s;
1510                  this.y = q.y / s;
1511                  this.z = q.z / s;
1512
1513             }
1514
1515             return this;
1516
1517         },
1518
1519         setAxisAngleFromRotationMatrix: function ( m ) {
1520
1521             // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm
1522
1523             // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
1524
1525             var angle, x, y, z,     // variables for result
1526                 epsilon = 0.01,     // margin to allow for rounding errors
1527                 epsilon2 = 0.1,     // margin to distinguish between 0 and 180 degrees
1528
1529                 te = m.elements,
1530
1531                 m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
1532                 m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
1533                 m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ];
1534
1535             if ( ( Math.abs( m12 - m21 ) < epsilon ) &&
1536                  ( Math.abs( m13 - m31 ) < epsilon ) &&
1537                  ( Math.abs( m23 - m32 ) < epsilon ) ) {
1538
1539                 // singularity found
1540                 // first check for identity matrix which must have +1 for all terms
1541                 // in leading diagonal and zero in other terms
1542
1543                 if ( ( Math.abs( m12 + m21 ) < epsilon2 ) &&
1544                      ( Math.abs( m13 + m31 ) < epsilon2 ) &&
1545                      ( Math.abs( m23 + m32 ) < epsilon2 ) &&
1546                      ( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) {
1547
1548                     // this singularity is identity matrix so angle = 0
1549
1550                     this.set( 1, 0, 0, 0 );
1551
1552                     return this; // zero angle, arbitrary axis
1553
1554                 }
1555
1556                 // otherwise this singularity is angle = 180
1557
1558                 angle = Math.PI;
1559
1560                 var xx = ( m11 + 1 ) / 2;
1561                 var yy = ( m22 + 1 ) / 2;
1562                 var zz = ( m33 + 1 ) / 2;
1563                 var xy = ( m12 + m21 ) / 4;
1564                 var xz = ( m13 + m31 ) / 4;
1565                 var yz = ( m23 + m32 ) / 4;
1566
1567                 if ( ( xx > yy ) && ( xx > zz ) ) {
1568
1569                     // m11 is the largest diagonal term
1570
1571                     if ( xx < epsilon ) {
1572
1573                         x = 0;
1574                         y = 0.707106781;
1575                         z = 0.707106781;
1576
1577                     } else {
1578
1579                         x = Math.sqrt( xx );
1580                         y = xy / x;
1581                         z = xz / x;
1582
1583                     }
1584
1585                 } else if ( yy > zz ) {
1586
1587                     // m22 is the largest diagonal term
1588
1589                     if ( yy < epsilon ) {
1590
1591                         x = 0.707106781;
1592                         y = 0;
1593                         z = 0.707106781;
1594
1595                     } else {
1596
1597                         y = Math.sqrt( yy );
1598                         x = xy / y;
1599                         z = yz / y;
1600
1601                     }
1602
1603                 } else {
1604
1605                     // m33 is the largest diagonal term so base result on this
1606
1607                     if ( zz < epsilon ) {
1608
1609                         x = 0.707106781;
1610                         y = 0.707106781;
1611                         z = 0;
1612
1613                     } else {
1614
1615                         z = Math.sqrt( zz );
1616                         x = xz / z;
1617                         y = yz / z;
1618
1619                     }
1620
1621                 }
1622
1623                 this.set( x, y, z, angle );
1624
1625                 return this; // return 180 deg rotation
1626
1627             }
1628
1629             // as we have reached here there are no singularities so we can handle normally
1630
1631             var s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) +
1632                                ( m13 - m31 ) * ( m13 - m31 ) +
1633                                ( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize
1634
1635             if ( Math.abs( s ) < 0.001 ) s = 1;
1636
1637             // prevent divide by zero, should not happen if matrix is orthogonal and should be
1638             // caught by singularity test above, but I've left it in just in case
1639
1640             this.x = ( m32 - m23 ) / s;
1641             this.y = ( m13 - m31 ) / s;
1642             this.z = ( m21 - m12 ) / s;
1643             this.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 );
1644
1645             return this;
1646
1647         },
1648
1649         min: function ( v ) {
1650
1651             this.x = Math.min( this.x, v.x );
1652             this.y = Math.min( this.y, v.y );
1653             this.z = Math.min( this.z, v.z );
1654             this.w = Math.min( this.w, v.w );
1655
1656             return this;
1657
1658         },
1659
1660         max: function ( v ) {
1661
1662             this.x = Math.max( this.x, v.x );
1663             this.y = Math.max( this.y, v.y );
1664             this.z = Math.max( this.z, v.z );
1665             this.w = Math.max( this.w, v.w );
1666
1667             return this;
1668
1669         },
1670
1671         clamp: function ( min, max ) {
1672
1673             // assumes min < max, componentwise
1674
1675             this.x = Math.max( min.x, Math.min( max.x, this.x ) );
1676             this.y = Math.max( min.y, Math.min( max.y, this.y ) );
1677             this.z = Math.max( min.z, Math.min( max.z, this.z ) );
1678             this.w = Math.max( min.w, Math.min( max.w, this.w ) );
1679
1680             return this;
1681
1682         },
1683
1684         clampScalar: function () {
1685
1686             var min, max;
1687
1688             return function clampScalar( minVal, maxVal ) {
1689
1690                 if ( min === undefined ) {
1691
1692                     min = new Vector4();
1693                     max = new Vector4();
1694
1695                 }
1696
1697                 min.set( minVal, minVal, minVal, minVal );
1698                 max.set( maxVal, maxVal, maxVal, maxVal );
1699
1700                 return this.clamp( min, max );
1701
1702             };
1703
1704         }(),
1705
1706         clampLength: function ( min, max ) {
1707
1708             var length = this.length();
1709
1710             return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
1711
1712         },
1713
1714         floor: function () {
1715
1716             this.x = Math.floor( this.x );
1717             this.y = Math.floor( this.y );
1718             this.z = Math.floor( this.z );
1719             this.w = Math.floor( this.w );
1720
1721             return this;
1722
1723         },
1724
1725         ceil: function () {
1726
1727             this.x = Math.ceil( this.x );
1728             this.y = Math.ceil( this.y );
1729             this.z = Math.ceil( this.z );
1730             this.w = Math.ceil( this.w );
1731
1732             return this;
1733
1734         },
1735
1736         round: function () {
1737
1738             this.x = Math.round( this.x );
1739             this.y = Math.round( this.y );
1740             this.z = Math.round( this.z );
1741             this.w = Math.round( this.w );
1742
1743             return this;
1744
1745         },
1746
1747         roundToZero: function () {
1748
1749             this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
1750             this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
1751             this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );
1752             this.w = ( this.w < 0 ) ? Math.ceil( this.w ) : Math.floor( this.w );
1753
1754             return this;
1755
1756         },
1757
1758         negate: function () {
1759
1760             this.x = - this.x;
1761             this.y = - this.y;
1762             this.z = - this.z;
1763             this.w = - this.w;
1764
1765             return this;
1766
1767         },
1768
1769         dot: function ( v ) {
1770
1771             return this.x * v.x + this.y * v.y + this.z * v.z + this.w * v.w;
1772
1773         },
1774
1775         lengthSq: function () {
1776
1777             return this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w;
1778
1779         },
1780
1781         length: function () {
1782
1783             return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z + this.w * this.w );
1784
1785         },
1786
1787         lengthManhattan: function () {
1788
1789             return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w );
1790
1791         },
1792
1793         normalize: function () {
1794
1795             return this.divideScalar( this.length() || 1 );
1796
1797         },
1798
1799         setLength: function ( length ) {
1800
1801             return this.normalize().multiplyScalar( length );
1802
1803         },
1804
1805         lerp: function ( v, alpha ) {
1806
1807             this.x += ( v.x - this.x ) * alpha;
1808             this.y += ( v.y - this.y ) * alpha;
1809             this.z += ( v.z - this.z ) * alpha;
1810             this.w += ( v.w - this.w ) * alpha;
1811
1812             return this;
1813
1814         },
1815
1816         lerpVectors: function ( v1, v2, alpha ) {
1817
1818             return this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
1819
1820         },
1821
1822         equals: function ( v ) {
1823
1824             return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) );
1825
1826         },
1827
1828         fromArray: function ( array, offset ) {
1829
1830             if ( offset === undefined ) offset = 0;
1831
1832             this.x = array[ offset ];
1833             this.y = array[ offset + 1 ];
1834             this.z = array[ offset + 2 ];
1835             this.w = array[ offset + 3 ];
1836
1837             return this;
1838
1839         },
1840
1841         toArray: function ( array, offset ) {
1842
1843             if ( array === undefined ) array = [];
1844             if ( offset === undefined ) offset = 0;
1845
1846             array[ offset ] = this.x;
1847             array[ offset + 1 ] = this.y;
1848             array[ offset + 2 ] = this.z;
1849             array[ offset + 3 ] = this.w;
1850
1851             return array;
1852
1853         },
1854
1855         fromBufferAttribute: function ( attribute, index, offset ) {
1856
1857             if ( offset !== undefined ) {
1858
1859                 console.warn( 'THREE.Vector4: offset has been removed from .fromBufferAttribute().' );
1860
1861             }
1862
1863             this.x = attribute.getX( index );
1864             this.y = attribute.getY( index );
1865             this.z = attribute.getZ( index );
1866             this.w = attribute.getW( index );
1867
1868             return this;
1869
1870         }
1871
1872     } );
1873
1874     /**
1875      * @author szimek / https://github.com/szimek/
1876      * @author alteredq / http://alteredqualia.com/
1877      * @author Marius Kintel / https://github.com/kintel
1878      */
1879
1880     /*
1881      In options, we can specify:
1882      * Texture parameters for an auto-generated target texture
1883      * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers
1884     */
1885     function WebGLRenderTarget( width, height, options ) {
1886
1887         this.uuid = _Math.generateUUID();
1888
1889         this.width = width;
1890         this.height = height;
1891
1892         this.scissor = new Vector4( 0, 0, width, height );
1893         this.scissorTest = false;
1894
1895         this.viewport = new Vector4( 0, 0, width, height );
1896
1897         options = options || {};
1898
1899         if ( options.minFilter === undefined ) options.minFilter = LinearFilter;
1900
1901         this.texture = new Texture( undefined, undefined, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.encoding );
1902
1903         this.depthBuffer = options.depthBuffer !== undefined ? options.depthBuffer : true;
1904         this.stencilBuffer = options.stencilBuffer !== undefined ? options.stencilBuffer : true;
1905         this.depthTexture = options.depthTexture !== undefined ? options.depthTexture : null;
1906
1907     }
1908
1909     Object.assign( WebGLRenderTarget.prototype, EventDispatcher.prototype, {
1910
1911         isWebGLRenderTarget: true,
1912
1913         setSize: function ( width, height ) {
1914
1915             if ( this.width !== width || this.height !== height ) {
1916
1917                 this.width = width;
1918                 this.height = height;
1919
1920                 this.dispose();
1921
1922             }
1923
1924             this.viewport.set( 0, 0, width, height );
1925             this.scissor.set( 0, 0, width, height );
1926
1927         },
1928
1929         clone: function () {
1930
1931             return new this.constructor().copy( this );
1932
1933         },
1934
1935         copy: function ( source ) {
1936
1937             this.width = source.width;
1938             this.height = source.height;
1939
1940             this.viewport.copy( source.viewport );
1941
1942             this.texture = source.texture.clone();
1943
1944             this.depthBuffer = source.depthBuffer;
1945             this.stencilBuffer = source.stencilBuffer;
1946             this.depthTexture = source.depthTexture;
1947
1948             return this;
1949
1950         },
1951
1952         dispose: function () {
1953
1954             this.dispatchEvent( { type: 'dispose' } );
1955
1956         }
1957
1958     } );
1959
1960     /**
1961      * @author alteredq / http://alteredqualia.com
1962      */
1963
1964     function WebGLRenderTargetCube( width, height, options ) {
1965
1966         WebGLRenderTarget.call( this, width, height, options );
1967
1968         this.activeCubeFace = 0; // PX 0, NX 1, PY 2, NY 3, PZ 4, NZ 5
1969         this.activeMipMapLevel = 0;
1970
1971     }
1972
1973     WebGLRenderTargetCube.prototype = Object.create( WebGLRenderTarget.prototype );
1974     WebGLRenderTargetCube.prototype.constructor = WebGLRenderTargetCube;
1975
1976     WebGLRenderTargetCube.prototype.isWebGLRenderTargetCube = true;
1977
1978     /**
1979      * @author mikael emtinger / http://gomo.se/
1980      * @author alteredq / http://alteredqualia.com/
1981      * @author WestLangley / http://github.com/WestLangley
1982      * @author bhouston / http://clara.io
1983      */
1984
1985     function Quaternion( x, y, z, w ) {
1986
1987         this._x = x || 0;
1988         this._y = y || 0;
1989         this._z = z || 0;
1990         this._w = ( w !== undefined ) ? w : 1;
1991
1992     }
1993
1994     Object.assign( Quaternion, {
1995
1996         slerp: function ( qa, qb, qm, t ) {
1997
1998             return qm.copy( qa ).slerp( qb, t );
1999
2000         },
2001
2002         slerpFlat: function ( dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) {
2003
2004             // fuzz-free, array-based Quaternion SLERP operation
2005
2006             var x0 = src0[ srcOffset0 + 0 ],
2007                 y0 = src0[ srcOffset0 + 1 ],
2008                 z0 = src0[ srcOffset0 + 2 ],
2009                 w0 = src0[ srcOffset0 + 3 ],
2010
2011                 x1 = src1[ srcOffset1 + 0 ],
2012                 y1 = src1[ srcOffset1 + 1 ],
2013                 z1 = src1[ srcOffset1 + 2 ],
2014                 w1 = src1[ srcOffset1 + 3 ];
2015
2016             if ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) {
2017
2018                 var s = 1 - t,
2019
2020                     cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
2021
2022                     dir = ( cos >= 0 ? 1 : - 1 ),
2023                     sqrSin = 1 - cos * cos;
2024
2025                 // Skip the Slerp for tiny steps to avoid numeric problems:
2026                 if ( sqrSin > Number.EPSILON ) {
2027
2028                     var sin = Math.sqrt( sqrSin ),
2029                         len = Math.atan2( sin, cos * dir );
2030
2031                     s = Math.sin( s * len ) / sin;
2032                     t = Math.sin( t * len ) / sin;
2033
2034                 }
2035
2036                 var tDir = t * dir;
2037
2038                 x0 = x0 * s + x1 * tDir;
2039                 y0 = y0 * s + y1 * tDir;
2040                 z0 = z0 * s + z1 * tDir;
2041                 w0 = w0 * s + w1 * tDir;
2042
2043                 // Normalize in case we just did a lerp:
2044                 if ( s === 1 - t ) {
2045
2046                     var f = 1 / Math.sqrt( x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0 );
2047
2048                     x0 *= f;
2049                     y0 *= f;
2050                     z0 *= f;
2051                     w0 *= f;
2052
2053                 }
2054
2055             }
2056
2057             dst[ dstOffset ] = x0;
2058             dst[ dstOffset + 1 ] = y0;
2059             dst[ dstOffset + 2 ] = z0;
2060             dst[ dstOffset + 3 ] = w0;
2061
2062         }
2063
2064     } );
2065
2066     Object.defineProperties( Quaternion.prototype, {
2067
2068         x: {
2069
2070             get: function () {
2071
2072                 return this._x;
2073
2074             },
2075
2076             set: function ( value ) {
2077
2078                 this._x = value;
2079                 this.onChangeCallback();
2080
2081             }
2082
2083         },
2084
2085         y: {
2086
2087             get: function () {
2088
2089                 return this._y;
2090
2091             },
2092
2093             set: function ( value ) {
2094
2095                 this._y = value;
2096                 this.onChangeCallback();
2097
2098             }
2099
2100         },
2101
2102         z: {
2103
2104             get: function () {
2105
2106                 return this._z;
2107
2108             },
2109
2110             set: function ( value ) {
2111
2112                 this._z = value;
2113                 this.onChangeCallback();
2114
2115             }
2116
2117         },
2118
2119         w: {
2120
2121             get: function () {
2122
2123                 return this._w;
2124
2125             },
2126
2127             set: function ( value ) {
2128
2129                 this._w = value;
2130                 this.onChangeCallback();
2131
2132             }
2133
2134         }
2135
2136     } );
2137
2138     Object.assign( Quaternion.prototype, {
2139
2140         set: function ( x, y, z, w ) {
2141
2142             this._x = x;
2143             this._y = y;
2144             this._z = z;
2145             this._w = w;
2146
2147             this.onChangeCallback();
2148
2149             return this;
2150
2151         },
2152
2153         clone: function () {
2154
2155             return new this.constructor( this._x, this._y, this._z, this._w );
2156
2157         },
2158
2159         copy: function ( quaternion ) {
2160
2161             this._x = quaternion.x;
2162             this._y = quaternion.y;
2163             this._z = quaternion.z;
2164             this._w = quaternion.w;
2165
2166             this.onChangeCallback();
2167
2168             return this;
2169
2170         },
2171
2172         setFromEuler: function ( euler, update ) {
2173
2174             if ( ! ( euler && euler.isEuler ) ) {
2175
2176                 throw new Error( 'THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.' );
2177
2178             }
2179
2180             var x = euler._x, y = euler._y, z = euler._z, order = euler.order;
2181
2182             // http://www.mathworks.com/matlabcentral/fileexchange/
2183             //  20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
2184             //  content/SpinCalc.m
2185
2186             var cos = Math.cos;
2187             var sin = Math.sin;
2188
2189             var c1 = cos( x / 2 );
2190             var c2 = cos( y / 2 );
2191             var c3 = cos( z / 2 );
2192
2193             var s1 = sin( x / 2 );
2194             var s2 = sin( y / 2 );
2195             var s3 = sin( z / 2 );
2196
2197             if ( order === 'XYZ' ) {
2198
2199                 this._x = s1 * c2 * c3 + c1 * s2 * s3;
2200                 this._y = c1 * s2 * c3 - s1 * c2 * s3;
2201                 this._z = c1 * c2 * s3 + s1 * s2 * c3;
2202                 this._w = c1 * c2 * c3 - s1 * s2 * s3;
2203
2204             } else if ( order === 'YXZ' ) {
2205
2206                 this._x = s1 * c2 * c3 + c1 * s2 * s3;
2207                 this._y = c1 * s2 * c3 - s1 * c2 * s3;
2208                 this._z = c1 * c2 * s3 - s1 * s2 * c3;
2209                 this._w = c1 * c2 * c3 + s1 * s2 * s3;
2210
2211             } else if ( order === 'ZXY' ) {
2212
2213                 this._x = s1 * c2 * c3 - c1 * s2 * s3;
2214                 this._y = c1 * s2 * c3 + s1 * c2 * s3;
2215                 this._z = c1 * c2 * s3 + s1 * s2 * c3;
2216                 this._w = c1 * c2 * c3 - s1 * s2 * s3;
2217
2218             } else if ( order === 'ZYX' ) {
2219
2220                 this._x = s1 * c2 * c3 - c1 * s2 * s3;
2221                 this._y = c1 * s2 * c3 + s1 * c2 * s3;
2222                 this._z = c1 * c2 * s3 - s1 * s2 * c3;
2223                 this._w = c1 * c2 * c3 + s1 * s2 * s3;
2224
2225             } else if ( order === 'YZX' ) {
2226
2227                 this._x = s1 * c2 * c3 + c1 * s2 * s3;
2228                 this._y = c1 * s2 * c3 + s1 * c2 * s3;
2229                 this._z = c1 * c2 * s3 - s1 * s2 * c3;
2230                 this._w = c1 * c2 * c3 - s1 * s2 * s3;
2231
2232             } else if ( order === 'XZY' ) {
2233
2234                 this._x = s1 * c2 * c3 - c1 * s2 * s3;
2235                 this._y = c1 * s2 * c3 - s1 * c2 * s3;
2236                 this._z = c1 * c2 * s3 + s1 * s2 * c3;
2237                 this._w = c1 * c2 * c3 + s1 * s2 * s3;
2238
2239             }
2240
2241             if ( update !== false ) this.onChangeCallback();
2242
2243             return this;
2244
2245         },
2246
2247         setFromAxisAngle: function ( axis, angle ) {
2248
2249             // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
2250
2251             // assumes axis is normalized
2252
2253             var halfAngle = angle / 2, s = Math.sin( halfAngle );
2254
2255             this._x = axis.x * s;
2256             this._y = axis.y * s;
2257             this._z = axis.z * s;
2258             this._w = Math.cos( halfAngle );
2259
2260             this.onChangeCallback();
2261
2262             return this;
2263
2264         },
2265
2266         setFromRotationMatrix: function ( m ) {
2267
2268             // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
2269
2270             // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
2271
2272             var te = m.elements,
2273
2274                 m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
2275                 m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
2276                 m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ],
2277
2278                 trace = m11 + m22 + m33,
2279                 s;
2280
2281             if ( trace > 0 ) {
2282
2283                 s = 0.5 / Math.sqrt( trace + 1.0 );
2284
2285                 this._w = 0.25 / s;
2286                 this._x = ( m32 - m23 ) * s;
2287                 this._y = ( m13 - m31 ) * s;
2288                 this._z = ( m21 - m12 ) * s;
2289
2290             } else if ( m11 > m22 && m11 > m33 ) {
2291
2292                 s = 2.0 * Math.sqrt( 1.0 + m11 - m22 - m33 );
2293
2294                 this._w = ( m32 - m23 ) / s;
2295                 this._x = 0.25 * s;
2296                 this._y = ( m12 + m21 ) / s;
2297                 this._z = ( m13 + m31 ) / s;
2298
2299             } else if ( m22 > m33 ) {
2300
2301                 s = 2.0 * Math.sqrt( 1.0 + m22 - m11 - m33 );
2302
2303                 this._w = ( m13 - m31 ) / s;
2304                 this._x = ( m12 + m21 ) / s;
2305                 this._y = 0.25 * s;
2306                 this._z = ( m23 + m32 ) / s;
2307
2308             } else {
2309
2310                 s = 2.0 * Math.sqrt( 1.0 + m33 - m11 - m22 );
2311
2312                 this._w = ( m21 - m12 ) / s;
2313                 this._x = ( m13 + m31 ) / s;
2314                 this._y = ( m23 + m32 ) / s;
2315                 this._z = 0.25 * s;
2316
2317             }
2318
2319             this.onChangeCallback();
2320
2321             return this;
2322
2323         },
2324
2325         setFromUnitVectors: function () {
2326
2327             // assumes direction vectors vFrom and vTo are normalized
2328
2329             var v1 = new Vector3();
2330             var r;
2331
2332             var EPS = 0.000001;
2333
2334             return function setFromUnitVectors( vFrom, vTo ) {
2335
2336                 if ( v1 === undefined ) v1 = new Vector3();
2337
2338                 r = vFrom.dot( vTo ) + 1;
2339
2340                 if ( r < EPS ) {
2341
2342                     r = 0;
2343
2344                     if ( Math.abs( vFrom.x ) > Math.abs( vFrom.z ) ) {
2345
2346                         v1.set( - vFrom.y, vFrom.x, 0 );
2347
2348                     } else {
2349
2350                         v1.set( 0, - vFrom.z, vFrom.y );
2351
2352                     }
2353
2354                 } else {
2355
2356                     v1.crossVectors( vFrom, vTo );
2357
2358                 }
2359
2360                 this._x = v1.x;
2361                 this._y = v1.y;
2362                 this._z = v1.z;
2363                 this._w = r;
2364
2365                 return this.normalize();
2366
2367             };
2368
2369         }(),
2370
2371         inverse: function () {
2372
2373             return this.conjugate().normalize();
2374
2375         },
2376
2377         conjugate: function () {
2378
2379             this._x *= - 1;
2380             this._y *= - 1;
2381             this._z *= - 1;
2382
2383             this.onChangeCallback();
2384
2385             return this;
2386
2387         },
2388
2389         dot: function ( v ) {
2390
2391             return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
2392
2393         },
2394
2395         lengthSq: function () {
2396
2397             return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
2398
2399         },
2400
2401         length: function () {
2402
2403             return Math.sqrt( this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w );
2404
2405         },
2406
2407         normalize: function () {
2408
2409             var l = this.length();
2410
2411             if ( l === 0 ) {
2412
2413                 this._x = 0;
2414                 this._y = 0;
2415                 this._z = 0;
2416                 this._w = 1;
2417
2418             } else {
2419
2420                 l = 1 / l;
2421
2422                 this._x = this._x * l;
2423                 this._y = this._y * l;
2424                 this._z = this._z * l;
2425                 this._w = this._w * l;
2426
2427             }
2428
2429             this.onChangeCallback();
2430
2431             return this;
2432
2433         },
2434
2435         multiply: function ( q, p ) {
2436
2437             if ( p !== undefined ) {
2438
2439                 console.warn( 'THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead.' );
2440                 return this.multiplyQuaternions( q, p );
2441
2442             }
2443
2444             return this.multiplyQuaternions( this, q );
2445
2446         },
2447
2448         premultiply: function ( q ) {
2449
2450             return this.multiplyQuaternions( q, this );
2451
2452         },
2453
2454         multiplyQuaternions: function ( a, b ) {
2455
2456             // from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
2457
2458             var qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;
2459             var qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;
2460
2461             this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
2462             this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
2463             this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
2464             this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
2465
2466             this.onChangeCallback();
2467
2468             return this;
2469
2470         },
2471
2472         slerp: function ( qb, t ) {
2473
2474             if ( t === 0 ) return this;
2475             if ( t === 1 ) return this.copy( qb );
2476
2477             var x = this._x, y = this._y, z = this._z, w = this._w;
2478
2479             // http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
2480
2481             var cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
2482
2483             if ( cosHalfTheta < 0 ) {
2484
2485                 this._w = - qb._w;
2486                 this._x = - qb._x;
2487                 this._y = - qb._y;
2488                 this._z = - qb._z;
2489
2490                 cosHalfTheta = - cosHalfTheta;
2491
2492             } else {
2493
2494                 this.copy( qb );
2495
2496             }
2497
2498             if ( cosHalfTheta >= 1.0 ) {
2499
2500                 this._w = w;
2501                 this._x = x;
2502                 this._y = y;
2503                 this._z = z;
2504
2505                 return this;
2506
2507             }
2508
2509             var sinHalfTheta = Math.sqrt( 1.0 - cosHalfTheta * cosHalfTheta );
2510
2511             if ( Math.abs( sinHalfTheta ) < 0.001 ) {
2512
2513                 this._w = 0.5 * ( w + this._w );
2514                 this._x = 0.5 * ( x + this._x );
2515                 this._y = 0.5 * ( y + this._y );
2516                 this._z = 0.5 * ( z + this._z );
2517
2518                 return this;
2519
2520             }
2521
2522             var halfTheta = Math.atan2( sinHalfTheta, cosHalfTheta );
2523             var ratioA = Math.sin( ( 1 - t ) * halfTheta ) / sinHalfTheta,
2524                 ratioB = Math.sin( t * halfTheta ) / sinHalfTheta;
2525
2526             this._w = ( w * ratioA + this._w * ratioB );
2527             this._x = ( x * ratioA + this._x * ratioB );
2528             this._y = ( y * ratioA + this._y * ratioB );
2529             this._z = ( z * ratioA + this._z * ratioB );
2530
2531             this.onChangeCallback();
2532
2533             return this;
2534
2535         },
2536
2537         equals: function ( quaternion ) {
2538
2539             return ( quaternion._x === this._x ) && ( quaternion._y === this._y ) && ( quaternion._z === this._z ) && ( quaternion._w === this._w );
2540
2541         },
2542
2543         fromArray: function ( array, offset ) {
2544
2545             if ( offset === undefined ) offset = 0;
2546
2547             this._x = array[ offset ];
2548             this._y = array[ offset + 1 ];
2549             this._z = array[ offset + 2 ];
2550             this._w = array[ offset + 3 ];
2551
2552             this.onChangeCallback();
2553
2554             return this;
2555
2556         },
2557
2558         toArray: function ( array, offset ) {
2559
2560             if ( array === undefined ) array = [];
2561             if ( offset === undefined ) offset = 0;
2562
2563             array[ offset ] = this._x;
2564             array[ offset + 1 ] = this._y;
2565             array[ offset + 2 ] = this._z;
2566             array[ offset + 3 ] = this._w;
2567
2568             return array;
2569
2570         },
2571
2572         onChange: function ( callback ) {
2573
2574             this.onChangeCallback = callback;
2575
2576             return this;
2577
2578         },
2579
2580         onChangeCallback: function () {}
2581
2582     } );
2583
2584     /**
2585      * @author mrdoob / http://mrdoob.com/
2586      * @author kile / http://kile.stravaganza.org/
2587      * @author philogb / http://blog.thejit.org/
2588      * @author mikael emtinger / http://gomo.se/
2589      * @author egraether / http://egraether.com/
2590      * @author WestLangley / http://github.com/WestLangley
2591      */
2592
2593     function Vector3( x, y, z ) {
2594
2595         this.x = x || 0;
2596         this.y = y || 0;
2597         this.z = z || 0;
2598
2599     }
2600
2601     Object.assign( Vector3.prototype, {
2602
2603         isVector3: true,
2604
2605         set: function ( x, y, z ) {
2606
2607             this.x = x;
2608             this.y = y;
2609             this.z = z;
2610
2611             return this;
2612
2613         },
2614
2615         setScalar: function ( scalar ) {
2616
2617             this.x = scalar;
2618             this.y = scalar;
2619             this.z = scalar;
2620
2621             return this;
2622
2623         },
2624
2625         setX: function ( x ) {
2626
2627             this.x = x;
2628
2629             return this;
2630
2631         },
2632
2633         setY: function ( y ) {
2634
2635             this.y = y;
2636
2637             return this;
2638
2639         },
2640
2641         setZ: function ( z ) {
2642
2643             this.z = z;
2644
2645             return this;
2646
2647         },
2648
2649         setComponent: function ( index, value ) {
2650
2651             switch ( index ) {
2652
2653                 case 0: this.x = value; break;
2654                 case 1: this.y = value; break;
2655                 case 2: this.z = value; break;
2656                 default: throw new Error( 'index is out of range: ' + index );
2657
2658             }
2659
2660             return this;
2661
2662         },
2663
2664         getComponent: function ( index ) {
2665
2666             switch ( index ) {
2667
2668                 case 0: return this.x;
2669                 case 1: return this.y;
2670                 case 2: return this.z;
2671                 default: throw new Error( 'index is out of range: ' + index );
2672
2673             }
2674
2675         },
2676
2677         clone: function () {
2678
2679             return new this.constructor( this.x, this.y, this.z );
2680
2681         },
2682
2683         copy: function ( v ) {
2684
2685             this.x = v.x;
2686             this.y = v.y;
2687             this.z = v.z;
2688
2689             return this;
2690
2691         },
2692
2693         add: function ( v, w ) {
2694
2695             if ( w !== undefined ) {
2696
2697                 console.warn( 'THREE.Vector3: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
2698                 return this.addVectors( v, w );
2699
2700             }
2701
2702             this.x += v.x;
2703             this.y += v.y;
2704             this.z += v.z;
2705
2706             return this;
2707
2708         },
2709
2710         addScalar: function ( s ) {
2711
2712             this.x += s;
2713             this.y += s;
2714             this.z += s;
2715
2716             return this;
2717
2718         },
2719
2720         addVectors: function ( a, b ) {
2721
2722             this.x = a.x + b.x;
2723             this.y = a.y + b.y;
2724             this.z = a.z + b.z;
2725
2726             return this;
2727
2728         },
2729
2730         addScaledVector: function ( v, s ) {
2731
2732             this.x += v.x * s;
2733             this.y += v.y * s;
2734             this.z += v.z * s;
2735
2736             return this;
2737
2738         },
2739
2740         sub: function ( v, w ) {
2741
2742             if ( w !== undefined ) {
2743
2744                 console.warn( 'THREE.Vector3: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
2745                 return this.subVectors( v, w );
2746
2747             }
2748
2749             this.x -= v.x;
2750             this.y -= v.y;
2751             this.z -= v.z;
2752
2753             return this;
2754
2755         },
2756
2757         subScalar: function ( s ) {
2758
2759             this.x -= s;
2760             this.y -= s;
2761             this.z -= s;
2762
2763             return this;
2764
2765         },
2766
2767         subVectors: function ( a, b ) {
2768
2769             this.x = a.x - b.x;
2770             this.y = a.y - b.y;
2771             this.z = a.z - b.z;
2772
2773             return this;
2774
2775         },
2776
2777         multiply: function ( v, w ) {
2778
2779             if ( w !== undefined ) {
2780
2781                 console.warn( 'THREE.Vector3: .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.' );
2782                 return this.multiplyVectors( v, w );
2783
2784             }
2785
2786             this.x *= v.x;
2787             this.y *= v.y;
2788             this.z *= v.z;
2789
2790             return this;
2791
2792         },
2793
2794         multiplyScalar: function ( scalar ) {
2795
2796             this.x *= scalar;
2797             this.y *= scalar;
2798             this.z *= scalar;
2799
2800             return this;
2801
2802         },
2803
2804         multiplyVectors: function ( a, b ) {
2805
2806             this.x = a.x * b.x;
2807             this.y = a.y * b.y;
2808             this.z = a.z * b.z;
2809
2810             return this;
2811
2812         },
2813
2814         applyEuler: function () {
2815
2816             var quaternion = new Quaternion();
2817
2818             return function applyEuler( euler ) {
2819
2820                 if ( ! ( euler && euler.isEuler ) ) {
2821
2822                     console.error( 'THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.' );
2823
2824                 }
2825
2826                 return this.applyQuaternion( quaternion.setFromEuler( euler ) );
2827
2828             };
2829
2830         }(),
2831
2832         applyAxisAngle: function () {
2833
2834             var quaternion = new Quaternion();
2835
2836             return function applyAxisAngle( axis, angle ) {
2837
2838                 return this.applyQuaternion( quaternion.setFromAxisAngle( axis, angle ) );
2839
2840             };
2841
2842         }(),
2843
2844         applyMatrix3: function ( m ) {
2845
2846             var x = this.x, y = this.y, z = this.z;
2847             var e = m.elements;
2848
2849             this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ] * z;
2850             this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ] * z;
2851             this.z = e[ 2 ] * x + e[ 5 ] * y + e[ 8 ] * z;
2852
2853             return this;
2854
2855         },
2856
2857         applyMatrix4: function ( m ) {
2858
2859             var x = this.x, y = this.y, z = this.z;
2860             var e = m.elements;
2861
2862             var w = 1 / ( e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] );
2863
2864             this.x = ( e[ 0 ] * x + e[ 4 ] * y + e[ 8 ]  * z + e[ 12 ] ) * w;
2865             this.y = ( e[ 1 ] * x + e[ 5 ] * y + e[ 9 ]  * z + e[ 13 ] ) * w;
2866             this.z = ( e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] ) * w;
2867
2868             return this;
2869
2870         },
2871
2872         applyQuaternion: function ( q ) {
2873
2874             var x = this.x, y = this.y, z = this.z;
2875             var qx = q.x, qy = q.y, qz = q.z, qw = q.w;
2876
2877             // calculate quat * vector
2878
2879             var ix =  qw * x + qy * z - qz * y;
2880             var iy =  qw * y + qz * x - qx * z;
2881             var iz =  qw * z + qx * y - qy * x;
2882             var iw = - qx * x - qy * y - qz * z;
2883
2884             // calculate result * inverse quat
2885
2886             this.x = ix * qw + iw * - qx + iy * - qz - iz * - qy;
2887             this.y = iy * qw + iw * - qy + iz * - qx - ix * - qz;
2888             this.z = iz * qw + iw * - qz + ix * - qy - iy * - qx;
2889
2890             return this;
2891
2892         },
2893
2894         project: function () {
2895
2896             var matrix = new Matrix4();
2897
2898             return function project( camera ) {
2899
2900                 matrix.multiplyMatrices( camera.projectionMatrix, matrix.getInverse( camera.matrixWorld ) );
2901                 return this.applyMatrix4( matrix );
2902
2903             };
2904
2905         }(),
2906
2907         unproject: function () {
2908
2909             var matrix = new Matrix4();
2910
2911             return function unproject( camera ) {
2912
2913                 matrix.multiplyMatrices( camera.matrixWorld, matrix.getInverse( camera.projectionMatrix ) );
2914                 return this.applyMatrix4( matrix );
2915
2916             };
2917
2918         }(),
2919
2920         transformDirection: function ( m ) {
2921
2922             // input: THREE.Matrix4 affine matrix
2923             // vector interpreted as a direction
2924
2925             var x = this.x, y = this.y, z = this.z;
2926             var e = m.elements;
2927
2928             this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ]  * z;
2929             this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ]  * z;
2930             this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z;
2931
2932             return this.normalize();
2933
2934         },
2935
2936         divide: function ( v ) {
2937
2938             this.x /= v.x;
2939             this.y /= v.y;
2940             this.z /= v.z;
2941
2942             return this;
2943
2944         },
2945
2946         divideScalar: function ( scalar ) {
2947
2948             return this.multiplyScalar( 1 / scalar );
2949
2950         },
2951
2952         min: function ( v ) {
2953
2954             this.x = Math.min( this.x, v.x );
2955             this.y = Math.min( this.y, v.y );
2956             this.z = Math.min( this.z, v.z );
2957
2958             return this;
2959
2960         },
2961
2962         max: function ( v ) {
2963
2964             this.x = Math.max( this.x, v.x );
2965             this.y = Math.max( this.y, v.y );
2966             this.z = Math.max( this.z, v.z );
2967
2968             return this;
2969
2970         },
2971
2972         clamp: function ( min, max ) {
2973
2974             // assumes min < max, componentwise
2975
2976             this.x = Math.max( min.x, Math.min( max.x, this.x ) );
2977             this.y = Math.max( min.y, Math.min( max.y, this.y ) );
2978             this.z = Math.max( min.z, Math.min( max.z, this.z ) );
2979
2980             return this;
2981
2982         },
2983
2984         clampScalar: function () {
2985
2986             var min = new Vector3();
2987             var max = new Vector3();
2988
2989             return function clampScalar( minVal, maxVal ) {
2990
2991                 min.set( minVal, minVal, minVal );
2992                 max.set( maxVal, maxVal, maxVal );
2993
2994                 return this.clamp( min, max );
2995
2996             };
2997
2998         }(),
2999
3000         clampLength: function ( min, max ) {
3001
3002             var length = this.length();
3003
3004             return this.divideScalar( length || 1 ).multiplyScalar( Math.max( min, Math.min( max, length ) ) );
3005
3006         },
3007
3008         floor: function () {
3009
3010             this.x = Math.floor( this.x );
3011             this.y = Math.floor( this.y );
3012             this.z = Math.floor( this.z );
3013
3014             return this;
3015
3016         },
3017
3018         ceil: function () {
3019
3020             this.x = Math.ceil( this.x );
3021             this.y = Math.ceil( this.y );
3022             this.z = Math.ceil( this.z );
3023
3024             return this;
3025
3026         },
3027
3028         round: function () {
3029
3030             this.x = Math.round( this.x );
3031             this.y = Math.round( this.y );
3032             this.z = Math.round( this.z );
3033
3034             return this;
3035
3036         },
3037
3038         roundToZero: function () {
3039
3040             this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
3041             this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
3042             this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );
3043
3044             return this;
3045
3046         },
3047
3048         negate: function () {
3049
3050             this.x = - this.x;
3051             this.y = - this.y;
3052             this.z = - this.z;
3053
3054             return this;
3055
3056         },
3057
3058         dot: function ( v ) {
3059
3060             return this.x * v.x + this.y * v.y + this.z * v.z;
3061
3062         },
3063
3064         // TODO lengthSquared?
3065
3066         lengthSq: function () {
3067
3068             return this.x * this.x + this.y * this.y + this.z * this.z;
3069
3070         },
3071
3072         length: function () {
3073
3074             return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );
3075
3076         },
3077
3078         lengthManhattan: function () {
3079
3080             return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z );
3081
3082         },
3083
3084         normalize: function () {
3085
3086             return this.divideScalar( this.length() || 1 );
3087
3088         },
3089
3090         setLength: function ( length ) {
3091
3092             return this.normalize().multiplyScalar( length );
3093
3094         },
3095
3096         lerp: function ( v, alpha ) {
3097
3098             this.x += ( v.x - this.x ) * alpha;
3099             this.y += ( v.y - this.y ) * alpha;
3100             this.z += ( v.z - this.z ) * alpha;
3101
3102             return this;
3103
3104         },
3105
3106         lerpVectors: function ( v1, v2, alpha ) {
3107
3108             return this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
3109
3110         },
3111
3112         cross: function ( v, w ) {
3113
3114             if ( w !== undefined ) {
3115
3116                 console.warn( 'THREE.Vector3: .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.' );
3117                 return this.crossVectors( v, w );
3118
3119             }
3120
3121             var x = this.x, y = this.y, z = this.z;
3122
3123             this.x = y * v.z - z * v.y;
3124             this.y = z * v.x - x * v.z;
3125             this.z = x * v.y - y * v.x;
3126
3127             return this;
3128
3129         },
3130
3131         crossVectors: function ( a, b ) {
3132
3133             var ax = a.x, ay = a.y, az = a.z;
3134             var bx = b.x, by = b.y, bz = b.z;
3135
3136             this.x = ay * bz - az * by;
3137             this.y = az * bx - ax * bz;
3138             this.z = ax * by - ay * bx;
3139
3140             return this;
3141
3142         },
3143
3144         projectOnVector: function ( vector ) {
3145
3146             var scalar = vector.dot( this ) / vector.lengthSq();
3147
3148             return this.copy( vector ).multiplyScalar( scalar );
3149
3150         },
3151
3152         projectOnPlane: function () {
3153
3154             var v1 = new Vector3();
3155
3156             return function projectOnPlane( planeNormal ) {
3157
3158                 v1.copy( this ).projectOnVector( planeNormal );
3159
3160                 return this.sub( v1 );
3161
3162             };
3163
3164         }(),
3165
3166         reflect: function () {
3167
3168             // reflect incident vector off plane orthogonal to normal
3169             // normal is assumed to have unit length
3170
3171             var v1 = new Vector3();
3172
3173             return function reflect( normal ) {
3174
3175                 return this.sub( v1.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) );
3176
3177             };
3178
3179         }(),
3180
3181         angleTo: function ( v ) {
3182
3183             var theta = this.dot( v ) / ( Math.sqrt( this.lengthSq() * v.lengthSq() ) );
3184
3185             // clamp, to handle numerical problems
3186
3187             return Math.acos( _Math.clamp( theta, - 1, 1 ) );
3188
3189         },
3190
3191         distanceTo: function ( v ) {
3192
3193             return Math.sqrt( this.distanceToSquared( v ) );
3194
3195         },
3196
3197         distanceToSquared: function ( v ) {
3198
3199             var dx = this.x - v.x, dy = this.y - v.y, dz = this.z - v.z;
3200
3201             return dx * dx + dy * dy + dz * dz;
3202
3203         },
3204
3205         distanceToManhattan: function ( v ) {
3206
3207             return Math.abs( this.x - v.x ) + Math.abs( this.y - v.y ) + Math.abs( this.z - v.z );
3208
3209         },
3210
3211         setFromSpherical: function ( s ) {
3212
3213             var sinPhiRadius = Math.sin( s.phi ) * s.radius;
3214
3215             this.x = sinPhiRadius * Math.sin( s.theta );
3216             this.y = Math.cos( s.phi ) * s.radius;
3217             this.z = sinPhiRadius * Math.cos( s.theta );
3218
3219             return this;
3220
3221         },
3222
3223         setFromCylindrical: function ( c ) {
3224
3225             this.x = c.radius * Math.sin( c.theta );
3226             this.y = c.y;
3227             this.z = c.radius * Math.cos( c.theta );
3228
3229             return this;
3230
3231         },
3232