text: /**
   * @author mrdoob / http://mrdoob.com/
   * @author *kile / http://kile.stravaganza.org/
   * @author philogb / http://blog.thejit.org/
   * @author mikael emtinger / http://gomo.se/
   * @author egraether / http://egraether.com/
   * @author WestLangley / http://github.com/WestLangley
   */
  
  THREE.Vector3 = function ( x, y, z ) {
  
  	this.x = x || 0;
  	this.y = y || 0;
  	this.z = z || 0;
  
  };
  
  THREE.Vector3.prototype = {
  
  	constructor: THREE.Vector3,
  
  	set: function ( x, y, z ) {
  
  		this.x = x;
  		this.y = y;
  		this.z = z;
  
  		return this;
  
  	},
  
  	setX: function ( x ) {
  
  		this.x = x;
  
  		return this;
  
  	},
  
  	setY: function ( y ) {
  
  		this.y = y;
  
  		return this;
  
  	},
  
  	setZ: function ( z ) {
  
  		this.z = z;
  
  		return this;
  
  	},
  
  	setComponent: function ( index, value ) {
  
  		switch ( index ) {
  
  			case 0: this.x = value; break;
  			case 1: this.y = value; break;
  			case 2: this.z = value; break;
  			default: throw new Error( "index is out of range: " + index );
  
  		}
  
  	},
  
  	getComponent: function ( index ) {
  
  		switch ( index ) {
  
  			case 0: return this.x;
  			case 1: return this.y;
  			case 2: return this.z;
  			default: throw new Error( "index is out of range: " + index );
  
  		}
  
  	},
  
  	copy: function ( v ) {
  
  		this.x = v.x;
  		this.y = v.y;
  		this.z = v.z;
  
  		return this;
  
  	},
  
  	add: function ( v, w ) {
  
  		if ( w !== undefined ) {
  
  			console.warn( 'DEPRECATED: Vector3\'s .add() now only accepts one argument. Use .addVectors( a, b ) instead.' );
  			return this.addVectors( v, w );
  
  		}
  
  		this.x += v.x;
  		this.y += v.y;
  		this.z += v.z;
  
  		return this;
  
  	},
  
  	addScalar: function ( s ) {
  
  		this.x += s;
  		this.y += s;
  		this.z += s;
  
  		return this;
  
  	},
  
  	addVectors: function ( a, b ) {
  
  		this.x = a.x + b.x;
  		this.y = a.y + b.y;
  		this.z = a.z + b.z;
  
  		return this;
  
  	},
  
  	sub: function ( v, w ) {
  
  		if ( w !== undefined ) {
  
  			console.warn( 'DEPRECATED: Vector3\'s .sub() now only accepts one argument. Use .subVectors( a, b ) instead.' );
  			return this.subVectors( v, w );
  
  		}
  
  		this.x -= v.x;
  		this.y -= v.y;
  		this.z -= v.z;
  
  		return this;
  
  	},
  
  	subVectors: function ( a, b ) {
  
  		this.x = a.x - b.x;
  		this.y = a.y - b.y;
  		this.z = a.z - b.z;
  
  		return this;
  
  	},
  
  	multiply: function ( v, w ) {
  
  		if ( w !== undefined ) {
  
  			console.warn( 'DEPRECATED: Vector3\'s .multiply() now only accepts one argument. Use .multiplyVectors( a, b ) instead.' );
  			return this.multiplyVectors( v, w );
  
  		}
  
  		this.x *= v.x;
  		this.y *= v.y;
  		this.z *= v.z;
  
  		return this;
  
  	},
  
  	multiplyScalar: function ( s ) {
  
  		this.x *= s;
  		this.y *= s;
  		this.z *= s;
  
  		return this;
  
  	},
  
  	multiplyVectors: function ( a, b ) {
  
  		this.x = a.x * b.x;
  		this.y = a.y * b.y;
  		this.z = a.z * b.z;
  
  		return this;
  
  	},
  
  	applyMatrix3: function ( m ) {
  
  		var x = this.x;
  		var y = this.y;
  		var z = this.z;
  
  		var e = m.elements;
  
  		this.x = e[0] * x + e[3] * y + e[6] * z;
  		this.y = e[1] * x + e[4] * y + e[7] * z;
  		this.z = e[2] * x + e[5] * y + e[8] * z;
  
  		return this;
  
  	},
  
  	applyMatrix4: function ( m ) {
  
  		// input: THREE.Matrix4 affine matrix
  
  		var x = this.x, y = this.y, z = this.z;
  
  		var e = m.elements;
  
  		this.x = e[0] * x + e[4] * y + e[8]  * z + e[12];
  		this.y = e[1] * x + e[5] * y + e[9]  * z + e[13];
  		this.z = e[2] * x + e[6] * y + e[10] * z + e[14];
  
  		return this;
  
  	},
  
  	applyProjection: function ( m ) {
  
  		// input: THREE.Matrix4 projection matrix
  
  		var x = this.x, y = this.y, z = this.z;
  
  		var e = m.elements;
  		var d = 1 / ( e[3] * x + e[7] * y + e[11] * z + e[15] ); // perspective divide
  
  		this.x = ( e[0] * x + e[4] * y + e[8]  * z + e[12] ) * d;
  		this.y = ( e[1] * x + e[5] * y + e[9]  * z + e[13] ) * d;
  		this.z = ( e[2] * x + e[6] * y + e[10] * z + e[14] ) * d;
  
  		return this;
  
  	},
  
  	applyQuaternion: function ( q ) {
  
  		var x = this.x;
  		var y = this.y;
  		var z = this.z;
  
  		var qx = q.x;
  		var qy = q.y;
  		var qz = q.z;
  		var qw = q.w;
  
  		// calculate quat * vector
  
  		var ix =  qw * x + qy * z - qz * y;
  		var iy =  qw * y + qz * x - qx * z;
  		var iz =  qw * z + qx * y - qy * x;
  		var iw = -qx * x - qy * y - qz * z;
  
  		// calculate result * inverse quat
  
  		this.x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
  		this.y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
  		this.z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
  
  		return this;
  
  	},
  
  	transformDirection: function ( m ) {
  
  		// input: THREE.Matrix4 affine matrix
  		// vector interpreted as a direction
  
  		var x = this.x, y = this.y, z = this.z;
  
  		var e = m.elements;
  
  		this.x = e[0] * x + e[4] * y + e[8]  * z;
  		this.y = e[1] * x + e[5] * y + e[9]  * z;
  		this.z = e[2] * x + e[6] * y + e[10] * z;
  
  		this.normalize();
  
  		return this;
  
  	},
  
  	divide: function ( v ) {
  
  		this.x /= v.x;
  		this.y /= v.y;
  		this.z /= v.z;
  
  		return this;
  
  	},
  
  	divideScalar: function ( s ) {
  
  		if ( s !== 0 ) {
  
  			this.x /= s;
  			this.y /= s;
  			this.z /= s;
  
  		} else {
  
  			this.x = 0;
  			this.y = 0;
  			this.z = 0;
  
  		}
  
  		return this;
  
  	},
  
  	min: function ( v ) {
  
  		if ( this.x > v.x ) {
  
  			this.x = v.x;
  
  		}
  
  		if ( this.y > v.y ) {
  
  			this.y = v.y;
  
  		}
  
  		if ( this.z > v.z ) {
  
  			this.z = v.z;
  
  		}
  
  		return this;
  
  	},
  
  	max: function ( v ) {
  
  		if ( this.x < v.x ) {
  
  			this.x = v.x;
  
  		}
  
  		if ( this.y < v.y ) {
  
  			this.y = v.y;
  
  		}
  
  		if ( this.z < v.z ) {
  
  			this.z = v.z;
  
  		}
  
  		return this;
  
  	},
  
  	clamp: function ( min, max ) {
  
  		// This function assumes min < max, if this assumption isn't true it will not operate correctly
  
  		if ( this.x < min.x ) {
  
  			this.x = min.x;
  
  		} else if ( this.x > max.x ) {
  
  			this.x = max.x;
  
  		}
  
  		if ( this.y < min.y ) {
  
  			this.y = min.y;
  
  		} else if ( this.y > max.y ) {
  
  			this.y = max.y;
  
  		}
  
  		if ( this.z < min.z ) {
  
  			this.z = min.z;
  
  		} else if ( this.z > max.z ) {
  
  			this.z = max.z;
  
  		}
  
  		return this;
  
  	},
  
  	negate: function () {
  
  		return this.multiplyScalar( - 1 );
  
  	},
  
  	dot: function ( v ) {
  
  		return this.x * v.x + this.y * v.y + this.z * v.z;
  
  	},
  
  	lengthSq: function () {
  
  		return this.x * this.x + this.y * this.y + this.z * this.z;
  
  	},
  
  	length: function () {
  
  		return Math.sqrt( this.x * this.x + this.y * this.y + this.z * this.z );
  
  	},
  
  	lengthManhattan: function () {
  
  		return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z );
  
  	},
  
  	normalize: function () {
  
  		return this.divideScalar( this.length() );
  
  	},
  
  	setLength: function ( l ) {
  
  		var oldLength = this.length();
  
  		if ( oldLength !== 0 && l !== oldLength  ) {
  
  			this.multiplyScalar( l / oldLength );
  		}
  
  		return this;
  
  	},
  
  	lerp: function ( v, alpha ) {
  
  		this.x += ( v.x - this.x ) * alpha;
  		this.y += ( v.y - this.y ) * alpha;
  		this.z += ( v.z - this.z ) * alpha;
  
  		return this;
  
  	},
  
  	cross: function ( v, w ) {
  
  		if ( w !== undefined ) {
  
  			console.warn( 'DEPRECATED: Vector3\'s .cross() now only accepts one argument. Use .crossVectors( a, b ) instead.' );
  			return this.crossVectors( v, w );
  
  		}
  
  		var x = this.x, y = this.y, z = this.z;
  
  		this.x = y * v.z - z * v.y;
  		this.y = z * v.x - x * v.z;
  		this.z = x * v.y - y * v.x;
  
  		return this;
  
  	},
  
  	crossVectors: function ( a, b ) {
  
  		this.x = a.y * b.z - a.z * b.y;
  		this.y = a.z * b.x - a.x * b.z;
  		this.z = a.x * b.y - a.y * b.x;
  
  		return this;
  
  	},
  
  	angleTo: function ( v ) {
  
  		var theta = this.dot( v ) / ( this.length() * v.length() );
  
  		// clamp, to handle numerical problems
  
  		return Math.acos( THREE.Math.clamp( theta, -1, 1 ) );
  
  	},
  
  	distanceTo: function ( v ) {
  
  		return Math.sqrt( this.distanceToSquared( v ) );
  
  	},
  
  	distanceToSquared: function ( v ) {
  
  		var dx = this.x - v.x;
  		var dy = this.y - v.y;
  		var dz = this.z - v.z;
  
  		return dx * dx + dy * dy + dz * dz;
  
  	},
  
  	setEulerFromRotationMatrix: function ( m, order ) {
  
  		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
  
  		// clamp, to handle numerical problems
  
  		function clamp( x ) {
  
  			return Math.min( Math.max( x, -1 ), 1 );
  
  		}
  
  		var te = m.elements;
  		var m11 = te[0], m12 = te[4], m13 = te[8];
  		var m21 = te[1], m22 = te[5], m23 = te[9];
  		var m31 = te[2], m32 = te[6], m33 = te[10];
  
  		if ( order === undefined || order === 'XYZ' ) {
  
  			this.y = Math.asin( clamp( m13 ) );
  
  			if ( Math.abs( m13 ) < 0.99999 ) {
  
  				this.x = Math.atan2( - m23, m33 );
  				this.z = Math.atan2( - m12, m11 );
  
  			} else {
  
  				this.x = Math.atan2( m32, m22 );
  				this.z = 0;
  
  			}
  
  		} else if ( order === 'YXZ' ) {
  
  			this.x = Math.asin( - clamp( m23 ) );
  
  			if ( Math.abs( m23 ) < 0.99999 ) {
  
  				this.y = Math.atan2( m13, m33 );
  				this.z = Math.atan2( m21, m22 );
  
  			} else {
  
  				this.y = Math.atan2( - m31, m11 );
  				this.z = 0;
  
  			}
  
  		} else if ( order === 'ZXY' ) {
  
  			this.x = Math.asin( clamp( m32 ) );
  
  			if ( Math.abs( m32 ) < 0.99999 ) {
  
  				this.y = Math.atan2( - m31, m33 );
  				this.z = Math.atan2( - m12, m22 );
  
  			} else {
  
  				this.y = 0;
  				this.z = Math.atan2( m21, m11 );
  
  			}
  
  		} else if ( order === 'ZYX' ) {
  
  			this.y = Math.asin( - clamp( m31 ) );
  
  			if ( Math.abs( m31 ) < 0.99999 ) {
  
  				this.x = Math.atan2( m32, m33 );
  				this.z = Math.atan2( m21, m11 );
  
  			} else {
  
  				this.x = 0;
  				this.z = Math.atan2( - m12, m22 );
  
  			}
  
  		} else if ( order === 'YZX' ) {
  
  			this.z = Math.asin( clamp( m21 ) );
  
  			if ( Math.abs( m21 ) < 0.99999 ) {
  
  				this.x = Math.atan2( - m23, m22 );
  				this.y = Math.atan2( - m31, m11 );
  
  			} else {
  
  				this.x = 0;
  				this.y = Math.atan2( m13, m33 );
  
  			}
  
  		} else if ( order === 'XZY' ) {
  
  			this.z = Math.asin( - clamp( m12 ) );
  
  			if ( Math.abs( m12 ) < 0.99999 ) {
  
  				this.x = Math.atan2( m32, m22 );
  				this.y = Math.atan2( m13, m11 );
  
  			} else {
  
  				this.x = Math.atan2( - m23, m33 );
  				this.y = 0;
  
  			}
  
  		}
  
  		return this;
  
  	},
  
  	setEulerFromQuaternion: function ( q, order ) {
  
  		// q is assumed to be normalized
  
  		// clamp, to handle numerical problems
  
  		function clamp( x ) {
  
  			return Math.min( Math.max( x, -1 ), 1 );
  
  		}
  
  		// http://www.mathworks.com/matlabcentral/fileexchange/20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/content/SpinCalc.m
  
  		var sqx = q.x * q.x;
  		var sqy = q.y * q.y;
  		var sqz = q.z * q.z;
  		var sqw = q.w * q.w;
  
  		if ( order === undefined || order === 'XYZ' ) {
  
  			this.x = Math.atan2( 2 * ( q.x * q.w - q.y * q.z ), ( sqw - sqx - sqy + sqz ) );
  			this.y = Math.asin(  clamp( 2 * ( q.x * q.z + q.y * q.w ) ) );
  			this.z = Math.atan2( 2 * ( q.z * q.w - q.x * q.y ), ( sqw + sqx - sqy - sqz ) );
  
  		} else if ( order ===  'YXZ' ) {
  
  			this.x = Math.asin(  clamp( 2 * ( q.x * q.w - q.y * q.z ) ) );
  			this.y = Math.atan2( 2 * ( q.x * q.z + q.y * q.w ), ( sqw - sqx - sqy + sqz ) );
  			this.z = Math.atan2( 2 * ( q.x * q.y + q.z * q.w ), ( sqw - sqx + sqy - sqz ) );
  
  		} else if ( order === 'ZXY' ) {
  
  			this.x = Math.asin(  clamp( 2 * ( q.x * q.w + q.y * q.z ) ) );
  			this.y = Math.atan2( 2 * ( q.y * q.w - q.z * q.x ), ( sqw - sqx - sqy + sqz ) );
  			this.z = Math.atan2( 2 * ( q.z * q.w - q.x * q.y ), ( sqw - sqx + sqy - sqz ) );
  
  		} else if ( order === 'ZYX' ) {
  
  			this.x = Math.atan2( 2 * ( q.x * q.w + q.z * q.y ), ( sqw - sqx - sqy + sqz ) );
  			this.y = Math.asin(  clamp( 2 * ( q.y * q.w - q.x * q.z ) ) );
  			this.z = Math.atan2( 2 * ( q.x * q.y + q.z * q.w ), ( sqw + sqx - sqy - sqz ) );
  
  		} else if ( order === 'YZX' ) {
  
  			this.x = Math.atan2( 2 * ( q.x * q.w - q.z * q.y ), ( sqw - sqx + sqy - sqz ) );
  			this.y = Math.atan2( 2 * ( q.y * q.w - q.x * q.z ), ( sqw + sqx - sqy - sqz ) );
  			this.z = Math.asin(  clamp( 2 * ( q.x * q.y + q.z * q.w ) ) );
  
  		} else if ( order === 'XZY' ) {
  
  			this.x = Math.atan2( 2 * ( q.x * q.w + q.y * q.z ), ( sqw - sqx + sqy - sqz ) );
  			this.y = Math.atan2( 2 * ( q.x * q.z + q.y * q.w ), ( sqw + sqx - sqy - sqz ) );
  			this.z = Math.asin(  clamp( 2 * ( q.z * q.w - q.x * q.y ) ) );
  
  		}
  
  		return this;
  
  	},
  
  	getPositionFromMatrix: function ( m ) {
  
  		this.x = m.elements[12];
  		this.y = m.elements[13];
  		this.z = m.elements[14];
  
  		return this;
  
  	},
  
  	getScaleFromMatrix: function ( m ) {
  
  		var sx = this.set( m.elements[0], m.elements[1], m.elements[2] ).length();
  		var sy = this.set( m.elements[4], m.elements[5], m.elements[6] ).length();
  		var sz = this.set( m.elements[8], m.elements[9], m.elements[10] ).length();
  
  		this.x = sx;
  		this.y = sy;
  		this.z = sz;
  
  		return this;
  	},
  
  	getColumnFromMatrix: function ( index, matrix ) {
  
  		var offset = index * 4;
  
  		var me = matrix.elements;
  
  		this.x = me[ offset ];
  		this.y = me[ offset + 1 ];
  		this.z = me[ offset + 2 ];
  
  		return this;
  
  	},
  
  	equals: function ( v ) {
  
  		return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) );
  
  	},
  
  	toArray: function () {
  
  		return [ this.x, this.y, this.z ];
  
  	},
  
  	clone: function () {
  
  		return new THREE.Vector3( this.x, this.y, this.z );
  
  	}
  
  };
  
  THREE.extend( THREE.Vector3.prototype, {
  
  	applyEuler: function () {
  
  		var q1 = new THREE.Quaternion();
  
  		return function ( v, eulerOrder ) {
  
  			var quaternion = q1.setFromEuler( v, eulerOrder );
  
  			this.applyQuaternion( quaternion );
  
  			return this;
  
  		};
  
  	}(),
  
  	applyAxisAngle: function () {
  
  		var q1 = new THREE.Quaternion();
  
  		return function ( axis, angle ) {
  
  			var quaternion = q1.setFromAxisAngle( axis, angle );
  
  			this.applyQuaternion( quaternion );
  
  			return this;
  
  		};
  
  	}(),
  
  	projectOnVector: function () {
  
  		var v1 = new THREE.Vector3();
  
  		return function ( vector ) {
  
  			v1.copy( vector ).normalize();
  			var d = this.dot( v1 );
  			return this.copy( v1 ).multiplyScalar( d );
  
  		};
  
  	}(),
  
  	projectOnPlane: function () {
  
  		var v1 = new THREE.Vector3();
  
  		return function ( planeNormal ) {
  
  			v1.copy( this ).projectOnVector( planeNormal );
  
  			return this.sub( v1 );
  
  		}
  
  	}(),
  
  	reflect: function () {
  
  		var v1 = new THREE.Vector3();
  
  		return function ( vector ) {
  
  		    v1.copy( this ).projectOnVector( vector ).multiplyScalar( 2 );
  
  		    return this.subVectors( v1, this );
  
  		}
  
  	}()
  
  } );
  