In this project, you will create a unique 3D animated scene composed of Three.js graphic components....

Question

In this project, you will create a unique 3D animated scene composed of Three.js graphic components. The scene should include animation, lighting, and multiple objects.

1 Project 3 Three js Project Overview In this project you will create a unique 3D animated scene composed of Three.js graphic components. The scene should include animation, lighting and multiple objects. Requirements: 1. Using Three.js create a unique 3D animated scene. The scene has the following specifications: a. Size: minimum of 640x480 b. Includes at least 6 different shapes c. Uses multiple lighting effects d. Includes radio buttons, slider bars or other widgets to turn on or off certain components of the animation. 2. Use Three.js 3. All JavaScript source code should be written using Google JavaScript style guide.( http://google.github.io/styleguide/jsguide.html) 4. Prepare, conduct and document a test plan verifying your application is working as expected. This plan should include a test matrix listing each method you tested, how you tested it, and the results of testing Deliverables: 1. All JavaScript source code used for this project. Code should adhere to the Google Javascript style guide. 2. Word or PDF file demonstrating with clearly labeled screen captures and associated well-written descriptions, the successful execution of your 3D Three.js animated scene. The document should be well-written, well-organized, includes the test plan, include page numbers, captions for all screen captures, and a title page including your name, class, section number and date. References should be included for all sources used and formatted in APA style. Grading guidelines: Attribute Meets Design 20 points Methods used to isolate functionality (10 points) Code is efficient without sacrificing readability and understanding. (5 points) Code can easily be used and maintained. (5 points) Functionality 50 points Uses Three.js create a unique 3D animated scene. (5 points) Scene is at least 640x480. (5 points) 2 Includes at least 6 different shapes. (10 points) Uses multiple lighting effects. (10 points) Includes radio buttons, slider bars or other widgets to turn on or off certain components of the animation. (10 points) Uses Three.js (10 points) Testing 10 points Prepares, conducts and documents a test plan verifying the application is functioning properly. (10 points) Documentation and deliverables 20 points Submits all JavaScript source code used for this project. (5 points) Code adheres to the Google JavaScript style guide. (5 points) Submits Word or PDF file demonstrating with clearly labeled screen captures and associated well-written descriptions, the successful execution of your 3D Three.js scene. (5 points) The document is well-written, well-organized, includes the test plan, includes page numbers, captions for all screen captures, and a title page including your name, class, section number and date. References are included for all sources used and formatted in APA style. (5 points) 1. Overview The project draws three simple images on a frame then applies translations, rotations, and scaling to the images. The different effects are done automatically with a timer that moves to the next frame. The effects are additive. There are two java classes in the project. Project1GUI.java is the main class the runs the logic and creates the GUI. The second class, Project1_Images.java creates the 2d representations of the images. In the second class, there are currently 3 images stored. The images are stored in 2d arrays. When the getImage() method is called, the parameter determines which image is returned. Based on the parameter provided a new BufferedImage is created using the 2d array. All of the images are have two colors. The first image is a horizontal line, the second is a vertical line, and the third is a checkerboard design. The method goes through the 2d array and assigns a color to the BufferedImage at the same index with the setRGB(x, y, pixelColor) method. The BufferedImage is used in the paintComponent() method of Project1GUI.java Project1GUI.java’s main method creates the GUI. The paintComplonent() method is overridden. The method determines the values for which transformations should be done by examining the frame index. The frame index cycles through 0 – 6 based on the timer. The first two cases, frames zero and one, set the images to the default positions, with no translations, no rotation and no scaling. The third case, frame two, translates the images to the left by 5 pixels. The next case translates the images up 7 pixels. The next case rotates the images 45 degrees counterclockwise. The next case rotates the images 90 clockwise. The next case scales the image in the x direction by 2.0 and the y direction by 0.5. The frame index then loops back to frame zero. 2. Execution There are 6 frames of animation for this program. The first two are identical. The third frame translates the images 5 pixels to the left. Figure 1. The first two frames of animation. Figure 2. The third frame of animation. The fourth frame translates the images 7 pixels up. The fifth frame rotates the image 45 degrees counterclockwise. Figure 3. The fourth frame of animation. Figure 4. The fifth frame of animation. The sixth frame rotates the image clockwise 90 degrees. For a total of a 45 degree clockwise rotation. The final frame of animation scales the images by 2.0 in the x direction and 0.5 in the y direction. Figure 5. The sixth frame of animation. 3. Testing The first step in testing was to take the template provided that had two duplicate images and change it to include a new image and increase the size of the images from 10 pixels to 25 pixels. The first step was to change the constants from 10 to 25. Then a new 2d array was created that used loops to hold the data and represent a horizontal line. A new method was created so that the original could still be used. The new method returned the new test image as a BufferedImage. The second call to drawImage() in the paintComponent() method was changed to use the new BufferedImage instead of a duplicate of the original image. Figure 6. The final frame of animation. The next thing to test was all three custom images. Figure 7. The new image next to the old image. Figure 8. The custom images added to the GUI. Test Case Input Expected Output Actual Output Result Translation Change translateX to -5 Objects move to the left slightly Images move to the left Pass Rotation counterclockwise Change rotation += 45*Math.PI / 180.0; Images rotate counterclockwise and point at the top left corner Images rotate counterclockwise Pass Rotation clockwise Add new case statement with rotation += (- 90*Math.PI / 180); Images rotate clockwise and point at top right corner. Images rotate clockwise Pass Scale x and y Add new case statement with scaleX += 1.0; and scaleY -= 0.5; Images get wider and shorter. Horizontal bar becomes longer, vertical bar becomes shorter Pass Figure 9. Test cases for the program.

project-3-r12glsec.pdf testplan-example-z5kt2q3n.pdf

Mohd · Accepted Answer

completed solution/code/index.html
  
  
  
    
      Stop Animation Cylinder
    
    
      Start Animation Cylinder
    
  
  
  
completed solution/code/js/three.js
(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
	typeof define === 'function' && define.amd ? define(['exports'], factory) :
	(global = global || self, factory(global.THREE = {}));
}(this, (function (exports) { 'use strict';
	// Polyfills
	if ( Number.EPSILON === undefined ) {
		Number.EPSILON = Math.pow( 2, - 52 );
	}
	if ( Number.isInteger === undefined ) {
		// Missing in IE
		// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger
		Number.isInteger = function ( value ) {
			return typeof value === 'number' && isFinite( value ) && Math.floor( value ) === value;
		};
	}
	//
	if ( Math.sign === undefined ) {
		// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sign
		Math.sign = function ( x ) {
			return ( x  0 ) ? 1 : + x;
		};
	}
	if ( 'name' in Function.prototype === false ) {
		// Missing in IE
		// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name
		Object.defineProperty( Function.prototype, 'name', {
			get: function () {
				return this.toString().match( /^\s*function\s*([^\(\s]*)/ )[ 1 ];
			}
		} );
	}
	if ( Object.assign === undefined ) {
		// Missing in IE
		// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
		Object.assign = function ( target ) {
			if ( target === undefined || target === null ) {
				throw new TypeError( 'Cannot convert undefined or null to object' );
			}
			var output = Object( target );
			for ( var index = 1; index > 8 & 0xff ] + _lut[ d0 >> 16 & 0xff ] + _lut[ d0 >> 24 & 0xff ] + '-' +
				_lut[ d1 & 0xff ] + _lut[ d1 >> 8 & 0xff ] + '-' + _lut[ d1 >> 16 & 0x0f | 0x40 ] + _lut[ d1 >> 24 & 0xff ] + '-' +
				_lut[ d2 & 0x3f | 0x80 ] + _lut[ d2 >> 8 & 0xff ] + '-' + _lut[ d2 >> 16 & 0xff ] + _lut[ d2 >> 24 & 0xff ] +
				_lut[ d3 & 0xff ] + _lut[ d3 >> 8 & 0xff ] + _lut[ d3 >> 16 & 0xff ] + _lut[ d3 >> 24 & 0xff ];
			// .toUpperCase() here flattens concatenated strings to save heap memory space.
			return uuid.toUpperCase();
		},
		clamp: function ( value, min, max ) {
			return Math.max( min, Math.min( max, value ) );
		},
		// compute euclidian modulo of m % n
		// https://en.wikipedia.org/wiki/Modulo_operation
		euclideanModulo: function ( n, m ) {
			return ( ( n % m ) + m ) % m;
		},
		// Linear mapping from range  to range 
		mapLinear: function ( x, a1, a2, b1, b2 ) {
			return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );
		},
		// https://en.wikipedia.org/wiki/Linear_interpolation
		lerp: function ( x, y, t ) {
			return ( 1 - t ) * x + t * y;
		},
		// http://en.wikipedia.org/wiki/Smoothstep
		smoothstep: function ( x, min, max ) {
			if ( x = max ) { return 1; }
			x = ( x - min ) / ( max - min );
			return x * x * ( 3 - 2 * x );
		},
		smootherstep: function ( x, min, max ) {
			if ( x = max ) { return 1; }
			x = ( x - min ) / ( max - min );
			return x * x * x * ( x * ( x * 6 - 15 ) + 10 );
		},
		// Random integer from  interval
		randInt: function ( low, high ) {
			return low + Math.floor( Math.random() * ( high - low + 1 ) );
		},
		// Random float from  interval
		randFloat: function ( low, high ) {
			return low + Math.random() * ( high - low );
		},
		// Random float from  interval
		randFloatSpread: function ( range ) {
			return range * ( 0.5 - Math.random() );
		},
		degToRad: function ( degrees ) {
			return degrees * MathUtils.DEG2RAD;
		},
		radToDeg: function ( radians ) {
			return radians * MathUtils.RAD2DEG;
		},
		isPowerOfTwo: function ( value ) {
			return ( value & ( value - 1 ) ) === 0 && value !== 0;
		},
		ceilPowerOfTwo: function ( value ) {
			return Math.pow( 2, Math.ceil( Math.log( value ) / Math.LN2 ) );
		},
		floorPowerOfTwo: function ( value ) {
			return Math.pow( 2, Math.floor( Math.log( value ) / Math.LN2 ) );
		},
		setQuaternionFromProperEuler: function ( q, a, b, c, order ) {
			// Intrinsic Proper Euler Angles - see https://en.wikipedia.org/wiki/Euler_angles
			// rotations are applied to the axes in the order specified by 'order'
			// rotation by angle 'a' is applied first, then by angle 'b', then by angle 'c'
			// angles are in radians
			var cos = Math.cos;
			var sin = Math.sin;
			var c2 = cos( b / 2 );
			var s2 = sin( b / 2 );
			var c13 = cos( ( a + c ) / 2 );
			var s13 = sin( ( a + c ) / 2 );
			var c1_3 = cos( ( a - c ) / 2 );
			var s1_3 = sin( ( a - c ) / 2 );
			var c3_1 = cos( ( c - a ) / 2 );
			var s3_1 = sin( ( c - a ) / 2 );
			switch ( order ) {
				case 'XYX':
					q.set( c2 * s13, s2 * c1_3, s2 * s1_3, c2 * c13 );
					break;
				case 'YZY':
					q.set( s2 * s1_3, c2 * s13, s2 * c1_3, c2 * c13 );
					break;
				case 'ZXZ':
					q.set( s2 * c1_3, s2 * s1_3, c2 * s13, c2 * c13 );
					break;
				case 'XZX':
					q.set( c2 * s13, s2 * s3_1, s2 * c3_1, c2 * c13 );
					break;
				case 'YXY':
					q.set( s2 * c3_1, c2 * s13, s2 * s3_1, c2 * c13 );
					break;
				case 'ZYZ':
					q.set( s2 * s3_1, s2 * c3_1, c2 * s13, c2 * c13 );
					break;
				default:
					console.warn( 'THREE.MathUtils: .setQuaternionFromProperEuler() encountered an unknown order: ' + order );
			}
		}
	};
	/**
	 * @author mrdoob / http://mrdoob.com/
	 * @author philogb / http://blog.thejit.org/
	 * @author egraether / http://egraether.com/
	 * @author zz85 / http://www.lab4games.net/zz85/blog
	 */
	function Vector2( x, y ) {
		this.x = x || 0;
		this.y = y || 0;
	}
	Object.defineProperties( Vector2.prototype, {
		"width": {
			get: function () {
				return this.x;
			},
			set: function ( value ) {
				this.x = value;
			}
		},
		"height": {
			get: function () {
				return this.y;
			},
			set: function ( value ) {
				this.y = value;
			}
		}
	} );
	Object.assign( Vector2.prototype, {
		isVector2: true,
		set: function ( x, y ) {
			this.x = x;
			this.y = y;
			return this;
		},
		setScalar: function ( scalar ) {
			this.x = scalar;
			this.y = scalar;
			return this;
		},
		setX: function ( x ) {
			this.x = x;
			return this;
		},
		setY: function ( y ) {
			this.y = y;
			return this;
		},
		setComponent: function ( index, value ) {
			switch ( index ) {
				case 0: this.x = value; break;
				case 1: this.y = value; break;
				default: throw new Error( 'index is out of range: ' + index );
			}
			return this;
		},
		getComponent: function ( index ) {
			switch ( index ) {
				case 0: return this.x;
				case 1: return this.y;
				default: throw new Error( 'index is out of range: ' + index );
			}
		},
		clone: function () {
			return new this.constructor( this.x, this.y );
		},
		copy: function ( v ) {
			this.x = v.x;
			this.y = v.y;
			return this;
		},
		add: function ( v, w ) {
			if ( w !== undefined ) {
				console.warn( 'THREE.Vector2: .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
				return this.addVectors( v, w );
			}
			this.x += v.x;
			this.y += v.y;
			return this;
		},
		addScalar: function ( s ) {
			this.x += s;
			this.y += s;
			return this;
		},
		addVectors: function ( a, b ) {
			this.x = a.x + b.x;
			this.y = a.y + b.y;
			return this;
		},
		addScaledVector: function ( v, s ) {
			this.x += v.x * s;
			this.y += v.y * s;
			return this;
		},
		sub: function ( v, w ) {
			if ( w !== undefined ) {
				console.warn( 'THREE.Vector2: .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
				return this.subVectors( v, w );
			}
			this.x -= v.x;
			this.y -= v.y;
			return this;
		},
		subScalar: function ( s ) {
			this.x -= s;
			this.y -= s;
			return this;
		},
		subVectors: function ( a, b ) {
			this.x = a.x - b.x;
			this.y = a.y - b.y;
			return this;
		},
		multiply: function ( v ) {
			this.x *= v.x;
			this.y *= v.y;
			return this;
		},
		multiplyScalar: function ( scalar ) {
			this.x *= scalar;
			this.y *= scalar;
			return this;
		},
		divide: function ( v ) {
			this.x /= v.x;
			this.y /= v.y;
			return this;
		},
		divideScalar: function ( scalar ) {
			return this.multiplyScalar( 1 / scalar );
		},
		applyMatrix3: function ( m ) {
			var x = this.x, y = this.y;
			var e = m.elements;
			this.x = e[ 0 ] * x + e[ 3 ] * y + e[ 6 ];
			this.y = e[ 1 ] * x + e[ 4 ] * y + e[ 7 ];
			return this;
		},
		min: function ( v ) {
			this.x = Math.min( this.x, v.x );
			this.y = Math.min( this.y, v.y );
			return this;
		},
		max: function ( v ) {
			this.x = Math.max( this.x, v.x );
			this.y = Math.max( this.y, v.y );
			return this;
		},
		clamp: function ( min, max ) {
			// assumes min  0 ) {
			console.error( 'THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.' );
		}
	}
	Object.assign( Matrix3.prototype, {
		isMatrix3: true,
		set: function ( n11, n12, n13, n21, n22, n23, n31, n32, n33 ) {
			var te = this.elements;
			te[ 0 ] = n11; te[ 1 ] = n21; te[ 2 ] = n31;
			te[ 3 ] = n12; te[ 4 ] = n22; te[ 5 ] = n32;
			te[ 6 ] = n13; te[ 7 ] = n23; te[ 8 ] = n33;
			return this;
		},
		identity: function () {
			this.set(
				1, 0, 0,
				0, 1, 0,
				0, 0, 1
			);
			return this;
		},
		clone: function () {
			return new this.constructor().fromArray( this.elements );
		},
		copy: function ( m ) {
			var te = this.elements;
			var me = m.elements;
			te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ];
			te[ 3 ] = me[ 3 ]; te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ];
			te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ]; te[ 8 ] = me[ 8 ];
			return this;
		},
		extractBasis: function ( xAxis, yAxis, zAxis ) {
			xAxis.setFromMatrix3Column( this, 0 );
			yAxis.setFromMatrix3Column( this, 1 );
			zAxis.setFromMatrix3Column( this, 2 );
			return this;
		},
		setFromMatrix4: function ( m ) {
			var me = m.elements;
			this.set(
				me[ 0 ], me[ 4 ], me[ 8 ],
				me[ 1 ], me[ 5 ], me[ 9 ],
				me[ 2 ], me[ 6 ], me[ 10 ]
			);
			return this;
		},
		multiply: function ( m ) {
			return this.multiplyMatrices( this, m );
		},
		premultiply: function ( m ) {
			return this.multiplyMatrices( m, this );
		},
		multiplyMatrices: function ( a, b ) {
			var ae = a.elements;
			var be = b.elements;
			var te = this.elements;
			var a11 = ae[ 0 ], a12 = ae[ 3 ], a13 = ae[ 6 ];
			var a21 = ae[ 1 ], a22 = ae[ 4 ], a23 = ae[ 7 ];
			var a31 = ae[ 2 ], a32 = ae[ 5 ], a33 = ae[ 8 ];
			var b11 = be[ 0 ], b12 = be[ 3 ], b13 = be[ 6 ];
			var b21 = be[ 1 ], b22 = be[ 4 ], b23 = be[ 7 ];
			var b31 = be[ 2 ], b32 = be[ 5 ], b33 = be[ 8 ];
			te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31;
			te[ 3 ] = a11 * b12 + a12 * b22 + a13 * b32;
			te[ 6 ] = a11 * b13 + a12 * b23 + a13 * b33;
			te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31;
			te[ 4 ] = a21 * b12 + a22 * b22 + a23 * b32;
			te[ 7 ] = a21 * b13 + a22 * b23 + a23 * b33;
			te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31;
			te[ 5 ] = a31 * b12 + a32 * b22 + a33 * b32;
			te[ 8 ] = a31 * b13 + a32 * b23 + a33 * b33;
			return this;
		},
		multiplyScalar: function ( s ) {
			var te = this.elements;
			te[ 0 ] *= s; te[ 3 ] *= s; te[ 6 ] *= s;
			te[ 1 ] *= s; te[ 4 ] *= s; te[ 7 ] *= s;
			te[ 2 ] *= s; te[ 5 ] *= s; te[ 8 ] *= s;
			return this;
		},
		determinant: function () {
			var te = this.elements;
			var a = te[ 0 ], b = te[ 1 ], c = te[ 2 ],
				d = te[ 3 ], e = te[ 4 ], f = te[ 5 ],
				g = te[ 6 ], h = te[ 7 ], i = te[ 8 ];
			return a * e * i - a * f * h - b * d * i + b * f * g + c * d * h - c * e * g;
		},
		getInverse: function ( matrix, throwOnDegenerate ) {
			if ( throwOnDegenerate !== undefined ) {
				console.warn( "THREE.Matrix3: .getInverse() can no longer be configured to throw on degenerate." );
			}
			var me = matrix.elements,
				te = this.elements,
				n11 = me[ 0 ], n21 = me[ 1 ], n31 = me[ 2 ],
				n12 = me[ 3 ], n22 = me[ 4 ], n32 = me[ 5 ],
				n13 = me[ 6 ], n23 = me[ 7 ], n33 = me[ 8 ],
				t11 = n33 * n22 - n32 * n23,
				t12 = n32 * n13 - n33 * n12,
				t13 = n23 * n12 - n22 * n13,
				det = n11 * t11 + n21 * t12 + n31 * t13;
			if ( det === 0 ) { return this.set( 0, 0, 0, 0, 0, 0, 0, 0, 0 ); }
			var detInv = 1 / det;
			te[ 0 ] = t11 * detInv;
			te[ 1 ] = ( n31 * n23 - n33 * n21 ) * detInv;
			te[ 2 ] = ( n32 * n21 - n31 * n22 ) * detInv;
			te[ 3 ] = t12 * detInv;
			te[ 4 ] = ( n33 * n11 - n31 * n13 ) * detInv;
			te[ 5 ] = ( n31 * n12 - n32 * n11 ) * detInv;
			te[ 6 ] = t13 * detInv;
			te[ 7 ] = ( n21 * n13 - n23 * n11 ) * detInv;
			te[ 8 ] = ( n22 * n11 - n21 * n12 ) * detInv;
			return this;
		},
		transpose: function () {
			var tmp, m = this.elements;
			tmp = m[ 1 ]; m[ 1 ] = m[ 3 ]; m[ 3 ] = tmp;
			tmp = m[ 2 ]; m[ 2 ] = m[ 6 ]; m[ 6 ] = tmp;
			tmp = m[ 5 ]; m[ 5 ] = m[ 7 ]; m[ 7 ] = tmp;
			return this;
		},
		getNormalMatrix: function ( matrix4 ) {
			return this.setFromMatrix4( matrix4 ).getInverse( this ).transpose();
		},
		transposeIntoArray: function ( r ) {
			var m = this.elements;
			r[ 0 ] = m[ 0 ];
			r[ 1 ] = m[ 3 ];
			r[ 2 ] = m[ 6 ];
			r[ 3 ] = m[ 1 ];
			r[ 4 ] = m[ 4 ];
			r[ 5 ] = m[ 7 ];
			r[ 6 ] = m[ 2 ];
			r[ 7 ] = m[ 5 ];
			r[ 8 ] = m[ 8 ];
			return this;
		},
		setUvTransform: function ( tx, ty, sx, sy, rotation, cx, cy ) {
			var c = Math.cos( rotation );
			var s = Math.sin( rotation );
			this.set(
				sx * c, sx * s, - sx * ( c * cx + s * cy ) + cx + tx,
				- sy * s, sy * c, - sy * ( - s * cx + c * cy ) + cy + ty,
				0, 0, 1
			);
		},
		scale: function ( sx, sy ) {
			var te = this.elements;
			te[ 0 ] *= sx; te[ 3 ] *= sx; te[ 6 ] *= sx;
			te[ 1 ] *= sy; te[ 4 ] *= sy; te[ 7 ] *= sy;
			return this;
		},
		rotate: function ( theta ) {
			var c = Math.cos( theta );
			var s = Math.sin( theta );
			var te = this.elements;
			var a11 = te[ 0 ], a12 = te[ 3 ], a13 = te[ 6 ];
			var a21 = te[ 1 ], a22 = te[ 4 ], a23 = te[ 7 ];
			te[ 0 ] = c * a11 + s * a21;
			te[ 3 ] = c * a12 + s * a22;
			te[ 6 ] = c * a13 + s * a23;
			te[ 1 ] = - s * a11 + c * a21;
			te[ 4 ] = - s * a12 + c * a22;
			te[ 7 ] = - s * a13 + c * a23;
			return this;
		},
		translate: function ( tx, ty ) {
			var te = this.elements;
			te[ 0 ] += tx * te[ 2 ]; te[ 3 ] += tx * te[ 5 ]; te[ 6 ] += tx * te[ 8 ];
			te[ 1 ] += ty * te[ 2 ]; te[ 4 ] += ty * te[ 5 ]; te[ 7 ] += ty * te[ 8 ];
			return this;
		},
		equals: function ( matrix ) {
			var te = this.elements;
			var me = matrix.elements;
			for ( var i = 0; i  2048 || canvas.height > 2048 ) {
				return canvas.toDataURL( 'image/jpeg', 0.6 );
			} else {
				return canvas.toDataURL( 'image/png' );
			}
		}
	};
	/**
	 * @author mrdoob / http://mrdoob.com/
	 * @author alteredq / http://alteredqualia.com/
	 * @author szimek / https://github.com/szimek/
	 */
	var textureId = 0;
	function Texture( image, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) {
		Object.defineProperty( this, 'id', { value: textureId ++ } );
		this.uuid = MathUtils.generateUUID();
		this.name = '';
		this.image = image !== undefined ? image : Texture.DEFAULT_IMAGE;
		this.mipmaps = [];
		this.mapping = mapping !== undefined ? mapping : Texture.DEFAULT_MAPPING;
		this.wrapS = wrapS !== undefined ? wrapS : ClampToEdgeWrapping;
		this.wrapT = wrapT !== undefined ? wrapT : ClampToEdgeWrapping;
		this.magFilter = magFilter !== undefined ? magFilter : LinearFilter;
		this.minFilter = minFilter !== undefined ? minFilter : LinearMipmapLinearFilter;
		this.anisotropy = anisotropy !== undefined ? anisotropy : 1;
		this.format = format !== undefined ? format : RGBAFormat;
		this.internalFormat = null;
		this.type = type !== undefined ? type : UnsignedByteType;
		this.offset = new Vector2( 0, 0 );
		this.repeat = new Vector2( 1, 1 );
		this.center = new Vector2( 0, 0 );
		this.rotation = 0;
		this.matrixAutoUpdate = true;
		this.matrix = new Matrix3();
		this.generateMipmaps = true;
		this.premultiplyAlpha = false;
		this.flipY = true;
		this.unpackAlignment = 4;	// valid values: 1, 2, 4, 8 (see http://www.khronos.org/opengles/sdk/docs/man/xhtml/glPixelStorei.xml)
		// Values of encoding !== THREE.LinearEncoding only supported on map, envMap and emissiveMap.
		//
		// Also changing the encoding after already used by a Material will not automatically make the Material
		// update. You need to explicitly call Material.needsUpdate to trigger it to recompile.
		this.encoding = encoding !== undefined ? encoding : LinearEncoding;
		this.version = 0;
		this.onUpdate = null;
	}
	Texture.DEFAULT_IMAGE = undefined;
	Texture.DEFAULT_MAPPING = UVMapping;
	Texture.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {
		constructor: Texture,
		isTexture: true,
		updateMatrix: function () {
			this.matrix.setUvTransform( this.offset.x, this.offset.y, this.repeat.x, this.repeat.y, this.rotation, this.center.x, this.center.y );
		},
		clone: function () {
			return new this.constructor().copy( this );
		},
		copy: function ( source ) {
			this.name = source.name;
			this.image = source.image;
			this.mipmaps = source.mipmaps.slice( 0 );
			this.mapping = source.mapping;
			this.wrapS = source.wrapS;
			this.wrapT = source.wrapT;
			this.magFilter = source.magFilter;
			this.minFilter = source.minFilter;
			this.anisotropy = source.anisotropy;
			this.format = source.format;
			this.internalFormat = source.internalFormat;
			this.type = source.type;
			this.offset.copy( source.offset );
			this.repeat.copy( source.repeat );
			this.center.copy( source.center );
			this.rotation = source.rotation;
			this.matrixAutoUpdate = source.matrixAutoUpdate;
			this.matrix.copy( source.matrix );
			this.generateMipmaps = source.generateMipmaps;
			this.premultiplyAlpha = source.premultiplyAlpha;
			this.flipY = source.flipY;
			this.unpackAlignment = source.unpackAlignment;
			this.encoding = source.encoding;
			return this;
		},
		toJSON: function ( meta ) {
			var isRootObject = ( meta === undefined || typeof meta === 'string' );
			if ( ! isRootObject && meta.textures[ this.uuid ] !== undefined ) {
				return meta.textures[ this.uuid ];
			}
			var output = {
				metadata: {
					version: 4.5,
					type: 'Texture',
					generator: 'Texture.toJSON'
				},
				uuid: this.uuid,
				name: this.name,
				mapping: this.mapping,
				repeat: [ this.repeat.x, this.repeat.y ],
				offset: [ this.offset.x, this.offset.y ],
				center: [ this.center.x, this.center.y ],
				rotation: this.rotation,
				wrap: [ this.wrapS, this.wrapT ],
				format: this.format,
				type: this.type,
				encoding: this.encoding,
				minFilter: this.minFilter,
				magFilter: this.magFilter,
				anisotropy: this.anisotropy,
				flipY: this.flipY,
				premultiplyAlpha: this.premultiplyAlpha,
				unpackAlignment: this.unpackAlignment
			};
			if ( this.image !== undefined ) {
				// TODO: Move to THREE.Image
				var image = this.image;
				if ( image.uuid === undefined ) {
					image.uuid = MathUtils.generateUUID(); // UGH
				}
				if ( ! isRootObject && meta.images[ image.uuid ] === undefined ) {
					var url;
					if ( Array.isArray( image ) ) {
						// process array of images e.g. CubeTexture
						url = [];
						for ( var i = 0, l = image.length; i  1 ) {
				switch ( this.wrapS ) {
					case RepeatWrapping:
						uv.x = uv.x - Math.floor( uv.x );
						break;
					case ClampToEdgeWrapping:
						uv.x = uv.x  1 ) {
				switch ( this.wrapT ) {
					case RepeatWrapping:
						uv.y = uv.y - Math.floor( uv.y );
						break;
					case ClampToEdgeWrapping:
						uv.y = uv.y  yy ) && ( xx > zz ) ) {
					// m11 is the largest diagonal term
					if ( xx  zz ) {
					// m22 is the largest diagonal term
					if ( yy = 0 ? 1 : - 1 ),
					sqrSin = 1 - cos * cos;
				// Skip the Slerp for tiny steps to avoid numeric problems:
				if ( sqrSin > Number.EPSILON ) {
					var sin = Math.sqrt( sqrSin ),
						len = Math.atan2( sin, cos * dir );
					s = Math.sin( s * len ) / sin;
					t = Math.sin( t * len ) / sin;
				}
				var tDir = t * dir;
				x0 = x0 * s + x1 * tDir;
				y0 = y0 * s + y1 * tDir;
				z0 = z0 * s + z1 * tDir;
				w0 = w0 * s + w1 * tDir;
				// Normalize in case we just did a lerp:
				if ( s === 1 - t ) {
					var f = 1 / Math.sqrt( x0 * x0 + y0 * y0 + z0 * z0 + w0 * w0 );
					x0 *= f;
					y0 *= f;
					z0 *= f;
					w0 *= f;
				}
			}
			dst[ dstOffset ] = x0;
			dst[ dstOffset + 1 ] = y0;
			dst[ dstOffset + 2 ] = z0;
			dst[ dstOffset + 3 ] = w0;
		},
		multiplyQuaternionsFlat: function ( dst, dstOffset, src0, srcOffset0, src1, srcOffset1 ) {
			var x0 = src0[ srcOffset0 ];
			var y0 = src0[ srcOffset0 + 1 ];
			var z0 = src0[ srcOffset0 + 2 ];
			var w0 = src0[ srcOffset0 + 3 ];
			var x1 = src1[ srcOffset1 ];
			var y1 = src1[ srcOffset1 + 1 ];
			var z1 = src1[ srcOffset1 + 2 ];
			var w1 = src1[ srcOffset1 + 3 ];
			dst[ dstOffset ] = x0 * w1 + w0 * x1 + y0 * z1 - z0 * y1;
			dst[ dstOffset + 1 ] = y0 * w1 + w0 * y1 + z0 * x1 - x0 * z1;
			dst[ dstOffset + 2 ] = z0 * w1 + w0 * z1 + x0 * y1 - y0 * x1;
			dst[ dstOffset + 3 ] = w0 * w1 - x0 * x1 - y0 * y1 - z0 * z1;
			return dst;
		}
	} );
	Object.defineProperties( Quaternion.prototype, {
		x: {
			get: function () {
				return this._x;
			},
			set: function ( value ) {
				this._x = value;
				this._onChangeCallback();
			}
		},
		y: {
			get: function () {
				return this._y;
			},
			set: function ( value ) {
				this._y = value;
				this._onChangeCallback();
			}
		},
		z: {
			get: function () {
				return this._z;
			},
			set: function ( value ) {
				this._z = value;
				this._onChangeCallback();
			}
		},
		w: {
			get: function () {
				return this._w;
			},
			set: function ( value ) {
				this._w = value;
				this._onChangeCallback();
			}
		}
	} );
	Object.assign( Quaternion.prototype, {
		isQuaternion: true,
		set: function ( x, y, z, w ) {
			this._x = x;
			this._y = y;
			this._z = z;
			this._w = w;
			this._onChangeCallback();
			return this;
		},
		clone: function () {
			return new this.constructor( this._x, this._y, this._z, this._w );
		},
		copy: function ( quaternion ) {
			this._x = quaternion.x;
			this._y = quaternion.y;
			this._z = quaternion.z;
			this._w = quaternion.w;
			this._onChangeCallback();
			return this;
		},
		setFromEuler: function ( euler, update ) {
			if ( ! ( euler && euler.isEuler ) ) {
				throw new Error( 'THREE.Quaternion: .setFromEuler() now expects an Euler rotation rather than a Vector3 and order.' );
			}
			var x = euler._x, y = euler._y, z = euler._z, order = euler.order;
			// http://www.mathworks.com/matlabcentral/fileexchange/
			// 	20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
			//	content/SpinCalc.m
			var cos = Math.cos;
			var sin = Math.sin;
			var c1 = cos( x / 2 );
			var c2 = cos( y / 2 );
			var c3 = cos( z / 2 );
			var s1 = sin( x / 2 );
			var s2 = sin( y / 2 );
			var s3 = sin( z / 2 );
			switch ( order ) {
				case 'XYZ':
					this._x = s1 * c2 * c3 + c1 * s2 * s3;
					this._y = c1 * s2 * c3 - s1 * c2 * s3;
					this._z = c1 * c2 * s3 + s1 * s2 * c3;
					this._w = c1 * c2 * c3 - s1 * s2 * s3;
					break;
				case 'YXZ':
					this._x = s1 * c2 * c3 + c1 * s2 * s3;
					this._y = c1 * s2 * c3 - s1 * c2 * s3;
					this._z = c1 * c2 * s3 - s1 * s2 * c3;
					this._w = c1 * c2 * c3 + s1 * s2 * s3;
					break;
				case 'ZXY':
					this._x = s1 * c2 * c3 - c1 * s2 * s3;
					this._y = c1 * s2 * c3 + s1 * c2 * s3;
					this._z = c1 * c2 * s3 + s1 * s2 * c3;
					this._w = c1 * c2 * c3 - s1 * s2 * s3;
					break;
				case 'ZYX':
					this._x = s1 * c2 * c3 - c1 * s2 * s3;
					this._y = c1 * s2 * c3 + s1 * c2 * s3;
					this._z = c1 * c2 * s3 - s1 * s2 * c3;
					this._w = c1 * c2 * c3 + s1 * s2 * s3;
					break;
				case 'YZX':
					this._x = s1 * c2 * c3 + c1 * s2 * s3;
					this._y = c1 * s2 * c3 + s1 * c2 * s3;
					this._z = c1 * c2 * s3 - s1 * s2 * c3;
					this._w = c1 * c2 * c3 - s1 * s2 * s3;
					break;
				case 'XZY':
					this._x = s1 * c2 * c3 - c1 * s2 * s3;
					this._y = c1 * s2 * c3 - s1 * c2 * s3;
					this._z = c1 * c2 * s3 + s1 * s2 * c3;
					this._w = c1 * c2 * c3 + s1 * s2 * s3;
					break;
				default:
					console.warn( 'THREE.Quaternion: .setFromEuler() encountered an unknown order: ' + order );
			}
			if ( update !== false ) { this._onChangeCallback(); }
			return this;
		},
		setFromAxisAngle: function ( axis, angle ) {
			// http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
			// assumes axis is normalized
			var halfAngle = angle / 2, s = Math.sin( halfAngle );
			this._x = axis.x * s;
			this._y = axis.y * s;
			this._z = axis.z * s;
			this._w = Math.cos( halfAngle );
			this._onChangeCallback();
			return this;
		},
		setFromRotationMatrix: function ( m ) {
			// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
			// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
			var te = m.elements,
				m11 = te[ 0 ], m12 = te[ 4 ], m13 = te[ 8 ],
				m21 = te[ 1 ], m22 = te[ 5 ], m23 = te[ 9 ],
				m31 = te[ 2 ], m32 = te[ 6 ], m33 = te[ 10 ],
				trace = m11 + m22 + m33,
				s;
			if ( trace > 0 ) {
				s = 0.5 / Math.sqrt( trace + 1.0 );
				this._w = 0.25 / s;
				this._x = ( m32 - m23 ) * s;
				this._y = ( m13 - m31 ) * s;
				this._z = ( m21 - m12 ) * s;
			} else if ( m11 > m22 && m11 > m33 ) {
				s = 2.0 * Math.sqrt( 1.0 + m11 - m22 - m33 );
				this._w = ( m32 - m23 ) / s;
				this._x = 0.25 * s;
				this._y = ( m12 + m21 ) / s;
				this._z = ( m13 + m31 ) / s;
			} else if ( m22 > m33 ) {
				s = 2.0 * Math.sqrt( 1.0 + m22 - m11 - m33 );
				this._w = ( m13 - m31 ) / s;
				this._x = ( m12 + m21 ) / s;
				this._y = 0.25 * s;
				this._z = ( m23 + m32 ) / s;
			} else {
				s = 2.0 * Math.sqrt( 1.0 + m33 - m11 - m22 );
				this._w = ( m21 - m12 ) / s;
				this._x = ( m13 + m31 ) / s;
				this._y = ( m23 + m32 ) / s;
				this._z = 0.25 * s;
			}
			this._onChangeCallback();
			return this;
		},
		setFromUnitVectors: function ( vFrom, vTo ) {
			// assumes direction vectors vFrom and vTo are normalized
			var EPS = 0.000001;
			var r = vFrom.dot( vTo ) + 1;
			if ( r  Math.abs( vFrom.z ) ) {
					this._x = - vFrom.y;
					this._y = vFrom.x;
					this._z = 0;
					this._w = r;
				} else {
					this._x = 0;
					this._y = - vFrom.z;
					this._z = vFrom.y;
					this._w = r;
				}
			} else {
				// crossVectors( vFrom, vTo ); // inlined to avoid cyclic dependency on Vector3
				this._x = vFrom.y * vTo.z - vFrom.z * vTo.y;
				this._y = vFrom.z * vTo.x - vFrom.x * vTo.z;
				this._z = vFrom.x * vTo.y - vFrom.y * vTo.x;
				this._w = r;
			}
			return this.normalize();
		},
		angleTo: function ( q ) {
			return 2 * Math.acos( Math.abs( MathUtils.clamp( this.dot( q ), - 1, 1 ) ) );
		},
		rotateTowards: function ( q, step ) {
			var angle = this.angleTo( q );
			if ( angle === 0 ) { return this; }
			var t = Math.min( 1, step / angle );
			this.slerp( q, t );
			return this;
		},
		inverse: function () {
			// quaternion is assumed to have unit length
			return this.conjugate();
		},
		conjugate: function () {
			this._x *= - 1;
			this._y *= - 1;
			this._z *= - 1;
			this._onChangeCallback();
			return this;
		},
		dot: function ( v ) {
			return this._x * v._x + this._y * v._y + this._z * v._z + this._w * v._w;
		},
		lengthSq: function () {
			return this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w;
		},
		length: function () {
			return Math.sqrt( this._x * this._x + this._y * this._y + this._z * this._z + this._w * this._w );
		},
		normalize: function () {
			var l = this.length();
			if ( l === 0 ) {
				this._x = 0;
				this._y = 0;
				this._z = 0;
				this._w = 1;
			} else {
				l = 1 / l;
				this._x = this._x * l;
				this._y = this._y * l;
				this._z = this._z * l;
				this._w = this._w * l;
			}
			this._onChangeCallback();
			return this;
		},
		multiply: function ( q, p ) {
			if ( p !== undefined ) {
				console.warn( 'THREE.Quaternion: .multiply() now only accepts one argument. Use .multiplyQuaternions( a, b ) instead.' );
				return this.multiplyQuaternions( q, p );
			}
			return this.multiplyQuaternions( this, q );
		},
		premultiply: function ( q ) {
			return this.multiplyQuaternions( q, this );
		},
		multiplyQuaternions: function ( a, b ) {
			// from http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/code/index.htm
			var qax = a._x, qay = a._y, qaz = a._z, qaw = a._w;
			var qbx = b._x, qby = b._y, qbz = b._z, qbw = b._w;
			this._x = qax * qbw + qaw * qbx + qay * qbz - qaz * qby;
			this._y = qay * qbw + qaw * qby + qaz * qbx - qax * qbz;
			this._z = qaz * qbw + qaw * qbz + qax * qby - qay * qbx;
			this._w = qaw * qbw - qax * qbx - qay * qby - qaz * qbz;
			this._onChangeCallback();
			return this;
		},
		slerp: function ( qb, t ) {
			if ( t === 0 ) { return this; }
			if ( t === 1 ) { return this.copy( qb ); }
			var x = this._x, y = this._y, z = this._z, w = this._w;
			// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/slerp/
			var cosHalfTheta = w * qb._w + x * qb._x + y * qb._y + z * qb._z;
			if ( cosHalfTheta = 1.0 ) {
				this._w = w;
				this._x = x;
				this._y = y;
				this._z = z;
				return this;
			}
			var sqrSinHalfTheta = 1.0 - cosHalfTheta * cosHalfTheta;
			if ( sqrSinHalfTheta  0 ) {
			console.error( 'THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.' );
		}
	}
	Object.assign( Matrix4.prototype, {
		isMatrix4: true,
		set: function ( n11, n12, n13, n14, n21, n22, n23, n24, n31, n32, n33, n34, n41, n42, n43, n44 ) {
			var te = this.elements;
			te[ 0 ] = n11; te[ 4 ] = n12; te[ 8 ] = n13; te[ 12 ] = n14;
			te[ 1 ] = n21; te[ 5 ] = n22; te[ 9 ] = n23; te[ 13 ] = n24;
			te[ 2 ] = n31; te[ 6 ] = n32; te[ 10 ] = n33; te[ 14 ] = n34;
			te[ 3 ] = n41; te[ 7 ] = n42; te[ 11 ] = n43; te[ 15 ] = n44;
			return this;
		},
		identity: function () {
			this.set(
				1, 0, 0, 0,
				0, 1, 0, 0,
				0, 0, 1, 0,
				0, 0, 0, 1
			);
			return this;
		},
		clone: function () {
			return new Matrix4().fromArray( this.elements );
		},
		copy: function ( m ) {
			var te = this.elements;
			var me = m.elements;
			te[ 0 ] = me[ 0 ]; te[ 1 ] = me[ 1 ]; te[ 2 ] = me[ 2 ]; te[ 3 ] = me[ 3 ];
			te[ 4 ] = me[ 4 ]; te[ 5 ] = me[ 5 ]; te[ 6 ] = me[ 6 ]; te[ 7 ] = me[ 7 ];
			te[ 8 ] = me[ 8 ]; te[ 9 ] = me[ 9 ]; te[ 10 ] = me[ 10 ]; te[ 11 ] = me[ 11 ];
			te[ 12 ] = me[ 12 ]; te[ 13 ] = me[ 13 ]; te[ 14 ] = me[ 14 ]; te[ 15 ] = me[ 15 ];
			return this;
		},
		copyPosition: function ( m ) {
			var te = this.elements, me = m.elements;
			te[ 12 ] = me[ 12 ];
			te[ 13 ] = me[ 13 ];
			te[ 14 ] = me[ 14 ];
			return this;
		},
		extractBasis: function ( xAxis, yAxis, zAxis ) {
			xAxis.setFromMatrixColumn( this, 0 );
			yAxis.setFromMatrixColumn( this, 1 );
			zAxis.setFromMatrixColumn( this, 2 );
			return this;
		},
		makeBasis: function ( xAxis, yAxis, zAxis ) {
			this.set(
				xAxis.x, yAxis.x, zAxis.x, 0,
				xAxis.y, yAxis.y, zAxis.y, 0,
				xAxis.z, yAxis.z, zAxis.z, 0,
				0, 0, 0, 1
			);
			return this;
		},
		extractRotation: function ( m ) {
			// this method does not support reflection matrices
			var te = this.elements;
			var me = m.elements;
			var scaleX = 1 / _v1.setFromMatrixColumn( m, 0 ).length();
			var scaleY = 1 / _v1.setFromMatrixColumn( m, 1 ).length();
			var scaleZ = 1 / _v1.setFromMatrixColumn( m, 2 ).length();
			te[ 0 ] = me[ 0 ] * scaleX;
			te[ 1 ] = me[ 1 ] * scaleX;
			te[ 2 ] = me[ 2 ] * scaleX;
			te[ 3 ] = 0;
			te[ 4 ] = me[ 4 ] * scaleY;
			te[ 5 ] = me[ 5 ] * scaleY;
			te[ 6 ] = me[ 6 ] * scaleY;
			te[ 7 ] = 0;
			te[ 8 ] = me[ 8 ] * scaleZ;
			te[ 9 ] = me[ 9 ] * scaleZ;
			te[ 10 ] = me[ 10 ] * scaleZ;
			te[ 11 ] = 0;
			te[ 12 ] = 0;
			te[ 13 ] = 0;
			te[ 14 ] = 0;
			te[ 15 ] = 1;
			return this;
		},
		makeRotationFromEuler: function ( euler ) {
			if ( ! ( euler && euler.isEuler ) ) {
				console.error( 'THREE.Matrix4: .makeRotationFromEuler() now expects a Euler rotation rather than a Vector3 and order.' );
			}
			var te = this.elements;
			var x = euler.x, y = euler.y, z = euler.z;
			var a = Math.cos( x ), b = Math.sin( x );
			var c = Math.cos( y ), d = Math.sin( y );
			var e = Math.cos( z ), f = Math.sin( z );
			if ( euler.order === 'XYZ' ) {
				var ae = a * e, af = a * f, be = b * e, bf = b * f;
				te[ 0 ] = c * e;
				te[ 4 ] = - c * f;
				te[ 8 ] = d;
				te[ 1 ] = af + be * d;
				te[ 5 ] = ae - bf * d;
				te[ 9 ] = - b * c;
				te[ 2 ] = bf - ae * d;
				te[ 6 ] = be + af * d;
				te[ 10 ] = a * c;
			} else if ( euler.order === 'YXZ' ) {
				var ce = c * e, cf = c * f, de = d * e, df = d * f;
				te[ 0 ] = ce + df * b;
				te[ 4 ] = de * b - cf;
				te[ 8 ] = a * d;
				te[ 1 ] = a * f;
				te[ 5 ] = a * e;
				te[ 9 ] = - b;
				te[ 2 ] = cf * b - de;
				te[ 6 ] = df + ce * b;
				te[ 10 ] = a * c;
			} else if ( euler.order === 'ZXY' ) {
				var ce = c * e, cf = c * f, de = d * e, df = d * f;
				te[ 0 ] = ce - df * b;
				te[ 4 ] = - a * f;
				te[ 8 ] = de + cf * b;
				te[ 1 ] = cf + de * b;
				te[ 5 ] = a * e;
				te[ 9 ] = df - ce * b;
				te[ 2 ] = - a * d;
				te[ 6 ] = b;
				te[ 10 ] = a * c;
			} else if ( euler.order === 'ZYX' ) {
				var ae = a * e, af = a * f, be = b * e, bf = b * f;
				te[ 0 ] = c * e;
				te[ 4 ] = be * d - af;
				te[ 8 ] = ae * d + bf;
				te[ 1 ] = c * f;
				te[ 5 ] = bf * d + ae;
				te[ 9 ] = af * d - be;
				te[ 2 ] = - d;
				te[ 6 ] = b * c;
				te[ 10 ] = a * c;
			} else if ( euler.order === 'YZX' ) {
				var ac = a * c, ad = a * d, bc = b * c, bd = b * d;
				te[ 0 ] = c * e;
				te[ 4 ] = bd - ac * f;
				te[ 8 ] = bc * f + ad;
				te[ 1 ] = f;
				te[ 5 ] = a * e;
				te[ 9 ] = - b * e;
				te[ 2 ] = - d * e;
				te[ 6 ] = ad * f + bc;
				te[ 10 ] = ac - bd * f;
			} else if ( euler.order === 'XZY' ) {
				var ac = a * c, ad = a * d, bc = b * c, bd = b * d;
				te[ 0 ] = c * e;
				te[ 4 ] = - f;
				te[ 8 ] = d * e;
				te[ 1 ] = ac * f + bd;
				te[ 5 ] = a * e;
				te[ 9 ] = ad * f - bc;
				te[ 2 ] = bc * f - ad;
				te[ 6 ] = b * e;
				te[ 10 ] = bd * f + ac;
			}
			// bottom row
			te[ 3 ] = 0;
			te[ 7 ] = 0;
			te[ 11 ] = 0;
			// last column
			te[ 12 ] = 0;
			te[ 13 ] = 0;
			te[ 14 ] = 0;
			te[ 15 ] = 1;
			return this;
		},
		makeRotationFromQuaternion: function ( q ) {
			return this.compose( _zero, q, _one );
		},
		lookAt: function ( eye, target, up ) {
			var te = this.elements;
			_z.subVectors( eye, target );
			if ( _z.lengthSq() === 0 ) {
				// eye and target are in the same position
				_z.z = 1;
			}
			_z.normalize();
			_x.crossVectors( up, _z );
			if ( _x.lengthSq() === 0 ) {
				// up and z are parallel
				if ( Math.abs( up.z ) === 1 ) {
					_z.x += 0.0001;
				} else {
					_z.z += 0.0001;
				}
				_z.normalize();
				_x.crossVectors( up, _z );
			}
			_x.normalize();
			_y.crossVectors( _z, _x );
			te[ 0 ] = _x.x; te[ 4 ] = _y.x; te[ 8 ] = _z.x;
			te[ 1 ] = _x.y; te[ 5 ] = _y.y; te[ 9 ] = _z.y;
			te[ 2 ] = _x.z; te[ 6 ] = _y.z; te[ 10 ] = _z.z;
			return this;
		},
		multiply: function ( m, n ) {
			if ( n !== undefined ) {
				console.warn( 'THREE.Matrix4: .multiply() now only accepts one argument. Use .multiplyMatrices( a, b ) instead.' );
				return this.multiplyMatrices( m, n );
			}
			return this.multiplyMatrices( this, m );
		},
		premultiply: function ( m ) {
			return this.multiplyMatrices( m, this );
		},
		multiplyMatrices: function ( a, b ) {
			var ae = a.elements;
			var be = b.elements;
			var te = this.elements;
			var a11 = ae[ 0 ], a12 = ae[ 4 ], a13 = ae[ 8 ], a14 = ae[ 12 ];
			var a21 = ae[ 1 ], a22 = ae[ 5 ], a23 = ae[ 9 ], a24 = ae[ 13 ];
			var a31 = ae[ 2 ], a32 = ae[ 6 ], a33 = ae[ 10 ], a34 = ae[ 14 ];
			var a41 = ae[ 3 ], a42 = ae[ 7 ], a43 = ae[ 11 ], a44 = ae[ 15 ];
			var b11 = be[ 0 ], b12 = be[ 4 ], b13 = be[ 8 ], b14 = be[ 12 ];
			var b21 = be[ 1 ], b22 = be[ 5 ], b23 = be[ 9 ], b24 = be[ 13 ];
			var b31 = be[ 2 ], b32 = be[ 6 ], b33 = be[ 10 ], b34 = be[ 14 ];
			var b41 = be[ 3 ], b42 = be[ 7 ], b43 = be[ 11 ], b44 = be[ 15 ];
			te[ 0 ] = a11 * b11 + a12 * b21 + a13 * b31 + a14 * b41;
			te[ 4 ] = a11 * b12 + a12 * b22 + a13 * b32 + a14 * b42;
			te[ 8 ] = a11 * b13 + a12 * b23 + a13 * b33 + a14 * b43;
			te[ 12 ] = a11 * b14 + a12 * b24 + a13 * b34 + a14 * b44;
			te[ 1 ] = a21 * b11 + a22 * b21 + a23 * b31 + a24 * b41;
			te[ 5 ] = a21 * b12 + a22 * b22 + a23 * b32 + a24 * b42;
			te[ 9 ] = a21 * b13 + a22 * b23 + a23 * b33 + a24 * b43;
			te[ 13 ] = a21 * b14 + a22 * b24 + a23 * b34 + a24 * b44;
			te[ 2 ] = a31 * b11 + a32 * b21 + a33 * b31 + a34 * b41;
			te[ 6 ] = a31 * b12 + a32 * b22 + a33 * b32 + a34 * b42;
			te[ 10 ] = a31 * b13 + a32 * b23 + a33 * b33 + a34 * b43;
			te[ 14 ] = a31 * b14 + a32 * b24 + a33 * b34 + a34 * b44;
			te[ 3 ] = a41 * b11 + a42 * b21 + a43 * b31 + a44 * b41;
			te[ 7 ] = a41 * b12 + a42 * b22 + a43 * b32 + a44 * b42;
			te[ 11 ] = a41 * b13 + a42 * b23 + a43 * b33 + a44 * b43;
			te[ 15 ] = a41 * b14 + a42 * b24 + a43 * b34 + a44 * b44;
			return this;
		},
		multiplyScalar: function ( s ) {
			var te = this.elements;
			te[ 0 ] *= s; te[ 4 ] *= s; te[ 8 ] *= s; te[ 12 ] *= s;
			te[ 1 ] *= s; te[ 5 ] *= s; te[ 9 ] *= s; te[ 13 ] *= s;
			te[ 2 ] *= s; te[ 6 ] *= s; te[ 10 ] *= s; te[ 14 ] *= s;
			te[ 3 ] *= s; te[ 7 ] *= s; te[ 11 ] *= s; te[ 15 ] *= s;
			return this;
		},
		determinant: function () {
			var te = this.elements;
			var n11 = te[ 0 ], n12 = te[ 4 ], n13 = te[ 8 ], n14 = te[ 12 ];
			var n21 = te[ 1 ], n22 = te[ 5 ], n23 = te[ 9 ], n24 = te[ 13 ];
			var n31 = te[ 2 ], n32 = te[ 6 ], n33 = te[ 10 ], n34 = te[ 14 ];
			var n41 = te[ 3 ], n42 = te[ 7 ], n43 = te[ 11 ], n44 = te[ 15 ];
			//TODO: make this more efficient
			//( based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm )
			return (
				n41 * (
					+ n14 * n23 * n32
					 - n13 * n24 * n32
					 - n14 * n22 * n33
					 + n12 * n24 * n33
					 + n13 * n22 * n34
					 - n12 * n23 * n34
				) +
				n42 * (
					+ n11 * n23 * n34
					 - n11 * n24 * n33
					 + n14 * n21 * n33
					 - n13 * n21 * n34
					 + n13 * n24 * n31
					 - n14 * n23 * n31
				) +
				n43 * (
					+ n11 * n24 * n32
					 - n11 * n22 * n34
					 - n14 * n21 * n32
					 + n12 * n21 * n34
					 + n14 * n22 * n31
					 - n12 * n24 * n31
				) +
				n44 * (
					- n13 * n22 * n31
					 - n11 * n23 * n32
					 + n11 * n22 * n33
					 + n13 * n21 * n32
					 - n12 * n21 * n33
					 + n12 * n23 * n31
				)
			);
		},
		transpose: function () {
			var te = this.elements;
			var tmp;
			tmp = te[ 1 ]; te[ 1 ] = te[ 4 ]; te[ 4 ] = tmp;
			tmp = te[ 2 ]; te[ 2 ] = te[ 8 ]; te[ 8 ] = tmp;
			tmp = te[ 6 ]; te[ 6 ] = te[ 9 ]; te[ 9 ] = tmp;
			tmp = te[ 3 ]; te[ 3 ] = te[ 12 ]; te[ 12 ] = tmp;
			tmp = te[ 7 ]; te[ 7 ] = te[ 13 ]; te[ 13 ] = tmp;
			tmp = te[ 11 ]; te[ 11 ] = te[ 14 ]; te[ 14 ] = tmp;
			return this;
		},
		setPosition: function ( x, y, z ) {
			var te = this.elements;
			if ( x.isVector3 ) {
				te[ 12 ] = x.x;
				te[ 13 ] = x.y;
				te[ 14 ] = x.z;
			} else {
				te[ 12 ] = x;
				te[ 13 ] = y;
				te[ 14 ] = z;
			}
			return this;
		},
		getInverse: function ( m, throwOnDegenerate ) {
			if ( throwOnDegenerate !== undefined ) {
				console.warn( "THREE.Matrix4: .getInverse() can no longer be configured to throw on degenerate." );
			}
			// based on http://www.euclideanspace.com/maths/algebra/matrix/functions/inverse/fourD/index.htm
			var te = this.elements,
				me = m.elements,
				n11 = me[ 0 ], n21 = me[ 1 ], n31 = me[ 2 ], n41 = me[ 3 ],
				n12 = me[ 4 ], n22 = me[ 5 ], n32 = me[ 6 ], n42 = me[ 7 ],
				n13 = me[ 8 ], n23 = me[ 9 ], n33 = me[ 10 ], n43 = me[ 11 ],
				n14 = me[ 12 ], n24 = me[ 13 ], n34 = me[ 14 ], n44 = me[ 15 ],
				t11 = n23 * n34 * n42 - n24 * n33 * n42 + n24 * n32 * n43 - n22 * n34 * n43 - n23 * n32 * n44 + n22 * n33 * n44,
				t12 = n14 * n33 * n42 - n13 * n34 * n42 - n14 * n32 * n43 + n12 * n34 * n43 + n13 * n32 * n44 - n12 * n33 * n44,
				t13 = n13 * n24 * n42 - n14 * n23 * n42 + n14 * n22 * n43 - n12 * n24 * n43 - n13 * n22 * n44 + n12 * n23 * n44,
				t14 = n14 * n23 * n32 - n13 * n24 * n32 - n14 * n22 * n33 + n12 * n24 * n33 + n13 * n22 * n34 - n12 * n23 * n34;
			var det = n11 * t11 + n21 * t12 + n31 * t13 + n41 * t14;
			if ( det === 0 ) { return this.set( 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ); }
			var detInv = 1 / det;
			te[ 0 ] = t11 * detInv;
			te[ 1 ] = ( n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44 ) * detInv;
			te[ 2 ] = ( n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44 ) * detInv;
			te[ 3 ] = ( n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43 ) * detInv;
			te[ 4 ] = t12 * detInv;
			te[ 5 ] = ( n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44 ) * detInv;
			te[ 6 ] = ( n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44 ) * detInv;
			te[ 7 ] = ( n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43 ) * detInv;
			te[ 8 ] = t13 * detInv;
			te[ 9 ] = ( n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44 ) * detInv;
			te[ 10 ] = ( n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44 ) * detInv;
			te[ 11 ] = ( n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43 ) * detInv;
			te[ 12 ] = t14 * detInv;
			te[ 13 ] = ( n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34 ) * detInv;
			te[ 14 ] = ( n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34 ) * detInv;
			te[ 15 ] = ( n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33 ) * detInv;
			return this;
		},
		scale: function ( v ) {
			var te = this.elements;
			var x = v.x, y = v.y, z = v.z;
			te[ 0 ] *= x; te[ 4 ] *= y; te[ 8 ] *= z;
			te[ 1 ] *= x; te[ 5 ] *= y; te[ 9 ] *= z;
			te[ 2 ] *= x; te[ 6 ] *= y; te[ 10 ] *= z;
			te[ 3 ] *= x; te[ 7 ] *= y; te[ 11 ] *= z;
			return this;
		},
		getMaxScaleOnAxis: function () {
			var te = this.elements;
			var scaleXSq = te[ 0 ] * te[ 0 ] + te[ 1 ] * te[ 1 ] + te[ 2 ] * te[ 2 ];
			var scaleYSq = te[ 4 ] * te[ 4 ] + te[ 5 ] * te[ 5 ] + te[ 6 ] * te[ 6 ];
			var scaleZSq = te[ 8 ] * te[ 8 ] + te[ 9 ] * te[ 9 ] + te[ 10 ] * te[ 10 ];
			return Math.sqrt( Math.max( scaleXSq, scaleYSq, scaleZSq ) );
		},
		makeTranslation: function ( x, y, z ) {
			this.set(
				1, 0, 0, x,
				0, 1, 0, y,
				0, 0, 1, z,
				0, 0, 0, 1
			);
			return this;
		},
		makeRotationX: function ( theta ) {
			var c = Math.cos( theta ), s = Math.sin( theta );
			this.set(
				1, 0, 0, 0,
				0, c, - s, 0,
				0, s, c, 0,
				0, 0, 0, 1
			);
			return this;
		},
		makeRotationY: function ( theta ) {
			var c = Math.cos( theta ), s = Math.sin( theta );
			this.set(
				 c, 0, s, 0,
				 0, 1, 0, 0,
				- s, 0, c, 0,
				 0, 0, 0, 1
			);
			return this;
		},
		makeRotationZ: function ( theta ) {
			var c = Math.cos( theta ), s = Math.sin( theta );
			this.set(
				c, - s, 0, 0,
				s, c, 0, 0,
				0, 0, 1, 0,
				0, 0, 0, 1
			);
			return this;
		},
		makeRotationAxis: function ( axis, angle ) {
			// Based on http://www.gamedev.net/reference/articles/article1199.asp
			var c = Math.cos( angle );
			var s = Math.sin( angle );
			var t = 1 - c;
			var x = axis.x, y = axis.y, z = axis.z;
			var tx = t * x, ty = t * y;
			this.set(
				tx * x + c, tx * y - s * z, tx * z + s * y, 0,
				tx * y + s * z, ty * y + c, ty * z - s * x, 0,
				tx * z - s * y, ty * z + s * x, t * z * z + c, 0,
				0, 0, 0, 1
			);
			 return this;
		},
		makeScale: function ( x, y, z ) {
			this.set(
				x, 0, 0, 0,
				0, y, 0, 0,
				0, 0, z, 0,
				0, 0, 0, 1
			);
			return this;
		},
		makeShear: function ( x, y, z ) {
			this.set(
				1, y, z, 0,
				x, 1, z, 0,
				x, y, 1, 0,
				0, 0, 0, 1
			);
			return this;
		},
		compose: function ( position, quaternion, scale ) {
			var te = this.elements;
			var x = quaternion._x, y = quaternion._y, z = quaternion._z, w = quaternion._w;
			var x2 = x + x,	y2 = y + y, z2 = z + z;
			var xx = x * x2, xy = x * y2, xz = x * z2;
			var yy = y * y2, yz = y * z2, zz = z * z2;
			var wx = w * x2, wy = w * y2, wz = w * z2;
			var sx = scale.x, sy = scale.y, sz = scale.z;
			te[ 0 ] = ( 1 - ( yy + zz ) ) * sx;
			te[ 1 ] = ( xy + wz ) * sx;
			te[ 2 ] = ( xz - wy ) * sx;
			te[ 3 ] = 0;
			te[ 4 ] = ( xy - wz ) * sy;
			te[ 5 ] = ( 1 - ( xx + zz ) ) * sy;
			te[ 6 ] = ( yz + wx ) * sy;
			te[ 7 ] = 0;
			te[ 8 ] = ( xz + wy ) * sz;
			te[ 9 ] = ( yz - wx ) * sz;
			te[ 10 ] = ( 1 - ( xx + yy ) ) * sz;
			te[ 11 ] = 0;
			te[ 12 ] = position.x;
			te[ 13 ] = position.y;
			te[ 14 ] = position.z;
			te[ 15 ] = 1;
			return this;
		},
		decompose: function ( position, quaternion, scale ) {
			var te = this.elements;
			var sx = _v1.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length();
			var sy = _v1.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();
			var sz = _v1.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length();
			// if determine is negative, we need to invert one scale
			var det = this.determinant();
			if ( det  1 ) {
				for ( var i = 0; i  1 ) {
				for ( var i = 0; i  0 ) {
				object.children = [];
				for ( var i = 0; i  0 ) { output.geometries = geometries; }
				if ( materials.length > 0 ) { output.materials = materials; }
				if ( textures.length > 0 ) { output.textures = textures; }
				if ( images.length > 0 ) { output.images = images; }
				if ( shapes.length > 0 ) { output.shapes = shapes; }
			}
			output.object = object;
			return output;
			// extract data from the cache hash
			// remove metadata on each item
			// and return as array
			function extractFromCache( cache ) {
				var values = [];
				for ( var key in cache ) {
					var data = cache[ key ];
					delete data.metadata;
					values.push( data );
				}
				return values;
			}
		},
		clone: function ( recursive ) {
			return new this.constructor().copy( this, recursive );
		},
		copy: function ( source, recursive ) {
			if ( recursive === undefined ) { recursive = true; }
			this.name = source.name;
			this.up.copy( source.up );
			this.position.copy( source.position );
			this.quaternion.copy( source.quaternion );
			this.scale.copy( source.scale );
			this.matrix.copy( source.matrix );
			this.matrixWorld.copy( source.matrixWorld );
			this.matrixAutoUpdate = source.matrixAutoUpdate;
			this.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate;
			this.layers.mask = source.layers.mask;
			this.visible = source.visible;
			this.castShadow = source.castShadow;
			this.receiveShadow = source.receiveShadow;
			this.frustumCulled = source.frustumCulled;
			this.renderOrder = source.renderOrder;
			this.userData = JSON.parse( JSON.stringify( source.userData ) );
			if ( recursive === true ) {
				for ( var i = 0; i  maxX ) { maxX = x; }
				if ( y > maxY ) { maxY = y; }
				if ( z > maxZ ) { maxZ = z; }
			}
			this.min.set( minX, minY, minZ );
			this.max.set( maxX, maxY, maxZ );
			return this;
		},
		setFromBufferAttribute: function ( attribute ) {
			var minX = + Infinity;
			var minY = + Infinity;
			var minZ = + Infinity;
			var maxX = - Infinity;
			var maxY = - Infinity;
			var maxZ = - Infinity;
			for ( var i = 0, l = attribute.count; i  maxX ) { maxX = x; }
				if ( y > maxY ) { maxY = y; }
				if ( z > maxZ ) { maxZ = z; }
			}
			this.min.set( minX, minY, minZ );
			this.max.set( maxX, maxY, maxZ );
			return this;
		},
		setFromPoints: function ( points ) {
			this.makeEmpty();
			for ( var i = 0, il = points.length; i  this.max.x ||
				point.y  this.max.y ||
				point.z  this.max.z ? false : true;
		},
		containsBox: function ( box ) {
			return this.min.x  this.max.x ||
				box.max.y  this.max.y ||
				box.max.z  this.max.z ? false : true;
		},
		intersectsSphere: function ( sphere ) {
			// Find the point on the AABB closest to the sphere center.
			this.clampPoint( sphere.center, _vector$1 );
			// If that point is inside the sphere, the AABB and sphere intersect.
			return _vector$1.distanceToSquared( sphere.center )  0 ) {
				min = plane.normal.x * this.min.x;
				max = plane.normal.x * this.max.x;
			} else {
				min = plane.normal.x * this.max.x;
				max = plane.normal.x * this.min.x;
			}
			if ( plane.normal.y > 0 ) {
				min += plane.normal.y * this.min.y;
				max += plane.normal.y * this.max.y;
			} else {
				min += plane.normal.y * this.max.y;
				max += plane.normal.y * this.min.y;
			}
			if ( plane.normal.z > 0 ) {
				min += plane.normal.z * this.min.z;
				max += plane.normal.z * this.max.z;
			} else {
				min += plane.normal.z * this.max.z;
				max += plane.normal.z * this.min.z;
			}
			return ( min = - plane.constant );
		},
		intersectsTriangle: function ( triangle ) {
			if ( this.isEmpty() ) {
				return false;
			}
			// compute box center and extents
			this.getCenter( _center );
			_extents.subVectors( this.max, _center );
			// translate triangle to aabb origin
			_v0.subVectors( triangle.a, _center );
			_v1$2.subVectors( triangle.b, _center );
			_v2.subVectors( triangle.c, _center );
			// compute edge vectors for triangle
			_f0.subVectors( _v1$2, _v0 );
			_f1.subVectors( _v2, _v1$2 );
			_f2.subVectors( _v0, _v2 );
			// test against axes that are given by cross product combinations of the edges of the triangle and the edges of the aabb
			// make an axis testing of each of the 3 sides of the aabb against each of the 3 sides of the triangle = 9 axis of separation
			// axis_ij = u_i x f_j (u0, u1, u2 = face normals of aabb = x,y,z axes vectors since aabb is axis aligned)
			var axes = [
				0, - _f0.z, _f0.y, 0, - _f1.z, _f1.y, 0, - _f2.z, _f2.y,
				_f0.z, 0, - _f0.x, _f1.z, 0, - _f1.x, _f2.z, 0, - _f2.x,
				- _f0.y, _f0.x, 0, - _f1.y, _f1.x, 0, - _f2.y, _f2.x, 0
			];
			if ( ! satForAxes( axes, _v0, _v1$2, _v2, _extents ) ) {
				return false;
			}
			// test 3 face normals from the aabb
			axes = [ 1, 0, 0, 0, 1, 0, 0, 0, 1 ];
			if ( ! satForAxes( axes, _v0, _v1$2, _v2, _extents ) ) {
				return false;
			}
			// finally testing the face normal of the triangle
			// use already existing triangle edge vectors here
			_triangleNormal.crossVectors( _f0, _f1 );
			axes = [ _triangleNormal.x, _triangleNormal.y, _triangleNormal.z ];
			return satForAxes( axes, _v0, _v1$2, _v2, _extents );
		},
		clampPoint: function ( point, target ) {
			if ( target === undefined ) {
				console.warn( 'THREE.Box3: .clampPoint() target is now required' );
				target = new Vector3();
			}
			return target.copy( point ).clamp( this.min, this.max );
		},
		distanceToPoint: function ( point ) {
			var clampedPoint = _vector$1.copy( point ).clamp( this.min, this.max );
			return clampedPoint.sub( point ).length();
		},
		getBoundingSphere: function ( target ) {
			if ( target === undefined ) {
				console.error( 'THREE.Box3: .getBoundingSphere() target is now required' );
				//target = new Sphere(); // removed to avoid cyclic dependency
			}
			this.getCenter( target.center );
			target.radius = this.getSize( _vector$1 ).length() * 0.5;
			return target;
		},
		intersect: function ( box ) {
			this.min.max( box.min );
			this.max.min( box.max );
			// ensure that if there is no overlap, the result is fully empty, not slightly empty with non-inf/+inf values that will cause subsequence intersects to erroneously return valid values.
			if ( this.isEmpty() ) { this.makeEmpty(); }
			return this;
		},
		union: function ( box ) {
			this.min.min( box.min );
			this.max.max( box.max );
			return this;
		},
		applyMatrix4: function ( matrix ) {
			// transform of empty box is an empty box.
			if ( this.isEmpty() ) { return this; }
			// NOTE: I am using a binary pattern to specify all 2^3 combinations below
			_points[ 0 ].set( this.min.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 000
			_points[ 1 ].set( this.min.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 001
			_points[ 2 ].set( this.min.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 010
			_points[ 3 ].set( this.min.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 011
			_points[ 4 ].set( this.max.x, this.min.y, this.min.z ).applyMatrix4( matrix ); // 100
			_points[ 5 ].set( this.max.x, this.min.y, this.max.z ).applyMatrix4( matrix ); // 101
			_points[ 6 ].set( this.max.x, this.max.y, this.min.z ).applyMatrix4( matrix ); // 110
			_points[ 7 ].set( this.max.x, this.max.y, this.max.z ).applyMatrix4( matrix ); // 111
			this.setFromPoints( _points );
			return this;
		},
		translate: function ( offset ) {
			this.min.add( offset );
			this.max.add( offset );
			return this;
		},
		equals: function ( box ) {
			return box.min.equals( this.min ) && box.max.equals( this.max );
		}
	} );
	function satForAxes( axes, v0, v1, v2, extents ) {
		var i, j;
		for ( i = 0, j = axes.length - 3; i  r ) {
				// points of the projected triangle are outside the projected half-length of the aabb
				// the axis is seperating and we can exit
				return false;
			}
		}
		return true;
	}
	var _box$1 = new Box3();
	/**
	 * @author bhouston / http://clara.io
	 * @author mrdoob / http://mrdoob.com/
	 */
	function Sphere( center, radius ) {
		this.center = ( center !== undefined ) ? center : new Vector3();
		this.radius = ( radius !== undefined ) ? radius : - 1;
	}
	Object.assign( Sphere.prototype, {
		set: function ( center, radius ) {
			this.center.copy( center );
			this.radius = radius;
			return this;
		},
		setFromPoints: function ( points, optionalCenter ) {
			var center = this.center;
			if ( optionalCenter !== undefined ) {
				center.copy( optionalCenter );
			} else {
				_box$1.setFromPoints( points ).getCenter( center );
			}
			var maxRadiusSq = 0;
			for ( var i = 0, il = points.length; i  ( this.radius * this.radius ) ) {
				target.sub( this.center ).normalize();
				target.multiplyScalar( this.radius ).add( this.center );
			}
			return target;
		},
		getBoundingBox: function ( target ) {
			if ( target === undefined ) {
				console.warn( 'THREE.Sphere: .getBoundingBox() target is now required' );
				target = new Box3();
			}
			if ( this.isEmpty() ) {
				// Empty sphere produces empty bounding box
				target.makeEmpty();
				return target;
			}
			target.set( this.center, this.center );
			target.expandByScalar( this.radius );
			return target;
		},
		applyMatrix4: function ( matrix ) {
			this.center.applyMatrix4( matrix );
			this.radius = this.radius * matrix.getMaxScaleOnAxis();
			return this;
		},
		translate: function ( offset ) {
			this.center.add( offset );
			return this;
		},
		equals: function ( sphere ) {
			return sphere.center.equals( this.center ) && ( sphere.radius === this.radius );
		}
	} );
	var _vector$2 = new Vector3();
	var _segCenter = new Vector3();
	var _segDir = new Vector3();
	var _diff = new Vector3();
	var _edge1 = new Vector3();
	var _edge2 = new Vector3();
	var _normal = new Vector3();
	/**
	 * @author bhouston / http://clara.io
	 */
	function Ray( origin, direction ) {
		this.origin = ( origin !== undefined ) ? origin : new Vector3();
		this.direction = ( direction !== undefined ) ? direction : new Vector3( 0, 0, - 1 );
	}
	Object.assign( Ray.prototype, {
		set: function ( origin, direction ) {
			this.origin.copy( origin );
			this.direction.copy( direction );
			return this;
		},
		clone: function () {
			return new this.constructor().copy( this );
		},
		copy: function ( ray ) {
			this.origin.copy( ray.origin );
			this.direction.copy( ray.direction );
			return this;
		},
		at: function ( t, target ) {
			if ( target === undefined ) {
				console.warn( 'THREE.Ray: .at() target is now required' );
				target = new Vector3();
			}
			return target.copy( this.direction ).multiplyScalar( t ).add( this.origin );
		},
		lookAt: function ( v ) {
			this.direction.copy( v ).sub( this.origin ).normalize();
			return this;
		},
		recast: function ( t ) {
			this.origin.copy( this.at( t, _vector$2 ) );
			return this;
		},
		closestPointToPoint: function ( point, target ) {
			if ( target === undefined ) {
				console.warn( 'THREE.Ray: .closestPointToPoint() target is now required' );
				target = new Vector3();
			}
			target.subVectors( point, this.origin );
			var directionDistance = target.dot( this.direction );
			if ( directionDistance  0 ) {
				// The ray and segment are not parallel.
				s0 = a01 * b1 - b0;
				s1 = a01 * b0 - b1;
				extDet = segExtent * det;
				if ( s0 >= 0 ) {
					if ( s1 >= - extDet ) {
						if ( s1  0 ) ? - segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );
						sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
					} else if ( s1  0 ) ? segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );
						sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
					}
				}
			} else {
				// Ray and segment are parallel.
				s1 = ( a01 > 0 ) ? - segExtent : segExtent;
				s0 = Math.max( 0, - ( a01 * s1 + b0 ) );
				sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
			}
			if ( optionalPointOnRay ) {
				optionalPointOnRay.copy( this.direction ).multiplyScalar( s0 ).add( this.origin );
			}
			if ( optionalPointOnSegment ) {
				optionalPointOnSegment.copy( _segDir ).multiplyScalar( s1 ).add( _segCenter );
			}
			return sqrDist;
		},
		intersectSphere: function ( sphere, target ) {
			_vector$2.subVectors( sphere.center, this.origin );
			var tca = _vector$2.dot( this.direction );
			var d2 = _vector$2.dot( _vector$2 ) - tca * tca;
			var radius2 = sphere.radius * sphere.radius;
			if ( d2 > radius2 ) { return null; }
			var thc = Math.sqrt( radius2 - d2 );
			// t0 = first intersect point - entrance on front of sphere
			var t0 = tca - thc;
			// t1 = second intersect point - exit point on back of sphere
			var t1 = tca + thc;
			// test to see if both t0 and t1 are behind the ray - if so, return null
			if ( t0 = 0 ? t : null;
		},
		intersectPlane: function ( plane, target ) {
			var t = this.distanceToPlane( plane );
			if ( t === null ) {
				return null;
			}
			return this.at( t, target );
		},
		intersectsPlane: function ( plane ) {
			// check if the ray lies on the plane first
			var distToPoint = plane.distanceToPoint( this.origin );
			if ( distToPoint === 0 ) {
				return true;
			}
			var denominator = plane.normal.dot( this.direction );
			if ( denominator * distToPoint = 0 ) {
				tmin = ( box.min.x - origin.x ) * invdirx;
				tmax = ( box.max.x - origin.x ) * invdirx;
			} else {
				tmin = ( box.max.x - origin.x ) * invdirx;
				tmax = ( box.min.x - origin.x ) * invdirx;
			}
			if ( invdiry >= 0 ) {
				tymin = ( box.min.y - origin.y ) * invdiry;
				tymax = ( box.max.y - origin.y ) * invdiry;
			} else {
				tymin = ( box.max.y - origin.y ) * invdiry;
				tymax = ( box.min.y - origin.y ) * invdiry;
			}
			if ( ( tmin > tymax ) || ( tymin > tmax ) ) { return null; }
			// These lines also handle the case where tmin or tmax is NaN
			// (result of 0 * Infinity). x !== x returns true if x is NaN
			if ( tymin > tmin || tmin !== tmin ) { tmin = tymin; }
			if ( tymax = 0 ) {
				tzmin = ( box.min.z - origin.z ) * invdirz;
				tzmax = ( box.max.z - origin.z ) * invdirz;
			} else {
				tzmin = ( box.max.z - origin.z ) * invdirz;
				tzmax = ( box.min.z - origin.z ) * invdirz;
			}
			if ( ( tmin > tzmax ) || ( tzmin > tmax ) ) { return null; }
			if ( tzmin > tmin || tmin !== tmin ) { tmin = tzmin; }
			if ( tzmax = 0 ? tmin : tmax, target );
		},
		intersectsBox: function ( box ) {
			return this.intersectBox( box, _vector$2 ) !== null;
		},
		intersectTriangle: function ( a, b, c, backfaceCulling, target ) {
			// Compute the offset origin, edges, and normal.
			// from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
			_edge1.subVectors( b, a );
			_edge2.subVectors( c, a );
			_normal.crossVectors( _edge1, _edge2 );
			// Solve Q + t*D = b1*E1 + b2*E2 (Q = kDiff, D = ray direction,
			// E1 = kEdge1, E2 = kEdge2, N = Cross(E1,E2)) by
			//   |Dot(D,N)|*b1 = sign(Dot(D,N))*Dot(D,Cross(Q,E2))
			//   |Dot(D,N)|*b2 = sign(Dot(D,N))*Dot(D,Cross(E1,Q))
			//   |Dot(D,N)|*t = -sign(Dot(D,N))*Dot(Q,N)
			var DdN = this.direction.dot( _normal );
			var sign;
			if ( DdN > 0 ) {
				if ( backfaceCulling ) { return null; }
				sign = 1;
			} else if ( DdN  1, no intersection
			if ( DdQxE2 + DdE1xQ > DdN ) {
				return null;
			}
			// Line intersects triangle, check if ray does.
			var QdN = - sign * _diff.dot( _normal );
			// t  1 ) {
				return undefined;
			}
			return target.copy( direction ).multiplyScalar( t ).add( line.start );
		},
		intersectsLine: function ( line ) {
			// Note: this tests if a line intersects the plane, not whether it (or its end-points) are coplanar with it.
			var startSign = this.distanceToPoint( line.start );
			var endSign = this.distanceToPoint( line.end );
			return ( startSign  0 ) || ( endSign  0 );
		},
		intersectsBox: function ( box ) {
			return box.intersectsPlane( this );
		},
		intersectsSphere: function ( sphere ) {
			return sphere.intersectsPlane( this );
		},
		coplanarPoint: function ( target ) {
			if ( target === undefined ) {
				console.warn( 'THREE.Plane: .coplanarPoint() target is now required' );
				target = new Vector3();
			}
			return target.copy( this.normal ).multiplyScalar( - this.constant );
		},
		applyMatrix4: function ( matrix, optionalNormalMatrix ) {
			var normalMatrix = optionalNormalMatrix || _normalMatrix.getNormalMatrix( matrix );
			var referencePoint = this.coplanarPoint( _vector1 ).applyMatrix4( matrix );
			var normal = this.normal.applyMatrix3( normalMatrix ).normalize();
			this.constant = - referencePoint.dot( normal );
			return this;
		},
		translate: function ( offset ) {
			this.constant -= offset.dot( this.normal );
			return this;
		},
		equals: function ( plane ) {
			return plane.normal.equals( this.normal ) && ( plane.constant === this.constant );
		}
	} );
	/**
	 * @author bhouston / http://clara.io
	 * @author mrdoob / http://mrdoob.com/
	 */
	var _v0$1 = new Vector3();
	var _v1$3 = new Vector3();
	var _v2$1 = new Vector3();
	var _v3 = new Vector3();
	var _vab = new Vector3();
	var _vac = new Vector3();
	var _vbc = new Vector3();
	var _vap = new Vector3();
	var _vbp = new Vector3();
	var _vcp = new Vector3();
	function Triangle( a, b, c ) {
		this.a = ( a !== undefined ) ? a : new Vector3();
		this.b = ( b !== undefined ) ? b : new Vector3();
		this.c = ( c !== undefined ) ? c : new Vector3();
	}
	Object.assign( Triangle, {
		getNormal: function ( a, b, c, target ) {
			if ( target === undefined ) {
				console.warn( 'THREE.Triangle: .getNormal() target is now required' );
				target = new Vector3();
			}
			target.subVectors( c, b );
			_v0$1.subVectors( a, b );
			target.cross( _v0$1 );
			var targetLengthSq = target.lengthSq();
			if ( targetLengthSq > 0 ) {
				return target.multiplyScalar( 1 / Math.sqrt( targetLengthSq ) );
			}
			return target.set( 0, 0, 0 );
		},
		// static/instance method to calculate barycentric coordinates
		// based on: http://www.blackpawn.com/texts/pointinpoly/default.html
		getBarycoord: function ( point, a, b, c, target ) {
			_v0$1.subVectors( c, a );
			_v1$3.subVectors( b, a );
			_v2$1.subVectors( point, a );
			var dot00 = _v0$1.dot( _v0$1 );
			var dot01 = _v0$1.dot( _v1$3 );
			var dot02 = _v0$1.dot( _v2$1 );
			var dot11 = _v1$3.dot( _v1$3 );
			var dot12 = _v1$3.dot( _v2$1 );
			var denom = ( dot00 * dot11 - dot01 * dot01 );
			if ( target === undefined ) {
				console.warn( 'THREE.Triangle: .getBarycoord() target is now required' );
				target = new Vector3();
			}
			// collinear or singular triangle
			if ( denom === 0 ) {
				// arbitrary location outside of triangle?
				// not sure if this is the best idea, maybe should be returning undefined
				return target.set( - 2, - 1, - 1 );
			}
			var invDenom = 1 / denom;
			var u = ( dot11 * dot02 - dot01 * dot12 ) * invDenom;
			var v = ( dot00 * dot12 - dot01 * dot02 ) * invDenom;
			// barycentric coordinates must always sum to 1
			return target.set( 1 - u - v, v, u );
		},
		containsPoint: function ( point, a, b, c ) {
			Triangle.getBarycoord( point, a, b, c, _v3 );
			return ( _v3.x >= 0 ) && ( _v3.y >= 0 ) && ( ( _v3.x + _v3.y ) = 0 && d4 = 0 && d3 = 0 && d5 = 0 && d6 = 0 && ( d5 - d6 ) >= 0 ) {
				_vbc.subVectors( c, b );
				w = ( d4 - d3 ) / ( ( d4 - d3 ) + ( d5 - d6 ) );
				// edge region of BC; barycentric coords (0, 1-w, w)
				return target.copy( b ).addScaledVector( _vbc, w ); // edge region of BC
			}
			// face region
			var denom = 1 / ( va + vb + vc );
			// u = va * denom
			v = vb * denom;
			w = vc * denom;
			return target.copy( a ).addScaledVector( _vab, v ).addScaledVector( _vac, w );
		},
		equals: function ( triangle ) {
			return triangle.a.equals( this.a ) && triangle.b.equals( this.b ) && triangle.c.equals( this.c );
		}
	} );
	/**
	 * @author mrdoob / http://mrdoob.com/
	 */
	var _colorKeywords = { 'aliceblue': 0xF0F8FF, 'antiquewhite': 0xFAEBD7, 'aqua': 0x00FFFF, 'aquamarine': 0x7FFFD4, 'azure': 0xF0FFFF,
		'beige': 0xF5F5DC, 'bisque': 0xFFE4C4, 'black': 0x000000, 'blanchedalmond': 0xFFEBCD, 'blue': 0x0000FF, 'blueviolet': 0x8A2BE2,
		'brown': 0xA52A2A, 'burlywood': 0xDEB887, 'cadetblue': 0x5F9EA0, 'chartreuse': 0x7FFF00, 'chocolate': 0xD2691E, 'coral': 0xFF7F50,
		'cornflowerblue': 0x6495ED, 'cornsilk': 0xFFF8DC, 'crimson': 0xDC143C, 'cyan': 0x00FFFF, 'darkblue': 0x00008B, 'darkcyan': 0x008B8B,
		'darkgoldenrod': 0xB8860B, 'darkgray': 0xA9A9A9, 'darkgreen': 0x006400, 'darkgrey': 0xA9A9A9, 'darkkhaki': 0xBDB76B, 'darkmagenta': 0x8B008B,
		'darkolivegreen': 0x556B2F, 'darkorange': 0xFF8C00, 'darkorchid': 0x9932CC, 'darkred': 0x8B0000, 'darksalmon': 0xE9967A, 'darkseagreen': 0x8FBC8F,
		'darkslateblue': 0x483D8B, 'darkslategray': 0x2F4F4F, 'darkslategrey': 0x2F4F4F, 'darkturquoise': 0x00CED1, 'darkviolet': 0x9400D3,
		'deeppink': 0xFF1493, 'deepskyblue': 0x00BFFF, 'dimgray': 0x696969, 'dimgrey': 0x696969, 'dodgerblue': 0x1E90FF, 'firebrick': 0xB22222,
		'floralwhite': 0xFFFAF0, 'forestgreen': 0x228B22, 'fuchsia': 0xFF00FF, 'gainsboro': 0xDCDCDC, 'ghostwhite': 0xF8F8FF, 'gold': 0xFFD700,
		'goldenrod': 0xDAA520, 'gray': 0x808080, 'green': 0x008000, 'greenyellow': 0xADFF2F, 'grey': 0x808080, 'honeydew': 0xF0FFF0, 'hotpink': 0xFF69B4,
		'indianred': 0xCD5C5C, 'indigo': 0x4B0082, 'ivory': 0xFFFFF0, 'khaki': 0xF0E68C, 'lavender': 0xE6E6FA, 'lavenderblush': 0xFFF0F5, 'lawngreen': 0x7CFC00,
		'lemonchiffon': 0xFFFACD, 'lightblue': 0xADD8E6, 'lightcoral': 0xF08080, 'lightcyan': 0xE0FFFF, 'lightgoldenrodyellow': 0xFAFAD2, 'lightgray': 0xD3D3D3,
		'lightgreen': 0x90EE90, 'lightgrey': 0xD3D3D3, 'lightpink': 0xFFB6C1, 'lightsalmon': 0xFFA07A, 'lightseagreen': 0x20B2AA, 'lightskyblue': 0x87CEFA,
		'lightslategray': 0x778899, 'lightslategrey': 0x778899, 'lightsteelblue': 0xB0C4DE, 'lightyellow': 0xFFFFE0, 'lime': 0x00FF00, 'limegreen': 0x32CD32,
		'linen': 0xFAF0E6, 'magenta': 0xFF00FF, 'maroon': 0x800000, 'mediumaquamarine': 0x66CDAA, 'mediumblue': 0x0000CD, 'mediumorchid': 0xBA55D3,
		'mediumpurple': 0x9370DB, 'mediumseagreen': 0x3CB371, 'mediumslateblue': 0x7B68EE, 'mediumspringgreen': 0x00FA9A, 'mediumturquoise': 0x48D1CC,
		'mediumvioletred': 0xC71585, 'midnightblue': 0x191970, 'mintcream': 0xF5FFFA, 'mistyrose': 0xFFE4E1, 'moccasin': 0xFFE4B5, 'navajowhite': 0xFFDEAD,
		'navy': 0x000080, 'oldlace': 0xFDF5E6, 'olive': 0x808000, 'olivedrab': 0x6B8E23, 'orange': 0xFFA500, 'orangered': 0xFF4500, 'orchid': 0xDA70D6,
		'palegoldenrod': 0xEEE8AA, 'palegreen': 0x98FB98, 'paleturquoise': 0xAFEEEE, 'palevioletred': 0xDB7093, 'papayawhip': 0xFFEFD5, 'peachpuff': 0xFFDAB9,
		'peru': 0xCD853F, 'pink': 0xFFC0CB, 'plum': 0xDDA0DD, 'powderblue': 0xB0E0E6, 'purple': 0x800080, 'rebeccapurple': 0x663399, 'red': 0xFF0000, 'rosybrown': 0xBC8F8F,
		'royalblue': 0x4169E1, 'saddlebrown': 0x8B4513, 'salmon': 0xFA8072, 'sandybrown': 0xF4A460, 'seagreen': 0x2E8B57, 'seashell': 0xFFF5EE,
		'sienna': 0xA0522D, 'silver': 0xC0C0C0, 'skyblue': 0x87CEEB, 'slateblue': 0x6A5ACD, 'slategray': 0x708090, 'slategrey': 0x708090, 'snow': 0xFFFAFA,
		'springgreen': 0x00FF7F, 'steelblue': 0x4682B4, 'tan': 0xD2B48C, 'teal': 0x008080, 'thistle': 0xD8BFD8, 'tomato': 0xFF6347, 'turquoise': 0x40E0D0,
		'violet': 0xEE82EE, 'wheat': 0xF5DEB3, 'white': 0xFFFFFF, 'whitesmoke': 0xF5F5F5, 'yellow': 0xFFFF00, 'yellowgreen': 0x9ACD32 };
	var _hslA = { h: 0, s: 0, l: 0 };
	var _hslB = { h: 0, s: 0, l: 0 };
	function Color( r, g, b ) {
		if ( g === undefined && b === undefined ) {
			// r is THREE.Color, hex or string
			return this.set( r );
		}
		return this.setRGB( r, g, b );
	}
	function hue2rgb( p, q, t ) {
		if ( t  1 ) { t -= 1; }
		if ( t > 16 & 255 ) / 255;
			this.g = ( hex >> 8 & 255 ) / 255;
			this.b = ( hex & 255 ) / 255;
			return this;
		},
		setRGB: function ( r, g, b ) {
			this.r = r;
			this.g = g;
			this.b = b;
			return this;
		},
		setHSL: function ( h, s, l ) {
			// h,s,l ranges are in 0.0 - 1.0
			h = MathUtils.euclideanModulo( h, 1 );
			s = MathUtils.clamp( s, 0, 1 );
			l = MathUtils.clamp( l, 0, 1 );
			if ( s === 0 ) {
				this.r = this.g = this.b = l;
			} else {
				var p = l  0 ) {
				return this.setColorName( style );
			}
			return this;
		},
		setColorName: function ( style ) {
			// color keywords
			var hex = _colorKeywords[ style ];
			if ( hex !== undefined ) {
				// red
				this.setHex( hex );
			} else {
				// unknown color
				console.warn( 'THREE.Color: Unknown color ' + style );
			}
			return this;
		},
		clone: function () {
			return new this.constructor( this.r, this.g, this.b );
		},
		copy: function ( color ) {
			this.r = color.r;
			this.g = color.g;
			this.b = color.b;
			return this;
		},
		copyGammaToLinear: function ( color, gammaFactor ) {
			if ( gammaFactor === undefined ) { gammaFactor = 2.0; }
			this.r = Math.pow( color.r, gammaFactor );
			this.g = Math.pow( color.g, gammaFactor );
			this.b = Math.pow( color.b, gammaFactor );
			return this;
		},
		copyLinearToGamma: function ( color, gammaFactor ) {
			if ( gammaFactor === undefined ) { gammaFactor = 2.0; }
			var safeInverse = ( gammaFactor > 0 ) ? ( 1.0 / gammaFactor ) : 1.0;
			this.r = Math.pow( color.r, safeInverse );
			this.g = Math.pow( color.g, safeInverse );
			this.b = Math.pow( color.b, safeInverse );
			return this;
		},
		convertGammaToLinear: function ( gammaFactor ) {
			this.copyGammaToLinear( this, gammaFactor );
			return this;
		},
		convertLinearToGamma: function ( gammaFactor ) {
			this.copyLinearToGamma( this, gammaFactor );
			return this;
		},
		copySRGBToLinear: function ( color ) {
			this.r = SRGBToLinear( color.r );
			this.g = SRGBToLinear( color.g );
			this.b = SRGBToLinear( color.b );
			return this;
		},
		copyLinearToSRGB: function ( color ) {
			this.r = LinearToSRGB( color.r );
			this.g = LinearToSRGB( color.g );
			this.b = LinearToSRGB( color.b );
			return this;
		},
		convertSRGBToLinear: function () {
			this.copySRGBToLinear( this );
			return this;
		},
		convertLinearToSRGB: function () {
			this.copyLinearToSRGB( this );
			return this;
		},
		getHex: function () {
			return ( this.r * 255 )  0 ) { data.alphaTest = this.alphaTest; }
			if ( this.premultipliedAlpha === true ) { data.premultipliedAlpha = this.premultipliedAlpha; }
			if ( this.wireframe === true ) { data.wireframe = this.wireframe; }
			if ( this.wireframeLinewidth > 1 ) { data.wireframeLinewidth = this.wireframeLinewidth; }
			if ( this.wireframeLinecap !== 'round' ) { data.wireframeLinecap = this.wireframeLinecap; }
			if ( this.wireframeLinejoin !== 'round' ) { data.wireframeLinejoin = this.wireframeLinejoin; }
			if ( this.morphTargets === true ) { data.morphTargets = true; }
			if ( this.morphNormals === true ) { data.morphNormals = true; }
			if ( this.skinning === true ) { data.skinning = true; }
			if ( this.visible === false ) { data.visible = false; }
			if ( this.toneMapped === false ) { data.toneMapped = false; }
			if ( JSON.stringify( this.userData ) !== '{}' ) { data.userData = this.userData; }
			// TODO: Copied from Object3D.toJSON
			function extractFromCache( cache ) {
				var values = [];
				for ( var key in cache ) {
					var data = cache[ key ];
					delete data.metadata;
					values.push( data );
				}
				return values;
			}
			if ( isRoot ) {
				var textures = extractFromCache( meta.textures );
				var images = extractFromCache( meta.images );
				if ( textures.length > 0 ) { data.textures = textures; }
				if ( images.length > 0 ) { data.images = images; }
			}
			return data;
		},
		clone: function () {
			return new this.constructor().copy( this );
		},
		copy: function ( source ) {
			this.name = source.name;
			this.fog = source.fog;
			this.blending = source.blending;
			this.side = source.side;
			this.flatShading = source.flatShading;
			this.vertexColors = source.vertexColors;
			this.opacity = source.opacity;
			this.transparent = source.transparent;
			this.blendSrc = source.blendSrc;
			this.blendDst = source.blendDst;
			this.blendEquation = source.blendEquation;
			this.blendSrcAlpha = source.blendSrcAlpha;
			this.blendDstAlpha = source.blendDstAlpha;
			this.blendEquationAlpha = source.blendEquationAlpha;
			this.depthFunc = source.depthFunc;
			this.depthTest = source.depthTest;
			this.depthWrite = source.depthWrite;
			this.stencilWriteMask = source.stencilWriteMask;
			this.stencilFunc = source.stencilFunc;
			this.stencilRef = source.stencilRef;
			this.stencilFuncMask = source.stencilFuncMask;
			this.stencilFail = source.stencilFail;
			this.stencilZFail = source.stencilZFail;
			this.stencilZPass = source.stencilZPass;
			this.stencilWrite = source.stencilWrite;
			var srcPlanes = source.clippingPlanes,
				dstPlanes = null;
			if ( srcPlanes !== null ) {
				var n = srcPlanes.length;
				dstPlanes = new Array( n );
				for ( var i = 0; i !== n; ++ i )
					{ dstPlanes[ i ] = srcPlanes[ i ].clone(); }
			}
			this.clippingPlanes = dstPlanes;
			this.clipIntersection = source.clipIntersection;
			this.clipShadows = source.clipShadows;
			this.shadowSide = source.shadowSide;
			this.colorWrite = source.colorWrite;
			this.precision = source.precision;
			this.polygonOffset = source.polygonOffset;
			this.polygonOffsetFactor = source.polygonOffsetFactor;
			this.polygonOffsetUnits = source.polygonOffsetUnits;
			this.dithering = source.dithering;
			this.alphaTest = source.alphaTest;
			this.premultipliedAlpha = source.premultipliedAlpha;
			this.visible = source.visible;
			this.toneMapped = source.toneMapped;
			this.userData = JSON.parse( JSON.stringify( source.userData ) );
			return this;
		},
		dispose: function () {
			this.dispatchEvent( { type: 'dispose' } );
		}
	} );
	Object.defineProperty( Material.prototype, 'needsUpdate', {
		set: function ( value ) {
			if ( value === true ) { this.version ++; }
		}
	} );
	/**
	 * @author mrdoob / http://mrdoob.com/
	 * @author alteredq / http://alteredqualia.com/
	 *
	 * parameters = {
	 *  color: ,
	 *  opacity: ,
	 *  map: new THREE.Texture(  ),
	 *
	 *  lightMap: new THREE.Texture(  ),
	 *  lightMapIntensity: 
	 *
	 *  aoMap: new THREE.Texture(  ),
	 *  aoMapIntensity: 
	 *
	 *  specularMap: new THREE.Texture(  ),
	 *
	 *  alphaMap: new THREE.Texture(  ),
	 *
	 *  envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
	 *  combine: THREE.Multiply,
	 *  reflectivity: ,
	 *  refractionRatio: ,
	 *
	 *  depthTest: ,
	 *  depthWrite: ,
	 *
	 *  wireframe: ,
	 *  wireframeLinewidth: ,
	 *
	 *  skinning: ,
	 *  morphTargets: 
	 * }
	 */
	function MeshBasicMaterial( parameters ) {
		Material.call( this );
		this.type = 'MeshBasicMaterial';
		this.color = new Color( 0xffffff ); // emissive
		this.map = null;
		this.lightMap = null;
		this.lightMapIntensity = 1.0;
		this.aoMap = null;
		this.aoMapIntensity = 1.0;
		this.specularMap = null;
		this.alphaMap = null;
		this.envMap = null;
		this.combine = MultiplyOperation;
		this.reflectivity = 1;
		this.refractionRatio = 0.98;
		this.wireframe = false;
		this.wireframeLinewidth = 1;
		this.wireframeLinecap = 'round';
		this.wireframeLinejoin = 'round';
		this.skinning = false;
		this.morphTargets = false;
		this.setValues( parameters );
	}
	MeshBasicMaterial.prototype = Object.create( Material.prototype );
	MeshBasicMaterial.prototype.constructor = MeshBasicMaterial;
	MeshBasicMaterial.prototype.isMeshBasicMaterial = true;
	MeshBasicMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.color.copy( source.color );
		this.map = source.map;
		this.lightMap = source.lightMap;
		this.lightMapIntensity = source.lightMapIntensity;
		this.aoMap = source.aoMap;
		this.aoMapIntensity = source.aoMapIntensity;
		this.specularMap = source.specularMap;
		this.alphaMap = source.alphaMap;
		this.envMap = source.envMap;
		this.combine = source.combine;
		this.reflectivity = source.reflectivity;
		this.refractionRatio = source.refractionRatio;
		this.wireframe = source.wireframe;
		this.wireframeLinewidth = source.wireframeLinewidth;
		this.wireframeLinecap = source.wireframeLinecap;
		this.wireframeLinejoin = source.wireframeLinejoin;
		this.skinning = source.skinning;
		this.morphTargets = source.morphTargets;
		return this;
	};
	/**
	 * @author mrdoob / http://mrdoob.com/
	 */
	var _vector$3 = new Vector3();
	function BufferAttribute( array, itemSize, normalized ) {
		if ( Array.isArray( array ) ) {
			throw new TypeError( 'THREE.BufferAttribute: array should be a Typed Array.' );
		}
		this.name = '';
		this.array = array;
		this.itemSize = itemSize;
		this.count = array !== undefined ? array.length / itemSize : 0;
		this.normalized = normalized === true;
		this.usage = StaticDrawUsage;
		this.updateRange = { offset: 0, count: - 1 };
		this.version = 0;
	}
	Object.defineProperty( BufferAttribute.prototype, 'needsUpdate', {
		set: function ( value ) {
			if ( value === true ) { this.version ++; }
		}
	} );
	Object.assign( BufferAttribute.prototype, {
		isBufferAttribute: true,
		onUploadCallback: function () {},
		setUsage: function ( value ) {
			this.usage = value;
			return this;
		},
		copy: function ( source ) {
			this.name = source.name;
			this.array = new source.array.constructor( source.array );
			this.itemSize = source.itemSize;
			this.count = source.count;
			this.normalized = source.normalized;
			this.usage = source.usage;
			return this;
		},
		copyAt: function ( index1, attribute, index2 ) {
			index1 *= this.itemSize;
			index2 *= attribute.itemSize;
			for ( var i = 0, l = this.itemSize; i  0;
			var hasFaceVertexUv2 = faceVertexUvs[ 1 ] && faceVertexUvs[ 1 ].length > 0;
			// morphs
			var morphTargets = geometry.morphTargets;
			var morphTargetsLength = morphTargets.length;
			var morphTargetsPosition;
			if ( morphTargetsLength > 0 ) {
				morphTargetsPosition = [];
				for ( var i = 0; i  0 ) {
				morphTargetsNormal = [];
				for ( var i = 0; i  0 && faces.length === 0 ) {
				console.error( 'THREE.DirectGeometry: Faceless geometries are not supported.' );
			}
			for ( var i = 0; i  max ) { max = array[ i ]; }
		}
		return max;
	}
	/**
	 * @author alteredq / http://alteredqualia.com/
	 * @author mrdoob / http://mrdoob.com/
	 */
	var _bufferGeometryId = 1; // BufferGeometry uses odd numbers as Id
	var _m1$2 = new Matrix4();
	var _obj = new Object3D();
	var _offset = new Vector3();
	var _box$2 = new Box3();
	var _boxMorphTargets = new Box3();
	var _vector$4 = new Vector3();
	function BufferGeometry() {
		Object.defineProperty( this, 'id', { value: _bufferGeometryId += 2 } );
		this.uuid = MathUtils.generateUUID();
		this.name = '';
		this.type = 'BufferGeometry';
		this.index = null;
		this.attributes = {};
		this.morphAttributes = {};
		this.morphTargetsRelative = false;
		this.groups = [];
		this.boundingBox = null;
		this.boundingSphere = null;
		this.drawRange = { start: 0, count: Infinity };
		this.userData = {};
	}
	BufferGeometry.prototype = Object.assign( Object.create( EventDispatcher.prototype ), {
		constructor: BufferGeometry,
		isBufferGeometry: true,
		getIndex: function () {
			return this.index;
		},
		setIndex: function ( index ) {
			if ( Array.isArray( index ) ) {
				this.index = new ( arrayMax( index ) > 65535 ? Uint32BufferAttribute : Uint16BufferAttribute )( index, 1 );
			} else {
				this.index = index;
			}
		},
		getAttribute: function ( name ) {
			return this.attributes[ name ];
		},
		setAttribute: function ( name, attribute ) {
			this.attributes[ name ] = attribute;
			return this;
		},
		deleteAttribute: function ( name ) {
			delete this.attributes[ name ];
			return this;
		},
		addGroup: function ( start, count, materialIndex ) {
			this.groups.push( {
				start: start,
				count: count,
				materialIndex: materialIndex !== undefined ? materialIndex : 0
			} );
		},
		clearGroups: function () {
			this.groups = [];
		},
		setDrawRange: function ( start, count ) {
			this.drawRange.start = start;
			this.drawRange.count = count;
		},
		applyMatrix4: function ( matrix ) {
			var position = this.attributes.position;
			if ( position !== undefined ) {
				position.applyMatrix4( matrix );
				position.needsUpdate = true;
			}
			var normal = this.attributes.normal;
			if ( normal !== undefined ) {
				var normalMatrix = new Matrix3().getNormalMatrix( matrix );
				normal.applyNormalMatrix( normalMatrix );
				normal.needsUpdate = true;
			}
			var tangent = this.attributes.tangent;
			if ( tangent !== undefined ) {
				tangent.transformDirection( matrix );
				tangent.needsUpdate = true;
			}
			if ( this.boundingBox !== null ) {
				this.computeBoundingBox();
			}
			if ( this.boundingSphere !== null ) {
				this.computeBoundingSphere();
			}
			return this;
		},
		rotateX: function ( angle ) {
			// rotate geometry around world x-axis
			_m1$2.makeRotationX( angle );
			this.applyMatrix4( _m1$2 );
			return this;
		},
		rotateY: function ( angle ) {
			// rotate geometry around world y-axis
			_m1$2.makeRotationY( angle );
			this.applyMatrix4( _m1$2 );
			return this;
		},
		rotateZ: function ( angle ) {
			// rotate geometry around world z-axis
			_m1$2.makeRotationZ( angle );
			this.applyMatrix4( _m1$2 );
			return this;
		},
		translate: function ( x, y, z ) {
			// translate geometry
			_m1$2.makeTranslation( x, y, z );
			this.applyMatrix4( _m1$2 );
			return this;
		},
		scale: function ( x, y, z ) {
			// scale geometry
			_m1$2.makeScale( x, y, z );
			this.applyMatrix4( _m1$2 );
			return this;
		},
		lookAt: function ( vector ) {
			_obj.lookAt( vector );
			_obj.updateMatrix();
			this.applyMatrix4( _obj.matrix );
			return this;
		},
		center: function () {
			this.computeBoundingBox();
			this.boundingBox.getCenter( _offset ).negate();
			this.translate( _offset.x, _offset.y, _offset.z );
			return this;
		},
		setFromObject: function ( object ) {
			// console.log( 'THREE.BufferGeometry.setFromObject(). Converting', object, this );
			var geometry = object.geometry;
			if ( object.isPoints || object.isLine ) {
				var positions = new Float32BufferAttribute( geometry.vertices.length * 3, 3 );
				var colors = new Float32BufferAttribute( geometry.colors.length * 3, 3 );
				this.setAttribute( 'position', positions.copyVector3sArray( geometry.vertices ) );
				this.setAttribute( 'color', colors.copyColorsArray( geometry.colors ) );
				if ( geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length ) {
					var lineDistances = new Float32BufferAttribute( geometry.lineDistances.length, 1 );
					this.setAttribute( 'lineDistance', lineDistances.copyArray( geometry.lineDistances ) );
				}
				if ( geometry.boundingSphere !== null ) {
					this.boundingSphere = geometry.boundingSphere.clone();
				}
				if ( geometry.boundingBox !== null ) {
					this.boundingBox = geometry.boundingBox.clone();
				}
			} else if ( object.isMesh ) {
				if ( geometry && geometry.isGeometry ) {
					this.fromGeometry( geometry );
				}
			}
			return this;
		},
		setFromPoints: function ( points ) {
			var position = [];
			for ( var i = 0, l = points.length; i  0 ) {
				var normals = new Float32Array( geometry.normals.length * 3 );
				this.setAttribute( 'normal', new BufferAttribute( normals, 3 ).copyVector3sArray( geometry.normals ) );
			}
			if ( geometry.colors.length > 0 ) {
				var colors = new Float32Array( geometry.colors.length * 3 );
				this.setAttribute( 'color', new BufferAttribute( colors, 3 ).copyColorsArray( geometry.colors ) );
			}
			if ( geometry.uvs.length > 0 ) {
				var uvs = new Float32Array( geometry.uvs.length * 2 );
				this.setAttribute( 'uv', new BufferAttribute( uvs, 2 ).copyVector2sArray( geometry.uvs ) );
			}
			if ( geometry.uvs2.length > 0 ) {
				var uvs2 = new Float32Array( geometry.uvs2.length * 2 );
				this.setAttribute( 'uv2', new BufferAttribute( uvs2, 2 ).copyVector2sArray( geometry.uvs2 ) );
			}
			// groups
			this.groups = geometry.groups;
			// morphs
			for ( var name in geometry.morphTargets ) {
				var array = [];
				var morphTargets = geometry.morphTargets[ name ];
				for ( var i = 0, l = morphTargets.length; i  0 ) {
				var skinIndices = new Float32BufferAttribute( geometry.skinIndices.length * 4, 4 );
				this.setAttribute( 'skinIndex', skinIndices.copyVector4sArray( geometry.skinIndices ) );
			}
			if ( geometry.skinWeights.length > 0 ) {
				var skinWeights = new Float32BufferAttribute( geometry.skinWeights.length * 4, 4 );
				this.setAttribute( 'skinWeight', skinWeights.copyVector4sArray( geometry.skinWeights ) );
			}
			//
			if ( geometry.boundingSphere !== null ) {
				this.boundingSphere = geometry.boundingSphere.clone();
			}
			if ( geometry.boundingBox !== null ) {
				this.boundingBox = geometry.boundingBox.clone();
			}
			return this;
		},
		computeBoundingBox: function () {
			if ( this.boundingBox === null ) {
				this.boundingBox = new Box3();
			}
			var position = this.attributes.position;
			var morphAttributesPosition = this.morphAttributes.position;
			if ( position !== undefined ) {
				this.boundingBox.setFromBufferAttribute( position );
				// process morph attributes if present
				if ( morphAttributesPosition ) {
					for ( var i = 0, il = morphAttributesPosition.length; i  0 ) { data.userData = this.userData; }
			if ( this.parameters !== undefined ) {
				var parameters = this.parameters;
				for ( var key in parameters ) {
					if ( parameters[ key ] !== undefined ) { data[ key ] = parameters[ key ]; }
				}
				return data;
			}
			data.data = { attributes: {} };
			var index = this.index;
			if ( index !== null ) {
				data.data.index = {
					type: index.array.constructor.name,
					array: Array.prototype.slice.call( index.array )
				};
			}
			var attributes = this.attributes;
			for ( var key in attributes ) {
				var attribute = attributes[ key ];
				var attributeData = attribute.toJSON();
				if ( attribute.name !== '' ) { attributeData.name = attribute.name; }
				data.data.attributes[ key ] = attributeData;
			}
			var morphAttributes = {};
			var hasMorphAttributes = false;
			for ( var key in this.morphAttributes ) {
				var attributeArray = this.morphAttributes[ key ];
				var array = [];
				for ( var i = 0, il = attributeArray.length; i  0 ) {
					morphAttributes[ key ] = array;
					hasMorphAttributes = true;
				}
			}
			if ( hasMorphAttributes ) {
				data.data.morphAttributes = morphAttributes;
				data.data.morphTargetsRelative = this.morphTargetsRelative;
			}
			var groups = this.groups;
			if ( groups.length > 0 ) {
				data.data.groups = JSON.parse( JSON.stringify( groups ) );
			}
			var boundingSphere = this.boundingSphere;
			if ( boundingSphere !== null ) {
				data.data.boundingSphere = {
					center: boundingSphere.center.toArray(),
					radius: boundingSphere.radius
				};
			}
			return data;
		},
		clone: function () {
			/*
			 // Handle primitives
			 var parameters = this.parameters;
			 if ( parameters !== undefined ) {
			 var values = [];
			 for ( var key in parameters ) {
			 values.push( parameters[ key ] );
			 }
			 var geometry = Object.create( this.constructor.prototype );
			 this.constructor.apply( geometry, values );
			 return geometry;
			 }
			 return new this.constructor().copy( this );
			 */
			return new BufferGeometry().copy( this );
		},
		copy: function ( source ) {
			var name, i, l;
			// reset
			this.index = null;
			this.attributes = {};
			this.morphAttributes = {};
			this.groups = [];
			this.boundingBox = null;
			this.boundingSphere = null;
			// name
			this.name = source.name;
			// index
			var index = source.index;
			if ( index !== null ) {
				this.setIndex( index.clone() );
			}
			// attributes
			var attributes = source.attributes;
			for ( name in attributes ) {
				var attribute = attributes[ name ];
				this.setAttribute( name, attribute.clone() );
			}
			// morph attributes
			var morphAttributes = source.morphAttributes;
			for ( name in morphAttributes ) {
				var array = [];
				var morphAttribute = morphAttributes[ name ]; // morphAttribute: array of Float32BufferAttributes
				for ( i = 0, l = morphAttribute.length; i  0 ) {
					var morphAttribute = morphAttributes[ keys[ 0 ] ];
					if ( morphAttribute !== undefined ) {
						this.morphTargetInfluences = [];
						this.morphTargetDictionary = {};
						for ( m = 0, ml = morphAttribute.length; m  0 ) {
					console.error( 'THREE.Mesh.updateMorphTargets() no longer supports THREE.Geometry. Use THREE.BufferGeometry instead.' );
				}
			}
		},
		raycast: function ( raycaster, intersects ) {
			var geometry = this.geometry;
			var material = this.material;
			var matrixWorld = this.matrixWorld;
			if ( material === undefined ) { return; }
			// Checking boundingSphere distance to ray
			if ( geometry.boundingSphere === null ) { geometry.computeBoundingSphere(); }
			_sphere.copy( geometry.boundingSphere );
			_sphere.applyMatrix4( matrixWorld );
			if ( raycaster.ray.intersectsSphere( _sphere ) === false ) { return; }
			//
			_inverseMatrix.getInverse( matrixWorld );
			_ray.copy( raycaster.ray ).applyMatrix4( _inverseMatrix );
			// Check boundingBox before continuing
			if ( geometry.boundingBox !== null ) {
				if ( _ray.intersectsBox( geometry.boundingBox ) === false ) { return; }
			}
			var intersection;
			if ( geometry.isBufferGeometry ) {
				var a, b, c;
				var index = geometry.index;
				var position = geometry.attributes.position;
				var morphPosition = geometry.morphAttributes.position;
				var morphTargetsRelative = geometry.morphTargetsRelative;
				var uv = geometry.attributes.uv;
				var uv2 = geometry.attributes.uv2;
				var groups = geometry.groups;
				var drawRange = geometry.drawRange;
				var i, j, il, jl;
				var group, groupMaterial;
				var start, end;
				if ( index !== null ) {
					// indexed buffer geometry
					if ( Array.isArray( material ) ) {
						for ( i = 0, il = groups.length; i  0 ) { uvs = faceVertexUvs; }
				for ( var f = 0, fl = faces.length; f  raycaster.far ) { return null; }
		return {
			distance: distance,
			point: _intersectionPointWorld.clone(),
			object: object
		};
	}
	function checkBufferGeometryIntersection( object, material, raycaster, ray, position, morphPosition, morphTargetsRelative, uv, uv2, a, b, c ) {
		_vA.fromBufferAttribute( position, a );
		_vB.fromBufferAttribute( position, b );
		_vC.fromBufferAttribute( position, c );
		var morphInfluences = object.morphTargetInfluences;
		if ( material.morphTargets && morphPosition && morphInfluences ) {
			_morphA.set( 0, 0, 0 );
			_morphB.set( 0, 0, 0 );
			_morphC.set( 0, 0, 0 );
			for ( var i = 0, il = morphPosition.length; i  0 ) {
				for ( var i = 0; i  0 ) {
				this.normalsNeedUpdate = true;
			}
		},
		computeFlatVertexNormals: function () {
			var f, fl, face;
			this.computeFaceNormals();
			for ( f = 0, fl = this.faces.length; f  0 ) {
				this.normalsNeedUpdate = true;
			}
		},
		computeMorphNormals: function () {
			var i, il, f, fl, face;
			// save original normals
			// - create temp variables on first access
			//   otherwise just copy (for faster repeated calls)
			for ( f = 0, fl = this.faces.length; f = 0; i -- ) {
				var idx = faceIndicesToRemove[ i ];
				this.faces.splice( idx, 1 );
				for ( j = 0, jl = this.faceVertexUvs.length; j  0;
				var hasFaceVertexNormal = face.vertexNormals.length > 0;
				var hasFaceColor = face.color.r !== 1 || face.color.g !== 1 || face.color.b !== 1;
				var hasFaceVertexColor = face.vertexColors.length > 0;
				var faceType = 0;
				faceType = setBit( faceType, 0, 0 ); // isQuad
				faceType = setBit( faceType, 1, hasMaterial );
				faceType = setBit( faceType, 2, hasFaceUv );
				faceType = setBit( faceType, 3, hasFaceVertexUv );
				faceType = setBit( faceType, 4, hasFaceNormal );
				faceType = setBit( faceType, 5, hasFaceVertexNormal );
				faceType = setBit( faceType, 6, hasFaceColor );
				faceType = setBit( faceType, 7, hasFaceVertexColor );
				faces.push( faceType );
				faces.push( face.a, face.b, face.c );
				faces.push( face.materialIndex );
				if ( hasFaceVertexUv ) {
					var faceVertexUvs = this.faceVertexUvs[ 0 ][ i ];
					faces.push(
						getUvIndex( faceVertexUvs[ 0 ] ),
						getUvIndex( faceVertexUvs[ 1 ] ),
						getUvIndex( faceVertexUvs[ 2 ] )
					);
				}
				if ( hasFaceNormal ) {
					faces.push( getNormalIndex( face.normal ) );
				}
				if ( hasFaceVertexNormal ) {
					var vertexNormals = face.vertexNormals;
					faces.push(
						getNormalIndex( vertexNormals[ 0 ] ),
						getNormalIndex( vertexNormals[ 1 ] ),
						getNormalIndex( vertexNormals[ 2 ] )
					);
				}
				if ( hasFaceColor ) {
					faces.push( getColorIndex( face.color ) );
				}
				if ( hasFaceVertexColor ) {
					var vertexColors = face.vertexColors;
					faces.push(
						getColorIndex( vertexColors[ 0 ] ),
						getColorIndex( vertexColors[ 1 ] ),
						getColorIndex( vertexColors[ 2 ] )
					);
				}
			}
			function setBit( value, position, enabled ) {
				return enabled ? value | ( 1  0 ) { data.data.colors = colors; }
			if ( uvs.length > 0 ) { data.data.uvs = [ uvs ]; } // temporal backward compatibility
			data.data.faces = faces;
			return data;
		},
		clone: function () {
			/*
			 // Handle primitives
			 var parameters = this.parameters;
			 if ( parameters !== undefined ) {
			 var values = [];
			 for ( var key in parameters ) {
			 values.push( parameters[ key ] );
			 }
			 var geometry = Object.create( this.constructor.prototype );
			 this.constructor.apply( geometry, values );
			 return geometry;
			 }
			 return new this.constructor().copy( this );
			 */
			return new Geometry().copy( this );
		},
		copy: function ( source ) {
			var i, il, j, jl, k, kl;
			// reset
			this.vertices = [];
			this.colors = [];
			this.faces = [];
			this.faceVertexUvs = [[]];
			this.morphTargets = [];
			this.morphNormals = [];
			this.skinWeights = [];
			this.skinIndices = [];
			this.lineDistances = [];
			this.boundingBox = null;
			this.boundingSphere = null;
			// name
			this.name = source.name;
			// vertices
			var vertices = source.vertices;
			for ( i = 0, il = vertices.length; i  0 ? 1 : - 1;
						// now apply vector to normal buffer
						normals.push( vector.x, vector.y, vector.z );
						// uvs
						uvs.push( ix / gridX );
						uvs.push( 1 - ( iy / gridY ) );
						// counters
						vertexCounter += 1;
					}
				}
				// indices
				// 1. you need three indices to draw a single face
				// 2. a single segment consists of two faces
				// 3. so we need to generate six (2*3) indices per segment
				for ( iy = 0; iy ,
	 *  vertexShader: ,
	 *
	 *  wireframe: ,
	 *  wireframeLinewidth: ,
	 *
	 *  lights: ,
	 *
	 *  skinning: ,
	 *  morphTargets: ,
	 *  morphNormals: 
	 * }
	 */
	function ShaderMaterial( parameters ) {
		Material.call( this );
		this.type = 'ShaderMaterial';
		this.defines = {};
		this.uniforms = {};
		this.vertexShader = default_vertex;
		this.fragmentShader = default_fragment;
		this.linewidth = 1;
		this.wireframe = false;
		this.wireframeLinewidth = 1;
		this.fog = false; // set to use scene fog
		this.lights = false; // set to use scene lights
		this.clipping = false; // set to use user-defined clipping planes
		this.skinning = false; // set to use skinning attribute streams
		this.morphTargets = false; // set to use morph targets
		this.morphNormals = false; // set to use morph normals
		this.extensions = {
			derivatives: false, // set to use derivatives
			fragDepth: false, // set to use fragment depth values
			drawBuffers: false, // set to use draw buffers
			shaderTextureLOD: false // set to use shader texture LOD
		};
		// When rendered geometry doesn't include these attributes but the material does,
		// use these default values in WebGL. This avoids errors when buffer data is missing.
		this.defaultAttributeValues = {
			'color': [ 1, 1, 1 ],
			'uv': [ 0, 0 ],
			'uv2': [ 0, 0 ]
		};
		this.index0AttributeName = undefined;
		this.uniformsNeedUpdate = false;
		if ( parameters !== undefined ) {
			if ( parameters.attributes !== undefined ) {
				console.error( 'THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead.' );
			}
			this.setValues( parameters );
		}
	}
	ShaderMaterial.prototype = Object.create( Material.prototype );
	ShaderMaterial.prototype.constructor = ShaderMaterial;
	ShaderMaterial.prototype.isShaderMaterial = true;
	ShaderMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.fragmentShader = source.fragmentShader;
		this.vertexShader = source.vertexShader;
		this.uniforms = cloneUniforms( source.uniforms );
		this.defines = Object.assign( {}, source.defines );
		this.wireframe = source.wireframe;
		this.wireframeLinewidth = source.wireframeLinewidth;
		this.lights = source.lights;
		this.clipping = source.clipping;
		this.skinning = source.skinning;
		this.morphTargets = source.morphTargets;
		this.morphNormals = source.morphNormals;
		this.extensions = source.extensions;
		return this;
	};
	ShaderMaterial.prototype.toJSON = function ( meta ) {
		var data = Material.prototype.toJSON.call( this, meta );
		data.uniforms = {};
		for ( var name in this.uniforms ) {
			var uniform = this.uniforms[ name ];
			var value = uniform.value;
			if ( value && value.isTexture ) {
				data.uniforms[ name ] = {
					type: 't',
					value: value.toJSON( meta ).uuid
				};
			} else if ( value && value.isColor ) {
				data.uniforms[ name ] = {
					type: 'c',
					value: value.getHex()
				};
			} else if ( value && value.isVector2 ) {
				data.uniforms[ name ] = {
					type: 'v2',
					value: value.toArray()
				};
			} else if ( value && value.isVector3 ) {
				data.uniforms[ name ] = {
					type: 'v3',
					value: value.toArray()
				};
			} else if ( value && value.isVector4 ) {
				data.uniforms[ name ] = {
					type: 'v4',
					value: value.toArray()
				};
			} else if ( value && value.isMatrix3 ) {
				data.uniforms[ name ] = {
					type: 'm3',
					value: value.toArray()
				};
			} else if ( value && value.isMatrix4 ) {
				data.uniforms[ name ] = {
					type: 'm4',
					value: value.toArray()
				};
			} else {
				data.uniforms[ name ] = {
					value: value
				};
				// note: the array variants v2v, v3v, v4v, m4v and tv are not supported so far
			}
		}
		if ( Object.keys( this.defines ).length > 0 ) { data.defines = this.defines; }
		data.vertexShader = this.vertexShader;
		data.fragmentShader = this.fragmentShader;
		var extensions = {};
		for ( var key in this.extensions ) {
			if ( this.extensions[ key ] === true ) { extensions[ key ] = true; }
		}
		if ( Object.keys( extensions ).length > 0 ) { data.extensions = extensions; }
		return data;
	};
	/**
	 * @author mrdoob / http://mrdoob.com/
	 * @author mikael emtinger / http://gomo.se/
	 * @author WestLangley / http://github.com/WestLangley
	*/
	function Camera() {
		Object3D.call( this );
		this.type = 'Camera';
		this.matrixWorldInverse = new Matrix4();
		this.projectionMatrix = new Matrix4();
		this.projectionMatrixInverse = new Matrix4();
	}
	Camera.prototype = Object.assign( Object.create( Object3D.prototype ), {
		constructor: Camera,
		isCamera: true,
		copy: function ( source, recursive ) {
			Object3D.prototype.copy.call( this, source, recursive );
			this.matrixWorldInverse.copy( source.matrixWorldInverse );
			this.projectionMatrix.copy( source.projectionMatrix );
			this.projectionMatrixInverse.copy( source.projectionMatrixInverse );
			return this;
		},
		getWorldDirection: function ( target ) {
			if ( target === undefined ) {
				console.warn( 'THREE.Camera: .getWorldDirection() target is now required' );
				target = new Vector3();
			}
			this.updateMatrixWorld( true );
			var e = this.matrixWorld.elements;
			return target.set( - e[ 8 ], - e[ 9 ], - e[ 10 ] ).normalize();
		},
		updateMatrixWorld: function ( force ) {
			Object3D.prototype.updateMatrixWorld.call( this, force );
			this.matrixWorldInverse.getInverse( this.matrixWorld );
		},
		updateWorldMatrix: function ( updateParents, updateChildren ) {
			Object3D.prototype.updateWorldMatrix.call( this, updateParents, updateChildren );
			this.matrixWorldInverse.getInverse( this.matrixWorld );
		},
		clone: function () {
			return new this.constructor().copy( this );
		}
	} );
	/**
	 * @author mrdoob / http://mrdoob.com/
	 * @author greggman / http://games.greggman.com/
	 * @author zz85 / http://www.lab4games.net/zz85/blog
	 * @author tschw
	 */
	function PerspectiveCamera( fov, aspect, near, far ) {
		Camera.call( this );
		this.type = 'PerspectiveCamera';
		this.fov = fov !== undefined ? fov : 50;
		this.zoom = 1;
		this.near = near !== undefined ? near : 0.1;
		this.far = far !== undefined ? far : 2000;
		this.focus = 10;
		this.aspect = aspect !== undefined ? aspect : 1;
		this.view = null;
		this.filmGauge = 35;	// width of the film (default in millimeters)
		this.filmOffset = 0;	// horizontal film offset (same unit as gauge)
		this.updateProjectionMatrix();
	}
	PerspectiveCamera.prototype = Object.assign( Object.create( Camera.prototype ), {
		constructor: PerspectiveCamera,
		isPerspectiveCamera: true,
		copy: function ( source, recursive ) {
			Camera.prototype.copy.call( this, source, recursive );
			this.fov = source.fov;
			this.zoom = source.zoom;
			this.near = source.near;
			this.far = source.far;
			this.focus = source.focus;
			this.aspect = source.aspect;
			this.view = source.view === null ? null : Object.assign( {}, source.view );
			this.filmGauge = source.filmGauge;
			this.filmOffset = source.filmOffset;
			return this;
		},
		/**
		 * Sets the FOV by focal length in respect to the current .filmGauge.
		 *
		 * The default film gauge is 35, so that the focal length can be specified for
		 * a 35mm (full frame) camera.
		 *
		 * Values for focal length and film gauge must have the same unit.
		 */
		setFocalLength: function ( focalLength ) {
			// see http://www.bobatkins.com/photography/technical/field_of_view.html
			var vExtentSlope = 0.5 * this.getFilmHeight() / focalLength;
			this.fov = MathUtils.RAD2DEG * 2 * Math.atan( vExtentSlope );
			this.updateProjectionMatrix();
		},
		/**
		 * Calculates the focal length from the current .fov and .filmGauge.
		 */
		getFocalLength: function () {
			var vExtentSlope = Math.tan( MathUtils.DEG2RAD * 0.5 * this.fov );
			return 0.5 * this.getFilmHeight() / vExtentSlope;
		},
		getEffectiveFOV: function () {
			return MathUtils.RAD2DEG * 2 * Math.atan(
				Math.tan( MathUtils.DEG2RAD * 0.5 * this.fov ) / this.zoom );
		},
		getFilmWidth: function () {
			// film not completely covered in portrait format (aspect  1)
			return this.filmGauge / Math.max( this.aspect, 1 );
		},
		/**
		 * Sets an offset in a larger frustum. This is useful for multi-window or
		 * multi-monitor/multi-machine setups.
		 *
		 * For example, if you have 3x2 monitors and each monitor is 1920x1080 and
		 * the monitors are in grid like this
		 *
		 *   +---+---+---+
		 *   | A | B | C |
		 *   +---+---+---+
		 *   | D | E | F |
		 *   +---+---+---+
		 *
		 * then for each monitor you would call it like this
		 *
		 *   var w = 1920;
		 *   var h = 1080;
		 *   var fullWidth = w * 3;
		 *   var fullHeight = h * 2;
		 *
		 *   --A--
		 *   camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );
		 *   --B--
		 *   camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );
		 *   --C--
		 *   camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );
		 *   --D--
		 *   camera.setViewOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );
		 *   --E--
		 *   camera.setViewOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );
		 *   --F--
		 *   camera.setViewOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );
		 *
		 *   Note there is no reason monitors have to be the same size or in a grid.
		 */
		setViewOffset: function ( fullWidth, fullHeight, x, y, width, height ) {
			this.aspect = fullWidth / fullHeight;
			if ( this.view === null ) {
				this.view = {
					enabled: true,
					fullWidth: 1,
					fullHeight: 1,
					offsetX: 0,
					offsetY: 0,
					width: 1,
					height: 1
				};
			}
			this.view.enabled = true;
			this.view.fullWidth = fullWidth;
			this.view.fullHeight = fullHeight;
			this.view.offsetX = x;
			this.view.offsetY = y;
			this.view.width = width;
			this.view.height = height;
			this.updateProjectionMatrix();
		},
		clearViewOffset: function () {
			if ( this.view !== null ) {
				this.view.enabled = false;
			}
			this.updateProjectionMatrix();
		},
		updateProjectionMatrix: function () {
			var near = this.near,
				top = near * Math.tan( MathUtils.DEG2RAD * 0.5 * this.fov ) / this.zoom,
				height = 2 * top,
				width = this.aspect * height,
				left = - 0.5 * width,
				view = this.view;
			if ( this.view !== null && this.view.enabled ) {
				var fullWidth = view.fullWidth,
					fullHeight = view.fullHeight;
				left += view.offsetX * width / fullWidth;
				top -= view.offsetY * height / fullHeight;
				width *= view.width / fullWidth;
				height *= view.height / fullHeight;
			}
			var skew = this.filmOffset;
			if ( skew !== 0 ) { left += near * skew / this.getFilmWidth(); }
			this.projectionMatrix.makePerspective( left, left + width, top, top - height, near, this.far );
			this.projectionMatrixInverse.getInverse( this.projectionMatrix );
		},
		toJSON: function ( meta ) {
			var data = Object3D.prototype.toJSON.call( this, meta );
			data.object.fov = this.fov;
			data.object.zoom = this.zoom;
			data.object.near = this.near;
			data.object.far = this.far;
			data.object.focus = this.focus;
			data.object.aspect = this.aspect;
			if ( this.view !== null ) { data.object.view = Object.assign( {}, this.view ); }
			data.object.filmGauge = this.filmGauge;
			data.object.filmOffset = this.filmOffset;
			return data;
		}
	} );
	/**
	 * Camera for rendering cube maps
	 *	- renders scene into axis-aligned cube
	 *
	 * @author alteredq / http://alteredqualia.com/
	 */
	var fov = 90, aspect = 1;
	function CubeCamera( near, far, cubeResolution, options ) {
		Object3D.call( this );
		this.type = 'CubeCamera';
		var cameraPX = new PerspectiveCamera( fov, aspect, near, far );
		cameraPX.up.set( 0, - 1, 0 );
		cameraPX.lookAt( new Vector3( 1, 0, 0 ) );
		this.add( cameraPX );
		var cameraNX = new PerspectiveCamera( fov, aspect, near, far );
		cameraNX.up.set( 0, - 1, 0 );
		cameraNX.lookAt( new Vector3( - 1, 0, 0 ) );
		this.add( cameraNX );
		var cameraPY = new PerspectiveCamera( fov, aspect, near, far );
		cameraPY.up.set( 0, 0, 1 );
		cameraPY.lookAt( new Vector3( 0, 1, 0 ) );
		this.add( cameraPY );
		var cameraNY = new PerspectiveCamera( fov, aspect, near, far );
		cameraNY.up.set( 0, 0, - 1 );
		cameraNY.lookAt( new Vector3( 0, - 1, 0 ) );
		this.add( cameraNY );
		var cameraPZ = new PerspectiveCamera( fov, aspect, near, far );
		cameraPZ.up.set( 0, - 1, 0 );
		cameraPZ.lookAt( new Vector3( 0, 0, 1 ) );
		this.add( cameraPZ );
		var cameraNZ = new PerspectiveCamera( fov, aspect, near, far );
		cameraNZ.up.set( 0, - 1, 0 );
		cameraNZ.lookAt( new Vector3( 0, 0, - 1 ) );
		this.add( cameraNZ );
		options = options || { format: RGBFormat, magFilter: LinearFilter, minFilter: LinearFilter };
		this.renderTarget = new WebGLCubeRenderTarget( cubeResolution, options );
		this.renderTarget.texture.name = "CubeCamera";
		this.update = function ( renderer, scene ) {
			if ( this.parent === null ) { this.updateMatrixWorld(); }
			var currentRenderTarget = renderer.getRenderTarget();
			var renderTarget = this.renderTarget;
			var generateMipmaps = renderTarget.texture.generateMipmaps;
			renderTarget.texture.generateMipmaps = false;
			renderer.setRenderTarget( renderTarget, 0 );
			renderer.render( scene, cameraPX );
			renderer.setRenderTarget( renderTarget, 1 );
			renderer.render( scene, cameraNX );
			renderer.setRenderTarget( renderTarget, 2 );
			renderer.render( scene, cameraPY );
			renderer.setRenderTarget( renderTarget, 3 );
			renderer.render( scene, cameraNY );
			renderer.setRenderTarget( renderTarget, 4 );
			renderer.render( scene, cameraPZ );
			renderTarget.texture.generateMipmaps = generateMipmaps;
			renderer.setRenderTarget( renderTarget, 5 );
			renderer.render( scene, cameraNZ );
			renderer.setRenderTarget( currentRenderTarget );
		};
		this.clear = function ( renderer, color, depth, stencil ) {
			var currentRenderTarget = renderer.getRenderTarget();
			var renderTarget = this.renderTarget;
			for ( var i = 0; i ",
				"	#include ",
				"}"
			].join( '\n' ),
			fragmentShader: [
				"uniform sampler2D tEquirect;",
				"varying vec3 vWorldDirection;",
				"#define RECIPROCAL_PI 0.31830988618",
				"#define RECIPROCAL_PI2 0.15915494",
				"void main() {",
				"	vec3 direction = normalize( vWorldDirection );",
				"	vec2 sampleUV;",
				"	sampleUV.y = asin( clamp( direction.y, - 1.0, 1.0 ) ) * RECIPROCAL_PI + 0.5;",
				"	sampleUV.x = atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;",
				"	gl_FragColor = texture2D( tEquirect, sampleUV );",
				"}"
			].join( '\n' ),
		};
		var material = new ShaderMaterial( {
			type: 'CubemapFromEquirect',
			uniforms: cloneUniforms( shader.uniforms ),
			vertexShader: shader.vertexShader,
			fragmentShader: shader.fragmentShader,
			side: BackSide,
			blending: NoBlending
		} );
		material.uniforms.tEquirect.value = texture;
		var mesh = new Mesh( new BoxBufferGeometry( 5, 5, 5 ), material );
		scene.add( mesh );
		var camera = new CubeCamera( 1, 10, 1 );
		camera.renderTarget = this;
		camera.renderTarget.texture.name = 'CubeCameraTexture';
		camera.update( renderer, scene );
		mesh.geometry.dispose();
		mesh.material.dispose();
		return this;
	};
	/**
	 * @author alteredq / http://alteredqualia.com/
	 */
	function DataTexture( data, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) {
		Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );
		this.image = { data: data || null, width: width || 1, height: height || 1 };
		this.magFilter = magFilter !== undefined ? magFilter : NearestFilter;
		this.minFilter = minFilter !== undefined ? minFilter : NearestFilter;
		this.generateMipmaps = false;
		this.flipY = false;
		this.unpackAlignment = 1;
		this.needsUpdate = true;
	}
	DataTexture.prototype = Object.create( Texture.prototype );
	DataTexture.prototype.constructor = DataTexture;
	DataTexture.prototype.isDataTexture = true;
	/**
	 * @author mrdoob / http://mrdoob.com/
	 * @author alteredq / http://alteredqualia.com/
	 * @author bhouston / http://clara.io
	 */
	var _sphere$1 = new Sphere();
	var _vector$5 = new Vector3();
	function Frustum( p0, p1, p2, p3, p4, p5 ) {
		this.planes = [
			( p0 !== undefined ) ? p0 : new Plane(),
			( p1 !== undefined ) ? p1 : new Plane(),
			( p2 !== undefined ) ? p2 : new Plane(),
			( p3 !== undefined ) ? p3 : new Plane(),
			( p4 !== undefined ) ? p4 : new Plane(),
			( p5 !== undefined ) ? p5 : new Plane()
		];
	}
	Object.assign( Frustum.prototype, {
		set: function ( p0, p1, p2, p3, p4, p5 ) {
			var planes = this.planes;
			planes[ 0 ].copy( p0 );
			planes[ 1 ].copy( p1 );
			planes[ 2 ].copy( p2 );
			planes[ 3 ].copy( p3 );
			planes[ 4 ].copy( p4 );
			planes[ 5 ].copy( p5 );
			return this;
		},
		clone: function () {
			return new this.constructor().copy( this );
		},
		copy: function ( frustum ) {
			var planes = this.planes;
			for ( var i = 0; i  0 ? box.max.x : box.min.x;
				_vector$5.y = plane.normal.y > 0 ? box.max.y : box.min.y;
				_vector$5.z = plane.normal.z > 0 ? box.max.z : box.min.z;
				if ( plane.distanceToPoint( _vector$5 )  0 &&
					gl.getShaderPrecisionFormat( 35632, 36338 ).precision > 0 ) {
					return 'highp';
				}
				precision = 'mediump';
			}
			if ( precision === 'mediump' ) {
				if ( gl.getShaderPrecisionFormat( 35633, 36337 ).precision > 0 &&
					gl.getShaderPrecisionFormat( 35632, 36337 ).precision > 0 ) {
					return 'mediump';
				}
			}
			return 'lowp';
		}
		/* eslint-disable no-undef */
		var isWebGL2 = ( typeof WebGL2RenderingContext !== 'undefined' && gl instanceof WebGL2RenderingContext ) ||
			( typeof WebGL2ComputeRenderingContext !== 'undefined' && gl instanceof WebGL2ComputeRenderingContext );
		/* eslint-enable no-undef */
		var precision = parameters.precision !== undefined ? parameters.precision : 'highp';
		var maxPrecision = getMaxPrecision( precision );
		if ( maxPrecision !== precision ) {
			console.warn( 'THREE.WebGLRenderer:', precision, 'not supported, using', maxPrecision, 'instead.' );
			precision = maxPrecision;
		}
		var logarithmicDepthBuffer = parameters.logarithmicDepthBuffer === true;
		var maxTextures = gl.getParameter( 34930 );
		var maxVertexTextures = gl.getParameter( 35660 );
		var maxTextureSize = gl.getParameter( 3379 );
		var maxCubemapSize = gl.getParameter( 34076 );
		var maxAttributes = gl.getParameter( 34921 );
		var maxVertexUniforms = gl.getParameter( 36347 );
		var maxVaryings = gl.getParameter( 36348 );
		var maxFragmentUniforms = gl.getParameter( 36349 );
		var vertexTextures = maxVertexTextures > 0;
		var floatFragmentTextures = isWebGL2 || !! extensions.get( 'OES_texture_float' );
		var floatVertexTextures = vertexTextures && floatFragmentTextures;
		var maxSamples = isWebGL2 ? gl.getParameter( 36183 ) : 0;
		return {
			isWebGL2: isWebGL2,
			getMaxAnisotropy: getMaxAnisotropy,
			getMaxPrecision: getMaxPrecision,
			precision: precision,
			logarithmicDepthBuffer: logarithmicDepthBuffer,
			maxTextures: maxTextures,
			maxVertexTextures: maxVertexTextures,
			maxTextureSize: maxTextureSize,
			maxCubemapSize: maxCubemapSize,
			maxAttributes: maxAttributes,
			maxVertexUniforms: maxVertexUniforms,
			maxVaryings: maxVaryings,
			maxFragmentUniforms: maxFragmentUniforms,
			vertexTextures: vertexTextures,
			floatFragmentTextures: floatFragmentTextures,
			floatVertexTextures: floatVertexTextures,
			maxSamples: maxSamples
		};
	}
	/**
	 * @author tschw
	 */
	function WebGLClipping() {
		var scope = this,
			globalState = null,
			numGlobalPlanes = 0,
			localClippingEnabled = false,
			renderingShadows = false,
			plane = new Plane(),
			viewNormalMatrix = new Matrix3(),
			uniform = { value: null, needsUpdate: false };
		this.uniform = uniform;
		this.numPlanes = 0;
		this.numIntersection = 0;
		this.init = function ( planes, enableLocalClipping, camera ) {
			var enabled =
				planes.length !== 0 ||
				enableLocalClipping ||
				// enable state of previous frame - the clipping code has to
				// run another frame in order to reset the state:
				numGlobalPlanes !== 0 ||
				localClippingEnabled;
			localClippingEnabled = enableLocalClipping;
			globalState = projectPlanes( planes, camera, 0 );
			numGlobalPlanes = planes.length;
			return enabled;
		};
		this.beginShadows = function () {
			renderingShadows = true;
			projectPlanes( null );
		};
		this.endShadows = function () {
			renderingShadows = false;
			resetGlobalState();
		};
		this.setState = function ( planes, clipIntersection, clipShadows, camera, cache, fromCache ) {
			if ( ! localClippingEnabled || planes === null || planes.length === 0 || renderingShadows && ! clipShadows ) {
				// there's no local clipping
				if ( renderingShadows ) {
					// there's no global clipping
					projectPlanes( null );
				} else {
					resetGlobalState();
				}
			} else {
				var nGlobal = renderingShadows ? 0 : numGlobalPlanes,
					lGlobal = nGlobal * 4,
					dstArray = cache.clippingState || null;
				uniform.value = dstArray; // ensure unique state
				dstArray = projectPlanes( planes, camera, lGlobal, fromCache );
				for ( var i = 0; i !== lGlobal; ++ i ) {
					dstArray[ i ] = globalState[ i ];
				}
				cache.clippingState = dstArray;
				this.numIntersection = clipIntersection ? this.numPlanes : 0;
				this.numPlanes += nGlobal;
			}
		};
		function resetGlobalState() {
			if ( uniform.value !== globalState ) {
				uniform.value = globalState;
				uniform.needsUpdate = numGlobalPlanes > 0;
			}
			scope.numPlanes = numGlobalPlanes;
			scope.numIntersection = 0;
		}
		function projectPlanes( planes, camera, dstOffset, skipTransform ) {
			var nPlanes = planes !== null ? planes.length : 0,
				dstArray = null;
			if ( nPlanes !== 0 ) {
				dstArray = uniform.value;
				if ( skipTransform !== true || dstArray === null ) {
					var flatSize = dstOffset + nPlanes * 4,
						viewMatrix = camera.matrixWorldInverse;
					viewNormalMatrix.getNormalMatrix( viewMatrix );
					if ( dstArray === null || dstArray.length  65535 ? Uint32BufferAttribute : Uint16BufferAttribute )( indices, 1 );
			attribute.version = version;
			attributes.update( attribute, 34963 );
			//
			var previousAttribute = wireframeAttributes.get( geometry );
			if ( previousAttribute ) { attributes.remove( previousAttribute ); }
			//
			wireframeAttributes.set( geometry, attribute );
		}
		function getWireframeAttribute( geometry ) {
			var currentAttribute = wireframeAttributes.get( geometry );
			if ( currentAttribute ) {
				var geometryIndex = geometry.index;
				if ( geometryIndex !== null ) {
					// if the attribute is obsolete, create a new one
					if ( currentAttribute.version  0 ) { return array; }
		// unoptimized: ! isNaN( firstElem )
		// see http://jacksondunstan.com/articles/983
		var n = nBlocks * blockSize,
			r = arrayCacheF32[ n ];
		if ( r === undefined ) {
			r = new Float32Array( n );
			arrayCacheF32[ n ] = r;
		}
		if ( nBlocks !== 0 ) {
			firstElem.toArray( r, 0 );
			for ( var i = 1, offset = 0; i !== nBlocks; ++ i ) {
				offset += blockSize;
				array[ i ].toArray( r, offset );
			}
		}
		return r;
	}
	function arraysEqual( a, b ) {
		if ( a.length !== b.length ) { return false; }
		for ( var i = 0, l = a.length; i /gm;
	function resolveIncludes( string ) {
		return string.replace( includePattern, includeReplacer );
	}
	function includeReplacer( match, include ) {
		var string = ShaderChunk[ include ];
		if ( string === undefined ) {
			throw new Error( 'Can not resolve #include ' );
		}
		return resolveIncludes( string );
	}
	// Unroll Loops
	var deprecatedUnrollLoopPattern = /#pragma unroll_loop[\s]+?for \( int i \= (\d+)\; i  0 ) ? renderer.gammaFactor : 1.0;
		var customExtensions = parameters.isWebGL2 ? '' : generateExtensions( parameters );
		var customDefines = generateDefines( defines );
		var program = gl.createProgram();
		var prefixVertex, prefixFragment;
		if ( parameters.isRawShaderMaterial ) {
			prefixVertex = [
				customDefines
			].filter( filterEmptyLine ).join( '\n' );
			if ( prefixVertex.length > 0 ) {
				prefixVertex += '\n';
			}
			prefixFragment = [
				customExtensions,
				customDefines
			].filter( filterEmptyLine ).join( '\n' );
			if ( prefixFragment.length > 0 ) {
				prefixFragment += '\n';
			}
		} else {
			prefixVertex = [
				generatePrecision( parameters ),
				'#define SHADER_NAME ' + parameters.shaderName,
				customDefines,
				parameters.instancing ? '#define USE_INSTANCING' : '',
				parameters.supportsVertexTextures ? '#define VERTEX_TEXTURES' : '',
				'#define GAMMA_FACTOR ' + gammaFactorDefine,
				'#define MAX_BONES ' + parameters.maxBones,
				( parameters.useFog && parameters.fog ) ? '#define USE_FOG' : '',
				( parameters.useFog && parameters.fogExp2 ) ? '#define FOG_EXP2' : '',
				parameters.map ? '#define USE_MAP' : '',
				parameters.envMap ? '#define USE_ENVMAP' : '',
				parameters.envMap ? '#define ' + envMapModeDefine : '',
				parameters.lightMap ? '#define USE_LIGHTMAP' : '',
				parameters.aoMap ? '#define USE_AOMAP' : '',
				parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
				parameters.bumpMap ? '#define USE_BUMPMAP' : '',
				parameters.normalMap ? '#define USE_NORMALMAP' : '',
				( parameters.normalMap && parameters.objectSpaceNormalMap ) ? '#define OBJECTSPACE_NORMALMAP' : '',
				( parameters.normalMap && parameters.tangentSpaceNormalMap ) ? '#define TANGENTSPACE_NORMALMAP' : '',
				parameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',
				parameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',
				parameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',
				parameters.displacementMap && parameters.supportsVertexTextures ? '#define USE_DISPLACEMENTMAP' : '',
				parameters.specularMap ? '#define USE_SPECULARMAP' : '',
				parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
				parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
				parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
				parameters.vertexTangents ? '#define USE_TANGENT' : '',
				parameters.vertexColors ? '#define USE_COLOR' : '',
				parameters.vertexUvs ? '#define USE_UV' : '',
				parameters.uvsVertexOnly ? '#define UVS_VERTEX_ONLY' : '',
				parameters.flatShading ? '#define FLAT_SHADED' : '',
				parameters.skinning ? '#define USE_SKINNING' : '',
				parameters.useVertexTexture ? '#define BONE_TEXTURE' : '',
				parameters.morphTargets ? '#define USE_MORPHTARGETS' : '',
				parameters.morphNormals && parameters.flatShading === false ? '#define USE_MORPHNORMALS' : '',
				parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
				parameters.flipSided ? '#define FLIP_SIDED' : '',
				parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
				parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',
				parameters.sizeAttenuation ? '#define USE_SIZEATTENUATION' : '',
				parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
				( parameters.logarithmicDepthBuffer && parameters.rendererExtensionFragDepth ) ? '#define USE_LOGDEPTHBUF_EXT' : '',
				'uniform mat4 modelMatrix;',
				'uniform mat4 modelViewMatrix;',
				'uniform mat4 projectionMatrix;',
				'uniform mat4 viewMatrix;',
				'uniform mat3 normalMatrix;',
				'uniform vec3 cameraPosition;',
				'uniform bool isOrthographic;',
				'#ifdef USE_INSTANCING',
				' attribute mat4 instanceMatrix;',
				'#endif',
				'attribute vec3 position;',
				'attribute vec3 normal;',
				'attribute vec2 uv;',
				'#ifdef USE_TANGENT',
				'	attribute vec4 tangent;',
				'#endif',
				'#ifdef USE_COLOR',
				'	attribute vec3 color;',
				'#endif',
				'#ifdef USE_MORPHTARGETS',
				'	attribute vec3 morphTarget0;',
				'	attribute vec3 morphTarget1;',
				'	attribute vec3 morphTarget2;',
				'	attribute vec3 morphTarget3;',
				'	#ifdef USE_MORPHNORMALS',
				'		attribute vec3 morphNormal0;',
				'		attribute vec3 morphNormal1;',
				'		attribute vec3 morphNormal2;',
				'		attribute vec3 morphNormal3;',
				'	#else',
				'		attribute vec3 morphTarget4;',
				'		attribute vec3 morphTarget5;',
				'		attribute vec3 morphTarget6;',
				'		attribute vec3 morphTarget7;',
				'	#endif',
				'#endif',
				'#ifdef USE_SKINNING',
				'	attribute vec4 skinIndex;',
				'	attribute vec4 skinWeight;',
				'#endif',
				'\n'
			].filter( filterEmptyLine ).join( '\n' );
			prefixFragment = [
				customExtensions,
				generatePrecision( parameters ),
				'#define SHADER_NAME ' + parameters.shaderName,
				customDefines,
				parameters.alphaTest ? '#define ALPHATEST ' + parameters.alphaTest + ( parameters.alphaTest % 1 ? '' : '.0' ) : '', // add '.0' if integer
				'#define GAMMA_FACTOR ' + gammaFactorDefine,
				( parameters.useFog && parameters.fog ) ? '#define USE_FOG' : '',
				( parameters.useFog && parameters.fogExp2 ) ? '#define FOG_EXP2' : '',
				parameters.map ? '#define USE_MAP' : '',
				parameters.matcap ? '#define USE_MATCAP' : '',
				parameters.envMap ? '#define USE_ENVMAP' : '',
				parameters.envMap ? '#define ' + envMapTypeDefine : '',
				parameters.envMap ? '#define ' + envMapModeDefine : '',
				parameters.envMap ? '#define ' + envMapBlendingDefine : '',
				parameters.lightMap ? '#define USE_LIGHTMAP' : '',
				parameters.aoMap ? '#define USE_AOMAP' : '',
				parameters.emissiveMap ? '#define USE_EMISSIVEMAP' : '',
				parameters.bumpMap ? '#define USE_BUMPMAP' : '',
				parameters.normalMap ? '#define USE_NORMALMAP' : '',
				( parameters.normalMap && parameters.objectSpaceNormalMap ) ? '#define OBJECTSPACE_NORMALMAP' : '',
				( parameters.normalMap && parameters.tangentSpaceNormalMap ) ? '#define TANGENTSPACE_NORMALMAP' : '',
				parameters.clearcoatMap ? '#define USE_CLEARCOATMAP' : '',
				parameters.clearcoatRoughnessMap ? '#define USE_CLEARCOAT_ROUGHNESSMAP' : '',
				parameters.clearcoatNormalMap ? '#define USE_CLEARCOAT_NORMALMAP' : '',
				parameters.specularMap ? '#define USE_SPECULARMAP' : '',
				parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
				parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
				parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
				parameters.sheen ? '#define USE_SHEEN' : '',
				parameters.vertexTangents ? '#define USE_TANGENT' : '',
				parameters.vertexColors ? '#define USE_COLOR' : '',
				parameters.vertexUvs ? '#define USE_UV' : '',
				parameters.uvsVertexOnly ? '#define UVS_VERTEX_ONLY' : '',
				parameters.gradientMap ? '#define USE_GRADIENTMAP' : '',
				parameters.flatShading ? '#define FLAT_SHADED' : '',
				parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
				parameters.flipSided ? '#define FLIP_SIDED' : '',
				parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
				parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',
				parameters.premultipliedAlpha ? '#define PREMULTIPLIED_ALPHA' : '',
				parameters.physicallyCorrectLights ? '#define PHYSICALLY_CORRECT_LIGHTS' : '',
				parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
				( parameters.logarithmicDepthBuffer && parameters.rendererExtensionFragDepth ) ? '#define USE_LOGDEPTHBUF_EXT' : '',
				( ( parameters.extensionShaderTextureLOD || parameters.envMap ) && parameters.rendererExtensionShaderTextureLod ) ? '#define TEXTURE_LOD_EXT' : '',
				'uniform mat4 viewMatrix;',
				'uniform vec3 cameraPosition;',
				'uniform bool isOrthographic;',
				( parameters.toneMapping !== NoToneMapping ) ? '#define TONE_MAPPING' : '',
				( parameters.toneMapping !== NoToneMapping ) ? ShaderChunk[ 'tonemapping_pars_fragment' ] : '', // this code is required here because it is used by the toneMapping() function defined below
				( parameters.toneMapping !== NoToneMapping ) ? getToneMappingFunction( 'toneMapping', parameters.toneMapping ) : '',
				parameters.dithering ? '#define DITHERING' : '',
				( parameters.outputEncoding || parameters.mapEncoding || parameters.matcapEncoding || parameters.envMapEncoding || parameters.emissiveMapEncoding || parameters.lightMapEncoding ) ?
					ShaderChunk[ 'encodings_pars_fragment' ] : '', // this code is required here because it is used by the various encoding/decoding function defined below
				parameters.mapEncoding ? getTexelDecodingFunction( 'mapTexelToLinear', parameters.mapEncoding ) : '',
				parameters.matcapEncoding ? getTexelDecodingFunction( 'matcapTexelToLinear', parameters.matcapEncoding ) : '',
				parameters.envMapEncoding ? getTexelDecodingFunction( 'envMapTexelToLinear', parameters.envMapEncoding ) : '',
				parameters.emissiveMapEncoding ? getTexelDecodingFunction( 'emissiveMapTexelToLinear', parameters.emissiveMapEncoding ) : '',
				parameters.lightMapEncoding ? getTexelDecodingFunction( 'lightMapTexelToLinear', parameters.lightMapEncoding ) : '',
				parameters.outputEncoding ? getTexelEncodingFunction( 'linearToOutputTexel', parameters.outputEncoding ) : '',
				parameters.depthPacking ? '#define DEPTH_PACKING ' + parameters.depthPacking : '',
				'\n'
			].filter( filterEmptyLine ).join( '\n' );
		}
		vertexShader = resolveIncludes( vertexShader );
		vertexShader = replaceLightNums( vertexShader, parameters );
		vertexShader = replaceClippingPlaneNums( vertexShader, parameters );
		fragmentShader = resolveIncludes( fragmentShader );
		fragmentShader = replaceLightNums( fragmentShader, parameters );
		fragmentShader = replaceClippingPlaneNums( fragmentShader, parameters );
		vertexShader = unrollLoops( vertexShader );
		fragmentShader = unrollLoops( fragmentShader );
		if ( parameters.isWebGL2 && ! parameters.isRawShaderMaterial ) {
			var isGLSL3ShaderMaterial = false;
			var versionRegex = /^\s*#version\s+300\s+es\s*\n/;
			if ( parameters.isShaderMaterial &&
				vertexShader.match( versionRegex ) !== null &&
				fragmentShader.match( versionRegex ) !== null ) {
				isGLSL3ShaderMaterial = true;
				vertexShader = vertexShader.replace( versionRegex, '' );
				fragmentShader = fragmentShader.replace( versionRegex, '' );
			}
			// GLSL 3.0 conversion
			prefixVertex = [
				'#version 300 es\n',
				'#define attribute in',
				'#define varying out',
				'#define texture2D texture'
			].join( '\n' ) + '\n' + prefixVertex;
			prefixFragment = [
				'#version 300 es\n',
				'#define varying in',
				isGLSL3ShaderMaterial ? '' : 'out highp vec4 pc_fragColor;',
				isGLSL3ShaderMaterial ? '' : '#define gl_FragColor pc_fragColor',
				'#define gl_FragDepthEXT gl_FragDepth',
				'#define texture2D texture',
				'#define textureCube texture',
				'#define texture2DProj textureProj',
				'#define texture2DLodEXT textureLod',
				'#define texture2DProjLodEXT textureProjLod',
				'#define textureCubeLodEXT textureLod',
				'#define texture2DGradEXT textureGrad',
				'#define texture2DProjGradEXT textureProjGrad',
				'#define textureCubeGradEXT textureGrad'
			].join( '\n' ) + '\n' + prefixFragment;
		}
		var vertexGlsl = prefixVertex + vertexShader;
		var fragmentGlsl = prefixFragment + fragmentShader;
		// console.log( '*VERTEX*', vertexGlsl );
		// console.log( '*FRAGMENT*', fragmentGlsl );
		var glVertexShader = WebGLShader( gl, 35633, vertexGlsl );
		var glFragmentShader = WebGLShader( gl, 35632, fragmentGlsl );
		gl.attachShader( program, glVertexShader );
		gl.attachShader( program, glFragmentShader );
		// Force a particular attribute to index 0.
		if ( parameters.index0AttributeName !== undefined ) {
			gl.bindAttribLocation( program, 0, parameters.index0AttributeName );
		} else if ( parameters.morphTargets === true ) {
			// programs with morphTargets displace position out of attribute 0
			gl.bindAttribLocation( program, 0, 'position' );
		}
		gl.linkProgram( program );
		// check for link errors
		if ( renderer.debug.checkShaderErrors ) {
			var programLog = gl.getProgramInfoLog( program ).trim();
			var vertexLog = gl.getShaderInfoLog( glVertexShader ).trim();
			var fragmentLog = gl.getShaderInfoLog( glFragmentShader ).trim();
			var runnable = true;
			var haveDiagnostics = true;
			if ( gl.getProgramParameter( program, 35714 ) === false ) {
				runnable = false;
				var vertexErrors = getShaderErrors( gl, glVertexShader, 'vertex' );
				var fragmentErrors = getShaderErrors( gl, glFragmentShader, 'fragment' );
				console.error( 'THREE.WebGLProgram: shader error: ', gl.getError(), '35715', gl.getProgramParameter( program, 35715 ), 'gl.getProgramInfoLog', programLog, vertexErrors, fragmentErrors );
			} else if ( programLog !== '' ) {
				console.warn( 'THREE.WebGLProgram: gl.getProgramInfoLog()', programLog );
			} else if ( vertexLog === '' || fragmentLog === '' ) {
				haveDiagnostics = false;
			}
			if ( haveDiagnostics ) {
				this.diagnostics = {
					runnable: runnable,
					programLog: programLog,
					vertexShader: {
						log: vertexLog,
						prefix: prefixVertex
					},
					fragmentShader: {
						log: fragmentLog,
						prefix: prefixFragment
					}
				};
			}
		}
		// clean up
		gl.detachShader( program, glVertexShader );
		gl.detachShader( program, glFragmentShader );
		gl.deleteShader( glVertexShader );
		gl.deleteShader( glFragmentShader );
		// set up caching for uniform locations
		var cachedUniforms;
		this.getUniforms = function () {
			if ( cachedUniforms === undefined ) {
				cachedUniforms = new WebGLUniforms( gl, program );
			}
			return cachedUniforms;
		};
		// set up caching for attribute locations
		var cachedAttributes;
		this.getAttributes = function () {
			if ( cachedAttributes === undefined ) {
				cachedAttributes = fetchAttributeLocations( gl, program );
			}
			return cachedAttributes;
		};
		// free resource
		this.destroy = function () {
			gl.deleteProgram( program );
			this.program = undefined;
		};
		//
		this.name = parameters.shaderName;
		this.id = programIdCount ++;
		this.cacheKey = cacheKey;
		this.usedTimes = 1;
		this.program = program;
		this.vertexShader = glVertexShader;
		this.fragmentShader = glFragmentShader;
		return this;
	}
	/**
	 * @author mrdoob / http://mrdoob.com/
	 */
	function WebGLPrograms( renderer, extensions, capabilities ) {
		var programs = [];
		var isWebGL2 = capabilities.isWebGL2;
		var logarithmicDepthBuffer = capabilities.logarithmicDepthBuffer;
		var floatVertexTextures = capabilities.floatVertexTextures;
		var precision = capabilities.precision;
		var maxVertexUniforms = capabilities.maxVertexUniforms;
		var vertexTextures = capabilities.vertexTextures;
		var shaderIDs = {
			MeshDepthMaterial: 'depth',
			MeshDistanceMaterial: 'distanceRGBA',
			MeshNormalMaterial: 'normal',
			MeshBasicMaterial: 'basic',
			MeshLambertMaterial: 'lambert',
			MeshPhongMaterial: 'phong',
			MeshToonMaterial: 'toon',
			MeshStandardMaterial: 'physical',
			MeshPhysicalMaterial: 'physical',
			MeshMatcapMaterial: 'matcap',
			LineBasicMaterial: 'basic',
			LineDashedMaterial: 'dashed',
			PointsMaterial: 'points',
			ShadowMaterial: 'shadow',
			SpriteMaterial: 'sprite'
		};
		var parameterNames = [
			"precision", "isWebGL2", "supportsVertexTextures", "outputEncoding", "instancing",
			"map", "mapEncoding", "matcap", "matcapEncoding", "envMap", "envMapMode", "envMapEncoding", "envMapCubeUV",
			"lightMap", "lightMapEncoding", "aoMap", "emissiveMap", "emissiveMapEncoding", "bumpMap", "normalMap", "objectSpaceNormalMap", "tangentSpaceNormalMap", "clearcoatMap", "clearcoatRoughnessMap", "clearcoatNormalMap", "displacementMap", "specularMap",
			"roughnessMap", "metalnessMap", "gradientMap",
			"alphaMap", "combine", "vertexColors", "vertexTangents", "vertexUvs", "uvsVertexOnly", "fog", "useFog", "fogExp2",
			"flatShading", "sizeAttenuation", "logarithmicDepthBuffer", "skinning",
			"maxBones", "useVertexTexture", "morphTargets", "morphNormals",
			"maxMorphTargets", "maxMorphNormals", "premultipliedAlpha",
			"numDirLights", "numPointLights", "numSpotLights", "numHemiLights", "numRectAreaLights",
			"numDirLightShadows", "numPointLightShadows", "numSpotLightShadows",
			"shadowMapEnabled", "shadowMapType", "toneMapping", 'physicallyCorrectLights',
			"alphaTest", "doubleSided", "flipSided", "numClippingPlanes", "numClipIntersection", "depthPacking", "dithering",
			"sheen"
		];
		function getShaderObject( material, shaderID ) {
			var shaderobject;
			if ( shaderID ) {
				var shader = ShaderLib[ shaderID ];
				shaderobject = {
					name: material.type,
					uniforms: UniformsUtils.clone( shader.uniforms ),
					vertexShader: shader.vertexShader,
					fragmentShader: shader.fragmentShader
				};
			} else {
				shaderobject = {
					name: material.type,
					uniforms: material.uniforms,
					vertexShader: material.vertexShader,
					fragmentShader: material.fragmentShader
				};
			}
			return shaderobject;
		}
		function allocateBones( object ) {
			var skeleton = object.skeleton;
			var bones = skeleton.bones;
			if ( floatVertexTextures ) {
				return 1024;
			} else {
				// default for when object is not specified
				// ( for example when prebuilding shader to be used with multiple objects )
				//
				//  - leave some extra space for other uniforms
				//  - limit here is ANGLE's 254 max uniform vectors
				//    (up to 54 should be safe)
				var nVertexUniforms = maxVertexUniforms;
				var nVertexMatrices = Math.floor( ( nVertexUniforms - 20 ) / 4 );
				var maxBones = Math.min( nVertexMatrices, bones.length );
				if ( maxBones  0,
				maxBones: maxBones,
				useVertexTexture: floatVertexTextures,
				morphTargets: material.morphTargets,
				morphNormals: material.morphNormals,
				maxMorphTargets: renderer.maxMorphTargets,
				maxMorphNormals: renderer.maxMorphNormals,
				numDirLights: lights.directional.length,
				numPointLights: lights.point.length,
				numSpotLights: lights.spot.length,
				numRectAreaLights: lights.rectArea.length,
				numHemiLights: lights.hemi.length,
				numDirLightShadows: lights.directionalShadowMap.length,
				numPointLightShadows: lights.pointShadowMap.length,
				numSpotLightShadows: lights.spotShadowMap.length,
				numClippingPlanes: nClipPlanes,
				numClipIntersection: nClipIntersection,
				dithering: material.dithering,
				shadowMapEnabled: renderer.shadowMap.enabled && shadows.length > 0,
				shadowMapType: renderer.shadowMap.type,
				toneMapping: material.toneMapped ? renderer.toneMapping : NoToneMapping,
				physicallyCorrectLights: renderer.physicallyCorrectLights,
				premultipliedAlpha: material.premultipliedAlpha,
				alphaTest: material.alphaTest,
				doubleSided: material.side === DoubleSide,
				flipSided: material.side === BackSide,
				depthPacking: ( material.depthPacking !== undefined ) ? material.depthPacking : false,
				index0AttributeName: material.index0AttributeName,
				extensionDerivatives: material.extensions && material.extensions.derivatives,
				extensionFragDepth: material.extensions && material.extensions.fragDepth,
				extensionDrawBuffers: material.extensions && material.extensions.drawBuffers,
				extensionShaderTextureLOD: material.extensions && material.extensions.shaderTextureLOD,
				rendererExtensionFragDepth: isWebGL2 || extensions.get( 'EXT_frag_depth' ) !== null,
				rendererExtensionDrawBuffers: isWebGL2 || extensions.get( 'WEBGL_draw_buffers' ) !== null,
				rendererExtensionShaderTextureLod: isWebGL2 || extensions.get( 'EXT_shader_texture_lod' ) !== null,
				onBeforeCompile: material.onBeforeCompile
			};
			return parameters;
		};
		this.getProgramCacheKey = function ( parameters ) {
			var array = [];
			if ( parameters.shaderID ) {
				array.push( parameters.shaderID );
			} else {
				array.push( parameters.fragmentShader );
				array.push( parameters.vertexShader );
			}
			if ( parameters.defines !== undefined ) {
				for ( var name in parameters.defines ) {
					array.push( name );
					array.push( parameters.defines[ name ] );
				}
			}
			if ( parameters.isRawShaderMaterial === undefined ) {
				for ( var i = 0; i  1 ) { opaque.sort( customOpaqueSort || painterSortStable ); }
			if ( transparent.length > 1 ) { transparent.sort( customTransparentSort || reversePainterSortStable ); }
		}
		function finish() {
			// Clear references from inactive renderItems in the list
			for ( var i = renderItemsIndex, il = renderItems.length; i ,
	 *
	 *  map: new THREE.Texture(  ),
	 *
	 *  alphaMap: new THREE.Texture(  ),
	 *
	 *  displacementMap: new THREE.Texture(  ),
	 *  displacementScale: ,
	 *  displacementBias: ,
	 *
	 *  wireframe: ,
	 *  wireframeLinewidth: 
	 * }
	 */
	function MeshDepthMaterial( parameters ) {
		Material.call( this );
		this.type = 'MeshDepthMaterial';
		this.depthPacking = BasicDepthPacking;
		this.skinning = false;
		this.morphTargets = false;
		this.map = null;
		this.alphaMap = null;
		this.displacementMap = null;
		this.displacementScale = 1;
		this.displacementBias = 0;
		this.wireframe = false;
		this.wireframeLinewidth = 1;
		this.fog = false;
		this.setValues( parameters );
	}
	MeshDepthMaterial.prototype = Object.create( Material.prototype );
	MeshDepthMaterial.prototype.constructor = MeshDepthMaterial;
	MeshDepthMaterial.prototype.isMeshDepthMaterial = true;
	MeshDepthMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.depthPacking = source.depthPacking;
		this.skinning = source.skinning;
		this.morphTargets = source.morphTargets;
		this.map = source.map;
		this.alphaMap = source.alphaMap;
		this.displacementMap = source.displacementMap;
		this.displacementScale = source.displacementScale;
		this.displacementBias = source.displacementBias;
		this.wireframe = source.wireframe;
		this.wireframeLinewidth = source.wireframeLinewidth;
		return this;
	};
	/**
	 * @author WestLangley / http://github.com/WestLangley
	 *
	 * parameters = {
	 *
	 *  referencePosition: ,
	 *  nearDistance: ,
	 *  farDistance: ,
	 *
	 *  skinning: ,
	 *  morphTargets: ,
	 *
	 *  map: new THREE.Texture(  ),
	 *
	 *  alphaMap: new THREE.Texture(  ),
	 *
	 *  displacementMap: new THREE.Texture(  ),
	 *  displacementScale: ,
	 *  displacementBias: 
	 *
	 * }
	 */
	function MeshDistanceMaterial( parameters ) {
		Material.call( this );
		this.type = 'MeshDistanceMaterial';
		this.referencePosition = new Vector3();
		this.nearDistance = 1;
		this.farDistance = 1000;
		this.skinning = false;
		this.morphTargets = false;
		this.map = null;
		this.alphaMap = null;
		this.displacementMap = null;
		this.displacementScale = 1;
		this.displacementBias = 0;
		this.fog = false;
		this.setValues( parameters );
	}
	MeshDistanceMaterial.prototype = Object.create( Material.prototype );
	MeshDistanceMaterial.prototype.constructor = MeshDistanceMaterial;
	MeshDistanceMaterial.prototype.isMeshDistanceMaterial = true;
	MeshDistanceMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.referencePosition.copy( source.referencePosition );
		this.nearDistance = source.nearDistance;
		this.farDistance = source.farDistance;
		this.skinning = source.skinning;
		this.morphTargets = source.morphTargets;
		this.map = source.map;
		this.alphaMap = source.alphaMap;
		this.displacementMap = source.displacementMap;
		this.displacementScale = source.displacementScale;
		this.displacementBias = source.displacementBias;
		return this;
	};
	var vsm_frag = "uniform sampler2D shadow_pass;\nuniform vec2 resolution;\nuniform float radius;\n#include \nvoid main() {\n  float mean = 0.0;\n  float squared_mean = 0.0;\n\tfloat depth = unpackRGBAToDepth( texture2D( shadow_pass, ( gl_FragCoord.xy  ) / resolution ) );\n  for ( float i = -1.0; i  maxTextureSize || _shadowMapSize.y > maxTextureSize ) {
					if ( _shadowMapSize.x > maxTextureSize ) {
						_viewportSize.x = Math.floor( maxTextureSize / shadowFrameExtents.x );
						_shadowMapSize.x = _viewportSize.x * shadowFrameExtents.x;
						shadow.mapSize.x = _viewportSize.x;
					}
					if ( _shadowMapSize.y > maxTextureSize ) {
						_viewportSize.y = Math.floor( maxTextureSize / shadowFrameExtents.y );
						_shadowMapSize.y = _viewportSize.y * shadowFrameExtents.y;
						shadow.mapSize.y = _viewportSize.y;
					}
				}
				if ( shadow.map === null && ! shadow.isPointLightShadow && this.type === VSMShadowMap ) {
					var pars = { minFilter: LinearFilter, magFilter: LinearFilter, format: RGBAFormat };
					shadow.map = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars );
					shadow.map.texture.name = light.name + ".shadowMap";
					shadow.mapPass = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars );
					shadow.camera.updateProjectionMatrix();
				}
				if ( shadow.map === null ) {
					var pars = { minFilter: NearestFilter, magFilter: NearestFilter, format: RGBAFormat };
					shadow.map = new WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars );
					shadow.map.texture.name = light.name + ".shadowMap";
					shadow.camera.updateProjectionMatrix();
				}
				_renderer.setRenderTarget( shadow.map );
				_renderer.clear();
				var viewportCount = shadow.getViewportCount();
				for ( var vp = 0; vp  0;
				}
				var useSkinning = false;
				if ( object.isSkinnedMesh === true ) {
					if ( material.skinning === true ) {
						useSkinning = true;
					} else {
						console.warn( 'THREE.WebGLShadowMap: THREE.SkinnedMesh with material.skinning set to false:', object );
					}
				}
				var useInstancing = object.isInstancedMesh === true;
				result = getMaterialVariant( useMorphing, useSkinning, useInstancing );
			} else {
				result = customMaterial;
			}
			if ( _renderer.localClippingEnabled &&
					material.clipShadows === true &&
					material.clippingPlanes.length !== 0 ) {
				// in this case we need a unique material instance reflecting the
				// appropriate state
				var keyA = result.uuid, keyB = material.uuid;
				var materialsForVariant = _materialCache[ keyA ];
				if ( materialsForVariant === undefined ) {
					materialsForVariant = {};
					_materialCache[ keyA ] = materialsForVariant;
				}
				var cachedMaterial = materialsForVariant[ keyB ];
				if ( cachedMaterial === undefined ) {
					cachedMaterial = result.clone();
					materialsForVariant[ keyB ] = cachedMaterial;
				}
				result = cachedMaterial;
			}
			result.visible = material.visible;
			result.wireframe = material.wireframe;
			if ( type === VSMShadowMap ) {
				result.side = ( material.shadowSide !== null ) ? material.shadowSide : material.side;
			} else {
				result.side = ( material.shadowSide !== null ) ? material.shadowSide : shadowSide[ material.side ];
			}
			result.clipShadows = material.clipShadows;
			result.clippingPlanes = material.clippingPlanes;
			result.clipIntersection = material.clipIntersection;
			result.wireframeLinewidth = material.wireframeLinewidth;
			result.linewidth = material.linewidth;
			if ( light.isPointLight === true && result.isMeshDistanceMaterial === true ) {
				result.referencePosition.setFromMatrixPosition( light.matrixWorld );
				result.nearDistance = shadowCameraNear;
				result.farDistance = shadowCameraFar;
			}
			return result;
		}
		function renderObject( object, camera, shadowCamera, light, type ) {
			if ( object.visible === false ) { return; }
			var visible = object.layers.test( camera.layers );
			if ( visible && ( object.isMesh || object.isLine || object.isPoints ) ) {
				if ( ( object.castShadow || ( object.receiveShadow && type === VSMShadowMap ) ) && ( ! object.frustumCulled || _frustum.intersectsObject( object ) ) ) {
					object.modelViewMatrix.multiplyMatrices( shadowCamera.matrixWorldInverse, object.matrixWorld );
					var geometry = _objects.update( object );
					var material = object.material;
					if ( Array.isArray( material ) ) {
						var groups = geometry.groups;
						for ( var k = 0, kl = groups.length; k = 1.0 );
		} else if ( glVersion.indexOf( 'OpenGL ES' ) !== - 1 ) {
			version = parseFloat( /^OpenGL\ ES\ ([0-9])/.exec( glVersion )[ 1 ] );
			lineWidthAvailable = ( version >= 2.0 );
		}
		var currentTextureSlot = null;
		var currentBoundTextures = {};
		var currentScissor = new Vector4();
		var currentViewport = new Vector4();
		function createTexture( type, target, count ) {
			var data = new Uint8Array( 4 ); // 4 is required to match default unpack alignment of 4.
			var texture = gl.createTexture();
			gl.bindTexture( type, texture );
			gl.texParameteri( type, 10241, 9728 );
			gl.texParameteri( type, 10240, 9728 );
			for ( var i = 0; i  maxSize || image.height > maxSize ) {
				scale = maxSize / Math.max( image.width, image.height );
			}
			// only perform resize if necessary
			if ( scale = maxTextures ) {
				console.warn( 'THREE.WebGLTextures: Trying to use ' + textureUnit + ' texture units while this GPU supports only ' + maxTextures );
			}
			textureUnits += 1;
			return textureUnit;
		}
		//
		function setTexture2D( texture, slot ) {
			var textureProperties = properties.get( texture );
			if ( texture.isVideoTexture ) { updateVideoTexture( texture ); }
			if ( texture.version > 0 && textureProperties.__version !== texture.version ) {
				var image = texture.image;
				if ( image === undefined ) {
					console.warn( 'THREE.WebGLRenderer: Texture marked for update but image is undefined' );
				} else if ( image.complete === false ) {
					console.warn( 'THREE.WebGLRenderer: Texture marked for update but image is incomplete' );
				} else {
					uploadTexture( textureProperties, texture, slot );
					return;
				}
			}
			state.activeTexture( 33984 + slot );
			state.bindTexture( 3553, textureProperties.__webglTexture );
		}
		function setTexture2DArray( texture, slot ) {
			var textureProperties = properties.get( texture );
			if ( texture.version > 0 && textureProperties.__version !== texture.version ) {
				uploadTexture( textureProperties, texture, slot );
				return;
			}
			state.activeTexture( 33984 + slot );
			state.bindTexture( 35866, textureProperties.__webglTexture );
		}
		function setTexture3D( texture, slot ) {
			var textureProperties = properties.get( texture );
			if ( texture.version > 0 && textureProperties.__version !== texture.version ) {
				uploadTexture( textureProperties, texture, slot );
				return;
			}
			state.activeTexture( 33984 + slot );
			state.bindTexture( 32879, textureProperties.__webglTexture );
		}
		function setTextureCube( texture, slot ) {
			if ( texture.image.length !== 6 ) { return; }
			var textureProperties = properties.get( texture );
			if ( texture.version > 0 && textureProperties.__version !== texture.version ) {
				initTexture( textureProperties, texture );
				state.activeTexture( 33984 + slot );
				state.bindTexture( 34067, textureProperties.__webglTexture );
				_gl.pixelStorei( 37440, texture.flipY );
				var isCompressed = ( texture && ( texture.isCompressedTexture || texture.image[ 0 ].isCompressedTexture ) );
				var isDataTexture = ( texture.image[ 0 ] && texture.image[ 0 ].isDataTexture );
				var cubeImage = [];
				for ( var i = 0; i  1 || properties.get( texture ).__currentAnisotropy ) {
					_gl.texParameterf( textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min( texture.anisotropy, capabilities.getMaxAnisotropy() ) );
					properties.get( texture ).__currentAnisotropy = texture.anisotropy;
				}
			}
		}
		function initTexture( textureProperties, texture ) {
			if ( textureProperties.__webglInit === undefined ) {
				textureProperties.__webglInit = true;
				texture.addEventListener( 'dispose', onTextureDispose );
				textureProperties.__webglTexture = _gl.createTexture();
				info.memory.textures ++;
			}
		}
		function uploadTexture( textureProperties, texture, slot ) {
			var textureType = 3553;
			if ( texture.isDataTexture2DArray ) { textureType = 35866; }
			if ( texture.isDataTexture3D ) { textureType = 32879; }
			initTexture( textureProperties, texture );
			state.activeTexture( 33984 + slot );
			state.bindTexture( textureType, textureProperties.__webglTexture );
			_gl.pixelStorei( 37440, texture.flipY );
			_gl.pixelStorei( 37441, texture.premultiplyAlpha );
			_gl.pixelStorei( 3317, texture.unpackAlignment );
			var needsPowerOfTwo = textureNeedsPowerOfTwo( texture ) && isPowerOfTwo( texture.image ) === false;
			var image = resizeImage( texture.image, needsPowerOfTwo, false, maxTextureSize );
			var supportsMips = isPowerOfTwo( image ) || isWebGL2,
				glFormat = utils.convert( texture.format ),
				glType = utils.convert( texture.type ),
				glInternalFormat = getInternalFormat( texture.internalFormat, glFormat, glType );
			setTextureParameters( textureType, texture, supportsMips );
			var mipmap, mipmaps = texture.mipmaps;
			if ( texture.isDepthTexture ) {
				// populate depth texture with dummy data
				glInternalFormat = 6402;
				if ( isWebGL2 ) {
					if ( texture.type === FloatType ) {
						glInternalFormat = 36012;
					} else if ( texture.type === UnsignedIntType ) {
						glInternalFormat = 33190;
					} else if ( texture.type === UnsignedInt248Type ) {
						glInternalFormat = 35056;
					} else {
						glInternalFormat = 33189; // WebGL2 requires sized internalformat for glTexImage2D
					}
				} else {
					if ( texture.type === FloatType ) {
						console.error( 'WebGLRenderer: Floating point depth texture requires WebGL2.' );
					}
				}
				// validation checks for WebGL 1
				if ( texture.format === DepthFormat && glInternalFormat === 6402 ) {
					// The error INVALID_OPERATION is generated by texImage2D if format and internalformat are
					// DEPTH_COMPONENT and type is not UNSIGNED_SHORT or UNSIGNED_INT
					// (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
					if ( texture.type !== UnsignedShortType && texture.type !== UnsignedIntType ) {
						console.warn( 'THREE.WebGLRenderer: Use UnsignedShortType or UnsignedIntType for DepthFormat DepthTexture.' );
						texture.type = UnsignedShortType;
						glType = utils.convert( texture.type );
					}
				}
				if ( texture.format === DepthStencilFormat && glInternalFormat === 6402 ) {
					// Depth stencil textures need the DEPTH_STENCIL internal format
					// (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
					glInternalFormat = 34041;
					// The error INVALID_OPERATION is generated by texImage2D if format and internalformat are
					// DEPTH_STENCIL and type is not UNSIGNED_INT_24_8_WEBGL.
					// (https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/)
					if ( texture.type !== UnsignedInt248Type ) {
						console.warn( 'THREE.WebGLRenderer: Use UnsignedInt248Type for DepthStencilFormat DepthTexture.' );
						texture.type = UnsignedInt248Type;
						glType = utils.convert( texture.type );
					}
				}
				//
				state.texImage2D( 3553, 0, glInternalFormat, image.width, image.height, 0, glFormat, glType, null );
			} else if ( texture.isDataTexture ) {
				// use manually created mipmaps if available
				// if there are no manual mipmaps
				// set 0 level mipmap and then use GL to generate other mipmap levels
				if ( mipmaps.length > 0 && supportsMips ) {
					for ( var i = 0, il = mipmaps.length; i  0 && supportsMips ) {
					for ( var i = 0, il = mipmaps.length; i = 0 ) {
					var geometryAttribute = geometryAttributes[ name ];
					if ( geometryAttribute !== undefined ) {
						var normalized = geometryAttribute.normalized;
						var size = geometryAttribute.itemSize;
						var attribute = attributes.get( geometryAttribute );
						// TODO Attribute may not be available on context restore
						if ( attribute === undefined ) { continue; }
						var buffer = attribute.buffer;
						var type = attribute.type;
						var bytesPerElement = attribute.bytesPerElement;
						if ( geometryAttribute.isInterleavedBufferAttribute ) {
							var data = geometryAttribute.data;
							var stride = data.stride;
							var offset = geometryAttribute.offset;
							if ( data && data.isInstancedInterleavedBuffer ) {
								state.enableAttributeAndDivisor( programAttribute, data.meshPerAttribute );
								if ( geometry.maxInstancedCount === undefined ) {
									geometry.maxInstancedCount = data.meshPerAttribute * data.count;
								}
							} else {
								state.enableAttribute( programAttribute );
							}
							_gl.bindBuffer( 34962, buffer );
							state.vertexAttribPointer( programAttribute, size, type, normalized, stride * bytesPerElement, offset * bytesPerElement );
						} else {
							if ( geometryAttribute.isInstancedBufferAttribute ) {
								state.enableAttributeAndDivisor( programAttribute, geometryAttribute.meshPerAttribute );
								if ( geometry.maxInstancedCount === undefined ) {
									geometry.maxInstancedCount = geometryAttribute.meshPerAttribute * geometryAttribute.count;
								}
							} else {
								state.enableAttribute( programAttribute );
							}
							_gl.bindBuffer( 34962, buffer );
							state.vertexAttribPointer( programAttribute, size, type, normalized, 0, 0 );
						}
					} else if ( name === 'instanceMatrix' ) {
						var attribute = attributes.get( object.instanceMatrix );
						// TODO Attribute may not be available on context restore
						if ( attribute === undefined ) { continue; }
						var buffer = attribute.buffer;
						var type = attribute.type;
						state.enableAttributeAndDivisor( programAttribute + 0, 1 );
						state.enableAttributeAndDivisor( programAttribute + 1, 1 );
						state.enableAttributeAndDivisor( programAttribute + 2, 1 );
						state.enableAttributeAndDivisor( programAttribute + 3, 1 );
						_gl.bindBuffer( 34962, buffer );
						_gl.vertexAttribPointer( programAttribute + 0, 4, type, false, 64, 0 );
						_gl.vertexAttribPointer( programAttribute + 1, 4, type, false, 64, 16 );
						_gl.vertexAttribPointer( programAttribute + 2, 4, type, false, 64, 32 );
						_gl.vertexAttribPointer( programAttribute + 3, 4, type, false, 64, 48 );
					} else if ( materialDefaultAttributeValues !== undefined ) {
						var value = materialDefaultAttributeValues[ name ];
						if ( value !== undefined ) {
							switch ( value.length ) {
								case 2:
									_gl.vertexAttrib2fv( programAttribute, value );
									break;
								case 3:
									_gl.vertexAttrib3fv( programAttribute, value );
									break;
								case 4:
									_gl.vertexAttrib4fv( programAttribute, value );
									break;
								default:
									_gl.vertexAttrib1fv( programAttribute, value );
							}
						}
					}
				}
			}
			state.disableUnusedAttributes();
		}
		// Compile
		this.compile = function ( scene, camera ) {
			currentRenderState = renderStates.get( scene, camera );
			currentRenderState.init();
			scene.traverse( function ( object ) {
				if ( object.isLight ) {
					currentRenderState.pushLight( object );
					if ( object.castShadow ) {
						currentRenderState.pushShadow( object );
					}
				}
			} );
			currentRenderState.setupLights( camera );
			var compiled = {};
			scene.traverse( function ( object ) {
				if ( object.material ) {
					if ( Array.isArray( object.material ) ) {
						for ( var i = 0; i = 0 ) {
						material.numSupportedMorphTargets ++;
					}
				}
			}
			if ( material.morphNormals ) {
				material.numSupportedMorphNormals = 0;
				for ( var i = 0; i = 0 ) {
						material.numSupportedMorphNormals ++;
					}
				}
			}
			var uniforms = materialProperties.uniforms;
			if ( ! material.isShaderMaterial &&
				! material.isRawShaderMaterial ||
				material.clipping === true ) {
				materialProperties.numClippingPlanes = _clipping.numPlanes;
				materialProperties.numIntersection = _clipping.numIntersection;
				uniforms.clippingPlanes = _clipping.uniform;
			}
			materialProperties.environment = material.isMeshStandardMaterial ? scene.environment : null;
			materialProperties.fog = scene.fog;
			// store the light setup it was created for
			materialProperties.needsLights = materialNeedsLights( material );
			materialProperties.lightsStateVersion = lightsStateVersion;
			if ( materialProperties.needsLights ) {
				// wire up the material to this renderer's lighting state
				uniforms.ambientLightColor.value = lights.state.ambient;
				uniforms.lightProbe.value = lights.state.probe;
				uniforms.directionalLights.value = lights.state.directional;
				uniforms.directionalLightShadows.value = lights.state.directionalShadow;
				uniforms.spotLights.value = lights.state.spot;
				uniforms.spotLightShadows.value = lights.state.spotShadow;
				uniforms.rectAreaLights.value = lights.state.rectArea;
				uniforms.pointLights.value = lights.state.point;
				uniforms.pointLightShadows.value = lights.state.pointShadow;
				uniforms.hemisphereLights.value = lights.state.hemi;
				uniforms.directionalShadowMap.value = lights.state.directionalShadowMap;
				uniforms.directionalShadowMatrix.value = lights.state.directionalShadowMatrix;
				uniforms.spotShadowMap.value = lights.state.spotShadowMap;
				uniforms.spotShadowMatrix.value = lights.state.spotShadowMatrix;
				uniforms.pointShadowMap.value = lights.state.pointShadowMap;
				uniforms.pointShadowMatrix.value = lights.state.pointShadowMatrix;
				// TODO (abelnation): add area lights shadow info to uniforms
			}
			var progUniforms = materialProperties.program.getUniforms(),
				uniformsList =
					WebGLUniforms.seqWithValue( progUniforms.seq, uniforms );
			materialProperties.uniformsList = uniformsList;
		}
		function setProgram( camera, scene, material, object ) {
			textures.resetTextureUnits();
			var fog = scene.fog;
			var environment = material.isMeshStandardMaterial ? scene.environment : null;
			var encoding = ( _currentRenderTarget === null ) ? _this.outputEncoding : _currentRenderTarget.texture.encoding;
			var materialProperties = properties.get( material );
			var lights = currentRenderState.state.lights;
			if ( _clippingEnabled ) {
				if ( _localClippingEnabled || camera !== _currentCamera ) {
					var useCache =
						camera === _currentCamera &&
						material.id === _currentMaterialId;
					// we might want to call this function with some ClippingGroup
					// object instead of the material, once it becomes feasible
					// (#8465, #8379)
					_clipping.setState(
						material.clippingPlanes, material.clipIntersection, material.clipShadows,
						camera, materialProperties, useCache );
				}
			}
			if ( material.version === materialProperties.__version ) {
				if ( materialProperties.program === undefined ) {
					initMaterial( material, scene, object );
				} else if ( material.fog && materialProperties.fog !== fog ) {
					initMaterial( material, scene, object );
				} else if ( materialProperties.environment !== environment ) {
					initMaterial( material, scene, object );
				} else if ( materialProperties.needsLights && ( materialProperties.lightsStateVersion !== lights.state.version ) ) {
					initMaterial( material, scene, object );
				} else if ( materialProperties.numClippingPlanes !== undefined &&
					( materialProperties.numClippingPlanes !== _clipping.numPlanes ||
					materialProperties.numIntersection !== _clipping.numIntersection ) ) {
					initMaterial( material, scene, object );
				} else if ( materialProperties.outputEncoding !== encoding ) {
					initMaterial( material, scene, object );
				}
			} else {
				initMaterial( material, scene, object );
				materialProperties.__version = material.version;
			}
			var refreshProgram = false;
			var refreshMaterial = false;
			var refreshLights = false;
			var program = materialProperties.program,
				p_uniforms = program.getUniforms(),
				m_uniforms = materialProperties.uniforms;
			if ( state.useProgram( program.program ) ) {
				refreshProgram = true;
				refreshMaterial = true;
				refreshLights = true;
			}
			if ( material.id !== _currentMaterialId ) {
				_currentMaterialId = material.id;
				refreshMaterial = true;
			}
			if ( refreshProgram || _currentCamera !== camera ) {
				p_uniforms.setValue( _gl, 'projectionMatrix', camera.projectionMatrix );
				if ( capabilities.logarithmicDepthBuffer ) {
					p_uniforms.setValue( _gl, 'logDepthBufFC',
						2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );
				}
				if ( _currentCamera !== camera ) {
					_currentCamera = camera;
					// lighting uniforms depend on the camera so enforce an update
					// now, in case this material supports lights - or later, when
					// the next material that does gets activated:
					refreshMaterial = true;		// set to true on material change
					refreshLights = true;		// remains set until update done
				}
				// load material specific uniforms
				// (shader material also gets them for the sake of genericity)
				if ( material.isShaderMaterial ||
					material.isMeshPhongMaterial ||
					material.isMeshToonMaterial ||
					material.isMeshStandardMaterial ||
					material.envMap ) {
					var uCamPos = p_uniforms.map.cameraPosition;
					if ( uCamPos !== undefined ) {
						uCamPos.setValue( _gl,
							_vector3.setFromMatrixPosition( camera.matrixWorld ) );
					}
				}
				if ( material.isMeshPhongMaterial ||
					material.isMeshToonMaterial ||
					material.isMeshLambertMaterial ||
					material.isMeshBasicMaterial ||
					material.isMeshStandardMaterial ||
					material.isShaderMaterial ) {
					p_uniforms.setValue( _gl, 'isOrthographic', camera.isOrthographicCamera === true );
				}
				if ( material.isMeshPhongMaterial ||
					material.isMeshToonMaterial ||
					material.isMeshLambertMaterial ||
					material.isMeshBasicMaterial ||
					material.isMeshStandardMaterial ||
					material.isShaderMaterial ||
					material.skinning ) {
					p_uniforms.setValue( _gl, 'viewMatrix', camera.matrixWorldInverse );
				}
			}
			// skinning uniforms must be set even if material didn't change
			// auto-setting of texture unit for bone texture must go before other textures
			// otherwise textures used for skinning can take over texture units reserved for other material textures
			if ( material.skinning ) {
				p_uniforms.setOptional( _gl, object, 'bindMatrix' );
				p_uniforms.setOptional( _gl, object, 'bindMatrixInverse' );
				var skeleton = object.skeleton;
				if ( skeleton ) {
					var bones = skeleton.bones;
					if ( capabilities.floatVertexTextures ) {
						if ( skeleton.boneTexture === undefined ) {
							// layout (1 matrix = 4 pixels)
							//      RGBA RGBA RGBA RGBA (=> column1, column2, column3, column4)
							//  with  8x8  pixel texture max   16 bones * 4 pixels =  (8 * 8)
							//       16x16 pixel texture max   64 bones * 4 pixels = (16 * 16)
							//       32x32 pixel texture max  256 bones * 4 pixels = (32 * 32)
							//       64x64 pixel texture max 1024 bones * 4 pixels = (64 * 64)
							var size = Math.sqrt( bones.length * 4 ); // 4 pixels needed for 1 matrix
							size = MathUtils.ceilPowerOfTwo( size );
							size = Math.max( size, 4 );
							var boneMatrices = new Float32Array( size * size * 4 ); // 4 floats per RGBA pixel
							boneMatrices.set( skeleton.boneMatrices ); // copy current values
							var boneTexture = new DataTexture( boneMatrices, size, size, RGBAFormat, FloatType );
							skeleton.boneMatrices = boneMatrices;
							skeleton.boneTexture = boneTexture;
							skeleton.boneTextureSize = size;
						}
						p_uniforms.setValue( _gl, 'boneTexture', skeleton.boneTexture, textures );
						p_uniforms.setValue( _gl, 'boneTextureSize', skeleton.boneTextureSize );
					} else {
						p_uniforms.setOptional( _gl, skeleton, 'boneMatrices' );
					}
				}
			}
			if ( refreshMaterial || materialProperties.receiveShadow !== object.receiveShadow ) {
				materialProperties.receiveShadow = object.receiveShadow;
				p_uniforms.setValue( _gl, 'receiveShadow', object.receiveShadow );
			}
			if ( refreshMaterial ) {
				p_uniforms.setValue( _gl, 'toneMappingExposure', _this.toneMappingExposure );
				p_uniforms.setValue( _gl, 'toneMappingWhitePoint', _this.toneMappingWhitePoint );
				if ( materialProperties.needsLights ) {
					// the current material requires lighting info
					// note: all lighting uniforms are always set correctly
					// they simply reference the renderer's state for their
					// values
					//
					// use the current material's .needsUpdate flags to set
					// the GL state when required
					markUniformsLightsNeedsUpdate( m_uniforms, refreshLights );
				}
				// refresh uniforms common to several materials
				if ( fog && material.fog ) {
					refreshUniformsFog( m_uniforms, fog );
				}
				if ( material.isMeshBasicMaterial ) {
					refreshUniformsCommon( m_uniforms, material );
				} else if ( material.isMeshLambertMaterial ) {
					refreshUniformsCommon( m_uniforms, material );
					refreshUniformsLambert( m_uniforms, material );
				} else if ( material.isMeshToonMaterial ) {
					refreshUniformsCommon( m_uniforms, material );
					refreshUniformsToon( m_uniforms, material );
				} else if ( material.isMeshPhongMaterial ) {
					refreshUniformsCommon( m_uniforms, material );
					refreshUniformsPhong( m_uniforms, material );
				} else if ( material.isMeshStandardMaterial ) {
					refreshUniformsCommon( m_uniforms, material, environment );
					if ( material.isMeshPhysicalMaterial ) {
						refreshUniformsPhysical( m_uniforms, material, environment );
					} else {
						refreshUniformsStandard( m_uniforms, material, environment );
					}
				} else if ( material.isMeshMatcapMaterial ) {
					refreshUniformsCommon( m_uniforms, material );
					refreshUniformsMatcap( m_uniforms, material );
				} else if ( material.isMeshDepthMaterial ) {
					refreshUniformsCommon( m_uniforms, material );
					refreshUniformsDepth( m_uniforms, material );
				} else if ( material.isMeshDistanceMaterial ) {
					refreshUniformsCommon( m_uniforms, material );
					refreshUniformsDistance( m_uniforms, material );
				} else if ( material.isMeshNormalMaterial ) {
					refreshUniformsCommon( m_uniforms, material );
					refreshUniformsNormal( m_uniforms, material );
				} else if ( material.isLineBasicMaterial ) {
					refreshUniformsLine( m_uniforms, material );
					if ( material.isLineDashedMaterial ) {
						refreshUniformsDash( m_uniforms, material );
					}
				} else if ( material.isPointsMaterial ) {
					refreshUniformsPoints( m_uniforms, material );
				} else if ( material.isSpriteMaterial ) {
					refreshUniformsSprites( m_uniforms, material );
				} else if ( material.isShadowMaterial ) {
					m_uniforms.color.value.copy( material.color );
					m_uniforms.opacity.value = material.opacity;
				}
				// RectAreaLight Texture
				// TODO (mrdoob): Find a nicer implementation
				if ( m_uniforms.ltc_1 !== undefined ) { m_uniforms.ltc_1.value = UniformsLib.LTC_1; }
				if ( m_uniforms.ltc_2 !== undefined ) { m_uniforms.ltc_2.value = UniformsLib.LTC_2; }
				WebGLUniforms.upload( _gl, materialProperties.uniformsList, m_uniforms, textures );
				if ( material.isShaderMaterial ) {
					material.uniformsNeedUpdate = false; // #15581
				}
			}
			if ( material.isShaderMaterial && material.uniformsNeedUpdate === true ) {
				WebGLUniforms.upload( _gl, materialProperties.uniformsList, m_uniforms, textures );
				material.uniformsNeedUpdate = false;
			}
			if ( material.isSpriteMaterial ) {
				p_uniforms.setValue( _gl, 'center', object.center );
			}
			// common matrices
			p_uniforms.setValue( _gl, 'modelViewMatrix', object.modelViewMatrix );
			p_uniforms.setValue( _gl, 'normalMatrix', object.normalMatrix );
			p_uniforms.setValue( _gl, 'modelMatrix', object.matrixWorld );
			return program;
		}
		// Uniforms (refresh uniforms objects)
		function refreshUniformsCommon( uniforms, material, environment ) {
			uniforms.opacity.value = material.opacity;
			if ( material.color ) {
				uniforms.diffuse.value.copy( material.color );
			}
			if ( material.emissive ) {
				uniforms.emissive.value.copy( material.emissive ).multiplyScalar( material.emissiveIntensity );
			}
			if ( material.map ) {
				uniforms.map.value = material.map;
			}
			if ( material.alphaMap ) {
				uniforms.alphaMap.value = material.alphaMap;
			}
			if ( material.specularMap ) {
				uniforms.specularMap.value = material.specularMap;
			}
			var envMap = material.envMap || environment;
			if ( envMap ) {
				uniforms.envMap.value = envMap;
				uniforms.flipEnvMap.value = envMap.isCubeTexture ? - 1 : 1;
				uniforms.reflectivity.value = material.reflectivity;
				uniforms.refractionRatio.value = material.refractionRatio;
				uniforms.maxMipLevel.value = properties.get( envMap ).__maxMipLevel;
			}
			if ( material.lightMap ) {
				uniforms.lightMap.value = material.lightMap;
				uniforms.lightMapIntensity.value = material.lightMapIntensity;
			}
			if ( material.aoMap ) {
				uniforms.aoMap.value = material.aoMap;
				uniforms.aoMapIntensity.value = material.aoMapIntensity;
			}
			// uv repeat and offset setting priorities
			// 1. color map
			// 2. specular map
			// 3. normal map
			// 4. bump map
			// 5. alpha map
			// 6. emissive map
			var uvScaleMap;
			if ( material.map ) {
				uvScaleMap = material.map;
			} else if ( material.specularMap ) {
				uvScaleMap = material.specularMap;
			} else if ( material.displacementMap ) {
				uvScaleMap = material.displacementMap;
			} else if ( material.normalMap ) {
				uvScaleMap = material.normalMap;
			} else if ( material.bumpMap ) {
				uvScaleMap = material.bumpMap;
			} else if ( material.roughnessMap ) {
				uvScaleMap = material.roughnessMap;
			} else if ( material.metalnessMap ) {
				uvScaleMap = material.metalnessMap;
			} else if ( material.alphaMap ) {
				uvScaleMap = material.alphaMap;
			} else if ( material.emissiveMap ) {
				uvScaleMap = material.emissiveMap;
			}
			if ( uvScaleMap !== undefined ) {
				// backwards compatibility
				if ( uvScaleMap.isWebGLRenderTarget ) {
					uvScaleMap = uvScaleMap.texture;
				}
				if ( uvScaleMap.matrixAutoUpdate === true ) {
					uvScaleMap.updateMatrix();
				}
				uniforms.uvTransform.value.copy( uvScaleMap.matrix );
			}
			// uv repeat and offset setting priorities for uv2
			// 1. ao map
			// 2. light map
			var uv2ScaleMap;
			if ( material.aoMap ) {
				uv2ScaleMap = material.aoMap;
			} else if ( material.lightMap ) {
				uv2ScaleMap = material.lightMap;
			}
			if ( uv2ScaleMap !== undefined ) {
				// backwards compatibility
				if ( uv2ScaleMap.isWebGLRenderTarget ) {
					uv2ScaleMap = uv2ScaleMap.texture;
				}
				if ( uv2ScaleMap.matrixAutoUpdate === true ) {
					uv2ScaleMap.updateMatrix();
				}
				uniforms.uv2Transform.value.copy( uv2ScaleMap.matrix );
			}
		}
		function refreshUniformsLine( uniforms, material ) {
			uniforms.diffuse.value.copy( material.color );
			uniforms.opacity.value = material.opacity;
		}
		function refreshUniformsDash( uniforms, material ) {
			uniforms.dashSize.value = material.dashSize;
			uniforms.totalSize.value = material.dashSize + material.gapSize;
			uniforms.scale.value = material.scale;
		}
		function refreshUniformsPoints( uniforms, material ) {
			uniforms.diffuse.value.copy( material.color );
			uniforms.opacity.value = material.opacity;
			uniforms.size.value = material.size * _pixelRatio;
			uniforms.scale.value = _height * 0.5;
			if ( material.map ) {
				uniforms.map.value = material.map;
			}
			if ( material.alphaMap ) {
				uniforms.alphaMap.value = material.alphaMap;
			}
			// uv repeat and offset setting priorities
			// 1. color map
			// 2. alpha map
			var uvScaleMap;
			if ( material.map ) {
				uvScaleMap = material.map;
			} else if ( material.alphaMap ) {
				uvScaleMap = material.alphaMap;
			}
			if ( uvScaleMap !== undefined ) {
				if ( uvScaleMap.matrixAutoUpdate === true ) {
					uvScaleMap.updateMatrix();
				}
				uniforms.uvTransform.value.copy( uvScaleMap.matrix );
			}
		}
		function refreshUniformsSprites( uniforms, material ) {
			uniforms.diffuse.value.copy( material.color );
			uniforms.opacity.value = material.opacity;
			uniforms.rotation.value = material.rotation;
			if ( material.map ) {
				uniforms.map.value = material.map;
			}
			if ( material.alphaMap ) {
				uniforms.alphaMap.value = material.alphaMap;
			}
			// uv repeat and offset setting priorities
			// 1. color map
			// 2. alpha map
			var uvScaleMap;
			if ( material.map ) {
				uvScaleMap = material.map;
			} else if ( material.alphaMap ) {
				uvScaleMap = material.alphaMap;
			}
			if ( uvScaleMap !== undefined ) {
				if ( uvScaleMap.matrixAutoUpdate === true ) {
					uvScaleMap.updateMatrix();
				}
				uniforms.uvTransform.value.copy( uvScaleMap.matrix );
			}
		}
		function refreshUniformsFog( uniforms, fog ) {
			uniforms.fogColor.value.copy( fog.color );
			if ( fog.isFog ) {
				uniforms.fogNear.value = fog.near;
				uniforms.fogFar.value = fog.far;
			} else if ( fog.isFogExp2 ) {
				uniforms.fogDensity.value = fog.density;
			}
		}
		function refreshUniformsLambert( uniforms, material ) {
			if ( material.emissiveMap ) {
				uniforms.emissiveMap.value = material.emissiveMap;
			}
		}
		function refreshUniformsPhong( uniforms, material ) {
			uniforms.specular.value.copy( material.specular );
			uniforms.shininess.value = Math.max( material.shininess, 1e-4 ); // to prevent pow( 0.0, 0.0 )
			if ( material.emissiveMap ) {
				uniforms.emissiveMap.value = material.emissiveMap;
			}
			if ( material.bumpMap ) {
				uniforms.bumpMap.value = material.bumpMap;
				uniforms.bumpScale.value = material.bumpScale;
				if ( material.side === BackSide ) { uniforms.bumpScale.value *= - 1; }
			}
			if ( material.normalMap ) {
				uniforms.normalMap.value = material.normalMap;
				uniforms.normalScale.value.copy( material.normalScale );
				if ( material.side === BackSide ) { uniforms.normalScale.value.negate(); }
			}
			if ( material.displacementMap ) {
				uniforms.displacementMap.value = material.displacementMap;
				uniforms.displacementScale.value = material.displacementScale;
				uniforms.displacementBias.value = material.displacementBias;
			}
		}
		function refreshUniformsToon( uniforms, material ) {
			uniforms.specular.value.copy( material.specular );
			uniforms.shininess.value = Math.max( material.shininess, 1e-4 ); // to prevent pow( 0.0, 0.0 )
			if ( material.gradientMap ) {
				uniforms.gradientMap.value = material.gradientMap;
			}
			if ( material.emissiveMap ) {
				uniforms.emissiveMap.value = material.emissiveMap;
			}
			if ( material.bumpMap ) {
				uniforms.bumpMap.value = material.bumpMap;
				uniforms.bumpScale.value = material.bumpScale;
				if ( material.side === BackSide ) { uniforms.bumpScale.value *= - 1; }
			}
			if ( material.normalMap ) {
				uniforms.normalMap.value = material.normalMap;
				uniforms.normalScale.value.copy( material.normalScale );
				if ( material.side === BackSide ) { uniforms.normalScale.value.negate(); }
			}
			if ( material.displacementMap ) {
				uniforms.displacementMap.value = material.displacementMap;
				uniforms.displacementScale.value = material.displacementScale;
				uniforms.displacementBias.value = material.displacementBias;
			}
		}
		function refreshUniformsStandard( uniforms, material, environment ) {
			uniforms.roughness.value = material.roughness;
			uniforms.metalness.value = material.metalness;
			if ( material.roughnessMap ) {
				uniforms.roughnessMap.value = material.roughnessMap;
			}
			if ( material.metalnessMap ) {
				uniforms.metalnessMap.value = material.metalnessMap;
			}
			if ( material.emissiveMap ) {
				uniforms.emissiveMap.value = material.emissiveMap;
			}
			if ( material.bumpMap ) {
				uniforms.bumpMap.value = material.bumpMap;
				uniforms.bumpScale.value = material.bumpScale;
				if ( material.side === BackSide ) { uniforms.bumpScale.value *= - 1; }
			}
			if ( material.normalMap ) {
				uniforms.normalMap.value = material.normalMap;
				uniforms.normalScale.value.copy( material.normalScale );
				if ( material.side === BackSide ) { uniforms.normalScale.value.negate(); }
			}
			if ( material.displacementMap ) {
				uniforms.displacementMap.value = material.displacementMap;
				uniforms.displacementScale.value = material.displacementScale;
				uniforms.displacementBias.value = material.displacementBias;
			}
			if ( material.envMap || environment ) {
				//uniforms.envMap.value = material.envMap; // part of uniforms common
				uniforms.envMapIntensity.value = material.envMapIntensity;
			}
		}
		function refreshUniformsPhysical( uniforms, material, environment ) {
			refreshUniformsStandard( uniforms, material, environment );
			uniforms.reflectivity.value = material.reflectivity; // also part of uniforms common
			uniforms.clearcoat.value = material.clearcoat;
			uniforms.clearcoatRoughness.value = material.clearcoatRoughness;
			if ( material.sheen ) { uniforms.sheen.value.copy( material.sheen ); }
			if ( material.clearcoatMap ) {
				uniforms.clearcoatMap.value = material.clearcoatMap;
			}
			if ( material.clearcoatRoughnessMap ) {
				uniforms.clearcoatRoughnessMap.value = material.clearcoatRoughnessMap;
			}
			if ( material.clearcoatNormalMap ) {
				uniforms.clearcoatNormalScale.value.copy( material.clearcoatNormalScale );
				uniforms.clearcoatNormalMap.value = material.clearcoatNormalMap;
				if ( material.side === BackSide ) {
					uniforms.clearcoatNormalScale.value.negate();
				}
			}
			uniforms.transparency.value = material.transparency;
		}
		function refreshUniformsMatcap( uniforms, material ) {
			if ( material.matcap ) {
				uniforms.matcap.value = material.matcap;
			}
			if ( material.bumpMap ) {
				uniforms.bumpMap.value = material.bumpMap;
				uniforms.bumpScale.value = material.bumpScale;
				if ( material.side === BackSide ) { uniforms.bumpScale.value *= - 1; }
			}
			if ( material.normalMap ) {
				uniforms.normalMap.value = material.normalMap;
				uniforms.normalScale.value.copy( material.normalScale );
				if ( material.side === BackSide ) { uniforms.normalScale.value.negate(); }
			}
			if ( material.displacementMap ) {
				uniforms.displacementMap.value = material.displacementMap;
				uniforms.displacementScale.value = material.displacementScale;
				uniforms.displacementBias.value = material.displacementBias;
			}
		}
		function refreshUniformsDepth( uniforms, material ) {
			if ( material.displacementMap ) {
				uniforms.displacementMap.value = material.displacementMap;
				uniforms.displacementScale.value = material.displacementScale;
				uniforms.displacementBias.value = material.displacementBias;
			}
		}
		function refreshUniformsDistance( uniforms, material ) {
			if ( material.displacementMap ) {
				uniforms.displacementMap.value = material.displacementMap;
				uniforms.displacementScale.value = material.displacementScale;
				uniforms.displacementBias.value = material.displacementBias;
			}
			uniforms.referencePosition.value.copy( material.referencePosition );
			uniforms.nearDistance.value = material.nearDistance;
			uniforms.farDistance.value = material.farDistance;
		}
		function refreshUniformsNormal( uniforms, material ) {
			if ( material.bumpMap ) {
				uniforms.bumpMap.value = material.bumpMap;
				uniforms.bumpScale.value = material.bumpScale;
				if ( material.side === BackSide ) { uniforms.bumpScale.value *= - 1; }
			}
			if ( material.normalMap ) {
				uniforms.normalMap.value = material.normalMap;
				uniforms.normalScale.value.copy( material.normalScale );
				if ( material.side === BackSide ) { uniforms.normalScale.value.negate(); }
			}
			if ( material.displacementMap ) {
				uniforms.displacementMap.value = material.displacementMap;
				uniforms.displacementScale.value = material.displacementScale;
				uniforms.displacementBias.value = material.displacementBias;
			}
		}
		// If uniforms are marked as clean, they don't need to be loaded to the GPU.
		function markUniformsLightsNeedsUpdate( uniforms, value ) {
			uniforms.ambientLightColor.needsUpdate = value;
			uniforms.lightProbe.needsUpdate = value;
			uniforms.directionalLights.needsUpdate = value;
			uniforms.directionalLightShadows.needsUpdate = value;
			uniforms.pointLights.needsUpdate = value;
			uniforms.pointLightShadows.needsUpdate = value;
			uniforms.spotLights.needsUpdate = value;
			uniforms.spotLightShadows.needsUpdate = value;
			uniforms.rectAreaLights.needsUpdate = value;
			uniforms.hemisphereLights.needsUpdate = value;
		}
		function materialNeedsLights( material ) {
			return material.isMeshLambertMaterial || material.isMeshToonMaterial || material.isMeshPhongMaterial ||
				material.isMeshStandardMaterial || material.isShadowMaterial ||
				( material.isShaderMaterial && material.lights === true );
		}
		//
		this.setFramebuffer = function ( value ) {
			if ( _framebuffer !== value && _currentRenderTarget === null ) { _gl.bindFramebuffer( 36160, value ); }
			_framebuffer = value;
		};
		this.getActiveCubeFace = function () {
			return _currentActiveCubeFace;
		};
		this.getActiveMipmapLevel = function () {
			return _currentActiveMipmapLevel;
		};
		this.getRenderTarget = function () {
			return _currentRenderTarget;
		};
		this.setRenderTarget = function ( renderTarget, activeCubeFace, activeMipmapLevel ) {
			_currentRenderTarget = renderTarget;
			_currentActiveCubeFace = activeCubeFace;
			_currentActiveMipmapLevel = activeMipmapLevel;
			if ( renderTarget && properties.get( renderTarget ).__webglFramebuffer === undefined ) {
				textures.setupRenderTarget( renderTarget );
			}
			var framebuffer = _framebuffer;
			var isCube = false;
			if ( renderTarget ) {
				var __webglFramebuffer = properties.get( renderTarget ).__webglFramebuffer;
				if ( renderTarget.isWebGLCubeRenderTarget ) {
					framebuffer = __webglFramebuffer[ activeCubeFace || 0 ];
					isCube = true;
				} else if ( renderTarget.isWebGLMultisampleRenderTarget ) {
					framebuffer = properties.get( renderTarget ).__webglMultisampledFramebuffer;
				} else {
					framebuffer = __webglFramebuffer;
				}
				_currentViewport.copy( renderTarget.viewport );
				_currentScissor.copy( renderTarget.scissor );
				_currentScissorTest = renderTarget.scissorTest;
			} else {
				_currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ).floor();
				_currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ).floor();
				_currentScissorTest = _scissorTest;
			}
			if ( _currentFramebuffer !== framebuffer ) {
				_gl.bindFramebuffer( 36160, framebuffer );
				_currentFramebuffer = framebuffer;
			}
			state.viewport( _currentViewport );
			state.scissor( _currentScissor );
			state.setScissorTest( _currentScissorTest );
			if ( isCube ) {
				var textureProperties = properties.get( renderTarget.texture );
				_gl.framebufferTexture2D( 36160, 36064, 34069 + ( activeCubeFace || 0 ), textureProperties.__webglTexture, activeMipmapLevel || 0 );
			}
		};
		this.readRenderTargetPixels = function ( renderTarget, x, y, width, height, buffer, activeCubeFaceIndex ) {
			if ( ! ( renderTarget && renderTarget.isWebGLRenderTarget ) ) {
				console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.' );
				return;
			}
			var framebuffer = properties.get( renderTarget ).__webglFramebuffer;
			if ( renderTarget.isWebGLCubeRenderTarget && activeCubeFaceIndex !== undefined ) {
				framebuffer = framebuffer[ activeCubeFaceIndex ];
			}
			if ( framebuffer ) {
				var restore = false;
				if ( framebuffer !== _currentFramebuffer ) {
					_gl.bindFramebuffer( 36160, framebuffer );
					restore = true;
				}
				try {
					var texture = renderTarget.texture;
					var textureFormat = texture.format;
					var textureType = texture.type;
					if ( textureFormat !== RGBAFormat && utils.convert( textureFormat ) !== _gl.getParameter( 35739 ) ) {
						console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.' );
						return;
					}
					if ( textureType !== UnsignedByteType && utils.convert( textureType ) !== _gl.getParameter( 35738 ) && // IE11, Edge and Chrome Mac = 52 and Firefox
						! ( textureType === HalfFloatType && ( capabilities.isWebGL2 ? extensions.get( 'EXT_color_buffer_float' ) : extensions.get( 'EXT_color_buffer_half_float' ) ) ) ) {
						console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in UnsignedByteType or implementation defined type.' );
						return;
					}
					if ( _gl.checkFramebufferStatus( 36160 ) === 36053 ) {
						// the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)
						if ( ( x >= 0 && x = 0 && y ,
	 *  map: new THREE.Texture(  ),
	 *  alphaMap: new THREE.Texture(  ),
	 *  rotation: ,
	 *  sizeAttenuation: 
	 * }
	 */
	function SpriteMaterial( parameters ) {
		Material.call( this );
		this.type = 'SpriteMaterial';
		this.color = new Color( 0xffffff );
		this.map = null;
		this.alphaMap = null;
		this.rotation = 0;
		this.sizeAttenuation = true;
		this.transparent = true;
		this.setValues( parameters );
	}
	SpriteMaterial.prototype = Object.create( Material.prototype );
	SpriteMaterial.prototype.constructor = SpriteMaterial;
	SpriteMaterial.prototype.isSpriteMaterial = true;
	SpriteMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.color.copy( source.color );
		this.map = source.map;
		this.alphaMap = source.alphaMap;
		this.rotation = source.rotation;
		this.sizeAttenuation = source.sizeAttenuation;
		return this;
	};
	/**
	 * @author mikael emtinger / http://gomo.se/
	 * @author alteredq / http://alteredqualia.com/
	 */
	var _geometry;
	var _intersectPoint = new Vector3();
	var _worldScale = new Vector3();
	var _mvPosition = new Vector3();
	var _alignedPosition = new Vector2();
	var _rotatedPosition = new Vector2();
	var _viewWorldMatrix = new Matrix4();
	var _vA$1 = new Vector3();
	var _vB$1 = new Vector3();
	var _vC$1 = new Vector3();
	var _uvA$1 = new Vector2();
	var _uvB$1 = new Vector2();
	var _uvC$1 = new Vector2();
	function Sprite( material ) {
		Object3D.call( this );
		this.type = 'Sprite';
		if ( _geometry === undefined ) {
			_geometry = new BufferGeometry();
			var float32Array = new Float32Array( [
				- 0.5, - 0.5, 0, 0, 0,
				0.5, - 0.5, 0, 1, 0,
				0.5, 0.5, 0, 1, 1,
				- 0.5, 0.5, 0, 0, 1
			] );
			var interleavedBuffer = new InterleavedBuffer( float32Array, 5 );
			_geometry.setIndex( [ 0, 1, 2,	0, 2, 3 ] );
			_geometry.setAttribute( 'position', new InterleavedBufferAttribute( interleavedBuffer, 3, 0, false ) );
			_geometry.setAttribute( 'uv', new InterleavedBufferAttribute( interleavedBuffer, 2, 3, false ) );
		}
		this.geometry = _geometry;
		this.material = ( material !== undefined ) ? material : new SpriteMaterial();
		this.center = new Vector2( 0.5, 0.5 );
	}
	Sprite.prototype = Object.assign( Object.create( Object3D.prototype ), {
		constructor: Sprite,
		isSprite: true,
		raycast: function ( raycaster, intersects ) {
			if ( raycaster.camera === null ) {
				console.error( 'THREE.Sprite: "Raycaster.camera" needs to be set in order to raycast against sprites.' );
			}
			_worldScale.setFromMatrixScale( this.matrixWorld );
			_viewWorldMatrix.copy( raycaster.camera.matrixWorld );
			this.modelViewMatrix.multiplyMatrices( raycaster.camera.matrixWorldInverse, this.matrixWorld );
			_mvPosition.setFromMatrixPosition( this.modelViewMatrix );
			if ( raycaster.camera.isPerspectiveCamera && this.material.sizeAttenuation === false ) {
				_worldScale.multiplyScalar( - _mvPosition.z );
			}
			var rotation = this.material.rotation;
			var sin, cos;
			if ( rotation !== 0 ) {
				cos = Math.cos( rotation );
				sin = Math.sin( rotation );
			}
			var center = this.center;
			transformVertex( _vA$1.set( - 0.5, - 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );
			transformVertex( _vB$1.set( 0.5, - 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );
			transformVertex( _vC$1.set( 0.5, 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );
			_uvA$1.set( 0, 0 );
			_uvB$1.set( 1, 0 );
			_uvC$1.set( 1, 1 );
			// check first triangle
			var intersect = raycaster.ray.intersectTriangle( _vA$1, _vB$1, _vC$1, false, _intersectPoint );
			if ( intersect === null ) {
				// check second triangle
				transformVertex( _vB$1.set( - 0.5, 0.5, 0 ), _mvPosition, center, _worldScale, sin, cos );
				_uvB$1.set( 0, 1 );
				intersect = raycaster.ray.intersectTriangle( _vA$1, _vC$1, _vB$1, false, _intersectPoint );
				if ( intersect === null ) {
					return;
				}
			}
			var distance = raycaster.ray.origin.distanceTo( _intersectPoint );
			if ( distance  raycaster.far ) { return; }
			intersects.push( {
				distance: distance,
				point: _intersectPoint.clone(),
				uv: Triangle.getUV( _intersectPoint, _vA$1, _vB$1, _vC$1, _uvA$1, _uvB$1, _uvC$1, new Vector2() ),
				face: null,
				object: this
			} );
		},
		clone: function () {
			return new this.constructor( this.material ).copy( this );
		},
		copy: function ( source ) {
			Object3D.prototype.copy.call( this, source );
			if ( source.center !== undefined ) { this.center.copy( source.center ); }
			return this;
		}
	} );
	function transformVertex( vertexPosition, mvPosition, center, scale, sin, cos ) {
		// compute position in camera space
		_alignedPosition.subVectors( vertexPosition, center ).addScalar( 0.5 ).multiply( scale );
		// to check if rotation is not zero
		if ( sin !== undefined ) {
			_rotatedPosition.x = ( cos * _alignedPosition.x ) - ( sin * _alignedPosition.y );
			_rotatedPosition.y = ( sin * _alignedPosition.x ) + ( cos * _alignedPosition.y );
		} else {
			_rotatedPosition.copy( _alignedPosition );
		}
		vertexPosition.copy( mvPosition );
		vertexPosition.x += _rotatedPosition.x;
		vertexPosition.y += _rotatedPosition.y;
		// transform to world space
		vertexPosition.applyMatrix4( _viewWorldMatrix );
	}
	/**
	 * @author mikael emtinger / http://gomo.se/
	 * @author alteredq / http://alteredqualia.com/
	 * @author mrdoob / http://mrdoob.com/
	 */
	var _v1$4 = new Vector3();
	var _v2$2 = new Vector3();
	function LOD() {
		Object3D.call( this );
		this._currentLevel = 0;
		this.type = 'LOD';
		Object.defineProperties( this, {
			levels: {
				enumerable: true,
				value: []
			}
		} );
		this.autoUpdate = true;
	}
	LOD.prototype = Object.assign( Object.create( Object3D.prototype ), {
		constructor: LOD,
		isLOD: true,
		copy: function ( source ) {
			Object3D.prototype.copy.call( this, source, false );
			var levels = source.levels;
			for ( var i = 0, l = levels.length; i  0 ) {
				for ( var i = 1, l = levels.length; i  0 ) {
				_v1$4.setFromMatrixPosition( this.matrixWorld );
				var distance = raycaster.ray.origin.distanceTo( _v1$4 );
				this.getObjectForDistance( distance ).raycast( raycaster, intersects );
			}
		},
		update: function ( camera ) {
			var levels = this.levels;
			if ( levels.length > 1 ) {
				_v1$4.setFromMatrixPosition( camera.matrixWorld );
				_v2$2.setFromMatrixPosition( this.matrixWorld );
				var distance = _v1$4.distanceTo( _v2$2 ) / camera.zoom;
				levels[ 0 ].object.visible = true;
				for ( var i = 1, l = levels.length; i = levels[ i ].distance ) {
						levels[ i - 1 ].object.visible = false;
						levels[ i ].object.visible = true;
					} else {
						break;
					}
				}
				this._currentLevel = i - 1;
				for ( ; i ,
	 *  opacity: ,
	 *
	 *  linewidth: ,
	 *  linecap: "round",
	 *  linejoin: "round"
	 * }
	 */
	function LineBasicMaterial( parameters ) {
		Material.call( this );
		this.type = 'LineBasicMaterial';
		this.color = new Color( 0xffffff );
		this.linewidth = 1;
		this.linecap = 'round';
		this.linejoin = 'round';
		this.setValues( parameters );
	}
	LineBasicMaterial.prototype = Object.create( Material.prototype );
	LineBasicMaterial.prototype.constructor = LineBasicMaterial;
	LineBasicMaterial.prototype.isLineBasicMaterial = true;
	LineBasicMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.color.copy( source.color );
		this.linewidth = source.linewidth;
		this.linecap = source.linecap;
		this.linejoin = source.linejoin;
		return this;
	};
	/**
	 * @author mrdoob / http://mrdoob.com/
	 */
	var _start = new Vector3();
	var _end = new Vector3();
	var _inverseMatrix$1 = new Matrix4();
	var _ray$1 = new Ray();
	var _sphere$2 = new Sphere();
	function Line( geometry, material, mode ) {
		if ( mode === 1 ) {
			console.error( 'THREE.Line: parameter THREE.LinePieces no longer supported. Use THREE.LineSegments instead.' );
		}
		Object3D.call( this );
		this.type = 'Line';
		this.geometry = geometry !== undefined ? geometry : new BufferGeometry();
		this.material = material !== undefined ? material : new LineBasicMaterial();
	}
	Line.prototype = Object.assign( Object.create( Object3D.prototype ), {
		constructor: Line,
		isLine: true,
		computeLineDistances: function () {
			var geometry = this.geometry;
			if ( geometry.isBufferGeometry ) {
				// we assume non-indexed geometry
				if ( geometry.index === null ) {
					var positionAttribute = geometry.attributes.position;
					var lineDistances = [ 0 ];
					for ( var i = 1, l = positionAttribute.count; i  localThresholdSq ) { continue; }
						interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
						var distance = raycaster.ray.origin.distanceTo( interRay );
						if ( distance  raycaster.far ) { continue; }
						intersects.push( {
							distance: distance,
							// What do we want? intersection point on the ray or on the segment??
							// point: raycaster.ray.at( distance ),
							point: interSegment.clone().applyMatrix4( this.matrixWorld ),
							index: i,
							face: null,
							faceIndex: null,
							object: this
						} );
					}
				} else {
					for ( var i = 0, l = positions.length / 3 - 1; i  localThresholdSq ) { continue; }
						interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
						var distance = raycaster.ray.origin.distanceTo( interRay );
						if ( distance  raycaster.far ) { continue; }
						intersects.push( {
							distance: distance,
							// What do we want? intersection point on the ray or on the segment??
							// point: raycaster.ray.at( distance ),
							point: interSegment.clone().applyMatrix4( this.matrixWorld ),
							index: i,
							face: null,
							faceIndex: null,
							object: this
						} );
					}
				}
			} else if ( geometry.isGeometry ) {
				var vertices = geometry.vertices;
				var nbVertices = vertices.length;
				for ( var i = 0; i  localThresholdSq ) { continue; }
					interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
					var distance = raycaster.ray.origin.distanceTo( interRay );
					if ( distance  raycaster.far ) { continue; }
					intersects.push( {
						distance: distance,
						// What do we want? intersection point on the ray or on the segment??
						// point: raycaster.ray.at( distance ),
						point: interSegment.clone().applyMatrix4( this.matrixWorld ),
						index: i,
						face: null,
						faceIndex: null,
						object: this
					} );
				}
			}
		},
		clone: function () {
			return new this.constructor( this.geometry, this.material ).copy( this );
		}
	} );
	/**
	 * @author mrdoob / http://mrdoob.com/
	 */
	var _start$1 = new Vector3();
	var _end$1 = new Vector3();
	function LineSegments( geometry, material ) {
		Line.call( this, geometry, material );
		this.type = 'LineSegments';
	}
	LineSegments.prototype = Object.assign( Object.create( Line.prototype ), {
		constructor: LineSegments,
		isLineSegments: true,
		computeLineDistances: function () {
			var geometry = this.geometry;
			if ( geometry.isBufferGeometry ) {
				// we assume non-indexed geometry
				if ( geometry.index === null ) {
					var positionAttribute = geometry.attributes.position;
					var lineDistances = [];
					for ( var i = 0, l = positionAttribute.count; i ,
	 *  opacity: ,
	 *  map: new THREE.Texture(  ),
	 *  alphaMap: new THREE.Texture(  ),
	 *
	 *  size: ,
	 *  sizeAttenuation: 
	 *
	 *  morphTargets: 
	 * }
	 */
	function PointsMaterial( parameters ) {
		Material.call( this );
		this.type = 'PointsMaterial';
		this.color = new Color( 0xffffff );
		this.map = null;
		this.alphaMap = null;
		this.size = 1;
		this.sizeAttenuation = true;
		this.morphTargets = false;
		this.setValues( parameters );
	}
	PointsMaterial.prototype = Object.create( Material.prototype );
	PointsMaterial.prototype.constructor = PointsMaterial;
	PointsMaterial.prototype.isPointsMaterial = true;
	PointsMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.color.copy( source.color );
		this.map = source.map;
		this.alphaMap = source.alphaMap;
		this.size = source.size;
		this.sizeAttenuation = source.sizeAttenuation;
		this.morphTargets = source.morphTargets;
		return this;
	};
	/**
	 * @author alteredq / http://alteredqualia.com/
	 */
	var _inverseMatrix$2 = new Matrix4();
	var _ray$2 = new Ray();
	var _sphere$3 = new Sphere();
	var _position$1 = new Vector3();
	function Points( geometry, material ) {
		Object3D.call( this );
		this.type = 'Points';
		this.geometry = geometry !== undefined ? geometry : new BufferGeometry();
		this.material = material !== undefined ? material : new PointsMaterial();
		this.updateMorphTargets();
	}
	Points.prototype = Object.assign( Object.create( Object3D.prototype ), {
		constructor: Points,
		isPoints: true,
		raycast: function ( raycaster, intersects ) {
			var geometry = this.geometry;
			var matrixWorld = this.matrixWorld;
			var threshold = raycaster.params.Points.threshold;
			// Checking boundingSphere distance to ray
			if ( geometry.boundingSphere === null ) { geometry.computeBoundingSphere(); }
			_sphere$3.copy( geometry.boundingSphere );
			_sphere$3.applyMatrix4( matrixWorld );
			_sphere$3.radius += threshold;
			if ( raycaster.ray.intersectsSphere( _sphere$3 ) === false ) { return; }
			//
			_inverseMatrix$2.getInverse( matrixWorld );
			_ray$2.copy( raycaster.ray ).applyMatrix4( _inverseMatrix$2 );
			var localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 );
			var localThresholdSq = localThreshold * localThreshold;
			if ( geometry.isBufferGeometry ) {
				var index = geometry.index;
				var attributes = geometry.attributes;
				var positions = attributes.position.array;
				if ( index !== null ) {
					var indices = index.array;
					for ( var i = 0, il = indices.length; i  0 ) {
					var morphAttribute = morphAttributes[ keys[ 0 ] ];
					if ( morphAttribute !== undefined ) {
						this.morphTargetInfluences = [];
						this.morphTargetDictionary = {};
						for ( m = 0, ml = morphAttribute.length; m  0 ) {
					console.error( 'THREE.Points.updateMorphTargets() does not support THREE.Geometry. Use THREE.BufferGeometry instead.' );
				}
			}
		},
		clone: function () {
			return new this.constructor( this.geometry, this.material ).copy( this );
		}
	} );
	function testPoint( point, index, localThresholdSq, matrixWorld, raycaster, intersects, object ) {
		var rayPointDistanceSq = _ray$2.distanceSqToPoint( point );
		if ( rayPointDistanceSq  raycaster.far ) { return; }
			intersects.push( {
				distance: distance,
				distanceToRay: Math.sqrt( rayPointDistanceSq ),
				point: intersectPoint,
				index: index,
				face: null,
				object: object
			} );
		}
	}
	/**
	 * @author mrdoob / http://mrdoob.com/
	 */
	function VideoTexture( video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {
		Texture.call( this, video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );
		this.format = format !== undefined ? format : RGBFormat;
		this.minFilter = minFilter !== undefined ? minFilter : LinearFilter;
		this.magFilter = magFilter !== undefined ? magFilter : LinearFilter;
		this.generateMipmaps = false;
	}
	VideoTexture.prototype = Object.assign( Object.create( Texture.prototype ), {
		constructor: VideoTexture,
		isVideoTexture: true,
		update: function () {
			var video = this.image;
			if ( video.readyState >= video.HAVE_CURRENT_DATA ) {
				this.needsUpdate = true;
			}
		}
	} );
	/**
	 * @author alteredq / http://alteredqualia.com/
	 */
	function CompressedTexture( mipmaps, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) {
		Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );
		this.image = { width: width, height: height };
		this.mipmaps = mipmaps;
		// no flipping for cube textures
		// (also flipping doesn't work for compressed textures )
		this.flipY = false;
		// can't generate mipmaps for compressed textures
		// mips must be embedded in DDS files
		this.generateMipmaps = false;
	}
	CompressedTexture.prototype = Object.create( Texture.prototype );
	CompressedTexture.prototype.constructor = CompressedTexture;
	CompressedTexture.prototype.isCompressedTexture = true;
	/**
	 * @author mrdoob / http://mrdoob.com/
	 */
	function CanvasTexture( canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {
		Texture.call( this, canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );
		this.needsUpdate = true;
	}
	CanvasTexture.prototype = Object.create( Texture.prototype );
	CanvasTexture.prototype.constructor = CanvasTexture;
	CanvasTexture.prototype.isCanvasTexture = true;
	/**
	 * @author Matt DesLauriers / @mattdesl
	 * @author atix / arthursilber.de
	 */
	function DepthTexture( width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, format ) {
		format = format !== undefined ? format : DepthFormat;
		if ( format !== DepthFormat && format !== DepthStencilFormat ) {
			throw new Error( 'DepthTexture format must be either THREE.DepthFormat or THREE.DepthStencilFormat' );
		}
		if ( type === undefined && format === DepthFormat ) { type = UnsignedShortType; }
		if ( type === undefined && format === DepthStencilFormat ) { type = UnsignedInt248Type; }
		Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );
		this.image = { width: width, height: height };
		this.magFilter = magFilter !== undefined ? magFilter : NearestFilter;
		this.minFilter = minFilter !== undefined ? minFilter : NearestFilter;
		this.flipY = false;
		this.generateMipmaps	= false;
	}
	DepthTexture.prototype = Object.create( Texture.prototype );
	DepthTexture.prototype.constructor = DepthTexture;
	DepthTexture.prototype.isDepthTexture = true;
	/**
	 * @author mrdoob / http://mrdoob.com/
	 * @author Mugen87 / https://github.com/Mugen87
	 */
	function WireframeGeometry( geometry ) {
		BufferGeometry.call( this );
		this.type = 'WireframeGeometry';
		// buffer
		var vertices = [];
		// helper variables
		var i, j, l, o, ol;
		var edge = [ 0, 0 ], edges = {}, e, edge1, edge2;
		var key, keys = [ 'a', 'b', 'c' ];
		var vertex;
		// different logic for Geometry and BufferGeometry
		if ( geometry && geometry.isGeometry ) {
			// create a data structure that contains all edges without duplicates
			var faces = geometry.faces;
			for ( i = 0, l = faces.length; i = 0 ) {
					func( u - EPS, v, p1 );
					pu.subVectors( p0, p1 );
				} else {
					func( u + EPS, v, p1 );
					pu.subVectors( p1, p0 );
				}
				if ( v - EPS >= 0 ) {
					func( u, v - EPS, p1 );
					pv.subVectors( p0, p1 );
				} else {
					func( u, v + EPS, p1 );
					pv.subVectors( p1, p0 );
				}
				// cross product of tangent vectors returns surface normal
				normal.crossVectors( pu, pv ).normalize();
				normals.push( normal.x, normal.y, normal.z );
				// uv
				uvs.push( u, v );
			}
		}
		// generate indices
		for ( i = 0; i  0.9 && min  80 * dim ) {
				minX = maxX = data[ 0 ];
				minY = maxY = data[ 1 ];
				for ( var i = dim; i  maxX ) { maxX = x; }
					if ( y > maxY ) { maxY = y; }
				}
				// minX, minY and invSize are later used to transform coords into integers for z-order calculation
				invSize = Math.max( maxX - minX, maxY - minY );
				invSize = invSize !== 0 ? 1 / invSize : 0;
			}
			earcutLinked( outerNode, triangles, dim, minX, minY, invSize );
			return triangles;
		}
	};
	// create a circular doubly linked list from polygon points in the specified winding order
	function linkedList( data, start, end, dim, clockwise ) {
		var i, last;
		if ( clockwise === ( signedArea( data, start, end, dim ) > 0 ) ) {
			for ( i = start; i = start; i -= dim ) { last = insertNode( i, data[ i ], data[ i + 1 ], last ); }
		}
		if ( last && equals( last, last.next ) ) {
			removeNode( last );
			last = last.next;
		}
		return last;
	}
	// eliminate colinear or duplicate points
	function filterPoints( start, end ) {
		if ( ! start ) { return start; }
		if ( ! end ) { end = start; }
		var p = start,
			again;
		do {
			again = false;
			if ( ! p.steiner && ( equals( p, p.next ) || area( p.prev, p, p.next ) === 0 ) ) {
				removeNode( p );
				p = end = p.prev;
				if ( p === p.next ) { break; }
				again = true;
			} else {
				p = p.next;
			}
		} while ( again || p !== end );
		return end;
	}
	// main ear slicing loop which triangulates a polygon (given as a linked list)
	function earcutLinked( ear, triangles, dim, minX, minY, invSize, pass ) {
		if ( ! ear ) { return; }
		// interlink polygon nodes in z-order
		if ( ! pass && invSize ) { indexCurve( ear, minX, minY, invSize ); }
		var stop = ear,
			prev, next;
		// iterate through ears, slicing them one by one
		while ( ear.prev !== ear.next ) {
			prev = ear.prev;
			next = ear.next;
			if ( invSize ? isEarHashed( ear, minX, minY, invSize ) : isEar( ear ) ) {
				// cut off the triangle
				triangles.push( prev.i / dim );
				triangles.push( ear.i / dim );
				triangles.push( next.i / dim );
				removeNode( ear );
				// skipping the next vertex leads to less sliver triangles
				ear = next.next;
				stop = next.next;
				continue;
			}
			ear = next;
			// if we looped through the whole remaining polygon and can't find any more ears
			if ( ear === stop ) {
				// try filtering points and slicing again
				if ( ! pass ) {
					earcutLinked( filterPoints( ear ), triangles, dim, minX, minY, invSize, 1 );
					// if this didn't work, try curing all small self-intersections locally
				} else if ( pass === 1 ) {
					ear = cureLocalIntersections( filterPoints( ear ), triangles, dim );
					earcutLinked( ear, triangles, dim, minX, minY, invSize, 2 );
					// as a last resort, try splitting the remaining polygon into two
				} else if ( pass === 2 ) {
					splitEarcut( ear, triangles, dim, minX, minY, invSize );
				}
				break;
			}
		}
	}
	// check whether a polygon node forms a valid ear with adjacent nodes
	function isEar( ear ) {
		var a = ear.prev,
			b = ear,
			c = ear.next;
		if ( area( a, b, c ) >= 0 ) { return false; } // reflex, can't be an ear
		// now make sure we don't have other points inside the potential ear
		var p = ear.next.next;
		while ( p !== ear.prev ) {
			if ( pointInTriangle( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) &&
				area( p.prev, p, p.next ) >= 0 ) { return false; }
			p = p.next;
		}
		return true;
	}
	function isEarHashed( ear, minX, minY, invSize ) {
		var a = ear.prev,
			b = ear,
			c = ear.next;
		if ( area( a, b, c ) >= 0 ) { return false; } // reflex, can't be an ear
		// triangle bbox; min & max are calculated like this for speed
		var minTX = a.x  b.x ? ( a.x > c.x ? a.x : c.x ) : ( b.x > c.x ? b.x : c.x ),
			maxTY = a.y > b.y ? ( a.y > c.y ? a.y : c.y ) : ( b.y > c.y ? b.y : c.y );
		// z-order range for the current triangle bbox;
		var minZ = zOrder( minTX, minTY, minX, minY, invSize ),
			maxZ = zOrder( maxTX, maxTY, minX, minY, invSize );
		var p = ear.prevZ,
			n = ear.nextZ;
		// look for points inside the triangle in both directions
		while ( p && p.z >= minZ && n && n.z = 0 ) { return false; }
			p = p.prevZ;
			if ( n !== ear.prev && n !== ear.next &&
				pointInTriangle( a.x, a.y, b.x, b.y, c.x, c.y, n.x, n.y ) &&
				area( n.prev, n, n.next ) >= 0 ) { return false; }
			n = n.nextZ;
		}
		// look for remaining points in decreasing z-order
		while ( p && p.z >= minZ ) {
			if ( p !== ear.prev && p !== ear.next &&
				pointInTriangle( a.x, a.y, b.x, b.y, c.x, c.y, p.x, p.y ) &&
				area( p.prev, p, p.next ) >= 0 ) { return false; }
			p = p.prevZ;
		}
		// look for remaining points in increasing z-order
		while ( n && n.z = 0 ) { return false; }
			n = n.nextZ;
		}
		return true;
	}
	// go through all polygon nodes and cure small local self-intersections
	function cureLocalIntersections( start, triangles, dim ) {
		var p = start;
		do {
			var a = p.prev,
				b = p.next.next;
			if ( ! equals( a, b ) && intersects( a, p, p.next, b ) && locallyInside( a, b ) && locallyInside( b, a ) ) {
				triangles.push( a.i / dim );
				triangles.push( p.i / dim );
				triangles.push( b.i / dim );
				// remove two nodes involved
				removeNode( p );
				removeNode( p.next );
				p = start = b;
			}
			p = p.next;
		} while ( p !== start );
		return filterPoints( p );
	}
	// try splitting polygon into two and triangulate them independently
	function splitEarcut( start, triangles, dim, minX, minY, invSize ) {
		// look for a valid diagonal that divides the polygon into two
		var a = start;
		do {
			var b = a.next.next;
			while ( b !== a.prev ) {
				if ( a.i !== b.i && isValidDiagonal( a, b ) ) {
					// split the polygon in two by the diagonal
					var c = splitPolygon( a, b );
					// filter colinear points around the cuts
					a = filterPoints( a, a.next );
					c = filterPoints( c, c.next );
					// run earcut on each half
					earcutLinked( a, triangles, dim, minX, minY, invSize );
					earcutLinked( c, triangles, dim, minX, minY, invSize );
					return;
				}
				b = b.next;
			}
			a = a.next;
		} while ( a !== start );
	}
	// link every hole into the outer loop, producing a single-ring polygon without holes
	function eliminateHoles( data, holeIndices, outerNode, dim ) {
		var queue = [],
			i, len, start, end, list;
		for ( i = 0, len = holeIndices.length; i = p.next.y && p.next.y !== p.y ) {
				var x = p.x + ( hy - p.y ) * ( p.next.x - p.x ) / ( p.next.y - p.y );
				if ( x  qx ) {
					qx = x;
					if ( x === hx ) {
						if ( hy === p.y ) { return p; }
						if ( hy === p.next.y ) { return p.next; }
					}
					m = p.x = p.x && p.x >= mx && hx !== p.x &&
					pointInTriangle( hy  m.x || ( p.x === m.x && sectorContainsSector( m, p ) ) ) ) ) ) {
					m = p;
					tanMin = tan;
				}
			}
			p = p.next;
		} while ( p !== stop );
		return m;
	}
	// whether sector in vertex m contains sector in vertex p in the same coordinates
	function sectorContainsSector( m, p ) {
		return area( m.prev, m, p.prev )  0 || ( qSize > 0 && q ) ) {
					if ( pSize !== 0 && ( qSize === 0 || ! q || p.z  1 );
		return list;
	}
	// z-order of a point given coords and inverse of the longer side of data bbox
	function zOrder( x, y, minX, minY, invSize ) {
		// coords are transformed into non-negative 15-bit integer range
		x = 32767 * ( x - minX ) * invSize;
		y = 32767 * ( y - minY ) * invSize;
		x = ( x | ( x = 0 &&
				( ax - px ) * ( by - py ) - ( bx - px ) * ( ay - py ) >= 0 &&
				( bx - px ) * ( cy - py ) - ( cx - px ) * ( by - py ) >= 0;
	}
	// check if a diagonal between two polygon nodes is valid (lies in polygon interior)
	function isValidDiagonal( a, b ) {
		return a.next.i !== b.i && a.prev.i !== b.i && ! intersectsPolygon( a, b ) && // dones't intersect other edges
			( locallyInside( a, b ) && locallyInside( b, a ) && middleInside( a, b ) && // locally visible
			( area( a.prev, a, b.prev ) || area( a, b.prev, b ) ) || // does not create opposite-facing sectors
			equals( a, b ) && area( a.prev, a, a.next ) > 0 && area( b.prev, b, b.next ) > 0 ); // special zero-length case
	}
	// signed area of a triangle
	function area( p, q, r ) {
		return ( q.y - p.y ) * ( r.x - q.x ) - ( q.x - p.x ) * ( r.y - q.y );
	}
	// check if two points are equal
	function equals( p1, p2 ) {
		return p1.x === p2.x && p1.y === p2.y;
	}
	// check if two segments intersect
	function intersects( p1, q1, p2, q2 ) {
		var o1 = sign( area( p1, q1, p2 ) );
		var o2 = sign( area( p1, q1, q2 ) );
		var o3 = sign( area( p2, q2, p1 ) );
		var o4 = sign( area( p2, q2, q1 ) );
		if ( o1 !== o2 && o3 !== o4 ) { return true; } // general case
		if ( o1 === 0 && onSegment( p1, p2, q1 ) ) { return true; } // p1, q1 and p2 are collinear and p2 lies on p1q1
		if ( o2 === 0 && onSegment( p1, q2, q1 ) ) { return true; } // p1, q1 and q2 are collinear and q2 lies on p1q1
		if ( o3 === 0 && onSegment( p2, p1, q2 ) ) { return true; } // p2, q2 and p1 are collinear and p1 lies on p2q2
		if ( o4 === 0 && onSegment( p2, q1, q2 ) ) { return true; } // p2, q2 and q1 are collinear and q1 lies on p2q2
		return false;
	}
	// for collinear points p, q, r, check if point q lies on segment pr
	function onSegment( p, q, r ) {
		return q.x = Math.min( p.x, r.x ) && q.y = Math.min( p.y, r.y );
	}
	function sign( num ) {
		return num > 0 ? 1 : num = 0 && area( a, a.prev, b ) >= 0 :
			area( a, b, a.prev )  py ) !== ( p.next.y > py ) ) && p.next.y !== p.y &&
					( px  2 && points[ l - 1 ].equals( points[ 0 ] ) ) {
			points.pop();
		}
	}
	function addContour( vertices, contour ) {
		for ( var i = 0; i , // number of points on the curves
	 *  steps: , // number of points for z-side extrusions / used for subdividing segments of extrude spline too
	 *  depth: , // Depth to extrude the shape
	 *
	 *  bevelEnabled: , // turn on bevel
	 *  bevelThickness: , // how deep into the original shape bevel goes
	 *  bevelSize: , // how far from shape outline (including bevelOffset) is bevel
	 *  bevelOffset: , // how far from shape outline does bevel start
	 *  bevelSegments: , // number of bevel layers
	 *
	 *  extrudePath:  // curve to extrude shape along
	 *
	 *  UVGenerator:  // object that provides UV generator functions
	 *
	 * }
	 */
	// ExtrudeGeometry
	function ExtrudeGeometry( shapes, options ) {
		Geometry.call( this );
		this.type = 'ExtrudeGeometry';
		this.parameters = {
			shapes: shapes,
			options: options
		};
		this.fromBufferGeometry( new ExtrudeBufferGeometry( shapes, options ) );
		this.mergeVertices();
	}
	ExtrudeGeometry.prototype = Object.create( Geometry.prototype );
	ExtrudeGeometry.prototype.constructor = ExtrudeGeometry;
	ExtrudeGeometry.prototype.toJSON = function () {
		var data = Geometry.prototype.toJSON.call( this );
		var shapes = this.parameters.shapes;
		var options = this.parameters.options;
		return toJSON( shapes, options, data );
	};
	// ExtrudeBufferGeometry
	function ExtrudeBufferGeometry( shapes, options ) {
		BufferGeometry.call( this );
		this.type = 'ExtrudeBufferGeometry';
		this.parameters = {
			shapes: shapes,
			options: options
		};
		shapes = Array.isArray( shapes ) ? shapes : [ shapes ];
		var scope = this;
		var verticesArray = [];
		var uvArray = [];
		for ( var i = 0, l = shapes.length; i  Number.EPSILON ) {
					// not collinear
					// length of vectors for normalizing
					var v_prev_len = Math.sqrt( v_prev_lensq );
					var v_next_len = Math.sqrt( v_next_x * v_next_x + v_next_y * v_next_y );
					// shift adjacent points by unit vectors to the left
					var ptPrevShift_x = ( inPrev.x - v_prev_y / v_prev_len );
					var ptPrevShift_y = ( inPrev.y + v_prev_x / v_prev_len );
					var ptNextShift_x = ( inNext.x - v_next_y / v_next_len );
					var ptNextShift_y = ( inNext.y + v_next_x / v_next_len );
					// scaling factor for v_prev to intersection point
					var sf = ( ( ptNextShift_x - ptPrevShift_x ) * v_next_y -
							( ptNextShift_y - ptPrevShift_y ) * v_next_x ) /
						( v_prev_x * v_next_y - v_prev_y * v_next_x );
					// vector from inPt to intersection point
					v_trans_x = ( ptPrevShift_x + v_prev_x * sf - inPt.x );
					v_trans_y = ( ptPrevShift_y + v_prev_y * sf - inPt.y );
					// Don't normalize!, otherwise sharp corners become ugly
					//  but prevent crazy spikes
					var v_trans_lensq = ( v_trans_x * v_trans_x + v_trans_y * v_trans_y );
					if ( v_trans_lensq  Number.EPSILON ) {
						if ( v_next_x > Number.EPSILON ) {
							direction_eq = true;
						}
					} else {
						if ( v_prev_x  0; b -- ) {
				t = b / bevelSegments;
				z = bevelThickness * Math.cos( t * Math.PI / 2 );
				bs = bevelSize * Math.sin( t * Math.PI / 2 ) + bevelOffset;
				// contract shape
				for ( i = 0, il = contour.length; i = 0; b -- ) {
				t = b / bevelSegments;
				z = bevelThickness * Math.cos( t * Math.PI / 2 );
				bs = bevelSize * Math.sin( t * Math.PI / 2 ) + bevelOffset;
				// contract shape
				for ( i = 0, il = contour.length; i = 0 ) {
					j = i;
					k = i - 1;
					if ( k , // font
	 *
	 *  size: , // size of the text
	 *  height: , // thickness to extrude text
	 *  curveSegments: , // number of points on the curves
	 *
	 *  bevelEnabled: , // turn on bevel
	 *  bevelThickness: , // how deep into text bevel goes
	 *  bevelSize: , // how far from text outline (including bevelOffset) is bevel
	 *  bevelOffset:  // how far from text outline does bevel start
	 * }
	 */
	// TextGeometry
	function TextGeometry( text, parameters ) {
		Geometry.call( this );
		this.type = 'TextGeometry';
		this.parameters = {
			text: text,
			parameters: parameters
		};
		this.fromBufferGeometry( new TextBufferGeometry( text, parameters ) );
		this.mergeVertices();
	}
	TextGeometry.prototype = Object.create( Geometry.prototype );
	TextGeometry.prototype.constructor = TextGeometry;
	// TextBufferGeometry
	function TextBufferGeometry( text, parameters ) {
		parameters = parameters || {};
		var font = parameters.font;
		if ( ! ( font && font.isFont ) ) {
			console.error( 'THREE.TextGeometry: font parameter is not an instance of THREE.Font.' );
			return new Geometry();
		}
		var shapes = font.generateShapes( text, parameters.size );
		// translate parameters to ExtrudeGeometry API
		parameters.depth = parameters.height !== undefined ? parameters.height : 50;
		// defaults
		if ( parameters.bevelThickness === undefined ) { parameters.bevelThickness = 10; }
		if ( parameters.bevelSize === undefined ) { parameters.bevelSize = 8; }
		if ( parameters.bevelEnabled === undefined ) { parameters.bevelEnabled = false; }
		ExtrudeBufferGeometry.call( this, shapes, parameters );
		this.type = 'TextBufferGeometry';
	}
	TextBufferGeometry.prototype = Object.create( ExtrudeBufferGeometry.prototype );
	TextBufferGeometry.prototype.constructor = TextBufferGeometry;
	/**
	 * @author mrdoob / http://mrdoob.com/
	 * @author benaadams / https://twitter.com/ben_a_adams
	 * @author Mugen87 / https://github.com/Mugen87
	 */
	// SphereGeometry
	function SphereGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) {
		Geometry.call( this );
		this.type = 'SphereGeometry';
		this.parameters = {
			radius: radius,
			widthSegments: widthSegments,
			heightSegments: heightSegments,
			phiStart: phiStart,
			phiLength: phiLength,
			thetaStart: thetaStart,
			thetaLength: thetaLength
		};
		this.fromBufferGeometry( new SphereBufferGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) );
		this.mergeVertices();
	}
	SphereGeometry.prototype = Object.create( Geometry.prototype );
	SphereGeometry.prototype.constructor = SphereGeometry;
	// SphereBufferGeometry
	function SphereBufferGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) {
		BufferGeometry.call( this );
		this.type = 'SphereBufferGeometry';
		this.parameters = {
			radius: radius,
			widthSegments: widthSegments,
			heightSegments: heightSegments,
			phiStart: phiStart,
			phiLength: phiLength,
			thetaStart: thetaStart,
			thetaLength: thetaLength
		};
		radius = radius || 1;
		widthSegments = Math.max( 3, Math.floor( widthSegments ) || 8 );
		heightSegments = Math.max( 2, Math.floor( heightSegments ) || 6 );
		phiStart = phiStart !== undefined ? phiStart : 0;
		phiLength = phiLength !== undefined ? phiLength : Math.PI * 2;
		thetaStart = thetaStart !== undefined ? thetaStart : 0;
		thetaLength = thetaLength !== undefined ? thetaLength : Math.PI;
		var thetaEnd = Math.min( thetaStart + thetaLength, Math.PI );
		var ix, iy;
		var index = 0;
		var grid = [];
		var vertex = new Vector3();
		var normal = new Vector3();
		// buffers
		var indices = [];
		var vertices = [];
		var normals = [];
		var uvs = [];
		// generate vertices, normals and uvs
		for ( iy = 0; iy  0 ) { indices.push( a, b, d ); }
				if ( iy !== heightSegments - 1 || thetaEnd  0 ) { generateCap( true ); }
			if ( radiusBottom > 0 ) { generateCap( false ); }
		}
		// build geometry
		this.setIndex( indices );
		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
		function generateTorso() {
			var x, y;
			var normal = new Vector3();
			var vertex = new Vector3();
			var groupCount = 0;
			// this will be used to calculate the normal
			var slope = ( radiusBottom - radiusTop ) / height;
			// generate vertices, normals and uvs
			for ( y = 0; y 
	 * }
	 */
	function ShadowMaterial( parameters ) {
		Material.call( this );
		this.type = 'ShadowMaterial';
		this.color = new Color( 0x000000 );
		this.transparent = true;
		this.setValues( parameters );
	}
	ShadowMaterial.prototype = Object.create( Material.prototype );
	ShadowMaterial.prototype.constructor = ShadowMaterial;
	ShadowMaterial.prototype.isShadowMaterial = true;
	ShadowMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.color.copy( source.color );
		return this;
	};
	/**
	 * @author mrdoob / http://mrdoob.com/
	 */
	function RawShaderMaterial( parameters ) {
		ShaderMaterial.call( this, parameters );
		this.type = 'RawShaderMaterial';
	}
	RawShaderMaterial.prototype = Object.create( ShaderMaterial.prototype );
	RawShaderMaterial.prototype.constructor = RawShaderMaterial;
	RawShaderMaterial.prototype.isRawShaderMaterial = true;
	/**
	 * @author WestLangley / http://github.com/WestLangley
	 *
	 * parameters = {
	 *  color: ,
	 *  roughness: ,
	 *  metalness: ,
	 *  opacity: ,
	 *
	 *  map: new THREE.Texture(  ),
	 *
	 *  lightMap: new THREE.Texture(  ),
	 *  lightMapIntensity: 
	 *
	 *  aoMap: new THREE.Texture(  ),
	 *  aoMapIntensity: 
	 *
	 *  emissive: ,
	 *  emissiveIntensity: 
	 *  emissiveMap: new THREE.Texture(  ),
	 *
	 *  bumpMap: new THREE.Texture(  ),
	 *  bumpScale: ,
	 *
	 *  normalMap: new THREE.Texture(  ),
	 *  normalMapType: THREE.TangentSpaceNormalMap,
	 *  normalScale: ,
	 *
	 *  displacementMap: new THREE.Texture(  ),
	 *  displacementScale: ,
	 *  displacementBias: ,
	 *
	 *  roughnessMap: new THREE.Texture(  ),
	 *
	 *  metalnessMap: new THREE.Texture(  ),
	 *
	 *  alphaMap: new THREE.Texture(  ),
	 *
	 *  envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
	 *  envMapIntensity: 
	 *
	 *  refractionRatio: ,
	 *
	 *  wireframe: ,
	 *  wireframeLinewidth: ,
	 *
	 *  skinning: ,
	 *  morphTargets: ,
	 *  morphNormals: 
	 * }
	 */
	function MeshStandardMaterial( parameters ) {
		Material.call( this );
		this.defines = { 'STANDARD': '' };
		this.type = 'MeshStandardMaterial';
		this.color = new Color( 0xffffff ); // diffuse
		this.roughness = 1.0;
		this.metalness = 0.0;
		this.map = null;
		this.lightMap = null;
		this.lightMapIntensity = 1.0;
		this.aoMap = null;
		this.aoMapIntensity = 1.0;
		this.emissive = new Color( 0x000000 );
		this.emissiveIntensity = 1.0;
		this.emissiveMap = null;
		this.bumpMap = null;
		this.bumpScale = 1;
		this.normalMap = null;
		this.normalMapType = TangentSpaceNormalMap;
		this.normalScale = new Vector2( 1, 1 );
		this.displacementMap = null;
		this.displacementScale = 1;
		this.displacementBias = 0;
		this.roughnessMap = null;
		this.metalnessMap = null;
		this.alphaMap = null;
		this.envMap = null;
		this.envMapIntensity = 1.0;
		this.refractionRatio = 0.98;
		this.wireframe = false;
		this.wireframeLinewidth = 1;
		this.wireframeLinecap = 'round';
		this.wireframeLinejoin = 'round';
		this.skinning = false;
		this.morphTargets = false;
		this.morphNormals = false;
		this.vertexTangents = false;
		this.setValues( parameters );
	}
	MeshStandardMaterial.prototype = Object.create( Material.prototype );
	MeshStandardMaterial.prototype.constructor = MeshStandardMaterial;
	MeshStandardMaterial.prototype.isMeshStandardMaterial = true;
	MeshStandardMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.defines = { 'STANDARD': '' };
		this.color.copy( source.color );
		this.roughness = source.roughness;
		this.metalness = source.metalness;
		this.map = source.map;
		this.lightMap = source.lightMap;
		this.lightMapIntensity = source.lightMapIntensity;
		this.aoMap = source.aoMap;
		this.aoMapIntensity = source.aoMapIntensity;
		this.emissive.copy( source.emissive );
		this.emissiveMap = source.emissiveMap;
		this.emissiveIntensity = source.emissiveIntensity;
		this.bumpMap = source.bumpMap;
		this.bumpScale = source.bumpScale;
		this.normalMap = source.normalMap;
		this.normalMapType = source.normalMapType;
		this.normalScale.copy( source.normalScale );
		this.displacementMap = source.displacementMap;
		this.displacementScale = source.displacementScale;
		this.displacementBias = source.displacementBias;
		this.roughnessMap = source.roughnessMap;
		this.metalnessMap = source.metalnessMap;
		this.alphaMap = source.alphaMap;
		this.envMap = source.envMap;
		this.envMapIntensity = source.envMapIntensity;
		this.refractionRatio = source.refractionRatio;
		this.wireframe = source.wireframe;
		this.wireframeLinewidth = source.wireframeLinewidth;
		this.wireframeLinecap = source.wireframeLinecap;
		this.wireframeLinejoin = source.wireframeLinejoin;
		this.skinning = source.skinning;
		this.morphTargets = source.morphTargets;
		this.morphNormals = source.morphNormals;
		this.vertexTangents = source.vertexTangents;
		return this;
	};
	/**
	 * @author WestLangley / http://github.com/WestLangley
	 *
	 * parameters = {
	 *  clearcoat: ,
	 *  clearcoatMap: new THREE.Texture(  ),
	 *  clearcoatRoughness: ,
	 *  clearcoatRoughnessMap: new THREE.Texture(  ),
	 *  clearcoatNormalScale: ,
	 *  clearcoatNormalMap: new THREE.Texture(  ),
	 *
	 *  reflectivity: ,
	 *
	 *  sheen: ,
	 *
	 *  transparency: 
	 * }
	 */
	function MeshPhysicalMaterial( parameters ) {
		MeshStandardMaterial.call( this );
		this.defines = {
			'STANDARD': '',
			'PHYSICAL': ''
		};
		this.type = 'MeshPhysicalMaterial';
		this.clearcoat = 0.0;
		this.clearcoatMap = null;
		this.clearcoatRoughness = 0.0;
		this.clearcoatRoughnessMap = null;
		this.clearcoatNormalScale = new Vector2( 1, 1 );
		this.clearcoatNormalMap = null;
		this.reflectivity = 0.5; // maps to F0 = 0.04
		this.sheen = null; // null will disable sheen bsdf
		this.transparency = 0.0;
		this.setValues( parameters );
	}
	MeshPhysicalMaterial.prototype = Object.create( MeshStandardMaterial.prototype );
	MeshPhysicalMaterial.prototype.constructor = MeshPhysicalMaterial;
	MeshPhysicalMaterial.prototype.isMeshPhysicalMaterial = true;
	MeshPhysicalMaterial.prototype.copy = function ( source ) {
		MeshStandardMaterial.prototype.copy.call( this, source );
		this.defines = {
			'STANDARD': '',
			'PHYSICAL': ''
		};
		this.clearcoat = source.clearcoat;
		this.clearcoatMap = source.clearcoatMap;
		this.clearcoatRoughness = source.clearcoatRoughness;
		this.clearcoatRoughnessMap = source.clearcoatRoughnessMap;
		this.clearcoatNormalMap = source.clearcoatNormalMap;
		this.clearcoatNormalScale.copy( source.clearcoatNormalScale );
		this.reflectivity = source.reflectivity;
		if ( source.sheen ) {
			this.sheen = ( this.sheen || new Color() ).copy( source.sheen );
		} else {
			this.sheen = null;
		}
		this.transparency = source.transparency;
		return this;
	};
	/**
	 * @author mrdoob / http://mrdoob.com/
	 * @author alteredq / http://alteredqualia.com/
	 *
	 * parameters = {
	 *  color: ,
	 *  specular: ,
	 *  shininess: ,
	 *  opacity: ,
	 *
	 *  map: new THREE.Texture(  ),
	 *
	 *  lightMap: new THREE.Texture(  ),
	 *  lightMapIntensity: 
	 *
	 *  aoMap: new THREE.Texture(  ),
	 *  aoMapIntensity: 
	 *
	 *  emissive: ,
	 *  emissiveIntensity: 
	 *  emissiveMap: new THREE.Texture(  ),
	 *
	 *  bumpMap: new THREE.Texture(  ),
	 *  bumpScale: ,
	 *
	 *  normalMap: new THREE.Texture(  ),
	 *  normalMapType: THREE.TangentSpaceNormalMap,
	 *  normalScale: ,
	 *
	 *  displacementMap: new THREE.Texture(  ),
	 *  displacementScale: ,
	 *  displacementBias: ,
	 *
	 *  specularMap: new THREE.Texture(  ),
	 *
	 *  alphaMap: new THREE.Texture(  ),
	 *
	 *  envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
	 *  combine: THREE.MultiplyOperation,
	 *  reflectivity: ,
	 *  refractionRatio: ,
	 *
	 *  wireframe: ,
	 *  wireframeLinewidth: ,
	 *
	 *  skinning: ,
	 *  morphTargets: ,
	 *  morphNormals: 
	 * }
	 */
	function MeshPhongMaterial( parameters ) {
		Material.call( this );
		this.type = 'MeshPhongMaterial';
		this.color = new Color( 0xffffff ); // diffuse
		this.specular = new Color( 0x111111 );
		this.shininess = 30;
		this.map = null;
		this.lightMap = null;
		this.lightMapIntensity = 1.0;
		this.aoMap = null;
		this.aoMapIntensity = 1.0;
		this.emissive = new Color( 0x000000 );
		this.emissiveIntensity = 1.0;
		this.emissiveMap = null;
		this.bumpMap = null;
		this.bumpScale = 1;
		this.normalMap = null;
		this.normalMapType = TangentSpaceNormalMap;
		this.normalScale = new Vector2( 1, 1 );
		this.displacementMap = null;
		this.displacementScale = 1;
		this.displacementBias = 0;
		this.specularMap = null;
		this.alphaMap = null;
		this.envMap = null;
		this.combine = MultiplyOperation;
		this.reflectivity = 1;
		this.refractionRatio = 0.98;
		this.wireframe = false;
		this.wireframeLinewidth = 1;
		this.wireframeLinecap = 'round';
		this.wireframeLinejoin = 'round';
		this.skinning = false;
		this.morphTargets = false;
		this.morphNormals = false;
		this.setValues( parameters );
	}
	MeshPhongMaterial.prototype = Object.create( Material.prototype );
	MeshPhongMaterial.prototype.constructor = MeshPhongMaterial;
	MeshPhongMaterial.prototype.isMeshPhongMaterial = true;
	MeshPhongMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.color.copy( source.color );
		this.specular.copy( source.specular );
		this.shininess = source.shininess;
		this.map = source.map;
		this.lightMap = source.lightMap;
		this.lightMapIntensity = source.lightMapIntensity;
		this.aoMap = source.aoMap;
		this.aoMapIntensity = source.aoMapIntensity;
		this.emissive.copy( source.emissive );
		this.emissiveMap = source.emissiveMap;
		this.emissiveIntensity = source.emissiveIntensity;
		this.bumpMap = source.bumpMap;
		this.bumpScale = source.bumpScale;
		this.normalMap = source.normalMap;
		this.normalMapType = source.normalMapType;
		this.normalScale.copy( source.normalScale );
		this.displacementMap = source.displacementMap;
		this.displacementScale = source.displacementScale;
		this.displacementBias = source.displacementBias;
		this.specularMap = source.specularMap;
		this.alphaMap = source.alphaMap;
		this.envMap = source.envMap;
		this.combine = source.combine;
		this.reflectivity = source.reflectivity;
		this.refractionRatio = source.refractionRatio;
		this.wireframe = source.wireframe;
		this.wireframeLinewidth = source.wireframeLinewidth;
		this.wireframeLinecap = source.wireframeLinecap;
		this.wireframeLinejoin = source.wireframeLinejoin;
		this.skinning = source.skinning;
		this.morphTargets = source.morphTargets;
		this.morphNormals = source.morphNormals;
		return this;
	};
	/**
	 * @author takahirox / http://github.com/takahirox
	 *
	 * parameters = {
	 *  color: ,
	 *  specular: ,
	 *  shininess: ,
	 *
	 *  map: new THREE.Texture(  ),
	 *  gradientMap: new THREE.Texture(  ),
	 *
	 *  lightMap: new THREE.Texture(  ),
	 *  lightMapIntensity: 
	 *
	 *  aoMap: new THREE.Texture(  ),
	 *  aoMapIntensity: 
	 *
	 *  emissive: ,
	 *  emissiveIntensity: 
	 *  emissiveMap: new THREE.Texture(  ),
	 *
	 *  bumpMap: new THREE.Texture(  ),
	 *  bumpScale: ,
	 *
	 *  normalMap: new THREE.Texture(  ),
	 *  normalMapType: THREE.TangentSpaceNormalMap,
	 *  normalScale: ,
	 *
	 *  displacementMap: new THREE.Texture(  ),
	 *  displacementScale: ,
	 *  displacementBias: ,
	 *
	 *  specularMap: new THREE.Texture(  ),
	 *
	 *  alphaMap: new THREE.Texture(  ),
	 *
	 *  wireframe: ,
	 *  wireframeLinewidth: ,
	 *
	 *  skinning: ,
	 *  morphTargets: ,
	 *  morphNormals: 
	 * }
	 */
	function MeshToonMaterial( parameters ) {
		Material.call( this );
		this.defines = { 'TOON': '' };
		this.type = 'MeshToonMaterial';
		this.color = new Color( 0xffffff );
		this.specular = new Color( 0x111111 );
		this.shininess = 30;
		this.map = null;
		this.gradientMap = null;
		this.lightMap = null;
		this.lightMapIntensity = 1.0;
		this.aoMap = null;
		this.aoMapIntensity = 1.0;
		this.emissive = new Color( 0x000000 );
		this.emissiveIntensity = 1.0;
		this.emissiveMap = null;
		this.bumpMap = null;
		this.bumpScale = 1;
		this.normalMap = null;
		this.normalMapType = TangentSpaceNormalMap;
		this.normalScale = new Vector2( 1, 1 );
		this.displacementMap = null;
		this.displacementScale = 1;
		this.displacementBias = 0;
		this.specularMap = null;
		this.alphaMap = null;
		this.wireframe = false;
		this.wireframeLinewidth = 1;
		this.wireframeLinecap = 'round';
		this.wireframeLinejoin = 'round';
		this.skinning = false;
		this.morphTargets = false;
		this.morphNormals = false;
		this.setValues( parameters );
	}
	MeshToonMaterial.prototype = Object.create( Material.prototype );
	MeshToonMaterial.prototype.constructor = MeshToonMaterial;
	MeshToonMaterial.prototype.isMeshToonMaterial = true;
	MeshToonMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.color.copy( source.color );
		this.specular.copy( source.specular );
		this.shininess = source.shininess;
		this.map = source.map;
		this.gradientMap = source.gradientMap;
		this.lightMap = source.lightMap;
		this.lightMapIntensity = source.lightMapIntensity;
		this.aoMap = source.aoMap;
		this.aoMapIntensity = source.aoMapIntensity;
		this.emissive.copy( source.emissive );
		this.emissiveMap = source.emissiveMap;
		this.emissiveIntensity = source.emissiveIntensity;
		this.bumpMap = source.bumpMap;
		this.bumpScale = source.bumpScale;
		this.normalMap = source.normalMap;
		this.normalMapType = source.normalMapType;
		this.normalScale.copy( source.normalScale );
		this.displacementMap = source.displacementMap;
		this.displacementScale = source.displacementScale;
		this.displacementBias = source.displacementBias;
		this.specularMap = source.specularMap;
		this.alphaMap = source.alphaMap;
		this.wireframe = source.wireframe;
		this.wireframeLinewidth = source.wireframeLinewidth;
		this.wireframeLinecap = source.wireframeLinecap;
		this.wireframeLinejoin = source.wireframeLinejoin;
		this.skinning = source.skinning;
		this.morphTargets = source.morphTargets;
		this.morphNormals = source.morphNormals;
		return this;
	};
	/**
	 * @author mrdoob / http://mrdoob.com/
	 * @author WestLangley / http://github.com/WestLangley
	 *
	 * parameters = {
	 *  opacity: ,
	 *
	 *  bumpMap: new THREE.Texture(  ),
	 *  bumpScale: ,
	 *
	 *  normalMap: new THREE.Texture(  ),
	 *  normalMapType: THREE.TangentSpaceNormalMap,
	 *  normalScale: ,
	 *
	 *  displacementMap: new THREE.Texture(  ),
	 *  displacementScale: ,
	 *  displacementBias: ,
	 *
	 *  wireframe: ,
	 *  wireframeLinewidth: 
	 *
	 *  skinning: ,
	 *  morphTargets: ,
	 *  morphNormals: 
	 * }
	 */
	function MeshNormalMaterial( parameters ) {
		Material.call( this );
		this.type = 'MeshNormalMaterial';
		this.bumpMap = null;
		this.bumpScale = 1;
		this.normalMap = null;
		this.normalMapType = TangentSpaceNormalMap;
		this.normalScale = new Vector2( 1, 1 );
		this.displacementMap = null;
		this.displacementScale = 1;
		this.displacementBias = 0;
		this.wireframe = false;
		this.wireframeLinewidth = 1;
		this.fog = false;
		this.skinning = false;
		this.morphTargets = false;
		this.morphNormals = false;
		this.setValues( parameters );
	}
	MeshNormalMaterial.prototype = Object.create( Material.prototype );
	MeshNormalMaterial.prototype.constructor = MeshNormalMaterial;
	MeshNormalMaterial.prototype.isMeshNormalMaterial = true;
	MeshNormalMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.bumpMap = source.bumpMap;
		this.bumpScale = source.bumpScale;
		this.normalMap = source.normalMap;
		this.normalMapType = source.normalMapType;
		this.normalScale.copy( source.normalScale );
		this.displacementMap = source.displacementMap;
		this.displacementScale = source.displacementScale;
		this.displacementBias = source.displacementBias;
		this.wireframe = source.wireframe;
		this.wireframeLinewidth = source.wireframeLinewidth;
		this.skinning = source.skinning;
		this.morphTargets = source.morphTargets;
		this.morphNormals = source.morphNormals;
		return this;
	};
	/**
	 * @author mrdoob / http://mrdoob.com/
	 * @author alteredq / http://alteredqualia.com/
	 *
	 * parameters = {
	 *  color: ,
	 *  opacity: ,
	 *
	 *  map: new THREE.Texture(  ),
	 *
	 *  lightMap: new THREE.Texture(  ),
	 *  lightMapIntensity: 
	 *
	 *  aoMap: new THREE.Texture(  ),
	 *  aoMapIntensity: 
	 *
	 *  emissive: ,
	 *  emissiveIntensity: 
	 *  emissiveMap: new THREE.Texture(  ),
	 *
	 *  specularMap: new THREE.Texture(  ),
	 *
	 *  alphaMap: new THREE.Texture(  ),
	 *
	 *  envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
	 *  combine: THREE.Multiply,
	 *  reflectivity: ,
	 *  refractionRatio: ,
	 *
	 *  wireframe: ,
	 *  wireframeLinewidth: ,
	 *
	 *  skinning: ,
	 *  morphTargets: ,
	 *  morphNormals: 
	 * }
	 */
	function MeshLambertMaterial( parameters ) {
		Material.call( this );
		this.type = 'MeshLambertMaterial';
		this.color = new Color( 0xffffff ); // diffuse
		this.map = null;
		this.lightMap = null;
		this.lightMapIntensity = 1.0;
		this.aoMap = null;
		this.aoMapIntensity = 1.0;
		this.emissive = new Color( 0x000000 );
		this.emissiveIntensity = 1.0;
		this.emissiveMap = null;
		this.specularMap = null;
		this.alphaMap = null;
		this.envMap = null;
		this.combine = MultiplyOperation;
		this.reflectivity = 1;
		this.refractionRatio = 0.98;
		this.wireframe = false;
		this.wireframeLinewidth = 1;
		this.wireframeLinecap = 'round';
		this.wireframeLinejoin = 'round';
		this.skinning = false;
		this.morphTargets = false;
		this.morphNormals = false;
		this.setValues( parameters );
	}
	MeshLambertMaterial.prototype = Object.create( Material.prototype );
	MeshLambertMaterial.prototype.constructor = MeshLambertMaterial;
	MeshLambertMaterial.prototype.isMeshLambertMaterial = true;
	MeshLambertMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.color.copy( source.color );
		this.map = source.map;
		this.lightMap = source.lightMap;
		this.lightMapIntensity = source.lightMapIntensity;
		this.aoMap = source.aoMap;
		this.aoMapIntensity = source.aoMapIntensity;
		this.emissive.copy( source.emissive );
		this.emissiveMap = source.emissiveMap;
		this.emissiveIntensity = source.emissiveIntensity;
		this.specularMap = source.specularMap;
		this.alphaMap = source.alphaMap;
		this.envMap = source.envMap;
		this.combine = source.combine;
		this.reflectivity = source.reflectivity;
		this.refractionRatio = source.refractionRatio;
		this.wireframe = source.wireframe;
		this.wireframeLinewidth = source.wireframeLinewidth;
		this.wireframeLinecap = source.wireframeLinecap;
		this.wireframeLinejoin = source.wireframeLinejoin;
		this.skinning = source.skinning;
		this.morphTargets = source.morphTargets;
		this.morphNormals = source.morphNormals;
		return this;
	};
	/**
	 * @author WestLangley / http://github.com/WestLangley
	 *
	 * parameters = {
	 *  color: ,
	 *  opacity: ,
	 *
	 *  matcap: new THREE.Texture(  ),
	 *
	 *  map: new THREE.Texture(  ),
	 *
	 *  bumpMap: new THREE.Texture(  ),
	 *  bumpScale: ,
	 *
	 *  normalMap: new THREE.Texture(  ),
	 *  normalMapType: THREE.TangentSpaceNormalMap,
	 *  normalScale: ,
	 *
	 *  displacementMap: new THREE.Texture(  ),
	 *  displacementScale: ,
	 *  displacementBias: ,
	 *
	 *  alphaMap: new THREE.Texture(  ),
	 *
	 *  skinning: ,
	 *  morphTargets: ,
	 *  morphNormals: 
	 * }
	 */
	function MeshMatcapMaterial( parameters ) {
		Material.call( this );
		this.defines = { 'MATCAP': '' };
		this.type = 'MeshMatcapMaterial';
		this.color = new Color( 0xffffff ); // diffuse
		this.matcap = null;
		this.map = null;
		this.bumpMap = null;
		this.bumpScale = 1;
		this.normalMap = null;
		this.normalMapType = TangentSpaceNormalMap;
		this.normalScale = new Vector2( 1, 1 );
		this.displacementMap = null;
		this.displacementScale = 1;
		this.displacementBias = 0;
		this.alphaMap = null;
		this.skinning = false;
		this.morphTargets = false;
		this.morphNormals = false;
		this.setValues( parameters );
	}
	MeshMatcapMaterial.prototype = Object.create( Material.prototype );
	MeshMatcapMaterial.prototype.constructor = MeshMatcapMaterial;
	MeshMatcapMaterial.prototype.isMeshMatcapMaterial = true;
	MeshMatcapMaterial.prototype.copy = function ( source ) {
		Material.prototype.copy.call( this, source );
		this.defines = { 'MATCAP': '' };
		this.color.copy( source.color );
		this.matcap = source.matcap;
		this.map = source.map;
		this.bumpMap = source.bumpMap;
		this.bumpScale = source.bumpScale;
		this.normalMap = source.normalMap;
		this.normalMapType = source.normalMapType;
		this.normalScale.copy( source.normalScale );
		this.displacementMap = source.displacementMap;
		this.displacementScale = source.displacementScale;
		this.displacementBias = source.displacementBias;
		this.alphaMap = source.alphaMap;
		this.skinning = source.skinning;
		this.morphTargets = source.morphTargets;
		this.morphNormals = source.morphNormals;
		return this;
	};
	/**
	 * @author alteredq / http://alteredqualia.com/
	 *
	 * parameters = {
	 *  color: ,
	 *  opacity: ,
	 *
	 *  linewidth: ,
	 *
	 *  scale: ,
	 *  dashSize: ,
	 *  gapSize: 
	 * }
	 */
	function LineDashedMaterial( parameters ) {
		LineBasicMaterial.call( this );
		this.type = 'LineDashedMaterial';
		this.scale = 1;
		this.dashSize = 3;
		this.gapSize = 1;
		this.setValues( parameters );
	}
	LineDashedMaterial.prototype = Object.create( LineBasicMaterial.prototype );
	LineDashedMaterial.prototype.constructor = LineDashedMaterial;
	LineDashedMaterial.prototype.isLineDashedMaterial = true;
	LineDashedMaterial.prototype.copy = function ( source ) {
		LineBasicMaterial.prototype.copy.call( this, source );
		this.scale = source.scale;
		this.dashSize = source.dashSize;
		this.gapSize = source.gapSize;
		return this;
	};
	var Materials = /*#__PURE__*/Object.freeze({
		__proto__: null,
		ShadowMaterial: ShadowMaterial,
		SpriteMaterial: SpriteMaterial,
		RawShaderMaterial: RawShaderMaterial,
		ShaderMaterial: ShaderMaterial,
		PointsMaterial: PointsMaterial,
		MeshPhysicalMaterial: MeshPhysicalMaterial,
		MeshStandardMaterial: MeshStandardMaterial,
		MeshPhongMaterial: MeshPhongMaterial,
		MeshToonMaterial: MeshToonMaterial,
		MeshNormalMaterial: MeshNormalMaterial,
		MeshLambertMaterial: MeshLambertMaterial,
		MeshDepthMaterial: MeshDepthMaterial,
		MeshDistanceMaterial: MeshDistanceMaterial,
		MeshBasicMaterial: MeshBasicMaterial,
		MeshMatcapMaterial: MeshMatcapMaterial,
		LineDashedMaterial: LineDashedMaterial,
		LineBasicMaterial: LineBasicMaterial,
		Material: Material
	});
	/**
	 * @author tschw
	 * @author Ben Houston / http://clara.io/
	 * @author David Sarno / http://lighthaus.us/
	 */
	var AnimationUtils = {
		// same as Array.prototype.slice, but also works on typed arrays
		arraySlice: function ( array, from, to ) {
			if ( AnimationUtils.isTypedArray( array ) ) {
				// in ios9 array.subarray(from, undefined) will return empty array
				// but array.subarray(from) or array.subarray(from, len) is correct
				return new array.constructor( array.subarray( from, to !== undefined ? to : array.length ) );
			}
			return array.slice( from, to );
		},
		// converts an array to a specific type
		convertArray: function ( array, type, forceClone ) {
			if ( ! array || // let 'undefined' and 'null' pass
				! forceClone && array.constructor === type ) { return array; }
			if ( typeof type.BYTES_PER_ELEMENT === 'number' ) {
				return new type( array ); // create typed array
			}
			return Array.prototype.slice.call( array ); // create Array
		},
		isTypedArray: function ( object ) {
			return ArrayBuffer.isView( object ) &&
				! ( object instanceof DataView );
		},
		// returns an array by which times and values can be sorted
		getKeyframeOrder: function ( times ) {
			function compareTime( i, j ) {
				return times[ i ] - times[ j ];
			}
			var n = times.length;
			var result = new Array( n );
			for ( var i = 0; i !== n; ++ i ) { result[ i ] = i; }
			result.sort( compareTime );
			return result;
		},
		// uses the array previously returned by 'getKeyframeOrder' to sort data
		sortedArray: function ( values, stride, order ) {
			var nValues = values.length;
			var result = new values.constructor( nValues );
			for ( var i = 0, dstOffset = 0; dstOffset !== nValues; ++ i ) {
				var srcOffset = order[ i ] * stride;
				for ( var j = 0; j !== stride; ++ j ) {
					result[ dstOffset ++ ] = values[ srcOffset + j ];
				}
			}
			return result;
		},
		// function for parsing AOS keyframe formats
		flattenJSON: function ( jsonKeys, times, values, valuePropertyName ) {
			var i = 1, key = jsonKeys[ 0 ];
			while ( key !== undefined && key[ valuePropertyName ] === undefined ) {
				key = jsonKeys[ i ++ ];
			}
			if ( key === undefined ) { return; } // no data
			var value = key[ valuePropertyName ];
			if ( value === undefined ) { return; } // no data
			if ( Array.isArray( value ) ) {
				do {
					value = key[ valuePropertyName ];
					if ( value !== undefined ) {
						times.push( key.time );
						values.push.apply( values, value ); // push all elements
					}
					key = jsonKeys[ i ++ ];
				} while ( key !== undefined );
			} else if ( value.toArray !== undefined ) {
				// ...assume THREE.Math-ish
				do {
					value = key[ valuePropertyName ];
					if ( value !== undefined ) {
						times.push( key.time );
						value.toArray( values, values.length );
					}
					key = jsonKeys[ i ++ ];
				} while ( key !== undefined );
			} else {
				// otherwise push as-is
				do {
					value = key[ valuePropertyName ];
					if ( value !== undefined ) {
						times.push( key.time );
						values.push( value );
					}
					key = jsonKeys[ i ++ ];
				} while ( key !== undefined );
			}
		},
		subclip: function ( sourceClip, name, startFrame, endFrame, fps ) {
			fps = fps || 30;
			var clip = sourceClip.clone();
			clip.name = name;
			var tracks = [];
			for ( var i = 0; i = endFrame ) { continue; }
					times.push( track.times[ j ] );
					for ( var k = 0; k  clip.tracks[ i ].times[ 0 ] ) {
					minStartTime = clip.tracks[ i ].times[ 0 ];
				}
			}
			// shift all tracks such that clip begins at t=0
			for ( var i = 0; i = referenceTrack.times[ lastIndex ] ) {
					// Reference frame is after the last keyframe, so just use the last keyframe
					var startIndex = lastIndex * valueSize;
					referenceValue = AnimationUtils.arraySlice( referenceTrack.values, startIndex );
				} else {
					// Interpolate to the reference value
					var interpolant = referenceTrack.createInterpolant();
					interpolant.evaluate( referenceTime );
					referenceValue = interpolant.resultBuffer;
				}
				// Conjugate the quaternion
				if ( referenceTrackType === 'quaternion' ) {
					var referenceQuat = new Quaternion(
						referenceValue[ 0 ],
						referenceValue[ 1 ],
						referenceValue[ 2 ],
						referenceValue[ 3 ]
					).normalize().conjugate();
					referenceQuat.toArray( referenceValue );
				}
				// Subtract the reference value from all of the track values
				var numTimes = targetTrack.times.length;
				for ( var j = 0; j = t1 || t1 === undefined ) {
						forward_scan: if ( ! ( t = t0 ) ) {
							// looping?
							var t1global = pp[ 1 ];
							if ( t = t0 ) {
									// we have arrived at the sought interval
									break seek;
								}
							}
							// prepare binary search on the left side of the index
							right = i1;
							i1 = 0;
							break linear_scan;
						}
						// the interval is valid
						break validate_interval;
					} // linear scan
					// binary search
					while ( i1 >> 1;
						if ( t  seconds conversions)
		scale: function ( timeScale ) {
			if ( timeScale !== 1.0 ) {
				var times = this.times;
				for ( var i = 0, n = times.length; i !== n; ++ i ) {
					times[ i ] *= timeScale;
				}
			}
			return this;
		},
		// removes keyframes before and after animation without changing any values within the range [startTime, endTime].
		// IMPORTANT: We do not shift around keys to the start of the track time, because for interpolated keys this will change their values
		trim: function ( startTime, endTime ) {
			var times = this.times,
				nKeys = times.length,
				from = 0,
				to = nKeys - 1;
			while ( from !== nKeys && times[ from ]  endTime ) {
				-- to;
			}
			++ to; // inclusive -> exclusive bound
			if ( from !== 0 || to !== nKeys ) {
				// empty tracks are forbidden, so keep at least one keyframe
				if ( from >= to ) {
					to = Math.max( to, 1 );
					from = to - 1;
				}
				var stride = this.getValueSize();
				this.times = AnimationUtils.arraySlice( times, from, to );
				this.values = AnimationUtils.arraySlice( this.values, from * stride, to * stride );

1 Project 3 Three js Project Overview In this project you will create a unique 3D animated scene composed of Three.js graphic components. The scene should include animation, lighting and multiple...

Answer To: 1 Project 3 Three js Project Overview In this project you will create a unique 3D animated scene...

Answer To This Question Is Available To Download

Related Questions & Answers

Submit New Assignment