From 4e9b72bf41719b8a9e735412c8781893b21981b5 Mon Sep 17 00:00:00 2001
From: amelie <amelie.heliou@polytechnique.edu>
Date: Thu, 12 May 2016 08:55:57 +0200
Subject: [PATCH 01/63] trying with three.js

---
 html/2by2.html | 57 +++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 56 insertions(+), 1 deletion(-)

diff --git a/html/2by2.html b/html/2by2.html
index cdee2d3..aca6087 100644
--- a/html/2by2.html
+++ b/html/2by2.html
@@ -6,6 +6,9 @@
         <title>2 by 2 games</title>
         <link rel="stylesheet" href="css/2by2.css">
         <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>
+        <script src="js/three/three.js"></script>
+        <script src="js/three/renderers/Projector.js"></script>
+		<script src="js/three/renderers/CanvasRenderer.js"></script>
     </head>
 
 <script>
@@ -95,7 +98,59 @@
     <td><input class="player1" type="text" name=P22_1 value=0>\<input class="player2" type="text" name=P22_2  value=0></td>
   </tr>
 </table>
-        <canvas id="Payoff2" width="200" height="500">
+        <canvas id="Payoff2" width="200" height="300">
         </canvas>
+        
+<script>
+$(document).ready(function(){
+    container = document.createElement( 'div' );
+    document.body.appendChild( container );
+    scene = new THREE.Scene();
+    camera = new THREE.PerspectiveCamera( 10, 1, 1, 10000 );
+    camera.position.z = 100;
+    renderer = new THREE.WebGLRenderer();
+    //renderer.setPixelRatio( window.devicePixelRatio );
+    renderer.setSize( window.innerWidth, window.innerWidth );
+    renderer.setClearColor( 0xffffff, 1);
+    container.appendChild( renderer.domElement );
+    var material = new THREE.LineBasicMaterial({color: 0x0000ff});
+    var geometry = new THREE.Geometry();
+    geometry.vertices.push(new THREE.Vector3( -window.innerWidth/2, -window.innerWidth/2, 0 ),
+                           new THREE.Vector3( 0, 0, 0 ),
+                           new THREE.Vector3( (window.innerWidth-1)/2, 0, 0 ),
+                           new THREE.Vector3( 5, 5, 0 )
+                           );
+                  
+                  
+    var P11_1=parseInt($("[name='P11_1']").val(),10);
+    var P12_1=parseInt($("[name='P12_1']").val(),10);
+    var maxP1_1;
+    var maxP1_2;
+    var minP1_1;
+    var minP1_2;
+    var P21_1=parseInt($("[name='P21_1']").val(),10);
+    var P22_1=parseInt($("[name='P22_1']").val(),10);
+    if( P11_1>P21_1){
+    maxP1_1=P11_1;
+    minP1_1=P21_1;
+    }else{
+    maxP1_1=P21_1;
+    minP1_1=P11_1;
+    }
+    if( P12_1>P22_1){
+    maxP1_2=P12_1;
+    minP1_2=P22_1;
+    }else{
+    maxP1_2=P22_1;
+    minP1_2=P12_1;
+    }
+                                                                      
+   var line = new THREE.Line( geometry, material );
+                  scene.add( line );
+   renderer.render( scene, camera);
+});
+   
+</script>
+                                                                    
 </body>
 </html>

From dc5c3496f4bed1ab0463bdd26e6561be497ae8a3 Mon Sep 17 00:00:00 2001
From: amelie <amelie.heliou@polytechnique.edu>
Date: Thu, 12 May 2016 08:56:14 +0200
Subject: [PATCH 02/63] trying with three.js

---
 html/js/three/renderers/CanvasRenderer.js |  1114 +
 html/js/three/renderers/Projector.js      |   921 +
 html/js/three/three.js                    | 41507 ++++++++++++++++++++
 3 files changed, 43542 insertions(+)
 create mode 100755 html/js/three/renderers/CanvasRenderer.js
 create mode 100755 html/js/three/renderers/Projector.js
 create mode 100755 html/js/three/three.js

diff --git a/html/js/three/renderers/CanvasRenderer.js b/html/js/three/renderers/CanvasRenderer.js
new file mode 100755
index 0000000..7009e72
--- /dev/null
+++ b/html/js/three/renderers/CanvasRenderer.js
@@ -0,0 +1,1114 @@
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.SpriteCanvasMaterial = function ( parameters ) {
+
+	THREE.Material.call( this );
+
+	this.type = 'SpriteCanvasMaterial';
+
+	this.color = new THREE.Color( 0xffffff );
+	this.program = function ( context, color ) {};
+
+	this.setValues( parameters );
+
+};
+
+THREE.SpriteCanvasMaterial.prototype = Object.create( THREE.Material.prototype );
+THREE.SpriteCanvasMaterial.prototype.constructor = THREE.SpriteCanvasMaterial;
+
+THREE.SpriteCanvasMaterial.prototype.clone = function () {
+
+	var material = new THREE.SpriteCanvasMaterial();
+
+	material.copy( this );
+	material.color.copy( this.color );
+	material.program = this.program;
+
+	return material;
+
+};
+
+//
+
+THREE.CanvasRenderer = function ( parameters ) {
+
+	console.log( 'THREE.CanvasRenderer', THREE.REVISION );
+
+	parameters = parameters || {};
+
+	var _this = this,
+	_renderData, _elements, _lights,
+	_projector = new THREE.Projector(),
+
+	_canvas = parameters.canvas !== undefined
+			 ? parameters.canvas
+			 : document.createElement( 'canvas' ),
+
+	_canvasWidth = _canvas.width,
+	_canvasHeight = _canvas.height,
+	_canvasWidthHalf = Math.floor( _canvasWidth / 2 ),
+	_canvasHeightHalf = Math.floor( _canvasHeight / 2 ),
+
+	_viewportX = 0,
+	_viewportY = 0,
+	_viewportWidth = _canvasWidth,
+	_viewportHeight = _canvasHeight,
+
+	_pixelRatio = 1,
+
+	_context = _canvas.getContext( '2d', {
+		alpha: parameters.alpha === true
+	} ),
+
+	_clearColor = new THREE.Color( 0x000000 ),
+	_clearAlpha = parameters.alpha === true ? 0 : 1,
+
+	_contextGlobalAlpha = 1,
+	_contextGlobalCompositeOperation = 0,
+	_contextStrokeStyle = null,
+	_contextFillStyle = null,
+	_contextLineWidth = null,
+	_contextLineCap = null,
+	_contextLineJoin = null,
+	_contextLineDash = [],
+
+	_camera,
+
+	_v1, _v2, _v3, _v4,
+	_v5 = new THREE.RenderableVertex(),
+	_v6 = new THREE.RenderableVertex(),
+
+	_v1x, _v1y, _v2x, _v2y, _v3x, _v3y,
+	_v4x, _v4y, _v5x, _v5y, _v6x, _v6y,
+
+	_color = new THREE.Color(),
+	_color1 = new THREE.Color(),
+	_color2 = new THREE.Color(),
+	_color3 = new THREE.Color(),
+	_color4 = new THREE.Color(),
+
+	_diffuseColor = new THREE.Color(),
+	_emissiveColor = new THREE.Color(),
+
+	_lightColor = new THREE.Color(),
+
+	_patterns = {},
+
+	_image, _uvs,
+	_uv1x, _uv1y, _uv2x, _uv2y, _uv3x, _uv3y,
+
+	_clipBox = new THREE.Box2(),
+	_clearBox = new THREE.Box2(),
+	_elemBox = new THREE.Box2(),
+
+	_ambientLight = new THREE.Color(),
+	_directionalLights = new THREE.Color(),
+	_pointLights = new THREE.Color(),
+
+	_vector3 = new THREE.Vector3(), // Needed for PointLight
+	_centroid = new THREE.Vector3(),
+	_normal = new THREE.Vector3(),
+	_normalViewMatrix = new THREE.Matrix3();
+
+	/* TODO
+	_canvas.mozImageSmoothingEnabled = false;
+	_canvas.webkitImageSmoothingEnabled = false;
+	_canvas.msImageSmoothingEnabled = false;
+	_canvas.imageSmoothingEnabled = false;
+	*/
+
+	// dash+gap fallbacks for Firefox and everything else
+
+	if ( _context.setLineDash === undefined ) {
+
+		_context.setLineDash = function () {};
+
+	}
+
+	this.domElement = _canvas;
+
+	this.autoClear = true;
+	this.sortObjects = true;
+	this.sortElements = true;
+
+	this.info = {
+
+		render: {
+
+			vertices: 0,
+			faces: 0
+
+		}
+
+	};
+
+	// WebGLRenderer compatibility
+
+	this.supportsVertexTextures = function () {};
+	this.setFaceCulling = function () {};
+
+	// API
+
+	this.getContext = function () {
+
+		return _context;
+
+	};
+
+	this.getContextAttributes = function () {
+
+		return _context.getContextAttributes();
+
+	};
+
+	this.getPixelRatio = function () {
+
+		return _pixelRatio;
+
+	};
+
+	this.setPixelRatio = function ( value ) {
+
+		if ( value !== undefined ) _pixelRatio = value;
+
+	};
+
+	this.setSize = function ( width, height, updateStyle ) {
+
+		_canvasWidth = width * _pixelRatio;
+		_canvasHeight = height * _pixelRatio;
+
+		_canvas.width = _canvasWidth;
+		_canvas.height = _canvasHeight;
+
+		_canvasWidthHalf = Math.floor( _canvasWidth / 2 );
+		_canvasHeightHalf = Math.floor( _canvasHeight / 2 );
+
+		if ( updateStyle !== false ) {
+
+			_canvas.style.width = width + 'px';
+			_canvas.style.height = height + 'px';
+
+		}
+
+		_clipBox.min.set( - _canvasWidthHalf, - _canvasHeightHalf );
+		_clipBox.max.set(   _canvasWidthHalf,   _canvasHeightHalf );
+
+		_clearBox.min.set( - _canvasWidthHalf, - _canvasHeightHalf );
+		_clearBox.max.set(   _canvasWidthHalf,   _canvasHeightHalf );
+
+		_contextGlobalAlpha = 1;
+		_contextGlobalCompositeOperation = 0;
+		_contextStrokeStyle = null;
+		_contextFillStyle = null;
+		_contextLineWidth = null;
+		_contextLineCap = null;
+		_contextLineJoin = null;
+
+		this.setViewport( 0, 0, width, height );
+
+	};
+
+	this.setViewport = function ( x, y, width, height ) {
+
+		_viewportX = x * _pixelRatio;
+		_viewportY = y * _pixelRatio;
+
+		_viewportWidth = width * _pixelRatio;
+		_viewportHeight = height * _pixelRatio;
+
+	};
+
+	this.setScissor = function () {};
+	this.setScissorTest = function () {};
+
+	this.setClearColor = function ( color, alpha ) {
+
+		_clearColor.set( color );
+		_clearAlpha = alpha !== undefined ? alpha : 1;
+
+		_clearBox.min.set( - _canvasWidthHalf, - _canvasHeightHalf );
+		_clearBox.max.set(   _canvasWidthHalf,   _canvasHeightHalf );
+
+	};
+
+	this.setClearColorHex = function ( hex, alpha ) {
+
+		console.warn( 'THREE.CanvasRenderer: .setClearColorHex() is being removed. Use .setClearColor() instead.' );
+		this.setClearColor( hex, alpha );
+
+	};
+
+	this.getClearColor = function () {
+
+		return _clearColor;
+
+	};
+
+	this.getClearAlpha = function () {
+
+		return _clearAlpha;
+
+	};
+
+	this.getMaxAnisotropy = function () {
+
+		return 0;
+
+	};
+
+	this.clear = function () {
+
+		if ( _clearBox.isEmpty() === false ) {
+
+			_clearBox.intersect( _clipBox );
+			_clearBox.expandByScalar( 2 );
+
+			_clearBox.min.x = _clearBox.min.x + _canvasWidthHalf;
+			_clearBox.min.y =  - _clearBox.min.y + _canvasHeightHalf;		// higher y value !
+			_clearBox.max.x = _clearBox.max.x + _canvasWidthHalf;
+			_clearBox.max.y =  - _clearBox.max.y + _canvasHeightHalf;		// lower y value !
+
+			if ( _clearAlpha < 1 ) {
+
+				_context.clearRect(
+					_clearBox.min.x | 0,
+					_clearBox.max.y | 0,
+					( _clearBox.max.x - _clearBox.min.x ) | 0,
+					( _clearBox.min.y - _clearBox.max.y ) | 0
+				);
+
+			}
+
+			if ( _clearAlpha > 0 ) {
+
+				setBlending( THREE.NormalBlending );
+				setOpacity( 1 );
+
+				setFillStyle( 'rgba(' + Math.floor( _clearColor.r * 255 ) + ',' + Math.floor( _clearColor.g * 255 ) + ',' + Math.floor( _clearColor.b * 255 ) + ',' + _clearAlpha + ')' );
+
+				_context.fillRect(
+					_clearBox.min.x | 0,
+					_clearBox.max.y | 0,
+					( _clearBox.max.x - _clearBox.min.x ) | 0,
+					( _clearBox.min.y - _clearBox.max.y ) | 0
+				);
+
+			}
+
+			_clearBox.makeEmpty();
+
+		}
+
+	};
+
+	// compatibility
+
+	this.clearColor = function () {};
+	this.clearDepth = function () {};
+	this.clearStencil = function () {};
+
+	this.render = function ( scene, camera ) {
+
+		if ( camera instanceof THREE.Camera === false ) {
+
+			console.error( 'THREE.CanvasRenderer.render: camera is not an instance of THREE.Camera.' );
+			return;
+
+		}
+
+		if ( this.autoClear === true ) this.clear();
+
+		_this.info.render.vertices = 0;
+		_this.info.render.faces = 0;
+
+		_context.setTransform( _viewportWidth / _canvasWidth, 0, 0, - _viewportHeight / _canvasHeight, _viewportX, _canvasHeight - _viewportY );
+		_context.translate( _canvasWidthHalf, _canvasHeightHalf );
+
+		_renderData = _projector.projectScene( scene, camera, this.sortObjects, this.sortElements );
+		_elements = _renderData.elements;
+		_lights = _renderData.lights;
+		_camera = camera;
+
+		_normalViewMatrix.getNormalMatrix( camera.matrixWorldInverse );
+
+		/* DEBUG
+		setFillStyle( 'rgba( 0, 255, 255, 0.5 )' );
+		_context.fillRect( _clipBox.min.x, _clipBox.min.y, _clipBox.max.x - _clipBox.min.x, _clipBox.max.y - _clipBox.min.y );
+		*/
+
+		calculateLights();
+
+		for ( var e = 0, el = _elements.length; e < el; e ++ ) {
+
+			var element = _elements[ e ];
+
+			var material = element.material;
+
+			if ( material === undefined || material.opacity === 0 ) continue;
+
+			_elemBox.makeEmpty();
+
+			if ( element instanceof THREE.RenderableSprite ) {
+
+				_v1 = element;
+				_v1.x *= _canvasWidthHalf; _v1.y *= _canvasHeightHalf;
+
+				renderSprite( _v1, element, material );
+
+			} else if ( element instanceof THREE.RenderableLine ) {
+
+				_v1 = element.v1; _v2 = element.v2;
+
+				_v1.positionScreen.x *= _canvasWidthHalf; _v1.positionScreen.y *= _canvasHeightHalf;
+				_v2.positionScreen.x *= _canvasWidthHalf; _v2.positionScreen.y *= _canvasHeightHalf;
+
+				_elemBox.setFromPoints( [
+					_v1.positionScreen,
+					_v2.positionScreen
+				] );
+
+				if ( _clipBox.intersectsBox( _elemBox ) === true ) {
+
+					renderLine( _v1, _v2, element, material );
+
+				}
+
+			} else if ( element instanceof THREE.RenderableFace ) {
+
+				_v1 = element.v1; _v2 = element.v2; _v3 = element.v3;
+
+				if ( _v1.positionScreen.z < - 1 || _v1.positionScreen.z > 1 ) continue;
+				if ( _v2.positionScreen.z < - 1 || _v2.positionScreen.z > 1 ) continue;
+				if ( _v3.positionScreen.z < - 1 || _v3.positionScreen.z > 1 ) continue;
+
+				_v1.positionScreen.x *= _canvasWidthHalf; _v1.positionScreen.y *= _canvasHeightHalf;
+				_v2.positionScreen.x *= _canvasWidthHalf; _v2.positionScreen.y *= _canvasHeightHalf;
+				_v3.positionScreen.x *= _canvasWidthHalf; _v3.positionScreen.y *= _canvasHeightHalf;
+
+				if ( material.overdraw > 0 ) {
+
+					expand( _v1.positionScreen, _v2.positionScreen, material.overdraw );
+					expand( _v2.positionScreen, _v3.positionScreen, material.overdraw );
+					expand( _v3.positionScreen, _v1.positionScreen, material.overdraw );
+
+				}
+
+				_elemBox.setFromPoints( [
+					_v1.positionScreen,
+					_v2.positionScreen,
+					_v3.positionScreen
+				] );
+
+				if ( _clipBox.intersectsBox( _elemBox ) === true ) {
+
+					renderFace3( _v1, _v2, _v3, 0, 1, 2, element, material );
+
+				}
+
+			}
+
+			/* DEBUG
+			setLineWidth( 1 );
+			setStrokeStyle( 'rgba( 0, 255, 0, 0.5 )' );
+			_context.strokeRect( _elemBox.min.x, _elemBox.min.y, _elemBox.max.x - _elemBox.min.x, _elemBox.max.y - _elemBox.min.y );
+			*/
+
+			_clearBox.union( _elemBox );
+
+		}
+
+		/* DEBUG
+		setLineWidth( 1 );
+		setStrokeStyle( 'rgba( 255, 0, 0, 0.5 )' );
+		_context.strokeRect( _clearBox.min.x, _clearBox.min.y, _clearBox.max.x - _clearBox.min.x, _clearBox.max.y - _clearBox.min.y );
+		*/
+
+		_context.setTransform( 1, 0, 0, 1, 0, 0 );
+
+	};
+
+	//
+
+	function calculateLights() {
+
+		_ambientLight.setRGB( 0, 0, 0 );
+		_directionalLights.setRGB( 0, 0, 0 );
+		_pointLights.setRGB( 0, 0, 0 );
+
+		for ( var l = 0, ll = _lights.length; l < ll; l ++ ) {
+
+			var light = _lights[ l ];
+			var lightColor = light.color;
+
+			if ( light instanceof THREE.AmbientLight ) {
+
+				_ambientLight.add( lightColor );
+
+			} else if ( light instanceof THREE.DirectionalLight ) {
+
+				// for sprites
+
+				_directionalLights.add( lightColor );
+
+			} else if ( light instanceof THREE.PointLight ) {
+
+				// for sprites
+
+				_pointLights.add( lightColor );
+
+			}
+
+		}
+
+	}
+
+	function calculateLight( position, normal, color ) {
+
+		for ( var l = 0, ll = _lights.length; l < ll; l ++ ) {
+
+			var light = _lights[ l ];
+
+			_lightColor.copy( light.color );
+
+			if ( light instanceof THREE.DirectionalLight ) {
+
+				var lightPosition = _vector3.setFromMatrixPosition( light.matrixWorld ).normalize();
+
+				var amount = normal.dot( lightPosition );
+
+				if ( amount <= 0 ) continue;
+
+				amount *= light.intensity;
+
+				color.add( _lightColor.multiplyScalar( amount ) );
+
+			} else if ( light instanceof THREE.PointLight ) {
+
+				var lightPosition = _vector3.setFromMatrixPosition( light.matrixWorld );
+
+				var amount = normal.dot( _vector3.subVectors( lightPosition, position ).normalize() );
+
+				if ( amount <= 0 ) continue;
+
+				amount *= light.distance == 0 ? 1 : 1 - Math.min( position.distanceTo( lightPosition ) / light.distance, 1 );
+
+				if ( amount == 0 ) continue;
+
+				amount *= light.intensity;
+
+				color.add( _lightColor.multiplyScalar( amount ) );
+
+			}
+
+		}
+
+	}
+
+	function renderSprite( v1, element, material ) {
+
+		setOpacity( material.opacity );
+		setBlending( material.blending );
+
+		var scaleX = element.scale.x * _canvasWidthHalf;
+		var scaleY = element.scale.y * _canvasHeightHalf;
+
+		var dist = 0.5 * Math.sqrt( scaleX * scaleX + scaleY * scaleY ); // allow for rotated sprite
+		_elemBox.min.set( v1.x - dist, v1.y - dist );
+		_elemBox.max.set( v1.x + dist, v1.y + dist );
+
+		if ( material instanceof THREE.SpriteMaterial ) {
+
+			var texture = material.map;
+
+			if ( texture !== null ) {
+
+				var pattern = _patterns[ texture.id ];
+
+				if ( pattern === undefined || pattern.version !== texture.version ) {
+
+					pattern = textureToPattern( texture );
+					_patterns[ texture.id ] = pattern;
+
+				}
+
+				if ( pattern.canvas !== undefined ) {
+
+					setFillStyle( pattern.canvas );
+
+					var bitmap = texture.image;
+
+					var ox = bitmap.width * texture.offset.x;
+					var oy = bitmap.height * texture.offset.y;
+
+					var sx = bitmap.width * texture.repeat.x;
+					var sy = bitmap.height * texture.repeat.y;
+
+					var cx = scaleX / sx;
+					var cy = scaleY / sy;
+
+					_context.save();
+					_context.translate( v1.x, v1.y );
+					if ( material.rotation !== 0 ) _context.rotate( material.rotation );
+					_context.translate( - scaleX / 2, - scaleY / 2 );
+					_context.scale( cx, cy );
+					_context.translate( - ox, - oy );
+					_context.fillRect( ox, oy, sx, sy );
+					_context.restore();
+
+				}
+
+			} else {
+
+				// no texture
+
+				setFillStyle( material.color.getStyle() );
+
+				_context.save();
+				_context.translate( v1.x, v1.y );
+				if ( material.rotation !== 0 ) _context.rotate( material.rotation );
+				_context.scale( scaleX, - scaleY );
+				_context.fillRect( - 0.5, - 0.5, 1, 1 );
+				_context.restore();
+
+			}
+
+		} else if ( material instanceof THREE.SpriteCanvasMaterial ) {
+
+			setStrokeStyle( material.color.getStyle() );
+			setFillStyle( material.color.getStyle() );
+
+			_context.save();
+			_context.translate( v1.x, v1.y );
+			if ( material.rotation !== 0 ) _context.rotate( material.rotation );
+			_context.scale( scaleX, scaleY );
+
+			material.program( _context );
+
+			_context.restore();
+
+		}
+
+		/* DEBUG
+		setStrokeStyle( 'rgb(255,255,0)' );
+		_context.beginPath();
+		_context.moveTo( v1.x - 10, v1.y );
+		_context.lineTo( v1.x + 10, v1.y );
+		_context.moveTo( v1.x, v1.y - 10 );
+		_context.lineTo( v1.x, v1.y + 10 );
+		_context.stroke();
+		*/
+
+	}
+
+	function renderLine( v1, v2, element, material ) {
+
+		setOpacity( material.opacity );
+		setBlending( material.blending );
+
+		_context.beginPath();
+		_context.moveTo( v1.positionScreen.x, v1.positionScreen.y );
+		_context.lineTo( v2.positionScreen.x, v2.positionScreen.y );
+
+		if ( material instanceof THREE.LineBasicMaterial ) {
+
+			setLineWidth( material.linewidth );
+			setLineCap( material.linecap );
+			setLineJoin( material.linejoin );
+
+			if ( material.vertexColors !== THREE.VertexColors ) {
+
+				setStrokeStyle( material.color.getStyle() );
+
+			} else {
+
+				var colorStyle1 = element.vertexColors[ 0 ].getStyle();
+				var colorStyle2 = element.vertexColors[ 1 ].getStyle();
+
+				if ( colorStyle1 === colorStyle2 ) {
+
+					setStrokeStyle( colorStyle1 );
+
+				} else {
+
+					try {
+
+						var grad = _context.createLinearGradient(
+							v1.positionScreen.x,
+							v1.positionScreen.y,
+							v2.positionScreen.x,
+							v2.positionScreen.y
+						);
+						grad.addColorStop( 0, colorStyle1 );
+						grad.addColorStop( 1, colorStyle2 );
+
+					} catch ( exception ) {
+
+						grad = colorStyle1;
+
+					}
+
+					setStrokeStyle( grad );
+
+				}
+
+			}
+
+			_context.stroke();
+			_elemBox.expandByScalar( material.linewidth * 2 );
+
+		} else if ( material instanceof THREE.LineDashedMaterial ) {
+
+			setLineWidth( material.linewidth );
+			setLineCap( material.linecap );
+			setLineJoin( material.linejoin );
+			setStrokeStyle( material.color.getStyle() );
+			setLineDash( [ material.dashSize, material.gapSize ] );
+
+			_context.stroke();
+
+			_elemBox.expandByScalar( material.linewidth * 2 );
+
+			setLineDash( [] );
+
+		}
+
+	}
+
+	function renderFace3( v1, v2, v3, uv1, uv2, uv3, element, material ) {
+
+		_this.info.render.vertices += 3;
+		_this.info.render.faces ++;
+
+		setOpacity( material.opacity );
+		setBlending( material.blending );
+
+		_v1x = v1.positionScreen.x; _v1y = v1.positionScreen.y;
+		_v2x = v2.positionScreen.x; _v2y = v2.positionScreen.y;
+		_v3x = v3.positionScreen.x; _v3y = v3.positionScreen.y;
+
+		drawTriangle( _v1x, _v1y, _v2x, _v2y, _v3x, _v3y );
+
+		if ( ( material instanceof THREE.MeshLambertMaterial || material instanceof THREE.MeshPhongMaterial ) && material.map === null ) {
+
+			_diffuseColor.copy( material.color );
+			_emissiveColor.copy( material.emissive );
+
+			if ( material.vertexColors === THREE.FaceColors ) {
+
+				_diffuseColor.multiply( element.color );
+
+			}
+
+			_color.copy( _ambientLight );
+
+			_centroid.copy( v1.positionWorld ).add( v2.positionWorld ).add( v3.positionWorld ).divideScalar( 3 );
+
+			calculateLight( _centroid, element.normalModel, _color );
+
+			_color.multiply( _diffuseColor ).add( _emissiveColor );
+
+			material.wireframe === true
+				 ? strokePath( _color, material.wireframeLinewidth, material.wireframeLinecap, material.wireframeLinejoin )
+				 : fillPath( _color );
+
+		} else if ( material instanceof THREE.MeshBasicMaterial ||
+				    material instanceof THREE.MeshLambertMaterial ||
+				    material instanceof THREE.MeshPhongMaterial ) {
+
+			if ( material.map !== null ) {
+
+				var mapping = material.map.mapping;
+
+				if ( mapping === THREE.UVMapping ) {
+
+					_uvs = element.uvs;
+					patternPath( _v1x, _v1y, _v2x, _v2y, _v3x, _v3y, _uvs[ uv1 ].x, _uvs[ uv1 ].y, _uvs[ uv2 ].x, _uvs[ uv2 ].y, _uvs[ uv3 ].x, _uvs[ uv3 ].y, material.map );
+
+				}
+
+			} else if ( material.envMap !== null ) {
+
+				if ( material.envMap.mapping === THREE.SphericalReflectionMapping ) {
+
+					_normal.copy( element.vertexNormalsModel[ uv1 ] ).applyMatrix3( _normalViewMatrix );
+					_uv1x = 0.5 * _normal.x + 0.5;
+					_uv1y = 0.5 * _normal.y + 0.5;
+
+					_normal.copy( element.vertexNormalsModel[ uv2 ] ).applyMatrix3( _normalViewMatrix );
+					_uv2x = 0.5 * _normal.x + 0.5;
+					_uv2y = 0.5 * _normal.y + 0.5;
+
+					_normal.copy( element.vertexNormalsModel[ uv3 ] ).applyMatrix3( _normalViewMatrix );
+					_uv3x = 0.5 * _normal.x + 0.5;
+					_uv3y = 0.5 * _normal.y + 0.5;
+
+					patternPath( _v1x, _v1y, _v2x, _v2y, _v3x, _v3y, _uv1x, _uv1y, _uv2x, _uv2y, _uv3x, _uv3y, material.envMap );
+
+				}
+
+			} else {
+
+				_color.copy( material.color );
+
+				if ( material.vertexColors === THREE.FaceColors ) {
+
+					_color.multiply( element.color );
+
+				}
+
+				material.wireframe === true
+					 ? strokePath( _color, material.wireframeLinewidth, material.wireframeLinecap, material.wireframeLinejoin )
+					 : fillPath( _color );
+
+			}
+
+		} else if ( material instanceof THREE.MeshNormalMaterial ) {
+
+			_normal.copy( element.normalModel ).applyMatrix3( _normalViewMatrix );
+
+			_color.setRGB( _normal.x, _normal.y, _normal.z ).multiplyScalar( 0.5 ).addScalar( 0.5 );
+
+			material.wireframe === true
+				 ? strokePath( _color, material.wireframeLinewidth, material.wireframeLinecap, material.wireframeLinejoin )
+				 : fillPath( _color );
+
+		} else {
+
+			_color.setRGB( 1, 1, 1 );
+
+			material.wireframe === true
+				 ? strokePath( _color, material.wireframeLinewidth, material.wireframeLinecap, material.wireframeLinejoin )
+				 : fillPath( _color );
+
+		}
+
+	}
+
+	//
+
+	function drawTriangle( x0, y0, x1, y1, x2, y2 ) {
+
+		_context.beginPath();
+		_context.moveTo( x0, y0 );
+		_context.lineTo( x1, y1 );
+		_context.lineTo( x2, y2 );
+		_context.closePath();
+
+	}
+
+	function strokePath( color, linewidth, linecap, linejoin ) {
+
+		setLineWidth( linewidth );
+		setLineCap( linecap );
+		setLineJoin( linejoin );
+		setStrokeStyle( color.getStyle() );
+
+		_context.stroke();
+
+		_elemBox.expandByScalar( linewidth * 2 );
+
+	}
+
+	function fillPath( color ) {
+
+		setFillStyle( color.getStyle() );
+		_context.fill();
+
+	}
+
+	function textureToPattern( texture ) {
+
+		if ( texture.version === 0 ||
+			texture instanceof THREE.CompressedTexture ||
+			texture instanceof THREE.DataTexture ) {
+
+			return {
+				canvas: undefined,
+				version: texture.version
+			};
+
+		}
+
+		var image = texture.image;
+
+		if ( image.complete === false ) {
+
+			return {
+				canvas: undefined,
+				version: 0
+			};
+
+		}
+
+		var canvas = document.createElement( 'canvas' );
+		canvas.width = image.width;
+		canvas.height = image.height;
+
+		var context = canvas.getContext( '2d' );
+		context.setTransform( 1, 0, 0, - 1, 0, image.height );
+		context.drawImage( image, 0, 0 );
+
+		var repeatX = texture.wrapS === THREE.RepeatWrapping;
+		var repeatY = texture.wrapT === THREE.RepeatWrapping;
+
+		var repeat = 'no-repeat';
+
+		if ( repeatX === true && repeatY === true ) {
+
+			repeat = 'repeat';
+
+		} else if ( repeatX === true ) {
+
+			repeat = 'repeat-x';
+
+		} else if ( repeatY === true ) {
+
+			repeat = 'repeat-y';
+
+		}
+
+		var pattern = _context.createPattern( canvas, repeat );
+
+		if ( texture.onUpdate ) texture.onUpdate( texture );
+
+		return {
+			canvas: pattern,
+			version: texture.version
+		};
+
+	}
+
+	function patternPath( x0, y0, x1, y1, x2, y2, u0, v0, u1, v1, u2, v2, texture ) {
+
+		var pattern = _patterns[ texture.id ];
+
+		if ( pattern === undefined || pattern.version !== texture.version ) {
+
+			pattern = textureToPattern( texture );
+			_patterns[ texture.id ] = pattern;
+
+		}
+
+		if ( pattern.canvas !== undefined ) {
+
+			setFillStyle( pattern.canvas );
+
+		} else {
+
+			setFillStyle( 'rgba( 0, 0, 0, 1)' );
+			_context.fill();
+			return;
+
+		}
+
+		// http://extremelysatisfactorytotalitarianism.com/blog/?p=2120
+
+		var a, b, c, d, e, f, det, idet,
+		offsetX = texture.offset.x / texture.repeat.x,
+		offsetY = texture.offset.y / texture.repeat.y,
+		width = texture.image.width * texture.repeat.x,
+		height = texture.image.height * texture.repeat.y;
+
+		u0 = ( u0 + offsetX ) * width;
+		v0 = ( v0 + offsetY ) * height;
+
+		u1 = ( u1 + offsetX ) * width;
+		v1 = ( v1 + offsetY ) * height;
+
+		u2 = ( u2 + offsetX ) * width;
+		v2 = ( v2 + offsetY ) * height;
+
+		x1 -= x0; y1 -= y0;
+		x2 -= x0; y2 -= y0;
+
+		u1 -= u0; v1 -= v0;
+		u2 -= u0; v2 -= v0;
+
+		det = u1 * v2 - u2 * v1;
+
+		if ( det === 0 ) return;
+
+		idet = 1 / det;
+
+		a = ( v2 * x1 - v1 * x2 ) * idet;
+		b = ( v2 * y1 - v1 * y2 ) * idet;
+		c = ( u1 * x2 - u2 * x1 ) * idet;
+		d = ( u1 * y2 - u2 * y1 ) * idet;
+
+		e = x0 - a * u0 - c * v0;
+		f = y0 - b * u0 - d * v0;
+
+		_context.save();
+		_context.transform( a, b, c, d, e, f );
+		_context.fill();
+		_context.restore();
+
+	}
+
+	function clipImage( x0, y0, x1, y1, x2, y2, u0, v0, u1, v1, u2, v2, image ) {
+
+		// http://extremelysatisfactorytotalitarianism.com/blog/?p=2120
+
+		var a, b, c, d, e, f, det, idet,
+		width = image.width - 1,
+		height = image.height - 1;
+
+		u0 *= width; v0 *= height;
+		u1 *= width; v1 *= height;
+		u2 *= width; v2 *= height;
+
+		x1 -= x0; y1 -= y0;
+		x2 -= x0; y2 -= y0;
+
+		u1 -= u0; v1 -= v0;
+		u2 -= u0; v2 -= v0;
+
+		det = u1 * v2 - u2 * v1;
+
+		idet = 1 / det;
+
+		a = ( v2 * x1 - v1 * x2 ) * idet;
+		b = ( v2 * y1 - v1 * y2 ) * idet;
+		c = ( u1 * x2 - u2 * x1 ) * idet;
+		d = ( u1 * y2 - u2 * y1 ) * idet;
+
+		e = x0 - a * u0 - c * v0;
+		f = y0 - b * u0 - d * v0;
+
+		_context.save();
+		_context.transform( a, b, c, d, e, f );
+		_context.clip();
+		_context.drawImage( image, 0, 0 );
+		_context.restore();
+
+	}
+
+	// Hide anti-alias gaps
+
+	function expand( v1, v2, pixels ) {
+
+		var x = v2.x - v1.x, y = v2.y - v1.y,
+		det = x * x + y * y, idet;
+
+		if ( det === 0 ) return;
+
+		idet = pixels / Math.sqrt( det );
+
+		x *= idet; y *= idet;
+
+		v2.x += x; v2.y += y;
+		v1.x -= x; v1.y -= y;
+
+	}
+
+	// Context cached methods.
+
+	function setOpacity( value ) {
+
+		if ( _contextGlobalAlpha !== value ) {
+
+			_context.globalAlpha = value;
+			_contextGlobalAlpha = value;
+
+		}
+
+	}
+
+	function setBlending( value ) {
+
+		if ( _contextGlobalCompositeOperation !== value ) {
+
+			if ( value === THREE.NormalBlending ) {
+
+				_context.globalCompositeOperation = 'source-over';
+
+			} else if ( value === THREE.AdditiveBlending ) {
+
+				_context.globalCompositeOperation = 'lighter';
+
+			} else if ( value === THREE.SubtractiveBlending ) {
+
+				_context.globalCompositeOperation = 'darker';
+
+			}
+
+			_contextGlobalCompositeOperation = value;
+
+		}
+
+	}
+
+	function setLineWidth( value ) {
+
+		if ( _contextLineWidth !== value ) {
+
+			_context.lineWidth = value;
+			_contextLineWidth = value;
+
+		}
+
+	}
+
+	function setLineCap( value ) {
+
+		// "butt", "round", "square"
+
+		if ( _contextLineCap !== value ) {
+
+			_context.lineCap = value;
+			_contextLineCap = value;
+
+		}
+
+	}
+
+	function setLineJoin( value ) {
+
+		// "round", "bevel", "miter"
+
+		if ( _contextLineJoin !== value ) {
+
+			_context.lineJoin = value;
+			_contextLineJoin = value;
+
+		}
+
+	}
+
+	function setStrokeStyle( value ) {
+
+		if ( _contextStrokeStyle !== value ) {
+
+			_context.strokeStyle = value;
+			_contextStrokeStyle = value;
+
+		}
+
+	}
+
+	function setFillStyle( value ) {
+
+		if ( _contextFillStyle !== value ) {
+
+			_context.fillStyle = value;
+			_contextFillStyle = value;
+
+		}
+
+	}
+
+	function setLineDash( value ) {
+
+		if ( _contextLineDash.length !== value.length ) {
+
+			_context.setLineDash( value );
+			_contextLineDash = value;
+
+		}
+
+	}
+
+};
diff --git a/html/js/three/renderers/Projector.js b/html/js/three/renderers/Projector.js
new file mode 100755
index 0000000..c05f56b
--- /dev/null
+++ b/html/js/three/renderers/Projector.js
@@ -0,0 +1,921 @@
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author supereggbert / http://www.paulbrunt.co.uk/
+ * @author julianwa / https://github.com/julianwa
+ */
+
+THREE.RenderableObject = function () {
+
+	this.id = 0;
+
+	this.object = null;
+	this.z = 0;
+	this.renderOrder = 0;
+
+};
+
+//
+
+THREE.RenderableFace = function () {
+
+	this.id = 0;
+
+	this.v1 = new THREE.RenderableVertex();
+	this.v2 = new THREE.RenderableVertex();
+	this.v3 = new THREE.RenderableVertex();
+
+	this.normalModel = new THREE.Vector3();
+
+	this.vertexNormalsModel = [ new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3() ];
+	this.vertexNormalsLength = 0;
+
+	this.color = new THREE.Color();
+	this.material = null;
+	this.uvs = [ new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2() ];
+
+	this.z = 0;
+	this.renderOrder = 0;
+
+};
+
+//
+
+THREE.RenderableVertex = function () {
+
+	this.position = new THREE.Vector3();
+	this.positionWorld = new THREE.Vector3();
+	this.positionScreen = new THREE.Vector4();
+
+	this.visible = true;
+
+};
+
+THREE.RenderableVertex.prototype.copy = function ( vertex ) {
+
+	this.positionWorld.copy( vertex.positionWorld );
+	this.positionScreen.copy( vertex.positionScreen );
+
+};
+
+//
+
+THREE.RenderableLine = function () {
+
+	this.id = 0;
+
+	this.v1 = new THREE.RenderableVertex();
+	this.v2 = new THREE.RenderableVertex();
+
+	this.vertexColors = [ new THREE.Color(), new THREE.Color() ];
+	this.material = null;
+
+	this.z = 0;
+	this.renderOrder = 0;
+
+};
+
+//
+
+THREE.RenderableSprite = function () {
+
+	this.id = 0;
+
+	this.object = null;
+
+	this.x = 0;
+	this.y = 0;
+	this.z = 0;
+
+	this.rotation = 0;
+	this.scale = new THREE.Vector2();
+
+	this.material = null;
+	this.renderOrder = 0;
+
+};
+
+//
+
+THREE.Projector = function () {
+
+	var _object, _objectCount, _objectPool = [], _objectPoolLength = 0,
+	_vertex, _vertexCount, _vertexPool = [], _vertexPoolLength = 0,
+	_face, _faceCount, _facePool = [], _facePoolLength = 0,
+	_line, _lineCount, _linePool = [], _linePoolLength = 0,
+	_sprite, _spriteCount, _spritePool = [], _spritePoolLength = 0,
+
+	_renderData = { objects: [], lights: [], elements: [] },
+
+	_vector3 = new THREE.Vector3(),
+	_vector4 = new THREE.Vector4(),
+
+	_clipBox = new THREE.Box3( new THREE.Vector3( - 1, - 1, - 1 ), new THREE.Vector3( 1, 1, 1 ) ),
+	_boundingBox = new THREE.Box3(),
+	_points3 = new Array( 3 ),
+	_points4 = new Array( 4 ),
+
+	_viewMatrix = new THREE.Matrix4(),
+	_viewProjectionMatrix = new THREE.Matrix4(),
+
+	_modelMatrix,
+	_modelViewProjectionMatrix = new THREE.Matrix4(),
+
+	_normalMatrix = new THREE.Matrix3(),
+
+	_frustum = new THREE.Frustum(),
+
+	_clippedVertex1PositionScreen = new THREE.Vector4(),
+	_clippedVertex2PositionScreen = new THREE.Vector4();
+
+	//
+
+	this.projectVector = function ( vector, camera ) {
+
+		console.warn( 'THREE.Projector: .projectVector() is now vector.project().' );
+		vector.project( camera );
+
+	};
+
+	this.unprojectVector = function ( vector, camera ) {
+
+		console.warn( 'THREE.Projector: .unprojectVector() is now vector.unproject().' );
+		vector.unproject( camera );
+
+	};
+
+	this.pickingRay = function ( vector, camera ) {
+
+		console.error( 'THREE.Projector: .pickingRay() is now raycaster.setFromCamera().' );
+
+	};
+
+	//
+
+	var RenderList = function () {
+
+		var normals = [];
+		var uvs = [];
+
+		var object = null;
+		var material = null;
+
+		var normalMatrix = new THREE.Matrix3();
+
+		function setObject( value ) {
+
+			object = value;
+			material = object.material;
+
+			normalMatrix.getNormalMatrix( object.matrixWorld );
+
+			normals.length = 0;
+			uvs.length = 0;
+
+		}
+
+		function projectVertex( vertex ) {
+
+			var position = vertex.position;
+			var positionWorld = vertex.positionWorld;
+			var positionScreen = vertex.positionScreen;
+
+			positionWorld.copy( position ).applyMatrix4( _modelMatrix );
+			positionScreen.copy( positionWorld ).applyMatrix4( _viewProjectionMatrix );
+
+			var invW = 1 / positionScreen.w;
+
+			positionScreen.x *= invW;
+			positionScreen.y *= invW;
+			positionScreen.z *= invW;
+
+			vertex.visible = positionScreen.x >= - 1 && positionScreen.x <= 1 &&
+					 positionScreen.y >= - 1 && positionScreen.y <= 1 &&
+					 positionScreen.z >= - 1 && positionScreen.z <= 1;
+
+		}
+
+		function pushVertex( x, y, z ) {
+
+			_vertex = getNextVertexInPool();
+			_vertex.position.set( x, y, z );
+
+			projectVertex( _vertex );
+
+		}
+
+		function pushNormal( x, y, z ) {
+
+			normals.push( x, y, z );
+
+		}
+
+		function pushUv( x, y ) {
+
+			uvs.push( x, y );
+
+		}
+
+		function checkTriangleVisibility( v1, v2, v3 ) {
+
+			if ( v1.visible === true || v2.visible === true || v3.visible === true ) return true;
+
+			_points3[ 0 ] = v1.positionScreen;
+			_points3[ 1 ] = v2.positionScreen;
+			_points3[ 2 ] = v3.positionScreen;
+
+			return _clipBox.intersectsBox( _boundingBox.setFromPoints( _points3 ) );
+
+		}
+
+		function checkBackfaceCulling( v1, v2, v3 ) {
+
+			return ( ( v3.positionScreen.x - v1.positionScreen.x ) *
+				    ( v2.positionScreen.y - v1.positionScreen.y ) -
+				    ( v3.positionScreen.y - v1.positionScreen.y ) *
+				    ( v2.positionScreen.x - v1.positionScreen.x ) ) < 0;
+
+		}
+
+		function pushLine( a, b ) {
+
+			var v1 = _vertexPool[ a ];
+			var v2 = _vertexPool[ b ];
+
+			_line = getNextLineInPool();
+
+			_line.id = object.id;
+			_line.v1.copy( v1 );
+			_line.v2.copy( v2 );
+			_line.z = ( v1.positionScreen.z + v2.positionScreen.z ) / 2;
+			_line.renderOrder = object.renderOrder;
+
+			_line.material = object.material;
+
+			_renderData.elements.push( _line );
+
+		}
+
+		function pushTriangle( a, b, c ) {
+
+			var v1 = _vertexPool[ a ];
+			var v2 = _vertexPool[ b ];
+			var v3 = _vertexPool[ c ];
+
+			if ( checkTriangleVisibility( v1, v2, v3 ) === false ) return;
+
+			if ( material.side === THREE.DoubleSide || checkBackfaceCulling( v1, v2, v3 ) === true ) {
+
+				_face = getNextFaceInPool();
+
+				_face.id = object.id;
+				_face.v1.copy( v1 );
+				_face.v2.copy( v2 );
+				_face.v3.copy( v3 );
+				_face.z = ( v1.positionScreen.z + v2.positionScreen.z + v3.positionScreen.z ) / 3;
+				_face.renderOrder = object.renderOrder;
+
+				// use first vertex normal as face normal
+
+				_face.normalModel.fromArray( normals, a * 3 );
+				_face.normalModel.applyMatrix3( normalMatrix ).normalize();
+
+				for ( var i = 0; i < 3; i ++ ) {
+
+					var normal = _face.vertexNormalsModel[ i ];
+					normal.fromArray( normals, arguments[ i ] * 3 );
+					normal.applyMatrix3( normalMatrix ).normalize();
+
+					var uv = _face.uvs[ i ];
+					uv.fromArray( uvs, arguments[ i ] * 2 );
+
+				}
+
+				_face.vertexNormalsLength = 3;
+
+				_face.material = object.material;
+
+				_renderData.elements.push( _face );
+
+			}
+
+		}
+
+		return {
+			setObject: setObject,
+			projectVertex: projectVertex,
+			checkTriangleVisibility: checkTriangleVisibility,
+			checkBackfaceCulling: checkBackfaceCulling,
+			pushVertex: pushVertex,
+			pushNormal: pushNormal,
+			pushUv: pushUv,
+			pushLine: pushLine,
+			pushTriangle: pushTriangle
+		}
+
+	};
+
+	var renderList = new RenderList();
+
+	this.projectScene = function ( scene, camera, sortObjects, sortElements ) {
+
+		_faceCount = 0;
+		_lineCount = 0;
+		_spriteCount = 0;
+
+		_renderData.elements.length = 0;
+
+		if ( scene.autoUpdate === true ) scene.updateMatrixWorld();
+		if ( camera.parent === null ) camera.updateMatrixWorld();
+
+		_viewMatrix.copy( camera.matrixWorldInverse.getInverse( camera.matrixWorld ) );
+		_viewProjectionMatrix.multiplyMatrices( camera.projectionMatrix, _viewMatrix );
+
+		_frustum.setFromMatrix( _viewProjectionMatrix );
+
+		//
+
+		_objectCount = 0;
+
+		_renderData.objects.length = 0;
+		_renderData.lights.length = 0;
+
+		scene.traverseVisible( function ( object ) {
+
+			if ( object instanceof THREE.Light ) {
+
+				_renderData.lights.push( object );
+
+			} else if ( object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Sprite ) {
+
+				var material = object.material;
+
+				if ( material.visible === false ) return;
+
+				if ( object.frustumCulled === false || _frustum.intersectsObject( object ) === true ) {
+
+					_object = getNextObjectInPool();
+					_object.id = object.id;
+					_object.object = object;
+
+					_vector3.setFromMatrixPosition( object.matrixWorld );
+					_vector3.applyProjection( _viewProjectionMatrix );
+					_object.z = _vector3.z;
+					_object.renderOrder = object.renderOrder;
+
+					_renderData.objects.push( _object );
+
+				}
+
+			}
+
+		} );
+
+		if ( sortObjects === true ) {
+
+			_renderData.objects.sort( painterSort );
+
+		}
+
+		//
+
+		for ( var o = 0, ol = _renderData.objects.length; o < ol; o ++ ) {
+
+			var object = _renderData.objects[ o ].object;
+			var geometry = object.geometry;
+
+			renderList.setObject( object );
+
+			_modelMatrix = object.matrixWorld;
+
+			_vertexCount = 0;
+
+			if ( object instanceof THREE.Mesh ) {
+
+				if ( geometry instanceof THREE.BufferGeometry ) {
+
+					var attributes = geometry.attributes;
+					var groups = geometry.groups;
+
+					if ( attributes.position === undefined ) continue;
+
+					var positions = attributes.position.array;
+
+					for ( var i = 0, l = positions.length; i < l; i += 3 ) {
+
+						renderList.pushVertex( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] );
+
+					}
+
+					if ( attributes.normal !== undefined ) {
+
+						var normals = attributes.normal.array;
+
+						for ( var i = 0, l = normals.length; i < l; i += 3 ) {
+
+							renderList.pushNormal( normals[ i ], normals[ i + 1 ], normals[ i + 2 ] );
+
+						}
+
+					}
+
+					if ( attributes.uv !== undefined ) {
+
+						var uvs = attributes.uv.array;
+
+						for ( var i = 0, l = uvs.length; i < l; i += 2 ) {
+
+							renderList.pushUv( uvs[ i ], uvs[ i + 1 ] );
+
+						}
+
+					}
+
+					if ( geometry.index !== null ) {
+
+						var indices = geometry.index.array;
+
+						if ( groups.length > 0 ) {
+
+							for ( var o = 0; o < groups.length; o ++ ) {
+
+								var group = groups[ o ];
+
+								for ( var i = group.start, l = group.start + group.count; i < l; i += 3 ) {
+
+									renderList.pushTriangle( indices[ i ], indices[ i + 1 ], indices[ i + 2 ] );
+
+								}
+
+							}
+
+						} else {
+
+							for ( var i = 0, l = indices.length; i < l; i += 3 ) {
+
+								renderList.pushTriangle( indices[ i ], indices[ i + 1 ], indices[ i + 2 ] );
+
+							}
+
+						}
+
+					} else {
+
+						for ( var i = 0, l = positions.length / 3; i < l; i += 3 ) {
+
+							renderList.pushTriangle( i, i + 1, i + 2 );
+
+						}
+
+					}
+
+				} else if ( geometry instanceof THREE.Geometry ) {
+
+					var vertices = geometry.vertices;
+					var faces = geometry.faces;
+					var faceVertexUvs = geometry.faceVertexUvs[ 0 ];
+
+					_normalMatrix.getNormalMatrix( _modelMatrix );
+
+					var material = object.material;
+
+					var isFaceMaterial = material instanceof THREE.MultiMaterial;
+					var objectMaterials = isFaceMaterial === true ? object.material : null;
+
+					for ( var v = 0, vl = vertices.length; v < vl; v ++ ) {
+
+						var vertex = vertices[ v ];
+
+						_vector3.copy( vertex );
+
+						if ( material.morphTargets === true ) {
+
+							var morphTargets = geometry.morphTargets;
+							var morphInfluences = object.morphTargetInfluences;
+
+							for ( var t = 0, tl = morphTargets.length; t < tl; t ++ ) {
+
+								var influence = morphInfluences[ t ];
+
+								if ( influence === 0 ) continue;
+
+								var target = morphTargets[ t ];
+								var targetVertex = target.vertices[ v ];
+
+								_vector3.x += ( targetVertex.x - vertex.x ) * influence;
+								_vector3.y += ( targetVertex.y - vertex.y ) * influence;
+								_vector3.z += ( targetVertex.z - vertex.z ) * influence;
+
+							}
+
+						}
+
+						renderList.pushVertex( _vector3.x, _vector3.y, _vector3.z );
+
+					}
+
+					for ( var f = 0, fl = faces.length; f < fl; f ++ ) {
+
+						var face = faces[ f ];
+
+						material = isFaceMaterial === true
+							 ? objectMaterials.materials[ face.materialIndex ]
+							 : object.material;
+
+						if ( material === undefined ) continue;
+
+						var side = material.side;
+
+						var v1 = _vertexPool[ face.a ];
+						var v2 = _vertexPool[ face.b ];
+						var v3 = _vertexPool[ face.c ];
+
+						if ( renderList.checkTriangleVisibility( v1, v2, v3 ) === false ) continue;
+
+						var visible = renderList.checkBackfaceCulling( v1, v2, v3 );
+
+						if ( side !== THREE.DoubleSide ) {
+
+							if ( side === THREE.FrontSide && visible === false ) continue;
+							if ( side === THREE.BackSide && visible === true ) continue;
+
+						}
+
+						_face = getNextFaceInPool();
+
+						_face.id = object.id;
+						_face.v1.copy( v1 );
+						_face.v2.copy( v2 );
+						_face.v3.copy( v3 );
+
+						_face.normalModel.copy( face.normal );
+
+						if ( visible === false && ( side === THREE.BackSide || side === THREE.DoubleSide ) ) {
+
+							_face.normalModel.negate();
+
+						}
+
+						_face.normalModel.applyMatrix3( _normalMatrix ).normalize();
+
+						var faceVertexNormals = face.vertexNormals;
+
+						for ( var n = 0, nl = Math.min( faceVertexNormals.length, 3 ); n < nl; n ++ ) {
+
+							var normalModel = _face.vertexNormalsModel[ n ];
+							normalModel.copy( faceVertexNormals[ n ] );
+
+							if ( visible === false && ( side === THREE.BackSide || side === THREE.DoubleSide ) ) {
+
+								normalModel.negate();
+
+							}
+
+							normalModel.applyMatrix3( _normalMatrix ).normalize();
+
+						}
+
+						_face.vertexNormalsLength = faceVertexNormals.length;
+
+						var vertexUvs = faceVertexUvs[ f ];
+
+						if ( vertexUvs !== undefined ) {
+
+							for ( var u = 0; u < 3; u ++ ) {
+
+								_face.uvs[ u ].copy( vertexUvs[ u ] );
+
+							}
+
+						}
+
+						_face.color = face.color;
+						_face.material = material;
+
+						_face.z = ( v1.positionScreen.z + v2.positionScreen.z + v3.positionScreen.z ) / 3;
+						_face.renderOrder = object.renderOrder;
+
+						_renderData.elements.push( _face );
+
+					}
+
+				}
+
+			} else if ( object instanceof THREE.Line ) {
+
+				if ( geometry instanceof THREE.BufferGeometry ) {
+
+					var attributes = geometry.attributes;
+
+					if ( attributes.position !== undefined ) {
+
+						var positions = attributes.position.array;
+
+						for ( var i = 0, l = positions.length; i < l; i += 3 ) {
+
+							renderList.pushVertex( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] );
+
+						}
+
+						if ( geometry.index !== null ) {
+
+							var indices = geometry.index.array;
+
+							for ( var i = 0, l = indices.length; i < l; i += 2 ) {
+
+								renderList.pushLine( indices[ i ], indices[ i + 1 ] );
+
+							}
+
+						} else {
+
+							var step = object instanceof THREE.LineSegments ? 2 : 1;
+
+							for ( var i = 0, l = ( positions.length / 3 ) - 1; i < l; i += step ) {
+
+								renderList.pushLine( i, i + 1 );
+
+							}
+
+						}
+
+					}
+
+				} else if ( geometry instanceof THREE.Geometry ) {
+
+					_modelViewProjectionMatrix.multiplyMatrices( _viewProjectionMatrix, _modelMatrix );
+
+					var vertices = object.geometry.vertices;
+
+					if ( vertices.length === 0 ) continue;
+
+					v1 = getNextVertexInPool();
+					v1.positionScreen.copy( vertices[ 0 ] ).applyMatrix4( _modelViewProjectionMatrix );
+
+					var step = object instanceof THREE.LineSegments ? 2 : 1;
+
+					for ( var v = 1, vl = vertices.length; v < vl; v ++ ) {
+
+						v1 = getNextVertexInPool();
+						v1.positionScreen.copy( vertices[ v ] ).applyMatrix4( _modelViewProjectionMatrix );
+
+						if ( ( v + 1 ) % step > 0 ) continue;
+
+						v2 = _vertexPool[ _vertexCount - 2 ];
+
+						_clippedVertex1PositionScreen.copy( v1.positionScreen );
+						_clippedVertex2PositionScreen.copy( v2.positionScreen );
+
+						if ( clipLine( _clippedVertex1PositionScreen, _clippedVertex2PositionScreen ) === true ) {
+
+							// Perform the perspective divide
+							_clippedVertex1PositionScreen.multiplyScalar( 1 / _clippedVertex1PositionScreen.w );
+							_clippedVertex2PositionScreen.multiplyScalar( 1 / _clippedVertex2PositionScreen.w );
+
+							_line = getNextLineInPool();
+
+							_line.id = object.id;
+							_line.v1.positionScreen.copy( _clippedVertex1PositionScreen );
+							_line.v2.positionScreen.copy( _clippedVertex2PositionScreen );
+
+							_line.z = Math.max( _clippedVertex1PositionScreen.z, _clippedVertex2PositionScreen.z );
+							_line.renderOrder = object.renderOrder;
+
+							_line.material = object.material;
+
+							if ( object.material.vertexColors === THREE.VertexColors ) {
+
+								_line.vertexColors[ 0 ].copy( object.geometry.colors[ v ] );
+								_line.vertexColors[ 1 ].copy( object.geometry.colors[ v - 1 ] );
+
+							}
+
+							_renderData.elements.push( _line );
+
+						}
+
+					}
+
+				}
+
+			} else if ( object instanceof THREE.Sprite ) {
+
+				_vector4.set( _modelMatrix.elements[ 12 ], _modelMatrix.elements[ 13 ], _modelMatrix.elements[ 14 ], 1 );
+				_vector4.applyMatrix4( _viewProjectionMatrix );
+
+				var invW = 1 / _vector4.w;
+
+				_vector4.z *= invW;
+
+				if ( _vector4.z >= - 1 && _vector4.z <= 1 ) {
+
+					_sprite = getNextSpriteInPool();
+					_sprite.id = object.id;
+					_sprite.x = _vector4.x * invW;
+					_sprite.y = _vector4.y * invW;
+					_sprite.z = _vector4.z;
+					_sprite.renderOrder = object.renderOrder;
+					_sprite.object = object;
+
+					_sprite.rotation = object.rotation;
+
+					_sprite.scale.x = object.scale.x * Math.abs( _sprite.x - ( _vector4.x + camera.projectionMatrix.elements[ 0 ] ) / ( _vector4.w + camera.projectionMatrix.elements[ 12 ] ) );
+					_sprite.scale.y = object.scale.y * Math.abs( _sprite.y - ( _vector4.y + camera.projectionMatrix.elements[ 5 ] ) / ( _vector4.w + camera.projectionMatrix.elements[ 13 ] ) );
+
+					_sprite.material = object.material;
+
+					_renderData.elements.push( _sprite );
+
+				}
+
+			}
+
+		}
+
+		if ( sortElements === true ) {
+
+			_renderData.elements.sort( painterSort );
+
+		}
+
+		return _renderData;
+
+	};
+
+	// Pools
+
+	function getNextObjectInPool() {
+
+		if ( _objectCount === _objectPoolLength ) {
+
+			var object = new THREE.RenderableObject();
+			_objectPool.push( object );
+			_objectPoolLength ++;
+			_objectCount ++;
+			return object;
+
+		}
+
+		return _objectPool[ _objectCount ++ ];
+
+	}
+
+	function getNextVertexInPool() {
+
+		if ( _vertexCount === _vertexPoolLength ) {
+
+			var vertex = new THREE.RenderableVertex();
+			_vertexPool.push( vertex );
+			_vertexPoolLength ++;
+			_vertexCount ++;
+			return vertex;
+
+		}
+
+		return _vertexPool[ _vertexCount ++ ];
+
+	}
+
+	function getNextFaceInPool() {
+
+		if ( _faceCount === _facePoolLength ) {
+
+			var face = new THREE.RenderableFace();
+			_facePool.push( face );
+			_facePoolLength ++;
+			_faceCount ++;
+			return face;
+
+		}
+
+		return _facePool[ _faceCount ++ ];
+
+
+	}
+
+	function getNextLineInPool() {
+
+		if ( _lineCount === _linePoolLength ) {
+
+			var line = new THREE.RenderableLine();
+			_linePool.push( line );
+			_linePoolLength ++;
+			_lineCount ++;
+			return line;
+
+		}
+
+		return _linePool[ _lineCount ++ ];
+
+	}
+
+	function getNextSpriteInPool() {
+
+		if ( _spriteCount === _spritePoolLength ) {
+
+			var sprite = new THREE.RenderableSprite();
+			_spritePool.push( sprite );
+			_spritePoolLength ++;
+			_spriteCount ++;
+			return sprite;
+
+		}
+
+		return _spritePool[ _spriteCount ++ ];
+
+	}
+
+	//
+
+	function painterSort( a, b ) {
+
+		if ( a.renderOrder !== b.renderOrder ) {
+
+			return a.renderOrder - b.renderOrder;
+
+		} else if ( a.z !== b.z ) {
+
+			return b.z - a.z;
+
+		} else if ( a.id !== b.id ) {
+
+			return a.id - b.id;
+
+		} else {
+
+			return 0;
+
+		}
+
+	}
+
+	function clipLine( s1, s2 ) {
+
+		var alpha1 = 0, alpha2 = 1,
+
+		// Calculate the boundary coordinate of each vertex for the near and far clip planes,
+		// Z = -1 and Z = +1, respectively.
+		bc1near =  s1.z + s1.w,
+		bc2near =  s2.z + s2.w,
+		bc1far =  - s1.z + s1.w,
+		bc2far =  - s2.z + s2.w;
+
+		if ( bc1near >= 0 && bc2near >= 0 && bc1far >= 0 && bc2far >= 0 ) {
+
+			// Both vertices lie entirely within all clip planes.
+			return true;
+
+		} else if ( ( bc1near < 0 && bc2near < 0 ) || ( bc1far < 0 && bc2far < 0 ) ) {
+
+			// Both vertices lie entirely outside one of the clip planes.
+			return false;
+
+		} else {
+
+			// The line segment spans at least one clip plane.
+
+			if ( bc1near < 0 ) {
+
+				// v1 lies outside the near plane, v2 inside
+				alpha1 = Math.max( alpha1, bc1near / ( bc1near - bc2near ) );
+
+			} else if ( bc2near < 0 ) {
+
+				// v2 lies outside the near plane, v1 inside
+				alpha2 = Math.min( alpha2, bc1near / ( bc1near - bc2near ) );
+
+			}
+
+			if ( bc1far < 0 ) {
+
+				// v1 lies outside the far plane, v2 inside
+				alpha1 = Math.max( alpha1, bc1far / ( bc1far - bc2far ) );
+
+			} else if ( bc2far < 0 ) {
+
+				// v2 lies outside the far plane, v2 inside
+				alpha2 = Math.min( alpha2, bc1far / ( bc1far - bc2far ) );
+
+			}
+
+			if ( alpha2 < alpha1 ) {
+
+				// The line segment spans two boundaries, but is outside both of them.
+				// (This can't happen when we're only clipping against just near/far but good
+				//  to leave the check here for future usage if other clip planes are added.)
+				return false;
+
+			} else {
+
+				// Update the s1 and s2 vertices to match the clipped line segment.
+				s1.lerp( s2, alpha1 );
+				s2.lerp( s1, 1 - alpha2 );
+
+				return true;
+
+			}
+
+		}
+
+	}
+
+};
diff --git a/html/js/three/three.js b/html/js/three/three.js
new file mode 100755
index 0000000..6756092
--- /dev/null
+++ b/html/js/three/three.js
@@ -0,0 +1,41507 @@
+// File:src/Three.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+var THREE = { REVISION: '76' };
+
+//
+
+if ( typeof define === 'function' && define.amd ) {
+
+	define( 'three', THREE );
+
+} else if ( 'undefined' !== typeof exports && 'undefined' !== typeof module ) {
+
+	module.exports = THREE;
+
+}
+
+//
+
+if ( Number.EPSILON === undefined ) {
+
+	Number.EPSILON = Math.pow( 2, - 52 );
+
+}
+
+//
+
+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 > 0 ) ? 1 : + x;
+
+	};
+
+}
+
+if ( Function.prototype.name === undefined && Object.defineProperty !== undefined ) {
+
+	// Missing in IE9-11.
+	// 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*)\s*\(/ )[ 1 ];
+
+		}
+
+	} );
+
+}
+
+if ( Object.assign === undefined ) {
+
+	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+
+	Object.defineProperty( Object, 'assign', {
+
+		writable: true,
+		configurable: true,
+
+		value: function ( target ) {
+
+			'use strict';
+
+			if ( target === undefined || target === null ) {
+
+				throw new TypeError( "Cannot convert first argument to object" );
+
+			}
+
+			var to = Object( target );
+
+			for ( var i = 1, n = arguments.length; i !== n; ++ i ) {
+
+				var nextSource = arguments[ i ];
+
+				if ( nextSource === undefined || nextSource === null ) continue;
+
+				nextSource = Object( nextSource );
+
+				var keysArray = Object.keys( nextSource );
+
+				for ( var nextIndex = 0, len = keysArray.length; nextIndex !== len; ++ nextIndex ) {
+
+					var nextKey = keysArray[ nextIndex ];
+					var desc = Object.getOwnPropertyDescriptor( nextSource, nextKey );
+
+					if ( desc !== undefined && desc.enumerable ) {
+
+						to[ nextKey ] = nextSource[ nextKey ];
+
+					}
+
+				}
+
+			}
+
+			return to;
+
+		}
+
+	} );
+
+}
+
+// https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.button
+
+THREE.MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2 };
+
+// GL STATE CONSTANTS
+
+THREE.CullFaceNone = 0;
+THREE.CullFaceBack = 1;
+THREE.CullFaceFront = 2;
+THREE.CullFaceFrontBack = 3;
+
+THREE.FrontFaceDirectionCW = 0;
+THREE.FrontFaceDirectionCCW = 1;
+
+// SHADOWING TYPES
+
+THREE.BasicShadowMap = 0;
+THREE.PCFShadowMap = 1;
+THREE.PCFSoftShadowMap = 2;
+
+// MATERIAL CONSTANTS
+
+// side
+
+THREE.FrontSide = 0;
+THREE.BackSide = 1;
+THREE.DoubleSide = 2;
+
+// shading
+
+THREE.FlatShading = 1;
+THREE.SmoothShading = 2;
+
+// colors
+
+THREE.NoColors = 0;
+THREE.FaceColors = 1;
+THREE.VertexColors = 2;
+
+// blending modes
+
+THREE.NoBlending = 0;
+THREE.NormalBlending = 1;
+THREE.AdditiveBlending = 2;
+THREE.SubtractiveBlending = 3;
+THREE.MultiplyBlending = 4;
+THREE.CustomBlending = 5;
+
+// custom blending equations
+// (numbers start from 100 not to clash with other
+// mappings to OpenGL constants defined in Texture.js)
+
+THREE.AddEquation = 100;
+THREE.SubtractEquation = 101;
+THREE.ReverseSubtractEquation = 102;
+THREE.MinEquation = 103;
+THREE.MaxEquation = 104;
+
+// custom blending destination factors
+
+THREE.ZeroFactor = 200;
+THREE.OneFactor = 201;
+THREE.SrcColorFactor = 202;
+THREE.OneMinusSrcColorFactor = 203;
+THREE.SrcAlphaFactor = 204;
+THREE.OneMinusSrcAlphaFactor = 205;
+THREE.DstAlphaFactor = 206;
+THREE.OneMinusDstAlphaFactor = 207;
+
+// custom blending source factors
+
+//THREE.ZeroFactor = 200;
+//THREE.OneFactor = 201;
+//THREE.SrcAlphaFactor = 204;
+//THREE.OneMinusSrcAlphaFactor = 205;
+//THREE.DstAlphaFactor = 206;
+//THREE.OneMinusDstAlphaFactor = 207;
+THREE.DstColorFactor = 208;
+THREE.OneMinusDstColorFactor = 209;
+THREE.SrcAlphaSaturateFactor = 210;
+
+// depth modes
+
+THREE.NeverDepth = 0;
+THREE.AlwaysDepth = 1;
+THREE.LessDepth = 2;
+THREE.LessEqualDepth = 3;
+THREE.EqualDepth = 4;
+THREE.GreaterEqualDepth = 5;
+THREE.GreaterDepth = 6;
+THREE.NotEqualDepth = 7;
+
+
+// TEXTURE CONSTANTS
+
+THREE.MultiplyOperation = 0;
+THREE.MixOperation = 1;
+THREE.AddOperation = 2;
+
+// Tone Mapping modes
+
+THREE.NoToneMapping = 0; // do not do any tone mapping, not even exposure (required for special purpose passes.)
+THREE.LinearToneMapping = 1; // only apply exposure.
+THREE.ReinhardToneMapping = 2;
+THREE.Uncharted2ToneMapping = 3; // John Hable
+THREE.CineonToneMapping = 4;  // optimized filmic operator by Jim Hejl and Richard Burgess-Dawson
+
+// Mapping modes
+
+THREE.UVMapping = 300;
+
+THREE.CubeReflectionMapping = 301;
+THREE.CubeRefractionMapping = 302;
+
+THREE.EquirectangularReflectionMapping = 303;
+THREE.EquirectangularRefractionMapping = 304;
+
+THREE.SphericalReflectionMapping = 305;
+THREE.CubeUVReflectionMapping = 306;
+THREE.CubeUVRefractionMapping = 307;
+
+// Wrapping modes
+
+THREE.RepeatWrapping = 1000;
+THREE.ClampToEdgeWrapping = 1001;
+THREE.MirroredRepeatWrapping = 1002;
+
+// Filters
+
+THREE.NearestFilter = 1003;
+THREE.NearestMipMapNearestFilter = 1004;
+THREE.NearestMipMapLinearFilter = 1005;
+THREE.LinearFilter = 1006;
+THREE.LinearMipMapNearestFilter = 1007;
+THREE.LinearMipMapLinearFilter = 1008;
+
+// Data types
+
+THREE.UnsignedByteType = 1009;
+THREE.ByteType = 1010;
+THREE.ShortType = 1011;
+THREE.UnsignedShortType = 1012;
+THREE.IntType = 1013;
+THREE.UnsignedIntType = 1014;
+THREE.FloatType = 1015;
+THREE.HalfFloatType = 1025;
+
+// Pixel types
+
+//THREE.UnsignedByteType = 1009;
+THREE.UnsignedShort4444Type = 1016;
+THREE.UnsignedShort5551Type = 1017;
+THREE.UnsignedShort565Type = 1018;
+
+// Pixel formats
+
+THREE.AlphaFormat = 1019;
+THREE.RGBFormat = 1020;
+THREE.RGBAFormat = 1021;
+THREE.LuminanceFormat = 1022;
+THREE.LuminanceAlphaFormat = 1023;
+// THREE.RGBEFormat handled as THREE.RGBAFormat in shaders
+THREE.RGBEFormat = THREE.RGBAFormat; //1024;
+THREE.DepthFormat = 1026;
+
+// DDS / ST3C Compressed texture formats
+
+THREE.RGB_S3TC_DXT1_Format = 2001;
+THREE.RGBA_S3TC_DXT1_Format = 2002;
+THREE.RGBA_S3TC_DXT3_Format = 2003;
+THREE.RGBA_S3TC_DXT5_Format = 2004;
+
+
+// PVRTC compressed texture formats
+
+THREE.RGB_PVRTC_4BPPV1_Format = 2100;
+THREE.RGB_PVRTC_2BPPV1_Format = 2101;
+THREE.RGBA_PVRTC_4BPPV1_Format = 2102;
+THREE.RGBA_PVRTC_2BPPV1_Format = 2103;
+
+// ETC compressed texture formats
+
+THREE.RGB_ETC1_Format = 2151;
+
+// Loop styles for AnimationAction
+
+THREE.LoopOnce = 2200;
+THREE.LoopRepeat = 2201;
+THREE.LoopPingPong = 2202;
+
+// Interpolation
+
+THREE.InterpolateDiscrete = 2300;
+THREE.InterpolateLinear = 2301;
+THREE.InterpolateSmooth = 2302;
+
+// Interpolant ending modes
+
+THREE.ZeroCurvatureEnding = 2400;
+THREE.ZeroSlopeEnding = 2401;
+THREE.WrapAroundEnding = 2402;
+
+// Triangle Draw modes
+
+THREE.TrianglesDrawMode = 0;
+THREE.TriangleStripDrawMode = 1;
+THREE.TriangleFanDrawMode = 2;
+
+// Texture Encodings
+
+THREE.LinearEncoding = 3000; // No encoding at all.
+THREE.sRGBEncoding = 3001;
+THREE.GammaEncoding = 3007; // uses GAMMA_FACTOR, for backwards compatibility with WebGLRenderer.gammaInput/gammaOutput
+
+// The following Texture Encodings are for RGB-only (no alpha) HDR light emission sources.
+// These encodings should not specified as output encodings except in rare situations.
+THREE.RGBEEncoding = 3002; // AKA Radiance.
+THREE.LogLuvEncoding = 3003;
+THREE.RGBM7Encoding = 3004;
+THREE.RGBM16Encoding = 3005;
+THREE.RGBDEncoding = 3006; // MaxRange is 256.
+
+// Depth packing strategies
+
+THREE.BasicDepthPacking = 3200;  // for writing to float textures for high precision or for visualizing results in RGB buffers
+THREE.RGBADepthPacking = 3201; // for packing into RGBA buffers.
+
+// File:src/math/Color.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.Color = function ( color ) {
+
+	if ( arguments.length === 3 ) {
+
+		return this.fromArray( arguments );
+
+	}
+
+	return this.set( color );
+
+};
+
+THREE.Color.prototype = {
+
+	constructor: THREE.Color,
+
+	r: 1, g: 1, b: 1,
+
+	set: function ( value ) {
+
+		if ( value instanceof THREE.Color ) {
+
+			this.copy( value );
+
+		} else if ( typeof value === 'number' ) {
+
+			this.setHex( value );
+
+		} else if ( typeof value === 'string' ) {
+
+			this.setStyle( value );
+
+		}
+
+		return this;
+
+	},
+
+	setScalar: function ( scalar ) {
+
+		this.r = scalar;
+		this.g = scalar;
+		this.b = scalar;
+
+	},
+
+	setHex: function ( hex ) {
+
+		hex = Math.floor( hex );
+
+		this.r = ( hex >> 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 () {
+
+		function hue2rgb( p, q, t ) {
+
+			if ( t < 0 ) t += 1;
+			if ( t > 1 ) t -= 1;
+			if ( t < 1 / 6 ) return p + ( q - p ) * 6 * t;
+			if ( t < 1 / 2 ) return q;
+			if ( t < 2 / 3 ) return p + ( q - p ) * 6 * ( 2 / 3 - t );
+			return p;
+
+		}
+
+		return function ( h, s, l ) {
+
+			// h,s,l ranges are in 0.0 - 1.0
+			h = THREE.Math.euclideanModulo( h, 1 );
+			s = THREE.Math.clamp( s, 0, 1 );
+			l = THREE.Math.clamp( l, 0, 1 );
+
+			if ( s === 0 ) {
+
+				this.r = this.g = this.b = l;
+
+			} else {
+
+				var p = l <= 0.5 ? l * ( 1 + s ) : l + s - ( l * s );
+				var q = ( 2 * l ) - p;
+
+				this.r = hue2rgb( q, p, h + 1 / 3 );
+				this.g = hue2rgb( q, p, h );
+				this.b = hue2rgb( q, p, h - 1 / 3 );
+
+			}
+
+			return this;
+
+		};
+
+	}(),
+
+	setStyle: function ( style ) {
+
+		function handleAlpha( string ) {
+
+			if ( string === undefined ) return;
+
+			if ( parseFloat( string ) < 1 ) {
+
+				console.warn( 'THREE.Color: Alpha component of ' + style + ' will be ignored.' );
+
+			}
+
+		}
+
+
+		var m;
+
+		if ( m = /^((?:rgb|hsl)a?)\(\s*([^\)]*)\)/.exec( style ) ) {
+
+			// rgb / hsl
+
+			var color;
+			var name = m[ 1 ];
+			var components = m[ 2 ];
+
+			switch ( name ) {
+
+				case 'rgb':
+				case 'rgba':
+
+					if ( color = /^(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) {
+
+						// rgb(255,0,0) rgba(255,0,0,0.5)
+						this.r = Math.min( 255, parseInt( color[ 1 ], 10 ) ) / 255;
+						this.g = Math.min( 255, parseInt( color[ 2 ], 10 ) ) / 255;
+						this.b = Math.min( 255, parseInt( color[ 3 ], 10 ) ) / 255;
+
+						handleAlpha( color[ 5 ] );
+
+						return this;
+
+					}
+
+					if ( color = /^(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) {
+
+						// rgb(100%,0%,0%) rgba(100%,0%,0%,0.5)
+						this.r = Math.min( 100, parseInt( color[ 1 ], 10 ) ) / 100;
+						this.g = Math.min( 100, parseInt( color[ 2 ], 10 ) ) / 100;
+						this.b = Math.min( 100, parseInt( color[ 3 ], 10 ) ) / 100;
+
+						handleAlpha( color[ 5 ] );
+
+						return this;
+
+					}
+
+					break;
+
+				case 'hsl':
+				case 'hsla':
+
+					if ( color = /^([0-9]*\.?[0-9]+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) {
+
+						// hsl(120,50%,50%) hsla(120,50%,50%,0.5)
+						var h = parseFloat( color[ 1 ] ) / 360;
+						var s = parseInt( color[ 2 ], 10 ) / 100;
+						var l = parseInt( color[ 3 ], 10 ) / 100;
+
+						handleAlpha( color[ 5 ] );
+
+						return this.setHSL( h, s, l );
+
+					}
+
+					break;
+
+			}
+
+		} else if ( m = /^\#([A-Fa-f0-9]+)$/.exec( style ) ) {
+
+			// hex color
+
+			var hex = m[ 1 ];
+			var size = hex.length;
+
+			if ( size === 3 ) {
+
+				// #ff0
+				this.r = parseInt( hex.charAt( 0 ) + hex.charAt( 0 ), 16 ) / 255;
+				this.g = parseInt( hex.charAt( 1 ) + hex.charAt( 1 ), 16 ) / 255;
+				this.b = parseInt( hex.charAt( 2 ) + hex.charAt( 2 ), 16 ) / 255;
+
+				return this;
+
+			} else if ( size === 6 ) {
+
+				// #ff0000
+				this.r = parseInt( hex.charAt( 0 ) + hex.charAt( 1 ), 16 ) / 255;
+				this.g = parseInt( hex.charAt( 2 ) + hex.charAt( 3 ), 16 ) / 255;
+				this.b = parseInt( hex.charAt( 4 ) + hex.charAt( 5 ), 16 ) / 255;
+
+				return this;
+
+			}
+
+		}
+
+		if ( style && style.length > 0 ) {
+
+			// color keywords
+			var hex = THREE.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 () {
+
+		var r = this.r, g = this.g, b = this.b;
+
+		this.r = r * r;
+		this.g = g * g;
+		this.b = b * b;
+
+		return this;
+
+	},
+
+	convertLinearToGamma: function () {
+
+		this.r = Math.sqrt( this.r );
+		this.g = Math.sqrt( this.g );
+		this.b = Math.sqrt( this.b );
+
+		return this;
+
+	},
+
+	getHex: function () {
+
+		return ( this.r * 255 ) << 16 ^ ( this.g * 255 ) << 8 ^ ( this.b * 255 ) << 0;
+
+	},
+
+	getHexString: function () {
+
+		return ( '000000' + this.getHex().toString( 16 ) ).slice( - 6 );
+
+	},
+
+	getHSL: function ( optionalTarget ) {
+
+		// h,s,l ranges are in 0.0 - 1.0
+
+		var hsl = optionalTarget || { h: 0, s: 0, l: 0 };
+
+		var r = this.r, g = this.g, b = this.b;
+
+		var max = Math.max( r, g, b );
+		var min = Math.min( r, g, b );
+
+		var hue, saturation;
+		var lightness = ( min + max ) / 2.0;
+
+		if ( min === max ) {
+
+			hue = 0;
+			saturation = 0;
+
+		} else {
+
+			var delta = max - min;
+
+			saturation = lightness <= 0.5 ? delta / ( max + min ) : delta / ( 2 - max - min );
+
+			switch ( max ) {
+
+				case r: hue = ( g - b ) / delta + ( g < b ? 6 : 0 ); break;
+				case g: hue = ( b - r ) / delta + 2; break;
+				case b: hue = ( r - g ) / delta + 4; break;
+
+			}
+
+			hue /= 6;
+
+		}
+
+		hsl.h = hue;
+		hsl.s = saturation;
+		hsl.l = lightness;
+
+		return hsl;
+
+	},
+
+	getStyle: function () {
+
+		return 'rgb(' + ( ( this.r * 255 ) | 0 ) + ',' + ( ( this.g * 255 ) | 0 ) + ',' + ( ( this.b * 255 ) | 0 ) + ')';
+
+	},
+
+	offsetHSL: function ( h, s, l ) {
+
+		var hsl = this.getHSL();
+
+		hsl.h += h; hsl.s += s; hsl.l += l;
+
+		this.setHSL( hsl.h, hsl.s, hsl.l );
+
+		return this;
+
+	},
+
+	add: function ( color ) {
+
+		this.r += color.r;
+		this.g += color.g;
+		this.b += color.b;
+
+		return this;
+
+	},
+
+	addColors: function ( color1, color2 ) {
+
+		this.r = color1.r + color2.r;
+		this.g = color1.g + color2.g;
+		this.b = color1.b + color2.b;
+
+		return this;
+
+	},
+
+	addScalar: function ( s ) {
+
+		this.r += s;
+		this.g += s;
+		this.b += s;
+
+		return this;
+
+	},
+
+	multiply: function ( color ) {
+
+		this.r *= color.r;
+		this.g *= color.g;
+		this.b *= color.b;
+
+		return this;
+
+	},
+
+	multiplyScalar: function ( s ) {
+
+		this.r *= s;
+		this.g *= s;
+		this.b *= s;
+
+		return this;
+
+	},
+
+	lerp: function ( color, alpha ) {
+
+		this.r += ( color.r - this.r ) * alpha;
+		this.g += ( color.g - this.g ) * alpha;
+		this.b += ( color.b - this.b ) * alpha;
+
+		return this;
+
+	},
+
+	equals: function ( c ) {
+
+		return ( c.r === this.r ) && ( c.g === this.g ) && ( c.b === this.b );
+
+	},
+
+	fromArray: function ( array, offset ) {
+
+		if ( offset === undefined ) offset = 0;
+
+		this.r = array[ offset ];
+		this.g = array[ offset + 1 ];
+		this.b = array[ offset + 2 ];
+
+		return this;
+
+	},
+
+	toArray: function ( array, offset ) {
+
+		if ( array === undefined ) array = [];
+		if ( offset === undefined ) offset = 0;
+
+		array[ offset ] = this.r;
+		array[ offset + 1 ] = this.g;
+		array[ offset + 2 ] = this.b;
+
+		return array;
+
+	}
+
+};
+
+THREE.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, '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 };
+
+// File:src/math/Quaternion.js
+
+/**
+ * @author mikael emtinger / http://gomo.se/
+ * @author alteredq / http://alteredqualia.com/
+ * @author WestLangley / http://github.com/WestLangley
+ * @author bhouston / http://clara.io
+ */
+
+THREE.Quaternion = function ( x, y, z, w ) {
+
+	this._x = x || 0;
+	this._y = y || 0;
+	this._z = z || 0;
+	this._w = ( w !== undefined ) ? w : 1;
+
+};
+
+THREE.Quaternion.prototype = {
+
+	constructor: THREE.Quaternion,
+
+	get x () {
+
+		return this._x;
+
+	},
+
+	set x ( value ) {
+
+		this._x = value;
+		this.onChangeCallback();
+
+	},
+
+	get y () {
+
+		return this._y;
+
+	},
+
+	set y ( value ) {
+
+		this._y = value;
+		this.onChangeCallback();
+
+	},
+
+	get z () {
+
+		return this._z;
+
+	},
+
+	set z ( value ) {
+
+		this._z = value;
+		this.onChangeCallback();
+
+	},
+
+	get w () {
+
+		return this._w;
+
+	},
+
+	set w ( value ) {
+
+		this._w = value;
+		this.onChangeCallback();
+
+	},
+
+	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 instanceof THREE.Euler === false ) {
+
+			throw new Error( 'THREE.Quaternion: .setFromEuler() now expects a Euler rotation rather than a Vector3 and order.' );
+
+		}
+
+		// http://www.mathworks.com/matlabcentral/fileexchange/
+		// 	20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
+		//	content/SpinCalc.m
+
+		var c1 = Math.cos( euler._x / 2 );
+		var c2 = Math.cos( euler._y / 2 );
+		var c3 = Math.cos( euler._z / 2 );
+		var s1 = Math.sin( euler._x / 2 );
+		var s2 = Math.sin( euler._y / 2 );
+		var s3 = Math.sin( euler._z / 2 );
+
+		var order = euler.order;
+
+		if ( order === '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;
+
+		} else if ( order === '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;
+
+		} else if ( order === '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;
+
+		} else if ( order === '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;
+
+		} else if ( order === '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;
+
+		} else if ( order === '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;
+
+		}
+
+		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 () {
+
+		// http://lolengine.net/blog/2014/02/24/quaternion-from-two-vectors-final
+
+		// assumes direction vectors vFrom and vTo are normalized
+
+		var v1, r;
+
+		var EPS = 0.000001;
+
+		return function ( vFrom, vTo ) {
+
+			if ( v1 === undefined ) v1 = new THREE.Vector3();
+
+			r = vFrom.dot( vTo ) + 1;
+
+			if ( r < EPS ) {
+
+				r = 0;
+
+				if ( Math.abs( vFrom.x ) > Math.abs( vFrom.z ) ) {
+
+					v1.set( - vFrom.y, vFrom.x, 0 );
+
+				} else {
+
+					v1.set( 0, - vFrom.z, vFrom.y );
+
+				}
+
+			} else {
+
+				v1.crossVectors( vFrom, vTo );
+
+			}
+
+			this._x = v1.x;
+			this._y = v1.y;
+			this._z = v1.z;
+			this._w = r;
+
+			this.normalize();
+
+			return this;
+
+		};
+
+	}(),
+
+	inverse: function () {
+
+		this.conjugate().normalize();
+
+		return this;
+
+	},
+
+	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 );
+
+	},
+
+	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 < 0 ) {
+
+			this._w = - qb._w;
+			this._x = - qb._x;
+			this._y = - qb._y;
+			this._z = - qb._z;
+
+			cosHalfTheta = - cosHalfTheta;
+
+		} else {
+
+			this.copy( qb );
+
+		}
+
+		if ( cosHalfTheta >= 1.0 ) {
+
+			this._w = w;
+			this._x = x;
+			this._y = y;
+			this._z = z;
+
+			return this;
+
+		}
+
+		var sinHalfTheta = Math.sqrt( 1.0 - cosHalfTheta * cosHalfTheta );
+
+		if ( Math.abs( sinHalfTheta ) < 0.001 ) {
+
+			this._w = 0.5 * ( w + this._w );
+			this._x = 0.5 * ( x + this._x );
+			this._y = 0.5 * ( y + this._y );
+			this._z = 0.5 * ( z + this._z );
+
+			return this;
+
+		}
+
+		var halfTheta = Math.atan2( sinHalfTheta, cosHalfTheta );
+		var ratioA = Math.sin( ( 1 - t ) * halfTheta ) / sinHalfTheta,
+		ratioB = Math.sin( t * halfTheta ) / sinHalfTheta;
+
+		this._w = ( w * ratioA + this._w * ratioB );
+		this._x = ( x * ratioA + this._x * ratioB );
+		this._y = ( y * ratioA + this._y * ratioB );
+		this._z = ( z * ratioA + this._z * ratioB );
+
+		this.onChangeCallback();
+
+		return this;
+
+	},
+
+	equals: function ( quaternion ) {
+
+		return ( quaternion._x === this._x ) && ( quaternion._y === this._y ) && ( quaternion._z === this._z ) && ( quaternion._w === this._w );
+
+	},
+
+	fromArray: function ( array, offset ) {
+
+		if ( offset === undefined ) offset = 0;
+
+		this._x = array[ offset ];
+		this._y = array[ offset + 1 ];
+		this._z = array[ offset + 2 ];
+		this._w = array[ offset + 3 ];
+
+		this.onChangeCallback();
+
+		return this;
+
+	},
+
+	toArray: function ( array, offset ) {
+
+		if ( array === undefined ) array = [];
+		if ( offset === undefined ) offset = 0;
+
+		array[ offset ] = this._x;
+		array[ offset + 1 ] = this._y;
+		array[ offset + 2 ] = this._z;
+		array[ offset + 3 ] = this._w;
+
+		return array;
+
+	},
+
+	onChange: function ( callback ) {
+
+		this.onChangeCallback = callback;
+
+		return this;
+
+	},
+
+	onChangeCallback: function () {}
+
+};
+
+Object.assign( THREE.Quaternion, {
+
+	slerp: function( qa, qb, qm, t ) {
+
+		return qm.copy( qa ).slerp( qb, t );
+
+	},
+
+	slerpFlat: function(
+			dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) {
+
+		// fuzz-free, array-based Quaternion SLERP operation
+
+		var x0 = src0[ srcOffset0 + 0 ],
+			y0 = src0[ srcOffset0 + 1 ],
+			z0 = src0[ srcOffset0 + 2 ],
+			w0 = src0[ srcOffset0 + 3 ],
+
+			x1 = src1[ srcOffset1 + 0 ],
+			y1 = src1[ srcOffset1 + 1 ],
+			z1 = src1[ srcOffset1 + 2 ],
+			w1 = src1[ srcOffset1 + 3 ];
+
+		if ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) {
+
+			var s = 1 - t,
+
+				cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
+
+				dir = ( cos >= 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;
+
+	}
+
+} );
+
+// File:src/math/Vector2.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author philogb / http://blog.thejit.org/
+ * @author egraether / http://egraether.com/
+ * @author zz85 / http://www.lab4games.net/zz85/blog
+ */
+
+THREE.Vector2 = function ( x, y ) {
+
+	this.x = x || 0;
+	this.y = y || 0;
+
+};
+
+THREE.Vector2.prototype = {
+
+	constructor: THREE.Vector2,
+
+	get width() {
+
+		return this.x;
+
+	},
+
+	set width( value ) {
+
+		this.x = value;
+
+	},
+
+	get height() {
+
+		return this.y;
+
+	},
+
+	set height( value ) {
+
+		this.y = value;
+
+	},
+
+	//
+
+	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 );
+
+		}
+
+	},
+
+	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 ) {
+
+		if ( isFinite( scalar ) ) {
+
+			this.x *= scalar;
+			this.y *= scalar;
+
+		} else {
+
+			this.x = 0;
+			this.y = 0;
+
+		}
+
+		return this;
+
+	},
+
+	divide: function ( v ) {
+
+		this.x /= v.x;
+		this.y /= v.y;
+
+		return this;
+
+	},
+
+	divideScalar: function ( scalar ) {
+
+		return this.multiplyScalar( 1 / scalar );
+
+	},
+
+	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 ) {
+
+		// This function assumes min < max, if this assumption isn't true it will not operate correctly
+
+		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
+		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
+
+		return this;
+
+	},
+
+	clampScalar: function () {
+
+		var min, max;
+
+		return function clampScalar( minVal, maxVal ) {
+
+			if ( min === undefined ) {
+
+				min = new THREE.Vector2();
+				max = new THREE.Vector2();
+
+			}
+
+			min.set( minVal, minVal );
+			max.set( maxVal, maxVal );
+
+			return this.clamp( min, max );
+
+		};
+
+	}(),
+
+	clampLength: function ( min, max ) {
+
+		var length = this.length();
+
+		this.multiplyScalar( Math.max( min, Math.min( max, length ) ) / length );
+
+		return this;
+
+	},
+
+	floor: function () {
+
+		this.x = Math.floor( this.x );
+		this.y = Math.floor( this.y );
+
+		return this;
+
+	},
+
+	ceil: function () {
+
+		this.x = Math.ceil( this.x );
+		this.y = Math.ceil( this.y );
+
+		return this;
+
+	},
+
+	round: function () {
+
+		this.x = Math.round( this.x );
+		this.y = Math.round( this.y );
+
+		return this;
+
+	},
+
+	roundToZero: function () {
+
+		this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
+		this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
+
+		return this;
+
+	},
+
+	negate: function () {
+
+		this.x = - this.x;
+		this.y = - this.y;
+
+		return this;
+
+	},
+
+	dot: function ( v ) {
+
+		return this.x * v.x + this.y * v.y;
+
+	},
+
+	lengthSq: function () {
+
+		return this.x * this.x + this.y * this.y;
+
+	},
+
+	length: function () {
+
+		return Math.sqrt( this.x * this.x + this.y * this.y );
+
+	},
+
+	lengthManhattan: function() {
+
+		return Math.abs( this.x ) + Math.abs( this.y );
+
+	},
+
+	normalize: function () {
+
+		return this.divideScalar( this.length() );
+
+	},
+
+	angle: function () {
+
+		// computes the angle in radians with respect to the positive x-axis
+
+		var angle = Math.atan2( this.y, this.x );
+
+		if ( angle < 0 ) angle += 2 * Math.PI;
+
+		return angle;
+
+	},
+
+	distanceTo: function ( v ) {
+
+		return Math.sqrt( this.distanceToSquared( v ) );
+
+	},
+
+	distanceToSquared: function ( v ) {
+
+		var dx = this.x - v.x, dy = this.y - v.y;
+		return dx * dx + dy * dy;
+
+	},
+
+	setLength: function ( length ) {
+
+		return this.multiplyScalar( length / this.length() );
+
+	},
+
+	lerp: function ( v, alpha ) {
+
+		this.x += ( v.x - this.x ) * alpha;
+		this.y += ( v.y - this.y ) * alpha;
+
+		return this;
+
+	},
+
+	lerpVectors: function ( v1, v2, alpha ) {
+
+		this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
+
+		return this;
+
+	},
+
+	equals: function ( v ) {
+
+		return ( ( v.x === this.x ) && ( v.y === this.y ) );
+
+	},
+
+	fromArray: function ( array, offset ) {
+
+		if ( offset === undefined ) offset = 0;
+
+		this.x = array[ offset ];
+		this.y = array[ offset + 1 ];
+
+		return this;
+
+	},
+
+	toArray: function ( array, offset ) {
+
+		if ( array === undefined ) array = [];
+		if ( offset === undefined ) offset = 0;
+
+		array[ offset ] = this.x;
+		array[ offset + 1 ] = this.y;
+
+		return array;
+
+	},
+
+	fromAttribute: function ( attribute, index, offset ) {
+
+		if ( offset === undefined ) offset = 0;
+
+		index = index * attribute.itemSize + offset;
+
+		this.x = attribute.array[ index ];
+		this.y = attribute.array[ index + 1 ];
+
+		return this;
+
+	},
+
+	rotateAround: function ( center, angle ) {
+
+		var c = Math.cos( angle ), s = Math.sin( angle );
+
+		var x = this.x - center.x;
+		var y = this.y - center.y;
+
+		this.x = x * c - y * s + center.x;
+		this.y = x * s + y * c + center.y;
+
+		return this;
+
+	}
+
+};
+
+// File:src/math/Vector3.js
+
+/**
+ * @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;
+
+	},
+
+	setScalar: function ( scalar ) {
+
+		this.x = scalar;
+		this.y = scalar;
+		this.z = scalar;
+
+		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 );
+
+		}
+
+	},
+
+	clone: function () {
+
+		return new this.constructor( this.x, this.y, this.z );
+
+	},
+
+	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( 'THREE.Vector3: .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;
+
+	},
+
+	addScaledVector: function ( v, s ) {
+
+		this.x += v.x * s;
+		this.y += v.y * s;
+		this.z += v.z * s;
+
+		return this;
+
+	},
+
+	sub: function ( v, w ) {
+
+		if ( w !== undefined ) {
+
+			console.warn( 'THREE.Vector3: .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;
+
+	},
+
+	subScalar: function ( s ) {
+
+		this.x -= s;
+		this.y -= s;
+		this.z -= s;
+
+		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( 'THREE.Vector3: .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 ( scalar ) {
+
+		if ( isFinite( scalar ) ) {
+
+			this.x *= scalar;
+			this.y *= scalar;
+			this.z *= scalar;
+
+		} else {
+
+			this.x = 0;
+			this.y = 0;
+			this.z = 0;
+
+		}
+
+		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;
+
+	},
+
+	applyEuler: function () {
+
+		var quaternion;
+
+		return function applyEuler( euler ) {
+
+			if ( euler instanceof THREE.Euler === false ) {
+
+				console.error( 'THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.' );
+
+			}
+
+			if ( quaternion === undefined ) quaternion = new THREE.Quaternion();
+
+			this.applyQuaternion( quaternion.setFromEuler( euler ) );
+
+			return this;
+
+		};
+
+	}(),
+
+	applyAxisAngle: function () {
+
+		var quaternion;
+
+		return function applyAxisAngle( axis, angle ) {
+
+			if ( quaternion === undefined ) quaternion = new THREE.Quaternion();
+
+			this.applyQuaternion( quaternion.setFromAxisAngle( axis, angle ) );
+
+			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;
+
+	},
+
+	project: function () {
+
+		var matrix;
+
+		return function project( camera ) {
+
+			if ( matrix === undefined ) matrix = new THREE.Matrix4();
+
+			matrix.multiplyMatrices( camera.projectionMatrix, matrix.getInverse( camera.matrixWorld ) );
+			return this.applyProjection( matrix );
+
+		};
+
+	}(),
+
+	unproject: function () {
+
+		var matrix;
+
+		return function unproject( camera ) {
+
+			if ( matrix === undefined ) matrix = new THREE.Matrix4();
+
+			matrix.multiplyMatrices( camera.matrixWorld, matrix.getInverse( camera.projectionMatrix ) );
+			return this.applyProjection( matrix );
+
+		};
+
+	}(),
+
+	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 ( scalar ) {
+
+		return this.multiplyScalar( 1 / scalar );
+
+	},
+
+	min: function ( v ) {
+
+		this.x = Math.min( this.x, v.x );
+		this.y = Math.min( this.y, v.y );
+		this.z = Math.min( this.z, v.z );
+
+		return this;
+
+	},
+
+	max: function ( v ) {
+
+		this.x = Math.max( this.x, v.x );
+		this.y = Math.max( this.y, v.y );
+		this.z = Math.max( 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
+
+		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
+		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
+		this.z = Math.max( min.z, Math.min( max.z, this.z ) );
+
+		return this;
+
+	},
+
+	clampScalar: function () {
+
+		var min, max;
+
+		return function clampScalar( minVal, maxVal ) {
+
+			if ( min === undefined ) {
+
+				min = new THREE.Vector3();
+				max = new THREE.Vector3();
+
+			}
+
+			min.set( minVal, minVal, minVal );
+			max.set( maxVal, maxVal, maxVal );
+
+			return this.clamp( min, max );
+
+		};
+
+	}(),
+
+	clampLength: function ( min, max ) {
+
+		var length = this.length();
+
+		this.multiplyScalar( Math.max( min, Math.min( max, length ) ) / length );
+
+		return this;
+
+	},
+
+	floor: function () {
+
+		this.x = Math.floor( this.x );
+		this.y = Math.floor( this.y );
+		this.z = Math.floor( this.z );
+
+		return this;
+
+	},
+
+	ceil: function () {
+
+		this.x = Math.ceil( this.x );
+		this.y = Math.ceil( this.y );
+		this.z = Math.ceil( this.z );
+
+		return this;
+
+	},
+
+	round: function () {
+
+		this.x = Math.round( this.x );
+		this.y = Math.round( this.y );
+		this.z = Math.round( this.z );
+
+		return this;
+
+	},
+
+	roundToZero: function () {
+
+		this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
+		this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
+		this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );
+
+		return this;
+
+	},
+
+	negate: function () {
+
+		this.x = - this.x;
+		this.y = - this.y;
+		this.z = - this.z;
+
+		return this;
+
+	},
+
+	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 ( length ) {
+
+		return this.multiplyScalar( length / this.length() );
+
+	},
+
+	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;
+
+	},
+
+	lerpVectors: function ( v1, v2, alpha ) {
+
+		this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
+
+		return this;
+
+	},
+
+	cross: function ( v, w ) {
+
+		if ( w !== undefined ) {
+
+			console.warn( 'THREE.Vector3: .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 ) {
+
+		var ax = a.x, ay = a.y, az = a.z;
+		var bx = b.x, by = b.y, bz = b.z;
+
+		this.x = ay * bz - az * by;
+		this.y = az * bx - ax * bz;
+		this.z = ax * by - ay * bx;
+
+		return this;
+
+	},
+
+	projectOnVector: function () {
+
+		var v1, dot;
+
+		return function projectOnVector( vector ) {
+
+			if ( v1 === undefined ) v1 = new THREE.Vector3();
+
+			v1.copy( vector ).normalize();
+
+			dot = this.dot( v1 );
+
+			return this.copy( v1 ).multiplyScalar( dot );
+
+		};
+
+	}(),
+
+	projectOnPlane: function () {
+
+		var v1;
+
+		return function projectOnPlane( planeNormal ) {
+
+			if ( v1 === undefined ) v1 = new THREE.Vector3();
+
+			v1.copy( this ).projectOnVector( planeNormal );
+
+			return this.sub( v1 );
+
+		};
+
+	}(),
+
+	reflect: function () {
+
+		// reflect incident vector off plane orthogonal to normal
+		// normal is assumed to have unit length
+
+		var v1;
+
+		return function reflect( normal ) {
+
+			if ( v1 === undefined ) v1 = new THREE.Vector3();
+
+			return this.sub( v1.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) );
+
+		};
+
+	}(),
+
+	angleTo: function ( v ) {
+
+		var theta = this.dot( v ) / ( Math.sqrt( this.lengthSq() * v.lengthSq() ) );
+
+		// 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;
+
+	},
+
+	setFromSpherical: function( s ) {
+
+		var sinPhiRadius = Math.sin( s.phi ) * s.radius;
+
+		this.x = sinPhiRadius * Math.sin( s.theta );
+		this.y = Math.cos( s.phi ) * s.radius;
+		this.z = sinPhiRadius * Math.cos( s.theta );
+
+		return this;
+
+	},
+
+	setFromMatrixPosition: function ( m ) {
+
+		return this.setFromMatrixColumn( m, 3 );
+
+	},
+
+	setFromMatrixScale: function ( m ) {
+
+		var sx = this.setFromMatrixColumn( m, 0 ).length();
+		var sy = this.setFromMatrixColumn( m, 1 ).length();
+		var sz = this.setFromMatrixColumn( m, 2 ).length();
+
+		this.x = sx;
+		this.y = sy;
+		this.z = sz;
+
+		return this;
+
+	},
+
+	setFromMatrixColumn: function ( m, index ) {
+
+		if ( typeof m === 'number' ) {
+
+			console.warn( 'THREE.Vector3: setFromMatrixColumn now expects ( matrix, index ).' );
+
+			m = arguments[ 1 ];
+			index = arguments[ 0 ];
+
+		}
+
+		return this.fromArray( m.elements, index * 4 );
+
+	},
+
+	equals: function ( v ) {
+
+		return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) );
+
+	},
+
+	fromArray: function ( array, offset ) {
+
+		if ( offset === undefined ) offset = 0;
+
+		this.x = array[ offset ];
+		this.y = array[ offset + 1 ];
+		this.z = array[ offset + 2 ];
+
+		return this;
+
+	},
+
+	toArray: function ( array, offset ) {
+
+		if ( array === undefined ) array = [];
+		if ( offset === undefined ) offset = 0;
+
+		array[ offset ] = this.x;
+		array[ offset + 1 ] = this.y;
+		array[ offset + 2 ] = this.z;
+
+		return array;
+
+	},
+
+	fromAttribute: function ( attribute, index, offset ) {
+
+		if ( offset === undefined ) offset = 0;
+
+		index = index * attribute.itemSize + offset;
+
+		this.x = attribute.array[ index ];
+		this.y = attribute.array[ index + 1 ];
+		this.z = attribute.array[ index + 2 ];
+
+		return this;
+
+	}
+
+};
+
+// File:src/math/Vector4.js
+
+/**
+ * @author supereggbert / http://www.paulbrunt.co.uk/
+ * @author philogb / http://blog.thejit.org/
+ * @author mikael emtinger / http://gomo.se/
+ * @author egraether / http://egraether.com/
+ * @author WestLangley / http://github.com/WestLangley
+ */
+
+THREE.Vector4 = function ( x, y, z, w ) {
+
+	this.x = x || 0;
+	this.y = y || 0;
+	this.z = z || 0;
+	this.w = ( w !== undefined ) ? w : 1;
+
+};
+
+THREE.Vector4.prototype = {
+
+	constructor: THREE.Vector4,
+
+	set: function ( x, y, z, w ) {
+
+		this.x = x;
+		this.y = y;
+		this.z = z;
+		this.w = w;
+
+		return this;
+
+	},
+
+	setScalar: function ( scalar ) {
+
+		this.x = scalar;
+		this.y = scalar;
+		this.z = scalar;
+		this.w = scalar;
+
+		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;
+
+	},
+
+	setW: function ( w ) {
+
+		this.w = w;
+
+		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;
+			case 3: this.w = 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;
+			case 3: return this.w;
+			default: throw new Error( 'index is out of range: ' + index );
+
+		}
+
+	},
+
+	clone: function () {
+
+		return new this.constructor( this.x, this.y, this.z, this.w );
+
+	},
+
+	copy: function ( v ) {
+
+		this.x = v.x;
+		this.y = v.y;
+		this.z = v.z;
+		this.w = ( v.w !== undefined ) ? v.w : 1;
+
+		return this;
+
+	},
+
+	add: function ( v, w ) {
+
+		if ( w !== undefined ) {
+
+			console.warn( 'THREE.Vector4: .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;
+		this.w += v.w;
+
+		return this;
+
+	},
+
+	addScalar: function ( s ) {
+
+		this.x += s;
+		this.y += s;
+		this.z += s;
+		this.w += 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;
+		this.w = a.w + b.w;
+
+		return this;
+
+	},
+
+	addScaledVector: function ( v, s ) {
+
+		this.x += v.x * s;
+		this.y += v.y * s;
+		this.z += v.z * s;
+		this.w += v.w * s;
+
+		return this;
+
+	},
+
+	sub: function ( v, w ) {
+
+		if ( w !== undefined ) {
+
+			console.warn( 'THREE.Vector4: .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;
+		this.w -= v.w;
+
+		return this;
+
+	},
+
+	subScalar: function ( s ) {
+
+		this.x -= s;
+		this.y -= s;
+		this.z -= s;
+		this.w -= s;
+
+		return this;
+
+	},
+
+	subVectors: function ( a, b ) {
+
+		this.x = a.x - b.x;
+		this.y = a.y - b.y;
+		this.z = a.z - b.z;
+		this.w = a.w - b.w;
+
+		return this;
+
+	},
+
+	multiplyScalar: function ( scalar ) {
+
+		if ( isFinite( scalar ) ) {
+
+			this.x *= scalar;
+			this.y *= scalar;
+			this.z *= scalar;
+			this.w *= scalar;
+
+		} else {
+
+			this.x = 0;
+			this.y = 0;
+			this.z = 0;
+			this.w = 0;
+
+		}
+
+		return this;
+
+	},
+
+	applyMatrix4: function ( m ) {
+
+		var x = this.x;
+		var y = this.y;
+		var z = this.z;
+		var w = this.w;
+
+		var e = m.elements;
+
+		this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w;
+		this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w;
+		this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w;
+		this.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w;
+
+		return this;
+
+	},
+
+	divideScalar: function ( scalar ) {
+
+		return this.multiplyScalar( 1 / scalar );
+
+	},
+
+	setAxisAngleFromQuaternion: function ( q ) {
+
+		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
+
+		// q is assumed to be normalized
+
+		this.w = 2 * Math.acos( q.w );
+
+		var s = Math.sqrt( 1 - q.w * q.w );
+
+		if ( s < 0.0001 ) {
+
+			 this.x = 1;
+			 this.y = 0;
+			 this.z = 0;
+
+		} else {
+
+			 this.x = q.x / s;
+			 this.y = q.y / s;
+			 this.z = q.z / s;
+
+		}
+
+		return this;
+
+	},
+
+	setAxisAngleFromRotationMatrix: function ( m ) {
+
+		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm
+
+		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+
+		var angle, x, y, z,		// variables for result
+			epsilon = 0.01,		// margin to allow for rounding errors
+			epsilon2 = 0.1,		// margin to distinguish between 0 and 180 degrees
+
+			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 ];
+
+		if ( ( Math.abs( m12 - m21 ) < epsilon ) &&
+		     ( Math.abs( m13 - m31 ) < epsilon ) &&
+		     ( Math.abs( m23 - m32 ) < epsilon ) ) {
+
+			// singularity found
+			// first check for identity matrix which must have +1 for all terms
+			// in leading diagonal and zero in other terms
+
+			if ( ( Math.abs( m12 + m21 ) < epsilon2 ) &&
+			     ( Math.abs( m13 + m31 ) < epsilon2 ) &&
+			     ( Math.abs( m23 + m32 ) < epsilon2 ) &&
+			     ( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) {
+
+				// this singularity is identity matrix so angle = 0
+
+				this.set( 1, 0, 0, 0 );
+
+				return this; // zero angle, arbitrary axis
+
+			}
+
+			// otherwise this singularity is angle = 180
+
+			angle = Math.PI;
+
+			var xx = ( m11 + 1 ) / 2;
+			var yy = ( m22 + 1 ) / 2;
+			var zz = ( m33 + 1 ) / 2;
+			var xy = ( m12 + m21 ) / 4;
+			var xz = ( m13 + m31 ) / 4;
+			var yz = ( m23 + m32 ) / 4;
+
+			if ( ( xx > yy ) && ( xx > zz ) ) {
+
+				// m11 is the largest diagonal term
+
+				if ( xx < epsilon ) {
+
+					x = 0;
+					y = 0.707106781;
+					z = 0.707106781;
+
+				} else {
+
+					x = Math.sqrt( xx );
+					y = xy / x;
+					z = xz / x;
+
+				}
+
+			} else if ( yy > zz ) {
+
+				// m22 is the largest diagonal term
+
+				if ( yy < epsilon ) {
+
+					x = 0.707106781;
+					y = 0;
+					z = 0.707106781;
+
+				} else {
+
+					y = Math.sqrt( yy );
+					x = xy / y;
+					z = yz / y;
+
+				}
+
+			} else {
+
+				// m33 is the largest diagonal term so base result on this
+
+				if ( zz < epsilon ) {
+
+					x = 0.707106781;
+					y = 0.707106781;
+					z = 0;
+
+				} else {
+
+					z = Math.sqrt( zz );
+					x = xz / z;
+					y = yz / z;
+
+				}
+
+			}
+
+			this.set( x, y, z, angle );
+
+			return this; // return 180 deg rotation
+
+		}
+
+		// as we have reached here there are no singularities so we can handle normally
+
+		var s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) +
+		                   ( m13 - m31 ) * ( m13 - m31 ) +
+		                   ( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize
+
+		if ( Math.abs( s ) < 0.001 ) s = 1;
+
+		// prevent divide by zero, should not happen if matrix is orthogonal and should be
+		// caught by singularity test above, but I've left it in just in case
+
+		this.x = ( m32 - m23 ) / s;
+		this.y = ( m13 - m31 ) / s;
+		this.z = ( m21 - m12 ) / s;
+		this.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 );
+
+		return this;
+
+	},
+
+	min: function ( v ) {
+
+		this.x = Math.min( this.x, v.x );
+		this.y = Math.min( this.y, v.y );
+		this.z = Math.min( this.z, v.z );
+		this.w = Math.min( this.w, v.w );
+
+		return this;
+
+	},
+
+	max: function ( v ) {
+
+		this.x = Math.max( this.x, v.x );
+		this.y = Math.max( this.y, v.y );
+		this.z = Math.max( this.z, v.z );
+		this.w = Math.max( this.w, v.w );
+
+		return this;
+
+	},
+
+	clamp: function ( min, max ) {
+
+		// This function assumes min < max, if this assumption isn't true it will not operate correctly
+
+		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
+		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
+		this.z = Math.max( min.z, Math.min( max.z, this.z ) );
+		this.w = Math.max( min.w, Math.min( max.w, this.w ) );
+
+		return this;
+
+	},
+
+	clampScalar: function () {
+
+		var min, max;
+
+		return function clampScalar( minVal, maxVal ) {
+
+			if ( min === undefined ) {
+
+				min = new THREE.Vector4();
+				max = new THREE.Vector4();
+
+			}
+
+			min.set( minVal, minVal, minVal, minVal );
+			max.set( maxVal, maxVal, maxVal, maxVal );
+
+			return this.clamp( min, max );
+
+		};
+
+	}(),
+
+	floor: function () {
+
+		this.x = Math.floor( this.x );
+		this.y = Math.floor( this.y );
+		this.z = Math.floor( this.z );
+		this.w = Math.floor( this.w );
+
+		return this;
+
+	},
+
+	ceil: function () {
+
+		this.x = Math.ceil( this.x );
+		this.y = Math.ceil( this.y );
+		this.z = Math.ceil( this.z );
+		this.w = Math.ceil( this.w );
+
+		return this;
+
+	},
+
+	round: function () {
+
+		this.x = Math.round( this.x );
+		this.y = Math.round( this.y );
+		this.z = Math.round( this.z );
+		this.w = Math.round( this.w );
+
+		return this;
+
+	},
+
+	roundToZero: function () {
+
+		this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
+		this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
+		this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );
+		this.w = ( this.w < 0 ) ? Math.ceil( this.w ) : Math.floor( this.w );
+
+		return this;
+
+	},
+
+	negate: function () {
+
+		this.x = - this.x;
+		this.y = - this.y;
+		this.z = - this.z;
+		this.w = - this.w;
+
+		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 );
+
+	},
+
+	lengthManhattan: function () {
+
+		return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w );
+
+	},
+
+	normalize: function () {
+
+		return this.divideScalar( this.length() );
+
+	},
+
+	setLength: function ( length ) {
+
+		return this.multiplyScalar( length / this.length() );
+
+	},
+
+	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;
+		this.w += ( v.w - this.w ) * alpha;
+
+		return this;
+
+	},
+
+	lerpVectors: function ( v1, v2, alpha ) {
+
+		this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
+
+		return this;
+
+	},
+
+	equals: function ( v ) {
+
+		return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) );
+
+	},
+
+	fromArray: function ( array, offset ) {
+
+		if ( offset === undefined ) offset = 0;
+
+		this.x = array[ offset ];
+		this.y = array[ offset + 1 ];
+		this.z = array[ offset + 2 ];
+		this.w = array[ offset + 3 ];
+
+		return this;
+
+	},
+
+	toArray: function ( array, offset ) {
+
+		if ( array === undefined ) array = [];
+		if ( offset === undefined ) offset = 0;
+
+		array[ offset ] = this.x;
+		array[ offset + 1 ] = this.y;
+		array[ offset + 2 ] = this.z;
+		array[ offset + 3 ] = this.w;
+
+		return array;
+
+	},
+
+	fromAttribute: function ( attribute, index, offset ) {
+
+		if ( offset === undefined ) offset = 0;
+
+		index = index * attribute.itemSize + offset;
+
+		this.x = attribute.array[ index ];
+		this.y = attribute.array[ index + 1 ];
+		this.z = attribute.array[ index + 2 ];
+		this.w = attribute.array[ index + 3 ];
+
+		return this;
+
+	}
+
+};
+
+// File:src/math/Euler.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author WestLangley / http://github.com/WestLangley
+ * @author bhouston / http://clara.io
+ */
+
+THREE.Euler = function ( x, y, z, order ) {
+
+	this._x = x || 0;
+	this._y = y || 0;
+	this._z = z || 0;
+	this._order = order || THREE.Euler.DefaultOrder;
+
+};
+
+THREE.Euler.RotationOrders = [ 'XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX' ];
+
+THREE.Euler.DefaultOrder = 'XYZ';
+
+THREE.Euler.prototype = {
+
+	constructor: THREE.Euler,
+
+	get x () {
+
+		return this._x;
+
+	},
+
+	set x ( value ) {
+
+		this._x = value;
+		this.onChangeCallback();
+
+	},
+
+	get y () {
+
+		return this._y;
+
+	},
+
+	set y ( value ) {
+
+		this._y = value;
+		this.onChangeCallback();
+
+	},
+
+	get z () {
+
+		return this._z;
+
+	},
+
+	set z ( value ) {
+
+		this._z = value;
+		this.onChangeCallback();
+
+	},
+
+	get order () {
+
+		return this._order;
+
+	},
+
+	set order ( value ) {
+
+		this._order = value;
+		this.onChangeCallback();
+
+	},
+
+	set: function ( x, y, z, order ) {
+
+		this._x = x;
+		this._y = y;
+		this._z = z;
+		this._order = order || this._order;
+
+		this.onChangeCallback();
+
+		return this;
+
+	},
+
+	clone: function () {
+
+		return new this.constructor( this._x, this._y, this._z, this._order );
+
+	},
+
+	copy: function ( euler ) {
+
+		this._x = euler._x;
+		this._y = euler._y;
+		this._z = euler._z;
+		this._order = euler._order;
+
+		this.onChangeCallback();
+
+		return this;
+
+	},
+
+	setFromRotationMatrix: function ( m, order, update ) {
+
+		var clamp = THREE.Math.clamp;
+
+		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+
+		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 ];
+
+		order = order || this._order;
+
+		if ( order === 'XYZ' ) {
+
+			this._y = Math.asin( clamp( m13, - 1, 1 ) );
+
+			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, - 1, 1 ) );
+
+			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, - 1, 1 ) );
+
+			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, - 1, 1 ) );
+
+			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, - 1, 1 ) );
+
+			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, - 1, 1 ) );
+
+			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;
+
+			}
+
+		} else {
+
+			console.warn( 'THREE.Euler: .setFromRotationMatrix() given unsupported order: ' + order );
+
+		}
+
+		this._order = order;
+
+		if ( update !== false ) this.onChangeCallback();
+
+		return this;
+
+	},
+
+	setFromQuaternion: function () {
+
+		var matrix;
+
+		return function ( q, order, update ) {
+
+			if ( matrix === undefined ) matrix = new THREE.Matrix4();
+			matrix.makeRotationFromQuaternion( q );
+			this.setFromRotationMatrix( matrix, order, update );
+
+			return this;
+
+		};
+
+	}(),
+
+	setFromVector3: function ( v, order ) {
+
+		return this.set( v.x, v.y, v.z, order || this._order );
+
+	},
+
+	reorder: function () {
+
+		// WARNING: this discards revolution information -bhouston
+
+		var q = new THREE.Quaternion();
+
+		return function ( newOrder ) {
+
+			q.setFromEuler( this );
+			this.setFromQuaternion( q, newOrder );
+
+		};
+
+	}(),
+
+	equals: function ( euler ) {
+
+		return ( euler._x === this._x ) && ( euler._y === this._y ) && ( euler._z === this._z ) && ( euler._order === this._order );
+
+	},
+
+	fromArray: function ( array ) {
+
+		this._x = array[ 0 ];
+		this._y = array[ 1 ];
+		this._z = array[ 2 ];
+		if ( array[ 3 ] !== undefined ) this._order = array[ 3 ];
+
+		this.onChangeCallback();
+
+		return this;
+
+	},
+
+	toArray: function ( array, offset ) {
+
+		if ( array === undefined ) array = [];
+		if ( offset === undefined ) offset = 0;
+
+		array[ offset ] = this._x;
+		array[ offset + 1 ] = this._y;
+		array[ offset + 2 ] = this._z;
+		array[ offset + 3 ] = this._order;
+
+		return array;
+
+	},
+
+	toVector3: function ( optionalResult ) {
+
+		if ( optionalResult ) {
+
+			return optionalResult.set( this._x, this._y, this._z );
+
+		} else {
+
+			return new THREE.Vector3( this._x, this._y, this._z );
+
+		}
+
+	},
+
+	onChange: function ( callback ) {
+
+		this.onChangeCallback = callback;
+
+		return this;
+
+	},
+
+	onChangeCallback: function () {}
+
+};
+
+// File:src/math/Line3.js
+
+/**
+ * @author bhouston / http://clara.io
+ */
+
+THREE.Line3 = function ( start, end ) {
+
+	this.start = ( start !== undefined ) ? start : new THREE.Vector3();
+	this.end = ( end !== undefined ) ? end : new THREE.Vector3();
+
+};
+
+THREE.Line3.prototype = {
+
+	constructor: THREE.Line3,
+
+	set: function ( start, end ) {
+
+		this.start.copy( start );
+		this.end.copy( end );
+
+		return this;
+
+	},
+
+	clone: function () {
+
+		return new this.constructor().copy( this );
+
+	},
+
+	copy: function ( line ) {
+
+		this.start.copy( line.start );
+		this.end.copy( line.end );
+
+		return this;
+
+	},
+
+	center: function ( optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector3();
+		return result.addVectors( this.start, this.end ).multiplyScalar( 0.5 );
+
+	},
+
+	delta: function ( optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector3();
+		return result.subVectors( this.end, this.start );
+
+	},
+
+	distanceSq: function () {
+
+		return this.start.distanceToSquared( this.end );
+
+	},
+
+	distance: function () {
+
+		return this.start.distanceTo( this.end );
+
+	},
+
+	at: function ( t, optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector3();
+
+		return this.delta( result ).multiplyScalar( t ).add( this.start );
+
+	},
+
+	closestPointToPointParameter: function () {
+
+		var startP = new THREE.Vector3();
+		var startEnd = new THREE.Vector3();
+
+		return function ( point, clampToLine ) {
+
+			startP.subVectors( point, this.start );
+			startEnd.subVectors( this.end, this.start );
+
+			var startEnd2 = startEnd.dot( startEnd );
+			var startEnd_startP = startEnd.dot( startP );
+
+			var t = startEnd_startP / startEnd2;
+
+			if ( clampToLine ) {
+
+				t = THREE.Math.clamp( t, 0, 1 );
+
+			}
+
+			return t;
+
+		};
+
+	}(),
+
+	closestPointToPoint: function ( point, clampToLine, optionalTarget ) {
+
+		var t = this.closestPointToPointParameter( point, clampToLine );
+
+		var result = optionalTarget || new THREE.Vector3();
+
+		return this.delta( result ).multiplyScalar( t ).add( this.start );
+
+	},
+
+	applyMatrix4: function ( matrix ) {
+
+		this.start.applyMatrix4( matrix );
+		this.end.applyMatrix4( matrix );
+
+		return this;
+
+	},
+
+	equals: function ( line ) {
+
+		return line.start.equals( this.start ) && line.end.equals( this.end );
+
+	}
+
+};
+
+// File:src/math/Box2.js
+
+/**
+ * @author bhouston / http://clara.io
+ */
+
+THREE.Box2 = function ( min, max ) {
+
+	this.min = ( min !== undefined ) ? min : new THREE.Vector2( + Infinity, + Infinity );
+	this.max = ( max !== undefined ) ? max : new THREE.Vector2( - Infinity, - Infinity );
+
+};
+
+THREE.Box2.prototype = {
+
+	constructor: THREE.Box2,
+
+	set: function ( min, max ) {
+
+		this.min.copy( min );
+		this.max.copy( max );
+
+		return this;
+
+	},
+
+	setFromPoints: function ( points ) {
+
+		this.makeEmpty();
+
+		for ( var i = 0, il = points.length; i < il; i ++ ) {
+
+			this.expandByPoint( points[ i ] );
+
+		}
+
+		return this;
+
+	},
+
+	setFromCenterAndSize: function () {
+
+		var v1 = new THREE.Vector2();
+
+		return function ( center, size ) {
+
+			var halfSize = v1.copy( size ).multiplyScalar( 0.5 );
+			this.min.copy( center ).sub( halfSize );
+			this.max.copy( center ).add( halfSize );
+
+			return this;
+
+		};
+
+	}(),
+
+	clone: function () {
+
+		return new this.constructor().copy( this );
+
+	},
+
+	copy: function ( box ) {
+
+		this.min.copy( box.min );
+		this.max.copy( box.max );
+
+		return this;
+
+	},
+
+	makeEmpty: function () {
+
+		this.min.x = this.min.y = + Infinity;
+		this.max.x = this.max.y = - Infinity;
+
+		return this;
+
+	},
+
+	isEmpty: function () {
+
+		// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
+
+		return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y );
+
+	},
+
+	center: function ( optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector2();
+		return result.addVectors( this.min, this.max ).multiplyScalar( 0.5 );
+
+	},
+
+	size: function ( optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector2();
+		return result.subVectors( this.max, this.min );
+
+	},
+
+	expandByPoint: function ( point ) {
+
+		this.min.min( point );
+		this.max.max( point );
+
+		return this;
+
+	},
+
+	expandByVector: function ( vector ) {
+
+		this.min.sub( vector );
+		this.max.add( vector );
+
+		return this;
+
+	},
+
+	expandByScalar: function ( scalar ) {
+
+		this.min.addScalar( - scalar );
+		this.max.addScalar( scalar );
+
+		return this;
+
+	},
+
+	containsPoint: function ( point ) {
+
+		if ( point.x < this.min.x || point.x > this.max.x ||
+		     point.y < this.min.y || point.y > this.max.y ) {
+
+			return false;
+
+		}
+
+		return true;
+
+	},
+
+	containsBox: function ( box ) {
+
+		if ( ( this.min.x <= box.min.x ) && ( box.max.x <= this.max.x ) &&
+		     ( this.min.y <= box.min.y ) && ( box.max.y <= this.max.y ) ) {
+
+			return true;
+
+		}
+
+		return false;
+
+	},
+
+	getParameter: function ( point, optionalTarget ) {
+
+		// This can potentially have a divide by zero if the box
+		// has a size dimension of 0.
+
+		var result = optionalTarget || new THREE.Vector2();
+
+		return result.set(
+			( point.x - this.min.x ) / ( this.max.x - this.min.x ),
+			( point.y - this.min.y ) / ( this.max.y - this.min.y )
+		);
+
+	},
+
+	intersectsBox: function ( box ) {
+
+		// using 6 splitting planes to rule out intersections.
+
+		if ( box.max.x < this.min.x || box.min.x > this.max.x ||
+		     box.max.y < this.min.y || box.min.y > this.max.y ) {
+
+			return false;
+
+		}
+
+		return true;
+
+	},
+
+	clampPoint: function ( point, optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector2();
+		return result.copy( point ).clamp( this.min, this.max );
+
+	},
+
+	distanceToPoint: function () {
+
+		var v1 = new THREE.Vector2();
+
+		return function ( point ) {
+
+			var clampedPoint = v1.copy( point ).clamp( this.min, this.max );
+			return clampedPoint.sub( point ).length();
+
+		};
+
+	}(),
+
+	intersect: function ( box ) {
+
+		this.min.max( box.min );
+		this.max.min( box.max );
+
+		return this;
+
+	},
+
+	union: function ( box ) {
+
+		this.min.min( box.min );
+		this.max.max( box.max );
+
+		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 );
+
+	}
+
+};
+
+// File:src/math/Box3.js
+
+/**
+ * @author bhouston / http://clara.io
+ * @author WestLangley / http://github.com/WestLangley
+ */
+
+THREE.Box3 = function ( min, max ) {
+
+	this.min = ( min !== undefined ) ? min : new THREE.Vector3( + Infinity, + Infinity, + Infinity );
+	this.max = ( max !== undefined ) ? max : new THREE.Vector3( - Infinity, - Infinity, - Infinity );
+
+};
+
+THREE.Box3.prototype = {
+
+	constructor: THREE.Box3,
+
+	set: function ( min, max ) {
+
+		this.min.copy( min );
+		this.max.copy( max );
+
+		return this;
+
+	},
+
+	setFromArray: function ( array ) {
+
+		var minX = + Infinity;
+		var minY = + Infinity;
+		var minZ = + Infinity;
+
+		var maxX = - Infinity;
+		var maxY = - Infinity;
+		var maxZ = - Infinity;
+
+		for ( var i = 0, l = array.length; i < l; i += 3 ) {
+
+			var x = array[ i ];
+			var y = array[ i + 1 ];
+			var z = array[ i + 2 ];
+
+			if ( x < minX ) minX = x;
+			if ( y < minY ) minY = y;
+			if ( z < minZ ) minZ = z;
+
+			if ( x > 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 );
+
+	},
+
+	setFromPoints: function ( points ) {
+
+		this.makeEmpty();
+
+		for ( var i = 0, il = points.length; i < il; i ++ ) {
+
+			this.expandByPoint( points[ i ] );
+
+		}
+
+		return this;
+
+	},
+
+	setFromCenterAndSize: function () {
+
+		var v1 = new THREE.Vector3();
+
+		return function ( center, size ) {
+
+			var halfSize = v1.copy( size ).multiplyScalar( 0.5 );
+
+			this.min.copy( center ).sub( halfSize );
+			this.max.copy( center ).add( halfSize );
+
+			return this;
+
+		};
+
+	}(),
+
+	setFromObject: function () {
+
+		// Computes the world-axis-aligned bounding box of an object (including its children),
+		// accounting for both the object's, and children's, world transforms
+
+		var v1 = new THREE.Vector3();
+
+		return function ( object ) {
+
+			var scope = this;
+
+			object.updateMatrixWorld( true );
+
+			this.makeEmpty();
+
+			object.traverse( function ( node ) {
+
+				var geometry = node.geometry;
+
+				if ( geometry !== undefined ) {
+
+					if ( geometry instanceof THREE.Geometry ) {
+
+						var vertices = geometry.vertices;
+
+						for ( var i = 0, il = vertices.length; i < il; i ++ ) {
+
+							v1.copy( vertices[ i ] );
+							v1.applyMatrix4( node.matrixWorld );
+
+							scope.expandByPoint( v1 );
+
+						}
+
+					} else if ( geometry instanceof THREE.BufferGeometry && geometry.attributes[ 'position' ] !== undefined ) {
+
+						var positions = geometry.attributes[ 'position' ].array;
+
+						for ( var i = 0, il = positions.length; i < il; i += 3 ) {
+
+							v1.fromArray( positions, i );
+							v1.applyMatrix4( node.matrixWorld );
+
+							scope.expandByPoint( v1 );
+
+						}
+
+					}
+
+				}
+
+			} );
+
+			return this;
+
+		};
+
+	}(),
+
+	clone: function () {
+
+		return new this.constructor().copy( this );
+
+	},
+
+	copy: function ( box ) {
+
+		this.min.copy( box.min );
+		this.max.copy( box.max );
+
+		return this;
+
+	},
+
+	makeEmpty: function () {
+
+		this.min.x = this.min.y = this.min.z = + Infinity;
+		this.max.x = this.max.y = this.max.z = - Infinity;
+
+		return this;
+
+	},
+
+	isEmpty: function () {
+
+		// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
+
+		return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y ) || ( this.max.z < this.min.z );
+
+	},
+
+	center: function ( optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector3();
+		return result.addVectors( this.min, this.max ).multiplyScalar( 0.5 );
+
+	},
+
+	size: function ( optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector3();
+		return result.subVectors( this.max, this.min );
+
+	},
+
+	expandByPoint: function ( point ) {
+
+		this.min.min( point );
+		this.max.max( point );
+
+		return this;
+
+	},
+
+	expandByVector: function ( vector ) {
+
+		this.min.sub( vector );
+		this.max.add( vector );
+
+		return this;
+
+	},
+
+	expandByScalar: function ( scalar ) {
+
+		this.min.addScalar( - scalar );
+		this.max.addScalar( scalar );
+
+		return this;
+
+	},
+
+	containsPoint: function ( point ) {
+
+		if ( point.x < this.min.x || point.x > this.max.x ||
+				 point.y < this.min.y || point.y > this.max.y ||
+				 point.z < this.min.z || point.z > this.max.z ) {
+
+			return false;
+
+		}
+
+		return true;
+
+	},
+
+	containsBox: function ( box ) {
+
+		if ( ( this.min.x <= box.min.x ) && ( box.max.x <= this.max.x ) &&
+			 ( this.min.y <= box.min.y ) && ( box.max.y <= this.max.y ) &&
+			 ( this.min.z <= box.min.z ) && ( box.max.z <= this.max.z ) ) {
+
+			return true;
+
+		}
+
+		return false;
+
+	},
+
+	getParameter: function ( point, optionalTarget ) {
+
+		// This can potentially have a divide by zero if the box
+		// has a size dimension of 0.
+
+		var result = optionalTarget || new THREE.Vector3();
+
+		return result.set(
+			( point.x - this.min.x ) / ( this.max.x - this.min.x ),
+			( point.y - this.min.y ) / ( this.max.y - this.min.y ),
+			( point.z - this.min.z ) / ( this.max.z - this.min.z )
+		);
+
+	},
+
+	intersectsBox: function ( box ) {
+
+		// using 6 splitting planes to rule out intersections.
+
+		if ( box.max.x < this.min.x || box.min.x > this.max.x ||
+				 box.max.y < this.min.y || box.min.y > this.max.y ||
+				 box.max.z < this.min.z || box.min.z > this.max.z ) {
+
+			return false;
+
+		}
+
+		return true;
+
+	},
+
+	intersectsSphere: ( function () {
+
+		var closestPoint;
+
+		return function intersectsSphere( sphere ) {
+
+			if ( closestPoint === undefined ) closestPoint = new THREE.Vector3();
+
+			// Find the point on the AABB closest to the sphere center.
+			this.clampPoint( sphere.center, closestPoint );
+
+			// If that point is inside the sphere, the AABB and sphere intersect.
+			return closestPoint.distanceToSquared( sphere.center ) <= ( sphere.radius * sphere.radius );
+
+		};
+
+	} )(),
+
+	intersectsPlane: function ( plane ) {
+
+		// We compute the minimum and maximum dot product values. If those values
+		// are on the same side (back or front) of the plane, then there is no intersection.
+
+		var min, max;
+
+		if ( plane.normal.x > 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 && max >= plane.constant );
+
+	},
+
+	clampPoint: function ( point, optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector3();
+		return result.copy( point ).clamp( this.min, this.max );
+
+	},
+
+	distanceToPoint: function () {
+
+		var v1 = new THREE.Vector3();
+
+		return function ( point ) {
+
+			var clampedPoint = v1.copy( point ).clamp( this.min, this.max );
+			return clampedPoint.sub( point ).length();
+
+		};
+
+	}(),
+
+	getBoundingSphere: function () {
+
+		var v1 = new THREE.Vector3();
+
+		return function ( optionalTarget ) {
+
+			var result = optionalTarget || new THREE.Sphere();
+
+			result.center = this.center();
+			result.radius = this.size( v1 ).length() * 0.5;
+
+			return result;
+
+		};
+
+	}(),
+
+	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 () {
+
+		var points = [
+			new THREE.Vector3(),
+			new THREE.Vector3(),
+			new THREE.Vector3(),
+			new THREE.Vector3(),
+			new THREE.Vector3(),
+			new THREE.Vector3(),
+			new THREE.Vector3(),
+			new THREE.Vector3()
+		];
+
+		return 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 );
+
+	}
+
+};
+
+// File:src/math/Matrix3.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ * @author WestLangley / http://github.com/WestLangley
+ * @author bhouston / http://clara.io
+ * @author tschw
+ */
+
+THREE.Matrix3 = function () {
+
+	this.elements = new Float32Array( [
+
+		1, 0, 0,
+		0, 1, 0,
+		0, 0, 1
+
+	] );
+
+	if ( arguments.length > 0 ) {
+
+		console.error( 'THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.' );
+
+	}
+
+};
+
+THREE.Matrix3.prototype = {
+
+	constructor: THREE.Matrix3,
+
+	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 me = m.elements;
+
+		this.set(
+
+			me[ 0 ], me[ 3 ], me[ 6 ],
+			me[ 1 ], me[ 4 ], me[ 7 ],
+			me[ 2 ], me[ 5 ], me[ 8 ]
+
+		);
+
+		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;
+
+	},
+
+	applyToVector3Array: function () {
+
+		var v1;
+
+		return function ( array, offset, length ) {
+
+			if ( v1 === undefined ) v1 = new THREE.Vector3();
+			if ( offset === undefined ) offset = 0;
+			if ( length === undefined ) length = array.length;
+
+			for ( var i = 0, j = offset; i < length; i += 3, j += 3 ) {
+
+				v1.fromArray( array, j );
+				v1.applyMatrix3( this );
+				v1.toArray( array, j );
+
+			}
+
+			return array;
+
+		};
+
+	}(),
+
+	applyToBuffer: function () {
+
+		var v1;
+
+		return function applyToBuffer( buffer, offset, length ) {
+
+			if ( v1 === undefined ) v1 = new THREE.Vector3();
+			if ( offset === undefined ) offset = 0;
+			if ( length === undefined ) length = buffer.length / buffer.itemSize;
+
+			for ( var i = 0, j = offset; i < length; i ++, j ++ ) {
+
+				v1.x = buffer.getX( j );
+				v1.y = buffer.getY( j );
+				v1.z = buffer.getZ( j );
+
+				v1.applyMatrix3( this );
+
+				buffer.setXYZ( v1.x, v1.y, v1.z );
+
+			}
+
+			return buffer;
+
+		};
+
+	}(),
+
+	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 ( matrix instanceof THREE.Matrix4 ) {
+
+			console.error( "THREE.Matrix3.getInverse no longer takes a Matrix4 argument." );
+
+		}
+
+		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 ) {
+
+			var msg = "THREE.Matrix3.getInverse(): can't invert matrix, determinant is 0";
+
+			if ( throwOnDegenerate || false ) {
+
+				throw new Error( msg );
+
+			} else {
+
+				console.warn( msg );
+
+			}
+
+			return this.identity();
+		}
+
+		te[ 0 ] = t11;
+		te[ 1 ] = n31 * n23 - n33 * n21;
+		te[ 2 ] = n32 * n21 - n31 * n22;
+
+		te[ 3 ] = t12;
+		te[ 4 ] = n33 * n11 - n31 * n13;
+		te[ 5 ] = n31 * n12 - n32 * n11;
+
+		te[ 6 ] = t13;
+		te[ 7 ] = n21 * n13 - n23 * n11;
+		te[ 8 ] = n22 * n11 - n21 * n12;
+
+		return this.multiplyScalar( 1 / det );
+
+	},
+
+	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;
+
+	},
+
+	flattenToArrayOffset: function ( array, offset ) {
+
+		console.warn( "THREE.Matrix3: .flattenToArrayOffset is deprecated " +
+				"- just use .toArray instead." );
+
+		return this.toArray( array, offset );
+
+	},
+
+	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;
+
+	},
+
+	fromArray: function ( array ) {
+
+		this.elements.set( array );
+
+		return this;
+
+	},
+
+	toArray: function ( array, offset ) {
+
+		if ( array === undefined ) array = [];
+		if ( offset === undefined ) offset = 0;
+
+		var te = this.elements;
+
+		array[ offset ] = te[ 0 ];
+		array[ offset + 1 ] = te[ 1 ];
+		array[ offset + 2 ] = te[ 2 ];
+
+		array[ offset + 3 ] = te[ 3 ];
+		array[ offset + 4 ] = te[ 4 ];
+		array[ offset + 5 ] = te[ 5 ];
+
+		array[ offset + 6 ] = te[ 6 ];
+		array[ offset + 7 ] = te[ 7 ];
+		array[ offset + 8 ]  = te[ 8 ];
+
+		return array;
+
+	}
+
+};
+
+// File:src/math/Matrix4.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author supereggbert / http://www.paulbrunt.co.uk/
+ * @author philogb / http://blog.thejit.org/
+ * @author jordi_ros / http://plattsoft.com
+ * @author D1plo1d / http://github.com/D1plo1d
+ * @author alteredq / http://alteredqualia.com/
+ * @author mikael emtinger / http://gomo.se/
+ * @author timknip / http://www.floorplanner.com/
+ * @author bhouston / http://clara.io
+ * @author WestLangley / http://github.com/WestLangley
+ */
+
+THREE.Matrix4 = function () {
+
+	this.elements = new Float32Array( [
+
+		1, 0, 0, 0,
+		0, 1, 0, 0,
+		0, 0, 1, 0,
+		0, 0, 0, 1
+
+	] );
+
+	if ( arguments.length > 0 ) {
+
+		console.error( 'THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.' );
+
+	}
+
+};
+
+THREE.Matrix4.prototype = {
+
+	constructor: THREE.Matrix4,
+
+	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 THREE.Matrix4().fromArray( this.elements );
+
+	},
+
+	copy: function ( m ) {
+
+		this.elements.set( m.elements );
+
+		return this;
+
+	},
+
+	copyPosition: function ( m ) {
+
+		var te = this.elements;
+		var 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 () {
+
+		var v1;
+
+		return function ( m ) {
+
+			if ( v1 === undefined ) v1 = new THREE.Vector3();
+
+			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[ 4 ] = me[ 4 ] * scaleY;
+			te[ 5 ] = me[ 5 ] * scaleY;
+			te[ 6 ] = me[ 6 ] * scaleY;
+
+			te[ 8 ] = me[ 8 ] * scaleZ;
+			te[ 9 ] = me[ 9 ] * scaleZ;
+			te[ 10 ] = me[ 10 ] * scaleZ;
+
+			return this;
+
+		};
+
+	}(),
+
+	makeRotationFromEuler: function ( euler ) {
+
+		if ( euler instanceof THREE.Euler === false ) {
+
+			console.error( 'THREE.Matrix: .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;
+
+		}
+
+		// last column
+		te[ 3 ] = 0;
+		te[ 7 ] = 0;
+		te[ 11 ] = 0;
+
+		// bottom row
+		te[ 12 ] = 0;
+		te[ 13 ] = 0;
+		te[ 14 ] = 0;
+		te[ 15 ] = 1;
+
+		return this;
+
+	},
+
+	makeRotationFromQuaternion: function ( q ) {
+
+		var te = this.elements;
+
+		var x = q.x, y = q.y, z = q.z, w = q.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;
+
+		te[ 0 ] = 1 - ( yy + zz );
+		te[ 4 ] = xy - wz;
+		te[ 8 ] = xz + wy;
+
+		te[ 1 ] = xy + wz;
+		te[ 5 ] = 1 - ( xx + zz );
+		te[ 9 ] = yz - wx;
+
+		te[ 2 ] = xz - wy;
+		te[ 6 ] = yz + wx;
+		te[ 10 ] = 1 - ( xx + yy );
+
+		// last column
+		te[ 3 ] = 0;
+		te[ 7 ] = 0;
+		te[ 11 ] = 0;
+
+		// bottom row
+		te[ 12 ] = 0;
+		te[ 13 ] = 0;
+		te[ 14 ] = 0;
+		te[ 15 ] = 1;
+
+		return this;
+
+	},
+
+	lookAt: function () {
+
+		var x, y, z;
+
+		return function ( eye, target, up ) {
+
+			if ( x === undefined ) x = new THREE.Vector3();
+			if ( y === undefined ) y = new THREE.Vector3();
+			if ( z === undefined ) z = new THREE.Vector3();
+
+			var te = this.elements;
+
+			z.subVectors( eye, target ).normalize();
+
+			if ( z.lengthSq() === 0 ) {
+
+				z.z = 1;
+
+			}
+
+			x.crossVectors( up, z ).normalize();
+
+			if ( x.lengthSq() === 0 ) {
+
+				z.x += 0.0001;
+				x.crossVectors( up, z ).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;
+
+	},
+
+	multiplyToArray: function ( a, b, r ) {
+
+		var te = this.elements;
+
+		this.multiplyMatrices( a, b );
+
+		r[ 0 ] = te[ 0 ]; r[ 1 ] = te[ 1 ]; r[ 2 ] = te[ 2 ]; r[ 3 ] = te[ 3 ];
+		r[ 4 ] = te[ 4 ]; r[ 5 ] = te[ 5 ]; r[ 6 ] = te[ 6 ]; r[ 7 ] = te[ 7 ];
+		r[ 8 ]  = te[ 8 ]; r[ 9 ]  = te[ 9 ]; r[ 10 ] = te[ 10 ]; r[ 11 ] = te[ 11 ];
+		r[ 12 ] = te[ 12 ]; r[ 13 ] = te[ 13 ]; r[ 14 ] = te[ 14 ]; r[ 15 ] = te[ 15 ];
+
+		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;
+
+	},
+
+	applyToVector3Array: function () {
+
+		var v1;
+
+		return function ( array, offset, length ) {
+
+			if ( v1 === undefined ) v1 = new THREE.Vector3();
+			if ( offset === undefined ) offset = 0;
+			if ( length === undefined ) length = array.length;
+
+			for ( var i = 0, j = offset; i < length; i += 3, j += 3 ) {
+
+				v1.fromArray( array, j );
+				v1.applyMatrix4( this );
+				v1.toArray( array, j );
+
+			}
+
+			return array;
+
+		};
+
+	}(),
+
+	applyToBuffer: function () {
+
+		var v1;
+
+		return function applyToBuffer( buffer, offset, length ) {
+
+			if ( v1 === undefined ) v1 = new THREE.Vector3();
+			if ( offset === undefined ) offset = 0;
+			if ( length === undefined ) length = buffer.length / buffer.itemSize;
+
+			for ( var i = 0, j = offset; i < length; i ++, j ++ ) {
+
+				v1.x = buffer.getX( j );
+				v1.y = buffer.getY( j );
+				v1.z = buffer.getZ( j );
+
+				v1.applyMatrix4( this );
+
+				buffer.setXYZ( v1.x, v1.y, v1.z );
+
+			}
+
+			return buffer;
+
+		};
+
+	}(),
+
+	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;
+
+	},
+
+	flattenToArrayOffset: function ( array, offset ) {
+
+		console.warn( "THREE.Matrix3: .flattenToArrayOffset is deprecated " +
+				"- just use .toArray instead." );
+
+		return this.toArray( array, offset );
+
+	},
+
+	getPosition: function () {
+
+		var v1;
+
+		return function () {
+
+			if ( v1 === undefined ) v1 = new THREE.Vector3();
+			console.warn( 'THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead.' );
+
+			return v1.setFromMatrixColumn( this, 3 );
+
+		};
+
+	}(),
+
+	setPosition: function ( v ) {
+
+		var te = this.elements;
+
+		te[ 12 ] = v.x;
+		te[ 13 ] = v.y;
+		te[ 14 ] = v.z;
+
+		return this;
+
+	},
+
+	getInverse: function ( m, throwOnDegenerate ) {
+
+		// 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 ) {
+
+			var msg = "THREE.Matrix4.getInverse(): can't invert matrix, determinant is 0";
+
+			if ( throwOnDegenerate || false ) {
+
+				throw new Error( msg );
+
+			} else {
+
+				console.warn( msg );
+
+			}
+
+			return this.identity();
+
+		}
+
+		te[ 0 ] = t11;
+		te[ 1 ] = n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44;
+		te[ 2 ] = n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44;
+		te[ 3 ] = n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43;
+
+		te[ 4 ] = t12;
+		te[ 5 ] = n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44;
+		te[ 6 ] = n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44;
+		te[ 7 ] = n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43;
+
+		te[ 8 ] = t13;
+		te[ 9 ] = n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44;
+		te[ 10 ] = n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44;
+		te[ 11 ] = n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43;
+
+		te[ 12 ] = t14;
+		te[ 13 ] = n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34;
+		te[ 14 ] = n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34;
+		te[ 15 ] = n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33;
+
+		return this.multiplyScalar( 1 / det );
+
+	},
+
+	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;
+
+	},
+
+	compose: function ( position, quaternion, scale ) {
+
+		this.makeRotationFromQuaternion( quaternion );
+		this.scale( scale );
+		this.setPosition( position );
+
+		return this;
+
+	},
+
+	decompose: function () {
+
+		var vector, matrix;
+
+		return function ( position, quaternion, scale ) {
+
+			if ( vector === undefined ) vector = new THREE.Vector3();
+			if ( matrix === undefined ) matrix = new THREE.Matrix4();
+
+			var te = this.elements;
+
+			var sx = vector.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length();
+			var sy = vector.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();
+			var sz = vector.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length();
+
+			// if determine is negative, we need to invert one scale
+			var det = this.determinant();
+			if ( det < 0 ) {
+
+				sx = - sx;
+
+			}
+
+			position.x = te[ 12 ];
+			position.y = te[ 13 ];
+			position.z = te[ 14 ];
+
+			// scale the rotation part
+
+			matrix.elements.set( this.elements ); // at this point matrix is incomplete so we can't use .copy()
+
+			var invSX = 1 / sx;
+			var invSY = 1 / sy;
+			var invSZ = 1 / sz;
+
+			matrix.elements[ 0 ] *= invSX;
+			matrix.elements[ 1 ] *= invSX;
+			matrix.elements[ 2 ] *= invSX;
+
+			matrix.elements[ 4 ] *= invSY;
+			matrix.elements[ 5 ] *= invSY;
+			matrix.elements[ 6 ] *= invSY;
+
+			matrix.elements[ 8 ] *= invSZ;
+			matrix.elements[ 9 ] *= invSZ;
+			matrix.elements[ 10 ] *= invSZ;
+
+			quaternion.setFromRotationMatrix( matrix );
+
+			scale.x = sx;
+			scale.y = sy;
+			scale.z = sz;
+
+			return this;
+
+		};
+
+	}(),
+
+	makeFrustum: function ( left, right, bottom, top, near, far ) {
+
+		var te = this.elements;
+		var x = 2 * near / ( right - left );
+		var y = 2 * near / ( top - bottom );
+
+		var a = ( right + left ) / ( right - left );
+		var b = ( top + bottom ) / ( top - bottom );
+		var c = - ( far + near ) / ( far - near );
+		var d = - 2 * far * near / ( far - near );
+
+		te[ 0 ] = x;	te[ 4 ] = 0;	te[ 8 ] = a;	te[ 12 ] = 0;
+		te[ 1 ] = 0;	te[ 5 ] = y;	te[ 9 ] = b;	te[ 13 ] = 0;
+		te[ 2 ] = 0;	te[ 6 ] = 0;	te[ 10 ] = c;	te[ 14 ] = d;
+		te[ 3 ] = 0;	te[ 7 ] = 0;	te[ 11 ] = - 1;	te[ 15 ] = 0;
+
+		return this;
+
+	},
+
+	makePerspective: function ( fov, aspect, near, far ) {
+
+		var ymax = near * Math.tan( THREE.Math.DEG2RAD * fov * 0.5 );
+		var ymin = - ymax;
+		var xmin = ymin * aspect;
+		var xmax = ymax * aspect;
+
+		return this.makeFrustum( xmin, xmax, ymin, ymax, near, far );
+
+	},
+
+	makeOrthographic: function ( left, right, top, bottom, near, far ) {
+
+		var te = this.elements;
+		var w = 1.0 / ( right - left );
+		var h = 1.0 / ( top - bottom );
+		var p = 1.0 / ( far - near );
+
+		var x = ( right + left ) * w;
+		var y = ( top + bottom ) * h;
+		var z = ( far + near ) * p;
+
+		te[ 0 ] = 2 * w;	te[ 4 ] = 0;	te[ 8 ] = 0;	te[ 12 ] = - x;
+		te[ 1 ] = 0;	te[ 5 ] = 2 * h;	te[ 9 ] = 0;	te[ 13 ] = - y;
+		te[ 2 ] = 0;	te[ 6 ] = 0;	te[ 10 ] = - 2 * p;	te[ 14 ] = - z;
+		te[ 3 ] = 0;	te[ 7 ] = 0;	te[ 11 ] = 0;	te[ 15 ] = 1;
+
+		return this;
+
+	},
+
+	equals: function ( matrix ) {
+
+		var te = this.elements;
+		var me = matrix.elements;
+
+		for ( var i = 0; i < 16; i ++ ) {
+
+			if ( te[ i ] !== me[ i ] ) return false;
+
+		}
+
+		return true;
+
+	},
+
+	fromArray: function ( array ) {
+
+		this.elements.set( array );
+
+		return this;
+
+	},
+
+	toArray: function ( array, offset ) {
+
+		if ( array === undefined ) array = [];
+		if ( offset === undefined ) offset = 0;
+
+		var te = this.elements;
+
+		array[ offset ] = te[ 0 ];
+		array[ offset + 1 ] = te[ 1 ];
+		array[ offset + 2 ] = te[ 2 ];
+		array[ offset + 3 ] = te[ 3 ];
+
+		array[ offset + 4 ] = te[ 4 ];
+		array[ offset + 5 ] = te[ 5 ];
+		array[ offset + 6 ] = te[ 6 ];
+		array[ offset + 7 ] = te[ 7 ];
+
+		array[ offset + 8 ]  = te[ 8 ];
+		array[ offset + 9 ]  = te[ 9 ];
+		array[ offset + 10 ] = te[ 10 ];
+		array[ offset + 11 ] = te[ 11 ];
+
+		array[ offset + 12 ] = te[ 12 ];
+		array[ offset + 13 ] = te[ 13 ];
+		array[ offset + 14 ] = te[ 14 ];
+		array[ offset + 15 ] = te[ 15 ];
+
+		return array;
+
+	}
+
+};
+
+// File:src/math/Ray.js
+
+/**
+ * @author bhouston / http://clara.io
+ */
+
+THREE.Ray = function ( origin, direction ) {
+
+	this.origin = ( origin !== undefined ) ? origin : new THREE.Vector3();
+	this.direction = ( direction !== undefined ) ? direction : new THREE.Vector3();
+
+};
+
+THREE.Ray.prototype = {
+
+	constructor: THREE.Ray,
+
+	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, optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector3();
+
+		return result.copy( this.direction ).multiplyScalar( t ).add( this.origin );
+
+	},
+
+	lookAt: function ( v ) {
+
+		this.direction.copy( v ).sub( this.origin ).normalize();
+
+	},
+
+	recast: function () {
+
+		var v1 = new THREE.Vector3();
+
+		return function ( t ) {
+
+			this.origin.copy( this.at( t, v1 ) );
+
+			return this;
+
+		};
+
+	}(),
+
+	closestPointToPoint: function ( point, optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector3();
+		result.subVectors( point, this.origin );
+		var directionDistance = result.dot( this.direction );
+
+		if ( directionDistance < 0 ) {
+
+			return result.copy( this.origin );
+
+		}
+
+		return result.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin );
+
+	},
+
+	distanceToPoint: function ( point ) {
+
+		return Math.sqrt( this.distanceSqToPoint( point ) );
+
+	},
+
+	distanceSqToPoint: function () {
+
+		var v1 = new THREE.Vector3();
+
+		return function ( point ) {
+
+			var directionDistance = v1.subVectors( point, this.origin ).dot( this.direction );
+
+			// point behind the ray
+
+			if ( directionDistance < 0 ) {
+
+				return this.origin.distanceToSquared( point );
+
+			}
+
+			v1.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin );
+
+			return v1.distanceToSquared( point );
+
+		};
+
+	}(),
+
+	distanceSqToSegment: function () {
+
+		var segCenter = new THREE.Vector3();
+		var segDir = new THREE.Vector3();
+		var diff = new THREE.Vector3();
+
+		return function ( v0, v1, optionalPointOnRay, optionalPointOnSegment ) {
+
+			// from http://www.geometrictools.com/LibMathematics/Distance/Wm5DistRay3Segment3.cpp
+			// It returns the min distance between the ray and the segment
+			// defined by v0 and v1
+			// It can also set two optional targets :
+			// - The closest point on the ray
+			// - The closest point on the segment
+
+			segCenter.copy( v0 ).add( v1 ).multiplyScalar( 0.5 );
+			segDir.copy( v1 ).sub( v0 ).normalize();
+			diff.copy( this.origin ).sub( segCenter );
+
+			var segExtent = v0.distanceTo( v1 ) * 0.5;
+			var a01 = - this.direction.dot( segDir );
+			var b0 = diff.dot( this.direction );
+			var b1 = - diff.dot( segDir );
+			var c = diff.lengthSq();
+			var det = Math.abs( 1 - a01 * a01 );
+			var s0, s1, sqrDist, extDet;
+
+			if ( det > 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 <= extDet ) {
+
+							// region 0
+							// Minimum at interior points of ray and segment.
+
+							var invDet = 1 / det;
+							s0 *= invDet;
+							s1 *= invDet;
+							sqrDist = s0 * ( s0 + a01 * s1 + 2 * b0 ) + s1 * ( a01 * s0 + s1 + 2 * b1 ) + c;
+
+						} else {
+
+							// region 1
+
+							s1 = segExtent;
+							s0 = Math.max( 0, - ( a01 * s1 + b0 ) );
+							sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
+
+						}
+
+					} else {
+
+						// region 5
+
+						s1 = - segExtent;
+						s0 = Math.max( 0, - ( a01 * s1 + b0 ) );
+						sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
+
+					}
+
+				} else {
+
+					if ( s1 <= - extDet ) {
+
+						// region 4
+
+						s0 = Math.max( 0, - ( - a01 * segExtent + b0 ) );
+						s1 = ( s0 > 0 ) ? - segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );
+						sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
+
+					} else if ( s1 <= extDet ) {
+
+						// region 3
+
+						s0 = 0;
+						s1 = Math.min( Math.max( - segExtent, - b1 ), segExtent );
+						sqrDist = s1 * ( s1 + 2 * b1 ) + c;
+
+					} else {
+
+						// region 2
+
+						s0 = Math.max( 0, - ( a01 * segExtent + b0 ) );
+						s1 = ( s0 > 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 () {
+
+		var v1 = new THREE.Vector3();
+
+		return function ( sphere, optionalTarget ) {
+
+			v1.subVectors( sphere.center, this.origin );
+			var tca = v1.dot( this.direction );
+			var d2 = v1.dot( v1 ) - 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 && t1 < 0 ) return null;
+
+			// test to see if t0 is behind the ray:
+			// if it is, the ray is inside the sphere, so return the second exit point scaled by t1,
+			// in order to always return an intersect point that is in front of the ray.
+			if ( t0 < 0 ) return this.at( t1, optionalTarget );
+
+			// else t0 is in front of the ray, so return the first collision point scaled by t0
+			return this.at( t0, optionalTarget );
+
+		};
+
+	}(),
+
+	intersectsSphere: function ( sphere ) {
+
+		return this.distanceToPoint( sphere.center ) <= sphere.radius;
+
+	},
+
+	distanceToPlane: function ( plane ) {
+
+		var denominator = plane.normal.dot( this.direction );
+
+		if ( denominator === 0 ) {
+
+			// line is coplanar, return origin
+			if ( plane.distanceToPoint( this.origin ) === 0 ) {
+
+				return 0;
+
+			}
+
+			// Null is preferable to undefined since undefined means.... it is undefined
+
+			return null;
+
+		}
+
+		var t = - ( this.origin.dot( plane.normal ) + plane.constant ) / denominator;
+
+		// Return if the ray never intersects the plane
+
+		return t >= 0 ? t :  null;
+
+	},
+
+	intersectPlane: function ( plane, optionalTarget ) {
+
+		var t = this.distanceToPlane( plane );
+
+		if ( t === null ) {
+
+			return null;
+
+		}
+
+		return this.at( t, optionalTarget );
+
+	},
+
+
+
+	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 ) {
+
+			return true;
+
+		}
+
+		// ray origin is behind the plane (and is pointing behind it)
+
+		return false;
+
+	},
+
+	intersectBox: function ( box, optionalTarget ) {
+
+		var tmin, tmax, tymin, tymax, tzmin, tzmax;
+
+		var invdirx = 1 / this.direction.x,
+			invdiry = 1 / this.direction.y,
+			invdirz = 1 / this.direction.z;
+
+		var origin = this.origin;
+
+		if ( invdirx >= 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 < tmax || tmax !== tmax ) tmax = tymax;
+
+		if ( invdirz >= 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 < tmax || tmax !== tmax ) tmax = tzmax;
+
+		//return point closest to the ray (positive side)
+
+		if ( tmax < 0 ) return null;
+
+		return this.at( tmin >= 0 ? tmin : tmax, optionalTarget );
+
+	},
+
+	intersectsBox: ( function () {
+
+		var v = new THREE.Vector3();
+
+		return function ( box ) {
+
+			return this.intersectBox( box, v ) !== null;
+
+		};
+
+	} )(),
+
+	intersectTriangle: function () {
+
+		// Compute the offset origin, edges, and normal.
+		var diff = new THREE.Vector3();
+		var edge1 = new THREE.Vector3();
+		var edge2 = new THREE.Vector3();
+		var normal = new THREE.Vector3();
+
+		return function ( a, b, c, backfaceCulling, optionalTarget ) {
+
+			// from http://www.geometrictools.com/LibMathematics/Intersection/Wm5IntrRay3Triangle3.cpp
+
+			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 < 0 ) {
+
+				sign = - 1;
+				DdN = - DdN;
+
+			} else {
+
+				return null;
+
+			}
+
+			diff.subVectors( this.origin, a );
+			var DdQxE2 = sign * this.direction.dot( edge2.crossVectors( diff, edge2 ) );
+
+			// b1 < 0, no intersection
+			if ( DdQxE2 < 0 ) {
+
+				return null;
+
+			}
+
+			var DdE1xQ = sign * this.direction.dot( edge1.cross( diff ) );
+
+			// b2 < 0, no intersection
+			if ( DdE1xQ < 0 ) {
+
+				return null;
+
+			}
+
+			// b1+b2 > 1, no intersection
+			if ( DdQxE2 + DdE1xQ > DdN ) {
+
+				return null;
+
+			}
+
+			// Line intersects triangle, check if ray does.
+			var QdN = - sign * diff.dot( normal );
+
+			// t < 0, no intersection
+			if ( QdN < 0 ) {
+
+				return null;
+
+			}
+
+			// Ray intersects triangle.
+			return this.at( QdN / DdN, optionalTarget );
+
+		};
+
+	}(),
+
+	applyMatrix4: function ( matrix4 ) {
+
+		this.direction.add( this.origin ).applyMatrix4( matrix4 );
+		this.origin.applyMatrix4( matrix4 );
+		this.direction.sub( this.origin );
+		this.direction.normalize();
+
+		return this;
+
+	},
+
+	equals: function ( ray ) {
+
+		return ray.origin.equals( this.origin ) && ray.direction.equals( this.direction );
+
+	}
+
+};
+
+// File:src/math/Sphere.js
+
+/**
+ * @author bhouston / http://clara.io
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.Sphere = function ( center, radius ) {
+
+	this.center = ( center !== undefined ) ? center : new THREE.Vector3();
+	this.radius = ( radius !== undefined ) ? radius : 0;
+
+};
+
+THREE.Sphere.prototype = {
+
+	constructor: THREE.Sphere,
+
+	set: function ( center, radius ) {
+
+		this.center.copy( center );
+		this.radius = radius;
+
+		return this;
+
+	},
+
+	setFromPoints: function () {
+
+		var box = new THREE.Box3();
+
+		return function ( points, optionalCenter ) {
+
+			var center = this.center;
+
+			if ( optionalCenter !== undefined ) {
+
+				center.copy( optionalCenter );
+
+			} else {
+
+				box.setFromPoints( points ).center( center );
+
+			}
+
+			var maxRadiusSq = 0;
+
+			for ( var i = 0, il = points.length; i < il; i ++ ) {
+
+				maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( points[ i ] ) );
+
+			}
+
+			this.radius = Math.sqrt( maxRadiusSq );
+
+			return this;
+
+		};
+
+	}(),
+
+	clone: function () {
+
+		return new this.constructor().copy( this );
+
+	},
+
+	copy: function ( sphere ) {
+
+		this.center.copy( sphere.center );
+		this.radius = sphere.radius;
+
+		return this;
+
+	},
+
+	empty: function () {
+
+		return ( this.radius <= 0 );
+
+	},
+
+	containsPoint: function ( point ) {
+
+		return ( point.distanceToSquared( this.center ) <= ( this.radius * this.radius ) );
+
+	},
+
+	distanceToPoint: function ( point ) {
+
+		return ( point.distanceTo( this.center ) - this.radius );
+
+	},
+
+	intersectsSphere: function ( sphere ) {
+
+		var radiusSum = this.radius + sphere.radius;
+
+		return sphere.center.distanceToSquared( this.center ) <= ( radiusSum * radiusSum );
+
+	},
+
+	intersectsBox: function ( box ) {
+
+		return box.intersectsSphere( this );
+
+	},
+
+	intersectsPlane: function ( plane ) {
+
+		// We use the following equation to compute the signed distance from
+		// the center of the sphere to the plane.
+		//
+		// distance = q * n - d
+		//
+		// If this distance is greater than the radius of the sphere,
+		// then there is no intersection.
+
+		return Math.abs( this.center.dot( plane.normal ) - plane.constant ) <= this.radius;
+
+	},
+
+	clampPoint: function ( point, optionalTarget ) {
+
+		var deltaLengthSq = this.center.distanceToSquared( point );
+
+		var result = optionalTarget || new THREE.Vector3();
+
+		result.copy( point );
+
+		if ( deltaLengthSq > ( this.radius * this.radius ) ) {
+
+			result.sub( this.center ).normalize();
+			result.multiplyScalar( this.radius ).add( this.center );
+
+		}
+
+		return result;
+
+	},
+
+	getBoundingBox: function ( optionalTarget ) {
+
+		var box = optionalTarget || new THREE.Box3();
+
+		box.set( this.center, this.center );
+		box.expandByScalar( this.radius );
+
+		return box;
+
+	},
+
+	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 );
+
+	}
+
+};
+
+// File:src/math/Frustum.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ * @author bhouston / http://clara.io
+ */
+
+THREE.Frustum = function ( p0, p1, p2, p3, p4, p5 ) {
+
+	this.planes = [
+
+		( p0 !== undefined ) ? p0 : new THREE.Plane(),
+		( p1 !== undefined ) ? p1 : new THREE.Plane(),
+		( p2 !== undefined ) ? p2 : new THREE.Plane(),
+		( p3 !== undefined ) ? p3 : new THREE.Plane(),
+		( p4 !== undefined ) ? p4 : new THREE.Plane(),
+		( p5 !== undefined ) ? p5 : new THREE.Plane()
+
+	];
+
+};
+
+THREE.Frustum.prototype = {
+
+	constructor: THREE.Frustum,
+
+	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 < 6; i ++ ) {
+
+			planes[ i ].copy( frustum.planes[ i ] );
+
+		}
+
+		return this;
+
+	},
+
+	setFromMatrix: function ( m ) {
+
+		var planes = this.planes;
+		var me = m.elements;
+		var me0 = me[ 0 ], me1 = me[ 1 ], me2 = me[ 2 ], me3 = me[ 3 ];
+		var me4 = me[ 4 ], me5 = me[ 5 ], me6 = me[ 6 ], me7 = me[ 7 ];
+		var me8 = me[ 8 ], me9 = me[ 9 ], me10 = me[ 10 ], me11 = me[ 11 ];
+		var me12 = me[ 12 ], me13 = me[ 13 ], me14 = me[ 14 ], me15 = me[ 15 ];
+
+		planes[ 0 ].setComponents( me3 - me0, me7 - me4, me11 - me8, me15 - me12 ).normalize();
+		planes[ 1 ].setComponents( me3 + me0, me7 + me4, me11 + me8, me15 + me12 ).normalize();
+		planes[ 2 ].setComponents( me3 + me1, me7 + me5, me11 + me9, me15 + me13 ).normalize();
+		planes[ 3 ].setComponents( me3 - me1, me7 - me5, me11 - me9, me15 - me13 ).normalize();
+		planes[ 4 ].setComponents( me3 - me2, me7 - me6, me11 - me10, me15 - me14 ).normalize();
+		planes[ 5 ].setComponents( me3 + me2, me7 + me6, me11 + me10, me15 + me14 ).normalize();
+
+		return this;
+
+	},
+
+	intersectsObject: function () {
+
+		var sphere = new THREE.Sphere();
+
+		return function ( object ) {
+
+			var geometry = object.geometry;
+
+			if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();
+
+			sphere.copy( geometry.boundingSphere );
+			sphere.applyMatrix4( object.matrixWorld );
+
+			return this.intersectsSphere( sphere );
+
+		};
+
+	}(),
+
+	intersectsSphere: function ( sphere ) {
+
+		var planes = this.planes;
+		var center = sphere.center;
+		var negRadius = - sphere.radius;
+
+		for ( var i = 0; i < 6; i ++ ) {
+
+			var distance = planes[ i ].distanceToPoint( center );
+
+			if ( distance < negRadius ) {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	},
+
+	intersectsBox: function () {
+
+		var p1 = new THREE.Vector3(),
+			p2 = new THREE.Vector3();
+
+		return function ( box ) {
+
+			var planes = this.planes;
+
+			for ( var i = 0; i < 6 ; i ++ ) {
+
+				var plane = planes[ i ];
+
+				p1.x = plane.normal.x > 0 ? box.min.x : box.max.x;
+				p2.x = plane.normal.x > 0 ? box.max.x : box.min.x;
+				p1.y = plane.normal.y > 0 ? box.min.y : box.max.y;
+				p2.y = plane.normal.y > 0 ? box.max.y : box.min.y;
+				p1.z = plane.normal.z > 0 ? box.min.z : box.max.z;
+				p2.z = plane.normal.z > 0 ? box.max.z : box.min.z;
+
+				var d1 = plane.distanceToPoint( p1 );
+				var d2 = plane.distanceToPoint( p2 );
+
+				// if both outside plane, no intersection
+
+				if ( d1 < 0 && d2 < 0 ) {
+
+					return false;
+
+				}
+
+			}
+
+			return true;
+
+		};
+
+	}(),
+
+
+	containsPoint: function ( point ) {
+
+		var planes = this.planes;
+
+		for ( var i = 0; i < 6; i ++ ) {
+
+			if ( planes[ i ].distanceToPoint( point ) < 0 ) {
+
+				return false;
+
+			}
+
+		}
+
+		return true;
+
+	}
+
+};
+
+// File:src/math/Plane.js
+
+/**
+ * @author bhouston / http://clara.io
+ */
+
+THREE.Plane = function ( normal, constant ) {
+
+	this.normal = ( normal !== undefined ) ? normal : new THREE.Vector3( 1, 0, 0 );
+	this.constant = ( constant !== undefined ) ? constant : 0;
+
+};
+
+THREE.Plane.prototype = {
+
+	constructor: THREE.Plane,
+
+	set: function ( normal, constant ) {
+
+		this.normal.copy( normal );
+		this.constant = constant;
+
+		return this;
+
+	},
+
+	setComponents: function ( x, y, z, w ) {
+
+		this.normal.set( x, y, z );
+		this.constant = w;
+
+		return this;
+
+	},
+
+	setFromNormalAndCoplanarPoint: function ( normal, point ) {
+
+		this.normal.copy( normal );
+		this.constant = - point.dot( this.normal );	// must be this.normal, not normal, as this.normal is normalized
+
+		return this;
+
+	},
+
+	setFromCoplanarPoints: function () {
+
+		var v1 = new THREE.Vector3();
+		var v2 = new THREE.Vector3();
+
+		return function ( a, b, c ) {
+
+			var normal = v1.subVectors( c, b ).cross( v2.subVectors( a, b ) ).normalize();
+
+			// Q: should an error be thrown if normal is zero (e.g. degenerate plane)?
+
+			this.setFromNormalAndCoplanarPoint( normal, a );
+
+			return this;
+
+		};
+
+	}(),
+
+	clone: function () {
+
+		return new this.constructor().copy( this );
+
+	},
+
+	copy: function ( plane ) {
+
+		this.normal.copy( plane.normal );
+		this.constant = plane.constant;
+
+		return this;
+
+	},
+
+	normalize: function () {
+
+		// Note: will lead to a divide by zero if the plane is invalid.
+
+		var inverseNormalLength = 1.0 / this.normal.length();
+		this.normal.multiplyScalar( inverseNormalLength );
+		this.constant *= inverseNormalLength;
+
+		return this;
+
+	},
+
+	negate: function () {
+
+		this.constant *= - 1;
+		this.normal.negate();
+
+		return this;
+
+	},
+
+	distanceToPoint: function ( point ) {
+
+		return this.normal.dot( point ) + this.constant;
+
+	},
+
+	distanceToSphere: function ( sphere ) {
+
+		return this.distanceToPoint( sphere.center ) - sphere.radius;
+
+	},
+
+	projectPoint: function ( point, optionalTarget ) {
+
+		return this.orthoPoint( point, optionalTarget ).sub( point ).negate();
+
+	},
+
+	orthoPoint: function ( point, optionalTarget ) {
+
+		var perpendicularMagnitude = this.distanceToPoint( point );
+
+		var result = optionalTarget || new THREE.Vector3();
+		return result.copy( this.normal ).multiplyScalar( perpendicularMagnitude );
+
+	},
+
+	intersectLine: function () {
+
+		var v1 = new THREE.Vector3();
+
+		return function ( line, optionalTarget ) {
+
+			var result = optionalTarget || new THREE.Vector3();
+
+			var direction = line.delta( v1 );
+
+			var denominator = this.normal.dot( direction );
+
+			if ( denominator === 0 ) {
+
+				// line is coplanar, return origin
+				if ( this.distanceToPoint( line.start ) === 0 ) {
+
+					return result.copy( line.start );
+
+				}
+
+				// Unsure if this is the correct method to handle this case.
+				return undefined;
+
+			}
+
+			var t = - ( line.start.dot( this.normal ) + this.constant ) / denominator;
+
+			if ( t < 0 || t > 1 ) {
+
+				return undefined;
+
+			}
+
+			return result.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 ) || ( endSign < 0 && startSign > 0 );
+
+	},
+
+	intersectsBox: function ( box ) {
+
+		return box.intersectsPlane( this );
+
+	},
+
+	intersectsSphere: function ( sphere ) {
+
+		return sphere.intersectsPlane( this );
+
+	},
+
+	coplanarPoint: function ( optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector3();
+		return result.copy( this.normal ).multiplyScalar( - this.constant );
+
+	},
+
+	applyMatrix4: function () {
+
+		var v1 = new THREE.Vector3();
+		var m1 = new THREE.Matrix3();
+
+		return function ( matrix, optionalNormalMatrix ) {
+
+			var referencePoint = this.coplanarPoint( v1 ).applyMatrix4( matrix );
+
+			// transform normal based on theory here:
+			// http://www.songho.ca/opengl/gl_normaltransform.html
+			var normalMatrix = optionalNormalMatrix || m1.getNormalMatrix( matrix );
+			var normal = this.normal.applyMatrix3( normalMatrix ).normalize();
+
+			// recalculate constant (like in setFromNormalAndCoplanarPoint)
+			this.constant = - referencePoint.dot( normal );
+
+			return this;
+
+		};
+
+	}(),
+
+	translate: function ( offset ) {
+
+		this.constant = this.constant - offset.dot( this.normal );
+
+		return this;
+
+	},
+
+	equals: function ( plane ) {
+
+		return plane.normal.equals( this.normal ) && ( plane.constant === this.constant );
+
+	}
+
+};
+
+// File:src/math/Spherical.js
+
+/**
+ * @author bhouston / http://clara.io
+ * @author WestLangley / http://github.com/WestLangley
+ *
+ * Ref: https://en.wikipedia.org/wiki/Spherical_coordinate_system
+ *
+ * The poles (phi) are at the positive and negative y axis.
+ * The equator starts at positive z.
+ */
+
+THREE.Spherical = function ( radius, phi, theta ) {
+
+	this.radius = ( radius !== undefined ) ? radius : 1.0;
+	this.phi = ( phi !== undefined ) ? phi : 0; // up / down towards top and bottom pole
+	this.theta = ( theta !== undefined ) ? theta : 0; // around the equator of the sphere
+
+	return this;
+
+};
+
+THREE.Spherical.prototype = {
+
+	constructor: THREE.Spherical,
+
+	set: function ( radius, phi, theta ) {
+
+		this.radius = radius;
+		this.phi = phi;
+		this.theta = theta;
+
+	},
+
+	clone: function () {
+
+		return new this.constructor().copy( this );
+
+	},
+
+	copy: function ( other ) {
+
+		this.radius.copy( other.radius );
+		this.phi.copy( other.phi );
+		this.theta.copy( other.theta );
+
+		return this;
+
+	},
+
+	// restrict phi to be betwee EPS and PI-EPS
+	makeSafe: function() {
+
+		var EPS = 0.000001;
+		this.phi = Math.max( EPS, Math.min( Math.PI - EPS, this.phi ) );
+
+	},
+
+	setFromVector3: function( vec3 ) {
+
+		this.radius = vec3.length();
+
+		if ( this.radius === 0 ) {
+
+			this.theta = 0;
+			this.phi = 0;
+
+		} else {
+
+			this.theta = Math.atan2( vec3.x, vec3.z ); // equator angle around y-up axis
+			this.phi = Math.acos( THREE.Math.clamp( vec3.y / this.radius, - 1, 1 ) ); // polar angle
+
+		}
+
+		return this;
+
+	},
+
+};
+
+// File:src/math/Math.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.Math = {
+
+	DEG2RAD: Math.PI / 180,
+	RAD2DEG: 180 / Math.PI,
+
+	generateUUID: function () {
+
+		// http://www.broofa.com/Tools/Math.uuid.htm
+
+		var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split( '' );
+		var uuid = new Array( 36 );
+		var rnd = 0, r;
+
+		return function () {
+
+			for ( var i = 0; i < 36; i ++ ) {
+
+				if ( i === 8 || i === 13 || i === 18 || i === 23 ) {
+
+					uuid[ i ] = '-';
+
+				} else if ( i === 14 ) {
+
+					uuid[ i ] = '4';
+
+				} else {
+
+					if ( rnd <= 0x02 ) rnd = 0x2000000 + ( Math.random() * 0x1000000 ) | 0;
+					r = rnd & 0xf;
+					rnd = rnd >> 4;
+					uuid[ i ] = chars[ ( i === 19 ) ? ( r & 0x3 ) | 0x8 : r ];
+
+				}
+
+			}
+
+			return uuid.join( '' );
+
+		};
+
+	}(),
+
+	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 <a1, a2> to range <b1, b2>
+
+	mapLinear: function ( x, a1, a2, b1, b2 ) {
+
+		return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );
+
+	},
+
+	// http://en.wikipedia.org/wiki/Smoothstep
+
+	smoothstep: function ( x, min, max ) {
+
+		if ( x <= min ) return 0;
+		if ( x >= max ) return 1;
+
+		x = ( x - min ) / ( max - min );
+
+		return x * x * ( 3 - 2 * x );
+
+	},
+
+	smootherstep: function ( x, min, max ) {
+
+		if ( x <= min ) return 0;
+		if ( x >= max ) return 1;
+
+		x = ( x - min ) / ( max - min );
+
+		return x * x * x * ( x * ( x * 6 - 15 ) + 10 );
+
+	},
+
+	random16: function () {
+
+		console.warn( 'THREE.Math.random16() has been deprecated. Use Math.random() instead.' );
+		return Math.random();
+
+	},
+
+	// Random integer from <low, high> interval
+
+	randInt: function ( low, high ) {
+
+		return low + Math.floor( Math.random() * ( high - low + 1 ) );
+
+	},
+
+	// Random float from <low, high> interval
+
+	randFloat: function ( low, high ) {
+
+		return low + Math.random() * ( high - low );
+
+	},
+
+	// Random float from <-range/2, range/2> interval
+
+	randFloatSpread: function ( range ) {
+
+		return range * ( 0.5 - Math.random() );
+
+	},
+
+	degToRad: function ( degrees ) {
+
+		return degrees * THREE.Math.DEG2RAD;
+
+	},
+
+	radToDeg: function ( radians ) {
+
+		return radians * THREE.Math.RAD2DEG;
+
+	},
+
+	isPowerOfTwo: function ( value ) {
+
+		return ( value & ( value - 1 ) ) === 0 && value !== 0;
+
+	},
+
+	nearestPowerOfTwo: function ( value ) {
+
+		return Math.pow( 2, Math.round( Math.log( value ) / Math.LN2 ) );
+
+	},
+
+	nextPowerOfTwo: function ( value ) {
+
+		value --;
+		value |= value >> 1;
+		value |= value >> 2;
+		value |= value >> 4;
+		value |= value >> 8;
+		value |= value >> 16;
+		value ++;
+
+		return value;
+
+	}
+
+};
+
+// File:src/math/Spline.js
+
+/**
+ * Spline from Tween.js, slightly optimized (and trashed)
+ * http://sole.github.com/tween.js/examples/05_spline.html
+ *
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.Spline = function ( points ) {
+
+	this.points = points;
+
+	var c = [], v3 = { x: 0, y: 0, z: 0 },
+	point, intPoint, weight, w2, w3,
+	pa, pb, pc, pd;
+
+	this.initFromArray = function ( a ) {
+
+		this.points = [];
+
+		for ( var i = 0; i < a.length; i ++ ) {
+
+			this.points[ i ] = { x: a[ i ][ 0 ], y: a[ i ][ 1 ], z: a[ i ][ 2 ] };
+
+		}
+
+	};
+
+	this.getPoint = function ( k ) {
+
+		point = ( this.points.length - 1 ) * k;
+		intPoint = Math.floor( point );
+		weight = point - intPoint;
+
+		c[ 0 ] = intPoint === 0 ? intPoint : intPoint - 1;
+		c[ 1 ] = intPoint;
+		c[ 2 ] = intPoint  > this.points.length - 2 ? this.points.length - 1 : intPoint + 1;
+		c[ 3 ] = intPoint  > this.points.length - 3 ? this.points.length - 1 : intPoint + 2;
+
+		pa = this.points[ c[ 0 ] ];
+		pb = this.points[ c[ 1 ] ];
+		pc = this.points[ c[ 2 ] ];
+		pd = this.points[ c[ 3 ] ];
+
+		w2 = weight * weight;
+		w3 = weight * w2;
+
+		v3.x = interpolate( pa.x, pb.x, pc.x, pd.x, weight, w2, w3 );
+		v3.y = interpolate( pa.y, pb.y, pc.y, pd.y, weight, w2, w3 );
+		v3.z = interpolate( pa.z, pb.z, pc.z, pd.z, weight, w2, w3 );
+
+		return v3;
+
+	};
+
+	this.getControlPointsArray = function () {
+
+		var i, p, l = this.points.length,
+			coords = [];
+
+		for ( i = 0; i < l; i ++ ) {
+
+			p = this.points[ i ];
+			coords[ i ] = [ p.x, p.y, p.z ];
+
+		}
+
+		return coords;
+
+	};
+
+	// approximate length by summing linear segments
+
+	this.getLength = function ( nSubDivisions ) {
+
+		var i, index, nSamples, position,
+			point = 0, intPoint = 0, oldIntPoint = 0,
+			oldPosition = new THREE.Vector3(),
+			tmpVec = new THREE.Vector3(),
+			chunkLengths = [],
+			totalLength = 0;
+
+		// first point has 0 length
+
+		chunkLengths[ 0 ] = 0;
+
+		if ( ! nSubDivisions ) nSubDivisions = 100;
+
+		nSamples = this.points.length * nSubDivisions;
+
+		oldPosition.copy( this.points[ 0 ] );
+
+		for ( i = 1; i < nSamples; i ++ ) {
+
+			index = i / nSamples;
+
+			position = this.getPoint( index );
+			tmpVec.copy( position );
+
+			totalLength += tmpVec.distanceTo( oldPosition );
+
+			oldPosition.copy( position );
+
+			point = ( this.points.length - 1 ) * index;
+			intPoint = Math.floor( point );
+
+			if ( intPoint !== oldIntPoint ) {
+
+				chunkLengths[ intPoint ] = totalLength;
+				oldIntPoint = intPoint;
+
+			}
+
+		}
+
+		// last point ends with total length
+
+		chunkLengths[ chunkLengths.length ] = totalLength;
+
+		return { chunks: chunkLengths, total: totalLength };
+
+	};
+
+	this.reparametrizeByArcLength = function ( samplingCoef ) {
+
+		var i, j,
+			index, indexCurrent, indexNext,
+			realDistance,
+			sampling, position,
+			newpoints = [],
+			tmpVec = new THREE.Vector3(),
+			sl = this.getLength();
+
+		newpoints.push( tmpVec.copy( this.points[ 0 ] ).clone() );
+
+		for ( i = 1; i < this.points.length; i ++ ) {
+
+			//tmpVec.copy( this.points[ i - 1 ] );
+			//linearDistance = tmpVec.distanceTo( this.points[ i ] );
+
+			realDistance = sl.chunks[ i ] - sl.chunks[ i - 1 ];
+
+			sampling = Math.ceil( samplingCoef * realDistance / sl.total );
+
+			indexCurrent = ( i - 1 ) / ( this.points.length - 1 );
+			indexNext = i / ( this.points.length - 1 );
+
+			for ( j = 1; j < sampling - 1; j ++ ) {
+
+				index = indexCurrent + j * ( 1 / sampling ) * ( indexNext - indexCurrent );
+
+				position = this.getPoint( index );
+				newpoints.push( tmpVec.copy( position ).clone() );
+
+			}
+
+			newpoints.push( tmpVec.copy( this.points[ i ] ).clone() );
+
+		}
+
+		this.points = newpoints;
+
+	};
+
+	// Catmull-Rom
+
+	function interpolate( p0, p1, p2, p3, t, t2, t3 ) {
+
+		var v0 = ( p2 - p0 ) * 0.5,
+			v1 = ( p3 - p1 ) * 0.5;
+
+		return ( 2 * ( p1 - p2 ) + v0 + v1 ) * t3 + ( - 3 * ( p1 - p2 ) - 2 * v0 - v1 ) * t2 + v0 * t + p1;
+
+	}
+
+};
+
+// File:src/math/Triangle.js
+
+/**
+ * @author bhouston / http://clara.io
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.Triangle = function ( a, b, c ) {
+
+	this.a = ( a !== undefined ) ? a : new THREE.Vector3();
+	this.b = ( b !== undefined ) ? b : new THREE.Vector3();
+	this.c = ( c !== undefined ) ? c : new THREE.Vector3();
+
+};
+
+THREE.Triangle.normal = function () {
+
+	var v0 = new THREE.Vector3();
+
+	return function ( a, b, c, optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector3();
+
+		result.subVectors( c, b );
+		v0.subVectors( a, b );
+		result.cross( v0 );
+
+		var resultLengthSq = result.lengthSq();
+		if ( resultLengthSq > 0 ) {
+
+			return result.multiplyScalar( 1 / Math.sqrt( resultLengthSq ) );
+
+		}
+
+		return result.set( 0, 0, 0 );
+
+	};
+
+}();
+
+// static/instance method to calculate barycentric coordinates
+// based on: http://www.blackpawn.com/texts/pointinpoly/default.html
+THREE.Triangle.barycoordFromPoint = function () {
+
+	var v0 = new THREE.Vector3();
+	var v1 = new THREE.Vector3();
+	var v2 = new THREE.Vector3();
+
+	return function ( point, a, b, c, optionalTarget ) {
+
+		v0.subVectors( c, a );
+		v1.subVectors( b, a );
+		v2.subVectors( point, a );
+
+		var dot00 = v0.dot( v0 );
+		var dot01 = v0.dot( v1 );
+		var dot02 = v0.dot( v2 );
+		var dot11 = v1.dot( v1 );
+		var dot12 = v1.dot( v2 );
+
+		var denom = ( dot00 * dot11 - dot01 * dot01 );
+
+		var result = optionalTarget || new THREE.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 result.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 result.set( 1 - u - v, v, u );
+
+	};
+
+}();
+
+THREE.Triangle.containsPoint = function () {
+
+	var v1 = new THREE.Vector3();
+
+	return function ( point, a, b, c ) {
+
+		var result = THREE.Triangle.barycoordFromPoint( point, a, b, c, v1 );
+
+		return ( result.x >= 0 ) && ( result.y >= 0 ) && ( ( result.x + result.y ) <= 1 );
+
+	};
+
+}();
+
+THREE.Triangle.prototype = {
+
+	constructor: THREE.Triangle,
+
+	set: function ( a, b, c ) {
+
+		this.a.copy( a );
+		this.b.copy( b );
+		this.c.copy( c );
+
+		return this;
+
+	},
+
+	setFromPointsAndIndices: function ( points, i0, i1, i2 ) {
+
+		this.a.copy( points[ i0 ] );
+		this.b.copy( points[ i1 ] );
+		this.c.copy( points[ i2 ] );
+
+		return this;
+
+	},
+
+	clone: function () {
+
+		return new this.constructor().copy( this );
+
+	},
+
+	copy: function ( triangle ) {
+
+		this.a.copy( triangle.a );
+		this.b.copy( triangle.b );
+		this.c.copy( triangle.c );
+
+		return this;
+
+	},
+
+	area: function () {
+
+		var v0 = new THREE.Vector3();
+		var v1 = new THREE.Vector3();
+
+		return function () {
+
+			v0.subVectors( this.c, this.b );
+			v1.subVectors( this.a, this.b );
+
+			return v0.cross( v1 ).length() * 0.5;
+
+		};
+
+	}(),
+
+	midpoint: function ( optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector3();
+		return result.addVectors( this.a, this.b ).add( this.c ).multiplyScalar( 1 / 3 );
+
+	},
+
+	normal: function ( optionalTarget ) {
+
+		return THREE.Triangle.normal( this.a, this.b, this.c, optionalTarget );
+
+	},
+
+	plane: function ( optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Plane();
+
+		return result.setFromCoplanarPoints( this.a, this.b, this.c );
+
+	},
+
+	barycoordFromPoint: function ( point, optionalTarget ) {
+
+		return THREE.Triangle.barycoordFromPoint( point, this.a, this.b, this.c, optionalTarget );
+
+	},
+
+	containsPoint: function ( point ) {
+
+		return THREE.Triangle.containsPoint( point, this.a, this.b, this.c );
+
+	},
+
+	closestPointToPoint: function () {
+
+		var plane, edgeList, projectedPoint, closestPoint;
+
+		return function closestPointToPoint( point, optionalTarget ) {
+
+			if ( plane === undefined ) {
+
+				plane = new THREE.Plane();
+				edgeList = [ new THREE.Line3(), new THREE.Line3(), new THREE.Line3() ];
+				projectedPoint = new THREE.Vector3();
+				closestPoint = new THREE.Vector3();
+
+			}
+
+			var result = optionalTarget || new THREE.Vector3();
+			var minDistance = Infinity;
+
+			// project the point onto the plane of the triangle
+
+			plane.setFromCoplanarPoints( this.a, this.b, this.c );
+			plane.projectPoint( point, projectedPoint );
+
+			// check if the projection lies within the triangle
+
+			if( this.containsPoint( projectedPoint ) === true ) {
+
+				// if so, this is the closest point
+
+				result.copy( projectedPoint );
+
+			} else {
+
+				// if not, the point falls outside the triangle. the result is the closest point to the triangle's edges or vertices
+
+				edgeList[ 0 ].set( this.a, this.b );
+				edgeList[ 1 ].set( this.b, this.c );
+				edgeList[ 2 ].set( this.c, this.a );
+
+				for( var i = 0; i < edgeList.length; i ++ ) {
+
+					edgeList[ i ].closestPointToPoint( projectedPoint, true, closestPoint );
+
+					var distance = projectedPoint.distanceToSquared( closestPoint );
+
+					if( distance < minDistance ) {
+
+						minDistance = distance;
+
+						result.copy( closestPoint );
+
+					}
+
+				}
+
+			}
+
+			return result;
+
+		};
+
+	}(),
+
+	equals: function ( triangle ) {
+
+		return triangle.a.equals( this.a ) && triangle.b.equals( this.b ) && triangle.c.equals( this.c );
+
+	}
+
+};
+
+// File:src/math/Interpolant.js
+
+/**
+ * Abstract base class of interpolants over parametric samples.
+ *
+ * The parameter domain is one dimensional, typically the time or a path
+ * along a curve defined by the data.
+ *
+ * The sample values can have any dimensionality and derived classes may
+ * apply special interpretations to the data.
+ *
+ * This class provides the interval seek in a Template Method, deferring
+ * the actual interpolation to derived classes.
+ *
+ * Time complexity is O(1) for linear access crossing at most two points
+ * and O(log N) for random access, where N is the number of positions.
+ *
+ * References:
+ *
+ * 		http://www.oodesign.com/template-method-pattern.html
+ *
+ * @author tschw
+ */
+
+THREE.Interpolant = function(
+		parameterPositions, sampleValues, sampleSize, resultBuffer ) {
+
+	this.parameterPositions = parameterPositions;
+	this._cachedIndex = 0;
+
+	this.resultBuffer = resultBuffer !== undefined ?
+			resultBuffer : new sampleValues.constructor( sampleSize );
+	this.sampleValues = sampleValues;
+	this.valueSize = sampleSize;
+
+};
+
+THREE.Interpolant.prototype = {
+
+	constructor: THREE.Interpolant,
+
+	evaluate: function( t ) {
+
+		var pp = this.parameterPositions,
+			i1 = this._cachedIndex,
+
+			t1 = pp[   i1   ],
+			t0 = pp[ i1 - 1 ];
+
+		validate_interval: {
+
+			seek: {
+
+				var right;
+
+				linear_scan: {
+//- See http://jsperf.com/comparison-to-undefined/3
+//- slower code:
+//-
+//- 				if ( t >= t1 || t1 === undefined ) {
+					forward_scan: if ( ! ( t < t1 ) ) {
+
+						for ( var giveUpAt = i1 + 2; ;) {
+
+							if ( t1 === undefined ) {
+
+								if ( t < t0 ) break forward_scan;
+
+								// after end
+
+								i1 = pp.length;
+								this._cachedIndex = i1;
+								return this.afterEnd_( i1 - 1, t, t0 );
+
+							}
+
+							if ( i1 === giveUpAt ) break; // this loop
+
+							t0 = t1;
+							t1 = pp[ ++ i1 ];
+
+							if ( t < t1 ) {
+
+								// we have arrived at the sought interval
+								break seek;
+
+							}
+
+						}
+
+						// prepare binary search on the right side of the index
+						right = pp.length;
+						break linear_scan;
+
+					}
+
+//- slower code:
+//-					if ( t < t0 || t0 === undefined ) {
+					if ( ! ( t >= t0 ) ) {
+
+						// looping?
+
+						var t1global = pp[ 1 ];
+
+						if ( t < t1global ) {
+
+							i1 = 2; // + 1, using the scan for the details
+							t0 = t1global;
+
+						}
+
+						// linear reverse scan
+
+						for ( var giveUpAt = i1 - 2; ;) {
+
+							if ( t0 === undefined ) {
+
+								// before start
+
+								this._cachedIndex = 0;
+								return this.beforeStart_( 0, t, t1 );
+
+							}
+
+							if ( i1 === giveUpAt ) break; // this loop
+
+							t1 = t0;
+							t0 = pp[ -- i1 - 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 < right ) {
+
+					var mid = ( i1 + right ) >>> 1;
+
+					if ( t < pp[ mid ] ) {
+
+						right = mid;
+
+					} else {
+
+						i1 = mid + 1;
+
+					}
+
+				}
+
+				t1 = pp[   i1   ];
+				t0 = pp[ i1 - 1 ];
+
+				// check boundary cases, again
+
+				if ( t0 === undefined ) {
+
+					this._cachedIndex = 0;
+					return this.beforeStart_( 0, t, t1 );
+
+				}
+
+				if ( t1 === undefined ) {
+
+					i1 = pp.length;
+					this._cachedIndex = i1;
+					return this.afterEnd_( i1 - 1, t0, t );
+
+				}
+
+			} // seek
+
+			this._cachedIndex = i1;
+
+			this.intervalChanged_( i1, t0, t1 );
+
+		} // validate_interval
+
+		return this.interpolate_( i1, t0, t, t1 );
+
+	},
+
+	settings: null, // optional, subclass-specific settings structure
+	// Note: The indirection allows central control of many interpolants.
+
+	// --- Protected interface
+
+	DefaultSettings_: {},
+
+	getSettings_: function() {
+
+		return this.settings || this.DefaultSettings_;
+
+	},
+
+	copySampleValue_: function( index ) {
+
+		// copies a sample value to the result buffer
+
+		var result = this.resultBuffer,
+			values = this.sampleValues,
+			stride = this.valueSize,
+			offset = index * stride;
+
+		for ( var i = 0; i !== stride; ++ i ) {
+
+			result[ i ] = values[ offset + i ];
+
+		}
+
+		return result;
+
+	},
+
+	// Template methods for derived classes:
+
+	interpolate_: function( i1, t0, t, t1 ) {
+
+		throw new Error( "call to abstract method" );
+		// implementations shall return this.resultBuffer
+
+	},
+
+	intervalChanged_: function( i1, t0, t1 ) {
+
+		// empty
+
+	}
+
+};
+
+Object.assign( THREE.Interpolant.prototype, {
+
+	beforeStart_: //( 0, t, t0 ), returns this.resultBuffer
+		THREE.Interpolant.prototype.copySampleValue_,
+
+	afterEnd_: //( N-1, tN-1, t ), returns this.resultBuffer
+		THREE.Interpolant.prototype.copySampleValue_
+
+} );
+
+// File:src/math/interpolants/CubicInterpolant.js
+
+/**
+ * Fast and simple cubic spline interpolant.
+ *
+ * It was derived from a Hermitian construction setting the first derivative
+ * at each sample position to the linear slope between neighboring positions
+ * over their parameter interval.
+ *
+ * @author tschw
+ */
+
+THREE.CubicInterpolant = function(
+		parameterPositions, sampleValues, sampleSize, resultBuffer ) {
+
+	THREE.Interpolant.call(
+			this, parameterPositions, sampleValues, sampleSize, resultBuffer );
+
+	this._weightPrev = -0;
+	this._offsetPrev = -0;
+	this._weightNext = -0;
+	this._offsetNext = -0;
+
+};
+
+THREE.CubicInterpolant.prototype =
+		Object.assign( Object.create( THREE.Interpolant.prototype ), {
+
+	constructor: THREE.CubicInterpolant,
+
+	DefaultSettings_: {
+
+		endingStart: 	THREE.ZeroCurvatureEnding,
+		endingEnd:		THREE.ZeroCurvatureEnding
+
+	},
+
+	intervalChanged_: function( i1, t0, t1 ) {
+
+		var pp = this.parameterPositions,
+			iPrev = i1 - 2,
+			iNext = i1 + 1,
+
+			tPrev = pp[ iPrev ],
+			tNext = pp[ iNext ];
+
+		if ( tPrev === undefined ) {
+
+			switch ( this.getSettings_().endingStart ) {
+
+				case THREE.ZeroSlopeEnding:
+
+					// f'(t0) = 0
+					iPrev = i1;
+					tPrev = 2 * t0 - t1;
+
+					break;
+
+				case THREE.WrapAroundEnding:
+
+					// use the other end of the curve
+					iPrev = pp.length - 2;
+					tPrev = t0 + pp[ iPrev ] - pp[ iPrev + 1 ];
+
+					break;
+
+				default: // ZeroCurvatureEnding
+
+					// f''(t0) = 0 a.k.a. Natural Spline
+					iPrev = i1;
+					tPrev = t1;
+
+			}
+
+		}
+
+		if ( tNext === undefined ) {
+
+			switch ( this.getSettings_().endingEnd ) {
+
+				case THREE.ZeroSlopeEnding:
+
+					// f'(tN) = 0
+					iNext = i1;
+					tNext = 2 * t1 - t0;
+
+					break;
+
+				case THREE.WrapAroundEnding:
+
+					// use the other end of the curve
+					iNext = 1;
+					tNext = t1 + pp[ 1 ] - pp[ 0 ];
+
+					break;
+
+				default: // ZeroCurvatureEnding
+
+					// f''(tN) = 0, a.k.a. Natural Spline
+					iNext = i1 - 1;
+					tNext = t0;
+
+			}
+
+		}
+
+		var halfDt = ( t1 - t0 ) * 0.5,
+			stride = this.valueSize;
+
+		this._weightPrev = halfDt / ( t0 - tPrev );
+		this._weightNext = halfDt / ( tNext - t1 );
+		this._offsetPrev = iPrev * stride;
+		this._offsetNext = iNext * stride;
+
+	},
+
+	interpolate_: function( i1, t0, t, t1 ) {
+
+		var result = this.resultBuffer,
+			values = this.sampleValues,
+			stride = this.valueSize,
+
+			o1 = i1 * stride,		o0 = o1 - stride,
+			oP = this._offsetPrev, 	oN = this._offsetNext,
+			wP = this._weightPrev,	wN = this._weightNext,
+
+			p = ( t - t0 ) / ( t1 - t0 ),
+			pp = p * p,
+			ppp = pp * p;
+
+		// evaluate polynomials
+
+		var sP =     - wP   * ppp   +         2 * wP    * pp    -          wP   * p;
+		var s0 = ( 1 + wP ) * ppp   + (-1.5 - 2 * wP )  * pp    + ( -0.5 + wP ) * p     + 1;
+		var s1 = (-1 - wN ) * ppp   + ( 1.5 +   wN   )  * pp    +    0.5        * p;
+		var sN =       wN   * ppp   -           wN      * pp;
+
+		// combine data linearly
+
+		for ( var i = 0; i !== stride; ++ i ) {
+
+			result[ i ] =
+					sP * values[ oP + i ] +
+					s0 * values[ o0 + i ] +
+					s1 * values[ o1 + i ] +
+					sN * values[ oN + i ];
+
+		}
+
+		return result;
+
+	}
+
+} );
+
+// File:src/math/interpolants/DiscreteInterpolant.js
+
+/**
+ *
+ * Interpolant that evaluates to the sample value at the position preceeding
+ * the parameter.
+ *
+ * @author tschw
+ */
+
+THREE.DiscreteInterpolant = function(
+		parameterPositions, sampleValues, sampleSize, resultBuffer ) {
+
+	THREE.Interpolant.call(
+			this, parameterPositions, sampleValues, sampleSize, resultBuffer );
+
+};
+
+THREE.DiscreteInterpolant.prototype =
+		Object.assign( Object.create( THREE.Interpolant.prototype ), {
+
+	constructor: THREE.DiscreteInterpolant,
+
+	interpolate_: function( i1, t0, t, t1 ) {
+
+		return this.copySampleValue_( i1 - 1 );
+
+	}
+
+} );
+
+// File:src/math/interpolants/LinearInterpolant.js
+
+/**
+ * @author tschw
+ */
+
+THREE.LinearInterpolant = function(
+		parameterPositions, sampleValues, sampleSize, resultBuffer ) {
+
+	THREE.Interpolant.call(
+			this, parameterPositions, sampleValues, sampleSize, resultBuffer );
+
+};
+
+THREE.LinearInterpolant.prototype =
+		Object.assign( Object.create( THREE.Interpolant.prototype ), {
+
+	constructor: THREE.LinearInterpolant,
+
+	interpolate_: function( i1, t0, t, t1 ) {
+
+		var result = this.resultBuffer,
+			values = this.sampleValues,
+			stride = this.valueSize,
+
+			offset1 = i1 * stride,
+			offset0 = offset1 - stride,
+
+			weight1 = ( t - t0 ) / ( t1 - t0 ),
+			weight0 = 1 - weight1;
+
+		for ( var i = 0; i !== stride; ++ i ) {
+
+			result[ i ] =
+					values[ offset0 + i ] * weight0 +
+					values[ offset1 + i ] * weight1;
+
+		}
+
+		return result;
+
+	}
+
+} );
+
+// File:src/math/interpolants/QuaternionLinearInterpolant.js
+
+/**
+ * Spherical linear unit quaternion interpolant.
+ *
+ * @author tschw
+ */
+
+THREE.QuaternionLinearInterpolant = function(
+		parameterPositions, sampleValues, sampleSize, resultBuffer ) {
+
+	THREE.Interpolant.call(
+			this, parameterPositions, sampleValues, sampleSize, resultBuffer );
+
+};
+
+THREE.QuaternionLinearInterpolant.prototype =
+		Object.assign( Object.create( THREE.Interpolant.prototype ), {
+
+	constructor: THREE.QuaternionLinearInterpolant,
+
+	interpolate_: function( i1, t0, t, t1 ) {
+
+		var result = this.resultBuffer,
+			values = this.sampleValues,
+			stride = this.valueSize,
+
+			offset = i1 * stride,
+
+			alpha = ( t - t0 ) / ( t1 - t0 );
+
+		for ( var end = offset + stride; offset !== end; offset += 4 ) {
+
+			THREE.Quaternion.slerpFlat( result, 0,
+					values, offset - stride, values, offset, alpha );
+
+		}
+
+		return result;
+
+	}
+
+} );
+
+// File:src/core/Clock.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.Clock = function ( autoStart ) {
+
+	this.autoStart = ( autoStart !== undefined ) ? autoStart : true;
+
+	this.startTime = 0;
+	this.oldTime = 0;
+	this.elapsedTime = 0;
+
+	this.running = false;
+
+};
+
+THREE.Clock.prototype = {
+
+	constructor: THREE.Clock,
+
+	start: function () {
+
+		this.startTime = ( performance || Date ).now();
+
+		this.oldTime = this.startTime;
+		this.running = true;
+
+	},
+
+	stop: function () {
+
+		this.getElapsedTime();
+		this.running = false;
+
+	},
+
+	getElapsedTime: function () {
+
+		this.getDelta();
+		return this.elapsedTime;
+
+	},
+
+	getDelta: function () {
+
+		var diff = 0;
+
+		if ( this.autoStart && ! this.running ) {
+
+			this.start();
+
+		}
+
+		if ( this.running ) {
+
+			var newTime = ( performance || Date ).now();
+
+			diff = ( newTime - this.oldTime ) / 1000;
+			this.oldTime = newTime;
+
+			this.elapsedTime += diff;
+
+		}
+
+		return diff;
+
+	}
+
+};
+
+// File:src/core/EventDispatcher.js
+
+/**
+ * https://github.com/mrdoob/eventdispatcher.js/
+ */
+
+THREE.EventDispatcher = function () {};
+
+THREE.EventDispatcher.prototype = {
+
+	constructor: THREE.EventDispatcher,
+
+	apply: function ( object ) {
+
+		object.addEventListener = THREE.EventDispatcher.prototype.addEventListener;
+		object.hasEventListener = THREE.EventDispatcher.prototype.hasEventListener;
+		object.removeEventListener = THREE.EventDispatcher.prototype.removeEventListener;
+		object.dispatchEvent = THREE.EventDispatcher.prototype.dispatchEvent;
+
+	},
+
+	addEventListener: function ( type, listener ) {
+
+		if ( this._listeners === undefined ) this._listeners = {};
+
+		var listeners = this._listeners;
+
+		if ( listeners[ type ] === undefined ) {
+
+			listeners[ type ] = [];
+
+		}
+
+		if ( listeners[ type ].indexOf( listener ) === - 1 ) {
+
+			listeners[ type ].push( listener );
+
+		}
+
+	},
+
+	hasEventListener: function ( type, listener ) {
+
+		if ( this._listeners === undefined ) return false;
+
+		var listeners = this._listeners;
+
+		if ( listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1 ) {
+
+			return true;
+
+		}
+
+		return false;
+
+	},
+
+	removeEventListener: function ( type, listener ) {
+
+		if ( this._listeners === undefined ) return;
+
+		var listeners = this._listeners;
+		var listenerArray = listeners[ type ];
+
+		if ( listenerArray !== undefined ) {
+
+			var index = listenerArray.indexOf( listener );
+
+			if ( index !== - 1 ) {
+
+				listenerArray.splice( index, 1 );
+
+			}
+
+		}
+
+	},
+
+	dispatchEvent: function ( event ) {
+
+		if ( this._listeners === undefined ) return;
+
+		var listeners = this._listeners;
+		var listenerArray = listeners[ event.type ];
+
+		if ( listenerArray !== undefined ) {
+
+			event.target = this;
+
+			var array = [];
+			var length = listenerArray.length;
+
+			for ( var i = 0; i < length; i ++ ) {
+
+				array[ i ] = listenerArray[ i ];
+
+			}
+
+			for ( var i = 0; i < length; i ++ ) {
+
+				array[ i ].call( this, event );
+
+			}
+
+		}
+
+	}
+
+};
+
+// File:src/core/Layers.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.Layers = function () {
+
+	this.mask = 1;
+
+};
+
+THREE.Layers.prototype = {
+
+	constructor: THREE.Layers,
+
+	set: function ( channel ) {
+
+		this.mask = 1 << channel;
+
+	},
+
+	enable: function ( channel ) {
+
+		this.mask |= 1 << channel;
+
+	},
+
+	toggle: function ( channel ) {
+
+		this.mask ^= 1 << channel;
+
+	},
+
+	disable: function ( channel ) {
+
+		this.mask &= ~ ( 1 << channel );
+
+	},
+
+	test: function ( layers ) {
+
+		return ( this.mask & layers.mask ) !== 0;
+
+	}
+
+};
+
+// File:src/core/Raycaster.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author bhouston / http://clara.io/
+ * @author stephomi / http://stephaneginier.com/
+ */
+
+( function ( THREE ) {
+
+	THREE.Raycaster = function ( origin, direction, near, far ) {
+
+		this.ray = new THREE.Ray( origin, direction );
+		// direction is assumed to be normalized (for accurate distance calculations)
+
+		this.near = near || 0;
+		this.far = far || Infinity;
+
+		this.params = {
+			Mesh: {},
+			Line: {},
+			LOD: {},
+			Points: { threshold: 1 },
+			Sprite: {}
+		};
+
+		Object.defineProperties( this.params, {
+			PointCloud: {
+				get: function () {
+					console.warn( 'THREE.Raycaster: params.PointCloud has been renamed to params.Points.' );
+					return this.Points;
+				}
+			}
+		} );
+
+	};
+
+	function ascSort( a, b ) {
+
+		return a.distance - b.distance;
+
+	}
+
+	function intersectObject( object, raycaster, intersects, recursive ) {
+
+		if ( object.visible === false ) return;
+
+		object.raycast( raycaster, intersects );
+
+		if ( recursive === true ) {
+
+			var children = object.children;
+
+			for ( var i = 0, l = children.length; i < l; i ++ ) {
+
+				intersectObject( children[ i ], raycaster, intersects, true );
+
+			}
+
+		}
+
+	}
+
+	//
+
+	THREE.Raycaster.prototype = {
+
+		constructor: THREE.Raycaster,
+
+		linePrecision: 1,
+
+		set: function ( origin, direction ) {
+
+			// direction is assumed to be normalized (for accurate distance calculations)
+
+			this.ray.set( origin, direction );
+
+		},
+
+		setFromCamera: function ( coords, camera ) {
+
+			if ( camera instanceof THREE.PerspectiveCamera ) {
+
+				this.ray.origin.setFromMatrixPosition( camera.matrixWorld );
+				this.ray.direction.set( coords.x, coords.y, 0.5 ).unproject( camera ).sub( this.ray.origin ).normalize();
+
+			} else if ( camera instanceof THREE.OrthographicCamera ) {
+
+				this.ray.origin.set( coords.x, coords.y, - 1 ).unproject( camera );
+				this.ray.direction.set( 0, 0, - 1 ).transformDirection( camera.matrixWorld );
+
+			} else {
+
+				console.error( 'THREE.Raycaster: Unsupported camera type.' );
+
+			}
+
+		},
+
+		intersectObject: function ( object, recursive ) {
+
+			var intersects = [];
+
+			intersectObject( object, this, intersects, recursive );
+
+			intersects.sort( ascSort );
+
+			return intersects;
+
+		},
+
+		intersectObjects: function ( objects, recursive ) {
+
+			var intersects = [];
+
+			if ( Array.isArray( objects ) === false ) {
+
+				console.warn( 'THREE.Raycaster.intersectObjects: objects is not an Array.' );
+				return intersects;
+
+			}
+
+			for ( var i = 0, l = objects.length; i < l; i ++ ) {
+
+				intersectObject( objects[ i ], this, intersects, recursive );
+
+			}
+
+			intersects.sort( ascSort );
+
+			return intersects;
+
+		}
+
+	};
+
+}( THREE ) );
+
+// File:src/core/Object3D.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author mikael emtinger / http://gomo.se/
+ * @author alteredq / http://alteredqualia.com/
+ * @author WestLangley / http://github.com/WestLangley
+ * @author elephantatwork / www.elephantatwork.ch
+ */
+
+THREE.Object3D = function () {
+
+	Object.defineProperty( this, 'id', { value: THREE.Object3DIdCount ++ } );
+
+	this.uuid = THREE.Math.generateUUID();
+
+	this.name = '';
+	this.type = 'Object3D';
+
+	this.parent = null;
+	this.children = [];
+
+	this.up = THREE.Object3D.DefaultUp.clone();
+
+	var position = new THREE.Vector3();
+	var rotation = new THREE.Euler();
+	var quaternion = new THREE.Quaternion();
+	var scale = new THREE.Vector3( 1, 1, 1 );
+
+	function onRotationChange() {
+
+		quaternion.setFromEuler( rotation, false );
+
+	}
+
+	function onQuaternionChange() {
+
+		rotation.setFromQuaternion( quaternion, undefined, false );
+
+	}
+
+	rotation.onChange( onRotationChange );
+	quaternion.onChange( onQuaternionChange );
+
+	Object.defineProperties( this, {
+		position: {
+			enumerable: true,
+			value: position
+		},
+		rotation: {
+			enumerable: true,
+			value: rotation
+		},
+		quaternion: {
+			enumerable: true,
+			value: quaternion
+		},
+		scale: {
+			enumerable: true,
+			value: scale
+		},
+		modelViewMatrix: {
+			value: new THREE.Matrix4()
+		},
+		normalMatrix: {
+			value: new THREE.Matrix3()
+		}
+	} );
+
+	this.rotationAutoUpdate = true;
+
+	this.matrix = new THREE.Matrix4();
+	this.matrixWorld = new THREE.Matrix4();
+
+	this.matrixAutoUpdate = THREE.Object3D.DefaultMatrixAutoUpdate;
+	this.matrixWorldNeedsUpdate = false;
+
+	this.layers = new THREE.Layers();
+	this.visible = true;
+
+	this.castShadow = false;
+	this.receiveShadow = false;
+
+	this.frustumCulled = true;
+	this.renderOrder = 0;
+
+	this.userData = {};
+
+};
+
+THREE.Object3D.DefaultUp = new THREE.Vector3( 0, 1, 0 );
+THREE.Object3D.DefaultMatrixAutoUpdate = true;
+
+THREE.Object3D.prototype = {
+
+	constructor: THREE.Object3D,
+
+	applyMatrix: function ( matrix ) {
+
+		this.matrix.multiplyMatrices( matrix, this.matrix );
+
+		this.matrix.decompose( this.position, this.quaternion, this.scale );
+
+	},
+
+	setRotationFromAxisAngle: function ( axis, angle ) {
+
+		// assumes axis is normalized
+
+		this.quaternion.setFromAxisAngle( axis, angle );
+
+	},
+
+	setRotationFromEuler: function ( euler ) {
+
+		this.quaternion.setFromEuler( euler, true );
+
+	},
+
+	setRotationFromMatrix: function ( m ) {
+
+		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+
+		this.quaternion.setFromRotationMatrix( m );
+
+	},
+
+	setRotationFromQuaternion: function ( q ) {
+
+		// assumes q is normalized
+
+		this.quaternion.copy( q );
+
+	},
+
+	rotateOnAxis: function () {
+
+		// rotate object on axis in object space
+		// axis is assumed to be normalized
+
+		var q1 = new THREE.Quaternion();
+
+		return function ( axis, angle ) {
+
+			q1.setFromAxisAngle( axis, angle );
+
+			this.quaternion.multiply( q1 );
+
+			return this;
+
+		};
+
+	}(),
+
+	rotateX: function () {
+
+		var v1 = new THREE.Vector3( 1, 0, 0 );
+
+		return function ( angle ) {
+
+			return this.rotateOnAxis( v1, angle );
+
+		};
+
+	}(),
+
+	rotateY: function () {
+
+		var v1 = new THREE.Vector3( 0, 1, 0 );
+
+		return function ( angle ) {
+
+			return this.rotateOnAxis( v1, angle );
+
+		};
+
+	}(),
+
+	rotateZ: function () {
+
+		var v1 = new THREE.Vector3( 0, 0, 1 );
+
+		return function ( angle ) {
+
+			return this.rotateOnAxis( v1, angle );
+
+		};
+
+	}(),
+
+	translateOnAxis: function () {
+
+		// translate object by distance along axis in object space
+		// axis is assumed to be normalized
+
+		var v1 = new THREE.Vector3();
+
+		return function ( axis, distance ) {
+
+			v1.copy( axis ).applyQuaternion( this.quaternion );
+
+			this.position.add( v1.multiplyScalar( distance ) );
+
+			return this;
+
+		};
+
+	}(),
+
+	translateX: function () {
+
+		var v1 = new THREE.Vector3( 1, 0, 0 );
+
+		return function ( distance ) {
+
+			return this.translateOnAxis( v1, distance );
+
+		};
+
+	}(),
+
+	translateY: function () {
+
+		var v1 = new THREE.Vector3( 0, 1, 0 );
+
+		return function ( distance ) {
+
+			return this.translateOnAxis( v1, distance );
+
+		};
+
+	}(),
+
+	translateZ: function () {
+
+		var v1 = new THREE.Vector3( 0, 0, 1 );
+
+		return function ( distance ) {
+
+			return this.translateOnAxis( v1, distance );
+
+		};
+
+	}(),
+
+	localToWorld: function ( vector ) {
+
+		return vector.applyMatrix4( this.matrixWorld );
+
+	},
+
+	worldToLocal: function () {
+
+		var m1 = new THREE.Matrix4();
+
+		return function ( vector ) {
+
+			return vector.applyMatrix4( m1.getInverse( this.matrixWorld ) );
+
+		};
+
+	}(),
+
+	lookAt: function () {
+
+		// This routine does not support objects with rotated and/or translated parent(s)
+
+		var m1 = new THREE.Matrix4();
+
+		return function ( vector ) {
+
+			m1.lookAt( vector, this.position, this.up );
+
+			this.quaternion.setFromRotationMatrix( m1 );
+
+		};
+
+	}(),
+
+	add: function ( object ) {
+
+		if ( arguments.length > 1 ) {
+
+			for ( var i = 0; i < arguments.length; i ++ ) {
+
+				this.add( arguments[ i ] );
+
+			}
+
+			return this;
+
+		}
+
+		if ( object === this ) {
+
+			console.error( "THREE.Object3D.add: object can't be added as a child of itself.", object );
+			return this;
+
+		}
+
+		if ( object instanceof THREE.Object3D ) {
+
+			if ( object.parent !== null ) {
+
+				object.parent.remove( object );
+
+			}
+
+			object.parent = this;
+			object.dispatchEvent( { type: 'added' } );
+
+			this.children.push( object );
+
+		} else {
+
+			console.error( "THREE.Object3D.add: object not an instance of THREE.Object3D.", object );
+
+		}
+
+		return this;
+
+	},
+
+	remove: function ( object ) {
+
+		if ( arguments.length > 1 ) {
+
+			for ( var i = 0; i < arguments.length; i ++ ) {
+
+				this.remove( arguments[ i ] );
+
+			}
+
+		}
+
+		var index = this.children.indexOf( object );
+
+		if ( index !== - 1 ) {
+
+			object.parent = null;
+
+			object.dispatchEvent( { type: 'removed' } );
+
+			this.children.splice( index, 1 );
+
+		}
+
+	},
+
+	getObjectById: function ( id ) {
+
+		return this.getObjectByProperty( 'id', id );
+
+	},
+
+	getObjectByName: function ( name ) {
+
+		return this.getObjectByProperty( 'name', name );
+
+	},
+
+	getObjectByProperty: function ( name, value ) {
+
+		if ( this[ name ] === value ) return this;
+
+		for ( var i = 0, l = this.children.length; i < l; i ++ ) {
+
+			var child = this.children[ i ];
+			var object = child.getObjectByProperty( name, value );
+
+			if ( object !== undefined ) {
+
+				return object;
+
+			}
+
+		}
+
+		return undefined;
+
+	},
+
+	getWorldPosition: function ( optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector3();
+
+		this.updateMatrixWorld( true );
+
+		return result.setFromMatrixPosition( this.matrixWorld );
+
+	},
+
+	getWorldQuaternion: function () {
+
+		var position = new THREE.Vector3();
+		var scale = new THREE.Vector3();
+
+		return function ( optionalTarget ) {
+
+			var result = optionalTarget || new THREE.Quaternion();
+
+			this.updateMatrixWorld( true );
+
+			this.matrixWorld.decompose( position, result, scale );
+
+			return result;
+
+		};
+
+	}(),
+
+	getWorldRotation: function () {
+
+		var quaternion = new THREE.Quaternion();
+
+		return function ( optionalTarget ) {
+
+			var result = optionalTarget || new THREE.Euler();
+
+			this.getWorldQuaternion( quaternion );
+
+			return result.setFromQuaternion( quaternion, this.rotation.order, false );
+
+		};
+
+	}(),
+
+	getWorldScale: function () {
+
+		var position = new THREE.Vector3();
+		var quaternion = new THREE.Quaternion();
+
+		return function ( optionalTarget ) {
+
+			var result = optionalTarget || new THREE.Vector3();
+
+			this.updateMatrixWorld( true );
+
+			this.matrixWorld.decompose( position, quaternion, result );
+
+			return result;
+
+		};
+
+	}(),
+
+	getWorldDirection: function () {
+
+		var quaternion = new THREE.Quaternion();
+
+		return function ( optionalTarget ) {
+
+			var result = optionalTarget || new THREE.Vector3();
+
+			this.getWorldQuaternion( quaternion );
+
+			return result.set( 0, 0, 1 ).applyQuaternion( quaternion );
+
+		};
+
+	}(),
+
+	raycast: function () {},
+
+	traverse: function ( callback ) {
+
+		callback( this );
+
+		var children = this.children;
+
+		for ( var i = 0, l = children.length; i < l; i ++ ) {
+
+			children[ i ].traverse( callback );
+
+		}
+
+	},
+
+	traverseVisible: function ( callback ) {
+
+		if ( this.visible === false ) return;
+
+		callback( this );
+
+		var children = this.children;
+
+		for ( var i = 0, l = children.length; i < l; i ++ ) {
+
+			children[ i ].traverseVisible( callback );
+
+		}
+
+	},
+
+	traverseAncestors: function ( callback ) {
+
+		var parent = this.parent;
+
+		if ( parent !== null ) {
+
+			callback( parent );
+
+			parent.traverseAncestors( callback );
+
+		}
+
+	},
+
+	updateMatrix: function () {
+
+		this.matrix.compose( this.position, this.quaternion, this.scale );
+
+		this.matrixWorldNeedsUpdate = true;
+
+	},
+
+	updateMatrixWorld: function ( force ) {
+
+		if ( this.matrixAutoUpdate === true ) this.updateMatrix();
+
+		if ( this.matrixWorldNeedsUpdate === true || force === true ) {
+
+			if ( this.parent === null ) {
+
+				this.matrixWorld.copy( this.matrix );
+
+			} else {
+
+				this.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );
+
+			}
+
+			this.matrixWorldNeedsUpdate = false;
+
+			force = true;
+
+		}
+
+		// update children
+
+		for ( var i = 0, l = this.children.length; i < l; i ++ ) {
+
+			this.children[ i ].updateMatrixWorld( force );
+
+		}
+
+	},
+
+	toJSON: function ( meta ) {
+
+		// meta is '' when called from JSON.stringify
+		var isRootObject = ( meta === undefined || meta === '' );
+
+		var output = {};
+
+		// meta is a hash used to collect geometries, materials.
+		// not providing it implies that this is the root object
+		// being serialized.
+		if ( isRootObject ) {
+
+			// initialize meta obj
+			meta = {
+				geometries: {},
+				materials: {},
+				textures: {},
+				images: {}
+			};
+
+			output.metadata = {
+				version: 4.4,
+				type: 'Object',
+				generator: 'Object3D.toJSON'
+			};
+
+		}
+
+		// standard Object3D serialization
+
+		var object = {};
+
+		object.uuid = this.uuid;
+		object.type = this.type;
+
+		if ( this.name !== '' ) object.name = this.name;
+		if ( JSON.stringify( this.userData ) !== '{}' ) object.userData = this.userData;
+		if ( this.castShadow === true ) object.castShadow = true;
+		if ( this.receiveShadow === true ) object.receiveShadow = true;
+		if ( this.visible === false ) object.visible = false;
+
+		object.matrix = this.matrix.toArray();
+
+		//
+
+		if ( this.geometry !== undefined ) {
+
+			if ( meta.geometries[ this.geometry.uuid ] === undefined ) {
+
+				meta.geometries[ this.geometry.uuid ] = this.geometry.toJSON( meta );
+
+			}
+
+			object.geometry = this.geometry.uuid;
+
+		}
+
+		if ( this.material !== undefined ) {
+
+			if ( meta.materials[ this.material.uuid ] === undefined ) {
+
+				meta.materials[ this.material.uuid ] = this.material.toJSON( meta );
+
+			}
+
+			object.material = this.material.uuid;
+
+		}
+
+		//
+
+		if ( this.children.length > 0 ) {
+
+			object.children = [];
+
+			for ( var i = 0; i < this.children.length; i ++ ) {
+
+				object.children.push( this.children[ i ].toJSON( meta ).object );
+
+			}
+
+		}
+
+		if ( isRootObject ) {
+
+			var geometries = extractFromCache( meta.geometries );
+			var materials = extractFromCache( meta.materials );
+			var textures = extractFromCache( meta.textures );
+			var images = extractFromCache( meta.images );
+
+			if ( geometries.length > 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;
+
+		}
+
+		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.rotationAutoUpdate = source.rotationAutoUpdate;
+
+		this.matrix.copy( source.matrix );
+		this.matrixWorld.copy( source.matrixWorld );
+
+		this.matrixAutoUpdate = source.matrixAutoUpdate;
+		this.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate;
+
+		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 < source.children.length; i ++ ) {
+
+				var child = source.children[ i ];
+				this.add( child.clone() );
+
+			}
+
+		}
+
+		return this;
+
+	}
+
+};
+
+THREE.EventDispatcher.prototype.apply( THREE.Object3D.prototype );
+
+THREE.Object3DIdCount = 0;
+
+// File:src/core/Face3.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.Face3 = function ( a, b, c, normal, color, materialIndex ) {
+
+	this.a = a;
+	this.b = b;
+	this.c = c;
+
+	this.normal = normal instanceof THREE.Vector3 ? normal : new THREE.Vector3();
+	this.vertexNormals = Array.isArray( normal ) ? normal : [];
+
+	this.color = color instanceof THREE.Color ? color : new THREE.Color();
+	this.vertexColors = Array.isArray( color ) ? color : [];
+
+	this.materialIndex = materialIndex !== undefined ? materialIndex : 0;
+
+};
+
+THREE.Face3.prototype = {
+
+	constructor: THREE.Face3,
+
+	clone: function () {
+
+		return new this.constructor().copy( this );
+
+	},
+
+	copy: function ( source ) {
+
+		this.a = source.a;
+		this.b = source.b;
+		this.c = source.c;
+
+		this.normal.copy( source.normal );
+		this.color.copy( source.color );
+
+		this.materialIndex = source.materialIndex;
+
+		for ( var i = 0, il = source.vertexNormals.length; i < il; i ++ ) {
+
+			this.vertexNormals[ i ] = source.vertexNormals[ i ].clone();
+
+		}
+
+		for ( var i = 0, il = source.vertexColors.length; i < il; i ++ ) {
+
+			this.vertexColors[ i ] = source.vertexColors[ i ].clone();
+
+		}
+
+		return this;
+
+	}
+
+};
+
+// File:src/core/BufferAttribute.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.BufferAttribute = function ( array, itemSize, normalized ) {
+
+	this.uuid = THREE.Math.generateUUID();
+
+	this.array = array;
+	this.itemSize = itemSize;
+
+	this.dynamic = false;
+	this.updateRange = { offset: 0, count: - 1 };
+
+	this.version = 0;
+	this.normalized = normalized === true;
+
+};
+
+THREE.BufferAttribute.prototype = {
+
+	constructor: THREE.BufferAttribute,
+
+	get count() {
+
+		return this.array.length / this.itemSize;
+
+	},
+
+	set needsUpdate( value ) {
+
+		if ( value === true ) this.version ++;
+
+	},
+
+	setDynamic: function ( value ) {
+
+		this.dynamic = value;
+
+		return this;
+
+	},
+
+	copy: function ( source ) {
+
+		this.array = new source.array.constructor( source.array );
+		this.itemSize = source.itemSize;
+
+		this.dynamic = source.dynamic;
+
+		return this;
+
+	},
+
+	copyAt: function ( index1, attribute, index2 ) {
+
+		index1 *= this.itemSize;
+		index2 *= attribute.itemSize;
+
+		for ( var i = 0, l = this.itemSize; i < l; i ++ ) {
+
+			this.array[ index1 + i ] = attribute.array[ index2 + i ];
+
+		}
+
+		return this;
+
+	},
+
+	copyArray: function ( array ) {
+
+		this.array.set( array );
+
+		return this;
+
+	},
+
+	copyColorsArray: function ( colors ) {
+
+		var array = this.array, offset = 0;
+
+		for ( var i = 0, l = colors.length; i < l; i ++ ) {
+
+			var color = colors[ i ];
+
+			if ( color === undefined ) {
+
+				console.warn( 'THREE.BufferAttribute.copyColorsArray(): color is undefined', i );
+				color = new THREE.Color();
+
+			}
+
+			array[ offset ++ ] = color.r;
+			array[ offset ++ ] = color.g;
+			array[ offset ++ ] = color.b;
+
+		}
+
+		return this;
+
+	},
+
+	copyIndicesArray: function ( indices ) {
+
+		var array = this.array, offset = 0;
+
+		for ( var i = 0, l = indices.length; i < l; i ++ ) {
+
+			var index = indices[ i ];
+
+			array[ offset ++ ] = index.a;
+			array[ offset ++ ] = index.b;
+			array[ offset ++ ] = index.c;
+
+		}
+
+		return this;
+
+	},
+
+	copyVector2sArray: function ( vectors ) {
+
+		var array = this.array, offset = 0;
+
+		for ( var i = 0, l = vectors.length; i < l; i ++ ) {
+
+			var vector = vectors[ i ];
+
+			if ( vector === undefined ) {
+
+				console.warn( 'THREE.BufferAttribute.copyVector2sArray(): vector is undefined', i );
+				vector = new THREE.Vector2();
+
+			}
+
+			array[ offset ++ ] = vector.x;
+			array[ offset ++ ] = vector.y;
+
+		}
+
+		return this;
+
+	},
+
+	copyVector3sArray: function ( vectors ) {
+
+		var array = this.array, offset = 0;
+
+		for ( var i = 0, l = vectors.length; i < l; i ++ ) {
+
+			var vector = vectors[ i ];
+
+			if ( vector === undefined ) {
+
+				console.warn( 'THREE.BufferAttribute.copyVector3sArray(): vector is undefined', i );
+				vector = new THREE.Vector3();
+
+			}
+
+			array[ offset ++ ] = vector.x;
+			array[ offset ++ ] = vector.y;
+			array[ offset ++ ] = vector.z;
+
+		}
+
+		return this;
+
+	},
+
+	copyVector4sArray: function ( vectors ) {
+
+		var array = this.array, offset = 0;
+
+		for ( var i = 0, l = vectors.length; i < l; i ++ ) {
+
+			var vector = vectors[ i ];
+
+			if ( vector === undefined ) {
+
+				console.warn( 'THREE.BufferAttribute.copyVector4sArray(): vector is undefined', i );
+				vector = new THREE.Vector4();
+
+			}
+
+			array[ offset ++ ] = vector.x;
+			array[ offset ++ ] = vector.y;
+			array[ offset ++ ] = vector.z;
+			array[ offset ++ ] = vector.w;
+
+		}
+
+		return this;
+
+	},
+
+	set: function ( value, offset ) {
+
+		if ( offset === undefined ) offset = 0;
+
+		this.array.set( value, offset );
+
+		return this;
+
+	},
+
+	getX: function ( index ) {
+
+		return this.array[ index * this.itemSize ];
+
+	},
+
+	setX: function ( index, x ) {
+
+		this.array[ index * this.itemSize ] = x;
+
+		return this;
+
+	},
+
+	getY: function ( index ) {
+
+		return this.array[ index * this.itemSize + 1 ];
+
+	},
+
+	setY: function ( index, y ) {
+
+		this.array[ index * this.itemSize + 1 ] = y;
+
+		return this;
+
+	},
+
+	getZ: function ( index ) {
+
+		return this.array[ index * this.itemSize + 2 ];
+
+	},
+
+	setZ: function ( index, z ) {
+
+		this.array[ index * this.itemSize + 2 ] = z;
+
+		return this;
+
+	},
+
+	getW: function ( index ) {
+
+		return this.array[ index * this.itemSize + 3 ];
+
+	},
+
+	setW: function ( index, w ) {
+
+		this.array[ index * this.itemSize + 3 ] = w;
+
+		return this;
+
+	},
+
+	setXY: function ( index, x, y ) {
+
+		index *= this.itemSize;
+
+		this.array[ index + 0 ] = x;
+		this.array[ index + 1 ] = y;
+
+		return this;
+
+	},
+
+	setXYZ: function ( index, x, y, z ) {
+
+		index *= this.itemSize;
+
+		this.array[ index + 0 ] = x;
+		this.array[ index + 1 ] = y;
+		this.array[ index + 2 ] = z;
+
+		return this;
+
+	},
+
+	setXYZW: function ( index, x, y, z, w ) {
+
+		index *= this.itemSize;
+
+		this.array[ index + 0 ] = x;
+		this.array[ index + 1 ] = y;
+		this.array[ index + 2 ] = z;
+		this.array[ index + 3 ] = w;
+
+		return this;
+
+	},
+
+	clone: function () {
+
+		return new this.constructor().copy( this );
+
+	}
+
+};
+
+//
+
+THREE.Int8Attribute = function ( array, itemSize ) {
+
+	return new THREE.BufferAttribute( new Int8Array( array ), itemSize );
+
+};
+
+THREE.Uint8Attribute = function ( array, itemSize ) {
+
+	return new THREE.BufferAttribute( new Uint8Array( array ), itemSize );
+
+};
+
+THREE.Uint8ClampedAttribute = function ( array, itemSize ) {
+
+	return new THREE.BufferAttribute( new Uint8ClampedArray( array ), itemSize );
+
+};
+
+THREE.Int16Attribute = function ( array, itemSize ) {
+
+	return new THREE.BufferAttribute( new Int16Array( array ), itemSize );
+
+};
+
+THREE.Uint16Attribute = function ( array, itemSize ) {
+
+	return new THREE.BufferAttribute( new Uint16Array( array ), itemSize );
+
+};
+
+THREE.Int32Attribute = function ( array, itemSize ) {
+
+	return new THREE.BufferAttribute( new Int32Array( array ), itemSize );
+
+};
+
+THREE.Uint32Attribute = function ( array, itemSize ) {
+
+	return new THREE.BufferAttribute( new Uint32Array( array ), itemSize );
+
+};
+
+THREE.Float32Attribute = function ( array, itemSize ) {
+
+	return new THREE.BufferAttribute( new Float32Array( array ), itemSize );
+
+};
+
+THREE.Float64Attribute = function ( array, itemSize ) {
+
+	return new THREE.BufferAttribute( new Float64Array( array ), itemSize );
+
+};
+
+
+// Deprecated
+
+THREE.DynamicBufferAttribute = function ( array, itemSize ) {
+
+	console.warn( 'THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setDynamic( true ) instead.' );
+	return new THREE.BufferAttribute( array, itemSize ).setDynamic( true );
+
+};
+
+// File:src/core/InstancedBufferAttribute.js
+
+/**
+ * @author benaadams / https://twitter.com/ben_a_adams
+ */
+
+THREE.InstancedBufferAttribute = function ( array, itemSize, meshPerAttribute ) {
+
+	THREE.BufferAttribute.call( this, array, itemSize );
+
+	this.meshPerAttribute = meshPerAttribute || 1;
+
+};
+
+THREE.InstancedBufferAttribute.prototype = Object.create( THREE.BufferAttribute.prototype );
+THREE.InstancedBufferAttribute.prototype.constructor = THREE.InstancedBufferAttribute;
+
+THREE.InstancedBufferAttribute.prototype.copy = function ( source ) {
+
+	THREE.BufferAttribute.prototype.copy.call( this, source );
+
+	this.meshPerAttribute = source.meshPerAttribute;
+
+	return this;
+
+};
+
+// File:src/core/InterleavedBuffer.js
+
+/**
+ * @author benaadams / https://twitter.com/ben_a_adams
+ */
+
+THREE.InterleavedBuffer = function ( array, stride ) {
+
+	this.uuid = THREE.Math.generateUUID();
+
+	this.array = array;
+	this.stride = stride;
+
+	this.dynamic = false;
+	this.updateRange = { offset: 0, count: - 1 };
+
+	this.version = 0;
+
+};
+
+THREE.InterleavedBuffer.prototype = {
+
+	constructor: THREE.InterleavedBuffer,
+
+	get length () {
+
+		return this.array.length;
+
+	},
+
+	get count () {
+
+		return this.array.length / this.stride;
+
+	},
+
+	set needsUpdate( value ) {
+
+		if ( value === true ) this.version ++;
+
+	},
+
+	setDynamic: function ( value ) {
+
+		this.dynamic = value;
+
+		return this;
+
+	},
+
+	copy: function ( source ) {
+
+		this.array = new source.array.constructor( source.array );
+		this.stride = source.stride;
+		this.dynamic = source.dynamic;
+
+		return this;
+
+	},
+
+	copyAt: function ( index1, attribute, index2 ) {
+
+		index1 *= this.stride;
+		index2 *= attribute.stride;
+
+		for ( var i = 0, l = this.stride; i < l; i ++ ) {
+
+			this.array[ index1 + i ] = attribute.array[ index2 + i ];
+
+		}
+
+		return this;
+
+	},
+
+	set: function ( value, offset ) {
+
+		if ( offset === undefined ) offset = 0;
+
+		this.array.set( value, offset );
+
+		return this;
+
+	},
+
+	clone: function () {
+
+		return new this.constructor().copy( this );
+
+	}
+
+};
+
+// File:src/core/InstancedInterleavedBuffer.js
+
+/**
+ * @author benaadams / https://twitter.com/ben_a_adams
+ */
+
+THREE.InstancedInterleavedBuffer = function ( array, stride, meshPerAttribute ) {
+
+	THREE.InterleavedBuffer.call( this, array, stride );
+
+	this.meshPerAttribute = meshPerAttribute || 1;
+
+};
+
+THREE.InstancedInterleavedBuffer.prototype = Object.create( THREE.InterleavedBuffer.prototype );
+THREE.InstancedInterleavedBuffer.prototype.constructor = THREE.InstancedInterleavedBuffer;
+
+THREE.InstancedInterleavedBuffer.prototype.copy = function ( source ) {
+
+	THREE.InterleavedBuffer.prototype.copy.call( this, source );
+
+	this.meshPerAttribute = source.meshPerAttribute;
+
+	return this;
+
+};
+
+// File:src/core/InterleavedBufferAttribute.js
+
+/**
+ * @author benaadams / https://twitter.com/ben_a_adams
+ */
+
+THREE.InterleavedBufferAttribute = function ( interleavedBuffer, itemSize, offset ) {
+
+	this.uuid = THREE.Math.generateUUID();
+
+	this.data = interleavedBuffer;
+	this.itemSize = itemSize;
+	this.offset = offset;
+
+};
+
+
+THREE.InterleavedBufferAttribute.prototype = {
+
+	constructor: THREE.InterleavedBufferAttribute,
+
+	get length() {
+
+		console.warn( 'THREE.BufferAttribute: .length has been deprecated. Please use .count.' );
+		return this.array.length;
+
+	},
+
+	get count() {
+
+		return this.data.count;
+
+	},
+
+	setX: function ( index, x ) {
+
+		this.data.array[ index * this.data.stride + this.offset ] = x;
+
+		return this;
+
+	},
+
+	setY: function ( index, y ) {
+
+		this.data.array[ index * this.data.stride + this.offset + 1 ] = y;
+
+		return this;
+
+	},
+
+	setZ: function ( index, z ) {
+
+		this.data.array[ index * this.data.stride + this.offset + 2 ] = z;
+
+		return this;
+
+	},
+
+	setW: function ( index, w ) {
+
+		this.data.array[ index * this.data.stride + this.offset + 3 ] = w;
+
+		return this;
+
+	},
+
+	getX: function ( index ) {
+
+		return this.data.array[ index * this.data.stride + this.offset ];
+
+	},
+
+	getY: function ( index ) {
+
+		return this.data.array[ index * this.data.stride + this.offset + 1 ];
+
+	},
+
+	getZ: function ( index ) {
+
+		return this.data.array[ index * this.data.stride + this.offset + 2 ];
+
+	},
+
+	getW: function ( index ) {
+
+		return this.data.array[ index * this.data.stride + this.offset + 3 ];
+
+	},
+
+	setXY: function ( index, x, y ) {
+
+		index = index * this.data.stride + this.offset;
+
+		this.data.array[ index + 0 ] = x;
+		this.data.array[ index + 1 ] = y;
+
+		return this;
+
+	},
+
+	setXYZ: function ( index, x, y, z ) {
+
+		index = index * this.data.stride + this.offset;
+
+		this.data.array[ index + 0 ] = x;
+		this.data.array[ index + 1 ] = y;
+		this.data.array[ index + 2 ] = z;
+
+		return this;
+
+	},
+
+	setXYZW: function ( index, x, y, z, w ) {
+
+		index = index * this.data.stride + this.offset;
+
+		this.data.array[ index + 0 ] = x;
+		this.data.array[ index + 1 ] = y;
+		this.data.array[ index + 2 ] = z;
+		this.data.array[ index + 3 ] = w;
+
+		return this;
+
+	}
+
+};
+
+// File:src/core/Geometry.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author kile / http://kile.stravaganza.org/
+ * @author alteredq / http://alteredqualia.com/
+ * @author mikael emtinger / http://gomo.se/
+ * @author zz85 / http://www.lab4games.net/zz85/blog
+ * @author bhouston / http://clara.io
+ */
+
+THREE.Geometry = function () {
+
+	Object.defineProperty( this, 'id', { value: THREE.GeometryIdCount ++ } );
+
+	this.uuid = THREE.Math.generateUUID();
+
+	this.name = '';
+	this.type = 'Geometry';
+
+	this.vertices = [];
+	this.colors = [];
+	this.faces = [];
+	this.faceVertexUvs = [ [] ];
+
+	this.morphTargets = [];
+	this.morphNormals = [];
+
+	this.skinWeights = [];
+	this.skinIndices = [];
+
+	this.lineDistances = [];
+
+	this.boundingBox = null;
+	this.boundingSphere = null;
+
+	// update flags
+
+	this.verticesNeedUpdate = false;
+	this.elementsNeedUpdate = false;
+	this.uvsNeedUpdate = false;
+	this.normalsNeedUpdate = false;
+	this.colorsNeedUpdate = false;
+	this.lineDistancesNeedUpdate = false;
+	this.groupsNeedUpdate = false;
+
+};
+
+THREE.Geometry.prototype = {
+
+	constructor: THREE.Geometry,
+
+	applyMatrix: function ( matrix ) {
+
+		var normalMatrix = new THREE.Matrix3().getNormalMatrix( matrix );
+
+		for ( var i = 0, il = this.vertices.length; i < il; i ++ ) {
+
+			var vertex = this.vertices[ i ];
+			vertex.applyMatrix4( matrix );
+
+		}
+
+		for ( var i = 0, il = this.faces.length; i < il; i ++ ) {
+
+			var face = this.faces[ i ];
+			face.normal.applyMatrix3( normalMatrix ).normalize();
+
+			for ( var j = 0, jl = face.vertexNormals.length; j < jl; j ++ ) {
+
+				face.vertexNormals[ j ].applyMatrix3( normalMatrix ).normalize();
+
+			}
+
+		}
+
+		if ( this.boundingBox !== null ) {
+
+			this.computeBoundingBox();
+
+		}
+
+		if ( this.boundingSphere !== null ) {
+
+			this.computeBoundingSphere();
+
+		}
+
+		this.verticesNeedUpdate = true;
+		this.normalsNeedUpdate = true;
+
+		return this;
+
+	},
+
+	rotateX: function () {
+
+		// rotate geometry around world x-axis
+
+		var m1;
+
+		return function rotateX( angle ) {
+
+			if ( m1 === undefined ) m1 = new THREE.Matrix4();
+
+			m1.makeRotationX( angle );
+
+			this.applyMatrix( m1 );
+
+			return this;
+
+		};
+
+	}(),
+
+	rotateY: function () {
+
+		// rotate geometry around world y-axis
+
+		var m1;
+
+		return function rotateY( angle ) {
+
+			if ( m1 === undefined ) m1 = new THREE.Matrix4();
+
+			m1.makeRotationY( angle );
+
+			this.applyMatrix( m1 );
+
+			return this;
+
+		};
+
+	}(),
+
+	rotateZ: function () {
+
+		// rotate geometry around world z-axis
+
+		var m1;
+
+		return function rotateZ( angle ) {
+
+			if ( m1 === undefined ) m1 = new THREE.Matrix4();
+
+			m1.makeRotationZ( angle );
+
+			this.applyMatrix( m1 );
+
+			return this;
+
+		};
+
+	}(),
+
+	translate: function () {
+
+		// translate geometry
+
+		var m1;
+
+		return function translate( x, y, z ) {
+
+			if ( m1 === undefined ) m1 = new THREE.Matrix4();
+
+			m1.makeTranslation( x, y, z );
+
+			this.applyMatrix( m1 );
+
+			return this;
+
+		};
+
+	}(),
+
+	scale: function () {
+
+		// scale geometry
+
+		var m1;
+
+		return function scale( x, y, z ) {
+
+			if ( m1 === undefined ) m1 = new THREE.Matrix4();
+
+			m1.makeScale( x, y, z );
+
+			this.applyMatrix( m1 );
+
+			return this;
+
+		};
+
+	}(),
+
+	lookAt: function () {
+
+		var obj;
+
+		return function lookAt( vector ) {
+
+			if ( obj === undefined ) obj = new THREE.Object3D();
+
+			obj.lookAt( vector );
+
+			obj.updateMatrix();
+
+			this.applyMatrix( obj.matrix );
+
+		};
+
+	}(),
+
+	fromBufferGeometry: function ( geometry ) {
+
+		var scope = this;
+
+		var indices = geometry.index !== null ? geometry.index.array : undefined;
+		var attributes = geometry.attributes;
+
+		var positions = attributes.position.array;
+		var normals = attributes.normal !== undefined ? attributes.normal.array : undefined;
+		var colors = attributes.color !== undefined ? attributes.color.array : undefined;
+		var uvs = attributes.uv !== undefined ? attributes.uv.array : undefined;
+		var uvs2 = attributes.uv2 !== undefined ? attributes.uv2.array : undefined;
+
+		if ( uvs2 !== undefined ) this.faceVertexUvs[ 1 ] = [];
+
+		var tempNormals = [];
+		var tempUVs = [];
+		var tempUVs2 = [];
+
+		for ( var i = 0, j = 0; i < positions.length; i += 3, j += 2 ) {
+
+			scope.vertices.push( new THREE.Vector3( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] ) );
+
+			if ( normals !== undefined ) {
+
+				tempNormals.push( new THREE.Vector3( normals[ i ], normals[ i + 1 ], normals[ i + 2 ] ) );
+
+			}
+
+			if ( colors !== undefined ) {
+
+				scope.colors.push( new THREE.Color( colors[ i ], colors[ i + 1 ], colors[ i + 2 ] ) );
+
+			}
+
+			if ( uvs !== undefined ) {
+
+				tempUVs.push( new THREE.Vector2( uvs[ j ], uvs[ j + 1 ] ) );
+
+			}
+
+			if ( uvs2 !== undefined ) {
+
+				tempUVs2.push( new THREE.Vector2( uvs2[ j ], uvs2[ j + 1 ] ) );
+
+			}
+
+		}
+
+		function addFace( a, b, c, materialIndex ) {
+
+			var vertexNormals = normals !== undefined ? [ tempNormals[ a ].clone(), tempNormals[ b ].clone(), tempNormals[ c ].clone() ] : [];
+			var vertexColors = colors !== undefined ? [ scope.colors[ a ].clone(), scope.colors[ b ].clone(), scope.colors[ c ].clone() ] : [];
+
+			var face = new THREE.Face3( a, b, c, vertexNormals, vertexColors, materialIndex );
+
+			scope.faces.push( face );
+
+			if ( uvs !== undefined ) {
+
+				scope.faceVertexUvs[ 0 ].push( [ tempUVs[ a ].clone(), tempUVs[ b ].clone(), tempUVs[ c ].clone() ] );
+
+			}
+
+			if ( uvs2 !== undefined ) {
+
+				scope.faceVertexUvs[ 1 ].push( [ tempUVs2[ a ].clone(), tempUVs2[ b ].clone(), tempUVs2[ c ].clone() ] );
+
+			}
+
+		}
+
+		if ( indices !== undefined ) {
+
+			var groups = geometry.groups;
+
+			if ( groups.length > 0 ) {
+
+				for ( var i = 0; i < groups.length; i ++ ) {
+
+					var group = groups[ i ];
+
+					var start = group.start;
+					var count = group.count;
+
+					for ( var j = start, jl = start + count; j < jl; j += 3 ) {
+
+						addFace( indices[ j ], indices[ j + 1 ], indices[ j + 2 ], group.materialIndex  );
+
+					}
+
+				}
+
+			} else {
+
+				for ( var i = 0; i < indices.length; i += 3 ) {
+
+					addFace( indices[ i ], indices[ i + 1 ], indices[ i + 2 ] );
+
+				}
+
+			}
+
+		} else {
+
+			for ( var i = 0; i < positions.length / 3; i += 3 ) {
+
+				addFace( i, i + 1, i + 2 );
+
+			}
+
+		}
+
+		this.computeFaceNormals();
+
+		if ( geometry.boundingBox !== null ) {
+
+			this.boundingBox = geometry.boundingBox.clone();
+
+		}
+
+		if ( geometry.boundingSphere !== null ) {
+
+			this.boundingSphere = geometry.boundingSphere.clone();
+
+		}
+
+		return this;
+
+	},
+
+	center: function () {
+
+		this.computeBoundingBox();
+
+		var offset = this.boundingBox.center().negate();
+
+		this.translate( offset.x, offset.y, offset.z );
+
+		return offset;
+
+	},
+
+	normalize: function () {
+
+		this.computeBoundingSphere();
+
+		var center = this.boundingSphere.center;
+		var radius = this.boundingSphere.radius;
+
+		var s = radius === 0 ? 1 : 1.0 / radius;
+
+		var matrix = new THREE.Matrix4();
+		matrix.set(
+			s, 0, 0, - s * center.x,
+			0, s, 0, - s * center.y,
+			0, 0, s, - s * center.z,
+			0, 0, 0, 1
+		);
+
+		this.applyMatrix( matrix );
+
+		return this;
+
+	},
+
+	computeFaceNormals: function () {
+
+		var cb = new THREE.Vector3(), ab = new THREE.Vector3();
+
+		for ( var f = 0, fl = this.faces.length; f < fl; f ++ ) {
+
+			var face = this.faces[ f ];
+
+			var vA = this.vertices[ face.a ];
+			var vB = this.vertices[ face.b ];
+			var vC = this.vertices[ face.c ];
+
+			cb.subVectors( vC, vB );
+			ab.subVectors( vA, vB );
+			cb.cross( ab );
+
+			cb.normalize();
+
+			face.normal.copy( cb );
+
+		}
+
+	},
+
+	computeVertexNormals: function ( areaWeighted ) {
+
+		if ( areaWeighted === undefined ) areaWeighted = true;
+
+		var v, vl, f, fl, face, vertices;
+
+		vertices = new Array( this.vertices.length );
+
+		for ( v = 0, vl = this.vertices.length; v < vl; v ++ ) {
+
+			vertices[ v ] = new THREE.Vector3();
+
+		}
+
+		if ( areaWeighted ) {
+
+			// vertex normals weighted by triangle areas
+			// http://www.iquilezles.org/www/articles/normals/normals.htm
+
+			var vA, vB, vC;
+			var cb = new THREE.Vector3(), ab = new THREE.Vector3();
+
+			for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
+
+				face = this.faces[ f ];
+
+				vA = this.vertices[ face.a ];
+				vB = this.vertices[ face.b ];
+				vC = this.vertices[ face.c ];
+
+				cb.subVectors( vC, vB );
+				ab.subVectors( vA, vB );
+				cb.cross( ab );
+
+				vertices[ face.a ].add( cb );
+				vertices[ face.b ].add( cb );
+				vertices[ face.c ].add( cb );
+
+			}
+
+		} else {
+
+			for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
+
+				face = this.faces[ f ];
+
+				vertices[ face.a ].add( face.normal );
+				vertices[ face.b ].add( face.normal );
+				vertices[ face.c ].add( face.normal );
+
+			}
+
+		}
+
+		for ( v = 0, vl = this.vertices.length; v < vl; v ++ ) {
+
+			vertices[ v ].normalize();
+
+		}
+
+		for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
+
+			face = this.faces[ f ];
+
+			var vertexNormals = face.vertexNormals;
+
+			if ( vertexNormals.length === 3 ) {
+
+				vertexNormals[ 0 ].copy( vertices[ face.a ] );
+				vertexNormals[ 1 ].copy( vertices[ face.b ] );
+				vertexNormals[ 2 ].copy( vertices[ face.c ] );
+
+			} else {
+
+				vertexNormals[ 0 ] = vertices[ face.a ].clone();
+				vertexNormals[ 1 ] = vertices[ face.b ].clone();
+				vertexNormals[ 2 ] = vertices[ face.c ].clone();
+
+			}
+
+		}
+
+		if ( this.faces.length > 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 < fl; f ++ ) {
+
+			face = this.faces[ f ];
+
+			if ( ! face.__originalFaceNormal ) {
+
+				face.__originalFaceNormal = face.normal.clone();
+
+			} else {
+
+				face.__originalFaceNormal.copy( face.normal );
+
+			}
+
+			if ( ! face.__originalVertexNormals ) face.__originalVertexNormals = [];
+
+			for ( i = 0, il = face.vertexNormals.length; i < il; i ++ ) {
+
+				if ( ! face.__originalVertexNormals[ i ] ) {
+
+					face.__originalVertexNormals[ i ] = face.vertexNormals[ i ].clone();
+
+				} else {
+
+					face.__originalVertexNormals[ i ].copy( face.vertexNormals[ i ] );
+
+				}
+
+			}
+
+		}
+
+		// use temp geometry to compute face and vertex normals for each morph
+
+		var tmpGeo = new THREE.Geometry();
+		tmpGeo.faces = this.faces;
+
+		for ( i = 0, il = this.morphTargets.length; i < il; i ++ ) {
+
+			// create on first access
+
+			if ( ! this.morphNormals[ i ] ) {
+
+				this.morphNormals[ i ] = {};
+				this.morphNormals[ i ].faceNormals = [];
+				this.morphNormals[ i ].vertexNormals = [];
+
+				var dstNormalsFace = this.morphNormals[ i ].faceNormals;
+				var dstNormalsVertex = this.morphNormals[ i ].vertexNormals;
+
+				var faceNormal, vertexNormals;
+
+				for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
+
+					faceNormal = new THREE.Vector3();
+					vertexNormals = { a: new THREE.Vector3(), b: new THREE.Vector3(), c: new THREE.Vector3() };
+
+					dstNormalsFace.push( faceNormal );
+					dstNormalsVertex.push( vertexNormals );
+
+				}
+
+			}
+
+			var morphNormals = this.morphNormals[ i ];
+
+			// set vertices to morph target
+
+			tmpGeo.vertices = this.morphTargets[ i ].vertices;
+
+			// compute morph normals
+
+			tmpGeo.computeFaceNormals();
+			tmpGeo.computeVertexNormals();
+
+			// store morph normals
+
+			var faceNormal, vertexNormals;
+
+			for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
+
+				face = this.faces[ f ];
+
+				faceNormal = morphNormals.faceNormals[ f ];
+				vertexNormals = morphNormals.vertexNormals[ f ];
+
+				faceNormal.copy( face.normal );
+
+				vertexNormals.a.copy( face.vertexNormals[ 0 ] );
+				vertexNormals.b.copy( face.vertexNormals[ 1 ] );
+				vertexNormals.c.copy( face.vertexNormals[ 2 ] );
+
+			}
+
+		}
+
+		// restore original normals
+
+		for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
+
+			face = this.faces[ f ];
+
+			face.normal = face.__originalFaceNormal;
+			face.vertexNormals = face.__originalVertexNormals;
+
+		}
+
+	},
+
+	computeTangents: function () {
+
+		console.warn( 'THREE.Geometry: .computeTangents() has been removed.' );
+
+	},
+
+	computeLineDistances: function () {
+
+		var d = 0;
+		var vertices = this.vertices;
+
+		for ( var i = 0, il = vertices.length; i < il; i ++ ) {
+
+			if ( i > 0 ) {
+
+				d += vertices[ i ].distanceTo( vertices[ i - 1 ] );
+
+			}
+
+			this.lineDistances[ i ] = d;
+
+		}
+
+	},
+
+	computeBoundingBox: function () {
+
+		if ( this.boundingBox === null ) {
+
+			this.boundingBox = new THREE.Box3();
+
+		}
+
+		this.boundingBox.setFromPoints( this.vertices );
+
+	},
+
+	computeBoundingSphere: function () {
+
+		if ( this.boundingSphere === null ) {
+
+			this.boundingSphere = new THREE.Sphere();
+
+		}
+
+		this.boundingSphere.setFromPoints( this.vertices );
+
+	},
+
+	merge: function ( geometry, matrix, materialIndexOffset ) {
+
+		if ( geometry instanceof THREE.Geometry === false ) {
+
+			console.error( 'THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.', geometry );
+			return;
+
+		}
+
+		var normalMatrix,
+		vertexOffset = this.vertices.length,
+		vertices1 = this.vertices,
+		vertices2 = geometry.vertices,
+		faces1 = this.faces,
+		faces2 = geometry.faces,
+		uvs1 = this.faceVertexUvs[ 0 ],
+		uvs2 = geometry.faceVertexUvs[ 0 ];
+
+		if ( materialIndexOffset === undefined ) materialIndexOffset = 0;
+
+		if ( matrix !== undefined ) {
+
+			normalMatrix = new THREE.Matrix3().getNormalMatrix( matrix );
+
+		}
+
+		// vertices
+
+		for ( var i = 0, il = vertices2.length; i < il; i ++ ) {
+
+			var vertex = vertices2[ i ];
+
+			var vertexCopy = vertex.clone();
+
+			if ( matrix !== undefined ) vertexCopy.applyMatrix4( matrix );
+
+			vertices1.push( vertexCopy );
+
+		}
+
+		// faces
+
+		for ( i = 0, il = faces2.length; i < il; i ++ ) {
+
+			var face = faces2[ i ], faceCopy, normal, color,
+			faceVertexNormals = face.vertexNormals,
+			faceVertexColors = face.vertexColors;
+
+			faceCopy = new THREE.Face3( face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset );
+			faceCopy.normal.copy( face.normal );
+
+			if ( normalMatrix !== undefined ) {
+
+				faceCopy.normal.applyMatrix3( normalMatrix ).normalize();
+
+			}
+
+			for ( var j = 0, jl = faceVertexNormals.length; j < jl; j ++ ) {
+
+				normal = faceVertexNormals[ j ].clone();
+
+				if ( normalMatrix !== undefined ) {
+
+					normal.applyMatrix3( normalMatrix ).normalize();
+
+				}
+
+				faceCopy.vertexNormals.push( normal );
+
+			}
+
+			faceCopy.color.copy( face.color );
+
+			for ( var j = 0, jl = faceVertexColors.length; j < jl; j ++ ) {
+
+				color = faceVertexColors[ j ];
+				faceCopy.vertexColors.push( color.clone() );
+
+			}
+
+			faceCopy.materialIndex = face.materialIndex + materialIndexOffset;
+
+			faces1.push( faceCopy );
+
+		}
+
+		// uvs
+
+		for ( i = 0, il = uvs2.length; i < il; i ++ ) {
+
+			var uv = uvs2[ i ], uvCopy = [];
+
+			if ( uv === undefined ) {
+
+				continue;
+
+			}
+
+			for ( var j = 0, jl = uv.length; j < jl; j ++ ) {
+
+				uvCopy.push( uv[ j ].clone() );
+
+			}
+
+			uvs1.push( uvCopy );
+
+		}
+
+	},
+
+	mergeMesh: function ( mesh ) {
+
+		if ( mesh instanceof THREE.Mesh === false ) {
+
+			console.error( 'THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh );
+			return;
+
+		}
+
+		mesh.matrixAutoUpdate && mesh.updateMatrix();
+
+		this.merge( mesh.geometry, mesh.matrix );
+
+	},
+
+	/*
+	 * Checks for duplicate vertices with hashmap.
+	 * Duplicated vertices are removed
+	 * and faces' vertices are updated.
+	 */
+
+	mergeVertices: function () {
+
+		var verticesMap = {}; // Hashmap for looking up vertices by position coordinates (and making sure they are unique)
+		var unique = [], changes = [];
+
+		var v, key;
+		var precisionPoints = 4; // number of decimal points, e.g. 4 for epsilon of 0.0001
+		var precision = Math.pow( 10, precisionPoints );
+		var i, il, face;
+		var indices, j, jl;
+
+		for ( i = 0, il = this.vertices.length; i < il; i ++ ) {
+
+			v = this.vertices[ i ];
+			key = Math.round( v.x * precision ) + '_' + Math.round( v.y * precision ) + '_' + Math.round( v.z * precision );
+
+			if ( verticesMap[ key ] === undefined ) {
+
+				verticesMap[ key ] = i;
+				unique.push( this.vertices[ i ] );
+				changes[ i ] = unique.length - 1;
+
+			} else {
+
+				//console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]);
+				changes[ i ] = changes[ verticesMap[ key ] ];
+
+			}
+
+		}
+
+
+		// if faces are completely degenerate after merging vertices, we
+		// have to remove them from the geometry.
+		var faceIndicesToRemove = [];
+
+		for ( i = 0, il = this.faces.length; i < il; i ++ ) {
+
+			face = this.faces[ i ];
+
+			face.a = changes[ face.a ];
+			face.b = changes[ face.b ];
+			face.c = changes[ face.c ];
+
+			indices = [ face.a, face.b, face.c ];
+
+			var dupIndex = - 1;
+
+			// if any duplicate vertices are found in a Face3
+			// we have to remove the face as nothing can be saved
+			for ( var n = 0; n < 3; n ++ ) {
+
+				if ( indices[ n ] === indices[ ( n + 1 ) % 3 ] ) {
+
+					dupIndex = n;
+					faceIndicesToRemove.push( i );
+					break;
+
+				}
+
+			}
+
+		}
+
+		for ( i = faceIndicesToRemove.length - 1; i >= 0; i -- ) {
+
+			var idx = faceIndicesToRemove[ i ];
+
+			this.faces.splice( idx, 1 );
+
+			for ( j = 0, jl = this.faceVertexUvs.length; j < jl; j ++ ) {
+
+				this.faceVertexUvs[ j ].splice( idx, 1 );
+
+			}
+
+		}
+
+		// Use unique set of vertices
+
+		var diff = this.vertices.length - unique.length;
+		this.vertices = unique;
+		return diff;
+
+	},
+
+	sortFacesByMaterialIndex: function () {
+
+		var faces = this.faces;
+		var length = faces.length;
+
+		// tag faces
+
+		for ( var i = 0; i < length; i ++ ) {
+
+			faces[ i ]._id = i;
+
+		}
+
+		// sort faces
+
+		function materialIndexSort( a, b ) {
+
+			return a.materialIndex - b.materialIndex;
+
+		}
+
+		faces.sort( materialIndexSort );
+
+		// sort uvs
+
+		var uvs1 = this.faceVertexUvs[ 0 ];
+		var uvs2 = this.faceVertexUvs[ 1 ];
+
+		var newUvs1, newUvs2;
+
+		if ( uvs1 && uvs1.length === length ) newUvs1 = [];
+		if ( uvs2 && uvs2.length === length ) newUvs2 = [];
+
+		for ( var i = 0; i < length; i ++ ) {
+
+			var id = faces[ i ]._id;
+
+			if ( newUvs1 ) newUvs1.push( uvs1[ id ] );
+			if ( newUvs2 ) newUvs2.push( uvs2[ id ] );
+
+		}
+
+		if ( newUvs1 ) this.faceVertexUvs[ 0 ] = newUvs1;
+		if ( newUvs2 ) this.faceVertexUvs[ 1 ] = newUvs2;
+
+	},
+
+	toJSON: function () {
+
+		var data = {
+			metadata: {
+				version: 4.4,
+				type: 'Geometry',
+				generator: 'Geometry.toJSON'
+			}
+		};
+
+		// standard Geometry serialization
+
+		data.uuid = this.uuid;
+		data.type = this.type;
+		if ( this.name !== '' ) data.name = this.name;
+
+		if ( this.parameters !== undefined ) {
+
+			var parameters = this.parameters;
+
+			for ( var key in parameters ) {
+
+				if ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ];
+
+			}
+
+			return data;
+
+		}
+
+		var vertices = [];
+
+		for ( var i = 0; i < this.vertices.length; i ++ ) {
+
+			var vertex = this.vertices[ i ];
+			vertices.push( vertex.x, vertex.y, vertex.z );
+
+		}
+
+		var faces = [];
+		var normals = [];
+		var normalsHash = {};
+		var colors = [];
+		var colorsHash = {};
+		var uvs = [];
+		var uvsHash = {};
+
+		for ( var i = 0; i < this.faces.length; i ++ ) {
+
+			var face = this.faces[ i ];
+
+			var hasMaterial = true;
+			var hasFaceUv = false; // deprecated
+			var hasFaceVertexUv = this.faceVertexUvs[ 0 ][ i ] !== undefined;
+			var hasFaceNormal = face.normal.length() > 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 << position ) : value & ( ~ ( 1 << position ) );
+
+		}
+
+		function getNormalIndex( normal ) {
+
+			var hash = normal.x.toString() + normal.y.toString() + normal.z.toString();
+
+			if ( normalsHash[ hash ] !== undefined ) {
+
+				return normalsHash[ hash ];
+
+			}
+
+			normalsHash[ hash ] = normals.length / 3;
+			normals.push( normal.x, normal.y, normal.z );
+
+			return normalsHash[ hash ];
+
+		}
+
+		function getColorIndex( color ) {
+
+			var hash = color.r.toString() + color.g.toString() + color.b.toString();
+
+			if ( colorsHash[ hash ] !== undefined ) {
+
+				return colorsHash[ hash ];
+
+			}
+
+			colorsHash[ hash ] = colors.length;
+			colors.push( color.getHex() );
+
+			return colorsHash[ hash ];
+
+		}
+
+		function getUvIndex( uv ) {
+
+			var hash = uv.x.toString() + uv.y.toString();
+
+			if ( uvsHash[ hash ] !== undefined ) {
+
+				return uvsHash[ hash ];
+
+			}
+
+			uvsHash[ hash ] = uvs.length / 2;
+			uvs.push( uv.x, uv.y );
+
+			return uvsHash[ hash ];
+
+		}
+
+		data.data = {};
+
+		data.data.vertices = vertices;
+		data.data.normals = normals;
+		if ( colors.length > 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 THREE.Geometry().copy( this );
+
+	},
+
+	copy: function ( source ) {
+
+		this.vertices = [];
+		this.faces = [];
+		this.faceVertexUvs = [ [] ];
+
+		var vertices = source.vertices;
+
+		for ( var i = 0, il = vertices.length; i < il; i ++ ) {
+
+			this.vertices.push( vertices[ i ].clone() );
+
+		}
+
+		var faces = source.faces;
+
+		for ( var i = 0, il = faces.length; i < il; i ++ ) {
+
+			this.faces.push( faces[ i ].clone() );
+
+		}
+
+		for ( var i = 0, il = source.faceVertexUvs.length; i < il; i ++ ) {
+
+			var faceVertexUvs = source.faceVertexUvs[ i ];
+
+			if ( this.faceVertexUvs[ i ] === undefined ) {
+
+				this.faceVertexUvs[ i ] = [];
+
+			}
+
+			for ( var j = 0, jl = faceVertexUvs.length; j < jl; j ++ ) {
+
+				var uvs = faceVertexUvs[ j ], uvsCopy = [];
+
+				for ( var k = 0, kl = uvs.length; k < kl; k ++ ) {
+
+					var uv = uvs[ k ];
+
+					uvsCopy.push( uv.clone() );
+
+				}
+
+				this.faceVertexUvs[ i ].push( uvsCopy );
+
+			}
+
+		}
+
+		return this;
+
+	},
+
+	dispose: function () {
+
+		this.dispatchEvent( { type: 'dispose' } );
+
+	}
+
+};
+
+THREE.EventDispatcher.prototype.apply( THREE.Geometry.prototype );
+
+THREE.GeometryIdCount = 0;
+
+// File:src/core/DirectGeometry.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.DirectGeometry = function () {
+
+	Object.defineProperty( this, 'id', { value: THREE.GeometryIdCount ++ } );
+
+	this.uuid = THREE.Math.generateUUID();
+
+	this.name = '';
+	this.type = 'DirectGeometry';
+
+	this.indices = [];
+	this.vertices = [];
+	this.normals = [];
+	this.colors = [];
+	this.uvs = [];
+	this.uvs2 = [];
+
+	this.groups = [];
+
+	this.morphTargets = {};
+
+	this.skinWeights = [];
+	this.skinIndices = [];
+
+	// this.lineDistances = [];
+
+	this.boundingBox = null;
+	this.boundingSphere = null;
+
+	// update flags
+
+	this.verticesNeedUpdate = false;
+	this.normalsNeedUpdate = false;
+	this.colorsNeedUpdate = false;
+	this.uvsNeedUpdate = false;
+	this.groupsNeedUpdate = false;
+
+};
+
+THREE.DirectGeometry.prototype = {
+
+	constructor: THREE.DirectGeometry,
+
+	computeBoundingBox: THREE.Geometry.prototype.computeBoundingBox,
+	computeBoundingSphere: THREE.Geometry.prototype.computeBoundingSphere,
+
+	computeFaceNormals: function () {
+
+		console.warn( 'THREE.DirectGeometry: computeFaceNormals() is not a method of this type of geometry.' );
+
+	},
+
+	computeVertexNormals: function () {
+
+		console.warn( 'THREE.DirectGeometry: computeVertexNormals() is not a method of this type of geometry.' );
+
+	},
+
+	computeGroups: function ( geometry ) {
+
+		var group;
+		var groups = [];
+		var materialIndex;
+
+		var faces = geometry.faces;
+
+		for ( var i = 0; i < faces.length; i ++ ) {
+
+			var face = faces[ i ];
+
+			// materials
+
+			if ( face.materialIndex !== materialIndex ) {
+
+				materialIndex = face.materialIndex;
+
+				if ( group !== undefined ) {
+
+					group.count = ( i * 3 ) - group.start;
+					groups.push( group );
+
+				}
+
+				group = {
+					start: i * 3,
+					materialIndex: materialIndex
+				};
+
+			}
+
+		}
+
+		if ( group !== undefined ) {
+
+			group.count = ( i * 3 ) - group.start;
+			groups.push( group );
+
+		}
+
+		this.groups = groups;
+
+	},
+
+	fromGeometry: function ( geometry ) {
+
+		var faces = geometry.faces;
+		var vertices = geometry.vertices;
+		var faceVertexUvs = geometry.faceVertexUvs;
+
+		var hasFaceVertexUv = faceVertexUvs[ 0 ] && faceVertexUvs[ 0 ].length > 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 < morphTargetsLength; i ++ ) {
+
+				morphTargetsPosition[ i ] = [];
+
+			}
+
+			this.morphTargets.position = morphTargetsPosition;
+
+		}
+
+		var morphNormals = geometry.morphNormals;
+		var morphNormalsLength = morphNormals.length;
+
+		var morphTargetsNormal;
+
+		if ( morphNormalsLength > 0 ) {
+
+			morphTargetsNormal = [];
+
+			for ( var i = 0; i < morphNormalsLength; i ++ ) {
+
+				morphTargetsNormal[ i ] = [];
+
+			}
+
+			this.morphTargets.normal = morphTargetsNormal;
+
+		}
+
+		// skins
+
+		var skinIndices = geometry.skinIndices;
+		var skinWeights = geometry.skinWeights;
+
+		var hasSkinIndices = skinIndices.length === vertices.length;
+		var hasSkinWeights = skinWeights.length === vertices.length;
+
+		//
+
+		for ( var i = 0; i < faces.length; i ++ ) {
+
+			var face = faces[ i ];
+
+			this.vertices.push( vertices[ face.a ], vertices[ face.b ], vertices[ face.c ] );
+
+			var vertexNormals = face.vertexNormals;
+
+			if ( vertexNormals.length === 3 ) {
+
+				this.normals.push( vertexNormals[ 0 ], vertexNormals[ 1 ], vertexNormals[ 2 ] );
+
+			} else {
+
+				var normal = face.normal;
+
+				this.normals.push( normal, normal, normal );
+
+			}
+
+			var vertexColors = face.vertexColors;
+
+			if ( vertexColors.length === 3 ) {
+
+				this.colors.push( vertexColors[ 0 ], vertexColors[ 1 ], vertexColors[ 2 ] );
+
+			} else {
+
+				var color = face.color;
+
+				this.colors.push( color, color, color );
+
+			}
+
+			if ( hasFaceVertexUv === true ) {
+
+				var vertexUvs = faceVertexUvs[ 0 ][ i ];
+
+				if ( vertexUvs !== undefined ) {
+
+					this.uvs.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] );
+
+				} else {
+
+					console.warn( 'THREE.DirectGeometry.fromGeometry(): Undefined vertexUv ', i );
+
+					this.uvs.push( new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2() );
+
+				}
+
+			}
+
+			if ( hasFaceVertexUv2 === true ) {
+
+				var vertexUvs = faceVertexUvs[ 1 ][ i ];
+
+				if ( vertexUvs !== undefined ) {
+
+					this.uvs2.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] );
+
+				} else {
+
+					console.warn( 'THREE.DirectGeometry.fromGeometry(): Undefined vertexUv2 ', i );
+
+					this.uvs2.push( new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2() );
+
+				}
+
+			}
+
+			// morphs
+
+			for ( var j = 0; j < morphTargetsLength; j ++ ) {
+
+				var morphTarget = morphTargets[ j ].vertices;
+
+				morphTargetsPosition[ j ].push( morphTarget[ face.a ], morphTarget[ face.b ], morphTarget[ face.c ] );
+
+			}
+
+			for ( var j = 0; j < morphNormalsLength; j ++ ) {
+
+				var morphNormal = morphNormals[ j ].vertexNormals[ i ];
+
+				morphTargetsNormal[ j ].push( morphNormal.a, morphNormal.b, morphNormal.c );
+
+			}
+
+			// skins
+
+			if ( hasSkinIndices ) {
+
+				this.skinIndices.push( skinIndices[ face.a ], skinIndices[ face.b ], skinIndices[ face.c ] );
+
+			}
+
+			if ( hasSkinWeights ) {
+
+				this.skinWeights.push( skinWeights[ face.a ], skinWeights[ face.b ], skinWeights[ face.c ] );
+
+			}
+
+		}
+
+		this.computeGroups( geometry );
+
+		this.verticesNeedUpdate = geometry.verticesNeedUpdate;
+		this.normalsNeedUpdate = geometry.normalsNeedUpdate;
+		this.colorsNeedUpdate = geometry.colorsNeedUpdate;
+		this.uvsNeedUpdate = geometry.uvsNeedUpdate;
+		this.groupsNeedUpdate = geometry.groupsNeedUpdate;
+
+		return this;
+
+	},
+
+	dispose: function () {
+
+		this.dispatchEvent( { type: 'dispose' } );
+
+	}
+
+};
+
+THREE.EventDispatcher.prototype.apply( THREE.DirectGeometry.prototype );
+
+// File:src/core/BufferGeometry.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.BufferGeometry = function () {
+
+	Object.defineProperty( this, 'id', { value: THREE.GeometryIdCount ++ } );
+
+	this.uuid = THREE.Math.generateUUID();
+
+	this.name = '';
+	this.type = 'BufferGeometry';
+
+	this.index = null;
+	this.attributes = {};
+
+	this.morphAttributes = {};
+
+	this.groups = [];
+
+	this.boundingBox = null;
+	this.boundingSphere = null;
+
+	this.drawRange = { start: 0, count: Infinity };
+
+};
+
+THREE.BufferGeometry.prototype = {
+
+	constructor: THREE.BufferGeometry,
+
+	getIndex: function () {
+
+		return this.index;
+
+	},
+
+	setIndex: function ( index ) {
+
+		this.index = index;
+
+	},
+
+	addAttribute: function ( name, attribute ) {
+
+		if ( attribute instanceof THREE.BufferAttribute === false && attribute instanceof THREE.InterleavedBufferAttribute === false ) {
+
+			console.warn( 'THREE.BufferGeometry: .addAttribute() now expects ( name, attribute ).' );
+
+			this.addAttribute( name, new THREE.BufferAttribute( arguments[ 1 ], arguments[ 2 ] ) );
+
+			return;
+
+		}
+
+		if ( name === 'index' ) {
+
+			console.warn( 'THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute.' );
+			this.setIndex( attribute );
+
+			return;
+
+		}
+
+		this.attributes[ name ] = attribute;
+
+		return this;
+
+	},
+
+	getAttribute: function ( name ) {
+
+		return this.attributes[ name ];
+
+	},
+
+	removeAttribute: 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;
+
+	},
+
+	applyMatrix: function ( matrix ) {
+
+		var position = this.attributes.position;
+
+		if ( position !== undefined ) {
+
+			matrix.applyToVector3Array( position.array );
+			position.needsUpdate = true;
+
+		}
+
+		var normal = this.attributes.normal;
+
+		if ( normal !== undefined ) {
+
+			var normalMatrix = new THREE.Matrix3().getNormalMatrix( matrix );
+
+			normalMatrix.applyToVector3Array( normal.array );
+			normal.needsUpdate = true;
+
+		}
+
+		if ( this.boundingBox !== null ) {
+
+			this.computeBoundingBox();
+
+		}
+
+		if ( this.boundingSphere !== null ) {
+
+			this.computeBoundingSphere();
+
+		}
+
+		return this;
+
+	},
+
+	rotateX: function () {
+
+		// rotate geometry around world x-axis
+
+		var m1;
+
+		return function rotateX( angle ) {
+
+			if ( m1 === undefined ) m1 = new THREE.Matrix4();
+
+			m1.makeRotationX( angle );
+
+			this.applyMatrix( m1 );
+
+			return this;
+
+		};
+
+	}(),
+
+	rotateY: function () {
+
+		// rotate geometry around world y-axis
+
+		var m1;
+
+		return function rotateY( angle ) {
+
+			if ( m1 === undefined ) m1 = new THREE.Matrix4();
+
+			m1.makeRotationY( angle );
+
+			this.applyMatrix( m1 );
+
+			return this;
+
+		};
+
+	}(),
+
+	rotateZ: function () {
+
+		// rotate geometry around world z-axis
+
+		var m1;
+
+		return function rotateZ( angle ) {
+
+			if ( m1 === undefined ) m1 = new THREE.Matrix4();
+
+			m1.makeRotationZ( angle );
+
+			this.applyMatrix( m1 );
+
+			return this;
+
+		};
+
+	}(),
+
+	translate: function () {
+
+		// translate geometry
+
+		var m1;
+
+		return function translate( x, y, z ) {
+
+			if ( m1 === undefined ) m1 = new THREE.Matrix4();
+
+			m1.makeTranslation( x, y, z );
+
+			this.applyMatrix( m1 );
+
+			return this;
+
+		};
+
+	}(),
+
+	scale: function () {
+
+		// scale geometry
+
+		var m1;
+
+		return function scale( x, y, z ) {
+
+			if ( m1 === undefined ) m1 = new THREE.Matrix4();
+
+			m1.makeScale( x, y, z );
+
+			this.applyMatrix( m1 );
+
+			return this;
+
+		};
+
+	}(),
+
+	lookAt: function () {
+
+		var obj;
+
+		return function lookAt( vector ) {
+
+			if ( obj === undefined ) obj = new THREE.Object3D();
+
+			obj.lookAt( vector );
+
+			obj.updateMatrix();
+
+			this.applyMatrix( obj.matrix );
+
+		};
+
+	}(),
+
+	center: function () {
+
+		this.computeBoundingBox();
+
+		var offset = this.boundingBox.center().negate();
+
+		this.translate( offset.x, offset.y, offset.z );
+
+		return offset;
+
+	},
+
+	setFromObject: function ( object ) {
+
+		// console.log( 'THREE.BufferGeometry.setFromObject(). Converting', object, this );
+
+		var geometry = object.geometry;
+
+		if ( object instanceof THREE.Points || object instanceof THREE.Line ) {
+
+			var positions = new THREE.Float32Attribute( geometry.vertices.length * 3, 3 );
+			var colors = new THREE.Float32Attribute( geometry.colors.length * 3, 3 );
+
+			this.addAttribute( 'position', positions.copyVector3sArray( geometry.vertices ) );
+			this.addAttribute( 'color', colors.copyColorsArray( geometry.colors ) );
+
+			if ( geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length ) {
+
+				var lineDistances = new THREE.Float32Attribute( geometry.lineDistances.length, 1 );
+
+				this.addAttribute( '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 instanceof THREE.Mesh ) {
+
+			if ( geometry instanceof THREE.Geometry ) {
+
+				this.fromGeometry( geometry );
+
+			}
+
+		}
+
+		return this;
+
+	},
+
+	updateFromObject: function ( object ) {
+
+		var geometry = object.geometry;
+
+		if ( object instanceof THREE.Mesh ) {
+
+			var direct = geometry.__directGeometry;
+
+			if ( direct === undefined ) {
+
+				return this.fromGeometry( geometry );
+
+			}
+
+			direct.verticesNeedUpdate = geometry.verticesNeedUpdate;
+			direct.normalsNeedUpdate = geometry.normalsNeedUpdate;
+			direct.colorsNeedUpdate = geometry.colorsNeedUpdate;
+			direct.uvsNeedUpdate = geometry.uvsNeedUpdate;
+			direct.groupsNeedUpdate = geometry.groupsNeedUpdate;
+
+			geometry.verticesNeedUpdate = false;
+			geometry.normalsNeedUpdate = false;
+			geometry.colorsNeedUpdate = false;
+			geometry.uvsNeedUpdate = false;
+			geometry.groupsNeedUpdate = false;
+
+			geometry = direct;
+
+		}
+
+		if ( geometry.verticesNeedUpdate === true ) {
+
+			var attribute = this.attributes.position;
+
+			if ( attribute !== undefined ) {
+
+				attribute.copyVector3sArray( geometry.vertices );
+				attribute.needsUpdate = true;
+
+			}
+
+			geometry.verticesNeedUpdate = false;
+
+		}
+
+		if ( geometry.normalsNeedUpdate === true ) {
+
+			var attribute = this.attributes.normal;
+
+			if ( attribute !== undefined ) {
+
+				attribute.copyVector3sArray( geometry.normals );
+				attribute.needsUpdate = true;
+
+			}
+
+			geometry.normalsNeedUpdate = false;
+
+		}
+
+		if ( geometry.colorsNeedUpdate === true ) {
+
+			var attribute = this.attributes.color;
+
+			if ( attribute !== undefined ) {
+
+				attribute.copyColorsArray( geometry.colors );
+				attribute.needsUpdate = true;
+
+			}
+
+			geometry.colorsNeedUpdate = false;
+
+		}
+
+		if ( geometry.uvsNeedUpdate ) {
+
+			var attribute = this.attributes.uv;
+
+			if ( attribute !== undefined ) {
+
+				attribute.copyVector2sArray( geometry.uvs );
+				attribute.needsUpdate = true;
+
+			}
+
+			geometry.uvsNeedUpdate = false;
+
+		}
+
+		if ( geometry.lineDistancesNeedUpdate ) {
+
+			var attribute = this.attributes.lineDistance;
+
+			if ( attribute !== undefined ) {
+
+				attribute.copyArray( geometry.lineDistances );
+				attribute.needsUpdate = true;
+
+			}
+
+			geometry.lineDistancesNeedUpdate = false;
+
+		}
+
+		if ( geometry.groupsNeedUpdate ) {
+
+			geometry.computeGroups( object.geometry );
+			this.groups = geometry.groups;
+
+			geometry.groupsNeedUpdate = false;
+
+		}
+
+		return this;
+
+	},
+
+	fromGeometry: function ( geometry ) {
+
+		geometry.__directGeometry = new THREE.DirectGeometry().fromGeometry( geometry );
+
+		return this.fromDirectGeometry( geometry.__directGeometry );
+
+	},
+
+	fromDirectGeometry: function ( geometry ) {
+
+		var positions = new Float32Array( geometry.vertices.length * 3 );
+		this.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ).copyVector3sArray( geometry.vertices ) );
+
+		if ( geometry.normals.length > 0 ) {
+
+			var normals = new Float32Array( geometry.normals.length * 3 );
+			this.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ).copyVector3sArray( geometry.normals ) );
+
+		}
+
+		if ( geometry.colors.length > 0 ) {
+
+			var colors = new Float32Array( geometry.colors.length * 3 );
+			this.addAttribute( 'color', new THREE.BufferAttribute( colors, 3 ).copyColorsArray( geometry.colors ) );
+
+		}
+
+		if ( geometry.uvs.length > 0 ) {
+
+			var uvs = new Float32Array( geometry.uvs.length * 2 );
+			this.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ).copyVector2sArray( geometry.uvs ) );
+
+		}
+
+		if ( geometry.uvs2.length > 0 ) {
+
+			var uvs2 = new Float32Array( geometry.uvs2.length * 2 );
+			this.addAttribute( 'uv2', new THREE.BufferAttribute( uvs2, 2 ).copyVector2sArray( geometry.uvs2 ) );
+
+		}
+
+		if ( geometry.indices.length > 0 ) {
+
+			var TypeArray = geometry.vertices.length > 65535 ? Uint32Array : Uint16Array;
+			var indices = new TypeArray( geometry.indices.length * 3 );
+			this.setIndex( new THREE.BufferAttribute( indices, 1 ).copyIndicesArray( geometry.indices ) );
+
+		}
+
+		// 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 < l; i ++ ) {
+
+				var morphTarget = morphTargets[ i ];
+
+				var attribute = new THREE.Float32Attribute( morphTarget.length * 3, 3 );
+
+				array.push( attribute.copyVector3sArray( morphTarget ) );
+
+			}
+
+			this.morphAttributes[ name ] = array;
+
+		}
+
+		// skinning
+
+		if ( geometry.skinIndices.length > 0 ) {
+
+			var skinIndices = new THREE.Float32Attribute( geometry.skinIndices.length * 4, 4 );
+			this.addAttribute( 'skinIndex', skinIndices.copyVector4sArray( geometry.skinIndices ) );
+
+		}
+
+		if ( geometry.skinWeights.length > 0 ) {
+
+			var skinWeights = new THREE.Float32Attribute( geometry.skinWeights.length * 4, 4 );
+			this.addAttribute( '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 THREE.Box3();
+
+		}
+
+		var positions = this.attributes.position.array;
+
+		if ( positions !== undefined ) {
+
+			this.boundingBox.setFromArray( positions );
+
+		} else {
+
+			this.boundingBox.makeEmpty();
+
+		}
+
+		if ( isNaN( this.boundingBox.min.x ) || isNaN( this.boundingBox.min.y ) || isNaN( this.boundingBox.min.z ) ) {
+
+			console.error( 'THREE.BufferGeometry.computeBoundingBox: Computed min/max have NaN values. The "position" attribute is likely to have NaN values.', this );
+
+		}
+
+	},
+
+	computeBoundingSphere: function () {
+
+		var box = new THREE.Box3();
+		var vector = new THREE.Vector3();
+
+		return function () {
+
+			if ( this.boundingSphere === null ) {
+
+				this.boundingSphere = new THREE.Sphere();
+
+			}
+
+			var positions = this.attributes.position.array;
+
+			if ( positions ) {
+
+				var center = this.boundingSphere.center;
+
+				box.setFromArray( positions );
+				box.center( center );
+
+				// hoping to find a boundingSphere with a radius smaller than the
+				// boundingSphere of the boundingBox: sqrt(3) smaller in the best case
+
+				var maxRadiusSq = 0;
+
+				for ( var i = 0, il = positions.length; i < il; i += 3 ) {
+
+					vector.fromArray( positions, i );
+					maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( vector ) );
+
+				}
+
+				this.boundingSphere.radius = Math.sqrt( maxRadiusSq );
+
+				if ( isNaN( this.boundingSphere.radius ) ) {
+
+					console.error( 'THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.', this );
+
+				}
+
+			}
+
+		};
+
+	}(),
+
+	computeFaceNormals: function () {
+
+		// backwards compatibility
+
+	},
+
+	computeVertexNormals: function () {
+
+		var index = this.index;
+		var attributes = this.attributes;
+		var groups = this.groups;
+
+		if ( attributes.position ) {
+
+			var positions = attributes.position.array;
+
+			if ( attributes.normal === undefined ) {
+
+				this.addAttribute( 'normal', new THREE.BufferAttribute( new Float32Array( positions.length ), 3 ) );
+
+			} else {
+
+				// reset existing normals to zero
+
+				var array = attributes.normal.array;
+
+				for ( var i = 0, il = array.length; i < il; i ++ ) {
+
+					array[ i ] = 0;
+
+				}
+
+			}
+
+			var normals = attributes.normal.array;
+
+			var vA, vB, vC,
+
+			pA = new THREE.Vector3(),
+			pB = new THREE.Vector3(),
+			pC = new THREE.Vector3(),
+
+			cb = new THREE.Vector3(),
+			ab = new THREE.Vector3();
+
+			// indexed elements
+
+			if ( index ) {
+
+				var indices = index.array;
+
+				if ( groups.length === 0 ) {
+
+					this.addGroup( 0, indices.length );
+
+				}
+
+				for ( var j = 0, jl = groups.length; j < jl; ++ j ) {
+
+					var group = groups[ j ];
+
+					var start = group.start;
+					var count = group.count;
+
+					for ( var i = start, il = start + count; i < il; i += 3 ) {
+
+						vA = indices[ i + 0 ] * 3;
+						vB = indices[ i + 1 ] * 3;
+						vC = indices[ i + 2 ] * 3;
+
+						pA.fromArray( positions, vA );
+						pB.fromArray( positions, vB );
+						pC.fromArray( positions, vC );
+
+						cb.subVectors( pC, pB );
+						ab.subVectors( pA, pB );
+						cb.cross( ab );
+
+						normals[ vA ] += cb.x;
+						normals[ vA + 1 ] += cb.y;
+						normals[ vA + 2 ] += cb.z;
+
+						normals[ vB ] += cb.x;
+						normals[ vB + 1 ] += cb.y;
+						normals[ vB + 2 ] += cb.z;
+
+						normals[ vC ] += cb.x;
+						normals[ vC + 1 ] += cb.y;
+						normals[ vC + 2 ] += cb.z;
+
+					}
+
+				}
+
+			} else {
+
+				// non-indexed elements (unconnected triangle soup)
+
+				for ( var i = 0, il = positions.length; i < il; i += 9 ) {
+
+					pA.fromArray( positions, i );
+					pB.fromArray( positions, i + 3 );
+					pC.fromArray( positions, i + 6 );
+
+					cb.subVectors( pC, pB );
+					ab.subVectors( pA, pB );
+					cb.cross( ab );
+
+					normals[ i ] = cb.x;
+					normals[ i + 1 ] = cb.y;
+					normals[ i + 2 ] = cb.z;
+
+					normals[ i + 3 ] = cb.x;
+					normals[ i + 4 ] = cb.y;
+					normals[ i + 5 ] = cb.z;
+
+					normals[ i + 6 ] = cb.x;
+					normals[ i + 7 ] = cb.y;
+					normals[ i + 8 ] = cb.z;
+
+				}
+
+			}
+
+			this.normalizeNormals();
+
+			attributes.normal.needsUpdate = true;
+
+		}
+
+	},
+
+	merge: function ( geometry, offset ) {
+
+		if ( geometry instanceof THREE.BufferGeometry === false ) {
+
+			console.error( 'THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.', geometry );
+			return;
+
+		}
+
+		if ( offset === undefined ) offset = 0;
+
+		var attributes = this.attributes;
+
+		for ( var key in attributes ) {
+
+			if ( geometry.attributes[ key ] === undefined ) continue;
+
+			var attribute1 = attributes[ key ];
+			var attributeArray1 = attribute1.array;
+
+			var attribute2 = geometry.attributes[ key ];
+			var attributeArray2 = attribute2.array;
+
+			var attributeSize = attribute2.itemSize;
+
+			for ( var i = 0, j = attributeSize * offset; i < attributeArray2.length; i ++, j ++ ) {
+
+				attributeArray1[ j ] = attributeArray2[ i ];
+
+			}
+
+		}
+
+		return this;
+
+	},
+
+	normalizeNormals: function () {
+
+		var normals = this.attributes.normal.array;
+
+		var x, y, z, n;
+
+		for ( var i = 0, il = normals.length; i < il; i += 3 ) {
+
+			x = normals[ i ];
+			y = normals[ i + 1 ];
+			z = normals[ i + 2 ];
+
+			n = 1.0 / Math.sqrt( x * x + y * y + z * z );
+
+			normals[ i ] *= n;
+			normals[ i + 1 ] *= n;
+			normals[ i + 2 ] *= n;
+
+		}
+
+	},
+
+	toNonIndexed: function () {
+
+		if ( this.index === null ) {
+
+			console.warn( 'THREE.BufferGeometry.toNonIndexed(): Geometry is already non-indexed.' );
+			return this;
+
+		}
+
+		var geometry2 = new THREE.BufferGeometry();
+
+		var indices = this.index.array;
+		var attributes = this.attributes;
+
+		for ( var name in attributes ) {
+
+			var attribute = attributes[ name ];
+
+			var array = attribute.array;
+			var itemSize = attribute.itemSize;
+
+			var array2 = new array.constructor( indices.length * itemSize );
+
+			var index = 0, index2 = 0;
+
+			for ( var i = 0, l = indices.length; i < l; i ++ ) {
+
+				index = indices[ i ] * itemSize;
+
+				for ( var j = 0; j < itemSize; j ++ ) {
+
+					array2[ index2 ++ ] = array[ index ++ ];
+
+				}
+
+			}
+
+			geometry2.addAttribute( name, new THREE.BufferAttribute( array2, itemSize ) );
+
+		}
+
+		return geometry2;
+
+	},
+
+	toJSON: function () {
+
+		var data = {
+			metadata: {
+				version: 4.4,
+				type: 'BufferGeometry',
+				generator: 'BufferGeometry.toJSON'
+			}
+		};
+
+		// standard BufferGeometry serialization
+
+		data.uuid = this.uuid;
+		data.type = this.type;
+		if ( this.name !== '' ) data.name = this.name;
+
+		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 ) {
+
+			var array = Array.prototype.slice.call( index.array );
+
+			data.data.index = {
+				type: index.array.constructor.name,
+				array: array
+			};
+
+		}
+
+		var attributes = this.attributes;
+
+		for ( var key in attributes ) {
+
+			var attribute = attributes[ key ];
+
+			var array = Array.prototype.slice.call( attribute.array );
+
+			data.data.attributes[ key ] = {
+				itemSize: attribute.itemSize,
+				type: attribute.array.constructor.name,
+				array: array,
+				normalized: attribute.normalized
+			};
+
+		}
+
+		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 THREE.BufferGeometry().copy( this );
+
+	},
+
+	copy: function ( source ) {
+
+		var index = source.index;
+
+		if ( index !== null ) {
+
+			this.setIndex( index.clone() );
+
+		}
+
+		var attributes = source.attributes;
+
+		for ( var name in attributes ) {
+
+			var attribute = attributes[ name ];
+			this.addAttribute( name, attribute.clone() );
+
+		}
+
+		var groups = source.groups;
+
+		for ( var i = 0, l = groups.length; i < l; i ++ ) {
+
+			var group = groups[ i ];
+			this.addGroup( group.start, group.count, group.materialIndex );
+
+		}
+
+		return this;
+
+	},
+
+	dispose: function () {
+
+		this.dispatchEvent( { type: 'dispose' } );
+
+	}
+
+};
+
+THREE.EventDispatcher.prototype.apply( THREE.BufferGeometry.prototype );
+
+THREE.BufferGeometry.MaxIndex = 65535;
+
+// File:src/core/InstancedBufferGeometry.js
+
+/**
+ * @author benaadams / https://twitter.com/ben_a_adams
+ */
+
+THREE.InstancedBufferGeometry = function () {
+
+	THREE.BufferGeometry.call( this );
+
+	this.type = 'InstancedBufferGeometry';
+	this.maxInstancedCount = undefined;
+
+};
+
+THREE.InstancedBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+THREE.InstancedBufferGeometry.prototype.constructor = THREE.InstancedBufferGeometry;
+
+THREE.InstancedBufferGeometry.prototype.addGroup = function ( start, count, instances ) {
+
+	this.groups.push( {
+
+		start: start,
+		count: count,
+		instances: instances
+
+	} );
+
+};
+
+THREE.InstancedBufferGeometry.prototype.copy = function ( source ) {
+
+	var index = source.index;
+
+	if ( index !== null ) {
+
+		this.setIndex( index.clone() );
+
+	}
+
+	var attributes = source.attributes;
+
+	for ( var name in attributes ) {
+
+		var attribute = attributes[ name ];
+		this.addAttribute( name, attribute.clone() );
+
+	}
+
+	var groups = source.groups;
+
+	for ( var i = 0, l = groups.length; i < l; i ++ ) {
+
+		var group = groups[ i ];
+		this.addGroup( group.start, group.count, group.instances );
+
+	}
+
+	return this;
+
+};
+
+THREE.EventDispatcher.prototype.apply( THREE.InstancedBufferGeometry.prototype );
+
+// File:src/core/Uniform.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.Uniform = function ( value ) {
+
+	if ( typeof value === 'string' ) {
+
+		console.warn( 'THREE.Uniform: Type parameter is no longer needed.' );
+		value = arguments[ 1 ];
+
+	}
+
+	this.value = value;
+
+	this.dynamic = false;
+
+};
+
+THREE.Uniform.prototype = {
+
+	constructor: THREE.Uniform,
+
+	onUpdate: function ( callback ) {
+
+		this.dynamic = true;
+		this.onUpdateCallback = callback;
+
+		return this;
+
+	}
+
+};
+
+// File:src/animation/AnimationClip.js
+
+/**
+ *
+ * Reusable set of Tracks that represent an animation.
+ *
+ * @author Ben Houston / http://clara.io/
+ * @author David Sarno / http://lighthaus.us/
+ */
+
+THREE.AnimationClip = function ( name, duration, tracks ) {
+
+	this.name = name || THREE.Math.generateUUID();
+	this.tracks = tracks;
+	this.duration = ( duration !== undefined ) ? duration : -1;
+
+	// this means it should figure out its duration by scanning the tracks
+	if ( this.duration < 0 ) {
+
+		this.resetDuration();
+
+	}
+
+	// maybe only do these on demand, as doing them here could potentially slow down loading
+	// but leaving these here during development as this ensures a lot of testing of these functions
+	this.trim();
+	this.optimize();
+
+};
+
+THREE.AnimationClip.prototype = {
+
+	constructor: THREE.AnimationClip,
+
+	resetDuration: function() {
+
+		var tracks = this.tracks,
+			duration = 0;
+
+		for ( var i = 0, n = tracks.length; i !== n; ++ i ) {
+
+			var track = this.tracks[ i ];
+
+			duration = Math.max(
+					duration, track.times[ track.times.length - 1 ] );
+
+		}
+
+		this.duration = duration;
+
+	},
+
+	trim: function() {
+
+		for ( var i = 0; i < this.tracks.length; i ++ ) {
+
+			this.tracks[ i ].trim( 0, this.duration );
+
+		}
+
+		return this;
+
+	},
+
+	optimize: function() {
+
+		for ( var i = 0; i < this.tracks.length; i ++ ) {
+
+			this.tracks[ i ].optimize();
+
+		}
+
+		return this;
+
+	}
+
+};
+
+// Static methods:
+
+Object.assign( THREE.AnimationClip, {
+
+	parse: function( json ) {
+
+		var tracks = [],
+			jsonTracks = json.tracks,
+			frameTime = 1.0 / ( json.fps || 1.0 );
+
+		for ( var i = 0, n = jsonTracks.length; i !== n; ++ i ) {
+
+			tracks.push( THREE.KeyframeTrack.parse( jsonTracks[ i ] ).scale( frameTime ) );
+
+		}
+
+		return new THREE.AnimationClip( json.name, json.duration, tracks );
+
+	},
+
+
+	toJSON: function( clip ) {
+
+		var tracks = [],
+			clipTracks = clip.tracks;
+
+		var json = {
+
+			'name': clip.name,
+			'duration': clip.duration,
+			'tracks': tracks
+
+		};
+
+		for ( var i = 0, n = clipTracks.length; i !== n; ++ i ) {
+
+			tracks.push( THREE.KeyframeTrack.toJSON( clipTracks[ i ] ) );
+
+		}
+
+		return json;
+
+	},
+
+
+	CreateFromMorphTargetSequence: function( name, morphTargetSequence, fps, noLoop ) {
+
+		var numMorphTargets = morphTargetSequence.length;
+		var tracks = [];
+
+		for ( var i = 0; i < numMorphTargets; i ++ ) {
+
+			var times = [];
+			var values = [];
+
+			times.push(
+					( i + numMorphTargets - 1 ) % numMorphTargets,
+					i,
+					( i + 1 ) % numMorphTargets );
+
+			values.push( 0, 1, 0 );
+
+			var order = THREE.AnimationUtils.getKeyframeOrder( times );
+			times = THREE.AnimationUtils.sortedArray( times, 1, order );
+			values = THREE.AnimationUtils.sortedArray( values, 1, order );
+
+			// if there is a key at the first frame, duplicate it as the
+			// last frame as well for perfect loop.
+			if ( ! noLoop && times[ 0 ] === 0 ) {
+
+				times.push( numMorphTargets );
+				values.push( values[ 0 ] );
+
+			}
+
+			tracks.push(
+					new THREE.NumberKeyframeTrack(
+						'.morphTargetInfluences[' + morphTargetSequence[ i ].name + ']',
+						times, values
+					).scale( 1.0 / fps ) );
+		}
+
+		return new THREE.AnimationClip( name, -1, tracks );
+
+	},
+
+	findByName: function( clipArray, name ) {
+
+		for ( var i = 0; i < clipArray.length; i ++ ) {
+
+			if ( clipArray[ i ].name === name ) {
+
+				return clipArray[ i ];
+
+			}
+		}
+
+		return null;
+
+	},
+
+	CreateClipsFromMorphTargetSequences: function( morphTargets, fps, noLoop ) {
+
+		var animationToMorphTargets = {};
+
+		// tested with https://regex101.com/ on trick sequences
+		// such flamingo_flyA_003, flamingo_run1_003, crdeath0059
+		var pattern = /^([\w-]*?)([\d]+)$/;
+
+		// sort morph target names into animation groups based
+		// patterns like Walk_001, Walk_002, Run_001, Run_002
+		for ( var i = 0, il = morphTargets.length; i < il; i ++ ) {
+
+			var morphTarget = morphTargets[ i ];
+			var parts = morphTarget.name.match( pattern );
+
+			if ( parts && parts.length > 1 ) {
+
+				var name = parts[ 1 ];
+
+				var animationMorphTargets = animationToMorphTargets[ name ];
+				if ( ! animationMorphTargets ) {
+
+					animationToMorphTargets[ name ] = animationMorphTargets = [];
+
+				}
+
+				animationMorphTargets.push( morphTarget );
+
+			}
+
+		}
+
+		var clips = [];
+
+		for ( var name in animationToMorphTargets ) {
+
+			clips.push( THREE.AnimationClip.CreateFromMorphTargetSequence( name, animationToMorphTargets[ name ], fps, noLoop ) );
+
+		}
+
+		return clips;
+
+	},
+
+	// parse the animation.hierarchy format
+	parseAnimation: function( animation, bones, nodeName ) {
+
+		if ( ! animation ) {
+
+			console.error( "  no animation in JSONLoader data" );
+			return null;
+
+		}
+
+		var addNonemptyTrack = function(
+				trackType, trackName, animationKeys, propertyName, destTracks ) {
+
+			// only return track if there are actually keys.
+			if ( animationKeys.length !== 0 ) {
+
+				var times = [];
+				var values = [];
+
+				THREE.AnimationUtils.flattenJSON(
+						animationKeys, times, values, propertyName );
+
+				// empty keys are filtered out, so check again
+				if ( times.length !== 0 ) {
+
+					destTracks.push( new trackType( trackName, times, values ) );
+
+				}
+
+			}
+
+		};
+
+		var tracks = [];
+
+		var clipName = animation.name || 'default';
+		// automatic length determination in AnimationClip.
+		var duration = animation.length || -1;
+		var fps = animation.fps || 30;
+
+		var hierarchyTracks = animation.hierarchy || [];
+
+		for ( var h = 0; h < hierarchyTracks.length; h ++ ) {
+
+			var animationKeys = hierarchyTracks[ h ].keys;
+
+			// skip empty tracks
+			if ( ! animationKeys || animationKeys.length == 0 ) continue;
+
+			// process morph targets in a way exactly compatible
+			// with AnimationHandler.init( animation )
+			if ( animationKeys[0].morphTargets ) {
+
+				// figure out all morph targets used in this track
+				var morphTargetNames = {};
+				for ( var k = 0; k < animationKeys.length; k ++ ) {
+
+					if ( animationKeys[k].morphTargets ) {
+
+						for ( var m = 0; m < animationKeys[k].morphTargets.length; m ++ ) {
+
+							morphTargetNames[ animationKeys[k].morphTargets[m] ] = -1;
+						}
+
+					}
+
+				}
+
+				// create a track for each morph target with all zero
+				// morphTargetInfluences except for the keys in which
+				// the morphTarget is named.
+				for ( var morphTargetName in morphTargetNames ) {
+
+					var times = [];
+					var values = [];
+
+					for ( var m = 0;
+							m !== animationKeys[k].morphTargets.length; ++ m ) {
+
+						var animationKey = animationKeys[k];
+
+						times.push( animationKey.time );
+						values.push( ( animationKey.morphTarget === morphTargetName ) ? 1 : 0 )
+
+					}
+
+					tracks.push( new THREE.NumberKeyframeTrack(
+							'.morphTargetInfluence[' + morphTargetName + ']', times, values ) );
+
+				}
+
+				duration = morphTargetNames.length * ( fps || 1.0 );
+
+			} else {
+				// ...assume skeletal animation
+
+				var boneName = '.bones[' + bones[ h ].name + ']';
+
+				addNonemptyTrack(
+						THREE.VectorKeyframeTrack, boneName + '.position',
+						animationKeys, 'pos', tracks );
+
+				addNonemptyTrack(
+						THREE.QuaternionKeyframeTrack, boneName + '.quaternion',
+						animationKeys, 'rot', tracks );
+
+				addNonemptyTrack(
+						THREE.VectorKeyframeTrack, boneName + '.scale',
+						animationKeys, 'scl', tracks );
+
+			}
+
+		}
+
+		if ( tracks.length === 0 ) {
+
+			return null;
+
+		}
+
+		var clip = new THREE.AnimationClip( clipName, duration, tracks );
+
+		return clip;
+
+	}
+
+} );
+
+
+// File:src/animation/AnimationMixer.js
+
+/**
+ *
+ * Player for AnimationClips.
+ *
+ *
+ * @author Ben Houston / http://clara.io/
+ * @author David Sarno / http://lighthaus.us/
+ * @author tschw
+ */
+
+THREE.AnimationMixer = function( root ) {
+
+	this._root = root;
+	this._initMemoryManager();
+	this._accuIndex = 0;
+
+	this.time = 0;
+
+	this.timeScale = 1.0;
+
+};
+
+THREE.AnimationMixer.prototype = {
+
+	constructor: THREE.AnimationMixer,
+
+	// return an action for a clip optionally using a custom root target
+	// object (this method allocates a lot of dynamic memory in case a
+	// previously unknown clip/root combination is specified)
+	clipAction: function( clip, optionalRoot ) {
+
+		var root = optionalRoot || this._root,
+			rootUuid = root.uuid,
+			clipName = ( typeof clip === 'string' ) ? clip : clip.name,
+			clipObject = ( clip !== clipName ) ? clip : null,
+
+			actionsForClip = this._actionsByClip[ clipName ],
+			prototypeAction;
+
+		if ( actionsForClip !== undefined ) {
+
+			var existingAction =
+					actionsForClip.actionByRoot[ rootUuid ];
+
+			if ( existingAction !== undefined ) {
+
+				return existingAction;
+
+			}
+
+			// we know the clip, so we don't have to parse all
+			// the bindings again but can just copy
+			prototypeAction = actionsForClip.knownActions[ 0 ];
+
+			// also, take the clip from the prototype action
+			clipObject = prototypeAction._clip;
+
+			if ( clip !== clipName && clip !== clipObject ) {
+
+				throw new Error(
+						"Different clips with the same name detected!" );
+
+			}
+
+		}
+
+		// clip must be known when specified via string
+		if ( clipObject === null ) return null;
+
+		// allocate all resources required to run it
+		var newAction = new THREE.
+				AnimationMixer._Action( this, clipObject, optionalRoot );
+
+		this._bindAction( newAction, prototypeAction );
+
+		// and make the action known to the memory manager
+		this._addInactiveAction( newAction, clipName, rootUuid );
+
+		return newAction;
+
+	},
+
+	// get an existing action
+	existingAction: function( clip, optionalRoot ) {
+
+		var root = optionalRoot || this._root,
+			rootUuid = root.uuid,
+			clipName = ( typeof clip === 'string' ) ? clip : clip.name,
+			actionsForClip = this._actionsByClip[ clipName ];
+
+		if ( actionsForClip !== undefined ) {
+
+			return actionsForClip.actionByRoot[ rootUuid ] || null;
+
+		}
+
+		return null;
+
+	},
+
+	// deactivates all previously scheduled actions
+	stopAllAction: function() {
+
+		var actions = this._actions,
+			nActions = this._nActiveActions,
+			bindings = this._bindings,
+			nBindings = this._nActiveBindings;
+
+		this._nActiveActions = 0;
+		this._nActiveBindings = 0;
+
+		for ( var i = 0; i !== nActions; ++ i ) {
+
+			actions[ i ].reset();
+
+		}
+
+		for ( var i = 0; i !== nBindings; ++ i ) {
+
+			bindings[ i ].useCount = 0;
+
+		}
+
+		return this;
+
+	},
+
+	// advance the time and update apply the animation
+	update: function( deltaTime ) {
+
+		deltaTime *= this.timeScale;
+
+		var actions = this._actions,
+			nActions = this._nActiveActions,
+
+			time = this.time += deltaTime,
+			timeDirection = Math.sign( deltaTime ),
+
+			accuIndex = this._accuIndex ^= 1;
+
+		// run active actions
+
+		for ( var i = 0; i !== nActions; ++ i ) {
+
+			var action = actions[ i ];
+
+			if ( action.enabled ) {
+
+				action._update( time, deltaTime, timeDirection, accuIndex );
+
+			}
+
+		}
+
+		// update scene graph
+
+		var bindings = this._bindings,
+			nBindings = this._nActiveBindings;
+
+		for ( var i = 0; i !== nBindings; ++ i ) {
+
+			bindings[ i ].apply( accuIndex );
+
+		}
+
+		return this;
+
+	},
+
+	// return this mixer's root target object
+	getRoot: function() {
+
+		return this._root;
+
+	},
+
+	// free all resources specific to a particular clip
+	uncacheClip: function( clip ) {
+
+		var actions = this._actions,
+			clipName = clip.name,
+			actionsByClip = this._actionsByClip,
+			actionsForClip = actionsByClip[ clipName ];
+
+		if ( actionsForClip !== undefined ) {
+
+			// note: just calling _removeInactiveAction would mess up the
+			// iteration state and also require updating the state we can
+			// just throw away
+
+			var actionsToRemove = actionsForClip.knownActions;
+
+			for ( var i = 0, n = actionsToRemove.length; i !== n; ++ i ) {
+
+				var action = actionsToRemove[ i ];
+
+				this._deactivateAction( action );
+
+				var cacheIndex = action._cacheIndex,
+					lastInactiveAction = actions[ actions.length - 1 ];
+
+				action._cacheIndex = null;
+				action._byClipCacheIndex = null;
+
+				lastInactiveAction._cacheIndex = cacheIndex;
+				actions[ cacheIndex ] = lastInactiveAction;
+				actions.pop();
+
+				this._removeInactiveBindingsForAction( action );
+
+			}
+
+			delete actionsByClip[ clipName ];
+
+		}
+
+	},
+
+	// free all resources specific to a particular root target object
+	uncacheRoot: function( root ) {
+
+		var rootUuid = root.uuid,
+			actionsByClip = this._actionsByClip;
+
+		for ( var clipName in actionsByClip ) {
+
+			var actionByRoot = actionsByClip[ clipName ].actionByRoot,
+				action = actionByRoot[ rootUuid ];
+
+			if ( action !== undefined ) {
+
+				this._deactivateAction( action );
+				this._removeInactiveAction( action );
+
+			}
+
+		}
+
+		var bindingsByRoot = this._bindingsByRootAndName,
+			bindingByName = bindingsByRoot[ rootUuid ];
+
+		if ( bindingByName !== undefined ) {
+
+			for ( var trackName in bindingByName ) {
+
+				var binding = bindingByName[ trackName ];
+				binding.restoreOriginalState();
+				this._removeInactiveBinding( binding );
+
+			}
+
+		}
+
+	},
+
+	// remove a targeted clip from the cache
+	uncacheAction: function( clip, optionalRoot ) {
+
+		var action = this.existingAction( clip, optionalRoot );
+
+		if ( action !== null ) {
+
+			this._deactivateAction( action );
+			this._removeInactiveAction( action );
+
+		}
+
+	}
+
+};
+
+THREE.EventDispatcher.prototype.apply( THREE.AnimationMixer.prototype );
+
+THREE.AnimationMixer._Action =
+		function( mixer, clip, localRoot ) {
+
+	this._mixer = mixer;
+	this._clip = clip;
+	this._localRoot = localRoot || null;
+
+	var tracks = clip.tracks,
+		nTracks = tracks.length,
+		interpolants = new Array( nTracks );
+
+	var interpolantSettings = {
+			endingStart: 	THREE.ZeroCurvatureEnding,
+			endingEnd:		THREE.ZeroCurvatureEnding
+	};
+
+	for ( var i = 0; i !== nTracks; ++ i ) {
+
+		var interpolant = tracks[ i ].createInterpolant( null );
+		interpolants[ i ] = interpolant;
+		interpolant.settings = interpolantSettings
+
+	}
+
+	this._interpolantSettings = interpolantSettings;
+
+	this._interpolants = interpolants;	// bound by the mixer
+
+	// inside: PropertyMixer (managed by the mixer)
+	this._propertyBindings = new Array( nTracks );
+
+	this._cacheIndex = null;			// for the memory manager
+	this._byClipCacheIndex = null;		// for the memory manager
+
+	this._timeScaleInterpolant = null;
+	this._weightInterpolant = null;
+
+	this.loop = THREE.LoopRepeat;
+	this._loopCount = -1;
+
+	// global mixer time when the action is to be started
+	// it's set back to 'null' upon start of the action
+	this._startTime = null;
+
+	// scaled local time of the action
+	// gets clamped or wrapped to 0..clip.duration according to loop
+	this.time = 0;
+
+	this.timeScale = 1;
+	this._effectiveTimeScale = 1;
+
+	this.weight = 1;
+	this._effectiveWeight = 1;
+
+	this.repetitions = Infinity; 		// no. of repetitions when looping
+
+	this.paused = false;				// false -> zero effective time scale
+	this.enabled = true;				// true -> zero effective weight
+
+	this.clampWhenFinished 	= false;	// keep feeding the last frame?
+
+	this.zeroSlopeAtStart 	= true;		// for smooth interpolation w/o separate
+	this.zeroSlopeAtEnd		= true;		// clips for start, loop and end
+
+};
+
+THREE.AnimationMixer._Action.prototype = {
+
+	constructor: THREE.AnimationMixer._Action,
+
+	// State & Scheduling
+
+	play: function() {
+
+		this._mixer._activateAction( this );
+
+		return this;
+
+	},
+
+	stop: function() {
+
+		this._mixer._deactivateAction( this );
+
+		return this.reset();
+
+	},
+
+	reset: function() {
+
+		this.paused = false;
+		this.enabled = true;
+
+		this.time = 0;			// restart clip
+		this._loopCount = -1;	// forget previous loops
+		this._startTime = null;	// forget scheduling
+
+		return this.stopFading().stopWarping();
+
+	},
+
+	isRunning: function() {
+
+		var start = this._startTime;
+
+		return this.enabled && ! this.paused && this.timeScale !== 0 &&
+				this._startTime === null && this._mixer._isActiveAction( this )
+
+	},
+
+	// return true when play has been called
+	isScheduled: function() {
+
+		return this._mixer._isActiveAction( this );
+
+	},
+
+	startAt: function( time ) {
+
+		this._startTime = time;
+
+		return this;
+
+	},
+
+	setLoop: function( mode, repetitions ) {
+
+		this.loop = mode;
+		this.repetitions = repetitions;
+
+		return this;
+
+	},
+
+	// Weight
+
+	// set the weight stopping any scheduled fading
+	// although .enabled = false yields an effective weight of zero, this
+	// method does *not* change .enabled, because it would be confusing
+	setEffectiveWeight: function( weight ) {
+
+		this.weight = weight;
+
+		// note: same logic as when updated at runtime
+		this._effectiveWeight = this.enabled ? weight : 0;
+
+		return this.stopFading();
+
+	},
+
+	// return the weight considering fading and .enabled
+	getEffectiveWeight: function() {
+
+		return this._effectiveWeight;
+
+	},
+
+	fadeIn: function( duration ) {
+
+		return this._scheduleFading( duration, 0, 1 );
+
+	},
+
+	fadeOut: function( duration ) {
+
+		return this._scheduleFading( duration, 1, 0 );
+
+	},
+
+	crossFadeFrom: function( fadeOutAction, duration, warp ) {
+
+		var mixer = this._mixer;
+
+		fadeOutAction.fadeOut( duration );
+		this.fadeIn( duration );
+
+		if( warp ) {
+
+			var fadeInDuration = this._clip.duration,
+				fadeOutDuration = fadeOutAction._clip.duration,
+
+				startEndRatio = fadeOutDuration / fadeInDuration,
+				endStartRatio = fadeInDuration / fadeOutDuration;
+
+			fadeOutAction.warp( 1.0, startEndRatio, duration );
+			this.warp( endStartRatio, 1.0, duration );
+
+		}
+
+		return this;
+
+	},
+
+	crossFadeTo: function( fadeInAction, duration, warp ) {
+
+		return fadeInAction.crossFadeFrom( this, duration, warp );
+
+	},
+
+	stopFading: function() {
+
+		var weightInterpolant = this._weightInterpolant;
+
+		if ( weightInterpolant !== null ) {
+
+			this._weightInterpolant = null;
+			this._mixer._takeBackControlInterpolant( weightInterpolant );
+
+		}
+
+		return this;
+
+	},
+
+	// Time Scale Control
+
+	// set the weight stopping any scheduled warping
+	// although .paused = true yields an effective time scale of zero, this
+	// method does *not* change .paused, because it would be confusing
+	setEffectiveTimeScale: function( timeScale ) {
+
+		this.timeScale = timeScale;
+		this._effectiveTimeScale = this.paused ? 0 :timeScale;
+
+		return this.stopWarping();
+
+	},
+
+	// return the time scale considering warping and .paused
+	getEffectiveTimeScale: function() {
+
+		return this._effectiveTimeScale;
+
+	},
+
+	setDuration: function( duration ) {
+
+		this.timeScale = this._clip.duration / duration;
+
+		return this.stopWarping();
+
+	},
+
+	syncWith: function( action ) {
+
+		this.time = action.time;
+		this.timeScale = action.timeScale;
+
+		return this.stopWarping();
+
+	},
+
+	halt: function( duration ) {
+
+		return this.warp( this._currentTimeScale, 0, duration );
+
+	},
+
+	warp: function( startTimeScale, endTimeScale, duration ) {
+
+		var mixer = this._mixer, now = mixer.time,
+			interpolant = this._timeScaleInterpolant,
+
+			timeScale = this.timeScale;
+
+		if ( interpolant === null ) {
+
+			interpolant = mixer._lendControlInterpolant(),
+			this._timeScaleInterpolant = interpolant;
+
+		}
+
+		var times = interpolant.parameterPositions,
+			values = interpolant.sampleValues;
+
+		times[ 0 ] = now;
+		times[ 1 ] = now + duration;
+
+		values[ 0 ] = startTimeScale / timeScale;
+		values[ 1 ] = endTimeScale / timeScale;
+
+		return this;
+
+	},
+
+	stopWarping: function() {
+
+		var timeScaleInterpolant = this._timeScaleInterpolant;
+
+		if ( timeScaleInterpolant !== null ) {
+
+			this._timeScaleInterpolant = null;
+			this._mixer._takeBackControlInterpolant( timeScaleInterpolant );
+
+		}
+
+		return this;
+
+	},
+
+	// Object Accessors
+
+	getMixer: function() {
+
+		return this._mixer;
+
+	},
+
+	getClip: function() {
+
+		return this._clip;
+
+	},
+
+	getRoot: function() {
+
+		return this._localRoot || this._mixer._root;
+
+	},
+
+	// Interna
+
+	_update: function( time, deltaTime, timeDirection, accuIndex ) {
+		// called by the mixer
+
+		var startTime = this._startTime;
+
+		if ( startTime !== null ) {
+
+			// check for scheduled start of action
+
+			var timeRunning = ( time - startTime ) * timeDirection;
+			if ( timeRunning < 0 || timeDirection === 0 ) {
+
+				return; // yet to come / don't decide when delta = 0
+
+			}
+
+			// start
+
+			this._startTime = null; // unschedule
+			deltaTime = timeDirection * timeRunning;
+
+		}
+
+		// apply time scale and advance time
+
+		deltaTime *= this._updateTimeScale( time );
+		var clipTime = this._updateTime( deltaTime );
+
+		// note: _updateTime may disable the action resulting in
+		// an effective weight of 0
+
+		var weight = this._updateWeight( time );
+
+		if ( weight > 0 ) {
+
+			var interpolants = this._interpolants;
+			var propertyMixers = this._propertyBindings;
+
+			for ( var j = 0, m = interpolants.length; j !== m; ++ j ) {
+
+				interpolants[ j ].evaluate( clipTime );
+				propertyMixers[ j ].accumulate( accuIndex, weight );
+
+			}
+
+		}
+
+	},
+
+	_updateWeight: function( time ) {
+
+		var weight = 0;
+
+		if ( this.enabled ) {
+
+			weight = this.weight;
+			var interpolant = this._weightInterpolant;
+
+			if ( interpolant !== null ) {
+
+				var interpolantValue = interpolant.evaluate( time )[ 0 ];
+
+				weight *= interpolantValue;
+
+				if ( time > interpolant.parameterPositions[ 1 ] ) {
+
+					this.stopFading();
+
+					if ( interpolantValue === 0 ) {
+
+						// faded out, disable
+						this.enabled = false;
+
+					}
+
+				}
+
+			}
+
+		}
+
+		this._effectiveWeight = weight;
+		return weight;
+
+	},
+
+	_updateTimeScale: function( time ) {
+
+		var timeScale = 0;
+
+		if ( ! this.paused ) {
+
+			timeScale = this.timeScale;
+
+			var interpolant = this._timeScaleInterpolant;
+
+			if ( interpolant !== null ) {
+
+				var interpolantValue = interpolant.evaluate( time )[ 0 ];
+
+				timeScale *= interpolantValue;
+
+				if ( time > interpolant.parameterPositions[ 1 ] ) {
+
+					this.stopWarping();
+
+					if ( timeScale === 0 ) {
+
+						// motion has halted, pause
+						this.pause = true;
+
+					} else {
+
+						// warp done - apply final time scale
+						this.timeScale = timeScale;
+
+					}
+
+				}
+
+			}
+
+		}
+
+		this._effectiveTimeScale = timeScale;
+		return timeScale;
+
+	},
+
+	_updateTime: function( deltaTime ) {
+
+		var time = this.time + deltaTime;
+
+		if ( deltaTime === 0 ) return time;
+
+		var duration = this._clip.duration,
+
+			loop = this.loop,
+			loopCount = this._loopCount,
+
+			pingPong = false;
+
+		switch ( loop ) {
+
+			case THREE.LoopOnce:
+
+				if ( loopCount === -1 ) {
+
+					// just started
+
+					this.loopCount = 0;
+					this._setEndings( true, true, false );
+
+				}
+
+				if ( time >= duration ) {
+
+					time = duration;
+
+				} else if ( time < 0 ) {
+
+					time = 0;
+
+				} else break;
+
+				// reached the end
+
+				if ( this.clampWhenFinished ) this.pause = true;
+				else this.enabled = false;
+
+				this._mixer.dispatchEvent( {
+					type: 'finished', action: this,
+					direction: deltaTime < 0 ? -1 : 1
+				} );
+
+				break;
+
+			case THREE.LoopPingPong:
+
+				pingPong = true;
+
+			case THREE.LoopRepeat:
+
+				if ( loopCount === -1 ) {
+
+					// just started
+
+					if ( deltaTime > 0 ) {
+
+						loopCount = 0;
+
+						this._setEndings(
+								true, this.repetitions === 0, pingPong );
+
+					} else {
+
+						// when looping in reverse direction, the initial
+						// transition through zero counts as a repetition,
+						// so leave loopCount at -1
+
+						this._setEndings(
+								this.repetitions === 0, true, pingPong );
+
+					}
+
+				}
+
+				if ( time >= duration || time < 0 ) {
+
+					// wrap around
+
+					var loopDelta = Math.floor( time / duration ); // signed
+					time -= duration * loopDelta;
+
+					loopCount += Math.abs( loopDelta );
+
+					var pending = this.repetitions - loopCount;
+
+					if ( pending < 0 ) {
+
+						// stop (switch state, clamp time, fire event)
+
+						if ( this.clampWhenFinished ) this.paused = true;
+						else this.enabled = false;
+
+						time = deltaTime > 0 ? duration : 0;
+
+						this._mixer.dispatchEvent( {
+							type: 'finished', action: this,
+							direction: deltaTime > 0 ? 1 : -1
+						} );
+
+						break;
+
+					} else if ( pending === 0 ) {
+
+						// transition to last round
+
+						var atStart = deltaTime < 0;
+						this._setEndings( atStart, ! atStart, pingPong );
+
+					} else {
+
+						this._setEndings( false, false, pingPong );
+
+					}
+
+					this._loopCount = loopCount;
+
+					this._mixer.dispatchEvent( {
+						type: 'loop', action: this, loopDelta: loopDelta
+					} );
+
+				}
+
+				if ( loop === THREE.LoopPingPong && ( loopCount & 1 ) === 1 ) {
+
+					// invert time for the "pong round"
+
+					this.time = time;
+
+					return duration - time;
+
+				}
+
+				break;
+
+		}
+
+		this.time = time;
+
+		return time;
+
+	},
+
+	_setEndings: function( atStart, atEnd, pingPong ) {
+
+		var settings = this._interpolantSettings;
+
+		if ( pingPong ) {
+
+			settings.endingStart 	= THREE.ZeroSlopeEnding;
+			settings.endingEnd		= THREE.ZeroSlopeEnding;
+
+		} else {
+
+			// assuming for LoopOnce atStart == atEnd == true
+
+			if ( atStart ) {
+
+				settings.endingStart = this.zeroSlopeAtStart ?
+						THREE.ZeroSlopeEnding : THREE.ZeroCurvatureEnding;
+
+			} else {
+
+				settings.endingStart = THREE.WrapAroundEnding;
+
+			}
+
+			if ( atEnd ) {
+
+				settings.endingEnd = this.zeroSlopeAtEnd ?
+						THREE.ZeroSlopeEnding : THREE.ZeroCurvatureEnding;
+
+			} else {
+
+				settings.endingEnd 	 = THREE.WrapAroundEnding;
+
+			}
+
+		}
+
+	},
+
+	_scheduleFading: function( duration, weightNow, weightThen ) {
+
+		var mixer = this._mixer, now = mixer.time,
+			interpolant = this._weightInterpolant;
+
+		if ( interpolant === null ) {
+
+			interpolant = mixer._lendControlInterpolant(),
+			this._weightInterpolant = interpolant;
+
+		}
+
+		var times = interpolant.parameterPositions,
+			values = interpolant.sampleValues;
+
+		times[ 0 ] = now; 				values[ 0 ] = weightNow;
+		times[ 1 ] = now + duration;	values[ 1 ] = weightThen;
+
+		return this;
+
+	}
+
+};
+
+// Implementation details:
+
+Object.assign( THREE.AnimationMixer.prototype, {
+
+	_bindAction: function( action, prototypeAction ) {
+
+		var root = action._localRoot || this._root,
+			tracks = action._clip.tracks,
+			nTracks = tracks.length,
+			bindings = action._propertyBindings,
+			interpolants = action._interpolants,
+			rootUuid = root.uuid,
+			bindingsByRoot = this._bindingsByRootAndName,
+			bindingsByName = bindingsByRoot[ rootUuid ];
+
+		if ( bindingsByName === undefined ) {
+
+			bindingsByName = {};
+			bindingsByRoot[ rootUuid ] = bindingsByName;
+
+		}
+
+		for ( var i = 0; i !== nTracks; ++ i ) {
+
+			var track = tracks[ i ],
+				trackName = track.name,
+				binding = bindingsByName[ trackName ];
+
+			if ( binding !== undefined ) {
+
+				bindings[ i ] = binding;
+
+			} else {
+
+				binding = bindings[ i ];
+
+				if ( binding !== undefined ) {
+
+					// existing binding, make sure the cache knows
+
+					if ( binding._cacheIndex === null ) {
+
+						++ binding.referenceCount;
+						this._addInactiveBinding( binding, rootUuid, trackName );
+
+					}
+
+					continue;
+
+				}
+
+				var path = prototypeAction && prototypeAction.
+						_propertyBindings[ i ].binding.parsedPath;
+
+				binding = new THREE.PropertyMixer(
+						THREE.PropertyBinding.create( root, trackName, path ),
+						track.ValueTypeName, track.getValueSize() );
+
+				++ binding.referenceCount;
+				this._addInactiveBinding( binding, rootUuid, trackName );
+
+				bindings[ i ] = binding;
+
+			}
+
+			interpolants[ i ].resultBuffer = binding.buffer;
+
+		}
+
+	},
+
+	_activateAction: function( action ) {
+
+		if ( ! this._isActiveAction( action ) ) {
+
+			if ( action._cacheIndex === null ) {
+
+				// this action has been forgotten by the cache, but the user
+				// appears to be still using it -> rebind
+
+				var rootUuid = ( action._localRoot || this._root ).uuid,
+					clipName = action._clip.name,
+					actionsForClip = this._actionsByClip[ clipName ];
+
+				this._bindAction( action,
+						actionsForClip && actionsForClip.knownActions[ 0 ] );
+
+				this._addInactiveAction( action, clipName, rootUuid );
+
+			}
+
+			var bindings = action._propertyBindings;
+
+			// increment reference counts / sort out state
+			for ( var i = 0, n = bindings.length; i !== n; ++ i ) {
+
+				var binding = bindings[ i ];
+
+				if ( binding.useCount ++ === 0 ) {
+
+					this._lendBinding( binding );
+					binding.saveOriginalState();
+
+				}
+
+			}
+
+			this._lendAction( action );
+
+		}
+
+	},
+
+	_deactivateAction: function( action ) {
+
+		if ( this._isActiveAction( action ) ) {
+
+			var bindings = action._propertyBindings;
+
+			// decrement reference counts / sort out state
+			for ( var i = 0, n = bindings.length; i !== n; ++ i ) {
+
+				var binding = bindings[ i ];
+
+				if ( -- binding.useCount === 0 ) {
+
+					binding.restoreOriginalState();
+					this._takeBackBinding( binding );
+
+				}
+
+			}
+
+			this._takeBackAction( action );
+
+		}
+
+	},
+
+	// Memory manager
+
+	_initMemoryManager: function() {
+
+		this._actions = []; // 'nActiveActions' followed by inactive ones
+		this._nActiveActions = 0;
+
+		this._actionsByClip = {};
+		// inside:
+		// {
+		// 		knownActions: Array< _Action >	- used as prototypes
+		// 		actionByRoot: _Action			- lookup
+		// }
+
+
+		this._bindings = []; // 'nActiveBindings' followed by inactive ones
+		this._nActiveBindings = 0;
+
+		this._bindingsByRootAndName = {}; // inside: Map< name, PropertyMixer >
+
+
+		this._controlInterpolants = []; // same game as above
+		this._nActiveControlInterpolants = 0;
+
+		var scope = this;
+
+		this.stats = {
+
+			actions: {
+				get total() { return scope._actions.length; },
+				get inUse() { return scope._nActiveActions; }
+			},
+			bindings: {
+				get total() { return scope._bindings.length; },
+				get inUse() { return scope._nActiveBindings; }
+			},
+			controlInterpolants: {
+				get total() { return scope._controlInterpolants.length; },
+				get inUse() { return scope._nActiveControlInterpolants; }
+			}
+
+		};
+
+	},
+
+	// Memory management for _Action objects
+
+	_isActiveAction: function( action ) {
+
+		var index = action._cacheIndex;
+		return index !== null && index < this._nActiveActions;
+
+	},
+
+	_addInactiveAction: function( action, clipName, rootUuid ) {
+
+		var actions = this._actions,
+			actionsByClip = this._actionsByClip,
+			actionsForClip = actionsByClip[ clipName ];
+
+		if ( actionsForClip === undefined ) {
+
+			actionsForClip = {
+
+				knownActions: [ action ],
+				actionByRoot: {}
+
+			};
+
+			action._byClipCacheIndex = 0;
+
+			actionsByClip[ clipName ] = actionsForClip;
+
+		} else {
+
+			var knownActions = actionsForClip.knownActions;
+
+			action._byClipCacheIndex = knownActions.length;
+			knownActions.push( action );
+
+		}
+
+		action._cacheIndex = actions.length;
+		actions.push( action );
+
+		actionsForClip.actionByRoot[ rootUuid ] = action;
+
+	},
+
+	_removeInactiveAction: function( action ) {
+
+		var actions = this._actions,
+			lastInactiveAction = actions[ actions.length - 1 ],
+			cacheIndex = action._cacheIndex;
+
+		lastInactiveAction._cacheIndex = cacheIndex;
+		actions[ cacheIndex ] = lastInactiveAction;
+		actions.pop();
+
+		action._cacheIndex = null;
+
+
+		var clipName = action._clip.name,
+			actionsByClip = this._actionsByClip,
+			actionsForClip = actionsByClip[ clipName ],
+			knownActionsForClip = actionsForClip.knownActions,
+
+			lastKnownAction =
+				knownActionsForClip[ knownActionsForClip.length - 1 ],
+
+			byClipCacheIndex = action._byClipCacheIndex;
+
+		lastKnownAction._byClipCacheIndex = byClipCacheIndex;
+		knownActionsForClip[ byClipCacheIndex ] = lastKnownAction;
+		knownActionsForClip.pop();
+
+		action._byClipCacheIndex = null;
+
+
+		var actionByRoot = actionsForClip.actionByRoot,
+			rootUuid = ( actions._localRoot || this._root ).uuid;
+
+		delete actionByRoot[ rootUuid ];
+
+		if ( knownActionsForClip.length === 0 ) {
+
+			delete actionsByClip[ clipName ];
+
+		}
+
+		this._removeInactiveBindingsForAction( action );
+
+	},
+
+	_removeInactiveBindingsForAction: function( action ) {
+
+		var bindings = action._propertyBindings;
+		for ( var i = 0, n = bindings.length; i !== n; ++ i ) {
+
+			var binding = bindings[ i ];
+
+			if ( -- binding.referenceCount === 0 ) {
+
+				this._removeInactiveBinding( binding );
+
+			}
+
+		}
+
+	},
+
+	_lendAction: function( action ) {
+
+		// [ active actions |  inactive actions  ]
+		// [  active actions >| inactive actions ]
+		//                 s        a
+		//                  <-swap->
+		//                 a        s
+
+		var actions = this._actions,
+			prevIndex = action._cacheIndex,
+
+			lastActiveIndex = this._nActiveActions ++,
+
+			firstInactiveAction = actions[ lastActiveIndex ];
+
+		action._cacheIndex = lastActiveIndex;
+		actions[ lastActiveIndex ] = action;
+
+		firstInactiveAction._cacheIndex = prevIndex;
+		actions[ prevIndex ] = firstInactiveAction;
+
+	},
+
+	_takeBackAction: function( action ) {
+
+		// [  active actions  | inactive actions ]
+		// [ active actions |< inactive actions  ]
+		//        a        s
+		//         <-swap->
+		//        s        a
+
+		var actions = this._actions,
+			prevIndex = action._cacheIndex,
+
+			firstInactiveIndex = -- this._nActiveActions,
+
+			lastActiveAction = actions[ firstInactiveIndex ];
+
+		action._cacheIndex = firstInactiveIndex;
+		actions[ firstInactiveIndex ] = action;
+
+		lastActiveAction._cacheIndex = prevIndex;
+		actions[ prevIndex ] = lastActiveAction;
+
+	},
+
+	// Memory management for PropertyMixer objects
+
+	_addInactiveBinding: function( binding, rootUuid, trackName ) {
+
+		var bindingsByRoot = this._bindingsByRootAndName,
+			bindingByName = bindingsByRoot[ rootUuid ],
+
+			bindings = this._bindings;
+
+		if ( bindingByName === undefined ) {
+
+			bindingByName = {};
+			bindingsByRoot[ rootUuid ] = bindingByName;
+
+		}
+
+		bindingByName[ trackName ] = binding;
+
+		binding._cacheIndex = bindings.length;
+		bindings.push( binding );
+
+	},
+
+	_removeInactiveBinding: function( binding ) {
+
+		var bindings = this._bindings,
+			propBinding = binding.binding,
+			rootUuid = propBinding.rootNode.uuid,
+			trackName = propBinding.path,
+			bindingsByRoot = this._bindingsByRootAndName,
+			bindingByName = bindingsByRoot[ rootUuid ],
+
+			lastInactiveBinding = bindings[ bindings.length - 1 ],
+			cacheIndex = binding._cacheIndex;
+
+		lastInactiveBinding._cacheIndex = cacheIndex;
+		bindings[ cacheIndex ] = lastInactiveBinding;
+		bindings.pop();
+
+		delete bindingByName[ trackName ];
+
+		remove_empty_map: {
+
+			for ( var _ in bindingByName ) break remove_empty_map;
+
+			delete bindingsByRoot[ rootUuid ];
+
+		}
+
+	},
+
+	_lendBinding: function( binding ) {
+
+		var bindings = this._bindings,
+			prevIndex = binding._cacheIndex,
+
+			lastActiveIndex = this._nActiveBindings ++,
+
+			firstInactiveBinding = bindings[ lastActiveIndex ];
+
+		binding._cacheIndex = lastActiveIndex;
+		bindings[ lastActiveIndex ] = binding;
+
+		firstInactiveBinding._cacheIndex = prevIndex;
+		bindings[ prevIndex ] = firstInactiveBinding;
+
+	},
+
+	_takeBackBinding: function( binding ) {
+
+		var bindings = this._bindings,
+			prevIndex = binding._cacheIndex,
+
+			firstInactiveIndex = -- this._nActiveBindings,
+
+			lastActiveBinding = bindings[ firstInactiveIndex ];
+
+		binding._cacheIndex = firstInactiveIndex;
+		bindings[ firstInactiveIndex ] = binding;
+
+		lastActiveBinding._cacheIndex = prevIndex;
+		bindings[ prevIndex ] = lastActiveBinding;
+
+	},
+
+
+	// Memory management of Interpolants for weight and time scale
+
+	_lendControlInterpolant: function() {
+
+		var interpolants = this._controlInterpolants,
+			lastActiveIndex = this._nActiveControlInterpolants ++,
+			interpolant = interpolants[ lastActiveIndex ];
+
+		if ( interpolant === undefined ) {
+
+			interpolant = new THREE.LinearInterpolant(
+					new Float32Array( 2 ), new Float32Array( 2 ),
+						1, this._controlInterpolantsResultBuffer );
+
+			interpolant.__cacheIndex = lastActiveIndex;
+			interpolants[ lastActiveIndex ] = interpolant;
+
+		}
+
+		return interpolant;
+
+	},
+
+	_takeBackControlInterpolant: function( interpolant ) {
+
+		var interpolants = this._controlInterpolants,
+			prevIndex = interpolant.__cacheIndex,
+
+			firstInactiveIndex = -- this._nActiveControlInterpolants,
+
+			lastActiveInterpolant = interpolants[ firstInactiveIndex ];
+
+		interpolant.__cacheIndex = firstInactiveIndex;
+		interpolants[ firstInactiveIndex ] = interpolant;
+
+		lastActiveInterpolant.__cacheIndex = prevIndex;
+		interpolants[ prevIndex ] = lastActiveInterpolant;
+
+	},
+
+	_controlInterpolantsResultBuffer: new Float32Array( 1 )
+
+} );
+
+
+// File:src/animation/AnimationObjectGroup.js
+
+/**
+ *
+ * A group of objects that receives a shared animation state.
+ *
+ * Usage:
+ *
+ * 	-	Add objects you would otherwise pass as 'root' to the
+ * 		constructor or the .clipAction method of AnimationMixer.
+ *
+ * 	-	Instead pass this object as 'root'.
+ *
+ * 	-	You can also add and remove objects later when the mixer
+ * 		is running.
+ *
+ * Note:
+ *
+ *  	Objects of this class appear as one object to the mixer,
+ *  	so cache control of the individual objects must be done
+ *  	on the group.
+ *
+ * Limitation:
+ *
+ * 	- 	The animated properties must be compatible among the
+ * 		all objects in the group.
+ *
+ *  -	A single property can either be controlled through a
+ *  	target group or directly, but not both.
+ *
+ * @author tschw
+ */
+
+THREE.AnimationObjectGroup = function( var_args ) {
+
+	this.uuid = THREE.Math.generateUUID();
+
+	// cached objects followed by the active ones
+	this._objects = Array.prototype.slice.call( arguments );
+
+	this.nCachedObjects_ = 0;			// threshold
+	// note: read by PropertyBinding.Composite
+
+	var indices = {};
+	this._indicesByUUID = indices;		// for bookkeeping
+
+	for ( var i = 0, n = arguments.length; i !== n; ++ i ) {
+
+		indices[ arguments[ i ].uuid ] = i;
+
+	}
+
+	this._paths = [];					// inside: string
+	this._parsedPaths = [];				// inside: { we don't care, here }
+	this._bindings = []; 				// inside: Array< PropertyBinding >
+	this._bindingsIndicesByPath = {}; 	// inside: indices in these arrays
+
+	var scope = this;
+
+	this.stats = {
+
+		objects: {
+			get total() { return scope._objects.length; },
+			get inUse() { return this.total - scope.nCachedObjects_;  }
+		},
+
+		get bindingsPerObject() { return scope._bindings.length; }
+
+	};
+
+};
+
+THREE.AnimationObjectGroup.prototype = {
+
+	constructor: THREE.AnimationObjectGroup,
+
+	add: function( var_args ) {
+
+		var objects = this._objects,
+			nObjects = objects.length,
+			nCachedObjects = this.nCachedObjects_,
+			indicesByUUID = this._indicesByUUID,
+			paths = this._paths,
+			parsedPaths = this._parsedPaths,
+			bindings = this._bindings,
+			nBindings = bindings.length;
+
+		for ( var i = 0, n = arguments.length; i !== n; ++ i ) {
+
+			var object = arguments[ i ],
+				uuid = object.uuid,
+				index = indicesByUUID[ uuid ];
+
+			if ( index === undefined ) {
+
+				// unknown object -> add it to the ACTIVE region
+
+				index = nObjects ++;
+				indicesByUUID[ uuid ] = index;
+				objects.push( object );
+
+				// accounting is done, now do the same for all bindings
+
+				for ( var j = 0, m = nBindings; j !== m; ++ j ) {
+
+					bindings[ j ].push(
+							new THREE.PropertyBinding(
+								object, paths[ j ], parsedPaths[ j ] ) );
+
+				}
+
+			} else if ( index < nCachedObjects ) {
+
+				var knownObject = objects[ index ];
+
+				// move existing object to the ACTIVE region
+
+				var firstActiveIndex = -- nCachedObjects,
+					lastCachedObject = objects[ firstActiveIndex ];
+
+				indicesByUUID[ lastCachedObject.uuid ] = index;
+				objects[ index ] = lastCachedObject;
+
+				indicesByUUID[ uuid ] = firstActiveIndex;
+				objects[ firstActiveIndex ] = object;
+
+				// accounting is done, now do the same for all bindings
+
+				for ( var j = 0, m = nBindings; j !== m; ++ j ) {
+
+					var bindingsForPath = bindings[ j ],
+						lastCached = bindingsForPath[ firstActiveIndex ],
+						binding = bindingsForPath[ index ];
+
+					bindingsForPath[ index ] = lastCached;
+
+					if ( binding === undefined ) {
+
+						// since we do not bother to create new bindings
+						// for objects that are cached, the binding may
+						// or may not exist
+
+						binding = new THREE.PropertyBinding(
+								object, paths[ j ], parsedPaths[ j ] );
+
+					}
+
+					bindingsForPath[ firstActiveIndex ] = binding;
+
+				}
+
+			} else if ( objects[ index ] !== knownObject) {
+
+				console.error( "Different objects with the same UUID " +
+						"detected. Clean the caches or recreate your " +
+						"infrastructure when reloading scenes..." );
+
+			} // else the object is already where we want it to be
+
+		} // for arguments
+
+		this.nCachedObjects_ = nCachedObjects;
+
+	},
+
+	remove: function( var_args ) {
+
+		var objects = this._objects,
+			nObjects = objects.length,
+			nCachedObjects = this.nCachedObjects_,
+			indicesByUUID = this._indicesByUUID,
+			bindings = this._bindings,
+			nBindings = bindings.length;
+
+		for ( var i = 0, n = arguments.length; i !== n; ++ i ) {
+
+			var object = arguments[ i ],
+				uuid = object.uuid,
+				index = indicesByUUID[ uuid ];
+
+			if ( index !== undefined && index >= nCachedObjects ) {
+
+				// move existing object into the CACHED region
+
+				var lastCachedIndex = nCachedObjects ++,
+					firstActiveObject = objects[ lastCachedIndex ];
+
+				indicesByUUID[ firstActiveObject.uuid ] = index;
+				objects[ index ] = firstActiveObject;
+
+				indicesByUUID[ uuid ] = lastCachedIndex;
+				objects[ lastCachedIndex ] = object;
+
+				// accounting is done, now do the same for all bindings
+
+				for ( var j = 0, m = nBindings; j !== m; ++ j ) {
+
+					var bindingsForPath = bindings[ j ],
+						firstActive = bindingsForPath[ lastCachedIndex ],
+						binding = bindingsForPath[ index ];
+
+					bindingsForPath[ index ] = firstActive;
+					bindingsForPath[ lastCachedIndex ] = binding;
+
+				}
+
+			}
+
+		} // for arguments
+
+		this.nCachedObjects_ = nCachedObjects;
+
+	},
+
+	// remove & forget
+	uncache: function( var_args ) {
+
+		var objects = this._objects,
+			nObjects = objects.length,
+			nCachedObjects = this.nCachedObjects_,
+			indicesByUUID = this._indicesByUUID,
+			bindings = this._bindings,
+			nBindings = bindings.length;
+
+		for ( var i = 0, n = arguments.length; i !== n; ++ i ) {
+
+			var object = arguments[ i ],
+				uuid = object.uuid,
+				index = indicesByUUID[ uuid ];
+
+			if ( index !== undefined ) {
+
+				delete indicesByUUID[ uuid ];
+
+				if ( index < nCachedObjects ) {
+
+					// object is cached, shrink the CACHED region
+
+					var firstActiveIndex = -- nCachedObjects,
+						lastCachedObject = objects[ firstActiveIndex ],
+						lastIndex = -- nObjects,
+						lastObject = objects[ lastIndex ];
+
+					// last cached object takes this object's place
+					indicesByUUID[ lastCachedObject.uuid ] = index;
+					objects[ index ] = lastCachedObject;
+
+					// last object goes to the activated slot and pop
+					indicesByUUID[ lastObject.uuid ] = firstActiveIndex;
+					objects[ firstActiveIndex ] = lastObject;
+					objects.pop();
+
+					// accounting is done, now do the same for all bindings
+
+					for ( var j = 0, m = nBindings; j !== m; ++ j ) {
+
+						var bindingsForPath = bindings[ j ],
+							lastCached = bindingsForPath[ firstActiveIndex ],
+							last = bindingsForPath[ lastIndex ];
+
+						bindingsForPath[ index ] = lastCached;
+						bindingsForPath[ firstActiveIndex ] = last;
+						bindingsForPath.pop();
+
+					}
+
+				} else {
+
+					// object is active, just swap with the last and pop
+
+					var lastIndex = -- nObjects,
+						lastObject = objects[ lastIndex ];
+
+					indicesByUUID[ lastObject.uuid ] = index;
+					objects[ index ] = lastObject;
+					objects.pop();
+
+					// accounting is done, now do the same for all bindings
+
+					for ( var j = 0, m = nBindings; j !== m; ++ j ) {
+
+						var bindingsForPath = bindings[ j ];
+
+						bindingsForPath[ index ] = bindingsForPath[ lastIndex ];
+						bindingsForPath.pop();
+
+					}
+
+				} // cached or active
+
+			} // if object is known
+
+		} // for arguments
+
+		this.nCachedObjects_ = nCachedObjects;
+
+	},
+
+	// Internal interface used by befriended PropertyBinding.Composite:
+
+	subscribe_: function( path, parsedPath ) {
+		// returns an array of bindings for the given path that is changed
+		// according to the contained objects in the group
+
+		var indicesByPath = this._bindingsIndicesByPath,
+			index = indicesByPath[ path ],
+			bindings = this._bindings;
+
+		if ( index !== undefined ) return bindings[ index ];
+
+		var paths = this._paths,
+			parsedPaths = this._parsedPaths,
+			objects = this._objects,
+			nObjects = objects.length,
+			nCachedObjects = this.nCachedObjects_,
+			bindingsForPath = new Array( nObjects );
+
+		index = bindings.length;
+
+		indicesByPath[ path ] = index;
+
+		paths.push( path );
+		parsedPaths.push( parsedPath );
+		bindings.push( bindingsForPath );
+
+		for ( var i = nCachedObjects,
+				n = objects.length; i !== n; ++ i ) {
+
+			var object = objects[ i ];
+
+			bindingsForPath[ i ] =
+					new THREE.PropertyBinding( object, path, parsedPath );
+
+		}
+
+		return bindingsForPath;
+
+	},
+
+	unsubscribe_: function( path ) {
+		// tells the group to forget about a property path and no longer
+		// update the array previously obtained with 'subscribe_'
+
+		var indicesByPath = this._bindingsIndicesByPath,
+			index = indicesByPath[ path ];
+
+		if ( index !== undefined ) {
+
+			var paths = this._paths,
+				parsedPaths = this._parsedPaths,
+				bindings = this._bindings,
+				lastBindingsIndex = bindings.length - 1,
+				lastBindings = bindings[ lastBindingsIndex ],
+				lastBindingsPath = path[ lastBindingsIndex ];
+
+			indicesByPath[ lastBindingsPath ] = index;
+
+			bindings[ index ] = lastBindings;
+			bindings.pop();
+
+			parsedPaths[ index ] = parsedPaths[ lastBindingsIndex ];
+			parsedPaths.pop();
+
+			paths[ index ] = paths[ lastBindingsIndex ];
+			paths.pop();
+
+		}
+
+	}
+
+};
+
+
+// File:src/animation/AnimationUtils.js
+
+/**
+ * @author tschw
+ * @author Ben Houston / http://clara.io/
+ * @author David Sarno / http://lighthaus.us/
+ */
+
+THREE.AnimationUtils = {
+
+	// same as Array.prototype.slice, but also works on typed arrays
+	arraySlice: function( array, from, to ) {
+
+		if ( THREE.AnimationUtils.isTypedArray( array ) ) {
+
+			return new array.constructor( array.subarray( from, to ) );
+
+		}
+
+		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 );
+
+		}
+
+	}
+
+};
+
+// File:src/animation/KeyframeTrack.js
+
+/**
+ *
+ * A timed sequence of keyframes for a specific property.
+ *
+ *
+ * @author Ben Houston / http://clara.io/
+ * @author David Sarno / http://lighthaus.us/
+ * @author tschw
+ */
+
+THREE.KeyframeTrack = function ( name, times, values, interpolation ) {
+
+	if( name === undefined ) throw new Error( "track name is undefined" );
+
+	if( times === undefined || times.length === 0 ) {
+
+		throw new Error( "no keyframes in track named " + name );
+
+	}
+
+	this.name = name;
+
+	this.times = THREE.AnimationUtils.convertArray( times, this.TimeBufferType );
+	this.values = THREE.AnimationUtils.convertArray( values, this.ValueBufferType );
+
+	this.setInterpolation( interpolation || this.DefaultInterpolation );
+
+	this.validate();
+	this.optimize();
+
+};
+
+THREE.KeyframeTrack.prototype = {
+
+	constructor: THREE.KeyframeTrack,
+
+	TimeBufferType: Float32Array,
+	ValueBufferType: Float32Array,
+
+	DefaultInterpolation: THREE.InterpolateLinear,
+
+	InterpolantFactoryMethodDiscrete: function( result ) {
+
+		return new THREE.DiscreteInterpolant(
+				this.times, this.values, this.getValueSize(), result );
+
+	},
+
+	InterpolantFactoryMethodLinear: function( result ) {
+
+		return new THREE.LinearInterpolant(
+				this.times, this.values, this.getValueSize(), result );
+
+	},
+
+	InterpolantFactoryMethodSmooth: function( result ) {
+
+		return new THREE.CubicInterpolant(
+				this.times, this.values, this.getValueSize(), result );
+
+	},
+
+	setInterpolation: function( interpolation ) {
+
+		var factoryMethod = undefined;
+
+		switch ( interpolation ) {
+
+			case THREE.InterpolateDiscrete:
+
+				factoryMethod = this.InterpolantFactoryMethodDiscrete;
+
+				break;
+
+			case THREE.InterpolateLinear:
+
+				factoryMethod = this.InterpolantFactoryMethodLinear;
+
+				break;
+
+			case THREE.InterpolateSmooth:
+
+				factoryMethod = this.InterpolantFactoryMethodSmooth;
+
+				break;
+
+		}
+
+		if ( factoryMethod === undefined ) {
+
+			var message = "unsupported interpolation for " +
+					this.ValueTypeName + " keyframe track named " + this.name;
+
+			if ( this.createInterpolant === undefined ) {
+
+				// fall back to default, unless the default itself is messed up
+				if ( interpolation !== this.DefaultInterpolation ) {
+
+					this.setInterpolation( this.DefaultInterpolation );
+
+				} else {
+
+					throw new Error( message ); // fatal, in this case
+
+				}
+
+			}
+
+			console.warn( message );
+			return;
+
+		}
+
+		this.createInterpolant = factoryMethod;
+
+	},
+
+	getInterpolation: function() {
+
+		switch ( this.createInterpolant ) {
+
+			case this.InterpolantFactoryMethodDiscrete:
+
+				return THREE.InterpolateDiscrete;
+
+			case this.InterpolantFactoryMethodLinear:
+
+				return THREE.InterpolateLinear;
+
+			case this.InterpolantFactoryMethodSmooth:
+
+				return THREE.InterpolateSmooth;
+
+		}
+
+	},
+
+	getValueSize: function() {
+
+		return this.values.length / this.times.length;
+
+	},
+
+	// move all keyframes either forwards or backwards in time
+	shift: function( timeOffset ) {
+
+		if( timeOffset !== 0.0 ) {
+
+			var times = this.times;
+
+			for( var i = 0, n = times.length; i !== n; ++ i ) {
+
+				times[ i ] += timeOffset;
+
+			}
+
+		}
+
+		return this;
+
+	},
+
+	// scale all keyframe times by a factor (useful for frame <-> 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 ] < startTime ) ++ from;
+		while ( to !== -1 && times[ to ] > 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 = THREE.AnimationUtils.arraySlice( times, from, to );
+			this.values = THREE.AnimationUtils.
+					arraySlice( this.values, from * stride, to * stride );
+
+		}
+
+		return this;
+
+	},
+
+	// ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable
+	validate: function() {
+
+		var valid = true;
+
+		var valueSize = this.getValueSize();
+		if ( valueSize - Math.floor( valueSize ) !== 0 ) {
+
+			console.error( "invalid value size in track", this );
+			valid = false;
+
+		}
+
+		var times = this.times,
+			values = this.values,
+
+			nKeys = times.length;
+
+		if( nKeys === 0 ) {
+
+			console.error( "track is empty", this );
+			valid = false;
+
+		}
+
+		var prevTime = null;
+
+		for( var i = 0; i !== nKeys; i ++ ) {
+
+			var currTime = times[ i ];
+
+			if ( typeof currTime === 'number' && isNaN( currTime ) ) {
+
+				console.error( "time is not a valid number", this, i, currTime );
+				valid = false;
+				break;
+
+			}
+
+			if( prevTime !== null && prevTime > currTime ) {
+
+				console.error( "out of order keys", this, i, currTime, prevTime );
+				valid = false;
+				break;
+
+			}
+
+			prevTime = currTime;
+
+		}
+
+		if ( values !== undefined ) {
+
+			if ( THREE.AnimationUtils.isTypedArray( values ) ) {
+
+				for ( var i = 0, n = values.length; i !== n; ++ i ) {
+
+					var value = values[ i ];
+
+					if ( isNaN( value ) ) {
+
+						console.error( "value is not a valid number", this, i, value );
+						valid = false;
+						break;
+
+					}
+
+				}
+
+			}
+
+		}
+
+		return valid;
+
+	},
+
+	// removes equivalent sequential keys as common in morph target sequences
+	// (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0)
+	optimize: function() {
+
+		var times = this.times,
+			values = this.values,
+			stride = this.getValueSize(),
+
+			writeIndex = 1;
+
+		for( var i = 1, n = times.length - 1; i <= n; ++ i ) {
+
+			var keep = false;
+
+			var time = times[ i ];
+			var timeNext = times[ i + 1 ];
+
+			// remove adjacent keyframes scheduled at the same time
+
+			if ( time !== timeNext && ( i !== 1 || time !== time[ 0 ] ) ) {
+
+				// remove unnecessary keyframes same as their neighbors
+				var offset = i * stride,
+					offsetP = offset - stride,
+					offsetN = offset + stride;
+
+				for ( var j = 0; j !== stride; ++ j ) {
+
+					var value = values[ offset + j ];
+
+					if ( value !== values[ offsetP + j ] ||
+							value !== values[ offsetN + j ] ) {
+
+						keep = true;
+						break;
+
+					}
+
+				}
+
+			}
+
+			// in-place compaction
+
+			if ( keep ) {
+
+				if ( i !== writeIndex ) {
+
+					times[ writeIndex ] = times[ i ];
+
+					var readOffset = i * stride,
+						writeOffset = writeIndex * stride;
+
+					for ( var j = 0; j !== stride; ++ j ) {
+
+						values[ writeOffset + j ] = values[ readOffset + j ];
+
+					}
+
+
+				}
+
+				++ writeIndex;
+
+			}
+
+		}
+
+		if ( writeIndex !== times.length ) {
+
+			this.times = THREE.AnimationUtils.arraySlice( times, 0, writeIndex );
+			this.values = THREE.AnimationUtils.arraySlice( values, 0, writeIndex * stride );
+
+		}
+
+		return this;
+
+	}
+
+};
+
+// Static methods:
+
+Object.assign( THREE.KeyframeTrack, {
+
+	// Serialization (in static context, because of constructor invocation
+	// and automatic invocation of .toJSON):
+
+	parse: function( json ) {
+
+		if( json.type === undefined ) {
+
+			throw new Error( "track type undefined, can not parse" );
+
+		}
+
+		var trackType = THREE.KeyframeTrack._getTrackTypeForValueTypeName( json.type );
+
+		if ( json.times === undefined ) {
+
+			console.warn( "legacy JSON format detected, converting" );
+
+			var times = [], values = [];
+
+			THREE.AnimationUtils.flattenJSON( json.keys, times, values, 'value' );
+
+			json.times = times;
+			json.values = values;
+
+		}
+
+		// derived classes can define a static parse method
+		if ( trackType.parse !== undefined ) {
+
+			return trackType.parse( json );
+
+		} else {
+
+			// by default, we asssume a constructor compatible with the base
+			return new trackType(
+					json.name, json.times, json.values, json.interpolation );
+
+		}
+
+	},
+
+	toJSON: function( track ) {
+
+		var trackType = track.constructor;
+
+		var json;
+
+		// derived classes can define a static toJSON method
+		if ( trackType.toJSON !== undefined ) {
+
+			json = trackType.toJSON( track );
+
+		} else {
+
+			// by default, we assume the data can be serialized as-is
+			json = {
+
+				'name': track.name,
+				'times': THREE.AnimationUtils.convertArray( track.times, Array ),
+				'values': THREE.AnimationUtils.convertArray( track.values, Array )
+
+			};
+
+			var interpolation = track.getInterpolation();
+
+			if ( interpolation !== track.DefaultInterpolation ) {
+
+				json.interpolation = interpolation;
+
+			}
+
+		}
+
+		json.type = track.ValueTypeName; // mandatory
+
+		return json;
+
+	},
+
+	_getTrackTypeForValueTypeName: function( typeName ) {
+
+		switch( typeName.toLowerCase() ) {
+
+			case "scalar":
+			case "double":
+			case "float":
+			case "number":
+			case "integer":
+
+				return THREE.NumberKeyframeTrack;
+
+			case "vector":
+			case "vector2":
+			case "vector3":
+			case "vector4":
+
+				return THREE.VectorKeyframeTrack;
+
+			case "color":
+
+				return THREE.ColorKeyframeTrack;
+
+			case "quaternion":
+
+				return THREE.QuaternionKeyframeTrack;
+
+			case "bool":
+			case "boolean":
+
+				return THREE.BooleanKeyframeTrack;
+
+			case "string":
+
+				return THREE.StringKeyframeTrack;
+
+		};
+
+		throw new Error( "Unsupported typeName: " + typeName );
+
+	}
+
+} );
+
+// File:src/animation/PropertyBinding.js
+
+/**
+ *
+ * A reference to a real property in the scene graph.
+ *
+ *
+ * @author Ben Houston / http://clara.io/
+ * @author David Sarno / http://lighthaus.us/
+ * @author tschw
+ */
+
+THREE.PropertyBinding = function ( rootNode, path, parsedPath ) {
+
+	this.path = path;
+	this.parsedPath = parsedPath ||
+			THREE.PropertyBinding.parseTrackName( path );
+
+	this.node = THREE.PropertyBinding.findNode(
+			rootNode, this.parsedPath.nodeName ) || rootNode;
+
+	this.rootNode = rootNode;
+
+};
+
+THREE.PropertyBinding.prototype = {
+
+	constructor: THREE.PropertyBinding,
+
+	getValue: function getValue_unbound( targetArray, offset ) {
+
+		this.bind();
+		this.getValue( targetArray, offset );
+
+		// Note: This class uses a State pattern on a per-method basis:
+		// 'bind' sets 'this.getValue' / 'setValue' and shadows the
+		// prototype version of these methods with one that represents
+		// the bound state. When the property is not found, the methods
+		// become no-ops.
+
+	},
+
+	setValue: function getValue_unbound( sourceArray, offset ) {
+
+		this.bind();
+		this.setValue( sourceArray, offset );
+
+	},
+
+	// create getter / setter pair for a property in the scene graph
+	bind: function() {
+
+		var targetObject = this.node,
+			parsedPath = this.parsedPath,
+
+			objectName = parsedPath.objectName,
+			propertyName = parsedPath.propertyName,
+			propertyIndex = parsedPath.propertyIndex;
+
+		if ( ! targetObject ) {
+
+			targetObject = THREE.PropertyBinding.findNode(
+					this.rootNode, parsedPath.nodeName ) || this.rootNode;
+
+			this.node = targetObject;
+
+		}
+
+		// set fail state so we can just 'return' on error
+		this.getValue = this._getValue_unavailable;
+		this.setValue = this._setValue_unavailable;
+
+ 		// ensure there is a value node
+		if ( ! targetObject ) {
+
+			console.error( "  trying to update node for track: " + this.path + " but it wasn't found." );
+			return;
+
+		}
+
+		if( objectName ) {
+
+			var objectIndex = parsedPath.objectIndex;
+
+			// special cases were we need to reach deeper into the hierarchy to get the face materials....
+			switch ( objectName ) {
+
+				case 'materials':
+
+					if( ! targetObject.material ) {
+
+						console.error( '  can not bind to material as node does not have a material', this );
+						return;
+
+					}
+
+					if( ! targetObject.material.materials ) {
+
+						console.error( '  can not bind to material.materials as node.material does not have a materials array', this );
+						return;
+
+					}
+
+					targetObject = targetObject.material.materials;
+
+					break;
+
+				case 'bones':
+
+					if( ! targetObject.skeleton ) {
+
+						console.error( '  can not bind to bones as node does not have a skeleton', this );
+						return;
+
+					}
+
+					// potential future optimization: skip this if propertyIndex is already an integer
+					// and convert the integer string to a true integer.
+
+					targetObject = targetObject.skeleton.bones;
+
+					// support resolving morphTarget names into indices.
+					for ( var i = 0; i < targetObject.length; i ++ ) {
+
+						if ( targetObject[i].name === objectIndex ) {
+
+							objectIndex = i;
+							break;
+
+						}
+
+					}
+
+					break;
+
+				default:
+
+					if ( targetObject[ objectName ] === undefined ) {
+
+						console.error( '  can not bind to objectName of node, undefined', this );
+						return;
+
+					}
+
+					targetObject = targetObject[ objectName ];
+
+			}
+
+
+			if ( objectIndex !== undefined ) {
+
+				if( targetObject[ objectIndex ] === undefined ) {
+
+					console.error( "  trying to bind to objectIndex of objectName, but is undefined:", this, targetObject );
+					return;
+
+				}
+
+				targetObject = targetObject[ objectIndex ];
+
+			}
+
+		}
+
+		// resolve property
+		var nodeProperty = targetObject[ propertyName ];
+
+		if ( ! nodeProperty ) {
+
+			var nodeName = parsedPath.nodeName;
+
+			console.error( "  trying to update property for track: " + nodeName +
+					'.' + propertyName + " but it wasn't found.", targetObject );
+			return;
+
+		}
+
+		// determine versioning scheme
+		var versioning = this.Versioning.None;
+
+		if ( targetObject.needsUpdate !== undefined ) { // material
+
+			versioning = this.Versioning.NeedsUpdate;
+			this.targetObject = targetObject;
+
+		} else if ( targetObject.matrixWorldNeedsUpdate !== undefined ) { // node transform
+
+			versioning = this.Versioning.MatrixWorldNeedsUpdate;
+			this.targetObject = targetObject;
+
+		}
+
+		// determine how the property gets bound
+		var bindingType = this.BindingType.Direct;
+
+		if ( propertyIndex !== undefined ) {
+			// access a sub element of the property array (only primitives are supported right now)
+
+			if ( propertyName === "morphTargetInfluences" ) {
+				// potential optimization, skip this if propertyIndex is already an integer, and convert the integer string to a true integer.
+
+				// support resolving morphTarget names into indices.
+				if ( ! targetObject.geometry ) {
+
+					console.error( '  can not bind to morphTargetInfluences becasuse node does not have a geometry', this );
+					return;
+
+				}
+
+				if ( ! targetObject.geometry.morphTargets ) {
+
+					console.error( '  can not bind to morphTargetInfluences becasuse node does not have a geometry.morphTargets', this );
+					return;
+
+				}
+
+				for ( var i = 0; i < this.node.geometry.morphTargets.length; i ++ ) {
+
+					if ( targetObject.geometry.morphTargets[i].name === propertyIndex ) {
+
+						propertyIndex = i;
+						break;
+
+					}
+
+				}
+
+			}
+
+			bindingType = this.BindingType.ArrayElement;
+
+			this.resolvedProperty = nodeProperty;
+			this.propertyIndex = propertyIndex;
+
+		} else if ( nodeProperty.fromArray !== undefined && nodeProperty.toArray !== undefined ) {
+			// must use copy for Object3D.Euler/Quaternion
+
+			bindingType = this.BindingType.HasFromToArray;
+
+			this.resolvedProperty = nodeProperty;
+
+		} else if ( nodeProperty.length !== undefined ) {
+
+			bindingType = this.BindingType.EntireArray;
+
+			this.resolvedProperty = nodeProperty;
+
+		} else {
+
+			this.propertyName = propertyName;
+
+		}
+
+		// select getter / setter
+		this.getValue = this.GetterByBindingType[ bindingType ];
+		this.setValue = this.SetterByBindingTypeAndVersioning[ bindingType ][ versioning ];
+
+	},
+
+	unbind: function() {
+
+		this.node = null;
+
+		// back to the prototype version of getValue / setValue
+		// note: avoiding to mutate the shape of 'this' via 'delete'
+		this.getValue = this._getValue_unbound;
+		this.setValue = this._setValue_unbound;
+
+	}
+
+};
+
+Object.assign( THREE.PropertyBinding.prototype, { // prototype, continued
+
+	// these are used to "bind" a nonexistent property
+	_getValue_unavailable: function() {},
+	_setValue_unavailable: function() {},
+
+	// initial state of these methods that calls 'bind'
+	_getValue_unbound: THREE.PropertyBinding.prototype.getValue,
+	_setValue_unbound: THREE.PropertyBinding.prototype.setValue,
+
+	BindingType: {
+		Direct: 0,
+		EntireArray: 1,
+		ArrayElement: 2,
+		HasFromToArray: 3
+	},
+
+	Versioning: {
+		None: 0,
+		NeedsUpdate: 1,
+		MatrixWorldNeedsUpdate: 2
+	},
+
+	GetterByBindingType: [
+
+		function getValue_direct( buffer, offset ) {
+
+			buffer[ offset ] = this.node[ this.propertyName ];
+
+		},
+
+		function getValue_array( buffer, offset ) {
+
+			var source = this.resolvedProperty;
+
+			for ( var i = 0, n = source.length; i !== n; ++ i ) {
+
+				buffer[ offset ++ ] = source[ i ];
+
+			}
+
+		},
+
+		function getValue_arrayElement( buffer, offset ) {
+
+			buffer[ offset ] = this.resolvedProperty[ this.propertyIndex ];
+
+		},
+
+		function getValue_toArray( buffer, offset ) {
+
+			this.resolvedProperty.toArray( buffer, offset );
+
+		}
+
+	],
+
+	SetterByBindingTypeAndVersioning: [
+
+		[
+			// Direct
+
+			function setValue_direct( buffer, offset ) {
+
+				this.node[ this.propertyName ] = buffer[ offset ];
+
+			},
+
+			function setValue_direct_setNeedsUpdate( buffer, offset ) {
+
+				this.node[ this.propertyName ] = buffer[ offset ];
+				this.targetObject.needsUpdate = true;
+
+			},
+
+			function setValue_direct_setMatrixWorldNeedsUpdate( buffer, offset ) {
+
+				this.node[ this.propertyName ] = buffer[ offset ];
+				this.targetObject.matrixWorldNeedsUpdate = true;
+
+			}
+
+		], [
+
+			// EntireArray
+
+			function setValue_array( buffer, offset ) {
+
+				var dest = this.resolvedProperty;
+
+				for ( var i = 0, n = dest.length; i !== n; ++ i ) {
+
+					dest[ i ] = buffer[ offset ++ ];
+
+				}
+
+			},
+
+			function setValue_array_setNeedsUpdate( buffer, offset ) {
+
+				var dest = this.resolvedProperty;
+
+				for ( var i = 0, n = dest.length; i !== n; ++ i ) {
+
+					dest[ i ] = buffer[ offset ++ ];
+
+				}
+
+				this.targetObject.needsUpdate = true;
+
+			},
+
+			function setValue_array_setMatrixWorldNeedsUpdate( buffer, offset ) {
+
+				var dest = this.resolvedProperty;
+
+				for ( var i = 0, n = dest.length; i !== n; ++ i ) {
+
+					dest[ i ] = buffer[ offset ++ ];
+
+				}
+
+				this.targetObject.matrixWorldNeedsUpdate = true;
+
+			}
+
+		], [
+
+			// ArrayElement
+
+			function setValue_arrayElement( buffer, offset ) {
+
+				this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];
+
+			},
+
+			function setValue_arrayElement_setNeedsUpdate( buffer, offset ) {
+
+				this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];
+				this.targetObject.needsUpdate = true;
+
+			},
+
+			function setValue_arrayElement_setMatrixWorldNeedsUpdate( buffer, offset ) {
+
+				this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];
+				this.targetObject.matrixWorldNeedsUpdate = true;
+
+			}
+
+		], [
+
+			// HasToFromArray
+
+			function setValue_fromArray( buffer, offset ) {
+
+				this.resolvedProperty.fromArray( buffer, offset );
+
+			},
+
+			function setValue_fromArray_setNeedsUpdate( buffer, offset ) {
+
+				this.resolvedProperty.fromArray( buffer, offset );
+				this.targetObject.needsUpdate = true;
+
+			},
+
+			function setValue_fromArray_setMatrixWorldNeedsUpdate( buffer, offset ) {
+
+				this.resolvedProperty.fromArray( buffer, offset );
+				this.targetObject.matrixWorldNeedsUpdate = true;
+
+			}
+
+		]
+
+	]
+
+} );
+
+THREE.PropertyBinding.Composite =
+		function( targetGroup, path, optionalParsedPath ) {
+
+	var parsedPath = optionalParsedPath ||
+			THREE.PropertyBinding.parseTrackName( path );
+
+	this._targetGroup = targetGroup;
+	this._bindings = targetGroup.subscribe_( path, parsedPath );
+
+};
+
+THREE.PropertyBinding.Composite.prototype = {
+
+	constructor: THREE.PropertyBinding.Composite,
+
+	getValue: function( array, offset ) {
+
+		this.bind(); // bind all binding
+
+		var firstValidIndex = this._targetGroup.nCachedObjects_,
+			binding = this._bindings[ firstValidIndex ];
+
+		// and only call .getValue on the first
+		if ( binding !== undefined ) binding.getValue( array, offset );
+
+	},
+
+	setValue: function( array, offset ) {
+
+		var bindings = this._bindings;
+
+		for ( var i = this._targetGroup.nCachedObjects_,
+				n = bindings.length; i !== n; ++ i ) {
+
+			bindings[ i ].setValue( array, offset );
+
+		}
+
+	},
+
+	bind: function() {
+
+		var bindings = this._bindings;
+
+		for ( var i = this._targetGroup.nCachedObjects_,
+				n = bindings.length; i !== n; ++ i ) {
+
+			bindings[ i ].bind();
+
+		}
+
+	},
+
+	unbind: function() {
+
+		var bindings = this._bindings;
+
+		for ( var i = this._targetGroup.nCachedObjects_,
+				n = bindings.length; i !== n; ++ i ) {
+
+			bindings[ i ].unbind();
+
+		}
+
+	}
+
+};
+
+THREE.PropertyBinding.create = function( root, path, parsedPath ) {
+
+	if ( ! ( root instanceof THREE.AnimationObjectGroup ) ) {
+
+		return new THREE.PropertyBinding( root, path, parsedPath );
+
+	} else {
+
+		return new THREE.PropertyBinding.Composite( root, path, parsedPath );
+
+	}
+
+};
+
+THREE.PropertyBinding.parseTrackName = function( trackName ) {
+
+	// matches strings in the form of:
+	//    nodeName.property
+	//    nodeName.property[accessor]
+	//    nodeName.material.property[accessor]
+	//    uuid.property[accessor]
+	//    uuid.objectName[objectIndex].propertyName[propertyIndex]
+	//    parentName/nodeName.property
+	//    parentName/parentName/nodeName.property[index]
+	//	  .bone[Armature.DEF_cog].position
+	// created and tested via https://regex101.com/#javascript
+
+	var re = /^(([\w]+\/)*)([\w-\d]+)?(\.([\w]+)(\[([\w\d\[\]\_.:\- ]+)\])?)?(\.([\w.]+)(\[([\w\d\[\]\_. ]+)\])?)$/;
+	var matches = re.exec(trackName);
+
+	if( ! matches ) {
+		throw new Error( "cannot parse trackName at all: " + trackName );
+	}
+
+    if (matches.index === re.lastIndex) {
+        re.lastIndex++;
+    }
+
+	var results = {
+		// directoryName: matches[1], // (tschw) currently unused
+		nodeName: matches[3], 	// allowed to be null, specified root node.
+		objectName: matches[5],
+		objectIndex: matches[7],
+		propertyName: matches[9],
+		propertyIndex: matches[11]	// allowed to be null, specifies that the whole property is set.
+	};
+
+	if( results.propertyName === null || results.propertyName.length === 0 ) {
+		throw new Error( "can not parse propertyName from trackName: " + trackName );
+	}
+
+	return results;
+
+};
+
+THREE.PropertyBinding.findNode = function( root, nodeName ) {
+
+	if( ! nodeName || nodeName === "" || nodeName === "root" || nodeName === "." || nodeName === -1 || nodeName === root.name || nodeName === root.uuid ) {
+
+		return root;
+
+	}
+
+	// search into skeleton bones.
+	if( root.skeleton ) {
+
+		var searchSkeleton = function( skeleton ) {
+
+			for( var i = 0; i < skeleton.bones.length; i ++ ) {
+
+				var bone = skeleton.bones[i];
+
+				if( bone.name === nodeName ) {
+
+					return bone;
+
+				}
+			}
+
+			return null;
+
+		};
+
+		var bone = searchSkeleton( root.skeleton );
+
+		if( bone ) {
+
+			return bone;
+
+		}
+	}
+
+	// search into node subtree.
+	if( root.children ) {
+
+		var searchNodeSubtree = function( children ) {
+
+			for( var i = 0; i < children.length; i ++ ) {
+
+				var childNode = children[i];
+
+				if( childNode.name === nodeName || childNode.uuid === nodeName ) {
+
+					return childNode;
+
+				}
+
+				var result = searchNodeSubtree( childNode.children );
+
+				if( result ) return result;
+
+			}
+
+			return null;
+
+		};
+
+		var subTreeNode = searchNodeSubtree( root.children );
+
+		if( subTreeNode ) {
+
+			return subTreeNode;
+
+		}
+
+	}
+
+	return null;
+
+}
+
+// File:src/animation/PropertyMixer.js
+
+/**
+ *
+ * Buffered scene graph property that allows weighted accumulation.
+ *
+ *
+ * @author Ben Houston / http://clara.io/
+ * @author David Sarno / http://lighthaus.us/
+ * @author tschw
+ */
+
+THREE.PropertyMixer = function ( binding, typeName, valueSize ) {
+
+	this.binding = binding;
+	this.valueSize = valueSize;
+
+	var bufferType = Float64Array,
+		mixFunction;
+
+	switch ( typeName ) {
+
+		case 'quaternion':			mixFunction = this._slerp;		break;
+
+		case 'string':
+		case 'bool':
+
+			bufferType = Array,		mixFunction = this._select;		break;
+
+		default:					mixFunction = this._lerp;
+
+	}
+
+	this.buffer = new bufferType( valueSize * 4 );
+	// layout: [ incoming | accu0 | accu1 | orig ]
+	//
+	// interpolators can use .buffer as their .result
+	// the data then goes to 'incoming'
+	//
+	// 'accu0' and 'accu1' are used frame-interleaved for
+	// the cumulative result and are compared to detect
+	// changes
+	//
+	// 'orig' stores the original state of the property
+
+	this._mixBufferRegion = mixFunction;
+
+	this.cumulativeWeight = 0;
+
+	this.useCount = 0;
+	this.referenceCount = 0;
+
+};
+
+THREE.PropertyMixer.prototype = {
+
+	constructor: THREE.PropertyMixer,
+
+	// accumulate data in the 'incoming' region into 'accu<i>'
+	accumulate: function( accuIndex, weight ) {
+
+		// note: happily accumulating nothing when weight = 0, the caller knows
+		// the weight and shouldn't have made the call in the first place
+
+		var buffer = this.buffer,
+			stride = this.valueSize,
+			offset = accuIndex * stride + stride,
+
+			currentWeight = this.cumulativeWeight;
+
+		if ( currentWeight === 0 ) {
+
+			// accuN := incoming * weight
+
+			for ( var i = 0; i !== stride; ++ i ) {
+
+				buffer[ offset + i ] = buffer[ i ];
+
+			}
+
+			currentWeight = weight;
+
+		} else {
+
+			// accuN := accuN + incoming * weight
+
+			currentWeight += weight;
+			var mix = weight / currentWeight;
+			this._mixBufferRegion( buffer, offset, 0, mix, stride );
+
+		}
+
+		this.cumulativeWeight = currentWeight;
+
+	},
+
+	// apply the state of 'accu<i>' to the binding when accus differ
+	apply: function( accuIndex ) {
+
+		var stride = this.valueSize,
+			buffer = this.buffer,
+			offset = accuIndex * stride + stride,
+
+			weight = this.cumulativeWeight,
+
+			binding = this.binding;
+
+		this.cumulativeWeight = 0;
+
+		if ( weight < 1 ) {
+
+			// accuN := accuN + original * ( 1 - cumulativeWeight )
+
+			var originalValueOffset = stride * 3;
+
+			this._mixBufferRegion(
+					buffer, offset, originalValueOffset, 1 - weight, stride );
+
+		}
+
+		for ( var i = stride, e = stride + stride; i !== e; ++ i ) {
+
+			if ( buffer[ i ] !== buffer[ i + stride ] ) {
+
+				// value has changed -> update scene graph
+
+				binding.setValue( buffer, offset );
+				break;
+
+			}
+
+		}
+
+	},
+
+	// remember the state of the bound property and copy it to both accus
+	saveOriginalState: function() {
+
+		var binding = this.binding;
+
+		var buffer = this.buffer,
+			stride = this.valueSize,
+
+			originalValueOffset = stride * 3;
+
+		binding.getValue( buffer, originalValueOffset );
+
+		// accu[0..1] := orig -- initially detect changes against the original
+		for ( var i = stride, e = originalValueOffset; i !== e; ++ i ) {
+
+			buffer[ i ] = buffer[ originalValueOffset + ( i % stride ) ];
+
+		}
+
+		this.cumulativeWeight = 0;
+
+	},
+
+	// apply the state previously taken via 'saveOriginalState' to the binding
+	restoreOriginalState: function() {
+
+		var originalValueOffset = this.valueSize * 3;
+		this.binding.setValue( this.buffer, originalValueOffset );
+
+	},
+
+
+	// mix functions
+
+	_select: function( buffer, dstOffset, srcOffset, t, stride ) {
+
+		if ( t >= 0.5 ) {
+
+			for ( var i = 0; i !== stride; ++ i ) {
+
+				buffer[ dstOffset + i ] = buffer[ srcOffset + i ];
+
+			}
+
+		}
+
+	},
+
+	_slerp: function( buffer, dstOffset, srcOffset, t, stride ) {
+
+		THREE.Quaternion.slerpFlat( buffer, dstOffset,
+				buffer, dstOffset, buffer, srcOffset, t );
+
+	},
+
+	_lerp: function( buffer, dstOffset, srcOffset, t, stride ) {
+
+		var s = 1 - t;
+
+		for ( var i = 0; i !== stride; ++ i ) {
+
+			var j = dstOffset + i;
+
+			buffer[ j ] = buffer[ j ] * s + buffer[ srcOffset + i ] * t;
+
+		}
+
+	}
+
+};
+
+// File:src/animation/tracks/BooleanKeyframeTrack.js
+
+/**
+ *
+ * A Track of Boolean keyframe values.
+ *
+ *
+ * @author Ben Houston / http://clara.io/
+ * @author David Sarno / http://lighthaus.us/
+ * @author tschw
+ */
+
+THREE.BooleanKeyframeTrack = function ( name, times, values ) {
+
+	THREE.KeyframeTrack.call( this, name, times, values );
+
+};
+
+THREE.BooleanKeyframeTrack.prototype =
+		Object.assign( Object.create( THREE.KeyframeTrack.prototype ), {
+
+	constructor: THREE.BooleanKeyframeTrack,
+
+	ValueTypeName: 'bool',
+	ValueBufferType: Array,
+
+	DefaultInterpolation: THREE.InterpolateDiscrete,
+
+	InterpolantFactoryMethodLinear: undefined,
+	InterpolantFactoryMethodSmooth: undefined
+
+	// Note: Actually this track could have a optimized / compressed
+	// representation of a single value and a custom interpolant that
+	// computes "firstValue ^ isOdd( index )".
+
+} );
+
+// File:src/animation/tracks/ColorKeyframeTrack.js
+
+/**
+ *
+ * A Track of keyframe values that represent color.
+ *
+ *
+ * @author Ben Houston / http://clara.io/
+ * @author David Sarno / http://lighthaus.us/
+ * @author tschw
+ */
+
+THREE.ColorKeyframeTrack = function ( name, times, values, interpolation ) {
+
+	THREE.KeyframeTrack.call( this, name, times, values, interpolation );
+
+};
+
+THREE.ColorKeyframeTrack.prototype =
+		Object.assign( Object.create( THREE.KeyframeTrack.prototype ), {
+
+	constructor: THREE.ColorKeyframeTrack,
+
+	ValueTypeName: 'color'
+
+	// ValueBufferType is inherited
+
+	// DefaultInterpolation is inherited
+
+
+	// Note: Very basic implementation and nothing special yet.
+	// However, this is the place for color space parameterization.
+
+} );
+
+// File:src/animation/tracks/NumberKeyframeTrack.js
+
+/**
+ *
+ * A Track of numeric keyframe values.
+ *
+ * @author Ben Houston / http://clara.io/
+ * @author David Sarno / http://lighthaus.us/
+ * @author tschw
+ */
+
+THREE.NumberKeyframeTrack = function ( name, times, values, interpolation ) {
+
+	THREE.KeyframeTrack.call( this, name, times, values, interpolation );
+
+};
+
+THREE.NumberKeyframeTrack.prototype =
+		Object.assign( Object.create( THREE.KeyframeTrack.prototype ), {
+
+	constructor: THREE.NumberKeyframeTrack,
+
+	ValueTypeName: 'number',
+
+	// ValueBufferType is inherited
+
+	// DefaultInterpolation is inherited
+
+} );
+
+// File:src/animation/tracks/QuaternionKeyframeTrack.js
+
+/**
+ *
+ * A Track of quaternion keyframe values.
+ *
+ * @author Ben Houston / http://clara.io/
+ * @author David Sarno / http://lighthaus.us/
+ * @author tschw
+ */
+
+THREE.QuaternionKeyframeTrack = function ( name, times, values, interpolation ) {
+
+	THREE.KeyframeTrack.call( this, name, times, values, interpolation );
+
+};
+
+THREE.QuaternionKeyframeTrack.prototype =
+		Object.assign( Object.create( THREE.KeyframeTrack.prototype ), {
+
+	constructor: THREE.QuaternionKeyframeTrack,
+
+	ValueTypeName: 'quaternion',
+
+	// ValueBufferType is inherited
+
+	DefaultInterpolation: THREE.InterpolateLinear,
+
+	InterpolantFactoryMethodLinear: function( result ) {
+
+		return new THREE.QuaternionLinearInterpolant(
+				this.times, this.values, this.getValueSize(), result );
+
+	},
+
+	InterpolantFactoryMethodSmooth: undefined // not yet implemented
+
+} );
+
+// File:src/animation/tracks/StringKeyframeTrack.js
+
+/**
+ *
+ * A Track that interpolates Strings
+ *
+ *
+ * @author Ben Houston / http://clara.io/
+ * @author David Sarno / http://lighthaus.us/
+ * @author tschw
+ */
+
+THREE.StringKeyframeTrack = function ( name, times, values, interpolation ) {
+
+	THREE.KeyframeTrack.call( this, name, times, values, interpolation );
+
+};
+
+THREE.StringKeyframeTrack.prototype =
+		Object.assign( Object.create( THREE.KeyframeTrack.prototype ), {
+
+	constructor: THREE.StringKeyframeTrack,
+
+	ValueTypeName: 'string',
+	ValueBufferType: Array,
+
+	DefaultInterpolation: THREE.InterpolateDiscrete,
+
+	InterpolantFactoryMethodLinear: undefined,
+
+	InterpolantFactoryMethodSmooth: undefined
+
+} );
+
+// File:src/animation/tracks/VectorKeyframeTrack.js
+
+/**
+ *
+ * A Track of vectored keyframe values.
+ *
+ *
+ * @author Ben Houston / http://clara.io/
+ * @author David Sarno / http://lighthaus.us/
+ * @author tschw
+ */
+
+THREE.VectorKeyframeTrack = function ( name, times, values, interpolation ) {
+
+	THREE.KeyframeTrack.call( this, name, times, values, interpolation );
+
+};
+
+THREE.VectorKeyframeTrack.prototype =
+		Object.assign( Object.create( THREE.KeyframeTrack.prototype ), {
+
+	constructor: THREE.VectorKeyframeTrack,
+
+	ValueTypeName: 'vector'
+
+	// ValueBufferType is inherited
+
+	// DefaultInterpolation is inherited
+
+} );
+
+// File:src/audio/Audio.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author Reece Aaron Lecrivain / http://reecenotes.com/
+ */
+
+THREE.Audio = function ( listener ) {
+
+	THREE.Object3D.call( this );
+
+	this.type = 'Audio';
+
+	this.context = listener.context;
+	this.source = this.context.createBufferSource();
+	this.source.onended = this.onEnded.bind( this );
+
+	this.gain = this.context.createGain();
+	this.gain.connect( listener.getInput() );
+
+	this.autoplay = false;
+
+	this.startTime = 0;
+	this.playbackRate = 1;
+	this.isPlaying = false;
+	this.hasPlaybackControl = true;
+	this.sourceType = 'empty';
+
+	this.filter = null;
+
+};
+
+THREE.Audio.prototype = Object.create( THREE.Object3D.prototype );
+THREE.Audio.prototype.constructor = THREE.Audio;
+
+THREE.Audio.prototype.getOutput = function () {
+
+	return this.gain;
+
+};
+
+THREE.Audio.prototype.setNodeSource = function ( audioNode ) {
+
+	this.hasPlaybackControl = false;
+	this.sourceType = 'audioNode';
+	this.source = audioNode;
+	this.connect();
+
+	return this;
+
+};
+
+THREE.Audio.prototype.setBuffer = function ( audioBuffer ) {
+
+	var scope = this;
+
+	scope.source.buffer = audioBuffer;
+	scope.sourceType = 'buffer';
+	if ( scope.autoplay ) scope.play();
+
+	return this;
+
+};
+
+THREE.Audio.prototype.play = function () {
+
+	if ( this.isPlaying === true ) {
+
+		console.warn( 'THREE.Audio: Audio is already playing.' );
+		return;
+
+	}
+
+	if ( this.hasPlaybackControl === false ) {
+
+		console.warn( 'THREE.Audio: this Audio has no playback control.' );
+		return;
+
+	}
+
+	var source = this.context.createBufferSource();
+
+	source.buffer = this.source.buffer;
+	source.loop = this.source.loop;
+	source.onended = this.source.onended;
+	source.start( 0, this.startTime );
+	source.playbackRate.value = this.playbackRate;
+
+	this.isPlaying = true;
+
+	this.source = source;
+
+	this.connect();
+
+};
+
+THREE.Audio.prototype.pause = function () {
+
+	if ( this.hasPlaybackControl === false ) {
+
+		console.warn( 'THREE.Audio: this Audio has no playback control.' );
+		return;
+
+	}
+
+	this.source.stop();
+	this.startTime = this.context.currentTime;
+
+};
+
+THREE.Audio.prototype.stop = function () {
+
+	if ( this.hasPlaybackControl === false ) {
+
+		console.warn( 'THREE.Audio: this Audio has no playback control.' );
+		return;
+
+	}
+
+	this.source.stop();
+	this.startTime = 0;
+
+};
+
+THREE.Audio.prototype.connect = function () {
+
+	if ( this.filter !== null ) {
+
+		this.source.connect( this.filter );
+		this.filter.connect( this.getOutput() );
+
+	} else {
+
+		this.source.connect( this.getOutput() );
+
+	}
+
+};
+
+THREE.Audio.prototype.disconnect = function () {
+
+	if ( this.filter !== null ) {
+
+		this.source.disconnect( this.filter );
+		this.filter.disconnect( this.getOutput() );
+
+	} else {
+
+		this.source.disconnect( this.getOutput() );
+
+	}
+
+};
+
+THREE.Audio.prototype.getFilter = function () {
+
+	return this.filter;
+
+};
+
+THREE.Audio.prototype.setFilter = function ( value ) {
+
+	if ( value === undefined ) value = null;
+
+	if ( this.isPlaying === true ) {
+
+		this.disconnect();
+		this.filter = value;
+		this.connect();
+
+	} else {
+
+		this.filter = value;
+
+	}
+
+};
+
+THREE.Audio.prototype.setPlaybackRate = function ( value ) {
+
+	if ( this.hasPlaybackControl === false ) {
+
+		console.warn( 'THREE.Audio: this Audio has no playback control.' );
+		return;
+
+	}
+
+	this.playbackRate = value;
+
+	if ( this.isPlaying === true ) {
+
+		this.source.playbackRate.value = this.playbackRate;
+
+	}
+
+};
+
+THREE.Audio.prototype.getPlaybackRate = function () {
+
+	return this.playbackRate;
+
+};
+
+THREE.Audio.prototype.onEnded = function () {
+
+	this.isPlaying = false;
+
+};
+
+THREE.Audio.prototype.setLoop = function ( value ) {
+
+	if ( this.hasPlaybackControl === false ) {
+
+		console.warn( 'THREE.Audio: this Audio has no playback control.' );
+		return;
+
+	}
+
+	this.source.loop = value;
+
+};
+
+THREE.Audio.prototype.getLoop = function () {
+
+	if ( this.hasPlaybackControl === false ) {
+
+		console.warn( 'THREE.Audio: this Audio has no playback control.' );
+		return false;
+
+	}
+
+	return this.source.loop;
+
+};
+
+
+THREE.Audio.prototype.setVolume = function ( value ) {
+
+	this.gain.gain.value = value;
+
+};
+
+THREE.Audio.prototype.getVolume = function () {
+
+	return this.gain.gain.value;
+
+};
+
+// File:src/audio/AudioAnalyser.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.AudioAnalyser = function ( audio, fftSize ) {
+
+	this.analyser = audio.context.createAnalyser();
+	this.analyser.fftSize = fftSize !== undefined ? fftSize : 2048;
+
+	this.data = new Uint8Array( this.analyser.frequencyBinCount );
+
+	audio.getOutput().connect( this.analyser );
+
+};
+
+THREE.AudioAnalyser.prototype = {
+
+	constructor: THREE.AudioAnalyser,
+
+	getData: function () {
+
+		this.analyser.getByteFrequencyData( this.data );
+		return this.data;
+
+	}
+
+};
+
+// File:src/audio/AudioContext.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+Object.defineProperty( THREE, 'AudioContext', {
+
+	get: ( function () {
+
+		var context;
+
+		return function () {
+
+			if ( context === undefined ) {
+
+				context = new ( window.AudioContext || window.webkitAudioContext )();
+
+			}
+
+			return context;
+
+		};
+
+	} )()
+
+} );
+
+// File:src/audio/PositionalAudio.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.PositionalAudio = function ( listener ) {
+
+	THREE.Audio.call( this, listener );
+
+	this.panner = this.context.createPanner();
+	this.panner.connect( this.gain );
+
+};
+
+THREE.PositionalAudio.prototype = Object.create( THREE.Audio.prototype );
+THREE.PositionalAudio.prototype.constructor = THREE.PositionalAudio;
+
+THREE.PositionalAudio.prototype.getOutput = function () {
+
+	return this.panner;
+
+};
+
+THREE.PositionalAudio.prototype.setRefDistance = function ( value ) {
+
+	this.panner.refDistance = value;
+
+};
+
+THREE.PositionalAudio.prototype.getRefDistance = function () {
+
+	return this.panner.refDistance;
+
+};
+
+THREE.PositionalAudio.prototype.setRolloffFactor = function ( value ) {
+
+	this.panner.rolloffFactor = value;
+
+};
+
+THREE.PositionalAudio.prototype.getRolloffFactor = function () {
+
+	return this.panner.rolloffFactor;
+
+};
+
+THREE.PositionalAudio.prototype.setDistanceModel = function ( value ) {
+
+	this.panner.distanceModel = value;
+
+};
+
+THREE.PositionalAudio.prototype.getDistanceModel = function () {
+
+	return this.panner.distanceModel;
+
+};
+
+THREE.PositionalAudio.prototype.setMaxDistance = function ( value ) {
+
+	this.panner.maxDistance = value;
+
+};
+
+THREE.PositionalAudio.prototype.getMaxDistance = function () {
+
+	return this.panner.maxDistance;
+
+};
+
+THREE.PositionalAudio.prototype.updateMatrixWorld = ( function () {
+
+	var position = new THREE.Vector3();
+
+	return function updateMatrixWorld( force ) {
+
+		THREE.Object3D.prototype.updateMatrixWorld.call( this, force );
+
+		position.setFromMatrixPosition( this.matrixWorld );
+
+		this.panner.setPosition( position.x, position.y, position.z );
+
+	};
+
+} )();
+
+// File:src/audio/AudioListener.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.AudioListener = function () {
+
+	THREE.Object3D.call( this );
+
+	this.type = 'AudioListener';
+
+	this.context = THREE.AudioContext;
+
+	this.gain = this.context.createGain();
+	this.gain.connect( this.context.destination );
+
+	this.filter = null;
+
+};
+
+THREE.AudioListener.prototype = Object.create( THREE.Object3D.prototype );
+THREE.AudioListener.prototype.constructor = THREE.AudioListener;
+
+THREE.AudioListener.prototype.getInput = function () {
+
+	return this.gain;
+
+};
+
+THREE.AudioListener.prototype.removeFilter = function ( ) {
+
+	if ( this.filter !== null ) {
+
+		this.gain.disconnect( this.filter );
+		this.filter.disconnect( this.context.destination );
+		this.gain.connect( this.context.destination );
+		this.filter = null;
+
+	}
+
+};
+
+THREE.AudioListener.prototype.setFilter = function ( value ) {
+
+	if ( this.filter !== null ) {
+
+		this.gain.disconnect( this.filter );
+		this.filter.disconnect( this.context.destination );
+
+	} else {
+
+		this.gain.disconnect( this.context.destination );
+
+	}
+
+	this.filter = value;
+	this.gain.connect( this.filter );
+	this.filter.connect( this.context.destination );
+
+};
+
+THREE.AudioListener.prototype.getFilter = function () {
+
+	return this.filter;
+
+};
+
+THREE.AudioListener.prototype.setMasterVolume = function ( value ) {
+
+	this.gain.gain.value = value;
+
+};
+
+THREE.AudioListener.prototype.getMasterVolume = function () {
+
+	return this.gain.gain.value;
+
+};
+
+
+THREE.AudioListener.prototype.updateMatrixWorld = ( function () {
+
+	var position = new THREE.Vector3();
+	var quaternion = new THREE.Quaternion();
+	var scale = new THREE.Vector3();
+
+	var orientation = new THREE.Vector3();
+
+	return function updateMatrixWorld( force ) {
+
+		THREE.Object3D.prototype.updateMatrixWorld.call( this, force );
+
+		var listener = this.context.listener;
+		var up = this.up;
+
+		this.matrixWorld.decompose( position, quaternion, scale );
+
+		orientation.set( 0, 0, - 1 ).applyQuaternion( quaternion );
+
+		listener.setPosition( position.x, position.y, position.z );
+		listener.setOrientation( orientation.x, orientation.y, orientation.z, up.x, up.y, up.z );
+
+	};
+
+} )();
+
+// File:src/cameras/Camera.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author mikael emtinger / http://gomo.se/
+ * @author WestLangley / http://github.com/WestLangley
+*/
+
+THREE.Camera = function () {
+
+	THREE.Object3D.call( this );
+
+	this.type = 'Camera';
+
+	this.matrixWorldInverse = new THREE.Matrix4();
+	this.projectionMatrix = new THREE.Matrix4();
+
+};
+
+THREE.Camera.prototype = Object.create( THREE.Object3D.prototype );
+THREE.Camera.prototype.constructor = THREE.Camera;
+
+THREE.Camera.prototype.getWorldDirection = function () {
+
+	var quaternion = new THREE.Quaternion();
+
+	return function ( optionalTarget ) {
+
+		var result = optionalTarget || new THREE.Vector3();
+
+		this.getWorldQuaternion( quaternion );
+
+		return result.set( 0, 0, - 1 ).applyQuaternion( quaternion );
+
+	};
+
+}();
+
+THREE.Camera.prototype.lookAt = function () {
+
+	// This routine does not support cameras with rotated and/or translated parent(s)
+
+	var m1 = new THREE.Matrix4();
+
+	return function ( vector ) {
+
+		m1.lookAt( this.position, vector, this.up );
+
+		this.quaternion.setFromRotationMatrix( m1 );
+
+	};
+
+}();
+
+THREE.Camera.prototype.clone = function () {
+
+	return new this.constructor().copy( this );
+
+};
+
+THREE.Camera.prototype.copy = function ( source ) {
+
+	THREE.Object3D.prototype.copy.call( this, source );
+
+	this.matrixWorldInverse.copy( source.matrixWorldInverse );
+	this.projectionMatrix.copy( source.projectionMatrix );
+
+	return this;
+
+};
+
+// File:src/cameras/CubeCamera.js
+
+/**
+ * Camera for rendering cube maps
+ *	- renders scene into axis-aligned cube
+ *
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.CubeCamera = function ( near, far, cubeResolution ) {
+
+	THREE.Object3D.call( this );
+
+	this.type = 'CubeCamera';
+
+	var fov = 90, aspect = 1;
+
+	var cameraPX = new THREE.PerspectiveCamera( fov, aspect, near, far );
+	cameraPX.up.set( 0, - 1, 0 );
+	cameraPX.lookAt( new THREE.Vector3( 1, 0, 0 ) );
+	this.add( cameraPX );
+
+	var cameraNX = new THREE.PerspectiveCamera( fov, aspect, near, far );
+	cameraNX.up.set( 0, - 1, 0 );
+	cameraNX.lookAt( new THREE.Vector3( - 1, 0, 0 ) );
+	this.add( cameraNX );
+
+	var cameraPY = new THREE.PerspectiveCamera( fov, aspect, near, far );
+	cameraPY.up.set( 0, 0, 1 );
+	cameraPY.lookAt( new THREE.Vector3( 0, 1, 0 ) );
+	this.add( cameraPY );
+
+	var cameraNY = new THREE.PerspectiveCamera( fov, aspect, near, far );
+	cameraNY.up.set( 0, 0, - 1 );
+	cameraNY.lookAt( new THREE.Vector3( 0, - 1, 0 ) );
+	this.add( cameraNY );
+
+	var cameraPZ = new THREE.PerspectiveCamera( fov, aspect, near, far );
+	cameraPZ.up.set( 0, - 1, 0 );
+	cameraPZ.lookAt( new THREE.Vector3( 0, 0, 1 ) );
+	this.add( cameraPZ );
+
+	var cameraNZ = new THREE.PerspectiveCamera( fov, aspect, near, far );
+	cameraNZ.up.set( 0, - 1, 0 );
+	cameraNZ.lookAt( new THREE.Vector3( 0, 0, - 1 ) );
+	this.add( cameraNZ );
+
+	var options = { format: THREE.RGBFormat, magFilter: THREE.LinearFilter, minFilter: THREE.LinearFilter };
+
+	this.renderTarget = new THREE.WebGLRenderTargetCube( cubeResolution, cubeResolution, options );
+
+	this.updateCubeMap = function ( renderer, scene ) {
+
+		if ( this.parent === null ) this.updateMatrixWorld();
+
+		var renderTarget = this.renderTarget;
+		var generateMipmaps = renderTarget.texture.generateMipmaps;
+
+		renderTarget.texture.generateMipmaps = false;
+
+		renderTarget.activeCubeFace = 0;
+		renderer.render( scene, cameraPX, renderTarget );
+
+		renderTarget.activeCubeFace = 1;
+		renderer.render( scene, cameraNX, renderTarget );
+
+		renderTarget.activeCubeFace = 2;
+		renderer.render( scene, cameraPY, renderTarget );
+
+		renderTarget.activeCubeFace = 3;
+		renderer.render( scene, cameraNY, renderTarget );
+
+		renderTarget.activeCubeFace = 4;
+		renderer.render( scene, cameraPZ, renderTarget );
+
+		renderTarget.texture.generateMipmaps = generateMipmaps;
+
+		renderTarget.activeCubeFace = 5;
+		renderer.render( scene, cameraNZ, renderTarget );
+
+		renderer.setRenderTarget( null );
+
+	};
+
+};
+
+THREE.CubeCamera.prototype = Object.create( THREE.Object3D.prototype );
+THREE.CubeCamera.prototype.constructor = THREE.CubeCamera;
+
+// File:src/cameras/OrthographicCamera.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.OrthographicCamera = function ( left, right, top, bottom, near, far ) {
+
+	THREE.Camera.call( this );
+
+	this.type = 'OrthographicCamera';
+
+	this.zoom = 1;
+
+	this.left = left;
+	this.right = right;
+	this.top = top;
+	this.bottom = bottom;
+
+	this.near = ( near !== undefined ) ? near : 0.1;
+	this.far = ( far !== undefined ) ? far : 2000;
+
+	this.updateProjectionMatrix();
+
+};
+
+THREE.OrthographicCamera.prototype = Object.create( THREE.Camera.prototype );
+THREE.OrthographicCamera.prototype.constructor = THREE.OrthographicCamera;
+
+THREE.OrthographicCamera.prototype.updateProjectionMatrix = function () {
+
+	var dx = ( this.right - this.left ) / ( 2 * this.zoom );
+	var dy = ( this.top - this.bottom ) / ( 2 * this.zoom );
+	var cx = ( this.right + this.left ) / 2;
+	var cy = ( this.top + this.bottom ) / 2;
+
+	this.projectionMatrix.makeOrthographic( cx - dx, cx + dx, cy + dy, cy - dy, this.near, this.far );
+
+};
+
+THREE.OrthographicCamera.prototype.copy = function ( source ) {
+
+	THREE.Camera.prototype.copy.call( this, source );
+
+	this.left = source.left;
+	this.right = source.right;
+	this.top = source.top;
+	this.bottom = source.bottom;
+	this.near = source.near;
+	this.far = source.far;
+
+	this.zoom = source.zoom;
+
+	return this;
+
+};
+
+THREE.OrthographicCamera.prototype.toJSON = function ( meta ) {
+
+	var data = THREE.Object3D.prototype.toJSON.call( this, meta );
+
+	data.object.zoom = this.zoom;
+	data.object.left = this.left;
+	data.object.right = this.right;
+	data.object.top = this.top;
+	data.object.bottom = this.bottom;
+	data.object.near = this.near;
+	data.object.far = this.far;
+
+	return data;
+
+};
+
+// File:src/cameras/PerspectiveCamera.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author greggman / http://games.greggman.com/
+ * @author zz85 / http://www.lab4games.net/zz85/blog
+ * @author tschw
+ */
+
+THREE.PerspectiveCamera = function( fov, aspect, near, far ) {
+
+	THREE.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();
+
+};
+
+THREE.PerspectiveCamera.prototype = Object.create( THREE.Camera.prototype );
+THREE.PerspectiveCamera.prototype.constructor = THREE.PerspectiveCamera;
+
+
+/**
+ * Sets the FOV by focal length (DEPRECATED).
+ *
+ * Optionally also sets .filmGauge, otherwise uses it. See .setFocalLength.
+ */
+THREE.PerspectiveCamera.prototype.setLens = function( focalLength, filmGauge ) {
+
+	console.warn( "THREE.PerspectiveCamera.setLens is deprecated. " +
+			"Use .setFocalLength and .filmGauge for a photographic setup." );
+
+	if ( filmGauge !== undefined ) this.filmGauge = filmGauge;
+	this.setFocalLength( focalLength );
+
+};
+
+/**
+ * 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.
+ */
+THREE.PerspectiveCamera.prototype.setFocalLength = function( focalLength ) {
+
+	// see http://www.bobatkins.com/photography/technical/field_of_view.html
+	var vExtentSlope = 0.5 * this.getFilmHeight() / focalLength;
+
+	this.fov = THREE.Math.RAD2DEG * 2 * Math.atan( vExtentSlope );
+	this.updateProjectionMatrix();
+
+};
+
+
+/**
+ * Calculates the focal length from the current .fov and .filmGauge.
+ */
+THREE.PerspectiveCamera.prototype.getFocalLength = function() {
+
+	var vExtentSlope = Math.tan( THREE.Math.DEG2RAD * 0.5 * this.fov );
+
+	return 0.5 * this.getFilmHeight() / vExtentSlope;
+
+};
+
+THREE.PerspectiveCamera.prototype.getEffectiveFOV = function() {
+
+	return THREE.Math.RAD2DEG * 2 * Math.atan(
+			Math.tan( THREE.Math.DEG2RAD * 0.5 * this.fov ) / this.zoom );
+
+};
+
+THREE.PerspectiveCamera.prototype.getFilmWidth = function() {
+
+	// film not completely covered in portrait format (aspect < 1)
+	return this.filmGauge * Math.min( this.aspect, 1 );
+
+};
+
+THREE.PerspectiveCamera.prototype.getFilmHeight = function() {
+
+	// film not completely covered in landscape 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.setOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );
+ *   --B--
+ *   camera.setOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );
+ *   --C--
+ *   camera.setOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );
+ *   --D--
+ *   camera.setOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );
+ *   --E--
+ *   camera.setOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );
+ *   --F--
+ *   camera.setOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );
+ *
+ *   Note there is no reason monitors have to be the same size or in a grid.
+ */
+THREE.PerspectiveCamera.prototype.setViewOffset = function( fullWidth, fullHeight, x, y, width, height ) {
+
+	this.aspect = fullWidth / fullHeight;
+
+	this.view = {
+		fullWidth: fullWidth,
+		fullHeight: fullHeight,
+		offsetX: x,
+		offsetY: y,
+		width: width,
+		height: height
+	};
+
+	this.updateProjectionMatrix();
+
+};
+
+THREE.PerspectiveCamera.prototype.updateProjectionMatrix = function() {
+
+	var near = this.near,
+		top = near * Math.tan(
+				THREE.Math.DEG2RAD * 0.5 * this.fov ) / this.zoom,
+		height = 2 * top,
+		width = this.aspect * height,
+		left = - 0.5 * width,
+		view = this.view;
+
+	if ( view !== null ) {
+
+		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.makeFrustum(
+			left, left + width, top - height, top, near, this.far );
+
+};
+
+THREE.PerspectiveCamera.prototype.copy = function( source ) {
+
+	THREE.Camera.prototype.copy.call( this, source );
+
+	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;
+
+};
+
+THREE.PerspectiveCamera.prototype.toJSON = function( meta ) {
+
+	var data = THREE.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;
+
+};
+
+// File:src/cameras/StereoCamera.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.StereoCamera = function () {
+
+	this.type = 'StereoCamera';
+
+	this.aspect = 1;
+
+	this.cameraL = new THREE.PerspectiveCamera();
+	this.cameraL.layers.enable( 1 );
+	this.cameraL.matrixAutoUpdate = false;
+
+	this.cameraR = new THREE.PerspectiveCamera();
+	this.cameraR.layers.enable( 2 );
+	this.cameraR.matrixAutoUpdate = false;
+
+};
+
+THREE.StereoCamera.prototype = {
+
+	constructor: THREE.StereoCamera,
+
+	update: ( function () {
+
+		var focus, fov, aspect, near, far;
+
+		var eyeRight = new THREE.Matrix4();
+		var eyeLeft = new THREE.Matrix4();
+
+		return function update ( camera ) {
+
+			var needsUpdate = focus !== camera.focus || fov !== camera.fov ||
+												aspect !== camera.aspect * this.aspect || near !== camera.near ||
+												far !== camera.far;
+
+			if ( needsUpdate ) {
+
+				focus = camera.focus;
+				fov = camera.fov;
+				aspect = camera.aspect * this.aspect;
+				near = camera.near;
+				far = camera.far;
+
+				// Off-axis stereoscopic effect based on
+				// http://paulbourke.net/stereographics/stereorender/
+
+				var projectionMatrix = camera.projectionMatrix.clone();
+				var eyeSep = 0.064 / 2;
+				var eyeSepOnProjection = eyeSep * near / focus;
+				var ymax = near * Math.tan( THREE.Math.DEG2RAD * fov * 0.5 );
+				var xmin, xmax;
+
+				// translate xOffset
+
+				eyeLeft.elements[ 12 ] = - eyeSep;
+				eyeRight.elements[ 12 ] = eyeSep;
+
+				// for left eye
+
+				xmin = - ymax * aspect + eyeSepOnProjection;
+				xmax = ymax * aspect + eyeSepOnProjection;
+
+				projectionMatrix.elements[ 0 ] = 2 * near / ( xmax - xmin );
+				projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );
+
+				this.cameraL.projectionMatrix.copy( projectionMatrix );
+
+				// for right eye
+
+				xmin = - ymax * aspect - eyeSepOnProjection;
+				xmax = ymax * aspect - eyeSepOnProjection;
+
+				projectionMatrix.elements[ 0 ] = 2 * near / ( xmax - xmin );
+				projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );
+
+				this.cameraR.projectionMatrix.copy( projectionMatrix );
+
+			}
+
+			this.cameraL.matrixWorld.copy( camera.matrixWorld ).multiply( eyeLeft );
+			this.cameraR.matrixWorld.copy( camera.matrixWorld ).multiply( eyeRight );
+
+		};
+
+	} )()
+
+};
+
+// File:src/lights/Light.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.Light = function ( color, intensity ) {
+
+	THREE.Object3D.call( this );
+
+	this.type = 'Light';
+
+	this.color = new THREE.Color( color );
+	this.intensity = intensity !== undefined ? intensity : 1;
+
+	this.receiveShadow = undefined;
+
+};
+
+THREE.Light.prototype = Object.create( THREE.Object3D.prototype );
+THREE.Light.prototype.constructor = THREE.Light;
+
+THREE.Light.prototype.copy = function ( source ) {
+
+	THREE.Object3D.prototype.copy.call( this, source );
+
+	this.color.copy( source.color );
+	this.intensity = source.intensity;
+
+	return this;
+
+};
+
+THREE.Light.prototype.toJSON = function ( meta ) {
+
+	var data = THREE.Object3D.prototype.toJSON.call( this, meta );
+
+	data.object.color = this.color.getHex();
+	data.object.intensity = this.intensity;
+
+	if ( this.groundColor !== undefined ) data.object.groundColor = this.groundColor.getHex();
+
+	if ( this.distance !== undefined ) data.object.distance = this.distance;
+	if ( this.angle !== undefined ) data.object.angle = this.angle;
+	if ( this.decay !== undefined ) data.object.decay = this.decay;
+	if ( this.penumbra !== undefined ) data.object.penumbra = this.penumbra;
+
+	return data;
+
+};
+
+// File:src/lights/LightShadow.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.LightShadow = function ( camera ) {
+
+	this.camera = camera;
+
+	this.bias = 0;
+	this.radius = 1;
+
+	this.mapSize = new THREE.Vector2( 512, 512 );
+
+	this.map = null;
+	this.matrix = new THREE.Matrix4();
+
+};
+
+THREE.LightShadow.prototype = {
+
+	constructor: THREE.LightShadow,
+
+	copy: function ( source ) {
+
+		this.camera = source.camera.clone();
+
+		this.bias = source.bias;
+		this.radius = source.radius;
+
+		this.mapSize.copy( source.mapSize );
+
+		return this;
+
+	},
+
+	clone: function () {
+
+		return new this.constructor().copy( this );
+
+	}
+
+};
+
+// File:src/lights/AmbientLight.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.AmbientLight = function ( color, intensity ) {
+
+	THREE.Light.call( this, color, intensity );
+
+	this.type = 'AmbientLight';
+
+	this.castShadow = undefined;
+
+};
+
+THREE.AmbientLight.prototype = Object.create( THREE.Light.prototype );
+THREE.AmbientLight.prototype.constructor = THREE.AmbientLight;
+
+// File:src/lights/DirectionalLight.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.DirectionalLight = function ( color, intensity ) {
+
+	THREE.Light.call( this, color, intensity );
+
+	this.type = 'DirectionalLight';
+
+	this.position.set( 0, 1, 0 );
+	this.updateMatrix();
+
+	this.target = new THREE.Object3D();
+
+	this.shadow = new THREE.DirectionalLightShadow();
+
+};
+
+THREE.DirectionalLight.prototype = Object.create( THREE.Light.prototype );
+THREE.DirectionalLight.prototype.constructor = THREE.DirectionalLight;
+
+THREE.DirectionalLight.prototype.copy = function ( source ) {
+
+	THREE.Light.prototype.copy.call( this, source );
+
+	this.target = source.target.clone();
+
+	this.shadow = source.shadow.clone();
+
+	return this;
+
+};
+
+// File:src/lights/DirectionalLightShadow.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.DirectionalLightShadow = function ( light ) {
+
+	THREE.LightShadow.call( this, new THREE.OrthographicCamera( - 5, 5, 5, - 5, 0.5, 500 ) );
+
+};
+
+THREE.DirectionalLightShadow.prototype = Object.create( THREE.LightShadow.prototype );
+THREE.DirectionalLightShadow.prototype.constructor = THREE.DirectionalLightShadow;
+
+// File:src/lights/HemisphereLight.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.HemisphereLight = function ( skyColor, groundColor, intensity ) {
+
+	THREE.Light.call( this, skyColor, intensity );
+
+	this.type = 'HemisphereLight';
+
+	this.castShadow = undefined;
+
+	this.position.set( 0, 1, 0 );
+	this.updateMatrix();
+
+	this.groundColor = new THREE.Color( groundColor );
+
+};
+
+THREE.HemisphereLight.prototype = Object.create( THREE.Light.prototype );
+THREE.HemisphereLight.prototype.constructor = THREE.HemisphereLight;
+
+THREE.HemisphereLight.prototype.copy = function ( source ) {
+
+	THREE.Light.prototype.copy.call( this, source );
+
+	this.groundColor.copy( source.groundColor );
+
+	return this;
+
+};
+
+// File:src/lights/PointLight.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+
+THREE.PointLight = function ( color, intensity, distance, decay ) {
+
+	THREE.Light.call( this, color, intensity );
+
+	this.type = 'PointLight';
+
+	this.distance = ( distance !== undefined ) ? distance : 0;
+	this.decay = ( decay !== undefined ) ? decay : 1;	// for physically correct lights, should be 2.
+
+	this.shadow = new THREE.LightShadow( new THREE.PerspectiveCamera( 90, 1, 0.5, 500 ) );
+
+};
+
+THREE.PointLight.prototype = Object.create( THREE.Light.prototype );
+THREE.PointLight.prototype.constructor = THREE.PointLight;
+
+Object.defineProperty( THREE.PointLight.prototype, "power", {
+
+	get: function () {
+
+		// intensity = power per solid angle.
+		// ref: equation (15) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf
+		return this.intensity * 4 * Math.PI;
+
+	},
+
+	set: function ( power ) {
+
+		// intensity = power per solid angle.
+		// ref: equation (15) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf
+		this.intensity = power / ( 4 * Math.PI );
+
+	}
+
+} );
+
+THREE.PointLight.prototype.copy = function ( source ) {
+
+	THREE.Light.prototype.copy.call( this, source );
+
+	this.distance = source.distance;
+	this.decay = source.decay;
+
+	this.shadow = source.shadow.clone();
+
+	return this;
+
+};
+
+// File:src/lights/SpotLight.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.SpotLight = function ( color, intensity, distance, angle, penumbra, decay ) {
+
+	THREE.Light.call( this, color, intensity );
+
+	this.type = 'SpotLight';
+
+	this.position.set( 0, 1, 0 );
+	this.updateMatrix();
+
+	this.target = new THREE.Object3D();
+
+	this.distance = ( distance !== undefined ) ? distance : 0;
+	this.angle = ( angle !== undefined ) ? angle : Math.PI / 3;
+	this.penumbra = ( penumbra !== undefined ) ? penumbra : 0;
+	this.decay = ( decay !== undefined ) ? decay : 1;	// for physically correct lights, should be 2.
+
+	this.shadow = new THREE.SpotLightShadow();
+
+};
+
+THREE.SpotLight.prototype = Object.create( THREE.Light.prototype );
+THREE.SpotLight.prototype.constructor = THREE.SpotLight;
+
+Object.defineProperty( THREE.SpotLight.prototype, "power", {
+
+	get: function () {
+
+		// intensity = power per solid angle.
+		// ref: equation (17) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf
+		return this.intensity * Math.PI;
+
+	},
+
+	set: function ( power ) {
+
+		// intensity = power per solid angle.
+		// ref: equation (17) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf
+		this.intensity = power / Math.PI;
+
+	}
+
+} );
+
+THREE.SpotLight.prototype.copy = function ( source ) {
+
+	THREE.Light.prototype.copy.call( this, source );
+
+	this.distance = source.distance;
+	this.angle = source.angle;
+	this.penumbra = source.penumbra;
+	this.decay = source.decay;
+
+	this.target = source.target.clone();
+
+	this.shadow = source.shadow.clone();
+
+	return this;
+
+};
+
+// File:src/lights/SpotLightShadow.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.SpotLightShadow = function () {
+
+	THREE.LightShadow.call( this, new THREE.PerspectiveCamera( 50, 1, 0.5, 500 ) );
+
+};
+
+THREE.SpotLightShadow.prototype = Object.create( THREE.LightShadow.prototype );
+THREE.SpotLightShadow.prototype.constructor = THREE.SpotLightShadow;
+
+THREE.SpotLightShadow.prototype.update = function ( light ) {
+
+	var fov = THREE.Math.RAD2DEG * 2 * light.angle;
+	var aspect = this.mapSize.width / this.mapSize.height;
+	var far = light.distance || 500;
+
+	var camera = this.camera;
+
+	if ( fov !== camera.fov || aspect !== camera.aspect || far !== camera.far ) {
+
+		camera.fov = fov;
+		camera.aspect = aspect;
+		camera.far = far;
+		camera.updateProjectionMatrix();
+
+	}
+
+};
+
+// File:src/loaders/AudioLoader.js
+
+/**
+ * @author Reece Aaron Lecrivain / http://reecenotes.com/
+ */
+
+THREE.AudioLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+
+};
+
+THREE.AudioLoader.prototype = {
+
+	constructor: THREE.AudioLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		var loader = new THREE.XHRLoader( this.manager );
+		loader.setResponseType( 'arraybuffer' );
+		loader.load( url, function ( buffer ) {
+
+			var context = THREE.AudioContext;
+
+			context.decodeAudioData( buffer, function ( audioBuffer ) {
+
+				onLoad( audioBuffer );
+
+			} );
+
+		}, onProgress, onError );
+
+	}
+
+};
+
+// File:src/loaders/Cache.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.Cache = {
+
+	enabled: false,
+
+	files: {},
+
+	add: function ( key, file ) {
+
+		if ( this.enabled === false ) return;
+
+		// console.log( 'THREE.Cache', 'Adding key:', key );
+
+		this.files[ key ] = file;
+
+	},
+
+	get: function ( key ) {
+
+		if ( this.enabled === false ) return;
+
+		// console.log( 'THREE.Cache', 'Checking key:', key );
+
+		return this.files[ key ];
+
+	},
+
+	remove: function ( key ) {
+
+		delete this.files[ key ];
+
+	},
+
+	clear: function () {
+
+		this.files = {};
+
+	}
+
+};
+
+// File:src/loaders/Loader.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.Loader = function () {
+
+	this.onLoadStart = function () {};
+	this.onLoadProgress = function () {};
+	this.onLoadComplete = function () {};
+
+};
+
+THREE.Loader.prototype = {
+
+	constructor: THREE.Loader,
+
+	crossOrigin: undefined,
+
+	extractUrlBase: function ( url ) {
+
+		var parts = url.split( '/' );
+
+		if ( parts.length === 1 ) return './';
+
+		parts.pop();
+
+		return parts.join( '/' ) + '/';
+
+	},
+
+	initMaterials: function ( materials, texturePath, crossOrigin ) {
+
+		var array = [];
+
+		for ( var i = 0; i < materials.length; ++ i ) {
+
+			array[ i ] = this.createMaterial( materials[ i ], texturePath, crossOrigin );
+
+		}
+
+		return array;
+
+	},
+
+	createMaterial: ( function () {
+
+		var color, textureLoader, materialLoader;
+
+		return function ( m, texturePath, crossOrigin ) {
+
+			if ( color === undefined ) color = new THREE.Color();
+			if ( textureLoader === undefined ) textureLoader = new THREE.TextureLoader();
+			if ( materialLoader === undefined ) materialLoader = new THREE.MaterialLoader();
+
+			// convert from old material format
+
+			var textures = {};
+
+			function loadTexture( path, repeat, offset, wrap, anisotropy ) {
+
+				var fullPath = texturePath + path;
+				var loader = THREE.Loader.Handlers.get( fullPath );
+
+				var texture;
+
+				if ( loader !== null ) {
+
+					texture = loader.load( fullPath );
+
+				} else {
+
+					textureLoader.setCrossOrigin( crossOrigin );
+					texture = textureLoader.load( fullPath );
+
+				}
+
+				if ( repeat !== undefined ) {
+
+					texture.repeat.fromArray( repeat );
+
+					if ( repeat[ 0 ] !== 1 ) texture.wrapS = THREE.RepeatWrapping;
+					if ( repeat[ 1 ] !== 1 ) texture.wrapT = THREE.RepeatWrapping;
+
+				}
+
+				if ( offset !== undefined ) {
+
+					texture.offset.fromArray( offset );
+
+				}
+
+				if ( wrap !== undefined ) {
+
+					if ( wrap[ 0 ] === 'repeat' ) texture.wrapS = THREE.RepeatWrapping;
+					if ( wrap[ 0 ] === 'mirror' ) texture.wrapS = THREE.MirroredRepeatWrapping;
+
+					if ( wrap[ 1 ] === 'repeat' ) texture.wrapT = THREE.RepeatWrapping;
+					if ( wrap[ 1 ] === 'mirror' ) texture.wrapT = THREE.MirroredRepeatWrapping;
+
+				}
+
+				if ( anisotropy !== undefined ) {
+
+					texture.anisotropy = anisotropy;
+
+				}
+
+				var uuid = THREE.Math.generateUUID();
+
+				textures[ uuid ] = texture;
+
+				return uuid;
+
+			}
+
+			//
+
+			var json = {
+				uuid: THREE.Math.generateUUID(),
+				type: 'MeshLambertMaterial'
+			};
+
+			for ( var name in m ) {
+
+				var value = m[ name ];
+
+				switch ( name ) {
+					case 'DbgColor':
+					case 'DbgIndex':
+					case 'opticalDensity':
+					case 'illumination':
+						break;
+					case 'DbgName':
+						json.name = value;
+						break;
+					case 'blending':
+						json.blending = THREE[ value ];
+						break;
+					case 'colorAmbient':
+					case 'mapAmbient':
+						console.warn( 'THREE.Loader.createMaterial:', name, 'is no longer supported.' );
+						break;
+					case 'colorDiffuse':
+						json.color = color.fromArray( value ).getHex();
+						break;
+					case 'colorSpecular':
+						json.specular = color.fromArray( value ).getHex();
+						break;
+					case 'colorEmissive':
+						json.emissive = color.fromArray( value ).getHex();
+						break;
+					case 'specularCoef':
+						json.shininess = value;
+						break;
+					case 'shading':
+						if ( value.toLowerCase() === 'basic' ) json.type = 'MeshBasicMaterial';
+						if ( value.toLowerCase() === 'phong' ) json.type = 'MeshPhongMaterial';
+						break;
+					case 'mapDiffuse':
+						json.map = loadTexture( value, m.mapDiffuseRepeat, m.mapDiffuseOffset, m.mapDiffuseWrap, m.mapDiffuseAnisotropy );
+						break;
+					case 'mapDiffuseRepeat':
+					case 'mapDiffuseOffset':
+					case 'mapDiffuseWrap':
+					case 'mapDiffuseAnisotropy':
+						break;
+					case 'mapLight':
+						json.lightMap = loadTexture( value, m.mapLightRepeat, m.mapLightOffset, m.mapLightWrap, m.mapLightAnisotropy );
+						break;
+					case 'mapLightRepeat':
+					case 'mapLightOffset':
+					case 'mapLightWrap':
+					case 'mapLightAnisotropy':
+						break;
+					case 'mapAO':
+						json.aoMap = loadTexture( value, m.mapAORepeat, m.mapAOOffset, m.mapAOWrap, m.mapAOAnisotropy );
+						break;
+					case 'mapAORepeat':
+					case 'mapAOOffset':
+					case 'mapAOWrap':
+					case 'mapAOAnisotropy':
+						break;
+					case 'mapBump':
+						json.bumpMap = loadTexture( value, m.mapBumpRepeat, m.mapBumpOffset, m.mapBumpWrap, m.mapBumpAnisotropy );
+						break;
+					case 'mapBumpScale':
+						json.bumpScale = value;
+						break;
+					case 'mapBumpRepeat':
+					case 'mapBumpOffset':
+					case 'mapBumpWrap':
+					case 'mapBumpAnisotropy':
+						break;
+					case 'mapNormal':
+						json.normalMap = loadTexture( value, m.mapNormalRepeat, m.mapNormalOffset, m.mapNormalWrap, m.mapNormalAnisotropy );
+						break;
+					case 'mapNormalFactor':
+						json.normalScale = [ value, value ];
+						break;
+					case 'mapNormalRepeat':
+					case 'mapNormalOffset':
+					case 'mapNormalWrap':
+					case 'mapNormalAnisotropy':
+						break;
+					case 'mapSpecular':
+						json.specularMap = loadTexture( value, m.mapSpecularRepeat, m.mapSpecularOffset, m.mapSpecularWrap, m.mapSpecularAnisotropy );
+						break;
+					case 'mapSpecularRepeat':
+					case 'mapSpecularOffset':
+					case 'mapSpecularWrap':
+					case 'mapSpecularAnisotropy':
+						break;
+					case 'mapAlpha':
+						json.alphaMap = loadTexture( value, m.mapAlphaRepeat, m.mapAlphaOffset, m.mapAlphaWrap, m.mapAlphaAnisotropy );
+						break;
+					case 'mapAlphaRepeat':
+					case 'mapAlphaOffset':
+					case 'mapAlphaWrap':
+					case 'mapAlphaAnisotropy':
+						break;
+					case 'flipSided':
+						json.side = THREE.BackSide;
+						break;
+					case 'doubleSided':
+						json.side = THREE.DoubleSide;
+						break;
+					case 'transparency':
+						console.warn( 'THREE.Loader.createMaterial: transparency has been renamed to opacity' );
+						json.opacity = value;
+						break;
+					case 'depthTest':
+					case 'depthWrite':
+					case 'colorWrite':
+					case 'opacity':
+					case 'reflectivity':
+					case 'transparent':
+					case 'visible':
+					case 'wireframe':
+						json[ name ] = value;
+						break;
+					case 'vertexColors':
+						if ( value === true ) json.vertexColors = THREE.VertexColors;
+						if ( value === 'face' ) json.vertexColors = THREE.FaceColors;
+						break;
+					default:
+						console.error( 'THREE.Loader.createMaterial: Unsupported', name, value );
+						break;
+				}
+
+			}
+
+			if ( json.type === 'MeshBasicMaterial' ) delete json.emissive;
+			if ( json.type !== 'MeshPhongMaterial' ) delete json.specular;
+
+			if ( json.opacity < 1 ) json.transparent = true;
+
+			materialLoader.setTextures( textures );
+
+			return materialLoader.parse( json );
+
+		};
+
+	} )()
+
+};
+
+THREE.Loader.Handlers = {
+
+	handlers: [],
+
+	add: function ( regex, loader ) {
+
+		this.handlers.push( regex, loader );
+
+	},
+
+	get: function ( file ) {
+
+		var handlers = this.handlers;
+
+		for ( var i = 0, l = handlers.length; i < l; i += 2 ) {
+
+			var regex = handlers[ i ];
+			var loader  = handlers[ i + 1 ];
+
+			if ( regex.test( file ) ) {
+
+				return loader;
+
+			}
+
+		}
+
+		return null;
+
+	}
+
+};
+
+// File:src/loaders/XHRLoader.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.XHRLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+
+};
+
+THREE.XHRLoader.prototype = {
+
+	constructor: THREE.XHRLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		if ( this.path !== undefined ) url = this.path + url;
+
+		var scope = this;
+
+		var cached = THREE.Cache.get( url );
+
+		if ( cached !== undefined ) {
+
+			if ( onLoad ) {
+
+				setTimeout( function () {
+
+					onLoad( cached );
+
+				}, 0 );
+
+			}
+
+			return cached;
+
+		}
+
+		var request = new XMLHttpRequest();
+		request.overrideMimeType( 'text/plain' );
+		request.open( 'GET', url, true );
+
+		request.addEventListener( 'load', function ( event ) {
+
+			var response = event.target.response;
+
+			THREE.Cache.add( url, response );
+
+			if ( this.status === 200 ) {
+
+				if ( onLoad ) onLoad( response );
+
+				scope.manager.itemEnd( url );
+
+			} else if ( this.status === 0 ) {
+
+				// Some browsers return HTTP Status 0 when using non-http protocol
+				// e.g. 'file://' or 'data://'. Handle as success.
+
+				console.warn( 'THREE.XHRLoader: HTTP Status 0 received.' );
+
+				if ( onLoad ) onLoad( response );
+
+				scope.manager.itemEnd( url );
+
+			} else {
+
+				if ( onError ) onError( event );
+
+				scope.manager.itemError( url );
+
+			}
+
+		}, false );
+
+		if ( onProgress !== undefined ) {
+
+			request.addEventListener( 'progress', function ( event ) {
+
+				onProgress( event );
+
+			}, false );
+
+		}
+
+		request.addEventListener( 'error', function ( event ) {
+
+			if ( onError ) onError( event );
+
+			scope.manager.itemError( url );
+
+		}, false );
+
+		if ( this.responseType !== undefined ) request.responseType = this.responseType;
+		if ( this.withCredentials !== undefined ) request.withCredentials = this.withCredentials;
+
+		request.send( null );
+
+		scope.manager.itemStart( url );
+
+		return request;
+
+	},
+
+	setPath: function ( value ) {
+
+		this.path = value;
+
+	},
+
+	setResponseType: function ( value ) {
+
+		this.responseType = value;
+
+	},
+
+	setWithCredentials: function ( value ) {
+
+		this.withCredentials = value;
+
+	}
+
+};
+
+// File:src/loaders/FontLoader.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.FontLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+
+};
+
+THREE.FontLoader.prototype = {
+
+	constructor: THREE.FontLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		var loader = new THREE.XHRLoader( this.manager );
+		loader.load( url, function ( text ) {
+
+			onLoad( new THREE.Font( JSON.parse( text.substring( 65, text.length - 2 ) ) ) );
+
+		}, onProgress, onError );
+
+	}
+
+};
+
+// File:src/loaders/ImageLoader.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.ImageLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+
+};
+
+THREE.ImageLoader.prototype = {
+
+	constructor: THREE.ImageLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		if ( this.path !== undefined ) url = this.path + url;
+
+		var scope = this;
+
+		var cached = THREE.Cache.get( url );
+
+		if ( cached !== undefined ) {
+
+			scope.manager.itemStart( url );
+
+			if ( onLoad ) {
+
+				setTimeout( function () {
+
+					onLoad( cached );
+
+					scope.manager.itemEnd( url );
+
+				}, 0 );
+
+			} else {
+
+				scope.manager.itemEnd( url );
+
+			}
+
+			return cached;
+
+		}
+
+		var image = document.createElement( 'img' );
+
+		image.addEventListener( 'load', function ( event ) {
+
+			THREE.Cache.add( url, this );
+
+			if ( onLoad ) onLoad( this );
+
+			scope.manager.itemEnd( url );
+
+		}, false );
+
+		if ( onProgress !== undefined ) {
+
+			image.addEventListener( 'progress', function ( event ) {
+
+				onProgress( event );
+
+			}, false );
+
+		}
+
+		image.addEventListener( 'error', function ( event ) {
+
+			if ( onError ) onError( event );
+
+			scope.manager.itemError( url );
+
+		}, false );
+
+		if ( this.crossOrigin !== undefined ) image.crossOrigin = this.crossOrigin;
+
+		scope.manager.itemStart( url );
+
+		image.src = url;
+
+		return image;
+
+	},
+
+	setCrossOrigin: function ( value ) {
+
+		this.crossOrigin = value;
+
+	},
+
+	setPath: function ( value ) {
+
+		this.path = value;
+
+	}
+
+};
+
+// File:src/loaders/JSONLoader.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.JSONLoader = function ( manager ) {
+
+	if ( typeof manager === 'boolean' ) {
+
+		console.warn( 'THREE.JSONLoader: showStatus parameter has been removed from constructor.' );
+		manager = undefined;
+
+	}
+
+	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+
+	this.withCredentials = false;
+
+};
+
+THREE.JSONLoader.prototype = {
+
+	constructor: THREE.JSONLoader,
+
+	// Deprecated
+
+	get statusDomElement () {
+
+		if ( this._statusDomElement === undefined ) {
+
+			this._statusDomElement = document.createElement( 'div' );
+
+		}
+
+		console.warn( 'THREE.JSONLoader: .statusDomElement has been removed.' );
+		return this._statusDomElement;
+
+	},
+
+	load: function( url, onLoad, onProgress, onError ) {
+
+		var scope = this;
+
+		var texturePath = this.texturePath && ( typeof this.texturePath === "string" ) ? this.texturePath : THREE.Loader.prototype.extractUrlBase( url );
+
+		var loader = new THREE.XHRLoader( this.manager );
+		loader.setWithCredentials( this.withCredentials );
+		loader.load( url, function ( text ) {
+
+			var json = JSON.parse( text );
+			var metadata = json.metadata;
+
+			if ( metadata !== undefined ) {
+
+				var type = metadata.type;
+
+				if ( type !== undefined ) {
+
+					if ( type.toLowerCase() === 'object' ) {
+
+						console.error( 'THREE.JSONLoader: ' + url + ' should be loaded with THREE.ObjectLoader instead.' );
+						return;
+
+					}
+
+					if ( type.toLowerCase() === 'scene' ) {
+
+						console.error( 'THREE.JSONLoader: ' + url + ' should be loaded with THREE.SceneLoader instead.' );
+						return;
+
+					}
+
+				}
+
+			}
+
+			var object = scope.parse( json, texturePath );
+			onLoad( object.geometry, object.materials );
+
+		}, onProgress, onError );
+
+	},
+
+	setTexturePath: function ( value ) {
+
+		this.texturePath = value;
+
+	},
+
+	parse: function ( json, texturePath ) {
+
+		var geometry = new THREE.Geometry(),
+		scale = ( json.scale !== undefined ) ? 1.0 / json.scale : 1.0;
+
+		parseModel( scale );
+
+		parseSkin();
+		parseMorphing( scale );
+		parseAnimations();
+
+		geometry.computeFaceNormals();
+		geometry.computeBoundingSphere();
+
+		function parseModel( scale ) {
+
+			function isBitSet( value, position ) {
+
+				return value & ( 1 << position );
+
+			}
+
+			var i, j, fi,
+
+			offset, zLength,
+
+		colorIndex, normalIndex, uvIndex, materialIndex,
+
+			type,
+			isQuad,
+			hasMaterial,
+			hasFaceVertexUv,
+			hasFaceNormal, hasFaceVertexNormal,
+			hasFaceColor, hasFaceVertexColor,
+
+		vertex, face, faceA, faceB, hex, normal,
+
+			uvLayer, uv, u, v,
+
+			faces = json.faces,
+			vertices = json.vertices,
+			normals = json.normals,
+			colors = json.colors,
+
+			nUvLayers = 0;
+
+			if ( json.uvs !== undefined ) {
+
+				// disregard empty arrays
+
+				for ( i = 0; i < json.uvs.length; i ++ ) {
+
+					if ( json.uvs[ i ].length ) nUvLayers ++;
+
+				}
+
+				for ( i = 0; i < nUvLayers; i ++ ) {
+
+					geometry.faceVertexUvs[ i ] = [];
+
+				}
+
+			}
+
+			offset = 0;
+			zLength = vertices.length;
+
+			while ( offset < zLength ) {
+
+				vertex = new THREE.Vector3();
+
+				vertex.x = vertices[ offset ++ ] * scale;
+				vertex.y = vertices[ offset ++ ] * scale;
+				vertex.z = vertices[ offset ++ ] * scale;
+
+				geometry.vertices.push( vertex );
+
+			}
+
+			offset = 0;
+			zLength = faces.length;
+
+			while ( offset < zLength ) {
+
+				type = faces[ offset ++ ];
+
+
+				isQuad              = isBitSet( type, 0 );
+				hasMaterial         = isBitSet( type, 1 );
+				hasFaceVertexUv     = isBitSet( type, 3 );
+				hasFaceNormal       = isBitSet( type, 4 );
+				hasFaceVertexNormal = isBitSet( type, 5 );
+				hasFaceColor	     = isBitSet( type, 6 );
+				hasFaceVertexColor  = isBitSet( type, 7 );
+
+				// console.log("type", type, "bits", isQuad, hasMaterial, hasFaceVertexUv, hasFaceNormal, hasFaceVertexNormal, hasFaceColor, hasFaceVertexColor);
+
+				if ( isQuad ) {
+
+					faceA = new THREE.Face3();
+					faceA.a = faces[ offset ];
+					faceA.b = faces[ offset + 1 ];
+					faceA.c = faces[ offset + 3 ];
+
+					faceB = new THREE.Face3();
+					faceB.a = faces[ offset + 1 ];
+					faceB.b = faces[ offset + 2 ];
+					faceB.c = faces[ offset + 3 ];
+
+					offset += 4;
+
+					if ( hasMaterial ) {
+
+						materialIndex = faces[ offset ++ ];
+						faceA.materialIndex = materialIndex;
+						faceB.materialIndex = materialIndex;
+
+					}
+
+					// to get face <=> uv index correspondence
+
+					fi = geometry.faces.length;
+
+					if ( hasFaceVertexUv ) {
+
+						for ( i = 0; i < nUvLayers; i ++ ) {
+
+							uvLayer = json.uvs[ i ];
+
+							geometry.faceVertexUvs[ i ][ fi ] = [];
+							geometry.faceVertexUvs[ i ][ fi + 1 ] = [];
+
+							for ( j = 0; j < 4; j ++ ) {
+
+								uvIndex = faces[ offset ++ ];
+
+								u = uvLayer[ uvIndex * 2 ];
+								v = uvLayer[ uvIndex * 2 + 1 ];
+
+								uv = new THREE.Vector2( u, v );
+
+								if ( j !== 2 ) geometry.faceVertexUvs[ i ][ fi ].push( uv );
+								if ( j !== 0 ) geometry.faceVertexUvs[ i ][ fi + 1 ].push( uv );
+
+							}
+
+						}
+
+					}
+
+					if ( hasFaceNormal ) {
+
+						normalIndex = faces[ offset ++ ] * 3;
+
+						faceA.normal.set(
+							normals[ normalIndex ++ ],
+							normals[ normalIndex ++ ],
+							normals[ normalIndex ]
+						);
+
+						faceB.normal.copy( faceA.normal );
+
+					}
+
+					if ( hasFaceVertexNormal ) {
+
+						for ( i = 0; i < 4; i ++ ) {
+
+							normalIndex = faces[ offset ++ ] * 3;
+
+							normal = new THREE.Vector3(
+								normals[ normalIndex ++ ],
+								normals[ normalIndex ++ ],
+								normals[ normalIndex ]
+							);
+
+
+							if ( i !== 2 ) faceA.vertexNormals.push( normal );
+							if ( i !== 0 ) faceB.vertexNormals.push( normal );
+
+						}
+
+					}
+
+
+					if ( hasFaceColor ) {
+
+						colorIndex = faces[ offset ++ ];
+						hex = colors[ colorIndex ];
+
+						faceA.color.setHex( hex );
+						faceB.color.setHex( hex );
+
+					}
+
+
+					if ( hasFaceVertexColor ) {
+
+						for ( i = 0; i < 4; i ++ ) {
+
+							colorIndex = faces[ offset ++ ];
+							hex = colors[ colorIndex ];
+
+							if ( i !== 2 ) faceA.vertexColors.push( new THREE.Color( hex ) );
+							if ( i !== 0 ) faceB.vertexColors.push( new THREE.Color( hex ) );
+
+						}
+
+					}
+
+					geometry.faces.push( faceA );
+					geometry.faces.push( faceB );
+
+				} else {
+
+					face = new THREE.Face3();
+					face.a = faces[ offset ++ ];
+					face.b = faces[ offset ++ ];
+					face.c = faces[ offset ++ ];
+
+					if ( hasMaterial ) {
+
+						materialIndex = faces[ offset ++ ];
+						face.materialIndex = materialIndex;
+
+					}
+
+					// to get face <=> uv index correspondence
+
+					fi = geometry.faces.length;
+
+					if ( hasFaceVertexUv ) {
+
+						for ( i = 0; i < nUvLayers; i ++ ) {
+
+							uvLayer = json.uvs[ i ];
+
+							geometry.faceVertexUvs[ i ][ fi ] = [];
+
+							for ( j = 0; j < 3; j ++ ) {
+
+								uvIndex = faces[ offset ++ ];
+
+								u = uvLayer[ uvIndex * 2 ];
+								v = uvLayer[ uvIndex * 2 + 1 ];
+
+								uv = new THREE.Vector2( u, v );
+
+								geometry.faceVertexUvs[ i ][ fi ].push( uv );
+
+							}
+
+						}
+
+					}
+
+					if ( hasFaceNormal ) {
+
+						normalIndex = faces[ offset ++ ] * 3;
+
+						face.normal.set(
+							normals[ normalIndex ++ ],
+							normals[ normalIndex ++ ],
+							normals[ normalIndex ]
+						);
+
+					}
+
+					if ( hasFaceVertexNormal ) {
+
+						for ( i = 0; i < 3; i ++ ) {
+
+							normalIndex = faces[ offset ++ ] * 3;
+
+							normal = new THREE.Vector3(
+								normals[ normalIndex ++ ],
+								normals[ normalIndex ++ ],
+								normals[ normalIndex ]
+							);
+
+							face.vertexNormals.push( normal );
+
+						}
+
+					}
+
+
+					if ( hasFaceColor ) {
+
+						colorIndex = faces[ offset ++ ];
+						face.color.setHex( colors[ colorIndex ] );
+
+					}
+
+
+					if ( hasFaceVertexColor ) {
+
+						for ( i = 0; i < 3; i ++ ) {
+
+							colorIndex = faces[ offset ++ ];
+							face.vertexColors.push( new THREE.Color( colors[ colorIndex ] ) );
+
+						}
+
+					}
+
+					geometry.faces.push( face );
+
+				}
+
+			}
+
+		};
+
+		function parseSkin() {
+
+			var influencesPerVertex = ( json.influencesPerVertex !== undefined ) ? json.influencesPerVertex : 2;
+
+			if ( json.skinWeights ) {
+
+				for ( var i = 0, l = json.skinWeights.length; i < l; i += influencesPerVertex ) {
+
+					var x =                               json.skinWeights[ i ];
+					var y = ( influencesPerVertex > 1 ) ? json.skinWeights[ i + 1 ] : 0;
+					var z = ( influencesPerVertex > 2 ) ? json.skinWeights[ i + 2 ] : 0;
+					var w = ( influencesPerVertex > 3 ) ? json.skinWeights[ i + 3 ] : 0;
+
+					geometry.skinWeights.push( new THREE.Vector4( x, y, z, w ) );
+
+				}
+
+			}
+
+			if ( json.skinIndices ) {
+
+				for ( var i = 0, l = json.skinIndices.length; i < l; i += influencesPerVertex ) {
+
+					var a =                               json.skinIndices[ i ];
+					var b = ( influencesPerVertex > 1 ) ? json.skinIndices[ i + 1 ] : 0;
+					var c = ( influencesPerVertex > 2 ) ? json.skinIndices[ i + 2 ] : 0;
+					var d = ( influencesPerVertex > 3 ) ? json.skinIndices[ i + 3 ] : 0;
+
+					geometry.skinIndices.push( new THREE.Vector4( a, b, c, d ) );
+
+				}
+
+			}
+
+			geometry.bones = json.bones;
+
+			if ( geometry.bones && geometry.bones.length > 0 && ( geometry.skinWeights.length !== geometry.skinIndices.length || geometry.skinIndices.length !== geometry.vertices.length ) ) {
+
+				console.warn( 'When skinning, number of vertices (' + geometry.vertices.length + '), skinIndices (' +
+					geometry.skinIndices.length + '), and skinWeights (' + geometry.skinWeights.length + ') should match.' );
+
+			}
+
+		};
+
+		function parseMorphing( scale ) {
+
+			if ( json.morphTargets !== undefined ) {
+
+				for ( var i = 0, l = json.morphTargets.length; i < l; i ++ ) {
+
+					geometry.morphTargets[ i ] = {};
+					geometry.morphTargets[ i ].name = json.morphTargets[ i ].name;
+					geometry.morphTargets[ i ].vertices = [];
+
+					var dstVertices = geometry.morphTargets[ i ].vertices;
+					var srcVertices = json.morphTargets[ i ].vertices;
+
+					for ( var v = 0, vl = srcVertices.length; v < vl; v += 3 ) {
+
+						var vertex = new THREE.Vector3();
+						vertex.x = srcVertices[ v ] * scale;
+						vertex.y = srcVertices[ v + 1 ] * scale;
+						vertex.z = srcVertices[ v + 2 ] * scale;
+
+						dstVertices.push( vertex );
+
+					}
+
+				}
+
+			}
+
+			if ( json.morphColors !== undefined && json.morphColors.length > 0 ) {
+
+				console.warn( 'THREE.JSONLoader: "morphColors" no longer supported. Using them as face colors.' );
+
+				var faces = geometry.faces;
+				var morphColors = json.morphColors[ 0 ].colors;
+
+				for ( var i = 0, l = faces.length; i < l; i ++ ) {
+
+					faces[ i ].color.fromArray( morphColors, i * 3 );
+
+				}
+
+			}
+
+		}
+
+		function parseAnimations() {
+
+			var outputAnimations = [];
+
+			// parse old style Bone/Hierarchy animations
+			var animations = [];
+
+			if ( json.animation !== undefined ) {
+
+				animations.push( json.animation );
+
+			}
+
+			if ( json.animations !== undefined ) {
+
+				if ( json.animations.length ) {
+
+					animations = animations.concat( json.animations );
+
+				} else {
+
+					animations.push( json.animations );
+
+				}
+
+			}
+
+			for ( var i = 0; i < animations.length; i ++ ) {
+
+				var clip = THREE.AnimationClip.parseAnimation( animations[ i ], geometry.bones );
+				if ( clip ) outputAnimations.push( clip );
+
+			}
+
+			// parse implicit morph animations
+			if ( geometry.morphTargets ) {
+
+				// TODO: Figure out what an appropraite FPS is for morph target animations -- defaulting to 10, but really it is completely arbitrary.
+				var morphAnimationClips = THREE.AnimationClip.CreateClipsFromMorphTargetSequences( geometry.morphTargets, 10 );
+				outputAnimations = outputAnimations.concat( morphAnimationClips );
+
+			}
+
+			if ( outputAnimations.length > 0 ) geometry.animations = outputAnimations;
+
+		};
+
+		if ( json.materials === undefined || json.materials.length === 0 ) {
+
+			return { geometry: geometry };
+
+		} else {
+
+			var materials = THREE.Loader.prototype.initMaterials( json.materials, texturePath, this.crossOrigin );
+
+			return { geometry: geometry, materials: materials };
+
+		}
+
+	}
+
+};
+
+// File:src/loaders/LoadingManager.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.LoadingManager = function ( onLoad, onProgress, onError ) {
+
+	var scope = this;
+
+	var isLoading = false, itemsLoaded = 0, itemsTotal = 0;
+
+	this.onStart = undefined;
+	this.onLoad = onLoad;
+	this.onProgress = onProgress;
+	this.onError = onError;
+
+	this.itemStart = function ( url ) {
+
+		itemsTotal ++;
+
+		if ( isLoading === false ) {
+
+			if ( scope.onStart !== undefined ) {
+
+				scope.onStart( url, itemsLoaded, itemsTotal );
+
+			}
+
+		}
+
+		isLoading = true;
+
+	};
+
+	this.itemEnd = function ( url ) {
+
+		itemsLoaded ++;
+
+		if ( scope.onProgress !== undefined ) {
+
+			scope.onProgress( url, itemsLoaded, itemsTotal );
+
+		}
+
+		if ( itemsLoaded === itemsTotal ) {
+
+			isLoading = false;
+
+			if ( scope.onLoad !== undefined ) {
+
+				scope.onLoad();
+
+			}
+
+		}
+
+	};
+
+	this.itemError = function ( url ) {
+
+		if ( scope.onError !== undefined ) {
+
+			scope.onError( url );
+
+		}
+
+	};
+
+};
+
+THREE.DefaultLoadingManager = new THREE.LoadingManager();
+
+// File:src/loaders/BufferGeometryLoader.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.BufferGeometryLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+
+};
+
+THREE.BufferGeometryLoader.prototype = {
+
+	constructor: THREE.BufferGeometryLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		var scope = this;
+
+		var loader = new THREE.XHRLoader( scope.manager );
+		loader.load( url, function ( text ) {
+
+			onLoad( scope.parse( JSON.parse( text ) ) );
+
+		}, onProgress, onError );
+
+	},
+
+	parse: function ( json ) {
+
+		var geometry = new THREE.BufferGeometry();
+
+		var index = json.data.index;
+
+		var TYPED_ARRAYS = {
+			'Int8Array': Int8Array,
+			'Uint8Array': Uint8Array,
+			'Uint8ClampedArray': Uint8ClampedArray,
+			'Int16Array': Int16Array,
+			'Uint16Array': Uint16Array,
+			'Int32Array': Int32Array,
+			'Uint32Array': Uint32Array,
+			'Float32Array': Float32Array,
+			'Float64Array': Float64Array
+		};
+
+		if ( index !== undefined ) {
+
+			var typedArray = new TYPED_ARRAYS[ index.type ]( index.array );
+			geometry.setIndex( new THREE.BufferAttribute( typedArray, 1 ) );
+
+		}
+
+		var attributes = json.data.attributes;
+
+		for ( var key in attributes ) {
+
+			var attribute = attributes[ key ];
+			var typedArray = new TYPED_ARRAYS[ attribute.type ]( attribute.array );
+
+			geometry.addAttribute( key, new THREE.BufferAttribute( typedArray, attribute.itemSize, attribute.normalized ) );
+
+		}
+
+		var groups = json.data.groups || json.data.drawcalls || json.data.offsets;
+
+		if ( groups !== undefined ) {
+
+			for ( var i = 0, n = groups.length; i !== n; ++ i ) {
+
+				var group = groups[ i ];
+
+				geometry.addGroup( group.start, group.count, group.materialIndex );
+
+			}
+
+		}
+
+		var boundingSphere = json.data.boundingSphere;
+
+		if ( boundingSphere !== undefined ) {
+
+			var center = new THREE.Vector3();
+
+			if ( boundingSphere.center !== undefined ) {
+
+				center.fromArray( boundingSphere.center );
+
+			}
+
+			geometry.boundingSphere = new THREE.Sphere( center, boundingSphere.radius );
+
+		}
+
+		return geometry;
+
+	}
+
+};
+
+// File:src/loaders/MaterialLoader.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.MaterialLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+	this.textures = {};
+
+};
+
+THREE.MaterialLoader.prototype = {
+
+	constructor: THREE.MaterialLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		var scope = this;
+
+		var loader = new THREE.XHRLoader( scope.manager );
+		loader.load( url, function ( text ) {
+
+			onLoad( scope.parse( JSON.parse( text ) ) );
+
+		}, onProgress, onError );
+
+	},
+
+	setTextures: function ( value ) {
+
+		this.textures = value;
+
+	},
+
+	getTexture: function ( name ) {
+
+		var textures = this.textures;
+
+		if ( textures[ name ] === undefined ) {
+
+			console.warn( 'THREE.MaterialLoader: Undefined texture', name );
+
+		}
+
+		return textures[ name ];
+
+	},
+
+	parse: function ( json ) {
+
+		var material = new THREE[ json.type ];
+
+		if ( json.uuid !== undefined ) material.uuid = json.uuid;
+		if ( json.name !== undefined ) material.name = json.name;
+		if ( json.color !== undefined ) material.color.setHex( json.color );
+		if ( json.roughness !== undefined ) material.roughness = json.roughness;
+		if ( json.metalness !== undefined ) material.metalness = json.metalness;
+		if ( json.emissive !== undefined ) material.emissive.setHex( json.emissive );
+		if ( json.specular !== undefined ) material.specular.setHex( json.specular );
+		if ( json.shininess !== undefined ) material.shininess = json.shininess;
+		if ( json.uniforms !== undefined ) material.uniforms = json.uniforms;
+		if ( json.vertexShader !== undefined ) material.vertexShader = json.vertexShader;
+		if ( json.fragmentShader !== undefined ) material.fragmentShader = json.fragmentShader;
+		if ( json.vertexColors !== undefined ) material.vertexColors = json.vertexColors;
+		if ( json.shading !== undefined ) material.shading = json.shading;
+		if ( json.blending !== undefined ) material.blending = json.blending;
+		if ( json.side !== undefined ) material.side = json.side;
+		if ( json.opacity !== undefined ) material.opacity = json.opacity;
+		if ( json.transparent !== undefined ) material.transparent = json.transparent;
+		if ( json.alphaTest !== undefined ) material.alphaTest = json.alphaTest;
+		if ( json.depthTest !== undefined ) material.depthTest = json.depthTest;
+		if ( json.depthWrite !== undefined ) material.depthWrite = json.depthWrite;
+		if ( json.colorWrite !== undefined ) material.colorWrite = json.colorWrite;
+		if ( json.wireframe !== undefined ) material.wireframe = json.wireframe;
+		if ( json.wireframeLinewidth !== undefined ) material.wireframeLinewidth = json.wireframeLinewidth;
+
+		// for PointsMaterial
+		if ( json.size !== undefined ) material.size = json.size;
+		if ( json.sizeAttenuation !== undefined ) material.sizeAttenuation = json.sizeAttenuation;
+
+		// maps
+
+		if ( json.map !== undefined ) material.map = this.getTexture( json.map );
+
+		if ( json.alphaMap !== undefined ) {
+
+			material.alphaMap = this.getTexture( json.alphaMap );
+			material.transparent = true;
+
+		}
+
+		if ( json.bumpMap !== undefined ) material.bumpMap = this.getTexture( json.bumpMap );
+		if ( json.bumpScale !== undefined ) material.bumpScale = json.bumpScale;
+
+		if ( json.normalMap !== undefined ) material.normalMap = this.getTexture( json.normalMap );
+		if ( json.normalScale !== undefined ) {
+
+			var normalScale = json.normalScale;
+
+			if ( Array.isArray( normalScale ) === false ) {
+
+				// Blender exporter used to export a scalar. See #7459
+
+				normalScale = [ normalScale, normalScale ];
+
+			}
+
+			material.normalScale = new THREE.Vector2().fromArray( normalScale );
+
+		}
+
+		if ( json.displacementMap !== undefined ) material.displacementMap = this.getTexture( json.displacementMap );
+		if ( json.displacementScale !== undefined ) material.displacementScale = json.displacementScale;
+		if ( json.displacementBias !== undefined ) material.displacementBias = json.displacementBias;
+
+		if ( json.roughnessMap !== undefined ) material.roughnessMap = this.getTexture( json.roughnessMap );
+		if ( json.metalnessMap !== undefined ) material.metalnessMap = this.getTexture( json.metalnessMap );
+
+		if ( json.emissiveMap !== undefined ) material.emissiveMap = this.getTexture( json.emissiveMap );
+		if ( json.emissiveIntensity !== undefined ) material.emissiveIntensity = json.emissiveIntensity;
+
+		if ( json.specularMap !== undefined ) material.specularMap = this.getTexture( json.specularMap );
+
+		if ( json.envMap !== undefined ) {
+
+			material.envMap = this.getTexture( json.envMap );
+			material.combine = THREE.MultiplyOperation;
+
+		}
+
+		if ( json.reflectivity ) material.reflectivity = json.reflectivity;
+
+		if ( json.lightMap !== undefined ) material.lightMap = this.getTexture( json.lightMap );
+		if ( json.lightMapIntensity !== undefined ) material.lightMapIntensity = json.lightMapIntensity;
+
+		if ( json.aoMap !== undefined ) material.aoMap = this.getTexture( json.aoMap );
+		if ( json.aoMapIntensity !== undefined ) material.aoMapIntensity = json.aoMapIntensity;
+
+		// MultiMaterial
+
+		if ( json.materials !== undefined ) {
+
+			for ( var i = 0, l = json.materials.length; i < l; i ++ ) {
+
+				material.materials.push( this.parse( json.materials[ i ] ) );
+
+			}
+
+		}
+
+		return material;
+
+	}
+
+};
+
+// File:src/loaders/ObjectLoader.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.ObjectLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+	this.texturePath = '';
+
+};
+
+THREE.ObjectLoader.prototype = {
+
+	constructor: THREE.ObjectLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		if ( this.texturePath === '' ) {
+
+			this.texturePath = url.substring( 0, url.lastIndexOf( '/' ) + 1 );
+
+		}
+
+		var scope = this;
+
+		var loader = new THREE.XHRLoader( scope.manager );
+		loader.load( url, function ( text ) {
+
+			scope.parse( JSON.parse( text ), onLoad );
+
+		}, onProgress, onError );
+
+	},
+
+	setTexturePath: function ( value ) {
+
+		this.texturePath = value;
+
+	},
+
+	setCrossOrigin: function ( value ) {
+
+		this.crossOrigin = value;
+
+	},
+
+	parse: function ( json, onLoad ) {
+
+		var geometries = this.parseGeometries( json.geometries );
+
+		var images = this.parseImages( json.images, function () {
+
+			if ( onLoad !== undefined ) onLoad( object );
+
+		} );
+
+		var textures  = this.parseTextures( json.textures, images );
+		var materials = this.parseMaterials( json.materials, textures );
+
+		var object = this.parseObject( json.object, geometries, materials );
+
+		if ( json.animations ) {
+
+			object.animations = this.parseAnimations( json.animations );
+
+		}
+
+		if ( json.images === undefined || json.images.length === 0 ) {
+
+			if ( onLoad !== undefined ) onLoad( object );
+
+		}
+
+		return object;
+
+	},
+
+	parseGeometries: function ( json ) {
+
+		var geometries = {};
+
+		if ( json !== undefined ) {
+
+			var geometryLoader = new THREE.JSONLoader();
+			var bufferGeometryLoader = new THREE.BufferGeometryLoader();
+
+			for ( var i = 0, l = json.length; i < l; i ++ ) {
+
+				var geometry;
+				var data = json[ i ];
+
+				switch ( data.type ) {
+
+					case 'PlaneGeometry':
+					case 'PlaneBufferGeometry':
+
+						geometry = new THREE[ data.type ](
+							data.width,
+							data.height,
+							data.widthSegments,
+							data.heightSegments
+						);
+
+						break;
+
+					case 'BoxGeometry':
+					case 'BoxBufferGeometry':
+					case 'CubeGeometry': // backwards compatible
+
+						geometry = new THREE[ data.type ](
+							data.width,
+							data.height,
+							data.depth,
+							data.widthSegments,
+							data.heightSegments,
+							data.depthSegments
+						);
+
+						break;
+
+					case 'CircleGeometry':
+					case 'CircleBufferGeometry':
+
+						geometry = new THREE[ data.type ](
+							data.radius,
+							data.segments,
+							data.thetaStart,
+							data.thetaLength
+						);
+
+						break;
+
+					case 'CylinderGeometry':
+					case 'CylinderBufferGeometry':
+
+						geometry = new THREE[ data.type ](
+							data.radiusTop,
+							data.radiusBottom,
+							data.height,
+							data.radialSegments,
+							data.heightSegments,
+							data.openEnded,
+							data.thetaStart,
+							data.thetaLength
+						);
+
+						break;
+
+					case 'SphereGeometry':
+					case 'SphereBufferGeometry':
+
+						geometry = new THREE[ data.type ](
+							data.radius,
+							data.widthSegments,
+							data.heightSegments,
+							data.phiStart,
+							data.phiLength,
+							data.thetaStart,
+							data.thetaLength
+						);
+
+						break;
+
+					case 'DodecahedronGeometry':
+
+						geometry = new THREE.DodecahedronGeometry(
+							data.radius,
+							data.detail
+						);
+
+						break;
+
+					case 'IcosahedronGeometry':
+
+						geometry = new THREE.IcosahedronGeometry(
+							data.radius,
+							data.detail
+						);
+
+						break;
+
+					case 'OctahedronGeometry':
+
+						geometry = new THREE.OctahedronGeometry(
+							data.radius,
+							data.detail
+						);
+
+						break;
+
+					case 'TetrahedronGeometry':
+
+						geometry = new THREE.TetrahedronGeometry(
+							data.radius,
+							data.detail
+						);
+
+						break;
+
+					case 'RingGeometry':
+					case 'RingBufferGeometry':
+
+						geometry = new THREE[ data.type ](
+							data.innerRadius,
+							data.outerRadius,
+							data.thetaSegments,
+							data.phiSegments,
+							data.thetaStart,
+							data.thetaLength
+						);
+
+						break;
+
+					case 'TorusGeometry':
+					case 'TorusBufferGeometry':
+
+						geometry = new THREE[ data.type ](
+							data.radius,
+							data.tube,
+							data.radialSegments,
+							data.tubularSegments,
+							data.arc
+						);
+
+						break;
+
+					case 'TorusKnotGeometry':
+					case 'TorusKnotBufferGeometry':
+
+						geometry = new THREE[ data.type ](
+							data.radius,
+							data.tube,
+							data.tubularSegments,
+							data.radialSegments,
+							data.p,
+							data.q
+						);
+
+						break;
+
+					case 'LatheGeometry':
+					case 'LatheBufferGeometry':
+
+						geometry = new THREE[ data.type ](
+							data.points,
+							data.segments,
+							data.phiStart,
+							data.phiLength
+						);
+
+						break;
+
+					case 'BufferGeometry':
+
+						geometry = bufferGeometryLoader.parse( data );
+
+						break;
+
+					case 'Geometry':
+
+						geometry = geometryLoader.parse( data.data, this.texturePath ).geometry;
+
+						break;
+
+					default:
+
+						console.warn( 'THREE.ObjectLoader: Unsupported geometry type "' + data.type + '"' );
+
+						continue;
+
+				}
+
+				geometry.uuid = data.uuid;
+
+				if ( data.name !== undefined ) geometry.name = data.name;
+
+				geometries[ data.uuid ] = geometry;
+
+			}
+
+		}
+
+		return geometries;
+
+	},
+
+	parseMaterials: function ( json, textures ) {
+
+		var materials = {};
+
+		if ( json !== undefined ) {
+
+			var loader = new THREE.MaterialLoader();
+			loader.setTextures( textures );
+
+			for ( var i = 0, l = json.length; i < l; i ++ ) {
+
+				var material = loader.parse( json[ i ] );
+				materials[ material.uuid ] = material;
+
+			}
+
+		}
+
+		return materials;
+
+	},
+
+	parseAnimations: function ( json ) {
+
+		var animations = [];
+
+		for ( var i = 0; i < json.length; i ++ ) {
+
+			var clip = THREE.AnimationClip.parse( json[ i ] );
+
+			animations.push( clip );
+
+		}
+
+		return animations;
+
+	},
+
+	parseImages: function ( json, onLoad ) {
+
+		var scope = this;
+		var images = {};
+
+		function loadImage( url ) {
+
+			scope.manager.itemStart( url );
+
+			return loader.load( url, function () {
+
+				scope.manager.itemEnd( url );
+
+			} );
+
+		}
+
+		if ( json !== undefined && json.length > 0 ) {
+
+			var manager = new THREE.LoadingManager( onLoad );
+
+			var loader = new THREE.ImageLoader( manager );
+			loader.setCrossOrigin( this.crossOrigin );
+
+			for ( var i = 0, l = json.length; i < l; i ++ ) {
+
+				var image = json[ i ];
+				var path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test( image.url ) ? image.url : scope.texturePath + image.url;
+
+				images[ image.uuid ] = loadImage( path );
+
+			}
+
+		}
+
+		return images;
+
+	},
+
+	parseTextures: function ( json, images ) {
+
+		function parseConstant( value ) {
+
+			if ( typeof( value ) === 'number' ) return value;
+
+			console.warn( 'THREE.ObjectLoader.parseTexture: Constant should be in numeric form.', value );
+
+			return THREE[ value ];
+
+		}
+
+		var textures = {};
+
+		if ( json !== undefined ) {
+
+			for ( var i = 0, l = json.length; i < l; i ++ ) {
+
+				var data = json[ i ];
+
+				if ( data.image === undefined ) {
+
+					console.warn( 'THREE.ObjectLoader: No "image" specified for', data.uuid );
+
+				}
+
+				if ( images[ data.image ] === undefined ) {
+
+					console.warn( 'THREE.ObjectLoader: Undefined image', data.image );
+
+				}
+
+				var texture = new THREE.Texture( images[ data.image ] );
+				texture.needsUpdate = true;
+
+				texture.uuid = data.uuid;
+
+				if ( data.name !== undefined ) texture.name = data.name;
+				if ( data.mapping !== undefined ) texture.mapping = parseConstant( data.mapping );
+				if ( data.offset !== undefined ) texture.offset = new THREE.Vector2( data.offset[ 0 ], data.offset[ 1 ] );
+				if ( data.repeat !== undefined ) texture.repeat = new THREE.Vector2( data.repeat[ 0 ], data.repeat[ 1 ] );
+				if ( data.minFilter !== undefined ) texture.minFilter = parseConstant( data.minFilter );
+				if ( data.magFilter !== undefined ) texture.magFilter = parseConstant( data.magFilter );
+				if ( data.anisotropy !== undefined ) texture.anisotropy = data.anisotropy;
+				if ( Array.isArray( data.wrap ) ) {
+
+					texture.wrapS = parseConstant( data.wrap[ 0 ] );
+					texture.wrapT = parseConstant( data.wrap[ 1 ] );
+
+				}
+
+				textures[ data.uuid ] = texture;
+
+			}
+
+		}
+
+		return textures;
+
+	},
+
+	parseObject: function () {
+
+		var matrix = new THREE.Matrix4();
+
+		return function ( data, geometries, materials ) {
+
+			var object;
+
+			function getGeometry( name ) {
+
+				if ( geometries[ name ] === undefined ) {
+
+					console.warn( 'THREE.ObjectLoader: Undefined geometry', name );
+
+				}
+
+				return geometries[ name ];
+
+			}
+
+			function getMaterial( name ) {
+
+				if ( name === undefined ) return undefined;
+
+				if ( materials[ name ] === undefined ) {
+
+					console.warn( 'THREE.ObjectLoader: Undefined material', name );
+
+				}
+
+				return materials[ name ];
+
+			}
+
+			switch ( data.type ) {
+
+				case 'Scene':
+
+					object = new THREE.Scene();
+
+					break;
+
+				case 'PerspectiveCamera':
+
+					object = new THREE.PerspectiveCamera(
+							data.fov, data.aspect, data.near, data.far );
+
+					if ( data.focus !== undefined ) object.focus = data.focus;
+					if ( data.zoom !== undefined ) object.zoom = data.zoom;
+					if ( data.filmGauge !== undefined ) object.filmGauge = data.filmGauge;
+					if ( data.filmOffset !== undefined ) object.filmOffset = data.filmOffset;
+					if ( data.view !== undefined ) object.view = Object.assign( {}, data.view );
+
+					break;
+
+				case 'OrthographicCamera':
+
+					object = new THREE.OrthographicCamera( data.left, data.right, data.top, data.bottom, data.near, data.far );
+
+					break;
+
+				case 'AmbientLight':
+
+					object = new THREE.AmbientLight( data.color, data.intensity );
+
+					break;
+
+				case 'DirectionalLight':
+
+					object = new THREE.DirectionalLight( data.color, data.intensity );
+
+					break;
+
+				case 'PointLight':
+
+					object = new THREE.PointLight( data.color, data.intensity, data.distance, data.decay );
+
+					break;
+
+				case 'SpotLight':
+
+					object = new THREE.SpotLight( data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay );
+
+					break;
+
+				case 'HemisphereLight':
+
+					object = new THREE.HemisphereLight( data.color, data.groundColor, data.intensity );
+
+					break;
+
+				case 'Mesh':
+
+					var geometry = getGeometry( data.geometry );
+					var material = getMaterial( data.material );
+
+					if ( geometry.bones && geometry.bones.length > 0 ) {
+
+						object = new THREE.SkinnedMesh( geometry, material );
+
+					} else {
+
+						object = new THREE.Mesh( geometry, material );
+
+					}
+
+					break;
+
+				case 'LOD':
+
+					object = new THREE.LOD();
+
+					break;
+
+				case 'Line':
+
+					object = new THREE.Line( getGeometry( data.geometry ), getMaterial( data.material ), data.mode );
+
+					break;
+
+				case 'PointCloud':
+				case 'Points':
+
+					object = new THREE.Points( getGeometry( data.geometry ), getMaterial( data.material ) );
+
+					break;
+
+				case 'Sprite':
+
+					object = new THREE.Sprite( getMaterial( data.material ) );
+
+					break;
+
+				case 'Group':
+
+					object = new THREE.Group();
+
+					break;
+
+				default:
+
+					object = new THREE.Object3D();
+
+			}
+
+			object.uuid = data.uuid;
+
+			if ( data.name !== undefined ) object.name = data.name;
+			if ( data.matrix !== undefined ) {
+
+				matrix.fromArray( data.matrix );
+				matrix.decompose( object.position, object.quaternion, object.scale );
+
+			} else {
+
+				if ( data.position !== undefined ) object.position.fromArray( data.position );
+				if ( data.rotation !== undefined ) object.rotation.fromArray( data.rotation );
+				if ( data.scale !== undefined ) object.scale.fromArray( data.scale );
+
+			}
+
+			if ( data.castShadow !== undefined ) object.castShadow = data.castShadow;
+			if ( data.receiveShadow !== undefined ) object.receiveShadow = data.receiveShadow;
+
+			if ( data.visible !== undefined ) object.visible = data.visible;
+			if ( data.userData !== undefined ) object.userData = data.userData;
+
+			if ( data.children !== undefined ) {
+
+				for ( var child in data.children ) {
+
+					object.add( this.parseObject( data.children[ child ], geometries, materials ) );
+
+				}
+
+			}
+
+			if ( data.type === 'LOD' ) {
+
+				var levels = data.levels;
+
+				for ( var l = 0; l < levels.length; l ++ ) {
+
+					var level = levels[ l ];
+					var child = object.getObjectByProperty( 'uuid', level.object );
+
+					if ( child !== undefined ) {
+
+						object.addLevel( child, level.distance );
+
+					}
+
+				}
+
+			}
+
+			return object;
+
+		};
+
+	}()
+
+};
+
+// File:src/loaders/TextureLoader.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.TextureLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+
+};
+
+THREE.TextureLoader.prototype = {
+
+	constructor: THREE.TextureLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		var texture = new THREE.Texture();
+
+		var loader = new THREE.ImageLoader( this.manager );
+		loader.setCrossOrigin( this.crossOrigin );
+		loader.setPath( this.path );
+		loader.load( url, function ( image ) {
+
+			texture.image = image;
+			texture.needsUpdate = true;
+
+			if ( onLoad !== undefined ) {
+
+				onLoad( texture );
+
+			}
+
+		}, onProgress, onError );
+
+		return texture;
+
+	},
+
+	setCrossOrigin: function ( value ) {
+
+		this.crossOrigin = value;
+
+	},
+
+	setPath: function ( value ) {
+
+		this.path = value;
+
+	}
+
+};
+
+// File:src/loaders/CubeTextureLoader.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.CubeTextureLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+
+};
+
+THREE.CubeTextureLoader.prototype = {
+
+	constructor: THREE.CubeTextureLoader,
+
+	load: function ( urls, onLoad, onProgress, onError ) {
+
+		var texture = new THREE.CubeTexture();
+
+		var loader = new THREE.ImageLoader( this.manager );
+		loader.setCrossOrigin( this.crossOrigin );
+		loader.setPath( this.path );
+
+		var loaded = 0;
+
+		function loadTexture( i ) {
+
+			loader.load( urls[ i ], function ( image ) {
+
+				texture.images[ i ] = image;
+
+				loaded ++;
+
+				if ( loaded === 6 ) {
+
+					texture.needsUpdate = true;
+
+					if ( onLoad ) onLoad( texture );
+
+				}
+
+			}, undefined, onError );
+
+		}
+
+		for ( var i = 0; i < urls.length; ++ i ) {
+
+			loadTexture( i );
+
+		}
+
+		return texture;
+
+	},
+
+	setCrossOrigin: function ( value ) {
+
+		this.crossOrigin = value;
+
+	},
+
+	setPath: function ( value ) {
+
+		this.path = value;
+
+	}
+
+};
+
+// File:src/loaders/BinaryTextureLoader.js
+
+/**
+ * @author Nikos M. / https://github.com/foo123/
+ *
+ * Abstract Base class to load generic binary textures formats (rgbe, hdr, ...)
+ */
+
+THREE.DataTextureLoader = THREE.BinaryTextureLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+
+	// override in sub classes
+	this._parser = null;
+
+};
+
+THREE.BinaryTextureLoader.prototype = {
+
+	constructor: THREE.BinaryTextureLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		var scope = this;
+
+		var texture = new THREE.DataTexture();
+
+		var loader = new THREE.XHRLoader( this.manager );
+		loader.setResponseType( 'arraybuffer' );
+
+		loader.load( url, function ( buffer ) {
+
+			var texData = scope._parser( buffer );
+
+			if ( ! texData ) return;
+
+			if ( undefined !== texData.image ) {
+
+				texture.image = texData.image;
+
+			} else if ( undefined !== texData.data ) {
+
+				texture.image.width = texData.width;
+				texture.image.height = texData.height;
+				texture.image.data = texData.data;
+
+			}
+
+			texture.wrapS = undefined !== texData.wrapS ? texData.wrapS : THREE.ClampToEdgeWrapping;
+			texture.wrapT = undefined !== texData.wrapT ? texData.wrapT : THREE.ClampToEdgeWrapping;
+
+			texture.magFilter = undefined !== texData.magFilter ? texData.magFilter : THREE.LinearFilter;
+			texture.minFilter = undefined !== texData.minFilter ? texData.minFilter : THREE.LinearMipMapLinearFilter;
+
+			texture.anisotropy = undefined !== texData.anisotropy ? texData.anisotropy : 1;
+
+			if ( undefined !== texData.format ) {
+
+				texture.format = texData.format;
+
+			}
+			if ( undefined !== texData.type ) {
+
+				texture.type = texData.type;
+
+			}
+
+			if ( undefined !== texData.mipmaps ) {
+
+				texture.mipmaps = texData.mipmaps;
+
+			}
+
+			if ( 1 === texData.mipmapCount ) {
+
+				texture.minFilter = THREE.LinearFilter;
+
+			}
+
+			texture.needsUpdate = true;
+
+			if ( onLoad ) onLoad( texture, texData );
+
+		}, onProgress, onError );
+
+
+		return texture;
+
+	}
+
+};
+
+// File:src/loaders/CompressedTextureLoader.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ *
+ * Abstract Base class to block based textures loader (dds, pvr, ...)
+ */
+
+THREE.CompressedTextureLoader = function ( manager ) {
+
+	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
+
+	// override in sub classes
+	this._parser = null;
+
+};
+
+
+THREE.CompressedTextureLoader.prototype = {
+
+	constructor: THREE.CompressedTextureLoader,
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		var scope = this;
+
+		var images = [];
+
+		var texture = new THREE.CompressedTexture();
+		texture.image = images;
+
+		var loader = new THREE.XHRLoader( this.manager );
+		loader.setPath( this.path );
+		loader.setResponseType( 'arraybuffer' );
+
+		function loadTexture( i ) {
+
+			loader.load( url[ i ], function ( buffer ) {
+
+				var texDatas = scope._parser( buffer, true );
+
+				images[ i ] = {
+					width: texDatas.width,
+					height: texDatas.height,
+					format: texDatas.format,
+					mipmaps: texDatas.mipmaps
+				};
+
+				loaded += 1;
+
+				if ( loaded === 6 ) {
+
+					if ( texDatas.mipmapCount === 1 )
+						texture.minFilter = THREE.LinearFilter;
+
+					texture.format = texDatas.format;
+					texture.needsUpdate = true;
+
+					if ( onLoad ) onLoad( texture );
+
+				}
+
+			}, onProgress, onError );
+
+		}
+
+		if ( Array.isArray( url ) ) {
+
+			var loaded = 0;
+
+			for ( var i = 0, il = url.length; i < il; ++ i ) {
+
+				loadTexture( i );
+
+			}
+
+		} else {
+
+			// compressed cubemap texture stored in a single DDS file
+
+			loader.load( url, function ( buffer ) {
+
+				var texDatas = scope._parser( buffer, true );
+
+				if ( texDatas.isCubemap ) {
+
+					var faces = texDatas.mipmaps.length / texDatas.mipmapCount;
+
+					for ( var f = 0; f < faces; f ++ ) {
+
+						images[ f ] = { mipmaps : [] };
+
+						for ( var i = 0; i < texDatas.mipmapCount; i ++ ) {
+
+							images[ f ].mipmaps.push( texDatas.mipmaps[ f * texDatas.mipmapCount + i ] );
+							images[ f ].format = texDatas.format;
+							images[ f ].width = texDatas.width;
+							images[ f ].height = texDatas.height;
+
+						}
+
+					}
+
+				} else {
+
+					texture.image.width = texDatas.width;
+					texture.image.height = texDatas.height;
+					texture.mipmaps = texDatas.mipmaps;
+
+				}
+
+				if ( texDatas.mipmapCount === 1 ) {
+
+					texture.minFilter = THREE.LinearFilter;
+
+				}
+
+				texture.format = texDatas.format;
+				texture.needsUpdate = true;
+
+				if ( onLoad ) onLoad( texture );
+
+			}, onProgress, onError );
+
+		}
+
+		return texture;
+
+	},
+
+	setPath: function ( value ) {
+
+		this.path = value;
+
+	}
+
+};
+
+// File:src/materials/Material.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.Material = function () {
+
+	Object.defineProperty( this, 'id', { value: THREE.MaterialIdCount ++ } );
+
+	this.uuid = THREE.Math.generateUUID();
+
+	this.name = '';
+	this.type = 'Material';
+
+	this.side = THREE.FrontSide;
+
+	this.opacity = 1;
+	this.transparent = false;
+
+	this.blending = THREE.NormalBlending;
+
+	this.blendSrc = THREE.SrcAlphaFactor;
+	this.blendDst = THREE.OneMinusSrcAlphaFactor;
+	this.blendEquation = THREE.AddEquation;
+	this.blendSrcAlpha = null;
+	this.blendDstAlpha = null;
+	this.blendEquationAlpha = null;
+
+	this.depthFunc = THREE.LessEqualDepth;
+	this.depthTest = true;
+	this.depthWrite = true;
+
+	this.clippingPlanes = null;
+	this.clipShadows = false;
+
+	this.colorWrite = true;
+
+	this.precision = null; // override the renderer's default precision for this material
+
+	this.polygonOffset = false;
+	this.polygonOffsetFactor = 0;
+	this.polygonOffsetUnits = 0;
+
+	this.alphaTest = 0;
+	this.premultipliedAlpha = false;
+
+	this.overdraw = 0; // Overdrawn pixels (typically between 0 and 1) for fixing antialiasing gaps in CanvasRenderer
+
+	this.visible = true;
+
+	this._needsUpdate = true;
+
+};
+
+THREE.Material.prototype = {
+
+	constructor: THREE.Material,
+
+	get needsUpdate () {
+
+		return this._needsUpdate;
+
+	},
+
+	set needsUpdate ( value ) {
+
+		if ( value === true ) this.update();
+
+		this._needsUpdate = value;
+
+	},
+
+	setValues: function ( values ) {
+
+		if ( values === undefined ) return;
+
+		for ( var key in values ) {
+
+			var newValue = values[ key ];
+
+			if ( newValue === undefined ) {
+
+				console.warn( "THREE.Material: '" + key + "' parameter is undefined." );
+				continue;
+
+			}
+
+			var currentValue = this[ key ];
+
+			if ( currentValue === undefined ) {
+
+				console.warn( "THREE." + this.type + ": '" + key + "' is not a property of this material." );
+				continue;
+
+			}
+
+			if ( currentValue instanceof THREE.Color ) {
+
+				currentValue.set( newValue );
+
+			} else if ( currentValue instanceof THREE.Vector3 && newValue instanceof THREE.Vector3 ) {
+
+				currentValue.copy( newValue );
+
+			} else if ( key === 'overdraw' ) {
+
+				// ensure overdraw is backwards-compatible with legacy boolean type
+				this[ key ] = Number( newValue );
+
+			} else {
+
+				this[ key ] = newValue;
+
+			}
+
+		}
+
+	},
+
+	toJSON: function ( meta ) {
+
+		var isRoot = meta === undefined;
+
+		if ( isRoot ) {
+
+			meta = {
+				textures: {},
+				images: {}
+			};
+
+		}
+
+		var data = {
+			metadata: {
+				version: 4.4,
+				type: 'Material',
+				generator: 'Material.toJSON'
+			}
+		};
+
+		// standard Material serialization
+		data.uuid = this.uuid;
+		data.type = this.type;
+		if ( this.name !== '' ) data.name = this.name;
+
+		if ( this.color instanceof THREE.Color ) data.color = this.color.getHex();
+
+		if ( this.roughness !== 0.5 ) data.roughness = this.roughness;
+		if ( this.metalness !== 0.5 ) data.metalness = this.metalness;
+
+		if ( this.emissive instanceof THREE.Color ) data.emissive = this.emissive.getHex();
+		if ( this.specular instanceof THREE.Color ) data.specular = this.specular.getHex();
+		if ( this.shininess !== undefined ) data.shininess = this.shininess;
+
+		if ( this.map instanceof THREE.Texture ) data.map = this.map.toJSON( meta ).uuid;
+		if ( this.alphaMap instanceof THREE.Texture ) data.alphaMap = this.alphaMap.toJSON( meta ).uuid;
+		if ( this.lightMap instanceof THREE.Texture ) data.lightMap = this.lightMap.toJSON( meta ).uuid;
+		if ( this.bumpMap instanceof THREE.Texture ) {
+
+			data.bumpMap = this.bumpMap.toJSON( meta ).uuid;
+			data.bumpScale = this.bumpScale;
+
+		}
+		if ( this.normalMap instanceof THREE.Texture ) {
+
+			data.normalMap = this.normalMap.toJSON( meta ).uuid;
+			data.normalScale = this.normalScale.toArray();
+
+		}
+		if ( this.displacementMap instanceof THREE.Texture ) {
+
+			data.displacementMap = this.displacementMap.toJSON( meta ).uuid;
+			data.displacementScale = this.displacementScale;
+			data.displacementBias = this.displacementBias;
+
+		}
+		if ( this.roughnessMap instanceof THREE.Texture ) data.roughnessMap = this.roughnessMap.toJSON( meta ).uuid;
+		if ( this.metalnessMap instanceof THREE.Texture ) data.metalnessMap = this.metalnessMap.toJSON( meta ).uuid;
+
+		if ( this.emissiveMap instanceof THREE.Texture ) data.emissiveMap = this.emissiveMap.toJSON( meta ).uuid;
+		if ( this.specularMap instanceof THREE.Texture ) data.specularMap = this.specularMap.toJSON( meta ).uuid;
+
+		if ( this.envMap instanceof THREE.Texture ) {
+
+			data.envMap = this.envMap.toJSON( meta ).uuid;
+			data.reflectivity = this.reflectivity; // Scale behind envMap
+
+		}
+
+		if ( this.size !== undefined ) data.size = this.size;
+		if ( this.sizeAttenuation !== undefined ) data.sizeAttenuation = this.sizeAttenuation;
+
+		if ( this.vertexColors !== undefined && this.vertexColors !== THREE.NoColors ) data.vertexColors = this.vertexColors;
+		if ( this.shading !== undefined && this.shading !== THREE.SmoothShading ) data.shading = this.shading;
+		if ( this.blending !== undefined && this.blending !== THREE.NormalBlending ) data.blending = this.blending;
+		if ( this.side !== undefined && this.side !== THREE.FrontSide ) data.side = this.side;
+
+		if ( this.opacity < 1 ) data.opacity = this.opacity;
+		if ( this.transparent === true ) data.transparent = this.transparent;
+		if ( this.alphaTest > 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;
+
+		// 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.side = source.side;
+
+		this.opacity = source.opacity;
+		this.transparent = source.transparent;
+
+		this.blending = source.blending;
+
+		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.colorWrite = source.colorWrite;
+
+		this.precision = source.precision;
+
+		this.polygonOffset = source.polygonOffset;
+		this.polygonOffsetFactor = source.polygonOffsetFactor;
+		this.polygonOffsetUnits = source.polygonOffsetUnits;
+
+		this.alphaTest = source.alphaTest;
+
+		this.premultipliedAlpha = source.premultipliedAlpha;
+
+		this.overdraw = source.overdraw;
+
+		this.visible = source.visible;
+		this.clipShadows = source.clipShadows;
+
+		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;
+
+		return this;
+
+	},
+
+	update: function () {
+
+		this.dispatchEvent( { type: 'update' } );
+
+	},
+
+	dispose: function () {
+
+		this.dispatchEvent( { type: 'dispose' } );
+
+	}
+
+};
+
+THREE.EventDispatcher.prototype.apply( THREE.Material.prototype );
+
+THREE.MaterialIdCount = 0;
+
+// File:src/materials/LineBasicMaterial.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ *
+ * parameters = {
+ *  color: <hex>,
+ *  opacity: <float>,
+ *
+ *  linewidth: <float>,
+ *  linecap: "round",
+ *  linejoin: "round",
+ *
+ *  blending: THREE.NormalBlending,
+ *  depthTest: <bool>,
+ *  depthWrite: <bool>,
+ *
+ *  vertexColors: <bool>
+ *
+ *  fog: <bool>
+ * }
+ */
+
+THREE.LineBasicMaterial = function ( parameters ) {
+
+	THREE.Material.call( this );
+
+	this.type = 'LineBasicMaterial';
+
+	this.color = new THREE.Color( 0xffffff );
+
+	this.linewidth = 1;
+	this.linecap = 'round';
+	this.linejoin = 'round';
+
+	this.blending = THREE.NormalBlending;
+
+	this.vertexColors = THREE.NoColors;
+
+	this.fog = true;
+
+	this.setValues( parameters );
+
+};
+
+THREE.LineBasicMaterial.prototype = Object.create( THREE.Material.prototype );
+THREE.LineBasicMaterial.prototype.constructor = THREE.LineBasicMaterial;
+
+THREE.LineBasicMaterial.prototype.copy = function ( source ) {
+
+	THREE.Material.prototype.copy.call( this, source );
+
+	this.color.copy( source.color );
+
+	this.linewidth = source.linewidth;
+	this.linecap = source.linecap;
+	this.linejoin = source.linejoin;
+
+	this.vertexColors = source.vertexColors;
+
+	this.fog = source.fog;
+
+	return this;
+
+};
+
+// File:src/materials/LineDashedMaterial.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ *
+ * parameters = {
+ *  color: <hex>,
+ *  opacity: <float>,
+ *
+ *  linewidth: <float>,
+ *
+ *  scale: <float>,
+ *  dashSize: <float>,
+ *  gapSize: <float>,
+ *
+ *  blending: THREE.NormalBlending,
+ *  depthTest: <bool>,
+ *  depthWrite: <bool>,
+ *
+ *  vertexColors: THREE.NoColors / THREE.FaceColors / THREE.VertexColors
+ *
+ *  fog: <bool>
+ * }
+ */
+
+THREE.LineDashedMaterial = function ( parameters ) {
+
+	THREE.Material.call( this );
+
+	this.type = 'LineDashedMaterial';
+
+	this.color = new THREE.Color( 0xffffff );
+
+	this.linewidth = 1;
+
+	this.scale = 1;
+	this.dashSize = 3;
+	this.gapSize = 1;
+
+	this.blending = THREE.NormalBlending;
+
+	this.vertexColors = THREE.NoColors;
+
+	this.fog = true;
+
+	this.setValues( parameters );
+
+};
+
+THREE.LineDashedMaterial.prototype = Object.create( THREE.Material.prototype );
+THREE.LineDashedMaterial.prototype.constructor = THREE.LineDashedMaterial;
+
+THREE.LineDashedMaterial.prototype.copy = function ( source ) {
+
+	THREE.Material.prototype.copy.call( this, source );
+
+	this.color.copy( source.color );
+
+	this.linewidth = source.linewidth;
+
+	this.scale = source.scale;
+	this.dashSize = source.dashSize;
+	this.gapSize = source.gapSize;
+
+	this.vertexColors = source.vertexColors;
+
+	this.fog = source.fog;
+
+	return this;
+
+};
+
+// File:src/materials/MeshBasicMaterial.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ *
+ * parameters = {
+ *  color: <hex>,
+ *  opacity: <float>,
+ *  map: new THREE.Texture( <Image> ),
+ *
+ *  aoMap: new THREE.Texture( <Image> ),
+ *  aoMapIntensity: <float>
+ *
+ *  specularMap: new THREE.Texture( <Image> ),
+ *
+ *  alphaMap: new THREE.Texture( <Image> ),
+ *
+ *  envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),
+ *  combine: THREE.Multiply,
+ *  reflectivity: <float>,
+ *  refractionRatio: <float>,
+ *
+ *  shading: THREE.SmoothShading,
+ *  blending: THREE.NormalBlending,
+ *  depthTest: <bool>,
+ *  depthWrite: <bool>,
+ *
+ *  wireframe: <boolean>,
+ *  wireframeLinewidth: <float>,
+ *
+ *  vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors,
+ *
+ *  skinning: <bool>,
+ *  morphTargets: <bool>,
+ *
+ *  fog: <bool>
+ * }
+ */
+
+THREE.MeshBasicMaterial = function ( parameters ) {
+
+	THREE.Material.call( this );
+
+	this.type = 'MeshBasicMaterial';
+
+	this.color = new THREE.Color( 0xffffff ); // emissive
+
+	this.map = null;
+
+	this.aoMap = null;
+	this.aoMapIntensity = 1.0;
+
+	this.specularMap = null;
+
+	this.alphaMap = null;
+
+	this.envMap = null;
+	this.combine = THREE.MultiplyOperation;
+	this.reflectivity = 1;
+	this.refractionRatio = 0.98;
+
+	this.fog = true;
+
+	this.shading = THREE.SmoothShading;
+	this.blending = THREE.NormalBlending;
+
+	this.wireframe = false;
+	this.wireframeLinewidth = 1;
+	this.wireframeLinecap = 'round';
+	this.wireframeLinejoin = 'round';
+
+	this.vertexColors = THREE.NoColors;
+
+	this.skinning = false;
+	this.morphTargets = false;
+
+	this.setValues( parameters );
+
+};
+
+THREE.MeshBasicMaterial.prototype = Object.create( THREE.Material.prototype );
+THREE.MeshBasicMaterial.prototype.constructor = THREE.MeshBasicMaterial;
+
+THREE.MeshBasicMaterial.prototype.copy = function ( source ) {
+
+	THREE.Material.prototype.copy.call( this, source );
+
+	this.color.copy( source.color );
+
+	this.map = source.map;
+
+	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.fog = source.fog;
+
+	this.shading = source.shading;
+
+	this.wireframe = source.wireframe;
+	this.wireframeLinewidth = source.wireframeLinewidth;
+	this.wireframeLinecap = source.wireframeLinecap;
+	this.wireframeLinejoin = source.wireframeLinejoin;
+
+	this.vertexColors = source.vertexColors;
+
+	this.skinning = source.skinning;
+	this.morphTargets = source.morphTargets;
+
+	return this;
+
+};
+
+// File:src/materials/MeshDepthMaterial.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ * @author bhouston / https://clara.io
+ * @author WestLangley / http://github.com/WestLangley
+ *
+ * parameters = {
+ *
+ *  opacity: <float>,
+ *
+ *  map: new THREE.Texture( <Image> ),
+ *
+ *  alphaMap: new THREE.Texture( <Image> ),
+ *
+ *  displacementMap: new THREE.Texture( <Image> ),
+ *  displacementScale: <float>,
+ *  displacementBias: <float>,
+ *
+ *  wireframe: <boolean>,
+ *  wireframeLinewidth: <float>
+ * }
+ */
+
+THREE.MeshDepthMaterial = function ( parameters ) {
+
+	THREE.Material.call( this );
+
+	this.type = 'MeshDepthMaterial';
+
+	this.depthPacking = THREE.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.setValues( parameters );
+
+};
+
+THREE.MeshDepthMaterial.prototype = Object.create( THREE.Material.prototype );
+THREE.MeshDepthMaterial.prototype.constructor = THREE.MeshDepthMaterial;
+
+THREE.MeshDepthMaterial.prototype.copy = function ( source ) {
+
+	THREE.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;
+
+};
+
+// File:src/materials/MeshLambertMaterial.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ *
+ * parameters = {
+ *  color: <hex>,
+ *  opacity: <float>,
+ *
+ *  map: new THREE.Texture( <Image> ),
+ *
+ *  lightMap: new THREE.Texture( <Image> ),
+ *  lightMapIntensity: <float>
+ *
+ *  aoMap: new THREE.Texture( <Image> ),
+ *  aoMapIntensity: <float>
+ *
+ *  emissive: <hex>,
+ *  emissiveIntensity: <float>
+ *  emissiveMap: new THREE.Texture( <Image> ),
+ *
+ *  specularMap: new THREE.Texture( <Image> ),
+ *
+ *  alphaMap: new THREE.Texture( <Image> ),
+ *
+ *  envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),
+ *  combine: THREE.Multiply,
+ *  reflectivity: <float>,
+ *  refractionRatio: <float>,
+ *
+ *  blending: THREE.NormalBlending,
+ *  depthTest: <bool>,
+ *  depthWrite: <bool>,
+ *
+ *  wireframe: <boolean>,
+ *  wireframeLinewidth: <float>,
+ *
+ *  vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors,
+ *
+ *  skinning: <bool>,
+ *  morphTargets: <bool>,
+ *  morphNormals: <bool>,
+ *
+ *	fog: <bool>
+ * }
+ */
+
+THREE.MeshLambertMaterial = function ( parameters ) {
+
+	THREE.Material.call( this );
+
+	this.type = 'MeshLambertMaterial';
+
+	this.color = new THREE.Color( 0xffffff ); // diffuse
+
+	this.map = null;
+
+	this.lightMap = null;
+	this.lightMapIntensity = 1.0;
+
+	this.aoMap = null;
+	this.aoMapIntensity = 1.0;
+
+	this.emissive = new THREE.Color( 0x000000 );
+	this.emissiveIntensity = 1.0;
+	this.emissiveMap = null;
+
+	this.specularMap = null;
+
+	this.alphaMap = null;
+
+	this.envMap = null;
+	this.combine = THREE.MultiplyOperation;
+	this.reflectivity = 1;
+	this.refractionRatio = 0.98;
+
+	this.fog = true;
+
+	this.blending = THREE.NormalBlending;
+
+	this.wireframe = false;
+	this.wireframeLinewidth = 1;
+	this.wireframeLinecap = 'round';
+	this.wireframeLinejoin = 'round';
+
+	this.vertexColors = THREE.NoColors;
+
+	this.skinning = false;
+	this.morphTargets = false;
+	this.morphNormals = false;
+
+	this.setValues( parameters );
+
+};
+
+THREE.MeshLambertMaterial.prototype = Object.create( THREE.Material.prototype );
+THREE.MeshLambertMaterial.prototype.constructor = THREE.MeshLambertMaterial;
+
+THREE.MeshLambertMaterial.prototype.copy = function ( source ) {
+
+	THREE.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.fog = source.fog;
+
+	this.wireframe = source.wireframe;
+	this.wireframeLinewidth = source.wireframeLinewidth;
+	this.wireframeLinecap = source.wireframeLinecap;
+	this.wireframeLinejoin = source.wireframeLinejoin;
+
+	this.vertexColors = source.vertexColors;
+
+	this.skinning = source.skinning;
+	this.morphTargets = source.morphTargets;
+	this.morphNormals = source.morphNormals;
+
+	return this;
+
+};
+
+// File:src/materials/MeshNormalMaterial.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ *
+ * parameters = {
+ *  opacity: <float>,
+ *
+ *  wireframe: <boolean>,
+ *  wireframeLinewidth: <float>
+ * }
+ */
+
+THREE.MeshNormalMaterial = function ( parameters ) {
+
+	THREE.Material.call( this, parameters );
+
+	this.type = 'MeshNormalMaterial';
+
+	this.wireframe = false;
+	this.wireframeLinewidth = 1;
+
+	this.morphTargets = false;
+
+	this.setValues( parameters );
+
+};
+
+THREE.MeshNormalMaterial.prototype = Object.create( THREE.Material.prototype );
+THREE.MeshNormalMaterial.prototype.constructor = THREE.MeshNormalMaterial;
+
+THREE.MeshNormalMaterial.prototype.copy = function ( source ) {
+
+	THREE.Material.prototype.copy.call( this, source );
+
+	this.wireframe = source.wireframe;
+	this.wireframeLinewidth = source.wireframeLinewidth;
+
+	return this;
+
+};
+
+// File:src/materials/MeshPhongMaterial.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ *
+ * parameters = {
+ *  color: <hex>,
+ *  specular: <hex>,
+ *  shininess: <float>,
+ *  opacity: <float>,
+ *
+ *  map: new THREE.Texture( <Image> ),
+ *
+ *  lightMap: new THREE.Texture( <Image> ),
+ *  lightMapIntensity: <float>
+ *
+ *  aoMap: new THREE.Texture( <Image> ),
+ *  aoMapIntensity: <float>
+ *
+ *  emissive: <hex>,
+ *  emissiveIntensity: <float>
+ *  emissiveMap: new THREE.Texture( <Image> ),
+ *
+ *  bumpMap: new THREE.Texture( <Image> ),
+ *  bumpScale: <float>,
+ *
+ *  normalMap: new THREE.Texture( <Image> ),
+ *  normalScale: <Vector2>,
+ *
+ *  displacementMap: new THREE.Texture( <Image> ),
+ *  displacementScale: <float>,
+ *  displacementBias: <float>,
+ *
+ *  specularMap: new THREE.Texture( <Image> ),
+ *
+ *  alphaMap: new THREE.Texture( <Image> ),
+ *
+ *  envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),
+ *  combine: THREE.Multiply,
+ *  reflectivity: <float>,
+ *  refractionRatio: <float>,
+ *
+ *  shading: THREE.SmoothShading,
+ *  blending: THREE.NormalBlending,
+ *  depthTest: <bool>,
+ *  depthWrite: <bool>,
+ *
+ *  wireframe: <boolean>,
+ *  wireframeLinewidth: <float>,
+ *
+ *  vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors,
+ *
+ *  skinning: <bool>,
+ *  morphTargets: <bool>,
+ *  morphNormals: <bool>,
+ *
+ *	fog: <bool>
+ * }
+ */
+
+THREE.MeshPhongMaterial = function ( parameters ) {
+
+	THREE.Material.call( this );
+
+	this.type = 'MeshPhongMaterial';
+
+	this.color = new THREE.Color( 0xffffff ); // diffuse
+	this.specular = new THREE.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 THREE.Color( 0x000000 );
+	this.emissiveIntensity = 1.0;
+	this.emissiveMap = null;
+
+	this.bumpMap = null;
+	this.bumpScale = 1;
+
+	this.normalMap = null;
+	this.normalScale = new THREE.Vector2( 1, 1 );
+
+	this.displacementMap = null;
+	this.displacementScale = 1;
+	this.displacementBias = 0;
+
+	this.specularMap = null;
+
+	this.alphaMap = null;
+
+	this.envMap = null;
+	this.combine = THREE.MultiplyOperation;
+	this.reflectivity = 1;
+	this.refractionRatio = 0.98;
+
+	this.fog = true;
+
+	this.shading = THREE.SmoothShading;
+	this.blending = THREE.NormalBlending;
+
+	this.wireframe = false;
+	this.wireframeLinewidth = 1;
+	this.wireframeLinecap = 'round';
+	this.wireframeLinejoin = 'round';
+
+	this.vertexColors = THREE.NoColors;
+
+	this.skinning = false;
+	this.morphTargets = false;
+	this.morphNormals = false;
+
+	this.setValues( parameters );
+
+};
+
+THREE.MeshPhongMaterial.prototype = Object.create( THREE.Material.prototype );
+THREE.MeshPhongMaterial.prototype.constructor = THREE.MeshPhongMaterial;
+
+THREE.MeshPhongMaterial.prototype.copy = function ( source ) {
+
+	THREE.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.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.fog = source.fog;
+
+	this.shading = source.shading;
+
+	this.wireframe = source.wireframe;
+	this.wireframeLinewidth = source.wireframeLinewidth;
+	this.wireframeLinecap = source.wireframeLinecap;
+	this.wireframeLinejoin = source.wireframeLinejoin;
+
+	this.vertexColors = source.vertexColors;
+
+	this.skinning = source.skinning;
+	this.morphTargets = source.morphTargets;
+	this.morphNormals = source.morphNormals;
+
+	return this;
+
+};
+
+// File:src/materials/MeshStandardMaterial.js
+
+/**
+ * @author WestLangley / http://github.com/WestLangley
+ *
+ * parameters = {
+ *  color: <hex>,
+ *  roughness: <float>,
+ *  metalness: <float>,
+ *  opacity: <float>,
+ *
+ *  map: new THREE.Texture( <Image> ),
+ *
+ *  lightMap: new THREE.Texture( <Image> ),
+ *  lightMapIntensity: <float>
+ *
+ *  aoMap: new THREE.Texture( <Image> ),
+ *  aoMapIntensity: <float>
+ *
+ *  emissive: <hex>,
+ *  emissiveIntensity: <float>
+ *  emissiveMap: new THREE.Texture( <Image> ),
+ *
+ *  bumpMap: new THREE.Texture( <Image> ),
+ *  bumpScale: <float>,
+ *
+ *  normalMap: new THREE.Texture( <Image> ),
+ *  normalScale: <Vector2>,
+ *
+ *  displacementMap: new THREE.Texture( <Image> ),
+ *  displacementScale: <float>,
+ *  displacementBias: <float>,
+ *
+ *  roughnessMap: new THREE.Texture( <Image> ),
+ *
+ *  metalnessMap: new THREE.Texture( <Image> ),
+ *
+ *  alphaMap: new THREE.Texture( <Image> ),
+ *
+ *  envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
+ *  envMapIntensity: <float>
+ *
+ *  refractionRatio: <float>,
+ *
+ *  shading: THREE.SmoothShading,
+ *  blending: THREE.NormalBlending,
+ *  depthTest: <bool>,
+ *  depthWrite: <bool>,
+ *
+ *  wireframe: <boolean>,
+ *  wireframeLinewidth: <float>,
+ *
+ *  vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors,
+ *
+ *  skinning: <bool>,
+ *  morphTargets: <bool>,
+ *  morphNormals: <bool>,
+ *
+ *	fog: <bool>
+ * }
+ */
+
+THREE.MeshStandardMaterial = function ( parameters ) {
+
+	THREE.Material.call( this );
+
+	this.defines = { 'STANDARD': '' };
+
+	this.type = 'MeshStandardMaterial';
+
+	this.color = new THREE.Color( 0xffffff ); // diffuse
+	this.roughness = 0.5;
+	this.metalness = 0.5;
+
+	this.map = null;
+
+	this.lightMap = null;
+	this.lightMapIntensity = 1.0;
+
+	this.aoMap = null;
+	this.aoMapIntensity = 1.0;
+
+	this.emissive = new THREE.Color( 0x000000 );
+	this.emissiveIntensity = 1.0;
+	this.emissiveMap = null;
+
+	this.bumpMap = null;
+	this.bumpScale = 1;
+
+	this.normalMap = null;
+	this.normalScale = new THREE.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.fog = true;
+
+	this.shading = THREE.SmoothShading;
+	this.blending = THREE.NormalBlending;
+
+	this.wireframe = false;
+	this.wireframeLinewidth = 1;
+	this.wireframeLinecap = 'round';
+	this.wireframeLinejoin = 'round';
+
+	this.vertexColors = THREE.NoColors;
+
+	this.skinning = false;
+	this.morphTargets = false;
+	this.morphNormals = false;
+
+	this.setValues( parameters );
+
+};
+
+THREE.MeshStandardMaterial.prototype = Object.create( THREE.Material.prototype );
+THREE.MeshStandardMaterial.prototype.constructor = THREE.MeshStandardMaterial;
+
+THREE.MeshStandardMaterial.prototype.copy = function ( source ) {
+
+	THREE.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.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.fog = source.fog;
+
+	this.shading = source.shading;
+
+	this.wireframe = source.wireframe;
+	this.wireframeLinewidth = source.wireframeLinewidth;
+	this.wireframeLinecap = source.wireframeLinecap;
+	this.wireframeLinejoin = source.wireframeLinejoin;
+
+	this.vertexColors = source.vertexColors;
+
+	this.skinning = source.skinning;
+	this.morphTargets = source.morphTargets;
+	this.morphNormals = source.morphNormals;
+
+	return this;
+
+};
+
+// File:src/materials/MeshPhysicalMaterial.js
+
+/**
+ * @author WestLangley / http://github.com/WestLangley
+ *
+ * parameters = {
+ *  reflectivity: <float>
+ * }
+ */
+
+THREE.MeshPhysicalMaterial = function ( parameters ) {
+
+	THREE.MeshStandardMaterial.call( this );
+
+	this.defines = { 'PHYSICAL': '' };
+
+	this.type = 'MeshPhysicalMaterial';
+
+	this.reflectivity = 0.5; // maps to F0 = 0.04
+
+	this.setValues( parameters );
+
+};
+
+THREE.MeshPhysicalMaterial.prototype = Object.create( THREE.MeshStandardMaterial.prototype );
+THREE.MeshPhysicalMaterial.prototype.constructor = THREE.MeshPhysicalMaterial;
+
+THREE.MeshPhysicalMaterial.prototype.copy = function ( source ) {
+
+	THREE.MeshStandardMaterial.prototype.copy.call( this, source );
+
+	this.defines = { 'PHYSICAL': '' };
+
+	this.reflectivity = source.reflectivity;
+
+	return this;
+
+};
+
+// File:src/materials/MultiMaterial.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.MultiMaterial = function ( materials ) {
+
+	this.uuid = THREE.Math.generateUUID();
+
+	this.type = 'MultiMaterial';
+
+	this.materials = materials instanceof Array ? materials : [];
+
+	this.visible = true;
+
+};
+
+THREE.MultiMaterial.prototype = {
+
+	constructor: THREE.MultiMaterial,
+
+	toJSON: function ( meta ) {
+
+		var output = {
+			metadata: {
+				version: 4.2,
+				type: 'material',
+				generator: 'MaterialExporter'
+			},
+			uuid: this.uuid,
+			type: this.type,
+			materials: []
+		};
+
+		var materials = this.materials;
+
+		for ( var i = 0, l = materials.length; i < l; i ++ ) {
+
+			var material = materials[ i ].toJSON( meta );
+			delete material.metadata;
+
+			output.materials.push( material );
+
+		}
+
+		output.visible = this.visible;
+
+		return output;
+
+	},
+
+	clone: function () {
+
+		var material = new this.constructor();
+
+		for ( var i = 0; i < this.materials.length; i ++ ) {
+
+			material.materials.push( this.materials[ i ].clone() );
+
+		}
+
+		material.visible = this.visible;
+
+		return material;
+
+	}
+
+};
+
+// File:src/materials/PointsMaterial.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ *
+ * parameters = {
+ *  color: <hex>,
+ *  opacity: <float>,
+ *  map: new THREE.Texture( <Image> ),
+ *
+ *  size: <float>,
+ *  sizeAttenuation: <bool>,
+ *
+ *  blending: THREE.NormalBlending,
+ *  depthTest: <bool>,
+ *  depthWrite: <bool>,
+ *
+ *  vertexColors: <bool>,
+ *
+ *  fog: <bool>
+ * }
+ */
+
+THREE.PointsMaterial = function ( parameters ) {
+
+	THREE.Material.call( this );
+
+	this.type = 'PointsMaterial';
+
+	this.color = new THREE.Color( 0xffffff );
+
+	this.map = null;
+
+	this.size = 1;
+	this.sizeAttenuation = true;
+
+	this.blending = THREE.NormalBlending;
+
+	this.vertexColors = THREE.NoColors;
+
+	this.fog = true;
+
+	this.setValues( parameters );
+
+};
+
+THREE.PointsMaterial.prototype = Object.create( THREE.Material.prototype );
+THREE.PointsMaterial.prototype.constructor = THREE.PointsMaterial;
+
+THREE.PointsMaterial.prototype.copy = function ( source ) {
+
+	THREE.Material.prototype.copy.call( this, source );
+
+	this.color.copy( source.color );
+
+	this.map = source.map;
+
+	this.size = source.size;
+	this.sizeAttenuation = source.sizeAttenuation;
+
+	this.vertexColors = source.vertexColors;
+
+	this.fog = source.fog;
+
+	return this;
+
+};
+
+// File:src/materials/ShaderMaterial.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ *
+ * parameters = {
+ *  defines: { "label" : "value" },
+ *  uniforms: { "parameter1": { type: "1f", value: 1.0 }, "parameter2": { type: "1i" value2: 2 } },
+ *
+ *  fragmentShader: <string>,
+ *  vertexShader: <string>,
+ *
+ *  shading: THREE.SmoothShading,
+ *
+ *  wireframe: <boolean>,
+ *  wireframeLinewidth: <float>,
+ *
+ *  lights: <bool>,
+ *
+ *  vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors,
+ *
+ *  skinning: <bool>,
+ *  morphTargets: <bool>,
+ *  morphNormals: <bool>,
+ *
+ *	fog: <bool>
+ * }
+ */
+
+THREE.ShaderMaterial = function ( parameters ) {
+
+	THREE.Material.call( this );
+
+	this.type = 'ShaderMaterial';
+
+	this.defines = {};
+	this.uniforms = {};
+
+	this.vertexShader = 'void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}';
+	this.fragmentShader = 'void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}';
+
+	this.shading = THREE.SmoothShading;
+
+	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.vertexColors = THREE.NoColors; // set to use "color" attribute stream
+
+	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;
+
+	if ( parameters !== undefined ) {
+
+		if ( parameters.attributes !== undefined ) {
+
+			console.error( 'THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead.' );
+
+		}
+
+		this.setValues( parameters );
+
+	}
+
+};
+
+THREE.ShaderMaterial.prototype = Object.create( THREE.Material.prototype );
+THREE.ShaderMaterial.prototype.constructor = THREE.ShaderMaterial;
+
+THREE.ShaderMaterial.prototype.copy = function ( source ) {
+
+	THREE.Material.prototype.copy.call( this, source );
+
+	this.fragmentShader = source.fragmentShader;
+	this.vertexShader = source.vertexShader;
+
+	this.uniforms = THREE.UniformsUtils.clone( source.uniforms );
+
+	this.defines = source.defines;
+
+	this.shading = source.shading;
+
+	this.wireframe = source.wireframe;
+	this.wireframeLinewidth = source.wireframeLinewidth;
+
+	this.fog = source.fog;
+
+	this.lights = source.lights;
+	this.clipping = source.clipping;
+
+	this.vertexColors = source.vertexColors;
+
+	this.skinning = source.skinning;
+
+	this.morphTargets = source.morphTargets;
+	this.morphNormals = source.morphNormals;
+
+	this.extensions = source.extensions;
+
+	return this;
+
+};
+
+THREE.ShaderMaterial.prototype.toJSON = function ( meta ) {
+
+	var data = THREE.Material.prototype.toJSON.call( this, meta );
+
+	data.uniforms = this.uniforms;
+	data.vertexShader = this.vertexShader;
+	data.fragmentShader = this.fragmentShader;
+
+	return data;
+
+};
+
+// File:src/materials/RawShaderMaterial.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.RawShaderMaterial = function ( parameters ) {
+
+	THREE.ShaderMaterial.call( this, parameters );
+
+	this.type = 'RawShaderMaterial';
+
+};
+
+THREE.RawShaderMaterial.prototype = Object.create( THREE.ShaderMaterial.prototype );
+THREE.RawShaderMaterial.prototype.constructor = THREE.RawShaderMaterial;
+
+// File:src/materials/SpriteMaterial.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ *
+ * parameters = {
+ *  color: <hex>,
+ *  opacity: <float>,
+ *  map: new THREE.Texture( <Image> ),
+ *
+ *	uvOffset: new THREE.Vector2(),
+ *	uvScale: new THREE.Vector2(),
+ *
+ *  fog: <bool>
+ * }
+ */
+
+THREE.SpriteMaterial = function ( parameters ) {
+
+	THREE.Material.call( this );
+
+	this.type = 'SpriteMaterial';
+
+	this.color = new THREE.Color( 0xffffff );
+	this.map = null;
+
+	this.rotation = 0;
+
+	this.fog = false;
+
+	// set parameters
+
+	this.setValues( parameters );
+
+};
+
+THREE.SpriteMaterial.prototype = Object.create( THREE.Material.prototype );
+THREE.SpriteMaterial.prototype.constructor = THREE.SpriteMaterial;
+
+THREE.SpriteMaterial.prototype.copy = function ( source ) {
+
+	THREE.Material.prototype.copy.call( this, source );
+
+	this.color.copy( source.color );
+	this.map = source.map;
+
+	this.rotation = source.rotation;
+
+	this.fog = source.fog;
+
+	return this;
+
+};
+
+// File:src/textures/Texture.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ * @author szimek / https://github.com/szimek/
+ */
+
+THREE.Texture = function ( image, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) {
+
+	Object.defineProperty( this, 'id', { value: THREE.TextureIdCount ++ } );
+
+	this.uuid = THREE.Math.generateUUID();
+
+	this.name = '';
+	this.sourceFile = '';
+
+	this.image = image !== undefined ? image : THREE.Texture.DEFAULT_IMAGE;
+	this.mipmaps = [];
+
+	this.mapping = mapping !== undefined ? mapping : THREE.Texture.DEFAULT_MAPPING;
+
+	this.wrapS = wrapS !== undefined ? wrapS : THREE.ClampToEdgeWrapping;
+	this.wrapT = wrapT !== undefined ? wrapT : THREE.ClampToEdgeWrapping;
+
+	this.magFilter = magFilter !== undefined ? magFilter : THREE.LinearFilter;
+	this.minFilter = minFilter !== undefined ? minFilter : THREE.LinearMipMapLinearFilter;
+
+	this.anisotropy = anisotropy !== undefined ? anisotropy : 1;
+
+	this.format = format !== undefined ? format : THREE.RGBAFormat;
+	this.type = type !== undefined ? type : THREE.UnsignedByteType;
+
+	this.offset = new THREE.Vector2( 0, 0 );
+	this.repeat = new THREE.Vector2( 1, 1 );
+
+	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 :  THREE.LinearEncoding;
+
+	this.version = 0;
+	this.onUpdate = null;
+
+};
+
+THREE.Texture.DEFAULT_IMAGE = undefined;
+THREE.Texture.DEFAULT_MAPPING = THREE.UVMapping;
+
+THREE.Texture.prototype = {
+
+	constructor: THREE.Texture,
+
+	set needsUpdate ( value ) {
+
+		if ( value === true ) this.version ++;
+
+	},
+
+	clone: function () {
+
+		return new this.constructor().copy( this );
+
+	},
+
+	copy: function ( source ) {
+
+		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.type = source.type;
+
+		this.offset.copy( source.offset );
+		this.repeat.copy( source.repeat );
+
+		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 ) {
+
+		if ( meta.textures[ this.uuid ] !== undefined ) {
+
+			return meta.textures[ this.uuid ];
+
+		}
+
+		function getDataURL( image ) {
+
+			var canvas;
+
+			if ( image.toDataURL !== undefined ) {
+
+				canvas = image;
+
+			} else {
+
+				canvas = document.createElement( 'canvas' );
+				canvas.width = image.width;
+				canvas.height = image.height;
+
+				canvas.getContext( '2d' ).drawImage( image, 0, 0, image.width, image.height );
+
+			}
+
+			if ( canvas.width > 2048 || canvas.height > 2048 ) {
+
+				return canvas.toDataURL( 'image/jpeg', 0.6 );
+
+			} else {
+
+				return canvas.toDataURL( 'image/png' );
+
+			}
+
+		}
+
+		var output = {
+			metadata: {
+				version: 4.4,
+				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 ],
+			wrap: [ this.wrapS, this.wrapT ],
+
+			minFilter: this.minFilter,
+			magFilter: this.magFilter,
+			anisotropy: this.anisotropy
+		};
+
+		if ( this.image !== undefined ) {
+
+			// TODO: Move to THREE.Image
+
+			var image = this.image;
+
+			if ( image.uuid === undefined ) {
+
+				image.uuid = THREE.Math.generateUUID(); // UGH
+
+			}
+
+			if ( meta.images[ image.uuid ] === undefined ) {
+
+				meta.images[ image.uuid ] = {
+					uuid: image.uuid,
+					url: getDataURL( image )
+				};
+
+			}
+
+			output.image = image.uuid;
+
+		}
+
+		meta.textures[ this.uuid ] = output;
+
+		return output;
+
+	},
+
+	dispose: function () {
+
+		this.dispatchEvent( { type: 'dispose' } );
+
+	},
+
+	transformUv: function ( uv ) {
+
+		if ( this.mapping !== THREE.UVMapping )  return;
+
+		uv.multiply( this.repeat );
+		uv.add( this.offset );
+
+		if ( uv.x < 0 || uv.x > 1 ) {
+
+			switch ( this.wrapS ) {
+
+				case THREE.RepeatWrapping:
+
+					uv.x = uv.x - Math.floor( uv.x );
+					break;
+
+				case THREE.ClampToEdgeWrapping:
+
+					uv.x = uv.x < 0 ? 0 : 1;
+					break;
+
+				case THREE.MirroredRepeatWrapping:
+
+					if ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) {
+
+						uv.x = Math.ceil( uv.x ) - uv.x;
+
+					} else {
+
+						uv.x = uv.x - Math.floor( uv.x );
+
+					}
+					break;
+
+			}
+
+		}
+
+		if ( uv.y < 0 || uv.y > 1 ) {
+
+			switch ( this.wrapT ) {
+
+				case THREE.RepeatWrapping:
+
+					uv.y = uv.y - Math.floor( uv.y );
+					break;
+
+				case THREE.ClampToEdgeWrapping:
+
+					uv.y = uv.y < 0 ? 0 : 1;
+					break;
+
+				case THREE.MirroredRepeatWrapping:
+
+					if ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) {
+
+						uv.y = Math.ceil( uv.y ) - uv.y;
+
+					} else {
+
+						uv.y = uv.y - Math.floor( uv.y );
+
+					}
+					break;
+
+			}
+
+		}
+
+		if ( this.flipY ) {
+
+			uv.y = 1 - uv.y;
+
+		}
+
+	}
+
+};
+
+THREE.EventDispatcher.prototype.apply( THREE.Texture.prototype );
+
+THREE.TextureIdCount = 0;
+
+// File:src/textures/DepthTexture.js
+
+/**
+ * @author Matt DesLauriers / @mattdesl
+ */
+
+THREE.DepthTexture = function ( width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy ) {
+
+  THREE.Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, THREE.DepthFormat, type, anisotropy );
+
+  this.image = { width: width, height: height };
+
+  this.type = type !== undefined ? type : THREE.UnsignedShortType;
+
+  this.magFilter = magFilter !== undefined ? magFilter : THREE.NearestFilter;
+  this.minFilter = minFilter !== undefined ? minFilter : THREE.NearestFilter;
+
+  this.flipY = false;
+  this.generateMipmaps  = false;
+
+};
+
+THREE.DepthTexture.prototype = Object.create( THREE.Texture.prototype );
+THREE.DepthTexture.prototype.constructor = THREE.DepthTexture;
+
+// File:src/textures/CanvasTexture.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.CanvasTexture = function ( canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {
+
+	THREE.Texture.call( this, canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );
+
+	this.needsUpdate = true;
+
+};
+
+THREE.CanvasTexture.prototype = Object.create( THREE.Texture.prototype );
+THREE.CanvasTexture.prototype.constructor = THREE.CanvasTexture;
+
+// File:src/textures/CubeTexture.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.CubeTexture = function ( images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) {
+
+	images = images !== undefined ? images : [];
+	mapping = mapping !== undefined ? mapping : THREE.CubeReflectionMapping;
+
+	THREE.Texture.call( this, images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );
+
+	this.flipY = false;
+
+};
+
+THREE.CubeTexture.prototype = Object.create( THREE.Texture.prototype );
+THREE.CubeTexture.prototype.constructor = THREE.CubeTexture;
+
+Object.defineProperty( THREE.CubeTexture.prototype, 'images', {
+
+	get: function () {
+
+		return this.image;
+
+	},
+
+	set: function ( value ) {
+
+		this.image = value;
+
+	}
+
+} );
+
+// File:src/textures/CompressedTexture.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.CompressedTexture = function ( mipmaps, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) {
+
+	THREE.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;
+
+};
+
+THREE.CompressedTexture.prototype = Object.create( THREE.Texture.prototype );
+THREE.CompressedTexture.prototype.constructor = THREE.CompressedTexture;
+
+// File:src/textures/DataTexture.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.DataTexture = function ( data, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) {
+
+	THREE.Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );
+
+	this.image = { data: data, width: width, height: height };
+
+	this.magFilter = magFilter !== undefined ? magFilter : THREE.NearestFilter;
+	this.minFilter = minFilter !== undefined ? minFilter : THREE.NearestFilter;
+
+	this.flipY = false;
+	this.generateMipmaps  = false;
+
+};
+
+THREE.DataTexture.prototype = Object.create( THREE.Texture.prototype );
+THREE.DataTexture.prototype.constructor = THREE.DataTexture;
+
+// File:src/textures/VideoTexture.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.VideoTexture = function ( video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {
+
+	THREE.Texture.call( this, video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );
+
+	this.generateMipmaps = false;
+
+	var scope = this;
+
+	function update() {
+
+		requestAnimationFrame( update );
+
+		if ( video.readyState >= video.HAVE_CURRENT_DATA ) {
+
+			scope.needsUpdate = true;
+
+		}
+
+	}
+
+	update();
+
+};
+
+THREE.VideoTexture.prototype = Object.create( THREE.Texture.prototype );
+THREE.VideoTexture.prototype.constructor = THREE.VideoTexture;
+
+// File:src/objects/Group.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.Group = function () {
+
+	THREE.Object3D.call( this );
+
+	this.type = 'Group';
+
+};
+
+THREE.Group.prototype = Object.create( THREE.Object3D.prototype );
+THREE.Group.prototype.constructor = THREE.Group;
+
+// File:src/objects/Points.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.Points = function ( geometry, material ) {
+
+	THREE.Object3D.call( this );
+
+	this.type = 'Points';
+
+	this.geometry = geometry !== undefined ? geometry : new THREE.Geometry();
+	this.material = material !== undefined ? material : new THREE.PointsMaterial( { color: Math.random() * 0xffffff } );
+
+};
+
+THREE.Points.prototype = Object.create( THREE.Object3D.prototype );
+THREE.Points.prototype.constructor = THREE.Points;
+
+THREE.Points.prototype.raycast = ( function () {
+
+	var inverseMatrix = new THREE.Matrix4();
+	var ray = new THREE.Ray();
+	var sphere = new THREE.Sphere();
+
+	return function raycast( raycaster, intersects ) {
+
+		var object = this;
+		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.copy( geometry.boundingSphere );
+		sphere.applyMatrix4( matrixWorld );
+
+		if ( raycaster.ray.intersectsSphere( sphere ) === false ) return;
+
+		//
+
+		inverseMatrix.getInverse( matrixWorld );
+		ray.copy( raycaster.ray ).applyMatrix4( inverseMatrix );
+
+		var localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 );
+		var localThresholdSq = localThreshold * localThreshold;
+		var position = new THREE.Vector3();
+
+		function testPoint( point, index ) {
+
+			var rayPointDistanceSq = ray.distanceSqToPoint( point );
+
+			if ( rayPointDistanceSq < localThresholdSq ) {
+
+				var intersectPoint = ray.closestPointToPoint( point );
+				intersectPoint.applyMatrix4( matrixWorld );
+
+				var distance = raycaster.ray.origin.distanceTo( intersectPoint );
+
+				if ( distance < raycaster.near || distance > raycaster.far ) return;
+
+				intersects.push( {
+
+					distance: distance,
+					distanceToRay: Math.sqrt( rayPointDistanceSq ),
+					point: intersectPoint.clone(),
+					index: index,
+					face: null,
+					object: object
+
+				} );
+
+			}
+
+		}
+
+		if ( geometry instanceof THREE.BufferGeometry ) {
+
+			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 < il; i ++ ) {
+
+					var a = indices[ i ];
+
+					position.fromArray( positions, a * 3 );
+
+					testPoint( position, a );
+
+				}
+
+			} else {
+
+				for ( var i = 0, l = positions.length / 3; i < l; i ++ ) {
+
+					position.fromArray( positions, i * 3 );
+
+					testPoint( position, i );
+
+				}
+
+			}
+
+		} else {
+
+			var vertices = geometry.vertices;
+
+			for ( var i = 0, l = vertices.length; i < l; i ++ ) {
+
+				testPoint( vertices[ i ], i );
+
+			}
+
+		}
+
+	};
+
+}() );
+
+THREE.Points.prototype.clone = function () {
+
+	return new this.constructor( this.geometry, this.material ).copy( this );
+
+};
+
+// File:src/objects/Line.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.Line = function ( geometry, material, mode ) {
+
+	if ( mode === 1 ) {
+
+		console.warn( 'THREE.Line: parameter THREE.LinePieces no longer supported. Created THREE.LineSegments instead.' );
+		return new THREE.LineSegments( geometry, material );
+
+	}
+
+	THREE.Object3D.call( this );
+
+	this.type = 'Line';
+
+	this.geometry = geometry !== undefined ? geometry : new THREE.Geometry();
+	this.material = material !== undefined ? material : new THREE.LineBasicMaterial( { color: Math.random() * 0xffffff } );
+
+};
+
+THREE.Line.prototype = Object.create( THREE.Object3D.prototype );
+THREE.Line.prototype.constructor = THREE.Line;
+
+THREE.Line.prototype.raycast = ( function () {
+
+	var inverseMatrix = new THREE.Matrix4();
+	var ray = new THREE.Ray();
+	var sphere = new THREE.Sphere();
+
+	return function raycast( raycaster, intersects ) {
+
+		var precision = raycaster.linePrecision;
+		var precisionSq = precision * precision;
+
+		var geometry = this.geometry;
+		var matrixWorld = this.matrixWorld;
+
+		// 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 );
+
+		var vStart = new THREE.Vector3();
+		var vEnd = new THREE.Vector3();
+		var interSegment = new THREE.Vector3();
+		var interRay = new THREE.Vector3();
+		var step = this instanceof THREE.LineSegments ? 2 : 1;
+
+		if ( geometry instanceof THREE.BufferGeometry ) {
+
+			var index = geometry.index;
+			var attributes = geometry.attributes;
+			var positions = attributes.position.array;
+
+			if ( index !== null ) {
+
+				var indices = index.array;
+
+				for ( var i = 0, l = indices.length - 1; i < l; i += step ) {
+
+					var a = indices[ i ];
+					var b = indices[ i + 1 ];
+
+					vStart.fromArray( positions, a * 3 );
+					vEnd.fromArray( positions, b * 3 );
+
+					var distSq = ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment );
+
+					if ( distSq > precisionSq ) continue;
+
+					interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
+
+					var distance = raycaster.ray.origin.distanceTo( interRay );
+
+					if ( distance < raycaster.near || 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 < l; i += step ) {
+
+					vStart.fromArray( positions, 3 * i );
+					vEnd.fromArray( positions, 3 * i + 3 );
+
+					var distSq = ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment );
+
+					if ( distSq > precisionSq ) continue;
+
+					interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
+
+					var distance = raycaster.ray.origin.distanceTo( interRay );
+
+					if ( distance < raycaster.near || 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 instanceof THREE.Geometry ) {
+
+			var vertices = geometry.vertices;
+			var nbVertices = vertices.length;
+
+			for ( var i = 0; i < nbVertices - 1; i += step ) {
+
+				var distSq = ray.distanceSqToSegment( vertices[ i ], vertices[ i + 1 ], interRay, interSegment );
+
+				if ( distSq > precisionSq ) continue;
+
+				interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
+
+				var distance = raycaster.ray.origin.distanceTo( interRay );
+
+				if ( distance < raycaster.near || 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
+
+				} );
+
+			}
+
+		}
+
+	};
+
+}() );
+
+THREE.Line.prototype.clone = function () {
+
+	return new this.constructor( this.geometry, this.material ).copy( this );
+
+};
+
+// DEPRECATED
+
+THREE.LineStrip = 0;
+THREE.LinePieces = 1;
+
+// File:src/objects/LineSegments.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.LineSegments = function ( geometry, material ) {
+
+	THREE.Line.call( this, geometry, material );
+
+	this.type = 'LineSegments';
+
+};
+
+THREE.LineSegments.prototype = Object.create( THREE.Line.prototype );
+THREE.LineSegments.prototype.constructor = THREE.LineSegments;
+
+// File:src/objects/Mesh.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ * @author mikael emtinger / http://gomo.se/
+ * @author jonobr1 / http://jonobr1.com/
+ */
+
+THREE.Mesh = function ( geometry, material ) {
+
+	THREE.Object3D.call( this );
+
+	this.type = 'Mesh';
+
+	this.geometry = geometry !== undefined ? geometry : new THREE.Geometry();
+	this.material = material !== undefined ? material : new THREE.MeshBasicMaterial( { color: Math.random() * 0xffffff } );
+
+	this.drawMode = THREE.TrianglesDrawMode;
+
+	this.updateMorphTargets();
+
+};
+
+THREE.Mesh.prototype = Object.create( THREE.Object3D.prototype );
+THREE.Mesh.prototype.constructor = THREE.Mesh;
+
+THREE.Mesh.prototype.setDrawMode = function ( value ) {
+
+	this.drawMode = value;
+
+};
+
+THREE.Mesh.prototype.updateMorphTargets = function () {
+
+	if ( this.geometry.morphTargets !== undefined && this.geometry.morphTargets.length > 0 ) {
+
+		this.morphTargetBase = - 1;
+		this.morphTargetInfluences = [];
+		this.morphTargetDictionary = {};
+
+		for ( var m = 0, ml = this.geometry.morphTargets.length; m < ml; m ++ ) {
+
+			this.morphTargetInfluences.push( 0 );
+			this.morphTargetDictionary[ this.geometry.morphTargets[ m ].name ] = m;
+
+		}
+
+	}
+
+};
+
+THREE.Mesh.prototype.getMorphTargetIndexByName = function ( name ) {
+
+	if ( this.morphTargetDictionary[ name ] !== undefined ) {
+
+		return this.morphTargetDictionary[ name ];
+
+	}
+
+	console.warn( 'THREE.Mesh.getMorphTargetIndexByName: morph target ' + name + ' does not exist. Returning 0.' );
+
+	return 0;
+
+};
+
+
+THREE.Mesh.prototype.raycast = ( function () {
+
+	var inverseMatrix = new THREE.Matrix4();
+	var ray = new THREE.Ray();
+	var sphere = new THREE.Sphere();
+
+	var vA = new THREE.Vector3();
+	var vB = new THREE.Vector3();
+	var vC = new THREE.Vector3();
+
+	var tempA = new THREE.Vector3();
+	var tempB = new THREE.Vector3();
+	var tempC = new THREE.Vector3();
+
+	var uvA = new THREE.Vector2();
+	var uvB = new THREE.Vector2();
+	var uvC = new THREE.Vector2();
+
+	var barycoord = new THREE.Vector3();
+
+	var intersectionPoint = new THREE.Vector3();
+	var intersectionPointWorld = new THREE.Vector3();
+
+	function uvIntersection( point, p1, p2, p3, uv1, uv2, uv3 ) {
+
+		THREE.Triangle.barycoordFromPoint( point, p1, p2, p3, barycoord );
+
+		uv1.multiplyScalar( barycoord.x );
+		uv2.multiplyScalar( barycoord.y );
+		uv3.multiplyScalar( barycoord.z );
+
+		uv1.add( uv2 ).add( uv3 );
+
+		return uv1.clone();
+
+	}
+
+	function checkIntersection( object, raycaster, ray, pA, pB, pC, point ) {
+
+		var intersect;
+		var material = object.material;
+
+		if ( material.side === THREE.BackSide ) {
+
+			intersect = ray.intersectTriangle( pC, pB, pA, true, point );
+
+		} else {
+
+			intersect = ray.intersectTriangle( pA, pB, pC, material.side !== THREE.DoubleSide, point );
+
+		}
+
+		if ( intersect === null ) return null;
+
+		intersectionPointWorld.copy( point );
+		intersectionPointWorld.applyMatrix4( object.matrixWorld );
+
+		var distance = raycaster.ray.origin.distanceTo( intersectionPointWorld );
+
+		if ( distance < raycaster.near || distance > raycaster.far ) return null;
+
+		return {
+			distance: distance,
+			point: intersectionPointWorld.clone(),
+			object: object
+		};
+
+	}
+
+	function checkBufferGeometryIntersection( object, raycaster, ray, positions, uvs, a, b, c ) {
+
+		vA.fromArray( positions, a * 3 );
+		vB.fromArray( positions, b * 3 );
+		vC.fromArray( positions, c * 3 );
+
+		var intersection = checkIntersection( object, raycaster, ray, vA, vB, vC, intersectionPoint );
+
+		if ( intersection ) {
+
+			if ( uvs ) {
+
+				uvA.fromArray( uvs, a * 2 );
+				uvB.fromArray( uvs, b * 2 );
+				uvC.fromArray( uvs, c * 2 );
+
+				intersection.uv = uvIntersection( intersectionPoint,  vA, vB, vC,  uvA, uvB, uvC );
+
+			}
+
+			intersection.face = new THREE.Face3( a, b, c, THREE.Triangle.normal( vA, vB, vC ) );
+			intersection.faceIndex = a;
+
+		}
+
+		return intersection;
+
+	}
+
+	return function raycast( 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 uvs, intersection;
+
+		if ( geometry instanceof THREE.BufferGeometry ) {
+
+			var a, b, c;
+			var index = geometry.index;
+			var attributes = geometry.attributes;
+			var positions = attributes.position.array;
+
+			if ( attributes.uv !== undefined ) {
+
+				uvs = attributes.uv.array;
+
+			}
+
+			if ( index !== null ) {
+
+				var indices = index.array;
+
+				for ( var i = 0, l = indices.length; i < l; i += 3 ) {
+
+					a = indices[ i ];
+					b = indices[ i + 1 ];
+					c = indices[ i + 2 ];
+
+					intersection = checkBufferGeometryIntersection( this, raycaster, ray, positions, uvs, a, b, c );
+
+					if ( intersection ) {
+
+						intersection.faceIndex = Math.floor( i / 3 ); // triangle number in indices buffer semantics
+						intersects.push( intersection );
+
+					}
+
+				}
+
+			} else {
+
+
+				for ( var i = 0, l = positions.length; i < l; i += 9 ) {
+
+					a = i / 3;
+					b = a + 1;
+					c = a + 2;
+
+					intersection = checkBufferGeometryIntersection( this, raycaster, ray, positions, uvs, a, b, c );
+
+					if ( intersection ) {
+
+						intersection.index = a; // triangle number in positions buffer semantics
+						intersects.push( intersection );
+
+					}
+
+				}
+
+			}
+
+		} else if ( geometry instanceof THREE.Geometry ) {
+
+			var fvA, fvB, fvC;
+			var isFaceMaterial = material instanceof THREE.MultiMaterial;
+			var materials = isFaceMaterial === true ? material.materials : null;
+
+			var vertices = geometry.vertices;
+			var faces = geometry.faces;
+			var faceVertexUvs = geometry.faceVertexUvs[ 0 ];
+			if ( faceVertexUvs.length > 0 ) uvs = faceVertexUvs;
+
+			for ( var f = 0, fl = faces.length; f < fl; f ++ ) {
+
+				var face = faces[ f ];
+				var faceMaterial = isFaceMaterial === true ? materials[ face.materialIndex ] : material;
+
+				if ( faceMaterial === undefined ) continue;
+
+				fvA = vertices[ face.a ];
+				fvB = vertices[ face.b ];
+				fvC = vertices[ face.c ];
+
+				if ( faceMaterial.morphTargets === true ) {
+
+					var morphTargets = geometry.morphTargets;
+					var morphInfluences = this.morphTargetInfluences;
+
+					vA.set( 0, 0, 0 );
+					vB.set( 0, 0, 0 );
+					vC.set( 0, 0, 0 );
+
+					for ( var t = 0, tl = morphTargets.length; t < tl; t ++ ) {
+
+						var influence = morphInfluences[ t ];
+
+						if ( influence === 0 ) continue;
+
+						var targets = morphTargets[ t ].vertices;
+
+						vA.addScaledVector( tempA.subVectors( targets[ face.a ], fvA ), influence );
+						vB.addScaledVector( tempB.subVectors( targets[ face.b ], fvB ), influence );
+						vC.addScaledVector( tempC.subVectors( targets[ face.c ], fvC ), influence );
+
+					}
+
+					vA.add( fvA );
+					vB.add( fvB );
+					vC.add( fvC );
+
+					fvA = vA;
+					fvB = vB;
+					fvC = vC;
+
+				}
+
+				intersection = checkIntersection( this, raycaster, ray, fvA, fvB, fvC, intersectionPoint );
+
+				if ( intersection ) {
+
+					if ( uvs ) {
+
+						var uvs_f = uvs[ f ];
+						uvA.copy( uvs_f[ 0 ] );
+						uvB.copy( uvs_f[ 1 ] );
+						uvC.copy( uvs_f[ 2 ] );
+
+						intersection.uv = uvIntersection( intersectionPoint, fvA, fvB, fvC, uvA, uvB, uvC );
+
+					}
+
+					intersection.face = face;
+					intersection.faceIndex = f;
+					intersects.push( intersection );
+
+				}
+
+			}
+
+		}
+
+	};
+
+}() );
+
+THREE.Mesh.prototype.clone = function () {
+
+	return new this.constructor( this.geometry, this.material ).copy( this );
+
+};
+
+// File:src/objects/Bone.js
+
+/**
+ * @author mikael emtinger / http://gomo.se/
+ * @author alteredq / http://alteredqualia.com/
+ * @author ikerr / http://verold.com
+ */
+
+THREE.Bone = function ( skin ) {
+
+	THREE.Object3D.call( this );
+
+	this.type = 'Bone';
+
+	this.skin = skin;
+
+};
+
+THREE.Bone.prototype = Object.create( THREE.Object3D.prototype );
+THREE.Bone.prototype.constructor = THREE.Bone;
+
+THREE.Bone.prototype.copy = function ( source ) {
+
+	THREE.Object3D.prototype.copy.call( this, source );
+
+	this.skin = source.skin;
+
+	return this;
+
+};
+
+// File:src/objects/Skeleton.js
+
+/**
+ * @author mikael emtinger / http://gomo.se/
+ * @author alteredq / http://alteredqualia.com/
+ * @author michael guerrero / http://realitymeltdown.com
+ * @author ikerr / http://verold.com
+ */
+
+THREE.Skeleton = function ( bones, boneInverses, useVertexTexture ) {
+
+	this.useVertexTexture = useVertexTexture !== undefined ? useVertexTexture : true;
+
+	this.identityMatrix = new THREE.Matrix4();
+
+	// copy the bone array
+
+	bones = bones || [];
+
+	this.bones = bones.slice( 0 );
+
+	// create a bone texture or an array of floats
+
+	if ( this.useVertexTexture ) {
+
+		// 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( this.bones.length * 4 ); // 4 pixels needed for 1 matrix
+		size = THREE.Math.nextPowerOfTwo( Math.ceil( size ) );
+		size = Math.max( size, 4 );
+
+		this.boneTextureWidth = size;
+		this.boneTextureHeight = size;
+
+		this.boneMatrices = new Float32Array( this.boneTextureWidth * this.boneTextureHeight * 4 ); // 4 floats per RGBA pixel
+		this.boneTexture = new THREE.DataTexture( this.boneMatrices, this.boneTextureWidth, this.boneTextureHeight, THREE.RGBAFormat, THREE.FloatType );
+
+	} else {
+
+		this.boneMatrices = new Float32Array( 16 * this.bones.length );
+
+	}
+
+	// use the supplied bone inverses or calculate the inverses
+
+	if ( boneInverses === undefined ) {
+
+		this.calculateInverses();
+
+	} else {
+
+		if ( this.bones.length === boneInverses.length ) {
+
+			this.boneInverses = boneInverses.slice( 0 );
+
+		} else {
+
+			console.warn( 'THREE.Skeleton bonInverses is the wrong length.' );
+
+			this.boneInverses = [];
+
+			for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) {
+
+				this.boneInverses.push( new THREE.Matrix4() );
+
+			}
+
+		}
+
+	}
+
+};
+
+THREE.Skeleton.prototype.calculateInverses = function () {
+
+	this.boneInverses = [];
+
+	for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) {
+
+		var inverse = new THREE.Matrix4();
+
+		if ( this.bones[ b ] ) {
+
+			inverse.getInverse( this.bones[ b ].matrixWorld );
+
+		}
+
+		this.boneInverses.push( inverse );
+
+	}
+
+};
+
+THREE.Skeleton.prototype.pose = function () {
+
+	var bone;
+
+	// recover the bind-time world matrices
+
+	for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) {
+
+		bone = this.bones[ b ];
+
+		if ( bone ) {
+
+			bone.matrixWorld.getInverse( this.boneInverses[ b ] );
+
+		}
+
+	}
+
+	// compute the local matrices, positions, rotations and scales
+
+	for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) {
+
+		bone = this.bones[ b ];
+
+		if ( bone ) {
+
+			if ( bone.parent ) {
+
+				bone.matrix.getInverse( bone.parent.matrixWorld );
+				bone.matrix.multiply( bone.matrixWorld );
+
+			} else {
+
+				bone.matrix.copy( bone.matrixWorld );
+
+			}
+
+			bone.matrix.decompose( bone.position, bone.quaternion, bone.scale );
+
+		}
+
+	}
+
+};
+
+THREE.Skeleton.prototype.update = ( function () {
+
+	var offsetMatrix = new THREE.Matrix4();
+
+	return function update() {
+
+		// flatten bone matrices to array
+
+		for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) {
+
+			// compute the offset between the current and the original transform
+
+			var matrix = this.bones[ b ] ? this.bones[ b ].matrixWorld : this.identityMatrix;
+
+			offsetMatrix.multiplyMatrices( matrix, this.boneInverses[ b ] );
+			offsetMatrix.toArray( this.boneMatrices, b * 16 );
+
+		}
+
+		if ( this.useVertexTexture ) {
+
+			this.boneTexture.needsUpdate = true;
+
+		}
+
+	};
+
+} )();
+
+THREE.Skeleton.prototype.clone = function () {
+
+	return new THREE.Skeleton( this.bones, this.boneInverses, this.useVertexTexture );
+
+};
+
+// File:src/objects/SkinnedMesh.js
+
+/**
+ * @author mikael emtinger / http://gomo.se/
+ * @author alteredq / http://alteredqualia.com/
+ * @author ikerr / http://verold.com
+ */
+
+THREE.SkinnedMesh = function ( geometry, material, useVertexTexture ) {
+
+	THREE.Mesh.call( this, geometry, material );
+
+	this.type = 'SkinnedMesh';
+
+	this.bindMode = "attached";
+	this.bindMatrix = new THREE.Matrix4();
+	this.bindMatrixInverse = new THREE.Matrix4();
+
+	// init bones
+
+	// TODO: remove bone creation as there is no reason (other than
+	// convenience) for THREE.SkinnedMesh to do this.
+
+	var bones = [];
+
+	if ( this.geometry && this.geometry.bones !== undefined ) {
+
+		var bone, gbone;
+
+		for ( var b = 0, bl = this.geometry.bones.length; b < bl; ++ b ) {
+
+			gbone = this.geometry.bones[ b ];
+
+			bone = new THREE.Bone( this );
+			bones.push( bone );
+
+			bone.name = gbone.name;
+			bone.position.fromArray( gbone.pos );
+			bone.quaternion.fromArray( gbone.rotq );
+			if ( gbone.scl !== undefined ) bone.scale.fromArray( gbone.scl );
+
+		}
+
+		for ( var b = 0, bl = this.geometry.bones.length; b < bl; ++ b ) {
+
+			gbone = this.geometry.bones[ b ];
+
+			if ( gbone.parent !== - 1 && gbone.parent !== null &&
+					bones[ gbone.parent ] !== undefined ) {
+
+				bones[ gbone.parent ].add( bones[ b ] );
+
+			} else {
+
+				this.add( bones[ b ] );
+
+			}
+
+		}
+
+	}
+
+	this.normalizeSkinWeights();
+
+	this.updateMatrixWorld( true );
+	this.bind( new THREE.Skeleton( bones, undefined, useVertexTexture ), this.matrixWorld );
+
+};
+
+
+THREE.SkinnedMesh.prototype = Object.create( THREE.Mesh.prototype );
+THREE.SkinnedMesh.prototype.constructor = THREE.SkinnedMesh;
+
+THREE.SkinnedMesh.prototype.bind = function( skeleton, bindMatrix ) {
+
+	this.skeleton = skeleton;
+
+	if ( bindMatrix === undefined ) {
+
+		this.updateMatrixWorld( true );
+
+		this.skeleton.calculateInverses();
+
+		bindMatrix = this.matrixWorld;
+
+	}
+
+	this.bindMatrix.copy( bindMatrix );
+	this.bindMatrixInverse.getInverse( bindMatrix );
+
+};
+
+THREE.SkinnedMesh.prototype.pose = function () {
+
+	this.skeleton.pose();
+
+};
+
+THREE.SkinnedMesh.prototype.normalizeSkinWeights = function () {
+
+	if ( this.geometry instanceof THREE.Geometry ) {
+
+		for ( var i = 0; i < this.geometry.skinWeights.length; i ++ ) {
+
+			var sw = this.geometry.skinWeights[ i ];
+
+			var scale = 1.0 / sw.lengthManhattan();
+
+			if ( scale !== Infinity ) {
+
+				sw.multiplyScalar( scale );
+
+			} else {
+
+				sw.set( 1, 0, 0, 0 ); // do something reasonable
+
+			}
+
+		}
+
+	} else if ( this.geometry instanceof THREE.BufferGeometry ) {
+
+		var vec = new THREE.Vector4();
+
+		var skinWeight = this.geometry.attributes.skinWeight;
+
+		for ( var i = 0; i < skinWeight.count; i ++ ) {
+
+			vec.x = skinWeight.getX( i );
+			vec.y = skinWeight.getY( i );
+			vec.z = skinWeight.getZ( i );
+			vec.w = skinWeight.getW( i );
+
+			var scale = 1.0 / vec.lengthManhattan();
+
+			if ( scale !== Infinity ) {
+
+				vec.multiplyScalar( scale );
+
+			} else {
+
+				vec.set( 1, 0, 0, 0 ); // do something reasonable
+
+			}
+
+			skinWeight.setXYZW( i, vec.x, vec.y, vec.z, vec.w );
+
+		}
+
+	}
+
+};
+
+THREE.SkinnedMesh.prototype.updateMatrixWorld = function( force ) {
+
+	THREE.Mesh.prototype.updateMatrixWorld.call( this, true );
+
+	if ( this.bindMode === "attached" ) {
+
+		this.bindMatrixInverse.getInverse( this.matrixWorld );
+
+	} else if ( this.bindMode === "detached" ) {
+
+		this.bindMatrixInverse.getInverse( this.bindMatrix );
+
+	} else {
+
+		console.warn( 'THREE.SkinnedMesh unrecognized bindMode: ' + this.bindMode );
+
+	}
+
+};
+
+THREE.SkinnedMesh.prototype.clone = function() {
+
+	return new this.constructor( this.geometry, this.material, this.useVertexTexture ).copy( this );
+
+};
+
+// File:src/objects/LOD.js
+
+/**
+ * @author mikael emtinger / http://gomo.se/
+ * @author alteredq / http://alteredqualia.com/
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.LOD = function () {
+
+	THREE.Object3D.call( this );
+
+	this.type = 'LOD';
+
+	Object.defineProperties( this, {
+		levels: {
+			enumerable: true,
+			value: []
+		}
+	} );
+
+};
+
+
+THREE.LOD.prototype = Object.create( THREE.Object3D.prototype );
+THREE.LOD.prototype.constructor = THREE.LOD;
+
+THREE.LOD.prototype.addLevel = function ( object, distance ) {
+
+	if ( distance === undefined ) distance = 0;
+
+	distance = Math.abs( distance );
+
+	var levels = this.levels;
+
+	for ( var l = 0; l < levels.length; l ++ ) {
+
+		if ( distance < levels[ l ].distance ) {
+
+			break;
+
+		}
+
+	}
+
+	levels.splice( l, 0, { distance: distance, object: object } );
+
+	this.add( object );
+
+};
+
+THREE.LOD.prototype.getObjectForDistance = function ( distance ) {
+
+	var levels = this.levels;
+
+	for ( var i = 1, l = levels.length; i < l; i ++ ) {
+
+		if ( distance < levels[ i ].distance ) {
+
+			break;
+
+		}
+
+	}
+
+	return levels[ i - 1 ].object;
+
+};
+
+THREE.LOD.prototype.raycast = ( function () {
+
+	var matrixPosition = new THREE.Vector3();
+
+	return function raycast( raycaster, intersects ) {
+
+		matrixPosition.setFromMatrixPosition( this.matrixWorld );
+
+		var distance = raycaster.ray.origin.distanceTo( matrixPosition );
+
+		this.getObjectForDistance( distance ).raycast( raycaster, intersects );
+
+	};
+
+}() );
+
+THREE.LOD.prototype.update = function () {
+
+	var v1 = new THREE.Vector3();
+	var v2 = new THREE.Vector3();
+
+	return function update( camera ) {
+
+		var levels = this.levels;
+
+		if ( levels.length > 1 ) {
+
+			v1.setFromMatrixPosition( camera.matrixWorld );
+			v2.setFromMatrixPosition( this.matrixWorld );
+
+			var distance = v1.distanceTo( v2 );
+
+			levels[ 0 ].object.visible = true;
+
+			for ( var i = 1, l = levels.length; i < l; i ++ ) {
+
+				if ( distance >= levels[ i ].distance ) {
+
+					levels[ i - 1 ].object.visible = false;
+					levels[ i ].object.visible = true;
+
+				} else {
+
+					break;
+
+				}
+
+			}
+
+			for ( ; i < l; i ++ ) {
+
+				levels[ i ].object.visible = false;
+
+			}
+
+		}
+
+	};
+
+}();
+
+THREE.LOD.prototype.copy = function ( source ) {
+
+	THREE.Object3D.prototype.copy.call( this, source, false );
+
+	var levels = source.levels;
+
+	for ( var i = 0, l = levels.length; i < l; i ++ ) {
+
+		var level = levels[ i ];
+
+		this.addLevel( level.object.clone(), level.distance );
+
+	}
+
+	return this;
+
+};
+
+THREE.LOD.prototype.toJSON = function ( meta ) {
+
+	var data = THREE.Object3D.prototype.toJSON.call( this, meta );
+
+	data.object.levels = [];
+
+	var levels = this.levels;
+
+	for ( var i = 0, l = levels.length; i < l; i ++ ) {
+
+		var level = levels[ i ];
+
+		data.object.levels.push( {
+			object: level.object.uuid,
+			distance: level.distance
+		} );
+
+	}
+
+	return data;
+
+};
+
+// File:src/objects/Sprite.js
+
+/**
+ * @author mikael emtinger / http://gomo.se/
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.Sprite = ( function () {
+
+	var indices = new Uint16Array( [ 0, 1, 2,  0, 2, 3 ] );
+	var vertices = new Float32Array( [ - 0.5, - 0.5, 0,   0.5, - 0.5, 0,   0.5, 0.5, 0,   - 0.5, 0.5, 0 ] );
+	var uvs = new Float32Array( [ 0, 0,   1, 0,   1, 1,   0, 1 ] );
+
+	var geometry = new THREE.BufferGeometry();
+	geometry.setIndex( new THREE.BufferAttribute( indices, 1 ) );
+	geometry.addAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+	geometry.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ) );
+
+	return function Sprite( material ) {
+
+		THREE.Object3D.call( this );
+
+		this.type = 'Sprite';
+
+		this.geometry = geometry;
+		this.material = ( material !== undefined ) ? material : new THREE.SpriteMaterial();
+
+	};
+
+} )();
+
+THREE.Sprite.prototype = Object.create( THREE.Object3D.prototype );
+THREE.Sprite.prototype.constructor = THREE.Sprite;
+
+THREE.Sprite.prototype.raycast = ( function () {
+
+	var matrixPosition = new THREE.Vector3();
+
+	return function raycast( raycaster, intersects ) {
+
+		matrixPosition.setFromMatrixPosition( this.matrixWorld );
+
+		var distanceSq = raycaster.ray.distanceSqToPoint( matrixPosition );
+		var guessSizeSq = this.scale.x * this.scale.y / 4;
+
+		if ( distanceSq > guessSizeSq ) {
+
+			return;
+
+		}
+
+		intersects.push( {
+
+			distance: Math.sqrt( distanceSq ),
+			point: this.position,
+			face: null,
+			object: this
+
+		} );
+
+	};
+
+}() );
+
+THREE.Sprite.prototype.clone = function () {
+
+	return new this.constructor( this.material ).copy( this );
+
+};
+
+// Backwards compatibility
+
+THREE.Particle = THREE.Sprite;
+
+// File:src/objects/LensFlare.js
+
+/**
+ * @author mikael emtinger / http://gomo.se/
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.LensFlare = function ( texture, size, distance, blending, color ) {
+
+	THREE.Object3D.call( this );
+
+	this.lensFlares = [];
+
+	this.positionScreen = new THREE.Vector3();
+	this.customUpdateCallback = undefined;
+
+	if ( texture !== undefined ) {
+
+		this.add( texture, size, distance, blending, color );
+
+	}
+
+};
+
+THREE.LensFlare.prototype = Object.create( THREE.Object3D.prototype );
+THREE.LensFlare.prototype.constructor = THREE.LensFlare;
+
+
+/*
+ * Add: adds another flare
+ */
+
+THREE.LensFlare.prototype.add = function ( texture, size, distance, blending, color, opacity ) {
+
+	if ( size === undefined ) size = - 1;
+	if ( distance === undefined ) distance = 0;
+	if ( opacity === undefined ) opacity = 1;
+	if ( color === undefined ) color = new THREE.Color( 0xffffff );
+	if ( blending === undefined ) blending = THREE.NormalBlending;
+
+	distance = Math.min( distance, Math.max( 0, distance ) );
+
+	this.lensFlares.push( {
+		texture: texture,	// THREE.Texture
+		size: size, 		// size in pixels (-1 = use texture.width)
+		distance: distance, 	// distance (0-1) from light source (0=at light source)
+		x: 0, y: 0, z: 0,	// screen position (-1 => 1) z = 0 is in front z = 1 is back
+		scale: 1, 		// scale
+		rotation: 0, 		// rotation
+		opacity: opacity,	// opacity
+		color: color,		// color
+		blending: blending	// blending
+	} );
+
+};
+
+/*
+ * Update lens flares update positions on all flares based on the screen position
+ * Set myLensFlare.customUpdateCallback to alter the flares in your project specific way.
+ */
+
+THREE.LensFlare.prototype.updateLensFlares = function () {
+
+	var f, fl = this.lensFlares.length;
+	var flare;
+	var vecX = - this.positionScreen.x * 2;
+	var vecY = - this.positionScreen.y * 2;
+
+	for ( f = 0; f < fl; f ++ ) {
+
+		flare = this.lensFlares[ f ];
+
+		flare.x = this.positionScreen.x + vecX * flare.distance;
+		flare.y = this.positionScreen.y + vecY * flare.distance;
+
+		flare.wantedRotation = flare.x * Math.PI * 0.25;
+		flare.rotation += ( flare.wantedRotation - flare.rotation ) * 0.25;
+
+	}
+
+};
+
+THREE.LensFlare.prototype.copy = function ( source ) {
+
+	THREE.Object3D.prototype.copy.call( this, source );
+
+	this.positionScreen.copy( source.positionScreen );
+	this.customUpdateCallback = source.customUpdateCallback;
+
+	for ( var i = 0, l = source.lensFlares.length; i < l; i ++ ) {
+
+		this.lensFlares.push( source.lensFlares[ i ] );
+
+	}
+
+	return this;
+
+};
+
+// File:src/scenes/Scene.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.Scene = function () {
+
+	THREE.Object3D.call( this );
+
+	this.type = 'Scene';
+
+	this.fog = null;
+	this.overrideMaterial = null;
+
+	this.autoUpdate = true; // checked by the renderer
+
+};
+
+THREE.Scene.prototype = Object.create( THREE.Object3D.prototype );
+THREE.Scene.prototype.constructor = THREE.Scene;
+
+THREE.Scene.prototype.copy = function ( source, recursive ) {
+
+	THREE.Object3D.prototype.copy.call( this, source, recursive );
+
+	if ( source.fog !== null ) this.fog = source.fog.clone();
+	if ( source.overrideMaterial !== null ) this.overrideMaterial = source.overrideMaterial.clone();
+
+	this.autoUpdate = source.autoUpdate;
+	this.matrixAutoUpdate = source.matrixAutoUpdate;
+
+	return this;
+
+};
+
+// File:src/scenes/Fog.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.Fog = function ( color, near, far ) {
+
+	this.name = '';
+
+	this.color = new THREE.Color( color );
+
+	this.near = ( near !== undefined ) ? near : 1;
+	this.far = ( far !== undefined ) ? far : 1000;
+
+};
+
+THREE.Fog.prototype.clone = function () {
+
+	return new THREE.Fog( this.color.getHex(), this.near, this.far );
+
+};
+
+// File:src/scenes/FogExp2.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.FogExp2 = function ( color, density ) {
+
+	this.name = '';
+
+	this.color = new THREE.Color( color );
+	this.density = ( density !== undefined ) ? density : 0.00025;
+
+};
+
+THREE.FogExp2.prototype.clone = function () {
+
+	return new THREE.FogExp2( this.color.getHex(), this.density );
+
+};
+
+// File:src/renderers/shaders/ShaderChunk.js
+
+THREE.ShaderChunk = {};
+
+// File:src/renderers/shaders/ShaderChunk/alphamap_fragment.glsl
+
+THREE.ShaderChunk[ 'alphamap_fragment' ] = "#ifdef USE_ALPHAMAP\n	diffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/alphamap_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'alphamap_pars_fragment' ] = "#ifdef USE_ALPHAMAP\n	uniform sampler2D alphaMap;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/alphatest_fragment.glsl
+
+THREE.ShaderChunk[ 'alphatest_fragment' ] = "#ifdef ALPHATEST\n	if ( diffuseColor.a < ALPHATEST ) discard;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/aomap_fragment.glsl
+
+THREE.ShaderChunk[ 'aomap_fragment' ] = "#ifdef USE_AOMAP\n	float ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n	reflectedLight.indirectDiffuse *= ambientOcclusion;\n	#if defined( USE_ENVMAP ) && defined( PHYSICAL )\n		float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n		reflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );\n	#endif\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/aomap_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'aomap_pars_fragment' ] = "#ifdef USE_AOMAP\n	uniform sampler2D aoMap;\n	uniform float aoMapIntensity;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/begin_vertex.glsl
+
+THREE.ShaderChunk[ 'begin_vertex' ] = "\nvec3 transformed = vec3( position );\n";
+
+// File:src/renderers/shaders/ShaderChunk/beginnormal_vertex.glsl
+
+THREE.ShaderChunk[ 'beginnormal_vertex' ] = "\nvec3 objectNormal = vec3( normal );\n";
+
+// File:src/renderers/shaders/ShaderChunk/bsdfs.glsl
+
+THREE.ShaderChunk[ 'bsdfs' ] = "bool testLightInRange( const in float lightDistance, const in float cutoffDistance ) {\n	return any( bvec2( cutoffDistance == 0.0, lightDistance < cutoffDistance ) );\n}\nfloat punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n		if( decayExponent > 0.0 ) {\n#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n			float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n			float maxDistanceCutoffFactor = pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n			return distanceFalloff * maxDistanceCutoffFactor;\n#else\n			return pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\n#endif\n		}\n		return 1.0;\n}\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\n	return RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\n	float fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\n	return ( 1.0 - specularColor ) * fresnel + specularColor;\n}\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\n	float a2 = pow2( alpha );\n	float gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n	float gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n	return 1.0 / ( gl * gv );\n}\nfloat G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n	float a2 = pow2( alpha );\n	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n	return 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n	float a2 = pow2( alpha );\n	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n	return RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {\n	float alpha = pow2( roughness );\n	vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n	float dotNL = saturate( dot( geometry.normal, incidentLight.direction ) );\n	float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n	float dotNH = saturate( dot( geometry.normal, halfDir ) );\n	float dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n	vec3 F = F_Schlick( specularColor, dotLH );\n	float G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n	float D = D_GGX( alpha, dotNH );\n	return F * ( G * D );\n}\nvec3 BRDF_Specular_GGX_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {\n	float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n	const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n	const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n	vec4 r = roughness * c0 + c1;\n	float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n	vec2 AB = vec2( -1.04, 1.04 ) * a004 + r.zw;\n	return specularColor * AB.x + AB.y;\n}\nfloat G_BlinnPhong_Implicit( ) {\n	return 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n	return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {\n	vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n	float dotNH = saturate( dot( geometry.normal, halfDir ) );\n	float dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n	vec3 F = F_Schlick( specularColor, dotLH );\n	float G = G_BlinnPhong_Implicit( );\n	float D = D_BlinnPhong( shininess, dotNH );\n	return F * ( G * D );\n}\nfloat GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {\n	return ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );\n}\nfloat BlinnExponentToGGXRoughness( const in float blinnExponent ) {\n	return sqrt( 2.0 / ( blinnExponent + 2.0 ) );\n}\n";
+
+// File:src/renderers/shaders/ShaderChunk/bumpmap_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'bumpmap_pars_fragment' ] = "#ifdef USE_BUMPMAP\n	uniform sampler2D bumpMap;\n	uniform float bumpScale;\n	vec2 dHdxy_fwd() {\n		vec2 dSTdx = dFdx( vUv );\n		vec2 dSTdy = dFdy( vUv );\n		float Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n		float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n		float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n		return vec2( dBx, dBy );\n	}\n	vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {\n		vec3 vSigmaX = dFdx( surf_pos );\n		vec3 vSigmaY = dFdy( surf_pos );\n		vec3 vN = surf_norm;\n		vec3 R1 = cross( vSigmaY, vN );\n		vec3 R2 = cross( vN, vSigmaX );\n		float fDet = dot( vSigmaX, R1 );\n		vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n		return normalize( abs( fDet ) * surf_norm - vGrad );\n	}\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/clipping_planes_fragment.glsl
+
+THREE.ShaderChunk[ 'clipping_planes_fragment' ] = "#if NUM_CLIPPING_PLANES > 0\n	for ( int i = 0; i < NUM_CLIPPING_PLANES; ++ i ) {\n		vec4 plane = clippingPlanes[ i ];\n		if ( dot( vViewPosition, plane.xyz ) > plane.w ) discard;\n	}\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/clipping_planes_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'clipping_planes_pars_fragment' ] = "#if NUM_CLIPPING_PLANES > 0\n	#if ! defined( PHYSICAL ) && ! defined( PHONG )\n		varying vec3 vViewPosition;\n	#endif\n	uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/clipping_planes_pars_vertex.glsl
+
+THREE.ShaderChunk[ 'clipping_planes_pars_vertex' ] = "#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\n	varying vec3 vViewPosition;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/clipping_planes_vertex.glsl
+
+THREE.ShaderChunk[ 'clipping_planes_vertex' ] = "#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\n	vViewPosition = - mvPosition.xyz;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/color_fragment.glsl
+
+THREE.ShaderChunk[ 'color_fragment' ] = "#ifdef USE_COLOR\n	diffuseColor.rgb *= vColor;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/color_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'color_pars_fragment' ] = "#ifdef USE_COLOR\n	varying vec3 vColor;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/color_pars_vertex.glsl
+
+THREE.ShaderChunk[ 'color_pars_vertex' ] = "#ifdef USE_COLOR\n	varying vec3 vColor;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/color_vertex.glsl
+
+THREE.ShaderChunk[ 'color_vertex' ] = "#ifdef USE_COLOR\n	vColor.xyz = color.xyz;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/common.glsl
+
+THREE.ShaderChunk[ 'common' ] = "#define PI 3.14159265359\n#define PI2 6.28318530718\n#define RECIPROCAL_PI 0.31830988618\n#define RECIPROCAL_PI2 0.15915494\n#define LOG2 1.442695\n#define EPSILON 1e-6\n#define saturate(a) clamp( a, 0.0, 1.0 )\n#define whiteCompliment(a) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n	const highp float a = 12.9898, b = 78.233, c = 43758.5453;\n	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n	return fract(sin(sn) * c);\n}\nstruct IncidentLight {\n	vec3 color;\n	vec3 direction;\n	bool visible;\n};\nstruct ReflectedLight {\n	vec3 directDiffuse;\n	vec3 directSpecular;\n	vec3 indirectDiffuse;\n	vec3 indirectSpecular;\n};\nstruct GeometricContext {\n	vec3 position;\n	vec3 normal;\n	vec3 viewDir;\n};\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n	float distance = dot( planeNormal, point - pointOnPlane );\n	return - distance * planeNormal + point;\n}\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n	return sign( dot( point - pointOnPlane, planeNormal ) );\n}\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\n	return lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\n}\n";
+
+// File:src/renderers/shaders/ShaderChunk/cube_uv_reflection_fragment.glsl
+
+THREE.ShaderChunk[ 'cube_uv_reflection_fragment' ] = "#ifdef ENVMAP_TYPE_CUBE_UV\nconst float cubeUV_textureSize = 1024.0;\nint getFaceFromDirection(vec3 direction) {\n	vec3 absDirection = abs(direction);\n	int face = -1;\n	if( absDirection.x > absDirection.z ) {\n		if(absDirection.x > absDirection.y )\n			face = direction.x > 0.0 ? 0 : 3;\n		else\n			face = direction.y > 0.0 ? 1 : 4;\n	}\n	else {\n		if(absDirection.z > absDirection.y )\n			face = direction.z > 0.0 ? 2 : 5;\n		else\n			face = direction.y > 0.0 ? 1 : 4;\n	}\n	return face;\n}\nfloat cubeUV_maxLods1 = log2(cubeUV_textureSize*0.25) - 1.0;\nfloat cubeUV_rangeClamp = exp2((6.0 - 1.0) * 2.0);\nvec2 MipLevelInfo( vec3 vec, float roughnessLevel, float roughness ) {\n	float scale = exp2(cubeUV_maxLods1 - roughnessLevel);\n	float dxRoughness = dFdx(roughness);\n	float dyRoughness = dFdy(roughness);\n	vec3 dx = dFdx( vec * scale * dxRoughness );\n	vec3 dy = dFdy( vec * scale * dyRoughness );\n	float d = max( dot( dx, dx ), dot( dy, dy ) );\n	d = clamp(d, 1.0, cubeUV_rangeClamp);\n	float mipLevel = 0.5 * log2(d);\n	return vec2(floor(mipLevel), fract(mipLevel));\n}\nfloat cubeUV_maxLods2 = log2(cubeUV_textureSize*0.25) - 2.0;\nconst float cubeUV_rcpTextureSize = 1.0 / cubeUV_textureSize;\nvec2 getCubeUV(vec3 direction, float roughnessLevel, float mipLevel) {\n	mipLevel = roughnessLevel > cubeUV_maxLods2 - 3.0 ? 0.0 : mipLevel;\n	float a = 16.0 * cubeUV_rcpTextureSize;\n	vec2 exp2_packed = exp2( vec2( roughnessLevel, mipLevel ) );\n	vec2 rcp_exp2_packed = vec2( 1.0 ) / exp2_packed;\n	float powScale = exp2_packed.x * exp2_packed.y;\n	float scale = rcp_exp2_packed.x * rcp_exp2_packed.y * 0.25;\n	float mipOffset = 0.75*(1.0 - rcp_exp2_packed.y) * rcp_exp2_packed.x;\n	bool bRes = mipLevel == 0.0;\n	scale =  bRes && (scale < a) ? a : scale;\n	vec3 r;\n	vec2 offset;\n	int face = getFaceFromDirection(direction);\n	float rcpPowScale = 1.0 / powScale;\n	if( face == 0) {\n		r = vec3(direction.x, -direction.z, direction.y);\n		offset = vec2(0.0+mipOffset,0.75 * rcpPowScale);\n		offset.y = bRes && (offset.y < 2.0*a) ?  a : offset.y;\n	}\n	else if( face == 1) {\n		r = vec3(direction.y, direction.x, direction.z);\n		offset = vec2(scale+mipOffset, 0.75 * rcpPowScale);\n		offset.y = bRes && (offset.y < 2.0*a) ?  a : offset.y;\n	}\n	else if( face == 2) {\n		r = vec3(direction.z, direction.x, direction.y);\n		offset = vec2(2.0*scale+mipOffset, 0.75 * rcpPowScale);\n		offset.y = bRes && (offset.y < 2.0*a) ?  a : offset.y;\n	}\n	else if( face == 3) {\n		r = vec3(direction.x, direction.z, direction.y);\n		offset = vec2(0.0+mipOffset,0.5 * rcpPowScale);\n		offset.y = bRes && (offset.y < 2.0*a) ?  0.0 : offset.y;\n	}\n	else if( face == 4) {\n		r = vec3(direction.y, direction.x, -direction.z);\n		offset = vec2(scale+mipOffset, 0.5 * rcpPowScale);\n		offset.y = bRes && (offset.y < 2.0*a) ?  0.0 : offset.y;\n	}\n	else {\n		r = vec3(direction.z, -direction.x, direction.y);\n		offset = vec2(2.0*scale+mipOffset, 0.5 * rcpPowScale);\n		offset.y = bRes && (offset.y < 2.0*a) ?  0.0 : offset.y;\n	}\n	r = normalize(r);\n	float texelOffset = 0.5 * cubeUV_rcpTextureSize;\n	vec2 s = ( r.yz / abs( r.x ) + vec2( 1.0 ) ) * 0.5;\n	vec2 base = offset + vec2( texelOffset );\n	return base + s * ( scale - 2.0 * texelOffset );\n}\nfloat cubeUV_maxLods3 = log2(cubeUV_textureSize*0.25) - 3.0;\nvec4 textureCubeUV(vec3 reflectedDirection, float roughness ) {\n	float roughnessVal = roughness* cubeUV_maxLods3;\n	float r1 = floor(roughnessVal);\n	float r2 = r1 + 1.0;\n	float t = fract(roughnessVal);\n	vec2 mipInfo = MipLevelInfo(reflectedDirection, r1, roughness);\n	float s = mipInfo.y;\n	float level0 = mipInfo.x;\n	float level1 = level0 + 1.0;\n	level1 = level1 > 5.0 ? 5.0 : level1;\n	level0 += min( floor( s + 0.5 ), 5.0 );\n	vec2 uv_10 = getCubeUV(reflectedDirection, r1, level0);\n	vec4 color10 = envMapTexelToLinear(texture2D(envMap, uv_10));\n	vec2 uv_20 = getCubeUV(reflectedDirection, r2, level0);\n	vec4 color20 = envMapTexelToLinear(texture2D(envMap, uv_20));\n	vec4 result = mix(color10, color20, t);\n	return vec4(result.rgb, 1.0);\n}\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/defaultnormal_vertex.glsl
+
+THREE.ShaderChunk[ 'defaultnormal_vertex' ] = "#ifdef FLIP_SIDED\n	objectNormal = -objectNormal;\n#endif\nvec3 transformedNormal = normalMatrix * objectNormal;\n";
+
+// File:src/renderers/shaders/ShaderChunk/displacementmap_vertex.glsl
+
+THREE.ShaderChunk[ 'displacementmap_vertex' ] = "#ifdef USE_DISPLACEMENTMAP\n	transformed += normal * ( texture2D( displacementMap, uv ).x * displacementScale + displacementBias );\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/displacementmap_pars_vertex.glsl
+
+THREE.ShaderChunk[ 'displacementmap_pars_vertex' ] = "#ifdef USE_DISPLACEMENTMAP\n	uniform sampler2D displacementMap;\n	uniform float displacementScale;\n	uniform float displacementBias;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl
+
+THREE.ShaderChunk[ 'emissivemap_fragment' ] = "#ifdef USE_EMISSIVEMAP\n	vec4 emissiveColor = texture2D( emissiveMap, vUv );\n	emissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;\n	totalEmissiveRadiance *= emissiveColor.rgb;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'emissivemap_pars_fragment' ] = "#ifdef USE_EMISSIVEMAP\n	uniform sampler2D emissiveMap;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/encodings_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'encodings_pars_fragment' ] = "\nvec4 LinearToLinear( in vec4 value ) {\n  return value;\n}\nvec4 GammaToLinear( in vec4 value, in float gammaFactor ) {\n  return vec4( pow( value.xyz, vec3( gammaFactor ) ), value.w );\n}\nvec4 LinearToGamma( in vec4 value, in float gammaFactor ) {\n  return vec4( pow( value.xyz, vec3( 1.0 / gammaFactor ) ), value.w );\n}\nvec4 sRGBToLinear( in vec4 value ) {\n  return vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.w );\n}\nvec4 LinearTosRGB( in vec4 value ) {\n  return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.w );\n}\nvec4 RGBEToLinear( in vec4 value ) {\n  return vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );\n}\nvec4 LinearToRGBE( in vec4 value ) {\n  float maxComponent = max( max( value.r, value.g ), value.b );\n  float fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );\n  return vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );\n}\nvec4 RGBMToLinear( in vec4 value, in float maxRange ) {\n  return vec4( value.xyz * value.w * maxRange, 1.0 );\n}\nvec4 LinearToRGBM( in vec4 value, in float maxRange ) {\n  float maxRGB = max( value.x, max( value.g, value.b ) );\n  float M      = clamp( maxRGB / maxRange, 0.0, 1.0 );\n  M            = ceil( M * 255.0 ) / 255.0;\n  return vec4( value.rgb / ( M * maxRange ), M );\n}\nvec4 RGBDToLinear( in vec4 value, in float maxRange ) {\n    return vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );\n}\nvec4 LinearToRGBD( in vec4 value, in float maxRange ) {\n    float maxRGB = max( value.x, max( value.g, value.b ) );\n    float D      = max( maxRange / maxRGB, 1.0 );\n    D            = min( floor( D ) / 255.0, 1.0 );\n    return vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );\n}\nconst mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );\nvec4 LinearToLogLuv( in vec4 value )  {\n  vec3 Xp_Y_XYZp = value.rgb * cLogLuvM;\n  Xp_Y_XYZp = max(Xp_Y_XYZp, vec3(1e-6, 1e-6, 1e-6));\n  vec4 vResult;\n  vResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;\n  float Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;\n  vResult.w = fract(Le);\n  vResult.z = (Le - (floor(vResult.w*255.0))/255.0)/255.0;\n  return vResult;\n}\nconst mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );\nvec4 LogLuvToLinear( in vec4 value ) {\n  float Le = value.z * 255.0 + value.w;\n  vec3 Xp_Y_XYZp;\n  Xp_Y_XYZp.y = exp2((Le - 127.0) / 2.0);\n  Xp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;\n  Xp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;\n  vec3 vRGB = Xp_Y_XYZp.rgb * cLogLuvInverseM;\n  return vec4( max(vRGB, 0.0), 1.0 );\n}\n";
+
+// File:src/renderers/shaders/ShaderChunk/encodings_fragment.glsl
+
+THREE.ShaderChunk[ 'encodings_fragment' ] = "  gl_FragColor = linearToOutputTexel( gl_FragColor );\n";
+
+// File:src/renderers/shaders/ShaderChunk/envmap_fragment.glsl
+
+THREE.ShaderChunk[ 'envmap_fragment' ] = "#ifdef USE_ENVMAP\n	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n		vec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );\n		vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n		#ifdef ENVMAP_MODE_REFLECTION\n			vec3 reflectVec = reflect( cameraToVertex, worldNormal );\n		#else\n			vec3 reflectVec = refract( cameraToVertex, worldNormal, refractionRatio );\n		#endif\n	#else\n		vec3 reflectVec = vReflect;\n	#endif\n	#ifdef DOUBLE_SIDED\n		float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n	#else\n		float flipNormal = 1.0;\n	#endif\n	#ifdef ENVMAP_TYPE_CUBE\n		vec4 envColor = textureCube( envMap, flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n	#elif defined( ENVMAP_TYPE_EQUIREC )\n		vec2 sampleUV;\n		sampleUV.y = saturate( flipNormal * reflectVec.y * 0.5 + 0.5 );\n		sampleUV.x = atan( flipNormal * reflectVec.z, flipNormal * reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n		vec4 envColor = texture2D( envMap, sampleUV );\n	#elif defined( ENVMAP_TYPE_SPHERE )\n		vec3 reflectView = flipNormal * normalize((viewMatrix * vec4( reflectVec, 0.0 )).xyz + vec3(0.0,0.0,1.0));\n		vec4 envColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5 );\n	#endif\n	envColor = envMapTexelToLinear( envColor );\n	#ifdef ENVMAP_BLENDING_MULTIPLY\n		outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n	#elif defined( ENVMAP_BLENDING_MIX )\n		outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n	#elif defined( ENVMAP_BLENDING_ADD )\n		outgoingLight += envColor.xyz * specularStrength * reflectivity;\n	#endif\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'envmap_pars_fragment' ] = "#if defined( USE_ENVMAP ) || defined( PHYSICAL )\n	uniform float reflectivity;\n	uniform float envMapIntenstiy;\n#endif\n#ifdef USE_ENVMAP\n	#if ! defined( PHYSICAL ) && ( defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) )\n		varying vec3 vWorldPosition;\n	#endif\n	#ifdef ENVMAP_TYPE_CUBE\n		uniform samplerCube envMap;\n	#else\n		uniform sampler2D envMap;\n	#endif\n	uniform float flipEnvMap;\n	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( PHYSICAL )\n		uniform float refractionRatio;\n	#else\n		varying vec3 vReflect;\n	#endif\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/envmap_pars_vertex.glsl
+
+THREE.ShaderChunk[ 'envmap_pars_vertex' ] = "#ifdef USE_ENVMAP\n	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n		varying vec3 vWorldPosition;\n	#else\n		varying vec3 vReflect;\n		uniform float refractionRatio;\n	#endif\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/envmap_vertex.glsl
+
+THREE.ShaderChunk[ 'envmap_vertex' ] = "#ifdef USE_ENVMAP\n	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n		vWorldPosition = worldPosition.xyz;\n	#else\n		vec3 cameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n		vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n		#ifdef ENVMAP_MODE_REFLECTION\n			vReflect = reflect( cameraToVertex, worldNormal );\n		#else\n			vReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n		#endif\n	#endif\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/fog_fragment.glsl
+
+THREE.ShaderChunk[ 'fog_fragment' ] = "#ifdef USE_FOG\n	#ifdef USE_LOGDEPTHBUF_EXT\n		float depth = gl_FragDepthEXT / gl_FragCoord.w;\n	#else\n		float depth = gl_FragCoord.z / gl_FragCoord.w;\n	#endif\n	#ifdef FOG_EXP2\n		float fogFactor = whiteCompliment( exp2( - fogDensity * fogDensity * depth * depth * LOG2 ) );\n	#else\n		float fogFactor = smoothstep( fogNear, fogFar, depth );\n	#endif\n	gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/fog_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'fog_pars_fragment' ] = "#ifdef USE_FOG\n	uniform vec3 fogColor;\n	#ifdef FOG_EXP2\n		uniform float fogDensity;\n	#else\n		uniform float fogNear;\n		uniform float fogFar;\n	#endif\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/lightmap_fragment.glsl
+
+THREE.ShaderChunk[ 'lightmap_fragment' ] = "#ifdef USE_LIGHTMAP\n	reflectedLight.indirectDiffuse += PI * texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/lightmap_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'lightmap_pars_fragment' ] = "#ifdef USE_LIGHTMAP\n	uniform sampler2D lightMap;\n	uniform float lightMapIntensity;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/lights_lambert_vertex.glsl
+
+THREE.ShaderChunk[ 'lights_lambert_vertex' ] = "vec3 diffuse = vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position = mvPosition.xyz;\ngeometry.normal = normalize( transformedNormal );\ngeometry.viewDir = normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position = geometry.position;\nbackGeometry.normal = -geometry.normal;\nbackGeometry.viewDir = geometry.viewDir;\nvLightFront = vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n	vLightBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\n#if NUM_POINT_LIGHTS > 0\n	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n		getPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );\n		dotNL = dot( geometry.normal, directLight.direction );\n		directLightColor_Diffuse = PI * directLight.color;\n		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n		#ifdef DOUBLE_SIDED\n			vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n		#endif\n	}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n		getSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );\n		dotNL = dot( geometry.normal, directLight.direction );\n		directLightColor_Diffuse = PI * directLight.color;\n		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n		#ifdef DOUBLE_SIDED\n			vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n		#endif\n	}\n#endif\n#if NUM_DIR_LIGHTS > 0\n	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n		getDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );\n		dotNL = dot( geometry.normal, directLight.direction );\n		directLightColor_Diffuse = PI * directLight.color;\n		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n		#ifdef DOUBLE_SIDED\n			vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n		#endif\n	}\n#endif\n#if NUM_HEMI_LIGHTS > 0\n	for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n		vLightFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n		#ifdef DOUBLE_SIDED\n			vLightBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\n		#endif\n	}\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/lights_pars.glsl
+
+THREE.ShaderChunk[ 'lights_pars' ] = "uniform vec3 ambientLightColor;\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n	vec3 irradiance = ambientLightColor;\n	#ifndef PHYSICALLY_CORRECT_LIGHTS\n		irradiance *= PI;\n	#endif\n	return irradiance;\n}\n#if NUM_DIR_LIGHTS > 0\n	struct DirectionalLight {\n		vec3 direction;\n		vec3 color;\n		int shadow;\n		float shadowBias;\n		float shadowRadius;\n		vec2 shadowMapSize;\n	};\n	uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n	void getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n		directLight.color = directionalLight.color;\n		directLight.direction = directionalLight.direction;\n		directLight.visible = true;\n	}\n#endif\n#if NUM_POINT_LIGHTS > 0\n	struct PointLight {\n		vec3 position;\n		vec3 color;\n		float distance;\n		float decay;\n		int shadow;\n		float shadowBias;\n		float shadowRadius;\n		vec2 shadowMapSize;\n	};\n	uniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n	void getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n		vec3 lVector = pointLight.position - geometry.position;\n		directLight.direction = normalize( lVector );\n		float lightDistance = length( lVector );\n		if ( testLightInRange( lightDistance, pointLight.distance ) ) {\n			directLight.color = pointLight.color;\n			directLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );\n			directLight.visible = true;\n		} else {\n			directLight.color = vec3( 0.0 );\n			directLight.visible = false;\n		}\n	}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n	struct SpotLight {\n		vec3 position;\n		vec3 direction;\n		vec3 color;\n		float distance;\n		float decay;\n		float coneCos;\n		float penumbraCos;\n		int shadow;\n		float shadowBias;\n		float shadowRadius;\n		vec2 shadowMapSize;\n	};\n	uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n	void getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight  ) {\n		vec3 lVector = spotLight.position - geometry.position;\n		directLight.direction = normalize( lVector );\n		float lightDistance = length( lVector );\n		float angleCos = dot( directLight.direction, spotLight.direction );\n		if ( all( bvec2( angleCos > spotLight.coneCos, testLightInRange( lightDistance, spotLight.distance ) ) ) ) {\n			float spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n			directLight.color = spotLight.color;\n			directLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );\n			directLight.visible = true;\n		} else {\n			directLight.color = vec3( 0.0 );\n			directLight.visible = false;\n		}\n	}\n#endif\n#if NUM_HEMI_LIGHTS > 0\n	struct HemisphereLight {\n		vec3 direction;\n		vec3 skyColor;\n		vec3 groundColor;\n	};\n	uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n	vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {\n		float dotNL = dot( geometry.normal, hemiLight.direction );\n		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n		vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n		#ifndef PHYSICALLY_CORRECT_LIGHTS\n			irradiance *= PI;\n		#endif\n		return irradiance;\n	}\n#endif\n#if defined( USE_ENVMAP ) && defined( PHYSICAL )\n	vec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\n		#ifdef DOUBLE_SIDED\n			float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n		#else\n			float flipNormal = 1.0;\n		#endif\n		vec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n		#ifdef ENVMAP_TYPE_CUBE\n			vec3 queryVec = flipNormal * vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n			#ifdef TEXTURE_LOD_EXT\n				vec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );\n			#else\n				vec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );\n			#endif\n			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n		#elif defined( ENVMAP_TYPE_CUBE_UV )\n			vec3 queryVec = flipNormal * vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n			vec4 envMapColor = textureCubeUV( queryVec, 1.0 );\n		#else\n			vec4 envMapColor = vec4( 0.0 );\n		#endif\n		return PI * envMapColor.rgb * envMapIntensity;\n	}\n	float getSpecularMIPLevel( const in float blinnShininessExponent, const in int maxMIPLevel ) {\n		float maxMIPLevelScalar = float( maxMIPLevel );\n		float desiredMIPLevel = maxMIPLevelScalar - 0.79248 - 0.5 * log2( pow2( blinnShininessExponent ) + 1.0 );\n		return clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\n	}\n	vec3 getLightProbeIndirectRadiance( const in GeometricContext geometry, const in float blinnShininessExponent, const in int maxMIPLevel ) {\n		#ifdef ENVMAP_MODE_REFLECTION\n			vec3 reflectVec = reflect( -geometry.viewDir, geometry.normal );\n		#else\n			vec3 reflectVec = refract( -geometry.viewDir, geometry.normal, refractionRatio );\n		#endif\n		#ifdef DOUBLE_SIDED\n			float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n		#else\n			float flipNormal = 1.0;\n		#endif\n		reflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n		float specularMIPLevel = getSpecularMIPLevel( blinnShininessExponent, maxMIPLevel );\n		#ifdef ENVMAP_TYPE_CUBE\n			vec3 queryReflectVec = flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n			#ifdef TEXTURE_LOD_EXT\n				vec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );\n			#else\n				vec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );\n			#endif\n			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n		#elif defined( ENVMAP_TYPE_CUBE_UV )\n			vec3 queryReflectVec = flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n			vec4 envMapColor = textureCubeUV(queryReflectVec, BlinnExponentToGGXRoughness(blinnShininessExponent));\n		#elif defined( ENVMAP_TYPE_EQUIREC )\n			vec2 sampleUV;\n			sampleUV.y = saturate( flipNormal * reflectVec.y * 0.5 + 0.5 );\n			sampleUV.x = atan( flipNormal * reflectVec.z, flipNormal * reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n			#ifdef TEXTURE_LOD_EXT\n				vec4 envMapColor = texture2DLodEXT( envMap, sampleUV, specularMIPLevel );\n			#else\n				vec4 envMapColor = texture2D( envMap, sampleUV, specularMIPLevel );\n			#endif\n			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n		#elif defined( ENVMAP_TYPE_SPHERE )\n			vec3 reflectView = flipNormal * normalize((viewMatrix * vec4( reflectVec, 0.0 )).xyz + vec3(0.0,0.0,1.0));\n			#ifdef TEXTURE_LOD_EXT\n				vec4 envMapColor = texture2DLodEXT( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n			#else\n				vec4 envMapColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n			#endif\n			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n		#endif\n		return envMapColor.rgb * envMapIntensity;\n	}\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/lights_phong_fragment.glsl
+
+THREE.ShaderChunk[ 'lights_phong_fragment' ] = "BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;\n";
+
+// File:src/renderers/shaders/ShaderChunk/lights_phong_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'lights_phong_pars_fragment' ] = "varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n	varying vec3 vNormal;\n#endif\nstruct BlinnPhongMaterial {\n	vec3	diffuseColor;\n	vec3	specularColor;\n	float	specularShininess;\n	float	specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n	vec3 irradiance = dotNL * directLight.color;\n	#ifndef PHYSICALLY_CORRECT_LIGHTS\n		irradiance *= PI;\n	#endif\n	reflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n	reflectedLight.directSpecular += irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n	reflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct				RE_Direct_BlinnPhong\n#define RE_IndirectDiffuse		RE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material )	(0)\n";
+
+// File:src/renderers/shaders/ShaderChunk/lights_physical_fragment.glsl
+
+THREE.ShaderChunk[ 'lights_physical_fragment' ] = "PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nmaterial.specularRoughness = clamp( roughnessFactor, 0.04, 1.0 );\n#ifdef STANDARD\n	material.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );\n#else\n	material.specularColor = mix( vec3( 0.16 * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'lights_physical_pars_fragment' ] = "struct PhysicalMaterial {\n	vec3	diffuseColor;\n	float	specularRoughness;\n	vec3	specularColor;\n	#ifndef STANDARD\n	#endif\n};\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n	vec3 irradiance = dotNL * directLight.color;\n	#ifndef PHYSICALLY_CORRECT_LIGHTS\n		irradiance *= PI;\n	#endif\n	reflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n	reflectedLight.directSpecular += irradiance * BRDF_Specular_GGX( directLight, geometry, material.specularColor, material.specularRoughness );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n	reflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n	reflectedLight.indirectSpecular += radiance * BRDF_Specular_GGX_Environment( geometry, material.specularColor, material.specularRoughness );\n}\n#define RE_Direct				RE_Direct_Physical\n#define RE_IndirectDiffuse		RE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular		RE_IndirectSpecular_Physical\n#define Material_BlinnShininessExponent( material )   GGXRoughnessToBlinnExponent( material.specularRoughness )\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n	return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}\n";
+
+// File:src/renderers/shaders/ShaderChunk/lights_template.glsl
+
+THREE.ShaderChunk[ 'lights_template' ] = "\nGeometricContext geometry;\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = normalize( vViewPosition );\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n	PointLight pointLight;\n	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n		pointLight = pointLights[ i ];\n		getPointDirectLightIrradiance( pointLight, geometry, directLight );\n		#ifdef USE_SHADOWMAP\n		directLight.color *= all( bvec2( pointLight.shadow, directLight.visible ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ] ) : 1.0;\n		#endif\n		RE_Direct( directLight, geometry, material, reflectedLight );\n	}\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n	SpotLight spotLight;\n	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n		spotLight = spotLights[ i ];\n		getSpotDirectLightIrradiance( spotLight, geometry, directLight );\n		#ifdef USE_SHADOWMAP\n		directLight.color *= all( bvec2( spotLight.shadow, directLight.visible ) ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n		#endif\n		RE_Direct( directLight, geometry, material, reflectedLight );\n	}\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n	DirectionalLight directionalLight;\n	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n		directionalLight = directionalLights[ i ];\n		getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n		#ifdef USE_SHADOWMAP\n		directLight.color *= all( bvec2( directionalLight.shadow, directLight.visible ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n		#endif\n		RE_Direct( directLight, geometry, material, reflectedLight );\n	}\n#endif\n#if defined( RE_IndirectDiffuse )\n	vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n	#ifdef USE_LIGHTMAP\n		vec3 lightMapIrradiance = texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n		#ifndef PHYSICALLY_CORRECT_LIGHTS\n			lightMapIrradiance *= PI;\n		#endif\n		irradiance += lightMapIrradiance;\n	#endif\n	#if ( NUM_HEMI_LIGHTS > 0 )\n		for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n			irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n		}\n	#endif\n	#if defined( USE_ENVMAP ) && defined( PHYSICAL ) && defined( ENVMAP_TYPE_CUBE_UV )\n	 	irradiance += getLightProbeIndirectIrradiance( geometry, 8 );\n	#endif\n	RE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n	vec3 radiance = getLightProbeIndirectRadiance( geometry, Material_BlinnShininessExponent( material ), 8 );\n	RE_IndirectSpecular( radiance, geometry, material, reflectedLight );\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/logdepthbuf_fragment.glsl
+
+THREE.ShaderChunk[ 'logdepthbuf_fragment' ] = "#if defined(USE_LOGDEPTHBUF) && defined(USE_LOGDEPTHBUF_EXT)\n	gl_FragDepthEXT = log2(vFragDepth) * logDepthBufFC * 0.5;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/logdepthbuf_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'logdepthbuf_pars_fragment' ] = "#ifdef USE_LOGDEPTHBUF\n	uniform float logDepthBufFC;\n	#ifdef USE_LOGDEPTHBUF_EXT\n		varying float vFragDepth;\n	#endif\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/logdepthbuf_pars_vertex.glsl
+
+THREE.ShaderChunk[ 'logdepthbuf_pars_vertex' ] = "#ifdef USE_LOGDEPTHBUF\n	#ifdef USE_LOGDEPTHBUF_EXT\n		varying float vFragDepth;\n	#endif\n	uniform float logDepthBufFC;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/logdepthbuf_vertex.glsl
+
+THREE.ShaderChunk[ 'logdepthbuf_vertex' ] = "#ifdef USE_LOGDEPTHBUF\n	gl_Position.z = log2(max( EPSILON, gl_Position.w + 1.0 )) * logDepthBufFC;\n	#ifdef USE_LOGDEPTHBUF_EXT\n		vFragDepth = 1.0 + gl_Position.w;\n	#else\n		gl_Position.z = (gl_Position.z - 1.0) * gl_Position.w;\n	#endif\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/map_fragment.glsl
+
+THREE.ShaderChunk[ 'map_fragment' ] = "#ifdef USE_MAP\n	vec4 texelColor = texture2D( map, vUv );\n	texelColor = mapTexelToLinear( texelColor );\n	diffuseColor *= texelColor;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'map_pars_fragment' ] = "#ifdef USE_MAP\n	uniform sampler2D map;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/map_particle_fragment.glsl
+
+THREE.ShaderChunk[ 'map_particle_fragment' ] = "#ifdef USE_MAP\n	vec4 mapTexel = texture2D( map, vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y ) * offsetRepeat.zw + offsetRepeat.xy );\n	diffuseColor *= mapTexelToLinear( mapTexel );\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/map_particle_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'map_particle_pars_fragment' ] = "#ifdef USE_MAP\n	uniform vec4 offsetRepeat;\n	uniform sampler2D map;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/metalnessmap_fragment.glsl
+
+THREE.ShaderChunk[ 'metalnessmap_fragment' ] = "float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n	vec4 texelMetalness = texture2D( metalnessMap, vUv );\n	metalnessFactor *= texelMetalness.r;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/metalnessmap_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'metalnessmap_pars_fragment' ] = "#ifdef USE_METALNESSMAP\n	uniform sampler2D metalnessMap;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/morphnormal_vertex.glsl
+
+THREE.ShaderChunk[ 'morphnormal_vertex' ] = "#ifdef USE_MORPHNORMALS\n	objectNormal += ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];\n	objectNormal += ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];\n	objectNormal += ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];\n	objectNormal += ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/morphtarget_pars_vertex.glsl
+
+THREE.ShaderChunk[ 'morphtarget_pars_vertex' ] = "#ifdef USE_MORPHTARGETS\n	#ifndef USE_MORPHNORMALS\n	uniform float morphTargetInfluences[ 8 ];\n	#else\n	uniform float morphTargetInfluences[ 4 ];\n	#endif\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/morphtarget_vertex.glsl
+
+THREE.ShaderChunk[ 'morphtarget_vertex' ] = "#ifdef USE_MORPHTARGETS\n	transformed += ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];\n	transformed += ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];\n	transformed += ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];\n	transformed += ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];\n	#ifndef USE_MORPHNORMALS\n	transformed += ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];\n	transformed += ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];\n	transformed += ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];\n	transformed += ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];\n	#endif\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/normal_fragment.glsl
+
+THREE.ShaderChunk[ 'normal_fragment' ] = "#ifdef FLAT_SHADED\n	vec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n	vec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n	vec3 normal = normalize( cross( fdx, fdy ) );\n#else\n	vec3 normal = normalize( vNormal );\n	#ifdef DOUBLE_SIDED\n		normal = normal * ( -1.0 + 2.0 * float( gl_FrontFacing ) );\n	#endif\n#endif\n#ifdef USE_NORMALMAP\n	normal = perturbNormal2Arb( -vViewPosition, normal );\n#elif defined( USE_BUMPMAP )\n	normal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/normalmap_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'normalmap_pars_fragment' ] = "#ifdef USE_NORMALMAP\n	uniform sampler2D normalMap;\n	uniform vec2 normalScale;\n	vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm ) {\n		vec3 q0 = dFdx( eye_pos.xyz );\n		vec3 q1 = dFdy( eye_pos.xyz );\n		vec2 st0 = dFdx( vUv.st );\n		vec2 st1 = dFdy( vUv.st );\n		vec3 S = normalize( q0 * st1.t - q1 * st0.t );\n		vec3 T = normalize( -q0 * st1.s + q1 * st0.s );\n		vec3 N = normalize( surf_norm );\n		vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n		mapN.xy = normalScale * mapN.xy;\n		mat3 tsn = mat3( S, T, N );\n		return normalize( tsn * mapN );\n	}\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/packing.glsl
+
+THREE.ShaderChunk[ 'packing' ] = "vec3 packNormalToRGB( const in vec3 normal ) {\n  return normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n  return 1.0 - 2.0 * rgb.xyz;\n}\nvec4 packDepthToRGBA( const in float value ) {\n	const vec4 bit_shift = vec4( 256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0 );\n	const vec4 bit_mask = vec4( 0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0 );\n	vec4 res = mod( value * bit_shift * vec4( 255 ), vec4( 256 ) ) / vec4( 255 );\n	res -= res.xxyz * bit_mask;\n	return res;\n}\nfloat unpackRGBAToDepth( const in vec4 rgba ) {\n	const vec4 bitSh = vec4( 1.0 / ( 256.0 * 256.0 * 256.0 ), 1.0 / ( 256.0 * 256.0 ), 1.0 / 256.0, 1.0 );\n	return dot( rgba, bitSh );\n}\nfloat viewZToOrthoDepth( const in float viewZ, const in float near, const in float far ) {\n  return ( viewZ + near ) / ( near - far );\n}\nfloat OrthoDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\n  return linearClipZ * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n  return (( near + viewZ ) * far ) / (( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\n  return ( near * far ) / ( ( far - near ) * invClipZ - far );\n}\n";
+
+// File:src/renderers/shaders/ShaderChunk/premultiplied_alpha_fragment.glsl
+
+THREE.ShaderChunk[ 'premultiplied_alpha_fragment' ] = "#ifdef PREMULTIPLIED_ALPHA\n	gl_FragColor.rgb *= gl_FragColor.a;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/project_vertex.glsl
+
+THREE.ShaderChunk[ 'project_vertex' ] = "#ifdef USE_SKINNING\n	vec4 mvPosition = modelViewMatrix * skinned;\n#else\n	vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );\n#endif\ngl_Position = projectionMatrix * mvPosition;\n";
+
+// File:src/renderers/shaders/ShaderChunk/roughnessmap_fragment.glsl
+
+THREE.ShaderChunk[ 'roughnessmap_fragment' ] = "float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n	vec4 texelRoughness = texture2D( roughnessMap, vUv );\n	roughnessFactor *= texelRoughness.r;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/roughnessmap_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'roughnessmap_pars_fragment' ] = "#ifdef USE_ROUGHNESSMAP\n	uniform sampler2D roughnessMap;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/shadowmap_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'shadowmap_pars_fragment' ] = "#ifdef USE_SHADOWMAP\n	#if NUM_DIR_LIGHTS > 0\n		uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHTS ];\n		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\n	#endif\n	#if NUM_SPOT_LIGHTS > 0\n		uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHTS ];\n		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\n	#endif\n	#if NUM_POINT_LIGHTS > 0\n		uniform sampler2D pointShadowMap[ NUM_POINT_LIGHTS ];\n		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\n	#endif\n	float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n		return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n	}\n	float texture2DShadowLerp( sampler2D depths, vec2 size, vec2 uv, float compare ) {\n		const vec2 offset = vec2( 0.0, 1.0 );\n		vec2 texelSize = vec2( 1.0 ) / size;\n		vec2 centroidUV = floor( uv * size + 0.5 ) / size;\n		float lb = texture2DCompare( depths, centroidUV + texelSize * offset.xx, compare );\n		float lt = texture2DCompare( depths, centroidUV + texelSize * offset.xy, compare );\n		float rb = texture2DCompare( depths, centroidUV + texelSize * offset.yx, compare );\n		float rt = texture2DCompare( depths, centroidUV + texelSize * offset.yy, compare );\n		vec2 f = fract( uv * size + 0.5 );\n		float a = mix( lb, lt, f.y );\n		float b = mix( rb, rt, f.y );\n		float c = mix( a, b, f.x );\n		return c;\n	}\n	float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n		shadowCoord.xyz /= shadowCoord.w;\n		shadowCoord.z += shadowBias;\n		bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n		bool inFrustum = all( inFrustumVec );\n		bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n		bool frustumTest = all( frustumTestVec );\n		if ( frustumTest ) {\n		#if defined( SHADOWMAP_TYPE_PCF )\n			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n			float dx0 = - texelSize.x * shadowRadius;\n			float dy0 = - texelSize.y * shadowRadius;\n			float dx1 = + texelSize.x * shadowRadius;\n			float dy1 = + texelSize.y * shadowRadius;\n			return (\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n			) * ( 1.0 / 9.0 );\n		#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n			float dx0 = - texelSize.x * shadowRadius;\n			float dy0 = - texelSize.y * shadowRadius;\n			float dx1 = + texelSize.x * shadowRadius;\n			float dy1 = + texelSize.y * shadowRadius;\n			return (\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy, shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n			) * ( 1.0 / 9.0 );\n		#else\n			return texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n		#endif\n		}\n		return 1.0;\n	}\n	vec2 cubeToUV( vec3 v, float texelSizeY ) {\n		vec3 absV = abs( v );\n		float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n		absV *= scaleToCube;\n		v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n		vec2 planar = v.xy;\n		float almostATexel = 1.5 * texelSizeY;\n		float almostOne = 1.0 - almostATexel;\n		if ( absV.z >= almostOne ) {\n			if ( v.z > 0.0 )\n				planar.x = 4.0 - v.x;\n		} else if ( absV.x >= almostOne ) {\n			float signX = sign( v.x );\n			planar.x = v.z * signX + 2.0 * signX;\n		} else if ( absV.y >= almostOne ) {\n			float signY = sign( v.y );\n			planar.x = v.x + 2.0 * signY + 2.0;\n			planar.y = v.z * signY - 2.0;\n		}\n		return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n	}\n	float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n		vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n		vec3 lightToPosition = shadowCoord.xyz;\n		vec3 bd3D = normalize( lightToPosition );\n		float dp = ( length( lightToPosition ) - shadowBias ) / 1000.0;\n		#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT )\n			vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n			return (\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n			) * ( 1.0 / 9.0 );\n		#else\n			return texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n		#endif\n	}\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/shadowmap_pars_vertex.glsl
+
+THREE.ShaderChunk[ 'shadowmap_pars_vertex' ] = "#ifdef USE_SHADOWMAP\n	#if NUM_DIR_LIGHTS > 0\n		uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHTS ];\n		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\n	#endif\n	#if NUM_SPOT_LIGHTS > 0\n		uniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHTS ];\n		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\n	#endif\n	#if NUM_POINT_LIGHTS > 0\n		uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHTS ];\n		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\n	#endif\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/shadowmap_vertex.glsl
+
+THREE.ShaderChunk[ 'shadowmap_vertex' ] = "#ifdef USE_SHADOWMAP\n	#if NUM_DIR_LIGHTS > 0\n	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n		vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * worldPosition;\n	}\n	#endif\n	#if NUM_SPOT_LIGHTS > 0\n	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n		vSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * worldPosition;\n	}\n	#endif\n	#if NUM_POINT_LIGHTS > 0\n	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n		vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * worldPosition;\n	}\n	#endif\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/shadowmask_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'shadowmask_pars_fragment' ] = "float getShadowMask() {\n	float shadow = 1.0;\n	#ifdef USE_SHADOWMAP\n	#if NUM_DIR_LIGHTS > 0\n	DirectionalLight directionalLight;\n	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n		directionalLight = directionalLights[ i ];\n		shadow *= bool( directionalLight.shadow ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n	}\n	#endif\n	#if NUM_SPOT_LIGHTS > 0\n	SpotLight spotLight;\n	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n		spotLight = spotLights[ i ];\n		shadow *= bool( spotLight.shadow ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n	}\n	#endif\n	#if NUM_POINT_LIGHTS > 0\n	PointLight pointLight;\n	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n		pointLight = pointLights[ i ];\n		shadow *= bool( pointLight.shadow ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ] ) : 1.0;\n	}\n	#endif\n	#endif\n	return shadow;\n}\n";
+
+// File:src/renderers/shaders/ShaderChunk/skinbase_vertex.glsl
+
+THREE.ShaderChunk[ 'skinbase_vertex' ] = "#ifdef USE_SKINNING\n	mat4 boneMatX = getBoneMatrix( skinIndex.x );\n	mat4 boneMatY = getBoneMatrix( skinIndex.y );\n	mat4 boneMatZ = getBoneMatrix( skinIndex.z );\n	mat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/skinning_pars_vertex.glsl
+
+THREE.ShaderChunk[ 'skinning_pars_vertex' ] = "#ifdef USE_SKINNING\n	uniform mat4 bindMatrix;\n	uniform mat4 bindMatrixInverse;\n	#ifdef BONE_TEXTURE\n		uniform sampler2D boneTexture;\n		uniform int boneTextureWidth;\n		uniform int boneTextureHeight;\n		mat4 getBoneMatrix( const in float i ) {\n			float j = i * 4.0;\n			float x = mod( j, float( boneTextureWidth ) );\n			float y = floor( j / float( boneTextureWidth ) );\n			float dx = 1.0 / float( boneTextureWidth );\n			float dy = 1.0 / float( boneTextureHeight );\n			y = dy * ( y + 0.5 );\n			vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n			vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n			vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n			vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n			mat4 bone = mat4( v1, v2, v3, v4 );\n			return bone;\n		}\n	#else\n		uniform mat4 boneMatrices[ MAX_BONES ];\n		mat4 getBoneMatrix( const in float i ) {\n			mat4 bone = boneMatrices[ int(i) ];\n			return bone;\n		}\n	#endif\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/skinning_vertex.glsl
+
+THREE.ShaderChunk[ 'skinning_vertex' ] = "#ifdef USE_SKINNING\n	vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n	vec4 skinned = vec4( 0.0 );\n	skinned += boneMatX * skinVertex * skinWeight.x;\n	skinned += boneMatY * skinVertex * skinWeight.y;\n	skinned += boneMatZ * skinVertex * skinWeight.z;\n	skinned += boneMatW * skinVertex * skinWeight.w;\n	skinned  = bindMatrixInverse * skinned;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/skinnormal_vertex.glsl
+
+THREE.ShaderChunk[ 'skinnormal_vertex' ] = "#ifdef USE_SKINNING\n	mat4 skinMatrix = mat4( 0.0 );\n	skinMatrix += skinWeight.x * boneMatX;\n	skinMatrix += skinWeight.y * boneMatY;\n	skinMatrix += skinWeight.z * boneMatZ;\n	skinMatrix += skinWeight.w * boneMatW;\n	skinMatrix  = bindMatrixInverse * skinMatrix * bindMatrix;\n	objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/specularmap_fragment.glsl
+
+THREE.ShaderChunk[ 'specularmap_fragment' ] = "float specularStrength;\n#ifdef USE_SPECULARMAP\n	vec4 texelSpecular = texture2D( specularMap, vUv );\n	specularStrength = texelSpecular.r;\n#else\n	specularStrength = 1.0;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/specularmap_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'specularmap_pars_fragment' ] = "#ifdef USE_SPECULARMAP\n	uniform sampler2D specularMap;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/tonemapping_fragment.glsl
+
+THREE.ShaderChunk[ 'tonemapping_fragment' ] = "#if defined( TONE_MAPPING )\n  gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/tonemapping_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'tonemapping_pars_fragment' ] = "#define saturate(a) clamp( a, 0.0, 1.0 )\nuniform float toneMappingExposure;\nuniform float toneMappingWhitePoint;\nvec3 LinearToneMapping( vec3 color ) {\n  return toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n  color *= toneMappingExposure;\n  return saturate( color / ( vec3( 1.0 ) + color ) );\n}\n#define Uncharted2Helper( x ) max( ( ( x * ( 0.15 * x + 0.10 * 0.50 ) + 0.20 * 0.02 ) / ( x * ( 0.15 * x + 0.50 ) + 0.20 * 0.30 ) ) - 0.02 / 0.30, vec3( 0.0 ) )\nvec3 Uncharted2ToneMapping( vec3 color ) {\n  color *= toneMappingExposure;\n  return saturate( Uncharted2Helper( color ) / Uncharted2Helper( vec3( toneMappingWhitePoint ) ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n  color *= toneMappingExposure;\n  color = max( vec3( 0.0 ), color - 0.004 );\n  return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\n";
+
+// File:src/renderers/shaders/ShaderChunk/uv2_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'uv2_pars_fragment' ] = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n	varying vec2 vUv2;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/uv2_pars_vertex.glsl
+
+THREE.ShaderChunk[ 'uv2_pars_vertex' ] = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n	attribute vec2 uv2;\n	varying vec2 vUv2;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/uv2_vertex.glsl
+
+THREE.ShaderChunk[ 'uv2_vertex' ] = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n	vUv2 = uv2;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/uv_pars_fragment.glsl
+
+THREE.ShaderChunk[ 'uv_pars_fragment' ] = "#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\n	varying vec2 vUv;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/uv_pars_vertex.glsl
+
+THREE.ShaderChunk[ 'uv_pars_vertex' ] = "#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\n	varying vec2 vUv;\n	uniform vec4 offsetRepeat;\n#endif\n";
+
+// File:src/renderers/shaders/ShaderChunk/uv_vertex.glsl
+
+THREE.ShaderChunk[ 'uv_vertex' ] = "#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\n	vUv = uv * offsetRepeat.zw + offsetRepeat.xy;\n#endif";
+
+// File:src/renderers/shaders/ShaderChunk/worldpos_vertex.glsl
+
+THREE.ShaderChunk[ 'worldpos_vertex' ] = "#if defined( USE_ENVMAP ) || defined( PHONG ) || defined( PHYSICAL ) || defined( LAMBERT ) || defined ( USE_SHADOWMAP )\n	#ifdef USE_SKINNING\n		vec4 worldPosition = modelMatrix * skinned;\n	#else\n		vec4 worldPosition = modelMatrix * vec4( transformed, 1.0 );\n	#endif\n#endif\n";
+
+// File:src/renderers/shaders/UniformsUtils.js
+
+/**
+ * Uniform Utilities
+ */
+
+THREE.UniformsUtils = {
+
+	merge: function ( uniforms ) {
+
+		var merged = {};
+
+		for ( var u = 0; u < uniforms.length; u ++ ) {
+
+			var tmp = this.clone( uniforms[ u ] );
+
+			for ( var p in tmp ) {
+
+				merged[ p ] = tmp[ p ];
+
+			}
+
+		}
+
+		return merged;
+
+	},
+
+	clone: function ( uniforms_src ) {
+
+		var uniforms_dst = {};
+
+		for ( var u in uniforms_src ) {
+
+			uniforms_dst[ u ] = {};
+
+			for ( var p in uniforms_src[ u ] ) {
+
+				var parameter_src = uniforms_src[ u ][ p ];
+
+				if ( parameter_src instanceof THREE.Color ||
+					 parameter_src instanceof THREE.Vector2 ||
+					 parameter_src instanceof THREE.Vector3 ||
+					 parameter_src instanceof THREE.Vector4 ||
+					 parameter_src instanceof THREE.Matrix3 ||
+					 parameter_src instanceof THREE.Matrix4 ||
+					 parameter_src instanceof THREE.Texture ) {
+
+					uniforms_dst[ u ][ p ] = parameter_src.clone();
+
+				} else if ( Array.isArray( parameter_src ) ) {
+
+					uniforms_dst[ u ][ p ] = parameter_src.slice();
+
+				} else {
+
+					uniforms_dst[ u ][ p ] = parameter_src;
+
+				}
+
+			}
+
+		}
+
+		return uniforms_dst;
+
+	}
+
+};
+
+// File:src/renderers/shaders/UniformsLib.js
+
+/**
+ * Uniforms library for shared webgl shaders
+ */
+
+THREE.UniformsLib = {
+
+	common: {
+
+		"diffuse": { type: "c", value: new THREE.Color( 0xeeeeee ) },
+		"opacity": { type: "1f", value: 1.0 },
+
+		"map": { type: "t", value: null },
+		"offsetRepeat": { type: "v4", value: new THREE.Vector4( 0, 0, 1, 1 ) },
+
+		"specularMap": { type: "t", value: null },
+		"alphaMap": { type: "t", value: null },
+
+		"envMap": { type: "t", value: null },
+		"flipEnvMap": { type: "1f", value: - 1 },
+		"reflectivity": { type: "1f", value: 1.0 },
+		"refractionRatio": { type: "1f", value: 0.98 }
+
+	},
+
+	aomap: {
+
+		"aoMap": { type: "t", value: null },
+		"aoMapIntensity": { type: "1f", value: 1 }
+
+	},
+
+	lightmap: {
+
+		"lightMap": { type: "t", value: null },
+		"lightMapIntensity": { type: "1f", value: 1 }
+
+	},
+
+	emissivemap: {
+
+		"emissiveMap": { type: "t", value: null }
+
+	},
+
+	bumpmap: {
+
+		"bumpMap": { type: "t", value: null },
+		"bumpScale": { type: "1f", value: 1 }
+
+	},
+
+	normalmap: {
+
+		"normalMap": { type: "t", value: null },
+		"normalScale": { type: "v2", value: new THREE.Vector2( 1, 1 ) }
+
+	},
+
+	displacementmap: {
+
+		"displacementMap": { type: "t", value: null },
+		"displacementScale": { type: "1f", value: 1 },
+		"displacementBias": { type: "1f", value: 0 }
+
+	},
+
+	roughnessmap: {
+
+		"roughnessMap": { type: "t", value: null }
+
+	},
+
+	metalnessmap: {
+
+		"metalnessMap": { type: "t", value: null }
+
+	},
+
+	fog: {
+
+		"fogDensity": { type: "1f", value: 0.00025 },
+		"fogNear": { type: "1f", value: 1 },
+		"fogFar": { type: "1f", value: 2000 },
+		"fogColor": { type: "c", value: new THREE.Color( 0xffffff ) }
+
+	},
+
+	lights: {
+
+		"ambientLightColor": { type: "3fv", value: [] },
+
+		"directionalLights": { type: "sa", value: [], properties: {
+			"direction": { type: "v3" },
+			"color": { type: "c" },
+
+			"shadow": { type: "1i" },
+			"shadowBias": { type: "1f" },
+			"shadowRadius": { type: "1f" },
+			"shadowMapSize": { type: "v2" }
+		} },
+
+		"directionalShadowMap": { type: "tv", value: [] },
+		"directionalShadowMatrix": { type: "m4v", value: [] },
+
+		"spotLights": { type: "sa", value: [], properties: {
+			"color": { type: "c" },
+			"position": { type: "v3" },
+			"direction": { type: "v3" },
+			"distance": { type: "1f" },
+			"coneCos": { type: "1f" },
+			"penumbraCos": { type: "1f" },
+			"decay": { type: "1f" },
+
+			"shadow": { type: "1i" },
+			"shadowBias": { type: "1f" },
+			"shadowRadius": { type: "1f" },
+			"shadowMapSize": { type: "v2" }
+		} },
+
+		"spotShadowMap": { type: "tv", value: [] },
+		"spotShadowMatrix": { type: "m4v", value: [] },
+
+		"pointLights": { type: "sa", value: [], properties: {
+			"color": { type: "c" },
+			"position": { type: "v3" },
+			"decay": { type: "1f" },
+			"distance": { type: "1f" },
+
+			"shadow": { type: "1i" },
+			"shadowBias": { type: "1f" },
+			"shadowRadius": { type: "1f" },
+			"shadowMapSize": { type: "v2" }
+		} },
+
+		"pointShadowMap": { type: "tv", value: [] },
+		"pointShadowMatrix": { type: "m4v", value: [] },
+
+		"hemisphereLights": { type: "sa", value: [], properties: {
+			"direction": { type: "v3" },
+			"skyColor": { type: "c" },
+			"groundColor": { type: "c" }
+		} }
+
+	},
+
+	points: {
+
+		"diffuse": { type: "c", value: new THREE.Color( 0xeeeeee ) },
+		"opacity": { type: "1f", value: 1.0 },
+		"size": { type: "1f", value: 1.0 },
+		"scale": { type: "1f", value: 1.0 },
+		"map": { type: "t", value: null },
+		"offsetRepeat": { type: "v4", value: new THREE.Vector4( 0, 0, 1, 1 ) }
+
+	}
+
+};
+
+// File:src/renderers/shaders/ShaderLib/cube_frag.glsl
+
+THREE.ShaderChunk[ 'cube_frag' ] = "uniform samplerCube tCube;\nuniform float tFlip;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	gl_FragColor = textureCube( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );\n	#include <logdepthbuf_fragment>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/cube_vert.glsl
+
+THREE.ShaderChunk[ 'cube_vert' ] = "varying vec3 vWorldPosition;\n#include <common>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	vWorldPosition = transformDirection( position, modelMatrix );\n	#include <begin_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/depth_frag.glsl
+
+THREE.ShaderChunk[ 'depth_frag' ] = "#if DEPTH_PACKING == 3200\n	uniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec4 diffuseColor = vec4( 1.0 );\n	#if DEPTH_PACKING == 3200\n		diffuseColor.a = opacity;\n	#endif\n	#include <map_fragment>\n	#include <alphamap_fragment>\n	#include <alphatest_fragment>\n	#include <logdepthbuf_fragment>\n	#if DEPTH_PACKING == 3200\n		gl_FragColor = vec4( vec3( gl_FragCoord.z ), opacity );\n	#elif DEPTH_PACKING == 3201\n		gl_FragColor = packDepthToRGBA( gl_FragCoord.z );\n	#endif\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/depth_vert.glsl
+
+THREE.ShaderChunk[ 'depth_vert' ] = "#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <uv_vertex>\n	#include <skinbase_vertex>\n	#include <begin_vertex>\n	#include <displacementmap_vertex>\n	#include <morphtarget_vertex>\n	#include <skinning_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/distanceRGBA_frag.glsl
+
+THREE.ShaderChunk[ 'distanceRGBA_frag' ] = "uniform vec3 lightPos;\nvarying vec4 vWorldPosition;\n#include <common>\n#include <packing>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n	#include <clipping_planes_fragment>\n	gl_FragColor = packDepthToRGBA( length( vWorldPosition.xyz - lightPos.xyz ) / 1000.0 );\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/distanceRGBA_vert.glsl
+
+THREE.ShaderChunk[ 'distanceRGBA_vert' ] = "varying vec4 vWorldPosition;\n#include <common>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <skinbase_vertex>\n	#include <begin_vertex>\n	#include <morphtarget_vertex>\n	#include <skinning_vertex>\n	#include <project_vertex>\n	#include <worldpos_vertex>\n	#include <clipping_planes_vertex>\n	vWorldPosition = worldPosition;\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/equirect_frag.glsl
+
+THREE.ShaderChunk[ 'equirect_frag' ] = "uniform sampler2D tEquirect;\nuniform float tFlip;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec3 direction = normalize( vWorldPosition );\n	vec2 sampleUV;\n	sampleUV.y = saturate( tFlip * direction.y * -0.5 + 0.5 );\n	sampleUV.x = atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;\n	gl_FragColor = texture2D( tEquirect, sampleUV );\n	#include <logdepthbuf_fragment>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/equirect_vert.glsl
+
+THREE.ShaderChunk[ 'equirect_vert' ] = "varying vec3 vWorldPosition;\n#include <common>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	vWorldPosition = transformDirection( position, modelMatrix );\n	#include <begin_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/linedashed_frag.glsl
+
+THREE.ShaderChunk[ 'linedashed_frag' ] = "uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	if ( mod( vLineDistance, totalSize ) > dashSize ) {\n		discard;\n	}\n	vec3 outgoingLight = vec3( 0.0 );\n	vec4 diffuseColor = vec4( diffuse, opacity );\n	#include <logdepthbuf_fragment>\n	#include <color_fragment>\n	outgoingLight = diffuseColor.rgb;\n	gl_FragColor = vec4( outgoingLight, diffuseColor.a );\n	#include <premultiplied_alpha_fragment>\n	#include <tonemapping_fragment>\n	#include <encodings_fragment>\n	#include <fog_fragment>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/linedashed_vert.glsl
+
+THREE.ShaderChunk[ 'linedashed_vert' ] = "uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <color_vertex>\n	vLineDistance = scale * lineDistance;\n	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n	gl_Position = projectionMatrix * mvPosition;\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/meshbasic_frag.glsl
+
+THREE.ShaderChunk[ 'meshbasic_frag' ] = "uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n	varying vec3 vNormal;\n#endif\n#include <common>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec4 diffuseColor = vec4( diffuse, opacity );\n	#include <logdepthbuf_fragment>\n	#include <map_fragment>\n	#include <color_fragment>\n	#include <alphamap_fragment>\n	#include <alphatest_fragment>\n	#include <specularmap_fragment>\n	ReflectedLight reflectedLight;\n	reflectedLight.directDiffuse = vec3( 0.0 );\n	reflectedLight.directSpecular = vec3( 0.0 );\n	reflectedLight.indirectDiffuse = diffuseColor.rgb;\n	reflectedLight.indirectSpecular = vec3( 0.0 );\n	#include <aomap_fragment>\n	vec3 outgoingLight = reflectedLight.indirectDiffuse;\n	#include <envmap_fragment>\n	gl_FragColor = vec4( outgoingLight, diffuseColor.a );\n	#include <premultiplied_alpha_fragment>\n	#include <tonemapping_fragment>\n	#include <encodings_fragment>\n	#include <fog_fragment>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/meshbasic_vert.glsl
+
+THREE.ShaderChunk[ 'meshbasic_vert' ] = "#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <uv_vertex>\n	#include <uv2_vertex>\n	#include <color_vertex>\n	#include <skinbase_vertex>\n	#ifdef USE_ENVMAP\n	#include <beginnormal_vertex>\n	#include <morphnormal_vertex>\n	#include <skinnormal_vertex>\n	#include <defaultnormal_vertex>\n	#endif\n	#include <begin_vertex>\n	#include <morphtarget_vertex>\n	#include <skinning_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <worldpos_vertex>\n	#include <clipping_planes_vertex>\n	#include <envmap_vertex>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/meshlambert_frag.glsl
+
+THREE.ShaderChunk[ 'meshlambert_frag' ] = "uniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\nvarying vec3 vLightFront;\n#ifdef DOUBLE_SIDED\n	varying vec3 vLightBack;\n#endif\n#include <common>\n#include <packing>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <bsdfs>\n#include <lights_pars>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec4 diffuseColor = vec4( diffuse, opacity );\n	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n	vec3 totalEmissiveRadiance = emissive;\n	#include <logdepthbuf_fragment>\n	#include <map_fragment>\n	#include <color_fragment>\n	#include <alphamap_fragment>\n	#include <alphatest_fragment>\n	#include <specularmap_fragment>\n	#include <emissivemap_fragment>\n	reflectedLight.indirectDiffuse = getAmbientLightIrradiance( ambientLightColor );\n	#include <lightmap_fragment>\n	reflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );\n	#ifdef DOUBLE_SIDED\n		reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\n	#else\n		reflectedLight.directDiffuse = vLightFront;\n	#endif\n	reflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();\n	#include <aomap_fragment>\n	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n	#include <envmap_fragment>\n	gl_FragColor = vec4( outgoingLight, diffuseColor.a );\n	#include <premultiplied_alpha_fragment>\n	#include <tonemapping_fragment>\n	#include <encodings_fragment>\n	#include <fog_fragment>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/meshlambert_vert.glsl
+
+THREE.ShaderChunk[ 'meshlambert_vert' ] = "#define LAMBERT\nvarying vec3 vLightFront;\n#ifdef DOUBLE_SIDED\n	varying vec3 vLightBack;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <bsdfs>\n#include <lights_pars>\n#include <color_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <uv_vertex>\n	#include <uv2_vertex>\n	#include <color_vertex>\n	#include <beginnormal_vertex>\n	#include <morphnormal_vertex>\n	#include <skinbase_vertex>\n	#include <skinnormal_vertex>\n	#include <defaultnormal_vertex>\n	#include <begin_vertex>\n	#include <morphtarget_vertex>\n	#include <skinning_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n	#include <worldpos_vertex>\n	#include <envmap_vertex>\n	#include <lights_lambert_vertex>\n	#include <shadowmap_vertex>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/meshphong_frag.glsl
+
+THREE.ShaderChunk[ 'meshphong_frag' ] = "#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec4 diffuseColor = vec4( diffuse, opacity );\n	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n	vec3 totalEmissiveRadiance = emissive;\n	#include <logdepthbuf_fragment>\n	#include <map_fragment>\n	#include <color_fragment>\n	#include <alphamap_fragment>\n	#include <alphatest_fragment>\n	#include <specularmap_fragment>\n	#include <normal_fragment>\n	#include <emissivemap_fragment>\n	#include <lights_phong_fragment>\n	#include <lights_template>\n	#include <aomap_fragment>\n	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n	#include <envmap_fragment>\n	gl_FragColor = vec4( outgoingLight, diffuseColor.a );\n	#include <premultiplied_alpha_fragment>\n	#include <tonemapping_fragment>\n	#include <encodings_fragment>\n	#include <fog_fragment>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/meshphong_vert.glsl
+
+THREE.ShaderChunk[ 'meshphong_vert' ] = "#define PHONG\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n	varying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <uv_vertex>\n	#include <uv2_vertex>\n	#include <color_vertex>\n	#include <beginnormal_vertex>\n	#include <morphnormal_vertex>\n	#include <skinbase_vertex>\n	#include <skinnormal_vertex>\n	#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n	vNormal = normalize( transformedNormal );\n#endif\n	#include <begin_vertex>\n	#include <displacementmap_vertex>\n	#include <morphtarget_vertex>\n	#include <skinning_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n	vViewPosition = - mvPosition.xyz;\n	#include <worldpos_vertex>\n	#include <envmap_vertex>\n	#include <shadowmap_vertex>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/meshphysical_frag.glsl
+
+THREE.ShaderChunk[ 'meshphysical_frag' ] = "#define PHYSICAL\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\nuniform float envMapIntensity;\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n	varying vec3 vNormal;\n#endif\n#include <common>\n#include <packing>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <cube_uv_reflection_fragment>\n#include <lights_pars>\n#include <lights_physical_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec4 diffuseColor = vec4( diffuse, opacity );\n	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n	vec3 totalEmissiveRadiance = emissive;\n	#include <logdepthbuf_fragment>\n	#include <map_fragment>\n	#include <color_fragment>\n	#include <alphamap_fragment>\n	#include <alphatest_fragment>\n	#include <specularmap_fragment>\n	#include <roughnessmap_fragment>\n	#include <metalnessmap_fragment>\n	#include <normal_fragment>\n	#include <emissivemap_fragment>\n	#include <lights_physical_fragment>\n	#include <lights_template>\n	#include <aomap_fragment>\n	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n	gl_FragColor = vec4( outgoingLight, diffuseColor.a );\n	#include <premultiplied_alpha_fragment>\n	#include <tonemapping_fragment>\n	#include <encodings_fragment>\n	#include <fog_fragment>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/meshphysical_vert.glsl
+
+THREE.ShaderChunk[ 'meshphysical_vert' ] = "#define PHYSICAL\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n	varying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <uv_vertex>\n	#include <uv2_vertex>\n	#include <color_vertex>\n	#include <beginnormal_vertex>\n	#include <morphnormal_vertex>\n	#include <skinbase_vertex>\n	#include <skinnormal_vertex>\n	#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n	vNormal = normalize( transformedNormal );\n#endif\n	#include <begin_vertex>\n	#include <displacementmap_vertex>\n	#include <morphtarget_vertex>\n	#include <skinning_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n	vViewPosition = - mvPosition.xyz;\n	#include <worldpos_vertex>\n	#include <shadowmap_vertex>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/normal_frag.glsl
+
+THREE.ShaderChunk[ 'normal_frag' ] = "uniform float opacity;\nvarying vec3 vNormal;\n#include <common>\n#include <packing>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	gl_FragColor = vec4( packNormalToRGB( vNormal ), opacity );\n	#include <logdepthbuf_fragment>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/normal_vert.glsl
+
+THREE.ShaderChunk[ 'normal_vert' ] = "varying vec3 vNormal;\n#include <common>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	vNormal = normalize( normalMatrix * normal );\n	#include <begin_vertex>\n	#include <morphtarget_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/points_frag.glsl
+
+THREE.ShaderChunk[ 'points_frag' ] = "uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec3 outgoingLight = vec3( 0.0 );\n	vec4 diffuseColor = vec4( diffuse, opacity );\n	#include <logdepthbuf_fragment>\n	#include <map_particle_fragment>\n	#include <color_fragment>\n	#include <alphatest_fragment>\n	outgoingLight = diffuseColor.rgb;\n	gl_FragColor = vec4( outgoingLight, diffuseColor.a );\n	#include <premultiplied_alpha_fragment>\n	#include <tonemapping_fragment>\n	#include <encodings_fragment>\n	#include <fog_fragment>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib/points_vert.glsl
+
+THREE.ShaderChunk[ 'points_vert' ] = "uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <color_vertex>\n	#include <begin_vertex>\n	#include <project_vertex>\n	#ifdef USE_SIZEATTENUATION\n		gl_PointSize = size * ( scale / - mvPosition.z );\n	#else\n		gl_PointSize = size;\n	#endif\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n	#include <worldpos_vertex>\n	#include <shadowmap_vertex>\n}\n";
+
+// File:src/renderers/shaders/ShaderLib.js
+
+/**
+ * Webgl Shader Library for three.js
+ *
+ * @author alteredq / http://alteredqualia.com/
+ * @author mrdoob / http://mrdoob.com/
+ * @author mikael emtinger / http://gomo.se/
+ */
+
+
+THREE.ShaderLib = {
+
+	'basic': {
+
+		uniforms: THREE.UniformsUtils.merge( [
+
+			THREE.UniformsLib[ 'common' ],
+			THREE.UniformsLib[ 'aomap' ],
+			THREE.UniformsLib[ 'fog' ]
+
+		] ),
+
+		vertexShader: THREE.ShaderChunk[ 'meshbasic_vert' ],
+		fragmentShader: THREE.ShaderChunk[ 'meshbasic_frag' ]
+
+	},
+
+	'lambert': {
+
+		uniforms: THREE.UniformsUtils.merge( [
+
+			THREE.UniformsLib[ 'common' ],
+			THREE.UniformsLib[ 'aomap' ],
+			THREE.UniformsLib[ 'lightmap' ],
+			THREE.UniformsLib[ 'emissivemap' ],
+			THREE.UniformsLib[ 'fog' ],
+			THREE.UniformsLib[ 'lights' ],
+
+			{
+				"emissive" : { type: "c", value: new THREE.Color( 0x000000 ) }
+			}
+
+		] ),
+
+		vertexShader: THREE.ShaderChunk[ 'meshlambert_vert' ],
+		fragmentShader: THREE.ShaderChunk[ 'meshlambert_frag' ]
+
+	},
+
+	'phong': {
+
+		uniforms: THREE.UniformsUtils.merge( [
+
+			THREE.UniformsLib[ 'common' ],
+			THREE.UniformsLib[ 'aomap' ],
+			THREE.UniformsLib[ 'lightmap' ],
+			THREE.UniformsLib[ 'emissivemap' ],
+			THREE.UniformsLib[ 'bumpmap' ],
+			THREE.UniformsLib[ 'normalmap' ],
+			THREE.UniformsLib[ 'displacementmap' ],
+			THREE.UniformsLib[ 'fog' ],
+			THREE.UniformsLib[ 'lights' ],
+
+			{
+				"emissive" : { type: "c", value: new THREE.Color( 0x000000 ) },
+				"specular" : { type: "c", value: new THREE.Color( 0x111111 ) },
+				"shininess": { type: "1f", value: 30 }
+			}
+
+		] ),
+
+		vertexShader: THREE.ShaderChunk[ 'meshphong_vert' ],
+		fragmentShader: THREE.ShaderChunk[ 'meshphong_frag' ]
+
+	},
+
+	'standard': {
+
+		uniforms: THREE.UniformsUtils.merge( [
+
+			THREE.UniformsLib[ 'common' ],
+			THREE.UniformsLib[ 'aomap' ],
+			THREE.UniformsLib[ 'lightmap' ],
+			THREE.UniformsLib[ 'emissivemap' ],
+			THREE.UniformsLib[ 'bumpmap' ],
+			THREE.UniformsLib[ 'normalmap' ],
+			THREE.UniformsLib[ 'displacementmap' ],
+			THREE.UniformsLib[ 'roughnessmap' ],
+			THREE.UniformsLib[ 'metalnessmap' ],
+			THREE.UniformsLib[ 'fog' ],
+			THREE.UniformsLib[ 'lights' ],
+
+			{
+				"emissive" : { type: "c", value: new THREE.Color( 0x000000 ) },
+				"roughness": { type: "1f", value: 0.5 },
+				"metalness": { type: "1f", value: 0 },
+				"envMapIntensity" : { type: "1f", value: 1 } // temporary
+			}
+
+		] ),
+
+		vertexShader: THREE.ShaderChunk[ 'meshphysical_vert' ],
+		fragmentShader: THREE.ShaderChunk[ 'meshphysical_frag' ]
+
+	},
+
+	'points': {
+
+		uniforms: THREE.UniformsUtils.merge( [
+
+			THREE.UniformsLib[ 'points' ],
+			THREE.UniformsLib[ 'fog' ]
+
+		] ),
+
+		vertexShader: THREE.ShaderChunk[ 'points_vert' ],
+		fragmentShader: THREE.ShaderChunk[ 'points_frag' ]
+
+	},
+
+	'dashed': {
+
+		uniforms: THREE.UniformsUtils.merge( [
+
+			THREE.UniformsLib[ 'common' ],
+			THREE.UniformsLib[ 'fog' ],
+
+			{
+				"scale"    : { type: "1f", value: 1 },
+				"dashSize" : { type: "1f", value: 1 },
+				"totalSize": { type: "1f", value: 2 }
+			}
+
+		] ),
+
+		vertexShader: THREE.ShaderChunk[ 'linedashed_vert' ],
+		fragmentShader: THREE.ShaderChunk[ 'linedashed_frag' ]
+
+	},
+
+	'depth': {
+
+		uniforms: THREE.UniformsUtils.merge( [
+
+			THREE.UniformsLib[ 'common' ],
+			THREE.UniformsLib[ 'displacementmap' ]
+
+		] ),
+
+		vertexShader: THREE.ShaderChunk[ 'depth_vert' ],
+		fragmentShader: THREE.ShaderChunk[ 'depth_frag' ]
+
+	},
+
+	'normal': {
+
+		uniforms: {
+
+			"opacity" : { type: "1f", value: 1.0 }
+
+		},
+
+		vertexShader: THREE.ShaderChunk[ 'normal_vert' ],
+		fragmentShader: THREE.ShaderChunk[ 'normal_frag' ]
+
+	},
+
+	/* -------------------------------------------------------------------------
+	//	Cube map shader
+	 ------------------------------------------------------------------------- */
+
+	'cube': {
+
+		uniforms: {
+			"tCube": { type: "t", value: null },
+			"tFlip": { type: "1f", value: - 1 }
+		},
+
+		vertexShader: THREE.ShaderChunk[ 'cube_vert' ],
+		fragmentShader: THREE.ShaderChunk[ 'cube_frag' ]
+
+	},
+
+	/* -------------------------------------------------------------------------
+	//	Cube map shader
+	 ------------------------------------------------------------------------- */
+
+	'equirect': {
+
+		uniforms: {
+			"tEquirect": { type: "t", value: null },
+			"tFlip": { type: "1f", value: - 1 }
+		},
+
+		vertexShader: THREE.ShaderChunk[ 'equirect_vert' ],
+		fragmentShader: THREE.ShaderChunk[ 'equirect_frag' ]
+
+	},
+
+	'distanceRGBA': {
+
+		uniforms: {
+
+			"lightPos": { type: "v3", value: new THREE.Vector3() }
+
+		},
+
+		vertexShader: THREE.ShaderChunk[ 'distanceRGBA_vert' ],
+		fragmentShader: THREE.ShaderChunk[ 'distanceRGBA_frag' ]
+
+	}
+
+};
+
+THREE.ShaderLib[ 'physical' ] = {
+
+	uniforms: THREE.UniformsUtils.merge( [
+
+		THREE.ShaderLib[ 'standard' ].uniforms,
+
+		{
+			// future
+		}
+
+	] ),
+
+	vertexShader: THREE.ShaderChunk[ 'meshphysical_vert' ],
+	fragmentShader: THREE.ShaderChunk[ 'meshphysical_frag' ]
+
+};
+
+
+// File:src/renderers/WebGLRenderer.js
+
+/**
+ * @author supereggbert / http://www.paulbrunt.co.uk/
+ * @author mrdoob / http://mrdoob.com/
+ * @author alteredq / http://alteredqualia.com/
+ * @author szimek / https://github.com/szimek/
+ * @author tschw
+ */
+
+THREE.WebGLRenderer = function ( parameters ) {
+
+	console.log( 'THREE.WebGLRenderer', THREE.REVISION );
+
+	parameters = parameters || {};
+
+	var _canvas = parameters.canvas !== undefined ? parameters.canvas : document.createElement( 'canvas' ),
+	_context = parameters.context !== undefined ? parameters.context : null,
+
+	_alpha = parameters.alpha !== undefined ? parameters.alpha : false,
+	_depth = parameters.depth !== undefined ? parameters.depth : true,
+	_stencil = parameters.stencil !== undefined ? parameters.stencil : true,
+	_antialias = parameters.antialias !== undefined ? parameters.antialias : false,
+	_premultipliedAlpha = parameters.premultipliedAlpha !== undefined ? parameters.premultipliedAlpha : true,
+	_preserveDrawingBuffer = parameters.preserveDrawingBuffer !== undefined ? parameters.preserveDrawingBuffer : false;
+
+	var lights = [];
+
+	var opaqueObjects = [];
+	var opaqueObjectsLastIndex = - 1;
+	var transparentObjects = [];
+	var transparentObjectsLastIndex = - 1;
+
+	var morphInfluences = new Float32Array( 8 );
+
+	var sprites = [];
+	var lensFlares = [];
+
+	// public properties
+
+	this.domElement = _canvas;
+	this.context = null;
+
+	// clearing
+
+	this.autoClear = true;
+	this.autoClearColor = true;
+	this.autoClearDepth = true;
+	this.autoClearStencil = true;
+
+	// scene graph
+
+	this.sortObjects = true;
+
+	// user-defined clipping
+
+	this.clippingPlanes = [];
+	this.localClippingEnabled = false;
+
+	// physically based shading
+
+	this.gammaFactor = 2.0;	// for backwards compatibility
+	this.gammaInput = false;
+	this.gammaOutput = false;
+
+	// physical lights
+
+	this.physicallyCorrectLights = false;
+
+	// tone mapping
+
+	this.toneMapping = THREE.LinearToneMapping;
+	this.toneMappingExposure = 1.0;
+	this.toneMappingWhitePoint = 1.0;
+
+	// morphs
+
+	this.maxMorphTargets = 8;
+	this.maxMorphNormals = 4;
+
+	// flags
+
+	this.autoScaleCubemaps = true;
+
+	// internal properties
+
+	var _this = this,
+
+	// internal state cache
+
+	_currentProgram = null,
+	_currentRenderTarget = null,
+	_currentFramebuffer = null,
+	_currentMaterialId = - 1,
+	_currentGeometryProgram = '',
+	_currentCamera = null,
+
+	_currentScissor = new THREE.Vector4(),
+	_currentScissorTest = null,
+
+	_currentViewport = new THREE.Vector4(),
+
+	//
+
+	_usedTextureUnits = 0,
+
+	//
+
+	_clearColor = new THREE.Color( 0x000000 ),
+	_clearAlpha = 0,
+
+	_width = _canvas.width,
+	_height = _canvas.height,
+
+	_pixelRatio = 1,
+
+	_scissor = new THREE.Vector4( 0, 0, _width, _height ),
+	_scissorTest = false,
+
+	_viewport = new THREE.Vector4( 0, 0, _width, _height ),
+
+	// frustum
+
+	_frustum = new THREE.Frustum(),
+
+	// clipping
+
+	_clippingEnabled = false,
+	_localClippingEnabled = false,
+	_clipRenderingShadows = false,
+
+	_numClippingPlanes = 0,
+	_clippingPlanesUniform = {
+			type: '4fv', value: null, needsUpdate: false },
+
+	_globalClippingState = null,
+	_numGlobalClippingPlanes = 0,
+
+	_matrix3 = new THREE.Matrix3(),
+	_sphere = new THREE.Sphere(),
+	_plane = new THREE.Plane(),
+
+
+	// camera matrices cache
+
+	_projScreenMatrix = new THREE.Matrix4(),
+
+	_vector3 = new THREE.Vector3(),
+
+	// light arrays cache
+
+	_lights = {
+
+		hash: '',
+
+		ambient: [ 0, 0, 0 ],
+		directional: [],
+		directionalShadowMap: [],
+		directionalShadowMatrix: [],
+		spot: [],
+		spotShadowMap: [],
+		spotShadowMatrix: [],
+		point: [],
+		pointShadowMap: [],
+		pointShadowMatrix: [],
+		hemi: [],
+
+		shadows: []
+
+	},
+
+	// info
+
+	_infoMemory = {
+
+		geometries: 0,
+		textures: 0
+
+	},
+
+	_infoRender = {
+
+		calls: 0,
+		vertices: 0,
+		faces: 0,
+		points: 0
+
+	};
+
+	this.info = {
+
+		render: _infoRender,
+		memory: _infoMemory,
+		programs: null
+
+	};
+
+
+	// initialize
+
+	var _gl;
+
+	try {
+
+		var attributes = {
+			alpha: _alpha,
+			depth: _depth,
+			stencil: _stencil,
+			antialias: _antialias,
+			premultipliedAlpha: _premultipliedAlpha,
+			preserveDrawingBuffer: _preserveDrawingBuffer
+		};
+
+		_gl = _context || _canvas.getContext( 'webgl', attributes ) || _canvas.getContext( 'experimental-webgl', attributes );
+
+		if ( _gl === null ) {
+
+			if ( _canvas.getContext( 'webgl' ) !== null ) {
+
+				throw 'Error creating WebGL context with your selected attributes.';
+
+			} else {
+
+				throw 'Error creating WebGL context.';
+
+			}
+
+		}
+
+		// Some experimental-webgl implementations do not have getShaderPrecisionFormat
+
+		if ( _gl.getShaderPrecisionFormat === undefined ) {
+
+			_gl.getShaderPrecisionFormat = function () {
+
+				return { 'rangeMin': 1, 'rangeMax': 1, 'precision': 1 };
+
+			};
+
+		}
+
+		_canvas.addEventListener( 'webglcontextlost', onContextLost, false );
+
+	} catch ( error ) {
+
+		console.error( 'THREE.WebGLRenderer: ' + error );
+
+	}
+
+	var _isWebGL2 = (typeof WebGL2RenderingContext !== 'undefined' && _gl instanceof WebGL2RenderingContext);
+	var extensions = new THREE.WebGLExtensions( _gl );
+
+	extensions.get( 'WEBGL_depth_texture' );
+	extensions.get( 'OES_texture_float' );
+	extensions.get( 'OES_texture_float_linear' );
+	extensions.get( 'OES_texture_half_float' );
+	extensions.get( 'OES_texture_half_float_linear' );
+	extensions.get( 'OES_standard_derivatives' );
+	extensions.get( 'ANGLE_instanced_arrays' );
+
+	if ( extensions.get( 'OES_element_index_uint' ) ) {
+
+		THREE.BufferGeometry.MaxIndex = 4294967296;
+
+	}
+
+	var capabilities = new THREE.WebGLCapabilities( _gl, extensions, parameters );
+
+	var state = new THREE.WebGLState( _gl, extensions, paramThreeToGL );
+	var properties = new THREE.WebGLProperties();
+	var objects = new THREE.WebGLObjects( _gl, properties, this.info );
+	var programCache = new THREE.WebGLPrograms( this, capabilities );
+	var lightCache = new THREE.WebGLLights();
+
+	this.info.programs = programCache.programs;
+
+	var bufferRenderer = new THREE.WebGLBufferRenderer( _gl, extensions, _infoRender );
+	var indexedBufferRenderer = new THREE.WebGLIndexedBufferRenderer( _gl, extensions, _infoRender );
+
+	//
+
+	function getTargetPixelRatio() {
+
+		return _currentRenderTarget === null ? _pixelRatio : 1;
+
+	}
+
+	function glClearColor( r, g, b, a ) {
+
+		if ( _premultipliedAlpha === true ) {
+
+			r *= a; g *= a; b *= a;
+
+		}
+
+		state.clearColor( r, g, b, a );
+
+	}
+
+	function setDefaultGLState() {
+
+		state.init();
+
+		state.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ) );
+		state.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ) );
+
+		glClearColor( _clearColor.r, _clearColor.g, _clearColor.b, _clearAlpha );
+
+	}
+
+	function resetGLState() {
+
+		_currentProgram = null;
+		_currentCamera = null;
+
+		_currentGeometryProgram = '';
+		_currentMaterialId = - 1;
+
+		state.reset();
+
+	}
+
+	setDefaultGLState();
+
+	this.context = _gl;
+	this.capabilities = capabilities;
+	this.extensions = extensions;
+	this.properties = properties;
+	this.state = state;
+
+	// shadow map
+
+	var shadowMap = new THREE.WebGLShadowMap( this, _lights, objects );
+
+	this.shadowMap = shadowMap;
+
+
+	// Plugins
+
+	var spritePlugin = new THREE.SpritePlugin( this, sprites );
+	var lensFlarePlugin = new THREE.LensFlarePlugin( this, lensFlares );
+
+	// API
+
+	this.getContext = function () {
+
+		return _gl;
+
+	};
+
+	this.getContextAttributes = function () {
+
+		return _gl.getContextAttributes();
+
+	};
+
+	this.forceContextLoss = function () {
+
+		extensions.get( 'WEBGL_lose_context' ).loseContext();
+
+	};
+
+	this.getMaxAnisotropy = ( function () {
+
+		var value;
+
+		return function getMaxAnisotropy() {
+
+			if ( value !== undefined ) return value;
+
+			var extension = extensions.get( 'EXT_texture_filter_anisotropic' );
+
+			if ( extension !== null ) {
+
+				value = _gl.getParameter( extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT );
+
+			} else {
+
+				value = 0;
+
+			}
+
+			return value;
+
+		};
+
+	} )();
+
+	this.getPrecision = function () {
+
+		return capabilities.precision;
+
+	};
+
+	this.getPixelRatio = function () {
+
+		return _pixelRatio;
+
+	};
+
+	this.setPixelRatio = function ( value ) {
+
+		if ( value === undefined ) return;
+
+		_pixelRatio = value;
+
+		this.setSize( _viewport.z, _viewport.w, false );
+
+	};
+
+	this.getSize = function () {
+
+		return {
+			width: _width,
+			height: _height
+		};
+
+	};
+
+	this.setSize = function ( width, height, updateStyle ) {
+
+		_width = width;
+		_height = height;
+
+		_canvas.width = width * _pixelRatio;
+		_canvas.height = height * _pixelRatio;
+
+		if ( updateStyle !== false ) {
+
+			_canvas.style.width = width + 'px';
+			_canvas.style.height = height + 'px';
+
+		}
+
+		this.setViewport( 0, 0, width, height );
+
+	};
+
+	this.setViewport = function ( x, y, width, height ) {
+
+		state.viewport( _viewport.set( x, y, width, height ) );
+
+	};
+
+	this.setScissor = function ( x, y, width, height ) {
+
+		state.scissor( _scissor.set( x, y, width, height ) );
+
+	};
+
+	this.setScissorTest = function ( boolean ) {
+
+		state.setScissorTest( _scissorTest = boolean );
+
+	};
+
+	// Clearing
+
+	this.getClearColor = function () {
+
+		return _clearColor;
+
+	};
+
+	this.setClearColor = function ( color, alpha ) {
+
+		_clearColor.set( color );
+
+		_clearAlpha = alpha !== undefined ? alpha : 1;
+
+		glClearColor( _clearColor.r, _clearColor.g, _clearColor.b, _clearAlpha );
+
+	};
+
+	this.getClearAlpha = function () {
+
+		return _clearAlpha;
+
+	};
+
+	this.setClearAlpha = function ( alpha ) {
+
+		_clearAlpha = alpha;
+
+		glClearColor( _clearColor.r, _clearColor.g, _clearColor.b, _clearAlpha );
+
+	};
+
+	this.clear = function ( color, depth, stencil ) {
+
+		var bits = 0;
+
+		if ( color === undefined || color ) bits |= _gl.COLOR_BUFFER_BIT;
+		if ( depth === undefined || depth ) bits |= _gl.DEPTH_BUFFER_BIT;
+		if ( stencil === undefined || stencil ) bits |= _gl.STENCIL_BUFFER_BIT;
+
+		_gl.clear( bits );
+
+	};
+
+	this.clearColor = function () {
+
+		this.clear( true, false, false );
+
+	};
+
+	this.clearDepth = function () {
+
+		this.clear( false, true, false );
+
+	};
+
+	this.clearStencil = function () {
+
+		this.clear( false, false, true );
+
+	};
+
+	this.clearTarget = function ( renderTarget, color, depth, stencil ) {
+
+		this.setRenderTarget( renderTarget );
+		this.clear( color, depth, stencil );
+
+	};
+
+	// Reset
+
+	this.resetGLState = resetGLState;
+
+	this.dispose = function() {
+
+		_canvas.removeEventListener( 'webglcontextlost', onContextLost, false );
+
+	};
+
+	// Events
+
+	function onContextLost( event ) {
+
+		event.preventDefault();
+
+		resetGLState();
+		setDefaultGLState();
+
+		properties.clear();
+
+	}
+
+	function onTextureDispose( event ) {
+
+		var texture = event.target;
+
+		texture.removeEventListener( 'dispose', onTextureDispose );
+
+		deallocateTexture( texture );
+
+		_infoMemory.textures --;
+
+
+	}
+
+	function onRenderTargetDispose( event ) {
+
+		var renderTarget = event.target;
+
+		renderTarget.removeEventListener( 'dispose', onRenderTargetDispose );
+
+		deallocateRenderTarget( renderTarget );
+
+		_infoMemory.textures --;
+
+	}
+
+	function onMaterialDispose( event ) {
+
+		var material = event.target;
+
+		material.removeEventListener( 'dispose', onMaterialDispose );
+
+		deallocateMaterial( material );
+
+	}
+
+	// Buffer deallocation
+
+	function deallocateTexture( texture ) {
+
+		var textureProperties = properties.get( texture );
+
+		if ( texture.image && textureProperties.__image__webglTextureCube ) {
+
+			// cube texture
+
+			_gl.deleteTexture( textureProperties.__image__webglTextureCube );
+
+		} else {
+
+			// 2D texture
+
+			if ( textureProperties.__webglInit === undefined ) return;
+
+			_gl.deleteTexture( textureProperties.__webglTexture );
+
+		}
+
+		// remove all webgl properties
+		properties.delete( texture );
+
+	}
+
+	function deallocateRenderTarget( renderTarget ) {
+
+		var renderTargetProperties = properties.get( renderTarget );
+		var textureProperties = properties.get( renderTarget.texture );
+
+		if ( ! renderTarget ) return;
+
+		if ( textureProperties.__webglTexture !== undefined ) {
+
+			_gl.deleteTexture( textureProperties.__webglTexture );
+
+		}
+
+		if ( renderTarget.depthTexture ) {
+
+			renderTarget.depthTexture.dispose();
+
+		}
+
+		if ( renderTarget instanceof THREE.WebGLRenderTargetCube ) {
+
+			for ( var i = 0; i < 6; i ++ ) {
+
+				_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ i ] );
+				if ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer[ i ] );
+
+			}
+
+		} else {
+
+			_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer );
+			if ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer );
+
+		}
+
+		properties.delete( renderTarget.texture );
+		properties.delete( renderTarget );
+
+	}
+
+	function deallocateMaterial( material ) {
+
+		releaseMaterialProgramReference( material );
+
+		properties.delete( material );
+
+	}
+
+
+	function releaseMaterialProgramReference( material ) {
+
+		var programInfo = properties.get( material ).program;
+
+		material.program = undefined;
+
+		if ( programInfo !== undefined ) {
+
+			programCache.releaseProgram( programInfo );
+
+		}
+
+	}
+
+	// Buffer rendering
+
+	this.renderBufferImmediate = function ( object, program, material ) {
+
+		state.initAttributes();
+
+		var buffers = properties.get( object );
+
+		if ( object.hasPositions && ! buffers.position ) buffers.position = _gl.createBuffer();
+		if ( object.hasNormals && ! buffers.normal ) buffers.normal = _gl.createBuffer();
+		if ( object.hasUvs && ! buffers.uv ) buffers.uv = _gl.createBuffer();
+		if ( object.hasColors && ! buffers.color ) buffers.color = _gl.createBuffer();
+
+		var attributes = program.getAttributes();
+
+		if ( object.hasPositions ) {
+
+			_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.position );
+			_gl.bufferData( _gl.ARRAY_BUFFER, object.positionArray, _gl.DYNAMIC_DRAW );
+
+			state.enableAttribute( attributes.position );
+			_gl.vertexAttribPointer( attributes.position, 3, _gl.FLOAT, false, 0, 0 );
+
+		}
+
+		if ( object.hasNormals ) {
+
+			_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.normal );
+
+			if ( material.type !== 'MeshPhongMaterial' && material.type !== 'MeshStandardMaterial' && material.type !== 'MeshPhysicalMaterial' && material.shading === THREE.FlatShading ) {
+
+				for ( var i = 0, l = object.count * 3; i < l; i += 9 ) {
+
+					var array = object.normalArray;
+
+					var nx = ( array[ i + 0 ] + array[ i + 3 ] + array[ i + 6 ] ) / 3;
+					var ny = ( array[ i + 1 ] + array[ i + 4 ] + array[ i + 7 ] ) / 3;
+					var nz = ( array[ i + 2 ] + array[ i + 5 ] + array[ i + 8 ] ) / 3;
+
+					array[ i + 0 ] = nx;
+					array[ i + 1 ] = ny;
+					array[ i + 2 ] = nz;
+
+					array[ i + 3 ] = nx;
+					array[ i + 4 ] = ny;
+					array[ i + 5 ] = nz;
+
+					array[ i + 6 ] = nx;
+					array[ i + 7 ] = ny;
+					array[ i + 8 ] = nz;
+
+				}
+
+			}
+
+			_gl.bufferData( _gl.ARRAY_BUFFER, object.normalArray, _gl.DYNAMIC_DRAW );
+
+			state.enableAttribute( attributes.normal );
+
+			_gl.vertexAttribPointer( attributes.normal, 3, _gl.FLOAT, false, 0, 0 );
+
+		}
+
+		if ( object.hasUvs && material.map ) {
+
+			_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.uv );
+			_gl.bufferData( _gl.ARRAY_BUFFER, object.uvArray, _gl.DYNAMIC_DRAW );
+
+			state.enableAttribute( attributes.uv );
+
+			_gl.vertexAttribPointer( attributes.uv, 2, _gl.FLOAT, false, 0, 0 );
+
+		}
+
+		if ( object.hasColors && material.vertexColors !== THREE.NoColors ) {
+
+			_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.color );
+			_gl.bufferData( _gl.ARRAY_BUFFER, object.colorArray, _gl.DYNAMIC_DRAW );
+
+			state.enableAttribute( attributes.color );
+
+			_gl.vertexAttribPointer( attributes.color, 3, _gl.FLOAT, false, 0, 0 );
+
+		}
+
+		state.disableUnusedAttributes();
+
+		_gl.drawArrays( _gl.TRIANGLES, 0, object.count );
+
+		object.count = 0;
+
+	};
+
+	this.renderBufferDirect = function ( camera, fog, geometry, material, object, group ) {
+
+		setMaterial( material );
+
+		var program = setProgram( camera, fog, material, object );
+
+		var updateBuffers = false;
+		var geometryProgram = geometry.id + '_' + program.id + '_' + material.wireframe;
+
+		if ( geometryProgram !== _currentGeometryProgram ) {
+
+			_currentGeometryProgram = geometryProgram;
+			updateBuffers = true;
+
+		}
+
+		// morph targets
+
+		var morphTargetInfluences = object.morphTargetInfluences;
+
+		if ( morphTargetInfluences !== undefined ) {
+
+			var activeInfluences = [];
+
+			for ( var i = 0, l = morphTargetInfluences.length; i < l; i ++ ) {
+
+				var influence = morphTargetInfluences[ i ];
+				activeInfluences.push( [ influence, i ] );
+
+			}
+
+			activeInfluences.sort( absNumericalSort );
+
+			if ( activeInfluences.length > 8 ) {
+
+				activeInfluences.length = 8;
+
+			}
+
+			var morphAttributes = geometry.morphAttributes;
+
+			for ( var i = 0, l = activeInfluences.length; i < l; i ++ ) {
+
+				var influence = activeInfluences[ i ];
+				morphInfluences[ i ] = influence[ 0 ];
+
+				if ( influence[ 0 ] !== 0 ) {
+
+					var index = influence[ 1 ];
+
+					if ( material.morphTargets === true && morphAttributes.position ) geometry.addAttribute( 'morphTarget' + i, morphAttributes.position[ index ] );
+					if ( material.morphNormals === true && morphAttributes.normal ) geometry.addAttribute( 'morphNormal' + i, morphAttributes.normal[ index ] );
+
+				} else {
+
+					if ( material.morphTargets === true ) geometry.removeAttribute( 'morphTarget' + i );
+					if ( material.morphNormals === true ) geometry.removeAttribute( 'morphNormal' + i );
+
+				}
+
+			}
+
+			program.getUniforms().setValue(
+					_gl, 'morphTargetInfluences', morphInfluences );
+
+			updateBuffers = true;
+
+		}
+
+		//
+
+		var index = geometry.index;
+		var position = geometry.attributes.position;
+
+		if ( material.wireframe === true ) {
+
+			index = objects.getWireframeAttribute( geometry );
+
+		}
+
+		var renderer;
+
+		if ( index !== null ) {
+
+			renderer = indexedBufferRenderer;
+			renderer.setIndex( index );
+
+		} else {
+
+			renderer = bufferRenderer;
+
+		}
+
+		if ( updateBuffers ) {
+
+			setupVertexAttributes( material, program, geometry );
+
+			if ( index !== null ) {
+
+				_gl.bindBuffer( _gl.ELEMENT_ARRAY_BUFFER, objects.getAttributeBuffer( index ) );
+
+			}
+
+		}
+
+		//
+
+		var dataStart = 0;
+		var dataCount = Infinity;
+
+		if ( index !== null ) {
+
+			dataCount = index.count;
+
+		} else if ( position !== undefined ) {
+
+			dataCount = position.count;
+
+		}
+
+		var rangeStart = geometry.drawRange.start;
+		var rangeCount = geometry.drawRange.count;
+
+		var groupStart = group !== null ? group.start : 0;
+		var groupCount = group !== null ? group.count : Infinity;
+
+		var drawStart = Math.max( dataStart, rangeStart, groupStart );
+		var drawEnd = Math.min( dataStart + dataCount, rangeStart + rangeCount, groupStart + groupCount ) - 1;
+
+		var drawCount = Math.max( 0, drawEnd - drawStart + 1 );
+
+		//
+
+		if ( object instanceof THREE.Mesh ) {
+
+			if ( material.wireframe === true ) {
+
+				state.setLineWidth( material.wireframeLinewidth * getTargetPixelRatio() );
+				renderer.setMode( _gl.LINES );
+
+			} else {
+
+				switch ( object.drawMode ) {
+
+					case THREE.TrianglesDrawMode:
+						renderer.setMode( _gl.TRIANGLES );
+						break;
+
+					case THREE.TriangleStripDrawMode:
+						renderer.setMode( _gl.TRIANGLE_STRIP );
+						break;
+
+					case THREE.TriangleFanDrawMode:
+						renderer.setMode( _gl.TRIANGLE_FAN );
+						break;
+
+				}
+
+			}
+
+
+		} else if ( object instanceof THREE.Line ) {
+
+			var lineWidth = material.linewidth;
+
+			if ( lineWidth === undefined ) lineWidth = 1; // Not using Line*Material
+
+			state.setLineWidth( lineWidth * getTargetPixelRatio() );
+
+			if ( object instanceof THREE.LineSegments ) {
+
+				renderer.setMode( _gl.LINES );
+
+			} else {
+
+				renderer.setMode( _gl.LINE_STRIP );
+
+			}
+
+		} else if ( object instanceof THREE.Points ) {
+
+			renderer.setMode( _gl.POINTS );
+
+		}
+
+		if ( geometry instanceof THREE.InstancedBufferGeometry ) {
+
+			if ( geometry.maxInstancedCount > 0 ) {
+
+				renderer.renderInstances( geometry, drawStart, drawCount );
+
+			}
+
+		} else {
+
+			renderer.render( drawStart, drawCount );
+
+		}
+
+	};
+
+	function setupVertexAttributes( material, program, geometry, startIndex ) {
+
+		var extension;
+
+		if ( geometry instanceof THREE.InstancedBufferGeometry ) {
+
+			extension = extensions.get( 'ANGLE_instanced_arrays' );
+
+			if ( extension === null ) {
+
+				console.error( 'THREE.WebGLRenderer.setupVertexAttributes: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );
+				return;
+
+			}
+
+		}
+
+		if ( startIndex === undefined ) startIndex = 0;
+
+		state.initAttributes();
+
+		var geometryAttributes = geometry.attributes;
+
+		var programAttributes = program.getAttributes();
+
+		var materialDefaultAttributeValues = material.defaultAttributeValues;
+
+		for ( var name in programAttributes ) {
+
+			var programAttribute = programAttributes[ name ];
+
+			if ( programAttribute >= 0 ) {
+
+				var geometryAttribute = geometryAttributes[ name ];
+
+				if ( geometryAttribute !== undefined ) {
+
+					var type = _gl.FLOAT;
+					var array = geometryAttribute.array;
+					var normalized = geometryAttribute.normalized;
+
+					if ( array instanceof Float32Array ) {
+
+						type = _gl.FLOAT;
+
+					} else if ( array instanceof Float64Array ) {
+
+						console.warn("Unsupported data buffer format: Float64Array");
+
+					} else if ( array instanceof Uint16Array ) {
+
+						type = _gl.UNSIGNED_SHORT;
+
+					} else if ( array instanceof Int16Array ) {
+
+						type = _gl.SHORT;
+
+					} else if ( array instanceof Uint32Array ) {
+
+						type = _gl.UNSIGNED_INT;
+
+					} else if ( array instanceof Int32Array ) {
+
+						type = _gl.INT;
+
+					} else if ( array instanceof Int8Array ) {
+
+						type = _gl.BYTE;
+
+					} else if ( array instanceof Uint8Array ) {
+
+						type = _gl.UNSIGNED_BYTE;
+
+					}
+
+					var size = geometryAttribute.itemSize;
+					var buffer = objects.getAttributeBuffer( geometryAttribute );
+
+					if ( geometryAttribute instanceof THREE.InterleavedBufferAttribute ) {
+
+						var data = geometryAttribute.data;
+						var stride = data.stride;
+						var offset = geometryAttribute.offset;
+
+						if ( data instanceof THREE.InstancedInterleavedBuffer ) {
+
+							state.enableAttributeAndDivisor( programAttribute, data.meshPerAttribute, extension );
+
+							if ( geometry.maxInstancedCount === undefined ) {
+
+								geometry.maxInstancedCount = data.meshPerAttribute * data.count;
+
+							}
+
+						} else {
+
+							state.enableAttribute( programAttribute );
+
+						}
+
+						_gl.bindBuffer( _gl.ARRAY_BUFFER, buffer );
+						_gl.vertexAttribPointer( programAttribute, size, type, normalized, stride * data.array.BYTES_PER_ELEMENT, ( startIndex * stride + offset ) * data.array.BYTES_PER_ELEMENT );
+
+					} else {
+
+						if ( geometryAttribute instanceof THREE.InstancedBufferAttribute ) {
+
+							state.enableAttributeAndDivisor( programAttribute, geometryAttribute.meshPerAttribute, extension );
+
+							if ( geometry.maxInstancedCount === undefined ) {
+
+								geometry.maxInstancedCount = geometryAttribute.meshPerAttribute * geometryAttribute.count;
+
+							}
+
+						} else {
+
+							state.enableAttribute( programAttribute );
+
+						}
+
+						_gl.bindBuffer( _gl.ARRAY_BUFFER, buffer );
+						_gl.vertexAttribPointer( programAttribute, size, type, normalized, 0, startIndex * size * geometryAttribute.array.BYTES_PER_ELEMENT );
+
+					}
+
+				} 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();
+
+	}
+
+	// Sorting
+
+	function absNumericalSort( a, b ) {
+
+		return Math.abs( b[ 0 ] ) - Math.abs( a[ 0 ] );
+
+	}
+
+	function painterSortStable ( a, b ) {
+
+		if ( a.object.renderOrder !== b.object.renderOrder ) {
+
+			return a.object.renderOrder - b.object.renderOrder;
+
+		} else if ( a.material.id !== b.material.id ) {
+
+			return a.material.id - b.material.id;
+
+		} else if ( a.z !== b.z ) {
+
+			return a.z - b.z;
+
+		} else {
+
+			return a.id - b.id;
+
+		}
+
+	}
+
+	function reversePainterSortStable ( a, b ) {
+
+		if ( a.object.renderOrder !== b.object.renderOrder ) {
+
+			return a.object.renderOrder - b.object.renderOrder;
+
+		} if ( a.z !== b.z ) {
+
+			return b.z - a.z;
+
+		} else {
+
+			return a.id - b.id;
+
+		}
+
+	}
+
+	// Rendering
+
+	this.render = function ( scene, camera, renderTarget, forceClear ) {
+
+		if ( camera instanceof THREE.Camera === false ) {
+
+			console.error( 'THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.' );
+			return;
+
+		}
+
+		var fog = scene.fog;
+
+		// reset caching for this frame
+
+		_currentGeometryProgram = '';
+		_currentMaterialId = - 1;
+		_currentCamera = null;
+
+		// update scene graph
+
+		if ( scene.autoUpdate === true ) scene.updateMatrixWorld();
+
+		// update camera matrices and frustum
+
+		if ( camera.parent === null ) camera.updateMatrixWorld();
+
+		camera.matrixWorldInverse.getInverse( camera.matrixWorld );
+
+		_projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );
+		_frustum.setFromMatrix( _projScreenMatrix );
+
+		lights.length = 0;
+
+		opaqueObjectsLastIndex = - 1;
+		transparentObjectsLastIndex = - 1;
+
+		sprites.length = 0;
+		lensFlares.length = 0;
+
+		setupGlobalClippingPlanes( this.clippingPlanes, camera );
+
+		projectObject( scene, camera );
+
+
+		opaqueObjects.length = opaqueObjectsLastIndex + 1;
+		transparentObjects.length = transparentObjectsLastIndex + 1;
+
+		if ( _this.sortObjects === true ) {
+
+			opaqueObjects.sort( painterSortStable );
+			transparentObjects.sort( reversePainterSortStable );
+
+		}
+
+		//
+
+		if ( _clippingEnabled ) {
+
+			_clipRenderingShadows = true;
+			setupClippingPlanes( null );
+
+		}
+
+		setupShadows( lights );
+
+		shadowMap.render( scene, camera );
+
+		setupLights( lights, camera );
+
+		if ( _clippingEnabled ) {
+
+			_clipRenderingShadows = false;
+			resetGlobalClippingState();
+
+		}
+
+		//
+
+		_infoRender.calls = 0;
+		_infoRender.vertices = 0;
+		_infoRender.faces = 0;
+		_infoRender.points = 0;
+
+		if ( renderTarget === undefined ) {
+
+			renderTarget = null;
+
+		}
+
+		this.setRenderTarget( renderTarget );
+
+		if ( this.autoClear || forceClear ) {
+
+			this.clear( this.autoClearColor, this.autoClearDepth, this.autoClearStencil );
+
+		}
+
+		//
+
+		if ( scene.overrideMaterial ) {
+
+			var overrideMaterial = scene.overrideMaterial;
+
+			renderObjects( opaqueObjects, camera, fog, overrideMaterial );
+			renderObjects( transparentObjects, camera, fog, overrideMaterial );
+
+		} else {
+
+			// opaque pass (front-to-back order)
+
+			state.setBlending( THREE.NoBlending );
+			renderObjects( opaqueObjects, camera, fog );
+
+			// transparent pass (back-to-front order)
+
+			renderObjects( transparentObjects, camera, fog );
+
+		}
+
+		// custom render plugins (post pass)
+
+		spritePlugin.render( scene, camera );
+		lensFlarePlugin.render( scene, camera, _currentViewport );
+
+		// Generate mipmap if we're using any kind of mipmap filtering
+
+		if ( renderTarget ) {
+
+			var texture = renderTarget.texture;
+
+			if ( texture.generateMipmaps && isPowerOfTwo( renderTarget ) &&
+					texture.minFilter !== THREE.NearestFilter &&
+					texture.minFilter !== THREE.LinearFilter ) {
+
+				updateRenderTargetMipmap( renderTarget );
+
+			}
+
+		}
+
+		// Ensure depth buffer writing is enabled so it can be cleared on next render
+
+		state.setDepthTest( true );
+		state.setDepthWrite( true );
+		state.setColorWrite( true );
+
+		// _gl.finish();
+
+	};
+
+	function pushRenderItem( object, geometry, material, z, group ) {
+
+		var array, index;
+
+		// allocate the next position in the appropriate array
+
+		if ( material.transparent ) {
+
+			array = transparentObjects;
+			index = ++ transparentObjectsLastIndex;
+
+		} else {
+
+			array = opaqueObjects;
+			index = ++ opaqueObjectsLastIndex;
+
+		}
+
+		// recycle existing render item or grow the array
+
+		var renderItem = array[ index ];
+
+		if ( renderItem !== undefined ) {
+
+			renderItem.id = object.id;
+			renderItem.object = object;
+			renderItem.geometry = geometry;
+			renderItem.material = material;
+			renderItem.z = _vector3.z;
+			renderItem.group = group;
+
+		} else {
+
+			renderItem = {
+				id: object.id,
+				object: object,
+				geometry: geometry,
+				material: material,
+				z: _vector3.z,
+				group: group
+			};
+
+			// assert( index === array.length );
+			array.push( renderItem );
+
+		}
+
+	}
+
+	function isObjectViewable( object ) {
+
+		var geometry = object.geometry;
+
+		if ( geometry.boundingSphere === null )
+			geometry.computeBoundingSphere();
+
+		var sphere = _sphere.
+				copy( geometry.boundingSphere ).
+				applyMatrix4( object.matrixWorld );
+
+		if ( ! _frustum.intersectsSphere( sphere ) ) return false;
+		if ( _numClippingPlanes === 0 ) return true;
+
+		var planes = _this.clippingPlanes,
+
+			center = sphere.center,
+			negRad = - sphere.radius,
+			i = 0;
+
+		do {
+
+			// out when deeper than radius in the negative halfspace
+			if ( planes[ i ].distanceToPoint( center ) < negRad ) return false;
+
+		} while ( ++ i !== _numClippingPlanes );
+
+		return true;
+
+	}
+
+	function projectObject( object, camera ) {
+
+		if ( object.visible === false ) return;
+
+		if ( object.layers.test( camera.layers ) ) {
+
+			if ( object instanceof THREE.Light ) {
+
+				lights.push( object );
+
+			} else if ( object instanceof THREE.Sprite ) {
+
+				if ( object.frustumCulled === false || isObjectViewable( object ) === true ) {
+
+					sprites.push( object );
+
+				}
+
+			} else if ( object instanceof THREE.LensFlare ) {
+
+				lensFlares.push( object );
+
+			} else if ( object instanceof THREE.ImmediateRenderObject ) {
+
+				if ( _this.sortObjects === true ) {
+
+					_vector3.setFromMatrixPosition( object.matrixWorld );
+					_vector3.applyProjection( _projScreenMatrix );
+
+				}
+
+				pushRenderItem( object, null, object.material, _vector3.z, null );
+
+			} else if ( object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Points ) {
+
+				if ( object instanceof THREE.SkinnedMesh ) {
+
+					object.skeleton.update();
+
+				}
+
+				if ( object.frustumCulled === false || isObjectViewable( object ) === true ) {
+
+					var material = object.material;
+
+					if ( material.visible === true ) {
+
+						if ( _this.sortObjects === true ) {
+
+							_vector3.setFromMatrixPosition( object.matrixWorld );
+							_vector3.applyProjection( _projScreenMatrix );
+
+						}
+
+						var geometry = objects.update( object );
+
+						if ( material instanceof THREE.MultiMaterial ) {
+
+							var groups = geometry.groups;
+							var materials = material.materials;
+
+							for ( var i = 0, l = groups.length; i < l; i ++ ) {
+
+								var group = groups[ i ];
+								var groupMaterial = materials[ group.materialIndex ];
+
+								if ( groupMaterial.visible === true ) {
+
+									pushRenderItem( object, geometry, groupMaterial, _vector3.z, group );
+
+								}
+
+							}
+
+						} else {
+
+							pushRenderItem( object, geometry, material, _vector3.z, null );
+
+						}
+
+					}
+
+				}
+
+			}
+
+		}
+
+		var children = object.children;
+
+		for ( var i = 0, l = children.length; i < l; i ++ ) {
+
+			projectObject( children[ i ], camera );
+
+		}
+
+	}
+
+	function renderObjects( renderList, camera, fog, overrideMaterial ) {
+
+		for ( var i = 0, l = renderList.length; i < l; i ++ ) {
+
+			var renderItem = renderList[ i ];
+
+			var object = renderItem.object;
+			var geometry = renderItem.geometry;
+			var material = overrideMaterial === undefined ? renderItem.material : overrideMaterial;
+			var group = renderItem.group;
+
+			object.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld );
+			object.normalMatrix.getNormalMatrix( object.modelViewMatrix );
+
+			if ( object instanceof THREE.ImmediateRenderObject ) {
+
+				setMaterial( material );
+
+				var program = setProgram( camera, fog, material, object );
+
+				_currentGeometryProgram = '';
+
+				object.render( function ( object ) {
+
+					_this.renderBufferImmediate( object, program, material );
+
+				} );
+
+			} else {
+
+				_this.renderBufferDirect( camera, fog, geometry, material, object, group );
+
+			}
+
+		}
+
+	}
+
+	function initMaterial( material, fog, object ) {
+
+		var materialProperties = properties.get( material );
+
+		var parameters = programCache.getParameters(
+				material, _lights, fog, _numClippingPlanes, object );
+
+		var code = programCache.getProgramCode( material, parameters );
+
+		var program = materialProperties.program;
+		var programChange = true;
+
+		if ( program === undefined ) {
+
+			// new material
+			material.addEventListener( 'dispose', onMaterialDispose );
+
+		} else if ( program.code !== code ) {
+
+			// changed glsl or parameters
+			releaseMaterialProgramReference( material );
+
+		} else if ( parameters.shaderID !== undefined ) {
+
+			// same glsl and uniform list
+			return;
+
+		} else {
+
+			// only rebuild uniform list
+			programChange = false;
+
+		}
+
+		if ( programChange ) {
+
+			if ( parameters.shaderID ) {
+
+				var shader = THREE.ShaderLib[ parameters.shaderID ];
+
+				materialProperties.__webglShader = {
+					name: material.type,
+					uniforms: THREE.UniformsUtils.clone( shader.uniforms ),
+					vertexShader: shader.vertexShader,
+					fragmentShader: shader.fragmentShader
+				};
+
+			} else {
+
+				materialProperties.__webglShader = {
+					name: material.type,
+					uniforms: material.uniforms,
+					vertexShader: material.vertexShader,
+					fragmentShader: material.fragmentShader
+				};
+
+			}
+
+			material.__webglShader = materialProperties.__webglShader;
+
+			program = programCache.acquireProgram( material, parameters, code );
+
+			materialProperties.program = program;
+			material.program = program;
+
+		}
+
+		var attributes = program.getAttributes();
+
+		if ( material.morphTargets ) {
+
+			material.numSupportedMorphTargets = 0;
+
+			for ( var i = 0; i < _this.maxMorphTargets; i ++ ) {
+
+				if ( attributes[ 'morphTarget' + i ] >= 0 ) {
+
+					material.numSupportedMorphTargets ++;
+
+				}
+
+			}
+
+		}
+
+		if ( material.morphNormals ) {
+
+			material.numSupportedMorphNormals = 0;
+
+			for ( var i = 0; i < _this.maxMorphNormals; i ++ ) {
+
+				if ( attributes[ 'morphNormal' + i ] >= 0 ) {
+
+					material.numSupportedMorphNormals ++;
+
+				}
+
+			}
+
+		}
+
+		var uniforms = materialProperties.__webglShader.uniforms;
+
+		if ( ! ( material instanceof THREE.ShaderMaterial ) &&
+				! ( material instanceof THREE.RawShaderMaterial ) ||
+				material.clipping === true ) {
+
+			materialProperties.numClippingPlanes = _numClippingPlanes;
+			uniforms.clippingPlanes = _clippingPlanesUniform;
+
+		}
+
+		if ( material instanceof THREE.MeshPhongMaterial ||
+				material instanceof THREE.MeshLambertMaterial ||
+				material instanceof THREE.MeshStandardMaterial ||
+				material.lights ) {
+
+			// store the light setup it was created for
+
+			materialProperties.lightsHash = _lights.hash;
+
+			// wire up the material to this renderer's lighting state
+
+			uniforms.ambientLightColor.value = _lights.ambient;
+			uniforms.directionalLights.value = _lights.directional;
+			uniforms.spotLights.value = _lights.spot;
+			uniforms.pointLights.value = _lights.point;
+			uniforms.hemisphereLights.value = _lights.hemi;
+
+			uniforms.directionalShadowMap.value = _lights.directionalShadowMap;
+			uniforms.directionalShadowMatrix.value = _lights.directionalShadowMatrix;
+			uniforms.spotShadowMap.value = _lights.spotShadowMap;
+			uniforms.spotShadowMatrix.value = _lights.spotShadowMatrix;
+			uniforms.pointShadowMap.value = _lights.pointShadowMap;
+			uniforms.pointShadowMatrix.value = _lights.pointShadowMatrix;
+
+		}
+
+		var progUniforms = materialProperties.program.getUniforms(),
+			uniformsList =
+					THREE.WebGLUniforms.seqWithValue( progUniforms.seq, uniforms );
+
+		materialProperties.uniformsList = uniformsList;
+		materialProperties.dynamicUniforms =
+				THREE.WebGLUniforms.splitDynamic( uniformsList, uniforms );
+
+	}
+
+	function setMaterial( material ) {
+
+		setMaterialFaces( material );
+
+		if ( material.transparent === true ) {
+
+			state.setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.premultipliedAlpha );
+
+		} else {
+
+			state.setBlending( THREE.NoBlending );
+
+		}
+
+		state.setDepthFunc( material.depthFunc );
+		state.setDepthTest( material.depthTest );
+		state.setDepthWrite( material.depthWrite );
+		state.setColorWrite( material.colorWrite );
+		state.setPolygonOffset( material.polygonOffset, material.polygonOffsetFactor, material.polygonOffsetUnits );
+
+	}
+
+	function setMaterialFaces( material ) {
+
+		material.side !== THREE.DoubleSide ? state.enable( _gl.CULL_FACE ) : state.disable( _gl.CULL_FACE );
+		state.setFlipSided( material.side === THREE.BackSide );
+
+	}
+
+	function setProgram( camera, fog, material, object ) {
+
+		_usedTextureUnits = 0;
+
+		var materialProperties = properties.get( material );
+
+		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)
+				setClippingState(
+						material.clippingPlanes, material.clipShadows,
+						camera, materialProperties, useCache );
+
+			}
+
+			if ( materialProperties.numClippingPlanes !== undefined &&
+				materialProperties.numClippingPlanes !== _numClippingPlanes ) {
+
+				material.needsUpdate = true;
+
+			}
+
+		}
+
+		if ( materialProperties.program === undefined ) {
+
+			material.needsUpdate = true;
+
+		}
+
+		if ( materialProperties.lightsHash !== undefined &&
+			materialProperties.lightsHash !== _lights.hash ) {
+
+			material.needsUpdate = true;
+
+		}
+
+		if ( material.needsUpdate ) {
+
+			initMaterial( material, fog, object );
+			material.needsUpdate = false;
+
+		}
+
+		var refreshProgram = false;
+		var refreshMaterial = false;
+		var refreshLights = false;
+
+		var program = materialProperties.program,
+			p_uniforms = program.getUniforms(),
+			m_uniforms = materialProperties.__webglShader.uniforms;
+
+		if ( program.id !== _currentProgram ) {
+
+			_gl.useProgram( program.program );
+			_currentProgram = program.id;
+
+			refreshProgram = true;
+			refreshMaterial = true;
+			refreshLights = true;
+
+		}
+
+		if ( material.id !== _currentMaterialId ) {
+
+			_currentMaterialId = material.id;
+
+			refreshMaterial = true;
+
+		}
+
+		if ( refreshProgram || camera !== _currentCamera ) {
+
+			p_uniforms.set( _gl, camera, 'projectionMatrix' );
+
+			if ( capabilities.logarithmicDepthBuffer ) {
+
+				p_uniforms.setValue( _gl, 'logDepthBufFC',
+						2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );
+
+			}
+
+
+			if ( camera !== _currentCamera ) {
+
+				_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 instanceof THREE.ShaderMaterial ||
+				 material instanceof THREE.MeshPhongMaterial ||
+				 material instanceof THREE.MeshStandardMaterial ||
+				 material.envMap ) {
+
+				var uCamPos = p_uniforms.map.cameraPosition;
+
+				if ( uCamPos !== undefined ) {
+
+					uCamPos.setValue( _gl,
+							_vector3.setFromMatrixPosition( camera.matrixWorld ) );
+
+				}
+
+			}
+
+			if ( material instanceof THREE.MeshPhongMaterial ||
+				 material instanceof THREE.MeshLambertMaterial ||
+				 material instanceof THREE.MeshBasicMaterial ||
+				 material instanceof THREE.MeshStandardMaterial ||
+				 material instanceof THREE.ShaderMaterial ||
+				 material.skinning ) {
+
+				p_uniforms.setValue( _gl, 'viewMatrix', camera.matrixWorldInverse );
+
+			}
+
+			p_uniforms.set( _gl, _this, 'toneMappingExposure' );
+			p_uniforms.set( _gl, _this, 'toneMappingWhitePoint' );
+
+		}
+
+		// skinning uniforms must be set even if material didn't change
+		// auto-setting of texture unit for bone texture must go before other textures
+		// not sure why, but otherwise weird things happen
+
+		if ( material.skinning ) {
+
+			p_uniforms.setOptional( _gl, object, 'bindMatrix' );
+			p_uniforms.setOptional( _gl, object, 'bindMatrixInverse' );
+
+			var skeleton = object.skeleton;
+
+			if ( skeleton ) {
+
+				if ( capabilities.floatVertexTextures && skeleton.useVertexTexture ) {
+
+					p_uniforms.set( _gl, skeleton, 'boneTexture' );
+					p_uniforms.set( _gl, skeleton, 'boneTextureWidth' );
+					p_uniforms.set( _gl, skeleton, 'boneTextureHeight' );
+
+				} else {
+
+					p_uniforms.setOptional( _gl, skeleton, 'boneMatrices' );
+
+				}
+
+			}
+
+		}
+
+		if ( refreshMaterial ) {
+
+			if ( material instanceof THREE.MeshPhongMaterial ||
+				 material instanceof THREE.MeshLambertMaterial ||
+				 material instanceof THREE.MeshStandardMaterial ||
+				 material.lights ) {
+
+				// 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 instanceof THREE.MeshBasicMaterial ||
+				 material instanceof THREE.MeshLambertMaterial ||
+				 material instanceof THREE.MeshPhongMaterial ||
+				 material instanceof THREE.MeshStandardMaterial ||
+				 material instanceof THREE.MeshDepthMaterial ) {
+
+				refreshUniformsCommon( m_uniforms, material );
+
+			}
+
+			// refresh single material specific uniforms
+
+			if ( material instanceof THREE.LineBasicMaterial ) {
+
+				refreshUniformsLine( m_uniforms, material );
+
+			} else if ( material instanceof THREE.LineDashedMaterial ) {
+
+				refreshUniformsLine( m_uniforms, material );
+				refreshUniformsDash( m_uniforms, material );
+
+			} else if ( material instanceof THREE.PointsMaterial ) {
+
+				refreshUniformsPoints( m_uniforms, material );
+
+			} else if ( material instanceof THREE.MeshLambertMaterial ) {
+
+				refreshUniformsLambert( m_uniforms, material );
+
+			} else if ( material instanceof THREE.MeshPhongMaterial ) {
+
+				refreshUniformsPhong( m_uniforms, material );
+
+			} else if ( material instanceof THREE.MeshPhysicalMaterial ) {
+
+				refreshUniformsPhysical( m_uniforms, material );
+
+			} else if ( material instanceof THREE.MeshStandardMaterial ) {
+
+				refreshUniformsStandard( m_uniforms, material );
+
+			} else if ( material instanceof THREE.MeshDepthMaterial ) {
+
+				if ( material.displacementMap ) {
+
+					m_uniforms.displacementMap.value = material.displacementMap;
+					m_uniforms.displacementScale.value = material.displacementScale;
+					m_uniforms.displacementBias.value = material.displacementBias;
+
+				}
+
+			} else if ( material instanceof THREE.MeshNormalMaterial ) {
+
+				m_uniforms.opacity.value = material.opacity;
+
+			}
+
+			THREE.WebGLUniforms.upload(
+					_gl, materialProperties.uniformsList, m_uniforms, _this );
+
+		}
+
+
+		// common matrices
+
+		p_uniforms.set( _gl, object, 'modelViewMatrix' );
+		p_uniforms.set( _gl, object, 'normalMatrix' );
+		p_uniforms.setValue( _gl, 'modelMatrix', object.matrixWorld );
+
+
+		// dynamic uniforms
+
+		var dynUniforms = materialProperties.dynamicUniforms;
+
+		if ( dynUniforms !== null ) {
+
+			THREE.WebGLUniforms.evalDynamic(
+					dynUniforms, m_uniforms, object, camera );
+
+			THREE.WebGLUniforms.upload( _gl, dynUniforms, m_uniforms, _this );
+
+		}
+
+		return program;
+
+	}
+
+	// Uniforms (refresh uniforms objects)
+
+	function refreshUniformsCommon ( uniforms, material ) {
+
+		uniforms.opacity.value = material.opacity;
+
+		uniforms.diffuse.value = material.color;
+
+		if ( material.emissive ) {
+
+			uniforms.emissive.value.copy( material.emissive ).multiplyScalar( material.emissiveIntensity );
+
+		}
+
+		uniforms.map.value = material.map;
+		uniforms.specularMap.value = material.specularMap;
+		uniforms.alphaMap.value = material.alphaMap;
+
+		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 ) {
+
+			if ( uvScaleMap instanceof THREE.WebGLRenderTarget ) {
+
+				uvScaleMap = uvScaleMap.texture;
+
+			}
+
+			var offset = uvScaleMap.offset;
+			var repeat = uvScaleMap.repeat;
+
+			uniforms.offsetRepeat.value.set( offset.x, offset.y, repeat.x, repeat.y );
+
+		}
+
+		uniforms.envMap.value = material.envMap;
+		uniforms.flipEnvMap.value = ( material.envMap instanceof THREE.WebGLRenderTargetCube ) ? 1 : - 1;
+
+		uniforms.reflectivity.value = material.reflectivity;
+		uniforms.refractionRatio.value = material.refractionRatio;
+
+	}
+
+	function refreshUniformsLine ( uniforms, material ) {
+
+		uniforms.diffuse.value = 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 = material.color;
+		uniforms.opacity.value = material.opacity;
+		uniforms.size.value = material.size * _pixelRatio;
+		uniforms.scale.value = _canvas.clientHeight * 0.5;
+
+		uniforms.map.value = material.map;
+
+		if ( material.map !== null ) {
+
+			var offset = material.map.offset;
+			var repeat = material.map.repeat;
+
+			uniforms.offsetRepeat.value.set( offset.x, offset.y, repeat.x, repeat.y );
+
+		}
+
+	}
+
+	function refreshUniformsFog ( uniforms, fog ) {
+
+		uniforms.fogColor.value = fog.color;
+
+		if ( fog instanceof THREE.Fog ) {
+
+			uniforms.fogNear.value = fog.near;
+			uniforms.fogFar.value = fog.far;
+
+		} else if ( fog instanceof THREE.FogExp2 ) {
+
+			uniforms.fogDensity.value = fog.density;
+
+		}
+
+	}
+
+	function refreshUniformsLambert ( uniforms, material ) {
+
+		if ( material.lightMap ) {
+
+			uniforms.lightMap.value = material.lightMap;
+			uniforms.lightMapIntensity.value = material.lightMapIntensity;
+
+		}
+
+		if ( material.emissiveMap ) {
+
+			uniforms.emissiveMap.value = material.emissiveMap;
+
+		}
+
+	}
+
+	function refreshUniformsPhong ( uniforms, material ) {
+
+		uniforms.specular.value = material.specular;
+		uniforms.shininess.value = Math.max( material.shininess, 1e-4 ); // to prevent pow( 0.0, 0.0 )
+
+		if ( material.lightMap ) {
+
+			uniforms.lightMap.value = material.lightMap;
+			uniforms.lightMapIntensity.value = material.lightMapIntensity;
+
+		}
+
+		if ( material.emissiveMap ) {
+
+			uniforms.emissiveMap.value = material.emissiveMap;
+
+		}
+
+		if ( material.bumpMap ) {
+
+			uniforms.bumpMap.value = material.bumpMap;
+			uniforms.bumpScale.value = material.bumpScale;
+
+		}
+
+		if ( material.normalMap ) {
+
+			uniforms.normalMap.value = material.normalMap;
+			uniforms.normalScale.value.copy( material.normalScale );
+
+		}
+
+		if ( material.displacementMap ) {
+
+			uniforms.displacementMap.value = material.displacementMap;
+			uniforms.displacementScale.value = material.displacementScale;
+			uniforms.displacementBias.value = material.displacementBias;
+
+		}
+
+	}
+
+	function refreshUniformsStandard ( uniforms, material ) {
+
+		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.lightMap ) {
+
+			uniforms.lightMap.value = material.lightMap;
+			uniforms.lightMapIntensity.value = material.lightMapIntensity;
+
+		}
+
+		if ( material.emissiveMap ) {
+
+			uniforms.emissiveMap.value = material.emissiveMap;
+
+		}
+
+		if ( material.bumpMap ) {
+
+			uniforms.bumpMap.value = material.bumpMap;
+			uniforms.bumpScale.value = material.bumpScale;
+
+		}
+
+		if ( material.normalMap ) {
+
+			uniforms.normalMap.value = material.normalMap;
+			uniforms.normalScale.value.copy( material.normalScale );
+
+		}
+
+		if ( material.displacementMap ) {
+
+			uniforms.displacementMap.value = material.displacementMap;
+			uniforms.displacementScale.value = material.displacementScale;
+			uniforms.displacementBias.value = material.displacementBias;
+
+		}
+
+		if ( material.envMap ) {
+
+			//uniforms.envMap.value = material.envMap; // part of uniforms common
+			uniforms.envMapIntensity.value = material.envMapIntensity;
+
+		}
+
+	}
+
+	function refreshUniformsPhysical ( uniforms, material ) {
+
+		refreshUniformsStandard( uniforms, material );
+
+	}
+
+	// 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.directionalLights.needsUpdate = value;
+		uniforms.pointLights.needsUpdate = value;
+		uniforms.spotLights.needsUpdate = value;
+		uniforms.hemisphereLights.needsUpdate = value;
+
+	}
+
+	// Lighting
+
+	function setupShadows ( lights ) {
+
+		var lightShadowsLength = 0;
+
+		for ( var i = 0, l = lights.length; i < l; i ++ ) {
+
+			var light = lights[ i ];
+
+			if ( light.castShadow ) {
+
+				_lights.shadows[ lightShadowsLength ++ ] = light;
+
+			}
+
+		}
+
+		_lights.shadows.length = lightShadowsLength;
+
+	}
+
+	function setupLights ( lights, camera ) {
+
+		var l, ll, light,
+		r = 0, g = 0, b = 0,
+		color,
+		intensity,
+		distance,
+
+		viewMatrix = camera.matrixWorldInverse,
+
+		directionalLength = 0,
+		pointLength = 0,
+		spotLength = 0,
+		hemiLength = 0;
+
+		for ( l = 0, ll = lights.length; l < ll; l ++ ) {
+
+			light = lights[ l ];
+
+			color = light.color;
+			intensity = light.intensity;
+			distance = light.distance;
+
+			if ( light instanceof THREE.AmbientLight ) {
+
+				r += color.r * intensity;
+				g += color.g * intensity;
+				b += color.b * intensity;
+
+			} else if ( light instanceof THREE.DirectionalLight ) {
+
+				var uniforms = lightCache.get( light );
+
+				uniforms.color.copy( light.color ).multiplyScalar( light.intensity );
+				uniforms.direction.setFromMatrixPosition( light.matrixWorld );
+				_vector3.setFromMatrixPosition( light.target.matrixWorld );
+				uniforms.direction.sub( _vector3 );
+				uniforms.direction.transformDirection( viewMatrix );
+
+				uniforms.shadow = light.castShadow;
+
+				if ( light.castShadow ) {
+
+					uniforms.shadowBias = light.shadow.bias;
+					uniforms.shadowRadius = light.shadow.radius;
+					uniforms.shadowMapSize = light.shadow.mapSize;
+
+				}
+
+				_lights.directionalShadowMap[ directionalLength ] = light.shadow.map;
+				_lights.directionalShadowMatrix[ directionalLength ] = light.shadow.matrix;
+				_lights.directional[ directionalLength ++ ] = uniforms;
+
+			} else if ( light instanceof THREE.SpotLight ) {
+
+				var uniforms = lightCache.get( light );
+
+				uniforms.position.setFromMatrixPosition( light.matrixWorld );
+				uniforms.position.applyMatrix4( viewMatrix );
+
+				uniforms.color.copy( color ).multiplyScalar( intensity );
+				uniforms.distance = distance;
+
+				uniforms.direction.setFromMatrixPosition( light.matrixWorld );
+				_vector3.setFromMatrixPosition( light.target.matrixWorld );
+				uniforms.direction.sub( _vector3 );
+				uniforms.direction.transformDirection( viewMatrix );
+
+				uniforms.coneCos = Math.cos( light.angle );
+				uniforms.penumbraCos = Math.cos( light.angle * ( 1 - light.penumbra ) );
+				uniforms.decay = ( light.distance === 0 ) ? 0.0 : light.decay;
+
+				uniforms.shadow = light.castShadow;
+
+				if ( light.castShadow ) {
+
+					uniforms.shadowBias = light.shadow.bias;
+					uniforms.shadowRadius = light.shadow.radius;
+					uniforms.shadowMapSize = light.shadow.mapSize;
+
+				}
+
+				_lights.spotShadowMap[ spotLength ] = light.shadow.map;
+				_lights.spotShadowMatrix[ spotLength ] = light.shadow.matrix;
+				_lights.spot[ spotLength ++ ] = uniforms;
+
+			} else if ( light instanceof THREE.PointLight ) {
+
+				var uniforms = lightCache.get( light );
+
+				uniforms.position.setFromMatrixPosition( light.matrixWorld );
+				uniforms.position.applyMatrix4( viewMatrix );
+
+				uniforms.color.copy( light.color ).multiplyScalar( light.intensity );
+				uniforms.distance = light.distance;
+				uniforms.decay = ( light.distance === 0 ) ? 0.0 : light.decay;
+
+				uniforms.shadow = light.castShadow;
+
+				if ( light.castShadow ) {
+
+					uniforms.shadowBias = light.shadow.bias;
+					uniforms.shadowRadius = light.shadow.radius;
+					uniforms.shadowMapSize = light.shadow.mapSize;
+
+				}
+
+				_lights.pointShadowMap[ pointLength ] = light.shadow.map;
+
+				if ( _lights.pointShadowMatrix[ pointLength ] === undefined ) {
+
+					_lights.pointShadowMatrix[ pointLength ] = new THREE.Matrix4();
+
+				}
+
+				// for point lights we set the shadow matrix to be a translation-only matrix
+				// equal to inverse of the light's position
+				_vector3.setFromMatrixPosition( light.matrixWorld ).negate();
+				_lights.pointShadowMatrix[ pointLength ].identity().setPosition( _vector3 );
+
+				_lights.point[ pointLength ++ ] = uniforms;
+
+			} else if ( light instanceof THREE.HemisphereLight ) {
+
+				var uniforms = lightCache.get( light );
+
+				uniforms.direction.setFromMatrixPosition( light.matrixWorld );
+				uniforms.direction.transformDirection( viewMatrix );
+				uniforms.direction.normalize();
+
+				uniforms.skyColor.copy( light.color ).multiplyScalar( intensity );
+				uniforms.groundColor.copy( light.groundColor ).multiplyScalar( intensity );
+
+				_lights.hemi[ hemiLength ++ ] = uniforms;
+
+			}
+
+		}
+
+		_lights.ambient[ 0 ] = r;
+		_lights.ambient[ 1 ] = g;
+		_lights.ambient[ 2 ] = b;
+
+		_lights.directional.length = directionalLength;
+		_lights.spot.length = spotLength;
+		_lights.point.length = pointLength;
+		_lights.hemi.length = hemiLength;
+
+		_lights.hash = directionalLength + ',' + pointLength + ',' + spotLength + ',' + hemiLength + ',' + _lights.shadows.length;
+
+	}
+
+	// Clipping
+
+	function setupGlobalClippingPlanes( planes, camera ) {
+
+		_clippingEnabled =
+				_this.clippingPlanes.length !== 0 ||
+				_this.localClippingEnabled ||
+				// enable state of previous frame - the clipping code has to
+				// run another frame in order to reset the state:
+				_numGlobalClippingPlanes !== 0 ||
+				_localClippingEnabled;
+
+		_localClippingEnabled = _this.localClippingEnabled;
+
+		_globalClippingState = setupClippingPlanes( planes, camera, 0 );
+		_numGlobalClippingPlanes = planes !== null ? planes.length : 0;
+
+	}
+
+	function setupClippingPlanes( planes, camera, dstOffset, skipTransform ) {
+
+		var nPlanes = planes !== null ? planes.length : 0,
+			dstArray = null;
+
+		if ( nPlanes !== 0 ) {
+
+			dstArray = _clippingPlanesUniform.value;
+
+			if ( skipTransform !== true || dstArray === null ) {
+
+				var flatSize = dstOffset + nPlanes * 4,
+					viewMatrix = camera.matrixWorldInverse,
+					viewNormalMatrix = _matrix3.getNormalMatrix( viewMatrix );
+
+				if ( dstArray === null || dstArray.length < flatSize ) {
+
+					dstArray = new Float32Array( flatSize );
+
+				}
+
+				for ( var i = 0, i4 = dstOffset; i !== nPlanes; ++ i, i4 += 4 ) {
+
+					var plane = _plane.copy( planes[ i ] ).
+							applyMatrix4( viewMatrix, viewNormalMatrix );
+
+					plane.normal.toArray( dstArray, i4 );
+					dstArray[ i4 + 3 ] = plane.constant;
+
+				}
+
+			}
+
+			_clippingPlanesUniform.value = dstArray;
+			_clippingPlanesUniform.needsUpdate = true;
+
+		}
+
+		_numClippingPlanes = nPlanes;
+		return dstArray;
+
+	}
+
+	function resetGlobalClippingState() {
+
+		if ( _clippingPlanesUniform.value !== _globalClippingState ) {
+
+			_clippingPlanesUniform.value = _globalClippingState;
+			_clippingPlanesUniform.needsUpdate = _numGlobalClippingPlanes > 0;
+
+		}
+
+		_numClippingPlanes = _numGlobalClippingPlanes;
+
+	}
+
+	function setClippingState( planes, clipShadows, camera, cache, fromCache ) {
+
+		if ( ! _localClippingEnabled ||
+				planes === null || planes.length === 0 ||
+				_clipRenderingShadows && ! clipShadows ) {
+			// there's no local clipping
+
+			if ( _clipRenderingShadows ) {
+				// there's no global clipping
+
+				setupClippingPlanes( null );
+
+			} else {
+
+				resetGlobalClippingState();
+			}
+
+		} else {
+
+			var nGlobal = _clipRenderingShadows ? 0 : _numGlobalClippingPlanes,
+				lGlobal = nGlobal * 4,
+
+				dstArray = cache.clippingState || null;
+
+			_clippingPlanesUniform.value = dstArray; // ensure unique state
+
+			dstArray = setupClippingPlanes(
+					planes, camera, lGlobal, fromCache );
+
+			for ( var i = 0; i !== lGlobal; ++ i ) {
+
+				dstArray[ i ] = _globalClippingState[ i ];
+
+			}
+
+			cache.clippingState = dstArray;
+			_numClippingPlanes += nGlobal;
+
+		}
+
+	}
+
+
+	// GL state setting
+
+	this.setFaceCulling = function ( cullFace, frontFaceDirection ) {
+
+		if ( cullFace === THREE.CullFaceNone ) {
+
+			state.disable( _gl.CULL_FACE );
+
+		} else {
+
+			if ( frontFaceDirection === THREE.FrontFaceDirectionCW ) {
+
+				_gl.frontFace( _gl.CW );
+
+			} else {
+
+				_gl.frontFace( _gl.CCW );
+
+			}
+
+			if ( cullFace === THREE.CullFaceBack ) {
+
+				_gl.cullFace( _gl.BACK );
+
+			} else if ( cullFace === THREE.CullFaceFront ) {
+
+				_gl.cullFace( _gl.FRONT );
+
+			} else {
+
+				_gl.cullFace( _gl.FRONT_AND_BACK );
+
+			}
+
+			state.enable( _gl.CULL_FACE );
+
+		}
+
+	};
+
+	// Textures
+
+	function allocTextureUnit() {
+
+		var textureUnit = _usedTextureUnits;
+
+		if ( textureUnit >= capabilities.maxTextures ) {
+
+			console.warn( 'WebGLRenderer: trying to use ' + textureUnit + ' texture units while this GPU supports only ' + capabilities.maxTextures );
+
+		}
+
+		_usedTextureUnits += 1;
+
+		return textureUnit;
+
+	}
+
+	function setTextureParameters ( textureType, texture, isPowerOfTwoImage ) {
+
+		var extension;
+
+		if ( isPowerOfTwoImage ) {
+
+			_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, paramThreeToGL( texture.wrapS ) );
+			_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, paramThreeToGL( texture.wrapT ) );
+
+			_gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, paramThreeToGL( texture.magFilter ) );
+			_gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, paramThreeToGL( texture.minFilter ) );
+
+		} else {
+
+			_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, _gl.CLAMP_TO_EDGE );
+			_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, _gl.CLAMP_TO_EDGE );
+
+			if ( texture.wrapS !== THREE.ClampToEdgeWrapping || texture.wrapT !== THREE.ClampToEdgeWrapping ) {
+
+				console.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping.', texture );
+
+			}
+
+			_gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, filterFallback( texture.magFilter ) );
+			_gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, filterFallback( texture.minFilter ) );
+
+			if ( texture.minFilter !== THREE.NearestFilter && texture.minFilter !== THREE.LinearFilter ) {
+
+				console.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.', texture );
+
+			}
+
+		}
+
+		extension = extensions.get( 'EXT_texture_filter_anisotropic' );
+
+		if ( extension ) {
+
+			if ( texture.type === THREE.FloatType && extensions.get( 'OES_texture_float_linear' ) === null ) return;
+			if ( texture.type === THREE.HalfFloatType && extensions.get( 'OES_texture_half_float_linear' ) === null ) return;
+
+			if ( texture.anisotropy > 1 || properties.get( texture ).__currentAnisotropy ) {
+
+				_gl.texParameterf( textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min( texture.anisotropy, _this.getMaxAnisotropy() ) );
+				properties.get( texture ).__currentAnisotropy = texture.anisotropy;
+
+			}
+
+		}
+
+	}
+
+	function uploadTexture( textureProperties, texture, slot ) {
+
+		if ( textureProperties.__webglInit === undefined ) {
+
+			textureProperties.__webglInit = true;
+
+			texture.addEventListener( 'dispose', onTextureDispose );
+
+			textureProperties.__webglTexture = _gl.createTexture();
+
+			_infoMemory.textures ++;
+
+		}
+
+		state.activeTexture( _gl.TEXTURE0 + slot );
+		state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture );
+
+		_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY );
+		_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha );
+		_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, texture.unpackAlignment );
+
+		var image = clampToMaxSize( texture.image, capabilities.maxTextureSize );
+
+		if ( textureNeedsPowerOfTwo( texture ) && isPowerOfTwo( image ) === false ) {
+
+			image = makePowerOfTwo( image );
+
+		}
+
+		var isPowerOfTwoImage = isPowerOfTwo( image ),
+		glFormat = paramThreeToGL( texture.format ),
+		glType = paramThreeToGL( texture.type );
+
+		setTextureParameters( _gl.TEXTURE_2D, texture, isPowerOfTwoImage );
+
+		var mipmap, mipmaps = texture.mipmaps;
+
+		if ( texture instanceof THREE.DepthTexture ) {
+
+			// populate depth texture with dummy data
+
+			var internalFormat = _gl.DEPTH_COMPONENT;
+
+			if ( texture.type === THREE.FloatType ) {
+
+				if ( !_isWebGL2 ) throw new Error('Float Depth Texture only supported in WebGL2.0');
+				internalFormat = _gl.DEPTH_COMPONENT32F;
+
+			} else if ( _isWebGL2 ) {
+
+				// WebGL 2.0 requires signed internalformat for glTexImage2D
+				internalFormat = _gl.DEPTH_COMPONENT16;
+
+			}
+
+			state.texImage2D( _gl.TEXTURE_2D, 0, internalFormat, image.width, image.height, 0, glFormat, glType, null );
+
+		} else if ( texture instanceof THREE.DataTexture ) {
+
+			// 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 && isPowerOfTwoImage ) {
+
+				for ( var i = 0, il = mipmaps.length; i < il; i ++ ) {
+
+					mipmap = mipmaps[ i ];
+					state.texImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );
+
+				}
+
+				texture.generateMipmaps = false;
+
+			} else {
+
+				state.texImage2D( _gl.TEXTURE_2D, 0, glFormat, image.width, image.height, 0, glFormat, glType, image.data );
+
+			}
+
+		} else if ( texture instanceof THREE.CompressedTexture ) {
+
+			for ( var i = 0, il = mipmaps.length; i < il; i ++ ) {
+
+				mipmap = mipmaps[ i ];
+
+				if ( texture.format !== THREE.RGBAFormat && texture.format !== THREE.RGBFormat ) {
+
+					if ( state.getCompressedTextureFormats().indexOf( glFormat ) > - 1 ) {
+
+						state.compressedTexImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, mipmap.data );
+
+					} else {
+
+						console.warn( "THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()" );
+
+					}
+
+				} else {
+
+					state.texImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );
+
+				}
+
+			}
+
+		} else {
+
+			// regular Texture (image, video, canvas)
+
+			// 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 && isPowerOfTwoImage ) {
+
+				for ( var i = 0, il = mipmaps.length; i < il; i ++ ) {
+
+					mipmap = mipmaps[ i ];
+					state.texImage2D( _gl.TEXTURE_2D, i, glFormat, glFormat, glType, mipmap );
+
+				}
+
+				texture.generateMipmaps = false;
+
+			} else {
+
+				state.texImage2D( _gl.TEXTURE_2D, 0, glFormat, glFormat, glType, image );
+
+			}
+
+		}
+
+		if ( texture.generateMipmaps && isPowerOfTwoImage ) _gl.generateMipmap( _gl.TEXTURE_2D );
+
+		textureProperties.__version = texture.version;
+
+		if ( texture.onUpdate ) texture.onUpdate( texture );
+
+	}
+
+	function setTexture2D( texture, slot ) {
+
+		if ( texture instanceof THREE.WebGLRenderTarget ) texture = texture.texture;
+
+		var textureProperties = properties.get( 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', texture );
+				return;
+
+			}
+
+			if ( image.complete === false ) {
+
+				console.warn( 'THREE.WebGLRenderer: Texture marked for update but image is incomplete', texture );
+				return;
+
+			}
+
+			uploadTexture( textureProperties, texture, slot );
+
+			return;
+
+		}
+
+		state.activeTexture( _gl.TEXTURE0 + slot );
+		state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture );
+
+	}
+
+	function clampToMaxSize ( image, maxSize ) {
+
+		if ( image.width > maxSize || image.height > maxSize ) {
+
+			// Warning: Scaling through the canvas will only work with images that use
+			// premultiplied alpha.
+
+			var scale = maxSize / Math.max( image.width, image.height );
+
+			var canvas = document.createElement( 'canvas' );
+			canvas.width = Math.floor( image.width * scale );
+			canvas.height = Math.floor( image.height * scale );
+
+			var context = canvas.getContext( '2d' );
+			context.drawImage( image, 0, 0, image.width, image.height, 0, 0, canvas.width, canvas.height );
+
+			console.warn( 'THREE.WebGLRenderer: image is too big (' + image.width + 'x' + image.height + '). Resized to ' + canvas.width + 'x' + canvas.height, image );
+
+			return canvas;
+
+		}
+
+		return image;
+
+	}
+
+	function isPowerOfTwo( image ) {
+
+		return THREE.Math.isPowerOfTwo( image.width ) && THREE.Math.isPowerOfTwo( image.height );
+
+	}
+
+	function textureNeedsPowerOfTwo( texture ) {
+
+		if ( texture.wrapS !== THREE.ClampToEdgeWrapping || texture.wrapT !== THREE.ClampToEdgeWrapping ) return true;
+		if ( texture.minFilter !== THREE.NearestFilter && texture.minFilter !== THREE.LinearFilter ) return true;
+
+		return false;
+
+	}
+
+	function makePowerOfTwo( image ) {
+
+		if ( image instanceof HTMLImageElement || image instanceof HTMLCanvasElement ) {
+
+			var canvas = document.createElement( 'canvas' );
+			canvas.width = THREE.Math.nearestPowerOfTwo( image.width );
+			canvas.height = THREE.Math.nearestPowerOfTwo( image.height );
+
+			var context = canvas.getContext( '2d' );
+			context.drawImage( image, 0, 0, canvas.width, canvas.height );
+
+			console.warn( 'THREE.WebGLRenderer: image is not power of two (' + image.width + 'x' + image.height + '). Resized to ' + canvas.width + 'x' + canvas.height, image );
+
+			return canvas;
+
+		}
+
+		return image;
+
+	}
+
+	function setCubeTexture ( texture, slot ) {
+
+		var textureProperties = properties.get( texture );
+
+		if ( texture.image.length === 6 ) {
+
+			if ( texture.version > 0 && textureProperties.__version !== texture.version ) {
+
+				if ( ! textureProperties.__image__webglTextureCube ) {
+
+					texture.addEventListener( 'dispose', onTextureDispose );
+
+					textureProperties.__image__webglTextureCube = _gl.createTexture();
+
+					_infoMemory.textures ++;
+
+				}
+
+				state.activeTexture( _gl.TEXTURE0 + slot );
+				state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube );
+
+				_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY );
+
+				var isCompressed = texture instanceof THREE.CompressedTexture;
+				var isDataTexture = texture.image[ 0 ] instanceof THREE.DataTexture;
+
+				var cubeImage = [];
+
+				for ( var i = 0; i < 6; i ++ ) {
+
+					if ( _this.autoScaleCubemaps && ! isCompressed && ! isDataTexture ) {
+
+						cubeImage[ i ] = clampToMaxSize( texture.image[ i ], capabilities.maxCubemapSize );
+
+					} else {
+
+						cubeImage[ i ] = isDataTexture ? texture.image[ i ].image : texture.image[ i ];
+
+					}
+
+				}
+
+				var image = cubeImage[ 0 ],
+				isPowerOfTwoImage = isPowerOfTwo( image ),
+				glFormat = paramThreeToGL( texture.format ),
+				glType = paramThreeToGL( texture.type );
+
+				setTextureParameters( _gl.TEXTURE_CUBE_MAP, texture, isPowerOfTwoImage );
+
+				for ( var i = 0; i < 6; i ++ ) {
+
+					if ( ! isCompressed ) {
+
+						if ( isDataTexture ) {
+
+							state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glFormat, cubeImage[ i ].width, cubeImage[ i ].height, 0, glFormat, glType, cubeImage[ i ].data );
+
+						} else {
+
+							state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glFormat, glFormat, glType, cubeImage[ i ] );
+
+						}
+
+					} else {
+
+						var mipmap, mipmaps = cubeImage[ i ].mipmaps;
+
+						for ( var j = 0, jl = mipmaps.length; j < jl; j ++ ) {
+
+							mipmap = mipmaps[ j ];
+
+							if ( texture.format !== THREE.RGBAFormat && texture.format !== THREE.RGBFormat ) {
+
+								if ( state.getCompressedTextureFormats().indexOf( glFormat ) > - 1 ) {
+
+									state.compressedTexImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glFormat, mipmap.width, mipmap.height, 0, mipmap.data );
+
+								} else {
+
+									console.warn( "THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setCubeTexture()" );
+
+								}
+
+							} else {
+
+								state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );
+
+							}
+
+						}
+
+					}
+
+				}
+
+				if ( texture.generateMipmaps && isPowerOfTwoImage ) {
+
+					_gl.generateMipmap( _gl.TEXTURE_CUBE_MAP );
+
+				}
+
+				textureProperties.__version = texture.version;
+
+				if ( texture.onUpdate ) texture.onUpdate( texture );
+
+			} else {
+
+				state.activeTexture( _gl.TEXTURE0 + slot );
+				state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube );
+
+			}
+
+		}
+
+	}
+
+	function setCubeTextureDynamic ( texture, slot ) {
+
+		state.activeTexture( _gl.TEXTURE0 + slot );
+		state.bindTexture( _gl.TEXTURE_CUBE_MAP, properties.get( texture ).__webglTexture );
+
+	}
+
+	var setTextureWarned = false;
+	this.setTexture = function( texture, slot ) {
+
+		if ( ! setTextureWarned ) {
+
+			console.warn( "THREE.WebGLRenderer: .setTexture is deprecated, " +
+				"use setTexture2D instead." );
+			setTextureWarned = true;
+
+		}
+
+		setTexture2D( texture, slot );
+
+	};
+
+	this.allocTextureUnit = allocTextureUnit;
+	this.setTexture2D = setTexture2D;
+	this.setTextureCube = function( texture, slot ) {
+
+		if ( texture instanceof THREE.CubeTexture ||
+			 ( Array.isArray( texture.image ) && texture.image.length === 6 ) ) {
+
+			// CompressedTexture can have Array in image :/
+
+			setCubeTexture( texture, slot );
+
+		} else {
+			// assumed: texture instanceof THREE.WebGLRenderTargetCube
+
+			setCubeTextureDynamic( texture.texture, slot );
+
+		}
+
+	};
+
+	// Render targets
+
+	// Setup storage for target texture and bind it to correct framebuffer
+	function setupFrameBufferTexture ( framebuffer, renderTarget, attachment, textureTarget ) {
+
+		var glFormat = paramThreeToGL( renderTarget.texture.format );
+		var glType = paramThreeToGL( renderTarget.texture.type );
+		state.texImage2D( textureTarget, 0, glFormat, renderTarget.width, renderTarget.height, 0, glFormat, glType, null );
+		_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+		_gl.framebufferTexture2D( _gl.FRAMEBUFFER, attachment, textureTarget, properties.get( renderTarget.texture ).__webglTexture, 0 );
+		_gl.bindFramebuffer( _gl.FRAMEBUFFER, null );
+
+	}
+
+	// Setup storage for internal depth/stencil buffers and bind to correct framebuffer
+	function setupRenderBufferStorage ( renderbuffer, renderTarget ) {
+
+		_gl.bindRenderbuffer( _gl.RENDERBUFFER, renderbuffer );
+
+		if ( renderTarget.depthBuffer && ! renderTarget.stencilBuffer ) {
+
+			_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_COMPONENT16, renderTarget.width, renderTarget.height );
+			_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );
+
+		} else if ( renderTarget.depthBuffer && renderTarget.stencilBuffer ) {
+
+			_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_STENCIL, renderTarget.width, renderTarget.height );
+			_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );
+
+		} else {
+
+			// FIXME: We don't support !depth !stencil
+			_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.RGBA4, renderTarget.width, renderTarget.height );
+
+		}
+
+		_gl.bindRenderbuffer( _gl.RENDERBUFFER, null );
+
+	}
+
+	// Setup resources for a Depth Texture for a FBO (needs an extension)
+	function setupDepthTexture ( framebuffer, renderTarget ) {
+
+		var isCube = ( renderTarget instanceof THREE.WebGLRenderTargetCube );
+		if ( isCube ) throw new Error('Depth Texture with cube render targets is not supported!');
+
+		_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+
+		if ( !( renderTarget.depthTexture instanceof THREE.DepthTexture ) ) {
+
+			throw new Error('renderTarget.depthTexture must be an instance of THREE.DepthTexture');
+
+		}
+
+		// upload an empty depth texture with framebuffer size
+		if ( !properties.get( renderTarget.depthTexture ).__webglTexture ||
+				renderTarget.depthTexture.image.width !== renderTarget.width ||
+				renderTarget.depthTexture.image.height !== renderTarget.height ) {
+			renderTarget.depthTexture.image.width = renderTarget.width;
+			renderTarget.depthTexture.image.height = renderTarget.height;
+			renderTarget.depthTexture.needsUpdate = true;
+		}
+
+		_this.setTexture( renderTarget.depthTexture, 0 );
+
+		var webglDepthTexture = properties.get( renderTarget.depthTexture ).__webglTexture;
+		_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 );
+
+	}
+
+	// Setup GL resources for a non-texture depth buffer
+	function setupDepthRenderbuffer( renderTarget ) {
+
+		var renderTargetProperties = properties.get( renderTarget );
+
+		var isCube = ( renderTarget instanceof THREE.WebGLRenderTargetCube );
+
+		if ( renderTarget.depthTexture ) {
+
+			if ( isCube ) throw new Error('target.depthTexture not supported in Cube render targets');
+
+			setupDepthTexture( renderTargetProperties.__webglFramebuffer, renderTarget );
+
+		} else {
+
+			if ( isCube ) {
+
+				renderTargetProperties.__webglDepthbuffer = [];
+
+				for ( var i = 0; i < 6; i ++ ) {
+
+					_gl.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[ i ] );
+					renderTargetProperties.__webglDepthbuffer[ i ] = _gl.createRenderbuffer();
+					setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer[ i ], renderTarget );
+
+				}
+
+			} else {
+
+				_gl.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );
+				renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer();
+				setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer, renderTarget );
+
+			}
+
+		}
+
+		_gl.bindFramebuffer( _gl.FRAMEBUFFER, null );
+
+	}
+
+	// Set up GL resources for the render target
+	function setupRenderTarget( renderTarget ) {
+
+		var renderTargetProperties = properties.get( renderTarget );
+		var textureProperties = properties.get( renderTarget.texture );
+
+		renderTarget.addEventListener( 'dispose', onRenderTargetDispose );
+
+		textureProperties.__webglTexture = _gl.createTexture();
+
+		_infoMemory.textures ++;
+
+		var isCube = ( renderTarget instanceof THREE.WebGLRenderTargetCube );
+		var isTargetPowerOfTwo = THREE.Math.isPowerOfTwo( renderTarget.width ) && THREE.Math.isPowerOfTwo( renderTarget.height );
+
+		// Setup framebuffer
+
+		if ( isCube ) {
+
+			renderTargetProperties.__webglFramebuffer = [];
+
+			for ( var i = 0; i < 6; i ++ ) {
+
+				renderTargetProperties.__webglFramebuffer[ i ] = _gl.createFramebuffer();
+
+			}
+
+		} else {
+
+			renderTargetProperties.__webglFramebuffer = _gl.createFramebuffer();
+
+		}
+
+		// Setup color buffer
+
+		if ( isCube ) {
+
+			state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture );
+			setTextureParameters( _gl.TEXTURE_CUBE_MAP, renderTarget.texture, isTargetPowerOfTwo );
+
+			for ( var i = 0; i < 6; i ++ ) {
+
+				setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ i ], renderTarget, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i );
+
+			}
+
+			if ( renderTarget.texture.generateMipmaps && isTargetPowerOfTwo ) _gl.generateMipmap( _gl.TEXTURE_CUBE_MAP );
+			state.bindTexture( _gl.TEXTURE_CUBE_MAP, null );
+
+		} else {
+
+			state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture );
+			setTextureParameters( _gl.TEXTURE_2D, renderTarget.texture, isTargetPowerOfTwo );
+			setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D );
+
+			if ( renderTarget.texture.generateMipmaps && isTargetPowerOfTwo ) _gl.generateMipmap( _gl.TEXTURE_2D );
+			state.bindTexture( _gl.TEXTURE_2D, null );
+
+		}
+
+		// Setup depth and stencil buffers
+
+		if ( renderTarget.depthBuffer ) {
+
+			setupDepthRenderbuffer( renderTarget );
+
+		}
+
+	}
+
+	this.getCurrentRenderTarget = function() {
+
+		return _currentRenderTarget;
+
+	};
+
+	this.setRenderTarget = function ( renderTarget ) {
+
+		_currentRenderTarget = renderTarget;
+
+		if ( renderTarget && properties.get( renderTarget ).__webglFramebuffer === undefined ) {
+
+			setupRenderTarget( renderTarget );
+
+		}
+
+		var isCube = ( renderTarget instanceof THREE.WebGLRenderTargetCube );
+		var framebuffer;
+
+		if ( renderTarget ) {
+
+			var renderTargetProperties = properties.get( renderTarget );
+
+			if ( isCube ) {
+
+				framebuffer = renderTargetProperties.__webglFramebuffer[ renderTarget.activeCubeFace ];
+
+			} else {
+
+				framebuffer = renderTargetProperties.__webglFramebuffer;
+
+			}
+
+			_currentScissor.copy( renderTarget.scissor );
+			_currentScissorTest = renderTarget.scissorTest;
+
+			_currentViewport.copy( renderTarget.viewport );
+
+		} else {
+
+			framebuffer = null;
+
+			_currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio );
+			_currentScissorTest = _scissorTest;
+
+			_currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio );
+
+		}
+
+		if ( _currentFramebuffer !== framebuffer ) {
+
+			_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+			_currentFramebuffer = framebuffer;
+
+		}
+
+		state.scissor( _currentScissor );
+		state.setScissorTest( _currentScissorTest );
+
+		state.viewport( _currentViewport );
+
+		if ( isCube ) {
+
+			var textureProperties = properties.get( renderTarget.texture );
+			_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + renderTarget.activeCubeFace, textureProperties.__webglTexture, renderTarget.activeMipMapLevel );
+
+		}
+
+	};
+
+	this.readRenderTargetPixels = function ( renderTarget, x, y, width, height, buffer ) {
+
+		if ( renderTarget instanceof THREE.WebGLRenderTarget === false ) {
+
+			console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.' );
+			return;
+
+		}
+
+		var framebuffer = properties.get( renderTarget ).__webglFramebuffer;
+
+		if ( framebuffer ) {
+
+			var restore = false;
+
+			if ( framebuffer !== _currentFramebuffer ) {
+
+				_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
+
+				restore = true;
+
+			}
+
+			try {
+
+				var texture = renderTarget.texture;
+
+				if ( texture.format !== THREE.RGBAFormat && paramThreeToGL( texture.format ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_FORMAT ) ) {
+
+					console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.' );
+					return;
+
+				}
+
+				if ( texture.type !== THREE.UnsignedByteType &&
+				     paramThreeToGL( texture.type ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_TYPE ) &&
+				     ! ( texture.type === THREE.FloatType && extensions.get( 'WEBGL_color_buffer_float' ) ) &&
+				     ! ( texture.type === THREE.HalfFloatType && 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( _gl.FRAMEBUFFER ) === _gl.FRAMEBUFFER_COMPLETE ) {
+
+					// the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)
+
+					if ( ( x > 0 && x <= ( renderTarget.width - width ) ) && ( y > 0 && y <= ( renderTarget.height - height ) ) ) {
+
+						_gl.readPixels( x, y, width, height, paramThreeToGL( texture.format ), paramThreeToGL( texture.type ), buffer );
+
+					}
+
+				} else {
+
+					console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.' );
+
+				}
+
+			} finally {
+
+				if ( restore ) {
+
+					_gl.bindFramebuffer( _gl.FRAMEBUFFER, _currentFramebuffer );
+
+				}
+
+			}
+
+		}
+
+	};
+
+	function updateRenderTargetMipmap( renderTarget ) {
+
+		var target = renderTarget instanceof THREE.WebGLRenderTargetCube ? _gl.TEXTURE_CUBE_MAP : _gl.TEXTURE_2D;
+		var texture = properties.get( renderTarget.texture ).__webglTexture;
+
+		state.bindTexture( target, texture );
+		_gl.generateMipmap( target );
+		state.bindTexture( target, null );
+
+	}
+
+	// Fallback filters for non-power-of-2 textures
+
+	function filterFallback ( f ) {
+
+		if ( f === THREE.NearestFilter || f === THREE.NearestMipMapNearestFilter || f === THREE.NearestMipMapLinearFilter ) {
+
+			return _gl.NEAREST;
+
+		}
+
+		return _gl.LINEAR;
+
+	}
+
+	// Map three.js constants to WebGL constants
+
+	function paramThreeToGL ( p ) {
+
+		var extension;
+
+		if ( p === THREE.RepeatWrapping ) return _gl.REPEAT;
+		if ( p === THREE.ClampToEdgeWrapping ) return _gl.CLAMP_TO_EDGE;
+		if ( p === THREE.MirroredRepeatWrapping ) return _gl.MIRRORED_REPEAT;
+
+		if ( p === THREE.NearestFilter ) return _gl.NEAREST;
+		if ( p === THREE.NearestMipMapNearestFilter ) return _gl.NEAREST_MIPMAP_NEAREST;
+		if ( p === THREE.NearestMipMapLinearFilter ) return _gl.NEAREST_MIPMAP_LINEAR;
+
+		if ( p === THREE.LinearFilter ) return _gl.LINEAR;
+		if ( p === THREE.LinearMipMapNearestFilter ) return _gl.LINEAR_MIPMAP_NEAREST;
+		if ( p === THREE.LinearMipMapLinearFilter ) return _gl.LINEAR_MIPMAP_LINEAR;
+
+		if ( p === THREE.UnsignedByteType ) return _gl.UNSIGNED_BYTE;
+		if ( p === THREE.UnsignedShort4444Type ) return _gl.UNSIGNED_SHORT_4_4_4_4;
+		if ( p === THREE.UnsignedShort5551Type ) return _gl.UNSIGNED_SHORT_5_5_5_1;
+		if ( p === THREE.UnsignedShort565Type ) return _gl.UNSIGNED_SHORT_5_6_5;
+
+		if ( p === THREE.ByteType ) return _gl.BYTE;
+		if ( p === THREE.ShortType ) return _gl.SHORT;
+		if ( p === THREE.UnsignedShortType ) return _gl.UNSIGNED_SHORT;
+		if ( p === THREE.IntType ) return _gl.INT;
+		if ( p === THREE.UnsignedIntType ) return _gl.UNSIGNED_INT;
+		if ( p === THREE.FloatType ) return _gl.FLOAT;
+
+		extension = extensions.get( 'OES_texture_half_float' );
+
+		if ( extension !== null ) {
+
+			if ( p === THREE.HalfFloatType ) return extension.HALF_FLOAT_OES;
+
+		}
+
+		if ( p === THREE.AlphaFormat ) return _gl.ALPHA;
+		if ( p === THREE.RGBFormat ) return _gl.RGB;
+		if ( p === THREE.RGBAFormat ) return _gl.RGBA;
+		if ( p === THREE.LuminanceFormat ) return _gl.LUMINANCE;
+		if ( p === THREE.LuminanceAlphaFormat ) return _gl.LUMINANCE_ALPHA;
+		if ( p === THREE.DepthFormat ) return _gl.DEPTH_COMPONENT;
+
+		if ( p === THREE.AddEquation ) return _gl.FUNC_ADD;
+		if ( p === THREE.SubtractEquation ) return _gl.FUNC_SUBTRACT;
+		if ( p === THREE.ReverseSubtractEquation ) return _gl.FUNC_REVERSE_SUBTRACT;
+
+		if ( p === THREE.ZeroFactor ) return _gl.ZERO;
+		if ( p === THREE.OneFactor ) return _gl.ONE;
+		if ( p === THREE.SrcColorFactor ) return _gl.SRC_COLOR;
+		if ( p === THREE.OneMinusSrcColorFactor ) return _gl.ONE_MINUS_SRC_COLOR;
+		if ( p === THREE.SrcAlphaFactor ) return _gl.SRC_ALPHA;
+		if ( p === THREE.OneMinusSrcAlphaFactor ) return _gl.ONE_MINUS_SRC_ALPHA;
+		if ( p === THREE.DstAlphaFactor ) return _gl.DST_ALPHA;
+		if ( p === THREE.OneMinusDstAlphaFactor ) return _gl.ONE_MINUS_DST_ALPHA;
+
+		if ( p === THREE.DstColorFactor ) return _gl.DST_COLOR;
+		if ( p === THREE.OneMinusDstColorFactor ) return _gl.ONE_MINUS_DST_COLOR;
+		if ( p === THREE.SrcAlphaSaturateFactor ) return _gl.SRC_ALPHA_SATURATE;
+
+		extension = extensions.get( 'WEBGL_compressed_texture_s3tc' );
+
+		if ( extension !== null ) {
+
+			if ( p === THREE.RGB_S3TC_DXT1_Format ) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT;
+			if ( p === THREE.RGBA_S3TC_DXT1_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT;
+			if ( p === THREE.RGBA_S3TC_DXT3_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT;
+			if ( p === THREE.RGBA_S3TC_DXT5_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT;
+
+		}
+
+		extension = extensions.get( 'WEBGL_compressed_texture_pvrtc' );
+
+		if ( extension !== null ) {
+
+			if ( p === THREE.RGB_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
+			if ( p === THREE.RGB_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
+			if ( p === THREE.RGBA_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
+			if ( p === THREE.RGBA_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
+
+		}
+
+		extension = extensions.get( 'WEBGL_compressed_texture_etc1' );
+
+		if ( extension !== null ) {
+
+			if ( p === THREE.RGB_ETC1_Format ) return extension.COMPRESSED_RGB_ETC1_WEBGL;
+
+		}
+
+		extension = extensions.get( 'EXT_blend_minmax' );
+
+		if ( extension !== null ) {
+
+			if ( p === THREE.MinEquation ) return extension.MIN_EXT;
+			if ( p === THREE.MaxEquation ) return extension.MAX_EXT;
+
+		}
+
+		return 0;
+
+	}
+
+};
+
+// File:src/renderers/WebGLRenderTarget.js
+
+/**
+ * @author szimek / https://github.com/szimek/
+ * @author alteredq / http://alteredqualia.com/
+ * @author Marius Kintel / https://github.com/kintel
+ */
+
+/*
+ In options, we can specify:
+ * Texture parameters for an auto-generated target texture
+ * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers
+*/
+THREE.WebGLRenderTarget = function ( width, height, options ) {
+
+	this.uuid = THREE.Math.generateUUID();
+
+	this.width = width;
+	this.height = height;
+
+	this.scissor = new THREE.Vector4( 0, 0, width, height );
+	this.scissorTest = false;
+
+	this.viewport = new THREE.Vector4( 0, 0, width, height );
+
+	options = options || {};
+
+	if ( options.minFilter === undefined ) options.minFilter = THREE.LinearFilter;
+
+	this.texture = new THREE.Texture( undefined, undefined, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.encoding );
+
+	this.depthBuffer = options.depthBuffer !== undefined ? options.depthBuffer : true;
+	this.stencilBuffer = options.stencilBuffer !== undefined ? options.stencilBuffer : true;
+	this.depthTexture = null;
+
+};
+
+THREE.WebGLRenderTarget.prototype = {
+
+	constructor: THREE.WebGLRenderTarget,
+
+	setSize: function ( width, height ) {
+
+		if ( this.width !== width || this.height !== height ) {
+
+			this.width = width;
+			this.height = height;
+
+			this.dispose();
+
+		}
+
+		this.viewport.set( 0, 0, width, height );
+		this.scissor.set( 0, 0, width, height );
+
+	},
+
+	clone: function () {
+
+		return new this.constructor().copy( this );
+
+	},
+
+	copy: function ( source ) {
+
+		this.width = source.width;
+		this.height = source.height;
+
+		this.viewport.copy( source.viewport );
+
+		this.texture = source.texture.clone();
+
+		this.depthBuffer = source.depthBuffer;
+		this.stencilBuffer = source.stencilBuffer;
+		this.depthTexture = source.depthTexture;
+
+		return this;
+
+	},
+
+	dispose: function () {
+
+		this.dispatchEvent( { type: 'dispose' } );
+
+	}
+
+};
+
+THREE.EventDispatcher.prototype.apply( THREE.WebGLRenderTarget.prototype );
+
+// File:src/renderers/WebGLRenderTargetCube.js
+
+/**
+ * @author alteredq / http://alteredqualia.com
+ */
+
+THREE.WebGLRenderTargetCube = function ( width, height, options ) {
+
+	THREE.WebGLRenderTarget.call( this, width, height, options );
+
+	this.activeCubeFace = 0; // PX 0, NX 1, PY 2, NY 3, PZ 4, NZ 5
+	this.activeMipMapLevel = 0;
+
+};
+
+THREE.WebGLRenderTargetCube.prototype = Object.create( THREE.WebGLRenderTarget.prototype );
+THREE.WebGLRenderTargetCube.prototype.constructor = THREE.WebGLRenderTargetCube;
+
+// File:src/renderers/webgl/WebGLBufferRenderer.js
+
+/**
+* @author mrdoob / http://mrdoob.com/
+*/
+
+THREE.WebGLBufferRenderer = function ( _gl, extensions, _infoRender ) {
+
+	var mode;
+
+	function setMode( value ) {
+
+		mode = value;
+
+	}
+
+	function render( start, count ) {
+
+		_gl.drawArrays( mode, start, count );
+
+		_infoRender.calls ++;
+		_infoRender.vertices += count;
+		if ( mode === _gl.TRIANGLES ) _infoRender.faces += count / 3;
+
+	}
+
+	function renderInstances( geometry ) {
+
+		var extension = extensions.get( 'ANGLE_instanced_arrays' );
+
+		if ( extension === null ) {
+
+			console.error( 'THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );
+			return;
+
+		}
+
+		var position = geometry.attributes.position;
+
+		var count = 0;
+
+		if ( position instanceof THREE.InterleavedBufferAttribute ) {
+
+			count = position.data.count;
+
+			extension.drawArraysInstancedANGLE( mode, 0, count, geometry.maxInstancedCount );
+
+		} else {
+
+			count = position.count;
+
+			extension.drawArraysInstancedANGLE( mode, 0, count, geometry.maxInstancedCount );
+
+		}
+
+		_infoRender.calls ++;
+		_infoRender.vertices += count * geometry.maxInstancedCount;
+		if ( mode === _gl.TRIANGLES ) _infoRender.faces += geometry.maxInstancedCount * count / 3;
+
+	}
+
+	this.setMode = setMode;
+	this.render = render;
+	this.renderInstances = renderInstances;
+
+};
+
+// File:src/renderers/webgl/WebGLIndexedBufferRenderer.js
+
+/**
+* @author mrdoob / http://mrdoob.com/
+*/
+
+THREE.WebGLIndexedBufferRenderer = function ( _gl, extensions, _infoRender ) {
+
+	var mode;
+
+	function setMode( value ) {
+
+		mode = value;
+
+	}
+
+	var type, size;
+
+	function setIndex( index ) {
+
+		if ( index.array instanceof Uint32Array && extensions.get( 'OES_element_index_uint' ) ) {
+
+			type = _gl.UNSIGNED_INT;
+			size = 4;
+
+		} else {
+
+			type = _gl.UNSIGNED_SHORT;
+			size = 2;
+
+		}
+
+	}
+
+	function render( start, count ) {
+
+		_gl.drawElements( mode, count, type, start * size );
+
+		_infoRender.calls ++;
+		_infoRender.vertices += count;
+		if ( mode === _gl.TRIANGLES ) _infoRender.faces += count / 3;
+
+	}
+
+	function renderInstances( geometry, start, count ) {
+
+		var extension = extensions.get( 'ANGLE_instanced_arrays' );
+
+		if ( extension === null ) {
+
+			console.error( 'THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );
+			return;
+
+		}
+
+		extension.drawElementsInstancedANGLE( mode, count, type, start * size, geometry.maxInstancedCount );
+
+		_infoRender.calls ++;
+		_infoRender.vertices += count * geometry.maxInstancedCount;
+		if ( mode === _gl.TRIANGLES ) _infoRender.faces += geometry.maxInstancedCount * count / 3;
+	}
+
+	this.setMode = setMode;
+	this.setIndex = setIndex;
+	this.render = render;
+	this.renderInstances = renderInstances;
+
+};
+
+// File:src/renderers/webgl/WebGLExtensions.js
+
+/**
+* @author mrdoob / http://mrdoob.com/
+*/
+
+THREE.WebGLExtensions = function ( gl ) {
+
+	var extensions = {};
+
+	this.get = function ( name ) {
+
+		if ( extensions[ name ] !== undefined ) {
+
+			return extensions[ name ];
+
+		}
+
+		var extension;
+
+		switch ( name ) {
+
+			case 'WEBGL_depth_texture':
+				extension = gl.getExtension( 'WEBGL_depth_texture' ) || gl.getExtension( 'MOZ_WEBGL_depth_texture' ) || gl.getExtension( 'WEBKIT_WEBGL_depth_texture' );
+
+			case 'EXT_texture_filter_anisotropic':
+				extension = gl.getExtension( 'EXT_texture_filter_anisotropic' ) || gl.getExtension( 'MOZ_EXT_texture_filter_anisotropic' ) || gl.getExtension( 'WEBKIT_EXT_texture_filter_anisotropic' );
+				break;
+
+			case 'WEBGL_compressed_texture_s3tc':
+				extension = gl.getExtension( 'WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'MOZ_WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_s3tc' );
+				break;
+
+			case 'WEBGL_compressed_texture_pvrtc':
+				extension = gl.getExtension( 'WEBGL_compressed_texture_pvrtc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_pvrtc' );
+				break;
+
+			case 'WEBGL_compressed_texture_etc1':
+				extension = gl.getExtension( 'WEBGL_compressed_texture_etc1' );
+				break;
+
+			default:
+				extension = gl.getExtension( name );
+
+		}
+
+		if ( extension === null ) {
+
+			console.warn( 'THREE.WebGLRenderer: ' + name + ' extension not supported.' );
+
+		}
+
+		extensions[ name ] = extension;
+
+		return extension;
+
+	};
+
+};
+
+// File:src/renderers/webgl/WebGLCapabilities.js
+
+THREE.WebGLCapabilities = function ( gl, extensions, parameters ) {
+
+	function getMaxPrecision( precision ) {
+
+		if ( precision === 'highp' ) {
+
+			if ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.HIGH_FLOAT ).precision > 0 &&
+			     gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.HIGH_FLOAT ).precision > 0 ) {
+
+				return 'highp';
+
+			}
+
+			precision = 'mediump';
+
+		}
+
+		if ( precision === 'mediump' ) {
+
+			if ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.MEDIUM_FLOAT ).precision > 0 &&
+			     gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT ).precision > 0 ) {
+
+				return 'mediump';
+
+			}
+
+		}
+
+		return 'lowp';
+
+	}
+
+	this.getMaxPrecision = getMaxPrecision;
+
+	this.precision = parameters.precision !== undefined ? parameters.precision : 'highp',
+	this.logarithmicDepthBuffer = parameters.logarithmicDepthBuffer !== undefined ? parameters.logarithmicDepthBuffer : false;
+
+	this.maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS );
+	this.maxVertexTextures = gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS );
+	this.maxTextureSize = gl.getParameter( gl.MAX_TEXTURE_SIZE );
+	this.maxCubemapSize = gl.getParameter( gl.MAX_CUBE_MAP_TEXTURE_SIZE );
+
+	this.maxAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS );
+	this.maxVertexUniforms = gl.getParameter( gl.MAX_VERTEX_UNIFORM_VECTORS );
+	this.maxVaryings = gl.getParameter( gl.MAX_VARYING_VECTORS );
+	this.maxFragmentUniforms = gl.getParameter( gl.MAX_FRAGMENT_UNIFORM_VECTORS );
+
+	this.vertexTextures = this.maxVertexTextures > 0;
+	this.floatFragmentTextures = !! extensions.get( 'OES_texture_float' );
+	this.floatVertexTextures = this.vertexTextures && this.floatFragmentTextures;
+
+	var _maxPrecision = getMaxPrecision( this.precision );
+
+	if ( _maxPrecision !== this.precision ) {
+
+		console.warn( 'THREE.WebGLRenderer:', this.precision, 'not supported, using', _maxPrecision, 'instead.' );
+		this.precision = _maxPrecision;
+
+	}
+
+	if ( this.logarithmicDepthBuffer ) {
+
+		this.logarithmicDepthBuffer = !! extensions.get( 'EXT_frag_depth' );
+
+	}
+
+};
+
+// File:src/renderers/webgl/WebGLGeometries.js
+
+/**
+* @author mrdoob / http://mrdoob.com/
+*/
+
+THREE.WebGLGeometries = function ( gl, properties, info ) {
+
+	var geometries = {};
+
+	function get( object ) {
+
+		var geometry = object.geometry;
+
+		if ( geometries[ geometry.id ] !== undefined ) {
+
+			return geometries[ geometry.id ];
+
+		}
+
+		geometry.addEventListener( 'dispose', onGeometryDispose );
+
+		var buffergeometry;
+
+		if ( geometry instanceof THREE.BufferGeometry ) {
+
+			buffergeometry = geometry;
+
+		} else if ( geometry instanceof THREE.Geometry ) {
+
+			if ( geometry._bufferGeometry === undefined ) {
+
+				geometry._bufferGeometry = new THREE.BufferGeometry().setFromObject( object );
+
+			}
+
+			buffergeometry = geometry._bufferGeometry;
+
+		}
+
+		geometries[ geometry.id ] = buffergeometry;
+
+		info.memory.geometries ++;
+
+		return buffergeometry;
+
+	}
+
+	function onGeometryDispose( event ) {
+
+		var geometry = event.target;
+		var buffergeometry = geometries[ geometry.id ];
+
+		if ( buffergeometry.index !== null ) {
+
+			deleteAttribute( buffergeometry.index );
+
+		}
+
+		deleteAttributes( buffergeometry.attributes );
+
+		geometry.removeEventListener( 'dispose', onGeometryDispose );
+
+		delete geometries[ geometry.id ];
+
+		// TODO
+
+		var property = properties.get( geometry );
+
+		if ( property.wireframe ) {
+
+			deleteAttribute( property.wireframe );
+
+		}
+
+		properties.delete( geometry );
+
+		var bufferproperty = properties.get( buffergeometry );
+
+		if ( bufferproperty.wireframe ) {
+
+			deleteAttribute( bufferproperty.wireframe );
+
+		}
+
+		properties.delete( buffergeometry );
+
+		//
+
+		info.memory.geometries --;
+
+	}
+
+	function getAttributeBuffer( attribute ) {
+
+		if ( attribute instanceof THREE.InterleavedBufferAttribute ) {
+
+			return properties.get( attribute.data ).__webglBuffer;
+
+		}
+
+		return properties.get( attribute ).__webglBuffer;
+
+	}
+
+	function deleteAttribute( attribute ) {
+
+		var buffer = getAttributeBuffer( attribute );
+
+		if ( buffer !== undefined ) {
+
+			gl.deleteBuffer( buffer );
+			removeAttributeBuffer( attribute );
+
+		}
+
+	}
+
+	function deleteAttributes( attributes ) {
+
+		for ( var name in attributes ) {
+
+			deleteAttribute( attributes[ name ] );
+
+		}
+
+	}
+
+	function removeAttributeBuffer( attribute ) {
+
+		if ( attribute instanceof THREE.InterleavedBufferAttribute ) {
+
+			properties.delete( attribute.data );
+
+		} else {
+
+			properties.delete( attribute );
+
+		}
+
+	}
+
+	this.get = get;
+
+};
+
+// File:src/renderers/webgl/WebGLLights.js
+
+/**
+* @author mrdoob / http://mrdoob.com/
+*/
+
+THREE.WebGLLights = function () {
+
+	var lights = {};
+
+	this.get = function ( light ) {
+
+		if ( lights[ light.id ] !== undefined ) {
+
+			return lights[ light.id ];
+
+		}
+
+		var uniforms;
+
+		switch ( light.type ) {
+
+			case 'DirectionalLight':
+				uniforms = {
+					direction: new THREE.Vector3(),
+					color: new THREE.Color(),
+
+					shadow: false,
+					shadowBias: 0,
+					shadowRadius: 1,
+					shadowMapSize: new THREE.Vector2()
+				};
+				break;
+
+			case 'SpotLight':
+				uniforms = {
+					position: new THREE.Vector3(),
+					direction: new THREE.Vector3(),
+					color: new THREE.Color(),
+					distance: 0,
+					coneCos: 0,
+					penumbraCos: 0,
+					decay: 0,
+
+					shadow: false,
+					shadowBias: 0,
+					shadowRadius: 1,
+					shadowMapSize: new THREE.Vector2()
+				};
+				break;
+
+			case 'PointLight':
+				uniforms = {
+					position: new THREE.Vector3(),
+					color: new THREE.Color(),
+					distance: 0,
+					decay: 0,
+
+					shadow: false,
+					shadowBias: 0,
+					shadowRadius: 1,
+					shadowMapSize: new THREE.Vector2()
+				};
+				break;
+
+			case 'HemisphereLight':
+				uniforms = {
+					direction: new THREE.Vector3(),
+					skyColor: new THREE.Color(),
+					groundColor: new THREE.Color()
+				};
+				break;
+
+		}
+
+		lights[ light.id ] = uniforms;
+
+		return uniforms;
+
+	};
+
+};
+
+// File:src/renderers/webgl/WebGLObjects.js
+
+/**
+* @author mrdoob / http://mrdoob.com/
+*/
+
+THREE.WebGLObjects = function ( gl, properties, info ) {
+
+	var geometries = new THREE.WebGLGeometries( gl, properties, info );
+
+	//
+
+	function update( object ) {
+
+		// TODO: Avoid updating twice (when using shadowMap). Maybe add frame counter.
+
+		var geometry = geometries.get( object );
+
+		if ( object.geometry instanceof THREE.Geometry ) {
+
+			geometry.updateFromObject( object );
+
+		}
+
+		var index = geometry.index;
+		var attributes = geometry.attributes;
+
+		if ( index !== null ) {
+
+			updateAttribute( index, gl.ELEMENT_ARRAY_BUFFER );
+
+		}
+
+		for ( var name in attributes ) {
+
+			updateAttribute( attributes[ name ], gl.ARRAY_BUFFER );
+
+		}
+
+		// morph targets
+
+		var morphAttributes = geometry.morphAttributes;
+
+		for ( var name in morphAttributes ) {
+
+			var array = morphAttributes[ name ];
+
+			for ( var i = 0, l = array.length; i < l; i ++ ) {
+
+				updateAttribute( array[ i ], gl.ARRAY_BUFFER );
+
+			}
+
+		}
+
+		return geometry;
+
+	}
+
+	function updateAttribute( attribute, bufferType ) {
+
+		var data = ( attribute instanceof THREE.InterleavedBufferAttribute ) ? attribute.data : attribute;
+
+		var attributeProperties = properties.get( data );
+
+		if ( attributeProperties.__webglBuffer === undefined ) {
+
+			createBuffer( attributeProperties, data, bufferType );
+
+		} else if ( attributeProperties.version !== data.version ) {
+
+			updateBuffer( attributeProperties, data, bufferType );
+
+		}
+
+	}
+
+	function createBuffer( attributeProperties, data, bufferType ) {
+
+		attributeProperties.__webglBuffer = gl.createBuffer();
+		gl.bindBuffer( bufferType, attributeProperties.__webglBuffer );
+
+		var usage = data.dynamic ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW;
+
+		gl.bufferData( bufferType, data.array, usage );
+
+		attributeProperties.version = data.version;
+
+	}
+
+	function updateBuffer( attributeProperties, data, bufferType ) {
+
+		gl.bindBuffer( bufferType, attributeProperties.__webglBuffer );
+
+		if ( data.dynamic === false || data.updateRange.count === - 1 ) {
+
+			// Not using update ranges
+
+			gl.bufferSubData( bufferType, 0, data.array );
+
+		} else if ( data.updateRange.count === 0 ) {
+
+			console.error( 'THREE.WebGLObjects.updateBuffer: dynamic THREE.BufferAttribute marked as needsUpdate but updateRange.count is 0, ensure you are using set methods or updating manually.' );
+
+		} else {
+
+			gl.bufferSubData( bufferType, data.updateRange.offset * data.array.BYTES_PER_ELEMENT,
+							  data.array.subarray( data.updateRange.offset, data.updateRange.offset + data.updateRange.count ) );
+
+			data.updateRange.count = 0; // reset range
+
+		}
+
+		attributeProperties.version = data.version;
+
+	}
+
+	function getAttributeBuffer( attribute ) {
+
+		if ( attribute instanceof THREE.InterleavedBufferAttribute ) {
+
+			return properties.get( attribute.data ).__webglBuffer;
+
+		}
+
+		return properties.get( attribute ).__webglBuffer;
+
+	}
+
+	function getWireframeAttribute( geometry ) {
+
+		var property = properties.get( geometry );
+
+		if ( property.wireframe !== undefined ) {
+
+			return property.wireframe;
+
+		}
+
+		var indices = [];
+
+		var index = geometry.index;
+		var attributes = geometry.attributes;
+		var position = attributes.position;
+
+		// console.time( 'wireframe' );
+
+		if ( index !== null ) {
+
+			var edges = {};
+			var array = index.array;
+
+			for ( var i = 0, l = array.length; i < l; i += 3 ) {
+
+				var a = array[ i + 0 ];
+				var b = array[ i + 1 ];
+				var c = array[ i + 2 ];
+
+				if ( checkEdge( edges, a, b ) ) indices.push( a, b );
+				if ( checkEdge( edges, b, c ) ) indices.push( b, c );
+				if ( checkEdge( edges, c, a ) ) indices.push( c, a );
+
+			}
+
+		} else {
+
+			var array = attributes.position.array;
+
+			for ( var i = 0, l = ( array.length / 3 ) - 1; i < l; i += 3 ) {
+
+				var a = i + 0;
+				var b = i + 1;
+				var c = i + 2;
+
+				indices.push( a, b, b, c, c, a );
+
+			}
+
+		}
+
+		// console.timeEnd( 'wireframe' );
+
+		var TypeArray = position.count > 65535 ? Uint32Array : Uint16Array;
+		var attribute = new THREE.BufferAttribute( new TypeArray( indices ), 1 );
+
+		updateAttribute( attribute, gl.ELEMENT_ARRAY_BUFFER );
+
+		property.wireframe = attribute;
+
+		return attribute;
+
+	}
+
+	function checkEdge( edges, a, b ) {
+
+		if ( a > b ) {
+
+			var tmp = a;
+			a = b;
+			b = tmp;
+
+		}
+
+		var list = edges[ a ];
+
+		if ( list === undefined ) {
+
+			edges[ a ] = [ b ];
+			return true;
+
+		} else if ( list.indexOf( b ) === -1 ) {
+
+			list.push( b );
+			return true;
+
+		}
+
+		return false;
+
+	}
+
+	this.getAttributeBuffer = getAttributeBuffer;
+	this.getWireframeAttribute = getWireframeAttribute;
+
+	this.update = update;
+
+};
+
+// File:src/renderers/webgl/WebGLProgram.js
+
+THREE.WebGLProgram = ( function () {
+
+	var programIdCount = 0;
+
+	function getEncodingComponents( encoding ) {
+
+		switch ( encoding ) {
+
+			case THREE.LinearEncoding:
+				return [ 'Linear','( value )' ];
+			case THREE.sRGBEncoding:
+				return [ 'sRGB','( value )' ];
+			case THREE.RGBEEncoding:
+				return [ 'RGBE','( value )' ];
+			case THREE.RGBM7Encoding:
+				return [ 'RGBM','( value, 7.0 )' ];
+			case THREE.RGBM16Encoding:
+				return [ 'RGBM','( value, 16.0 )' ];
+			case THREE.RGBDEncoding:
+				return [ 'RGBD','( value, 256.0 )' ];
+			case THREE.GammaEncoding:
+				return [ 'Gamma','( value, float( GAMMA_FACTOR ) )' ];
+			default:
+				throw new Error( 'unsupported encoding: ' + encoding );
+
+		}
+
+	}
+
+	function getTexelDecodingFunction( functionName, encoding ) {
+
+		var components = getEncodingComponents( encoding );
+		return "vec4 " + functionName + "( vec4 value ) { return " + components[ 0 ] + "ToLinear" + components[ 1 ] + "; }";
+
+	}
+
+	function getTexelEncodingFunction( functionName, encoding ) {
+
+		var components = getEncodingComponents( encoding );
+		return "vec4 " + functionName + "( vec4 value ) { return LinearTo" + components[ 0 ] + components[ 1 ] + "; }";
+
+	}
+
+	function getToneMappingFunction( functionName, toneMapping ) {
+
+		var toneMappingName;
+
+		switch ( toneMapping ) {
+
+			case THREE.LinearToneMapping:
+				toneMappingName = "Linear";
+				break;
+
+			case THREE.ReinhardToneMapping:
+				toneMappingName = "Reinhard";
+				break;
+
+			case THREE.Uncharted2ToneMapping:
+				toneMappingName = "Uncharted2";
+				break;
+
+			case THREE.CineonToneMapping:
+				toneMappingName = "OptimizedCineon";
+				break;
+
+			default:
+				throw new Error( 'unsupported toneMapping: ' + toneMapping );
+
+		}
+
+		return "vec3 " + functionName + "( vec3 color ) { return " + toneMappingName + "ToneMapping( color ); }";
+
+	}
+
+	function generateExtensions( extensions, parameters, rendererExtensions ) {
+
+		extensions = extensions || {};
+
+		var chunks = [
+			( extensions.derivatives || parameters.envMapCubeUV || parameters.bumpMap || parameters.normalMap || parameters.flatShading ) ? '#extension GL_OES_standard_derivatives : enable' : '',
+			( extensions.fragDepth || parameters.logarithmicDepthBuffer ) && rendererExtensions.get( 'EXT_frag_depth' ) ? '#extension GL_EXT_frag_depth : enable' : '',
+			( extensions.drawBuffers ) && rendererExtensions.get( 'WEBGL_draw_buffers' ) ? '#extension GL_EXT_draw_buffers : require' : '',
+			( extensions.shaderTextureLOD || parameters.envMap ) && rendererExtensions.get( 'EXT_shader_texture_lod' ) ? '#extension GL_EXT_shader_texture_lod : enable' : '',
+		];
+
+		return chunks.filter( filterEmptyLine ).join( '\n' );
+
+	}
+
+	function generateDefines( defines ) {
+
+		var chunks = [];
+
+		for ( var name in defines ) {
+
+			var value = defines[ name ];
+
+			if ( value === false ) continue;
+
+			chunks.push( '#define ' + name + ' ' + value );
+
+		}
+
+		return chunks.join( '\n' );
+
+	}
+
+	function fetchAttributeLocations( gl, program, identifiers ) {
+
+		var attributes = {};
+
+		var n = gl.getProgramParameter( program, gl.ACTIVE_ATTRIBUTES );
+
+		for ( var i = 0; i < n; i ++ ) {
+
+			var info = gl.getActiveAttrib( program, i );
+			var name = info.name;
+
+			// console.log("THREE.WebGLProgram: ACTIVE VERTEX ATTRIBUTE:", name, i );
+
+			attributes[ name ] = gl.getAttribLocation( program, name );
+
+		}
+
+		return attributes;
+
+	}
+
+	function filterEmptyLine( string ) {
+
+		return string !== '';
+
+	}
+
+	function replaceLightNums( string, parameters ) {
+
+		return string
+			.replace( /NUM_DIR_LIGHTS/g, parameters.numDirLights )
+			.replace( /NUM_SPOT_LIGHTS/g, parameters.numSpotLights )
+			.replace( /NUM_POINT_LIGHTS/g, parameters.numPointLights )
+			.replace( /NUM_HEMI_LIGHTS/g, parameters.numHemiLights );
+
+	}
+
+	function parseIncludes( string ) {
+
+		var pattern = /#include +<([\w\d.]+)>/g;
+
+		function replace( match, include ) {
+
+			var replace = THREE.ShaderChunk[ include ];
+
+			if ( replace === undefined ) {
+
+				throw new Error( 'Can not resolve #include <' + include + '>' );
+
+			}
+
+			return parseIncludes( replace );
+
+		}
+
+		return string.replace( pattern, replace );
+
+	}
+
+	function unrollLoops( string ) {
+
+		var pattern = /for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g;
+
+		function replace( match, start, end, snippet ) {
+
+			var unroll = '';
+
+			for ( var i = parseInt( start ); i < parseInt( end ); i ++ ) {
+
+				unroll += snippet.replace( /\[ i \]/g, '[ ' + i + ' ]' );
+
+			}
+
+			return unroll;
+
+		}
+
+		return string.replace( pattern, replace );
+
+	}
+
+	return function WebGLProgram( renderer, code, material, parameters ) {
+
+		var gl = renderer.context;
+
+		var extensions = material.extensions;
+		var defines = material.defines;
+
+		var vertexShader = material.__webglShader.vertexShader;
+		var fragmentShader = material.__webglShader.fragmentShader;
+
+		var shadowMapTypeDefine = 'SHADOWMAP_TYPE_BASIC';
+
+		if ( parameters.shadowMapType === THREE.PCFShadowMap ) {
+
+			shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF';
+
+		} else if ( parameters.shadowMapType === THREE.PCFSoftShadowMap ) {
+
+			shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF_SOFT';
+
+		}
+
+		var envMapTypeDefine = 'ENVMAP_TYPE_CUBE';
+		var envMapModeDefine = 'ENVMAP_MODE_REFLECTION';
+		var envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';
+
+		if ( parameters.envMap ) {
+
+			switch ( material.envMap.mapping ) {
+
+				case THREE.CubeReflectionMapping:
+				case THREE.CubeRefractionMapping:
+					envMapTypeDefine = 'ENVMAP_TYPE_CUBE';
+					break;
+
+				case THREE.CubeUVReflectionMapping:
+				case THREE.CubeUVRefractionMapping:
+					envMapTypeDefine = 'ENVMAP_TYPE_CUBE_UV';
+					break;
+
+				case THREE.EquirectangularReflectionMapping:
+				case THREE.EquirectangularRefractionMapping:
+					envMapTypeDefine = 'ENVMAP_TYPE_EQUIREC';
+					break;
+
+				case THREE.SphericalReflectionMapping:
+					envMapTypeDefine = 'ENVMAP_TYPE_SPHERE';
+					break;
+
+			}
+
+			switch ( material.envMap.mapping ) {
+
+				case THREE.CubeRefractionMapping:
+				case THREE.EquirectangularRefractionMapping:
+					envMapModeDefine = 'ENVMAP_MODE_REFRACTION';
+					break;
+
+			}
+
+			switch ( material.combine ) {
+
+				case THREE.MultiplyOperation:
+					envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';
+					break;
+
+				case THREE.MixOperation:
+					envMapBlendingDefine = 'ENVMAP_BLENDING_MIX';
+					break;
+
+				case THREE.AddOperation:
+					envMapBlendingDefine = 'ENVMAP_BLENDING_ADD';
+					break;
+
+			}
+
+		}
+
+		var gammaFactorDefine = ( renderer.gammaFactor > 0 ) ? renderer.gammaFactor : 1.0;
+
+		// console.log( 'building new program ' );
+
+		//
+
+		var customExtensions = generateExtensions( extensions, parameters, renderer.extensions );
+
+		var customDefines = generateDefines( defines );
+
+		//
+
+		var program = gl.createProgram();
+
+		var prefixVertex, prefixFragment;
+
+		if ( material instanceof THREE.RawShaderMaterial ) {
+
+			prefixVertex = '';
+			prefixFragment = '';
+
+		} else {
+
+			prefixVertex = [
+
+				'precision ' + parameters.precision + ' float;',
+				'precision ' + parameters.precision + ' int;',
+
+				'#define SHADER_NAME ' + material.__webglShader.name,
+
+				customDefines,
+
+				parameters.supportsVertexTextures ? '#define VERTEX_TEXTURES' : '',
+
+				'#define GAMMA_FACTOR ' + gammaFactorDefine,
+
+				'#define MAX_BONES ' + parameters.maxBones,
+
+				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.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.vertexColors ? '#define USE_COLOR' : '',
+
+				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' : '',
+
+				'#define NUM_CLIPPING_PLANES ' + parameters.numClippingPlanes,
+
+				parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
+				parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',
+
+				parameters.sizeAttenuation ? '#define USE_SIZEATTENUATION' : '',
+
+				parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
+				parameters.logarithmicDepthBuffer && renderer.extensions.get( 'EXT_frag_depth' ) ? '#define USE_LOGDEPTHBUF_EXT' : '',
+
+				'uniform mat4 modelMatrix;',
+				'uniform mat4 modelViewMatrix;',
+				'uniform mat4 projectionMatrix;',
+				'uniform mat4 viewMatrix;',
+				'uniform mat3 normalMatrix;',
+				'uniform vec3 cameraPosition;',
+
+				'attribute vec3 position;',
+				'attribute vec3 normal;',
+				'attribute vec2 uv;',
+
+				'#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,
+
+				'precision ' + parameters.precision + ' float;',
+				'precision ' + parameters.precision + ' int;',
+
+				'#define SHADER_NAME ' + material.__webglShader.name,
+
+				customDefines,
+
+				parameters.alphaTest ? '#define ALPHATEST ' + parameters.alphaTest : '',
+
+				'#define GAMMA_FACTOR ' + gammaFactorDefine,
+
+				( parameters.useFog && parameters.fog ) ? '#define USE_FOG' : '',
+				( parameters.useFog && parameters.fogExp ) ? '#define FOG_EXP2' : '',
+
+				parameters.map ? '#define USE_MAP' : '',
+				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.specularMap ? '#define USE_SPECULARMAP' : '',
+				parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
+				parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
+				parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
+				parameters.vertexColors ? '#define USE_COLOR' : '',
+
+				parameters.flatShading ? '#define FLAT_SHADED' : '',
+
+				parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
+				parameters.flipSided ? '#define FLIP_SIDED' : '',
+
+				'#define NUM_CLIPPING_PLANES ' + parameters.numClippingPlanes,
+
+				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 && renderer.extensions.get( 'EXT_frag_depth' ) ? '#define USE_LOGDEPTHBUF_EXT' : '',
+
+				parameters.envMap && renderer.extensions.get( 'EXT_shader_texture_lod' ) ? '#define TEXTURE_LOD_EXT' : '',
+
+				'uniform mat4 viewMatrix;',
+				'uniform vec3 cameraPosition;',
+
+				( parameters.toneMapping !== THREE.NoToneMapping ) ? "#define TONE_MAPPING" : '',
+				( parameters.toneMapping !== THREE.NoToneMapping ) ? THREE.ShaderChunk[ 'tonemapping_pars_fragment' ] : '',  // this code is required here because it is used by the toneMapping() function defined below
+				( parameters.toneMapping !== THREE.NoToneMapping ) ? getToneMappingFunction( "toneMapping", parameters.toneMapping ) : '',
+
+				( parameters.outputEncoding || parameters.mapEncoding || parameters.envMapEncoding || parameters.emissiveMapEncoding ) ? THREE.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.envMapEncoding ? getTexelDecodingFunction( 'envMapTexelToLinear', parameters.envMapEncoding ) : '',
+				parameters.emissiveMapEncoding ? getTexelDecodingFunction( 'emissiveMapTexelToLinear', parameters.emissiveMapEncoding ) : '',
+				parameters.outputEncoding ? getTexelEncodingFunction( "linearToOutputTexel", parameters.outputEncoding ) : '',
+
+				parameters.depthPacking ? "#define DEPTH_PACKING " + material.depthPacking : '',
+
+				'\n'
+
+			].filter( filterEmptyLine ).join( '\n' );
+
+		}
+
+		vertexShader = parseIncludes( vertexShader, parameters );
+		vertexShader = replaceLightNums( vertexShader, parameters );
+
+		fragmentShader = parseIncludes( fragmentShader, parameters );
+		fragmentShader = replaceLightNums( fragmentShader, parameters );
+
+		if ( material instanceof THREE.ShaderMaterial === false ) {
+
+			vertexShader = unrollLoops( vertexShader );
+			fragmentShader = unrollLoops( fragmentShader );
+
+		}
+
+		var vertexGlsl = prefixVertex + vertexShader;
+		var fragmentGlsl = prefixFragment + fragmentShader;
+
+		// console.log( '*VERTEX*', vertexGlsl );
+		// console.log( '*FRAGMENT*', fragmentGlsl );
+
+		var glVertexShader = THREE.WebGLShader( gl, gl.VERTEX_SHADER, vertexGlsl );
+		var glFragmentShader = THREE.WebGLShader( gl, gl.FRAGMENT_SHADER, fragmentGlsl );
+
+		gl.attachShader( program, glVertexShader );
+		gl.attachShader( program, glFragmentShader );
+
+		// Force a particular attribute to index 0.
+
+		if ( material.index0AttributeName !== undefined ) {
+
+			gl.bindAttribLocation( program, 0, material.index0AttributeName );
+
+		} else if ( parameters.morphTargets === true ) {
+
+			// programs with morphTargets displace position out of attribute 0
+			gl.bindAttribLocation( program, 0, 'position' );
+
+		}
+
+		gl.linkProgram( program );
+
+		var programLog = gl.getProgramInfoLog( program );
+		var vertexLog = gl.getShaderInfoLog( glVertexShader );
+		var fragmentLog = gl.getShaderInfoLog( glFragmentShader );
+
+		var runnable = true;
+		var haveDiagnostics = true;
+
+		// console.log( '**VERTEX**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glVertexShader ) );
+		// console.log( '**FRAGMENT**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glFragmentShader ) );
+
+		if ( gl.getProgramParameter( program, gl.LINK_STATUS ) === false ) {
+
+			runnable = false;
+
+			console.error( 'THREE.WebGLProgram: shader error: ', gl.getError(), 'gl.VALIDATE_STATUS', gl.getProgramParameter( program, gl.VALIDATE_STATUS ), 'gl.getProgramInfoLog', programLog, vertexLog, fragmentLog );
+
+		} else if ( programLog !== '' ) {
+
+			console.warn( 'THREE.WebGLProgram: gl.getProgramInfoLog()', programLog );
+
+		} else if ( vertexLog === '' || fragmentLog === '' ) {
+
+			haveDiagnostics = false;
+
+		}
+
+		if ( haveDiagnostics ) {
+
+			this.diagnostics = {
+
+				runnable: runnable,
+				material: material,
+
+				programLog: programLog,
+
+				vertexShader: {
+
+					log: vertexLog,
+					prefix: prefixVertex
+
+				},
+
+				fragmentShader: {
+
+					log: fragmentLog,
+					prefix: prefixFragment
+
+				}
+
+			};
+
+		}
+
+		// clean up
+
+		gl.deleteShader( glVertexShader );
+		gl.deleteShader( glFragmentShader );
+
+		// set up caching for uniform locations
+
+		var cachedUniforms;
+
+		this.getUniforms = function() {
+
+			if ( cachedUniforms === undefined ) {
+
+				cachedUniforms =
+						new THREE.WebGLUniforms( gl, program, renderer );
+
+			}
+
+			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;
+
+		};
+
+		// DEPRECATED
+
+		Object.defineProperties( this, {
+
+			uniforms: {
+				get: function() {
+
+					console.warn( 'THREE.WebGLProgram: .uniforms is now .getUniforms().' );
+					return this.getUniforms();
+
+				}
+			},
+
+			attributes: {
+				get: function() {
+
+					console.warn( 'THREE.WebGLProgram: .attributes is now .getAttributes().' );
+					return this.getAttributes();
+
+				}
+			}
+
+		} );
+
+
+		//
+
+		this.id = programIdCount ++;
+		this.code = code;
+		this.usedTimes = 1;
+		this.program = program;
+		this.vertexShader = glVertexShader;
+		this.fragmentShader = glFragmentShader;
+
+		return this;
+
+	};
+
+} )();
+
+// File:src/renderers/webgl/WebGLPrograms.js
+
+THREE.WebGLPrograms = function ( renderer, capabilities ) {
+
+	var programs = [];
+
+	var shaderIDs = {
+		MeshDepthMaterial: 'depth',
+		MeshNormalMaterial: 'normal',
+		MeshBasicMaterial: 'basic',
+		MeshLambertMaterial: 'lambert',
+		MeshPhongMaterial: 'phong',
+		MeshStandardMaterial: 'physical',
+		MeshPhysicalMaterial: 'physical',
+		LineBasicMaterial: 'basic',
+		LineDashedMaterial: 'dashed',
+		PointsMaterial: 'points'
+	};
+
+	var parameterNames = [
+		"precision", "supportsVertexTextures", "map", "mapEncoding", "envMap", "envMapMode", "envMapEncoding",
+		"lightMap", "aoMap", "emissiveMap", "emissiveMapEncoding", "bumpMap", "normalMap", "displacementMap", "specularMap",
+		"roughnessMap", "metalnessMap",
+		"alphaMap", "combine", "vertexColors", "fog", "useFog", "fogExp",
+		"flatShading", "sizeAttenuation", "logarithmicDepthBuffer", "skinning",
+		"maxBones", "useVertexTexture", "morphTargets", "morphNormals",
+		"maxMorphTargets", "maxMorphNormals", "premultipliedAlpha",
+		"numDirLights", "numPointLights", "numSpotLights", "numHemiLights",
+		"shadowMapEnabled", "shadowMapType", "toneMapping", 'physicallyCorrectLights',
+		"alphaTest", "doubleSided", "flipSided", "numClippingPlanes", "depthPacking"
+	];
+
+
+	function allocateBones ( object ) {
+
+		if ( capabilities.floatVertexTextures && object && object.skeleton && object.skeleton.useVertexTexture ) {
+
+			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 = capabilities.maxVertexUniforms;
+			var nVertexMatrices = Math.floor( ( nVertexUniforms - 20 ) / 4 );
+
+			var maxBones = nVertexMatrices;
+
+			if ( object !== undefined && object instanceof THREE.SkinnedMesh ) {
+
+				maxBones = Math.min( object.skeleton.bones.length, maxBones );
+
+				if ( maxBones < object.skeleton.bones.length ) {
+
+					console.warn( 'WebGLRenderer: too many bones - ' + object.skeleton.bones.length + ', this GPU supports just ' + maxBones + ' (try OpenGL instead of ANGLE)' );
+
+				}
+
+			}
+
+			return maxBones;
+
+		}
+
+	}
+
+	function getTextureEncodingFromMap( map, gammaOverrideLinear ) {
+
+		var encoding;
+
+		if ( ! map ) {
+
+			encoding = THREE.LinearEncoding;
+
+		} else if ( map instanceof THREE.Texture ) {
+
+			encoding = map.encoding;
+
+		} else if ( map instanceof THREE.WebGLRenderTarget ) {
+
+			encoding = map.texture.encoding;
+
+		}
+
+		// add backwards compatibility for WebGLRenderer.gammaInput/gammaOutput parameter, should probably be removed at some point.
+		if ( encoding === THREE.LinearEncoding && gammaOverrideLinear ) {
+
+			encoding = THREE.GammaEncoding;
+
+		}
+
+		return encoding;
+
+	}
+
+	this.getParameters = function ( material, lights, fog, nClipPlanes, object ) {
+
+		var shaderID = shaderIDs[ material.type ];
+
+		// heuristics to create shader parameters according to lights in the scene
+		// (not to blow over maxLights budget)
+
+		var maxBones = allocateBones( object );
+		var precision = renderer.getPrecision();
+
+		if ( material.precision !== null ) {
+
+			precision = capabilities.getMaxPrecision( material.precision );
+
+			if ( precision !== material.precision ) {
+
+				console.warn( 'THREE.WebGLProgram.getParameters:', material.precision, 'not supported, using', precision, 'instead.' );
+
+			}
+
+		}
+
+		var parameters = {
+
+			shaderID: shaderID,
+
+			precision: precision,
+			supportsVertexTextures: capabilities.vertexTextures,
+			outputEncoding: getTextureEncodingFromMap( renderer.getCurrentRenderTarget(), renderer.gammaOutput ),
+			map: !! material.map,
+			mapEncoding: getTextureEncodingFromMap( material.map, renderer.gammaInput ),
+			envMap: !! material.envMap,
+			envMapMode: material.envMap && material.envMap.mapping,
+			envMapEncoding: getTextureEncodingFromMap( material.envMap, renderer.gammaInput ),
+			envMapCubeUV: ( !! material.envMap ) && ( ( material.envMap.mapping === THREE.CubeUVReflectionMapping ) || ( material.envMap.mapping === THREE.CubeUVRefractionMapping ) ),
+			lightMap: !! material.lightMap,
+			aoMap: !! material.aoMap,
+			emissiveMap: !! material.emissiveMap,
+			emissiveMapEncoding: getTextureEncodingFromMap( material.emissiveMap, renderer.gammaInput ),
+			bumpMap: !! material.bumpMap,
+			normalMap: !! material.normalMap,
+			displacementMap: !! material.displacementMap,
+			roughnessMap: !! material.roughnessMap,
+			metalnessMap: !! material.metalnessMap,
+			specularMap: !! material.specularMap,
+			alphaMap: !! material.alphaMap,
+
+			combine: material.combine,
+
+			vertexColors: material.vertexColors,
+
+			fog: fog,
+			useFog: material.fog,
+			fogExp: fog instanceof THREE.FogExp2,
+
+			flatShading: material.shading === THREE.FlatShading,
+
+			sizeAttenuation: material.sizeAttenuation,
+			logarithmicDepthBuffer: capabilities.logarithmicDepthBuffer,
+
+			skinning: material.skinning,
+			maxBones: maxBones,
+			useVertexTexture: capabilities.floatVertexTextures && object && object.skeleton && object.skeleton.useVertexTexture,
+
+			morphTargets: material.morphTargets,
+			morphNormals: material.morphNormals,
+			maxMorphTargets: renderer.maxMorphTargets,
+			maxMorphNormals: renderer.maxMorphNormals,
+
+			numDirLights: lights.directional.length,
+			numPointLights: lights.point.length,
+			numSpotLights: lights.spot.length,
+			numHemiLights: lights.hemi.length,
+
+			numClippingPlanes: nClipPlanes,
+
+			shadowMapEnabled: renderer.shadowMap.enabled && object.receiveShadow && lights.shadows.length > 0,
+			shadowMapType: renderer.shadowMap.type,
+
+			toneMapping: renderer.toneMapping,
+			physicallyCorrectLights: renderer.physicallyCorrectLights,
+
+			premultipliedAlpha: material.premultipliedAlpha,
+
+			alphaTest: material.alphaTest,
+			doubleSided: material.side === THREE.DoubleSide,
+			flipSided: material.side === THREE.BackSide,
+
+			depthPacking: ( material.depthPacking !== undefined ) ? material.depthPacking : false
+
+		};
+
+		return parameters;
+
+	};
+
+	this.getProgramCode = function ( material, parameters ) {
+
+		var array = [];
+
+		if ( parameters.shaderID ) {
+
+			array.push( parameters.shaderID );
+
+		} else {
+
+			array.push( material.fragmentShader );
+			array.push( material.vertexShader );
+
+		}
+
+		if ( material.defines !== undefined ) {
+
+			for ( var name in material.defines ) {
+
+				array.push( name );
+				array.push( material.defines[ name ] );
+
+			}
+
+		}
+
+		for ( var i = 0; i < parameterNames.length; i ++ ) {
+
+			array.push( parameters[ parameterNames[ i ] ] );
+
+		}
+
+		return array.join();
+
+	};
+
+	this.acquireProgram = function ( material, parameters, code ) {
+
+		var program;
+
+		// Check if code has been already compiled
+		for ( var p = 0, pl = programs.length; p < pl; p ++ ) {
+
+			var programInfo = programs[ p ];
+
+			if ( programInfo.code === code ) {
+
+				program = programInfo;
+				++ program.usedTimes;
+
+				break;
+
+			}
+
+		}
+
+		if ( program === undefined ) {
+
+			program = new THREE.WebGLProgram( renderer, code, material, parameters );
+			programs.push( program );
+
+		}
+
+		return program;
+
+	};
+
+	this.releaseProgram = function( program ) {
+
+		if ( -- program.usedTimes === 0 ) {
+
+			// Remove from unordered set
+			var i = programs.indexOf( program );
+			programs[ i ] = programs[ programs.length - 1 ];
+			programs.pop();
+
+			// Free WebGL resources
+			program.destroy();
+
+		}
+
+	};
+
+	// Exposed for resource monitoring & error feedback via renderer.info:
+	this.programs = programs;
+
+};
+
+// File:src/renderers/webgl/WebGLProperties.js
+
+/**
+* @author fordacious / fordacious.github.io
+*/
+
+THREE.WebGLProperties = function () {
+
+	var properties = {};
+
+	this.get = function ( object ) {
+
+		var uuid = object.uuid;
+		var map = properties[ uuid ];
+
+		if ( map === undefined ) {
+
+			map = {};
+			properties[ uuid ] = map;
+
+		}
+
+		return map;
+
+	};
+
+	this.delete = function ( object ) {
+
+		delete properties[ object.uuid ];
+
+	};
+
+	this.clear = function () {
+
+		properties = {};
+
+	};
+
+};
+
+// File:src/renderers/webgl/WebGLShader.js
+
+THREE.WebGLShader = ( function () {
+
+	function addLineNumbers( string ) {
+
+		var lines = string.split( '\n' );
+
+		for ( var i = 0; i < lines.length; i ++ ) {
+
+			lines[ i ] = ( i + 1 ) + ': ' + lines[ i ];
+
+		}
+
+		return lines.join( '\n' );
+
+	}
+
+	return function WebGLShader( gl, type, string ) {
+
+		var shader = gl.createShader( type );
+
+		gl.shaderSource( shader, string );
+		gl.compileShader( shader );
+
+		if ( gl.getShaderParameter( shader, gl.COMPILE_STATUS ) === false ) {
+
+			console.error( 'THREE.WebGLShader: Shader couldn\'t compile.' );
+
+		}
+
+		if ( gl.getShaderInfoLog( shader ) !== '' ) {
+
+			console.warn( 'THREE.WebGLShader: gl.getShaderInfoLog()', type === gl.VERTEX_SHADER ? 'vertex' : 'fragment', gl.getShaderInfoLog( shader ), addLineNumbers( string ) );
+
+		}
+
+		// --enable-privileged-webgl-extension
+		// console.log( type, gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( shader ) );
+
+		return shader;
+
+	};
+
+} )();
+
+// File:src/renderers/webgl/WebGLShadowMap.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.WebGLShadowMap = function ( _renderer, _lights, _objects ) {
+
+	var _gl = _renderer.context,
+	_state = _renderer.state,
+	_frustum = new THREE.Frustum(),
+	_projScreenMatrix = new THREE.Matrix4(),
+
+	_lightShadows = _lights.shadows,
+
+	_shadowMapSize = new THREE.Vector2(),
+
+	_lookTarget = new THREE.Vector3(),
+	_lightPositionWorld = new THREE.Vector3(),
+
+	_renderList = [],
+
+	_MorphingFlag = 1,
+	_SkinningFlag = 2,
+
+	_NumberOfMaterialVariants = ( _MorphingFlag | _SkinningFlag ) + 1,
+
+	_depthMaterials = new Array( _NumberOfMaterialVariants ),
+	_distanceMaterials = new Array( _NumberOfMaterialVariants ),
+
+	_materialCache = {};
+
+	var cubeDirections = [
+		new THREE.Vector3( 1, 0, 0 ), new THREE.Vector3( - 1, 0, 0 ), new THREE.Vector3( 0, 0, 1 ),
+		new THREE.Vector3( 0, 0, - 1 ), new THREE.Vector3( 0, 1, 0 ), new THREE.Vector3( 0, - 1, 0 )
+	];
+
+	var cubeUps = [
+		new THREE.Vector3( 0, 1, 0 ), new THREE.Vector3( 0, 1, 0 ), new THREE.Vector3( 0, 1, 0 ),
+		new THREE.Vector3( 0, 1, 0 ), new THREE.Vector3( 0, 0, 1 ),	new THREE.Vector3( 0, 0, - 1 )
+	];
+
+	var cube2DViewPorts = [
+		new THREE.Vector4(), new THREE.Vector4(), new THREE.Vector4(),
+		new THREE.Vector4(), new THREE.Vector4(), new THREE.Vector4()
+	];
+
+	// init
+
+	var depthMaterialTemplate = new THREE.MeshDepthMaterial();
+	depthMaterialTemplate.depthPacking = THREE.RGBADepthPacking;
+	depthMaterialTemplate.clipping = true;
+
+	var distanceShader = THREE.ShaderLib[ "distanceRGBA" ];
+	var distanceUniforms = THREE.UniformsUtils.clone( distanceShader.uniforms );
+
+	for ( var i = 0; i !== _NumberOfMaterialVariants; ++ i ) {
+
+		var useMorphing = ( i & _MorphingFlag ) !== 0;
+		var useSkinning = ( i & _SkinningFlag ) !== 0;
+
+		var depthMaterial = depthMaterialTemplate.clone();
+		depthMaterial.morphTargets = useMorphing;
+		depthMaterial.skinning = useSkinning;
+
+		_depthMaterials[ i ] = depthMaterial;
+
+		var distanceMaterial = new THREE.ShaderMaterial( {
+			defines: {
+				'USE_SHADOWMAP': ''
+			},
+			uniforms: distanceUniforms,
+			vertexShader: distanceShader.vertexShader,
+			fragmentShader: distanceShader.fragmentShader,
+			morphTargets: useMorphing,
+			skinning: useSkinning,
+			clipping: true
+		} );
+
+		_distanceMaterials[ i ] = distanceMaterial;
+
+	}
+
+	//
+
+	var scope = this;
+
+	this.enabled = false;
+
+	this.autoUpdate = true;
+	this.needsUpdate = false;
+
+	this.type = THREE.PCFShadowMap;
+	this.cullFace = THREE.CullFaceFront;
+
+	this.render = function ( scene, camera ) {
+
+		if ( scope.enabled === false ) return;
+		if ( scope.autoUpdate === false && scope.needsUpdate === false ) return;
+
+		if ( _lightShadows.length === 0 ) return;
+
+		// Set GL state for depth map.
+		_state.clearColor( 1, 1, 1, 1 );
+		_state.disable( _gl.BLEND );
+		_state.enable( _gl.CULL_FACE );
+		_gl.frontFace( _gl.CCW );
+		_gl.cullFace( scope.cullFace === THREE.CullFaceFront ? _gl.FRONT : _gl.BACK );
+		_state.setDepthTest( true );
+		_state.setScissorTest( false );
+
+		// render depth map
+
+		var faceCount, isPointLight;
+
+		for ( var i = 0, il = _lightShadows.length; i < il; i ++ ) {
+
+			var light = _lightShadows[ i ];
+
+			var shadow = light.shadow;
+			var shadowCamera = shadow.camera;
+
+			_shadowMapSize.copy( shadow.mapSize );
+
+			if ( light instanceof THREE.PointLight ) {
+
+				faceCount = 6;
+				isPointLight = true;
+
+				var vpWidth = _shadowMapSize.x;
+				var vpHeight = _shadowMapSize.y;
+
+				// These viewports map a cube-map onto a 2D texture with the
+				// following orientation:
+				//
+				//  xzXZ
+				//   y Y
+				//
+				// X - Positive x direction
+				// x - Negative x direction
+				// Y - Positive y direction
+				// y - Negative y direction
+				// Z - Positive z direction
+				// z - Negative z direction
+
+				// positive X
+				cube2DViewPorts[ 0 ].set( vpWidth * 2, vpHeight, vpWidth, vpHeight );
+				// negative X
+				cube2DViewPorts[ 1 ].set( 0, vpHeight, vpWidth, vpHeight );
+				// positive Z
+				cube2DViewPorts[ 2 ].set( vpWidth * 3, vpHeight, vpWidth, vpHeight );
+				// negative Z
+				cube2DViewPorts[ 3 ].set( vpWidth, vpHeight, vpWidth, vpHeight );
+				// positive Y
+				cube2DViewPorts[ 4 ].set( vpWidth * 3, 0, vpWidth, vpHeight );
+				// negative Y
+				cube2DViewPorts[ 5 ].set( vpWidth, 0, vpWidth, vpHeight );
+
+				_shadowMapSize.x *= 4.0;
+				_shadowMapSize.y *= 2.0;
+
+			} else {
+
+				faceCount = 1;
+				isPointLight = false;
+
+			}
+
+			if ( shadow.map === null ) {
+
+				var pars = { minFilter: THREE.NearestFilter, magFilter: THREE.NearestFilter, format: THREE.RGBAFormat };
+
+				shadow.map = new THREE.WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars );
+
+				shadowCamera.updateProjectionMatrix();
+
+			}
+
+			if ( shadow instanceof THREE.SpotLightShadow ) {
+
+				shadow.update( light );
+
+			}
+
+			var shadowMap = shadow.map;
+			var shadowMatrix = shadow.matrix;
+
+			_lightPositionWorld.setFromMatrixPosition( light.matrixWorld );
+			shadowCamera.position.copy( _lightPositionWorld );
+
+			_renderer.setRenderTarget( shadowMap );
+			_renderer.clear();
+
+			// render shadow map for each cube face (if omni-directional) or
+			// run a single pass if not
+
+			for ( var face = 0; face < faceCount; face ++ ) {
+
+				if ( isPointLight ) {
+
+					_lookTarget.copy( shadowCamera.position );
+					_lookTarget.add( cubeDirections[ face ] );
+					shadowCamera.up.copy( cubeUps[ face ] );
+					shadowCamera.lookAt( _lookTarget );
+
+					var vpDimensions = cube2DViewPorts[ face ];
+					_state.viewport( vpDimensions );
+
+				} else {
+
+					_lookTarget.setFromMatrixPosition( light.target.matrixWorld );
+					shadowCamera.lookAt( _lookTarget );
+
+				}
+
+				shadowCamera.updateMatrixWorld();
+				shadowCamera.matrixWorldInverse.getInverse( shadowCamera.matrixWorld );
+
+				// compute shadow matrix
+
+				shadowMatrix.set(
+					0.5, 0.0, 0.0, 0.5,
+					0.0, 0.5, 0.0, 0.5,
+					0.0, 0.0, 0.5, 0.5,
+					0.0, 0.0, 0.0, 1.0
+				);
+
+				shadowMatrix.multiply( shadowCamera.projectionMatrix );
+				shadowMatrix.multiply( shadowCamera.matrixWorldInverse );
+
+				// update camera matrices and frustum
+
+				_projScreenMatrix.multiplyMatrices( shadowCamera.projectionMatrix, shadowCamera.matrixWorldInverse );
+				_frustum.setFromMatrix( _projScreenMatrix );
+
+				// set object matrices & frustum culling
+
+				_renderList.length = 0;
+
+				projectObject( scene, camera, shadowCamera );
+
+				// render shadow map
+				// render regular objects
+
+				for ( var j = 0, jl = _renderList.length; j < jl; j ++ ) {
+
+					var object = _renderList[ j ];
+					var geometry = _objects.update( object );
+					var material = object.material;
+
+					if ( material instanceof THREE.MultiMaterial ) {
+
+						var groups = geometry.groups;
+						var materials = material.materials;
+
+						for ( var k = 0, kl = groups.length; k < kl; k ++ ) {
+
+							var group = groups[ k ];
+							var groupMaterial = materials[ group.materialIndex ];
+
+							if ( groupMaterial.visible === true ) {
+
+								var depthMaterial = getDepthMaterial( object, groupMaterial, isPointLight, _lightPositionWorld );
+								_renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, group );
+
+							}
+
+						}
+
+					} else {
+
+						var depthMaterial = getDepthMaterial( object, material, isPointLight, _lightPositionWorld );
+						_renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, null );
+
+					}
+
+				}
+
+			}
+
+		}
+
+		// Restore GL state.
+		var clearColor = _renderer.getClearColor(),
+		clearAlpha = _renderer.getClearAlpha();
+		_renderer.setClearColor( clearColor, clearAlpha );
+
+		_state.enable( _gl.BLEND );
+
+		if ( scope.cullFace === THREE.CullFaceFront ) {
+
+			_gl.cullFace( _gl.BACK );
+
+		}
+
+		scope.needsUpdate = false;
+
+	};
+
+	function getDepthMaterial( object, material, isPointLight, lightPositionWorld ) {
+
+		var geometry = object.geometry;
+
+		var result = null;
+
+		var materialVariants = _depthMaterials;
+		var customMaterial = object.customDepthMaterial;
+
+		if ( isPointLight ) {
+
+			materialVariants = _distanceMaterials;
+			customMaterial = object.customDistanceMaterial;
+
+		}
+
+		if ( ! customMaterial ) {
+
+			var useMorphing = geometry.morphTargets !== undefined &&
+					geometry.morphTargets.length > 0 && material.morphTargets;
+
+			var useSkinning = object instanceof THREE.SkinnedMesh && material.skinning;
+
+			var variantIndex = 0;
+
+			if ( useMorphing ) variantIndex |= _MorphingFlag;
+			if ( useSkinning ) variantIndex |= _SkinningFlag;
+
+			result = materialVariants[ variantIndex ];
+
+		} 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;
+		result.side = material.side;
+		result.clipShadows = material.clipShadows;
+		result.clippingPlanes = material.clippingPlanes;
+		result.wireframeLinewidth = material.wireframeLinewidth;
+		result.linewidth = material.linewidth;
+
+		if ( isPointLight && result.uniforms.lightPos !== undefined ) {
+
+			result.uniforms.lightPos.value.copy( lightPositionWorld );
+
+		}
+
+		return result;
+
+	}
+
+	function projectObject( object, camera, shadowCamera ) {
+
+		if ( object.visible === false ) return;
+
+		if ( object.layers.test( camera.layers ) && ( object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Points ) ) {
+
+			if ( object.castShadow && ( object.frustumCulled === false || _frustum.intersectsObject( object ) === true ) ) {
+
+				var material = object.material;
+
+				if ( material.visible === true ) {
+
+					object.modelViewMatrix.multiplyMatrices( shadowCamera.matrixWorldInverse, object.matrixWorld );
+					_renderList.push( object );
+
+				}
+
+			}
+
+		}
+
+		var children = object.children;
+
+		for ( var i = 0, l = children.length; i < l; i ++ ) {
+
+			projectObject( children[ i ], camera, shadowCamera );
+
+		}
+
+	}
+
+};
+
+// File:src/renderers/webgl/WebGLState.js
+
+/**
+* @author mrdoob / http://mrdoob.com/
+*/
+
+THREE.WebGLState = function ( gl, extensions, paramThreeToGL ) {
+
+	var _this = this;
+
+	var color = new THREE.Vector4();
+
+	var maxVertexAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS );
+	var newAttributes = new Uint8Array( maxVertexAttributes );
+	var enabledAttributes = new Uint8Array( maxVertexAttributes );
+	var attributeDivisors = new Uint8Array( maxVertexAttributes );
+
+	var capabilities = {};
+
+	var compressedTextureFormats = null;
+
+	var currentBlending = null;
+	var currentBlendEquation = null;
+	var currentBlendSrc = null;
+	var currentBlendDst = null;
+	var currentBlendEquationAlpha = null;
+	var currentBlendSrcAlpha = null;
+	var currentBlendDstAlpha = null;
+	var currentPremultipledAlpha = false;
+
+	var currentDepthFunc = null;
+	var currentDepthWrite = null;
+
+	var currentColorWrite = null;
+
+	var currentStencilWrite = null;
+	var currentStencilFunc = null;
+	var currentStencilRef = null;
+	var currentStencilMask = null;
+	var currentStencilFail  = null;
+	var currentStencilZFail = null;
+	var currentStencilZPass = null;
+
+	var currentFlipSided = null;
+
+	var currentLineWidth = null;
+
+	var currentPolygonOffsetFactor = null;
+	var currentPolygonOffsetUnits = null;
+
+	var currentScissorTest = null;
+
+	var maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS );
+
+	var currentTextureSlot = undefined;
+	var currentBoundTextures = {};
+
+	var currentClearColor = new THREE.Vector4();
+	var currentClearDepth = null;
+	var currentClearStencil = null;
+
+	var currentScissor = new THREE.Vector4();
+	var currentViewport = new THREE.Vector4();
+
+	this.init = function () {
+
+		this.clearColor( 0, 0, 0, 1 );
+		this.clearDepth( 1 );
+		this.clearStencil( 0 );
+
+		this.enable( gl.DEPTH_TEST );
+		gl.depthFunc( gl.LEQUAL );
+
+		gl.frontFace( gl.CCW );
+		gl.cullFace( gl.BACK );
+		this.enable( gl.CULL_FACE );
+
+		this.enable( gl.BLEND );
+		gl.blendEquation( gl.FUNC_ADD );
+		gl.blendFunc( gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA );
+
+	};
+
+	this.initAttributes = function () {
+
+		for ( var i = 0, l = newAttributes.length; i < l; i ++ ) {
+
+			newAttributes[ i ] = 0;
+
+		}
+
+	};
+
+	this.enableAttribute = function ( attribute ) {
+
+		newAttributes[ attribute ] = 1;
+
+		if ( enabledAttributes[ attribute ] === 0 ) {
+
+			gl.enableVertexAttribArray( attribute );
+			enabledAttributes[ attribute ] = 1;
+
+		}
+
+		if ( attributeDivisors[ attribute ] !== 0 ) {
+
+			var extension = extensions.get( 'ANGLE_instanced_arrays' );
+
+			extension.vertexAttribDivisorANGLE( attribute, 0 );
+			attributeDivisors[ attribute ] = 0;
+
+		}
+
+	};
+
+	this.enableAttributeAndDivisor = function ( attribute, meshPerAttribute, extension ) {
+
+		newAttributes[ attribute ] = 1;
+
+		if ( enabledAttributes[ attribute ] === 0 ) {
+
+			gl.enableVertexAttribArray( attribute );
+			enabledAttributes[ attribute ] = 1;
+
+		}
+
+		if ( attributeDivisors[ attribute ] !== meshPerAttribute ) {
+
+			extension.vertexAttribDivisorANGLE( attribute, meshPerAttribute );
+			attributeDivisors[ attribute ] = meshPerAttribute;
+
+		}
+
+	};
+
+	this.disableUnusedAttributes = function () {
+
+		for ( var i = 0, l = enabledAttributes.length; i < l; i ++ ) {
+
+			if ( enabledAttributes[ i ] !== newAttributes[ i ] ) {
+
+				gl.disableVertexAttribArray( i );
+				enabledAttributes[ i ] = 0;
+
+			}
+
+		}
+
+	};
+
+	this.enable = function ( id ) {
+
+		if ( capabilities[ id ] !== true ) {
+
+			gl.enable( id );
+			capabilities[ id ] = true;
+
+		}
+
+	};
+
+	this.disable = function ( id ) {
+
+		if ( capabilities[ id ] !== false ) {
+
+			gl.disable( id );
+			capabilities[ id ] = false;
+
+		}
+
+	};
+
+	this.getCompressedTextureFormats = function () {
+
+		if ( compressedTextureFormats === null ) {
+
+			compressedTextureFormats = [];
+
+			if ( extensions.get( 'WEBGL_compressed_texture_pvrtc' ) ||
+			     extensions.get( 'WEBGL_compressed_texture_s3tc' ) ||
+			     extensions.get( 'WEBGL_compressed_texture_etc1' ) ) {
+
+				var formats = gl.getParameter( gl.COMPRESSED_TEXTURE_FORMATS );
+
+				for ( var i = 0; i < formats.length; i ++ ) {
+
+					compressedTextureFormats.push( formats[ i ] );
+
+				}
+
+			}
+
+		}
+
+		return compressedTextureFormats;
+
+	};
+
+	this.setBlending = function ( blending, blendEquation, blendSrc, blendDst, blendEquationAlpha, blendSrcAlpha, blendDstAlpha, premultipliedAlpha ) {
+
+		if ( blending === THREE.NoBlending ) {
+
+			this.disable( gl.BLEND );
+
+		} else {
+
+			this.enable( gl.BLEND );
+
+		}
+
+		if ( blending !== currentBlending || premultipliedAlpha !== currentPremultipledAlpha ) {
+
+			if ( blending === THREE.AdditiveBlending ) {
+
+				if ( premultipliedAlpha ) {
+
+					gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );
+					gl.blendFuncSeparate( gl.ONE, gl.ONE, gl.ONE, gl.ONE );
+
+				} else {
+
+					gl.blendEquation( gl.FUNC_ADD );
+					gl.blendFunc( gl.SRC_ALPHA, gl.ONE );
+
+				}
+
+			} else if ( blending === THREE.SubtractiveBlending ) {
+
+				if ( premultipliedAlpha ) {
+
+					gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );
+					gl.blendFuncSeparate( gl.ZERO, gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ONE_MINUS_SRC_ALPHA );
+
+				} else {
+
+					gl.blendEquation( gl.FUNC_ADD );
+					gl.blendFunc( gl.ZERO, gl.ONE_MINUS_SRC_COLOR );
+
+				}
+
+			} else if ( blending === THREE.MultiplyBlending ) {
+
+				if ( premultipliedAlpha ) {
+
+					gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );
+					gl.blendFuncSeparate( gl.ZERO, gl.ZERO, gl.SRC_COLOR, gl.SRC_ALPHA );
+
+				} else {
+
+					gl.blendEquation( gl.FUNC_ADD );
+					gl.blendFunc( gl.ZERO, gl.SRC_COLOR );
+
+				}
+
+			} else {
+
+				if ( premultipliedAlpha ) {
+
+					gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );
+					gl.blendFuncSeparate( gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA );
+
+				} else {
+
+					gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );
+					gl.blendFuncSeparate( gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA );
+
+				}
+
+			}
+
+			currentBlending = blending;
+			currentPremultipledAlpha = premultipliedAlpha;
+
+		}
+
+		if ( blending === THREE.CustomBlending ) {
+
+			blendEquationAlpha = blendEquationAlpha || blendEquation;
+			blendSrcAlpha = blendSrcAlpha || blendSrc;
+			blendDstAlpha = blendDstAlpha || blendDst;
+
+			if ( blendEquation !== currentBlendEquation || blendEquationAlpha !== currentBlendEquationAlpha ) {
+
+				gl.blendEquationSeparate( paramThreeToGL( blendEquation ), paramThreeToGL( blendEquationAlpha ) );
+
+				currentBlendEquation = blendEquation;
+				currentBlendEquationAlpha = blendEquationAlpha;
+
+			}
+
+			if ( blendSrc !== currentBlendSrc || blendDst !== currentBlendDst || blendSrcAlpha !== currentBlendSrcAlpha || blendDstAlpha !== currentBlendDstAlpha ) {
+
+				gl.blendFuncSeparate( paramThreeToGL( blendSrc ), paramThreeToGL( blendDst ), paramThreeToGL( blendSrcAlpha ), paramThreeToGL( blendDstAlpha ) );
+
+				currentBlendSrc = blendSrc;
+				currentBlendDst = blendDst;
+				currentBlendSrcAlpha = blendSrcAlpha;
+				currentBlendDstAlpha = blendDstAlpha;
+
+			}
+
+		} else {
+
+			currentBlendEquation = null;
+			currentBlendSrc = null;
+			currentBlendDst = null;
+			currentBlendEquationAlpha = null;
+			currentBlendSrcAlpha = null;
+			currentBlendDstAlpha = null;
+
+		}
+
+	};
+
+	this.setDepthFunc = function ( depthFunc ) {
+
+		if ( currentDepthFunc !== depthFunc ) {
+
+			if ( depthFunc ) {
+
+				switch ( depthFunc ) {
+
+					case THREE.NeverDepth:
+
+						gl.depthFunc( gl.NEVER );
+						break;
+
+					case THREE.AlwaysDepth:
+
+						gl.depthFunc( gl.ALWAYS );
+						break;
+
+					case THREE.LessDepth:
+
+						gl.depthFunc( gl.LESS );
+						break;
+
+					case THREE.LessEqualDepth:
+
+						gl.depthFunc( gl.LEQUAL );
+						break;
+
+					case THREE.EqualDepth:
+
+						gl.depthFunc( gl.EQUAL );
+						break;
+
+					case THREE.GreaterEqualDepth:
+
+						gl.depthFunc( gl.GEQUAL );
+						break;
+
+					case THREE.GreaterDepth:
+
+						gl.depthFunc( gl.GREATER );
+						break;
+
+					case THREE.NotEqualDepth:
+
+						gl.depthFunc( gl.NOTEQUAL );
+						break;
+
+					default:
+
+						gl.depthFunc( gl.LEQUAL );
+
+				}
+
+			} else {
+
+				gl.depthFunc( gl.LEQUAL );
+
+			}
+
+			currentDepthFunc = depthFunc;
+
+		}
+
+	};
+
+	this.setDepthTest = function ( depthTest ) {
+
+		if ( depthTest ) {
+
+			this.enable( gl.DEPTH_TEST );
+
+		} else {
+
+			this.disable( gl.DEPTH_TEST );
+
+		}
+
+	};
+
+	this.setDepthWrite = function ( depthWrite ) {
+
+		// TODO: Rename to setDepthMask
+
+		if ( currentDepthWrite !== depthWrite ) {
+
+			gl.depthMask( depthWrite );
+			currentDepthWrite = depthWrite;
+
+		}
+
+	};
+
+	this.setColorWrite = function ( colorWrite ) {
+
+		// TODO: Rename to setColorMask
+
+		if ( currentColorWrite !== colorWrite ) {
+
+			gl.colorMask( colorWrite, colorWrite, colorWrite, colorWrite );
+			currentColorWrite = colorWrite;
+
+		}
+
+	};
+
+	this.setStencilFunc = function ( stencilFunc, stencilRef, stencilMask ) {
+
+		if ( currentStencilFunc !== stencilFunc ||
+				 currentStencilRef 	!== stencilRef 	||
+				 currentStencilMask !== stencilMask ) {
+
+			gl.stencilFunc( stencilFunc,  stencilRef, stencilMask );
+
+			currentStencilFunc = stencilFunc;
+			currentStencilRef  = stencilRef;
+			currentStencilMask = stencilMask;
+
+		}
+
+	};
+
+	this.setStencilOp = function ( stencilFail, stencilZFail, stencilZPass ) {
+
+		if ( currentStencilFail	 !== stencilFail 	||
+				 currentStencilZFail !== stencilZFail ||
+				 currentStencilZPass !== stencilZPass ) {
+
+			gl.stencilOp( stencilFail,  stencilZFail, stencilZPass );
+
+			currentStencilFail  = stencilFail;
+			currentStencilZFail = stencilZFail;
+			currentStencilZPass = stencilZPass;
+
+		}
+
+	};
+
+	this.setStencilTest = function ( stencilTest ) {
+
+		if ( stencilTest ) {
+
+			this.enable( gl.STENCIL_TEST );
+
+		} else {
+
+			this.disable( gl.STENCIL_TEST );
+
+		}
+
+	};
+
+	this.setStencilWrite = function ( stencilWrite ) {
+
+		// TODO: Rename to setStencilMask
+
+		if ( currentStencilWrite !== stencilWrite ) {
+
+			gl.stencilMask( stencilWrite );
+			currentStencilWrite = stencilWrite;
+
+		}
+
+	};
+
+	this.setFlipSided = function ( flipSided ) {
+
+		if ( currentFlipSided !== flipSided ) {
+
+			if ( flipSided ) {
+
+				gl.frontFace( gl.CW );
+
+			} else {
+
+				gl.frontFace( gl.CCW );
+
+			}
+
+			currentFlipSided = flipSided;
+
+		}
+
+	};
+
+	this.setLineWidth = function ( width ) {
+
+		if ( width !== currentLineWidth ) {
+
+			gl.lineWidth( width );
+
+			currentLineWidth = width;
+
+		}
+
+	};
+
+	this.setPolygonOffset = function ( polygonOffset, factor, units ) {
+
+		if ( polygonOffset ) {
+
+			this.enable( gl.POLYGON_OFFSET_FILL );
+
+		} else {
+
+			this.disable( gl.POLYGON_OFFSET_FILL );
+
+		}
+
+		if ( polygonOffset && ( currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units ) ) {
+
+			gl.polygonOffset( factor, units );
+
+			currentPolygonOffsetFactor = factor;
+			currentPolygonOffsetUnits = units;
+
+		}
+
+	};
+
+	this.getScissorTest = function () {
+
+		return currentScissorTest;
+
+	};
+
+	this.setScissorTest = function ( scissorTest ) {
+
+		currentScissorTest = scissorTest;
+
+		if ( scissorTest ) {
+
+			this.enable( gl.SCISSOR_TEST );
+
+		} else {
+
+			this.disable( gl.SCISSOR_TEST );
+
+		}
+
+	};
+
+	// texture
+
+	this.activeTexture = function ( webglSlot ) {
+
+		if ( webglSlot === undefined ) webglSlot = gl.TEXTURE0 + maxTextures - 1;
+
+		if ( currentTextureSlot !== webglSlot ) {
+
+			gl.activeTexture( webglSlot );
+			currentTextureSlot = webglSlot;
+
+		}
+
+	};
+
+	this.bindTexture = function ( webglType, webglTexture ) {
+
+		if ( currentTextureSlot === undefined ) {
+
+			_this.activeTexture();
+
+		}
+
+		var boundTexture = currentBoundTextures[ currentTextureSlot ];
+
+		if ( boundTexture === undefined ) {
+
+			boundTexture = { type: undefined, texture: undefined };
+			currentBoundTextures[ currentTextureSlot ] = boundTexture;
+
+		}
+
+		if ( boundTexture.type !== webglType || boundTexture.texture !== webglTexture ) {
+
+			gl.bindTexture( webglType, webglTexture );
+
+			boundTexture.type = webglType;
+			boundTexture.texture = webglTexture;
+
+		}
+
+	};
+
+	this.compressedTexImage2D = function () {
+
+		try {
+
+			gl.compressedTexImage2D.apply( gl, arguments );
+
+		} catch ( error ) {
+
+			console.error( error );
+
+		}
+
+	};
+
+	this.texImage2D = function () {
+
+		try {
+
+			gl.texImage2D.apply( gl, arguments );
+
+		} catch ( error ) {
+
+			console.error( error );
+
+		}
+
+	};
+
+	// clear values
+
+	this.clearColor = function ( r, g, b, a ) {
+
+		color.set( r, g, b, a );
+
+		if ( currentClearColor.equals( color ) === false ) {
+
+			gl.clearColor( r, g, b, a );
+			currentClearColor.copy( color );
+
+		}
+
+	};
+
+	this.clearDepth = function ( depth ) {
+
+		if ( currentClearDepth !== depth ) {
+
+			gl.clearDepth( depth );
+			currentClearDepth = depth;
+
+		}
+
+	};
+
+	this.clearStencil = function ( stencil ) {
+
+		if ( currentClearStencil !== stencil ) {
+
+			gl.clearStencil( stencil );
+			currentClearStencil = stencil;
+
+		}
+
+	};
+
+	//
+
+	this.scissor = function ( scissor ) {
+
+		if ( currentScissor.equals( scissor ) === false ) {
+
+			gl.scissor( scissor.x, scissor.y, scissor.z, scissor.w );
+			currentScissor.copy( scissor );
+
+		}
+
+	};
+
+	this.viewport = function ( viewport ) {
+
+		if ( currentViewport.equals( viewport ) === false ) {
+
+			gl.viewport( viewport.x, viewport.y, viewport.z, viewport.w );
+			currentViewport.copy( viewport );
+
+		}
+
+	};
+
+	//
+
+	this.reset = function () {
+
+		for ( var i = 0; i < enabledAttributes.length; i ++ ) {
+
+			if ( enabledAttributes[ i ] === 1 ) {
+
+				gl.disableVertexAttribArray( i );
+				enabledAttributes[ i ] = 0;
+
+			}
+
+		}
+
+		capabilities = {};
+
+		compressedTextureFormats = null;
+
+		currentTextureSlot = undefined;
+		currentBoundTextures = {};
+
+		currentBlending = null;
+
+		currentColorWrite = null;
+		currentDepthWrite = null;
+		currentStencilWrite = null;
+
+		currentFlipSided = null;
+
+	};
+
+};
+
+// File:src/renderers/webgl/WebGLUniforms.js
+
+/**
+ *
+ * Uniforms of a program.
+ * Those form a tree structure with a special top-level container for the root,
+ * which you get by calling 'new WebGLUniforms( gl, program, renderer )'.
+ *
+ *
+ * Properties of inner nodes including the top-level container:
+ *
+ * .seq - array of nested uniforms
+ * .map - nested uniforms by name
+ *
+ *
+ * Methods of all nodes except the top-level container:
+ *
+ * .setValue( gl, value, [renderer] )
+ *
+ * 		uploads a uniform value(s)
+ *  	the 'renderer' parameter is needed for sampler uniforms
+ *
+ *
+ * Static methods of the top-level container (renderer factorizations):
+ *
+ * .upload( gl, seq, values, renderer )
+ *
+ * 		sets uniforms in 'seq' to 'values[id].value'
+ *
+ * .seqWithValue( seq, values ) : filteredSeq
+ *
+ * 		filters 'seq' entries with corresponding entry in values
+ *
+ * .splitDynamic( seq, values ) : filteredSeq
+ *
+ * 		filters 'seq' entries with dynamic entry and removes them from 'seq'
+ *
+ *
+ * Methods of the top-level container (renderer factorizations):
+ *
+ * .setValue( gl, name, value )
+ *
+ * 		sets uniform with  name 'name' to 'value'
+ *
+ * .set( gl, obj, prop )
+ *
+ * 		sets uniform from object and property with same name than uniform
+ *
+ * .setOptional( gl, obj, prop )
+ *
+ * 		like .set for an optional property of the object
+ *
+ *
+ * @author tschw
+ *
+ */
+
+THREE.WebGLUniforms = ( function() { // scope
+
+	// --- Base for inner nodes (including the root) ---
+
+	var UniformContainer = function() {
+
+			this.seq = [];
+			this.map = {};
+
+		},
+
+	// --- Utilities ---
+
+	// Array Caches (provide typed arrays for temporary by size)
+
+		arrayCacheF32 = [],
+		arrayCacheI32 = [],
+
+		uncacheTemporaryArrays = function() {
+
+			arrayCacheF32.length = 0;
+			arrayCacheI32.length = 0;
+
+		},
+
+	// Flattening for arrays of vectors and matrices
+
+		flatten = function( array, nBlocks, blockSize ) {
+
+			var firstElem = array[ 0 ];
+
+			if ( firstElem <= 0 || firstElem > 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;
+
+		},
+
+	// Texture unit allocation
+
+		allocTexUnits = function( renderer, n ) {
+
+			var r = arrayCacheI32[ n ];
+
+			if ( r === undefined ) {
+
+				r = new Int32Array( n );
+				arrayCacheI32[ n ] = r;
+
+			}
+
+			for ( var i = 0; i !== n; ++ i )
+				r[ i ] = renderer.allocTextureUnit();
+
+			return r;
+
+		},
+
+	// --- Setters ---
+
+	// Note: Defining these methods externally, because they come in a bunch
+	// and this way their names minify.
+
+		// Single scalar
+
+		setValue1f = function( gl, v ) { gl.uniform1f( this.addr, v ); },
+		setValue1i = function( gl, v ) { gl.uniform1i( this.addr, v ); },
+
+		// Single float vector (from flat array or THREE.VectorN)
+
+		setValue2fv = function( gl, v ) {
+
+			if ( v.x === undefined ) gl.uniform2fv( this.addr, v );
+			else gl.uniform2f( this.addr, v.x, v.y );
+
+		},
+
+		setValue3fv = function( gl, v ) {
+
+			if ( v.x !== undefined )
+				gl.uniform3f( this.addr, v.x, v.y, v.z );
+			else if ( v.r !== undefined )
+				gl.uniform3f( this.addr, v.r, v.g, v.b );
+			else
+				gl.uniform3fv( this.addr, v );
+
+		},
+
+		setValue4fv = function( gl, v ) {
+
+			if ( v.x === undefined ) gl.uniform4fv( this.addr, v );
+			else gl.uniform4f( this.addr, v.x, v.y, v.z, v.w );
+
+		},
+
+		// Single matrix (from flat array or MatrixN)
+
+		setValue2fm = function( gl, v ) {
+
+			gl.uniformMatrix2fv( this.addr, false, v.elements || v );
+
+		},
+
+		setValue3fm = function( gl, v ) {
+
+			gl.uniformMatrix3fv( this.addr, false, v.elements || v );
+
+		},
+
+		setValue4fm = function( gl, v ) {
+
+			gl.uniformMatrix4fv( this.addr, false, v.elements || v );
+
+		},
+
+		// Single texture (2D / Cube)
+
+		setValueT1 = function( gl, v, renderer ) {
+
+			var unit = renderer.allocTextureUnit();
+			gl.uniform1i( this.addr, unit );
+			if ( v ) renderer.setTexture2D( v, unit );
+
+		},
+
+		setValueT6 = function( gl, v, renderer ) {
+
+			var unit = renderer.allocTextureUnit();
+			gl.uniform1i( this.addr, unit );
+			if ( v ) renderer.setTextureCube( v, unit );
+
+		},
+
+		// Integer / Boolean vectors or arrays thereof (always flat arrays)
+
+		setValue2iv = function( gl, v ) { gl.uniform2iv( this.addr, v ); },
+		setValue3iv = function( gl, v ) { gl.uniform3iv( this.addr, v ); },
+		setValue4iv = function( gl, v ) { gl.uniform4iv( this.addr, v ); },
+
+		// Helper to pick the right setter for the singular case
+
+		getSingularSetter = function( type ) {
+
+			switch ( type ) {
+
+				case 0x1406: return setValue1f; // FLOAT
+				case 0x8b50: return setValue2fv; // _VEC2
+				case 0x8b51: return setValue3fv; // _VEC3
+				case 0x8b52: return setValue4fv; // _VEC4
+
+				case 0x8b5a: return setValue2fm; // _MAT2
+				case 0x8b5b: return setValue3fm; // _MAT3
+				case 0x8b5c: return setValue4fm; // _MAT4
+
+				case 0x8b5e: return setValueT1; // SAMPLER_2D
+				case 0x8b60: return setValueT6; // SAMPLER_CUBE
+
+				case 0x1404: case 0x8b56: return setValue1i; // INT, BOOL
+				case 0x8b53: case 0x8b57: return setValue2iv; // _VEC2
+				case 0x8b54: case 0x8b58: return setValue3iv; // _VEC3
+				case 0x8b55: case 0x8b59: return setValue4iv; // _VEC4
+
+			}
+
+		},
+
+		// Array of scalars
+
+		setValue1fv = function( gl, v ) { gl.uniform1fv( this.addr, v ); },
+		setValue1iv = function( gl, v ) { gl.uniform1iv( this.addr, v ); },
+
+		// Array of vectors (flat or from THREE classes)
+
+		setValueV2a = function( gl, v ) {
+
+			gl.uniform2fv( this.addr, flatten( v, this.size, 2 ) );
+
+		},
+
+		setValueV3a = function( gl, v ) {
+
+			gl.uniform3fv( this.addr, flatten( v, this.size, 3 ) );
+
+		},
+
+		setValueV4a = function( gl, v ) {
+
+			gl.uniform4fv( this.addr, flatten( v, this.size, 4 ) );
+
+		},
+
+		// Array of matrices (flat or from THREE clases)
+
+		setValueM2a = function( gl, v ) {
+
+			gl.uniformMatrix2fv( this.addr, false, flatten( v, this.size, 4 ) );
+
+		},
+
+		setValueM3a = function( gl, v ) {
+
+			gl.uniformMatrix3fv( this.addr, false, flatten( v, this.size, 9 ) );
+
+		},
+
+		setValueM4a = function( gl, v ) {
+
+			gl.uniformMatrix4fv( this.addr, false, flatten( v, this.size, 16 ) );
+
+		},
+
+		// Array of textures (2D / Cube)
+
+		setValueT1a = function( gl, v, renderer ) {
+
+			var n = v.length,
+				units = allocTexUnits( renderer, n );
+
+			gl.uniform1iv( this.addr, units );
+
+			for ( var i = 0; i !== n; ++ i ) {
+
+				var tex = v[ i ];
+				if ( tex ) renderer.setTexture2D( tex, units[ i ] );
+
+			}
+
+		},
+
+		setValueT6a = function( gl, v, renderer ) {
+
+			var n = v.length,
+				units = allocTexUnits( renderer, n );
+
+			gl.uniform1iv( this.addr, units );
+
+			for ( var i = 0; i !== n; ++ i ) {
+
+				var tex = v[ i ];
+				if ( tex ) renderer.setTextureCube( tex, units[ i ] );
+
+			}
+
+		},
+
+
+		// Helper to pick the right setter for a pure (bottom-level) array
+
+		getPureArraySetter = function( type ) {
+
+			switch ( type ) {
+
+				case 0x1406: return setValue1fv; // FLOAT
+				case 0x8b50: return setValueV2a; // _VEC2
+				case 0x8b51: return setValueV3a; // _VEC3
+				case 0x8b52: return setValueV4a; // _VEC4
+
+				case 0x8b5a: return setValueM2a; // _MAT2
+				case 0x8b5b: return setValueM3a; // _MAT3
+				case 0x8b5c: return setValueM4a; // _MAT4
+
+				case 0x8b5e: return setValueT1a; // SAMPLER_2D
+				case 0x8b60: return setValueT6a; // SAMPLER_CUBE
+
+				case 0x1404: case 0x8b56: return setValue1iv; // INT, BOOL
+				case 0x8b53: case 0x8b57: return setValue2iv; // _VEC2
+				case 0x8b54: case 0x8b58: return setValue3iv; // _VEC3
+				case 0x8b55: case 0x8b59: return setValue4iv; // _VEC4
+
+			}
+
+		},
+
+	// --- Uniform Classes ---
+
+		SingleUniform = function SingleUniform( id, activeInfo, addr ) {
+
+			this.id = id;
+			this.addr = addr;
+			this.setValue = getSingularSetter( activeInfo.type );
+
+			// this.path = activeInfo.name; // DEBUG
+
+		},
+
+		PureArrayUniform = function( id, activeInfo, addr ) {
+
+			this.id = id;
+			this.addr = addr;
+			this.size = activeInfo.size;
+			this.setValue = getPureArraySetter( activeInfo.type );
+
+			// this.path = activeInfo.name; // DEBUG
+
+		},
+
+		StructuredUniform = function( id ) {
+
+			this.id = id;
+
+			UniformContainer.call( this ); // mix-in
+
+		};
+
+	StructuredUniform.prototype.setValue = function( gl, value ) {
+
+		// Note: Don't need an extra 'renderer' parameter, since samplers
+		// are not allowed in structured uniforms.
+
+		var seq = this.seq;
+
+		for ( var i = 0, n = seq.length; i !== n; ++ i ) {
+
+			var u = seq[ i ];
+			u.setValue( gl, value[ u.id ] );
+
+		}
+
+	};
+
+	// --- Top-level ---
+
+	// Parser - builds up the property tree from the path strings
+
+	var RePathPart = /([\w\d_]+)(\])?(\[|\.)?/g,
+		// extracts
+		// 	- the identifier (member name or array index)
+		//  - followed by an optional right bracket (found when array index)
+		//  - followed by an optional left bracket or dot (type of subscript)
+		//
+		// Note: These portions can be read in a non-overlapping fashion and
+		// allow straightforward parsing of the hierarchy that WebGL encodes
+		// in the uniform names.
+
+		addUniform = function( container, uniformObject ) {
+
+			container.seq.push( uniformObject );
+			container.map[ uniformObject.id ] = uniformObject;
+
+		},
+
+		parseUniform = function( activeInfo, addr, container ) {
+
+			var path = activeInfo.name,
+				pathLength = path.length;
+
+			// reset RegExp object, because of the early exit of a previous run
+			RePathPart.lastIndex = 0;
+
+			for (; ;) {
+
+				var match = RePathPart.exec( path ),
+					matchEnd = RePathPart.lastIndex,
+
+					id = match[ 1 ],
+					idIsIndex = match[ 2 ] === ']',
+					subscript = match[ 3 ];
+
+				if ( idIsIndex ) id = id | 0; // convert to integer
+
+				if ( subscript === undefined ||
+						subscript === '[' && matchEnd + 2 === pathLength ) {
+					// bare name or "pure" bottom-level array "[0]" suffix
+
+					addUniform( container, subscript === undefined ?
+							new SingleUniform( id, activeInfo, addr ) :
+							new PureArrayUniform( id, activeInfo, addr ) );
+
+					break;
+
+				} else {
+					// step into inner node / create it in case it doesn't exist
+
+					var map = container.map,
+						next = map[ id ];
+
+					if ( next === undefined ) {
+
+						next = new StructuredUniform( id );
+						addUniform( container, next );
+
+					}
+
+					container = next;
+
+				}
+
+			}
+
+		},
+
+	// Root Container
+
+		WebGLUniforms = function WebGLUniforms( gl, program, renderer ) {
+
+			UniformContainer.call( this );
+
+			this.renderer = renderer;
+
+			var n = gl.getProgramParameter( program, gl.ACTIVE_UNIFORMS );
+
+			for ( var i = 0; i !== n; ++ i ) {
+
+				var info = gl.getActiveUniform( program, i ),
+					path = info.name,
+					addr = gl.getUniformLocation( program, path );
+
+				parseUniform( info, addr, this );
+
+			}
+
+		};
+
+
+	WebGLUniforms.prototype.setValue = function( gl, name, value ) {
+
+		var u = this.map[ name ];
+
+		if ( u !== undefined ) u.setValue( gl, value, this.renderer );
+
+	};
+
+	WebGLUniforms.prototype.set = function( gl, object, name ) {
+
+		var u = this.map[ name ];
+
+		if ( u !== undefined ) u.setValue( gl, object[ name ], this.renderer );
+
+	};
+
+	WebGLUniforms.prototype.setOptional = function( gl, object, name ) {
+
+		var v = object[ name ];
+
+		if ( v !== undefined ) this.setValue( gl, name, v );
+
+	};
+
+
+	// Static interface
+
+	WebGLUniforms.upload = function( gl, seq, values, renderer ) {
+
+		for ( var i = 0, n = seq.length; i !== n; ++ i ) {
+
+			var u = seq[ i ],
+				v = values[ u.id ];
+
+			if ( v.needsUpdate !== false ) {
+				// note: always updating when .needsUpdate is undefined
+
+				u.setValue( gl, v.value, renderer );
+
+			}
+
+		}
+
+	};
+
+	WebGLUniforms.seqWithValue = function( seq, values ) {
+
+		var r = [];
+
+		for ( var i = 0, n = seq.length; i !== n; ++ i ) {
+
+			var u = seq[ i ];
+			if ( u.id in values ) r.push( u );
+
+		}
+
+		return r;
+
+	};
+
+	WebGLUniforms.splitDynamic = function( seq, values ) {
+
+		var r = null,
+			n = seq.length,
+			w = 0;
+
+		for ( var i = 0; i !== n; ++ i ) {
+
+			var u = seq[ i ],
+				v = values[ u.id ];
+
+			if ( v && v.dynamic === true ) {
+
+				if ( r === null ) r = [];
+				r.push( u );
+
+			} else {
+
+				// in-place compact 'seq', removing the matches
+				if ( w < i ) seq[ w ] = u;
+				++ w;
+
+			}
+
+		}
+
+		if ( w < n ) seq.length = w;
+
+		return r;
+
+	};
+
+	WebGLUniforms.evalDynamic = function( seq, values, object, camera ) {
+
+		for ( var i = 0, n = seq.length; i !== n; ++ i ) {
+
+			var v = values[ seq[ i ].id ],
+				f = v.onUpdateCallback;
+
+			if ( f !== undefined ) f.call( v, object, camera );
+
+		}
+
+	};
+
+	return WebGLUniforms;
+
+} )();
+
+
+// File:src/renderers/webgl/plugins/LensFlarePlugin.js
+
+/**
+ * @author mikael emtinger / http://gomo.se/
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.LensFlarePlugin = function ( renderer, flares ) {
+
+	var gl = renderer.context;
+	var state = renderer.state;
+
+	var vertexBuffer, elementBuffer;
+	var shader, program, attributes, uniforms;
+
+	var tempTexture, occlusionTexture;
+
+	function init() {
+
+		var vertices = new Float32Array( [
+			- 1, - 1,  0, 0,
+			 1, - 1,  1, 0,
+			 1,  1,  1, 1,
+			- 1,  1,  0, 1
+		] );
+
+		var faces = new Uint16Array( [
+			0, 1, 2,
+			0, 2, 3
+		] );
+
+		// buffers
+
+		vertexBuffer     = gl.createBuffer();
+		elementBuffer    = gl.createBuffer();
+
+		gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );
+		gl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW );
+
+		gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );
+		gl.bufferData( gl.ELEMENT_ARRAY_BUFFER, faces, gl.STATIC_DRAW );
+
+		// textures
+
+		tempTexture      = gl.createTexture();
+		occlusionTexture = gl.createTexture();
+
+		state.bindTexture( gl.TEXTURE_2D, tempTexture );
+		gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGB, 16, 16, 0, gl.RGB, gl.UNSIGNED_BYTE, null );
+		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE );
+		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE );
+		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST );
+		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST );
+
+		state.bindTexture( gl.TEXTURE_2D, occlusionTexture );
+		gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGBA, 16, 16, 0, gl.RGBA, gl.UNSIGNED_BYTE, null );
+		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE );
+		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE );
+		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST );
+		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST );
+
+		shader = {
+
+			vertexShader: [
+
+				"uniform lowp int renderType;",
+
+				"uniform vec3 screenPosition;",
+				"uniform vec2 scale;",
+				"uniform float rotation;",
+
+				"uniform sampler2D occlusionMap;",
+
+				"attribute vec2 position;",
+				"attribute vec2 uv;",
+
+				"varying vec2 vUV;",
+				"varying float vVisibility;",
+
+				"void main() {",
+
+					"vUV = uv;",
+
+					"vec2 pos = position;",
+
+					"if ( renderType == 2 ) {",
+
+						"vec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );",
+						"visibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );",
+						"visibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );",
+						"visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );",
+						"visibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );",
+						"visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );",
+						"visibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );",
+						"visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );",
+						"visibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );",
+
+						"vVisibility =        visibility.r / 9.0;",
+						"vVisibility *= 1.0 - visibility.g / 9.0;",
+						"vVisibility *=       visibility.b / 9.0;",
+						"vVisibility *= 1.0 - visibility.a / 9.0;",
+
+						"pos.x = cos( rotation ) * position.x - sin( rotation ) * position.y;",
+						"pos.y = sin( rotation ) * position.x + cos( rotation ) * position.y;",
+
+					"}",
+
+					"gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );",
+
+				"}"
+
+			].join( "\n" ),
+
+			fragmentShader: [
+
+				"uniform lowp int renderType;",
+
+				"uniform sampler2D map;",
+				"uniform float opacity;",
+				"uniform vec3 color;",
+
+				"varying vec2 vUV;",
+				"varying float vVisibility;",
+
+				"void main() {",
+
+					// pink square
+
+					"if ( renderType == 0 ) {",
+
+						"gl_FragColor = vec4( 1.0, 0.0, 1.0, 0.0 );",
+
+					// restore
+
+					"} else if ( renderType == 1 ) {",
+
+						"gl_FragColor = texture2D( map, vUV );",
+
+					// flare
+
+					"} else {",
+
+						"vec4 texture = texture2D( map, vUV );",
+						"texture.a *= opacity * vVisibility;",
+						"gl_FragColor = texture;",
+						"gl_FragColor.rgb *= color;",
+
+					"}",
+
+				"}"
+
+			].join( "\n" )
+
+		};
+
+		program = createProgram( shader );
+
+		attributes = {
+			vertex: gl.getAttribLocation ( program, "position" ),
+			uv:     gl.getAttribLocation ( program, "uv" )
+		};
+
+		uniforms = {
+			renderType:     gl.getUniformLocation( program, "renderType" ),
+			map:            gl.getUniformLocation( program, "map" ),
+			occlusionMap:   gl.getUniformLocation( program, "occlusionMap" ),
+			opacity:        gl.getUniformLocation( program, "opacity" ),
+			color:          gl.getUniformLocation( program, "color" ),
+			scale:          gl.getUniformLocation( program, "scale" ),
+			rotation:       gl.getUniformLocation( program, "rotation" ),
+			screenPosition: gl.getUniformLocation( program, "screenPosition" )
+		};
+
+	}
+
+	/*
+	 * Render lens flares
+	 * Method: renders 16x16 0xff00ff-colored points scattered over the light source area,
+	 *         reads these back and calculates occlusion.
+	 */
+
+	this.render = function ( scene, camera, viewport ) {
+
+		if ( flares.length === 0 ) return;
+
+		var tempPosition = new THREE.Vector3();
+
+		var invAspect = viewport.w / viewport.z,
+			halfViewportWidth = viewport.z * 0.5,
+			halfViewportHeight = viewport.w * 0.5;
+
+		var size = 16 / viewport.w,
+			scale = new THREE.Vector2( size * invAspect, size );
+
+		var screenPosition = new THREE.Vector3( 1, 1, 0 ),
+			screenPositionPixels = new THREE.Vector2( 1, 1 );
+
+		var validArea = new THREE.Box2();
+
+		validArea.min.set( 0, 0 );
+		validArea.max.set( viewport.z - 16, viewport.w - 16 );
+
+		if ( program === undefined ) {
+
+			init();
+
+		}
+
+		gl.useProgram( program );
+
+		state.initAttributes();
+		state.enableAttribute( attributes.vertex );
+		state.enableAttribute( attributes.uv );
+		state.disableUnusedAttributes();
+
+		// loop through all lens flares to update their occlusion and positions
+		// setup gl and common used attribs/uniforms
+
+		gl.uniform1i( uniforms.occlusionMap, 0 );
+		gl.uniform1i( uniforms.map, 1 );
+
+		gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );
+		gl.vertexAttribPointer( attributes.vertex, 2, gl.FLOAT, false, 2 * 8, 0 );
+		gl.vertexAttribPointer( attributes.uv, 2, gl.FLOAT, false, 2 * 8, 8 );
+
+		gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );
+
+		state.disable( gl.CULL_FACE );
+		state.setDepthWrite( false );
+
+		for ( var i = 0, l = flares.length; i < l; i ++ ) {
+
+			size = 16 / viewport.w;
+			scale.set( size * invAspect, size );
+
+			// calc object screen position
+
+			var flare = flares[ i ];
+
+			tempPosition.set( flare.matrixWorld.elements[ 12 ], flare.matrixWorld.elements[ 13 ], flare.matrixWorld.elements[ 14 ] );
+
+			tempPosition.applyMatrix4( camera.matrixWorldInverse );
+			tempPosition.applyProjection( camera.projectionMatrix );
+
+			// setup arrays for gl programs
+
+			screenPosition.copy( tempPosition );
+
+			// horizontal and vertical coordinate of the lower left corner of the pixels to copy
+
+			screenPositionPixels.x = viewport.x + ( screenPosition.x * halfViewportWidth ) + halfViewportWidth - 8;
+			screenPositionPixels.y = viewport.y + ( screenPosition.y * halfViewportHeight ) + halfViewportHeight - 8;
+
+			// screen cull
+
+			if ( validArea.containsPoint( screenPositionPixels ) === true ) {
+
+				// save current RGB to temp texture
+
+				state.activeTexture( gl.TEXTURE0 );
+				state.bindTexture( gl.TEXTURE_2D, null );
+				state.activeTexture( gl.TEXTURE1 );
+				state.bindTexture( gl.TEXTURE_2D, tempTexture );
+				gl.copyTexImage2D( gl.TEXTURE_2D, 0, gl.RGB, screenPositionPixels.x, screenPositionPixels.y, 16, 16, 0 );
+
+
+				// render pink quad
+
+				gl.uniform1i( uniforms.renderType, 0 );
+				gl.uniform2f( uniforms.scale, scale.x, scale.y );
+				gl.uniform3f( uniforms.screenPosition, screenPosition.x, screenPosition.y, screenPosition.z );
+
+				state.disable( gl.BLEND );
+				state.enable( gl.DEPTH_TEST );
+
+				gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );
+
+
+				// copy result to occlusionMap
+
+				state.activeTexture( gl.TEXTURE0 );
+				state.bindTexture( gl.TEXTURE_2D, occlusionTexture );
+				gl.copyTexImage2D( gl.TEXTURE_2D, 0, gl.RGBA, screenPositionPixels.x, screenPositionPixels.y, 16, 16, 0 );
+
+
+				// restore graphics
+
+				gl.uniform1i( uniforms.renderType, 1 );
+				state.disable( gl.DEPTH_TEST );
+
+				state.activeTexture( gl.TEXTURE1 );
+				state.bindTexture( gl.TEXTURE_2D, tempTexture );
+				gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );
+
+
+				// update object positions
+
+				flare.positionScreen.copy( screenPosition );
+
+				if ( flare.customUpdateCallback ) {
+
+					flare.customUpdateCallback( flare );
+
+				} else {
+
+					flare.updateLensFlares();
+
+				}
+
+				// render flares
+
+				gl.uniform1i( uniforms.renderType, 2 );
+				state.enable( gl.BLEND );
+
+				for ( var j = 0, jl = flare.lensFlares.length; j < jl; j ++ ) {
+
+					var sprite = flare.lensFlares[ j ];
+
+					if ( sprite.opacity > 0.001 && sprite.scale > 0.001 ) {
+
+						screenPosition.x = sprite.x;
+						screenPosition.y = sprite.y;
+						screenPosition.z = sprite.z;
+
+						size = sprite.size * sprite.scale / viewport.w;
+
+						scale.x = size * invAspect;
+						scale.y = size;
+
+						gl.uniform3f( uniforms.screenPosition, screenPosition.x, screenPosition.y, screenPosition.z );
+						gl.uniform2f( uniforms.scale, scale.x, scale.y );
+						gl.uniform1f( uniforms.rotation, sprite.rotation );
+
+						gl.uniform1f( uniforms.opacity, sprite.opacity );
+						gl.uniform3f( uniforms.color, sprite.color.r, sprite.color.g, sprite.color.b );
+
+						state.setBlending( sprite.blending, sprite.blendEquation, sprite.blendSrc, sprite.blendDst );
+						renderer.setTexture2D( sprite.texture, 1 );
+
+						gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );
+
+					}
+
+				}
+
+			}
+
+		}
+
+		// restore gl
+
+		state.enable( gl.CULL_FACE );
+		state.enable( gl.DEPTH_TEST );
+		state.setDepthWrite( true );
+
+		renderer.resetGLState();
+
+	};
+
+	function createProgram ( shader ) {
+
+		var program = gl.createProgram();
+
+		var fragmentShader = gl.createShader( gl.FRAGMENT_SHADER );
+		var vertexShader = gl.createShader( gl.VERTEX_SHADER );
+
+		var prefix = "precision " + renderer.getPrecision() + " float;\n";
+
+		gl.shaderSource( fragmentShader, prefix + shader.fragmentShader );
+		gl.shaderSource( vertexShader, prefix + shader.vertexShader );
+
+		gl.compileShader( fragmentShader );
+		gl.compileShader( vertexShader );
+
+		gl.attachShader( program, fragmentShader );
+		gl.attachShader( program, vertexShader );
+
+		gl.linkProgram( program );
+
+		return program;
+
+	}
+
+};
+
+// File:src/renderers/webgl/plugins/SpritePlugin.js
+
+/**
+ * @author mikael emtinger / http://gomo.se/
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.SpritePlugin = function ( renderer, sprites ) {
+
+	var gl = renderer.context;
+	var state = renderer.state;
+
+	var vertexBuffer, elementBuffer;
+	var program, attributes, uniforms;
+
+	var texture;
+
+	// decompose matrixWorld
+
+	var spritePosition = new THREE.Vector3();
+	var spriteRotation = new THREE.Quaternion();
+	var spriteScale = new THREE.Vector3();
+
+	function init() {
+
+		var vertices = new Float32Array( [
+			- 0.5, - 0.5,  0, 0,
+			  0.5, - 0.5,  1, 0,
+			  0.5,   0.5,  1, 1,
+			- 0.5,   0.5,  0, 1
+		] );
+
+		var faces = new Uint16Array( [
+			0, 1, 2,
+			0, 2, 3
+		] );
+
+		vertexBuffer  = gl.createBuffer();
+		elementBuffer = gl.createBuffer();
+
+		gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );
+		gl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW );
+
+		gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );
+		gl.bufferData( gl.ELEMENT_ARRAY_BUFFER, faces, gl.STATIC_DRAW );
+
+		program = createProgram();
+
+		attributes = {
+			position:			gl.getAttribLocation ( program, 'position' ),
+			uv:					gl.getAttribLocation ( program, 'uv' )
+		};
+
+		uniforms = {
+			uvOffset:			gl.getUniformLocation( program, 'uvOffset' ),
+			uvScale:			gl.getUniformLocation( program, 'uvScale' ),
+
+			rotation:			gl.getUniformLocation( program, 'rotation' ),
+			scale:				gl.getUniformLocation( program, 'scale' ),
+
+			color:				gl.getUniformLocation( program, 'color' ),
+			map:				gl.getUniformLocation( program, 'map' ),
+			opacity:			gl.getUniformLocation( program, 'opacity' ),
+
+			modelViewMatrix: 	gl.getUniformLocation( program, 'modelViewMatrix' ),
+			projectionMatrix:	gl.getUniformLocation( program, 'projectionMatrix' ),
+
+			fogType:			gl.getUniformLocation( program, 'fogType' ),
+			fogDensity:			gl.getUniformLocation( program, 'fogDensity' ),
+			fogNear:			gl.getUniformLocation( program, 'fogNear' ),
+			fogFar:				gl.getUniformLocation( program, 'fogFar' ),
+			fogColor:			gl.getUniformLocation( program, 'fogColor' ),
+
+			alphaTest:			gl.getUniformLocation( program, 'alphaTest' )
+		};
+
+		var canvas = document.createElement( 'canvas' );
+		canvas.width = 8;
+		canvas.height = 8;
+
+		var context = canvas.getContext( '2d' );
+		context.fillStyle = 'white';
+		context.fillRect( 0, 0, 8, 8 );
+
+		texture = new THREE.Texture( canvas );
+		texture.needsUpdate = true;
+
+	}
+
+	this.render = function ( scene, camera ) {
+
+		if ( sprites.length === 0 ) return;
+
+		// setup gl
+
+		if ( program === undefined ) {
+
+			init();
+
+		}
+
+		gl.useProgram( program );
+
+		state.initAttributes();
+		state.enableAttribute( attributes.position );
+		state.enableAttribute( attributes.uv );
+		state.disableUnusedAttributes();
+
+		state.disable( gl.CULL_FACE );
+		state.enable( gl.BLEND );
+
+		gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );
+		gl.vertexAttribPointer( attributes.position, 2, gl.FLOAT, false, 2 * 8, 0 );
+		gl.vertexAttribPointer( attributes.uv, 2, gl.FLOAT, false, 2 * 8, 8 );
+
+		gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );
+
+		gl.uniformMatrix4fv( uniforms.projectionMatrix, false, camera.projectionMatrix.elements );
+
+		state.activeTexture( gl.TEXTURE0 );
+		gl.uniform1i( uniforms.map, 0 );
+
+		var oldFogType = 0;
+		var sceneFogType = 0;
+		var fog = scene.fog;
+
+		if ( fog ) {
+
+			gl.uniform3f( uniforms.fogColor, fog.color.r, fog.color.g, fog.color.b );
+
+			if ( fog instanceof THREE.Fog ) {
+
+				gl.uniform1f( uniforms.fogNear, fog.near );
+				gl.uniform1f( uniforms.fogFar, fog.far );
+
+				gl.uniform1i( uniforms.fogType, 1 );
+				oldFogType = 1;
+				sceneFogType = 1;
+
+			} else if ( fog instanceof THREE.FogExp2 ) {
+
+				gl.uniform1f( uniforms.fogDensity, fog.density );
+
+				gl.uniform1i( uniforms.fogType, 2 );
+				oldFogType = 2;
+				sceneFogType = 2;
+
+			}
+
+		} else {
+
+			gl.uniform1i( uniforms.fogType, 0 );
+			oldFogType = 0;
+			sceneFogType = 0;
+
+		}
+
+
+		// update positions and sort
+
+		for ( var i = 0, l = sprites.length; i < l; i ++ ) {
+
+			var sprite = sprites[ i ];
+
+			sprite.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, sprite.matrixWorld );
+			sprite.z = - sprite.modelViewMatrix.elements[ 14 ];
+
+		}
+
+		sprites.sort( painterSortStable );
+
+		// render all sprites
+
+		var scale = [];
+
+		for ( var i = 0, l = sprites.length; i < l; i ++ ) {
+
+			var sprite = sprites[ i ];
+			var material = sprite.material;
+
+			gl.uniform1f( uniforms.alphaTest, material.alphaTest );
+			gl.uniformMatrix4fv( uniforms.modelViewMatrix, false, sprite.modelViewMatrix.elements );
+
+			sprite.matrixWorld.decompose( spritePosition, spriteRotation, spriteScale );
+
+			scale[ 0 ] = spriteScale.x;
+			scale[ 1 ] = spriteScale.y;
+
+			var fogType = 0;
+
+			if ( scene.fog && material.fog ) {
+
+				fogType = sceneFogType;
+
+			}
+
+			if ( oldFogType !== fogType ) {
+
+				gl.uniform1i( uniforms.fogType, fogType );
+				oldFogType = fogType;
+
+			}
+
+			if ( material.map !== null ) {
+
+				gl.uniform2f( uniforms.uvOffset, material.map.offset.x, material.map.offset.y );
+				gl.uniform2f( uniforms.uvScale, material.map.repeat.x, material.map.repeat.y );
+
+			} else {
+
+				gl.uniform2f( uniforms.uvOffset, 0, 0 );
+				gl.uniform2f( uniforms.uvScale, 1, 1 );
+
+			}
+
+			gl.uniform1f( uniforms.opacity, material.opacity );
+			gl.uniform3f( uniforms.color, material.color.r, material.color.g, material.color.b );
+
+			gl.uniform1f( uniforms.rotation, material.rotation );
+			gl.uniform2fv( uniforms.scale, scale );
+
+			state.setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst );
+			state.setDepthTest( material.depthTest );
+			state.setDepthWrite( material.depthWrite );
+
+			if ( material.map ) {
+
+				renderer.setTexture2D( material.map, 0 );
+
+			} else {
+
+				renderer.setTexture2D( texture, 0 );
+
+			}
+
+			gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );
+
+		}
+
+		// restore gl
+
+		state.enable( gl.CULL_FACE );
+
+		renderer.resetGLState();
+
+	};
+
+	function createProgram () {
+
+		var program = gl.createProgram();
+
+		var vertexShader = gl.createShader( gl.VERTEX_SHADER );
+		var fragmentShader = gl.createShader( gl.FRAGMENT_SHADER );
+
+		gl.shaderSource( vertexShader, [
+
+			'precision ' + renderer.getPrecision() + ' float;',
+
+			'uniform mat4 modelViewMatrix;',
+			'uniform mat4 projectionMatrix;',
+			'uniform float rotation;',
+			'uniform vec2 scale;',
+			'uniform vec2 uvOffset;',
+			'uniform vec2 uvScale;',
+
+			'attribute vec2 position;',
+			'attribute vec2 uv;',
+
+			'varying vec2 vUV;',
+
+			'void main() {',
+
+				'vUV = uvOffset + uv * uvScale;',
+
+				'vec2 alignedPosition = position * scale;',
+
+				'vec2 rotatedPosition;',
+				'rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;',
+				'rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;',
+
+				'vec4 finalPosition;',
+
+				'finalPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );',
+				'finalPosition.xy += rotatedPosition;',
+				'finalPosition = projectionMatrix * finalPosition;',
+
+				'gl_Position = finalPosition;',
+
+			'}'
+
+		].join( '\n' ) );
+
+		gl.shaderSource( fragmentShader, [
+
+			'precision ' + renderer.getPrecision() + ' float;',
+
+			'uniform vec3 color;',
+			'uniform sampler2D map;',
+			'uniform float opacity;',
+
+			'uniform int fogType;',
+			'uniform vec3 fogColor;',
+			'uniform float fogDensity;',
+			'uniform float fogNear;',
+			'uniform float fogFar;',
+			'uniform float alphaTest;',
+
+			'varying vec2 vUV;',
+
+			'void main() {',
+
+				'vec4 texture = texture2D( map, vUV );',
+
+				'if ( texture.a < alphaTest ) discard;',
+
+				'gl_FragColor = vec4( color * texture.xyz, texture.a * opacity );',
+
+				'if ( fogType > 0 ) {',
+
+					'float depth = gl_FragCoord.z / gl_FragCoord.w;',
+					'float fogFactor = 0.0;',
+
+					'if ( fogType == 1 ) {',
+
+						'fogFactor = smoothstep( fogNear, fogFar, depth );',
+
+					'} else {',
+
+						'const float LOG2 = 1.442695;',
+						'fogFactor = exp2( - fogDensity * fogDensity * depth * depth * LOG2 );',
+						'fogFactor = 1.0 - clamp( fogFactor, 0.0, 1.0 );',
+
+					'}',
+
+					'gl_FragColor = mix( gl_FragColor, vec4( fogColor, gl_FragColor.w ), fogFactor );',
+
+				'}',
+
+			'}'
+
+		].join( '\n' ) );
+
+		gl.compileShader( vertexShader );
+		gl.compileShader( fragmentShader );
+
+		gl.attachShader( program, vertexShader );
+		gl.attachShader( program, fragmentShader );
+
+		gl.linkProgram( program );
+
+		return program;
+
+	}
+
+	function painterSortStable ( a, b ) {
+		
+		if ( a.renderOrder !== b.renderOrder ) {
+
+			return a.renderOrder - b.renderOrder;
+
+		} else if ( a.z !== b.z ) {
+
+			return b.z - a.z;
+
+		} else {
+
+			return b.id - a.id;
+
+		}
+
+	}
+
+};
+
+// File:src/Three.Legacy.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+Object.defineProperties( THREE.Box2.prototype, {
+	empty: {
+		value: function () {
+			console.warn( 'THREE.Box2: .empty() has been renamed to .isEmpty().' );
+			return this.isEmpty();
+		}
+	},
+	isIntersectionBox: {
+		value: function ( box ) {
+			console.warn( 'THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox().' );
+			return this.intersectsBox( box );
+		}
+	}
+} );
+
+Object.defineProperties( THREE.Box3.prototype, {
+	empty: {
+		value: function () {
+			console.warn( 'THREE.Box3: .empty() has been renamed to .isEmpty().' );
+			return this.isEmpty();
+		}
+	},
+	isIntersectionBox: {
+		value: function ( box ) {
+			console.warn( 'THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox().' );
+			return this.intersectsBox( box );
+		}
+	},
+	isIntersectionSphere: {
+		value: function ( sphere ) {
+			console.warn( 'THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere().' );
+			return this.intersectsSphere( sphere );
+		}
+	}
+} );
+
+Object.defineProperties( THREE.Matrix3.prototype, {
+	multiplyVector3: {
+		value: function ( vector ) {
+			console.warn( 'THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead.' );
+			return vector.applyMatrix3( this );
+		}
+	},
+	multiplyVector3Array: {
+		value: function ( a ) {
+			console.warn( 'THREE.Matrix3: .multiplyVector3Array() has been renamed. Use matrix.applyToVector3Array( array ) instead.' );
+			return this.applyToVector3Array( a );
+		}
+	}
+} );
+
+Object.defineProperties( THREE.Matrix4.prototype, {
+	extractPosition: {
+		value: function ( m ) {
+			console.warn( 'THREE.Matrix4: .extractPosition() has been renamed to .copyPosition().' );
+			return this.copyPosition( m );
+		}
+	},
+	setRotationFromQuaternion: {
+		value: function ( q ) {
+			console.warn( 'THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion().' );
+			return this.makeRotationFromQuaternion( q );
+		}
+	},
+	multiplyVector3: {
+		value: function ( vector ) {
+			console.warn( 'THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) or vector.applyProjection( matrix ) instead.' );
+			return vector.applyProjection( this );
+		}
+	},
+	multiplyVector4: {
+		value: function ( vector ) {
+			console.warn( 'THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead.' );
+			return vector.applyMatrix4( this );
+		}
+	},
+	multiplyVector3Array: {
+		value: function ( a ) {
+			console.warn( 'THREE.Matrix4: .multiplyVector3Array() has been renamed. Use matrix.applyToVector3Array( array ) instead.' );
+			return this.applyToVector3Array( a );
+		}
+	},
+	rotateAxis: {
+		value: function ( v ) {
+			console.warn( 'THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead.' );
+			v.transformDirection( this );
+		}
+	},
+	crossVector: {
+		value: function ( vector ) {
+			console.warn( 'THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead.' );
+			return vector.applyMatrix4( this );
+		}
+	},
+	translate: {
+		value: function ( v ) {
+			console.error( 'THREE.Matrix4: .translate() has been removed.' );
+		}
+	},
+	rotateX: {
+		value: function ( angle ) {
+			console.error( 'THREE.Matrix4: .rotateX() has been removed.' );
+		}
+	},
+	rotateY: {
+		value: function ( angle ) {
+			console.error( 'THREE.Matrix4: .rotateY() has been removed.' );
+		}
+	},
+	rotateZ: {
+		value: function ( angle ) {
+			console.error( 'THREE.Matrix4: .rotateZ() has been removed.' );
+		}
+	},
+	rotateByAxis: {
+		value: function ( axis, angle ) {
+			console.error( 'THREE.Matrix4: .rotateByAxis() has been removed.' );
+		}
+	}
+} );
+
+Object.defineProperties( THREE.Plane.prototype, {
+	isIntersectionLine: {
+		value: function ( line ) {
+			console.warn( 'THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine().' );
+			return this.intersectsLine( line );
+		}
+	}
+} );
+
+Object.defineProperties( THREE.Quaternion.prototype, {
+	multiplyVector3: {
+		value: function ( vector ) {
+			console.warn( 'THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead.' );
+			return vector.applyQuaternion( this );
+		}
+	}
+} );
+
+Object.defineProperties( THREE.Ray.prototype, {
+	isIntersectionBox: {
+		value: function ( box ) {
+			console.warn( 'THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox().' );
+			return this.intersectsBox( box );
+		}
+	},
+	isIntersectionPlane: {
+		value: function ( plane ) {
+			console.warn( 'THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane().' );
+			return this.intersectsPlane( plane );
+		}
+	},
+	isIntersectionSphere: {
+		value: function ( sphere ) {
+			console.warn( 'THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere().' );
+			return this.intersectsSphere( sphere );
+		}
+	}
+} );
+
+Object.defineProperties( THREE.Vector3.prototype, {
+	setEulerFromRotationMatrix: {
+		value: function () {
+			console.error( 'THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.' );
+		}
+	},
+	setEulerFromQuaternion: {
+		value: function () {
+			console.error( 'THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.' );
+		}
+	},
+	getPositionFromMatrix: {
+		value: function ( m ) {
+			console.warn( 'THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition().' );
+			return this.setFromMatrixPosition( m );
+		}
+	},
+	getScaleFromMatrix: {
+		value: function ( m ) {
+			console.warn( 'THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale().' );
+			return this.setFromMatrixScale( m );
+		}
+	},
+	getColumnFromMatrix: {
+		value: function ( index, matrix ) {
+			console.warn( 'THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn().' );
+			return this.setFromMatrixColumn( index, matrix );
+		}
+	}
+} );
+
+//
+
+THREE.Face4 = function ( a, b, c, d, normal, color, materialIndex ) {
+
+	console.warn( 'THREE.Face4 has been removed. A THREE.Face3 will be created instead.' );
+	return new THREE.Face3( a, b, c, normal, color, materialIndex );
+
+};
+
+THREE.Vertex = function ( x, y, z ) {
+
+	console.warn( 'THREE.Vertex has been removed. Use THREE.Vector3 instead.' );
+	return new THREE.Vector3( x, y, z );
+
+};
+
+//
+
+Object.defineProperties( THREE.Object3D.prototype, {
+	eulerOrder: {
+		get: function () {
+			console.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' );
+			return this.rotation.order;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' );
+			this.rotation.order = value;
+		}
+	},
+	getChildByName: {
+		value: function ( name ) {
+			console.warn( 'THREE.Object3D: .getChildByName() has been renamed to .getObjectByName().' );
+			return this.getObjectByName( name );
+		}
+	},
+	renderDepth: {
+		set: function ( value ) {
+			console.warn( 'THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.' );
+		}
+	},
+	translate: {
+		value: function ( distance, axis ) {
+			console.warn( 'THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead.' );
+			return this.translateOnAxis( axis, distance );
+		}
+	},
+	useQuaternion: {
+		get: function () {
+			console.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' );
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' );
+		}
+	}
+} );
+
+//
+
+Object.defineProperties( THREE, {
+	PointCloud: {
+		value: function ( geometry, material ) {
+			console.warn( 'THREE.PointCloud has been renamed to THREE.Points.' );
+			return new THREE.Points( geometry, material );
+		}
+	},
+	ParticleSystem: {
+		value: function ( geometry, material ) {
+			console.warn( 'THREE.ParticleSystem has been renamed to THREE.Points.' );
+			return new THREE.Points( geometry, material );
+		}
+	}
+} );
+
+//
+
+Object.defineProperties( THREE.Light.prototype, {
+	onlyShadow: {
+		set: function ( value ) {
+			console.warn( 'THREE.Light: .onlyShadow has been removed.' );
+		}
+	},
+	shadowCameraFov: {
+		set: function ( value ) {
+			console.warn( 'THREE.Light: .shadowCameraFov is now .shadow.camera.fov.' );
+			this.shadow.camera.fov = value;
+		}
+	},
+	shadowCameraLeft: {
+		set: function ( value ) {
+			console.warn( 'THREE.Light: .shadowCameraLeft is now .shadow.camera.left.' );
+			this.shadow.camera.left = value;
+		}
+	},
+	shadowCameraRight: {
+		set: function ( value ) {
+			console.warn( 'THREE.Light: .shadowCameraRight is now .shadow.camera.right.' );
+			this.shadow.camera.right = value;
+		}
+	},
+	shadowCameraTop: {
+		set: function ( value ) {
+			console.warn( 'THREE.Light: .shadowCameraTop is now .shadow.camera.top.' );
+			this.shadow.camera.top = value;
+		}
+	},
+	shadowCameraBottom: {
+		set: function ( value ) {
+			console.warn( 'THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom.' );
+			this.shadow.camera.bottom = value;
+		}
+	},
+	shadowCameraNear: {
+		set: function ( value ) {
+			console.warn( 'THREE.Light: .shadowCameraNear is now .shadow.camera.near.' );
+			this.shadow.camera.near = value;
+		}
+	},
+	shadowCameraFar: {
+		set: function ( value ) {
+			console.warn( 'THREE.Light: .shadowCameraFar is now .shadow.camera.far.' );
+			this.shadow.camera.far = value;
+		}
+	},
+	shadowCameraVisible: {
+		set: function ( value ) {
+			console.warn( 'THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.' );
+		}
+	},
+	shadowBias: {
+		set: function ( value ) {
+			console.warn( 'THREE.Light: .shadowBias is now .shadow.bias.' );
+			this.shadow.bias = value;
+		}
+	},
+	shadowDarkness: {
+		set: function ( value ) {
+			console.warn( 'THREE.Light: .shadowDarkness has been removed.' );
+		}
+	},
+	shadowMapWidth: {
+		set: function ( value ) {
+			console.warn( 'THREE.Light: .shadowMapWidth is now .shadow.mapSize.width.' );
+			this.shadow.mapSize.width = value;
+		}
+	},
+	shadowMapHeight: {
+		set: function ( value ) {
+			console.warn( 'THREE.Light: .shadowMapHeight is now .shadow.mapSize.height.' );
+			this.shadow.mapSize.height = value;
+		}
+	}
+} );
+
+//
+
+Object.defineProperties( THREE.BufferAttribute.prototype, {
+	length: {
+		get: function () {
+			console.warn( 'THREE.BufferAttribute: .length has been deprecated. Please use .count.' );
+			return this.array.length;
+		}
+	}
+} );
+
+Object.defineProperties( THREE.BufferGeometry.prototype, {
+	drawcalls: {
+		get: function () {
+			console.error( 'THREE.BufferGeometry: .drawcalls has been renamed to .groups.' );
+			return this.groups;
+		}
+	},
+	offsets: {
+		get: function () {
+			console.warn( 'THREE.BufferGeometry: .offsets has been renamed to .groups.' );
+			return this.groups;
+		}
+	},
+	addIndex: {
+		value: function ( index ) {
+			console.warn( 'THREE.BufferGeometry: .addIndex() has been renamed to .setIndex().' );
+			this.setIndex( index );
+		}
+	},
+	addDrawCall: {
+		value: function ( start, count, indexOffset ) {
+			if ( indexOffset !== undefined ) {
+				console.warn( 'THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset.' );
+			}
+			console.warn( 'THREE.BufferGeometry: .addDrawCall() is now .addGroup().' );
+			this.addGroup( start, count );
+		}
+	},
+	clearDrawCalls: {
+		value: function () {
+			console.warn( 'THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups().' );
+			this.clearGroups();
+		}
+	},
+	computeTangents: {
+		value: function () {
+			console.warn( 'THREE.BufferGeometry: .computeTangents() has been removed.' );
+		}
+	},
+	computeOffsets: {
+		value: function () {
+			console.warn( 'THREE.BufferGeometry: .computeOffsets() has been removed.' );
+		}
+	}
+} );
+
+//
+
+Object.defineProperties( THREE.Material.prototype, {
+	wrapAround: {
+		get: function () {
+			console.warn( 'THREE.' + this.type + ': .wrapAround has been removed.' );
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.' + this.type + ': .wrapAround has been removed.' );
+		}
+	},
+	wrapRGB: {
+		get: function () {
+			console.warn( 'THREE.' + this.type + ': .wrapRGB has been removed.' );
+			return new THREE.Color();
+		}
+	}
+} );
+
+Object.defineProperties( THREE, {
+	PointCloudMaterial: {
+		value: function ( parameters ) {
+			console.warn( 'THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial.' );
+			return new THREE.PointsMaterial( parameters );
+		}
+	},
+	ParticleBasicMaterial: {
+		value: function ( parameters ) {
+			console.warn( 'THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial.' );
+			return new THREE.PointsMaterial( parameters );
+		}
+	},
+	ParticleSystemMaterial:{
+		value: function ( parameters ) {
+			console.warn( 'THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial.' );
+			return new THREE.PointsMaterial( parameters );
+		}
+	}
+} );
+
+Object.defineProperties( THREE.MeshPhongMaterial.prototype, {
+	metal: {
+		get: function () {
+			console.warn( 'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead.' );
+			return false;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead' );
+		}
+	}
+} );
+
+Object.defineProperties( THREE.ShaderMaterial.prototype, {
+	derivatives: {
+		get: function () {
+			console.warn( 'THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives.' );
+			return this.extensions.derivatives;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives.' );
+			this.extensions.derivatives = value;
+		}
+	}
+} );
+
+//
+
+Object.defineProperties( THREE.WebGLRenderer.prototype, {
+	supportsFloatTextures: {
+		value: function () {
+			console.warn( 'THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( \'OES_texture_float\' ).' );
+			return this.extensions.get( 'OES_texture_float' );
+		}
+	},
+	supportsHalfFloatTextures: {
+		value: function () {
+			console.warn( 'THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( \'OES_texture_half_float\' ).' );
+			return this.extensions.get( 'OES_texture_half_float' );
+		}
+	},
+	supportsStandardDerivatives: {
+		value: function () {
+			console.warn( 'THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( \'OES_standard_derivatives\' ).' );
+			return this.extensions.get( 'OES_standard_derivatives' );
+		}
+	},
+	supportsCompressedTextureS3TC: {
+		value: function () {
+			console.warn( 'THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( \'WEBGL_compressed_texture_s3tc\' ).' );
+			return this.extensions.get( 'WEBGL_compressed_texture_s3tc' );
+		}
+	},
+	supportsCompressedTexturePVRTC: {
+		value: function () {
+			console.warn( 'THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( \'WEBGL_compressed_texture_pvrtc\' ).' );
+			return this.extensions.get( 'WEBGL_compressed_texture_pvrtc' );
+		}
+	},
+	supportsBlendMinMax: {
+		value: function () {
+			console.warn( 'THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( \'EXT_blend_minmax\' ).' );
+			return this.extensions.get( 'EXT_blend_minmax' );
+		}
+	},
+	supportsVertexTextures: {
+		value: function () {
+			return this.capabilities.vertexTextures;
+		}
+	},
+	supportsInstancedArrays: {
+		value: function () {
+			console.warn( 'THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( \'ANGLE_instanced_arrays\' ).' );
+			return this.extensions.get( 'ANGLE_instanced_arrays' );
+		}
+	},
+	enableScissorTest: {
+		value: function ( boolean ) {
+			console.warn( 'THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest().' );
+			this.setScissorTest( boolean );
+		}
+	},
+	initMaterial: {
+		value: function () {
+			console.warn( 'THREE.WebGLRenderer: .initMaterial() has been removed.' );
+		}
+	},
+	addPrePlugin: {
+		value: function () {
+			console.warn( 'THREE.WebGLRenderer: .addPrePlugin() has been removed.' );
+		}
+	},
+	addPostPlugin: {
+		value: function () {
+			console.warn( 'THREE.WebGLRenderer: .addPostPlugin() has been removed.' );
+		}
+	},
+	updateShadowMap: {
+		value: function () {
+			console.warn( 'THREE.WebGLRenderer: .updateShadowMap() has been removed.' );
+		}
+	},
+	shadowMapEnabled: {
+		get: function () {
+			return this.shadowMap.enabled;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled.' );
+			this.shadowMap.enabled = value;
+		}
+	},
+	shadowMapType: {
+		get: function () {
+			return this.shadowMap.type;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type.' );
+			this.shadowMap.type = value;
+		}
+	},
+	shadowMapCullFace: {
+		get: function () {
+			return this.shadowMap.cullFace;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.WebGLRenderer: .shadowMapCullFace is now .shadowMap.cullFace.' );
+			this.shadowMap.cullFace = value;
+		}
+	}
+} );
+
+//
+
+Object.defineProperties( THREE.WebGLRenderTarget.prototype, {
+	wrapS: {
+		get: function () {
+			console.warn( 'THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.' );
+			return this.texture.wrapS;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.' );
+			this.texture.wrapS = value;
+		}
+	},
+	wrapT: {
+		get: function () {
+			console.warn( 'THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.' );
+			return this.texture.wrapT;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.' );
+			this.texture.wrapT = value;
+		}
+	},
+	magFilter: {
+		get: function () {
+			console.warn( 'THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.' );
+			return this.texture.magFilter;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.' );
+			this.texture.magFilter = value;
+		}
+	},
+	minFilter: {
+		get: function () {
+			console.warn( 'THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.' );
+			return this.texture.minFilter;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.' );
+			this.texture.minFilter = value;
+		}
+	},
+	anisotropy: {
+		get: function () {
+			console.warn( 'THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.' );
+			return this.texture.anisotropy;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.' );
+			this.texture.anisotropy = value;
+		}
+	},
+	offset: {
+		get: function () {
+			console.warn( 'THREE.WebGLRenderTarget: .offset is now .texture.offset.' );
+			return this.texture.offset;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.WebGLRenderTarget: .offset is now .texture.offset.' );
+			this.texture.offset = value;
+		}
+	},
+	repeat: {
+		get: function () {
+			console.warn( 'THREE.WebGLRenderTarget: .repeat is now .texture.repeat.' );
+			return this.texture.repeat;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.WebGLRenderTarget: .repeat is now .texture.repeat.' );
+			this.texture.repeat = value;
+		}
+	},
+	format: {
+		get: function () {
+			console.warn( 'THREE.WebGLRenderTarget: .format is now .texture.format.' );
+			return this.texture.format;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.WebGLRenderTarget: .format is now .texture.format.' );
+			this.texture.format = value;
+		}
+	},
+	type: {
+		get: function () {
+			console.warn( 'THREE.WebGLRenderTarget: .type is now .texture.type.' );
+			return this.texture.type;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.WebGLRenderTarget: .type is now .texture.type.' );
+			this.texture.type = value;
+		}
+	},
+	generateMipmaps: {
+		get: function () {
+			console.warn( 'THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.' );
+			return this.texture.generateMipmaps;
+		},
+		set: function ( value ) {
+			console.warn( 'THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.' );
+			this.texture.generateMipmaps = value;
+		}
+	}
+} );
+
+//
+
+Object.defineProperties( THREE.Audio.prototype, {
+	load: {
+		value: function ( file ) {
+
+			console.warn( 'THREE.Audio: .load has been deprecated. Please use THREE.AudioLoader.' );
+
+			var scope = this;
+
+			var audioLoader = new THREE.AudioLoader();
+
+			audioLoader.load( file, function ( buffer ) {
+
+				scope.setBuffer( buffer );
+
+			} );
+
+			return this;
+
+		}
+	}
+} );
+
+//
+
+THREE.GeometryUtils = {
+
+	merge: function ( geometry1, geometry2, materialIndexOffset ) {
+
+		console.warn( 'THREE.GeometryUtils: .merge() has been moved to Geometry. Use geometry.merge( geometry2, matrix, materialIndexOffset ) instead.' );
+
+		var matrix;
+
+		if ( geometry2 instanceof THREE.Mesh ) {
+
+			geometry2.matrixAutoUpdate && geometry2.updateMatrix();
+
+			matrix = geometry2.matrix;
+			geometry2 = geometry2.geometry;
+
+		}
+
+		geometry1.merge( geometry2, matrix, materialIndexOffset );
+
+	},
+
+	center: function ( geometry ) {
+
+		console.warn( 'THREE.GeometryUtils: .center() has been moved to Geometry. Use geometry.center() instead.' );
+		return geometry.center();
+
+	}
+
+};
+
+THREE.ImageUtils = {
+
+	crossOrigin: undefined,
+
+	loadTexture: function ( url, mapping, onLoad, onError ) {
+
+		console.warn( 'THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.' );
+
+		var loader = new THREE.TextureLoader();
+		loader.setCrossOrigin( this.crossOrigin );
+
+		var texture = loader.load( url, onLoad, undefined, onError );
+
+		if ( mapping ) texture.mapping = mapping;
+
+		return texture;
+
+	},
+
+	loadTextureCube: function ( urls, mapping, onLoad, onError ) {
+
+		console.warn( 'THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.' );
+
+		var loader = new THREE.CubeTextureLoader();
+		loader.setCrossOrigin( this.crossOrigin );
+
+		var texture = loader.load( urls, onLoad, undefined, onError );
+
+		if ( mapping ) texture.mapping = mapping;
+
+		return texture;
+
+	},
+
+	loadCompressedTexture: function () {
+
+		console.error( 'THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.' );
+
+	},
+
+	loadCompressedTextureCube: function () {
+
+		console.error( 'THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.' );
+
+	}
+
+};
+
+//
+
+THREE.Projector = function () {
+
+	console.error( 'THREE.Projector has been moved to /examples/js/renderers/Projector.js.' );
+
+	this.projectVector = function ( vector, camera ) {
+
+		console.warn( 'THREE.Projector: .projectVector() is now vector.project().' );
+		vector.project( camera );
+
+	};
+
+	this.unprojectVector = function ( vector, camera ) {
+
+		console.warn( 'THREE.Projector: .unprojectVector() is now vector.unproject().' );
+		vector.unproject( camera );
+
+	};
+
+	this.pickingRay = function ( vector, camera ) {
+
+		console.error( 'THREE.Projector: .pickingRay() is now raycaster.setFromCamera().' );
+
+	};
+
+};
+
+//
+
+THREE.CanvasRenderer = function () {
+
+	console.error( 'THREE.CanvasRenderer has been moved to /examples/js/renderers/CanvasRenderer.js' );
+
+	this.domElement = document.createElement( 'canvas' );
+	this.clear = function () {};
+	this.render = function () {};
+	this.setClearColor = function () {};
+	this.setSize = function () {};
+
+};
+
+//
+
+THREE.MeshFaceMaterial = THREE.MultiMaterial;
+
+//
+
+Object.defineProperties( THREE.LOD.prototype, {
+	objects: {
+		get: function () {
+
+			console.warn( 'THREE.LOD: .objects has been renamed to .levels.' );
+			return this.levels;
+
+		}
+	}
+} );
+
+// File:src/extras/CurveUtils.js
+
+/**
+ * @author zz85 / http://www.lab4games.net/zz85/blog
+ */
+
+THREE.CurveUtils = {
+
+	tangentQuadraticBezier: function ( t, p0, p1, p2 ) {
+
+		return 2 * ( 1 - t ) * ( p1 - p0 ) + 2 * t * ( p2 - p1 );
+
+	},
+
+	// Puay Bing, thanks for helping with this derivative!
+
+	tangentCubicBezier: function ( t, p0, p1, p2, p3 ) {
+
+		return - 3 * p0 * ( 1 - t ) * ( 1 - t )  +
+			3 * p1 * ( 1 - t ) * ( 1 - t ) - 6 * t * p1 * ( 1 - t ) +
+			6 * t *  p2 * ( 1 - t ) - 3 * t * t * p2 +
+			3 * t * t * p3;
+
+	},
+
+	tangentSpline: function ( t, p0, p1, p2, p3 ) {
+
+		// To check if my formulas are correct
+
+		var h00 = 6 * t * t - 6 * t; 	// derived from 2t^3 − 3t^2 + 1
+		var h10 = 3 * t * t - 4 * t + 1; // t^3 − 2t^2 + t
+		var h01 = - 6 * t * t + 6 * t; 	// − 2t3 + 3t2
+		var h11 = 3 * t * t - 2 * t;	// t3 − t2
+
+		return h00 + h10 + h01 + h11;
+
+	},
+
+	// Catmull-Rom
+
+	interpolate: function( p0, p1, p2, p3, t ) {
+
+		var v0 = ( p2 - p0 ) * 0.5;
+		var v1 = ( p3 - p1 ) * 0.5;
+		var t2 = t * t;
+		var t3 = t * t2;
+		return ( 2 * p1 - 2 * p2 + v0 + v1 ) * t3 + ( - 3 * p1 + 3 * p2 - 2 * v0 - v1 ) * t2 + v0 * t + p1;
+
+	}
+
+};
+
+// File:src/extras/SceneUtils.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.SceneUtils = {
+
+	createMultiMaterialObject: function ( geometry, materials ) {
+
+		var group = new THREE.Group();
+
+		for ( var i = 0, l = materials.length; i < l; i ++ ) {
+
+			group.add( new THREE.Mesh( geometry, materials[ i ] ) );
+
+		}
+
+		return group;
+
+	},
+
+	detach: function ( child, parent, scene ) {
+
+		child.applyMatrix( parent.matrixWorld );
+		parent.remove( child );
+		scene.add( child );
+
+	},
+
+	attach: function ( child, scene, parent ) {
+
+		var matrixWorldInverse = new THREE.Matrix4();
+		matrixWorldInverse.getInverse( parent.matrixWorld );
+		child.applyMatrix( matrixWorldInverse );
+
+		scene.remove( child );
+		parent.add( child );
+
+	}
+
+};
+
+// File:src/extras/ShapeUtils.js
+
+/**
+ * @author zz85 / http://www.lab4games.net/zz85/blog
+ */
+
+THREE.ShapeUtils = {
+
+	// calculate area of the contour polygon
+
+	area: function ( contour ) {
+
+		var n = contour.length;
+		var a = 0.0;
+
+		for ( var p = n - 1, q = 0; q < n; p = q ++ ) {
+
+			a += contour[ p ].x * contour[ q ].y - contour[ q ].x * contour[ p ].y;
+
+		}
+
+		return a * 0.5;
+
+	},
+
+	triangulate: ( function () {
+
+		/**
+		 * This code is a quick port of code written in C++ which was submitted to
+		 * flipcode.com by John W. Ratcliff  // July 22, 2000
+		 * See original code and more information here:
+		 * http://www.flipcode.com/archives/Efficient_Polygon_Triangulation.shtml
+		 *
+		 * ported to actionscript by Zevan Rosser
+		 * www.actionsnippet.com
+		 *
+		 * ported to javascript by Joshua Koo
+		 * http://www.lab4games.net/zz85/blog
+		 *
+		 */
+
+		function snip( contour, u, v, w, n, verts ) {
+
+			var p;
+			var ax, ay, bx, by;
+			var cx, cy, px, py;
+
+			ax = contour[ verts[ u ] ].x;
+			ay = contour[ verts[ u ] ].y;
+
+			bx = contour[ verts[ v ] ].x;
+			by = contour[ verts[ v ] ].y;
+
+			cx = contour[ verts[ w ] ].x;
+			cy = contour[ verts[ w ] ].y;
+
+			if ( Number.EPSILON > ( ( ( bx - ax ) * ( cy - ay ) ) - ( ( by - ay ) * ( cx - ax ) ) ) ) return false;
+
+			var aX, aY, bX, bY, cX, cY;
+			var apx, apy, bpx, bpy, cpx, cpy;
+			var cCROSSap, bCROSScp, aCROSSbp;
+
+			aX = cx - bx;  aY = cy - by;
+			bX = ax - cx;  bY = ay - cy;
+			cX = bx - ax;  cY = by - ay;
+
+			for ( p = 0; p < n; p ++ ) {
+
+				px = contour[ verts[ p ] ].x;
+				py = contour[ verts[ p ] ].y;
+
+				if ( ( ( px === ax ) && ( py === ay ) ) ||
+					 ( ( px === bx ) && ( py === by ) ) ||
+					 ( ( px === cx ) && ( py === cy ) ) )	continue;
+
+				apx = px - ax;  apy = py - ay;
+				bpx = px - bx;  bpy = py - by;
+				cpx = px - cx;  cpy = py - cy;
+
+				// see if p is inside triangle abc
+
+				aCROSSbp = aX * bpy - aY * bpx;
+				cCROSSap = cX * apy - cY * apx;
+				bCROSScp = bX * cpy - bY * cpx;
+
+				if ( ( aCROSSbp >= - Number.EPSILON ) && ( bCROSScp >= - Number.EPSILON ) && ( cCROSSap >= - Number.EPSILON ) ) return false;
+
+			}
+
+			return true;
+
+		}
+
+		// takes in an contour array and returns
+
+		return function ( contour, indices ) {
+
+			var n = contour.length;
+
+			if ( n < 3 ) return null;
+
+			var result = [],
+				verts = [],
+				vertIndices = [];
+
+			/* we want a counter-clockwise polygon in verts */
+
+			var u, v, w;
+
+			if ( THREE.ShapeUtils.area( contour ) > 0.0 ) {
+
+				for ( v = 0; v < n; v ++ ) verts[ v ] = v;
+
+			} else {
+
+				for ( v = 0; v < n; v ++ ) verts[ v ] = ( n - 1 ) - v;
+
+			}
+
+			var nv = n;
+
+			/*  remove nv - 2 vertices, creating 1 triangle every time */
+
+			var count = 2 * nv;   /* error detection */
+
+			for ( v = nv - 1; nv > 2; ) {
+
+				/* if we loop, it is probably a non-simple polygon */
+
+				if ( ( count -- ) <= 0 ) {
+
+					//** Triangulate: ERROR - probable bad polygon!
+
+					//throw ( "Warning, unable to triangulate polygon!" );
+					//return null;
+					// Sometimes warning is fine, especially polygons are triangulated in reverse.
+					console.warn( 'THREE.ShapeUtils: Unable to triangulate polygon! in triangulate()' );
+
+					if ( indices ) return vertIndices;
+					return result;
+
+				}
+
+				/* three consecutive vertices in current polygon, <u,v,w> */
+
+				u = v; 	 	if ( nv <= u ) u = 0;     /* previous */
+				v = u + 1;  if ( nv <= v ) v = 0;     /* new v    */
+				w = v + 1;  if ( nv <= w ) w = 0;     /* next     */
+
+				if ( snip( contour, u, v, w, nv, verts ) ) {
+
+					var a, b, c, s, t;
+
+					/* true names of the vertices */
+
+					a = verts[ u ];
+					b = verts[ v ];
+					c = verts[ w ];
+
+					/* output Triangle */
+
+					result.push( [ contour[ a ],
+						contour[ b ],
+						contour[ c ] ] );
+
+
+					vertIndices.push( [ verts[ u ], verts[ v ], verts[ w ] ] );
+
+					/* remove v from the remaining polygon */
+
+					for ( s = v, t = v + 1; t < nv; s ++, t ++ ) {
+
+						verts[ s ] = verts[ t ];
+
+					}
+
+					nv --;
+
+					/* reset error detection counter */
+
+					count = 2 * nv;
+
+				}
+
+			}
+
+			if ( indices ) return vertIndices;
+			return result;
+
+		}
+
+	} )(),
+
+	triangulateShape: function ( contour, holes ) {
+
+		function point_in_segment_2D_colin( inSegPt1, inSegPt2, inOtherPt ) {
+
+			// inOtherPt needs to be collinear to the inSegment
+			if ( inSegPt1.x !== inSegPt2.x ) {
+
+				if ( inSegPt1.x < inSegPt2.x ) {
+
+					return	( ( inSegPt1.x <= inOtherPt.x ) && ( inOtherPt.x <= inSegPt2.x ) );
+
+				} else {
+
+					return	( ( inSegPt2.x <= inOtherPt.x ) && ( inOtherPt.x <= inSegPt1.x ) );
+
+				}
+
+			} else {
+
+				if ( inSegPt1.y < inSegPt2.y ) {
+
+					return	( ( inSegPt1.y <= inOtherPt.y ) && ( inOtherPt.y <= inSegPt2.y ) );
+
+				} else {
+
+					return	( ( inSegPt2.y <= inOtherPt.y ) && ( inOtherPt.y <= inSegPt1.y ) );
+
+				}
+
+			}
+
+		}
+
+		function intersect_segments_2D( inSeg1Pt1, inSeg1Pt2, inSeg2Pt1, inSeg2Pt2, inExcludeAdjacentSegs ) {
+
+			var seg1dx = inSeg1Pt2.x - inSeg1Pt1.x,   seg1dy = inSeg1Pt2.y - inSeg1Pt1.y;
+			var seg2dx = inSeg2Pt2.x - inSeg2Pt1.x,   seg2dy = inSeg2Pt2.y - inSeg2Pt1.y;
+
+			var seg1seg2dx = inSeg1Pt1.x - inSeg2Pt1.x;
+			var seg1seg2dy = inSeg1Pt1.y - inSeg2Pt1.y;
+
+			var limit		= seg1dy * seg2dx - seg1dx * seg2dy;
+			var perpSeg1	= seg1dy * seg1seg2dx - seg1dx * seg1seg2dy;
+
+			if ( Math.abs( limit ) > Number.EPSILON ) {
+
+				// not parallel
+
+				var perpSeg2;
+				if ( limit > 0 ) {
+
+					if ( ( perpSeg1 < 0 ) || ( perpSeg1 > limit ) ) 		return [];
+					perpSeg2 = seg2dy * seg1seg2dx - seg2dx * seg1seg2dy;
+					if ( ( perpSeg2 < 0 ) || ( perpSeg2 > limit ) ) 		return [];
+
+				} else {
+
+					if ( ( perpSeg1 > 0 ) || ( perpSeg1 < limit ) ) 		return [];
+					perpSeg2 = seg2dy * seg1seg2dx - seg2dx * seg1seg2dy;
+					if ( ( perpSeg2 > 0 ) || ( perpSeg2 < limit ) ) 		return [];
+
+				}
+
+				// i.e. to reduce rounding errors
+				// intersection at endpoint of segment#1?
+				if ( perpSeg2 === 0 ) {
+
+					if ( ( inExcludeAdjacentSegs ) &&
+						 ( ( perpSeg1 === 0 ) || ( perpSeg1 === limit ) ) )		return [];
+					return [ inSeg1Pt1 ];
+
+				}
+				if ( perpSeg2 === limit ) {
+
+					if ( ( inExcludeAdjacentSegs ) &&
+						 ( ( perpSeg1 === 0 ) || ( perpSeg1 === limit ) ) )		return [];
+					return [ inSeg1Pt2 ];
+
+				}
+				// intersection at endpoint of segment#2?
+				if ( perpSeg1 === 0 )		return [ inSeg2Pt1 ];
+				if ( perpSeg1 === limit )	return [ inSeg2Pt2 ];
+
+				// return real intersection point
+				var factorSeg1 = perpSeg2 / limit;
+				return	[ { x: inSeg1Pt1.x + factorSeg1 * seg1dx,
+							y: inSeg1Pt1.y + factorSeg1 * seg1dy } ];
+
+			} else {
+
+				// parallel or collinear
+				if ( ( perpSeg1 !== 0 ) ||
+					 ( seg2dy * seg1seg2dx !== seg2dx * seg1seg2dy ) ) 			return [];
+
+				// they are collinear or degenerate
+				var seg1Pt = ( ( seg1dx === 0 ) && ( seg1dy === 0 ) );	// segment1 is just a point?
+				var seg2Pt = ( ( seg2dx === 0 ) && ( seg2dy === 0 ) );	// segment2 is just a point?
+				// both segments are points
+				if ( seg1Pt && seg2Pt ) {
+
+					if ( ( inSeg1Pt1.x !== inSeg2Pt1.x ) ||
+						 ( inSeg1Pt1.y !== inSeg2Pt1.y ) )		return [];	// they are distinct  points
+					return [ inSeg1Pt1 ];                 						// they are the same point
+
+				}
+				// segment#1  is a single point
+				if ( seg1Pt ) {
+
+					if ( ! point_in_segment_2D_colin( inSeg2Pt1, inSeg2Pt2, inSeg1Pt1 ) )		return [];		// but not in segment#2
+					return [ inSeg1Pt1 ];
+
+				}
+				// segment#2  is a single point
+				if ( seg2Pt ) {
+
+					if ( ! point_in_segment_2D_colin( inSeg1Pt1, inSeg1Pt2, inSeg2Pt1 ) )		return [];		// but not in segment#1
+					return [ inSeg2Pt1 ];
+
+				}
+
+				// they are collinear segments, which might overlap
+				var seg1min, seg1max, seg1minVal, seg1maxVal;
+				var seg2min, seg2max, seg2minVal, seg2maxVal;
+				if ( seg1dx !== 0 ) {
+
+					// the segments are NOT on a vertical line
+					if ( inSeg1Pt1.x < inSeg1Pt2.x ) {
+
+						seg1min = inSeg1Pt1; seg1minVal = inSeg1Pt1.x;
+						seg1max = inSeg1Pt2; seg1maxVal = inSeg1Pt2.x;
+
+					} else {
+
+						seg1min = inSeg1Pt2; seg1minVal = inSeg1Pt2.x;
+						seg1max = inSeg1Pt1; seg1maxVal = inSeg1Pt1.x;
+
+					}
+					if ( inSeg2Pt1.x < inSeg2Pt2.x ) {
+
+						seg2min = inSeg2Pt1; seg2minVal = inSeg2Pt1.x;
+						seg2max = inSeg2Pt2; seg2maxVal = inSeg2Pt2.x;
+
+					} else {
+
+						seg2min = inSeg2Pt2; seg2minVal = inSeg2Pt2.x;
+						seg2max = inSeg2Pt1; seg2maxVal = inSeg2Pt1.x;
+
+					}
+
+				} else {
+
+					// the segments are on a vertical line
+					if ( inSeg1Pt1.y < inSeg1Pt2.y ) {
+
+						seg1min = inSeg1Pt1; seg1minVal = inSeg1Pt1.y;
+						seg1max = inSeg1Pt2; seg1maxVal = inSeg1Pt2.y;
+
+					} else {
+
+						seg1min = inSeg1Pt2; seg1minVal = inSeg1Pt2.y;
+						seg1max = inSeg1Pt1; seg1maxVal = inSeg1Pt1.y;
+
+					}
+					if ( inSeg2Pt1.y < inSeg2Pt2.y ) {
+
+						seg2min = inSeg2Pt1; seg2minVal = inSeg2Pt1.y;
+						seg2max = inSeg2Pt2; seg2maxVal = inSeg2Pt2.y;
+
+					} else {
+
+						seg2min = inSeg2Pt2; seg2minVal = inSeg2Pt2.y;
+						seg2max = inSeg2Pt1; seg2maxVal = inSeg2Pt1.y;
+
+					}
+
+				}
+				if ( seg1minVal <= seg2minVal ) {
+
+					if ( seg1maxVal <  seg2minVal )	return [];
+					if ( seg1maxVal === seg2minVal )	{
+
+						if ( inExcludeAdjacentSegs )		return [];
+						return [ seg2min ];
+
+					}
+					if ( seg1maxVal <= seg2maxVal )	return [ seg2min, seg1max ];
+					return	[ seg2min, seg2max ];
+
+				} else {
+
+					if ( seg1minVal >  seg2maxVal )	return [];
+					if ( seg1minVal === seg2maxVal )	{
+
+						if ( inExcludeAdjacentSegs )		return [];
+						return [ seg1min ];
+
+					}
+					if ( seg1maxVal <= seg2maxVal )	return [ seg1min, seg1max ];
+					return	[ seg1min, seg2max ];
+
+				}
+
+			}
+
+		}
+
+		function isPointInsideAngle( inVertex, inLegFromPt, inLegToPt, inOtherPt ) {
+
+			// The order of legs is important
+
+			// translation of all points, so that Vertex is at (0,0)
+			var legFromPtX	= inLegFromPt.x - inVertex.x,  legFromPtY	= inLegFromPt.y - inVertex.y;
+			var legToPtX	= inLegToPt.x	- inVertex.x,  legToPtY		= inLegToPt.y	- inVertex.y;
+			var otherPtX	= inOtherPt.x	- inVertex.x,  otherPtY		= inOtherPt.y	- inVertex.y;
+
+			// main angle >0: < 180 deg.; 0: 180 deg.; <0: > 180 deg.
+			var from2toAngle	= legFromPtX * legToPtY - legFromPtY * legToPtX;
+			var from2otherAngle	= legFromPtX * otherPtY - legFromPtY * otherPtX;
+
+			if ( Math.abs( from2toAngle ) > Number.EPSILON ) {
+
+				// angle != 180 deg.
+
+				var other2toAngle		= otherPtX * legToPtY - otherPtY * legToPtX;
+				// console.log( "from2to: " + from2toAngle + ", from2other: " + from2otherAngle + ", other2to: " + other2toAngle );
+
+				if ( from2toAngle > 0 ) {
+
+					// main angle < 180 deg.
+					return	( ( from2otherAngle >= 0 ) && ( other2toAngle >= 0 ) );
+
+				} else {
+
+					// main angle > 180 deg.
+					return	( ( from2otherAngle >= 0 ) || ( other2toAngle >= 0 ) );
+
+				}
+
+			} else {
+
+				// angle == 180 deg.
+				// console.log( "from2to: 180 deg., from2other: " + from2otherAngle  );
+				return	( from2otherAngle > 0 );
+
+			}
+
+		}
+
+
+		function removeHoles( contour, holes ) {
+
+			var shape = contour.concat(); // work on this shape
+			var hole;
+
+			function isCutLineInsideAngles( inShapeIdx, inHoleIdx ) {
+
+				// Check if hole point lies within angle around shape point
+				var lastShapeIdx = shape.length - 1;
+
+				var prevShapeIdx = inShapeIdx - 1;
+				if ( prevShapeIdx < 0 )			prevShapeIdx = lastShapeIdx;
+
+				var nextShapeIdx = inShapeIdx + 1;
+				if ( nextShapeIdx > lastShapeIdx )	nextShapeIdx = 0;
+
+				var insideAngle = isPointInsideAngle( shape[ inShapeIdx ], shape[ prevShapeIdx ], shape[ nextShapeIdx ], hole[ inHoleIdx ] );
+				if ( ! insideAngle ) {
+
+					// console.log( "Vertex (Shape): " + inShapeIdx + ", Point: " + hole[inHoleIdx].x + "/" + hole[inHoleIdx].y );
+					return	false;
+
+				}
+
+				// Check if shape point lies within angle around hole point
+				var lastHoleIdx = hole.length - 1;
+
+				var prevHoleIdx = inHoleIdx - 1;
+				if ( prevHoleIdx < 0 )			prevHoleIdx = lastHoleIdx;
+
+				var nextHoleIdx = inHoleIdx + 1;
+				if ( nextHoleIdx > lastHoleIdx )	nextHoleIdx = 0;
+
+				insideAngle = isPointInsideAngle( hole[ inHoleIdx ], hole[ prevHoleIdx ], hole[ nextHoleIdx ], shape[ inShapeIdx ] );
+				if ( ! insideAngle ) {
+
+					// console.log( "Vertex (Hole): " + inHoleIdx + ", Point: " + shape[inShapeIdx].x + "/" + shape[inShapeIdx].y );
+					return	false;
+
+				}
+
+				return	true;
+
+			}
+
+			function intersectsShapeEdge( inShapePt, inHolePt ) {
+
+				// checks for intersections with shape edges
+				var sIdx, nextIdx, intersection;
+				for ( sIdx = 0; sIdx < shape.length; sIdx ++ ) {
+
+					nextIdx = sIdx + 1; nextIdx %= shape.length;
+					intersection = intersect_segments_2D( inShapePt, inHolePt, shape[ sIdx ], shape[ nextIdx ], true );
+					if ( intersection.length > 0 )		return	true;
+
+				}
+
+				return	false;
+
+			}
+
+			var indepHoles = [];
+
+			function intersectsHoleEdge( inShapePt, inHolePt ) {
+
+				// checks for intersections with hole edges
+				var ihIdx, chkHole,
+					hIdx, nextIdx, intersection;
+				for ( ihIdx = 0; ihIdx < indepHoles.length; ihIdx ++ ) {
+
+					chkHole = holes[ indepHoles[ ihIdx ]];
+					for ( hIdx = 0; hIdx < chkHole.length; hIdx ++ ) {
+
+						nextIdx = hIdx + 1; nextIdx %= chkHole.length;
+						intersection = intersect_segments_2D( inShapePt, inHolePt, chkHole[ hIdx ], chkHole[ nextIdx ], true );
+						if ( intersection.length > 0 )		return	true;
+
+					}
+
+				}
+				return	false;
+
+			}
+
+			var holeIndex, shapeIndex,
+				shapePt, holePt,
+				holeIdx, cutKey, failedCuts = [],
+				tmpShape1, tmpShape2,
+				tmpHole1, tmpHole2;
+
+			for ( var h = 0, hl = holes.length; h < hl; h ++ ) {
+
+				indepHoles.push( h );
+
+			}
+
+			var minShapeIndex = 0;
+			var counter = indepHoles.length * 2;
+			while ( indepHoles.length > 0 ) {
+
+				counter --;
+				if ( counter < 0 ) {
+
+					console.log( "Infinite Loop! Holes left:" + indepHoles.length + ", Probably Hole outside Shape!" );
+					break;
+
+				}
+
+				// search for shape-vertex and hole-vertex,
+				// which can be connected without intersections
+				for ( shapeIndex = minShapeIndex; shapeIndex < shape.length; shapeIndex ++ ) {
+
+					shapePt = shape[ shapeIndex ];
+					holeIndex	= - 1;
+
+					// search for hole which can be reached without intersections
+					for ( var h = 0; h < indepHoles.length; h ++ ) {
+
+						holeIdx = indepHoles[ h ];
+
+						// prevent multiple checks
+						cutKey = shapePt.x + ":" + shapePt.y + ":" + holeIdx;
+						if ( failedCuts[ cutKey ] !== undefined )			continue;
+
+						hole = holes[ holeIdx ];
+						for ( var h2 = 0; h2 < hole.length; h2 ++ ) {
+
+							holePt = hole[ h2 ];
+							if ( ! isCutLineInsideAngles( shapeIndex, h2 ) )		continue;
+							if ( intersectsShapeEdge( shapePt, holePt ) )		continue;
+							if ( intersectsHoleEdge( shapePt, holePt ) )		continue;
+
+							holeIndex = h2;
+							indepHoles.splice( h, 1 );
+
+							tmpShape1 = shape.slice( 0, shapeIndex + 1 );
+							tmpShape2 = shape.slice( shapeIndex );
+							tmpHole1 = hole.slice( holeIndex );
+							tmpHole2 = hole.slice( 0, holeIndex + 1 );
+
+							shape = tmpShape1.concat( tmpHole1 ).concat( tmpHole2 ).concat( tmpShape2 );
+
+							minShapeIndex = shapeIndex;
+
+							// Debug only, to show the selected cuts
+							// glob_CutLines.push( [ shapePt, holePt ] );
+
+							break;
+
+						}
+						if ( holeIndex >= 0 )	break;		// hole-vertex found
+
+						failedCuts[ cutKey ] = true;			// remember failure
+
+					}
+					if ( holeIndex >= 0 )	break;		// hole-vertex found
+
+				}
+
+			}
+
+			return shape; 			/* shape with no holes */
+
+		}
+
+
+		var i, il, f, face,
+			key, index,
+			allPointsMap = {};
+
+		// To maintain reference to old shape, one must match coordinates, or offset the indices from original arrays. It's probably easier to do the first.
+
+		var allpoints = contour.concat();
+
+		for ( var h = 0, hl = holes.length; h < hl; h ++ ) {
+
+			Array.prototype.push.apply( allpoints, holes[ h ] );
+
+		}
+
+		//console.log( "allpoints",allpoints, allpoints.length );
+
+		// prepare all points map
+
+		for ( i = 0, il = allpoints.length; i < il; i ++ ) {
+
+			key = allpoints[ i ].x + ":" + allpoints[ i ].y;
+
+			if ( allPointsMap[ key ] !== undefined ) {
+
+				console.warn( "THREE.Shape: Duplicate point", key );
+
+			}
+
+			allPointsMap[ key ] = i;
+
+		}
+
+		// remove holes by cutting paths to holes and adding them to the shape
+		var shapeWithoutHoles = removeHoles( contour, holes );
+
+		var triangles = THREE.ShapeUtils.triangulate( shapeWithoutHoles, false ); // True returns indices for points of spooled shape
+		//console.log( "triangles",triangles, triangles.length );
+
+		// check all face vertices against all points map
+
+		for ( i = 0, il = triangles.length; i < il; i ++ ) {
+
+			face = triangles[ i ];
+
+			for ( f = 0; f < 3; f ++ ) {
+
+				key = face[ f ].x + ":" + face[ f ].y;
+
+				index = allPointsMap[ key ];
+
+				if ( index !== undefined ) {
+
+					face[ f ] = index;
+
+				}
+
+			}
+
+		}
+
+		return triangles.concat();
+
+	},
+
+	isClockWise: function ( pts ) {
+
+		return THREE.ShapeUtils.area( pts ) < 0;
+
+	},
+
+	// Bezier Curves formulas obtained from
+	// http://en.wikipedia.org/wiki/B%C3%A9zier_curve
+
+	// Quad Bezier Functions
+
+	b2: ( function () {
+
+		function b2p0( t, p ) {
+
+			var k = 1 - t;
+			return k * k * p;
+
+		}
+
+		function b2p1( t, p ) {
+
+			return 2 * ( 1 - t ) * t * p;
+
+		}
+
+		function b2p2( t, p ) {
+
+			return t * t * p;
+
+		}
+
+		return function ( t, p0, p1, p2 ) {
+
+			return b2p0( t, p0 ) + b2p1( t, p1 ) + b2p2( t, p2 );
+
+		};
+
+	} )(),
+
+	// Cubic Bezier Functions
+
+	b3: ( function () {
+
+		function b3p0( t, p ) {
+
+			var k = 1 - t;
+			return k * k * k * p;
+
+		}
+
+		function b3p1( t, p ) {
+
+			var k = 1 - t;
+			return 3 * k * k * t * p;
+
+		}
+
+		function b3p2( t, p ) {
+
+			var k = 1 - t;
+			return 3 * k * t * t * p;
+
+		}
+
+		function b3p3( t, p ) {
+
+			return t * t * t * p;
+
+		}
+
+		return function ( t, p0, p1, p2, p3 ) {
+
+			return b3p0( t, p0 ) + b3p1( t, p1 ) + b3p2( t, p2 ) + b3p3( t, p3 );
+
+		};
+
+	} )()
+
+};
+
+// File:src/extras/core/Curve.js
+
+/**
+ * @author zz85 / http://www.lab4games.net/zz85/blog
+ * Extensible curve object
+ *
+ * Some common of Curve methods
+ * .getPoint(t), getTangent(t)
+ * .getPointAt(u), getTagentAt(u)
+ * .getPoints(), .getSpacedPoints()
+ * .getLength()
+ * .updateArcLengths()
+ *
+ * This following classes subclasses THREE.Curve:
+ *
+ * -- 2d classes --
+ * THREE.LineCurve
+ * THREE.QuadraticBezierCurve
+ * THREE.CubicBezierCurve
+ * THREE.SplineCurve
+ * THREE.ArcCurve
+ * THREE.EllipseCurve
+ *
+ * -- 3d classes --
+ * THREE.LineCurve3
+ * THREE.QuadraticBezierCurve3
+ * THREE.CubicBezierCurve3
+ * THREE.SplineCurve3
+ *
+ * A series of curves can be represented as a THREE.CurvePath
+ *
+ **/
+
+/**************************************************************
+ *	Abstract Curve base class
+ **************************************************************/
+
+THREE.Curve = function () {
+
+};
+
+THREE.Curve.prototype = {
+
+	constructor: THREE.Curve,
+
+	// Virtual base class method to overwrite and implement in subclasses
+	//	- t [0 .. 1]
+
+	getPoint: function ( t ) {
+
+		console.warn( "THREE.Curve: Warning, getPoint() not implemented!" );
+		return null;
+
+	},
+
+	// Get point at relative position in curve according to arc length
+	// - u [0 .. 1]
+
+	getPointAt: function ( u ) {
+
+		var t = this.getUtoTmapping( u );
+		return this.getPoint( t );
+
+	},
+
+	// Get sequence of points using getPoint( t )
+
+	getPoints: function ( divisions ) {
+
+		if ( ! divisions ) divisions = 5;
+
+		var d, pts = [];
+
+		for ( d = 0; d <= divisions; d ++ ) {
+
+			pts.push( this.getPoint( d / divisions ) );
+
+		}
+
+		return pts;
+
+	},
+
+	// Get sequence of points using getPointAt( u )
+
+	getSpacedPoints: function ( divisions ) {
+
+		if ( ! divisions ) divisions = 5;
+
+		var d, pts = [];
+
+		for ( d = 0; d <= divisions; d ++ ) {
+
+			pts.push( this.getPointAt( d / divisions ) );
+
+		}
+
+		return pts;
+
+	},
+
+	// Get total curve arc length
+
+	getLength: function () {
+
+		var lengths = this.getLengths();
+		return lengths[ lengths.length - 1 ];
+
+	},
+
+	// Get list of cumulative segment lengths
+
+	getLengths: function ( divisions ) {
+
+		if ( ! divisions ) divisions = ( this.__arcLengthDivisions ) ? ( this.__arcLengthDivisions ) : 200;
+
+		if ( this.cacheArcLengths
+			&& ( this.cacheArcLengths.length === divisions + 1 )
+			&& ! this.needsUpdate ) {
+
+			//console.log( "cached", this.cacheArcLengths );
+			return this.cacheArcLengths;
+
+		}
+
+		this.needsUpdate = false;
+
+		var cache = [];
+		var current, last = this.getPoint( 0 );
+		var p, sum = 0;
+
+		cache.push( 0 );
+
+		for ( p = 1; p <= divisions; p ++ ) {
+
+			current = this.getPoint ( p / divisions );
+			sum += current.distanceTo( last );
+			cache.push( sum );
+			last = current;
+
+		}
+
+		this.cacheArcLengths = cache;
+
+		return cache; // { sums: cache, sum:sum }; Sum is in the last element.
+
+	},
+
+	updateArcLengths: function() {
+
+		this.needsUpdate = true;
+		this.getLengths();
+
+	},
+
+	// Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant
+
+	getUtoTmapping: function ( u, distance ) {
+
+		var arcLengths = this.getLengths();
+
+		var i = 0, il = arcLengths.length;
+
+		var targetArcLength; // The targeted u distance value to get
+
+		if ( distance ) {
+
+			targetArcLength = distance;
+
+		} else {
+
+			targetArcLength = u * arcLengths[ il - 1 ];
+
+		}
+
+		//var time = Date.now();
+
+		// binary search for the index with largest value smaller than target u distance
+
+		var low = 0, high = il - 1, comparison;
+
+		while ( low <= high ) {
+
+			i = Math.floor( low + ( high - low ) / 2 ); // less likely to overflow, though probably not issue here, JS doesn't really have integers, all numbers are floats
+
+			comparison = arcLengths[ i ] - targetArcLength;
+
+			if ( comparison < 0 ) {
+
+				low = i + 1;
+
+			} else if ( comparison > 0 ) {
+
+				high = i - 1;
+
+			} else {
+
+				high = i;
+				break;
+
+				// DONE
+
+			}
+
+		}
+
+		i = high;
+
+		//console.log('b' , i, low, high, Date.now()- time);
+
+		if ( arcLengths[ i ] === targetArcLength ) {
+
+			var t = i / ( il - 1 );
+			return t;
+
+		}
+
+		// we could get finer grain at lengths, or use simple interpolation between two points
+
+		var lengthBefore = arcLengths[ i ];
+		var lengthAfter = arcLengths[ i + 1 ];
+
+		var segmentLength = lengthAfter - lengthBefore;
+
+		// determine where we are between the 'before' and 'after' points
+
+		var segmentFraction = ( targetArcLength - lengthBefore ) / segmentLength;
+
+		// add that fractional amount to t
+
+		var t = ( i + segmentFraction ) / ( il - 1 );
+
+		return t;
+
+	},
+
+	// Returns a unit vector tangent at t
+	// In case any sub curve does not implement its tangent derivation,
+	// 2 points a small delta apart will be used to find its gradient
+	// which seems to give a reasonable approximation
+
+	getTangent: function( t ) {
+
+		var delta = 0.0001;
+		var t1 = t - delta;
+		var t2 = t + delta;
+
+		// Capping in case of danger
+
+		if ( t1 < 0 ) t1 = 0;
+		if ( t2 > 1 ) t2 = 1;
+
+		var pt1 = this.getPoint( t1 );
+		var pt2 = this.getPoint( t2 );
+
+		var vec = pt2.clone().sub( pt1 );
+		return vec.normalize();
+
+	},
+
+	getTangentAt: function ( u ) {
+
+		var t = this.getUtoTmapping( u );
+		return this.getTangent( t );
+
+	}
+
+};
+
+// TODO: Transformation for Curves?
+
+/**************************************************************
+ *	3D Curves
+ **************************************************************/
+
+// A Factory method for creating new curve subclasses
+
+THREE.Curve.create = function ( constructor, getPointFunc ) {
+
+	constructor.prototype = Object.create( THREE.Curve.prototype );
+	constructor.prototype.constructor = constructor;
+	constructor.prototype.getPoint = getPointFunc;
+
+	return constructor;
+
+};
+
+// File:src/extras/core/CurvePath.js
+
+/**
+ * @author zz85 / http://www.lab4games.net/zz85/blog
+ *
+ **/
+
+/**************************************************************
+ *	Curved Path - a curve path is simply a array of connected
+ *  curves, but retains the api of a curve
+ **************************************************************/
+
+THREE.CurvePath = function () {
+
+	this.curves = [];
+
+	this.autoClose = false; // Automatically closes the path
+
+};
+
+THREE.CurvePath.prototype = Object.create( THREE.Curve.prototype );
+THREE.CurvePath.prototype.constructor = THREE.CurvePath;
+
+THREE.CurvePath.prototype.add = function ( curve ) {
+
+	this.curves.push( curve );
+
+};
+
+/*
+THREE.CurvePath.prototype.checkConnection = function() {
+	// TODO
+	// If the ending of curve is not connected to the starting
+	// or the next curve, then, this is not a real path
+};
+*/
+
+THREE.CurvePath.prototype.closePath = function() {
+
+	// TODO Test
+	// and verify for vector3 (needs to implement equals)
+	// Add a line curve if start and end of lines are not connected
+	var startPoint = this.curves[ 0 ].getPoint( 0 );
+	var endPoint = this.curves[ this.curves.length - 1 ].getPoint( 1 );
+
+	if ( ! startPoint.equals( endPoint ) ) {
+
+		this.curves.push( new THREE.LineCurve( endPoint, startPoint ) );
+
+	}
+
+};
+
+// To get accurate point with reference to
+// entire path distance at time t,
+// following has to be done:
+
+// 1. Length of each sub path have to be known
+// 2. Locate and identify type of curve
+// 3. Get t for the curve
+// 4. Return curve.getPointAt(t')
+
+THREE.CurvePath.prototype.getPoint = function( t ) {
+
+	var d = t * this.getLength();
+	var curveLengths = this.getCurveLengths();
+	var i = 0;
+
+	// To think about boundaries points.
+
+	while ( i < curveLengths.length ) {
+
+		if ( curveLengths[ i ] >= d ) {
+
+			var diff = curveLengths[ i ] - d;
+			var curve = this.curves[ i ];
+
+			var u = 1 - diff / curve.getLength();
+
+			return curve.getPointAt( u );
+
+		}
+
+		i ++;
+
+	}
+
+	return null;
+
+	// loop where sum != 0, sum > d , sum+1 <d
+
+};
+
+/*
+THREE.CurvePath.prototype.getTangent = function( t ) {
+};
+*/
+
+// We cannot use the default THREE.Curve getPoint() with getLength() because in
+// THREE.Curve, getLength() depends on getPoint() but in THREE.CurvePath
+// getPoint() depends on getLength
+
+THREE.CurvePath.prototype.getLength = function() {
+
+	var lens = this.getCurveLengths();
+	return lens[ lens.length - 1 ];
+
+};
+
+// Compute lengths and cache them
+// We cannot overwrite getLengths() because UtoT mapping uses it.
+
+THREE.CurvePath.prototype.getCurveLengths = function() {
+
+	// We use cache values if curves and cache array are same length
+
+	if ( this.cacheLengths && this.cacheLengths.length === this.curves.length ) {
+
+		return this.cacheLengths;
+
+	}
+
+	// Get length of sub-curve
+	// Push sums into cached array
+
+	var lengths = [], sums = 0;
+
+	for ( var i = 0, l = this.curves.length; i < l; i ++ ) {
+
+		sums += this.curves[ i ].getLength();
+		lengths.push( sums );
+
+	}
+
+	this.cacheLengths = lengths;
+
+	return lengths;
+
+};
+
+
+
+/**************************************************************
+ *	Create Geometries Helpers
+ **************************************************************/
+
+/// Generate geometry from path points (for Line or Points objects)
+
+THREE.CurvePath.prototype.createPointsGeometry = function( divisions ) {
+
+	var pts = this.getPoints( divisions );
+	return this.createGeometry( pts );
+
+};
+
+// Generate geometry from equidistant sampling along the path
+
+THREE.CurvePath.prototype.createSpacedPointsGeometry = function( divisions ) {
+
+	var pts = this.getSpacedPoints( divisions );
+	return this.createGeometry( pts );
+
+};
+
+THREE.CurvePath.prototype.createGeometry = function( points ) {
+
+	var geometry = new THREE.Geometry();
+
+	for ( var i = 0, l = points.length; i < l; i ++ ) {
+
+		var point = points[ i ];
+		geometry.vertices.push( new THREE.Vector3( point.x, point.y, point.z || 0 ) );
+
+	}
+
+	return geometry;
+
+};
+
+// File:src/extras/core/Font.js
+
+/**
+ * @author zz85 / http://www.lab4games.net/zz85/blog
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.Font = function ( data ) {
+
+	this.data = data;
+
+};
+
+THREE.Font.prototype = {
+
+	constructor: THREE.Font,
+
+	generateShapes: function ( text, size, divisions ) {
+
+		function createPaths( text ) {
+
+			var chars = String( text ).split( '' );
+			var scale = size / data.resolution;
+			var offset = 0;
+
+			var paths = [];
+
+			for ( var i = 0; i < chars.length; i ++ ) {
+
+				var ret = createPath( chars[ i ], scale, offset );
+				offset += ret.offset;
+
+				paths.push( ret.path );
+
+			}
+
+			return paths;
+
+		}
+
+		function createPath( c, scale, offset ) {
+
+			var glyph = data.glyphs[ c ] || data.glyphs[ '?' ];
+
+			if ( ! glyph ) return;
+
+			var path = new THREE.Path();
+
+			var pts = [], b2 = THREE.ShapeUtils.b2, b3 = THREE.ShapeUtils.b3;
+			var x, y, cpx, cpy, cpx0, cpy0, cpx1, cpy1, cpx2, cpy2, laste;
+
+			if ( glyph.o ) {
+
+				var outline = glyph._cachedOutline || ( glyph._cachedOutline = glyph.o.split( ' ' ) );
+
+				for ( var i = 0, l = outline.length; i < l; ) {
+
+					var action = outline[ i ++ ];
+
+					switch ( action ) {
+
+						case 'm': // moveTo
+
+							x = outline[ i ++ ] * scale + offset;
+							y = outline[ i ++ ] * scale;
+
+							path.moveTo( x, y );
+
+							break;
+
+						case 'l': // lineTo
+
+							x = outline[ i ++ ] * scale + offset;
+							y = outline[ i ++ ] * scale;
+
+							path.lineTo( x, y );
+
+							break;
+
+						case 'q': // quadraticCurveTo
+
+							cpx  = outline[ i ++ ] * scale + offset;
+							cpy  = outline[ i ++ ] * scale;
+							cpx1 = outline[ i ++ ] * scale + offset;
+							cpy1 = outline[ i ++ ] * scale;
+
+							path.quadraticCurveTo( cpx1, cpy1, cpx, cpy );
+
+							laste = pts[ pts.length - 1 ];
+
+							if ( laste ) {
+
+								cpx0 = laste.x;
+								cpy0 = laste.y;
+
+								for ( var i2 = 1; i2 <= divisions; i2 ++ ) {
+
+									var t = i2 / divisions;
+									b2( t, cpx0, cpx1, cpx );
+									b2( t, cpy0, cpy1, cpy );
+
+								}
+
+							}
+
+							break;
+
+						case 'b': // bezierCurveTo
+
+							cpx  = outline[ i ++ ] * scale + offset;
+							cpy  = outline[ i ++ ] * scale;
+							cpx1 = outline[ i ++ ] * scale + offset;
+							cpy1 = outline[ i ++ ] * scale;
+							cpx2 = outline[ i ++ ] * scale + offset;
+							cpy2 = outline[ i ++ ] * scale;
+
+							path.bezierCurveTo( cpx1, cpy1, cpx2, cpy2, cpx, cpy );
+
+							laste = pts[ pts.length - 1 ];
+
+							if ( laste ) {
+
+								cpx0 = laste.x;
+								cpy0 = laste.y;
+
+								for ( var i2 = 1; i2 <= divisions; i2 ++ ) {
+
+									var t = i2 / divisions;
+									b3( t, cpx0, cpx1, cpx2, cpx );
+									b3( t, cpy0, cpy1, cpy2, cpy );
+
+								}
+
+							}
+
+							break;
+
+					}
+
+				}
+
+			}
+
+			return { offset: glyph.ha * scale, path: path };
+
+		}
+
+		//
+
+		if ( size === undefined ) size = 100;
+		if ( divisions === undefined ) divisions = 4;
+
+		var data = this.data;
+
+		var paths = createPaths( text );
+		var shapes = [];
+
+		for ( var p = 0, pl = paths.length; p < pl; p ++ ) {
+
+			Array.prototype.push.apply( shapes, paths[ p ].toShapes() );
+
+		}
+
+		return shapes;
+
+	}
+
+};
+
+// File:src/extras/core/Path.js
+
+/**
+ * @author zz85 / http://www.lab4games.net/zz85/blog
+ * Creates free form 2d path using series of points, lines or curves.
+ *
+ **/
+
+THREE.Path = function ( points ) {
+
+	THREE.CurvePath.call( this );
+
+	this.actions = [];
+
+	if ( points ) {
+
+		this.fromPoints( points );
+
+	}
+
+};
+
+THREE.Path.prototype = Object.create( THREE.CurvePath.prototype );
+THREE.Path.prototype.constructor = THREE.Path;
+
+// TODO Clean up PATH API
+
+// Create path using straight lines to connect all points
+// - vectors: array of Vector2
+
+THREE.Path.prototype.fromPoints = function ( vectors ) {
+
+	this.moveTo( vectors[ 0 ].x, vectors[ 0 ].y );
+
+	for ( var i = 1, l = vectors.length; i < l; i ++ ) {
+
+		this.lineTo( vectors[ i ].x, vectors[ i ].y );
+
+	}
+
+};
+
+// startPath() endPath()?
+
+THREE.Path.prototype.moveTo = function ( x, y ) {
+
+	this.actions.push( { action: 'moveTo', args: [ x, y ] } );
+
+};
+
+THREE.Path.prototype.lineTo = function ( x, y ) {
+
+	var lastargs = this.actions[ this.actions.length - 1 ].args;
+
+	var x0 = lastargs[ lastargs.length - 2 ];
+	var y0 = lastargs[ lastargs.length - 1 ];
+
+	var curve = new THREE.LineCurve( new THREE.Vector2( x0, y0 ), new THREE.Vector2( x, y ) );
+	this.curves.push( curve );
+
+	this.actions.push( { action: 'lineTo', args: [ x, y ] } );
+
+};
+
+THREE.Path.prototype.quadraticCurveTo = function( aCPx, aCPy, aX, aY ) {
+
+	var lastargs = this.actions[ this.actions.length - 1 ].args;
+
+	var x0 = lastargs[ lastargs.length - 2 ];
+	var y0 = lastargs[ lastargs.length - 1 ];
+
+	var curve = new THREE.QuadraticBezierCurve(
+		new THREE.Vector2( x0, y0 ),
+		new THREE.Vector2( aCPx, aCPy ),
+		new THREE.Vector2( aX, aY )
+	);
+
+	this.curves.push( curve );
+
+	this.actions.push( { action: 'quadraticCurveTo', args: [ aCPx, aCPy, aX, aY ] } );
+
+};
+
+THREE.Path.prototype.bezierCurveTo = function( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) {
+
+	var lastargs = this.actions[ this.actions.length - 1 ].args;
+
+	var x0 = lastargs[ lastargs.length - 2 ];
+	var y0 = lastargs[ lastargs.length - 1 ];
+
+	var curve = new THREE.CubicBezierCurve(
+		new THREE.Vector2( x0, y0 ),
+		new THREE.Vector2( aCP1x, aCP1y ),
+		new THREE.Vector2( aCP2x, aCP2y ),
+		new THREE.Vector2( aX, aY )
+	);
+
+	this.curves.push( curve );
+
+	this.actions.push( { action: 'bezierCurveTo', args: [ aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ] } );
+
+};
+
+THREE.Path.prototype.splineThru = function( pts /*Array of Vector*/ ) {
+
+	var args = Array.prototype.slice.call( arguments );
+
+	var lastargs = this.actions[ this.actions.length - 1 ].args;
+
+	var x0 = lastargs[ lastargs.length - 2 ];
+	var y0 = lastargs[ lastargs.length - 1 ];
+
+	var npts = [ new THREE.Vector2( x0, y0 ) ];
+	Array.prototype.push.apply( npts, pts );
+
+	var curve = new THREE.SplineCurve( npts );
+	this.curves.push( curve );
+
+	this.actions.push( { action: 'splineThru', args: args } );
+
+};
+
+// FUTURE: Change the API or follow canvas API?
+
+THREE.Path.prototype.arc = function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {
+
+	var lastargs = this.actions[ this.actions.length - 1 ].args;
+	var x0 = lastargs[ lastargs.length - 2 ];
+	var y0 = lastargs[ lastargs.length - 1 ];
+
+	this.absarc( aX + x0, aY + y0, aRadius,
+		aStartAngle, aEndAngle, aClockwise );
+
+ };
+
+ THREE.Path.prototype.absarc = function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {
+
+	this.absellipse( aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );
+
+ };
+
+THREE.Path.prototype.ellipse = function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {
+
+	var lastargs = this.actions[ this.actions.length - 1 ].args;
+	var x0 = lastargs[ lastargs.length - 2 ];
+	var y0 = lastargs[ lastargs.length - 1 ];
+
+	this.absellipse( aX + x0, aY + y0, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );
+
+ };
+
+
+THREE.Path.prototype.absellipse = function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {
+
+	var args = [
+		aX, aY,
+		xRadius, yRadius,
+		aStartAngle, aEndAngle,
+		aClockwise,
+		aRotation || 0 // aRotation is optional.
+	];
+
+	var curve = new THREE.EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );
+	this.curves.push( curve );
+
+	var lastPoint = curve.getPoint( 1 );
+	args.push( lastPoint.x );
+	args.push( lastPoint.y );
+
+	this.actions.push( { action: 'ellipse', args: args } );
+
+ };
+
+THREE.Path.prototype.getSpacedPoints = function ( divisions ) {
+
+	if ( ! divisions ) divisions = 40;
+
+	var points = [];
+
+	for ( var i = 0; i < divisions; i ++ ) {
+
+		points.push( this.getPoint( i / divisions ) );
+
+		//if ( !this.getPoint( i / divisions ) ) throw "DIE";
+
+	}
+
+	if ( this.autoClose ) {
+
+		points.push( points[ 0 ] );
+
+	}
+
+	return points;
+
+};
+
+/* Return an array of vectors based on contour of the path */
+
+THREE.Path.prototype.getPoints = function( divisions ) {
+
+	divisions = divisions || 12;
+
+	var b2 = THREE.ShapeUtils.b2;
+	var b3 = THREE.ShapeUtils.b3;
+
+	var points = [];
+
+	var cpx, cpy, cpx2, cpy2, cpx1, cpy1, cpx0, cpy0,
+		laste, tx, ty;
+
+	for ( var i = 0, l = this.actions.length; i < l; i ++ ) {
+
+		var item = this.actions[ i ];
+
+		var action = item.action;
+		var args = item.args;
+
+		switch ( action ) {
+
+		case 'moveTo':
+
+			points.push( new THREE.Vector2( args[ 0 ], args[ 1 ] ) );
+
+			break;
+
+		case 'lineTo':
+
+			points.push( new THREE.Vector2( args[ 0 ], args[ 1 ] ) );
+
+			break;
+
+		case 'quadraticCurveTo':
+
+			cpx  = args[ 2 ];
+			cpy  = args[ 3 ];
+
+			cpx1 = args[ 0 ];
+			cpy1 = args[ 1 ];
+
+			if ( points.length > 0 ) {
+
+				laste = points[ points.length - 1 ];
+
+				cpx0 = laste.x;
+				cpy0 = laste.y;
+
+			} else {
+
+				laste = this.actions[ i - 1 ].args;
+
+				cpx0 = laste[ laste.length - 2 ];
+				cpy0 = laste[ laste.length - 1 ];
+
+			}
+
+			for ( var j = 1; j <= divisions; j ++ ) {
+
+				var t = j / divisions;
+
+				tx = b2( t, cpx0, cpx1, cpx );
+				ty = b2( t, cpy0, cpy1, cpy );
+
+				points.push( new THREE.Vector2( tx, ty ) );
+
+			}
+
+			break;
+
+		case 'bezierCurveTo':
+
+			cpx  = args[ 4 ];
+			cpy  = args[ 5 ];
+
+			cpx1 = args[ 0 ];
+			cpy1 = args[ 1 ];
+
+			cpx2 = args[ 2 ];
+			cpy2 = args[ 3 ];
+
+			if ( points.length > 0 ) {
+
+				laste = points[ points.length - 1 ];
+
+				cpx0 = laste.x;
+				cpy0 = laste.y;
+
+			} else {
+
+				laste = this.actions[ i - 1 ].args;
+
+				cpx0 = laste[ laste.length - 2 ];
+				cpy0 = laste[ laste.length - 1 ];
+
+			}
+
+
+			for ( var j = 1; j <= divisions; j ++ ) {
+
+				var t = j / divisions;
+
+				tx = b3( t, cpx0, cpx1, cpx2, cpx );
+				ty = b3( t, cpy0, cpy1, cpy2, cpy );
+
+				points.push( new THREE.Vector2( tx, ty ) );
+
+			}
+
+			break;
+
+		case 'splineThru':
+
+			laste = this.actions[ i - 1 ].args;
+
+			var last = new THREE.Vector2( laste[ laste.length - 2 ], laste[ laste.length - 1 ] );
+			var spts = [ last ];
+
+			var n = divisions * args[ 0 ].length;
+
+			spts = spts.concat( args[ 0 ] );
+
+			var spline = new THREE.SplineCurve( spts );
+
+			for ( var j = 1; j <= n; j ++ ) {
+
+				points.push( spline.getPointAt( j / n ) );
+
+			}
+
+			break;
+
+		case 'arc':
+
+			var aX = args[ 0 ], aY = args[ 1 ],
+				aRadius = args[ 2 ],
+				aStartAngle = args[ 3 ], aEndAngle = args[ 4 ],
+				aClockwise = !! args[ 5 ];
+
+			var deltaAngle = aEndAngle - aStartAngle;
+			var angle;
+			var tdivisions = divisions * 2;
+
+			for ( var j = 1; j <= tdivisions; j ++ ) {
+
+				var t = j / tdivisions;
+
+				if ( ! aClockwise ) {
+
+					t = 1 - t;
+
+				}
+
+				angle = aStartAngle + t * deltaAngle;
+
+				tx = aX + aRadius * Math.cos( angle );
+				ty = aY + aRadius * Math.sin( angle );
+
+				//console.log('t', t, 'angle', angle, 'tx', tx, 'ty', ty);
+
+				points.push( new THREE.Vector2( tx, ty ) );
+
+			}
+
+			//console.log(points);
+
+			break;
+
+		case 'ellipse':
+
+			var aX = args[ 0 ], aY = args[ 1 ],
+				xRadius = args[ 2 ],
+				yRadius = args[ 3 ],
+				aStartAngle = args[ 4 ], aEndAngle = args[ 5 ],
+				aClockwise = !! args[ 6 ],
+				aRotation = args[ 7 ];
+
+
+			var deltaAngle = aEndAngle - aStartAngle;
+			var angle;
+			var tdivisions = divisions * 2;
+
+			var cos, sin;
+			if ( aRotation !== 0 ) {
+
+				cos = Math.cos( aRotation );
+				sin = Math.sin( aRotation );
+
+			}
+
+			for ( var j = 1; j <= tdivisions; j ++ ) {
+
+				var t = j / tdivisions;
+
+				if ( ! aClockwise ) {
+
+					t = 1 - t;
+
+				}
+
+				angle = aStartAngle + t * deltaAngle;
+
+				tx = aX + xRadius * Math.cos( angle );
+				ty = aY + yRadius * Math.sin( angle );
+
+				if ( aRotation !== 0 ) {
+
+					var x = tx, y = ty;
+
+					// Rotate the point about the center of the ellipse.
+					tx = ( x - aX ) * cos - ( y - aY ) * sin + aX;
+					ty = ( x - aX ) * sin + ( y - aY ) * cos + aY;
+
+				}
+
+				//console.log('t', t, 'angle', angle, 'tx', tx, 'ty', ty);
+
+				points.push( new THREE.Vector2( tx, ty ) );
+
+			}
+
+			//console.log(points);
+
+			break;
+
+		} // end switch
+
+	}
+
+
+
+	// Normalize to remove the closing point by default.
+	var lastPoint = points[ points.length - 1 ];
+	if ( Math.abs( lastPoint.x - points[ 0 ].x ) < Number.EPSILON &&
+			 Math.abs( lastPoint.y - points[ 0 ].y ) < Number.EPSILON )
+		points.splice( points.length - 1, 1 );
+
+	if ( this.autoClose ) {
+
+		points.push( points[ 0 ] );
+
+	}
+
+	return points;
+
+};
+
+//
+// Breaks path into shapes
+//
+//	Assumptions (if parameter isCCW==true the opposite holds):
+//	- solid shapes are defined clockwise (CW)
+//	- holes are defined counterclockwise (CCW)
+//
+//	If parameter noHoles==true:
+//  - all subPaths are regarded as solid shapes
+//  - definition order CW/CCW has no relevance
+//
+
+THREE.Path.prototype.toShapes = function( isCCW, noHoles ) {
+
+	function extractSubpaths( inActions ) {
+
+		var subPaths = [], lastPath = new THREE.Path();
+
+		for ( var i = 0, l = inActions.length; i < l; i ++ ) {
+
+			var item = inActions[ i ];
+
+			var args = item.args;
+			var action = item.action;
+
+			if ( action === 'moveTo' ) {
+
+				if ( lastPath.actions.length !== 0 ) {
+
+					subPaths.push( lastPath );
+					lastPath = new THREE.Path();
+
+				}
+
+			}
+
+			lastPath[ action ].apply( lastPath, args );
+
+		}
+
+		if ( lastPath.actions.length !== 0 ) {
+
+			subPaths.push( lastPath );
+
+		}
+
+		// console.log(subPaths);
+
+		return	subPaths;
+
+	}
+
+	function toShapesNoHoles( inSubpaths ) {
+
+		var shapes = [];
+
+		for ( var i = 0, l = inSubpaths.length; i < l; i ++ ) {
+
+			var tmpPath = inSubpaths[ i ];
+
+			var tmpShape = new THREE.Shape();
+			tmpShape.actions = tmpPath.actions;
+			tmpShape.curves = tmpPath.curves;
+
+			shapes.push( tmpShape );
+
+		}
+
+		//console.log("shape", shapes);
+
+		return shapes;
+
+	}
+
+	function isPointInsidePolygon( inPt, inPolygon ) {
+
+		var polyLen = inPolygon.length;
+
+		// inPt on polygon contour => immediate success    or
+		// toggling of inside/outside at every single! intersection point of an edge
+		//  with the horizontal line through inPt, left of inPt
+		//  not counting lowerY endpoints of edges and whole edges on that line
+		var inside = false;
+		for ( var p = polyLen - 1, q = 0; q < polyLen; p = q ++ ) {
+
+			var edgeLowPt  = inPolygon[ p ];
+			var edgeHighPt = inPolygon[ q ];
+
+			var edgeDx = edgeHighPt.x - edgeLowPt.x;
+			var edgeDy = edgeHighPt.y - edgeLowPt.y;
+
+			if ( Math.abs( edgeDy ) > Number.EPSILON ) {
+
+				// not parallel
+				if ( edgeDy < 0 ) {
+
+					edgeLowPt  = inPolygon[ q ]; edgeDx = - edgeDx;
+					edgeHighPt = inPolygon[ p ]; edgeDy = - edgeDy;
+
+				}
+				if ( ( inPt.y < edgeLowPt.y ) || ( inPt.y > edgeHighPt.y ) ) 		continue;
+
+				if ( inPt.y === edgeLowPt.y ) {
+
+					if ( inPt.x === edgeLowPt.x )		return	true;		// inPt is on contour ?
+					// continue;				// no intersection or edgeLowPt => doesn't count !!!
+
+				} else {
+
+					var perpEdge = edgeDy * ( inPt.x - edgeLowPt.x ) - edgeDx * ( inPt.y - edgeLowPt.y );
+					if ( perpEdge === 0 )				return	true;		// inPt is on contour ?
+					if ( perpEdge < 0 ) 				continue;
+					inside = ! inside;		// true intersection left of inPt
+
+				}
+
+			} else {
+
+				// parallel or collinear
+				if ( inPt.y !== edgeLowPt.y ) 		continue;			// parallel
+				// edge lies on the same horizontal line as inPt
+				if ( ( ( edgeHighPt.x <= inPt.x ) && ( inPt.x <= edgeLowPt.x ) ) ||
+					 ( ( edgeLowPt.x <= inPt.x ) && ( inPt.x <= edgeHighPt.x ) ) )		return	true;	// inPt: Point on contour !
+				// continue;
+
+			}
+
+		}
+
+		return	inside;
+
+	}
+
+	var isClockWise = THREE.ShapeUtils.isClockWise;
+
+	var subPaths = extractSubpaths( this.actions );
+	if ( subPaths.length === 0 ) return [];
+
+	if ( noHoles === true )	return	toShapesNoHoles( subPaths );
+
+
+	var solid, tmpPath, tmpShape, shapes = [];
+
+	if ( subPaths.length === 1 ) {
+
+		tmpPath = subPaths[ 0 ];
+		tmpShape = new THREE.Shape();
+		tmpShape.actions = tmpPath.actions;
+		tmpShape.curves = tmpPath.curves;
+		shapes.push( tmpShape );
+		return shapes;
+
+	}
+
+	var holesFirst = ! isClockWise( subPaths[ 0 ].getPoints() );
+	holesFirst = isCCW ? ! holesFirst : holesFirst;
+
+	// console.log("Holes first", holesFirst);
+
+	var betterShapeHoles = [];
+	var newShapes = [];
+	var newShapeHoles = [];
+	var mainIdx = 0;
+	var tmpPoints;
+
+	newShapes[ mainIdx ] = undefined;
+	newShapeHoles[ mainIdx ] = [];
+
+	for ( var i = 0, l = subPaths.length; i < l; i ++ ) {
+
+		tmpPath = subPaths[ i ];
+		tmpPoints = tmpPath.getPoints();
+		solid = isClockWise( tmpPoints );
+		solid = isCCW ? ! solid : solid;
+
+		if ( solid ) {
+
+			if ( ( ! holesFirst ) && ( newShapes[ mainIdx ] ) )	mainIdx ++;
+
+			newShapes[ mainIdx ] = { s: new THREE.Shape(), p: tmpPoints };
+			newShapes[ mainIdx ].s.actions = tmpPath.actions;
+			newShapes[ mainIdx ].s.curves = tmpPath.curves;
+
+			if ( holesFirst )	mainIdx ++;
+			newShapeHoles[ mainIdx ] = [];
+
+			//console.log('cw', i);
+
+		} else {
+
+			newShapeHoles[ mainIdx ].push( { h: tmpPath, p: tmpPoints[ 0 ] } );
+
+			//console.log('ccw', i);
+
+		}
+
+	}
+
+	// only Holes? -> probably all Shapes with wrong orientation
+	if ( ! newShapes[ 0 ] )	return	toShapesNoHoles( subPaths );
+
+
+	if ( newShapes.length > 1 ) {
+
+		var ambiguous = false;
+		var toChange = [];
+
+		for ( var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {
+
+			betterShapeHoles[ sIdx ] = [];
+
+		}
+
+		for ( var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {
+
+			var sho = newShapeHoles[ sIdx ];
+
+			for ( var hIdx = 0; hIdx < sho.length; hIdx ++ ) {
+
+				var ho = sho[ hIdx ];
+				var hole_unassigned = true;
+
+				for ( var s2Idx = 0; s2Idx < newShapes.length; s2Idx ++ ) {
+
+					if ( isPointInsidePolygon( ho.p, newShapes[ s2Idx ].p ) ) {
+
+						if ( sIdx !== s2Idx )	toChange.push( { froms: sIdx, tos: s2Idx, hole: hIdx } );
+						if ( hole_unassigned ) {
+
+							hole_unassigned = false;
+							betterShapeHoles[ s2Idx ].push( ho );
+
+						} else {
+
+							ambiguous = true;
+
+						}
+
+					}
+
+				}
+				if ( hole_unassigned ) {
+
+					betterShapeHoles[ sIdx ].push( ho );
+
+				}
+
+			}
+
+		}
+		// console.log("ambiguous: ", ambiguous);
+		if ( toChange.length > 0 ) {
+
+			// console.log("to change: ", toChange);
+			if ( ! ambiguous )	newShapeHoles = betterShapeHoles;
+
+		}
+
+	}
+
+	var tmpHoles;
+
+	for ( var i = 0, il = newShapes.length; i < il; i ++ ) {
+
+		tmpShape = newShapes[ i ].s;
+		shapes.push( tmpShape );
+		tmpHoles = newShapeHoles[ i ];
+
+		for ( var j = 0, jl = tmpHoles.length; j < jl; j ++ ) {
+
+			tmpShape.holes.push( tmpHoles[ j ].h );
+
+		}
+
+	}
+
+	//console.log("shape", shapes);
+
+	return shapes;
+
+};
+
+// File:src/extras/core/Shape.js
+
+/**
+ * @author zz85 / http://www.lab4games.net/zz85/blog
+ * Defines a 2d shape plane using paths.
+ **/
+
+// STEP 1 Create a path.
+// STEP 2 Turn path into shape.
+// STEP 3 ExtrudeGeometry takes in Shape/Shapes
+// STEP 3a - Extract points from each shape, turn to vertices
+// STEP 3b - Triangulate each shape, add faces.
+
+THREE.Shape = function () {
+
+	THREE.Path.apply( this, arguments );
+
+	this.holes = [];
+
+};
+
+THREE.Shape.prototype = Object.create( THREE.Path.prototype );
+THREE.Shape.prototype.constructor = THREE.Shape;
+
+// Convenience method to return ExtrudeGeometry
+
+THREE.Shape.prototype.extrude = function ( options ) {
+
+	return new THREE.ExtrudeGeometry( this, options );
+
+};
+
+// Convenience method to return ShapeGeometry
+
+THREE.Shape.prototype.makeGeometry = function ( options ) {
+
+	return new THREE.ShapeGeometry( this, options );
+
+};
+
+// Get points of holes
+
+THREE.Shape.prototype.getPointsHoles = function ( divisions ) {
+
+	var holesPts = [];
+
+	for ( var i = 0, l = this.holes.length; i < l; i ++ ) {
+
+		holesPts[ i ] = this.holes[ i ].getPoints( divisions );
+
+	}
+
+	return holesPts;
+
+};
+
+
+// Get points of shape and holes (keypoints based on segments parameter)
+
+THREE.Shape.prototype.extractAllPoints = function ( divisions ) {
+
+	return {
+
+		shape: this.getPoints( divisions ),
+		holes: this.getPointsHoles( divisions )
+
+	};
+
+};
+
+THREE.Shape.prototype.extractPoints = function ( divisions ) {
+
+	return this.extractAllPoints( divisions );
+
+};
+
+// File:src/extras/curves/LineCurve.js
+
+/**************************************************************
+ *	Line
+ **************************************************************/
+
+THREE.LineCurve = function ( v1, v2 ) {
+
+	this.v1 = v1;
+	this.v2 = v2;
+
+};
+
+THREE.LineCurve.prototype = Object.create( THREE.Curve.prototype );
+THREE.LineCurve.prototype.constructor = THREE.LineCurve;
+
+THREE.LineCurve.prototype.getPoint = function ( t ) {
+
+	var point = this.v2.clone().sub( this.v1 );
+	point.multiplyScalar( t ).add( this.v1 );
+
+	return point;
+
+};
+
+// Line curve is linear, so we can overwrite default getPointAt
+
+THREE.LineCurve.prototype.getPointAt = function ( u ) {
+
+	return this.getPoint( u );
+
+};
+
+THREE.LineCurve.prototype.getTangent = function( t ) {
+
+	var tangent = this.v2.clone().sub( this.v1 );
+
+	return tangent.normalize();
+
+};
+
+// File:src/extras/curves/QuadraticBezierCurve.js
+
+/**************************************************************
+ *	Quadratic Bezier curve
+ **************************************************************/
+
+
+THREE.QuadraticBezierCurve = function ( v0, v1, v2 ) {
+
+	this.v0 = v0;
+	this.v1 = v1;
+	this.v2 = v2;
+
+};
+
+THREE.QuadraticBezierCurve.prototype = Object.create( THREE.Curve.prototype );
+THREE.QuadraticBezierCurve.prototype.constructor = THREE.QuadraticBezierCurve;
+
+
+THREE.QuadraticBezierCurve.prototype.getPoint = function ( t ) {
+
+	var b2 = THREE.ShapeUtils.b2;
+
+	return new THREE.Vector2(
+		b2( t, this.v0.x, this.v1.x, this.v2.x ),
+		b2( t, this.v0.y, this.v1.y, this.v2.y )
+	);
+
+};
+
+
+THREE.QuadraticBezierCurve.prototype.getTangent = function( t ) {
+
+	var tangentQuadraticBezier = THREE.CurveUtils.tangentQuadraticBezier;
+
+	return new THREE.Vector2(
+		tangentQuadraticBezier( t, this.v0.x, this.v1.x, this.v2.x ),
+		tangentQuadraticBezier( t, this.v0.y, this.v1.y, this.v2.y )
+	).normalize();
+
+};
+
+// File:src/extras/curves/CubicBezierCurve.js
+
+/**************************************************************
+ *	Cubic Bezier curve
+ **************************************************************/
+
+THREE.CubicBezierCurve = function ( v0, v1, v2, v3 ) {
+
+	this.v0 = v0;
+	this.v1 = v1;
+	this.v2 = v2;
+	this.v3 = v3;
+
+};
+
+THREE.CubicBezierCurve.prototype = Object.create( THREE.Curve.prototype );
+THREE.CubicBezierCurve.prototype.constructor = THREE.CubicBezierCurve;
+
+THREE.CubicBezierCurve.prototype.getPoint = function ( t ) {
+
+	var b3 = THREE.ShapeUtils.b3;
+
+	return new THREE.Vector2( 
+		b3( t, this.v0.x, this.v1.x, this.v2.x, this.v3.x ),
+		b3( t, this.v0.y, this.v1.y, this.v2.y, this.v3.y )
+	);
+
+};
+
+THREE.CubicBezierCurve.prototype.getTangent = function( t ) {
+
+	var tangentCubicBezier = THREE.CurveUtils.tangentCubicBezier;
+
+	return new THREE.Vector2( 
+		tangentCubicBezier( t, this.v0.x, this.v1.x, this.v2.x, this.v3.x ),
+		tangentCubicBezier( t, this.v0.y, this.v1.y, this.v2.y, this.v3.y )
+	).normalize();
+
+};
+
+// File:src/extras/curves/SplineCurve.js
+
+/**************************************************************
+ *	Spline curve
+ **************************************************************/
+
+THREE.SplineCurve = function ( points /* array of Vector2 */ ) {
+
+	this.points = ( points == undefined ) ? [] : points;
+
+};
+
+THREE.SplineCurve.prototype = Object.create( THREE.Curve.prototype );
+THREE.SplineCurve.prototype.constructor = THREE.SplineCurve;
+
+THREE.SplineCurve.prototype.getPoint = function ( t ) {
+
+	var points = this.points;
+	var point = ( points.length - 1 ) * t;
+
+	var intPoint = Math.floor( point );
+	var weight = point - intPoint;
+
+	var point0 = points[ intPoint === 0 ? intPoint : intPoint - 1 ];
+	var point1 = points[ intPoint ];
+	var point2 = points[ intPoint > points.length - 2 ? points.length - 1 : intPoint + 1 ];
+	var point3 = points[ intPoint > points.length - 3 ? points.length - 1 : intPoint + 2 ];
+
+	var interpolate = THREE.CurveUtils.interpolate;
+
+	return new THREE.Vector2(
+		interpolate( point0.x, point1.x, point2.x, point3.x, weight ),
+		interpolate( point0.y, point1.y, point2.y, point3.y, weight )
+	);
+
+};
+
+// File:src/extras/curves/EllipseCurve.js
+
+/**************************************************************
+ *	Ellipse curve
+ **************************************************************/
+
+THREE.EllipseCurve = function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {
+
+	this.aX = aX;
+	this.aY = aY;
+
+	this.xRadius = xRadius;
+	this.yRadius = yRadius;
+
+	this.aStartAngle = aStartAngle;
+	this.aEndAngle = aEndAngle;
+
+	this.aClockwise = aClockwise;
+	
+	this.aRotation = aRotation || 0;
+
+};
+
+THREE.EllipseCurve.prototype = Object.create( THREE.Curve.prototype );
+THREE.EllipseCurve.prototype.constructor = THREE.EllipseCurve;
+
+THREE.EllipseCurve.prototype.getPoint = function ( t ) {
+
+	var deltaAngle = this.aEndAngle - this.aStartAngle;
+
+	if ( deltaAngle < 0 ) deltaAngle += Math.PI * 2;
+	if ( deltaAngle > Math.PI * 2 ) deltaAngle -= Math.PI * 2;
+
+	var angle;
+
+	if ( this.aClockwise === true ) {
+
+		angle = this.aEndAngle + ( 1 - t ) * ( Math.PI * 2 - deltaAngle );
+
+	} else {
+
+		angle = this.aStartAngle + t * deltaAngle;
+
+	}
+	
+	var x = this.aX + this.xRadius * Math.cos( angle );
+	var y = this.aY + this.yRadius * Math.sin( angle );
+
+	if ( this.aRotation !== 0 ) {
+
+		var cos = Math.cos( this.aRotation );
+		var sin = Math.sin( this.aRotation );
+
+		var tx = x, ty = y;
+
+		// Rotate the point about the center of the ellipse.
+		x = ( tx - this.aX ) * cos - ( ty - this.aY ) * sin + this.aX;
+		y = ( tx - this.aX ) * sin + ( ty - this.aY ) * cos + this.aY;
+
+	}
+
+	return new THREE.Vector2( x, y );
+
+};
+
+// File:src/extras/curves/ArcCurve.js
+
+/**************************************************************
+ *	Arc curve
+ **************************************************************/
+
+THREE.ArcCurve = function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {
+
+	THREE.EllipseCurve.call( this, aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );
+
+};
+
+THREE.ArcCurve.prototype = Object.create( THREE.EllipseCurve.prototype );
+THREE.ArcCurve.prototype.constructor = THREE.ArcCurve;
+
+// File:src/extras/curves/LineCurve3.js
+
+/**************************************************************
+ *	Line3D
+ **************************************************************/
+
+THREE.LineCurve3 = THREE.Curve.create(
+
+	function ( v1, v2 ) {
+
+		this.v1 = v1;
+		this.v2 = v2;
+
+	},
+
+	function ( t ) {
+
+		var vector = new THREE.Vector3();
+
+		vector.subVectors( this.v2, this.v1 ); // diff
+		vector.multiplyScalar( t );
+		vector.add( this.v1 );
+
+		return vector;
+
+	}
+
+);
+
+// File:src/extras/curves/QuadraticBezierCurve3.js
+
+/**************************************************************
+ *	Quadratic Bezier 3D curve
+ **************************************************************/
+
+THREE.QuadraticBezierCurve3 = THREE.Curve.create(
+
+	function ( v0, v1, v2 ) {
+
+		this.v0 = v0;
+		this.v1 = v1;
+		this.v2 = v2;
+
+	},
+
+	function ( t ) {
+
+		var b2 = THREE.ShapeUtils.b2;		
+
+		return new THREE.Vector3(
+			b2( t, this.v0.x, this.v1.x, this.v2.x ),
+			b2( t, this.v0.y, this.v1.y, this.v2.y ),
+			b2( t, this.v0.z, this.v1.z, this.v2.z )
+		);
+
+	}
+
+);
+
+// File:src/extras/curves/CubicBezierCurve3.js
+
+/**************************************************************
+ *	Cubic Bezier 3D curve
+ **************************************************************/
+
+THREE.CubicBezierCurve3 = THREE.Curve.create(
+
+	function ( v0, v1, v2, v3 ) {
+
+		this.v0 = v0;
+		this.v1 = v1;
+		this.v2 = v2;
+		this.v3 = v3;
+
+	},
+
+	function ( t ) {
+
+		var b3 = THREE.ShapeUtils.b3;
+
+		return new THREE.Vector3(
+			b3( t, this.v0.x, this.v1.x, this.v2.x, this.v3.x ),
+			b3( t, this.v0.y, this.v1.y, this.v2.y, this.v3.y ),
+			b3( t, this.v0.z, this.v1.z, this.v2.z, this.v3.z )
+		);
+
+	}
+
+);
+
+// File:src/extras/curves/SplineCurve3.js
+
+/**************************************************************
+ *	Spline 3D curve
+ **************************************************************/
+
+
+THREE.SplineCurve3 = THREE.Curve.create(
+
+	function ( points /* array of Vector3 */ ) {
+
+		console.warn( 'THREE.SplineCurve3 will be deprecated. Please use THREE.CatmullRomCurve3' );
+		this.points = ( points == undefined ) ? [] : points;
+
+	},
+
+	function ( t ) {
+
+		var points = this.points;
+		var point = ( points.length - 1 ) * t;
+
+		var intPoint = Math.floor( point );
+		var weight = point - intPoint;
+
+		var point0 = points[ intPoint == 0 ? intPoint : intPoint - 1 ];
+		var point1 = points[ intPoint ];
+		var point2 = points[ intPoint > points.length - 2 ? points.length - 1 : intPoint + 1 ];
+		var point3 = points[ intPoint > points.length - 3 ? points.length - 1 : intPoint + 2 ];
+
+		var interpolate = THREE.CurveUtils.interpolate;
+
+		return new THREE.Vector3(
+			interpolate( point0.x, point1.x, point2.x, point3.x, weight ),
+			interpolate( point0.y, point1.y, point2.y, point3.y, weight ),
+			interpolate( point0.z, point1.z, point2.z, point3.z, weight )
+		);
+
+	}
+
+);
+
+// File:src/extras/curves/CatmullRomCurve3.js
+
+/**
+ * @author zz85 https://github.com/zz85
+ *
+ * Centripetal CatmullRom Curve - which is useful for avoiding
+ * cusps and self-intersections in non-uniform catmull rom curves.
+ * http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf
+ *
+ * curve.type accepts centripetal(default), chordal and catmullrom
+ * curve.tension is used for catmullrom which defaults to 0.5
+ */
+
+THREE.CatmullRomCurve3 = ( function() {
+
+	var
+		tmp = new THREE.Vector3(),
+		px = new CubicPoly(),
+		py = new CubicPoly(),
+		pz = new CubicPoly();
+
+	/*
+	Based on an optimized c++ solution in
+	 - http://stackoverflow.com/questions/9489736/catmull-rom-curve-with-no-cusps-and-no-self-intersections/
+	 - http://ideone.com/NoEbVM
+
+	This CubicPoly class could be used for reusing some variables and calculations,
+	but for three.js curve use, it could be possible inlined and flatten into a single function call
+	which can be placed in CurveUtils.
+	*/
+
+	function CubicPoly() {
+
+	}
+
+	/*
+	 * Compute coefficients for a cubic polynomial
+	 *   p(s) = c0 + c1*s + c2*s^2 + c3*s^3
+	 * such that
+	 *   p(0) = x0, p(1) = x1
+	 *  and
+	 *   p'(0) = t0, p'(1) = t1.
+	 */
+	CubicPoly.prototype.init = function( x0, x1, t0, t1 ) {
+
+		this.c0 = x0;
+		this.c1 = t0;
+		this.c2 = - 3 * x0 + 3 * x1 - 2 * t0 - t1;
+		this.c3 = 2 * x0 - 2 * x1 + t0 + t1;
+
+	};
+
+	CubicPoly.prototype.initNonuniformCatmullRom = function( x0, x1, x2, x3, dt0, dt1, dt2 ) {
+
+		// compute tangents when parameterized in [t1,t2]
+		var t1 = ( x1 - x0 ) / dt0 - ( x2 - x0 ) / ( dt0 + dt1 ) + ( x2 - x1 ) / dt1;
+		var t2 = ( x2 - x1 ) / dt1 - ( x3 - x1 ) / ( dt1 + dt2 ) + ( x3 - x2 ) / dt2;
+
+		// rescale tangents for parametrization in [0,1]
+		t1 *= dt1;
+		t2 *= dt1;
+
+		// initCubicPoly
+		this.init( x1, x2, t1, t2 );
+
+	};
+
+	// standard Catmull-Rom spline: interpolate between x1 and x2 with previous/following points x1/x4
+	CubicPoly.prototype.initCatmullRom = function( x0, x1, x2, x3, tension ) {
+
+		this.init( x1, x2, tension * ( x2 - x0 ), tension * ( x3 - x1 ) );
+
+	};
+
+	CubicPoly.prototype.calc = function( t ) {
+
+		var t2 = t * t;
+		var t3 = t2 * t;
+		return this.c0 + this.c1 * t + this.c2 * t2 + this.c3 * t3;
+
+	};
+
+	// Subclass Three.js curve
+	return THREE.Curve.create(
+
+		function ( p /* array of Vector3 */ ) {
+
+			this.points = p || [];
+			this.closed = false;
+
+		},
+
+		function ( t ) {
+
+			var points = this.points,
+				point, intPoint, weight, l;
+
+			l = points.length;
+
+			if ( l < 2 ) console.log( 'duh, you need at least 2 points' );
+
+			point = ( l - ( this.closed ? 0 : 1 ) ) * t;
+			intPoint = Math.floor( point );
+			weight = point - intPoint;
+
+			if ( this.closed ) {
+
+				intPoint += intPoint > 0 ? 0 : ( Math.floor( Math.abs( intPoint ) / points.length ) + 1 ) * points.length;
+
+			} else if ( weight === 0 && intPoint === l - 1 ) {
+
+				intPoint = l - 2;
+				weight = 1;
+
+			}
+
+			var p0, p1, p2, p3; // 4 points
+
+			if ( this.closed || intPoint > 0 ) {
+
+				p0 = points[ ( intPoint - 1 ) % l ];
+
+			} else {
+
+				// extrapolate first point
+				tmp.subVectors( points[ 0 ], points[ 1 ] ).add( points[ 0 ] );
+				p0 = tmp;
+
+			}
+
+			p1 = points[ intPoint % l ];
+			p2 = points[ ( intPoint + 1 ) % l ];
+
+			if ( this.closed || intPoint + 2 < l ) {
+
+				p3 = points[ ( intPoint + 2 ) % l ];
+
+			} else {
+
+				// extrapolate last point
+				tmp.subVectors( points[ l - 1 ], points[ l - 2 ] ).add( points[ l - 1 ] );
+				p3 = tmp;
+
+			}
+
+			if ( this.type === undefined || this.type === 'centripetal' || this.type === 'chordal' ) {
+
+				// init Centripetal / Chordal Catmull-Rom
+				var pow = this.type === 'chordal' ? 0.5 : 0.25;
+				var dt0 = Math.pow( p0.distanceToSquared( p1 ), pow );
+				var dt1 = Math.pow( p1.distanceToSquared( p2 ), pow );
+				var dt2 = Math.pow( p2.distanceToSquared( p3 ), pow );
+
+				// safety check for repeated points
+				if ( dt1 < 1e-4 ) dt1 = 1.0;
+				if ( dt0 < 1e-4 ) dt0 = dt1;
+				if ( dt2 < 1e-4 ) dt2 = dt1;
+
+				px.initNonuniformCatmullRom( p0.x, p1.x, p2.x, p3.x, dt0, dt1, dt2 );
+				py.initNonuniformCatmullRom( p0.y, p1.y, p2.y, p3.y, dt0, dt1, dt2 );
+				pz.initNonuniformCatmullRom( p0.z, p1.z, p2.z, p3.z, dt0, dt1, dt2 );
+
+			} else if ( this.type === 'catmullrom' ) {
+
+				var tension = this.tension !== undefined ? this.tension : 0.5;
+				px.initCatmullRom( p0.x, p1.x, p2.x, p3.x, tension );
+				py.initCatmullRom( p0.y, p1.y, p2.y, p3.y, tension );
+				pz.initCatmullRom( p0.z, p1.z, p2.z, p3.z, tension );
+
+			}
+
+			var v = new THREE.Vector3(
+				px.calc( weight ),
+				py.calc( weight ),
+				pz.calc( weight )
+			);
+
+			return v;
+
+		}
+
+	);
+
+} )();
+
+// File:src/extras/curves/ClosedSplineCurve3.js
+
+/**************************************************************
+ *	Closed Spline 3D curve
+ **************************************************************/
+
+
+THREE.ClosedSplineCurve3 = function ( points ) {
+
+	console.warn( 'THREE.ClosedSplineCurve3 has been deprecated. Please use THREE.CatmullRomCurve3.' );
+
+	THREE.CatmullRomCurve3.call( this, points );
+	this.type = 'catmullrom';
+	this.closed = true;
+
+};
+
+THREE.ClosedSplineCurve3.prototype = Object.create( THREE.CatmullRomCurve3.prototype );
+
+// File:src/extras/geometries/BoxGeometry.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * based on http://papervision3d.googlecode.com/svn/trunk/as3/trunk/src/org/papervision3d/objects/primitives/Cube.as
+ */
+
+THREE.BoxGeometry = function ( width, height, depth, widthSegments, heightSegments, depthSegments ) {
+
+	THREE.Geometry.call( this );
+
+	this.type = 'BoxGeometry';
+
+	this.parameters = {
+		width: width,
+		height: height,
+		depth: depth,
+		widthSegments: widthSegments,
+		heightSegments: heightSegments,
+		depthSegments: depthSegments
+	};
+
+	this.fromBufferGeometry( new THREE.BoxBufferGeometry( width, height, depth, widthSegments, heightSegments, depthSegments ) );
+	this.mergeVertices();
+
+};
+
+THREE.BoxGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.BoxGeometry.prototype.constructor = THREE.BoxGeometry;
+
+THREE.CubeGeometry = THREE.BoxGeometry;
+
+// File:src/extras/geometries/BoxBufferGeometry.js
+
+/**
+ * @author Mugen87 / https://github.com/Mugen87
+ */
+
+THREE.BoxBufferGeometry = function ( width, height, depth, widthSegments, heightSegments, depthSegments ) {
+
+	THREE.BufferGeometry.call( this );
+
+	this.type = 'BoxBufferGeometry';
+
+	this.parameters = {
+		width: width,
+		height: height,
+		depth: depth,
+		widthSegments: widthSegments,
+		heightSegments: heightSegments,
+		depthSegments: depthSegments
+	};
+
+	var scope = this;
+
+	// segments
+	widthSegments = Math.floor( widthSegments ) || 1;
+	heightSegments = Math.floor( heightSegments ) || 1;
+	depthSegments = Math.floor( depthSegments ) || 1;
+
+	// these are used to calculate buffer length
+	var vertexCount = calculateVertexCount( widthSegments, heightSegments, depthSegments );
+	var indexCount = ( vertexCount / 4 ) * 6;
+
+	// buffers
+	var indices = new ( indexCount > 65535 ? Uint32Array : Uint16Array )( indexCount );
+	var vertices = new Float32Array( vertexCount * 3 );
+	var normals = new Float32Array( vertexCount * 3 );
+	var uvs = new Float32Array( vertexCount * 2 );
+
+	// offset variables
+	var vertexBufferOffset = 0;
+	var uvBufferOffset = 0;
+	var indexBufferOffset = 0;
+	var numberOfVertices = 0;
+
+	// group variables
+	var groupStart = 0;
+
+	// build each side of the box geometry
+	buildPlane( 'z', 'y', 'x', - 1, - 1, depth, height,   width,  depthSegments, heightSegments, 0 ); // px
+	buildPlane( 'z', 'y', 'x',   1, - 1, depth, height, - width,  depthSegments, heightSegments, 1 ); // nx
+	buildPlane( 'x', 'z', 'y',   1,   1, width, depth,    height, widthSegments, depthSegments,  2 ); // py
+	buildPlane( 'x', 'z', 'y',   1, - 1, width, depth,  - height, widthSegments, depthSegments,  3 ); // ny
+	buildPlane( 'x', 'y', 'z',   1, - 1, width, height,   depth,  widthSegments, heightSegments, 4 ); // pz
+	buildPlane( 'x', 'y', 'z', - 1, - 1, width, height, - depth,  widthSegments, heightSegments, 5 ); // nz
+
+	// build geometry
+	this.setIndex( new THREE.BufferAttribute( indices, 1 ) );
+	this.addAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+	this.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
+	this.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ) );
+
+	// helper functions
+
+	function calculateVertexCount ( w, h, d ) {
+
+		var segments = 0;
+
+		// calculate the amount of segments for each side
+		segments += w * h * 2; // xy
+		segments += w * d * 2; // xz
+		segments += d * h * 2; // zy
+
+		return segments * 4; // four vertices per segments
+
+	}
+
+	function buildPlane ( u, v, w, udir, vdir, width, height, depth, gridX, gridY, materialIndex ) {
+
+		var segmentWidth	= width / gridX;
+		var segmentHeight = height / gridY;
+
+		var widthHalf = width / 2;
+		var heightHalf = height / 2;
+		var depthHalf = depth / 2;
+
+		var gridX1 = gridX + 1;
+		var gridY1 = gridY + 1;
+
+		var vertexCounter = 0;
+		var groupCount = 0;
+
+		var vector = new THREE.Vector3();
+
+		// generate vertices, normals and uvs
+
+		for ( var iy = 0; iy < gridY1; iy ++ ) {
+
+			var y = iy * segmentHeight - heightHalf;
+
+			for ( var ix = 0; ix < gridX1; ix ++ ) {
+
+				var x = ix * segmentWidth - widthHalf;
+
+				// set values to correct vector component
+				vector[ u ] = x * udir;
+				vector[ v ] = y * vdir;
+				vector[ w ] = depthHalf;
+
+				// now apply vector to vertex buffer
+				vertices[ vertexBufferOffset ] = vector.x;
+				vertices[ vertexBufferOffset + 1 ] = vector.y;
+				vertices[ vertexBufferOffset + 2 ] = vector.z;
+
+				// set values to correct vector component
+				vector[ u ] = 0;
+				vector[ v ] = 0;
+				vector[ w ] = depth > 0 ? 1 : - 1;
+
+				// now apply vector to normal buffer
+				normals[ vertexBufferOffset ] = vector.x;
+				normals[ vertexBufferOffset + 1 ] = vector.y;
+				normals[ vertexBufferOffset + 2 ] = vector.z;
+
+				// uvs
+				uvs[ uvBufferOffset ] = ix / gridX;
+				uvs[ uvBufferOffset + 1 ] = 1 - ( iy / gridY );
+
+				// update offsets and counters
+				vertexBufferOffset += 3;
+				uvBufferOffset += 2;
+				vertexCounter += 1;
+
+			}
+
+		}
+
+		// 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 < gridY; iy ++ ) {
+
+			for ( ix = 0; ix < gridX; ix ++ ) {
+
+				// indices
+				var a = numberOfVertices + ix + gridX1 * iy;
+				var b = numberOfVertices + ix + gridX1 * ( iy + 1 );
+				var c = numberOfVertices + ( ix + 1 ) + gridX1 * ( iy + 1 );
+				var d = numberOfVertices + ( ix + 1 ) + gridX1 * iy;
+
+				// face one
+				indices[ indexBufferOffset ] = a;
+				indices[ indexBufferOffset + 1 ] = b;
+				indices[ indexBufferOffset + 2 ] = d;
+
+				// face two
+				indices[ indexBufferOffset + 3 ] = b;
+				indices[ indexBufferOffset + 4 ] = c;
+				indices[ indexBufferOffset + 5 ] = d;
+
+				// update offsets and counters
+				indexBufferOffset += 6;
+				groupCount += 6;
+
+			}
+
+		}
+
+		// add a group to the geometry. this will ensure multi material support
+		scope.addGroup( groupStart, groupCount, materialIndex );
+
+		// calculate new start value for groups
+		groupStart += groupCount;
+
+		// update total number of vertices
+		numberOfVertices += vertexCounter;
+
+	}
+
+};
+
+THREE.BoxBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+THREE.BoxBufferGeometry.prototype.constructor = THREE.BoxBufferGeometry;
+
+// File:src/extras/geometries/CircleGeometry.js
+
+/**
+ * @author hughes
+ */
+
+THREE.CircleGeometry = function ( radius, segments, thetaStart, thetaLength ) {
+
+	THREE.Geometry.call( this );
+
+	this.type = 'CircleGeometry';
+
+	this.parameters = {
+		radius: radius,
+		segments: segments,
+		thetaStart: thetaStart,
+		thetaLength: thetaLength
+	};
+
+	this.fromBufferGeometry( new THREE.CircleBufferGeometry( radius, segments, thetaStart, thetaLength ) );
+
+};
+
+THREE.CircleGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.CircleGeometry.prototype.constructor = THREE.CircleGeometry;
+
+// File:src/extras/geometries/CircleBufferGeometry.js
+
+/**
+ * @author benaadams / https://twitter.com/ben_a_adams
+ */
+
+THREE.CircleBufferGeometry = function ( radius, segments, thetaStart, thetaLength ) {
+
+	THREE.BufferGeometry.call( this );
+
+	this.type = 'CircleBufferGeometry';
+
+	this.parameters = {
+		radius: radius,
+		segments: segments,
+		thetaStart: thetaStart,
+		thetaLength: thetaLength
+	};
+
+	radius = radius || 50;
+	segments = segments !== undefined ? Math.max( 3, segments ) : 8;
+
+	thetaStart = thetaStart !== undefined ? thetaStart : 0;
+	thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;
+
+	var vertices = segments + 2;
+
+	var positions = new Float32Array( vertices * 3 );
+	var normals = new Float32Array( vertices * 3 );
+	var uvs = new Float32Array( vertices * 2 );
+
+	// center data is already zero, but need to set a few extras
+	normals[ 2 ] = 1.0;
+	uvs[ 0 ] = 0.5;
+	uvs[ 1 ] = 0.5;
+
+	for ( var s = 0, i = 3, ii = 2 ; s <= segments; s ++, i += 3, ii += 2 ) {
+
+		var segment = thetaStart + s / segments * thetaLength;
+
+		positions[ i ] = radius * Math.cos( segment );
+		positions[ i + 1 ] = radius * Math.sin( segment );
+
+		normals[ i + 2 ] = 1; // normal z
+
+		uvs[ ii ] = ( positions[ i ] / radius + 1 ) / 2;
+		uvs[ ii + 1 ] = ( positions[ i + 1 ] / radius + 1 ) / 2;
+
+	}
+
+	var indices = [];
+
+	for ( var i = 1; i <= segments; i ++ ) {
+
+		indices.push( i, i + 1, 0 );
+
+	}
+
+	this.setIndex( new THREE.BufferAttribute( new Uint16Array( indices ), 1 ) );
+	this.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
+	this.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
+	this.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ) );
+
+	this.boundingSphere = new THREE.Sphere( new THREE.Vector3(), radius );
+
+};
+
+THREE.CircleBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+THREE.CircleBufferGeometry.prototype.constructor = THREE.CircleBufferGeometry;
+
+// File:src/extras/geometries/CylinderBufferGeometry.js
+
+/**
+ * @author Mugen87 / https://github.com/Mugen87
+ */
+
+THREE.CylinderBufferGeometry = function( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {
+
+	THREE.BufferGeometry.call( this );
+
+	this.type = 'CylinderBufferGeometry';
+
+	this.parameters = {
+		radiusTop: radiusTop,
+		radiusBottom: radiusBottom,
+		height: height,
+		radialSegments: radialSegments,
+		heightSegments: heightSegments,
+		openEnded: openEnded,
+		thetaStart: thetaStart,
+		thetaLength: thetaLength
+	};
+
+	var scope = this;
+
+	radiusTop = radiusTop !== undefined ? radiusTop : 20;
+	radiusBottom = radiusBottom !== undefined ? radiusBottom : 20;
+	height = height !== undefined ? height : 100;
+
+	radialSegments = Math.floor( radialSegments ) || 8;
+	heightSegments = Math.floor( heightSegments ) || 1;
+
+	openEnded = openEnded !== undefined ? openEnded : false;
+	thetaStart = thetaStart !== undefined ? thetaStart : 0;
+	thetaLength = thetaLength !== undefined ? thetaLength : 2 * Math.PI;
+
+	// used to calculate buffer length
+
+	var vertexCount = calculateVertexCount();
+	var indexCount = calculateIndexCount();
+
+	// buffers
+
+	var indices = new THREE.BufferAttribute( new ( indexCount > 65535 ? Uint32Array : Uint16Array )( indexCount ), 1 );
+	var vertices = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
+	var normals = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
+	var uvs = new THREE.BufferAttribute( new Float32Array( vertexCount * 2 ), 2 );
+
+	// helper variables
+
+	var index = 0, indexOffset = 0, indexArray = [], halfHeight = height / 2;
+
+	// group variables
+	var groupStart = 0;
+
+	// generate geometry
+
+	generateTorso();
+
+	if ( openEnded === false ) {
+
+		if ( radiusTop > 0 ) generateCap( true );
+		if ( radiusBottom > 0 ) generateCap( false );
+
+	}
+
+	// build geometry
+
+	this.setIndex( indices );
+	this.addAttribute( 'position', vertices );
+	this.addAttribute( 'normal', normals );
+	this.addAttribute( 'uv', uvs );
+
+	// helper functions
+
+	function calculateVertexCount() {
+
+		var count = ( radialSegments + 1 ) * ( heightSegments + 1 );
+
+		if ( openEnded === false ) {
+
+			count += ( ( radialSegments + 1 ) * 2 ) + ( radialSegments * 2 );
+
+		}
+
+		return count;
+
+	}
+
+	function calculateIndexCount() {
+
+		var count = radialSegments * heightSegments * 2 * 3;
+
+		if ( openEnded === false ) {
+
+			count += radialSegments * 2 * 3;
+
+		}
+
+		return count;
+
+	}
+
+	function generateTorso() {
+
+		var x, y;
+		var normal = new THREE.Vector3();
+		var vertex = new THREE.Vector3();
+
+		var groupCount = 0;
+
+		// this will be used to calculate the normal
+		var tanTheta = ( radiusBottom - radiusTop ) / height;
+
+		// generate vertices, normals and uvs
+
+		for ( y = 0; y <= heightSegments; y ++ ) {
+
+			var indexRow = [];
+
+			var v = y / heightSegments;
+
+			// calculate the radius of the current row
+			var radius = v * ( radiusBottom - radiusTop ) + radiusTop;
+
+			for ( x = 0; x <= radialSegments; x ++ ) {
+
+				var u = x / radialSegments;
+
+				// vertex
+				vertex.x = radius * Math.sin( u * thetaLength + thetaStart );
+				vertex.y = - v * height + halfHeight;
+				vertex.z = radius * Math.cos( u * thetaLength + thetaStart );
+				vertices.setXYZ( index, vertex.x, vertex.y, vertex.z );
+
+				// normal
+				normal.copy( vertex );
+
+				// handle special case if radiusTop/radiusBottom is zero
+				if ( ( radiusTop === 0 && y === 0 ) || ( radiusBottom === 0 && y === heightSegments ) ) {
+
+					normal.x = Math.sin( u * thetaLength + thetaStart );
+					normal.z = Math.cos( u * thetaLength + thetaStart );
+
+				}
+
+				normal.setY( Math.sqrt( normal.x * normal.x + normal.z * normal.z ) * tanTheta ).normalize();
+				normals.setXYZ( index, normal.x, normal.y, normal.z );
+
+				// uv
+				uvs.setXY( index, u, 1 - v );
+
+				// save index of vertex in respective row
+				indexRow.push( index );
+
+				// increase index
+				index ++;
+
+			}
+
+			// now save vertices of the row in our index array
+			indexArray.push( indexRow );
+
+		}
+
+		// generate indices
+
+		for ( x = 0; x < radialSegments; x ++ ) {
+
+			for ( y = 0; y < heightSegments; y ++ ) {
+
+				// we use the index array to access the correct indices
+				var i1 = indexArray[ y ][ x ];
+				var i2 = indexArray[ y + 1 ][ x ];
+				var i3 = indexArray[ y + 1 ][ x + 1 ];
+				var i4 = indexArray[ y ][ x + 1 ];
+
+				// face one
+				indices.setX( indexOffset, i1 ); indexOffset ++;
+				indices.setX( indexOffset, i2 ); indexOffset ++;
+				indices.setX( indexOffset, i4 ); indexOffset ++;
+
+				// face two
+				indices.setX( indexOffset, i2 ); indexOffset ++;
+				indices.setX( indexOffset, i3 ); indexOffset ++;
+				indices.setX( indexOffset, i4 ); indexOffset ++;
+
+				// update counters
+				groupCount += 6;
+
+			}
+
+		}
+
+		// add a group to the geometry. this will ensure multi material support
+		scope.addGroup( groupStart, groupCount, 0 );
+
+		// calculate new start value for groups
+		groupStart += groupCount;
+
+	}
+
+	function generateCap( top ) {
+
+		var x, centerIndexStart, centerIndexEnd;
+		var uv = new THREE.Vector2();
+		var vertex = new THREE.Vector3();
+
+		var groupCount = 0;
+
+		var radius = ( top === true ) ? radiusTop : radiusBottom;
+		var sign = ( top === true ) ? 1 : - 1;
+
+		// save the index of the first center vertex
+		centerIndexStart = index;
+
+		// first we generate the center vertex data of the cap.
+		// because the geometry needs one set of uvs per face,
+		// we must generate a center vertex per face/segment
+
+		for ( x = 1; x <= radialSegments; x ++ ) {
+
+			// vertex
+			vertices.setXYZ( index, 0, halfHeight * sign, 0 );
+
+			// normal
+			normals.setXYZ( index, 0, sign, 0 );
+
+			// uv
+			if ( top === true ) {
+
+				uv.x = x / radialSegments;
+				uv.y = 0;
+
+			} else {
+
+				uv.x = ( x - 1 ) / radialSegments;
+				uv.y = 1;
+
+			}
+
+			uvs.setXY( index, uv.x, uv.y );
+
+			// increase index
+			index ++;
+
+		}
+
+		// save the index of the last center vertex
+		centerIndexEnd = index;
+
+		// now we generate the surrounding vertices, normals and uvs
+
+		for ( x = 0; x <= radialSegments; x ++ ) {
+
+			var u = x / radialSegments;
+
+			// vertex
+			vertex.x = radius * Math.sin( u * thetaLength + thetaStart );
+			vertex.y = halfHeight * sign;
+			vertex.z = radius * Math.cos( u * thetaLength + thetaStart );
+			vertices.setXYZ( index, vertex.x, vertex.y, vertex.z );
+
+			// normal
+			normals.setXYZ( index, 0, sign, 0 );
+
+			// uv
+			uvs.setXY( index, u, ( top === true ) ? 1 : 0 );
+
+			// increase index
+			index ++;
+
+		}
+
+		// generate indices
+
+		for ( x = 0; x < radialSegments; x ++ ) {
+
+			var c = centerIndexStart + x;
+			var i = centerIndexEnd + x;
+
+			if ( top === true ) {
+
+				// face top
+				indices.setX( indexOffset, i ); indexOffset ++;
+				indices.setX( indexOffset, i + 1 ); indexOffset ++;
+				indices.setX( indexOffset, c ); indexOffset ++;
+
+			} else {
+
+				// face bottom
+				indices.setX( indexOffset, i + 1 ); indexOffset ++;
+				indices.setX( indexOffset, i ); indexOffset ++;
+				indices.setX( indexOffset, c ); indexOffset ++;
+
+			}
+
+			// update counters
+			groupCount += 3;
+
+		}
+
+		// add a group to the geometry. this will ensure multi material support
+		scope.addGroup( groupStart, groupCount, top === true ? 1 : 2 );
+
+		// calculate new start value for groups
+		groupStart += groupCount;
+
+	}
+
+};
+
+THREE.CylinderBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+THREE.CylinderBufferGeometry.prototype.constructor = THREE.CylinderBufferGeometry;
+
+// File:src/extras/geometries/CylinderGeometry.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.CylinderGeometry = function ( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {
+
+	THREE.Geometry.call( this );
+
+	this.type = 'CylinderGeometry';
+
+	this.parameters = {
+		radiusTop: radiusTop,
+		radiusBottom: radiusBottom,
+		height: height,
+		radialSegments: radialSegments,
+		heightSegments: heightSegments,
+		openEnded: openEnded,
+		thetaStart: thetaStart,
+		thetaLength: thetaLength
+	};
+
+	this.fromBufferGeometry( new THREE.CylinderBufferGeometry( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) );
+	this.mergeVertices();
+
+};
+
+THREE.CylinderGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.CylinderGeometry.prototype.constructor = THREE.CylinderGeometry;
+
+// File:src/extras/geometries/EdgesGeometry.js
+
+/**
+ * @author WestLangley / http://github.com/WestLangley
+ */
+
+THREE.EdgesGeometry = function ( geometry, thresholdAngle ) {
+
+	THREE.BufferGeometry.call( this );
+
+	thresholdAngle = ( thresholdAngle !== undefined ) ? thresholdAngle : 1;
+
+	var thresholdDot = Math.cos( THREE.Math.DEG2RAD * thresholdAngle );
+
+	var edge = [ 0, 0 ], hash = {};
+
+	function sortFunction( a, b ) {
+
+		return a - b;
+
+	}
+
+	var keys = [ 'a', 'b', 'c' ];
+
+	var geometry2;
+
+	if ( geometry instanceof THREE.BufferGeometry ) {
+
+		geometry2 = new THREE.Geometry();
+		geometry2.fromBufferGeometry( geometry );
+
+	} else {
+
+		geometry2 = geometry.clone();
+
+	}
+
+	geometry2.mergeVertices();
+	geometry2.computeFaceNormals();
+
+	var vertices = geometry2.vertices;
+	var faces = geometry2.faces;
+
+	for ( var i = 0, l = faces.length; i < l; i ++ ) {
+
+		var face = faces[ i ];
+
+		for ( var j = 0; j < 3; j ++ ) {
+
+			edge[ 0 ] = face[ keys[ j ] ];
+			edge[ 1 ] = face[ keys[ ( j + 1 ) % 3 ] ];
+			edge.sort( sortFunction );
+
+			var key = edge.toString();
+
+			if ( hash[ key ] === undefined ) {
+
+				hash[ key ] = { vert1: edge[ 0 ], vert2: edge[ 1 ], face1: i, face2: undefined };
+
+			} else {
+
+				hash[ key ].face2 = i;
+
+			}
+
+		}
+
+	}
+
+	var coords = [];
+
+	for ( var key in hash ) {
+
+		var h = hash[ key ];
+
+		if ( h.face2 === undefined || faces[ h.face1 ].normal.dot( faces[ h.face2 ].normal ) <= thresholdDot ) {
+
+			var vertex = vertices[ h.vert1 ];
+			coords.push( vertex.x );
+			coords.push( vertex.y );
+			coords.push( vertex.z );
+
+			vertex = vertices[ h.vert2 ];
+			coords.push( vertex.x );
+			coords.push( vertex.y );
+			coords.push( vertex.z );
+
+		}
+
+	}
+
+	this.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( coords ), 3 ) );
+
+};
+
+THREE.EdgesGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+THREE.EdgesGeometry.prototype.constructor = THREE.EdgesGeometry;
+
+// File:src/extras/geometries/ExtrudeGeometry.js
+
+/**
+ * @author zz85 / http://www.lab4games.net/zz85/blog
+ *
+ * Creates extruded geometry from a path shape.
+ *
+ * parameters = {
+ *
+ *  curveSegments: <int>, // number of points on the curves
+ *  steps: <int>, // number of points for z-side extrusions / used for subdividing segments of extrude spline too
+ *  amount: <int>, // Depth to extrude the shape
+ *
+ *  bevelEnabled: <bool>, // turn on bevel
+ *  bevelThickness: <float>, // how deep into the original shape bevel goes
+ *  bevelSize: <float>, // how far from shape outline is bevel
+ *  bevelSegments: <int>, // number of bevel layers
+ *
+ *  extrudePath: <THREE.CurvePath> // 3d spline path to extrude shape along. (creates Frames if .frames aren't defined)
+ *  frames: <THREE.TubeGeometry.FrenetFrames> // containing arrays of tangents, normals, binormals
+ *
+ *  uvGenerator: <Object> // object that provides UV generator functions
+ *
+ * }
+ **/
+
+THREE.ExtrudeGeometry = function ( shapes, options ) {
+
+	if ( typeof( shapes ) === "undefined" ) {
+
+		shapes = [];
+		return;
+
+	}
+
+	THREE.Geometry.call( this );
+
+	this.type = 'ExtrudeGeometry';
+
+	shapes = Array.isArray( shapes ) ? shapes : [ shapes ];
+
+	this.addShapeList( shapes, options );
+
+	this.computeFaceNormals();
+
+	// can't really use automatic vertex normals
+	// as then front and back sides get smoothed too
+	// should do separate smoothing just for sides
+
+	//this.computeVertexNormals();
+
+	//console.log( "took", ( Date.now() - startTime ) );
+
+};
+
+THREE.ExtrudeGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.ExtrudeGeometry.prototype.constructor = THREE.ExtrudeGeometry;
+
+THREE.ExtrudeGeometry.prototype.addShapeList = function ( shapes, options ) {
+
+	var sl = shapes.length;
+
+	for ( var s = 0; s < sl; s ++ ) {
+
+		var shape = shapes[ s ];
+		this.addShape( shape, options );
+
+	}
+
+};
+
+THREE.ExtrudeGeometry.prototype.addShape = function ( shape, options ) {
+
+	var amount = options.amount !== undefined ? options.amount : 100;
+
+	var bevelThickness = options.bevelThickness !== undefined ? options.bevelThickness : 6; // 10
+	var bevelSize = options.bevelSize !== undefined ? options.bevelSize : bevelThickness - 2; // 8
+	var bevelSegments = options.bevelSegments !== undefined ? options.bevelSegments : 3;
+
+	var bevelEnabled = options.bevelEnabled !== undefined ? options.bevelEnabled : true; // false
+
+	var curveSegments = options.curveSegments !== undefined ? options.curveSegments : 12;
+
+	var steps = options.steps !== undefined ? options.steps : 1;
+
+	var extrudePath = options.extrudePath;
+	var extrudePts, extrudeByPath = false;
+
+	// Use default WorldUVGenerator if no UV generators are specified.
+	var uvgen = options.UVGenerator !== undefined ? options.UVGenerator : THREE.ExtrudeGeometry.WorldUVGenerator;
+
+	var splineTube, binormal, normal, position2;
+	if ( extrudePath ) {
+
+		extrudePts = extrudePath.getSpacedPoints( steps );
+
+		extrudeByPath = true;
+		bevelEnabled = false; // bevels not supported for path extrusion
+
+		// SETUP TNB variables
+
+		// Reuse TNB from TubeGeomtry for now.
+		// TODO1 - have a .isClosed in spline?
+
+		splineTube = options.frames !== undefined ? options.frames : new THREE.TubeGeometry.FrenetFrames( extrudePath, steps, false );
+
+		// console.log(splineTube, 'splineTube', splineTube.normals.length, 'steps', steps, 'extrudePts', extrudePts.length);
+
+		binormal = new THREE.Vector3();
+		normal = new THREE.Vector3();
+		position2 = new THREE.Vector3();
+
+	}
+
+	// Safeguards if bevels are not enabled
+
+	if ( ! bevelEnabled ) {
+
+		bevelSegments = 0;
+		bevelThickness = 0;
+		bevelSize = 0;
+
+	}
+
+	// Variables initialization
+
+	var ahole, h, hl; // looping of holes
+	var scope = this;
+
+	var shapesOffset = this.vertices.length;
+
+	var shapePoints = shape.extractPoints( curveSegments );
+
+	var vertices = shapePoints.shape;
+	var holes = shapePoints.holes;
+
+	var reverse = ! THREE.ShapeUtils.isClockWise( vertices );
+
+	if ( reverse ) {
+
+		vertices = vertices.reverse();
+
+		// Maybe we should also check if holes are in the opposite direction, just to be safe ...
+
+		for ( h = 0, hl = holes.length; h < hl; h ++ ) {
+
+			ahole = holes[ h ];
+
+			if ( THREE.ShapeUtils.isClockWise( ahole ) ) {
+
+				holes[ h ] = ahole.reverse();
+
+			}
+
+		}
+
+		reverse = false; // If vertices are in order now, we shouldn't need to worry about them again (hopefully)!
+
+	}
+
+
+	var faces = THREE.ShapeUtils.triangulateShape( vertices, holes );
+
+	/* Vertices */
+
+	var contour = vertices; // vertices has all points but contour has only points of circumference
+
+	for ( h = 0, hl = holes.length; h < hl; h ++ ) {
+
+		ahole = holes[ h ];
+
+		vertices = vertices.concat( ahole );
+
+	}
+
+
+	function scalePt2 ( pt, vec, size ) {
+
+		if ( ! vec ) console.error( "THREE.ExtrudeGeometry: vec does not exist" );
+
+		return vec.clone().multiplyScalar( size ).add( pt );
+
+	}
+
+	var b, bs, t, z,
+		vert, vlen = vertices.length,
+		face, flen = faces.length;
+
+
+	// Find directions for point movement
+
+
+	function getBevelVec( inPt, inPrev, inNext ) {
+
+		// computes for inPt the corresponding point inPt' on a new contour
+		//   shifted by 1 unit (length of normalized vector) to the left
+		// if we walk along contour clockwise, this new contour is outside the old one
+		//
+		// inPt' is the intersection of the two lines parallel to the two
+		//  adjacent edges of inPt at a distance of 1 unit on the left side.
+
+		var v_trans_x, v_trans_y, shrink_by = 1;		// resulting translation vector for inPt
+
+		// good reading for geometry algorithms (here: line-line intersection)
+		// http://geomalgorithms.com/a05-_intersect-1.html
+
+		var v_prev_x = inPt.x - inPrev.x, v_prev_y = inPt.y - inPrev.y;
+		var v_next_x = inNext.x - inPt.x, v_next_y = inNext.y - inPt.y;
+
+		var v_prev_lensq = ( v_prev_x * v_prev_x + v_prev_y * v_prev_y );
+
+		// check for collinear edges
+		var collinear0 = ( v_prev_x * v_next_y - v_prev_y * v_next_x );
+
+		if ( Math.abs( collinear0 ) > 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 <= 2 ) {
+
+				return	new THREE.Vector2( v_trans_x, v_trans_y );
+
+			} else {
+
+				shrink_by = Math.sqrt( v_trans_lensq / 2 );
+
+			}
+
+		} else {
+
+			// handle special case of collinear edges
+
+			var direction_eq = false;		// assumes: opposite
+			if ( v_prev_x > Number.EPSILON ) {
+
+				if ( v_next_x > Number.EPSILON ) {
+
+					direction_eq = true;
+
+				}
+
+			} else {
+
+				if ( v_prev_x < - Number.EPSILON ) {
+
+					if ( v_next_x < - Number.EPSILON ) {
+
+						direction_eq = true;
+
+					}
+
+				} else {
+
+					if ( Math.sign( v_prev_y ) === Math.sign( v_next_y ) ) {
+
+						direction_eq = true;
+
+					}
+
+				}
+
+			}
+
+			if ( direction_eq ) {
+
+				// console.log("Warning: lines are a straight sequence");
+				v_trans_x = - v_prev_y;
+				v_trans_y =  v_prev_x;
+				shrink_by = Math.sqrt( v_prev_lensq );
+
+			} else {
+
+				// console.log("Warning: lines are a straight spike");
+				v_trans_x = v_prev_x;
+				v_trans_y = v_prev_y;
+				shrink_by = Math.sqrt( v_prev_lensq / 2 );
+
+			}
+
+		}
+
+		return	new THREE.Vector2( v_trans_x / shrink_by, v_trans_y / shrink_by );
+
+	}
+
+
+	var contourMovements = [];
+
+	for ( var i = 0, il = contour.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {
+
+		if ( j === il ) j = 0;
+		if ( k === il ) k = 0;
+
+		//  (j)---(i)---(k)
+		// console.log('i,j,k', i, j , k)
+
+		contourMovements[ i ] = getBevelVec( contour[ i ], contour[ j ], contour[ k ] );
+
+	}
+
+	var holesMovements = [], oneHoleMovements, verticesMovements = contourMovements.concat();
+
+	for ( h = 0, hl = holes.length; h < hl; h ++ ) {
+
+		ahole = holes[ h ];
+
+		oneHoleMovements = [];
+
+		for ( i = 0, il = ahole.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {
+
+			if ( j === il ) j = 0;
+			if ( k === il ) k = 0;
+
+			//  (j)---(i)---(k)
+			oneHoleMovements[ i ] = getBevelVec( ahole[ i ], ahole[ j ], ahole[ k ] );
+
+		}
+
+		holesMovements.push( oneHoleMovements );
+		verticesMovements = verticesMovements.concat( oneHoleMovements );
+
+	}
+
+
+	// Loop bevelSegments, 1 for the front, 1 for the back
+
+	for ( b = 0; b < bevelSegments; b ++ ) {
+
+		//for ( b = bevelSegments; b > 0; b -- ) {
+
+		t = b / bevelSegments;
+		z = bevelThickness * ( 1 - t );
+
+		//z = bevelThickness * t;
+		bs = bevelSize * ( Math.sin ( t * Math.PI / 2 ) ); // curved
+		//bs = bevelSize * t; // linear
+
+		// contract shape
+
+		for ( i = 0, il = contour.length; i < il; i ++ ) {
+
+			vert = scalePt2( contour[ i ], contourMovements[ i ], bs );
+
+			v( vert.x, vert.y,  - z );
+
+		}
+
+		// expand holes
+
+		for ( h = 0, hl = holes.length; h < hl; h ++ ) {
+
+			ahole = holes[ h ];
+			oneHoleMovements = holesMovements[ h ];
+
+			for ( i = 0, il = ahole.length; i < il; i ++ ) {
+
+				vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );
+
+				v( vert.x, vert.y,  - z );
+
+			}
+
+		}
+
+	}
+
+	bs = bevelSize;
+
+	// Back facing vertices
+
+	for ( i = 0; i < vlen; i ++ ) {
+
+		vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];
+
+		if ( ! extrudeByPath ) {
+
+			v( vert.x, vert.y, 0 );
+
+		} else {
+
+			// v( vert.x, vert.y + extrudePts[ 0 ].y, extrudePts[ 0 ].x );
+
+			normal.copy( splineTube.normals[ 0 ] ).multiplyScalar( vert.x );
+			binormal.copy( splineTube.binormals[ 0 ] ).multiplyScalar( vert.y );
+
+			position2.copy( extrudePts[ 0 ] ).add( normal ).add( binormal );
+
+			v( position2.x, position2.y, position2.z );
+
+		}
+
+	}
+
+	// Add stepped vertices...
+	// Including front facing vertices
+
+	var s;
+
+	for ( s = 1; s <= steps; s ++ ) {
+
+		for ( i = 0; i < vlen; i ++ ) {
+
+			vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];
+
+			if ( ! extrudeByPath ) {
+
+				v( vert.x, vert.y, amount / steps * s );
+
+			} else {
+
+				// v( vert.x, vert.y + extrudePts[ s - 1 ].y, extrudePts[ s - 1 ].x );
+
+				normal.copy( splineTube.normals[ s ] ).multiplyScalar( vert.x );
+				binormal.copy( splineTube.binormals[ s ] ).multiplyScalar( vert.y );
+
+				position2.copy( extrudePts[ s ] ).add( normal ).add( binormal );
+
+				v( position2.x, position2.y, position2.z );
+
+			}
+
+		}
+
+	}
+
+
+	// Add bevel segments planes
+
+	//for ( b = 1; b <= bevelSegments; b ++ ) {
+	for ( b = bevelSegments - 1; b >= 0; b -- ) {
+
+		t = b / bevelSegments;
+		z = bevelThickness * ( 1 - t );
+		//bs = bevelSize * ( 1-Math.sin ( ( 1 - t ) * Math.PI/2 ) );
+		bs = bevelSize * Math.sin ( t * Math.PI / 2 );
+
+		// contract shape
+
+		for ( i = 0, il = contour.length; i < il; i ++ ) {
+
+			vert = scalePt2( contour[ i ], contourMovements[ i ], bs );
+			v( vert.x, vert.y,  amount + z );
+
+		}
+
+		// expand holes
+
+		for ( h = 0, hl = holes.length; h < hl; h ++ ) {
+
+			ahole = holes[ h ];
+			oneHoleMovements = holesMovements[ h ];
+
+			for ( i = 0, il = ahole.length; i < il; i ++ ) {
+
+				vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );
+
+				if ( ! extrudeByPath ) {
+
+					v( vert.x, vert.y,  amount + z );
+
+				} else {
+
+					v( vert.x, vert.y + extrudePts[ steps - 1 ].y, extrudePts[ steps - 1 ].x + z );
+
+				}
+
+			}
+
+		}
+
+	}
+
+	/* Faces */
+
+	// Top and bottom faces
+
+	buildLidFaces();
+
+	// Sides faces
+
+	buildSideFaces();
+
+
+	/////  Internal functions
+
+	function buildLidFaces() {
+
+		if ( bevelEnabled ) {
+
+			var layer = 0; // steps + 1
+			var offset = vlen * layer;
+
+			// Bottom faces
+
+			for ( i = 0; i < flen; i ++ ) {
+
+				face = faces[ i ];
+				f3( face[ 2 ] + offset, face[ 1 ] + offset, face[ 0 ] + offset );
+
+			}
+
+			layer = steps + bevelSegments * 2;
+			offset = vlen * layer;
+
+			// Top faces
+
+			for ( i = 0; i < flen; i ++ ) {
+
+				face = faces[ i ];
+				f3( face[ 0 ] + offset, face[ 1 ] + offset, face[ 2 ] + offset );
+
+			}
+
+		} else {
+
+			// Bottom faces
+
+			for ( i = 0; i < flen; i ++ ) {
+
+				face = faces[ i ];
+				f3( face[ 2 ], face[ 1 ], face[ 0 ] );
+
+			}
+
+			// Top faces
+
+			for ( i = 0; i < flen; i ++ ) {
+
+				face = faces[ i ];
+				f3( face[ 0 ] + vlen * steps, face[ 1 ] + vlen * steps, face[ 2 ] + vlen * steps );
+
+			}
+
+		}
+
+	}
+
+	// Create faces for the z-sides of the shape
+
+	function buildSideFaces() {
+
+		var layeroffset = 0;
+		sidewalls( contour, layeroffset );
+		layeroffset += contour.length;
+
+		for ( h = 0, hl = holes.length; h < hl; h ++ ) {
+
+			ahole = holes[ h ];
+			sidewalls( ahole, layeroffset );
+
+			//, true
+			layeroffset += ahole.length;
+
+		}
+
+	}
+
+	function sidewalls( contour, layeroffset ) {
+
+		var j, k;
+		i = contour.length;
+
+		while ( -- i >= 0 ) {
+
+			j = i;
+			k = i - 1;
+			if ( k < 0 ) k = contour.length - 1;
+
+			//console.log('b', i,j, i-1, k,vertices.length);
+
+			var s = 0, sl = steps  + bevelSegments * 2;
+
+			for ( s = 0; s < sl; s ++ ) {
+
+				var slen1 = vlen * s;
+				var slen2 = vlen * ( s + 1 );
+
+				var a = layeroffset + j + slen1,
+					b = layeroffset + k + slen1,
+					c = layeroffset + k + slen2,
+					d = layeroffset + j + slen2;
+
+				f4( a, b, c, d, contour, s, sl, j, k );
+
+			}
+
+		}
+
+	}
+
+
+	function v( x, y, z ) {
+
+		scope.vertices.push( new THREE.Vector3( x, y, z ) );
+
+	}
+
+	function f3( a, b, c ) {
+
+		a += shapesOffset;
+		b += shapesOffset;
+		c += shapesOffset;
+
+		scope.faces.push( new THREE.Face3( a, b, c, null, null, 0 ) );
+
+		var uvs = uvgen.generateTopUV( scope, a, b, c );
+
+		scope.faceVertexUvs[ 0 ].push( uvs );
+
+	}
+
+	function f4( a, b, c, d, wallContour, stepIndex, stepsLength, contourIndex1, contourIndex2 ) {
+
+		a += shapesOffset;
+		b += shapesOffset;
+		c += shapesOffset;
+		d += shapesOffset;
+
+		scope.faces.push( new THREE.Face3( a, b, d, null, null, 1 ) );
+		scope.faces.push( new THREE.Face3( b, c, d, null, null, 1 ) );
+
+		var uvs = uvgen.generateSideWallUV( scope, a, b, c, d );
+
+		scope.faceVertexUvs[ 0 ].push( [ uvs[ 0 ], uvs[ 1 ], uvs[ 3 ] ] );
+		scope.faceVertexUvs[ 0 ].push( [ uvs[ 1 ], uvs[ 2 ], uvs[ 3 ] ] );
+
+	}
+
+};
+
+THREE.ExtrudeGeometry.WorldUVGenerator = {
+
+	generateTopUV: function ( geometry, indexA, indexB, indexC ) {
+
+		var vertices = geometry.vertices;
+
+		var a = vertices[ indexA ];
+		var b = vertices[ indexB ];
+		var c = vertices[ indexC ];
+
+		return [
+			new THREE.Vector2( a.x, a.y ),
+			new THREE.Vector2( b.x, b.y ),
+			new THREE.Vector2( c.x, c.y )
+		];
+
+	},
+
+	generateSideWallUV: function ( geometry, indexA, indexB, indexC, indexD ) {
+
+		var vertices = geometry.vertices;
+
+		var a = vertices[ indexA ];
+		var b = vertices[ indexB ];
+		var c = vertices[ indexC ];
+		var d = vertices[ indexD ];
+
+		if ( Math.abs( a.y - b.y ) < 0.01 ) {
+
+			return [
+				new THREE.Vector2( a.x, 1 - a.z ),
+				new THREE.Vector2( b.x, 1 - b.z ),
+				new THREE.Vector2( c.x, 1 - c.z ),
+				new THREE.Vector2( d.x, 1 - d.z )
+			];
+
+		} else {
+
+			return [
+				new THREE.Vector2( a.y, 1 - a.z ),
+				new THREE.Vector2( b.y, 1 - b.z ),
+				new THREE.Vector2( c.y, 1 - c.z ),
+				new THREE.Vector2( d.y, 1 - d.z )
+			];
+
+		}
+
+	}
+};
+
+// File:src/extras/geometries/ShapeGeometry.js
+
+/**
+ * @author jonobr1 / http://jonobr1.com
+ *
+ * Creates a one-sided polygonal geometry from a path shape. Similar to
+ * ExtrudeGeometry.
+ *
+ * parameters = {
+ *
+ *	curveSegments: <int>, // number of points on the curves. NOT USED AT THE MOMENT.
+ *
+ *	material: <int> // material index for front and back faces
+ *	uvGenerator: <Object> // object that provides UV generator functions
+ *
+ * }
+ **/
+
+THREE.ShapeGeometry = function ( shapes, options ) {
+
+	THREE.Geometry.call( this );
+
+	this.type = 'ShapeGeometry';
+
+	if ( Array.isArray( shapes ) === false ) shapes = [ shapes ];
+
+	this.addShapeList( shapes, options );
+
+	this.computeFaceNormals();
+
+};
+
+THREE.ShapeGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.ShapeGeometry.prototype.constructor = THREE.ShapeGeometry;
+
+/**
+ * Add an array of shapes to THREE.ShapeGeometry.
+ */
+THREE.ShapeGeometry.prototype.addShapeList = function ( shapes, options ) {
+
+	for ( var i = 0, l = shapes.length; i < l; i ++ ) {
+
+		this.addShape( shapes[ i ], options );
+
+	}
+
+	return this;
+
+};
+
+/**
+ * Adds a shape to THREE.ShapeGeometry, based on THREE.ExtrudeGeometry.
+ */
+THREE.ShapeGeometry.prototype.addShape = function ( shape, options ) {
+
+	if ( options === undefined ) options = {};
+	var curveSegments = options.curveSegments !== undefined ? options.curveSegments : 12;
+
+	var material = options.material;
+	var uvgen = options.UVGenerator === undefined ? THREE.ExtrudeGeometry.WorldUVGenerator : options.UVGenerator;
+
+	//
+
+	var i, l, hole;
+
+	var shapesOffset = this.vertices.length;
+	var shapePoints = shape.extractPoints( curveSegments );
+
+	var vertices = shapePoints.shape;
+	var holes = shapePoints.holes;
+
+	var reverse = ! THREE.ShapeUtils.isClockWise( vertices );
+
+	if ( reverse ) {
+
+		vertices = vertices.reverse();
+
+		// Maybe we should also check if holes are in the opposite direction, just to be safe...
+
+		for ( i = 0, l = holes.length; i < l; i ++ ) {
+
+			hole = holes[ i ];
+
+			if ( THREE.ShapeUtils.isClockWise( hole ) ) {
+
+				holes[ i ] = hole.reverse();
+
+			}
+
+		}
+
+		reverse = false;
+
+	}
+
+	var faces = THREE.ShapeUtils.triangulateShape( vertices, holes );
+
+	// Vertices
+
+	for ( i = 0, l = holes.length; i < l; i ++ ) {
+
+		hole = holes[ i ];
+		vertices = vertices.concat( hole );
+
+	}
+
+	//
+
+	var vert, vlen = vertices.length;
+	var face, flen = faces.length;
+
+	for ( i = 0; i < vlen; i ++ ) {
+
+		vert = vertices[ i ];
+
+		this.vertices.push( new THREE.Vector3( vert.x, vert.y, 0 ) );
+
+	}
+
+	for ( i = 0; i < flen; i ++ ) {
+
+		face = faces[ i ];
+
+		var a = face[ 0 ] + shapesOffset;
+		var b = face[ 1 ] + shapesOffset;
+		var c = face[ 2 ] + shapesOffset;
+
+		this.faces.push( new THREE.Face3( a, b, c, null, null, material ) );
+		this.faceVertexUvs[ 0 ].push( uvgen.generateTopUV( this, a, b, c ) );
+
+	}
+
+};
+
+// File:src/extras/geometries/LatheBufferGeometry.js
+
+/**
+ * @author Mugen87 / https://github.com/Mugen87
+ */
+
+ // points - to create a closed torus, one must use a set of points
+ //    like so: [ a, b, c, d, a ], see first is the same as last.
+ // segments - the number of circumference segments to create
+ // phiStart - the starting radian
+ // phiLength - the radian (0 to 2PI) range of the lathed section
+ //    2PI is a closed lathe, less than 2PI is a portion.
+
+THREE.LatheBufferGeometry = function ( points, segments, phiStart, phiLength ) {
+
+	THREE.BufferGeometry.call( this );
+
+	this.type = 'LatheBufferGeometry';
+
+	this.parameters = {
+		points: points,
+		segments: segments,
+		phiStart: phiStart,
+		phiLength: phiLength
+	};
+
+	segments = Math.floor( segments ) || 12;
+	phiStart = phiStart || 0;
+	phiLength = phiLength || Math.PI * 2;
+
+	// clamp phiLength so it's in range of [ 0, 2PI ]
+	phiLength = THREE.Math.clamp( phiLength, 0, Math.PI * 2 );
+
+	// these are used to calculate buffer length
+	var vertexCount = ( segments + 1 ) * points.length;
+	var indexCount = segments * points.length * 2 * 3;
+
+	// buffers
+	var indices = new THREE.BufferAttribute( new ( indexCount > 65535 ? Uint32Array : Uint16Array )( indexCount ) , 1 );
+	var vertices = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
+	var uvs = new THREE.BufferAttribute( new Float32Array( vertexCount * 2 ), 2 );
+
+	// helper variables
+	var index = 0, indexOffset = 0, base;
+	var inversePointLength = 1.0 / ( points.length - 1 );
+	var inverseSegments = 1.0 / segments;
+	var vertex = new THREE.Vector3();
+	var uv = new THREE.Vector2();
+	var i, j;
+
+	// generate vertices and uvs
+
+	for ( i = 0; i <= segments; i ++ ) {
+
+		var phi = phiStart + i * inverseSegments * phiLength;
+
+		var sin = Math.sin( phi );
+		var cos = Math.cos( phi );
+
+		for ( j = 0; j <= ( points.length - 1 ); j ++ ) {
+
+			// vertex
+			vertex.x = points[ j ].x * sin;
+			vertex.y = points[ j ].y;
+			vertex.z = points[ j ].x * cos;
+			vertices.setXYZ( index, vertex.x, vertex.y, vertex.z );
+
+			// uv
+			uv.x = i / segments;
+			uv.y = j / ( points.length - 1 );
+			uvs.setXY( index, uv.x, uv.y );
+
+			// increase index
+			index ++;
+
+		}
+
+	}
+
+	// generate indices
+
+	for ( i = 0; i < segments; i ++ ) {
+
+		for ( j = 0; j < ( points.length - 1 ); j ++ ) {
+
+			base = j + i * points.length;
+
+			// indices
+			var a = base;
+			var b = base + points.length;
+			var c = base + points.length + 1;
+			var d = base + 1;
+
+			// face one
+			indices.setX( indexOffset, a ); indexOffset++;
+			indices.setX( indexOffset, b ); indexOffset++;
+			indices.setX( indexOffset, d ); indexOffset++;
+
+			// face two
+			indices.setX( indexOffset, b ); indexOffset++;
+			indices.setX( indexOffset, c ); indexOffset++;
+			indices.setX( indexOffset, d ); indexOffset++;
+
+		}
+
+	}
+
+	// build geometry
+
+	this.setIndex( indices );
+	this.addAttribute( 'position', vertices );
+	this.addAttribute( 'uv', uvs );
+
+	// generate normals
+
+	this.computeVertexNormals();
+
+	// if the geometry is closed, we need to average the normals along the seam.
+	// because the corresponding vertices are identical (but still have different UVs).
+
+	if( phiLength === Math.PI * 2 ) {
+
+		var normals = this.attributes.normal.array;
+		var n1 = new THREE.Vector3();
+		var n2 = new THREE.Vector3();
+		var n = new THREE.Vector3();
+
+		// this is the buffer offset for the last line of vertices
+		base = segments * points.length * 3;
+
+		for( i = 0, j = 0; i < points.length; i ++, j += 3 ) {
+
+			// select the normal of the vertex in the first line
+			n1.x = normals[ j + 0 ];
+			n1.y = normals[ j + 1 ];
+			n1.z = normals[ j + 2 ];
+
+			// select the normal of the vertex in the last line
+			n2.x = normals[ base + j + 0 ];
+			n2.y = normals[ base + j + 1 ];
+			n2.z = normals[ base + j + 2 ];
+
+			// average normals
+			n.addVectors( n1, n2 ).normalize();
+
+			// assign the new values to both normals
+			normals[ j + 0 ] = normals[ base + j + 0 ] = n.x;
+			normals[ j + 1 ] = normals[ base + j + 1 ] = n.y;
+			normals[ j + 2 ] = normals[ base + j + 2 ] = n.z;
+
+		} // next row
+
+	}
+
+};
+
+THREE.LatheBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+THREE.LatheBufferGeometry.prototype.constructor = THREE.LatheBufferGeometry;
+
+// File:src/extras/geometries/LatheGeometry.js
+
+/**
+ * @author astrodud / http://astrodud.isgreat.org/
+ * @author zz85 / https://github.com/zz85
+ * @author bhouston / http://clara.io
+ */
+
+// points - to create a closed torus, one must use a set of points
+//    like so: [ a, b, c, d, a ], see first is the same as last.
+// segments - the number of circumference segments to create
+// phiStart - the starting radian
+// phiLength - the radian (0 to 2PI) range of the lathed section
+//    2PI is a closed lathe, less than 2PI is a portion.
+
+THREE.LatheGeometry = function ( points, segments, phiStart, phiLength ) {
+
+	THREE.Geometry.call( this );
+
+	this.type = 'LatheGeometry';
+
+	this.parameters = {
+		points: points,
+		segments: segments,
+		phiStart: phiStart,
+		phiLength: phiLength
+	};
+
+	this.fromBufferGeometry( new THREE.LatheBufferGeometry( points, segments, phiStart, phiLength ) );
+	this.mergeVertices();
+
+};
+
+THREE.LatheGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.LatheGeometry.prototype.constructor = THREE.LatheGeometry;
+
+// File:src/extras/geometries/PlaneGeometry.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * based on http://papervision3d.googlecode.com/svn/trunk/as3/trunk/src/org/papervision3d/objects/primitives/Plane.as
+ */
+
+THREE.PlaneGeometry = function ( width, height, widthSegments, heightSegments ) {
+
+	THREE.Geometry.call( this );
+
+	this.type = 'PlaneGeometry';
+
+	this.parameters = {
+		width: width,
+		height: height,
+		widthSegments: widthSegments,
+		heightSegments: heightSegments
+	};
+
+	this.fromBufferGeometry( new THREE.PlaneBufferGeometry( width, height, widthSegments, heightSegments ) );
+
+};
+
+THREE.PlaneGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.PlaneGeometry.prototype.constructor = THREE.PlaneGeometry;
+
+// File:src/extras/geometries/PlaneBufferGeometry.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * based on http://papervision3d.googlecode.com/svn/trunk/as3/trunk/src/org/papervision3d/objects/primitives/Plane.as
+ */
+
+THREE.PlaneBufferGeometry = function ( width, height, widthSegments, heightSegments ) {
+
+	THREE.BufferGeometry.call( this );
+
+	this.type = 'PlaneBufferGeometry';
+
+	this.parameters = {
+		width: width,
+		height: height,
+		widthSegments: widthSegments,
+		heightSegments: heightSegments
+	};
+
+	var width_half = width / 2;
+	var height_half = height / 2;
+
+	var gridX = Math.floor( widthSegments ) || 1;
+	var gridY = Math.floor( heightSegments ) || 1;
+
+	var gridX1 = gridX + 1;
+	var gridY1 = gridY + 1;
+
+	var segment_width = width / gridX;
+	var segment_height = height / gridY;
+
+	var vertices = new Float32Array( gridX1 * gridY1 * 3 );
+	var normals = new Float32Array( gridX1 * gridY1 * 3 );
+	var uvs = new Float32Array( gridX1 * gridY1 * 2 );
+
+	var offset = 0;
+	var offset2 = 0;
+
+	for ( var iy = 0; iy < gridY1; iy ++ ) {
+
+		var y = iy * segment_height - height_half;
+
+		for ( var ix = 0; ix < gridX1; ix ++ ) {
+
+			var x = ix * segment_width - width_half;
+
+			vertices[ offset ] = x;
+			vertices[ offset + 1 ] = - y;
+
+			normals[ offset + 2 ] = 1;
+
+			uvs[ offset2 ] = ix / gridX;
+			uvs[ offset2 + 1 ] = 1 - ( iy / gridY );
+
+			offset += 3;
+			offset2 += 2;
+
+		}
+
+	}
+
+	offset = 0;
+
+	var indices = new ( ( vertices.length / 3 ) > 65535 ? Uint32Array : Uint16Array )( gridX * gridY * 6 );
+
+	for ( var iy = 0; iy < gridY; iy ++ ) {
+
+		for ( var ix = 0; ix < gridX; ix ++ ) {
+
+			var a = ix + gridX1 * iy;
+			var b = ix + gridX1 * ( iy + 1 );
+			var c = ( ix + 1 ) + gridX1 * ( iy + 1 );
+			var d = ( ix + 1 ) + gridX1 * iy;
+
+			indices[ offset ] = a;
+			indices[ offset + 1 ] = b;
+			indices[ offset + 2 ] = d;
+
+			indices[ offset + 3 ] = b;
+			indices[ offset + 4 ] = c;
+			indices[ offset + 5 ] = d;
+
+			offset += 6;
+
+		}
+
+	}
+
+	this.setIndex( new THREE.BufferAttribute( indices, 1 ) );
+	this.addAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+	this.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
+	this.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ) );
+
+};
+
+THREE.PlaneBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+THREE.PlaneBufferGeometry.prototype.constructor = THREE.PlaneBufferGeometry;
+
+// File:src/extras/geometries/RingBufferGeometry.js
+
+/**
+ * @author Mugen87 / https://github.com/Mugen87
+ */
+
+THREE.RingBufferGeometry = function ( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) {
+
+	THREE.BufferGeometry.call( this );
+
+	this.type = 'RingBufferGeometry';
+
+	this.parameters = {
+		innerRadius: innerRadius,
+		outerRadius: outerRadius,
+		thetaSegments: thetaSegments,
+		phiSegments: phiSegments,
+		thetaStart: thetaStart,
+		thetaLength: thetaLength
+	};
+
+	innerRadius = innerRadius || 20;
+	outerRadius = outerRadius || 50;
+
+	thetaStart = thetaStart !== undefined ? thetaStart : 0;
+	thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;
+
+	thetaSegments = thetaSegments !== undefined ? Math.max( 3, thetaSegments ) : 8;
+	phiSegments = phiSegments !== undefined ? Math.max( 1, phiSegments ) : 1;
+
+	// these are used to calculate buffer length
+	var vertexCount = ( thetaSegments + 1 ) * ( phiSegments + 1 );
+	var indexCount = thetaSegments * phiSegments * 2 * 3;
+
+	// buffers
+	var indices = new THREE.BufferAttribute( new ( indexCount > 65535 ? Uint32Array : Uint16Array )( indexCount ) , 1 );
+	var vertices = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
+	var normals = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
+	var uvs = new THREE.BufferAttribute( new Float32Array( vertexCount * 2 ), 2 );
+
+	// some helper variables
+	var index = 0, indexOffset = 0, segment;
+	var radius = innerRadius;
+	var radiusStep = ( ( outerRadius - innerRadius ) / phiSegments );
+	var vertex = new THREE.Vector3();
+	var uv = new THREE.Vector2();
+	var j, i;
+
+	// generate vertices, normals and uvs
+
+	// values are generate from the inside of the ring to the outside
+
+	for ( j = 0; j <= phiSegments; j ++ ) {
+
+		for ( i = 0; i <= thetaSegments; i ++ ) {
+
+			segment = thetaStart + i / thetaSegments * thetaLength;
+
+			// vertex
+			vertex.x = radius * Math.cos( segment );
+			vertex.y = radius * Math.sin( segment );
+			vertices.setXYZ( index, vertex.x, vertex.y, vertex.z );
+
+			// normal
+			normals.setXYZ( index, 0, 0, 1 );
+
+			// uv
+			uv.x = ( vertex.x / outerRadius + 1 ) / 2;
+			uv.y = ( vertex.y / outerRadius + 1 ) / 2;
+			uvs.setXY( index, uv.x, uv.y );
+
+			// increase index
+			index++;
+
+		}
+
+		// increase the radius for next row of vertices
+		radius += radiusStep;
+
+	}
+
+	// generate indices
+
+	for ( j = 0; j < phiSegments; j ++ ) {
+
+		var thetaSegmentLevel = j * ( thetaSegments + 1 );
+
+		for ( i = 0; i < thetaSegments; i ++ ) {
+
+			segment = i + thetaSegmentLevel;
+
+			// indices
+			var a = segment;
+			var b = segment + thetaSegments + 1;
+			var c = segment + thetaSegments + 2;
+			var d = segment + 1;
+
+			// face one
+			indices.setX( indexOffset, a ); indexOffset++;
+			indices.setX( indexOffset, b ); indexOffset++;
+			indices.setX( indexOffset, c ); indexOffset++;
+
+			// face two
+			indices.setX( indexOffset, a ); indexOffset++;
+			indices.setX( indexOffset, c ); indexOffset++;
+			indices.setX( indexOffset, d ); indexOffset++;
+
+		}
+
+	}
+
+	// build geometry
+
+	this.setIndex( indices );
+	this.addAttribute( 'position', vertices );
+	this.addAttribute( 'normal', normals );
+	this.addAttribute( 'uv', uvs );
+
+};
+
+THREE.RingBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+THREE.RingBufferGeometry.prototype.constructor = THREE.RingBufferGeometry;
+
+// File:src/extras/geometries/RingGeometry.js
+
+/**
+ * @author Kaleb Murphy
+ */
+
+THREE.RingGeometry = function ( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) {
+
+	THREE.Geometry.call( this );
+
+	this.type = 'RingGeometry';
+
+	this.parameters = {
+		innerRadius: innerRadius,
+		outerRadius: outerRadius,
+		thetaSegments: thetaSegments,
+		phiSegments: phiSegments,
+		thetaStart: thetaStart,
+		thetaLength: thetaLength
+	};
+
+	this.fromBufferGeometry( new THREE.RingBufferGeometry( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) );
+
+};
+
+THREE.RingGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.RingGeometry.prototype.constructor = THREE.RingGeometry;
+
+// File:src/extras/geometries/SphereGeometry.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.SphereGeometry = function ( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) {
+
+	THREE.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 THREE.SphereBufferGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) );
+
+};
+
+THREE.SphereGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.SphereGeometry.prototype.constructor = THREE.SphereGeometry;
+
+// File:src/extras/geometries/SphereBufferGeometry.js
+
+/**
+ * @author benaadams / https://twitter.com/ben_a_adams
+ * based on THREE.SphereGeometry
+ */
+
+THREE.SphereBufferGeometry = function ( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) {
+
+	THREE.BufferGeometry.call( this );
+
+	this.type = 'SphereBufferGeometry';
+
+	this.parameters = {
+		radius: radius,
+		widthSegments: widthSegments,
+		heightSegments: heightSegments,
+		phiStart: phiStart,
+		phiLength: phiLength,
+		thetaStart: thetaStart,
+		thetaLength: thetaLength
+	};
+
+	radius = radius || 50;
+
+	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 = thetaStart + thetaLength;
+
+	var vertexCount = ( ( widthSegments + 1 ) * ( heightSegments + 1 ) );
+
+	var positions = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
+	var normals = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
+	var uvs = new THREE.BufferAttribute( new Float32Array( vertexCount * 2 ), 2 );
+
+	var index = 0, vertices = [], normal = new THREE.Vector3();
+
+	for ( var y = 0; y <= heightSegments; y ++ ) {
+
+		var verticesRow = [];
+
+		var v = y / heightSegments;
+
+		for ( var x = 0; x <= widthSegments; x ++ ) {
+
+			var u = x / widthSegments;
+
+			var px = - radius * Math.cos( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );
+			var py = radius * Math.cos( thetaStart + v * thetaLength );
+			var pz = radius * Math.sin( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );
+
+			normal.set( px, py, pz ).normalize();
+
+			positions.setXYZ( index, px, py, pz );
+			normals.setXYZ( index, normal.x, normal.y, normal.z );
+			uvs.setXY( index, u, 1 - v );
+
+			verticesRow.push( index );
+
+			index ++;
+
+		}
+
+		vertices.push( verticesRow );
+
+	}
+
+	var indices = [];
+
+	for ( var y = 0; y < heightSegments; y ++ ) {
+
+		for ( var x = 0; x < widthSegments; x ++ ) {
+
+			var v1 = vertices[ y ][ x + 1 ];
+			var v2 = vertices[ y ][ x ];
+			var v3 = vertices[ y + 1 ][ x ];
+			var v4 = vertices[ y + 1 ][ x + 1 ];
+
+			if ( y !== 0 || thetaStart > 0 ) indices.push( v1, v2, v4 );
+			if ( y !== heightSegments - 1 || thetaEnd < Math.PI ) indices.push( v2, v3, v4 );
+
+		}
+
+	}
+
+	this.setIndex( new ( positions.count > 65535 ? THREE.Uint32Attribute : THREE.Uint16Attribute )( indices, 1 ) );
+	this.addAttribute( 'position', positions );
+	this.addAttribute( 'normal', normals );
+	this.addAttribute( 'uv', uvs );
+
+	this.boundingSphere = new THREE.Sphere( new THREE.Vector3(), radius );
+
+};
+
+THREE.SphereBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+THREE.SphereBufferGeometry.prototype.constructor = THREE.SphereBufferGeometry;
+
+// File:src/extras/geometries/TextGeometry.js
+
+/**
+ * @author zz85 / http://www.lab4games.net/zz85/blog
+ * @author alteredq / http://alteredqualia.com/
+ *
+ * Text = 3D Text
+ *
+ * parameters = {
+ *  font: <THREE.Font>, // font
+ *
+ *  size: <float>, // size of the text
+ *  height: <float>, // thickness to extrude text
+ *  curveSegments: <int>, // number of points on the curves
+ *
+ *  bevelEnabled: <bool>, // turn on bevel
+ *  bevelThickness: <float>, // how deep into text bevel goes
+ *  bevelSize: <float> // how far from text outline is bevel
+ * }
+ */
+
+THREE.TextGeometry = function ( text, parameters ) {
+
+	parameters = parameters || {};
+
+	var font = parameters.font;
+
+	if ( font instanceof THREE.Font === false ) {
+
+		console.error( 'THREE.TextGeometry: font parameter is not an instance of THREE.Font.' );
+		return new THREE.Geometry();
+
+	}
+
+	var shapes = font.generateShapes( text, parameters.size, parameters.curveSegments );
+
+	// translate parameters to ExtrudeGeometry API
+
+	parameters.amount = 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;
+
+	THREE.ExtrudeGeometry.call( this, shapes, parameters );
+
+	this.type = 'TextGeometry';
+
+};
+
+THREE.TextGeometry.prototype = Object.create( THREE.ExtrudeGeometry.prototype );
+THREE.TextGeometry.prototype.constructor = THREE.TextGeometry;
+
+// File:src/extras/geometries/TorusBufferGeometry.js
+
+/**
+ * @author Mugen87 / https://github.com/Mugen87
+ */
+
+THREE.TorusBufferGeometry = function ( radius, tube, radialSegments, tubularSegments, arc ) {
+
+	THREE.BufferGeometry.call( this );
+
+	this.type = 'TorusBufferGeometry';
+
+	this.parameters = {
+		radius: radius,
+		tube: tube,
+		radialSegments: radialSegments,
+		tubularSegments: tubularSegments,
+		arc: arc
+	};
+
+	radius = radius || 100;
+	tube = tube || 40;
+	radialSegments = Math.floor( radialSegments ) || 8;
+	tubularSegments = Math.floor( tubularSegments ) || 6;
+	arc = arc || Math.PI * 2;
+
+	// used to calculate buffer length
+	var vertexCount = ( ( radialSegments + 1 ) * ( tubularSegments + 1 ) );
+	var indexCount = radialSegments * tubularSegments * 2 * 3;
+
+	// buffers
+	var indices = new ( indexCount > 65535 ? Uint32Array : Uint16Array )( indexCount );
+	var vertices = new Float32Array( vertexCount * 3 );
+	var normals = new Float32Array( vertexCount * 3 );
+	var uvs = new Float32Array( vertexCount * 2 );
+
+	// offset variables
+	var vertexBufferOffset = 0;
+	var uvBufferOffset = 0;
+	var indexBufferOffset = 0;
+
+	// helper variables
+	var center = new THREE.Vector3();
+	var vertex = new THREE.Vector3();
+	var normal = new THREE.Vector3();
+
+	var j, i;
+
+	// generate vertices, normals and uvs
+
+	for ( j = 0; j <= radialSegments; j ++ ) {
+
+		for ( i = 0; i <= tubularSegments; i ++ ) {
+
+			var u = i / tubularSegments * arc;
+			var v = j / radialSegments * Math.PI * 2;
+
+			// vertex
+			vertex.x = ( radius + tube * Math.cos( v ) ) * Math.cos( u );
+			vertex.y = ( radius + tube * Math.cos( v ) ) * Math.sin( u );
+			vertex.z = tube * Math.sin( v );
+
+			vertices[ vertexBufferOffset ] = vertex.x;
+			vertices[ vertexBufferOffset + 1 ] = vertex.y;
+			vertices[ vertexBufferOffset + 2 ] = vertex.z;
+
+			// this vector is used to calculate the normal
+			center.x = radius * Math.cos( u );
+			center.y = radius * Math.sin( u );
+
+			// normal
+			normal.subVectors( vertex, center ).normalize();
+
+			normals[ vertexBufferOffset ] = normal.x;
+			normals[ vertexBufferOffset + 1 ] = normal.y;
+			normals[ vertexBufferOffset + 2 ] = normal.z;
+
+			// uv
+			uvs[ uvBufferOffset ] = i / tubularSegments;
+			uvs[ uvBufferOffset + 1 ] = j / radialSegments;
+
+			// update offsets
+			vertexBufferOffset += 3;
+			uvBufferOffset += 2;
+
+		}
+
+	}
+
+	// generate indices
+
+	for ( j = 1; j <= radialSegments; j ++ ) {
+
+		for ( i = 1; i <= tubularSegments; i ++ ) {
+
+			// indices
+			var a = ( tubularSegments + 1 ) * j + i - 1;
+			var b = ( tubularSegments + 1 ) * ( j - 1 ) + i - 1;
+			var c = ( tubularSegments + 1 ) * ( j - 1 ) + i;
+			var d = ( tubularSegments + 1 ) * j + i;
+
+			// face one
+			indices[ indexBufferOffset ] = a;
+			indices[ indexBufferOffset + 1 ] = b;
+			indices[ indexBufferOffset + 2 ] = d;
+
+			// face two
+			indices[ indexBufferOffset + 3 ] = b;
+			indices[ indexBufferOffset + 4 ] = c;
+			indices[ indexBufferOffset + 5 ] = d;
+
+			// update offset
+			indexBufferOffset += 6;
+
+		}
+
+	}
+
+	// build geometry
+	this.setIndex( new THREE.BufferAttribute( indices, 1 ) );
+	this.addAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+	this.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
+	this.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ) );
+
+};
+
+THREE.TorusBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+THREE.TorusBufferGeometry.prototype.constructor = THREE.TorusBufferGeometry;
+
+// File:src/extras/geometries/TorusGeometry.js
+
+/**
+ * @author oosmoxiecode
+ * @author mrdoob / http://mrdoob.com/
+ * based on http://code.google.com/p/away3d/source/browse/trunk/fp10/Away3DLite/src/away3dlite/primitives/Torus.as?r=2888
+ */
+
+THREE.TorusGeometry = function ( radius, tube, radialSegments, tubularSegments, arc ) {
+
+	THREE.Geometry.call( this );
+
+	this.type = 'TorusGeometry';
+
+	this.parameters = {
+		radius: radius,
+		tube: tube,
+		radialSegments: radialSegments,
+		tubularSegments: tubularSegments,
+		arc: arc
+	};
+
+	this.fromBufferGeometry( new THREE.TorusBufferGeometry( radius, tube, radialSegments, tubularSegments, arc ) );
+
+};
+
+THREE.TorusGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.TorusGeometry.prototype.constructor = THREE.TorusGeometry;
+
+// File:src/extras/geometries/TorusKnotBufferGeometry.js
+
+/**
+ * @author Mugen87 / https://github.com/Mugen87
+ *
+ * see: http://www.blackpawn.com/texts/pqtorus/
+ */
+THREE.TorusKnotBufferGeometry = function ( radius, tube, tubularSegments, radialSegments, p, q ) {
+
+	THREE.BufferGeometry.call( this );
+
+	this.type = 'TorusKnotBufferGeometry';
+
+	this.parameters = {
+		radius: radius,
+		tube: tube,
+		tubularSegments: tubularSegments,
+		radialSegments: radialSegments,
+		p: p,
+		q: q
+	};
+
+	radius = radius || 100;
+	tube = tube || 40;
+	tubularSegments = Math.floor( tubularSegments ) || 64;
+	radialSegments = Math.floor( radialSegments ) || 8;
+	p = p || 2;
+	q = q || 3;
+
+	// used to calculate buffer length
+	var vertexCount = ( ( radialSegments + 1 ) * ( tubularSegments + 1 ) );
+	var indexCount = radialSegments * tubularSegments * 2 * 3;
+
+	// buffers
+	var indices = new THREE.BufferAttribute( new ( indexCount > 65535 ? Uint32Array : Uint16Array )( indexCount ) , 1 );
+	var vertices = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
+	var normals = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
+	var uvs = new THREE.BufferAttribute( new Float32Array( vertexCount * 2 ), 2 );
+
+	// helper variables
+	var i, j, index = 0, indexOffset = 0;
+
+	var vertex = new THREE.Vector3();
+	var normal = new THREE.Vector3();
+	var uv = new THREE.Vector2();
+
+	var P1 = new THREE.Vector3();
+	var P2 = new THREE.Vector3();
+
+	var B = new THREE.Vector3();
+	var T = new THREE.Vector3();
+	var N = new THREE.Vector3();
+
+	// generate vertices, normals and uvs
+
+	for ( i = 0; i <= tubularSegments; ++ i ) {
+
+		// the radian "u" is used to calculate the position on the torus curve of the current tubular segement
+
+		var u = i / tubularSegments * p * Math.PI * 2;
+
+		// now we calculate two points. P1 is our current position on the curve, P2 is a little farther ahead.
+		// these points are used to create a special "coordinate space", which is necessary to calculate the correct vertex positions
+
+		calculatePositionOnCurve( u, p, q, radius, P1 );
+		calculatePositionOnCurve( u + 0.01, p, q, radius, P2 );
+
+		// calculate orthonormal basis
+
+		T.subVectors( P2, P1 );
+		N.addVectors( P2, P1 );
+		B.crossVectors( T, N );
+		N.crossVectors( B, T );
+
+		// normalize B, N. T can be ignored, we don't use it
+
+		B.normalize();
+		N.normalize();
+
+		for ( j = 0; j <= radialSegments; ++ j ) {
+
+			// now calculate the vertices. they are nothing more than an extrusion of the torus curve.
+			// because we extrude a shape in the xy-plane, there is no need to calculate a z-value.
+
+			var v = j / radialSegments * Math.PI * 2;
+			var cx = - tube * Math.cos( v );
+			var cy = tube * Math.sin( v );
+
+			// now calculate the final vertex position.
+			// first we orient the extrusion with our basis vectos, then we add it to the current position on the curve
+
+			vertex.x = P1.x + ( cx * N.x + cy * B.x );
+			vertex.y = P1.y + ( cx * N.y + cy * B.y );
+			vertex.z = P1.z + ( cx * N.z + cy * B.z );
+
+			// vertex
+			vertices.setXYZ( index, vertex.x, vertex.y, vertex.z );
+
+			// normal (P1 is always the center/origin of the extrusion, thus we can use it to calculate the normal)
+			normal.subVectors( vertex, P1 ).normalize();
+			normals.setXYZ( index, normal.x, normal.y, normal.z );
+
+			// uv
+			uv.x = i / tubularSegments;
+			uv.y = j / radialSegments;
+			uvs.setXY( index, uv.x, uv.y );
+
+			// increase index
+			index ++;
+
+		}
+
+	}
+
+	// generate indices
+
+	for ( j = 1; j <= tubularSegments; j ++ ) {
+
+		for ( i = 1; i <= radialSegments; i ++ ) {
+
+			// indices
+			var a = ( radialSegments + 1 ) * ( j - 1 ) + ( i - 1 );
+			var b = ( radialSegments + 1 ) * j + ( i - 1 );
+			var c = ( radialSegments + 1 ) * j + i;
+			var d = ( radialSegments + 1 ) * ( j - 1 ) + i;
+
+			// face one
+			indices.setX( indexOffset, a ); indexOffset++;
+			indices.setX( indexOffset, b ); indexOffset++;
+			indices.setX( indexOffset, d ); indexOffset++;
+
+			// face two
+			indices.setX( indexOffset, b ); indexOffset++;
+			indices.setX( indexOffset, c ); indexOffset++;
+			indices.setX( indexOffset, d ); indexOffset++;
+
+		}
+
+	}
+
+	// build geometry
+
+	this.setIndex( indices );
+	this.addAttribute( 'position', vertices );
+	this.addAttribute( 'normal', normals );
+	this.addAttribute( 'uv', uvs );
+
+	// this function calculates the current position on the torus curve
+
+	function calculatePositionOnCurve( u, p, q, radius, position ) {
+
+		var cu = Math.cos( u );
+		var su = Math.sin( u );
+		var quOverP = q / p * u;
+		var cs = Math.cos( quOverP );
+
+		position.x = radius * ( 2 + cs ) * 0.5 * cu;
+		position.y = radius * ( 2 + cs ) * su * 0.5;
+		position.z = radius * Math.sin( quOverP ) * 0.5;
+
+	}
+
+};
+
+THREE.TorusKnotBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+THREE.TorusKnotBufferGeometry.prototype.constructor = THREE.TorusKnotBufferGeometry;
+
+// File:src/extras/geometries/TorusKnotGeometry.js
+
+/**
+ * @author oosmoxiecode
+ */
+
+THREE.TorusKnotGeometry = function ( radius, tube, tubularSegments, radialSegments, p, q, heightScale ) {
+
+	THREE.Geometry.call( this );
+
+	this.type = 'TorusKnotGeometry';
+
+	this.parameters = {
+		radius: radius,
+		tube: tube,
+		tubularSegments: tubularSegments,
+		radialSegments: radialSegments,
+		p: p,
+		q: q
+	};
+
+	if( heightScale !== undefined ) console.warn( 'THREE.TorusKnotGeometry: heightScale has been deprecated. Use .scale( x, y, z ) instead.' );
+
+	this.fromBufferGeometry( new THREE.TorusKnotBufferGeometry( radius, tube, tubularSegments, radialSegments, p, q ) );
+	this.mergeVertices();
+
+};
+
+THREE.TorusKnotGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.TorusKnotGeometry.prototype.constructor = THREE.TorusKnotGeometry;
+
+// File:src/extras/geometries/TubeGeometry.js
+
+/**
+ * @author WestLangley / https://github.com/WestLangley
+ * @author zz85 / https://github.com/zz85
+ * @author miningold / https://github.com/miningold
+ * @author jonobr1 / https://github.com/jonobr1
+ *
+ * Modified from the TorusKnotGeometry by @oosmoxiecode
+ *
+ * Creates a tube which extrudes along a 3d spline
+ *
+ * Uses parallel transport frames as described in
+ * http://www.cs.indiana.edu/pub/techreports/TR425.pdf
+ */
+
+THREE.TubeGeometry = function ( path, segments, radius, radialSegments, closed, taper ) {
+
+	THREE.Geometry.call( this );
+
+	this.type = 'TubeGeometry';
+
+	this.parameters = {
+		path: path,
+		segments: segments,
+		radius: radius,
+		radialSegments: radialSegments,
+		closed: closed,
+		taper: taper
+	};
+
+	segments = segments || 64;
+	radius = radius || 1;
+	radialSegments = radialSegments || 8;
+	closed = closed || false;
+	taper = taper || THREE.TubeGeometry.NoTaper;
+
+	var grid = [];
+
+	var scope = this,
+
+		tangent,
+		normal,
+		binormal,
+
+		numpoints = segments + 1,
+
+		u, v, r,
+
+		cx, cy,
+		pos, pos2 = new THREE.Vector3(),
+		i, j,
+		ip, jp,
+		a, b, c, d,
+		uva, uvb, uvc, uvd;
+
+	var frames = new THREE.TubeGeometry.FrenetFrames( path, segments, closed ),
+		tangents = frames.tangents,
+		normals = frames.normals,
+		binormals = frames.binormals;
+
+	// proxy internals
+	this.tangents = tangents;
+	this.normals = normals;
+	this.binormals = binormals;
+
+	function vert( x, y, z ) {
+
+		return scope.vertices.push( new THREE.Vector3( x, y, z ) ) - 1;
+
+	}
+
+	// construct the grid
+
+	for ( i = 0; i < numpoints; i ++ ) {
+
+		grid[ i ] = [];
+
+		u = i / ( numpoints - 1 );
+
+		pos = path.getPointAt( u );
+
+		tangent = tangents[ i ];
+		normal = normals[ i ];
+		binormal = binormals[ i ];
+
+		r = radius * taper( u );
+
+		for ( j = 0; j < radialSegments; j ++ ) {
+
+			v = j / radialSegments * 2 * Math.PI;
+
+			cx = - r * Math.cos( v ); // TODO: Hack: Negating it so it faces outside.
+			cy = r * Math.sin( v );
+
+			pos2.copy( pos );
+			pos2.x += cx * normal.x + cy * binormal.x;
+			pos2.y += cx * normal.y + cy * binormal.y;
+			pos2.z += cx * normal.z + cy * binormal.z;
+
+			grid[ i ][ j ] = vert( pos2.x, pos2.y, pos2.z );
+
+		}
+
+	}
+
+
+	// construct the mesh
+
+	for ( i = 0; i < segments; i ++ ) {
+
+		for ( j = 0; j < radialSegments; j ++ ) {
+
+			ip = ( closed ) ? ( i + 1 ) % segments : i + 1;
+			jp = ( j + 1 ) % radialSegments;
+
+			a = grid[ i ][ j ];		// *** NOT NECESSARILY PLANAR ! ***
+			b = grid[ ip ][ j ];
+			c = grid[ ip ][ jp ];
+			d = grid[ i ][ jp ];
+
+			uva = new THREE.Vector2( i / segments, j / radialSegments );
+			uvb = new THREE.Vector2( ( i + 1 ) / segments, j / radialSegments );
+			uvc = new THREE.Vector2( ( i + 1 ) / segments, ( j + 1 ) / radialSegments );
+			uvd = new THREE.Vector2( i / segments, ( j + 1 ) / radialSegments );
+
+			this.faces.push( new THREE.Face3( a, b, d ) );
+			this.faceVertexUvs[ 0 ].push( [ uva, uvb, uvd ] );
+
+			this.faces.push( new THREE.Face3( b, c, d ) );
+			this.faceVertexUvs[ 0 ].push( [ uvb.clone(), uvc, uvd.clone() ] );
+
+		}
+
+	}
+
+	this.computeFaceNormals();
+	this.computeVertexNormals();
+
+};
+
+THREE.TubeGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.TubeGeometry.prototype.constructor = THREE.TubeGeometry;
+
+THREE.TubeGeometry.NoTaper = function ( u ) {
+
+	return 1;
+
+};
+
+THREE.TubeGeometry.SinusoidalTaper = function ( u ) {
+
+	return Math.sin( Math.PI * u );
+
+};
+
+// For computing of Frenet frames, exposing the tangents, normals and binormals the spline
+THREE.TubeGeometry.FrenetFrames = function ( path, segments, closed ) {
+
+	var	normal = new THREE.Vector3(),
+
+		tangents = [],
+		normals = [],
+		binormals = [],
+
+		vec = new THREE.Vector3(),
+		mat = new THREE.Matrix4(),
+
+		numpoints = segments + 1,
+		theta,
+		smallest,
+
+		tx, ty, tz,
+		i, u;
+
+
+	// expose internals
+	this.tangents = tangents;
+	this.normals = normals;
+	this.binormals = binormals;
+
+	// compute the tangent vectors for each segment on the path
+
+	for ( i = 0; i < numpoints; i ++ ) {
+
+		u = i / ( numpoints - 1 );
+
+		tangents[ i ] = path.getTangentAt( u );
+		tangents[ i ].normalize();
+
+	}
+
+	initialNormal3();
+
+	/*
+	function initialNormal1(lastBinormal) {
+		// fixed start binormal. Has dangers of 0 vectors
+		normals[ 0 ] = new THREE.Vector3();
+		binormals[ 0 ] = new THREE.Vector3();
+		if (lastBinormal===undefined) lastBinormal = new THREE.Vector3( 0, 0, 1 );
+		normals[ 0 ].crossVectors( lastBinormal, tangents[ 0 ] ).normalize();
+		binormals[ 0 ].crossVectors( tangents[ 0 ], normals[ 0 ] ).normalize();
+	}
+
+	function initialNormal2() {
+
+		// This uses the Frenet-Serret formula for deriving binormal
+		var t2 = path.getTangentAt( epsilon );
+
+		normals[ 0 ] = new THREE.Vector3().subVectors( t2, tangents[ 0 ] ).normalize();
+		binormals[ 0 ] = new THREE.Vector3().crossVectors( tangents[ 0 ], normals[ 0 ] );
+
+		normals[ 0 ].crossVectors( binormals[ 0 ], tangents[ 0 ] ).normalize(); // last binormal x tangent
+		binormals[ 0 ].crossVectors( tangents[ 0 ], normals[ 0 ] ).normalize();
+
+	}
+	*/
+
+	function initialNormal3() {
+
+		// select an initial normal vector perpendicular to the first tangent vector,
+		// and in the direction of the smallest tangent xyz component
+
+		normals[ 0 ] = new THREE.Vector3();
+		binormals[ 0 ] = new THREE.Vector3();
+		smallest = Number.MAX_VALUE;
+		tx = Math.abs( tangents[ 0 ].x );
+		ty = Math.abs( tangents[ 0 ].y );
+		tz = Math.abs( tangents[ 0 ].z );
+
+		if ( tx <= smallest ) {
+
+			smallest = tx;
+			normal.set( 1, 0, 0 );
+
+		}
+
+		if ( ty <= smallest ) {
+
+			smallest = ty;
+			normal.set( 0, 1, 0 );
+
+		}
+
+		if ( tz <= smallest ) {
+
+			normal.set( 0, 0, 1 );
+
+		}
+
+		vec.crossVectors( tangents[ 0 ], normal ).normalize();
+
+		normals[ 0 ].crossVectors( tangents[ 0 ], vec );
+		binormals[ 0 ].crossVectors( tangents[ 0 ], normals[ 0 ] );
+
+	}
+
+
+	// compute the slowly-varying normal and binormal vectors for each segment on the path
+
+	for ( i = 1; i < numpoints; i ++ ) {
+
+		normals[ i ] = normals[ i - 1 ].clone();
+
+		binormals[ i ] = binormals[ i - 1 ].clone();
+
+		vec.crossVectors( tangents[ i - 1 ], tangents[ i ] );
+
+		if ( vec.length() > Number.EPSILON ) {
+
+			vec.normalize();
+
+			theta = Math.acos( THREE.Math.clamp( tangents[ i - 1 ].dot( tangents[ i ] ), - 1, 1 ) ); // clamp for floating pt errors
+
+			normals[ i ].applyMatrix4( mat.makeRotationAxis( vec, theta ) );
+
+		}
+
+		binormals[ i ].crossVectors( tangents[ i ], normals[ i ] );
+
+	}
+
+
+	// if the curve is closed, postprocess the vectors so the first and last normal vectors are the same
+
+	if ( closed ) {
+
+		theta = Math.acos( THREE.Math.clamp( normals[ 0 ].dot( normals[ numpoints - 1 ] ), - 1, 1 ) );
+		theta /= ( numpoints - 1 );
+
+		if ( tangents[ 0 ].dot( vec.crossVectors( normals[ 0 ], normals[ numpoints - 1 ] ) ) > 0 ) {
+
+			theta = - theta;
+
+		}
+
+		for ( i = 1; i < numpoints; i ++ ) {
+
+			// twist a little...
+			normals[ i ].applyMatrix4( mat.makeRotationAxis( tangents[ i ], theta * i ) );
+			binormals[ i ].crossVectors( tangents[ i ], normals[ i ] );
+
+		}
+
+	}
+
+};
+
+// File:src/extras/geometries/PolyhedronGeometry.js
+
+/**
+ * @author clockworkgeek / https://github.com/clockworkgeek
+ * @author timothypratley / https://github.com/timothypratley
+ * @author WestLangley / http://github.com/WestLangley
+*/
+
+THREE.PolyhedronGeometry = function ( vertices, indices, radius, detail ) {
+
+	THREE.Geometry.call( this );
+
+	this.type = 'PolyhedronGeometry';
+
+	this.parameters = {
+		vertices: vertices,
+		indices: indices,
+		radius: radius,
+		detail: detail
+	};
+
+	radius = radius || 1;
+	detail = detail || 0;
+
+	var that = this;
+
+	for ( var i = 0, l = vertices.length; i < l; i += 3 ) {
+
+		prepare( new THREE.Vector3( vertices[ i ], vertices[ i + 1 ], vertices[ i + 2 ] ) );
+
+	}
+
+	var p = this.vertices;
+
+	var faces = [];
+
+	for ( var i = 0, j = 0, l = indices.length; i < l; i += 3, j ++ ) {
+
+		var v1 = p[ indices[ i ] ];
+		var v2 = p[ indices[ i + 1 ] ];
+		var v3 = p[ indices[ i + 2 ] ];
+
+		faces[ j ] = new THREE.Face3( v1.index, v2.index, v3.index, [ v1.clone(), v2.clone(), v3.clone() ], undefined, j );
+
+	}
+
+	var centroid = new THREE.Vector3();
+
+	for ( var i = 0, l = faces.length; i < l; i ++ ) {
+
+		subdivide( faces[ i ], detail );
+
+	}
+
+
+	// Handle case when face straddles the seam
+
+	for ( var i = 0, l = this.faceVertexUvs[ 0 ].length; i < l; i ++ ) {
+
+		var uvs = this.faceVertexUvs[ 0 ][ i ];
+
+		var x0 = uvs[ 0 ].x;
+		var x1 = uvs[ 1 ].x;
+		var x2 = uvs[ 2 ].x;
+
+		var max = Math.max( x0, x1, x2 );
+		var min = Math.min( x0, x1, x2 );
+
+		if ( max > 0.9 && min < 0.1 ) {
+
+			// 0.9 is somewhat arbitrary
+
+			if ( x0 < 0.2 ) uvs[ 0 ].x += 1;
+			if ( x1 < 0.2 ) uvs[ 1 ].x += 1;
+			if ( x2 < 0.2 ) uvs[ 2 ].x += 1;
+
+		}
+
+	}
+
+
+	// Apply radius
+
+	for ( var i = 0, l = this.vertices.length; i < l; i ++ ) {
+
+		this.vertices[ i ].multiplyScalar( radius );
+
+	}
+
+
+	// Merge vertices
+
+	this.mergeVertices();
+
+	this.computeFaceNormals();
+
+	this.boundingSphere = new THREE.Sphere( new THREE.Vector3(), radius );
+
+
+	// Project vector onto sphere's surface
+
+	function prepare( vector ) {
+
+		var vertex = vector.normalize().clone();
+		vertex.index = that.vertices.push( vertex ) - 1;
+
+		// Texture coords are equivalent to map coords, calculate angle and convert to fraction of a circle.
+
+		var u = azimuth( vector ) / 2 / Math.PI + 0.5;
+		var v = inclination( vector ) / Math.PI + 0.5;
+		vertex.uv = new THREE.Vector2( u, 1 - v );
+
+		return vertex;
+
+	}
+
+
+	// Approximate a curved face with recursively sub-divided triangles.
+
+	function make( v1, v2, v3, materialIndex ) {
+
+		var face = new THREE.Face3( v1.index, v2.index, v3.index, [ v1.clone(), v2.clone(), v3.clone() ], undefined, materialIndex );
+		that.faces.push( face );
+
+		centroid.copy( v1 ).add( v2 ).add( v3 ).divideScalar( 3 );
+
+		var azi = azimuth( centroid );
+
+		that.faceVertexUvs[ 0 ].push( [
+			correctUV( v1.uv, v1, azi ),
+			correctUV( v2.uv, v2, azi ),
+			correctUV( v3.uv, v3, azi )
+		] );
+
+	}
+
+
+	// Analytically subdivide a face to the required detail level.
+
+	function subdivide( face, detail ) {
+
+		var cols = Math.pow( 2, detail );
+		var a = prepare( that.vertices[ face.a ] );
+		var b = prepare( that.vertices[ face.b ] );
+		var c = prepare( that.vertices[ face.c ] );
+		var v = [];
+
+		var materialIndex = face.materialIndex;
+
+		// Construct all of the vertices for this subdivision.
+
+		for ( var i = 0 ; i <= cols; i ++ ) {
+
+			v[ i ] = [];
+
+			var aj = prepare( a.clone().lerp( c, i / cols ) );
+			var bj = prepare( b.clone().lerp( c, i / cols ) );
+			var rows = cols - i;
+
+			for ( var j = 0; j <= rows; j ++ ) {
+
+				if ( j === 0 && i === cols ) {
+
+					v[ i ][ j ] = aj;
+
+				} else {
+
+					v[ i ][ j ] = prepare( aj.clone().lerp( bj, j / rows ) );
+
+				}
+
+			}
+
+		}
+
+		// Construct all of the faces.
+
+		for ( var i = 0; i < cols ; i ++ ) {
+
+			for ( var j = 0; j < 2 * ( cols - i ) - 1; j ++ ) {
+
+				var k = Math.floor( j / 2 );
+
+				if ( j % 2 === 0 ) {
+
+					make(
+						v[ i ][ k + 1 ],
+						v[ i + 1 ][ k ],
+						v[ i ][ k ],
+						materialIndex
+					);
+
+				} else {
+
+					make(
+						v[ i ][ k + 1 ],
+						v[ i + 1 ][ k + 1 ],
+						v[ i + 1 ][ k ],
+						materialIndex
+					);
+
+				}
+
+			}
+
+		}
+
+	}
+
+
+	// Angle around the Y axis, counter-clockwise when looking from above.
+
+	function azimuth( vector ) {
+
+		return Math.atan2( vector.z, - vector.x );
+
+	}
+
+
+	// Angle above the XZ plane.
+
+	function inclination( vector ) {
+
+		return Math.atan2( - vector.y, Math.sqrt( ( vector.x * vector.x ) + ( vector.z * vector.z ) ) );
+
+	}
+
+
+	// Texture fixing helper. Spheres have some odd behaviours.
+
+	function correctUV( uv, vector, azimuth ) {
+
+		if ( ( azimuth < 0 ) && ( uv.x === 1 ) ) uv = new THREE.Vector2( uv.x - 1, uv.y );
+		if ( ( vector.x === 0 ) && ( vector.z === 0 ) ) uv = new THREE.Vector2( azimuth / 2 / Math.PI + 0.5, uv.y );
+		return uv.clone();
+
+	}
+
+
+};
+
+THREE.PolyhedronGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.PolyhedronGeometry.prototype.constructor = THREE.PolyhedronGeometry;
+
+// File:src/extras/geometries/DodecahedronGeometry.js
+
+/**
+ * @author Abe Pazos / https://hamoid.com
+ */
+
+THREE.DodecahedronGeometry = function ( radius, detail ) {
+
+	var t = ( 1 + Math.sqrt( 5 ) ) / 2;
+	var r = 1 / t;
+
+	var vertices = [
+
+		// (±1, ±1, ±1)
+		- 1, - 1, - 1,    - 1, - 1,  1,
+		- 1,  1, - 1,    - 1,  1,  1,
+		 1, - 1, - 1,     1, - 1,  1,
+		 1,  1, - 1,     1,  1,  1,
+
+		// (0, ±1/φ, ±φ)
+		 0, - r, - t,     0, - r,  t,
+		 0,  r, - t,     0,  r,  t,
+
+		// (±1/φ, ±φ, 0)
+		- r, - t,  0,    - r,  t,  0,
+		 r, - t,  0,     r,  t,  0,
+
+		// (±φ, 0, ±1/φ)
+		- t,  0, - r,     t,  0, - r,
+		- t,  0,  r,     t,  0,  r
+	];
+
+	var indices = [
+		 3, 11,  7,      3,  7, 15,      3, 15, 13,
+		 7, 19, 17,      7, 17,  6,      7,  6, 15,
+		17,  4,  8,     17,  8, 10,     17, 10,  6,
+		 8,  0, 16,      8, 16,  2,      8,  2, 10,
+		 0, 12,  1,      0,  1, 18,      0, 18, 16,
+		 6, 10,  2,      6,  2, 13,      6, 13, 15,
+		 2, 16, 18,      2, 18,  3,      2,  3, 13,
+		18,  1,  9,     18,  9, 11,     18, 11,  3,
+		 4, 14, 12,      4, 12,  0,      4,  0,  8,
+		11,  9,  5,     11,  5, 19,     11, 19,  7,
+		19,  5, 14,     19, 14,  4,     19,  4, 17,
+		 1, 12, 14,      1, 14,  5,      1,  5,  9
+	];
+
+	THREE.PolyhedronGeometry.call( this, vertices, indices, radius, detail );
+
+	this.type = 'DodecahedronGeometry';
+
+	this.parameters = {
+		radius: radius,
+		detail: detail
+	};
+
+};
+
+THREE.DodecahedronGeometry.prototype = Object.create( THREE.PolyhedronGeometry.prototype );
+THREE.DodecahedronGeometry.prototype.constructor = THREE.DodecahedronGeometry;
+
+// File:src/extras/geometries/IcosahedronGeometry.js
+
+/**
+ * @author timothypratley / https://github.com/timothypratley
+ */
+
+THREE.IcosahedronGeometry = function ( radius, detail ) {
+
+	var t = ( 1 + Math.sqrt( 5 ) ) / 2;
+
+	var vertices = [
+		- 1,  t,  0,    1,  t,  0,   - 1, - t,  0,    1, - t,  0,
+		 0, - 1,  t,    0,  1,  t,    0, - 1, - t,    0,  1, - t,
+		 t,  0, - 1,    t,  0,  1,   - t,  0, - 1,   - t,  0,  1
+	];
+
+	var indices = [
+		 0, 11,  5,    0,  5,  1,    0,  1,  7,    0,  7, 10,    0, 10, 11,
+		 1,  5,  9,    5, 11,  4,   11, 10,  2,   10,  7,  6,    7,  1,  8,
+		 3,  9,  4,    3,  4,  2,    3,  2,  6,    3,  6,  8,    3,  8,  9,
+		 4,  9,  5,    2,  4, 11,    6,  2, 10,    8,  6,  7,    9,  8,  1
+	];
+
+	THREE.PolyhedronGeometry.call( this, vertices, indices, radius, detail );
+
+	this.type = 'IcosahedronGeometry';
+
+	this.parameters = {
+		radius: radius,
+		detail: detail
+	};
+
+};
+
+THREE.IcosahedronGeometry.prototype = Object.create( THREE.PolyhedronGeometry.prototype );
+THREE.IcosahedronGeometry.prototype.constructor = THREE.IcosahedronGeometry;
+
+// File:src/extras/geometries/OctahedronGeometry.js
+
+/**
+ * @author timothypratley / https://github.com/timothypratley
+ */
+
+THREE.OctahedronGeometry = function ( radius, detail ) {
+
+	var vertices = [
+		1, 0, 0,   - 1, 0, 0,    0, 1, 0,    0, - 1, 0,    0, 0, 1,    0, 0, - 1
+	];
+
+	var indices = [
+		0, 2, 4,    0, 4, 3,    0, 3, 5,    0, 5, 2,    1, 2, 5,    1, 5, 3,    1, 3, 4,    1, 4, 2
+	];
+
+	THREE.PolyhedronGeometry.call( this, vertices, indices, radius, detail );
+
+	this.type = 'OctahedronGeometry';
+
+	this.parameters = {
+		radius: radius,
+		detail: detail
+	};
+
+};
+
+THREE.OctahedronGeometry.prototype = Object.create( THREE.PolyhedronGeometry.prototype );
+THREE.OctahedronGeometry.prototype.constructor = THREE.OctahedronGeometry;
+
+// File:src/extras/geometries/TetrahedronGeometry.js
+
+/**
+ * @author timothypratley / https://github.com/timothypratley
+ */
+
+THREE.TetrahedronGeometry = function ( radius, detail ) {
+
+	var vertices = [
+		 1,  1,  1,   - 1, - 1,  1,   - 1,  1, - 1,    1, - 1, - 1
+	];
+
+	var indices = [
+		 2,  1,  0,    0,  3,  2,    1,  3,  0,    2,  3,  1
+	];
+
+	THREE.PolyhedronGeometry.call( this, vertices, indices, radius, detail );
+
+	this.type = 'TetrahedronGeometry';
+
+	this.parameters = {
+		radius: radius,
+		detail: detail
+	};
+
+};
+
+THREE.TetrahedronGeometry.prototype = Object.create( THREE.PolyhedronGeometry.prototype );
+THREE.TetrahedronGeometry.prototype.constructor = THREE.TetrahedronGeometry;
+
+// File:src/extras/geometries/ParametricGeometry.js
+
+/**
+ * @author zz85 / https://github.com/zz85
+ * Parametric Surfaces Geometry
+ * based on the brilliant article by @prideout http://prideout.net/blog/?p=44
+ *
+ * new THREE.ParametricGeometry( parametricFunction, uSegments, ySegements );
+ *
+ */
+
+THREE.ParametricGeometry = function ( func, slices, stacks ) {
+
+	THREE.Geometry.call( this );
+
+	this.type = 'ParametricGeometry';
+
+	this.parameters = {
+		func: func,
+		slices: slices,
+		stacks: stacks
+	};
+
+	var verts = this.vertices;
+	var faces = this.faces;
+	var uvs = this.faceVertexUvs[ 0 ];
+
+	var i, j, p;
+	var u, v;
+
+	var sliceCount = slices + 1;
+
+	for ( i = 0; i <= stacks; i ++ ) {
+
+		v = i / stacks;
+
+		for ( j = 0; j <= slices; j ++ ) {
+
+			u = j / slices;
+
+			p = func( u, v );
+			verts.push( p );
+
+		}
+
+	}
+
+	var a, b, c, d;
+	var uva, uvb, uvc, uvd;
+
+	for ( i = 0; i < stacks; i ++ ) {
+
+		for ( j = 0; j < slices; j ++ ) {
+
+			a = i * sliceCount + j;
+			b = i * sliceCount + j + 1;
+			c = ( i + 1 ) * sliceCount + j + 1;
+			d = ( i + 1 ) * sliceCount + j;
+
+			uva = new THREE.Vector2( j / slices, i / stacks );
+			uvb = new THREE.Vector2( ( j + 1 ) / slices, i / stacks );
+			uvc = new THREE.Vector2( ( j + 1 ) / slices, ( i + 1 ) / stacks );
+			uvd = new THREE.Vector2( j / slices, ( i + 1 ) / stacks );
+
+			faces.push( new THREE.Face3( a, b, d ) );
+			uvs.push( [ uva, uvb, uvd ] );
+
+			faces.push( new THREE.Face3( b, c, d ) );
+			uvs.push( [ uvb.clone(), uvc, uvd.clone() ] );
+
+		}
+
+	}
+
+	// console.log(this);
+
+	// magic bullet
+	// var diff = this.mergeVertices();
+	// console.log('removed ', diff, ' vertices by merging');
+
+	this.computeFaceNormals();
+	this.computeVertexNormals();
+
+};
+
+THREE.ParametricGeometry.prototype = Object.create( THREE.Geometry.prototype );
+THREE.ParametricGeometry.prototype.constructor = THREE.ParametricGeometry;
+
+// File:src/extras/geometries/WireframeGeometry.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.WireframeGeometry = function ( geometry ) {
+
+	THREE.BufferGeometry.call( this );
+
+	var edge = [ 0, 0 ], hash = {};
+
+	function sortFunction( a, b ) {
+
+		return a - b;
+
+	}
+
+	var keys = [ 'a', 'b', 'c' ];
+
+	if ( geometry instanceof THREE.Geometry ) {
+
+		var vertices = geometry.vertices;
+		var faces = geometry.faces;
+		var numEdges = 0;
+
+		// allocate maximal size
+		var edges = new Uint32Array( 6 * faces.length );
+
+		for ( var i = 0, l = faces.length; i < l; i ++ ) {
+
+			var face = faces[ i ];
+
+			for ( var j = 0; j < 3; j ++ ) {
+
+				edge[ 0 ] = face[ keys[ j ] ];
+				edge[ 1 ] = face[ keys[ ( j + 1 ) % 3 ] ];
+				edge.sort( sortFunction );
+
+				var key = edge.toString();
+
+				if ( hash[ key ] === undefined ) {
+
+					edges[ 2 * numEdges ] = edge[ 0 ];
+					edges[ 2 * numEdges + 1 ] = edge[ 1 ];
+					hash[ key ] = true;
+					numEdges ++;
+
+				}
+
+			}
+
+		}
+
+		var coords = new Float32Array( numEdges * 2 * 3 );
+
+		for ( var i = 0, l = numEdges; i < l; i ++ ) {
+
+			for ( var j = 0; j < 2; j ++ ) {
+
+				var vertex = vertices[ edges [ 2 * i + j ] ];
+
+				var index = 6 * i + 3 * j;
+				coords[ index + 0 ] = vertex.x;
+				coords[ index + 1 ] = vertex.y;
+				coords[ index + 2 ] = vertex.z;
+
+			}
+
+		}
+
+		this.addAttribute( 'position', new THREE.BufferAttribute( coords, 3 ) );
+
+	} else if ( geometry instanceof THREE.BufferGeometry ) {
+
+		if ( geometry.index !== null ) {
+
+			// Indexed BufferGeometry
+
+			var indices = geometry.index.array;
+			var vertices = geometry.attributes.position;
+			var groups = geometry.groups;
+			var numEdges = 0;
+
+			if ( groups.length === 0 ) {
+
+				geometry.addGroup( 0, indices.length );
+
+			}
+
+			// allocate maximal size
+			var edges = new Uint32Array( 2 * indices.length );
+
+			for ( var o = 0, ol = groups.length; o < ol; ++ o ) {
+
+				var group = groups[ o ];
+
+				var start = group.start;
+				var count = group.count;
+
+				for ( var i = start, il = start + count; i < il; i += 3 ) {
+
+					for ( var j = 0; j < 3; j ++ ) {
+
+						edge[ 0 ] = indices[ i + j ];
+						edge[ 1 ] = indices[ i + ( j + 1 ) % 3 ];
+						edge.sort( sortFunction );
+
+						var key = edge.toString();
+
+						if ( hash[ key ] === undefined ) {
+
+							edges[ 2 * numEdges ] = edge[ 0 ];
+							edges[ 2 * numEdges + 1 ] = edge[ 1 ];
+							hash[ key ] = true;
+							numEdges ++;
+
+						}
+
+					}
+
+				}
+
+			}
+
+			var coords = new Float32Array( numEdges * 2 * 3 );
+
+			for ( var i = 0, l = numEdges; i < l; i ++ ) {
+
+				for ( var j = 0; j < 2; j ++ ) {
+
+					var index = 6 * i + 3 * j;
+					var index2 = edges[ 2 * i + j ];
+
+					coords[ index + 0 ] = vertices.getX( index2 );
+					coords[ index + 1 ] = vertices.getY( index2 );
+					coords[ index + 2 ] = vertices.getZ( index2 );
+
+				}
+
+			}
+
+			this.addAttribute( 'position', new THREE.BufferAttribute( coords, 3 ) );
+
+		} else {
+
+			// non-indexed BufferGeometry
+
+			var vertices = geometry.attributes.position.array;
+			var numEdges = vertices.length / 3;
+			var numTris = numEdges / 3;
+
+			var coords = new Float32Array( numEdges * 2 * 3 );
+
+			for ( var i = 0, l = numTris; i < l; i ++ ) {
+
+				for ( var j = 0; j < 3; j ++ ) {
+
+					var index = 18 * i + 6 * j;
+
+					var index1 = 9 * i + 3 * j;
+					coords[ index + 0 ] = vertices[ index1 ];
+					coords[ index + 1 ] = vertices[ index1 + 1 ];
+					coords[ index + 2 ] = vertices[ index1 + 2 ];
+
+					var index2 = 9 * i + 3 * ( ( j + 1 ) % 3 );
+					coords[ index + 3 ] = vertices[ index2 ];
+					coords[ index + 4 ] = vertices[ index2 + 1 ];
+					coords[ index + 5 ] = vertices[ index2 + 2 ];
+
+				}
+
+			}
+
+			this.addAttribute( 'position', new THREE.BufferAttribute( coords, 3 ) );
+
+		}
+
+	}
+
+};
+
+THREE.WireframeGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
+THREE.WireframeGeometry.prototype.constructor = THREE.WireframeGeometry;
+
+// File:src/extras/helpers/AxisHelper.js
+
+/**
+ * @author sroucheray / http://sroucheray.org/
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.AxisHelper = function ( size ) {
+
+	size = size || 1;
+
+	var vertices = new Float32Array( [
+		0, 0, 0,  size, 0, 0,
+		0, 0, 0,  0, size, 0,
+		0, 0, 0,  0, 0, size
+	] );
+
+	var colors = new Float32Array( [
+		1, 0, 0,  1, 0.6, 0,
+		0, 1, 0,  0.6, 1, 0,
+		0, 0, 1,  0, 0.6, 1
+	] );
+
+	var geometry = new THREE.BufferGeometry();
+	geometry.addAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
+	geometry.addAttribute( 'color', new THREE.BufferAttribute( colors, 3 ) );
+
+	var material = new THREE.LineBasicMaterial( { vertexColors: THREE.VertexColors } );
+
+	THREE.LineSegments.call( this, geometry, material );
+
+};
+
+THREE.AxisHelper.prototype = Object.create( THREE.LineSegments.prototype );
+THREE.AxisHelper.prototype.constructor = THREE.AxisHelper;
+
+// File:src/extras/helpers/ArrowHelper.js
+
+/**
+ * @author WestLangley / http://github.com/WestLangley
+ * @author zz85 / http://github.com/zz85
+ * @author bhouston / http://clara.io
+ *
+ * Creates an arrow for visualizing directions
+ *
+ * Parameters:
+ *  dir - Vector3
+ *  origin - Vector3
+ *  length - Number
+ *  color - color in hex value
+ *  headLength - Number
+ *  headWidth - Number
+ */
+
+THREE.ArrowHelper = ( function () {
+
+	var lineGeometry = new THREE.Geometry();
+	lineGeometry.vertices.push( new THREE.Vector3( 0, 0, 0 ), new THREE.Vector3( 0, 1, 0 ) );
+
+	var coneGeometry = new THREE.CylinderGeometry( 0, 0.5, 1, 5, 1 );
+	coneGeometry.translate( 0, - 0.5, 0 );
+
+	return function ArrowHelper( dir, origin, length, color, headLength, headWidth ) {
+
+		// dir is assumed to be normalized
+
+		THREE.Object3D.call( this );
+
+		if ( color === undefined ) color = 0xffff00;
+		if ( length === undefined ) length = 1;
+		if ( headLength === undefined ) headLength = 0.2 * length;
+		if ( headWidth === undefined ) headWidth = 0.2 * headLength;
+
+		this.position.copy( origin );
+		
+		this.line = new THREE.Line( lineGeometry, new THREE.LineBasicMaterial( { color: color } ) );
+		this.line.matrixAutoUpdate = false;
+		this.add( this.line );
+
+		this.cone = new THREE.Mesh( coneGeometry, new THREE.MeshBasicMaterial( { color: color } ) );
+		this.cone.matrixAutoUpdate = false;
+		this.add( this.cone );
+
+		this.setDirection( dir );
+		this.setLength( length, headLength, headWidth );
+
+	}
+
+}() );
+
+THREE.ArrowHelper.prototype = Object.create( THREE.Object3D.prototype );
+THREE.ArrowHelper.prototype.constructor = THREE.ArrowHelper;
+
+THREE.ArrowHelper.prototype.setDirection = ( function () {
+
+	var axis = new THREE.Vector3();
+	var radians;
+
+	return function setDirection( dir ) {
+
+		// dir is assumed to be normalized
+
+		if ( dir.y > 0.99999 ) {
+
+			this.quaternion.set( 0, 0, 0, 1 );
+
+		} else if ( dir.y < - 0.99999 ) {
+
+			this.quaternion.set( 1, 0, 0, 0 );
+
+		} else {
+
+			axis.set( dir.z, 0, - dir.x ).normalize();
+
+			radians = Math.acos( dir.y );
+
+			this.quaternion.setFromAxisAngle( axis, radians );
+
+		}
+
+	};
+
+}() );
+
+THREE.ArrowHelper.prototype.setLength = function ( length, headLength, headWidth ) {
+
+	if ( headLength === undefined ) headLength = 0.2 * length;
+	if ( headWidth === undefined ) headWidth = 0.2 * headLength;
+
+	this.line.scale.set( 1, Math.max( 0, length - headLength ), 1 );
+	this.line.updateMatrix();
+
+	this.cone.scale.set( headWidth, headLength, headWidth );
+	this.cone.position.y = length;
+	this.cone.updateMatrix();
+
+};
+
+THREE.ArrowHelper.prototype.setColor = function ( color ) {
+
+	this.line.material.color.set( color );
+	this.cone.material.color.set( color );
+
+};
+
+// File:src/extras/helpers/BoxHelper.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.BoxHelper = function ( object ) {
+
+	var indices = new Uint16Array( [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 ] );
+	var positions = new Float32Array( 8 * 3 );
+
+	var geometry = new THREE.BufferGeometry();
+	geometry.setIndex( new THREE.BufferAttribute( indices, 1 ) );
+	geometry.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
+
+	THREE.LineSegments.call( this, geometry, new THREE.LineBasicMaterial( { color: 0xffff00 } ) );
+
+	if ( object !== undefined ) {
+
+		this.update( object );
+
+	}
+
+};
+
+THREE.BoxHelper.prototype = Object.create( THREE.LineSegments.prototype );
+THREE.BoxHelper.prototype.constructor = THREE.BoxHelper;
+
+THREE.BoxHelper.prototype.update = ( function () {
+
+	var box = new THREE.Box3();
+
+	return function ( object ) {
+
+		if ( object instanceof THREE.Box3 ) {
+
+			box.copy( object );
+
+		} else {
+
+			box.setFromObject( object );
+
+		}
+
+		if ( box.isEmpty() ) return;
+
+		var min = box.min;
+		var max = box.max;
+
+		/*
+		  5____4
+		1/___0/|
+		| 6__|_7
+		2/___3/
+
+		0: max.x, max.y, max.z
+		1: min.x, max.y, max.z
+		2: min.x, min.y, max.z
+		3: max.x, min.y, max.z
+		4: max.x, max.y, min.z
+		5: min.x, max.y, min.z
+		6: min.x, min.y, min.z
+		7: max.x, min.y, min.z
+		*/
+
+		var position = this.geometry.attributes.position;
+		var array = position.array;
+
+		array[  0 ] = max.x; array[  1 ] = max.y; array[  2 ] = max.z;
+		array[  3 ] = min.x; array[  4 ] = max.y; array[  5 ] = max.z;
+		array[  6 ] = min.x; array[  7 ] = min.y; array[  8 ] = max.z;
+		array[  9 ] = max.x; array[ 10 ] = min.y; array[ 11 ] = max.z;
+		array[ 12 ] = max.x; array[ 13 ] = max.y; array[ 14 ] = min.z;
+		array[ 15 ] = min.x; array[ 16 ] = max.y; array[ 17 ] = min.z;
+		array[ 18 ] = min.x; array[ 19 ] = min.y; array[ 20 ] = min.z;
+		array[ 21 ] = max.x; array[ 22 ] = min.y; array[ 23 ] = min.z;
+
+		position.needsUpdate = true;
+
+		this.geometry.computeBoundingSphere();
+
+	};
+
+} )();
+
+// File:src/extras/helpers/BoundingBoxHelper.js
+
+/**
+ * @author WestLangley / http://github.com/WestLangley
+ */
+
+// a helper to show the world-axis-aligned bounding box for an object
+
+THREE.BoundingBoxHelper = function ( object, hex ) {
+
+	var color = ( hex !== undefined ) ? hex : 0x888888;
+
+	this.object = object;
+
+	this.box = new THREE.Box3();
+
+	THREE.Mesh.call( this, new THREE.BoxGeometry( 1, 1, 1 ), new THREE.MeshBasicMaterial( { color: color, wireframe: true } ) );
+
+};
+
+THREE.BoundingBoxHelper.prototype = Object.create( THREE.Mesh.prototype );
+THREE.BoundingBoxHelper.prototype.constructor = THREE.BoundingBoxHelper;
+
+THREE.BoundingBoxHelper.prototype.update = function () {
+
+	this.box.setFromObject( this.object );
+
+	this.box.size( this.scale );
+
+	this.box.center( this.position );
+
+};
+
+// File:src/extras/helpers/CameraHelper.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ *
+ *	- shows frustum, line of sight and up of the camera
+ *	- suitable for fast updates
+ * 	- based on frustum visualization in lightgl.js shadowmap example
+ *		http://evanw.github.com/lightgl.js/tests/shadowmap.html
+ */
+
+THREE.CameraHelper = function ( camera ) {
+
+	var geometry = new THREE.Geometry();
+	var material = new THREE.LineBasicMaterial( { color: 0xffffff, vertexColors: THREE.FaceColors } );
+
+	var pointMap = {};
+
+	// colors
+
+	var hexFrustum = 0xffaa00;
+	var hexCone = 0xff0000;
+	var hexUp = 0x00aaff;
+	var hexTarget = 0xffffff;
+	var hexCross = 0x333333;
+
+	// near
+
+	addLine( "n1", "n2", hexFrustum );
+	addLine( "n2", "n4", hexFrustum );
+	addLine( "n4", "n3", hexFrustum );
+	addLine( "n3", "n1", hexFrustum );
+
+	// far
+
+	addLine( "f1", "f2", hexFrustum );
+	addLine( "f2", "f4", hexFrustum );
+	addLine( "f4", "f3", hexFrustum );
+	addLine( "f3", "f1", hexFrustum );
+
+	// sides
+
+	addLine( "n1", "f1", hexFrustum );
+	addLine( "n2", "f2", hexFrustum );
+	addLine( "n3", "f3", hexFrustum );
+	addLine( "n4", "f4", hexFrustum );
+
+	// cone
+
+	addLine( "p", "n1", hexCone );
+	addLine( "p", "n2", hexCone );
+	addLine( "p", "n3", hexCone );
+	addLine( "p", "n4", hexCone );
+
+	// up
+
+	addLine( "u1", "u2", hexUp );
+	addLine( "u2", "u3", hexUp );
+	addLine( "u3", "u1", hexUp );
+
+	// target
+
+	addLine( "c", "t", hexTarget );
+	addLine( "p", "c", hexCross );
+
+	// cross
+
+	addLine( "cn1", "cn2", hexCross );
+	addLine( "cn3", "cn4", hexCross );
+
+	addLine( "cf1", "cf2", hexCross );
+	addLine( "cf3", "cf4", hexCross );
+
+	function addLine( a, b, hex ) {
+
+		addPoint( a, hex );
+		addPoint( b, hex );
+
+	}
+
+	function addPoint( id, hex ) {
+
+		geometry.vertices.push( new THREE.Vector3() );
+		geometry.colors.push( new THREE.Color( hex ) );
+
+		if ( pointMap[ id ] === undefined ) {
+
+			pointMap[ id ] = [];
+
+		}
+
+		pointMap[ id ].push( geometry.vertices.length - 1 );
+
+	}
+
+	THREE.LineSegments.call( this, geometry, material );
+
+	this.camera = camera;
+	this.camera.updateProjectionMatrix();
+
+	this.matrix = camera.matrixWorld;
+	this.matrixAutoUpdate = false;
+
+	this.pointMap = pointMap;
+
+	this.update();
+
+};
+
+THREE.CameraHelper.prototype = Object.create( THREE.LineSegments.prototype );
+THREE.CameraHelper.prototype.constructor = THREE.CameraHelper;
+
+THREE.CameraHelper.prototype.update = function () {
+
+	var geometry, pointMap;
+
+	var vector = new THREE.Vector3();
+	var camera = new THREE.Camera();
+
+	function setPoint( point, x, y, z ) {
+
+		vector.set( x, y, z ).unproject( camera );
+
+		var points = pointMap[ point ];
+
+		if ( points !== undefined ) {
+
+			for ( var i = 0, il = points.length; i < il; i ++ ) {
+
+				geometry.vertices[ points[ i ] ].copy( vector );
+
+			}
+
+		}
+
+	}
+
+	return function () {
+
+		geometry = this.geometry;
+		pointMap = this.pointMap;
+
+		var w = 1, h = 1;
+
+		// we need just camera projection matrix
+		// world matrix must be identity
+
+		camera.projectionMatrix.copy( this.camera.projectionMatrix );
+
+		// center / target
+
+		setPoint( "c", 0, 0, - 1 );
+		setPoint( "t", 0, 0,  1 );
+
+		// near
+
+		setPoint( "n1", - w, - h, - 1 );
+		setPoint( "n2",   w, - h, - 1 );
+		setPoint( "n3", - w,   h, - 1 );
+		setPoint( "n4",   w,   h, - 1 );
+
+		// far
+
+		setPoint( "f1", - w, - h, 1 );
+		setPoint( "f2",   w, - h, 1 );
+		setPoint( "f3", - w,   h, 1 );
+		setPoint( "f4",   w,   h, 1 );
+
+		// up
+
+		setPoint( "u1",   w * 0.7, h * 1.1, - 1 );
+		setPoint( "u2", - w * 0.7, h * 1.1, - 1 );
+		setPoint( "u3",         0, h * 2,   - 1 );
+
+		// cross
+
+		setPoint( "cf1", - w,   0, 1 );
+		setPoint( "cf2",   w,   0, 1 );
+		setPoint( "cf3",   0, - h, 1 );
+		setPoint( "cf4",   0,   h, 1 );
+
+		setPoint( "cn1", - w,   0, - 1 );
+		setPoint( "cn2",   w,   0, - 1 );
+		setPoint( "cn3",   0, - h, - 1 );
+		setPoint( "cn4",   0,   h, - 1 );
+
+		geometry.verticesNeedUpdate = true;
+
+	};
+
+}();
+
+// File:src/extras/helpers/DirectionalLightHelper.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ * @author mrdoob / http://mrdoob.com/
+ * @author WestLangley / http://github.com/WestLangley
+ */
+
+THREE.DirectionalLightHelper = function ( light, size ) {
+
+	THREE.Object3D.call( this );
+
+	this.light = light;
+	this.light.updateMatrixWorld();
+
+	this.matrix = light.matrixWorld;
+	this.matrixAutoUpdate = false;
+
+	size = size || 1;
+
+	var geometry = new THREE.Geometry();
+	geometry.vertices.push(
+		new THREE.Vector3( - size,   size, 0 ),
+		new THREE.Vector3(   size,   size, 0 ),
+		new THREE.Vector3(   size, - size, 0 ),
+		new THREE.Vector3( - size, - size, 0 ),
+		new THREE.Vector3( - size,   size, 0 )
+	);
+
+	var material = new THREE.LineBasicMaterial( { fog: false } );
+	material.color.copy( this.light.color ).multiplyScalar( this.light.intensity );
+
+	this.lightPlane = new THREE.Line( geometry, material );
+	this.add( this.lightPlane );
+
+	geometry = new THREE.Geometry();
+	geometry.vertices.push(
+		new THREE.Vector3(),
+		new THREE.Vector3()
+	);
+
+	material = new THREE.LineBasicMaterial( { fog: false } );
+	material.color.copy( this.light.color ).multiplyScalar( this.light.intensity );
+
+	this.targetLine = new THREE.Line( geometry, material );
+	this.add( this.targetLine );
+
+	this.update();
+
+};
+
+THREE.DirectionalLightHelper.prototype = Object.create( THREE.Object3D.prototype );
+THREE.DirectionalLightHelper.prototype.constructor = THREE.DirectionalLightHelper;
+
+THREE.DirectionalLightHelper.prototype.dispose = function () {
+
+	this.lightPlane.geometry.dispose();
+	this.lightPlane.material.dispose();
+	this.targetLine.geometry.dispose();
+	this.targetLine.material.dispose();
+
+};
+
+THREE.DirectionalLightHelper.prototype.update = function () {
+
+	var v1 = new THREE.Vector3();
+	var v2 = new THREE.Vector3();
+	var v3 = new THREE.Vector3();
+
+	return function () {
+
+		v1.setFromMatrixPosition( this.light.matrixWorld );
+		v2.setFromMatrixPosition( this.light.target.matrixWorld );
+		v3.subVectors( v2, v1 );
+
+		this.lightPlane.lookAt( v3 );
+		this.lightPlane.material.color.copy( this.light.color ).multiplyScalar( this.light.intensity );
+
+		this.targetLine.geometry.vertices[ 1 ].copy( v3 );
+		this.targetLine.geometry.verticesNeedUpdate = true;
+		this.targetLine.material.color.copy( this.lightPlane.material.color );
+
+	};
+
+}();
+
+// File:src/extras/helpers/EdgesHelper.js
+
+/**
+ * @author WestLangley / http://github.com/WestLangley
+ * @param object THREE.Mesh whose geometry will be used
+ * @param hex line color
+ * @param thresholdAngle the minimum angle (in degrees),
+ * between the face normals of adjacent faces,
+ * that is required to render an edge. A value of 10 means
+ * an edge is only rendered if the angle is at least 10 degrees.
+ */
+
+THREE.EdgesHelper = function ( object, hex, thresholdAngle ) {
+
+	var color = ( hex !== undefined ) ? hex : 0xffffff;
+
+	THREE.LineSegments.call( this, new THREE.EdgesGeometry( object.geometry, thresholdAngle ), new THREE.LineBasicMaterial( { color: color } ) );
+
+	this.matrix = object.matrixWorld;
+	this.matrixAutoUpdate = false;
+
+};
+
+THREE.EdgesHelper.prototype = Object.create( THREE.LineSegments.prototype );
+THREE.EdgesHelper.prototype.constructor = THREE.EdgesHelper;
+
+// File:src/extras/helpers/FaceNormalsHelper.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author WestLangley / http://github.com/WestLangley
+*/
+
+THREE.FaceNormalsHelper = function ( object, size, hex, linewidth ) {
+
+	// FaceNormalsHelper only supports THREE.Geometry
+
+	this.object = object;
+
+	this.size = ( size !== undefined ) ? size : 1;
+
+	var color = ( hex !== undefined ) ? hex : 0xffff00;
+
+	var width = ( linewidth !== undefined ) ? linewidth : 1;
+
+	//
+
+	var nNormals = 0;
+
+	var objGeometry = this.object.geometry;
+
+	if ( objGeometry instanceof THREE.Geometry ) {
+
+		nNormals = objGeometry.faces.length;
+
+	} else {
+
+		console.warn( 'THREE.FaceNormalsHelper: only THREE.Geometry is supported. Use THREE.VertexNormalsHelper, instead.' );
+
+	}
+
+	//
+
+	var geometry = new THREE.BufferGeometry();
+
+	var positions = new THREE.Float32Attribute( nNormals * 2 * 3, 3 );
+
+	geometry.addAttribute( 'position', positions );
+
+	THREE.LineSegments.call( this, geometry, new THREE.LineBasicMaterial( { color: color, linewidth: width } ) );
+
+	//
+
+	this.matrixAutoUpdate = false;
+	this.update();
+
+};
+
+THREE.FaceNormalsHelper.prototype = Object.create( THREE.LineSegments.prototype );
+THREE.FaceNormalsHelper.prototype.constructor = THREE.FaceNormalsHelper;
+
+THREE.FaceNormalsHelper.prototype.update = ( function () {
+
+	var v1 = new THREE.Vector3();
+	var v2 = new THREE.Vector3();
+	var normalMatrix = new THREE.Matrix3();
+
+	return function update() {
+
+		this.object.updateMatrixWorld( true );
+
+		normalMatrix.getNormalMatrix( this.object.matrixWorld );
+
+		var matrixWorld = this.object.matrixWorld;
+
+		var position = this.geometry.attributes.position;
+
+		//
+
+		var objGeometry = this.object.geometry;
+
+		var vertices = objGeometry.vertices;
+
+		var faces = objGeometry.faces;
+
+		var idx = 0;
+
+		for ( var i = 0, l = faces.length; i < l; i ++ ) {
+
+			var face = faces[ i ];
+
+			var normal = face.normal;
+
+			v1.copy( vertices[ face.a ] )
+				.add( vertices[ face.b ] )
+				.add( vertices[ face.c ] )
+				.divideScalar( 3 )
+				.applyMatrix4( matrixWorld );
+
+			v2.copy( normal ).applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 );
+
+			position.setXYZ( idx, v1.x, v1.y, v1.z );
+
+			idx = idx + 1;
+
+			position.setXYZ( idx, v2.x, v2.y, v2.z );
+
+			idx = idx + 1;
+
+		}
+
+		position.needsUpdate = true;
+
+		return this;
+
+	}
+
+}() );
+
+// File:src/extras/helpers/GridHelper.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.GridHelper = function ( size, step ) {
+
+	var geometry = new THREE.Geometry();
+	var material = new THREE.LineBasicMaterial( { vertexColors: THREE.VertexColors } );
+
+	this.color1 = new THREE.Color( 0x444444 );
+	this.color2 = new THREE.Color( 0x888888 );
+
+	for ( var i = - size; i <= size; i += step ) {
+
+		geometry.vertices.push(
+			new THREE.Vector3( - size, 0, i ), new THREE.Vector3( size, 0, i ),
+			new THREE.Vector3( i, 0, - size ), new THREE.Vector3( i, 0, size )
+		);
+
+		var color = i === 0 ? this.color1 : this.color2;
+
+		geometry.colors.push( color, color, color, color );
+
+	}
+
+	THREE.LineSegments.call( this, geometry, material );
+
+};
+
+THREE.GridHelper.prototype = Object.create( THREE.LineSegments.prototype );
+THREE.GridHelper.prototype.constructor = THREE.GridHelper;
+
+THREE.GridHelper.prototype.setColors = function( colorCenterLine, colorGrid ) {
+
+	this.color1.set( colorCenterLine );
+	this.color2.set( colorGrid );
+
+	this.geometry.colorsNeedUpdate = true;
+
+};
+
+// File:src/extras/helpers/HemisphereLightHelper.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.HemisphereLightHelper = function ( light, sphereSize ) {
+
+	THREE.Object3D.call( this );
+
+	this.light = light;
+	this.light.updateMatrixWorld();
+
+	this.matrix = light.matrixWorld;
+	this.matrixAutoUpdate = false;
+
+	this.colors = [ new THREE.Color(), new THREE.Color() ];
+
+	var geometry = new THREE.SphereGeometry( sphereSize, 4, 2 );
+	geometry.rotateX( - Math.PI / 2 );
+
+	for ( var i = 0, il = 8; i < il; i ++ ) {
+
+		geometry.faces[ i ].color = this.colors[ i < 4 ? 0 : 1 ];
+
+	}
+
+	var material = new THREE.MeshBasicMaterial( { vertexColors: THREE.FaceColors, wireframe: true } );
+
+	this.lightSphere = new THREE.Mesh( geometry, material );
+	this.add( this.lightSphere );
+
+	this.update();
+
+};
+
+THREE.HemisphereLightHelper.prototype = Object.create( THREE.Object3D.prototype );
+THREE.HemisphereLightHelper.prototype.constructor = THREE.HemisphereLightHelper;
+
+THREE.HemisphereLightHelper.prototype.dispose = function () {
+
+	this.lightSphere.geometry.dispose();
+	this.lightSphere.material.dispose();
+
+};
+
+THREE.HemisphereLightHelper.prototype.update = function () {
+
+	var vector = new THREE.Vector3();
+
+	return function () {
+
+		this.colors[ 0 ].copy( this.light.color ).multiplyScalar( this.light.intensity );
+		this.colors[ 1 ].copy( this.light.groundColor ).multiplyScalar( this.light.intensity );
+
+		this.lightSphere.lookAt( vector.setFromMatrixPosition( this.light.matrixWorld ).negate() );
+		this.lightSphere.geometry.colorsNeedUpdate = true;
+
+	}
+
+}();
+
+// File:src/extras/helpers/PointLightHelper.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.PointLightHelper = function ( light, sphereSize ) {
+
+	this.light = light;
+	this.light.updateMatrixWorld();
+
+	var geometry = new THREE.SphereGeometry( sphereSize, 4, 2 );
+	var material = new THREE.MeshBasicMaterial( { wireframe: true, fog: false } );
+	material.color.copy( this.light.color ).multiplyScalar( this.light.intensity );
+
+	THREE.Mesh.call( this, geometry, material );
+
+	this.matrix = this.light.matrixWorld;
+	this.matrixAutoUpdate = false;
+
+	/*
+	var distanceGeometry = new THREE.IcosahedronGeometry( 1, 2 );
+	var distanceMaterial = new THREE.MeshBasicMaterial( { color: hexColor, fog: false, wireframe: true, opacity: 0.1, transparent: true } );
+
+	this.lightSphere = new THREE.Mesh( bulbGeometry, bulbMaterial );
+	this.lightDistance = new THREE.Mesh( distanceGeometry, distanceMaterial );
+
+	var d = light.distance;
+
+	if ( d === 0.0 ) {
+
+		this.lightDistance.visible = false;
+
+	} else {
+
+		this.lightDistance.scale.set( d, d, d );
+
+	}
+
+	this.add( this.lightDistance );
+	*/
+
+};
+
+THREE.PointLightHelper.prototype = Object.create( THREE.Mesh.prototype );
+THREE.PointLightHelper.prototype.constructor = THREE.PointLightHelper;
+
+THREE.PointLightHelper.prototype.dispose = function () {
+
+	this.geometry.dispose();
+	this.material.dispose();
+
+};
+
+THREE.PointLightHelper.prototype.update = function () {
+
+	this.material.color.copy( this.light.color ).multiplyScalar( this.light.intensity );
+
+	/*
+	var d = this.light.distance;
+
+	if ( d === 0.0 ) {
+
+		this.lightDistance.visible = false;
+
+	} else {
+
+		this.lightDistance.visible = true;
+		this.lightDistance.scale.set( d, d, d );
+
+	}
+	*/
+
+};
+
+// File:src/extras/helpers/SkeletonHelper.js
+
+/**
+ * @author Sean Griffin / http://twitter.com/sgrif
+ * @author Michael Guerrero / http://realitymeltdown.com
+ * @author mrdoob / http://mrdoob.com/
+ * @author ikerr / http://verold.com
+ */
+
+THREE.SkeletonHelper = function ( object ) {
+
+	this.bones = this.getBoneList( object );
+
+	var geometry = new THREE.Geometry();
+
+	for ( var i = 0; i < this.bones.length; i ++ ) {
+
+		var bone = this.bones[ i ];
+
+		if ( bone.parent instanceof THREE.Bone ) {
+
+			geometry.vertices.push( new THREE.Vector3() );
+			geometry.vertices.push( new THREE.Vector3() );
+			geometry.colors.push( new THREE.Color( 0, 0, 1 ) );
+			geometry.colors.push( new THREE.Color( 0, 1, 0 ) );
+
+		}
+
+	}
+
+	geometry.dynamic = true;
+
+	var material = new THREE.LineBasicMaterial( { vertexColors: THREE.VertexColors, depthTest: false, depthWrite: false, transparent: true } );
+
+	THREE.LineSegments.call( this, geometry, material );
+
+	this.root = object;
+
+	this.matrix = object.matrixWorld;
+	this.matrixAutoUpdate = false;
+
+	this.update();
+
+};
+
+
+THREE.SkeletonHelper.prototype = Object.create( THREE.LineSegments.prototype );
+THREE.SkeletonHelper.prototype.constructor = THREE.SkeletonHelper;
+
+THREE.SkeletonHelper.prototype.getBoneList = function( object ) {
+
+	var boneList = [];
+
+	if ( object instanceof THREE.Bone ) {
+
+		boneList.push( object );
+
+	}
+
+	for ( var i = 0; i < object.children.length; i ++ ) {
+
+		boneList.push.apply( boneList, this.getBoneList( object.children[ i ] ) );
+
+	}
+
+	return boneList;
+
+};
+
+THREE.SkeletonHelper.prototype.update = function () {
+
+	var geometry = this.geometry;
+
+	var matrixWorldInv = new THREE.Matrix4().getInverse( this.root.matrixWorld );
+
+	var boneMatrix = new THREE.Matrix4();
+
+	var j = 0;
+
+	for ( var i = 0; i < this.bones.length; i ++ ) {
+
+		var bone = this.bones[ i ];
+
+		if ( bone.parent instanceof THREE.Bone ) {
+
+			boneMatrix.multiplyMatrices( matrixWorldInv, bone.matrixWorld );
+			geometry.vertices[ j ].setFromMatrixPosition( boneMatrix );
+
+			boneMatrix.multiplyMatrices( matrixWorldInv, bone.parent.matrixWorld );
+			geometry.vertices[ j + 1 ].setFromMatrixPosition( boneMatrix );
+
+			j += 2;
+
+		}
+
+	}
+
+	geometry.verticesNeedUpdate = true;
+
+	geometry.computeBoundingSphere();
+
+};
+
+// File:src/extras/helpers/SpotLightHelper.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ * @author mrdoob / http://mrdoob.com/
+ * @author WestLangley / http://github.com/WestLangley
+*/
+
+THREE.SpotLightHelper = function ( light ) {
+
+	THREE.Object3D.call( this );
+
+	this.light = light;
+	this.light.updateMatrixWorld();
+
+	this.matrix = light.matrixWorld;
+	this.matrixAutoUpdate = false;
+
+	var geometry = new THREE.BufferGeometry();
+
+	var positions = [
+		0, 0, 0,   0,   0,   1,
+		0, 0, 0,   1,   0,   1,
+		0, 0, 0, - 1,   0,   1,
+		0, 0, 0,   0,   1,   1,
+		0, 0, 0,   0, - 1,   1
+	];
+
+	for ( var i = 0, j = 1, l = 32; i < l; i ++, j ++ ) {
+
+		var p1 = ( i / l ) * Math.PI * 2;
+		var p2 = ( j / l ) * Math.PI * 2;
+
+		positions.push(
+			Math.cos( p1 ), Math.sin( p1 ), 1,
+			Math.cos( p2 ), Math.sin( p2 ), 1
+		);
+
+	}
+
+	geometry.addAttribute( 'position', new THREE.Float32Attribute( positions, 3 ) );
+
+	var material = new THREE.LineBasicMaterial( { fog: false } );
+
+	this.cone = new THREE.LineSegments( geometry, material );
+	this.add( this.cone );
+
+	this.update();
+
+};
+
+THREE.SpotLightHelper.prototype = Object.create( THREE.Object3D.prototype );
+THREE.SpotLightHelper.prototype.constructor = THREE.SpotLightHelper;
+
+THREE.SpotLightHelper.prototype.dispose = function () {
+
+	this.cone.geometry.dispose();
+	this.cone.material.dispose();
+
+};
+
+THREE.SpotLightHelper.prototype.update = function () {
+
+	var vector = new THREE.Vector3();
+	var vector2 = new THREE.Vector3();
+
+	return function () {
+
+		var coneLength = this.light.distance ? this.light.distance : 1000;
+		var coneWidth = coneLength * Math.tan( this.light.angle );
+
+		this.cone.scale.set( coneWidth, coneWidth, coneLength );
+
+		vector.setFromMatrixPosition( this.light.matrixWorld );
+		vector2.setFromMatrixPosition( this.light.target.matrixWorld );
+
+		this.cone.lookAt( vector2.sub( vector ) );
+
+		this.cone.material.color.copy( this.light.color ).multiplyScalar( this.light.intensity );
+
+	};
+
+}();
+
+// File:src/extras/helpers/VertexNormalsHelper.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ * @author WestLangley / http://github.com/WestLangley
+*/
+
+THREE.VertexNormalsHelper = function ( object, size, hex, linewidth ) {
+
+	this.object = object;
+
+	this.size = ( size !== undefined ) ? size : 1;
+
+	var color = ( hex !== undefined ) ? hex : 0xff0000;
+
+	var width = ( linewidth !== undefined ) ? linewidth : 1;
+
+	//
+
+	var nNormals = 0;
+
+	var objGeometry = this.object.geometry;
+
+	if ( objGeometry instanceof THREE.Geometry ) {
+
+		nNormals = objGeometry.faces.length * 3;
+
+	} else if ( objGeometry instanceof THREE.BufferGeometry ) {
+
+		nNormals = objGeometry.attributes.normal.count
+
+	}
+
+	//
+
+	var geometry = new THREE.BufferGeometry();
+
+	var positions = new THREE.Float32Attribute( nNormals * 2 * 3, 3 );
+
+	geometry.addAttribute( 'position', positions );
+
+	THREE.LineSegments.call( this, geometry, new THREE.LineBasicMaterial( { color: color, linewidth: width } ) );
+
+	//
+
+	this.matrixAutoUpdate = false;
+
+	this.update();
+
+};
+
+THREE.VertexNormalsHelper.prototype = Object.create( THREE.LineSegments.prototype );
+THREE.VertexNormalsHelper.prototype.constructor = THREE.VertexNormalsHelper;
+
+THREE.VertexNormalsHelper.prototype.update = ( function () {
+
+	var v1 = new THREE.Vector3();
+	var v2 = new THREE.Vector3();
+	var normalMatrix = new THREE.Matrix3();
+
+	return function update() {
+
+		var keys = [ 'a', 'b', 'c' ];
+
+		this.object.updateMatrixWorld( true );
+
+		normalMatrix.getNormalMatrix( this.object.matrixWorld );
+
+		var matrixWorld = this.object.matrixWorld;
+
+		var position = this.geometry.attributes.position;
+
+		//
+
+		var objGeometry = this.object.geometry;
+
+		if ( objGeometry instanceof THREE.Geometry ) {
+
+			var vertices = objGeometry.vertices;
+
+			var faces = objGeometry.faces;
+
+			var idx = 0;
+
+			for ( var i = 0, l = faces.length; i < l; i ++ ) {
+
+				var face = faces[ i ];
+
+				for ( var j = 0, jl = face.vertexNormals.length; j < jl; j ++ ) {
+
+					var vertex = vertices[ face[ keys[ j ] ] ];
+
+					var normal = face.vertexNormals[ j ];
+
+					v1.copy( vertex ).applyMatrix4( matrixWorld );
+
+					v2.copy( normal ).applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 );
+
+					position.setXYZ( idx, v1.x, v1.y, v1.z );
+
+					idx = idx + 1;
+
+					position.setXYZ( idx, v2.x, v2.y, v2.z );
+
+					idx = idx + 1;
+
+				}
+
+			}
+
+		} else if ( objGeometry instanceof THREE.BufferGeometry ) {
+
+			var objPos = objGeometry.attributes.position;
+
+			var objNorm = objGeometry.attributes.normal;
+
+			var idx = 0;
+
+			// for simplicity, ignore index and drawcalls, and render every normal
+
+			for ( var j = 0, jl = objPos.count; j < jl; j ++ ) {
+
+				v1.set( objPos.getX( j ), objPos.getY( j ), objPos.getZ( j ) ).applyMatrix4( matrixWorld );
+
+				v2.set( objNorm.getX( j ), objNorm.getY( j ), objNorm.getZ( j ) );
+
+				v2.applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 );
+
+				position.setXYZ( idx, v1.x, v1.y, v1.z );
+
+				idx = idx + 1;
+
+				position.setXYZ( idx, v2.x, v2.y, v2.z );
+
+				idx = idx + 1;
+
+			}
+
+		}
+
+		position.needsUpdate = true;
+
+		return this;
+
+	}
+
+}() );
+
+// File:src/extras/helpers/WireframeHelper.js
+
+/**
+ * @author mrdoob / http://mrdoob.com/
+ */
+
+THREE.WireframeHelper = function ( object, hex ) {
+
+	var color = ( hex !== undefined ) ? hex : 0xffffff;
+
+	THREE.LineSegments.call( this, new THREE.WireframeGeometry( object.geometry ), new THREE.LineBasicMaterial( { color: color } ) );
+
+	this.matrix = object.matrixWorld;
+	this.matrixAutoUpdate = false;
+
+};
+
+THREE.WireframeHelper.prototype = Object.create( THREE.LineSegments.prototype );
+THREE.WireframeHelper.prototype.constructor = THREE.WireframeHelper;
+
+// File:src/extras/objects/ImmediateRenderObject.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.ImmediateRenderObject = function ( material ) {
+
+	THREE.Object3D.call( this );
+
+	this.material = material;
+	this.render = function ( renderCallback ) {};
+
+};
+
+THREE.ImmediateRenderObject.prototype = Object.create( THREE.Object3D.prototype );
+THREE.ImmediateRenderObject.prototype.constructor = THREE.ImmediateRenderObject;
+
+// File:src/extras/objects/MorphBlendMesh.js
+
+/**
+ * @author alteredq / http://alteredqualia.com/
+ */
+
+THREE.MorphBlendMesh = function( geometry, material ) {
+
+	THREE.Mesh.call( this, geometry, material );
+
+	this.animationsMap = {};
+	this.animationsList = [];
+
+	// prepare default animation
+	// (all frames played together in 1 second)
+
+	var numFrames = this.geometry.morphTargets.length;
+
+	var name = "__default";
+
+	var startFrame = 0;
+	var endFrame = numFrames - 1;
+
+	var fps = numFrames / 1;
+
+	this.createAnimation( name, startFrame, endFrame, fps );
+	this.setAnimationWeight( name, 1 );
+
+};
+
+THREE.MorphBlendMesh.prototype = Object.create( THREE.Mesh.prototype );
+THREE.MorphBlendMesh.prototype.constructor = THREE.MorphBlendMesh;
+
+THREE.MorphBlendMesh.prototype.createAnimation = function ( name, start, end, fps ) {
+
+	var animation = {
+
+		start: start,
+		end: end,
+
+		length: end - start + 1,
+
+		fps: fps,
+		duration: ( end - start ) / fps,
+
+		lastFrame: 0,
+		currentFrame: 0,
+
+		active: false,
+
+		time: 0,
+		direction: 1,
+		weight: 1,
+
+		directionBackwards: false,
+		mirroredLoop: false
+
+	};
+
+	this.animationsMap[ name ] = animation;
+	this.animationsList.push( animation );
+
+};
+
+THREE.MorphBlendMesh.prototype.autoCreateAnimations = function ( fps ) {
+
+	var pattern = /([a-z]+)_?(\d+)/i;
+
+	var firstAnimation, frameRanges = {};
+
+	var geometry = this.geometry;
+
+	for ( var i = 0, il = geometry.morphTargets.length; i < il; i ++ ) {
+
+		var morph = geometry.morphTargets[ i ];
+		var chunks = morph.name.match( pattern );
+
+		if ( chunks && chunks.length > 1 ) {
+
+			var name = chunks[ 1 ];
+
+			if ( ! frameRanges[ name ] ) frameRanges[ name ] = { start: Infinity, end: - Infinity };
+
+			var range = frameRanges[ name ];
+
+			if ( i < range.start ) range.start = i;
+			if ( i > range.end ) range.end = i;
+
+			if ( ! firstAnimation ) firstAnimation = name;
+
+		}
+
+	}
+
+	for ( var name in frameRanges ) {
+
+		var range = frameRanges[ name ];
+		this.createAnimation( name, range.start, range.end, fps );
+
+	}
+
+	this.firstAnimation = firstAnimation;
+
+};
+
+THREE.MorphBlendMesh.prototype.setAnimationDirectionForward = function ( name ) {
+
+	var animation = this.animationsMap[ name ];
+
+	if ( animation ) {
+
+		animation.direction = 1;
+		animation.directionBackwards = false;
+
+	}
+
+};
+
+THREE.MorphBlendMesh.prototype.setAnimationDirectionBackward = function ( name ) {
+
+	var animation = this.animationsMap[ name ];
+
+	if ( animation ) {
+
+		animation.direction = - 1;
+		animation.directionBackwards = true;
+
+	}
+
+};
+
+THREE.MorphBlendMesh.prototype.setAnimationFPS = function ( name, fps ) {
+
+	var animation = this.animationsMap[ name ];
+
+	if ( animation ) {
+
+		animation.fps = fps;
+		animation.duration = ( animation.end - animation.start ) / animation.fps;
+
+	}
+
+};
+
+THREE.MorphBlendMesh.prototype.setAnimationDuration = function ( name, duration ) {
+
+	var animation = this.animationsMap[ name ];
+
+	if ( animation ) {
+
+		animation.duration = duration;
+		animation.fps = ( animation.end - animation.start ) / animation.duration;
+
+	}
+
+};
+
+THREE.MorphBlendMesh.prototype.setAnimationWeight = function ( name, weight ) {
+
+	var animation = this.animationsMap[ name ];
+
+	if ( animation ) {
+
+		animation.weight = weight;
+
+	}
+
+};
+
+THREE.MorphBlendMesh.prototype.setAnimationTime = function ( name, time ) {
+
+	var animation = this.animationsMap[ name ];
+
+	if ( animation ) {
+
+		animation.time = time;
+
+	}
+
+};
+
+THREE.MorphBlendMesh.prototype.getAnimationTime = function ( name ) {
+
+	var time = 0;
+
+	var animation = this.animationsMap[ name ];
+
+	if ( animation ) {
+
+		time = animation.time;
+
+	}
+
+	return time;
+
+};
+
+THREE.MorphBlendMesh.prototype.getAnimationDuration = function ( name ) {
+
+	var duration = - 1;
+
+	var animation = this.animationsMap[ name ];
+
+	if ( animation ) {
+
+		duration = animation.duration;
+
+	}
+
+	return duration;
+
+};
+
+THREE.MorphBlendMesh.prototype.playAnimation = function ( name ) {
+
+	var animation = this.animationsMap[ name ];
+
+	if ( animation ) {
+
+		animation.time = 0;
+		animation.active = true;
+
+	} else {
+
+		console.warn( "THREE.MorphBlendMesh: animation[" + name + "] undefined in .playAnimation()" );
+
+	}
+
+};
+
+THREE.MorphBlendMesh.prototype.stopAnimation = function ( name ) {
+
+	var animation = this.animationsMap[ name ];
+
+	if ( animation ) {
+
+		animation.active = false;
+
+	}
+
+};
+
+THREE.MorphBlendMesh.prototype.update = function ( delta ) {
+
+	for ( var i = 0, il = this.animationsList.length; i < il; i ++ ) {
+
+		var animation = this.animationsList[ i ];
+
+		if ( ! animation.active ) continue;
+
+		var frameTime = animation.duration / animation.length;
+
+		animation.time += animation.direction * delta;
+
+		if ( animation.mirroredLoop ) {
+
+			if ( animation.time > animation.duration || animation.time < 0 ) {
+
+				animation.direction *= - 1;
+
+				if ( animation.time > animation.duration ) {
+
+					animation.time = animation.duration;
+					animation.directionBackwards = true;
+
+				}
+
+				if ( animation.time < 0 ) {
+
+					animation.time = 0;
+					animation.directionBackwards = false;
+
+				}
+
+			}
+
+		} else {
+
+			animation.time = animation.time % animation.duration;
+
+			if ( animation.time < 0 ) animation.time += animation.duration;
+
+		}
+
+		var keyframe = animation.start + THREE.Math.clamp( Math.floor( animation.time / frameTime ), 0, animation.length - 1 );
+		var weight = animation.weight;
+
+		if ( keyframe !== animation.currentFrame ) {
+
+			this.morphTargetInfluences[ animation.lastFrame ] = 0;
+			this.morphTargetInfluences[ animation.currentFrame ] = 1 * weight;
+
+			this.morphTargetInfluences[ keyframe ] = 0;
+
+			animation.lastFrame = animation.currentFrame;
+			animation.currentFrame = keyframe;
+
+		}
+
+		var mix = ( animation.time % frameTime ) / frameTime;
+
+		if ( animation.directionBackwards ) mix = 1 - mix;
+
+		if ( animation.currentFrame !== animation.lastFrame ) {
+
+			this.morphTargetInfluences[ animation.currentFrame ] = mix * weight;
+			this.morphTargetInfluences[ animation.lastFrame ] = ( 1 - mix ) * weight;
+
+		} else {
+
+			this.morphTargetInfluences[ animation.currentFrame ] = weight;
+
+		}
+
+	}
+
+};
+

From e01051370ba714b86242f8fc625cf79865ec38c3 Mon Sep 17 00:00:00 2001
From: amelie <amelie.heliou@polytechnique.edu>
Date: Thu, 12 May 2016 09:22:42 +0200
Subject: [PATCH 03/63] first drawing with three.js

---
 html/2by2.html | 111 +++++++++++++++++++++++++++----------------------
 1 file changed, 61 insertions(+), 50 deletions(-)

diff --git a/html/2by2.html b/html/2by2.html
index aca6087..dcc16e7 100644
--- a/html/2by2.html
+++ b/html/2by2.html
@@ -12,6 +12,66 @@
     </head>
 
 <script>
+    function bottom() {
+        container = document.createElement( 'div' );
+        document.body.appendChild( container );
+        scene = new THREE.Scene();
+        camera = new THREE.PerspectiveCamera( 60, 1, 1, 10000 );
+        camera.position.z = window.innerWidth;
+        renderer = new THREE.WebGLRenderer();
+        //renderer.setPixelRatio( window.devicePixelRatio );
+        renderer.setSize( window.innerWidth/2, window.innerWidth/2 );
+        renderer.setClearColor( 0xffffff, 1);
+        container.appendChild( renderer.domElement );
+        var material = new THREE.LineBasicMaterial({color: 0x000000});
+        var geometry = new THREE.Geometry();
+        geometry.vertices.push(new THREE.Vector3( -window.innerWidth/4, window.innerWidth/4, 0 ),
+                               new THREE.Vector3(-window.innerWidth/4, -window.innerWidth/4, 0 ),
+                               new THREE.Vector3( window.innerWidth/4, -window.innerWidth/4, 0 ),
+                               new THREE.Vector3( window.innerWidth/4, window.innerWidth/4, 0 )
+                               );
+        var line = new THREE.Line( geometry, material );
+        scene.add( line );
+                               
+                               var P11_1=parseInt($("[name='P11_1']").val(),10);
+                               var P12_1=parseInt($("[name='P12_1']").val(),10);
+                               var maxP1_1;
+                               var maxP1_2;
+                               var minP1_1;
+                               var minP1_2;
+                               var P21_1=parseInt($("[name='P21_1']").val(),10);
+                               var P22_1=parseInt($("[name='P22_1']").val(),10);
+                               if( P11_1>P21_1){
+                                   maxP1_1=P11_1;
+                                   minP1_1=P21_1;
+                               }else{
+                                   maxP1_1=P21_1;
+                                   minP1_1=P11_1;
+                               }
+                               if( P12_1>P22_1){
+                                   maxP1_2=P12_1;
+                                   minP1_2=P22_1;
+                               }else{
+                                   maxP1_2=P22_1;
+                                   minP1_2=P12_1;
+                               }
+                               var geometryP1_1 = new THREE.Geometry();
+                               var materialP1_1 = new THREE.LineBasicMaterial({color: 0xff0000});
+                               geometryP1_1.vertices.push(new THREE.Vector3( -window.innerWidth/4, P11_1, 0 ),
+                                                          new THREE.Vector3(window.innerWidth/4, P12_1, 0 )
+                                                          );
+                                                          var lineP1_1 = new THREE.Line( geometryP1_1, materialP1_1 );
+                                                          scene.add( lineP1_1 );
+                                                          var geometryP1_2 = new THREE.Geometry();
+                                                          var materialP1_2 = new THREE.LineBasicMaterial({color: 0xff0000});
+                                                          geometryP1_2.vertices.push(new THREE.Vector3( -window.innerWidth/4, P21_1, 0 ),
+                                                                                     new THREE.Vector3(window.innerWidth/4, P22_1, 0 ));
+                                                                                     var lineP1_2 = new THREE.Line( geometryP1_2, materialP1_2 );
+                                                                                     scene.add( lineP1_2 );
+                                                                                     renderer.render( scene, camera);
+    };
+    
+    
 $(document).ready(function(){
     $("input").change(function(){
    // alert("test");
@@ -72,6 +132,7 @@
     ctx.fillStyle="#ff6666";
     ctx.fill();
     ctx.closePath();
+                      bottom();
     });
 });
 </script>
@@ -101,56 +162,6 @@
         <canvas id="Payoff2" width="200" height="300">
         </canvas>
         
-<script>
-$(document).ready(function(){
-    container = document.createElement( 'div' );
-    document.body.appendChild( container );
-    scene = new THREE.Scene();
-    camera = new THREE.PerspectiveCamera( 10, 1, 1, 10000 );
-    camera.position.z = 100;
-    renderer = new THREE.WebGLRenderer();
-    //renderer.setPixelRatio( window.devicePixelRatio );
-    renderer.setSize( window.innerWidth, window.innerWidth );
-    renderer.setClearColor( 0xffffff, 1);
-    container.appendChild( renderer.domElement );
-    var material = new THREE.LineBasicMaterial({color: 0x0000ff});
-    var geometry = new THREE.Geometry();
-    geometry.vertices.push(new THREE.Vector3( -window.innerWidth/2, -window.innerWidth/2, 0 ),
-                           new THREE.Vector3( 0, 0, 0 ),
-                           new THREE.Vector3( (window.innerWidth-1)/2, 0, 0 ),
-                           new THREE.Vector3( 5, 5, 0 )
-                           );
-                  
-                  
-    var P11_1=parseInt($("[name='P11_1']").val(),10);
-    var P12_1=parseInt($("[name='P12_1']").val(),10);
-    var maxP1_1;
-    var maxP1_2;
-    var minP1_1;
-    var minP1_2;
-    var P21_1=parseInt($("[name='P21_1']").val(),10);
-    var P22_1=parseInt($("[name='P22_1']").val(),10);
-    if( P11_1>P21_1){
-    maxP1_1=P11_1;
-    minP1_1=P21_1;
-    }else{
-    maxP1_1=P21_1;
-    minP1_1=P11_1;
-    }
-    if( P12_1>P22_1){
-    maxP1_2=P12_1;
-    minP1_2=P22_1;
-    }else{
-    maxP1_2=P22_1;
-    minP1_2=P12_1;
-    }
-                                                                      
-   var line = new THREE.Line( geometry, material );
-                  scene.add( line );
-   renderer.render( scene, camera);
-});
-   
-</script>
                                                                     
 </body>
 </html>

From de9b771ea140620748b80aaf9960c289ccbcb1f1 Mon Sep 17 00:00:00 2001
From: amelie <amelie.heliou@polytechnique.edu>
Date: Thu, 12 May 2016 09:38:48 +0200
Subject: [PATCH 04/63] 2 lines with three.js

---
 html/2by2.html | 82 +++++++++++++++++++++++++++-----------------------
 1 file changed, 44 insertions(+), 38 deletions(-)

diff --git a/html/2by2.html b/html/2by2.html
index dcc16e7..ddf56a5 100644
--- a/html/2by2.html
+++ b/html/2by2.html
@@ -23,7 +23,7 @@
         renderer.setSize( window.innerWidth/2, window.innerWidth/2 );
         renderer.setClearColor( 0xffffff, 1);
         container.appendChild( renderer.domElement );
-        var material = new THREE.LineBasicMaterial({color: 0x000000});
+        var material = new THREE.LineBasicMaterial({color: 0x000000, linewidth:2});
         var geometry = new THREE.Geometry();
         geometry.vertices.push(new THREE.Vector3( -window.innerWidth/4, window.innerWidth/4, 0 ),
                                new THREE.Vector3(-window.innerWidth/4, -window.innerWidth/4, 0 ),
@@ -32,43 +32,49 @@
                                );
         var line = new THREE.Line( geometry, material );
         scene.add( line );
-                               
-                               var P11_1=parseInt($("[name='P11_1']").val(),10);
-                               var P12_1=parseInt($("[name='P12_1']").val(),10);
-                               var maxP1_1;
-                               var maxP1_2;
-                               var minP1_1;
-                               var minP1_2;
-                               var P21_1=parseInt($("[name='P21_1']").val(),10);
-                               var P22_1=parseInt($("[name='P22_1']").val(),10);
-                               if( P11_1>P21_1){
-                                   maxP1_1=P11_1;
-                                   minP1_1=P21_1;
-                               }else{
-                                   maxP1_1=P21_1;
-                                   minP1_1=P11_1;
-                               }
-                               if( P12_1>P22_1){
-                                   maxP1_2=P12_1;
-                                   minP1_2=P22_1;
-                               }else{
-                                   maxP1_2=P22_1;
-                                   minP1_2=P12_1;
-                               }
-                               var geometryP1_1 = new THREE.Geometry();
-                               var materialP1_1 = new THREE.LineBasicMaterial({color: 0xff0000});
-                               geometryP1_1.vertices.push(new THREE.Vector3( -window.innerWidth/4, P11_1, 0 ),
-                                                          new THREE.Vector3(window.innerWidth/4, P12_1, 0 )
-                                                          );
-                                                          var lineP1_1 = new THREE.Line( geometryP1_1, materialP1_1 );
-                                                          scene.add( lineP1_1 );
-                                                          var geometryP1_2 = new THREE.Geometry();
-                                                          var materialP1_2 = new THREE.LineBasicMaterial({color: 0xff0000});
-                                                          geometryP1_2.vertices.push(new THREE.Vector3( -window.innerWidth/4, P21_1, 0 ),
-                                                                                     new THREE.Vector3(window.innerWidth/4, P22_1, 0 ));
-                                                                                     var lineP1_2 = new THREE.Line( geometryP1_2, materialP1_2 );
-                                                                                     scene.add( lineP1_2 );
-                                                                                     renderer.render( scene, camera);
+        var ratio=window.innerWidth/10;
+        var P11_1=$("[name='P11_1']").val()*ratio-window.innerWidth/4;
+        var P12_1=$("[name='P12_1']").val()*ratio-window.innerWidth/4;
+        var maxP1_1;
+        var maxP1_2;
+        var minP1_1;
+        var minP1_2;
+        var P21_1=$("[name='P21_1']").val()*ratio-window.innerWidth/4;
+        var P22_1=$("[name='P22_1']").val()*ratio-window.innerWidth/4;
+        if( P11_1>P21_1){
+           maxP1_1=P11_1;
+           minP1_1=P21_1;
+        }else{
+            maxP1_1=P21_1;
+            minP1_1=P11_1;
+        }
+        if( P12_1>P22_1){
+            maxP1_2=P12_1;
+            minP1_2=P22_1;
+        }else{
+            maxP1_2=P22_1;
+            minP1_2=P12_1;
+        }
+        var geometryP1_1 = new THREE.Geometry();
+        var materialP1_1 = new THREE.LineBasicMaterial({color: 0xff0000, linewidth:3});
+        geometryP1_1.vertices.push(new THREE.Vector3( -window.innerWidth/4, P11_1, 0 ),
+                                   new THREE.Vector3(window.innerWidth/4, P12_1, 0 ));
+        var lineP1_1 = new THREE.Line( geometryP1_1, materialP1_1 );
+        scene.add( lineP1_1 );
+        var geometryP1_2 = new THREE.Geometry();
+        var materialP1_2 = new THREE.LineBasicMaterial({color: 0xff0000, linewidth:3});
+        geometryP1_2.vertices.push(new THREE.Vector3( -window.innerWidth/4, P21_1, 0 ),
+        new THREE.Vector3(window.innerWidth/4, P22_1, 0 ));
+        var lineP1_2 = new THREE.Line( geometryP1_2, materialP1_2 );
+        scene.add( lineP1_2 );
+        
+        var geometryP1_sur = new THREE.Geometry();
+        var material_sur = new THREE.LineBasicMaterial({color: 0xff0000, linewidth:3});
+        geometryP1_2.vertices.push(new THREE.Vector3( -window.innerWidth/4, P21_1, 0 ),
+                                   new THREE.Vector3(window.innerWidth/4, P22_1, 0 ));
+        var lineP1_2 = new THREE.Line( geometryP1_2, materialP1_2 );
+        scene.add( lineP1_2 );
+        renderer.render( scene, camera);
     };
     
     

From deca0a2d017aab62f44d7fa6fcaa836355da70f6 Mon Sep 17 00:00:00 2001
From: amelie <amelie.heliou@polytechnique.edu>
Date: Thu, 12 May 2016 21:38:48 +0200
Subject: [PATCH 05/63] keep three.js in an other file to work mostly on JS

---
 html/2by2_three.html | 173 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 173 insertions(+)
 create mode 100644 html/2by2_three.html

diff --git a/html/2by2_three.html b/html/2by2_three.html
new file mode 100644
index 0000000..ddf56a5
--- /dev/null
+++ b/html/2by2_three.html
@@ -0,0 +1,173 @@
+<!doctype html>
+<html class="no-js" lang"">
+    <head>
+        <meta charset="utf-8">
+        <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
+        <title>2 by 2 games</title>
+        <link rel="stylesheet" href="css/2by2.css">
+        <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>
+        <script src="js/three/three.js"></script>
+        <script src="js/three/renderers/Projector.js"></script>
+		<script src="js/three/renderers/CanvasRenderer.js"></script>
+    </head>
+
+<script>
+    function bottom() {
+        container = document.createElement( 'div' );
+        document.body.appendChild( container );
+        scene = new THREE.Scene();
+        camera = new THREE.PerspectiveCamera( 60, 1, 1, 10000 );
+        camera.position.z = window.innerWidth;
+        renderer = new THREE.WebGLRenderer();
+        //renderer.setPixelRatio( window.devicePixelRatio );
+        renderer.setSize( window.innerWidth/2, window.innerWidth/2 );
+        renderer.setClearColor( 0xffffff, 1);
+        container.appendChild( renderer.domElement );
+        var material = new THREE.LineBasicMaterial({color: 0x000000, linewidth:2});
+        var geometry = new THREE.Geometry();
+        geometry.vertices.push(new THREE.Vector3( -window.innerWidth/4, window.innerWidth/4, 0 ),
+                               new THREE.Vector3(-window.innerWidth/4, -window.innerWidth/4, 0 ),
+                               new THREE.Vector3( window.innerWidth/4, -window.innerWidth/4, 0 ),
+                               new THREE.Vector3( window.innerWidth/4, window.innerWidth/4, 0 )
+                               );
+        var line = new THREE.Line( geometry, material );
+        scene.add( line );
+        var ratio=window.innerWidth/10;
+        var P11_1=$("[name='P11_1']").val()*ratio-window.innerWidth/4;
+        var P12_1=$("[name='P12_1']").val()*ratio-window.innerWidth/4;
+        var maxP1_1;
+        var maxP1_2;
+        var minP1_1;
+        var minP1_2;
+        var P21_1=$("[name='P21_1']").val()*ratio-window.innerWidth/4;
+        var P22_1=$("[name='P22_1']").val()*ratio-window.innerWidth/4;
+        if( P11_1>P21_1){
+           maxP1_1=P11_1;
+           minP1_1=P21_1;
+        }else{
+            maxP1_1=P21_1;
+            minP1_1=P11_1;
+        }
+        if( P12_1>P22_1){
+            maxP1_2=P12_1;
+            minP1_2=P22_1;
+        }else{
+            maxP1_2=P22_1;
+            minP1_2=P12_1;
+        }
+        var geometryP1_1 = new THREE.Geometry();
+        var materialP1_1 = new THREE.LineBasicMaterial({color: 0xff0000, linewidth:3});
+        geometryP1_1.vertices.push(new THREE.Vector3( -window.innerWidth/4, P11_1, 0 ),
+                                   new THREE.Vector3(window.innerWidth/4, P12_1, 0 ));
+        var lineP1_1 = new THREE.Line( geometryP1_1, materialP1_1 );
+        scene.add( lineP1_1 );
+        var geometryP1_2 = new THREE.Geometry();
+        var materialP1_2 = new THREE.LineBasicMaterial({color: 0xff0000, linewidth:3});
+        geometryP1_2.vertices.push(new THREE.Vector3( -window.innerWidth/4, P21_1, 0 ),
+        new THREE.Vector3(window.innerWidth/4, P22_1, 0 ));
+        var lineP1_2 = new THREE.Line( geometryP1_2, materialP1_2 );
+        scene.add( lineP1_2 );
+        
+        var geometryP1_sur = new THREE.Geometry();
+        var material_sur = new THREE.LineBasicMaterial({color: 0xff0000, linewidth:3});
+        geometryP1_2.vertices.push(new THREE.Vector3( -window.innerWidth/4, P21_1, 0 ),
+                                   new THREE.Vector3(window.innerWidth/4, P22_1, 0 ));
+        var lineP1_2 = new THREE.Line( geometryP1_2, materialP1_2 );
+        scene.add( lineP1_2 );
+        renderer.render( scene, camera);
+    };
+    
+    
+$(document).ready(function(){
+    $("input").change(function(){
+   // alert("test");
+    var c=document.getElementById("Payoff2");
+    var ctx = c.getContext("2d");
+    ctx.moveTo(0,0);
+    ctx.clearRect(0,0,c.width,c.height);
+    ctx.beginPath();
+    var P11_1=parseInt($("[name='P11_1']").val(),10);
+    var P12_1=parseInt($("[name='P12_1']").val(),10);
+    var maxP1_1;
+    var maxP1_2;
+    var minP1_1;
+    var minP1_2;
+    var P21_1=parseInt($("[name='P21_1']").val(),10);
+    var P22_1=parseInt($("[name='P22_1']").val(),10);
+    if( P11_1>P21_1){
+        maxP1_1=P11_1;
+        minP1_1=P21_1;
+    }else{
+       maxP1_1=P21_1;
+       minP1_1=P11_1;
+   }
+   if( P12_1>P22_1){
+        maxP1_2=P12_1;
+        minP1_2=P22_1;
+    }else{
+       maxP1_2=P22_1;
+       minP1_2=P12_1;
+   }
+   // alert(P11_1);
+    ctx.moveTo(0,c.height-P11_1*100);
+    ctx.lineTo(c.width,c.height-P12_1*100);
+    ctx.moveTo(0,c.height-P21_1*100);
+    ctx.lineTo(c.width,c.height-P22_1*100);
+    ctx.lineWidth = 2;
+    ctx.strokeStyle = '#ff0000';
+    ctx.stroke();
+    ctx.closePath();
+    ctx.beginPath();
+    if((maxP1_1==P11_1 && maxP1_2==P12_1)||(maxP1_1==P21_1 && maxP1_2==P22_1)){
+        ctx.moveTo(0,0);
+        ctx.lineTo(0,c.height-maxP1_2*100);
+        ctx.lineTo(c.width,c.height-maxP1_1*100);
+        ctx.lineTo(c.width,0);
+        ctx.lineTo(0,0);
+    }
+    else{
+        var middle_x=(P21_1-P11_1)/(Number(P12_1)- Number(P22_1) + Number(P21_1) - Number(P11_1));
+        var middle_y=Number((P12_1-P11_1)*middle_x)+Number(P11_1);
+        ctx.moveTo(0,0);
+        ctx.lineTo(0,c.height-maxP1_1*100);
+        ctx.lineTo(middle_x*c.width,c.height-middle_y*100);
+        ctx.lineTo(c.width,c.height-maxP1_2*100);
+        ctx.lineTo(c.width,0);
+        ctx.lineTo(0,0);
+    }
+    ctx.fillStyle="#ff6666";
+    ctx.fill();
+    ctx.closePath();
+                      bottom();
+    });
+});
+</script>
+
+    <body>
+        <!--[if lt IE 8]>
+            <p class="browserupgrade">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
+        <![endif]-->
+
+        <table border="1">
+  <tr>
+    <th><label class="player1">Player I</label> \ <label class="player2">Player II</label></th>
+    <th><label><input class="player2" type="text" name=2s1 value="S1"/> </label></th>
+    <th><label><input class="player2" type="text" name=2s2 value="S2"/> </label></th>
+  </tr>
+  <tr>
+      <th><label><input class="player1" type="text" name=1s1 value="S1"/> </label></th>
+    <td><input class="player1" type="text" name="P11_1" value=0>\<input class="player2" type="text" name=P11_2  value=0></td>
+    <td><input class="player1" type="text" name=P12_1  value=0>\<input class="player2" type="text" name=P12_2 value=0></td>
+  </tr>
+  <tr>
+  <th><label><input class="player1" type="text" name=1s2 value="S2"/> </label></th>
+    <td><input class="player1" type="text" name=P21_1  value=0>\<input class="player2" type="text" name=P21_2  value=0></td>
+    <td><input class="player1" type="text" name=P22_1 value=0>\<input class="player2" type="text" name=P22_2  value=0></td>
+  </tr>
+</table>
+        <canvas id="Payoff2" width="200" height="300">
+        </canvas>
+        
+                                                                    
+</body>
+</html>

From ccf5f26bbc9885c84b61c99ade44c3025a591528 Mon Sep 17 00:00:00 2001
From: amelie <amelie.heliou@polytechnique.edu>
Date: Thu, 12 May 2016 23:54:47 +0200
Subject: [PATCH 06/63] 2by2 only with JS. Still have to make points draggable

---
 html/2by2.html | 364 ++++++++++++++++++++++++++++++-------------------
 1 file changed, 225 insertions(+), 139 deletions(-)

diff --git a/html/2by2.html b/html/2by2.html
index ddf56a5..cb23dc0 100644
--- a/html/2by2.html
+++ b/html/2by2.html
@@ -5,167 +5,253 @@
         <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
         <title>2 by 2 games</title>
         <link rel="stylesheet" href="css/2by2.css">
-        <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>
-        <script src="js/three/three.js"></script>
-        <script src="js/three/renderers/Projector.js"></script>
-		<script src="js/three/renderers/CanvasRenderer.js"></script>
     </head>
+</script>
+
+<body onload="initDraws()">
+        <!--[if lt IE 8]>
+            <p class="browserupgrade">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
+        <![endif]-->
 
 <script>
-    function bottom() {
-        container = document.createElement( 'div' );
-        document.body.appendChild( container );
-        scene = new THREE.Scene();
-        camera = new THREE.PerspectiveCamera( 60, 1, 1, 10000 );
-        camera.position.z = window.innerWidth;
-        renderer = new THREE.WebGLRenderer();
-        //renderer.setPixelRatio( window.devicePixelRatio );
-        renderer.setSize( window.innerWidth/2, window.innerWidth/2 );
-        renderer.setClearColor( 0xffffff, 1);
-        container.appendChild( renderer.domElement );
-        var material = new THREE.LineBasicMaterial({color: 0x000000, linewidth:2});
-        var geometry = new THREE.Geometry();
-        geometry.vertices.push(new THREE.Vector3( -window.innerWidth/4, window.innerWidth/4, 0 ),
-                               new THREE.Vector3(-window.innerWidth/4, -window.innerWidth/4, 0 ),
-                               new THREE.Vector3( window.innerWidth/4, -window.innerWidth/4, 0 ),
-                               new THREE.Vector3( window.innerWidth/4, window.innerWidth/4, 0 )
-                               );
-        var line = new THREE.Line( geometry, material );
-        scene.add( line );
-        var ratio=window.innerWidth/10;
-        var P11_1=$("[name='P11_1']").val()*ratio-window.innerWidth/4;
-        var P12_1=$("[name='P12_1']").val()*ratio-window.innerWidth/4;
-        var maxP1_1;
-        var maxP1_2;
-        var minP1_1;
-        var minP1_2;
-        var P21_1=$("[name='P21_1']").val()*ratio-window.innerWidth/4;
-        var P22_1=$("[name='P22_1']").val()*ratio-window.innerWidth/4;
-        if( P11_1>P21_1){
-           maxP1_1=P11_1;
-           minP1_1=P21_1;
+    var canvas1,canvas2;
+    var ctx1,ctx2;
+    var payoff1_11, payoff1_12, payoff1_21, payoff1_22, payoff2_11, payoff2_12, payoff2_21, payoff2_22; //payoff vertices
+    var point1_1, point1_2, point1_3,point2_1, point2_2, point2_3; // point delimiting the best response.
+    
+    function initDraws() {
+        canvas1 = document.getElementById("Payoff1");
+        canvas2 = document.getElementById("Payoff2");
+        ctx1 = canvas1.getContext("2d");
+        ctx2 = canvas2.getContext("2d");
+        compute_firstP();
+        compute_secondP();
+        draw();
+        // mouse event
+        //canvas1.addEventListener("mousedown",doMouseDown);
+        //canvas1.addEventListener("mouseup",doMouseUp);
+        //canvas2.addEventListener("mousedown",doMouseDown);
+        //canvas2.addEventListener("mouseup",doMouseUp);
+        input_user=document.getElementsByTagName("input");
+        for (var i=0; i<input_user.length;i++){
+           input_user[i].addEventListener("onchange",redraw);
+        }
+    }
+
+    function redraw(){
+        canvas1.clearRect(0,0,canvas1.width,canvas1.height);
+        canvas2.clearRect(0,0,canvas2.width,canvas2.height);
+        compute_firstP();
+        compute_secondP();
+        draw();
+    }
+
+    function compute_firstP(){
+        var P1_11=document.getElementById("P1_11").value;
+        var P1_12=document.getElementById("P1_12").value;
+        var P1_21=document.getElementById("P1_21").value;
+        var P1_22=document.getElementById("P1_22").value;
+        payoff1_11={x:0, y:canvas1.height-P1_11*100, radius:5, color:"yellow"};
+        payoff1_12={x:canvas1.width, y:canvas1.height-P1_12*100, radius:5, color:"yellow"};
+        payoff1_21={x:0, y:canvas1.height-P1_21*100, radius:5, color:"yellow"};
+        payoff1_22={x:canvas1.width, y:canvas1.height-P1_22*100, radius:5, color:"yellow"};
+        var maxP1_1, minP1_1, maxP1_2, minP1_2; // max and min off player1 payoff for strategy 1 or 2 of player2
+        if( P1_11>P1_21){
+            maxP1_1=P1_11;
+            minP1_1=P1_21;
         }else{
-            maxP1_1=P21_1;
-            minP1_1=P11_1;
+            maxP1_1=P1_21;
+            minP1_1=P1_11;
         }
-        if( P12_1>P22_1){
-            maxP1_2=P12_1;
-            minP1_2=P22_1;
+        if( P1_12>P1_22){
+            maxP1_2=P1_12;
+            minP1_2=P1_22;
         }else{
-            maxP1_2=P22_1;
-            minP1_2=P12_1;
+            maxP1_2=P1_22;
+            minP1_2=P1_12;
+        }
+        if((maxP1_1==P1_11 && maxP1_2==P1_12)||(maxP1_1==P1_21 && maxP1_2==P1_22)){
+            alert("test");
+            point1_1={x:0,y:canvas1.height-maxP1_2*100};
+            point1_2={x:canvas1.width,y:canvas1.height-maxP1_1*100};
+            point1_3={x:canvas1.width,y:canvas1.height-maxP1_1*100};}
+        else{
+            var middle_x=(P1_21-P1_11)/(Number(P1_21)- Number(P1_22) + Number(P1_12) - Number(P1_11));
+            var middle_y=Number((P1_12-P1_11)*middle_x)+Number(P1_11);
+            point1_1={x:0, y:canvas1.height-maxP1_1*100};
+            point1_2={x:middle_x * canvas1.width,y:canvas1.height-middle_y*100};
+            point1_3={x:canvas1.width,y:canvas1.height-maxP1_2*100};
         }
-        var geometryP1_1 = new THREE.Geometry();
-        var materialP1_1 = new THREE.LineBasicMaterial({color: 0xff0000, linewidth:3});
-        geometryP1_1.vertices.push(new THREE.Vector3( -window.innerWidth/4, P11_1, 0 ),
-                                   new THREE.Vector3(window.innerWidth/4, P12_1, 0 ));
-        var lineP1_1 = new THREE.Line( geometryP1_1, materialP1_1 );
-        scene.add( lineP1_1 );
-        var geometryP1_2 = new THREE.Geometry();
-        var materialP1_2 = new THREE.LineBasicMaterial({color: 0xff0000, linewidth:3});
-        geometryP1_2.vertices.push(new THREE.Vector3( -window.innerWidth/4, P21_1, 0 ),
-        new THREE.Vector3(window.innerWidth/4, P22_1, 0 ));
-        var lineP1_2 = new THREE.Line( geometryP1_2, materialP1_2 );
-        scene.add( lineP1_2 );
-        
-        var geometryP1_sur = new THREE.Geometry();
-        var material_sur = new THREE.LineBasicMaterial({color: 0xff0000, linewidth:3});
-        geometryP1_2.vertices.push(new THREE.Vector3( -window.innerWidth/4, P21_1, 0 ),
-                                   new THREE.Vector3(window.innerWidth/4, P22_1, 0 ));
-        var lineP1_2 = new THREE.Line( geometryP1_2, materialP1_2 );
-        scene.add( lineP1_2 );
-        renderer.render( scene, camera);
-    };
-    
-    
-$(document).ready(function(){
-    $("input").change(function(){
-   // alert("test");
-    var c=document.getElementById("Payoff2");
-    var ctx = c.getContext("2d");
-    ctx.moveTo(0,0);
-    ctx.clearRect(0,0,c.width,c.height);
-    ctx.beginPath();
-    var P11_1=parseInt($("[name='P11_1']").val(),10);
-    var P12_1=parseInt($("[name='P12_1']").val(),10);
-    var maxP1_1;
-    var maxP1_2;
-    var minP1_1;
-    var minP1_2;
-    var P21_1=parseInt($("[name='P21_1']").val(),10);
-    var P22_1=parseInt($("[name='P22_1']").val(),10);
-    if( P11_1>P21_1){
-        maxP1_1=P11_1;
-        minP1_1=P21_1;
-    }else{
-       maxP1_1=P21_1;
-       minP1_1=P11_1;
-   }
-   if( P12_1>P22_1){
-        maxP1_2=P12_1;
-        minP1_2=P22_1;
-    }else{
-       maxP1_2=P22_1;
-       minP1_2=P12_1;
-   }
-   // alert(P11_1);
-    ctx.moveTo(0,c.height-P11_1*100);
-    ctx.lineTo(c.width,c.height-P12_1*100);
-    ctx.moveTo(0,c.height-P21_1*100);
-    ctx.lineTo(c.width,c.height-P22_1*100);
-    ctx.lineWidth = 2;
-    ctx.strokeStyle = '#ff0000';
-    ctx.stroke();
-    ctx.closePath();
-    ctx.beginPath();
-    if((maxP1_1==P11_1 && maxP1_2==P12_1)||(maxP1_1==P21_1 && maxP1_2==P22_1)){
-        ctx.moveTo(0,0);
-        ctx.lineTo(0,c.height-maxP1_2*100);
-        ctx.lineTo(c.width,c.height-maxP1_1*100);
-        ctx.lineTo(c.width,0);
-        ctx.lineTo(0,0);
     }
-    else{
-        var middle_x=(P21_1-P11_1)/(Number(P12_1)- Number(P22_1) + Number(P21_1) - Number(P11_1));
-        var middle_y=Number((P12_1-P11_1)*middle_x)+Number(P11_1);
-        ctx.moveTo(0,0);
-        ctx.lineTo(0,c.height-maxP1_1*100);
-        ctx.lineTo(middle_x*c.width,c.height-middle_y*100);
-        ctx.lineTo(c.width,c.height-maxP1_2*100);
-        ctx.lineTo(c.width,0);
-        ctx.lineTo(0,0);
+            
+    function compute_secondP(){
+        var P2_11=document.getElementById("P2_11").value;
+        var P2_12=document.getElementById("P2_12").value;
+        var P2_21=document.getElementById("P2_21").value;
+        var P2_22=document.getElementById("P2_22").value;
+        payoff2_11={x:0, y:canvas2.height-P2_11*100, radius:5, color:"yellow"};
+        payoff2_12={x:0, y:canvas2.height-P2_12*100, radius:5, color:"yellow"};
+        payoff2_21={x:canvas2.width, y:canvas2.height-P2_21*100, radius:5, color:"yellow"};
+        payoff2_22={x:canvas2.width, y:canvas2.height-P2_22*100, radius:5, color:"yellow"};
+        var maxP2_1, minP2_1, maxP2_2, minP2_2; // max and min off player1 payoff for strategy 1 or 2 of player2
+        if( P2_11>P2_12){
+            maxP2_1=P2_11;
+            minP2_1=P2_12;
+        }else{
+            maxP2_1=P2_12;
+            minP2_1=P2_11;
+        }
+        if( P2_21>P2_22){
+            maxP2_2=P2_21;
+            minP2_2=P2_22;
+        }else{
+            maxP2_2=P2_22;
+            minP2_2=P2_21;
+        }
+        if((maxP2_1==P2_11 && maxP2_2==P2_21)||(maxP2_1==P2_12 && maxP2_2==P2_22)){
+            point2_1={x:0,y:canvas2.height-maxP2_2*100};
+            point2_2={x:canvas2.width,y:canvas2.height-maxP2_1*100};
+            point2_3={x:canvas2.width,y:canvas2.height-maxP2_1*100};}
+        else{
+            var middle_x=(P2_12-P2_11)/(Number(P2_12)- Number(P2_22) + Number(P2_21) - Number(P2_11));
+            var middle_y=Number((P2_21-P2_11)*middle_x)+Number(P2_11);
+            point2_1={x:0,y:canvas2.height-maxP2_1*100};
+            point2_2={x:middle_x * canvas2.width,y:canvas2.height-middle_y*100};
+            point2_3={x:canvas2.width,y:canvas2.height-maxP2_2*100};
+        }
+    }
+    
+    function draw(){
+        ctx1.beginPath();
+        ctx1.moveTo(0,0);
+        ctx1.lineTo(0,canvas1.height);
+        ctx1.lineTo(canvas1.width,canvas1.height);
+        ctx1.lineTo(canvas1.width,0);
+        ctx1.lineWidth = 4;
+        ctx1.strokeStyle = '#000000';
+        ctx1.stroke();
+        ctx1.closePath();
+        ctx1.beginPath();
+        ctx1.moveTo(payoff1_11.x,payoff1_11.y);
+        ctx1.lineTo(payoff1_12.x,payoff1_12.y);
+        ctx1.moveTo(payoff1_21.x,payoff1_21.y);
+        ctx1.lineTo(payoff1_22.x,payoff1_22.y);
+        ctx1.lineWidth = 4;
+        ctx1.strokeStyle = '#ff0000';
+        ctx1.stroke();
+        ctx1.closePath();
+        ctx1.beginPath();
+        ctx1.moveTo(0,0);
+        ctx1.lineTo(point1_1.x,point1_1.y);
+        ctx1.lineTo(point1_2.x,point1_2.y);
+        ctx1.lineTo(point1_3.x,point1_3.y);
+        ctx1.lineTo(canvas1.width,0);
+        ctx1.lineTo(0,0);
+        ctx1.fillStyle="#ff6666";
+        ctx1.fill();
+        ctx1.closePath();
+        ctx1.beginPath();
+        ctx1.arc(payoff1_11.x, payoff1_11.y, payoff1_11.radius, 0, 2*Math.PI);
+        ctx1.fillStyle = payoff1_11.color;
+        ctx1.fill();
+        ctx1.stroke();
+        ctx1.closePath();
+        ctx1.beginPath();
+        ctx1.arc(payoff1_12.x, payoff1_12.y, payoff1_12.radius, 0, 2*Math.PI);
+        ctx1.fillStyle = payoff1_11.color;
+        ctx1.fill();
+        ctx1.stroke();
+        ctx1.closePath();
+        ctx1.beginPath();
+        ctx1.arc(payoff1_21.x, payoff1_21.y, payoff1_21.radius, 0, 2*Math.PI);
+        ctx1.fillStyle = payoff1_11.color;
+        ctx1.fill();
+        ctx1.stroke();
+        ctx1.closePath();
+        ctx1.beginPath();
+        ctx1.arc(payoff1_22.x, payoff1_22.y, payoff1_22.radius, 0, 2*Math.PI);
+        ctx1.fillStyle = payoff1_11.color;
+        ctx1.fill();
+        ctx1.stroke();
+        ctx1.closePath();
+        
+        ctx2.beginPath();
+        ctx2.moveTo(0,0);
+        ctx2.lineTo(0,canvas2.height);
+        ctx2.lineTo(canvas2.width,canvas2.height);
+        ctx2.lineTo(canvas2.width,0);
+        ctx2.lineWidth = 4;
+        ctx2.strokeStyle = '#000000';
+        ctx2.stroke();
+        ctx2.closePath();
+        ctx2.beginPath();
+        ctx2.moveTo(payoff2_11.x,payoff2_11.y);
+        ctx2.lineTo(payoff2_21.x,payoff2_21.y);
+        ctx2.moveTo(payoff2_12.x,payoff2_12.y);
+        ctx2.lineTo(payoff2_22.x,payoff2_22.y);
+        ctx2.lineWidth = 4;
+        ctx2.strokeStyle = '#0000ff';
+        ctx2.stroke();
+        ctx2.closePath();
+        ctx2.beginPath();
+        ctx2.moveTo(0,0);
+        ctx2.lineTo(point2_1.x,point2_1.y);
+        ctx2.lineTo(point2_2.x,point2_2.y);
+        ctx2.lineTo(point2_3.x,point2_3.y);
+        ctx2.lineTo(canvas1.width,0);
+        ctx2.lineTo(0,0);
+        ctx2.fillStyle="#6666ff";
+        ctx2.fill();
+        ctx2.closePath();
+        ctx2.beginPath();
+        ctx2.arc(payoff2_11.x, payoff2_11.y, payoff2_11.radius, 0, 2*Math.PI);
+        ctx2.fillStyle = payoff2_11.color;
+        ctx2.fill();
+        ctx2.stroke();
+        ctx2.closePath();
+        ctx2.beginPath();
+        ctx2.arc(payoff2_12.x, payoff2_12.y, payoff2_12.radius, 0, 2*Math.PI);
+        ctx2.fillStyle = payoff2_11.color;
+        ctx2.fill();
+        ctx2.stroke();
+        ctx2.closePath();
+        ctx2.beginPath();
+        ctx2.arc(payoff2_21.x, payoff2_21.y, payoff2_21.radius, 0, 2*Math.PI);
+        ctx2.fillStyle = payoff2_11.color;
+        ctx2.fill();
+        ctx2.stroke();
+        ctx2.closePath();
+        ctx2.beginPath();
+        ctx2.arc(payoff2_22.x, payoff2_22.y, payoff2_22.radius, 0, 2*Math.PI);
+        ctx2.fillStyle = payoff2_11.color;
+        ctx2.fill();
+        ctx2.stroke();
+        ctx2.closePath();
     }
-    ctx.fillStyle="#ff6666";
-    ctx.fill();
-    ctx.closePath();
-                      bottom();
-    });
-});
-</script>
 
-    <body>
-        <!--[if lt IE 8]>
-            <p class="browserupgrade">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
-        <![endif]-->
+</script>
 
         <table border="1">
   <tr>
     <th><label class="player1">Player I</label> \ <label class="player2">Player II</label></th>
-    <th><label><input class="player2" type="text" name=2s1 value="S1"/> </label></th>
-    <th><label><input class="player2" type="text" name=2s2 value="S2"/> </label></th>
+    <th><label><input class="player2" type="text" id="P2S1" value="S1"/> </label></th>
+    <th><label><input class="player2" type="text" id="P2S2" value="S2"/> </label></th>
   </tr>
   <tr>
       <th><label><input class="player1" type="text" name=1s1 value="S1"/> </label></th>
-    <td><input class="player1" type="text" name="P11_1" value=0>\<input class="player2" type="text" name=P11_2  value=0></td>
-    <td><input class="player1" type="text" name=P12_1  value=0>\<input class="player2" type="text" name=P12_2 value=0></td>
+    <td><input class="player1" type="text" id="P1_11" value=0>\<input class="player2" type="text" id="P2_11"  value=0></td>
+    <td><input class="player1" type="text" id="P1_12"  value=0>\<input class="player2" type="text" id="P2_12" value=0></td>
   </tr>
   <tr>
   <th><label><input class="player1" type="text" name=1s2 value="S2"/> </label></th>
-    <td><input class="player1" type="text" name=P21_1  value=0>\<input class="player2" type="text" name=P21_2  value=0></td>
-    <td><input class="player1" type="text" name=P22_1 value=0>\<input class="player2" type="text" name=P22_2  value=0></td>
+    <td><input class="player1" type="text" id="P1_21"  value=0>\<input class="player2" type="text" id="P2_21"  value=0></td>
+    <td><input class="player1" type="text" id="P1_22" value=0>\<input class="player2" type="text" id="P2_22"  value=0></td>
   </tr>
 </table>
-        <canvas id="Payoff2" width="200" height="300">
+        <canvas id="Payoff1" width="300" height="500" style = "float:left; width: 40%;">
+        </canvas>
+        
+        <canvas id="Payoff2" width="300" height="500" style = "float:right; width: 40%;">
         </canvas>
         
                                                                     

From c49f6eecc825397fd5b74d8499beac747395af6e Mon Sep 17 00:00:00 2001
From: amelie <amelie.heliou@polytechnique.edu>
Date: Sun, 15 May 2016 10:37:18 +0200
Subject: [PATCH 07/63] 2 interactive drawings, a lot of cleanning code to do

---
 html/2by2.html    | 231 +++++++++++++++++++++++++++++++++-------------
 html/css/2by2.css |   5 +
 2 files changed, 172 insertions(+), 64 deletions(-)

diff --git a/html/2by2.html b/html/2by2.html
index cb23dc0..6ed51a8 100644
--- a/html/2by2.html
+++ b/html/2by2.html
@@ -16,8 +16,6 @@
 <script>
     var canvas1,canvas2;
     var ctx1,ctx2;
-    var payoff1_11, payoff1_12, payoff1_21, payoff1_22, payoff2_11, payoff2_12, payoff2_21, payoff2_22; //payoff vertices
-    var point1_1, point1_2, point1_3,point2_1, point2_2, point2_3; // point delimiting the best response.
     
     function initDraws() {
         canvas1 = document.getElementById("Payoff1");
@@ -26,21 +24,111 @@
         ctx2 = canvas2.getContext("2d");
         compute_firstP();
         compute_secondP();
+        points=[payoff1_11, payoff1_12, payoff1_21, payoff1_22, payoff2_11, payoff2_12, payoff2_21, payoff2_22];
         draw();
+        
+        //alert(points[0].y);
         // mouse event
-        //canvas1.addEventListener("mousedown",doMouseDown);
-        //canvas1.addEventListener("mouseup",doMouseUp);
-        //canvas2.addEventListener("mousedown",doMouseDown);
-        //canvas2.addEventListener("mouseup",doMouseUp);
+        canvas1.addEventListener("mousedown",doMouseDown);
+        canvas1.addEventListener("mouseup",doMouseUp);
+        canvas2.addEventListener("mousedown",doMouseDown);
+        canvas2.addEventListener("mouseup",doMouseUp);
         input_user=document.getElementsByTagName("input");
         for (var i=0; i<input_user.length;i++){
-           input_user[i].addEventListener("onchange",redraw);
+           //input_user[i].addEventListener("onchange",redraw());
         }
     }
 
+function getMousePosition(e) {
+    return {
+        x: e.clientX ,
+        y: e.clientY
+  };
+}
+
+
+function doMouseDown(event) {
+    mousePosition = getMousePosition( event)
+    
+    var isMouseOver = isMouseOverPoint(mousePosition);
+    /*if (isMouseOver) {
+        canvas1.addEventListener("mousemove", doMouseMove);
+    }*/
+    //console.log("Pressing1: X = " + mousePosition.x + ", Y = " + mousePosition.y);
+    //mousePosition = getMousePosition(canvas2, event)
+    
+    //isMouseOver = isMouseOverPoint(mousePosition);
+    /*if (isMouseOver) {
+        canvas2.addEventListener("mousemove", doMouseMove);
+    }*/
+    console.log("Pressing2: X = " + mousePosition.x + ", Y = " + mousePosition.y);
+}
+
+function doMouseUp(event) {
+    mousePosition = getMousePosition(event)
+    
+    canvas1.removeEventListener("mousemove", doMouseMove);
+    canvas2.removeEventListener("mousemove", doMouseMove);
+
+    redraw()
+    console.log("Releasing: X = " + mousePosition.x + ", Y = " + mousePosition.y);
+}
+
+function isMouseOverPoint(mousePosition) {
+    var canvasPosition = canvas1.getBoundingClientRect();
+    for (var i=0 ; i< points.length/2;i++){
+        distX = mousePosition.x - (points[i].x)-canvasPosition.left;
+        distY = mousePosition.y -points[i].y-canvasPosition.top;
+        var squareDist = distX*distX + distY*distY;
+        if (squareDist < 100) {
+            canvas1.addEventListener("mousemove", doMouseMove);
+            point_moving=i;
+            return i;
+        }
+    }
+    canvasPosition = canvas2.getBoundingClientRect();
+    for (var i=points.length/2 ; i< points.length;i++){
+        distX = mousePosition.x - points[i].x-canvasPosition.left;
+        distY = mousePosition.y - points[i].y-canvasPosition.top;
+        var squareDist = distX*distX + distY*distY;
+        if (squareDist < 100) {
+            (canvas2).addEventListener("mousemove", doMouseMove);
+            point_moving=i;
+            return i;
+        }
+    }
+    
+    return -1;
+}
+
+function doMouseMove(event) {
+    //alert("moving "+point_moving);
+    if (point_moving<points.length/2){
+        mousePosition = getMousePosition(event)
+        var canvasPosition = canvas1.getBoundingClientRect();
+         points[point_moving].y = mousePosition.y-canvasPosition.top;
+         if(point_moving==0) document.getElementById("P1_11").value=~~((-points[point_moving].y+canvas1.height-50)/3)/10;
+         if(point_moving==1) document.getElementById("P1_12").value=~~((-points[point_moving].y+canvas1.height-50)/3)/10;
+         if(point_moving==2) document.getElementById("P1_21").value=~~((-points[point_moving].y+canvas1.height-50)/3)/10;
+         if(point_moving==3) document.getElementById("P1_22").value=~~((-points[point_moving].y+canvas1.height-50)/3)/10;
+    }
+    if (point_moving>=points.length/2){
+        mousePosition = getMousePosition(event)
+        var canvasPosition = canvas2.getBoundingClientRect();
+        points[point_moving].y = mousePosition.y-canvasPosition.top;
+        if(point_moving==4) document.getElementById("P2_11").value=~~((-points[point_moving].y+canvas2.height-50)/3)/10;
+        if(point_moving==5) document.getElementById("P2_12").value=~~((-points[point_moving].y+canvas2.height-50)/3)/10;
+        if(point_moving==6) document.getElementById("P2_21").value=~~((-points[point_moving].y+canvas2.height-50)/3)/10;
+        if(point_moving==7) document.getElementById("P2_22").value=~~((-points[point_moving].y+canvas2.height-50)/3)/10;
+    }
+    redraw()
+    
+    console.log("Moving: X = " + mousePosition.x + ", Y = " + mousePosition.y);
+}
+
     function redraw(){
-        canvas1.clearRect(0,0,canvas1.width,canvas1.height);
-        canvas2.clearRect(0,0,canvas2.width,canvas2.height);
+        ctx1.clearRect(0,0,canvas1.width,canvas1.height);
+        ctx2.clearRect(0,0,canvas2.width,canvas2.height);
         compute_firstP();
         compute_secondP();
         draw();
@@ -51,10 +139,10 @@
         var P1_12=document.getElementById("P1_12").value;
         var P1_21=document.getElementById("P1_21").value;
         var P1_22=document.getElementById("P1_22").value;
-        payoff1_11={x:0, y:canvas1.height-P1_11*100, radius:5, color:"yellow"};
-        payoff1_12={x:canvas1.width, y:canvas1.height-P1_12*100, radius:5, color:"yellow"};
-        payoff1_21={x:0, y:canvas1.height-P1_21*100, radius:5, color:"yellow"};
-        payoff1_22={x:canvas1.width, y:canvas1.height-P1_22*100, radius:5, color:"yellow"};
+        payoff1_11={x:50, y:canvas1.height-50-P1_11*30, radius:5, color:"yellow"};
+        payoff1_12={x:canvas1.width-50, y:canvas1.height-50-P1_12*30, radius:5, color:"yellow"};
+        payoff1_21={x:50, y:canvas1.height-50-P1_21*30, radius:5, color:"yellow"};
+        payoff1_22={x:canvas1.width-50, y:canvas1.height-50-P1_22*30, radius:5, color:"yellow"};
         var maxP1_1, minP1_1, maxP1_2, minP1_2; // max and min off player1 payoff for strategy 1 or 2 of player2
         if( P1_11>P1_21){
             maxP1_1=P1_11;
@@ -71,16 +159,15 @@
             minP1_2=P1_12;
         }
         if((maxP1_1==P1_11 && maxP1_2==P1_12)||(maxP1_1==P1_21 && maxP1_2==P1_22)){
-            alert("test");
-            point1_1={x:0,y:canvas1.height-maxP1_2*100};
-            point1_2={x:canvas1.width,y:canvas1.height-maxP1_1*100};
-            point1_3={x:canvas1.width,y:canvas1.height-maxP1_1*100};}
+            point1_1={x:50,y:canvas1.height-50-maxP1_1*30};
+            point1_2={x:canvas1.width-50,y:canvas1.height-50-maxP1_2*30};
+            point1_3={x:canvas1.width-50,y:canvas1.height-50-maxP1_2*30};}
         else{
             var middle_x=(P1_21-P1_11)/(Number(P1_21)- Number(P1_22) + Number(P1_12) - Number(P1_11));
             var middle_y=Number((P1_12-P1_11)*middle_x)+Number(P1_11);
-            point1_1={x:0, y:canvas1.height-maxP1_1*100};
-            point1_2={x:middle_x * canvas1.width,y:canvas1.height-middle_y*100};
-            point1_3={x:canvas1.width,y:canvas1.height-maxP1_2*100};
+            point1_1={x:50, y:canvas1.height-50-maxP1_1*30};
+            point1_2={x:middle_x * (canvas1.width-100)+50,y:canvas1.height-50-middle_y*30};
+            point1_3={x:canvas1.width-50,y:canvas1.height-50-maxP1_2*30};
         }
     }
             
@@ -89,10 +176,10 @@
         var P2_12=document.getElementById("P2_12").value;
         var P2_21=document.getElementById("P2_21").value;
         var P2_22=document.getElementById("P2_22").value;
-        payoff2_11={x:0, y:canvas2.height-P2_11*100, radius:5, color:"yellow"};
-        payoff2_12={x:0, y:canvas2.height-P2_12*100, radius:5, color:"yellow"};
-        payoff2_21={x:canvas2.width, y:canvas2.height-P2_21*100, radius:5, color:"yellow"};
-        payoff2_22={x:canvas2.width, y:canvas2.height-P2_22*100, radius:5, color:"yellow"};
+        payoff2_11={x:50, y:canvas2.height-50-P2_11*30, radius:5, color:"yellow"};
+        payoff2_12={x:50, y:canvas2.height-50-P2_12*30, radius:5, color:"yellow"};
+        payoff2_21={x:canvas2.width-50, y:canvas2.height-50-P2_21*30, radius:5, color:"yellow"};
+        payoff2_22={x:canvas2.width-50, y:canvas2.height-50-P2_22*30, radius:5, color:"yellow"};
         var maxP2_1, minP2_1, maxP2_2, minP2_2; // max and min off player1 payoff for strategy 1 or 2 of player2
         if( P2_11>P2_12){
             maxP2_1=P2_11;
@@ -109,48 +196,48 @@
             minP2_2=P2_21;
         }
         if((maxP2_1==P2_11 && maxP2_2==P2_21)||(maxP2_1==P2_12 && maxP2_2==P2_22)){
-            point2_1={x:0,y:canvas2.height-maxP2_2*100};
-            point2_2={x:canvas2.width,y:canvas2.height-maxP2_1*100};
-            point2_3={x:canvas2.width,y:canvas2.height-maxP2_1*100};}
+            point2_1={x:50,y:canvas2.height-50-maxP2_1*30};
+            point2_2={x:canvas2.width-50,y:canvas2.height-50-maxP2_2*30};
+            point2_3={x:canvas2.width-50,y:canvas2.height-50-maxP2_2*30};}
         else{
             var middle_x=(P2_12-P2_11)/(Number(P2_12)- Number(P2_22) + Number(P2_21) - Number(P2_11));
             var middle_y=Number((P2_21-P2_11)*middle_x)+Number(P2_11);
-            point2_1={x:0,y:canvas2.height-maxP2_1*100};
-            point2_2={x:middle_x * canvas2.width,y:canvas2.height-middle_y*100};
-            point2_3={x:canvas2.width,y:canvas2.height-maxP2_2*100};
+            point2_1={x:50,y:canvas2.height-50-maxP2_1*30};
+            point2_2={x:middle_x * (canvas2.width-100)+50,y:canvas2.height-50-middle_y*30};
+            point2_3={x:canvas2.width-50,y:canvas2.height-50-maxP2_2*30};
         }
     }
     
     function draw(){
-        ctx1.beginPath();
-        ctx1.moveTo(0,0);
-        ctx1.lineTo(0,canvas1.height);
-        ctx1.lineTo(canvas1.width,canvas1.height);
-        ctx1.lineTo(canvas1.width,0);
-        ctx1.lineWidth = 4;
+        ctx1.beginPath(); //limits of the drawing
+        ctx1.moveTo(50,50);
+        ctx1.lineTo(50,canvas1.height-50);
+        ctx1.lineTo(canvas1.width-50,canvas1.height-50);
+        ctx1.lineTo(canvas1.width-50,50);
+        ctx1.lineWidth = 2;
         ctx1.strokeStyle = '#000000';
         ctx1.stroke();
         ctx1.closePath();
-        ctx1.beginPath();
+        ctx1.beginPath(); // Two lines
         ctx1.moveTo(payoff1_11.x,payoff1_11.y);
         ctx1.lineTo(payoff1_12.x,payoff1_12.y);
         ctx1.moveTo(payoff1_21.x,payoff1_21.y);
         ctx1.lineTo(payoff1_22.x,payoff1_22.y);
-        ctx1.lineWidth = 4;
+        ctx1.lineWidth = 2;
         ctx1.strokeStyle = '#ff0000';
         ctx1.stroke();
         ctx1.closePath();
-        ctx1.beginPath();
-        ctx1.moveTo(0,0);
+        ctx1.beginPath();//best response surface
+        ctx1.moveTo(50,50);
         ctx1.lineTo(point1_1.x,point1_1.y);
         ctx1.lineTo(point1_2.x,point1_2.y);
         ctx1.lineTo(point1_3.x,point1_3.y);
-        ctx1.lineTo(canvas1.width,0);
-        ctx1.lineTo(0,0);
+        ctx1.lineTo(canvas1.width-50,50);
+        ctx1.lineTo(50,50);
         ctx1.fillStyle="#ff6666";
         ctx1.fill();
         ctx1.closePath();
-        ctx1.beginPath();
+        ctx1.beginPath();// Points
         ctx1.arc(payoff1_11.x, payoff1_11.y, payoff1_11.radius, 0, 2*Math.PI);
         ctx1.fillStyle = payoff1_11.color;
         ctx1.fill();
@@ -174,36 +261,44 @@
         ctx1.fill();
         ctx1.stroke();
         ctx1.closePath();
+        ctx1.fillStyle = '#000000';
+        ctx1.font='30px Arial';
+        ctx1.fillText("Player1 payoff",50,40);
+        ctx1.font='20px Arial';
+        ctx1.fillStyle = '#0000ff';
+        ctx1.fillText("0",40,370);
+        ctx1.fillText("1",260,370);
+        ctx1.fillText("Player2 "+document.getElementById("P2S2").value+" prob ",80,380);
         
-        ctx2.beginPath();
-        ctx2.moveTo(0,0);
-        ctx2.lineTo(0,canvas2.height);
-        ctx2.lineTo(canvas2.width,canvas2.height);
-        ctx2.lineTo(canvas2.width,0);
-        ctx2.lineWidth = 4;
+        ctx2.beginPath(); //limits of the drawing
+        ctx2.moveTo(50,50);
+        ctx2.lineTo(50,canvas2.height-50);
+        ctx2.lineTo(canvas2.width-50,canvas2.height-50);
+        ctx2.lineTo(canvas2.width-50,50);
+        ctx2.lineWidth = 2;
         ctx2.strokeStyle = '#000000';
         ctx2.stroke();
         ctx2.closePath();
-        ctx2.beginPath();
+        ctx2.beginPath();// Two lines
         ctx2.moveTo(payoff2_11.x,payoff2_11.y);
         ctx2.lineTo(payoff2_21.x,payoff2_21.y);
         ctx2.moveTo(payoff2_12.x,payoff2_12.y);
         ctx2.lineTo(payoff2_22.x,payoff2_22.y);
-        ctx2.lineWidth = 4;
+        ctx2.lineWidth = 2;
         ctx2.strokeStyle = '#0000ff';
         ctx2.stroke();
         ctx2.closePath();
-        ctx2.beginPath();
-        ctx2.moveTo(0,0);
+        ctx2.beginPath();//best response surface
+        ctx2.moveTo(50,50);
         ctx2.lineTo(point2_1.x,point2_1.y);
         ctx2.lineTo(point2_2.x,point2_2.y);
         ctx2.lineTo(point2_3.x,point2_3.y);
-        ctx2.lineTo(canvas1.width,0);
-        ctx2.lineTo(0,0);
+        ctx2.lineTo(canvas1.width-50,50);
+        ctx2.lineTo(50,50);
         ctx2.fillStyle="#6666ff";
         ctx2.fill();
         ctx2.closePath();
-        ctx2.beginPath();
+        ctx2.beginPath();// Points
         ctx2.arc(payoff2_11.x, payoff2_11.y, payoff2_11.radius, 0, 2*Math.PI);
         ctx2.fillStyle = payoff2_11.color;
         ctx2.fill();
@@ -227,6 +322,14 @@
         ctx2.fill();
         ctx2.stroke();
         ctx2.closePath();
+        ctx2.fillStyle = '#000000';
+        ctx2.font='30px Arial';
+        ctx2.fillText("Player2 payoff",50,40);
+        ctx2.font='20px Arial';
+        ctx2.fillStyle = '#ff0000';
+        ctx2.fillText("0",40,370);
+        ctx2.fillText("1",260,370);
+        ctx2.fillText("Player1 "+document.getElementById("P1S2").value+" prob ",80,380);
     }
 
 </script>
@@ -238,20 +341,20 @@
     <th><label><input class="player2" type="text" id="P2S2" value="S2"/> </label></th>
   </tr>
   <tr>
-      <th><label><input class="player1" type="text" name=1s1 value="S1"/> </label></th>
-    <td><input class="player1" type="text" id="P1_11" value=0>\<input class="player2" type="text" id="P2_11"  value=0></td>
-    <td><input class="player1" type="text" id="P1_12"  value=0>\<input class="player2" type="text" id="P2_12" value=0></td>
+      <th><label><input class="player1" type="text" id="P1S1" value="S1"/> </label></th>
+    <td><input class="player1" type="text" id="P1_11" onchange="redraw()" value=0>\<input class="player2" type="text" id="P2_11"  onchange="redraw()" value=0></td>
+    <td><input class="player1" type="text" id="P1_12" onchange="redraw()" value=0>\<input class="player2" type="text" id="P2_12" onchange="redraw()" value=0></td>
   </tr>
   <tr>
-  <th><label><input class="player1" type="text" name=1s2 value="S2"/> </label></th>
-    <td><input class="player1" type="text" id="P1_21"  value=0>\<input class="player2" type="text" id="P2_21"  value=0></td>
-    <td><input class="player1" type="text" id="P1_22" value=0>\<input class="player2" type="text" id="P2_22"  value=0></td>
+  <th><label><input class="player1" type="text" id="P1S2" value="S2"/> </label></th>
+    <td><input class="player1" type="text" id="P1_21" onchange="redraw()" value=0>\<input class="player2" type="text" id="P2_21"  onchange="redraw()" value=0></td>
+    <td><input class="player1" type="text" id="P1_22" onchange="redraw()" value=0>\<input class="player2" type="text" id="P2_22"  onchange="redraw()" value=0></td>
   </tr>
 </table>
-        <canvas id="Payoff1" width="300" height="500" style = "float:left; width: 40%;">
+        <canvas id="Payoff1" width="300px" height="400px">
         </canvas>
         
-        <canvas id="Payoff2" width="300" height="500" style = "float:right; width: 40%;">
+        <canvas id="Payoff2" width="300px" height="400px">
         </canvas>
         
                                                                     
diff --git a/html/css/2by2.css b/html/css/2by2.css
index 86dba40..7ba260a 100644
--- a/html/css/2by2.css
+++ b/html/css/2by2.css
@@ -10,3 +10,8 @@ input{
     width: 50px;
    text-align: center;
 }
+
+canvas{
+    #padding: 30px;
+    margin: 50px;
+}

From 56613155c9868d04dbd5fcf2a5504352fab97d55 Mon Sep 17 00:00:00 2001
From: amelie <amelie.heliou@polytechnique.edu>
Date: Mon, 16 May 2016 08:26:23 +0200
Subject: [PATCH 08/63] untrack a few files

---
 html/2by2_three.html                      |   173 -
 html/js/three/renderers/CanvasRenderer.js |  1114 -
 html/js/three/renderers/Projector.js      |   921 -
 html/js/three/three.js                    | 41507 --------------------
 4 files changed, 43715 deletions(-)
 delete mode 100644 html/2by2_three.html
 delete mode 100755 html/js/three/renderers/CanvasRenderer.js
 delete mode 100755 html/js/three/renderers/Projector.js
 delete mode 100755 html/js/three/three.js

diff --git a/html/2by2_three.html b/html/2by2_three.html
deleted file mode 100644
index ddf56a5..0000000
--- a/html/2by2_three.html
+++ /dev/null
@@ -1,173 +0,0 @@
-<!doctype html>
-<html class="no-js" lang"">
-    <head>
-        <meta charset="utf-8">
-        <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
-        <title>2 by 2 games</title>
-        <link rel="stylesheet" href="css/2by2.css">
-        <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>
-        <script src="js/three/three.js"></script>
-        <script src="js/three/renderers/Projector.js"></script>
-		<script src="js/three/renderers/CanvasRenderer.js"></script>
-    </head>
-
-<script>
-    function bottom() {
-        container = document.createElement( 'div' );
-        document.body.appendChild( container );
-        scene = new THREE.Scene();
-        camera = new THREE.PerspectiveCamera( 60, 1, 1, 10000 );
-        camera.position.z = window.innerWidth;
-        renderer = new THREE.WebGLRenderer();
-        //renderer.setPixelRatio( window.devicePixelRatio );
-        renderer.setSize( window.innerWidth/2, window.innerWidth/2 );
-        renderer.setClearColor( 0xffffff, 1);
-        container.appendChild( renderer.domElement );
-        var material = new THREE.LineBasicMaterial({color: 0x000000, linewidth:2});
-        var geometry = new THREE.Geometry();
-        geometry.vertices.push(new THREE.Vector3( -window.innerWidth/4, window.innerWidth/4, 0 ),
-                               new THREE.Vector3(-window.innerWidth/4, -window.innerWidth/4, 0 ),
-                               new THREE.Vector3( window.innerWidth/4, -window.innerWidth/4, 0 ),
-                               new THREE.Vector3( window.innerWidth/4, window.innerWidth/4, 0 )
-                               );
-        var line = new THREE.Line( geometry, material );
-        scene.add( line );
-        var ratio=window.innerWidth/10;
-        var P11_1=$("[name='P11_1']").val()*ratio-window.innerWidth/4;
-        var P12_1=$("[name='P12_1']").val()*ratio-window.innerWidth/4;
-        var maxP1_1;
-        var maxP1_2;
-        var minP1_1;
-        var minP1_2;
-        var P21_1=$("[name='P21_1']").val()*ratio-window.innerWidth/4;
-        var P22_1=$("[name='P22_1']").val()*ratio-window.innerWidth/4;
-        if( P11_1>P21_1){
-           maxP1_1=P11_1;
-           minP1_1=P21_1;
-        }else{
-            maxP1_1=P21_1;
-            minP1_1=P11_1;
-        }
-        if( P12_1>P22_1){
-            maxP1_2=P12_1;
-            minP1_2=P22_1;
-        }else{
-            maxP1_2=P22_1;
-            minP1_2=P12_1;
-        }
-        var geometryP1_1 = new THREE.Geometry();
-        var materialP1_1 = new THREE.LineBasicMaterial({color: 0xff0000, linewidth:3});
-        geometryP1_1.vertices.push(new THREE.Vector3( -window.innerWidth/4, P11_1, 0 ),
-                                   new THREE.Vector3(window.innerWidth/4, P12_1, 0 ));
-        var lineP1_1 = new THREE.Line( geometryP1_1, materialP1_1 );
-        scene.add( lineP1_1 );
-        var geometryP1_2 = new THREE.Geometry();
-        var materialP1_2 = new THREE.LineBasicMaterial({color: 0xff0000, linewidth:3});
-        geometryP1_2.vertices.push(new THREE.Vector3( -window.innerWidth/4, P21_1, 0 ),
-        new THREE.Vector3(window.innerWidth/4, P22_1, 0 ));
-        var lineP1_2 = new THREE.Line( geometryP1_2, materialP1_2 );
-        scene.add( lineP1_2 );
-        
-        var geometryP1_sur = new THREE.Geometry();
-        var material_sur = new THREE.LineBasicMaterial({color: 0xff0000, linewidth:3});
-        geometryP1_2.vertices.push(new THREE.Vector3( -window.innerWidth/4, P21_1, 0 ),
-                                   new THREE.Vector3(window.innerWidth/4, P22_1, 0 ));
-        var lineP1_2 = new THREE.Line( geometryP1_2, materialP1_2 );
-        scene.add( lineP1_2 );
-        renderer.render( scene, camera);
-    };
-    
-    
-$(document).ready(function(){
-    $("input").change(function(){
-   // alert("test");
-    var c=document.getElementById("Payoff2");
-    var ctx = c.getContext("2d");
-    ctx.moveTo(0,0);
-    ctx.clearRect(0,0,c.width,c.height);
-    ctx.beginPath();
-    var P11_1=parseInt($("[name='P11_1']").val(),10);
-    var P12_1=parseInt($("[name='P12_1']").val(),10);
-    var maxP1_1;
-    var maxP1_2;
-    var minP1_1;
-    var minP1_2;
-    var P21_1=parseInt($("[name='P21_1']").val(),10);
-    var P22_1=parseInt($("[name='P22_1']").val(),10);
-    if( P11_1>P21_1){
-        maxP1_1=P11_1;
-        minP1_1=P21_1;
-    }else{
-       maxP1_1=P21_1;
-       minP1_1=P11_1;
-   }
-   if( P12_1>P22_1){
-        maxP1_2=P12_1;
-        minP1_2=P22_1;
-    }else{
-       maxP1_2=P22_1;
-       minP1_2=P12_1;
-   }
-   // alert(P11_1);
-    ctx.moveTo(0,c.height-P11_1*100);
-    ctx.lineTo(c.width,c.height-P12_1*100);
-    ctx.moveTo(0,c.height-P21_1*100);
-    ctx.lineTo(c.width,c.height-P22_1*100);
-    ctx.lineWidth = 2;
-    ctx.strokeStyle = '#ff0000';
-    ctx.stroke();
-    ctx.closePath();
-    ctx.beginPath();
-    if((maxP1_1==P11_1 && maxP1_2==P12_1)||(maxP1_1==P21_1 && maxP1_2==P22_1)){
-        ctx.moveTo(0,0);
-        ctx.lineTo(0,c.height-maxP1_2*100);
-        ctx.lineTo(c.width,c.height-maxP1_1*100);
-        ctx.lineTo(c.width,0);
-        ctx.lineTo(0,0);
-    }
-    else{
-        var middle_x=(P21_1-P11_1)/(Number(P12_1)- Number(P22_1) + Number(P21_1) - Number(P11_1));
-        var middle_y=Number((P12_1-P11_1)*middle_x)+Number(P11_1);
-        ctx.moveTo(0,0);
-        ctx.lineTo(0,c.height-maxP1_1*100);
-        ctx.lineTo(middle_x*c.width,c.height-middle_y*100);
-        ctx.lineTo(c.width,c.height-maxP1_2*100);
-        ctx.lineTo(c.width,0);
-        ctx.lineTo(0,0);
-    }
-    ctx.fillStyle="#ff6666";
-    ctx.fill();
-    ctx.closePath();
-                      bottom();
-    });
-});
-</script>
-
-    <body>
-        <!--[if lt IE 8]>
-            <p class="browserupgrade">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
-        <![endif]-->
-
-        <table border="1">
-  <tr>
-    <th><label class="player1">Player I</label> \ <label class="player2">Player II</label></th>
-    <th><label><input class="player2" type="text" name=2s1 value="S1"/> </label></th>
-    <th><label><input class="player2" type="text" name=2s2 value="S2"/> </label></th>
-  </tr>
-  <tr>
-      <th><label><input class="player1" type="text" name=1s1 value="S1"/> </label></th>
-    <td><input class="player1" type="text" name="P11_1" value=0>\<input class="player2" type="text" name=P11_2  value=0></td>
-    <td><input class="player1" type="text" name=P12_1  value=0>\<input class="player2" type="text" name=P12_2 value=0></td>
-  </tr>
-  <tr>
-  <th><label><input class="player1" type="text" name=1s2 value="S2"/> </label></th>
-    <td><input class="player1" type="text" name=P21_1  value=0>\<input class="player2" type="text" name=P21_2  value=0></td>
-    <td><input class="player1" type="text" name=P22_1 value=0>\<input class="player2" type="text" name=P22_2  value=0></td>
-  </tr>
-</table>
-        <canvas id="Payoff2" width="200" height="300">
-        </canvas>
-        
-                                                                    
-</body>
-</html>
diff --git a/html/js/three/renderers/CanvasRenderer.js b/html/js/three/renderers/CanvasRenderer.js
deleted file mode 100755
index 7009e72..0000000
--- a/html/js/three/renderers/CanvasRenderer.js
+++ /dev/null
@@ -1,1114 +0,0 @@
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.SpriteCanvasMaterial = function ( parameters ) {
-
-	THREE.Material.call( this );
-
-	this.type = 'SpriteCanvasMaterial';
-
-	this.color = new THREE.Color( 0xffffff );
-	this.program = function ( context, color ) {};
-
-	this.setValues( parameters );
-
-};
-
-THREE.SpriteCanvasMaterial.prototype = Object.create( THREE.Material.prototype );
-THREE.SpriteCanvasMaterial.prototype.constructor = THREE.SpriteCanvasMaterial;
-
-THREE.SpriteCanvasMaterial.prototype.clone = function () {
-
-	var material = new THREE.SpriteCanvasMaterial();
-
-	material.copy( this );
-	material.color.copy( this.color );
-	material.program = this.program;
-
-	return material;
-
-};
-
-//
-
-THREE.CanvasRenderer = function ( parameters ) {
-
-	console.log( 'THREE.CanvasRenderer', THREE.REVISION );
-
-	parameters = parameters || {};
-
-	var _this = this,
-	_renderData, _elements, _lights,
-	_projector = new THREE.Projector(),
-
-	_canvas = parameters.canvas !== undefined
-			 ? parameters.canvas
-			 : document.createElement( 'canvas' ),
-
-	_canvasWidth = _canvas.width,
-	_canvasHeight = _canvas.height,
-	_canvasWidthHalf = Math.floor( _canvasWidth / 2 ),
-	_canvasHeightHalf = Math.floor( _canvasHeight / 2 ),
-
-	_viewportX = 0,
-	_viewportY = 0,
-	_viewportWidth = _canvasWidth,
-	_viewportHeight = _canvasHeight,
-
-	_pixelRatio = 1,
-
-	_context = _canvas.getContext( '2d', {
-		alpha: parameters.alpha === true
-	} ),
-
-	_clearColor = new THREE.Color( 0x000000 ),
-	_clearAlpha = parameters.alpha === true ? 0 : 1,
-
-	_contextGlobalAlpha = 1,
-	_contextGlobalCompositeOperation = 0,
-	_contextStrokeStyle = null,
-	_contextFillStyle = null,
-	_contextLineWidth = null,
-	_contextLineCap = null,
-	_contextLineJoin = null,
-	_contextLineDash = [],
-
-	_camera,
-
-	_v1, _v2, _v3, _v4,
-	_v5 = new THREE.RenderableVertex(),
-	_v6 = new THREE.RenderableVertex(),
-
-	_v1x, _v1y, _v2x, _v2y, _v3x, _v3y,
-	_v4x, _v4y, _v5x, _v5y, _v6x, _v6y,
-
-	_color = new THREE.Color(),
-	_color1 = new THREE.Color(),
-	_color2 = new THREE.Color(),
-	_color3 = new THREE.Color(),
-	_color4 = new THREE.Color(),
-
-	_diffuseColor = new THREE.Color(),
-	_emissiveColor = new THREE.Color(),
-
-	_lightColor = new THREE.Color(),
-
-	_patterns = {},
-
-	_image, _uvs,
-	_uv1x, _uv1y, _uv2x, _uv2y, _uv3x, _uv3y,
-
-	_clipBox = new THREE.Box2(),
-	_clearBox = new THREE.Box2(),
-	_elemBox = new THREE.Box2(),
-
-	_ambientLight = new THREE.Color(),
-	_directionalLights = new THREE.Color(),
-	_pointLights = new THREE.Color(),
-
-	_vector3 = new THREE.Vector3(), // Needed for PointLight
-	_centroid = new THREE.Vector3(),
-	_normal = new THREE.Vector3(),
-	_normalViewMatrix = new THREE.Matrix3();
-
-	/* TODO
-	_canvas.mozImageSmoothingEnabled = false;
-	_canvas.webkitImageSmoothingEnabled = false;
-	_canvas.msImageSmoothingEnabled = false;
-	_canvas.imageSmoothingEnabled = false;
-	*/
-
-	// dash+gap fallbacks for Firefox and everything else
-
-	if ( _context.setLineDash === undefined ) {
-
-		_context.setLineDash = function () {};
-
-	}
-
-	this.domElement = _canvas;
-
-	this.autoClear = true;
-	this.sortObjects = true;
-	this.sortElements = true;
-
-	this.info = {
-
-		render: {
-
-			vertices: 0,
-			faces: 0
-
-		}
-
-	};
-
-	// WebGLRenderer compatibility
-
-	this.supportsVertexTextures = function () {};
-	this.setFaceCulling = function () {};
-
-	// API
-
-	this.getContext = function () {
-
-		return _context;
-
-	};
-
-	this.getContextAttributes = function () {
-
-		return _context.getContextAttributes();
-
-	};
-
-	this.getPixelRatio = function () {
-
-		return _pixelRatio;
-
-	};
-
-	this.setPixelRatio = function ( value ) {
-
-		if ( value !== undefined ) _pixelRatio = value;
-
-	};
-
-	this.setSize = function ( width, height, updateStyle ) {
-
-		_canvasWidth = width * _pixelRatio;
-		_canvasHeight = height * _pixelRatio;
-
-		_canvas.width = _canvasWidth;
-		_canvas.height = _canvasHeight;
-
-		_canvasWidthHalf = Math.floor( _canvasWidth / 2 );
-		_canvasHeightHalf = Math.floor( _canvasHeight / 2 );
-
-		if ( updateStyle !== false ) {
-
-			_canvas.style.width = width + 'px';
-			_canvas.style.height = height + 'px';
-
-		}
-
-		_clipBox.min.set( - _canvasWidthHalf, - _canvasHeightHalf );
-		_clipBox.max.set(   _canvasWidthHalf,   _canvasHeightHalf );
-
-		_clearBox.min.set( - _canvasWidthHalf, - _canvasHeightHalf );
-		_clearBox.max.set(   _canvasWidthHalf,   _canvasHeightHalf );
-
-		_contextGlobalAlpha = 1;
-		_contextGlobalCompositeOperation = 0;
-		_contextStrokeStyle = null;
-		_contextFillStyle = null;
-		_contextLineWidth = null;
-		_contextLineCap = null;
-		_contextLineJoin = null;
-
-		this.setViewport( 0, 0, width, height );
-
-	};
-
-	this.setViewport = function ( x, y, width, height ) {
-
-		_viewportX = x * _pixelRatio;
-		_viewportY = y * _pixelRatio;
-
-		_viewportWidth = width * _pixelRatio;
-		_viewportHeight = height * _pixelRatio;
-
-	};
-
-	this.setScissor = function () {};
-	this.setScissorTest = function () {};
-
-	this.setClearColor = function ( color, alpha ) {
-
-		_clearColor.set( color );
-		_clearAlpha = alpha !== undefined ? alpha : 1;
-
-		_clearBox.min.set( - _canvasWidthHalf, - _canvasHeightHalf );
-		_clearBox.max.set(   _canvasWidthHalf,   _canvasHeightHalf );
-
-	};
-
-	this.setClearColorHex = function ( hex, alpha ) {
-
-		console.warn( 'THREE.CanvasRenderer: .setClearColorHex() is being removed. Use .setClearColor() instead.' );
-		this.setClearColor( hex, alpha );
-
-	};
-
-	this.getClearColor = function () {
-
-		return _clearColor;
-
-	};
-
-	this.getClearAlpha = function () {
-
-		return _clearAlpha;
-
-	};
-
-	this.getMaxAnisotropy = function () {
-
-		return 0;
-
-	};
-
-	this.clear = function () {
-
-		if ( _clearBox.isEmpty() === false ) {
-
-			_clearBox.intersect( _clipBox );
-			_clearBox.expandByScalar( 2 );
-
-			_clearBox.min.x = _clearBox.min.x + _canvasWidthHalf;
-			_clearBox.min.y =  - _clearBox.min.y + _canvasHeightHalf;		// higher y value !
-			_clearBox.max.x = _clearBox.max.x + _canvasWidthHalf;
-			_clearBox.max.y =  - _clearBox.max.y + _canvasHeightHalf;		// lower y value !
-
-			if ( _clearAlpha < 1 ) {
-
-				_context.clearRect(
-					_clearBox.min.x | 0,
-					_clearBox.max.y | 0,
-					( _clearBox.max.x - _clearBox.min.x ) | 0,
-					( _clearBox.min.y - _clearBox.max.y ) | 0
-				);
-
-			}
-
-			if ( _clearAlpha > 0 ) {
-
-				setBlending( THREE.NormalBlending );
-				setOpacity( 1 );
-
-				setFillStyle( 'rgba(' + Math.floor( _clearColor.r * 255 ) + ',' + Math.floor( _clearColor.g * 255 ) + ',' + Math.floor( _clearColor.b * 255 ) + ',' + _clearAlpha + ')' );
-
-				_context.fillRect(
-					_clearBox.min.x | 0,
-					_clearBox.max.y | 0,
-					( _clearBox.max.x - _clearBox.min.x ) | 0,
-					( _clearBox.min.y - _clearBox.max.y ) | 0
-				);
-
-			}
-
-			_clearBox.makeEmpty();
-
-		}
-
-	};
-
-	// compatibility
-
-	this.clearColor = function () {};
-	this.clearDepth = function () {};
-	this.clearStencil = function () {};
-
-	this.render = function ( scene, camera ) {
-
-		if ( camera instanceof THREE.Camera === false ) {
-
-			console.error( 'THREE.CanvasRenderer.render: camera is not an instance of THREE.Camera.' );
-			return;
-
-		}
-
-		if ( this.autoClear === true ) this.clear();
-
-		_this.info.render.vertices = 0;
-		_this.info.render.faces = 0;
-
-		_context.setTransform( _viewportWidth / _canvasWidth, 0, 0, - _viewportHeight / _canvasHeight, _viewportX, _canvasHeight - _viewportY );
-		_context.translate( _canvasWidthHalf, _canvasHeightHalf );
-
-		_renderData = _projector.projectScene( scene, camera, this.sortObjects, this.sortElements );
-		_elements = _renderData.elements;
-		_lights = _renderData.lights;
-		_camera = camera;
-
-		_normalViewMatrix.getNormalMatrix( camera.matrixWorldInverse );
-
-		/* DEBUG
-		setFillStyle( 'rgba( 0, 255, 255, 0.5 )' );
-		_context.fillRect( _clipBox.min.x, _clipBox.min.y, _clipBox.max.x - _clipBox.min.x, _clipBox.max.y - _clipBox.min.y );
-		*/
-
-		calculateLights();
-
-		for ( var e = 0, el = _elements.length; e < el; e ++ ) {
-
-			var element = _elements[ e ];
-
-			var material = element.material;
-
-			if ( material === undefined || material.opacity === 0 ) continue;
-
-			_elemBox.makeEmpty();
-
-			if ( element instanceof THREE.RenderableSprite ) {
-
-				_v1 = element;
-				_v1.x *= _canvasWidthHalf; _v1.y *= _canvasHeightHalf;
-
-				renderSprite( _v1, element, material );
-
-			} else if ( element instanceof THREE.RenderableLine ) {
-
-				_v1 = element.v1; _v2 = element.v2;
-
-				_v1.positionScreen.x *= _canvasWidthHalf; _v1.positionScreen.y *= _canvasHeightHalf;
-				_v2.positionScreen.x *= _canvasWidthHalf; _v2.positionScreen.y *= _canvasHeightHalf;
-
-				_elemBox.setFromPoints( [
-					_v1.positionScreen,
-					_v2.positionScreen
-				] );
-
-				if ( _clipBox.intersectsBox( _elemBox ) === true ) {
-
-					renderLine( _v1, _v2, element, material );
-
-				}
-
-			} else if ( element instanceof THREE.RenderableFace ) {
-
-				_v1 = element.v1; _v2 = element.v2; _v3 = element.v3;
-
-				if ( _v1.positionScreen.z < - 1 || _v1.positionScreen.z > 1 ) continue;
-				if ( _v2.positionScreen.z < - 1 || _v2.positionScreen.z > 1 ) continue;
-				if ( _v3.positionScreen.z < - 1 || _v3.positionScreen.z > 1 ) continue;
-
-				_v1.positionScreen.x *= _canvasWidthHalf; _v1.positionScreen.y *= _canvasHeightHalf;
-				_v2.positionScreen.x *= _canvasWidthHalf; _v2.positionScreen.y *= _canvasHeightHalf;
-				_v3.positionScreen.x *= _canvasWidthHalf; _v3.positionScreen.y *= _canvasHeightHalf;
-
-				if ( material.overdraw > 0 ) {
-
-					expand( _v1.positionScreen, _v2.positionScreen, material.overdraw );
-					expand( _v2.positionScreen, _v3.positionScreen, material.overdraw );
-					expand( _v3.positionScreen, _v1.positionScreen, material.overdraw );
-
-				}
-
-				_elemBox.setFromPoints( [
-					_v1.positionScreen,
-					_v2.positionScreen,
-					_v3.positionScreen
-				] );
-
-				if ( _clipBox.intersectsBox( _elemBox ) === true ) {
-
-					renderFace3( _v1, _v2, _v3, 0, 1, 2, element, material );
-
-				}
-
-			}
-
-			/* DEBUG
-			setLineWidth( 1 );
-			setStrokeStyle( 'rgba( 0, 255, 0, 0.5 )' );
-			_context.strokeRect( _elemBox.min.x, _elemBox.min.y, _elemBox.max.x - _elemBox.min.x, _elemBox.max.y - _elemBox.min.y );
-			*/
-
-			_clearBox.union( _elemBox );
-
-		}
-
-		/* DEBUG
-		setLineWidth( 1 );
-		setStrokeStyle( 'rgba( 255, 0, 0, 0.5 )' );
-		_context.strokeRect( _clearBox.min.x, _clearBox.min.y, _clearBox.max.x - _clearBox.min.x, _clearBox.max.y - _clearBox.min.y );
-		*/
-
-		_context.setTransform( 1, 0, 0, 1, 0, 0 );
-
-	};
-
-	//
-
-	function calculateLights() {
-
-		_ambientLight.setRGB( 0, 0, 0 );
-		_directionalLights.setRGB( 0, 0, 0 );
-		_pointLights.setRGB( 0, 0, 0 );
-
-		for ( var l = 0, ll = _lights.length; l < ll; l ++ ) {
-
-			var light = _lights[ l ];
-			var lightColor = light.color;
-
-			if ( light instanceof THREE.AmbientLight ) {
-
-				_ambientLight.add( lightColor );
-
-			} else if ( light instanceof THREE.DirectionalLight ) {
-
-				// for sprites
-
-				_directionalLights.add( lightColor );
-
-			} else if ( light instanceof THREE.PointLight ) {
-
-				// for sprites
-
-				_pointLights.add( lightColor );
-
-			}
-
-		}
-
-	}
-
-	function calculateLight( position, normal, color ) {
-
-		for ( var l = 0, ll = _lights.length; l < ll; l ++ ) {
-
-			var light = _lights[ l ];
-
-			_lightColor.copy( light.color );
-
-			if ( light instanceof THREE.DirectionalLight ) {
-
-				var lightPosition = _vector3.setFromMatrixPosition( light.matrixWorld ).normalize();
-
-				var amount = normal.dot( lightPosition );
-
-				if ( amount <= 0 ) continue;
-
-				amount *= light.intensity;
-
-				color.add( _lightColor.multiplyScalar( amount ) );
-
-			} else if ( light instanceof THREE.PointLight ) {
-
-				var lightPosition = _vector3.setFromMatrixPosition( light.matrixWorld );
-
-				var amount = normal.dot( _vector3.subVectors( lightPosition, position ).normalize() );
-
-				if ( amount <= 0 ) continue;
-
-				amount *= light.distance == 0 ? 1 : 1 - Math.min( position.distanceTo( lightPosition ) / light.distance, 1 );
-
-				if ( amount == 0 ) continue;
-
-				amount *= light.intensity;
-
-				color.add( _lightColor.multiplyScalar( amount ) );
-
-			}
-
-		}
-
-	}
-
-	function renderSprite( v1, element, material ) {
-
-		setOpacity( material.opacity );
-		setBlending( material.blending );
-
-		var scaleX = element.scale.x * _canvasWidthHalf;
-		var scaleY = element.scale.y * _canvasHeightHalf;
-
-		var dist = 0.5 * Math.sqrt( scaleX * scaleX + scaleY * scaleY ); // allow for rotated sprite
-		_elemBox.min.set( v1.x - dist, v1.y - dist );
-		_elemBox.max.set( v1.x + dist, v1.y + dist );
-
-		if ( material instanceof THREE.SpriteMaterial ) {
-
-			var texture = material.map;
-
-			if ( texture !== null ) {
-
-				var pattern = _patterns[ texture.id ];
-
-				if ( pattern === undefined || pattern.version !== texture.version ) {
-
-					pattern = textureToPattern( texture );
-					_patterns[ texture.id ] = pattern;
-
-				}
-
-				if ( pattern.canvas !== undefined ) {
-
-					setFillStyle( pattern.canvas );
-
-					var bitmap = texture.image;
-
-					var ox = bitmap.width * texture.offset.x;
-					var oy = bitmap.height * texture.offset.y;
-
-					var sx = bitmap.width * texture.repeat.x;
-					var sy = bitmap.height * texture.repeat.y;
-
-					var cx = scaleX / sx;
-					var cy = scaleY / sy;
-
-					_context.save();
-					_context.translate( v1.x, v1.y );
-					if ( material.rotation !== 0 ) _context.rotate( material.rotation );
-					_context.translate( - scaleX / 2, - scaleY / 2 );
-					_context.scale( cx, cy );
-					_context.translate( - ox, - oy );
-					_context.fillRect( ox, oy, sx, sy );
-					_context.restore();
-
-				}
-
-			} else {
-
-				// no texture
-
-				setFillStyle( material.color.getStyle() );
-
-				_context.save();
-				_context.translate( v1.x, v1.y );
-				if ( material.rotation !== 0 ) _context.rotate( material.rotation );
-				_context.scale( scaleX, - scaleY );
-				_context.fillRect( - 0.5, - 0.5, 1, 1 );
-				_context.restore();
-
-			}
-
-		} else if ( material instanceof THREE.SpriteCanvasMaterial ) {
-
-			setStrokeStyle( material.color.getStyle() );
-			setFillStyle( material.color.getStyle() );
-
-			_context.save();
-			_context.translate( v1.x, v1.y );
-			if ( material.rotation !== 0 ) _context.rotate( material.rotation );
-			_context.scale( scaleX, scaleY );
-
-			material.program( _context );
-
-			_context.restore();
-
-		}
-
-		/* DEBUG
-		setStrokeStyle( 'rgb(255,255,0)' );
-		_context.beginPath();
-		_context.moveTo( v1.x - 10, v1.y );
-		_context.lineTo( v1.x + 10, v1.y );
-		_context.moveTo( v1.x, v1.y - 10 );
-		_context.lineTo( v1.x, v1.y + 10 );
-		_context.stroke();
-		*/
-
-	}
-
-	function renderLine( v1, v2, element, material ) {
-
-		setOpacity( material.opacity );
-		setBlending( material.blending );
-
-		_context.beginPath();
-		_context.moveTo( v1.positionScreen.x, v1.positionScreen.y );
-		_context.lineTo( v2.positionScreen.x, v2.positionScreen.y );
-
-		if ( material instanceof THREE.LineBasicMaterial ) {
-
-			setLineWidth( material.linewidth );
-			setLineCap( material.linecap );
-			setLineJoin( material.linejoin );
-
-			if ( material.vertexColors !== THREE.VertexColors ) {
-
-				setStrokeStyle( material.color.getStyle() );
-
-			} else {
-
-				var colorStyle1 = element.vertexColors[ 0 ].getStyle();
-				var colorStyle2 = element.vertexColors[ 1 ].getStyle();
-
-				if ( colorStyle1 === colorStyle2 ) {
-
-					setStrokeStyle( colorStyle1 );
-
-				} else {
-
-					try {
-
-						var grad = _context.createLinearGradient(
-							v1.positionScreen.x,
-							v1.positionScreen.y,
-							v2.positionScreen.x,
-							v2.positionScreen.y
-						);
-						grad.addColorStop( 0, colorStyle1 );
-						grad.addColorStop( 1, colorStyle2 );
-
-					} catch ( exception ) {
-
-						grad = colorStyle1;
-
-					}
-
-					setStrokeStyle( grad );
-
-				}
-
-			}
-
-			_context.stroke();
-			_elemBox.expandByScalar( material.linewidth * 2 );
-
-		} else if ( material instanceof THREE.LineDashedMaterial ) {
-
-			setLineWidth( material.linewidth );
-			setLineCap( material.linecap );
-			setLineJoin( material.linejoin );
-			setStrokeStyle( material.color.getStyle() );
-			setLineDash( [ material.dashSize, material.gapSize ] );
-
-			_context.stroke();
-
-			_elemBox.expandByScalar( material.linewidth * 2 );
-
-			setLineDash( [] );
-
-		}
-
-	}
-
-	function renderFace3( v1, v2, v3, uv1, uv2, uv3, element, material ) {
-
-		_this.info.render.vertices += 3;
-		_this.info.render.faces ++;
-
-		setOpacity( material.opacity );
-		setBlending( material.blending );
-
-		_v1x = v1.positionScreen.x; _v1y = v1.positionScreen.y;
-		_v2x = v2.positionScreen.x; _v2y = v2.positionScreen.y;
-		_v3x = v3.positionScreen.x; _v3y = v3.positionScreen.y;
-
-		drawTriangle( _v1x, _v1y, _v2x, _v2y, _v3x, _v3y );
-
-		if ( ( material instanceof THREE.MeshLambertMaterial || material instanceof THREE.MeshPhongMaterial ) && material.map === null ) {
-
-			_diffuseColor.copy( material.color );
-			_emissiveColor.copy( material.emissive );
-
-			if ( material.vertexColors === THREE.FaceColors ) {
-
-				_diffuseColor.multiply( element.color );
-
-			}
-
-			_color.copy( _ambientLight );
-
-			_centroid.copy( v1.positionWorld ).add( v2.positionWorld ).add( v3.positionWorld ).divideScalar( 3 );
-
-			calculateLight( _centroid, element.normalModel, _color );
-
-			_color.multiply( _diffuseColor ).add( _emissiveColor );
-
-			material.wireframe === true
-				 ? strokePath( _color, material.wireframeLinewidth, material.wireframeLinecap, material.wireframeLinejoin )
-				 : fillPath( _color );
-
-		} else if ( material instanceof THREE.MeshBasicMaterial ||
-				    material instanceof THREE.MeshLambertMaterial ||
-				    material instanceof THREE.MeshPhongMaterial ) {
-
-			if ( material.map !== null ) {
-
-				var mapping = material.map.mapping;
-
-				if ( mapping === THREE.UVMapping ) {
-
-					_uvs = element.uvs;
-					patternPath( _v1x, _v1y, _v2x, _v2y, _v3x, _v3y, _uvs[ uv1 ].x, _uvs[ uv1 ].y, _uvs[ uv2 ].x, _uvs[ uv2 ].y, _uvs[ uv3 ].x, _uvs[ uv3 ].y, material.map );
-
-				}
-
-			} else if ( material.envMap !== null ) {
-
-				if ( material.envMap.mapping === THREE.SphericalReflectionMapping ) {
-
-					_normal.copy( element.vertexNormalsModel[ uv1 ] ).applyMatrix3( _normalViewMatrix );
-					_uv1x = 0.5 * _normal.x + 0.5;
-					_uv1y = 0.5 * _normal.y + 0.5;
-
-					_normal.copy( element.vertexNormalsModel[ uv2 ] ).applyMatrix3( _normalViewMatrix );
-					_uv2x = 0.5 * _normal.x + 0.5;
-					_uv2y = 0.5 * _normal.y + 0.5;
-
-					_normal.copy( element.vertexNormalsModel[ uv3 ] ).applyMatrix3( _normalViewMatrix );
-					_uv3x = 0.5 * _normal.x + 0.5;
-					_uv3y = 0.5 * _normal.y + 0.5;
-
-					patternPath( _v1x, _v1y, _v2x, _v2y, _v3x, _v3y, _uv1x, _uv1y, _uv2x, _uv2y, _uv3x, _uv3y, material.envMap );
-
-				}
-
-			} else {
-
-				_color.copy( material.color );
-
-				if ( material.vertexColors === THREE.FaceColors ) {
-
-					_color.multiply( element.color );
-
-				}
-
-				material.wireframe === true
-					 ? strokePath( _color, material.wireframeLinewidth, material.wireframeLinecap, material.wireframeLinejoin )
-					 : fillPath( _color );
-
-			}
-
-		} else if ( material instanceof THREE.MeshNormalMaterial ) {
-
-			_normal.copy( element.normalModel ).applyMatrix3( _normalViewMatrix );
-
-			_color.setRGB( _normal.x, _normal.y, _normal.z ).multiplyScalar( 0.5 ).addScalar( 0.5 );
-
-			material.wireframe === true
-				 ? strokePath( _color, material.wireframeLinewidth, material.wireframeLinecap, material.wireframeLinejoin )
-				 : fillPath( _color );
-
-		} else {
-
-			_color.setRGB( 1, 1, 1 );
-
-			material.wireframe === true
-				 ? strokePath( _color, material.wireframeLinewidth, material.wireframeLinecap, material.wireframeLinejoin )
-				 : fillPath( _color );
-
-		}
-
-	}
-
-	//
-
-	function drawTriangle( x0, y0, x1, y1, x2, y2 ) {
-
-		_context.beginPath();
-		_context.moveTo( x0, y0 );
-		_context.lineTo( x1, y1 );
-		_context.lineTo( x2, y2 );
-		_context.closePath();
-
-	}
-
-	function strokePath( color, linewidth, linecap, linejoin ) {
-
-		setLineWidth( linewidth );
-		setLineCap( linecap );
-		setLineJoin( linejoin );
-		setStrokeStyle( color.getStyle() );
-
-		_context.stroke();
-
-		_elemBox.expandByScalar( linewidth * 2 );
-
-	}
-
-	function fillPath( color ) {
-
-		setFillStyle( color.getStyle() );
-		_context.fill();
-
-	}
-
-	function textureToPattern( texture ) {
-
-		if ( texture.version === 0 ||
-			texture instanceof THREE.CompressedTexture ||
-			texture instanceof THREE.DataTexture ) {
-
-			return {
-				canvas: undefined,
-				version: texture.version
-			};
-
-		}
-
-		var image = texture.image;
-
-		if ( image.complete === false ) {
-
-			return {
-				canvas: undefined,
-				version: 0
-			};
-
-		}
-
-		var canvas = document.createElement( 'canvas' );
-		canvas.width = image.width;
-		canvas.height = image.height;
-
-		var context = canvas.getContext( '2d' );
-		context.setTransform( 1, 0, 0, - 1, 0, image.height );
-		context.drawImage( image, 0, 0 );
-
-		var repeatX = texture.wrapS === THREE.RepeatWrapping;
-		var repeatY = texture.wrapT === THREE.RepeatWrapping;
-
-		var repeat = 'no-repeat';
-
-		if ( repeatX === true && repeatY === true ) {
-
-			repeat = 'repeat';
-
-		} else if ( repeatX === true ) {
-
-			repeat = 'repeat-x';
-
-		} else if ( repeatY === true ) {
-
-			repeat = 'repeat-y';
-
-		}
-
-		var pattern = _context.createPattern( canvas, repeat );
-
-		if ( texture.onUpdate ) texture.onUpdate( texture );
-
-		return {
-			canvas: pattern,
-			version: texture.version
-		};
-
-	}
-
-	function patternPath( x0, y0, x1, y1, x2, y2, u0, v0, u1, v1, u2, v2, texture ) {
-
-		var pattern = _patterns[ texture.id ];
-
-		if ( pattern === undefined || pattern.version !== texture.version ) {
-
-			pattern = textureToPattern( texture );
-			_patterns[ texture.id ] = pattern;
-
-		}
-
-		if ( pattern.canvas !== undefined ) {
-
-			setFillStyle( pattern.canvas );
-
-		} else {
-
-			setFillStyle( 'rgba( 0, 0, 0, 1)' );
-			_context.fill();
-			return;
-
-		}
-
-		// http://extremelysatisfactorytotalitarianism.com/blog/?p=2120
-
-		var a, b, c, d, e, f, det, idet,
-		offsetX = texture.offset.x / texture.repeat.x,
-		offsetY = texture.offset.y / texture.repeat.y,
-		width = texture.image.width * texture.repeat.x,
-		height = texture.image.height * texture.repeat.y;
-
-		u0 = ( u0 + offsetX ) * width;
-		v0 = ( v0 + offsetY ) * height;
-
-		u1 = ( u1 + offsetX ) * width;
-		v1 = ( v1 + offsetY ) * height;
-
-		u2 = ( u2 + offsetX ) * width;
-		v2 = ( v2 + offsetY ) * height;
-
-		x1 -= x0; y1 -= y0;
-		x2 -= x0; y2 -= y0;
-
-		u1 -= u0; v1 -= v0;
-		u2 -= u0; v2 -= v0;
-
-		det = u1 * v2 - u2 * v1;
-
-		if ( det === 0 ) return;
-
-		idet = 1 / det;
-
-		a = ( v2 * x1 - v1 * x2 ) * idet;
-		b = ( v2 * y1 - v1 * y2 ) * idet;
-		c = ( u1 * x2 - u2 * x1 ) * idet;
-		d = ( u1 * y2 - u2 * y1 ) * idet;
-
-		e = x0 - a * u0 - c * v0;
-		f = y0 - b * u0 - d * v0;
-
-		_context.save();
-		_context.transform( a, b, c, d, e, f );
-		_context.fill();
-		_context.restore();
-
-	}
-
-	function clipImage( x0, y0, x1, y1, x2, y2, u0, v0, u1, v1, u2, v2, image ) {
-
-		// http://extremelysatisfactorytotalitarianism.com/blog/?p=2120
-
-		var a, b, c, d, e, f, det, idet,
-		width = image.width - 1,
-		height = image.height - 1;
-
-		u0 *= width; v0 *= height;
-		u1 *= width; v1 *= height;
-		u2 *= width; v2 *= height;
-
-		x1 -= x0; y1 -= y0;
-		x2 -= x0; y2 -= y0;
-
-		u1 -= u0; v1 -= v0;
-		u2 -= u0; v2 -= v0;
-
-		det = u1 * v2 - u2 * v1;
-
-		idet = 1 / det;
-
-		a = ( v2 * x1 - v1 * x2 ) * idet;
-		b = ( v2 * y1 - v1 * y2 ) * idet;
-		c = ( u1 * x2 - u2 * x1 ) * idet;
-		d = ( u1 * y2 - u2 * y1 ) * idet;
-
-		e = x0 - a * u0 - c * v0;
-		f = y0 - b * u0 - d * v0;
-
-		_context.save();
-		_context.transform( a, b, c, d, e, f );
-		_context.clip();
-		_context.drawImage( image, 0, 0 );
-		_context.restore();
-
-	}
-
-	// Hide anti-alias gaps
-
-	function expand( v1, v2, pixels ) {
-
-		var x = v2.x - v1.x, y = v2.y - v1.y,
-		det = x * x + y * y, idet;
-
-		if ( det === 0 ) return;
-
-		idet = pixels / Math.sqrt( det );
-
-		x *= idet; y *= idet;
-
-		v2.x += x; v2.y += y;
-		v1.x -= x; v1.y -= y;
-
-	}
-
-	// Context cached methods.
-
-	function setOpacity( value ) {
-
-		if ( _contextGlobalAlpha !== value ) {
-
-			_context.globalAlpha = value;
-			_contextGlobalAlpha = value;
-
-		}
-
-	}
-
-	function setBlending( value ) {
-
-		if ( _contextGlobalCompositeOperation !== value ) {
-
-			if ( value === THREE.NormalBlending ) {
-
-				_context.globalCompositeOperation = 'source-over';
-
-			} else if ( value === THREE.AdditiveBlending ) {
-
-				_context.globalCompositeOperation = 'lighter';
-
-			} else if ( value === THREE.SubtractiveBlending ) {
-
-				_context.globalCompositeOperation = 'darker';
-
-			}
-
-			_contextGlobalCompositeOperation = value;
-
-		}
-
-	}
-
-	function setLineWidth( value ) {
-
-		if ( _contextLineWidth !== value ) {
-
-			_context.lineWidth = value;
-			_contextLineWidth = value;
-
-		}
-
-	}
-
-	function setLineCap( value ) {
-
-		// "butt", "round", "square"
-
-		if ( _contextLineCap !== value ) {
-
-			_context.lineCap = value;
-			_contextLineCap = value;
-
-		}
-
-	}
-
-	function setLineJoin( value ) {
-
-		// "round", "bevel", "miter"
-
-		if ( _contextLineJoin !== value ) {
-
-			_context.lineJoin = value;
-			_contextLineJoin = value;
-
-		}
-
-	}
-
-	function setStrokeStyle( value ) {
-
-		if ( _contextStrokeStyle !== value ) {
-
-			_context.strokeStyle = value;
-			_contextStrokeStyle = value;
-
-		}
-
-	}
-
-	function setFillStyle( value ) {
-
-		if ( _contextFillStyle !== value ) {
-
-			_context.fillStyle = value;
-			_contextFillStyle = value;
-
-		}
-
-	}
-
-	function setLineDash( value ) {
-
-		if ( _contextLineDash.length !== value.length ) {
-
-			_context.setLineDash( value );
-			_contextLineDash = value;
-
-		}
-
-	}
-
-};
diff --git a/html/js/three/renderers/Projector.js b/html/js/three/renderers/Projector.js
deleted file mode 100755
index c05f56b..0000000
--- a/html/js/three/renderers/Projector.js
+++ /dev/null
@@ -1,921 +0,0 @@
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author supereggbert / http://www.paulbrunt.co.uk/
- * @author julianwa / https://github.com/julianwa
- */
-
-THREE.RenderableObject = function () {
-
-	this.id = 0;
-
-	this.object = null;
-	this.z = 0;
-	this.renderOrder = 0;
-
-};
-
-//
-
-THREE.RenderableFace = function () {
-
-	this.id = 0;
-
-	this.v1 = new THREE.RenderableVertex();
-	this.v2 = new THREE.RenderableVertex();
-	this.v3 = new THREE.RenderableVertex();
-
-	this.normalModel = new THREE.Vector3();
-
-	this.vertexNormalsModel = [ new THREE.Vector3(), new THREE.Vector3(), new THREE.Vector3() ];
-	this.vertexNormalsLength = 0;
-
-	this.color = new THREE.Color();
-	this.material = null;
-	this.uvs = [ new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2() ];
-
-	this.z = 0;
-	this.renderOrder = 0;
-
-};
-
-//
-
-THREE.RenderableVertex = function () {
-
-	this.position = new THREE.Vector3();
-	this.positionWorld = new THREE.Vector3();
-	this.positionScreen = new THREE.Vector4();
-
-	this.visible = true;
-
-};
-
-THREE.RenderableVertex.prototype.copy = function ( vertex ) {
-
-	this.positionWorld.copy( vertex.positionWorld );
-	this.positionScreen.copy( vertex.positionScreen );
-
-};
-
-//
-
-THREE.RenderableLine = function () {
-
-	this.id = 0;
-
-	this.v1 = new THREE.RenderableVertex();
-	this.v2 = new THREE.RenderableVertex();
-
-	this.vertexColors = [ new THREE.Color(), new THREE.Color() ];
-	this.material = null;
-
-	this.z = 0;
-	this.renderOrder = 0;
-
-};
-
-//
-
-THREE.RenderableSprite = function () {
-
-	this.id = 0;
-
-	this.object = null;
-
-	this.x = 0;
-	this.y = 0;
-	this.z = 0;
-
-	this.rotation = 0;
-	this.scale = new THREE.Vector2();
-
-	this.material = null;
-	this.renderOrder = 0;
-
-};
-
-//
-
-THREE.Projector = function () {
-
-	var _object, _objectCount, _objectPool = [], _objectPoolLength = 0,
-	_vertex, _vertexCount, _vertexPool = [], _vertexPoolLength = 0,
-	_face, _faceCount, _facePool = [], _facePoolLength = 0,
-	_line, _lineCount, _linePool = [], _linePoolLength = 0,
-	_sprite, _spriteCount, _spritePool = [], _spritePoolLength = 0,
-
-	_renderData = { objects: [], lights: [], elements: [] },
-
-	_vector3 = new THREE.Vector3(),
-	_vector4 = new THREE.Vector4(),
-
-	_clipBox = new THREE.Box3( new THREE.Vector3( - 1, - 1, - 1 ), new THREE.Vector3( 1, 1, 1 ) ),
-	_boundingBox = new THREE.Box3(),
-	_points3 = new Array( 3 ),
-	_points4 = new Array( 4 ),
-
-	_viewMatrix = new THREE.Matrix4(),
-	_viewProjectionMatrix = new THREE.Matrix4(),
-
-	_modelMatrix,
-	_modelViewProjectionMatrix = new THREE.Matrix4(),
-
-	_normalMatrix = new THREE.Matrix3(),
-
-	_frustum = new THREE.Frustum(),
-
-	_clippedVertex1PositionScreen = new THREE.Vector4(),
-	_clippedVertex2PositionScreen = new THREE.Vector4();
-
-	//
-
-	this.projectVector = function ( vector, camera ) {
-
-		console.warn( 'THREE.Projector: .projectVector() is now vector.project().' );
-		vector.project( camera );
-
-	};
-
-	this.unprojectVector = function ( vector, camera ) {
-
-		console.warn( 'THREE.Projector: .unprojectVector() is now vector.unproject().' );
-		vector.unproject( camera );
-
-	};
-
-	this.pickingRay = function ( vector, camera ) {
-
-		console.error( 'THREE.Projector: .pickingRay() is now raycaster.setFromCamera().' );
-
-	};
-
-	//
-
-	var RenderList = function () {
-
-		var normals = [];
-		var uvs = [];
-
-		var object = null;
-		var material = null;
-
-		var normalMatrix = new THREE.Matrix3();
-
-		function setObject( value ) {
-
-			object = value;
-			material = object.material;
-
-			normalMatrix.getNormalMatrix( object.matrixWorld );
-
-			normals.length = 0;
-			uvs.length = 0;
-
-		}
-
-		function projectVertex( vertex ) {
-
-			var position = vertex.position;
-			var positionWorld = vertex.positionWorld;
-			var positionScreen = vertex.positionScreen;
-
-			positionWorld.copy( position ).applyMatrix4( _modelMatrix );
-			positionScreen.copy( positionWorld ).applyMatrix4( _viewProjectionMatrix );
-
-			var invW = 1 / positionScreen.w;
-
-			positionScreen.x *= invW;
-			positionScreen.y *= invW;
-			positionScreen.z *= invW;
-
-			vertex.visible = positionScreen.x >= - 1 && positionScreen.x <= 1 &&
-					 positionScreen.y >= - 1 && positionScreen.y <= 1 &&
-					 positionScreen.z >= - 1 && positionScreen.z <= 1;
-
-		}
-
-		function pushVertex( x, y, z ) {
-
-			_vertex = getNextVertexInPool();
-			_vertex.position.set( x, y, z );
-
-			projectVertex( _vertex );
-
-		}
-
-		function pushNormal( x, y, z ) {
-
-			normals.push( x, y, z );
-
-		}
-
-		function pushUv( x, y ) {
-
-			uvs.push( x, y );
-
-		}
-
-		function checkTriangleVisibility( v1, v2, v3 ) {
-
-			if ( v1.visible === true || v2.visible === true || v3.visible === true ) return true;
-
-			_points3[ 0 ] = v1.positionScreen;
-			_points3[ 1 ] = v2.positionScreen;
-			_points3[ 2 ] = v3.positionScreen;
-
-			return _clipBox.intersectsBox( _boundingBox.setFromPoints( _points3 ) );
-
-		}
-
-		function checkBackfaceCulling( v1, v2, v3 ) {
-
-			return ( ( v3.positionScreen.x - v1.positionScreen.x ) *
-				    ( v2.positionScreen.y - v1.positionScreen.y ) -
-				    ( v3.positionScreen.y - v1.positionScreen.y ) *
-				    ( v2.positionScreen.x - v1.positionScreen.x ) ) < 0;
-
-		}
-
-		function pushLine( a, b ) {
-
-			var v1 = _vertexPool[ a ];
-			var v2 = _vertexPool[ b ];
-
-			_line = getNextLineInPool();
-
-			_line.id = object.id;
-			_line.v1.copy( v1 );
-			_line.v2.copy( v2 );
-			_line.z = ( v1.positionScreen.z + v2.positionScreen.z ) / 2;
-			_line.renderOrder = object.renderOrder;
-
-			_line.material = object.material;
-
-			_renderData.elements.push( _line );
-
-		}
-
-		function pushTriangle( a, b, c ) {
-
-			var v1 = _vertexPool[ a ];
-			var v2 = _vertexPool[ b ];
-			var v3 = _vertexPool[ c ];
-
-			if ( checkTriangleVisibility( v1, v2, v3 ) === false ) return;
-
-			if ( material.side === THREE.DoubleSide || checkBackfaceCulling( v1, v2, v3 ) === true ) {
-
-				_face = getNextFaceInPool();
-
-				_face.id = object.id;
-				_face.v1.copy( v1 );
-				_face.v2.copy( v2 );
-				_face.v3.copy( v3 );
-				_face.z = ( v1.positionScreen.z + v2.positionScreen.z + v3.positionScreen.z ) / 3;
-				_face.renderOrder = object.renderOrder;
-
-				// use first vertex normal as face normal
-
-				_face.normalModel.fromArray( normals, a * 3 );
-				_face.normalModel.applyMatrix3( normalMatrix ).normalize();
-
-				for ( var i = 0; i < 3; i ++ ) {
-
-					var normal = _face.vertexNormalsModel[ i ];
-					normal.fromArray( normals, arguments[ i ] * 3 );
-					normal.applyMatrix3( normalMatrix ).normalize();
-
-					var uv = _face.uvs[ i ];
-					uv.fromArray( uvs, arguments[ i ] * 2 );
-
-				}
-
-				_face.vertexNormalsLength = 3;
-
-				_face.material = object.material;
-
-				_renderData.elements.push( _face );
-
-			}
-
-		}
-
-		return {
-			setObject: setObject,
-			projectVertex: projectVertex,
-			checkTriangleVisibility: checkTriangleVisibility,
-			checkBackfaceCulling: checkBackfaceCulling,
-			pushVertex: pushVertex,
-			pushNormal: pushNormal,
-			pushUv: pushUv,
-			pushLine: pushLine,
-			pushTriangle: pushTriangle
-		}
-
-	};
-
-	var renderList = new RenderList();
-
-	this.projectScene = function ( scene, camera, sortObjects, sortElements ) {
-
-		_faceCount = 0;
-		_lineCount = 0;
-		_spriteCount = 0;
-
-		_renderData.elements.length = 0;
-
-		if ( scene.autoUpdate === true ) scene.updateMatrixWorld();
-		if ( camera.parent === null ) camera.updateMatrixWorld();
-
-		_viewMatrix.copy( camera.matrixWorldInverse.getInverse( camera.matrixWorld ) );
-		_viewProjectionMatrix.multiplyMatrices( camera.projectionMatrix, _viewMatrix );
-
-		_frustum.setFromMatrix( _viewProjectionMatrix );
-
-		//
-
-		_objectCount = 0;
-
-		_renderData.objects.length = 0;
-		_renderData.lights.length = 0;
-
-		scene.traverseVisible( function ( object ) {
-
-			if ( object instanceof THREE.Light ) {
-
-				_renderData.lights.push( object );
-
-			} else if ( object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Sprite ) {
-
-				var material = object.material;
-
-				if ( material.visible === false ) return;
-
-				if ( object.frustumCulled === false || _frustum.intersectsObject( object ) === true ) {
-
-					_object = getNextObjectInPool();
-					_object.id = object.id;
-					_object.object = object;
-
-					_vector3.setFromMatrixPosition( object.matrixWorld );
-					_vector3.applyProjection( _viewProjectionMatrix );
-					_object.z = _vector3.z;
-					_object.renderOrder = object.renderOrder;
-
-					_renderData.objects.push( _object );
-
-				}
-
-			}
-
-		} );
-
-		if ( sortObjects === true ) {
-
-			_renderData.objects.sort( painterSort );
-
-		}
-
-		//
-
-		for ( var o = 0, ol = _renderData.objects.length; o < ol; o ++ ) {
-
-			var object = _renderData.objects[ o ].object;
-			var geometry = object.geometry;
-
-			renderList.setObject( object );
-
-			_modelMatrix = object.matrixWorld;
-
-			_vertexCount = 0;
-
-			if ( object instanceof THREE.Mesh ) {
-
-				if ( geometry instanceof THREE.BufferGeometry ) {
-
-					var attributes = geometry.attributes;
-					var groups = geometry.groups;
-
-					if ( attributes.position === undefined ) continue;
-
-					var positions = attributes.position.array;
-
-					for ( var i = 0, l = positions.length; i < l; i += 3 ) {
-
-						renderList.pushVertex( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] );
-
-					}
-
-					if ( attributes.normal !== undefined ) {
-
-						var normals = attributes.normal.array;
-
-						for ( var i = 0, l = normals.length; i < l; i += 3 ) {
-
-							renderList.pushNormal( normals[ i ], normals[ i + 1 ], normals[ i + 2 ] );
-
-						}
-
-					}
-
-					if ( attributes.uv !== undefined ) {
-
-						var uvs = attributes.uv.array;
-
-						for ( var i = 0, l = uvs.length; i < l; i += 2 ) {
-
-							renderList.pushUv( uvs[ i ], uvs[ i + 1 ] );
-
-						}
-
-					}
-
-					if ( geometry.index !== null ) {
-
-						var indices = geometry.index.array;
-
-						if ( groups.length > 0 ) {
-
-							for ( var o = 0; o < groups.length; o ++ ) {
-
-								var group = groups[ o ];
-
-								for ( var i = group.start, l = group.start + group.count; i < l; i += 3 ) {
-
-									renderList.pushTriangle( indices[ i ], indices[ i + 1 ], indices[ i + 2 ] );
-
-								}
-
-							}
-
-						} else {
-
-							for ( var i = 0, l = indices.length; i < l; i += 3 ) {
-
-								renderList.pushTriangle( indices[ i ], indices[ i + 1 ], indices[ i + 2 ] );
-
-							}
-
-						}
-
-					} else {
-
-						for ( var i = 0, l = positions.length / 3; i < l; i += 3 ) {
-
-							renderList.pushTriangle( i, i + 1, i + 2 );
-
-						}
-
-					}
-
-				} else if ( geometry instanceof THREE.Geometry ) {
-
-					var vertices = geometry.vertices;
-					var faces = geometry.faces;
-					var faceVertexUvs = geometry.faceVertexUvs[ 0 ];
-
-					_normalMatrix.getNormalMatrix( _modelMatrix );
-
-					var material = object.material;
-
-					var isFaceMaterial = material instanceof THREE.MultiMaterial;
-					var objectMaterials = isFaceMaterial === true ? object.material : null;
-
-					for ( var v = 0, vl = vertices.length; v < vl; v ++ ) {
-
-						var vertex = vertices[ v ];
-
-						_vector3.copy( vertex );
-
-						if ( material.morphTargets === true ) {
-
-							var morphTargets = geometry.morphTargets;
-							var morphInfluences = object.morphTargetInfluences;
-
-							for ( var t = 0, tl = morphTargets.length; t < tl; t ++ ) {
-
-								var influence = morphInfluences[ t ];
-
-								if ( influence === 0 ) continue;
-
-								var target = morphTargets[ t ];
-								var targetVertex = target.vertices[ v ];
-
-								_vector3.x += ( targetVertex.x - vertex.x ) * influence;
-								_vector3.y += ( targetVertex.y - vertex.y ) * influence;
-								_vector3.z += ( targetVertex.z - vertex.z ) * influence;
-
-							}
-
-						}
-
-						renderList.pushVertex( _vector3.x, _vector3.y, _vector3.z );
-
-					}
-
-					for ( var f = 0, fl = faces.length; f < fl; f ++ ) {
-
-						var face = faces[ f ];
-
-						material = isFaceMaterial === true
-							 ? objectMaterials.materials[ face.materialIndex ]
-							 : object.material;
-
-						if ( material === undefined ) continue;
-
-						var side = material.side;
-
-						var v1 = _vertexPool[ face.a ];
-						var v2 = _vertexPool[ face.b ];
-						var v3 = _vertexPool[ face.c ];
-
-						if ( renderList.checkTriangleVisibility( v1, v2, v3 ) === false ) continue;
-
-						var visible = renderList.checkBackfaceCulling( v1, v2, v3 );
-
-						if ( side !== THREE.DoubleSide ) {
-
-							if ( side === THREE.FrontSide && visible === false ) continue;
-							if ( side === THREE.BackSide && visible === true ) continue;
-
-						}
-
-						_face = getNextFaceInPool();
-
-						_face.id = object.id;
-						_face.v1.copy( v1 );
-						_face.v2.copy( v2 );
-						_face.v3.copy( v3 );
-
-						_face.normalModel.copy( face.normal );
-
-						if ( visible === false && ( side === THREE.BackSide || side === THREE.DoubleSide ) ) {
-
-							_face.normalModel.negate();
-
-						}
-
-						_face.normalModel.applyMatrix3( _normalMatrix ).normalize();
-
-						var faceVertexNormals = face.vertexNormals;
-
-						for ( var n = 0, nl = Math.min( faceVertexNormals.length, 3 ); n < nl; n ++ ) {
-
-							var normalModel = _face.vertexNormalsModel[ n ];
-							normalModel.copy( faceVertexNormals[ n ] );
-
-							if ( visible === false && ( side === THREE.BackSide || side === THREE.DoubleSide ) ) {
-
-								normalModel.negate();
-
-							}
-
-							normalModel.applyMatrix3( _normalMatrix ).normalize();
-
-						}
-
-						_face.vertexNormalsLength = faceVertexNormals.length;
-
-						var vertexUvs = faceVertexUvs[ f ];
-
-						if ( vertexUvs !== undefined ) {
-
-							for ( var u = 0; u < 3; u ++ ) {
-
-								_face.uvs[ u ].copy( vertexUvs[ u ] );
-
-							}
-
-						}
-
-						_face.color = face.color;
-						_face.material = material;
-
-						_face.z = ( v1.positionScreen.z + v2.positionScreen.z + v3.positionScreen.z ) / 3;
-						_face.renderOrder = object.renderOrder;
-
-						_renderData.elements.push( _face );
-
-					}
-
-				}
-
-			} else if ( object instanceof THREE.Line ) {
-
-				if ( geometry instanceof THREE.BufferGeometry ) {
-
-					var attributes = geometry.attributes;
-
-					if ( attributes.position !== undefined ) {
-
-						var positions = attributes.position.array;
-
-						for ( var i = 0, l = positions.length; i < l; i += 3 ) {
-
-							renderList.pushVertex( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] );
-
-						}
-
-						if ( geometry.index !== null ) {
-
-							var indices = geometry.index.array;
-
-							for ( var i = 0, l = indices.length; i < l; i += 2 ) {
-
-								renderList.pushLine( indices[ i ], indices[ i + 1 ] );
-
-							}
-
-						} else {
-
-							var step = object instanceof THREE.LineSegments ? 2 : 1;
-
-							for ( var i = 0, l = ( positions.length / 3 ) - 1; i < l; i += step ) {
-
-								renderList.pushLine( i, i + 1 );
-
-							}
-
-						}
-
-					}
-
-				} else if ( geometry instanceof THREE.Geometry ) {
-
-					_modelViewProjectionMatrix.multiplyMatrices( _viewProjectionMatrix, _modelMatrix );
-
-					var vertices = object.geometry.vertices;
-
-					if ( vertices.length === 0 ) continue;
-
-					v1 = getNextVertexInPool();
-					v1.positionScreen.copy( vertices[ 0 ] ).applyMatrix4( _modelViewProjectionMatrix );
-
-					var step = object instanceof THREE.LineSegments ? 2 : 1;
-
-					for ( var v = 1, vl = vertices.length; v < vl; v ++ ) {
-
-						v1 = getNextVertexInPool();
-						v1.positionScreen.copy( vertices[ v ] ).applyMatrix4( _modelViewProjectionMatrix );
-
-						if ( ( v + 1 ) % step > 0 ) continue;
-
-						v2 = _vertexPool[ _vertexCount - 2 ];
-
-						_clippedVertex1PositionScreen.copy( v1.positionScreen );
-						_clippedVertex2PositionScreen.copy( v2.positionScreen );
-
-						if ( clipLine( _clippedVertex1PositionScreen, _clippedVertex2PositionScreen ) === true ) {
-
-							// Perform the perspective divide
-							_clippedVertex1PositionScreen.multiplyScalar( 1 / _clippedVertex1PositionScreen.w );
-							_clippedVertex2PositionScreen.multiplyScalar( 1 / _clippedVertex2PositionScreen.w );
-
-							_line = getNextLineInPool();
-
-							_line.id = object.id;
-							_line.v1.positionScreen.copy( _clippedVertex1PositionScreen );
-							_line.v2.positionScreen.copy( _clippedVertex2PositionScreen );
-
-							_line.z = Math.max( _clippedVertex1PositionScreen.z, _clippedVertex2PositionScreen.z );
-							_line.renderOrder = object.renderOrder;
-
-							_line.material = object.material;
-
-							if ( object.material.vertexColors === THREE.VertexColors ) {
-
-								_line.vertexColors[ 0 ].copy( object.geometry.colors[ v ] );
-								_line.vertexColors[ 1 ].copy( object.geometry.colors[ v - 1 ] );
-
-							}
-
-							_renderData.elements.push( _line );
-
-						}
-
-					}
-
-				}
-
-			} else if ( object instanceof THREE.Sprite ) {
-
-				_vector4.set( _modelMatrix.elements[ 12 ], _modelMatrix.elements[ 13 ], _modelMatrix.elements[ 14 ], 1 );
-				_vector4.applyMatrix4( _viewProjectionMatrix );
-
-				var invW = 1 / _vector4.w;
-
-				_vector4.z *= invW;
-
-				if ( _vector4.z >= - 1 && _vector4.z <= 1 ) {
-
-					_sprite = getNextSpriteInPool();
-					_sprite.id = object.id;
-					_sprite.x = _vector4.x * invW;
-					_sprite.y = _vector4.y * invW;
-					_sprite.z = _vector4.z;
-					_sprite.renderOrder = object.renderOrder;
-					_sprite.object = object;
-
-					_sprite.rotation = object.rotation;
-
-					_sprite.scale.x = object.scale.x * Math.abs( _sprite.x - ( _vector4.x + camera.projectionMatrix.elements[ 0 ] ) / ( _vector4.w + camera.projectionMatrix.elements[ 12 ] ) );
-					_sprite.scale.y = object.scale.y * Math.abs( _sprite.y - ( _vector4.y + camera.projectionMatrix.elements[ 5 ] ) / ( _vector4.w + camera.projectionMatrix.elements[ 13 ] ) );
-
-					_sprite.material = object.material;
-
-					_renderData.elements.push( _sprite );
-
-				}
-
-			}
-
-		}
-
-		if ( sortElements === true ) {
-
-			_renderData.elements.sort( painterSort );
-
-		}
-
-		return _renderData;
-
-	};
-
-	// Pools
-
-	function getNextObjectInPool() {
-
-		if ( _objectCount === _objectPoolLength ) {
-
-			var object = new THREE.RenderableObject();
-			_objectPool.push( object );
-			_objectPoolLength ++;
-			_objectCount ++;
-			return object;
-
-		}
-
-		return _objectPool[ _objectCount ++ ];
-
-	}
-
-	function getNextVertexInPool() {
-
-		if ( _vertexCount === _vertexPoolLength ) {
-
-			var vertex = new THREE.RenderableVertex();
-			_vertexPool.push( vertex );
-			_vertexPoolLength ++;
-			_vertexCount ++;
-			return vertex;
-
-		}
-
-		return _vertexPool[ _vertexCount ++ ];
-
-	}
-
-	function getNextFaceInPool() {
-
-		if ( _faceCount === _facePoolLength ) {
-
-			var face = new THREE.RenderableFace();
-			_facePool.push( face );
-			_facePoolLength ++;
-			_faceCount ++;
-			return face;
-
-		}
-
-		return _facePool[ _faceCount ++ ];
-
-
-	}
-
-	function getNextLineInPool() {
-
-		if ( _lineCount === _linePoolLength ) {
-
-			var line = new THREE.RenderableLine();
-			_linePool.push( line );
-			_linePoolLength ++;
-			_lineCount ++;
-			return line;
-
-		}
-
-		return _linePool[ _lineCount ++ ];
-
-	}
-
-	function getNextSpriteInPool() {
-
-		if ( _spriteCount === _spritePoolLength ) {
-
-			var sprite = new THREE.RenderableSprite();
-			_spritePool.push( sprite );
-			_spritePoolLength ++;
-			_spriteCount ++;
-			return sprite;
-
-		}
-
-		return _spritePool[ _spriteCount ++ ];
-
-	}
-
-	//
-
-	function painterSort( a, b ) {
-
-		if ( a.renderOrder !== b.renderOrder ) {
-
-			return a.renderOrder - b.renderOrder;
-
-		} else if ( a.z !== b.z ) {
-
-			return b.z - a.z;
-
-		} else if ( a.id !== b.id ) {
-
-			return a.id - b.id;
-
-		} else {
-
-			return 0;
-
-		}
-
-	}
-
-	function clipLine( s1, s2 ) {
-
-		var alpha1 = 0, alpha2 = 1,
-
-		// Calculate the boundary coordinate of each vertex for the near and far clip planes,
-		// Z = -1 and Z = +1, respectively.
-		bc1near =  s1.z + s1.w,
-		bc2near =  s2.z + s2.w,
-		bc1far =  - s1.z + s1.w,
-		bc2far =  - s2.z + s2.w;
-
-		if ( bc1near >= 0 && bc2near >= 0 && bc1far >= 0 && bc2far >= 0 ) {
-
-			// Both vertices lie entirely within all clip planes.
-			return true;
-
-		} else if ( ( bc1near < 0 && bc2near < 0 ) || ( bc1far < 0 && bc2far < 0 ) ) {
-
-			// Both vertices lie entirely outside one of the clip planes.
-			return false;
-
-		} else {
-
-			// The line segment spans at least one clip plane.
-
-			if ( bc1near < 0 ) {
-
-				// v1 lies outside the near plane, v2 inside
-				alpha1 = Math.max( alpha1, bc1near / ( bc1near - bc2near ) );
-
-			} else if ( bc2near < 0 ) {
-
-				// v2 lies outside the near plane, v1 inside
-				alpha2 = Math.min( alpha2, bc1near / ( bc1near - bc2near ) );
-
-			}
-
-			if ( bc1far < 0 ) {
-
-				// v1 lies outside the far plane, v2 inside
-				alpha1 = Math.max( alpha1, bc1far / ( bc1far - bc2far ) );
-
-			} else if ( bc2far < 0 ) {
-
-				// v2 lies outside the far plane, v2 inside
-				alpha2 = Math.min( alpha2, bc1far / ( bc1far - bc2far ) );
-
-			}
-
-			if ( alpha2 < alpha1 ) {
-
-				// The line segment spans two boundaries, but is outside both of them.
-				// (This can't happen when we're only clipping against just near/far but good
-				//  to leave the check here for future usage if other clip planes are added.)
-				return false;
-
-			} else {
-
-				// Update the s1 and s2 vertices to match the clipped line segment.
-				s1.lerp( s2, alpha1 );
-				s2.lerp( s1, 1 - alpha2 );
-
-				return true;
-
-			}
-
-		}
-
-	}
-
-};
diff --git a/html/js/three/three.js b/html/js/three/three.js
deleted file mode 100755
index 6756092..0000000
--- a/html/js/three/three.js
+++ /dev/null
@@ -1,41507 +0,0 @@
-// File:src/Three.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-var THREE = { REVISION: '76' };
-
-//
-
-if ( typeof define === 'function' && define.amd ) {
-
-	define( 'three', THREE );
-
-} else if ( 'undefined' !== typeof exports && 'undefined' !== typeof module ) {
-
-	module.exports = THREE;
-
-}
-
-//
-
-if ( Number.EPSILON === undefined ) {
-
-	Number.EPSILON = Math.pow( 2, - 52 );
-
-}
-
-//
-
-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 > 0 ) ? 1 : + x;
-
-	};
-
-}
-
-if ( Function.prototype.name === undefined && Object.defineProperty !== undefined ) {
-
-	// Missing in IE9-11.
-	// 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*)\s*\(/ )[ 1 ];
-
-		}
-
-	} );
-
-}
-
-if ( Object.assign === undefined ) {
-
-	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
-
-	Object.defineProperty( Object, 'assign', {
-
-		writable: true,
-		configurable: true,
-
-		value: function ( target ) {
-
-			'use strict';
-
-			if ( target === undefined || target === null ) {
-
-				throw new TypeError( "Cannot convert first argument to object" );
-
-			}
-
-			var to = Object( target );
-
-			for ( var i = 1, n = arguments.length; i !== n; ++ i ) {
-
-				var nextSource = arguments[ i ];
-
-				if ( nextSource === undefined || nextSource === null ) continue;
-
-				nextSource = Object( nextSource );
-
-				var keysArray = Object.keys( nextSource );
-
-				for ( var nextIndex = 0, len = keysArray.length; nextIndex !== len; ++ nextIndex ) {
-
-					var nextKey = keysArray[ nextIndex ];
-					var desc = Object.getOwnPropertyDescriptor( nextSource, nextKey );
-
-					if ( desc !== undefined && desc.enumerable ) {
-
-						to[ nextKey ] = nextSource[ nextKey ];
-
-					}
-
-				}
-
-			}
-
-			return to;
-
-		}
-
-	} );
-
-}
-
-// https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent.button
-
-THREE.MOUSE = { LEFT: 0, MIDDLE: 1, RIGHT: 2 };
-
-// GL STATE CONSTANTS
-
-THREE.CullFaceNone = 0;
-THREE.CullFaceBack = 1;
-THREE.CullFaceFront = 2;
-THREE.CullFaceFrontBack = 3;
-
-THREE.FrontFaceDirectionCW = 0;
-THREE.FrontFaceDirectionCCW = 1;
-
-// SHADOWING TYPES
-
-THREE.BasicShadowMap = 0;
-THREE.PCFShadowMap = 1;
-THREE.PCFSoftShadowMap = 2;
-
-// MATERIAL CONSTANTS
-
-// side
-
-THREE.FrontSide = 0;
-THREE.BackSide = 1;
-THREE.DoubleSide = 2;
-
-// shading
-
-THREE.FlatShading = 1;
-THREE.SmoothShading = 2;
-
-// colors
-
-THREE.NoColors = 0;
-THREE.FaceColors = 1;
-THREE.VertexColors = 2;
-
-// blending modes
-
-THREE.NoBlending = 0;
-THREE.NormalBlending = 1;
-THREE.AdditiveBlending = 2;
-THREE.SubtractiveBlending = 3;
-THREE.MultiplyBlending = 4;
-THREE.CustomBlending = 5;
-
-// custom blending equations
-// (numbers start from 100 not to clash with other
-// mappings to OpenGL constants defined in Texture.js)
-
-THREE.AddEquation = 100;
-THREE.SubtractEquation = 101;
-THREE.ReverseSubtractEquation = 102;
-THREE.MinEquation = 103;
-THREE.MaxEquation = 104;
-
-// custom blending destination factors
-
-THREE.ZeroFactor = 200;
-THREE.OneFactor = 201;
-THREE.SrcColorFactor = 202;
-THREE.OneMinusSrcColorFactor = 203;
-THREE.SrcAlphaFactor = 204;
-THREE.OneMinusSrcAlphaFactor = 205;
-THREE.DstAlphaFactor = 206;
-THREE.OneMinusDstAlphaFactor = 207;
-
-// custom blending source factors
-
-//THREE.ZeroFactor = 200;
-//THREE.OneFactor = 201;
-//THREE.SrcAlphaFactor = 204;
-//THREE.OneMinusSrcAlphaFactor = 205;
-//THREE.DstAlphaFactor = 206;
-//THREE.OneMinusDstAlphaFactor = 207;
-THREE.DstColorFactor = 208;
-THREE.OneMinusDstColorFactor = 209;
-THREE.SrcAlphaSaturateFactor = 210;
-
-// depth modes
-
-THREE.NeverDepth = 0;
-THREE.AlwaysDepth = 1;
-THREE.LessDepth = 2;
-THREE.LessEqualDepth = 3;
-THREE.EqualDepth = 4;
-THREE.GreaterEqualDepth = 5;
-THREE.GreaterDepth = 6;
-THREE.NotEqualDepth = 7;
-
-
-// TEXTURE CONSTANTS
-
-THREE.MultiplyOperation = 0;
-THREE.MixOperation = 1;
-THREE.AddOperation = 2;
-
-// Tone Mapping modes
-
-THREE.NoToneMapping = 0; // do not do any tone mapping, not even exposure (required for special purpose passes.)
-THREE.LinearToneMapping = 1; // only apply exposure.
-THREE.ReinhardToneMapping = 2;
-THREE.Uncharted2ToneMapping = 3; // John Hable
-THREE.CineonToneMapping = 4;  // optimized filmic operator by Jim Hejl and Richard Burgess-Dawson
-
-// Mapping modes
-
-THREE.UVMapping = 300;
-
-THREE.CubeReflectionMapping = 301;
-THREE.CubeRefractionMapping = 302;
-
-THREE.EquirectangularReflectionMapping = 303;
-THREE.EquirectangularRefractionMapping = 304;
-
-THREE.SphericalReflectionMapping = 305;
-THREE.CubeUVReflectionMapping = 306;
-THREE.CubeUVRefractionMapping = 307;
-
-// Wrapping modes
-
-THREE.RepeatWrapping = 1000;
-THREE.ClampToEdgeWrapping = 1001;
-THREE.MirroredRepeatWrapping = 1002;
-
-// Filters
-
-THREE.NearestFilter = 1003;
-THREE.NearestMipMapNearestFilter = 1004;
-THREE.NearestMipMapLinearFilter = 1005;
-THREE.LinearFilter = 1006;
-THREE.LinearMipMapNearestFilter = 1007;
-THREE.LinearMipMapLinearFilter = 1008;
-
-// Data types
-
-THREE.UnsignedByteType = 1009;
-THREE.ByteType = 1010;
-THREE.ShortType = 1011;
-THREE.UnsignedShortType = 1012;
-THREE.IntType = 1013;
-THREE.UnsignedIntType = 1014;
-THREE.FloatType = 1015;
-THREE.HalfFloatType = 1025;
-
-// Pixel types
-
-//THREE.UnsignedByteType = 1009;
-THREE.UnsignedShort4444Type = 1016;
-THREE.UnsignedShort5551Type = 1017;
-THREE.UnsignedShort565Type = 1018;
-
-// Pixel formats
-
-THREE.AlphaFormat = 1019;
-THREE.RGBFormat = 1020;
-THREE.RGBAFormat = 1021;
-THREE.LuminanceFormat = 1022;
-THREE.LuminanceAlphaFormat = 1023;
-// THREE.RGBEFormat handled as THREE.RGBAFormat in shaders
-THREE.RGBEFormat = THREE.RGBAFormat; //1024;
-THREE.DepthFormat = 1026;
-
-// DDS / ST3C Compressed texture formats
-
-THREE.RGB_S3TC_DXT1_Format = 2001;
-THREE.RGBA_S3TC_DXT1_Format = 2002;
-THREE.RGBA_S3TC_DXT3_Format = 2003;
-THREE.RGBA_S3TC_DXT5_Format = 2004;
-
-
-// PVRTC compressed texture formats
-
-THREE.RGB_PVRTC_4BPPV1_Format = 2100;
-THREE.RGB_PVRTC_2BPPV1_Format = 2101;
-THREE.RGBA_PVRTC_4BPPV1_Format = 2102;
-THREE.RGBA_PVRTC_2BPPV1_Format = 2103;
-
-// ETC compressed texture formats
-
-THREE.RGB_ETC1_Format = 2151;
-
-// Loop styles for AnimationAction
-
-THREE.LoopOnce = 2200;
-THREE.LoopRepeat = 2201;
-THREE.LoopPingPong = 2202;
-
-// Interpolation
-
-THREE.InterpolateDiscrete = 2300;
-THREE.InterpolateLinear = 2301;
-THREE.InterpolateSmooth = 2302;
-
-// Interpolant ending modes
-
-THREE.ZeroCurvatureEnding = 2400;
-THREE.ZeroSlopeEnding = 2401;
-THREE.WrapAroundEnding = 2402;
-
-// Triangle Draw modes
-
-THREE.TrianglesDrawMode = 0;
-THREE.TriangleStripDrawMode = 1;
-THREE.TriangleFanDrawMode = 2;
-
-// Texture Encodings
-
-THREE.LinearEncoding = 3000; // No encoding at all.
-THREE.sRGBEncoding = 3001;
-THREE.GammaEncoding = 3007; // uses GAMMA_FACTOR, for backwards compatibility with WebGLRenderer.gammaInput/gammaOutput
-
-// The following Texture Encodings are for RGB-only (no alpha) HDR light emission sources.
-// These encodings should not specified as output encodings except in rare situations.
-THREE.RGBEEncoding = 3002; // AKA Radiance.
-THREE.LogLuvEncoding = 3003;
-THREE.RGBM7Encoding = 3004;
-THREE.RGBM16Encoding = 3005;
-THREE.RGBDEncoding = 3006; // MaxRange is 256.
-
-// Depth packing strategies
-
-THREE.BasicDepthPacking = 3200;  // for writing to float textures for high precision or for visualizing results in RGB buffers
-THREE.RGBADepthPacking = 3201; // for packing into RGBA buffers.
-
-// File:src/math/Color.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.Color = function ( color ) {
-
-	if ( arguments.length === 3 ) {
-
-		return this.fromArray( arguments );
-
-	}
-
-	return this.set( color );
-
-};
-
-THREE.Color.prototype = {
-
-	constructor: THREE.Color,
-
-	r: 1, g: 1, b: 1,
-
-	set: function ( value ) {
-
-		if ( value instanceof THREE.Color ) {
-
-			this.copy( value );
-
-		} else if ( typeof value === 'number' ) {
-
-			this.setHex( value );
-
-		} else if ( typeof value === 'string' ) {
-
-			this.setStyle( value );
-
-		}
-
-		return this;
-
-	},
-
-	setScalar: function ( scalar ) {
-
-		this.r = scalar;
-		this.g = scalar;
-		this.b = scalar;
-
-	},
-
-	setHex: function ( hex ) {
-
-		hex = Math.floor( hex );
-
-		this.r = ( hex >> 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 () {
-
-		function hue2rgb( p, q, t ) {
-
-			if ( t < 0 ) t += 1;
-			if ( t > 1 ) t -= 1;
-			if ( t < 1 / 6 ) return p + ( q - p ) * 6 * t;
-			if ( t < 1 / 2 ) return q;
-			if ( t < 2 / 3 ) return p + ( q - p ) * 6 * ( 2 / 3 - t );
-			return p;
-
-		}
-
-		return function ( h, s, l ) {
-
-			// h,s,l ranges are in 0.0 - 1.0
-			h = THREE.Math.euclideanModulo( h, 1 );
-			s = THREE.Math.clamp( s, 0, 1 );
-			l = THREE.Math.clamp( l, 0, 1 );
-
-			if ( s === 0 ) {
-
-				this.r = this.g = this.b = l;
-
-			} else {
-
-				var p = l <= 0.5 ? l * ( 1 + s ) : l + s - ( l * s );
-				var q = ( 2 * l ) - p;
-
-				this.r = hue2rgb( q, p, h + 1 / 3 );
-				this.g = hue2rgb( q, p, h );
-				this.b = hue2rgb( q, p, h - 1 / 3 );
-
-			}
-
-			return this;
-
-		};
-
-	}(),
-
-	setStyle: function ( style ) {
-
-		function handleAlpha( string ) {
-
-			if ( string === undefined ) return;
-
-			if ( parseFloat( string ) < 1 ) {
-
-				console.warn( 'THREE.Color: Alpha component of ' + style + ' will be ignored.' );
-
-			}
-
-		}
-
-
-		var m;
-
-		if ( m = /^((?:rgb|hsl)a?)\(\s*([^\)]*)\)/.exec( style ) ) {
-
-			// rgb / hsl
-
-			var color;
-			var name = m[ 1 ];
-			var components = m[ 2 ];
-
-			switch ( name ) {
-
-				case 'rgb':
-				case 'rgba':
-
-					if ( color = /^(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) {
-
-						// rgb(255,0,0) rgba(255,0,0,0.5)
-						this.r = Math.min( 255, parseInt( color[ 1 ], 10 ) ) / 255;
-						this.g = Math.min( 255, parseInt( color[ 2 ], 10 ) ) / 255;
-						this.b = Math.min( 255, parseInt( color[ 3 ], 10 ) ) / 255;
-
-						handleAlpha( color[ 5 ] );
-
-						return this;
-
-					}
-
-					if ( color = /^(\d+)\%\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) {
-
-						// rgb(100%,0%,0%) rgba(100%,0%,0%,0.5)
-						this.r = Math.min( 100, parseInt( color[ 1 ], 10 ) ) / 100;
-						this.g = Math.min( 100, parseInt( color[ 2 ], 10 ) ) / 100;
-						this.b = Math.min( 100, parseInt( color[ 3 ], 10 ) ) / 100;
-
-						handleAlpha( color[ 5 ] );
-
-						return this;
-
-					}
-
-					break;
-
-				case 'hsl':
-				case 'hsla':
-
-					if ( color = /^([0-9]*\.?[0-9]+)\s*,\s*(\d+)\%\s*,\s*(\d+)\%\s*(,\s*([0-9]*\.?[0-9]+)\s*)?$/.exec( components ) ) {
-
-						// hsl(120,50%,50%) hsla(120,50%,50%,0.5)
-						var h = parseFloat( color[ 1 ] ) / 360;
-						var s = parseInt( color[ 2 ], 10 ) / 100;
-						var l = parseInt( color[ 3 ], 10 ) / 100;
-
-						handleAlpha( color[ 5 ] );
-
-						return this.setHSL( h, s, l );
-
-					}
-
-					break;
-
-			}
-
-		} else if ( m = /^\#([A-Fa-f0-9]+)$/.exec( style ) ) {
-
-			// hex color
-
-			var hex = m[ 1 ];
-			var size = hex.length;
-
-			if ( size === 3 ) {
-
-				// #ff0
-				this.r = parseInt( hex.charAt( 0 ) + hex.charAt( 0 ), 16 ) / 255;
-				this.g = parseInt( hex.charAt( 1 ) + hex.charAt( 1 ), 16 ) / 255;
-				this.b = parseInt( hex.charAt( 2 ) + hex.charAt( 2 ), 16 ) / 255;
-
-				return this;
-
-			} else if ( size === 6 ) {
-
-				// #ff0000
-				this.r = parseInt( hex.charAt( 0 ) + hex.charAt( 1 ), 16 ) / 255;
-				this.g = parseInt( hex.charAt( 2 ) + hex.charAt( 3 ), 16 ) / 255;
-				this.b = parseInt( hex.charAt( 4 ) + hex.charAt( 5 ), 16 ) / 255;
-
-				return this;
-
-			}
-
-		}
-
-		if ( style && style.length > 0 ) {
-
-			// color keywords
-			var hex = THREE.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 () {
-
-		var r = this.r, g = this.g, b = this.b;
-
-		this.r = r * r;
-		this.g = g * g;
-		this.b = b * b;
-
-		return this;
-
-	},
-
-	convertLinearToGamma: function () {
-
-		this.r = Math.sqrt( this.r );
-		this.g = Math.sqrt( this.g );
-		this.b = Math.sqrt( this.b );
-
-		return this;
-
-	},
-
-	getHex: function () {
-
-		return ( this.r * 255 ) << 16 ^ ( this.g * 255 ) << 8 ^ ( this.b * 255 ) << 0;
-
-	},
-
-	getHexString: function () {
-
-		return ( '000000' + this.getHex().toString( 16 ) ).slice( - 6 );
-
-	},
-
-	getHSL: function ( optionalTarget ) {
-
-		// h,s,l ranges are in 0.0 - 1.0
-
-		var hsl = optionalTarget || { h: 0, s: 0, l: 0 };
-
-		var r = this.r, g = this.g, b = this.b;
-
-		var max = Math.max( r, g, b );
-		var min = Math.min( r, g, b );
-
-		var hue, saturation;
-		var lightness = ( min + max ) / 2.0;
-
-		if ( min === max ) {
-
-			hue = 0;
-			saturation = 0;
-
-		} else {
-
-			var delta = max - min;
-
-			saturation = lightness <= 0.5 ? delta / ( max + min ) : delta / ( 2 - max - min );
-
-			switch ( max ) {
-
-				case r: hue = ( g - b ) / delta + ( g < b ? 6 : 0 ); break;
-				case g: hue = ( b - r ) / delta + 2; break;
-				case b: hue = ( r - g ) / delta + 4; break;
-
-			}
-
-			hue /= 6;
-
-		}
-
-		hsl.h = hue;
-		hsl.s = saturation;
-		hsl.l = lightness;
-
-		return hsl;
-
-	},
-
-	getStyle: function () {
-
-		return 'rgb(' + ( ( this.r * 255 ) | 0 ) + ',' + ( ( this.g * 255 ) | 0 ) + ',' + ( ( this.b * 255 ) | 0 ) + ')';
-
-	},
-
-	offsetHSL: function ( h, s, l ) {
-
-		var hsl = this.getHSL();
-
-		hsl.h += h; hsl.s += s; hsl.l += l;
-
-		this.setHSL( hsl.h, hsl.s, hsl.l );
-
-		return this;
-
-	},
-
-	add: function ( color ) {
-
-		this.r += color.r;
-		this.g += color.g;
-		this.b += color.b;
-
-		return this;
-
-	},
-
-	addColors: function ( color1, color2 ) {
-
-		this.r = color1.r + color2.r;
-		this.g = color1.g + color2.g;
-		this.b = color1.b + color2.b;
-
-		return this;
-
-	},
-
-	addScalar: function ( s ) {
-
-		this.r += s;
-		this.g += s;
-		this.b += s;
-
-		return this;
-
-	},
-
-	multiply: function ( color ) {
-
-		this.r *= color.r;
-		this.g *= color.g;
-		this.b *= color.b;
-
-		return this;
-
-	},
-
-	multiplyScalar: function ( s ) {
-
-		this.r *= s;
-		this.g *= s;
-		this.b *= s;
-
-		return this;
-
-	},
-
-	lerp: function ( color, alpha ) {
-
-		this.r += ( color.r - this.r ) * alpha;
-		this.g += ( color.g - this.g ) * alpha;
-		this.b += ( color.b - this.b ) * alpha;
-
-		return this;
-
-	},
-
-	equals: function ( c ) {
-
-		return ( c.r === this.r ) && ( c.g === this.g ) && ( c.b === this.b );
-
-	},
-
-	fromArray: function ( array, offset ) {
-
-		if ( offset === undefined ) offset = 0;
-
-		this.r = array[ offset ];
-		this.g = array[ offset + 1 ];
-		this.b = array[ offset + 2 ];
-
-		return this;
-
-	},
-
-	toArray: function ( array, offset ) {
-
-		if ( array === undefined ) array = [];
-		if ( offset === undefined ) offset = 0;
-
-		array[ offset ] = this.r;
-		array[ offset + 1 ] = this.g;
-		array[ offset + 2 ] = this.b;
-
-		return array;
-
-	}
-
-};
-
-THREE.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, '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 };
-
-// File:src/math/Quaternion.js
-
-/**
- * @author mikael emtinger / http://gomo.se/
- * @author alteredq / http://alteredqualia.com/
- * @author WestLangley / http://github.com/WestLangley
- * @author bhouston / http://clara.io
- */
-
-THREE.Quaternion = function ( x, y, z, w ) {
-
-	this._x = x || 0;
-	this._y = y || 0;
-	this._z = z || 0;
-	this._w = ( w !== undefined ) ? w : 1;
-
-};
-
-THREE.Quaternion.prototype = {
-
-	constructor: THREE.Quaternion,
-
-	get x () {
-
-		return this._x;
-
-	},
-
-	set x ( value ) {
-
-		this._x = value;
-		this.onChangeCallback();
-
-	},
-
-	get y () {
-
-		return this._y;
-
-	},
-
-	set y ( value ) {
-
-		this._y = value;
-		this.onChangeCallback();
-
-	},
-
-	get z () {
-
-		return this._z;
-
-	},
-
-	set z ( value ) {
-
-		this._z = value;
-		this.onChangeCallback();
-
-	},
-
-	get w () {
-
-		return this._w;
-
-	},
-
-	set w ( value ) {
-
-		this._w = value;
-		this.onChangeCallback();
-
-	},
-
-	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 instanceof THREE.Euler === false ) {
-
-			throw new Error( 'THREE.Quaternion: .setFromEuler() now expects a Euler rotation rather than a Vector3 and order.' );
-
-		}
-
-		// http://www.mathworks.com/matlabcentral/fileexchange/
-		// 	20696-function-to-convert-between-dcm-euler-angles-quaternions-and-euler-vectors/
-		//	content/SpinCalc.m
-
-		var c1 = Math.cos( euler._x / 2 );
-		var c2 = Math.cos( euler._y / 2 );
-		var c3 = Math.cos( euler._z / 2 );
-		var s1 = Math.sin( euler._x / 2 );
-		var s2 = Math.sin( euler._y / 2 );
-		var s3 = Math.sin( euler._z / 2 );
-
-		var order = euler.order;
-
-		if ( order === '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;
-
-		} else if ( order === '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;
-
-		} else if ( order === '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;
-
-		} else if ( order === '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;
-
-		} else if ( order === '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;
-
-		} else if ( order === '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;
-
-		}
-
-		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 () {
-
-		// http://lolengine.net/blog/2014/02/24/quaternion-from-two-vectors-final
-
-		// assumes direction vectors vFrom and vTo are normalized
-
-		var v1, r;
-
-		var EPS = 0.000001;
-
-		return function ( vFrom, vTo ) {
-
-			if ( v1 === undefined ) v1 = new THREE.Vector3();
-
-			r = vFrom.dot( vTo ) + 1;
-
-			if ( r < EPS ) {
-
-				r = 0;
-
-				if ( Math.abs( vFrom.x ) > Math.abs( vFrom.z ) ) {
-
-					v1.set( - vFrom.y, vFrom.x, 0 );
-
-				} else {
-
-					v1.set( 0, - vFrom.z, vFrom.y );
-
-				}
-
-			} else {
-
-				v1.crossVectors( vFrom, vTo );
-
-			}
-
-			this._x = v1.x;
-			this._y = v1.y;
-			this._z = v1.z;
-			this._w = r;
-
-			this.normalize();
-
-			return this;
-
-		};
-
-	}(),
-
-	inverse: function () {
-
-		this.conjugate().normalize();
-
-		return this;
-
-	},
-
-	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 );
-
-	},
-
-	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 < 0 ) {
-
-			this._w = - qb._w;
-			this._x = - qb._x;
-			this._y = - qb._y;
-			this._z = - qb._z;
-
-			cosHalfTheta = - cosHalfTheta;
-
-		} else {
-
-			this.copy( qb );
-
-		}
-
-		if ( cosHalfTheta >= 1.0 ) {
-
-			this._w = w;
-			this._x = x;
-			this._y = y;
-			this._z = z;
-
-			return this;
-
-		}
-
-		var sinHalfTheta = Math.sqrt( 1.0 - cosHalfTheta * cosHalfTheta );
-
-		if ( Math.abs( sinHalfTheta ) < 0.001 ) {
-
-			this._w = 0.5 * ( w + this._w );
-			this._x = 0.5 * ( x + this._x );
-			this._y = 0.5 * ( y + this._y );
-			this._z = 0.5 * ( z + this._z );
-
-			return this;
-
-		}
-
-		var halfTheta = Math.atan2( sinHalfTheta, cosHalfTheta );
-		var ratioA = Math.sin( ( 1 - t ) * halfTheta ) / sinHalfTheta,
-		ratioB = Math.sin( t * halfTheta ) / sinHalfTheta;
-
-		this._w = ( w * ratioA + this._w * ratioB );
-		this._x = ( x * ratioA + this._x * ratioB );
-		this._y = ( y * ratioA + this._y * ratioB );
-		this._z = ( z * ratioA + this._z * ratioB );
-
-		this.onChangeCallback();
-
-		return this;
-
-	},
-
-	equals: function ( quaternion ) {
-
-		return ( quaternion._x === this._x ) && ( quaternion._y === this._y ) && ( quaternion._z === this._z ) && ( quaternion._w === this._w );
-
-	},
-
-	fromArray: function ( array, offset ) {
-
-		if ( offset === undefined ) offset = 0;
-
-		this._x = array[ offset ];
-		this._y = array[ offset + 1 ];
-		this._z = array[ offset + 2 ];
-		this._w = array[ offset + 3 ];
-
-		this.onChangeCallback();
-
-		return this;
-
-	},
-
-	toArray: function ( array, offset ) {
-
-		if ( array === undefined ) array = [];
-		if ( offset === undefined ) offset = 0;
-
-		array[ offset ] = this._x;
-		array[ offset + 1 ] = this._y;
-		array[ offset + 2 ] = this._z;
-		array[ offset + 3 ] = this._w;
-
-		return array;
-
-	},
-
-	onChange: function ( callback ) {
-
-		this.onChangeCallback = callback;
-
-		return this;
-
-	},
-
-	onChangeCallback: function () {}
-
-};
-
-Object.assign( THREE.Quaternion, {
-
-	slerp: function( qa, qb, qm, t ) {
-
-		return qm.copy( qa ).slerp( qb, t );
-
-	},
-
-	slerpFlat: function(
-			dst, dstOffset, src0, srcOffset0, src1, srcOffset1, t ) {
-
-		// fuzz-free, array-based Quaternion SLERP operation
-
-		var x0 = src0[ srcOffset0 + 0 ],
-			y0 = src0[ srcOffset0 + 1 ],
-			z0 = src0[ srcOffset0 + 2 ],
-			w0 = src0[ srcOffset0 + 3 ],
-
-			x1 = src1[ srcOffset1 + 0 ],
-			y1 = src1[ srcOffset1 + 1 ],
-			z1 = src1[ srcOffset1 + 2 ],
-			w1 = src1[ srcOffset1 + 3 ];
-
-		if ( w0 !== w1 || x0 !== x1 || y0 !== y1 || z0 !== z1 ) {
-
-			var s = 1 - t,
-
-				cos = x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1,
-
-				dir = ( cos >= 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;
-
-	}
-
-} );
-
-// File:src/math/Vector2.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author philogb / http://blog.thejit.org/
- * @author egraether / http://egraether.com/
- * @author zz85 / http://www.lab4games.net/zz85/blog
- */
-
-THREE.Vector2 = function ( x, y ) {
-
-	this.x = x || 0;
-	this.y = y || 0;
-
-};
-
-THREE.Vector2.prototype = {
-
-	constructor: THREE.Vector2,
-
-	get width() {
-
-		return this.x;
-
-	},
-
-	set width( value ) {
-
-		this.x = value;
-
-	},
-
-	get height() {
-
-		return this.y;
-
-	},
-
-	set height( value ) {
-
-		this.y = value;
-
-	},
-
-	//
-
-	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 );
-
-		}
-
-	},
-
-	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 ) {
-
-		if ( isFinite( scalar ) ) {
-
-			this.x *= scalar;
-			this.y *= scalar;
-
-		} else {
-
-			this.x = 0;
-			this.y = 0;
-
-		}
-
-		return this;
-
-	},
-
-	divide: function ( v ) {
-
-		this.x /= v.x;
-		this.y /= v.y;
-
-		return this;
-
-	},
-
-	divideScalar: function ( scalar ) {
-
-		return this.multiplyScalar( 1 / scalar );
-
-	},
-
-	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 ) {
-
-		// This function assumes min < max, if this assumption isn't true it will not operate correctly
-
-		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
-		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
-
-		return this;
-
-	},
-
-	clampScalar: function () {
-
-		var min, max;
-
-		return function clampScalar( minVal, maxVal ) {
-
-			if ( min === undefined ) {
-
-				min = new THREE.Vector2();
-				max = new THREE.Vector2();
-
-			}
-
-			min.set( minVal, minVal );
-			max.set( maxVal, maxVal );
-
-			return this.clamp( min, max );
-
-		};
-
-	}(),
-
-	clampLength: function ( min, max ) {
-
-		var length = this.length();
-
-		this.multiplyScalar( Math.max( min, Math.min( max, length ) ) / length );
-
-		return this;
-
-	},
-
-	floor: function () {
-
-		this.x = Math.floor( this.x );
-		this.y = Math.floor( this.y );
-
-		return this;
-
-	},
-
-	ceil: function () {
-
-		this.x = Math.ceil( this.x );
-		this.y = Math.ceil( this.y );
-
-		return this;
-
-	},
-
-	round: function () {
-
-		this.x = Math.round( this.x );
-		this.y = Math.round( this.y );
-
-		return this;
-
-	},
-
-	roundToZero: function () {
-
-		this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
-		this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
-
-		return this;
-
-	},
-
-	negate: function () {
-
-		this.x = - this.x;
-		this.y = - this.y;
-
-		return this;
-
-	},
-
-	dot: function ( v ) {
-
-		return this.x * v.x + this.y * v.y;
-
-	},
-
-	lengthSq: function () {
-
-		return this.x * this.x + this.y * this.y;
-
-	},
-
-	length: function () {
-
-		return Math.sqrt( this.x * this.x + this.y * this.y );
-
-	},
-
-	lengthManhattan: function() {
-
-		return Math.abs( this.x ) + Math.abs( this.y );
-
-	},
-
-	normalize: function () {
-
-		return this.divideScalar( this.length() );
-
-	},
-
-	angle: function () {
-
-		// computes the angle in radians with respect to the positive x-axis
-
-		var angle = Math.atan2( this.y, this.x );
-
-		if ( angle < 0 ) angle += 2 * Math.PI;
-
-		return angle;
-
-	},
-
-	distanceTo: function ( v ) {
-
-		return Math.sqrt( this.distanceToSquared( v ) );
-
-	},
-
-	distanceToSquared: function ( v ) {
-
-		var dx = this.x - v.x, dy = this.y - v.y;
-		return dx * dx + dy * dy;
-
-	},
-
-	setLength: function ( length ) {
-
-		return this.multiplyScalar( length / this.length() );
-
-	},
-
-	lerp: function ( v, alpha ) {
-
-		this.x += ( v.x - this.x ) * alpha;
-		this.y += ( v.y - this.y ) * alpha;
-
-		return this;
-
-	},
-
-	lerpVectors: function ( v1, v2, alpha ) {
-
-		this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
-
-		return this;
-
-	},
-
-	equals: function ( v ) {
-
-		return ( ( v.x === this.x ) && ( v.y === this.y ) );
-
-	},
-
-	fromArray: function ( array, offset ) {
-
-		if ( offset === undefined ) offset = 0;
-
-		this.x = array[ offset ];
-		this.y = array[ offset + 1 ];
-
-		return this;
-
-	},
-
-	toArray: function ( array, offset ) {
-
-		if ( array === undefined ) array = [];
-		if ( offset === undefined ) offset = 0;
-
-		array[ offset ] = this.x;
-		array[ offset + 1 ] = this.y;
-
-		return array;
-
-	},
-
-	fromAttribute: function ( attribute, index, offset ) {
-
-		if ( offset === undefined ) offset = 0;
-
-		index = index * attribute.itemSize + offset;
-
-		this.x = attribute.array[ index ];
-		this.y = attribute.array[ index + 1 ];
-
-		return this;
-
-	},
-
-	rotateAround: function ( center, angle ) {
-
-		var c = Math.cos( angle ), s = Math.sin( angle );
-
-		var x = this.x - center.x;
-		var y = this.y - center.y;
-
-		this.x = x * c - y * s + center.x;
-		this.y = x * s + y * c + center.y;
-
-		return this;
-
-	}
-
-};
-
-// File:src/math/Vector3.js
-
-/**
- * @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;
-
-	},
-
-	setScalar: function ( scalar ) {
-
-		this.x = scalar;
-		this.y = scalar;
-		this.z = scalar;
-
-		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 );
-
-		}
-
-	},
-
-	clone: function () {
-
-		return new this.constructor( this.x, this.y, this.z );
-
-	},
-
-	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( 'THREE.Vector3: .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;
-
-	},
-
-	addScaledVector: function ( v, s ) {
-
-		this.x += v.x * s;
-		this.y += v.y * s;
-		this.z += v.z * s;
-
-		return this;
-
-	},
-
-	sub: function ( v, w ) {
-
-		if ( w !== undefined ) {
-
-			console.warn( 'THREE.Vector3: .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;
-
-	},
-
-	subScalar: function ( s ) {
-
-		this.x -= s;
-		this.y -= s;
-		this.z -= s;
-
-		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( 'THREE.Vector3: .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 ( scalar ) {
-
-		if ( isFinite( scalar ) ) {
-
-			this.x *= scalar;
-			this.y *= scalar;
-			this.z *= scalar;
-
-		} else {
-
-			this.x = 0;
-			this.y = 0;
-			this.z = 0;
-
-		}
-
-		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;
-
-	},
-
-	applyEuler: function () {
-
-		var quaternion;
-
-		return function applyEuler( euler ) {
-
-			if ( euler instanceof THREE.Euler === false ) {
-
-				console.error( 'THREE.Vector3: .applyEuler() now expects an Euler rotation rather than a Vector3 and order.' );
-
-			}
-
-			if ( quaternion === undefined ) quaternion = new THREE.Quaternion();
-
-			this.applyQuaternion( quaternion.setFromEuler( euler ) );
-
-			return this;
-
-		};
-
-	}(),
-
-	applyAxisAngle: function () {
-
-		var quaternion;
-
-		return function applyAxisAngle( axis, angle ) {
-
-			if ( quaternion === undefined ) quaternion = new THREE.Quaternion();
-
-			this.applyQuaternion( quaternion.setFromAxisAngle( axis, angle ) );
-
-			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;
-
-	},
-
-	project: function () {
-
-		var matrix;
-
-		return function project( camera ) {
-
-			if ( matrix === undefined ) matrix = new THREE.Matrix4();
-
-			matrix.multiplyMatrices( camera.projectionMatrix, matrix.getInverse( camera.matrixWorld ) );
-			return this.applyProjection( matrix );
-
-		};
-
-	}(),
-
-	unproject: function () {
-
-		var matrix;
-
-		return function unproject( camera ) {
-
-			if ( matrix === undefined ) matrix = new THREE.Matrix4();
-
-			matrix.multiplyMatrices( camera.matrixWorld, matrix.getInverse( camera.projectionMatrix ) );
-			return this.applyProjection( matrix );
-
-		};
-
-	}(),
-
-	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 ( scalar ) {
-
-		return this.multiplyScalar( 1 / scalar );
-
-	},
-
-	min: function ( v ) {
-
-		this.x = Math.min( this.x, v.x );
-		this.y = Math.min( this.y, v.y );
-		this.z = Math.min( this.z, v.z );
-
-		return this;
-
-	},
-
-	max: function ( v ) {
-
-		this.x = Math.max( this.x, v.x );
-		this.y = Math.max( this.y, v.y );
-		this.z = Math.max( 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
-
-		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
-		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
-		this.z = Math.max( min.z, Math.min( max.z, this.z ) );
-
-		return this;
-
-	},
-
-	clampScalar: function () {
-
-		var min, max;
-
-		return function clampScalar( minVal, maxVal ) {
-
-			if ( min === undefined ) {
-
-				min = new THREE.Vector3();
-				max = new THREE.Vector3();
-
-			}
-
-			min.set( minVal, minVal, minVal );
-			max.set( maxVal, maxVal, maxVal );
-
-			return this.clamp( min, max );
-
-		};
-
-	}(),
-
-	clampLength: function ( min, max ) {
-
-		var length = this.length();
-
-		this.multiplyScalar( Math.max( min, Math.min( max, length ) ) / length );
-
-		return this;
-
-	},
-
-	floor: function () {
-
-		this.x = Math.floor( this.x );
-		this.y = Math.floor( this.y );
-		this.z = Math.floor( this.z );
-
-		return this;
-
-	},
-
-	ceil: function () {
-
-		this.x = Math.ceil( this.x );
-		this.y = Math.ceil( this.y );
-		this.z = Math.ceil( this.z );
-
-		return this;
-
-	},
-
-	round: function () {
-
-		this.x = Math.round( this.x );
-		this.y = Math.round( this.y );
-		this.z = Math.round( this.z );
-
-		return this;
-
-	},
-
-	roundToZero: function () {
-
-		this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
-		this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
-		this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );
-
-		return this;
-
-	},
-
-	negate: function () {
-
-		this.x = - this.x;
-		this.y = - this.y;
-		this.z = - this.z;
-
-		return this;
-
-	},
-
-	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 ( length ) {
-
-		return this.multiplyScalar( length / this.length() );
-
-	},
-
-	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;
-
-	},
-
-	lerpVectors: function ( v1, v2, alpha ) {
-
-		this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
-
-		return this;
-
-	},
-
-	cross: function ( v, w ) {
-
-		if ( w !== undefined ) {
-
-			console.warn( 'THREE.Vector3: .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 ) {
-
-		var ax = a.x, ay = a.y, az = a.z;
-		var bx = b.x, by = b.y, bz = b.z;
-
-		this.x = ay * bz - az * by;
-		this.y = az * bx - ax * bz;
-		this.z = ax * by - ay * bx;
-
-		return this;
-
-	},
-
-	projectOnVector: function () {
-
-		var v1, dot;
-
-		return function projectOnVector( vector ) {
-
-			if ( v1 === undefined ) v1 = new THREE.Vector3();
-
-			v1.copy( vector ).normalize();
-
-			dot = this.dot( v1 );
-
-			return this.copy( v1 ).multiplyScalar( dot );
-
-		};
-
-	}(),
-
-	projectOnPlane: function () {
-
-		var v1;
-
-		return function projectOnPlane( planeNormal ) {
-
-			if ( v1 === undefined ) v1 = new THREE.Vector3();
-
-			v1.copy( this ).projectOnVector( planeNormal );
-
-			return this.sub( v1 );
-
-		};
-
-	}(),
-
-	reflect: function () {
-
-		// reflect incident vector off plane orthogonal to normal
-		// normal is assumed to have unit length
-
-		var v1;
-
-		return function reflect( normal ) {
-
-			if ( v1 === undefined ) v1 = new THREE.Vector3();
-
-			return this.sub( v1.copy( normal ).multiplyScalar( 2 * this.dot( normal ) ) );
-
-		};
-
-	}(),
-
-	angleTo: function ( v ) {
-
-		var theta = this.dot( v ) / ( Math.sqrt( this.lengthSq() * v.lengthSq() ) );
-
-		// 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;
-
-	},
-
-	setFromSpherical: function( s ) {
-
-		var sinPhiRadius = Math.sin( s.phi ) * s.radius;
-
-		this.x = sinPhiRadius * Math.sin( s.theta );
-		this.y = Math.cos( s.phi ) * s.radius;
-		this.z = sinPhiRadius * Math.cos( s.theta );
-
-		return this;
-
-	},
-
-	setFromMatrixPosition: function ( m ) {
-
-		return this.setFromMatrixColumn( m, 3 );
-
-	},
-
-	setFromMatrixScale: function ( m ) {
-
-		var sx = this.setFromMatrixColumn( m, 0 ).length();
-		var sy = this.setFromMatrixColumn( m, 1 ).length();
-		var sz = this.setFromMatrixColumn( m, 2 ).length();
-
-		this.x = sx;
-		this.y = sy;
-		this.z = sz;
-
-		return this;
-
-	},
-
-	setFromMatrixColumn: function ( m, index ) {
-
-		if ( typeof m === 'number' ) {
-
-			console.warn( 'THREE.Vector3: setFromMatrixColumn now expects ( matrix, index ).' );
-
-			m = arguments[ 1 ];
-			index = arguments[ 0 ];
-
-		}
-
-		return this.fromArray( m.elements, index * 4 );
-
-	},
-
-	equals: function ( v ) {
-
-		return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) );
-
-	},
-
-	fromArray: function ( array, offset ) {
-
-		if ( offset === undefined ) offset = 0;
-
-		this.x = array[ offset ];
-		this.y = array[ offset + 1 ];
-		this.z = array[ offset + 2 ];
-
-		return this;
-
-	},
-
-	toArray: function ( array, offset ) {
-
-		if ( array === undefined ) array = [];
-		if ( offset === undefined ) offset = 0;
-
-		array[ offset ] = this.x;
-		array[ offset + 1 ] = this.y;
-		array[ offset + 2 ] = this.z;
-
-		return array;
-
-	},
-
-	fromAttribute: function ( attribute, index, offset ) {
-
-		if ( offset === undefined ) offset = 0;
-
-		index = index * attribute.itemSize + offset;
-
-		this.x = attribute.array[ index ];
-		this.y = attribute.array[ index + 1 ];
-		this.z = attribute.array[ index + 2 ];
-
-		return this;
-
-	}
-
-};
-
-// File:src/math/Vector4.js
-
-/**
- * @author supereggbert / http://www.paulbrunt.co.uk/
- * @author philogb / http://blog.thejit.org/
- * @author mikael emtinger / http://gomo.se/
- * @author egraether / http://egraether.com/
- * @author WestLangley / http://github.com/WestLangley
- */
-
-THREE.Vector4 = function ( x, y, z, w ) {
-
-	this.x = x || 0;
-	this.y = y || 0;
-	this.z = z || 0;
-	this.w = ( w !== undefined ) ? w : 1;
-
-};
-
-THREE.Vector4.prototype = {
-
-	constructor: THREE.Vector4,
-
-	set: function ( x, y, z, w ) {
-
-		this.x = x;
-		this.y = y;
-		this.z = z;
-		this.w = w;
-
-		return this;
-
-	},
-
-	setScalar: function ( scalar ) {
-
-		this.x = scalar;
-		this.y = scalar;
-		this.z = scalar;
-		this.w = scalar;
-
-		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;
-
-	},
-
-	setW: function ( w ) {
-
-		this.w = w;
-
-		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;
-			case 3: this.w = 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;
-			case 3: return this.w;
-			default: throw new Error( 'index is out of range: ' + index );
-
-		}
-
-	},
-
-	clone: function () {
-
-		return new this.constructor( this.x, this.y, this.z, this.w );
-
-	},
-
-	copy: function ( v ) {
-
-		this.x = v.x;
-		this.y = v.y;
-		this.z = v.z;
-		this.w = ( v.w !== undefined ) ? v.w : 1;
-
-		return this;
-
-	},
-
-	add: function ( v, w ) {
-
-		if ( w !== undefined ) {
-
-			console.warn( 'THREE.Vector4: .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;
-		this.w += v.w;
-
-		return this;
-
-	},
-
-	addScalar: function ( s ) {
-
-		this.x += s;
-		this.y += s;
-		this.z += s;
-		this.w += 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;
-		this.w = a.w + b.w;
-
-		return this;
-
-	},
-
-	addScaledVector: function ( v, s ) {
-
-		this.x += v.x * s;
-		this.y += v.y * s;
-		this.z += v.z * s;
-		this.w += v.w * s;
-
-		return this;
-
-	},
-
-	sub: function ( v, w ) {
-
-		if ( w !== undefined ) {
-
-			console.warn( 'THREE.Vector4: .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;
-		this.w -= v.w;
-
-		return this;
-
-	},
-
-	subScalar: function ( s ) {
-
-		this.x -= s;
-		this.y -= s;
-		this.z -= s;
-		this.w -= s;
-
-		return this;
-
-	},
-
-	subVectors: function ( a, b ) {
-
-		this.x = a.x - b.x;
-		this.y = a.y - b.y;
-		this.z = a.z - b.z;
-		this.w = a.w - b.w;
-
-		return this;
-
-	},
-
-	multiplyScalar: function ( scalar ) {
-
-		if ( isFinite( scalar ) ) {
-
-			this.x *= scalar;
-			this.y *= scalar;
-			this.z *= scalar;
-			this.w *= scalar;
-
-		} else {
-
-			this.x = 0;
-			this.y = 0;
-			this.z = 0;
-			this.w = 0;
-
-		}
-
-		return this;
-
-	},
-
-	applyMatrix4: function ( m ) {
-
-		var x = this.x;
-		var y = this.y;
-		var z = this.z;
-		var w = this.w;
-
-		var e = m.elements;
-
-		this.x = e[ 0 ] * x + e[ 4 ] * y + e[ 8 ] * z + e[ 12 ] * w;
-		this.y = e[ 1 ] * x + e[ 5 ] * y + e[ 9 ] * z + e[ 13 ] * w;
-		this.z = e[ 2 ] * x + e[ 6 ] * y + e[ 10 ] * z + e[ 14 ] * w;
-		this.w = e[ 3 ] * x + e[ 7 ] * y + e[ 11 ] * z + e[ 15 ] * w;
-
-		return this;
-
-	},
-
-	divideScalar: function ( scalar ) {
-
-		return this.multiplyScalar( 1 / scalar );
-
-	},
-
-	setAxisAngleFromQuaternion: function ( q ) {
-
-		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/quaternionToAngle/index.htm
-
-		// q is assumed to be normalized
-
-		this.w = 2 * Math.acos( q.w );
-
-		var s = Math.sqrt( 1 - q.w * q.w );
-
-		if ( s < 0.0001 ) {
-
-			 this.x = 1;
-			 this.y = 0;
-			 this.z = 0;
-
-		} else {
-
-			 this.x = q.x / s;
-			 this.y = q.y / s;
-			 this.z = q.z / s;
-
-		}
-
-		return this;
-
-	},
-
-	setAxisAngleFromRotationMatrix: function ( m ) {
-
-		// http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToAngle/index.htm
-
-		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
-
-		var angle, x, y, z,		// variables for result
-			epsilon = 0.01,		// margin to allow for rounding errors
-			epsilon2 = 0.1,		// margin to distinguish between 0 and 180 degrees
-
-			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 ];
-
-		if ( ( Math.abs( m12 - m21 ) < epsilon ) &&
-		     ( Math.abs( m13 - m31 ) < epsilon ) &&
-		     ( Math.abs( m23 - m32 ) < epsilon ) ) {
-
-			// singularity found
-			// first check for identity matrix which must have +1 for all terms
-			// in leading diagonal and zero in other terms
-
-			if ( ( Math.abs( m12 + m21 ) < epsilon2 ) &&
-			     ( Math.abs( m13 + m31 ) < epsilon2 ) &&
-			     ( Math.abs( m23 + m32 ) < epsilon2 ) &&
-			     ( Math.abs( m11 + m22 + m33 - 3 ) < epsilon2 ) ) {
-
-				// this singularity is identity matrix so angle = 0
-
-				this.set( 1, 0, 0, 0 );
-
-				return this; // zero angle, arbitrary axis
-
-			}
-
-			// otherwise this singularity is angle = 180
-
-			angle = Math.PI;
-
-			var xx = ( m11 + 1 ) / 2;
-			var yy = ( m22 + 1 ) / 2;
-			var zz = ( m33 + 1 ) / 2;
-			var xy = ( m12 + m21 ) / 4;
-			var xz = ( m13 + m31 ) / 4;
-			var yz = ( m23 + m32 ) / 4;
-
-			if ( ( xx > yy ) && ( xx > zz ) ) {
-
-				// m11 is the largest diagonal term
-
-				if ( xx < epsilon ) {
-
-					x = 0;
-					y = 0.707106781;
-					z = 0.707106781;
-
-				} else {
-
-					x = Math.sqrt( xx );
-					y = xy / x;
-					z = xz / x;
-
-				}
-
-			} else if ( yy > zz ) {
-
-				// m22 is the largest diagonal term
-
-				if ( yy < epsilon ) {
-
-					x = 0.707106781;
-					y = 0;
-					z = 0.707106781;
-
-				} else {
-
-					y = Math.sqrt( yy );
-					x = xy / y;
-					z = yz / y;
-
-				}
-
-			} else {
-
-				// m33 is the largest diagonal term so base result on this
-
-				if ( zz < epsilon ) {
-
-					x = 0.707106781;
-					y = 0.707106781;
-					z = 0;
-
-				} else {
-
-					z = Math.sqrt( zz );
-					x = xz / z;
-					y = yz / z;
-
-				}
-
-			}
-
-			this.set( x, y, z, angle );
-
-			return this; // return 180 deg rotation
-
-		}
-
-		// as we have reached here there are no singularities so we can handle normally
-
-		var s = Math.sqrt( ( m32 - m23 ) * ( m32 - m23 ) +
-		                   ( m13 - m31 ) * ( m13 - m31 ) +
-		                   ( m21 - m12 ) * ( m21 - m12 ) ); // used to normalize
-
-		if ( Math.abs( s ) < 0.001 ) s = 1;
-
-		// prevent divide by zero, should not happen if matrix is orthogonal and should be
-		// caught by singularity test above, but I've left it in just in case
-
-		this.x = ( m32 - m23 ) / s;
-		this.y = ( m13 - m31 ) / s;
-		this.z = ( m21 - m12 ) / s;
-		this.w = Math.acos( ( m11 + m22 + m33 - 1 ) / 2 );
-
-		return this;
-
-	},
-
-	min: function ( v ) {
-
-		this.x = Math.min( this.x, v.x );
-		this.y = Math.min( this.y, v.y );
-		this.z = Math.min( this.z, v.z );
-		this.w = Math.min( this.w, v.w );
-
-		return this;
-
-	},
-
-	max: function ( v ) {
-
-		this.x = Math.max( this.x, v.x );
-		this.y = Math.max( this.y, v.y );
-		this.z = Math.max( this.z, v.z );
-		this.w = Math.max( this.w, v.w );
-
-		return this;
-
-	},
-
-	clamp: function ( min, max ) {
-
-		// This function assumes min < max, if this assumption isn't true it will not operate correctly
-
-		this.x = Math.max( min.x, Math.min( max.x, this.x ) );
-		this.y = Math.max( min.y, Math.min( max.y, this.y ) );
-		this.z = Math.max( min.z, Math.min( max.z, this.z ) );
-		this.w = Math.max( min.w, Math.min( max.w, this.w ) );
-
-		return this;
-
-	},
-
-	clampScalar: function () {
-
-		var min, max;
-
-		return function clampScalar( minVal, maxVal ) {
-
-			if ( min === undefined ) {
-
-				min = new THREE.Vector4();
-				max = new THREE.Vector4();
-
-			}
-
-			min.set( minVal, minVal, minVal, minVal );
-			max.set( maxVal, maxVal, maxVal, maxVal );
-
-			return this.clamp( min, max );
-
-		};
-
-	}(),
-
-	floor: function () {
-
-		this.x = Math.floor( this.x );
-		this.y = Math.floor( this.y );
-		this.z = Math.floor( this.z );
-		this.w = Math.floor( this.w );
-
-		return this;
-
-	},
-
-	ceil: function () {
-
-		this.x = Math.ceil( this.x );
-		this.y = Math.ceil( this.y );
-		this.z = Math.ceil( this.z );
-		this.w = Math.ceil( this.w );
-
-		return this;
-
-	},
-
-	round: function () {
-
-		this.x = Math.round( this.x );
-		this.y = Math.round( this.y );
-		this.z = Math.round( this.z );
-		this.w = Math.round( this.w );
-
-		return this;
-
-	},
-
-	roundToZero: function () {
-
-		this.x = ( this.x < 0 ) ? Math.ceil( this.x ) : Math.floor( this.x );
-		this.y = ( this.y < 0 ) ? Math.ceil( this.y ) : Math.floor( this.y );
-		this.z = ( this.z < 0 ) ? Math.ceil( this.z ) : Math.floor( this.z );
-		this.w = ( this.w < 0 ) ? Math.ceil( this.w ) : Math.floor( this.w );
-
-		return this;
-
-	},
-
-	negate: function () {
-
-		this.x = - this.x;
-		this.y = - this.y;
-		this.z = - this.z;
-		this.w = - this.w;
-
-		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 );
-
-	},
-
-	lengthManhattan: function () {
-
-		return Math.abs( this.x ) + Math.abs( this.y ) + Math.abs( this.z ) + Math.abs( this.w );
-
-	},
-
-	normalize: function () {
-
-		return this.divideScalar( this.length() );
-
-	},
-
-	setLength: function ( length ) {
-
-		return this.multiplyScalar( length / this.length() );
-
-	},
-
-	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;
-		this.w += ( v.w - this.w ) * alpha;
-
-		return this;
-
-	},
-
-	lerpVectors: function ( v1, v2, alpha ) {
-
-		this.subVectors( v2, v1 ).multiplyScalar( alpha ).add( v1 );
-
-		return this;
-
-	},
-
-	equals: function ( v ) {
-
-		return ( ( v.x === this.x ) && ( v.y === this.y ) && ( v.z === this.z ) && ( v.w === this.w ) );
-
-	},
-
-	fromArray: function ( array, offset ) {
-
-		if ( offset === undefined ) offset = 0;
-
-		this.x = array[ offset ];
-		this.y = array[ offset + 1 ];
-		this.z = array[ offset + 2 ];
-		this.w = array[ offset + 3 ];
-
-		return this;
-
-	},
-
-	toArray: function ( array, offset ) {
-
-		if ( array === undefined ) array = [];
-		if ( offset === undefined ) offset = 0;
-
-		array[ offset ] = this.x;
-		array[ offset + 1 ] = this.y;
-		array[ offset + 2 ] = this.z;
-		array[ offset + 3 ] = this.w;
-
-		return array;
-
-	},
-
-	fromAttribute: function ( attribute, index, offset ) {
-
-		if ( offset === undefined ) offset = 0;
-
-		index = index * attribute.itemSize + offset;
-
-		this.x = attribute.array[ index ];
-		this.y = attribute.array[ index + 1 ];
-		this.z = attribute.array[ index + 2 ];
-		this.w = attribute.array[ index + 3 ];
-
-		return this;
-
-	}
-
-};
-
-// File:src/math/Euler.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author WestLangley / http://github.com/WestLangley
- * @author bhouston / http://clara.io
- */
-
-THREE.Euler = function ( x, y, z, order ) {
-
-	this._x = x || 0;
-	this._y = y || 0;
-	this._z = z || 0;
-	this._order = order || THREE.Euler.DefaultOrder;
-
-};
-
-THREE.Euler.RotationOrders = [ 'XYZ', 'YZX', 'ZXY', 'XZY', 'YXZ', 'ZYX' ];
-
-THREE.Euler.DefaultOrder = 'XYZ';
-
-THREE.Euler.prototype = {
-
-	constructor: THREE.Euler,
-
-	get x () {
-
-		return this._x;
-
-	},
-
-	set x ( value ) {
-
-		this._x = value;
-		this.onChangeCallback();
-
-	},
-
-	get y () {
-
-		return this._y;
-
-	},
-
-	set y ( value ) {
-
-		this._y = value;
-		this.onChangeCallback();
-
-	},
-
-	get z () {
-
-		return this._z;
-
-	},
-
-	set z ( value ) {
-
-		this._z = value;
-		this.onChangeCallback();
-
-	},
-
-	get order () {
-
-		return this._order;
-
-	},
-
-	set order ( value ) {
-
-		this._order = value;
-		this.onChangeCallback();
-
-	},
-
-	set: function ( x, y, z, order ) {
-
-		this._x = x;
-		this._y = y;
-		this._z = z;
-		this._order = order || this._order;
-
-		this.onChangeCallback();
-
-		return this;
-
-	},
-
-	clone: function () {
-
-		return new this.constructor( this._x, this._y, this._z, this._order );
-
-	},
-
-	copy: function ( euler ) {
-
-		this._x = euler._x;
-		this._y = euler._y;
-		this._z = euler._z;
-		this._order = euler._order;
-
-		this.onChangeCallback();
-
-		return this;
-
-	},
-
-	setFromRotationMatrix: function ( m, order, update ) {
-
-		var clamp = THREE.Math.clamp;
-
-		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
-
-		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 ];
-
-		order = order || this._order;
-
-		if ( order === 'XYZ' ) {
-
-			this._y = Math.asin( clamp( m13, - 1, 1 ) );
-
-			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, - 1, 1 ) );
-
-			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, - 1, 1 ) );
-
-			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, - 1, 1 ) );
-
-			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, - 1, 1 ) );
-
-			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, - 1, 1 ) );
-
-			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;
-
-			}
-
-		} else {
-
-			console.warn( 'THREE.Euler: .setFromRotationMatrix() given unsupported order: ' + order );
-
-		}
-
-		this._order = order;
-
-		if ( update !== false ) this.onChangeCallback();
-
-		return this;
-
-	},
-
-	setFromQuaternion: function () {
-
-		var matrix;
-
-		return function ( q, order, update ) {
-
-			if ( matrix === undefined ) matrix = new THREE.Matrix4();
-			matrix.makeRotationFromQuaternion( q );
-			this.setFromRotationMatrix( matrix, order, update );
-
-			return this;
-
-		};
-
-	}(),
-
-	setFromVector3: function ( v, order ) {
-
-		return this.set( v.x, v.y, v.z, order || this._order );
-
-	},
-
-	reorder: function () {
-
-		// WARNING: this discards revolution information -bhouston
-
-		var q = new THREE.Quaternion();
-
-		return function ( newOrder ) {
-
-			q.setFromEuler( this );
-			this.setFromQuaternion( q, newOrder );
-
-		};
-
-	}(),
-
-	equals: function ( euler ) {
-
-		return ( euler._x === this._x ) && ( euler._y === this._y ) && ( euler._z === this._z ) && ( euler._order === this._order );
-
-	},
-
-	fromArray: function ( array ) {
-
-		this._x = array[ 0 ];
-		this._y = array[ 1 ];
-		this._z = array[ 2 ];
-		if ( array[ 3 ] !== undefined ) this._order = array[ 3 ];
-
-		this.onChangeCallback();
-
-		return this;
-
-	},
-
-	toArray: function ( array, offset ) {
-
-		if ( array === undefined ) array = [];
-		if ( offset === undefined ) offset = 0;
-
-		array[ offset ] = this._x;
-		array[ offset + 1 ] = this._y;
-		array[ offset + 2 ] = this._z;
-		array[ offset + 3 ] = this._order;
-
-		return array;
-
-	},
-
-	toVector3: function ( optionalResult ) {
-
-		if ( optionalResult ) {
-
-			return optionalResult.set( this._x, this._y, this._z );
-
-		} else {
-
-			return new THREE.Vector3( this._x, this._y, this._z );
-
-		}
-
-	},
-
-	onChange: function ( callback ) {
-
-		this.onChangeCallback = callback;
-
-		return this;
-
-	},
-
-	onChangeCallback: function () {}
-
-};
-
-// File:src/math/Line3.js
-
-/**
- * @author bhouston / http://clara.io
- */
-
-THREE.Line3 = function ( start, end ) {
-
-	this.start = ( start !== undefined ) ? start : new THREE.Vector3();
-	this.end = ( end !== undefined ) ? end : new THREE.Vector3();
-
-};
-
-THREE.Line3.prototype = {
-
-	constructor: THREE.Line3,
-
-	set: function ( start, end ) {
-
-		this.start.copy( start );
-		this.end.copy( end );
-
-		return this;
-
-	},
-
-	clone: function () {
-
-		return new this.constructor().copy( this );
-
-	},
-
-	copy: function ( line ) {
-
-		this.start.copy( line.start );
-		this.end.copy( line.end );
-
-		return this;
-
-	},
-
-	center: function ( optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector3();
-		return result.addVectors( this.start, this.end ).multiplyScalar( 0.5 );
-
-	},
-
-	delta: function ( optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector3();
-		return result.subVectors( this.end, this.start );
-
-	},
-
-	distanceSq: function () {
-
-		return this.start.distanceToSquared( this.end );
-
-	},
-
-	distance: function () {
-
-		return this.start.distanceTo( this.end );
-
-	},
-
-	at: function ( t, optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector3();
-
-		return this.delta( result ).multiplyScalar( t ).add( this.start );
-
-	},
-
-	closestPointToPointParameter: function () {
-
-		var startP = new THREE.Vector3();
-		var startEnd = new THREE.Vector3();
-
-		return function ( point, clampToLine ) {
-
-			startP.subVectors( point, this.start );
-			startEnd.subVectors( this.end, this.start );
-
-			var startEnd2 = startEnd.dot( startEnd );
-			var startEnd_startP = startEnd.dot( startP );
-
-			var t = startEnd_startP / startEnd2;
-
-			if ( clampToLine ) {
-
-				t = THREE.Math.clamp( t, 0, 1 );
-
-			}
-
-			return t;
-
-		};
-
-	}(),
-
-	closestPointToPoint: function ( point, clampToLine, optionalTarget ) {
-
-		var t = this.closestPointToPointParameter( point, clampToLine );
-
-		var result = optionalTarget || new THREE.Vector3();
-
-		return this.delta( result ).multiplyScalar( t ).add( this.start );
-
-	},
-
-	applyMatrix4: function ( matrix ) {
-
-		this.start.applyMatrix4( matrix );
-		this.end.applyMatrix4( matrix );
-
-		return this;
-
-	},
-
-	equals: function ( line ) {
-
-		return line.start.equals( this.start ) && line.end.equals( this.end );
-
-	}
-
-};
-
-// File:src/math/Box2.js
-
-/**
- * @author bhouston / http://clara.io
- */
-
-THREE.Box2 = function ( min, max ) {
-
-	this.min = ( min !== undefined ) ? min : new THREE.Vector2( + Infinity, + Infinity );
-	this.max = ( max !== undefined ) ? max : new THREE.Vector2( - Infinity, - Infinity );
-
-};
-
-THREE.Box2.prototype = {
-
-	constructor: THREE.Box2,
-
-	set: function ( min, max ) {
-
-		this.min.copy( min );
-		this.max.copy( max );
-
-		return this;
-
-	},
-
-	setFromPoints: function ( points ) {
-
-		this.makeEmpty();
-
-		for ( var i = 0, il = points.length; i < il; i ++ ) {
-
-			this.expandByPoint( points[ i ] );
-
-		}
-
-		return this;
-
-	},
-
-	setFromCenterAndSize: function () {
-
-		var v1 = new THREE.Vector2();
-
-		return function ( center, size ) {
-
-			var halfSize = v1.copy( size ).multiplyScalar( 0.5 );
-			this.min.copy( center ).sub( halfSize );
-			this.max.copy( center ).add( halfSize );
-
-			return this;
-
-		};
-
-	}(),
-
-	clone: function () {
-
-		return new this.constructor().copy( this );
-
-	},
-
-	copy: function ( box ) {
-
-		this.min.copy( box.min );
-		this.max.copy( box.max );
-
-		return this;
-
-	},
-
-	makeEmpty: function () {
-
-		this.min.x = this.min.y = + Infinity;
-		this.max.x = this.max.y = - Infinity;
-
-		return this;
-
-	},
-
-	isEmpty: function () {
-
-		// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
-
-		return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y );
-
-	},
-
-	center: function ( optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector2();
-		return result.addVectors( this.min, this.max ).multiplyScalar( 0.5 );
-
-	},
-
-	size: function ( optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector2();
-		return result.subVectors( this.max, this.min );
-
-	},
-
-	expandByPoint: function ( point ) {
-
-		this.min.min( point );
-		this.max.max( point );
-
-		return this;
-
-	},
-
-	expandByVector: function ( vector ) {
-
-		this.min.sub( vector );
-		this.max.add( vector );
-
-		return this;
-
-	},
-
-	expandByScalar: function ( scalar ) {
-
-		this.min.addScalar( - scalar );
-		this.max.addScalar( scalar );
-
-		return this;
-
-	},
-
-	containsPoint: function ( point ) {
-
-		if ( point.x < this.min.x || point.x > this.max.x ||
-		     point.y < this.min.y || point.y > this.max.y ) {
-
-			return false;
-
-		}
-
-		return true;
-
-	},
-
-	containsBox: function ( box ) {
-
-		if ( ( this.min.x <= box.min.x ) && ( box.max.x <= this.max.x ) &&
-		     ( this.min.y <= box.min.y ) && ( box.max.y <= this.max.y ) ) {
-
-			return true;
-
-		}
-
-		return false;
-
-	},
-
-	getParameter: function ( point, optionalTarget ) {
-
-		// This can potentially have a divide by zero if the box
-		// has a size dimension of 0.
-
-		var result = optionalTarget || new THREE.Vector2();
-
-		return result.set(
-			( point.x - this.min.x ) / ( this.max.x - this.min.x ),
-			( point.y - this.min.y ) / ( this.max.y - this.min.y )
-		);
-
-	},
-
-	intersectsBox: function ( box ) {
-
-		// using 6 splitting planes to rule out intersections.
-
-		if ( box.max.x < this.min.x || box.min.x > this.max.x ||
-		     box.max.y < this.min.y || box.min.y > this.max.y ) {
-
-			return false;
-
-		}
-
-		return true;
-
-	},
-
-	clampPoint: function ( point, optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector2();
-		return result.copy( point ).clamp( this.min, this.max );
-
-	},
-
-	distanceToPoint: function () {
-
-		var v1 = new THREE.Vector2();
-
-		return function ( point ) {
-
-			var clampedPoint = v1.copy( point ).clamp( this.min, this.max );
-			return clampedPoint.sub( point ).length();
-
-		};
-
-	}(),
-
-	intersect: function ( box ) {
-
-		this.min.max( box.min );
-		this.max.min( box.max );
-
-		return this;
-
-	},
-
-	union: function ( box ) {
-
-		this.min.min( box.min );
-		this.max.max( box.max );
-
-		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 );
-
-	}
-
-};
-
-// File:src/math/Box3.js
-
-/**
- * @author bhouston / http://clara.io
- * @author WestLangley / http://github.com/WestLangley
- */
-
-THREE.Box3 = function ( min, max ) {
-
-	this.min = ( min !== undefined ) ? min : new THREE.Vector3( + Infinity, + Infinity, + Infinity );
-	this.max = ( max !== undefined ) ? max : new THREE.Vector3( - Infinity, - Infinity, - Infinity );
-
-};
-
-THREE.Box3.prototype = {
-
-	constructor: THREE.Box3,
-
-	set: function ( min, max ) {
-
-		this.min.copy( min );
-		this.max.copy( max );
-
-		return this;
-
-	},
-
-	setFromArray: function ( array ) {
-
-		var minX = + Infinity;
-		var minY = + Infinity;
-		var minZ = + Infinity;
-
-		var maxX = - Infinity;
-		var maxY = - Infinity;
-		var maxZ = - Infinity;
-
-		for ( var i = 0, l = array.length; i < l; i += 3 ) {
-
-			var x = array[ i ];
-			var y = array[ i + 1 ];
-			var z = array[ i + 2 ];
-
-			if ( x < minX ) minX = x;
-			if ( y < minY ) minY = y;
-			if ( z < minZ ) minZ = z;
-
-			if ( x > 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 );
-
-	},
-
-	setFromPoints: function ( points ) {
-
-		this.makeEmpty();
-
-		for ( var i = 0, il = points.length; i < il; i ++ ) {
-
-			this.expandByPoint( points[ i ] );
-
-		}
-
-		return this;
-
-	},
-
-	setFromCenterAndSize: function () {
-
-		var v1 = new THREE.Vector3();
-
-		return function ( center, size ) {
-
-			var halfSize = v1.copy( size ).multiplyScalar( 0.5 );
-
-			this.min.copy( center ).sub( halfSize );
-			this.max.copy( center ).add( halfSize );
-
-			return this;
-
-		};
-
-	}(),
-
-	setFromObject: function () {
-
-		// Computes the world-axis-aligned bounding box of an object (including its children),
-		// accounting for both the object's, and children's, world transforms
-
-		var v1 = new THREE.Vector3();
-
-		return function ( object ) {
-
-			var scope = this;
-
-			object.updateMatrixWorld( true );
-
-			this.makeEmpty();
-
-			object.traverse( function ( node ) {
-
-				var geometry = node.geometry;
-
-				if ( geometry !== undefined ) {
-
-					if ( geometry instanceof THREE.Geometry ) {
-
-						var vertices = geometry.vertices;
-
-						for ( var i = 0, il = vertices.length; i < il; i ++ ) {
-
-							v1.copy( vertices[ i ] );
-							v1.applyMatrix4( node.matrixWorld );
-
-							scope.expandByPoint( v1 );
-
-						}
-
-					} else if ( geometry instanceof THREE.BufferGeometry && geometry.attributes[ 'position' ] !== undefined ) {
-
-						var positions = geometry.attributes[ 'position' ].array;
-
-						for ( var i = 0, il = positions.length; i < il; i += 3 ) {
-
-							v1.fromArray( positions, i );
-							v1.applyMatrix4( node.matrixWorld );
-
-							scope.expandByPoint( v1 );
-
-						}
-
-					}
-
-				}
-
-			} );
-
-			return this;
-
-		};
-
-	}(),
-
-	clone: function () {
-
-		return new this.constructor().copy( this );
-
-	},
-
-	copy: function ( box ) {
-
-		this.min.copy( box.min );
-		this.max.copy( box.max );
-
-		return this;
-
-	},
-
-	makeEmpty: function () {
-
-		this.min.x = this.min.y = this.min.z = + Infinity;
-		this.max.x = this.max.y = this.max.z = - Infinity;
-
-		return this;
-
-	},
-
-	isEmpty: function () {
-
-		// this is a more robust check for empty than ( volume <= 0 ) because volume can get positive with two negative axes
-
-		return ( this.max.x < this.min.x ) || ( this.max.y < this.min.y ) || ( this.max.z < this.min.z );
-
-	},
-
-	center: function ( optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector3();
-		return result.addVectors( this.min, this.max ).multiplyScalar( 0.5 );
-
-	},
-
-	size: function ( optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector3();
-		return result.subVectors( this.max, this.min );
-
-	},
-
-	expandByPoint: function ( point ) {
-
-		this.min.min( point );
-		this.max.max( point );
-
-		return this;
-
-	},
-
-	expandByVector: function ( vector ) {
-
-		this.min.sub( vector );
-		this.max.add( vector );
-
-		return this;
-
-	},
-
-	expandByScalar: function ( scalar ) {
-
-		this.min.addScalar( - scalar );
-		this.max.addScalar( scalar );
-
-		return this;
-
-	},
-
-	containsPoint: function ( point ) {
-
-		if ( point.x < this.min.x || point.x > this.max.x ||
-				 point.y < this.min.y || point.y > this.max.y ||
-				 point.z < this.min.z || point.z > this.max.z ) {
-
-			return false;
-
-		}
-
-		return true;
-
-	},
-
-	containsBox: function ( box ) {
-
-		if ( ( this.min.x <= box.min.x ) && ( box.max.x <= this.max.x ) &&
-			 ( this.min.y <= box.min.y ) && ( box.max.y <= this.max.y ) &&
-			 ( this.min.z <= box.min.z ) && ( box.max.z <= this.max.z ) ) {
-
-			return true;
-
-		}
-
-		return false;
-
-	},
-
-	getParameter: function ( point, optionalTarget ) {
-
-		// This can potentially have a divide by zero if the box
-		// has a size dimension of 0.
-
-		var result = optionalTarget || new THREE.Vector3();
-
-		return result.set(
-			( point.x - this.min.x ) / ( this.max.x - this.min.x ),
-			( point.y - this.min.y ) / ( this.max.y - this.min.y ),
-			( point.z - this.min.z ) / ( this.max.z - this.min.z )
-		);
-
-	},
-
-	intersectsBox: function ( box ) {
-
-		// using 6 splitting planes to rule out intersections.
-
-		if ( box.max.x < this.min.x || box.min.x > this.max.x ||
-				 box.max.y < this.min.y || box.min.y > this.max.y ||
-				 box.max.z < this.min.z || box.min.z > this.max.z ) {
-
-			return false;
-
-		}
-
-		return true;
-
-	},
-
-	intersectsSphere: ( function () {
-
-		var closestPoint;
-
-		return function intersectsSphere( sphere ) {
-
-			if ( closestPoint === undefined ) closestPoint = new THREE.Vector3();
-
-			// Find the point on the AABB closest to the sphere center.
-			this.clampPoint( sphere.center, closestPoint );
-
-			// If that point is inside the sphere, the AABB and sphere intersect.
-			return closestPoint.distanceToSquared( sphere.center ) <= ( sphere.radius * sphere.radius );
-
-		};
-
-	} )(),
-
-	intersectsPlane: function ( plane ) {
-
-		// We compute the minimum and maximum dot product values. If those values
-		// are on the same side (back or front) of the plane, then there is no intersection.
-
-		var min, max;
-
-		if ( plane.normal.x > 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 && max >= plane.constant );
-
-	},
-
-	clampPoint: function ( point, optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector3();
-		return result.copy( point ).clamp( this.min, this.max );
-
-	},
-
-	distanceToPoint: function () {
-
-		var v1 = new THREE.Vector3();
-
-		return function ( point ) {
-
-			var clampedPoint = v1.copy( point ).clamp( this.min, this.max );
-			return clampedPoint.sub( point ).length();
-
-		};
-
-	}(),
-
-	getBoundingSphere: function () {
-
-		var v1 = new THREE.Vector3();
-
-		return function ( optionalTarget ) {
-
-			var result = optionalTarget || new THREE.Sphere();
-
-			result.center = this.center();
-			result.radius = this.size( v1 ).length() * 0.5;
-
-			return result;
-
-		};
-
-	}(),
-
-	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 () {
-
-		var points = [
-			new THREE.Vector3(),
-			new THREE.Vector3(),
-			new THREE.Vector3(),
-			new THREE.Vector3(),
-			new THREE.Vector3(),
-			new THREE.Vector3(),
-			new THREE.Vector3(),
-			new THREE.Vector3()
-		];
-
-		return 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 );
-
-	}
-
-};
-
-// File:src/math/Matrix3.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- * @author WestLangley / http://github.com/WestLangley
- * @author bhouston / http://clara.io
- * @author tschw
- */
-
-THREE.Matrix3 = function () {
-
-	this.elements = new Float32Array( [
-
-		1, 0, 0,
-		0, 1, 0,
-		0, 0, 1
-
-	] );
-
-	if ( arguments.length > 0 ) {
-
-		console.error( 'THREE.Matrix3: the constructor no longer reads arguments. use .set() instead.' );
-
-	}
-
-};
-
-THREE.Matrix3.prototype = {
-
-	constructor: THREE.Matrix3,
-
-	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 me = m.elements;
-
-		this.set(
-
-			me[ 0 ], me[ 3 ], me[ 6 ],
-			me[ 1 ], me[ 4 ], me[ 7 ],
-			me[ 2 ], me[ 5 ], me[ 8 ]
-
-		);
-
-		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;
-
-	},
-
-	applyToVector3Array: function () {
-
-		var v1;
-
-		return function ( array, offset, length ) {
-
-			if ( v1 === undefined ) v1 = new THREE.Vector3();
-			if ( offset === undefined ) offset = 0;
-			if ( length === undefined ) length = array.length;
-
-			for ( var i = 0, j = offset; i < length; i += 3, j += 3 ) {
-
-				v1.fromArray( array, j );
-				v1.applyMatrix3( this );
-				v1.toArray( array, j );
-
-			}
-
-			return array;
-
-		};
-
-	}(),
-
-	applyToBuffer: function () {
-
-		var v1;
-
-		return function applyToBuffer( buffer, offset, length ) {
-
-			if ( v1 === undefined ) v1 = new THREE.Vector3();
-			if ( offset === undefined ) offset = 0;
-			if ( length === undefined ) length = buffer.length / buffer.itemSize;
-
-			for ( var i = 0, j = offset; i < length; i ++, j ++ ) {
-
-				v1.x = buffer.getX( j );
-				v1.y = buffer.getY( j );
-				v1.z = buffer.getZ( j );
-
-				v1.applyMatrix3( this );
-
-				buffer.setXYZ( v1.x, v1.y, v1.z );
-
-			}
-
-			return buffer;
-
-		};
-
-	}(),
-
-	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 ( matrix instanceof THREE.Matrix4 ) {
-
-			console.error( "THREE.Matrix3.getInverse no longer takes a Matrix4 argument." );
-
-		}
-
-		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 ) {
-
-			var msg = "THREE.Matrix3.getInverse(): can't invert matrix, determinant is 0";
-
-			if ( throwOnDegenerate || false ) {
-
-				throw new Error( msg );
-
-			} else {
-
-				console.warn( msg );
-
-			}
-
-			return this.identity();
-		}
-
-		te[ 0 ] = t11;
-		te[ 1 ] = n31 * n23 - n33 * n21;
-		te[ 2 ] = n32 * n21 - n31 * n22;
-
-		te[ 3 ] = t12;
-		te[ 4 ] = n33 * n11 - n31 * n13;
-		te[ 5 ] = n31 * n12 - n32 * n11;
-
-		te[ 6 ] = t13;
-		te[ 7 ] = n21 * n13 - n23 * n11;
-		te[ 8 ] = n22 * n11 - n21 * n12;
-
-		return this.multiplyScalar( 1 / det );
-
-	},
-
-	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;
-
-	},
-
-	flattenToArrayOffset: function ( array, offset ) {
-
-		console.warn( "THREE.Matrix3: .flattenToArrayOffset is deprecated " +
-				"- just use .toArray instead." );
-
-		return this.toArray( array, offset );
-
-	},
-
-	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;
-
-	},
-
-	fromArray: function ( array ) {
-
-		this.elements.set( array );
-
-		return this;
-
-	},
-
-	toArray: function ( array, offset ) {
-
-		if ( array === undefined ) array = [];
-		if ( offset === undefined ) offset = 0;
-
-		var te = this.elements;
-
-		array[ offset ] = te[ 0 ];
-		array[ offset + 1 ] = te[ 1 ];
-		array[ offset + 2 ] = te[ 2 ];
-
-		array[ offset + 3 ] = te[ 3 ];
-		array[ offset + 4 ] = te[ 4 ];
-		array[ offset + 5 ] = te[ 5 ];
-
-		array[ offset + 6 ] = te[ 6 ];
-		array[ offset + 7 ] = te[ 7 ];
-		array[ offset + 8 ]  = te[ 8 ];
-
-		return array;
-
-	}
-
-};
-
-// File:src/math/Matrix4.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author supereggbert / http://www.paulbrunt.co.uk/
- * @author philogb / http://blog.thejit.org/
- * @author jordi_ros / http://plattsoft.com
- * @author D1plo1d / http://github.com/D1plo1d
- * @author alteredq / http://alteredqualia.com/
- * @author mikael emtinger / http://gomo.se/
- * @author timknip / http://www.floorplanner.com/
- * @author bhouston / http://clara.io
- * @author WestLangley / http://github.com/WestLangley
- */
-
-THREE.Matrix4 = function () {
-
-	this.elements = new Float32Array( [
-
-		1, 0, 0, 0,
-		0, 1, 0, 0,
-		0, 0, 1, 0,
-		0, 0, 0, 1
-
-	] );
-
-	if ( arguments.length > 0 ) {
-
-		console.error( 'THREE.Matrix4: the constructor no longer reads arguments. use .set() instead.' );
-
-	}
-
-};
-
-THREE.Matrix4.prototype = {
-
-	constructor: THREE.Matrix4,
-
-	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 THREE.Matrix4().fromArray( this.elements );
-
-	},
-
-	copy: function ( m ) {
-
-		this.elements.set( m.elements );
-
-		return this;
-
-	},
-
-	copyPosition: function ( m ) {
-
-		var te = this.elements;
-		var 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 () {
-
-		var v1;
-
-		return function ( m ) {
-
-			if ( v1 === undefined ) v1 = new THREE.Vector3();
-
-			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[ 4 ] = me[ 4 ] * scaleY;
-			te[ 5 ] = me[ 5 ] * scaleY;
-			te[ 6 ] = me[ 6 ] * scaleY;
-
-			te[ 8 ] = me[ 8 ] * scaleZ;
-			te[ 9 ] = me[ 9 ] * scaleZ;
-			te[ 10 ] = me[ 10 ] * scaleZ;
-
-			return this;
-
-		};
-
-	}(),
-
-	makeRotationFromEuler: function ( euler ) {
-
-		if ( euler instanceof THREE.Euler === false ) {
-
-			console.error( 'THREE.Matrix: .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;
-
-		}
-
-		// last column
-		te[ 3 ] = 0;
-		te[ 7 ] = 0;
-		te[ 11 ] = 0;
-
-		// bottom row
-		te[ 12 ] = 0;
-		te[ 13 ] = 0;
-		te[ 14 ] = 0;
-		te[ 15 ] = 1;
-
-		return this;
-
-	},
-
-	makeRotationFromQuaternion: function ( q ) {
-
-		var te = this.elements;
-
-		var x = q.x, y = q.y, z = q.z, w = q.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;
-
-		te[ 0 ] = 1 - ( yy + zz );
-		te[ 4 ] = xy - wz;
-		te[ 8 ] = xz + wy;
-
-		te[ 1 ] = xy + wz;
-		te[ 5 ] = 1 - ( xx + zz );
-		te[ 9 ] = yz - wx;
-
-		te[ 2 ] = xz - wy;
-		te[ 6 ] = yz + wx;
-		te[ 10 ] = 1 - ( xx + yy );
-
-		// last column
-		te[ 3 ] = 0;
-		te[ 7 ] = 0;
-		te[ 11 ] = 0;
-
-		// bottom row
-		te[ 12 ] = 0;
-		te[ 13 ] = 0;
-		te[ 14 ] = 0;
-		te[ 15 ] = 1;
-
-		return this;
-
-	},
-
-	lookAt: function () {
-
-		var x, y, z;
-
-		return function ( eye, target, up ) {
-
-			if ( x === undefined ) x = new THREE.Vector3();
-			if ( y === undefined ) y = new THREE.Vector3();
-			if ( z === undefined ) z = new THREE.Vector3();
-
-			var te = this.elements;
-
-			z.subVectors( eye, target ).normalize();
-
-			if ( z.lengthSq() === 0 ) {
-
-				z.z = 1;
-
-			}
-
-			x.crossVectors( up, z ).normalize();
-
-			if ( x.lengthSq() === 0 ) {
-
-				z.x += 0.0001;
-				x.crossVectors( up, z ).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;
-
-	},
-
-	multiplyToArray: function ( a, b, r ) {
-
-		var te = this.elements;
-
-		this.multiplyMatrices( a, b );
-
-		r[ 0 ] = te[ 0 ]; r[ 1 ] = te[ 1 ]; r[ 2 ] = te[ 2 ]; r[ 3 ] = te[ 3 ];
-		r[ 4 ] = te[ 4 ]; r[ 5 ] = te[ 5 ]; r[ 6 ] = te[ 6 ]; r[ 7 ] = te[ 7 ];
-		r[ 8 ]  = te[ 8 ]; r[ 9 ]  = te[ 9 ]; r[ 10 ] = te[ 10 ]; r[ 11 ] = te[ 11 ];
-		r[ 12 ] = te[ 12 ]; r[ 13 ] = te[ 13 ]; r[ 14 ] = te[ 14 ]; r[ 15 ] = te[ 15 ];
-
-		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;
-
-	},
-
-	applyToVector3Array: function () {
-
-		var v1;
-
-		return function ( array, offset, length ) {
-
-			if ( v1 === undefined ) v1 = new THREE.Vector3();
-			if ( offset === undefined ) offset = 0;
-			if ( length === undefined ) length = array.length;
-
-			for ( var i = 0, j = offset; i < length; i += 3, j += 3 ) {
-
-				v1.fromArray( array, j );
-				v1.applyMatrix4( this );
-				v1.toArray( array, j );
-
-			}
-
-			return array;
-
-		};
-
-	}(),
-
-	applyToBuffer: function () {
-
-		var v1;
-
-		return function applyToBuffer( buffer, offset, length ) {
-
-			if ( v1 === undefined ) v1 = new THREE.Vector3();
-			if ( offset === undefined ) offset = 0;
-			if ( length === undefined ) length = buffer.length / buffer.itemSize;
-
-			for ( var i = 0, j = offset; i < length; i ++, j ++ ) {
-
-				v1.x = buffer.getX( j );
-				v1.y = buffer.getY( j );
-				v1.z = buffer.getZ( j );
-
-				v1.applyMatrix4( this );
-
-				buffer.setXYZ( v1.x, v1.y, v1.z );
-
-			}
-
-			return buffer;
-
-		};
-
-	}(),
-
-	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;
-
-	},
-
-	flattenToArrayOffset: function ( array, offset ) {
-
-		console.warn( "THREE.Matrix3: .flattenToArrayOffset is deprecated " +
-				"- just use .toArray instead." );
-
-		return this.toArray( array, offset );
-
-	},
-
-	getPosition: function () {
-
-		var v1;
-
-		return function () {
-
-			if ( v1 === undefined ) v1 = new THREE.Vector3();
-			console.warn( 'THREE.Matrix4: .getPosition() has been removed. Use Vector3.setFromMatrixPosition( matrix ) instead.' );
-
-			return v1.setFromMatrixColumn( this, 3 );
-
-		};
-
-	}(),
-
-	setPosition: function ( v ) {
-
-		var te = this.elements;
-
-		te[ 12 ] = v.x;
-		te[ 13 ] = v.y;
-		te[ 14 ] = v.z;
-
-		return this;
-
-	},
-
-	getInverse: function ( m, throwOnDegenerate ) {
-
-		// 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 ) {
-
-			var msg = "THREE.Matrix4.getInverse(): can't invert matrix, determinant is 0";
-
-			if ( throwOnDegenerate || false ) {
-
-				throw new Error( msg );
-
-			} else {
-
-				console.warn( msg );
-
-			}
-
-			return this.identity();
-
-		}
-
-		te[ 0 ] = t11;
-		te[ 1 ] = n24 * n33 * n41 - n23 * n34 * n41 - n24 * n31 * n43 + n21 * n34 * n43 + n23 * n31 * n44 - n21 * n33 * n44;
-		te[ 2 ] = n22 * n34 * n41 - n24 * n32 * n41 + n24 * n31 * n42 - n21 * n34 * n42 - n22 * n31 * n44 + n21 * n32 * n44;
-		te[ 3 ] = n23 * n32 * n41 - n22 * n33 * n41 - n23 * n31 * n42 + n21 * n33 * n42 + n22 * n31 * n43 - n21 * n32 * n43;
-
-		te[ 4 ] = t12;
-		te[ 5 ] = n13 * n34 * n41 - n14 * n33 * n41 + n14 * n31 * n43 - n11 * n34 * n43 - n13 * n31 * n44 + n11 * n33 * n44;
-		te[ 6 ] = n14 * n32 * n41 - n12 * n34 * n41 - n14 * n31 * n42 + n11 * n34 * n42 + n12 * n31 * n44 - n11 * n32 * n44;
-		te[ 7 ] = n12 * n33 * n41 - n13 * n32 * n41 + n13 * n31 * n42 - n11 * n33 * n42 - n12 * n31 * n43 + n11 * n32 * n43;
-
-		te[ 8 ] = t13;
-		te[ 9 ] = n14 * n23 * n41 - n13 * n24 * n41 - n14 * n21 * n43 + n11 * n24 * n43 + n13 * n21 * n44 - n11 * n23 * n44;
-		te[ 10 ] = n12 * n24 * n41 - n14 * n22 * n41 + n14 * n21 * n42 - n11 * n24 * n42 - n12 * n21 * n44 + n11 * n22 * n44;
-		te[ 11 ] = n13 * n22 * n41 - n12 * n23 * n41 - n13 * n21 * n42 + n11 * n23 * n42 + n12 * n21 * n43 - n11 * n22 * n43;
-
-		te[ 12 ] = t14;
-		te[ 13 ] = n13 * n24 * n31 - n14 * n23 * n31 + n14 * n21 * n33 - n11 * n24 * n33 - n13 * n21 * n34 + n11 * n23 * n34;
-		te[ 14 ] = n14 * n22 * n31 - n12 * n24 * n31 - n14 * n21 * n32 + n11 * n24 * n32 + n12 * n21 * n34 - n11 * n22 * n34;
-		te[ 15 ] = n12 * n23 * n31 - n13 * n22 * n31 + n13 * n21 * n32 - n11 * n23 * n32 - n12 * n21 * n33 + n11 * n22 * n33;
-
-		return this.multiplyScalar( 1 / det );
-
-	},
-
-	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;
-
-	},
-
-	compose: function ( position, quaternion, scale ) {
-
-		this.makeRotationFromQuaternion( quaternion );
-		this.scale( scale );
-		this.setPosition( position );
-
-		return this;
-
-	},
-
-	decompose: function () {
-
-		var vector, matrix;
-
-		return function ( position, quaternion, scale ) {
-
-			if ( vector === undefined ) vector = new THREE.Vector3();
-			if ( matrix === undefined ) matrix = new THREE.Matrix4();
-
-			var te = this.elements;
-
-			var sx = vector.set( te[ 0 ], te[ 1 ], te[ 2 ] ).length();
-			var sy = vector.set( te[ 4 ], te[ 5 ], te[ 6 ] ).length();
-			var sz = vector.set( te[ 8 ], te[ 9 ], te[ 10 ] ).length();
-
-			// if determine is negative, we need to invert one scale
-			var det = this.determinant();
-			if ( det < 0 ) {
-
-				sx = - sx;
-
-			}
-
-			position.x = te[ 12 ];
-			position.y = te[ 13 ];
-			position.z = te[ 14 ];
-
-			// scale the rotation part
-
-			matrix.elements.set( this.elements ); // at this point matrix is incomplete so we can't use .copy()
-
-			var invSX = 1 / sx;
-			var invSY = 1 / sy;
-			var invSZ = 1 / sz;
-
-			matrix.elements[ 0 ] *= invSX;
-			matrix.elements[ 1 ] *= invSX;
-			matrix.elements[ 2 ] *= invSX;
-
-			matrix.elements[ 4 ] *= invSY;
-			matrix.elements[ 5 ] *= invSY;
-			matrix.elements[ 6 ] *= invSY;
-
-			matrix.elements[ 8 ] *= invSZ;
-			matrix.elements[ 9 ] *= invSZ;
-			matrix.elements[ 10 ] *= invSZ;
-
-			quaternion.setFromRotationMatrix( matrix );
-
-			scale.x = sx;
-			scale.y = sy;
-			scale.z = sz;
-
-			return this;
-
-		};
-
-	}(),
-
-	makeFrustum: function ( left, right, bottom, top, near, far ) {
-
-		var te = this.elements;
-		var x = 2 * near / ( right - left );
-		var y = 2 * near / ( top - bottom );
-
-		var a = ( right + left ) / ( right - left );
-		var b = ( top + bottom ) / ( top - bottom );
-		var c = - ( far + near ) / ( far - near );
-		var d = - 2 * far * near / ( far - near );
-
-		te[ 0 ] = x;	te[ 4 ] = 0;	te[ 8 ] = a;	te[ 12 ] = 0;
-		te[ 1 ] = 0;	te[ 5 ] = y;	te[ 9 ] = b;	te[ 13 ] = 0;
-		te[ 2 ] = 0;	te[ 6 ] = 0;	te[ 10 ] = c;	te[ 14 ] = d;
-		te[ 3 ] = 0;	te[ 7 ] = 0;	te[ 11 ] = - 1;	te[ 15 ] = 0;
-
-		return this;
-
-	},
-
-	makePerspective: function ( fov, aspect, near, far ) {
-
-		var ymax = near * Math.tan( THREE.Math.DEG2RAD * fov * 0.5 );
-		var ymin = - ymax;
-		var xmin = ymin * aspect;
-		var xmax = ymax * aspect;
-
-		return this.makeFrustum( xmin, xmax, ymin, ymax, near, far );
-
-	},
-
-	makeOrthographic: function ( left, right, top, bottom, near, far ) {
-
-		var te = this.elements;
-		var w = 1.0 / ( right - left );
-		var h = 1.0 / ( top - bottom );
-		var p = 1.0 / ( far - near );
-
-		var x = ( right + left ) * w;
-		var y = ( top + bottom ) * h;
-		var z = ( far + near ) * p;
-
-		te[ 0 ] = 2 * w;	te[ 4 ] = 0;	te[ 8 ] = 0;	te[ 12 ] = - x;
-		te[ 1 ] = 0;	te[ 5 ] = 2 * h;	te[ 9 ] = 0;	te[ 13 ] = - y;
-		te[ 2 ] = 0;	te[ 6 ] = 0;	te[ 10 ] = - 2 * p;	te[ 14 ] = - z;
-		te[ 3 ] = 0;	te[ 7 ] = 0;	te[ 11 ] = 0;	te[ 15 ] = 1;
-
-		return this;
-
-	},
-
-	equals: function ( matrix ) {
-
-		var te = this.elements;
-		var me = matrix.elements;
-
-		for ( var i = 0; i < 16; i ++ ) {
-
-			if ( te[ i ] !== me[ i ] ) return false;
-
-		}
-
-		return true;
-
-	},
-
-	fromArray: function ( array ) {
-
-		this.elements.set( array );
-
-		return this;
-
-	},
-
-	toArray: function ( array, offset ) {
-
-		if ( array === undefined ) array = [];
-		if ( offset === undefined ) offset = 0;
-
-		var te = this.elements;
-
-		array[ offset ] = te[ 0 ];
-		array[ offset + 1 ] = te[ 1 ];
-		array[ offset + 2 ] = te[ 2 ];
-		array[ offset + 3 ] = te[ 3 ];
-
-		array[ offset + 4 ] = te[ 4 ];
-		array[ offset + 5 ] = te[ 5 ];
-		array[ offset + 6 ] = te[ 6 ];
-		array[ offset + 7 ] = te[ 7 ];
-
-		array[ offset + 8 ]  = te[ 8 ];
-		array[ offset + 9 ]  = te[ 9 ];
-		array[ offset + 10 ] = te[ 10 ];
-		array[ offset + 11 ] = te[ 11 ];
-
-		array[ offset + 12 ] = te[ 12 ];
-		array[ offset + 13 ] = te[ 13 ];
-		array[ offset + 14 ] = te[ 14 ];
-		array[ offset + 15 ] = te[ 15 ];
-
-		return array;
-
-	}
-
-};
-
-// File:src/math/Ray.js
-
-/**
- * @author bhouston / http://clara.io
- */
-
-THREE.Ray = function ( origin, direction ) {
-
-	this.origin = ( origin !== undefined ) ? origin : new THREE.Vector3();
-	this.direction = ( direction !== undefined ) ? direction : new THREE.Vector3();
-
-};
-
-THREE.Ray.prototype = {
-
-	constructor: THREE.Ray,
-
-	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, optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector3();
-
-		return result.copy( this.direction ).multiplyScalar( t ).add( this.origin );
-
-	},
-
-	lookAt: function ( v ) {
-
-		this.direction.copy( v ).sub( this.origin ).normalize();
-
-	},
-
-	recast: function () {
-
-		var v1 = new THREE.Vector3();
-
-		return function ( t ) {
-
-			this.origin.copy( this.at( t, v1 ) );
-
-			return this;
-
-		};
-
-	}(),
-
-	closestPointToPoint: function ( point, optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector3();
-		result.subVectors( point, this.origin );
-		var directionDistance = result.dot( this.direction );
-
-		if ( directionDistance < 0 ) {
-
-			return result.copy( this.origin );
-
-		}
-
-		return result.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin );
-
-	},
-
-	distanceToPoint: function ( point ) {
-
-		return Math.sqrt( this.distanceSqToPoint( point ) );
-
-	},
-
-	distanceSqToPoint: function () {
-
-		var v1 = new THREE.Vector3();
-
-		return function ( point ) {
-
-			var directionDistance = v1.subVectors( point, this.origin ).dot( this.direction );
-
-			// point behind the ray
-
-			if ( directionDistance < 0 ) {
-
-				return this.origin.distanceToSquared( point );
-
-			}
-
-			v1.copy( this.direction ).multiplyScalar( directionDistance ).add( this.origin );
-
-			return v1.distanceToSquared( point );
-
-		};
-
-	}(),
-
-	distanceSqToSegment: function () {
-
-		var segCenter = new THREE.Vector3();
-		var segDir = new THREE.Vector3();
-		var diff = new THREE.Vector3();
-
-		return function ( v0, v1, optionalPointOnRay, optionalPointOnSegment ) {
-
-			// from http://www.geometrictools.com/LibMathematics/Distance/Wm5DistRay3Segment3.cpp
-			// It returns the min distance between the ray and the segment
-			// defined by v0 and v1
-			// It can also set two optional targets :
-			// - The closest point on the ray
-			// - The closest point on the segment
-
-			segCenter.copy( v0 ).add( v1 ).multiplyScalar( 0.5 );
-			segDir.copy( v1 ).sub( v0 ).normalize();
-			diff.copy( this.origin ).sub( segCenter );
-
-			var segExtent = v0.distanceTo( v1 ) * 0.5;
-			var a01 = - this.direction.dot( segDir );
-			var b0 = diff.dot( this.direction );
-			var b1 = - diff.dot( segDir );
-			var c = diff.lengthSq();
-			var det = Math.abs( 1 - a01 * a01 );
-			var s0, s1, sqrDist, extDet;
-
-			if ( det > 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 <= extDet ) {
-
-							// region 0
-							// Minimum at interior points of ray and segment.
-
-							var invDet = 1 / det;
-							s0 *= invDet;
-							s1 *= invDet;
-							sqrDist = s0 * ( s0 + a01 * s1 + 2 * b0 ) + s1 * ( a01 * s0 + s1 + 2 * b1 ) + c;
-
-						} else {
-
-							// region 1
-
-							s1 = segExtent;
-							s0 = Math.max( 0, - ( a01 * s1 + b0 ) );
-							sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
-
-						}
-
-					} else {
-
-						// region 5
-
-						s1 = - segExtent;
-						s0 = Math.max( 0, - ( a01 * s1 + b0 ) );
-						sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
-
-					}
-
-				} else {
-
-					if ( s1 <= - extDet ) {
-
-						// region 4
-
-						s0 = Math.max( 0, - ( - a01 * segExtent + b0 ) );
-						s1 = ( s0 > 0 ) ? - segExtent : Math.min( Math.max( - segExtent, - b1 ), segExtent );
-						sqrDist = - s0 * s0 + s1 * ( s1 + 2 * b1 ) + c;
-
-					} else if ( s1 <= extDet ) {
-
-						// region 3
-
-						s0 = 0;
-						s1 = Math.min( Math.max( - segExtent, - b1 ), segExtent );
-						sqrDist = s1 * ( s1 + 2 * b1 ) + c;
-
-					} else {
-
-						// region 2
-
-						s0 = Math.max( 0, - ( a01 * segExtent + b0 ) );
-						s1 = ( s0 > 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 () {
-
-		var v1 = new THREE.Vector3();
-
-		return function ( sphere, optionalTarget ) {
-
-			v1.subVectors( sphere.center, this.origin );
-			var tca = v1.dot( this.direction );
-			var d2 = v1.dot( v1 ) - 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 && t1 < 0 ) return null;
-
-			// test to see if t0 is behind the ray:
-			// if it is, the ray is inside the sphere, so return the second exit point scaled by t1,
-			// in order to always return an intersect point that is in front of the ray.
-			if ( t0 < 0 ) return this.at( t1, optionalTarget );
-
-			// else t0 is in front of the ray, so return the first collision point scaled by t0
-			return this.at( t0, optionalTarget );
-
-		};
-
-	}(),
-
-	intersectsSphere: function ( sphere ) {
-
-		return this.distanceToPoint( sphere.center ) <= sphere.radius;
-
-	},
-
-	distanceToPlane: function ( plane ) {
-
-		var denominator = plane.normal.dot( this.direction );
-
-		if ( denominator === 0 ) {
-
-			// line is coplanar, return origin
-			if ( plane.distanceToPoint( this.origin ) === 0 ) {
-
-				return 0;
-
-			}
-
-			// Null is preferable to undefined since undefined means.... it is undefined
-
-			return null;
-
-		}
-
-		var t = - ( this.origin.dot( plane.normal ) + plane.constant ) / denominator;
-
-		// Return if the ray never intersects the plane
-
-		return t >= 0 ? t :  null;
-
-	},
-
-	intersectPlane: function ( plane, optionalTarget ) {
-
-		var t = this.distanceToPlane( plane );
-
-		if ( t === null ) {
-
-			return null;
-
-		}
-
-		return this.at( t, optionalTarget );
-
-	},
-
-
-
-	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 ) {
-
-			return true;
-
-		}
-
-		// ray origin is behind the plane (and is pointing behind it)
-
-		return false;
-
-	},
-
-	intersectBox: function ( box, optionalTarget ) {
-
-		var tmin, tmax, tymin, tymax, tzmin, tzmax;
-
-		var invdirx = 1 / this.direction.x,
-			invdiry = 1 / this.direction.y,
-			invdirz = 1 / this.direction.z;
-
-		var origin = this.origin;
-
-		if ( invdirx >= 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 < tmax || tmax !== tmax ) tmax = tymax;
-
-		if ( invdirz >= 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 < tmax || tmax !== tmax ) tmax = tzmax;
-
-		//return point closest to the ray (positive side)
-
-		if ( tmax < 0 ) return null;
-
-		return this.at( tmin >= 0 ? tmin : tmax, optionalTarget );
-
-	},
-
-	intersectsBox: ( function () {
-
-		var v = new THREE.Vector3();
-
-		return function ( box ) {
-
-			return this.intersectBox( box, v ) !== null;
-
-		};
-
-	} )(),
-
-	intersectTriangle: function () {
-
-		// Compute the offset origin, edges, and normal.
-		var diff = new THREE.Vector3();
-		var edge1 = new THREE.Vector3();
-		var edge2 = new THREE.Vector3();
-		var normal = new THREE.Vector3();
-
-		return function ( a, b, c, backfaceCulling, optionalTarget ) {
-
-			// from http://www.geometrictools.com/LibMathematics/Intersection/Wm5IntrRay3Triangle3.cpp
-
-			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 < 0 ) {
-
-				sign = - 1;
-				DdN = - DdN;
-
-			} else {
-
-				return null;
-
-			}
-
-			diff.subVectors( this.origin, a );
-			var DdQxE2 = sign * this.direction.dot( edge2.crossVectors( diff, edge2 ) );
-
-			// b1 < 0, no intersection
-			if ( DdQxE2 < 0 ) {
-
-				return null;
-
-			}
-
-			var DdE1xQ = sign * this.direction.dot( edge1.cross( diff ) );
-
-			// b2 < 0, no intersection
-			if ( DdE1xQ < 0 ) {
-
-				return null;
-
-			}
-
-			// b1+b2 > 1, no intersection
-			if ( DdQxE2 + DdE1xQ > DdN ) {
-
-				return null;
-
-			}
-
-			// Line intersects triangle, check if ray does.
-			var QdN = - sign * diff.dot( normal );
-
-			// t < 0, no intersection
-			if ( QdN < 0 ) {
-
-				return null;
-
-			}
-
-			// Ray intersects triangle.
-			return this.at( QdN / DdN, optionalTarget );
-
-		};
-
-	}(),
-
-	applyMatrix4: function ( matrix4 ) {
-
-		this.direction.add( this.origin ).applyMatrix4( matrix4 );
-		this.origin.applyMatrix4( matrix4 );
-		this.direction.sub( this.origin );
-		this.direction.normalize();
-
-		return this;
-
-	},
-
-	equals: function ( ray ) {
-
-		return ray.origin.equals( this.origin ) && ray.direction.equals( this.direction );
-
-	}
-
-};
-
-// File:src/math/Sphere.js
-
-/**
- * @author bhouston / http://clara.io
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.Sphere = function ( center, radius ) {
-
-	this.center = ( center !== undefined ) ? center : new THREE.Vector3();
-	this.radius = ( radius !== undefined ) ? radius : 0;
-
-};
-
-THREE.Sphere.prototype = {
-
-	constructor: THREE.Sphere,
-
-	set: function ( center, radius ) {
-
-		this.center.copy( center );
-		this.radius = radius;
-
-		return this;
-
-	},
-
-	setFromPoints: function () {
-
-		var box = new THREE.Box3();
-
-		return function ( points, optionalCenter ) {
-
-			var center = this.center;
-
-			if ( optionalCenter !== undefined ) {
-
-				center.copy( optionalCenter );
-
-			} else {
-
-				box.setFromPoints( points ).center( center );
-
-			}
-
-			var maxRadiusSq = 0;
-
-			for ( var i = 0, il = points.length; i < il; i ++ ) {
-
-				maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( points[ i ] ) );
-
-			}
-
-			this.radius = Math.sqrt( maxRadiusSq );
-
-			return this;
-
-		};
-
-	}(),
-
-	clone: function () {
-
-		return new this.constructor().copy( this );
-
-	},
-
-	copy: function ( sphere ) {
-
-		this.center.copy( sphere.center );
-		this.radius = sphere.radius;
-
-		return this;
-
-	},
-
-	empty: function () {
-
-		return ( this.radius <= 0 );
-
-	},
-
-	containsPoint: function ( point ) {
-
-		return ( point.distanceToSquared( this.center ) <= ( this.radius * this.radius ) );
-
-	},
-
-	distanceToPoint: function ( point ) {
-
-		return ( point.distanceTo( this.center ) - this.radius );
-
-	},
-
-	intersectsSphere: function ( sphere ) {
-
-		var radiusSum = this.radius + sphere.radius;
-
-		return sphere.center.distanceToSquared( this.center ) <= ( radiusSum * radiusSum );
-
-	},
-
-	intersectsBox: function ( box ) {
-
-		return box.intersectsSphere( this );
-
-	},
-
-	intersectsPlane: function ( plane ) {
-
-		// We use the following equation to compute the signed distance from
-		// the center of the sphere to the plane.
-		//
-		// distance = q * n - d
-		//
-		// If this distance is greater than the radius of the sphere,
-		// then there is no intersection.
-
-		return Math.abs( this.center.dot( plane.normal ) - plane.constant ) <= this.radius;
-
-	},
-
-	clampPoint: function ( point, optionalTarget ) {
-
-		var deltaLengthSq = this.center.distanceToSquared( point );
-
-		var result = optionalTarget || new THREE.Vector3();
-
-		result.copy( point );
-
-		if ( deltaLengthSq > ( this.radius * this.radius ) ) {
-
-			result.sub( this.center ).normalize();
-			result.multiplyScalar( this.radius ).add( this.center );
-
-		}
-
-		return result;
-
-	},
-
-	getBoundingBox: function ( optionalTarget ) {
-
-		var box = optionalTarget || new THREE.Box3();
-
-		box.set( this.center, this.center );
-		box.expandByScalar( this.radius );
-
-		return box;
-
-	},
-
-	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 );
-
-	}
-
-};
-
-// File:src/math/Frustum.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- * @author bhouston / http://clara.io
- */
-
-THREE.Frustum = function ( p0, p1, p2, p3, p4, p5 ) {
-
-	this.planes = [
-
-		( p0 !== undefined ) ? p0 : new THREE.Plane(),
-		( p1 !== undefined ) ? p1 : new THREE.Plane(),
-		( p2 !== undefined ) ? p2 : new THREE.Plane(),
-		( p3 !== undefined ) ? p3 : new THREE.Plane(),
-		( p4 !== undefined ) ? p4 : new THREE.Plane(),
-		( p5 !== undefined ) ? p5 : new THREE.Plane()
-
-	];
-
-};
-
-THREE.Frustum.prototype = {
-
-	constructor: THREE.Frustum,
-
-	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 < 6; i ++ ) {
-
-			planes[ i ].copy( frustum.planes[ i ] );
-
-		}
-
-		return this;
-
-	},
-
-	setFromMatrix: function ( m ) {
-
-		var planes = this.planes;
-		var me = m.elements;
-		var me0 = me[ 0 ], me1 = me[ 1 ], me2 = me[ 2 ], me3 = me[ 3 ];
-		var me4 = me[ 4 ], me5 = me[ 5 ], me6 = me[ 6 ], me7 = me[ 7 ];
-		var me8 = me[ 8 ], me9 = me[ 9 ], me10 = me[ 10 ], me11 = me[ 11 ];
-		var me12 = me[ 12 ], me13 = me[ 13 ], me14 = me[ 14 ], me15 = me[ 15 ];
-
-		planes[ 0 ].setComponents( me3 - me0, me7 - me4, me11 - me8, me15 - me12 ).normalize();
-		planes[ 1 ].setComponents( me3 + me0, me7 + me4, me11 + me8, me15 + me12 ).normalize();
-		planes[ 2 ].setComponents( me3 + me1, me7 + me5, me11 + me9, me15 + me13 ).normalize();
-		planes[ 3 ].setComponents( me3 - me1, me7 - me5, me11 - me9, me15 - me13 ).normalize();
-		planes[ 4 ].setComponents( me3 - me2, me7 - me6, me11 - me10, me15 - me14 ).normalize();
-		planes[ 5 ].setComponents( me3 + me2, me7 + me6, me11 + me10, me15 + me14 ).normalize();
-
-		return this;
-
-	},
-
-	intersectsObject: function () {
-
-		var sphere = new THREE.Sphere();
-
-		return function ( object ) {
-
-			var geometry = object.geometry;
-
-			if ( geometry.boundingSphere === null ) geometry.computeBoundingSphere();
-
-			sphere.copy( geometry.boundingSphere );
-			sphere.applyMatrix4( object.matrixWorld );
-
-			return this.intersectsSphere( sphere );
-
-		};
-
-	}(),
-
-	intersectsSphere: function ( sphere ) {
-
-		var planes = this.planes;
-		var center = sphere.center;
-		var negRadius = - sphere.radius;
-
-		for ( var i = 0; i < 6; i ++ ) {
-
-			var distance = planes[ i ].distanceToPoint( center );
-
-			if ( distance < negRadius ) {
-
-				return false;
-
-			}
-
-		}
-
-		return true;
-
-	},
-
-	intersectsBox: function () {
-
-		var p1 = new THREE.Vector3(),
-			p2 = new THREE.Vector3();
-
-		return function ( box ) {
-
-			var planes = this.planes;
-
-			for ( var i = 0; i < 6 ; i ++ ) {
-
-				var plane = planes[ i ];
-
-				p1.x = plane.normal.x > 0 ? box.min.x : box.max.x;
-				p2.x = plane.normal.x > 0 ? box.max.x : box.min.x;
-				p1.y = plane.normal.y > 0 ? box.min.y : box.max.y;
-				p2.y = plane.normal.y > 0 ? box.max.y : box.min.y;
-				p1.z = plane.normal.z > 0 ? box.min.z : box.max.z;
-				p2.z = plane.normal.z > 0 ? box.max.z : box.min.z;
-
-				var d1 = plane.distanceToPoint( p1 );
-				var d2 = plane.distanceToPoint( p2 );
-
-				// if both outside plane, no intersection
-
-				if ( d1 < 0 && d2 < 0 ) {
-
-					return false;
-
-				}
-
-			}
-
-			return true;
-
-		};
-
-	}(),
-
-
-	containsPoint: function ( point ) {
-
-		var planes = this.planes;
-
-		for ( var i = 0; i < 6; i ++ ) {
-
-			if ( planes[ i ].distanceToPoint( point ) < 0 ) {
-
-				return false;
-
-			}
-
-		}
-
-		return true;
-
-	}
-
-};
-
-// File:src/math/Plane.js
-
-/**
- * @author bhouston / http://clara.io
- */
-
-THREE.Plane = function ( normal, constant ) {
-
-	this.normal = ( normal !== undefined ) ? normal : new THREE.Vector3( 1, 0, 0 );
-	this.constant = ( constant !== undefined ) ? constant : 0;
-
-};
-
-THREE.Plane.prototype = {
-
-	constructor: THREE.Plane,
-
-	set: function ( normal, constant ) {
-
-		this.normal.copy( normal );
-		this.constant = constant;
-
-		return this;
-
-	},
-
-	setComponents: function ( x, y, z, w ) {
-
-		this.normal.set( x, y, z );
-		this.constant = w;
-
-		return this;
-
-	},
-
-	setFromNormalAndCoplanarPoint: function ( normal, point ) {
-
-		this.normal.copy( normal );
-		this.constant = - point.dot( this.normal );	// must be this.normal, not normal, as this.normal is normalized
-
-		return this;
-
-	},
-
-	setFromCoplanarPoints: function () {
-
-		var v1 = new THREE.Vector3();
-		var v2 = new THREE.Vector3();
-
-		return function ( a, b, c ) {
-
-			var normal = v1.subVectors( c, b ).cross( v2.subVectors( a, b ) ).normalize();
-
-			// Q: should an error be thrown if normal is zero (e.g. degenerate plane)?
-
-			this.setFromNormalAndCoplanarPoint( normal, a );
-
-			return this;
-
-		};
-
-	}(),
-
-	clone: function () {
-
-		return new this.constructor().copy( this );
-
-	},
-
-	copy: function ( plane ) {
-
-		this.normal.copy( plane.normal );
-		this.constant = plane.constant;
-
-		return this;
-
-	},
-
-	normalize: function () {
-
-		// Note: will lead to a divide by zero if the plane is invalid.
-
-		var inverseNormalLength = 1.0 / this.normal.length();
-		this.normal.multiplyScalar( inverseNormalLength );
-		this.constant *= inverseNormalLength;
-
-		return this;
-
-	},
-
-	negate: function () {
-
-		this.constant *= - 1;
-		this.normal.negate();
-
-		return this;
-
-	},
-
-	distanceToPoint: function ( point ) {
-
-		return this.normal.dot( point ) + this.constant;
-
-	},
-
-	distanceToSphere: function ( sphere ) {
-
-		return this.distanceToPoint( sphere.center ) - sphere.radius;
-
-	},
-
-	projectPoint: function ( point, optionalTarget ) {
-
-		return this.orthoPoint( point, optionalTarget ).sub( point ).negate();
-
-	},
-
-	orthoPoint: function ( point, optionalTarget ) {
-
-		var perpendicularMagnitude = this.distanceToPoint( point );
-
-		var result = optionalTarget || new THREE.Vector3();
-		return result.copy( this.normal ).multiplyScalar( perpendicularMagnitude );
-
-	},
-
-	intersectLine: function () {
-
-		var v1 = new THREE.Vector3();
-
-		return function ( line, optionalTarget ) {
-
-			var result = optionalTarget || new THREE.Vector3();
-
-			var direction = line.delta( v1 );
-
-			var denominator = this.normal.dot( direction );
-
-			if ( denominator === 0 ) {
-
-				// line is coplanar, return origin
-				if ( this.distanceToPoint( line.start ) === 0 ) {
-
-					return result.copy( line.start );
-
-				}
-
-				// Unsure if this is the correct method to handle this case.
-				return undefined;
-
-			}
-
-			var t = - ( line.start.dot( this.normal ) + this.constant ) / denominator;
-
-			if ( t < 0 || t > 1 ) {
-
-				return undefined;
-
-			}
-
-			return result.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 ) || ( endSign < 0 && startSign > 0 );
-
-	},
-
-	intersectsBox: function ( box ) {
-
-		return box.intersectsPlane( this );
-
-	},
-
-	intersectsSphere: function ( sphere ) {
-
-		return sphere.intersectsPlane( this );
-
-	},
-
-	coplanarPoint: function ( optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector3();
-		return result.copy( this.normal ).multiplyScalar( - this.constant );
-
-	},
-
-	applyMatrix4: function () {
-
-		var v1 = new THREE.Vector3();
-		var m1 = new THREE.Matrix3();
-
-		return function ( matrix, optionalNormalMatrix ) {
-
-			var referencePoint = this.coplanarPoint( v1 ).applyMatrix4( matrix );
-
-			// transform normal based on theory here:
-			// http://www.songho.ca/opengl/gl_normaltransform.html
-			var normalMatrix = optionalNormalMatrix || m1.getNormalMatrix( matrix );
-			var normal = this.normal.applyMatrix3( normalMatrix ).normalize();
-
-			// recalculate constant (like in setFromNormalAndCoplanarPoint)
-			this.constant = - referencePoint.dot( normal );
-
-			return this;
-
-		};
-
-	}(),
-
-	translate: function ( offset ) {
-
-		this.constant = this.constant - offset.dot( this.normal );
-
-		return this;
-
-	},
-
-	equals: function ( plane ) {
-
-		return plane.normal.equals( this.normal ) && ( plane.constant === this.constant );
-
-	}
-
-};
-
-// File:src/math/Spherical.js
-
-/**
- * @author bhouston / http://clara.io
- * @author WestLangley / http://github.com/WestLangley
- *
- * Ref: https://en.wikipedia.org/wiki/Spherical_coordinate_system
- *
- * The poles (phi) are at the positive and negative y axis.
- * The equator starts at positive z.
- */
-
-THREE.Spherical = function ( radius, phi, theta ) {
-
-	this.radius = ( radius !== undefined ) ? radius : 1.0;
-	this.phi = ( phi !== undefined ) ? phi : 0; // up / down towards top and bottom pole
-	this.theta = ( theta !== undefined ) ? theta : 0; // around the equator of the sphere
-
-	return this;
-
-};
-
-THREE.Spherical.prototype = {
-
-	constructor: THREE.Spherical,
-
-	set: function ( radius, phi, theta ) {
-
-		this.radius = radius;
-		this.phi = phi;
-		this.theta = theta;
-
-	},
-
-	clone: function () {
-
-		return new this.constructor().copy( this );
-
-	},
-
-	copy: function ( other ) {
-
-		this.radius.copy( other.radius );
-		this.phi.copy( other.phi );
-		this.theta.copy( other.theta );
-
-		return this;
-
-	},
-
-	// restrict phi to be betwee EPS and PI-EPS
-	makeSafe: function() {
-
-		var EPS = 0.000001;
-		this.phi = Math.max( EPS, Math.min( Math.PI - EPS, this.phi ) );
-
-	},
-
-	setFromVector3: function( vec3 ) {
-
-		this.radius = vec3.length();
-
-		if ( this.radius === 0 ) {
-
-			this.theta = 0;
-			this.phi = 0;
-
-		} else {
-
-			this.theta = Math.atan2( vec3.x, vec3.z ); // equator angle around y-up axis
-			this.phi = Math.acos( THREE.Math.clamp( vec3.y / this.radius, - 1, 1 ) ); // polar angle
-
-		}
-
-		return this;
-
-	},
-
-};
-
-// File:src/math/Math.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.Math = {
-
-	DEG2RAD: Math.PI / 180,
-	RAD2DEG: 180 / Math.PI,
-
-	generateUUID: function () {
-
-		// http://www.broofa.com/Tools/Math.uuid.htm
-
-		var chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split( '' );
-		var uuid = new Array( 36 );
-		var rnd = 0, r;
-
-		return function () {
-
-			for ( var i = 0; i < 36; i ++ ) {
-
-				if ( i === 8 || i === 13 || i === 18 || i === 23 ) {
-
-					uuid[ i ] = '-';
-
-				} else if ( i === 14 ) {
-
-					uuid[ i ] = '4';
-
-				} else {
-
-					if ( rnd <= 0x02 ) rnd = 0x2000000 + ( Math.random() * 0x1000000 ) | 0;
-					r = rnd & 0xf;
-					rnd = rnd >> 4;
-					uuid[ i ] = chars[ ( i === 19 ) ? ( r & 0x3 ) | 0x8 : r ];
-
-				}
-
-			}
-
-			return uuid.join( '' );
-
-		};
-
-	}(),
-
-	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 <a1, a2> to range <b1, b2>
-
-	mapLinear: function ( x, a1, a2, b1, b2 ) {
-
-		return b1 + ( x - a1 ) * ( b2 - b1 ) / ( a2 - a1 );
-
-	},
-
-	// http://en.wikipedia.org/wiki/Smoothstep
-
-	smoothstep: function ( x, min, max ) {
-
-		if ( x <= min ) return 0;
-		if ( x >= max ) return 1;
-
-		x = ( x - min ) / ( max - min );
-
-		return x * x * ( 3 - 2 * x );
-
-	},
-
-	smootherstep: function ( x, min, max ) {
-
-		if ( x <= min ) return 0;
-		if ( x >= max ) return 1;
-
-		x = ( x - min ) / ( max - min );
-
-		return x * x * x * ( x * ( x * 6 - 15 ) + 10 );
-
-	},
-
-	random16: function () {
-
-		console.warn( 'THREE.Math.random16() has been deprecated. Use Math.random() instead.' );
-		return Math.random();
-
-	},
-
-	// Random integer from <low, high> interval
-
-	randInt: function ( low, high ) {
-
-		return low + Math.floor( Math.random() * ( high - low + 1 ) );
-
-	},
-
-	// Random float from <low, high> interval
-
-	randFloat: function ( low, high ) {
-
-		return low + Math.random() * ( high - low );
-
-	},
-
-	// Random float from <-range/2, range/2> interval
-
-	randFloatSpread: function ( range ) {
-
-		return range * ( 0.5 - Math.random() );
-
-	},
-
-	degToRad: function ( degrees ) {
-
-		return degrees * THREE.Math.DEG2RAD;
-
-	},
-
-	radToDeg: function ( radians ) {
-
-		return radians * THREE.Math.RAD2DEG;
-
-	},
-
-	isPowerOfTwo: function ( value ) {
-
-		return ( value & ( value - 1 ) ) === 0 && value !== 0;
-
-	},
-
-	nearestPowerOfTwo: function ( value ) {
-
-		return Math.pow( 2, Math.round( Math.log( value ) / Math.LN2 ) );
-
-	},
-
-	nextPowerOfTwo: function ( value ) {
-
-		value --;
-		value |= value >> 1;
-		value |= value >> 2;
-		value |= value >> 4;
-		value |= value >> 8;
-		value |= value >> 16;
-		value ++;
-
-		return value;
-
-	}
-
-};
-
-// File:src/math/Spline.js
-
-/**
- * Spline from Tween.js, slightly optimized (and trashed)
- * http://sole.github.com/tween.js/examples/05_spline.html
- *
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.Spline = function ( points ) {
-
-	this.points = points;
-
-	var c = [], v3 = { x: 0, y: 0, z: 0 },
-	point, intPoint, weight, w2, w3,
-	pa, pb, pc, pd;
-
-	this.initFromArray = function ( a ) {
-
-		this.points = [];
-
-		for ( var i = 0; i < a.length; i ++ ) {
-
-			this.points[ i ] = { x: a[ i ][ 0 ], y: a[ i ][ 1 ], z: a[ i ][ 2 ] };
-
-		}
-
-	};
-
-	this.getPoint = function ( k ) {
-
-		point = ( this.points.length - 1 ) * k;
-		intPoint = Math.floor( point );
-		weight = point - intPoint;
-
-		c[ 0 ] = intPoint === 0 ? intPoint : intPoint - 1;
-		c[ 1 ] = intPoint;
-		c[ 2 ] = intPoint  > this.points.length - 2 ? this.points.length - 1 : intPoint + 1;
-		c[ 3 ] = intPoint  > this.points.length - 3 ? this.points.length - 1 : intPoint + 2;
-
-		pa = this.points[ c[ 0 ] ];
-		pb = this.points[ c[ 1 ] ];
-		pc = this.points[ c[ 2 ] ];
-		pd = this.points[ c[ 3 ] ];
-
-		w2 = weight * weight;
-		w3 = weight * w2;
-
-		v3.x = interpolate( pa.x, pb.x, pc.x, pd.x, weight, w2, w3 );
-		v3.y = interpolate( pa.y, pb.y, pc.y, pd.y, weight, w2, w3 );
-		v3.z = interpolate( pa.z, pb.z, pc.z, pd.z, weight, w2, w3 );
-
-		return v3;
-
-	};
-
-	this.getControlPointsArray = function () {
-
-		var i, p, l = this.points.length,
-			coords = [];
-
-		for ( i = 0; i < l; i ++ ) {
-
-			p = this.points[ i ];
-			coords[ i ] = [ p.x, p.y, p.z ];
-
-		}
-
-		return coords;
-
-	};
-
-	// approximate length by summing linear segments
-
-	this.getLength = function ( nSubDivisions ) {
-
-		var i, index, nSamples, position,
-			point = 0, intPoint = 0, oldIntPoint = 0,
-			oldPosition = new THREE.Vector3(),
-			tmpVec = new THREE.Vector3(),
-			chunkLengths = [],
-			totalLength = 0;
-
-		// first point has 0 length
-
-		chunkLengths[ 0 ] = 0;
-
-		if ( ! nSubDivisions ) nSubDivisions = 100;
-
-		nSamples = this.points.length * nSubDivisions;
-
-		oldPosition.copy( this.points[ 0 ] );
-
-		for ( i = 1; i < nSamples; i ++ ) {
-
-			index = i / nSamples;
-
-			position = this.getPoint( index );
-			tmpVec.copy( position );
-
-			totalLength += tmpVec.distanceTo( oldPosition );
-
-			oldPosition.copy( position );
-
-			point = ( this.points.length - 1 ) * index;
-			intPoint = Math.floor( point );
-
-			if ( intPoint !== oldIntPoint ) {
-
-				chunkLengths[ intPoint ] = totalLength;
-				oldIntPoint = intPoint;
-
-			}
-
-		}
-
-		// last point ends with total length
-
-		chunkLengths[ chunkLengths.length ] = totalLength;
-
-		return { chunks: chunkLengths, total: totalLength };
-
-	};
-
-	this.reparametrizeByArcLength = function ( samplingCoef ) {
-
-		var i, j,
-			index, indexCurrent, indexNext,
-			realDistance,
-			sampling, position,
-			newpoints = [],
-			tmpVec = new THREE.Vector3(),
-			sl = this.getLength();
-
-		newpoints.push( tmpVec.copy( this.points[ 0 ] ).clone() );
-
-		for ( i = 1; i < this.points.length; i ++ ) {
-
-			//tmpVec.copy( this.points[ i - 1 ] );
-			//linearDistance = tmpVec.distanceTo( this.points[ i ] );
-
-			realDistance = sl.chunks[ i ] - sl.chunks[ i - 1 ];
-
-			sampling = Math.ceil( samplingCoef * realDistance / sl.total );
-
-			indexCurrent = ( i - 1 ) / ( this.points.length - 1 );
-			indexNext = i / ( this.points.length - 1 );
-
-			for ( j = 1; j < sampling - 1; j ++ ) {
-
-				index = indexCurrent + j * ( 1 / sampling ) * ( indexNext - indexCurrent );
-
-				position = this.getPoint( index );
-				newpoints.push( tmpVec.copy( position ).clone() );
-
-			}
-
-			newpoints.push( tmpVec.copy( this.points[ i ] ).clone() );
-
-		}
-
-		this.points = newpoints;
-
-	};
-
-	// Catmull-Rom
-
-	function interpolate( p0, p1, p2, p3, t, t2, t3 ) {
-
-		var v0 = ( p2 - p0 ) * 0.5,
-			v1 = ( p3 - p1 ) * 0.5;
-
-		return ( 2 * ( p1 - p2 ) + v0 + v1 ) * t3 + ( - 3 * ( p1 - p2 ) - 2 * v0 - v1 ) * t2 + v0 * t + p1;
-
-	}
-
-};
-
-// File:src/math/Triangle.js
-
-/**
- * @author bhouston / http://clara.io
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.Triangle = function ( a, b, c ) {
-
-	this.a = ( a !== undefined ) ? a : new THREE.Vector3();
-	this.b = ( b !== undefined ) ? b : new THREE.Vector3();
-	this.c = ( c !== undefined ) ? c : new THREE.Vector3();
-
-};
-
-THREE.Triangle.normal = function () {
-
-	var v0 = new THREE.Vector3();
-
-	return function ( a, b, c, optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector3();
-
-		result.subVectors( c, b );
-		v0.subVectors( a, b );
-		result.cross( v0 );
-
-		var resultLengthSq = result.lengthSq();
-		if ( resultLengthSq > 0 ) {
-
-			return result.multiplyScalar( 1 / Math.sqrt( resultLengthSq ) );
-
-		}
-
-		return result.set( 0, 0, 0 );
-
-	};
-
-}();
-
-// static/instance method to calculate barycentric coordinates
-// based on: http://www.blackpawn.com/texts/pointinpoly/default.html
-THREE.Triangle.barycoordFromPoint = function () {
-
-	var v0 = new THREE.Vector3();
-	var v1 = new THREE.Vector3();
-	var v2 = new THREE.Vector3();
-
-	return function ( point, a, b, c, optionalTarget ) {
-
-		v0.subVectors( c, a );
-		v1.subVectors( b, a );
-		v2.subVectors( point, a );
-
-		var dot00 = v0.dot( v0 );
-		var dot01 = v0.dot( v1 );
-		var dot02 = v0.dot( v2 );
-		var dot11 = v1.dot( v1 );
-		var dot12 = v1.dot( v2 );
-
-		var denom = ( dot00 * dot11 - dot01 * dot01 );
-
-		var result = optionalTarget || new THREE.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 result.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 result.set( 1 - u - v, v, u );
-
-	};
-
-}();
-
-THREE.Triangle.containsPoint = function () {
-
-	var v1 = new THREE.Vector3();
-
-	return function ( point, a, b, c ) {
-
-		var result = THREE.Triangle.barycoordFromPoint( point, a, b, c, v1 );
-
-		return ( result.x >= 0 ) && ( result.y >= 0 ) && ( ( result.x + result.y ) <= 1 );
-
-	};
-
-}();
-
-THREE.Triangle.prototype = {
-
-	constructor: THREE.Triangle,
-
-	set: function ( a, b, c ) {
-
-		this.a.copy( a );
-		this.b.copy( b );
-		this.c.copy( c );
-
-		return this;
-
-	},
-
-	setFromPointsAndIndices: function ( points, i0, i1, i2 ) {
-
-		this.a.copy( points[ i0 ] );
-		this.b.copy( points[ i1 ] );
-		this.c.copy( points[ i2 ] );
-
-		return this;
-
-	},
-
-	clone: function () {
-
-		return new this.constructor().copy( this );
-
-	},
-
-	copy: function ( triangle ) {
-
-		this.a.copy( triangle.a );
-		this.b.copy( triangle.b );
-		this.c.copy( triangle.c );
-
-		return this;
-
-	},
-
-	area: function () {
-
-		var v0 = new THREE.Vector3();
-		var v1 = new THREE.Vector3();
-
-		return function () {
-
-			v0.subVectors( this.c, this.b );
-			v1.subVectors( this.a, this.b );
-
-			return v0.cross( v1 ).length() * 0.5;
-
-		};
-
-	}(),
-
-	midpoint: function ( optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector3();
-		return result.addVectors( this.a, this.b ).add( this.c ).multiplyScalar( 1 / 3 );
-
-	},
-
-	normal: function ( optionalTarget ) {
-
-		return THREE.Triangle.normal( this.a, this.b, this.c, optionalTarget );
-
-	},
-
-	plane: function ( optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Plane();
-
-		return result.setFromCoplanarPoints( this.a, this.b, this.c );
-
-	},
-
-	barycoordFromPoint: function ( point, optionalTarget ) {
-
-		return THREE.Triangle.barycoordFromPoint( point, this.a, this.b, this.c, optionalTarget );
-
-	},
-
-	containsPoint: function ( point ) {
-
-		return THREE.Triangle.containsPoint( point, this.a, this.b, this.c );
-
-	},
-
-	closestPointToPoint: function () {
-
-		var plane, edgeList, projectedPoint, closestPoint;
-
-		return function closestPointToPoint( point, optionalTarget ) {
-
-			if ( plane === undefined ) {
-
-				plane = new THREE.Plane();
-				edgeList = [ new THREE.Line3(), new THREE.Line3(), new THREE.Line3() ];
-				projectedPoint = new THREE.Vector3();
-				closestPoint = new THREE.Vector3();
-
-			}
-
-			var result = optionalTarget || new THREE.Vector3();
-			var minDistance = Infinity;
-
-			// project the point onto the plane of the triangle
-
-			plane.setFromCoplanarPoints( this.a, this.b, this.c );
-			plane.projectPoint( point, projectedPoint );
-
-			// check if the projection lies within the triangle
-
-			if( this.containsPoint( projectedPoint ) === true ) {
-
-				// if so, this is the closest point
-
-				result.copy( projectedPoint );
-
-			} else {
-
-				// if not, the point falls outside the triangle. the result is the closest point to the triangle's edges or vertices
-
-				edgeList[ 0 ].set( this.a, this.b );
-				edgeList[ 1 ].set( this.b, this.c );
-				edgeList[ 2 ].set( this.c, this.a );
-
-				for( var i = 0; i < edgeList.length; i ++ ) {
-
-					edgeList[ i ].closestPointToPoint( projectedPoint, true, closestPoint );
-
-					var distance = projectedPoint.distanceToSquared( closestPoint );
-
-					if( distance < minDistance ) {
-
-						minDistance = distance;
-
-						result.copy( closestPoint );
-
-					}
-
-				}
-
-			}
-
-			return result;
-
-		};
-
-	}(),
-
-	equals: function ( triangle ) {
-
-		return triangle.a.equals( this.a ) && triangle.b.equals( this.b ) && triangle.c.equals( this.c );
-
-	}
-
-};
-
-// File:src/math/Interpolant.js
-
-/**
- * Abstract base class of interpolants over parametric samples.
- *
- * The parameter domain is one dimensional, typically the time or a path
- * along a curve defined by the data.
- *
- * The sample values can have any dimensionality and derived classes may
- * apply special interpretations to the data.
- *
- * This class provides the interval seek in a Template Method, deferring
- * the actual interpolation to derived classes.
- *
- * Time complexity is O(1) for linear access crossing at most two points
- * and O(log N) for random access, where N is the number of positions.
- *
- * References:
- *
- * 		http://www.oodesign.com/template-method-pattern.html
- *
- * @author tschw
- */
-
-THREE.Interpolant = function(
-		parameterPositions, sampleValues, sampleSize, resultBuffer ) {
-
-	this.parameterPositions = parameterPositions;
-	this._cachedIndex = 0;
-
-	this.resultBuffer = resultBuffer !== undefined ?
-			resultBuffer : new sampleValues.constructor( sampleSize );
-	this.sampleValues = sampleValues;
-	this.valueSize = sampleSize;
-
-};
-
-THREE.Interpolant.prototype = {
-
-	constructor: THREE.Interpolant,
-
-	evaluate: function( t ) {
-
-		var pp = this.parameterPositions,
-			i1 = this._cachedIndex,
-
-			t1 = pp[   i1   ],
-			t0 = pp[ i1 - 1 ];
-
-		validate_interval: {
-
-			seek: {
-
-				var right;
-
-				linear_scan: {
-//- See http://jsperf.com/comparison-to-undefined/3
-//- slower code:
-//-
-//- 				if ( t >= t1 || t1 === undefined ) {
-					forward_scan: if ( ! ( t < t1 ) ) {
-
-						for ( var giveUpAt = i1 + 2; ;) {
-
-							if ( t1 === undefined ) {
-
-								if ( t < t0 ) break forward_scan;
-
-								// after end
-
-								i1 = pp.length;
-								this._cachedIndex = i1;
-								return this.afterEnd_( i1 - 1, t, t0 );
-
-							}
-
-							if ( i1 === giveUpAt ) break; // this loop
-
-							t0 = t1;
-							t1 = pp[ ++ i1 ];
-
-							if ( t < t1 ) {
-
-								// we have arrived at the sought interval
-								break seek;
-
-							}
-
-						}
-
-						// prepare binary search on the right side of the index
-						right = pp.length;
-						break linear_scan;
-
-					}
-
-//- slower code:
-//-					if ( t < t0 || t0 === undefined ) {
-					if ( ! ( t >= t0 ) ) {
-
-						// looping?
-
-						var t1global = pp[ 1 ];
-
-						if ( t < t1global ) {
-
-							i1 = 2; // + 1, using the scan for the details
-							t0 = t1global;
-
-						}
-
-						// linear reverse scan
-
-						for ( var giveUpAt = i1 - 2; ;) {
-
-							if ( t0 === undefined ) {
-
-								// before start
-
-								this._cachedIndex = 0;
-								return this.beforeStart_( 0, t, t1 );
-
-							}
-
-							if ( i1 === giveUpAt ) break; // this loop
-
-							t1 = t0;
-							t0 = pp[ -- i1 - 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 < right ) {
-
-					var mid = ( i1 + right ) >>> 1;
-
-					if ( t < pp[ mid ] ) {
-
-						right = mid;
-
-					} else {
-
-						i1 = mid + 1;
-
-					}
-
-				}
-
-				t1 = pp[   i1   ];
-				t0 = pp[ i1 - 1 ];
-
-				// check boundary cases, again
-
-				if ( t0 === undefined ) {
-
-					this._cachedIndex = 0;
-					return this.beforeStart_( 0, t, t1 );
-
-				}
-
-				if ( t1 === undefined ) {
-
-					i1 = pp.length;
-					this._cachedIndex = i1;
-					return this.afterEnd_( i1 - 1, t0, t );
-
-				}
-
-			} // seek
-
-			this._cachedIndex = i1;
-
-			this.intervalChanged_( i1, t0, t1 );
-
-		} // validate_interval
-
-		return this.interpolate_( i1, t0, t, t1 );
-
-	},
-
-	settings: null, // optional, subclass-specific settings structure
-	// Note: The indirection allows central control of many interpolants.
-
-	// --- Protected interface
-
-	DefaultSettings_: {},
-
-	getSettings_: function() {
-
-		return this.settings || this.DefaultSettings_;
-
-	},
-
-	copySampleValue_: function( index ) {
-
-		// copies a sample value to the result buffer
-
-		var result = this.resultBuffer,
-			values = this.sampleValues,
-			stride = this.valueSize,
-			offset = index * stride;
-
-		for ( var i = 0; i !== stride; ++ i ) {
-
-			result[ i ] = values[ offset + i ];
-
-		}
-
-		return result;
-
-	},
-
-	// Template methods for derived classes:
-
-	interpolate_: function( i1, t0, t, t1 ) {
-
-		throw new Error( "call to abstract method" );
-		// implementations shall return this.resultBuffer
-
-	},
-
-	intervalChanged_: function( i1, t0, t1 ) {
-
-		// empty
-
-	}
-
-};
-
-Object.assign( THREE.Interpolant.prototype, {
-
-	beforeStart_: //( 0, t, t0 ), returns this.resultBuffer
-		THREE.Interpolant.prototype.copySampleValue_,
-
-	afterEnd_: //( N-1, tN-1, t ), returns this.resultBuffer
-		THREE.Interpolant.prototype.copySampleValue_
-
-} );
-
-// File:src/math/interpolants/CubicInterpolant.js
-
-/**
- * Fast and simple cubic spline interpolant.
- *
- * It was derived from a Hermitian construction setting the first derivative
- * at each sample position to the linear slope between neighboring positions
- * over their parameter interval.
- *
- * @author tschw
- */
-
-THREE.CubicInterpolant = function(
-		parameterPositions, sampleValues, sampleSize, resultBuffer ) {
-
-	THREE.Interpolant.call(
-			this, parameterPositions, sampleValues, sampleSize, resultBuffer );
-
-	this._weightPrev = -0;
-	this._offsetPrev = -0;
-	this._weightNext = -0;
-	this._offsetNext = -0;
-
-};
-
-THREE.CubicInterpolant.prototype =
-		Object.assign( Object.create( THREE.Interpolant.prototype ), {
-
-	constructor: THREE.CubicInterpolant,
-
-	DefaultSettings_: {
-
-		endingStart: 	THREE.ZeroCurvatureEnding,
-		endingEnd:		THREE.ZeroCurvatureEnding
-
-	},
-
-	intervalChanged_: function( i1, t0, t1 ) {
-
-		var pp = this.parameterPositions,
-			iPrev = i1 - 2,
-			iNext = i1 + 1,
-
-			tPrev = pp[ iPrev ],
-			tNext = pp[ iNext ];
-
-		if ( tPrev === undefined ) {
-
-			switch ( this.getSettings_().endingStart ) {
-
-				case THREE.ZeroSlopeEnding:
-
-					// f'(t0) = 0
-					iPrev = i1;
-					tPrev = 2 * t0 - t1;
-
-					break;
-
-				case THREE.WrapAroundEnding:
-
-					// use the other end of the curve
-					iPrev = pp.length - 2;
-					tPrev = t0 + pp[ iPrev ] - pp[ iPrev + 1 ];
-
-					break;
-
-				default: // ZeroCurvatureEnding
-
-					// f''(t0) = 0 a.k.a. Natural Spline
-					iPrev = i1;
-					tPrev = t1;
-
-			}
-
-		}
-
-		if ( tNext === undefined ) {
-
-			switch ( this.getSettings_().endingEnd ) {
-
-				case THREE.ZeroSlopeEnding:
-
-					// f'(tN) = 0
-					iNext = i1;
-					tNext = 2 * t1 - t0;
-
-					break;
-
-				case THREE.WrapAroundEnding:
-
-					// use the other end of the curve
-					iNext = 1;
-					tNext = t1 + pp[ 1 ] - pp[ 0 ];
-
-					break;
-
-				default: // ZeroCurvatureEnding
-
-					// f''(tN) = 0, a.k.a. Natural Spline
-					iNext = i1 - 1;
-					tNext = t0;
-
-			}
-
-		}
-
-		var halfDt = ( t1 - t0 ) * 0.5,
-			stride = this.valueSize;
-
-		this._weightPrev = halfDt / ( t0 - tPrev );
-		this._weightNext = halfDt / ( tNext - t1 );
-		this._offsetPrev = iPrev * stride;
-		this._offsetNext = iNext * stride;
-
-	},
-
-	interpolate_: function( i1, t0, t, t1 ) {
-
-		var result = this.resultBuffer,
-			values = this.sampleValues,
-			stride = this.valueSize,
-
-			o1 = i1 * stride,		o0 = o1 - stride,
-			oP = this._offsetPrev, 	oN = this._offsetNext,
-			wP = this._weightPrev,	wN = this._weightNext,
-
-			p = ( t - t0 ) / ( t1 - t0 ),
-			pp = p * p,
-			ppp = pp * p;
-
-		// evaluate polynomials
-
-		var sP =     - wP   * ppp   +         2 * wP    * pp    -          wP   * p;
-		var s0 = ( 1 + wP ) * ppp   + (-1.5 - 2 * wP )  * pp    + ( -0.5 + wP ) * p     + 1;
-		var s1 = (-1 - wN ) * ppp   + ( 1.5 +   wN   )  * pp    +    0.5        * p;
-		var sN =       wN   * ppp   -           wN      * pp;
-
-		// combine data linearly
-
-		for ( var i = 0; i !== stride; ++ i ) {
-
-			result[ i ] =
-					sP * values[ oP + i ] +
-					s0 * values[ o0 + i ] +
-					s1 * values[ o1 + i ] +
-					sN * values[ oN + i ];
-
-		}
-
-		return result;
-
-	}
-
-} );
-
-// File:src/math/interpolants/DiscreteInterpolant.js
-
-/**
- *
- * Interpolant that evaluates to the sample value at the position preceeding
- * the parameter.
- *
- * @author tschw
- */
-
-THREE.DiscreteInterpolant = function(
-		parameterPositions, sampleValues, sampleSize, resultBuffer ) {
-
-	THREE.Interpolant.call(
-			this, parameterPositions, sampleValues, sampleSize, resultBuffer );
-
-};
-
-THREE.DiscreteInterpolant.prototype =
-		Object.assign( Object.create( THREE.Interpolant.prototype ), {
-
-	constructor: THREE.DiscreteInterpolant,
-
-	interpolate_: function( i1, t0, t, t1 ) {
-
-		return this.copySampleValue_( i1 - 1 );
-
-	}
-
-} );
-
-// File:src/math/interpolants/LinearInterpolant.js
-
-/**
- * @author tschw
- */
-
-THREE.LinearInterpolant = function(
-		parameterPositions, sampleValues, sampleSize, resultBuffer ) {
-
-	THREE.Interpolant.call(
-			this, parameterPositions, sampleValues, sampleSize, resultBuffer );
-
-};
-
-THREE.LinearInterpolant.prototype =
-		Object.assign( Object.create( THREE.Interpolant.prototype ), {
-
-	constructor: THREE.LinearInterpolant,
-
-	interpolate_: function( i1, t0, t, t1 ) {
-
-		var result = this.resultBuffer,
-			values = this.sampleValues,
-			stride = this.valueSize,
-
-			offset1 = i1 * stride,
-			offset0 = offset1 - stride,
-
-			weight1 = ( t - t0 ) / ( t1 - t0 ),
-			weight0 = 1 - weight1;
-
-		for ( var i = 0; i !== stride; ++ i ) {
-
-			result[ i ] =
-					values[ offset0 + i ] * weight0 +
-					values[ offset1 + i ] * weight1;
-
-		}
-
-		return result;
-
-	}
-
-} );
-
-// File:src/math/interpolants/QuaternionLinearInterpolant.js
-
-/**
- * Spherical linear unit quaternion interpolant.
- *
- * @author tschw
- */
-
-THREE.QuaternionLinearInterpolant = function(
-		parameterPositions, sampleValues, sampleSize, resultBuffer ) {
-
-	THREE.Interpolant.call(
-			this, parameterPositions, sampleValues, sampleSize, resultBuffer );
-
-};
-
-THREE.QuaternionLinearInterpolant.prototype =
-		Object.assign( Object.create( THREE.Interpolant.prototype ), {
-
-	constructor: THREE.QuaternionLinearInterpolant,
-
-	interpolate_: function( i1, t0, t, t1 ) {
-
-		var result = this.resultBuffer,
-			values = this.sampleValues,
-			stride = this.valueSize,
-
-			offset = i1 * stride,
-
-			alpha = ( t - t0 ) / ( t1 - t0 );
-
-		for ( var end = offset + stride; offset !== end; offset += 4 ) {
-
-			THREE.Quaternion.slerpFlat( result, 0,
-					values, offset - stride, values, offset, alpha );
-
-		}
-
-		return result;
-
-	}
-
-} );
-
-// File:src/core/Clock.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.Clock = function ( autoStart ) {
-
-	this.autoStart = ( autoStart !== undefined ) ? autoStart : true;
-
-	this.startTime = 0;
-	this.oldTime = 0;
-	this.elapsedTime = 0;
-
-	this.running = false;
-
-};
-
-THREE.Clock.prototype = {
-
-	constructor: THREE.Clock,
-
-	start: function () {
-
-		this.startTime = ( performance || Date ).now();
-
-		this.oldTime = this.startTime;
-		this.running = true;
-
-	},
-
-	stop: function () {
-
-		this.getElapsedTime();
-		this.running = false;
-
-	},
-
-	getElapsedTime: function () {
-
-		this.getDelta();
-		return this.elapsedTime;
-
-	},
-
-	getDelta: function () {
-
-		var diff = 0;
-
-		if ( this.autoStart && ! this.running ) {
-
-			this.start();
-
-		}
-
-		if ( this.running ) {
-
-			var newTime = ( performance || Date ).now();
-
-			diff = ( newTime - this.oldTime ) / 1000;
-			this.oldTime = newTime;
-
-			this.elapsedTime += diff;
-
-		}
-
-		return diff;
-
-	}
-
-};
-
-// File:src/core/EventDispatcher.js
-
-/**
- * https://github.com/mrdoob/eventdispatcher.js/
- */
-
-THREE.EventDispatcher = function () {};
-
-THREE.EventDispatcher.prototype = {
-
-	constructor: THREE.EventDispatcher,
-
-	apply: function ( object ) {
-
-		object.addEventListener = THREE.EventDispatcher.prototype.addEventListener;
-		object.hasEventListener = THREE.EventDispatcher.prototype.hasEventListener;
-		object.removeEventListener = THREE.EventDispatcher.prototype.removeEventListener;
-		object.dispatchEvent = THREE.EventDispatcher.prototype.dispatchEvent;
-
-	},
-
-	addEventListener: function ( type, listener ) {
-
-		if ( this._listeners === undefined ) this._listeners = {};
-
-		var listeners = this._listeners;
-
-		if ( listeners[ type ] === undefined ) {
-
-			listeners[ type ] = [];
-
-		}
-
-		if ( listeners[ type ].indexOf( listener ) === - 1 ) {
-
-			listeners[ type ].push( listener );
-
-		}
-
-	},
-
-	hasEventListener: function ( type, listener ) {
-
-		if ( this._listeners === undefined ) return false;
-
-		var listeners = this._listeners;
-
-		if ( listeners[ type ] !== undefined && listeners[ type ].indexOf( listener ) !== - 1 ) {
-
-			return true;
-
-		}
-
-		return false;
-
-	},
-
-	removeEventListener: function ( type, listener ) {
-
-		if ( this._listeners === undefined ) return;
-
-		var listeners = this._listeners;
-		var listenerArray = listeners[ type ];
-
-		if ( listenerArray !== undefined ) {
-
-			var index = listenerArray.indexOf( listener );
-
-			if ( index !== - 1 ) {
-
-				listenerArray.splice( index, 1 );
-
-			}
-
-		}
-
-	},
-
-	dispatchEvent: function ( event ) {
-
-		if ( this._listeners === undefined ) return;
-
-		var listeners = this._listeners;
-		var listenerArray = listeners[ event.type ];
-
-		if ( listenerArray !== undefined ) {
-
-			event.target = this;
-
-			var array = [];
-			var length = listenerArray.length;
-
-			for ( var i = 0; i < length; i ++ ) {
-
-				array[ i ] = listenerArray[ i ];
-
-			}
-
-			for ( var i = 0; i < length; i ++ ) {
-
-				array[ i ].call( this, event );
-
-			}
-
-		}
-
-	}
-
-};
-
-// File:src/core/Layers.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.Layers = function () {
-
-	this.mask = 1;
-
-};
-
-THREE.Layers.prototype = {
-
-	constructor: THREE.Layers,
-
-	set: function ( channel ) {
-
-		this.mask = 1 << channel;
-
-	},
-
-	enable: function ( channel ) {
-
-		this.mask |= 1 << channel;
-
-	},
-
-	toggle: function ( channel ) {
-
-		this.mask ^= 1 << channel;
-
-	},
-
-	disable: function ( channel ) {
-
-		this.mask &= ~ ( 1 << channel );
-
-	},
-
-	test: function ( layers ) {
-
-		return ( this.mask & layers.mask ) !== 0;
-
-	}
-
-};
-
-// File:src/core/Raycaster.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author bhouston / http://clara.io/
- * @author stephomi / http://stephaneginier.com/
- */
-
-( function ( THREE ) {
-
-	THREE.Raycaster = function ( origin, direction, near, far ) {
-
-		this.ray = new THREE.Ray( origin, direction );
-		// direction is assumed to be normalized (for accurate distance calculations)
-
-		this.near = near || 0;
-		this.far = far || Infinity;
-
-		this.params = {
-			Mesh: {},
-			Line: {},
-			LOD: {},
-			Points: { threshold: 1 },
-			Sprite: {}
-		};
-
-		Object.defineProperties( this.params, {
-			PointCloud: {
-				get: function () {
-					console.warn( 'THREE.Raycaster: params.PointCloud has been renamed to params.Points.' );
-					return this.Points;
-				}
-			}
-		} );
-
-	};
-
-	function ascSort( a, b ) {
-
-		return a.distance - b.distance;
-
-	}
-
-	function intersectObject( object, raycaster, intersects, recursive ) {
-
-		if ( object.visible === false ) return;
-
-		object.raycast( raycaster, intersects );
-
-		if ( recursive === true ) {
-
-			var children = object.children;
-
-			for ( var i = 0, l = children.length; i < l; i ++ ) {
-
-				intersectObject( children[ i ], raycaster, intersects, true );
-
-			}
-
-		}
-
-	}
-
-	//
-
-	THREE.Raycaster.prototype = {
-
-		constructor: THREE.Raycaster,
-
-		linePrecision: 1,
-
-		set: function ( origin, direction ) {
-
-			// direction is assumed to be normalized (for accurate distance calculations)
-
-			this.ray.set( origin, direction );
-
-		},
-
-		setFromCamera: function ( coords, camera ) {
-
-			if ( camera instanceof THREE.PerspectiveCamera ) {
-
-				this.ray.origin.setFromMatrixPosition( camera.matrixWorld );
-				this.ray.direction.set( coords.x, coords.y, 0.5 ).unproject( camera ).sub( this.ray.origin ).normalize();
-
-			} else if ( camera instanceof THREE.OrthographicCamera ) {
-
-				this.ray.origin.set( coords.x, coords.y, - 1 ).unproject( camera );
-				this.ray.direction.set( 0, 0, - 1 ).transformDirection( camera.matrixWorld );
-
-			} else {
-
-				console.error( 'THREE.Raycaster: Unsupported camera type.' );
-
-			}
-
-		},
-
-		intersectObject: function ( object, recursive ) {
-
-			var intersects = [];
-
-			intersectObject( object, this, intersects, recursive );
-
-			intersects.sort( ascSort );
-
-			return intersects;
-
-		},
-
-		intersectObjects: function ( objects, recursive ) {
-
-			var intersects = [];
-
-			if ( Array.isArray( objects ) === false ) {
-
-				console.warn( 'THREE.Raycaster.intersectObjects: objects is not an Array.' );
-				return intersects;
-
-			}
-
-			for ( var i = 0, l = objects.length; i < l; i ++ ) {
-
-				intersectObject( objects[ i ], this, intersects, recursive );
-
-			}
-
-			intersects.sort( ascSort );
-
-			return intersects;
-
-		}
-
-	};
-
-}( THREE ) );
-
-// File:src/core/Object3D.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author mikael emtinger / http://gomo.se/
- * @author alteredq / http://alteredqualia.com/
- * @author WestLangley / http://github.com/WestLangley
- * @author elephantatwork / www.elephantatwork.ch
- */
-
-THREE.Object3D = function () {
-
-	Object.defineProperty( this, 'id', { value: THREE.Object3DIdCount ++ } );
-
-	this.uuid = THREE.Math.generateUUID();
-
-	this.name = '';
-	this.type = 'Object3D';
-
-	this.parent = null;
-	this.children = [];
-
-	this.up = THREE.Object3D.DefaultUp.clone();
-
-	var position = new THREE.Vector3();
-	var rotation = new THREE.Euler();
-	var quaternion = new THREE.Quaternion();
-	var scale = new THREE.Vector3( 1, 1, 1 );
-
-	function onRotationChange() {
-
-		quaternion.setFromEuler( rotation, false );
-
-	}
-
-	function onQuaternionChange() {
-
-		rotation.setFromQuaternion( quaternion, undefined, false );
-
-	}
-
-	rotation.onChange( onRotationChange );
-	quaternion.onChange( onQuaternionChange );
-
-	Object.defineProperties( this, {
-		position: {
-			enumerable: true,
-			value: position
-		},
-		rotation: {
-			enumerable: true,
-			value: rotation
-		},
-		quaternion: {
-			enumerable: true,
-			value: quaternion
-		},
-		scale: {
-			enumerable: true,
-			value: scale
-		},
-		modelViewMatrix: {
-			value: new THREE.Matrix4()
-		},
-		normalMatrix: {
-			value: new THREE.Matrix3()
-		}
-	} );
-
-	this.rotationAutoUpdate = true;
-
-	this.matrix = new THREE.Matrix4();
-	this.matrixWorld = new THREE.Matrix4();
-
-	this.matrixAutoUpdate = THREE.Object3D.DefaultMatrixAutoUpdate;
-	this.matrixWorldNeedsUpdate = false;
-
-	this.layers = new THREE.Layers();
-	this.visible = true;
-
-	this.castShadow = false;
-	this.receiveShadow = false;
-
-	this.frustumCulled = true;
-	this.renderOrder = 0;
-
-	this.userData = {};
-
-};
-
-THREE.Object3D.DefaultUp = new THREE.Vector3( 0, 1, 0 );
-THREE.Object3D.DefaultMatrixAutoUpdate = true;
-
-THREE.Object3D.prototype = {
-
-	constructor: THREE.Object3D,
-
-	applyMatrix: function ( matrix ) {
-
-		this.matrix.multiplyMatrices( matrix, this.matrix );
-
-		this.matrix.decompose( this.position, this.quaternion, this.scale );
-
-	},
-
-	setRotationFromAxisAngle: function ( axis, angle ) {
-
-		// assumes axis is normalized
-
-		this.quaternion.setFromAxisAngle( axis, angle );
-
-	},
-
-	setRotationFromEuler: function ( euler ) {
-
-		this.quaternion.setFromEuler( euler, true );
-
-	},
-
-	setRotationFromMatrix: function ( m ) {
-
-		// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
-
-		this.quaternion.setFromRotationMatrix( m );
-
-	},
-
-	setRotationFromQuaternion: function ( q ) {
-
-		// assumes q is normalized
-
-		this.quaternion.copy( q );
-
-	},
-
-	rotateOnAxis: function () {
-
-		// rotate object on axis in object space
-		// axis is assumed to be normalized
-
-		var q1 = new THREE.Quaternion();
-
-		return function ( axis, angle ) {
-
-			q1.setFromAxisAngle( axis, angle );
-
-			this.quaternion.multiply( q1 );
-
-			return this;
-
-		};
-
-	}(),
-
-	rotateX: function () {
-
-		var v1 = new THREE.Vector3( 1, 0, 0 );
-
-		return function ( angle ) {
-
-			return this.rotateOnAxis( v1, angle );
-
-		};
-
-	}(),
-
-	rotateY: function () {
-
-		var v1 = new THREE.Vector3( 0, 1, 0 );
-
-		return function ( angle ) {
-
-			return this.rotateOnAxis( v1, angle );
-
-		};
-
-	}(),
-
-	rotateZ: function () {
-
-		var v1 = new THREE.Vector3( 0, 0, 1 );
-
-		return function ( angle ) {
-
-			return this.rotateOnAxis( v1, angle );
-
-		};
-
-	}(),
-
-	translateOnAxis: function () {
-
-		// translate object by distance along axis in object space
-		// axis is assumed to be normalized
-
-		var v1 = new THREE.Vector3();
-
-		return function ( axis, distance ) {
-
-			v1.copy( axis ).applyQuaternion( this.quaternion );
-
-			this.position.add( v1.multiplyScalar( distance ) );
-
-			return this;
-
-		};
-
-	}(),
-
-	translateX: function () {
-
-		var v1 = new THREE.Vector3( 1, 0, 0 );
-
-		return function ( distance ) {
-
-			return this.translateOnAxis( v1, distance );
-
-		};
-
-	}(),
-
-	translateY: function () {
-
-		var v1 = new THREE.Vector3( 0, 1, 0 );
-
-		return function ( distance ) {
-
-			return this.translateOnAxis( v1, distance );
-
-		};
-
-	}(),
-
-	translateZ: function () {
-
-		var v1 = new THREE.Vector3( 0, 0, 1 );
-
-		return function ( distance ) {
-
-			return this.translateOnAxis( v1, distance );
-
-		};
-
-	}(),
-
-	localToWorld: function ( vector ) {
-
-		return vector.applyMatrix4( this.matrixWorld );
-
-	},
-
-	worldToLocal: function () {
-
-		var m1 = new THREE.Matrix4();
-
-		return function ( vector ) {
-
-			return vector.applyMatrix4( m1.getInverse( this.matrixWorld ) );
-
-		};
-
-	}(),
-
-	lookAt: function () {
-
-		// This routine does not support objects with rotated and/or translated parent(s)
-
-		var m1 = new THREE.Matrix4();
-
-		return function ( vector ) {
-
-			m1.lookAt( vector, this.position, this.up );
-
-			this.quaternion.setFromRotationMatrix( m1 );
-
-		};
-
-	}(),
-
-	add: function ( object ) {
-
-		if ( arguments.length > 1 ) {
-
-			for ( var i = 0; i < arguments.length; i ++ ) {
-
-				this.add( arguments[ i ] );
-
-			}
-
-			return this;
-
-		}
-
-		if ( object === this ) {
-
-			console.error( "THREE.Object3D.add: object can't be added as a child of itself.", object );
-			return this;
-
-		}
-
-		if ( object instanceof THREE.Object3D ) {
-
-			if ( object.parent !== null ) {
-
-				object.parent.remove( object );
-
-			}
-
-			object.parent = this;
-			object.dispatchEvent( { type: 'added' } );
-
-			this.children.push( object );
-
-		} else {
-
-			console.error( "THREE.Object3D.add: object not an instance of THREE.Object3D.", object );
-
-		}
-
-		return this;
-
-	},
-
-	remove: function ( object ) {
-
-		if ( arguments.length > 1 ) {
-
-			for ( var i = 0; i < arguments.length; i ++ ) {
-
-				this.remove( arguments[ i ] );
-
-			}
-
-		}
-
-		var index = this.children.indexOf( object );
-
-		if ( index !== - 1 ) {
-
-			object.parent = null;
-
-			object.dispatchEvent( { type: 'removed' } );
-
-			this.children.splice( index, 1 );
-
-		}
-
-	},
-
-	getObjectById: function ( id ) {
-
-		return this.getObjectByProperty( 'id', id );
-
-	},
-
-	getObjectByName: function ( name ) {
-
-		return this.getObjectByProperty( 'name', name );
-
-	},
-
-	getObjectByProperty: function ( name, value ) {
-
-		if ( this[ name ] === value ) return this;
-
-		for ( var i = 0, l = this.children.length; i < l; i ++ ) {
-
-			var child = this.children[ i ];
-			var object = child.getObjectByProperty( name, value );
-
-			if ( object !== undefined ) {
-
-				return object;
-
-			}
-
-		}
-
-		return undefined;
-
-	},
-
-	getWorldPosition: function ( optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector3();
-
-		this.updateMatrixWorld( true );
-
-		return result.setFromMatrixPosition( this.matrixWorld );
-
-	},
-
-	getWorldQuaternion: function () {
-
-		var position = new THREE.Vector3();
-		var scale = new THREE.Vector3();
-
-		return function ( optionalTarget ) {
-
-			var result = optionalTarget || new THREE.Quaternion();
-
-			this.updateMatrixWorld( true );
-
-			this.matrixWorld.decompose( position, result, scale );
-
-			return result;
-
-		};
-
-	}(),
-
-	getWorldRotation: function () {
-
-		var quaternion = new THREE.Quaternion();
-
-		return function ( optionalTarget ) {
-
-			var result = optionalTarget || new THREE.Euler();
-
-			this.getWorldQuaternion( quaternion );
-
-			return result.setFromQuaternion( quaternion, this.rotation.order, false );
-
-		};
-
-	}(),
-
-	getWorldScale: function () {
-
-		var position = new THREE.Vector3();
-		var quaternion = new THREE.Quaternion();
-
-		return function ( optionalTarget ) {
-
-			var result = optionalTarget || new THREE.Vector3();
-
-			this.updateMatrixWorld( true );
-
-			this.matrixWorld.decompose( position, quaternion, result );
-
-			return result;
-
-		};
-
-	}(),
-
-	getWorldDirection: function () {
-
-		var quaternion = new THREE.Quaternion();
-
-		return function ( optionalTarget ) {
-
-			var result = optionalTarget || new THREE.Vector3();
-
-			this.getWorldQuaternion( quaternion );
-
-			return result.set( 0, 0, 1 ).applyQuaternion( quaternion );
-
-		};
-
-	}(),
-
-	raycast: function () {},
-
-	traverse: function ( callback ) {
-
-		callback( this );
-
-		var children = this.children;
-
-		for ( var i = 0, l = children.length; i < l; i ++ ) {
-
-			children[ i ].traverse( callback );
-
-		}
-
-	},
-
-	traverseVisible: function ( callback ) {
-
-		if ( this.visible === false ) return;
-
-		callback( this );
-
-		var children = this.children;
-
-		for ( var i = 0, l = children.length; i < l; i ++ ) {
-
-			children[ i ].traverseVisible( callback );
-
-		}
-
-	},
-
-	traverseAncestors: function ( callback ) {
-
-		var parent = this.parent;
-
-		if ( parent !== null ) {
-
-			callback( parent );
-
-			parent.traverseAncestors( callback );
-
-		}
-
-	},
-
-	updateMatrix: function () {
-
-		this.matrix.compose( this.position, this.quaternion, this.scale );
-
-		this.matrixWorldNeedsUpdate = true;
-
-	},
-
-	updateMatrixWorld: function ( force ) {
-
-		if ( this.matrixAutoUpdate === true ) this.updateMatrix();
-
-		if ( this.matrixWorldNeedsUpdate === true || force === true ) {
-
-			if ( this.parent === null ) {
-
-				this.matrixWorld.copy( this.matrix );
-
-			} else {
-
-				this.matrixWorld.multiplyMatrices( this.parent.matrixWorld, this.matrix );
-
-			}
-
-			this.matrixWorldNeedsUpdate = false;
-
-			force = true;
-
-		}
-
-		// update children
-
-		for ( var i = 0, l = this.children.length; i < l; i ++ ) {
-
-			this.children[ i ].updateMatrixWorld( force );
-
-		}
-
-	},
-
-	toJSON: function ( meta ) {
-
-		// meta is '' when called from JSON.stringify
-		var isRootObject = ( meta === undefined || meta === '' );
-
-		var output = {};
-
-		// meta is a hash used to collect geometries, materials.
-		// not providing it implies that this is the root object
-		// being serialized.
-		if ( isRootObject ) {
-
-			// initialize meta obj
-			meta = {
-				geometries: {},
-				materials: {},
-				textures: {},
-				images: {}
-			};
-
-			output.metadata = {
-				version: 4.4,
-				type: 'Object',
-				generator: 'Object3D.toJSON'
-			};
-
-		}
-
-		// standard Object3D serialization
-
-		var object = {};
-
-		object.uuid = this.uuid;
-		object.type = this.type;
-
-		if ( this.name !== '' ) object.name = this.name;
-		if ( JSON.stringify( this.userData ) !== '{}' ) object.userData = this.userData;
-		if ( this.castShadow === true ) object.castShadow = true;
-		if ( this.receiveShadow === true ) object.receiveShadow = true;
-		if ( this.visible === false ) object.visible = false;
-
-		object.matrix = this.matrix.toArray();
-
-		//
-
-		if ( this.geometry !== undefined ) {
-
-			if ( meta.geometries[ this.geometry.uuid ] === undefined ) {
-
-				meta.geometries[ this.geometry.uuid ] = this.geometry.toJSON( meta );
-
-			}
-
-			object.geometry = this.geometry.uuid;
-
-		}
-
-		if ( this.material !== undefined ) {
-
-			if ( meta.materials[ this.material.uuid ] === undefined ) {
-
-				meta.materials[ this.material.uuid ] = this.material.toJSON( meta );
-
-			}
-
-			object.material = this.material.uuid;
-
-		}
-
-		//
-
-		if ( this.children.length > 0 ) {
-
-			object.children = [];
-
-			for ( var i = 0; i < this.children.length; i ++ ) {
-
-				object.children.push( this.children[ i ].toJSON( meta ).object );
-
-			}
-
-		}
-
-		if ( isRootObject ) {
-
-			var geometries = extractFromCache( meta.geometries );
-			var materials = extractFromCache( meta.materials );
-			var textures = extractFromCache( meta.textures );
-			var images = extractFromCache( meta.images );
-
-			if ( geometries.length > 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;
-
-		}
-
-		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.rotationAutoUpdate = source.rotationAutoUpdate;
-
-		this.matrix.copy( source.matrix );
-		this.matrixWorld.copy( source.matrixWorld );
-
-		this.matrixAutoUpdate = source.matrixAutoUpdate;
-		this.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate;
-
-		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 < source.children.length; i ++ ) {
-
-				var child = source.children[ i ];
-				this.add( child.clone() );
-
-			}
-
-		}
-
-		return this;
-
-	}
-
-};
-
-THREE.EventDispatcher.prototype.apply( THREE.Object3D.prototype );
-
-THREE.Object3DIdCount = 0;
-
-// File:src/core/Face3.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.Face3 = function ( a, b, c, normal, color, materialIndex ) {
-
-	this.a = a;
-	this.b = b;
-	this.c = c;
-
-	this.normal = normal instanceof THREE.Vector3 ? normal : new THREE.Vector3();
-	this.vertexNormals = Array.isArray( normal ) ? normal : [];
-
-	this.color = color instanceof THREE.Color ? color : new THREE.Color();
-	this.vertexColors = Array.isArray( color ) ? color : [];
-
-	this.materialIndex = materialIndex !== undefined ? materialIndex : 0;
-
-};
-
-THREE.Face3.prototype = {
-
-	constructor: THREE.Face3,
-
-	clone: function () {
-
-		return new this.constructor().copy( this );
-
-	},
-
-	copy: function ( source ) {
-
-		this.a = source.a;
-		this.b = source.b;
-		this.c = source.c;
-
-		this.normal.copy( source.normal );
-		this.color.copy( source.color );
-
-		this.materialIndex = source.materialIndex;
-
-		for ( var i = 0, il = source.vertexNormals.length; i < il; i ++ ) {
-
-			this.vertexNormals[ i ] = source.vertexNormals[ i ].clone();
-
-		}
-
-		for ( var i = 0, il = source.vertexColors.length; i < il; i ++ ) {
-
-			this.vertexColors[ i ] = source.vertexColors[ i ].clone();
-
-		}
-
-		return this;
-
-	}
-
-};
-
-// File:src/core/BufferAttribute.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.BufferAttribute = function ( array, itemSize, normalized ) {
-
-	this.uuid = THREE.Math.generateUUID();
-
-	this.array = array;
-	this.itemSize = itemSize;
-
-	this.dynamic = false;
-	this.updateRange = { offset: 0, count: - 1 };
-
-	this.version = 0;
-	this.normalized = normalized === true;
-
-};
-
-THREE.BufferAttribute.prototype = {
-
-	constructor: THREE.BufferAttribute,
-
-	get count() {
-
-		return this.array.length / this.itemSize;
-
-	},
-
-	set needsUpdate( value ) {
-
-		if ( value === true ) this.version ++;
-
-	},
-
-	setDynamic: function ( value ) {
-
-		this.dynamic = value;
-
-		return this;
-
-	},
-
-	copy: function ( source ) {
-
-		this.array = new source.array.constructor( source.array );
-		this.itemSize = source.itemSize;
-
-		this.dynamic = source.dynamic;
-
-		return this;
-
-	},
-
-	copyAt: function ( index1, attribute, index2 ) {
-
-		index1 *= this.itemSize;
-		index2 *= attribute.itemSize;
-
-		for ( var i = 0, l = this.itemSize; i < l; i ++ ) {
-
-			this.array[ index1 + i ] = attribute.array[ index2 + i ];
-
-		}
-
-		return this;
-
-	},
-
-	copyArray: function ( array ) {
-
-		this.array.set( array );
-
-		return this;
-
-	},
-
-	copyColorsArray: function ( colors ) {
-
-		var array = this.array, offset = 0;
-
-		for ( var i = 0, l = colors.length; i < l; i ++ ) {
-
-			var color = colors[ i ];
-
-			if ( color === undefined ) {
-
-				console.warn( 'THREE.BufferAttribute.copyColorsArray(): color is undefined', i );
-				color = new THREE.Color();
-
-			}
-
-			array[ offset ++ ] = color.r;
-			array[ offset ++ ] = color.g;
-			array[ offset ++ ] = color.b;
-
-		}
-
-		return this;
-
-	},
-
-	copyIndicesArray: function ( indices ) {
-
-		var array = this.array, offset = 0;
-
-		for ( var i = 0, l = indices.length; i < l; i ++ ) {
-
-			var index = indices[ i ];
-
-			array[ offset ++ ] = index.a;
-			array[ offset ++ ] = index.b;
-			array[ offset ++ ] = index.c;
-
-		}
-
-		return this;
-
-	},
-
-	copyVector2sArray: function ( vectors ) {
-
-		var array = this.array, offset = 0;
-
-		for ( var i = 0, l = vectors.length; i < l; i ++ ) {
-
-			var vector = vectors[ i ];
-
-			if ( vector === undefined ) {
-
-				console.warn( 'THREE.BufferAttribute.copyVector2sArray(): vector is undefined', i );
-				vector = new THREE.Vector2();
-
-			}
-
-			array[ offset ++ ] = vector.x;
-			array[ offset ++ ] = vector.y;
-
-		}
-
-		return this;
-
-	},
-
-	copyVector3sArray: function ( vectors ) {
-
-		var array = this.array, offset = 0;
-
-		for ( var i = 0, l = vectors.length; i < l; i ++ ) {
-
-			var vector = vectors[ i ];
-
-			if ( vector === undefined ) {
-
-				console.warn( 'THREE.BufferAttribute.copyVector3sArray(): vector is undefined', i );
-				vector = new THREE.Vector3();
-
-			}
-
-			array[ offset ++ ] = vector.x;
-			array[ offset ++ ] = vector.y;
-			array[ offset ++ ] = vector.z;
-
-		}
-
-		return this;
-
-	},
-
-	copyVector4sArray: function ( vectors ) {
-
-		var array = this.array, offset = 0;
-
-		for ( var i = 0, l = vectors.length; i < l; i ++ ) {
-
-			var vector = vectors[ i ];
-
-			if ( vector === undefined ) {
-
-				console.warn( 'THREE.BufferAttribute.copyVector4sArray(): vector is undefined', i );
-				vector = new THREE.Vector4();
-
-			}
-
-			array[ offset ++ ] = vector.x;
-			array[ offset ++ ] = vector.y;
-			array[ offset ++ ] = vector.z;
-			array[ offset ++ ] = vector.w;
-
-		}
-
-		return this;
-
-	},
-
-	set: function ( value, offset ) {
-
-		if ( offset === undefined ) offset = 0;
-
-		this.array.set( value, offset );
-
-		return this;
-
-	},
-
-	getX: function ( index ) {
-
-		return this.array[ index * this.itemSize ];
-
-	},
-
-	setX: function ( index, x ) {
-
-		this.array[ index * this.itemSize ] = x;
-
-		return this;
-
-	},
-
-	getY: function ( index ) {
-
-		return this.array[ index * this.itemSize + 1 ];
-
-	},
-
-	setY: function ( index, y ) {
-
-		this.array[ index * this.itemSize + 1 ] = y;
-
-		return this;
-
-	},
-
-	getZ: function ( index ) {
-
-		return this.array[ index * this.itemSize + 2 ];
-
-	},
-
-	setZ: function ( index, z ) {
-
-		this.array[ index * this.itemSize + 2 ] = z;
-
-		return this;
-
-	},
-
-	getW: function ( index ) {
-
-		return this.array[ index * this.itemSize + 3 ];
-
-	},
-
-	setW: function ( index, w ) {
-
-		this.array[ index * this.itemSize + 3 ] = w;
-
-		return this;
-
-	},
-
-	setXY: function ( index, x, y ) {
-
-		index *= this.itemSize;
-
-		this.array[ index + 0 ] = x;
-		this.array[ index + 1 ] = y;
-
-		return this;
-
-	},
-
-	setXYZ: function ( index, x, y, z ) {
-
-		index *= this.itemSize;
-
-		this.array[ index + 0 ] = x;
-		this.array[ index + 1 ] = y;
-		this.array[ index + 2 ] = z;
-
-		return this;
-
-	},
-
-	setXYZW: function ( index, x, y, z, w ) {
-
-		index *= this.itemSize;
-
-		this.array[ index + 0 ] = x;
-		this.array[ index + 1 ] = y;
-		this.array[ index + 2 ] = z;
-		this.array[ index + 3 ] = w;
-
-		return this;
-
-	},
-
-	clone: function () {
-
-		return new this.constructor().copy( this );
-
-	}
-
-};
-
-//
-
-THREE.Int8Attribute = function ( array, itemSize ) {
-
-	return new THREE.BufferAttribute( new Int8Array( array ), itemSize );
-
-};
-
-THREE.Uint8Attribute = function ( array, itemSize ) {
-
-	return new THREE.BufferAttribute( new Uint8Array( array ), itemSize );
-
-};
-
-THREE.Uint8ClampedAttribute = function ( array, itemSize ) {
-
-	return new THREE.BufferAttribute( new Uint8ClampedArray( array ), itemSize );
-
-};
-
-THREE.Int16Attribute = function ( array, itemSize ) {
-
-	return new THREE.BufferAttribute( new Int16Array( array ), itemSize );
-
-};
-
-THREE.Uint16Attribute = function ( array, itemSize ) {
-
-	return new THREE.BufferAttribute( new Uint16Array( array ), itemSize );
-
-};
-
-THREE.Int32Attribute = function ( array, itemSize ) {
-
-	return new THREE.BufferAttribute( new Int32Array( array ), itemSize );
-
-};
-
-THREE.Uint32Attribute = function ( array, itemSize ) {
-
-	return new THREE.BufferAttribute( new Uint32Array( array ), itemSize );
-
-};
-
-THREE.Float32Attribute = function ( array, itemSize ) {
-
-	return new THREE.BufferAttribute( new Float32Array( array ), itemSize );
-
-};
-
-THREE.Float64Attribute = function ( array, itemSize ) {
-
-	return new THREE.BufferAttribute( new Float64Array( array ), itemSize );
-
-};
-
-
-// Deprecated
-
-THREE.DynamicBufferAttribute = function ( array, itemSize ) {
-
-	console.warn( 'THREE.DynamicBufferAttribute has been removed. Use new THREE.BufferAttribute().setDynamic( true ) instead.' );
-	return new THREE.BufferAttribute( array, itemSize ).setDynamic( true );
-
-};
-
-// File:src/core/InstancedBufferAttribute.js
-
-/**
- * @author benaadams / https://twitter.com/ben_a_adams
- */
-
-THREE.InstancedBufferAttribute = function ( array, itemSize, meshPerAttribute ) {
-
-	THREE.BufferAttribute.call( this, array, itemSize );
-
-	this.meshPerAttribute = meshPerAttribute || 1;
-
-};
-
-THREE.InstancedBufferAttribute.prototype = Object.create( THREE.BufferAttribute.prototype );
-THREE.InstancedBufferAttribute.prototype.constructor = THREE.InstancedBufferAttribute;
-
-THREE.InstancedBufferAttribute.prototype.copy = function ( source ) {
-
-	THREE.BufferAttribute.prototype.copy.call( this, source );
-
-	this.meshPerAttribute = source.meshPerAttribute;
-
-	return this;
-
-};
-
-// File:src/core/InterleavedBuffer.js
-
-/**
- * @author benaadams / https://twitter.com/ben_a_adams
- */
-
-THREE.InterleavedBuffer = function ( array, stride ) {
-
-	this.uuid = THREE.Math.generateUUID();
-
-	this.array = array;
-	this.stride = stride;
-
-	this.dynamic = false;
-	this.updateRange = { offset: 0, count: - 1 };
-
-	this.version = 0;
-
-};
-
-THREE.InterleavedBuffer.prototype = {
-
-	constructor: THREE.InterleavedBuffer,
-
-	get length () {
-
-		return this.array.length;
-
-	},
-
-	get count () {
-
-		return this.array.length / this.stride;
-
-	},
-
-	set needsUpdate( value ) {
-
-		if ( value === true ) this.version ++;
-
-	},
-
-	setDynamic: function ( value ) {
-
-		this.dynamic = value;
-
-		return this;
-
-	},
-
-	copy: function ( source ) {
-
-		this.array = new source.array.constructor( source.array );
-		this.stride = source.stride;
-		this.dynamic = source.dynamic;
-
-		return this;
-
-	},
-
-	copyAt: function ( index1, attribute, index2 ) {
-
-		index1 *= this.stride;
-		index2 *= attribute.stride;
-
-		for ( var i = 0, l = this.stride; i < l; i ++ ) {
-
-			this.array[ index1 + i ] = attribute.array[ index2 + i ];
-
-		}
-
-		return this;
-
-	},
-
-	set: function ( value, offset ) {
-
-		if ( offset === undefined ) offset = 0;
-
-		this.array.set( value, offset );
-
-		return this;
-
-	},
-
-	clone: function () {
-
-		return new this.constructor().copy( this );
-
-	}
-
-};
-
-// File:src/core/InstancedInterleavedBuffer.js
-
-/**
- * @author benaadams / https://twitter.com/ben_a_adams
- */
-
-THREE.InstancedInterleavedBuffer = function ( array, stride, meshPerAttribute ) {
-
-	THREE.InterleavedBuffer.call( this, array, stride );
-
-	this.meshPerAttribute = meshPerAttribute || 1;
-
-};
-
-THREE.InstancedInterleavedBuffer.prototype = Object.create( THREE.InterleavedBuffer.prototype );
-THREE.InstancedInterleavedBuffer.prototype.constructor = THREE.InstancedInterleavedBuffer;
-
-THREE.InstancedInterleavedBuffer.prototype.copy = function ( source ) {
-
-	THREE.InterleavedBuffer.prototype.copy.call( this, source );
-
-	this.meshPerAttribute = source.meshPerAttribute;
-
-	return this;
-
-};
-
-// File:src/core/InterleavedBufferAttribute.js
-
-/**
- * @author benaadams / https://twitter.com/ben_a_adams
- */
-
-THREE.InterleavedBufferAttribute = function ( interleavedBuffer, itemSize, offset ) {
-
-	this.uuid = THREE.Math.generateUUID();
-
-	this.data = interleavedBuffer;
-	this.itemSize = itemSize;
-	this.offset = offset;
-
-};
-
-
-THREE.InterleavedBufferAttribute.prototype = {
-
-	constructor: THREE.InterleavedBufferAttribute,
-
-	get length() {
-
-		console.warn( 'THREE.BufferAttribute: .length has been deprecated. Please use .count.' );
-		return this.array.length;
-
-	},
-
-	get count() {
-
-		return this.data.count;
-
-	},
-
-	setX: function ( index, x ) {
-
-		this.data.array[ index * this.data.stride + this.offset ] = x;
-
-		return this;
-
-	},
-
-	setY: function ( index, y ) {
-
-		this.data.array[ index * this.data.stride + this.offset + 1 ] = y;
-
-		return this;
-
-	},
-
-	setZ: function ( index, z ) {
-
-		this.data.array[ index * this.data.stride + this.offset + 2 ] = z;
-
-		return this;
-
-	},
-
-	setW: function ( index, w ) {
-
-		this.data.array[ index * this.data.stride + this.offset + 3 ] = w;
-
-		return this;
-
-	},
-
-	getX: function ( index ) {
-
-		return this.data.array[ index * this.data.stride + this.offset ];
-
-	},
-
-	getY: function ( index ) {
-
-		return this.data.array[ index * this.data.stride + this.offset + 1 ];
-
-	},
-
-	getZ: function ( index ) {
-
-		return this.data.array[ index * this.data.stride + this.offset + 2 ];
-
-	},
-
-	getW: function ( index ) {
-
-		return this.data.array[ index * this.data.stride + this.offset + 3 ];
-
-	},
-
-	setXY: function ( index, x, y ) {
-
-		index = index * this.data.stride + this.offset;
-
-		this.data.array[ index + 0 ] = x;
-		this.data.array[ index + 1 ] = y;
-
-		return this;
-
-	},
-
-	setXYZ: function ( index, x, y, z ) {
-
-		index = index * this.data.stride + this.offset;
-
-		this.data.array[ index + 0 ] = x;
-		this.data.array[ index + 1 ] = y;
-		this.data.array[ index + 2 ] = z;
-
-		return this;
-
-	},
-
-	setXYZW: function ( index, x, y, z, w ) {
-
-		index = index * this.data.stride + this.offset;
-
-		this.data.array[ index + 0 ] = x;
-		this.data.array[ index + 1 ] = y;
-		this.data.array[ index + 2 ] = z;
-		this.data.array[ index + 3 ] = w;
-
-		return this;
-
-	}
-
-};
-
-// File:src/core/Geometry.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author kile / http://kile.stravaganza.org/
- * @author alteredq / http://alteredqualia.com/
- * @author mikael emtinger / http://gomo.se/
- * @author zz85 / http://www.lab4games.net/zz85/blog
- * @author bhouston / http://clara.io
- */
-
-THREE.Geometry = function () {
-
-	Object.defineProperty( this, 'id', { value: THREE.GeometryIdCount ++ } );
-
-	this.uuid = THREE.Math.generateUUID();
-
-	this.name = '';
-	this.type = 'Geometry';
-
-	this.vertices = [];
-	this.colors = [];
-	this.faces = [];
-	this.faceVertexUvs = [ [] ];
-
-	this.morphTargets = [];
-	this.morphNormals = [];
-
-	this.skinWeights = [];
-	this.skinIndices = [];
-
-	this.lineDistances = [];
-
-	this.boundingBox = null;
-	this.boundingSphere = null;
-
-	// update flags
-
-	this.verticesNeedUpdate = false;
-	this.elementsNeedUpdate = false;
-	this.uvsNeedUpdate = false;
-	this.normalsNeedUpdate = false;
-	this.colorsNeedUpdate = false;
-	this.lineDistancesNeedUpdate = false;
-	this.groupsNeedUpdate = false;
-
-};
-
-THREE.Geometry.prototype = {
-
-	constructor: THREE.Geometry,
-
-	applyMatrix: function ( matrix ) {
-
-		var normalMatrix = new THREE.Matrix3().getNormalMatrix( matrix );
-
-		for ( var i = 0, il = this.vertices.length; i < il; i ++ ) {
-
-			var vertex = this.vertices[ i ];
-			vertex.applyMatrix4( matrix );
-
-		}
-
-		for ( var i = 0, il = this.faces.length; i < il; i ++ ) {
-
-			var face = this.faces[ i ];
-			face.normal.applyMatrix3( normalMatrix ).normalize();
-
-			for ( var j = 0, jl = face.vertexNormals.length; j < jl; j ++ ) {
-
-				face.vertexNormals[ j ].applyMatrix3( normalMatrix ).normalize();
-
-			}
-
-		}
-
-		if ( this.boundingBox !== null ) {
-
-			this.computeBoundingBox();
-
-		}
-
-		if ( this.boundingSphere !== null ) {
-
-			this.computeBoundingSphere();
-
-		}
-
-		this.verticesNeedUpdate = true;
-		this.normalsNeedUpdate = true;
-
-		return this;
-
-	},
-
-	rotateX: function () {
-
-		// rotate geometry around world x-axis
-
-		var m1;
-
-		return function rotateX( angle ) {
-
-			if ( m1 === undefined ) m1 = new THREE.Matrix4();
-
-			m1.makeRotationX( angle );
-
-			this.applyMatrix( m1 );
-
-			return this;
-
-		};
-
-	}(),
-
-	rotateY: function () {
-
-		// rotate geometry around world y-axis
-
-		var m1;
-
-		return function rotateY( angle ) {
-
-			if ( m1 === undefined ) m1 = new THREE.Matrix4();
-
-			m1.makeRotationY( angle );
-
-			this.applyMatrix( m1 );
-
-			return this;
-
-		};
-
-	}(),
-
-	rotateZ: function () {
-
-		// rotate geometry around world z-axis
-
-		var m1;
-
-		return function rotateZ( angle ) {
-
-			if ( m1 === undefined ) m1 = new THREE.Matrix4();
-
-			m1.makeRotationZ( angle );
-
-			this.applyMatrix( m1 );
-
-			return this;
-
-		};
-
-	}(),
-
-	translate: function () {
-
-		// translate geometry
-
-		var m1;
-
-		return function translate( x, y, z ) {
-
-			if ( m1 === undefined ) m1 = new THREE.Matrix4();
-
-			m1.makeTranslation( x, y, z );
-
-			this.applyMatrix( m1 );
-
-			return this;
-
-		};
-
-	}(),
-
-	scale: function () {
-
-		// scale geometry
-
-		var m1;
-
-		return function scale( x, y, z ) {
-
-			if ( m1 === undefined ) m1 = new THREE.Matrix4();
-
-			m1.makeScale( x, y, z );
-
-			this.applyMatrix( m1 );
-
-			return this;
-
-		};
-
-	}(),
-
-	lookAt: function () {
-
-		var obj;
-
-		return function lookAt( vector ) {
-
-			if ( obj === undefined ) obj = new THREE.Object3D();
-
-			obj.lookAt( vector );
-
-			obj.updateMatrix();
-
-			this.applyMatrix( obj.matrix );
-
-		};
-
-	}(),
-
-	fromBufferGeometry: function ( geometry ) {
-
-		var scope = this;
-
-		var indices = geometry.index !== null ? geometry.index.array : undefined;
-		var attributes = geometry.attributes;
-
-		var positions = attributes.position.array;
-		var normals = attributes.normal !== undefined ? attributes.normal.array : undefined;
-		var colors = attributes.color !== undefined ? attributes.color.array : undefined;
-		var uvs = attributes.uv !== undefined ? attributes.uv.array : undefined;
-		var uvs2 = attributes.uv2 !== undefined ? attributes.uv2.array : undefined;
-
-		if ( uvs2 !== undefined ) this.faceVertexUvs[ 1 ] = [];
-
-		var tempNormals = [];
-		var tempUVs = [];
-		var tempUVs2 = [];
-
-		for ( var i = 0, j = 0; i < positions.length; i += 3, j += 2 ) {
-
-			scope.vertices.push( new THREE.Vector3( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] ) );
-
-			if ( normals !== undefined ) {
-
-				tempNormals.push( new THREE.Vector3( normals[ i ], normals[ i + 1 ], normals[ i + 2 ] ) );
-
-			}
-
-			if ( colors !== undefined ) {
-
-				scope.colors.push( new THREE.Color( colors[ i ], colors[ i + 1 ], colors[ i + 2 ] ) );
-
-			}
-
-			if ( uvs !== undefined ) {
-
-				tempUVs.push( new THREE.Vector2( uvs[ j ], uvs[ j + 1 ] ) );
-
-			}
-
-			if ( uvs2 !== undefined ) {
-
-				tempUVs2.push( new THREE.Vector2( uvs2[ j ], uvs2[ j + 1 ] ) );
-
-			}
-
-		}
-
-		function addFace( a, b, c, materialIndex ) {
-
-			var vertexNormals = normals !== undefined ? [ tempNormals[ a ].clone(), tempNormals[ b ].clone(), tempNormals[ c ].clone() ] : [];
-			var vertexColors = colors !== undefined ? [ scope.colors[ a ].clone(), scope.colors[ b ].clone(), scope.colors[ c ].clone() ] : [];
-
-			var face = new THREE.Face3( a, b, c, vertexNormals, vertexColors, materialIndex );
-
-			scope.faces.push( face );
-
-			if ( uvs !== undefined ) {
-
-				scope.faceVertexUvs[ 0 ].push( [ tempUVs[ a ].clone(), tempUVs[ b ].clone(), tempUVs[ c ].clone() ] );
-
-			}
-
-			if ( uvs2 !== undefined ) {
-
-				scope.faceVertexUvs[ 1 ].push( [ tempUVs2[ a ].clone(), tempUVs2[ b ].clone(), tempUVs2[ c ].clone() ] );
-
-			}
-
-		}
-
-		if ( indices !== undefined ) {
-
-			var groups = geometry.groups;
-
-			if ( groups.length > 0 ) {
-
-				for ( var i = 0; i < groups.length; i ++ ) {
-
-					var group = groups[ i ];
-
-					var start = group.start;
-					var count = group.count;
-
-					for ( var j = start, jl = start + count; j < jl; j += 3 ) {
-
-						addFace( indices[ j ], indices[ j + 1 ], indices[ j + 2 ], group.materialIndex  );
-
-					}
-
-				}
-
-			} else {
-
-				for ( var i = 0; i < indices.length; i += 3 ) {
-
-					addFace( indices[ i ], indices[ i + 1 ], indices[ i + 2 ] );
-
-				}
-
-			}
-
-		} else {
-
-			for ( var i = 0; i < positions.length / 3; i += 3 ) {
-
-				addFace( i, i + 1, i + 2 );
-
-			}
-
-		}
-
-		this.computeFaceNormals();
-
-		if ( geometry.boundingBox !== null ) {
-
-			this.boundingBox = geometry.boundingBox.clone();
-
-		}
-
-		if ( geometry.boundingSphere !== null ) {
-
-			this.boundingSphere = geometry.boundingSphere.clone();
-
-		}
-
-		return this;
-
-	},
-
-	center: function () {
-
-		this.computeBoundingBox();
-
-		var offset = this.boundingBox.center().negate();
-
-		this.translate( offset.x, offset.y, offset.z );
-
-		return offset;
-
-	},
-
-	normalize: function () {
-
-		this.computeBoundingSphere();
-
-		var center = this.boundingSphere.center;
-		var radius = this.boundingSphere.radius;
-
-		var s = radius === 0 ? 1 : 1.0 / radius;
-
-		var matrix = new THREE.Matrix4();
-		matrix.set(
-			s, 0, 0, - s * center.x,
-			0, s, 0, - s * center.y,
-			0, 0, s, - s * center.z,
-			0, 0, 0, 1
-		);
-
-		this.applyMatrix( matrix );
-
-		return this;
-
-	},
-
-	computeFaceNormals: function () {
-
-		var cb = new THREE.Vector3(), ab = new THREE.Vector3();
-
-		for ( var f = 0, fl = this.faces.length; f < fl; f ++ ) {
-
-			var face = this.faces[ f ];
-
-			var vA = this.vertices[ face.a ];
-			var vB = this.vertices[ face.b ];
-			var vC = this.vertices[ face.c ];
-
-			cb.subVectors( vC, vB );
-			ab.subVectors( vA, vB );
-			cb.cross( ab );
-
-			cb.normalize();
-
-			face.normal.copy( cb );
-
-		}
-
-	},
-
-	computeVertexNormals: function ( areaWeighted ) {
-
-		if ( areaWeighted === undefined ) areaWeighted = true;
-
-		var v, vl, f, fl, face, vertices;
-
-		vertices = new Array( this.vertices.length );
-
-		for ( v = 0, vl = this.vertices.length; v < vl; v ++ ) {
-
-			vertices[ v ] = new THREE.Vector3();
-
-		}
-
-		if ( areaWeighted ) {
-
-			// vertex normals weighted by triangle areas
-			// http://www.iquilezles.org/www/articles/normals/normals.htm
-
-			var vA, vB, vC;
-			var cb = new THREE.Vector3(), ab = new THREE.Vector3();
-
-			for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
-
-				face = this.faces[ f ];
-
-				vA = this.vertices[ face.a ];
-				vB = this.vertices[ face.b ];
-				vC = this.vertices[ face.c ];
-
-				cb.subVectors( vC, vB );
-				ab.subVectors( vA, vB );
-				cb.cross( ab );
-
-				vertices[ face.a ].add( cb );
-				vertices[ face.b ].add( cb );
-				vertices[ face.c ].add( cb );
-
-			}
-
-		} else {
-
-			for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
-
-				face = this.faces[ f ];
-
-				vertices[ face.a ].add( face.normal );
-				vertices[ face.b ].add( face.normal );
-				vertices[ face.c ].add( face.normal );
-
-			}
-
-		}
-
-		for ( v = 0, vl = this.vertices.length; v < vl; v ++ ) {
-
-			vertices[ v ].normalize();
-
-		}
-
-		for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
-
-			face = this.faces[ f ];
-
-			var vertexNormals = face.vertexNormals;
-
-			if ( vertexNormals.length === 3 ) {
-
-				vertexNormals[ 0 ].copy( vertices[ face.a ] );
-				vertexNormals[ 1 ].copy( vertices[ face.b ] );
-				vertexNormals[ 2 ].copy( vertices[ face.c ] );
-
-			} else {
-
-				vertexNormals[ 0 ] = vertices[ face.a ].clone();
-				vertexNormals[ 1 ] = vertices[ face.b ].clone();
-				vertexNormals[ 2 ] = vertices[ face.c ].clone();
-
-			}
-
-		}
-
-		if ( this.faces.length > 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 < fl; f ++ ) {
-
-			face = this.faces[ f ];
-
-			if ( ! face.__originalFaceNormal ) {
-
-				face.__originalFaceNormal = face.normal.clone();
-
-			} else {
-
-				face.__originalFaceNormal.copy( face.normal );
-
-			}
-
-			if ( ! face.__originalVertexNormals ) face.__originalVertexNormals = [];
-
-			for ( i = 0, il = face.vertexNormals.length; i < il; i ++ ) {
-
-				if ( ! face.__originalVertexNormals[ i ] ) {
-
-					face.__originalVertexNormals[ i ] = face.vertexNormals[ i ].clone();
-
-				} else {
-
-					face.__originalVertexNormals[ i ].copy( face.vertexNormals[ i ] );
-
-				}
-
-			}
-
-		}
-
-		// use temp geometry to compute face and vertex normals for each morph
-
-		var tmpGeo = new THREE.Geometry();
-		tmpGeo.faces = this.faces;
-
-		for ( i = 0, il = this.morphTargets.length; i < il; i ++ ) {
-
-			// create on first access
-
-			if ( ! this.morphNormals[ i ] ) {
-
-				this.morphNormals[ i ] = {};
-				this.morphNormals[ i ].faceNormals = [];
-				this.morphNormals[ i ].vertexNormals = [];
-
-				var dstNormalsFace = this.morphNormals[ i ].faceNormals;
-				var dstNormalsVertex = this.morphNormals[ i ].vertexNormals;
-
-				var faceNormal, vertexNormals;
-
-				for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
-
-					faceNormal = new THREE.Vector3();
-					vertexNormals = { a: new THREE.Vector3(), b: new THREE.Vector3(), c: new THREE.Vector3() };
-
-					dstNormalsFace.push( faceNormal );
-					dstNormalsVertex.push( vertexNormals );
-
-				}
-
-			}
-
-			var morphNormals = this.morphNormals[ i ];
-
-			// set vertices to morph target
-
-			tmpGeo.vertices = this.morphTargets[ i ].vertices;
-
-			// compute morph normals
-
-			tmpGeo.computeFaceNormals();
-			tmpGeo.computeVertexNormals();
-
-			// store morph normals
-
-			var faceNormal, vertexNormals;
-
-			for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
-
-				face = this.faces[ f ];
-
-				faceNormal = morphNormals.faceNormals[ f ];
-				vertexNormals = morphNormals.vertexNormals[ f ];
-
-				faceNormal.copy( face.normal );
-
-				vertexNormals.a.copy( face.vertexNormals[ 0 ] );
-				vertexNormals.b.copy( face.vertexNormals[ 1 ] );
-				vertexNormals.c.copy( face.vertexNormals[ 2 ] );
-
-			}
-
-		}
-
-		// restore original normals
-
-		for ( f = 0, fl = this.faces.length; f < fl; f ++ ) {
-
-			face = this.faces[ f ];
-
-			face.normal = face.__originalFaceNormal;
-			face.vertexNormals = face.__originalVertexNormals;
-
-		}
-
-	},
-
-	computeTangents: function () {
-
-		console.warn( 'THREE.Geometry: .computeTangents() has been removed.' );
-
-	},
-
-	computeLineDistances: function () {
-
-		var d = 0;
-		var vertices = this.vertices;
-
-		for ( var i = 0, il = vertices.length; i < il; i ++ ) {
-
-			if ( i > 0 ) {
-
-				d += vertices[ i ].distanceTo( vertices[ i - 1 ] );
-
-			}
-
-			this.lineDistances[ i ] = d;
-
-		}
-
-	},
-
-	computeBoundingBox: function () {
-
-		if ( this.boundingBox === null ) {
-
-			this.boundingBox = new THREE.Box3();
-
-		}
-
-		this.boundingBox.setFromPoints( this.vertices );
-
-	},
-
-	computeBoundingSphere: function () {
-
-		if ( this.boundingSphere === null ) {
-
-			this.boundingSphere = new THREE.Sphere();
-
-		}
-
-		this.boundingSphere.setFromPoints( this.vertices );
-
-	},
-
-	merge: function ( geometry, matrix, materialIndexOffset ) {
-
-		if ( geometry instanceof THREE.Geometry === false ) {
-
-			console.error( 'THREE.Geometry.merge(): geometry not an instance of THREE.Geometry.', geometry );
-			return;
-
-		}
-
-		var normalMatrix,
-		vertexOffset = this.vertices.length,
-		vertices1 = this.vertices,
-		vertices2 = geometry.vertices,
-		faces1 = this.faces,
-		faces2 = geometry.faces,
-		uvs1 = this.faceVertexUvs[ 0 ],
-		uvs2 = geometry.faceVertexUvs[ 0 ];
-
-		if ( materialIndexOffset === undefined ) materialIndexOffset = 0;
-
-		if ( matrix !== undefined ) {
-
-			normalMatrix = new THREE.Matrix3().getNormalMatrix( matrix );
-
-		}
-
-		// vertices
-
-		for ( var i = 0, il = vertices2.length; i < il; i ++ ) {
-
-			var vertex = vertices2[ i ];
-
-			var vertexCopy = vertex.clone();
-
-			if ( matrix !== undefined ) vertexCopy.applyMatrix4( matrix );
-
-			vertices1.push( vertexCopy );
-
-		}
-
-		// faces
-
-		for ( i = 0, il = faces2.length; i < il; i ++ ) {
-
-			var face = faces2[ i ], faceCopy, normal, color,
-			faceVertexNormals = face.vertexNormals,
-			faceVertexColors = face.vertexColors;
-
-			faceCopy = new THREE.Face3( face.a + vertexOffset, face.b + vertexOffset, face.c + vertexOffset );
-			faceCopy.normal.copy( face.normal );
-
-			if ( normalMatrix !== undefined ) {
-
-				faceCopy.normal.applyMatrix3( normalMatrix ).normalize();
-
-			}
-
-			for ( var j = 0, jl = faceVertexNormals.length; j < jl; j ++ ) {
-
-				normal = faceVertexNormals[ j ].clone();
-
-				if ( normalMatrix !== undefined ) {
-
-					normal.applyMatrix3( normalMatrix ).normalize();
-
-				}
-
-				faceCopy.vertexNormals.push( normal );
-
-			}
-
-			faceCopy.color.copy( face.color );
-
-			for ( var j = 0, jl = faceVertexColors.length; j < jl; j ++ ) {
-
-				color = faceVertexColors[ j ];
-				faceCopy.vertexColors.push( color.clone() );
-
-			}
-
-			faceCopy.materialIndex = face.materialIndex + materialIndexOffset;
-
-			faces1.push( faceCopy );
-
-		}
-
-		// uvs
-
-		for ( i = 0, il = uvs2.length; i < il; i ++ ) {
-
-			var uv = uvs2[ i ], uvCopy = [];
-
-			if ( uv === undefined ) {
-
-				continue;
-
-			}
-
-			for ( var j = 0, jl = uv.length; j < jl; j ++ ) {
-
-				uvCopy.push( uv[ j ].clone() );
-
-			}
-
-			uvs1.push( uvCopy );
-
-		}
-
-	},
-
-	mergeMesh: function ( mesh ) {
-
-		if ( mesh instanceof THREE.Mesh === false ) {
-
-			console.error( 'THREE.Geometry.mergeMesh(): mesh not an instance of THREE.Mesh.', mesh );
-			return;
-
-		}
-
-		mesh.matrixAutoUpdate && mesh.updateMatrix();
-
-		this.merge( mesh.geometry, mesh.matrix );
-
-	},
-
-	/*
-	 * Checks for duplicate vertices with hashmap.
-	 * Duplicated vertices are removed
-	 * and faces' vertices are updated.
-	 */
-
-	mergeVertices: function () {
-
-		var verticesMap = {}; // Hashmap for looking up vertices by position coordinates (and making sure they are unique)
-		var unique = [], changes = [];
-
-		var v, key;
-		var precisionPoints = 4; // number of decimal points, e.g. 4 for epsilon of 0.0001
-		var precision = Math.pow( 10, precisionPoints );
-		var i, il, face;
-		var indices, j, jl;
-
-		for ( i = 0, il = this.vertices.length; i < il; i ++ ) {
-
-			v = this.vertices[ i ];
-			key = Math.round( v.x * precision ) + '_' + Math.round( v.y * precision ) + '_' + Math.round( v.z * precision );
-
-			if ( verticesMap[ key ] === undefined ) {
-
-				verticesMap[ key ] = i;
-				unique.push( this.vertices[ i ] );
-				changes[ i ] = unique.length - 1;
-
-			} else {
-
-				//console.log('Duplicate vertex found. ', i, ' could be using ', verticesMap[key]);
-				changes[ i ] = changes[ verticesMap[ key ] ];
-
-			}
-
-		}
-
-
-		// if faces are completely degenerate after merging vertices, we
-		// have to remove them from the geometry.
-		var faceIndicesToRemove = [];
-
-		for ( i = 0, il = this.faces.length; i < il; i ++ ) {
-
-			face = this.faces[ i ];
-
-			face.a = changes[ face.a ];
-			face.b = changes[ face.b ];
-			face.c = changes[ face.c ];
-
-			indices = [ face.a, face.b, face.c ];
-
-			var dupIndex = - 1;
-
-			// if any duplicate vertices are found in a Face3
-			// we have to remove the face as nothing can be saved
-			for ( var n = 0; n < 3; n ++ ) {
-
-				if ( indices[ n ] === indices[ ( n + 1 ) % 3 ] ) {
-
-					dupIndex = n;
-					faceIndicesToRemove.push( i );
-					break;
-
-				}
-
-			}
-
-		}
-
-		for ( i = faceIndicesToRemove.length - 1; i >= 0; i -- ) {
-
-			var idx = faceIndicesToRemove[ i ];
-
-			this.faces.splice( idx, 1 );
-
-			for ( j = 0, jl = this.faceVertexUvs.length; j < jl; j ++ ) {
-
-				this.faceVertexUvs[ j ].splice( idx, 1 );
-
-			}
-
-		}
-
-		// Use unique set of vertices
-
-		var diff = this.vertices.length - unique.length;
-		this.vertices = unique;
-		return diff;
-
-	},
-
-	sortFacesByMaterialIndex: function () {
-
-		var faces = this.faces;
-		var length = faces.length;
-
-		// tag faces
-
-		for ( var i = 0; i < length; i ++ ) {
-
-			faces[ i ]._id = i;
-
-		}
-
-		// sort faces
-
-		function materialIndexSort( a, b ) {
-
-			return a.materialIndex - b.materialIndex;
-
-		}
-
-		faces.sort( materialIndexSort );
-
-		// sort uvs
-
-		var uvs1 = this.faceVertexUvs[ 0 ];
-		var uvs2 = this.faceVertexUvs[ 1 ];
-
-		var newUvs1, newUvs2;
-
-		if ( uvs1 && uvs1.length === length ) newUvs1 = [];
-		if ( uvs2 && uvs2.length === length ) newUvs2 = [];
-
-		for ( var i = 0; i < length; i ++ ) {
-
-			var id = faces[ i ]._id;
-
-			if ( newUvs1 ) newUvs1.push( uvs1[ id ] );
-			if ( newUvs2 ) newUvs2.push( uvs2[ id ] );
-
-		}
-
-		if ( newUvs1 ) this.faceVertexUvs[ 0 ] = newUvs1;
-		if ( newUvs2 ) this.faceVertexUvs[ 1 ] = newUvs2;
-
-	},
-
-	toJSON: function () {
-
-		var data = {
-			metadata: {
-				version: 4.4,
-				type: 'Geometry',
-				generator: 'Geometry.toJSON'
-			}
-		};
-
-		// standard Geometry serialization
-
-		data.uuid = this.uuid;
-		data.type = this.type;
-		if ( this.name !== '' ) data.name = this.name;
-
-		if ( this.parameters !== undefined ) {
-
-			var parameters = this.parameters;
-
-			for ( var key in parameters ) {
-
-				if ( parameters[ key ] !== undefined ) data[ key ] = parameters[ key ];
-
-			}
-
-			return data;
-
-		}
-
-		var vertices = [];
-
-		for ( var i = 0; i < this.vertices.length; i ++ ) {
-
-			var vertex = this.vertices[ i ];
-			vertices.push( vertex.x, vertex.y, vertex.z );
-
-		}
-
-		var faces = [];
-		var normals = [];
-		var normalsHash = {};
-		var colors = [];
-		var colorsHash = {};
-		var uvs = [];
-		var uvsHash = {};
-
-		for ( var i = 0; i < this.faces.length; i ++ ) {
-
-			var face = this.faces[ i ];
-
-			var hasMaterial = true;
-			var hasFaceUv = false; // deprecated
-			var hasFaceVertexUv = this.faceVertexUvs[ 0 ][ i ] !== undefined;
-			var hasFaceNormal = face.normal.length() > 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 << position ) : value & ( ~ ( 1 << position ) );
-
-		}
-
-		function getNormalIndex( normal ) {
-
-			var hash = normal.x.toString() + normal.y.toString() + normal.z.toString();
-
-			if ( normalsHash[ hash ] !== undefined ) {
-
-				return normalsHash[ hash ];
-
-			}
-
-			normalsHash[ hash ] = normals.length / 3;
-			normals.push( normal.x, normal.y, normal.z );
-
-			return normalsHash[ hash ];
-
-		}
-
-		function getColorIndex( color ) {
-
-			var hash = color.r.toString() + color.g.toString() + color.b.toString();
-
-			if ( colorsHash[ hash ] !== undefined ) {
-
-				return colorsHash[ hash ];
-
-			}
-
-			colorsHash[ hash ] = colors.length;
-			colors.push( color.getHex() );
-
-			return colorsHash[ hash ];
-
-		}
-
-		function getUvIndex( uv ) {
-
-			var hash = uv.x.toString() + uv.y.toString();
-
-			if ( uvsHash[ hash ] !== undefined ) {
-
-				return uvsHash[ hash ];
-
-			}
-
-			uvsHash[ hash ] = uvs.length / 2;
-			uvs.push( uv.x, uv.y );
-
-			return uvsHash[ hash ];
-
-		}
-
-		data.data = {};
-
-		data.data.vertices = vertices;
-		data.data.normals = normals;
-		if ( colors.length > 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 THREE.Geometry().copy( this );
-
-	},
-
-	copy: function ( source ) {
-
-		this.vertices = [];
-		this.faces = [];
-		this.faceVertexUvs = [ [] ];
-
-		var vertices = source.vertices;
-
-		for ( var i = 0, il = vertices.length; i < il; i ++ ) {
-
-			this.vertices.push( vertices[ i ].clone() );
-
-		}
-
-		var faces = source.faces;
-
-		for ( var i = 0, il = faces.length; i < il; i ++ ) {
-
-			this.faces.push( faces[ i ].clone() );
-
-		}
-
-		for ( var i = 0, il = source.faceVertexUvs.length; i < il; i ++ ) {
-
-			var faceVertexUvs = source.faceVertexUvs[ i ];
-
-			if ( this.faceVertexUvs[ i ] === undefined ) {
-
-				this.faceVertexUvs[ i ] = [];
-
-			}
-
-			for ( var j = 0, jl = faceVertexUvs.length; j < jl; j ++ ) {
-
-				var uvs = faceVertexUvs[ j ], uvsCopy = [];
-
-				for ( var k = 0, kl = uvs.length; k < kl; k ++ ) {
-
-					var uv = uvs[ k ];
-
-					uvsCopy.push( uv.clone() );
-
-				}
-
-				this.faceVertexUvs[ i ].push( uvsCopy );
-
-			}
-
-		}
-
-		return this;
-
-	},
-
-	dispose: function () {
-
-		this.dispatchEvent( { type: 'dispose' } );
-
-	}
-
-};
-
-THREE.EventDispatcher.prototype.apply( THREE.Geometry.prototype );
-
-THREE.GeometryIdCount = 0;
-
-// File:src/core/DirectGeometry.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.DirectGeometry = function () {
-
-	Object.defineProperty( this, 'id', { value: THREE.GeometryIdCount ++ } );
-
-	this.uuid = THREE.Math.generateUUID();
-
-	this.name = '';
-	this.type = 'DirectGeometry';
-
-	this.indices = [];
-	this.vertices = [];
-	this.normals = [];
-	this.colors = [];
-	this.uvs = [];
-	this.uvs2 = [];
-
-	this.groups = [];
-
-	this.morphTargets = {};
-
-	this.skinWeights = [];
-	this.skinIndices = [];
-
-	// this.lineDistances = [];
-
-	this.boundingBox = null;
-	this.boundingSphere = null;
-
-	// update flags
-
-	this.verticesNeedUpdate = false;
-	this.normalsNeedUpdate = false;
-	this.colorsNeedUpdate = false;
-	this.uvsNeedUpdate = false;
-	this.groupsNeedUpdate = false;
-
-};
-
-THREE.DirectGeometry.prototype = {
-
-	constructor: THREE.DirectGeometry,
-
-	computeBoundingBox: THREE.Geometry.prototype.computeBoundingBox,
-	computeBoundingSphere: THREE.Geometry.prototype.computeBoundingSphere,
-
-	computeFaceNormals: function () {
-
-		console.warn( 'THREE.DirectGeometry: computeFaceNormals() is not a method of this type of geometry.' );
-
-	},
-
-	computeVertexNormals: function () {
-
-		console.warn( 'THREE.DirectGeometry: computeVertexNormals() is not a method of this type of geometry.' );
-
-	},
-
-	computeGroups: function ( geometry ) {
-
-		var group;
-		var groups = [];
-		var materialIndex;
-
-		var faces = geometry.faces;
-
-		for ( var i = 0; i < faces.length; i ++ ) {
-
-			var face = faces[ i ];
-
-			// materials
-
-			if ( face.materialIndex !== materialIndex ) {
-
-				materialIndex = face.materialIndex;
-
-				if ( group !== undefined ) {
-
-					group.count = ( i * 3 ) - group.start;
-					groups.push( group );
-
-				}
-
-				group = {
-					start: i * 3,
-					materialIndex: materialIndex
-				};
-
-			}
-
-		}
-
-		if ( group !== undefined ) {
-
-			group.count = ( i * 3 ) - group.start;
-			groups.push( group );
-
-		}
-
-		this.groups = groups;
-
-	},
-
-	fromGeometry: function ( geometry ) {
-
-		var faces = geometry.faces;
-		var vertices = geometry.vertices;
-		var faceVertexUvs = geometry.faceVertexUvs;
-
-		var hasFaceVertexUv = faceVertexUvs[ 0 ] && faceVertexUvs[ 0 ].length > 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 < morphTargetsLength; i ++ ) {
-
-				morphTargetsPosition[ i ] = [];
-
-			}
-
-			this.morphTargets.position = morphTargetsPosition;
-
-		}
-
-		var morphNormals = geometry.morphNormals;
-		var morphNormalsLength = morphNormals.length;
-
-		var morphTargetsNormal;
-
-		if ( morphNormalsLength > 0 ) {
-
-			morphTargetsNormal = [];
-
-			for ( var i = 0; i < morphNormalsLength; i ++ ) {
-
-				morphTargetsNormal[ i ] = [];
-
-			}
-
-			this.morphTargets.normal = morphTargetsNormal;
-
-		}
-
-		// skins
-
-		var skinIndices = geometry.skinIndices;
-		var skinWeights = geometry.skinWeights;
-
-		var hasSkinIndices = skinIndices.length === vertices.length;
-		var hasSkinWeights = skinWeights.length === vertices.length;
-
-		//
-
-		for ( var i = 0; i < faces.length; i ++ ) {
-
-			var face = faces[ i ];
-
-			this.vertices.push( vertices[ face.a ], vertices[ face.b ], vertices[ face.c ] );
-
-			var vertexNormals = face.vertexNormals;
-
-			if ( vertexNormals.length === 3 ) {
-
-				this.normals.push( vertexNormals[ 0 ], vertexNormals[ 1 ], vertexNormals[ 2 ] );
-
-			} else {
-
-				var normal = face.normal;
-
-				this.normals.push( normal, normal, normal );
-
-			}
-
-			var vertexColors = face.vertexColors;
-
-			if ( vertexColors.length === 3 ) {
-
-				this.colors.push( vertexColors[ 0 ], vertexColors[ 1 ], vertexColors[ 2 ] );
-
-			} else {
-
-				var color = face.color;
-
-				this.colors.push( color, color, color );
-
-			}
-
-			if ( hasFaceVertexUv === true ) {
-
-				var vertexUvs = faceVertexUvs[ 0 ][ i ];
-
-				if ( vertexUvs !== undefined ) {
-
-					this.uvs.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] );
-
-				} else {
-
-					console.warn( 'THREE.DirectGeometry.fromGeometry(): Undefined vertexUv ', i );
-
-					this.uvs.push( new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2() );
-
-				}
-
-			}
-
-			if ( hasFaceVertexUv2 === true ) {
-
-				var vertexUvs = faceVertexUvs[ 1 ][ i ];
-
-				if ( vertexUvs !== undefined ) {
-
-					this.uvs2.push( vertexUvs[ 0 ], vertexUvs[ 1 ], vertexUvs[ 2 ] );
-
-				} else {
-
-					console.warn( 'THREE.DirectGeometry.fromGeometry(): Undefined vertexUv2 ', i );
-
-					this.uvs2.push( new THREE.Vector2(), new THREE.Vector2(), new THREE.Vector2() );
-
-				}
-
-			}
-
-			// morphs
-
-			for ( var j = 0; j < morphTargetsLength; j ++ ) {
-
-				var morphTarget = morphTargets[ j ].vertices;
-
-				morphTargetsPosition[ j ].push( morphTarget[ face.a ], morphTarget[ face.b ], morphTarget[ face.c ] );
-
-			}
-
-			for ( var j = 0; j < morphNormalsLength; j ++ ) {
-
-				var morphNormal = morphNormals[ j ].vertexNormals[ i ];
-
-				morphTargetsNormal[ j ].push( morphNormal.a, morphNormal.b, morphNormal.c );
-
-			}
-
-			// skins
-
-			if ( hasSkinIndices ) {
-
-				this.skinIndices.push( skinIndices[ face.a ], skinIndices[ face.b ], skinIndices[ face.c ] );
-
-			}
-
-			if ( hasSkinWeights ) {
-
-				this.skinWeights.push( skinWeights[ face.a ], skinWeights[ face.b ], skinWeights[ face.c ] );
-
-			}
-
-		}
-
-		this.computeGroups( geometry );
-
-		this.verticesNeedUpdate = geometry.verticesNeedUpdate;
-		this.normalsNeedUpdate = geometry.normalsNeedUpdate;
-		this.colorsNeedUpdate = geometry.colorsNeedUpdate;
-		this.uvsNeedUpdate = geometry.uvsNeedUpdate;
-		this.groupsNeedUpdate = geometry.groupsNeedUpdate;
-
-		return this;
-
-	},
-
-	dispose: function () {
-
-		this.dispatchEvent( { type: 'dispose' } );
-
-	}
-
-};
-
-THREE.EventDispatcher.prototype.apply( THREE.DirectGeometry.prototype );
-
-// File:src/core/BufferGeometry.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.BufferGeometry = function () {
-
-	Object.defineProperty( this, 'id', { value: THREE.GeometryIdCount ++ } );
-
-	this.uuid = THREE.Math.generateUUID();
-
-	this.name = '';
-	this.type = 'BufferGeometry';
-
-	this.index = null;
-	this.attributes = {};
-
-	this.morphAttributes = {};
-
-	this.groups = [];
-
-	this.boundingBox = null;
-	this.boundingSphere = null;
-
-	this.drawRange = { start: 0, count: Infinity };
-
-};
-
-THREE.BufferGeometry.prototype = {
-
-	constructor: THREE.BufferGeometry,
-
-	getIndex: function () {
-
-		return this.index;
-
-	},
-
-	setIndex: function ( index ) {
-
-		this.index = index;
-
-	},
-
-	addAttribute: function ( name, attribute ) {
-
-		if ( attribute instanceof THREE.BufferAttribute === false && attribute instanceof THREE.InterleavedBufferAttribute === false ) {
-
-			console.warn( 'THREE.BufferGeometry: .addAttribute() now expects ( name, attribute ).' );
-
-			this.addAttribute( name, new THREE.BufferAttribute( arguments[ 1 ], arguments[ 2 ] ) );
-
-			return;
-
-		}
-
-		if ( name === 'index' ) {
-
-			console.warn( 'THREE.BufferGeometry.addAttribute: Use .setIndex() for index attribute.' );
-			this.setIndex( attribute );
-
-			return;
-
-		}
-
-		this.attributes[ name ] = attribute;
-
-		return this;
-
-	},
-
-	getAttribute: function ( name ) {
-
-		return this.attributes[ name ];
-
-	},
-
-	removeAttribute: 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;
-
-	},
-
-	applyMatrix: function ( matrix ) {
-
-		var position = this.attributes.position;
-
-		if ( position !== undefined ) {
-
-			matrix.applyToVector3Array( position.array );
-			position.needsUpdate = true;
-
-		}
-
-		var normal = this.attributes.normal;
-
-		if ( normal !== undefined ) {
-
-			var normalMatrix = new THREE.Matrix3().getNormalMatrix( matrix );
-
-			normalMatrix.applyToVector3Array( normal.array );
-			normal.needsUpdate = true;
-
-		}
-
-		if ( this.boundingBox !== null ) {
-
-			this.computeBoundingBox();
-
-		}
-
-		if ( this.boundingSphere !== null ) {
-
-			this.computeBoundingSphere();
-
-		}
-
-		return this;
-
-	},
-
-	rotateX: function () {
-
-		// rotate geometry around world x-axis
-
-		var m1;
-
-		return function rotateX( angle ) {
-
-			if ( m1 === undefined ) m1 = new THREE.Matrix4();
-
-			m1.makeRotationX( angle );
-
-			this.applyMatrix( m1 );
-
-			return this;
-
-		};
-
-	}(),
-
-	rotateY: function () {
-
-		// rotate geometry around world y-axis
-
-		var m1;
-
-		return function rotateY( angle ) {
-
-			if ( m1 === undefined ) m1 = new THREE.Matrix4();
-
-			m1.makeRotationY( angle );
-
-			this.applyMatrix( m1 );
-
-			return this;
-
-		};
-
-	}(),
-
-	rotateZ: function () {
-
-		// rotate geometry around world z-axis
-
-		var m1;
-
-		return function rotateZ( angle ) {
-
-			if ( m1 === undefined ) m1 = new THREE.Matrix4();
-
-			m1.makeRotationZ( angle );
-
-			this.applyMatrix( m1 );
-
-			return this;
-
-		};
-
-	}(),
-
-	translate: function () {
-
-		// translate geometry
-
-		var m1;
-
-		return function translate( x, y, z ) {
-
-			if ( m1 === undefined ) m1 = new THREE.Matrix4();
-
-			m1.makeTranslation( x, y, z );
-
-			this.applyMatrix( m1 );
-
-			return this;
-
-		};
-
-	}(),
-
-	scale: function () {
-
-		// scale geometry
-
-		var m1;
-
-		return function scale( x, y, z ) {
-
-			if ( m1 === undefined ) m1 = new THREE.Matrix4();
-
-			m1.makeScale( x, y, z );
-
-			this.applyMatrix( m1 );
-
-			return this;
-
-		};
-
-	}(),
-
-	lookAt: function () {
-
-		var obj;
-
-		return function lookAt( vector ) {
-
-			if ( obj === undefined ) obj = new THREE.Object3D();
-
-			obj.lookAt( vector );
-
-			obj.updateMatrix();
-
-			this.applyMatrix( obj.matrix );
-
-		};
-
-	}(),
-
-	center: function () {
-
-		this.computeBoundingBox();
-
-		var offset = this.boundingBox.center().negate();
-
-		this.translate( offset.x, offset.y, offset.z );
-
-		return offset;
-
-	},
-
-	setFromObject: function ( object ) {
-
-		// console.log( 'THREE.BufferGeometry.setFromObject(). Converting', object, this );
-
-		var geometry = object.geometry;
-
-		if ( object instanceof THREE.Points || object instanceof THREE.Line ) {
-
-			var positions = new THREE.Float32Attribute( geometry.vertices.length * 3, 3 );
-			var colors = new THREE.Float32Attribute( geometry.colors.length * 3, 3 );
-
-			this.addAttribute( 'position', positions.copyVector3sArray( geometry.vertices ) );
-			this.addAttribute( 'color', colors.copyColorsArray( geometry.colors ) );
-
-			if ( geometry.lineDistances && geometry.lineDistances.length === geometry.vertices.length ) {
-
-				var lineDistances = new THREE.Float32Attribute( geometry.lineDistances.length, 1 );
-
-				this.addAttribute( '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 instanceof THREE.Mesh ) {
-
-			if ( geometry instanceof THREE.Geometry ) {
-
-				this.fromGeometry( geometry );
-
-			}
-
-		}
-
-		return this;
-
-	},
-
-	updateFromObject: function ( object ) {
-
-		var geometry = object.geometry;
-
-		if ( object instanceof THREE.Mesh ) {
-
-			var direct = geometry.__directGeometry;
-
-			if ( direct === undefined ) {
-
-				return this.fromGeometry( geometry );
-
-			}
-
-			direct.verticesNeedUpdate = geometry.verticesNeedUpdate;
-			direct.normalsNeedUpdate = geometry.normalsNeedUpdate;
-			direct.colorsNeedUpdate = geometry.colorsNeedUpdate;
-			direct.uvsNeedUpdate = geometry.uvsNeedUpdate;
-			direct.groupsNeedUpdate = geometry.groupsNeedUpdate;
-
-			geometry.verticesNeedUpdate = false;
-			geometry.normalsNeedUpdate = false;
-			geometry.colorsNeedUpdate = false;
-			geometry.uvsNeedUpdate = false;
-			geometry.groupsNeedUpdate = false;
-
-			geometry = direct;
-
-		}
-
-		if ( geometry.verticesNeedUpdate === true ) {
-
-			var attribute = this.attributes.position;
-
-			if ( attribute !== undefined ) {
-
-				attribute.copyVector3sArray( geometry.vertices );
-				attribute.needsUpdate = true;
-
-			}
-
-			geometry.verticesNeedUpdate = false;
-
-		}
-
-		if ( geometry.normalsNeedUpdate === true ) {
-
-			var attribute = this.attributes.normal;
-
-			if ( attribute !== undefined ) {
-
-				attribute.copyVector3sArray( geometry.normals );
-				attribute.needsUpdate = true;
-
-			}
-
-			geometry.normalsNeedUpdate = false;
-
-		}
-
-		if ( geometry.colorsNeedUpdate === true ) {
-
-			var attribute = this.attributes.color;
-
-			if ( attribute !== undefined ) {
-
-				attribute.copyColorsArray( geometry.colors );
-				attribute.needsUpdate = true;
-
-			}
-
-			geometry.colorsNeedUpdate = false;
-
-		}
-
-		if ( geometry.uvsNeedUpdate ) {
-
-			var attribute = this.attributes.uv;
-
-			if ( attribute !== undefined ) {
-
-				attribute.copyVector2sArray( geometry.uvs );
-				attribute.needsUpdate = true;
-
-			}
-
-			geometry.uvsNeedUpdate = false;
-
-		}
-
-		if ( geometry.lineDistancesNeedUpdate ) {
-
-			var attribute = this.attributes.lineDistance;
-
-			if ( attribute !== undefined ) {
-
-				attribute.copyArray( geometry.lineDistances );
-				attribute.needsUpdate = true;
-
-			}
-
-			geometry.lineDistancesNeedUpdate = false;
-
-		}
-
-		if ( geometry.groupsNeedUpdate ) {
-
-			geometry.computeGroups( object.geometry );
-			this.groups = geometry.groups;
-
-			geometry.groupsNeedUpdate = false;
-
-		}
-
-		return this;
-
-	},
-
-	fromGeometry: function ( geometry ) {
-
-		geometry.__directGeometry = new THREE.DirectGeometry().fromGeometry( geometry );
-
-		return this.fromDirectGeometry( geometry.__directGeometry );
-
-	},
-
-	fromDirectGeometry: function ( geometry ) {
-
-		var positions = new Float32Array( geometry.vertices.length * 3 );
-		this.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ).copyVector3sArray( geometry.vertices ) );
-
-		if ( geometry.normals.length > 0 ) {
-
-			var normals = new Float32Array( geometry.normals.length * 3 );
-			this.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ).copyVector3sArray( geometry.normals ) );
-
-		}
-
-		if ( geometry.colors.length > 0 ) {
-
-			var colors = new Float32Array( geometry.colors.length * 3 );
-			this.addAttribute( 'color', new THREE.BufferAttribute( colors, 3 ).copyColorsArray( geometry.colors ) );
-
-		}
-
-		if ( geometry.uvs.length > 0 ) {
-
-			var uvs = new Float32Array( geometry.uvs.length * 2 );
-			this.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ).copyVector2sArray( geometry.uvs ) );
-
-		}
-
-		if ( geometry.uvs2.length > 0 ) {
-
-			var uvs2 = new Float32Array( geometry.uvs2.length * 2 );
-			this.addAttribute( 'uv2', new THREE.BufferAttribute( uvs2, 2 ).copyVector2sArray( geometry.uvs2 ) );
-
-		}
-
-		if ( geometry.indices.length > 0 ) {
-
-			var TypeArray = geometry.vertices.length > 65535 ? Uint32Array : Uint16Array;
-			var indices = new TypeArray( geometry.indices.length * 3 );
-			this.setIndex( new THREE.BufferAttribute( indices, 1 ).copyIndicesArray( geometry.indices ) );
-
-		}
-
-		// 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 < l; i ++ ) {
-
-				var morphTarget = morphTargets[ i ];
-
-				var attribute = new THREE.Float32Attribute( morphTarget.length * 3, 3 );
-
-				array.push( attribute.copyVector3sArray( morphTarget ) );
-
-			}
-
-			this.morphAttributes[ name ] = array;
-
-		}
-
-		// skinning
-
-		if ( geometry.skinIndices.length > 0 ) {
-
-			var skinIndices = new THREE.Float32Attribute( geometry.skinIndices.length * 4, 4 );
-			this.addAttribute( 'skinIndex', skinIndices.copyVector4sArray( geometry.skinIndices ) );
-
-		}
-
-		if ( geometry.skinWeights.length > 0 ) {
-
-			var skinWeights = new THREE.Float32Attribute( geometry.skinWeights.length * 4, 4 );
-			this.addAttribute( '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 THREE.Box3();
-
-		}
-
-		var positions = this.attributes.position.array;
-
-		if ( positions !== undefined ) {
-
-			this.boundingBox.setFromArray( positions );
-
-		} else {
-
-			this.boundingBox.makeEmpty();
-
-		}
-
-		if ( isNaN( this.boundingBox.min.x ) || isNaN( this.boundingBox.min.y ) || isNaN( this.boundingBox.min.z ) ) {
-
-			console.error( 'THREE.BufferGeometry.computeBoundingBox: Computed min/max have NaN values. The "position" attribute is likely to have NaN values.', this );
-
-		}
-
-	},
-
-	computeBoundingSphere: function () {
-
-		var box = new THREE.Box3();
-		var vector = new THREE.Vector3();
-
-		return function () {
-
-			if ( this.boundingSphere === null ) {
-
-				this.boundingSphere = new THREE.Sphere();
-
-			}
-
-			var positions = this.attributes.position.array;
-
-			if ( positions ) {
-
-				var center = this.boundingSphere.center;
-
-				box.setFromArray( positions );
-				box.center( center );
-
-				// hoping to find a boundingSphere with a radius smaller than the
-				// boundingSphere of the boundingBox: sqrt(3) smaller in the best case
-
-				var maxRadiusSq = 0;
-
-				for ( var i = 0, il = positions.length; i < il; i += 3 ) {
-
-					vector.fromArray( positions, i );
-					maxRadiusSq = Math.max( maxRadiusSq, center.distanceToSquared( vector ) );
-
-				}
-
-				this.boundingSphere.radius = Math.sqrt( maxRadiusSq );
-
-				if ( isNaN( this.boundingSphere.radius ) ) {
-
-					console.error( 'THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.', this );
-
-				}
-
-			}
-
-		};
-
-	}(),
-
-	computeFaceNormals: function () {
-
-		// backwards compatibility
-
-	},
-
-	computeVertexNormals: function () {
-
-		var index = this.index;
-		var attributes = this.attributes;
-		var groups = this.groups;
-
-		if ( attributes.position ) {
-
-			var positions = attributes.position.array;
-
-			if ( attributes.normal === undefined ) {
-
-				this.addAttribute( 'normal', new THREE.BufferAttribute( new Float32Array( positions.length ), 3 ) );
-
-			} else {
-
-				// reset existing normals to zero
-
-				var array = attributes.normal.array;
-
-				for ( var i = 0, il = array.length; i < il; i ++ ) {
-
-					array[ i ] = 0;
-
-				}
-
-			}
-
-			var normals = attributes.normal.array;
-
-			var vA, vB, vC,
-
-			pA = new THREE.Vector3(),
-			pB = new THREE.Vector3(),
-			pC = new THREE.Vector3(),
-
-			cb = new THREE.Vector3(),
-			ab = new THREE.Vector3();
-
-			// indexed elements
-
-			if ( index ) {
-
-				var indices = index.array;
-
-				if ( groups.length === 0 ) {
-
-					this.addGroup( 0, indices.length );
-
-				}
-
-				for ( var j = 0, jl = groups.length; j < jl; ++ j ) {
-
-					var group = groups[ j ];
-
-					var start = group.start;
-					var count = group.count;
-
-					for ( var i = start, il = start + count; i < il; i += 3 ) {
-
-						vA = indices[ i + 0 ] * 3;
-						vB = indices[ i + 1 ] * 3;
-						vC = indices[ i + 2 ] * 3;
-
-						pA.fromArray( positions, vA );
-						pB.fromArray( positions, vB );
-						pC.fromArray( positions, vC );
-
-						cb.subVectors( pC, pB );
-						ab.subVectors( pA, pB );
-						cb.cross( ab );
-
-						normals[ vA ] += cb.x;
-						normals[ vA + 1 ] += cb.y;
-						normals[ vA + 2 ] += cb.z;
-
-						normals[ vB ] += cb.x;
-						normals[ vB + 1 ] += cb.y;
-						normals[ vB + 2 ] += cb.z;
-
-						normals[ vC ] += cb.x;
-						normals[ vC + 1 ] += cb.y;
-						normals[ vC + 2 ] += cb.z;
-
-					}
-
-				}
-
-			} else {
-
-				// non-indexed elements (unconnected triangle soup)
-
-				for ( var i = 0, il = positions.length; i < il; i += 9 ) {
-
-					pA.fromArray( positions, i );
-					pB.fromArray( positions, i + 3 );
-					pC.fromArray( positions, i + 6 );
-
-					cb.subVectors( pC, pB );
-					ab.subVectors( pA, pB );
-					cb.cross( ab );
-
-					normals[ i ] = cb.x;
-					normals[ i + 1 ] = cb.y;
-					normals[ i + 2 ] = cb.z;
-
-					normals[ i + 3 ] = cb.x;
-					normals[ i + 4 ] = cb.y;
-					normals[ i + 5 ] = cb.z;
-
-					normals[ i + 6 ] = cb.x;
-					normals[ i + 7 ] = cb.y;
-					normals[ i + 8 ] = cb.z;
-
-				}
-
-			}
-
-			this.normalizeNormals();
-
-			attributes.normal.needsUpdate = true;
-
-		}
-
-	},
-
-	merge: function ( geometry, offset ) {
-
-		if ( geometry instanceof THREE.BufferGeometry === false ) {
-
-			console.error( 'THREE.BufferGeometry.merge(): geometry not an instance of THREE.BufferGeometry.', geometry );
-			return;
-
-		}
-
-		if ( offset === undefined ) offset = 0;
-
-		var attributes = this.attributes;
-
-		for ( var key in attributes ) {
-
-			if ( geometry.attributes[ key ] === undefined ) continue;
-
-			var attribute1 = attributes[ key ];
-			var attributeArray1 = attribute1.array;
-
-			var attribute2 = geometry.attributes[ key ];
-			var attributeArray2 = attribute2.array;
-
-			var attributeSize = attribute2.itemSize;
-
-			for ( var i = 0, j = attributeSize * offset; i < attributeArray2.length; i ++, j ++ ) {
-
-				attributeArray1[ j ] = attributeArray2[ i ];
-
-			}
-
-		}
-
-		return this;
-
-	},
-
-	normalizeNormals: function () {
-
-		var normals = this.attributes.normal.array;
-
-		var x, y, z, n;
-
-		for ( var i = 0, il = normals.length; i < il; i += 3 ) {
-
-			x = normals[ i ];
-			y = normals[ i + 1 ];
-			z = normals[ i + 2 ];
-
-			n = 1.0 / Math.sqrt( x * x + y * y + z * z );
-
-			normals[ i ] *= n;
-			normals[ i + 1 ] *= n;
-			normals[ i + 2 ] *= n;
-
-		}
-
-	},
-
-	toNonIndexed: function () {
-
-		if ( this.index === null ) {
-
-			console.warn( 'THREE.BufferGeometry.toNonIndexed(): Geometry is already non-indexed.' );
-			return this;
-
-		}
-
-		var geometry2 = new THREE.BufferGeometry();
-
-		var indices = this.index.array;
-		var attributes = this.attributes;
-
-		for ( var name in attributes ) {
-
-			var attribute = attributes[ name ];
-
-			var array = attribute.array;
-			var itemSize = attribute.itemSize;
-
-			var array2 = new array.constructor( indices.length * itemSize );
-
-			var index = 0, index2 = 0;
-
-			for ( var i = 0, l = indices.length; i < l; i ++ ) {
-
-				index = indices[ i ] * itemSize;
-
-				for ( var j = 0; j < itemSize; j ++ ) {
-
-					array2[ index2 ++ ] = array[ index ++ ];
-
-				}
-
-			}
-
-			geometry2.addAttribute( name, new THREE.BufferAttribute( array2, itemSize ) );
-
-		}
-
-		return geometry2;
-
-	},
-
-	toJSON: function () {
-
-		var data = {
-			metadata: {
-				version: 4.4,
-				type: 'BufferGeometry',
-				generator: 'BufferGeometry.toJSON'
-			}
-		};
-
-		// standard BufferGeometry serialization
-
-		data.uuid = this.uuid;
-		data.type = this.type;
-		if ( this.name !== '' ) data.name = this.name;
-
-		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 ) {
-
-			var array = Array.prototype.slice.call( index.array );
-
-			data.data.index = {
-				type: index.array.constructor.name,
-				array: array
-			};
-
-		}
-
-		var attributes = this.attributes;
-
-		for ( var key in attributes ) {
-
-			var attribute = attributes[ key ];
-
-			var array = Array.prototype.slice.call( attribute.array );
-
-			data.data.attributes[ key ] = {
-				itemSize: attribute.itemSize,
-				type: attribute.array.constructor.name,
-				array: array,
-				normalized: attribute.normalized
-			};
-
-		}
-
-		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 THREE.BufferGeometry().copy( this );
-
-	},
-
-	copy: function ( source ) {
-
-		var index = source.index;
-
-		if ( index !== null ) {
-
-			this.setIndex( index.clone() );
-
-		}
-
-		var attributes = source.attributes;
-
-		for ( var name in attributes ) {
-
-			var attribute = attributes[ name ];
-			this.addAttribute( name, attribute.clone() );
-
-		}
-
-		var groups = source.groups;
-
-		for ( var i = 0, l = groups.length; i < l; i ++ ) {
-
-			var group = groups[ i ];
-			this.addGroup( group.start, group.count, group.materialIndex );
-
-		}
-
-		return this;
-
-	},
-
-	dispose: function () {
-
-		this.dispatchEvent( { type: 'dispose' } );
-
-	}
-
-};
-
-THREE.EventDispatcher.prototype.apply( THREE.BufferGeometry.prototype );
-
-THREE.BufferGeometry.MaxIndex = 65535;
-
-// File:src/core/InstancedBufferGeometry.js
-
-/**
- * @author benaadams / https://twitter.com/ben_a_adams
- */
-
-THREE.InstancedBufferGeometry = function () {
-
-	THREE.BufferGeometry.call( this );
-
-	this.type = 'InstancedBufferGeometry';
-	this.maxInstancedCount = undefined;
-
-};
-
-THREE.InstancedBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
-THREE.InstancedBufferGeometry.prototype.constructor = THREE.InstancedBufferGeometry;
-
-THREE.InstancedBufferGeometry.prototype.addGroup = function ( start, count, instances ) {
-
-	this.groups.push( {
-
-		start: start,
-		count: count,
-		instances: instances
-
-	} );
-
-};
-
-THREE.InstancedBufferGeometry.prototype.copy = function ( source ) {
-
-	var index = source.index;
-
-	if ( index !== null ) {
-
-		this.setIndex( index.clone() );
-
-	}
-
-	var attributes = source.attributes;
-
-	for ( var name in attributes ) {
-
-		var attribute = attributes[ name ];
-		this.addAttribute( name, attribute.clone() );
-
-	}
-
-	var groups = source.groups;
-
-	for ( var i = 0, l = groups.length; i < l; i ++ ) {
-
-		var group = groups[ i ];
-		this.addGroup( group.start, group.count, group.instances );
-
-	}
-
-	return this;
-
-};
-
-THREE.EventDispatcher.prototype.apply( THREE.InstancedBufferGeometry.prototype );
-
-// File:src/core/Uniform.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.Uniform = function ( value ) {
-
-	if ( typeof value === 'string' ) {
-
-		console.warn( 'THREE.Uniform: Type parameter is no longer needed.' );
-		value = arguments[ 1 ];
-
-	}
-
-	this.value = value;
-
-	this.dynamic = false;
-
-};
-
-THREE.Uniform.prototype = {
-
-	constructor: THREE.Uniform,
-
-	onUpdate: function ( callback ) {
-
-		this.dynamic = true;
-		this.onUpdateCallback = callback;
-
-		return this;
-
-	}
-
-};
-
-// File:src/animation/AnimationClip.js
-
-/**
- *
- * Reusable set of Tracks that represent an animation.
- *
- * @author Ben Houston / http://clara.io/
- * @author David Sarno / http://lighthaus.us/
- */
-
-THREE.AnimationClip = function ( name, duration, tracks ) {
-
-	this.name = name || THREE.Math.generateUUID();
-	this.tracks = tracks;
-	this.duration = ( duration !== undefined ) ? duration : -1;
-
-	// this means it should figure out its duration by scanning the tracks
-	if ( this.duration < 0 ) {
-
-		this.resetDuration();
-
-	}
-
-	// maybe only do these on demand, as doing them here could potentially slow down loading
-	// but leaving these here during development as this ensures a lot of testing of these functions
-	this.trim();
-	this.optimize();
-
-};
-
-THREE.AnimationClip.prototype = {
-
-	constructor: THREE.AnimationClip,
-
-	resetDuration: function() {
-
-		var tracks = this.tracks,
-			duration = 0;
-
-		for ( var i = 0, n = tracks.length; i !== n; ++ i ) {
-
-			var track = this.tracks[ i ];
-
-			duration = Math.max(
-					duration, track.times[ track.times.length - 1 ] );
-
-		}
-
-		this.duration = duration;
-
-	},
-
-	trim: function() {
-
-		for ( var i = 0; i < this.tracks.length; i ++ ) {
-
-			this.tracks[ i ].trim( 0, this.duration );
-
-		}
-
-		return this;
-
-	},
-
-	optimize: function() {
-
-		for ( var i = 0; i < this.tracks.length; i ++ ) {
-
-			this.tracks[ i ].optimize();
-
-		}
-
-		return this;
-
-	}
-
-};
-
-// Static methods:
-
-Object.assign( THREE.AnimationClip, {
-
-	parse: function( json ) {
-
-		var tracks = [],
-			jsonTracks = json.tracks,
-			frameTime = 1.0 / ( json.fps || 1.0 );
-
-		for ( var i = 0, n = jsonTracks.length; i !== n; ++ i ) {
-
-			tracks.push( THREE.KeyframeTrack.parse( jsonTracks[ i ] ).scale( frameTime ) );
-
-		}
-
-		return new THREE.AnimationClip( json.name, json.duration, tracks );
-
-	},
-
-
-	toJSON: function( clip ) {
-
-		var tracks = [],
-			clipTracks = clip.tracks;
-
-		var json = {
-
-			'name': clip.name,
-			'duration': clip.duration,
-			'tracks': tracks
-
-		};
-
-		for ( var i = 0, n = clipTracks.length; i !== n; ++ i ) {
-
-			tracks.push( THREE.KeyframeTrack.toJSON( clipTracks[ i ] ) );
-
-		}
-
-		return json;
-
-	},
-
-
-	CreateFromMorphTargetSequence: function( name, morphTargetSequence, fps, noLoop ) {
-
-		var numMorphTargets = morphTargetSequence.length;
-		var tracks = [];
-
-		for ( var i = 0; i < numMorphTargets; i ++ ) {
-
-			var times = [];
-			var values = [];
-
-			times.push(
-					( i + numMorphTargets - 1 ) % numMorphTargets,
-					i,
-					( i + 1 ) % numMorphTargets );
-
-			values.push( 0, 1, 0 );
-
-			var order = THREE.AnimationUtils.getKeyframeOrder( times );
-			times = THREE.AnimationUtils.sortedArray( times, 1, order );
-			values = THREE.AnimationUtils.sortedArray( values, 1, order );
-
-			// if there is a key at the first frame, duplicate it as the
-			// last frame as well for perfect loop.
-			if ( ! noLoop && times[ 0 ] === 0 ) {
-
-				times.push( numMorphTargets );
-				values.push( values[ 0 ] );
-
-			}
-
-			tracks.push(
-					new THREE.NumberKeyframeTrack(
-						'.morphTargetInfluences[' + morphTargetSequence[ i ].name + ']',
-						times, values
-					).scale( 1.0 / fps ) );
-		}
-
-		return new THREE.AnimationClip( name, -1, tracks );
-
-	},
-
-	findByName: function( clipArray, name ) {
-
-		for ( var i = 0; i < clipArray.length; i ++ ) {
-
-			if ( clipArray[ i ].name === name ) {
-
-				return clipArray[ i ];
-
-			}
-		}
-
-		return null;
-
-	},
-
-	CreateClipsFromMorphTargetSequences: function( morphTargets, fps, noLoop ) {
-
-		var animationToMorphTargets = {};
-
-		// tested with https://regex101.com/ on trick sequences
-		// such flamingo_flyA_003, flamingo_run1_003, crdeath0059
-		var pattern = /^([\w-]*?)([\d]+)$/;
-
-		// sort morph target names into animation groups based
-		// patterns like Walk_001, Walk_002, Run_001, Run_002
-		for ( var i = 0, il = morphTargets.length; i < il; i ++ ) {
-
-			var morphTarget = morphTargets[ i ];
-			var parts = morphTarget.name.match( pattern );
-
-			if ( parts && parts.length > 1 ) {
-
-				var name = parts[ 1 ];
-
-				var animationMorphTargets = animationToMorphTargets[ name ];
-				if ( ! animationMorphTargets ) {
-
-					animationToMorphTargets[ name ] = animationMorphTargets = [];
-
-				}
-
-				animationMorphTargets.push( morphTarget );
-
-			}
-
-		}
-
-		var clips = [];
-
-		for ( var name in animationToMorphTargets ) {
-
-			clips.push( THREE.AnimationClip.CreateFromMorphTargetSequence( name, animationToMorphTargets[ name ], fps, noLoop ) );
-
-		}
-
-		return clips;
-
-	},
-
-	// parse the animation.hierarchy format
-	parseAnimation: function( animation, bones, nodeName ) {
-
-		if ( ! animation ) {
-
-			console.error( "  no animation in JSONLoader data" );
-			return null;
-
-		}
-
-		var addNonemptyTrack = function(
-				trackType, trackName, animationKeys, propertyName, destTracks ) {
-
-			// only return track if there are actually keys.
-			if ( animationKeys.length !== 0 ) {
-
-				var times = [];
-				var values = [];
-
-				THREE.AnimationUtils.flattenJSON(
-						animationKeys, times, values, propertyName );
-
-				// empty keys are filtered out, so check again
-				if ( times.length !== 0 ) {
-
-					destTracks.push( new trackType( trackName, times, values ) );
-
-				}
-
-			}
-
-		};
-
-		var tracks = [];
-
-		var clipName = animation.name || 'default';
-		// automatic length determination in AnimationClip.
-		var duration = animation.length || -1;
-		var fps = animation.fps || 30;
-
-		var hierarchyTracks = animation.hierarchy || [];
-
-		for ( var h = 0; h < hierarchyTracks.length; h ++ ) {
-
-			var animationKeys = hierarchyTracks[ h ].keys;
-
-			// skip empty tracks
-			if ( ! animationKeys || animationKeys.length == 0 ) continue;
-
-			// process morph targets in a way exactly compatible
-			// with AnimationHandler.init( animation )
-			if ( animationKeys[0].morphTargets ) {
-
-				// figure out all morph targets used in this track
-				var morphTargetNames = {};
-				for ( var k = 0; k < animationKeys.length; k ++ ) {
-
-					if ( animationKeys[k].morphTargets ) {
-
-						for ( var m = 0; m < animationKeys[k].morphTargets.length; m ++ ) {
-
-							morphTargetNames[ animationKeys[k].morphTargets[m] ] = -1;
-						}
-
-					}
-
-				}
-
-				// create a track for each morph target with all zero
-				// morphTargetInfluences except for the keys in which
-				// the morphTarget is named.
-				for ( var morphTargetName in morphTargetNames ) {
-
-					var times = [];
-					var values = [];
-
-					for ( var m = 0;
-							m !== animationKeys[k].morphTargets.length; ++ m ) {
-
-						var animationKey = animationKeys[k];
-
-						times.push( animationKey.time );
-						values.push( ( animationKey.morphTarget === morphTargetName ) ? 1 : 0 )
-
-					}
-
-					tracks.push( new THREE.NumberKeyframeTrack(
-							'.morphTargetInfluence[' + morphTargetName + ']', times, values ) );
-
-				}
-
-				duration = morphTargetNames.length * ( fps || 1.0 );
-
-			} else {
-				// ...assume skeletal animation
-
-				var boneName = '.bones[' + bones[ h ].name + ']';
-
-				addNonemptyTrack(
-						THREE.VectorKeyframeTrack, boneName + '.position',
-						animationKeys, 'pos', tracks );
-
-				addNonemptyTrack(
-						THREE.QuaternionKeyframeTrack, boneName + '.quaternion',
-						animationKeys, 'rot', tracks );
-
-				addNonemptyTrack(
-						THREE.VectorKeyframeTrack, boneName + '.scale',
-						animationKeys, 'scl', tracks );
-
-			}
-
-		}
-
-		if ( tracks.length === 0 ) {
-
-			return null;
-
-		}
-
-		var clip = new THREE.AnimationClip( clipName, duration, tracks );
-
-		return clip;
-
-	}
-
-} );
-
-
-// File:src/animation/AnimationMixer.js
-
-/**
- *
- * Player for AnimationClips.
- *
- *
- * @author Ben Houston / http://clara.io/
- * @author David Sarno / http://lighthaus.us/
- * @author tschw
- */
-
-THREE.AnimationMixer = function( root ) {
-
-	this._root = root;
-	this._initMemoryManager();
-	this._accuIndex = 0;
-
-	this.time = 0;
-
-	this.timeScale = 1.0;
-
-};
-
-THREE.AnimationMixer.prototype = {
-
-	constructor: THREE.AnimationMixer,
-
-	// return an action for a clip optionally using a custom root target
-	// object (this method allocates a lot of dynamic memory in case a
-	// previously unknown clip/root combination is specified)
-	clipAction: function( clip, optionalRoot ) {
-
-		var root = optionalRoot || this._root,
-			rootUuid = root.uuid,
-			clipName = ( typeof clip === 'string' ) ? clip : clip.name,
-			clipObject = ( clip !== clipName ) ? clip : null,
-
-			actionsForClip = this._actionsByClip[ clipName ],
-			prototypeAction;
-
-		if ( actionsForClip !== undefined ) {
-
-			var existingAction =
-					actionsForClip.actionByRoot[ rootUuid ];
-
-			if ( existingAction !== undefined ) {
-
-				return existingAction;
-
-			}
-
-			// we know the clip, so we don't have to parse all
-			// the bindings again but can just copy
-			prototypeAction = actionsForClip.knownActions[ 0 ];
-
-			// also, take the clip from the prototype action
-			clipObject = prototypeAction._clip;
-
-			if ( clip !== clipName && clip !== clipObject ) {
-
-				throw new Error(
-						"Different clips with the same name detected!" );
-
-			}
-
-		}
-
-		// clip must be known when specified via string
-		if ( clipObject === null ) return null;
-
-		// allocate all resources required to run it
-		var newAction = new THREE.
-				AnimationMixer._Action( this, clipObject, optionalRoot );
-
-		this._bindAction( newAction, prototypeAction );
-
-		// and make the action known to the memory manager
-		this._addInactiveAction( newAction, clipName, rootUuid );
-
-		return newAction;
-
-	},
-
-	// get an existing action
-	existingAction: function( clip, optionalRoot ) {
-
-		var root = optionalRoot || this._root,
-			rootUuid = root.uuid,
-			clipName = ( typeof clip === 'string' ) ? clip : clip.name,
-			actionsForClip = this._actionsByClip[ clipName ];
-
-		if ( actionsForClip !== undefined ) {
-
-			return actionsForClip.actionByRoot[ rootUuid ] || null;
-
-		}
-
-		return null;
-
-	},
-
-	// deactivates all previously scheduled actions
-	stopAllAction: function() {
-
-		var actions = this._actions,
-			nActions = this._nActiveActions,
-			bindings = this._bindings,
-			nBindings = this._nActiveBindings;
-
-		this._nActiveActions = 0;
-		this._nActiveBindings = 0;
-
-		for ( var i = 0; i !== nActions; ++ i ) {
-
-			actions[ i ].reset();
-
-		}
-
-		for ( var i = 0; i !== nBindings; ++ i ) {
-
-			bindings[ i ].useCount = 0;
-
-		}
-
-		return this;
-
-	},
-
-	// advance the time and update apply the animation
-	update: function( deltaTime ) {
-
-		deltaTime *= this.timeScale;
-
-		var actions = this._actions,
-			nActions = this._nActiveActions,
-
-			time = this.time += deltaTime,
-			timeDirection = Math.sign( deltaTime ),
-
-			accuIndex = this._accuIndex ^= 1;
-
-		// run active actions
-
-		for ( var i = 0; i !== nActions; ++ i ) {
-
-			var action = actions[ i ];
-
-			if ( action.enabled ) {
-
-				action._update( time, deltaTime, timeDirection, accuIndex );
-
-			}
-
-		}
-
-		// update scene graph
-
-		var bindings = this._bindings,
-			nBindings = this._nActiveBindings;
-
-		for ( var i = 0; i !== nBindings; ++ i ) {
-
-			bindings[ i ].apply( accuIndex );
-
-		}
-
-		return this;
-
-	},
-
-	// return this mixer's root target object
-	getRoot: function() {
-
-		return this._root;
-
-	},
-
-	// free all resources specific to a particular clip
-	uncacheClip: function( clip ) {
-
-		var actions = this._actions,
-			clipName = clip.name,
-			actionsByClip = this._actionsByClip,
-			actionsForClip = actionsByClip[ clipName ];
-
-		if ( actionsForClip !== undefined ) {
-
-			// note: just calling _removeInactiveAction would mess up the
-			// iteration state and also require updating the state we can
-			// just throw away
-
-			var actionsToRemove = actionsForClip.knownActions;
-
-			for ( var i = 0, n = actionsToRemove.length; i !== n; ++ i ) {
-
-				var action = actionsToRemove[ i ];
-
-				this._deactivateAction( action );
-
-				var cacheIndex = action._cacheIndex,
-					lastInactiveAction = actions[ actions.length - 1 ];
-
-				action._cacheIndex = null;
-				action._byClipCacheIndex = null;
-
-				lastInactiveAction._cacheIndex = cacheIndex;
-				actions[ cacheIndex ] = lastInactiveAction;
-				actions.pop();
-
-				this._removeInactiveBindingsForAction( action );
-
-			}
-
-			delete actionsByClip[ clipName ];
-
-		}
-
-	},
-
-	// free all resources specific to a particular root target object
-	uncacheRoot: function( root ) {
-
-		var rootUuid = root.uuid,
-			actionsByClip = this._actionsByClip;
-
-		for ( var clipName in actionsByClip ) {
-
-			var actionByRoot = actionsByClip[ clipName ].actionByRoot,
-				action = actionByRoot[ rootUuid ];
-
-			if ( action !== undefined ) {
-
-				this._deactivateAction( action );
-				this._removeInactiveAction( action );
-
-			}
-
-		}
-
-		var bindingsByRoot = this._bindingsByRootAndName,
-			bindingByName = bindingsByRoot[ rootUuid ];
-
-		if ( bindingByName !== undefined ) {
-
-			for ( var trackName in bindingByName ) {
-
-				var binding = bindingByName[ trackName ];
-				binding.restoreOriginalState();
-				this._removeInactiveBinding( binding );
-
-			}
-
-		}
-
-	},
-
-	// remove a targeted clip from the cache
-	uncacheAction: function( clip, optionalRoot ) {
-
-		var action = this.existingAction( clip, optionalRoot );
-
-		if ( action !== null ) {
-
-			this._deactivateAction( action );
-			this._removeInactiveAction( action );
-
-		}
-
-	}
-
-};
-
-THREE.EventDispatcher.prototype.apply( THREE.AnimationMixer.prototype );
-
-THREE.AnimationMixer._Action =
-		function( mixer, clip, localRoot ) {
-
-	this._mixer = mixer;
-	this._clip = clip;
-	this._localRoot = localRoot || null;
-
-	var tracks = clip.tracks,
-		nTracks = tracks.length,
-		interpolants = new Array( nTracks );
-
-	var interpolantSettings = {
-			endingStart: 	THREE.ZeroCurvatureEnding,
-			endingEnd:		THREE.ZeroCurvatureEnding
-	};
-
-	for ( var i = 0; i !== nTracks; ++ i ) {
-
-		var interpolant = tracks[ i ].createInterpolant( null );
-		interpolants[ i ] = interpolant;
-		interpolant.settings = interpolantSettings
-
-	}
-
-	this._interpolantSettings = interpolantSettings;
-
-	this._interpolants = interpolants;	// bound by the mixer
-
-	// inside: PropertyMixer (managed by the mixer)
-	this._propertyBindings = new Array( nTracks );
-
-	this._cacheIndex = null;			// for the memory manager
-	this._byClipCacheIndex = null;		// for the memory manager
-
-	this._timeScaleInterpolant = null;
-	this._weightInterpolant = null;
-
-	this.loop = THREE.LoopRepeat;
-	this._loopCount = -1;
-
-	// global mixer time when the action is to be started
-	// it's set back to 'null' upon start of the action
-	this._startTime = null;
-
-	// scaled local time of the action
-	// gets clamped or wrapped to 0..clip.duration according to loop
-	this.time = 0;
-
-	this.timeScale = 1;
-	this._effectiveTimeScale = 1;
-
-	this.weight = 1;
-	this._effectiveWeight = 1;
-
-	this.repetitions = Infinity; 		// no. of repetitions when looping
-
-	this.paused = false;				// false -> zero effective time scale
-	this.enabled = true;				// true -> zero effective weight
-
-	this.clampWhenFinished 	= false;	// keep feeding the last frame?
-
-	this.zeroSlopeAtStart 	= true;		// for smooth interpolation w/o separate
-	this.zeroSlopeAtEnd		= true;		// clips for start, loop and end
-
-};
-
-THREE.AnimationMixer._Action.prototype = {
-
-	constructor: THREE.AnimationMixer._Action,
-
-	// State & Scheduling
-
-	play: function() {
-
-		this._mixer._activateAction( this );
-
-		return this;
-
-	},
-
-	stop: function() {
-
-		this._mixer._deactivateAction( this );
-
-		return this.reset();
-
-	},
-
-	reset: function() {
-
-		this.paused = false;
-		this.enabled = true;
-
-		this.time = 0;			// restart clip
-		this._loopCount = -1;	// forget previous loops
-		this._startTime = null;	// forget scheduling
-
-		return this.stopFading().stopWarping();
-
-	},
-
-	isRunning: function() {
-
-		var start = this._startTime;
-
-		return this.enabled && ! this.paused && this.timeScale !== 0 &&
-				this._startTime === null && this._mixer._isActiveAction( this )
-
-	},
-
-	// return true when play has been called
-	isScheduled: function() {
-
-		return this._mixer._isActiveAction( this );
-
-	},
-
-	startAt: function( time ) {
-
-		this._startTime = time;
-
-		return this;
-
-	},
-
-	setLoop: function( mode, repetitions ) {
-
-		this.loop = mode;
-		this.repetitions = repetitions;
-
-		return this;
-
-	},
-
-	// Weight
-
-	// set the weight stopping any scheduled fading
-	// although .enabled = false yields an effective weight of zero, this
-	// method does *not* change .enabled, because it would be confusing
-	setEffectiveWeight: function( weight ) {
-
-		this.weight = weight;
-
-		// note: same logic as when updated at runtime
-		this._effectiveWeight = this.enabled ? weight : 0;
-
-		return this.stopFading();
-
-	},
-
-	// return the weight considering fading and .enabled
-	getEffectiveWeight: function() {
-
-		return this._effectiveWeight;
-
-	},
-
-	fadeIn: function( duration ) {
-
-		return this._scheduleFading( duration, 0, 1 );
-
-	},
-
-	fadeOut: function( duration ) {
-
-		return this._scheduleFading( duration, 1, 0 );
-
-	},
-
-	crossFadeFrom: function( fadeOutAction, duration, warp ) {
-
-		var mixer = this._mixer;
-
-		fadeOutAction.fadeOut( duration );
-		this.fadeIn( duration );
-
-		if( warp ) {
-
-			var fadeInDuration = this._clip.duration,
-				fadeOutDuration = fadeOutAction._clip.duration,
-
-				startEndRatio = fadeOutDuration / fadeInDuration,
-				endStartRatio = fadeInDuration / fadeOutDuration;
-
-			fadeOutAction.warp( 1.0, startEndRatio, duration );
-			this.warp( endStartRatio, 1.0, duration );
-
-		}
-
-		return this;
-
-	},
-
-	crossFadeTo: function( fadeInAction, duration, warp ) {
-
-		return fadeInAction.crossFadeFrom( this, duration, warp );
-
-	},
-
-	stopFading: function() {
-
-		var weightInterpolant = this._weightInterpolant;
-
-		if ( weightInterpolant !== null ) {
-
-			this._weightInterpolant = null;
-			this._mixer._takeBackControlInterpolant( weightInterpolant );
-
-		}
-
-		return this;
-
-	},
-
-	// Time Scale Control
-
-	// set the weight stopping any scheduled warping
-	// although .paused = true yields an effective time scale of zero, this
-	// method does *not* change .paused, because it would be confusing
-	setEffectiveTimeScale: function( timeScale ) {
-
-		this.timeScale = timeScale;
-		this._effectiveTimeScale = this.paused ? 0 :timeScale;
-
-		return this.stopWarping();
-
-	},
-
-	// return the time scale considering warping and .paused
-	getEffectiveTimeScale: function() {
-
-		return this._effectiveTimeScale;
-
-	},
-
-	setDuration: function( duration ) {
-
-		this.timeScale = this._clip.duration / duration;
-
-		return this.stopWarping();
-
-	},
-
-	syncWith: function( action ) {
-
-		this.time = action.time;
-		this.timeScale = action.timeScale;
-
-		return this.stopWarping();
-
-	},
-
-	halt: function( duration ) {
-
-		return this.warp( this._currentTimeScale, 0, duration );
-
-	},
-
-	warp: function( startTimeScale, endTimeScale, duration ) {
-
-		var mixer = this._mixer, now = mixer.time,
-			interpolant = this._timeScaleInterpolant,
-
-			timeScale = this.timeScale;
-
-		if ( interpolant === null ) {
-
-			interpolant = mixer._lendControlInterpolant(),
-			this._timeScaleInterpolant = interpolant;
-
-		}
-
-		var times = interpolant.parameterPositions,
-			values = interpolant.sampleValues;
-
-		times[ 0 ] = now;
-		times[ 1 ] = now + duration;
-
-		values[ 0 ] = startTimeScale / timeScale;
-		values[ 1 ] = endTimeScale / timeScale;
-
-		return this;
-
-	},
-
-	stopWarping: function() {
-
-		var timeScaleInterpolant = this._timeScaleInterpolant;
-
-		if ( timeScaleInterpolant !== null ) {
-
-			this._timeScaleInterpolant = null;
-			this._mixer._takeBackControlInterpolant( timeScaleInterpolant );
-
-		}
-
-		return this;
-
-	},
-
-	// Object Accessors
-
-	getMixer: function() {
-
-		return this._mixer;
-
-	},
-
-	getClip: function() {
-
-		return this._clip;
-
-	},
-
-	getRoot: function() {
-
-		return this._localRoot || this._mixer._root;
-
-	},
-
-	// Interna
-
-	_update: function( time, deltaTime, timeDirection, accuIndex ) {
-		// called by the mixer
-
-		var startTime = this._startTime;
-
-		if ( startTime !== null ) {
-
-			// check for scheduled start of action
-
-			var timeRunning = ( time - startTime ) * timeDirection;
-			if ( timeRunning < 0 || timeDirection === 0 ) {
-
-				return; // yet to come / don't decide when delta = 0
-
-			}
-
-			// start
-
-			this._startTime = null; // unschedule
-			deltaTime = timeDirection * timeRunning;
-
-		}
-
-		// apply time scale and advance time
-
-		deltaTime *= this._updateTimeScale( time );
-		var clipTime = this._updateTime( deltaTime );
-
-		// note: _updateTime may disable the action resulting in
-		// an effective weight of 0
-
-		var weight = this._updateWeight( time );
-
-		if ( weight > 0 ) {
-
-			var interpolants = this._interpolants;
-			var propertyMixers = this._propertyBindings;
-
-			for ( var j = 0, m = interpolants.length; j !== m; ++ j ) {
-
-				interpolants[ j ].evaluate( clipTime );
-				propertyMixers[ j ].accumulate( accuIndex, weight );
-
-			}
-
-		}
-
-	},
-
-	_updateWeight: function( time ) {
-
-		var weight = 0;
-
-		if ( this.enabled ) {
-
-			weight = this.weight;
-			var interpolant = this._weightInterpolant;
-
-			if ( interpolant !== null ) {
-
-				var interpolantValue = interpolant.evaluate( time )[ 0 ];
-
-				weight *= interpolantValue;
-
-				if ( time > interpolant.parameterPositions[ 1 ] ) {
-
-					this.stopFading();
-
-					if ( interpolantValue === 0 ) {
-
-						// faded out, disable
-						this.enabled = false;
-
-					}
-
-				}
-
-			}
-
-		}
-
-		this._effectiveWeight = weight;
-		return weight;
-
-	},
-
-	_updateTimeScale: function( time ) {
-
-		var timeScale = 0;
-
-		if ( ! this.paused ) {
-
-			timeScale = this.timeScale;
-
-			var interpolant = this._timeScaleInterpolant;
-
-			if ( interpolant !== null ) {
-
-				var interpolantValue = interpolant.evaluate( time )[ 0 ];
-
-				timeScale *= interpolantValue;
-
-				if ( time > interpolant.parameterPositions[ 1 ] ) {
-
-					this.stopWarping();
-
-					if ( timeScale === 0 ) {
-
-						// motion has halted, pause
-						this.pause = true;
-
-					} else {
-
-						// warp done - apply final time scale
-						this.timeScale = timeScale;
-
-					}
-
-				}
-
-			}
-
-		}
-
-		this._effectiveTimeScale = timeScale;
-		return timeScale;
-
-	},
-
-	_updateTime: function( deltaTime ) {
-
-		var time = this.time + deltaTime;
-
-		if ( deltaTime === 0 ) return time;
-
-		var duration = this._clip.duration,
-
-			loop = this.loop,
-			loopCount = this._loopCount,
-
-			pingPong = false;
-
-		switch ( loop ) {
-
-			case THREE.LoopOnce:
-
-				if ( loopCount === -1 ) {
-
-					// just started
-
-					this.loopCount = 0;
-					this._setEndings( true, true, false );
-
-				}
-
-				if ( time >= duration ) {
-
-					time = duration;
-
-				} else if ( time < 0 ) {
-
-					time = 0;
-
-				} else break;
-
-				// reached the end
-
-				if ( this.clampWhenFinished ) this.pause = true;
-				else this.enabled = false;
-
-				this._mixer.dispatchEvent( {
-					type: 'finished', action: this,
-					direction: deltaTime < 0 ? -1 : 1
-				} );
-
-				break;
-
-			case THREE.LoopPingPong:
-
-				pingPong = true;
-
-			case THREE.LoopRepeat:
-
-				if ( loopCount === -1 ) {
-
-					// just started
-
-					if ( deltaTime > 0 ) {
-
-						loopCount = 0;
-
-						this._setEndings(
-								true, this.repetitions === 0, pingPong );
-
-					} else {
-
-						// when looping in reverse direction, the initial
-						// transition through zero counts as a repetition,
-						// so leave loopCount at -1
-
-						this._setEndings(
-								this.repetitions === 0, true, pingPong );
-
-					}
-
-				}
-
-				if ( time >= duration || time < 0 ) {
-
-					// wrap around
-
-					var loopDelta = Math.floor( time / duration ); // signed
-					time -= duration * loopDelta;
-
-					loopCount += Math.abs( loopDelta );
-
-					var pending = this.repetitions - loopCount;
-
-					if ( pending < 0 ) {
-
-						// stop (switch state, clamp time, fire event)
-
-						if ( this.clampWhenFinished ) this.paused = true;
-						else this.enabled = false;
-
-						time = deltaTime > 0 ? duration : 0;
-
-						this._mixer.dispatchEvent( {
-							type: 'finished', action: this,
-							direction: deltaTime > 0 ? 1 : -1
-						} );
-
-						break;
-
-					} else if ( pending === 0 ) {
-
-						// transition to last round
-
-						var atStart = deltaTime < 0;
-						this._setEndings( atStart, ! atStart, pingPong );
-
-					} else {
-
-						this._setEndings( false, false, pingPong );
-
-					}
-
-					this._loopCount = loopCount;
-
-					this._mixer.dispatchEvent( {
-						type: 'loop', action: this, loopDelta: loopDelta
-					} );
-
-				}
-
-				if ( loop === THREE.LoopPingPong && ( loopCount & 1 ) === 1 ) {
-
-					// invert time for the "pong round"
-
-					this.time = time;
-
-					return duration - time;
-
-				}
-
-				break;
-
-		}
-
-		this.time = time;
-
-		return time;
-
-	},
-
-	_setEndings: function( atStart, atEnd, pingPong ) {
-
-		var settings = this._interpolantSettings;
-
-		if ( pingPong ) {
-
-			settings.endingStart 	= THREE.ZeroSlopeEnding;
-			settings.endingEnd		= THREE.ZeroSlopeEnding;
-
-		} else {
-
-			// assuming for LoopOnce atStart == atEnd == true
-
-			if ( atStart ) {
-
-				settings.endingStart = this.zeroSlopeAtStart ?
-						THREE.ZeroSlopeEnding : THREE.ZeroCurvatureEnding;
-
-			} else {
-
-				settings.endingStart = THREE.WrapAroundEnding;
-
-			}
-
-			if ( atEnd ) {
-
-				settings.endingEnd = this.zeroSlopeAtEnd ?
-						THREE.ZeroSlopeEnding : THREE.ZeroCurvatureEnding;
-
-			} else {
-
-				settings.endingEnd 	 = THREE.WrapAroundEnding;
-
-			}
-
-		}
-
-	},
-
-	_scheduleFading: function( duration, weightNow, weightThen ) {
-
-		var mixer = this._mixer, now = mixer.time,
-			interpolant = this._weightInterpolant;
-
-		if ( interpolant === null ) {
-
-			interpolant = mixer._lendControlInterpolant(),
-			this._weightInterpolant = interpolant;
-
-		}
-
-		var times = interpolant.parameterPositions,
-			values = interpolant.sampleValues;
-
-		times[ 0 ] = now; 				values[ 0 ] = weightNow;
-		times[ 1 ] = now + duration;	values[ 1 ] = weightThen;
-
-		return this;
-
-	}
-
-};
-
-// Implementation details:
-
-Object.assign( THREE.AnimationMixer.prototype, {
-
-	_bindAction: function( action, prototypeAction ) {
-
-		var root = action._localRoot || this._root,
-			tracks = action._clip.tracks,
-			nTracks = tracks.length,
-			bindings = action._propertyBindings,
-			interpolants = action._interpolants,
-			rootUuid = root.uuid,
-			bindingsByRoot = this._bindingsByRootAndName,
-			bindingsByName = bindingsByRoot[ rootUuid ];
-
-		if ( bindingsByName === undefined ) {
-
-			bindingsByName = {};
-			bindingsByRoot[ rootUuid ] = bindingsByName;
-
-		}
-
-		for ( var i = 0; i !== nTracks; ++ i ) {
-
-			var track = tracks[ i ],
-				trackName = track.name,
-				binding = bindingsByName[ trackName ];
-
-			if ( binding !== undefined ) {
-
-				bindings[ i ] = binding;
-
-			} else {
-
-				binding = bindings[ i ];
-
-				if ( binding !== undefined ) {
-
-					// existing binding, make sure the cache knows
-
-					if ( binding._cacheIndex === null ) {
-
-						++ binding.referenceCount;
-						this._addInactiveBinding( binding, rootUuid, trackName );
-
-					}
-
-					continue;
-
-				}
-
-				var path = prototypeAction && prototypeAction.
-						_propertyBindings[ i ].binding.parsedPath;
-
-				binding = new THREE.PropertyMixer(
-						THREE.PropertyBinding.create( root, trackName, path ),
-						track.ValueTypeName, track.getValueSize() );
-
-				++ binding.referenceCount;
-				this._addInactiveBinding( binding, rootUuid, trackName );
-
-				bindings[ i ] = binding;
-
-			}
-
-			interpolants[ i ].resultBuffer = binding.buffer;
-
-		}
-
-	},
-
-	_activateAction: function( action ) {
-
-		if ( ! this._isActiveAction( action ) ) {
-
-			if ( action._cacheIndex === null ) {
-
-				// this action has been forgotten by the cache, but the user
-				// appears to be still using it -> rebind
-
-				var rootUuid = ( action._localRoot || this._root ).uuid,
-					clipName = action._clip.name,
-					actionsForClip = this._actionsByClip[ clipName ];
-
-				this._bindAction( action,
-						actionsForClip && actionsForClip.knownActions[ 0 ] );
-
-				this._addInactiveAction( action, clipName, rootUuid );
-
-			}
-
-			var bindings = action._propertyBindings;
-
-			// increment reference counts / sort out state
-			for ( var i = 0, n = bindings.length; i !== n; ++ i ) {
-
-				var binding = bindings[ i ];
-
-				if ( binding.useCount ++ === 0 ) {
-
-					this._lendBinding( binding );
-					binding.saveOriginalState();
-
-				}
-
-			}
-
-			this._lendAction( action );
-
-		}
-
-	},
-
-	_deactivateAction: function( action ) {
-
-		if ( this._isActiveAction( action ) ) {
-
-			var bindings = action._propertyBindings;
-
-			// decrement reference counts / sort out state
-			for ( var i = 0, n = bindings.length; i !== n; ++ i ) {
-
-				var binding = bindings[ i ];
-
-				if ( -- binding.useCount === 0 ) {
-
-					binding.restoreOriginalState();
-					this._takeBackBinding( binding );
-
-				}
-
-			}
-
-			this._takeBackAction( action );
-
-		}
-
-	},
-
-	// Memory manager
-
-	_initMemoryManager: function() {
-
-		this._actions = []; // 'nActiveActions' followed by inactive ones
-		this._nActiveActions = 0;
-
-		this._actionsByClip = {};
-		// inside:
-		// {
-		// 		knownActions: Array< _Action >	- used as prototypes
-		// 		actionByRoot: _Action			- lookup
-		// }
-
-
-		this._bindings = []; // 'nActiveBindings' followed by inactive ones
-		this._nActiveBindings = 0;
-
-		this._bindingsByRootAndName = {}; // inside: Map< name, PropertyMixer >
-
-
-		this._controlInterpolants = []; // same game as above
-		this._nActiveControlInterpolants = 0;
-
-		var scope = this;
-
-		this.stats = {
-
-			actions: {
-				get total() { return scope._actions.length; },
-				get inUse() { return scope._nActiveActions; }
-			},
-			bindings: {
-				get total() { return scope._bindings.length; },
-				get inUse() { return scope._nActiveBindings; }
-			},
-			controlInterpolants: {
-				get total() { return scope._controlInterpolants.length; },
-				get inUse() { return scope._nActiveControlInterpolants; }
-			}
-
-		};
-
-	},
-
-	// Memory management for _Action objects
-
-	_isActiveAction: function( action ) {
-
-		var index = action._cacheIndex;
-		return index !== null && index < this._nActiveActions;
-
-	},
-
-	_addInactiveAction: function( action, clipName, rootUuid ) {
-
-		var actions = this._actions,
-			actionsByClip = this._actionsByClip,
-			actionsForClip = actionsByClip[ clipName ];
-
-		if ( actionsForClip === undefined ) {
-
-			actionsForClip = {
-
-				knownActions: [ action ],
-				actionByRoot: {}
-
-			};
-
-			action._byClipCacheIndex = 0;
-
-			actionsByClip[ clipName ] = actionsForClip;
-
-		} else {
-
-			var knownActions = actionsForClip.knownActions;
-
-			action._byClipCacheIndex = knownActions.length;
-			knownActions.push( action );
-
-		}
-
-		action._cacheIndex = actions.length;
-		actions.push( action );
-
-		actionsForClip.actionByRoot[ rootUuid ] = action;
-
-	},
-
-	_removeInactiveAction: function( action ) {
-
-		var actions = this._actions,
-			lastInactiveAction = actions[ actions.length - 1 ],
-			cacheIndex = action._cacheIndex;
-
-		lastInactiveAction._cacheIndex = cacheIndex;
-		actions[ cacheIndex ] = lastInactiveAction;
-		actions.pop();
-
-		action._cacheIndex = null;
-
-
-		var clipName = action._clip.name,
-			actionsByClip = this._actionsByClip,
-			actionsForClip = actionsByClip[ clipName ],
-			knownActionsForClip = actionsForClip.knownActions,
-
-			lastKnownAction =
-				knownActionsForClip[ knownActionsForClip.length - 1 ],
-
-			byClipCacheIndex = action._byClipCacheIndex;
-
-		lastKnownAction._byClipCacheIndex = byClipCacheIndex;
-		knownActionsForClip[ byClipCacheIndex ] = lastKnownAction;
-		knownActionsForClip.pop();
-
-		action._byClipCacheIndex = null;
-
-
-		var actionByRoot = actionsForClip.actionByRoot,
-			rootUuid = ( actions._localRoot || this._root ).uuid;
-
-		delete actionByRoot[ rootUuid ];
-
-		if ( knownActionsForClip.length === 0 ) {
-
-			delete actionsByClip[ clipName ];
-
-		}
-
-		this._removeInactiveBindingsForAction( action );
-
-	},
-
-	_removeInactiveBindingsForAction: function( action ) {
-
-		var bindings = action._propertyBindings;
-		for ( var i = 0, n = bindings.length; i !== n; ++ i ) {
-
-			var binding = bindings[ i ];
-
-			if ( -- binding.referenceCount === 0 ) {
-
-				this._removeInactiveBinding( binding );
-
-			}
-
-		}
-
-	},
-
-	_lendAction: function( action ) {
-
-		// [ active actions |  inactive actions  ]
-		// [  active actions >| inactive actions ]
-		//                 s        a
-		//                  <-swap->
-		//                 a        s
-
-		var actions = this._actions,
-			prevIndex = action._cacheIndex,
-
-			lastActiveIndex = this._nActiveActions ++,
-
-			firstInactiveAction = actions[ lastActiveIndex ];
-
-		action._cacheIndex = lastActiveIndex;
-		actions[ lastActiveIndex ] = action;
-
-		firstInactiveAction._cacheIndex = prevIndex;
-		actions[ prevIndex ] = firstInactiveAction;
-
-	},
-
-	_takeBackAction: function( action ) {
-
-		// [  active actions  | inactive actions ]
-		// [ active actions |< inactive actions  ]
-		//        a        s
-		//         <-swap->
-		//        s        a
-
-		var actions = this._actions,
-			prevIndex = action._cacheIndex,
-
-			firstInactiveIndex = -- this._nActiveActions,
-
-			lastActiveAction = actions[ firstInactiveIndex ];
-
-		action._cacheIndex = firstInactiveIndex;
-		actions[ firstInactiveIndex ] = action;
-
-		lastActiveAction._cacheIndex = prevIndex;
-		actions[ prevIndex ] = lastActiveAction;
-
-	},
-
-	// Memory management for PropertyMixer objects
-
-	_addInactiveBinding: function( binding, rootUuid, trackName ) {
-
-		var bindingsByRoot = this._bindingsByRootAndName,
-			bindingByName = bindingsByRoot[ rootUuid ],
-
-			bindings = this._bindings;
-
-		if ( bindingByName === undefined ) {
-
-			bindingByName = {};
-			bindingsByRoot[ rootUuid ] = bindingByName;
-
-		}
-
-		bindingByName[ trackName ] = binding;
-
-		binding._cacheIndex = bindings.length;
-		bindings.push( binding );
-
-	},
-
-	_removeInactiveBinding: function( binding ) {
-
-		var bindings = this._bindings,
-			propBinding = binding.binding,
-			rootUuid = propBinding.rootNode.uuid,
-			trackName = propBinding.path,
-			bindingsByRoot = this._bindingsByRootAndName,
-			bindingByName = bindingsByRoot[ rootUuid ],
-
-			lastInactiveBinding = bindings[ bindings.length - 1 ],
-			cacheIndex = binding._cacheIndex;
-
-		lastInactiveBinding._cacheIndex = cacheIndex;
-		bindings[ cacheIndex ] = lastInactiveBinding;
-		bindings.pop();
-
-		delete bindingByName[ trackName ];
-
-		remove_empty_map: {
-
-			for ( var _ in bindingByName ) break remove_empty_map;
-
-			delete bindingsByRoot[ rootUuid ];
-
-		}
-
-	},
-
-	_lendBinding: function( binding ) {
-
-		var bindings = this._bindings,
-			prevIndex = binding._cacheIndex,
-
-			lastActiveIndex = this._nActiveBindings ++,
-
-			firstInactiveBinding = bindings[ lastActiveIndex ];
-
-		binding._cacheIndex = lastActiveIndex;
-		bindings[ lastActiveIndex ] = binding;
-
-		firstInactiveBinding._cacheIndex = prevIndex;
-		bindings[ prevIndex ] = firstInactiveBinding;
-
-	},
-
-	_takeBackBinding: function( binding ) {
-
-		var bindings = this._bindings,
-			prevIndex = binding._cacheIndex,
-
-			firstInactiveIndex = -- this._nActiveBindings,
-
-			lastActiveBinding = bindings[ firstInactiveIndex ];
-
-		binding._cacheIndex = firstInactiveIndex;
-		bindings[ firstInactiveIndex ] = binding;
-
-		lastActiveBinding._cacheIndex = prevIndex;
-		bindings[ prevIndex ] = lastActiveBinding;
-
-	},
-
-
-	// Memory management of Interpolants for weight and time scale
-
-	_lendControlInterpolant: function() {
-
-		var interpolants = this._controlInterpolants,
-			lastActiveIndex = this._nActiveControlInterpolants ++,
-			interpolant = interpolants[ lastActiveIndex ];
-
-		if ( interpolant === undefined ) {
-
-			interpolant = new THREE.LinearInterpolant(
-					new Float32Array( 2 ), new Float32Array( 2 ),
-						1, this._controlInterpolantsResultBuffer );
-
-			interpolant.__cacheIndex = lastActiveIndex;
-			interpolants[ lastActiveIndex ] = interpolant;
-
-		}
-
-		return interpolant;
-
-	},
-
-	_takeBackControlInterpolant: function( interpolant ) {
-
-		var interpolants = this._controlInterpolants,
-			prevIndex = interpolant.__cacheIndex,
-
-			firstInactiveIndex = -- this._nActiveControlInterpolants,
-
-			lastActiveInterpolant = interpolants[ firstInactiveIndex ];
-
-		interpolant.__cacheIndex = firstInactiveIndex;
-		interpolants[ firstInactiveIndex ] = interpolant;
-
-		lastActiveInterpolant.__cacheIndex = prevIndex;
-		interpolants[ prevIndex ] = lastActiveInterpolant;
-
-	},
-
-	_controlInterpolantsResultBuffer: new Float32Array( 1 )
-
-} );
-
-
-// File:src/animation/AnimationObjectGroup.js
-
-/**
- *
- * A group of objects that receives a shared animation state.
- *
- * Usage:
- *
- * 	-	Add objects you would otherwise pass as 'root' to the
- * 		constructor or the .clipAction method of AnimationMixer.
- *
- * 	-	Instead pass this object as 'root'.
- *
- * 	-	You can also add and remove objects later when the mixer
- * 		is running.
- *
- * Note:
- *
- *  	Objects of this class appear as one object to the mixer,
- *  	so cache control of the individual objects must be done
- *  	on the group.
- *
- * Limitation:
- *
- * 	- 	The animated properties must be compatible among the
- * 		all objects in the group.
- *
- *  -	A single property can either be controlled through a
- *  	target group or directly, but not both.
- *
- * @author tschw
- */
-
-THREE.AnimationObjectGroup = function( var_args ) {
-
-	this.uuid = THREE.Math.generateUUID();
-
-	// cached objects followed by the active ones
-	this._objects = Array.prototype.slice.call( arguments );
-
-	this.nCachedObjects_ = 0;			// threshold
-	// note: read by PropertyBinding.Composite
-
-	var indices = {};
-	this._indicesByUUID = indices;		// for bookkeeping
-
-	for ( var i = 0, n = arguments.length; i !== n; ++ i ) {
-
-		indices[ arguments[ i ].uuid ] = i;
-
-	}
-
-	this._paths = [];					// inside: string
-	this._parsedPaths = [];				// inside: { we don't care, here }
-	this._bindings = []; 				// inside: Array< PropertyBinding >
-	this._bindingsIndicesByPath = {}; 	// inside: indices in these arrays
-
-	var scope = this;
-
-	this.stats = {
-
-		objects: {
-			get total() { return scope._objects.length; },
-			get inUse() { return this.total - scope.nCachedObjects_;  }
-		},
-
-		get bindingsPerObject() { return scope._bindings.length; }
-
-	};
-
-};
-
-THREE.AnimationObjectGroup.prototype = {
-
-	constructor: THREE.AnimationObjectGroup,
-
-	add: function( var_args ) {
-
-		var objects = this._objects,
-			nObjects = objects.length,
-			nCachedObjects = this.nCachedObjects_,
-			indicesByUUID = this._indicesByUUID,
-			paths = this._paths,
-			parsedPaths = this._parsedPaths,
-			bindings = this._bindings,
-			nBindings = bindings.length;
-
-		for ( var i = 0, n = arguments.length; i !== n; ++ i ) {
-
-			var object = arguments[ i ],
-				uuid = object.uuid,
-				index = indicesByUUID[ uuid ];
-
-			if ( index === undefined ) {
-
-				// unknown object -> add it to the ACTIVE region
-
-				index = nObjects ++;
-				indicesByUUID[ uuid ] = index;
-				objects.push( object );
-
-				// accounting is done, now do the same for all bindings
-
-				for ( var j = 0, m = nBindings; j !== m; ++ j ) {
-
-					bindings[ j ].push(
-							new THREE.PropertyBinding(
-								object, paths[ j ], parsedPaths[ j ] ) );
-
-				}
-
-			} else if ( index < nCachedObjects ) {
-
-				var knownObject = objects[ index ];
-
-				// move existing object to the ACTIVE region
-
-				var firstActiveIndex = -- nCachedObjects,
-					lastCachedObject = objects[ firstActiveIndex ];
-
-				indicesByUUID[ lastCachedObject.uuid ] = index;
-				objects[ index ] = lastCachedObject;
-
-				indicesByUUID[ uuid ] = firstActiveIndex;
-				objects[ firstActiveIndex ] = object;
-
-				// accounting is done, now do the same for all bindings
-
-				for ( var j = 0, m = nBindings; j !== m; ++ j ) {
-
-					var bindingsForPath = bindings[ j ],
-						lastCached = bindingsForPath[ firstActiveIndex ],
-						binding = bindingsForPath[ index ];
-
-					bindingsForPath[ index ] = lastCached;
-
-					if ( binding === undefined ) {
-
-						// since we do not bother to create new bindings
-						// for objects that are cached, the binding may
-						// or may not exist
-
-						binding = new THREE.PropertyBinding(
-								object, paths[ j ], parsedPaths[ j ] );
-
-					}
-
-					bindingsForPath[ firstActiveIndex ] = binding;
-
-				}
-
-			} else if ( objects[ index ] !== knownObject) {
-
-				console.error( "Different objects with the same UUID " +
-						"detected. Clean the caches or recreate your " +
-						"infrastructure when reloading scenes..." );
-
-			} // else the object is already where we want it to be
-
-		} // for arguments
-
-		this.nCachedObjects_ = nCachedObjects;
-
-	},
-
-	remove: function( var_args ) {
-
-		var objects = this._objects,
-			nObjects = objects.length,
-			nCachedObjects = this.nCachedObjects_,
-			indicesByUUID = this._indicesByUUID,
-			bindings = this._bindings,
-			nBindings = bindings.length;
-
-		for ( var i = 0, n = arguments.length; i !== n; ++ i ) {
-
-			var object = arguments[ i ],
-				uuid = object.uuid,
-				index = indicesByUUID[ uuid ];
-
-			if ( index !== undefined && index >= nCachedObjects ) {
-
-				// move existing object into the CACHED region
-
-				var lastCachedIndex = nCachedObjects ++,
-					firstActiveObject = objects[ lastCachedIndex ];
-
-				indicesByUUID[ firstActiveObject.uuid ] = index;
-				objects[ index ] = firstActiveObject;
-
-				indicesByUUID[ uuid ] = lastCachedIndex;
-				objects[ lastCachedIndex ] = object;
-
-				// accounting is done, now do the same for all bindings
-
-				for ( var j = 0, m = nBindings; j !== m; ++ j ) {
-
-					var bindingsForPath = bindings[ j ],
-						firstActive = bindingsForPath[ lastCachedIndex ],
-						binding = bindingsForPath[ index ];
-
-					bindingsForPath[ index ] = firstActive;
-					bindingsForPath[ lastCachedIndex ] = binding;
-
-				}
-
-			}
-
-		} // for arguments
-
-		this.nCachedObjects_ = nCachedObjects;
-
-	},
-
-	// remove & forget
-	uncache: function( var_args ) {
-
-		var objects = this._objects,
-			nObjects = objects.length,
-			nCachedObjects = this.nCachedObjects_,
-			indicesByUUID = this._indicesByUUID,
-			bindings = this._bindings,
-			nBindings = bindings.length;
-
-		for ( var i = 0, n = arguments.length; i !== n; ++ i ) {
-
-			var object = arguments[ i ],
-				uuid = object.uuid,
-				index = indicesByUUID[ uuid ];
-
-			if ( index !== undefined ) {
-
-				delete indicesByUUID[ uuid ];
-
-				if ( index < nCachedObjects ) {
-
-					// object is cached, shrink the CACHED region
-
-					var firstActiveIndex = -- nCachedObjects,
-						lastCachedObject = objects[ firstActiveIndex ],
-						lastIndex = -- nObjects,
-						lastObject = objects[ lastIndex ];
-
-					// last cached object takes this object's place
-					indicesByUUID[ lastCachedObject.uuid ] = index;
-					objects[ index ] = lastCachedObject;
-
-					// last object goes to the activated slot and pop
-					indicesByUUID[ lastObject.uuid ] = firstActiveIndex;
-					objects[ firstActiveIndex ] = lastObject;
-					objects.pop();
-
-					// accounting is done, now do the same for all bindings
-
-					for ( var j = 0, m = nBindings; j !== m; ++ j ) {
-
-						var bindingsForPath = bindings[ j ],
-							lastCached = bindingsForPath[ firstActiveIndex ],
-							last = bindingsForPath[ lastIndex ];
-
-						bindingsForPath[ index ] = lastCached;
-						bindingsForPath[ firstActiveIndex ] = last;
-						bindingsForPath.pop();
-
-					}
-
-				} else {
-
-					// object is active, just swap with the last and pop
-
-					var lastIndex = -- nObjects,
-						lastObject = objects[ lastIndex ];
-
-					indicesByUUID[ lastObject.uuid ] = index;
-					objects[ index ] = lastObject;
-					objects.pop();
-
-					// accounting is done, now do the same for all bindings
-
-					for ( var j = 0, m = nBindings; j !== m; ++ j ) {
-
-						var bindingsForPath = bindings[ j ];
-
-						bindingsForPath[ index ] = bindingsForPath[ lastIndex ];
-						bindingsForPath.pop();
-
-					}
-
-				} // cached or active
-
-			} // if object is known
-
-		} // for arguments
-
-		this.nCachedObjects_ = nCachedObjects;
-
-	},
-
-	// Internal interface used by befriended PropertyBinding.Composite:
-
-	subscribe_: function( path, parsedPath ) {
-		// returns an array of bindings for the given path that is changed
-		// according to the contained objects in the group
-
-		var indicesByPath = this._bindingsIndicesByPath,
-			index = indicesByPath[ path ],
-			bindings = this._bindings;
-
-		if ( index !== undefined ) return bindings[ index ];
-
-		var paths = this._paths,
-			parsedPaths = this._parsedPaths,
-			objects = this._objects,
-			nObjects = objects.length,
-			nCachedObjects = this.nCachedObjects_,
-			bindingsForPath = new Array( nObjects );
-
-		index = bindings.length;
-
-		indicesByPath[ path ] = index;
-
-		paths.push( path );
-		parsedPaths.push( parsedPath );
-		bindings.push( bindingsForPath );
-
-		for ( var i = nCachedObjects,
-				n = objects.length; i !== n; ++ i ) {
-
-			var object = objects[ i ];
-
-			bindingsForPath[ i ] =
-					new THREE.PropertyBinding( object, path, parsedPath );
-
-		}
-
-		return bindingsForPath;
-
-	},
-
-	unsubscribe_: function( path ) {
-		// tells the group to forget about a property path and no longer
-		// update the array previously obtained with 'subscribe_'
-
-		var indicesByPath = this._bindingsIndicesByPath,
-			index = indicesByPath[ path ];
-
-		if ( index !== undefined ) {
-
-			var paths = this._paths,
-				parsedPaths = this._parsedPaths,
-				bindings = this._bindings,
-				lastBindingsIndex = bindings.length - 1,
-				lastBindings = bindings[ lastBindingsIndex ],
-				lastBindingsPath = path[ lastBindingsIndex ];
-
-			indicesByPath[ lastBindingsPath ] = index;
-
-			bindings[ index ] = lastBindings;
-			bindings.pop();
-
-			parsedPaths[ index ] = parsedPaths[ lastBindingsIndex ];
-			parsedPaths.pop();
-
-			paths[ index ] = paths[ lastBindingsIndex ];
-			paths.pop();
-
-		}
-
-	}
-
-};
-
-
-// File:src/animation/AnimationUtils.js
-
-/**
- * @author tschw
- * @author Ben Houston / http://clara.io/
- * @author David Sarno / http://lighthaus.us/
- */
-
-THREE.AnimationUtils = {
-
-	// same as Array.prototype.slice, but also works on typed arrays
-	arraySlice: function( array, from, to ) {
-
-		if ( THREE.AnimationUtils.isTypedArray( array ) ) {
-
-			return new array.constructor( array.subarray( from, to ) );
-
-		}
-
-		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 );
-
-		}
-
-	}
-
-};
-
-// File:src/animation/KeyframeTrack.js
-
-/**
- *
- * A timed sequence of keyframes for a specific property.
- *
- *
- * @author Ben Houston / http://clara.io/
- * @author David Sarno / http://lighthaus.us/
- * @author tschw
- */
-
-THREE.KeyframeTrack = function ( name, times, values, interpolation ) {
-
-	if( name === undefined ) throw new Error( "track name is undefined" );
-
-	if( times === undefined || times.length === 0 ) {
-
-		throw new Error( "no keyframes in track named " + name );
-
-	}
-
-	this.name = name;
-
-	this.times = THREE.AnimationUtils.convertArray( times, this.TimeBufferType );
-	this.values = THREE.AnimationUtils.convertArray( values, this.ValueBufferType );
-
-	this.setInterpolation( interpolation || this.DefaultInterpolation );
-
-	this.validate();
-	this.optimize();
-
-};
-
-THREE.KeyframeTrack.prototype = {
-
-	constructor: THREE.KeyframeTrack,
-
-	TimeBufferType: Float32Array,
-	ValueBufferType: Float32Array,
-
-	DefaultInterpolation: THREE.InterpolateLinear,
-
-	InterpolantFactoryMethodDiscrete: function( result ) {
-
-		return new THREE.DiscreteInterpolant(
-				this.times, this.values, this.getValueSize(), result );
-
-	},
-
-	InterpolantFactoryMethodLinear: function( result ) {
-
-		return new THREE.LinearInterpolant(
-				this.times, this.values, this.getValueSize(), result );
-
-	},
-
-	InterpolantFactoryMethodSmooth: function( result ) {
-
-		return new THREE.CubicInterpolant(
-				this.times, this.values, this.getValueSize(), result );
-
-	},
-
-	setInterpolation: function( interpolation ) {
-
-		var factoryMethod = undefined;
-
-		switch ( interpolation ) {
-
-			case THREE.InterpolateDiscrete:
-
-				factoryMethod = this.InterpolantFactoryMethodDiscrete;
-
-				break;
-
-			case THREE.InterpolateLinear:
-
-				factoryMethod = this.InterpolantFactoryMethodLinear;
-
-				break;
-
-			case THREE.InterpolateSmooth:
-
-				factoryMethod = this.InterpolantFactoryMethodSmooth;
-
-				break;
-
-		}
-
-		if ( factoryMethod === undefined ) {
-
-			var message = "unsupported interpolation for " +
-					this.ValueTypeName + " keyframe track named " + this.name;
-
-			if ( this.createInterpolant === undefined ) {
-
-				// fall back to default, unless the default itself is messed up
-				if ( interpolation !== this.DefaultInterpolation ) {
-
-					this.setInterpolation( this.DefaultInterpolation );
-
-				} else {
-
-					throw new Error( message ); // fatal, in this case
-
-				}
-
-			}
-
-			console.warn( message );
-			return;
-
-		}
-
-		this.createInterpolant = factoryMethod;
-
-	},
-
-	getInterpolation: function() {
-
-		switch ( this.createInterpolant ) {
-
-			case this.InterpolantFactoryMethodDiscrete:
-
-				return THREE.InterpolateDiscrete;
-
-			case this.InterpolantFactoryMethodLinear:
-
-				return THREE.InterpolateLinear;
-
-			case this.InterpolantFactoryMethodSmooth:
-
-				return THREE.InterpolateSmooth;
-
-		}
-
-	},
-
-	getValueSize: function() {
-
-		return this.values.length / this.times.length;
-
-	},
-
-	// move all keyframes either forwards or backwards in time
-	shift: function( timeOffset ) {
-
-		if( timeOffset !== 0.0 ) {
-
-			var times = this.times;
-
-			for( var i = 0, n = times.length; i !== n; ++ i ) {
-
-				times[ i ] += timeOffset;
-
-			}
-
-		}
-
-		return this;
-
-	},
-
-	// scale all keyframe times by a factor (useful for frame <-> 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 ] < startTime ) ++ from;
-		while ( to !== -1 && times[ to ] > 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 = THREE.AnimationUtils.arraySlice( times, from, to );
-			this.values = THREE.AnimationUtils.
-					arraySlice( this.values, from * stride, to * stride );
-
-		}
-
-		return this;
-
-	},
-
-	// ensure we do not get a GarbageInGarbageOut situation, make sure tracks are at least minimally viable
-	validate: function() {
-
-		var valid = true;
-
-		var valueSize = this.getValueSize();
-		if ( valueSize - Math.floor( valueSize ) !== 0 ) {
-
-			console.error( "invalid value size in track", this );
-			valid = false;
-
-		}
-
-		var times = this.times,
-			values = this.values,
-
-			nKeys = times.length;
-
-		if( nKeys === 0 ) {
-
-			console.error( "track is empty", this );
-			valid = false;
-
-		}
-
-		var prevTime = null;
-
-		for( var i = 0; i !== nKeys; i ++ ) {
-
-			var currTime = times[ i ];
-
-			if ( typeof currTime === 'number' && isNaN( currTime ) ) {
-
-				console.error( "time is not a valid number", this, i, currTime );
-				valid = false;
-				break;
-
-			}
-
-			if( prevTime !== null && prevTime > currTime ) {
-
-				console.error( "out of order keys", this, i, currTime, prevTime );
-				valid = false;
-				break;
-
-			}
-
-			prevTime = currTime;
-
-		}
-
-		if ( values !== undefined ) {
-
-			if ( THREE.AnimationUtils.isTypedArray( values ) ) {
-
-				for ( var i = 0, n = values.length; i !== n; ++ i ) {
-
-					var value = values[ i ];
-
-					if ( isNaN( value ) ) {
-
-						console.error( "value is not a valid number", this, i, value );
-						valid = false;
-						break;
-
-					}
-
-				}
-
-			}
-
-		}
-
-		return valid;
-
-	},
-
-	// removes equivalent sequential keys as common in morph target sequences
-	// (0,0,0,0,1,1,1,0,0,0,0,0,0,0) --> (0,0,1,1,0,0)
-	optimize: function() {
-
-		var times = this.times,
-			values = this.values,
-			stride = this.getValueSize(),
-
-			writeIndex = 1;
-
-		for( var i = 1, n = times.length - 1; i <= n; ++ i ) {
-
-			var keep = false;
-
-			var time = times[ i ];
-			var timeNext = times[ i + 1 ];
-
-			// remove adjacent keyframes scheduled at the same time
-
-			if ( time !== timeNext && ( i !== 1 || time !== time[ 0 ] ) ) {
-
-				// remove unnecessary keyframes same as their neighbors
-				var offset = i * stride,
-					offsetP = offset - stride,
-					offsetN = offset + stride;
-
-				for ( var j = 0; j !== stride; ++ j ) {
-
-					var value = values[ offset + j ];
-
-					if ( value !== values[ offsetP + j ] ||
-							value !== values[ offsetN + j ] ) {
-
-						keep = true;
-						break;
-
-					}
-
-				}
-
-			}
-
-			// in-place compaction
-
-			if ( keep ) {
-
-				if ( i !== writeIndex ) {
-
-					times[ writeIndex ] = times[ i ];
-
-					var readOffset = i * stride,
-						writeOffset = writeIndex * stride;
-
-					for ( var j = 0; j !== stride; ++ j ) {
-
-						values[ writeOffset + j ] = values[ readOffset + j ];
-
-					}
-
-
-				}
-
-				++ writeIndex;
-
-			}
-
-		}
-
-		if ( writeIndex !== times.length ) {
-
-			this.times = THREE.AnimationUtils.arraySlice( times, 0, writeIndex );
-			this.values = THREE.AnimationUtils.arraySlice( values, 0, writeIndex * stride );
-
-		}
-
-		return this;
-
-	}
-
-};
-
-// Static methods:
-
-Object.assign( THREE.KeyframeTrack, {
-
-	// Serialization (in static context, because of constructor invocation
-	// and automatic invocation of .toJSON):
-
-	parse: function( json ) {
-
-		if( json.type === undefined ) {
-
-			throw new Error( "track type undefined, can not parse" );
-
-		}
-
-		var trackType = THREE.KeyframeTrack._getTrackTypeForValueTypeName( json.type );
-
-		if ( json.times === undefined ) {
-
-			console.warn( "legacy JSON format detected, converting" );
-
-			var times = [], values = [];
-
-			THREE.AnimationUtils.flattenJSON( json.keys, times, values, 'value' );
-
-			json.times = times;
-			json.values = values;
-
-		}
-
-		// derived classes can define a static parse method
-		if ( trackType.parse !== undefined ) {
-
-			return trackType.parse( json );
-
-		} else {
-
-			// by default, we asssume a constructor compatible with the base
-			return new trackType(
-					json.name, json.times, json.values, json.interpolation );
-
-		}
-
-	},
-
-	toJSON: function( track ) {
-
-		var trackType = track.constructor;
-
-		var json;
-
-		// derived classes can define a static toJSON method
-		if ( trackType.toJSON !== undefined ) {
-
-			json = trackType.toJSON( track );
-
-		} else {
-
-			// by default, we assume the data can be serialized as-is
-			json = {
-
-				'name': track.name,
-				'times': THREE.AnimationUtils.convertArray( track.times, Array ),
-				'values': THREE.AnimationUtils.convertArray( track.values, Array )
-
-			};
-
-			var interpolation = track.getInterpolation();
-
-			if ( interpolation !== track.DefaultInterpolation ) {
-
-				json.interpolation = interpolation;
-
-			}
-
-		}
-
-		json.type = track.ValueTypeName; // mandatory
-
-		return json;
-
-	},
-
-	_getTrackTypeForValueTypeName: function( typeName ) {
-
-		switch( typeName.toLowerCase() ) {
-
-			case "scalar":
-			case "double":
-			case "float":
-			case "number":
-			case "integer":
-
-				return THREE.NumberKeyframeTrack;
-
-			case "vector":
-			case "vector2":
-			case "vector3":
-			case "vector4":
-
-				return THREE.VectorKeyframeTrack;
-
-			case "color":
-
-				return THREE.ColorKeyframeTrack;
-
-			case "quaternion":
-
-				return THREE.QuaternionKeyframeTrack;
-
-			case "bool":
-			case "boolean":
-
-				return THREE.BooleanKeyframeTrack;
-
-			case "string":
-
-				return THREE.StringKeyframeTrack;
-
-		};
-
-		throw new Error( "Unsupported typeName: " + typeName );
-
-	}
-
-} );
-
-// File:src/animation/PropertyBinding.js
-
-/**
- *
- * A reference to a real property in the scene graph.
- *
- *
- * @author Ben Houston / http://clara.io/
- * @author David Sarno / http://lighthaus.us/
- * @author tschw
- */
-
-THREE.PropertyBinding = function ( rootNode, path, parsedPath ) {
-
-	this.path = path;
-	this.parsedPath = parsedPath ||
-			THREE.PropertyBinding.parseTrackName( path );
-
-	this.node = THREE.PropertyBinding.findNode(
-			rootNode, this.parsedPath.nodeName ) || rootNode;
-
-	this.rootNode = rootNode;
-
-};
-
-THREE.PropertyBinding.prototype = {
-
-	constructor: THREE.PropertyBinding,
-
-	getValue: function getValue_unbound( targetArray, offset ) {
-
-		this.bind();
-		this.getValue( targetArray, offset );
-
-		// Note: This class uses a State pattern on a per-method basis:
-		// 'bind' sets 'this.getValue' / 'setValue' and shadows the
-		// prototype version of these methods with one that represents
-		// the bound state. When the property is not found, the methods
-		// become no-ops.
-
-	},
-
-	setValue: function getValue_unbound( sourceArray, offset ) {
-
-		this.bind();
-		this.setValue( sourceArray, offset );
-
-	},
-
-	// create getter / setter pair for a property in the scene graph
-	bind: function() {
-
-		var targetObject = this.node,
-			parsedPath = this.parsedPath,
-
-			objectName = parsedPath.objectName,
-			propertyName = parsedPath.propertyName,
-			propertyIndex = parsedPath.propertyIndex;
-
-		if ( ! targetObject ) {
-
-			targetObject = THREE.PropertyBinding.findNode(
-					this.rootNode, parsedPath.nodeName ) || this.rootNode;
-
-			this.node = targetObject;
-
-		}
-
-		// set fail state so we can just 'return' on error
-		this.getValue = this._getValue_unavailable;
-		this.setValue = this._setValue_unavailable;
-
- 		// ensure there is a value node
-		if ( ! targetObject ) {
-
-			console.error( "  trying to update node for track: " + this.path + " but it wasn't found." );
-			return;
-
-		}
-
-		if( objectName ) {
-
-			var objectIndex = parsedPath.objectIndex;
-
-			// special cases were we need to reach deeper into the hierarchy to get the face materials....
-			switch ( objectName ) {
-
-				case 'materials':
-
-					if( ! targetObject.material ) {
-
-						console.error( '  can not bind to material as node does not have a material', this );
-						return;
-
-					}
-
-					if( ! targetObject.material.materials ) {
-
-						console.error( '  can not bind to material.materials as node.material does not have a materials array', this );
-						return;
-
-					}
-
-					targetObject = targetObject.material.materials;
-
-					break;
-
-				case 'bones':
-
-					if( ! targetObject.skeleton ) {
-
-						console.error( '  can not bind to bones as node does not have a skeleton', this );
-						return;
-
-					}
-
-					// potential future optimization: skip this if propertyIndex is already an integer
-					// and convert the integer string to a true integer.
-
-					targetObject = targetObject.skeleton.bones;
-
-					// support resolving morphTarget names into indices.
-					for ( var i = 0; i < targetObject.length; i ++ ) {
-
-						if ( targetObject[i].name === objectIndex ) {
-
-							objectIndex = i;
-							break;
-
-						}
-
-					}
-
-					break;
-
-				default:
-
-					if ( targetObject[ objectName ] === undefined ) {
-
-						console.error( '  can not bind to objectName of node, undefined', this );
-						return;
-
-					}
-
-					targetObject = targetObject[ objectName ];
-
-			}
-
-
-			if ( objectIndex !== undefined ) {
-
-				if( targetObject[ objectIndex ] === undefined ) {
-
-					console.error( "  trying to bind to objectIndex of objectName, but is undefined:", this, targetObject );
-					return;
-
-				}
-
-				targetObject = targetObject[ objectIndex ];
-
-			}
-
-		}
-
-		// resolve property
-		var nodeProperty = targetObject[ propertyName ];
-
-		if ( ! nodeProperty ) {
-
-			var nodeName = parsedPath.nodeName;
-
-			console.error( "  trying to update property for track: " + nodeName +
-					'.' + propertyName + " but it wasn't found.", targetObject );
-			return;
-
-		}
-
-		// determine versioning scheme
-		var versioning = this.Versioning.None;
-
-		if ( targetObject.needsUpdate !== undefined ) { // material
-
-			versioning = this.Versioning.NeedsUpdate;
-			this.targetObject = targetObject;
-
-		} else if ( targetObject.matrixWorldNeedsUpdate !== undefined ) { // node transform
-
-			versioning = this.Versioning.MatrixWorldNeedsUpdate;
-			this.targetObject = targetObject;
-
-		}
-
-		// determine how the property gets bound
-		var bindingType = this.BindingType.Direct;
-
-		if ( propertyIndex !== undefined ) {
-			// access a sub element of the property array (only primitives are supported right now)
-
-			if ( propertyName === "morphTargetInfluences" ) {
-				// potential optimization, skip this if propertyIndex is already an integer, and convert the integer string to a true integer.
-
-				// support resolving morphTarget names into indices.
-				if ( ! targetObject.geometry ) {
-
-					console.error( '  can not bind to morphTargetInfluences becasuse node does not have a geometry', this );
-					return;
-
-				}
-
-				if ( ! targetObject.geometry.morphTargets ) {
-
-					console.error( '  can not bind to morphTargetInfluences becasuse node does not have a geometry.morphTargets', this );
-					return;
-
-				}
-
-				for ( var i = 0; i < this.node.geometry.morphTargets.length; i ++ ) {
-
-					if ( targetObject.geometry.morphTargets[i].name === propertyIndex ) {
-
-						propertyIndex = i;
-						break;
-
-					}
-
-				}
-
-			}
-
-			bindingType = this.BindingType.ArrayElement;
-
-			this.resolvedProperty = nodeProperty;
-			this.propertyIndex = propertyIndex;
-
-		} else if ( nodeProperty.fromArray !== undefined && nodeProperty.toArray !== undefined ) {
-			// must use copy for Object3D.Euler/Quaternion
-
-			bindingType = this.BindingType.HasFromToArray;
-
-			this.resolvedProperty = nodeProperty;
-
-		} else if ( nodeProperty.length !== undefined ) {
-
-			bindingType = this.BindingType.EntireArray;
-
-			this.resolvedProperty = nodeProperty;
-
-		} else {
-
-			this.propertyName = propertyName;
-
-		}
-
-		// select getter / setter
-		this.getValue = this.GetterByBindingType[ bindingType ];
-		this.setValue = this.SetterByBindingTypeAndVersioning[ bindingType ][ versioning ];
-
-	},
-
-	unbind: function() {
-
-		this.node = null;
-
-		// back to the prototype version of getValue / setValue
-		// note: avoiding to mutate the shape of 'this' via 'delete'
-		this.getValue = this._getValue_unbound;
-		this.setValue = this._setValue_unbound;
-
-	}
-
-};
-
-Object.assign( THREE.PropertyBinding.prototype, { // prototype, continued
-
-	// these are used to "bind" a nonexistent property
-	_getValue_unavailable: function() {},
-	_setValue_unavailable: function() {},
-
-	// initial state of these methods that calls 'bind'
-	_getValue_unbound: THREE.PropertyBinding.prototype.getValue,
-	_setValue_unbound: THREE.PropertyBinding.prototype.setValue,
-
-	BindingType: {
-		Direct: 0,
-		EntireArray: 1,
-		ArrayElement: 2,
-		HasFromToArray: 3
-	},
-
-	Versioning: {
-		None: 0,
-		NeedsUpdate: 1,
-		MatrixWorldNeedsUpdate: 2
-	},
-
-	GetterByBindingType: [
-
-		function getValue_direct( buffer, offset ) {
-
-			buffer[ offset ] = this.node[ this.propertyName ];
-
-		},
-
-		function getValue_array( buffer, offset ) {
-
-			var source = this.resolvedProperty;
-
-			for ( var i = 0, n = source.length; i !== n; ++ i ) {
-
-				buffer[ offset ++ ] = source[ i ];
-
-			}
-
-		},
-
-		function getValue_arrayElement( buffer, offset ) {
-
-			buffer[ offset ] = this.resolvedProperty[ this.propertyIndex ];
-
-		},
-
-		function getValue_toArray( buffer, offset ) {
-
-			this.resolvedProperty.toArray( buffer, offset );
-
-		}
-
-	],
-
-	SetterByBindingTypeAndVersioning: [
-
-		[
-			// Direct
-
-			function setValue_direct( buffer, offset ) {
-
-				this.node[ this.propertyName ] = buffer[ offset ];
-
-			},
-
-			function setValue_direct_setNeedsUpdate( buffer, offset ) {
-
-				this.node[ this.propertyName ] = buffer[ offset ];
-				this.targetObject.needsUpdate = true;
-
-			},
-
-			function setValue_direct_setMatrixWorldNeedsUpdate( buffer, offset ) {
-
-				this.node[ this.propertyName ] = buffer[ offset ];
-				this.targetObject.matrixWorldNeedsUpdate = true;
-
-			}
-
-		], [
-
-			// EntireArray
-
-			function setValue_array( buffer, offset ) {
-
-				var dest = this.resolvedProperty;
-
-				for ( var i = 0, n = dest.length; i !== n; ++ i ) {
-
-					dest[ i ] = buffer[ offset ++ ];
-
-				}
-
-			},
-
-			function setValue_array_setNeedsUpdate( buffer, offset ) {
-
-				var dest = this.resolvedProperty;
-
-				for ( var i = 0, n = dest.length; i !== n; ++ i ) {
-
-					dest[ i ] = buffer[ offset ++ ];
-
-				}
-
-				this.targetObject.needsUpdate = true;
-
-			},
-
-			function setValue_array_setMatrixWorldNeedsUpdate( buffer, offset ) {
-
-				var dest = this.resolvedProperty;
-
-				for ( var i = 0, n = dest.length; i !== n; ++ i ) {
-
-					dest[ i ] = buffer[ offset ++ ];
-
-				}
-
-				this.targetObject.matrixWorldNeedsUpdate = true;
-
-			}
-
-		], [
-
-			// ArrayElement
-
-			function setValue_arrayElement( buffer, offset ) {
-
-				this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];
-
-			},
-
-			function setValue_arrayElement_setNeedsUpdate( buffer, offset ) {
-
-				this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];
-				this.targetObject.needsUpdate = true;
-
-			},
-
-			function setValue_arrayElement_setMatrixWorldNeedsUpdate( buffer, offset ) {
-
-				this.resolvedProperty[ this.propertyIndex ] = buffer[ offset ];
-				this.targetObject.matrixWorldNeedsUpdate = true;
-
-			}
-
-		], [
-
-			// HasToFromArray
-
-			function setValue_fromArray( buffer, offset ) {
-
-				this.resolvedProperty.fromArray( buffer, offset );
-
-			},
-
-			function setValue_fromArray_setNeedsUpdate( buffer, offset ) {
-
-				this.resolvedProperty.fromArray( buffer, offset );
-				this.targetObject.needsUpdate = true;
-
-			},
-
-			function setValue_fromArray_setMatrixWorldNeedsUpdate( buffer, offset ) {
-
-				this.resolvedProperty.fromArray( buffer, offset );
-				this.targetObject.matrixWorldNeedsUpdate = true;
-
-			}
-
-		]
-
-	]
-
-} );
-
-THREE.PropertyBinding.Composite =
-		function( targetGroup, path, optionalParsedPath ) {
-
-	var parsedPath = optionalParsedPath ||
-			THREE.PropertyBinding.parseTrackName( path );
-
-	this._targetGroup = targetGroup;
-	this._bindings = targetGroup.subscribe_( path, parsedPath );
-
-};
-
-THREE.PropertyBinding.Composite.prototype = {
-
-	constructor: THREE.PropertyBinding.Composite,
-
-	getValue: function( array, offset ) {
-
-		this.bind(); // bind all binding
-
-		var firstValidIndex = this._targetGroup.nCachedObjects_,
-			binding = this._bindings[ firstValidIndex ];
-
-		// and only call .getValue on the first
-		if ( binding !== undefined ) binding.getValue( array, offset );
-
-	},
-
-	setValue: function( array, offset ) {
-
-		var bindings = this._bindings;
-
-		for ( var i = this._targetGroup.nCachedObjects_,
-				n = bindings.length; i !== n; ++ i ) {
-
-			bindings[ i ].setValue( array, offset );
-
-		}
-
-	},
-
-	bind: function() {
-
-		var bindings = this._bindings;
-
-		for ( var i = this._targetGroup.nCachedObjects_,
-				n = bindings.length; i !== n; ++ i ) {
-
-			bindings[ i ].bind();
-
-		}
-
-	},
-
-	unbind: function() {
-
-		var bindings = this._bindings;
-
-		for ( var i = this._targetGroup.nCachedObjects_,
-				n = bindings.length; i !== n; ++ i ) {
-
-			bindings[ i ].unbind();
-
-		}
-
-	}
-
-};
-
-THREE.PropertyBinding.create = function( root, path, parsedPath ) {
-
-	if ( ! ( root instanceof THREE.AnimationObjectGroup ) ) {
-
-		return new THREE.PropertyBinding( root, path, parsedPath );
-
-	} else {
-
-		return new THREE.PropertyBinding.Composite( root, path, parsedPath );
-
-	}
-
-};
-
-THREE.PropertyBinding.parseTrackName = function( trackName ) {
-
-	// matches strings in the form of:
-	//    nodeName.property
-	//    nodeName.property[accessor]
-	//    nodeName.material.property[accessor]
-	//    uuid.property[accessor]
-	//    uuid.objectName[objectIndex].propertyName[propertyIndex]
-	//    parentName/nodeName.property
-	//    parentName/parentName/nodeName.property[index]
-	//	  .bone[Armature.DEF_cog].position
-	// created and tested via https://regex101.com/#javascript
-
-	var re = /^(([\w]+\/)*)([\w-\d]+)?(\.([\w]+)(\[([\w\d\[\]\_.:\- ]+)\])?)?(\.([\w.]+)(\[([\w\d\[\]\_. ]+)\])?)$/;
-	var matches = re.exec(trackName);
-
-	if( ! matches ) {
-		throw new Error( "cannot parse trackName at all: " + trackName );
-	}
-
-    if (matches.index === re.lastIndex) {
-        re.lastIndex++;
-    }
-
-	var results = {
-		// directoryName: matches[1], // (tschw) currently unused
-		nodeName: matches[3], 	// allowed to be null, specified root node.
-		objectName: matches[5],
-		objectIndex: matches[7],
-		propertyName: matches[9],
-		propertyIndex: matches[11]	// allowed to be null, specifies that the whole property is set.
-	};
-
-	if( results.propertyName === null || results.propertyName.length === 0 ) {
-		throw new Error( "can not parse propertyName from trackName: " + trackName );
-	}
-
-	return results;
-
-};
-
-THREE.PropertyBinding.findNode = function( root, nodeName ) {
-
-	if( ! nodeName || nodeName === "" || nodeName === "root" || nodeName === "." || nodeName === -1 || nodeName === root.name || nodeName === root.uuid ) {
-
-		return root;
-
-	}
-
-	// search into skeleton bones.
-	if( root.skeleton ) {
-
-		var searchSkeleton = function( skeleton ) {
-
-			for( var i = 0; i < skeleton.bones.length; i ++ ) {
-
-				var bone = skeleton.bones[i];
-
-				if( bone.name === nodeName ) {
-
-					return bone;
-
-				}
-			}
-
-			return null;
-
-		};
-
-		var bone = searchSkeleton( root.skeleton );
-
-		if( bone ) {
-
-			return bone;
-
-		}
-	}
-
-	// search into node subtree.
-	if( root.children ) {
-
-		var searchNodeSubtree = function( children ) {
-
-			for( var i = 0; i < children.length; i ++ ) {
-
-				var childNode = children[i];
-
-				if( childNode.name === nodeName || childNode.uuid === nodeName ) {
-
-					return childNode;
-
-				}
-
-				var result = searchNodeSubtree( childNode.children );
-
-				if( result ) return result;
-
-			}
-
-			return null;
-
-		};
-
-		var subTreeNode = searchNodeSubtree( root.children );
-
-		if( subTreeNode ) {
-
-			return subTreeNode;
-
-		}
-
-	}
-
-	return null;
-
-}
-
-// File:src/animation/PropertyMixer.js
-
-/**
- *
- * Buffered scene graph property that allows weighted accumulation.
- *
- *
- * @author Ben Houston / http://clara.io/
- * @author David Sarno / http://lighthaus.us/
- * @author tschw
- */
-
-THREE.PropertyMixer = function ( binding, typeName, valueSize ) {
-
-	this.binding = binding;
-	this.valueSize = valueSize;
-
-	var bufferType = Float64Array,
-		mixFunction;
-
-	switch ( typeName ) {
-
-		case 'quaternion':			mixFunction = this._slerp;		break;
-
-		case 'string':
-		case 'bool':
-
-			bufferType = Array,		mixFunction = this._select;		break;
-
-		default:					mixFunction = this._lerp;
-
-	}
-
-	this.buffer = new bufferType( valueSize * 4 );
-	// layout: [ incoming | accu0 | accu1 | orig ]
-	//
-	// interpolators can use .buffer as their .result
-	// the data then goes to 'incoming'
-	//
-	// 'accu0' and 'accu1' are used frame-interleaved for
-	// the cumulative result and are compared to detect
-	// changes
-	//
-	// 'orig' stores the original state of the property
-
-	this._mixBufferRegion = mixFunction;
-
-	this.cumulativeWeight = 0;
-
-	this.useCount = 0;
-	this.referenceCount = 0;
-
-};
-
-THREE.PropertyMixer.prototype = {
-
-	constructor: THREE.PropertyMixer,
-
-	// accumulate data in the 'incoming' region into 'accu<i>'
-	accumulate: function( accuIndex, weight ) {
-
-		// note: happily accumulating nothing when weight = 0, the caller knows
-		// the weight and shouldn't have made the call in the first place
-
-		var buffer = this.buffer,
-			stride = this.valueSize,
-			offset = accuIndex * stride + stride,
-
-			currentWeight = this.cumulativeWeight;
-
-		if ( currentWeight === 0 ) {
-
-			// accuN := incoming * weight
-
-			for ( var i = 0; i !== stride; ++ i ) {
-
-				buffer[ offset + i ] = buffer[ i ];
-
-			}
-
-			currentWeight = weight;
-
-		} else {
-
-			// accuN := accuN + incoming * weight
-
-			currentWeight += weight;
-			var mix = weight / currentWeight;
-			this._mixBufferRegion( buffer, offset, 0, mix, stride );
-
-		}
-
-		this.cumulativeWeight = currentWeight;
-
-	},
-
-	// apply the state of 'accu<i>' to the binding when accus differ
-	apply: function( accuIndex ) {
-
-		var stride = this.valueSize,
-			buffer = this.buffer,
-			offset = accuIndex * stride + stride,
-
-			weight = this.cumulativeWeight,
-
-			binding = this.binding;
-
-		this.cumulativeWeight = 0;
-
-		if ( weight < 1 ) {
-
-			// accuN := accuN + original * ( 1 - cumulativeWeight )
-
-			var originalValueOffset = stride * 3;
-
-			this._mixBufferRegion(
-					buffer, offset, originalValueOffset, 1 - weight, stride );
-
-		}
-
-		for ( var i = stride, e = stride + stride; i !== e; ++ i ) {
-
-			if ( buffer[ i ] !== buffer[ i + stride ] ) {
-
-				// value has changed -> update scene graph
-
-				binding.setValue( buffer, offset );
-				break;
-
-			}
-
-		}
-
-	},
-
-	// remember the state of the bound property and copy it to both accus
-	saveOriginalState: function() {
-
-		var binding = this.binding;
-
-		var buffer = this.buffer,
-			stride = this.valueSize,
-
-			originalValueOffset = stride * 3;
-
-		binding.getValue( buffer, originalValueOffset );
-
-		// accu[0..1] := orig -- initially detect changes against the original
-		for ( var i = stride, e = originalValueOffset; i !== e; ++ i ) {
-
-			buffer[ i ] = buffer[ originalValueOffset + ( i % stride ) ];
-
-		}
-
-		this.cumulativeWeight = 0;
-
-	},
-
-	// apply the state previously taken via 'saveOriginalState' to the binding
-	restoreOriginalState: function() {
-
-		var originalValueOffset = this.valueSize * 3;
-		this.binding.setValue( this.buffer, originalValueOffset );
-
-	},
-
-
-	// mix functions
-
-	_select: function( buffer, dstOffset, srcOffset, t, stride ) {
-
-		if ( t >= 0.5 ) {
-
-			for ( var i = 0; i !== stride; ++ i ) {
-
-				buffer[ dstOffset + i ] = buffer[ srcOffset + i ];
-
-			}
-
-		}
-
-	},
-
-	_slerp: function( buffer, dstOffset, srcOffset, t, stride ) {
-
-		THREE.Quaternion.slerpFlat( buffer, dstOffset,
-				buffer, dstOffset, buffer, srcOffset, t );
-
-	},
-
-	_lerp: function( buffer, dstOffset, srcOffset, t, stride ) {
-
-		var s = 1 - t;
-
-		for ( var i = 0; i !== stride; ++ i ) {
-
-			var j = dstOffset + i;
-
-			buffer[ j ] = buffer[ j ] * s + buffer[ srcOffset + i ] * t;
-
-		}
-
-	}
-
-};
-
-// File:src/animation/tracks/BooleanKeyframeTrack.js
-
-/**
- *
- * A Track of Boolean keyframe values.
- *
- *
- * @author Ben Houston / http://clara.io/
- * @author David Sarno / http://lighthaus.us/
- * @author tschw
- */
-
-THREE.BooleanKeyframeTrack = function ( name, times, values ) {
-
-	THREE.KeyframeTrack.call( this, name, times, values );
-
-};
-
-THREE.BooleanKeyframeTrack.prototype =
-		Object.assign( Object.create( THREE.KeyframeTrack.prototype ), {
-
-	constructor: THREE.BooleanKeyframeTrack,
-
-	ValueTypeName: 'bool',
-	ValueBufferType: Array,
-
-	DefaultInterpolation: THREE.InterpolateDiscrete,
-
-	InterpolantFactoryMethodLinear: undefined,
-	InterpolantFactoryMethodSmooth: undefined
-
-	// Note: Actually this track could have a optimized / compressed
-	// representation of a single value and a custom interpolant that
-	// computes "firstValue ^ isOdd( index )".
-
-} );
-
-// File:src/animation/tracks/ColorKeyframeTrack.js
-
-/**
- *
- * A Track of keyframe values that represent color.
- *
- *
- * @author Ben Houston / http://clara.io/
- * @author David Sarno / http://lighthaus.us/
- * @author tschw
- */
-
-THREE.ColorKeyframeTrack = function ( name, times, values, interpolation ) {
-
-	THREE.KeyframeTrack.call( this, name, times, values, interpolation );
-
-};
-
-THREE.ColorKeyframeTrack.prototype =
-		Object.assign( Object.create( THREE.KeyframeTrack.prototype ), {
-
-	constructor: THREE.ColorKeyframeTrack,
-
-	ValueTypeName: 'color'
-
-	// ValueBufferType is inherited
-
-	// DefaultInterpolation is inherited
-
-
-	// Note: Very basic implementation and nothing special yet.
-	// However, this is the place for color space parameterization.
-
-} );
-
-// File:src/animation/tracks/NumberKeyframeTrack.js
-
-/**
- *
- * A Track of numeric keyframe values.
- *
- * @author Ben Houston / http://clara.io/
- * @author David Sarno / http://lighthaus.us/
- * @author tschw
- */
-
-THREE.NumberKeyframeTrack = function ( name, times, values, interpolation ) {
-
-	THREE.KeyframeTrack.call( this, name, times, values, interpolation );
-
-};
-
-THREE.NumberKeyframeTrack.prototype =
-		Object.assign( Object.create( THREE.KeyframeTrack.prototype ), {
-
-	constructor: THREE.NumberKeyframeTrack,
-
-	ValueTypeName: 'number',
-
-	// ValueBufferType is inherited
-
-	// DefaultInterpolation is inherited
-
-} );
-
-// File:src/animation/tracks/QuaternionKeyframeTrack.js
-
-/**
- *
- * A Track of quaternion keyframe values.
- *
- * @author Ben Houston / http://clara.io/
- * @author David Sarno / http://lighthaus.us/
- * @author tschw
- */
-
-THREE.QuaternionKeyframeTrack = function ( name, times, values, interpolation ) {
-
-	THREE.KeyframeTrack.call( this, name, times, values, interpolation );
-
-};
-
-THREE.QuaternionKeyframeTrack.prototype =
-		Object.assign( Object.create( THREE.KeyframeTrack.prototype ), {
-
-	constructor: THREE.QuaternionKeyframeTrack,
-
-	ValueTypeName: 'quaternion',
-
-	// ValueBufferType is inherited
-
-	DefaultInterpolation: THREE.InterpolateLinear,
-
-	InterpolantFactoryMethodLinear: function( result ) {
-
-		return new THREE.QuaternionLinearInterpolant(
-				this.times, this.values, this.getValueSize(), result );
-
-	},
-
-	InterpolantFactoryMethodSmooth: undefined // not yet implemented
-
-} );
-
-// File:src/animation/tracks/StringKeyframeTrack.js
-
-/**
- *
- * A Track that interpolates Strings
- *
- *
- * @author Ben Houston / http://clara.io/
- * @author David Sarno / http://lighthaus.us/
- * @author tschw
- */
-
-THREE.StringKeyframeTrack = function ( name, times, values, interpolation ) {
-
-	THREE.KeyframeTrack.call( this, name, times, values, interpolation );
-
-};
-
-THREE.StringKeyframeTrack.prototype =
-		Object.assign( Object.create( THREE.KeyframeTrack.prototype ), {
-
-	constructor: THREE.StringKeyframeTrack,
-
-	ValueTypeName: 'string',
-	ValueBufferType: Array,
-
-	DefaultInterpolation: THREE.InterpolateDiscrete,
-
-	InterpolantFactoryMethodLinear: undefined,
-
-	InterpolantFactoryMethodSmooth: undefined
-
-} );
-
-// File:src/animation/tracks/VectorKeyframeTrack.js
-
-/**
- *
- * A Track of vectored keyframe values.
- *
- *
- * @author Ben Houston / http://clara.io/
- * @author David Sarno / http://lighthaus.us/
- * @author tschw
- */
-
-THREE.VectorKeyframeTrack = function ( name, times, values, interpolation ) {
-
-	THREE.KeyframeTrack.call( this, name, times, values, interpolation );
-
-};
-
-THREE.VectorKeyframeTrack.prototype =
-		Object.assign( Object.create( THREE.KeyframeTrack.prototype ), {
-
-	constructor: THREE.VectorKeyframeTrack,
-
-	ValueTypeName: 'vector'
-
-	// ValueBufferType is inherited
-
-	// DefaultInterpolation is inherited
-
-} );
-
-// File:src/audio/Audio.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author Reece Aaron Lecrivain / http://reecenotes.com/
- */
-
-THREE.Audio = function ( listener ) {
-
-	THREE.Object3D.call( this );
-
-	this.type = 'Audio';
-
-	this.context = listener.context;
-	this.source = this.context.createBufferSource();
-	this.source.onended = this.onEnded.bind( this );
-
-	this.gain = this.context.createGain();
-	this.gain.connect( listener.getInput() );
-
-	this.autoplay = false;
-
-	this.startTime = 0;
-	this.playbackRate = 1;
-	this.isPlaying = false;
-	this.hasPlaybackControl = true;
-	this.sourceType = 'empty';
-
-	this.filter = null;
-
-};
-
-THREE.Audio.prototype = Object.create( THREE.Object3D.prototype );
-THREE.Audio.prototype.constructor = THREE.Audio;
-
-THREE.Audio.prototype.getOutput = function () {
-
-	return this.gain;
-
-};
-
-THREE.Audio.prototype.setNodeSource = function ( audioNode ) {
-
-	this.hasPlaybackControl = false;
-	this.sourceType = 'audioNode';
-	this.source = audioNode;
-	this.connect();
-
-	return this;
-
-};
-
-THREE.Audio.prototype.setBuffer = function ( audioBuffer ) {
-
-	var scope = this;
-
-	scope.source.buffer = audioBuffer;
-	scope.sourceType = 'buffer';
-	if ( scope.autoplay ) scope.play();
-
-	return this;
-
-};
-
-THREE.Audio.prototype.play = function () {
-
-	if ( this.isPlaying === true ) {
-
-		console.warn( 'THREE.Audio: Audio is already playing.' );
-		return;
-
-	}
-
-	if ( this.hasPlaybackControl === false ) {
-
-		console.warn( 'THREE.Audio: this Audio has no playback control.' );
-		return;
-
-	}
-
-	var source = this.context.createBufferSource();
-
-	source.buffer = this.source.buffer;
-	source.loop = this.source.loop;
-	source.onended = this.source.onended;
-	source.start( 0, this.startTime );
-	source.playbackRate.value = this.playbackRate;
-
-	this.isPlaying = true;
-
-	this.source = source;
-
-	this.connect();
-
-};
-
-THREE.Audio.prototype.pause = function () {
-
-	if ( this.hasPlaybackControl === false ) {
-
-		console.warn( 'THREE.Audio: this Audio has no playback control.' );
-		return;
-
-	}
-
-	this.source.stop();
-	this.startTime = this.context.currentTime;
-
-};
-
-THREE.Audio.prototype.stop = function () {
-
-	if ( this.hasPlaybackControl === false ) {
-
-		console.warn( 'THREE.Audio: this Audio has no playback control.' );
-		return;
-
-	}
-
-	this.source.stop();
-	this.startTime = 0;
-
-};
-
-THREE.Audio.prototype.connect = function () {
-
-	if ( this.filter !== null ) {
-
-		this.source.connect( this.filter );
-		this.filter.connect( this.getOutput() );
-
-	} else {
-
-		this.source.connect( this.getOutput() );
-
-	}
-
-};
-
-THREE.Audio.prototype.disconnect = function () {
-
-	if ( this.filter !== null ) {
-
-		this.source.disconnect( this.filter );
-		this.filter.disconnect( this.getOutput() );
-
-	} else {
-
-		this.source.disconnect( this.getOutput() );
-
-	}
-
-};
-
-THREE.Audio.prototype.getFilter = function () {
-
-	return this.filter;
-
-};
-
-THREE.Audio.prototype.setFilter = function ( value ) {
-
-	if ( value === undefined ) value = null;
-
-	if ( this.isPlaying === true ) {
-
-		this.disconnect();
-		this.filter = value;
-		this.connect();
-
-	} else {
-
-		this.filter = value;
-
-	}
-
-};
-
-THREE.Audio.prototype.setPlaybackRate = function ( value ) {
-
-	if ( this.hasPlaybackControl === false ) {
-
-		console.warn( 'THREE.Audio: this Audio has no playback control.' );
-		return;
-
-	}
-
-	this.playbackRate = value;
-
-	if ( this.isPlaying === true ) {
-
-		this.source.playbackRate.value = this.playbackRate;
-
-	}
-
-};
-
-THREE.Audio.prototype.getPlaybackRate = function () {
-
-	return this.playbackRate;
-
-};
-
-THREE.Audio.prototype.onEnded = function () {
-
-	this.isPlaying = false;
-
-};
-
-THREE.Audio.prototype.setLoop = function ( value ) {
-
-	if ( this.hasPlaybackControl === false ) {
-
-		console.warn( 'THREE.Audio: this Audio has no playback control.' );
-		return;
-
-	}
-
-	this.source.loop = value;
-
-};
-
-THREE.Audio.prototype.getLoop = function () {
-
-	if ( this.hasPlaybackControl === false ) {
-
-		console.warn( 'THREE.Audio: this Audio has no playback control.' );
-		return false;
-
-	}
-
-	return this.source.loop;
-
-};
-
-
-THREE.Audio.prototype.setVolume = function ( value ) {
-
-	this.gain.gain.value = value;
-
-};
-
-THREE.Audio.prototype.getVolume = function () {
-
-	return this.gain.gain.value;
-
-};
-
-// File:src/audio/AudioAnalyser.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.AudioAnalyser = function ( audio, fftSize ) {
-
-	this.analyser = audio.context.createAnalyser();
-	this.analyser.fftSize = fftSize !== undefined ? fftSize : 2048;
-
-	this.data = new Uint8Array( this.analyser.frequencyBinCount );
-
-	audio.getOutput().connect( this.analyser );
-
-};
-
-THREE.AudioAnalyser.prototype = {
-
-	constructor: THREE.AudioAnalyser,
-
-	getData: function () {
-
-		this.analyser.getByteFrequencyData( this.data );
-		return this.data;
-
-	}
-
-};
-
-// File:src/audio/AudioContext.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-Object.defineProperty( THREE, 'AudioContext', {
-
-	get: ( function () {
-
-		var context;
-
-		return function () {
-
-			if ( context === undefined ) {
-
-				context = new ( window.AudioContext || window.webkitAudioContext )();
-
-			}
-
-			return context;
-
-		};
-
-	} )()
-
-} );
-
-// File:src/audio/PositionalAudio.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.PositionalAudio = function ( listener ) {
-
-	THREE.Audio.call( this, listener );
-
-	this.panner = this.context.createPanner();
-	this.panner.connect( this.gain );
-
-};
-
-THREE.PositionalAudio.prototype = Object.create( THREE.Audio.prototype );
-THREE.PositionalAudio.prototype.constructor = THREE.PositionalAudio;
-
-THREE.PositionalAudio.prototype.getOutput = function () {
-
-	return this.panner;
-
-};
-
-THREE.PositionalAudio.prototype.setRefDistance = function ( value ) {
-
-	this.panner.refDistance = value;
-
-};
-
-THREE.PositionalAudio.prototype.getRefDistance = function () {
-
-	return this.panner.refDistance;
-
-};
-
-THREE.PositionalAudio.prototype.setRolloffFactor = function ( value ) {
-
-	this.panner.rolloffFactor = value;
-
-};
-
-THREE.PositionalAudio.prototype.getRolloffFactor = function () {
-
-	return this.panner.rolloffFactor;
-
-};
-
-THREE.PositionalAudio.prototype.setDistanceModel = function ( value ) {
-
-	this.panner.distanceModel = value;
-
-};
-
-THREE.PositionalAudio.prototype.getDistanceModel = function () {
-
-	return this.panner.distanceModel;
-
-};
-
-THREE.PositionalAudio.prototype.setMaxDistance = function ( value ) {
-
-	this.panner.maxDistance = value;
-
-};
-
-THREE.PositionalAudio.prototype.getMaxDistance = function () {
-
-	return this.panner.maxDistance;
-
-};
-
-THREE.PositionalAudio.prototype.updateMatrixWorld = ( function () {
-
-	var position = new THREE.Vector3();
-
-	return function updateMatrixWorld( force ) {
-
-		THREE.Object3D.prototype.updateMatrixWorld.call( this, force );
-
-		position.setFromMatrixPosition( this.matrixWorld );
-
-		this.panner.setPosition( position.x, position.y, position.z );
-
-	};
-
-} )();
-
-// File:src/audio/AudioListener.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.AudioListener = function () {
-
-	THREE.Object3D.call( this );
-
-	this.type = 'AudioListener';
-
-	this.context = THREE.AudioContext;
-
-	this.gain = this.context.createGain();
-	this.gain.connect( this.context.destination );
-
-	this.filter = null;
-
-};
-
-THREE.AudioListener.prototype = Object.create( THREE.Object3D.prototype );
-THREE.AudioListener.prototype.constructor = THREE.AudioListener;
-
-THREE.AudioListener.prototype.getInput = function () {
-
-	return this.gain;
-
-};
-
-THREE.AudioListener.prototype.removeFilter = function ( ) {
-
-	if ( this.filter !== null ) {
-
-		this.gain.disconnect( this.filter );
-		this.filter.disconnect( this.context.destination );
-		this.gain.connect( this.context.destination );
-		this.filter = null;
-
-	}
-
-};
-
-THREE.AudioListener.prototype.setFilter = function ( value ) {
-
-	if ( this.filter !== null ) {
-
-		this.gain.disconnect( this.filter );
-		this.filter.disconnect( this.context.destination );
-
-	} else {
-
-		this.gain.disconnect( this.context.destination );
-
-	}
-
-	this.filter = value;
-	this.gain.connect( this.filter );
-	this.filter.connect( this.context.destination );
-
-};
-
-THREE.AudioListener.prototype.getFilter = function () {
-
-	return this.filter;
-
-};
-
-THREE.AudioListener.prototype.setMasterVolume = function ( value ) {
-
-	this.gain.gain.value = value;
-
-};
-
-THREE.AudioListener.prototype.getMasterVolume = function () {
-
-	return this.gain.gain.value;
-
-};
-
-
-THREE.AudioListener.prototype.updateMatrixWorld = ( function () {
-
-	var position = new THREE.Vector3();
-	var quaternion = new THREE.Quaternion();
-	var scale = new THREE.Vector3();
-
-	var orientation = new THREE.Vector3();
-
-	return function updateMatrixWorld( force ) {
-
-		THREE.Object3D.prototype.updateMatrixWorld.call( this, force );
-
-		var listener = this.context.listener;
-		var up = this.up;
-
-		this.matrixWorld.decompose( position, quaternion, scale );
-
-		orientation.set( 0, 0, - 1 ).applyQuaternion( quaternion );
-
-		listener.setPosition( position.x, position.y, position.z );
-		listener.setOrientation( orientation.x, orientation.y, orientation.z, up.x, up.y, up.z );
-
-	};
-
-} )();
-
-// File:src/cameras/Camera.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author mikael emtinger / http://gomo.se/
- * @author WestLangley / http://github.com/WestLangley
-*/
-
-THREE.Camera = function () {
-
-	THREE.Object3D.call( this );
-
-	this.type = 'Camera';
-
-	this.matrixWorldInverse = new THREE.Matrix4();
-	this.projectionMatrix = new THREE.Matrix4();
-
-};
-
-THREE.Camera.prototype = Object.create( THREE.Object3D.prototype );
-THREE.Camera.prototype.constructor = THREE.Camera;
-
-THREE.Camera.prototype.getWorldDirection = function () {
-
-	var quaternion = new THREE.Quaternion();
-
-	return function ( optionalTarget ) {
-
-		var result = optionalTarget || new THREE.Vector3();
-
-		this.getWorldQuaternion( quaternion );
-
-		return result.set( 0, 0, - 1 ).applyQuaternion( quaternion );
-
-	};
-
-}();
-
-THREE.Camera.prototype.lookAt = function () {
-
-	// This routine does not support cameras with rotated and/or translated parent(s)
-
-	var m1 = new THREE.Matrix4();
-
-	return function ( vector ) {
-
-		m1.lookAt( this.position, vector, this.up );
-
-		this.quaternion.setFromRotationMatrix( m1 );
-
-	};
-
-}();
-
-THREE.Camera.prototype.clone = function () {
-
-	return new this.constructor().copy( this );
-
-};
-
-THREE.Camera.prototype.copy = function ( source ) {
-
-	THREE.Object3D.prototype.copy.call( this, source );
-
-	this.matrixWorldInverse.copy( source.matrixWorldInverse );
-	this.projectionMatrix.copy( source.projectionMatrix );
-
-	return this;
-
-};
-
-// File:src/cameras/CubeCamera.js
-
-/**
- * Camera for rendering cube maps
- *	- renders scene into axis-aligned cube
- *
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.CubeCamera = function ( near, far, cubeResolution ) {
-
-	THREE.Object3D.call( this );
-
-	this.type = 'CubeCamera';
-
-	var fov = 90, aspect = 1;
-
-	var cameraPX = new THREE.PerspectiveCamera( fov, aspect, near, far );
-	cameraPX.up.set( 0, - 1, 0 );
-	cameraPX.lookAt( new THREE.Vector3( 1, 0, 0 ) );
-	this.add( cameraPX );
-
-	var cameraNX = new THREE.PerspectiveCamera( fov, aspect, near, far );
-	cameraNX.up.set( 0, - 1, 0 );
-	cameraNX.lookAt( new THREE.Vector3( - 1, 0, 0 ) );
-	this.add( cameraNX );
-
-	var cameraPY = new THREE.PerspectiveCamera( fov, aspect, near, far );
-	cameraPY.up.set( 0, 0, 1 );
-	cameraPY.lookAt( new THREE.Vector3( 0, 1, 0 ) );
-	this.add( cameraPY );
-
-	var cameraNY = new THREE.PerspectiveCamera( fov, aspect, near, far );
-	cameraNY.up.set( 0, 0, - 1 );
-	cameraNY.lookAt( new THREE.Vector3( 0, - 1, 0 ) );
-	this.add( cameraNY );
-
-	var cameraPZ = new THREE.PerspectiveCamera( fov, aspect, near, far );
-	cameraPZ.up.set( 0, - 1, 0 );
-	cameraPZ.lookAt( new THREE.Vector3( 0, 0, 1 ) );
-	this.add( cameraPZ );
-
-	var cameraNZ = new THREE.PerspectiveCamera( fov, aspect, near, far );
-	cameraNZ.up.set( 0, - 1, 0 );
-	cameraNZ.lookAt( new THREE.Vector3( 0, 0, - 1 ) );
-	this.add( cameraNZ );
-
-	var options = { format: THREE.RGBFormat, magFilter: THREE.LinearFilter, minFilter: THREE.LinearFilter };
-
-	this.renderTarget = new THREE.WebGLRenderTargetCube( cubeResolution, cubeResolution, options );
-
-	this.updateCubeMap = function ( renderer, scene ) {
-
-		if ( this.parent === null ) this.updateMatrixWorld();
-
-		var renderTarget = this.renderTarget;
-		var generateMipmaps = renderTarget.texture.generateMipmaps;
-
-		renderTarget.texture.generateMipmaps = false;
-
-		renderTarget.activeCubeFace = 0;
-		renderer.render( scene, cameraPX, renderTarget );
-
-		renderTarget.activeCubeFace = 1;
-		renderer.render( scene, cameraNX, renderTarget );
-
-		renderTarget.activeCubeFace = 2;
-		renderer.render( scene, cameraPY, renderTarget );
-
-		renderTarget.activeCubeFace = 3;
-		renderer.render( scene, cameraNY, renderTarget );
-
-		renderTarget.activeCubeFace = 4;
-		renderer.render( scene, cameraPZ, renderTarget );
-
-		renderTarget.texture.generateMipmaps = generateMipmaps;
-
-		renderTarget.activeCubeFace = 5;
-		renderer.render( scene, cameraNZ, renderTarget );
-
-		renderer.setRenderTarget( null );
-
-	};
-
-};
-
-THREE.CubeCamera.prototype = Object.create( THREE.Object3D.prototype );
-THREE.CubeCamera.prototype.constructor = THREE.CubeCamera;
-
-// File:src/cameras/OrthographicCamera.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.OrthographicCamera = function ( left, right, top, bottom, near, far ) {
-
-	THREE.Camera.call( this );
-
-	this.type = 'OrthographicCamera';
-
-	this.zoom = 1;
-
-	this.left = left;
-	this.right = right;
-	this.top = top;
-	this.bottom = bottom;
-
-	this.near = ( near !== undefined ) ? near : 0.1;
-	this.far = ( far !== undefined ) ? far : 2000;
-
-	this.updateProjectionMatrix();
-
-};
-
-THREE.OrthographicCamera.prototype = Object.create( THREE.Camera.prototype );
-THREE.OrthographicCamera.prototype.constructor = THREE.OrthographicCamera;
-
-THREE.OrthographicCamera.prototype.updateProjectionMatrix = function () {
-
-	var dx = ( this.right - this.left ) / ( 2 * this.zoom );
-	var dy = ( this.top - this.bottom ) / ( 2 * this.zoom );
-	var cx = ( this.right + this.left ) / 2;
-	var cy = ( this.top + this.bottom ) / 2;
-
-	this.projectionMatrix.makeOrthographic( cx - dx, cx + dx, cy + dy, cy - dy, this.near, this.far );
-
-};
-
-THREE.OrthographicCamera.prototype.copy = function ( source ) {
-
-	THREE.Camera.prototype.copy.call( this, source );
-
-	this.left = source.left;
-	this.right = source.right;
-	this.top = source.top;
-	this.bottom = source.bottom;
-	this.near = source.near;
-	this.far = source.far;
-
-	this.zoom = source.zoom;
-
-	return this;
-
-};
-
-THREE.OrthographicCamera.prototype.toJSON = function ( meta ) {
-
-	var data = THREE.Object3D.prototype.toJSON.call( this, meta );
-
-	data.object.zoom = this.zoom;
-	data.object.left = this.left;
-	data.object.right = this.right;
-	data.object.top = this.top;
-	data.object.bottom = this.bottom;
-	data.object.near = this.near;
-	data.object.far = this.far;
-
-	return data;
-
-};
-
-// File:src/cameras/PerspectiveCamera.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author greggman / http://games.greggman.com/
- * @author zz85 / http://www.lab4games.net/zz85/blog
- * @author tschw
- */
-
-THREE.PerspectiveCamera = function( fov, aspect, near, far ) {
-
-	THREE.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();
-
-};
-
-THREE.PerspectiveCamera.prototype = Object.create( THREE.Camera.prototype );
-THREE.PerspectiveCamera.prototype.constructor = THREE.PerspectiveCamera;
-
-
-/**
- * Sets the FOV by focal length (DEPRECATED).
- *
- * Optionally also sets .filmGauge, otherwise uses it. See .setFocalLength.
- */
-THREE.PerspectiveCamera.prototype.setLens = function( focalLength, filmGauge ) {
-
-	console.warn( "THREE.PerspectiveCamera.setLens is deprecated. " +
-			"Use .setFocalLength and .filmGauge for a photographic setup." );
-
-	if ( filmGauge !== undefined ) this.filmGauge = filmGauge;
-	this.setFocalLength( focalLength );
-
-};
-
-/**
- * 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.
- */
-THREE.PerspectiveCamera.prototype.setFocalLength = function( focalLength ) {
-
-	// see http://www.bobatkins.com/photography/technical/field_of_view.html
-	var vExtentSlope = 0.5 * this.getFilmHeight() / focalLength;
-
-	this.fov = THREE.Math.RAD2DEG * 2 * Math.atan( vExtentSlope );
-	this.updateProjectionMatrix();
-
-};
-
-
-/**
- * Calculates the focal length from the current .fov and .filmGauge.
- */
-THREE.PerspectiveCamera.prototype.getFocalLength = function() {
-
-	var vExtentSlope = Math.tan( THREE.Math.DEG2RAD * 0.5 * this.fov );
-
-	return 0.5 * this.getFilmHeight() / vExtentSlope;
-
-};
-
-THREE.PerspectiveCamera.prototype.getEffectiveFOV = function() {
-
-	return THREE.Math.RAD2DEG * 2 * Math.atan(
-			Math.tan( THREE.Math.DEG2RAD * 0.5 * this.fov ) / this.zoom );
-
-};
-
-THREE.PerspectiveCamera.prototype.getFilmWidth = function() {
-
-	// film not completely covered in portrait format (aspect < 1)
-	return this.filmGauge * Math.min( this.aspect, 1 );
-
-};
-
-THREE.PerspectiveCamera.prototype.getFilmHeight = function() {
-
-	// film not completely covered in landscape 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.setOffset( fullWidth, fullHeight, w * 0, h * 0, w, h );
- *   --B--
- *   camera.setOffset( fullWidth, fullHeight, w * 1, h * 0, w, h );
- *   --C--
- *   camera.setOffset( fullWidth, fullHeight, w * 2, h * 0, w, h );
- *   --D--
- *   camera.setOffset( fullWidth, fullHeight, w * 0, h * 1, w, h );
- *   --E--
- *   camera.setOffset( fullWidth, fullHeight, w * 1, h * 1, w, h );
- *   --F--
- *   camera.setOffset( fullWidth, fullHeight, w * 2, h * 1, w, h );
- *
- *   Note there is no reason monitors have to be the same size or in a grid.
- */
-THREE.PerspectiveCamera.prototype.setViewOffset = function( fullWidth, fullHeight, x, y, width, height ) {
-
-	this.aspect = fullWidth / fullHeight;
-
-	this.view = {
-		fullWidth: fullWidth,
-		fullHeight: fullHeight,
-		offsetX: x,
-		offsetY: y,
-		width: width,
-		height: height
-	};
-
-	this.updateProjectionMatrix();
-
-};
-
-THREE.PerspectiveCamera.prototype.updateProjectionMatrix = function() {
-
-	var near = this.near,
-		top = near * Math.tan(
-				THREE.Math.DEG2RAD * 0.5 * this.fov ) / this.zoom,
-		height = 2 * top,
-		width = this.aspect * height,
-		left = - 0.5 * width,
-		view = this.view;
-
-	if ( view !== null ) {
-
-		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.makeFrustum(
-			left, left + width, top - height, top, near, this.far );
-
-};
-
-THREE.PerspectiveCamera.prototype.copy = function( source ) {
-
-	THREE.Camera.prototype.copy.call( this, source );
-
-	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;
-
-};
-
-THREE.PerspectiveCamera.prototype.toJSON = function( meta ) {
-
-	var data = THREE.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;
-
-};
-
-// File:src/cameras/StereoCamera.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.StereoCamera = function () {
-
-	this.type = 'StereoCamera';
-
-	this.aspect = 1;
-
-	this.cameraL = new THREE.PerspectiveCamera();
-	this.cameraL.layers.enable( 1 );
-	this.cameraL.matrixAutoUpdate = false;
-
-	this.cameraR = new THREE.PerspectiveCamera();
-	this.cameraR.layers.enable( 2 );
-	this.cameraR.matrixAutoUpdate = false;
-
-};
-
-THREE.StereoCamera.prototype = {
-
-	constructor: THREE.StereoCamera,
-
-	update: ( function () {
-
-		var focus, fov, aspect, near, far;
-
-		var eyeRight = new THREE.Matrix4();
-		var eyeLeft = new THREE.Matrix4();
-
-		return function update ( camera ) {
-
-			var needsUpdate = focus !== camera.focus || fov !== camera.fov ||
-												aspect !== camera.aspect * this.aspect || near !== camera.near ||
-												far !== camera.far;
-
-			if ( needsUpdate ) {
-
-				focus = camera.focus;
-				fov = camera.fov;
-				aspect = camera.aspect * this.aspect;
-				near = camera.near;
-				far = camera.far;
-
-				// Off-axis stereoscopic effect based on
-				// http://paulbourke.net/stereographics/stereorender/
-
-				var projectionMatrix = camera.projectionMatrix.clone();
-				var eyeSep = 0.064 / 2;
-				var eyeSepOnProjection = eyeSep * near / focus;
-				var ymax = near * Math.tan( THREE.Math.DEG2RAD * fov * 0.5 );
-				var xmin, xmax;
-
-				// translate xOffset
-
-				eyeLeft.elements[ 12 ] = - eyeSep;
-				eyeRight.elements[ 12 ] = eyeSep;
-
-				// for left eye
-
-				xmin = - ymax * aspect + eyeSepOnProjection;
-				xmax = ymax * aspect + eyeSepOnProjection;
-
-				projectionMatrix.elements[ 0 ] = 2 * near / ( xmax - xmin );
-				projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );
-
-				this.cameraL.projectionMatrix.copy( projectionMatrix );
-
-				// for right eye
-
-				xmin = - ymax * aspect - eyeSepOnProjection;
-				xmax = ymax * aspect - eyeSepOnProjection;
-
-				projectionMatrix.elements[ 0 ] = 2 * near / ( xmax - xmin );
-				projectionMatrix.elements[ 8 ] = ( xmax + xmin ) / ( xmax - xmin );
-
-				this.cameraR.projectionMatrix.copy( projectionMatrix );
-
-			}
-
-			this.cameraL.matrixWorld.copy( camera.matrixWorld ).multiply( eyeLeft );
-			this.cameraR.matrixWorld.copy( camera.matrixWorld ).multiply( eyeRight );
-
-		};
-
-	} )()
-
-};
-
-// File:src/lights/Light.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.Light = function ( color, intensity ) {
-
-	THREE.Object3D.call( this );
-
-	this.type = 'Light';
-
-	this.color = new THREE.Color( color );
-	this.intensity = intensity !== undefined ? intensity : 1;
-
-	this.receiveShadow = undefined;
-
-};
-
-THREE.Light.prototype = Object.create( THREE.Object3D.prototype );
-THREE.Light.prototype.constructor = THREE.Light;
-
-THREE.Light.prototype.copy = function ( source ) {
-
-	THREE.Object3D.prototype.copy.call( this, source );
-
-	this.color.copy( source.color );
-	this.intensity = source.intensity;
-
-	return this;
-
-};
-
-THREE.Light.prototype.toJSON = function ( meta ) {
-
-	var data = THREE.Object3D.prototype.toJSON.call( this, meta );
-
-	data.object.color = this.color.getHex();
-	data.object.intensity = this.intensity;
-
-	if ( this.groundColor !== undefined ) data.object.groundColor = this.groundColor.getHex();
-
-	if ( this.distance !== undefined ) data.object.distance = this.distance;
-	if ( this.angle !== undefined ) data.object.angle = this.angle;
-	if ( this.decay !== undefined ) data.object.decay = this.decay;
-	if ( this.penumbra !== undefined ) data.object.penumbra = this.penumbra;
-
-	return data;
-
-};
-
-// File:src/lights/LightShadow.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.LightShadow = function ( camera ) {
-
-	this.camera = camera;
-
-	this.bias = 0;
-	this.radius = 1;
-
-	this.mapSize = new THREE.Vector2( 512, 512 );
-
-	this.map = null;
-	this.matrix = new THREE.Matrix4();
-
-};
-
-THREE.LightShadow.prototype = {
-
-	constructor: THREE.LightShadow,
-
-	copy: function ( source ) {
-
-		this.camera = source.camera.clone();
-
-		this.bias = source.bias;
-		this.radius = source.radius;
-
-		this.mapSize.copy( source.mapSize );
-
-		return this;
-
-	},
-
-	clone: function () {
-
-		return new this.constructor().copy( this );
-
-	}
-
-};
-
-// File:src/lights/AmbientLight.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.AmbientLight = function ( color, intensity ) {
-
-	THREE.Light.call( this, color, intensity );
-
-	this.type = 'AmbientLight';
-
-	this.castShadow = undefined;
-
-};
-
-THREE.AmbientLight.prototype = Object.create( THREE.Light.prototype );
-THREE.AmbientLight.prototype.constructor = THREE.AmbientLight;
-
-// File:src/lights/DirectionalLight.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.DirectionalLight = function ( color, intensity ) {
-
-	THREE.Light.call( this, color, intensity );
-
-	this.type = 'DirectionalLight';
-
-	this.position.set( 0, 1, 0 );
-	this.updateMatrix();
-
-	this.target = new THREE.Object3D();
-
-	this.shadow = new THREE.DirectionalLightShadow();
-
-};
-
-THREE.DirectionalLight.prototype = Object.create( THREE.Light.prototype );
-THREE.DirectionalLight.prototype.constructor = THREE.DirectionalLight;
-
-THREE.DirectionalLight.prototype.copy = function ( source ) {
-
-	THREE.Light.prototype.copy.call( this, source );
-
-	this.target = source.target.clone();
-
-	this.shadow = source.shadow.clone();
-
-	return this;
-
-};
-
-// File:src/lights/DirectionalLightShadow.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.DirectionalLightShadow = function ( light ) {
-
-	THREE.LightShadow.call( this, new THREE.OrthographicCamera( - 5, 5, 5, - 5, 0.5, 500 ) );
-
-};
-
-THREE.DirectionalLightShadow.prototype = Object.create( THREE.LightShadow.prototype );
-THREE.DirectionalLightShadow.prototype.constructor = THREE.DirectionalLightShadow;
-
-// File:src/lights/HemisphereLight.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.HemisphereLight = function ( skyColor, groundColor, intensity ) {
-
-	THREE.Light.call( this, skyColor, intensity );
-
-	this.type = 'HemisphereLight';
-
-	this.castShadow = undefined;
-
-	this.position.set( 0, 1, 0 );
-	this.updateMatrix();
-
-	this.groundColor = new THREE.Color( groundColor );
-
-};
-
-THREE.HemisphereLight.prototype = Object.create( THREE.Light.prototype );
-THREE.HemisphereLight.prototype.constructor = THREE.HemisphereLight;
-
-THREE.HemisphereLight.prototype.copy = function ( source ) {
-
-	THREE.Light.prototype.copy.call( this, source );
-
-	this.groundColor.copy( source.groundColor );
-
-	return this;
-
-};
-
-// File:src/lights/PointLight.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-
-THREE.PointLight = function ( color, intensity, distance, decay ) {
-
-	THREE.Light.call( this, color, intensity );
-
-	this.type = 'PointLight';
-
-	this.distance = ( distance !== undefined ) ? distance : 0;
-	this.decay = ( decay !== undefined ) ? decay : 1;	// for physically correct lights, should be 2.
-
-	this.shadow = new THREE.LightShadow( new THREE.PerspectiveCamera( 90, 1, 0.5, 500 ) );
-
-};
-
-THREE.PointLight.prototype = Object.create( THREE.Light.prototype );
-THREE.PointLight.prototype.constructor = THREE.PointLight;
-
-Object.defineProperty( THREE.PointLight.prototype, "power", {
-
-	get: function () {
-
-		// intensity = power per solid angle.
-		// ref: equation (15) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf
-		return this.intensity * 4 * Math.PI;
-
-	},
-
-	set: function ( power ) {
-
-		// intensity = power per solid angle.
-		// ref: equation (15) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf
-		this.intensity = power / ( 4 * Math.PI );
-
-	}
-
-} );
-
-THREE.PointLight.prototype.copy = function ( source ) {
-
-	THREE.Light.prototype.copy.call( this, source );
-
-	this.distance = source.distance;
-	this.decay = source.decay;
-
-	this.shadow = source.shadow.clone();
-
-	return this;
-
-};
-
-// File:src/lights/SpotLight.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.SpotLight = function ( color, intensity, distance, angle, penumbra, decay ) {
-
-	THREE.Light.call( this, color, intensity );
-
-	this.type = 'SpotLight';
-
-	this.position.set( 0, 1, 0 );
-	this.updateMatrix();
-
-	this.target = new THREE.Object3D();
-
-	this.distance = ( distance !== undefined ) ? distance : 0;
-	this.angle = ( angle !== undefined ) ? angle : Math.PI / 3;
-	this.penumbra = ( penumbra !== undefined ) ? penumbra : 0;
-	this.decay = ( decay !== undefined ) ? decay : 1;	// for physically correct lights, should be 2.
-
-	this.shadow = new THREE.SpotLightShadow();
-
-};
-
-THREE.SpotLight.prototype = Object.create( THREE.Light.prototype );
-THREE.SpotLight.prototype.constructor = THREE.SpotLight;
-
-Object.defineProperty( THREE.SpotLight.prototype, "power", {
-
-	get: function () {
-
-		// intensity = power per solid angle.
-		// ref: equation (17) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf
-		return this.intensity * Math.PI;
-
-	},
-
-	set: function ( power ) {
-
-		// intensity = power per solid angle.
-		// ref: equation (17) from http://www.frostbite.com/wp-content/uploads/2014/11/course_notes_moving_frostbite_to_pbr.pdf
-		this.intensity = power / Math.PI;
-
-	}
-
-} );
-
-THREE.SpotLight.prototype.copy = function ( source ) {
-
-	THREE.Light.prototype.copy.call( this, source );
-
-	this.distance = source.distance;
-	this.angle = source.angle;
-	this.penumbra = source.penumbra;
-	this.decay = source.decay;
-
-	this.target = source.target.clone();
-
-	this.shadow = source.shadow.clone();
-
-	return this;
-
-};
-
-// File:src/lights/SpotLightShadow.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.SpotLightShadow = function () {
-
-	THREE.LightShadow.call( this, new THREE.PerspectiveCamera( 50, 1, 0.5, 500 ) );
-
-};
-
-THREE.SpotLightShadow.prototype = Object.create( THREE.LightShadow.prototype );
-THREE.SpotLightShadow.prototype.constructor = THREE.SpotLightShadow;
-
-THREE.SpotLightShadow.prototype.update = function ( light ) {
-
-	var fov = THREE.Math.RAD2DEG * 2 * light.angle;
-	var aspect = this.mapSize.width / this.mapSize.height;
-	var far = light.distance || 500;
-
-	var camera = this.camera;
-
-	if ( fov !== camera.fov || aspect !== camera.aspect || far !== camera.far ) {
-
-		camera.fov = fov;
-		camera.aspect = aspect;
-		camera.far = far;
-		camera.updateProjectionMatrix();
-
-	}
-
-};
-
-// File:src/loaders/AudioLoader.js
-
-/**
- * @author Reece Aaron Lecrivain / http://reecenotes.com/
- */
-
-THREE.AudioLoader = function ( manager ) {
-
-	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
-
-};
-
-THREE.AudioLoader.prototype = {
-
-	constructor: THREE.AudioLoader,
-
-	load: function ( url, onLoad, onProgress, onError ) {
-
-		var loader = new THREE.XHRLoader( this.manager );
-		loader.setResponseType( 'arraybuffer' );
-		loader.load( url, function ( buffer ) {
-
-			var context = THREE.AudioContext;
-
-			context.decodeAudioData( buffer, function ( audioBuffer ) {
-
-				onLoad( audioBuffer );
-
-			} );
-
-		}, onProgress, onError );
-
-	}
-
-};
-
-// File:src/loaders/Cache.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.Cache = {
-
-	enabled: false,
-
-	files: {},
-
-	add: function ( key, file ) {
-
-		if ( this.enabled === false ) return;
-
-		// console.log( 'THREE.Cache', 'Adding key:', key );
-
-		this.files[ key ] = file;
-
-	},
-
-	get: function ( key ) {
-
-		if ( this.enabled === false ) return;
-
-		// console.log( 'THREE.Cache', 'Checking key:', key );
-
-		return this.files[ key ];
-
-	},
-
-	remove: function ( key ) {
-
-		delete this.files[ key ];
-
-	},
-
-	clear: function () {
-
-		this.files = {};
-
-	}
-
-};
-
-// File:src/loaders/Loader.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.Loader = function () {
-
-	this.onLoadStart = function () {};
-	this.onLoadProgress = function () {};
-	this.onLoadComplete = function () {};
-
-};
-
-THREE.Loader.prototype = {
-
-	constructor: THREE.Loader,
-
-	crossOrigin: undefined,
-
-	extractUrlBase: function ( url ) {
-
-		var parts = url.split( '/' );
-
-		if ( parts.length === 1 ) return './';
-
-		parts.pop();
-
-		return parts.join( '/' ) + '/';
-
-	},
-
-	initMaterials: function ( materials, texturePath, crossOrigin ) {
-
-		var array = [];
-
-		for ( var i = 0; i < materials.length; ++ i ) {
-
-			array[ i ] = this.createMaterial( materials[ i ], texturePath, crossOrigin );
-
-		}
-
-		return array;
-
-	},
-
-	createMaterial: ( function () {
-
-		var color, textureLoader, materialLoader;
-
-		return function ( m, texturePath, crossOrigin ) {
-
-			if ( color === undefined ) color = new THREE.Color();
-			if ( textureLoader === undefined ) textureLoader = new THREE.TextureLoader();
-			if ( materialLoader === undefined ) materialLoader = new THREE.MaterialLoader();
-
-			// convert from old material format
-
-			var textures = {};
-
-			function loadTexture( path, repeat, offset, wrap, anisotropy ) {
-
-				var fullPath = texturePath + path;
-				var loader = THREE.Loader.Handlers.get( fullPath );
-
-				var texture;
-
-				if ( loader !== null ) {
-
-					texture = loader.load( fullPath );
-
-				} else {
-
-					textureLoader.setCrossOrigin( crossOrigin );
-					texture = textureLoader.load( fullPath );
-
-				}
-
-				if ( repeat !== undefined ) {
-
-					texture.repeat.fromArray( repeat );
-
-					if ( repeat[ 0 ] !== 1 ) texture.wrapS = THREE.RepeatWrapping;
-					if ( repeat[ 1 ] !== 1 ) texture.wrapT = THREE.RepeatWrapping;
-
-				}
-
-				if ( offset !== undefined ) {
-
-					texture.offset.fromArray( offset );
-
-				}
-
-				if ( wrap !== undefined ) {
-
-					if ( wrap[ 0 ] === 'repeat' ) texture.wrapS = THREE.RepeatWrapping;
-					if ( wrap[ 0 ] === 'mirror' ) texture.wrapS = THREE.MirroredRepeatWrapping;
-
-					if ( wrap[ 1 ] === 'repeat' ) texture.wrapT = THREE.RepeatWrapping;
-					if ( wrap[ 1 ] === 'mirror' ) texture.wrapT = THREE.MirroredRepeatWrapping;
-
-				}
-
-				if ( anisotropy !== undefined ) {
-
-					texture.anisotropy = anisotropy;
-
-				}
-
-				var uuid = THREE.Math.generateUUID();
-
-				textures[ uuid ] = texture;
-
-				return uuid;
-
-			}
-
-			//
-
-			var json = {
-				uuid: THREE.Math.generateUUID(),
-				type: 'MeshLambertMaterial'
-			};
-
-			for ( var name in m ) {
-
-				var value = m[ name ];
-
-				switch ( name ) {
-					case 'DbgColor':
-					case 'DbgIndex':
-					case 'opticalDensity':
-					case 'illumination':
-						break;
-					case 'DbgName':
-						json.name = value;
-						break;
-					case 'blending':
-						json.blending = THREE[ value ];
-						break;
-					case 'colorAmbient':
-					case 'mapAmbient':
-						console.warn( 'THREE.Loader.createMaterial:', name, 'is no longer supported.' );
-						break;
-					case 'colorDiffuse':
-						json.color = color.fromArray( value ).getHex();
-						break;
-					case 'colorSpecular':
-						json.specular = color.fromArray( value ).getHex();
-						break;
-					case 'colorEmissive':
-						json.emissive = color.fromArray( value ).getHex();
-						break;
-					case 'specularCoef':
-						json.shininess = value;
-						break;
-					case 'shading':
-						if ( value.toLowerCase() === 'basic' ) json.type = 'MeshBasicMaterial';
-						if ( value.toLowerCase() === 'phong' ) json.type = 'MeshPhongMaterial';
-						break;
-					case 'mapDiffuse':
-						json.map = loadTexture( value, m.mapDiffuseRepeat, m.mapDiffuseOffset, m.mapDiffuseWrap, m.mapDiffuseAnisotropy );
-						break;
-					case 'mapDiffuseRepeat':
-					case 'mapDiffuseOffset':
-					case 'mapDiffuseWrap':
-					case 'mapDiffuseAnisotropy':
-						break;
-					case 'mapLight':
-						json.lightMap = loadTexture( value, m.mapLightRepeat, m.mapLightOffset, m.mapLightWrap, m.mapLightAnisotropy );
-						break;
-					case 'mapLightRepeat':
-					case 'mapLightOffset':
-					case 'mapLightWrap':
-					case 'mapLightAnisotropy':
-						break;
-					case 'mapAO':
-						json.aoMap = loadTexture( value, m.mapAORepeat, m.mapAOOffset, m.mapAOWrap, m.mapAOAnisotropy );
-						break;
-					case 'mapAORepeat':
-					case 'mapAOOffset':
-					case 'mapAOWrap':
-					case 'mapAOAnisotropy':
-						break;
-					case 'mapBump':
-						json.bumpMap = loadTexture( value, m.mapBumpRepeat, m.mapBumpOffset, m.mapBumpWrap, m.mapBumpAnisotropy );
-						break;
-					case 'mapBumpScale':
-						json.bumpScale = value;
-						break;
-					case 'mapBumpRepeat':
-					case 'mapBumpOffset':
-					case 'mapBumpWrap':
-					case 'mapBumpAnisotropy':
-						break;
-					case 'mapNormal':
-						json.normalMap = loadTexture( value, m.mapNormalRepeat, m.mapNormalOffset, m.mapNormalWrap, m.mapNormalAnisotropy );
-						break;
-					case 'mapNormalFactor':
-						json.normalScale = [ value, value ];
-						break;
-					case 'mapNormalRepeat':
-					case 'mapNormalOffset':
-					case 'mapNormalWrap':
-					case 'mapNormalAnisotropy':
-						break;
-					case 'mapSpecular':
-						json.specularMap = loadTexture( value, m.mapSpecularRepeat, m.mapSpecularOffset, m.mapSpecularWrap, m.mapSpecularAnisotropy );
-						break;
-					case 'mapSpecularRepeat':
-					case 'mapSpecularOffset':
-					case 'mapSpecularWrap':
-					case 'mapSpecularAnisotropy':
-						break;
-					case 'mapAlpha':
-						json.alphaMap = loadTexture( value, m.mapAlphaRepeat, m.mapAlphaOffset, m.mapAlphaWrap, m.mapAlphaAnisotropy );
-						break;
-					case 'mapAlphaRepeat':
-					case 'mapAlphaOffset':
-					case 'mapAlphaWrap':
-					case 'mapAlphaAnisotropy':
-						break;
-					case 'flipSided':
-						json.side = THREE.BackSide;
-						break;
-					case 'doubleSided':
-						json.side = THREE.DoubleSide;
-						break;
-					case 'transparency':
-						console.warn( 'THREE.Loader.createMaterial: transparency has been renamed to opacity' );
-						json.opacity = value;
-						break;
-					case 'depthTest':
-					case 'depthWrite':
-					case 'colorWrite':
-					case 'opacity':
-					case 'reflectivity':
-					case 'transparent':
-					case 'visible':
-					case 'wireframe':
-						json[ name ] = value;
-						break;
-					case 'vertexColors':
-						if ( value === true ) json.vertexColors = THREE.VertexColors;
-						if ( value === 'face' ) json.vertexColors = THREE.FaceColors;
-						break;
-					default:
-						console.error( 'THREE.Loader.createMaterial: Unsupported', name, value );
-						break;
-				}
-
-			}
-
-			if ( json.type === 'MeshBasicMaterial' ) delete json.emissive;
-			if ( json.type !== 'MeshPhongMaterial' ) delete json.specular;
-
-			if ( json.opacity < 1 ) json.transparent = true;
-
-			materialLoader.setTextures( textures );
-
-			return materialLoader.parse( json );
-
-		};
-
-	} )()
-
-};
-
-THREE.Loader.Handlers = {
-
-	handlers: [],
-
-	add: function ( regex, loader ) {
-
-		this.handlers.push( regex, loader );
-
-	},
-
-	get: function ( file ) {
-
-		var handlers = this.handlers;
-
-		for ( var i = 0, l = handlers.length; i < l; i += 2 ) {
-
-			var regex = handlers[ i ];
-			var loader  = handlers[ i + 1 ];
-
-			if ( regex.test( file ) ) {
-
-				return loader;
-
-			}
-
-		}
-
-		return null;
-
-	}
-
-};
-
-// File:src/loaders/XHRLoader.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.XHRLoader = function ( manager ) {
-
-	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
-
-};
-
-THREE.XHRLoader.prototype = {
-
-	constructor: THREE.XHRLoader,
-
-	load: function ( url, onLoad, onProgress, onError ) {
-
-		if ( this.path !== undefined ) url = this.path + url;
-
-		var scope = this;
-
-		var cached = THREE.Cache.get( url );
-
-		if ( cached !== undefined ) {
-
-			if ( onLoad ) {
-
-				setTimeout( function () {
-
-					onLoad( cached );
-
-				}, 0 );
-
-			}
-
-			return cached;
-
-		}
-
-		var request = new XMLHttpRequest();
-		request.overrideMimeType( 'text/plain' );
-		request.open( 'GET', url, true );
-
-		request.addEventListener( 'load', function ( event ) {
-
-			var response = event.target.response;
-
-			THREE.Cache.add( url, response );
-
-			if ( this.status === 200 ) {
-
-				if ( onLoad ) onLoad( response );
-
-				scope.manager.itemEnd( url );
-
-			} else if ( this.status === 0 ) {
-
-				// Some browsers return HTTP Status 0 when using non-http protocol
-				// e.g. 'file://' or 'data://'. Handle as success.
-
-				console.warn( 'THREE.XHRLoader: HTTP Status 0 received.' );
-
-				if ( onLoad ) onLoad( response );
-
-				scope.manager.itemEnd( url );
-
-			} else {
-
-				if ( onError ) onError( event );
-
-				scope.manager.itemError( url );
-
-			}
-
-		}, false );
-
-		if ( onProgress !== undefined ) {
-
-			request.addEventListener( 'progress', function ( event ) {
-
-				onProgress( event );
-
-			}, false );
-
-		}
-
-		request.addEventListener( 'error', function ( event ) {
-
-			if ( onError ) onError( event );
-
-			scope.manager.itemError( url );
-
-		}, false );
-
-		if ( this.responseType !== undefined ) request.responseType = this.responseType;
-		if ( this.withCredentials !== undefined ) request.withCredentials = this.withCredentials;
-
-		request.send( null );
-
-		scope.manager.itemStart( url );
-
-		return request;
-
-	},
-
-	setPath: function ( value ) {
-
-		this.path = value;
-
-	},
-
-	setResponseType: function ( value ) {
-
-		this.responseType = value;
-
-	},
-
-	setWithCredentials: function ( value ) {
-
-		this.withCredentials = value;
-
-	}
-
-};
-
-// File:src/loaders/FontLoader.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.FontLoader = function ( manager ) {
-
-	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
-
-};
-
-THREE.FontLoader.prototype = {
-
-	constructor: THREE.FontLoader,
-
-	load: function ( url, onLoad, onProgress, onError ) {
-
-		var loader = new THREE.XHRLoader( this.manager );
-		loader.load( url, function ( text ) {
-
-			onLoad( new THREE.Font( JSON.parse( text.substring( 65, text.length - 2 ) ) ) );
-
-		}, onProgress, onError );
-
-	}
-
-};
-
-// File:src/loaders/ImageLoader.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.ImageLoader = function ( manager ) {
-
-	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
-
-};
-
-THREE.ImageLoader.prototype = {
-
-	constructor: THREE.ImageLoader,
-
-	load: function ( url, onLoad, onProgress, onError ) {
-
-		if ( this.path !== undefined ) url = this.path + url;
-
-		var scope = this;
-
-		var cached = THREE.Cache.get( url );
-
-		if ( cached !== undefined ) {
-
-			scope.manager.itemStart( url );
-
-			if ( onLoad ) {
-
-				setTimeout( function () {
-
-					onLoad( cached );
-
-					scope.manager.itemEnd( url );
-
-				}, 0 );
-
-			} else {
-
-				scope.manager.itemEnd( url );
-
-			}
-
-			return cached;
-
-		}
-
-		var image = document.createElement( 'img' );
-
-		image.addEventListener( 'load', function ( event ) {
-
-			THREE.Cache.add( url, this );
-
-			if ( onLoad ) onLoad( this );
-
-			scope.manager.itemEnd( url );
-
-		}, false );
-
-		if ( onProgress !== undefined ) {
-
-			image.addEventListener( 'progress', function ( event ) {
-
-				onProgress( event );
-
-			}, false );
-
-		}
-
-		image.addEventListener( 'error', function ( event ) {
-
-			if ( onError ) onError( event );
-
-			scope.manager.itemError( url );
-
-		}, false );
-
-		if ( this.crossOrigin !== undefined ) image.crossOrigin = this.crossOrigin;
-
-		scope.manager.itemStart( url );
-
-		image.src = url;
-
-		return image;
-
-	},
-
-	setCrossOrigin: function ( value ) {
-
-		this.crossOrigin = value;
-
-	},
-
-	setPath: function ( value ) {
-
-		this.path = value;
-
-	}
-
-};
-
-// File:src/loaders/JSONLoader.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.JSONLoader = function ( manager ) {
-
-	if ( typeof manager === 'boolean' ) {
-
-		console.warn( 'THREE.JSONLoader: showStatus parameter has been removed from constructor.' );
-		manager = undefined;
-
-	}
-
-	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
-
-	this.withCredentials = false;
-
-};
-
-THREE.JSONLoader.prototype = {
-
-	constructor: THREE.JSONLoader,
-
-	// Deprecated
-
-	get statusDomElement () {
-
-		if ( this._statusDomElement === undefined ) {
-
-			this._statusDomElement = document.createElement( 'div' );
-
-		}
-
-		console.warn( 'THREE.JSONLoader: .statusDomElement has been removed.' );
-		return this._statusDomElement;
-
-	},
-
-	load: function( url, onLoad, onProgress, onError ) {
-
-		var scope = this;
-
-		var texturePath = this.texturePath && ( typeof this.texturePath === "string" ) ? this.texturePath : THREE.Loader.prototype.extractUrlBase( url );
-
-		var loader = new THREE.XHRLoader( this.manager );
-		loader.setWithCredentials( this.withCredentials );
-		loader.load( url, function ( text ) {
-
-			var json = JSON.parse( text );
-			var metadata = json.metadata;
-
-			if ( metadata !== undefined ) {
-
-				var type = metadata.type;
-
-				if ( type !== undefined ) {
-
-					if ( type.toLowerCase() === 'object' ) {
-
-						console.error( 'THREE.JSONLoader: ' + url + ' should be loaded with THREE.ObjectLoader instead.' );
-						return;
-
-					}
-
-					if ( type.toLowerCase() === 'scene' ) {
-
-						console.error( 'THREE.JSONLoader: ' + url + ' should be loaded with THREE.SceneLoader instead.' );
-						return;
-
-					}
-
-				}
-
-			}
-
-			var object = scope.parse( json, texturePath );
-			onLoad( object.geometry, object.materials );
-
-		}, onProgress, onError );
-
-	},
-
-	setTexturePath: function ( value ) {
-
-		this.texturePath = value;
-
-	},
-
-	parse: function ( json, texturePath ) {
-
-		var geometry = new THREE.Geometry(),
-		scale = ( json.scale !== undefined ) ? 1.0 / json.scale : 1.0;
-
-		parseModel( scale );
-
-		parseSkin();
-		parseMorphing( scale );
-		parseAnimations();
-
-		geometry.computeFaceNormals();
-		geometry.computeBoundingSphere();
-
-		function parseModel( scale ) {
-
-			function isBitSet( value, position ) {
-
-				return value & ( 1 << position );
-
-			}
-
-			var i, j, fi,
-
-			offset, zLength,
-
-		colorIndex, normalIndex, uvIndex, materialIndex,
-
-			type,
-			isQuad,
-			hasMaterial,
-			hasFaceVertexUv,
-			hasFaceNormal, hasFaceVertexNormal,
-			hasFaceColor, hasFaceVertexColor,
-
-		vertex, face, faceA, faceB, hex, normal,
-
-			uvLayer, uv, u, v,
-
-			faces = json.faces,
-			vertices = json.vertices,
-			normals = json.normals,
-			colors = json.colors,
-
-			nUvLayers = 0;
-
-			if ( json.uvs !== undefined ) {
-
-				// disregard empty arrays
-
-				for ( i = 0; i < json.uvs.length; i ++ ) {
-
-					if ( json.uvs[ i ].length ) nUvLayers ++;
-
-				}
-
-				for ( i = 0; i < nUvLayers; i ++ ) {
-
-					geometry.faceVertexUvs[ i ] = [];
-
-				}
-
-			}
-
-			offset = 0;
-			zLength = vertices.length;
-
-			while ( offset < zLength ) {
-
-				vertex = new THREE.Vector3();
-
-				vertex.x = vertices[ offset ++ ] * scale;
-				vertex.y = vertices[ offset ++ ] * scale;
-				vertex.z = vertices[ offset ++ ] * scale;
-
-				geometry.vertices.push( vertex );
-
-			}
-
-			offset = 0;
-			zLength = faces.length;
-
-			while ( offset < zLength ) {
-
-				type = faces[ offset ++ ];
-
-
-				isQuad              = isBitSet( type, 0 );
-				hasMaterial         = isBitSet( type, 1 );
-				hasFaceVertexUv     = isBitSet( type, 3 );
-				hasFaceNormal       = isBitSet( type, 4 );
-				hasFaceVertexNormal = isBitSet( type, 5 );
-				hasFaceColor	     = isBitSet( type, 6 );
-				hasFaceVertexColor  = isBitSet( type, 7 );
-
-				// console.log("type", type, "bits", isQuad, hasMaterial, hasFaceVertexUv, hasFaceNormal, hasFaceVertexNormal, hasFaceColor, hasFaceVertexColor);
-
-				if ( isQuad ) {
-
-					faceA = new THREE.Face3();
-					faceA.a = faces[ offset ];
-					faceA.b = faces[ offset + 1 ];
-					faceA.c = faces[ offset + 3 ];
-
-					faceB = new THREE.Face3();
-					faceB.a = faces[ offset + 1 ];
-					faceB.b = faces[ offset + 2 ];
-					faceB.c = faces[ offset + 3 ];
-
-					offset += 4;
-
-					if ( hasMaterial ) {
-
-						materialIndex = faces[ offset ++ ];
-						faceA.materialIndex = materialIndex;
-						faceB.materialIndex = materialIndex;
-
-					}
-
-					// to get face <=> uv index correspondence
-
-					fi = geometry.faces.length;
-
-					if ( hasFaceVertexUv ) {
-
-						for ( i = 0; i < nUvLayers; i ++ ) {
-
-							uvLayer = json.uvs[ i ];
-
-							geometry.faceVertexUvs[ i ][ fi ] = [];
-							geometry.faceVertexUvs[ i ][ fi + 1 ] = [];
-
-							for ( j = 0; j < 4; j ++ ) {
-
-								uvIndex = faces[ offset ++ ];
-
-								u = uvLayer[ uvIndex * 2 ];
-								v = uvLayer[ uvIndex * 2 + 1 ];
-
-								uv = new THREE.Vector2( u, v );
-
-								if ( j !== 2 ) geometry.faceVertexUvs[ i ][ fi ].push( uv );
-								if ( j !== 0 ) geometry.faceVertexUvs[ i ][ fi + 1 ].push( uv );
-
-							}
-
-						}
-
-					}
-
-					if ( hasFaceNormal ) {
-
-						normalIndex = faces[ offset ++ ] * 3;
-
-						faceA.normal.set(
-							normals[ normalIndex ++ ],
-							normals[ normalIndex ++ ],
-							normals[ normalIndex ]
-						);
-
-						faceB.normal.copy( faceA.normal );
-
-					}
-
-					if ( hasFaceVertexNormal ) {
-
-						for ( i = 0; i < 4; i ++ ) {
-
-							normalIndex = faces[ offset ++ ] * 3;
-
-							normal = new THREE.Vector3(
-								normals[ normalIndex ++ ],
-								normals[ normalIndex ++ ],
-								normals[ normalIndex ]
-							);
-
-
-							if ( i !== 2 ) faceA.vertexNormals.push( normal );
-							if ( i !== 0 ) faceB.vertexNormals.push( normal );
-
-						}
-
-					}
-
-
-					if ( hasFaceColor ) {
-
-						colorIndex = faces[ offset ++ ];
-						hex = colors[ colorIndex ];
-
-						faceA.color.setHex( hex );
-						faceB.color.setHex( hex );
-
-					}
-
-
-					if ( hasFaceVertexColor ) {
-
-						for ( i = 0; i < 4; i ++ ) {
-
-							colorIndex = faces[ offset ++ ];
-							hex = colors[ colorIndex ];
-
-							if ( i !== 2 ) faceA.vertexColors.push( new THREE.Color( hex ) );
-							if ( i !== 0 ) faceB.vertexColors.push( new THREE.Color( hex ) );
-
-						}
-
-					}
-
-					geometry.faces.push( faceA );
-					geometry.faces.push( faceB );
-
-				} else {
-
-					face = new THREE.Face3();
-					face.a = faces[ offset ++ ];
-					face.b = faces[ offset ++ ];
-					face.c = faces[ offset ++ ];
-
-					if ( hasMaterial ) {
-
-						materialIndex = faces[ offset ++ ];
-						face.materialIndex = materialIndex;
-
-					}
-
-					// to get face <=> uv index correspondence
-
-					fi = geometry.faces.length;
-
-					if ( hasFaceVertexUv ) {
-
-						for ( i = 0; i < nUvLayers; i ++ ) {
-
-							uvLayer = json.uvs[ i ];
-
-							geometry.faceVertexUvs[ i ][ fi ] = [];
-
-							for ( j = 0; j < 3; j ++ ) {
-
-								uvIndex = faces[ offset ++ ];
-
-								u = uvLayer[ uvIndex * 2 ];
-								v = uvLayer[ uvIndex * 2 + 1 ];
-
-								uv = new THREE.Vector2( u, v );
-
-								geometry.faceVertexUvs[ i ][ fi ].push( uv );
-
-							}
-
-						}
-
-					}
-
-					if ( hasFaceNormal ) {
-
-						normalIndex = faces[ offset ++ ] * 3;
-
-						face.normal.set(
-							normals[ normalIndex ++ ],
-							normals[ normalIndex ++ ],
-							normals[ normalIndex ]
-						);
-
-					}
-
-					if ( hasFaceVertexNormal ) {
-
-						for ( i = 0; i < 3; i ++ ) {
-
-							normalIndex = faces[ offset ++ ] * 3;
-
-							normal = new THREE.Vector3(
-								normals[ normalIndex ++ ],
-								normals[ normalIndex ++ ],
-								normals[ normalIndex ]
-							);
-
-							face.vertexNormals.push( normal );
-
-						}
-
-					}
-
-
-					if ( hasFaceColor ) {
-
-						colorIndex = faces[ offset ++ ];
-						face.color.setHex( colors[ colorIndex ] );
-
-					}
-
-
-					if ( hasFaceVertexColor ) {
-
-						for ( i = 0; i < 3; i ++ ) {
-
-							colorIndex = faces[ offset ++ ];
-							face.vertexColors.push( new THREE.Color( colors[ colorIndex ] ) );
-
-						}
-
-					}
-
-					geometry.faces.push( face );
-
-				}
-
-			}
-
-		};
-
-		function parseSkin() {
-
-			var influencesPerVertex = ( json.influencesPerVertex !== undefined ) ? json.influencesPerVertex : 2;
-
-			if ( json.skinWeights ) {
-
-				for ( var i = 0, l = json.skinWeights.length; i < l; i += influencesPerVertex ) {
-
-					var x =                               json.skinWeights[ i ];
-					var y = ( influencesPerVertex > 1 ) ? json.skinWeights[ i + 1 ] : 0;
-					var z = ( influencesPerVertex > 2 ) ? json.skinWeights[ i + 2 ] : 0;
-					var w = ( influencesPerVertex > 3 ) ? json.skinWeights[ i + 3 ] : 0;
-
-					geometry.skinWeights.push( new THREE.Vector4( x, y, z, w ) );
-
-				}
-
-			}
-
-			if ( json.skinIndices ) {
-
-				for ( var i = 0, l = json.skinIndices.length; i < l; i += influencesPerVertex ) {
-
-					var a =                               json.skinIndices[ i ];
-					var b = ( influencesPerVertex > 1 ) ? json.skinIndices[ i + 1 ] : 0;
-					var c = ( influencesPerVertex > 2 ) ? json.skinIndices[ i + 2 ] : 0;
-					var d = ( influencesPerVertex > 3 ) ? json.skinIndices[ i + 3 ] : 0;
-
-					geometry.skinIndices.push( new THREE.Vector4( a, b, c, d ) );
-
-				}
-
-			}
-
-			geometry.bones = json.bones;
-
-			if ( geometry.bones && geometry.bones.length > 0 && ( geometry.skinWeights.length !== geometry.skinIndices.length || geometry.skinIndices.length !== geometry.vertices.length ) ) {
-
-				console.warn( 'When skinning, number of vertices (' + geometry.vertices.length + '), skinIndices (' +
-					geometry.skinIndices.length + '), and skinWeights (' + geometry.skinWeights.length + ') should match.' );
-
-			}
-
-		};
-
-		function parseMorphing( scale ) {
-
-			if ( json.morphTargets !== undefined ) {
-
-				for ( var i = 0, l = json.morphTargets.length; i < l; i ++ ) {
-
-					geometry.morphTargets[ i ] = {};
-					geometry.morphTargets[ i ].name = json.morphTargets[ i ].name;
-					geometry.morphTargets[ i ].vertices = [];
-
-					var dstVertices = geometry.morphTargets[ i ].vertices;
-					var srcVertices = json.morphTargets[ i ].vertices;
-
-					for ( var v = 0, vl = srcVertices.length; v < vl; v += 3 ) {
-
-						var vertex = new THREE.Vector3();
-						vertex.x = srcVertices[ v ] * scale;
-						vertex.y = srcVertices[ v + 1 ] * scale;
-						vertex.z = srcVertices[ v + 2 ] * scale;
-
-						dstVertices.push( vertex );
-
-					}
-
-				}
-
-			}
-
-			if ( json.morphColors !== undefined && json.morphColors.length > 0 ) {
-
-				console.warn( 'THREE.JSONLoader: "morphColors" no longer supported. Using them as face colors.' );
-
-				var faces = geometry.faces;
-				var morphColors = json.morphColors[ 0 ].colors;
-
-				for ( var i = 0, l = faces.length; i < l; i ++ ) {
-
-					faces[ i ].color.fromArray( morphColors, i * 3 );
-
-				}
-
-			}
-
-		}
-
-		function parseAnimations() {
-
-			var outputAnimations = [];
-
-			// parse old style Bone/Hierarchy animations
-			var animations = [];
-
-			if ( json.animation !== undefined ) {
-
-				animations.push( json.animation );
-
-			}
-
-			if ( json.animations !== undefined ) {
-
-				if ( json.animations.length ) {
-
-					animations = animations.concat( json.animations );
-
-				} else {
-
-					animations.push( json.animations );
-
-				}
-
-			}
-
-			for ( var i = 0; i < animations.length; i ++ ) {
-
-				var clip = THREE.AnimationClip.parseAnimation( animations[ i ], geometry.bones );
-				if ( clip ) outputAnimations.push( clip );
-
-			}
-
-			// parse implicit morph animations
-			if ( geometry.morphTargets ) {
-
-				// TODO: Figure out what an appropraite FPS is for morph target animations -- defaulting to 10, but really it is completely arbitrary.
-				var morphAnimationClips = THREE.AnimationClip.CreateClipsFromMorphTargetSequences( geometry.morphTargets, 10 );
-				outputAnimations = outputAnimations.concat( morphAnimationClips );
-
-			}
-
-			if ( outputAnimations.length > 0 ) geometry.animations = outputAnimations;
-
-		};
-
-		if ( json.materials === undefined || json.materials.length === 0 ) {
-
-			return { geometry: geometry };
-
-		} else {
-
-			var materials = THREE.Loader.prototype.initMaterials( json.materials, texturePath, this.crossOrigin );
-
-			return { geometry: geometry, materials: materials };
-
-		}
-
-	}
-
-};
-
-// File:src/loaders/LoadingManager.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.LoadingManager = function ( onLoad, onProgress, onError ) {
-
-	var scope = this;
-
-	var isLoading = false, itemsLoaded = 0, itemsTotal = 0;
-
-	this.onStart = undefined;
-	this.onLoad = onLoad;
-	this.onProgress = onProgress;
-	this.onError = onError;
-
-	this.itemStart = function ( url ) {
-
-		itemsTotal ++;
-
-		if ( isLoading === false ) {
-
-			if ( scope.onStart !== undefined ) {
-
-				scope.onStart( url, itemsLoaded, itemsTotal );
-
-			}
-
-		}
-
-		isLoading = true;
-
-	};
-
-	this.itemEnd = function ( url ) {
-
-		itemsLoaded ++;
-
-		if ( scope.onProgress !== undefined ) {
-
-			scope.onProgress( url, itemsLoaded, itemsTotal );
-
-		}
-
-		if ( itemsLoaded === itemsTotal ) {
-
-			isLoading = false;
-
-			if ( scope.onLoad !== undefined ) {
-
-				scope.onLoad();
-
-			}
-
-		}
-
-	};
-
-	this.itemError = function ( url ) {
-
-		if ( scope.onError !== undefined ) {
-
-			scope.onError( url );
-
-		}
-
-	};
-
-};
-
-THREE.DefaultLoadingManager = new THREE.LoadingManager();
-
-// File:src/loaders/BufferGeometryLoader.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.BufferGeometryLoader = function ( manager ) {
-
-	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
-
-};
-
-THREE.BufferGeometryLoader.prototype = {
-
-	constructor: THREE.BufferGeometryLoader,
-
-	load: function ( url, onLoad, onProgress, onError ) {
-
-		var scope = this;
-
-		var loader = new THREE.XHRLoader( scope.manager );
-		loader.load( url, function ( text ) {
-
-			onLoad( scope.parse( JSON.parse( text ) ) );
-
-		}, onProgress, onError );
-
-	},
-
-	parse: function ( json ) {
-
-		var geometry = new THREE.BufferGeometry();
-
-		var index = json.data.index;
-
-		var TYPED_ARRAYS = {
-			'Int8Array': Int8Array,
-			'Uint8Array': Uint8Array,
-			'Uint8ClampedArray': Uint8ClampedArray,
-			'Int16Array': Int16Array,
-			'Uint16Array': Uint16Array,
-			'Int32Array': Int32Array,
-			'Uint32Array': Uint32Array,
-			'Float32Array': Float32Array,
-			'Float64Array': Float64Array
-		};
-
-		if ( index !== undefined ) {
-
-			var typedArray = new TYPED_ARRAYS[ index.type ]( index.array );
-			geometry.setIndex( new THREE.BufferAttribute( typedArray, 1 ) );
-
-		}
-
-		var attributes = json.data.attributes;
-
-		for ( var key in attributes ) {
-
-			var attribute = attributes[ key ];
-			var typedArray = new TYPED_ARRAYS[ attribute.type ]( attribute.array );
-
-			geometry.addAttribute( key, new THREE.BufferAttribute( typedArray, attribute.itemSize, attribute.normalized ) );
-
-		}
-
-		var groups = json.data.groups || json.data.drawcalls || json.data.offsets;
-
-		if ( groups !== undefined ) {
-
-			for ( var i = 0, n = groups.length; i !== n; ++ i ) {
-
-				var group = groups[ i ];
-
-				geometry.addGroup( group.start, group.count, group.materialIndex );
-
-			}
-
-		}
-
-		var boundingSphere = json.data.boundingSphere;
-
-		if ( boundingSphere !== undefined ) {
-
-			var center = new THREE.Vector3();
-
-			if ( boundingSphere.center !== undefined ) {
-
-				center.fromArray( boundingSphere.center );
-
-			}
-
-			geometry.boundingSphere = new THREE.Sphere( center, boundingSphere.radius );
-
-		}
-
-		return geometry;
-
-	}
-
-};
-
-// File:src/loaders/MaterialLoader.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.MaterialLoader = function ( manager ) {
-
-	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
-	this.textures = {};
-
-};
-
-THREE.MaterialLoader.prototype = {
-
-	constructor: THREE.MaterialLoader,
-
-	load: function ( url, onLoad, onProgress, onError ) {
-
-		var scope = this;
-
-		var loader = new THREE.XHRLoader( scope.manager );
-		loader.load( url, function ( text ) {
-
-			onLoad( scope.parse( JSON.parse( text ) ) );
-
-		}, onProgress, onError );
-
-	},
-
-	setTextures: function ( value ) {
-
-		this.textures = value;
-
-	},
-
-	getTexture: function ( name ) {
-
-		var textures = this.textures;
-
-		if ( textures[ name ] === undefined ) {
-
-			console.warn( 'THREE.MaterialLoader: Undefined texture', name );
-
-		}
-
-		return textures[ name ];
-
-	},
-
-	parse: function ( json ) {
-
-		var material = new THREE[ json.type ];
-
-		if ( json.uuid !== undefined ) material.uuid = json.uuid;
-		if ( json.name !== undefined ) material.name = json.name;
-		if ( json.color !== undefined ) material.color.setHex( json.color );
-		if ( json.roughness !== undefined ) material.roughness = json.roughness;
-		if ( json.metalness !== undefined ) material.metalness = json.metalness;
-		if ( json.emissive !== undefined ) material.emissive.setHex( json.emissive );
-		if ( json.specular !== undefined ) material.specular.setHex( json.specular );
-		if ( json.shininess !== undefined ) material.shininess = json.shininess;
-		if ( json.uniforms !== undefined ) material.uniforms = json.uniforms;
-		if ( json.vertexShader !== undefined ) material.vertexShader = json.vertexShader;
-		if ( json.fragmentShader !== undefined ) material.fragmentShader = json.fragmentShader;
-		if ( json.vertexColors !== undefined ) material.vertexColors = json.vertexColors;
-		if ( json.shading !== undefined ) material.shading = json.shading;
-		if ( json.blending !== undefined ) material.blending = json.blending;
-		if ( json.side !== undefined ) material.side = json.side;
-		if ( json.opacity !== undefined ) material.opacity = json.opacity;
-		if ( json.transparent !== undefined ) material.transparent = json.transparent;
-		if ( json.alphaTest !== undefined ) material.alphaTest = json.alphaTest;
-		if ( json.depthTest !== undefined ) material.depthTest = json.depthTest;
-		if ( json.depthWrite !== undefined ) material.depthWrite = json.depthWrite;
-		if ( json.colorWrite !== undefined ) material.colorWrite = json.colorWrite;
-		if ( json.wireframe !== undefined ) material.wireframe = json.wireframe;
-		if ( json.wireframeLinewidth !== undefined ) material.wireframeLinewidth = json.wireframeLinewidth;
-
-		// for PointsMaterial
-		if ( json.size !== undefined ) material.size = json.size;
-		if ( json.sizeAttenuation !== undefined ) material.sizeAttenuation = json.sizeAttenuation;
-
-		// maps
-
-		if ( json.map !== undefined ) material.map = this.getTexture( json.map );
-
-		if ( json.alphaMap !== undefined ) {
-
-			material.alphaMap = this.getTexture( json.alphaMap );
-			material.transparent = true;
-
-		}
-
-		if ( json.bumpMap !== undefined ) material.bumpMap = this.getTexture( json.bumpMap );
-		if ( json.bumpScale !== undefined ) material.bumpScale = json.bumpScale;
-
-		if ( json.normalMap !== undefined ) material.normalMap = this.getTexture( json.normalMap );
-		if ( json.normalScale !== undefined ) {
-
-			var normalScale = json.normalScale;
-
-			if ( Array.isArray( normalScale ) === false ) {
-
-				// Blender exporter used to export a scalar. See #7459
-
-				normalScale = [ normalScale, normalScale ];
-
-			}
-
-			material.normalScale = new THREE.Vector2().fromArray( normalScale );
-
-		}
-
-		if ( json.displacementMap !== undefined ) material.displacementMap = this.getTexture( json.displacementMap );
-		if ( json.displacementScale !== undefined ) material.displacementScale = json.displacementScale;
-		if ( json.displacementBias !== undefined ) material.displacementBias = json.displacementBias;
-
-		if ( json.roughnessMap !== undefined ) material.roughnessMap = this.getTexture( json.roughnessMap );
-		if ( json.metalnessMap !== undefined ) material.metalnessMap = this.getTexture( json.metalnessMap );
-
-		if ( json.emissiveMap !== undefined ) material.emissiveMap = this.getTexture( json.emissiveMap );
-		if ( json.emissiveIntensity !== undefined ) material.emissiveIntensity = json.emissiveIntensity;
-
-		if ( json.specularMap !== undefined ) material.specularMap = this.getTexture( json.specularMap );
-
-		if ( json.envMap !== undefined ) {
-
-			material.envMap = this.getTexture( json.envMap );
-			material.combine = THREE.MultiplyOperation;
-
-		}
-
-		if ( json.reflectivity ) material.reflectivity = json.reflectivity;
-
-		if ( json.lightMap !== undefined ) material.lightMap = this.getTexture( json.lightMap );
-		if ( json.lightMapIntensity !== undefined ) material.lightMapIntensity = json.lightMapIntensity;
-
-		if ( json.aoMap !== undefined ) material.aoMap = this.getTexture( json.aoMap );
-		if ( json.aoMapIntensity !== undefined ) material.aoMapIntensity = json.aoMapIntensity;
-
-		// MultiMaterial
-
-		if ( json.materials !== undefined ) {
-
-			for ( var i = 0, l = json.materials.length; i < l; i ++ ) {
-
-				material.materials.push( this.parse( json.materials[ i ] ) );
-
-			}
-
-		}
-
-		return material;
-
-	}
-
-};
-
-// File:src/loaders/ObjectLoader.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.ObjectLoader = function ( manager ) {
-
-	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
-	this.texturePath = '';
-
-};
-
-THREE.ObjectLoader.prototype = {
-
-	constructor: THREE.ObjectLoader,
-
-	load: function ( url, onLoad, onProgress, onError ) {
-
-		if ( this.texturePath === '' ) {
-
-			this.texturePath = url.substring( 0, url.lastIndexOf( '/' ) + 1 );
-
-		}
-
-		var scope = this;
-
-		var loader = new THREE.XHRLoader( scope.manager );
-		loader.load( url, function ( text ) {
-
-			scope.parse( JSON.parse( text ), onLoad );
-
-		}, onProgress, onError );
-
-	},
-
-	setTexturePath: function ( value ) {
-
-		this.texturePath = value;
-
-	},
-
-	setCrossOrigin: function ( value ) {
-
-		this.crossOrigin = value;
-
-	},
-
-	parse: function ( json, onLoad ) {
-
-		var geometries = this.parseGeometries( json.geometries );
-
-		var images = this.parseImages( json.images, function () {
-
-			if ( onLoad !== undefined ) onLoad( object );
-
-		} );
-
-		var textures  = this.parseTextures( json.textures, images );
-		var materials = this.parseMaterials( json.materials, textures );
-
-		var object = this.parseObject( json.object, geometries, materials );
-
-		if ( json.animations ) {
-
-			object.animations = this.parseAnimations( json.animations );
-
-		}
-
-		if ( json.images === undefined || json.images.length === 0 ) {
-
-			if ( onLoad !== undefined ) onLoad( object );
-
-		}
-
-		return object;
-
-	},
-
-	parseGeometries: function ( json ) {
-
-		var geometries = {};
-
-		if ( json !== undefined ) {
-
-			var geometryLoader = new THREE.JSONLoader();
-			var bufferGeometryLoader = new THREE.BufferGeometryLoader();
-
-			for ( var i = 0, l = json.length; i < l; i ++ ) {
-
-				var geometry;
-				var data = json[ i ];
-
-				switch ( data.type ) {
-
-					case 'PlaneGeometry':
-					case 'PlaneBufferGeometry':
-
-						geometry = new THREE[ data.type ](
-							data.width,
-							data.height,
-							data.widthSegments,
-							data.heightSegments
-						);
-
-						break;
-
-					case 'BoxGeometry':
-					case 'BoxBufferGeometry':
-					case 'CubeGeometry': // backwards compatible
-
-						geometry = new THREE[ data.type ](
-							data.width,
-							data.height,
-							data.depth,
-							data.widthSegments,
-							data.heightSegments,
-							data.depthSegments
-						);
-
-						break;
-
-					case 'CircleGeometry':
-					case 'CircleBufferGeometry':
-
-						geometry = new THREE[ data.type ](
-							data.radius,
-							data.segments,
-							data.thetaStart,
-							data.thetaLength
-						);
-
-						break;
-
-					case 'CylinderGeometry':
-					case 'CylinderBufferGeometry':
-
-						geometry = new THREE[ data.type ](
-							data.radiusTop,
-							data.radiusBottom,
-							data.height,
-							data.radialSegments,
-							data.heightSegments,
-							data.openEnded,
-							data.thetaStart,
-							data.thetaLength
-						);
-
-						break;
-
-					case 'SphereGeometry':
-					case 'SphereBufferGeometry':
-
-						geometry = new THREE[ data.type ](
-							data.radius,
-							data.widthSegments,
-							data.heightSegments,
-							data.phiStart,
-							data.phiLength,
-							data.thetaStart,
-							data.thetaLength
-						);
-
-						break;
-
-					case 'DodecahedronGeometry':
-
-						geometry = new THREE.DodecahedronGeometry(
-							data.radius,
-							data.detail
-						);
-
-						break;
-
-					case 'IcosahedronGeometry':
-
-						geometry = new THREE.IcosahedronGeometry(
-							data.radius,
-							data.detail
-						);
-
-						break;
-
-					case 'OctahedronGeometry':
-
-						geometry = new THREE.OctahedronGeometry(
-							data.radius,
-							data.detail
-						);
-
-						break;
-
-					case 'TetrahedronGeometry':
-
-						geometry = new THREE.TetrahedronGeometry(
-							data.radius,
-							data.detail
-						);
-
-						break;
-
-					case 'RingGeometry':
-					case 'RingBufferGeometry':
-
-						geometry = new THREE[ data.type ](
-							data.innerRadius,
-							data.outerRadius,
-							data.thetaSegments,
-							data.phiSegments,
-							data.thetaStart,
-							data.thetaLength
-						);
-
-						break;
-
-					case 'TorusGeometry':
-					case 'TorusBufferGeometry':
-
-						geometry = new THREE[ data.type ](
-							data.radius,
-							data.tube,
-							data.radialSegments,
-							data.tubularSegments,
-							data.arc
-						);
-
-						break;
-
-					case 'TorusKnotGeometry':
-					case 'TorusKnotBufferGeometry':
-
-						geometry = new THREE[ data.type ](
-							data.radius,
-							data.tube,
-							data.tubularSegments,
-							data.radialSegments,
-							data.p,
-							data.q
-						);
-
-						break;
-
-					case 'LatheGeometry':
-					case 'LatheBufferGeometry':
-
-						geometry = new THREE[ data.type ](
-							data.points,
-							data.segments,
-							data.phiStart,
-							data.phiLength
-						);
-
-						break;
-
-					case 'BufferGeometry':
-
-						geometry = bufferGeometryLoader.parse( data );
-
-						break;
-
-					case 'Geometry':
-
-						geometry = geometryLoader.parse( data.data, this.texturePath ).geometry;
-
-						break;
-
-					default:
-
-						console.warn( 'THREE.ObjectLoader: Unsupported geometry type "' + data.type + '"' );
-
-						continue;
-
-				}
-
-				geometry.uuid = data.uuid;
-
-				if ( data.name !== undefined ) geometry.name = data.name;
-
-				geometries[ data.uuid ] = geometry;
-
-			}
-
-		}
-
-		return geometries;
-
-	},
-
-	parseMaterials: function ( json, textures ) {
-
-		var materials = {};
-
-		if ( json !== undefined ) {
-
-			var loader = new THREE.MaterialLoader();
-			loader.setTextures( textures );
-
-			for ( var i = 0, l = json.length; i < l; i ++ ) {
-
-				var material = loader.parse( json[ i ] );
-				materials[ material.uuid ] = material;
-
-			}
-
-		}
-
-		return materials;
-
-	},
-
-	parseAnimations: function ( json ) {
-
-		var animations = [];
-
-		for ( var i = 0; i < json.length; i ++ ) {
-
-			var clip = THREE.AnimationClip.parse( json[ i ] );
-
-			animations.push( clip );
-
-		}
-
-		return animations;
-
-	},
-
-	parseImages: function ( json, onLoad ) {
-
-		var scope = this;
-		var images = {};
-
-		function loadImage( url ) {
-
-			scope.manager.itemStart( url );
-
-			return loader.load( url, function () {
-
-				scope.manager.itemEnd( url );
-
-			} );
-
-		}
-
-		if ( json !== undefined && json.length > 0 ) {
-
-			var manager = new THREE.LoadingManager( onLoad );
-
-			var loader = new THREE.ImageLoader( manager );
-			loader.setCrossOrigin( this.crossOrigin );
-
-			for ( var i = 0, l = json.length; i < l; i ++ ) {
-
-				var image = json[ i ];
-				var path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test( image.url ) ? image.url : scope.texturePath + image.url;
-
-				images[ image.uuid ] = loadImage( path );
-
-			}
-
-		}
-
-		return images;
-
-	},
-
-	parseTextures: function ( json, images ) {
-
-		function parseConstant( value ) {
-
-			if ( typeof( value ) === 'number' ) return value;
-
-			console.warn( 'THREE.ObjectLoader.parseTexture: Constant should be in numeric form.', value );
-
-			return THREE[ value ];
-
-		}
-
-		var textures = {};
-
-		if ( json !== undefined ) {
-
-			for ( var i = 0, l = json.length; i < l; i ++ ) {
-
-				var data = json[ i ];
-
-				if ( data.image === undefined ) {
-
-					console.warn( 'THREE.ObjectLoader: No "image" specified for', data.uuid );
-
-				}
-
-				if ( images[ data.image ] === undefined ) {
-
-					console.warn( 'THREE.ObjectLoader: Undefined image', data.image );
-
-				}
-
-				var texture = new THREE.Texture( images[ data.image ] );
-				texture.needsUpdate = true;
-
-				texture.uuid = data.uuid;
-
-				if ( data.name !== undefined ) texture.name = data.name;
-				if ( data.mapping !== undefined ) texture.mapping = parseConstant( data.mapping );
-				if ( data.offset !== undefined ) texture.offset = new THREE.Vector2( data.offset[ 0 ], data.offset[ 1 ] );
-				if ( data.repeat !== undefined ) texture.repeat = new THREE.Vector2( data.repeat[ 0 ], data.repeat[ 1 ] );
-				if ( data.minFilter !== undefined ) texture.minFilter = parseConstant( data.minFilter );
-				if ( data.magFilter !== undefined ) texture.magFilter = parseConstant( data.magFilter );
-				if ( data.anisotropy !== undefined ) texture.anisotropy = data.anisotropy;
-				if ( Array.isArray( data.wrap ) ) {
-
-					texture.wrapS = parseConstant( data.wrap[ 0 ] );
-					texture.wrapT = parseConstant( data.wrap[ 1 ] );
-
-				}
-
-				textures[ data.uuid ] = texture;
-
-			}
-
-		}
-
-		return textures;
-
-	},
-
-	parseObject: function () {
-
-		var matrix = new THREE.Matrix4();
-
-		return function ( data, geometries, materials ) {
-
-			var object;
-
-			function getGeometry( name ) {
-
-				if ( geometries[ name ] === undefined ) {
-
-					console.warn( 'THREE.ObjectLoader: Undefined geometry', name );
-
-				}
-
-				return geometries[ name ];
-
-			}
-
-			function getMaterial( name ) {
-
-				if ( name === undefined ) return undefined;
-
-				if ( materials[ name ] === undefined ) {
-
-					console.warn( 'THREE.ObjectLoader: Undefined material', name );
-
-				}
-
-				return materials[ name ];
-
-			}
-
-			switch ( data.type ) {
-
-				case 'Scene':
-
-					object = new THREE.Scene();
-
-					break;
-
-				case 'PerspectiveCamera':
-
-					object = new THREE.PerspectiveCamera(
-							data.fov, data.aspect, data.near, data.far );
-
-					if ( data.focus !== undefined ) object.focus = data.focus;
-					if ( data.zoom !== undefined ) object.zoom = data.zoom;
-					if ( data.filmGauge !== undefined ) object.filmGauge = data.filmGauge;
-					if ( data.filmOffset !== undefined ) object.filmOffset = data.filmOffset;
-					if ( data.view !== undefined ) object.view = Object.assign( {}, data.view );
-
-					break;
-
-				case 'OrthographicCamera':
-
-					object = new THREE.OrthographicCamera( data.left, data.right, data.top, data.bottom, data.near, data.far );
-
-					break;
-
-				case 'AmbientLight':
-
-					object = new THREE.AmbientLight( data.color, data.intensity );
-
-					break;
-
-				case 'DirectionalLight':
-
-					object = new THREE.DirectionalLight( data.color, data.intensity );
-
-					break;
-
-				case 'PointLight':
-
-					object = new THREE.PointLight( data.color, data.intensity, data.distance, data.decay );
-
-					break;
-
-				case 'SpotLight':
-
-					object = new THREE.SpotLight( data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay );
-
-					break;
-
-				case 'HemisphereLight':
-
-					object = new THREE.HemisphereLight( data.color, data.groundColor, data.intensity );
-
-					break;
-
-				case 'Mesh':
-
-					var geometry = getGeometry( data.geometry );
-					var material = getMaterial( data.material );
-
-					if ( geometry.bones && geometry.bones.length > 0 ) {
-
-						object = new THREE.SkinnedMesh( geometry, material );
-
-					} else {
-
-						object = new THREE.Mesh( geometry, material );
-
-					}
-
-					break;
-
-				case 'LOD':
-
-					object = new THREE.LOD();
-
-					break;
-
-				case 'Line':
-
-					object = new THREE.Line( getGeometry( data.geometry ), getMaterial( data.material ), data.mode );
-
-					break;
-
-				case 'PointCloud':
-				case 'Points':
-
-					object = new THREE.Points( getGeometry( data.geometry ), getMaterial( data.material ) );
-
-					break;
-
-				case 'Sprite':
-
-					object = new THREE.Sprite( getMaterial( data.material ) );
-
-					break;
-
-				case 'Group':
-
-					object = new THREE.Group();
-
-					break;
-
-				default:
-
-					object = new THREE.Object3D();
-
-			}
-
-			object.uuid = data.uuid;
-
-			if ( data.name !== undefined ) object.name = data.name;
-			if ( data.matrix !== undefined ) {
-
-				matrix.fromArray( data.matrix );
-				matrix.decompose( object.position, object.quaternion, object.scale );
-
-			} else {
-
-				if ( data.position !== undefined ) object.position.fromArray( data.position );
-				if ( data.rotation !== undefined ) object.rotation.fromArray( data.rotation );
-				if ( data.scale !== undefined ) object.scale.fromArray( data.scale );
-
-			}
-
-			if ( data.castShadow !== undefined ) object.castShadow = data.castShadow;
-			if ( data.receiveShadow !== undefined ) object.receiveShadow = data.receiveShadow;
-
-			if ( data.visible !== undefined ) object.visible = data.visible;
-			if ( data.userData !== undefined ) object.userData = data.userData;
-
-			if ( data.children !== undefined ) {
-
-				for ( var child in data.children ) {
-
-					object.add( this.parseObject( data.children[ child ], geometries, materials ) );
-
-				}
-
-			}
-
-			if ( data.type === 'LOD' ) {
-
-				var levels = data.levels;
-
-				for ( var l = 0; l < levels.length; l ++ ) {
-
-					var level = levels[ l ];
-					var child = object.getObjectByProperty( 'uuid', level.object );
-
-					if ( child !== undefined ) {
-
-						object.addLevel( child, level.distance );
-
-					}
-
-				}
-
-			}
-
-			return object;
-
-		};
-
-	}()
-
-};
-
-// File:src/loaders/TextureLoader.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.TextureLoader = function ( manager ) {
-
-	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
-
-};
-
-THREE.TextureLoader.prototype = {
-
-	constructor: THREE.TextureLoader,
-
-	load: function ( url, onLoad, onProgress, onError ) {
-
-		var texture = new THREE.Texture();
-
-		var loader = new THREE.ImageLoader( this.manager );
-		loader.setCrossOrigin( this.crossOrigin );
-		loader.setPath( this.path );
-		loader.load( url, function ( image ) {
-
-			texture.image = image;
-			texture.needsUpdate = true;
-
-			if ( onLoad !== undefined ) {
-
-				onLoad( texture );
-
-			}
-
-		}, onProgress, onError );
-
-		return texture;
-
-	},
-
-	setCrossOrigin: function ( value ) {
-
-		this.crossOrigin = value;
-
-	},
-
-	setPath: function ( value ) {
-
-		this.path = value;
-
-	}
-
-};
-
-// File:src/loaders/CubeTextureLoader.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.CubeTextureLoader = function ( manager ) {
-
-	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
-
-};
-
-THREE.CubeTextureLoader.prototype = {
-
-	constructor: THREE.CubeTextureLoader,
-
-	load: function ( urls, onLoad, onProgress, onError ) {
-
-		var texture = new THREE.CubeTexture();
-
-		var loader = new THREE.ImageLoader( this.manager );
-		loader.setCrossOrigin( this.crossOrigin );
-		loader.setPath( this.path );
-
-		var loaded = 0;
-
-		function loadTexture( i ) {
-
-			loader.load( urls[ i ], function ( image ) {
-
-				texture.images[ i ] = image;
-
-				loaded ++;
-
-				if ( loaded === 6 ) {
-
-					texture.needsUpdate = true;
-
-					if ( onLoad ) onLoad( texture );
-
-				}
-
-			}, undefined, onError );
-
-		}
-
-		for ( var i = 0; i < urls.length; ++ i ) {
-
-			loadTexture( i );
-
-		}
-
-		return texture;
-
-	},
-
-	setCrossOrigin: function ( value ) {
-
-		this.crossOrigin = value;
-
-	},
-
-	setPath: function ( value ) {
-
-		this.path = value;
-
-	}
-
-};
-
-// File:src/loaders/BinaryTextureLoader.js
-
-/**
- * @author Nikos M. / https://github.com/foo123/
- *
- * Abstract Base class to load generic binary textures formats (rgbe, hdr, ...)
- */
-
-THREE.DataTextureLoader = THREE.BinaryTextureLoader = function ( manager ) {
-
-	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
-
-	// override in sub classes
-	this._parser = null;
-
-};
-
-THREE.BinaryTextureLoader.prototype = {
-
-	constructor: THREE.BinaryTextureLoader,
-
-	load: function ( url, onLoad, onProgress, onError ) {
-
-		var scope = this;
-
-		var texture = new THREE.DataTexture();
-
-		var loader = new THREE.XHRLoader( this.manager );
-		loader.setResponseType( 'arraybuffer' );
-
-		loader.load( url, function ( buffer ) {
-
-			var texData = scope._parser( buffer );
-
-			if ( ! texData ) return;
-
-			if ( undefined !== texData.image ) {
-
-				texture.image = texData.image;
-
-			} else if ( undefined !== texData.data ) {
-
-				texture.image.width = texData.width;
-				texture.image.height = texData.height;
-				texture.image.data = texData.data;
-
-			}
-
-			texture.wrapS = undefined !== texData.wrapS ? texData.wrapS : THREE.ClampToEdgeWrapping;
-			texture.wrapT = undefined !== texData.wrapT ? texData.wrapT : THREE.ClampToEdgeWrapping;
-
-			texture.magFilter = undefined !== texData.magFilter ? texData.magFilter : THREE.LinearFilter;
-			texture.minFilter = undefined !== texData.minFilter ? texData.minFilter : THREE.LinearMipMapLinearFilter;
-
-			texture.anisotropy = undefined !== texData.anisotropy ? texData.anisotropy : 1;
-
-			if ( undefined !== texData.format ) {
-
-				texture.format = texData.format;
-
-			}
-			if ( undefined !== texData.type ) {
-
-				texture.type = texData.type;
-
-			}
-
-			if ( undefined !== texData.mipmaps ) {
-
-				texture.mipmaps = texData.mipmaps;
-
-			}
-
-			if ( 1 === texData.mipmapCount ) {
-
-				texture.minFilter = THREE.LinearFilter;
-
-			}
-
-			texture.needsUpdate = true;
-
-			if ( onLoad ) onLoad( texture, texData );
-
-		}, onProgress, onError );
-
-
-		return texture;
-
-	}
-
-};
-
-// File:src/loaders/CompressedTextureLoader.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- *
- * Abstract Base class to block based textures loader (dds, pvr, ...)
- */
-
-THREE.CompressedTextureLoader = function ( manager ) {
-
-	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
-
-	// override in sub classes
-	this._parser = null;
-
-};
-
-
-THREE.CompressedTextureLoader.prototype = {
-
-	constructor: THREE.CompressedTextureLoader,
-
-	load: function ( url, onLoad, onProgress, onError ) {
-
-		var scope = this;
-
-		var images = [];
-
-		var texture = new THREE.CompressedTexture();
-		texture.image = images;
-
-		var loader = new THREE.XHRLoader( this.manager );
-		loader.setPath( this.path );
-		loader.setResponseType( 'arraybuffer' );
-
-		function loadTexture( i ) {
-
-			loader.load( url[ i ], function ( buffer ) {
-
-				var texDatas = scope._parser( buffer, true );
-
-				images[ i ] = {
-					width: texDatas.width,
-					height: texDatas.height,
-					format: texDatas.format,
-					mipmaps: texDatas.mipmaps
-				};
-
-				loaded += 1;
-
-				if ( loaded === 6 ) {
-
-					if ( texDatas.mipmapCount === 1 )
-						texture.minFilter = THREE.LinearFilter;
-
-					texture.format = texDatas.format;
-					texture.needsUpdate = true;
-
-					if ( onLoad ) onLoad( texture );
-
-				}
-
-			}, onProgress, onError );
-
-		}
-
-		if ( Array.isArray( url ) ) {
-
-			var loaded = 0;
-
-			for ( var i = 0, il = url.length; i < il; ++ i ) {
-
-				loadTexture( i );
-
-			}
-
-		} else {
-
-			// compressed cubemap texture stored in a single DDS file
-
-			loader.load( url, function ( buffer ) {
-
-				var texDatas = scope._parser( buffer, true );
-
-				if ( texDatas.isCubemap ) {
-
-					var faces = texDatas.mipmaps.length / texDatas.mipmapCount;
-
-					for ( var f = 0; f < faces; f ++ ) {
-
-						images[ f ] = { mipmaps : [] };
-
-						for ( var i = 0; i < texDatas.mipmapCount; i ++ ) {
-
-							images[ f ].mipmaps.push( texDatas.mipmaps[ f * texDatas.mipmapCount + i ] );
-							images[ f ].format = texDatas.format;
-							images[ f ].width = texDatas.width;
-							images[ f ].height = texDatas.height;
-
-						}
-
-					}
-
-				} else {
-
-					texture.image.width = texDatas.width;
-					texture.image.height = texDatas.height;
-					texture.mipmaps = texDatas.mipmaps;
-
-				}
-
-				if ( texDatas.mipmapCount === 1 ) {
-
-					texture.minFilter = THREE.LinearFilter;
-
-				}
-
-				texture.format = texDatas.format;
-				texture.needsUpdate = true;
-
-				if ( onLoad ) onLoad( texture );
-
-			}, onProgress, onError );
-
-		}
-
-		return texture;
-
-	},
-
-	setPath: function ( value ) {
-
-		this.path = value;
-
-	}
-
-};
-
-// File:src/materials/Material.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.Material = function () {
-
-	Object.defineProperty( this, 'id', { value: THREE.MaterialIdCount ++ } );
-
-	this.uuid = THREE.Math.generateUUID();
-
-	this.name = '';
-	this.type = 'Material';
-
-	this.side = THREE.FrontSide;
-
-	this.opacity = 1;
-	this.transparent = false;
-
-	this.blending = THREE.NormalBlending;
-
-	this.blendSrc = THREE.SrcAlphaFactor;
-	this.blendDst = THREE.OneMinusSrcAlphaFactor;
-	this.blendEquation = THREE.AddEquation;
-	this.blendSrcAlpha = null;
-	this.blendDstAlpha = null;
-	this.blendEquationAlpha = null;
-
-	this.depthFunc = THREE.LessEqualDepth;
-	this.depthTest = true;
-	this.depthWrite = true;
-
-	this.clippingPlanes = null;
-	this.clipShadows = false;
-
-	this.colorWrite = true;
-
-	this.precision = null; // override the renderer's default precision for this material
-
-	this.polygonOffset = false;
-	this.polygonOffsetFactor = 0;
-	this.polygonOffsetUnits = 0;
-
-	this.alphaTest = 0;
-	this.premultipliedAlpha = false;
-
-	this.overdraw = 0; // Overdrawn pixels (typically between 0 and 1) for fixing antialiasing gaps in CanvasRenderer
-
-	this.visible = true;
-
-	this._needsUpdate = true;
-
-};
-
-THREE.Material.prototype = {
-
-	constructor: THREE.Material,
-
-	get needsUpdate () {
-
-		return this._needsUpdate;
-
-	},
-
-	set needsUpdate ( value ) {
-
-		if ( value === true ) this.update();
-
-		this._needsUpdate = value;
-
-	},
-
-	setValues: function ( values ) {
-
-		if ( values === undefined ) return;
-
-		for ( var key in values ) {
-
-			var newValue = values[ key ];
-
-			if ( newValue === undefined ) {
-
-				console.warn( "THREE.Material: '" + key + "' parameter is undefined." );
-				continue;
-
-			}
-
-			var currentValue = this[ key ];
-
-			if ( currentValue === undefined ) {
-
-				console.warn( "THREE." + this.type + ": '" + key + "' is not a property of this material." );
-				continue;
-
-			}
-
-			if ( currentValue instanceof THREE.Color ) {
-
-				currentValue.set( newValue );
-
-			} else if ( currentValue instanceof THREE.Vector3 && newValue instanceof THREE.Vector3 ) {
-
-				currentValue.copy( newValue );
-
-			} else if ( key === 'overdraw' ) {
-
-				// ensure overdraw is backwards-compatible with legacy boolean type
-				this[ key ] = Number( newValue );
-
-			} else {
-
-				this[ key ] = newValue;
-
-			}
-
-		}
-
-	},
-
-	toJSON: function ( meta ) {
-
-		var isRoot = meta === undefined;
-
-		if ( isRoot ) {
-
-			meta = {
-				textures: {},
-				images: {}
-			};
-
-		}
-
-		var data = {
-			metadata: {
-				version: 4.4,
-				type: 'Material',
-				generator: 'Material.toJSON'
-			}
-		};
-
-		// standard Material serialization
-		data.uuid = this.uuid;
-		data.type = this.type;
-		if ( this.name !== '' ) data.name = this.name;
-
-		if ( this.color instanceof THREE.Color ) data.color = this.color.getHex();
-
-		if ( this.roughness !== 0.5 ) data.roughness = this.roughness;
-		if ( this.metalness !== 0.5 ) data.metalness = this.metalness;
-
-		if ( this.emissive instanceof THREE.Color ) data.emissive = this.emissive.getHex();
-		if ( this.specular instanceof THREE.Color ) data.specular = this.specular.getHex();
-		if ( this.shininess !== undefined ) data.shininess = this.shininess;
-
-		if ( this.map instanceof THREE.Texture ) data.map = this.map.toJSON( meta ).uuid;
-		if ( this.alphaMap instanceof THREE.Texture ) data.alphaMap = this.alphaMap.toJSON( meta ).uuid;
-		if ( this.lightMap instanceof THREE.Texture ) data.lightMap = this.lightMap.toJSON( meta ).uuid;
-		if ( this.bumpMap instanceof THREE.Texture ) {
-
-			data.bumpMap = this.bumpMap.toJSON( meta ).uuid;
-			data.bumpScale = this.bumpScale;
-
-		}
-		if ( this.normalMap instanceof THREE.Texture ) {
-
-			data.normalMap = this.normalMap.toJSON( meta ).uuid;
-			data.normalScale = this.normalScale.toArray();
-
-		}
-		if ( this.displacementMap instanceof THREE.Texture ) {
-
-			data.displacementMap = this.displacementMap.toJSON( meta ).uuid;
-			data.displacementScale = this.displacementScale;
-			data.displacementBias = this.displacementBias;
-
-		}
-		if ( this.roughnessMap instanceof THREE.Texture ) data.roughnessMap = this.roughnessMap.toJSON( meta ).uuid;
-		if ( this.metalnessMap instanceof THREE.Texture ) data.metalnessMap = this.metalnessMap.toJSON( meta ).uuid;
-
-		if ( this.emissiveMap instanceof THREE.Texture ) data.emissiveMap = this.emissiveMap.toJSON( meta ).uuid;
-		if ( this.specularMap instanceof THREE.Texture ) data.specularMap = this.specularMap.toJSON( meta ).uuid;
-
-		if ( this.envMap instanceof THREE.Texture ) {
-
-			data.envMap = this.envMap.toJSON( meta ).uuid;
-			data.reflectivity = this.reflectivity; // Scale behind envMap
-
-		}
-
-		if ( this.size !== undefined ) data.size = this.size;
-		if ( this.sizeAttenuation !== undefined ) data.sizeAttenuation = this.sizeAttenuation;
-
-		if ( this.vertexColors !== undefined && this.vertexColors !== THREE.NoColors ) data.vertexColors = this.vertexColors;
-		if ( this.shading !== undefined && this.shading !== THREE.SmoothShading ) data.shading = this.shading;
-		if ( this.blending !== undefined && this.blending !== THREE.NormalBlending ) data.blending = this.blending;
-		if ( this.side !== undefined && this.side !== THREE.FrontSide ) data.side = this.side;
-
-		if ( this.opacity < 1 ) data.opacity = this.opacity;
-		if ( this.transparent === true ) data.transparent = this.transparent;
-		if ( this.alphaTest > 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;
-
-		// 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.side = source.side;
-
-		this.opacity = source.opacity;
-		this.transparent = source.transparent;
-
-		this.blending = source.blending;
-
-		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.colorWrite = source.colorWrite;
-
-		this.precision = source.precision;
-
-		this.polygonOffset = source.polygonOffset;
-		this.polygonOffsetFactor = source.polygonOffsetFactor;
-		this.polygonOffsetUnits = source.polygonOffsetUnits;
-
-		this.alphaTest = source.alphaTest;
-
-		this.premultipliedAlpha = source.premultipliedAlpha;
-
-		this.overdraw = source.overdraw;
-
-		this.visible = source.visible;
-		this.clipShadows = source.clipShadows;
-
-		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;
-
-		return this;
-
-	},
-
-	update: function () {
-
-		this.dispatchEvent( { type: 'update' } );
-
-	},
-
-	dispose: function () {
-
-		this.dispatchEvent( { type: 'dispose' } );
-
-	}
-
-};
-
-THREE.EventDispatcher.prototype.apply( THREE.Material.prototype );
-
-THREE.MaterialIdCount = 0;
-
-// File:src/materials/LineBasicMaterial.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- *
- * parameters = {
- *  color: <hex>,
- *  opacity: <float>,
- *
- *  linewidth: <float>,
- *  linecap: "round",
- *  linejoin: "round",
- *
- *  blending: THREE.NormalBlending,
- *  depthTest: <bool>,
- *  depthWrite: <bool>,
- *
- *  vertexColors: <bool>
- *
- *  fog: <bool>
- * }
- */
-
-THREE.LineBasicMaterial = function ( parameters ) {
-
-	THREE.Material.call( this );
-
-	this.type = 'LineBasicMaterial';
-
-	this.color = new THREE.Color( 0xffffff );
-
-	this.linewidth = 1;
-	this.linecap = 'round';
-	this.linejoin = 'round';
-
-	this.blending = THREE.NormalBlending;
-
-	this.vertexColors = THREE.NoColors;
-
-	this.fog = true;
-
-	this.setValues( parameters );
-
-};
-
-THREE.LineBasicMaterial.prototype = Object.create( THREE.Material.prototype );
-THREE.LineBasicMaterial.prototype.constructor = THREE.LineBasicMaterial;
-
-THREE.LineBasicMaterial.prototype.copy = function ( source ) {
-
-	THREE.Material.prototype.copy.call( this, source );
-
-	this.color.copy( source.color );
-
-	this.linewidth = source.linewidth;
-	this.linecap = source.linecap;
-	this.linejoin = source.linejoin;
-
-	this.vertexColors = source.vertexColors;
-
-	this.fog = source.fog;
-
-	return this;
-
-};
-
-// File:src/materials/LineDashedMaterial.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- *
- * parameters = {
- *  color: <hex>,
- *  opacity: <float>,
- *
- *  linewidth: <float>,
- *
- *  scale: <float>,
- *  dashSize: <float>,
- *  gapSize: <float>,
- *
- *  blending: THREE.NormalBlending,
- *  depthTest: <bool>,
- *  depthWrite: <bool>,
- *
- *  vertexColors: THREE.NoColors / THREE.FaceColors / THREE.VertexColors
- *
- *  fog: <bool>
- * }
- */
-
-THREE.LineDashedMaterial = function ( parameters ) {
-
-	THREE.Material.call( this );
-
-	this.type = 'LineDashedMaterial';
-
-	this.color = new THREE.Color( 0xffffff );
-
-	this.linewidth = 1;
-
-	this.scale = 1;
-	this.dashSize = 3;
-	this.gapSize = 1;
-
-	this.blending = THREE.NormalBlending;
-
-	this.vertexColors = THREE.NoColors;
-
-	this.fog = true;
-
-	this.setValues( parameters );
-
-};
-
-THREE.LineDashedMaterial.prototype = Object.create( THREE.Material.prototype );
-THREE.LineDashedMaterial.prototype.constructor = THREE.LineDashedMaterial;
-
-THREE.LineDashedMaterial.prototype.copy = function ( source ) {
-
-	THREE.Material.prototype.copy.call( this, source );
-
-	this.color.copy( source.color );
-
-	this.linewidth = source.linewidth;
-
-	this.scale = source.scale;
-	this.dashSize = source.dashSize;
-	this.gapSize = source.gapSize;
-
-	this.vertexColors = source.vertexColors;
-
-	this.fog = source.fog;
-
-	return this;
-
-};
-
-// File:src/materials/MeshBasicMaterial.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- *
- * parameters = {
- *  color: <hex>,
- *  opacity: <float>,
- *  map: new THREE.Texture( <Image> ),
- *
- *  aoMap: new THREE.Texture( <Image> ),
- *  aoMapIntensity: <float>
- *
- *  specularMap: new THREE.Texture( <Image> ),
- *
- *  alphaMap: new THREE.Texture( <Image> ),
- *
- *  envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),
- *  combine: THREE.Multiply,
- *  reflectivity: <float>,
- *  refractionRatio: <float>,
- *
- *  shading: THREE.SmoothShading,
- *  blending: THREE.NormalBlending,
- *  depthTest: <bool>,
- *  depthWrite: <bool>,
- *
- *  wireframe: <boolean>,
- *  wireframeLinewidth: <float>,
- *
- *  vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors,
- *
- *  skinning: <bool>,
- *  morphTargets: <bool>,
- *
- *  fog: <bool>
- * }
- */
-
-THREE.MeshBasicMaterial = function ( parameters ) {
-
-	THREE.Material.call( this );
-
-	this.type = 'MeshBasicMaterial';
-
-	this.color = new THREE.Color( 0xffffff ); // emissive
-
-	this.map = null;
-
-	this.aoMap = null;
-	this.aoMapIntensity = 1.0;
-
-	this.specularMap = null;
-
-	this.alphaMap = null;
-
-	this.envMap = null;
-	this.combine = THREE.MultiplyOperation;
-	this.reflectivity = 1;
-	this.refractionRatio = 0.98;
-
-	this.fog = true;
-
-	this.shading = THREE.SmoothShading;
-	this.blending = THREE.NormalBlending;
-
-	this.wireframe = false;
-	this.wireframeLinewidth = 1;
-	this.wireframeLinecap = 'round';
-	this.wireframeLinejoin = 'round';
-
-	this.vertexColors = THREE.NoColors;
-
-	this.skinning = false;
-	this.morphTargets = false;
-
-	this.setValues( parameters );
-
-};
-
-THREE.MeshBasicMaterial.prototype = Object.create( THREE.Material.prototype );
-THREE.MeshBasicMaterial.prototype.constructor = THREE.MeshBasicMaterial;
-
-THREE.MeshBasicMaterial.prototype.copy = function ( source ) {
-
-	THREE.Material.prototype.copy.call( this, source );
-
-	this.color.copy( source.color );
-
-	this.map = source.map;
-
-	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.fog = source.fog;
-
-	this.shading = source.shading;
-
-	this.wireframe = source.wireframe;
-	this.wireframeLinewidth = source.wireframeLinewidth;
-	this.wireframeLinecap = source.wireframeLinecap;
-	this.wireframeLinejoin = source.wireframeLinejoin;
-
-	this.vertexColors = source.vertexColors;
-
-	this.skinning = source.skinning;
-	this.morphTargets = source.morphTargets;
-
-	return this;
-
-};
-
-// File:src/materials/MeshDepthMaterial.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- * @author bhouston / https://clara.io
- * @author WestLangley / http://github.com/WestLangley
- *
- * parameters = {
- *
- *  opacity: <float>,
- *
- *  map: new THREE.Texture( <Image> ),
- *
- *  alphaMap: new THREE.Texture( <Image> ),
- *
- *  displacementMap: new THREE.Texture( <Image> ),
- *  displacementScale: <float>,
- *  displacementBias: <float>,
- *
- *  wireframe: <boolean>,
- *  wireframeLinewidth: <float>
- * }
- */
-
-THREE.MeshDepthMaterial = function ( parameters ) {
-
-	THREE.Material.call( this );
-
-	this.type = 'MeshDepthMaterial';
-
-	this.depthPacking = THREE.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.setValues( parameters );
-
-};
-
-THREE.MeshDepthMaterial.prototype = Object.create( THREE.Material.prototype );
-THREE.MeshDepthMaterial.prototype.constructor = THREE.MeshDepthMaterial;
-
-THREE.MeshDepthMaterial.prototype.copy = function ( source ) {
-
-	THREE.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;
-
-};
-
-// File:src/materials/MeshLambertMaterial.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- *
- * parameters = {
- *  color: <hex>,
- *  opacity: <float>,
- *
- *  map: new THREE.Texture( <Image> ),
- *
- *  lightMap: new THREE.Texture( <Image> ),
- *  lightMapIntensity: <float>
- *
- *  aoMap: new THREE.Texture( <Image> ),
- *  aoMapIntensity: <float>
- *
- *  emissive: <hex>,
- *  emissiveIntensity: <float>
- *  emissiveMap: new THREE.Texture( <Image> ),
- *
- *  specularMap: new THREE.Texture( <Image> ),
- *
- *  alphaMap: new THREE.Texture( <Image> ),
- *
- *  envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),
- *  combine: THREE.Multiply,
- *  reflectivity: <float>,
- *  refractionRatio: <float>,
- *
- *  blending: THREE.NormalBlending,
- *  depthTest: <bool>,
- *  depthWrite: <bool>,
- *
- *  wireframe: <boolean>,
- *  wireframeLinewidth: <float>,
- *
- *  vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors,
- *
- *  skinning: <bool>,
- *  morphTargets: <bool>,
- *  morphNormals: <bool>,
- *
- *	fog: <bool>
- * }
- */
-
-THREE.MeshLambertMaterial = function ( parameters ) {
-
-	THREE.Material.call( this );
-
-	this.type = 'MeshLambertMaterial';
-
-	this.color = new THREE.Color( 0xffffff ); // diffuse
-
-	this.map = null;
-
-	this.lightMap = null;
-	this.lightMapIntensity = 1.0;
-
-	this.aoMap = null;
-	this.aoMapIntensity = 1.0;
-
-	this.emissive = new THREE.Color( 0x000000 );
-	this.emissiveIntensity = 1.0;
-	this.emissiveMap = null;
-
-	this.specularMap = null;
-
-	this.alphaMap = null;
-
-	this.envMap = null;
-	this.combine = THREE.MultiplyOperation;
-	this.reflectivity = 1;
-	this.refractionRatio = 0.98;
-
-	this.fog = true;
-
-	this.blending = THREE.NormalBlending;
-
-	this.wireframe = false;
-	this.wireframeLinewidth = 1;
-	this.wireframeLinecap = 'round';
-	this.wireframeLinejoin = 'round';
-
-	this.vertexColors = THREE.NoColors;
-
-	this.skinning = false;
-	this.morphTargets = false;
-	this.morphNormals = false;
-
-	this.setValues( parameters );
-
-};
-
-THREE.MeshLambertMaterial.prototype = Object.create( THREE.Material.prototype );
-THREE.MeshLambertMaterial.prototype.constructor = THREE.MeshLambertMaterial;
-
-THREE.MeshLambertMaterial.prototype.copy = function ( source ) {
-
-	THREE.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.fog = source.fog;
-
-	this.wireframe = source.wireframe;
-	this.wireframeLinewidth = source.wireframeLinewidth;
-	this.wireframeLinecap = source.wireframeLinecap;
-	this.wireframeLinejoin = source.wireframeLinejoin;
-
-	this.vertexColors = source.vertexColors;
-
-	this.skinning = source.skinning;
-	this.morphTargets = source.morphTargets;
-	this.morphNormals = source.morphNormals;
-
-	return this;
-
-};
-
-// File:src/materials/MeshNormalMaterial.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- *
- * parameters = {
- *  opacity: <float>,
- *
- *  wireframe: <boolean>,
- *  wireframeLinewidth: <float>
- * }
- */
-
-THREE.MeshNormalMaterial = function ( parameters ) {
-
-	THREE.Material.call( this, parameters );
-
-	this.type = 'MeshNormalMaterial';
-
-	this.wireframe = false;
-	this.wireframeLinewidth = 1;
-
-	this.morphTargets = false;
-
-	this.setValues( parameters );
-
-};
-
-THREE.MeshNormalMaterial.prototype = Object.create( THREE.Material.prototype );
-THREE.MeshNormalMaterial.prototype.constructor = THREE.MeshNormalMaterial;
-
-THREE.MeshNormalMaterial.prototype.copy = function ( source ) {
-
-	THREE.Material.prototype.copy.call( this, source );
-
-	this.wireframe = source.wireframe;
-	this.wireframeLinewidth = source.wireframeLinewidth;
-
-	return this;
-
-};
-
-// File:src/materials/MeshPhongMaterial.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- *
- * parameters = {
- *  color: <hex>,
- *  specular: <hex>,
- *  shininess: <float>,
- *  opacity: <float>,
- *
- *  map: new THREE.Texture( <Image> ),
- *
- *  lightMap: new THREE.Texture( <Image> ),
- *  lightMapIntensity: <float>
- *
- *  aoMap: new THREE.Texture( <Image> ),
- *  aoMapIntensity: <float>
- *
- *  emissive: <hex>,
- *  emissiveIntensity: <float>
- *  emissiveMap: new THREE.Texture( <Image> ),
- *
- *  bumpMap: new THREE.Texture( <Image> ),
- *  bumpScale: <float>,
- *
- *  normalMap: new THREE.Texture( <Image> ),
- *  normalScale: <Vector2>,
- *
- *  displacementMap: new THREE.Texture( <Image> ),
- *  displacementScale: <float>,
- *  displacementBias: <float>,
- *
- *  specularMap: new THREE.Texture( <Image> ),
- *
- *  alphaMap: new THREE.Texture( <Image> ),
- *
- *  envMap: new THREE.TextureCube( [posx, negx, posy, negy, posz, negz] ),
- *  combine: THREE.Multiply,
- *  reflectivity: <float>,
- *  refractionRatio: <float>,
- *
- *  shading: THREE.SmoothShading,
- *  blending: THREE.NormalBlending,
- *  depthTest: <bool>,
- *  depthWrite: <bool>,
- *
- *  wireframe: <boolean>,
- *  wireframeLinewidth: <float>,
- *
- *  vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors,
- *
- *  skinning: <bool>,
- *  morphTargets: <bool>,
- *  morphNormals: <bool>,
- *
- *	fog: <bool>
- * }
- */
-
-THREE.MeshPhongMaterial = function ( parameters ) {
-
-	THREE.Material.call( this );
-
-	this.type = 'MeshPhongMaterial';
-
-	this.color = new THREE.Color( 0xffffff ); // diffuse
-	this.specular = new THREE.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 THREE.Color( 0x000000 );
-	this.emissiveIntensity = 1.0;
-	this.emissiveMap = null;
-
-	this.bumpMap = null;
-	this.bumpScale = 1;
-
-	this.normalMap = null;
-	this.normalScale = new THREE.Vector2( 1, 1 );
-
-	this.displacementMap = null;
-	this.displacementScale = 1;
-	this.displacementBias = 0;
-
-	this.specularMap = null;
-
-	this.alphaMap = null;
-
-	this.envMap = null;
-	this.combine = THREE.MultiplyOperation;
-	this.reflectivity = 1;
-	this.refractionRatio = 0.98;
-
-	this.fog = true;
-
-	this.shading = THREE.SmoothShading;
-	this.blending = THREE.NormalBlending;
-
-	this.wireframe = false;
-	this.wireframeLinewidth = 1;
-	this.wireframeLinecap = 'round';
-	this.wireframeLinejoin = 'round';
-
-	this.vertexColors = THREE.NoColors;
-
-	this.skinning = false;
-	this.morphTargets = false;
-	this.morphNormals = false;
-
-	this.setValues( parameters );
-
-};
-
-THREE.MeshPhongMaterial.prototype = Object.create( THREE.Material.prototype );
-THREE.MeshPhongMaterial.prototype.constructor = THREE.MeshPhongMaterial;
-
-THREE.MeshPhongMaterial.prototype.copy = function ( source ) {
-
-	THREE.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.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.fog = source.fog;
-
-	this.shading = source.shading;
-
-	this.wireframe = source.wireframe;
-	this.wireframeLinewidth = source.wireframeLinewidth;
-	this.wireframeLinecap = source.wireframeLinecap;
-	this.wireframeLinejoin = source.wireframeLinejoin;
-
-	this.vertexColors = source.vertexColors;
-
-	this.skinning = source.skinning;
-	this.morphTargets = source.morphTargets;
-	this.morphNormals = source.morphNormals;
-
-	return this;
-
-};
-
-// File:src/materials/MeshStandardMaterial.js
-
-/**
- * @author WestLangley / http://github.com/WestLangley
- *
- * parameters = {
- *  color: <hex>,
- *  roughness: <float>,
- *  metalness: <float>,
- *  opacity: <float>,
- *
- *  map: new THREE.Texture( <Image> ),
- *
- *  lightMap: new THREE.Texture( <Image> ),
- *  lightMapIntensity: <float>
- *
- *  aoMap: new THREE.Texture( <Image> ),
- *  aoMapIntensity: <float>
- *
- *  emissive: <hex>,
- *  emissiveIntensity: <float>
- *  emissiveMap: new THREE.Texture( <Image> ),
- *
- *  bumpMap: new THREE.Texture( <Image> ),
- *  bumpScale: <float>,
- *
- *  normalMap: new THREE.Texture( <Image> ),
- *  normalScale: <Vector2>,
- *
- *  displacementMap: new THREE.Texture( <Image> ),
- *  displacementScale: <float>,
- *  displacementBias: <float>,
- *
- *  roughnessMap: new THREE.Texture( <Image> ),
- *
- *  metalnessMap: new THREE.Texture( <Image> ),
- *
- *  alphaMap: new THREE.Texture( <Image> ),
- *
- *  envMap: new THREE.CubeTexture( [posx, negx, posy, negy, posz, negz] ),
- *  envMapIntensity: <float>
- *
- *  refractionRatio: <float>,
- *
- *  shading: THREE.SmoothShading,
- *  blending: THREE.NormalBlending,
- *  depthTest: <bool>,
- *  depthWrite: <bool>,
- *
- *  wireframe: <boolean>,
- *  wireframeLinewidth: <float>,
- *
- *  vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors,
- *
- *  skinning: <bool>,
- *  morphTargets: <bool>,
- *  morphNormals: <bool>,
- *
- *	fog: <bool>
- * }
- */
-
-THREE.MeshStandardMaterial = function ( parameters ) {
-
-	THREE.Material.call( this );
-
-	this.defines = { 'STANDARD': '' };
-
-	this.type = 'MeshStandardMaterial';
-
-	this.color = new THREE.Color( 0xffffff ); // diffuse
-	this.roughness = 0.5;
-	this.metalness = 0.5;
-
-	this.map = null;
-
-	this.lightMap = null;
-	this.lightMapIntensity = 1.0;
-
-	this.aoMap = null;
-	this.aoMapIntensity = 1.0;
-
-	this.emissive = new THREE.Color( 0x000000 );
-	this.emissiveIntensity = 1.0;
-	this.emissiveMap = null;
-
-	this.bumpMap = null;
-	this.bumpScale = 1;
-
-	this.normalMap = null;
-	this.normalScale = new THREE.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.fog = true;
-
-	this.shading = THREE.SmoothShading;
-	this.blending = THREE.NormalBlending;
-
-	this.wireframe = false;
-	this.wireframeLinewidth = 1;
-	this.wireframeLinecap = 'round';
-	this.wireframeLinejoin = 'round';
-
-	this.vertexColors = THREE.NoColors;
-
-	this.skinning = false;
-	this.morphTargets = false;
-	this.morphNormals = false;
-
-	this.setValues( parameters );
-
-};
-
-THREE.MeshStandardMaterial.prototype = Object.create( THREE.Material.prototype );
-THREE.MeshStandardMaterial.prototype.constructor = THREE.MeshStandardMaterial;
-
-THREE.MeshStandardMaterial.prototype.copy = function ( source ) {
-
-	THREE.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.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.fog = source.fog;
-
-	this.shading = source.shading;
-
-	this.wireframe = source.wireframe;
-	this.wireframeLinewidth = source.wireframeLinewidth;
-	this.wireframeLinecap = source.wireframeLinecap;
-	this.wireframeLinejoin = source.wireframeLinejoin;
-
-	this.vertexColors = source.vertexColors;
-
-	this.skinning = source.skinning;
-	this.morphTargets = source.morphTargets;
-	this.morphNormals = source.morphNormals;
-
-	return this;
-
-};
-
-// File:src/materials/MeshPhysicalMaterial.js
-
-/**
- * @author WestLangley / http://github.com/WestLangley
- *
- * parameters = {
- *  reflectivity: <float>
- * }
- */
-
-THREE.MeshPhysicalMaterial = function ( parameters ) {
-
-	THREE.MeshStandardMaterial.call( this );
-
-	this.defines = { 'PHYSICAL': '' };
-
-	this.type = 'MeshPhysicalMaterial';
-
-	this.reflectivity = 0.5; // maps to F0 = 0.04
-
-	this.setValues( parameters );
-
-};
-
-THREE.MeshPhysicalMaterial.prototype = Object.create( THREE.MeshStandardMaterial.prototype );
-THREE.MeshPhysicalMaterial.prototype.constructor = THREE.MeshPhysicalMaterial;
-
-THREE.MeshPhysicalMaterial.prototype.copy = function ( source ) {
-
-	THREE.MeshStandardMaterial.prototype.copy.call( this, source );
-
-	this.defines = { 'PHYSICAL': '' };
-
-	this.reflectivity = source.reflectivity;
-
-	return this;
-
-};
-
-// File:src/materials/MultiMaterial.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.MultiMaterial = function ( materials ) {
-
-	this.uuid = THREE.Math.generateUUID();
-
-	this.type = 'MultiMaterial';
-
-	this.materials = materials instanceof Array ? materials : [];
-
-	this.visible = true;
-
-};
-
-THREE.MultiMaterial.prototype = {
-
-	constructor: THREE.MultiMaterial,
-
-	toJSON: function ( meta ) {
-
-		var output = {
-			metadata: {
-				version: 4.2,
-				type: 'material',
-				generator: 'MaterialExporter'
-			},
-			uuid: this.uuid,
-			type: this.type,
-			materials: []
-		};
-
-		var materials = this.materials;
-
-		for ( var i = 0, l = materials.length; i < l; i ++ ) {
-
-			var material = materials[ i ].toJSON( meta );
-			delete material.metadata;
-
-			output.materials.push( material );
-
-		}
-
-		output.visible = this.visible;
-
-		return output;
-
-	},
-
-	clone: function () {
-
-		var material = new this.constructor();
-
-		for ( var i = 0; i < this.materials.length; i ++ ) {
-
-			material.materials.push( this.materials[ i ].clone() );
-
-		}
-
-		material.visible = this.visible;
-
-		return material;
-
-	}
-
-};
-
-// File:src/materials/PointsMaterial.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- *
- * parameters = {
- *  color: <hex>,
- *  opacity: <float>,
- *  map: new THREE.Texture( <Image> ),
- *
- *  size: <float>,
- *  sizeAttenuation: <bool>,
- *
- *  blending: THREE.NormalBlending,
- *  depthTest: <bool>,
- *  depthWrite: <bool>,
- *
- *  vertexColors: <bool>,
- *
- *  fog: <bool>
- * }
- */
-
-THREE.PointsMaterial = function ( parameters ) {
-
-	THREE.Material.call( this );
-
-	this.type = 'PointsMaterial';
-
-	this.color = new THREE.Color( 0xffffff );
-
-	this.map = null;
-
-	this.size = 1;
-	this.sizeAttenuation = true;
-
-	this.blending = THREE.NormalBlending;
-
-	this.vertexColors = THREE.NoColors;
-
-	this.fog = true;
-
-	this.setValues( parameters );
-
-};
-
-THREE.PointsMaterial.prototype = Object.create( THREE.Material.prototype );
-THREE.PointsMaterial.prototype.constructor = THREE.PointsMaterial;
-
-THREE.PointsMaterial.prototype.copy = function ( source ) {
-
-	THREE.Material.prototype.copy.call( this, source );
-
-	this.color.copy( source.color );
-
-	this.map = source.map;
-
-	this.size = source.size;
-	this.sizeAttenuation = source.sizeAttenuation;
-
-	this.vertexColors = source.vertexColors;
-
-	this.fog = source.fog;
-
-	return this;
-
-};
-
-// File:src/materials/ShaderMaterial.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- *
- * parameters = {
- *  defines: { "label" : "value" },
- *  uniforms: { "parameter1": { type: "1f", value: 1.0 }, "parameter2": { type: "1i" value2: 2 } },
- *
- *  fragmentShader: <string>,
- *  vertexShader: <string>,
- *
- *  shading: THREE.SmoothShading,
- *
- *  wireframe: <boolean>,
- *  wireframeLinewidth: <float>,
- *
- *  lights: <bool>,
- *
- *  vertexColors: THREE.NoColors / THREE.VertexColors / THREE.FaceColors,
- *
- *  skinning: <bool>,
- *  morphTargets: <bool>,
- *  morphNormals: <bool>,
- *
- *	fog: <bool>
- * }
- */
-
-THREE.ShaderMaterial = function ( parameters ) {
-
-	THREE.Material.call( this );
-
-	this.type = 'ShaderMaterial';
-
-	this.defines = {};
-	this.uniforms = {};
-
-	this.vertexShader = 'void main() {\n\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}';
-	this.fragmentShader = 'void main() {\n\tgl_FragColor = vec4( 1.0, 0.0, 0.0, 1.0 );\n}';
-
-	this.shading = THREE.SmoothShading;
-
-	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.vertexColors = THREE.NoColors; // set to use "color" attribute stream
-
-	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;
-
-	if ( parameters !== undefined ) {
-
-		if ( parameters.attributes !== undefined ) {
-
-			console.error( 'THREE.ShaderMaterial: attributes should now be defined in THREE.BufferGeometry instead.' );
-
-		}
-
-		this.setValues( parameters );
-
-	}
-
-};
-
-THREE.ShaderMaterial.prototype = Object.create( THREE.Material.prototype );
-THREE.ShaderMaterial.prototype.constructor = THREE.ShaderMaterial;
-
-THREE.ShaderMaterial.prototype.copy = function ( source ) {
-
-	THREE.Material.prototype.copy.call( this, source );
-
-	this.fragmentShader = source.fragmentShader;
-	this.vertexShader = source.vertexShader;
-
-	this.uniforms = THREE.UniformsUtils.clone( source.uniforms );
-
-	this.defines = source.defines;
-
-	this.shading = source.shading;
-
-	this.wireframe = source.wireframe;
-	this.wireframeLinewidth = source.wireframeLinewidth;
-
-	this.fog = source.fog;
-
-	this.lights = source.lights;
-	this.clipping = source.clipping;
-
-	this.vertexColors = source.vertexColors;
-
-	this.skinning = source.skinning;
-
-	this.morphTargets = source.morphTargets;
-	this.morphNormals = source.morphNormals;
-
-	this.extensions = source.extensions;
-
-	return this;
-
-};
-
-THREE.ShaderMaterial.prototype.toJSON = function ( meta ) {
-
-	var data = THREE.Material.prototype.toJSON.call( this, meta );
-
-	data.uniforms = this.uniforms;
-	data.vertexShader = this.vertexShader;
-	data.fragmentShader = this.fragmentShader;
-
-	return data;
-
-};
-
-// File:src/materials/RawShaderMaterial.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.RawShaderMaterial = function ( parameters ) {
-
-	THREE.ShaderMaterial.call( this, parameters );
-
-	this.type = 'RawShaderMaterial';
-
-};
-
-THREE.RawShaderMaterial.prototype = Object.create( THREE.ShaderMaterial.prototype );
-THREE.RawShaderMaterial.prototype.constructor = THREE.RawShaderMaterial;
-
-// File:src/materials/SpriteMaterial.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- *
- * parameters = {
- *  color: <hex>,
- *  opacity: <float>,
- *  map: new THREE.Texture( <Image> ),
- *
- *	uvOffset: new THREE.Vector2(),
- *	uvScale: new THREE.Vector2(),
- *
- *  fog: <bool>
- * }
- */
-
-THREE.SpriteMaterial = function ( parameters ) {
-
-	THREE.Material.call( this );
-
-	this.type = 'SpriteMaterial';
-
-	this.color = new THREE.Color( 0xffffff );
-	this.map = null;
-
-	this.rotation = 0;
-
-	this.fog = false;
-
-	// set parameters
-
-	this.setValues( parameters );
-
-};
-
-THREE.SpriteMaterial.prototype = Object.create( THREE.Material.prototype );
-THREE.SpriteMaterial.prototype.constructor = THREE.SpriteMaterial;
-
-THREE.SpriteMaterial.prototype.copy = function ( source ) {
-
-	THREE.Material.prototype.copy.call( this, source );
-
-	this.color.copy( source.color );
-	this.map = source.map;
-
-	this.rotation = source.rotation;
-
-	this.fog = source.fog;
-
-	return this;
-
-};
-
-// File:src/textures/Texture.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- * @author szimek / https://github.com/szimek/
- */
-
-THREE.Texture = function ( image, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) {
-
-	Object.defineProperty( this, 'id', { value: THREE.TextureIdCount ++ } );
-
-	this.uuid = THREE.Math.generateUUID();
-
-	this.name = '';
-	this.sourceFile = '';
-
-	this.image = image !== undefined ? image : THREE.Texture.DEFAULT_IMAGE;
-	this.mipmaps = [];
-
-	this.mapping = mapping !== undefined ? mapping : THREE.Texture.DEFAULT_MAPPING;
-
-	this.wrapS = wrapS !== undefined ? wrapS : THREE.ClampToEdgeWrapping;
-	this.wrapT = wrapT !== undefined ? wrapT : THREE.ClampToEdgeWrapping;
-
-	this.magFilter = magFilter !== undefined ? magFilter : THREE.LinearFilter;
-	this.minFilter = minFilter !== undefined ? minFilter : THREE.LinearMipMapLinearFilter;
-
-	this.anisotropy = anisotropy !== undefined ? anisotropy : 1;
-
-	this.format = format !== undefined ? format : THREE.RGBAFormat;
-	this.type = type !== undefined ? type : THREE.UnsignedByteType;
-
-	this.offset = new THREE.Vector2( 0, 0 );
-	this.repeat = new THREE.Vector2( 1, 1 );
-
-	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 :  THREE.LinearEncoding;
-
-	this.version = 0;
-	this.onUpdate = null;
-
-};
-
-THREE.Texture.DEFAULT_IMAGE = undefined;
-THREE.Texture.DEFAULT_MAPPING = THREE.UVMapping;
-
-THREE.Texture.prototype = {
-
-	constructor: THREE.Texture,
-
-	set needsUpdate ( value ) {
-
-		if ( value === true ) this.version ++;
-
-	},
-
-	clone: function () {
-
-		return new this.constructor().copy( this );
-
-	},
-
-	copy: function ( source ) {
-
-		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.type = source.type;
-
-		this.offset.copy( source.offset );
-		this.repeat.copy( source.repeat );
-
-		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 ) {
-
-		if ( meta.textures[ this.uuid ] !== undefined ) {
-
-			return meta.textures[ this.uuid ];
-
-		}
-
-		function getDataURL( image ) {
-
-			var canvas;
-
-			if ( image.toDataURL !== undefined ) {
-
-				canvas = image;
-
-			} else {
-
-				canvas = document.createElement( 'canvas' );
-				canvas.width = image.width;
-				canvas.height = image.height;
-
-				canvas.getContext( '2d' ).drawImage( image, 0, 0, image.width, image.height );
-
-			}
-
-			if ( canvas.width > 2048 || canvas.height > 2048 ) {
-
-				return canvas.toDataURL( 'image/jpeg', 0.6 );
-
-			} else {
-
-				return canvas.toDataURL( 'image/png' );
-
-			}
-
-		}
-
-		var output = {
-			metadata: {
-				version: 4.4,
-				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 ],
-			wrap: [ this.wrapS, this.wrapT ],
-
-			minFilter: this.minFilter,
-			magFilter: this.magFilter,
-			anisotropy: this.anisotropy
-		};
-
-		if ( this.image !== undefined ) {
-
-			// TODO: Move to THREE.Image
-
-			var image = this.image;
-
-			if ( image.uuid === undefined ) {
-
-				image.uuid = THREE.Math.generateUUID(); // UGH
-
-			}
-
-			if ( meta.images[ image.uuid ] === undefined ) {
-
-				meta.images[ image.uuid ] = {
-					uuid: image.uuid,
-					url: getDataURL( image )
-				};
-
-			}
-
-			output.image = image.uuid;
-
-		}
-
-		meta.textures[ this.uuid ] = output;
-
-		return output;
-
-	},
-
-	dispose: function () {
-
-		this.dispatchEvent( { type: 'dispose' } );
-
-	},
-
-	transformUv: function ( uv ) {
-
-		if ( this.mapping !== THREE.UVMapping )  return;
-
-		uv.multiply( this.repeat );
-		uv.add( this.offset );
-
-		if ( uv.x < 0 || uv.x > 1 ) {
-
-			switch ( this.wrapS ) {
-
-				case THREE.RepeatWrapping:
-
-					uv.x = uv.x - Math.floor( uv.x );
-					break;
-
-				case THREE.ClampToEdgeWrapping:
-
-					uv.x = uv.x < 0 ? 0 : 1;
-					break;
-
-				case THREE.MirroredRepeatWrapping:
-
-					if ( Math.abs( Math.floor( uv.x ) % 2 ) === 1 ) {
-
-						uv.x = Math.ceil( uv.x ) - uv.x;
-
-					} else {
-
-						uv.x = uv.x - Math.floor( uv.x );
-
-					}
-					break;
-
-			}
-
-		}
-
-		if ( uv.y < 0 || uv.y > 1 ) {
-
-			switch ( this.wrapT ) {
-
-				case THREE.RepeatWrapping:
-
-					uv.y = uv.y - Math.floor( uv.y );
-					break;
-
-				case THREE.ClampToEdgeWrapping:
-
-					uv.y = uv.y < 0 ? 0 : 1;
-					break;
-
-				case THREE.MirroredRepeatWrapping:
-
-					if ( Math.abs( Math.floor( uv.y ) % 2 ) === 1 ) {
-
-						uv.y = Math.ceil( uv.y ) - uv.y;
-
-					} else {
-
-						uv.y = uv.y - Math.floor( uv.y );
-
-					}
-					break;
-
-			}
-
-		}
-
-		if ( this.flipY ) {
-
-			uv.y = 1 - uv.y;
-
-		}
-
-	}
-
-};
-
-THREE.EventDispatcher.prototype.apply( THREE.Texture.prototype );
-
-THREE.TextureIdCount = 0;
-
-// File:src/textures/DepthTexture.js
-
-/**
- * @author Matt DesLauriers / @mattdesl
- */
-
-THREE.DepthTexture = function ( width, height, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy ) {
-
-  THREE.Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, THREE.DepthFormat, type, anisotropy );
-
-  this.image = { width: width, height: height };
-
-  this.type = type !== undefined ? type : THREE.UnsignedShortType;
-
-  this.magFilter = magFilter !== undefined ? magFilter : THREE.NearestFilter;
-  this.minFilter = minFilter !== undefined ? minFilter : THREE.NearestFilter;
-
-  this.flipY = false;
-  this.generateMipmaps  = false;
-
-};
-
-THREE.DepthTexture.prototype = Object.create( THREE.Texture.prototype );
-THREE.DepthTexture.prototype.constructor = THREE.DepthTexture;
-
-// File:src/textures/CanvasTexture.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.CanvasTexture = function ( canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {
-
-	THREE.Texture.call( this, canvas, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );
-
-	this.needsUpdate = true;
-
-};
-
-THREE.CanvasTexture.prototype = Object.create( THREE.Texture.prototype );
-THREE.CanvasTexture.prototype.constructor = THREE.CanvasTexture;
-
-// File:src/textures/CubeTexture.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.CubeTexture = function ( images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding ) {
-
-	images = images !== undefined ? images : [];
-	mapping = mapping !== undefined ? mapping : THREE.CubeReflectionMapping;
-
-	THREE.Texture.call( this, images, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );
-
-	this.flipY = false;
-
-};
-
-THREE.CubeTexture.prototype = Object.create( THREE.Texture.prototype );
-THREE.CubeTexture.prototype.constructor = THREE.CubeTexture;
-
-Object.defineProperty( THREE.CubeTexture.prototype, 'images', {
-
-	get: function () {
-
-		return this.image;
-
-	},
-
-	set: function ( value ) {
-
-		this.image = value;
-
-	}
-
-} );
-
-// File:src/textures/CompressedTexture.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.CompressedTexture = function ( mipmaps, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) {
-
-	THREE.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;
-
-};
-
-THREE.CompressedTexture.prototype = Object.create( THREE.Texture.prototype );
-THREE.CompressedTexture.prototype.constructor = THREE.CompressedTexture;
-
-// File:src/textures/DataTexture.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.DataTexture = function ( data, width, height, format, type, mapping, wrapS, wrapT, magFilter, minFilter, anisotropy, encoding ) {
-
-	THREE.Texture.call( this, null, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy, encoding );
-
-	this.image = { data: data, width: width, height: height };
-
-	this.magFilter = magFilter !== undefined ? magFilter : THREE.NearestFilter;
-	this.minFilter = minFilter !== undefined ? minFilter : THREE.NearestFilter;
-
-	this.flipY = false;
-	this.generateMipmaps  = false;
-
-};
-
-THREE.DataTexture.prototype = Object.create( THREE.Texture.prototype );
-THREE.DataTexture.prototype.constructor = THREE.DataTexture;
-
-// File:src/textures/VideoTexture.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.VideoTexture = function ( video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy ) {
-
-	THREE.Texture.call( this, video, mapping, wrapS, wrapT, magFilter, minFilter, format, type, anisotropy );
-
-	this.generateMipmaps = false;
-
-	var scope = this;
-
-	function update() {
-
-		requestAnimationFrame( update );
-
-		if ( video.readyState >= video.HAVE_CURRENT_DATA ) {
-
-			scope.needsUpdate = true;
-
-		}
-
-	}
-
-	update();
-
-};
-
-THREE.VideoTexture.prototype = Object.create( THREE.Texture.prototype );
-THREE.VideoTexture.prototype.constructor = THREE.VideoTexture;
-
-// File:src/objects/Group.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.Group = function () {
-
-	THREE.Object3D.call( this );
-
-	this.type = 'Group';
-
-};
-
-THREE.Group.prototype = Object.create( THREE.Object3D.prototype );
-THREE.Group.prototype.constructor = THREE.Group;
-
-// File:src/objects/Points.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.Points = function ( geometry, material ) {
-
-	THREE.Object3D.call( this );
-
-	this.type = 'Points';
-
-	this.geometry = geometry !== undefined ? geometry : new THREE.Geometry();
-	this.material = material !== undefined ? material : new THREE.PointsMaterial( { color: Math.random() * 0xffffff } );
-
-};
-
-THREE.Points.prototype = Object.create( THREE.Object3D.prototype );
-THREE.Points.prototype.constructor = THREE.Points;
-
-THREE.Points.prototype.raycast = ( function () {
-
-	var inverseMatrix = new THREE.Matrix4();
-	var ray = new THREE.Ray();
-	var sphere = new THREE.Sphere();
-
-	return function raycast( raycaster, intersects ) {
-
-		var object = this;
-		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.copy( geometry.boundingSphere );
-		sphere.applyMatrix4( matrixWorld );
-
-		if ( raycaster.ray.intersectsSphere( sphere ) === false ) return;
-
-		//
-
-		inverseMatrix.getInverse( matrixWorld );
-		ray.copy( raycaster.ray ).applyMatrix4( inverseMatrix );
-
-		var localThreshold = threshold / ( ( this.scale.x + this.scale.y + this.scale.z ) / 3 );
-		var localThresholdSq = localThreshold * localThreshold;
-		var position = new THREE.Vector3();
-
-		function testPoint( point, index ) {
-
-			var rayPointDistanceSq = ray.distanceSqToPoint( point );
-
-			if ( rayPointDistanceSq < localThresholdSq ) {
-
-				var intersectPoint = ray.closestPointToPoint( point );
-				intersectPoint.applyMatrix4( matrixWorld );
-
-				var distance = raycaster.ray.origin.distanceTo( intersectPoint );
-
-				if ( distance < raycaster.near || distance > raycaster.far ) return;
-
-				intersects.push( {
-
-					distance: distance,
-					distanceToRay: Math.sqrt( rayPointDistanceSq ),
-					point: intersectPoint.clone(),
-					index: index,
-					face: null,
-					object: object
-
-				} );
-
-			}
-
-		}
-
-		if ( geometry instanceof THREE.BufferGeometry ) {
-
-			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 < il; i ++ ) {
-
-					var a = indices[ i ];
-
-					position.fromArray( positions, a * 3 );
-
-					testPoint( position, a );
-
-				}
-
-			} else {
-
-				for ( var i = 0, l = positions.length / 3; i < l; i ++ ) {
-
-					position.fromArray( positions, i * 3 );
-
-					testPoint( position, i );
-
-				}
-
-			}
-
-		} else {
-
-			var vertices = geometry.vertices;
-
-			for ( var i = 0, l = vertices.length; i < l; i ++ ) {
-
-				testPoint( vertices[ i ], i );
-
-			}
-
-		}
-
-	};
-
-}() );
-
-THREE.Points.prototype.clone = function () {
-
-	return new this.constructor( this.geometry, this.material ).copy( this );
-
-};
-
-// File:src/objects/Line.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.Line = function ( geometry, material, mode ) {
-
-	if ( mode === 1 ) {
-
-		console.warn( 'THREE.Line: parameter THREE.LinePieces no longer supported. Created THREE.LineSegments instead.' );
-		return new THREE.LineSegments( geometry, material );
-
-	}
-
-	THREE.Object3D.call( this );
-
-	this.type = 'Line';
-
-	this.geometry = geometry !== undefined ? geometry : new THREE.Geometry();
-	this.material = material !== undefined ? material : new THREE.LineBasicMaterial( { color: Math.random() * 0xffffff } );
-
-};
-
-THREE.Line.prototype = Object.create( THREE.Object3D.prototype );
-THREE.Line.prototype.constructor = THREE.Line;
-
-THREE.Line.prototype.raycast = ( function () {
-
-	var inverseMatrix = new THREE.Matrix4();
-	var ray = new THREE.Ray();
-	var sphere = new THREE.Sphere();
-
-	return function raycast( raycaster, intersects ) {
-
-		var precision = raycaster.linePrecision;
-		var precisionSq = precision * precision;
-
-		var geometry = this.geometry;
-		var matrixWorld = this.matrixWorld;
-
-		// 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 );
-
-		var vStart = new THREE.Vector3();
-		var vEnd = new THREE.Vector3();
-		var interSegment = new THREE.Vector3();
-		var interRay = new THREE.Vector3();
-		var step = this instanceof THREE.LineSegments ? 2 : 1;
-
-		if ( geometry instanceof THREE.BufferGeometry ) {
-
-			var index = geometry.index;
-			var attributes = geometry.attributes;
-			var positions = attributes.position.array;
-
-			if ( index !== null ) {
-
-				var indices = index.array;
-
-				for ( var i = 0, l = indices.length - 1; i < l; i += step ) {
-
-					var a = indices[ i ];
-					var b = indices[ i + 1 ];
-
-					vStart.fromArray( positions, a * 3 );
-					vEnd.fromArray( positions, b * 3 );
-
-					var distSq = ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment );
-
-					if ( distSq > precisionSq ) continue;
-
-					interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
-
-					var distance = raycaster.ray.origin.distanceTo( interRay );
-
-					if ( distance < raycaster.near || 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 < l; i += step ) {
-
-					vStart.fromArray( positions, 3 * i );
-					vEnd.fromArray( positions, 3 * i + 3 );
-
-					var distSq = ray.distanceSqToSegment( vStart, vEnd, interRay, interSegment );
-
-					if ( distSq > precisionSq ) continue;
-
-					interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
-
-					var distance = raycaster.ray.origin.distanceTo( interRay );
-
-					if ( distance < raycaster.near || 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 instanceof THREE.Geometry ) {
-
-			var vertices = geometry.vertices;
-			var nbVertices = vertices.length;
-
-			for ( var i = 0; i < nbVertices - 1; i += step ) {
-
-				var distSq = ray.distanceSqToSegment( vertices[ i ], vertices[ i + 1 ], interRay, interSegment );
-
-				if ( distSq > precisionSq ) continue;
-
-				interRay.applyMatrix4( this.matrixWorld ); //Move back to world space for distance calculation
-
-				var distance = raycaster.ray.origin.distanceTo( interRay );
-
-				if ( distance < raycaster.near || 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
-
-				} );
-
-			}
-
-		}
-
-	};
-
-}() );
-
-THREE.Line.prototype.clone = function () {
-
-	return new this.constructor( this.geometry, this.material ).copy( this );
-
-};
-
-// DEPRECATED
-
-THREE.LineStrip = 0;
-THREE.LinePieces = 1;
-
-// File:src/objects/LineSegments.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.LineSegments = function ( geometry, material ) {
-
-	THREE.Line.call( this, geometry, material );
-
-	this.type = 'LineSegments';
-
-};
-
-THREE.LineSegments.prototype = Object.create( THREE.Line.prototype );
-THREE.LineSegments.prototype.constructor = THREE.LineSegments;
-
-// File:src/objects/Mesh.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- * @author mikael emtinger / http://gomo.se/
- * @author jonobr1 / http://jonobr1.com/
- */
-
-THREE.Mesh = function ( geometry, material ) {
-
-	THREE.Object3D.call( this );
-
-	this.type = 'Mesh';
-
-	this.geometry = geometry !== undefined ? geometry : new THREE.Geometry();
-	this.material = material !== undefined ? material : new THREE.MeshBasicMaterial( { color: Math.random() * 0xffffff } );
-
-	this.drawMode = THREE.TrianglesDrawMode;
-
-	this.updateMorphTargets();
-
-};
-
-THREE.Mesh.prototype = Object.create( THREE.Object3D.prototype );
-THREE.Mesh.prototype.constructor = THREE.Mesh;
-
-THREE.Mesh.prototype.setDrawMode = function ( value ) {
-
-	this.drawMode = value;
-
-};
-
-THREE.Mesh.prototype.updateMorphTargets = function () {
-
-	if ( this.geometry.morphTargets !== undefined && this.geometry.morphTargets.length > 0 ) {
-
-		this.morphTargetBase = - 1;
-		this.morphTargetInfluences = [];
-		this.morphTargetDictionary = {};
-
-		for ( var m = 0, ml = this.geometry.morphTargets.length; m < ml; m ++ ) {
-
-			this.morphTargetInfluences.push( 0 );
-			this.morphTargetDictionary[ this.geometry.morphTargets[ m ].name ] = m;
-
-		}
-
-	}
-
-};
-
-THREE.Mesh.prototype.getMorphTargetIndexByName = function ( name ) {
-
-	if ( this.morphTargetDictionary[ name ] !== undefined ) {
-
-		return this.morphTargetDictionary[ name ];
-
-	}
-
-	console.warn( 'THREE.Mesh.getMorphTargetIndexByName: morph target ' + name + ' does not exist. Returning 0.' );
-
-	return 0;
-
-};
-
-
-THREE.Mesh.prototype.raycast = ( function () {
-
-	var inverseMatrix = new THREE.Matrix4();
-	var ray = new THREE.Ray();
-	var sphere = new THREE.Sphere();
-
-	var vA = new THREE.Vector3();
-	var vB = new THREE.Vector3();
-	var vC = new THREE.Vector3();
-
-	var tempA = new THREE.Vector3();
-	var tempB = new THREE.Vector3();
-	var tempC = new THREE.Vector3();
-
-	var uvA = new THREE.Vector2();
-	var uvB = new THREE.Vector2();
-	var uvC = new THREE.Vector2();
-
-	var barycoord = new THREE.Vector3();
-
-	var intersectionPoint = new THREE.Vector3();
-	var intersectionPointWorld = new THREE.Vector3();
-
-	function uvIntersection( point, p1, p2, p3, uv1, uv2, uv3 ) {
-
-		THREE.Triangle.barycoordFromPoint( point, p1, p2, p3, barycoord );
-
-		uv1.multiplyScalar( barycoord.x );
-		uv2.multiplyScalar( barycoord.y );
-		uv3.multiplyScalar( barycoord.z );
-
-		uv1.add( uv2 ).add( uv3 );
-
-		return uv1.clone();
-
-	}
-
-	function checkIntersection( object, raycaster, ray, pA, pB, pC, point ) {
-
-		var intersect;
-		var material = object.material;
-
-		if ( material.side === THREE.BackSide ) {
-
-			intersect = ray.intersectTriangle( pC, pB, pA, true, point );
-
-		} else {
-
-			intersect = ray.intersectTriangle( pA, pB, pC, material.side !== THREE.DoubleSide, point );
-
-		}
-
-		if ( intersect === null ) return null;
-
-		intersectionPointWorld.copy( point );
-		intersectionPointWorld.applyMatrix4( object.matrixWorld );
-
-		var distance = raycaster.ray.origin.distanceTo( intersectionPointWorld );
-
-		if ( distance < raycaster.near || distance > raycaster.far ) return null;
-
-		return {
-			distance: distance,
-			point: intersectionPointWorld.clone(),
-			object: object
-		};
-
-	}
-
-	function checkBufferGeometryIntersection( object, raycaster, ray, positions, uvs, a, b, c ) {
-
-		vA.fromArray( positions, a * 3 );
-		vB.fromArray( positions, b * 3 );
-		vC.fromArray( positions, c * 3 );
-
-		var intersection = checkIntersection( object, raycaster, ray, vA, vB, vC, intersectionPoint );
-
-		if ( intersection ) {
-
-			if ( uvs ) {
-
-				uvA.fromArray( uvs, a * 2 );
-				uvB.fromArray( uvs, b * 2 );
-				uvC.fromArray( uvs, c * 2 );
-
-				intersection.uv = uvIntersection( intersectionPoint,  vA, vB, vC,  uvA, uvB, uvC );
-
-			}
-
-			intersection.face = new THREE.Face3( a, b, c, THREE.Triangle.normal( vA, vB, vC ) );
-			intersection.faceIndex = a;
-
-		}
-
-		return intersection;
-
-	}
-
-	return function raycast( 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 uvs, intersection;
-
-		if ( geometry instanceof THREE.BufferGeometry ) {
-
-			var a, b, c;
-			var index = geometry.index;
-			var attributes = geometry.attributes;
-			var positions = attributes.position.array;
-
-			if ( attributes.uv !== undefined ) {
-
-				uvs = attributes.uv.array;
-
-			}
-
-			if ( index !== null ) {
-
-				var indices = index.array;
-
-				for ( var i = 0, l = indices.length; i < l; i += 3 ) {
-
-					a = indices[ i ];
-					b = indices[ i + 1 ];
-					c = indices[ i + 2 ];
-
-					intersection = checkBufferGeometryIntersection( this, raycaster, ray, positions, uvs, a, b, c );
-
-					if ( intersection ) {
-
-						intersection.faceIndex = Math.floor( i / 3 ); // triangle number in indices buffer semantics
-						intersects.push( intersection );
-
-					}
-
-				}
-
-			} else {
-
-
-				for ( var i = 0, l = positions.length; i < l; i += 9 ) {
-
-					a = i / 3;
-					b = a + 1;
-					c = a + 2;
-
-					intersection = checkBufferGeometryIntersection( this, raycaster, ray, positions, uvs, a, b, c );
-
-					if ( intersection ) {
-
-						intersection.index = a; // triangle number in positions buffer semantics
-						intersects.push( intersection );
-
-					}
-
-				}
-
-			}
-
-		} else if ( geometry instanceof THREE.Geometry ) {
-
-			var fvA, fvB, fvC;
-			var isFaceMaterial = material instanceof THREE.MultiMaterial;
-			var materials = isFaceMaterial === true ? material.materials : null;
-
-			var vertices = geometry.vertices;
-			var faces = geometry.faces;
-			var faceVertexUvs = geometry.faceVertexUvs[ 0 ];
-			if ( faceVertexUvs.length > 0 ) uvs = faceVertexUvs;
-
-			for ( var f = 0, fl = faces.length; f < fl; f ++ ) {
-
-				var face = faces[ f ];
-				var faceMaterial = isFaceMaterial === true ? materials[ face.materialIndex ] : material;
-
-				if ( faceMaterial === undefined ) continue;
-
-				fvA = vertices[ face.a ];
-				fvB = vertices[ face.b ];
-				fvC = vertices[ face.c ];
-
-				if ( faceMaterial.morphTargets === true ) {
-
-					var morphTargets = geometry.morphTargets;
-					var morphInfluences = this.morphTargetInfluences;
-
-					vA.set( 0, 0, 0 );
-					vB.set( 0, 0, 0 );
-					vC.set( 0, 0, 0 );
-
-					for ( var t = 0, tl = morphTargets.length; t < tl; t ++ ) {
-
-						var influence = morphInfluences[ t ];
-
-						if ( influence === 0 ) continue;
-
-						var targets = morphTargets[ t ].vertices;
-
-						vA.addScaledVector( tempA.subVectors( targets[ face.a ], fvA ), influence );
-						vB.addScaledVector( tempB.subVectors( targets[ face.b ], fvB ), influence );
-						vC.addScaledVector( tempC.subVectors( targets[ face.c ], fvC ), influence );
-
-					}
-
-					vA.add( fvA );
-					vB.add( fvB );
-					vC.add( fvC );
-
-					fvA = vA;
-					fvB = vB;
-					fvC = vC;
-
-				}
-
-				intersection = checkIntersection( this, raycaster, ray, fvA, fvB, fvC, intersectionPoint );
-
-				if ( intersection ) {
-
-					if ( uvs ) {
-
-						var uvs_f = uvs[ f ];
-						uvA.copy( uvs_f[ 0 ] );
-						uvB.copy( uvs_f[ 1 ] );
-						uvC.copy( uvs_f[ 2 ] );
-
-						intersection.uv = uvIntersection( intersectionPoint, fvA, fvB, fvC, uvA, uvB, uvC );
-
-					}
-
-					intersection.face = face;
-					intersection.faceIndex = f;
-					intersects.push( intersection );
-
-				}
-
-			}
-
-		}
-
-	};
-
-}() );
-
-THREE.Mesh.prototype.clone = function () {
-
-	return new this.constructor( this.geometry, this.material ).copy( this );
-
-};
-
-// File:src/objects/Bone.js
-
-/**
- * @author mikael emtinger / http://gomo.se/
- * @author alteredq / http://alteredqualia.com/
- * @author ikerr / http://verold.com
- */
-
-THREE.Bone = function ( skin ) {
-
-	THREE.Object3D.call( this );
-
-	this.type = 'Bone';
-
-	this.skin = skin;
-
-};
-
-THREE.Bone.prototype = Object.create( THREE.Object3D.prototype );
-THREE.Bone.prototype.constructor = THREE.Bone;
-
-THREE.Bone.prototype.copy = function ( source ) {
-
-	THREE.Object3D.prototype.copy.call( this, source );
-
-	this.skin = source.skin;
-
-	return this;
-
-};
-
-// File:src/objects/Skeleton.js
-
-/**
- * @author mikael emtinger / http://gomo.se/
- * @author alteredq / http://alteredqualia.com/
- * @author michael guerrero / http://realitymeltdown.com
- * @author ikerr / http://verold.com
- */
-
-THREE.Skeleton = function ( bones, boneInverses, useVertexTexture ) {
-
-	this.useVertexTexture = useVertexTexture !== undefined ? useVertexTexture : true;
-
-	this.identityMatrix = new THREE.Matrix4();
-
-	// copy the bone array
-
-	bones = bones || [];
-
-	this.bones = bones.slice( 0 );
-
-	// create a bone texture or an array of floats
-
-	if ( this.useVertexTexture ) {
-
-		// 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( this.bones.length * 4 ); // 4 pixels needed for 1 matrix
-		size = THREE.Math.nextPowerOfTwo( Math.ceil( size ) );
-		size = Math.max( size, 4 );
-
-		this.boneTextureWidth = size;
-		this.boneTextureHeight = size;
-
-		this.boneMatrices = new Float32Array( this.boneTextureWidth * this.boneTextureHeight * 4 ); // 4 floats per RGBA pixel
-		this.boneTexture = new THREE.DataTexture( this.boneMatrices, this.boneTextureWidth, this.boneTextureHeight, THREE.RGBAFormat, THREE.FloatType );
-
-	} else {
-
-		this.boneMatrices = new Float32Array( 16 * this.bones.length );
-
-	}
-
-	// use the supplied bone inverses or calculate the inverses
-
-	if ( boneInverses === undefined ) {
-
-		this.calculateInverses();
-
-	} else {
-
-		if ( this.bones.length === boneInverses.length ) {
-
-			this.boneInverses = boneInverses.slice( 0 );
-
-		} else {
-
-			console.warn( 'THREE.Skeleton bonInverses is the wrong length.' );
-
-			this.boneInverses = [];
-
-			for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) {
-
-				this.boneInverses.push( new THREE.Matrix4() );
-
-			}
-
-		}
-
-	}
-
-};
-
-THREE.Skeleton.prototype.calculateInverses = function () {
-
-	this.boneInverses = [];
-
-	for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) {
-
-		var inverse = new THREE.Matrix4();
-
-		if ( this.bones[ b ] ) {
-
-			inverse.getInverse( this.bones[ b ].matrixWorld );
-
-		}
-
-		this.boneInverses.push( inverse );
-
-	}
-
-};
-
-THREE.Skeleton.prototype.pose = function () {
-
-	var bone;
-
-	// recover the bind-time world matrices
-
-	for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) {
-
-		bone = this.bones[ b ];
-
-		if ( bone ) {
-
-			bone.matrixWorld.getInverse( this.boneInverses[ b ] );
-
-		}
-
-	}
-
-	// compute the local matrices, positions, rotations and scales
-
-	for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) {
-
-		bone = this.bones[ b ];
-
-		if ( bone ) {
-
-			if ( bone.parent ) {
-
-				bone.matrix.getInverse( bone.parent.matrixWorld );
-				bone.matrix.multiply( bone.matrixWorld );
-
-			} else {
-
-				bone.matrix.copy( bone.matrixWorld );
-
-			}
-
-			bone.matrix.decompose( bone.position, bone.quaternion, bone.scale );
-
-		}
-
-	}
-
-};
-
-THREE.Skeleton.prototype.update = ( function () {
-
-	var offsetMatrix = new THREE.Matrix4();
-
-	return function update() {
-
-		// flatten bone matrices to array
-
-		for ( var b = 0, bl = this.bones.length; b < bl; b ++ ) {
-
-			// compute the offset between the current and the original transform
-
-			var matrix = this.bones[ b ] ? this.bones[ b ].matrixWorld : this.identityMatrix;
-
-			offsetMatrix.multiplyMatrices( matrix, this.boneInverses[ b ] );
-			offsetMatrix.toArray( this.boneMatrices, b * 16 );
-
-		}
-
-		if ( this.useVertexTexture ) {
-
-			this.boneTexture.needsUpdate = true;
-
-		}
-
-	};
-
-} )();
-
-THREE.Skeleton.prototype.clone = function () {
-
-	return new THREE.Skeleton( this.bones, this.boneInverses, this.useVertexTexture );
-
-};
-
-// File:src/objects/SkinnedMesh.js
-
-/**
- * @author mikael emtinger / http://gomo.se/
- * @author alteredq / http://alteredqualia.com/
- * @author ikerr / http://verold.com
- */
-
-THREE.SkinnedMesh = function ( geometry, material, useVertexTexture ) {
-
-	THREE.Mesh.call( this, geometry, material );
-
-	this.type = 'SkinnedMesh';
-
-	this.bindMode = "attached";
-	this.bindMatrix = new THREE.Matrix4();
-	this.bindMatrixInverse = new THREE.Matrix4();
-
-	// init bones
-
-	// TODO: remove bone creation as there is no reason (other than
-	// convenience) for THREE.SkinnedMesh to do this.
-
-	var bones = [];
-
-	if ( this.geometry && this.geometry.bones !== undefined ) {
-
-		var bone, gbone;
-
-		for ( var b = 0, bl = this.geometry.bones.length; b < bl; ++ b ) {
-
-			gbone = this.geometry.bones[ b ];
-
-			bone = new THREE.Bone( this );
-			bones.push( bone );
-
-			bone.name = gbone.name;
-			bone.position.fromArray( gbone.pos );
-			bone.quaternion.fromArray( gbone.rotq );
-			if ( gbone.scl !== undefined ) bone.scale.fromArray( gbone.scl );
-
-		}
-
-		for ( var b = 0, bl = this.geometry.bones.length; b < bl; ++ b ) {
-
-			gbone = this.geometry.bones[ b ];
-
-			if ( gbone.parent !== - 1 && gbone.parent !== null &&
-					bones[ gbone.parent ] !== undefined ) {
-
-				bones[ gbone.parent ].add( bones[ b ] );
-
-			} else {
-
-				this.add( bones[ b ] );
-
-			}
-
-		}
-
-	}
-
-	this.normalizeSkinWeights();
-
-	this.updateMatrixWorld( true );
-	this.bind( new THREE.Skeleton( bones, undefined, useVertexTexture ), this.matrixWorld );
-
-};
-
-
-THREE.SkinnedMesh.prototype = Object.create( THREE.Mesh.prototype );
-THREE.SkinnedMesh.prototype.constructor = THREE.SkinnedMesh;
-
-THREE.SkinnedMesh.prototype.bind = function( skeleton, bindMatrix ) {
-
-	this.skeleton = skeleton;
-
-	if ( bindMatrix === undefined ) {
-
-		this.updateMatrixWorld( true );
-
-		this.skeleton.calculateInverses();
-
-		bindMatrix = this.matrixWorld;
-
-	}
-
-	this.bindMatrix.copy( bindMatrix );
-	this.bindMatrixInverse.getInverse( bindMatrix );
-
-};
-
-THREE.SkinnedMesh.prototype.pose = function () {
-
-	this.skeleton.pose();
-
-};
-
-THREE.SkinnedMesh.prototype.normalizeSkinWeights = function () {
-
-	if ( this.geometry instanceof THREE.Geometry ) {
-
-		for ( var i = 0; i < this.geometry.skinWeights.length; i ++ ) {
-
-			var sw = this.geometry.skinWeights[ i ];
-
-			var scale = 1.0 / sw.lengthManhattan();
-
-			if ( scale !== Infinity ) {
-
-				sw.multiplyScalar( scale );
-
-			} else {
-
-				sw.set( 1, 0, 0, 0 ); // do something reasonable
-
-			}
-
-		}
-
-	} else if ( this.geometry instanceof THREE.BufferGeometry ) {
-
-		var vec = new THREE.Vector4();
-
-		var skinWeight = this.geometry.attributes.skinWeight;
-
-		for ( var i = 0; i < skinWeight.count; i ++ ) {
-
-			vec.x = skinWeight.getX( i );
-			vec.y = skinWeight.getY( i );
-			vec.z = skinWeight.getZ( i );
-			vec.w = skinWeight.getW( i );
-
-			var scale = 1.0 / vec.lengthManhattan();
-
-			if ( scale !== Infinity ) {
-
-				vec.multiplyScalar( scale );
-
-			} else {
-
-				vec.set( 1, 0, 0, 0 ); // do something reasonable
-
-			}
-
-			skinWeight.setXYZW( i, vec.x, vec.y, vec.z, vec.w );
-
-		}
-
-	}
-
-};
-
-THREE.SkinnedMesh.prototype.updateMatrixWorld = function( force ) {
-
-	THREE.Mesh.prototype.updateMatrixWorld.call( this, true );
-
-	if ( this.bindMode === "attached" ) {
-
-		this.bindMatrixInverse.getInverse( this.matrixWorld );
-
-	} else if ( this.bindMode === "detached" ) {
-
-		this.bindMatrixInverse.getInverse( this.bindMatrix );
-
-	} else {
-
-		console.warn( 'THREE.SkinnedMesh unrecognized bindMode: ' + this.bindMode );
-
-	}
-
-};
-
-THREE.SkinnedMesh.prototype.clone = function() {
-
-	return new this.constructor( this.geometry, this.material, this.useVertexTexture ).copy( this );
-
-};
-
-// File:src/objects/LOD.js
-
-/**
- * @author mikael emtinger / http://gomo.se/
- * @author alteredq / http://alteredqualia.com/
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.LOD = function () {
-
-	THREE.Object3D.call( this );
-
-	this.type = 'LOD';
-
-	Object.defineProperties( this, {
-		levels: {
-			enumerable: true,
-			value: []
-		}
-	} );
-
-};
-
-
-THREE.LOD.prototype = Object.create( THREE.Object3D.prototype );
-THREE.LOD.prototype.constructor = THREE.LOD;
-
-THREE.LOD.prototype.addLevel = function ( object, distance ) {
-
-	if ( distance === undefined ) distance = 0;
-
-	distance = Math.abs( distance );
-
-	var levels = this.levels;
-
-	for ( var l = 0; l < levels.length; l ++ ) {
-
-		if ( distance < levels[ l ].distance ) {
-
-			break;
-
-		}
-
-	}
-
-	levels.splice( l, 0, { distance: distance, object: object } );
-
-	this.add( object );
-
-};
-
-THREE.LOD.prototype.getObjectForDistance = function ( distance ) {
-
-	var levels = this.levels;
-
-	for ( var i = 1, l = levels.length; i < l; i ++ ) {
-
-		if ( distance < levels[ i ].distance ) {
-
-			break;
-
-		}
-
-	}
-
-	return levels[ i - 1 ].object;
-
-};
-
-THREE.LOD.prototype.raycast = ( function () {
-
-	var matrixPosition = new THREE.Vector3();
-
-	return function raycast( raycaster, intersects ) {
-
-		matrixPosition.setFromMatrixPosition( this.matrixWorld );
-
-		var distance = raycaster.ray.origin.distanceTo( matrixPosition );
-
-		this.getObjectForDistance( distance ).raycast( raycaster, intersects );
-
-	};
-
-}() );
-
-THREE.LOD.prototype.update = function () {
-
-	var v1 = new THREE.Vector3();
-	var v2 = new THREE.Vector3();
-
-	return function update( camera ) {
-
-		var levels = this.levels;
-
-		if ( levels.length > 1 ) {
-
-			v1.setFromMatrixPosition( camera.matrixWorld );
-			v2.setFromMatrixPosition( this.matrixWorld );
-
-			var distance = v1.distanceTo( v2 );
-
-			levels[ 0 ].object.visible = true;
-
-			for ( var i = 1, l = levels.length; i < l; i ++ ) {
-
-				if ( distance >= levels[ i ].distance ) {
-
-					levels[ i - 1 ].object.visible = false;
-					levels[ i ].object.visible = true;
-
-				} else {
-
-					break;
-
-				}
-
-			}
-
-			for ( ; i < l; i ++ ) {
-
-				levels[ i ].object.visible = false;
-
-			}
-
-		}
-
-	};
-
-}();
-
-THREE.LOD.prototype.copy = function ( source ) {
-
-	THREE.Object3D.prototype.copy.call( this, source, false );
-
-	var levels = source.levels;
-
-	for ( var i = 0, l = levels.length; i < l; i ++ ) {
-
-		var level = levels[ i ];
-
-		this.addLevel( level.object.clone(), level.distance );
-
-	}
-
-	return this;
-
-};
-
-THREE.LOD.prototype.toJSON = function ( meta ) {
-
-	var data = THREE.Object3D.prototype.toJSON.call( this, meta );
-
-	data.object.levels = [];
-
-	var levels = this.levels;
-
-	for ( var i = 0, l = levels.length; i < l; i ++ ) {
-
-		var level = levels[ i ];
-
-		data.object.levels.push( {
-			object: level.object.uuid,
-			distance: level.distance
-		} );
-
-	}
-
-	return data;
-
-};
-
-// File:src/objects/Sprite.js
-
-/**
- * @author mikael emtinger / http://gomo.se/
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.Sprite = ( function () {
-
-	var indices = new Uint16Array( [ 0, 1, 2,  0, 2, 3 ] );
-	var vertices = new Float32Array( [ - 0.5, - 0.5, 0,   0.5, - 0.5, 0,   0.5, 0.5, 0,   - 0.5, 0.5, 0 ] );
-	var uvs = new Float32Array( [ 0, 0,   1, 0,   1, 1,   0, 1 ] );
-
-	var geometry = new THREE.BufferGeometry();
-	geometry.setIndex( new THREE.BufferAttribute( indices, 1 ) );
-	geometry.addAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
-	geometry.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ) );
-
-	return function Sprite( material ) {
-
-		THREE.Object3D.call( this );
-
-		this.type = 'Sprite';
-
-		this.geometry = geometry;
-		this.material = ( material !== undefined ) ? material : new THREE.SpriteMaterial();
-
-	};
-
-} )();
-
-THREE.Sprite.prototype = Object.create( THREE.Object3D.prototype );
-THREE.Sprite.prototype.constructor = THREE.Sprite;
-
-THREE.Sprite.prototype.raycast = ( function () {
-
-	var matrixPosition = new THREE.Vector3();
-
-	return function raycast( raycaster, intersects ) {
-
-		matrixPosition.setFromMatrixPosition( this.matrixWorld );
-
-		var distanceSq = raycaster.ray.distanceSqToPoint( matrixPosition );
-		var guessSizeSq = this.scale.x * this.scale.y / 4;
-
-		if ( distanceSq > guessSizeSq ) {
-
-			return;
-
-		}
-
-		intersects.push( {
-
-			distance: Math.sqrt( distanceSq ),
-			point: this.position,
-			face: null,
-			object: this
-
-		} );
-
-	};
-
-}() );
-
-THREE.Sprite.prototype.clone = function () {
-
-	return new this.constructor( this.material ).copy( this );
-
-};
-
-// Backwards compatibility
-
-THREE.Particle = THREE.Sprite;
-
-// File:src/objects/LensFlare.js
-
-/**
- * @author mikael emtinger / http://gomo.se/
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.LensFlare = function ( texture, size, distance, blending, color ) {
-
-	THREE.Object3D.call( this );
-
-	this.lensFlares = [];
-
-	this.positionScreen = new THREE.Vector3();
-	this.customUpdateCallback = undefined;
-
-	if ( texture !== undefined ) {
-
-		this.add( texture, size, distance, blending, color );
-
-	}
-
-};
-
-THREE.LensFlare.prototype = Object.create( THREE.Object3D.prototype );
-THREE.LensFlare.prototype.constructor = THREE.LensFlare;
-
-
-/*
- * Add: adds another flare
- */
-
-THREE.LensFlare.prototype.add = function ( texture, size, distance, blending, color, opacity ) {
-
-	if ( size === undefined ) size = - 1;
-	if ( distance === undefined ) distance = 0;
-	if ( opacity === undefined ) opacity = 1;
-	if ( color === undefined ) color = new THREE.Color( 0xffffff );
-	if ( blending === undefined ) blending = THREE.NormalBlending;
-
-	distance = Math.min( distance, Math.max( 0, distance ) );
-
-	this.lensFlares.push( {
-		texture: texture,	// THREE.Texture
-		size: size, 		// size in pixels (-1 = use texture.width)
-		distance: distance, 	// distance (0-1) from light source (0=at light source)
-		x: 0, y: 0, z: 0,	// screen position (-1 => 1) z = 0 is in front z = 1 is back
-		scale: 1, 		// scale
-		rotation: 0, 		// rotation
-		opacity: opacity,	// opacity
-		color: color,		// color
-		blending: blending	// blending
-	} );
-
-};
-
-/*
- * Update lens flares update positions on all flares based on the screen position
- * Set myLensFlare.customUpdateCallback to alter the flares in your project specific way.
- */
-
-THREE.LensFlare.prototype.updateLensFlares = function () {
-
-	var f, fl = this.lensFlares.length;
-	var flare;
-	var vecX = - this.positionScreen.x * 2;
-	var vecY = - this.positionScreen.y * 2;
-
-	for ( f = 0; f < fl; f ++ ) {
-
-		flare = this.lensFlares[ f ];
-
-		flare.x = this.positionScreen.x + vecX * flare.distance;
-		flare.y = this.positionScreen.y + vecY * flare.distance;
-
-		flare.wantedRotation = flare.x * Math.PI * 0.25;
-		flare.rotation += ( flare.wantedRotation - flare.rotation ) * 0.25;
-
-	}
-
-};
-
-THREE.LensFlare.prototype.copy = function ( source ) {
-
-	THREE.Object3D.prototype.copy.call( this, source );
-
-	this.positionScreen.copy( source.positionScreen );
-	this.customUpdateCallback = source.customUpdateCallback;
-
-	for ( var i = 0, l = source.lensFlares.length; i < l; i ++ ) {
-
-		this.lensFlares.push( source.lensFlares[ i ] );
-
-	}
-
-	return this;
-
-};
-
-// File:src/scenes/Scene.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.Scene = function () {
-
-	THREE.Object3D.call( this );
-
-	this.type = 'Scene';
-
-	this.fog = null;
-	this.overrideMaterial = null;
-
-	this.autoUpdate = true; // checked by the renderer
-
-};
-
-THREE.Scene.prototype = Object.create( THREE.Object3D.prototype );
-THREE.Scene.prototype.constructor = THREE.Scene;
-
-THREE.Scene.prototype.copy = function ( source, recursive ) {
-
-	THREE.Object3D.prototype.copy.call( this, source, recursive );
-
-	if ( source.fog !== null ) this.fog = source.fog.clone();
-	if ( source.overrideMaterial !== null ) this.overrideMaterial = source.overrideMaterial.clone();
-
-	this.autoUpdate = source.autoUpdate;
-	this.matrixAutoUpdate = source.matrixAutoUpdate;
-
-	return this;
-
-};
-
-// File:src/scenes/Fog.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.Fog = function ( color, near, far ) {
-
-	this.name = '';
-
-	this.color = new THREE.Color( color );
-
-	this.near = ( near !== undefined ) ? near : 1;
-	this.far = ( far !== undefined ) ? far : 1000;
-
-};
-
-THREE.Fog.prototype.clone = function () {
-
-	return new THREE.Fog( this.color.getHex(), this.near, this.far );
-
-};
-
-// File:src/scenes/FogExp2.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.FogExp2 = function ( color, density ) {
-
-	this.name = '';
-
-	this.color = new THREE.Color( color );
-	this.density = ( density !== undefined ) ? density : 0.00025;
-
-};
-
-THREE.FogExp2.prototype.clone = function () {
-
-	return new THREE.FogExp2( this.color.getHex(), this.density );
-
-};
-
-// File:src/renderers/shaders/ShaderChunk.js
-
-THREE.ShaderChunk = {};
-
-// File:src/renderers/shaders/ShaderChunk/alphamap_fragment.glsl
-
-THREE.ShaderChunk[ 'alphamap_fragment' ] = "#ifdef USE_ALPHAMAP\n	diffuseColor.a *= texture2D( alphaMap, vUv ).g;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/alphamap_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'alphamap_pars_fragment' ] = "#ifdef USE_ALPHAMAP\n	uniform sampler2D alphaMap;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/alphatest_fragment.glsl
-
-THREE.ShaderChunk[ 'alphatest_fragment' ] = "#ifdef ALPHATEST\n	if ( diffuseColor.a < ALPHATEST ) discard;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/aomap_fragment.glsl
-
-THREE.ShaderChunk[ 'aomap_fragment' ] = "#ifdef USE_AOMAP\n	float ambientOcclusion = ( texture2D( aoMap, vUv2 ).r - 1.0 ) * aoMapIntensity + 1.0;\n	reflectedLight.indirectDiffuse *= ambientOcclusion;\n	#if defined( USE_ENVMAP ) && defined( PHYSICAL )\n		float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n		reflectedLight.indirectSpecular *= computeSpecularOcclusion( dotNV, ambientOcclusion, material.specularRoughness );\n	#endif\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/aomap_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'aomap_pars_fragment' ] = "#ifdef USE_AOMAP\n	uniform sampler2D aoMap;\n	uniform float aoMapIntensity;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/begin_vertex.glsl
-
-THREE.ShaderChunk[ 'begin_vertex' ] = "\nvec3 transformed = vec3( position );\n";
-
-// File:src/renderers/shaders/ShaderChunk/beginnormal_vertex.glsl
-
-THREE.ShaderChunk[ 'beginnormal_vertex' ] = "\nvec3 objectNormal = vec3( normal );\n";
-
-// File:src/renderers/shaders/ShaderChunk/bsdfs.glsl
-
-THREE.ShaderChunk[ 'bsdfs' ] = "bool testLightInRange( const in float lightDistance, const in float cutoffDistance ) {\n	return any( bvec2( cutoffDistance == 0.0, lightDistance < cutoffDistance ) );\n}\nfloat punctualLightIntensityToIrradianceFactor( const in float lightDistance, const in float cutoffDistance, const in float decayExponent ) {\n		if( decayExponent > 0.0 ) {\n#if defined ( PHYSICALLY_CORRECT_LIGHTS )\n			float distanceFalloff = 1.0 / max( pow( lightDistance, decayExponent ), 0.01 );\n			float maxDistanceCutoffFactor = pow2( saturate( 1.0 - pow4( lightDistance / cutoffDistance ) ) );\n			return distanceFalloff * maxDistanceCutoffFactor;\n#else\n			return pow( saturate( -lightDistance / cutoffDistance + 1.0 ), decayExponent );\n#endif\n		}\n		return 1.0;\n}\nvec3 BRDF_Diffuse_Lambert( const in vec3 diffuseColor ) {\n	return RECIPROCAL_PI * diffuseColor;\n}\nvec3 F_Schlick( const in vec3 specularColor, const in float dotLH ) {\n	float fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );\n	return ( 1.0 - specularColor ) * fresnel + specularColor;\n}\nfloat G_GGX_Smith( const in float alpha, const in float dotNL, const in float dotNV ) {\n	float a2 = pow2( alpha );\n	float gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n	float gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n	return 1.0 / ( gl * gv );\n}\nfloat G_GGX_SmithCorrelated( const in float alpha, const in float dotNL, const in float dotNV ) {\n	float a2 = pow2( alpha );\n	float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNV ) );\n	float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * pow2( dotNL ) );\n	return 0.5 / max( gv + gl, EPSILON );\n}\nfloat D_GGX( const in float alpha, const in float dotNH ) {\n	float a2 = pow2( alpha );\n	float denom = pow2( dotNH ) * ( a2 - 1.0 ) + 1.0;\n	return RECIPROCAL_PI * a2 / pow2( denom );\n}\nvec3 BRDF_Specular_GGX( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {\n	float alpha = pow2( roughness );\n	vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n	float dotNL = saturate( dot( geometry.normal, incidentLight.direction ) );\n	float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n	float dotNH = saturate( dot( geometry.normal, halfDir ) );\n	float dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n	vec3 F = F_Schlick( specularColor, dotLH );\n	float G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );\n	float D = D_GGX( alpha, dotNH );\n	return F * ( G * D );\n}\nvec3 BRDF_Specular_GGX_Environment( const in GeometricContext geometry, const in vec3 specularColor, const in float roughness ) {\n	float dotNV = saturate( dot( geometry.normal, geometry.viewDir ) );\n	const vec4 c0 = vec4( - 1, - 0.0275, - 0.572, 0.022 );\n	const vec4 c1 = vec4( 1, 0.0425, 1.04, - 0.04 );\n	vec4 r = roughness * c0 + c1;\n	float a004 = min( r.x * r.x, exp2( - 9.28 * dotNV ) ) * r.x + r.y;\n	vec2 AB = vec2( -1.04, 1.04 ) * a004 + r.zw;\n	return specularColor * AB.x + AB.y;\n}\nfloat G_BlinnPhong_Implicit( ) {\n	return 0.25;\n}\nfloat D_BlinnPhong( const in float shininess, const in float dotNH ) {\n	return RECIPROCAL_PI * ( shininess * 0.5 + 1.0 ) * pow( dotNH, shininess );\n}\nvec3 BRDF_Specular_BlinnPhong( const in IncidentLight incidentLight, const in GeometricContext geometry, const in vec3 specularColor, const in float shininess ) {\n	vec3 halfDir = normalize( incidentLight.direction + geometry.viewDir );\n	float dotNH = saturate( dot( geometry.normal, halfDir ) );\n	float dotLH = saturate( dot( incidentLight.direction, halfDir ) );\n	vec3 F = F_Schlick( specularColor, dotLH );\n	float G = G_BlinnPhong_Implicit( );\n	float D = D_BlinnPhong( shininess, dotNH );\n	return F * ( G * D );\n}\nfloat GGXRoughnessToBlinnExponent( const in float ggxRoughness ) {\n	return ( 2.0 / pow2( ggxRoughness + 0.0001 ) - 2.0 );\n}\nfloat BlinnExponentToGGXRoughness( const in float blinnExponent ) {\n	return sqrt( 2.0 / ( blinnExponent + 2.0 ) );\n}\n";
-
-// File:src/renderers/shaders/ShaderChunk/bumpmap_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'bumpmap_pars_fragment' ] = "#ifdef USE_BUMPMAP\n	uniform sampler2D bumpMap;\n	uniform float bumpScale;\n	vec2 dHdxy_fwd() {\n		vec2 dSTdx = dFdx( vUv );\n		vec2 dSTdy = dFdy( vUv );\n		float Hll = bumpScale * texture2D( bumpMap, vUv ).x;\n		float dBx = bumpScale * texture2D( bumpMap, vUv + dSTdx ).x - Hll;\n		float dBy = bumpScale * texture2D( bumpMap, vUv + dSTdy ).x - Hll;\n		return vec2( dBx, dBy );\n	}\n	vec3 perturbNormalArb( vec3 surf_pos, vec3 surf_norm, vec2 dHdxy ) {\n		vec3 vSigmaX = dFdx( surf_pos );\n		vec3 vSigmaY = dFdy( surf_pos );\n		vec3 vN = surf_norm;\n		vec3 R1 = cross( vSigmaY, vN );\n		vec3 R2 = cross( vN, vSigmaX );\n		float fDet = dot( vSigmaX, R1 );\n		vec3 vGrad = sign( fDet ) * ( dHdxy.x * R1 + dHdxy.y * R2 );\n		return normalize( abs( fDet ) * surf_norm - vGrad );\n	}\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/clipping_planes_fragment.glsl
-
-THREE.ShaderChunk[ 'clipping_planes_fragment' ] = "#if NUM_CLIPPING_PLANES > 0\n	for ( int i = 0; i < NUM_CLIPPING_PLANES; ++ i ) {\n		vec4 plane = clippingPlanes[ i ];\n		if ( dot( vViewPosition, plane.xyz ) > plane.w ) discard;\n	}\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/clipping_planes_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'clipping_planes_pars_fragment' ] = "#if NUM_CLIPPING_PLANES > 0\n	#if ! defined( PHYSICAL ) && ! defined( PHONG )\n		varying vec3 vViewPosition;\n	#endif\n	uniform vec4 clippingPlanes[ NUM_CLIPPING_PLANES ];\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/clipping_planes_pars_vertex.glsl
-
-THREE.ShaderChunk[ 'clipping_planes_pars_vertex' ] = "#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\n	varying vec3 vViewPosition;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/clipping_planes_vertex.glsl
-
-THREE.ShaderChunk[ 'clipping_planes_vertex' ] = "#if NUM_CLIPPING_PLANES > 0 && ! defined( PHYSICAL ) && ! defined( PHONG )\n	vViewPosition = - mvPosition.xyz;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/color_fragment.glsl
-
-THREE.ShaderChunk[ 'color_fragment' ] = "#ifdef USE_COLOR\n	diffuseColor.rgb *= vColor;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/color_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'color_pars_fragment' ] = "#ifdef USE_COLOR\n	varying vec3 vColor;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/color_pars_vertex.glsl
-
-THREE.ShaderChunk[ 'color_pars_vertex' ] = "#ifdef USE_COLOR\n	varying vec3 vColor;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/color_vertex.glsl
-
-THREE.ShaderChunk[ 'color_vertex' ] = "#ifdef USE_COLOR\n	vColor.xyz = color.xyz;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/common.glsl
-
-THREE.ShaderChunk[ 'common' ] = "#define PI 3.14159265359\n#define PI2 6.28318530718\n#define RECIPROCAL_PI 0.31830988618\n#define RECIPROCAL_PI2 0.15915494\n#define LOG2 1.442695\n#define EPSILON 1e-6\n#define saturate(a) clamp( a, 0.0, 1.0 )\n#define whiteCompliment(a) ( 1.0 - saturate( a ) )\nfloat pow2( const in float x ) { return x*x; }\nfloat pow3( const in float x ) { return x*x*x; }\nfloat pow4( const in float x ) { float x2 = x*x; return x2*x2; }\nfloat average( const in vec3 color ) { return dot( color, vec3( 0.3333 ) ); }\nhighp float rand( const in vec2 uv ) {\n	const highp float a = 12.9898, b = 78.233, c = 43758.5453;\n	highp float dt = dot( uv.xy, vec2( a,b ) ), sn = mod( dt, PI );\n	return fract(sin(sn) * c);\n}\nstruct IncidentLight {\n	vec3 color;\n	vec3 direction;\n	bool visible;\n};\nstruct ReflectedLight {\n	vec3 directDiffuse;\n	vec3 directSpecular;\n	vec3 indirectDiffuse;\n	vec3 indirectSpecular;\n};\nstruct GeometricContext {\n	vec3 position;\n	vec3 normal;\n	vec3 viewDir;\n};\nvec3 transformDirection( in vec3 dir, in mat4 matrix ) {\n	return normalize( ( matrix * vec4( dir, 0.0 ) ).xyz );\n}\nvec3 inverseTransformDirection( in vec3 dir, in mat4 matrix ) {\n	return normalize( ( vec4( dir, 0.0 ) * matrix ).xyz );\n}\nvec3 projectOnPlane(in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n	float distance = dot( planeNormal, point - pointOnPlane );\n	return - distance * planeNormal + point;\n}\nfloat sideOfPlane( in vec3 point, in vec3 pointOnPlane, in vec3 planeNormal ) {\n	return sign( dot( point - pointOnPlane, planeNormal ) );\n}\nvec3 linePlaneIntersect( in vec3 pointOnLine, in vec3 lineDirection, in vec3 pointOnPlane, in vec3 planeNormal ) {\n	return lineDirection * ( dot( planeNormal, pointOnPlane - pointOnLine ) / dot( planeNormal, lineDirection ) ) + pointOnLine;\n}\n";
-
-// File:src/renderers/shaders/ShaderChunk/cube_uv_reflection_fragment.glsl
-
-THREE.ShaderChunk[ 'cube_uv_reflection_fragment' ] = "#ifdef ENVMAP_TYPE_CUBE_UV\nconst float cubeUV_textureSize = 1024.0;\nint getFaceFromDirection(vec3 direction) {\n	vec3 absDirection = abs(direction);\n	int face = -1;\n	if( absDirection.x > absDirection.z ) {\n		if(absDirection.x > absDirection.y )\n			face = direction.x > 0.0 ? 0 : 3;\n		else\n			face = direction.y > 0.0 ? 1 : 4;\n	}\n	else {\n		if(absDirection.z > absDirection.y )\n			face = direction.z > 0.0 ? 2 : 5;\n		else\n			face = direction.y > 0.0 ? 1 : 4;\n	}\n	return face;\n}\nfloat cubeUV_maxLods1 = log2(cubeUV_textureSize*0.25) - 1.0;\nfloat cubeUV_rangeClamp = exp2((6.0 - 1.0) * 2.0);\nvec2 MipLevelInfo( vec3 vec, float roughnessLevel, float roughness ) {\n	float scale = exp2(cubeUV_maxLods1 - roughnessLevel);\n	float dxRoughness = dFdx(roughness);\n	float dyRoughness = dFdy(roughness);\n	vec3 dx = dFdx( vec * scale * dxRoughness );\n	vec3 dy = dFdy( vec * scale * dyRoughness );\n	float d = max( dot( dx, dx ), dot( dy, dy ) );\n	d = clamp(d, 1.0, cubeUV_rangeClamp);\n	float mipLevel = 0.5 * log2(d);\n	return vec2(floor(mipLevel), fract(mipLevel));\n}\nfloat cubeUV_maxLods2 = log2(cubeUV_textureSize*0.25) - 2.0;\nconst float cubeUV_rcpTextureSize = 1.0 / cubeUV_textureSize;\nvec2 getCubeUV(vec3 direction, float roughnessLevel, float mipLevel) {\n	mipLevel = roughnessLevel > cubeUV_maxLods2 - 3.0 ? 0.0 : mipLevel;\n	float a = 16.0 * cubeUV_rcpTextureSize;\n	vec2 exp2_packed = exp2( vec2( roughnessLevel, mipLevel ) );\n	vec2 rcp_exp2_packed = vec2( 1.0 ) / exp2_packed;\n	float powScale = exp2_packed.x * exp2_packed.y;\n	float scale = rcp_exp2_packed.x * rcp_exp2_packed.y * 0.25;\n	float mipOffset = 0.75*(1.0 - rcp_exp2_packed.y) * rcp_exp2_packed.x;\n	bool bRes = mipLevel == 0.0;\n	scale =  bRes && (scale < a) ? a : scale;\n	vec3 r;\n	vec2 offset;\n	int face = getFaceFromDirection(direction);\n	float rcpPowScale = 1.0 / powScale;\n	if( face == 0) {\n		r = vec3(direction.x, -direction.z, direction.y);\n		offset = vec2(0.0+mipOffset,0.75 * rcpPowScale);\n		offset.y = bRes && (offset.y < 2.0*a) ?  a : offset.y;\n	}\n	else if( face == 1) {\n		r = vec3(direction.y, direction.x, direction.z);\n		offset = vec2(scale+mipOffset, 0.75 * rcpPowScale);\n		offset.y = bRes && (offset.y < 2.0*a) ?  a : offset.y;\n	}\n	else if( face == 2) {\n		r = vec3(direction.z, direction.x, direction.y);\n		offset = vec2(2.0*scale+mipOffset, 0.75 * rcpPowScale);\n		offset.y = bRes && (offset.y < 2.0*a) ?  a : offset.y;\n	}\n	else if( face == 3) {\n		r = vec3(direction.x, direction.z, direction.y);\n		offset = vec2(0.0+mipOffset,0.5 * rcpPowScale);\n		offset.y = bRes && (offset.y < 2.0*a) ?  0.0 : offset.y;\n	}\n	else if( face == 4) {\n		r = vec3(direction.y, direction.x, -direction.z);\n		offset = vec2(scale+mipOffset, 0.5 * rcpPowScale);\n		offset.y = bRes && (offset.y < 2.0*a) ?  0.0 : offset.y;\n	}\n	else {\n		r = vec3(direction.z, -direction.x, direction.y);\n		offset = vec2(2.0*scale+mipOffset, 0.5 * rcpPowScale);\n		offset.y = bRes && (offset.y < 2.0*a) ?  0.0 : offset.y;\n	}\n	r = normalize(r);\n	float texelOffset = 0.5 * cubeUV_rcpTextureSize;\n	vec2 s = ( r.yz / abs( r.x ) + vec2( 1.0 ) ) * 0.5;\n	vec2 base = offset + vec2( texelOffset );\n	return base + s * ( scale - 2.0 * texelOffset );\n}\nfloat cubeUV_maxLods3 = log2(cubeUV_textureSize*0.25) - 3.0;\nvec4 textureCubeUV(vec3 reflectedDirection, float roughness ) {\n	float roughnessVal = roughness* cubeUV_maxLods3;\n	float r1 = floor(roughnessVal);\n	float r2 = r1 + 1.0;\n	float t = fract(roughnessVal);\n	vec2 mipInfo = MipLevelInfo(reflectedDirection, r1, roughness);\n	float s = mipInfo.y;\n	float level0 = mipInfo.x;\n	float level1 = level0 + 1.0;\n	level1 = level1 > 5.0 ? 5.0 : level1;\n	level0 += min( floor( s + 0.5 ), 5.0 );\n	vec2 uv_10 = getCubeUV(reflectedDirection, r1, level0);\n	vec4 color10 = envMapTexelToLinear(texture2D(envMap, uv_10));\n	vec2 uv_20 = getCubeUV(reflectedDirection, r2, level0);\n	vec4 color20 = envMapTexelToLinear(texture2D(envMap, uv_20));\n	vec4 result = mix(color10, color20, t);\n	return vec4(result.rgb, 1.0);\n}\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/defaultnormal_vertex.glsl
-
-THREE.ShaderChunk[ 'defaultnormal_vertex' ] = "#ifdef FLIP_SIDED\n	objectNormal = -objectNormal;\n#endif\nvec3 transformedNormal = normalMatrix * objectNormal;\n";
-
-// File:src/renderers/shaders/ShaderChunk/displacementmap_vertex.glsl
-
-THREE.ShaderChunk[ 'displacementmap_vertex' ] = "#ifdef USE_DISPLACEMENTMAP\n	transformed += normal * ( texture2D( displacementMap, uv ).x * displacementScale + displacementBias );\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/displacementmap_pars_vertex.glsl
-
-THREE.ShaderChunk[ 'displacementmap_pars_vertex' ] = "#ifdef USE_DISPLACEMENTMAP\n	uniform sampler2D displacementMap;\n	uniform float displacementScale;\n	uniform float displacementBias;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/emissivemap_fragment.glsl
-
-THREE.ShaderChunk[ 'emissivemap_fragment' ] = "#ifdef USE_EMISSIVEMAP\n	vec4 emissiveColor = texture2D( emissiveMap, vUv );\n	emissiveColor.rgb = emissiveMapTexelToLinear( emissiveColor ).rgb;\n	totalEmissiveRadiance *= emissiveColor.rgb;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/emissivemap_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'emissivemap_pars_fragment' ] = "#ifdef USE_EMISSIVEMAP\n	uniform sampler2D emissiveMap;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/encodings_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'encodings_pars_fragment' ] = "\nvec4 LinearToLinear( in vec4 value ) {\n  return value;\n}\nvec4 GammaToLinear( in vec4 value, in float gammaFactor ) {\n  return vec4( pow( value.xyz, vec3( gammaFactor ) ), value.w );\n}\nvec4 LinearToGamma( in vec4 value, in float gammaFactor ) {\n  return vec4( pow( value.xyz, vec3( 1.0 / gammaFactor ) ), value.w );\n}\nvec4 sRGBToLinear( in vec4 value ) {\n  return vec4( mix( pow( value.rgb * 0.9478672986 + vec3( 0.0521327014 ), vec3( 2.4 ) ), value.rgb * 0.0773993808, vec3( lessThanEqual( value.rgb, vec3( 0.04045 ) ) ) ), value.w );\n}\nvec4 LinearTosRGB( in vec4 value ) {\n  return vec4( mix( pow( value.rgb, vec3( 0.41666 ) ) * 1.055 - vec3( 0.055 ), value.rgb * 12.92, vec3( lessThanEqual( value.rgb, vec3( 0.0031308 ) ) ) ), value.w );\n}\nvec4 RGBEToLinear( in vec4 value ) {\n  return vec4( value.rgb * exp2( value.a * 255.0 - 128.0 ), 1.0 );\n}\nvec4 LinearToRGBE( in vec4 value ) {\n  float maxComponent = max( max( value.r, value.g ), value.b );\n  float fExp = clamp( ceil( log2( maxComponent ) ), -128.0, 127.0 );\n  return vec4( value.rgb / exp2( fExp ), ( fExp + 128.0 ) / 255.0 );\n}\nvec4 RGBMToLinear( in vec4 value, in float maxRange ) {\n  return vec4( value.xyz * value.w * maxRange, 1.0 );\n}\nvec4 LinearToRGBM( in vec4 value, in float maxRange ) {\n  float maxRGB = max( value.x, max( value.g, value.b ) );\n  float M      = clamp( maxRGB / maxRange, 0.0, 1.0 );\n  M            = ceil( M * 255.0 ) / 255.0;\n  return vec4( value.rgb / ( M * maxRange ), M );\n}\nvec4 RGBDToLinear( in vec4 value, in float maxRange ) {\n    return vec4( value.rgb * ( ( maxRange / 255.0 ) / value.a ), 1.0 );\n}\nvec4 LinearToRGBD( in vec4 value, in float maxRange ) {\n    float maxRGB = max( value.x, max( value.g, value.b ) );\n    float D      = max( maxRange / maxRGB, 1.0 );\n    D            = min( floor( D ) / 255.0, 1.0 );\n    return vec4( value.rgb * ( D * ( 255.0 / maxRange ) ), D );\n}\nconst mat3 cLogLuvM = mat3( 0.2209, 0.3390, 0.4184, 0.1138, 0.6780, 0.7319, 0.0102, 0.1130, 0.2969 );\nvec4 LinearToLogLuv( in vec4 value )  {\n  vec3 Xp_Y_XYZp = value.rgb * cLogLuvM;\n  Xp_Y_XYZp = max(Xp_Y_XYZp, vec3(1e-6, 1e-6, 1e-6));\n  vec4 vResult;\n  vResult.xy = Xp_Y_XYZp.xy / Xp_Y_XYZp.z;\n  float Le = 2.0 * log2(Xp_Y_XYZp.y) + 127.0;\n  vResult.w = fract(Le);\n  vResult.z = (Le - (floor(vResult.w*255.0))/255.0)/255.0;\n  return vResult;\n}\nconst mat3 cLogLuvInverseM = mat3( 6.0014, -2.7008, -1.7996, -1.3320, 3.1029, -5.7721, 0.3008, -1.0882, 5.6268 );\nvec4 LogLuvToLinear( in vec4 value ) {\n  float Le = value.z * 255.0 + value.w;\n  vec3 Xp_Y_XYZp;\n  Xp_Y_XYZp.y = exp2((Le - 127.0) / 2.0);\n  Xp_Y_XYZp.z = Xp_Y_XYZp.y / value.y;\n  Xp_Y_XYZp.x = value.x * Xp_Y_XYZp.z;\n  vec3 vRGB = Xp_Y_XYZp.rgb * cLogLuvInverseM;\n  return vec4( max(vRGB, 0.0), 1.0 );\n}\n";
-
-// File:src/renderers/shaders/ShaderChunk/encodings_fragment.glsl
-
-THREE.ShaderChunk[ 'encodings_fragment' ] = "  gl_FragColor = linearToOutputTexel( gl_FragColor );\n";
-
-// File:src/renderers/shaders/ShaderChunk/envmap_fragment.glsl
-
-THREE.ShaderChunk[ 'envmap_fragment' ] = "#ifdef USE_ENVMAP\n	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n		vec3 cameraToVertex = normalize( vWorldPosition - cameraPosition );\n		vec3 worldNormal = inverseTransformDirection( normal, viewMatrix );\n		#ifdef ENVMAP_MODE_REFLECTION\n			vec3 reflectVec = reflect( cameraToVertex, worldNormal );\n		#else\n			vec3 reflectVec = refract( cameraToVertex, worldNormal, refractionRatio );\n		#endif\n	#else\n		vec3 reflectVec = vReflect;\n	#endif\n	#ifdef DOUBLE_SIDED\n		float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n	#else\n		float flipNormal = 1.0;\n	#endif\n	#ifdef ENVMAP_TYPE_CUBE\n		vec4 envColor = textureCube( envMap, flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz ) );\n	#elif defined( ENVMAP_TYPE_EQUIREC )\n		vec2 sampleUV;\n		sampleUV.y = saturate( flipNormal * reflectVec.y * 0.5 + 0.5 );\n		sampleUV.x = atan( flipNormal * reflectVec.z, flipNormal * reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n		vec4 envColor = texture2D( envMap, sampleUV );\n	#elif defined( ENVMAP_TYPE_SPHERE )\n		vec3 reflectView = flipNormal * normalize((viewMatrix * vec4( reflectVec, 0.0 )).xyz + vec3(0.0,0.0,1.0));\n		vec4 envColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5 );\n	#endif\n	envColor = envMapTexelToLinear( envColor );\n	#ifdef ENVMAP_BLENDING_MULTIPLY\n		outgoingLight = mix( outgoingLight, outgoingLight * envColor.xyz, specularStrength * reflectivity );\n	#elif defined( ENVMAP_BLENDING_MIX )\n		outgoingLight = mix( outgoingLight, envColor.xyz, specularStrength * reflectivity );\n	#elif defined( ENVMAP_BLENDING_ADD )\n		outgoingLight += envColor.xyz * specularStrength * reflectivity;\n	#endif\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/envmap_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'envmap_pars_fragment' ] = "#if defined( USE_ENVMAP ) || defined( PHYSICAL )\n	uniform float reflectivity;\n	uniform float envMapIntenstiy;\n#endif\n#ifdef USE_ENVMAP\n	#if ! defined( PHYSICAL ) && ( defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) )\n		varying vec3 vWorldPosition;\n	#endif\n	#ifdef ENVMAP_TYPE_CUBE\n		uniform samplerCube envMap;\n	#else\n		uniform sampler2D envMap;\n	#endif\n	uniform float flipEnvMap;\n	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG ) || defined( PHYSICAL )\n		uniform float refractionRatio;\n	#else\n		varying vec3 vReflect;\n	#endif\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/envmap_pars_vertex.glsl
-
-THREE.ShaderChunk[ 'envmap_pars_vertex' ] = "#ifdef USE_ENVMAP\n	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n		varying vec3 vWorldPosition;\n	#else\n		varying vec3 vReflect;\n		uniform float refractionRatio;\n	#endif\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/envmap_vertex.glsl
-
-THREE.ShaderChunk[ 'envmap_vertex' ] = "#ifdef USE_ENVMAP\n	#if defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( PHONG )\n		vWorldPosition = worldPosition.xyz;\n	#else\n		vec3 cameraToVertex = normalize( worldPosition.xyz - cameraPosition );\n		vec3 worldNormal = inverseTransformDirection( transformedNormal, viewMatrix );\n		#ifdef ENVMAP_MODE_REFLECTION\n			vReflect = reflect( cameraToVertex, worldNormal );\n		#else\n			vReflect = refract( cameraToVertex, worldNormal, refractionRatio );\n		#endif\n	#endif\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/fog_fragment.glsl
-
-THREE.ShaderChunk[ 'fog_fragment' ] = "#ifdef USE_FOG\n	#ifdef USE_LOGDEPTHBUF_EXT\n		float depth = gl_FragDepthEXT / gl_FragCoord.w;\n	#else\n		float depth = gl_FragCoord.z / gl_FragCoord.w;\n	#endif\n	#ifdef FOG_EXP2\n		float fogFactor = whiteCompliment( exp2( - fogDensity * fogDensity * depth * depth * LOG2 ) );\n	#else\n		float fogFactor = smoothstep( fogNear, fogFar, depth );\n	#endif\n	gl_FragColor.rgb = mix( gl_FragColor.rgb, fogColor, fogFactor );\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/fog_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'fog_pars_fragment' ] = "#ifdef USE_FOG\n	uniform vec3 fogColor;\n	#ifdef FOG_EXP2\n		uniform float fogDensity;\n	#else\n		uniform float fogNear;\n		uniform float fogFar;\n	#endif\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/lightmap_fragment.glsl
-
-THREE.ShaderChunk[ 'lightmap_fragment' ] = "#ifdef USE_LIGHTMAP\n	reflectedLight.indirectDiffuse += PI * texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/lightmap_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'lightmap_pars_fragment' ] = "#ifdef USE_LIGHTMAP\n	uniform sampler2D lightMap;\n	uniform float lightMapIntensity;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/lights_lambert_vertex.glsl
-
-THREE.ShaderChunk[ 'lights_lambert_vertex' ] = "vec3 diffuse = vec3( 1.0 );\nGeometricContext geometry;\ngeometry.position = mvPosition.xyz;\ngeometry.normal = normalize( transformedNormal );\ngeometry.viewDir = normalize( -mvPosition.xyz );\nGeometricContext backGeometry;\nbackGeometry.position = geometry.position;\nbackGeometry.normal = -geometry.normal;\nbackGeometry.viewDir = geometry.viewDir;\nvLightFront = vec3( 0.0 );\n#ifdef DOUBLE_SIDED\n	vLightBack = vec3( 0.0 );\n#endif\nIncidentLight directLight;\nfloat dotNL;\nvec3 directLightColor_Diffuse;\n#if NUM_POINT_LIGHTS > 0\n	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n		getPointDirectLightIrradiance( pointLights[ i ], geometry, directLight );\n		dotNL = dot( geometry.normal, directLight.direction );\n		directLightColor_Diffuse = PI * directLight.color;\n		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n		#ifdef DOUBLE_SIDED\n			vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n		#endif\n	}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n		getSpotDirectLightIrradiance( spotLights[ i ], geometry, directLight );\n		dotNL = dot( geometry.normal, directLight.direction );\n		directLightColor_Diffuse = PI * directLight.color;\n		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n		#ifdef DOUBLE_SIDED\n			vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n		#endif\n	}\n#endif\n#if NUM_DIR_LIGHTS > 0\n	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n		getDirectionalDirectLightIrradiance( directionalLights[ i ], geometry, directLight );\n		dotNL = dot( geometry.normal, directLight.direction );\n		directLightColor_Diffuse = PI * directLight.color;\n		vLightFront += saturate( dotNL ) * directLightColor_Diffuse;\n		#ifdef DOUBLE_SIDED\n			vLightBack += saturate( -dotNL ) * directLightColor_Diffuse;\n		#endif\n	}\n#endif\n#if NUM_HEMI_LIGHTS > 0\n	for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n		vLightFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n		#ifdef DOUBLE_SIDED\n			vLightBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry );\n		#endif\n	}\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/lights_pars.glsl
-
-THREE.ShaderChunk[ 'lights_pars' ] = "uniform vec3 ambientLightColor;\nvec3 getAmbientLightIrradiance( const in vec3 ambientLightColor ) {\n	vec3 irradiance = ambientLightColor;\n	#ifndef PHYSICALLY_CORRECT_LIGHTS\n		irradiance *= PI;\n	#endif\n	return irradiance;\n}\n#if NUM_DIR_LIGHTS > 0\n	struct DirectionalLight {\n		vec3 direction;\n		vec3 color;\n		int shadow;\n		float shadowBias;\n		float shadowRadius;\n		vec2 shadowMapSize;\n	};\n	uniform DirectionalLight directionalLights[ NUM_DIR_LIGHTS ];\n	void getDirectionalDirectLightIrradiance( const in DirectionalLight directionalLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n		directLight.color = directionalLight.color;\n		directLight.direction = directionalLight.direction;\n		directLight.visible = true;\n	}\n#endif\n#if NUM_POINT_LIGHTS > 0\n	struct PointLight {\n		vec3 position;\n		vec3 color;\n		float distance;\n		float decay;\n		int shadow;\n		float shadowBias;\n		float shadowRadius;\n		vec2 shadowMapSize;\n	};\n	uniform PointLight pointLights[ NUM_POINT_LIGHTS ];\n	void getPointDirectLightIrradiance( const in PointLight pointLight, const in GeometricContext geometry, out IncidentLight directLight ) {\n		vec3 lVector = pointLight.position - geometry.position;\n		directLight.direction = normalize( lVector );\n		float lightDistance = length( lVector );\n		if ( testLightInRange( lightDistance, pointLight.distance ) ) {\n			directLight.color = pointLight.color;\n			directLight.color *= punctualLightIntensityToIrradianceFactor( lightDistance, pointLight.distance, pointLight.decay );\n			directLight.visible = true;\n		} else {\n			directLight.color = vec3( 0.0 );\n			directLight.visible = false;\n		}\n	}\n#endif\n#if NUM_SPOT_LIGHTS > 0\n	struct SpotLight {\n		vec3 position;\n		vec3 direction;\n		vec3 color;\n		float distance;\n		float decay;\n		float coneCos;\n		float penumbraCos;\n		int shadow;\n		float shadowBias;\n		float shadowRadius;\n		vec2 shadowMapSize;\n	};\n	uniform SpotLight spotLights[ NUM_SPOT_LIGHTS ];\n	void getSpotDirectLightIrradiance( const in SpotLight spotLight, const in GeometricContext geometry, out IncidentLight directLight  ) {\n		vec3 lVector = spotLight.position - geometry.position;\n		directLight.direction = normalize( lVector );\n		float lightDistance = length( lVector );\n		float angleCos = dot( directLight.direction, spotLight.direction );\n		if ( all( bvec2( angleCos > spotLight.coneCos, testLightInRange( lightDistance, spotLight.distance ) ) ) ) {\n			float spotEffect = smoothstep( spotLight.coneCos, spotLight.penumbraCos, angleCos );\n			directLight.color = spotLight.color;\n			directLight.color *= spotEffect * punctualLightIntensityToIrradianceFactor( lightDistance, spotLight.distance, spotLight.decay );\n			directLight.visible = true;\n		} else {\n			directLight.color = vec3( 0.0 );\n			directLight.visible = false;\n		}\n	}\n#endif\n#if NUM_HEMI_LIGHTS > 0\n	struct HemisphereLight {\n		vec3 direction;\n		vec3 skyColor;\n		vec3 groundColor;\n	};\n	uniform HemisphereLight hemisphereLights[ NUM_HEMI_LIGHTS ];\n	vec3 getHemisphereLightIrradiance( const in HemisphereLight hemiLight, const in GeometricContext geometry ) {\n		float dotNL = dot( geometry.normal, hemiLight.direction );\n		float hemiDiffuseWeight = 0.5 * dotNL + 0.5;\n		vec3 irradiance = mix( hemiLight.groundColor, hemiLight.skyColor, hemiDiffuseWeight );\n		#ifndef PHYSICALLY_CORRECT_LIGHTS\n			irradiance *= PI;\n		#endif\n		return irradiance;\n	}\n#endif\n#if defined( USE_ENVMAP ) && defined( PHYSICAL )\n	vec3 getLightProbeIndirectIrradiance( const in GeometricContext geometry, const in int maxMIPLevel ) {\n		#ifdef DOUBLE_SIDED\n			float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n		#else\n			float flipNormal = 1.0;\n		#endif\n		vec3 worldNormal = inverseTransformDirection( geometry.normal, viewMatrix );\n		#ifdef ENVMAP_TYPE_CUBE\n			vec3 queryVec = flipNormal * vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n			#ifdef TEXTURE_LOD_EXT\n				vec4 envMapColor = textureCubeLodEXT( envMap, queryVec, float( maxMIPLevel ) );\n			#else\n				vec4 envMapColor = textureCube( envMap, queryVec, float( maxMIPLevel ) );\n			#endif\n			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n		#elif defined( ENVMAP_TYPE_CUBE_UV )\n			vec3 queryVec = flipNormal * vec3( flipEnvMap * worldNormal.x, worldNormal.yz );\n			vec4 envMapColor = textureCubeUV( queryVec, 1.0 );\n		#else\n			vec4 envMapColor = vec4( 0.0 );\n		#endif\n		return PI * envMapColor.rgb * envMapIntensity;\n	}\n	float getSpecularMIPLevel( const in float blinnShininessExponent, const in int maxMIPLevel ) {\n		float maxMIPLevelScalar = float( maxMIPLevel );\n		float desiredMIPLevel = maxMIPLevelScalar - 0.79248 - 0.5 * log2( pow2( blinnShininessExponent ) + 1.0 );\n		return clamp( desiredMIPLevel, 0.0, maxMIPLevelScalar );\n	}\n	vec3 getLightProbeIndirectRadiance( const in GeometricContext geometry, const in float blinnShininessExponent, const in int maxMIPLevel ) {\n		#ifdef ENVMAP_MODE_REFLECTION\n			vec3 reflectVec = reflect( -geometry.viewDir, geometry.normal );\n		#else\n			vec3 reflectVec = refract( -geometry.viewDir, geometry.normal, refractionRatio );\n		#endif\n		#ifdef DOUBLE_SIDED\n			float flipNormal = ( float( gl_FrontFacing ) * 2.0 - 1.0 );\n		#else\n			float flipNormal = 1.0;\n		#endif\n		reflectVec = inverseTransformDirection( reflectVec, viewMatrix );\n		float specularMIPLevel = getSpecularMIPLevel( blinnShininessExponent, maxMIPLevel );\n		#ifdef ENVMAP_TYPE_CUBE\n			vec3 queryReflectVec = flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n			#ifdef TEXTURE_LOD_EXT\n				vec4 envMapColor = textureCubeLodEXT( envMap, queryReflectVec, specularMIPLevel );\n			#else\n				vec4 envMapColor = textureCube( envMap, queryReflectVec, specularMIPLevel );\n			#endif\n			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n		#elif defined( ENVMAP_TYPE_CUBE_UV )\n			vec3 queryReflectVec = flipNormal * vec3( flipEnvMap * reflectVec.x, reflectVec.yz );\n			vec4 envMapColor = textureCubeUV(queryReflectVec, BlinnExponentToGGXRoughness(blinnShininessExponent));\n		#elif defined( ENVMAP_TYPE_EQUIREC )\n			vec2 sampleUV;\n			sampleUV.y = saturate( flipNormal * reflectVec.y * 0.5 + 0.5 );\n			sampleUV.x = atan( flipNormal * reflectVec.z, flipNormal * reflectVec.x ) * RECIPROCAL_PI2 + 0.5;\n			#ifdef TEXTURE_LOD_EXT\n				vec4 envMapColor = texture2DLodEXT( envMap, sampleUV, specularMIPLevel );\n			#else\n				vec4 envMapColor = texture2D( envMap, sampleUV, specularMIPLevel );\n			#endif\n			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n		#elif defined( ENVMAP_TYPE_SPHERE )\n			vec3 reflectView = flipNormal * normalize((viewMatrix * vec4( reflectVec, 0.0 )).xyz + vec3(0.0,0.0,1.0));\n			#ifdef TEXTURE_LOD_EXT\n				vec4 envMapColor = texture2DLodEXT( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n			#else\n				vec4 envMapColor = texture2D( envMap, reflectView.xy * 0.5 + 0.5, specularMIPLevel );\n			#endif\n			envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;\n		#endif\n		return envMapColor.rgb * envMapIntensity;\n	}\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/lights_phong_fragment.glsl
-
-THREE.ShaderChunk[ 'lights_phong_fragment' ] = "BlinnPhongMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb;\nmaterial.specularColor = specular;\nmaterial.specularShininess = shininess;\nmaterial.specularStrength = specularStrength;\n";
-
-// File:src/renderers/shaders/ShaderChunk/lights_phong_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'lights_phong_pars_fragment' ] = "varying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n	varying vec3 vNormal;\n#endif\nstruct BlinnPhongMaterial {\n	vec3	diffuseColor;\n	vec3	specularColor;\n	float	specularShininess;\n	float	specularStrength;\n};\nvoid RE_Direct_BlinnPhong( const in IncidentLight directLight, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n	vec3 irradiance = dotNL * directLight.color;\n	#ifndef PHYSICALLY_CORRECT_LIGHTS\n		irradiance *= PI;\n	#endif\n	reflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n	reflectedLight.directSpecular += irradiance * BRDF_Specular_BlinnPhong( directLight, geometry, material.specularColor, material.specularShininess ) * material.specularStrength;\n}\nvoid RE_IndirectDiffuse_BlinnPhong( const in vec3 irradiance, const in GeometricContext geometry, const in BlinnPhongMaterial material, inout ReflectedLight reflectedLight ) {\n	reflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\n#define RE_Direct				RE_Direct_BlinnPhong\n#define RE_IndirectDiffuse		RE_IndirectDiffuse_BlinnPhong\n#define Material_LightProbeLOD( material )	(0)\n";
-
-// File:src/renderers/shaders/ShaderChunk/lights_physical_fragment.glsl
-
-THREE.ShaderChunk[ 'lights_physical_fragment' ] = "PhysicalMaterial material;\nmaterial.diffuseColor = diffuseColor.rgb * ( 1.0 - metalnessFactor );\nmaterial.specularRoughness = clamp( roughnessFactor, 0.04, 1.0 );\n#ifdef STANDARD\n	material.specularColor = mix( vec3( 0.04 ), diffuseColor.rgb, metalnessFactor );\n#else\n	material.specularColor = mix( vec3( 0.16 * pow2( reflectivity ) ), diffuseColor.rgb, metalnessFactor );\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/lights_physical_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'lights_physical_pars_fragment' ] = "struct PhysicalMaterial {\n	vec3	diffuseColor;\n	float	specularRoughness;\n	vec3	specularColor;\n	#ifndef STANDARD\n	#endif\n};\nvoid RE_Direct_Physical( const in IncidentLight directLight, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n	float dotNL = saturate( dot( geometry.normal, directLight.direction ) );\n	vec3 irradiance = dotNL * directLight.color;\n	#ifndef PHYSICALLY_CORRECT_LIGHTS\n		irradiance *= PI;\n	#endif\n	reflectedLight.directDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n	reflectedLight.directSpecular += irradiance * BRDF_Specular_GGX( directLight, geometry, material.specularColor, material.specularRoughness );\n}\nvoid RE_IndirectDiffuse_Physical( const in vec3 irradiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n	reflectedLight.indirectDiffuse += irradiance * BRDF_Diffuse_Lambert( material.diffuseColor );\n}\nvoid RE_IndirectSpecular_Physical( const in vec3 radiance, const in GeometricContext geometry, const in PhysicalMaterial material, inout ReflectedLight reflectedLight ) {\n	reflectedLight.indirectSpecular += radiance * BRDF_Specular_GGX_Environment( geometry, material.specularColor, material.specularRoughness );\n}\n#define RE_Direct				RE_Direct_Physical\n#define RE_IndirectDiffuse		RE_IndirectDiffuse_Physical\n#define RE_IndirectSpecular		RE_IndirectSpecular_Physical\n#define Material_BlinnShininessExponent( material )   GGXRoughnessToBlinnExponent( material.specularRoughness )\nfloat computeSpecularOcclusion( const in float dotNV, const in float ambientOcclusion, const in float roughness ) {\n	return saturate( pow( dotNV + ambientOcclusion, exp2( - 16.0 * roughness - 1.0 ) ) - 1.0 + ambientOcclusion );\n}\n";
-
-// File:src/renderers/shaders/ShaderChunk/lights_template.glsl
-
-THREE.ShaderChunk[ 'lights_template' ] = "\nGeometricContext geometry;\ngeometry.position = - vViewPosition;\ngeometry.normal = normal;\ngeometry.viewDir = normalize( vViewPosition );\nIncidentLight directLight;\n#if ( NUM_POINT_LIGHTS > 0 ) && defined( RE_Direct )\n	PointLight pointLight;\n	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n		pointLight = pointLights[ i ];\n		getPointDirectLightIrradiance( pointLight, geometry, directLight );\n		#ifdef USE_SHADOWMAP\n		directLight.color *= all( bvec2( pointLight.shadow, directLight.visible ) ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ] ) : 1.0;\n		#endif\n		RE_Direct( directLight, geometry, material, reflectedLight );\n	}\n#endif\n#if ( NUM_SPOT_LIGHTS > 0 ) && defined( RE_Direct )\n	SpotLight spotLight;\n	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n		spotLight = spotLights[ i ];\n		getSpotDirectLightIrradiance( spotLight, geometry, directLight );\n		#ifdef USE_SHADOWMAP\n		directLight.color *= all( bvec2( spotLight.shadow, directLight.visible ) ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n		#endif\n		RE_Direct( directLight, geometry, material, reflectedLight );\n	}\n#endif\n#if ( NUM_DIR_LIGHTS > 0 ) && defined( RE_Direct )\n	DirectionalLight directionalLight;\n	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n		directionalLight = directionalLights[ i ];\n		getDirectionalDirectLightIrradiance( directionalLight, geometry, directLight );\n		#ifdef USE_SHADOWMAP\n		directLight.color *= all( bvec2( directionalLight.shadow, directLight.visible ) ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n		#endif\n		RE_Direct( directLight, geometry, material, reflectedLight );\n	}\n#endif\n#if defined( RE_IndirectDiffuse )\n	vec3 irradiance = getAmbientLightIrradiance( ambientLightColor );\n	#ifdef USE_LIGHTMAP\n		vec3 lightMapIrradiance = texture2D( lightMap, vUv2 ).xyz * lightMapIntensity;\n		#ifndef PHYSICALLY_CORRECT_LIGHTS\n			lightMapIrradiance *= PI;\n		#endif\n		irradiance += lightMapIrradiance;\n	#endif\n	#if ( NUM_HEMI_LIGHTS > 0 )\n		for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {\n			irradiance += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry );\n		}\n	#endif\n	#if defined( USE_ENVMAP ) && defined( PHYSICAL ) && defined( ENVMAP_TYPE_CUBE_UV )\n	 	irradiance += getLightProbeIndirectIrradiance( geometry, 8 );\n	#endif\n	RE_IndirectDiffuse( irradiance, geometry, material, reflectedLight );\n#endif\n#if defined( USE_ENVMAP ) && defined( RE_IndirectSpecular )\n	vec3 radiance = getLightProbeIndirectRadiance( geometry, Material_BlinnShininessExponent( material ), 8 );\n	RE_IndirectSpecular( radiance, geometry, material, reflectedLight );\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/logdepthbuf_fragment.glsl
-
-THREE.ShaderChunk[ 'logdepthbuf_fragment' ] = "#if defined(USE_LOGDEPTHBUF) && defined(USE_LOGDEPTHBUF_EXT)\n	gl_FragDepthEXT = log2(vFragDepth) * logDepthBufFC * 0.5;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/logdepthbuf_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'logdepthbuf_pars_fragment' ] = "#ifdef USE_LOGDEPTHBUF\n	uniform float logDepthBufFC;\n	#ifdef USE_LOGDEPTHBUF_EXT\n		varying float vFragDepth;\n	#endif\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/logdepthbuf_pars_vertex.glsl
-
-THREE.ShaderChunk[ 'logdepthbuf_pars_vertex' ] = "#ifdef USE_LOGDEPTHBUF\n	#ifdef USE_LOGDEPTHBUF_EXT\n		varying float vFragDepth;\n	#endif\n	uniform float logDepthBufFC;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/logdepthbuf_vertex.glsl
-
-THREE.ShaderChunk[ 'logdepthbuf_vertex' ] = "#ifdef USE_LOGDEPTHBUF\n	gl_Position.z = log2(max( EPSILON, gl_Position.w + 1.0 )) * logDepthBufFC;\n	#ifdef USE_LOGDEPTHBUF_EXT\n		vFragDepth = 1.0 + gl_Position.w;\n	#else\n		gl_Position.z = (gl_Position.z - 1.0) * gl_Position.w;\n	#endif\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/map_fragment.glsl
-
-THREE.ShaderChunk[ 'map_fragment' ] = "#ifdef USE_MAP\n	vec4 texelColor = texture2D( map, vUv );\n	texelColor = mapTexelToLinear( texelColor );\n	diffuseColor *= texelColor;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/map_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'map_pars_fragment' ] = "#ifdef USE_MAP\n	uniform sampler2D map;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/map_particle_fragment.glsl
-
-THREE.ShaderChunk[ 'map_particle_fragment' ] = "#ifdef USE_MAP\n	vec4 mapTexel = texture2D( map, vec2( gl_PointCoord.x, 1.0 - gl_PointCoord.y ) * offsetRepeat.zw + offsetRepeat.xy );\n	diffuseColor *= mapTexelToLinear( mapTexel );\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/map_particle_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'map_particle_pars_fragment' ] = "#ifdef USE_MAP\n	uniform vec4 offsetRepeat;\n	uniform sampler2D map;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/metalnessmap_fragment.glsl
-
-THREE.ShaderChunk[ 'metalnessmap_fragment' ] = "float metalnessFactor = metalness;\n#ifdef USE_METALNESSMAP\n	vec4 texelMetalness = texture2D( metalnessMap, vUv );\n	metalnessFactor *= texelMetalness.r;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/metalnessmap_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'metalnessmap_pars_fragment' ] = "#ifdef USE_METALNESSMAP\n	uniform sampler2D metalnessMap;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/morphnormal_vertex.glsl
-
-THREE.ShaderChunk[ 'morphnormal_vertex' ] = "#ifdef USE_MORPHNORMALS\n	objectNormal += ( morphNormal0 - normal ) * morphTargetInfluences[ 0 ];\n	objectNormal += ( morphNormal1 - normal ) * morphTargetInfluences[ 1 ];\n	objectNormal += ( morphNormal2 - normal ) * morphTargetInfluences[ 2 ];\n	objectNormal += ( morphNormal3 - normal ) * morphTargetInfluences[ 3 ];\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/morphtarget_pars_vertex.glsl
-
-THREE.ShaderChunk[ 'morphtarget_pars_vertex' ] = "#ifdef USE_MORPHTARGETS\n	#ifndef USE_MORPHNORMALS\n	uniform float morphTargetInfluences[ 8 ];\n	#else\n	uniform float morphTargetInfluences[ 4 ];\n	#endif\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/morphtarget_vertex.glsl
-
-THREE.ShaderChunk[ 'morphtarget_vertex' ] = "#ifdef USE_MORPHTARGETS\n	transformed += ( morphTarget0 - position ) * morphTargetInfluences[ 0 ];\n	transformed += ( morphTarget1 - position ) * morphTargetInfluences[ 1 ];\n	transformed += ( morphTarget2 - position ) * morphTargetInfluences[ 2 ];\n	transformed += ( morphTarget3 - position ) * morphTargetInfluences[ 3 ];\n	#ifndef USE_MORPHNORMALS\n	transformed += ( morphTarget4 - position ) * morphTargetInfluences[ 4 ];\n	transformed += ( morphTarget5 - position ) * morphTargetInfluences[ 5 ];\n	transformed += ( morphTarget6 - position ) * morphTargetInfluences[ 6 ];\n	transformed += ( morphTarget7 - position ) * morphTargetInfluences[ 7 ];\n	#endif\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/normal_fragment.glsl
-
-THREE.ShaderChunk[ 'normal_fragment' ] = "#ifdef FLAT_SHADED\n	vec3 fdx = vec3( dFdx( vViewPosition.x ), dFdx( vViewPosition.y ), dFdx( vViewPosition.z ) );\n	vec3 fdy = vec3( dFdy( vViewPosition.x ), dFdy( vViewPosition.y ), dFdy( vViewPosition.z ) );\n	vec3 normal = normalize( cross( fdx, fdy ) );\n#else\n	vec3 normal = normalize( vNormal );\n	#ifdef DOUBLE_SIDED\n		normal = normal * ( -1.0 + 2.0 * float( gl_FrontFacing ) );\n	#endif\n#endif\n#ifdef USE_NORMALMAP\n	normal = perturbNormal2Arb( -vViewPosition, normal );\n#elif defined( USE_BUMPMAP )\n	normal = perturbNormalArb( -vViewPosition, normal, dHdxy_fwd() );\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/normalmap_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'normalmap_pars_fragment' ] = "#ifdef USE_NORMALMAP\n	uniform sampler2D normalMap;\n	uniform vec2 normalScale;\n	vec3 perturbNormal2Arb( vec3 eye_pos, vec3 surf_norm ) {\n		vec3 q0 = dFdx( eye_pos.xyz );\n		vec3 q1 = dFdy( eye_pos.xyz );\n		vec2 st0 = dFdx( vUv.st );\n		vec2 st1 = dFdy( vUv.st );\n		vec3 S = normalize( q0 * st1.t - q1 * st0.t );\n		vec3 T = normalize( -q0 * st1.s + q1 * st0.s );\n		vec3 N = normalize( surf_norm );\n		vec3 mapN = texture2D( normalMap, vUv ).xyz * 2.0 - 1.0;\n		mapN.xy = normalScale * mapN.xy;\n		mat3 tsn = mat3( S, T, N );\n		return normalize( tsn * mapN );\n	}\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/packing.glsl
-
-THREE.ShaderChunk[ 'packing' ] = "vec3 packNormalToRGB( const in vec3 normal ) {\n  return normalize( normal ) * 0.5 + 0.5;\n}\nvec3 unpackRGBToNormal( const in vec3 rgb ) {\n  return 1.0 - 2.0 * rgb.xyz;\n}\nvec4 packDepthToRGBA( const in float value ) {\n	const vec4 bit_shift = vec4( 256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0 );\n	const vec4 bit_mask = vec4( 0.0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0 );\n	vec4 res = mod( value * bit_shift * vec4( 255 ), vec4( 256 ) ) / vec4( 255 );\n	res -= res.xxyz * bit_mask;\n	return res;\n}\nfloat unpackRGBAToDepth( const in vec4 rgba ) {\n	const vec4 bitSh = vec4( 1.0 / ( 256.0 * 256.0 * 256.0 ), 1.0 / ( 256.0 * 256.0 ), 1.0 / 256.0, 1.0 );\n	return dot( rgba, bitSh );\n}\nfloat viewZToOrthoDepth( const in float viewZ, const in float near, const in float far ) {\n  return ( viewZ + near ) / ( near - far );\n}\nfloat OrthoDepthToViewZ( const in float linearClipZ, const in float near, const in float far ) {\n  return linearClipZ * ( near - far ) - near;\n}\nfloat viewZToPerspectiveDepth( const in float viewZ, const in float near, const in float far ) {\n  return (( near + viewZ ) * far ) / (( far - near ) * viewZ );\n}\nfloat perspectiveDepthToViewZ( const in float invClipZ, const in float near, const in float far ) {\n  return ( near * far ) / ( ( far - near ) * invClipZ - far );\n}\n";
-
-// File:src/renderers/shaders/ShaderChunk/premultiplied_alpha_fragment.glsl
-
-THREE.ShaderChunk[ 'premultiplied_alpha_fragment' ] = "#ifdef PREMULTIPLIED_ALPHA\n	gl_FragColor.rgb *= gl_FragColor.a;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/project_vertex.glsl
-
-THREE.ShaderChunk[ 'project_vertex' ] = "#ifdef USE_SKINNING\n	vec4 mvPosition = modelViewMatrix * skinned;\n#else\n	vec4 mvPosition = modelViewMatrix * vec4( transformed, 1.0 );\n#endif\ngl_Position = projectionMatrix * mvPosition;\n";
-
-// File:src/renderers/shaders/ShaderChunk/roughnessmap_fragment.glsl
-
-THREE.ShaderChunk[ 'roughnessmap_fragment' ] = "float roughnessFactor = roughness;\n#ifdef USE_ROUGHNESSMAP\n	vec4 texelRoughness = texture2D( roughnessMap, vUv );\n	roughnessFactor *= texelRoughness.r;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/roughnessmap_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'roughnessmap_pars_fragment' ] = "#ifdef USE_ROUGHNESSMAP\n	uniform sampler2D roughnessMap;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/shadowmap_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'shadowmap_pars_fragment' ] = "#ifdef USE_SHADOWMAP\n	#if NUM_DIR_LIGHTS > 0\n		uniform sampler2D directionalShadowMap[ NUM_DIR_LIGHTS ];\n		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\n	#endif\n	#if NUM_SPOT_LIGHTS > 0\n		uniform sampler2D spotShadowMap[ NUM_SPOT_LIGHTS ];\n		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\n	#endif\n	#if NUM_POINT_LIGHTS > 0\n		uniform sampler2D pointShadowMap[ NUM_POINT_LIGHTS ];\n		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\n	#endif\n	float texture2DCompare( sampler2D depths, vec2 uv, float compare ) {\n		return step( compare, unpackRGBAToDepth( texture2D( depths, uv ) ) );\n	}\n	float texture2DShadowLerp( sampler2D depths, vec2 size, vec2 uv, float compare ) {\n		const vec2 offset = vec2( 0.0, 1.0 );\n		vec2 texelSize = vec2( 1.0 ) / size;\n		vec2 centroidUV = floor( uv * size + 0.5 ) / size;\n		float lb = texture2DCompare( depths, centroidUV + texelSize * offset.xx, compare );\n		float lt = texture2DCompare( depths, centroidUV + texelSize * offset.xy, compare );\n		float rb = texture2DCompare( depths, centroidUV + texelSize * offset.yx, compare );\n		float rt = texture2DCompare( depths, centroidUV + texelSize * offset.yy, compare );\n		vec2 f = fract( uv * size + 0.5 );\n		float a = mix( lb, lt, f.y );\n		float b = mix( rb, rt, f.y );\n		float c = mix( a, b, f.x );\n		return c;\n	}\n	float getShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n		shadowCoord.xyz /= shadowCoord.w;\n		shadowCoord.z += shadowBias;\n		bvec4 inFrustumVec = bvec4 ( shadowCoord.x >= 0.0, shadowCoord.x <= 1.0, shadowCoord.y >= 0.0, shadowCoord.y <= 1.0 );\n		bool inFrustum = all( inFrustumVec );\n		bvec2 frustumTestVec = bvec2( inFrustum, shadowCoord.z <= 1.0 );\n		bool frustumTest = all( frustumTestVec );\n		if ( frustumTest ) {\n		#if defined( SHADOWMAP_TYPE_PCF )\n			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n			float dx0 = - texelSize.x * shadowRadius;\n			float dy0 = - texelSize.y * shadowRadius;\n			float dx1 = + texelSize.x * shadowRadius;\n			float dy1 = + texelSize.y * shadowRadius;\n			return (\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n				texture2DCompare( shadowMap, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n			) * ( 1.0 / 9.0 );\n		#elif defined( SHADOWMAP_TYPE_PCF_SOFT )\n			vec2 texelSize = vec2( 1.0 ) / shadowMapSize;\n			float dx0 = - texelSize.x * shadowRadius;\n			float dy0 = - texelSize.y * shadowRadius;\n			float dx1 = + texelSize.x * shadowRadius;\n			float dy1 = + texelSize.y * shadowRadius;\n			return (\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy0 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy0 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy0 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, 0.0 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy, shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, 0.0 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx0, dy1 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( 0.0, dy1 ), shadowCoord.z ) +\n				texture2DShadowLerp( shadowMap, shadowMapSize, shadowCoord.xy + vec2( dx1, dy1 ), shadowCoord.z )\n			) * ( 1.0 / 9.0 );\n		#else\n			return texture2DCompare( shadowMap, shadowCoord.xy, shadowCoord.z );\n		#endif\n		}\n		return 1.0;\n	}\n	vec2 cubeToUV( vec3 v, float texelSizeY ) {\n		vec3 absV = abs( v );\n		float scaleToCube = 1.0 / max( absV.x, max( absV.y, absV.z ) );\n		absV *= scaleToCube;\n		v *= scaleToCube * ( 1.0 - 2.0 * texelSizeY );\n		vec2 planar = v.xy;\n		float almostATexel = 1.5 * texelSizeY;\n		float almostOne = 1.0 - almostATexel;\n		if ( absV.z >= almostOne ) {\n			if ( v.z > 0.0 )\n				planar.x = 4.0 - v.x;\n		} else if ( absV.x >= almostOne ) {\n			float signX = sign( v.x );\n			planar.x = v.z * signX + 2.0 * signX;\n		} else if ( absV.y >= almostOne ) {\n			float signY = sign( v.y );\n			planar.x = v.x + 2.0 * signY + 2.0;\n			planar.y = v.z * signY - 2.0;\n		}\n		return vec2( 0.125, 0.25 ) * planar + vec2( 0.375, 0.75 );\n	}\n	float getPointShadow( sampler2D shadowMap, vec2 shadowMapSize, float shadowBias, float shadowRadius, vec4 shadowCoord ) {\n		vec2 texelSize = vec2( 1.0 ) / ( shadowMapSize * vec2( 4.0, 2.0 ) );\n		vec3 lightToPosition = shadowCoord.xyz;\n		vec3 bd3D = normalize( lightToPosition );\n		float dp = ( length( lightToPosition ) - shadowBias ) / 1000.0;\n		#if defined( SHADOWMAP_TYPE_PCF ) || defined( SHADOWMAP_TYPE_PCF_SOFT )\n			vec2 offset = vec2( - 1, 1 ) * shadowRadius * texelSize.y;\n			return (\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyy, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyy, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xyx, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yyx, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxy, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxy, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.xxx, texelSize.y ), dp ) +\n				texture2DCompare( shadowMap, cubeToUV( bd3D + offset.yxx, texelSize.y ), dp )\n			) * ( 1.0 / 9.0 );\n		#else\n			return texture2DCompare( shadowMap, cubeToUV( bd3D, texelSize.y ), dp );\n		#endif\n	}\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/shadowmap_pars_vertex.glsl
-
-THREE.ShaderChunk[ 'shadowmap_pars_vertex' ] = "#ifdef USE_SHADOWMAP\n	#if NUM_DIR_LIGHTS > 0\n		uniform mat4 directionalShadowMatrix[ NUM_DIR_LIGHTS ];\n		varying vec4 vDirectionalShadowCoord[ NUM_DIR_LIGHTS ];\n	#endif\n	#if NUM_SPOT_LIGHTS > 0\n		uniform mat4 spotShadowMatrix[ NUM_SPOT_LIGHTS ];\n		varying vec4 vSpotShadowCoord[ NUM_SPOT_LIGHTS ];\n	#endif\n	#if NUM_POINT_LIGHTS > 0\n		uniform mat4 pointShadowMatrix[ NUM_POINT_LIGHTS ];\n		varying vec4 vPointShadowCoord[ NUM_POINT_LIGHTS ];\n	#endif\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/shadowmap_vertex.glsl
-
-THREE.ShaderChunk[ 'shadowmap_vertex' ] = "#ifdef USE_SHADOWMAP\n	#if NUM_DIR_LIGHTS > 0\n	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n		vDirectionalShadowCoord[ i ] = directionalShadowMatrix[ i ] * worldPosition;\n	}\n	#endif\n	#if NUM_SPOT_LIGHTS > 0\n	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n		vSpotShadowCoord[ i ] = spotShadowMatrix[ i ] * worldPosition;\n	}\n	#endif\n	#if NUM_POINT_LIGHTS > 0\n	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n		vPointShadowCoord[ i ] = pointShadowMatrix[ i ] * worldPosition;\n	}\n	#endif\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/shadowmask_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'shadowmask_pars_fragment' ] = "float getShadowMask() {\n	float shadow = 1.0;\n	#ifdef USE_SHADOWMAP\n	#if NUM_DIR_LIGHTS > 0\n	DirectionalLight directionalLight;\n	for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {\n		directionalLight = directionalLights[ i ];\n		shadow *= bool( directionalLight.shadow ) ? getShadow( directionalShadowMap[ i ], directionalLight.shadowMapSize, directionalLight.shadowBias, directionalLight.shadowRadius, vDirectionalShadowCoord[ i ] ) : 1.0;\n	}\n	#endif\n	#if NUM_SPOT_LIGHTS > 0\n	SpotLight spotLight;\n	for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {\n		spotLight = spotLights[ i ];\n		shadow *= bool( spotLight.shadow ) ? getShadow( spotShadowMap[ i ], spotLight.shadowMapSize, spotLight.shadowBias, spotLight.shadowRadius, vSpotShadowCoord[ i ] ) : 1.0;\n	}\n	#endif\n	#if NUM_POINT_LIGHTS > 0\n	PointLight pointLight;\n	for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {\n		pointLight = pointLights[ i ];\n		shadow *= bool( pointLight.shadow ) ? getPointShadow( pointShadowMap[ i ], pointLight.shadowMapSize, pointLight.shadowBias, pointLight.shadowRadius, vPointShadowCoord[ i ] ) : 1.0;\n	}\n	#endif\n	#endif\n	return shadow;\n}\n";
-
-// File:src/renderers/shaders/ShaderChunk/skinbase_vertex.glsl
-
-THREE.ShaderChunk[ 'skinbase_vertex' ] = "#ifdef USE_SKINNING\n	mat4 boneMatX = getBoneMatrix( skinIndex.x );\n	mat4 boneMatY = getBoneMatrix( skinIndex.y );\n	mat4 boneMatZ = getBoneMatrix( skinIndex.z );\n	mat4 boneMatW = getBoneMatrix( skinIndex.w );\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/skinning_pars_vertex.glsl
-
-THREE.ShaderChunk[ 'skinning_pars_vertex' ] = "#ifdef USE_SKINNING\n	uniform mat4 bindMatrix;\n	uniform mat4 bindMatrixInverse;\n	#ifdef BONE_TEXTURE\n		uniform sampler2D boneTexture;\n		uniform int boneTextureWidth;\n		uniform int boneTextureHeight;\n		mat4 getBoneMatrix( const in float i ) {\n			float j = i * 4.0;\n			float x = mod( j, float( boneTextureWidth ) );\n			float y = floor( j / float( boneTextureWidth ) );\n			float dx = 1.0 / float( boneTextureWidth );\n			float dy = 1.0 / float( boneTextureHeight );\n			y = dy * ( y + 0.5 );\n			vec4 v1 = texture2D( boneTexture, vec2( dx * ( x + 0.5 ), y ) );\n			vec4 v2 = texture2D( boneTexture, vec2( dx * ( x + 1.5 ), y ) );\n			vec4 v3 = texture2D( boneTexture, vec2( dx * ( x + 2.5 ), y ) );\n			vec4 v4 = texture2D( boneTexture, vec2( dx * ( x + 3.5 ), y ) );\n			mat4 bone = mat4( v1, v2, v3, v4 );\n			return bone;\n		}\n	#else\n		uniform mat4 boneMatrices[ MAX_BONES ];\n		mat4 getBoneMatrix( const in float i ) {\n			mat4 bone = boneMatrices[ int(i) ];\n			return bone;\n		}\n	#endif\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/skinning_vertex.glsl
-
-THREE.ShaderChunk[ 'skinning_vertex' ] = "#ifdef USE_SKINNING\n	vec4 skinVertex = bindMatrix * vec4( transformed, 1.0 );\n	vec4 skinned = vec4( 0.0 );\n	skinned += boneMatX * skinVertex * skinWeight.x;\n	skinned += boneMatY * skinVertex * skinWeight.y;\n	skinned += boneMatZ * skinVertex * skinWeight.z;\n	skinned += boneMatW * skinVertex * skinWeight.w;\n	skinned  = bindMatrixInverse * skinned;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/skinnormal_vertex.glsl
-
-THREE.ShaderChunk[ 'skinnormal_vertex' ] = "#ifdef USE_SKINNING\n	mat4 skinMatrix = mat4( 0.0 );\n	skinMatrix += skinWeight.x * boneMatX;\n	skinMatrix += skinWeight.y * boneMatY;\n	skinMatrix += skinWeight.z * boneMatZ;\n	skinMatrix += skinWeight.w * boneMatW;\n	skinMatrix  = bindMatrixInverse * skinMatrix * bindMatrix;\n	objectNormal = vec4( skinMatrix * vec4( objectNormal, 0.0 ) ).xyz;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/specularmap_fragment.glsl
-
-THREE.ShaderChunk[ 'specularmap_fragment' ] = "float specularStrength;\n#ifdef USE_SPECULARMAP\n	vec4 texelSpecular = texture2D( specularMap, vUv );\n	specularStrength = texelSpecular.r;\n#else\n	specularStrength = 1.0;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/specularmap_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'specularmap_pars_fragment' ] = "#ifdef USE_SPECULARMAP\n	uniform sampler2D specularMap;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/tonemapping_fragment.glsl
-
-THREE.ShaderChunk[ 'tonemapping_fragment' ] = "#if defined( TONE_MAPPING )\n  gl_FragColor.rgb = toneMapping( gl_FragColor.rgb );\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/tonemapping_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'tonemapping_pars_fragment' ] = "#define saturate(a) clamp( a, 0.0, 1.0 )\nuniform float toneMappingExposure;\nuniform float toneMappingWhitePoint;\nvec3 LinearToneMapping( vec3 color ) {\n  return toneMappingExposure * color;\n}\nvec3 ReinhardToneMapping( vec3 color ) {\n  color *= toneMappingExposure;\n  return saturate( color / ( vec3( 1.0 ) + color ) );\n}\n#define Uncharted2Helper( x ) max( ( ( x * ( 0.15 * x + 0.10 * 0.50 ) + 0.20 * 0.02 ) / ( x * ( 0.15 * x + 0.50 ) + 0.20 * 0.30 ) ) - 0.02 / 0.30, vec3( 0.0 ) )\nvec3 Uncharted2ToneMapping( vec3 color ) {\n  color *= toneMappingExposure;\n  return saturate( Uncharted2Helper( color ) / Uncharted2Helper( vec3( toneMappingWhitePoint ) ) );\n}\nvec3 OptimizedCineonToneMapping( vec3 color ) {\n  color *= toneMappingExposure;\n  color = max( vec3( 0.0 ), color - 0.004 );\n  return pow( ( color * ( 6.2 * color + 0.5 ) ) / ( color * ( 6.2 * color + 1.7 ) + 0.06 ), vec3( 2.2 ) );\n}\n";
-
-// File:src/renderers/shaders/ShaderChunk/uv2_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'uv2_pars_fragment' ] = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n	varying vec2 vUv2;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/uv2_pars_vertex.glsl
-
-THREE.ShaderChunk[ 'uv2_pars_vertex' ] = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n	attribute vec2 uv2;\n	varying vec2 vUv2;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/uv2_vertex.glsl
-
-THREE.ShaderChunk[ 'uv2_vertex' ] = "#if defined( USE_LIGHTMAP ) || defined( USE_AOMAP )\n	vUv2 = uv2;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/uv_pars_fragment.glsl
-
-THREE.ShaderChunk[ 'uv_pars_fragment' ] = "#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\n	varying vec2 vUv;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/uv_pars_vertex.glsl
-
-THREE.ShaderChunk[ 'uv_pars_vertex' ] = "#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\n	varying vec2 vUv;\n	uniform vec4 offsetRepeat;\n#endif\n";
-
-// File:src/renderers/shaders/ShaderChunk/uv_vertex.glsl
-
-THREE.ShaderChunk[ 'uv_vertex' ] = "#if defined( USE_MAP ) || defined( USE_BUMPMAP ) || defined( USE_NORMALMAP ) || defined( USE_SPECULARMAP ) || defined( USE_ALPHAMAP ) || defined( USE_EMISSIVEMAP ) || defined( USE_ROUGHNESSMAP ) || defined( USE_METALNESSMAP )\n	vUv = uv * offsetRepeat.zw + offsetRepeat.xy;\n#endif";
-
-// File:src/renderers/shaders/ShaderChunk/worldpos_vertex.glsl
-
-THREE.ShaderChunk[ 'worldpos_vertex' ] = "#if defined( USE_ENVMAP ) || defined( PHONG ) || defined( PHYSICAL ) || defined( LAMBERT ) || defined ( USE_SHADOWMAP )\n	#ifdef USE_SKINNING\n		vec4 worldPosition = modelMatrix * skinned;\n	#else\n		vec4 worldPosition = modelMatrix * vec4( transformed, 1.0 );\n	#endif\n#endif\n";
-
-// File:src/renderers/shaders/UniformsUtils.js
-
-/**
- * Uniform Utilities
- */
-
-THREE.UniformsUtils = {
-
-	merge: function ( uniforms ) {
-
-		var merged = {};
-
-		for ( var u = 0; u < uniforms.length; u ++ ) {
-
-			var tmp = this.clone( uniforms[ u ] );
-
-			for ( var p in tmp ) {
-
-				merged[ p ] = tmp[ p ];
-
-			}
-
-		}
-
-		return merged;
-
-	},
-
-	clone: function ( uniforms_src ) {
-
-		var uniforms_dst = {};
-
-		for ( var u in uniforms_src ) {
-
-			uniforms_dst[ u ] = {};
-
-			for ( var p in uniforms_src[ u ] ) {
-
-				var parameter_src = uniforms_src[ u ][ p ];
-
-				if ( parameter_src instanceof THREE.Color ||
-					 parameter_src instanceof THREE.Vector2 ||
-					 parameter_src instanceof THREE.Vector3 ||
-					 parameter_src instanceof THREE.Vector4 ||
-					 parameter_src instanceof THREE.Matrix3 ||
-					 parameter_src instanceof THREE.Matrix4 ||
-					 parameter_src instanceof THREE.Texture ) {
-
-					uniforms_dst[ u ][ p ] = parameter_src.clone();
-
-				} else if ( Array.isArray( parameter_src ) ) {
-
-					uniforms_dst[ u ][ p ] = parameter_src.slice();
-
-				} else {
-
-					uniforms_dst[ u ][ p ] = parameter_src;
-
-				}
-
-			}
-
-		}
-
-		return uniforms_dst;
-
-	}
-
-};
-
-// File:src/renderers/shaders/UniformsLib.js
-
-/**
- * Uniforms library for shared webgl shaders
- */
-
-THREE.UniformsLib = {
-
-	common: {
-
-		"diffuse": { type: "c", value: new THREE.Color( 0xeeeeee ) },
-		"opacity": { type: "1f", value: 1.0 },
-
-		"map": { type: "t", value: null },
-		"offsetRepeat": { type: "v4", value: new THREE.Vector4( 0, 0, 1, 1 ) },
-
-		"specularMap": { type: "t", value: null },
-		"alphaMap": { type: "t", value: null },
-
-		"envMap": { type: "t", value: null },
-		"flipEnvMap": { type: "1f", value: - 1 },
-		"reflectivity": { type: "1f", value: 1.0 },
-		"refractionRatio": { type: "1f", value: 0.98 }
-
-	},
-
-	aomap: {
-
-		"aoMap": { type: "t", value: null },
-		"aoMapIntensity": { type: "1f", value: 1 }
-
-	},
-
-	lightmap: {
-
-		"lightMap": { type: "t", value: null },
-		"lightMapIntensity": { type: "1f", value: 1 }
-
-	},
-
-	emissivemap: {
-
-		"emissiveMap": { type: "t", value: null }
-
-	},
-
-	bumpmap: {
-
-		"bumpMap": { type: "t", value: null },
-		"bumpScale": { type: "1f", value: 1 }
-
-	},
-
-	normalmap: {
-
-		"normalMap": { type: "t", value: null },
-		"normalScale": { type: "v2", value: new THREE.Vector2( 1, 1 ) }
-
-	},
-
-	displacementmap: {
-
-		"displacementMap": { type: "t", value: null },
-		"displacementScale": { type: "1f", value: 1 },
-		"displacementBias": { type: "1f", value: 0 }
-
-	},
-
-	roughnessmap: {
-
-		"roughnessMap": { type: "t", value: null }
-
-	},
-
-	metalnessmap: {
-
-		"metalnessMap": { type: "t", value: null }
-
-	},
-
-	fog: {
-
-		"fogDensity": { type: "1f", value: 0.00025 },
-		"fogNear": { type: "1f", value: 1 },
-		"fogFar": { type: "1f", value: 2000 },
-		"fogColor": { type: "c", value: new THREE.Color( 0xffffff ) }
-
-	},
-
-	lights: {
-
-		"ambientLightColor": { type: "3fv", value: [] },
-
-		"directionalLights": { type: "sa", value: [], properties: {
-			"direction": { type: "v3" },
-			"color": { type: "c" },
-
-			"shadow": { type: "1i" },
-			"shadowBias": { type: "1f" },
-			"shadowRadius": { type: "1f" },
-			"shadowMapSize": { type: "v2" }
-		} },
-
-		"directionalShadowMap": { type: "tv", value: [] },
-		"directionalShadowMatrix": { type: "m4v", value: [] },
-
-		"spotLights": { type: "sa", value: [], properties: {
-			"color": { type: "c" },
-			"position": { type: "v3" },
-			"direction": { type: "v3" },
-			"distance": { type: "1f" },
-			"coneCos": { type: "1f" },
-			"penumbraCos": { type: "1f" },
-			"decay": { type: "1f" },
-
-			"shadow": { type: "1i" },
-			"shadowBias": { type: "1f" },
-			"shadowRadius": { type: "1f" },
-			"shadowMapSize": { type: "v2" }
-		} },
-
-		"spotShadowMap": { type: "tv", value: [] },
-		"spotShadowMatrix": { type: "m4v", value: [] },
-
-		"pointLights": { type: "sa", value: [], properties: {
-			"color": { type: "c" },
-			"position": { type: "v3" },
-			"decay": { type: "1f" },
-			"distance": { type: "1f" },
-
-			"shadow": { type: "1i" },
-			"shadowBias": { type: "1f" },
-			"shadowRadius": { type: "1f" },
-			"shadowMapSize": { type: "v2" }
-		} },
-
-		"pointShadowMap": { type: "tv", value: [] },
-		"pointShadowMatrix": { type: "m4v", value: [] },
-
-		"hemisphereLights": { type: "sa", value: [], properties: {
-			"direction": { type: "v3" },
-			"skyColor": { type: "c" },
-			"groundColor": { type: "c" }
-		} }
-
-	},
-
-	points: {
-
-		"diffuse": { type: "c", value: new THREE.Color( 0xeeeeee ) },
-		"opacity": { type: "1f", value: 1.0 },
-		"size": { type: "1f", value: 1.0 },
-		"scale": { type: "1f", value: 1.0 },
-		"map": { type: "t", value: null },
-		"offsetRepeat": { type: "v4", value: new THREE.Vector4( 0, 0, 1, 1 ) }
-
-	}
-
-};
-
-// File:src/renderers/shaders/ShaderLib/cube_frag.glsl
-
-THREE.ShaderChunk[ 'cube_frag' ] = "uniform samplerCube tCube;\nuniform float tFlip;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	gl_FragColor = textureCube( tCube, vec3( tFlip * vWorldPosition.x, vWorldPosition.yz ) );\n	#include <logdepthbuf_fragment>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/cube_vert.glsl
-
-THREE.ShaderChunk[ 'cube_vert' ] = "varying vec3 vWorldPosition;\n#include <common>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	vWorldPosition = transformDirection( position, modelMatrix );\n	#include <begin_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/depth_frag.glsl
-
-THREE.ShaderChunk[ 'depth_frag' ] = "#if DEPTH_PACKING == 3200\n	uniform float opacity;\n#endif\n#include <common>\n#include <packing>\n#include <uv_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec4 diffuseColor = vec4( 1.0 );\n	#if DEPTH_PACKING == 3200\n		diffuseColor.a = opacity;\n	#endif\n	#include <map_fragment>\n	#include <alphamap_fragment>\n	#include <alphatest_fragment>\n	#include <logdepthbuf_fragment>\n	#if DEPTH_PACKING == 3200\n		gl_FragColor = vec4( vec3( gl_FragCoord.z ), opacity );\n	#elif DEPTH_PACKING == 3201\n		gl_FragColor = packDepthToRGBA( gl_FragCoord.z );\n	#endif\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/depth_vert.glsl
-
-THREE.ShaderChunk[ 'depth_vert' ] = "#include <common>\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <uv_vertex>\n	#include <skinbase_vertex>\n	#include <begin_vertex>\n	#include <displacementmap_vertex>\n	#include <morphtarget_vertex>\n	#include <skinning_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/distanceRGBA_frag.glsl
-
-THREE.ShaderChunk[ 'distanceRGBA_frag' ] = "uniform vec3 lightPos;\nvarying vec4 vWorldPosition;\n#include <common>\n#include <packing>\n#include <clipping_planes_pars_fragment>\nvoid main () {\n	#include <clipping_planes_fragment>\n	gl_FragColor = packDepthToRGBA( length( vWorldPosition.xyz - lightPos.xyz ) / 1000.0 );\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/distanceRGBA_vert.glsl
-
-THREE.ShaderChunk[ 'distanceRGBA_vert' ] = "varying vec4 vWorldPosition;\n#include <common>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <skinbase_vertex>\n	#include <begin_vertex>\n	#include <morphtarget_vertex>\n	#include <skinning_vertex>\n	#include <project_vertex>\n	#include <worldpos_vertex>\n	#include <clipping_planes_vertex>\n	vWorldPosition = worldPosition;\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/equirect_frag.glsl
-
-THREE.ShaderChunk[ 'equirect_frag' ] = "uniform sampler2D tEquirect;\nuniform float tFlip;\nvarying vec3 vWorldPosition;\n#include <common>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec3 direction = normalize( vWorldPosition );\n	vec2 sampleUV;\n	sampleUV.y = saturate( tFlip * direction.y * -0.5 + 0.5 );\n	sampleUV.x = atan( direction.z, direction.x ) * RECIPROCAL_PI2 + 0.5;\n	gl_FragColor = texture2D( tEquirect, sampleUV );\n	#include <logdepthbuf_fragment>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/equirect_vert.glsl
-
-THREE.ShaderChunk[ 'equirect_vert' ] = "varying vec3 vWorldPosition;\n#include <common>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	vWorldPosition = transformDirection( position, modelMatrix );\n	#include <begin_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/linedashed_frag.glsl
-
-THREE.ShaderChunk[ 'linedashed_frag' ] = "uniform vec3 diffuse;\nuniform float opacity;\nuniform float dashSize;\nuniform float totalSize;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_fragment>\n#include <fog_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	if ( mod( vLineDistance, totalSize ) > dashSize ) {\n		discard;\n	}\n	vec3 outgoingLight = vec3( 0.0 );\n	vec4 diffuseColor = vec4( diffuse, opacity );\n	#include <logdepthbuf_fragment>\n	#include <color_fragment>\n	outgoingLight = diffuseColor.rgb;\n	gl_FragColor = vec4( outgoingLight, diffuseColor.a );\n	#include <premultiplied_alpha_fragment>\n	#include <tonemapping_fragment>\n	#include <encodings_fragment>\n	#include <fog_fragment>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/linedashed_vert.glsl
-
-THREE.ShaderChunk[ 'linedashed_vert' ] = "uniform float scale;\nattribute float lineDistance;\nvarying float vLineDistance;\n#include <common>\n#include <color_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <color_vertex>\n	vLineDistance = scale * lineDistance;\n	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );\n	gl_Position = projectionMatrix * mvPosition;\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/meshbasic_frag.glsl
-
-THREE.ShaderChunk[ 'meshbasic_frag' ] = "uniform vec3 diffuse;\nuniform float opacity;\n#ifndef FLAT_SHADED\n	varying vec3 vNormal;\n#endif\n#include <common>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec4 diffuseColor = vec4( diffuse, opacity );\n	#include <logdepthbuf_fragment>\n	#include <map_fragment>\n	#include <color_fragment>\n	#include <alphamap_fragment>\n	#include <alphatest_fragment>\n	#include <specularmap_fragment>\n	ReflectedLight reflectedLight;\n	reflectedLight.directDiffuse = vec3( 0.0 );\n	reflectedLight.directSpecular = vec3( 0.0 );\n	reflectedLight.indirectDiffuse = diffuseColor.rgb;\n	reflectedLight.indirectSpecular = vec3( 0.0 );\n	#include <aomap_fragment>\n	vec3 outgoingLight = reflectedLight.indirectDiffuse;\n	#include <envmap_fragment>\n	gl_FragColor = vec4( outgoingLight, diffuseColor.a );\n	#include <premultiplied_alpha_fragment>\n	#include <tonemapping_fragment>\n	#include <encodings_fragment>\n	#include <fog_fragment>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/meshbasic_vert.glsl
-
-THREE.ShaderChunk[ 'meshbasic_vert' ] = "#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <uv_vertex>\n	#include <uv2_vertex>\n	#include <color_vertex>\n	#include <skinbase_vertex>\n	#ifdef USE_ENVMAP\n	#include <beginnormal_vertex>\n	#include <morphnormal_vertex>\n	#include <skinnormal_vertex>\n	#include <defaultnormal_vertex>\n	#endif\n	#include <begin_vertex>\n	#include <morphtarget_vertex>\n	#include <skinning_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <worldpos_vertex>\n	#include <clipping_planes_vertex>\n	#include <envmap_vertex>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/meshlambert_frag.glsl
-
-THREE.ShaderChunk[ 'meshlambert_frag' ] = "uniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float opacity;\nvarying vec3 vLightFront;\n#ifdef DOUBLE_SIDED\n	varying vec3 vLightBack;\n#endif\n#include <common>\n#include <packing>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <bsdfs>\n#include <lights_pars>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <shadowmask_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec4 diffuseColor = vec4( diffuse, opacity );\n	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n	vec3 totalEmissiveRadiance = emissive;\n	#include <logdepthbuf_fragment>\n	#include <map_fragment>\n	#include <color_fragment>\n	#include <alphamap_fragment>\n	#include <alphatest_fragment>\n	#include <specularmap_fragment>\n	#include <emissivemap_fragment>\n	reflectedLight.indirectDiffuse = getAmbientLightIrradiance( ambientLightColor );\n	#include <lightmap_fragment>\n	reflectedLight.indirectDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb );\n	#ifdef DOUBLE_SIDED\n		reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;\n	#else\n		reflectedLight.directDiffuse = vLightFront;\n	#endif\n	reflectedLight.directDiffuse *= BRDF_Diffuse_Lambert( diffuseColor.rgb ) * getShadowMask();\n	#include <aomap_fragment>\n	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;\n	#include <envmap_fragment>\n	gl_FragColor = vec4( outgoingLight, diffuseColor.a );\n	#include <premultiplied_alpha_fragment>\n	#include <tonemapping_fragment>\n	#include <encodings_fragment>\n	#include <fog_fragment>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/meshlambert_vert.glsl
-
-THREE.ShaderChunk[ 'meshlambert_vert' ] = "#define LAMBERT\nvarying vec3 vLightFront;\n#ifdef DOUBLE_SIDED\n	varying vec3 vLightBack;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <bsdfs>\n#include <lights_pars>\n#include <color_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <uv_vertex>\n	#include <uv2_vertex>\n	#include <color_vertex>\n	#include <beginnormal_vertex>\n	#include <morphnormal_vertex>\n	#include <skinbase_vertex>\n	#include <skinnormal_vertex>\n	#include <defaultnormal_vertex>\n	#include <begin_vertex>\n	#include <morphtarget_vertex>\n	#include <skinning_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n	#include <worldpos_vertex>\n	#include <envmap_vertex>\n	#include <lights_lambert_vertex>\n	#include <shadowmap_vertex>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/meshphong_frag.glsl
-
-THREE.ShaderChunk[ 'meshphong_frag' ] = "#define PHONG\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform vec3 specular;\nuniform float shininess;\nuniform float opacity;\n#include <common>\n#include <packing>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <lights_pars>\n#include <lights_phong_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec4 diffuseColor = vec4( diffuse, opacity );\n	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n	vec3 totalEmissiveRadiance = emissive;\n	#include <logdepthbuf_fragment>\n	#include <map_fragment>\n	#include <color_fragment>\n	#include <alphamap_fragment>\n	#include <alphatest_fragment>\n	#include <specularmap_fragment>\n	#include <normal_fragment>\n	#include <emissivemap_fragment>\n	#include <lights_phong_fragment>\n	#include <lights_template>\n	#include <aomap_fragment>\n	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n	#include <envmap_fragment>\n	gl_FragColor = vec4( outgoingLight, diffuseColor.a );\n	#include <premultiplied_alpha_fragment>\n	#include <tonemapping_fragment>\n	#include <encodings_fragment>\n	#include <fog_fragment>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/meshphong_vert.glsl
-
-THREE.ShaderChunk[ 'meshphong_vert' ] = "#define PHONG\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n	varying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <uv_vertex>\n	#include <uv2_vertex>\n	#include <color_vertex>\n	#include <beginnormal_vertex>\n	#include <morphnormal_vertex>\n	#include <skinbase_vertex>\n	#include <skinnormal_vertex>\n	#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n	vNormal = normalize( transformedNormal );\n#endif\n	#include <begin_vertex>\n	#include <displacementmap_vertex>\n	#include <morphtarget_vertex>\n	#include <skinning_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n	vViewPosition = - mvPosition.xyz;\n	#include <worldpos_vertex>\n	#include <envmap_vertex>\n	#include <shadowmap_vertex>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/meshphysical_frag.glsl
-
-THREE.ShaderChunk[ 'meshphysical_frag' ] = "#define PHYSICAL\nuniform vec3 diffuse;\nuniform vec3 emissive;\nuniform float roughness;\nuniform float metalness;\nuniform float opacity;\nuniform float envMapIntensity;\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n	varying vec3 vNormal;\n#endif\n#include <common>\n#include <packing>\n#include <color_pars_fragment>\n#include <uv_pars_fragment>\n#include <uv2_pars_fragment>\n#include <map_pars_fragment>\n#include <alphamap_pars_fragment>\n#include <aomap_pars_fragment>\n#include <lightmap_pars_fragment>\n#include <emissivemap_pars_fragment>\n#include <envmap_pars_fragment>\n#include <fog_pars_fragment>\n#include <bsdfs>\n#include <cube_uv_reflection_fragment>\n#include <lights_pars>\n#include <lights_physical_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <bumpmap_pars_fragment>\n#include <normalmap_pars_fragment>\n#include <roughnessmap_pars_fragment>\n#include <metalnessmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec4 diffuseColor = vec4( diffuse, opacity );\n	ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );\n	vec3 totalEmissiveRadiance = emissive;\n	#include <logdepthbuf_fragment>\n	#include <map_fragment>\n	#include <color_fragment>\n	#include <alphamap_fragment>\n	#include <alphatest_fragment>\n	#include <specularmap_fragment>\n	#include <roughnessmap_fragment>\n	#include <metalnessmap_fragment>\n	#include <normal_fragment>\n	#include <emissivemap_fragment>\n	#include <lights_physical_fragment>\n	#include <lights_template>\n	#include <aomap_fragment>\n	vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + reflectedLight.directSpecular + reflectedLight.indirectSpecular + totalEmissiveRadiance;\n	gl_FragColor = vec4( outgoingLight, diffuseColor.a );\n	#include <premultiplied_alpha_fragment>\n	#include <tonemapping_fragment>\n	#include <encodings_fragment>\n	#include <fog_fragment>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/meshphysical_vert.glsl
-
-THREE.ShaderChunk[ 'meshphysical_vert' ] = "#define PHYSICAL\nvarying vec3 vViewPosition;\n#ifndef FLAT_SHADED\n	varying vec3 vNormal;\n#endif\n#include <common>\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <color_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <specularmap_pars_fragment>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <uv_vertex>\n	#include <uv2_vertex>\n	#include <color_vertex>\n	#include <beginnormal_vertex>\n	#include <morphnormal_vertex>\n	#include <skinbase_vertex>\n	#include <skinnormal_vertex>\n	#include <defaultnormal_vertex>\n#ifndef FLAT_SHADED\n	vNormal = normalize( transformedNormal );\n#endif\n	#include <begin_vertex>\n	#include <displacementmap_vertex>\n	#include <morphtarget_vertex>\n	#include <skinning_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n	vViewPosition = - mvPosition.xyz;\n	#include <worldpos_vertex>\n	#include <shadowmap_vertex>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/normal_frag.glsl
-
-THREE.ShaderChunk[ 'normal_frag' ] = "uniform float opacity;\nvarying vec3 vNormal;\n#include <common>\n#include <packing>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	gl_FragColor = vec4( packNormalToRGB( vNormal ), opacity );\n	#include <logdepthbuf_fragment>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/normal_vert.glsl
-
-THREE.ShaderChunk[ 'normal_vert' ] = "varying vec3 vNormal;\n#include <common>\n#include <morphtarget_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	vNormal = normalize( normalMatrix * normal );\n	#include <begin_vertex>\n	#include <morphtarget_vertex>\n	#include <project_vertex>\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/points_frag.glsl
-
-THREE.ShaderChunk[ 'points_frag' ] = "uniform vec3 diffuse;\nuniform float opacity;\n#include <common>\n#include <color_pars_fragment>\n#include <map_particle_pars_fragment>\n#include <fog_pars_fragment>\n#include <shadowmap_pars_fragment>\n#include <logdepthbuf_pars_fragment>\n#include <clipping_planes_pars_fragment>\nvoid main() {\n	#include <clipping_planes_fragment>\n	vec3 outgoingLight = vec3( 0.0 );\n	vec4 diffuseColor = vec4( diffuse, opacity );\n	#include <logdepthbuf_fragment>\n	#include <map_particle_fragment>\n	#include <color_fragment>\n	#include <alphatest_fragment>\n	outgoingLight = diffuseColor.rgb;\n	gl_FragColor = vec4( outgoingLight, diffuseColor.a );\n	#include <premultiplied_alpha_fragment>\n	#include <tonemapping_fragment>\n	#include <encodings_fragment>\n	#include <fog_fragment>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib/points_vert.glsl
-
-THREE.ShaderChunk[ 'points_vert' ] = "uniform float size;\nuniform float scale;\n#include <common>\n#include <color_pars_vertex>\n#include <shadowmap_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\nvoid main() {\n	#include <color_vertex>\n	#include <begin_vertex>\n	#include <project_vertex>\n	#ifdef USE_SIZEATTENUATION\n		gl_PointSize = size * ( scale / - mvPosition.z );\n	#else\n		gl_PointSize = size;\n	#endif\n	#include <logdepthbuf_vertex>\n	#include <clipping_planes_vertex>\n	#include <worldpos_vertex>\n	#include <shadowmap_vertex>\n}\n";
-
-// File:src/renderers/shaders/ShaderLib.js
-
-/**
- * Webgl Shader Library for three.js
- *
- * @author alteredq / http://alteredqualia.com/
- * @author mrdoob / http://mrdoob.com/
- * @author mikael emtinger / http://gomo.se/
- */
-
-
-THREE.ShaderLib = {
-
-	'basic': {
-
-		uniforms: THREE.UniformsUtils.merge( [
-
-			THREE.UniformsLib[ 'common' ],
-			THREE.UniformsLib[ 'aomap' ],
-			THREE.UniformsLib[ 'fog' ]
-
-		] ),
-
-		vertexShader: THREE.ShaderChunk[ 'meshbasic_vert' ],
-		fragmentShader: THREE.ShaderChunk[ 'meshbasic_frag' ]
-
-	},
-
-	'lambert': {
-
-		uniforms: THREE.UniformsUtils.merge( [
-
-			THREE.UniformsLib[ 'common' ],
-			THREE.UniformsLib[ 'aomap' ],
-			THREE.UniformsLib[ 'lightmap' ],
-			THREE.UniformsLib[ 'emissivemap' ],
-			THREE.UniformsLib[ 'fog' ],
-			THREE.UniformsLib[ 'lights' ],
-
-			{
-				"emissive" : { type: "c", value: new THREE.Color( 0x000000 ) }
-			}
-
-		] ),
-
-		vertexShader: THREE.ShaderChunk[ 'meshlambert_vert' ],
-		fragmentShader: THREE.ShaderChunk[ 'meshlambert_frag' ]
-
-	},
-
-	'phong': {
-
-		uniforms: THREE.UniformsUtils.merge( [
-
-			THREE.UniformsLib[ 'common' ],
-			THREE.UniformsLib[ 'aomap' ],
-			THREE.UniformsLib[ 'lightmap' ],
-			THREE.UniformsLib[ 'emissivemap' ],
-			THREE.UniformsLib[ 'bumpmap' ],
-			THREE.UniformsLib[ 'normalmap' ],
-			THREE.UniformsLib[ 'displacementmap' ],
-			THREE.UniformsLib[ 'fog' ],
-			THREE.UniformsLib[ 'lights' ],
-
-			{
-				"emissive" : { type: "c", value: new THREE.Color( 0x000000 ) },
-				"specular" : { type: "c", value: new THREE.Color( 0x111111 ) },
-				"shininess": { type: "1f", value: 30 }
-			}
-
-		] ),
-
-		vertexShader: THREE.ShaderChunk[ 'meshphong_vert' ],
-		fragmentShader: THREE.ShaderChunk[ 'meshphong_frag' ]
-
-	},
-
-	'standard': {
-
-		uniforms: THREE.UniformsUtils.merge( [
-
-			THREE.UniformsLib[ 'common' ],
-			THREE.UniformsLib[ 'aomap' ],
-			THREE.UniformsLib[ 'lightmap' ],
-			THREE.UniformsLib[ 'emissivemap' ],
-			THREE.UniformsLib[ 'bumpmap' ],
-			THREE.UniformsLib[ 'normalmap' ],
-			THREE.UniformsLib[ 'displacementmap' ],
-			THREE.UniformsLib[ 'roughnessmap' ],
-			THREE.UniformsLib[ 'metalnessmap' ],
-			THREE.UniformsLib[ 'fog' ],
-			THREE.UniformsLib[ 'lights' ],
-
-			{
-				"emissive" : { type: "c", value: new THREE.Color( 0x000000 ) },
-				"roughness": { type: "1f", value: 0.5 },
-				"metalness": { type: "1f", value: 0 },
-				"envMapIntensity" : { type: "1f", value: 1 } // temporary
-			}
-
-		] ),
-
-		vertexShader: THREE.ShaderChunk[ 'meshphysical_vert' ],
-		fragmentShader: THREE.ShaderChunk[ 'meshphysical_frag' ]
-
-	},
-
-	'points': {
-
-		uniforms: THREE.UniformsUtils.merge( [
-
-			THREE.UniformsLib[ 'points' ],
-			THREE.UniformsLib[ 'fog' ]
-
-		] ),
-
-		vertexShader: THREE.ShaderChunk[ 'points_vert' ],
-		fragmentShader: THREE.ShaderChunk[ 'points_frag' ]
-
-	},
-
-	'dashed': {
-
-		uniforms: THREE.UniformsUtils.merge( [
-
-			THREE.UniformsLib[ 'common' ],
-			THREE.UniformsLib[ 'fog' ],
-
-			{
-				"scale"    : { type: "1f", value: 1 },
-				"dashSize" : { type: "1f", value: 1 },
-				"totalSize": { type: "1f", value: 2 }
-			}
-
-		] ),
-
-		vertexShader: THREE.ShaderChunk[ 'linedashed_vert' ],
-		fragmentShader: THREE.ShaderChunk[ 'linedashed_frag' ]
-
-	},
-
-	'depth': {
-
-		uniforms: THREE.UniformsUtils.merge( [
-
-			THREE.UniformsLib[ 'common' ],
-			THREE.UniformsLib[ 'displacementmap' ]
-
-		] ),
-
-		vertexShader: THREE.ShaderChunk[ 'depth_vert' ],
-		fragmentShader: THREE.ShaderChunk[ 'depth_frag' ]
-
-	},
-
-	'normal': {
-
-		uniforms: {
-
-			"opacity" : { type: "1f", value: 1.0 }
-
-		},
-
-		vertexShader: THREE.ShaderChunk[ 'normal_vert' ],
-		fragmentShader: THREE.ShaderChunk[ 'normal_frag' ]
-
-	},
-
-	/* -------------------------------------------------------------------------
-	//	Cube map shader
-	 ------------------------------------------------------------------------- */
-
-	'cube': {
-
-		uniforms: {
-			"tCube": { type: "t", value: null },
-			"tFlip": { type: "1f", value: - 1 }
-		},
-
-		vertexShader: THREE.ShaderChunk[ 'cube_vert' ],
-		fragmentShader: THREE.ShaderChunk[ 'cube_frag' ]
-
-	},
-
-	/* -------------------------------------------------------------------------
-	//	Cube map shader
-	 ------------------------------------------------------------------------- */
-
-	'equirect': {
-
-		uniforms: {
-			"tEquirect": { type: "t", value: null },
-			"tFlip": { type: "1f", value: - 1 }
-		},
-
-		vertexShader: THREE.ShaderChunk[ 'equirect_vert' ],
-		fragmentShader: THREE.ShaderChunk[ 'equirect_frag' ]
-
-	},
-
-	'distanceRGBA': {
-
-		uniforms: {
-
-			"lightPos": { type: "v3", value: new THREE.Vector3() }
-
-		},
-
-		vertexShader: THREE.ShaderChunk[ 'distanceRGBA_vert' ],
-		fragmentShader: THREE.ShaderChunk[ 'distanceRGBA_frag' ]
-
-	}
-
-};
-
-THREE.ShaderLib[ 'physical' ] = {
-
-	uniforms: THREE.UniformsUtils.merge( [
-
-		THREE.ShaderLib[ 'standard' ].uniforms,
-
-		{
-			// future
-		}
-
-	] ),
-
-	vertexShader: THREE.ShaderChunk[ 'meshphysical_vert' ],
-	fragmentShader: THREE.ShaderChunk[ 'meshphysical_frag' ]
-
-};
-
-
-// File:src/renderers/WebGLRenderer.js
-
-/**
- * @author supereggbert / http://www.paulbrunt.co.uk/
- * @author mrdoob / http://mrdoob.com/
- * @author alteredq / http://alteredqualia.com/
- * @author szimek / https://github.com/szimek/
- * @author tschw
- */
-
-THREE.WebGLRenderer = function ( parameters ) {
-
-	console.log( 'THREE.WebGLRenderer', THREE.REVISION );
-
-	parameters = parameters || {};
-
-	var _canvas = parameters.canvas !== undefined ? parameters.canvas : document.createElement( 'canvas' ),
-	_context = parameters.context !== undefined ? parameters.context : null,
-
-	_alpha = parameters.alpha !== undefined ? parameters.alpha : false,
-	_depth = parameters.depth !== undefined ? parameters.depth : true,
-	_stencil = parameters.stencil !== undefined ? parameters.stencil : true,
-	_antialias = parameters.antialias !== undefined ? parameters.antialias : false,
-	_premultipliedAlpha = parameters.premultipliedAlpha !== undefined ? parameters.premultipliedAlpha : true,
-	_preserveDrawingBuffer = parameters.preserveDrawingBuffer !== undefined ? parameters.preserveDrawingBuffer : false;
-
-	var lights = [];
-
-	var opaqueObjects = [];
-	var opaqueObjectsLastIndex = - 1;
-	var transparentObjects = [];
-	var transparentObjectsLastIndex = - 1;
-
-	var morphInfluences = new Float32Array( 8 );
-
-	var sprites = [];
-	var lensFlares = [];
-
-	// public properties
-
-	this.domElement = _canvas;
-	this.context = null;
-
-	// clearing
-
-	this.autoClear = true;
-	this.autoClearColor = true;
-	this.autoClearDepth = true;
-	this.autoClearStencil = true;
-
-	// scene graph
-
-	this.sortObjects = true;
-
-	// user-defined clipping
-
-	this.clippingPlanes = [];
-	this.localClippingEnabled = false;
-
-	// physically based shading
-
-	this.gammaFactor = 2.0;	// for backwards compatibility
-	this.gammaInput = false;
-	this.gammaOutput = false;
-
-	// physical lights
-
-	this.physicallyCorrectLights = false;
-
-	// tone mapping
-
-	this.toneMapping = THREE.LinearToneMapping;
-	this.toneMappingExposure = 1.0;
-	this.toneMappingWhitePoint = 1.0;
-
-	// morphs
-
-	this.maxMorphTargets = 8;
-	this.maxMorphNormals = 4;
-
-	// flags
-
-	this.autoScaleCubemaps = true;
-
-	// internal properties
-
-	var _this = this,
-
-	// internal state cache
-
-	_currentProgram = null,
-	_currentRenderTarget = null,
-	_currentFramebuffer = null,
-	_currentMaterialId = - 1,
-	_currentGeometryProgram = '',
-	_currentCamera = null,
-
-	_currentScissor = new THREE.Vector4(),
-	_currentScissorTest = null,
-
-	_currentViewport = new THREE.Vector4(),
-
-	//
-
-	_usedTextureUnits = 0,
-
-	//
-
-	_clearColor = new THREE.Color( 0x000000 ),
-	_clearAlpha = 0,
-
-	_width = _canvas.width,
-	_height = _canvas.height,
-
-	_pixelRatio = 1,
-
-	_scissor = new THREE.Vector4( 0, 0, _width, _height ),
-	_scissorTest = false,
-
-	_viewport = new THREE.Vector4( 0, 0, _width, _height ),
-
-	// frustum
-
-	_frustum = new THREE.Frustum(),
-
-	// clipping
-
-	_clippingEnabled = false,
-	_localClippingEnabled = false,
-	_clipRenderingShadows = false,
-
-	_numClippingPlanes = 0,
-	_clippingPlanesUniform = {
-			type: '4fv', value: null, needsUpdate: false },
-
-	_globalClippingState = null,
-	_numGlobalClippingPlanes = 0,
-
-	_matrix3 = new THREE.Matrix3(),
-	_sphere = new THREE.Sphere(),
-	_plane = new THREE.Plane(),
-
-
-	// camera matrices cache
-
-	_projScreenMatrix = new THREE.Matrix4(),
-
-	_vector3 = new THREE.Vector3(),
-
-	// light arrays cache
-
-	_lights = {
-
-		hash: '',
-
-		ambient: [ 0, 0, 0 ],
-		directional: [],
-		directionalShadowMap: [],
-		directionalShadowMatrix: [],
-		spot: [],
-		spotShadowMap: [],
-		spotShadowMatrix: [],
-		point: [],
-		pointShadowMap: [],
-		pointShadowMatrix: [],
-		hemi: [],
-
-		shadows: []
-
-	},
-
-	// info
-
-	_infoMemory = {
-
-		geometries: 0,
-		textures: 0
-
-	},
-
-	_infoRender = {
-
-		calls: 0,
-		vertices: 0,
-		faces: 0,
-		points: 0
-
-	};
-
-	this.info = {
-
-		render: _infoRender,
-		memory: _infoMemory,
-		programs: null
-
-	};
-
-
-	// initialize
-
-	var _gl;
-
-	try {
-
-		var attributes = {
-			alpha: _alpha,
-			depth: _depth,
-			stencil: _stencil,
-			antialias: _antialias,
-			premultipliedAlpha: _premultipliedAlpha,
-			preserveDrawingBuffer: _preserveDrawingBuffer
-		};
-
-		_gl = _context || _canvas.getContext( 'webgl', attributes ) || _canvas.getContext( 'experimental-webgl', attributes );
-
-		if ( _gl === null ) {
-
-			if ( _canvas.getContext( 'webgl' ) !== null ) {
-
-				throw 'Error creating WebGL context with your selected attributes.';
-
-			} else {
-
-				throw 'Error creating WebGL context.';
-
-			}
-
-		}
-
-		// Some experimental-webgl implementations do not have getShaderPrecisionFormat
-
-		if ( _gl.getShaderPrecisionFormat === undefined ) {
-
-			_gl.getShaderPrecisionFormat = function () {
-
-				return { 'rangeMin': 1, 'rangeMax': 1, 'precision': 1 };
-
-			};
-
-		}
-
-		_canvas.addEventListener( 'webglcontextlost', onContextLost, false );
-
-	} catch ( error ) {
-
-		console.error( 'THREE.WebGLRenderer: ' + error );
-
-	}
-
-	var _isWebGL2 = (typeof WebGL2RenderingContext !== 'undefined' && _gl instanceof WebGL2RenderingContext);
-	var extensions = new THREE.WebGLExtensions( _gl );
-
-	extensions.get( 'WEBGL_depth_texture' );
-	extensions.get( 'OES_texture_float' );
-	extensions.get( 'OES_texture_float_linear' );
-	extensions.get( 'OES_texture_half_float' );
-	extensions.get( 'OES_texture_half_float_linear' );
-	extensions.get( 'OES_standard_derivatives' );
-	extensions.get( 'ANGLE_instanced_arrays' );
-
-	if ( extensions.get( 'OES_element_index_uint' ) ) {
-
-		THREE.BufferGeometry.MaxIndex = 4294967296;
-
-	}
-
-	var capabilities = new THREE.WebGLCapabilities( _gl, extensions, parameters );
-
-	var state = new THREE.WebGLState( _gl, extensions, paramThreeToGL );
-	var properties = new THREE.WebGLProperties();
-	var objects = new THREE.WebGLObjects( _gl, properties, this.info );
-	var programCache = new THREE.WebGLPrograms( this, capabilities );
-	var lightCache = new THREE.WebGLLights();
-
-	this.info.programs = programCache.programs;
-
-	var bufferRenderer = new THREE.WebGLBufferRenderer( _gl, extensions, _infoRender );
-	var indexedBufferRenderer = new THREE.WebGLIndexedBufferRenderer( _gl, extensions, _infoRender );
-
-	//
-
-	function getTargetPixelRatio() {
-
-		return _currentRenderTarget === null ? _pixelRatio : 1;
-
-	}
-
-	function glClearColor( r, g, b, a ) {
-
-		if ( _premultipliedAlpha === true ) {
-
-			r *= a; g *= a; b *= a;
-
-		}
-
-		state.clearColor( r, g, b, a );
-
-	}
-
-	function setDefaultGLState() {
-
-		state.init();
-
-		state.scissor( _currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio ) );
-		state.viewport( _currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio ) );
-
-		glClearColor( _clearColor.r, _clearColor.g, _clearColor.b, _clearAlpha );
-
-	}
-
-	function resetGLState() {
-
-		_currentProgram = null;
-		_currentCamera = null;
-
-		_currentGeometryProgram = '';
-		_currentMaterialId = - 1;
-
-		state.reset();
-
-	}
-
-	setDefaultGLState();
-
-	this.context = _gl;
-	this.capabilities = capabilities;
-	this.extensions = extensions;
-	this.properties = properties;
-	this.state = state;
-
-	// shadow map
-
-	var shadowMap = new THREE.WebGLShadowMap( this, _lights, objects );
-
-	this.shadowMap = shadowMap;
-
-
-	// Plugins
-
-	var spritePlugin = new THREE.SpritePlugin( this, sprites );
-	var lensFlarePlugin = new THREE.LensFlarePlugin( this, lensFlares );
-
-	// API
-
-	this.getContext = function () {
-
-		return _gl;
-
-	};
-
-	this.getContextAttributes = function () {
-
-		return _gl.getContextAttributes();
-
-	};
-
-	this.forceContextLoss = function () {
-
-		extensions.get( 'WEBGL_lose_context' ).loseContext();
-
-	};
-
-	this.getMaxAnisotropy = ( function () {
-
-		var value;
-
-		return function getMaxAnisotropy() {
-
-			if ( value !== undefined ) return value;
-
-			var extension = extensions.get( 'EXT_texture_filter_anisotropic' );
-
-			if ( extension !== null ) {
-
-				value = _gl.getParameter( extension.MAX_TEXTURE_MAX_ANISOTROPY_EXT );
-
-			} else {
-
-				value = 0;
-
-			}
-
-			return value;
-
-		};
-
-	} )();
-
-	this.getPrecision = function () {
-
-		return capabilities.precision;
-
-	};
-
-	this.getPixelRatio = function () {
-
-		return _pixelRatio;
-
-	};
-
-	this.setPixelRatio = function ( value ) {
-
-		if ( value === undefined ) return;
-
-		_pixelRatio = value;
-
-		this.setSize( _viewport.z, _viewport.w, false );
-
-	};
-
-	this.getSize = function () {
-
-		return {
-			width: _width,
-			height: _height
-		};
-
-	};
-
-	this.setSize = function ( width, height, updateStyle ) {
-
-		_width = width;
-		_height = height;
-
-		_canvas.width = width * _pixelRatio;
-		_canvas.height = height * _pixelRatio;
-
-		if ( updateStyle !== false ) {
-
-			_canvas.style.width = width + 'px';
-			_canvas.style.height = height + 'px';
-
-		}
-
-		this.setViewport( 0, 0, width, height );
-
-	};
-
-	this.setViewport = function ( x, y, width, height ) {
-
-		state.viewport( _viewport.set( x, y, width, height ) );
-
-	};
-
-	this.setScissor = function ( x, y, width, height ) {
-
-		state.scissor( _scissor.set( x, y, width, height ) );
-
-	};
-
-	this.setScissorTest = function ( boolean ) {
-
-		state.setScissorTest( _scissorTest = boolean );
-
-	};
-
-	// Clearing
-
-	this.getClearColor = function () {
-
-		return _clearColor;
-
-	};
-
-	this.setClearColor = function ( color, alpha ) {
-
-		_clearColor.set( color );
-
-		_clearAlpha = alpha !== undefined ? alpha : 1;
-
-		glClearColor( _clearColor.r, _clearColor.g, _clearColor.b, _clearAlpha );
-
-	};
-
-	this.getClearAlpha = function () {
-
-		return _clearAlpha;
-
-	};
-
-	this.setClearAlpha = function ( alpha ) {
-
-		_clearAlpha = alpha;
-
-		glClearColor( _clearColor.r, _clearColor.g, _clearColor.b, _clearAlpha );
-
-	};
-
-	this.clear = function ( color, depth, stencil ) {
-
-		var bits = 0;
-
-		if ( color === undefined || color ) bits |= _gl.COLOR_BUFFER_BIT;
-		if ( depth === undefined || depth ) bits |= _gl.DEPTH_BUFFER_BIT;
-		if ( stencil === undefined || stencil ) bits |= _gl.STENCIL_BUFFER_BIT;
-
-		_gl.clear( bits );
-
-	};
-
-	this.clearColor = function () {
-
-		this.clear( true, false, false );
-
-	};
-
-	this.clearDepth = function () {
-
-		this.clear( false, true, false );
-
-	};
-
-	this.clearStencil = function () {
-
-		this.clear( false, false, true );
-
-	};
-
-	this.clearTarget = function ( renderTarget, color, depth, stencil ) {
-
-		this.setRenderTarget( renderTarget );
-		this.clear( color, depth, stencil );
-
-	};
-
-	// Reset
-
-	this.resetGLState = resetGLState;
-
-	this.dispose = function() {
-
-		_canvas.removeEventListener( 'webglcontextlost', onContextLost, false );
-
-	};
-
-	// Events
-
-	function onContextLost( event ) {
-
-		event.preventDefault();
-
-		resetGLState();
-		setDefaultGLState();
-
-		properties.clear();
-
-	}
-
-	function onTextureDispose( event ) {
-
-		var texture = event.target;
-
-		texture.removeEventListener( 'dispose', onTextureDispose );
-
-		deallocateTexture( texture );
-
-		_infoMemory.textures --;
-
-
-	}
-
-	function onRenderTargetDispose( event ) {
-
-		var renderTarget = event.target;
-
-		renderTarget.removeEventListener( 'dispose', onRenderTargetDispose );
-
-		deallocateRenderTarget( renderTarget );
-
-		_infoMemory.textures --;
-
-	}
-
-	function onMaterialDispose( event ) {
-
-		var material = event.target;
-
-		material.removeEventListener( 'dispose', onMaterialDispose );
-
-		deallocateMaterial( material );
-
-	}
-
-	// Buffer deallocation
-
-	function deallocateTexture( texture ) {
-
-		var textureProperties = properties.get( texture );
-
-		if ( texture.image && textureProperties.__image__webglTextureCube ) {
-
-			// cube texture
-
-			_gl.deleteTexture( textureProperties.__image__webglTextureCube );
-
-		} else {
-
-			// 2D texture
-
-			if ( textureProperties.__webglInit === undefined ) return;
-
-			_gl.deleteTexture( textureProperties.__webglTexture );
-
-		}
-
-		// remove all webgl properties
-		properties.delete( texture );
-
-	}
-
-	function deallocateRenderTarget( renderTarget ) {
-
-		var renderTargetProperties = properties.get( renderTarget );
-		var textureProperties = properties.get( renderTarget.texture );
-
-		if ( ! renderTarget ) return;
-
-		if ( textureProperties.__webglTexture !== undefined ) {
-
-			_gl.deleteTexture( textureProperties.__webglTexture );
-
-		}
-
-		if ( renderTarget.depthTexture ) {
-
-			renderTarget.depthTexture.dispose();
-
-		}
-
-		if ( renderTarget instanceof THREE.WebGLRenderTargetCube ) {
-
-			for ( var i = 0; i < 6; i ++ ) {
-
-				_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer[ i ] );
-				if ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer[ i ] );
-
-			}
-
-		} else {
-
-			_gl.deleteFramebuffer( renderTargetProperties.__webglFramebuffer );
-			if ( renderTargetProperties.__webglDepthbuffer ) _gl.deleteRenderbuffer( renderTargetProperties.__webglDepthbuffer );
-
-		}
-
-		properties.delete( renderTarget.texture );
-		properties.delete( renderTarget );
-
-	}
-
-	function deallocateMaterial( material ) {
-
-		releaseMaterialProgramReference( material );
-
-		properties.delete( material );
-
-	}
-
-
-	function releaseMaterialProgramReference( material ) {
-
-		var programInfo = properties.get( material ).program;
-
-		material.program = undefined;
-
-		if ( programInfo !== undefined ) {
-
-			programCache.releaseProgram( programInfo );
-
-		}
-
-	}
-
-	// Buffer rendering
-
-	this.renderBufferImmediate = function ( object, program, material ) {
-
-		state.initAttributes();
-
-		var buffers = properties.get( object );
-
-		if ( object.hasPositions && ! buffers.position ) buffers.position = _gl.createBuffer();
-		if ( object.hasNormals && ! buffers.normal ) buffers.normal = _gl.createBuffer();
-		if ( object.hasUvs && ! buffers.uv ) buffers.uv = _gl.createBuffer();
-		if ( object.hasColors && ! buffers.color ) buffers.color = _gl.createBuffer();
-
-		var attributes = program.getAttributes();
-
-		if ( object.hasPositions ) {
-
-			_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.position );
-			_gl.bufferData( _gl.ARRAY_BUFFER, object.positionArray, _gl.DYNAMIC_DRAW );
-
-			state.enableAttribute( attributes.position );
-			_gl.vertexAttribPointer( attributes.position, 3, _gl.FLOAT, false, 0, 0 );
-
-		}
-
-		if ( object.hasNormals ) {
-
-			_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.normal );
-
-			if ( material.type !== 'MeshPhongMaterial' && material.type !== 'MeshStandardMaterial' && material.type !== 'MeshPhysicalMaterial' && material.shading === THREE.FlatShading ) {
-
-				for ( var i = 0, l = object.count * 3; i < l; i += 9 ) {
-
-					var array = object.normalArray;
-
-					var nx = ( array[ i + 0 ] + array[ i + 3 ] + array[ i + 6 ] ) / 3;
-					var ny = ( array[ i + 1 ] + array[ i + 4 ] + array[ i + 7 ] ) / 3;
-					var nz = ( array[ i + 2 ] + array[ i + 5 ] + array[ i + 8 ] ) / 3;
-
-					array[ i + 0 ] = nx;
-					array[ i + 1 ] = ny;
-					array[ i + 2 ] = nz;
-
-					array[ i + 3 ] = nx;
-					array[ i + 4 ] = ny;
-					array[ i + 5 ] = nz;
-
-					array[ i + 6 ] = nx;
-					array[ i + 7 ] = ny;
-					array[ i + 8 ] = nz;
-
-				}
-
-			}
-
-			_gl.bufferData( _gl.ARRAY_BUFFER, object.normalArray, _gl.DYNAMIC_DRAW );
-
-			state.enableAttribute( attributes.normal );
-
-			_gl.vertexAttribPointer( attributes.normal, 3, _gl.FLOAT, false, 0, 0 );
-
-		}
-
-		if ( object.hasUvs && material.map ) {
-
-			_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.uv );
-			_gl.bufferData( _gl.ARRAY_BUFFER, object.uvArray, _gl.DYNAMIC_DRAW );
-
-			state.enableAttribute( attributes.uv );
-
-			_gl.vertexAttribPointer( attributes.uv, 2, _gl.FLOAT, false, 0, 0 );
-
-		}
-
-		if ( object.hasColors && material.vertexColors !== THREE.NoColors ) {
-
-			_gl.bindBuffer( _gl.ARRAY_BUFFER, buffers.color );
-			_gl.bufferData( _gl.ARRAY_BUFFER, object.colorArray, _gl.DYNAMIC_DRAW );
-
-			state.enableAttribute( attributes.color );
-
-			_gl.vertexAttribPointer( attributes.color, 3, _gl.FLOAT, false, 0, 0 );
-
-		}
-
-		state.disableUnusedAttributes();
-
-		_gl.drawArrays( _gl.TRIANGLES, 0, object.count );
-
-		object.count = 0;
-
-	};
-
-	this.renderBufferDirect = function ( camera, fog, geometry, material, object, group ) {
-
-		setMaterial( material );
-
-		var program = setProgram( camera, fog, material, object );
-
-		var updateBuffers = false;
-		var geometryProgram = geometry.id + '_' + program.id + '_' + material.wireframe;
-
-		if ( geometryProgram !== _currentGeometryProgram ) {
-
-			_currentGeometryProgram = geometryProgram;
-			updateBuffers = true;
-
-		}
-
-		// morph targets
-
-		var morphTargetInfluences = object.morphTargetInfluences;
-
-		if ( morphTargetInfluences !== undefined ) {
-
-			var activeInfluences = [];
-
-			for ( var i = 0, l = morphTargetInfluences.length; i < l; i ++ ) {
-
-				var influence = morphTargetInfluences[ i ];
-				activeInfluences.push( [ influence, i ] );
-
-			}
-
-			activeInfluences.sort( absNumericalSort );
-
-			if ( activeInfluences.length > 8 ) {
-
-				activeInfluences.length = 8;
-
-			}
-
-			var morphAttributes = geometry.morphAttributes;
-
-			for ( var i = 0, l = activeInfluences.length; i < l; i ++ ) {
-
-				var influence = activeInfluences[ i ];
-				morphInfluences[ i ] = influence[ 0 ];
-
-				if ( influence[ 0 ] !== 0 ) {
-
-					var index = influence[ 1 ];
-
-					if ( material.morphTargets === true && morphAttributes.position ) geometry.addAttribute( 'morphTarget' + i, morphAttributes.position[ index ] );
-					if ( material.morphNormals === true && morphAttributes.normal ) geometry.addAttribute( 'morphNormal' + i, morphAttributes.normal[ index ] );
-
-				} else {
-
-					if ( material.morphTargets === true ) geometry.removeAttribute( 'morphTarget' + i );
-					if ( material.morphNormals === true ) geometry.removeAttribute( 'morphNormal' + i );
-
-				}
-
-			}
-
-			program.getUniforms().setValue(
-					_gl, 'morphTargetInfluences', morphInfluences );
-
-			updateBuffers = true;
-
-		}
-
-		//
-
-		var index = geometry.index;
-		var position = geometry.attributes.position;
-
-		if ( material.wireframe === true ) {
-
-			index = objects.getWireframeAttribute( geometry );
-
-		}
-
-		var renderer;
-
-		if ( index !== null ) {
-
-			renderer = indexedBufferRenderer;
-			renderer.setIndex( index );
-
-		} else {
-
-			renderer = bufferRenderer;
-
-		}
-
-		if ( updateBuffers ) {
-
-			setupVertexAttributes( material, program, geometry );
-
-			if ( index !== null ) {
-
-				_gl.bindBuffer( _gl.ELEMENT_ARRAY_BUFFER, objects.getAttributeBuffer( index ) );
-
-			}
-
-		}
-
-		//
-
-		var dataStart = 0;
-		var dataCount = Infinity;
-
-		if ( index !== null ) {
-
-			dataCount = index.count;
-
-		} else if ( position !== undefined ) {
-
-			dataCount = position.count;
-
-		}
-
-		var rangeStart = geometry.drawRange.start;
-		var rangeCount = geometry.drawRange.count;
-
-		var groupStart = group !== null ? group.start : 0;
-		var groupCount = group !== null ? group.count : Infinity;
-
-		var drawStart = Math.max( dataStart, rangeStart, groupStart );
-		var drawEnd = Math.min( dataStart + dataCount, rangeStart + rangeCount, groupStart + groupCount ) - 1;
-
-		var drawCount = Math.max( 0, drawEnd - drawStart + 1 );
-
-		//
-
-		if ( object instanceof THREE.Mesh ) {
-
-			if ( material.wireframe === true ) {
-
-				state.setLineWidth( material.wireframeLinewidth * getTargetPixelRatio() );
-				renderer.setMode( _gl.LINES );
-
-			} else {
-
-				switch ( object.drawMode ) {
-
-					case THREE.TrianglesDrawMode:
-						renderer.setMode( _gl.TRIANGLES );
-						break;
-
-					case THREE.TriangleStripDrawMode:
-						renderer.setMode( _gl.TRIANGLE_STRIP );
-						break;
-
-					case THREE.TriangleFanDrawMode:
-						renderer.setMode( _gl.TRIANGLE_FAN );
-						break;
-
-				}
-
-			}
-
-
-		} else if ( object instanceof THREE.Line ) {
-
-			var lineWidth = material.linewidth;
-
-			if ( lineWidth === undefined ) lineWidth = 1; // Not using Line*Material
-
-			state.setLineWidth( lineWidth * getTargetPixelRatio() );
-
-			if ( object instanceof THREE.LineSegments ) {
-
-				renderer.setMode( _gl.LINES );
-
-			} else {
-
-				renderer.setMode( _gl.LINE_STRIP );
-
-			}
-
-		} else if ( object instanceof THREE.Points ) {
-
-			renderer.setMode( _gl.POINTS );
-
-		}
-
-		if ( geometry instanceof THREE.InstancedBufferGeometry ) {
-
-			if ( geometry.maxInstancedCount > 0 ) {
-
-				renderer.renderInstances( geometry, drawStart, drawCount );
-
-			}
-
-		} else {
-
-			renderer.render( drawStart, drawCount );
-
-		}
-
-	};
-
-	function setupVertexAttributes( material, program, geometry, startIndex ) {
-
-		var extension;
-
-		if ( geometry instanceof THREE.InstancedBufferGeometry ) {
-
-			extension = extensions.get( 'ANGLE_instanced_arrays' );
-
-			if ( extension === null ) {
-
-				console.error( 'THREE.WebGLRenderer.setupVertexAttributes: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );
-				return;
-
-			}
-
-		}
-
-		if ( startIndex === undefined ) startIndex = 0;
-
-		state.initAttributes();
-
-		var geometryAttributes = geometry.attributes;
-
-		var programAttributes = program.getAttributes();
-
-		var materialDefaultAttributeValues = material.defaultAttributeValues;
-
-		for ( var name in programAttributes ) {
-
-			var programAttribute = programAttributes[ name ];
-
-			if ( programAttribute >= 0 ) {
-
-				var geometryAttribute = geometryAttributes[ name ];
-
-				if ( geometryAttribute !== undefined ) {
-
-					var type = _gl.FLOAT;
-					var array = geometryAttribute.array;
-					var normalized = geometryAttribute.normalized;
-
-					if ( array instanceof Float32Array ) {
-
-						type = _gl.FLOAT;
-
-					} else if ( array instanceof Float64Array ) {
-
-						console.warn("Unsupported data buffer format: Float64Array");
-
-					} else if ( array instanceof Uint16Array ) {
-
-						type = _gl.UNSIGNED_SHORT;
-
-					} else if ( array instanceof Int16Array ) {
-
-						type = _gl.SHORT;
-
-					} else if ( array instanceof Uint32Array ) {
-
-						type = _gl.UNSIGNED_INT;
-
-					} else if ( array instanceof Int32Array ) {
-
-						type = _gl.INT;
-
-					} else if ( array instanceof Int8Array ) {
-
-						type = _gl.BYTE;
-
-					} else if ( array instanceof Uint8Array ) {
-
-						type = _gl.UNSIGNED_BYTE;
-
-					}
-
-					var size = geometryAttribute.itemSize;
-					var buffer = objects.getAttributeBuffer( geometryAttribute );
-
-					if ( geometryAttribute instanceof THREE.InterleavedBufferAttribute ) {
-
-						var data = geometryAttribute.data;
-						var stride = data.stride;
-						var offset = geometryAttribute.offset;
-
-						if ( data instanceof THREE.InstancedInterleavedBuffer ) {
-
-							state.enableAttributeAndDivisor( programAttribute, data.meshPerAttribute, extension );
-
-							if ( geometry.maxInstancedCount === undefined ) {
-
-								geometry.maxInstancedCount = data.meshPerAttribute * data.count;
-
-							}
-
-						} else {
-
-							state.enableAttribute( programAttribute );
-
-						}
-
-						_gl.bindBuffer( _gl.ARRAY_BUFFER, buffer );
-						_gl.vertexAttribPointer( programAttribute, size, type, normalized, stride * data.array.BYTES_PER_ELEMENT, ( startIndex * stride + offset ) * data.array.BYTES_PER_ELEMENT );
-
-					} else {
-
-						if ( geometryAttribute instanceof THREE.InstancedBufferAttribute ) {
-
-							state.enableAttributeAndDivisor( programAttribute, geometryAttribute.meshPerAttribute, extension );
-
-							if ( geometry.maxInstancedCount === undefined ) {
-
-								geometry.maxInstancedCount = geometryAttribute.meshPerAttribute * geometryAttribute.count;
-
-							}
-
-						} else {
-
-							state.enableAttribute( programAttribute );
-
-						}
-
-						_gl.bindBuffer( _gl.ARRAY_BUFFER, buffer );
-						_gl.vertexAttribPointer( programAttribute, size, type, normalized, 0, startIndex * size * geometryAttribute.array.BYTES_PER_ELEMENT );
-
-					}
-
-				} 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();
-
-	}
-
-	// Sorting
-
-	function absNumericalSort( a, b ) {
-
-		return Math.abs( b[ 0 ] ) - Math.abs( a[ 0 ] );
-
-	}
-
-	function painterSortStable ( a, b ) {
-
-		if ( a.object.renderOrder !== b.object.renderOrder ) {
-
-			return a.object.renderOrder - b.object.renderOrder;
-
-		} else if ( a.material.id !== b.material.id ) {
-
-			return a.material.id - b.material.id;
-
-		} else if ( a.z !== b.z ) {
-
-			return a.z - b.z;
-
-		} else {
-
-			return a.id - b.id;
-
-		}
-
-	}
-
-	function reversePainterSortStable ( a, b ) {
-
-		if ( a.object.renderOrder !== b.object.renderOrder ) {
-
-			return a.object.renderOrder - b.object.renderOrder;
-
-		} if ( a.z !== b.z ) {
-
-			return b.z - a.z;
-
-		} else {
-
-			return a.id - b.id;
-
-		}
-
-	}
-
-	// Rendering
-
-	this.render = function ( scene, camera, renderTarget, forceClear ) {
-
-		if ( camera instanceof THREE.Camera === false ) {
-
-			console.error( 'THREE.WebGLRenderer.render: camera is not an instance of THREE.Camera.' );
-			return;
-
-		}
-
-		var fog = scene.fog;
-
-		// reset caching for this frame
-
-		_currentGeometryProgram = '';
-		_currentMaterialId = - 1;
-		_currentCamera = null;
-
-		// update scene graph
-
-		if ( scene.autoUpdate === true ) scene.updateMatrixWorld();
-
-		// update camera matrices and frustum
-
-		if ( camera.parent === null ) camera.updateMatrixWorld();
-
-		camera.matrixWorldInverse.getInverse( camera.matrixWorld );
-
-		_projScreenMatrix.multiplyMatrices( camera.projectionMatrix, camera.matrixWorldInverse );
-		_frustum.setFromMatrix( _projScreenMatrix );
-
-		lights.length = 0;
-
-		opaqueObjectsLastIndex = - 1;
-		transparentObjectsLastIndex = - 1;
-
-		sprites.length = 0;
-		lensFlares.length = 0;
-
-		setupGlobalClippingPlanes( this.clippingPlanes, camera );
-
-		projectObject( scene, camera );
-
-
-		opaqueObjects.length = opaqueObjectsLastIndex + 1;
-		transparentObjects.length = transparentObjectsLastIndex + 1;
-
-		if ( _this.sortObjects === true ) {
-
-			opaqueObjects.sort( painterSortStable );
-			transparentObjects.sort( reversePainterSortStable );
-
-		}
-
-		//
-
-		if ( _clippingEnabled ) {
-
-			_clipRenderingShadows = true;
-			setupClippingPlanes( null );
-
-		}
-
-		setupShadows( lights );
-
-		shadowMap.render( scene, camera );
-
-		setupLights( lights, camera );
-
-		if ( _clippingEnabled ) {
-
-			_clipRenderingShadows = false;
-			resetGlobalClippingState();
-
-		}
-
-		//
-
-		_infoRender.calls = 0;
-		_infoRender.vertices = 0;
-		_infoRender.faces = 0;
-		_infoRender.points = 0;
-
-		if ( renderTarget === undefined ) {
-
-			renderTarget = null;
-
-		}
-
-		this.setRenderTarget( renderTarget );
-
-		if ( this.autoClear || forceClear ) {
-
-			this.clear( this.autoClearColor, this.autoClearDepth, this.autoClearStencil );
-
-		}
-
-		//
-
-		if ( scene.overrideMaterial ) {
-
-			var overrideMaterial = scene.overrideMaterial;
-
-			renderObjects( opaqueObjects, camera, fog, overrideMaterial );
-			renderObjects( transparentObjects, camera, fog, overrideMaterial );
-
-		} else {
-
-			// opaque pass (front-to-back order)
-
-			state.setBlending( THREE.NoBlending );
-			renderObjects( opaqueObjects, camera, fog );
-
-			// transparent pass (back-to-front order)
-
-			renderObjects( transparentObjects, camera, fog );
-
-		}
-
-		// custom render plugins (post pass)
-
-		spritePlugin.render( scene, camera );
-		lensFlarePlugin.render( scene, camera, _currentViewport );
-
-		// Generate mipmap if we're using any kind of mipmap filtering
-
-		if ( renderTarget ) {
-
-			var texture = renderTarget.texture;
-
-			if ( texture.generateMipmaps && isPowerOfTwo( renderTarget ) &&
-					texture.minFilter !== THREE.NearestFilter &&
-					texture.minFilter !== THREE.LinearFilter ) {
-
-				updateRenderTargetMipmap( renderTarget );
-
-			}
-
-		}
-
-		// Ensure depth buffer writing is enabled so it can be cleared on next render
-
-		state.setDepthTest( true );
-		state.setDepthWrite( true );
-		state.setColorWrite( true );
-
-		// _gl.finish();
-
-	};
-
-	function pushRenderItem( object, geometry, material, z, group ) {
-
-		var array, index;
-
-		// allocate the next position in the appropriate array
-
-		if ( material.transparent ) {
-
-			array = transparentObjects;
-			index = ++ transparentObjectsLastIndex;
-
-		} else {
-
-			array = opaqueObjects;
-			index = ++ opaqueObjectsLastIndex;
-
-		}
-
-		// recycle existing render item or grow the array
-
-		var renderItem = array[ index ];
-
-		if ( renderItem !== undefined ) {
-
-			renderItem.id = object.id;
-			renderItem.object = object;
-			renderItem.geometry = geometry;
-			renderItem.material = material;
-			renderItem.z = _vector3.z;
-			renderItem.group = group;
-
-		} else {
-
-			renderItem = {
-				id: object.id,
-				object: object,
-				geometry: geometry,
-				material: material,
-				z: _vector3.z,
-				group: group
-			};
-
-			// assert( index === array.length );
-			array.push( renderItem );
-
-		}
-
-	}
-
-	function isObjectViewable( object ) {
-
-		var geometry = object.geometry;
-
-		if ( geometry.boundingSphere === null )
-			geometry.computeBoundingSphere();
-
-		var sphere = _sphere.
-				copy( geometry.boundingSphere ).
-				applyMatrix4( object.matrixWorld );
-
-		if ( ! _frustum.intersectsSphere( sphere ) ) return false;
-		if ( _numClippingPlanes === 0 ) return true;
-
-		var planes = _this.clippingPlanes,
-
-			center = sphere.center,
-			negRad = - sphere.radius,
-			i = 0;
-
-		do {
-
-			// out when deeper than radius in the negative halfspace
-			if ( planes[ i ].distanceToPoint( center ) < negRad ) return false;
-
-		} while ( ++ i !== _numClippingPlanes );
-
-		return true;
-
-	}
-
-	function projectObject( object, camera ) {
-
-		if ( object.visible === false ) return;
-
-		if ( object.layers.test( camera.layers ) ) {
-
-			if ( object instanceof THREE.Light ) {
-
-				lights.push( object );
-
-			} else if ( object instanceof THREE.Sprite ) {
-
-				if ( object.frustumCulled === false || isObjectViewable( object ) === true ) {
-
-					sprites.push( object );
-
-				}
-
-			} else if ( object instanceof THREE.LensFlare ) {
-
-				lensFlares.push( object );
-
-			} else if ( object instanceof THREE.ImmediateRenderObject ) {
-
-				if ( _this.sortObjects === true ) {
-
-					_vector3.setFromMatrixPosition( object.matrixWorld );
-					_vector3.applyProjection( _projScreenMatrix );
-
-				}
-
-				pushRenderItem( object, null, object.material, _vector3.z, null );
-
-			} else if ( object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Points ) {
-
-				if ( object instanceof THREE.SkinnedMesh ) {
-
-					object.skeleton.update();
-
-				}
-
-				if ( object.frustumCulled === false || isObjectViewable( object ) === true ) {
-
-					var material = object.material;
-
-					if ( material.visible === true ) {
-
-						if ( _this.sortObjects === true ) {
-
-							_vector3.setFromMatrixPosition( object.matrixWorld );
-							_vector3.applyProjection( _projScreenMatrix );
-
-						}
-
-						var geometry = objects.update( object );
-
-						if ( material instanceof THREE.MultiMaterial ) {
-
-							var groups = geometry.groups;
-							var materials = material.materials;
-
-							for ( var i = 0, l = groups.length; i < l; i ++ ) {
-
-								var group = groups[ i ];
-								var groupMaterial = materials[ group.materialIndex ];
-
-								if ( groupMaterial.visible === true ) {
-
-									pushRenderItem( object, geometry, groupMaterial, _vector3.z, group );
-
-								}
-
-							}
-
-						} else {
-
-							pushRenderItem( object, geometry, material, _vector3.z, null );
-
-						}
-
-					}
-
-				}
-
-			}
-
-		}
-
-		var children = object.children;
-
-		for ( var i = 0, l = children.length; i < l; i ++ ) {
-
-			projectObject( children[ i ], camera );
-
-		}
-
-	}
-
-	function renderObjects( renderList, camera, fog, overrideMaterial ) {
-
-		for ( var i = 0, l = renderList.length; i < l; i ++ ) {
-
-			var renderItem = renderList[ i ];
-
-			var object = renderItem.object;
-			var geometry = renderItem.geometry;
-			var material = overrideMaterial === undefined ? renderItem.material : overrideMaterial;
-			var group = renderItem.group;
-
-			object.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, object.matrixWorld );
-			object.normalMatrix.getNormalMatrix( object.modelViewMatrix );
-
-			if ( object instanceof THREE.ImmediateRenderObject ) {
-
-				setMaterial( material );
-
-				var program = setProgram( camera, fog, material, object );
-
-				_currentGeometryProgram = '';
-
-				object.render( function ( object ) {
-
-					_this.renderBufferImmediate( object, program, material );
-
-				} );
-
-			} else {
-
-				_this.renderBufferDirect( camera, fog, geometry, material, object, group );
-
-			}
-
-		}
-
-	}
-
-	function initMaterial( material, fog, object ) {
-
-		var materialProperties = properties.get( material );
-
-		var parameters = programCache.getParameters(
-				material, _lights, fog, _numClippingPlanes, object );
-
-		var code = programCache.getProgramCode( material, parameters );
-
-		var program = materialProperties.program;
-		var programChange = true;
-
-		if ( program === undefined ) {
-
-			// new material
-			material.addEventListener( 'dispose', onMaterialDispose );
-
-		} else if ( program.code !== code ) {
-
-			// changed glsl or parameters
-			releaseMaterialProgramReference( material );
-
-		} else if ( parameters.shaderID !== undefined ) {
-
-			// same glsl and uniform list
-			return;
-
-		} else {
-
-			// only rebuild uniform list
-			programChange = false;
-
-		}
-
-		if ( programChange ) {
-
-			if ( parameters.shaderID ) {
-
-				var shader = THREE.ShaderLib[ parameters.shaderID ];
-
-				materialProperties.__webglShader = {
-					name: material.type,
-					uniforms: THREE.UniformsUtils.clone( shader.uniforms ),
-					vertexShader: shader.vertexShader,
-					fragmentShader: shader.fragmentShader
-				};
-
-			} else {
-
-				materialProperties.__webglShader = {
-					name: material.type,
-					uniforms: material.uniforms,
-					vertexShader: material.vertexShader,
-					fragmentShader: material.fragmentShader
-				};
-
-			}
-
-			material.__webglShader = materialProperties.__webglShader;
-
-			program = programCache.acquireProgram( material, parameters, code );
-
-			materialProperties.program = program;
-			material.program = program;
-
-		}
-
-		var attributes = program.getAttributes();
-
-		if ( material.morphTargets ) {
-
-			material.numSupportedMorphTargets = 0;
-
-			for ( var i = 0; i < _this.maxMorphTargets; i ++ ) {
-
-				if ( attributes[ 'morphTarget' + i ] >= 0 ) {
-
-					material.numSupportedMorphTargets ++;
-
-				}
-
-			}
-
-		}
-
-		if ( material.morphNormals ) {
-
-			material.numSupportedMorphNormals = 0;
-
-			for ( var i = 0; i < _this.maxMorphNormals; i ++ ) {
-
-				if ( attributes[ 'morphNormal' + i ] >= 0 ) {
-
-					material.numSupportedMorphNormals ++;
-
-				}
-
-			}
-
-		}
-
-		var uniforms = materialProperties.__webglShader.uniforms;
-
-		if ( ! ( material instanceof THREE.ShaderMaterial ) &&
-				! ( material instanceof THREE.RawShaderMaterial ) ||
-				material.clipping === true ) {
-
-			materialProperties.numClippingPlanes = _numClippingPlanes;
-			uniforms.clippingPlanes = _clippingPlanesUniform;
-
-		}
-
-		if ( material instanceof THREE.MeshPhongMaterial ||
-				material instanceof THREE.MeshLambertMaterial ||
-				material instanceof THREE.MeshStandardMaterial ||
-				material.lights ) {
-
-			// store the light setup it was created for
-
-			materialProperties.lightsHash = _lights.hash;
-
-			// wire up the material to this renderer's lighting state
-
-			uniforms.ambientLightColor.value = _lights.ambient;
-			uniforms.directionalLights.value = _lights.directional;
-			uniforms.spotLights.value = _lights.spot;
-			uniforms.pointLights.value = _lights.point;
-			uniforms.hemisphereLights.value = _lights.hemi;
-
-			uniforms.directionalShadowMap.value = _lights.directionalShadowMap;
-			uniforms.directionalShadowMatrix.value = _lights.directionalShadowMatrix;
-			uniforms.spotShadowMap.value = _lights.spotShadowMap;
-			uniforms.spotShadowMatrix.value = _lights.spotShadowMatrix;
-			uniforms.pointShadowMap.value = _lights.pointShadowMap;
-			uniforms.pointShadowMatrix.value = _lights.pointShadowMatrix;
-
-		}
-
-		var progUniforms = materialProperties.program.getUniforms(),
-			uniformsList =
-					THREE.WebGLUniforms.seqWithValue( progUniforms.seq, uniforms );
-
-		materialProperties.uniformsList = uniformsList;
-		materialProperties.dynamicUniforms =
-				THREE.WebGLUniforms.splitDynamic( uniformsList, uniforms );
-
-	}
-
-	function setMaterial( material ) {
-
-		setMaterialFaces( material );
-
-		if ( material.transparent === true ) {
-
-			state.setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst, material.blendEquationAlpha, material.blendSrcAlpha, material.blendDstAlpha, material.premultipliedAlpha );
-
-		} else {
-
-			state.setBlending( THREE.NoBlending );
-
-		}
-
-		state.setDepthFunc( material.depthFunc );
-		state.setDepthTest( material.depthTest );
-		state.setDepthWrite( material.depthWrite );
-		state.setColorWrite( material.colorWrite );
-		state.setPolygonOffset( material.polygonOffset, material.polygonOffsetFactor, material.polygonOffsetUnits );
-
-	}
-
-	function setMaterialFaces( material ) {
-
-		material.side !== THREE.DoubleSide ? state.enable( _gl.CULL_FACE ) : state.disable( _gl.CULL_FACE );
-		state.setFlipSided( material.side === THREE.BackSide );
-
-	}
-
-	function setProgram( camera, fog, material, object ) {
-
-		_usedTextureUnits = 0;
-
-		var materialProperties = properties.get( material );
-
-		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)
-				setClippingState(
-						material.clippingPlanes, material.clipShadows,
-						camera, materialProperties, useCache );
-
-			}
-
-			if ( materialProperties.numClippingPlanes !== undefined &&
-				materialProperties.numClippingPlanes !== _numClippingPlanes ) {
-
-				material.needsUpdate = true;
-
-			}
-
-		}
-
-		if ( materialProperties.program === undefined ) {
-
-			material.needsUpdate = true;
-
-		}
-
-		if ( materialProperties.lightsHash !== undefined &&
-			materialProperties.lightsHash !== _lights.hash ) {
-
-			material.needsUpdate = true;
-
-		}
-
-		if ( material.needsUpdate ) {
-
-			initMaterial( material, fog, object );
-			material.needsUpdate = false;
-
-		}
-
-		var refreshProgram = false;
-		var refreshMaterial = false;
-		var refreshLights = false;
-
-		var program = materialProperties.program,
-			p_uniforms = program.getUniforms(),
-			m_uniforms = materialProperties.__webglShader.uniforms;
-
-		if ( program.id !== _currentProgram ) {
-
-			_gl.useProgram( program.program );
-			_currentProgram = program.id;
-
-			refreshProgram = true;
-			refreshMaterial = true;
-			refreshLights = true;
-
-		}
-
-		if ( material.id !== _currentMaterialId ) {
-
-			_currentMaterialId = material.id;
-
-			refreshMaterial = true;
-
-		}
-
-		if ( refreshProgram || camera !== _currentCamera ) {
-
-			p_uniforms.set( _gl, camera, 'projectionMatrix' );
-
-			if ( capabilities.logarithmicDepthBuffer ) {
-
-				p_uniforms.setValue( _gl, 'logDepthBufFC',
-						2.0 / ( Math.log( camera.far + 1.0 ) / Math.LN2 ) );
-
-			}
-
-
-			if ( camera !== _currentCamera ) {
-
-				_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 instanceof THREE.ShaderMaterial ||
-				 material instanceof THREE.MeshPhongMaterial ||
-				 material instanceof THREE.MeshStandardMaterial ||
-				 material.envMap ) {
-
-				var uCamPos = p_uniforms.map.cameraPosition;
-
-				if ( uCamPos !== undefined ) {
-
-					uCamPos.setValue( _gl,
-							_vector3.setFromMatrixPosition( camera.matrixWorld ) );
-
-				}
-
-			}
-
-			if ( material instanceof THREE.MeshPhongMaterial ||
-				 material instanceof THREE.MeshLambertMaterial ||
-				 material instanceof THREE.MeshBasicMaterial ||
-				 material instanceof THREE.MeshStandardMaterial ||
-				 material instanceof THREE.ShaderMaterial ||
-				 material.skinning ) {
-
-				p_uniforms.setValue( _gl, 'viewMatrix', camera.matrixWorldInverse );
-
-			}
-
-			p_uniforms.set( _gl, _this, 'toneMappingExposure' );
-			p_uniforms.set( _gl, _this, 'toneMappingWhitePoint' );
-
-		}
-
-		// skinning uniforms must be set even if material didn't change
-		// auto-setting of texture unit for bone texture must go before other textures
-		// not sure why, but otherwise weird things happen
-
-		if ( material.skinning ) {
-
-			p_uniforms.setOptional( _gl, object, 'bindMatrix' );
-			p_uniforms.setOptional( _gl, object, 'bindMatrixInverse' );
-
-			var skeleton = object.skeleton;
-
-			if ( skeleton ) {
-
-				if ( capabilities.floatVertexTextures && skeleton.useVertexTexture ) {
-
-					p_uniforms.set( _gl, skeleton, 'boneTexture' );
-					p_uniforms.set( _gl, skeleton, 'boneTextureWidth' );
-					p_uniforms.set( _gl, skeleton, 'boneTextureHeight' );
-
-				} else {
-
-					p_uniforms.setOptional( _gl, skeleton, 'boneMatrices' );
-
-				}
-
-			}
-
-		}
-
-		if ( refreshMaterial ) {
-
-			if ( material instanceof THREE.MeshPhongMaterial ||
-				 material instanceof THREE.MeshLambertMaterial ||
-				 material instanceof THREE.MeshStandardMaterial ||
-				 material.lights ) {
-
-				// 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 instanceof THREE.MeshBasicMaterial ||
-				 material instanceof THREE.MeshLambertMaterial ||
-				 material instanceof THREE.MeshPhongMaterial ||
-				 material instanceof THREE.MeshStandardMaterial ||
-				 material instanceof THREE.MeshDepthMaterial ) {
-
-				refreshUniformsCommon( m_uniforms, material );
-
-			}
-
-			// refresh single material specific uniforms
-
-			if ( material instanceof THREE.LineBasicMaterial ) {
-
-				refreshUniformsLine( m_uniforms, material );
-
-			} else if ( material instanceof THREE.LineDashedMaterial ) {
-
-				refreshUniformsLine( m_uniforms, material );
-				refreshUniformsDash( m_uniforms, material );
-
-			} else if ( material instanceof THREE.PointsMaterial ) {
-
-				refreshUniformsPoints( m_uniforms, material );
-
-			} else if ( material instanceof THREE.MeshLambertMaterial ) {
-
-				refreshUniformsLambert( m_uniforms, material );
-
-			} else if ( material instanceof THREE.MeshPhongMaterial ) {
-
-				refreshUniformsPhong( m_uniforms, material );
-
-			} else if ( material instanceof THREE.MeshPhysicalMaterial ) {
-
-				refreshUniformsPhysical( m_uniforms, material );
-
-			} else if ( material instanceof THREE.MeshStandardMaterial ) {
-
-				refreshUniformsStandard( m_uniforms, material );
-
-			} else if ( material instanceof THREE.MeshDepthMaterial ) {
-
-				if ( material.displacementMap ) {
-
-					m_uniforms.displacementMap.value = material.displacementMap;
-					m_uniforms.displacementScale.value = material.displacementScale;
-					m_uniforms.displacementBias.value = material.displacementBias;
-
-				}
-
-			} else if ( material instanceof THREE.MeshNormalMaterial ) {
-
-				m_uniforms.opacity.value = material.opacity;
-
-			}
-
-			THREE.WebGLUniforms.upload(
-					_gl, materialProperties.uniformsList, m_uniforms, _this );
-
-		}
-
-
-		// common matrices
-
-		p_uniforms.set( _gl, object, 'modelViewMatrix' );
-		p_uniforms.set( _gl, object, 'normalMatrix' );
-		p_uniforms.setValue( _gl, 'modelMatrix', object.matrixWorld );
-
-
-		// dynamic uniforms
-
-		var dynUniforms = materialProperties.dynamicUniforms;
-
-		if ( dynUniforms !== null ) {
-
-			THREE.WebGLUniforms.evalDynamic(
-					dynUniforms, m_uniforms, object, camera );
-
-			THREE.WebGLUniforms.upload( _gl, dynUniforms, m_uniforms, _this );
-
-		}
-
-		return program;
-
-	}
-
-	// Uniforms (refresh uniforms objects)
-
-	function refreshUniformsCommon ( uniforms, material ) {
-
-		uniforms.opacity.value = material.opacity;
-
-		uniforms.diffuse.value = material.color;
-
-		if ( material.emissive ) {
-
-			uniforms.emissive.value.copy( material.emissive ).multiplyScalar( material.emissiveIntensity );
-
-		}
-
-		uniforms.map.value = material.map;
-		uniforms.specularMap.value = material.specularMap;
-		uniforms.alphaMap.value = material.alphaMap;
-
-		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 ) {
-
-			if ( uvScaleMap instanceof THREE.WebGLRenderTarget ) {
-
-				uvScaleMap = uvScaleMap.texture;
-
-			}
-
-			var offset = uvScaleMap.offset;
-			var repeat = uvScaleMap.repeat;
-
-			uniforms.offsetRepeat.value.set( offset.x, offset.y, repeat.x, repeat.y );
-
-		}
-
-		uniforms.envMap.value = material.envMap;
-		uniforms.flipEnvMap.value = ( material.envMap instanceof THREE.WebGLRenderTargetCube ) ? 1 : - 1;
-
-		uniforms.reflectivity.value = material.reflectivity;
-		uniforms.refractionRatio.value = material.refractionRatio;
-
-	}
-
-	function refreshUniformsLine ( uniforms, material ) {
-
-		uniforms.diffuse.value = 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 = material.color;
-		uniforms.opacity.value = material.opacity;
-		uniforms.size.value = material.size * _pixelRatio;
-		uniforms.scale.value = _canvas.clientHeight * 0.5;
-
-		uniforms.map.value = material.map;
-
-		if ( material.map !== null ) {
-
-			var offset = material.map.offset;
-			var repeat = material.map.repeat;
-
-			uniforms.offsetRepeat.value.set( offset.x, offset.y, repeat.x, repeat.y );
-
-		}
-
-	}
-
-	function refreshUniformsFog ( uniforms, fog ) {
-
-		uniforms.fogColor.value = fog.color;
-
-		if ( fog instanceof THREE.Fog ) {
-
-			uniforms.fogNear.value = fog.near;
-			uniforms.fogFar.value = fog.far;
-
-		} else if ( fog instanceof THREE.FogExp2 ) {
-
-			uniforms.fogDensity.value = fog.density;
-
-		}
-
-	}
-
-	function refreshUniformsLambert ( uniforms, material ) {
-
-		if ( material.lightMap ) {
-
-			uniforms.lightMap.value = material.lightMap;
-			uniforms.lightMapIntensity.value = material.lightMapIntensity;
-
-		}
-
-		if ( material.emissiveMap ) {
-
-			uniforms.emissiveMap.value = material.emissiveMap;
-
-		}
-
-	}
-
-	function refreshUniformsPhong ( uniforms, material ) {
-
-		uniforms.specular.value = material.specular;
-		uniforms.shininess.value = Math.max( material.shininess, 1e-4 ); // to prevent pow( 0.0, 0.0 )
-
-		if ( material.lightMap ) {
-
-			uniforms.lightMap.value = material.lightMap;
-			uniforms.lightMapIntensity.value = material.lightMapIntensity;
-
-		}
-
-		if ( material.emissiveMap ) {
-
-			uniforms.emissiveMap.value = material.emissiveMap;
-
-		}
-
-		if ( material.bumpMap ) {
-
-			uniforms.bumpMap.value = material.bumpMap;
-			uniforms.bumpScale.value = material.bumpScale;
-
-		}
-
-		if ( material.normalMap ) {
-
-			uniforms.normalMap.value = material.normalMap;
-			uniforms.normalScale.value.copy( material.normalScale );
-
-		}
-
-		if ( material.displacementMap ) {
-
-			uniforms.displacementMap.value = material.displacementMap;
-			uniforms.displacementScale.value = material.displacementScale;
-			uniforms.displacementBias.value = material.displacementBias;
-
-		}
-
-	}
-
-	function refreshUniformsStandard ( uniforms, material ) {
-
-		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.lightMap ) {
-
-			uniforms.lightMap.value = material.lightMap;
-			uniforms.lightMapIntensity.value = material.lightMapIntensity;
-
-		}
-
-		if ( material.emissiveMap ) {
-
-			uniforms.emissiveMap.value = material.emissiveMap;
-
-		}
-
-		if ( material.bumpMap ) {
-
-			uniforms.bumpMap.value = material.bumpMap;
-			uniforms.bumpScale.value = material.bumpScale;
-
-		}
-
-		if ( material.normalMap ) {
-
-			uniforms.normalMap.value = material.normalMap;
-			uniforms.normalScale.value.copy( material.normalScale );
-
-		}
-
-		if ( material.displacementMap ) {
-
-			uniforms.displacementMap.value = material.displacementMap;
-			uniforms.displacementScale.value = material.displacementScale;
-			uniforms.displacementBias.value = material.displacementBias;
-
-		}
-
-		if ( material.envMap ) {
-
-			//uniforms.envMap.value = material.envMap; // part of uniforms common
-			uniforms.envMapIntensity.value = material.envMapIntensity;
-
-		}
-
-	}
-
-	function refreshUniformsPhysical ( uniforms, material ) {
-
-		refreshUniformsStandard( uniforms, material );
-
-	}
-
-	// 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.directionalLights.needsUpdate = value;
-		uniforms.pointLights.needsUpdate = value;
-		uniforms.spotLights.needsUpdate = value;
-		uniforms.hemisphereLights.needsUpdate = value;
-
-	}
-
-	// Lighting
-
-	function setupShadows ( lights ) {
-
-		var lightShadowsLength = 0;
-
-		for ( var i = 0, l = lights.length; i < l; i ++ ) {
-
-			var light = lights[ i ];
-
-			if ( light.castShadow ) {
-
-				_lights.shadows[ lightShadowsLength ++ ] = light;
-
-			}
-
-		}
-
-		_lights.shadows.length = lightShadowsLength;
-
-	}
-
-	function setupLights ( lights, camera ) {
-
-		var l, ll, light,
-		r = 0, g = 0, b = 0,
-		color,
-		intensity,
-		distance,
-
-		viewMatrix = camera.matrixWorldInverse,
-
-		directionalLength = 0,
-		pointLength = 0,
-		spotLength = 0,
-		hemiLength = 0;
-
-		for ( l = 0, ll = lights.length; l < ll; l ++ ) {
-
-			light = lights[ l ];
-
-			color = light.color;
-			intensity = light.intensity;
-			distance = light.distance;
-
-			if ( light instanceof THREE.AmbientLight ) {
-
-				r += color.r * intensity;
-				g += color.g * intensity;
-				b += color.b * intensity;
-
-			} else if ( light instanceof THREE.DirectionalLight ) {
-
-				var uniforms = lightCache.get( light );
-
-				uniforms.color.copy( light.color ).multiplyScalar( light.intensity );
-				uniforms.direction.setFromMatrixPosition( light.matrixWorld );
-				_vector3.setFromMatrixPosition( light.target.matrixWorld );
-				uniforms.direction.sub( _vector3 );
-				uniforms.direction.transformDirection( viewMatrix );
-
-				uniforms.shadow = light.castShadow;
-
-				if ( light.castShadow ) {
-
-					uniforms.shadowBias = light.shadow.bias;
-					uniforms.shadowRadius = light.shadow.radius;
-					uniforms.shadowMapSize = light.shadow.mapSize;
-
-				}
-
-				_lights.directionalShadowMap[ directionalLength ] = light.shadow.map;
-				_lights.directionalShadowMatrix[ directionalLength ] = light.shadow.matrix;
-				_lights.directional[ directionalLength ++ ] = uniforms;
-
-			} else if ( light instanceof THREE.SpotLight ) {
-
-				var uniforms = lightCache.get( light );
-
-				uniforms.position.setFromMatrixPosition( light.matrixWorld );
-				uniforms.position.applyMatrix4( viewMatrix );
-
-				uniforms.color.copy( color ).multiplyScalar( intensity );
-				uniforms.distance = distance;
-
-				uniforms.direction.setFromMatrixPosition( light.matrixWorld );
-				_vector3.setFromMatrixPosition( light.target.matrixWorld );
-				uniforms.direction.sub( _vector3 );
-				uniforms.direction.transformDirection( viewMatrix );
-
-				uniforms.coneCos = Math.cos( light.angle );
-				uniforms.penumbraCos = Math.cos( light.angle * ( 1 - light.penumbra ) );
-				uniforms.decay = ( light.distance === 0 ) ? 0.0 : light.decay;
-
-				uniforms.shadow = light.castShadow;
-
-				if ( light.castShadow ) {
-
-					uniforms.shadowBias = light.shadow.bias;
-					uniforms.shadowRadius = light.shadow.radius;
-					uniforms.shadowMapSize = light.shadow.mapSize;
-
-				}
-
-				_lights.spotShadowMap[ spotLength ] = light.shadow.map;
-				_lights.spotShadowMatrix[ spotLength ] = light.shadow.matrix;
-				_lights.spot[ spotLength ++ ] = uniforms;
-
-			} else if ( light instanceof THREE.PointLight ) {
-
-				var uniforms = lightCache.get( light );
-
-				uniforms.position.setFromMatrixPosition( light.matrixWorld );
-				uniforms.position.applyMatrix4( viewMatrix );
-
-				uniforms.color.copy( light.color ).multiplyScalar( light.intensity );
-				uniforms.distance = light.distance;
-				uniforms.decay = ( light.distance === 0 ) ? 0.0 : light.decay;
-
-				uniforms.shadow = light.castShadow;
-
-				if ( light.castShadow ) {
-
-					uniforms.shadowBias = light.shadow.bias;
-					uniforms.shadowRadius = light.shadow.radius;
-					uniforms.shadowMapSize = light.shadow.mapSize;
-
-				}
-
-				_lights.pointShadowMap[ pointLength ] = light.shadow.map;
-
-				if ( _lights.pointShadowMatrix[ pointLength ] === undefined ) {
-
-					_lights.pointShadowMatrix[ pointLength ] = new THREE.Matrix4();
-
-				}
-
-				// for point lights we set the shadow matrix to be a translation-only matrix
-				// equal to inverse of the light's position
-				_vector3.setFromMatrixPosition( light.matrixWorld ).negate();
-				_lights.pointShadowMatrix[ pointLength ].identity().setPosition( _vector3 );
-
-				_lights.point[ pointLength ++ ] = uniforms;
-
-			} else if ( light instanceof THREE.HemisphereLight ) {
-
-				var uniforms = lightCache.get( light );
-
-				uniforms.direction.setFromMatrixPosition( light.matrixWorld );
-				uniforms.direction.transformDirection( viewMatrix );
-				uniforms.direction.normalize();
-
-				uniforms.skyColor.copy( light.color ).multiplyScalar( intensity );
-				uniforms.groundColor.copy( light.groundColor ).multiplyScalar( intensity );
-
-				_lights.hemi[ hemiLength ++ ] = uniforms;
-
-			}
-
-		}
-
-		_lights.ambient[ 0 ] = r;
-		_lights.ambient[ 1 ] = g;
-		_lights.ambient[ 2 ] = b;
-
-		_lights.directional.length = directionalLength;
-		_lights.spot.length = spotLength;
-		_lights.point.length = pointLength;
-		_lights.hemi.length = hemiLength;
-
-		_lights.hash = directionalLength + ',' + pointLength + ',' + spotLength + ',' + hemiLength + ',' + _lights.shadows.length;
-
-	}
-
-	// Clipping
-
-	function setupGlobalClippingPlanes( planes, camera ) {
-
-		_clippingEnabled =
-				_this.clippingPlanes.length !== 0 ||
-				_this.localClippingEnabled ||
-				// enable state of previous frame - the clipping code has to
-				// run another frame in order to reset the state:
-				_numGlobalClippingPlanes !== 0 ||
-				_localClippingEnabled;
-
-		_localClippingEnabled = _this.localClippingEnabled;
-
-		_globalClippingState = setupClippingPlanes( planes, camera, 0 );
-		_numGlobalClippingPlanes = planes !== null ? planes.length : 0;
-
-	}
-
-	function setupClippingPlanes( planes, camera, dstOffset, skipTransform ) {
-
-		var nPlanes = planes !== null ? planes.length : 0,
-			dstArray = null;
-
-		if ( nPlanes !== 0 ) {
-
-			dstArray = _clippingPlanesUniform.value;
-
-			if ( skipTransform !== true || dstArray === null ) {
-
-				var flatSize = dstOffset + nPlanes * 4,
-					viewMatrix = camera.matrixWorldInverse,
-					viewNormalMatrix = _matrix3.getNormalMatrix( viewMatrix );
-
-				if ( dstArray === null || dstArray.length < flatSize ) {
-
-					dstArray = new Float32Array( flatSize );
-
-				}
-
-				for ( var i = 0, i4 = dstOffset; i !== nPlanes; ++ i, i4 += 4 ) {
-
-					var plane = _plane.copy( planes[ i ] ).
-							applyMatrix4( viewMatrix, viewNormalMatrix );
-
-					plane.normal.toArray( dstArray, i4 );
-					dstArray[ i4 + 3 ] = plane.constant;
-
-				}
-
-			}
-
-			_clippingPlanesUniform.value = dstArray;
-			_clippingPlanesUniform.needsUpdate = true;
-
-		}
-
-		_numClippingPlanes = nPlanes;
-		return dstArray;
-
-	}
-
-	function resetGlobalClippingState() {
-
-		if ( _clippingPlanesUniform.value !== _globalClippingState ) {
-
-			_clippingPlanesUniform.value = _globalClippingState;
-			_clippingPlanesUniform.needsUpdate = _numGlobalClippingPlanes > 0;
-
-		}
-
-		_numClippingPlanes = _numGlobalClippingPlanes;
-
-	}
-
-	function setClippingState( planes, clipShadows, camera, cache, fromCache ) {
-
-		if ( ! _localClippingEnabled ||
-				planes === null || planes.length === 0 ||
-				_clipRenderingShadows && ! clipShadows ) {
-			// there's no local clipping
-
-			if ( _clipRenderingShadows ) {
-				// there's no global clipping
-
-				setupClippingPlanes( null );
-
-			} else {
-
-				resetGlobalClippingState();
-			}
-
-		} else {
-
-			var nGlobal = _clipRenderingShadows ? 0 : _numGlobalClippingPlanes,
-				lGlobal = nGlobal * 4,
-
-				dstArray = cache.clippingState || null;
-
-			_clippingPlanesUniform.value = dstArray; // ensure unique state
-
-			dstArray = setupClippingPlanes(
-					planes, camera, lGlobal, fromCache );
-
-			for ( var i = 0; i !== lGlobal; ++ i ) {
-
-				dstArray[ i ] = _globalClippingState[ i ];
-
-			}
-
-			cache.clippingState = dstArray;
-			_numClippingPlanes += nGlobal;
-
-		}
-
-	}
-
-
-	// GL state setting
-
-	this.setFaceCulling = function ( cullFace, frontFaceDirection ) {
-
-		if ( cullFace === THREE.CullFaceNone ) {
-
-			state.disable( _gl.CULL_FACE );
-
-		} else {
-
-			if ( frontFaceDirection === THREE.FrontFaceDirectionCW ) {
-
-				_gl.frontFace( _gl.CW );
-
-			} else {
-
-				_gl.frontFace( _gl.CCW );
-
-			}
-
-			if ( cullFace === THREE.CullFaceBack ) {
-
-				_gl.cullFace( _gl.BACK );
-
-			} else if ( cullFace === THREE.CullFaceFront ) {
-
-				_gl.cullFace( _gl.FRONT );
-
-			} else {
-
-				_gl.cullFace( _gl.FRONT_AND_BACK );
-
-			}
-
-			state.enable( _gl.CULL_FACE );
-
-		}
-
-	};
-
-	// Textures
-
-	function allocTextureUnit() {
-
-		var textureUnit = _usedTextureUnits;
-
-		if ( textureUnit >= capabilities.maxTextures ) {
-
-			console.warn( 'WebGLRenderer: trying to use ' + textureUnit + ' texture units while this GPU supports only ' + capabilities.maxTextures );
-
-		}
-
-		_usedTextureUnits += 1;
-
-		return textureUnit;
-
-	}
-
-	function setTextureParameters ( textureType, texture, isPowerOfTwoImage ) {
-
-		var extension;
-
-		if ( isPowerOfTwoImage ) {
-
-			_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, paramThreeToGL( texture.wrapS ) );
-			_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, paramThreeToGL( texture.wrapT ) );
-
-			_gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, paramThreeToGL( texture.magFilter ) );
-			_gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, paramThreeToGL( texture.minFilter ) );
-
-		} else {
-
-			_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_S, _gl.CLAMP_TO_EDGE );
-			_gl.texParameteri( textureType, _gl.TEXTURE_WRAP_T, _gl.CLAMP_TO_EDGE );
-
-			if ( texture.wrapS !== THREE.ClampToEdgeWrapping || texture.wrapT !== THREE.ClampToEdgeWrapping ) {
-
-				console.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.wrapS and Texture.wrapT should be set to THREE.ClampToEdgeWrapping.', texture );
-
-			}
-
-			_gl.texParameteri( textureType, _gl.TEXTURE_MAG_FILTER, filterFallback( texture.magFilter ) );
-			_gl.texParameteri( textureType, _gl.TEXTURE_MIN_FILTER, filterFallback( texture.minFilter ) );
-
-			if ( texture.minFilter !== THREE.NearestFilter && texture.minFilter !== THREE.LinearFilter ) {
-
-				console.warn( 'THREE.WebGLRenderer: Texture is not power of two. Texture.minFilter should be set to THREE.NearestFilter or THREE.LinearFilter.', texture );
-
-			}
-
-		}
-
-		extension = extensions.get( 'EXT_texture_filter_anisotropic' );
-
-		if ( extension ) {
-
-			if ( texture.type === THREE.FloatType && extensions.get( 'OES_texture_float_linear' ) === null ) return;
-			if ( texture.type === THREE.HalfFloatType && extensions.get( 'OES_texture_half_float_linear' ) === null ) return;
-
-			if ( texture.anisotropy > 1 || properties.get( texture ).__currentAnisotropy ) {
-
-				_gl.texParameterf( textureType, extension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min( texture.anisotropy, _this.getMaxAnisotropy() ) );
-				properties.get( texture ).__currentAnisotropy = texture.anisotropy;
-
-			}
-
-		}
-
-	}
-
-	function uploadTexture( textureProperties, texture, slot ) {
-
-		if ( textureProperties.__webglInit === undefined ) {
-
-			textureProperties.__webglInit = true;
-
-			texture.addEventListener( 'dispose', onTextureDispose );
-
-			textureProperties.__webglTexture = _gl.createTexture();
-
-			_infoMemory.textures ++;
-
-		}
-
-		state.activeTexture( _gl.TEXTURE0 + slot );
-		state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture );
-
-		_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY );
-		_gl.pixelStorei( _gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultiplyAlpha );
-		_gl.pixelStorei( _gl.UNPACK_ALIGNMENT, texture.unpackAlignment );
-
-		var image = clampToMaxSize( texture.image, capabilities.maxTextureSize );
-
-		if ( textureNeedsPowerOfTwo( texture ) && isPowerOfTwo( image ) === false ) {
-
-			image = makePowerOfTwo( image );
-
-		}
-
-		var isPowerOfTwoImage = isPowerOfTwo( image ),
-		glFormat = paramThreeToGL( texture.format ),
-		glType = paramThreeToGL( texture.type );
-
-		setTextureParameters( _gl.TEXTURE_2D, texture, isPowerOfTwoImage );
-
-		var mipmap, mipmaps = texture.mipmaps;
-
-		if ( texture instanceof THREE.DepthTexture ) {
-
-			// populate depth texture with dummy data
-
-			var internalFormat = _gl.DEPTH_COMPONENT;
-
-			if ( texture.type === THREE.FloatType ) {
-
-				if ( !_isWebGL2 ) throw new Error('Float Depth Texture only supported in WebGL2.0');
-				internalFormat = _gl.DEPTH_COMPONENT32F;
-
-			} else if ( _isWebGL2 ) {
-
-				// WebGL 2.0 requires signed internalformat for glTexImage2D
-				internalFormat = _gl.DEPTH_COMPONENT16;
-
-			}
-
-			state.texImage2D( _gl.TEXTURE_2D, 0, internalFormat, image.width, image.height, 0, glFormat, glType, null );
-
-		} else if ( texture instanceof THREE.DataTexture ) {
-
-			// 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 && isPowerOfTwoImage ) {
-
-				for ( var i = 0, il = mipmaps.length; i < il; i ++ ) {
-
-					mipmap = mipmaps[ i ];
-					state.texImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );
-
-				}
-
-				texture.generateMipmaps = false;
-
-			} else {
-
-				state.texImage2D( _gl.TEXTURE_2D, 0, glFormat, image.width, image.height, 0, glFormat, glType, image.data );
-
-			}
-
-		} else if ( texture instanceof THREE.CompressedTexture ) {
-
-			for ( var i = 0, il = mipmaps.length; i < il; i ++ ) {
-
-				mipmap = mipmaps[ i ];
-
-				if ( texture.format !== THREE.RGBAFormat && texture.format !== THREE.RGBFormat ) {
-
-					if ( state.getCompressedTextureFormats().indexOf( glFormat ) > - 1 ) {
-
-						state.compressedTexImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, mipmap.data );
-
-					} else {
-
-						console.warn( "THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .uploadTexture()" );
-
-					}
-
-				} else {
-
-					state.texImage2D( _gl.TEXTURE_2D, i, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );
-
-				}
-
-			}
-
-		} else {
-
-			// regular Texture (image, video, canvas)
-
-			// 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 && isPowerOfTwoImage ) {
-
-				for ( var i = 0, il = mipmaps.length; i < il; i ++ ) {
-
-					mipmap = mipmaps[ i ];
-					state.texImage2D( _gl.TEXTURE_2D, i, glFormat, glFormat, glType, mipmap );
-
-				}
-
-				texture.generateMipmaps = false;
-
-			} else {
-
-				state.texImage2D( _gl.TEXTURE_2D, 0, glFormat, glFormat, glType, image );
-
-			}
-
-		}
-
-		if ( texture.generateMipmaps && isPowerOfTwoImage ) _gl.generateMipmap( _gl.TEXTURE_2D );
-
-		textureProperties.__version = texture.version;
-
-		if ( texture.onUpdate ) texture.onUpdate( texture );
-
-	}
-
-	function setTexture2D( texture, slot ) {
-
-		if ( texture instanceof THREE.WebGLRenderTarget ) texture = texture.texture;
-
-		var textureProperties = properties.get( 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', texture );
-				return;
-
-			}
-
-			if ( image.complete === false ) {
-
-				console.warn( 'THREE.WebGLRenderer: Texture marked for update but image is incomplete', texture );
-				return;
-
-			}
-
-			uploadTexture( textureProperties, texture, slot );
-
-			return;
-
-		}
-
-		state.activeTexture( _gl.TEXTURE0 + slot );
-		state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture );
-
-	}
-
-	function clampToMaxSize ( image, maxSize ) {
-
-		if ( image.width > maxSize || image.height > maxSize ) {
-
-			// Warning: Scaling through the canvas will only work with images that use
-			// premultiplied alpha.
-
-			var scale = maxSize / Math.max( image.width, image.height );
-
-			var canvas = document.createElement( 'canvas' );
-			canvas.width = Math.floor( image.width * scale );
-			canvas.height = Math.floor( image.height * scale );
-
-			var context = canvas.getContext( '2d' );
-			context.drawImage( image, 0, 0, image.width, image.height, 0, 0, canvas.width, canvas.height );
-
-			console.warn( 'THREE.WebGLRenderer: image is too big (' + image.width + 'x' + image.height + '). Resized to ' + canvas.width + 'x' + canvas.height, image );
-
-			return canvas;
-
-		}
-
-		return image;
-
-	}
-
-	function isPowerOfTwo( image ) {
-
-		return THREE.Math.isPowerOfTwo( image.width ) && THREE.Math.isPowerOfTwo( image.height );
-
-	}
-
-	function textureNeedsPowerOfTwo( texture ) {
-
-		if ( texture.wrapS !== THREE.ClampToEdgeWrapping || texture.wrapT !== THREE.ClampToEdgeWrapping ) return true;
-		if ( texture.minFilter !== THREE.NearestFilter && texture.minFilter !== THREE.LinearFilter ) return true;
-
-		return false;
-
-	}
-
-	function makePowerOfTwo( image ) {
-
-		if ( image instanceof HTMLImageElement || image instanceof HTMLCanvasElement ) {
-
-			var canvas = document.createElement( 'canvas' );
-			canvas.width = THREE.Math.nearestPowerOfTwo( image.width );
-			canvas.height = THREE.Math.nearestPowerOfTwo( image.height );
-
-			var context = canvas.getContext( '2d' );
-			context.drawImage( image, 0, 0, canvas.width, canvas.height );
-
-			console.warn( 'THREE.WebGLRenderer: image is not power of two (' + image.width + 'x' + image.height + '). Resized to ' + canvas.width + 'x' + canvas.height, image );
-
-			return canvas;
-
-		}
-
-		return image;
-
-	}
-
-	function setCubeTexture ( texture, slot ) {
-
-		var textureProperties = properties.get( texture );
-
-		if ( texture.image.length === 6 ) {
-
-			if ( texture.version > 0 && textureProperties.__version !== texture.version ) {
-
-				if ( ! textureProperties.__image__webglTextureCube ) {
-
-					texture.addEventListener( 'dispose', onTextureDispose );
-
-					textureProperties.__image__webglTextureCube = _gl.createTexture();
-
-					_infoMemory.textures ++;
-
-				}
-
-				state.activeTexture( _gl.TEXTURE0 + slot );
-				state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube );
-
-				_gl.pixelStorei( _gl.UNPACK_FLIP_Y_WEBGL, texture.flipY );
-
-				var isCompressed = texture instanceof THREE.CompressedTexture;
-				var isDataTexture = texture.image[ 0 ] instanceof THREE.DataTexture;
-
-				var cubeImage = [];
-
-				for ( var i = 0; i < 6; i ++ ) {
-
-					if ( _this.autoScaleCubemaps && ! isCompressed && ! isDataTexture ) {
-
-						cubeImage[ i ] = clampToMaxSize( texture.image[ i ], capabilities.maxCubemapSize );
-
-					} else {
-
-						cubeImage[ i ] = isDataTexture ? texture.image[ i ].image : texture.image[ i ];
-
-					}
-
-				}
-
-				var image = cubeImage[ 0 ],
-				isPowerOfTwoImage = isPowerOfTwo( image ),
-				glFormat = paramThreeToGL( texture.format ),
-				glType = paramThreeToGL( texture.type );
-
-				setTextureParameters( _gl.TEXTURE_CUBE_MAP, texture, isPowerOfTwoImage );
-
-				for ( var i = 0; i < 6; i ++ ) {
-
-					if ( ! isCompressed ) {
-
-						if ( isDataTexture ) {
-
-							state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glFormat, cubeImage[ i ].width, cubeImage[ i ].height, 0, glFormat, glType, cubeImage[ i ].data );
-
-						} else {
-
-							state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, glFormat, glFormat, glType, cubeImage[ i ] );
-
-						}
-
-					} else {
-
-						var mipmap, mipmaps = cubeImage[ i ].mipmaps;
-
-						for ( var j = 0, jl = mipmaps.length; j < jl; j ++ ) {
-
-							mipmap = mipmaps[ j ];
-
-							if ( texture.format !== THREE.RGBAFormat && texture.format !== THREE.RGBFormat ) {
-
-								if ( state.getCompressedTextureFormats().indexOf( glFormat ) > - 1 ) {
-
-									state.compressedTexImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glFormat, mipmap.width, mipmap.height, 0, mipmap.data );
-
-								} else {
-
-									console.warn( "THREE.WebGLRenderer: Attempt to load unsupported compressed texture format in .setCubeTexture()" );
-
-								}
-
-							} else {
-
-								state.texImage2D( _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i, j, glFormat, mipmap.width, mipmap.height, 0, glFormat, glType, mipmap.data );
-
-							}
-
-						}
-
-					}
-
-				}
-
-				if ( texture.generateMipmaps && isPowerOfTwoImage ) {
-
-					_gl.generateMipmap( _gl.TEXTURE_CUBE_MAP );
-
-				}
-
-				textureProperties.__version = texture.version;
-
-				if ( texture.onUpdate ) texture.onUpdate( texture );
-
-			} else {
-
-				state.activeTexture( _gl.TEXTURE0 + slot );
-				state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__image__webglTextureCube );
-
-			}
-
-		}
-
-	}
-
-	function setCubeTextureDynamic ( texture, slot ) {
-
-		state.activeTexture( _gl.TEXTURE0 + slot );
-		state.bindTexture( _gl.TEXTURE_CUBE_MAP, properties.get( texture ).__webglTexture );
-
-	}
-
-	var setTextureWarned = false;
-	this.setTexture = function( texture, slot ) {
-
-		if ( ! setTextureWarned ) {
-
-			console.warn( "THREE.WebGLRenderer: .setTexture is deprecated, " +
-				"use setTexture2D instead." );
-			setTextureWarned = true;
-
-		}
-
-		setTexture2D( texture, slot );
-
-	};
-
-	this.allocTextureUnit = allocTextureUnit;
-	this.setTexture2D = setTexture2D;
-	this.setTextureCube = function( texture, slot ) {
-
-		if ( texture instanceof THREE.CubeTexture ||
-			 ( Array.isArray( texture.image ) && texture.image.length === 6 ) ) {
-
-			// CompressedTexture can have Array in image :/
-
-			setCubeTexture( texture, slot );
-
-		} else {
-			// assumed: texture instanceof THREE.WebGLRenderTargetCube
-
-			setCubeTextureDynamic( texture.texture, slot );
-
-		}
-
-	};
-
-	// Render targets
-
-	// Setup storage for target texture and bind it to correct framebuffer
-	function setupFrameBufferTexture ( framebuffer, renderTarget, attachment, textureTarget ) {
-
-		var glFormat = paramThreeToGL( renderTarget.texture.format );
-		var glType = paramThreeToGL( renderTarget.texture.type );
-		state.texImage2D( textureTarget, 0, glFormat, renderTarget.width, renderTarget.height, 0, glFormat, glType, null );
-		_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
-		_gl.framebufferTexture2D( _gl.FRAMEBUFFER, attachment, textureTarget, properties.get( renderTarget.texture ).__webglTexture, 0 );
-		_gl.bindFramebuffer( _gl.FRAMEBUFFER, null );
-
-	}
-
-	// Setup storage for internal depth/stencil buffers and bind to correct framebuffer
-	function setupRenderBufferStorage ( renderbuffer, renderTarget ) {
-
-		_gl.bindRenderbuffer( _gl.RENDERBUFFER, renderbuffer );
-
-		if ( renderTarget.depthBuffer && ! renderTarget.stencilBuffer ) {
-
-			_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_COMPONENT16, renderTarget.width, renderTarget.height );
-			_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );
-
-		} else if ( renderTarget.depthBuffer && renderTarget.stencilBuffer ) {
-
-			_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.DEPTH_STENCIL, renderTarget.width, renderTarget.height );
-			_gl.framebufferRenderbuffer( _gl.FRAMEBUFFER, _gl.DEPTH_STENCIL_ATTACHMENT, _gl.RENDERBUFFER, renderbuffer );
-
-		} else {
-
-			// FIXME: We don't support !depth !stencil
-			_gl.renderbufferStorage( _gl.RENDERBUFFER, _gl.RGBA4, renderTarget.width, renderTarget.height );
-
-		}
-
-		_gl.bindRenderbuffer( _gl.RENDERBUFFER, null );
-
-	}
-
-	// Setup resources for a Depth Texture for a FBO (needs an extension)
-	function setupDepthTexture ( framebuffer, renderTarget ) {
-
-		var isCube = ( renderTarget instanceof THREE.WebGLRenderTargetCube );
-		if ( isCube ) throw new Error('Depth Texture with cube render targets is not supported!');
-
-		_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
-
-		if ( !( renderTarget.depthTexture instanceof THREE.DepthTexture ) ) {
-
-			throw new Error('renderTarget.depthTexture must be an instance of THREE.DepthTexture');
-
-		}
-
-		// upload an empty depth texture with framebuffer size
-		if ( !properties.get( renderTarget.depthTexture ).__webglTexture ||
-				renderTarget.depthTexture.image.width !== renderTarget.width ||
-				renderTarget.depthTexture.image.height !== renderTarget.height ) {
-			renderTarget.depthTexture.image.width = renderTarget.width;
-			renderTarget.depthTexture.image.height = renderTarget.height;
-			renderTarget.depthTexture.needsUpdate = true;
-		}
-
-		_this.setTexture( renderTarget.depthTexture, 0 );
-
-		var webglDepthTexture = properties.get( renderTarget.depthTexture ).__webglTexture;
-		_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.DEPTH_ATTACHMENT, _gl.TEXTURE_2D, webglDepthTexture, 0 );
-
-	}
-
-	// Setup GL resources for a non-texture depth buffer
-	function setupDepthRenderbuffer( renderTarget ) {
-
-		var renderTargetProperties = properties.get( renderTarget );
-
-		var isCube = ( renderTarget instanceof THREE.WebGLRenderTargetCube );
-
-		if ( renderTarget.depthTexture ) {
-
-			if ( isCube ) throw new Error('target.depthTexture not supported in Cube render targets');
-
-			setupDepthTexture( renderTargetProperties.__webglFramebuffer, renderTarget );
-
-		} else {
-
-			if ( isCube ) {
-
-				renderTargetProperties.__webglDepthbuffer = [];
-
-				for ( var i = 0; i < 6; i ++ ) {
-
-					_gl.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer[ i ] );
-					renderTargetProperties.__webglDepthbuffer[ i ] = _gl.createRenderbuffer();
-					setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer[ i ], renderTarget );
-
-				}
-
-			} else {
-
-				_gl.bindFramebuffer( _gl.FRAMEBUFFER, renderTargetProperties.__webglFramebuffer );
-				renderTargetProperties.__webglDepthbuffer = _gl.createRenderbuffer();
-				setupRenderBufferStorage( renderTargetProperties.__webglDepthbuffer, renderTarget );
-
-			}
-
-		}
-
-		_gl.bindFramebuffer( _gl.FRAMEBUFFER, null );
-
-	}
-
-	// Set up GL resources for the render target
-	function setupRenderTarget( renderTarget ) {
-
-		var renderTargetProperties = properties.get( renderTarget );
-		var textureProperties = properties.get( renderTarget.texture );
-
-		renderTarget.addEventListener( 'dispose', onRenderTargetDispose );
-
-		textureProperties.__webglTexture = _gl.createTexture();
-
-		_infoMemory.textures ++;
-
-		var isCube = ( renderTarget instanceof THREE.WebGLRenderTargetCube );
-		var isTargetPowerOfTwo = THREE.Math.isPowerOfTwo( renderTarget.width ) && THREE.Math.isPowerOfTwo( renderTarget.height );
-
-		// Setup framebuffer
-
-		if ( isCube ) {
-
-			renderTargetProperties.__webglFramebuffer = [];
-
-			for ( var i = 0; i < 6; i ++ ) {
-
-				renderTargetProperties.__webglFramebuffer[ i ] = _gl.createFramebuffer();
-
-			}
-
-		} else {
-
-			renderTargetProperties.__webglFramebuffer = _gl.createFramebuffer();
-
-		}
-
-		// Setup color buffer
-
-		if ( isCube ) {
-
-			state.bindTexture( _gl.TEXTURE_CUBE_MAP, textureProperties.__webglTexture );
-			setTextureParameters( _gl.TEXTURE_CUBE_MAP, renderTarget.texture, isTargetPowerOfTwo );
-
-			for ( var i = 0; i < 6; i ++ ) {
-
-				setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer[ i ], renderTarget, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + i );
-
-			}
-
-			if ( renderTarget.texture.generateMipmaps && isTargetPowerOfTwo ) _gl.generateMipmap( _gl.TEXTURE_CUBE_MAP );
-			state.bindTexture( _gl.TEXTURE_CUBE_MAP, null );
-
-		} else {
-
-			state.bindTexture( _gl.TEXTURE_2D, textureProperties.__webglTexture );
-			setTextureParameters( _gl.TEXTURE_2D, renderTarget.texture, isTargetPowerOfTwo );
-			setupFrameBufferTexture( renderTargetProperties.__webglFramebuffer, renderTarget, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_2D );
-
-			if ( renderTarget.texture.generateMipmaps && isTargetPowerOfTwo ) _gl.generateMipmap( _gl.TEXTURE_2D );
-			state.bindTexture( _gl.TEXTURE_2D, null );
-
-		}
-
-		// Setup depth and stencil buffers
-
-		if ( renderTarget.depthBuffer ) {
-
-			setupDepthRenderbuffer( renderTarget );
-
-		}
-
-	}
-
-	this.getCurrentRenderTarget = function() {
-
-		return _currentRenderTarget;
-
-	};
-
-	this.setRenderTarget = function ( renderTarget ) {
-
-		_currentRenderTarget = renderTarget;
-
-		if ( renderTarget && properties.get( renderTarget ).__webglFramebuffer === undefined ) {
-
-			setupRenderTarget( renderTarget );
-
-		}
-
-		var isCube = ( renderTarget instanceof THREE.WebGLRenderTargetCube );
-		var framebuffer;
-
-		if ( renderTarget ) {
-
-			var renderTargetProperties = properties.get( renderTarget );
-
-			if ( isCube ) {
-
-				framebuffer = renderTargetProperties.__webglFramebuffer[ renderTarget.activeCubeFace ];
-
-			} else {
-
-				framebuffer = renderTargetProperties.__webglFramebuffer;
-
-			}
-
-			_currentScissor.copy( renderTarget.scissor );
-			_currentScissorTest = renderTarget.scissorTest;
-
-			_currentViewport.copy( renderTarget.viewport );
-
-		} else {
-
-			framebuffer = null;
-
-			_currentScissor.copy( _scissor ).multiplyScalar( _pixelRatio );
-			_currentScissorTest = _scissorTest;
-
-			_currentViewport.copy( _viewport ).multiplyScalar( _pixelRatio );
-
-		}
-
-		if ( _currentFramebuffer !== framebuffer ) {
-
-			_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
-			_currentFramebuffer = framebuffer;
-
-		}
-
-		state.scissor( _currentScissor );
-		state.setScissorTest( _currentScissorTest );
-
-		state.viewport( _currentViewport );
-
-		if ( isCube ) {
-
-			var textureProperties = properties.get( renderTarget.texture );
-			_gl.framebufferTexture2D( _gl.FRAMEBUFFER, _gl.COLOR_ATTACHMENT0, _gl.TEXTURE_CUBE_MAP_POSITIVE_X + renderTarget.activeCubeFace, textureProperties.__webglTexture, renderTarget.activeMipMapLevel );
-
-		}
-
-	};
-
-	this.readRenderTargetPixels = function ( renderTarget, x, y, width, height, buffer ) {
-
-		if ( renderTarget instanceof THREE.WebGLRenderTarget === false ) {
-
-			console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not THREE.WebGLRenderTarget.' );
-			return;
-
-		}
-
-		var framebuffer = properties.get( renderTarget ).__webglFramebuffer;
-
-		if ( framebuffer ) {
-
-			var restore = false;
-
-			if ( framebuffer !== _currentFramebuffer ) {
-
-				_gl.bindFramebuffer( _gl.FRAMEBUFFER, framebuffer );
-
-				restore = true;
-
-			}
-
-			try {
-
-				var texture = renderTarget.texture;
-
-				if ( texture.format !== THREE.RGBAFormat && paramThreeToGL( texture.format ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_FORMAT ) ) {
-
-					console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: renderTarget is not in RGBA or implementation defined format.' );
-					return;
-
-				}
-
-				if ( texture.type !== THREE.UnsignedByteType &&
-				     paramThreeToGL( texture.type ) !== _gl.getParameter( _gl.IMPLEMENTATION_COLOR_READ_TYPE ) &&
-				     ! ( texture.type === THREE.FloatType && extensions.get( 'WEBGL_color_buffer_float' ) ) &&
-				     ! ( texture.type === THREE.HalfFloatType && 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( _gl.FRAMEBUFFER ) === _gl.FRAMEBUFFER_COMPLETE ) {
-
-					// the following if statement ensures valid read requests (no out-of-bounds pixels, see #8604)
-
-					if ( ( x > 0 && x <= ( renderTarget.width - width ) ) && ( y > 0 && y <= ( renderTarget.height - height ) ) ) {
-
-						_gl.readPixels( x, y, width, height, paramThreeToGL( texture.format ), paramThreeToGL( texture.type ), buffer );
-
-					}
-
-				} else {
-
-					console.error( 'THREE.WebGLRenderer.readRenderTargetPixels: readPixels from renderTarget failed. Framebuffer not complete.' );
-
-				}
-
-			} finally {
-
-				if ( restore ) {
-
-					_gl.bindFramebuffer( _gl.FRAMEBUFFER, _currentFramebuffer );
-
-				}
-
-			}
-
-		}
-
-	};
-
-	function updateRenderTargetMipmap( renderTarget ) {
-
-		var target = renderTarget instanceof THREE.WebGLRenderTargetCube ? _gl.TEXTURE_CUBE_MAP : _gl.TEXTURE_2D;
-		var texture = properties.get( renderTarget.texture ).__webglTexture;
-
-		state.bindTexture( target, texture );
-		_gl.generateMipmap( target );
-		state.bindTexture( target, null );
-
-	}
-
-	// Fallback filters for non-power-of-2 textures
-
-	function filterFallback ( f ) {
-
-		if ( f === THREE.NearestFilter || f === THREE.NearestMipMapNearestFilter || f === THREE.NearestMipMapLinearFilter ) {
-
-			return _gl.NEAREST;
-
-		}
-
-		return _gl.LINEAR;
-
-	}
-
-	// Map three.js constants to WebGL constants
-
-	function paramThreeToGL ( p ) {
-
-		var extension;
-
-		if ( p === THREE.RepeatWrapping ) return _gl.REPEAT;
-		if ( p === THREE.ClampToEdgeWrapping ) return _gl.CLAMP_TO_EDGE;
-		if ( p === THREE.MirroredRepeatWrapping ) return _gl.MIRRORED_REPEAT;
-
-		if ( p === THREE.NearestFilter ) return _gl.NEAREST;
-		if ( p === THREE.NearestMipMapNearestFilter ) return _gl.NEAREST_MIPMAP_NEAREST;
-		if ( p === THREE.NearestMipMapLinearFilter ) return _gl.NEAREST_MIPMAP_LINEAR;
-
-		if ( p === THREE.LinearFilter ) return _gl.LINEAR;
-		if ( p === THREE.LinearMipMapNearestFilter ) return _gl.LINEAR_MIPMAP_NEAREST;
-		if ( p === THREE.LinearMipMapLinearFilter ) return _gl.LINEAR_MIPMAP_LINEAR;
-
-		if ( p === THREE.UnsignedByteType ) return _gl.UNSIGNED_BYTE;
-		if ( p === THREE.UnsignedShort4444Type ) return _gl.UNSIGNED_SHORT_4_4_4_4;
-		if ( p === THREE.UnsignedShort5551Type ) return _gl.UNSIGNED_SHORT_5_5_5_1;
-		if ( p === THREE.UnsignedShort565Type ) return _gl.UNSIGNED_SHORT_5_6_5;
-
-		if ( p === THREE.ByteType ) return _gl.BYTE;
-		if ( p === THREE.ShortType ) return _gl.SHORT;
-		if ( p === THREE.UnsignedShortType ) return _gl.UNSIGNED_SHORT;
-		if ( p === THREE.IntType ) return _gl.INT;
-		if ( p === THREE.UnsignedIntType ) return _gl.UNSIGNED_INT;
-		if ( p === THREE.FloatType ) return _gl.FLOAT;
-
-		extension = extensions.get( 'OES_texture_half_float' );
-
-		if ( extension !== null ) {
-
-			if ( p === THREE.HalfFloatType ) return extension.HALF_FLOAT_OES;
-
-		}
-
-		if ( p === THREE.AlphaFormat ) return _gl.ALPHA;
-		if ( p === THREE.RGBFormat ) return _gl.RGB;
-		if ( p === THREE.RGBAFormat ) return _gl.RGBA;
-		if ( p === THREE.LuminanceFormat ) return _gl.LUMINANCE;
-		if ( p === THREE.LuminanceAlphaFormat ) return _gl.LUMINANCE_ALPHA;
-		if ( p === THREE.DepthFormat ) return _gl.DEPTH_COMPONENT;
-
-		if ( p === THREE.AddEquation ) return _gl.FUNC_ADD;
-		if ( p === THREE.SubtractEquation ) return _gl.FUNC_SUBTRACT;
-		if ( p === THREE.ReverseSubtractEquation ) return _gl.FUNC_REVERSE_SUBTRACT;
-
-		if ( p === THREE.ZeroFactor ) return _gl.ZERO;
-		if ( p === THREE.OneFactor ) return _gl.ONE;
-		if ( p === THREE.SrcColorFactor ) return _gl.SRC_COLOR;
-		if ( p === THREE.OneMinusSrcColorFactor ) return _gl.ONE_MINUS_SRC_COLOR;
-		if ( p === THREE.SrcAlphaFactor ) return _gl.SRC_ALPHA;
-		if ( p === THREE.OneMinusSrcAlphaFactor ) return _gl.ONE_MINUS_SRC_ALPHA;
-		if ( p === THREE.DstAlphaFactor ) return _gl.DST_ALPHA;
-		if ( p === THREE.OneMinusDstAlphaFactor ) return _gl.ONE_MINUS_DST_ALPHA;
-
-		if ( p === THREE.DstColorFactor ) return _gl.DST_COLOR;
-		if ( p === THREE.OneMinusDstColorFactor ) return _gl.ONE_MINUS_DST_COLOR;
-		if ( p === THREE.SrcAlphaSaturateFactor ) return _gl.SRC_ALPHA_SATURATE;
-
-		extension = extensions.get( 'WEBGL_compressed_texture_s3tc' );
-
-		if ( extension !== null ) {
-
-			if ( p === THREE.RGB_S3TC_DXT1_Format ) return extension.COMPRESSED_RGB_S3TC_DXT1_EXT;
-			if ( p === THREE.RGBA_S3TC_DXT1_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT1_EXT;
-			if ( p === THREE.RGBA_S3TC_DXT3_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT3_EXT;
-			if ( p === THREE.RGBA_S3TC_DXT5_Format ) return extension.COMPRESSED_RGBA_S3TC_DXT5_EXT;
-
-		}
-
-		extension = extensions.get( 'WEBGL_compressed_texture_pvrtc' );
-
-		if ( extension !== null ) {
-
-			if ( p === THREE.RGB_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_4BPPV1_IMG;
-			if ( p === THREE.RGB_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGB_PVRTC_2BPPV1_IMG;
-			if ( p === THREE.RGBA_PVRTC_4BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG;
-			if ( p === THREE.RGBA_PVRTC_2BPPV1_Format ) return extension.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG;
-
-		}
-
-		extension = extensions.get( 'WEBGL_compressed_texture_etc1' );
-
-		if ( extension !== null ) {
-
-			if ( p === THREE.RGB_ETC1_Format ) return extension.COMPRESSED_RGB_ETC1_WEBGL;
-
-		}
-
-		extension = extensions.get( 'EXT_blend_minmax' );
-
-		if ( extension !== null ) {
-
-			if ( p === THREE.MinEquation ) return extension.MIN_EXT;
-			if ( p === THREE.MaxEquation ) return extension.MAX_EXT;
-
-		}
-
-		return 0;
-
-	}
-
-};
-
-// File:src/renderers/WebGLRenderTarget.js
-
-/**
- * @author szimek / https://github.com/szimek/
- * @author alteredq / http://alteredqualia.com/
- * @author Marius Kintel / https://github.com/kintel
- */
-
-/*
- In options, we can specify:
- * Texture parameters for an auto-generated target texture
- * depthBuffer/stencilBuffer: Booleans to indicate if we should generate these buffers
-*/
-THREE.WebGLRenderTarget = function ( width, height, options ) {
-
-	this.uuid = THREE.Math.generateUUID();
-
-	this.width = width;
-	this.height = height;
-
-	this.scissor = new THREE.Vector4( 0, 0, width, height );
-	this.scissorTest = false;
-
-	this.viewport = new THREE.Vector4( 0, 0, width, height );
-
-	options = options || {};
-
-	if ( options.minFilter === undefined ) options.minFilter = THREE.LinearFilter;
-
-	this.texture = new THREE.Texture( undefined, undefined, options.wrapS, options.wrapT, options.magFilter, options.minFilter, options.format, options.type, options.anisotropy, options.encoding );
-
-	this.depthBuffer = options.depthBuffer !== undefined ? options.depthBuffer : true;
-	this.stencilBuffer = options.stencilBuffer !== undefined ? options.stencilBuffer : true;
-	this.depthTexture = null;
-
-};
-
-THREE.WebGLRenderTarget.prototype = {
-
-	constructor: THREE.WebGLRenderTarget,
-
-	setSize: function ( width, height ) {
-
-		if ( this.width !== width || this.height !== height ) {
-
-			this.width = width;
-			this.height = height;
-
-			this.dispose();
-
-		}
-
-		this.viewport.set( 0, 0, width, height );
-		this.scissor.set( 0, 0, width, height );
-
-	},
-
-	clone: function () {
-
-		return new this.constructor().copy( this );
-
-	},
-
-	copy: function ( source ) {
-
-		this.width = source.width;
-		this.height = source.height;
-
-		this.viewport.copy( source.viewport );
-
-		this.texture = source.texture.clone();
-
-		this.depthBuffer = source.depthBuffer;
-		this.stencilBuffer = source.stencilBuffer;
-		this.depthTexture = source.depthTexture;
-
-		return this;
-
-	},
-
-	dispose: function () {
-
-		this.dispatchEvent( { type: 'dispose' } );
-
-	}
-
-};
-
-THREE.EventDispatcher.prototype.apply( THREE.WebGLRenderTarget.prototype );
-
-// File:src/renderers/WebGLRenderTargetCube.js
-
-/**
- * @author alteredq / http://alteredqualia.com
- */
-
-THREE.WebGLRenderTargetCube = function ( width, height, options ) {
-
-	THREE.WebGLRenderTarget.call( this, width, height, options );
-
-	this.activeCubeFace = 0; // PX 0, NX 1, PY 2, NY 3, PZ 4, NZ 5
-	this.activeMipMapLevel = 0;
-
-};
-
-THREE.WebGLRenderTargetCube.prototype = Object.create( THREE.WebGLRenderTarget.prototype );
-THREE.WebGLRenderTargetCube.prototype.constructor = THREE.WebGLRenderTargetCube;
-
-// File:src/renderers/webgl/WebGLBufferRenderer.js
-
-/**
-* @author mrdoob / http://mrdoob.com/
-*/
-
-THREE.WebGLBufferRenderer = function ( _gl, extensions, _infoRender ) {
-
-	var mode;
-
-	function setMode( value ) {
-
-		mode = value;
-
-	}
-
-	function render( start, count ) {
-
-		_gl.drawArrays( mode, start, count );
-
-		_infoRender.calls ++;
-		_infoRender.vertices += count;
-		if ( mode === _gl.TRIANGLES ) _infoRender.faces += count / 3;
-
-	}
-
-	function renderInstances( geometry ) {
-
-		var extension = extensions.get( 'ANGLE_instanced_arrays' );
-
-		if ( extension === null ) {
-
-			console.error( 'THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );
-			return;
-
-		}
-
-		var position = geometry.attributes.position;
-
-		var count = 0;
-
-		if ( position instanceof THREE.InterleavedBufferAttribute ) {
-
-			count = position.data.count;
-
-			extension.drawArraysInstancedANGLE( mode, 0, count, geometry.maxInstancedCount );
-
-		} else {
-
-			count = position.count;
-
-			extension.drawArraysInstancedANGLE( mode, 0, count, geometry.maxInstancedCount );
-
-		}
-
-		_infoRender.calls ++;
-		_infoRender.vertices += count * geometry.maxInstancedCount;
-		if ( mode === _gl.TRIANGLES ) _infoRender.faces += geometry.maxInstancedCount * count / 3;
-
-	}
-
-	this.setMode = setMode;
-	this.render = render;
-	this.renderInstances = renderInstances;
-
-};
-
-// File:src/renderers/webgl/WebGLIndexedBufferRenderer.js
-
-/**
-* @author mrdoob / http://mrdoob.com/
-*/
-
-THREE.WebGLIndexedBufferRenderer = function ( _gl, extensions, _infoRender ) {
-
-	var mode;
-
-	function setMode( value ) {
-
-		mode = value;
-
-	}
-
-	var type, size;
-
-	function setIndex( index ) {
-
-		if ( index.array instanceof Uint32Array && extensions.get( 'OES_element_index_uint' ) ) {
-
-			type = _gl.UNSIGNED_INT;
-			size = 4;
-
-		} else {
-
-			type = _gl.UNSIGNED_SHORT;
-			size = 2;
-
-		}
-
-	}
-
-	function render( start, count ) {
-
-		_gl.drawElements( mode, count, type, start * size );
-
-		_infoRender.calls ++;
-		_infoRender.vertices += count;
-		if ( mode === _gl.TRIANGLES ) _infoRender.faces += count / 3;
-
-	}
-
-	function renderInstances( geometry, start, count ) {
-
-		var extension = extensions.get( 'ANGLE_instanced_arrays' );
-
-		if ( extension === null ) {
-
-			console.error( 'THREE.WebGLBufferRenderer: using THREE.InstancedBufferGeometry but hardware does not support extension ANGLE_instanced_arrays.' );
-			return;
-
-		}
-
-		extension.drawElementsInstancedANGLE( mode, count, type, start * size, geometry.maxInstancedCount );
-
-		_infoRender.calls ++;
-		_infoRender.vertices += count * geometry.maxInstancedCount;
-		if ( mode === _gl.TRIANGLES ) _infoRender.faces += geometry.maxInstancedCount * count / 3;
-	}
-
-	this.setMode = setMode;
-	this.setIndex = setIndex;
-	this.render = render;
-	this.renderInstances = renderInstances;
-
-};
-
-// File:src/renderers/webgl/WebGLExtensions.js
-
-/**
-* @author mrdoob / http://mrdoob.com/
-*/
-
-THREE.WebGLExtensions = function ( gl ) {
-
-	var extensions = {};
-
-	this.get = function ( name ) {
-
-		if ( extensions[ name ] !== undefined ) {
-
-			return extensions[ name ];
-
-		}
-
-		var extension;
-
-		switch ( name ) {
-
-			case 'WEBGL_depth_texture':
-				extension = gl.getExtension( 'WEBGL_depth_texture' ) || gl.getExtension( 'MOZ_WEBGL_depth_texture' ) || gl.getExtension( 'WEBKIT_WEBGL_depth_texture' );
-
-			case 'EXT_texture_filter_anisotropic':
-				extension = gl.getExtension( 'EXT_texture_filter_anisotropic' ) || gl.getExtension( 'MOZ_EXT_texture_filter_anisotropic' ) || gl.getExtension( 'WEBKIT_EXT_texture_filter_anisotropic' );
-				break;
-
-			case 'WEBGL_compressed_texture_s3tc':
-				extension = gl.getExtension( 'WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'MOZ_WEBGL_compressed_texture_s3tc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_s3tc' );
-				break;
-
-			case 'WEBGL_compressed_texture_pvrtc':
-				extension = gl.getExtension( 'WEBGL_compressed_texture_pvrtc' ) || gl.getExtension( 'WEBKIT_WEBGL_compressed_texture_pvrtc' );
-				break;
-
-			case 'WEBGL_compressed_texture_etc1':
-				extension = gl.getExtension( 'WEBGL_compressed_texture_etc1' );
-				break;
-
-			default:
-				extension = gl.getExtension( name );
-
-		}
-
-		if ( extension === null ) {
-
-			console.warn( 'THREE.WebGLRenderer: ' + name + ' extension not supported.' );
-
-		}
-
-		extensions[ name ] = extension;
-
-		return extension;
-
-	};
-
-};
-
-// File:src/renderers/webgl/WebGLCapabilities.js
-
-THREE.WebGLCapabilities = function ( gl, extensions, parameters ) {
-
-	function getMaxPrecision( precision ) {
-
-		if ( precision === 'highp' ) {
-
-			if ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.HIGH_FLOAT ).precision > 0 &&
-			     gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.HIGH_FLOAT ).precision > 0 ) {
-
-				return 'highp';
-
-			}
-
-			precision = 'mediump';
-
-		}
-
-		if ( precision === 'mediump' ) {
-
-			if ( gl.getShaderPrecisionFormat( gl.VERTEX_SHADER, gl.MEDIUM_FLOAT ).precision > 0 &&
-			     gl.getShaderPrecisionFormat( gl.FRAGMENT_SHADER, gl.MEDIUM_FLOAT ).precision > 0 ) {
-
-				return 'mediump';
-
-			}
-
-		}
-
-		return 'lowp';
-
-	}
-
-	this.getMaxPrecision = getMaxPrecision;
-
-	this.precision = parameters.precision !== undefined ? parameters.precision : 'highp',
-	this.logarithmicDepthBuffer = parameters.logarithmicDepthBuffer !== undefined ? parameters.logarithmicDepthBuffer : false;
-
-	this.maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS );
-	this.maxVertexTextures = gl.getParameter( gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS );
-	this.maxTextureSize = gl.getParameter( gl.MAX_TEXTURE_SIZE );
-	this.maxCubemapSize = gl.getParameter( gl.MAX_CUBE_MAP_TEXTURE_SIZE );
-
-	this.maxAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS );
-	this.maxVertexUniforms = gl.getParameter( gl.MAX_VERTEX_UNIFORM_VECTORS );
-	this.maxVaryings = gl.getParameter( gl.MAX_VARYING_VECTORS );
-	this.maxFragmentUniforms = gl.getParameter( gl.MAX_FRAGMENT_UNIFORM_VECTORS );
-
-	this.vertexTextures = this.maxVertexTextures > 0;
-	this.floatFragmentTextures = !! extensions.get( 'OES_texture_float' );
-	this.floatVertexTextures = this.vertexTextures && this.floatFragmentTextures;
-
-	var _maxPrecision = getMaxPrecision( this.precision );
-
-	if ( _maxPrecision !== this.precision ) {
-
-		console.warn( 'THREE.WebGLRenderer:', this.precision, 'not supported, using', _maxPrecision, 'instead.' );
-		this.precision = _maxPrecision;
-
-	}
-
-	if ( this.logarithmicDepthBuffer ) {
-
-		this.logarithmicDepthBuffer = !! extensions.get( 'EXT_frag_depth' );
-
-	}
-
-};
-
-// File:src/renderers/webgl/WebGLGeometries.js
-
-/**
-* @author mrdoob / http://mrdoob.com/
-*/
-
-THREE.WebGLGeometries = function ( gl, properties, info ) {
-
-	var geometries = {};
-
-	function get( object ) {
-
-		var geometry = object.geometry;
-
-		if ( geometries[ geometry.id ] !== undefined ) {
-
-			return geometries[ geometry.id ];
-
-		}
-
-		geometry.addEventListener( 'dispose', onGeometryDispose );
-
-		var buffergeometry;
-
-		if ( geometry instanceof THREE.BufferGeometry ) {
-
-			buffergeometry = geometry;
-
-		} else if ( geometry instanceof THREE.Geometry ) {
-
-			if ( geometry._bufferGeometry === undefined ) {
-
-				geometry._bufferGeometry = new THREE.BufferGeometry().setFromObject( object );
-
-			}
-
-			buffergeometry = geometry._bufferGeometry;
-
-		}
-
-		geometries[ geometry.id ] = buffergeometry;
-
-		info.memory.geometries ++;
-
-		return buffergeometry;
-
-	}
-
-	function onGeometryDispose( event ) {
-
-		var geometry = event.target;
-		var buffergeometry = geometries[ geometry.id ];
-
-		if ( buffergeometry.index !== null ) {
-
-			deleteAttribute( buffergeometry.index );
-
-		}
-
-		deleteAttributes( buffergeometry.attributes );
-
-		geometry.removeEventListener( 'dispose', onGeometryDispose );
-
-		delete geometries[ geometry.id ];
-
-		// TODO
-
-		var property = properties.get( geometry );
-
-		if ( property.wireframe ) {
-
-			deleteAttribute( property.wireframe );
-
-		}
-
-		properties.delete( geometry );
-
-		var bufferproperty = properties.get( buffergeometry );
-
-		if ( bufferproperty.wireframe ) {
-
-			deleteAttribute( bufferproperty.wireframe );
-
-		}
-
-		properties.delete( buffergeometry );
-
-		//
-
-		info.memory.geometries --;
-
-	}
-
-	function getAttributeBuffer( attribute ) {
-
-		if ( attribute instanceof THREE.InterleavedBufferAttribute ) {
-
-			return properties.get( attribute.data ).__webglBuffer;
-
-		}
-
-		return properties.get( attribute ).__webglBuffer;
-
-	}
-
-	function deleteAttribute( attribute ) {
-
-		var buffer = getAttributeBuffer( attribute );
-
-		if ( buffer !== undefined ) {
-
-			gl.deleteBuffer( buffer );
-			removeAttributeBuffer( attribute );
-
-		}
-
-	}
-
-	function deleteAttributes( attributes ) {
-
-		for ( var name in attributes ) {
-
-			deleteAttribute( attributes[ name ] );
-
-		}
-
-	}
-
-	function removeAttributeBuffer( attribute ) {
-
-		if ( attribute instanceof THREE.InterleavedBufferAttribute ) {
-
-			properties.delete( attribute.data );
-
-		} else {
-
-			properties.delete( attribute );
-
-		}
-
-	}
-
-	this.get = get;
-
-};
-
-// File:src/renderers/webgl/WebGLLights.js
-
-/**
-* @author mrdoob / http://mrdoob.com/
-*/
-
-THREE.WebGLLights = function () {
-
-	var lights = {};
-
-	this.get = function ( light ) {
-
-		if ( lights[ light.id ] !== undefined ) {
-
-			return lights[ light.id ];
-
-		}
-
-		var uniforms;
-
-		switch ( light.type ) {
-
-			case 'DirectionalLight':
-				uniforms = {
-					direction: new THREE.Vector3(),
-					color: new THREE.Color(),
-
-					shadow: false,
-					shadowBias: 0,
-					shadowRadius: 1,
-					shadowMapSize: new THREE.Vector2()
-				};
-				break;
-
-			case 'SpotLight':
-				uniforms = {
-					position: new THREE.Vector3(),
-					direction: new THREE.Vector3(),
-					color: new THREE.Color(),
-					distance: 0,
-					coneCos: 0,
-					penumbraCos: 0,
-					decay: 0,
-
-					shadow: false,
-					shadowBias: 0,
-					shadowRadius: 1,
-					shadowMapSize: new THREE.Vector2()
-				};
-				break;
-
-			case 'PointLight':
-				uniforms = {
-					position: new THREE.Vector3(),
-					color: new THREE.Color(),
-					distance: 0,
-					decay: 0,
-
-					shadow: false,
-					shadowBias: 0,
-					shadowRadius: 1,
-					shadowMapSize: new THREE.Vector2()
-				};
-				break;
-
-			case 'HemisphereLight':
-				uniforms = {
-					direction: new THREE.Vector3(),
-					skyColor: new THREE.Color(),
-					groundColor: new THREE.Color()
-				};
-				break;
-
-		}
-
-		lights[ light.id ] = uniforms;
-
-		return uniforms;
-
-	};
-
-};
-
-// File:src/renderers/webgl/WebGLObjects.js
-
-/**
-* @author mrdoob / http://mrdoob.com/
-*/
-
-THREE.WebGLObjects = function ( gl, properties, info ) {
-
-	var geometries = new THREE.WebGLGeometries( gl, properties, info );
-
-	//
-
-	function update( object ) {
-
-		// TODO: Avoid updating twice (when using shadowMap). Maybe add frame counter.
-
-		var geometry = geometries.get( object );
-
-		if ( object.geometry instanceof THREE.Geometry ) {
-
-			geometry.updateFromObject( object );
-
-		}
-
-		var index = geometry.index;
-		var attributes = geometry.attributes;
-
-		if ( index !== null ) {
-
-			updateAttribute( index, gl.ELEMENT_ARRAY_BUFFER );
-
-		}
-
-		for ( var name in attributes ) {
-
-			updateAttribute( attributes[ name ], gl.ARRAY_BUFFER );
-
-		}
-
-		// morph targets
-
-		var morphAttributes = geometry.morphAttributes;
-
-		for ( var name in morphAttributes ) {
-
-			var array = morphAttributes[ name ];
-
-			for ( var i = 0, l = array.length; i < l; i ++ ) {
-
-				updateAttribute( array[ i ], gl.ARRAY_BUFFER );
-
-			}
-
-		}
-
-		return geometry;
-
-	}
-
-	function updateAttribute( attribute, bufferType ) {
-
-		var data = ( attribute instanceof THREE.InterleavedBufferAttribute ) ? attribute.data : attribute;
-
-		var attributeProperties = properties.get( data );
-
-		if ( attributeProperties.__webglBuffer === undefined ) {
-
-			createBuffer( attributeProperties, data, bufferType );
-
-		} else if ( attributeProperties.version !== data.version ) {
-
-			updateBuffer( attributeProperties, data, bufferType );
-
-		}
-
-	}
-
-	function createBuffer( attributeProperties, data, bufferType ) {
-
-		attributeProperties.__webglBuffer = gl.createBuffer();
-		gl.bindBuffer( bufferType, attributeProperties.__webglBuffer );
-
-		var usage = data.dynamic ? gl.DYNAMIC_DRAW : gl.STATIC_DRAW;
-
-		gl.bufferData( bufferType, data.array, usage );
-
-		attributeProperties.version = data.version;
-
-	}
-
-	function updateBuffer( attributeProperties, data, bufferType ) {
-
-		gl.bindBuffer( bufferType, attributeProperties.__webglBuffer );
-
-		if ( data.dynamic === false || data.updateRange.count === - 1 ) {
-
-			// Not using update ranges
-
-			gl.bufferSubData( bufferType, 0, data.array );
-
-		} else if ( data.updateRange.count === 0 ) {
-
-			console.error( 'THREE.WebGLObjects.updateBuffer: dynamic THREE.BufferAttribute marked as needsUpdate but updateRange.count is 0, ensure you are using set methods or updating manually.' );
-
-		} else {
-
-			gl.bufferSubData( bufferType, data.updateRange.offset * data.array.BYTES_PER_ELEMENT,
-							  data.array.subarray( data.updateRange.offset, data.updateRange.offset + data.updateRange.count ) );
-
-			data.updateRange.count = 0; // reset range
-
-		}
-
-		attributeProperties.version = data.version;
-
-	}
-
-	function getAttributeBuffer( attribute ) {
-
-		if ( attribute instanceof THREE.InterleavedBufferAttribute ) {
-
-			return properties.get( attribute.data ).__webglBuffer;
-
-		}
-
-		return properties.get( attribute ).__webglBuffer;
-
-	}
-
-	function getWireframeAttribute( geometry ) {
-
-		var property = properties.get( geometry );
-
-		if ( property.wireframe !== undefined ) {
-
-			return property.wireframe;
-
-		}
-
-		var indices = [];
-
-		var index = geometry.index;
-		var attributes = geometry.attributes;
-		var position = attributes.position;
-
-		// console.time( 'wireframe' );
-
-		if ( index !== null ) {
-
-			var edges = {};
-			var array = index.array;
-
-			for ( var i = 0, l = array.length; i < l; i += 3 ) {
-
-				var a = array[ i + 0 ];
-				var b = array[ i + 1 ];
-				var c = array[ i + 2 ];
-
-				if ( checkEdge( edges, a, b ) ) indices.push( a, b );
-				if ( checkEdge( edges, b, c ) ) indices.push( b, c );
-				if ( checkEdge( edges, c, a ) ) indices.push( c, a );
-
-			}
-
-		} else {
-
-			var array = attributes.position.array;
-
-			for ( var i = 0, l = ( array.length / 3 ) - 1; i < l; i += 3 ) {
-
-				var a = i + 0;
-				var b = i + 1;
-				var c = i + 2;
-
-				indices.push( a, b, b, c, c, a );
-
-			}
-
-		}
-
-		// console.timeEnd( 'wireframe' );
-
-		var TypeArray = position.count > 65535 ? Uint32Array : Uint16Array;
-		var attribute = new THREE.BufferAttribute( new TypeArray( indices ), 1 );
-
-		updateAttribute( attribute, gl.ELEMENT_ARRAY_BUFFER );
-
-		property.wireframe = attribute;
-
-		return attribute;
-
-	}
-
-	function checkEdge( edges, a, b ) {
-
-		if ( a > b ) {
-
-			var tmp = a;
-			a = b;
-			b = tmp;
-
-		}
-
-		var list = edges[ a ];
-
-		if ( list === undefined ) {
-
-			edges[ a ] = [ b ];
-			return true;
-
-		} else if ( list.indexOf( b ) === -1 ) {
-
-			list.push( b );
-			return true;
-
-		}
-
-		return false;
-
-	}
-
-	this.getAttributeBuffer = getAttributeBuffer;
-	this.getWireframeAttribute = getWireframeAttribute;
-
-	this.update = update;
-
-};
-
-// File:src/renderers/webgl/WebGLProgram.js
-
-THREE.WebGLProgram = ( function () {
-
-	var programIdCount = 0;
-
-	function getEncodingComponents( encoding ) {
-
-		switch ( encoding ) {
-
-			case THREE.LinearEncoding:
-				return [ 'Linear','( value )' ];
-			case THREE.sRGBEncoding:
-				return [ 'sRGB','( value )' ];
-			case THREE.RGBEEncoding:
-				return [ 'RGBE','( value )' ];
-			case THREE.RGBM7Encoding:
-				return [ 'RGBM','( value, 7.0 )' ];
-			case THREE.RGBM16Encoding:
-				return [ 'RGBM','( value, 16.0 )' ];
-			case THREE.RGBDEncoding:
-				return [ 'RGBD','( value, 256.0 )' ];
-			case THREE.GammaEncoding:
-				return [ 'Gamma','( value, float( GAMMA_FACTOR ) )' ];
-			default:
-				throw new Error( 'unsupported encoding: ' + encoding );
-
-		}
-
-	}
-
-	function getTexelDecodingFunction( functionName, encoding ) {
-
-		var components = getEncodingComponents( encoding );
-		return "vec4 " + functionName + "( vec4 value ) { return " + components[ 0 ] + "ToLinear" + components[ 1 ] + "; }";
-
-	}
-
-	function getTexelEncodingFunction( functionName, encoding ) {
-
-		var components = getEncodingComponents( encoding );
-		return "vec4 " + functionName + "( vec4 value ) { return LinearTo" + components[ 0 ] + components[ 1 ] + "; }";
-
-	}
-
-	function getToneMappingFunction( functionName, toneMapping ) {
-
-		var toneMappingName;
-
-		switch ( toneMapping ) {
-
-			case THREE.LinearToneMapping:
-				toneMappingName = "Linear";
-				break;
-
-			case THREE.ReinhardToneMapping:
-				toneMappingName = "Reinhard";
-				break;
-
-			case THREE.Uncharted2ToneMapping:
-				toneMappingName = "Uncharted2";
-				break;
-
-			case THREE.CineonToneMapping:
-				toneMappingName = "OptimizedCineon";
-				break;
-
-			default:
-				throw new Error( 'unsupported toneMapping: ' + toneMapping );
-
-		}
-
-		return "vec3 " + functionName + "( vec3 color ) { return " + toneMappingName + "ToneMapping( color ); }";
-
-	}
-
-	function generateExtensions( extensions, parameters, rendererExtensions ) {
-
-		extensions = extensions || {};
-
-		var chunks = [
-			( extensions.derivatives || parameters.envMapCubeUV || parameters.bumpMap || parameters.normalMap || parameters.flatShading ) ? '#extension GL_OES_standard_derivatives : enable' : '',
-			( extensions.fragDepth || parameters.logarithmicDepthBuffer ) && rendererExtensions.get( 'EXT_frag_depth' ) ? '#extension GL_EXT_frag_depth : enable' : '',
-			( extensions.drawBuffers ) && rendererExtensions.get( 'WEBGL_draw_buffers' ) ? '#extension GL_EXT_draw_buffers : require' : '',
-			( extensions.shaderTextureLOD || parameters.envMap ) && rendererExtensions.get( 'EXT_shader_texture_lod' ) ? '#extension GL_EXT_shader_texture_lod : enable' : '',
-		];
-
-		return chunks.filter( filterEmptyLine ).join( '\n' );
-
-	}
-
-	function generateDefines( defines ) {
-
-		var chunks = [];
-
-		for ( var name in defines ) {
-
-			var value = defines[ name ];
-
-			if ( value === false ) continue;
-
-			chunks.push( '#define ' + name + ' ' + value );
-
-		}
-
-		return chunks.join( '\n' );
-
-	}
-
-	function fetchAttributeLocations( gl, program, identifiers ) {
-
-		var attributes = {};
-
-		var n = gl.getProgramParameter( program, gl.ACTIVE_ATTRIBUTES );
-
-		for ( var i = 0; i < n; i ++ ) {
-
-			var info = gl.getActiveAttrib( program, i );
-			var name = info.name;
-
-			// console.log("THREE.WebGLProgram: ACTIVE VERTEX ATTRIBUTE:", name, i );
-
-			attributes[ name ] = gl.getAttribLocation( program, name );
-
-		}
-
-		return attributes;
-
-	}
-
-	function filterEmptyLine( string ) {
-
-		return string !== '';
-
-	}
-
-	function replaceLightNums( string, parameters ) {
-
-		return string
-			.replace( /NUM_DIR_LIGHTS/g, parameters.numDirLights )
-			.replace( /NUM_SPOT_LIGHTS/g, parameters.numSpotLights )
-			.replace( /NUM_POINT_LIGHTS/g, parameters.numPointLights )
-			.replace( /NUM_HEMI_LIGHTS/g, parameters.numHemiLights );
-
-	}
-
-	function parseIncludes( string ) {
-
-		var pattern = /#include +<([\w\d.]+)>/g;
-
-		function replace( match, include ) {
-
-			var replace = THREE.ShaderChunk[ include ];
-
-			if ( replace === undefined ) {
-
-				throw new Error( 'Can not resolve #include <' + include + '>' );
-
-			}
-
-			return parseIncludes( replace );
-
-		}
-
-		return string.replace( pattern, replace );
-
-	}
-
-	function unrollLoops( string ) {
-
-		var pattern = /for \( int i \= (\d+)\; i < (\d+)\; i \+\+ \) \{([\s\S]+?)(?=\})\}/g;
-
-		function replace( match, start, end, snippet ) {
-
-			var unroll = '';
-
-			for ( var i = parseInt( start ); i < parseInt( end ); i ++ ) {
-
-				unroll += snippet.replace( /\[ i \]/g, '[ ' + i + ' ]' );
-
-			}
-
-			return unroll;
-
-		}
-
-		return string.replace( pattern, replace );
-
-	}
-
-	return function WebGLProgram( renderer, code, material, parameters ) {
-
-		var gl = renderer.context;
-
-		var extensions = material.extensions;
-		var defines = material.defines;
-
-		var vertexShader = material.__webglShader.vertexShader;
-		var fragmentShader = material.__webglShader.fragmentShader;
-
-		var shadowMapTypeDefine = 'SHADOWMAP_TYPE_BASIC';
-
-		if ( parameters.shadowMapType === THREE.PCFShadowMap ) {
-
-			shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF';
-
-		} else if ( parameters.shadowMapType === THREE.PCFSoftShadowMap ) {
-
-			shadowMapTypeDefine = 'SHADOWMAP_TYPE_PCF_SOFT';
-
-		}
-
-		var envMapTypeDefine = 'ENVMAP_TYPE_CUBE';
-		var envMapModeDefine = 'ENVMAP_MODE_REFLECTION';
-		var envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';
-
-		if ( parameters.envMap ) {
-
-			switch ( material.envMap.mapping ) {
-
-				case THREE.CubeReflectionMapping:
-				case THREE.CubeRefractionMapping:
-					envMapTypeDefine = 'ENVMAP_TYPE_CUBE';
-					break;
-
-				case THREE.CubeUVReflectionMapping:
-				case THREE.CubeUVRefractionMapping:
-					envMapTypeDefine = 'ENVMAP_TYPE_CUBE_UV';
-					break;
-
-				case THREE.EquirectangularReflectionMapping:
-				case THREE.EquirectangularRefractionMapping:
-					envMapTypeDefine = 'ENVMAP_TYPE_EQUIREC';
-					break;
-
-				case THREE.SphericalReflectionMapping:
-					envMapTypeDefine = 'ENVMAP_TYPE_SPHERE';
-					break;
-
-			}
-
-			switch ( material.envMap.mapping ) {
-
-				case THREE.CubeRefractionMapping:
-				case THREE.EquirectangularRefractionMapping:
-					envMapModeDefine = 'ENVMAP_MODE_REFRACTION';
-					break;
-
-			}
-
-			switch ( material.combine ) {
-
-				case THREE.MultiplyOperation:
-					envMapBlendingDefine = 'ENVMAP_BLENDING_MULTIPLY';
-					break;
-
-				case THREE.MixOperation:
-					envMapBlendingDefine = 'ENVMAP_BLENDING_MIX';
-					break;
-
-				case THREE.AddOperation:
-					envMapBlendingDefine = 'ENVMAP_BLENDING_ADD';
-					break;
-
-			}
-
-		}
-
-		var gammaFactorDefine = ( renderer.gammaFactor > 0 ) ? renderer.gammaFactor : 1.0;
-
-		// console.log( 'building new program ' );
-
-		//
-
-		var customExtensions = generateExtensions( extensions, parameters, renderer.extensions );
-
-		var customDefines = generateDefines( defines );
-
-		//
-
-		var program = gl.createProgram();
-
-		var prefixVertex, prefixFragment;
-
-		if ( material instanceof THREE.RawShaderMaterial ) {
-
-			prefixVertex = '';
-			prefixFragment = '';
-
-		} else {
-
-			prefixVertex = [
-
-				'precision ' + parameters.precision + ' float;',
-				'precision ' + parameters.precision + ' int;',
-
-				'#define SHADER_NAME ' + material.__webglShader.name,
-
-				customDefines,
-
-				parameters.supportsVertexTextures ? '#define VERTEX_TEXTURES' : '',
-
-				'#define GAMMA_FACTOR ' + gammaFactorDefine,
-
-				'#define MAX_BONES ' + parameters.maxBones,
-
-				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.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.vertexColors ? '#define USE_COLOR' : '',
-
-				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' : '',
-
-				'#define NUM_CLIPPING_PLANES ' + parameters.numClippingPlanes,
-
-				parameters.shadowMapEnabled ? '#define USE_SHADOWMAP' : '',
-				parameters.shadowMapEnabled ? '#define ' + shadowMapTypeDefine : '',
-
-				parameters.sizeAttenuation ? '#define USE_SIZEATTENUATION' : '',
-
-				parameters.logarithmicDepthBuffer ? '#define USE_LOGDEPTHBUF' : '',
-				parameters.logarithmicDepthBuffer && renderer.extensions.get( 'EXT_frag_depth' ) ? '#define USE_LOGDEPTHBUF_EXT' : '',
-
-				'uniform mat4 modelMatrix;',
-				'uniform mat4 modelViewMatrix;',
-				'uniform mat4 projectionMatrix;',
-				'uniform mat4 viewMatrix;',
-				'uniform mat3 normalMatrix;',
-				'uniform vec3 cameraPosition;',
-
-				'attribute vec3 position;',
-				'attribute vec3 normal;',
-				'attribute vec2 uv;',
-
-				'#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,
-
-				'precision ' + parameters.precision + ' float;',
-				'precision ' + parameters.precision + ' int;',
-
-				'#define SHADER_NAME ' + material.__webglShader.name,
-
-				customDefines,
-
-				parameters.alphaTest ? '#define ALPHATEST ' + parameters.alphaTest : '',
-
-				'#define GAMMA_FACTOR ' + gammaFactorDefine,
-
-				( parameters.useFog && parameters.fog ) ? '#define USE_FOG' : '',
-				( parameters.useFog && parameters.fogExp ) ? '#define FOG_EXP2' : '',
-
-				parameters.map ? '#define USE_MAP' : '',
-				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.specularMap ? '#define USE_SPECULARMAP' : '',
-				parameters.roughnessMap ? '#define USE_ROUGHNESSMAP' : '',
-				parameters.metalnessMap ? '#define USE_METALNESSMAP' : '',
-				parameters.alphaMap ? '#define USE_ALPHAMAP' : '',
-				parameters.vertexColors ? '#define USE_COLOR' : '',
-
-				parameters.flatShading ? '#define FLAT_SHADED' : '',
-
-				parameters.doubleSided ? '#define DOUBLE_SIDED' : '',
-				parameters.flipSided ? '#define FLIP_SIDED' : '',
-
-				'#define NUM_CLIPPING_PLANES ' + parameters.numClippingPlanes,
-
-				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 && renderer.extensions.get( 'EXT_frag_depth' ) ? '#define USE_LOGDEPTHBUF_EXT' : '',
-
-				parameters.envMap && renderer.extensions.get( 'EXT_shader_texture_lod' ) ? '#define TEXTURE_LOD_EXT' : '',
-
-				'uniform mat4 viewMatrix;',
-				'uniform vec3 cameraPosition;',
-
-				( parameters.toneMapping !== THREE.NoToneMapping ) ? "#define TONE_MAPPING" : '',
-				( parameters.toneMapping !== THREE.NoToneMapping ) ? THREE.ShaderChunk[ 'tonemapping_pars_fragment' ] : '',  // this code is required here because it is used by the toneMapping() function defined below
-				( parameters.toneMapping !== THREE.NoToneMapping ) ? getToneMappingFunction( "toneMapping", parameters.toneMapping ) : '',
-
-				( parameters.outputEncoding || parameters.mapEncoding || parameters.envMapEncoding || parameters.emissiveMapEncoding ) ? THREE.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.envMapEncoding ? getTexelDecodingFunction( 'envMapTexelToLinear', parameters.envMapEncoding ) : '',
-				parameters.emissiveMapEncoding ? getTexelDecodingFunction( 'emissiveMapTexelToLinear', parameters.emissiveMapEncoding ) : '',
-				parameters.outputEncoding ? getTexelEncodingFunction( "linearToOutputTexel", parameters.outputEncoding ) : '',
-
-				parameters.depthPacking ? "#define DEPTH_PACKING " + material.depthPacking : '',
-
-				'\n'
-
-			].filter( filterEmptyLine ).join( '\n' );
-
-		}
-
-		vertexShader = parseIncludes( vertexShader, parameters );
-		vertexShader = replaceLightNums( vertexShader, parameters );
-
-		fragmentShader = parseIncludes( fragmentShader, parameters );
-		fragmentShader = replaceLightNums( fragmentShader, parameters );
-
-		if ( material instanceof THREE.ShaderMaterial === false ) {
-
-			vertexShader = unrollLoops( vertexShader );
-			fragmentShader = unrollLoops( fragmentShader );
-
-		}
-
-		var vertexGlsl = prefixVertex + vertexShader;
-		var fragmentGlsl = prefixFragment + fragmentShader;
-
-		// console.log( '*VERTEX*', vertexGlsl );
-		// console.log( '*FRAGMENT*', fragmentGlsl );
-
-		var glVertexShader = THREE.WebGLShader( gl, gl.VERTEX_SHADER, vertexGlsl );
-		var glFragmentShader = THREE.WebGLShader( gl, gl.FRAGMENT_SHADER, fragmentGlsl );
-
-		gl.attachShader( program, glVertexShader );
-		gl.attachShader( program, glFragmentShader );
-
-		// Force a particular attribute to index 0.
-
-		if ( material.index0AttributeName !== undefined ) {
-
-			gl.bindAttribLocation( program, 0, material.index0AttributeName );
-
-		} else if ( parameters.morphTargets === true ) {
-
-			// programs with morphTargets displace position out of attribute 0
-			gl.bindAttribLocation( program, 0, 'position' );
-
-		}
-
-		gl.linkProgram( program );
-
-		var programLog = gl.getProgramInfoLog( program );
-		var vertexLog = gl.getShaderInfoLog( glVertexShader );
-		var fragmentLog = gl.getShaderInfoLog( glFragmentShader );
-
-		var runnable = true;
-		var haveDiagnostics = true;
-
-		// console.log( '**VERTEX**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glVertexShader ) );
-		// console.log( '**FRAGMENT**', gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( glFragmentShader ) );
-
-		if ( gl.getProgramParameter( program, gl.LINK_STATUS ) === false ) {
-
-			runnable = false;
-
-			console.error( 'THREE.WebGLProgram: shader error: ', gl.getError(), 'gl.VALIDATE_STATUS', gl.getProgramParameter( program, gl.VALIDATE_STATUS ), 'gl.getProgramInfoLog', programLog, vertexLog, fragmentLog );
-
-		} else if ( programLog !== '' ) {
-
-			console.warn( 'THREE.WebGLProgram: gl.getProgramInfoLog()', programLog );
-
-		} else if ( vertexLog === '' || fragmentLog === '' ) {
-
-			haveDiagnostics = false;
-
-		}
-
-		if ( haveDiagnostics ) {
-
-			this.diagnostics = {
-
-				runnable: runnable,
-				material: material,
-
-				programLog: programLog,
-
-				vertexShader: {
-
-					log: vertexLog,
-					prefix: prefixVertex
-
-				},
-
-				fragmentShader: {
-
-					log: fragmentLog,
-					prefix: prefixFragment
-
-				}
-
-			};
-
-		}
-
-		// clean up
-
-		gl.deleteShader( glVertexShader );
-		gl.deleteShader( glFragmentShader );
-
-		// set up caching for uniform locations
-
-		var cachedUniforms;
-
-		this.getUniforms = function() {
-
-			if ( cachedUniforms === undefined ) {
-
-				cachedUniforms =
-						new THREE.WebGLUniforms( gl, program, renderer );
-
-			}
-
-			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;
-
-		};
-
-		// DEPRECATED
-
-		Object.defineProperties( this, {
-
-			uniforms: {
-				get: function() {
-
-					console.warn( 'THREE.WebGLProgram: .uniforms is now .getUniforms().' );
-					return this.getUniforms();
-
-				}
-			},
-
-			attributes: {
-				get: function() {
-
-					console.warn( 'THREE.WebGLProgram: .attributes is now .getAttributes().' );
-					return this.getAttributes();
-
-				}
-			}
-
-		} );
-
-
-		//
-
-		this.id = programIdCount ++;
-		this.code = code;
-		this.usedTimes = 1;
-		this.program = program;
-		this.vertexShader = glVertexShader;
-		this.fragmentShader = glFragmentShader;
-
-		return this;
-
-	};
-
-} )();
-
-// File:src/renderers/webgl/WebGLPrograms.js
-
-THREE.WebGLPrograms = function ( renderer, capabilities ) {
-
-	var programs = [];
-
-	var shaderIDs = {
-		MeshDepthMaterial: 'depth',
-		MeshNormalMaterial: 'normal',
-		MeshBasicMaterial: 'basic',
-		MeshLambertMaterial: 'lambert',
-		MeshPhongMaterial: 'phong',
-		MeshStandardMaterial: 'physical',
-		MeshPhysicalMaterial: 'physical',
-		LineBasicMaterial: 'basic',
-		LineDashedMaterial: 'dashed',
-		PointsMaterial: 'points'
-	};
-
-	var parameterNames = [
-		"precision", "supportsVertexTextures", "map", "mapEncoding", "envMap", "envMapMode", "envMapEncoding",
-		"lightMap", "aoMap", "emissiveMap", "emissiveMapEncoding", "bumpMap", "normalMap", "displacementMap", "specularMap",
-		"roughnessMap", "metalnessMap",
-		"alphaMap", "combine", "vertexColors", "fog", "useFog", "fogExp",
-		"flatShading", "sizeAttenuation", "logarithmicDepthBuffer", "skinning",
-		"maxBones", "useVertexTexture", "morphTargets", "morphNormals",
-		"maxMorphTargets", "maxMorphNormals", "premultipliedAlpha",
-		"numDirLights", "numPointLights", "numSpotLights", "numHemiLights",
-		"shadowMapEnabled", "shadowMapType", "toneMapping", 'physicallyCorrectLights',
-		"alphaTest", "doubleSided", "flipSided", "numClippingPlanes", "depthPacking"
-	];
-
-
-	function allocateBones ( object ) {
-
-		if ( capabilities.floatVertexTextures && object && object.skeleton && object.skeleton.useVertexTexture ) {
-
-			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 = capabilities.maxVertexUniforms;
-			var nVertexMatrices = Math.floor( ( nVertexUniforms - 20 ) / 4 );
-
-			var maxBones = nVertexMatrices;
-
-			if ( object !== undefined && object instanceof THREE.SkinnedMesh ) {
-
-				maxBones = Math.min( object.skeleton.bones.length, maxBones );
-
-				if ( maxBones < object.skeleton.bones.length ) {
-
-					console.warn( 'WebGLRenderer: too many bones - ' + object.skeleton.bones.length + ', this GPU supports just ' + maxBones + ' (try OpenGL instead of ANGLE)' );
-
-				}
-
-			}
-
-			return maxBones;
-
-		}
-
-	}
-
-	function getTextureEncodingFromMap( map, gammaOverrideLinear ) {
-
-		var encoding;
-
-		if ( ! map ) {
-
-			encoding = THREE.LinearEncoding;
-
-		} else if ( map instanceof THREE.Texture ) {
-
-			encoding = map.encoding;
-
-		} else if ( map instanceof THREE.WebGLRenderTarget ) {
-
-			encoding = map.texture.encoding;
-
-		}
-
-		// add backwards compatibility for WebGLRenderer.gammaInput/gammaOutput parameter, should probably be removed at some point.
-		if ( encoding === THREE.LinearEncoding && gammaOverrideLinear ) {
-
-			encoding = THREE.GammaEncoding;
-
-		}
-
-		return encoding;
-
-	}
-
-	this.getParameters = function ( material, lights, fog, nClipPlanes, object ) {
-
-		var shaderID = shaderIDs[ material.type ];
-
-		// heuristics to create shader parameters according to lights in the scene
-		// (not to blow over maxLights budget)
-
-		var maxBones = allocateBones( object );
-		var precision = renderer.getPrecision();
-
-		if ( material.precision !== null ) {
-
-			precision = capabilities.getMaxPrecision( material.precision );
-
-			if ( precision !== material.precision ) {
-
-				console.warn( 'THREE.WebGLProgram.getParameters:', material.precision, 'not supported, using', precision, 'instead.' );
-
-			}
-
-		}
-
-		var parameters = {
-
-			shaderID: shaderID,
-
-			precision: precision,
-			supportsVertexTextures: capabilities.vertexTextures,
-			outputEncoding: getTextureEncodingFromMap( renderer.getCurrentRenderTarget(), renderer.gammaOutput ),
-			map: !! material.map,
-			mapEncoding: getTextureEncodingFromMap( material.map, renderer.gammaInput ),
-			envMap: !! material.envMap,
-			envMapMode: material.envMap && material.envMap.mapping,
-			envMapEncoding: getTextureEncodingFromMap( material.envMap, renderer.gammaInput ),
-			envMapCubeUV: ( !! material.envMap ) && ( ( material.envMap.mapping === THREE.CubeUVReflectionMapping ) || ( material.envMap.mapping === THREE.CubeUVRefractionMapping ) ),
-			lightMap: !! material.lightMap,
-			aoMap: !! material.aoMap,
-			emissiveMap: !! material.emissiveMap,
-			emissiveMapEncoding: getTextureEncodingFromMap( material.emissiveMap, renderer.gammaInput ),
-			bumpMap: !! material.bumpMap,
-			normalMap: !! material.normalMap,
-			displacementMap: !! material.displacementMap,
-			roughnessMap: !! material.roughnessMap,
-			metalnessMap: !! material.metalnessMap,
-			specularMap: !! material.specularMap,
-			alphaMap: !! material.alphaMap,
-
-			combine: material.combine,
-
-			vertexColors: material.vertexColors,
-
-			fog: fog,
-			useFog: material.fog,
-			fogExp: fog instanceof THREE.FogExp2,
-
-			flatShading: material.shading === THREE.FlatShading,
-
-			sizeAttenuation: material.sizeAttenuation,
-			logarithmicDepthBuffer: capabilities.logarithmicDepthBuffer,
-
-			skinning: material.skinning,
-			maxBones: maxBones,
-			useVertexTexture: capabilities.floatVertexTextures && object && object.skeleton && object.skeleton.useVertexTexture,
-
-			morphTargets: material.morphTargets,
-			morphNormals: material.morphNormals,
-			maxMorphTargets: renderer.maxMorphTargets,
-			maxMorphNormals: renderer.maxMorphNormals,
-
-			numDirLights: lights.directional.length,
-			numPointLights: lights.point.length,
-			numSpotLights: lights.spot.length,
-			numHemiLights: lights.hemi.length,
-
-			numClippingPlanes: nClipPlanes,
-
-			shadowMapEnabled: renderer.shadowMap.enabled && object.receiveShadow && lights.shadows.length > 0,
-			shadowMapType: renderer.shadowMap.type,
-
-			toneMapping: renderer.toneMapping,
-			physicallyCorrectLights: renderer.physicallyCorrectLights,
-
-			premultipliedAlpha: material.premultipliedAlpha,
-
-			alphaTest: material.alphaTest,
-			doubleSided: material.side === THREE.DoubleSide,
-			flipSided: material.side === THREE.BackSide,
-
-			depthPacking: ( material.depthPacking !== undefined ) ? material.depthPacking : false
-
-		};
-
-		return parameters;
-
-	};
-
-	this.getProgramCode = function ( material, parameters ) {
-
-		var array = [];
-
-		if ( parameters.shaderID ) {
-
-			array.push( parameters.shaderID );
-
-		} else {
-
-			array.push( material.fragmentShader );
-			array.push( material.vertexShader );
-
-		}
-
-		if ( material.defines !== undefined ) {
-
-			for ( var name in material.defines ) {
-
-				array.push( name );
-				array.push( material.defines[ name ] );
-
-			}
-
-		}
-
-		for ( var i = 0; i < parameterNames.length; i ++ ) {
-
-			array.push( parameters[ parameterNames[ i ] ] );
-
-		}
-
-		return array.join();
-
-	};
-
-	this.acquireProgram = function ( material, parameters, code ) {
-
-		var program;
-
-		// Check if code has been already compiled
-		for ( var p = 0, pl = programs.length; p < pl; p ++ ) {
-
-			var programInfo = programs[ p ];
-
-			if ( programInfo.code === code ) {
-
-				program = programInfo;
-				++ program.usedTimes;
-
-				break;
-
-			}
-
-		}
-
-		if ( program === undefined ) {
-
-			program = new THREE.WebGLProgram( renderer, code, material, parameters );
-			programs.push( program );
-
-		}
-
-		return program;
-
-	};
-
-	this.releaseProgram = function( program ) {
-
-		if ( -- program.usedTimes === 0 ) {
-
-			// Remove from unordered set
-			var i = programs.indexOf( program );
-			programs[ i ] = programs[ programs.length - 1 ];
-			programs.pop();
-
-			// Free WebGL resources
-			program.destroy();
-
-		}
-
-	};
-
-	// Exposed for resource monitoring & error feedback via renderer.info:
-	this.programs = programs;
-
-};
-
-// File:src/renderers/webgl/WebGLProperties.js
-
-/**
-* @author fordacious / fordacious.github.io
-*/
-
-THREE.WebGLProperties = function () {
-
-	var properties = {};
-
-	this.get = function ( object ) {
-
-		var uuid = object.uuid;
-		var map = properties[ uuid ];
-
-		if ( map === undefined ) {
-
-			map = {};
-			properties[ uuid ] = map;
-
-		}
-
-		return map;
-
-	};
-
-	this.delete = function ( object ) {
-
-		delete properties[ object.uuid ];
-
-	};
-
-	this.clear = function () {
-
-		properties = {};
-
-	};
-
-};
-
-// File:src/renderers/webgl/WebGLShader.js
-
-THREE.WebGLShader = ( function () {
-
-	function addLineNumbers( string ) {
-
-		var lines = string.split( '\n' );
-
-		for ( var i = 0; i < lines.length; i ++ ) {
-
-			lines[ i ] = ( i + 1 ) + ': ' + lines[ i ];
-
-		}
-
-		return lines.join( '\n' );
-
-	}
-
-	return function WebGLShader( gl, type, string ) {
-
-		var shader = gl.createShader( type );
-
-		gl.shaderSource( shader, string );
-		gl.compileShader( shader );
-
-		if ( gl.getShaderParameter( shader, gl.COMPILE_STATUS ) === false ) {
-
-			console.error( 'THREE.WebGLShader: Shader couldn\'t compile.' );
-
-		}
-
-		if ( gl.getShaderInfoLog( shader ) !== '' ) {
-
-			console.warn( 'THREE.WebGLShader: gl.getShaderInfoLog()', type === gl.VERTEX_SHADER ? 'vertex' : 'fragment', gl.getShaderInfoLog( shader ), addLineNumbers( string ) );
-
-		}
-
-		// --enable-privileged-webgl-extension
-		// console.log( type, gl.getExtension( 'WEBGL_debug_shaders' ).getTranslatedShaderSource( shader ) );
-
-		return shader;
-
-	};
-
-} )();
-
-// File:src/renderers/webgl/WebGLShadowMap.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.WebGLShadowMap = function ( _renderer, _lights, _objects ) {
-
-	var _gl = _renderer.context,
-	_state = _renderer.state,
-	_frustum = new THREE.Frustum(),
-	_projScreenMatrix = new THREE.Matrix4(),
-
-	_lightShadows = _lights.shadows,
-
-	_shadowMapSize = new THREE.Vector2(),
-
-	_lookTarget = new THREE.Vector3(),
-	_lightPositionWorld = new THREE.Vector3(),
-
-	_renderList = [],
-
-	_MorphingFlag = 1,
-	_SkinningFlag = 2,
-
-	_NumberOfMaterialVariants = ( _MorphingFlag | _SkinningFlag ) + 1,
-
-	_depthMaterials = new Array( _NumberOfMaterialVariants ),
-	_distanceMaterials = new Array( _NumberOfMaterialVariants ),
-
-	_materialCache = {};
-
-	var cubeDirections = [
-		new THREE.Vector3( 1, 0, 0 ), new THREE.Vector3( - 1, 0, 0 ), new THREE.Vector3( 0, 0, 1 ),
-		new THREE.Vector3( 0, 0, - 1 ), new THREE.Vector3( 0, 1, 0 ), new THREE.Vector3( 0, - 1, 0 )
-	];
-
-	var cubeUps = [
-		new THREE.Vector3( 0, 1, 0 ), new THREE.Vector3( 0, 1, 0 ), new THREE.Vector3( 0, 1, 0 ),
-		new THREE.Vector3( 0, 1, 0 ), new THREE.Vector3( 0, 0, 1 ),	new THREE.Vector3( 0, 0, - 1 )
-	];
-
-	var cube2DViewPorts = [
-		new THREE.Vector4(), new THREE.Vector4(), new THREE.Vector4(),
-		new THREE.Vector4(), new THREE.Vector4(), new THREE.Vector4()
-	];
-
-	// init
-
-	var depthMaterialTemplate = new THREE.MeshDepthMaterial();
-	depthMaterialTemplate.depthPacking = THREE.RGBADepthPacking;
-	depthMaterialTemplate.clipping = true;
-
-	var distanceShader = THREE.ShaderLib[ "distanceRGBA" ];
-	var distanceUniforms = THREE.UniformsUtils.clone( distanceShader.uniforms );
-
-	for ( var i = 0; i !== _NumberOfMaterialVariants; ++ i ) {
-
-		var useMorphing = ( i & _MorphingFlag ) !== 0;
-		var useSkinning = ( i & _SkinningFlag ) !== 0;
-
-		var depthMaterial = depthMaterialTemplate.clone();
-		depthMaterial.morphTargets = useMorphing;
-		depthMaterial.skinning = useSkinning;
-
-		_depthMaterials[ i ] = depthMaterial;
-
-		var distanceMaterial = new THREE.ShaderMaterial( {
-			defines: {
-				'USE_SHADOWMAP': ''
-			},
-			uniforms: distanceUniforms,
-			vertexShader: distanceShader.vertexShader,
-			fragmentShader: distanceShader.fragmentShader,
-			morphTargets: useMorphing,
-			skinning: useSkinning,
-			clipping: true
-		} );
-
-		_distanceMaterials[ i ] = distanceMaterial;
-
-	}
-
-	//
-
-	var scope = this;
-
-	this.enabled = false;
-
-	this.autoUpdate = true;
-	this.needsUpdate = false;
-
-	this.type = THREE.PCFShadowMap;
-	this.cullFace = THREE.CullFaceFront;
-
-	this.render = function ( scene, camera ) {
-
-		if ( scope.enabled === false ) return;
-		if ( scope.autoUpdate === false && scope.needsUpdate === false ) return;
-
-		if ( _lightShadows.length === 0 ) return;
-
-		// Set GL state for depth map.
-		_state.clearColor( 1, 1, 1, 1 );
-		_state.disable( _gl.BLEND );
-		_state.enable( _gl.CULL_FACE );
-		_gl.frontFace( _gl.CCW );
-		_gl.cullFace( scope.cullFace === THREE.CullFaceFront ? _gl.FRONT : _gl.BACK );
-		_state.setDepthTest( true );
-		_state.setScissorTest( false );
-
-		// render depth map
-
-		var faceCount, isPointLight;
-
-		for ( var i = 0, il = _lightShadows.length; i < il; i ++ ) {
-
-			var light = _lightShadows[ i ];
-
-			var shadow = light.shadow;
-			var shadowCamera = shadow.camera;
-
-			_shadowMapSize.copy( shadow.mapSize );
-
-			if ( light instanceof THREE.PointLight ) {
-
-				faceCount = 6;
-				isPointLight = true;
-
-				var vpWidth = _shadowMapSize.x;
-				var vpHeight = _shadowMapSize.y;
-
-				// These viewports map a cube-map onto a 2D texture with the
-				// following orientation:
-				//
-				//  xzXZ
-				//   y Y
-				//
-				// X - Positive x direction
-				// x - Negative x direction
-				// Y - Positive y direction
-				// y - Negative y direction
-				// Z - Positive z direction
-				// z - Negative z direction
-
-				// positive X
-				cube2DViewPorts[ 0 ].set( vpWidth * 2, vpHeight, vpWidth, vpHeight );
-				// negative X
-				cube2DViewPorts[ 1 ].set( 0, vpHeight, vpWidth, vpHeight );
-				// positive Z
-				cube2DViewPorts[ 2 ].set( vpWidth * 3, vpHeight, vpWidth, vpHeight );
-				// negative Z
-				cube2DViewPorts[ 3 ].set( vpWidth, vpHeight, vpWidth, vpHeight );
-				// positive Y
-				cube2DViewPorts[ 4 ].set( vpWidth * 3, 0, vpWidth, vpHeight );
-				// negative Y
-				cube2DViewPorts[ 5 ].set( vpWidth, 0, vpWidth, vpHeight );
-
-				_shadowMapSize.x *= 4.0;
-				_shadowMapSize.y *= 2.0;
-
-			} else {
-
-				faceCount = 1;
-				isPointLight = false;
-
-			}
-
-			if ( shadow.map === null ) {
-
-				var pars = { minFilter: THREE.NearestFilter, magFilter: THREE.NearestFilter, format: THREE.RGBAFormat };
-
-				shadow.map = new THREE.WebGLRenderTarget( _shadowMapSize.x, _shadowMapSize.y, pars );
-
-				shadowCamera.updateProjectionMatrix();
-
-			}
-
-			if ( shadow instanceof THREE.SpotLightShadow ) {
-
-				shadow.update( light );
-
-			}
-
-			var shadowMap = shadow.map;
-			var shadowMatrix = shadow.matrix;
-
-			_lightPositionWorld.setFromMatrixPosition( light.matrixWorld );
-			shadowCamera.position.copy( _lightPositionWorld );
-
-			_renderer.setRenderTarget( shadowMap );
-			_renderer.clear();
-
-			// render shadow map for each cube face (if omni-directional) or
-			// run a single pass if not
-
-			for ( var face = 0; face < faceCount; face ++ ) {
-
-				if ( isPointLight ) {
-
-					_lookTarget.copy( shadowCamera.position );
-					_lookTarget.add( cubeDirections[ face ] );
-					shadowCamera.up.copy( cubeUps[ face ] );
-					shadowCamera.lookAt( _lookTarget );
-
-					var vpDimensions = cube2DViewPorts[ face ];
-					_state.viewport( vpDimensions );
-
-				} else {
-
-					_lookTarget.setFromMatrixPosition( light.target.matrixWorld );
-					shadowCamera.lookAt( _lookTarget );
-
-				}
-
-				shadowCamera.updateMatrixWorld();
-				shadowCamera.matrixWorldInverse.getInverse( shadowCamera.matrixWorld );
-
-				// compute shadow matrix
-
-				shadowMatrix.set(
-					0.5, 0.0, 0.0, 0.5,
-					0.0, 0.5, 0.0, 0.5,
-					0.0, 0.0, 0.5, 0.5,
-					0.0, 0.0, 0.0, 1.0
-				);
-
-				shadowMatrix.multiply( shadowCamera.projectionMatrix );
-				shadowMatrix.multiply( shadowCamera.matrixWorldInverse );
-
-				// update camera matrices and frustum
-
-				_projScreenMatrix.multiplyMatrices( shadowCamera.projectionMatrix, shadowCamera.matrixWorldInverse );
-				_frustum.setFromMatrix( _projScreenMatrix );
-
-				// set object matrices & frustum culling
-
-				_renderList.length = 0;
-
-				projectObject( scene, camera, shadowCamera );
-
-				// render shadow map
-				// render regular objects
-
-				for ( var j = 0, jl = _renderList.length; j < jl; j ++ ) {
-
-					var object = _renderList[ j ];
-					var geometry = _objects.update( object );
-					var material = object.material;
-
-					if ( material instanceof THREE.MultiMaterial ) {
-
-						var groups = geometry.groups;
-						var materials = material.materials;
-
-						for ( var k = 0, kl = groups.length; k < kl; k ++ ) {
-
-							var group = groups[ k ];
-							var groupMaterial = materials[ group.materialIndex ];
-
-							if ( groupMaterial.visible === true ) {
-
-								var depthMaterial = getDepthMaterial( object, groupMaterial, isPointLight, _lightPositionWorld );
-								_renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, group );
-
-							}
-
-						}
-
-					} else {
-
-						var depthMaterial = getDepthMaterial( object, material, isPointLight, _lightPositionWorld );
-						_renderer.renderBufferDirect( shadowCamera, null, geometry, depthMaterial, object, null );
-
-					}
-
-				}
-
-			}
-
-		}
-
-		// Restore GL state.
-		var clearColor = _renderer.getClearColor(),
-		clearAlpha = _renderer.getClearAlpha();
-		_renderer.setClearColor( clearColor, clearAlpha );
-
-		_state.enable( _gl.BLEND );
-
-		if ( scope.cullFace === THREE.CullFaceFront ) {
-
-			_gl.cullFace( _gl.BACK );
-
-		}
-
-		scope.needsUpdate = false;
-
-	};
-
-	function getDepthMaterial( object, material, isPointLight, lightPositionWorld ) {
-
-		var geometry = object.geometry;
-
-		var result = null;
-
-		var materialVariants = _depthMaterials;
-		var customMaterial = object.customDepthMaterial;
-
-		if ( isPointLight ) {
-
-			materialVariants = _distanceMaterials;
-			customMaterial = object.customDistanceMaterial;
-
-		}
-
-		if ( ! customMaterial ) {
-
-			var useMorphing = geometry.morphTargets !== undefined &&
-					geometry.morphTargets.length > 0 && material.morphTargets;
-
-			var useSkinning = object instanceof THREE.SkinnedMesh && material.skinning;
-
-			var variantIndex = 0;
-
-			if ( useMorphing ) variantIndex |= _MorphingFlag;
-			if ( useSkinning ) variantIndex |= _SkinningFlag;
-
-			result = materialVariants[ variantIndex ];
-
-		} 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;
-		result.side = material.side;
-		result.clipShadows = material.clipShadows;
-		result.clippingPlanes = material.clippingPlanes;
-		result.wireframeLinewidth = material.wireframeLinewidth;
-		result.linewidth = material.linewidth;
-
-		if ( isPointLight && result.uniforms.lightPos !== undefined ) {
-
-			result.uniforms.lightPos.value.copy( lightPositionWorld );
-
-		}
-
-		return result;
-
-	}
-
-	function projectObject( object, camera, shadowCamera ) {
-
-		if ( object.visible === false ) return;
-
-		if ( object.layers.test( camera.layers ) && ( object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Points ) ) {
-
-			if ( object.castShadow && ( object.frustumCulled === false || _frustum.intersectsObject( object ) === true ) ) {
-
-				var material = object.material;
-
-				if ( material.visible === true ) {
-
-					object.modelViewMatrix.multiplyMatrices( shadowCamera.matrixWorldInverse, object.matrixWorld );
-					_renderList.push( object );
-
-				}
-
-			}
-
-		}
-
-		var children = object.children;
-
-		for ( var i = 0, l = children.length; i < l; i ++ ) {
-
-			projectObject( children[ i ], camera, shadowCamera );
-
-		}
-
-	}
-
-};
-
-// File:src/renderers/webgl/WebGLState.js
-
-/**
-* @author mrdoob / http://mrdoob.com/
-*/
-
-THREE.WebGLState = function ( gl, extensions, paramThreeToGL ) {
-
-	var _this = this;
-
-	var color = new THREE.Vector4();
-
-	var maxVertexAttributes = gl.getParameter( gl.MAX_VERTEX_ATTRIBS );
-	var newAttributes = new Uint8Array( maxVertexAttributes );
-	var enabledAttributes = new Uint8Array( maxVertexAttributes );
-	var attributeDivisors = new Uint8Array( maxVertexAttributes );
-
-	var capabilities = {};
-
-	var compressedTextureFormats = null;
-
-	var currentBlending = null;
-	var currentBlendEquation = null;
-	var currentBlendSrc = null;
-	var currentBlendDst = null;
-	var currentBlendEquationAlpha = null;
-	var currentBlendSrcAlpha = null;
-	var currentBlendDstAlpha = null;
-	var currentPremultipledAlpha = false;
-
-	var currentDepthFunc = null;
-	var currentDepthWrite = null;
-
-	var currentColorWrite = null;
-
-	var currentStencilWrite = null;
-	var currentStencilFunc = null;
-	var currentStencilRef = null;
-	var currentStencilMask = null;
-	var currentStencilFail  = null;
-	var currentStencilZFail = null;
-	var currentStencilZPass = null;
-
-	var currentFlipSided = null;
-
-	var currentLineWidth = null;
-
-	var currentPolygonOffsetFactor = null;
-	var currentPolygonOffsetUnits = null;
-
-	var currentScissorTest = null;
-
-	var maxTextures = gl.getParameter( gl.MAX_TEXTURE_IMAGE_UNITS );
-
-	var currentTextureSlot = undefined;
-	var currentBoundTextures = {};
-
-	var currentClearColor = new THREE.Vector4();
-	var currentClearDepth = null;
-	var currentClearStencil = null;
-
-	var currentScissor = new THREE.Vector4();
-	var currentViewport = new THREE.Vector4();
-
-	this.init = function () {
-
-		this.clearColor( 0, 0, 0, 1 );
-		this.clearDepth( 1 );
-		this.clearStencil( 0 );
-
-		this.enable( gl.DEPTH_TEST );
-		gl.depthFunc( gl.LEQUAL );
-
-		gl.frontFace( gl.CCW );
-		gl.cullFace( gl.BACK );
-		this.enable( gl.CULL_FACE );
-
-		this.enable( gl.BLEND );
-		gl.blendEquation( gl.FUNC_ADD );
-		gl.blendFunc( gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA );
-
-	};
-
-	this.initAttributes = function () {
-
-		for ( var i = 0, l = newAttributes.length; i < l; i ++ ) {
-
-			newAttributes[ i ] = 0;
-
-		}
-
-	};
-
-	this.enableAttribute = function ( attribute ) {
-
-		newAttributes[ attribute ] = 1;
-
-		if ( enabledAttributes[ attribute ] === 0 ) {
-
-			gl.enableVertexAttribArray( attribute );
-			enabledAttributes[ attribute ] = 1;
-
-		}
-
-		if ( attributeDivisors[ attribute ] !== 0 ) {
-
-			var extension = extensions.get( 'ANGLE_instanced_arrays' );
-
-			extension.vertexAttribDivisorANGLE( attribute, 0 );
-			attributeDivisors[ attribute ] = 0;
-
-		}
-
-	};
-
-	this.enableAttributeAndDivisor = function ( attribute, meshPerAttribute, extension ) {
-
-		newAttributes[ attribute ] = 1;
-
-		if ( enabledAttributes[ attribute ] === 0 ) {
-
-			gl.enableVertexAttribArray( attribute );
-			enabledAttributes[ attribute ] = 1;
-
-		}
-
-		if ( attributeDivisors[ attribute ] !== meshPerAttribute ) {
-
-			extension.vertexAttribDivisorANGLE( attribute, meshPerAttribute );
-			attributeDivisors[ attribute ] = meshPerAttribute;
-
-		}
-
-	};
-
-	this.disableUnusedAttributes = function () {
-
-		for ( var i = 0, l = enabledAttributes.length; i < l; i ++ ) {
-
-			if ( enabledAttributes[ i ] !== newAttributes[ i ] ) {
-
-				gl.disableVertexAttribArray( i );
-				enabledAttributes[ i ] = 0;
-
-			}
-
-		}
-
-	};
-
-	this.enable = function ( id ) {
-
-		if ( capabilities[ id ] !== true ) {
-
-			gl.enable( id );
-			capabilities[ id ] = true;
-
-		}
-
-	};
-
-	this.disable = function ( id ) {
-
-		if ( capabilities[ id ] !== false ) {
-
-			gl.disable( id );
-			capabilities[ id ] = false;
-
-		}
-
-	};
-
-	this.getCompressedTextureFormats = function () {
-
-		if ( compressedTextureFormats === null ) {
-
-			compressedTextureFormats = [];
-
-			if ( extensions.get( 'WEBGL_compressed_texture_pvrtc' ) ||
-			     extensions.get( 'WEBGL_compressed_texture_s3tc' ) ||
-			     extensions.get( 'WEBGL_compressed_texture_etc1' ) ) {
-
-				var formats = gl.getParameter( gl.COMPRESSED_TEXTURE_FORMATS );
-
-				for ( var i = 0; i < formats.length; i ++ ) {
-
-					compressedTextureFormats.push( formats[ i ] );
-
-				}
-
-			}
-
-		}
-
-		return compressedTextureFormats;
-
-	};
-
-	this.setBlending = function ( blending, blendEquation, blendSrc, blendDst, blendEquationAlpha, blendSrcAlpha, blendDstAlpha, premultipliedAlpha ) {
-
-		if ( blending === THREE.NoBlending ) {
-
-			this.disable( gl.BLEND );
-
-		} else {
-
-			this.enable( gl.BLEND );
-
-		}
-
-		if ( blending !== currentBlending || premultipliedAlpha !== currentPremultipledAlpha ) {
-
-			if ( blending === THREE.AdditiveBlending ) {
-
-				if ( premultipliedAlpha ) {
-
-					gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );
-					gl.blendFuncSeparate( gl.ONE, gl.ONE, gl.ONE, gl.ONE );
-
-				} else {
-
-					gl.blendEquation( gl.FUNC_ADD );
-					gl.blendFunc( gl.SRC_ALPHA, gl.ONE );
-
-				}
-
-			} else if ( blending === THREE.SubtractiveBlending ) {
-
-				if ( premultipliedAlpha ) {
-
-					gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );
-					gl.blendFuncSeparate( gl.ZERO, gl.ZERO, gl.ONE_MINUS_SRC_COLOR, gl.ONE_MINUS_SRC_ALPHA );
-
-				} else {
-
-					gl.blendEquation( gl.FUNC_ADD );
-					gl.blendFunc( gl.ZERO, gl.ONE_MINUS_SRC_COLOR );
-
-				}
-
-			} else if ( blending === THREE.MultiplyBlending ) {
-
-				if ( premultipliedAlpha ) {
-
-					gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );
-					gl.blendFuncSeparate( gl.ZERO, gl.ZERO, gl.SRC_COLOR, gl.SRC_ALPHA );
-
-				} else {
-
-					gl.blendEquation( gl.FUNC_ADD );
-					gl.blendFunc( gl.ZERO, gl.SRC_COLOR );
-
-				}
-
-			} else {
-
-				if ( premultipliedAlpha ) {
-
-					gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );
-					gl.blendFuncSeparate( gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA );
-
-				} else {
-
-					gl.blendEquationSeparate( gl.FUNC_ADD, gl.FUNC_ADD );
-					gl.blendFuncSeparate( gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA );
-
-				}
-
-			}
-
-			currentBlending = blending;
-			currentPremultipledAlpha = premultipliedAlpha;
-
-		}
-
-		if ( blending === THREE.CustomBlending ) {
-
-			blendEquationAlpha = blendEquationAlpha || blendEquation;
-			blendSrcAlpha = blendSrcAlpha || blendSrc;
-			blendDstAlpha = blendDstAlpha || blendDst;
-
-			if ( blendEquation !== currentBlendEquation || blendEquationAlpha !== currentBlendEquationAlpha ) {
-
-				gl.blendEquationSeparate( paramThreeToGL( blendEquation ), paramThreeToGL( blendEquationAlpha ) );
-
-				currentBlendEquation = blendEquation;
-				currentBlendEquationAlpha = blendEquationAlpha;
-
-			}
-
-			if ( blendSrc !== currentBlendSrc || blendDst !== currentBlendDst || blendSrcAlpha !== currentBlendSrcAlpha || blendDstAlpha !== currentBlendDstAlpha ) {
-
-				gl.blendFuncSeparate( paramThreeToGL( blendSrc ), paramThreeToGL( blendDst ), paramThreeToGL( blendSrcAlpha ), paramThreeToGL( blendDstAlpha ) );
-
-				currentBlendSrc = blendSrc;
-				currentBlendDst = blendDst;
-				currentBlendSrcAlpha = blendSrcAlpha;
-				currentBlendDstAlpha = blendDstAlpha;
-
-			}
-
-		} else {
-
-			currentBlendEquation = null;
-			currentBlendSrc = null;
-			currentBlendDst = null;
-			currentBlendEquationAlpha = null;
-			currentBlendSrcAlpha = null;
-			currentBlendDstAlpha = null;
-
-		}
-
-	};
-
-	this.setDepthFunc = function ( depthFunc ) {
-
-		if ( currentDepthFunc !== depthFunc ) {
-
-			if ( depthFunc ) {
-
-				switch ( depthFunc ) {
-
-					case THREE.NeverDepth:
-
-						gl.depthFunc( gl.NEVER );
-						break;
-
-					case THREE.AlwaysDepth:
-
-						gl.depthFunc( gl.ALWAYS );
-						break;
-
-					case THREE.LessDepth:
-
-						gl.depthFunc( gl.LESS );
-						break;
-
-					case THREE.LessEqualDepth:
-
-						gl.depthFunc( gl.LEQUAL );
-						break;
-
-					case THREE.EqualDepth:
-
-						gl.depthFunc( gl.EQUAL );
-						break;
-
-					case THREE.GreaterEqualDepth:
-
-						gl.depthFunc( gl.GEQUAL );
-						break;
-
-					case THREE.GreaterDepth:
-
-						gl.depthFunc( gl.GREATER );
-						break;
-
-					case THREE.NotEqualDepth:
-
-						gl.depthFunc( gl.NOTEQUAL );
-						break;
-
-					default:
-
-						gl.depthFunc( gl.LEQUAL );
-
-				}
-
-			} else {
-
-				gl.depthFunc( gl.LEQUAL );
-
-			}
-
-			currentDepthFunc = depthFunc;
-
-		}
-
-	};
-
-	this.setDepthTest = function ( depthTest ) {
-
-		if ( depthTest ) {
-
-			this.enable( gl.DEPTH_TEST );
-
-		} else {
-
-			this.disable( gl.DEPTH_TEST );
-
-		}
-
-	};
-
-	this.setDepthWrite = function ( depthWrite ) {
-
-		// TODO: Rename to setDepthMask
-
-		if ( currentDepthWrite !== depthWrite ) {
-
-			gl.depthMask( depthWrite );
-			currentDepthWrite = depthWrite;
-
-		}
-
-	};
-
-	this.setColorWrite = function ( colorWrite ) {
-
-		// TODO: Rename to setColorMask
-
-		if ( currentColorWrite !== colorWrite ) {
-
-			gl.colorMask( colorWrite, colorWrite, colorWrite, colorWrite );
-			currentColorWrite = colorWrite;
-
-		}
-
-	};
-
-	this.setStencilFunc = function ( stencilFunc, stencilRef, stencilMask ) {
-
-		if ( currentStencilFunc !== stencilFunc ||
-				 currentStencilRef 	!== stencilRef 	||
-				 currentStencilMask !== stencilMask ) {
-
-			gl.stencilFunc( stencilFunc,  stencilRef, stencilMask );
-
-			currentStencilFunc = stencilFunc;
-			currentStencilRef  = stencilRef;
-			currentStencilMask = stencilMask;
-
-		}
-
-	};
-
-	this.setStencilOp = function ( stencilFail, stencilZFail, stencilZPass ) {
-
-		if ( currentStencilFail	 !== stencilFail 	||
-				 currentStencilZFail !== stencilZFail ||
-				 currentStencilZPass !== stencilZPass ) {
-
-			gl.stencilOp( stencilFail,  stencilZFail, stencilZPass );
-
-			currentStencilFail  = stencilFail;
-			currentStencilZFail = stencilZFail;
-			currentStencilZPass = stencilZPass;
-
-		}
-
-	};
-
-	this.setStencilTest = function ( stencilTest ) {
-
-		if ( stencilTest ) {
-
-			this.enable( gl.STENCIL_TEST );
-
-		} else {
-
-			this.disable( gl.STENCIL_TEST );
-
-		}
-
-	};
-
-	this.setStencilWrite = function ( stencilWrite ) {
-
-		// TODO: Rename to setStencilMask
-
-		if ( currentStencilWrite !== stencilWrite ) {
-
-			gl.stencilMask( stencilWrite );
-			currentStencilWrite = stencilWrite;
-
-		}
-
-	};
-
-	this.setFlipSided = function ( flipSided ) {
-
-		if ( currentFlipSided !== flipSided ) {
-
-			if ( flipSided ) {
-
-				gl.frontFace( gl.CW );
-
-			} else {
-
-				gl.frontFace( gl.CCW );
-
-			}
-
-			currentFlipSided = flipSided;
-
-		}
-
-	};
-
-	this.setLineWidth = function ( width ) {
-
-		if ( width !== currentLineWidth ) {
-
-			gl.lineWidth( width );
-
-			currentLineWidth = width;
-
-		}
-
-	};
-
-	this.setPolygonOffset = function ( polygonOffset, factor, units ) {
-
-		if ( polygonOffset ) {
-
-			this.enable( gl.POLYGON_OFFSET_FILL );
-
-		} else {
-
-			this.disable( gl.POLYGON_OFFSET_FILL );
-
-		}
-
-		if ( polygonOffset && ( currentPolygonOffsetFactor !== factor || currentPolygonOffsetUnits !== units ) ) {
-
-			gl.polygonOffset( factor, units );
-
-			currentPolygonOffsetFactor = factor;
-			currentPolygonOffsetUnits = units;
-
-		}
-
-	};
-
-	this.getScissorTest = function () {
-
-		return currentScissorTest;
-
-	};
-
-	this.setScissorTest = function ( scissorTest ) {
-
-		currentScissorTest = scissorTest;
-
-		if ( scissorTest ) {
-
-			this.enable( gl.SCISSOR_TEST );
-
-		} else {
-
-			this.disable( gl.SCISSOR_TEST );
-
-		}
-
-	};
-
-	// texture
-
-	this.activeTexture = function ( webglSlot ) {
-
-		if ( webglSlot === undefined ) webglSlot = gl.TEXTURE0 + maxTextures - 1;
-
-		if ( currentTextureSlot !== webglSlot ) {
-
-			gl.activeTexture( webglSlot );
-			currentTextureSlot = webglSlot;
-
-		}
-
-	};
-
-	this.bindTexture = function ( webglType, webglTexture ) {
-
-		if ( currentTextureSlot === undefined ) {
-
-			_this.activeTexture();
-
-		}
-
-		var boundTexture = currentBoundTextures[ currentTextureSlot ];
-
-		if ( boundTexture === undefined ) {
-
-			boundTexture = { type: undefined, texture: undefined };
-			currentBoundTextures[ currentTextureSlot ] = boundTexture;
-
-		}
-
-		if ( boundTexture.type !== webglType || boundTexture.texture !== webglTexture ) {
-
-			gl.bindTexture( webglType, webglTexture );
-
-			boundTexture.type = webglType;
-			boundTexture.texture = webglTexture;
-
-		}
-
-	};
-
-	this.compressedTexImage2D = function () {
-
-		try {
-
-			gl.compressedTexImage2D.apply( gl, arguments );
-
-		} catch ( error ) {
-
-			console.error( error );
-
-		}
-
-	};
-
-	this.texImage2D = function () {
-
-		try {
-
-			gl.texImage2D.apply( gl, arguments );
-
-		} catch ( error ) {
-
-			console.error( error );
-
-		}
-
-	};
-
-	// clear values
-
-	this.clearColor = function ( r, g, b, a ) {
-
-		color.set( r, g, b, a );
-
-		if ( currentClearColor.equals( color ) === false ) {
-
-			gl.clearColor( r, g, b, a );
-			currentClearColor.copy( color );
-
-		}
-
-	};
-
-	this.clearDepth = function ( depth ) {
-
-		if ( currentClearDepth !== depth ) {
-
-			gl.clearDepth( depth );
-			currentClearDepth = depth;
-
-		}
-
-	};
-
-	this.clearStencil = function ( stencil ) {
-
-		if ( currentClearStencil !== stencil ) {
-
-			gl.clearStencil( stencil );
-			currentClearStencil = stencil;
-
-		}
-
-	};
-
-	//
-
-	this.scissor = function ( scissor ) {
-
-		if ( currentScissor.equals( scissor ) === false ) {
-
-			gl.scissor( scissor.x, scissor.y, scissor.z, scissor.w );
-			currentScissor.copy( scissor );
-
-		}
-
-	};
-
-	this.viewport = function ( viewport ) {
-
-		if ( currentViewport.equals( viewport ) === false ) {
-
-			gl.viewport( viewport.x, viewport.y, viewport.z, viewport.w );
-			currentViewport.copy( viewport );
-
-		}
-
-	};
-
-	//
-
-	this.reset = function () {
-
-		for ( var i = 0; i < enabledAttributes.length; i ++ ) {
-
-			if ( enabledAttributes[ i ] === 1 ) {
-
-				gl.disableVertexAttribArray( i );
-				enabledAttributes[ i ] = 0;
-
-			}
-
-		}
-
-		capabilities = {};
-
-		compressedTextureFormats = null;
-
-		currentTextureSlot = undefined;
-		currentBoundTextures = {};
-
-		currentBlending = null;
-
-		currentColorWrite = null;
-		currentDepthWrite = null;
-		currentStencilWrite = null;
-
-		currentFlipSided = null;
-
-	};
-
-};
-
-// File:src/renderers/webgl/WebGLUniforms.js
-
-/**
- *
- * Uniforms of a program.
- * Those form a tree structure with a special top-level container for the root,
- * which you get by calling 'new WebGLUniforms( gl, program, renderer )'.
- *
- *
- * Properties of inner nodes including the top-level container:
- *
- * .seq - array of nested uniforms
- * .map - nested uniforms by name
- *
- *
- * Methods of all nodes except the top-level container:
- *
- * .setValue( gl, value, [renderer] )
- *
- * 		uploads a uniform value(s)
- *  	the 'renderer' parameter is needed for sampler uniforms
- *
- *
- * Static methods of the top-level container (renderer factorizations):
- *
- * .upload( gl, seq, values, renderer )
- *
- * 		sets uniforms in 'seq' to 'values[id].value'
- *
- * .seqWithValue( seq, values ) : filteredSeq
- *
- * 		filters 'seq' entries with corresponding entry in values
- *
- * .splitDynamic( seq, values ) : filteredSeq
- *
- * 		filters 'seq' entries with dynamic entry and removes them from 'seq'
- *
- *
- * Methods of the top-level container (renderer factorizations):
- *
- * .setValue( gl, name, value )
- *
- * 		sets uniform with  name 'name' to 'value'
- *
- * .set( gl, obj, prop )
- *
- * 		sets uniform from object and property with same name than uniform
- *
- * .setOptional( gl, obj, prop )
- *
- * 		like .set for an optional property of the object
- *
- *
- * @author tschw
- *
- */
-
-THREE.WebGLUniforms = ( function() { // scope
-
-	// --- Base for inner nodes (including the root) ---
-
-	var UniformContainer = function() {
-
-			this.seq = [];
-			this.map = {};
-
-		},
-
-	// --- Utilities ---
-
-	// Array Caches (provide typed arrays for temporary by size)
-
-		arrayCacheF32 = [],
-		arrayCacheI32 = [],
-
-		uncacheTemporaryArrays = function() {
-
-			arrayCacheF32.length = 0;
-			arrayCacheI32.length = 0;
-
-		},
-
-	// Flattening for arrays of vectors and matrices
-
-		flatten = function( array, nBlocks, blockSize ) {
-
-			var firstElem = array[ 0 ];
-
-			if ( firstElem <= 0 || firstElem > 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;
-
-		},
-
-	// Texture unit allocation
-
-		allocTexUnits = function( renderer, n ) {
-
-			var r = arrayCacheI32[ n ];
-
-			if ( r === undefined ) {
-
-				r = new Int32Array( n );
-				arrayCacheI32[ n ] = r;
-
-			}
-
-			for ( var i = 0; i !== n; ++ i )
-				r[ i ] = renderer.allocTextureUnit();
-
-			return r;
-
-		},
-
-	// --- Setters ---
-
-	// Note: Defining these methods externally, because they come in a bunch
-	// and this way their names minify.
-
-		// Single scalar
-
-		setValue1f = function( gl, v ) { gl.uniform1f( this.addr, v ); },
-		setValue1i = function( gl, v ) { gl.uniform1i( this.addr, v ); },
-
-		// Single float vector (from flat array or THREE.VectorN)
-
-		setValue2fv = function( gl, v ) {
-
-			if ( v.x === undefined ) gl.uniform2fv( this.addr, v );
-			else gl.uniform2f( this.addr, v.x, v.y );
-
-		},
-
-		setValue3fv = function( gl, v ) {
-
-			if ( v.x !== undefined )
-				gl.uniform3f( this.addr, v.x, v.y, v.z );
-			else if ( v.r !== undefined )
-				gl.uniform3f( this.addr, v.r, v.g, v.b );
-			else
-				gl.uniform3fv( this.addr, v );
-
-		},
-
-		setValue4fv = function( gl, v ) {
-
-			if ( v.x === undefined ) gl.uniform4fv( this.addr, v );
-			else gl.uniform4f( this.addr, v.x, v.y, v.z, v.w );
-
-		},
-
-		// Single matrix (from flat array or MatrixN)
-
-		setValue2fm = function( gl, v ) {
-
-			gl.uniformMatrix2fv( this.addr, false, v.elements || v );
-
-		},
-
-		setValue3fm = function( gl, v ) {
-
-			gl.uniformMatrix3fv( this.addr, false, v.elements || v );
-
-		},
-
-		setValue4fm = function( gl, v ) {
-
-			gl.uniformMatrix4fv( this.addr, false, v.elements || v );
-
-		},
-
-		// Single texture (2D / Cube)
-
-		setValueT1 = function( gl, v, renderer ) {
-
-			var unit = renderer.allocTextureUnit();
-			gl.uniform1i( this.addr, unit );
-			if ( v ) renderer.setTexture2D( v, unit );
-
-		},
-
-		setValueT6 = function( gl, v, renderer ) {
-
-			var unit = renderer.allocTextureUnit();
-			gl.uniform1i( this.addr, unit );
-			if ( v ) renderer.setTextureCube( v, unit );
-
-		},
-
-		// Integer / Boolean vectors or arrays thereof (always flat arrays)
-
-		setValue2iv = function( gl, v ) { gl.uniform2iv( this.addr, v ); },
-		setValue3iv = function( gl, v ) { gl.uniform3iv( this.addr, v ); },
-		setValue4iv = function( gl, v ) { gl.uniform4iv( this.addr, v ); },
-
-		// Helper to pick the right setter for the singular case
-
-		getSingularSetter = function( type ) {
-
-			switch ( type ) {
-
-				case 0x1406: return setValue1f; // FLOAT
-				case 0x8b50: return setValue2fv; // _VEC2
-				case 0x8b51: return setValue3fv; // _VEC3
-				case 0x8b52: return setValue4fv; // _VEC4
-
-				case 0x8b5a: return setValue2fm; // _MAT2
-				case 0x8b5b: return setValue3fm; // _MAT3
-				case 0x8b5c: return setValue4fm; // _MAT4
-
-				case 0x8b5e: return setValueT1; // SAMPLER_2D
-				case 0x8b60: return setValueT6; // SAMPLER_CUBE
-
-				case 0x1404: case 0x8b56: return setValue1i; // INT, BOOL
-				case 0x8b53: case 0x8b57: return setValue2iv; // _VEC2
-				case 0x8b54: case 0x8b58: return setValue3iv; // _VEC3
-				case 0x8b55: case 0x8b59: return setValue4iv; // _VEC4
-
-			}
-
-		},
-
-		// Array of scalars
-
-		setValue1fv = function( gl, v ) { gl.uniform1fv( this.addr, v ); },
-		setValue1iv = function( gl, v ) { gl.uniform1iv( this.addr, v ); },
-
-		// Array of vectors (flat or from THREE classes)
-
-		setValueV2a = function( gl, v ) {
-
-			gl.uniform2fv( this.addr, flatten( v, this.size, 2 ) );
-
-		},
-
-		setValueV3a = function( gl, v ) {
-
-			gl.uniform3fv( this.addr, flatten( v, this.size, 3 ) );
-
-		},
-
-		setValueV4a = function( gl, v ) {
-
-			gl.uniform4fv( this.addr, flatten( v, this.size, 4 ) );
-
-		},
-
-		// Array of matrices (flat or from THREE clases)
-
-		setValueM2a = function( gl, v ) {
-
-			gl.uniformMatrix2fv( this.addr, false, flatten( v, this.size, 4 ) );
-
-		},
-
-		setValueM3a = function( gl, v ) {
-
-			gl.uniformMatrix3fv( this.addr, false, flatten( v, this.size, 9 ) );
-
-		},
-
-		setValueM4a = function( gl, v ) {
-
-			gl.uniformMatrix4fv( this.addr, false, flatten( v, this.size, 16 ) );
-
-		},
-
-		// Array of textures (2D / Cube)
-
-		setValueT1a = function( gl, v, renderer ) {
-
-			var n = v.length,
-				units = allocTexUnits( renderer, n );
-
-			gl.uniform1iv( this.addr, units );
-
-			for ( var i = 0; i !== n; ++ i ) {
-
-				var tex = v[ i ];
-				if ( tex ) renderer.setTexture2D( tex, units[ i ] );
-
-			}
-
-		},
-
-		setValueT6a = function( gl, v, renderer ) {
-
-			var n = v.length,
-				units = allocTexUnits( renderer, n );
-
-			gl.uniform1iv( this.addr, units );
-
-			for ( var i = 0; i !== n; ++ i ) {
-
-				var tex = v[ i ];
-				if ( tex ) renderer.setTextureCube( tex, units[ i ] );
-
-			}
-
-		},
-
-
-		// Helper to pick the right setter for a pure (bottom-level) array
-
-		getPureArraySetter = function( type ) {
-
-			switch ( type ) {
-
-				case 0x1406: return setValue1fv; // FLOAT
-				case 0x8b50: return setValueV2a; // _VEC2
-				case 0x8b51: return setValueV3a; // _VEC3
-				case 0x8b52: return setValueV4a; // _VEC4
-
-				case 0x8b5a: return setValueM2a; // _MAT2
-				case 0x8b5b: return setValueM3a; // _MAT3
-				case 0x8b5c: return setValueM4a; // _MAT4
-
-				case 0x8b5e: return setValueT1a; // SAMPLER_2D
-				case 0x8b60: return setValueT6a; // SAMPLER_CUBE
-
-				case 0x1404: case 0x8b56: return setValue1iv; // INT, BOOL
-				case 0x8b53: case 0x8b57: return setValue2iv; // _VEC2
-				case 0x8b54: case 0x8b58: return setValue3iv; // _VEC3
-				case 0x8b55: case 0x8b59: return setValue4iv; // _VEC4
-
-			}
-
-		},
-
-	// --- Uniform Classes ---
-
-		SingleUniform = function SingleUniform( id, activeInfo, addr ) {
-
-			this.id = id;
-			this.addr = addr;
-			this.setValue = getSingularSetter( activeInfo.type );
-
-			// this.path = activeInfo.name; // DEBUG
-
-		},
-
-		PureArrayUniform = function( id, activeInfo, addr ) {
-
-			this.id = id;
-			this.addr = addr;
-			this.size = activeInfo.size;
-			this.setValue = getPureArraySetter( activeInfo.type );
-
-			// this.path = activeInfo.name; // DEBUG
-
-		},
-
-		StructuredUniform = function( id ) {
-
-			this.id = id;
-
-			UniformContainer.call( this ); // mix-in
-
-		};
-
-	StructuredUniform.prototype.setValue = function( gl, value ) {
-
-		// Note: Don't need an extra 'renderer' parameter, since samplers
-		// are not allowed in structured uniforms.
-
-		var seq = this.seq;
-
-		for ( var i = 0, n = seq.length; i !== n; ++ i ) {
-
-			var u = seq[ i ];
-			u.setValue( gl, value[ u.id ] );
-
-		}
-
-	};
-
-	// --- Top-level ---
-
-	// Parser - builds up the property tree from the path strings
-
-	var RePathPart = /([\w\d_]+)(\])?(\[|\.)?/g,
-		// extracts
-		// 	- the identifier (member name or array index)
-		//  - followed by an optional right bracket (found when array index)
-		//  - followed by an optional left bracket or dot (type of subscript)
-		//
-		// Note: These portions can be read in a non-overlapping fashion and
-		// allow straightforward parsing of the hierarchy that WebGL encodes
-		// in the uniform names.
-
-		addUniform = function( container, uniformObject ) {
-
-			container.seq.push( uniformObject );
-			container.map[ uniformObject.id ] = uniformObject;
-
-		},
-
-		parseUniform = function( activeInfo, addr, container ) {
-
-			var path = activeInfo.name,
-				pathLength = path.length;
-
-			// reset RegExp object, because of the early exit of a previous run
-			RePathPart.lastIndex = 0;
-
-			for (; ;) {
-
-				var match = RePathPart.exec( path ),
-					matchEnd = RePathPart.lastIndex,
-
-					id = match[ 1 ],
-					idIsIndex = match[ 2 ] === ']',
-					subscript = match[ 3 ];
-
-				if ( idIsIndex ) id = id | 0; // convert to integer
-
-				if ( subscript === undefined ||
-						subscript === '[' && matchEnd + 2 === pathLength ) {
-					// bare name or "pure" bottom-level array "[0]" suffix
-
-					addUniform( container, subscript === undefined ?
-							new SingleUniform( id, activeInfo, addr ) :
-							new PureArrayUniform( id, activeInfo, addr ) );
-
-					break;
-
-				} else {
-					// step into inner node / create it in case it doesn't exist
-
-					var map = container.map,
-						next = map[ id ];
-
-					if ( next === undefined ) {
-
-						next = new StructuredUniform( id );
-						addUniform( container, next );
-
-					}
-
-					container = next;
-
-				}
-
-			}
-
-		},
-
-	// Root Container
-
-		WebGLUniforms = function WebGLUniforms( gl, program, renderer ) {
-
-			UniformContainer.call( this );
-
-			this.renderer = renderer;
-
-			var n = gl.getProgramParameter( program, gl.ACTIVE_UNIFORMS );
-
-			for ( var i = 0; i !== n; ++ i ) {
-
-				var info = gl.getActiveUniform( program, i ),
-					path = info.name,
-					addr = gl.getUniformLocation( program, path );
-
-				parseUniform( info, addr, this );
-
-			}
-
-		};
-
-
-	WebGLUniforms.prototype.setValue = function( gl, name, value ) {
-
-		var u = this.map[ name ];
-
-		if ( u !== undefined ) u.setValue( gl, value, this.renderer );
-
-	};
-
-	WebGLUniforms.prototype.set = function( gl, object, name ) {
-
-		var u = this.map[ name ];
-
-		if ( u !== undefined ) u.setValue( gl, object[ name ], this.renderer );
-
-	};
-
-	WebGLUniforms.prototype.setOptional = function( gl, object, name ) {
-
-		var v = object[ name ];
-
-		if ( v !== undefined ) this.setValue( gl, name, v );
-
-	};
-
-
-	// Static interface
-
-	WebGLUniforms.upload = function( gl, seq, values, renderer ) {
-
-		for ( var i = 0, n = seq.length; i !== n; ++ i ) {
-
-			var u = seq[ i ],
-				v = values[ u.id ];
-
-			if ( v.needsUpdate !== false ) {
-				// note: always updating when .needsUpdate is undefined
-
-				u.setValue( gl, v.value, renderer );
-
-			}
-
-		}
-
-	};
-
-	WebGLUniforms.seqWithValue = function( seq, values ) {
-
-		var r = [];
-
-		for ( var i = 0, n = seq.length; i !== n; ++ i ) {
-
-			var u = seq[ i ];
-			if ( u.id in values ) r.push( u );
-
-		}
-
-		return r;
-
-	};
-
-	WebGLUniforms.splitDynamic = function( seq, values ) {
-
-		var r = null,
-			n = seq.length,
-			w = 0;
-
-		for ( var i = 0; i !== n; ++ i ) {
-
-			var u = seq[ i ],
-				v = values[ u.id ];
-
-			if ( v && v.dynamic === true ) {
-
-				if ( r === null ) r = [];
-				r.push( u );
-
-			} else {
-
-				// in-place compact 'seq', removing the matches
-				if ( w < i ) seq[ w ] = u;
-				++ w;
-
-			}
-
-		}
-
-		if ( w < n ) seq.length = w;
-
-		return r;
-
-	};
-
-	WebGLUniforms.evalDynamic = function( seq, values, object, camera ) {
-
-		for ( var i = 0, n = seq.length; i !== n; ++ i ) {
-
-			var v = values[ seq[ i ].id ],
-				f = v.onUpdateCallback;
-
-			if ( f !== undefined ) f.call( v, object, camera );
-
-		}
-
-	};
-
-	return WebGLUniforms;
-
-} )();
-
-
-// File:src/renderers/webgl/plugins/LensFlarePlugin.js
-
-/**
- * @author mikael emtinger / http://gomo.se/
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.LensFlarePlugin = function ( renderer, flares ) {
-
-	var gl = renderer.context;
-	var state = renderer.state;
-
-	var vertexBuffer, elementBuffer;
-	var shader, program, attributes, uniforms;
-
-	var tempTexture, occlusionTexture;
-
-	function init() {
-
-		var vertices = new Float32Array( [
-			- 1, - 1,  0, 0,
-			 1, - 1,  1, 0,
-			 1,  1,  1, 1,
-			- 1,  1,  0, 1
-		] );
-
-		var faces = new Uint16Array( [
-			0, 1, 2,
-			0, 2, 3
-		] );
-
-		// buffers
-
-		vertexBuffer     = gl.createBuffer();
-		elementBuffer    = gl.createBuffer();
-
-		gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );
-		gl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW );
-
-		gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );
-		gl.bufferData( gl.ELEMENT_ARRAY_BUFFER, faces, gl.STATIC_DRAW );
-
-		// textures
-
-		tempTexture      = gl.createTexture();
-		occlusionTexture = gl.createTexture();
-
-		state.bindTexture( gl.TEXTURE_2D, tempTexture );
-		gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGB, 16, 16, 0, gl.RGB, gl.UNSIGNED_BYTE, null );
-		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE );
-		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE );
-		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST );
-		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST );
-
-		state.bindTexture( gl.TEXTURE_2D, occlusionTexture );
-		gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGBA, 16, 16, 0, gl.RGBA, gl.UNSIGNED_BYTE, null );
-		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE );
-		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE );
-		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST );
-		gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST );
-
-		shader = {
-
-			vertexShader: [
-
-				"uniform lowp int renderType;",
-
-				"uniform vec3 screenPosition;",
-				"uniform vec2 scale;",
-				"uniform float rotation;",
-
-				"uniform sampler2D occlusionMap;",
-
-				"attribute vec2 position;",
-				"attribute vec2 uv;",
-
-				"varying vec2 vUV;",
-				"varying float vVisibility;",
-
-				"void main() {",
-
-					"vUV = uv;",
-
-					"vec2 pos = position;",
-
-					"if ( renderType == 2 ) {",
-
-						"vec4 visibility = texture2D( occlusionMap, vec2( 0.1, 0.1 ) );",
-						"visibility += texture2D( occlusionMap, vec2( 0.5, 0.1 ) );",
-						"visibility += texture2D( occlusionMap, vec2( 0.9, 0.1 ) );",
-						"visibility += texture2D( occlusionMap, vec2( 0.9, 0.5 ) );",
-						"visibility += texture2D( occlusionMap, vec2( 0.9, 0.9 ) );",
-						"visibility += texture2D( occlusionMap, vec2( 0.5, 0.9 ) );",
-						"visibility += texture2D( occlusionMap, vec2( 0.1, 0.9 ) );",
-						"visibility += texture2D( occlusionMap, vec2( 0.1, 0.5 ) );",
-						"visibility += texture2D( occlusionMap, vec2( 0.5, 0.5 ) );",
-
-						"vVisibility =        visibility.r / 9.0;",
-						"vVisibility *= 1.0 - visibility.g / 9.0;",
-						"vVisibility *=       visibility.b / 9.0;",
-						"vVisibility *= 1.0 - visibility.a / 9.0;",
-
-						"pos.x = cos( rotation ) * position.x - sin( rotation ) * position.y;",
-						"pos.y = sin( rotation ) * position.x + cos( rotation ) * position.y;",
-
-					"}",
-
-					"gl_Position = vec4( ( pos * scale + screenPosition.xy ).xy, screenPosition.z, 1.0 );",
-
-				"}"
-
-			].join( "\n" ),
-
-			fragmentShader: [
-
-				"uniform lowp int renderType;",
-
-				"uniform sampler2D map;",
-				"uniform float opacity;",
-				"uniform vec3 color;",
-
-				"varying vec2 vUV;",
-				"varying float vVisibility;",
-
-				"void main() {",
-
-					// pink square
-
-					"if ( renderType == 0 ) {",
-
-						"gl_FragColor = vec4( 1.0, 0.0, 1.0, 0.0 );",
-
-					// restore
-
-					"} else if ( renderType == 1 ) {",
-
-						"gl_FragColor = texture2D( map, vUV );",
-
-					// flare
-
-					"} else {",
-
-						"vec4 texture = texture2D( map, vUV );",
-						"texture.a *= opacity * vVisibility;",
-						"gl_FragColor = texture;",
-						"gl_FragColor.rgb *= color;",
-
-					"}",
-
-				"}"
-
-			].join( "\n" )
-
-		};
-
-		program = createProgram( shader );
-
-		attributes = {
-			vertex: gl.getAttribLocation ( program, "position" ),
-			uv:     gl.getAttribLocation ( program, "uv" )
-		};
-
-		uniforms = {
-			renderType:     gl.getUniformLocation( program, "renderType" ),
-			map:            gl.getUniformLocation( program, "map" ),
-			occlusionMap:   gl.getUniformLocation( program, "occlusionMap" ),
-			opacity:        gl.getUniformLocation( program, "opacity" ),
-			color:          gl.getUniformLocation( program, "color" ),
-			scale:          gl.getUniformLocation( program, "scale" ),
-			rotation:       gl.getUniformLocation( program, "rotation" ),
-			screenPosition: gl.getUniformLocation( program, "screenPosition" )
-		};
-
-	}
-
-	/*
-	 * Render lens flares
-	 * Method: renders 16x16 0xff00ff-colored points scattered over the light source area,
-	 *         reads these back and calculates occlusion.
-	 */
-
-	this.render = function ( scene, camera, viewport ) {
-
-		if ( flares.length === 0 ) return;
-
-		var tempPosition = new THREE.Vector3();
-
-		var invAspect = viewport.w / viewport.z,
-			halfViewportWidth = viewport.z * 0.5,
-			halfViewportHeight = viewport.w * 0.5;
-
-		var size = 16 / viewport.w,
-			scale = new THREE.Vector2( size * invAspect, size );
-
-		var screenPosition = new THREE.Vector3( 1, 1, 0 ),
-			screenPositionPixels = new THREE.Vector2( 1, 1 );
-
-		var validArea = new THREE.Box2();
-
-		validArea.min.set( 0, 0 );
-		validArea.max.set( viewport.z - 16, viewport.w - 16 );
-
-		if ( program === undefined ) {
-
-			init();
-
-		}
-
-		gl.useProgram( program );
-
-		state.initAttributes();
-		state.enableAttribute( attributes.vertex );
-		state.enableAttribute( attributes.uv );
-		state.disableUnusedAttributes();
-
-		// loop through all lens flares to update their occlusion and positions
-		// setup gl and common used attribs/uniforms
-
-		gl.uniform1i( uniforms.occlusionMap, 0 );
-		gl.uniform1i( uniforms.map, 1 );
-
-		gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );
-		gl.vertexAttribPointer( attributes.vertex, 2, gl.FLOAT, false, 2 * 8, 0 );
-		gl.vertexAttribPointer( attributes.uv, 2, gl.FLOAT, false, 2 * 8, 8 );
-
-		gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );
-
-		state.disable( gl.CULL_FACE );
-		state.setDepthWrite( false );
-
-		for ( var i = 0, l = flares.length; i < l; i ++ ) {
-
-			size = 16 / viewport.w;
-			scale.set( size * invAspect, size );
-
-			// calc object screen position
-
-			var flare = flares[ i ];
-
-			tempPosition.set( flare.matrixWorld.elements[ 12 ], flare.matrixWorld.elements[ 13 ], flare.matrixWorld.elements[ 14 ] );
-
-			tempPosition.applyMatrix4( camera.matrixWorldInverse );
-			tempPosition.applyProjection( camera.projectionMatrix );
-
-			// setup arrays for gl programs
-
-			screenPosition.copy( tempPosition );
-
-			// horizontal and vertical coordinate of the lower left corner of the pixels to copy
-
-			screenPositionPixels.x = viewport.x + ( screenPosition.x * halfViewportWidth ) + halfViewportWidth - 8;
-			screenPositionPixels.y = viewport.y + ( screenPosition.y * halfViewportHeight ) + halfViewportHeight - 8;
-
-			// screen cull
-
-			if ( validArea.containsPoint( screenPositionPixels ) === true ) {
-
-				// save current RGB to temp texture
-
-				state.activeTexture( gl.TEXTURE0 );
-				state.bindTexture( gl.TEXTURE_2D, null );
-				state.activeTexture( gl.TEXTURE1 );
-				state.bindTexture( gl.TEXTURE_2D, tempTexture );
-				gl.copyTexImage2D( gl.TEXTURE_2D, 0, gl.RGB, screenPositionPixels.x, screenPositionPixels.y, 16, 16, 0 );
-
-
-				// render pink quad
-
-				gl.uniform1i( uniforms.renderType, 0 );
-				gl.uniform2f( uniforms.scale, scale.x, scale.y );
-				gl.uniform3f( uniforms.screenPosition, screenPosition.x, screenPosition.y, screenPosition.z );
-
-				state.disable( gl.BLEND );
-				state.enable( gl.DEPTH_TEST );
-
-				gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );
-
-
-				// copy result to occlusionMap
-
-				state.activeTexture( gl.TEXTURE0 );
-				state.bindTexture( gl.TEXTURE_2D, occlusionTexture );
-				gl.copyTexImage2D( gl.TEXTURE_2D, 0, gl.RGBA, screenPositionPixels.x, screenPositionPixels.y, 16, 16, 0 );
-
-
-				// restore graphics
-
-				gl.uniform1i( uniforms.renderType, 1 );
-				state.disable( gl.DEPTH_TEST );
-
-				state.activeTexture( gl.TEXTURE1 );
-				state.bindTexture( gl.TEXTURE_2D, tempTexture );
-				gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );
-
-
-				// update object positions
-
-				flare.positionScreen.copy( screenPosition );
-
-				if ( flare.customUpdateCallback ) {
-
-					flare.customUpdateCallback( flare );
-
-				} else {
-
-					flare.updateLensFlares();
-
-				}
-
-				// render flares
-
-				gl.uniform1i( uniforms.renderType, 2 );
-				state.enable( gl.BLEND );
-
-				for ( var j = 0, jl = flare.lensFlares.length; j < jl; j ++ ) {
-
-					var sprite = flare.lensFlares[ j ];
-
-					if ( sprite.opacity > 0.001 && sprite.scale > 0.001 ) {
-
-						screenPosition.x = sprite.x;
-						screenPosition.y = sprite.y;
-						screenPosition.z = sprite.z;
-
-						size = sprite.size * sprite.scale / viewport.w;
-
-						scale.x = size * invAspect;
-						scale.y = size;
-
-						gl.uniform3f( uniforms.screenPosition, screenPosition.x, screenPosition.y, screenPosition.z );
-						gl.uniform2f( uniforms.scale, scale.x, scale.y );
-						gl.uniform1f( uniforms.rotation, sprite.rotation );
-
-						gl.uniform1f( uniforms.opacity, sprite.opacity );
-						gl.uniform3f( uniforms.color, sprite.color.r, sprite.color.g, sprite.color.b );
-
-						state.setBlending( sprite.blending, sprite.blendEquation, sprite.blendSrc, sprite.blendDst );
-						renderer.setTexture2D( sprite.texture, 1 );
-
-						gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );
-
-					}
-
-				}
-
-			}
-
-		}
-
-		// restore gl
-
-		state.enable( gl.CULL_FACE );
-		state.enable( gl.DEPTH_TEST );
-		state.setDepthWrite( true );
-
-		renderer.resetGLState();
-
-	};
-
-	function createProgram ( shader ) {
-
-		var program = gl.createProgram();
-
-		var fragmentShader = gl.createShader( gl.FRAGMENT_SHADER );
-		var vertexShader = gl.createShader( gl.VERTEX_SHADER );
-
-		var prefix = "precision " + renderer.getPrecision() + " float;\n";
-
-		gl.shaderSource( fragmentShader, prefix + shader.fragmentShader );
-		gl.shaderSource( vertexShader, prefix + shader.vertexShader );
-
-		gl.compileShader( fragmentShader );
-		gl.compileShader( vertexShader );
-
-		gl.attachShader( program, fragmentShader );
-		gl.attachShader( program, vertexShader );
-
-		gl.linkProgram( program );
-
-		return program;
-
-	}
-
-};
-
-// File:src/renderers/webgl/plugins/SpritePlugin.js
-
-/**
- * @author mikael emtinger / http://gomo.se/
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.SpritePlugin = function ( renderer, sprites ) {
-
-	var gl = renderer.context;
-	var state = renderer.state;
-
-	var vertexBuffer, elementBuffer;
-	var program, attributes, uniforms;
-
-	var texture;
-
-	// decompose matrixWorld
-
-	var spritePosition = new THREE.Vector3();
-	var spriteRotation = new THREE.Quaternion();
-	var spriteScale = new THREE.Vector3();
-
-	function init() {
-
-		var vertices = new Float32Array( [
-			- 0.5, - 0.5,  0, 0,
-			  0.5, - 0.5,  1, 0,
-			  0.5,   0.5,  1, 1,
-			- 0.5,   0.5,  0, 1
-		] );
-
-		var faces = new Uint16Array( [
-			0, 1, 2,
-			0, 2, 3
-		] );
-
-		vertexBuffer  = gl.createBuffer();
-		elementBuffer = gl.createBuffer();
-
-		gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );
-		gl.bufferData( gl.ARRAY_BUFFER, vertices, gl.STATIC_DRAW );
-
-		gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );
-		gl.bufferData( gl.ELEMENT_ARRAY_BUFFER, faces, gl.STATIC_DRAW );
-
-		program = createProgram();
-
-		attributes = {
-			position:			gl.getAttribLocation ( program, 'position' ),
-			uv:					gl.getAttribLocation ( program, 'uv' )
-		};
-
-		uniforms = {
-			uvOffset:			gl.getUniformLocation( program, 'uvOffset' ),
-			uvScale:			gl.getUniformLocation( program, 'uvScale' ),
-
-			rotation:			gl.getUniformLocation( program, 'rotation' ),
-			scale:				gl.getUniformLocation( program, 'scale' ),
-
-			color:				gl.getUniformLocation( program, 'color' ),
-			map:				gl.getUniformLocation( program, 'map' ),
-			opacity:			gl.getUniformLocation( program, 'opacity' ),
-
-			modelViewMatrix: 	gl.getUniformLocation( program, 'modelViewMatrix' ),
-			projectionMatrix:	gl.getUniformLocation( program, 'projectionMatrix' ),
-
-			fogType:			gl.getUniformLocation( program, 'fogType' ),
-			fogDensity:			gl.getUniformLocation( program, 'fogDensity' ),
-			fogNear:			gl.getUniformLocation( program, 'fogNear' ),
-			fogFar:				gl.getUniformLocation( program, 'fogFar' ),
-			fogColor:			gl.getUniformLocation( program, 'fogColor' ),
-
-			alphaTest:			gl.getUniformLocation( program, 'alphaTest' )
-		};
-
-		var canvas = document.createElement( 'canvas' );
-		canvas.width = 8;
-		canvas.height = 8;
-
-		var context = canvas.getContext( '2d' );
-		context.fillStyle = 'white';
-		context.fillRect( 0, 0, 8, 8 );
-
-		texture = new THREE.Texture( canvas );
-		texture.needsUpdate = true;
-
-	}
-
-	this.render = function ( scene, camera ) {
-
-		if ( sprites.length === 0 ) return;
-
-		// setup gl
-
-		if ( program === undefined ) {
-
-			init();
-
-		}
-
-		gl.useProgram( program );
-
-		state.initAttributes();
-		state.enableAttribute( attributes.position );
-		state.enableAttribute( attributes.uv );
-		state.disableUnusedAttributes();
-
-		state.disable( gl.CULL_FACE );
-		state.enable( gl.BLEND );
-
-		gl.bindBuffer( gl.ARRAY_BUFFER, vertexBuffer );
-		gl.vertexAttribPointer( attributes.position, 2, gl.FLOAT, false, 2 * 8, 0 );
-		gl.vertexAttribPointer( attributes.uv, 2, gl.FLOAT, false, 2 * 8, 8 );
-
-		gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, elementBuffer );
-
-		gl.uniformMatrix4fv( uniforms.projectionMatrix, false, camera.projectionMatrix.elements );
-
-		state.activeTexture( gl.TEXTURE0 );
-		gl.uniform1i( uniforms.map, 0 );
-
-		var oldFogType = 0;
-		var sceneFogType = 0;
-		var fog = scene.fog;
-
-		if ( fog ) {
-
-			gl.uniform3f( uniforms.fogColor, fog.color.r, fog.color.g, fog.color.b );
-
-			if ( fog instanceof THREE.Fog ) {
-
-				gl.uniform1f( uniforms.fogNear, fog.near );
-				gl.uniform1f( uniforms.fogFar, fog.far );
-
-				gl.uniform1i( uniforms.fogType, 1 );
-				oldFogType = 1;
-				sceneFogType = 1;
-
-			} else if ( fog instanceof THREE.FogExp2 ) {
-
-				gl.uniform1f( uniforms.fogDensity, fog.density );
-
-				gl.uniform1i( uniforms.fogType, 2 );
-				oldFogType = 2;
-				sceneFogType = 2;
-
-			}
-
-		} else {
-
-			gl.uniform1i( uniforms.fogType, 0 );
-			oldFogType = 0;
-			sceneFogType = 0;
-
-		}
-
-
-		// update positions and sort
-
-		for ( var i = 0, l = sprites.length; i < l; i ++ ) {
-
-			var sprite = sprites[ i ];
-
-			sprite.modelViewMatrix.multiplyMatrices( camera.matrixWorldInverse, sprite.matrixWorld );
-			sprite.z = - sprite.modelViewMatrix.elements[ 14 ];
-
-		}
-
-		sprites.sort( painterSortStable );
-
-		// render all sprites
-
-		var scale = [];
-
-		for ( var i = 0, l = sprites.length; i < l; i ++ ) {
-
-			var sprite = sprites[ i ];
-			var material = sprite.material;
-
-			gl.uniform1f( uniforms.alphaTest, material.alphaTest );
-			gl.uniformMatrix4fv( uniforms.modelViewMatrix, false, sprite.modelViewMatrix.elements );
-
-			sprite.matrixWorld.decompose( spritePosition, spriteRotation, spriteScale );
-
-			scale[ 0 ] = spriteScale.x;
-			scale[ 1 ] = spriteScale.y;
-
-			var fogType = 0;
-
-			if ( scene.fog && material.fog ) {
-
-				fogType = sceneFogType;
-
-			}
-
-			if ( oldFogType !== fogType ) {
-
-				gl.uniform1i( uniforms.fogType, fogType );
-				oldFogType = fogType;
-
-			}
-
-			if ( material.map !== null ) {
-
-				gl.uniform2f( uniforms.uvOffset, material.map.offset.x, material.map.offset.y );
-				gl.uniform2f( uniforms.uvScale, material.map.repeat.x, material.map.repeat.y );
-
-			} else {
-
-				gl.uniform2f( uniforms.uvOffset, 0, 0 );
-				gl.uniform2f( uniforms.uvScale, 1, 1 );
-
-			}
-
-			gl.uniform1f( uniforms.opacity, material.opacity );
-			gl.uniform3f( uniforms.color, material.color.r, material.color.g, material.color.b );
-
-			gl.uniform1f( uniforms.rotation, material.rotation );
-			gl.uniform2fv( uniforms.scale, scale );
-
-			state.setBlending( material.blending, material.blendEquation, material.blendSrc, material.blendDst );
-			state.setDepthTest( material.depthTest );
-			state.setDepthWrite( material.depthWrite );
-
-			if ( material.map ) {
-
-				renderer.setTexture2D( material.map, 0 );
-
-			} else {
-
-				renderer.setTexture2D( texture, 0 );
-
-			}
-
-			gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );
-
-		}
-
-		// restore gl
-
-		state.enable( gl.CULL_FACE );
-
-		renderer.resetGLState();
-
-	};
-
-	function createProgram () {
-
-		var program = gl.createProgram();
-
-		var vertexShader = gl.createShader( gl.VERTEX_SHADER );
-		var fragmentShader = gl.createShader( gl.FRAGMENT_SHADER );
-
-		gl.shaderSource( vertexShader, [
-
-			'precision ' + renderer.getPrecision() + ' float;',
-
-			'uniform mat4 modelViewMatrix;',
-			'uniform mat4 projectionMatrix;',
-			'uniform float rotation;',
-			'uniform vec2 scale;',
-			'uniform vec2 uvOffset;',
-			'uniform vec2 uvScale;',
-
-			'attribute vec2 position;',
-			'attribute vec2 uv;',
-
-			'varying vec2 vUV;',
-
-			'void main() {',
-
-				'vUV = uvOffset + uv * uvScale;',
-
-				'vec2 alignedPosition = position * scale;',
-
-				'vec2 rotatedPosition;',
-				'rotatedPosition.x = cos( rotation ) * alignedPosition.x - sin( rotation ) * alignedPosition.y;',
-				'rotatedPosition.y = sin( rotation ) * alignedPosition.x + cos( rotation ) * alignedPosition.y;',
-
-				'vec4 finalPosition;',
-
-				'finalPosition = modelViewMatrix * vec4( 0.0, 0.0, 0.0, 1.0 );',
-				'finalPosition.xy += rotatedPosition;',
-				'finalPosition = projectionMatrix * finalPosition;',
-
-				'gl_Position = finalPosition;',
-
-			'}'
-
-		].join( '\n' ) );
-
-		gl.shaderSource( fragmentShader, [
-
-			'precision ' + renderer.getPrecision() + ' float;',
-
-			'uniform vec3 color;',
-			'uniform sampler2D map;',
-			'uniform float opacity;',
-
-			'uniform int fogType;',
-			'uniform vec3 fogColor;',
-			'uniform float fogDensity;',
-			'uniform float fogNear;',
-			'uniform float fogFar;',
-			'uniform float alphaTest;',
-
-			'varying vec2 vUV;',
-
-			'void main() {',
-
-				'vec4 texture = texture2D( map, vUV );',
-
-				'if ( texture.a < alphaTest ) discard;',
-
-				'gl_FragColor = vec4( color * texture.xyz, texture.a * opacity );',
-
-				'if ( fogType > 0 ) {',
-
-					'float depth = gl_FragCoord.z / gl_FragCoord.w;',
-					'float fogFactor = 0.0;',
-
-					'if ( fogType == 1 ) {',
-
-						'fogFactor = smoothstep( fogNear, fogFar, depth );',
-
-					'} else {',
-
-						'const float LOG2 = 1.442695;',
-						'fogFactor = exp2( - fogDensity * fogDensity * depth * depth * LOG2 );',
-						'fogFactor = 1.0 - clamp( fogFactor, 0.0, 1.0 );',
-
-					'}',
-
-					'gl_FragColor = mix( gl_FragColor, vec4( fogColor, gl_FragColor.w ), fogFactor );',
-
-				'}',
-
-			'}'
-
-		].join( '\n' ) );
-
-		gl.compileShader( vertexShader );
-		gl.compileShader( fragmentShader );
-
-		gl.attachShader( program, vertexShader );
-		gl.attachShader( program, fragmentShader );
-
-		gl.linkProgram( program );
-
-		return program;
-
-	}
-
-	function painterSortStable ( a, b ) {
-		
-		if ( a.renderOrder !== b.renderOrder ) {
-
-			return a.renderOrder - b.renderOrder;
-
-		} else if ( a.z !== b.z ) {
-
-			return b.z - a.z;
-
-		} else {
-
-			return b.id - a.id;
-
-		}
-
-	}
-
-};
-
-// File:src/Three.Legacy.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-Object.defineProperties( THREE.Box2.prototype, {
-	empty: {
-		value: function () {
-			console.warn( 'THREE.Box2: .empty() has been renamed to .isEmpty().' );
-			return this.isEmpty();
-		}
-	},
-	isIntersectionBox: {
-		value: function ( box ) {
-			console.warn( 'THREE.Box2: .isIntersectionBox() has been renamed to .intersectsBox().' );
-			return this.intersectsBox( box );
-		}
-	}
-} );
-
-Object.defineProperties( THREE.Box3.prototype, {
-	empty: {
-		value: function () {
-			console.warn( 'THREE.Box3: .empty() has been renamed to .isEmpty().' );
-			return this.isEmpty();
-		}
-	},
-	isIntersectionBox: {
-		value: function ( box ) {
-			console.warn( 'THREE.Box3: .isIntersectionBox() has been renamed to .intersectsBox().' );
-			return this.intersectsBox( box );
-		}
-	},
-	isIntersectionSphere: {
-		value: function ( sphere ) {
-			console.warn( 'THREE.Box3: .isIntersectionSphere() has been renamed to .intersectsSphere().' );
-			return this.intersectsSphere( sphere );
-		}
-	}
-} );
-
-Object.defineProperties( THREE.Matrix3.prototype, {
-	multiplyVector3: {
-		value: function ( vector ) {
-			console.warn( 'THREE.Matrix3: .multiplyVector3() has been removed. Use vector.applyMatrix3( matrix ) instead.' );
-			return vector.applyMatrix3( this );
-		}
-	},
-	multiplyVector3Array: {
-		value: function ( a ) {
-			console.warn( 'THREE.Matrix3: .multiplyVector3Array() has been renamed. Use matrix.applyToVector3Array( array ) instead.' );
-			return this.applyToVector3Array( a );
-		}
-	}
-} );
-
-Object.defineProperties( THREE.Matrix4.prototype, {
-	extractPosition: {
-		value: function ( m ) {
-			console.warn( 'THREE.Matrix4: .extractPosition() has been renamed to .copyPosition().' );
-			return this.copyPosition( m );
-		}
-	},
-	setRotationFromQuaternion: {
-		value: function ( q ) {
-			console.warn( 'THREE.Matrix4: .setRotationFromQuaternion() has been renamed to .makeRotationFromQuaternion().' );
-			return this.makeRotationFromQuaternion( q );
-		}
-	},
-	multiplyVector3: {
-		value: function ( vector ) {
-			console.warn( 'THREE.Matrix4: .multiplyVector3() has been removed. Use vector.applyMatrix4( matrix ) or vector.applyProjection( matrix ) instead.' );
-			return vector.applyProjection( this );
-		}
-	},
-	multiplyVector4: {
-		value: function ( vector ) {
-			console.warn( 'THREE.Matrix4: .multiplyVector4() has been removed. Use vector.applyMatrix4( matrix ) instead.' );
-			return vector.applyMatrix4( this );
-		}
-	},
-	multiplyVector3Array: {
-		value: function ( a ) {
-			console.warn( 'THREE.Matrix4: .multiplyVector3Array() has been renamed. Use matrix.applyToVector3Array( array ) instead.' );
-			return this.applyToVector3Array( a );
-		}
-	},
-	rotateAxis: {
-		value: function ( v ) {
-			console.warn( 'THREE.Matrix4: .rotateAxis() has been removed. Use Vector3.transformDirection( matrix ) instead.' );
-			v.transformDirection( this );
-		}
-	},
-	crossVector: {
-		value: function ( vector ) {
-			console.warn( 'THREE.Matrix4: .crossVector() has been removed. Use vector.applyMatrix4( matrix ) instead.' );
-			return vector.applyMatrix4( this );
-		}
-	},
-	translate: {
-		value: function ( v ) {
-			console.error( 'THREE.Matrix4: .translate() has been removed.' );
-		}
-	},
-	rotateX: {
-		value: function ( angle ) {
-			console.error( 'THREE.Matrix4: .rotateX() has been removed.' );
-		}
-	},
-	rotateY: {
-		value: function ( angle ) {
-			console.error( 'THREE.Matrix4: .rotateY() has been removed.' );
-		}
-	},
-	rotateZ: {
-		value: function ( angle ) {
-			console.error( 'THREE.Matrix4: .rotateZ() has been removed.' );
-		}
-	},
-	rotateByAxis: {
-		value: function ( axis, angle ) {
-			console.error( 'THREE.Matrix4: .rotateByAxis() has been removed.' );
-		}
-	}
-} );
-
-Object.defineProperties( THREE.Plane.prototype, {
-	isIntersectionLine: {
-		value: function ( line ) {
-			console.warn( 'THREE.Plane: .isIntersectionLine() has been renamed to .intersectsLine().' );
-			return this.intersectsLine( line );
-		}
-	}
-} );
-
-Object.defineProperties( THREE.Quaternion.prototype, {
-	multiplyVector3: {
-		value: function ( vector ) {
-			console.warn( 'THREE.Quaternion: .multiplyVector3() has been removed. Use is now vector.applyQuaternion( quaternion ) instead.' );
-			return vector.applyQuaternion( this );
-		}
-	}
-} );
-
-Object.defineProperties( THREE.Ray.prototype, {
-	isIntersectionBox: {
-		value: function ( box ) {
-			console.warn( 'THREE.Ray: .isIntersectionBox() has been renamed to .intersectsBox().' );
-			return this.intersectsBox( box );
-		}
-	},
-	isIntersectionPlane: {
-		value: function ( plane ) {
-			console.warn( 'THREE.Ray: .isIntersectionPlane() has been renamed to .intersectsPlane().' );
-			return this.intersectsPlane( plane );
-		}
-	},
-	isIntersectionSphere: {
-		value: function ( sphere ) {
-			console.warn( 'THREE.Ray: .isIntersectionSphere() has been renamed to .intersectsSphere().' );
-			return this.intersectsSphere( sphere );
-		}
-	}
-} );
-
-Object.defineProperties( THREE.Vector3.prototype, {
-	setEulerFromRotationMatrix: {
-		value: function () {
-			console.error( 'THREE.Vector3: .setEulerFromRotationMatrix() has been removed. Use Euler.setFromRotationMatrix() instead.' );
-		}
-	},
-	setEulerFromQuaternion: {
-		value: function () {
-			console.error( 'THREE.Vector3: .setEulerFromQuaternion() has been removed. Use Euler.setFromQuaternion() instead.' );
-		}
-	},
-	getPositionFromMatrix: {
-		value: function ( m ) {
-			console.warn( 'THREE.Vector3: .getPositionFromMatrix() has been renamed to .setFromMatrixPosition().' );
-			return this.setFromMatrixPosition( m );
-		}
-	},
-	getScaleFromMatrix: {
-		value: function ( m ) {
-			console.warn( 'THREE.Vector3: .getScaleFromMatrix() has been renamed to .setFromMatrixScale().' );
-			return this.setFromMatrixScale( m );
-		}
-	},
-	getColumnFromMatrix: {
-		value: function ( index, matrix ) {
-			console.warn( 'THREE.Vector3: .getColumnFromMatrix() has been renamed to .setFromMatrixColumn().' );
-			return this.setFromMatrixColumn( index, matrix );
-		}
-	}
-} );
-
-//
-
-THREE.Face4 = function ( a, b, c, d, normal, color, materialIndex ) {
-
-	console.warn( 'THREE.Face4 has been removed. A THREE.Face3 will be created instead.' );
-	return new THREE.Face3( a, b, c, normal, color, materialIndex );
-
-};
-
-THREE.Vertex = function ( x, y, z ) {
-
-	console.warn( 'THREE.Vertex has been removed. Use THREE.Vector3 instead.' );
-	return new THREE.Vector3( x, y, z );
-
-};
-
-//
-
-Object.defineProperties( THREE.Object3D.prototype, {
-	eulerOrder: {
-		get: function () {
-			console.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' );
-			return this.rotation.order;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.Object3D: .eulerOrder is now .rotation.order.' );
-			this.rotation.order = value;
-		}
-	},
-	getChildByName: {
-		value: function ( name ) {
-			console.warn( 'THREE.Object3D: .getChildByName() has been renamed to .getObjectByName().' );
-			return this.getObjectByName( name );
-		}
-	},
-	renderDepth: {
-		set: function ( value ) {
-			console.warn( 'THREE.Object3D: .renderDepth has been removed. Use .renderOrder, instead.' );
-		}
-	},
-	translate: {
-		value: function ( distance, axis ) {
-			console.warn( 'THREE.Object3D: .translate() has been removed. Use .translateOnAxis( axis, distance ) instead.' );
-			return this.translateOnAxis( axis, distance );
-		}
-	},
-	useQuaternion: {
-		get: function () {
-			console.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' );
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.Object3D: .useQuaternion has been removed. The library now uses quaternions by default.' );
-		}
-	}
-} );
-
-//
-
-Object.defineProperties( THREE, {
-	PointCloud: {
-		value: function ( geometry, material ) {
-			console.warn( 'THREE.PointCloud has been renamed to THREE.Points.' );
-			return new THREE.Points( geometry, material );
-		}
-	},
-	ParticleSystem: {
-		value: function ( geometry, material ) {
-			console.warn( 'THREE.ParticleSystem has been renamed to THREE.Points.' );
-			return new THREE.Points( geometry, material );
-		}
-	}
-} );
-
-//
-
-Object.defineProperties( THREE.Light.prototype, {
-	onlyShadow: {
-		set: function ( value ) {
-			console.warn( 'THREE.Light: .onlyShadow has been removed.' );
-		}
-	},
-	shadowCameraFov: {
-		set: function ( value ) {
-			console.warn( 'THREE.Light: .shadowCameraFov is now .shadow.camera.fov.' );
-			this.shadow.camera.fov = value;
-		}
-	},
-	shadowCameraLeft: {
-		set: function ( value ) {
-			console.warn( 'THREE.Light: .shadowCameraLeft is now .shadow.camera.left.' );
-			this.shadow.camera.left = value;
-		}
-	},
-	shadowCameraRight: {
-		set: function ( value ) {
-			console.warn( 'THREE.Light: .shadowCameraRight is now .shadow.camera.right.' );
-			this.shadow.camera.right = value;
-		}
-	},
-	shadowCameraTop: {
-		set: function ( value ) {
-			console.warn( 'THREE.Light: .shadowCameraTop is now .shadow.camera.top.' );
-			this.shadow.camera.top = value;
-		}
-	},
-	shadowCameraBottom: {
-		set: function ( value ) {
-			console.warn( 'THREE.Light: .shadowCameraBottom is now .shadow.camera.bottom.' );
-			this.shadow.camera.bottom = value;
-		}
-	},
-	shadowCameraNear: {
-		set: function ( value ) {
-			console.warn( 'THREE.Light: .shadowCameraNear is now .shadow.camera.near.' );
-			this.shadow.camera.near = value;
-		}
-	},
-	shadowCameraFar: {
-		set: function ( value ) {
-			console.warn( 'THREE.Light: .shadowCameraFar is now .shadow.camera.far.' );
-			this.shadow.camera.far = value;
-		}
-	},
-	shadowCameraVisible: {
-		set: function ( value ) {
-			console.warn( 'THREE.Light: .shadowCameraVisible has been removed. Use new THREE.CameraHelper( light.shadow.camera ) instead.' );
-		}
-	},
-	shadowBias: {
-		set: function ( value ) {
-			console.warn( 'THREE.Light: .shadowBias is now .shadow.bias.' );
-			this.shadow.bias = value;
-		}
-	},
-	shadowDarkness: {
-		set: function ( value ) {
-			console.warn( 'THREE.Light: .shadowDarkness has been removed.' );
-		}
-	},
-	shadowMapWidth: {
-		set: function ( value ) {
-			console.warn( 'THREE.Light: .shadowMapWidth is now .shadow.mapSize.width.' );
-			this.shadow.mapSize.width = value;
-		}
-	},
-	shadowMapHeight: {
-		set: function ( value ) {
-			console.warn( 'THREE.Light: .shadowMapHeight is now .shadow.mapSize.height.' );
-			this.shadow.mapSize.height = value;
-		}
-	}
-} );
-
-//
-
-Object.defineProperties( THREE.BufferAttribute.prototype, {
-	length: {
-		get: function () {
-			console.warn( 'THREE.BufferAttribute: .length has been deprecated. Please use .count.' );
-			return this.array.length;
-		}
-	}
-} );
-
-Object.defineProperties( THREE.BufferGeometry.prototype, {
-	drawcalls: {
-		get: function () {
-			console.error( 'THREE.BufferGeometry: .drawcalls has been renamed to .groups.' );
-			return this.groups;
-		}
-	},
-	offsets: {
-		get: function () {
-			console.warn( 'THREE.BufferGeometry: .offsets has been renamed to .groups.' );
-			return this.groups;
-		}
-	},
-	addIndex: {
-		value: function ( index ) {
-			console.warn( 'THREE.BufferGeometry: .addIndex() has been renamed to .setIndex().' );
-			this.setIndex( index );
-		}
-	},
-	addDrawCall: {
-		value: function ( start, count, indexOffset ) {
-			if ( indexOffset !== undefined ) {
-				console.warn( 'THREE.BufferGeometry: .addDrawCall() no longer supports indexOffset.' );
-			}
-			console.warn( 'THREE.BufferGeometry: .addDrawCall() is now .addGroup().' );
-			this.addGroup( start, count );
-		}
-	},
-	clearDrawCalls: {
-		value: function () {
-			console.warn( 'THREE.BufferGeometry: .clearDrawCalls() is now .clearGroups().' );
-			this.clearGroups();
-		}
-	},
-	computeTangents: {
-		value: function () {
-			console.warn( 'THREE.BufferGeometry: .computeTangents() has been removed.' );
-		}
-	},
-	computeOffsets: {
-		value: function () {
-			console.warn( 'THREE.BufferGeometry: .computeOffsets() has been removed.' );
-		}
-	}
-} );
-
-//
-
-Object.defineProperties( THREE.Material.prototype, {
-	wrapAround: {
-		get: function () {
-			console.warn( 'THREE.' + this.type + ': .wrapAround has been removed.' );
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.' + this.type + ': .wrapAround has been removed.' );
-		}
-	},
-	wrapRGB: {
-		get: function () {
-			console.warn( 'THREE.' + this.type + ': .wrapRGB has been removed.' );
-			return new THREE.Color();
-		}
-	}
-} );
-
-Object.defineProperties( THREE, {
-	PointCloudMaterial: {
-		value: function ( parameters ) {
-			console.warn( 'THREE.PointCloudMaterial has been renamed to THREE.PointsMaterial.' );
-			return new THREE.PointsMaterial( parameters );
-		}
-	},
-	ParticleBasicMaterial: {
-		value: function ( parameters ) {
-			console.warn( 'THREE.ParticleBasicMaterial has been renamed to THREE.PointsMaterial.' );
-			return new THREE.PointsMaterial( parameters );
-		}
-	},
-	ParticleSystemMaterial:{
-		value: function ( parameters ) {
-			console.warn( 'THREE.ParticleSystemMaterial has been renamed to THREE.PointsMaterial.' );
-			return new THREE.PointsMaterial( parameters );
-		}
-	}
-} );
-
-Object.defineProperties( THREE.MeshPhongMaterial.prototype, {
-	metal: {
-		get: function () {
-			console.warn( 'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead.' );
-			return false;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.MeshPhongMaterial: .metal has been removed. Use THREE.MeshStandardMaterial instead' );
-		}
-	}
-} );
-
-Object.defineProperties( THREE.ShaderMaterial.prototype, {
-	derivatives: {
-		get: function () {
-			console.warn( 'THREE.ShaderMaterial: .derivatives has been moved to .extensions.derivatives.' );
-			return this.extensions.derivatives;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE. ShaderMaterial: .derivatives has been moved to .extensions.derivatives.' );
-			this.extensions.derivatives = value;
-		}
-	}
-} );
-
-//
-
-Object.defineProperties( THREE.WebGLRenderer.prototype, {
-	supportsFloatTextures: {
-		value: function () {
-			console.warn( 'THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( \'OES_texture_float\' ).' );
-			return this.extensions.get( 'OES_texture_float' );
-		}
-	},
-	supportsHalfFloatTextures: {
-		value: function () {
-			console.warn( 'THREE.WebGLRenderer: .supportsHalfFloatTextures() is now .extensions.get( \'OES_texture_half_float\' ).' );
-			return this.extensions.get( 'OES_texture_half_float' );
-		}
-	},
-	supportsStandardDerivatives: {
-		value: function () {
-			console.warn( 'THREE.WebGLRenderer: .supportsStandardDerivatives() is now .extensions.get( \'OES_standard_derivatives\' ).' );
-			return this.extensions.get( 'OES_standard_derivatives' );
-		}
-	},
-	supportsCompressedTextureS3TC: {
-		value: function () {
-			console.warn( 'THREE.WebGLRenderer: .supportsCompressedTextureS3TC() is now .extensions.get( \'WEBGL_compressed_texture_s3tc\' ).' );
-			return this.extensions.get( 'WEBGL_compressed_texture_s3tc' );
-		}
-	},
-	supportsCompressedTexturePVRTC: {
-		value: function () {
-			console.warn( 'THREE.WebGLRenderer: .supportsCompressedTexturePVRTC() is now .extensions.get( \'WEBGL_compressed_texture_pvrtc\' ).' );
-			return this.extensions.get( 'WEBGL_compressed_texture_pvrtc' );
-		}
-	},
-	supportsBlendMinMax: {
-		value: function () {
-			console.warn( 'THREE.WebGLRenderer: .supportsBlendMinMax() is now .extensions.get( \'EXT_blend_minmax\' ).' );
-			return this.extensions.get( 'EXT_blend_minmax' );
-		}
-	},
-	supportsVertexTextures: {
-		value: function () {
-			return this.capabilities.vertexTextures;
-		}
-	},
-	supportsInstancedArrays: {
-		value: function () {
-			console.warn( 'THREE.WebGLRenderer: .supportsInstancedArrays() is now .extensions.get( \'ANGLE_instanced_arrays\' ).' );
-			return this.extensions.get( 'ANGLE_instanced_arrays' );
-		}
-	},
-	enableScissorTest: {
-		value: function ( boolean ) {
-			console.warn( 'THREE.WebGLRenderer: .enableScissorTest() is now .setScissorTest().' );
-			this.setScissorTest( boolean );
-		}
-	},
-	initMaterial: {
-		value: function () {
-			console.warn( 'THREE.WebGLRenderer: .initMaterial() has been removed.' );
-		}
-	},
-	addPrePlugin: {
-		value: function () {
-			console.warn( 'THREE.WebGLRenderer: .addPrePlugin() has been removed.' );
-		}
-	},
-	addPostPlugin: {
-		value: function () {
-			console.warn( 'THREE.WebGLRenderer: .addPostPlugin() has been removed.' );
-		}
-	},
-	updateShadowMap: {
-		value: function () {
-			console.warn( 'THREE.WebGLRenderer: .updateShadowMap() has been removed.' );
-		}
-	},
-	shadowMapEnabled: {
-		get: function () {
-			return this.shadowMap.enabled;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.WebGLRenderer: .shadowMapEnabled is now .shadowMap.enabled.' );
-			this.shadowMap.enabled = value;
-		}
-	},
-	shadowMapType: {
-		get: function () {
-			return this.shadowMap.type;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.WebGLRenderer: .shadowMapType is now .shadowMap.type.' );
-			this.shadowMap.type = value;
-		}
-	},
-	shadowMapCullFace: {
-		get: function () {
-			return this.shadowMap.cullFace;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.WebGLRenderer: .shadowMapCullFace is now .shadowMap.cullFace.' );
-			this.shadowMap.cullFace = value;
-		}
-	}
-} );
-
-//
-
-Object.defineProperties( THREE.WebGLRenderTarget.prototype, {
-	wrapS: {
-		get: function () {
-			console.warn( 'THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.' );
-			return this.texture.wrapS;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.WebGLRenderTarget: .wrapS is now .texture.wrapS.' );
-			this.texture.wrapS = value;
-		}
-	},
-	wrapT: {
-		get: function () {
-			console.warn( 'THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.' );
-			return this.texture.wrapT;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.WebGLRenderTarget: .wrapT is now .texture.wrapT.' );
-			this.texture.wrapT = value;
-		}
-	},
-	magFilter: {
-		get: function () {
-			console.warn( 'THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.' );
-			return this.texture.magFilter;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.WebGLRenderTarget: .magFilter is now .texture.magFilter.' );
-			this.texture.magFilter = value;
-		}
-	},
-	minFilter: {
-		get: function () {
-			console.warn( 'THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.' );
-			return this.texture.minFilter;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.WebGLRenderTarget: .minFilter is now .texture.minFilter.' );
-			this.texture.minFilter = value;
-		}
-	},
-	anisotropy: {
-		get: function () {
-			console.warn( 'THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.' );
-			return this.texture.anisotropy;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.WebGLRenderTarget: .anisotropy is now .texture.anisotropy.' );
-			this.texture.anisotropy = value;
-		}
-	},
-	offset: {
-		get: function () {
-			console.warn( 'THREE.WebGLRenderTarget: .offset is now .texture.offset.' );
-			return this.texture.offset;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.WebGLRenderTarget: .offset is now .texture.offset.' );
-			this.texture.offset = value;
-		}
-	},
-	repeat: {
-		get: function () {
-			console.warn( 'THREE.WebGLRenderTarget: .repeat is now .texture.repeat.' );
-			return this.texture.repeat;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.WebGLRenderTarget: .repeat is now .texture.repeat.' );
-			this.texture.repeat = value;
-		}
-	},
-	format: {
-		get: function () {
-			console.warn( 'THREE.WebGLRenderTarget: .format is now .texture.format.' );
-			return this.texture.format;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.WebGLRenderTarget: .format is now .texture.format.' );
-			this.texture.format = value;
-		}
-	},
-	type: {
-		get: function () {
-			console.warn( 'THREE.WebGLRenderTarget: .type is now .texture.type.' );
-			return this.texture.type;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.WebGLRenderTarget: .type is now .texture.type.' );
-			this.texture.type = value;
-		}
-	},
-	generateMipmaps: {
-		get: function () {
-			console.warn( 'THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.' );
-			return this.texture.generateMipmaps;
-		},
-		set: function ( value ) {
-			console.warn( 'THREE.WebGLRenderTarget: .generateMipmaps is now .texture.generateMipmaps.' );
-			this.texture.generateMipmaps = value;
-		}
-	}
-} );
-
-//
-
-Object.defineProperties( THREE.Audio.prototype, {
-	load: {
-		value: function ( file ) {
-
-			console.warn( 'THREE.Audio: .load has been deprecated. Please use THREE.AudioLoader.' );
-
-			var scope = this;
-
-			var audioLoader = new THREE.AudioLoader();
-
-			audioLoader.load( file, function ( buffer ) {
-
-				scope.setBuffer( buffer );
-
-			} );
-
-			return this;
-
-		}
-	}
-} );
-
-//
-
-THREE.GeometryUtils = {
-
-	merge: function ( geometry1, geometry2, materialIndexOffset ) {
-
-		console.warn( 'THREE.GeometryUtils: .merge() has been moved to Geometry. Use geometry.merge( geometry2, matrix, materialIndexOffset ) instead.' );
-
-		var matrix;
-
-		if ( geometry2 instanceof THREE.Mesh ) {
-
-			geometry2.matrixAutoUpdate && geometry2.updateMatrix();
-
-			matrix = geometry2.matrix;
-			geometry2 = geometry2.geometry;
-
-		}
-
-		geometry1.merge( geometry2, matrix, materialIndexOffset );
-
-	},
-
-	center: function ( geometry ) {
-
-		console.warn( 'THREE.GeometryUtils: .center() has been moved to Geometry. Use geometry.center() instead.' );
-		return geometry.center();
-
-	}
-
-};
-
-THREE.ImageUtils = {
-
-	crossOrigin: undefined,
-
-	loadTexture: function ( url, mapping, onLoad, onError ) {
-
-		console.warn( 'THREE.ImageUtils.loadTexture has been deprecated. Use THREE.TextureLoader() instead.' );
-
-		var loader = new THREE.TextureLoader();
-		loader.setCrossOrigin( this.crossOrigin );
-
-		var texture = loader.load( url, onLoad, undefined, onError );
-
-		if ( mapping ) texture.mapping = mapping;
-
-		return texture;
-
-	},
-
-	loadTextureCube: function ( urls, mapping, onLoad, onError ) {
-
-		console.warn( 'THREE.ImageUtils.loadTextureCube has been deprecated. Use THREE.CubeTextureLoader() instead.' );
-
-		var loader = new THREE.CubeTextureLoader();
-		loader.setCrossOrigin( this.crossOrigin );
-
-		var texture = loader.load( urls, onLoad, undefined, onError );
-
-		if ( mapping ) texture.mapping = mapping;
-
-		return texture;
-
-	},
-
-	loadCompressedTexture: function () {
-
-		console.error( 'THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.' );
-
-	},
-
-	loadCompressedTextureCube: function () {
-
-		console.error( 'THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.' );
-
-	}
-
-};
-
-//
-
-THREE.Projector = function () {
-
-	console.error( 'THREE.Projector has been moved to /examples/js/renderers/Projector.js.' );
-
-	this.projectVector = function ( vector, camera ) {
-
-		console.warn( 'THREE.Projector: .projectVector() is now vector.project().' );
-		vector.project( camera );
-
-	};
-
-	this.unprojectVector = function ( vector, camera ) {
-
-		console.warn( 'THREE.Projector: .unprojectVector() is now vector.unproject().' );
-		vector.unproject( camera );
-
-	};
-
-	this.pickingRay = function ( vector, camera ) {
-
-		console.error( 'THREE.Projector: .pickingRay() is now raycaster.setFromCamera().' );
-
-	};
-
-};
-
-//
-
-THREE.CanvasRenderer = function () {
-
-	console.error( 'THREE.CanvasRenderer has been moved to /examples/js/renderers/CanvasRenderer.js' );
-
-	this.domElement = document.createElement( 'canvas' );
-	this.clear = function () {};
-	this.render = function () {};
-	this.setClearColor = function () {};
-	this.setSize = function () {};
-
-};
-
-//
-
-THREE.MeshFaceMaterial = THREE.MultiMaterial;
-
-//
-
-Object.defineProperties( THREE.LOD.prototype, {
-	objects: {
-		get: function () {
-
-			console.warn( 'THREE.LOD: .objects has been renamed to .levels.' );
-			return this.levels;
-
-		}
-	}
-} );
-
-// File:src/extras/CurveUtils.js
-
-/**
- * @author zz85 / http://www.lab4games.net/zz85/blog
- */
-
-THREE.CurveUtils = {
-
-	tangentQuadraticBezier: function ( t, p0, p1, p2 ) {
-
-		return 2 * ( 1 - t ) * ( p1 - p0 ) + 2 * t * ( p2 - p1 );
-
-	},
-
-	// Puay Bing, thanks for helping with this derivative!
-
-	tangentCubicBezier: function ( t, p0, p1, p2, p3 ) {
-
-		return - 3 * p0 * ( 1 - t ) * ( 1 - t )  +
-			3 * p1 * ( 1 - t ) * ( 1 - t ) - 6 * t * p1 * ( 1 - t ) +
-			6 * t *  p2 * ( 1 - t ) - 3 * t * t * p2 +
-			3 * t * t * p3;
-
-	},
-
-	tangentSpline: function ( t, p0, p1, p2, p3 ) {
-
-		// To check if my formulas are correct
-
-		var h00 = 6 * t * t - 6 * t; 	// derived from 2t^3 − 3t^2 + 1
-		var h10 = 3 * t * t - 4 * t + 1; // t^3 − 2t^2 + t
-		var h01 = - 6 * t * t + 6 * t; 	// − 2t3 + 3t2
-		var h11 = 3 * t * t - 2 * t;	// t3 − t2
-
-		return h00 + h10 + h01 + h11;
-
-	},
-
-	// Catmull-Rom
-
-	interpolate: function( p0, p1, p2, p3, t ) {
-
-		var v0 = ( p2 - p0 ) * 0.5;
-		var v1 = ( p3 - p1 ) * 0.5;
-		var t2 = t * t;
-		var t3 = t * t2;
-		return ( 2 * p1 - 2 * p2 + v0 + v1 ) * t3 + ( - 3 * p1 + 3 * p2 - 2 * v0 - v1 ) * t2 + v0 * t + p1;
-
-	}
-
-};
-
-// File:src/extras/SceneUtils.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.SceneUtils = {
-
-	createMultiMaterialObject: function ( geometry, materials ) {
-
-		var group = new THREE.Group();
-
-		for ( var i = 0, l = materials.length; i < l; i ++ ) {
-
-			group.add( new THREE.Mesh( geometry, materials[ i ] ) );
-
-		}
-
-		return group;
-
-	},
-
-	detach: function ( child, parent, scene ) {
-
-		child.applyMatrix( parent.matrixWorld );
-		parent.remove( child );
-		scene.add( child );
-
-	},
-
-	attach: function ( child, scene, parent ) {
-
-		var matrixWorldInverse = new THREE.Matrix4();
-		matrixWorldInverse.getInverse( parent.matrixWorld );
-		child.applyMatrix( matrixWorldInverse );
-
-		scene.remove( child );
-		parent.add( child );
-
-	}
-
-};
-
-// File:src/extras/ShapeUtils.js
-
-/**
- * @author zz85 / http://www.lab4games.net/zz85/blog
- */
-
-THREE.ShapeUtils = {
-
-	// calculate area of the contour polygon
-
-	area: function ( contour ) {
-
-		var n = contour.length;
-		var a = 0.0;
-
-		for ( var p = n - 1, q = 0; q < n; p = q ++ ) {
-
-			a += contour[ p ].x * contour[ q ].y - contour[ q ].x * contour[ p ].y;
-
-		}
-
-		return a * 0.5;
-
-	},
-
-	triangulate: ( function () {
-
-		/**
-		 * This code is a quick port of code written in C++ which was submitted to
-		 * flipcode.com by John W. Ratcliff  // July 22, 2000
-		 * See original code and more information here:
-		 * http://www.flipcode.com/archives/Efficient_Polygon_Triangulation.shtml
-		 *
-		 * ported to actionscript by Zevan Rosser
-		 * www.actionsnippet.com
-		 *
-		 * ported to javascript by Joshua Koo
-		 * http://www.lab4games.net/zz85/blog
-		 *
-		 */
-
-		function snip( contour, u, v, w, n, verts ) {
-
-			var p;
-			var ax, ay, bx, by;
-			var cx, cy, px, py;
-
-			ax = contour[ verts[ u ] ].x;
-			ay = contour[ verts[ u ] ].y;
-
-			bx = contour[ verts[ v ] ].x;
-			by = contour[ verts[ v ] ].y;
-
-			cx = contour[ verts[ w ] ].x;
-			cy = contour[ verts[ w ] ].y;
-
-			if ( Number.EPSILON > ( ( ( bx - ax ) * ( cy - ay ) ) - ( ( by - ay ) * ( cx - ax ) ) ) ) return false;
-
-			var aX, aY, bX, bY, cX, cY;
-			var apx, apy, bpx, bpy, cpx, cpy;
-			var cCROSSap, bCROSScp, aCROSSbp;
-
-			aX = cx - bx;  aY = cy - by;
-			bX = ax - cx;  bY = ay - cy;
-			cX = bx - ax;  cY = by - ay;
-
-			for ( p = 0; p < n; p ++ ) {
-
-				px = contour[ verts[ p ] ].x;
-				py = contour[ verts[ p ] ].y;
-
-				if ( ( ( px === ax ) && ( py === ay ) ) ||
-					 ( ( px === bx ) && ( py === by ) ) ||
-					 ( ( px === cx ) && ( py === cy ) ) )	continue;
-
-				apx = px - ax;  apy = py - ay;
-				bpx = px - bx;  bpy = py - by;
-				cpx = px - cx;  cpy = py - cy;
-
-				// see if p is inside triangle abc
-
-				aCROSSbp = aX * bpy - aY * bpx;
-				cCROSSap = cX * apy - cY * apx;
-				bCROSScp = bX * cpy - bY * cpx;
-
-				if ( ( aCROSSbp >= - Number.EPSILON ) && ( bCROSScp >= - Number.EPSILON ) && ( cCROSSap >= - Number.EPSILON ) ) return false;
-
-			}
-
-			return true;
-
-		}
-
-		// takes in an contour array and returns
-
-		return function ( contour, indices ) {
-
-			var n = contour.length;
-
-			if ( n < 3 ) return null;
-
-			var result = [],
-				verts = [],
-				vertIndices = [];
-
-			/* we want a counter-clockwise polygon in verts */
-
-			var u, v, w;
-
-			if ( THREE.ShapeUtils.area( contour ) > 0.0 ) {
-
-				for ( v = 0; v < n; v ++ ) verts[ v ] = v;
-
-			} else {
-
-				for ( v = 0; v < n; v ++ ) verts[ v ] = ( n - 1 ) - v;
-
-			}
-
-			var nv = n;
-
-			/*  remove nv - 2 vertices, creating 1 triangle every time */
-
-			var count = 2 * nv;   /* error detection */
-
-			for ( v = nv - 1; nv > 2; ) {
-
-				/* if we loop, it is probably a non-simple polygon */
-
-				if ( ( count -- ) <= 0 ) {
-
-					//** Triangulate: ERROR - probable bad polygon!
-
-					//throw ( "Warning, unable to triangulate polygon!" );
-					//return null;
-					// Sometimes warning is fine, especially polygons are triangulated in reverse.
-					console.warn( 'THREE.ShapeUtils: Unable to triangulate polygon! in triangulate()' );
-
-					if ( indices ) return vertIndices;
-					return result;
-
-				}
-
-				/* three consecutive vertices in current polygon, <u,v,w> */
-
-				u = v; 	 	if ( nv <= u ) u = 0;     /* previous */
-				v = u + 1;  if ( nv <= v ) v = 0;     /* new v    */
-				w = v + 1;  if ( nv <= w ) w = 0;     /* next     */
-
-				if ( snip( contour, u, v, w, nv, verts ) ) {
-
-					var a, b, c, s, t;
-
-					/* true names of the vertices */
-
-					a = verts[ u ];
-					b = verts[ v ];
-					c = verts[ w ];
-
-					/* output Triangle */
-
-					result.push( [ contour[ a ],
-						contour[ b ],
-						contour[ c ] ] );
-
-
-					vertIndices.push( [ verts[ u ], verts[ v ], verts[ w ] ] );
-
-					/* remove v from the remaining polygon */
-
-					for ( s = v, t = v + 1; t < nv; s ++, t ++ ) {
-
-						verts[ s ] = verts[ t ];
-
-					}
-
-					nv --;
-
-					/* reset error detection counter */
-
-					count = 2 * nv;
-
-				}
-
-			}
-
-			if ( indices ) return vertIndices;
-			return result;
-
-		}
-
-	} )(),
-
-	triangulateShape: function ( contour, holes ) {
-
-		function point_in_segment_2D_colin( inSegPt1, inSegPt2, inOtherPt ) {
-
-			// inOtherPt needs to be collinear to the inSegment
-			if ( inSegPt1.x !== inSegPt2.x ) {
-
-				if ( inSegPt1.x < inSegPt2.x ) {
-
-					return	( ( inSegPt1.x <= inOtherPt.x ) && ( inOtherPt.x <= inSegPt2.x ) );
-
-				} else {
-
-					return	( ( inSegPt2.x <= inOtherPt.x ) && ( inOtherPt.x <= inSegPt1.x ) );
-
-				}
-
-			} else {
-
-				if ( inSegPt1.y < inSegPt2.y ) {
-
-					return	( ( inSegPt1.y <= inOtherPt.y ) && ( inOtherPt.y <= inSegPt2.y ) );
-
-				} else {
-
-					return	( ( inSegPt2.y <= inOtherPt.y ) && ( inOtherPt.y <= inSegPt1.y ) );
-
-				}
-
-			}
-
-		}
-
-		function intersect_segments_2D( inSeg1Pt1, inSeg1Pt2, inSeg2Pt1, inSeg2Pt2, inExcludeAdjacentSegs ) {
-
-			var seg1dx = inSeg1Pt2.x - inSeg1Pt1.x,   seg1dy = inSeg1Pt2.y - inSeg1Pt1.y;
-			var seg2dx = inSeg2Pt2.x - inSeg2Pt1.x,   seg2dy = inSeg2Pt2.y - inSeg2Pt1.y;
-
-			var seg1seg2dx = inSeg1Pt1.x - inSeg2Pt1.x;
-			var seg1seg2dy = inSeg1Pt1.y - inSeg2Pt1.y;
-
-			var limit		= seg1dy * seg2dx - seg1dx * seg2dy;
-			var perpSeg1	= seg1dy * seg1seg2dx - seg1dx * seg1seg2dy;
-
-			if ( Math.abs( limit ) > Number.EPSILON ) {
-
-				// not parallel
-
-				var perpSeg2;
-				if ( limit > 0 ) {
-
-					if ( ( perpSeg1 < 0 ) || ( perpSeg1 > limit ) ) 		return [];
-					perpSeg2 = seg2dy * seg1seg2dx - seg2dx * seg1seg2dy;
-					if ( ( perpSeg2 < 0 ) || ( perpSeg2 > limit ) ) 		return [];
-
-				} else {
-
-					if ( ( perpSeg1 > 0 ) || ( perpSeg1 < limit ) ) 		return [];
-					perpSeg2 = seg2dy * seg1seg2dx - seg2dx * seg1seg2dy;
-					if ( ( perpSeg2 > 0 ) || ( perpSeg2 < limit ) ) 		return [];
-
-				}
-
-				// i.e. to reduce rounding errors
-				// intersection at endpoint of segment#1?
-				if ( perpSeg2 === 0 ) {
-
-					if ( ( inExcludeAdjacentSegs ) &&
-						 ( ( perpSeg1 === 0 ) || ( perpSeg1 === limit ) ) )		return [];
-					return [ inSeg1Pt1 ];
-
-				}
-				if ( perpSeg2 === limit ) {
-
-					if ( ( inExcludeAdjacentSegs ) &&
-						 ( ( perpSeg1 === 0 ) || ( perpSeg1 === limit ) ) )		return [];
-					return [ inSeg1Pt2 ];
-
-				}
-				// intersection at endpoint of segment#2?
-				if ( perpSeg1 === 0 )		return [ inSeg2Pt1 ];
-				if ( perpSeg1 === limit )	return [ inSeg2Pt2 ];
-
-				// return real intersection point
-				var factorSeg1 = perpSeg2 / limit;
-				return	[ { x: inSeg1Pt1.x + factorSeg1 * seg1dx,
-							y: inSeg1Pt1.y + factorSeg1 * seg1dy } ];
-
-			} else {
-
-				// parallel or collinear
-				if ( ( perpSeg1 !== 0 ) ||
-					 ( seg2dy * seg1seg2dx !== seg2dx * seg1seg2dy ) ) 			return [];
-
-				// they are collinear or degenerate
-				var seg1Pt = ( ( seg1dx === 0 ) && ( seg1dy === 0 ) );	// segment1 is just a point?
-				var seg2Pt = ( ( seg2dx === 0 ) && ( seg2dy === 0 ) );	// segment2 is just a point?
-				// both segments are points
-				if ( seg1Pt && seg2Pt ) {
-
-					if ( ( inSeg1Pt1.x !== inSeg2Pt1.x ) ||
-						 ( inSeg1Pt1.y !== inSeg2Pt1.y ) )		return [];	// they are distinct  points
-					return [ inSeg1Pt1 ];                 						// they are the same point
-
-				}
-				// segment#1  is a single point
-				if ( seg1Pt ) {
-
-					if ( ! point_in_segment_2D_colin( inSeg2Pt1, inSeg2Pt2, inSeg1Pt1 ) )		return [];		// but not in segment#2
-					return [ inSeg1Pt1 ];
-
-				}
-				// segment#2  is a single point
-				if ( seg2Pt ) {
-
-					if ( ! point_in_segment_2D_colin( inSeg1Pt1, inSeg1Pt2, inSeg2Pt1 ) )		return [];		// but not in segment#1
-					return [ inSeg2Pt1 ];
-
-				}
-
-				// they are collinear segments, which might overlap
-				var seg1min, seg1max, seg1minVal, seg1maxVal;
-				var seg2min, seg2max, seg2minVal, seg2maxVal;
-				if ( seg1dx !== 0 ) {
-
-					// the segments are NOT on a vertical line
-					if ( inSeg1Pt1.x < inSeg1Pt2.x ) {
-
-						seg1min = inSeg1Pt1; seg1minVal = inSeg1Pt1.x;
-						seg1max = inSeg1Pt2; seg1maxVal = inSeg1Pt2.x;
-
-					} else {
-
-						seg1min = inSeg1Pt2; seg1minVal = inSeg1Pt2.x;
-						seg1max = inSeg1Pt1; seg1maxVal = inSeg1Pt1.x;
-
-					}
-					if ( inSeg2Pt1.x < inSeg2Pt2.x ) {
-
-						seg2min = inSeg2Pt1; seg2minVal = inSeg2Pt1.x;
-						seg2max = inSeg2Pt2; seg2maxVal = inSeg2Pt2.x;
-
-					} else {
-
-						seg2min = inSeg2Pt2; seg2minVal = inSeg2Pt2.x;
-						seg2max = inSeg2Pt1; seg2maxVal = inSeg2Pt1.x;
-
-					}
-
-				} else {
-
-					// the segments are on a vertical line
-					if ( inSeg1Pt1.y < inSeg1Pt2.y ) {
-
-						seg1min = inSeg1Pt1; seg1minVal = inSeg1Pt1.y;
-						seg1max = inSeg1Pt2; seg1maxVal = inSeg1Pt2.y;
-
-					} else {
-
-						seg1min = inSeg1Pt2; seg1minVal = inSeg1Pt2.y;
-						seg1max = inSeg1Pt1; seg1maxVal = inSeg1Pt1.y;
-
-					}
-					if ( inSeg2Pt1.y < inSeg2Pt2.y ) {
-
-						seg2min = inSeg2Pt1; seg2minVal = inSeg2Pt1.y;
-						seg2max = inSeg2Pt2; seg2maxVal = inSeg2Pt2.y;
-
-					} else {
-
-						seg2min = inSeg2Pt2; seg2minVal = inSeg2Pt2.y;
-						seg2max = inSeg2Pt1; seg2maxVal = inSeg2Pt1.y;
-
-					}
-
-				}
-				if ( seg1minVal <= seg2minVal ) {
-
-					if ( seg1maxVal <  seg2minVal )	return [];
-					if ( seg1maxVal === seg2minVal )	{
-
-						if ( inExcludeAdjacentSegs )		return [];
-						return [ seg2min ];
-
-					}
-					if ( seg1maxVal <= seg2maxVal )	return [ seg2min, seg1max ];
-					return	[ seg2min, seg2max ];
-
-				} else {
-
-					if ( seg1minVal >  seg2maxVal )	return [];
-					if ( seg1minVal === seg2maxVal )	{
-
-						if ( inExcludeAdjacentSegs )		return [];
-						return [ seg1min ];
-
-					}
-					if ( seg1maxVal <= seg2maxVal )	return [ seg1min, seg1max ];
-					return	[ seg1min, seg2max ];
-
-				}
-
-			}
-
-		}
-
-		function isPointInsideAngle( inVertex, inLegFromPt, inLegToPt, inOtherPt ) {
-
-			// The order of legs is important
-
-			// translation of all points, so that Vertex is at (0,0)
-			var legFromPtX	= inLegFromPt.x - inVertex.x,  legFromPtY	= inLegFromPt.y - inVertex.y;
-			var legToPtX	= inLegToPt.x	- inVertex.x,  legToPtY		= inLegToPt.y	- inVertex.y;
-			var otherPtX	= inOtherPt.x	- inVertex.x,  otherPtY		= inOtherPt.y	- inVertex.y;
-
-			// main angle >0: < 180 deg.; 0: 180 deg.; <0: > 180 deg.
-			var from2toAngle	= legFromPtX * legToPtY - legFromPtY * legToPtX;
-			var from2otherAngle	= legFromPtX * otherPtY - legFromPtY * otherPtX;
-
-			if ( Math.abs( from2toAngle ) > Number.EPSILON ) {
-
-				// angle != 180 deg.
-
-				var other2toAngle		= otherPtX * legToPtY - otherPtY * legToPtX;
-				// console.log( "from2to: " + from2toAngle + ", from2other: " + from2otherAngle + ", other2to: " + other2toAngle );
-
-				if ( from2toAngle > 0 ) {
-
-					// main angle < 180 deg.
-					return	( ( from2otherAngle >= 0 ) && ( other2toAngle >= 0 ) );
-
-				} else {
-
-					// main angle > 180 deg.
-					return	( ( from2otherAngle >= 0 ) || ( other2toAngle >= 0 ) );
-
-				}
-
-			} else {
-
-				// angle == 180 deg.
-				// console.log( "from2to: 180 deg., from2other: " + from2otherAngle  );
-				return	( from2otherAngle > 0 );
-
-			}
-
-		}
-
-
-		function removeHoles( contour, holes ) {
-
-			var shape = contour.concat(); // work on this shape
-			var hole;
-
-			function isCutLineInsideAngles( inShapeIdx, inHoleIdx ) {
-
-				// Check if hole point lies within angle around shape point
-				var lastShapeIdx = shape.length - 1;
-
-				var prevShapeIdx = inShapeIdx - 1;
-				if ( prevShapeIdx < 0 )			prevShapeIdx = lastShapeIdx;
-
-				var nextShapeIdx = inShapeIdx + 1;
-				if ( nextShapeIdx > lastShapeIdx )	nextShapeIdx = 0;
-
-				var insideAngle = isPointInsideAngle( shape[ inShapeIdx ], shape[ prevShapeIdx ], shape[ nextShapeIdx ], hole[ inHoleIdx ] );
-				if ( ! insideAngle ) {
-
-					// console.log( "Vertex (Shape): " + inShapeIdx + ", Point: " + hole[inHoleIdx].x + "/" + hole[inHoleIdx].y );
-					return	false;
-
-				}
-
-				// Check if shape point lies within angle around hole point
-				var lastHoleIdx = hole.length - 1;
-
-				var prevHoleIdx = inHoleIdx - 1;
-				if ( prevHoleIdx < 0 )			prevHoleIdx = lastHoleIdx;
-
-				var nextHoleIdx = inHoleIdx + 1;
-				if ( nextHoleIdx > lastHoleIdx )	nextHoleIdx = 0;
-
-				insideAngle = isPointInsideAngle( hole[ inHoleIdx ], hole[ prevHoleIdx ], hole[ nextHoleIdx ], shape[ inShapeIdx ] );
-				if ( ! insideAngle ) {
-
-					// console.log( "Vertex (Hole): " + inHoleIdx + ", Point: " + shape[inShapeIdx].x + "/" + shape[inShapeIdx].y );
-					return	false;
-
-				}
-
-				return	true;
-
-			}
-
-			function intersectsShapeEdge( inShapePt, inHolePt ) {
-
-				// checks for intersections with shape edges
-				var sIdx, nextIdx, intersection;
-				for ( sIdx = 0; sIdx < shape.length; sIdx ++ ) {
-
-					nextIdx = sIdx + 1; nextIdx %= shape.length;
-					intersection = intersect_segments_2D( inShapePt, inHolePt, shape[ sIdx ], shape[ nextIdx ], true );
-					if ( intersection.length > 0 )		return	true;
-
-				}
-
-				return	false;
-
-			}
-
-			var indepHoles = [];
-
-			function intersectsHoleEdge( inShapePt, inHolePt ) {
-
-				// checks for intersections with hole edges
-				var ihIdx, chkHole,
-					hIdx, nextIdx, intersection;
-				for ( ihIdx = 0; ihIdx < indepHoles.length; ihIdx ++ ) {
-
-					chkHole = holes[ indepHoles[ ihIdx ]];
-					for ( hIdx = 0; hIdx < chkHole.length; hIdx ++ ) {
-
-						nextIdx = hIdx + 1; nextIdx %= chkHole.length;
-						intersection = intersect_segments_2D( inShapePt, inHolePt, chkHole[ hIdx ], chkHole[ nextIdx ], true );
-						if ( intersection.length > 0 )		return	true;
-
-					}
-
-				}
-				return	false;
-
-			}
-
-			var holeIndex, shapeIndex,
-				shapePt, holePt,
-				holeIdx, cutKey, failedCuts = [],
-				tmpShape1, tmpShape2,
-				tmpHole1, tmpHole2;
-
-			for ( var h = 0, hl = holes.length; h < hl; h ++ ) {
-
-				indepHoles.push( h );
-
-			}
-
-			var minShapeIndex = 0;
-			var counter = indepHoles.length * 2;
-			while ( indepHoles.length > 0 ) {
-
-				counter --;
-				if ( counter < 0 ) {
-
-					console.log( "Infinite Loop! Holes left:" + indepHoles.length + ", Probably Hole outside Shape!" );
-					break;
-
-				}
-
-				// search for shape-vertex and hole-vertex,
-				// which can be connected without intersections
-				for ( shapeIndex = minShapeIndex; shapeIndex < shape.length; shapeIndex ++ ) {
-
-					shapePt = shape[ shapeIndex ];
-					holeIndex	= - 1;
-
-					// search for hole which can be reached without intersections
-					for ( var h = 0; h < indepHoles.length; h ++ ) {
-
-						holeIdx = indepHoles[ h ];
-
-						// prevent multiple checks
-						cutKey = shapePt.x + ":" + shapePt.y + ":" + holeIdx;
-						if ( failedCuts[ cutKey ] !== undefined )			continue;
-
-						hole = holes[ holeIdx ];
-						for ( var h2 = 0; h2 < hole.length; h2 ++ ) {
-
-							holePt = hole[ h2 ];
-							if ( ! isCutLineInsideAngles( shapeIndex, h2 ) )		continue;
-							if ( intersectsShapeEdge( shapePt, holePt ) )		continue;
-							if ( intersectsHoleEdge( shapePt, holePt ) )		continue;
-
-							holeIndex = h2;
-							indepHoles.splice( h, 1 );
-
-							tmpShape1 = shape.slice( 0, shapeIndex + 1 );
-							tmpShape2 = shape.slice( shapeIndex );
-							tmpHole1 = hole.slice( holeIndex );
-							tmpHole2 = hole.slice( 0, holeIndex + 1 );
-
-							shape = tmpShape1.concat( tmpHole1 ).concat( tmpHole2 ).concat( tmpShape2 );
-
-							minShapeIndex = shapeIndex;
-
-							// Debug only, to show the selected cuts
-							// glob_CutLines.push( [ shapePt, holePt ] );
-
-							break;
-
-						}
-						if ( holeIndex >= 0 )	break;		// hole-vertex found
-
-						failedCuts[ cutKey ] = true;			// remember failure
-
-					}
-					if ( holeIndex >= 0 )	break;		// hole-vertex found
-
-				}
-
-			}
-
-			return shape; 			/* shape with no holes */
-
-		}
-
-
-		var i, il, f, face,
-			key, index,
-			allPointsMap = {};
-
-		// To maintain reference to old shape, one must match coordinates, or offset the indices from original arrays. It's probably easier to do the first.
-
-		var allpoints = contour.concat();
-
-		for ( var h = 0, hl = holes.length; h < hl; h ++ ) {
-
-			Array.prototype.push.apply( allpoints, holes[ h ] );
-
-		}
-
-		//console.log( "allpoints",allpoints, allpoints.length );
-
-		// prepare all points map
-
-		for ( i = 0, il = allpoints.length; i < il; i ++ ) {
-
-			key = allpoints[ i ].x + ":" + allpoints[ i ].y;
-
-			if ( allPointsMap[ key ] !== undefined ) {
-
-				console.warn( "THREE.Shape: Duplicate point", key );
-
-			}
-
-			allPointsMap[ key ] = i;
-
-		}
-
-		// remove holes by cutting paths to holes and adding them to the shape
-		var shapeWithoutHoles = removeHoles( contour, holes );
-
-		var triangles = THREE.ShapeUtils.triangulate( shapeWithoutHoles, false ); // True returns indices for points of spooled shape
-		//console.log( "triangles",triangles, triangles.length );
-
-		// check all face vertices against all points map
-
-		for ( i = 0, il = triangles.length; i < il; i ++ ) {
-
-			face = triangles[ i ];
-
-			for ( f = 0; f < 3; f ++ ) {
-
-				key = face[ f ].x + ":" + face[ f ].y;
-
-				index = allPointsMap[ key ];
-
-				if ( index !== undefined ) {
-
-					face[ f ] = index;
-
-				}
-
-			}
-
-		}
-
-		return triangles.concat();
-
-	},
-
-	isClockWise: function ( pts ) {
-
-		return THREE.ShapeUtils.area( pts ) < 0;
-
-	},
-
-	// Bezier Curves formulas obtained from
-	// http://en.wikipedia.org/wiki/B%C3%A9zier_curve
-
-	// Quad Bezier Functions
-
-	b2: ( function () {
-
-		function b2p0( t, p ) {
-
-			var k = 1 - t;
-			return k * k * p;
-
-		}
-
-		function b2p1( t, p ) {
-
-			return 2 * ( 1 - t ) * t * p;
-
-		}
-
-		function b2p2( t, p ) {
-
-			return t * t * p;
-
-		}
-
-		return function ( t, p0, p1, p2 ) {
-
-			return b2p0( t, p0 ) + b2p1( t, p1 ) + b2p2( t, p2 );
-
-		};
-
-	} )(),
-
-	// Cubic Bezier Functions
-
-	b3: ( function () {
-
-		function b3p0( t, p ) {
-
-			var k = 1 - t;
-			return k * k * k * p;
-
-		}
-
-		function b3p1( t, p ) {
-
-			var k = 1 - t;
-			return 3 * k * k * t * p;
-
-		}
-
-		function b3p2( t, p ) {
-
-			var k = 1 - t;
-			return 3 * k * t * t * p;
-
-		}
-
-		function b3p3( t, p ) {
-
-			return t * t * t * p;
-
-		}
-
-		return function ( t, p0, p1, p2, p3 ) {
-
-			return b3p0( t, p0 ) + b3p1( t, p1 ) + b3p2( t, p2 ) + b3p3( t, p3 );
-
-		};
-
-	} )()
-
-};
-
-// File:src/extras/core/Curve.js
-
-/**
- * @author zz85 / http://www.lab4games.net/zz85/blog
- * Extensible curve object
- *
- * Some common of Curve methods
- * .getPoint(t), getTangent(t)
- * .getPointAt(u), getTagentAt(u)
- * .getPoints(), .getSpacedPoints()
- * .getLength()
- * .updateArcLengths()
- *
- * This following classes subclasses THREE.Curve:
- *
- * -- 2d classes --
- * THREE.LineCurve
- * THREE.QuadraticBezierCurve
- * THREE.CubicBezierCurve
- * THREE.SplineCurve
- * THREE.ArcCurve
- * THREE.EllipseCurve
- *
- * -- 3d classes --
- * THREE.LineCurve3
- * THREE.QuadraticBezierCurve3
- * THREE.CubicBezierCurve3
- * THREE.SplineCurve3
- *
- * A series of curves can be represented as a THREE.CurvePath
- *
- **/
-
-/**************************************************************
- *	Abstract Curve base class
- **************************************************************/
-
-THREE.Curve = function () {
-
-};
-
-THREE.Curve.prototype = {
-
-	constructor: THREE.Curve,
-
-	// Virtual base class method to overwrite and implement in subclasses
-	//	- t [0 .. 1]
-
-	getPoint: function ( t ) {
-
-		console.warn( "THREE.Curve: Warning, getPoint() not implemented!" );
-		return null;
-
-	},
-
-	// Get point at relative position in curve according to arc length
-	// - u [0 .. 1]
-
-	getPointAt: function ( u ) {
-
-		var t = this.getUtoTmapping( u );
-		return this.getPoint( t );
-
-	},
-
-	// Get sequence of points using getPoint( t )
-
-	getPoints: function ( divisions ) {
-
-		if ( ! divisions ) divisions = 5;
-
-		var d, pts = [];
-
-		for ( d = 0; d <= divisions; d ++ ) {
-
-			pts.push( this.getPoint( d / divisions ) );
-
-		}
-
-		return pts;
-
-	},
-
-	// Get sequence of points using getPointAt( u )
-
-	getSpacedPoints: function ( divisions ) {
-
-		if ( ! divisions ) divisions = 5;
-
-		var d, pts = [];
-
-		for ( d = 0; d <= divisions; d ++ ) {
-
-			pts.push( this.getPointAt( d / divisions ) );
-
-		}
-
-		return pts;
-
-	},
-
-	// Get total curve arc length
-
-	getLength: function () {
-
-		var lengths = this.getLengths();
-		return lengths[ lengths.length - 1 ];
-
-	},
-
-	// Get list of cumulative segment lengths
-
-	getLengths: function ( divisions ) {
-
-		if ( ! divisions ) divisions = ( this.__arcLengthDivisions ) ? ( this.__arcLengthDivisions ) : 200;
-
-		if ( this.cacheArcLengths
-			&& ( this.cacheArcLengths.length === divisions + 1 )
-			&& ! this.needsUpdate ) {
-
-			//console.log( "cached", this.cacheArcLengths );
-			return this.cacheArcLengths;
-
-		}
-
-		this.needsUpdate = false;
-
-		var cache = [];
-		var current, last = this.getPoint( 0 );
-		var p, sum = 0;
-
-		cache.push( 0 );
-
-		for ( p = 1; p <= divisions; p ++ ) {
-
-			current = this.getPoint ( p / divisions );
-			sum += current.distanceTo( last );
-			cache.push( sum );
-			last = current;
-
-		}
-
-		this.cacheArcLengths = cache;
-
-		return cache; // { sums: cache, sum:sum }; Sum is in the last element.
-
-	},
-
-	updateArcLengths: function() {
-
-		this.needsUpdate = true;
-		this.getLengths();
-
-	},
-
-	// Given u ( 0 .. 1 ), get a t to find p. This gives you points which are equidistant
-
-	getUtoTmapping: function ( u, distance ) {
-
-		var arcLengths = this.getLengths();
-
-		var i = 0, il = arcLengths.length;
-
-		var targetArcLength; // The targeted u distance value to get
-
-		if ( distance ) {
-
-			targetArcLength = distance;
-
-		} else {
-
-			targetArcLength = u * arcLengths[ il - 1 ];
-
-		}
-
-		//var time = Date.now();
-
-		// binary search for the index with largest value smaller than target u distance
-
-		var low = 0, high = il - 1, comparison;
-
-		while ( low <= high ) {
-
-			i = Math.floor( low + ( high - low ) / 2 ); // less likely to overflow, though probably not issue here, JS doesn't really have integers, all numbers are floats
-
-			comparison = arcLengths[ i ] - targetArcLength;
-
-			if ( comparison < 0 ) {
-
-				low = i + 1;
-
-			} else if ( comparison > 0 ) {
-
-				high = i - 1;
-
-			} else {
-
-				high = i;
-				break;
-
-				// DONE
-
-			}
-
-		}
-
-		i = high;
-
-		//console.log('b' , i, low, high, Date.now()- time);
-
-		if ( arcLengths[ i ] === targetArcLength ) {
-
-			var t = i / ( il - 1 );
-			return t;
-
-		}
-
-		// we could get finer grain at lengths, or use simple interpolation between two points
-
-		var lengthBefore = arcLengths[ i ];
-		var lengthAfter = arcLengths[ i + 1 ];
-
-		var segmentLength = lengthAfter - lengthBefore;
-
-		// determine where we are between the 'before' and 'after' points
-
-		var segmentFraction = ( targetArcLength - lengthBefore ) / segmentLength;
-
-		// add that fractional amount to t
-
-		var t = ( i + segmentFraction ) / ( il - 1 );
-
-		return t;
-
-	},
-
-	// Returns a unit vector tangent at t
-	// In case any sub curve does not implement its tangent derivation,
-	// 2 points a small delta apart will be used to find its gradient
-	// which seems to give a reasonable approximation
-
-	getTangent: function( t ) {
-
-		var delta = 0.0001;
-		var t1 = t - delta;
-		var t2 = t + delta;
-
-		// Capping in case of danger
-
-		if ( t1 < 0 ) t1 = 0;
-		if ( t2 > 1 ) t2 = 1;
-
-		var pt1 = this.getPoint( t1 );
-		var pt2 = this.getPoint( t2 );
-
-		var vec = pt2.clone().sub( pt1 );
-		return vec.normalize();
-
-	},
-
-	getTangentAt: function ( u ) {
-
-		var t = this.getUtoTmapping( u );
-		return this.getTangent( t );
-
-	}
-
-};
-
-// TODO: Transformation for Curves?
-
-/**************************************************************
- *	3D Curves
- **************************************************************/
-
-// A Factory method for creating new curve subclasses
-
-THREE.Curve.create = function ( constructor, getPointFunc ) {
-
-	constructor.prototype = Object.create( THREE.Curve.prototype );
-	constructor.prototype.constructor = constructor;
-	constructor.prototype.getPoint = getPointFunc;
-
-	return constructor;
-
-};
-
-// File:src/extras/core/CurvePath.js
-
-/**
- * @author zz85 / http://www.lab4games.net/zz85/blog
- *
- **/
-
-/**************************************************************
- *	Curved Path - a curve path is simply a array of connected
- *  curves, but retains the api of a curve
- **************************************************************/
-
-THREE.CurvePath = function () {
-
-	this.curves = [];
-
-	this.autoClose = false; // Automatically closes the path
-
-};
-
-THREE.CurvePath.prototype = Object.create( THREE.Curve.prototype );
-THREE.CurvePath.prototype.constructor = THREE.CurvePath;
-
-THREE.CurvePath.prototype.add = function ( curve ) {
-
-	this.curves.push( curve );
-
-};
-
-/*
-THREE.CurvePath.prototype.checkConnection = function() {
-	// TODO
-	// If the ending of curve is not connected to the starting
-	// or the next curve, then, this is not a real path
-};
-*/
-
-THREE.CurvePath.prototype.closePath = function() {
-
-	// TODO Test
-	// and verify for vector3 (needs to implement equals)
-	// Add a line curve if start and end of lines are not connected
-	var startPoint = this.curves[ 0 ].getPoint( 0 );
-	var endPoint = this.curves[ this.curves.length - 1 ].getPoint( 1 );
-
-	if ( ! startPoint.equals( endPoint ) ) {
-
-		this.curves.push( new THREE.LineCurve( endPoint, startPoint ) );
-
-	}
-
-};
-
-// To get accurate point with reference to
-// entire path distance at time t,
-// following has to be done:
-
-// 1. Length of each sub path have to be known
-// 2. Locate and identify type of curve
-// 3. Get t for the curve
-// 4. Return curve.getPointAt(t')
-
-THREE.CurvePath.prototype.getPoint = function( t ) {
-
-	var d = t * this.getLength();
-	var curveLengths = this.getCurveLengths();
-	var i = 0;
-
-	// To think about boundaries points.
-
-	while ( i < curveLengths.length ) {
-
-		if ( curveLengths[ i ] >= d ) {
-
-			var diff = curveLengths[ i ] - d;
-			var curve = this.curves[ i ];
-
-			var u = 1 - diff / curve.getLength();
-
-			return curve.getPointAt( u );
-
-		}
-
-		i ++;
-
-	}
-
-	return null;
-
-	// loop where sum != 0, sum > d , sum+1 <d
-
-};
-
-/*
-THREE.CurvePath.prototype.getTangent = function( t ) {
-};
-*/
-
-// We cannot use the default THREE.Curve getPoint() with getLength() because in
-// THREE.Curve, getLength() depends on getPoint() but in THREE.CurvePath
-// getPoint() depends on getLength
-
-THREE.CurvePath.prototype.getLength = function() {
-
-	var lens = this.getCurveLengths();
-	return lens[ lens.length - 1 ];
-
-};
-
-// Compute lengths and cache them
-// We cannot overwrite getLengths() because UtoT mapping uses it.
-
-THREE.CurvePath.prototype.getCurveLengths = function() {
-
-	// We use cache values if curves and cache array are same length
-
-	if ( this.cacheLengths && this.cacheLengths.length === this.curves.length ) {
-
-		return this.cacheLengths;
-
-	}
-
-	// Get length of sub-curve
-	// Push sums into cached array
-
-	var lengths = [], sums = 0;
-
-	for ( var i = 0, l = this.curves.length; i < l; i ++ ) {
-
-		sums += this.curves[ i ].getLength();
-		lengths.push( sums );
-
-	}
-
-	this.cacheLengths = lengths;
-
-	return lengths;
-
-};
-
-
-
-/**************************************************************
- *	Create Geometries Helpers
- **************************************************************/
-
-/// Generate geometry from path points (for Line or Points objects)
-
-THREE.CurvePath.prototype.createPointsGeometry = function( divisions ) {
-
-	var pts = this.getPoints( divisions );
-	return this.createGeometry( pts );
-
-};
-
-// Generate geometry from equidistant sampling along the path
-
-THREE.CurvePath.prototype.createSpacedPointsGeometry = function( divisions ) {
-
-	var pts = this.getSpacedPoints( divisions );
-	return this.createGeometry( pts );
-
-};
-
-THREE.CurvePath.prototype.createGeometry = function( points ) {
-
-	var geometry = new THREE.Geometry();
-
-	for ( var i = 0, l = points.length; i < l; i ++ ) {
-
-		var point = points[ i ];
-		geometry.vertices.push( new THREE.Vector3( point.x, point.y, point.z || 0 ) );
-
-	}
-
-	return geometry;
-
-};
-
-// File:src/extras/core/Font.js
-
-/**
- * @author zz85 / http://www.lab4games.net/zz85/blog
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.Font = function ( data ) {
-
-	this.data = data;
-
-};
-
-THREE.Font.prototype = {
-
-	constructor: THREE.Font,
-
-	generateShapes: function ( text, size, divisions ) {
-
-		function createPaths( text ) {
-
-			var chars = String( text ).split( '' );
-			var scale = size / data.resolution;
-			var offset = 0;
-
-			var paths = [];
-
-			for ( var i = 0; i < chars.length; i ++ ) {
-
-				var ret = createPath( chars[ i ], scale, offset );
-				offset += ret.offset;
-
-				paths.push( ret.path );
-
-			}
-
-			return paths;
-
-		}
-
-		function createPath( c, scale, offset ) {
-
-			var glyph = data.glyphs[ c ] || data.glyphs[ '?' ];
-
-			if ( ! glyph ) return;
-
-			var path = new THREE.Path();
-
-			var pts = [], b2 = THREE.ShapeUtils.b2, b3 = THREE.ShapeUtils.b3;
-			var x, y, cpx, cpy, cpx0, cpy0, cpx1, cpy1, cpx2, cpy2, laste;
-
-			if ( glyph.o ) {
-
-				var outline = glyph._cachedOutline || ( glyph._cachedOutline = glyph.o.split( ' ' ) );
-
-				for ( var i = 0, l = outline.length; i < l; ) {
-
-					var action = outline[ i ++ ];
-
-					switch ( action ) {
-
-						case 'm': // moveTo
-
-							x = outline[ i ++ ] * scale + offset;
-							y = outline[ i ++ ] * scale;
-
-							path.moveTo( x, y );
-
-							break;
-
-						case 'l': // lineTo
-
-							x = outline[ i ++ ] * scale + offset;
-							y = outline[ i ++ ] * scale;
-
-							path.lineTo( x, y );
-
-							break;
-
-						case 'q': // quadraticCurveTo
-
-							cpx  = outline[ i ++ ] * scale + offset;
-							cpy  = outline[ i ++ ] * scale;
-							cpx1 = outline[ i ++ ] * scale + offset;
-							cpy1 = outline[ i ++ ] * scale;
-
-							path.quadraticCurveTo( cpx1, cpy1, cpx, cpy );
-
-							laste = pts[ pts.length - 1 ];
-
-							if ( laste ) {
-
-								cpx0 = laste.x;
-								cpy0 = laste.y;
-
-								for ( var i2 = 1; i2 <= divisions; i2 ++ ) {
-
-									var t = i2 / divisions;
-									b2( t, cpx0, cpx1, cpx );
-									b2( t, cpy0, cpy1, cpy );
-
-								}
-
-							}
-
-							break;
-
-						case 'b': // bezierCurveTo
-
-							cpx  = outline[ i ++ ] * scale + offset;
-							cpy  = outline[ i ++ ] * scale;
-							cpx1 = outline[ i ++ ] * scale + offset;
-							cpy1 = outline[ i ++ ] * scale;
-							cpx2 = outline[ i ++ ] * scale + offset;
-							cpy2 = outline[ i ++ ] * scale;
-
-							path.bezierCurveTo( cpx1, cpy1, cpx2, cpy2, cpx, cpy );
-
-							laste = pts[ pts.length - 1 ];
-
-							if ( laste ) {
-
-								cpx0 = laste.x;
-								cpy0 = laste.y;
-
-								for ( var i2 = 1; i2 <= divisions; i2 ++ ) {
-
-									var t = i2 / divisions;
-									b3( t, cpx0, cpx1, cpx2, cpx );
-									b3( t, cpy0, cpy1, cpy2, cpy );
-
-								}
-
-							}
-
-							break;
-
-					}
-
-				}
-
-			}
-
-			return { offset: glyph.ha * scale, path: path };
-
-		}
-
-		//
-
-		if ( size === undefined ) size = 100;
-		if ( divisions === undefined ) divisions = 4;
-
-		var data = this.data;
-
-		var paths = createPaths( text );
-		var shapes = [];
-
-		for ( var p = 0, pl = paths.length; p < pl; p ++ ) {
-
-			Array.prototype.push.apply( shapes, paths[ p ].toShapes() );
-
-		}
-
-		return shapes;
-
-	}
-
-};
-
-// File:src/extras/core/Path.js
-
-/**
- * @author zz85 / http://www.lab4games.net/zz85/blog
- * Creates free form 2d path using series of points, lines or curves.
- *
- **/
-
-THREE.Path = function ( points ) {
-
-	THREE.CurvePath.call( this );
-
-	this.actions = [];
-
-	if ( points ) {
-
-		this.fromPoints( points );
-
-	}
-
-};
-
-THREE.Path.prototype = Object.create( THREE.CurvePath.prototype );
-THREE.Path.prototype.constructor = THREE.Path;
-
-// TODO Clean up PATH API
-
-// Create path using straight lines to connect all points
-// - vectors: array of Vector2
-
-THREE.Path.prototype.fromPoints = function ( vectors ) {
-
-	this.moveTo( vectors[ 0 ].x, vectors[ 0 ].y );
-
-	for ( var i = 1, l = vectors.length; i < l; i ++ ) {
-
-		this.lineTo( vectors[ i ].x, vectors[ i ].y );
-
-	}
-
-};
-
-// startPath() endPath()?
-
-THREE.Path.prototype.moveTo = function ( x, y ) {
-
-	this.actions.push( { action: 'moveTo', args: [ x, y ] } );
-
-};
-
-THREE.Path.prototype.lineTo = function ( x, y ) {
-
-	var lastargs = this.actions[ this.actions.length - 1 ].args;
-
-	var x0 = lastargs[ lastargs.length - 2 ];
-	var y0 = lastargs[ lastargs.length - 1 ];
-
-	var curve = new THREE.LineCurve( new THREE.Vector2( x0, y0 ), new THREE.Vector2( x, y ) );
-	this.curves.push( curve );
-
-	this.actions.push( { action: 'lineTo', args: [ x, y ] } );
-
-};
-
-THREE.Path.prototype.quadraticCurveTo = function( aCPx, aCPy, aX, aY ) {
-
-	var lastargs = this.actions[ this.actions.length - 1 ].args;
-
-	var x0 = lastargs[ lastargs.length - 2 ];
-	var y0 = lastargs[ lastargs.length - 1 ];
-
-	var curve = new THREE.QuadraticBezierCurve(
-		new THREE.Vector2( x0, y0 ),
-		new THREE.Vector2( aCPx, aCPy ),
-		new THREE.Vector2( aX, aY )
-	);
-
-	this.curves.push( curve );
-
-	this.actions.push( { action: 'quadraticCurveTo', args: [ aCPx, aCPy, aX, aY ] } );
-
-};
-
-THREE.Path.prototype.bezierCurveTo = function( aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ) {
-
-	var lastargs = this.actions[ this.actions.length - 1 ].args;
-
-	var x0 = lastargs[ lastargs.length - 2 ];
-	var y0 = lastargs[ lastargs.length - 1 ];
-
-	var curve = new THREE.CubicBezierCurve(
-		new THREE.Vector2( x0, y0 ),
-		new THREE.Vector2( aCP1x, aCP1y ),
-		new THREE.Vector2( aCP2x, aCP2y ),
-		new THREE.Vector2( aX, aY )
-	);
-
-	this.curves.push( curve );
-
-	this.actions.push( { action: 'bezierCurveTo', args: [ aCP1x, aCP1y, aCP2x, aCP2y, aX, aY ] } );
-
-};
-
-THREE.Path.prototype.splineThru = function( pts /*Array of Vector*/ ) {
-
-	var args = Array.prototype.slice.call( arguments );
-
-	var lastargs = this.actions[ this.actions.length - 1 ].args;
-
-	var x0 = lastargs[ lastargs.length - 2 ];
-	var y0 = lastargs[ lastargs.length - 1 ];
-
-	var npts = [ new THREE.Vector2( x0, y0 ) ];
-	Array.prototype.push.apply( npts, pts );
-
-	var curve = new THREE.SplineCurve( npts );
-	this.curves.push( curve );
-
-	this.actions.push( { action: 'splineThru', args: args } );
-
-};
-
-// FUTURE: Change the API or follow canvas API?
-
-THREE.Path.prototype.arc = function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {
-
-	var lastargs = this.actions[ this.actions.length - 1 ].args;
-	var x0 = lastargs[ lastargs.length - 2 ];
-	var y0 = lastargs[ lastargs.length - 1 ];
-
-	this.absarc( aX + x0, aY + y0, aRadius,
-		aStartAngle, aEndAngle, aClockwise );
-
- };
-
- THREE.Path.prototype.absarc = function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {
-
-	this.absellipse( aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );
-
- };
-
-THREE.Path.prototype.ellipse = function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {
-
-	var lastargs = this.actions[ this.actions.length - 1 ].args;
-	var x0 = lastargs[ lastargs.length - 2 ];
-	var y0 = lastargs[ lastargs.length - 1 ];
-
-	this.absellipse( aX + x0, aY + y0, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );
-
- };
-
-
-THREE.Path.prototype.absellipse = function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {
-
-	var args = [
-		aX, aY,
-		xRadius, yRadius,
-		aStartAngle, aEndAngle,
-		aClockwise,
-		aRotation || 0 // aRotation is optional.
-	];
-
-	var curve = new THREE.EllipseCurve( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation );
-	this.curves.push( curve );
-
-	var lastPoint = curve.getPoint( 1 );
-	args.push( lastPoint.x );
-	args.push( lastPoint.y );
-
-	this.actions.push( { action: 'ellipse', args: args } );
-
- };
-
-THREE.Path.prototype.getSpacedPoints = function ( divisions ) {
-
-	if ( ! divisions ) divisions = 40;
-
-	var points = [];
-
-	for ( var i = 0; i < divisions; i ++ ) {
-
-		points.push( this.getPoint( i / divisions ) );
-
-		//if ( !this.getPoint( i / divisions ) ) throw "DIE";
-
-	}
-
-	if ( this.autoClose ) {
-
-		points.push( points[ 0 ] );
-
-	}
-
-	return points;
-
-};
-
-/* Return an array of vectors based on contour of the path */
-
-THREE.Path.prototype.getPoints = function( divisions ) {
-
-	divisions = divisions || 12;
-
-	var b2 = THREE.ShapeUtils.b2;
-	var b3 = THREE.ShapeUtils.b3;
-
-	var points = [];
-
-	var cpx, cpy, cpx2, cpy2, cpx1, cpy1, cpx0, cpy0,
-		laste, tx, ty;
-
-	for ( var i = 0, l = this.actions.length; i < l; i ++ ) {
-
-		var item = this.actions[ i ];
-
-		var action = item.action;
-		var args = item.args;
-
-		switch ( action ) {
-
-		case 'moveTo':
-
-			points.push( new THREE.Vector2( args[ 0 ], args[ 1 ] ) );
-
-			break;
-
-		case 'lineTo':
-
-			points.push( new THREE.Vector2( args[ 0 ], args[ 1 ] ) );
-
-			break;
-
-		case 'quadraticCurveTo':
-
-			cpx  = args[ 2 ];
-			cpy  = args[ 3 ];
-
-			cpx1 = args[ 0 ];
-			cpy1 = args[ 1 ];
-
-			if ( points.length > 0 ) {
-
-				laste = points[ points.length - 1 ];
-
-				cpx0 = laste.x;
-				cpy0 = laste.y;
-
-			} else {
-
-				laste = this.actions[ i - 1 ].args;
-
-				cpx0 = laste[ laste.length - 2 ];
-				cpy0 = laste[ laste.length - 1 ];
-
-			}
-
-			for ( var j = 1; j <= divisions; j ++ ) {
-
-				var t = j / divisions;
-
-				tx = b2( t, cpx0, cpx1, cpx );
-				ty = b2( t, cpy0, cpy1, cpy );
-
-				points.push( new THREE.Vector2( tx, ty ) );
-
-			}
-
-			break;
-
-		case 'bezierCurveTo':
-
-			cpx  = args[ 4 ];
-			cpy  = args[ 5 ];
-
-			cpx1 = args[ 0 ];
-			cpy1 = args[ 1 ];
-
-			cpx2 = args[ 2 ];
-			cpy2 = args[ 3 ];
-
-			if ( points.length > 0 ) {
-
-				laste = points[ points.length - 1 ];
-
-				cpx0 = laste.x;
-				cpy0 = laste.y;
-
-			} else {
-
-				laste = this.actions[ i - 1 ].args;
-
-				cpx0 = laste[ laste.length - 2 ];
-				cpy0 = laste[ laste.length - 1 ];
-
-			}
-
-
-			for ( var j = 1; j <= divisions; j ++ ) {
-
-				var t = j / divisions;
-
-				tx = b3( t, cpx0, cpx1, cpx2, cpx );
-				ty = b3( t, cpy0, cpy1, cpy2, cpy );
-
-				points.push( new THREE.Vector2( tx, ty ) );
-
-			}
-
-			break;
-
-		case 'splineThru':
-
-			laste = this.actions[ i - 1 ].args;
-
-			var last = new THREE.Vector2( laste[ laste.length - 2 ], laste[ laste.length - 1 ] );
-			var spts = [ last ];
-
-			var n = divisions * args[ 0 ].length;
-
-			spts = spts.concat( args[ 0 ] );
-
-			var spline = new THREE.SplineCurve( spts );
-
-			for ( var j = 1; j <= n; j ++ ) {
-
-				points.push( spline.getPointAt( j / n ) );
-
-			}
-
-			break;
-
-		case 'arc':
-
-			var aX = args[ 0 ], aY = args[ 1 ],
-				aRadius = args[ 2 ],
-				aStartAngle = args[ 3 ], aEndAngle = args[ 4 ],
-				aClockwise = !! args[ 5 ];
-
-			var deltaAngle = aEndAngle - aStartAngle;
-			var angle;
-			var tdivisions = divisions * 2;
-
-			for ( var j = 1; j <= tdivisions; j ++ ) {
-
-				var t = j / tdivisions;
-
-				if ( ! aClockwise ) {
-
-					t = 1 - t;
-
-				}
-
-				angle = aStartAngle + t * deltaAngle;
-
-				tx = aX + aRadius * Math.cos( angle );
-				ty = aY + aRadius * Math.sin( angle );
-
-				//console.log('t', t, 'angle', angle, 'tx', tx, 'ty', ty);
-
-				points.push( new THREE.Vector2( tx, ty ) );
-
-			}
-
-			//console.log(points);
-
-			break;
-
-		case 'ellipse':
-
-			var aX = args[ 0 ], aY = args[ 1 ],
-				xRadius = args[ 2 ],
-				yRadius = args[ 3 ],
-				aStartAngle = args[ 4 ], aEndAngle = args[ 5 ],
-				aClockwise = !! args[ 6 ],
-				aRotation = args[ 7 ];
-
-
-			var deltaAngle = aEndAngle - aStartAngle;
-			var angle;
-			var tdivisions = divisions * 2;
-
-			var cos, sin;
-			if ( aRotation !== 0 ) {
-
-				cos = Math.cos( aRotation );
-				sin = Math.sin( aRotation );
-
-			}
-
-			for ( var j = 1; j <= tdivisions; j ++ ) {
-
-				var t = j / tdivisions;
-
-				if ( ! aClockwise ) {
-
-					t = 1 - t;
-
-				}
-
-				angle = aStartAngle + t * deltaAngle;
-
-				tx = aX + xRadius * Math.cos( angle );
-				ty = aY + yRadius * Math.sin( angle );
-
-				if ( aRotation !== 0 ) {
-
-					var x = tx, y = ty;
-
-					// Rotate the point about the center of the ellipse.
-					tx = ( x - aX ) * cos - ( y - aY ) * sin + aX;
-					ty = ( x - aX ) * sin + ( y - aY ) * cos + aY;
-
-				}
-
-				//console.log('t', t, 'angle', angle, 'tx', tx, 'ty', ty);
-
-				points.push( new THREE.Vector2( tx, ty ) );
-
-			}
-
-			//console.log(points);
-
-			break;
-
-		} // end switch
-
-	}
-
-
-
-	// Normalize to remove the closing point by default.
-	var lastPoint = points[ points.length - 1 ];
-	if ( Math.abs( lastPoint.x - points[ 0 ].x ) < Number.EPSILON &&
-			 Math.abs( lastPoint.y - points[ 0 ].y ) < Number.EPSILON )
-		points.splice( points.length - 1, 1 );
-
-	if ( this.autoClose ) {
-
-		points.push( points[ 0 ] );
-
-	}
-
-	return points;
-
-};
-
-//
-// Breaks path into shapes
-//
-//	Assumptions (if parameter isCCW==true the opposite holds):
-//	- solid shapes are defined clockwise (CW)
-//	- holes are defined counterclockwise (CCW)
-//
-//	If parameter noHoles==true:
-//  - all subPaths are regarded as solid shapes
-//  - definition order CW/CCW has no relevance
-//
-
-THREE.Path.prototype.toShapes = function( isCCW, noHoles ) {
-
-	function extractSubpaths( inActions ) {
-
-		var subPaths = [], lastPath = new THREE.Path();
-
-		for ( var i = 0, l = inActions.length; i < l; i ++ ) {
-
-			var item = inActions[ i ];
-
-			var args = item.args;
-			var action = item.action;
-
-			if ( action === 'moveTo' ) {
-
-				if ( lastPath.actions.length !== 0 ) {
-
-					subPaths.push( lastPath );
-					lastPath = new THREE.Path();
-
-				}
-
-			}
-
-			lastPath[ action ].apply( lastPath, args );
-
-		}
-
-		if ( lastPath.actions.length !== 0 ) {
-
-			subPaths.push( lastPath );
-
-		}
-
-		// console.log(subPaths);
-
-		return	subPaths;
-
-	}
-
-	function toShapesNoHoles( inSubpaths ) {
-
-		var shapes = [];
-
-		for ( var i = 0, l = inSubpaths.length; i < l; i ++ ) {
-
-			var tmpPath = inSubpaths[ i ];
-
-			var tmpShape = new THREE.Shape();
-			tmpShape.actions = tmpPath.actions;
-			tmpShape.curves = tmpPath.curves;
-
-			shapes.push( tmpShape );
-
-		}
-
-		//console.log("shape", shapes);
-
-		return shapes;
-
-	}
-
-	function isPointInsidePolygon( inPt, inPolygon ) {
-
-		var polyLen = inPolygon.length;
-
-		// inPt on polygon contour => immediate success    or
-		// toggling of inside/outside at every single! intersection point of an edge
-		//  with the horizontal line through inPt, left of inPt
-		//  not counting lowerY endpoints of edges and whole edges on that line
-		var inside = false;
-		for ( var p = polyLen - 1, q = 0; q < polyLen; p = q ++ ) {
-
-			var edgeLowPt  = inPolygon[ p ];
-			var edgeHighPt = inPolygon[ q ];
-
-			var edgeDx = edgeHighPt.x - edgeLowPt.x;
-			var edgeDy = edgeHighPt.y - edgeLowPt.y;
-
-			if ( Math.abs( edgeDy ) > Number.EPSILON ) {
-
-				// not parallel
-				if ( edgeDy < 0 ) {
-
-					edgeLowPt  = inPolygon[ q ]; edgeDx = - edgeDx;
-					edgeHighPt = inPolygon[ p ]; edgeDy = - edgeDy;
-
-				}
-				if ( ( inPt.y < edgeLowPt.y ) || ( inPt.y > edgeHighPt.y ) ) 		continue;
-
-				if ( inPt.y === edgeLowPt.y ) {
-
-					if ( inPt.x === edgeLowPt.x )		return	true;		// inPt is on contour ?
-					// continue;				// no intersection or edgeLowPt => doesn't count !!!
-
-				} else {
-
-					var perpEdge = edgeDy * ( inPt.x - edgeLowPt.x ) - edgeDx * ( inPt.y - edgeLowPt.y );
-					if ( perpEdge === 0 )				return	true;		// inPt is on contour ?
-					if ( perpEdge < 0 ) 				continue;
-					inside = ! inside;		// true intersection left of inPt
-
-				}
-
-			} else {
-
-				// parallel or collinear
-				if ( inPt.y !== edgeLowPt.y ) 		continue;			// parallel
-				// edge lies on the same horizontal line as inPt
-				if ( ( ( edgeHighPt.x <= inPt.x ) && ( inPt.x <= edgeLowPt.x ) ) ||
-					 ( ( edgeLowPt.x <= inPt.x ) && ( inPt.x <= edgeHighPt.x ) ) )		return	true;	// inPt: Point on contour !
-				// continue;
-
-			}
-
-		}
-
-		return	inside;
-
-	}
-
-	var isClockWise = THREE.ShapeUtils.isClockWise;
-
-	var subPaths = extractSubpaths( this.actions );
-	if ( subPaths.length === 0 ) return [];
-
-	if ( noHoles === true )	return	toShapesNoHoles( subPaths );
-
-
-	var solid, tmpPath, tmpShape, shapes = [];
-
-	if ( subPaths.length === 1 ) {
-
-		tmpPath = subPaths[ 0 ];
-		tmpShape = new THREE.Shape();
-		tmpShape.actions = tmpPath.actions;
-		tmpShape.curves = tmpPath.curves;
-		shapes.push( tmpShape );
-		return shapes;
-
-	}
-
-	var holesFirst = ! isClockWise( subPaths[ 0 ].getPoints() );
-	holesFirst = isCCW ? ! holesFirst : holesFirst;
-
-	// console.log("Holes first", holesFirst);
-
-	var betterShapeHoles = [];
-	var newShapes = [];
-	var newShapeHoles = [];
-	var mainIdx = 0;
-	var tmpPoints;
-
-	newShapes[ mainIdx ] = undefined;
-	newShapeHoles[ mainIdx ] = [];
-
-	for ( var i = 0, l = subPaths.length; i < l; i ++ ) {
-
-		tmpPath = subPaths[ i ];
-		tmpPoints = tmpPath.getPoints();
-		solid = isClockWise( tmpPoints );
-		solid = isCCW ? ! solid : solid;
-
-		if ( solid ) {
-
-			if ( ( ! holesFirst ) && ( newShapes[ mainIdx ] ) )	mainIdx ++;
-
-			newShapes[ mainIdx ] = { s: new THREE.Shape(), p: tmpPoints };
-			newShapes[ mainIdx ].s.actions = tmpPath.actions;
-			newShapes[ mainIdx ].s.curves = tmpPath.curves;
-
-			if ( holesFirst )	mainIdx ++;
-			newShapeHoles[ mainIdx ] = [];
-
-			//console.log('cw', i);
-
-		} else {
-
-			newShapeHoles[ mainIdx ].push( { h: tmpPath, p: tmpPoints[ 0 ] } );
-
-			//console.log('ccw', i);
-
-		}
-
-	}
-
-	// only Holes? -> probably all Shapes with wrong orientation
-	if ( ! newShapes[ 0 ] )	return	toShapesNoHoles( subPaths );
-
-
-	if ( newShapes.length > 1 ) {
-
-		var ambiguous = false;
-		var toChange = [];
-
-		for ( var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {
-
-			betterShapeHoles[ sIdx ] = [];
-
-		}
-
-		for ( var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {
-
-			var sho = newShapeHoles[ sIdx ];
-
-			for ( var hIdx = 0; hIdx < sho.length; hIdx ++ ) {
-
-				var ho = sho[ hIdx ];
-				var hole_unassigned = true;
-
-				for ( var s2Idx = 0; s2Idx < newShapes.length; s2Idx ++ ) {
-
-					if ( isPointInsidePolygon( ho.p, newShapes[ s2Idx ].p ) ) {
-
-						if ( sIdx !== s2Idx )	toChange.push( { froms: sIdx, tos: s2Idx, hole: hIdx } );
-						if ( hole_unassigned ) {
-
-							hole_unassigned = false;
-							betterShapeHoles[ s2Idx ].push( ho );
-
-						} else {
-
-							ambiguous = true;
-
-						}
-
-					}
-
-				}
-				if ( hole_unassigned ) {
-
-					betterShapeHoles[ sIdx ].push( ho );
-
-				}
-
-			}
-
-		}
-		// console.log("ambiguous: ", ambiguous);
-		if ( toChange.length > 0 ) {
-
-			// console.log("to change: ", toChange);
-			if ( ! ambiguous )	newShapeHoles = betterShapeHoles;
-
-		}
-
-	}
-
-	var tmpHoles;
-
-	for ( var i = 0, il = newShapes.length; i < il; i ++ ) {
-
-		tmpShape = newShapes[ i ].s;
-		shapes.push( tmpShape );
-		tmpHoles = newShapeHoles[ i ];
-
-		for ( var j = 0, jl = tmpHoles.length; j < jl; j ++ ) {
-
-			tmpShape.holes.push( tmpHoles[ j ].h );
-
-		}
-
-	}
-
-	//console.log("shape", shapes);
-
-	return shapes;
-
-};
-
-// File:src/extras/core/Shape.js
-
-/**
- * @author zz85 / http://www.lab4games.net/zz85/blog
- * Defines a 2d shape plane using paths.
- **/
-
-// STEP 1 Create a path.
-// STEP 2 Turn path into shape.
-// STEP 3 ExtrudeGeometry takes in Shape/Shapes
-// STEP 3a - Extract points from each shape, turn to vertices
-// STEP 3b - Triangulate each shape, add faces.
-
-THREE.Shape = function () {
-
-	THREE.Path.apply( this, arguments );
-
-	this.holes = [];
-
-};
-
-THREE.Shape.prototype = Object.create( THREE.Path.prototype );
-THREE.Shape.prototype.constructor = THREE.Shape;
-
-// Convenience method to return ExtrudeGeometry
-
-THREE.Shape.prototype.extrude = function ( options ) {
-
-	return new THREE.ExtrudeGeometry( this, options );
-
-};
-
-// Convenience method to return ShapeGeometry
-
-THREE.Shape.prototype.makeGeometry = function ( options ) {
-
-	return new THREE.ShapeGeometry( this, options );
-
-};
-
-// Get points of holes
-
-THREE.Shape.prototype.getPointsHoles = function ( divisions ) {
-
-	var holesPts = [];
-
-	for ( var i = 0, l = this.holes.length; i < l; i ++ ) {
-
-		holesPts[ i ] = this.holes[ i ].getPoints( divisions );
-
-	}
-
-	return holesPts;
-
-};
-
-
-// Get points of shape and holes (keypoints based on segments parameter)
-
-THREE.Shape.prototype.extractAllPoints = function ( divisions ) {
-
-	return {
-
-		shape: this.getPoints( divisions ),
-		holes: this.getPointsHoles( divisions )
-
-	};
-
-};
-
-THREE.Shape.prototype.extractPoints = function ( divisions ) {
-
-	return this.extractAllPoints( divisions );
-
-};
-
-// File:src/extras/curves/LineCurve.js
-
-/**************************************************************
- *	Line
- **************************************************************/
-
-THREE.LineCurve = function ( v1, v2 ) {
-
-	this.v1 = v1;
-	this.v2 = v2;
-
-};
-
-THREE.LineCurve.prototype = Object.create( THREE.Curve.prototype );
-THREE.LineCurve.prototype.constructor = THREE.LineCurve;
-
-THREE.LineCurve.prototype.getPoint = function ( t ) {
-
-	var point = this.v2.clone().sub( this.v1 );
-	point.multiplyScalar( t ).add( this.v1 );
-
-	return point;
-
-};
-
-// Line curve is linear, so we can overwrite default getPointAt
-
-THREE.LineCurve.prototype.getPointAt = function ( u ) {
-
-	return this.getPoint( u );
-
-};
-
-THREE.LineCurve.prototype.getTangent = function( t ) {
-
-	var tangent = this.v2.clone().sub( this.v1 );
-
-	return tangent.normalize();
-
-};
-
-// File:src/extras/curves/QuadraticBezierCurve.js
-
-/**************************************************************
- *	Quadratic Bezier curve
- **************************************************************/
-
-
-THREE.QuadraticBezierCurve = function ( v0, v1, v2 ) {
-
-	this.v0 = v0;
-	this.v1 = v1;
-	this.v2 = v2;
-
-};
-
-THREE.QuadraticBezierCurve.prototype = Object.create( THREE.Curve.prototype );
-THREE.QuadraticBezierCurve.prototype.constructor = THREE.QuadraticBezierCurve;
-
-
-THREE.QuadraticBezierCurve.prototype.getPoint = function ( t ) {
-
-	var b2 = THREE.ShapeUtils.b2;
-
-	return new THREE.Vector2(
-		b2( t, this.v0.x, this.v1.x, this.v2.x ),
-		b2( t, this.v0.y, this.v1.y, this.v2.y )
-	);
-
-};
-
-
-THREE.QuadraticBezierCurve.prototype.getTangent = function( t ) {
-
-	var tangentQuadraticBezier = THREE.CurveUtils.tangentQuadraticBezier;
-
-	return new THREE.Vector2(
-		tangentQuadraticBezier( t, this.v0.x, this.v1.x, this.v2.x ),
-		tangentQuadraticBezier( t, this.v0.y, this.v1.y, this.v2.y )
-	).normalize();
-
-};
-
-// File:src/extras/curves/CubicBezierCurve.js
-
-/**************************************************************
- *	Cubic Bezier curve
- **************************************************************/
-
-THREE.CubicBezierCurve = function ( v0, v1, v2, v3 ) {
-
-	this.v0 = v0;
-	this.v1 = v1;
-	this.v2 = v2;
-	this.v3 = v3;
-
-};
-
-THREE.CubicBezierCurve.prototype = Object.create( THREE.Curve.prototype );
-THREE.CubicBezierCurve.prototype.constructor = THREE.CubicBezierCurve;
-
-THREE.CubicBezierCurve.prototype.getPoint = function ( t ) {
-
-	var b3 = THREE.ShapeUtils.b3;
-
-	return new THREE.Vector2( 
-		b3( t, this.v0.x, this.v1.x, this.v2.x, this.v3.x ),
-		b3( t, this.v0.y, this.v1.y, this.v2.y, this.v3.y )
-	);
-
-};
-
-THREE.CubicBezierCurve.prototype.getTangent = function( t ) {
-
-	var tangentCubicBezier = THREE.CurveUtils.tangentCubicBezier;
-
-	return new THREE.Vector2( 
-		tangentCubicBezier( t, this.v0.x, this.v1.x, this.v2.x, this.v3.x ),
-		tangentCubicBezier( t, this.v0.y, this.v1.y, this.v2.y, this.v3.y )
-	).normalize();
-
-};
-
-// File:src/extras/curves/SplineCurve.js
-
-/**************************************************************
- *	Spline curve
- **************************************************************/
-
-THREE.SplineCurve = function ( points /* array of Vector2 */ ) {
-
-	this.points = ( points == undefined ) ? [] : points;
-
-};
-
-THREE.SplineCurve.prototype = Object.create( THREE.Curve.prototype );
-THREE.SplineCurve.prototype.constructor = THREE.SplineCurve;
-
-THREE.SplineCurve.prototype.getPoint = function ( t ) {
-
-	var points = this.points;
-	var point = ( points.length - 1 ) * t;
-
-	var intPoint = Math.floor( point );
-	var weight = point - intPoint;
-
-	var point0 = points[ intPoint === 0 ? intPoint : intPoint - 1 ];
-	var point1 = points[ intPoint ];
-	var point2 = points[ intPoint > points.length - 2 ? points.length - 1 : intPoint + 1 ];
-	var point3 = points[ intPoint > points.length - 3 ? points.length - 1 : intPoint + 2 ];
-
-	var interpolate = THREE.CurveUtils.interpolate;
-
-	return new THREE.Vector2(
-		interpolate( point0.x, point1.x, point2.x, point3.x, weight ),
-		interpolate( point0.y, point1.y, point2.y, point3.y, weight )
-	);
-
-};
-
-// File:src/extras/curves/EllipseCurve.js
-
-/**************************************************************
- *	Ellipse curve
- **************************************************************/
-
-THREE.EllipseCurve = function ( aX, aY, xRadius, yRadius, aStartAngle, aEndAngle, aClockwise, aRotation ) {
-
-	this.aX = aX;
-	this.aY = aY;
-
-	this.xRadius = xRadius;
-	this.yRadius = yRadius;
-
-	this.aStartAngle = aStartAngle;
-	this.aEndAngle = aEndAngle;
-
-	this.aClockwise = aClockwise;
-	
-	this.aRotation = aRotation || 0;
-
-};
-
-THREE.EllipseCurve.prototype = Object.create( THREE.Curve.prototype );
-THREE.EllipseCurve.prototype.constructor = THREE.EllipseCurve;
-
-THREE.EllipseCurve.prototype.getPoint = function ( t ) {
-
-	var deltaAngle = this.aEndAngle - this.aStartAngle;
-
-	if ( deltaAngle < 0 ) deltaAngle += Math.PI * 2;
-	if ( deltaAngle > Math.PI * 2 ) deltaAngle -= Math.PI * 2;
-
-	var angle;
-
-	if ( this.aClockwise === true ) {
-
-		angle = this.aEndAngle + ( 1 - t ) * ( Math.PI * 2 - deltaAngle );
-
-	} else {
-
-		angle = this.aStartAngle + t * deltaAngle;
-
-	}
-	
-	var x = this.aX + this.xRadius * Math.cos( angle );
-	var y = this.aY + this.yRadius * Math.sin( angle );
-
-	if ( this.aRotation !== 0 ) {
-
-		var cos = Math.cos( this.aRotation );
-		var sin = Math.sin( this.aRotation );
-
-		var tx = x, ty = y;
-
-		// Rotate the point about the center of the ellipse.
-		x = ( tx - this.aX ) * cos - ( ty - this.aY ) * sin + this.aX;
-		y = ( tx - this.aX ) * sin + ( ty - this.aY ) * cos + this.aY;
-
-	}
-
-	return new THREE.Vector2( x, y );
-
-};
-
-// File:src/extras/curves/ArcCurve.js
-
-/**************************************************************
- *	Arc curve
- **************************************************************/
-
-THREE.ArcCurve = function ( aX, aY, aRadius, aStartAngle, aEndAngle, aClockwise ) {
-
-	THREE.EllipseCurve.call( this, aX, aY, aRadius, aRadius, aStartAngle, aEndAngle, aClockwise );
-
-};
-
-THREE.ArcCurve.prototype = Object.create( THREE.EllipseCurve.prototype );
-THREE.ArcCurve.prototype.constructor = THREE.ArcCurve;
-
-// File:src/extras/curves/LineCurve3.js
-
-/**************************************************************
- *	Line3D
- **************************************************************/
-
-THREE.LineCurve3 = THREE.Curve.create(
-
-	function ( v1, v2 ) {
-
-		this.v1 = v1;
-		this.v2 = v2;
-
-	},
-
-	function ( t ) {
-
-		var vector = new THREE.Vector3();
-
-		vector.subVectors( this.v2, this.v1 ); // diff
-		vector.multiplyScalar( t );
-		vector.add( this.v1 );
-
-		return vector;
-
-	}
-
-);
-
-// File:src/extras/curves/QuadraticBezierCurve3.js
-
-/**************************************************************
- *	Quadratic Bezier 3D curve
- **************************************************************/
-
-THREE.QuadraticBezierCurve3 = THREE.Curve.create(
-
-	function ( v0, v1, v2 ) {
-
-		this.v0 = v0;
-		this.v1 = v1;
-		this.v2 = v2;
-
-	},
-
-	function ( t ) {
-
-		var b2 = THREE.ShapeUtils.b2;		
-
-		return new THREE.Vector3(
-			b2( t, this.v0.x, this.v1.x, this.v2.x ),
-			b2( t, this.v0.y, this.v1.y, this.v2.y ),
-			b2( t, this.v0.z, this.v1.z, this.v2.z )
-		);
-
-	}
-
-);
-
-// File:src/extras/curves/CubicBezierCurve3.js
-
-/**************************************************************
- *	Cubic Bezier 3D curve
- **************************************************************/
-
-THREE.CubicBezierCurve3 = THREE.Curve.create(
-
-	function ( v0, v1, v2, v3 ) {
-
-		this.v0 = v0;
-		this.v1 = v1;
-		this.v2 = v2;
-		this.v3 = v3;
-
-	},
-
-	function ( t ) {
-
-		var b3 = THREE.ShapeUtils.b3;
-
-		return new THREE.Vector3(
-			b3( t, this.v0.x, this.v1.x, this.v2.x, this.v3.x ),
-			b3( t, this.v0.y, this.v1.y, this.v2.y, this.v3.y ),
-			b3( t, this.v0.z, this.v1.z, this.v2.z, this.v3.z )
-		);
-
-	}
-
-);
-
-// File:src/extras/curves/SplineCurve3.js
-
-/**************************************************************
- *	Spline 3D curve
- **************************************************************/
-
-
-THREE.SplineCurve3 = THREE.Curve.create(
-
-	function ( points /* array of Vector3 */ ) {
-
-		console.warn( 'THREE.SplineCurve3 will be deprecated. Please use THREE.CatmullRomCurve3' );
-		this.points = ( points == undefined ) ? [] : points;
-
-	},
-
-	function ( t ) {
-
-		var points = this.points;
-		var point = ( points.length - 1 ) * t;
-
-		var intPoint = Math.floor( point );
-		var weight = point - intPoint;
-
-		var point0 = points[ intPoint == 0 ? intPoint : intPoint - 1 ];
-		var point1 = points[ intPoint ];
-		var point2 = points[ intPoint > points.length - 2 ? points.length - 1 : intPoint + 1 ];
-		var point3 = points[ intPoint > points.length - 3 ? points.length - 1 : intPoint + 2 ];
-
-		var interpolate = THREE.CurveUtils.interpolate;
-
-		return new THREE.Vector3(
-			interpolate( point0.x, point1.x, point2.x, point3.x, weight ),
-			interpolate( point0.y, point1.y, point2.y, point3.y, weight ),
-			interpolate( point0.z, point1.z, point2.z, point3.z, weight )
-		);
-
-	}
-
-);
-
-// File:src/extras/curves/CatmullRomCurve3.js
-
-/**
- * @author zz85 https://github.com/zz85
- *
- * Centripetal CatmullRom Curve - which is useful for avoiding
- * cusps and self-intersections in non-uniform catmull rom curves.
- * http://www.cemyuksel.com/research/catmullrom_param/catmullrom.pdf
- *
- * curve.type accepts centripetal(default), chordal and catmullrom
- * curve.tension is used for catmullrom which defaults to 0.5
- */
-
-THREE.CatmullRomCurve3 = ( function() {
-
-	var
-		tmp = new THREE.Vector3(),
-		px = new CubicPoly(),
-		py = new CubicPoly(),
-		pz = new CubicPoly();
-
-	/*
-	Based on an optimized c++ solution in
-	 - http://stackoverflow.com/questions/9489736/catmull-rom-curve-with-no-cusps-and-no-self-intersections/
-	 - http://ideone.com/NoEbVM
-
-	This CubicPoly class could be used for reusing some variables and calculations,
-	but for three.js curve use, it could be possible inlined and flatten into a single function call
-	which can be placed in CurveUtils.
-	*/
-
-	function CubicPoly() {
-
-	}
-
-	/*
-	 * Compute coefficients for a cubic polynomial
-	 *   p(s) = c0 + c1*s + c2*s^2 + c3*s^3
-	 * such that
-	 *   p(0) = x0, p(1) = x1
-	 *  and
-	 *   p'(0) = t0, p'(1) = t1.
-	 */
-	CubicPoly.prototype.init = function( x0, x1, t0, t1 ) {
-
-		this.c0 = x0;
-		this.c1 = t0;
-		this.c2 = - 3 * x0 + 3 * x1 - 2 * t0 - t1;
-		this.c3 = 2 * x0 - 2 * x1 + t0 + t1;
-
-	};
-
-	CubicPoly.prototype.initNonuniformCatmullRom = function( x0, x1, x2, x3, dt0, dt1, dt2 ) {
-
-		// compute tangents when parameterized in [t1,t2]
-		var t1 = ( x1 - x0 ) / dt0 - ( x2 - x0 ) / ( dt0 + dt1 ) + ( x2 - x1 ) / dt1;
-		var t2 = ( x2 - x1 ) / dt1 - ( x3 - x1 ) / ( dt1 + dt2 ) + ( x3 - x2 ) / dt2;
-
-		// rescale tangents for parametrization in [0,1]
-		t1 *= dt1;
-		t2 *= dt1;
-
-		// initCubicPoly
-		this.init( x1, x2, t1, t2 );
-
-	};
-
-	// standard Catmull-Rom spline: interpolate between x1 and x2 with previous/following points x1/x4
-	CubicPoly.prototype.initCatmullRom = function( x0, x1, x2, x3, tension ) {
-
-		this.init( x1, x2, tension * ( x2 - x0 ), tension * ( x3 - x1 ) );
-
-	};
-
-	CubicPoly.prototype.calc = function( t ) {
-
-		var t2 = t * t;
-		var t3 = t2 * t;
-		return this.c0 + this.c1 * t + this.c2 * t2 + this.c3 * t3;
-
-	};
-
-	// Subclass Three.js curve
-	return THREE.Curve.create(
-
-		function ( p /* array of Vector3 */ ) {
-
-			this.points = p || [];
-			this.closed = false;
-
-		},
-
-		function ( t ) {
-
-			var points = this.points,
-				point, intPoint, weight, l;
-
-			l = points.length;
-
-			if ( l < 2 ) console.log( 'duh, you need at least 2 points' );
-
-			point = ( l - ( this.closed ? 0 : 1 ) ) * t;
-			intPoint = Math.floor( point );
-			weight = point - intPoint;
-
-			if ( this.closed ) {
-
-				intPoint += intPoint > 0 ? 0 : ( Math.floor( Math.abs( intPoint ) / points.length ) + 1 ) * points.length;
-
-			} else if ( weight === 0 && intPoint === l - 1 ) {
-
-				intPoint = l - 2;
-				weight = 1;
-
-			}
-
-			var p0, p1, p2, p3; // 4 points
-
-			if ( this.closed || intPoint > 0 ) {
-
-				p0 = points[ ( intPoint - 1 ) % l ];
-
-			} else {
-
-				// extrapolate first point
-				tmp.subVectors( points[ 0 ], points[ 1 ] ).add( points[ 0 ] );
-				p0 = tmp;
-
-			}
-
-			p1 = points[ intPoint % l ];
-			p2 = points[ ( intPoint + 1 ) % l ];
-
-			if ( this.closed || intPoint + 2 < l ) {
-
-				p3 = points[ ( intPoint + 2 ) % l ];
-
-			} else {
-
-				// extrapolate last point
-				tmp.subVectors( points[ l - 1 ], points[ l - 2 ] ).add( points[ l - 1 ] );
-				p3 = tmp;
-
-			}
-
-			if ( this.type === undefined || this.type === 'centripetal' || this.type === 'chordal' ) {
-
-				// init Centripetal / Chordal Catmull-Rom
-				var pow = this.type === 'chordal' ? 0.5 : 0.25;
-				var dt0 = Math.pow( p0.distanceToSquared( p1 ), pow );
-				var dt1 = Math.pow( p1.distanceToSquared( p2 ), pow );
-				var dt2 = Math.pow( p2.distanceToSquared( p3 ), pow );
-
-				// safety check for repeated points
-				if ( dt1 < 1e-4 ) dt1 = 1.0;
-				if ( dt0 < 1e-4 ) dt0 = dt1;
-				if ( dt2 < 1e-4 ) dt2 = dt1;
-
-				px.initNonuniformCatmullRom( p0.x, p1.x, p2.x, p3.x, dt0, dt1, dt2 );
-				py.initNonuniformCatmullRom( p0.y, p1.y, p2.y, p3.y, dt0, dt1, dt2 );
-				pz.initNonuniformCatmullRom( p0.z, p1.z, p2.z, p3.z, dt0, dt1, dt2 );
-
-			} else if ( this.type === 'catmullrom' ) {
-
-				var tension = this.tension !== undefined ? this.tension : 0.5;
-				px.initCatmullRom( p0.x, p1.x, p2.x, p3.x, tension );
-				py.initCatmullRom( p0.y, p1.y, p2.y, p3.y, tension );
-				pz.initCatmullRom( p0.z, p1.z, p2.z, p3.z, tension );
-
-			}
-
-			var v = new THREE.Vector3(
-				px.calc( weight ),
-				py.calc( weight ),
-				pz.calc( weight )
-			);
-
-			return v;
-
-		}
-
-	);
-
-} )();
-
-// File:src/extras/curves/ClosedSplineCurve3.js
-
-/**************************************************************
- *	Closed Spline 3D curve
- **************************************************************/
-
-
-THREE.ClosedSplineCurve3 = function ( points ) {
-
-	console.warn( 'THREE.ClosedSplineCurve3 has been deprecated. Please use THREE.CatmullRomCurve3.' );
-
-	THREE.CatmullRomCurve3.call( this, points );
-	this.type = 'catmullrom';
-	this.closed = true;
-
-};
-
-THREE.ClosedSplineCurve3.prototype = Object.create( THREE.CatmullRomCurve3.prototype );
-
-// File:src/extras/geometries/BoxGeometry.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * based on http://papervision3d.googlecode.com/svn/trunk/as3/trunk/src/org/papervision3d/objects/primitives/Cube.as
- */
-
-THREE.BoxGeometry = function ( width, height, depth, widthSegments, heightSegments, depthSegments ) {
-
-	THREE.Geometry.call( this );
-
-	this.type = 'BoxGeometry';
-
-	this.parameters = {
-		width: width,
-		height: height,
-		depth: depth,
-		widthSegments: widthSegments,
-		heightSegments: heightSegments,
-		depthSegments: depthSegments
-	};
-
-	this.fromBufferGeometry( new THREE.BoxBufferGeometry( width, height, depth, widthSegments, heightSegments, depthSegments ) );
-	this.mergeVertices();
-
-};
-
-THREE.BoxGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.BoxGeometry.prototype.constructor = THREE.BoxGeometry;
-
-THREE.CubeGeometry = THREE.BoxGeometry;
-
-// File:src/extras/geometries/BoxBufferGeometry.js
-
-/**
- * @author Mugen87 / https://github.com/Mugen87
- */
-
-THREE.BoxBufferGeometry = function ( width, height, depth, widthSegments, heightSegments, depthSegments ) {
-
-	THREE.BufferGeometry.call( this );
-
-	this.type = 'BoxBufferGeometry';
-
-	this.parameters = {
-		width: width,
-		height: height,
-		depth: depth,
-		widthSegments: widthSegments,
-		heightSegments: heightSegments,
-		depthSegments: depthSegments
-	};
-
-	var scope = this;
-
-	// segments
-	widthSegments = Math.floor( widthSegments ) || 1;
-	heightSegments = Math.floor( heightSegments ) || 1;
-	depthSegments = Math.floor( depthSegments ) || 1;
-
-	// these are used to calculate buffer length
-	var vertexCount = calculateVertexCount( widthSegments, heightSegments, depthSegments );
-	var indexCount = ( vertexCount / 4 ) * 6;
-
-	// buffers
-	var indices = new ( indexCount > 65535 ? Uint32Array : Uint16Array )( indexCount );
-	var vertices = new Float32Array( vertexCount * 3 );
-	var normals = new Float32Array( vertexCount * 3 );
-	var uvs = new Float32Array( vertexCount * 2 );
-
-	// offset variables
-	var vertexBufferOffset = 0;
-	var uvBufferOffset = 0;
-	var indexBufferOffset = 0;
-	var numberOfVertices = 0;
-
-	// group variables
-	var groupStart = 0;
-
-	// build each side of the box geometry
-	buildPlane( 'z', 'y', 'x', - 1, - 1, depth, height,   width,  depthSegments, heightSegments, 0 ); // px
-	buildPlane( 'z', 'y', 'x',   1, - 1, depth, height, - width,  depthSegments, heightSegments, 1 ); // nx
-	buildPlane( 'x', 'z', 'y',   1,   1, width, depth,    height, widthSegments, depthSegments,  2 ); // py
-	buildPlane( 'x', 'z', 'y',   1, - 1, width, depth,  - height, widthSegments, depthSegments,  3 ); // ny
-	buildPlane( 'x', 'y', 'z',   1, - 1, width, height,   depth,  widthSegments, heightSegments, 4 ); // pz
-	buildPlane( 'x', 'y', 'z', - 1, - 1, width, height, - depth,  widthSegments, heightSegments, 5 ); // nz
-
-	// build geometry
-	this.setIndex( new THREE.BufferAttribute( indices, 1 ) );
-	this.addAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
-	this.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
-	this.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ) );
-
-	// helper functions
-
-	function calculateVertexCount ( w, h, d ) {
-
-		var segments = 0;
-
-		// calculate the amount of segments for each side
-		segments += w * h * 2; // xy
-		segments += w * d * 2; // xz
-		segments += d * h * 2; // zy
-
-		return segments * 4; // four vertices per segments
-
-	}
-
-	function buildPlane ( u, v, w, udir, vdir, width, height, depth, gridX, gridY, materialIndex ) {
-
-		var segmentWidth	= width / gridX;
-		var segmentHeight = height / gridY;
-
-		var widthHalf = width / 2;
-		var heightHalf = height / 2;
-		var depthHalf = depth / 2;
-
-		var gridX1 = gridX + 1;
-		var gridY1 = gridY + 1;
-
-		var vertexCounter = 0;
-		var groupCount = 0;
-
-		var vector = new THREE.Vector3();
-
-		// generate vertices, normals and uvs
-
-		for ( var iy = 0; iy < gridY1; iy ++ ) {
-
-			var y = iy * segmentHeight - heightHalf;
-
-			for ( var ix = 0; ix < gridX1; ix ++ ) {
-
-				var x = ix * segmentWidth - widthHalf;
-
-				// set values to correct vector component
-				vector[ u ] = x * udir;
-				vector[ v ] = y * vdir;
-				vector[ w ] = depthHalf;
-
-				// now apply vector to vertex buffer
-				vertices[ vertexBufferOffset ] = vector.x;
-				vertices[ vertexBufferOffset + 1 ] = vector.y;
-				vertices[ vertexBufferOffset + 2 ] = vector.z;
-
-				// set values to correct vector component
-				vector[ u ] = 0;
-				vector[ v ] = 0;
-				vector[ w ] = depth > 0 ? 1 : - 1;
-
-				// now apply vector to normal buffer
-				normals[ vertexBufferOffset ] = vector.x;
-				normals[ vertexBufferOffset + 1 ] = vector.y;
-				normals[ vertexBufferOffset + 2 ] = vector.z;
-
-				// uvs
-				uvs[ uvBufferOffset ] = ix / gridX;
-				uvs[ uvBufferOffset + 1 ] = 1 - ( iy / gridY );
-
-				// update offsets and counters
-				vertexBufferOffset += 3;
-				uvBufferOffset += 2;
-				vertexCounter += 1;
-
-			}
-
-		}
-
-		// 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 < gridY; iy ++ ) {
-
-			for ( ix = 0; ix < gridX; ix ++ ) {
-
-				// indices
-				var a = numberOfVertices + ix + gridX1 * iy;
-				var b = numberOfVertices + ix + gridX1 * ( iy + 1 );
-				var c = numberOfVertices + ( ix + 1 ) + gridX1 * ( iy + 1 );
-				var d = numberOfVertices + ( ix + 1 ) + gridX1 * iy;
-
-				// face one
-				indices[ indexBufferOffset ] = a;
-				indices[ indexBufferOffset + 1 ] = b;
-				indices[ indexBufferOffset + 2 ] = d;
-
-				// face two
-				indices[ indexBufferOffset + 3 ] = b;
-				indices[ indexBufferOffset + 4 ] = c;
-				indices[ indexBufferOffset + 5 ] = d;
-
-				// update offsets and counters
-				indexBufferOffset += 6;
-				groupCount += 6;
-
-			}
-
-		}
-
-		// add a group to the geometry. this will ensure multi material support
-		scope.addGroup( groupStart, groupCount, materialIndex );
-
-		// calculate new start value for groups
-		groupStart += groupCount;
-
-		// update total number of vertices
-		numberOfVertices += vertexCounter;
-
-	}
-
-};
-
-THREE.BoxBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
-THREE.BoxBufferGeometry.prototype.constructor = THREE.BoxBufferGeometry;
-
-// File:src/extras/geometries/CircleGeometry.js
-
-/**
- * @author hughes
- */
-
-THREE.CircleGeometry = function ( radius, segments, thetaStart, thetaLength ) {
-
-	THREE.Geometry.call( this );
-
-	this.type = 'CircleGeometry';
-
-	this.parameters = {
-		radius: radius,
-		segments: segments,
-		thetaStart: thetaStart,
-		thetaLength: thetaLength
-	};
-
-	this.fromBufferGeometry( new THREE.CircleBufferGeometry( radius, segments, thetaStart, thetaLength ) );
-
-};
-
-THREE.CircleGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.CircleGeometry.prototype.constructor = THREE.CircleGeometry;
-
-// File:src/extras/geometries/CircleBufferGeometry.js
-
-/**
- * @author benaadams / https://twitter.com/ben_a_adams
- */
-
-THREE.CircleBufferGeometry = function ( radius, segments, thetaStart, thetaLength ) {
-
-	THREE.BufferGeometry.call( this );
-
-	this.type = 'CircleBufferGeometry';
-
-	this.parameters = {
-		radius: radius,
-		segments: segments,
-		thetaStart: thetaStart,
-		thetaLength: thetaLength
-	};
-
-	radius = radius || 50;
-	segments = segments !== undefined ? Math.max( 3, segments ) : 8;
-
-	thetaStart = thetaStart !== undefined ? thetaStart : 0;
-	thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;
-
-	var vertices = segments + 2;
-
-	var positions = new Float32Array( vertices * 3 );
-	var normals = new Float32Array( vertices * 3 );
-	var uvs = new Float32Array( vertices * 2 );
-
-	// center data is already zero, but need to set a few extras
-	normals[ 2 ] = 1.0;
-	uvs[ 0 ] = 0.5;
-	uvs[ 1 ] = 0.5;
-
-	for ( var s = 0, i = 3, ii = 2 ; s <= segments; s ++, i += 3, ii += 2 ) {
-
-		var segment = thetaStart + s / segments * thetaLength;
-
-		positions[ i ] = radius * Math.cos( segment );
-		positions[ i + 1 ] = radius * Math.sin( segment );
-
-		normals[ i + 2 ] = 1; // normal z
-
-		uvs[ ii ] = ( positions[ i ] / radius + 1 ) / 2;
-		uvs[ ii + 1 ] = ( positions[ i + 1 ] / radius + 1 ) / 2;
-
-	}
-
-	var indices = [];
-
-	for ( var i = 1; i <= segments; i ++ ) {
-
-		indices.push( i, i + 1, 0 );
-
-	}
-
-	this.setIndex( new THREE.BufferAttribute( new Uint16Array( indices ), 1 ) );
-	this.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
-	this.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
-	this.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ) );
-
-	this.boundingSphere = new THREE.Sphere( new THREE.Vector3(), radius );
-
-};
-
-THREE.CircleBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
-THREE.CircleBufferGeometry.prototype.constructor = THREE.CircleBufferGeometry;
-
-// File:src/extras/geometries/CylinderBufferGeometry.js
-
-/**
- * @author Mugen87 / https://github.com/Mugen87
- */
-
-THREE.CylinderBufferGeometry = function( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {
-
-	THREE.BufferGeometry.call( this );
-
-	this.type = 'CylinderBufferGeometry';
-
-	this.parameters = {
-		radiusTop: radiusTop,
-		radiusBottom: radiusBottom,
-		height: height,
-		radialSegments: radialSegments,
-		heightSegments: heightSegments,
-		openEnded: openEnded,
-		thetaStart: thetaStart,
-		thetaLength: thetaLength
-	};
-
-	var scope = this;
-
-	radiusTop = radiusTop !== undefined ? radiusTop : 20;
-	radiusBottom = radiusBottom !== undefined ? radiusBottom : 20;
-	height = height !== undefined ? height : 100;
-
-	radialSegments = Math.floor( radialSegments ) || 8;
-	heightSegments = Math.floor( heightSegments ) || 1;
-
-	openEnded = openEnded !== undefined ? openEnded : false;
-	thetaStart = thetaStart !== undefined ? thetaStart : 0;
-	thetaLength = thetaLength !== undefined ? thetaLength : 2 * Math.PI;
-
-	// used to calculate buffer length
-
-	var vertexCount = calculateVertexCount();
-	var indexCount = calculateIndexCount();
-
-	// buffers
-
-	var indices = new THREE.BufferAttribute( new ( indexCount > 65535 ? Uint32Array : Uint16Array )( indexCount ), 1 );
-	var vertices = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
-	var normals = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
-	var uvs = new THREE.BufferAttribute( new Float32Array( vertexCount * 2 ), 2 );
-
-	// helper variables
-
-	var index = 0, indexOffset = 0, indexArray = [], halfHeight = height / 2;
-
-	// group variables
-	var groupStart = 0;
-
-	// generate geometry
-
-	generateTorso();
-
-	if ( openEnded === false ) {
-
-		if ( radiusTop > 0 ) generateCap( true );
-		if ( radiusBottom > 0 ) generateCap( false );
-
-	}
-
-	// build geometry
-
-	this.setIndex( indices );
-	this.addAttribute( 'position', vertices );
-	this.addAttribute( 'normal', normals );
-	this.addAttribute( 'uv', uvs );
-
-	// helper functions
-
-	function calculateVertexCount() {
-
-		var count = ( radialSegments + 1 ) * ( heightSegments + 1 );
-
-		if ( openEnded === false ) {
-
-			count += ( ( radialSegments + 1 ) * 2 ) + ( radialSegments * 2 );
-
-		}
-
-		return count;
-
-	}
-
-	function calculateIndexCount() {
-
-		var count = radialSegments * heightSegments * 2 * 3;
-
-		if ( openEnded === false ) {
-
-			count += radialSegments * 2 * 3;
-
-		}
-
-		return count;
-
-	}
-
-	function generateTorso() {
-
-		var x, y;
-		var normal = new THREE.Vector3();
-		var vertex = new THREE.Vector3();
-
-		var groupCount = 0;
-
-		// this will be used to calculate the normal
-		var tanTheta = ( radiusBottom - radiusTop ) / height;
-
-		// generate vertices, normals and uvs
-
-		for ( y = 0; y <= heightSegments; y ++ ) {
-
-			var indexRow = [];
-
-			var v = y / heightSegments;
-
-			// calculate the radius of the current row
-			var radius = v * ( radiusBottom - radiusTop ) + radiusTop;
-
-			for ( x = 0; x <= radialSegments; x ++ ) {
-
-				var u = x / radialSegments;
-
-				// vertex
-				vertex.x = radius * Math.sin( u * thetaLength + thetaStart );
-				vertex.y = - v * height + halfHeight;
-				vertex.z = radius * Math.cos( u * thetaLength + thetaStart );
-				vertices.setXYZ( index, vertex.x, vertex.y, vertex.z );
-
-				// normal
-				normal.copy( vertex );
-
-				// handle special case if radiusTop/radiusBottom is zero
-				if ( ( radiusTop === 0 && y === 0 ) || ( radiusBottom === 0 && y === heightSegments ) ) {
-
-					normal.x = Math.sin( u * thetaLength + thetaStart );
-					normal.z = Math.cos( u * thetaLength + thetaStart );
-
-				}
-
-				normal.setY( Math.sqrt( normal.x * normal.x + normal.z * normal.z ) * tanTheta ).normalize();
-				normals.setXYZ( index, normal.x, normal.y, normal.z );
-
-				// uv
-				uvs.setXY( index, u, 1 - v );
-
-				// save index of vertex in respective row
-				indexRow.push( index );
-
-				// increase index
-				index ++;
-
-			}
-
-			// now save vertices of the row in our index array
-			indexArray.push( indexRow );
-
-		}
-
-		// generate indices
-
-		for ( x = 0; x < radialSegments; x ++ ) {
-
-			for ( y = 0; y < heightSegments; y ++ ) {
-
-				// we use the index array to access the correct indices
-				var i1 = indexArray[ y ][ x ];
-				var i2 = indexArray[ y + 1 ][ x ];
-				var i3 = indexArray[ y + 1 ][ x + 1 ];
-				var i4 = indexArray[ y ][ x + 1 ];
-
-				// face one
-				indices.setX( indexOffset, i1 ); indexOffset ++;
-				indices.setX( indexOffset, i2 ); indexOffset ++;
-				indices.setX( indexOffset, i4 ); indexOffset ++;
-
-				// face two
-				indices.setX( indexOffset, i2 ); indexOffset ++;
-				indices.setX( indexOffset, i3 ); indexOffset ++;
-				indices.setX( indexOffset, i4 ); indexOffset ++;
-
-				// update counters
-				groupCount += 6;
-
-			}
-
-		}
-
-		// add a group to the geometry. this will ensure multi material support
-		scope.addGroup( groupStart, groupCount, 0 );
-
-		// calculate new start value for groups
-		groupStart += groupCount;
-
-	}
-
-	function generateCap( top ) {
-
-		var x, centerIndexStart, centerIndexEnd;
-		var uv = new THREE.Vector2();
-		var vertex = new THREE.Vector3();
-
-		var groupCount = 0;
-
-		var radius = ( top === true ) ? radiusTop : radiusBottom;
-		var sign = ( top === true ) ? 1 : - 1;
-
-		// save the index of the first center vertex
-		centerIndexStart = index;
-
-		// first we generate the center vertex data of the cap.
-		// because the geometry needs one set of uvs per face,
-		// we must generate a center vertex per face/segment
-
-		for ( x = 1; x <= radialSegments; x ++ ) {
-
-			// vertex
-			vertices.setXYZ( index, 0, halfHeight * sign, 0 );
-
-			// normal
-			normals.setXYZ( index, 0, sign, 0 );
-
-			// uv
-			if ( top === true ) {
-
-				uv.x = x / radialSegments;
-				uv.y = 0;
-
-			} else {
-
-				uv.x = ( x - 1 ) / radialSegments;
-				uv.y = 1;
-
-			}
-
-			uvs.setXY( index, uv.x, uv.y );
-
-			// increase index
-			index ++;
-
-		}
-
-		// save the index of the last center vertex
-		centerIndexEnd = index;
-
-		// now we generate the surrounding vertices, normals and uvs
-
-		for ( x = 0; x <= radialSegments; x ++ ) {
-
-			var u = x / radialSegments;
-
-			// vertex
-			vertex.x = radius * Math.sin( u * thetaLength + thetaStart );
-			vertex.y = halfHeight * sign;
-			vertex.z = radius * Math.cos( u * thetaLength + thetaStart );
-			vertices.setXYZ( index, vertex.x, vertex.y, vertex.z );
-
-			// normal
-			normals.setXYZ( index, 0, sign, 0 );
-
-			// uv
-			uvs.setXY( index, u, ( top === true ) ? 1 : 0 );
-
-			// increase index
-			index ++;
-
-		}
-
-		// generate indices
-
-		for ( x = 0; x < radialSegments; x ++ ) {
-
-			var c = centerIndexStart + x;
-			var i = centerIndexEnd + x;
-
-			if ( top === true ) {
-
-				// face top
-				indices.setX( indexOffset, i ); indexOffset ++;
-				indices.setX( indexOffset, i + 1 ); indexOffset ++;
-				indices.setX( indexOffset, c ); indexOffset ++;
-
-			} else {
-
-				// face bottom
-				indices.setX( indexOffset, i + 1 ); indexOffset ++;
-				indices.setX( indexOffset, i ); indexOffset ++;
-				indices.setX( indexOffset, c ); indexOffset ++;
-
-			}
-
-			// update counters
-			groupCount += 3;
-
-		}
-
-		// add a group to the geometry. this will ensure multi material support
-		scope.addGroup( groupStart, groupCount, top === true ? 1 : 2 );
-
-		// calculate new start value for groups
-		groupStart += groupCount;
-
-	}
-
-};
-
-THREE.CylinderBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
-THREE.CylinderBufferGeometry.prototype.constructor = THREE.CylinderBufferGeometry;
-
-// File:src/extras/geometries/CylinderGeometry.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.CylinderGeometry = function ( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {
-
-	THREE.Geometry.call( this );
-
-	this.type = 'CylinderGeometry';
-
-	this.parameters = {
-		radiusTop: radiusTop,
-		radiusBottom: radiusBottom,
-		height: height,
-		radialSegments: radialSegments,
-		heightSegments: heightSegments,
-		openEnded: openEnded,
-		thetaStart: thetaStart,
-		thetaLength: thetaLength
-	};
-
-	this.fromBufferGeometry( new THREE.CylinderBufferGeometry( radiusTop, radiusBottom, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) );
-	this.mergeVertices();
-
-};
-
-THREE.CylinderGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.CylinderGeometry.prototype.constructor = THREE.CylinderGeometry;
-
-// File:src/extras/geometries/EdgesGeometry.js
-
-/**
- * @author WestLangley / http://github.com/WestLangley
- */
-
-THREE.EdgesGeometry = function ( geometry, thresholdAngle ) {
-
-	THREE.BufferGeometry.call( this );
-
-	thresholdAngle = ( thresholdAngle !== undefined ) ? thresholdAngle : 1;
-
-	var thresholdDot = Math.cos( THREE.Math.DEG2RAD * thresholdAngle );
-
-	var edge = [ 0, 0 ], hash = {};
-
-	function sortFunction( a, b ) {
-
-		return a - b;
-
-	}
-
-	var keys = [ 'a', 'b', 'c' ];
-
-	var geometry2;
-
-	if ( geometry instanceof THREE.BufferGeometry ) {
-
-		geometry2 = new THREE.Geometry();
-		geometry2.fromBufferGeometry( geometry );
-
-	} else {
-
-		geometry2 = geometry.clone();
-
-	}
-
-	geometry2.mergeVertices();
-	geometry2.computeFaceNormals();
-
-	var vertices = geometry2.vertices;
-	var faces = geometry2.faces;
-
-	for ( var i = 0, l = faces.length; i < l; i ++ ) {
-
-		var face = faces[ i ];
-
-		for ( var j = 0; j < 3; j ++ ) {
-
-			edge[ 0 ] = face[ keys[ j ] ];
-			edge[ 1 ] = face[ keys[ ( j + 1 ) % 3 ] ];
-			edge.sort( sortFunction );
-
-			var key = edge.toString();
-
-			if ( hash[ key ] === undefined ) {
-
-				hash[ key ] = { vert1: edge[ 0 ], vert2: edge[ 1 ], face1: i, face2: undefined };
-
-			} else {
-
-				hash[ key ].face2 = i;
-
-			}
-
-		}
-
-	}
-
-	var coords = [];
-
-	for ( var key in hash ) {
-
-		var h = hash[ key ];
-
-		if ( h.face2 === undefined || faces[ h.face1 ].normal.dot( faces[ h.face2 ].normal ) <= thresholdDot ) {
-
-			var vertex = vertices[ h.vert1 ];
-			coords.push( vertex.x );
-			coords.push( vertex.y );
-			coords.push( vertex.z );
-
-			vertex = vertices[ h.vert2 ];
-			coords.push( vertex.x );
-			coords.push( vertex.y );
-			coords.push( vertex.z );
-
-		}
-
-	}
-
-	this.addAttribute( 'position', new THREE.BufferAttribute( new Float32Array( coords ), 3 ) );
-
-};
-
-THREE.EdgesGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
-THREE.EdgesGeometry.prototype.constructor = THREE.EdgesGeometry;
-
-// File:src/extras/geometries/ExtrudeGeometry.js
-
-/**
- * @author zz85 / http://www.lab4games.net/zz85/blog
- *
- * Creates extruded geometry from a path shape.
- *
- * parameters = {
- *
- *  curveSegments: <int>, // number of points on the curves
- *  steps: <int>, // number of points for z-side extrusions / used for subdividing segments of extrude spline too
- *  amount: <int>, // Depth to extrude the shape
- *
- *  bevelEnabled: <bool>, // turn on bevel
- *  bevelThickness: <float>, // how deep into the original shape bevel goes
- *  bevelSize: <float>, // how far from shape outline is bevel
- *  bevelSegments: <int>, // number of bevel layers
- *
- *  extrudePath: <THREE.CurvePath> // 3d spline path to extrude shape along. (creates Frames if .frames aren't defined)
- *  frames: <THREE.TubeGeometry.FrenetFrames> // containing arrays of tangents, normals, binormals
- *
- *  uvGenerator: <Object> // object that provides UV generator functions
- *
- * }
- **/
-
-THREE.ExtrudeGeometry = function ( shapes, options ) {
-
-	if ( typeof( shapes ) === "undefined" ) {
-
-		shapes = [];
-		return;
-
-	}
-
-	THREE.Geometry.call( this );
-
-	this.type = 'ExtrudeGeometry';
-
-	shapes = Array.isArray( shapes ) ? shapes : [ shapes ];
-
-	this.addShapeList( shapes, options );
-
-	this.computeFaceNormals();
-
-	// can't really use automatic vertex normals
-	// as then front and back sides get smoothed too
-	// should do separate smoothing just for sides
-
-	//this.computeVertexNormals();
-
-	//console.log( "took", ( Date.now() - startTime ) );
-
-};
-
-THREE.ExtrudeGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.ExtrudeGeometry.prototype.constructor = THREE.ExtrudeGeometry;
-
-THREE.ExtrudeGeometry.prototype.addShapeList = function ( shapes, options ) {
-
-	var sl = shapes.length;
-
-	for ( var s = 0; s < sl; s ++ ) {
-
-		var shape = shapes[ s ];
-		this.addShape( shape, options );
-
-	}
-
-};
-
-THREE.ExtrudeGeometry.prototype.addShape = function ( shape, options ) {
-
-	var amount = options.amount !== undefined ? options.amount : 100;
-
-	var bevelThickness = options.bevelThickness !== undefined ? options.bevelThickness : 6; // 10
-	var bevelSize = options.bevelSize !== undefined ? options.bevelSize : bevelThickness - 2; // 8
-	var bevelSegments = options.bevelSegments !== undefined ? options.bevelSegments : 3;
-
-	var bevelEnabled = options.bevelEnabled !== undefined ? options.bevelEnabled : true; // false
-
-	var curveSegments = options.curveSegments !== undefined ? options.curveSegments : 12;
-
-	var steps = options.steps !== undefined ? options.steps : 1;
-
-	var extrudePath = options.extrudePath;
-	var extrudePts, extrudeByPath = false;
-
-	// Use default WorldUVGenerator if no UV generators are specified.
-	var uvgen = options.UVGenerator !== undefined ? options.UVGenerator : THREE.ExtrudeGeometry.WorldUVGenerator;
-
-	var splineTube, binormal, normal, position2;
-	if ( extrudePath ) {
-
-		extrudePts = extrudePath.getSpacedPoints( steps );
-
-		extrudeByPath = true;
-		bevelEnabled = false; // bevels not supported for path extrusion
-
-		// SETUP TNB variables
-
-		// Reuse TNB from TubeGeomtry for now.
-		// TODO1 - have a .isClosed in spline?
-
-		splineTube = options.frames !== undefined ? options.frames : new THREE.TubeGeometry.FrenetFrames( extrudePath, steps, false );
-
-		// console.log(splineTube, 'splineTube', splineTube.normals.length, 'steps', steps, 'extrudePts', extrudePts.length);
-
-		binormal = new THREE.Vector3();
-		normal = new THREE.Vector3();
-		position2 = new THREE.Vector3();
-
-	}
-
-	// Safeguards if bevels are not enabled
-
-	if ( ! bevelEnabled ) {
-
-		bevelSegments = 0;
-		bevelThickness = 0;
-		bevelSize = 0;
-
-	}
-
-	// Variables initialization
-
-	var ahole, h, hl; // looping of holes
-	var scope = this;
-
-	var shapesOffset = this.vertices.length;
-
-	var shapePoints = shape.extractPoints( curveSegments );
-
-	var vertices = shapePoints.shape;
-	var holes = shapePoints.holes;
-
-	var reverse = ! THREE.ShapeUtils.isClockWise( vertices );
-
-	if ( reverse ) {
-
-		vertices = vertices.reverse();
-
-		// Maybe we should also check if holes are in the opposite direction, just to be safe ...
-
-		for ( h = 0, hl = holes.length; h < hl; h ++ ) {
-
-			ahole = holes[ h ];
-
-			if ( THREE.ShapeUtils.isClockWise( ahole ) ) {
-
-				holes[ h ] = ahole.reverse();
-
-			}
-
-		}
-
-		reverse = false; // If vertices are in order now, we shouldn't need to worry about them again (hopefully)!
-
-	}
-
-
-	var faces = THREE.ShapeUtils.triangulateShape( vertices, holes );
-
-	/* Vertices */
-
-	var contour = vertices; // vertices has all points but contour has only points of circumference
-
-	for ( h = 0, hl = holes.length; h < hl; h ++ ) {
-
-		ahole = holes[ h ];
-
-		vertices = vertices.concat( ahole );
-
-	}
-
-
-	function scalePt2 ( pt, vec, size ) {
-
-		if ( ! vec ) console.error( "THREE.ExtrudeGeometry: vec does not exist" );
-
-		return vec.clone().multiplyScalar( size ).add( pt );
-
-	}
-
-	var b, bs, t, z,
-		vert, vlen = vertices.length,
-		face, flen = faces.length;
-
-
-	// Find directions for point movement
-
-
-	function getBevelVec( inPt, inPrev, inNext ) {
-
-		// computes for inPt the corresponding point inPt' on a new contour
-		//   shifted by 1 unit (length of normalized vector) to the left
-		// if we walk along contour clockwise, this new contour is outside the old one
-		//
-		// inPt' is the intersection of the two lines parallel to the two
-		//  adjacent edges of inPt at a distance of 1 unit on the left side.
-
-		var v_trans_x, v_trans_y, shrink_by = 1;		// resulting translation vector for inPt
-
-		// good reading for geometry algorithms (here: line-line intersection)
-		// http://geomalgorithms.com/a05-_intersect-1.html
-
-		var v_prev_x = inPt.x - inPrev.x, v_prev_y = inPt.y - inPrev.y;
-		var v_next_x = inNext.x - inPt.x, v_next_y = inNext.y - inPt.y;
-
-		var v_prev_lensq = ( v_prev_x * v_prev_x + v_prev_y * v_prev_y );
-
-		// check for collinear edges
-		var collinear0 = ( v_prev_x * v_next_y - v_prev_y * v_next_x );
-
-		if ( Math.abs( collinear0 ) > 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 <= 2 ) {
-
-				return	new THREE.Vector2( v_trans_x, v_trans_y );
-
-			} else {
-
-				shrink_by = Math.sqrt( v_trans_lensq / 2 );
-
-			}
-
-		} else {
-
-			// handle special case of collinear edges
-
-			var direction_eq = false;		// assumes: opposite
-			if ( v_prev_x > Number.EPSILON ) {
-
-				if ( v_next_x > Number.EPSILON ) {
-
-					direction_eq = true;
-
-				}
-
-			} else {
-
-				if ( v_prev_x < - Number.EPSILON ) {
-
-					if ( v_next_x < - Number.EPSILON ) {
-
-						direction_eq = true;
-
-					}
-
-				} else {
-
-					if ( Math.sign( v_prev_y ) === Math.sign( v_next_y ) ) {
-
-						direction_eq = true;
-
-					}
-
-				}
-
-			}
-
-			if ( direction_eq ) {
-
-				// console.log("Warning: lines are a straight sequence");
-				v_trans_x = - v_prev_y;
-				v_trans_y =  v_prev_x;
-				shrink_by = Math.sqrt( v_prev_lensq );
-
-			} else {
-
-				// console.log("Warning: lines are a straight spike");
-				v_trans_x = v_prev_x;
-				v_trans_y = v_prev_y;
-				shrink_by = Math.sqrt( v_prev_lensq / 2 );
-
-			}
-
-		}
-
-		return	new THREE.Vector2( v_trans_x / shrink_by, v_trans_y / shrink_by );
-
-	}
-
-
-	var contourMovements = [];
-
-	for ( var i = 0, il = contour.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {
-
-		if ( j === il ) j = 0;
-		if ( k === il ) k = 0;
-
-		//  (j)---(i)---(k)
-		// console.log('i,j,k', i, j , k)
-
-		contourMovements[ i ] = getBevelVec( contour[ i ], contour[ j ], contour[ k ] );
-
-	}
-
-	var holesMovements = [], oneHoleMovements, verticesMovements = contourMovements.concat();
-
-	for ( h = 0, hl = holes.length; h < hl; h ++ ) {
-
-		ahole = holes[ h ];
-
-		oneHoleMovements = [];
-
-		for ( i = 0, il = ahole.length, j = il - 1, k = i + 1; i < il; i ++, j ++, k ++ ) {
-
-			if ( j === il ) j = 0;
-			if ( k === il ) k = 0;
-
-			//  (j)---(i)---(k)
-			oneHoleMovements[ i ] = getBevelVec( ahole[ i ], ahole[ j ], ahole[ k ] );
-
-		}
-
-		holesMovements.push( oneHoleMovements );
-		verticesMovements = verticesMovements.concat( oneHoleMovements );
-
-	}
-
-
-	// Loop bevelSegments, 1 for the front, 1 for the back
-
-	for ( b = 0; b < bevelSegments; b ++ ) {
-
-		//for ( b = bevelSegments; b > 0; b -- ) {
-
-		t = b / bevelSegments;
-		z = bevelThickness * ( 1 - t );
-
-		//z = bevelThickness * t;
-		bs = bevelSize * ( Math.sin ( t * Math.PI / 2 ) ); // curved
-		//bs = bevelSize * t; // linear
-
-		// contract shape
-
-		for ( i = 0, il = contour.length; i < il; i ++ ) {
-
-			vert = scalePt2( contour[ i ], contourMovements[ i ], bs );
-
-			v( vert.x, vert.y,  - z );
-
-		}
-
-		// expand holes
-
-		for ( h = 0, hl = holes.length; h < hl; h ++ ) {
-
-			ahole = holes[ h ];
-			oneHoleMovements = holesMovements[ h ];
-
-			for ( i = 0, il = ahole.length; i < il; i ++ ) {
-
-				vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );
-
-				v( vert.x, vert.y,  - z );
-
-			}
-
-		}
-
-	}
-
-	bs = bevelSize;
-
-	// Back facing vertices
-
-	for ( i = 0; i < vlen; i ++ ) {
-
-		vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];
-
-		if ( ! extrudeByPath ) {
-
-			v( vert.x, vert.y, 0 );
-
-		} else {
-
-			// v( vert.x, vert.y + extrudePts[ 0 ].y, extrudePts[ 0 ].x );
-
-			normal.copy( splineTube.normals[ 0 ] ).multiplyScalar( vert.x );
-			binormal.copy( splineTube.binormals[ 0 ] ).multiplyScalar( vert.y );
-
-			position2.copy( extrudePts[ 0 ] ).add( normal ).add( binormal );
-
-			v( position2.x, position2.y, position2.z );
-
-		}
-
-	}
-
-	// Add stepped vertices...
-	// Including front facing vertices
-
-	var s;
-
-	for ( s = 1; s <= steps; s ++ ) {
-
-		for ( i = 0; i < vlen; i ++ ) {
-
-			vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];
-
-			if ( ! extrudeByPath ) {
-
-				v( vert.x, vert.y, amount / steps * s );
-
-			} else {
-
-				// v( vert.x, vert.y + extrudePts[ s - 1 ].y, extrudePts[ s - 1 ].x );
-
-				normal.copy( splineTube.normals[ s ] ).multiplyScalar( vert.x );
-				binormal.copy( splineTube.binormals[ s ] ).multiplyScalar( vert.y );
-
-				position2.copy( extrudePts[ s ] ).add( normal ).add( binormal );
-
-				v( position2.x, position2.y, position2.z );
-
-			}
-
-		}
-
-	}
-
-
-	// Add bevel segments planes
-
-	//for ( b = 1; b <= bevelSegments; b ++ ) {
-	for ( b = bevelSegments - 1; b >= 0; b -- ) {
-
-		t = b / bevelSegments;
-		z = bevelThickness * ( 1 - t );
-		//bs = bevelSize * ( 1-Math.sin ( ( 1 - t ) * Math.PI/2 ) );
-		bs = bevelSize * Math.sin ( t * Math.PI / 2 );
-
-		// contract shape
-
-		for ( i = 0, il = contour.length; i < il; i ++ ) {
-
-			vert = scalePt2( contour[ i ], contourMovements[ i ], bs );
-			v( vert.x, vert.y,  amount + z );
-
-		}
-
-		// expand holes
-
-		for ( h = 0, hl = holes.length; h < hl; h ++ ) {
-
-			ahole = holes[ h ];
-			oneHoleMovements = holesMovements[ h ];
-
-			for ( i = 0, il = ahole.length; i < il; i ++ ) {
-
-				vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );
-
-				if ( ! extrudeByPath ) {
-
-					v( vert.x, vert.y,  amount + z );
-
-				} else {
-
-					v( vert.x, vert.y + extrudePts[ steps - 1 ].y, extrudePts[ steps - 1 ].x + z );
-
-				}
-
-			}
-
-		}
-
-	}
-
-	/* Faces */
-
-	// Top and bottom faces
-
-	buildLidFaces();
-
-	// Sides faces
-
-	buildSideFaces();
-
-
-	/////  Internal functions
-
-	function buildLidFaces() {
-
-		if ( bevelEnabled ) {
-
-			var layer = 0; // steps + 1
-			var offset = vlen * layer;
-
-			// Bottom faces
-
-			for ( i = 0; i < flen; i ++ ) {
-
-				face = faces[ i ];
-				f3( face[ 2 ] + offset, face[ 1 ] + offset, face[ 0 ] + offset );
-
-			}
-
-			layer = steps + bevelSegments * 2;
-			offset = vlen * layer;
-
-			// Top faces
-
-			for ( i = 0; i < flen; i ++ ) {
-
-				face = faces[ i ];
-				f3( face[ 0 ] + offset, face[ 1 ] + offset, face[ 2 ] + offset );
-
-			}
-
-		} else {
-
-			// Bottom faces
-
-			for ( i = 0; i < flen; i ++ ) {
-
-				face = faces[ i ];
-				f3( face[ 2 ], face[ 1 ], face[ 0 ] );
-
-			}
-
-			// Top faces
-
-			for ( i = 0; i < flen; i ++ ) {
-
-				face = faces[ i ];
-				f3( face[ 0 ] + vlen * steps, face[ 1 ] + vlen * steps, face[ 2 ] + vlen * steps );
-
-			}
-
-		}
-
-	}
-
-	// Create faces for the z-sides of the shape
-
-	function buildSideFaces() {
-
-		var layeroffset = 0;
-		sidewalls( contour, layeroffset );
-		layeroffset += contour.length;
-
-		for ( h = 0, hl = holes.length; h < hl; h ++ ) {
-
-			ahole = holes[ h ];
-			sidewalls( ahole, layeroffset );
-
-			//, true
-			layeroffset += ahole.length;
-
-		}
-
-	}
-
-	function sidewalls( contour, layeroffset ) {
-
-		var j, k;
-		i = contour.length;
-
-		while ( -- i >= 0 ) {
-
-			j = i;
-			k = i - 1;
-			if ( k < 0 ) k = contour.length - 1;
-
-			//console.log('b', i,j, i-1, k,vertices.length);
-
-			var s = 0, sl = steps  + bevelSegments * 2;
-
-			for ( s = 0; s < sl; s ++ ) {
-
-				var slen1 = vlen * s;
-				var slen2 = vlen * ( s + 1 );
-
-				var a = layeroffset + j + slen1,
-					b = layeroffset + k + slen1,
-					c = layeroffset + k + slen2,
-					d = layeroffset + j + slen2;
-
-				f4( a, b, c, d, contour, s, sl, j, k );
-
-			}
-
-		}
-
-	}
-
-
-	function v( x, y, z ) {
-
-		scope.vertices.push( new THREE.Vector3( x, y, z ) );
-
-	}
-
-	function f3( a, b, c ) {
-
-		a += shapesOffset;
-		b += shapesOffset;
-		c += shapesOffset;
-
-		scope.faces.push( new THREE.Face3( a, b, c, null, null, 0 ) );
-
-		var uvs = uvgen.generateTopUV( scope, a, b, c );
-
-		scope.faceVertexUvs[ 0 ].push( uvs );
-
-	}
-
-	function f4( a, b, c, d, wallContour, stepIndex, stepsLength, contourIndex1, contourIndex2 ) {
-
-		a += shapesOffset;
-		b += shapesOffset;
-		c += shapesOffset;
-		d += shapesOffset;
-
-		scope.faces.push( new THREE.Face3( a, b, d, null, null, 1 ) );
-		scope.faces.push( new THREE.Face3( b, c, d, null, null, 1 ) );
-
-		var uvs = uvgen.generateSideWallUV( scope, a, b, c, d );
-
-		scope.faceVertexUvs[ 0 ].push( [ uvs[ 0 ], uvs[ 1 ], uvs[ 3 ] ] );
-		scope.faceVertexUvs[ 0 ].push( [ uvs[ 1 ], uvs[ 2 ], uvs[ 3 ] ] );
-
-	}
-
-};
-
-THREE.ExtrudeGeometry.WorldUVGenerator = {
-
-	generateTopUV: function ( geometry, indexA, indexB, indexC ) {
-
-		var vertices = geometry.vertices;
-
-		var a = vertices[ indexA ];
-		var b = vertices[ indexB ];
-		var c = vertices[ indexC ];
-
-		return [
-			new THREE.Vector2( a.x, a.y ),
-			new THREE.Vector2( b.x, b.y ),
-			new THREE.Vector2( c.x, c.y )
-		];
-
-	},
-
-	generateSideWallUV: function ( geometry, indexA, indexB, indexC, indexD ) {
-
-		var vertices = geometry.vertices;
-
-		var a = vertices[ indexA ];
-		var b = vertices[ indexB ];
-		var c = vertices[ indexC ];
-		var d = vertices[ indexD ];
-
-		if ( Math.abs( a.y - b.y ) < 0.01 ) {
-
-			return [
-				new THREE.Vector2( a.x, 1 - a.z ),
-				new THREE.Vector2( b.x, 1 - b.z ),
-				new THREE.Vector2( c.x, 1 - c.z ),
-				new THREE.Vector2( d.x, 1 - d.z )
-			];
-
-		} else {
-
-			return [
-				new THREE.Vector2( a.y, 1 - a.z ),
-				new THREE.Vector2( b.y, 1 - b.z ),
-				new THREE.Vector2( c.y, 1 - c.z ),
-				new THREE.Vector2( d.y, 1 - d.z )
-			];
-
-		}
-
-	}
-};
-
-// File:src/extras/geometries/ShapeGeometry.js
-
-/**
- * @author jonobr1 / http://jonobr1.com
- *
- * Creates a one-sided polygonal geometry from a path shape. Similar to
- * ExtrudeGeometry.
- *
- * parameters = {
- *
- *	curveSegments: <int>, // number of points on the curves. NOT USED AT THE MOMENT.
- *
- *	material: <int> // material index for front and back faces
- *	uvGenerator: <Object> // object that provides UV generator functions
- *
- * }
- **/
-
-THREE.ShapeGeometry = function ( shapes, options ) {
-
-	THREE.Geometry.call( this );
-
-	this.type = 'ShapeGeometry';
-
-	if ( Array.isArray( shapes ) === false ) shapes = [ shapes ];
-
-	this.addShapeList( shapes, options );
-
-	this.computeFaceNormals();
-
-};
-
-THREE.ShapeGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.ShapeGeometry.prototype.constructor = THREE.ShapeGeometry;
-
-/**
- * Add an array of shapes to THREE.ShapeGeometry.
- */
-THREE.ShapeGeometry.prototype.addShapeList = function ( shapes, options ) {
-
-	for ( var i = 0, l = shapes.length; i < l; i ++ ) {
-
-		this.addShape( shapes[ i ], options );
-
-	}
-
-	return this;
-
-};
-
-/**
- * Adds a shape to THREE.ShapeGeometry, based on THREE.ExtrudeGeometry.
- */
-THREE.ShapeGeometry.prototype.addShape = function ( shape, options ) {
-
-	if ( options === undefined ) options = {};
-	var curveSegments = options.curveSegments !== undefined ? options.curveSegments : 12;
-
-	var material = options.material;
-	var uvgen = options.UVGenerator === undefined ? THREE.ExtrudeGeometry.WorldUVGenerator : options.UVGenerator;
-
-	//
-
-	var i, l, hole;
-
-	var shapesOffset = this.vertices.length;
-	var shapePoints = shape.extractPoints( curveSegments );
-
-	var vertices = shapePoints.shape;
-	var holes = shapePoints.holes;
-
-	var reverse = ! THREE.ShapeUtils.isClockWise( vertices );
-
-	if ( reverse ) {
-
-		vertices = vertices.reverse();
-
-		// Maybe we should also check if holes are in the opposite direction, just to be safe...
-
-		for ( i = 0, l = holes.length; i < l; i ++ ) {
-
-			hole = holes[ i ];
-
-			if ( THREE.ShapeUtils.isClockWise( hole ) ) {
-
-				holes[ i ] = hole.reverse();
-
-			}
-
-		}
-
-		reverse = false;
-
-	}
-
-	var faces = THREE.ShapeUtils.triangulateShape( vertices, holes );
-
-	// Vertices
-
-	for ( i = 0, l = holes.length; i < l; i ++ ) {
-
-		hole = holes[ i ];
-		vertices = vertices.concat( hole );
-
-	}
-
-	//
-
-	var vert, vlen = vertices.length;
-	var face, flen = faces.length;
-
-	for ( i = 0; i < vlen; i ++ ) {
-
-		vert = vertices[ i ];
-
-		this.vertices.push( new THREE.Vector3( vert.x, vert.y, 0 ) );
-
-	}
-
-	for ( i = 0; i < flen; i ++ ) {
-
-		face = faces[ i ];
-
-		var a = face[ 0 ] + shapesOffset;
-		var b = face[ 1 ] + shapesOffset;
-		var c = face[ 2 ] + shapesOffset;
-
-		this.faces.push( new THREE.Face3( a, b, c, null, null, material ) );
-		this.faceVertexUvs[ 0 ].push( uvgen.generateTopUV( this, a, b, c ) );
-
-	}
-
-};
-
-// File:src/extras/geometries/LatheBufferGeometry.js
-
-/**
- * @author Mugen87 / https://github.com/Mugen87
- */
-
- // points - to create a closed torus, one must use a set of points
- //    like so: [ a, b, c, d, a ], see first is the same as last.
- // segments - the number of circumference segments to create
- // phiStart - the starting radian
- // phiLength - the radian (0 to 2PI) range of the lathed section
- //    2PI is a closed lathe, less than 2PI is a portion.
-
-THREE.LatheBufferGeometry = function ( points, segments, phiStart, phiLength ) {
-
-	THREE.BufferGeometry.call( this );
-
-	this.type = 'LatheBufferGeometry';
-
-	this.parameters = {
-		points: points,
-		segments: segments,
-		phiStart: phiStart,
-		phiLength: phiLength
-	};
-
-	segments = Math.floor( segments ) || 12;
-	phiStart = phiStart || 0;
-	phiLength = phiLength || Math.PI * 2;
-
-	// clamp phiLength so it's in range of [ 0, 2PI ]
-	phiLength = THREE.Math.clamp( phiLength, 0, Math.PI * 2 );
-
-	// these are used to calculate buffer length
-	var vertexCount = ( segments + 1 ) * points.length;
-	var indexCount = segments * points.length * 2 * 3;
-
-	// buffers
-	var indices = new THREE.BufferAttribute( new ( indexCount > 65535 ? Uint32Array : Uint16Array )( indexCount ) , 1 );
-	var vertices = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
-	var uvs = new THREE.BufferAttribute( new Float32Array( vertexCount * 2 ), 2 );
-
-	// helper variables
-	var index = 0, indexOffset = 0, base;
-	var inversePointLength = 1.0 / ( points.length - 1 );
-	var inverseSegments = 1.0 / segments;
-	var vertex = new THREE.Vector3();
-	var uv = new THREE.Vector2();
-	var i, j;
-
-	// generate vertices and uvs
-
-	for ( i = 0; i <= segments; i ++ ) {
-
-		var phi = phiStart + i * inverseSegments * phiLength;
-
-		var sin = Math.sin( phi );
-		var cos = Math.cos( phi );
-
-		for ( j = 0; j <= ( points.length - 1 ); j ++ ) {
-
-			// vertex
-			vertex.x = points[ j ].x * sin;
-			vertex.y = points[ j ].y;
-			vertex.z = points[ j ].x * cos;
-			vertices.setXYZ( index, vertex.x, vertex.y, vertex.z );
-
-			// uv
-			uv.x = i / segments;
-			uv.y = j / ( points.length - 1 );
-			uvs.setXY( index, uv.x, uv.y );
-
-			// increase index
-			index ++;
-
-		}
-
-	}
-
-	// generate indices
-
-	for ( i = 0; i < segments; i ++ ) {
-
-		for ( j = 0; j < ( points.length - 1 ); j ++ ) {
-
-			base = j + i * points.length;
-
-			// indices
-			var a = base;
-			var b = base + points.length;
-			var c = base + points.length + 1;
-			var d = base + 1;
-
-			// face one
-			indices.setX( indexOffset, a ); indexOffset++;
-			indices.setX( indexOffset, b ); indexOffset++;
-			indices.setX( indexOffset, d ); indexOffset++;
-
-			// face two
-			indices.setX( indexOffset, b ); indexOffset++;
-			indices.setX( indexOffset, c ); indexOffset++;
-			indices.setX( indexOffset, d ); indexOffset++;
-
-		}
-
-	}
-
-	// build geometry
-
-	this.setIndex( indices );
-	this.addAttribute( 'position', vertices );
-	this.addAttribute( 'uv', uvs );
-
-	// generate normals
-
-	this.computeVertexNormals();
-
-	// if the geometry is closed, we need to average the normals along the seam.
-	// because the corresponding vertices are identical (but still have different UVs).
-
-	if( phiLength === Math.PI * 2 ) {
-
-		var normals = this.attributes.normal.array;
-		var n1 = new THREE.Vector3();
-		var n2 = new THREE.Vector3();
-		var n = new THREE.Vector3();
-
-		// this is the buffer offset for the last line of vertices
-		base = segments * points.length * 3;
-
-		for( i = 0, j = 0; i < points.length; i ++, j += 3 ) {
-
-			// select the normal of the vertex in the first line
-			n1.x = normals[ j + 0 ];
-			n1.y = normals[ j + 1 ];
-			n1.z = normals[ j + 2 ];
-
-			// select the normal of the vertex in the last line
-			n2.x = normals[ base + j + 0 ];
-			n2.y = normals[ base + j + 1 ];
-			n2.z = normals[ base + j + 2 ];
-
-			// average normals
-			n.addVectors( n1, n2 ).normalize();
-
-			// assign the new values to both normals
-			normals[ j + 0 ] = normals[ base + j + 0 ] = n.x;
-			normals[ j + 1 ] = normals[ base + j + 1 ] = n.y;
-			normals[ j + 2 ] = normals[ base + j + 2 ] = n.z;
-
-		} // next row
-
-	}
-
-};
-
-THREE.LatheBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
-THREE.LatheBufferGeometry.prototype.constructor = THREE.LatheBufferGeometry;
-
-// File:src/extras/geometries/LatheGeometry.js
-
-/**
- * @author astrodud / http://astrodud.isgreat.org/
- * @author zz85 / https://github.com/zz85
- * @author bhouston / http://clara.io
- */
-
-// points - to create a closed torus, one must use a set of points
-//    like so: [ a, b, c, d, a ], see first is the same as last.
-// segments - the number of circumference segments to create
-// phiStart - the starting radian
-// phiLength - the radian (0 to 2PI) range of the lathed section
-//    2PI is a closed lathe, less than 2PI is a portion.
-
-THREE.LatheGeometry = function ( points, segments, phiStart, phiLength ) {
-
-	THREE.Geometry.call( this );
-
-	this.type = 'LatheGeometry';
-
-	this.parameters = {
-		points: points,
-		segments: segments,
-		phiStart: phiStart,
-		phiLength: phiLength
-	};
-
-	this.fromBufferGeometry( new THREE.LatheBufferGeometry( points, segments, phiStart, phiLength ) );
-	this.mergeVertices();
-
-};
-
-THREE.LatheGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.LatheGeometry.prototype.constructor = THREE.LatheGeometry;
-
-// File:src/extras/geometries/PlaneGeometry.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * based on http://papervision3d.googlecode.com/svn/trunk/as3/trunk/src/org/papervision3d/objects/primitives/Plane.as
- */
-
-THREE.PlaneGeometry = function ( width, height, widthSegments, heightSegments ) {
-
-	THREE.Geometry.call( this );
-
-	this.type = 'PlaneGeometry';
-
-	this.parameters = {
-		width: width,
-		height: height,
-		widthSegments: widthSegments,
-		heightSegments: heightSegments
-	};
-
-	this.fromBufferGeometry( new THREE.PlaneBufferGeometry( width, height, widthSegments, heightSegments ) );
-
-};
-
-THREE.PlaneGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.PlaneGeometry.prototype.constructor = THREE.PlaneGeometry;
-
-// File:src/extras/geometries/PlaneBufferGeometry.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * based on http://papervision3d.googlecode.com/svn/trunk/as3/trunk/src/org/papervision3d/objects/primitives/Plane.as
- */
-
-THREE.PlaneBufferGeometry = function ( width, height, widthSegments, heightSegments ) {
-
-	THREE.BufferGeometry.call( this );
-
-	this.type = 'PlaneBufferGeometry';
-
-	this.parameters = {
-		width: width,
-		height: height,
-		widthSegments: widthSegments,
-		heightSegments: heightSegments
-	};
-
-	var width_half = width / 2;
-	var height_half = height / 2;
-
-	var gridX = Math.floor( widthSegments ) || 1;
-	var gridY = Math.floor( heightSegments ) || 1;
-
-	var gridX1 = gridX + 1;
-	var gridY1 = gridY + 1;
-
-	var segment_width = width / gridX;
-	var segment_height = height / gridY;
-
-	var vertices = new Float32Array( gridX1 * gridY1 * 3 );
-	var normals = new Float32Array( gridX1 * gridY1 * 3 );
-	var uvs = new Float32Array( gridX1 * gridY1 * 2 );
-
-	var offset = 0;
-	var offset2 = 0;
-
-	for ( var iy = 0; iy < gridY1; iy ++ ) {
-
-		var y = iy * segment_height - height_half;
-
-		for ( var ix = 0; ix < gridX1; ix ++ ) {
-
-			var x = ix * segment_width - width_half;
-
-			vertices[ offset ] = x;
-			vertices[ offset + 1 ] = - y;
-
-			normals[ offset + 2 ] = 1;
-
-			uvs[ offset2 ] = ix / gridX;
-			uvs[ offset2 + 1 ] = 1 - ( iy / gridY );
-
-			offset += 3;
-			offset2 += 2;
-
-		}
-
-	}
-
-	offset = 0;
-
-	var indices = new ( ( vertices.length / 3 ) > 65535 ? Uint32Array : Uint16Array )( gridX * gridY * 6 );
-
-	for ( var iy = 0; iy < gridY; iy ++ ) {
-
-		for ( var ix = 0; ix < gridX; ix ++ ) {
-
-			var a = ix + gridX1 * iy;
-			var b = ix + gridX1 * ( iy + 1 );
-			var c = ( ix + 1 ) + gridX1 * ( iy + 1 );
-			var d = ( ix + 1 ) + gridX1 * iy;
-
-			indices[ offset ] = a;
-			indices[ offset + 1 ] = b;
-			indices[ offset + 2 ] = d;
-
-			indices[ offset + 3 ] = b;
-			indices[ offset + 4 ] = c;
-			indices[ offset + 5 ] = d;
-
-			offset += 6;
-
-		}
-
-	}
-
-	this.setIndex( new THREE.BufferAttribute( indices, 1 ) );
-	this.addAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
-	this.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
-	this.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ) );
-
-};
-
-THREE.PlaneBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
-THREE.PlaneBufferGeometry.prototype.constructor = THREE.PlaneBufferGeometry;
-
-// File:src/extras/geometries/RingBufferGeometry.js
-
-/**
- * @author Mugen87 / https://github.com/Mugen87
- */
-
-THREE.RingBufferGeometry = function ( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) {
-
-	THREE.BufferGeometry.call( this );
-
-	this.type = 'RingBufferGeometry';
-
-	this.parameters = {
-		innerRadius: innerRadius,
-		outerRadius: outerRadius,
-		thetaSegments: thetaSegments,
-		phiSegments: phiSegments,
-		thetaStart: thetaStart,
-		thetaLength: thetaLength
-	};
-
-	innerRadius = innerRadius || 20;
-	outerRadius = outerRadius || 50;
-
-	thetaStart = thetaStart !== undefined ? thetaStart : 0;
-	thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;
-
-	thetaSegments = thetaSegments !== undefined ? Math.max( 3, thetaSegments ) : 8;
-	phiSegments = phiSegments !== undefined ? Math.max( 1, phiSegments ) : 1;
-
-	// these are used to calculate buffer length
-	var vertexCount = ( thetaSegments + 1 ) * ( phiSegments + 1 );
-	var indexCount = thetaSegments * phiSegments * 2 * 3;
-
-	// buffers
-	var indices = new THREE.BufferAttribute( new ( indexCount > 65535 ? Uint32Array : Uint16Array )( indexCount ) , 1 );
-	var vertices = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
-	var normals = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
-	var uvs = new THREE.BufferAttribute( new Float32Array( vertexCount * 2 ), 2 );
-
-	// some helper variables
-	var index = 0, indexOffset = 0, segment;
-	var radius = innerRadius;
-	var radiusStep = ( ( outerRadius - innerRadius ) / phiSegments );
-	var vertex = new THREE.Vector3();
-	var uv = new THREE.Vector2();
-	var j, i;
-
-	// generate vertices, normals and uvs
-
-	// values are generate from the inside of the ring to the outside
-
-	for ( j = 0; j <= phiSegments; j ++ ) {
-
-		for ( i = 0; i <= thetaSegments; i ++ ) {
-
-			segment = thetaStart + i / thetaSegments * thetaLength;
-
-			// vertex
-			vertex.x = radius * Math.cos( segment );
-			vertex.y = radius * Math.sin( segment );
-			vertices.setXYZ( index, vertex.x, vertex.y, vertex.z );
-
-			// normal
-			normals.setXYZ( index, 0, 0, 1 );
-
-			// uv
-			uv.x = ( vertex.x / outerRadius + 1 ) / 2;
-			uv.y = ( vertex.y / outerRadius + 1 ) / 2;
-			uvs.setXY( index, uv.x, uv.y );
-
-			// increase index
-			index++;
-
-		}
-
-		// increase the radius for next row of vertices
-		radius += radiusStep;
-
-	}
-
-	// generate indices
-
-	for ( j = 0; j < phiSegments; j ++ ) {
-
-		var thetaSegmentLevel = j * ( thetaSegments + 1 );
-
-		for ( i = 0; i < thetaSegments; i ++ ) {
-
-			segment = i + thetaSegmentLevel;
-
-			// indices
-			var a = segment;
-			var b = segment + thetaSegments + 1;
-			var c = segment + thetaSegments + 2;
-			var d = segment + 1;
-
-			// face one
-			indices.setX( indexOffset, a ); indexOffset++;
-			indices.setX( indexOffset, b ); indexOffset++;
-			indices.setX( indexOffset, c ); indexOffset++;
-
-			// face two
-			indices.setX( indexOffset, a ); indexOffset++;
-			indices.setX( indexOffset, c ); indexOffset++;
-			indices.setX( indexOffset, d ); indexOffset++;
-
-		}
-
-	}
-
-	// build geometry
-
-	this.setIndex( indices );
-	this.addAttribute( 'position', vertices );
-	this.addAttribute( 'normal', normals );
-	this.addAttribute( 'uv', uvs );
-
-};
-
-THREE.RingBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
-THREE.RingBufferGeometry.prototype.constructor = THREE.RingBufferGeometry;
-
-// File:src/extras/geometries/RingGeometry.js
-
-/**
- * @author Kaleb Murphy
- */
-
-THREE.RingGeometry = function ( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) {
-
-	THREE.Geometry.call( this );
-
-	this.type = 'RingGeometry';
-
-	this.parameters = {
-		innerRadius: innerRadius,
-		outerRadius: outerRadius,
-		thetaSegments: thetaSegments,
-		phiSegments: phiSegments,
-		thetaStart: thetaStart,
-		thetaLength: thetaLength
-	};
-
-	this.fromBufferGeometry( new THREE.RingBufferGeometry( innerRadius, outerRadius, thetaSegments, phiSegments, thetaStart, thetaLength ) );
-
-};
-
-THREE.RingGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.RingGeometry.prototype.constructor = THREE.RingGeometry;
-
-// File:src/extras/geometries/SphereGeometry.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.SphereGeometry = function ( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) {
-
-	THREE.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 THREE.SphereBufferGeometry( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) );
-
-};
-
-THREE.SphereGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.SphereGeometry.prototype.constructor = THREE.SphereGeometry;
-
-// File:src/extras/geometries/SphereBufferGeometry.js
-
-/**
- * @author benaadams / https://twitter.com/ben_a_adams
- * based on THREE.SphereGeometry
- */
-
-THREE.SphereBufferGeometry = function ( radius, widthSegments, heightSegments, phiStart, phiLength, thetaStart, thetaLength ) {
-
-	THREE.BufferGeometry.call( this );
-
-	this.type = 'SphereBufferGeometry';
-
-	this.parameters = {
-		radius: radius,
-		widthSegments: widthSegments,
-		heightSegments: heightSegments,
-		phiStart: phiStart,
-		phiLength: phiLength,
-		thetaStart: thetaStart,
-		thetaLength: thetaLength
-	};
-
-	radius = radius || 50;
-
-	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 = thetaStart + thetaLength;
-
-	var vertexCount = ( ( widthSegments + 1 ) * ( heightSegments + 1 ) );
-
-	var positions = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
-	var normals = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
-	var uvs = new THREE.BufferAttribute( new Float32Array( vertexCount * 2 ), 2 );
-
-	var index = 0, vertices = [], normal = new THREE.Vector3();
-
-	for ( var y = 0; y <= heightSegments; y ++ ) {
-
-		var verticesRow = [];
-
-		var v = y / heightSegments;
-
-		for ( var x = 0; x <= widthSegments; x ++ ) {
-
-			var u = x / widthSegments;
-
-			var px = - radius * Math.cos( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );
-			var py = radius * Math.cos( thetaStart + v * thetaLength );
-			var pz = radius * Math.sin( phiStart + u * phiLength ) * Math.sin( thetaStart + v * thetaLength );
-
-			normal.set( px, py, pz ).normalize();
-
-			positions.setXYZ( index, px, py, pz );
-			normals.setXYZ( index, normal.x, normal.y, normal.z );
-			uvs.setXY( index, u, 1 - v );
-
-			verticesRow.push( index );
-
-			index ++;
-
-		}
-
-		vertices.push( verticesRow );
-
-	}
-
-	var indices = [];
-
-	for ( var y = 0; y < heightSegments; y ++ ) {
-
-		for ( var x = 0; x < widthSegments; x ++ ) {
-
-			var v1 = vertices[ y ][ x + 1 ];
-			var v2 = vertices[ y ][ x ];
-			var v3 = vertices[ y + 1 ][ x ];
-			var v4 = vertices[ y + 1 ][ x + 1 ];
-
-			if ( y !== 0 || thetaStart > 0 ) indices.push( v1, v2, v4 );
-			if ( y !== heightSegments - 1 || thetaEnd < Math.PI ) indices.push( v2, v3, v4 );
-
-		}
-
-	}
-
-	this.setIndex( new ( positions.count > 65535 ? THREE.Uint32Attribute : THREE.Uint16Attribute )( indices, 1 ) );
-	this.addAttribute( 'position', positions );
-	this.addAttribute( 'normal', normals );
-	this.addAttribute( 'uv', uvs );
-
-	this.boundingSphere = new THREE.Sphere( new THREE.Vector3(), radius );
-
-};
-
-THREE.SphereBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
-THREE.SphereBufferGeometry.prototype.constructor = THREE.SphereBufferGeometry;
-
-// File:src/extras/geometries/TextGeometry.js
-
-/**
- * @author zz85 / http://www.lab4games.net/zz85/blog
- * @author alteredq / http://alteredqualia.com/
- *
- * Text = 3D Text
- *
- * parameters = {
- *  font: <THREE.Font>, // font
- *
- *  size: <float>, // size of the text
- *  height: <float>, // thickness to extrude text
- *  curveSegments: <int>, // number of points on the curves
- *
- *  bevelEnabled: <bool>, // turn on bevel
- *  bevelThickness: <float>, // how deep into text bevel goes
- *  bevelSize: <float> // how far from text outline is bevel
- * }
- */
-
-THREE.TextGeometry = function ( text, parameters ) {
-
-	parameters = parameters || {};
-
-	var font = parameters.font;
-
-	if ( font instanceof THREE.Font === false ) {
-
-		console.error( 'THREE.TextGeometry: font parameter is not an instance of THREE.Font.' );
-		return new THREE.Geometry();
-
-	}
-
-	var shapes = font.generateShapes( text, parameters.size, parameters.curveSegments );
-
-	// translate parameters to ExtrudeGeometry API
-
-	parameters.amount = 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;
-
-	THREE.ExtrudeGeometry.call( this, shapes, parameters );
-
-	this.type = 'TextGeometry';
-
-};
-
-THREE.TextGeometry.prototype = Object.create( THREE.ExtrudeGeometry.prototype );
-THREE.TextGeometry.prototype.constructor = THREE.TextGeometry;
-
-// File:src/extras/geometries/TorusBufferGeometry.js
-
-/**
- * @author Mugen87 / https://github.com/Mugen87
- */
-
-THREE.TorusBufferGeometry = function ( radius, tube, radialSegments, tubularSegments, arc ) {
-
-	THREE.BufferGeometry.call( this );
-
-	this.type = 'TorusBufferGeometry';
-
-	this.parameters = {
-		radius: radius,
-		tube: tube,
-		radialSegments: radialSegments,
-		tubularSegments: tubularSegments,
-		arc: arc
-	};
-
-	radius = radius || 100;
-	tube = tube || 40;
-	radialSegments = Math.floor( radialSegments ) || 8;
-	tubularSegments = Math.floor( tubularSegments ) || 6;
-	arc = arc || Math.PI * 2;
-
-	// used to calculate buffer length
-	var vertexCount = ( ( radialSegments + 1 ) * ( tubularSegments + 1 ) );
-	var indexCount = radialSegments * tubularSegments * 2 * 3;
-
-	// buffers
-	var indices = new ( indexCount > 65535 ? Uint32Array : Uint16Array )( indexCount );
-	var vertices = new Float32Array( vertexCount * 3 );
-	var normals = new Float32Array( vertexCount * 3 );
-	var uvs = new Float32Array( vertexCount * 2 );
-
-	// offset variables
-	var vertexBufferOffset = 0;
-	var uvBufferOffset = 0;
-	var indexBufferOffset = 0;
-
-	// helper variables
-	var center = new THREE.Vector3();
-	var vertex = new THREE.Vector3();
-	var normal = new THREE.Vector3();
-
-	var j, i;
-
-	// generate vertices, normals and uvs
-
-	for ( j = 0; j <= radialSegments; j ++ ) {
-
-		for ( i = 0; i <= tubularSegments; i ++ ) {
-
-			var u = i / tubularSegments * arc;
-			var v = j / radialSegments * Math.PI * 2;
-
-			// vertex
-			vertex.x = ( radius + tube * Math.cos( v ) ) * Math.cos( u );
-			vertex.y = ( radius + tube * Math.cos( v ) ) * Math.sin( u );
-			vertex.z = tube * Math.sin( v );
-
-			vertices[ vertexBufferOffset ] = vertex.x;
-			vertices[ vertexBufferOffset + 1 ] = vertex.y;
-			vertices[ vertexBufferOffset + 2 ] = vertex.z;
-
-			// this vector is used to calculate the normal
-			center.x = radius * Math.cos( u );
-			center.y = radius * Math.sin( u );
-
-			// normal
-			normal.subVectors( vertex, center ).normalize();
-
-			normals[ vertexBufferOffset ] = normal.x;
-			normals[ vertexBufferOffset + 1 ] = normal.y;
-			normals[ vertexBufferOffset + 2 ] = normal.z;
-
-			// uv
-			uvs[ uvBufferOffset ] = i / tubularSegments;
-			uvs[ uvBufferOffset + 1 ] = j / radialSegments;
-
-			// update offsets
-			vertexBufferOffset += 3;
-			uvBufferOffset += 2;
-
-		}
-
-	}
-
-	// generate indices
-
-	for ( j = 1; j <= radialSegments; j ++ ) {
-
-		for ( i = 1; i <= tubularSegments; i ++ ) {
-
-			// indices
-			var a = ( tubularSegments + 1 ) * j + i - 1;
-			var b = ( tubularSegments + 1 ) * ( j - 1 ) + i - 1;
-			var c = ( tubularSegments + 1 ) * ( j - 1 ) + i;
-			var d = ( tubularSegments + 1 ) * j + i;
-
-			// face one
-			indices[ indexBufferOffset ] = a;
-			indices[ indexBufferOffset + 1 ] = b;
-			indices[ indexBufferOffset + 2 ] = d;
-
-			// face two
-			indices[ indexBufferOffset + 3 ] = b;
-			indices[ indexBufferOffset + 4 ] = c;
-			indices[ indexBufferOffset + 5 ] = d;
-
-			// update offset
-			indexBufferOffset += 6;
-
-		}
-
-	}
-
-	// build geometry
-	this.setIndex( new THREE.BufferAttribute( indices, 1 ) );
-	this.addAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
-	this.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
-	this.addAttribute( 'uv', new THREE.BufferAttribute( uvs, 2 ) );
-
-};
-
-THREE.TorusBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
-THREE.TorusBufferGeometry.prototype.constructor = THREE.TorusBufferGeometry;
-
-// File:src/extras/geometries/TorusGeometry.js
-
-/**
- * @author oosmoxiecode
- * @author mrdoob / http://mrdoob.com/
- * based on http://code.google.com/p/away3d/source/browse/trunk/fp10/Away3DLite/src/away3dlite/primitives/Torus.as?r=2888
- */
-
-THREE.TorusGeometry = function ( radius, tube, radialSegments, tubularSegments, arc ) {
-
-	THREE.Geometry.call( this );
-
-	this.type = 'TorusGeometry';
-
-	this.parameters = {
-		radius: radius,
-		tube: tube,
-		radialSegments: radialSegments,
-		tubularSegments: tubularSegments,
-		arc: arc
-	};
-
-	this.fromBufferGeometry( new THREE.TorusBufferGeometry( radius, tube, radialSegments, tubularSegments, arc ) );
-
-};
-
-THREE.TorusGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.TorusGeometry.prototype.constructor = THREE.TorusGeometry;
-
-// File:src/extras/geometries/TorusKnotBufferGeometry.js
-
-/**
- * @author Mugen87 / https://github.com/Mugen87
- *
- * see: http://www.blackpawn.com/texts/pqtorus/
- */
-THREE.TorusKnotBufferGeometry = function ( radius, tube, tubularSegments, radialSegments, p, q ) {
-
-	THREE.BufferGeometry.call( this );
-
-	this.type = 'TorusKnotBufferGeometry';
-
-	this.parameters = {
-		radius: radius,
-		tube: tube,
-		tubularSegments: tubularSegments,
-		radialSegments: radialSegments,
-		p: p,
-		q: q
-	};
-
-	radius = radius || 100;
-	tube = tube || 40;
-	tubularSegments = Math.floor( tubularSegments ) || 64;
-	radialSegments = Math.floor( radialSegments ) || 8;
-	p = p || 2;
-	q = q || 3;
-
-	// used to calculate buffer length
-	var vertexCount = ( ( radialSegments + 1 ) * ( tubularSegments + 1 ) );
-	var indexCount = radialSegments * tubularSegments * 2 * 3;
-
-	// buffers
-	var indices = new THREE.BufferAttribute( new ( indexCount > 65535 ? Uint32Array : Uint16Array )( indexCount ) , 1 );
-	var vertices = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
-	var normals = new THREE.BufferAttribute( new Float32Array( vertexCount * 3 ), 3 );
-	var uvs = new THREE.BufferAttribute( new Float32Array( vertexCount * 2 ), 2 );
-
-	// helper variables
-	var i, j, index = 0, indexOffset = 0;
-
-	var vertex = new THREE.Vector3();
-	var normal = new THREE.Vector3();
-	var uv = new THREE.Vector2();
-
-	var P1 = new THREE.Vector3();
-	var P2 = new THREE.Vector3();
-
-	var B = new THREE.Vector3();
-	var T = new THREE.Vector3();
-	var N = new THREE.Vector3();
-
-	// generate vertices, normals and uvs
-
-	for ( i = 0; i <= tubularSegments; ++ i ) {
-
-		// the radian "u" is used to calculate the position on the torus curve of the current tubular segement
-
-		var u = i / tubularSegments * p * Math.PI * 2;
-
-		// now we calculate two points. P1 is our current position on the curve, P2 is a little farther ahead.
-		// these points are used to create a special "coordinate space", which is necessary to calculate the correct vertex positions
-
-		calculatePositionOnCurve( u, p, q, radius, P1 );
-		calculatePositionOnCurve( u + 0.01, p, q, radius, P2 );
-
-		// calculate orthonormal basis
-
-		T.subVectors( P2, P1 );
-		N.addVectors( P2, P1 );
-		B.crossVectors( T, N );
-		N.crossVectors( B, T );
-
-		// normalize B, N. T can be ignored, we don't use it
-
-		B.normalize();
-		N.normalize();
-
-		for ( j = 0; j <= radialSegments; ++ j ) {
-
-			// now calculate the vertices. they are nothing more than an extrusion of the torus curve.
-			// because we extrude a shape in the xy-plane, there is no need to calculate a z-value.
-
-			var v = j / radialSegments * Math.PI * 2;
-			var cx = - tube * Math.cos( v );
-			var cy = tube * Math.sin( v );
-
-			// now calculate the final vertex position.
-			// first we orient the extrusion with our basis vectos, then we add it to the current position on the curve
-
-			vertex.x = P1.x + ( cx * N.x + cy * B.x );
-			vertex.y = P1.y + ( cx * N.y + cy * B.y );
-			vertex.z = P1.z + ( cx * N.z + cy * B.z );
-
-			// vertex
-			vertices.setXYZ( index, vertex.x, vertex.y, vertex.z );
-
-			// normal (P1 is always the center/origin of the extrusion, thus we can use it to calculate the normal)
-			normal.subVectors( vertex, P1 ).normalize();
-			normals.setXYZ( index, normal.x, normal.y, normal.z );
-
-			// uv
-			uv.x = i / tubularSegments;
-			uv.y = j / radialSegments;
-			uvs.setXY( index, uv.x, uv.y );
-
-			// increase index
-			index ++;
-
-		}
-
-	}
-
-	// generate indices
-
-	for ( j = 1; j <= tubularSegments; j ++ ) {
-
-		for ( i = 1; i <= radialSegments; i ++ ) {
-
-			// indices
-			var a = ( radialSegments + 1 ) * ( j - 1 ) + ( i - 1 );
-			var b = ( radialSegments + 1 ) * j + ( i - 1 );
-			var c = ( radialSegments + 1 ) * j + i;
-			var d = ( radialSegments + 1 ) * ( j - 1 ) + i;
-
-			// face one
-			indices.setX( indexOffset, a ); indexOffset++;
-			indices.setX( indexOffset, b ); indexOffset++;
-			indices.setX( indexOffset, d ); indexOffset++;
-
-			// face two
-			indices.setX( indexOffset, b ); indexOffset++;
-			indices.setX( indexOffset, c ); indexOffset++;
-			indices.setX( indexOffset, d ); indexOffset++;
-
-		}
-
-	}
-
-	// build geometry
-
-	this.setIndex( indices );
-	this.addAttribute( 'position', vertices );
-	this.addAttribute( 'normal', normals );
-	this.addAttribute( 'uv', uvs );
-
-	// this function calculates the current position on the torus curve
-
-	function calculatePositionOnCurve( u, p, q, radius, position ) {
-
-		var cu = Math.cos( u );
-		var su = Math.sin( u );
-		var quOverP = q / p * u;
-		var cs = Math.cos( quOverP );
-
-		position.x = radius * ( 2 + cs ) * 0.5 * cu;
-		position.y = radius * ( 2 + cs ) * su * 0.5;
-		position.z = radius * Math.sin( quOverP ) * 0.5;
-
-	}
-
-};
-
-THREE.TorusKnotBufferGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
-THREE.TorusKnotBufferGeometry.prototype.constructor = THREE.TorusKnotBufferGeometry;
-
-// File:src/extras/geometries/TorusKnotGeometry.js
-
-/**
- * @author oosmoxiecode
- */
-
-THREE.TorusKnotGeometry = function ( radius, tube, tubularSegments, radialSegments, p, q, heightScale ) {
-
-	THREE.Geometry.call( this );
-
-	this.type = 'TorusKnotGeometry';
-
-	this.parameters = {
-		radius: radius,
-		tube: tube,
-		tubularSegments: tubularSegments,
-		radialSegments: radialSegments,
-		p: p,
-		q: q
-	};
-
-	if( heightScale !== undefined ) console.warn( 'THREE.TorusKnotGeometry: heightScale has been deprecated. Use .scale( x, y, z ) instead.' );
-
-	this.fromBufferGeometry( new THREE.TorusKnotBufferGeometry( radius, tube, tubularSegments, radialSegments, p, q ) );
-	this.mergeVertices();
-
-};
-
-THREE.TorusKnotGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.TorusKnotGeometry.prototype.constructor = THREE.TorusKnotGeometry;
-
-// File:src/extras/geometries/TubeGeometry.js
-
-/**
- * @author WestLangley / https://github.com/WestLangley
- * @author zz85 / https://github.com/zz85
- * @author miningold / https://github.com/miningold
- * @author jonobr1 / https://github.com/jonobr1
- *
- * Modified from the TorusKnotGeometry by @oosmoxiecode
- *
- * Creates a tube which extrudes along a 3d spline
- *
- * Uses parallel transport frames as described in
- * http://www.cs.indiana.edu/pub/techreports/TR425.pdf
- */
-
-THREE.TubeGeometry = function ( path, segments, radius, radialSegments, closed, taper ) {
-
-	THREE.Geometry.call( this );
-
-	this.type = 'TubeGeometry';
-
-	this.parameters = {
-		path: path,
-		segments: segments,
-		radius: radius,
-		radialSegments: radialSegments,
-		closed: closed,
-		taper: taper
-	};
-
-	segments = segments || 64;
-	radius = radius || 1;
-	radialSegments = radialSegments || 8;
-	closed = closed || false;
-	taper = taper || THREE.TubeGeometry.NoTaper;
-
-	var grid = [];
-
-	var scope = this,
-
-		tangent,
-		normal,
-		binormal,
-
-		numpoints = segments + 1,
-
-		u, v, r,
-
-		cx, cy,
-		pos, pos2 = new THREE.Vector3(),
-		i, j,
-		ip, jp,
-		a, b, c, d,
-		uva, uvb, uvc, uvd;
-
-	var frames = new THREE.TubeGeometry.FrenetFrames( path, segments, closed ),
-		tangents = frames.tangents,
-		normals = frames.normals,
-		binormals = frames.binormals;
-
-	// proxy internals
-	this.tangents = tangents;
-	this.normals = normals;
-	this.binormals = binormals;
-
-	function vert( x, y, z ) {
-
-		return scope.vertices.push( new THREE.Vector3( x, y, z ) ) - 1;
-
-	}
-
-	// construct the grid
-
-	for ( i = 0; i < numpoints; i ++ ) {
-
-		grid[ i ] = [];
-
-		u = i / ( numpoints - 1 );
-
-		pos = path.getPointAt( u );
-
-		tangent = tangents[ i ];
-		normal = normals[ i ];
-		binormal = binormals[ i ];
-
-		r = radius * taper( u );
-
-		for ( j = 0; j < radialSegments; j ++ ) {
-
-			v = j / radialSegments * 2 * Math.PI;
-
-			cx = - r * Math.cos( v ); // TODO: Hack: Negating it so it faces outside.
-			cy = r * Math.sin( v );
-
-			pos2.copy( pos );
-			pos2.x += cx * normal.x + cy * binormal.x;
-			pos2.y += cx * normal.y + cy * binormal.y;
-			pos2.z += cx * normal.z + cy * binormal.z;
-
-			grid[ i ][ j ] = vert( pos2.x, pos2.y, pos2.z );
-
-		}
-
-	}
-
-
-	// construct the mesh
-
-	for ( i = 0; i < segments; i ++ ) {
-
-		for ( j = 0; j < radialSegments; j ++ ) {
-
-			ip = ( closed ) ? ( i + 1 ) % segments : i + 1;
-			jp = ( j + 1 ) % radialSegments;
-
-			a = grid[ i ][ j ];		// *** NOT NECESSARILY PLANAR ! ***
-			b = grid[ ip ][ j ];
-			c = grid[ ip ][ jp ];
-			d = grid[ i ][ jp ];
-
-			uva = new THREE.Vector2( i / segments, j / radialSegments );
-			uvb = new THREE.Vector2( ( i + 1 ) / segments, j / radialSegments );
-			uvc = new THREE.Vector2( ( i + 1 ) / segments, ( j + 1 ) / radialSegments );
-			uvd = new THREE.Vector2( i / segments, ( j + 1 ) / radialSegments );
-
-			this.faces.push( new THREE.Face3( a, b, d ) );
-			this.faceVertexUvs[ 0 ].push( [ uva, uvb, uvd ] );
-
-			this.faces.push( new THREE.Face3( b, c, d ) );
-			this.faceVertexUvs[ 0 ].push( [ uvb.clone(), uvc, uvd.clone() ] );
-
-		}
-
-	}
-
-	this.computeFaceNormals();
-	this.computeVertexNormals();
-
-};
-
-THREE.TubeGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.TubeGeometry.prototype.constructor = THREE.TubeGeometry;
-
-THREE.TubeGeometry.NoTaper = function ( u ) {
-
-	return 1;
-
-};
-
-THREE.TubeGeometry.SinusoidalTaper = function ( u ) {
-
-	return Math.sin( Math.PI * u );
-
-};
-
-// For computing of Frenet frames, exposing the tangents, normals and binormals the spline
-THREE.TubeGeometry.FrenetFrames = function ( path, segments, closed ) {
-
-	var	normal = new THREE.Vector3(),
-
-		tangents = [],
-		normals = [],
-		binormals = [],
-
-		vec = new THREE.Vector3(),
-		mat = new THREE.Matrix4(),
-
-		numpoints = segments + 1,
-		theta,
-		smallest,
-
-		tx, ty, tz,
-		i, u;
-
-
-	// expose internals
-	this.tangents = tangents;
-	this.normals = normals;
-	this.binormals = binormals;
-
-	// compute the tangent vectors for each segment on the path
-
-	for ( i = 0; i < numpoints; i ++ ) {
-
-		u = i / ( numpoints - 1 );
-
-		tangents[ i ] = path.getTangentAt( u );
-		tangents[ i ].normalize();
-
-	}
-
-	initialNormal3();
-
-	/*
-	function initialNormal1(lastBinormal) {
-		// fixed start binormal. Has dangers of 0 vectors
-		normals[ 0 ] = new THREE.Vector3();
-		binormals[ 0 ] = new THREE.Vector3();
-		if (lastBinormal===undefined) lastBinormal = new THREE.Vector3( 0, 0, 1 );
-		normals[ 0 ].crossVectors( lastBinormal, tangents[ 0 ] ).normalize();
-		binormals[ 0 ].crossVectors( tangents[ 0 ], normals[ 0 ] ).normalize();
-	}
-
-	function initialNormal2() {
-
-		// This uses the Frenet-Serret formula for deriving binormal
-		var t2 = path.getTangentAt( epsilon );
-
-		normals[ 0 ] = new THREE.Vector3().subVectors( t2, tangents[ 0 ] ).normalize();
-		binormals[ 0 ] = new THREE.Vector3().crossVectors( tangents[ 0 ], normals[ 0 ] );
-
-		normals[ 0 ].crossVectors( binormals[ 0 ], tangents[ 0 ] ).normalize(); // last binormal x tangent
-		binormals[ 0 ].crossVectors( tangents[ 0 ], normals[ 0 ] ).normalize();
-
-	}
-	*/
-
-	function initialNormal3() {
-
-		// select an initial normal vector perpendicular to the first tangent vector,
-		// and in the direction of the smallest tangent xyz component
-
-		normals[ 0 ] = new THREE.Vector3();
-		binormals[ 0 ] = new THREE.Vector3();
-		smallest = Number.MAX_VALUE;
-		tx = Math.abs( tangents[ 0 ].x );
-		ty = Math.abs( tangents[ 0 ].y );
-		tz = Math.abs( tangents[ 0 ].z );
-
-		if ( tx <= smallest ) {
-
-			smallest = tx;
-			normal.set( 1, 0, 0 );
-
-		}
-
-		if ( ty <= smallest ) {
-
-			smallest = ty;
-			normal.set( 0, 1, 0 );
-
-		}
-
-		if ( tz <= smallest ) {
-
-			normal.set( 0, 0, 1 );
-
-		}
-
-		vec.crossVectors( tangents[ 0 ], normal ).normalize();
-
-		normals[ 0 ].crossVectors( tangents[ 0 ], vec );
-		binormals[ 0 ].crossVectors( tangents[ 0 ], normals[ 0 ] );
-
-	}
-
-
-	// compute the slowly-varying normal and binormal vectors for each segment on the path
-
-	for ( i = 1; i < numpoints; i ++ ) {
-
-		normals[ i ] = normals[ i - 1 ].clone();
-
-		binormals[ i ] = binormals[ i - 1 ].clone();
-
-		vec.crossVectors( tangents[ i - 1 ], tangents[ i ] );
-
-		if ( vec.length() > Number.EPSILON ) {
-
-			vec.normalize();
-
-			theta = Math.acos( THREE.Math.clamp( tangents[ i - 1 ].dot( tangents[ i ] ), - 1, 1 ) ); // clamp for floating pt errors
-
-			normals[ i ].applyMatrix4( mat.makeRotationAxis( vec, theta ) );
-
-		}
-
-		binormals[ i ].crossVectors( tangents[ i ], normals[ i ] );
-
-	}
-
-
-	// if the curve is closed, postprocess the vectors so the first and last normal vectors are the same
-
-	if ( closed ) {
-
-		theta = Math.acos( THREE.Math.clamp( normals[ 0 ].dot( normals[ numpoints - 1 ] ), - 1, 1 ) );
-		theta /= ( numpoints - 1 );
-
-		if ( tangents[ 0 ].dot( vec.crossVectors( normals[ 0 ], normals[ numpoints - 1 ] ) ) > 0 ) {
-
-			theta = - theta;
-
-		}
-
-		for ( i = 1; i < numpoints; i ++ ) {
-
-			// twist a little...
-			normals[ i ].applyMatrix4( mat.makeRotationAxis( tangents[ i ], theta * i ) );
-			binormals[ i ].crossVectors( tangents[ i ], normals[ i ] );
-
-		}
-
-	}
-
-};
-
-// File:src/extras/geometries/PolyhedronGeometry.js
-
-/**
- * @author clockworkgeek / https://github.com/clockworkgeek
- * @author timothypratley / https://github.com/timothypratley
- * @author WestLangley / http://github.com/WestLangley
-*/
-
-THREE.PolyhedronGeometry = function ( vertices, indices, radius, detail ) {
-
-	THREE.Geometry.call( this );
-
-	this.type = 'PolyhedronGeometry';
-
-	this.parameters = {
-		vertices: vertices,
-		indices: indices,
-		radius: radius,
-		detail: detail
-	};
-
-	radius = radius || 1;
-	detail = detail || 0;
-
-	var that = this;
-
-	for ( var i = 0, l = vertices.length; i < l; i += 3 ) {
-
-		prepare( new THREE.Vector3( vertices[ i ], vertices[ i + 1 ], vertices[ i + 2 ] ) );
-
-	}
-
-	var p = this.vertices;
-
-	var faces = [];
-
-	for ( var i = 0, j = 0, l = indices.length; i < l; i += 3, j ++ ) {
-
-		var v1 = p[ indices[ i ] ];
-		var v2 = p[ indices[ i + 1 ] ];
-		var v3 = p[ indices[ i + 2 ] ];
-
-		faces[ j ] = new THREE.Face3( v1.index, v2.index, v3.index, [ v1.clone(), v2.clone(), v3.clone() ], undefined, j );
-
-	}
-
-	var centroid = new THREE.Vector3();
-
-	for ( var i = 0, l = faces.length; i < l; i ++ ) {
-
-		subdivide( faces[ i ], detail );
-
-	}
-
-
-	// Handle case when face straddles the seam
-
-	for ( var i = 0, l = this.faceVertexUvs[ 0 ].length; i < l; i ++ ) {
-
-		var uvs = this.faceVertexUvs[ 0 ][ i ];
-
-		var x0 = uvs[ 0 ].x;
-		var x1 = uvs[ 1 ].x;
-		var x2 = uvs[ 2 ].x;
-
-		var max = Math.max( x0, x1, x2 );
-		var min = Math.min( x0, x1, x2 );
-
-		if ( max > 0.9 && min < 0.1 ) {
-
-			// 0.9 is somewhat arbitrary
-
-			if ( x0 < 0.2 ) uvs[ 0 ].x += 1;
-			if ( x1 < 0.2 ) uvs[ 1 ].x += 1;
-			if ( x2 < 0.2 ) uvs[ 2 ].x += 1;
-
-		}
-
-	}
-
-
-	// Apply radius
-
-	for ( var i = 0, l = this.vertices.length; i < l; i ++ ) {
-
-		this.vertices[ i ].multiplyScalar( radius );
-
-	}
-
-
-	// Merge vertices
-
-	this.mergeVertices();
-
-	this.computeFaceNormals();
-
-	this.boundingSphere = new THREE.Sphere( new THREE.Vector3(), radius );
-
-
-	// Project vector onto sphere's surface
-
-	function prepare( vector ) {
-
-		var vertex = vector.normalize().clone();
-		vertex.index = that.vertices.push( vertex ) - 1;
-
-		// Texture coords are equivalent to map coords, calculate angle and convert to fraction of a circle.
-
-		var u = azimuth( vector ) / 2 / Math.PI + 0.5;
-		var v = inclination( vector ) / Math.PI + 0.5;
-		vertex.uv = new THREE.Vector2( u, 1 - v );
-
-		return vertex;
-
-	}
-
-
-	// Approximate a curved face with recursively sub-divided triangles.
-
-	function make( v1, v2, v3, materialIndex ) {
-
-		var face = new THREE.Face3( v1.index, v2.index, v3.index, [ v1.clone(), v2.clone(), v3.clone() ], undefined, materialIndex );
-		that.faces.push( face );
-
-		centroid.copy( v1 ).add( v2 ).add( v3 ).divideScalar( 3 );
-
-		var azi = azimuth( centroid );
-
-		that.faceVertexUvs[ 0 ].push( [
-			correctUV( v1.uv, v1, azi ),
-			correctUV( v2.uv, v2, azi ),
-			correctUV( v3.uv, v3, azi )
-		] );
-
-	}
-
-
-	// Analytically subdivide a face to the required detail level.
-
-	function subdivide( face, detail ) {
-
-		var cols = Math.pow( 2, detail );
-		var a = prepare( that.vertices[ face.a ] );
-		var b = prepare( that.vertices[ face.b ] );
-		var c = prepare( that.vertices[ face.c ] );
-		var v = [];
-
-		var materialIndex = face.materialIndex;
-
-		// Construct all of the vertices for this subdivision.
-
-		for ( var i = 0 ; i <= cols; i ++ ) {
-
-			v[ i ] = [];
-
-			var aj = prepare( a.clone().lerp( c, i / cols ) );
-			var bj = prepare( b.clone().lerp( c, i / cols ) );
-			var rows = cols - i;
-
-			for ( var j = 0; j <= rows; j ++ ) {
-
-				if ( j === 0 && i === cols ) {
-
-					v[ i ][ j ] = aj;
-
-				} else {
-
-					v[ i ][ j ] = prepare( aj.clone().lerp( bj, j / rows ) );
-
-				}
-
-			}
-
-		}
-
-		// Construct all of the faces.
-
-		for ( var i = 0; i < cols ; i ++ ) {
-
-			for ( var j = 0; j < 2 * ( cols - i ) - 1; j ++ ) {
-
-				var k = Math.floor( j / 2 );
-
-				if ( j % 2 === 0 ) {
-
-					make(
-						v[ i ][ k + 1 ],
-						v[ i + 1 ][ k ],
-						v[ i ][ k ],
-						materialIndex
-					);
-
-				} else {
-
-					make(
-						v[ i ][ k + 1 ],
-						v[ i + 1 ][ k + 1 ],
-						v[ i + 1 ][ k ],
-						materialIndex
-					);
-
-				}
-
-			}
-
-		}
-
-	}
-
-
-	// Angle around the Y axis, counter-clockwise when looking from above.
-
-	function azimuth( vector ) {
-
-		return Math.atan2( vector.z, - vector.x );
-
-	}
-
-
-	// Angle above the XZ plane.
-
-	function inclination( vector ) {
-
-		return Math.atan2( - vector.y, Math.sqrt( ( vector.x * vector.x ) + ( vector.z * vector.z ) ) );
-
-	}
-
-
-	// Texture fixing helper. Spheres have some odd behaviours.
-
-	function correctUV( uv, vector, azimuth ) {
-
-		if ( ( azimuth < 0 ) && ( uv.x === 1 ) ) uv = new THREE.Vector2( uv.x - 1, uv.y );
-		if ( ( vector.x === 0 ) && ( vector.z === 0 ) ) uv = new THREE.Vector2( azimuth / 2 / Math.PI + 0.5, uv.y );
-		return uv.clone();
-
-	}
-
-
-};
-
-THREE.PolyhedronGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.PolyhedronGeometry.prototype.constructor = THREE.PolyhedronGeometry;
-
-// File:src/extras/geometries/DodecahedronGeometry.js
-
-/**
- * @author Abe Pazos / https://hamoid.com
- */
-
-THREE.DodecahedronGeometry = function ( radius, detail ) {
-
-	var t = ( 1 + Math.sqrt( 5 ) ) / 2;
-	var r = 1 / t;
-
-	var vertices = [
-
-		// (±1, ±1, ±1)
-		- 1, - 1, - 1,    - 1, - 1,  1,
-		- 1,  1, - 1,    - 1,  1,  1,
-		 1, - 1, - 1,     1, - 1,  1,
-		 1,  1, - 1,     1,  1,  1,
-
-		// (0, ±1/φ, ±φ)
-		 0, - r, - t,     0, - r,  t,
-		 0,  r, - t,     0,  r,  t,
-
-		// (±1/φ, ±φ, 0)
-		- r, - t,  0,    - r,  t,  0,
-		 r, - t,  0,     r,  t,  0,
-
-		// (±φ, 0, ±1/φ)
-		- t,  0, - r,     t,  0, - r,
-		- t,  0,  r,     t,  0,  r
-	];
-
-	var indices = [
-		 3, 11,  7,      3,  7, 15,      3, 15, 13,
-		 7, 19, 17,      7, 17,  6,      7,  6, 15,
-		17,  4,  8,     17,  8, 10,     17, 10,  6,
-		 8,  0, 16,      8, 16,  2,      8,  2, 10,
-		 0, 12,  1,      0,  1, 18,      0, 18, 16,
-		 6, 10,  2,      6,  2, 13,      6, 13, 15,
-		 2, 16, 18,      2, 18,  3,      2,  3, 13,
-		18,  1,  9,     18,  9, 11,     18, 11,  3,
-		 4, 14, 12,      4, 12,  0,      4,  0,  8,
-		11,  9,  5,     11,  5, 19,     11, 19,  7,
-		19,  5, 14,     19, 14,  4,     19,  4, 17,
-		 1, 12, 14,      1, 14,  5,      1,  5,  9
-	];
-
-	THREE.PolyhedronGeometry.call( this, vertices, indices, radius, detail );
-
-	this.type = 'DodecahedronGeometry';
-
-	this.parameters = {
-		radius: radius,
-		detail: detail
-	};
-
-};
-
-THREE.DodecahedronGeometry.prototype = Object.create( THREE.PolyhedronGeometry.prototype );
-THREE.DodecahedronGeometry.prototype.constructor = THREE.DodecahedronGeometry;
-
-// File:src/extras/geometries/IcosahedronGeometry.js
-
-/**
- * @author timothypratley / https://github.com/timothypratley
- */
-
-THREE.IcosahedronGeometry = function ( radius, detail ) {
-
-	var t = ( 1 + Math.sqrt( 5 ) ) / 2;
-
-	var vertices = [
-		- 1,  t,  0,    1,  t,  0,   - 1, - t,  0,    1, - t,  0,
-		 0, - 1,  t,    0,  1,  t,    0, - 1, - t,    0,  1, - t,
-		 t,  0, - 1,    t,  0,  1,   - t,  0, - 1,   - t,  0,  1
-	];
-
-	var indices = [
-		 0, 11,  5,    0,  5,  1,    0,  1,  7,    0,  7, 10,    0, 10, 11,
-		 1,  5,  9,    5, 11,  4,   11, 10,  2,   10,  7,  6,    7,  1,  8,
-		 3,  9,  4,    3,  4,  2,    3,  2,  6,    3,  6,  8,    3,  8,  9,
-		 4,  9,  5,    2,  4, 11,    6,  2, 10,    8,  6,  7,    9,  8,  1
-	];
-
-	THREE.PolyhedronGeometry.call( this, vertices, indices, radius, detail );
-
-	this.type = 'IcosahedronGeometry';
-
-	this.parameters = {
-		radius: radius,
-		detail: detail
-	};
-
-};
-
-THREE.IcosahedronGeometry.prototype = Object.create( THREE.PolyhedronGeometry.prototype );
-THREE.IcosahedronGeometry.prototype.constructor = THREE.IcosahedronGeometry;
-
-// File:src/extras/geometries/OctahedronGeometry.js
-
-/**
- * @author timothypratley / https://github.com/timothypratley
- */
-
-THREE.OctahedronGeometry = function ( radius, detail ) {
-
-	var vertices = [
-		1, 0, 0,   - 1, 0, 0,    0, 1, 0,    0, - 1, 0,    0, 0, 1,    0, 0, - 1
-	];
-
-	var indices = [
-		0, 2, 4,    0, 4, 3,    0, 3, 5,    0, 5, 2,    1, 2, 5,    1, 5, 3,    1, 3, 4,    1, 4, 2
-	];
-
-	THREE.PolyhedronGeometry.call( this, vertices, indices, radius, detail );
-
-	this.type = 'OctahedronGeometry';
-
-	this.parameters = {
-		radius: radius,
-		detail: detail
-	};
-
-};
-
-THREE.OctahedronGeometry.prototype = Object.create( THREE.PolyhedronGeometry.prototype );
-THREE.OctahedronGeometry.prototype.constructor = THREE.OctahedronGeometry;
-
-// File:src/extras/geometries/TetrahedronGeometry.js
-
-/**
- * @author timothypratley / https://github.com/timothypratley
- */
-
-THREE.TetrahedronGeometry = function ( radius, detail ) {
-
-	var vertices = [
-		 1,  1,  1,   - 1, - 1,  1,   - 1,  1, - 1,    1, - 1, - 1
-	];
-
-	var indices = [
-		 2,  1,  0,    0,  3,  2,    1,  3,  0,    2,  3,  1
-	];
-
-	THREE.PolyhedronGeometry.call( this, vertices, indices, radius, detail );
-
-	this.type = 'TetrahedronGeometry';
-
-	this.parameters = {
-		radius: radius,
-		detail: detail
-	};
-
-};
-
-THREE.TetrahedronGeometry.prototype = Object.create( THREE.PolyhedronGeometry.prototype );
-THREE.TetrahedronGeometry.prototype.constructor = THREE.TetrahedronGeometry;
-
-// File:src/extras/geometries/ParametricGeometry.js
-
-/**
- * @author zz85 / https://github.com/zz85
- * Parametric Surfaces Geometry
- * based on the brilliant article by @prideout http://prideout.net/blog/?p=44
- *
- * new THREE.ParametricGeometry( parametricFunction, uSegments, ySegements );
- *
- */
-
-THREE.ParametricGeometry = function ( func, slices, stacks ) {
-
-	THREE.Geometry.call( this );
-
-	this.type = 'ParametricGeometry';
-
-	this.parameters = {
-		func: func,
-		slices: slices,
-		stacks: stacks
-	};
-
-	var verts = this.vertices;
-	var faces = this.faces;
-	var uvs = this.faceVertexUvs[ 0 ];
-
-	var i, j, p;
-	var u, v;
-
-	var sliceCount = slices + 1;
-
-	for ( i = 0; i <= stacks; i ++ ) {
-
-		v = i / stacks;
-
-		for ( j = 0; j <= slices; j ++ ) {
-
-			u = j / slices;
-
-			p = func( u, v );
-			verts.push( p );
-
-		}
-
-	}
-
-	var a, b, c, d;
-	var uva, uvb, uvc, uvd;
-
-	for ( i = 0; i < stacks; i ++ ) {
-
-		for ( j = 0; j < slices; j ++ ) {
-
-			a = i * sliceCount + j;
-			b = i * sliceCount + j + 1;
-			c = ( i + 1 ) * sliceCount + j + 1;
-			d = ( i + 1 ) * sliceCount + j;
-
-			uva = new THREE.Vector2( j / slices, i / stacks );
-			uvb = new THREE.Vector2( ( j + 1 ) / slices, i / stacks );
-			uvc = new THREE.Vector2( ( j + 1 ) / slices, ( i + 1 ) / stacks );
-			uvd = new THREE.Vector2( j / slices, ( i + 1 ) / stacks );
-
-			faces.push( new THREE.Face3( a, b, d ) );
-			uvs.push( [ uva, uvb, uvd ] );
-
-			faces.push( new THREE.Face3( b, c, d ) );
-			uvs.push( [ uvb.clone(), uvc, uvd.clone() ] );
-
-		}
-
-	}
-
-	// console.log(this);
-
-	// magic bullet
-	// var diff = this.mergeVertices();
-	// console.log('removed ', diff, ' vertices by merging');
-
-	this.computeFaceNormals();
-	this.computeVertexNormals();
-
-};
-
-THREE.ParametricGeometry.prototype = Object.create( THREE.Geometry.prototype );
-THREE.ParametricGeometry.prototype.constructor = THREE.ParametricGeometry;
-
-// File:src/extras/geometries/WireframeGeometry.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.WireframeGeometry = function ( geometry ) {
-
-	THREE.BufferGeometry.call( this );
-
-	var edge = [ 0, 0 ], hash = {};
-
-	function sortFunction( a, b ) {
-
-		return a - b;
-
-	}
-
-	var keys = [ 'a', 'b', 'c' ];
-
-	if ( geometry instanceof THREE.Geometry ) {
-
-		var vertices = geometry.vertices;
-		var faces = geometry.faces;
-		var numEdges = 0;
-
-		// allocate maximal size
-		var edges = new Uint32Array( 6 * faces.length );
-
-		for ( var i = 0, l = faces.length; i < l; i ++ ) {
-
-			var face = faces[ i ];
-
-			for ( var j = 0; j < 3; j ++ ) {
-
-				edge[ 0 ] = face[ keys[ j ] ];
-				edge[ 1 ] = face[ keys[ ( j + 1 ) % 3 ] ];
-				edge.sort( sortFunction );
-
-				var key = edge.toString();
-
-				if ( hash[ key ] === undefined ) {
-
-					edges[ 2 * numEdges ] = edge[ 0 ];
-					edges[ 2 * numEdges + 1 ] = edge[ 1 ];
-					hash[ key ] = true;
-					numEdges ++;
-
-				}
-
-			}
-
-		}
-
-		var coords = new Float32Array( numEdges * 2 * 3 );
-
-		for ( var i = 0, l = numEdges; i < l; i ++ ) {
-
-			for ( var j = 0; j < 2; j ++ ) {
-
-				var vertex = vertices[ edges [ 2 * i + j ] ];
-
-				var index = 6 * i + 3 * j;
-				coords[ index + 0 ] = vertex.x;
-				coords[ index + 1 ] = vertex.y;
-				coords[ index + 2 ] = vertex.z;
-
-			}
-
-		}
-
-		this.addAttribute( 'position', new THREE.BufferAttribute( coords, 3 ) );
-
-	} else if ( geometry instanceof THREE.BufferGeometry ) {
-
-		if ( geometry.index !== null ) {
-
-			// Indexed BufferGeometry
-
-			var indices = geometry.index.array;
-			var vertices = geometry.attributes.position;
-			var groups = geometry.groups;
-			var numEdges = 0;
-
-			if ( groups.length === 0 ) {
-
-				geometry.addGroup( 0, indices.length );
-
-			}
-
-			// allocate maximal size
-			var edges = new Uint32Array( 2 * indices.length );
-
-			for ( var o = 0, ol = groups.length; o < ol; ++ o ) {
-
-				var group = groups[ o ];
-
-				var start = group.start;
-				var count = group.count;
-
-				for ( var i = start, il = start + count; i < il; i += 3 ) {
-
-					for ( var j = 0; j < 3; j ++ ) {
-
-						edge[ 0 ] = indices[ i + j ];
-						edge[ 1 ] = indices[ i + ( j + 1 ) % 3 ];
-						edge.sort( sortFunction );
-
-						var key = edge.toString();
-
-						if ( hash[ key ] === undefined ) {
-
-							edges[ 2 * numEdges ] = edge[ 0 ];
-							edges[ 2 * numEdges + 1 ] = edge[ 1 ];
-							hash[ key ] = true;
-							numEdges ++;
-
-						}
-
-					}
-
-				}
-
-			}
-
-			var coords = new Float32Array( numEdges * 2 * 3 );
-
-			for ( var i = 0, l = numEdges; i < l; i ++ ) {
-
-				for ( var j = 0; j < 2; j ++ ) {
-
-					var index = 6 * i + 3 * j;
-					var index2 = edges[ 2 * i + j ];
-
-					coords[ index + 0 ] = vertices.getX( index2 );
-					coords[ index + 1 ] = vertices.getY( index2 );
-					coords[ index + 2 ] = vertices.getZ( index2 );
-
-				}
-
-			}
-
-			this.addAttribute( 'position', new THREE.BufferAttribute( coords, 3 ) );
-
-		} else {
-
-			// non-indexed BufferGeometry
-
-			var vertices = geometry.attributes.position.array;
-			var numEdges = vertices.length / 3;
-			var numTris = numEdges / 3;
-
-			var coords = new Float32Array( numEdges * 2 * 3 );
-
-			for ( var i = 0, l = numTris; i < l; i ++ ) {
-
-				for ( var j = 0; j < 3; j ++ ) {
-
-					var index = 18 * i + 6 * j;
-
-					var index1 = 9 * i + 3 * j;
-					coords[ index + 0 ] = vertices[ index1 ];
-					coords[ index + 1 ] = vertices[ index1 + 1 ];
-					coords[ index + 2 ] = vertices[ index1 + 2 ];
-
-					var index2 = 9 * i + 3 * ( ( j + 1 ) % 3 );
-					coords[ index + 3 ] = vertices[ index2 ];
-					coords[ index + 4 ] = vertices[ index2 + 1 ];
-					coords[ index + 5 ] = vertices[ index2 + 2 ];
-
-				}
-
-			}
-
-			this.addAttribute( 'position', new THREE.BufferAttribute( coords, 3 ) );
-
-		}
-
-	}
-
-};
-
-THREE.WireframeGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
-THREE.WireframeGeometry.prototype.constructor = THREE.WireframeGeometry;
-
-// File:src/extras/helpers/AxisHelper.js
-
-/**
- * @author sroucheray / http://sroucheray.org/
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.AxisHelper = function ( size ) {
-
-	size = size || 1;
-
-	var vertices = new Float32Array( [
-		0, 0, 0,  size, 0, 0,
-		0, 0, 0,  0, size, 0,
-		0, 0, 0,  0, 0, size
-	] );
-
-	var colors = new Float32Array( [
-		1, 0, 0,  1, 0.6, 0,
-		0, 1, 0,  0.6, 1, 0,
-		0, 0, 1,  0, 0.6, 1
-	] );
-
-	var geometry = new THREE.BufferGeometry();
-	geometry.addAttribute( 'position', new THREE.BufferAttribute( vertices, 3 ) );
-	geometry.addAttribute( 'color', new THREE.BufferAttribute( colors, 3 ) );
-
-	var material = new THREE.LineBasicMaterial( { vertexColors: THREE.VertexColors } );
-
-	THREE.LineSegments.call( this, geometry, material );
-
-};
-
-THREE.AxisHelper.prototype = Object.create( THREE.LineSegments.prototype );
-THREE.AxisHelper.prototype.constructor = THREE.AxisHelper;
-
-// File:src/extras/helpers/ArrowHelper.js
-
-/**
- * @author WestLangley / http://github.com/WestLangley
- * @author zz85 / http://github.com/zz85
- * @author bhouston / http://clara.io
- *
- * Creates an arrow for visualizing directions
- *
- * Parameters:
- *  dir - Vector3
- *  origin - Vector3
- *  length - Number
- *  color - color in hex value
- *  headLength - Number
- *  headWidth - Number
- */
-
-THREE.ArrowHelper = ( function () {
-
-	var lineGeometry = new THREE.Geometry();
-	lineGeometry.vertices.push( new THREE.Vector3( 0, 0, 0 ), new THREE.Vector3( 0, 1, 0 ) );
-
-	var coneGeometry = new THREE.CylinderGeometry( 0, 0.5, 1, 5, 1 );
-	coneGeometry.translate( 0, - 0.5, 0 );
-
-	return function ArrowHelper( dir, origin, length, color, headLength, headWidth ) {
-
-		// dir is assumed to be normalized
-
-		THREE.Object3D.call( this );
-
-		if ( color === undefined ) color = 0xffff00;
-		if ( length === undefined ) length = 1;
-		if ( headLength === undefined ) headLength = 0.2 * length;
-		if ( headWidth === undefined ) headWidth = 0.2 * headLength;
-
-		this.position.copy( origin );
-		
-		this.line = new THREE.Line( lineGeometry, new THREE.LineBasicMaterial( { color: color } ) );
-		this.line.matrixAutoUpdate = false;
-		this.add( this.line );
-
-		this.cone = new THREE.Mesh( coneGeometry, new THREE.MeshBasicMaterial( { color: color } ) );
-		this.cone.matrixAutoUpdate = false;
-		this.add( this.cone );
-
-		this.setDirection( dir );
-		this.setLength( length, headLength, headWidth );
-
-	}
-
-}() );
-
-THREE.ArrowHelper.prototype = Object.create( THREE.Object3D.prototype );
-THREE.ArrowHelper.prototype.constructor = THREE.ArrowHelper;
-
-THREE.ArrowHelper.prototype.setDirection = ( function () {
-
-	var axis = new THREE.Vector3();
-	var radians;
-
-	return function setDirection( dir ) {
-
-		// dir is assumed to be normalized
-
-		if ( dir.y > 0.99999 ) {
-
-			this.quaternion.set( 0, 0, 0, 1 );
-
-		} else if ( dir.y < - 0.99999 ) {
-
-			this.quaternion.set( 1, 0, 0, 0 );
-
-		} else {
-
-			axis.set( dir.z, 0, - dir.x ).normalize();
-
-			radians = Math.acos( dir.y );
-
-			this.quaternion.setFromAxisAngle( axis, radians );
-
-		}
-
-	};
-
-}() );
-
-THREE.ArrowHelper.prototype.setLength = function ( length, headLength, headWidth ) {
-
-	if ( headLength === undefined ) headLength = 0.2 * length;
-	if ( headWidth === undefined ) headWidth = 0.2 * headLength;
-
-	this.line.scale.set( 1, Math.max( 0, length - headLength ), 1 );
-	this.line.updateMatrix();
-
-	this.cone.scale.set( headWidth, headLength, headWidth );
-	this.cone.position.y = length;
-	this.cone.updateMatrix();
-
-};
-
-THREE.ArrowHelper.prototype.setColor = function ( color ) {
-
-	this.line.material.color.set( color );
-	this.cone.material.color.set( color );
-
-};
-
-// File:src/extras/helpers/BoxHelper.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.BoxHelper = function ( object ) {
-
-	var indices = new Uint16Array( [ 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 ] );
-	var positions = new Float32Array( 8 * 3 );
-
-	var geometry = new THREE.BufferGeometry();
-	geometry.setIndex( new THREE.BufferAttribute( indices, 1 ) );
-	geometry.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
-
-	THREE.LineSegments.call( this, geometry, new THREE.LineBasicMaterial( { color: 0xffff00 } ) );
-
-	if ( object !== undefined ) {
-
-		this.update( object );
-
-	}
-
-};
-
-THREE.BoxHelper.prototype = Object.create( THREE.LineSegments.prototype );
-THREE.BoxHelper.prototype.constructor = THREE.BoxHelper;
-
-THREE.BoxHelper.prototype.update = ( function () {
-
-	var box = new THREE.Box3();
-
-	return function ( object ) {
-
-		if ( object instanceof THREE.Box3 ) {
-
-			box.copy( object );
-
-		} else {
-
-			box.setFromObject( object );
-
-		}
-
-		if ( box.isEmpty() ) return;
-
-		var min = box.min;
-		var max = box.max;
-
-		/*
-		  5____4
-		1/___0/|
-		| 6__|_7
-		2/___3/
-
-		0: max.x, max.y, max.z
-		1: min.x, max.y, max.z
-		2: min.x, min.y, max.z
-		3: max.x, min.y, max.z
-		4: max.x, max.y, min.z
-		5: min.x, max.y, min.z
-		6: min.x, min.y, min.z
-		7: max.x, min.y, min.z
-		*/
-
-		var position = this.geometry.attributes.position;
-		var array = position.array;
-
-		array[  0 ] = max.x; array[  1 ] = max.y; array[  2 ] = max.z;
-		array[  3 ] = min.x; array[  4 ] = max.y; array[  5 ] = max.z;
-		array[  6 ] = min.x; array[  7 ] = min.y; array[  8 ] = max.z;
-		array[  9 ] = max.x; array[ 10 ] = min.y; array[ 11 ] = max.z;
-		array[ 12 ] = max.x; array[ 13 ] = max.y; array[ 14 ] = min.z;
-		array[ 15 ] = min.x; array[ 16 ] = max.y; array[ 17 ] = min.z;
-		array[ 18 ] = min.x; array[ 19 ] = min.y; array[ 20 ] = min.z;
-		array[ 21 ] = max.x; array[ 22 ] = min.y; array[ 23 ] = min.z;
-
-		position.needsUpdate = true;
-
-		this.geometry.computeBoundingSphere();
-
-	};
-
-} )();
-
-// File:src/extras/helpers/BoundingBoxHelper.js
-
-/**
- * @author WestLangley / http://github.com/WestLangley
- */
-
-// a helper to show the world-axis-aligned bounding box for an object
-
-THREE.BoundingBoxHelper = function ( object, hex ) {
-
-	var color = ( hex !== undefined ) ? hex : 0x888888;
-
-	this.object = object;
-
-	this.box = new THREE.Box3();
-
-	THREE.Mesh.call( this, new THREE.BoxGeometry( 1, 1, 1 ), new THREE.MeshBasicMaterial( { color: color, wireframe: true } ) );
-
-};
-
-THREE.BoundingBoxHelper.prototype = Object.create( THREE.Mesh.prototype );
-THREE.BoundingBoxHelper.prototype.constructor = THREE.BoundingBoxHelper;
-
-THREE.BoundingBoxHelper.prototype.update = function () {
-
-	this.box.setFromObject( this.object );
-
-	this.box.size( this.scale );
-
-	this.box.center( this.position );
-
-};
-
-// File:src/extras/helpers/CameraHelper.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- *
- *	- shows frustum, line of sight and up of the camera
- *	- suitable for fast updates
- * 	- based on frustum visualization in lightgl.js shadowmap example
- *		http://evanw.github.com/lightgl.js/tests/shadowmap.html
- */
-
-THREE.CameraHelper = function ( camera ) {
-
-	var geometry = new THREE.Geometry();
-	var material = new THREE.LineBasicMaterial( { color: 0xffffff, vertexColors: THREE.FaceColors } );
-
-	var pointMap = {};
-
-	// colors
-
-	var hexFrustum = 0xffaa00;
-	var hexCone = 0xff0000;
-	var hexUp = 0x00aaff;
-	var hexTarget = 0xffffff;
-	var hexCross = 0x333333;
-
-	// near
-
-	addLine( "n1", "n2", hexFrustum );
-	addLine( "n2", "n4", hexFrustum );
-	addLine( "n4", "n3", hexFrustum );
-	addLine( "n3", "n1", hexFrustum );
-
-	// far
-
-	addLine( "f1", "f2", hexFrustum );
-	addLine( "f2", "f4", hexFrustum );
-	addLine( "f4", "f3", hexFrustum );
-	addLine( "f3", "f1", hexFrustum );
-
-	// sides
-
-	addLine( "n1", "f1", hexFrustum );
-	addLine( "n2", "f2", hexFrustum );
-	addLine( "n3", "f3", hexFrustum );
-	addLine( "n4", "f4", hexFrustum );
-
-	// cone
-
-	addLine( "p", "n1", hexCone );
-	addLine( "p", "n2", hexCone );
-	addLine( "p", "n3", hexCone );
-	addLine( "p", "n4", hexCone );
-
-	// up
-
-	addLine( "u1", "u2", hexUp );
-	addLine( "u2", "u3", hexUp );
-	addLine( "u3", "u1", hexUp );
-
-	// target
-
-	addLine( "c", "t", hexTarget );
-	addLine( "p", "c", hexCross );
-
-	// cross
-
-	addLine( "cn1", "cn2", hexCross );
-	addLine( "cn3", "cn4", hexCross );
-
-	addLine( "cf1", "cf2", hexCross );
-	addLine( "cf3", "cf4", hexCross );
-
-	function addLine( a, b, hex ) {
-
-		addPoint( a, hex );
-		addPoint( b, hex );
-
-	}
-
-	function addPoint( id, hex ) {
-
-		geometry.vertices.push( new THREE.Vector3() );
-		geometry.colors.push( new THREE.Color( hex ) );
-
-		if ( pointMap[ id ] === undefined ) {
-
-			pointMap[ id ] = [];
-
-		}
-
-		pointMap[ id ].push( geometry.vertices.length - 1 );
-
-	}
-
-	THREE.LineSegments.call( this, geometry, material );
-
-	this.camera = camera;
-	this.camera.updateProjectionMatrix();
-
-	this.matrix = camera.matrixWorld;
-	this.matrixAutoUpdate = false;
-
-	this.pointMap = pointMap;
-
-	this.update();
-
-};
-
-THREE.CameraHelper.prototype = Object.create( THREE.LineSegments.prototype );
-THREE.CameraHelper.prototype.constructor = THREE.CameraHelper;
-
-THREE.CameraHelper.prototype.update = function () {
-
-	var geometry, pointMap;
-
-	var vector = new THREE.Vector3();
-	var camera = new THREE.Camera();
-
-	function setPoint( point, x, y, z ) {
-
-		vector.set( x, y, z ).unproject( camera );
-
-		var points = pointMap[ point ];
-
-		if ( points !== undefined ) {
-
-			for ( var i = 0, il = points.length; i < il; i ++ ) {
-
-				geometry.vertices[ points[ i ] ].copy( vector );
-
-			}
-
-		}
-
-	}
-
-	return function () {
-
-		geometry = this.geometry;
-		pointMap = this.pointMap;
-
-		var w = 1, h = 1;
-
-		// we need just camera projection matrix
-		// world matrix must be identity
-
-		camera.projectionMatrix.copy( this.camera.projectionMatrix );
-
-		// center / target
-
-		setPoint( "c", 0, 0, - 1 );
-		setPoint( "t", 0, 0,  1 );
-
-		// near
-
-		setPoint( "n1", - w, - h, - 1 );
-		setPoint( "n2",   w, - h, - 1 );
-		setPoint( "n3", - w,   h, - 1 );
-		setPoint( "n4",   w,   h, - 1 );
-
-		// far
-
-		setPoint( "f1", - w, - h, 1 );
-		setPoint( "f2",   w, - h, 1 );
-		setPoint( "f3", - w,   h, 1 );
-		setPoint( "f4",   w,   h, 1 );
-
-		// up
-
-		setPoint( "u1",   w * 0.7, h * 1.1, - 1 );
-		setPoint( "u2", - w * 0.7, h * 1.1, - 1 );
-		setPoint( "u3",         0, h * 2,   - 1 );
-
-		// cross
-
-		setPoint( "cf1", - w,   0, 1 );
-		setPoint( "cf2",   w,   0, 1 );
-		setPoint( "cf3",   0, - h, 1 );
-		setPoint( "cf4",   0,   h, 1 );
-
-		setPoint( "cn1", - w,   0, - 1 );
-		setPoint( "cn2",   w,   0, - 1 );
-		setPoint( "cn3",   0, - h, - 1 );
-		setPoint( "cn4",   0,   h, - 1 );
-
-		geometry.verticesNeedUpdate = true;
-
-	};
-
-}();
-
-// File:src/extras/helpers/DirectionalLightHelper.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- * @author mrdoob / http://mrdoob.com/
- * @author WestLangley / http://github.com/WestLangley
- */
-
-THREE.DirectionalLightHelper = function ( light, size ) {
-
-	THREE.Object3D.call( this );
-
-	this.light = light;
-	this.light.updateMatrixWorld();
-
-	this.matrix = light.matrixWorld;
-	this.matrixAutoUpdate = false;
-
-	size = size || 1;
-
-	var geometry = new THREE.Geometry();
-	geometry.vertices.push(
-		new THREE.Vector3( - size,   size, 0 ),
-		new THREE.Vector3(   size,   size, 0 ),
-		new THREE.Vector3(   size, - size, 0 ),
-		new THREE.Vector3( - size, - size, 0 ),
-		new THREE.Vector3( - size,   size, 0 )
-	);
-
-	var material = new THREE.LineBasicMaterial( { fog: false } );
-	material.color.copy( this.light.color ).multiplyScalar( this.light.intensity );
-
-	this.lightPlane = new THREE.Line( geometry, material );
-	this.add( this.lightPlane );
-
-	geometry = new THREE.Geometry();
-	geometry.vertices.push(
-		new THREE.Vector3(),
-		new THREE.Vector3()
-	);
-
-	material = new THREE.LineBasicMaterial( { fog: false } );
-	material.color.copy( this.light.color ).multiplyScalar( this.light.intensity );
-
-	this.targetLine = new THREE.Line( geometry, material );
-	this.add( this.targetLine );
-
-	this.update();
-
-};
-
-THREE.DirectionalLightHelper.prototype = Object.create( THREE.Object3D.prototype );
-THREE.DirectionalLightHelper.prototype.constructor = THREE.DirectionalLightHelper;
-
-THREE.DirectionalLightHelper.prototype.dispose = function () {
-
-	this.lightPlane.geometry.dispose();
-	this.lightPlane.material.dispose();
-	this.targetLine.geometry.dispose();
-	this.targetLine.material.dispose();
-
-};
-
-THREE.DirectionalLightHelper.prototype.update = function () {
-
-	var v1 = new THREE.Vector3();
-	var v2 = new THREE.Vector3();
-	var v3 = new THREE.Vector3();
-
-	return function () {
-
-		v1.setFromMatrixPosition( this.light.matrixWorld );
-		v2.setFromMatrixPosition( this.light.target.matrixWorld );
-		v3.subVectors( v2, v1 );
-
-		this.lightPlane.lookAt( v3 );
-		this.lightPlane.material.color.copy( this.light.color ).multiplyScalar( this.light.intensity );
-
-		this.targetLine.geometry.vertices[ 1 ].copy( v3 );
-		this.targetLine.geometry.verticesNeedUpdate = true;
-		this.targetLine.material.color.copy( this.lightPlane.material.color );
-
-	};
-
-}();
-
-// File:src/extras/helpers/EdgesHelper.js
-
-/**
- * @author WestLangley / http://github.com/WestLangley
- * @param object THREE.Mesh whose geometry will be used
- * @param hex line color
- * @param thresholdAngle the minimum angle (in degrees),
- * between the face normals of adjacent faces,
- * that is required to render an edge. A value of 10 means
- * an edge is only rendered if the angle is at least 10 degrees.
- */
-
-THREE.EdgesHelper = function ( object, hex, thresholdAngle ) {
-
-	var color = ( hex !== undefined ) ? hex : 0xffffff;
-
-	THREE.LineSegments.call( this, new THREE.EdgesGeometry( object.geometry, thresholdAngle ), new THREE.LineBasicMaterial( { color: color } ) );
-
-	this.matrix = object.matrixWorld;
-	this.matrixAutoUpdate = false;
-
-};
-
-THREE.EdgesHelper.prototype = Object.create( THREE.LineSegments.prototype );
-THREE.EdgesHelper.prototype.constructor = THREE.EdgesHelper;
-
-// File:src/extras/helpers/FaceNormalsHelper.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author WestLangley / http://github.com/WestLangley
-*/
-
-THREE.FaceNormalsHelper = function ( object, size, hex, linewidth ) {
-
-	// FaceNormalsHelper only supports THREE.Geometry
-
-	this.object = object;
-
-	this.size = ( size !== undefined ) ? size : 1;
-
-	var color = ( hex !== undefined ) ? hex : 0xffff00;
-
-	var width = ( linewidth !== undefined ) ? linewidth : 1;
-
-	//
-
-	var nNormals = 0;
-
-	var objGeometry = this.object.geometry;
-
-	if ( objGeometry instanceof THREE.Geometry ) {
-
-		nNormals = objGeometry.faces.length;
-
-	} else {
-
-		console.warn( 'THREE.FaceNormalsHelper: only THREE.Geometry is supported. Use THREE.VertexNormalsHelper, instead.' );
-
-	}
-
-	//
-
-	var geometry = new THREE.BufferGeometry();
-
-	var positions = new THREE.Float32Attribute( nNormals * 2 * 3, 3 );
-
-	geometry.addAttribute( 'position', positions );
-
-	THREE.LineSegments.call( this, geometry, new THREE.LineBasicMaterial( { color: color, linewidth: width } ) );
-
-	//
-
-	this.matrixAutoUpdate = false;
-	this.update();
-
-};
-
-THREE.FaceNormalsHelper.prototype = Object.create( THREE.LineSegments.prototype );
-THREE.FaceNormalsHelper.prototype.constructor = THREE.FaceNormalsHelper;
-
-THREE.FaceNormalsHelper.prototype.update = ( function () {
-
-	var v1 = new THREE.Vector3();
-	var v2 = new THREE.Vector3();
-	var normalMatrix = new THREE.Matrix3();
-
-	return function update() {
-
-		this.object.updateMatrixWorld( true );
-
-		normalMatrix.getNormalMatrix( this.object.matrixWorld );
-
-		var matrixWorld = this.object.matrixWorld;
-
-		var position = this.geometry.attributes.position;
-
-		//
-
-		var objGeometry = this.object.geometry;
-
-		var vertices = objGeometry.vertices;
-
-		var faces = objGeometry.faces;
-
-		var idx = 0;
-
-		for ( var i = 0, l = faces.length; i < l; i ++ ) {
-
-			var face = faces[ i ];
-
-			var normal = face.normal;
-
-			v1.copy( vertices[ face.a ] )
-				.add( vertices[ face.b ] )
-				.add( vertices[ face.c ] )
-				.divideScalar( 3 )
-				.applyMatrix4( matrixWorld );
-
-			v2.copy( normal ).applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 );
-
-			position.setXYZ( idx, v1.x, v1.y, v1.z );
-
-			idx = idx + 1;
-
-			position.setXYZ( idx, v2.x, v2.y, v2.z );
-
-			idx = idx + 1;
-
-		}
-
-		position.needsUpdate = true;
-
-		return this;
-
-	}
-
-}() );
-
-// File:src/extras/helpers/GridHelper.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.GridHelper = function ( size, step ) {
-
-	var geometry = new THREE.Geometry();
-	var material = new THREE.LineBasicMaterial( { vertexColors: THREE.VertexColors } );
-
-	this.color1 = new THREE.Color( 0x444444 );
-	this.color2 = new THREE.Color( 0x888888 );
-
-	for ( var i = - size; i <= size; i += step ) {
-
-		geometry.vertices.push(
-			new THREE.Vector3( - size, 0, i ), new THREE.Vector3( size, 0, i ),
-			new THREE.Vector3( i, 0, - size ), new THREE.Vector3( i, 0, size )
-		);
-
-		var color = i === 0 ? this.color1 : this.color2;
-
-		geometry.colors.push( color, color, color, color );
-
-	}
-
-	THREE.LineSegments.call( this, geometry, material );
-
-};
-
-THREE.GridHelper.prototype = Object.create( THREE.LineSegments.prototype );
-THREE.GridHelper.prototype.constructor = THREE.GridHelper;
-
-THREE.GridHelper.prototype.setColors = function( colorCenterLine, colorGrid ) {
-
-	this.color1.set( colorCenterLine );
-	this.color2.set( colorGrid );
-
-	this.geometry.colorsNeedUpdate = true;
-
-};
-
-// File:src/extras/helpers/HemisphereLightHelper.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.HemisphereLightHelper = function ( light, sphereSize ) {
-
-	THREE.Object3D.call( this );
-
-	this.light = light;
-	this.light.updateMatrixWorld();
-
-	this.matrix = light.matrixWorld;
-	this.matrixAutoUpdate = false;
-
-	this.colors = [ new THREE.Color(), new THREE.Color() ];
-
-	var geometry = new THREE.SphereGeometry( sphereSize, 4, 2 );
-	geometry.rotateX( - Math.PI / 2 );
-
-	for ( var i = 0, il = 8; i < il; i ++ ) {
-
-		geometry.faces[ i ].color = this.colors[ i < 4 ? 0 : 1 ];
-
-	}
-
-	var material = new THREE.MeshBasicMaterial( { vertexColors: THREE.FaceColors, wireframe: true } );
-
-	this.lightSphere = new THREE.Mesh( geometry, material );
-	this.add( this.lightSphere );
-
-	this.update();
-
-};
-
-THREE.HemisphereLightHelper.prototype = Object.create( THREE.Object3D.prototype );
-THREE.HemisphereLightHelper.prototype.constructor = THREE.HemisphereLightHelper;
-
-THREE.HemisphereLightHelper.prototype.dispose = function () {
-
-	this.lightSphere.geometry.dispose();
-	this.lightSphere.material.dispose();
-
-};
-
-THREE.HemisphereLightHelper.prototype.update = function () {
-
-	var vector = new THREE.Vector3();
-
-	return function () {
-
-		this.colors[ 0 ].copy( this.light.color ).multiplyScalar( this.light.intensity );
-		this.colors[ 1 ].copy( this.light.groundColor ).multiplyScalar( this.light.intensity );
-
-		this.lightSphere.lookAt( vector.setFromMatrixPosition( this.light.matrixWorld ).negate() );
-		this.lightSphere.geometry.colorsNeedUpdate = true;
-
-	}
-
-}();
-
-// File:src/extras/helpers/PointLightHelper.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.PointLightHelper = function ( light, sphereSize ) {
-
-	this.light = light;
-	this.light.updateMatrixWorld();
-
-	var geometry = new THREE.SphereGeometry( sphereSize, 4, 2 );
-	var material = new THREE.MeshBasicMaterial( { wireframe: true, fog: false } );
-	material.color.copy( this.light.color ).multiplyScalar( this.light.intensity );
-
-	THREE.Mesh.call( this, geometry, material );
-
-	this.matrix = this.light.matrixWorld;
-	this.matrixAutoUpdate = false;
-
-	/*
-	var distanceGeometry = new THREE.IcosahedronGeometry( 1, 2 );
-	var distanceMaterial = new THREE.MeshBasicMaterial( { color: hexColor, fog: false, wireframe: true, opacity: 0.1, transparent: true } );
-
-	this.lightSphere = new THREE.Mesh( bulbGeometry, bulbMaterial );
-	this.lightDistance = new THREE.Mesh( distanceGeometry, distanceMaterial );
-
-	var d = light.distance;
-
-	if ( d === 0.0 ) {
-
-		this.lightDistance.visible = false;
-
-	} else {
-
-		this.lightDistance.scale.set( d, d, d );
-
-	}
-
-	this.add( this.lightDistance );
-	*/
-
-};
-
-THREE.PointLightHelper.prototype = Object.create( THREE.Mesh.prototype );
-THREE.PointLightHelper.prototype.constructor = THREE.PointLightHelper;
-
-THREE.PointLightHelper.prototype.dispose = function () {
-
-	this.geometry.dispose();
-	this.material.dispose();
-
-};
-
-THREE.PointLightHelper.prototype.update = function () {
-
-	this.material.color.copy( this.light.color ).multiplyScalar( this.light.intensity );
-
-	/*
-	var d = this.light.distance;
-
-	if ( d === 0.0 ) {
-
-		this.lightDistance.visible = false;
-
-	} else {
-
-		this.lightDistance.visible = true;
-		this.lightDistance.scale.set( d, d, d );
-
-	}
-	*/
-
-};
-
-// File:src/extras/helpers/SkeletonHelper.js
-
-/**
- * @author Sean Griffin / http://twitter.com/sgrif
- * @author Michael Guerrero / http://realitymeltdown.com
- * @author mrdoob / http://mrdoob.com/
- * @author ikerr / http://verold.com
- */
-
-THREE.SkeletonHelper = function ( object ) {
-
-	this.bones = this.getBoneList( object );
-
-	var geometry = new THREE.Geometry();
-
-	for ( var i = 0; i < this.bones.length; i ++ ) {
-
-		var bone = this.bones[ i ];
-
-		if ( bone.parent instanceof THREE.Bone ) {
-
-			geometry.vertices.push( new THREE.Vector3() );
-			geometry.vertices.push( new THREE.Vector3() );
-			geometry.colors.push( new THREE.Color( 0, 0, 1 ) );
-			geometry.colors.push( new THREE.Color( 0, 1, 0 ) );
-
-		}
-
-	}
-
-	geometry.dynamic = true;
-
-	var material = new THREE.LineBasicMaterial( { vertexColors: THREE.VertexColors, depthTest: false, depthWrite: false, transparent: true } );
-
-	THREE.LineSegments.call( this, geometry, material );
-
-	this.root = object;
-
-	this.matrix = object.matrixWorld;
-	this.matrixAutoUpdate = false;
-
-	this.update();
-
-};
-
-
-THREE.SkeletonHelper.prototype = Object.create( THREE.LineSegments.prototype );
-THREE.SkeletonHelper.prototype.constructor = THREE.SkeletonHelper;
-
-THREE.SkeletonHelper.prototype.getBoneList = function( object ) {
-
-	var boneList = [];
-
-	if ( object instanceof THREE.Bone ) {
-
-		boneList.push( object );
-
-	}
-
-	for ( var i = 0; i < object.children.length; i ++ ) {
-
-		boneList.push.apply( boneList, this.getBoneList( object.children[ i ] ) );
-
-	}
-
-	return boneList;
-
-};
-
-THREE.SkeletonHelper.prototype.update = function () {
-
-	var geometry = this.geometry;
-
-	var matrixWorldInv = new THREE.Matrix4().getInverse( this.root.matrixWorld );
-
-	var boneMatrix = new THREE.Matrix4();
-
-	var j = 0;
-
-	for ( var i = 0; i < this.bones.length; i ++ ) {
-
-		var bone = this.bones[ i ];
-
-		if ( bone.parent instanceof THREE.Bone ) {
-
-			boneMatrix.multiplyMatrices( matrixWorldInv, bone.matrixWorld );
-			geometry.vertices[ j ].setFromMatrixPosition( boneMatrix );
-
-			boneMatrix.multiplyMatrices( matrixWorldInv, bone.parent.matrixWorld );
-			geometry.vertices[ j + 1 ].setFromMatrixPosition( boneMatrix );
-
-			j += 2;
-
-		}
-
-	}
-
-	geometry.verticesNeedUpdate = true;
-
-	geometry.computeBoundingSphere();
-
-};
-
-// File:src/extras/helpers/SpotLightHelper.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- * @author mrdoob / http://mrdoob.com/
- * @author WestLangley / http://github.com/WestLangley
-*/
-
-THREE.SpotLightHelper = function ( light ) {
-
-	THREE.Object3D.call( this );
-
-	this.light = light;
-	this.light.updateMatrixWorld();
-
-	this.matrix = light.matrixWorld;
-	this.matrixAutoUpdate = false;
-
-	var geometry = new THREE.BufferGeometry();
-
-	var positions = [
-		0, 0, 0,   0,   0,   1,
-		0, 0, 0,   1,   0,   1,
-		0, 0, 0, - 1,   0,   1,
-		0, 0, 0,   0,   1,   1,
-		0, 0, 0,   0, - 1,   1
-	];
-
-	for ( var i = 0, j = 1, l = 32; i < l; i ++, j ++ ) {
-
-		var p1 = ( i / l ) * Math.PI * 2;
-		var p2 = ( j / l ) * Math.PI * 2;
-
-		positions.push(
-			Math.cos( p1 ), Math.sin( p1 ), 1,
-			Math.cos( p2 ), Math.sin( p2 ), 1
-		);
-
-	}
-
-	geometry.addAttribute( 'position', new THREE.Float32Attribute( positions, 3 ) );
-
-	var material = new THREE.LineBasicMaterial( { fog: false } );
-
-	this.cone = new THREE.LineSegments( geometry, material );
-	this.add( this.cone );
-
-	this.update();
-
-};
-
-THREE.SpotLightHelper.prototype = Object.create( THREE.Object3D.prototype );
-THREE.SpotLightHelper.prototype.constructor = THREE.SpotLightHelper;
-
-THREE.SpotLightHelper.prototype.dispose = function () {
-
-	this.cone.geometry.dispose();
-	this.cone.material.dispose();
-
-};
-
-THREE.SpotLightHelper.prototype.update = function () {
-
-	var vector = new THREE.Vector3();
-	var vector2 = new THREE.Vector3();
-
-	return function () {
-
-		var coneLength = this.light.distance ? this.light.distance : 1000;
-		var coneWidth = coneLength * Math.tan( this.light.angle );
-
-		this.cone.scale.set( coneWidth, coneWidth, coneLength );
-
-		vector.setFromMatrixPosition( this.light.matrixWorld );
-		vector2.setFromMatrixPosition( this.light.target.matrixWorld );
-
-		this.cone.lookAt( vector2.sub( vector ) );
-
-		this.cone.material.color.copy( this.light.color ).multiplyScalar( this.light.intensity );
-
-	};
-
-}();
-
-// File:src/extras/helpers/VertexNormalsHelper.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author WestLangley / http://github.com/WestLangley
-*/
-
-THREE.VertexNormalsHelper = function ( object, size, hex, linewidth ) {
-
-	this.object = object;
-
-	this.size = ( size !== undefined ) ? size : 1;
-
-	var color = ( hex !== undefined ) ? hex : 0xff0000;
-
-	var width = ( linewidth !== undefined ) ? linewidth : 1;
-
-	//
-
-	var nNormals = 0;
-
-	var objGeometry = this.object.geometry;
-
-	if ( objGeometry instanceof THREE.Geometry ) {
-
-		nNormals = objGeometry.faces.length * 3;
-
-	} else if ( objGeometry instanceof THREE.BufferGeometry ) {
-
-		nNormals = objGeometry.attributes.normal.count
-
-	}
-
-	//
-
-	var geometry = new THREE.BufferGeometry();
-
-	var positions = new THREE.Float32Attribute( nNormals * 2 * 3, 3 );
-
-	geometry.addAttribute( 'position', positions );
-
-	THREE.LineSegments.call( this, geometry, new THREE.LineBasicMaterial( { color: color, linewidth: width } ) );
-
-	//
-
-	this.matrixAutoUpdate = false;
-
-	this.update();
-
-};
-
-THREE.VertexNormalsHelper.prototype = Object.create( THREE.LineSegments.prototype );
-THREE.VertexNormalsHelper.prototype.constructor = THREE.VertexNormalsHelper;
-
-THREE.VertexNormalsHelper.prototype.update = ( function () {
-
-	var v1 = new THREE.Vector3();
-	var v2 = new THREE.Vector3();
-	var normalMatrix = new THREE.Matrix3();
-
-	return function update() {
-
-		var keys = [ 'a', 'b', 'c' ];
-
-		this.object.updateMatrixWorld( true );
-
-		normalMatrix.getNormalMatrix( this.object.matrixWorld );
-
-		var matrixWorld = this.object.matrixWorld;
-
-		var position = this.geometry.attributes.position;
-
-		//
-
-		var objGeometry = this.object.geometry;
-
-		if ( objGeometry instanceof THREE.Geometry ) {
-
-			var vertices = objGeometry.vertices;
-
-			var faces = objGeometry.faces;
-
-			var idx = 0;
-
-			for ( var i = 0, l = faces.length; i < l; i ++ ) {
-
-				var face = faces[ i ];
-
-				for ( var j = 0, jl = face.vertexNormals.length; j < jl; j ++ ) {
-
-					var vertex = vertices[ face[ keys[ j ] ] ];
-
-					var normal = face.vertexNormals[ j ];
-
-					v1.copy( vertex ).applyMatrix4( matrixWorld );
-
-					v2.copy( normal ).applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 );
-
-					position.setXYZ( idx, v1.x, v1.y, v1.z );
-
-					idx = idx + 1;
-
-					position.setXYZ( idx, v2.x, v2.y, v2.z );
-
-					idx = idx + 1;
-
-				}
-
-			}
-
-		} else if ( objGeometry instanceof THREE.BufferGeometry ) {
-
-			var objPos = objGeometry.attributes.position;
-
-			var objNorm = objGeometry.attributes.normal;
-
-			var idx = 0;
-
-			// for simplicity, ignore index and drawcalls, and render every normal
-
-			for ( var j = 0, jl = objPos.count; j < jl; j ++ ) {
-
-				v1.set( objPos.getX( j ), objPos.getY( j ), objPos.getZ( j ) ).applyMatrix4( matrixWorld );
-
-				v2.set( objNorm.getX( j ), objNorm.getY( j ), objNorm.getZ( j ) );
-
-				v2.applyMatrix3( normalMatrix ).normalize().multiplyScalar( this.size ).add( v1 );
-
-				position.setXYZ( idx, v1.x, v1.y, v1.z );
-
-				idx = idx + 1;
-
-				position.setXYZ( idx, v2.x, v2.y, v2.z );
-
-				idx = idx + 1;
-
-			}
-
-		}
-
-		position.needsUpdate = true;
-
-		return this;
-
-	}
-
-}() );
-
-// File:src/extras/helpers/WireframeHelper.js
-
-/**
- * @author mrdoob / http://mrdoob.com/
- */
-
-THREE.WireframeHelper = function ( object, hex ) {
-
-	var color = ( hex !== undefined ) ? hex : 0xffffff;
-
-	THREE.LineSegments.call( this, new THREE.WireframeGeometry( object.geometry ), new THREE.LineBasicMaterial( { color: color } ) );
-
-	this.matrix = object.matrixWorld;
-	this.matrixAutoUpdate = false;
-
-};
-
-THREE.WireframeHelper.prototype = Object.create( THREE.LineSegments.prototype );
-THREE.WireframeHelper.prototype.constructor = THREE.WireframeHelper;
-
-// File:src/extras/objects/ImmediateRenderObject.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.ImmediateRenderObject = function ( material ) {
-
-	THREE.Object3D.call( this );
-
-	this.material = material;
-	this.render = function ( renderCallback ) {};
-
-};
-
-THREE.ImmediateRenderObject.prototype = Object.create( THREE.Object3D.prototype );
-THREE.ImmediateRenderObject.prototype.constructor = THREE.ImmediateRenderObject;
-
-// File:src/extras/objects/MorphBlendMesh.js
-
-/**
- * @author alteredq / http://alteredqualia.com/
- */
-
-THREE.MorphBlendMesh = function( geometry, material ) {
-
-	THREE.Mesh.call( this, geometry, material );
-
-	this.animationsMap = {};
-	this.animationsList = [];
-
-	// prepare default animation
-	// (all frames played together in 1 second)
-
-	var numFrames = this.geometry.morphTargets.length;
-
-	var name = "__default";
-
-	var startFrame = 0;
-	var endFrame = numFrames - 1;
-
-	var fps = numFrames / 1;
-
-	this.createAnimation( name, startFrame, endFrame, fps );
-	this.setAnimationWeight( name, 1 );
-
-};
-
-THREE.MorphBlendMesh.prototype = Object.create( THREE.Mesh.prototype );
-THREE.MorphBlendMesh.prototype.constructor = THREE.MorphBlendMesh;
-
-THREE.MorphBlendMesh.prototype.createAnimation = function ( name, start, end, fps ) {
-
-	var animation = {
-
-		start: start,
-		end: end,
-
-		length: end - start + 1,
-
-		fps: fps,
-		duration: ( end - start ) / fps,
-
-		lastFrame: 0,
-		currentFrame: 0,
-
-		active: false,
-
-		time: 0,
-		direction: 1,
-		weight: 1,
-
-		directionBackwards: false,
-		mirroredLoop: false
-
-	};
-
-	this.animationsMap[ name ] = animation;
-	this.animationsList.push( animation );
-
-};
-
-THREE.MorphBlendMesh.prototype.autoCreateAnimations = function ( fps ) {
-
-	var pattern = /([a-z]+)_?(\d+)/i;
-
-	var firstAnimation, frameRanges = {};
-
-	var geometry = this.geometry;
-
-	for ( var i = 0, il = geometry.morphTargets.length; i < il; i ++ ) {
-
-		var morph = geometry.morphTargets[ i ];
-		var chunks = morph.name.match( pattern );
-
-		if ( chunks && chunks.length > 1 ) {
-
-			var name = chunks[ 1 ];
-
-			if ( ! frameRanges[ name ] ) frameRanges[ name ] = { start: Infinity, end: - Infinity };
-
-			var range = frameRanges[ name ];
-
-			if ( i < range.start ) range.start = i;
-			if ( i > range.end ) range.end = i;
-
-			if ( ! firstAnimation ) firstAnimation = name;
-
-		}
-
-	}
-
-	for ( var name in frameRanges ) {
-
-		var range = frameRanges[ name ];
-		this.createAnimation( name, range.start, range.end, fps );
-
-	}
-
-	this.firstAnimation = firstAnimation;
-
-};
-
-THREE.MorphBlendMesh.prototype.setAnimationDirectionForward = function ( name ) {
-
-	var animation = this.animationsMap[ name ];
-
-	if ( animation ) {
-
-		animation.direction = 1;
-		animation.directionBackwards = false;
-
-	}
-
-};
-
-THREE.MorphBlendMesh.prototype.setAnimationDirectionBackward = function ( name ) {
-
-	var animation = this.animationsMap[ name ];
-
-	if ( animation ) {
-
-		animation.direction = - 1;
-		animation.directionBackwards = true;
-
-	}
-
-};
-
-THREE.MorphBlendMesh.prototype.setAnimationFPS = function ( name, fps ) {
-
-	var animation = this.animationsMap[ name ];
-
-	if ( animation ) {
-
-		animation.fps = fps;
-		animation.duration = ( animation.end - animation.start ) / animation.fps;
-
-	}
-
-};
-
-THREE.MorphBlendMesh.prototype.setAnimationDuration = function ( name, duration ) {
-
-	var animation = this.animationsMap[ name ];
-
-	if ( animation ) {
-
-		animation.duration = duration;
-		animation.fps = ( animation.end - animation.start ) / animation.duration;
-
-	}
-
-};
-
-THREE.MorphBlendMesh.prototype.setAnimationWeight = function ( name, weight ) {
-
-	var animation = this.animationsMap[ name ];
-
-	if ( animation ) {
-
-		animation.weight = weight;
-
-	}
-
-};
-
-THREE.MorphBlendMesh.prototype.setAnimationTime = function ( name, time ) {
-
-	var animation = this.animationsMap[ name ];
-
-	if ( animation ) {
-
-		animation.time = time;
-
-	}
-
-};
-
-THREE.MorphBlendMesh.prototype.getAnimationTime = function ( name ) {
-
-	var time = 0;
-
-	var animation = this.animationsMap[ name ];
-
-	if ( animation ) {
-
-		time = animation.time;
-
-	}
-
-	return time;
-
-};
-
-THREE.MorphBlendMesh.prototype.getAnimationDuration = function ( name ) {
-
-	var duration = - 1;
-
-	var animation = this.animationsMap[ name ];
-
-	if ( animation ) {
-
-		duration = animation.duration;
-
-	}
-
-	return duration;
-
-};
-
-THREE.MorphBlendMesh.prototype.playAnimation = function ( name ) {
-
-	var animation = this.animationsMap[ name ];
-
-	if ( animation ) {
-
-		animation.time = 0;
-		animation.active = true;
-
-	} else {
-
-		console.warn( "THREE.MorphBlendMesh: animation[" + name + "] undefined in .playAnimation()" );
-
-	}
-
-};
-
-THREE.MorphBlendMesh.prototype.stopAnimation = function ( name ) {
-
-	var animation = this.animationsMap[ name ];
-
-	if ( animation ) {
-
-		animation.active = false;
-
-	}
-
-};
-
-THREE.MorphBlendMesh.prototype.update = function ( delta ) {
-
-	for ( var i = 0, il = this.animationsList.length; i < il; i ++ ) {
-
-		var animation = this.animationsList[ i ];
-
-		if ( ! animation.active ) continue;
-
-		var frameTime = animation.duration / animation.length;
-
-		animation.time += animation.direction * delta;
-
-		if ( animation.mirroredLoop ) {
-
-			if ( animation.time > animation.duration || animation.time < 0 ) {
-
-				animation.direction *= - 1;
-
-				if ( animation.time > animation.duration ) {
-
-					animation.time = animation.duration;
-					animation.directionBackwards = true;
-
-				}
-
-				if ( animation.time < 0 ) {
-
-					animation.time = 0;
-					animation.directionBackwards = false;
-
-				}
-
-			}
-
-		} else {
-
-			animation.time = animation.time % animation.duration;
-
-			if ( animation.time < 0 ) animation.time += animation.duration;
-
-		}
-
-		var keyframe = animation.start + THREE.Math.clamp( Math.floor( animation.time / frameTime ), 0, animation.length - 1 );
-		var weight = animation.weight;
-
-		if ( keyframe !== animation.currentFrame ) {
-
-			this.morphTargetInfluences[ animation.lastFrame ] = 0;
-			this.morphTargetInfluences[ animation.currentFrame ] = 1 * weight;
-
-			this.morphTargetInfluences[ keyframe ] = 0;
-
-			animation.lastFrame = animation.currentFrame;
-			animation.currentFrame = keyframe;
-
-		}
-
-		var mix = ( animation.time % frameTime ) / frameTime;
-
-		if ( animation.directionBackwards ) mix = 1 - mix;
-
-		if ( animation.currentFrame !== animation.lastFrame ) {
-
-			this.morphTargetInfluences[ animation.currentFrame ] = mix * weight;
-			this.morphTargetInfluences[ animation.lastFrame ] = ( 1 - mix ) * weight;
-
-		} else {
-
-			this.morphTargetInfluences[ animation.currentFrame ] = weight;
-
-		}
-
-	}
-
-};
-

From 36d4a067e55c73435712058359195ca1364e7203 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Thu, 19 May 2016 18:57:12 +0530
Subject: [PATCH 09/63] Added buttons for save/load functionality

---
 html/css/font.css | 6 ++++++
 html/index.html   | 4 ++++
 2 files changed, 10 insertions(+)

diff --git a/html/css/font.css b/html/css/font.css
index dfe9888..8faac22 100755
--- a/html/css/font.css
+++ b/html/css/font.css
@@ -59,3 +59,9 @@
 .icon-cog:before {
 	content: "\e900";
 }
+.icon-save:before {
+	content: "\f15b";
+}
+.icon-load:before {
+	content: "\f15b	";
+}
\ No newline at end of file
diff --git a/html/index.html b/html/index.html
index 7566841..33a36ee 100644
--- a/html/index.html
+++ b/html/index.html
@@ -25,6 +25,9 @@
             <div>
                 <ul class="vertical-centered">
                     <li><button id="button-new" class="button button--sacnite button--inverted" alt="New game" title="New game"><i class="icon-file"></i></button></li>
+                    <li><button id="button-load" class="button button--sacnite button--inverted" alt="New game" title="Load"><i class="icon-load"></i></button></li>
+                    <li><button id="button-save" class="button button--sacnite button--inverted" alt="New game" title="Save"><i class="icon-save"></i></button></li>
+
                 </ul>
             </div>
             <div>
@@ -88,6 +91,7 @@
                     </li>
                 </ul>
             </form>
+            <input type="file" id="xmlFile" style="display: none;" />
         </div>
         <script src="js/thirdparty/svg.min.js"></script>
         <script src="js/structure.js"></script>

From 7c27d248bbb00e81582107365be0253a751afcdb Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Thu, 19 May 2016 18:58:17 +0530
Subject: [PATCH 10/63] Made function to take input of xml file from user

---
 html/js/guiutils/Tools.js |  5 +++++
 html/js/main.js           | 16 ++++++++++++++++
 2 files changed, 21 insertions(+)

diff --git a/html/js/guiutils/Tools.js b/html/js/guiutils/Tools.js
index 760e868..04305a1 100644
--- a/html/js/guiutils/Tools.js
+++ b/html/js/guiutils/Tools.js
@@ -32,6 +32,11 @@ GTE.UI = (function (parentModule) {
         this.switchMode(GTE.MODES.ADD);
     };
 
+    Tools.prototype.loadTree = function(xml) {
+        //TODO :: Parse xml to javascript
+        console.log(xml);
+    };
+
     /**
     * Function that switches mode to the one specified by the button pressed
     * @param {Button} button Button pressed that will activate mode
diff --git a/html/js/main.js b/html/js/main.js
index 84abc8e..0876b6b 100644
--- a/html/js/main.js
+++ b/html/js/main.js
@@ -78,6 +78,22 @@
         GTE.tools.newTree();
         return false;
     });
+    document.getElementById("button-load").addEventListener("click", function(){
+        var xmlFiles = document.getElementById("xmlFile");
+        if (xmlFiles) {
+            xmlFiles.click();
+        }
+        var file = xmlFiles.files[0];
+        var reader = new FileReader();
+        reader.onloadend = function(evt) {
+            if (evt.target.readyState == FileReader.DONE) {
+                    GTE.tools.loadTree(evt.target.result);
+            };
+        };
+        var blob = file.slice(0, file.size - 1);
+        reader.readAsBinaryString(blob);
+        return false;
+    });
 
     document.getElementById("button-add").addEventListener("click", function(){
         GTE.tools.switchMode(GTE.MODES.ADD);

From ac5182511f2153df97c94b077c4741925dc547d4 Mon Sep 17 00:00:00 2001
From: amelie <amelie.heliou@polytechnique.edu>
Date: Thu, 19 May 2016 19:37:37 +0200
Subject: [PATCH 11/63] fixing little buggs on drawing

---
 html/2by2.html | 74 ++++++++++++++++++++++++++------------------------
 1 file changed, 38 insertions(+), 36 deletions(-)

diff --git a/html/2by2.html b/html/2by2.html
index 6ed51a8..bfc2c44 100644
--- a/html/2by2.html
+++ b/html/2by2.html
@@ -16,6 +16,15 @@
 <script>
     var canvas1,canvas2;
     var ctx1,ctx2;
+    var points=[];
+    
+    function redraw(){
+        ctx1.clearRect(0,0,canvas1.width,canvas1.height);
+        ctx2.clearRect(0,0,canvas2.width,canvas2.height);
+        compute_firstP();
+        compute_secondP();
+        draw();
+    }
     
     function initDraws() {
         canvas1 = document.getElementById("Payoff1");
@@ -24,7 +33,7 @@
         ctx2 = canvas2.getContext("2d");
         compute_firstP();
         compute_secondP();
-        points=[payoff1_11, payoff1_12, payoff1_21, payoff1_22, payoff2_11, payoff2_12, payoff2_21, payoff2_22];
+        alert(points[0].y);
         draw();
         
         //alert(points[0].y);
@@ -51,16 +60,7 @@
     mousePosition = getMousePosition( event)
     
     var isMouseOver = isMouseOverPoint(mousePosition);
-    /*if (isMouseOver) {
-        canvas1.addEventListener("mousemove", doMouseMove);
-    }*/
-    //console.log("Pressing1: X = " + mousePosition.x + ", Y = " + mousePosition.y);
-    //mousePosition = getMousePosition(canvas2, event)
-    
-    //isMouseOver = isMouseOverPoint(mousePosition);
-    /*if (isMouseOver) {
-        canvas2.addEventListener("mousemove", doMouseMove);
-    }*/
+
     console.log("Pressing2: X = " + mousePosition.x + ", Y = " + mousePosition.y);
 }
 
@@ -107,34 +107,34 @@
         mousePosition = getMousePosition(event)
         var canvasPosition = canvas1.getBoundingClientRect();
          points[point_moving].y = mousePosition.y-canvasPosition.top;
-         if(point_moving==0) document.getElementById("P1_11").value=~~((-points[point_moving].y+canvas1.height-50)/3)/10;
-         if(point_moving==1) document.getElementById("P1_12").value=~~((-points[point_moving].y+canvas1.height-50)/3)/10;
-         if(point_moving==2) document.getElementById("P1_21").value=~~((-points[point_moving].y+canvas1.height-50)/3)/10;
-         if(point_moving==3) document.getElementById("P1_22").value=~~((-points[point_moving].y+canvas1.height-50)/3)/10;
+         var newPos=~~((-points[point_moving].y+canvas1.height-50)/3)/10;
+         if (Number(newPos)<0) newPos=0;
+         if (Number(newPos)>10) newPos=10;
+         if(point_moving==0) document.getElementById("P1_11").value=newPos;
+         if(point_moving==1) document.getElementById("P1_12").value=newPos;
+         if(point_moving==2) document.getElementById("P1_21").value=newPos;
+         if(point_moving==3) document.getElementById("P1_22").value=newPos;
     }
     if (point_moving>=points.length/2){
         mousePosition = getMousePosition(event)
         var canvasPosition = canvas2.getBoundingClientRect();
         points[point_moving].y = mousePosition.y-canvasPosition.top;
-        if(point_moving==4) document.getElementById("P2_11").value=~~((-points[point_moving].y+canvas2.height-50)/3)/10;
-        if(point_moving==5) document.getElementById("P2_12").value=~~((-points[point_moving].y+canvas2.height-50)/3)/10;
-        if(point_moving==6) document.getElementById("P2_21").value=~~((-points[point_moving].y+canvas2.height-50)/3)/10;
-        if(point_moving==7) document.getElementById("P2_22").value=~~((-points[point_moving].y+canvas2.height-50)/3)/10;
+        var newPos=~~((-points[point_moving].y+canvas2.height-50)/3)/10;
+        if (Number(newPos)<0) newPos=0;
+        if (Number(newPos)>10) newPos=10;
+        if(point_moving==4) document.getElementById("P2_11").value=newPos;
+        if(point_moving==5) document.getElementById("P2_12").value=newPos;
+        if(point_moving==6) document.getElementById("P2_21").value=newPos;
+        if(point_moving==7) document.getElementById("P2_22").value=newPos;
     }
     redraw()
     
     console.log("Moving: X = " + mousePosition.x + ", Y = " + mousePosition.y);
 }
 
-    function redraw(){
-        ctx1.clearRect(0,0,canvas1.width,canvas1.height);
-        ctx2.clearRect(0,0,canvas2.width,canvas2.height);
-        compute_firstP();
-        compute_secondP();
-        draw();
-    }
 
-    function compute_firstP(){
+
+function compute_firstP(){
         var P1_11=document.getElementById("P1_11").value;
         var P1_12=document.getElementById("P1_12").value;
         var P1_21=document.getElementById("P1_21").value;
@@ -144,14 +144,14 @@
         payoff1_21={x:50, y:canvas1.height-50-P1_21*30, radius:5, color:"yellow"};
         payoff1_22={x:canvas1.width-50, y:canvas1.height-50-P1_22*30, radius:5, color:"yellow"};
         var maxP1_1, minP1_1, maxP1_2, minP1_2; // max and min off player1 payoff for strategy 1 or 2 of player2
-        if( P1_11>P1_21){
+        if( Number(P1_11)>Number(P1_21)){
             maxP1_1=P1_11;
             minP1_1=P1_21;
         }else{
             maxP1_1=P1_21;
             minP1_1=P1_11;
         }
-        if( P1_12>P1_22){
+        if( Number(P1_12)>Number(P1_22)){
             maxP1_2=P1_12;
             minP1_2=P1_22;
         }else{
@@ -180,15 +180,16 @@
         payoff2_12={x:50, y:canvas2.height-50-P2_12*30, radius:5, color:"yellow"};
         payoff2_21={x:canvas2.width-50, y:canvas2.height-50-P2_21*30, radius:5, color:"yellow"};
         payoff2_22={x:canvas2.width-50, y:canvas2.height-50-P2_22*30, radius:5, color:"yellow"};
+        points=[payoff1_11, payoff1_12, payoff1_21, payoff1_22, payoff2_11, payoff2_12, payoff2_21, payoff2_22];
         var maxP2_1, minP2_1, maxP2_2, minP2_2; // max and min off player1 payoff for strategy 1 or 2 of player2
-        if( P2_11>P2_12){
+        if( Number(P2_11)>Number(P2_12)){
             maxP2_1=P2_11;
             minP2_1=P2_12;
         }else{
             maxP2_1=P2_12;
             minP2_1=P2_11;
         }
-        if( P2_21>P2_22){
+        if( Number(P2_21)>Number(P2_22)){
             maxP2_2=P2_21;
             minP2_2=P2_22;
         }else{
@@ -198,7 +199,8 @@
         if((maxP2_1==P2_11 && maxP2_2==P2_21)||(maxP2_1==P2_12 && maxP2_2==P2_22)){
             point2_1={x:50,y:canvas2.height-50-maxP2_1*30};
             point2_2={x:canvas2.width-50,y:canvas2.height-50-maxP2_2*30};
-            point2_3={x:canvas2.width-50,y:canvas2.height-50-maxP2_2*30};}
+            point2_3={x:canvas2.width-50,y:canvas2.height-50-maxP2_2*30};
+            }
         else{
             var middle_x=(P2_12-P2_11)/(Number(P2_12)- Number(P2_22) + Number(P2_21) - Number(P2_11));
             var middle_y=Number((P2_21-P2_11)*middle_x)+Number(P2_11);
@@ -337,16 +339,16 @@
         <table border="1">
   <tr>
     <th><label class="player1">Player I</label> \ <label class="player2">Player II</label></th>
-    <th><label><input class="player2" type="text" id="P2S1" value="S1"/> </label></th>
-    <th><label><input class="player2" type="text" id="P2S2" value="S2"/> </label></th>
+    <th><label><input class="player2" type="text" id="P2S1" onchange="redraw()" value="S1"/> </label></th>
+    <th><label><input class="player2" type="text" id="P2S2" onchange="redraw()" value="S2"/> </label></th>
   </tr>
   <tr>
-      <th><label><input class="player1" type="text" id="P1S1" value="S1"/> </label></th>
+      <th><label><input class="player1" type="text" id="P1S1" onchange="redraw()" value="S1"/> </label></th>
     <td><input class="player1" type="text" id="P1_11" onchange="redraw()" value=0>\<input class="player2" type="text" id="P2_11"  onchange="redraw()" value=0></td>
     <td><input class="player1" type="text" id="P1_12" onchange="redraw()" value=0>\<input class="player2" type="text" id="P2_12" onchange="redraw()" value=0></td>
   </tr>
   <tr>
-  <th><label><input class="player1" type="text" id="P1S2" value="S2"/> </label></th>
+  <th><label><input class="player1" type="text" id="P1S2" onchange="redraw()" value="S2"/> </label></th>
     <td><input class="player1" type="text" id="P1_21" onchange="redraw()" value=0>\<input class="player2" type="text" id="P2_21"  onchange="redraw()" value=0></td>
     <td><input class="player1" type="text" id="P1_22" onchange="redraw()" value=0>\<input class="player2" type="text" id="P2_22"  onchange="redraw()" value=0></td>
   </tr>

From 70c81dc1de21a2fc36bd88d4b4d4bf889dc15a6a Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Fri, 20 May 2016 00:01:58 +0530
Subject: [PATCH 12/63] Added functions to parse player data from xml to
 javascript

---
 html/index.html                |   2 +
 html/js/guiutils/Tools.js      |  36 +++-
 html/js/main.js                |  21 +-
 html/js/thirdparty/xml2json.js | 349 +++++++++++++++++++++++++++++++++
 html/js/tree/Player.js         |   7 +-
 html/js/tree/Tree.js           |  15 +-
 6 files changed, 405 insertions(+), 25 deletions(-)
 create mode 100644 html/js/thirdparty/xml2json.js

diff --git a/html/index.html b/html/index.html
index 33a36ee..80f25cd 100644
--- a/html/index.html
+++ b/html/index.html
@@ -93,7 +93,9 @@
             </form>
             <input type="file" id="xmlFile" style="display: none;" />
         </div>
+
         <script src="js/thirdparty/svg.min.js"></script>
+        <script src="js/thirdparty/xml2json.js"></script>
         <script src="js/structure.js"></script>
         <script src="js/guiutils/Tools.js"></script>
         <script src="js/guiutils/ContentEditable.js"></script>
diff --git a/html/js/guiutils/Tools.js b/html/js/guiutils/Tools.js
index 04305a1..f6d20af 100644
--- a/html/js/guiutils/Tools.js
+++ b/html/js/guiutils/Tools.js
@@ -14,7 +14,7 @@ GTE.UI = (function (parentModule) {
     * It creates a new Tree and draws it
     */
     Tools.prototype.newTree = function() {
-        this.resetPlayers();
+        this.resetPlayers(1);
         this.activePlayer = -1;
         var root = new GTE.TREE.Node(null);
         var child1 = new GTE.TREE.Node(root);
@@ -33,8 +33,18 @@ GTE.UI = (function (parentModule) {
     };
 
     Tools.prototype.loadTree = function(xml) {
-        //TODO :: Parse xml to javascript
-        console.log(xml);
+        var jsTree = X2J.parseXml(xml);
+        var tree = jsTree[0].gte[0];
+        this.resetPlayers(1);
+        this.activePlayer = -1;
+        var root = new GTE.TREE.Node(null);
+        var child1 = new GTE.TREE.Node(root);
+        var child2 = new GTE.TREE.Node(root);
+        GTE.tree = new GTE.TREE.Tree(root);
+        this.addChancePlayer();
+        this.setPlayers(tree.display[0].color, tree.players[0].player);
+        GTE.tree.draw();
+        this.switchMode(GTE.MODES.ADD);
     };
 
     /**
@@ -124,10 +134,10 @@ GTE.UI = (function (parentModule) {
     /**
     * Function that adds a player button to the toolbar
     */
-    Tools.prototype.addPlayer = function () {
+    Tools.prototype.addPlayer = function (colour, id, name) {
         if (GTE.tree.numberOfPlayers() < GTE.CONSTANTS.MAX_PLAYERS) {
             // Create a new player
-            var player = GTE.tree.newPlayer();
+            var player = GTE.tree.newPlayer(colour, id, name);
             if (player !== null) {
                 if (player.id == GTE.CONSTANTS.MIN_PLAYERS + 1) {
                     document.getElementById("button-player-less").className =
@@ -246,9 +256,9 @@ GTE.UI = (function (parentModule) {
     /**
     * Removes all players from the toolbar
     */
-    Tools.prototype.resetPlayers = function () {
+    Tools.prototype.resetPlayers = function (length) {
         var buttons = document.getElementsByClassName("button-player");
-        while(buttons.length > 2) {
+        while(buttons.length > length + 1) {
             this.removePlayerButton(buttons[buttons.length-1]);
         }
     };
@@ -256,6 +266,18 @@ GTE.UI = (function (parentModule) {
     Tools.prototype.changePlayerColour = function (playerId, colour) {
         var playerButton = document.getElementById("button-player-" + playerId);
         playerButton.style.color = colour;
+        GTE.STORAGE.settingsPlayersColours[playerId] = colour;
+    };
+
+    Tools.prototype.setPlayers = function (colour,name) {
+        for(var i=1; i<=name.length; i++)
+        {
+            this.addPlayer(colour[i-1].jValue, i, name[i-1].jValue);
+   //         var pl = new GTE.TREE.Player(i,colour[i-1].jValue);
+     //       pl.name = name[i-1].jValue;
+       //     GTE.tree.players[i] = pl;
+         //   this.changePlayerColour(i,colour[i-1].jValue);
+        }
     };
 
     // Add class to parent module
diff --git a/html/js/main.js b/html/js/main.js
index 0876b6b..87ee5b5 100644
--- a/html/js/main.js
+++ b/html/js/main.js
@@ -80,18 +80,21 @@
     });
     document.getElementById("button-load").addEventListener("click", function(){
         var xmlFiles = document.getElementById("xmlFile");
+        xmlFiles.onchange = function(e) {
+            var file = xmlFiles.files[0];
+            var reader = new FileReader();
+            reader.onloadend = function(evt) {
+                if (evt.target.readyState == FileReader.DONE) {
+                        GTE.tools.loadTree(evt.target.result);
+                };
+            };
+
+            var blob = file.slice(0, file.size - 1);
+            reader.readAsBinaryString(blob);
+        };
         if (xmlFiles) {
             xmlFiles.click();
         }
-        var file = xmlFiles.files[0];
-        var reader = new FileReader();
-        reader.onloadend = function(evt) {
-            if (evt.target.readyState == FileReader.DONE) {
-                    GTE.tools.loadTree(evt.target.result);
-            };
-        };
-        var blob = file.slice(0, file.size - 1);
-        reader.readAsBinaryString(blob);
         return false;
     });
 
diff --git a/html/js/thirdparty/xml2json.js b/html/js/thirdparty/xml2json.js
new file mode 100644
index 0000000..0c717bd
--- /dev/null
+++ b/html/js/thirdparty/xml2json.js
@@ -0,0 +1,349 @@
+/*
+Author: Surya Nyayapati
+http://www.nyayapati.com/surya
+
+The MIT License (MIT)
+Copyright (c) <2012> <Surya Nyayapati>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), 
+to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+(function (window, undefined) {
+    var X2J = {
+        VERSION: '1.1',
+        //convert xml to x2j object
+        //Rule: Get ordered list of javascript object for xml
+        parseXml: function (xml, xpathExpression) {
+            var isObjectEmpty = function (obj) {
+                for (var name in obj) {
+                    return false;
+                }
+                return true;
+            };
+            //TODO:if there is name conflict, change name and during output change it back
+
+            //jNode = [{jName, jValue}] || [{jIndex, jNode,jName}]
+            //jIndex = [{jName, counter}]    
+            //jName = "node_name"    
+            //jValue = "node_value"
+            //counter = 0..n (i.e. index for jNode)
+            var GetChildNode = function (domElement) {
+                var obj = {};  
+                obj['jName'] = domElement.nodeName;
+                obj['jAttr'] = GetAttributes(domElement.attributes);
+                
+                for (var i = 0; i < domElement.childNodes.length; i++) {
+                    var node1 = domElement.childNodes[i];
+                    if (node1.nodeType === TEXT_NODE) {                        
+                        if (node1.textContent.trim() !== "") {
+                            obj['jValue'] = node1.textContent;                            
+                        }                        
+                    }
+                    else 
+                    {
+                        var tmp = {};
+                        var childNode = GetChildNode(node1);
+                        for (var key in childNode) {                            
+                            if (key !== 'jIndex' && key !== 'jValue') {
+                                tmp[key] = childNode[key];
+                            }
+                        }
+                        
+                        if(!childNode['jIndex'])
+                        {
+                            tmp = childNode;
+                            if (!tmp.hasOwnProperty('jValue')) {
+                                tmp['jValue'] = '';
+                            }
+                        }    
+                        
+                        if (obj['jIndex'] === undefined) {
+                            obj['jIndex'] = [];
+                        }
+
+                        if (obj.hasOwnProperty(node1.nodeName)) {
+                            obj['jIndex'].push([node1.nodeName, obj[node1.nodeName].length]);
+                            if (childNode['jIndex'] !== undefined) {
+                                tmp['jIndex'] = childNode['jIndex'];
+                            }
+                            obj[node1.nodeName].push(tmp);
+                        }
+                        else {
+                            obj[node1.nodeName] = [];
+                            obj['jIndex'].push([node1.nodeName, obj[node1.nodeName].length]);
+                            if (childNode['jIndex'] !== undefined) {
+                                tmp['jIndex'] = childNode['jIndex'];
+                            }
+                            obj[node1.nodeName].push(tmp);
+                        }
+                    }
+                }
+                
+                return obj;
+            };
+
+            //Rule: attributes are unique list of name value pair inside a node.
+            //Summary: This will return an object with jIndex property as an array and all the attributes as name value properties.
+            //The number of attributes in a node will be equal to jIndex length. each element inside jIndex will be same as attribute name.
+            var GetAttributes = function (attrs) {            
+                var obj = {};                
+                obj['jIndex'] = [];
+                if(!attrs) return obj;
+                
+                for (var i = 0; i < attrs.length; i++) { 
+                    obj[attrs[i].name] = attrs[i].value;
+                    obj['jIndex'].push(attrs[i].name);
+                }
+                return obj;
+            };
+            
+            if (!xml) {
+                return;
+            }
+            if (!xpathExpression) {
+                xpathExpression = '/';
+            }
+            //var xmlStr = (new XMLSerializer()).serializeToString(xml);
+            var xmlDocument = null;
+            if(typeof(xml) ==='string')
+            {
+                var parser = new DOMParser();
+                xmlDocument = parser.parseFromString(xml, "text/xml");
+            }
+            else
+            {
+                xmlDocument = xml;
+            }
+            
+            //var xmlDoc = parser.parseFromString(xmlStr, "text/xml");
+            //var nodes = xmlDoc.evaluate("/", xmlDoc, null, XPathResult.ANY_TYPE, null);
+            var xPathResult1 = xmlDocument.evaluate(xpathExpression, xmlDocument, null, XPathResult.ANY_TYPE, null);
+            if (xPathResult1.resultType === UNORDERED_NODE_ITERATOR_TYPE
+            || xPathResult1.resultType === ORDERED_NODE_ITERATOR_TYPE) {//if result is a node-set then UNORDERED_NODE_ITERATOR_TYPE is always the resulting type
+
+                var dom_node1 = xPathResult1.iterateNext(); //returns node https://developer.mozilla.org/en/DOM/Node
+                var domArr = [];
+                while (dom_node1) {                                           
+                    domArr.push(GetChildNode(dom_node1));
+                    dom_node1 = xPathResult1.iterateNext();
+                }
+                //if (domArr.length == 1) {
+                //    return domArr[0];
+                //}
+                return domArr;
+
+            } else {
+                console.log(xPathResult1);
+            }
+        },
+        printJNode: function (jNode, callback) {
+            if (jNode === undefined) {
+                return;
+            }
+            var _printNode = function (jNode, level) {
+                if (jNode.jIndex !== undefined) {
+                    for (var j = 0; j < jNode.jIndex.length; j++) {
+                        var node = jNode[jNode.jIndex[j][0]][jNode.jIndex[j][1]];
+                        if (node.jIndex !== undefined) {
+                            callback(jNode.jIndex[j][0], node.jIndex, node.jAttr, level);
+                            _printNode(node, level + 1); //go deeper
+                        } else {
+                            callback(node.jName, node.jValue, node.jAttr, level);
+                        }
+                    }
+                } else {
+                    callback(jNode.jName, jNode.jValue, jNode.jAttr, level);
+                }
+            };
+            _printNode(jNode, 0);
+        },
+        printJAttribute: function (jAttr) {
+            var strArr = [];
+            if (jAttr.jIndex) {
+                for (var i = 0; i < jAttr.jIndex.length; i++) {
+                    strArr.push(jAttr.jIndex[i] + "=" + jAttr[jAttr.jIndex[i]]);
+                }
+            }
+            return strArr.join(', ');
+        },
+        ///Safe way to get value, Use when not sure if a name is present. if not present return default_value.
+        getValue: function (jNode, name, index, default_value) {//if index undefined then 0
+            //console.log(jNode, name, index,default_value);
+            if (jNode === undefined || jNode === null) {
+                return default_value;
+            }
+            if (index === undefined || typeof(index) != 'number') {
+                index = 0;
+            }
+
+            if (index >= 0) {//if index is present
+                if (jNode.length !== undefined && jNode.length == index + 1) {//if array
+                    if (jNode[index].jName !== undefined && jNode[index].jName == name) {
+                        //console.log('getValue 0');
+                        return jNode[index].jValue; //tested
+                    }
+                }
+                else if (jNode[name] !== undefined) {//if not array but name obj is array then return indexOf
+                    var node = jNode[name][index];
+                    if (node !== undefined) {
+                        if (node.jValue !== undefined) {
+                            //console.log('getValue 1');
+                            return node.jValue;
+                        } else {
+                            //console.log('getValue 2');
+                            return node;
+                        }
+                    }
+                }
+                else if (jNode.jName !== undefined && jNode.jName == name) {
+                    //console.log('getValue 3');
+                    return jNode.jValue;
+                }
+                else if (jNode.length === undefined && jNode[name]) { //if not array and name exists
+                    //console.log('getValue 4');
+                    return jNode[name]; //tested
+                }
+
+                return default_value;
+            }
+
+            throw new RangeError("index must be positive!");
+
+        },
+        search: function (jNode, name, options) {
+            //options is object with keys like 'max_deep', ...
+            //same as getValue, but returns array of obj(jName,jValue/jIndex,jAttr,[jNode]??)
+        },
+        getAttr: function (jNode, name) {
+            var isObjectEmpty = function (obj) {
+                for (var name in obj) {
+                    return false;
+                }
+                return true;
+            };
+
+            if (!jNode || !jNode.jAttr || isObjectEmpty(jNode.jAttr)) {
+                return;
+            }
+            return jNode.jAttr[name];
+        },
+        getJson: function (jNode) {
+            return JSON.stringify(jNode);
+        },
+        getXml: function (jNode) {
+            var spaces = function (no) {
+                if (no === 0) {
+                    return '';
+                }
+                var space = ' ';
+                for (var i = 0; i < no; i++) {
+                    space += ' ';
+                }
+                return space;
+            };
+            var _printAttribute = function (jNode) {
+                if (!jNode) {
+                    return;
+                }
+                var arr = [];
+                for (var i = 0; i < jNode.jAttr.jIndex.length; i++) {
+                    arr.push(' ' + jNode.jAttr.jIndex[i] + '="' + jNode.jAttr[jNode.jAttr.jIndex[i]] + '"');
+                }
+                return arr.join('');
+            }
+            var _printNode = function (jNode, level) {
+                if (!jNode) {
+                    return;
+                }
+                var xml = '';
+                if (jNode.jIndex) {
+                    for (var j = 0; j < jNode.jIndex.length; j++) {
+                        var node = jNode[jNode.jIndex[j][0]][jNode.jIndex[j][1]];
+                        if (node.jIndex) {
+                            xml += spaces(level) + '<' + jNode.jIndex[j][0] + _printAttribute(node) + '>\n' + _printNode(node, level + 1) + spaces(level) + '</' + jNode.jIndex[j][0] + '>\n';
+                        } else {
+                            xml += spaces(level) + '<' + jNode.jIndex[j][0] + _printAttribute(node) + '>' + node.jValue + '</' + jNode.jIndex[j][0] + '>\n';
+                        }
+                    }
+                } else {
+                    xml += spaces(level) + '<' + jNode.jName + _printAttribute(jNode) + '>' + jNode.jValue + '</' + jNode.jName + '>\n';
+                }
+                return xml;
+            };
+            if (jNode.length) {
+                var xmlArr = [];
+                for (var i = 0; i < jNode.length; i++) {
+                    xmlArr.push(_printNode(jNode[i], 0))
+                }
+                return xmlArr;
+            } else {
+                return _printNode(jNode, 0);
+            }
+        }
+    };
+
+    window.X2J = X2J;
+
+    //////////////////////////////////////////////////////////
+    //////////////////////Constants///////////////////////
+    //////////////////////////////////////////////////////////
+
+    var ANY_TYPE = 0,                  //A result set containing whatever type naturally results from evaluation of the expression. Note that if the result is a node-set then UNORDERED_NODE_ITERATOR_TYPE is always the resulting type.
+        NUMBER_TYPE = 1,                 //A result containing a single number. This is useful for example, in an XPath expression using the count() function.
+        STRING_TYPE = 2,                 //A result containing a single string.
+        BOOLEAN_TYPE = 3,                 //A result containing a single boolean value. This is useful for example, in an XPath expression using the not() function.
+        UNORDERED_NODE_ITERATOR_TYPE = 4, //A result node-set containing all the nodes matching the expression. The nodes may not necessarily be in the same order that they appear in the document.
+        ORDERED_NODE_ITERATOR_TYPE = 5, //A result node-set containing all the nodes matching the expression. The nodes in the result set are in the same order that they appear in the document.
+        UNORDERED_NODE_SNAPSHOT_TYPE = 6, //A result node-set containing snapshots of all the nodes matching the expression. The nodes may not necessarily be in the same order that they appear in the document.
+        ORDERED_NODE_SNAPSHOT_TYPE = 7, //A result node-set containing snapshots of all the nodes matching the expression. The nodes in the result set are in the same order that they appear in the document.
+        ANY_UNORDERED_NODE_TYPE = 8, //A result node-set containing any single node that matches the expression. The node is not necessarily the first node in the document that matches the expression.
+        FIRST_ORDERED_NODE_TYPE = 9;    //A result node-set containing the first node in the document that matches the expression.
+
+    var XPathDict = {
+        0: "ANY_TYPE",
+        1: "NUMBER_TYPE",
+        2: "STRING_TYPE",
+        3: "BOOLEAN_TYPE",
+        4: "UNORDERED_NODE_ITERATOR_TYPE",
+        5: "ORDERED_NODE_ITERATOR_TYPE",
+        6: "UNORDERED_NODE_SNAPSHOT_TYPE",
+        7: "ORDERED_NODE_SNAPSHOT_TYPE",
+        8: "ANY_UNORDERED_NODE_TYPE",
+        9: "FIRST_ORDERED_NODE_TYPE"
+    };
+
+    var ELEMENT_NODE = 1,
+    ATTRIBUTE_NODE = 2,
+    TEXT_NODE = 3,
+    DATA_SECTION_NODE = 4,
+    ENTITY_REFERENCE_NODE = 5,
+    ENTITY_NODE = 6,
+    PROCESSING_INSTRUCTION_NODE = 7,
+    COMMENT_NODE = 8,
+    DOCUMENT_NODE = 9,
+    DOCUMENT_TYPE_NODE = 10,
+    DOCUMENT_FRAGMENT_NODE = 11,
+    NOTATION_NODE = 12
+
+    var ElementDict = { 1: "ELEMENT_NODE",
+        2: "ATTRIBUTE_NODE",
+        3: "TEXT_NODE",
+        4: "DATA_SECTION_NODE",
+        5: "ENTITY_REFERENCE_NODE",
+        6: "ENTITY_NODE",
+        7: "PROCESSING_INSTRUCTION_NODE",
+        8: "COMMENT_NODE",
+        9: "DOCUMENT_NODE",
+        10: "DOCUMENT_TYPE_NODE",
+        11: "DOCUMENT_FRAGMENT_NODE",
+        12: "NOTATION_NODE"
+    };
+} (window));
\ No newline at end of file
diff --git a/html/js/tree/Player.js b/html/js/tree/Player.js
index 9d52843..1c02004 100644
--- a/html/js/tree/Player.js
+++ b/html/js/tree/Player.js
@@ -8,9 +8,12 @@ GTE.TREE = (function (parentModule) {
     * @param {Number} id     Player's id.
     * @param {String} colour Player's hex colour.
     */
-    function Player(id, colour) {
+    function Player(id, colour, name) {
         this.id = id;
-        if (this.id === Player.CHANCE) {
+        if(name != null) {
+            this.name = name;
+        }
+        else if (this.id === Player.CHANCE) {
             this.name = GTE.PLAYERS.DEFAULT_CHANCE_NAME;
         } else {
             this.name = "" + this.id;
diff --git a/html/js/tree/Tree.js b/html/js/tree/Tree.js
index 4d4ecff..27623b1 100644
--- a/html/js/tree/Tree.js
+++ b/html/js/tree/Tree.js
@@ -849,18 +849,19 @@ GTE.TREE = (function (parentModule) {
     *                           get this player's colour from the list of colours
     * @return {Player} player   Created player
     */
-    Tree.prototype.newPlayer = function (colour) {
+    Tree.prototype.newPlayer = function (colour, id, name) {
         // Player ID is incremental
         var id;
-        if (this.players.length >= 1) {
-            id = this.players[this.players.length-1].id+1;
-        } else {
-            id = GTE.TREE.Player.CHANCE;
+        if(id == null) {
+            if (this.players.length >= 1) {
+                    id = this.players[this.players.length-1].id+1;
+                } else {
+                    id = GTE.TREE.Player.CHANCE;
+            }
         }
-
         colour = colour || GTE.tools.getColour(this.players.length);
         // Create the new player
-        var player = new GTE.TREE.Player(id, colour);
+        var player = new GTE.TREE.Player(id, colour, name);
         // Add the player to the list of players and return it
         return this.addPlayer(player);
     };

From 907f948bb44d36be5bf1973e53677175d0148f5d Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Fri, 20 May 2016 00:05:54 +0530
Subject: [PATCH 13/63] Added comments and removed redundant data

---
 html/js/guiutils/Tools.js | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/html/js/guiutils/Tools.js b/html/js/guiutils/Tools.js
index f6d20af..2e95744 100644
--- a/html/js/guiutils/Tools.js
+++ b/html/js/guiutils/Tools.js
@@ -32,6 +32,10 @@ GTE.UI = (function (parentModule) {
         this.switchMode(GTE.MODES.ADD);
     };
 
+    /**
+    * Function used to create new tree according
+    * to the xml data received.
+    */
     Tools.prototype.loadTree = function(xml) {
         var jsTree = X2J.parseXml(xml);
         var tree = jsTree[0].gte[0];
@@ -254,7 +258,7 @@ GTE.UI = (function (parentModule) {
     };
 
     /**
-    * Removes all players from the toolbar
+    * Resets the length of the players to @length in the toolbar.
     */
     Tools.prototype.resetPlayers = function (length) {
         var buttons = document.getElementsByClassName("button-player");
@@ -263,20 +267,13 @@ GTE.UI = (function (parentModule) {
         }
     };
 
-    Tools.prototype.changePlayerColour = function (playerId, colour) {
-        var playerButton = document.getElementById("button-player-" + playerId);
-        playerButton.style.color = colour;
-        GTE.STORAGE.settingsPlayersColours[playerId] = colour;
-    };
-
+    /**
+    * Adds new players to the according to color and name arrays
+    */
     Tools.prototype.setPlayers = function (colour,name) {
         for(var i=1; i<=name.length; i++)
         {
             this.addPlayer(colour[i-1].jValue, i, name[i-1].jValue);
-   //         var pl = new GTE.TREE.Player(i,colour[i-1].jValue);
-     //       pl.name = name[i-1].jValue;
-       //     GTE.tree.players[i] = pl;
-         //   this.changePlayerColour(i,colour[i-1].jValue);
         }
     };
 

From a73017c61eeaba0b8ea2280a58b624412c435cac Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Fri, 20 May 2016 03:14:59 +0530
Subject: [PATCH 14/63] Added functions to set display properties according to
 xml data

---
 html/js/guiutils/Tools.js | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/html/js/guiutils/Tools.js b/html/js/guiutils/Tools.js
index 2e95744..a0d16c2 100644
--- a/html/js/guiutils/Tools.js
+++ b/html/js/guiutils/Tools.js
@@ -39,6 +39,7 @@ GTE.UI = (function (parentModule) {
     Tools.prototype.loadTree = function(xml) {
         var jsTree = X2J.parseXml(xml);
         var tree = jsTree[0].gte[0];
+        var display = tree.display[0];
         this.resetPlayers(1);
         this.activePlayer = -1;
         var root = new GTE.TREE.Node(null);
@@ -46,7 +47,8 @@ GTE.UI = (function (parentModule) {
         var child2 = new GTE.TREE.Node(root);
         GTE.tree = new GTE.TREE.Tree(root);
         this.addChancePlayer();
-        this.setPlayers(tree.display[0].color, tree.players[0].player);
+        this.setPlayers(display.color, tree.players[0].player);
+        this.setDisplayProperties(display);
         GTE.tree.draw();
         this.switchMode(GTE.MODES.ADD);
     };
@@ -277,6 +279,15 @@ GTE.UI = (function (parentModule) {
         }
     };
 
+    /**
+    * Sets display properties of the tree
+    */
+    Tools.prototype.setDisplayProperties = function (display) {
+        GTE.STORAGE.settingsLineThickness = display.strokeWidth[0].jValue;
+        GTE.STORAGE.settingsCircleSize = display.nodeDiameter[0].jValue;
+        GTE.STORAGE.settingsDistLevels = display.levelDistance[0].jValue;
+    };
+
     // Add class to parent module
     parentModule.Tools = Tools;
 

From be077b1914e282c9c4a080569e06571cb879880a Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Fri, 20 May 2016 20:34:44 +0530
Subject: [PATCH 15/63] Added functions to parse nodes according to xml data

---
 html/js/guiutils/Tools.js | 29 +++++++++++++++++++++++++++--
 html/js/tree/Tree.js      |  4 ++--
 2 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/html/js/guiutils/Tools.js b/html/js/guiutils/Tools.js
index a0d16c2..d4826fa 100644
--- a/html/js/guiutils/Tools.js
+++ b/html/js/guiutils/Tools.js
@@ -43,16 +43,41 @@ GTE.UI = (function (parentModule) {
         this.resetPlayers(1);
         this.activePlayer = -1;
         var root = new GTE.TREE.Node(null);
-        var child1 = new GTE.TREE.Node(root);
-        var child2 = new GTE.TREE.Node(root);
         GTE.tree = new GTE.TREE.Tree(root);
         this.addChancePlayer();
         this.setPlayers(display.color, tree.players[0].player);
         this.setDisplayProperties(display);
+        this.createTree(tree.extensiveForm[0].node[0], root);
+        root.assignPlayer(GTE.tree.players[tree.extensiveForm[0].node[0].jAttr.player]);
         GTE.tree.draw();
         this.switchMode(GTE.MODES.ADD);
     };
 
+    Tools.prototype.createRecursiveTree = function(node, father) {
+        var currentNode = GTE.tree.addChildNodeTo( father, GTE.tree.players[node.jAttr.player] );
+        for( var i = 0 ; i < node.jIndex.length ; i++) {
+            if(node.jIndex[i][0] == "node") {
+                this.createRecursiveTree(node.node[node.jIndex[i][1]], currentNode);
+            }
+            if(node.jIndex[i][0] == "outcome") {
+                GTE.tree.addChildNodeTo(currentNode, GTE.tree.players[node.outcome[node.jIndex[i][1]].jAttr.player]);
+            }
+        }
+    };
+
+    Tools.prototype.createTree = function(node, root) {
+        //  var root = new GTE.TREE.Node(null, node.jAttr.player);
+        for( var i = 0 ; i < node.jIndex.length ; i++) {
+            if(node.jIndex[i][0] == "node") {
+                this.createRecursiveTree(node.node[node.jIndex[i][1]], root);
+            }
+            if(node.jIndex[i][0] == "outcome") {
+                GTE.tree.addChildNodeTo(root, GTE.tree.players[node.node[node.jIndex[i][1]].jAttr.player]);
+            }
+        }
+        return root;
+    };
+
     /**
     * Function that switches mode to the one specified by the button pressed
     * @param {Button} button Button pressed that will activate mode
diff --git a/html/js/tree/Tree.js b/html/js/tree/Tree.js
index 27623b1..ada1053 100644
--- a/html/js/tree/Tree.js
+++ b/html/js/tree/Tree.js
@@ -569,8 +569,8 @@ GTE.TREE = (function (parentModule) {
     * @param  {Node} parentNode Node that will get a new child
     * @return {Node} newNode    Node that has been added
     */
-    Tree.prototype.addChildNodeTo = function (parentNode) {
-        var newNode = new GTE.TREE.Node(parentNode);
+    Tree.prototype.addChildNodeTo = function (parentNode, player, reachedBy, iset) {
+        var newNode = new GTE.TREE.Node(parentNode, player, reachedBy, iset);
         this.positionsUpdated = false;
         return newNode;
     };

From c09c71118999c6a9ab05cf8f407ad01c31b019a0 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Sat, 21 May 2016 16:17:57 +0530
Subject: [PATCH 16/63] Reset isetToolsRan property on load of a new tree

---
 html/js/guiutils/Tools.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/html/js/guiutils/Tools.js b/html/js/guiutils/Tools.js
index d4826fa..b3ca96c 100644
--- a/html/js/guiutils/Tools.js
+++ b/html/js/guiutils/Tools.js
@@ -7,6 +7,7 @@ GTE.UI = (function (parentModule) {
     */
     function Tools() {
         this.activePlayer = -1;
+        this.isetToolsRan = false;
     }
 
     /**
@@ -16,6 +17,7 @@ GTE.UI = (function (parentModule) {
     Tools.prototype.newTree = function() {
         this.resetPlayers(1);
         this.activePlayer = -1;
+        this.isetToolsRan = false;
         var root = new GTE.TREE.Node(null);
         var child1 = new GTE.TREE.Node(root);
         var child2 = new GTE.TREE.Node(root);
@@ -42,6 +44,7 @@ GTE.UI = (function (parentModule) {
         var display = tree.display[0];
         this.resetPlayers(1);
         this.activePlayer = -1;
+        this.isetToolsRan = false;
         var root = new GTE.TREE.Node(null);
         GTE.tree = new GTE.TREE.Tree(root);
         this.addChancePlayer();

From e557ed349577ea58466f314fa62a64ff264b974c Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Sat, 21 May 2016 17:13:44 +0530
Subject: [PATCH 17/63] Added comments

---
 html/js/guiutils/Tools.js | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/html/js/guiutils/Tools.js b/html/js/guiutils/Tools.js
index b3ca96c..f20b667 100644
--- a/html/js/guiutils/Tools.js
+++ b/html/js/guiutils/Tools.js
@@ -56,6 +56,9 @@ GTE.UI = (function (parentModule) {
         this.switchMode(GTE.MODES.ADD);
     };
 
+    /**
+    * Builds the sub-tree for the variable @node
+    */
     Tools.prototype.createRecursiveTree = function(node, father) {
         var currentNode = GTE.tree.addChildNodeTo( father, GTE.tree.players[node.jAttr.player] );
         for( var i = 0 ; i < node.jIndex.length ; i++) {
@@ -68,6 +71,9 @@ GTE.UI = (function (parentModule) {
         }
     };
 
+    /**
+    * Function to create nodes of the laoded tree
+    */
     Tools.prototype.createTree = function(node, root) {
         //  var root = new GTE.TREE.Node(null, node.jAttr.player);
         for( var i = 0 ; i < node.jIndex.length ; i++) {

From f83c808b8548368837890ef8251c068addeff8db Mon Sep 17 00:00:00 2001
From: amelie <amelie.heliou@polytechnique.edu>
Date: Mon, 23 May 2016 11:03:22 +0200
Subject: [PATCH 18/63] improvement of svg version

---
 html/2by2_svg.html | 394 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 394 insertions(+)
 create mode 100644 html/2by2_svg.html

diff --git a/html/2by2_svg.html b/html/2by2_svg.html
new file mode 100644
index 0000000..0b93d58
--- /dev/null
+++ b/html/2by2_svg.html
@@ -0,0 +1,394 @@
+<!doctype html>
+<html class="no-js" lang"">
+    <head>
+        <meta charset="utf-8">
+        <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
+        <title>2 by 2 games</title>
+        <link rel="stylesheet" href="css/2by2.css">
+    </head>
+</script>
+
+<body onload="initDraws()">
+        <!--[if lt IE 8]>
+            <p class="browserupgrade">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
+        <![endif]-->
+
+<script>
+    var svg1,svg2;
+    var ctx1,ctx2;
+    var points=[];
+    var svgH=400;
+    var svgW=300
+
+    
+    function initDraws() {
+        svg1 = document.getElementById("SVG1");
+        svg2 = document.getElementById("SVG2");
+        pay1_11 = document.getElementById("Payoff1_11");
+        pay1_12 = document.getElementById("Payoff1_12");
+        pay1_21 = document.getElementById("Payoff1_21");
+        pay1_22 = document.getElementById("Payoff1_22");
+        pay2_11 = document.getElementById("Payoff2_11");
+        pay2_12 = document.getElementById("Payoff2_12");
+        pay2_21 = document.getElementById("Payoff2_21");
+        pay2_22 = document.getElementById("Payoff2_22");
+        compute_firstP();
+        compute_secondP();
+        draw();
+        
+        //alert(points[0].y);
+        // mouse event
+        pay1_11.addEventListener("click", doMouseDown);
+        pay1_12.addEventListener("click", doMouseDown);
+        pay1_21.addEventListener("click", doMouseDown);
+        pay1_22.addEventListener("click", doMouseDown);
+        pay2_11.addEventListener("click", doMouseDown);
+        pay2_12.addEventListener("click", doMouseDown);
+        pay2_21.addEventListener("click", doMouseDown);
+        pay2_22.addEventListener("click", doMouseDown);
+        input_user=document.getElementsByTagName("input");
+        for (var i=0; i<input_user.length;i++){
+           //input_user[i].addEventListener("onchange",redraw());
+        }
+    }
+
+
+function redraw(){
+    compute_firstP();
+    compute_secondP();
+    draw();
+}
+
+function getMousePosition(e) {
+    return {
+        x: e.clientX ,
+        y: e.clientY
+  };
+}
+
+
+function doMouseDown(event) {
+    event.preventDefault();
+    //var temp=this.parentNode.childNodes[13];
+    this.parentNode.insertBefore(this,null);
+    
+    this.addEventListener("mousemove", doMouseMove);
+    this.addEventListener("click", doMouseUp);
+    this.removeEventListener("click", doMouseDown);
+    console.log("Down: "+this.getAttribute("id"));
+}
+
+
+function doMouseUp(event) {
+    mousePosition = getMousePosition(event)
+    this.removeEventListener("mousemove", doMouseMove);
+    this.addEventListener("click", doMouseDown);
+    console.log("Releasing: X = " + mousePosition.x + ", Y = " + mousePosition.y);
+}
+
+
+function doMouseMove(event) {
+    var mousePosition = getMousePosition(event)
+    svgPosition = this.parentNode.getBoundingClientRect();
+    var newPos=~~((-mousePosition.y+svgPosition.top+svgH-50)/3)/10;
+    if (Number(newPos)<0) newPos=0;
+    if (Number(newPos)>10) newPos=10;
+    if( (Number(newPos)-this.getAttribute("cy"))*(Number(newPos)-this.getAttribute("cy"))>0.005){
+       document.getElementById(this.getAttribute("asso")).value=newPos;
+       redraw();
+    }
+    
+    console.log("Moving: X = " + mousePosition.x + ", Y = " + mousePosition.y);
+}
+
+
+
+function compute_firstP(){
+        var P1_11=document.getElementById("P1_11").value;
+        var P1_12=document.getElementById("P1_12").value;
+        var P1_21=document.getElementById("P1_21").value;
+        var P1_22=document.getElementById("P1_22").value;
+        pay1_11.setAttributeNS(null, "cy", svgH-50-P1_11*30);
+        pay1_12.setAttributeNS(null, "cy", svgH-50-P1_12*30);
+        pay1_21.setAttributeNS(null, "cy", svgH-50-P1_21*30);
+        pay1_22.setAttributeNS(null, "cy", svgH-50-P1_22*30);
+        var maxP1_1, minP1_1, maxP1_2, minP1_2; // max and min off player1 payoff for strategy 1 or 2 of player2
+        if( Number(P1_11)>Number(P1_21)){
+            maxP1_1=P1_11;
+            minP1_1=P1_21;
+        }else{
+            maxP1_1=P1_21;
+            minP1_1=P1_11;
+        }
+        if( Number(P1_12)>Number(P1_22)){
+            maxP1_2=P1_12;
+            minP1_2=P1_22;
+        }else{
+            maxP1_2=P1_22;
+            minP1_2=P1_12;
+        }
+        if((maxP1_1==P1_11 && maxP1_2==P1_12)||(maxP1_1==P1_21 && maxP1_2==P1_22)){
+            point1_1={x:50,y:svgH-50-maxP1_1*30};
+            point1_2={x:svgW-50,y:svgH-50-maxP1_2*30};
+            point1_3={x:svgW-50,y:svgH-50-maxP1_2*30};}
+        else{
+            var middle_x=(P1_21-P1_11)/(Number(P1_21)- Number(P1_22) + Number(P1_12) - Number(P1_11));
+            var middle_y=Number((P1_12-P1_11)*middle_x)+Number(P1_11);
+            point1_1={x:50, y:svgH-50-maxP1_1*30};
+            point1_2={x:middle_x * (svgW-100)+50,y:svgH-50-middle_y*30};
+            point1_3={x:svgW-50,y:svgH-50-maxP1_2*30};
+        }
+    }
+            
+    function compute_secondP(){
+        var P2_11=document.getElementById("P2_11").value;
+        var P2_12=document.getElementById("P2_12").value;
+        var P2_21=document.getElementById("P2_21").value;
+        var P2_22=document.getElementById("P2_22").value;
+        
+        pay2_11.setAttributeNS(null, "cy", svgH-50-P2_11*30);
+        pay2_12.setAttributeNS(null, "cy", svgH-50-P2_12*30);
+        pay2_21.setAttributeNS(null, "cy", svgH-50-P2_21*30);
+        pay2_22.setAttributeNS(null, "cy", svgH-50-P2_22*30);
+        var maxP2_1, minP2_1, maxP2_2, minP2_2; // max and min off player1 payoff for strategy 1 or 2 of player2
+        if( Number(P2_11)>Number(P2_12)){
+            maxP2_1=P2_11;
+            minP2_1=P2_12;
+        }else{
+            maxP2_1=P2_12;
+            minP2_1=P2_11;
+        }
+        if( Number(P2_21)>Number(P2_22)){
+            maxP2_2=P2_21;
+            minP2_2=P2_22;
+        }else{
+            maxP2_2=P2_22;
+            minP2_2=P2_21;
+        }
+        if((maxP2_1==P2_11 && maxP2_2==P2_21)||(maxP2_1==P2_12 && maxP2_2==P2_22)){
+            point2_1={x:50,y:svgH-50-maxP2_1*30};
+            point2_2={x:svgW-50,y:svgH-50-maxP2_2*30};
+            point2_3={x:svgW-50,y:svgH-50-maxP2_2*30};
+            }
+        else{
+            var middle_x=(P2_12-P2_11)/(Number(P2_12)- Number(P2_22) + Number(P2_21) - Number(P2_11));
+            var middle_y=Number((P2_21-P2_11)*middle_x)+Number(P2_11);
+            point2_1={x:50,y:svgH-50-maxP2_1*30};
+            point2_2={x:middle_x * (svgW-100)+50,y:svgH-50-middle_y*30};
+            point2_3={x:svgW-50,y:svgH-50-maxP2_2*30};
+        }
+    }
+    
+    function draw(){
+        var P1S1=document.getElementById("P1S1").value;
+        var P1S2=document.getElementById("P1S2").value;
+        var P2S1=document.getElementById("P2S1").value;
+        var P2S2=document.getElementById("P2S2").value;
+        // Lines update svg1
+        var lines=svg1.getElementsByTagName("line");
+        lines[0].setAttributeNS(null, "y1", pay1_11.getAttribute("cy"));
+        lines[0].setAttributeNS(null, "y2", pay1_12.getAttribute("cy"));
+        var labelline=svg1.getElementById("text11");
+        labelline.setAttributeNS(null, "y", pay1_11.getAttribute("cy"));
+        labelline.textContent=P1S1;
+        lines[1].setAttributeNS(null, "y1", pay1_21.getAttribute("cy"));
+        lines[1].setAttributeNS(null, "y2", pay1_22.getAttribute("cy"));
+        labelline=svg1.getElementById("text12");
+        labelline.setAttributeNS(null, "y", pay1_22.getAttribute("cy"));
+        labelline.textContent=P1S2;
+        // Lines update svg2
+        lines=svg2.getElementsByTagName("line");
+        lines[0].setAttributeNS(null, "y1", pay2_11.getAttribute("cy"));
+        lines[0].setAttributeNS(null, "y2", pay2_21.getAttribute("cy"));
+        labelline=svg2.getElementById("text21");
+        labelline.setAttributeNS(null, "y", pay2_11.getAttribute("cy"));
+        labelline.textContent=P2S1;
+        lines[1].setAttributeNS(null, "y1", pay2_12.getAttribute("cy"));
+        lines[1].setAttributeNS(null, "y2", pay2_22.getAttribute("cy"));
+        labelline=svg2.getElementById("text22");
+        labelline.setAttributeNS(null, "y", pay2_22.getAttribute("cy"));
+        labelline.textContent=P2S2;
+        //envelop svg1
+        var envelop1=document.getElementById("envelop1");
+        envelop1.setAttributeNS(null,"points", "50,50 "+point1_1.x+","+point1_1.y+" "+point1_2.x+","+point1_2.y+" "+point1_3.x+","+point1_3.y+" 250,50");
+        var inter=svg1.getElementById("inter1");
+        inter.setAttributeNS(null,"cx", point1_2.x);
+        inter.setAttributeNS(null,"cy", point1_2.y);
+        var interlabel=svg1.getElementById("interlabel1");
+        interlabel.setAttributeNS(null, "x",point1_2.x);
+        interlabel.textContent=~~((Number(point1_2.x)-50)/2)/100;
+        var stick=svg1.getElementById("interstick1");
+        stick.setAttributeNS(null, "x1",point1_2.x);
+        stick.setAttributeNS(null, "x2",point1_2.x);
+        //envelop svg2
+        var envelop2=document.getElementById("envelop2");
+        envelop2.setAttributeNS(null,"points", "50,50 "+point2_1.x+","+point2_1.y+" "+point2_2.x+","+point2_2.y+" "+point2_3.x+","+point2_3.y+" 250,50");
+        inter=svg2.getElementById("inter2");
+        inter.setAttributeNS(null,"cx", point2_2.x);
+        inter.setAttributeNS(null,"cy", point2_2.y);
+        interlabel=svg2.getElementById("interlabel2");
+        interlabel.setAttributeNS(null, "x",point2_2.x);
+        interlabel.textContent=~~((Number(point2_2.x)-50)/2)/100;
+        stick=svg2.getElementById("interstick2");
+        stick.setAttributeNS(null, "x1",point2_2.x);
+        stick.setAttributeNS(null, "x2",point2_2.x);
+        
+    }
+
+</script>
+ <!-- Table for user to update payoff and strategies' names.-->
+        <table border="1">
+  <tr>
+    <th><label class="player1">Player I</label> \ <label class="player2">Player II</label></th>
+    <th><label><input class="player2" type="text" id="P2S1" onchange="redraw()" value="S1"/> </label></th>
+    <th><label><input class="player2" type="text" id="P2S2" onchange="redraw()" value="S2"/> </label></th>
+  </tr>
+  <tr>
+      <th><label><input class="player1" type="text" id="P1S1" onchange="redraw()" value="S1"/> </label></th>
+    <td><input class="player1" type="text" id="P1_11" onchange="redraw()" value=0>\<input class="player2" type="text" id="P2_11"  onchange="redraw()" value=0></td>
+    <td><input class="player1" type="text" id="P1_12" onchange="redraw()" value=0>\<input class="player2" type="text" id="P2_12" onchange="redraw()" value=0></td>
+  </tr>
+  <tr>
+  <th><label><input class="player1" type="text" id="P1S2" onchange="redraw()" value="S2"/> </label></th>
+    <td><input class="player1" type="text" id="P1_21" onchange="redraw()" value=0>\<input class="player2" type="text" id="P2_21"  onchange="redraw()" value=0></td>
+    <td><input class="player1" type="text" id="P1_22" onchange="redraw()" value=0>\<input class="player2" type="text" id="P2_22"  onchange="redraw()" value=0></td>
+  </tr>
+</table>
+        <!-- SVG1 for the first player payoff accordingly to player2's strategies-->
+        <svg id="SVG1" version="1.1" width="300px" height="400px">
+            <!-- Drawing the contour-->
+            <polyline points="50,50 50,350 250,350, 250,50" style="fill:none;stroke:black;stroke-width:2" />
+            <!-- Legend, strategy names will be updated after-->
+            <text x="50" y="40" fill="green" font-family="Arial" font-size="30">Player1 payoff</text>
+            <text x="80" y="385" fill="blue" font-family="Arial" font-size="20">Player2 S2 prob</text>
+            <text x="5" y="180" fill="blue" font-family="Arial" font-size="30" transform="rotate(270 30,180)">S1</text>
+            <text x="260" y="180" fill="blue" font-family="Arial" font-size="30" transform="rotate(90 270,180)">S2</text>
+            <text x="40" y="368" fill="blue" font-family="Arial" font-size="20">0</text>
+            <text x="250" y="368" fill="blue" font-family="Arial" font-size="20">1</text>
+            <!-- Upper envelop, coordinates will be updated-->
+            <polygon id="envelop1" points="50,50 50,350 250,350 250,50" style="fill:orange;stroke:orange;stroke-width:0" />
+            <!-- First strategy payoff-->
+            <line id="11" x1="50" y1="350" x2="250" y2="350" style="stroke:red;stroke-width:2" />
+            <text id="text11" x="80" y="350" fill="red" font-family="Arial" font-size="20">S1</text>
+            <!-- Second strategy payoff-->
+            <line id="12" x1="50" y1="350" x2="250" y2="350" style="stroke:yellow;stroke-width:2" />
+            <text id="text12" x="200" y="350" fill="yellow" font-family="Arial" font-size="20">S2</text>
+            <!-- Sticks-->
+            <line x1="50" y1="80" x2="45" y2="80" style="stroke:black;stroke-width:1" />
+            <text x="35" y="85" fill="black" font-family="Arial" font-size="15">9</text>
+            <line x1="50" y1="110" x2="45" y2="110" style="stroke:black;stroke-width:1" />
+            <text x="35" y="115" fill="black" font-family="Arial" font-size="15">8</text>
+            <line x1="50" y1="140" x2="45" y2="140" style="stroke:black;stroke-width:1" />
+            <text x="35" y="145" fill="black" font-family="Arial" font-size="15">7</text>
+            <line x1="50" y1="170" x2="45" y2="170" style="stroke:black;stroke-width:1" />
+            <text x="35" y="175" fill="black" font-family="Arial" font-size="15">6</text>
+            <line x1="50" y1="200" x2="45" y2="200" style="stroke:black;stroke-width:1" />
+            <text x="35" y="205" fill="black" font-family="Arial" font-size="15">5</text>
+            <line x1="50" y1="230" x2="45" y2="230" style="stroke:black;stroke-width:1" />
+            <text x="35" y="235" fill="black" font-family="Arial" font-size="15">4</text>
+            <line x1="50" y1="260" x2="45" y2="260" style="stroke:black;stroke-width:1" />
+            <text x="35" y="265" fill="black" font-family="Arial" font-size="15">3</text>
+            <line x1="50" y1="290" x2="45" y2="290" style="stroke:black;stroke-width:1" />
+            <text x="35" y="295" fill="black" font-family="Arial" font-size="15">2</text>
+            <line x1="50" y1="320" x2="45" y2="320" style="stroke:black;stroke-width:1" />
+            <text x="35" y="325" fill="black" font-family="Arial" font-size="15">1</text>
+            <line x1="250" y1="80" x2="255" y2="80" style="stroke:black;stroke-width:1" />
+            <text x="258" y="85" fill="black" font-family="Arial" font-size="15">9</text>
+            <line x1="250" y1="110" x2="255" y2="110" style="stroke:black;stroke-width:1" />
+            <text x="258" y="115" fill="black" font-family="Arial" font-size="15">8</text>
+            <line x1="250" y1="140" x2="255" y2="140" style="stroke:black;stroke-width:1" />
+            <text x="258" y="145" fill="black" font-family="Arial" font-size="15">7</text>
+            <line x1="250" y1="170" x2="255" y2="170" style="stroke:black;stroke-width:1" />
+            <text x="258" y="175" fill="black" font-family="Arial" font-size="15">6</text>
+            <line x1="250" y1="200" x2="255" y2="200" style="stroke:black;stroke-width:1" />
+            <text x="258" y="205" fill="black" font-family="Arial" font-size="15">5</text>
+            <line x1="250" y1="230" x2="255" y2="230" style="stroke:black;stroke-width:1" />
+            <text x="258" y="235" fill="black" font-family="Arial" font-size="15">4</text>
+            <line x1="250" y1="260" x2="255" y2="260" style="stroke:black;stroke-width:1" />
+            <text x="258" y="265" fill="black" font-family="Arial" font-size="15">3</text>
+            <line x1="250" y1="290" x2="255" y2="290" style="stroke:black;stroke-width:1" />
+            <text x="258" y="295" fill="black" font-family="Arial" font-size="15">2</text>
+            <line x1="250" y1="320" x2="255" y2="320" style="stroke:black;stroke-width:1" />
+            <text x="258" y="325" fill="black" font-family="Arial" font-size="15">1</text>
+            <!-- Intersection point-->
+            <circle id="inter1" cx="250" cy="350" r="8" fill="orange" stroke="black" stroke-width="1" draggable="false" ondragstart="doMouseDown()"/>
+            <line id="interstick1" x1="250" y1="350" x2="250" y2="355" style="stroke:black;stroke-width:1" />
+            <text id="interlabel1" x="250" y="368" fill="blue" font-family="Arial" font-size="20">1</text>
+            <!-- Payoff points-->
+            <circle id="Payoff1_11" asso="P1_11" cx="50" cy="350" r="10" fill="red" stroke="black" draggable="false" ondragstart="doMouseDown()"/>
+            <circle id="Payoff1_12" asso="P1_12" cx="250" cy="350" r="10" fill="red" stroke="black" draggable="false" ondragstart="doMouseDown()"/>
+            <circle id="Payoff1_21" asso="P1_21" cx="50" cy="350" r="10" fill="yellow" stroke="black" draggable="false" ondragstart="doMouseDown()"/>
+            <circle id="Payoff1_22" asso="P1_22" cx="250" cy="350" r="10" fill="yellow" stroke="black" draggable="false" ondragstart="doMouseDown()"/>
+            
+        </svg>
+        
+        <!-- SVG2 for the second player payoff accordingly to player1's strategies-->
+        <svg id="SVG2" version="1.1" width="300px" height="400px">
+            <!-- Drawing the contour-->
+            <polyline points="50,50 50,350 250,350, 250,50" style="fill:none;stroke:black;stroke-width:2" />
+            <!-- Legend, strategy names will be updated after-->
+            <text x="50" y="40" fill="blue" font-family="Arial" font-size="30">Player2 payoff</text>
+            <text x="80" y="385" fill="green" font-family="Arial" font-size="20">Player1 S2 prob</text>
+            <text x="40" y="368" fill="green" font-family="Arial" font-size="20">0</text>
+            <text x="250" y="368" fill="green" font-family="Arial" font-size="20">1</text>
+            <text x="5" y="180" fill="green" font-family="Arial" font-size="30" transform="rotate(270 30,180)">S1</text>
+            <text x="260" y="180" fill="green" font-family="Arial" font-size="30" transform="rotate(90 270,180)">S2</text>
+            <!-- Upper envelop, coordinates will be updated-->
+            <polygon id="envelop2" points="50,50 50,350 250,350 250,50" style="fill:orange;stroke:orange;stroke-width:0" />
+            <!-- First strategy payoff-->
+            <line id="21" x1="50" y1="350" x2="250" y2="350" style="stroke:red;stroke-width:2" />
+            <text id="text21" x="80" y="350" fill="red" font-family="Arial" font-size="20">S1</text>
+            <!-- Second strategy payoff-->
+            <line id="22" x1="50" y1="350" x2="250" y2="350" style="stroke:yellow;stroke-width:2" />
+            <text id="text22" x="200" y="350" fill="yellow" font-family="Arial" font-size="20">S2</text>
+            <!-- Sticks-->
+            <line x1="50" y1="80" x2="45" y2="80" style="stroke:black;stroke-width:1" />
+            <text x="35" y="85" fill="black" font-family="Arial" font-size="15">9</text>
+            <line x1="50" y1="110" x2="45" y2="110" style="stroke:black;stroke-width:1" />
+            <text x="35" y="115" fill="black" font-family="Arial" font-size="15">8</text>
+            <line x1="50" y1="140" x2="45" y2="140" style="stroke:black;stroke-width:1" />
+            <text x="35" y="145" fill="black" font-family="Arial" font-size="15">7</text>
+            <line x1="50" y1="170" x2="45" y2="170" style="stroke:black;stroke-width:1" />
+            <text x="35" y="175" fill="black" font-family="Arial" font-size="15">6</text>
+            <line x1="50" y1="200" x2="45" y2="200" style="stroke:black;stroke-width:1" />
+            <text x="35" y="205" fill="black" font-family="Arial" font-size="15">5</text>
+            <line x1="50" y1="230" x2="45" y2="230" style="stroke:black;stroke-width:1" />
+            <text x="35" y="235" fill="black" font-family="Arial" font-size="15">4</text>
+            <line x1="50" y1="260" x2="45" y2="260" style="stroke:black;stroke-width:1" />
+            <text x="35" y="265" fill="black" font-family="Arial" font-size="15">3</text>
+            <line x1="50" y1="290" x2="45" y2="290" style="stroke:black;stroke-width:1" />
+            <text x="35" y="295" fill="black" font-family="Arial" font-size="15">2</text>
+            <line x1="50" y1="320" x2="45" y2="320" style="stroke:black;stroke-width:1" />
+            <text x="35" y="325" fill="black" font-family="Arial" font-size="15">1</text>
+            <text x="258" y="85" fill="black" font-family="Arial" font-size="15">9</text>
+            <line x1="250" y1="110" x2="255" y2="110" style="stroke:black;stroke-width:1" />
+            <text x="258" y="115" fill="black" font-family="Arial" font-size="15">8</text>
+            <line x1="250" y1="140" x2="255" y2="140" style="stroke:black;stroke-width:1" />
+            <text x="258" y="145" fill="black" font-family="Arial" font-size="15">7</text>
+            <line x1="250" y1="170" x2="255" y2="170" style="stroke:black;stroke-width:1" />
+            <text x="258" y="175" fill="black" font-family="Arial" font-size="15">6</text>
+            <line x1="250" y1="200" x2="255" y2="200" style="stroke:black;stroke-width:1" />
+            <text x="258" y="205" fill="black" font-family="Arial" font-size="15">5</text>
+            <line x1="250" y1="230" x2="255" y2="230" style="stroke:black;stroke-width:1" />
+            <text x="258" y="235" fill="black" font-family="Arial" font-size="15">4</text>
+            <line x1="250" y1="260" x2="255" y2="260" style="stroke:black;stroke-width:1" />
+            <text x="258" y="265" fill="black" font-family="Arial" font-size="15">3</text>
+            <line x1="250" y1="290" x2="255" y2="290" style="stroke:black;stroke-width:1" />
+            <text x="258" y="295" fill="black" font-family="Arial" font-size="15">2</text>
+            <line x1="250" y1="320" x2="255" y2="320" style="stroke:black;stroke-width:1" />
+            <text x="258" y="325" fill="black" font-family="Arial" font-size="15">1</text>
+            <!-- Intersection point-->
+            <circle id="inter2" cx="250" cy="350" r="8" fill="orange" stroke="black" stroke-width="1" draggable="false" ondragstart="doMouseDown()"/>
+            <line id="interstick2" x1="250" y1="350" x2="250" y2="355" style="stroke:black;stroke-width:1" />
+            <text id="interlabel2" x="250" y="368" fill="green" font-family="Arial" font-size="20">1</text>
+            <!-- Payoff points-->
+            <circle id="Payoff2_11" asso="P2_11" cx="50" cy="350" r="10" fill="red" stroke="black" draggable="false" ondragstart="doMouseDown()"/>
+            <circle id="Payoff2_12" asso="P2_12" cx="50" cy="350" r="10" fill="yellow" stroke="black" draggable="false" ondragstart="doMouseDown()"/>
+            <circle id="Payoff2_21" asso="P2_21" cx="250" cy="350" r="10" fill="red" stroke="black" draggable="false" ondragstart="doMouseDown()"/>
+            <circle id="Payoff2_22" asso="P2_22" cx="250" cy="350" r="10" fill="yellow" stroke="black" draggable="false" ondragstart="doMouseDown()"/>
+            
+        </svg>
+        
+                                                                    
+</body>
+</html>

From d7208a2b7d29f03540bb764f3cf6f4d72fea258b Mon Sep 17 00:00:00 2001
From: amelie <amelie.heliou@polytechnique.edu>
Date: Mon, 23 May 2016 11:03:59 +0200
Subject: [PATCH 19/63] change of color

---
 html/css/2by2.css | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/html/css/2by2.css b/html/css/2by2.css
index 7ba260a..eaacbb3 100644
--- a/html/css/2by2.css
+++ b/html/css/2by2.css
@@ -1,5 +1,5 @@
 .player1{
-    color:red
+    color:green
 }
 
 .player2{

From cad4020d1e561083b9a64d8e78dc09e077003763 Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Mon, 23 May 2016 16:55:23 +0100
Subject: [PATCH 20/63] strategic form docu from Harkirat

---
 INFOS/strategic-form.md | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 INFOS/strategic-form.md

diff --git a/INFOS/strategic-form.md b/INFOS/strategic-form.md
new file mode 100644
index 0000000..3f3e0d1
--- /dev/null
+++ b/INFOS/strategic-form.md
@@ -0,0 +1,22 @@
+## Strategic Form
+The role of the Strategic form would be to convert the complete game tree (in which all nodes are assigned with players and all leaf nodes have payoffs assigned to them) into strategic form.
+The strategic form for an n-player game would be an n-dimensional matrix.
+As suggested by Bernhard, the matrix should be integer addressable rather than string addressable. To implement this functionality, the following classes have been added to jsgte.
+
+Right now it is being implemented only for 2 player games as they are easy to represent. Can be extended to n-player games after further discussion.
+
+## Matrix.js
+The role of matrix.js is to create an instance of the matrix that will be rendered to the Canvas when the user wants to see the strategic form of the game tree.
+It will contain a multidimensional array of the type strategyBlock which will be indexed by integers itself. There will be prototype functions that will return (n-1) dimensional arrays of a given strategy passed as a parameter.
+
+## StrategyBlock.js
+The role of StrategyBlock.js is to create an instance of strategyBlock class. The strategy class represents one unit of the matrix represented by Matrix.js. It will have parameters :
+coordinate -> array of coordinates used to reference this particular strategy ( the number will be equal to the number of players)
+strategies -> an array of strategies that are used in this StrategyBlock instance. 
+node -> the leaf node to which these set of strategies point to
+
+##Strategy.js
+The role of Strategy.js is to create an instance of a strategy. A strategy represents for a particular player, a set of moves that he may take forward
+player -> The player whose strategy is represented in this strategy.js instance.
+moves -> a set of moves assigned to this player
+This class will also contain a toString method which will output the set of moves in string format.
\ No newline at end of file

From e3f2681133587e5775449f0513e2557e3cdad734 Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Mon, 23 May 2016 17:43:20 +0100
Subject: [PATCH 21/63] Harkirat's strategic form docu, start

---
 INFOS/strategic-form.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/INFOS/strategic-form.md b/INFOS/strategic-form.md
index 3f3e0d1..6b3075d 100644
--- a/INFOS/strategic-form.md
+++ b/INFOS/strategic-form.md
@@ -1,4 +1,5 @@
 ## Strategic Form
+
 The role of the Strategic form would be to convert the complete game tree (in which all nodes are assigned with players and all leaf nodes have payoffs assigned to them) into strategic form.
 The strategic form for an n-player game would be an n-dimensional matrix.
 As suggested by Bernhard, the matrix should be integer addressable rather than string addressable. To implement this functionality, the following classes have been added to jsgte.
@@ -19,4 +20,4 @@ node -> the leaf node to which these set of strategies point to
 The role of Strategy.js is to create an instance of a strategy. A strategy represents for a particular player, a set of moves that he may take forward
 player -> The player whose strategy is represented in this strategy.js instance.
 moves -> a set of moves assigned to this player
-This class will also contain a toString method which will output the set of moves in string format.
\ No newline at end of file
+This class will also contain a toString method which will output the set of moves in string format.

From 87fee7a60aa3dd10e5d4706bc326d2607b657351 Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Mon, 23 May 2016 17:46:55 +0100
Subject: [PATCH 22/63] renamed:    strategic-form.md -> strategicform.md

---
 INFOS/{strategic-form.md => strategicform.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename INFOS/{strategic-form.md => strategicform.md} (100%)

diff --git a/INFOS/strategic-form.md b/INFOS/strategicform.md
similarity index 100%
rename from INFOS/strategic-form.md
rename to INFOS/strategicform.md

From 0ef4642f435f15e4a74872eda1516c256739f0cb Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Mon, 23 May 2016 17:50:29 +0100
Subject: [PATCH 23/63] example .png of strategic form

---
 fileformats/battle.png | Bin 0 -> 6877 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 fileformats/battle.png

diff --git a/fileformats/battle.png b/fileformats/battle.png
new file mode 100644
index 0000000000000000000000000000000000000000..30dd6edb90dd5681b6cc43193e86468199648ccf
GIT binary patch
literal 6877
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
A-~a#s

literal 0
HcmV?d00001


From a23d335bfe8150829bf452232581b65bdf30990d Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Mon, 23 May 2016 18:51:18 +0100
Subject: [PATCH 24/63] definition SF

---
 fileformats/IMAGES/battle.fig       |  75 ++++++++++++++++++++++++++++
 fileformats/{ => IMAGES}/battle.png | Bin
 fileformats/strategic.md            |  47 ++++++++++++++---
 3 files changed, 114 insertions(+), 8 deletions(-)
 create mode 100644 fileformats/IMAGES/battle.fig
 rename fileformats/{ => IMAGES}/battle.png (100%)

diff --git a/fileformats/IMAGES/battle.fig b/fileformats/IMAGES/battle.fig
new file mode 100644
index 0000000..2590c24
--- /dev/null
+++ b/fileformats/IMAGES/battle.fig
@@ -0,0 +1,75 @@
+#FIG 3.2  Produced by xfig version 3.2.5c
+Landscape
+Center
+Metric
+A4      
+100.00
+Single
+0
+1200 2
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 3799 8752 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 11152 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 3799 6352 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 3799 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 6352 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 8599 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 6199 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 8599 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 3799 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 8599 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 6199 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 8599 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 4725 2205 6335 3815
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 8955 7425 9810 7425 9810 8415 8955 8415 8955 7425
+2 1 0 1 2 7 51 -1 -1 0.000 0 0 -1 0 0 2
+	 6345 8595 11115 3825
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 7695 3960 8550 3960 8550 4950 7695 4950 7695 3960
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 6525 5040 7380 5040 7380 6030 6525 6030 6525 5040
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 10080 6345 10935 6345 10935 7335 10080 7335 10080 6345
+4 0 4 988 0 16 62 0.0000 4 765 585 6696 8300 0\001
+4 0 4 984 0 16 62 0.0000 4 765 585 9096 8300 3\001
+4 0 4 993 0 16 62 0.0000 4 765 585 9096 5895 0\001
+4 2 4 989 0 0 60 0.0000 4 675 330 5085 3690 I\001
+4 2 4 983 0 3 62 0.0000 4 690 630 5940 5376 T\001
+4 2 4 995 0 3 62 0.0000 4 690 690 5985 7776 B\001
+4 0 4 990 0 16 62 0.0000 4 735 585 6696 5900 1\001
+4 2 1 991 0 16 62 0.0000 4 735 585 8415 4808 4\001
+4 2 1 994 0 16 62 0.0000 4 765 585 8415 7200 0\001
+4 2 1 992 0 16 62 0.0000 4 735 585 10800 7200 2\001
+4 2 1 986 0 16 62 0.0000 4 765 585 10800 4815 0\001
+4 1 1 987 0 3 62 0.0000 4 735 285 7650 3519 l\001
+4 1 1 985 0 3 62 0.0000 4 495 405 9900 3519 r\001
+4 0 1 996 0 0 60 0.0000 4 675 660 5535 2565 II\001
diff --git a/fileformats/battle.png b/fileformats/IMAGES/battle.png
similarity index 100%
rename from fileformats/battle.png
rename to fileformats/IMAGES/battle.png
diff --git a/fileformats/strategic.md b/fileformats/strategic.md
index a9a0cb0..ef07b29 100644
--- a/fileformats/strategic.md
+++ b/fileformats/strategic.md
@@ -19,9 +19,10 @@ form* instead, and we should do so too.
 Hence, the shorthand SF suggests itself.
 
 One of the problems is that SF is also a possible
-abbreviation for the *sequence form* that is derived from
-the *extensive form* (a game tree) and is a strategic
-description of the same size as the game tree.
+abbreviation for the *sequence form* which is another,
+different strategic description, which is derived from
+the *extensive form* (a game tree). Unlike the strategic
+form, the sequence form has the same size as the game tree.
 The sequence form is very useful for solving game trees of
 large (and even medium) size and we will use it.
 
@@ -29,19 +30,26 @@ So it seems that we have convenient abbreviations EF, NF, SF
 for extensive form, normal form, and sequence form.
 However, we should not re-introduce "normal form" for this
 purpose only. In addition, the sequence form is not well
-known.
+known, nor is the abbreviation "SF" for "sequence form".
 
 I suggest the following alternatives (for discussion):
 
 * EF for extensive form
-* SF or STF for strategic form (also known as normal form)
-* QF or SQF for the seQuence form
+* SF (or possibly STF) for strategic form (also known as normal form)
+* QF (or possibly SQF) for the seQuence form
+
+Further common abbreviations:
+
+* NE for Nash equilibrium
+* SPNE for subgame perfect Nash equilibrium.
 
 ## Definition
 
 The SF (strategic form) is specified by a set of
-N *players*, each of which has a set of *strategies*, and
-*payoffs* defined for each player as follows.
+N *players*, each of which has a nonempty set of
+*strategies*, and *payoffs* defined for each player as
+follows.
+N is a positive integer.
 A *strategy profile* is an N-tuple of strategies, one for
 each player.
 The SF specifies a payoff to each player for each strategy
@@ -51,10 +59,33 @@ In our computational setting, the sets of players and their
 strategies are all finite, payoffs are rational numbers
 (in the theory, real numbers).
 
+The strategic form can be considered either as
+
+* a primitive, that is, a given game structure on its own, or
+* *derived* from an EF (extensive form) game.
+
+EF games are often converted to SF in order to study
+concepts like NE (Nash equilibrium), or to compute a NE.
+
+### Names of strategies and players
+
 In order to display a SF game, players and strategies should
 have *names*.
 
+In JS, these names could be used to index the N-dimensional
+array that defines the SF.
+However, the order of these names should not prescribe the
+order in which they appear.
+We will therefore *number* the strategies as nonnegative
+integers (starting from 0), and keep their names separately.
+
+Players should also have names.
+We number players with 1, 2, 3 and so on.
+Player 0 is the special *chance player* in an EF game.
+
+The following is an example of a two-player game.
 
+![](./IMAGES/battle.png) 
 
 The strategic form is a table that lists STRATEGIES for each
 player (rows for player 1, columns for player 2) and the

From b4e0746fed09ad045ee66167b73cc23e28dbca8c Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Mon, 23 May 2016 20:05:18 +0100
Subject: [PATCH 25/63] display details for 2 players

---
 fileformats/IMAGES/TBcorners.png | Bin 0 -> 121510 bytes
 fileformats/IMAGES/battle.png    | Bin 6877 -> 7350 bytes
 fileformats/IMAGES/battleTB.png  | Bin 0 -> 19147 bytes
 fileformats/IMAGES/corners.png   | Bin 0 -> 7720 bytes
 fileformats/strategic.md         | 110 ++++++++++++++++++++++++++++++-
 5 files changed, 109 insertions(+), 1 deletion(-)
 create mode 100644 fileformats/IMAGES/TBcorners.png
 create mode 100644 fileformats/IMAGES/battleTB.png
 create mode 100644 fileformats/IMAGES/corners.png

diff --git a/fileformats/IMAGES/TBcorners.png b/fileformats/IMAGES/TBcorners.png
new file mode 100644
index 0000000000000000000000000000000000000000..e9fe61759fa506d502a500802c03c9d0cf7df958
GIT binary patch
literal 121510
zcmYg%V|XO()^*4B#F%hm+qP{@Y;(d%CbpeSj0q-o$4<w#ZTrh}&U4=D`*n9!byeNk
zd#%0qs&FL*NhEkYcmM!^BrPST0sugL{)7a;f`2y5S0-OR8weK>X*F0_*p)5C&Cf$z
zS8**@RR?od4`XLDfQ7w-of*B0iL;rRy^E!T>jeZ*001BcNQ()pd1jqvd-$mJFAwIX
zt2U;RXUf1y!HM(yj9C2J^rLz$a&e`>uqq&eaHYbaO|$=Je%P4-0>>%R5iBGuf1H6k
z=ZeQfy4SiO2VCa(w<RNVrGpnq0m?en9M*%=rKfC*eO%{Zaf?79VpLd2@IawS=y##g
z^49e{8uzyTqnd`qnU&3lr=L@4DXE!ebs0a#L_Ys2g~5#;erALJ&kg_F_d?w^T3*w5
z4Oqj6ZqZ;#UDktoV#u6JNE-hNtD!c(^y;=mXA187Bf5@;7pQpA?)%+^RKPIrPdiWX
zQ8rCcx$}iVi+g56<{$LWXTjs5Jv1Qw`{bW*@kUhBCAGVy`GGqMt%0n*<J%8@Yig&B
z(yIxlYYi}bZ+MMScq~4*NkC<3gQwx24l**}xX6)9&5Cpm-zb|l=e1c~YU_B_%Ug^0
zi!}FtiN4#{$`GTT(iTF5qO31){AbjkgSeLzX>-p~OY<0c;^bKqsGF)aStwpMBDNeY
zzx`!%yo!n0(9n=0#PlV4z!tvYXv;?vbQoyDBJx)_RAGvS6I*i*kA>yoj9Tx<xcU-<
zriH9FeF}+qkiT{-+Z$;=eiQRRC6=ni3c72=xULLDcTF!t)(toyz;MB?s=R7qd{_n;
zHum(s2PTo%?Wh*pU;76>aki>5tKbv``c{i>q3ZZr!0#*de;27HcZO0=@V#)fXss;>
zy`B4^lfJ66Eeqo3UUJ8GB$!J}=vY7irRA+sug08mI&0TXtj1W!#p{iI&FMP-d*Mxr
z;7eXA%4$<dT=HCayc6lt(o!}aCGdILU*OI5D%H?8J2CsO2faIe*z5@cca$DW+7H|2
zSSdUaW!h+(Z@Qf9&xar5)b#W}cE+J_aqrKqgli0Yxeo};v?D%VhC?p^T~XRi10QB`
zl))-8D`mzG#X_uVtM(pTsIzF~{aj3f1-0{Mv4?Li@<y-nj3%h1g4Q(_*tZuuyZwTx
zHl?FhRz?HTa<ST&BVn@|q>@Y6D%X(%D75wLueVPioMV|Lo6YkR+W+popXbog-$1VB
zES-1Hz4-7UwpI67knUec_+X;=sG2?|vpONb^2`_Jj|uUcs&zZ7X!LBy=io!y8!m?<
zi`RR!5u=M0kl4|bXI%9c+y=NpJ+(z(i-=_t=td(*F+^HVY*m*M{q_+{c7EP~rrpj~
zE;=XN-9#W>-hPi9FKfx2v<K#u%lH{YP%MSjuj7wqyRMd&Giqu=|CVH9BE9-0J%30|
zRw1aXJVmU1s=sJyre0Z2qn!>qKF%OR&Q)tS-f6VcB`@R8CVSlJ#;LAylTAoUHok!o
z!37PZ5{Dh$J^#^g>7eXN%gM}M0(HcT0NUPG530n8pR}P9=K_WJNG|6zobukB5yuX%
zo3HX*ss(>sZ`wjwCU1aRZtB7p_<f$jx(-nIZ|&>?@DqW7M+F5Wi$*QmA62-tFIXE_
zqQ4kJ5~hvIU|GGa*KnV-Q?%@aI0p9YPsBoGxGcHf%5MfoI{QZjsiRSoRQ+kuik^@0
z{Mp27AeW4&#)hlPDv%`dqc0%g)YX^FG^4&DH2RR9l)4)l!u{7dxN`m-Tb+yC&@I8^
zG`nTEk)#x>fZ5~zmd*YaFsvHIkZRim5paGZetg{cQL}gliqt)>Sa^|lmbjPzepC}h
z_OZCk%*I7sNwG!1;^L;eXO7!9m6el@vH%WSiJ}Ky{rp9PCU)+WWaK3pd{GoNr>Mck
zxcqm<n~LQ-0#L8l9t2H`&vNMw=U#H!EH3)_>;R>e6)zJvj4wXtg|3Ej^K~e|qn@D1
zua8O2#bn?@OvR7oBP^`Z5*1{A-(hQ4P7t16c~lam&$6xN&59~r#kP?wg&jIVREqV7
zU6*lD2h<haxY^4YN(jThL|W0g%yL^SHEq0l58*^k$4FjFJH`~X(ZU%4dkn&l4zgW9
z=e4yBHvYaQ-MT?ANLd_rue#=I<{Y@wf9CNu_}KT}T;z;o5KR<L@Ou0lj4T7$^9yy=
zWl+Nz$9j?Ows0UsD$N^+XZ|SvDp=h_34uUTMhaBQR39I$Iff%@BdS5t(SLURV|@|@
zATG~58TAm$bVgs|YVN`!qwh?xThqBh55x(^Z;zLPG~Ef{`$2csq*GqLE@0C-Y?|Y{
z@Ma<zOUKA)SBn*jOxXFn;P$ZQYr}-&eRlWMy1tKJ^aXs8={cXX3a9vI=T^V=MAdaj
zxGJ9Wxs75p$Ip+pP<#Kf!rvcI53f5oFo2rU0d3Ks*@shRcbQX+K?~nUgO+ileXAT{
z+L}E+46*es7s?U2b)oLFn{xv2IfRmp293z$2x_zM8OdZacMb7>n>svwNBXB$3_4%W
z$3s^gAG~1p7ZD)=0Z=yX_ODh`ADw!JHcnigGk2neM2a<+?YymJ)&D|LYi7WBgI}+r
z9P{iQZn`GW#WVM3qC;9DyLJ7xBilhdE6X2TTu~QiXJ}-@+dezDWOg^NHw}9OTC1t9
z8tJ%@kSGZgA*m0)x0@Sh*ktl>>kO>uf&6$TfK=_a<6><s3ztPJh^E5Y{bCsjGCD-z
zPqOSaeo2|_%&>-m@=lFzr3NdQR;z1z|Mzt7?v~$1mM4wlR?F^ld)SOV4{zId{dNsl
z(fx?l5s4I#5{O^@_V%#(Uxy09j|h^}D7_cw1{W8`eA~$PhyM1b&2C;@Wr=>=UGq0`
zmI$^?S7;FusCn4cA2MnhIQLu<u&cBj*I^qzvRN}rlG{YM)-|yFF(q)F&puE%ENEWv
zd%a#&Y%B*6c+eC1Z`=&py#jgHSFD`4PBmQi@)v;I-p}HL{(J|K-gPrm)Rau5^K<O0
zzJqk2t2wV~bdlrZ4v7NmhBO!?p3UH$*p{1f?(Vz~;K$2lLS#uaF01*>z_x4oT?l67
z1-FCX(nm?Cxu4qpPBc&AyjMXLhP~Hb^=kwE#oC{%p>>8hG4f6(_OFhIdlp38Rn^hQ
zNGmCR*CXv;$$2YLaG@0hPO1lE2op?#E#Hd23i^0$vCJ9Apto4q&NOGa9#P1qP*OEG
zsOwr3E>DFbD;92aIIKAdx!|Aovz7p>O|>)GnHrsJ#3?Z2z4?rFn4TRD<a3z*7^WNq
z;d;<<G}~HP8)>J=eN#2w5U6f{j3S>pY8ta-!EtEa!W(ENpPJThGu581=V;=QAqfZ)
z?BMa(_Fafl3DxJa8_J;cpTDVYaji$|dU#vq<Phh+<^TQ@LP+<m?-nNIF>XYo!lqkS
zb^;gcc|X#+q#t!ZVFEi0GKhHqEbNa`sCMlN;Sm+T?N!unW(AoLDMwwxPW_>pNa1;i
z5ErT`ETGRw4W58z<Qwt$1?_FZNLZl+LTz*<#>*}ah9c%pz^)anIJjRlS+Z%WXk%J7
zAefa<$li`*28YC2V?!?!3{Woxsa8N?(e((_6U@In(yn&6mEIp1CW@ksT57HSpILYZ
zJg<vq$*dl5FPd@hj*YTN#$>b^2?Kk2Fk%D+m@{qb%wh=KhSF2TvH2c;P3(Za3USLy
z3WfB<XPvITzabz&_g|o>scSAQ%=fd&&)^aRgtZf>iXzHQ+w{CzynJ77N5(<xe_br(
z?V^{Gs%Rb;qHw#77Qe#we{^hL%cAh!ZX(MTnS9J?>fhfj2&!qMIDw+S?eJdsI^M=h
zX1Rbi&NE&7GaAh-+N{gV2cvNd@YDcCQ6vF$?9rxhxRW0NNcfz1I&kk=Y>hS#=UG`<
z@|hl{W<2`ZAWv_p)cVsP1$=_%ttvNU7&vAMROVRzopuBTekKGX-T}qvX5aX+M29S|
zjH?pP9N)6e&Bw@z=Cl3Hag^6h)xG&6PX0^%S?@=7RTz8k>v<TToe!@SGs^1rvooDs
z<LzYs;pe-uj}&vQF=Ie_F!h!Ht=IU}AYtlXOE4CG5eliy44w&gO#=a+MI}I9l4Hyu
zf$wbN886>?tL8z6--CYL$8+k8Vfw@I^4*Ea-^IS50S79B)PW?=9=7p}lRTqzpRKE}
zAe};-I~*xx^U1xy8HI6}%Vs)LQ6Wh<G;#+~CW1>F0#or}7n<6sp8x{P>OqWfG4=s4
zA&um9Txd0Xh#ad`oM`S6`Ak#2`>C0WS<ws8cR!F9>+fwtMh9r|VvY{eDcTFofj>dt
z3?1kDXGD1~o=Zoz!%!Y)nvhog_-8lGVTH&`<ej+b@Tl(Ya*UD?$C~<Jp@{F0;)RHH
zk{rT4+6Gkhyuo4lQl@G8Qx2+@>2c=}Efm;N;;*Ah$0ZQ4AgXn5FAh4Z4**>adA6!Q
z$9Ah25~Hl$LkiY&pXXW3%H|Bl-DZ<La?;hW=N1rheVazkGzhKf&RVbng*MNB5czBg
zDvs3Z>8q~jA*0z?+kBFDH+|s2dg!UUDsQ6L?!3**czQ~%L6*lQS!yghk>^rT=<kc$
zUOGT$Zf=g@wySA~k3=XOAc>ii@9G{2(4A|(arty;LP?Z{<P3cHsEcp&wLJ`1oycJ^
z4^V}U;!x8}@)7*Fs~%C)9c*Rj#(60``M8iu)t}<0*y#A^$)qI@tz4dfc|Y5?LB2>e
zD+a`8$OGFSMt)=l1s0369PnLla|3E@y4~u4Tg3vE=s<C+i4_^-JeQyn0TtKlSzs<#
z<D`tqovxqfN3=((MssbghM?zox-wE1oBO_MQ%uTZD<wll-8V?$3h3nh0h>hukNrQ@
zt8yTL=M?URD5fZZ{11PPKTVm$ei?{V2_2`jOO1mH|FU1-u#F5T0F31vOjOpS#Vh&J
zcPBG*kpE8fmC1mqnOU-?n(boqRa!wze$oh*Z0=PeGL?Z>*GTf7IVC^{uV6V40%m{L
z)Fz{If5FYbL6nLB?pIHgv9NFs>1dWo(8R^nEN(QkgXm|hHl4mjhsS2QnFq$v*3sTh
zH(s|13ju?Kr=m8ycnJ3PyGWO750)<*N9$X`QKR-p)=gJI*r6Tls>j0FC&&1h{BWZI
z{UINXC?Aj?8W|DU-NT%N4kDFh0ZVf|6a#1hjf18pztjB5FHfL@==y<R=zp;GQK{E~
z4gg4ze{m+{XPyA=AE_X*oFWPH-;|bN$5!ayKGKSRG%td6p_#1aS*6S<9`0%Te5_7*
z1pY4EU0R<Q=Q?`)`E_62+;ElVE%@gJHV*O-vYn5ce)d<*S3Q?y5?{o?a)FO#qe;-O
zrex<T8F*4aUbk(f{<G|!wj|;Dk8aI%SWegWZ3ho+b*eAW0kn+3$G9NMJ`7xNQaSGX
zL!eG&o%zPm&5K6$yW8sGRK#~vIbFkc<JloJ9#QFIEr1KZ`S@SqKcHOy(-xCX9}^c?
zd1OOT(JgJxs7V`<h#51Iu}~gP&$ak`Rfcr$o<jjF*rdvL)Atj>(@U8~TSW-mAKl{?
zu_u`qN?=SiKj!=oK)SkLC!;k0aZ-!+1K97}qA6xU-8edR+<I)@5>u$O8{b(?h9w;?
z@}w|L@;p0P+)w9%Zf-5vop*x^9dtWTSdcp&r*4qP)WGuHPC7kr`cXI@U2isRa+@0*
zuWtS6Rcikv`?+Rwz06Tl)K&Y+57$eSWnE9Z%o1v}G^p#;)8y^G?=11cRQjEQo^-P`
zq`V}+K;71y&KHg2ZKM&(CADHqBH5jm>w-BQHj~GL=bpa0h%Y6r4Sugfl_t5W_S_KI
zW9@G@GV%##srnole+Z;_CO$JKA}HLu#M&veH09@=7k(}?3^oK?F>U8<H}~mJPfr-%
zqBhiO|7J59l~Yf$Ni|eXOz7YAH55dfFt#HDx<1}q9Oh(7m7&14J#bOjJlS{e*2ONI
z<%gKAYgfz_8X=5C-5PSzGm{tmd!!a3BS+K_24mJIjefG5r|L&KGnsxNbU7ld_1JHh
z2XL&Njwt27L)*J*IfoE<-O>L|pV{aymJHl~cy<e$`z6)GNkZ~he2|pV-odg9s%f2r
z0znAnk<Dg4&x9d287-6D!PmEVG#)IWgkd_%key~p8yN{{Jy;wIcGl9xJk1Pnx$qcP
zZ(-o}s&`*iO*j8W%hvRtG|EpwZYT~}_bs7*dr5u4x57j}o!Z@BsRkKdH{)L!bv}c|
zUgprRF<B4+-<vG3k?9uO%jnML>f9^F&)id!Y_FamvbuMBk-4`odm|#CW#DpprO0dT
z-$ERKFUCvP$?;NS7dI$Ge3Qm?MH}#>_a`e4eLE#=CBeO0EsVf+-vfJ(jvtqsf!J9d
z?!X?uN?A9p8-IheALDbW8yqLO0MmJTPVC)-jgQL@b~ZLDnTVF)v!w-BEp2u6#iq+!
zRYko{XE$-LqA5#2fOM!rl9|`|azjW89+$w6>zKBKRe_Tf%nA(vfV7{AmLR=%^j)(z
z9I4An;$cBi@9HngE(vFUXbG$`A+gJ)k&W$5#5El+9JRv6JSMN>YmG1mMFz_nXkLRO
z4Fxxz(cuaOCmyr1bn8vw<E3!(fVH!-+APny)2D=5!YuiFso%`}<dG=!lHlu9MJb`j
z_F3IKyZ3C^7vG<cptcMBhuDfwa#80!evC=0LCEHJ3ibxyWV_PpVsW&{Tu@ib!cU|)
zxHj5MF%#9c;pH?q%$e;w_ES5OO?@jw_~5IF_RTSEHv)qPx0;>D7(V=ifXzT9Wp}It
z-;Fi(E$?+!8LI`3J@7!%0l;RFiw42!4tzLt;Ux=chx6z6IHtD+MKeNup_elQ#1%P8
z6bGUHG(vpJX9)eHnG6%43+J*Zw~mT5`+_i#<*c_cw5;ioHa3(|?WNNwjz}Zs@%lJo
z@^t}5YQ8kFn(yQ|vQf_8JgD>R;LPWB=yxMZlQXh1k7c3k%CiQNFfFRsIa}g<DiIo5
z{k%q*1Vu!!OcMG}SQexrKC%HcxpXYk@|mrQ%Rch5E-OS5BUSBevSAr71nrH-5JKmB
zv?V3CZ9+wZ<D}Q33c-wr{gDg+&J4O>X45HTfGlGx4gjnDEv7r~n|FY^x<Sq5TBbw$
z`K0JKpUWvq0F$Q@FzIe6O@z=SMEi;%^P?xjcp+8;jQH|q^oCQy7T0}sr}xhH?vkF-
z-XsY<9qW`joqOwb*gar#B6jV*@7gif<$%xGd*`R$Zdi1!+V$)Y(Z3SRmP}MF>F)EE
z-Y)Wi4i`@gGx*x?Nk_4UEQ?Ny;Sl?&vuS&TE+1a!Hwpd5b*4nFGrkrmLwEvXSN2u~
zGL?QG=PMf(yAh;jJl9fe+*5mF6rKE(xKrwEvFSV%2zjrSxDV}`BhE3|PqStagE=hc
zdqo=+5=0Qo+b<CTe9FIj!BY93@6F^t*j`^(S9t5_iisUM5rJjZI)*g=!({Pl0!<A+
z!#PXxELD-JmfZyHht-=sO+(*@UKDIY$H3s|lSQ=xW?G;_wJr91@bn+A{&MxCI4L&w
z-L24E|MPV7I&Q4UN`2jSyO(<@F6+M;@)9!vU~dD_guauHe+{Z1_PlNuD(Tnj{|1wN
z^AcMD<3<;G1rr3If@?&|FWeFG%D^Duux&P*VEaGay*?q>1MSQcZ@w#*A=@;j$tw!p
z^r&m<@i_H78bCdHthx9TqbemOnVdF`_wplvA(b1SG}>WeVjg7s7B~GiKDur;#Qvu6
z8PnU$SIO(45PZ#meig_Z$8(4;h$4P)p5FY%`THt5tGQP!jT_kAR+3c3nvrhz%Sb;!
zS_sZU>|q|-SS&`pp-3V1xHI=<cu^aL&x7Og`0IY>EYnp8MwB35!&O&>eXdg;S<Tg`
zrol6`TnLjg^+PIWSLr%(wAYvQzW^eq&C4&oJ!stLbZbz6PeiEDs4Vwr1M50+B^?Zb
z76jm^VO;M5jHsVeRNF-N0+-#s`qb|Y0pHCIw+}eIZ$MmjX%{Q$vK8Onl5aiI$#jxN
zAtv|*+P2SD3}5pHEdScQPGE$*KfLe#G0uJeVfXq)#H_y`e>B|qA>^QLa81xkg|W4i
z<L5CEHs`_Y%H}xVeg?wxx%a`mx_c!0)*%x0by(y^r#lnWCH;@9sSEs52A4FG=SC~<
zAyYBMr(#SJAn0*l#eZw-K^`|<e&Gz>PNz2Aknc(8q+H#&7?EfrGqtm^w{+m`05+hK
zk>6P?AW6eX<Ejr6dlZ^t#@Hn7IjWqSHLaO(`C}xMs0Ci@taZZBZ%dT3xh3kVHi9~|
z(Fp;pL7qU!*CwUC&eOzfk>|BOvSiIq{&8Ti@hG0@?6Hkt<BAG&zSaf@aOOLBwF1PY
zX37Vgt~c=d@%Fo{JI>rD-4(7wQxBNgkKs-MuU5<mx!4q!QO)oY`o`)fg?nU*tBn;C
z5;*HWoj5*LH4^SPoYNQ{_9}S5u9IZw`s-<B0sh9Z746rK=VAFqL|&V#>qr}(TlWkb
zO}Zto;Y~0VP?wyQ8#}J=dsKx2PMT7+wKCkP(~Qhpwu~0Dxc2rE+c)dQ?QkqJp%=nM
zY(U;Z3ktu#{S6GrKmj*Di_EIbpLvUXn@ugn+sztunrH_$_?y$9&27L$kj9<5^S#Y%
z(7m<#-%^GV(D<M{S3;3Xh9$j}4&p#G6p{NbcqiBYPQ9YvdA3lL8cc)=T?E#6s|MH#
zPO^5V=fv%C*%wrz@7Xzc;&m1c1$?cgLxr`@0HL8NCzOg6*=o)kCn7(M;+CxW^foX8
zpO-V(fg%?9Y-HQ{iUPhTXAgj`@65p4p1P|(2uVc#*P33$@~t2g!P{nj-1KzmBA!3#
zE=1u2bXW)gst9Yg^y8D0OipU~m3FKT9r_eUuGiHYMt#q%CyOk1XP4(bxSda`&~P&Q
z4Jj&`rbt>I%ux(5SNaoc9&U~GkF66!+O44qan9@!7Df9`?;wMBDy|h<-x<sXSBd6T
zk4LDUkIO|-tU$e07sbMwC#X?(W6{1Q6V;0gx?Fn8=VGwoD$s)*T|z8$EhOx!Mk1n|
z^gB5o6re!)ti~I1MA<EaSOwpBy$B)ob#I=PlFqaFeT*8EzzJN$RFxF(-entbMSc?Z
zEet6-v3B{xRz4Yb`r%gaamp-?ySuPYky;)#YZTe)G1r?UhcH!vj@>$%6H;?>NqgSG
zbdWlD@VaRnvGg-cBZz3R{xW4Lq#X<<+i86d#c<GEph?AT(UsV0x!C0vri=OYG4kE{
zvgR|y#hO=}lraU@gSXSt`}x83o$KQWTZPLyPv^<lsjIN`cd)&c+YuU=ijJ8xDg`A5
zK<o9ogoli`&qsHo?LNYS`|lUTT-SB=gYmQ?Mc|!DBpE8>Ni0R<{5Dp8aTFcqi2r+|
zr(_aU%!Gjsll!Z>>cEoU+Y)X1oWdGqyrY~t1z>30i9Oe(&}_4!@jUtqIF2yfvq(X8
zmRAyl&<$h~q7BH2Q&C^gWL;t|rM}3mmK-u{!g)XLRo)(yHXS#hm`F3jy=T31iw0d9
z!}k$_0bOpppy}Y-z`XqOX{xt&G0lhoKoWqmi%YUADSQ|^x9=ge-0*qn`nZ@smZ^r~
zTTsp;X;uI5IkVFXZ|v%`JOqF_x_x&TH*`^gK#=<6;OoyrxF>a7I;<Ioqlz!t<o}k7
zVoTv|_9$#Z#Yklo6!^@R%~C&FjdwQQ?>TMWbKvZ!GBOA&{2A6;abcn^)ZQpEWwAPM
z*0&jfG5z&QTzpPF!SQ6F7UrhJ-+enQe4Vap_bNKIUgsVJ-(5$fDeX5p3+jR>#0Yrp
zPlJO7zyhZ031wX<a20q-p@07FK<(-jdhBd-m>3>L4khdF@Ap_2xCspX=r9?)zlCru
zvK_W$k*>WxZhtz+{-II*(?`t5?|c+vF!n2_I~(aAT85YlG|aDJ);tcEPZ>oFlJxn3
zwn_1n$h5l6h13*$O4xwNQIWJvCvrU})68x|jIf4y2IX@$TEw}$eYSo17E9B!wkG>=
zAn5PO3?pYsXcHX`|IVqgc_RduBx$Bv*e|zd{DFq6->gOOBz+eTWck)i03mV$kv>nU
z8q4~fOKAeI(kbJgmc+#)%f%>In*2V;;{GTx#-sbM+lgVlUr8j|n5Rs>=H4w8TY_z7
zIRU_hq)Y@p%LIM3vCYTt2zCB`KA@iOxx?16yg+JW^X1KonR543``ZJc=i2bjLG^N1
zJ|26aRc0~7M5fP4^k7}}zTo{f2g)$-R&fOiGyw9u(mdUIR~5f=lHJojbMKkDtlu56
z6AgW(gVWItR+EXkY9q(QP;sB_5-vg6kC*8KLp+{yLk!Ah0d1o2JX3IhO!)i&eIctp
z1QU0(1iFZLvd?)2V7G0I=SIqEmC_=Y6BBUWy3=SZ8hU%Q(w5&&$2^UB(C)Ay0-##2
zxjO%G0TZyAb^3`7s9oz!oY4Xw8KR%rmg=u92fgbHf*cLNo1syVzVnK|hbP!QA9g}9
zBt(EgT@jwd7aYkfF6NVA!~Ci-{?60lKdm#=4xXnOtPgU5DSF76F+U9S*mK2`1vyUJ
zP2j<ZRa(npRtEP=0W~Kp9$3DH)yViB?@65!06^5QpNK*ue0g1$=PX}`(k_@Fbt%np
z0?2j%Mk62=%eLP3@<MQlTd<0j=hO#*4a{xg75$bzNu+Y<!eq6<c|#}=H~L(<nI;$@
zj>LO5zpj`tL;e1aH`n%+-Z%N$`rl&JDMr4z#ats&d<LFqB7g%2QBm;CRRwWfN?!i+
zta4plT@Y^U;LVbSVcK}{D#1d-f?jfNZtmkzI3<CuzUs^F%!K#q`N#VOM8R+~rIfQb
z@pnJ_^JZp~1ay29SYa{CjAN<ok77>pmxb|#JDMTjN4KPXy5Ed!b-O$6Z`R@srh{(D
z6YC0IGa{?G3{qP6wzFg}Gw*{>y}*C905^*KPkr%ZAua=gFWaLig73R=qLf%z_w<ak
zl=5adzQ=!|96Hu^Z6m-gol%<h%^W2HI3>1(yY?Nq!t{!~OFK<nHgC~(ycZl+%PRcb
zE}Q*kZ_coCHBwpD98`8;NhO1b5)?aJS#)1F57bXR;j_pBJw=nyXSw!f4UAwMw1db+
z2QxFkZE2{(CH)kRF~m+cs!;(WBebZ@oRlzt<Kxw^Lsu>U@fY}Fk^ngLe)9k=DOIY-
z+1FcxtFi?}_au6sMgkmR`oh3&>%1_nIxB46<1UE0jn_h%y)5RF(%&4u59XYTVY`t8
z7(MVL4t#?CW2Lvb&M&{9Msu4F8X5%ZmcC4}707*GC4m2dlmJ=(^y?S7ETl;o<V-yh
zF3pqpQ_anhN9RUaMYmKT-Q;4YHpRQ4;0wj=L?ZIn4CX2II#VyPeYUIbO|7>9r7of}
z72lPER?d>Y9M^06W^nJ}S{cDZ`$C7K(qPQDL(o~S9^QLW{93jha6Hx>ohV3N;bSsW
zGv1|TjDxMiysI;@vkDRhPZ{u_r(A&o$ogq>*dE4NsZO++%@abaGvh`BaAL#?l-&<b
zfe>8@6tX+qE4P5AoRrx53-Q!wRtQKxKeMf3p}gHWkJ#3i)Ajp;D!!eQBZs;A=G=q}
zt3TS;=f{avUrllx?;vif?UiW<_c8lg*Nkg}%AQy&%VHo+PF2r+zO&#(vj8?@P~Mx=
zOMFgZ0K2*`hL1yJiKC*$Jp&8Yko6H}D~@AEW~=hC69`Avk1s1Fz+Z?ul;A_UHd}cH
zBZv6=dQX#oC?itoUY~-GLUknN+HBU@<aZ)OOh$>CkH)i&t90<Q@99BJ{p;N@dMpRY
zF3Nv1wq2C8h8JY5rK@j1{BN6x0qwPh=a1FAe{Bz*X`V#>XH>j=xLzv@^eeA>g9Y&L
zv)?$a5}u=5)-r*wo-eItIqxuT?o6Uo?CJ8bN?KZnt~?uBHJ71ZQ=8Z9MZ!k+cx<Oh
z{^3K$xdKG7gSO0~k-{cAj(x`&#}vR<^bby2T3SIy#=i;0CVGuNb8Qzu|6aF`Lv^J%
z1zKMB6b7Gzx8q})m{m(Qkk{eV2jAO;|N3JrZWBmhqdl$oh(~pHw^<un`fQE&V`ifB
z(z64rV(B|O*<dujtZBMV<-C?!tTi*Bd9z2B4y$g7;Hy4s(qYwI!|kJSi>n)K3-lL&
zr-+=r7%>io(p$F$W@xTgKSi>G?*)kWJOOTC+`&&{z^sf$orjDAL-O($`%9r!39qKW
zJ8+E(m(w0L%kA{{Q-421EPa&ydsk?d3mgj!O6}vk!yPVlbm3I!1OH_W)(l{CJCcF#
zsc&aH{3`GP>L8a8F+`)%03%!iCC5{V4r@iZRn?;15GbO*U~_!T69qO7##O2TVQCx<
z7{T(o>+t|yYo+*V+Hq(>;7O2X>Da+{TiTBHOxPS`xxASzuWTeGyh~=gxcl9OPE>K?
zBXt*Jrd~aejwh4#Nj}mb-1IVXO}E@-I~)^uK_LSGRa4NhnWjYk%fjz=MGeL^_jq2@
zEuzCQ9va?Ui&0KaNilXbzl`o0b-1?bf%5i`e`g0-T{44{Akjdhg3rb8Tda)qan>6j
zE$fzXz0yQ&DX9iK)?r08*1t06bfEPfJ`<K2g6=OBnK*d5x$(Om7xPgtxjv=8Z6#ZB
zbrB@8JVBNXr$I$--j!ZP?Wd<+6v1Mu>mm`my086JiJ+FtYigH|HgTT)(>fT)6oE?{
zEfpjk?+wd=N6w9RCcEROjvsg4yWQN39na4hh6`vS15rd?duG@zdfKg3{x5HeSdr2R
z%j?i(4J<^S_p{O(0J|L<g!z>*=dgaP@t3XOm2WGou`Szu4i-MOl$4D+RT;*J48GUr
zk_rNDBc%o!`#0JlQAY)i`jLv13Oi77(5QMqYsu>09WHhfWI~1BGbmp>-p&;<H7a^L
z?tmyAB>K)HkMB@#kpSZ3ibZ8TEb&nBkFBGFXFcEZq~GZhbze#))S)xu8x-o}4i6^A
zF5LQ$Lhojdeg6_*RC#Z$!_a_uUec5ySibza7P^a}VIYYcz+Iw`78Mf<N%AUxO|v7L
zwfqYnuwPB1-?lsYAfSWG#v@vxaV~Jbc&a}dxkf)v;89f_48Z!27OF-NO<At3?#2J+
zdB-bAa+k;_Y}vV-3DCECer%ZH^Lh63qU0CVV{r$on%z`0L!YOHep_V8{B9*Z_gUZP
zrGtyN2Y-$Vb|Q2yMyfS+<<^StQzeE2AN<dyWDFgL7e#F}Z1OOG0j;Adc(Geg{6_ng
z;_~r2Azpz<k9FS-BPC36VKJbf=X;CAXB{xd@BZmF)Wz-Y{4^`eFr~_}q%R~o6H{DT
zh8!{kg-}IP^T65cn^t5*w^p5x_MCPi<%9mExH=V45p_2ljv%`^dzt!I{;N3SWeRLP
zk7o2ry}RxXMn76zOj;@GnO-3_dt$baivz-%oyryWziCU`t9R?NkyXIk&XNx-D(%;?
zOkF!HRWtG|-@ZPdjSLHq6HAW585D(3e!t84l?zj@vrr;uCN{4C!H@0H+S+SNwuG%Q
z0s-4YMZu4JtBk4}G#KO+wOT0d&=~jhEvbNVEU0>=D0C*-Eu*z^O@n*W^w~5q?kycI
zXoiYFrGC0Iy~j(4c!c8jyX9eX*py1Im+pnmvar0VWF^DVKps-kV=AW%{&JM~q`Hf&
znb-7#9bF3sOC~O80`KQC|2pLW$Fl)LtktXi1tS$Q*sDp~qeXLaHm$q6f@+@X$I;o9
zVkJNrlr^V%2t`ELm}z~AZ>QzV@JvXO->XR_vWAIDE~TM2GF7^cZc!#dK(q}TTEI+J
zk_8(uV);ib_fgVJomxQYkCTyybFZ_T(y1J!6z=gd2NDFMaY{wOy!W^KItRbWu=g`T
zLH~<P_FzdNg`05WziAfh*NWOHxI0i#UUd#{n%gB&PTDCK9WVDKIbI9|$W7{S-0#g~
zi3xZ=<syRvq<phv(r5svQR(^bc*vV<5bS$TYwCE@0`BM<+YXzE!VbPkCOOfNW+k>N
zcNuuV7_l?Ak?aRKe4!J;4vYC7!rK1%ErBjTS2ybA6V42dB!D=HM?Mda9uXjPAIi>;
zXL?m?8az~+WRsk)7VXTAerb&dL7X6WLl8nGMUBzhiihCI7UG+&BE{mA6ckSt8GKi~
ze@&;Rn%Ob)S=W!U%E+IV(_Mw$EQJJr*OIe27nKRurr?MahM+DjV>aZEFVrg`fxX`}
zxWjB%{9iso&_rozSwLd1w2Tv3;Qot=Ld>=!AYgtHwXAIE6B{?$-yhGz8jBu=7_3g}
zRTX%)9zWUbR7o!5^X^PX)j>Mt*9+VDANzccNBuM2m|tFZp7CcG?>4i30H60)fH_Xf
zsuO%b>$~II2Jel|Uz&zq+99lKHOAr1{Occlf*uR!`r+ZQ<r9pAtS|3C7=z}k4caf6
z6auzpM#!_8y!3#9ff@mVJt400P*H-ga+Or^Xyuk{SHR@tm-~4hIn<3-2~p9-i#ay^
zgd)96yuy1&uAKz`4VKeU-t*_uC>`5uUo`Y^v62lRvZCGLl3b_&B`Uhng!1w_`zOtd
z^$z<?-_(^IB7W;zc1?YbhvWr~KU(n$**rQyIU|S&dA}R@>q$_}qxP1g@qT}HgM6fi
zB!qaFZAMOr*<=RCK)KuYuQLFNUf4suDqA9X0CkclP4sS#UW5tk=q&DS78l;rRsM6G
z`w9~fBS|Fgo1bUu>7i={N4&`MIFE=!(bN<9d)zjyxl(+GfexS_C-c}E-dYjf35*>B
z(bSdG&D66>w6sQbTHpH;uA@W}_%|PpGCreO)B+jSahWKZa5HWayA2%`;x98~B*?_W
zDlzKQg$nI+D(bzT<FV(+JkP$lELA3pN#mm?67gAk-o5~SSdA~c)j4!f;K1`gysm1|
zEo)HhHk-ss0f+B}l_0>5hJFxr<_pF`_8R@g0Ry<xr}=%bd_|DX4u`yyEXnTFIW{q#
z()_O!_Fk|jerU0FPGc4Yhn?A>t0t>Q7@(xuT4cQvat35TLiJLwW-eBM^0&sXn0t=3
zsoLc6zZYbL7VZArJ4+?Ghqm!;7i}N4vJA)SN{-_VoP~zRe<g`(wZ<Ge??4B+jOR%u
zJXn!W5W=8oCrk=a3hO!@b@nB00#l9*kJ*9;g8KW;rLU<WBDG$OG#dymc%(8Lst$ga
zkF}u=-hU%TjHlDb<G=s_G<+XFA=gG9GRNnmk~5mM2A_VJfy=*==c#5#xlOAQyjg&^
zL8y4KW@@qp>&^XcN<+3v$KlhJ4{VNdw8Pcw#|`W-oM@|BI%SdX%=GBd3_dPIfGn4H
zwu0`wa(Gh9R(mDP>HFD$*%jimBH^x<?*kEpZrr|lSO`M(ekaF@8#<45ygh0aY4e$3
zhyQ9sfxKfmH24EP<#%n<EGH@GHgo`h-y9yB7D4$E8bTU>^6Fx>?DDmD2dnuy800BO
z#q4mLCJ?P@aHZZ$nli)`N#Nrk68OBEI5B3fS^`fKk&wQ1`X@fT-X0|Ovr|8p{~ek@
zikx0Npwb=;jf$eL?)|MqfZC*0VkYBb6)$uRx>CXV{gu;9`;(}r8nCdlvhG|_=0fel
z`Wrxvb?5buNgD9KFhU)!z22#!_<c!{#-Z-|swY_*5d|BJ8YCPI0})#M19}^5{R{5$
z+jW9TOwKAq2>icNH@^!4t@jH0ZQVUQ6~=UCBGgo3Vv;0N>%gn?ae<)9=7&RHJ97l0
z)(?Xc7l+-Vg_9holkB5|2haBMaveJU9h);8F>0KdES0F?0ir~)FcqZ(cRaD-RrzR8
z>)yV8+o+-69ea>5BX;nI@um?X3?H7TG$}(OL2?2m_$zK{g$sm`53Wx}TtO_)pOsUz
zfA!R_zc;gNGC<t17nMK5f>DWu0+eJh#T8c5UHpx9!yroD-(DZ9xQ}-1E<5j^Ge3>d
zBT@Zl$H2**G)sea<;yZ^_XVc&Y<%MV|4G6BV+O9g`Yq5}|7z9$X@0(8vGg<p>C_ex
zP>Cxn4?TcYs|z9j6Lmv^cV8qYBqZeL=lj};D-zSbEb&C&3(Kva>U_I>IPCit3|sdD
z(b!#41XkKbRp3AMo7R-8ox#Wr;y@!t96>*y*Sx|)(+!>JwJ(^M!!#s-fJq!NKEKIV
zY$HWSr{G<oop9U)mL^baWx0$kg}%-&9?dXFKv7XqcDeaRt<Tf-V<1x-466A9`M5d4
z|5hya@$KE$PGrHPZYd+y3?e?S2w)%SKFe5N>7bja!cjsJq#Nl905n)U{KEMEhw^1f
zh#FuuokXo}m+)PlC!p}QxS&rauPmexUYBa`(Qk*mGh2@qLC5CElm6SY#p>m!(Eb1J
z&lcB^-p1QBCxM3z5JE-AAQle&1~)y=TKv20i&a_R@1h4zYTc9csVjD1VVP+{7Ib)h
z$^ZcH_IxM%>Tv+drmj14_?#_t<HmmhP3W?O^c)OYDz1g#GwmHs#M76YY{iyIK1WOo
z&x~Ux9*<aFSgxi_E}pFZiw0i(i*$ThzErIo=C2X>WD1&5wUjb)VIMyhlPu<{6TO8N
zP;-@&yh$sFJ=%(Afvw8QTh2r$$_6j8UyH5S22X;lwfL_V8#;X3$(l_B=Tooow2bj+
zeFya<ugAHZ3IY%zc!@upsZBS0Q0-7nDxoo=URB*?H^dds8nikVfk~_K&Aprk&0YLI
zGt&JvHV5~NT)ak>HE+!ziuF@Mr2{Lq3&2V|TI@xZ7*Lw=3@G@ruU1^!XBsZUl59q*
zEMoRgmrKbpWUO{1(UZ+&C`e_={fMOj0Z~pMr3Gb+tU3wYG1n^AT|U1qH^P>fC>MPP
z8RM*zq2?Z~oEfL>tx&(GodhASgu@yM+ZhN%dHCOi*>S~`^f{G-ueQLcQ_m&)+DgJ{
z=C-98Uo%r19yWY*9v{KKxUE%9KOWc51ypDj-C0B{D9v4v#&g{tckKi}*7@V1KJ8-i
z7r8)s8?R8kCk4%;==9Rml!Gm;Q{24o5dAJAsu-W;BWn5Q6qk`Ji%=D*<p-;T%OuHM
zeZbiTql!?3%b>@TOQ&SUn9)cFtBAmnKvF{`eX_cPE;MdQF&gD!R(c%Mi~+Xj{_mx#
z60V?lGL{G`5||NgXTU5QuF-4F?~O_=aVei^4q+jYfWnx1s7bbShYi^j=fhlboKG!l
z<AQmUy1MR%JN;4GnnHIKXDMrCQ?=iN=vwDOM|R&ue{}l?*#OVyI4&tE-$@(19@pnD
zL{4J+=H-8GAn-dDxHsKKlTk7>i35<+_FVf!g!9xy;85ep(8<4W9|)!O!J&&#iG#Sw
zl9YA{xGBEGJCP@06b8Ex!ip1TvB4~eK=w%>Md>ZL(MU%O_pu?N!hyvA!U#UUS3r#?
zbB?MO-ybrGuc7Vj#(Mz!7Oj2`x0?LZHS32R=4#veDf<2LX_C5Ips-cbUFgNxo7kI3
z>N+{U#EJHZ^h7g*f4RHI+u6+gm-G9Ze=IG}CVX@>2Ui^d(jR>p?|VZI%+(5v3H5<S
z;j2W6AcCj@ym&vDX}AO~46ziqGcshH^DZPTm<;z$5-P|Q9yXZRLJE#0B-rsY;TIM_
zAhr4?3rB*ZSq2$E#xZKN%QI6(j&Iv&q)+G!JrwT(5CX;DG-KKG2pQ?6P{G)00G*a^
zKh7&t>9VDNukldcH>IudP)z+;;`xhkRKBioymIc|b^dE9Ts)x_8-2_k1O(o3xU#JP
z-}rt=Zp&Wn?-auIN}D8+cdu%A^U{lq!kCp{CAw<)ThK~p2;btLV1Eu#ID?JXeC5g4
zieJ7pJGJphutRr&pt|smQRHOf&pcLRt|al{x9tamk(bKs-}=+dv~Rex)RMl^{kr}^
z%Ogt~w9YrmCa83fVw+JIB5^K|60loQU|{fFaK8ieB;ic+k^nFg0gjMD5`aAA4N?lB
zI2DoYt4z2)4^9!Ws2_It#@=cwn29rJrB(Y`WENex&LHlcC@@LWKg!UoG12cvLd4@+
zd5Nz;X|hN2?8*5_pqqDSYd$aek^>v>aABXfj^@is<r;4t25bG?${M}L!}4k2t@%m@
zijIH%$0~W{xaDA>{qe^=nI^@aTp7xW%!Tu`k8302(61)pPv3E`IIWGDrP5s7lG6N^
z`|03Rit8zc68juuEA6mgr#&c7Z@LvTpohXg*g&-V1o03M<Vg_35b)^Wj&Ol}6!gM<
z%~TXD;-COj<S1~KBq~xz87dMf>AGjTRW)h`V|+6v=NMQ%g7|3Yf*IUDRU!l2CPO&K
zh`2jZBo;$lEFtpmTh03vm4yzh(jv4+4ku&T$Mam-ckM-@C~0eit|O<eQrhLC{g>-^
z?lw*<olE*4gUq!=iDGG8huXG+<nz2i$d-Tnw;x%yuM(xe7Viu1+!o$uM?rRK&$fkB
zO>W#Y^Ga{wlba<;KxRkR5DvgO8#NA=Sa=hF4w!s|w8YE3i3%nmi&*+zv!YfZ&zxRL
zswxdmthaC{rG@aT08G$P3_Lm$kqliZsv0h)EfcI>Ns2iWGf^9*P1&N0+X68&U#MW6
zDrhHtr>+cRp1ujS=ZrSE3SC*hO7O?PDMJbG*m+>$nR8uYR)xOxDUn~>(#u)&tgq`<
z%_ir_n!7pbKY2wX|AK~?wT+yWwZeL+pX9B(ZvH5-{yg>RB9UhG(eP;}h;E>?0XIV2
zgDa@ku%URzm@H*&79Lg>7~~Or)@60J#gyC<9l2nYO@egfF0&wO_m<B~hwOfO_cbK@
zblAks`l9+4-afiUAyGHqQme7xb!%N<i^8&4p`)CN3qG;x6E{IEpgihJb=d?>u!q8^
zQ;~)n3#K+zi`mNak=ya}B-}S0g@c%xUz#-)_6hC^<-B7dF$R#0H&*$Ua+Do)cZG(0
zM@H2)0dEdpDE@(IOA|ZUlfid`SJe7D(Z&V#CWqhucy<P)AooEgY3@XU<+dewYF))8
zrDu1MRfsHNYH1%hMhiS*aH(J;pAc4-kR<Q}HRdIFc)Fz}wS?wk$yK7fq=5(i1ghUj
zGU&f~QeDv_KZO9F2ek!?jFKDcfg|N1wJb(|n5o#<7+|2qOqIV$7t?9lE+~L-ETWEh
zSoo{r0-Zo^yEvSGJBBm?lOYOHbp<c%P?0j%N9-l1at&1VvQitTe)Oq9-!hVtDE}tx
z+rEsP&bux)tvxX0spj)f6}n%$Zgj-Y&KtPO%B-lYlj~bMkc9&$$5E>LLe-|p=!)v<
z2`R0&ON-pzDsP&;jk9-H3AC-$QeLT&1bu>A-htK01J$1J3E$-X%nzRmM-4mmv|HM^
zqyz=sqg^!E)`<BBtrI0JyS>#m4W2)&Z+%H|2({NclCWK<CSeCe{7b3^4AkZ1vSJD0
zVielNwSRD;8x1;aTfDMZtE|KlsFK6z`XAnl66Ch=(&CCCmYXqaK5;S-eaVtMc-D>%
z?g#(mDh&YO_$e-N=BkKXkbLtiw&KH@apNa~p(VngEzqonGW4$o#8Z*T7e$Mc89W_D
zPESwIAI!`595vN_QouS84+7e+CH^h}=9ebT$2Jb#SDdDAdl?o}%Kw0OLl|{8c=tN9
z-|ORlscJ$3I&fp-*Ids#^XA_r+pD1bd{XWsR`7r<C;7zE;3UA75F9C<Er;YrXYk}F
z82nBeVM!)WBJVMaL*qV(`ZPzGFmenKT%u6^C-Y8{$@&NHp+u8V7ivh5+D6*Pd!Idp
z=pX@;q{cS(3Vl0Uau#w286ja^T(J{j`*gn=?Cc>vC7VPisGrQ3bPVejG5b#HKjifi
zMzlTW5u?`M;K~#X5uj%ww@@|$n;Lh>q9p6yxU?7X<QuSfcm%aO1ja24IS@vQF~V&z
zYs92QKfkIcYfv?u{u@UPFlq9)bmQxvGPssCZ?^I_{`pk`k?<cU8X{6V-?||I@xMeR
zETEMlGGaa*yxdG6nFY_mm04Hzjz>A_C&`ocNLz!@zv5+onHYP2!vB}yesa-Y00~e_
zF&HPQiJHcrmX?Gm)T#=K1iE4LA*nbB(qwWaQ==?dbSS0+^QD)25TU?oN+xZEbwqIp
z(oDXxp_$p;^LAd_dRqF?;mm?=Ya%Lmm=r8{9*AN<PQjx7ci;)nf@_u4C+uQvpf<0(
zi2nQH&*uFP+XU8o!L$qjLkQGTMRq`i;gW)Yi?GmUru~ftqKa5@#4L{6Io*W;H!5XS
zPd9hHsynC_28lEnRc6Injv1%+`EK-Zrlh#A@cW&$s=a$*H@<sYAmDP~uFIRsba>p&
zVFUEJ-H;I62GWT(yqevz3Hy6Lzm@&mJ^$&2u+C?2a%O|k8u__(!VruSP+@t964D31
z1B`04wdsm~{Z!Kka2YY%49kLW7D{KbcQ&&?#zl-+w%CT$b$92T#s=`+-5L5^2FeX3
zv4VyOS^Bn}?cR@Re|-3n#A3Vh3&7w798Q%E?}2}MJ{NhDjQM&LrrzSa&Tyx^6$9{3
zmCXP8@)L9ws@F6}5J6#uPYwXgx)q<)PKEJA2IG@!??(+LGZRaK;$23x_Pc}|dqkrD
z8dDOP3=bXF3=f)5tY7ZLe)(;>H-Z~0Xg@lP>)iu~4}9#IZ%g%9ahHKriWq_|3MkdG
zi#K9F=3yCNubhJTb8=OFU%K&aCY8}}9jaq`=l_pTge|09Dz?anllIRCkCKjS=mYaq
z3$-8+A)AYx26_w_<0&?yz>l*E@}=}7!pRP_#mOo=yrCchAru8G8=l2M9?2;wU$8Y#
zm&GZ{YWzQ(Feo*u3=%6`z?BTzNxr}@ow~b740MsjEIyw#)wobPLuX-#z#e#$f3I13
z#l)1G`R6rm@(_K^mlX7LPypgx4{j8lw6(;~J|?jFcl>wCUKtLR9E)F%E{0XWg`dgc
zjK~4O|72)`l2A7hQK==hl>unnsirC1j(HTE3kUAl3Ib#CnVDKSti>nKuh@oqk7IS@
z1S)XifEdT_y9FYTV`^aMRWazPv>>)oi|*?6J}c|gxR-CmLxN@m4uC2I&WFXSRVg>)
z$#;oK3Sh%eIjkNi_HSZ%D{S+Y`gc>;Y_J;jgzG<UH*1^q-)Sk@ZzV2j@SH`Q{et|d
z5KkTe2M+!j3Ae^1$ib4DNWntvMh$1_)?Ty1Ai;a{MbK7U98QIw_@Q03_<yuD=5P1V
zR%yL10_|WWz+q8E-`8#!U*D>D2SM2g0dIq`B?+^OL`5B;DAhC!$VsXF@+1LrGp2R8
z@facjsNho6dr|#Jvfef9oEuG+t{$#&|AwENisBX&r9zi5-`-hDpX5<r-%IjFo%okd
zH7Ed1@{wVSIB1b%q|W4!feAn1Fu>jJnEOcJc(4FmCXD>=kFVS=w$L+2CAog@(VRxa
zlMh`G@i%Mz_$mI^N9~y(R_;6yQD0r|k`MI#eO<I^q<v9%EFTz0OR*9yO;D}+Eg^}c
znTyZ>+-$fhkl4mG|J(j+y#lx=gX&FbC$y-pFwQnlQsi)eI2UpPDy!M9U}9%YWi)Um
zP`B*}E)%hG{ClhIQV$H#X}|JxeXV?^Ld*T~zT#k()4<;a{g)$EMc?OL)h(^t25yuu
z(O(7qu6NfoG==}C1=z3E?)ZW4?0j1;ldd8{jS7!Wkwi+mMF96Z_|m+$wMFtht`zh$
zt?B!P0Or5uDMb6AIbt<^b|9TTo#DwJj@O*+oiJttG!HbocqEhm6(@}#9S#tp0<&C4
z4JRXkL_;kjx4=XShX&`dxPRpfT52!BIj9!ARcfr_HG4Wdspj3g9!+d-FmHRSt}~~u
zeLd>^2yNxKcz+r6dv&VA&|=18eZkb2Q-dfHqE4oWQuO>bc?h;|8fy$!Z*UM_x|b2F
zZXwK9^t4gPH;#*5=Qea9&gpJx(GKH>eL(tOr&6P6i3J#ksVtGEB&^So>F`Lb;Qd2s
zmczhh5twI(ZrDw(5T_s`m+rEWunYDL)+v<sGiD%5hLtSLA}a#*h?r)b$eFa(Ddu_x
zYOzIxvG47*rG6$Ho!|3>DK}hAMp{OKr+2D4+|LHT_72FK(P}zu)LU&{ZjI-f-(P6{
zKd!z4Dyr`bcN7IBL_k7PNoi>W0g<6gV(9MfjsZlvq#LARXer4->F!SH9J*(iH|p>I
z-dgXnxU&|_I%nS#JHGv$eXE@aW8W0S*?gkWW2gJ_-~kifvp8Dk+@3%KQI+==aanx)
z1+;eZGyTxvJ?R{gKe0G!2VI(L;Vud;PBPFfHB7{$aI)^G;oDc`2mK5?(uu=g=xeOB
z!2X>0hQ5UMK^U{)2O#F72TzQ;A7Jd{JYUx_Ufgg1w8z;)TlWjoiwotU+gVTJ8IIt$
zrN0?6E$SB*tOhNrBLxo6`{n5*SnDk}`+*N^`UW@fA4}(|#^H1qR|ZJoKSl*tFMmXT
zkc#g~`KsEsVx}zM>Yaj+94cfi4<h&vKYQh?b!RY<e<y*w(@}qN-wy8<-@Th!NR@c7
zNc|*<7VqO)Qv)6lP-S9{VYSb1Oga&T;w`@C@~*FUO%EGK3ZEZOzHCVFxiI~CjJ9BJ
zKgr0zRY(w+qpzf7)HG(b`Q<sv4<W31x8bG|MolgHq5TIv!&8oiHQu6xpF>&|13V7n
zs(T5HLt%#-mO^xbnaa8zm>*&Pp_=((A<s(PBrXrFgJI4=hqwy70k2{ad%<$c7$gAy
z=dT{&;k|qH82G4mYvZlF*f9TgnWbbdHdBd2V8ADg#3!$nK1`3ntTV=oA^qVGS*KV4
z{<JF6NpBL7*{y;xG5bxhM}EVtm6(D*La9rF=EeItZ8eEDHS82<1=Y+Q8SIKOeJKRv
zO%AdgZQMCC6-O9Oip;&@H1Qkaq&YK}G&2?Eqm39G1>GXPZ}zIa(*7<b`-m<)?nfA{
z)Wc3S&`}nb-{O^Ct5+rD)0;{3)hooO)sE5zofqMs5DqZT_qE(yd7a%_^5GMM30e!~
zO1HM+0<Rk=`S;xlDi#_AGF$hf`Gybrdd7&FZ5xVU$+#%~4?s`g2d~$97HnbeJ=$Fq
z{Aao3XSn7~dcC`;|8%*p+35pK@seeMc50xUOt3~`Lhth^9aqqgTG|{HLPE{7Y=+#c
z`!#m(+O}U-$1#P--EVfk)5^r_>sT6$m5U1cE5Y;Q4k{!rls5keSr>xJ%Ka<|dQ7H4
zph55`g4hf=i5`F@W+rA678)j<KmUoEdK|sOf1%fPDdMv{=9oM>Ekl8pi7HA=f69Rt
zNkzZ3m-|vBpVHnH+R?dnxg&>;rZxmJhX~Q8%z4n1phrF=cD^!a0k=t0C4kZ=Wcc`b
z!BSG1z>o%;rvs*hMUcJ4#X)Sm*59`FzK6t=ps9!=MdZ&Ak@th}O-1BVv)`7vL{HED
zvW=zTZz?MAHRSWuM@J;tN($KG{?ybO%{XvvcJ`(t1g9nf9U-8US7sxn@*ri6+F`+U
zHOrFy=N3a5`X5<cO?1^w7s!4ulI_F#bY}MMC4$v%3FXdc?wAF2xd=*_s$bKY8X191
z%>=n=H^alf5}@c5olpII3@wWJ-?yA~li4?Jw^#9S^%NrEIU${m@XXFe)LBA(==s4|
zxo8!#y_Ijp)BJV}t1^S-(X@s!X3zkG!dDLPBKu40haKJcWK(HQM_Re|`T~G$*`HCD
z`FF;Zj<n7Z>L14c2)Og3L<36p5D+V%`waw4O-KL*O_G)Z>7Pu#qo*b;b-6D{9vB$t
z`fcc!R(;tl49`KHZ%n#r-EW9Nd8@5wu3EN*`i!I?P5dIr>JZA?!AfLzUDvPC-s5I4
z%v|0I`}lNi4Rv%{60_^~$;kkF%c_pW=MNcNz&-Mk?@F8b4|OPz3;j~7E)Q+uPR1Fl
zVTP`i6DC2wCCsN<6`Dqz_igRSzO$j^1ORM4rUDL_+l^)&&KV<qw39p)GcFIWf`BrG
z{O-?X*$d2_+7R;gUJG|C$T@w)4lgg?vdhE~V!m={7<FFQ56Yh^3?C#GxhM%D)^FN`
z*b?x1tQLW-R<vQVE9Zk@1i#@Q4bY5-g7PHiG(bJmap6j(Ni4C3c}$LED&^(2egg9a
z>!$b2mEI=KHx3Kkn&q`c7ZDA!{_rwgRkC%wFjQg+05Iqnh<>1U>IzabQhv>o6j}VG
zK-tk|a>h7H>Ur>p@crh#eIwnQ7x2{X`J?MqjE=YO-S-AzLf-c?RJXC?r{f(!x%Va>
z`#ZCD;0xqjjeBJ=?5@yWCfTp6kw*W%|LgBQ3PA;-OL52OC=TFo(6mMozP!XxM)olT
zhOOb7z_{@&dh76I?ew3jK!6WW?A7+8XZ>yg^vWWWYT_xZB}}nO5SBq)dAVXpXbn>b
zgbPK2McmFDwcNq-OKYkx1(8G0l7s<V<TSFu+vA7Dk9Ikr%z60{l4^S-^Da>z-s?l>
zv&!JNRwR6i=a&@jvu>@g?QwBXx6q*f-p%IZ*W>IciV{4UBn>!qdoX-;BOv7M(?7BR
z_9w^kB=45Kz)<28S`b-u0KrSTgi2eR12yq8dPNFSiJ%C%<dKYb_vaIWZb!?mORjy5
zyiaVN`y65TZLPY4w^M0C*jrCAx$Ku}wxjQkknR}JchC6-Z-YXRTOq>m-(jrUp*z1C
zokx6rV+q#Vv9@~Mubq#*k&WQ$=FdBre56K!K_g}(XGUZZE+B?`|9<qZT!2wOQ7{Q>
z2`2$w$s00LUb$M2liccnP#TbO9i)Rgf*pEV0KIF*SiYz@6m-jHZ|~M=xVqfGT+Ukd
zoFF>_?~aLy8@sn&4#$ouQ8)RVtmP=)U({DupY~0tM^o?&T4^Lk;$#GOL!QS<y?sw@
z81!!MTc#C#tbP^Azy1yAMCpY&@k*2v{6W5tXHzx@k`c9o3K`*5<6p;r$+E{BE#BxO
z*VvaYE8GtkTLpKqbZ26aE65p<``zr4UTyG3NO|4%NEYJP%Kc$+|DyBAK%;X~6p0~c
zum(4GH$RB?MI?6V#5nvthe|8kXeji*#||&Xa#6;(4CC8F3~s2SU4m8$QeW05F%c@$
z;mHcHIBo8X_024vT>0G=Rf>2VS9l-QiDn8<E!QtKublkG#f!!2$Qya@yb;DAQ=~Z3
zdVcCa^6ar11&1abk!!aW9VgJuB_W|ALnJSUX3d4zVngp=zZ!{eDhto@A>E~~ZX`9r
z5_V3R*^hp#M>|+5fm9PfXj7+ykKg&4&G0ls?|W$`M&6&@@<DI57VOT1GR|ZM28#5-
zH@yUk8G@Ja@!g5_;V1$O(RS)zAG_o5!@hC^7r*7*>fdbSD$><>4dTtndKA&e;2a6~
zqv}w~&fmAh)Q%5wz$w+X&(-sEmO+8uD7OoX7{1LU17Z5b6tDxYHrBRvSgI&BH)9jN
zFHscX;PslSo6+;`z#)i_r!h7jY~dI2yIJc}VNhtf9hZ&R9)4UfUVO@H91>LxVWG|s
zewg!hGNqj}-N40Ucf4ROzNqtQDTJw}Z`!wR{^LI}f-i}>b~iNv<)u(;d}md=3*A`X
z$NVgb6&XTYO}6`|2jsDk;_$DbO06y%sjRXMhjZ?CU07VQvIE31ltQl8Qtz;t4ZGg;
zKqR=IGsf95aOse<#cAOY8RF5QEXiwL8&3<LMGe8TwUdI>2qx;>gATVvT7`zX21TMj
z0<;%$^6>Dinu}uCUh{mtJX}z>@2!aARKNQmDfCS`%uL_Y)M%THSK=3D3GRRllY}d5
z*5zhx5azwS6G~JunEcs^&SjXeQ~dQ@IBD#MsbUh46SZNn++dj;q>x|O4zr8dd_)Jl
zTTrEnPe}OsHKCFSm#b|bUxfk}-qLNM{Si#%Pwg@QplZx^Rc};yc?QLf1R<!~rN?;s
zp>n^+#}`v4I<)H(DpaLt1>$mVQj<rr{dS$RSG>+x)ejfQl9*AB1F;&dOWP;8H4UIR
zw+k(`g#7bjQeIvXQtEML^WniZxRa-$XlDu2J0*RpODs<DcxA~U=_n<&m08O7rhhtr
z+dCRS^i61YvH7*^Ngr+qYE1xv5F2cQFeVN%Uhp(CHJ)3tzNhC^{S29PrZeQD%$_kT
zV@Z>;<<^|NPKI#PMRz)VB^122muc8Y&c+&4V2UH=7@hIy(<?LM@~00$noS-j<0r&h
z`a;@TI<!+J{?*sQv$;T%NF_)G+Tck~{t4M>`UVBRgMpo0#Y*`fnE)C+^b8Dq4kjAS
zLuUhdw*#+AR(_Hnn#;CTepl9D()T*)oF=n-B0I3Rw!;j8FyTkxxWRrok7W75G>r#m
zr_^z6mz2rV-(cgCk%b2TK2<h#tmYPMcG(>tFObC#X38bSWs2^hEamL-txlA(P8Oxc
z{%>daPxZ0|Zg`V&5yb!Yptm^5^9{qUF}$3s;}>Xp&$nG#CwwoF_Zjh3ms;61v43$_
z#p^U*v3`uY<K*W_SYO7t4DjR0P>MYFFTTCNOg(f<uJnuyIluXyTZi#DQHze%+I%SC
z9VMT!lM|<N9z3g!<ZH00-Fzjnbkj>;ID^WS_UPTwfPpZXhb{Je%~-nGWNX(e_zQ}!
z!JFx0$ukmLg^1ha@g3`<lPgn$?5GExWa#@JGdbGZu((l&h!_X*J7o?AYH6J|59U~B
z^r<4TledX;f7!5&-ZFlNkoAG76VrsiMf{S$PC1*DKGo*;1UGLY0pw&~{1#Fh<PlcN
zOMJ|&e6L0%V$x&%ej()V?qTJ29k<Jo;8v-$7Qx-kiSZu4EXy0S^Ub>O8Hso^?B1HO
z!2hJQovdo(%VV#Mg3I5XvYUQgF+0CX9`N<CwV_O{7^B#gfK|>_QtlSgt4M6BnO=%=
zYdzFJBxnGEgEpZW8R>$)TH=AfUsEgNIV!Ai@0(ZSi}3RA%^zGvK*F8D!RCHy8PSPR
zrpBo_cQ*~8ap=H?s|P8lq;+2<`p;MJZ$C$xDXo=_E|AQ7D$VG%mkaFjX=CdaN>_S9
z;7sg$z927c5!7iZi5MI$uG>2mZu<{e*`i!e6bC-EDxd>bpp0ZwlamP}rMB3F!VatL
zA8_9CzA%>yPkw=!iO+>s&Cy2%?MZe)bPlX7!W*5}I*B4kiM@pgFZ$G!Ir!hT>x;!@
zLOOMZ7AT#Emcl|C@ta&8PEYp8TR1u4i(Gt*(SlPAny?@kUC)qnH^CR1$RM-@?8=^_
z1=4~QN)ZP6tSG&Eeu}Sr<`xq39}s7Q?TTZf*1;j!xv5Duzp`_yz>ifAcjZv?Modgx
z{{o9G!NoOk-D9v{A~h%_^&_Kh8f$b6ad<~!0iEkF8QQ&M{OI6|ThJGAP~tky=>kxW
zeu0{vTDd~HUd{&1+0k+A+lDN#u}#_6CU|A%PBFI)NyLj-xD~E9`5J+q+ApzkcYUF>
z0zKYXI@|KO=Q>{JUcra+7cAfN+g6jV+-2wb`f+eup}ux;ep0jp0IS?yt8gRba~@nX
zHhJbpG`U7}q-NgOjr5824a0ewUqb-iawehC8R;BBMxWl&??ny{$_-kjU^ACE8)`7B
zCnd{ZoypcDn=59v_?#vNrDDk@v$GEA>9uh-_-x8p-phD8=CssmXzD={k~(DOf(W-i
zo;)_8=Um*0AuXKDjQah}KrZL{f@^zxDa%(GHh#w0%ek(2Yr)3*DW{Y@&Qa9Yk2lWj
zyc)+9#~}XJ==pLp_AhJK=UEuPVkQD==fD~D_x3q4W4STtZxPDK`=8HxrDo2{@2*v9
zOIH%~E@x~v^=^!Bm-G0gYi@SZ=TbLjP5km`(sgQTKA$t7o{Tt2Hbjr#afU~*AtoA~
zS3T#jakOvn*RKf%1-1~wfZ53ee<j>t(VJ}U_V8mZd0F?}&I!&}$E`cn0lvR5@(lx1
z!FL6)nz5Z6J>ER_ruoPRa!?f&m3!knA;kFHcE6v}{r=uwa?;awo0NyS%8jSjVd^?o
z8MgS`@wT?_e66f94Ix6Z`!-WBBO_{An-nx^f}yUd)yN^k58(55z}}H{o@eFz7CVfM
zmn2`!us`DE9l3{yP6y6N+!LXls<?c(*TuHErTB{4*hM?-!ekT)CIf7`esxze%64%c
zXWm|;lM({ptEPhW=u-4mj{{asGy3l~U(~9PKQVjqOaF5HXp<Q~g*1ng7>E$MY`tBM
z<XLU}Nk+x<1X*-Y`M{IcYcBGfJu7~}bh&}YN>P0w$zEfr&`o<Oz3|TTqV%P&XZhu(
z_NWXO`o<he!1Jv(W?thDSy9W}G)OMP=iu-yvgt~7+54MagyI-Vzg+mi+k6iHedif(
zp50DAHb{O=Gaf$IKQ2mv?O|J670BtyBl5jrEH;W#KKXO=*s2vkK{3cQ)ptvkp4zs0
zHceaEqw7<~B3HwU>Xi}T3sXG;{pg9JU3%6>xKgV?u5n&%F4CpqvC87JY`2n<n*o%7
zTvbCmva)H5)yYvWH_Xw7X1@%fHmd7<WLxbc5%Ig(NS_sBh<eP>j;UdND^a~8F*LRf
zyi}GB)xBM%kFs<c8iou%ly|H@SDH|}a&87q6DqC`O5}Z5v}h|GQb+uC2mFP1?ot*A
zUGsvXDjFf)n?+D9$7b)(@QO50?4A&?Bx^8A;?n8xgr|t7yOHzAYWP2&u12ltgBbK0
zpc9oOSC)T&MvsW#xrlXI7%RFEbEv_(<)Xc^KzP=ydGY);u^-gymNPwA!}xrY>7Dhb
zY~}oly0qBetzfLaQSBDjo%Xn7K5150_n1QWP4fLdOg?w)OixWu7fs(ZUd--R_$)(l
zAibx3cp}v7yqVAfJuSfO+sprbbVKM87Y4t`fz8bY_qUD`ZDxkrceS^1cO<a*ApTb7
zW<<(#q@+}>zj@s4RvPp8IZ3ezvAS}89e>K<S0!OW7ZVe$CV7GN=N2KFV-OMaF~=a#
z=o7Zhr>da#N1~tJkXV=30XH%TwtvZp{~87TdRz9xY3G*{D#qND(J1+{=~STVlsIbt
zrNF6C6{Rr{MFm|2vfCq2mkqLlAn`35sqVK1e@8*1S<S3=Pqo*^rP7D60amN5Ym1`a
ziNRX;Xf^tJa;nD!SKwQ3U9iruB4h`;wa6Y#Kcav8CmJKMM*Wh_zN!k~=}v2(e|0QL
zO6J?&tzn(|#zjF~heT$l^Br;UeI8b3_)6#%f0!_ixK3A)LT8wBhp};G>rq=rjEJ6|
z26tU7ao*<{i*>}_v!M@MquAVN|L<eEq)pup<>=0@pu1>)jgJ3F3z=B~dpD|Lid6^H
z(GPbq<tI(jfasJ#gm}F4bI-To1*%gdG=@73;=qhz=d}#vq`oLnm9Z%aza)-{Iaa3j
zS(ON%i|SXhOIYUpo_cDO<=dOTo-hDVYm4FyBkX>q$tf!GiM;9^WTXSGFVwTLvQ%*h
zpTs>0!z-nY4$=UoiepFMKjjK@CLQwJ^pPOKTaSEuC+_2GM1)6(r{t)RaeZ1D9_maz
z7D!65o}fy18<QYaP}}mp-nR64Dxo^@@@N`7js@{)tBM|%r_m#V82JA^^l0Qyd-U3!
z-dGxh-N*E26awd~fw;UPg<21$-vCN^BsyQ}XA{yB5pe`dr*tMAjs^)HWj61+M$9bZ
zzn$B`Rm}49Tu9xn1mBPa$#kW>K{%27$78b$mxQi_-iOAIh7p{CjFbqYqVZz)>T7Ih
z?U<(Q{;mW7fLomlefCP!4YCJJ1p&#qYWREPhDXErz;}(!RNr!x23{0*n^za>Emxbv
z_JoS`omX}aJXxP5*24zNbh%w_bl!>xIy!m555m^qWzGsyB?Q|U{IPG(J!jvYtb@ff
z!f)HlAZu%O6Tmnv#FLl*g}qvMv{=VXN^nu}FXVVH#gy2$oD8pzukLj$w<!lq#1o}c
zgQP>rOHG~Rg86GZ3Q8~E;tBd00TYuL-1a($oty263vy)5-6(HPFO5}Ls1@RNN{7Q%
z!jZ)hB8e87Msz&sjkw(ZcD&-j3RGlH*yq~8%=~-N*zk1a99N+kUCtXMBs84BG3Uo<
z(C=JE@NO%V+k5JQaBML9yOk!yPbQbHh;A%y=let)>Sxm<#;=$~pxJb0>~8s{vsu{X
zv~VUQQAXpbE?q*^+OKddv8Q6h0#7r)<T&TB<CPMKD5^DWMVNm5H_A;v8KycyaPLy)
z->=n^n3Cz%m|urfHg%6MZ5H{nl`h{+-?3*k8<d-N&{vrpPI`kaJ!hi8WtFC!a!Gy9
zHR(HSQm|tUIpyTWBq33S((Kk_J9))Wny736xBcyV3lBSq%;HL9VK9c^w$7W4&Ufxp
z6%_iO8)MYf9BnM}GOCLW$QVkb&Poy1QC3tdHt}DnutW1CV^GB!_);G+KP^o?gcr%X
znQ=F6&6o2(oo@5Jdk6*9yr_bFAyhWCR=v1s@VVM7wXcGFqy;MUxqH;hDda6$uPqLc
zgG_yq<`s=Lt|^WQ0b#)1UodU+w(XVWOMT?(-ZqqeIJVe12S^h@2YbRg9F*H%7YOE)
ze(YgsS+XMkR}lYUvX?Jkekp-4FfiPCT**=VC`IJv0S1AjxR2Br*s!I;rr4sesi0Sa
zQc@{j)_=Fj(6c=zn^OIqJn@pBCKH^fI?nOq?dhc8a>JFq-*#GuzUsDWp6Jg#ofexo
z0%Az~Q0pU9l`quwLGhw2*-4pb8S3YE#p&>2O6uj5ns{eW4umw87}w{_$#F9LNljky
zrF9CnWz(56xj)adcDak@57x>UN%I0##bCt3vNj~4^6r*+a^%rr$i2i<4fy$J>NNA~
z=V*VsaFK<g@4HFYVk--XhdWo`LoB*}sNBKILvQCRUw;=qmuOVSiGOWIPe2T=e94PZ
z$+TF<^TT!#MjBpmYbC9p;;yLs49czYu7*XLQ6o1d4f`qhRuHUJF$lZuR-df&-{=f8
z9`i78-~~vo`~O890RT08kpBdua)xtac(`f``=U#-W7>wEtQEXd9Z23|pnu<Lu6<0v
zhr80s)4O6k^ZbYubJ+=W+@>7@b$bVIB~H$6d0`gbPMY}n!Wy}Tum|rpR!3CcMvv~z
zNXJ=dl?^7QlHB}TG}D#m*9)Q~xGmL>Nfqf5X{AA~hC7{!a|vCzx8+-U9VQy<StAE`
zBG9Ah*z6|LABlHMtvuI$N0cHiZE!3}B6DWa9)t4BAht*a-))TL(`FG_YHI4S$<dr}
ziwZ369E^Xvw#<B=`MmJ%Bf|v$%#!Ani=V@O1iHJ<SIn=Dm}=#!Ow&~~Y!UN1FnN%F
zV(NX7wxqTkGz_DH?fz2eQZhRw9S3C1+@5>BH&iKDj|?Cy5*DLg%fKx8@rkwp`)!lR
ze^VtckV(H_t@-H3*iTpcNxFcMR+&!64D3wQIFhKmW)iGZf<+a!tXZJ5h@21}z2rgO
z)(h-jF%vT@4t@c0Yv%LWGPjwHn?3ts{Of)cM~o^{Pnnv^cEUFY*KZ(3@2nssDlSyz
zwGtFxdGfKA^HTkP)0I}r7MS3|Zbq$M^42-1n8hfRm7u5}s*`!6>37gQHb@vV7$kDD
zvDnw;;=UOq$Z%M>$m6(eGW6uPpDSXNU8LbFC3cx3o`>arg|YqhHlN6eCBBjpUXe0R
z3%MT<{jX=_?}}sW@7>2Rp2lJs`I;I8iXEd-99%jn^w=_2NcKa}YPfI7G>cp&HmVa*
z%tQ|%<_nI?V{~pi_-t=3t;72il$hQrgTiJo6bJ(@W&`Y@un1(=bB>oHGd1=a7r#jE
zvHq_1{l#xV%cxY^Me|eL7oFCxZn#T;osJ%Lo$4YNH*<n8R~dych){Ovgg&B%qHB;a
zJG+v00W7*|Qj(hucDkHEE=|waGF~epW9(THGV+riPv^go18&<x&D|Dw7T7aiD^rcW
zi-!=38~p9gKRPul3w-<&<8CRO4RbF+NuJz4)y@NMuLrNVY8)$mbCg#Sv7O6#VO4cU
zkEx$6&*>m9?CYutLxe<#_^cn}7+=OHvSeyFNZ*$4Pc5wcI1Gc9FLydzhQC4kyC&Kt
zl411nODv>EOU(_k>aeKY-Q6t=Rg6t~>G70e^%_GiwKOWfo4Gk(dx-b<H$q-*KFBE^
z@zs%K=pju=CH!}UY)#_c+f^4UMC*D4YyCa^@M`%oQIR+<ymrW~;h)nwdpsV-M-VIs
zLz#PBRN+o?0T+v|Q`Z;%6Az|3116qpt~r><#z%Mi`8qKY_&2<`&U04;pTqi!*wvq9
zGE)htd+j-Gc7C>A$I@uAYJkw6shBr^__w6XoJ-RlSvxs7jdo*KvQJ?;#5vB97>VE!
zaV!K0d8cF7B07kZ!6$VD+7a}~QC)2;cUx8;gCi2W*4ovqCY^UK73VVy$=bLb$yduH
zf#)c#`L8YjvrS6M+?x`6RrGGazk#})^7<xztJ}QCDK!PKDc9eZn!_EjP2ylrUecy&
zJnq$YpB!orBkMVcGQP~5!SOqXvBqRE`)(X3ifzlV@{F?c$;kn`wICGd5$FHbQhEUU
ziz|M#qyOJrH(n0Z_ZF!Ys8-cZGu3=Qava>Caab2o)Gcedfa+TCjN&grop)jz4zFX}
z?KMyOr=&|#L+4^1OshULll%M+Y)o(0DO)i1ClL0b6!w`78QIdT?ed@BN$a~ObgxkQ
z{>%ZhhP@HOG?VJy7+u7cxN>`QhI>GMTb(XRHOu2Np;5KQNHxo+02Dc!8ek^hp0O~Z
zrjELYSh9z=|6Q0>U>?lc^qPh<t#Maot2nD#qN*p1WYl!BkVU6%pYz4jyzQj09h?Qs
zt0VF@zwJ@7dcw3Xzi|)9{H{0FFbj-L#ex%5!+>wpPsJbqbCISi)jqRHAl+m#U6`n+
zzv9Porn*^`p&t6ZYxU`<vwG-GVfE_0t{AGp+Y{~XQ_1_;A>$A|TO$9t=Nts3O8Bwx
z2gU!*Rd*8XW^tW%v81i1e9;JbkGP5L-p#aD=W+(Upa&)5)EIUQnjLJ65e4t@!kvwB
zPOI0?j&4o|FQEcAlLby&m$(O{R!*?lzU?@(=VZzSI&1%vlDEYK+acyCJ#yx7kCl@w
z%B@0|`>C2&g*l<2nHg`l25$$Kc^d6vx<sHN_-yJlknjEJrLO&~mW|WKW?akmNkr<x
z3O^C|J35UFzQMun21zH~Zwt&wN-4|zzey|<OniS07~EB5r0ym$#^%trcB2B<O2=N}
zE`LX4&cuApUby+0$rm+8k0Ih(VrRb{+%ux@=glu5-G*tS;Y+;3GviZKSP1VaDJiKl
zH^{g6J6jeDCNj{4?<bF6D3<EzDoe!!%aVp*>xxvCI##WI+YaAb3k-xkkyG}F#W_@g
zfI!!<ogVv_BL|*)%8k+#Gf|OLBFDDwLif@I9{1Zn*Vq5^G|8rC4%BvE|Lo%wcXgi@
zTB2G!nex>p{yNesm#@?wiKOr7CYcj(2On%y2kqNcdf$iL92cJK$!WRUG7FzxE+G*j
zdc}N;?$>!3_2zEEw|h=!8s4YF4K4R4icYF8)Tou|E=sw@%VGX#7|&>@R%u7+3v{79
zRPn;X@91lwH?Dsl4uGz|PvfMXXsiwW$hYR0sre1mMY3K~U}`OHcl}HM{T&*z0(OJE
zPnCuGtxW9-p*ja&P|OI!``7X+*=|VS!M0s@?olnyBNq4PAzA6RS%&OOZVk_?If7N!
zQK0MlrMcb8@l@VjnoQ3(>?>gc&Y4ZsFaLGz#r~|l<T(V=hQZCuwO>`|4ZXzefnKy0
z*fyVSBY&TriFgfkqBRF|-K{j5*V?Vg-;GWVhB5yRmv_nEkZntg>Zdp$$OKOKZ1UQ6
zJ&y?erx?m*aS^)uOF1)nR*!!OV7YLkqxc7@k-rVC?GXn@;Ptyb;((RQxd|vTsnicX
z9R^yu4n%UFjXKwqlfP^Tak^=UuzqFA)S%n^m*@bnu?i&e!le+HJfe3|k|*A=*kVSd
zPK@+1cn8JF4t)2ZnF7ZYH4V$US4>AYJ!gLBzu@ePbr%7;G|bDVqouM`X=$E&Ms8mn
zXo6G267~ikE(K~<Pp5zdImiB63Am_uQsjCy5Md`y3_^3@%t?S~b);<=PPL~geRoH0
zB5%5oH|~p4ZuI6yqjOzi=EU}-xXX>^2lq=fd{K|>XN42ITy~wrvzjz+^N1@lQuG@a
zoJq;dI;4p$qO`Y=yroS<cwMQyTp*By7hCDM1XzQ;e3G3s(d6$uXb@k*mKKia%lgjG
zUCz+<RQ;tB=YYG(p;9boZwcL4b>@-DQ22Swy}dk}yHVTeXiYMe*QL{)d_~>GwMuZ5
zVV)yE0kd7WdPd)&q{K&~oJ{{L?=x4t@uuRS$d|CnznvIRymQ)+f~JoaqU?XUMq33J
z7Iz7LO*nom{!8P~UM<SstJAv-OvsyL=!p=r9;>|Ee&#oOwc%@{E%>X|OQ!bL1lYqU
zT2w(Q)b%puQEBqS@H>1J2o`rNheVhL;<gz$sPp!{Cb`$pZ^^`)Id`NEE~$C)mc8%o
z*<))~ve(f~AJiAf`0T1)U;RsX(>!TyeesD0A)(2shaQ$XH={F$+X-SL<@)Kf%@q<J
zaTc<IaE|ImbMME|zwP|Oj1lzlg=Ze7gDX)PZ0I4*UqPx;4^j4~X8ZVe2StmGWJSH!
z6lJFl#lte2$fFyShSD%9<bO(Bp2<RV)pkAQcS$B9<OwhNfw^!aVr-rT-LH<pef)rn
z%y^chuQD*9|L||4fKkQ}Tq*@lD=+WE<ilRqc@=vK13YT_IDP`=8q-Uzx6A~DHdS4-
zzfKpEVi54NO7H!X284s<9c-9)fNco6d4)`_{`QHx4Nt~IYH!#hi1Y2=cFWXB&=zHR
z242zaQ{pklp6ml^;;sSxa)UsVP?oVD96_%<4r}yVc2h^7*SGebH*M~$dd}98^W0vS
zL3d!}c716i5oUL%EM=@!E9ToZ_J57)@3Wm3HcK#UF1qw=A?~j35U%d^;32zWF05Ln
z>LVmMu};+M?66esG@1zccAH2>QZB7Gks^1qwj=MIJl7zp>3Uat6!x0S^~_Ykk|Qn8
zSw`4(oJ+~<_?>3ihK@Yp@s)@*eH+GSQA81Hc@;BOq3hCBR%!G1#HiXIf3DK?c&j*j
z-?E{DGVcwm%DI9|3^4wVM};{xof?lEM2;LoE~@`$|KQZql(4XeC{Rq?S|TEd6?KAt
zM5z9%mzZfy$5zXfdO!{++ZC(6e0=HbeU#q3S>Yl`A0yIwwzJMBjJRQ~;N;-uB!46~
zb;?FSP@4TH!rHp6xBagGfPLMwuZxTi#0zvsp1<49Soyu*4uaf&TH#7tt4S%g_)Hy}
zVxTInnmO&FemQgXljlY2UTL=GeUYL%Fo?E|nK<$#?@x#4*tj@%mX%gVWkB*^L!XW(
zd079c2mKpr2Q#njCc$+5{L-j%$iOQ+ym-<=RPC~lIjbL~LuBbsY5ch&(2HIc`pet7
z<0w&Jh37z|TxFQ`sh&kvqh8^#-Zs+rzy_`6$B*78t$$^%3dm>pc{;sYyejv(yt$@T
z*7ei3l8<b7Tqi-PsbqGu9pvGYEbsFjVT0oO<xj^hyyzIPu1Sr=R6}FR$cn7h??6!O
zIGoQaMGBjh(QN<N5mn&w${!0})eW#=7m;n+{fc_E79!E6w0>Yxu?|zK%UWl2rl6#x
zWO-fR1J^t=L`!oTTG}x~xbqnn*0#Q<cqa4n^!ZzM$j^VHsv8%RcOz6j7`f@ri`gKg
zP5uML#-KOa@_$qI#atoFN!5NS$IUXZ3Q_`v7z#4s5^#`Fi<zWgbp~5+wJWRs7wz6c
zXi$+24Y7Y1t7M>4&|XE$LZ{5;vR8~GMb<l+Ued$TVbM&Nj7zjH6Ep1|27kNOm>D<r
zpHX+;scpJ(`|#0Tiw9u+f=4=(wdQ1ihJ%r@rzGJ`x(Jswg=NhLt;~-Ca}%#Pdh+7d
zO9~sC{@Eadb&}dq@14;cFkemt1eJp0<JY4M3*#9smyYG7@<r&AUYS&&-u-hZIW#xH
zY02+?lK(2>9oNkx-EaS*J^@oNuiKv(R0r<NO>cVLWw#P}<6`CvTeZAR5=>S2My<XM
zuP^p2BH{;BsXoa6^8vrnP<kI!gDCutSAR0ASGbgLSaWc2D7pK6a<AN;*_CGncc#q`
z+nDmMm6U&9D$r(`HS0#>lWu&{{%^oDPnWOS8oFpeu3lbErBS;-UeyuVcW&#IZ-L5*
z&3Rh2?9G~&`F}U{H7JosSH6fsg7g*5Bo_Yx@;Ii(a-Zw;9_^l&j!{vhllURXj^?VJ
zXGV8IamuQv)7mwx1O3sg%XxU;2JlQ@OGd32m*cRIS;G~KXSJx6w}HTn_|X!6VgW}5
zoj1c_XW8Lj6m)h_e`|dEVjK7oX<_N;xV3mwRCsR*24|(pA+uQiO6@;PIyk!EBl^m2
zTH5`aX|gE(c=gE%M%(704olo`Ck;b9<1P&jqbLEIX^oEVv{6!Pd4s4h&bQju4+pwC
zV`sl}0P}?r0t~|?*Jb;i?_3oip0lz1j!Fs&6i2;jhs|zn7pQ5tIWXTQCaS$G>892A
zH(0H!&h`^FKCA5kCf-(7kOfvP*7)eJGWn3o=6$xh>30lTQ3yyIZ&^O%{=rI(<|F~3
zG9Cje8>(A?pEO|Dc)&!MZ3#jl(BXv&rOO(*`vf5SGMU`H3>s^F_nD=%JMm60#L&Me
ztzBUJ<J3&iN=XSLmG6Y1$A?Lm03v0{THiZ2$LO*POLg(dw*(PSstwhQOi?KJHX3(?
z{s)aP)-a};VmzaY`_JwAJ${kiK$VOn(3dz8RwintSC>U^7-OC7?xGK)6B2Rqj{hxN
zvY)pkXf3zGBWN1;1#p(pk5)F%AyuKAcOo6y4V2eoR4ma^oLne-70ChI5Ro6gn3~%#
zCO{!FV4555x!sIX7S`75l92?qk=qXk@eX6?eW%c=bhn$Q|Ge{^EK%H6$kh2l?U^%8
zs(=H2<XL7x{6i<R=0J#wOi8wzrY2}odQw^wC|=RLjpODamFrbjIWLf{t}El^M?X>M
zZ11HQ7r>RBX5_eFeMvv2E<P0ok$SJ9{_ubMrm3L(-1}A1LElwGR=5(bpsYDldu~2B
zrQ!&e75KCF803E7I?PcMdX4GObeYcnP{o!aB^21{Cs(xSa>JMT1<`#y#5bm1n6Ip~
zt(pM|J#*yKYGBkec#8LLkMRce_4O@-B4<9`Wu~P;(k&+lm)atqS3GSWi)(L#$)IW+
zS=`w+RM!auyoJ$caN18?bI;S?b!+X@RB%WD;gaF#Pt0R^jA!)yZW{B}GD5!+aGuO}
zIzIas>-*bDo3BRqU%A1e{%}lKnAS3s2up!3h^0y@Qc{_5dl!?#ofSEB1*!}mxuZdb
zWf$DNw<rV(NL%T5*hRB)JYgCZT2*;#)wCCJ`#%F+uJ}1o_<PYj>Fol#J|E1Aa#-PW
z7vzNip5#fBq`DNFFw%#<XRCpcFpvvlgJG!O<%>cLxq_E`DN_u#G|BC0W$~w-8hiOI
zkm~2Z%E@5Ks#><@2)-DC-I8{`;Pu(o#bk-`yTF@bH^yjc_AqDa;YwFpwPYDO2<z{{
zGgclcXw(MAQx&UX2ea=M)cD(zl}QOM1OIzsE6V+}-jRhx3;J#NJ=+jGgQzoJngj1{
z)3qzi`E|9Sv4$;4uzarl686DVCOI?0a_L;Qjzi;P5h`Dyf){Z={C7iE?Vh{9O7Hs;
zf|_H$pdz_*3q2>cgtw~3WhBbdg)O)7A~*3UYn7@o-taD!IL#@RpEcX*tmcEa_vOLO
zPb#>mUp^M|MrX;j^taf5ro({7a<cSYyhnUT6Gd>HIt_S#&*~-_Wf|5h`tl8TevOid
z*+|JNKLGy@A}*^F-e1ONiFCAxG~@-R*uU_NC&@_9lwk~So5HN@w8n{Gv2b`#ewIxx
z=*EKG!4C)l1FAybINoaq*p2;@A6yq_7H`~?2}YH~=NA%MYTdum<pD4RfIc!97TZjc
z;IA{7m~F`vtPzWO^;{NM2Y-ort<2j$IQX%zWz-S7(Bl_m?>z{T-(+m!a<yYoyBx<<
zaxEptG@-s&Nx^;>_RUwzE%9qEe)W@7N+ITdN-TY3xz$_U72YH}FsJz~Oe!;8rnmbI
zS8DM?IpC(#jYu1Es1kYsp<UyAdFn@ich*&;paX`fW`NIH6Z1~lOJp=I$&?H=zDR-2
z>t8b_=K<t^kUf-Uiw6Pc-1aU1bwc7HMDldetI+qLy5||?``M{(7abIK8;ixvhCNsH
zS}Z9Zpi`o%S7Tb?WEegB^=M;IE@9H!(<ml&wx)>GcY?;P6w$j*lCk^=q^wMrsP8rO
zD@6Fx2j8Er>?;Z`RWkqd;J>BBYufyQIW}B|1iuD9ep1zcU^|*1omJ#Cb&J@R+w?NL
zqr@C}y#OOmbZX3i075o^K2pyxU13x3@PCq`u?Rh#UX{C8Y+*ld+P}$=QuohuAsy0B
zEE9X7_!-2OY_5l$#IEyB$Q8;Cm#ER}ay3wJ2iuLJ%_9p+?nh1l26W1VFWbCwb=U;A
z;}&Y@lgr}W9-}k|Z+L8M>|hqE3<oL)j_S+H%;DqFJRLKMXJ5jwwdP!LO$1sIbGwea
zf+^k!8EWMBypKp)xAsg%*?Y*w9_M25$mhG>epH!6riMxpD`qkycd^<YE@F10c&R8)
zj=)|R_m8Q-7N$}|gtvhg*pC;E-0<)or?F2@gJEb@*-3LYE8lgPilR5JEuw|3ODNM_
zf}%g#GZDtmRf9kSn@-O+=yxFQwv&GU+>dXB0g>1f<H}#PjQA!dQ1l}cC#O@D?Aysk
zqw2&6r@_vBG;@i^MQRU|Oawj8QUAC%?upiIbn2QM_5w9vaqs;hjvk`YG?!#3A|k@}
zX&FUZI$(dsAo>9;z(t;)k+cZ6*WFvs+kI!%m+CGP3hzaNFMDeqSBUg{cdk$_S#<27
z5Oh1R0GG?b<o)D$$8%=v^F`>Te|&o5a}uG?@?vk$E3ws*OrIOj-j2!#>1mNFERVV2
zE;HMI6!Op&9a(LDTJ^xDWprUJbmjcX@BA9>seRGRwgXZOGz@Kbn9oS1-}xEz?oR)<
z26?bvsK44PG6)2NmfvFQd+ip$Z#JFkBwd=mrsKBn8Us70WQz1bnJFnxI!3hyrh<ai
zNp!FQRS#&_!O2Np=Y_myu$P`5XkyCqQpZb={6(kV{4^`GQgtXQ{Dp~%ZSO|>_WWkg
z=4b9V{jN<lHRR;Y#a~EHE0?HV`4~q!M=S3((2$|3xlZxx4z<cTW^dmTxIF-rncuw2
zj_04R;cMOzZ~Xa+-j?>-?qRz`+_T!&464%k!y6uql~Z=V%MMv;uuwj&>#ddTQha>x
zUe8l^w~lwoavw4)01W$tDu?KRcJ%t%+QoIC0Oxqbv)NJ5^)ow?>#HY#(UM}FOv{@S
z=xwJt_)H{9%h;-!RB#*qVze)d_6lE#vn*La_tCSCDy8FL_aMrz@9G`^nyf4>8x#3{
zvZ5GjY@0EnJSfZf&6{_bRwI?8eYYy<1sL&5s<hv+kI_2qQAB9JtSm0FUu@+%WP~u3
zIe`^Y$Xp%u%gXGLy(I6RYF6E?dtAUfSkcm@N|l!I+106=P%|;W22dU{HGQWZ6NycO
zRw<c!L@E=yuYOPU3bl&J`V4}XQ9wKIFoaB=Y;y{Jf1Wj%p)tfh)wDXb&JKnXql)=3
zGla|v5RRKTE?Z>Sj<Yr@X_%V%eYnrL<c$Ly1iEuBHh^~~-%wG$b25n<5oboF&?l1@
z9soR8i2?+{@+PY|-^kc0cZhxX9suSE;LFf^04p1Yjq-`I@6=d`wmi;IL1K9OE@S3C
z<pD#G9hf4#hmZj$wDg+{2@0MbeJs4l>n9S0jY2D`UcSGaHAbcBi66IUaCW9jCyFEX
z#8_m6CwQqg2L^{5QJO)w+3m6Drz-`$0_As}ryGgP>U+V<=MpaZ7rN1<Ljx{Ph-i%f
z{?9b43%~qna?}xx2i*e|AFTciMA(X{KL(TTxU{HV$Ucb2=TPB%?Hu34hL<Q)KxX&j
zXC=uZJPE}}KAeHxUwq6Nr9~*ezvNH5c}Kdluv<w909fVd)1fk*F&9GT6=R*9Kxldu
zrl^_tl23Pn#u?ivwNd2Lj^hTuyM`Dl5xpz3h9$QJMR=#;i-@kb*yVNd<CWcr3i&0h
z0)yZ;0DrxYf7~Pkw1ozHeH7HgAsItCbcD^Bnce87U841%FmbE$G}hJ3Y|EJHPUC(C
z;Oy*7b={6J&WzwyoV+hA#KLp`12<=);1Afj@2#^Sz@O(|lU$|gWHXr((!#yx%xcus
zn-;27oQ__4rE1jsot=-kMn*==VJ4BODJfEG=iy=VD-9nG7F29?o8w-keHlTa5=9MM
zF%?QN_85OP{V1M#h0d-!fmYr8v)Pj`pb~#n9!fZp)A5CjFM8p8{+^=zcSn5xvt2$*
z9W$Wg8BiYBDbwFS1|K;D1^UhpN)DZ8$#Lt-vK^kFARB=SPdt*=KY^RT8=<F34a<^`
zald<DJLqUfS(i({+9GQH5FtepJlq%-7FJ_E5*-s`4y&!IddtD_J0owBNm9Pz<x0Xt
zpSntvwNevozF!Qi7+-_F=k{0Bs*2aJOXW{R+KxQ9T#R&iZtCQK1DgHo>+2CDd?a~b
za}X5KwI;ZH@{B59d-ov)MV=B@Zg7{@0shi^4PL+Es893jsD=IK`mld$eaRH-1nJ%j
zv{+&rP5oT153n4`5?VnbR`jpTv>WW?M;Kd;aut$9W$IX)r%cjz2x&IMJzYULwLK00
zf{~pF6q;;uDJL&~Q9xIkh}%B(tVh_Se*Ez~bMk=b^F_A>+v)ixKIdUpHn!U}hXLJh
z)}%=`CQ0nW)^u|9P9GxvZ&UtJuZ7S(d|g9e9y=F}O{JOwn&^z-t&aM}B3GQ!@5!9o
z4AP~`MW1H~``)HmS7>TzSU5pt3QkW4*tM;-Gad`@oPg?y20MXGM(jKEUKzZ2c7LDq
zm9cNo@&#M*FgWqHRN%21gmQrvK`*H9bJFF4yA9{)PWhPAK6n$dr&qP>qmI*IkCA7_
z44R`{`G+SNjGEkvGXyQ3gP}FB*uLS4>3|wBi#*J?1bAGIUPL>!CXsetfuZ4DYYsLh
zCbUo`79vKT&W14w6ckxwFU^K&o_hyDkw{i5MG}@RPOB5Kc#*Sns3~ao;^yRBH1RDt
z=SUT4wOnq8+-0n$J^<`Aqg9^|qcRRI-{i+_gm2B<=)?HtR&XA0#j07Cw2^TWJhgmN
z!SdbZ_JHtd{ANVjjLl42?3?6)%hL>dQc1dX0sRl&%xK%hRHtOFBK7z(=^4vWsQ%8C
z8i*g*C0I3i>HAI4H}uw8)kRs-L3s4N8>7<QJ{>_BS%Vigs_bg>7b?TmD(2=Q&;TxK
z@hJjT&PI<RJTH~k`Ts<uz@8XNs%fS@h1;QqgJAO*;wYRs4SF#-IhiTSF}a(9Sct%E
z?2oRwaxYKRcD37=H7rjYFJ9TP!M8xP-DEP?=U<qAzxc8^@M>}`eq#MdDz8RhHnO6P
zY1&D$)4(6c5~1+9j*>3kK%9R#sryrGIft2sZSkHry$YXfo8=%mNrzmg%wQ*vv&$5D
zV=#MLj}k#25#U?J6nd5dT>y`oX^G>G)|C2Wck)W$3)FqI_165ppJF6?sImoOtagX9
zH=}|B2t>=_tMu;hN0SGs5P&<&nO;trG7PZk@H@Mm-tKcUIJd~ybC!V2Vv0_xmQ9?>
z&IQ_c-)FqZ^qj&cGhOciaBZ6h*j3Pg=B6u0V;jGJx_|61ItoAZP`CCi#f-OQ2pCo~
zopJK<E;|39Z&k%Av0~z9p4|j%Wt#snA07bZgFZq{bSP?)&-s6ErSkeZBnv3bsQIU=
zA~r@KK%3dGj9-(c$Pp7zmc}Y-Ew>74>ipb2Rp3;~iW-OzbYjU1lNsuiGfD9c=NUw$
z5gzh_7dW+zF}t5>s&Ko}K9TtR&7zEF?1A(|oP<-0OgyjrFYCefQX%)Qh1ZCOfc%1$
z2|iE0BPuKWKyA5)OA0lua?qs#5j4Wybib%5&SOYc2BlB3x@#SMfQU2vgKrVQfB=%N
zKqfx@*Sh8{QNAaiy!10G{85T}^IBSn&07;RQfg{^5H%r42_HlUqNAIlJ?~yh<GFdR
zFQ{q22-%hZ>0YY5M<pRl)+9M8(tV9TGROf<xD}wa%EUYMTn^smJWyS4T+}*Mw(p19
z%27<_ug$zauGJmXIb_`BtsRT1@6v12osyy4w>eq?EeTW}VlURHi|?yzuR|XKG-lqS
z|44oa8TvZtVruAU<1)!GM{9n&8JFv2v-gO~W&LLhljHG}j%89jHaWXhXJ1H$oaIb%
zv^nusYN%%Fp38zAZK`@>*Ox{}pt@^w(~QpgA60JJ#W(FM2Ng<Uly4voR>uzC4P5vk
z)f3Uq3f4~}-Vk)!|5<yfE}mC9W_3^a3JuLh>Q5E{xRe>zyDhh7T$$B&x228N0k&N+
zIWM1PZn*uBajr7V#=Mw>>YX@9+VysjQRJnIKyU+oU_2;vJll-h&jm!f#HPD-xQY^B
zx;XJ_LN~mmw8_R>e3jQKC6!<y!e>Z(q1d)uKfgxnAUaFf>@ag&F!ylflgZ`z7HF)$
zRqc;kP(>ulot6YYh1y6ZCnXnUWiNXlUT917MDi@Yy5&6zSTypiCmilO_yu<^QULvO
z3V;`{cArV|CE;efQXM8VHHg6;TP*eVN_}swtwm|7@3pm)J(o7`S=&M=zYyAKwK!p<
zr$JShCaaSK>pkpZCKQfjV|8!$nqoTyPa!+Kr6{(Z0fCHrd?AduV7EUB0QkoRh+?3p
zZ}LJ2V?xr&LH=mDP6emuVe8QlG_MKqRUgXXgAwvkWexf5-N~o@CZX7|rUcK)cpWd)
zQx_uVG!Rb=T93orO-vr`Hn>vwXfK|?t1gE}C_Go7Mz-}`%TOUH=#cCCbsPit^Q_&W
z(%c%T*aQEe!epTWDiju)wNy&>C*<78c>_?tBjeJhrvE+&7T)&wVe2H-I;lw!r(I<H
zeJcjy9kl3%AC41CCo}Z4e2DEafK00CStQ9KnTO=^;(T`YlwJ<sX4^CH3g2&Pp;n}q
z(j)X)DRgK2vSwIQ>59C?gwWL@7b<Aq8MDAI%Qv$Q{W8Z%27S-&Y$w1x?2~)p&KFO+
zQ21IcEUcGyLQ=&RbEE+qz?<T7D}VV4&0RZrTo!k$ZBJ@|PuuBi{tm*Yh`z7d1wJHx
z;Ez*sF}k03y830~;!UrjGohq>v<e5`NX??vw{l86s>;cOgdg+iGSJ<?Snva0UJ)1{
zl<MUV41w_hccFP3efHX1?@G*;Wq<()by~>xT%Okp1zDoCHY)8;|M=uE`WD2Q`eRh4
zB<%YdMv0kh-jE!|j>J--wSqcTeckQLf}+9-J(ZHn+Q9;Vfw3jNOKd>8#tG{Mr2o^9
zq)5f307bPYBs#s5{wCNixDpT01c?Ey@SqP5Yk9w_RQQ}o)xr#pi7BeXtGBxVsk4kv
z3(D_j#)(vo<w_Q#Hjio_wuUQ}IJ%uS{ZRdBTZ;+@$+rqQ^loMx0B`yr_DI;z-Mtp0
z1M=dpi#lIZt5f3_OO=o&1%<}8)>K*-i>hfbf<x^%lf!wA_B2>T`3?SYj#!AA>o(6G
z$}i(Bm!Qab`tpZZTvfFZKI~w2)wT8-=N!;x4X8@3!*}tXJ8WdLZF+tfuP8hRKbQNW
z@bC=v`cW_PtiUwOf>8M2h}e1_-=Zff@8$kNQWC4n=nwIlk`0?M(5U(?_lp-1^%`$b
z+-np88?#;m8#4eWT(sICu$|~3!6OtQyPRhlKbC(x1B;pPshIjxU6SC<aI67C6#UEl
z=Qdzia=?@*(@35qV_2fYmdI3qB1%9KWH$ehu-RMwlCU2eDI|X`rAcZm(#`Sq5%iaT
z_VNdx)^6CmUJGzradu<xp5Vh4hCe7ZJzW;FD^TSneMPweZz67!FyfLQ4I`B&T-DXW
z=6slMg*f>48hmYh{Co8@dO&pm4m`MSy3_k1frfDzPTA9k)@WoJ^<zaSW;QF{JIA$*
zFF9C<U}rWL!#6nuj`#w^!NWoL!NXx+3`v6VWn3cpUF|$j&E75hY@Dzs6BDJRh9X`W
zMr9vvLBH;>n88jCz1-OS1A?#@$x;dB_dkXaqGNy?9s<()0h@aEw(scrT7`z&MZLlq
z>F}rauVAdnNgbbT44}^U_!ti`es0&pUe(dcNPu=%69>S^WQK-Pr9bTL)9xG3`lNEi
z?R7pW!)t=rVo2})_V(mES34^URiG+J8g$-vGe8<l8XSWi6AyuW=PdDANQ?j@S0WXf
zK4CtdtGT)~)<=-`guQL`BEUl>r1LRG)W^>n|M<2ht67@WFCwRczd^rxKLFfTmY?qn
ze!OyTuR8I&Y3qbA0oSz~)cQ@8J$nuwQ`v$x4xNd`Gm49M5YEKX|A(lzjEXB*x`qdL
zf;$NzI0OxDf#4e4gG+FC8{7#N+%34fOK>N+4DPOhLB5lFpZk9Q7}l(H=5$w=?7gcx
zNbFAww|)!NM9Wl3g4Z7N!%%6`$gvrVn#``_zs>DaesHNvu2;T{UFUF<&XhXn|M&HR
ziH9;lRyQRvaj||u_uag%s?wLpC1PcbZ_LqlYYbv}ooAydFQ^7}-{T!gO^q!S&5Pp^
z4-(_zHpiT`{>q~QRdNFTv#qSkn9><gi0zrl+KwfA_;fV!pIS+~5LiI$-*XOxHT!v(
zh6MPFg)JfdX_}m{$Et21f!`tf&AG@u`RztczvgG=2dg<Eqs}s21-{@&KTEMcy!b6{
z9s?SIbG(iUeN*Rt$0rCbz#kB{hikoL7H=bOKw=)o6xZcaAHxc=rulc06;dHB<@u|T
z5CWL)2*gS|C#S=kmD-+E8a^q%ynY#`(k(Hczs@nh%nusMnB&U1lC*6T#@>k%Hfwa^
zzOgjs$TCZB&6{an{BT(NcyMOEiK6#sRa95X&V^6Jw`d4eLN8~KuCB8eKo(u~s2%9c
z;xCT?90t!>Y!U<UW9~;-koBk1(?SSXSp`NNhtfz5|29{Hp77EK8Awj>4d0no04qdu
z*u({@$^dg9Z2o!cs32CVcJyaNzCz$qn!pB6=oyAQyy)Y4nMxDfV#W_J3|ITpxjvQ;
zU<)jnV2uyL<7({pYE|Z7g~k-`G*x|=m;U~{^G-)LZCh^X_EIu8*~%h)<HcpVXLe{T
zXGfpPu$FjUtk9#x+?p<8<#?YTXQzDTFUvpY9-Nuk_ke88=+6yOy`xF-*<9QTjJ4TN
zcOXdI-~dO}2gX1}8j!HOTg%nZf02LlEWc%YKFhK@2m-p!rHJB}U)eiP^{$iUN_Wx^
zFXW`pqJ?odNE66O<xA!w#OPFzVxYX-49Kr@i|QDePBE(S#}1<nkohlrn|+}RI5HYu
z%rh+AB=3Q+!^j9%g$zewsP^?Qg1@|lPtdwpTW0n#;@WyF2IdSSibv@Y(AFDIQlTmq
zv@J~4J5kes=SS9ZDe;zs(oFa)nJ$ZriG+PDk!dD<$Gl6jz<V!hY;r+0Fo7!Lal1H$
z0Oh$v+Dm7w8^9>v12#e>1)zd~-z_bVhH0|_Vw3NKRIz@xzS^JQ_w>XKBq7?|&m?{G
zjy3KpRWA&Lk*90W1L(R&i+fEGa>i&k6{R7aLVxfP)pygG4bF;AT{NF~nE4MT8!!vM
zqN2`be}Dnxg*D}|%~EO5)C>#^q;Oz%E`97EoQ!BNK_Be%Nw|?6sAkLOhOD|ix<p1s
z4#ud3!Ytf{#l%-TQC+POD!l&QQDaU+DwF8+UgIjz_rFC0G8(-yC}TWEw(liB1xS+x
z(H!B!kr+uVtbHp>4UdE2?ivT7?&=(`OxHm5WS;}*?NVFQDJct?APF;z25tYy8x#f8
z4L_H&KiP`kb~9vYdSpJGBdm>7uPeyIbPT-j2eP*RhzP0`FkYxM83!i7sKet3iKY3E
zv0E8sK}j;dd5Y%|C*m5E4&=F_-tX1;K$kl&pExF^N>ufT=#zpHYVBRLnXolV!kiwC
z%Qa!{T0T90uU+ezi&bwY1UZwkU$h3I5>1(Xd<Cii46}prsUj!+3La4&+}woj)oiVt
z1oXo$8hnQ&)TB|%kG%Wkru#F&5EJ8*3I3JN%cSCL*Ft4i!vZ;ao;mVmHPMKluzM!;
z>{hbZ2D@MEw1H&W#<!|96y|d=kPH6?qoP>qbyIDEK*u_sb1O+ZfwuY*gbPtHchZ__
zj7cNe^18P^$&<Tng0!TrMn*e(=^V*A0>16PN%hmxP-P4GBH<Q}F`q9hG=N@-Q#*2X
zLAaZU+w~YiJ1-9w(8UihH*bMH(I;{(1$2-B)@53e@l^w4-Fzd>#owpMc|y97a^UHq
zKjys6xv^-aPXBm_h|BCs-p<H)W<lF?H;K0MR)^Pv^6D4_o$+|0T>?nEhBEjvr+1LX
zQ8k96el<Y2f0c{>(bZ)F&#o;^7I>)tI3jVgin{kg=Uv9q(zmHF;_6NVJP^n|P#Cc}
zrg5e!wyhIywaT!MGr@pbUre)vwT|d`WcL^HSjOAu(E+)g$NLGN+cISaY))UkcyWJH
zgpHdF&C<>%9eNGb3=3COi&7gWJ)798)7>cb6hX9{?H^zynQK(dV)oCDXjBomuwB(4
z(8avgfm+2t$2^~~*RVZgJr*h-3Cjva9}|-qAi83kYjG?za++SSlUsGs*waofE@BuR
zRYKs&1}EGcH#xy9+U*!u^X%)GM`_K~N?OS!0Va1$0*Hdph48>I2G8FapD`ysP0uk;
z$tfXoT_)dja1@72sR7<UCM+IZZcOK_h1RJeb?}{AAx?3=ovo@fo@f4XkxWl2rTxhL
zWX8*1wS^z-9Oge?<_4Z~;%H$&#O@zGr(St|syM%4?CKMl5Fw(2NX6P3AYh}TQ)8pY
z^;8ZL+OeJ3urL7Yr$1Ze^&aOuOeoOpyit7JktwwI;AKk66CNE+Rn#llk)ckurpo>~
z>YMukdl+&LHJcE_DEn<Q7K{K&mrh7rp(FjmU7jMlfb$0Hqk&!@8WCtd!PUu5pT@hg
ztQFJ#sqk0L&%~qH=4hLTBD;|jhsa2%&{Z5~quJ)ee(dX>9hc`H&Gd6vy(U>_{gJL;
zym06=f50nKqgQs1MP(h<MVWN3wnP<OMDwzqCx4~>-d+X6eP*0VFz^TzVsO7@;}P6+
zV#itZOUoiIL$aKQxkKl;L`|BrvGY_hQ#3rDUlID-!`Zm^5bIk%?1N!`JV#pe6nTL@
zr8d-EHdA=BBEvGJ_R%Ql1`QePVyMg3-O6#`z@5KFX-~6t=Rsg`#g-DDxJX2EJxspP
zb=@odzV=pO6lo)d=k*}pC3`~gq&Y@)wv74v9}~UVEfx6+uEa*cIQ$uw&u=K;n(~r(
zrUSX>$BpgRB(_dpJnMhvSuj@3iHw37eLMb~+4&v4W&Ntp4=Q&9`e+q}9!$D)rin!!
z6D-)Mte(A9-st;0yJZTeo}-P=+a8O)v&HAVUo?JL5%j*jl{3j>o|5UG7Sk**xQ*<#
z%2sVL&&4|=%rWPZKs=ivg%B`)xAK<lC@t~-x*FJ;%BufhcUf3l8nnbx@dVYITSzCm
zU?Bq`E^VMgPQxrg^9RDU13(iwuJoEaug897&tLb!bjQ2%*UnEID*G_%!dl5SfIwZN
zxXY41v68{PsY8MdXvi}**}!-C{$wJ#{@Kl#Zxx&t+e+$L7vX5`XE)PhUOTMU%GaX(
zNSXPlJ<o$h;lph96DZsO4i~AK|7N4yKrB;gn^P~x$IZwzW?sya6<@vc_4?^@d;hIZ
z{coN1rw_utB0rWq?&`9APP{scr^j^0(jLo}H)zNK-7##HVB#Z`X2qona-ak{0J~&@
zp_)Rc223X#r1y8)bLopy>GsVGa4E_2S4L7<eKGBMo_9O-i_3e1<wv(1{#~;${!uXK
z9mN0V_e}%ou;U{1yYE*fJCvJ7S_KLH6`wBO3D1t;O^qS>ZgXE9-v22UelB$DT1k>|
zQS=;aQSs|?ip42G)(B;&D)%6ecNR#bA(Yl{30y$(=Oo!d&#=>+$?`2swr%%1lQKF~
zRy>a>n8mzPJ^xeK$_KZkO)@_anR{wC6=6Cj!3X7!<m`OWu|{!Z0XhHV%7iiqi}G;n
zJNYWosNOph9H3)2$k_=)Yq7p}Bn4EBAZ(y13e*@;ni`)yS3p`%Y5myiUXv8Pw`7Gc
z;FOuUdGA*yI<8XJyb6{-q^IV=bdS^aSjLNA4?3^DPOhgT@!8JbuR|ao9>}0$@$j{B
zqA7ChTEo(GR8ybPOklJrtP7cTKl(s_irTT*<Tj1&641%!q8*dwkk*?HBgiZy?-YJU
z8~#jhn2MrhMu8iT{yz0RlqzBDvZiqVVNLk0^iOJ*+K<Dv&(Kd9({ZMUHB8w@+mNfU
zGgML2k|Ma3FDqcq^jrJgCwDueS85*603Z0Uc*iIOuJN7j9^YLhjrS>TjOE4pR+KZ_
zj!{>k9)2Ja#{g@{Th(?AtRUt0u%0);La$HP+v`^QpJmF!N$pZi2i9QaK)7syc)fI1
zlpmM$w0POyCyd?uLRSL!F=z_2p5kIN9*;C==U*>4vLCASAF1!2bKy*t`_Wl{F@jc$
zG1PG!lti#_ROi7x7QoeK(VlfnUhW7=FFw~qm=xUi*D?f1Z*_7Ry?{n>Y^+;+_*}=Y
zLbzA`Yt8VmFhvTuOk5HwZVfgW`4jvsaeYr0Hcb@}H;BLS4`srqQ;6;BuD(Kf*DY>#
z^WI#QSw$UsVp!CnrYjyaGrhzgL4+<FmCwFz-8yIb*UHxmK7x%RE>AE5irjZvRtVmb
z%xQ60$L-4N;;iniw`Uiv`jIiGY9LZ<qjHrvR?y`ycii&zv7%>6oQ-CQTDF2eF}O{_
z+Y>soiU)D8PZf3;)n6SmihWOvi`$RX!f(0#c0NEJZ}rVNcpS;9xBFG_0=Idm=$dis
zDUc&Y3dx$a-e4~1Ryng&2K<1!!+6LwBrQnEm_@}+o<-urzwe2XW^o$yh2kNuWbFG|
z;i&b@hJywT5yOxdFBeZ0yFMItOBTbse}3WMolx|<N+@o>N(#S)yiSF7-aane^XsE@
zJ}#;RH2zs#yKR9k0Zj8yZBsklgM9!6o}@Tgvy$DXX?Tz*Tyzf{P|Rb&i=<%ooh-0-
zJLd1+q~RP;cN=omQx>YoSI@wDD`q2CJFfj3H8fo1E^hRE2Fy9*?|OwUg-R8i4DVLX
zKq?VN=;5<Hqzd0EU<Ku+w!(2A^-Pl<XBx_NP&ZH@2T&l3hN9O%j%KY$sEiYp?~<r%
zqeutIn;cdeD{WRzp;c|n&qrz%cQ=YYM?1-#pK4xO-8!$Ao7zna-s510S)<nL^=+2_
zUJVEOa1gPShC>-oH3O=L<fg$Npua`nMGXGE0Tw}sRw+yjzrA0rnDc1WOT$eXV)#<$
zuk5GI@$l6>XPArU1^x31TG_9v6|S4+LUpIqEYjtWhdpln`%1THzW(CXmq4q=Of#n(
zaP=E!srqK~$t<ON0Ys%er{Pds_+0p+t?syIX0x@b|Gbh~^7^N~UhrWAgvn~;{l{(-
zEC1|vJG)0y^4T&FPfe<}cI)4|?6tc*LYE5Dm-+M87mRZsJ5P901p$YZNd5L(k4fkZ
z+P5h?t_?KbzkznP{DQt&`BOJz1M3JPzbL8ss~7+KAPxyG7+HRspPbY`2n<5lR*SnF
zwf)b}m_e>Tld~UUU)^V}v$GdZ;`q;1Wo1|VHVNOZwz(aKec;M+o++|f;mUNL8K}@v
zZ2oHmy4UlnI5Y0bjQidCIe)wRgE?|l$Td+i7q9(;Bp$q>wTzQNjsAZYvliD>CixxP
zdW+M3rCytikcEgdeDkb&#FEku94hN2ji%V3z@c>bK7`x~=9Gy=_&WRbp<rK-#U~{?
z*5@PvkwzG@)|FH*PS0M$JjI6l_B}jVxW(2&K>H_$W{YTxY6{g195T%ljei>#bYi{U
z&U>}~*Aaz^=2MyrAMC1wtl5v&%|C;JFF((JryI<@dp_WQ-4@<b<kEiE{;+qjAP-Qm
zK4(sYq>^3gGe3_N1kqMGme*O-*ThAgXV=rKlJ8dhJVD{(@FKr3gZciql-T)PJq*0C
z0!d=KzH+wPf|mY0as??5ttykgPaiYY7001x(3w$vAp`w4-sfK2fXNeg-N+h8ZC9#(
zbm(_kc}Mt(bem!~)worN#}?hd#f8%_<@@Gphu8hlktH)phLEmjwjie_R#2(Z54gx@
zRKW5Bu!<k$t3xc!3#mL<fd|^aYsQHncF0{s3;zvN`F0h*9D=cw?fADFeBOEPbMN;G
zedeMlL>@a}dzjjwS=}WyQ-tEf8@dj!fq(lV{M#F%So(R8@nU=3A?l`c=)SLDwrtj$
zlEF_>V{-i<?CD=0f4*DldR+!i=_=%JG^x-{ZXXh6x$wp3?G$4!p}QJVMS<y;CXW@a
zHCyiUmVLl(+RgVT(uJ>6y+V>y5-82S=Ik9ryuuoP>R~`WURfg7RMo;V3m_x^-*(lc
zs$*PGSo5&&4mcDyj2?1Q$J9oy&r-xG!)LraAKxDMKAgIB9H-m)c?spififEI2ht}5
zlD+(ny92u-hGND82<QPHC(n$@bjSD~@1VHF+3iqj)bdP}7?qxM#cy5Ge-7Vm;ji%g
za!YoXLUJg43f&fT==L*Tb%qN}v5|09-)`VapZ@-DNr<{Zqo?}=dMjc7UGS;UFFq-E
z&4}>{&p+Rxx=yElCH%Z-l^TE&S{nZi9V;65WE^K<ybPhfz7Z$r!R&<Rf7XHP2nd=F
z=Rt5aLHk3#P~^06kFzGTR`NPet{(P+__)oIFEZlP-JkDRf!RQp`uV$*doX8i&3XG|
z1b}xKu>arLam;04+cdnhlD_FA(Z$!LVcudc0l~4Vx=?n#pZ+AZi4u!c5jv&fxxK^x
z=3=8S90jdcjwAkm_QEP`680P;hKI|n64IuegCYhXt!!(KcesjcPBz}NI+MPXAUf-=
z8n5Rg+|vZFDkP9KWbOL>dMC7P?Km5R2v>Y|sO@*Xq)74EOXvid2zfBWC$Fe}mqxc<
zKgS&hQOrM*CxZf+`p5MD3~ETU9YtNOxBYpe2X`9L1bg{AXYiSrKmD(#!iGKV3U%Yj
zRo97!;#DH_-A1PgjUHXG#U{^};kLkAsQToa+CpMsT|qw`PeFvPJ9pH}&be!ab#l2t
z=anN5R1g@fGs$ZQjqZ7Tm*Mo5jZCAWq9TsmoaZqG`Awd_KX(ny=D>r@;YPkJ8nZ~s
z$B_SbREbMkZ;FTsUgR~N)XNYT9}AMC5mx<PpJUfrlQxKfCQ4|5g-T3&LiPFO=HsH3
zdABXZIPIH+x5g#`{GQK#R;(ByGpM_w$5UNQhJMfm0Hm^+<%_`4tpgJ_%pU4gsX@|M
zW-%iFGr`{W_>T{~HZ9NXO(ySLKR~Jd!^rkr%Y2}n@7_9{umQK;#%w#IIFgBCRh|a@
z;7@l*PGfg#NIPqjz0s~{0LCfAd7U@+S#<m%cPO@p7fk(1{~HXLrkouT<||G3GpZVm
z&!Jhyv^Ew)u<mfcS4`j*rPT(jg?h=jH<`>+ad2&8%lB_qTOj_tvLTmY_G5m=yMr}w
z!8qe4qw%?*&|ip@d75M-MSd6;JM7={2MeXY|BFfQ3F9%zp5K4?#A;znC6dB-dCW2D
zJRk5?en*C2&p%=TMElR5uDah4_)}8;Fv?HdN&&6dGlzOiIWW?EEhpeUYdmNrmJ?zL
zQqdWF6j%u*`;p|7H=*MH*9q{;MPCNNxPBKQ<8PRlc%mf)wQac;ih1H^!n$_g(Hs$h
zZ+I$;97c1j#jn99thg5=E*f2@kt;{QjqfzuB09ahUsb!eg;hCiW`b!n)nwmU5v;%-
z%<sh`$GObTs6V4pL0K0~<3;Pu!#Vd%I*_HnWYQ#9dPZ!&>*sRvW7rGtUuhjW&&)tI
z#3m}uOp4#>X};8HP~f)!!Q*O~=S`~KX$7=3$qfdBe?{<}_568eDw>LDW2}tCc#*-V
zra&e>H1F!k-|CJOBUsX*li+)w*Hb6@Xrq^LZ+k)Afo%R+Q`6nxyv#Y+zIETpNM5vb
zG#!cOeW9LUO>Z>aZrYy?!P;RuYC@hAPkOGftlb`m>*zNj5^<MG^jeaD-!YU3zxTE^
z`1{n|tIHm_uH)Qb(&dE19i$~-*X!?AG5ssq&R<-2*wGYKRGn_q66UhR=hV>?qX>`N
zb^9^=+bni&^6J2B3eqpTNnedH!6uc7(ahq0!d}~%wZoZ`II0wZG`^YH)1OL|H$;O0
z1&V0B*6}Hq76(t=yU}u3h{`u}DZhP@1T=arl1zUQ|9rZ`cc2DB&aMg&oPBb)jN%Y*
z{(uHK*;y6MFpsRqgIWeUB7GB}a`g>)tYqaUVv>I<dJTOX-$&6-8f!NFs-hVCB)AX7
zM<S3gVwPvge^&qagAScKpLk@27CE0?c7`-A;dxo?fc;C4o?ea(PcpG&hWnFv*In6Q
zrl+Oxti)W8QiK$*3_YqZSWjJsp0Z8OwWraV1_5N9lA0RL)+0PX1huM0CjV$<lM+4O
zb3X71m?V6rbEkK^@Xlu=hCe@JUu=VK++Ab?CHl|XPuel(P8TF1z!}ZDBQ3{9`X*3Y
zwzgU~RHc{lW?*85@RV>bn{Jc079tef!?oW6Npog)77%H*SnWR_<Jn>x?AluMlWQP>
zJ05q5h*DS5wMChC5C3dplhQkwXA@=+IGhW^QD=yVgg9ovl}q%2dDy!5bhA}wLg18e
z{kc-{dE(XkqC2(^C6({X+5NJ_oYIbAfuP&U`BVVK7#-XRw<Zf_`{Jkc<H$pB<m!ob
zitLF?Tgp3gk%LiIXakj}exa3r@f;5y*2XW1g=&vStCx4pmGc7=9caq^AtL>lbndB_
zhd*Eksq=nur?63MO_X;ypzPU~QG~Xr+>CDWny`|>r)!&ssFdmbUDkhIXzC0E=EMHk
zr$74D?}cFajo9)(w%r@R7XKWf1O!pBF*ywTkVU&&X@$T7@b)B+o)t#-5es@9Y#2JJ
zX&4^3+trM+55Ag`2!xJ*5){DEcj>5q+zH+%G1JkqF5i^EsOiP3wyC#StTZ-*a1UlX
zq#@GrxYlpW$tg+x1|FF;WYN{bwbkAGd5@lsK@<qwtXxSy*Wn$I&J=$p?y=8iZ5Jr#
zz_@)cnX`leg;n&kD`7pT<yMgRe>Sns(8MODTr@@SUz(sMJDGhM1(EhO((z!eC|o&V
zy+iB?@#DWD?T-S8{qcSlO=nfCpc>*~-@uQ66U`+=OQ&WYW4ylc`ALCpuKAZ+?=sy~
zp4S<E5ne>QyOR=jNuO7j(ufPxgO!*U^T?5Iv1edJ1Z(}%`On?b86ENi<u5oyzLo{0
zVAjx0eTgT(OzDK)^*`@9mb`U<3r>vDp%{&XNCbPCJq-LIMCiUUPxeOSrtz0nXdWu1
zA>JlI8N)xHGF+FLtYj##VfH8#tQt5@Hqq75yNU7>DPg;Kuq*$k1^7H>jUM*7AGi<E
zbYIq}mV+Re&6vXe&u8Q4q@^iv8(JVSs{`)d1gz+J17<m88)j@RAS;HQREdaxLyO$&
zOuXV7XdVv7LPUw8bzrVy)TL(j3vM)BnRDmEhn?PuOn$f1WzJKjoiE8C$xD5!d_;*j
z*cCa8kW<IsO0e}9f7z|u%)f}iBmOq3H5}YqB<l(h$&4}=yIki1gOMBzR<K$*I(Kd)
z;r&N4gIjj`Py$%>XzC#wEx@K`uuIc8<^8T)&76dXBhy?L0n$u&TqfDV(g0jsl5xIa
z5(83;2Kh`INru8iHf?$YV<~zr#1V;*mf52vp&rCgd5X|Xyn{;hN$^sDaqgZ}V6+Gk
z3|CDy*A7{1!(b5$W}4i-kJ+Qqq+IHM$~TIF;orW2f?;rIk&*--Mr`Gkxpc8-Fa-vW
z_-9ebui{ei84BCJ7jfz<Dbh4u#(<FI%Tf%{NyiH^(%M!n7QOdA+ZxwFm!I}09RDVK
zF_+~x8YJxtV-Ch7a~?NBtTRH)0o;!NZJ(8dl^I;Z3HbMcSm6E1631rCkZ9tA?$stx
z^P=)D+f~1FFfi<-yS~%5-DMOvO;QZ|5gYa6!<U9S<#>UV7?6{usa2aHb_&@(ZPrCl
zQc_Y$G^VDG4s^n;GyhH165j^$5%nUF=kvz5JtKPIA`ytam7w)uWZD0Ug-G#^_`MtA
zes>XL&@6dYT{%7YE&UYh0MQqC{bSFL7htB9>s#5vZH25H(#(-XdW^a}@P}A|-fID4
zId)jNOS)R1aGt<3>FN>s4c<@t9o~xWQ|Pf~&oV)eAEf&uc5Dp03Z~MX&lv}GnVeRA
zaQ|<^sMdTU$IcmzCOj*8_kjQ6y^pb6*<8^?MrRmHu^-054YiA7-i!Jr`(_NDRfP{E
zblMP}XWh`s9n0Ot#buF(+$6$4L{k%oZ@HX%8a|>1vVpbL4ZK~Fc@dg_FtO1<0XJpW
zH}TnM5XTB~wes?PG+XC6+}~^A*Xnbq4E>P=Jwo@(Ng~pH1o|Ll2YAD>BAV^aJm?&%
zZMERycYf~+!Tf#iW6Ez#Y-~;))5e04j?B|GUs+kXcic_vmI8GEa;Cr`Uea4clFxB>
zq~uCunph!}HB2HzC=Wx()NFN`o?eBY;X+dD?@rO%2e77>mzRHj)JasH2XCWID>8Pt
z@-AvDQZBz(-iLhk`LNvpT+T^)e(U20$ZoZ*pm>mbJ>%AZ4l+_J--hlsxATc<aY<C6
zNI0}!=WyM6EjzAh>rbTOD|TDW-}}M)DGy<UN%jeX8(7y4m<aFnfn$iLka$71WS8A*
zkiNNUCm(F-e|pR+g2C#Mh14BlEjT%=EqpWeg+T%jUSTk3d)lDj5BKFP^WtLFyyx~n
z^tjn9k<Gr;mB6GD!|Im>Zj7jECk=(2<L-wud7^aBd>Dg{US_2?_!jXZ^Tu!0b_sQ~
z(#Fm5*Q<LVjwek{x(*w>qDCy(xa;<#sdz;b)_Os8oZ5zs#AaPTgLd!A|7QAPu=*Ql
z>lqVW1oC`@vuIl3;vx<9`-uFd(*Z+*0byB&lY@39EB{xOUL#uNab-mXF|Hi!3AEE8
z<L}=9pX=(A{hFcQ+LCL5zZ_BikVcn&H|&VLlj|%y;`d9UpY;v=5CMlK%I(O=GKPvD
zUOpmeHlLbGqe*PkHCNn*^7ENk!s-JH!jx^3;AA8kD>iRTAnPLOcl!m*K1T@M<`QZJ
zr(s3IvzpsB&&2Ywc75tOw1_{cH4=8hJBE+JjNipEajbpFM+)CNx=yMf2Scuh_cxd@
zG-8!mQ7YGMrI0h3An4(<5WCao!a{D5RWMY=Ow3J{50<PWhR)pz|IbJ@p^^B#)}-e=
zwj`OuZjy$?iezDz3_Uba%7^!$Yz~0XII{B>?eH*M$^NyptH%a1>o#b68{lQLm3YoA
z7_}#vMu==|k-2ndF%sQWGNBA-L^wsjO~T*=rDE}dag7uWgjb|9*2xMjE*xkfPKshj
zz!^7;Ku3EmV)O+LIMTi0DN<w*wexSgXtuFxHg(dM23YUI!epU+-bonyUKCpIr|oyb
z!1T4m2kXM*wi*V~k8U{W#-`os{x&~dD%5p!bn4>F(~-$Z@dnF$mtxwM(J^5q-$<7?
zBNx3T$$SI_o!lf$vST9=&=f;39EKZNk2ZINd<EFEnzGX6jVcbw_bO+XxET+YC+^cu
zTAHLKn1LUdW+LmW@E-_iqZ1fXkAms<d%vpr<O_|3Hv&AYb)JW3KGs>s{rZY+liq^h
zVL`&T`__f$HOTWCAQ+;&6{qV~I^nK`xSw!GoE6c2sl6T8tdwg4(dI^&W=Hm`lc7YQ
z3YNs^0LHP+c4O-<phE<u;rH6Gjry{4hBHSC)so2$m6j`!8%?_~N*_UBy~zpG|Kt84
zId)7}`I%$`2yAD|4OYwfL!k<&HxDfC>oWrw$z8WLu3P%><mtSd^<vI*Y8q?q+tGIJ
zeWWphcZ>Nkd`C^b$4xIU0I&wAr$xpRPJhnpedvnb7nN)!9kw^(9m_EzMV0sgOKv8z
zqG?~P=|a`oR(+FbgMx+@h>etGEHi<9+T`P6>rEXo7u!A|_tQ=y@7OTHZgAtvVAZ0p
zjv2A{u!is5SJyl6u%y|ylA;@l|AVL6uOlY)J(faAMk+pjT;hx?kr)M~czAd`fRWz1
zZ<9j)rY*GZ4J-QADjy|PdGF3w=m6l#q<dEKkYCIoIA7Nyf$|a$4F}ucXwfd}=|i{i
z=uyy5#;gn$w5`<RakDNBhMKb_aWZ!T`qzO^vW-q%s|!aw)nCat-pek{aciqQFQ`3Z
zqxMRvmS)cFaGkwODC%1zhuH^}B5<6>Q+~D@w+;x8iwA4vCq8Z<3IA<u>Nwp=P(-{)
zEEd>};XnHepiK9^cck1aQX$*lqFE=%JlK1YS>v{t&kIxT_sC$Fr9{MS%liJ*<si|O
zQHTLC8g3}dV0DrJ@QLx?JBp3pxv4@wM#o<d>|WEEyw9SEo(UZIZ^R_J_tA$KCU-gk
z2G)M^<-`N8h-5G**#?Pe@)}DbklS|kZ+h25Iv~YwI2=y~0Jh}Ln?lbHq0c@x>`sX@
zWXa!dO5aHk!8FFmiiOi?x^nYo#YmH>JvAybB^qjH$99>7KTjZSb&D#FoJ6iTh4SvD
z#VEaLr^xz2edxw&EMRqYbrMJ9^@@)I8~c1XbeVG%r$x6lkp5%SaRXeDJcHkRh&dU~
ziBiHWpUY1_rRdpneMHKw`!e6;Wr$I26M&zMINWG!wg+hD9vZ5APU9rsmi#O4FMyjg
zUIe}F%FD|a@ebVe%jm-Sd`GqhA`{_gE&YL*G&t#Ni@hO=(YQY`%P5{ZYIr2FL7CE}
zLG_u;-IeZ?>ysq(BlCgkD#pFh`bg}iSBr&aZWeE{%7VJcDDK$ScU?IN%YX)t>pj#t
zbR7}d76<RQ25lMNaJkpnN2A&-{r??Tm)$>>oNY8GW96xEFt$xAV^8(Pf~UJIel5qX
z+Q)!Y^H}fPb79R5qE|Ktbo}7Wo!u2=!_oTESjOgu0j<=Pl|>o~l-Ys1S^<63bze92
z4bK2aLRrd6dxRG)MI?vssbyNQb(bzX)DhH_|7chLBNG+nRO+ix+)y)V^5=HMl$fu!
zL}i7n2+N4Z)3!~gCt{uFRpsTN3jsTz&BD&-Sm$)C<J6T@<mVOE78sHxoIl0Z%Le~_
zlFaJKn$|pRBPrRe00<T)%z@p#?Ua~IIV1oA_?>}&-zhgc5~gH``1k_BP=EpNWqjCo
zv{(g>EE`Evi6UE@6tXbp4e`03JH7?RtFT?0ChNH_=(*V}*B|Bs*ziC!DfwW{v^FJ4
z2FY8tKi~vdx$;(5EFydHiAT_Hd;mawPuLGO&qO)@y^E+lB=wsmDdLTt03v{}kC7_%
zI+=9&oJ{Ts-0LJr`7*bF)fWW1NB?UTKqTwrsc>mqvu)4@z4biE&5spYHv0g)v^PMS
zB2+tU4_MUdTXpF}mlr(W?h#MAOY}w~@z@K%j#<~w!*5l(vkWeO-WSGD{ucJEfH3Sw
zu!rxkF~Yv~O(fE(uY;$`8Qn80gGs9yU!V-1Oj)9o>#8(blIU|+k$Sj+omy`fK+D7*
z_#{=rFxv;gNl(D(YAB4moXXZ9bSt4Tl14S;S=sgG?Wrl9+ymWGf^Tr~5sOFt;~Y2K
zG3>vFkWKu?6G~#(?GXH^angi}o@Fmpn-iS+h0Gl$b*l0@>3Yl4XWZ1F+WRq>GIF$+
z{O~j@+|A>}*Z5gMTqHX!l_yoyl_9r5YX}QU9$u1C4GmT7qSB;d`tm@5cp@id$gxL9
z&X<z4aAZr>aXGe+#@w8<Zx|!=cwpi23$ED8-{yPGM=14I=Hj-mwTo3mj@VLvHB!9#
z!GsZ_UI^087V0V9q91M?H*yL6>C}a1a$O!ip`eKYft_QG=-gmcUI7c<>~kFq+?eaz
zjruSN?2Y<oZAqU$`ETd0Sr6x@P;SND;CYf@$*sXM;=a&2uY21S3vJ85;;`s587$2d
zVPMZOQ6dy#kO#hoj4aA!^f3jN4@u^4-RX=gq2Ma#e!i@BH)-8!(#NoWXck;3+TV_5
zPk=7j<@Ix~Ve+lLE6awHM2d)gpY^QUfOn9k*>zgdW7HKuAs5DD@A7M?!(Gv=>`H|w
zJ=LAN>`59M-tbec>2}da?$I<H`?y+ZM5*ZwWY)(OyC0RS`|aqq!NIEVi$&iOB9wDZ
z*#gFif5|Z(tQT-<o;2}n#jU&Ry4hoCVwvGNY&;Y-Tds)4Y2MeT$b6~|(AWqv>B8g4
zvZn_Tu;bVTsO7TSMg9Ll6KUbd_@G;CgKl<lq<H*W%mOGs_8C(h!UH$rj~(F#fV=hL
z1#L?e3nTl^#8?;vMKLBKXmyc1)vW%jeO-=|g7~!=ca$d@>u0|GWhMLPj37g8RTa+<
zIR6Sik-q&P#by0j`l;{-U);NN2ONV@5Ym|fczz&d@q&mVXcLk<Se9s`ZpnH*xIt6}
z4-WPK2*yV|ymey!vrmytCv`k~Gjx@GP7gbOB?#Td$NHCk0u>fZlBGFkOSBuG!IB^E
z6Ky7}jo<0Q3qvMCCXF$%{bTb+%rT9d(jmHqAzu{9bmk~UHU5jJ{(}EGo(zBX^8l-#
z-2tc{Tr7p%)SGbb)Og}X<D56br2VP38O`jE;Qow+&Q*4>mf<f~b(wgi*?bfNj+L|(
zv5&R_to+|#?CW2%x+Kspx0mrO=<*EUC~H%f(HXnc>_Vs$!D4RPcs^XUC&J4`6xif^
zA$dq&Is3uEVN138xoKk-D4wZIe@6)&iyt|=iHh9+kua0{05*{0Mrc8ig2Yn_^EM4O
z^Th>3tYi2-N)-1OE{vI2S1=Ab=pPH~c<_&f6?J_?nOvO=RYf>Iy)P%5JpI*2_a5gP
z_P>+i%MJOxR7EtcI`sBf=SM>JWf0TQ64qY$h|IaY^`6}b%=R^CWf$Nai5=}=Xei<D
z%C<{}1ouDp(w$aq-7vz%6zPi6BBV*vL)}Z?sMBJ!eUcH%pg_;bIB=WHFQ}-67&t!o
zzOT8?;wNME_f<@#?FY*iA=741wK#k;?&1)1&-IpRHn>VFZ_ddbk(8i|U2@Lb`6Sg7
zY2ZIZl<#uyEVi_)AFTuzB}6|ZvY1MjarLY2xEf`i=S&bKzY&`DWM4>bB{6L4?=+8E
zrhG)I54ont<+JbNt*m`xaK$zT4<NF`C#6-Y9DAa_A*Qmw(_Pd&tR2iuGkQf?>*BX4
zIZ;?S0*O|?2Q(P=g?M&!0=3&r$ehI|b#-;jcS6=t^V)E(XAqI=m$Rk1;vlei>Lm3$
zg`uIK2u@sA)uO)QShW}837o(3tQ+YuS{})?B0vBp-kx`LozwWmlqBy~HPpS6K+W{&
zzkYu!fUB<sLXv)(@l6GD81LYsaFNPl_Fn~~qpkgTmE5JfoWeA45%@-E(Xt_Meij5m
z3@qW0X;aWN*rU%&4^FLykUcx0L-8pvb%`TJ?Z~WQubl&h6st^C_o~)i;wkLKPq;s*
zM9r%2Qz3s~!<Db*L$A}9&6`!5v+}R7ATgewpHCa#J8gn|o3QZ2Df%*L`9qH`8pSv;
zCHP`PD!3})husNx&Hkk;=S&@e05ZD6##ZVUhV6qAWXbVO?g+Z;hD5&5U9jo|J`XMj
zK3d%nx>ObQmy@Q)8!Us`IuL1dWgD=90IpE`WGH?D@iVVbhl4{kIHT^N90>Tq@q6h!
zsBg$&a;tl*+o|tlT|$;~JBodinp=X*{os!J6K@r49lL_zL^wdKk3=2B$kd_`AYoJw
zVP!k*X)SzfE1R>Fckl+TMcdDE;lfq@f$*`F(V0l`hnXO91`TBITg!>%)qDA@CjoQ8
z$pIknd`s0k#Aj!(c-nWwv+{>44(y(j{yXW;G_7j*o`~ROT=|l}fn<X@_v9BVW1bB#
zm8Hvc^zqTNZSBqna_>W~@Ksf8mc<M!PI=_Lquzqc8ZdKU*VD)2yR?$rj5s*>+gL`!
z1eT+%If=u@ccm$KDYU{)v|A&>=pM`rhc_)Tzf?_NsQ`J!9LW5CB@tG^XBF0-O4z8T
zb;@p#Oo>Ft`mcr4{`SsuQsb0pdh1W96v_pO$E`9Y7Kjw-FsBt2PSyC7?<#XJt12sF
z>Yss`(P$*Y-W<~QibjFYzlOfk=ibjTg**;Qkny+?F!ZW?g}D&T{E|z1S4+GtqbWC@
z5Ig3r;&Zt6Uv9lfFv8ouLQ?r}HtbpF1JYoo3*vFiK2BVj>UcCE`aVro4SiUky2fhi
zc9Rq9?k_k9Bp(#f1U_39iB}T;H2%xdGFEe<E{NwLZA`Re`s;uY{?*4Xg;+>Hscg*f
zHf37`SAu&nG}5c)0Wm{dCAfu(EqA(nRvO%hhT6P${<<k{_oA;bzH7gyCo2-2Qc`Cw
zD(92`Vk9OewtDw+o$$)9{hgcj62prvTrK8kvaGCZn|wmZ>ZBM=^xMu^nIO6QFQt7R
z^tcNi04QQ*l#|UH5wKN+{x%YGBi!Ufb&@Dt){?i~1~>y0d*nCk9vko0uNsRxjtFCg
zucHbdXM&K1dN-IHyO#K>?~AH@x32o`*Yx3nJ*L5MqXK}Z*iq;3tEesw7mRikVhrH1
z|E_w9=oY_ZTJ(DiLvu(<yRPi@n}%OdN}LF4-RRfT@<ggPH1yqKBc^q(=g--G5G3?&
zbVS^4y^cJ7RFcYShUEqE{2W_>sIii@94m3vU0GE7FkP&;ydAToU$9vMzHLAf0n`qm
zDQXToF1EC*iXuv@zyCNoYz(JT$(Uv9T=|p=S~!F<w}9Lk_NxO_kI=>J4yKgUK7QeW
zTt;;?<<foy01Cx+l%ItGYCQtg_iC-8JZqc0|55^M8TwGu?il5WXgE_!$y1uk8GbXl
zxOMiP3GGB7`5J}UH4avnw{KMWRvE#dP?3TYc3M{|CL)i+AMoI9RVuY+%DxmkAn5&8
zwSC@3$_!LjQzM<sV+$7>_A*Z$xz`uHEy+1ED^w)=B=n|QZ=$v+<GmYY_vJ;onmm+`
zh~|CT^LT<Mb3fc5`d7)s)Hb7DysY+|QG8sw42z|hVw~x3xiU<N`KY4b!r+o)S3?vg
z0y6qi89@^`FXTYUTYNw$*m!bzU31TbEUwi5r}_6bWnqPqkt1CtIdKdZDgDhdi;?v`
ziKVN?J0_@mBAWcL@tqFA-n(!tW{N9LN$fB<!oiKUMU-;~N#$UazAlx5DJLEz)qV7x
zLQQ<Pjjf?$cp%`Uz}9{53Il%jz^D?l^AjiaH+>_LJolSs^O<W+s{jl8Y}KQo4D;JR
zXbBuGgwh1{;+^W6azGIKARAP?q{~uCR@1x!nXxU8jEqNVVSRuq`<7TfAan=5!tU@8
z4FQl<*aAp{kDO1&J?5lI(Xe{l{;X-hjK8>v9*KKq%{jCzH&-p<w;h{3Gz(_OH*RNf
z-MZFURb$myIIk-*$|C(=_IL3s%3)C8b_Q~IMwPtAtU$AG-7ymt!8sF|wpJg^Mz;kY
z^NeTMs;ccd`+wekG6LevU5<0`sV72i1{9`67r0&ZF}EuGYAs7)<+c9?{cJ$Avp*A;
zOl9*-PYU%0R;lxnSpiE^Q?nn8Rv6aykUO0BY^Is1L@*Lo^qVR|Z8cpvn8*yJs&Yzj
zR8nFn^`F3Mdtf#Th6tA9CwIBE&+2vz-`+uCQb=37ZrR7Vqub@H__p>P<~b`_PV<sI
zW|p>wG@UYDS=olP<3B$$w8vfa)SSo{Tr4>UU6PbRQPax{%h&biq?15N@0E4l;4?XE
zGkGu2wRX4saqaHeb;YisU46x>Y5Dlrx9zk+`_$|j>~+@WGnqBN*_WeG>rq%Ff&-xJ
zdi~(*->64K1Zje3t@^bGOcT}12~t<P>O$jqlV2vS+A_A6gSEO4BigEWKYU1(1k(S6
z!ZN4S%<OG=&hE^5^MR|85iP}*?)zt;JBB;`c!wwEm?x%8chEs^w>5@x(1m<Zt@5~;
znRmp29QcQ0(sAj9#x76HHt3?ktfJwZRG+k>p(^^a;oJ&RxiD~FKfiq6z%|hHhS*r(
z6e>ZQ@8Z)pvZUBzFv$tACKr+uQ@Zd_?{dW&Fw#bu#DOOufN|LHCgw-vkJm$At36nO
zh~5jEJDjxSPT9HEz7wp9-@c+h>jje9uMB;?U4e|g&<c7a!h-`AxRCMi;_SVKc^?Q*
zWnTfE`xq9#0nOe9QVKwb%FwrcHjz4}2uxeDun8mDbmjXSyF_Gsf_W0KhR+d3JZ1n(
z%GlDQ;xo>9-#@F^w!3`pNCZy+)iZJAR;H(|guP;xBXrmZ_^~oIto6f*$H^sqHd;KH
z)qiR2HNe|sFFf^ofa(8ZuDTKU7>4~}xZb*$TwjpT!}5drh=^RK+}qv=@3dAPx5jMu
z6Os*vv+%^^Co0QeFB#YvGyx-qqcAUhggZB&oq9ZF>X2@DR#G$LZaMVo?^RWH0!MTh
z{<&d!S(>FJl<i*kXLECNYi(|^9ib@M%m6#cyVb2mk!-(oGB6m_gGa?>tn2b2x*(_j
zFf~iyyQ?HKp2%&X+x|pmo9k)X9o<!r{F5z_488FukvKM1R92HQw}rQlbxlv3jdc_7
zab2CZ=(s(Ng?SU`ojt8DE-hqS6%o&U6ygoLeEvGN?U$$LURCE%a~5tca1`5s{e^Ho
zxiX@CtC#TTCn*5kHx5KgN6@=MJLhJc>&<#Cp}-VKi96dK?Ci;$A{c3@Vcwq$r&3K|
zTTk91bC0^jV~gKnwgxB%6?29Je0)hsf8M7_R#F=>O0JLwGfL7X!Rx1M&`HN#+xb&B
zG?f?oDjK#c{KBsKS`&*06+sflkn&N#>o(+czcS19j92>@^3vt^00)d2F>h{=->IFq
zM&}^4nJw!1)O#Wc#8lqw>KEW189k!I@NGe>IQrgTL`7sKWHj*y%++7qX~)+^^SJ9F
zMbM=kuhknJ-5xt`f+Ka`qxbhGKRJip-VH&MxYB!)RxQdytr*;>X@88F8}6mZ<T(lh
z+!-?rX3=LOGvj*9fHE;wdv6HRMTeaqbaMUmB|l{zpZ9{??00#T1DOV~dPJf!-m)EC
zH{PS2azF(fX@v%n-&2-b*QJ}U+wo!XW9RGNY|o>WSiw7azZ=QovSk|0=euaO@P`oM
zwbvp#efm>u$p%{`NUo}gJT)>s6W(uL`}}qDrjB`y*@!xK(Qi$;!4ke(=f+)4Z4@H{
zq1R$4)FpwCWXn$aXbD{Mwuw_2X1Wo<b>76-u~iiS8O~kSqL+Rvr-52uVcxi@jzDBV
zim#3ixnDUxw)5WSkEPw0><@R;AH2-(wi9?FodbO!fR9;#TM7267lOIzT7QU9^uEc@
z+K1uUrzZro<}aJ)orm(p{0$$ZYRu-X@8RI+D0s0Qg0XTlm8g(c6CzUl#6xPn0*uUa
zJ2%g~XWc&H^hjx{eb;AoZ0?+CA?VtR!fvJ8Rp3t#O!I(<_6y%U&dm!%{f?IYAjwiB
zW<Ern{@{=AQXh)aX43tU?mA^Okc;^R?oS?cUreL`5*1{S@AK{ii(><;8+eVSi^s>u
z=a_AJ(_7BCJ2FB8P&l3ie6DH2P;g^gYitX#YhSIRR>uY{<aUqy`JTJ;GCo?emTP&z
zVAi-=JOe+sS8h6BZ?T6!{pGYQYoW=-5lB>mmhM!RvX1ljmxC=WFLd8l);sIAxK&X+
zbkb{eHWNR7oE&>EJ<$tm7|j9*_$vMh_ypfEfMY<Cjg~3VcRh0D-D4q1#sZUYb^9JR
z71_Q8*H<bxap{>2jW5MMM@M}}Gm<6y)@m_%=j-zCx?%xEnOC7GFf-A7aaIU4d7WoR
z*qH6pxbLxiuSL2IEpjsBcLJ&48+VIlF%_kZbK_4>M4;zy$!&Ez+>%e~oz^i__5@Je
znD~$1)itBYyW2i#VLf7-%4kp<$>D};?sQP|+iSq{xFe)BocGn#T?IrLZo6j<eg;Yc
zvVFAsV>@!?*9)@HhR3bvh{VT*w!^&bxg_DdvNuX@F!rJKfCi@7rn$n0wQ1#aLIZiM
z^SrJq8i)Y7`N;PB{D|Qo7CiB`kzPbmqy)PIFY8k#BO+0P0jCYJy5xMpMV|@N!SWJT
z*M@@roS@t&!!E(5;jMb5cTAwGVm&}lX}3=1Vdw2(DQDKDLKSBM$@+hH1i;FJNR8{y
zIqLGs`XuO$jIF;{?t5g-+Z3K%&gs7<d#=^}IgU|!$CLBTm8pVUUB9__)Yq%%^F8i{
zX$Zc7)iQS0{`bk*f&NE>@uL=kfgH=9?1NfUfy2kaZ+yNW`60zYSqZM!$O7ZY+^@Rr
zAcjGOy*Q{@8Aom-_-4r{r`#RS{^ZM;n#MqnCxhs1x&eY1%4FQZEj@ap$Xbt8k+`To
zvH$e)y}%%mD>^#w2pAXMY~>UfW7McDQ!;vAw(qMic#m=<e4eY3k@xLV|Bt906vI_;
z3cM24cxUs2_w7FbdimZ(>Muz8K!YwU7y~x>qF0>XJS_@S*LkJXUAaCe08R8tDp-1G
z+IL$qaa1|Qj^Sg+_mHJ3)6eH+hiTR6>eBfQm)=Ci^-3{Dri%xzZ5R~H-C{Sbb|tT`
z?zhF0dG|hQ<htjz5MTPKFkbs)P@reQXSl5W2b)PEn|dy7Nm~AA8P}7=xD~D8&%>cQ
zayUZj*jDir7mJEbXt-G&!;@X^e;3hRHfGYe2EX)dbyI)9<}zde_>5klkG@DBF5~^3
zj?d~%_Y%>mmp0=dn*`%7PkG6jEyt8)!?H|6Z`P#nl?CL@+#SauymE#58)!6lkLU>a
z1B}@oSAL<782}1r#sP+91G%oh)FMrJtCvIXnltlHXa5!ROCUh(>`T?`ZiTQNNd<ih
zBx_!!kL(8&EdhAgFVW{BWSW{LrOI$*ZW}KJ>Dq-0VjWdQvj}`|k<82>*NMtgA!O{!
zN-~8iIpGIOvFfB&&i5a0uC5QRRt{b5>H!jhj^{1Ro)~KVLZb?G;eJ-$S!OaEc9M7V
zOpF?R5gkJ?>S8&^fK_bvSo_4vzZ#zkP3oT<k?!YV-d6XLv_&6P>Msv;NkCG3K=}=h
zthlvgy3d;K+a;;pEt!7c3{+SL7A9t4-V(S`nYb{Ko%QR8L!xEViWopE+fb6iRAP4=
z%H7WR(PBI<%N~AE%t3oinAwCFysn9CWC6qbto+p~2%;IHK&129R+&UTPyOdhb+qRR
zvw?Ki|I{aWjJrPyaoh{ICbpOCa{GwBQ;8}9a>n$$N^to#+&%}6!v=ampjos;NA`$J
zkbH{X4jPG}Yf0t79hD9fYej>gc#{cKoB?(W6t>|dgiT*49jCO+6EiM{shks@sO;y2
z`8;=fgcKSU_HuxB(?~dbY?pU`a!w9(2B5)`8ZV1|6qW*it6a#ZtzWUxfg3Aodv&5U
z6D(WW?*)}+7q<?H7>sVnEYGa>^pLDN5uv>d?25<o*#9N;1T=WOu_hhF=lmb34ruG)
z$eQ075dta+6_ZxZ?*A$~HHMKshUK8B>r&#=!=@}*^rhhgzs`)NNxR~wa;%nml@Ge$
zA^c;yPT&kA^M2-o+mzqy_s2`Z3&s1{FJ@m+KY5O$tkPIoVMvtCMTABQPI72-5cw-x
zo-DMqwx*fZ0g0BPW7xsr^d`+xE`?mM(u#=rs=Mkb*>|G3*8vk|6tcyap0k$(VSJ>Y
z6!s)2`>1n<QRli6qMbR|1mN!o5sd6UO5biQ0!&BK0{4{FwHg`$SP}04mzysCaF)B&
zM%D!3?~dd&tt*cI;Ggfmrvxi36!qk*r^*QH3o+{J_j1sjtKyV(ONS-aQKZ&gZz(H_
zJZw^ZxBPGOdOl36m@yDJRBZg1iQ*nwEfym=7sF@cP`QQF66gD&Dhy+ik*Sio<IRXF
zTOfT9Nx^y$mBcC%f6y9%OIaPjy#@t>luI^jnhm0+y9v+c^qYZ!d5lbykH;%*kHY5C
zV2LqsG@DJKfbq%u)=*riIQ4>qDNc^t`TE){xZ*Ja(cHXI)MNW_*MA`eiaAIl`H<1i
z%gByyi0soD$}|h6#%}%E?;9M2Zu>`97fX{_$#6cLyQkDl@Z$gQ1Ku~Ra3c;UqD<?{
zq_bAv^1`y@t0fAKwRU(iFN3y=3{eG?zb<&5>=dOf23pulgxr0TxFq2ywT&(<*Yf0-
zcMHXC8QR}D*ANeRUr^J#q-&QK-g6C?%<)z_=q<hjVy^dqtAVs4)?T`$j9oyFXmTZ%
z!o9abl}OcLTtty1>ZiEg?*6U&tm`A%YydP*8?AaK^nGfIZFV1iIT8o}(y=q+7^ke~
zfboHi7q92z&e?XTKhnmIto}tm_fwBr*K=AR_d2q{ZlVpL{vEg1%U#vmmMwk6H;FL#
zLH_)XLZ1*k(bLCAfojd8{rxz%F|v7mM&z6vvj$wqr}YV>dZr1V(7+m<7`G|1OeayK
z3HJE<uB7Zv{#o?2ckU!DQ@untxac)#hEyRF^H%T1ef2Qb({-~0SWT^mIR2#+@``t)
z9~BE*HI+svr0IW9D#O=)A6(6x@wU1i^m?=Id9m><{2ba<f4@=j?_<ub|MhZV=!C!D
z8|c0L@i#bwm6Fk_ze$p7F5Uc_H4TiNHP6ksz|Eb0!z^T_!kgwVPmXP6vch+hv1AU@
zhr+KB2OEMR$jYt)nKYUlt017rtfx@@d28lGl}_#g4fy|<ddsLPqb*$crMpB*x>Xva
zyBnmt1VK6lBsVFINViHi2%GLkx|@w4-QDoLoOAAX?++M^!5FaiTC?YTo_T4V{ry32
zm^cT=>F;*1za(--ou7jt?sp7wj&>|g?WYJMRP%2ezpdZxO4@p%IGR88#tQL?<GSRk
zF5AldiG9#tD)hIai~r+n$HEq`%%d`c__V?D6l(Bz0B`5J5>(+moD8$qd3+V)eg65}
z>Zo3@bpzq*M(1I%3&=W-XW9~~G7D;t)%P14GY@3ZRuKrrahG_MCt?KNOF__Gt2NG{
zt5xP@=7<4hlL~GgnE6@h`rAOnal4NPU+>R5By&aL#W9WqF3g{l8nFn9^v9m(ZkTEq
zW-s<H;-#G#=i8`;u%;{E4m&I^BX<(97}HJRoX7}x0(q90q?TfRlec+&ZutPkyW>ON
zWvuqH@$tS!Mh640rG{ux?@1$fuD~OwyKu(`+CDV}(V@f8$EGNk3^d4O5!@lF;74+!
zs;GZ0Js<TjB+xWF*h|=ve==%#m{N<k`Dn^B5h$2`5;*s~8}j%X_#Vkp$tzXxa<PDY
zZc_-yn2W^=l|3vhMSv}uv$j%T&2M9=8<;s9b06kcwez{wFsRG=eLm3E?Ee(o{ArN%
z@vvp<{tqSYwLx;rj(o+_q@SP<xH9DLH-KHEE(*WhcfHNJD?@>o8N>_S&}Kf7Sv6ua
zmsL(!MD_IW5(YPil^3EZ>y|5t7ver6*?wG2gEXwD#|yRUJZXPIJEWA*(J^Ua2w>Q2
zYR^jxokyR)zKXiH8J#UVmbI+u)d{bcwv769SQ;SM%|9gjALfh{yYD?cB7U=>C(oLQ
z^*R1st<Cf1^#^z+Vti!3u4BjSZAaC+;nNpuFZD~)S8jH9i>Ht=I$v6Mr(Eh<X6;TP
zVBiH|Fm!$Y;*9z8^)FlIyN^7*8i?Yrlj=`m_y<SN(P-Kci6I?`#OCmSL5w8eyr3rA
zVS9E5^Scs!gyH)ge5^xwUkbN>GiQLa?0*EYT828pK2ko-<;hYY(BPJs&g8|Me#d&U
z9E7NVDr^`>>}aw7!ksX<h^nZefwp06T1rZy5Z;9xy%Q6E)c;Vmv17VM-#E{CTzG@6
ztM%<i3`Y_~p7DE0XKb^F$ILpJHiw0;q-+;{hx4+FCT%CVL0>7Ryvs2j+kGFHVuhaa
zWXYO(d@Y{H(^VUY+OHnhx;pS?aYS5JWsRCFf$P=m`<>c6ujMj0s`u=b$0s9XJw-<p
zE^hs6FMi@HS4(*zi9dH_pD|3-7}c|gw%{nQ@ri8<ZwtfiG;2bBA8Vs|Az~#*Eyg=M
z5=(VqZ?<*s`mK7H--q)(Z~uqGZe)*x8Qzwg^6lBD8`vd6{nl_Bh<mG6H9&Gw@<_S}
zFmP<zU#Ikb95)CHd;MC1r#CnVGtHFa8#dh5r!x9JbNYKG)XofQZ02Xokz^{?PINyw
z*h{$3omTWYV6!rslLKIH?=5^UOMq8RO#}RKPEJaSVZ3<H^wgbbZmWn><-8<TD|*f7
z@9xqv{vJCHUQ7zpaxyV|SaQJ>>sMgb8*r8Z!~)C(csrOJhapn?PY_juU=OMx{Qn2-
z;lOyqzaP>wWVZ!}j4v1W8*XkRv3L6Eo^8~BUQyMc{Hfn|i!aO`nuie4`q(ha#;XmG
z)gR2@_^p|<32l0+M~J`76S{i*{Zkg(O8`}<SEwcAmGy_<=dSb+2Ljogg2eeYghdtt
zw^K`>ptv?Myrn=Gj80{;ftunzxw!;RhrjI6M59vI4%O1#zMoRe_Sg`;UzcXPX{b#t
zWYG@vwQKe3X%pT_O@4<XjJb;7e_F6eO3E{3L#C<6WO+!wdmt+B+{rFGJ$M>jW8>TK
zi~`~G#Lo4LdIh!|=7XwvHeUv(Qk@{tONB<}g19aMYvYfpOTFGh2t#%W>K!mAn#!up
zn=&@Pos0sJ4aTg;nxHG}-4!7o+ppNZTTD7|*OC7BUv)$*Nf9vl-YNxbTA;hVTcSbM
zc!$<OxC27rw28fc8HI<VoeimpX^`or@U9KN`iJBBQ}ewSKIZg@g8ZqeVQ@>Spnp|r
zP#7CNUeHU3VqJ!3hpS(0Fr1Osl6j0{sneWEIvjgI3J}x48c=U5jnjJ=N{<G<6{_?Y
zm$Ie=dgo9Vq@}#aFQh@TStpFR)EMmZN{wzs*($Unedprm2%@>6`%OKA|BC79Ab~6J
zE1uoAxDM)tk<=PRDFz=Ib|9E@DD#VdPVlGV-lw`Mv>_6x9wIny9zuW6KK{GEl081S
zj$`<O;omKRWwvKOZzd88s(hhGN&a;yxP)>r%_Ve6KH$)^kYk3={_agl%FDNGcm#>7
z=A*_=pVp2Qkp=1F;Y|6UH@Lm1@Qhv>)Il>cs(94|AUaTCDIm}B8~b7~FGKVN^1n5L
zO{BX5-S2L}f1_UDmth-mw~IR^HfX?;-QIV&?^S#38@PLoq6q=^QKDX{hqkKxw79VL
zh@X5ZSSdLHaKwbhy<yl()m&#|1+gs8gU*riqO-#rDuWSWOEqZH=A@m}Q4fEV<T`!E
zKE3;8b6JltNR$u)4k>&r^3yv0cPR+{0$FcERInx$^_U^1Y1|C(7QL^n6Fu58HiT7<
z7fs{7EzIP6lfm~U+(@-Zc7622<^~p%d$wrnLG78}ZUKe90d1aL8duzJ=TGr}1aXkR
zO@@c1vCBpkLnX60)zd&cb*B%l1BhNR0@cq|>KWe+Cle&#Y}!wG5SR+L41LafmoCEH
z7BIIuY-#=s`ODC?|0NQ3C!}Mb>FVfiS11z17X7_5XYPM-<#)A}eYV6@-ntt?WOUz9
zQsFgF?Z0W#dQZvb*&Cwc^SLii)%!NlWceg8l9l3k`;4ve`VYB|=u>B8dGl>?w(qX0
z?@sz`H>K}i`qAdK-4c;Y9sh@>w#z-ooA$d>c6=ngQE@$&inH`Q<T>PkK0$F3gxYXj
z=MO5hY9R17IIEvLkv$RwGM*{qtf1P=TX9xvy^aL2gaZ?I=y{85z-%KM682DKfVMg|
z2eA_Ss^gOPtd;0R(MDn-le?j^RCd$tTlL-S)^lm#`A0y<?=#99?(1<T5Ac^d#=Zn^
zE_xjAb=Jm5eK!U@V2?TA;;RCO)}8!1pH<)Y=tBS#4LnDX_>dA9N_9x|##$u_tYk4&
z>+V5@rF@?acyAWk8*#ihIqS+A%&7BtcLbY>+Y878b@39EoZWu1zkKeHeh9Qw{6a#;
zO98&7R9^i=85MnMj`Tn5VS7l;rvF7`a<8Pmi$r9cOSY9b>fdU_khh=X&i}AI`ZP59
zV*HG)IV{2JZ%^_!^~-T0qtl^PwY<kQ;iDVMiZ2H_s(f&@TZDM{9C&X&dOJDqzw2w}
z&8FL4rXEk*?`h=eTynkZ7WofK7Hm8Cg?z~~Z$k;H*$OL)u~nNRGhZ+#k>NQ~wi3KD
z<Vxf;<#o9(%uP!DDHo8U$JOc!TZUb4jeb{uy3S*Rzn(2=#axXb*Fm^G2M37<FV&hd
z{HBnDE0&zOA)`hYiQD5(M@%NQu`6}{PhUlE!YP-0T&>s<za|KGDZEjc23*Uz+lA#V
zIB}?|0^~p>x5SN`!z$uW;Q3h6<p)JvT-@z=UGMln7s$ffg1oG4n1;z@`%O)N1CAXT
z72ToD`$?Fs>3qT!WThuEIaRXsn|I9~90CRI`}S5O+ZP7lZhP=f==L6i?ZalW@D~5j
zeP<+FxL@n`n&N&AAmTNTV)DdP;Ww4U0=tc6Lx8ADVbg|5a}iVVFo?Lltrs%$h@y$5
z1q=1wbLqJ@=mksdXwp=nR6|TI_87GBEU3*~xv;d%<(HgO#$#-hu7O4$#7G^2RE5um
zBylL{^1Bx9&da<V8y`dQNBPKyV)pX0+aCMPc)X$z1fdJ+IX|JuXMev^2wY5Qc$oNi
z;ana1UPc;U53N(U8k&c|g;cW6w?lX-KmWsN^`CqpKF=^cgvp%!SRd<uW@EVm@<?A7
zP;-GJGuP1|iW$Vmd?XH}()>11V((f3mjrM6lj=8dpi&Us5Y0omeM8n@?)WE7YIwWq
zimStA?_LtC{pF^sJ(H)~b;>7CB{sDNO1)m!l`mV%K4-(1A#@Z1>rq?+Dx@WFmNZD6
zyf{l2qJA6GjKYVdXCoqu&dZJ_{ttQu87`BpzUG*2lljUHb)t@<C*4O&PF?Y%!n4lH
zIuG}Q#%HG{^*5oUtiCscSq&Q;2HHIE?@f6iaB!tRI>FNTT$OnrF#>7&GrA}6J@=_i
zNFvdPHVJV#AEgwXe+z`16OOmPNb+d&f`4GAq=c_pKduB_Jv}g)e1T=&wOvL#zE&TW
z#4+(+zWBSzKefVxLw<Y9J$v2S_WAD8<6&mc|B_zxDx=R~@%L}M&^PF1OoBY{9L~%}
zO@ikuu7qoA|KWQ;)yhZ5HXOFFGsDJ}#N8xlsAZCFzS1K2)qz$_2$$uA<1qK|M*_Ih
z#|LSX_^vvwlsq9(&4=WU{yUeGb)|Ly7pfBC;U@-C<o+vPAOOFw(VcplvgCbO;lHj#
z_vdgtu2Ou}I`&u4QZL#K&3^?*CmJ10ZU0a89&zq**3bZ)6!}~@o9*p4o3lJIYb*1M
zA{ILcZtZ##5l~`(2@C!YHdw9rN~^|DU+qv6`}xk4i@%`?8w`x9>*+ZE;w^jzXdps@
zCdp!{{>98yuu}v{LcsQsLMh4E*?hUY+-Ga_gI?vNFoN~gyCeVonKG)_=<qfr?EnPV
zAqo6~0CTLo2EqEJuOpj(do9`#3s-d*q^16pHQZgn<`rw{#omJ2;G4hEo`^1Pm4Eg`
znm#O(qn5q)J{WP>vSs`e{HIa`B`U;M%&4vba~0pXc=Wh8dQY^q-1%D=9GX8Sku-%P
zenOdYsB?V!ixbO#IhUA7(C2(A@WMkg(R|P-G$Ugx84$C5=%@X9)O?102_;oU%^LE_
z;rC<VoQ(q=nWt3v*oI)`(g0e>grOr3dnBw9Rl@O~qvgjUaGuk|<?S?c!?@cwc>7^;
z0IvZoWj|ey2x6H6$R6~xK|rwlps-}~)I8790WeYJcKDbaMiwgh??qVHuN-8Ss@^w!
z%5xP)w9oM`JB5a`X+u27{m~zDKU~ULP1l0=+;&Igv#BTzgUd^Ssxv6QVZ({-zT{py
z<~>Z>l!MR?Fwh_s)<4jAMtNu6y1C7kS4E`P!nXBxu(~5aoBR9yZ-mjlOvCDil~1K$
zn|6{S40o)McP!;ElLGE72c<t($PPZekcJSn4uxmy%kit=)X|T!5WzS@Y(sUubqmrR
zB-6$yuAe0@4NPN%Wv0+xGH$ESyly4qH8`{b8OO*H5c@Eq`V<2Wt=h(O%t?<{g{{Ob
zz?dpE{~b!!g<yjv7qNd1^{xT6z-(f(c&87?9{4ZAUTb*$!CMDi=+5k2F)Zyg&Ga(^
z{;%>w?WqA4?d4*Uk*>urJL7HE^wG?Xj8Su6aw^H)tfaT_AgNwQHl7Ir>XXbdX>*pC
z^eT4QBHLqFV8CmcP>+xUNiXvpEFo!$x8+G!n`H`r(Ed7-_Zc^u9hDgjzfi&+MzGR(
z9b=k#TMgen17!MSAWe-PApzREI>w~2@Hv7m>2&BXt`<YrmqBcTW2$lgnD(m^yR88|
zBO~&GfJp-xv^f%9usEAyy)Ued_tUf?8XsMPmBq|B&emHyC67V(8F?x2>lq6v#oexS
zf@qFhSTV(T%Y!2TSJhYFH-i|V`kG+q_d7A?rY#JLf1N>zoCg^Vy4!OzET9Z@X2hAl
z=HnQT`+wAS6!*WZCT%AXCbkVAmMkbz<<ON8-cHB)eW#$VB0k;<MaRP7K=k*uKP`ko
z>!IB3YClrE_D#vW+yk<lvhjN}@&J(jf}a)-J*HycZgT$?I{vA9HtZH%n)bhzVU+SK
zHhBa}M1g$mzpa`{OFa#E9(b~su<w~yVO2N5EJQ84T76l+TUwo^`D4`IUKhQ5lh?0?
z{bu9a1B;>kQ&ou^UR)pzz&>Qx`NU;MGsjwOW?nOHr|Us6z3^x!;&PqkTW54JFo<&~
zDrS~aU!pprD@R=px?i+zZep~8k3RxrxU^>s92s(XTk*yFi8v7dbD_rJvp}-X_J4<J
zOa28B1{0XZ=$mm=-dwY=c@G+VDnj18xJc5{%L{uM=aN8!{-FJaCa<6MEz+Ep)Y~~o
z7{HDKKh(=!&4Fxc9`%q|hPH?`r(d<XD&7_Pw{TrW@PNSa%UJ>J^789pqhK;x!HY@q
zgOwJ8@83YpiJ)yn+uNy=%%(?;pZw&;_;M=!6TC|*n(NoOBjyR!PfXumWoEU0%6DGB
z8N?*sEO;`h2;Qr&^9dpQny@}&V}a1>5S<_yL*ueU-!u`R?j8_$Tp^ijn*8Q1lcnY5
z;z3s#52=RESgUOBb!&leEV$6rw`~5?f%ieJRn3fXdbHUAI3O`2vnMOM(?j&Q#`d`9
zy`uPTCwDOJK}OuPiTT-LynlB>`dcO^z*2`n72)F$H8V4_TA**viWmauRV*{QX9dIx
zRNj{#%+o|}tCXFcCA>(y<7kLRQLfyVl0+UG>a&NHL(2m?FxlrIXi70TH5}~!nDMxR
zNbJJU?B2zfynOktLrtk0Gsibw)BYt~6y+@rY|gWr*w?+fia@b;s~RMcf)NLEm{=mG
z=cP5ZwvG(B6STJ;InK8(LkLQB@jdc!DN?1(tx8(eL;k}m;u_oC7yRW{NqnbTrO81*
zR5-cY7Ba~D_kUig0Hel;9n#c1Wdoh_s-Wh<{J_pd$_{2d^C=@DDJ0!8TwM5E`0?<j
zm_Xq8<)ZI_ch)*dPINg*j@@c96q_*0EQT<p1JyN`me;tLEq#Q@;DjUye9U0IyplaF
zfi&uu^6zM!Gm4b_7G3F*eEKHe$eK7J@{a|w6TRE*pl7)h>{H^UP5Zw+;yn<R>LVwP
z&n)rs7^_K?D`=h?g4IFYeg)lY%ngf<(N~KrNohBQ@k(KGmcHzN5AxKn+9HHrwtS`d
zl7eMYkoH+5Fq(g%Nbl!I^Qf7jwCJjbg2gNx8ujj02V2gx6nh5l6w}UcpPeA%^1(jO
z#gIUDg6|(wl^YzHV&O*gia5IKQs0NJSHY-I^l>9{?;YL2SoL>RPthCR7{M|lm5Mjc
z2}bqfFJzrpsg`Vk59XToXtjxn<069HN}=)`Btf^oCy=`f8>qfLj9!TsHvFk}Wxf%y
z#ajJTy4t}*dba-YiFApx_x|4mUiz{?wHmv{yC?=ro`p}t`gOwgQ4Ho$;<(1x`FK1K
zbSv9eUqKArFUF+*a4q$4)Os&6##mtwdrb;BnzvA2GQIp$(>fp596C?Gf>=TmUBSs=
zZOdT#ioDja`!qWz+*=Y3nY2eHh$I3obY_*ER-dCLbVjN>Mp8;iifSTFEHohi?)3}P
z_4L|V&R)-$lax8)_3Ka}9?UYmJG=d6+1Afsqn-y@X0a$PMKBawg5CL~o*(4t=$nmd
zV0&iaN#V{Xe$2cdTeq&vbSi0Bc`1pD{^2cbfA#g8Vq+Dn$=(qAvs2}tufW1qZ7tca
zC;M!Jt)q9RWg3_n*Uuotm4J`~7pmxvMGE5zm1}6VVif)WFNddl_sRl**fl3np3hL&
zm67mx=`FXeaivr4K^cXc!{;-~b_1@ybLv-*+xa9%QBU$HjiH+fJK^*um~t3{=Q86+
zO?ue$UXsblG9tDMQ~E6#vX(N!E4Z}dMGxCY{fJ91Bzw8YNR>LXa4KC#>7c8mNFHy&
zLv~(IBVEdk@BNRJR5|8@Q+o6|pOln7J{}(FdVCWidrJS|*Zxr3#0p;+ic^;n3U(bx
zUk;-$u$+6Bcti6r2Wgqf8F`Pz4pu6a=B^Bk$0$ptLo>;Vhs^YxQKM7A;>L63V8Cb2
zv1XLHmg@gJU!#ec4LBb+2wBl_AFg>Dung{oR*^3|=o^wj7?R=OdegJ;QH(Sv$p*Q!
z2A%}_SF89*MP_!GogZh22spWA3uMhYd||N+Eg0YpB{5a?4vjwYmT4GLTHtN%>m@!Q
zC9etPNsH#FWpuOqw{)S3X>CRSe2~One0vl&7+@&=Q)w@qyb8u|ZfOJI0@GI-mvzpM
zbJ4Qzb6%L5D@9^)>@GO+4|W%iWQ|MZ&P3B#I{IdYW%Qz#@l$moBdlxiNwV3o)-0!9
z9toY}23;+EhTX>5BgZ>VnPtZ<a*zBUUVwQ|d;2-!E|boHyO~%EbBd$cWL>VW@TK;v
zv){&hQ{0Bx@@`Fg@YC}Ks-NY(J5}MjZaWCO5~<4M=llGN;h4Fjdo}AFW!&dhaR^U~
zrM~jd9M&-@@z=x)BTb7urDKNWaWke4uWY>S)or@+vHI+bi)eWfENI&SsQ%+m6l|`5
z8p}Fl2n36X8_;!e?x$ZpH`k#kZNOY<a+`An2|BtiXm^M5r%zjN+l6~m3}%)JYI#V_
zRgMR))1ps=hV2yNloL{-b$i_<!q?A8r7?sLbV_wWJ<xq!%ziWuc&!|&a$5fX$E|pe
z78>HePSB?9FbU2Y(6v_)nc4lRV&EBLji=U@vZzs&AvvgKIBORdI7MYZc#W%jC*w^;
z1FLJ8Li|AP!~4S*2Xa)m_zCV)QIazmay5rSyxHVT)>a)B>8KSfU+gZ|cer<MWNe5B
zr7`}JY#2eP27RtKcpaZy8lOrJMFrLMoa>?VM8)~nVp3Qgc&C+o7IDFFajbV^W0|>H
z;`=&<s5gGqw3kepfp!C<)*yjY3;mrFBmB}EgxbcPyWE%7*>Y7JQs=|zeo_kK!yd-x
z@m6?61ws#GxYuI>5J!`iy9M96z)yE4jFfiEia$0`PQWx6A$Wac<#Jo_2+nB%hu6pd
zNu2#sWS8Ohz)<u@)haWYuJKmRC~%Nw@kr=X)EAY5dJW$myP67LWwLy+zTSm8Wa8yN
zX=6rB;!EE6bQBSH$A#zKGr=<d(ViUj;eT6E!+yU%IW2+AO(DNh|L_WaXzP4A|9|Jm
zx1}ICxgWahYRnF}@NXg#;NQ?Rf^f;ODGz_2BU%(nx;zy@^TBbeY{VJB0p@?i-E;_S
zkB=^#UL1j2^acz>udEm0$X1$;s-G^o0YS(5y?{x;$@UD{&W)sy35Po`#lT|q6?;z1
z*VwVpVMhPTD<tUpTuPr=d>{@_DKy-7-c)w+Xz;7gvdex-*=sQD0^35xsrN#=r3J&A
zUP(kWpym&2wt{t|Ovks+hI^7|BZM>?cq7Na(|c*gAi2-i9U;dNcl1RH^vl8(WpW+Y
zrpoC_!#}yfa78;Ztmd-WofI<bP;~;=E_P>c2@avyXLl^ka1&cv_CVAzYknH|rKcMB
zEl%2Z<sU$OJ%?nv%&*;TKBW9W<~udsy)Ap)ZT{?~=kwCeD57oJ#;cL{Ye7OtKZXye
zoiE?4J)47ug1`w<t48`JG=@57-j)b(S~H89#sw5wyf?VDWJWqtvP)ZrZAX0yMd{_R
zD~-iEKuU49xli<R1my}}?#{Srnc)|a$eGYnoGbvY+Jn`v9SQ>5EQW$MNRaV^#H7*H
z%kK#5>|Av%wGJS`oA(~K`CN_R(Vs4lPdPf*xqYm&``=RLYsqqS5&6^*GDh5E<TNj3
zibjN){MNB*=*;y%#ly7(Ky~xXKL)Ks#e2B_G0Zv81pfJ})M{#JIWuIjFV&`MAdK)s
zqmJTgzNCWoSA~)5@+D(7y6Iqe>`Lv$xT?s55^fy0whv<zxzc&^^sDF>0>~(3^R#FK
zvguBDZ*SVDX%4v#6LPhC<tB&eTn%(|h~?l54rQ%O^W*!)${Y8+vG6|1k9{&#F^leF
zJC8aKf4sa!7F>N*T`61$!Fxvh`F%+C)OD?)#UvqfFpwC3-w^k$EMIjYn7w~i=bCVj
z`)~8R6inW~oB@n}N8{?L^R4<_B6!xYvjuyaiPq6x6g*w7J&dg81Jc<giG{j5_SP+^
z0RUZKX)A-PJeo>?`{C;X#Ye5YB(a+&8nTDk-esAsTjR*!5c38Eis)*3qJvdpus=eh
zQ3LypLq1<Yr4)PLHjj3o(>kB({ni*kD2&}LO_w}-VV1RE)>OgSJlR{$(JJI}t_Tl8
z$Tn+(xcV=LqT1`!7ihhC5H$9hv<K|JocAu|3qaDW<0X98ImMEF?+3F5JxKw9nE*#%
z3Y))-))v^kx;@At2YgaGOe@WDj;s-`MfaD#_*l$-X1s(oT(#&|=8%3mA2FUAHhMXb
zR3H9IKZ$vsuthF{`;|W@g)D{Y+UE?<O?>|h)eMVX6$Z*h=Ux);-UwQ70P~YY{EEfE
zg1r3Hf^vkS>z*a={9OdO*2PNGRmS~EF*?p`AR7Aqb;eP_w2^0_*Jm})AIBxGhb<pZ
zZr<QfvFe!g;O7m}mgBc8bD<>7K=@scLDG7|VWLf$w0k#&H+fUvnQ_I58q%g->B-9#
zW}Ee1b3YVYTJPeh@H`Z|*L6rZk`Jp1+4}~t5f&O&%_rue0xzt9VDZn(Z@ve|lR;iH
zFZ<0>05D<a-MOlG0Q|UY`>z4d#bxg-|AV!@$Lljd<nH#OP!L`$919%o7=I}(k4SYm
zO2CE!<ktpgcA-IB)^fXn(>Nw+R>9T?kL12z`|Z13=eTcP7B}&7UrjrnPQJ-YP%rto
zadQ?rLrrJ#LSj9uU4gsfZCiEDjt;a{3th^Z){RTCV>8?L-W==>a$9CSqHACF_?-8(
zF}6^XFugJ-SAOE9vZQD}s5QBckL4B7N!QCvRslc0<wTl>f0frslNZJKRgTu#yQ4mv
za&YB?=#-5sb+Js3m+4FEeShR{mqG=bf`R&MZns5H3U8yaCVOyy;3Dktl+y2>^yw!4
zCu%WE&*W3A`Wt-UZSV!{gBf=FVcCO;upf52cTDyx&&31a{ZO{|1}4PN1NK+=aFLc4
zcrC%12K1AXx*-C;_!jg9^{kmy9J}$+APNb`a`04SXY$a?sBk`VrHhY*KbY^2WBsp}
zMK9EB?R_=-Vku2}X7i*!<v_tfzC8W<n}$?cJp+9j4Hk0(*nCmNO({{WjnVwMVB5`1
zYp0i{Z#6tHv*7V`u6oeAe%W?^@zj+Ju6a(4*_KcPq~P7Hb%*V-8UeDEwk<)JFG)MQ
zdF2bZev-z6%Vl7V%4dC#cBjieTo@C=cM2`QWTk?KxW+}7jMCDhv}=85Cj{hE8<>In
z*JD_@29$UlQUU@ZrzLGJi-Hv8SnpvETA-*olx9v;gd$ESop-L({Ejru(|6OZ?5CM@
zWa7Fos1vy#yL;++dT(i&q=l9U<8^W(7*UrsP2xO@eH`?UlW$9bMo$Vfy5?U{#DJf8
z_|x(oT{=62G&K0LKVE`9vT|Gcyl2n_#rQp8vNx$g8j))*e}0|#?dH0w&*RnOk1kzv
z<(ASkzIZ;sRFa1X{@D0eC8DVZteyO*6<;jCVz*NZ$P`5Jz_|oGFQlONO!VFK0|9W|
zH;C4F^=oRCKwwNemMrkTGQNudfKyY)1FUa&r!z|&Zf#3<-d(aiUN|Zlwq1^W6{&Y;
z`=ii&y%w3~m#D5#7D?#nXPn3}B`MLM&dTbelcznZ-&XQF1;c>IQ-kH73<sZJSzYV;
zI9BXCSpd{nk&DH)v(v4%6vl{e<*$)q5FrCP@s)r3`@R4?jPZGBK$F1oW7i#U{}4aA
z?0Y8yTzL?7t~daTw?nP1egGc=AkPeR;>i#Jn$2!Xct9&fA1fTBD)<j(`|PiZ1S))B
zOoRDl5$R4OvxL~{(w5)V)kxd@F3!^_+eSnWL9N&*k@oYF!H+^h%56Kac~zEEyJti3
z8|ry$L@@uYvXxe?*kMD|#LKJ%%hFkTwO6Srg;p8Ykl*)q)c?RlIa64Ny;t$GIGSW9
zujlFuIkc&&iTD(KUR1a*oE3h5BipWaODJz(kI9Ky9+o!B@w-@x_0fNMgw;h=*9$;Y
zLeb}+J32+$`9!syL;US!^G`nK+v6aCR@v2SZP{a4(Wg=6q8C%{#J_BEE0VPMzkA{F
zX_ZSM#RK&ZwdC3NYZ$=eKii6XOklNq@yg8&zCFfX*t-!6(sI+mHLeAyON_f+ea!?E
zoHx9_ycA<28bbrdE0ZUp%mxtY%mBw_C^u2AqOiuTv82EVWawYR8Rgx4_R*5JX$YIR
z@D=MoM%l<bb4#b%vsH?my{tCorYo$?C8||`T5gvaR17rQ(pBa~zyU8%i%-<)s())P
zV32RcG3fy3pS$Z|jR@_tv00ucYkZJQqfFH{7wq<?5#xrNnHB&U+3U)F5Bd0^Zs}ZB
z_AA^{v*Xj#dHmBsi=#07>QsYk_Vthn;JNj1B;<eb0s^~XYZEjqew-`F9Q}UW%JKkU
zW7!QaX5F^`maGHV9*hq7HTE+4i2SB9#C0Ysz>D3qz1y_HLMvw32`S@=xLBz8q{5`S
zE^hC-ykqwU0DEgJ=R+Q``6QksVRDvqrsD2cd-Q1p8bl<9q>JgGEEgqBU+&ZymJbnu
z$PB9KwRaE2(Ho&v)p-)9oq_x@!%z%$RtZ^I%+*#wccF(he!%~(Gf(zN7<Dx|rnRE^
z79FBv;^(@RWxw;_;dq2{oWyZ9_lN+1n+5z&9|awdzeP2V%=lf$G{Fh^-2EIsAqPax
zQWx9&EM-)0-m6~GHeJH?Bk{NsTB}|T1&q6Rh^0*z3Rz*Ce^^K-g26A>YtQ^fE(axO
zct(AAw8S`a=G%{jiB6*0*6JMnc;@;`t#!=5y#!gHX+VQl+WK>wOb0KufhyLTLP;qP
z?9cIhJ|ahfBlCaQwTf-QUR_DQy!t`Z-Wm||4xkhkbeV;600;;zg0&X_$WRkW>3J*y
z;7}}ldAyefOz!^>jYb=jQlulcJMZjY$OBt!netZm4hM@~eSaT-!`->YviA=I6-r9f
zlkhF43+HRe#c2c{MAuFML9SWKpe*S(Tsrv8oR{c#?>_zjALteIkw*7Sf%Gfs?~^!M
z+23z?mru4sWz)DU5FoGK7THdLs~+;|Y>RN@ziJ)@<`eAWWf>jwb6eqg&MdzYH5^JM
zI(wE-8<KYqZ=rv;L&`SaWmT=1>qSftMh%w(2tSnUl5aogLf#}f9^wGa2Zw?av^nPH
zC>{=Qm0XmeB5<ZdQ+E#Y*rrw<b86lMjdx9O`*R%sa`D9s-w=IuNAO%k5%n_tCjb#P
zxV`iCX7&4v0WkbI{Oi4fyvpl$X@x^6l92V+>y5ml(8W$$S&X8X*m~|pURrfhQ-9NN
z8h`V#B;n0}PDo&Vt5wVme&mHeuXL1VRoG|SLm(PDDhP93<cS~f+EWW+Jc!}m%P-ZA
z!KJv&$}-*o84d21Ffm@p2ieD>t(C&8S?!$9MVy$X`vw}`4!#%wrSuv=wH0cZC)(&l
z*p6}uyZ`Hdj|W_>xE#+{_`-?#%T_sVDFY)J!opsUm=JOlhg9w@-b@4~#hq}Kv#rw9
z#xtlG?@F2T=J6VW{pH{Jt!EFG^fNF2v7GgP8nhtZ^0y(&Z!48J!<~=K2XT)VCFQrP
zt<^BHv2AS2m9YQa{3zRIR&}V<<Q)&omrB<e7e~II9wVt;)y$PRmD-SJ?~ud;J~}9-
z-;L*N%t-C9kE16XZRBlDxLvWG-Wws<Zazv#xjFoS^W0qesOVbu5=+QwlKci2FcuWO
z=}a9z|FK1KwSyW&>G@9_xLQ7$sStL3*?zKKamR|WYUOt>i3$HcH3Iq8`|=Vjwr2QU
zY*gz2KBK;larN-40|l|5B+3JIEoXPRJk2Cetjiy?100$c!SBXY8?4`=pLJgA*%}jq
z_O0<J7Os~@WZ^??tJpVIM(N2sO+3gU%ozjNPkDg&{LFF=p+{L2t|N#0&Odrcepr8j
z4YVLgzPJR4cV8|2&O;DuE#Yk$%_~`_rCqORb9>po>_PtJ-yIC+M^oL_{OA)F1Y@?Z
zDUb!&Jxd_9nNmCyG5Pm)3_}O9rBtmC2a=6KXBMD0dXj-QilFatj~{M7vn}1`sqSrJ
z=dv0-)31PE-VSFIZaXI5B%R<yZgejZW6OtcK0g7u4Ar#`7Vb-_#i8^qmD9z8Jc^?p
zxg-vnkIGi}`4dZ^0~=NYU%$F`&i*<g%+4!_-pTo5QXCs-#CR=_Eyntnb9OWi=>NQV
zD;NPV^vM*cLO)_aSR*I9Xo1TEQl(h`9l^e%);&2VFu=2F^W7~`6-A(WRTRv?YbzJL
zQ+|**3TND-^@Hds_t}@KgA#9pFpgnR*2q73bbal4>v7gwRlm9QKVNFW2q^mIEDtd>
zU2HS0!PU>@^M=`_1rHhuOOte00qp!+<iMPeT?)!-{Pu1`3Gg<YRIV77)#81LFz0?H
zIqGv^4J>*b9U~xw{8a?7mp{XT4-k$M8MC8g6aX<M8?I4?QK$iuR{-IsOoUR<VscOX
zPX^@)t5LOu_eKQ1i&&I#9gpY8#*z!xx^Fq=19C*CF912gM(Lz!y=H+=gYG1)@3yRV
z9eLz#|CSbC{F=tMyX?Ag7;RjH_s|_mC5`>0Q3J|P&!@rD|Al?piqMq(#(p0I)&8A_
zNgSP&Z=`i>3uA#cH@xuyYQm;)bm76&6QmG0T*MWA1OV4+k`%2E4v5cjBlu*3)(H={
zy}~&*s|Fk|&$21;1KZd^gIltI(3J#q#n(#-8|FpaUUqj$=Dq6*lxO>{mt8Ggt^Uje
z{+M40UGy9cy>hEX@*=NpR9AR2O$G*M3$M>RwfA19yO8d64UV+4{Pxtc*|2V&foB1R
z!@kSYR6FF_><|I<0wjDXH`K^ij)JFMqUco2s!_&GsH^8E__abvrc-*On5#!wUJOLK
z!1~7hqcJ?L{XzN<+;-2=L+8;QnsK#vYW|J<@rP^cju<ogP;!0n{S`ie7B3I9$@+b}
z?ou#z_gYOkW8DRKEDOTa7kXc{K%&SNALr4rb5<p($#{q@%R)`=L%}<HP>>hG793%;
z|1&{J_N|E-1~&etdhDLuBe>;On_fIwpDnZt9rS~-ck56uT#BdGo%XksJF~1P<-6(k
zCl(DDD&WK7uQ6a=ui6_1Ct*Ui@Bkr#h|wF2le#Q#g!bA;ma8Q<K<ujN$Zee#Xnj0z
z6nUDE-?EIc5y%)k{nK{QQ<$cQZ=B2sT14nL)a0!CzcIZwQ&sbiCMQSN_@q#k96d>%
zkwd$L6$hd3%FV+WmSjUq#$kZ7vqb84I<k@A^0g4TFTS&D*7*=A+vCQ%BRp~Rzujpy
zfbOCCaD84H8<2<>^!FueXB4@bUN*=^z&(H5n0BRTZzxH8J%9v#``Ivj!feKcZ9tu~
z5`0f+6?mgIl4BSK+~O??h9<M<SS1D@lfy^yVNiw6k}2+`b6-eNYq3isHM<f2#q-K}
zWzr5T{;yOJj?GTn3OrNGQV8_i=-DQ}fl|EtZ$xJkb0e`|x{l#f|A(U<X>*8G^*u~E
z40u7jnhs9un2X-IqJa2FDN7G8wu_P_XekF;<sB-pgaAlLNzpl<p5v=d?TsP!yVQwy
z3Jjyn$oGS~uiYcV{A45d-d>)~4%#q9nzgs%krm!yJ$lwDtFFxY1dm#5PKX+Ss?F|o
zvbNrKVQ_T4ic(9-NBr+>m~1%1Fwf=h)Sk(g`;&=dCpoEi<|w%zH6gPf3CmTUlPswI
zjGJC5X_imGwGpe%rk|&M?|1Ndv_U~Hp=(0bR%G$vt|QHZP5IcGn6>Z{mTN=yOhTy9
z5%c2yj^20l3FS5(Yue9mkT|<~u@r|2><`g$y0%#U`jU(rpITRRS%<`|2K)-WDB`u*
zF#?_U0^JNVT@8%PdOB^>&q{W(LSLAa>O7xN?at`?X0ktMQw<dxq@-{arQmJDZ0&oY
z-tW4H_1`A#(@elyXb+{uS?9U)ri$cDiO9Ya1ajPQ5O6!*<-+zKvVBemq<wq93rny`
zyR}KA8+%{8(5r7ecRLbeV?B>4)Yfa!#H#0^5@7KvTw06@fg?0G%{RON;m}Q<Fja~f
zs!Gk3={drSXmgdY`}8}}jAp3x7JY&!S?tFS+>mF<&&P$j&ffq0{WNOQ7YR0`US>?6
zb50%IdmYofNn=ZsO$8)pyndn~icQFTq~S6e&m^}iU}~JF#TuUAs(q`FZQeSnBI?!{
z=_Qlro5hwRy`rLvvA0N50a{a*`2VSdt!dCOoU!4VtGSrLP#gp5#74!dczR_Wm+;&q
zg987}$+q9o<JJQ_TwE!|7YjR*>KJXQ--JB0_~UE2d}myTq(G;ar#U$OKjUm)<F_sB
zb-oSG8_jsXETJvrrJ8N}p=Pq$Ncf>3vSyk&BlBlu>a=m{v>Mg`t3Oit3d<R|FVm7T
zb>3e%TI`pe?(=nWp9KehsQST0JdK>cqhqgaKNI%~nB=mXY)`k;Bm_)Rsi1Qa{1Fvc
zYDt{rL-TwY4QKoDa`wQ5gB2cR0)=!+L|z|wKA65?wL~E6%iJ`ZM+^hlyxKw8Lw*|a
zyR$w$0B?t4+w0u-3iEJYdz<+cDY3b-X*5<8T2xi9zIho3ArJe^caCXQJ;~nh&|Y26
zq^N)@pxrnnM7WyhC`8zMbidx+pn2=u)GL_WyN^|P`;W#3(^k3P%~4E@adxho5px=w
z0u$)f56lnzN{n;Pb(vq5)YVAkFUWDR+4)+@7C{M>V05VMfmtj@l(z#%+&5yTZ>tz-
zE#~+b)(1SzS>mW|2XxIRf7lLaN>*?rDRCp?>v19jT#=eN73^Hzxn}j3jKeK!EvVI3
zohm5}?*6)5Zj-BDMQ;yPefC|=Y3Yl#qPCV&<evlBJ&DPR|AZtAbEc7|_D<6mnR}BC
zde?DBO_A`Y#=%IPH1P6{2)KCiPh~5F;$A3ba2N&t&7Pwof9W>qEVHL3E7%d3JE5|9
zTljJpQ9D!Se{ZeybeoCL_eDKn!pxJAF>y2g&#~CddmOY4g)adD)9}+}dBV$YGi8fH
zKC<m!kcZniu9NHuCtd240kb;#mZpnYWh-2$l~T|YbW|=<8X5#MJa`N$DH_9U8YMfl
zgtG<})=Rl>R-|HLA{^y*f8rUkXq+dhQ~9H3I<3E{h+1sg+?Rz~gs}_${kd!)G~xWS
zR=FzF^f{r(glfu-@u)%dEsf?jTt2pX7;D?UsswW^O?<>uq)J2pLEQ91ACNbm94sA{
zV)`1ZaK4W#IEq?#<Vq76JHg9?F+{}ijFT(vg_zjtAG0sHeD1YQ2Q|*?7imsqL}`<9
zn0V}}jO#X;sjfc>@ZOifeJo#2f7U9kD&36FxrWA1#5p_>dHE(r9CG%kEEl!d=b7Yr
z+N$3&C7Iw=?qc;!Q&J}EAsx(8(^%2O)5`%Rf>dftP2O&^%j-sh=Aj62_%2z+-fy(J
zKI>N!1ovYh1xYsi^!Ap4?Kd3z_}vT5(Q4omp3oQvhv-SsJ(RLf`0ej<8d0UKu!8zC
zh5ixW(VRltM&v9c7|G^i$#HI@!Z&^MLAf^2H0h&dA}lGTN>_?aKg6WaM|bXI$^9D;
zBZjb>V!mf-Rak0RUug9(+?!K7DNM*f!NVm+4`+_!m`?daGjvQ79(INqC)9C%K)$mw
z$?xK|I$RJ`w0D6ybYWBJw23UK%ctCAnB9n32FC=YKqsZ6(yECnn$p*I54WRN6Ze*y
z);Cz~obhm<dNn?_s5B2S?~F7}qqCzS^uo6`VmW@+XGNr;aJL(Mu=*MkMXyN`Nh2A@
z9s2s6W+j7_(nvcy$qU>Gt?CzXDGfC0mv%HdMg2{e?rDz(#(OKv9=ii87^7(3cx)nN
z4_@q6Ga;9_MThMSnv0F$oaw)x^`Q8Rewnytkyh3B|Cj?CNz_+3dC`3qQS8L*+9^E|
z%hSA{&59M9FK*Tvx<rp<9`h&UUeb#o8=4xL(p8$_zC=O_3go8l(99{$-GG7fhN!qC
z8QEb^=X3wAC{ZZ|#~zf9?pO&>uru%X&;n37xaO*JcalSdi^<1%xD=*b8q|x6YVJ!C
z^p)gv>$Pi}3oD)E#@?ptQ~Mgo77d#U0IH1gmqRh#FVNuNLsM2HrfBmNGa}C(DkyH_
zc$bnUx-EM6QOwNwFuzNTS@j;h+d>Jv=J&r!*uxw^lmYm}JINxuhr-#b{}DH|GX(hF
zUr%*U&EYKT)jPrBl9e1_;ZJ;>KNZ`vq%+uq=*ti!h3Xse@ogF!2iTI-6`)L+S0#jw
zP>D`;uF9nTsWkn6A!SGVuc710D66+=e};^kzrsba2O(-JQL56dZ(k&`!EU=MqCHfS
z`pieMX)JuKstoe|`u+CC@2koAZ!LE2*yLCp`4I~UObO*7{jMSWAJ8(HJh20WAQIO)
zY|==EzOaK?Z_4_sz3|1WUdkjovTV-jn|AozgR%Wo+m1SlfJF7OvMS7`T=-LT%5p;a
zSs(4ly4-W`F0}X^E63}*hY!ENz#aOcME7nQ6e>;&q7H?f(p4yzEXKQLt0TGK?r*4g
z5x8lknrrPzy%^`2<1AN%51x!~?TRw?-U^&eHngo+mE#_J(8fO6yA`lFZPUNA5Ce$6
zSJE*Pn7L<UGgq&-t9QEWCEd^1FJ^iE-OoB4^w_`M6kPf8&md8;uK97RInVr@6HO3r
z%3bdCcpB^5@15D96QtL9GxG~j%GuFUdEKH-0~tBpp<m({-K)};2+D0X^hsW3dxC;C
z)7DG&`M@L;w%azO(j3H2hkMyOmk~P{FOv1*XoLD@4dGfvhxJcL*6F`S1l-SRbWtVF
zPmHn@8QbsV3{Cqd+<;4(7^EQv_u92@_1$;6|87o-aF)2wOOD#k6i3I0ePsokPOn<e
z`cE_}$cTkRzMRPf(EguUfXp>c4sX=pO!nEg?a+oc0TkV$naP^ex<nT}u1fXcnwd#j
zD0co#&nfGF{8cnlyIW|&xqoL&3vE@mL}*F~)5*286(-jHhGB9*TTJ&iT)mgCIi=$O
zy6gL61DS7I5$1~F91@yk(-Ggo*yD-1Rt(IWIgDRNNF?9yOcprab{IU3(_Yb=C!fV<
z@9lkgI;8a4I@Ta^rx5wFtJ@Yvl(di}H~ps~w?u32?U(}hGJLA*bj}f$Y9WbkQNEu1
zt<hwr`44LGGBJGZmI)7cFmB)y2zygj>@~Vlr8*~gsnQ%NYaSkd;JwBk*3+~0;iT$X
z>ie#Jz3#8q{$6}VbgT+KJ@komEeCJqU(n0bpAc;2bZZ&DXzF&}=OawO5AXNeS7gLz
zGctf71gG5JDhH`K-7PmA5_5~wlS>K^dzw%(0%ebHrv(U8{d9yYMy{G05o^>-K5bB&
z9dH)sn?UWDnk#2-7bb1JHFgGckE&|gAg^338c~zNaM3tS`LZKDR$g|+L!_gq5jcSk
z_;5KIGIU5?_G7;5`Ou7Dyaa1)h;81z++6zHH$*ykHW}iqfhuQ_2ZM}+oa>7>PxD8u
zH$Ure<Yt>VF8MmkzG8btc<z<|#i+OhS3h8IRU-i}aILSkia&o^&@7HF(+;;|*=<k5
zo%&t&C#1!F8OzJwkw*ZfJ~faZ-0IRT$R1EijJO{v!1$N?0~IE2JT)=IGz@`5r60}v
z+WB@RQuV>~eEJ7(E_=P_%6*dm6$WoxJR;2p-IUa3#?dw6nCLUP4AmEwkCBeek8{iY
z_;hVJ1JaSGVRZ-OqF3r_#55E%$J1U=&Djnbv3ICU(AF8@2OHWNbz7^?q*9Zx9UXdh
zX4`_)`KO;_7o)soTFsRgpx5Nd*r(CeqUl@-2n!3hmgOVRert@`Pjie2k7-JUNP|dI
z<wW&?{Y$0~iNp6mDocjyht<!A$9cp+IBFyvwgx>a)%WTE)eKiw`R{zrY>D@0j4;o|
zfG{Pv0qNkNZ*i>$^e0Uz)Sb9^XryfbSZbIOu<5iJRVcdnEi*~0LqVKGj`KTQ=c;w3
zM*E@DxX;7=+@3ryi5kpQ2&T2mUzjNlKu9m*2sl2Zh`~#;2fBq=1%@C>{CuyX#9C=^
z>AvFM6lrL7R9>OtAn5Iak^BKL#oMaawA@<NOBsYGMI7Nzu74fFxVCM}7DYMF^sgeQ
zLh(^NfkE(&AwX&_-#j-p{Yl%kiNQ24?W6Y3&qXAk4|Z$x5w&fK9Gb-k^;xlN_S=6X
zazG_)J<KX*1qE+wW7HK1rq0aG*{T2od%L&$`0UlXxR_|-m>lv8NaW$Vf5oB_mmQJj
z*<ogk?v(e#>*T6N2X1f(cmQReTyrGN<$iIb9Y1L>rVFe5T6e7BU2o(e5iA}zHY_`s
zJaAtAUZFfCfpLGxS<BT)!1N$MTVeRuw0WL(A)4a)hs}yR3_29778_{k#k2D${5V+d
zn|Bs4tKW{xrAm;9==<V})m#vg1z_ok>SK>@i~wPYM=BjXi0aMee;i<ve3Ey_s-ccT
z;Q#_4A*tlF5x?kS=J}mtT7s%n3hTIh_R1EGMJ_n|%%$kfWNBWs;%{ge*l&2@CK$0G
zj1m`Fn&izyhbrYQXt_=tF~0()^lcaZdyX+M-UwiOS+8D|YN6-&uC|xRw-bA9vR?2(
zc7k-sDNwHew=Q+p=)vyOFuuoK1~op(uNrGTsg#iU>MNR;Iv*%y*D^g(lG$<7SDqfS
zANxn2_AsJ;2jGiJ<096%es|RwA5YGO^Rz^9gCcqLil`_Q<?HU9m+a_+lEk`GXI&%i
zHmP5MVW3g2&hq-Y00htCKkZeR`0i|sO`Uzbkcmkl@4yf;1<D_&-#_r+lhILke}f31
zJBN#_DOul^aWggXDg2?wt8EC3Wg?R;L^hR`$_pPj{BRukbZj=q7T7)@EtzG<#(1;E
zX5Uin?>5tJQ-_KR3bdwcsnhqek#Vi!3#iBKbWZ?J*=1|x#j_N@-CnLepnO_{`JLj3
zK9;Haa02fa&B6c#`48yAa$<%|Pn==^MoREsrWCTDuYb#Wdno#|<GIVINoiI*YU8sr
za>#zf+jNni>k{<DIePt|k(&0(cjxO0-kf@f6Z%WZa!HwrC<kxf;<NH&fq-HI$^kcY
zmDp`EP?(hls}-Pmm)K}FlQu_SFg9aN`fQ4xJHST|JJ}1qeFy#*q))xc3c+r^R#JAQ
zXZvOV@i#GIcB)YJ_SZP;`xsQK>K;cGF|D*B$!z~{QPj%r1(&OtS$`JN&;b2CrVK}6
z<X@~ZXtR}~MMw^#q>aVyS>i=8uLPDzE3#k$*2?8yKOxG=O8?MDWk9tBt6h3&N#5M1
zOw&FG<S(Z3^N4B}UcWo%nLK~FU_jxwjpBdP##U{miO-JqO|B6>Y05jx_kxGf<?_ov
z2|JSSf0AO*G)mv|?Ye|9y^tl76^Sq;Yv6NH3jwKAV04_$d6$fw&QkJH@=6<R-?uT;
zAJfuPUcCD84~dRV)ccp~@sDcp&wcc`^6UA^%DxQ=>VxCKk6T`LGxw!nDfYj$n7pZs
zz}qrM;m2+wzb71lXl`hyJ#aF@E{RB$0_>cQO5yhYdwu%l+#zwqcqzTj@Awp|Az$&W
z%Az|LE^VSRjWsxNWC02uA|$1wb>V4f<vN$PVKx8K`IL~?>-U^s=yg<yp@7FBi|ASZ
zydt9@X`hiW*N(!NLebmkRt1)z|5XeQiVF&?v>WPA!t{0j(+z%j?gkUJCNOpbK%9-u
zXDUy5jLMlHOuFHAii{skIs%P&|Ei$44~Hui_kSAdT67oCX{h5z=tlG?n3I}Z2At^q
zg$FP&#FY%GEkCI4uL@V~G1V_=Qj;8Tgp^sB(EDi{_9X8R!TgG0*BbaOxKq{drX7Ip
zX~VJvb=!|4r=QQd+<l2Lgg!@NYS~l0dZB4BfnfkG+1LDg6H`cvUY;THa9#0GQdGSa
z*~?dc=$ycc%3`rLhWrr)K+ZCoOe`dpKxMWgvcpCdOTymj74f?+QZ<}^k|n~4?!GAt
zxxVwr1{V@)c-XaN?VW2dJb4sgKim>Ik`i(5zX=C8<q<D?$R6iWYTdQuJ`kN}29a!_
zN7kkEUv;QrFY^7SA_iz^xZEXaCMZ7TEht3hLP;;}*cf8Ud#Xoo+%RH!9_%8UD~q|o
zM?R36tXK$pE^q7a46js!7aX-3>;IT+*YF~(#z+rxj*Rz>STJ$W<4!8LyOS@aQUEIj
z)eO7Wq890LyJ|r7$n${FBkQ%=m{C+0yoO34=8+NyXlIlwHYr#iPOT1Q%Ek8O#aOBT
z3SOSc!tNManUYjUT)E{XioSty1EFU`sH{M<ZZV5ER&LMg?%Kq2G*jk?U=OK@`dQ9y
zTz=o9_m2d<=a;1^w_+MTSb=o^1y*O?NA8$8G{?G&u&LrEFr~h-NqaZ>f(>}P)%i;@
z%{4lRdJd4n#j%~_v35cXB!&y7LM=N_CC1~UIb#1pPu!xE%<tjgG0TOY$q*iv8YP{F
zc!YX-Y*gTl?iizTp>Y_&)Di7b$-5Tal(6;x@pRQ;Rdq}M03t|-v>+fMUD7Gtywcs>
z-5fxq1*99K<<Q+Bt#o&H9=Z>FoA=)P@$kU;17^=&Yt77WV$H}jv8#*Iz>Lj%xk&?n
z)YKSdWckIiUGbT-+R9ta1DQ_<4PnMrn#=^&4Gfw^QSzT)BSjMJpZ`rT7T|wKng7ga
zrIq+Ajf27Hqxgy#VMw7)G<qN-2<tbhCp;ID2_in|+xmxue&8B=Na(Ode4x@|riz7&
z@%I9ha1p|zV84<3n<baw<ls)qKoZpWs;@jaQYUel8ECY*x^3IMdXaLq`&x8$kR7?W
zC?_^S_FY)|m{n`a$9C4?PNrPVj3?%V!CvF4O0qmG5J{n6UijZ_Q5cCTvql6-QK(t`
z<R#!4<{S1&O~X67mC?O6l%F7)sO!-tM9Q`1QWT>j3hUGceT?dskgl<NM?pW?^ENXq
z!ap)c!<Ho-M7foT4ae~&GP1X&<yvW(YvAlku_bYHT#*^ceky`CmC|Eb7vdU6@yB*X
zyauH+-$}Fhx+<DMj#GQZFfE={Ls?`7tu(<}I1M~4$-OF|Z|AI!`nxpdO+u3Pm&oqz
z72|bhMtLA;tXhJwcq#M>&NiUDER6K&cKeB2>Y|G<`LuPbf+Cp^)qK#32OlRe%#)TG
zL;5M*14E^$TdC?TRg-y>@nZ^HP{l;JoR^9C{f|^o>G6oH9c!5Yoag+0gEDi)>0z4N
z6Ln@;qJc6H1Qb%}fS_BB*%bo)R>aKfQs~Jk;l;m&{mpFh{e3#+dRdm_ZxgHq-xJ8_
z3@7CKFz3)Fa9J=YSofDv$2`_Gm63v-obo3vL4TjHx8=e5apKr^ZWSTgSr6WZ3_@RT
z&HAjOo1m|Ys5n;6B^}4~J|7c^p&-d<+NNWkgXIb>QfBJH&0sd$=Ipm-WanYIZuyi0
zL1f}lsEzC{j9HSS<Ae1!P+Tyar%$cuU^?qx{$8u1%8qdwq{~o-(`i+v1|jY1;&NQ%
zcQVF#6NXH6CDVjI&FAPBxMSb_e341uztMS>_aQS|X!YS<oQ(WBdL99|2nA<<5(Pef
zicBv2+5pWyLK!eH@fcP|a7?8t{3Y6P_c&$}ELT2;AkFuEh@3-9FR}|LtkP+@T$HZ~
zX+CeRwN7(ORfp_*oVl(*C4r=<9ep#(rFE)(U^&#{+k&c2aqwtydvy6oHObAiOy@ig
zJuAEk1$;GDAodYU-y-Uta?!`F#1jIk2$NXP>t2zQcVSQ>M&W7`=U*xB_M)4;c@0yW
zrNL8$qfBg?d&2MD6P|9Thu+Ex$s_$py-#Nz=Tu<ml&veJ-mWU79;M0e;iRuJmlE2&
z<3w;kZr*W;oaD^rMp5XHE#6MW=uEiNpgR6UgN+r7`Eg}2cvq78wFuVNuqm7x1^)O+
zujbdR0TSZ_VmgInWGTj?e@JK!(0D7Yj@7@4p!lIl3IzV;?9P(zWR!OFWn5i{#Xw2O
z4v&pYBt(9?UaY!$a^SL9y;7HDTIsrTZ2Q|0x$j@TYJo8QOD%HjvScBq&|umeDDbk<
z^C(07wA_&)DT6J~&0F-0lQUt!coGI{!T}+_k<RC9;D(tneMfvFE&|Ust<@#I_X!Qh
zSVSc7l@}YFZt6!-0V`i3aZ31baRChJyUv+&OHD%Pi3kl8r%<KR@<2_NNspr>uSDmS
z{^LL$a;f?Ff1eEofQ8CG2B%)$q@@emDs}1PAn~(6dw$}<{LnDuHyRqQ<@Sezm1rhL
z@^u*UsxiMsUmJ$O5#6TD1%AIx(WTat(x$>!T*J8~#I0u)n34)Hosot-58?+(xZ+nT
zlNd1AlGaktmyj6$P#EKpP+3&pt<~Sx==f}X3?!js%l-+F=XAS&{l$*Y(Jk)-ysxEf
z!}Z&2(nL+bWWyU7Cv|qc=3r+f!U{waAr}+Hg4c4aD<V3Q5fGsQ@!ujd=kO%i+-*!n
z>zhP{nM%T?%|FODKLU{&g~J~uijxlN*U#_~+BaEJ$7<Hskt!dP2U83E^i*Wa@L#q*
z5fy(`?ubZcMUm{}fL};I45DUWj*`NIHCTynYs6RzSHPA6ks*A=E{)4#?ecw6rYD0u
zeBI=GFVEs~FG4Sd*p6gS@$-S$0$N!@bL{oUXXcO{kpk7031DecM&RrVMTjBAlZmSb
zp>bT&B=AI3nb*VV{Po%NSE?!V$f$%vRA}`ZOr^ox(|o6{bdBwytmM;K=0=in<k4(w
z5}UX@PAXM-{6}o6(0=?O<i--Ub3x}V>FaJF%{+2{RQf@-7~O7~WBnk@G1kH+Jq#%3
z8T<*<cygn+4Zk&Xugt#}o~CP5%_NW)4`gfVOlS^@f4Ep2k>sZp^w}gu<TX;_A}0|M
z{~nA@m=@hW>1GH5afq)8v~w&u`Sz?F&@5$P^^(6QwE51a>bJAcHk1rbZbG@F{BTmr
zDqz7i(^)!&VpXfc@P#g!!KMZ}^?DkmL|?5I_j4Kj%i^kiT83x3@-JwfOAwjhZN94e
zDQ1I`b8P+@a|D{lpt0fCU0wkX{f=rF<jQ1O4QET<CttK$>z(0Oh)p2iRM#<3(BK{|
zkM1t6b1oSC6YKR|XUhHthX~dm#(y%0cc=Nw)^*o<sdRuxaaw0eF7<xTzp7C=jH$ef
zsGAk9QCAnFE#-&3E}jN(0bO15SE4~di+l#*B5uNfPAqsa(z{MVTuoeU4*Z2=pZF}B
zvvRf*CuAVkvY)L@_?n2_oKIKd8SmAK;EdOm@reF0l-YH+eye+=7068DfGSnF@f2Hr
z7HRzIE9EFtGjN4T3$7NvAMs*+SO<y#c3Uw&(K8fG(bFCF4Y*ikX8c?wuhZ7vg{aHc
zMg6>IQR5cL)o!Q}`GwDnUVylM@M=ZWQj}yzY%vz~Z?9uDtw(jnTgl}lqgewZhvI>O
z&_2Q+6zrm}euQ;$^nWW3pgFIf!s}Z$s`{{$*3ip35KP0WT5^aZEpI0P`X(YBs)F8C
z=kxb`rZWvsw#IH~Udc?w2`D<i;y)CcSDEfUE%j_I1*$xf^4w6yFRWtV>#Pyea8)11
zOSJ9CnvvBx5IKY>A)Ief1F0tQ?S7H{_$*>cS6N87kdJlA8{N!%aHHb$s5x)KE<@g=
z8DYjulM$wST!oB)i*??&Wh+!0Jm!v6h_x`5rfWD+xVujp1A=!dY)Gv}bt_mNOJ!r(
z9Mo?ihhS?IQ}>RzDR~?U1*qj8TG?s;j|X~U?{vCf4fwOP3(evakEu~fU#;JjpY$`3
zcjC-<?jS5uZ)gcbLa~KEMh8oXe?x?;#AOXZi{&&$M=bOX`p7@uz=am;dI0@yLBJ+1
zGnAq)Ek{>?UoE-4I#WSkGA!xx)mqqFjiF#><dRaeaN+TLNpjKadJp8$#`nVp)(RG=
zI&ziMA6yuf)Y27w#jYfZ%=$hPiV=(|DcddY%JX`n6Z}pa-AGR*@ySnAPXBGKrd6k1
zf?vq{x$b=%BvIMMx*3s=sg-z)JG<#|?%`TTY}(ish7q~q^s8R^f?cjIPEdx^C*ITR
zevv?a6Dujv-$LOelcR7(qYYxQe23qt&4bB3!mKV^z~$9EX<V&MG5iJs+fys!qJ7Dh
zOv0rgztYU9THg!r;Jq6|;BUZmdzGWL_Ir5UxZTt0pk!4*m@{>YSecVa(0r6godlD4
z#~#&puCX;qIsJ3ww`K(%5_eqipY)8KZwdu-rwID?{n=)1km<sLoQ70$#;;}|3KWWh
zKU+1~{@q1o1C%Axmbxs*=Cdv%>b?bMR<B+Wex*i<RV1PLIz>j~B9NbGYBQMjEpcH_
zn`)(m#QLH3C$ACiU;XYV4NsD>5^bP(1OOsRjUgaHgfps)ox%O>>=KV5#oq-XsqO3^
zc1N_AiLOFNQj0mHsQg$_(F{dGs1!N|KABHeFP5fDyHqHrD-0@vR#dlFxfD_Vdq(J{
zKfw*_I?*#Vd>uf3Gtm}MqXVCp<UGl*ViKl+IpJzqm<q=eA0+XrPNJX)nyT(m>^-}1
zpmo)ot<$^)0NYvxyguSGdp0e($>FJ6YwinUeI8myM{3*iY#z1QuLR+R1_i1dh%VHc
zpgN&VqIq0kE*T`t!Q!Og(}zOy$vRV#6zY~SHCWcwqG%ny#ovqwbJawNi%R7(6O-Ob
z&U-Z_lMrqGi|uc{k9%g&JdJ&tsp@};vbtcGCXAry^Z$m=POoY4Y)>+=ZqyU*;z)Ka
zU;f#*-%_*tYW5_Yw+IPPAG!-BNQTG$_6mo$%t|JTn%9OCNC(taRg4w!9lb0#faWXs
zbi$<~a*<$1BAlTjSn7NnG8H`vS>h6M9l4O(aY)Ns6L<(b?2xSk9F&qMHBX1M`s|yQ
zb7)K78oH@hNn_ou#J}p1dB-xaT=JjdkU7`aj(q$LRigYZ%?|E<rMyW^f59kq<mut7
zacvfEO=a4Hm#(kNnOfD-+m`MJ4e9FW827o$++mqMu?89!A8cCM*DkD}oY@+F@OS1d
z0$f2e9nwHaWx<SGz>xRwFE#s%OwtyImNExN^4W19Uh|px{mzAv(EBYH;M0~f7s0DL
zU#t)=v>;t(WHFL&Tm%c`wK<$z$X#Qv0;^twe6C0CsEnY#8*OsB8J+|!J$F3rG8-E`
zy|FRzREoN~PG8<hRh6j5QOV}=Fege@==)sU$~hH(+YhcHhld}3cjyS@B<XGD>1_rv
zN}0+AOWF$exeJIIhiji+R-#y|+9jZl)VmB(m8A|I^lHG(b;<b|VWerov{<?PM;#4v
zDf;(1E@WH7D1fK$3Jyqp+PIn|ullrY5FlX7KiW1-AZVK>G}B^t-UmwRvzvJl-Rt8X
zo$0bt<FUfga;dW7(?3#mbL7{aw^@($-t&%R^}DP}9o_Fq9k#MTRG^@{rgXz0v?N{f
z)1s}ef^-MnaHn0~)xVp~IRS(XC9Q4Pi~Li(c5}pJbY(VDf(sUG8L?<UK+rh#DKb?8
z!masjKJw<MRVgC|S0g-5c5AbTnpvS^sNLNlFpM=4Sqy|PLsBuhVp9%H=wWoqXrx+k
zyZz_Ba_H6#&$56kOZ`^Rhcr1wyVpR8zy+f2S+^*5G1#FX*FkqoV~J4aANwzAYXPOA
zup*G{oj@6s5(lt))Z^(Q35~8<#fSC{3@O48Yi>Xwc!5$^(z$GscdRq;<dpe~F!&=s
z->ZeW@c0#<v!UpDA0zWo%7m4-ie8^N$ux@YQ2Oy^r)T@&Rcr$LhTQ6bN`YT({%-cr
z3dOoYv)ymJtLI}jnr3CQ{~p<C6!^5J%eM%9gyu@DJwv7<Xf(z+SeoC&rF(or{vi+G
zw9>?b^I05^e^1!>kmd8$@cOmfNYidM>|`$8!qYcHu&8Yq=XEcvrTaG=w}6oEk=8XM
z<65b;Tk5=yiKpa6&5H(*(@c&wV|wONiAUHvpYhdSTg(I>gwT#l?xC0cM*xfQv4^yu
z=*w;+EGTizX_Uk_1dBY*rwfuLN)ZL#m4cE|%PK3`#EqCO%J8sr_kHOpXBNoOQU`j&
zk$rXyEh`&6ZgO-m`FHh6y!vL%AHB_uMzbiSOL{1WvTR_Z9L5#(B7mWqLiZ=No$nm0
zMp$&z7KSmO`?RHe%Omm(vObFh;xx*rlM<C_biWE@WLu))$TQ~;DacWg1C0W$XQ;5T
ztJJ^RAvBGQ?49EQ4yZOOE|Dj`Ov9^kcOi@LO4bJ|d`ch3)#!B0CD@G5SKSjA|L6U2
z0t2JnIgZE*{7}Dz566D@6tm`tVh0LiaU)9Vvc=zJo0h84vr9NDqeuq1liUE6LMR8*
zZ#c&c)BbSi^KwECLSDRzwl7)`8-}7oMK3N;chQx;$z(Scwq`x$vV-5?Oc0Wfw@<ll
z^QXrvhkKq_R>qU18K=Fqv1rn$ac<69lm4r8%pMt>E7ujbt@cG|BL|ubOPg~Bk>0}%
zrvEOHxkeeB&uG>>zd;+tQ3-?devd(cwgL$hw3NoHGAV~!+Z8PpN%ZHuyfb(+3O|rL
zL%sc9MWj7^l-dj;A6og$7>>pGA#>d(sti2m57k59e($}uj#O4>F_Phh?)c$D)9>Fa
zD=RQ0O#9_#w|3gadOMwyfmjEs@n|L;sPEu%qAags9B|X3?dD<S=8<ExiK^)-GjF;#
zw~ae^sT1KQhD?|Ze6IjZv~SGvbHk)6m}<6}{{d{GjoIN-{nwpW)8NY&MEEnn+NfH;
z)(jh(p-I7pWrS}M<=9M9W6SFdU1JJ``tQM+d=EPU#(DwcC5(-Y2a}kBMd3gk78cLu
z;nG6c9nMz=CNVI_w`%82T~#Klyp>Q94U1VArr;^M`$|*E>a9B;QR7YE2Y&me;NI_9
zo_Yd4?is}l@#estqVDGY5Z*G`=N0X@YW8~}MRvovmy%P;$tUN|U9#=7+OJlqX3i)9
zS8-}%|J|B7%EX(NI=VVa%G05d&)-Ue15$#^Gy~_#Fjs^<51B9p9$B%cA2M2+U%q~%
zUh*5DehQd15cUFwR1%qhA~yckj0!$r`X9Y7U;r8mpLQ$xWPAE=Gbp7$t#s7~1|eZ)
z3Bp1=^jmLM!gpQaE2nmzX57(%6F0A(5=h{ARPCRmJLHM~l&L)FprcJrTdOLoQC7_P
zuXbb#4_Pr!8wVQ9!wnr})KG?`qQ_GVqV1Gnw)&l(<^b&=dI*D3={(f`a7S-eRaNms
z$5X*!g%~j>A08hMZ#xq(>wE6ygic80(DoI1`*;VDODmau_u7k<%94%C*NsN`9Td}=
z_hXcn*(llb`bdyN2~)ND88B@9?BFx&*uN9iE<1b}U_JT?>$0*FaEF|rn2k9tP+@rZ
zvU~~FX44>nWkiM3tTwq$#+fcp8%9(D_v1ZbSKtZnhiAZt6CZ|r_a_SEl9>}_3r<c>
zSkWez1Bwa@H+aCn&}Ke9zL3z+i#q}2p{3bbkNxv)posfuzKvE86I<|nFE7TRZ9#A7
zc&Ytx;fmo4^*OWA=nDUJyO8RqdV7X~G|S-L>7D$#ZP-Em$v!u!$aPcg>0&wl$eY7-
zMV+lS`npQ|))(=pEA;mEuHN48hStvfAgE|ZpSaxkd(@_cQze=e#c4ZNog<o4Q9+w|
z!*3I_I<-BRtduRJ_wjAL-QvvrJTC)n(R)P&g*Nw%MCIbC>3Icm^QS-Aw}1R^9-dFu
zLxJA1I#3ztep`n#?5~v2dF=Q&V9J&0TjtoXi)PdQR}0`%j<~i@OQVOaT}-2OwOX|!
zu&(`B-zM_fekk<<-8QPPzOuJtCrz2_SK`*U>H9((?8d0F!GFy+XJRJ(_f#WKbyjs$
z<a~T88^PXyN~L!`^)u`wCS{()K6i<ev`Y3wggm~3OeyovjFhyB8H6Mxi!B}wz#XC~
z(`*`8WnNyl4;jh(_Y3vQ+PJ+=Ihv2X2DiI0!e_e%cL(tvE8y8ACK$^*|EKyzhvU6H
zLQ)dCL|K(&W|ue~=r^LFS2z$g{~{@%PW(dFA61v<_3G(5LjyjWNnM}1EuoH<*cI_)
z#?OTq{b^aIMPvNmvVcF0R+^Nv0I!frMMudjQ_8jh%q`-a(L6gDqRkFqLkJ3j!C+VY
z92b!+?b6~%K%Y5EbA3a^(h`jd{YFot{_EorTJb(Yi0WVQ+tV07Q(xc5qj~NMOauSL
z*alJ_$J3#CZjY0>t4kH7s5bYmUbaZ3QAR9jL4;Wqpc;6&vy06$F!a;p22#_3$so;2
zpFpX4@_)6HH8s9Ut6ghMl5aAt2#pxZE3E6Rc=7LSAx4I+!DlOk!tCsBJ4dIdjs^w>
zu(OKR^N2e4{%BIvBXEN84vX);3)Bbd!?1lmZKGko&@%di&2)n*EhB?H<oam7#bPwe
zx!|!cy(ltxqi3q;jKCm5F&nYQ0{?o&=S7lJgl!oL)W0l#nxE<T;g-GE5`buY+8k4s
z$#~VPTSoju=^{GG7f+By^D|kO!6x%xQ+O!%kezILO+QAr`wko1%VdCLbOwiFVB3Y?
z0}TUXrsm}CVwWND?@F6b(X2&zHpB?yG+qg8CHI`f4{bfXB%%G>=y>+HwuVI{W*YV}
zBJU${OfK*%D=W*l{Pg+hw|~m*49C0vuC5~+i@_}e>~RcB;Id!sTE$gO$kf*lstgVE
zyq_!3-Nc6fBTwz0V9aU(A;aGW2muh(l@%P;!*3!#%M|+X@Nih;8&B2bxGrjP&)Me*
zRcbx|dxuI8cjg3#($>arAW#pTNPKw8_J6)F#*J5rztgq%ywv8UN4F<J`PxYgv?(L}
zwyd{2vtTn@0b6~Zbx`uXY0Lnth=XKXGNafyL|L(4<r8VrO`p4FQXm3OB<Yu9ZfU?p
z)egTizg}UTx4zd4IiMe#k8-ncV^^utTxuVFW%P{T(DAV1Gbzi6ohj_!UR2bt&2KXS
z?L{Ss249sB2t5REO_)(qc6B54+6lH9<v3nifTM-)4Hk_lqVw8+uJY0v;-g_2(26<5
z>9#tqA1Vp^ZS?$k>>bqmZfdD>cfRe-N6XQ6;v!g^&It|#3M4tkygF<YfSOPs+@Gk;
zG>BT222L&l60rDQh(F~)Nm&g`b(?xI7-+WWwvMMs-C|;5S4{p=l9KMn3)^iK*^yz)
zdabvK9iETp7D7^8Ajb9O#pZ?^pz(bh6IqPph<@9-{}cFz1*Y0R!{p}&Yhr!Q7Cy6B
zy}KUI<aY-~cjB_LvfiGG#XJUiv>!&r(@JdJpAOVnWD7puv8dRYf<!pDgpKuH13?6J
z$yr~0n>4W61EA7X<EKk{_M<-CGn?O8a?1U9+GQZ2jH=s5hYun1+eLaR!E|$XFO)jy
zT?r2l7tIMseW37ycHC{V7~G~Sg<pW2UqcsH_&?3H`1KpQ`cY;@ynbUc8#4NQ|GxE5
z_-SN+cJ+2r_(2JC>3MAwHpC+S<<qB6Q_IVG!qdQ*4iJ^hxrL1H`h@|2<8<Wa&nu=v
zixZSd(nk(#O<ou*E;69lb1PGI*`psTDR9E5B!txCp(4*rO*+g>O{oI4p>;#kB`j^e
zPf%f&5!@di9y|XT?fmEYnlvc6;(PS>WN(}lXZEf5!&%zr`|QV<_?YFJn&;)wB06G`
zV%5K|*Hj5ZSS1gZM@-EVN+x&p_8ERADBH-<f*j0AC}9VpV+SGC1TtJOQ5KwnDM{QR
z#dvr^h&zd#8(V2#DDQ3;YlhqD(tORIJJgVm4ySV?S-&&If)*RHnpl1PN>%0OB)%8l
zI;#>&ti65^KFxa%xzP?a+RI3HKrn(QqQv~c)_H_1zW@(pT_My={IL3SE<K1u>8u1h
z1K?|_2fMR#tNiHubL8Liy-wUzME<K6JnI36vyFJZ03ZBM{#xkjOw;jN*2>CB{BF5|
zyn4hN0(!FTEoD_-rj6URwV20r|5QKEX2;7`B~#>AAL>?YVVLDWMR8ICg>{E4(@S_@
zCJewE5VZg+Z}qaeqybQMCx)2#Cz~PzP~Spe>s{dQld^`@sYI66%bmnuZ}Cj%B!LGw
ztMU+?{fhKnbt5p}Ik>dFh-S;YmaCjmbO=m%>er}!DoI#4tu34d1L>S=;JQBDG?}$a
z0Edmyo9U!9oIU}(wZ10{O5*Q>F}8=q%@2kc>yZw+*W3Aoc~~5Y%Za~kwIw9|1hiA;
zW+wS}-|UtE_ZDmM6@GDx%t9d#Ku$?J6^NvKdm*mU0pSFeimQ2nOL~4gF_l6b^n2u{
zQkR*a--)aGuN=$LT^$R?vIm2gfd759YMgObaEbz56Aqq!$yiE^WLH&Jpr6n6kpzuK
zQQfL8Gxw^C79lqBs|-5gS@!>2)~mw+l4h`%iza3NfsXzYpVI7W28a5P;V8u^o!)WJ
z_;j;gt|&RcKOT8(JVRHZjnE$q)GS%;qE!qux?yt(@g-lLuGsr{$o@pBFfTo|t-9>Z
zbaTYjNWXOY_@o{XPZfA0`U(eu)n$|5XQbgvxjy#)q!ZV2&#usLCsZ6OEC3B8mg2de
z*a6-MABo0b-#N8wI9}}#ZZl}McX8W>R0wZB4Q3ztKCBmy|CMvl<%(sY(hZwWiZ4lg
zEJlfvX4fU;FseMRde3t{CRRg(iTi~xWFCKSvPh}p`h2iUK#N|X^^u+kM|F0yYlyQ_
zTIVNFeO?FLv4_BhS|M(tp~?`_e3yWlng9t+Ya8Y9x}tWzvvUTTY|PTOr?wb(S64K2
z^qeH^c&hbLKl-~VgA?D=nW~cbidHYqUxfw^awpo<{t(*=7l8>idNKi?+ktKepWF2^
z1cVy;wwVQ1w8Kb4y(Z`FbR|KzJ5+=7kvrM9dQIkNRiGcW@TG_bfB@#;25@7(Fa*RA
z6RhRn%w`fGPs8%2Xq^FYy&4rbUnIV@pOx);9C_aOtm^ogVtvcL8=Tk`Zad7;smORQ
z=yk14_#jFdJcmT>!SuI-C^Qew<8iK~;fQRZ#RD3cj!A4{&MA!hMMFd5`qpJsz~%UG
zHN|&Rff5IwU6MR0j6&HauyA3OI0RUkGXDPtG!v{fKHF8Z<S$sr!&6WeD^^f{h3g^Y
z@Y=YtnJrgPRCITD7tKGn@YnRZ|Dy+t#CRGyEv}h$enWu!mJ);h$vc6cWLpx!`_cnk
z;PG7Un*3qsIlIjxvW`j)+S<-?Jp!p|IWA>xXenAuCi4OM*$n-54PqLyq*{4RM)-yz
zpU6so7m?zJ=Qk;REEeQ^@Mmdh0g4Zv##E-AV$S1Zz~7|H8}w%tvP|nutCd40Gl^(9
zlulwo-5zGBjr*e)qr+g&Zr6Y2uo-3|YDOXPyZ%qB+bOhXD@#j+wDYaLXB)kt@4>fu
z!myeM28wk(YGaQ0@b7ZN@>D<>cmT2`2*}*Se5h|%SjXNNa)`j-Svfv_<)rnAk6{ok
zJmGi~9=6ZfBN@z|p45`~?$E*i1{k+|+uQM&eE7T}>~n?Gal`SvQSo?}-S)hEBLu#@
z_q;d&zHj%Q*1I31R@?j^@<?G<&$p{Sy9EA8VdDA4$rCNmb{~I#=xFQn)5F#CP3D28
zK($t;^e^K>Ow@3jpnSWnKdV4dE>CjJ6m)n!K)sUz@qoY<^Opf=2PxM>@mdH$)9UYL
zIplj4eUB6`&X?ZllbUSU5MZEMV%~S$Dm~|I`aEA+JOx((z~2}8Abh(uUb4A9eRg_q
z`wI-PHtu224(pBpZwfy)tiq-ZEUk_o_QvyA{PyK;Zf+LvpO$uoJZ|r@mtj3hV;8$p
z*p!f=cviI@%Kp|p4m3khrzoNE9nFm>W(E8&gG#}lU^q~EziJ>xc&Dwh3j+=X4owoN
zhB%dj;Qe{WU4=i)=6Naa`B6CM{qt$0!9%d{V>i_A^ojN%xj#MhC%EJ0{P?~4`IY}O
z)bGruW1$*CS9rD2i~9c2_7-5|=4$m8-Roj!@%hSMr48)&)`-$Xl;lI|x0K*t=QONh
za0nn!3TXv6_>C-_EdsDeot%}lxY~@r<v7{n>2p6gnd#uewkp6^1i%gN_D7xPZSeC!
zk^eEl^Cf2cP4|uPd<P#HS#)S}zZ4MDaC+WrOXh}ZoX<XGc06paKGxAdZ-5clPhAA<
zjy&&#V3(8PFk<jsiGklUlJM=VM!WaTC1y%W%J3#uRT%aG{VU=F0uZS4$npxclPlmJ
zaqTNPlBc3P2~{;;d|1ksXKf#(gj+&1=Hvvt-tkaj-+n$Rd=)ADeBP#%<$t-kT*4hX
z>+I>~d-$}@ascyTaadVB>v(+ssMFy8U;sQ_33_ruMn=}f{s7zTk6HEF&Fo$WY%^@H
z8&lX;c>og=GaGP~1Rig_)PUap^-nC=!G=~vfw3SokS1D~PCL#|@bBvvzN$qoN5b(s
zzo1lxDZrT<=jM$m9Yy<J^dcGD0xx&NVBmY#repv+y;Bl8?Y3$5a`P<#-`;|sVH(+Y
zPti}Q0Q0b=j`MUDgLdDWWsi=>Z5F6|3%A1xRxEF0$II9AR=konPSATYGVm_IedsfE
zGI{kb`pXJl4U@bARUCdSO}#`V7&hzgciHe71OiC|d@UjX>*uJJf@P_3_SYB7=vtz3
zk7GK$<LV@j<>|tI+eP>}xJCGG&GY750d`+g5z~*9b3fdF^YFg)ap<PxfWiO5;QoH~
zfjhc?^I~^2TiD;;Vig)Lt@E2nKtSMe<oQ;(?ZzLrsnmWK6UJbko9Bl^!K<9Ux=0C;
z3Qe`px38}QIH?6)q1Gc!v4GYVSS2c{=xM0ChNQ43Np34TF7__`j~RsTfNk@Cp5cb-
zN3<5V-;P+U#&Tb7T+!aNyl)lojk&GqxRx_`@OV~aMvc^J7r)%-jeP%f8k+sEv<o!*
zCUx0aUtjmX%l6-Gd)~bfx)ttdDxs$-{#FvP8m8JKs>&9LY#~wccnG*>QK#UHjX&|U
z1X>ut!7>Z{-x>uU*&!KDD`|-Tg1FaTG5clhFIV`U#XSFh4||FX^*`Ua<<fXQ3cc~a
zI^K*q@ql&+_-a6s{r724{GZC6*P%ew>V5I(^TKS$^&Qad-mEP~=zeb>`uy~wFgKxK
zXpO<s#H>HCJ^RW2cL2M8ppQW}VCc=t^XfCEIX<Pa5Kg#VP>;Mb71#1NyBOoQUGN|f
zD}g?(2rvK&Sinx_F^NjF0hFw0zp%<HoH=|wb7P^uXVWFz6~dn2n|)Ylm+D#MX8Qfr
zA!baBkeA!-bu3ia|6+M|we9&>I1b`{lMLPuy750v_uq8z-DWVLW4=BH286zcb^G5Q
zJ3O5jJf3Bboq1m13e)v(0($QEa*>Cy=lx|H?X!+V&$MDnio!7y&Q65Z(1#}4DPb^G
z{l)Qd887e``==fjOY^`^m&V>rL;du)>k`{}-~D5cKDMR+53rsau#_3!rUWyi!Cysc
z1f&C*!~fR&`A+zG-9p&qmSJ@Dk?oH~%)@5)(<FEH-HeU*({(qJL;Lf+n!*sU^y|RL
znRM=oj?><bDXM_yec`(rVW0C3@Z;|40=61n2lxz7zGctXNF9%In7}E0zV@K6KQp^V
zLfeU$|0D!~99WWlua=ZXr>oX)Q5-%#J_e9ZKa6KI9#D5Ye>gom6!;?kS@g}j{HJ4%
z3KTG0+2HR(l446jmBZbmiw#@vj(vX2Gq{`J7rvSK03PX|oz{6wb?8Xgb$wpf5f*As
zdNGHYs#5D8NMrhw@TC&RvQkqS3L~`i+a515pTo*#ILkRS)Oy9`)g+|M4bn?;H^*O#
zczpcKS&rcAoZ}=6?6oF*m7?WaU=5KyJ3s*pMdwl!NGad$G|%ic)LJ0TCD*IQPyMUS
zCHn9E+ZWoHLT~iRpnKaz*&Vx5Ez9-|B@jQg<C0}?gO5rF&|Rh%2&GVMPM2t~=(l=a
zZ1jRPjy+oZ>K4_2A0-g${?-zRRLjA*eFrcMQjr2WG!0>Q8k2Imf~5PSuPRBd@Ocl-
zbX(hNm#^9a`&tO%gR{jvvIZsnG3hPHHhVZqo%;lL-3NISh)*e$HhKA5=kd)Xl5kRJ
zvM&qEp;Z5a$Lf*oSZymdW$xzLNAdm`;k(nAr@an;PdzoY>WMSY$MNi^`LlSXm4#yl
z8grT)Jqboz)-$t~h*Z!1A@Tk^pT>x}o5zA*Pio0DpS9I!tY>u3Y2%ai29PkdFfdp_
zAV#>oSCxX5C2*RI18`ZmxbVk4EVyq{<5U=Jy@gm~k=wj`-nR{Q`6lFH9S6r$m!w2X
z6-!HRX&!%*78iQlfr4*`SMgBpT1AbWzsuZ?+e^tOj+e<7E~%Ln9F<c-Qlj?ou&M2%
zX7DL->Yc`>=-#Hqm1@J-l^Qu&MrC{KQak#c2jE_V0wNJILG?)PoFEY4b*?HE2ku~Z
zI=AG5x>~_TZn(Insf8*X^xNJ?N`AhGA7kUY2XXu(h8+?7?!_JY2h{{4Pw#L^W4gov
zOS6R(iF;gTCKHk7q8mG(3-)0|x<UnklFjb;;DUetmWflSe$+z;foiI_oz(~MHOs>e
z2w2E~>%cqfzY3_+Sxr$+7_ilBZP*_sR3&L6>n(X7?OGTlcw60jzARY}iMyJPFQlh>
z_<+xH%LkhJvmlY^@7T%*1d1I-wf|jF-5=X~-;!v!H@_aV9~NxV5Ve<7$$&sQ#w;Ul
zX2vwdVSq-<%YOK)kz(*ZMoMo)i|0$7m7uvh+f*Vk&4INHq*|>}w1;a@LpsvbXvf;%
z`1%3bcB7xDF#V6?!i0TiTFEDUjMLNY7lgC6p{onPL;S(JObpOZM7;-;yG|7omw@@V
z{xpy<{SNP|V+X&(qK@0%QQsYomgVSXE;8#6g9~`Duf#jtw5x#i@qc;@g8GK8v{o_K
z%4yQ*^)<t>@WTeT=!>h>1TQUeJ&~A^kO)B_=HOVA|H9Eqd~)wyQ)mGTHrsePWXsdn
z)ARPpqvJtxUu|5mTq>7?vPa%_(0m^*BcswohW<Nl0TX49X;+rVkk1BWLw5UFncHk7
zt5B}nclLUIL=WQyoG^F6Pdms39BNv1UWjW2?OV=MnG_q?;($8)=6oKK!%`Y4=bhBT
zk08sj;;mh(@I1)61cyU35qvY<TMk=2M~OWc(M1|Xy&+N>J&6@5iAxIwm~qBH9mjD^
zX3M*Gh5#PRMue<J1}%-Kb)W3!%Xn~dy#X0U%^@3Kb3(#A<Xa+c@H%>@7uBw~E*5(n
zY97QM!@ACZPi!3$)@V%^JD4qOCrYk)&ti{U7dkyLT}0lhXF4zclI7K}3ly!i3Sq;S
z<;Au*o_PL!TnQZf41))C4wb6Hx{?tTJg*iPJ|ciB$;lX)VT_AK&gKwqZ#&*S(l5QW
z9~Ri4kiF6Ns{)}84~?7gN^1=@pXX4o{?>{)MpONh6c05s4EmkS3$Wj0Vf5-m{CC|0
z^SP`m3>u;igyh4VPB;+g(tQ2ELpc<^z^~!+c`vaB%s3vzis=y{Cp>sPA9~WN4r33F
z!FTtI8%VNL#C4bl58(LKh>r0Bec_7~1g&e5vZN5zOV%tWm1TM@xySVrAy&T7kv4?n
zAOy4*S#iAbiK9sEWc|S{Qx1MP&g8#U1G%<KY`q=WDb=&;vl5f5jiC{$_S%E=Lt^)o
zC35{^ij4t@o8`B7Eg{{c!hdohjNWDDTUx|C?|Dsmw?GJ>PJvQA82pcb0Si!hAkc`<
zCz&TaImBlvcI@?^FfF~YzqieO_*@87AJql>vM5Ww#mkOrPtj19cl8?=6&zhp83`Rf
zbLFL<MFSmJ2Au!t0PH*hgK`Ix8MwHjWA@~TqSnoAX|}H7E~Dh-AaRLBZb+Ovdbpy~
z(G-|${xYYqcw~>YvF>SiP5KeWVd|H&6IX~wpVm4eHG(Qliv%{ug*(<glw-G_VRjCH
z0~uPY=Yv}u?K9{%v>T)%?>P<QL6wfpZ+}m$INZpQTdX<{<Mo^e_U9nPj!bPEP9OX<
zP3L-NV>nI8<3+K9&!Og;jnXiKX^5ft>9h4j{0HJPJ&4H7$VUKVvNGGKb{x~N@-{h7
zBpl{iuN{>|#~;iFD8P5d?Nb`$fcv|4KsFcC#Y!ZonK;>sTUF`Qu87gGm%$zx%Yt5T
zWsMS!>_N2+pL65#-!0cn%c1FF@OA=pNddYc@x&?Gc#2YDm|f;>o>w}nvo}}!ET4eW
zPtwiPH`ZxUMQgFrY-k>(QTR7b&8rc;!}=|EPHNX%voI8c{jC-8jY1)3<gO94%^h08
zfgki^z@fND1O<d^R@@7szN*m2)P`lbeE{gCe<tYp`uap#f-7WR_75YfMh4@Rd#UAB
z$zS8x7S)k0Gg$5$Gvr;3IX47*Ql11C!MQ-NbM?D_7Z-)=C%DLc1$gtw-1}Y{IKu(~
z`?ZPDI)!V~2${rSD`{G`&*P~9SKE1hm`3NML27}PDh7P6tba>%dTWShd77#Hsy)N;
z3!_C8`!IF?Rm9&%UQboz$dS83Q;SmY<;5d!B7p@Z-nUrkx;pM(F`tqAJtFg?nnojU
zg_4GpjC6I>`@obh!s5FQOtJ=>w~Fj5q^S)>oj`Ct>$gvw3qpz#4VoANaBjmqi!0F!
ze{f@Q9d4LzalE{F4@uX~8jzbiIT^|RhI0}<3>U5JoW~_8fiB;KW^Oi@COh)?7LR#J
zIpqrrO>A_ua+pk%`~o=<f;%J8yji`|6+M9KL1?>c;QI=PgEVW(+!&TSflcH5fsZIi
z5Ob!CmI6TP=Ex+%QI{8k{IqlblDCt_a@eQRc{Ua&sJQ?WBdM7Au3ayPj2Tk2bl2Rz
zPY=qdm4BO$vx*WRyV(>_0&qG>VfkVA@VW>RB_&M>5m%36GH@jHF6Slyum<{3Lrbq(
z_BZZpssvFt#mfAQxq8lsJ&I4+KRS_#($O<x-0_*}ssZ(63qPX}KJaxOrv&%GkU=0r
zaz6Pf>kuQxf8JcW-{Idj1;k%2zECWM*Mp)Io=i1jSq6ob2^U!F6R|Ni+1dEu$3`ee
zlh9yq^JxS#7ZrEB)#^UNV@*bCbUL$nMFl{~Uk;_Bb0X^{@s>Fgxh_8~)Pai$QNY%9
z1?~a(S0h(me296D_Y+Swv1ZCZ-zO5)zm*q}Vu=iTNAoM>P73>l`chT&7#{C7V{@Ww
zNzS+a#A9SbEr(j)fj|M#@9Z&X_%4a39N=FK(GYpanZ$!Y<r!^v4Ci0s_be#cMk=9q
zhY-DR%%u8*)Skk(Bzm?eT*-$ToN7JF#3{WJpW|7owof=w<D{waG8tbBa&Z7HSV2EO
z<m_-vevBOj>Ehd30U#z>kauuat-(0kNKSmDG3qkQEyQh`!70SyBPA1#c{qyv;n&Gt
zvJTnHYQKy|^s4qjmKo>;6pmxGb;;HS4%7*GqrAR}uHFW(fn5Iyqyg_7uxnaTTZU>;
zj}D9kt&jRjH&^-P4LyYlRode%d@p3&j=Gew{2P9M&a{1!bchfTg5C1%K8qdw4||#M
z!(ZSu3Fan1x|mpPF3PdVc|(1+rizmROdB=Mb``5Xl`@Il)6`Q^If4%dwF<JFCAE_m
zMh|J%OA!H-7+`~_3}=h>@@6Sv5!$sMLzfJ9J}S-88xl+pspI>&4T)1RR?Vp`$Jm<f
z{~}g5#`UQyEwS)I(j?exCfB>Cy4sT#(7`nUf#yIzPz+5B<p42qReh319enFv<|QNV
zLCN4ZFY&qM(qNioZoq=Z2&j|Ug1mKgn2DMLZ^apvZlCdHLk9%>?rZf*f#Qoawy|13
zzajoVvHUsuv0N%M=a5_u=7m(Pgc~_0N9VnQ{3?Yw(a*cah>U_uqoq>Z4YHKZD^~qa
zZ5HTcU$wfz)|r)ppSnRHM|^-12@q;?%>0QwlhMc}z5e}>?QNU61_r|q8MAa@d2PJN
znQ>py^CT>X3+p1y(&44IZGuJ1)@Uo@)%fo_7kkGV0EQ_4N2U&lWc(4D%omd8g=kIx
z;zX5crJvHWS{Xx;neZ{OBa!Z{W=rl}?QQy^myoCMeY?)x;4&W%?E!#7iq1Um?5&Hi
zZXJJ$>4~v2BEt}yh2MoC8~lt17zE7b5$bX95|L882vaoo`sfP2Vv*T${{UE8R)^Xp
z1g`uz)_dnda2s)qDkTTNh(A%U6#QIxZj(d#yx%a7DCo_eFgP2`BKf*0!o48l8ly-<
zx3{r+Ax_@!tW9Oc$}@PnnT~@te;p)1n$RvY3W^lfyXm8)%oqVDkAMXaH1`^?wE_MA
z!4`)E#hcodzG4GT`qT{B5w^o6@Hi|*4vZ3?Q8@+F;%RQ|4{YlpH*V=Te(|(2WSG~0
zn#*_vgbvYws2GR>$y5KjDMi&nJV7n}$LugAbym&Bm`roUt?^h!D@`(QMy;&z?gz|h
z@2t<(_*o{wZvU$Vn09coQtg8W1lqIMu`wnN48;uf$xmT^<14`j_{t#AMNN@rwQN2!
zE~zYfAxp`J@b1LPuM=;H38;^w-lDhprE1QpjmwJu;)v*SKKQYDy`>LhYqFUr0!X6&
zEa(cvkY>>1xrNUJczr>qS;Svc)fV;mayau^<U4DsqT9?!<P9lsa4;&Q<s+$SYpG}2
z<Ftpx6^*iM16}qHgQAqclx=j7d4Y2x5J<!Wr#K+43l-^qdsr~{a6U+HGkf3JT<PL&
z!izW;uAB!Bf{}zurW;zEZGK%CX<el;W2W7%fM@FifhzUM@jClDlU{?Uw(2T=;0cgY
zAZh9j8X)vTt_YKD?5$8sX)HaBNDcE$6izBw>H1SY_?1k6=NVR2u*a|$ZiCSP9}5qz
z7{v7&P$%R_&K`;o6~yweu$~6F2p@P4?Cd{G!I9LX+zKBQ)#DwDTW}vQ_a|M_@uGtD
z-<HL^D7gO@wcdFTbbFfITi-$f)ElRDXZLKCs@!+_%#k|bitMrfOsj?HFmHf-)}!>L
zK%g;fX~asl$^rmCy_pm0l)<Q^5jK#YRQQ^^{0B>Nxc*Tstjyf~YjU`JH#LX6t!Zt4
zatyxNle3JAPv-o7O^0~$8qo}}Cv^z_<^3mOCc<~ez2f->T?XwEuMaD^CZ%5!inVkj
zE3lc4IASL$N1G*Z_op{IK9RcZoLX+xd}4aBt*&tY)nFq0FA5M(PR8mi^`Y$v|C!dS
z_{v^iGcv44g0E#nO1bp9^dzn;QCYlB=F;xgRONDQadDB%yHQTrDaI<677f&>{lCo!
zkoXde-xe)yQ!hP9*&eLyloH?bu6Qm)TU{0*^iPk3jvOCExNjiymv~Ytei}X?+wlK=
z4G<%`#<JF%G4U2jn##B`nYXT}XKLYMg}q4ZE{tX_7rfwC(`KHsiYT+p)pv|;QL09u
z&cu!OeKGm~poJ80zEP=0;AUX%%i;M96`wcQGKOP!4nvX)Pu2DWhs@cN@+sm*9ux*9
z0zx;Yi`BE11s9_c%OgsFU>&E*tRi8noGUpc-_m;w*T%IEaI6@RH&np6_(}TqcUrtO
zsN|iV+}2ECo7W~mRVZT=0q)V)-UV&<*EHcpd*hL}R85zh7JcY?*DhREhI4=}u-SCv
z`GGYp-uE#`8AL*U#|Gd6?H6MWc^fS+zOGYm$*F6-k)APH;4qHv{vkEtfZ5$JZs2%Z
zoGRvtMNT;Wy7Y0q@b`;aDR~WS(@Vr0q{*tbo}p1*gr=Su%n<Hybh174>e{Qv3vc%q
zDO<^J2*0vrDU}IdCs}rdPx;NF7(yO9u)tVR#G?rR1|&fNW;GUhbZsPqvT=RUcJ}M+
z<7_H9EA`WN-QWP{AhEfc<R0bfxcGnr)~xVv(H4HqnW>adO;+LYPUAqV2BZo1PlqAw
z+XPy4H(W7Ye9*f!UMJqprFUUR0~emuE*^p_P1|$txCrz%4GJ3(94YE}^j3uS1fF{?
zk-wc(y`ndP1C^&fhBATF-%PR0p=h6N=v)f?YZV~ZM<e&mDo1i6F4liSNN}}njIm>1
zjWhf~7dq0GQt1yIcPiUc5Fh@04-YC&>e2jlNGxm{$hpB!w*OwPGW9ocRq&hHX9O;g
zLV|OE;5)O6kQgUt2ama@H^CKQ(#2MPXibwJN)&%}oMzL$ya}`H7Z`k{@<Do<WvzOi
zp{r}9>x0Z#PZn{HDO>$KPj@cTe*5n`L7Mr7Qx?%Jlx#F&<tYDPI|@q!k_9pWuk-x%
z6PXk*-WO7gSU_@x8iPA@!L^_ptWSm2oL9+`HN9Ot!MaW5lDzpWLUo@`-OP<YceKMo
z*m0L2nwup1z{xgxpS?dc2so-B!@z%i5Twh>*9=n6Tu5+_9FqmeGeF(|NFq3+qpA5a
zKeS4HsoHY>^4f=rEzqw;f3itBY~CDdEpfav8_i6+9CnppU&g8+ji>04hGm}R)ie)i
z2tdh7)!w%q0e)}BPq1)dnzbr8E0tNIGQuQHmCcfZrxPMrK}AcA-$(oh=yb(rq=93X
zu|jB?l{8;afLmtgb$z6@4=2?pB{cd16hWXQ1Yp~6=0?{bmGGLq_@NogOI``Ctapo%
znLj3^%{&NNme%4EmXyZ*(W|7!{edG70`0=rf$CpfUwE@!LkqHv{l3wUQLytW9u7Nu
z<Xr%MT3>s+6Wji+dzn=_m7V1);1bhi6XCv(kB?2lX+h)B!3&K&j4Ak+=c2AVA&@#y
znZjp_k-^)=IlCp6e1e-h)ckY6U(;NmkS9x-qBU1f>W<;M^*%jP`$1j2pF?PvUE2$Q
zM_ni{sS6R*e^3qO424-j!II@2sOqO$Zy_QckqR`j6T$IvMqCeU8dK_*%}%y9TB*58
zT8d6QBzS-MxL;{U>O(=<y!|PJ>*#kts0_sT?iXSub!E0j=#A$v+*=2SR*>RfVHL{H
zk=P?|Xj$l%8N`dd?Zf>suqO`q8dh@uNH|PZuF%(dIymFd1LhN?N%s$`-hdoZUi!!c
zt3lp<Ar}mcd4trIY)M`FQ9o?G<`iBta=b8N1hIwt4?fNAsCPFPl$McZM(aC#bc8VX
zbi%b;wnSK&%aIh<{j~lKzFAR4fEn6cp^SI@;PTS`6^ju(;5dLH5f5(Obzz#j`2i4$
z`Sv4uQMm&~=)I#uG<3Y3SeGIgYwz`6K8`_nnuwqjj;oT5lu4al*ET#Evl`%nU|**8
zS-srqMgbZ9CrlGAxwmed-<Scam6R{BHkCX%&EF%LX<Tr+m%i~kVlu<Kt<c!F1&jn&
z3>@K&=Q?H%ygq+2;{$Zi*2fjrXr#EY|9FGs4FLj%RxiNK90VjvBj7dp>(FP3Ev<~+
z+HZ*_8>x7vk*E(BsxifG)xtAtx9i(s3{BagnApGZeA&a!^T2yjQN7jo7&mTy{`*L9
z_$}F(b3<zj`(*H>JSC^>7Df}nojc?vZr@!#t=ypF&;FvLLs}M%#7!TVbrGtutY<#V
zdfUw!2*_SQFz9MArnw%vxDMKHA%6r5ExkWjpfTUHc~u^-3aU{~3^pDkwM5BKB>u3E
zDm4q2B74BiORj-6D7fQ=IhO!h(q}6{+*5mbBNGwWbzZrR!4=91)H&?hMd6m132O^9
zDzhDv(e+(mnt6l0!ZZ<6+IQ{OWz8Y2?Oy}xrY@PkRbIcX`12)k9A<7yyzt9~gvE5$
z@Y6kV<E8+jpgrXOh+N5<qSL;`ybvC46@+RV(PDgHdqU1bu5nJ4kAW_Bo4TO_Y51tr
z&?9_vQSAh3h4XnaAvW?C;9UTY*H8S;q)zZ_@**6{KkQc2T(;;<2jAO_t%&!FCf-Yg
z@}}3zoTw_#X{}~y{IQ<xl1Vl5U&;qtum&m}*rjv=6gnjWv_U%X4@3c!Tu6-tn_r@x
z&9u_1WomLa^qLdDm=d|<`=rWz<CVMMobRACV!haBJudKSeS!a=&WZp1FU_@f#ZH+A
zoly4>V_ZsOhW79E3?&#R0)3ee^~fn+`Wwdbzb?v=kzJ}?u~NR2WDA6l-q)>61t~?7
zLy>VC04)$XAaqQC&>=+_4*yw^dgoH=wfU%TkTFkS#f+xTqOx26&p&D5zFjQ+8od>R
zd;*IQgK+I<cNrwbPfW`GFS^!|hbPuiWmXjz+t2sUF5FLUFh~62Xy`rYs)Z5=;pWRS
zu=Bef>P5U|Y{-95CUoEMRf(Zimm|J9Jl5Z3DjJ<fRN0yzFyt!$TQDHKD1rb~<yp=*
zqzBzOLhnv6iyT0P#Zzv_Hypo#G1jSmw&(cH-h#GjPFl{*1KXloHCYtdT5Yvw<0sGc
z+{#|~b@qz!?U^52o1`$;3*CW69Du`gYhS=?a>X(on~U@nq>szA*j<@H)4*|L+VTV7
z^dSh{8U!*;q14<sV6X@&!SGkqXCRoZQ;3+VIE1EKPvzd@X`rPAO_B_mm;Iv73X;Q_
zLtdsqUwX99=Wvbv+k3PTec?g$26&P#9&NA!dtt*jAiA&@tWl5Od=%w-T99yR%RjFe
zyt-3L1f1S*?9QWmOtxTR4at}Yl?>guG%gAaBsmh-f>N5a1Bvtp=l#-e4Q*;XHfgS3
z*7jbk4va@`af>^PfeeFthBD}0PpIui()mF^)^jJ*w$s67216X0F~=p{j?1!(-S?F6
z>s)=ORuO6B>n}PRmW;_c9nG-R@B*IT^2%u{e;xU?XteO;k)Yhg?tGtDUtUyNy3x<B
z9FE?go4;Xi^ylM<+S$(MX%c^PKuvuHhjR*>g{DFu5Ux2uwDTl>K5vcGmxFuiH{6&j
zRoeA2TWBO{tmm&djIoV2M``T7rjPTfN80#XeyD-D1dHt9qRn>djr|_-^4rh9{FK<0
z|A6@KBS{QhgI$z)UtK-0Q7Ae8`QE~PS*v2XcIQz|>g7UCsd7OC2nX{Kue(>cYsJc`
z1}j*NzLHs)T68EkxHNT!epj8&SDAK~tHLUms;Jh{16?4W)-lp|m~^dhT1kikc&SRZ
z!hd*<|H8q(%yx+%%qj^vUlq>-<bz;nop(pQ4NKHc%86mV8C6(Sw+E`Fixj=22|Xlz
z_N64LucU0!Q`4p@_IkFQ$!m2gCU(7fesR1tRTNn91?d8~5j5N9ic%!QD+1h~mYJ?F
zFs{|!r~y_B@4-uKk5cosDWZ~;+5HK7th5U+9nf!8M%(G?|A=}EhbY_Udw2l>Nu^t*
zySt?uq?c}%21)5|1nCaxhNZia?w0NbkrYJVdwo9N_xA_vTzg+RbLPyM+K#^r-_9^j
z78Mzrl#|KIFwukqpP}hP$RgoMrXCA%SH!CYna?MjgDPX~?Gj$_xfbU+u3jdHzyh@(
z6>IVR`uzdT)&%KRa7X+a80yWFr{0={{$pg*_=fpi)LaG6;>xjsiKS!XcgFlshdkUk
zy9+$`p@}I~RA<b_<{QFPq%+_B8!cv?#NT>T5!H@42y4#Y-af=h`xU$doLbNqbsp!b
zR8nA&?MhaMM8WUA36VboUA}!ExsyJFfRJiwXHOE%rWPp4PgAl`NDb^YntA+}HRg9d
zkdAG}<2H`Ay{@3$dN(!bMwk*7dhMl=<I-QKg2_VjiZ`3y#`(w)Hf<8AxlelLk*%)I
z*fsWf_>1B)VxQFN+}FtcW;Td{?VPm{`;7jc6`+lLrE2HZXyw3&1pCA@roLp_QQ)ZO
ziI^kZlpK`y4>!AfRiO}%KWVAd#+FQvs!*x~Sl?31`u(xHfcTi=4Q4pWUq<iJPz<LO
zHDLv$d*g%bGYDt*bg$nAp#U=B)s%WY@Ail%yM^lcXUWuVQ~cDJ(^J!5m~yIaR(LmO
zr)HjLK>y<g{NXb_X8umHq*|SO*@1!NF?~M(>WjD>le07gz)oOcCU1969=nwI-#=G}
zLvPIev>l_}UQ%9~BhO!I!J-pk>(+E%*My|>MjJeA_k?Bbil3<bRhUX`Wlm)e^>l~J
z2ls98;6?qrqH@iAXm!Bg1Y!rk9NY(t2iQ;lq5Lz9ihSZBfsR#5*0`@T-j?_r)fWQn
zVB<TUD6n`cWtEg%(Rzmb%z)OPNQDbGxan_|O3a3i+s;%@2m%lMy4t5!n3zuV!x_ZH
z)JozmM#W_*nfA<pbz{m0Q)(tIg=9*$5c(T)4vBlh-B1_<K=!Q4+@kL4n`c};{&Vun
zl@B|kGR&u|5~9Wo3*%~uIt!II_AMXq7%Z`{guU-7e~HQT|DQiwYyYj`q2bXWv<YsG
zGxXJ3!}J&L)jpyhtE8ZB#wx039}}WU$Q`~MVM_5(wro9f)JtAV)k{Nsn?AOH-%PCZ
zlO0~0!rqkW-1NuxZzlwm*;xLb>?ue&RqD{e3Zq(s4=-$$?@st$5YW=tC+%job@2#-
zXI0COG}X*AlJdAAyMOaF`I$SFhvh8qxJ&ggPOh(>KVfjrM=NV(K~!O1tr~;Bi+bBG
zez2H`5ra+7=GVY8f9VFA5v1+HNFe{+F2>Na9K9sYN&$IUFYH>fZbgGNX&KedOx;xN
zpN>0<ip<ia`&&PlU7QOmcQA3#J6FWFT(l{Ubk`H+{BW~}4_j+>M+706u~+C%&9l05
zfcnc~aPds3>0OlQs})m1J6BH=!tI5bOgG!<G(uw!=&f`|_4OS-bQeJ>ja{u-lqN>j
z3May;-|9)@Ll~=JyG$RU;P-pS@BOcP8CP)$E|p#5N6v+Q_`#)x`Qquc3*>><j4BoQ
zPRG8NQ@gDtNo5g^jWCTEw4!9yC`c~AM^V`t@$!rCzX2?P5C9g99>U4}=zGi`S!a!9
zB!6WN>OFn!A<>gF`|o5Exs1L#-*4gy2F)oNlWmX7-_w{Z5A~8oDv!=222MPx&3$}w
zrd6_pnZms~Y3{0dbuIx1MsQb<cs9g=VIKP>e7;3}>AP^GuT;w4pYCYIhqzzORf;4e
z_Ii0XnJk<fy!Jki)^6tSxqhioAN6OM1A7BNP6BMr+8X4l{K~kI+{lwtddkyH2-2C?
zXD<l^i2?$F5NA-<?8GS{LPM<L%j2mojjHK8g2RT!!ntdT$hDLP^Tk%IY2CcoBB`lS
zxXGypnIIm(v30UXm&;THfEfbw0S)&v$aEhN0d^WxB9x%;I73h|YnAtlmgC)s8v-uK
zvrf&6Or^S$=C2lZw0^?th6YY-lXo$>IQ!*CsT+`P6}Q8_*$Mwc_iEnYR7aEZ5P33L
z0220~f}}@Ow9qUu6do*vk1Xk{fh(j<@SD^EJ~~Q88QY@(soM+5AZ`p%rb3e{ag6dF
z?u|GBGT&FTOlp`xD}a>-KyF>mZy0sIz2A=&ml|zio@HQ@&|(YM*bd5COom3)J7s*x
zT1ykggM@vInQ9VV89Levh>dLbN?_??fx%87KnN$4S#{}N$)Dxf>N=1aqm8gtDfPPr
z=Wv<NjzgAh#TI@lH_LBQ6Wu@3zM+XhnrBEz)OsoP)Fe9NpU2n(RF?b~VbKE!Bpjdt
zk^mbIa5r%g20=rCa5*oq9mhF<I#v<WhSMW_jD}@D7(6lmnvaYi+(G?&d>PZ-%qYr8
zBxH5w#pF<0BAJEF)m=(FEK>^V(Q%DOrF(&)B{`PzO&N(+?8H&@F3Gz)y(+Wt%xfmS
z0aMF9@R>-Jrs@)1zxY$mb;XW?biFN(VV=|#J}VJ_hQ5G80Y0M;ZxtpCjoOkY9CHa)
zMMC2Ez#Dt<#!LZ0CD9+vR}irm?k>GYcasKL74h(${7SQ!Jcqx*xXZ(Gz90XcXQP8V
zGWO{yu2DGur9zSi$xlea$%Gtp#YJQG>a(FQI?OaE3$YMBE$P>8F0?4{pgQob{q@~i
zT<3uJ(mg)58;wA0JJyQA1>It^$cQ#;Zx?^9dxpz8>45u}P9~<AwvW0WRqtaTpxMRj
zkttz7-Vy|wgja(@hp3wLFVE&78(w4tQ{566e)PDLjPI`qEsbxKd*9$59L$?Z-2VBe
zR$UywoOvTkg|cbY^9{39Ep{(|;~%>z{QpdOfyzK(2)AfF?^Soi@9*+V*A*k=G~U&H
z@j9mC`8nbB(pDXy#!RSv!pg6|g+J(BU46G7KjqcKKjlUY!?-}k`T&&Zq+Gtq5Bog0
z7CyZATh;3idq+a6ac5qC)Yf8}<sxX(yU$JeG`me)69^PdgB!+9bTgq!)Oj+g1qL=E
zan)_G>#Yhv7GZxytM@-@k)%{DU8JzPW>tcp)MGinvHdMgg2pV{N#Sy`ALv>}JjhYr
zDTm*c=t6AvX1H5XB&SHbecmSw1xWY*!%ESS<EM<7U0Hn)!_={)_A|$lbJxYxFC1h?
znIm;8KBwQJV^>3#gS6x6CnCwt9^YvmPh?MvYalC}hHO&>JyI$82Dr?iy#<&fAS(cR
zMc;F3InMWk)cXUU3C8sHpI1vLcY4=U;mAiVCaa*ur!b`YG;9-jsoaiHfjxa?Ui4j`
z2tms7RYg;pnSK_s2#|#WO}{9FCzO@hB{(4nI5k(9|DHf6Ejh?fyEAvXu*hXp<EG=A
z^x!;C6)86mDxJF1kSQy)aTi~JTPBabmx$A({TUWfSHG4;WDB`qp90`L)uVYMNimhr
z_QANf>l0UUtx(Xd7r0{1Y2a!sFQd~%-zGPyx~$f-yPSuMS1a&h5-fhR=BM!Q1O)&{
z<;_8*s}X>RaRJfPK=E|Wmw35y2U5JMh3Xo#a~Id!v#ZVg6FC`1tK(Di)=##rUpHs1
zqb#b2`FjpiI&5;g+gqgmec1aisClepbH2iWWqtl9p_EpftP{;$q^DBL%{P(j@K+3S
zjmJ$i@{3%SksU@5W`byA>c_c`dD?3V@MDX$x!|*S**1`x20TU7ytiXXT_MaEJwYp{
z1cL(`^Kte8oDeMzbzT`+#pEN?3n%^i729n(XRl8$8(40IBx7R}WMQkWPXhcH`LKyE
z2skE$cS>$GuAb#NEYN-hJqV_t$8wYo2^zDFU4#CI+3H_4-5lbmY%{XuZo^bxCScQw
zBa7(7qL2a`+AEL(?1J4WHj9{(SS%@pv8I8lOVS-WV4$~{zD}NrYlNfCJRrRkCb`Qb
zE-*edo)zr@SO8UmU?zZNNd#b0xna12GfHaVD2~BQ1=Epn^Yy_c4^B0u;ABRo_-*~#
zVg>H}PL$t3a<@sv)$Tu+Z<&}y99<30)nt1%6@YBODBcVWj8TR(w8CxiH6l7fv4zfi
zD+2Y}`I4LR>l7y<^okIci4%l=ci6r_0<vL~CeXoZAz%?ILxl$;yCQ4HRBQ(I=6j_0
z8XXI0WU%E%T}A$W&&I&3AE3pJOF~~m{D1J{0qBIl)$$i?<X+=12tu@o$Y8x1sdG1u
z*KM+e`BJVk5S)?mZ*chJMW5V|IB-xts?m)p%y@?E@OE8cxcmSLxrtIF@&E>0K%@H7
zeS8>7Bm2G+{~)}Un8&SPzqGtZ9dh?HTrkXYjmkjP`S?0Fqe)q|M7r&uQ~J1$pydqJ
zR4258W`3gvEhTm_P#6_9rAS47w7OrVIK=E~qNU0<rD@c=mq$Q~l2U`>6Z566*M!G3
zD7tp=K*PHqQ*UwVU$SQc&2Z^sUcDXslSn@jfnD7EAr4bQh3s$x25<&Q7i)JLbGmAD
zyZLs%xQzyOSybswbm6V4V1o5taf+;_4-L8{KE6jU;(HfDqLM$@E0>&d7Ds*k#OGe#
z-lwAOGN*=C#(*Vb(sy|8A#J6bXbMJsDM-dul0ah_{!3o+%Nqr#O;Li+1Z}*Xl6zT~
z7%_y=rra*DL?xFdpI3A)L~C-da?6F<RoqX|6*gI?z;*6gT=1B^E%zNrkQL-d8xz42
zWKAzqj%Ye1=kr2b)=B&ocT!1E&i&V$F$%l}Z(lTt%{V{{IcsYL(tS5a5Fw)fUYdaI
z2l&=6s9RLD3zz#vtYXhWSAhWKw)AC+cG~<FLT*&N!*7-^aZ6vPY@}9Cm$Y5)c${y(
z<a@zG_Wqn;lWJ4p!2&{Y;5x6*SPQVPx4DhZM(@!rtpss%m!?G+xELbH?B}iO{jqsg
zgdR;?I@d>GHB(><LCCQa+<8|#L`SP}$&4dZVDn>n;20a#*GgiEWz^f+VRU8=DlUi`
z<vYAhjg*v4VvBXKDuXj<GaTLJHmqT>*pCuU)a+~PW`)RjVpZlZ+N0Vz5PUnRRviGy
z#mqq!zzd=O>Kbs<ZN8JuQ<sXoxDG!4RM~P<Z<jk7sfu4E-$;}>-$W5xX{h~;;pgWv
zCyps1o`R4Nig<;j4)>W^X$BWNZjX-vWjX`O_Lu~3k>r7ky{8HASRuf%sm>DokIwqJ
z&78udL?AsR<XTAYbfL|q+$qJ@#JoaxrCe8$VvjOY$)JL&Qs-AYV(wD$%OT*2O5Qte
z{%X1o^uXZvCkRXRVwp96N5V^}3Zp^u$f-Ur-ufmE^OHJAtMbYAtx-j*b>I3b0Xw*o
zbQ5XB%Fq-a%OTo6<!t$L<?zV*nYNi0xw<Zcu3oS5VjIBLXV5j06)&RR!$!^k+{C6H
z&I+S$3N9F-;T)=X>48Fl$^~`mY%XQ~46KtAgJtp7TohlZ&BQ7l^-^ECQ+;dpNHg2d
z!*f|tEvmGB>T%MI5SpKqMK_>WpC%WV0Ekw%-+Bs=G6sPbWgW|Eolst|3=ZCIwCWK9
zuJOJ)3KkU2zv*on|9}KC(HU;J2qjgaAVCpEbpEG<;w%(;bnQa9;XCrsY@1kmuMP~x
z+%I|0<~FL&Ji>UupER~6<zRW1G$zYRLQRY!(wIOjm}@A4CiWh|C<<x$lRPV0>5by%
zQf%!avWirSJ8K5H7q&QoQsM;E@{~nVWv2eoZ%bF1S|yV0^=Bt|6k2iNmB<Dl@v1f=
z&80@bF$A_IUaB8{EoNAFBqnsyxV<WM@T4<3gwvSTh#6LLl>BR~y@th^KSU~;xnrCq
zpP#U)@5Hdlurf~NuC;wHzgU8%HXj;?jr?&nEpBa#o;IPby_l>tFmt|!Umd+U49Q{V
zz$xu;sz?+F@W8^+@(C}D`2Z4%U7EZMb7qS4j-rk`g|^-2Ls=T{MpBw+??2A?bCtmb
zdh)|A0_t^X6Wo^C`fZW;D=R?+(8JL!nybnwu7v>#tF0c~#CQM41sH=92Hr0TJ_Uvb
zZ?EUGnthLHxYPW9eywrmnHzRhv;Q*`>Yt61*>sCXg0udmYwS2MJ6-dW3qL2AAklI?
zA3QJI)vJc16gWgXbDMsMk}GX+w7<puLzqGoAlc#;kXRh@B!~?kg{A+E)?2zav$sAo
zcfuFAB~YDKuRkp9tNU=oY@W3=9n_p=pP86iiHhcAO{f0z<;N<kD~SYrdC38B&603|
zOuyo*FL+-Aaj>8H2QnAb-Et2PoC1)Lw9!zF0$FYnQJFCU&l|!?PPRPUu+RZLR-G)8
z$$)J1Z}33ofI$^|Nm3Ysx+p*1L6_{|uA|fH`H53q?DcB3j5rmGKVO3&wvjHQO+PM;
z2?5eNzP#|Of>I*{)316*B~q8C0<AMy$9yC~`Mqvx5CEF$!6q_Ia{FbyK~<dPeY~dG
zW1*9BZe6jI1qHSk9GEg$)S1R!_DZvs4jF8O{S-)V^QyAuySf@rXe3=BL8ijjUbR|3
zvt8a%92SKwps7^>TmB>WdxU1T>bI-DJg_@nHmyqX1Jq}`kTHmH-{;mFe|f~1DM3We
zDrY`e7|Y`8h_!RoYfaB?1GFJS=&O7lkCjz=t-;F65B`~%{B_=QOeU7t*_3OfY4$-;
zw4dp6Or1mC#|_FwdK)c~4KnwA1z1v?QIEnzA_A||EVs~+N`Xs~jkfji7CQGx*nmT7
zyx&)hSzYHy$$U~+St@$qp5oKs{>4Dmnw@;Q`geop%gA#3BE~iuU}t0^{GQ)7I#C#8
zF97MZD{jG9emXHn&&v0S!dwV^2v-h@Qyl_;`K+O+6n188f|F)JZwmJ0Y7I6{RU7yx
zxWZ`5eW}VM<tEyM9thA{tWXe%@qAqDcioioVk|pOyi?AXEVDBsd-&57S*7#%wiviA
z`RO`;$yYx4)<9~B(`)Y<_ksu*D!3QmeP*L0%}RBN@5D;IRI@b2%t+FBS5MG(Rw2R2
zPJ${qw8<}tR~nTVHFwv0MI@NmVky_gjDr}woST-1s^x(U_RuB1r%c00>rsLQj$AnV
z&l$5J1nDPV*hkF*7T6LVx%HiBad@urfSmT5vt&xfw%KG(V_z)GSY}hkVE%|bF8gIP
zD_TdluN9xD)q<AS4}=UOiP`12aB$8A8sHt?ZW)-0wzR+Crtpl4Gk*6$3r2iW*X|^C
z$h)0;(>Bb{)$hh${&=fz0~@6=2sX-d{4(F+bdaq6YmQKK6Rn?|6O#-5!;v<Wmg#)Q
zHAyIj3zxFL(Id<3Y96!pI`(H<-o5ZrW$F#+%&`IEbgn8qP{4yGEpjrZ4i5jk*@27C
zKiyX|YPV8|dq!U#$wOAcXW=@>J#%B<Z=q!)!Z?dvS!g#+M5^4$4Cb$__v-v|AWO&@
zc_e%KuCf1_r%o60w=QL}Z?eXL9^T;nA%bl;FVz2<9Y_+uT>B|IvbZw_d4vYpm$Hb{
znf(4=&9n!UkxBxlvvE#A;mTbs?*?>wzn*_sbCu;w@@ksBKk7^N)o+-3y=drgvBDuU
zx+;oPfAn*1T<ex$a3c+&ve9<#<DA^lMxzTg&AH?rhg;IU3vA&NIqDyk0(d|LF7dD@
zNV>Ou;Q!G`LoOyo(#k|$uV|+KMCFtRX(3fozF^Hv-7#;dx8G%$X`5`A5-olx^dzqo
zVEaX9>wH2CV&ed?Cs58<`KIUl@;y!HIrHa<4$mlTg0^O4?}QJrqr>u-LkY8Wc6~`w
zl4)t+Wn1;8_*pGB&UP2ci^7M}<3fB_RByQIa$EYcF)?Nr0CxNA=wlXgU%;u7Bb4sK
z4?+Y&XqP(sGUHOLaAzeuZv`_>gz0SG(gP-4<ZxHRJNxi~7n~KS8W)auJxmk><KH)K
zHS_qJ?Kz1^E!}#TD^q1VZFn&VZf`VTgv@IYz<4uWZqfk3c#dGcwwL&d>t#^>o;G+N
zjV~+Pb_Q3SLB4c#Z%?n?M-ETJYOTEo@AYP>2CF01cUuBg5t(WlA|tFI$dd%GCj_`X
zQ}!+OY)RhLHy|?;yA40_&oqDn<N`H7BnW!MOm8DL_*Z0V@};GC>U3;BxRVbT*T<Ks
z4T=!1XglDO;3|nh+nS_55*QhP85caewz!Ho(pK)ovGWT^{s7)N+@*xJ&)zjaV_+j=
z17`Wn|1q0TyfgbwgVU1nPESSZ2dWw4m5%V(9jX|{vm|LU^*A<pQrfMpTr+mZ_TXz0
z<157*U3}Ofn~SBCosKVX*vpaxY=55rN`dXXSB3D)guwe4kTrU$4p~tf+*Takv8a$p
zw@+rWMN!w_{@&?K)ZV7ci34%g)SLWM@Zrn+NmSRqtHzI!MVW%lWv)z<Eg_I%uUz_f
zl^-fx%pha6|8bQVcc447Q+2*~o?9Qk3>@QW5-AMQ*lt%;e=I$;W3A_(m_&@Nk1=31
zZT4C_rla>Nx?r%_CGI_b)}s__UvBMmwA%*y;k*W@Z*Ufx8gT{whD*l3C$E*=fhX*!
z<q<5LIO9#^iu@nRs+I*70I6cuGMeKRTGM?RY~sM@Bzq=Wn3ugr(wc~xUu&Y%DzA#R
zbV#^mOeo*~5X{&viUnOi_BBhj7IUm7|MP3l>;bMn*JO3pW74Az?XZhkX?Nn+#$)TI
z(3TefguxaRG%ZdQU~p;pcKdA7JH2ew;8=c!CwlpXWM<3ZbpLP+AfptP$hD=ha-txQ
zoa)M1FS|fa>h-2!T1kV;Ig+;rH{)x#6)A<W7i;R5N|Bj{e%dqVF|g6%_G9-Lx`EIh
z^Z;%N0YDt$`?o(V@m@USu*~G*>$PQ5`+NqqFnQOAmmRIqDA%;SKjL#=p~ZR|sjtIC
zQDK~|bjo0!J_;5oUhyB7$TA>fGNG3eO&m6zXKnoeDR7$z{QK!x2El^GO4t4D)%*@}
z4x@3C&2NX@Y*LHKdYV8aBqRW#5D1r8R`|zbu=IcN#JNiWpO_+Ju=!A<3XlO<o-g@8
z*XqaLrv?w2R9h`$Wxg%ci)%Tx^xNuLnqpzs(f9n(I_D&Ktu9pYpmBy1wtAJ%)jeOW
ztmj}ye7Rft)%y_A_V#EfyH&1qZON_fgP*jD^T#XCkBhg;_;0t?7FNv);rP)0(Xd{^
z96>y8NkQ*OlKkxTbYqah;$nm^oD~Iy<tl&6*M%D4C7*cx_D!|KEtcF(dTH%)U4%Hk
z^97FexZ8Ee8`bBg((IM|jOJdRjS(pRIq%eh!y99usumQm?^N<H1o?m{fFir-XSX)0
zZQz^??I6_Dgw8)Z%sP`DT56D6(XUsWs(BQRAiq(qdEA0L^h6i!#{Ib_?4~7Xt2y1)
zEt1)BNLBIAw_eqm6y!H=8Y?$)+6U@Ak4sOz{eAe>PE!+2-MO1?<PLu4gK8D;Lglro
zG1jmts~Xw4Kh-ltFPB?uJ2G~%8)W#}Zn2F|6lT2kpdn~OSa6&>pY9pkqxk0d)P_Ki
zL6`25|LG@M`6dfzuAqd6lyHYLA;=7fe`xk8_=`StLjpU1fzRj{J8>11C-pb;r4%u`
zK4Pz)ts*@2SR1If9qos~Pd9zi`UK)Q@c>iZ&}}%fAMjrV0@)hw0*#?_zJ*rBl9fm3
zMi5xRo7P%G+w+sK{a>2*#=$fIs8Fb1n8P-Isgrkb%`sC3Br<X`fQgIKxf{}O4o+0i
zEC%|#@MokaX8^j3%5Ms8B>gnWDK3mb%~bnMr?asu9c@}EDecoe2<at_F%Sww?l`87
zu&Ay~Pug4B{8T}01>T7{GX^JWVCK$&k7|MgGS?ahtXlp;N<;ZstNMOg7izH##LSau
zO*1q4r8jnm(Cje&8+e|<+|OT9n9v^9W+(a`Z)SO4eFEI)6*kTI1W^MAuG>J?e7_p8
z#@NB~&5`1UZK&>B*57l;XmJ124|xBIVN^j6OO^bdXQ5w*bL%KiP6#JmS@x_xaPXm*
zHX^C|RCk=p0w`F=ICHD%X7rSU^7~v+21cf7+!G%(Y<)AZwMOYt@S`32Y3B_9pltxV
z0Tq)d)h}O)GwyMa05RYk%Q>KPN2xzKvh<e_B#M`y&{LS1y|F@Lii$FLFnM^kB}@?m
zuZ6h5rCMBY_VSw~{~;?DS|?WrZmY)Lb&>1X33dR%lQQPldrsPwJ_(U~?k>l?w;#G0
z#s5~iyl0VMyy(ohV{R)u)%6_<1tA$DfRXvQy*V{?>=r7-GYWvdE91K4Xe&P_c*3<6
z>FOKOdh8@}TCY%urv<K=CRU!Lqi*X}JND%5dyz$=UFJM)b6p7fR0xd)e)ef7={4+%
zoaOrg*f%naiJUUE8>1jPlOk8~-diEXY>D^l^buV-*~DYvc4;BUuUbfZ!g=Aq0QTu&
zsV{bT3ARgcmR0clsx6u6EDbkQHq!8+=X$zeKZb}ig|^9N&RO+ps=|+!TU~|}^x+@X
zSqlzEH!<v%b@p1tak>5`D`_4rIApd4(z}XUVWHkrFb@4FH)B0h$L~vH>EJz1_0H1<
zTWJ*+*C45jQ}pB;Um0DS_5hg_Qk+AVK~-k+Z;zjAD98@Xor&ayy>fYe+7rG8n?^FB
zf9un_PZpjV|KOnagq1}ZI?y@o-&oIX@gD2qiljXL6i`p)&yd&HhM=7LnaS|Ru)3nA
zgb{-!M{PUphM~X_(~i1RNlqPuFK}6$dQF0#RiOZMbMGYijelI~*Ul84Th9Ax{!*TQ
zzVSKuvVthJ{8tPsDu~2vlj>dYvF-`>T8N}W^_y|r%B?)_>@G`aa;<(>jb19n#2Jl=
z@EsTDa``#=gi>hZO}cyZ!}m1t57`SujUJ+4t2pTLxFCPN4PqW8umy^wlVmtk)w&<@
z13ahYx?hIpWRxF^tF5lw91E{km45iak7?#UH`FJn^wii0y(#;oX5e2T*o^r%AxT)l
zcVd|(;nq4#v?ew9CL8ymhgL@eo{bKk9OL`Hiuz~2-h)<k{YRaqIOd>*J%nfhZ1=C@
zB{WLqHmU;Mdv3)_rnN1nAE6ZwmMF(P*j4WE%<9h{{n%dVI@6lWZZY8(RpM6*YvKOw
z_~9`--PuCSY*)Z?V$#zBJL20O0D2Y^WFMR~rn*>^l`c6l@dczmo8w8aY3COk7ZRbw
zQ<GEMNujN<x?NAm;uTJJ*kO1>7xzN9r3D53oE@Lhi&jO%=03YAe~Nhg6~Nqjv%CNb
zm??{iy;U6*DF+W|mL>4Tu3(uKDjbd&?0>3N@7Pg`nZRSm7Az#I_-%|jM{AHW9zBQM
zGN@zU#+6BwX=Pk$q#OB^T2JBcw!M{YXDUgK(S+;@|DR?0Wj(~Q?*#nh@<|UB;^S1s
z;>kF5*4@T)<=Q(b-6rs+o448qxc&_80g1D7S`LgDO7S<b(}TH*mL0gORfA!j>$WoY
ziIrVUi-V^c!R}t#{Tb=1Z?I8%xO(SU&gYE2Uk9iLD1%lJ+KKh?{t2#7l-NnQY`osE
zqpDtL_!wuzsDtx&LBsQ4>)f&`dYI9Y_9Ha`^lZMau&l>aJv3dB{s{jsZ)&j=6i~98
z2wouml!Mod?3Z+jX}9o^=nChO56@lD3SMCQ`*7yfeCE@i00WF_446|YsLdlgJKU<N
zrWJ%z0bjV%#KtjT>BPtJ*jo3PtjS5G+TXt}BL3ahIOWGXlOh)C)=Bb91ul9ZlB`Zo
zMrE){gZ2onWG4S<MnHnkcFMLIZ0|g1fUSnyO1QjsTcvY-Be83lcNMiA+`>!nz~(lp
zNM=)4A@LKo0$ppe#)fH0`?;i|2Hx-8YS)Gc<XI8gGo$IgtOU!|tEp7%a5LXWg-i%u
z4>dww=-{2M<H`c_l#k}-8j!PIsW4m6h%kG*tba#c>UvKusy4Pbu;}L2G=RH~eYc*J
zwTK_N81qQ$xqnt}Ds@UK<3$Mqvp$6TGYNDhUJr=|`vF$pZC76Md;JjlJB{mct0R2)
z@-I!08xS_~U%~U?7TCDDx+qo3IR9`$z$T-kAM<({{zs;gbl*xzIKIV}=_~3@BCU#i
z?iMVd81C(MS{H-=A(iG5y<^Kx4|LN6UQQkKzxXDWX|DaW?QQp*Q$I>UF)&(|BxbF%
ze;FylL_GQUV-afh;<-;jhaorACI;8-w*_~y0sG#cD6L^d*PClxJ#3Y4<6{P|R{xOu
zt+Ib}akjst+R0@dH1(w|HFDCD>^~A?RJXf@&etGw5Q3&d2zqqJ$hG|$nETIuSofSa
zmbN$*8V<70ehe?<d!tv0f5)34mVB=3(?;?G%m&016HSZUY@y#a0=nB?%e4l2%m(MS
zEspiUtWOJP`nEZi?_RicRt)(bG~RH$$P<ivD|+V+#mu5v9?o7#)JlfioJfs2_lrd3
zfu85$=8j-#<v5jPC*Zf`PbRz&1rM68j^qe?FaGq54UO~30m$55_0*cJFD#Wo7e5PD
z7yOu&XDKf|w!3iVS&t?QH;JUz4(G~@5V+Wuv6-WITVLod+b$(57&?BfiYGA=O3#v$
z$iN9@8l2-{5g0*s=O0k5swC<J*S@oS8nWB|Ys2#UN^9U?b7aCli2o1}Nbb6P0ldtd
zQ<sBbm)B(rHE_g)Ot}C#JLX;wx9vMV5-kdU5A;##`&mw{+jHKYUzAa?MbSh)PZ)pt
z?CJ>i8*xR1;!4HEbj6u7-sAmD#npnjOS~qTpy;CBc6R&-e<TC&e?!!#_=_E=b|YCC
z1GTxs+Olg<+0}QUKC7h#s$w_z*M5nz#~<(+nO|m4?z>eP#o1SKJrSN!owOO**yT$(
zIy#0cC~+PFvKA9|&CSif8X#4(5^TXNmHUvOSf&o1*(ksHqd%oq0S$5~mx4fkAkyl4
z?)u+?qt211^OGIj2Y1wJ(&g?$wU1QV_C*$&n^C*@lfADUYP^bQCuE|Q+AcC$L~-fO
z{U@aaX;0G2=t?u`P{#soIJLW_Pu;Wbcr1q#1E@LMh_k+$olk5}yFN+Ixo@jo?nx0c
z!U39^O>DuJTuuPe<%CbxO`9g#iJaALDjt_H#XL24rFy0G3S?ZW-&*z|RbF3+Bk{u;
z5np2ITAmZ-PdXd-67d>JZXNaw0i$p8eLIuNwc6zyF}Fhq$&h@%OfILyY3|?}wu4sQ
zOcjt}pXlr=U3Tchp*zwaj-B!!Uhn^=n;5``HA`Nc3oe<o6#X?$miu*#&1VQ9djBJW
zfkVi%H%l=pS6Ng0UO_CUXo{I|WuoV~k$^0JE7M9k{{G2Z%BXD1)t6uoC0+5vJpJd#
zI4^MG05fJ6kL3gJ@fvjslUcD}lYQwXi~ji~-){sa&)lh=_l?FZ*;(cXgsPy7qvy>h
zUtbED<|i6a5AEEiaoV?d0T%FBg0$X6(u3SYKaszlf9cPq<?b=$Sg0IUf=uIASC=I>
z6HGeN^B6jZLYampv8F`?mvXO$5Z0GiPEs?_EE?C~znMz?C3XL0@DMT9IK{J9Qbb=Y
z96hr+lI}6%dN~{Q$0aQZ>Mlz_v?hTd@f`G#=z-Y+*ChS&<c|MI*yX7ppBNv^y78I^
zd3wC_N~+eCtuA7&Bq8U%AYG2Cbn{(g**r>Q-{;VT8I-O!S|4L@rj(;{cR>VF2Xs=k
zNCG_}ecEWdYcHY9^ih!=y)1JMTiIE^4$D>16+i6N{X34meck@1+6Zi4@^?bfFM36e
zhQJQr+7b-Po!%oWXW~GoH5W2>@uKz%f-#s!ez5g?(_Rg&5)$EkAuv<azfi;Sv~~gF
zT^IQQ$J3+p*Yf@$-dC!3YBwWA*pKkUc}#LHc5GbwQAhtST;qi(Ny?d^7;V4|(SG+m
zxnRdo^_!pLFzz_>S#T&L71g-8D4o*D__8TyffL6FJ`eIo?}DH=%9A9Jm8l_&pp~g*
z>KAQhH3b{Y@vcsde@Y?2z25Xd*}Mt|<m58KR*CEUwdDi%=zAKk0(^(pa6qD2uh3e1
zR}dTY=D%X$GkZLXl#YB3y@G|q=O|$kA6*)J{1iHBzJx+G=a0{06mqXjXHoUm9SzUh
z{ED*)^8>w&5a-x4AIYd6KcXs>kL7zJ?fz)=Qfc4taE2=0P;amS-R|=I#2j^bHX{CZ
z-ap_An|5#3FTYpDXkmbHpq-J=gp9A$79X3L3P<(QEjz{s2F3?=NC<yzNEaU9KDR|7
zg^3A(b$_GrRFtBa240v}G73nkFT3napJ2*8^DP~OGApY8f&XNA>9KWwF50fhpq*gI
zXI8b~{r$EpF<LVj$2W3mjKiM^pp2{*SZK3S5xoF8g`P>6I#><adcV^VtFTdJ=Zt*L
zW%uxH;F38{8fYC7C|TkmvcxkuH})^_hi|sAp=V4ZVJ))4s0_UThvvy4ih5+7tX*Xm
z8u1(-eg0!Pjc^_(Jmq-N&Nkz`i=<Jr12|7NEZK*3U+zty`lBAeOs^K)SHC%3#Z@#0
zy^r_ZCgnt7kCr{_LVZh3XM#n}@pj>LD)SjtUFX)%fH{YL@m@fqucQihlA5JLkh-%b
zRR3o7Q|}0nT>LoXn6UAe39sVeCe!{VMSK@OqD{A|uE7IaRNOu?`bqhhLkLU`s+~BX
z{vVSq`cV}OPLo*KH*VCGBSqDa3LGg<bkdg`lje$MaK>9`k<Sf!4&Ol_4qj;x6DUA;
zRd+P3`W$`;@<`tXKG9_Dt#J4_PxivfjmCjbox|J~5rg}k;m3UI_8N}Af-9lXzngZ}
zHgWaOYcvF$u{Kfur?E4M_)nK^1KeNjRUZKcqCbgbCRL@l`AzIUvF23@6g+{G@`9;0
za_u-f)DA2OQr2et=b&c2uC9P<x_4C`+vD#*KZ7JPESe5=EcdR7H%HuA2><#lHiVz?
zpYC_2ufoK9;#k_fn%>9UZ5FZo$VCD5pr4H#KBlxi);)C#{$L;b%33q_r%`M|r=ai)
z4QZVxj;M~D{*!7%+F+;#?NqTYwOi4k1)0NNcO69iD23<iMV1X+2cl>8;@43)N~;`G
zgPS9R95YMej2rr|f>mKkWM&W5UFD8jfMAX>Vy%@_MGfcBj`}Mo`=tDQ-3TTPMf`^|
z9isk&pyV1kIf!udZMJ<^O^(d5y<1auY+FOP&uzx9!cPvwPWC80OLwm_|N5||9j#Km
zqpgFK@UXG|RE}jlkbxZ343_J}!k+AJ7ASu^&9o6fTD>_*mjH<|n^mE3&D3@VX<5#w
z$SOTq<G^{+u`a=np}X){v+~p`K4$$TVSshZLmZ95%SwaeC|kJ8@%INl2w!n}<gI_<
zC3w&RVnau;AT!cFe>GobaLINtrz&}Dr!L6XtEQI6g?@hOCx54<;=<QY$syh1xm34=
zq}gsO9q0U=w48q7R9BCa(q0MX;=T)Umw!G1saGwG|3wJsd;gV<Bqw}D#5?oVy3^@7
z5OO)W{zj2(umEwk57voTS?gE)e4?##l3$`D8q>w8x=)j`-0;gjA)Xc?*}4{K@zoXy
z*)j4D$ZrIKO8}u#`1k<`zjzQ`;lZp*cdURuk+H#%NDrba!^cRg^%c4<_9`1{ium_D
z7zrKk93p}y6TbK&Icw-eN6LcdnVCPauOtOk)EpRit~yT9W6pWC?9Krd+(qvv4kKZq
zhS{%n;?O)e5Q?{vPE@{)dNp!w#b_3q7FHQ}sUYe*-m!)WXX;XgH6EjIiE}{k&lFee
z`T&%1hnm2m1v^8B@@Jb=xN}DQE2(<jY9I@}O!(E5YECT~9%S+D){hm8haE5obE8+D
z9Avgx?=dDuR-81;luR&LeQ9c6>EIvU+brWxIJ;H4@=`7k@!5MxDw2L@lv+=Ss8G+{
z?uprSVP2u?XnkTB`9x;|ByhREd(57sZV3k729#@q#t{G?I^?w#nQA35A$KTYNn`c=
zhxl28tMSNQ(n(KRf#EHxd+k0H69FBCis-k3dw2R5G(!Ryd{dVTVoQUt41Y{tkxz*v
zP@L$a40Lt@Ai>Ji&N_omhR;;iP(9W`?sT(N9%ilNCVA&Y$3n*uF2y=X3+d{(qPXJF
z>k8(f*%pfPrW3hWO~-e!*xz4`4e>@o0IRkDQo@w7VGo6szgJkQU=)=IY>leY-}7cN
z2$TgEe@1Fb4M~&pdA0q?kM}FyAcGt@E#GUlZCYceOfAbNb4hOzp1au`WfqVT>q-9~
z90mdlk|Xmq@I}cSjq7WPYwKGu8Ex`28{#o;GZf-S-$m^D?A98piR+@-(+IScOh1RT
z^EI5aUME714I|8fe-+mMxp4^yMl6A2Y)s*b#e`57RMLL{%C(_4Z(uo1m{CsnE@^1A
z%3qZ%#iSZ({g#}pFUvO+LKaSzJnY;VQS^Za#)bp~G*@G9AhE|r_NCngJIWZEm=qam
z8&X|o-sxmP>7_|_%!QvZN*2eL);WG=Yf0Ty^C^;KqBk<dJ?a5a?8_EC#rm(9)Ak<%
zcXI^~vO{7FaN}~u-9P*GOS)I=qWE(()#%VI68kUq-W}#t5BH&M7A>XFvT5y++?`nK
zF-rDpXW*|a25H0C81wbRuR+lim%CC&D`+4vvv+>jtY#Zsii_7ZlaVDh3PCVkimW<g
zD&Hvn9dqJ9%BR>|3P-9+c}Od#q$I`h^s(_ldg_0~cZrAvR*+s^Sqh0c8;COBB>)Rk
znA<zQ^3p+ThGC>hvnV|@#8;jzw9?>`;_1vtb*S6~`;<gZ^V<FYxBzLAG3Y$%$NamG
zdV!;zUO-W2ck>q0e`y<F^7vqrmsM%*=fd|M0fCJa7JNVHsv}08ez}P`a*X_HpWp(i
zpyT_loNi@Z;-uq-f^YiPomn^V>F3O!E2<-7!b0G~S<vTM!DQ!sw?OJ+c?gY|5LC-j
zerLQ9cKK;sYr>gSctRvcCm(%>ExC~PC&5lpb>ZQP-k_zsatXl00UaO#$Y)%A8#vR+
z3iwNi-aic@I#zV;c5UhAEm%rQ-IIzwD-dO8;&q}<q%1cZGqAdOdsi4`V0Ho_3D8!-
z{@3zN765c*q(7|#JHq%EY=?gJXk1yMrDpMgu{xG%xl3d6a0!a-?DdMG&e>EFSQHUe
z$DnpigVmDG=NWASl@i5hWXT~%;K$0Cq}$Q!ySv4gsxHOHl-w`Z@l60W#a0FkfhuUJ
zxI881VFk^>7=1f7virhe`fm%S;lcTwa9FA3j4Y2j9d9sk!WE5H*JK+B7T5jfT9pdj
zl2j@Mcr-C`(^Bd-{@8odk~YV(1gj`7I4}VODKIN+5gN`;5|LPOIY6ENAzUg_lMjt`
zYM$L^t8e3liT>ITy(maYU$!!LXV6}zid%M&o20VjTx1y;UAtxBs91tBSmuW4qX)2{
zPF@f{l<n>fLj%MCk%I*obUid;@cA7C)Pq!-f6+B+tBIH@u}^Qw>XmGGz@`=gmeX@d
zOzg^9s;ujb*T7=N#G3oMi5=bEvy)|=il8qK$1=JUn{lT#W8pI<B+}Jp!9axq5CTqM
z?{C3wbr=#7s4}}#6!lkgd9NznjpA25H484Qq&!<z_6jpvm2{tt+6QBsWG~V&gUpMH
zH<H5diC<3W2=QQHs3%{0cgua_00>Cb094&H1a2oTss$Y(1M)6~Kc%b42|LQ)B}c^+
zj~abWF3}vzS0NcoNdQ3#0;KG6sUm5xBAFnX+G9c`>hphmlKFd-W+ox~AP=Gy5xInr
zHS9Edis~VGA%M-uMh2VX@s0{TT#mYk-UZkzP&TWkiB!UxXxQ0BkQL{1*V_L_h*4DA
z=hBddVy13IB_%|-0)j$Qo0~vwFQaW|mSwwj!E!o|(ql;CO(e8B3vAs<c-Yo`)9z*P
z#xc6oaETTkM2JQLPe#y_zg&kwn;0g8cvUvWO?z9RSjI?0Zi4fMS&OxvU??3GvKc(W
zqvHH(XU&r3p1gQX{X7RDYkY3M+C1zx%cgzHL+K$4a5%Q~bst+?BUk^=gIu_JxH3D(
zep<E$53R4LrwmnG+sPS>mW#=d`QzAU6+FIZU$(@VI@6;IMXP>_N1KY3a+|MhvF2w$
z8DnYfEf}8Jkambxh7}ypdmX)aP&VEMuFhHk*K)Q&Q$DP3c>vEd#ZmL8TT!9g^GDTZ
z=L1@o-y9i6c1BynI$HZxd^$_3J>yE4PFQb=*YnxJ1$(~K0Of1cc{qSF*L?*(pyh}!
zl}Z7Y-k~8TyvgJ6w^qu;p(>U{a!lmRdL_%nITXy;^qlNN>VD<<8_FGJFY9_0ziM@f
z@|){m&#o=Or8^FoR(!Poc`!_$0ZhdBN34`4pSD^OHo>TTwB@gMD$)bwE>kUM?;l?L
z^XsNhQJuWw&}B;+OA)<40^couv|gkC0@#_x>F;R)UfU0Y&*IY{*CE0_q~YC*7Lguu
zu9e~qXDaK0HZ2tQfV$vDPEuZwyXu_Ip;1w?eI^x!sX8$uW~OqK^5rB-;G|qoz6{h{
zk0x*j@P8U>ow7jz+m$B{XfV)Eh(&e~c@>Gj=h+D!+#pG<hT$9i$nh%VF3Hwv5bvu_
zv`MTqF<N?Z>iB?Nl$hW->CY%?qpDX0Ptd`#wo+S-9ze+>`ipF6=+O(1^a~(D7@SR7
zK~oY$^!DHD&|9r2UEZOKi&dWVoa56jl8dZph)>WSZt9QE6bq3Xurc2BTNb6$raan=
zr`K|JP;GkM3GDP&WWFWa0&rb8U}7MJ&P4QbogW}R7f066+45j_V6^snfuZ0ABGnj=
zMTy~+_OCt-Zh>xCEVKa<t6MyXYlgF)D5IQ_U0n~?z-yljlc5}HY4=Jx+7I+?Z4YoY
zt!3{}u)|awWV(U7=*{6<?v(c{KH=rITOTPV)`(}Yzx$l1Xtuhxl#PY&7W5g-&hTya
zov<~?BPmH2{T0EtNR&0Muhobc$G}xh05~RgF`50nOK909+BMWYCd^YP0mXD5zj}Lr
zh=2LSB5A!{G3-@TxvQ$Ddi04ZdB6qguePSRER;aPDA{zzsXaqR>4f!s>=FlaZH(Vo
z9>t(;qA-1NdsasNiv<TzL@6k+;=%nHKE|pLpGyj@J}_C*$P>Bsex(%mlfdlNh?O(t
z+)BA=F}T3v;O>qG<?|xs+sU-8qOrg}?GxbRfmnuxScrUR*$|nZM(xh9JZ>XqU1$H2
zehGiIIQaip7Et}RU#MBC_~=~YXi1fH`>=qc259N^j_k>;S3TSbmGBAKJVB23Efj_*
ztHh(JD`^m6x<C5(fFicFrU((pzSg#ieX-g>yL%UP?4Pb+@5y_r>#Q>!H`1Se)n95^
z5$!n~(+3$fScQ_&Z>vALYJQe;vUL6=mmZ?!^mDZH;6#Jyh{lsY_*S4B5XAvGB@{l!
zYIXMqUcSHwyb>-$9eSA76kbt=dVbxQWYa~Gt=L}H=GH+Ns;+o3B>uUym<MapbE15J
z{Vsu@&Ia{u|8*JA;Xo|_xP<g6TOY}G$a+2CQz>Seb)SjD94G0|Ht*UWg|D-CfDqub
z#>OA&B^_-=uDXbY%I%?G!pyMKQ(nfAjP@?l6uP|&4$T=xVU1kezY}X+cApwpvKstl
zuEI_J0=~Z~(b5y5G5Oxf(zG7JCMjm><Njpp=}zhg<06<S_no9<Wk{hzq`3fmy;`Ap
z*l9OBMWiOlTS4!ow@(auUAIo)?=h}8@~@W?WX}L?AM5IxIG;uGX}Ly*5EkH(YHF>q
zHM(vs#qnB}{E^*b!47>^I$1JyKh|l7Mi-LSb?OnrpCa?M4$M!X^c4OZabTRhl~?Yj
zv3E+5hL$f-uA|--89b7K+wl{xc+S|CI<g>XJMYV_aT9a=Z>4b^paMES;+FP0_>Kga
zE4yI)TU$PDgnkcrg*=02uix(WD|_qBH%^+KY6$8T=ob&AFk(ypMrN6uCPNk9pk_0N
z$;{*+H`bgO=Tk*|iraowT8zAVzlxkGpoiZ4v8cG})p$wQ7_68f0}w$3ZK717)kCME
z4vp4X9klLyKmmw#OW!pR*~5QMXe|neyHM3=YP!~?_mI@Hu%``9+Huuq&uNdCHp&y<
zja!?$>AoHtxujLeiTN4pYW}ZyGv=S)>T8ty$CDViHV`e%Jk}N{ITr6OOyOT;`L~V0
zflmAG;k39@BRj&!<lfbxhTunCI`M{>>Cq|-gv!@fm=F4Kdq}?x`Kf24OJ>A8nMy-p
zdG{7#_CNDl-H`Q{z_}!<@tYVc8!UwAYx1v~0pQ_&fvpkw+fO!kkD=gD5(YKAI+t~}
z3h+AE@t2p$*$Ft*bHqR%zcC6tfVnGc$T`F-AhG<yO8ai{R~xw$b38=npAxunKkfpn
z4{fbG_N^`W_*>2n^lI}R7!fG(Geu;>A)6D|rr7(ehccL&jlPhutc>-1eyRGcW(o(>
zWD=J}+9J;Y&kE1zJg$<KNm5eAV}GR{(!UX<{4ji&o(jx5TL}Io0Wd8D$c+Z4nQg@x
zA}r{ftBz5f!pGm<TtTniz60e&oOhohma4XHm~!hh;WmrRs%bCjZnb=`M=^`dFON*`
zB*nbV8LTmLG`~}w&JPoC`QBt@N|A41nB7KF(D2J(FdsOw`&ltQIXlP}zkgs97gV3N
zRm&ZH0Awy`A00op;0<M0`F@R_0uC|5Qy;%2LG$=z>gNu_X9`q1_oBk&iV8@h#}IV(
zF~Xj%{-yV+4)cgzDw}mrp@l1>q5H{!v|K^KP8$9DaNtTygS$-7iH<2fO7H|iSGR5d
zs=3g>)h7x)AQ!YN`o2~g##MTfoDwjw_J(hFvM@l`)qkiv`e9BZz%X*kD1@we28qRt
zh+r@^yFu~*?}&{&oAx*IXO{)wXC1y#=>@U{Ujc~J80n-<WQ`OP5LPm+<7i3V-kyHg
zCK(UFw5b*BK=5*@F7nkLf*AG{z_Y!8g&jkKSp}9o<7Y0u=_`ZcnFyAtoJ@drTlM0=
zKws}JMu|d@W<nwh8MrSJT+Fzs)1m}NtEL`3MKdTE`d*15_rD>-B49oZbe`8;G*@q2
zzy8~K+cyXji0MnG9K3RVM)INsir83JH!FWM@7iHu{nCh+GTD#uohlPvJ&jLou6e0n
zG|=y-;Bv%*h>tT_Utj>9e<H^RsvZycu{|f3(z5DTx7&ZFpO*xH(<tPf9e?Ut9%s)(
zSikg*OreG9<lU{EK>*OGZlG+A<akeiP@adD5#ub`>5@k5y3|NkADH~Nl-O2jQU`&f
zh-kepxJgeWe2qL%j*(%4lPYZlM8~HVwcaDT?E(g)$0#1!*wakCyg;D?bn&|$<LXi1
zyn@_R5<)q5<czM60}*G4x$?6tB@F6#M~;hZ8YG3p(?4Q*01CMMzp4*!S`X&xjwFW`
z1=5v<CejpaXcI;9a)nK)o38{vq)4YKQg850&D(bv*xG%Ba+1ziHICQ%n~7%9<l23(
zi;4|P?AdRv>;w-~0o3yZ01Yw)X{}LfZM^oPL=t89?!&I+$`059<5XgYWGJ()DiG@{
z{4A2$D$HDxcfTB(g-_K+%IW>|ip;bH(j~y>zl?ZMD_08zwuj{1o_Ps_p+!3yRITva
z@a_30-&ciSFwQPr>(g=aeRNebn&@wr;%?#!Robb{ohx$b;OsG7OY22<5pBlOQbu6h
z77$1s6c6G-;o$+Wld+Ar$K!_X&b-IQ1KTgcb#<!WB@>?|)kQR=`G&Zhy=p&3jau5M
zpmN2nS*P%imbT4FS{1Q$g?>-K1C}|D_ce-fqOlo*6ZH|PafpP<gdy3J`Bp<qUDAn$
zXYbgRrzm3NeToG0Q7u@1N&YQW>_>{e)he^#*!RU?6B<aAebo55x(9<i6A;9Lo&#h-
znJ-940#4yzRQ0E3ymEoC6*F)6rycM?A%>-8LXhKFa_5dky{teLqf3z&3%e@b=?S5U
zrvF&%2vYWVH}~k`mJy9v2V2;C!0)6+_`lCo48iG9{!K&QE-pD<&f%gpIqKDahY59F
zUTw%{logy?wz9UQFx@UqO3@zZ{c~G3y!M*Xpm4q8mZ+N<Axw7D9c7(j26(7kktyKp
zBKx<UN^P%){)B$^wZ0+P2fAlq9#tasoXn6<e~;Fb*&x*7@9BEaRVJ=OEx3rLMW$s>
zLXQQFIEN-Bg(>IfNgdmH7t}}^s0}Egs>^Wm?ms@Vo2_*J68h(flENB~*c8=Zx*13~
z7-W##YPQtazBC5$^mMtZ?f=4Vt?rIwqE_?uavLh3;$5bFslZh0Yg)_r&c4J#u4DqQ
z`YzCAWL?$J{i9Jh-9rAd$UX4CLAbyEuC~|H%GI3;{W#RWj~E`VDsL-qn<1G7ksKj?
zct`IpQTUG7lB<8FkDa8RsNOUF$^!i_w$U%Tj1k4zv~QA=F%$W3;*+?j=!k|Hu-_N7
z&v<*->nK>-UEIGBUK@;K#Ue^4B5Iw#mndME?O*S&XP5}6nd&@z2NRnt3Zwy_nrr+@
zxv3!3(y1{yNV1>%O=)QWU)&<Yi?mdGpfk8`6Y9F7tyB`Lqju>!c-z@U@AEXpeZ6Wj
zVf&(r#E4nsFl5$p_b!+mut!QV%c?KGi}70sL8u^y4)V;DYE%iTe_YTu<FC@VTd!<^
zf?Kt49U21hvF|jEP`v#m6qxdtc@>x~VoytVK{Pa2mK5=9N<f7tAjyf6Z8LV!viZx4
z!U|FWku(AYm`OZ_Dp<F$lg_0TJ@)3HhbOZ84NnpN!3VMAz7DWu{OoqCr9s3eJ?-jj
zujW*R&3Md%-EJi}-a>vAM&C#3P$38zB<mv;p`28Yn(8-slkmEP#ZU?Dr@d}g$2h->
zgFlyS2MEL%c!QRz_Sj2POm32T{42<}8<eVeVOEmZf}?%7%+(#yuVr8qfJb3sO=VPO
zFb4fWvQcx6p7P<9*5OO`r*B#`KJbZuljc7uWOUY<{(nS$bwHEf_dn`e5kV0UkPu{)
zFhaUP329Jjbcb|Hg8@h*T^mSC=jf7@8s+Hj?hzY<-vB?~-}!qx&w1`W_r&Ym=bVSB
zK)9akqHRO{8CYT?W-WWV<1M*0=Ie%d|Ldp3`JR4MIGYeP=zMk6s%?nBFSr8bXz)$5
zqx4vwGt8UK4{0F;z3y6p<r_K2eJl7hpe{1bZmE<;Pq|pO8`!}-)=9zn-IV3vSzb2c
z!OU{)QO&1l`ktdYSxm6_hz8x7?N4ok_0oS9p#ltA!khcs83J!z>eK}oQ-4iD)6H2W
zRoY$X^7P7$RhqLBbd<GR5-dvmRZ`w5TXY3q*1x>RUKPy?I@$%>&Hmz|-q6Fs+J8zo
zuhNRoi`9Z8ljBfzZCN}6_@+M~%WG`SP+|l`pj_c<naI(_e7tRghh3kyzu5<2S|lOu
zKAc4l*IBG?a)_UaMyTeG@|r)a?t01U?gl;jeg}&U+yB3s*!^#hvATYe%A?pDD?C#}
zUvdA=H^<F}4(JXP=Ur$64>X!X+65gn*QRTQK!3HZ{73{IO=#==KDal6v_9ysR7op5
zuCrF!SJ8kPYwZE_FPBZyFaj&QmH8}>BQ}oZfVXp;GODySR;pRtJRe|Leo(CcOfel^
zA@;o>*=9OdXXm~K-(Y5fpqPx*bY)B3=7Sx-?z1ppi}cLBX@TdKE6Vq=9B^LJwcIS~
zN6j3Z_{f@9C#hgrrphSVDU^e3QM4VSk)4!rMrm4Nu%d7uG_-X?x4AMIPuE9x+Z*20
z&4JspRSadjtm&-(h4~8Q|9E+2u<%<zB3*)4!b@BU6}Q5(i6gDgU18Q%l#y<Er0xho
z>-bGB1eGbzTc(qqL&ne_I)FRXUWy+IMkhUB9NZ_TDn3~bUVip#*L+*Jp3vN3qrWh`
z*YYU+rMIwv>xzz5|GiyrMTBh&^1nQ6Jq=g=JXjQeKVR6}4DHb(awQb1CO=98%6B$+
zf3P=fP2|(OjZ1a1TQzJX-kTI_UhCTrtOP>e(mRGL$5itbKGC>zxf%j)Z?kkS>;%8p
zRS^v&X~x=hZz_o4%a%A6FFF_PID2iJ3_s<$g9W4c-`?W(g_dZZc#|i~|AblzIHBho
z0I%T^_VxUQ*3FiErMnD8N~=~qgaiZyLb<zx(D!JV&>qW~zJ^^tH8$2h%bS1uSUP_2
zl}%8LT3N}m=P5zI)=ptTWq6$(EuGt^5W8)Fl8#57ulY1#-$p=cxtgM;$^d=(Iro91
z*IVj=WU(h$^GQEXhVd-j<CX80K5AR|@erdLrQ~^X+XiP5S{pB;_Ya)_Bzf7|5%snR
z0u?E3tL6^%V2y;Y6xlN!c^~dCO+H!Fd{sQt(luMEGO0|XPrACAHg4%RJt>NdHQ&cA
zD2t_Qy5v}RtWTTf@tp``w)mr9L7~%Lcpi-sTv2jqfihO1(Q6|_UQ1=2qxz69svOk^
zwH&+1b{)M1+~&LsoqF!oHX*lN$_*j0)XGDT>z8*(x<1QXluu-XIwgHqxDMH|TF#%I
zVDXJIgNQZNH^3Ds)y%lnBkb^j5+!SeH~DOqqwc}U-NH>zBE7d&3U}{5#=_c4$Tv08
zdv$H1DUDyZNU5<}d>+Y4F--sEHR;6T1BzVR8JwM#M_kpH&tKK8KLCYW<L?MTV2k4-
z^39eJai5h%_o|QVfU<vOR<ZW`-W~_s9IH}F|5?`_dYgG$yL-ERaSLY+)uj4th_NH9
zjw8Dc_!qUGqN`V>Xa2SMcny;cA;*|72SW~W7la?vkxkQ9d>V}lsxqlXE?zQ#)T>XK
z7eLD)=WP$-o~Cw3CzTol&nNZ#q1EgD9)~@w!<hH(HVS^B%b9*vfg}`L#x!M=+$Cb*
zA_{J=vwB!3YRVb4`%YcC!q-3AAc2LD;b@a&uz!>xFGhWHX<JC9`V-cc-Eh{N8Y4#x
zhxD&|TmE^OIm)dT6rxcW#06u9+V!yb3AgX)=Qfb2sd}v>imG<=t(x*A@tMtNmOf4>
z^-O1OfXi!8=Y2XRgts|g@T<T#Tr7$w#Y#Rar&>IJd&33`D^>Af<CZDiU+*R6b<I6`
zfVuf<tW51}LK0jI4&5ngJV54uR@fA+(=1$N&F1f~V};5!EJPukcIelOnyX_^>bq);
z+7@*--2U;y8g21^P0^cI$cQh?a-8o1L<$2$f?nzKoVJO>LHHzgu2D)_<0Zd~9}whr
z%j%~1m_{7VsECx$MkozG?KPOKX-iM4I(S~NBZtw0YqB+ZQtE&8v?5Ez7Wz85?NVQ5
zWuj&Y)H?hTs*r4)S?C~~y4U-Muw=*Pi+Y^D&Qi3u;YqVbwFvTb`U&__=24q;Q5Ubq
zdsGU0jO7S@7YdULT$850k|Z6WTtgmiJeAwBvwhqbM7+W9eJ#J>&6j#FWP7uu*v&Ok
zzHEj5gzGXC?~;g0{p}~kCrI7n4k?ya913^-fl0M6l=}ALSE!P}hB3>Qt`0h$GheQI
zdG5#fXp%s{#3X~h%Hxb+H6Kk|-cgEg1rPp)=#$PgIMfoBM%3r6*Zqy_a{8FO<4sC-
z-JRmvb`91mdHjh9XOeXF)N$Y^RQ(l_1Mkbse@1ED5FXL5E|8E<TE<N28#fwCG`tlv
zHa{rRvhz&_lP+9SF5~f!kb-DcoSJw(p}>QDcJjtF#P4@ss%9#*(x$a~;)-KT1Sb6&
z>o7wMoLkTSPrviMi3;;8)HAs$+_p!(INY}WlzNYo<?RDEdrvy`8w=|Y|H&79(QkMQ
zIxP{jdIawWN4glTUE?Acppxsp*XJ=NmoE_}o>GcCk8Mli^?j!CG6Y9db^_rz;n}dF
zbQ!3Q`nf=HwK;?H@>`i1y`PbuF>$)}lPR|x0&d=#`FDO%6(nwQU#DJ3-6zrx{#$Nu
z)%MuNj@>5pG!JR$Y(*IJv^E=?W@D1QYX165XG|h!?IhwCq?5!|<zQ~fYtEp8ts@W7
z+Wf7FFE+f!N3IJ^P^iY|P1}E^^I3JLy79j{9|yAD%D>5OQyyag|JxS;2kOc!(iw<(
zCm?>zJ%8Uupb8w8o1_A3yjQK!flg}0*{T{AKVbL(oU?))XkKa0m{~#^e=6JK95=+)
z|C|gH=e~Ul%Rkm_ei9;3@@e1;3Ri1m^BfOZwH2LUozMa=Hnur7Ur^+I(fkpmMENIo
zI=Kz6|Mb}cZ1;7=2(-V^y%bt{A;9zdaDy)bMQ=_*NRV#^D$cpeIhR$bH+oD|n^+)$
zsL`+=WgI=h8@X_DTnZ|#p(<(jJlwCnc=5yaRudhA>bGJGe3~i8h`*PTk@Bj3<X3lX
zmBUfDB`H>BTGVD%TH}6jrLh6}tCRPxaKzr?c%^uWNjX)v>KI3NZ6BsS7*6z0tFe@H
zQb`1Xl)MO)IE(C_x)+V*YIpb<%w3(3!%#s>$HvND_1WSX-&xKz`qQgTDiG7pO>o0<
zeecI-u0m})={N0uG1}2X7QOmXkAa4O05Ei4$NWS-(}bp4;|l^e!$XPAOoU37dM~v~
zEpi!Jpk4iOuJSiy-@7XdhyZEBRLv*Z-n7VD6TBZbr4B=Cu{BRC3mEHp5vNw1)NFQb
zgV>#2zjEidBfrL)3+PdNzb6k)`aAx(FQ0#!MP$r?m#b1+uR)<om^+V(3CYmAcSp3d
z|7NA;hg+!TT|@MKN_YXyhdg+8?l6R`!9z=pkWm9Ia0<#Qyze@Bu0tHh(W%vH*#^Xp
z*1zKm0w&duENB2uMUVDBfJoh*ytA6K4Invf64$ypyjb(x%W88uTO5u&7a(sdvxCN;
z^jW4)uF|=A^XlT(Ul(HE<%&8Z9wRJ{XMPY`7rM@(K-a3!D%slCDoJSF8IG9h6;fee
z@9;o8Pirzv;>P%oYihCl6Fe-L`O<7|@<cymCMi#@`4VW}NM2XR*=}rbqUZ=JGGYkH
z<r0D<`LwFL;Z7tjd8xTB3RdE4nE0{7aZ7hzPM+^Jy!VVQ4f%QN&q|eipE&p!RoLya
zFh6kCeN_bF{{F4CkLl(2BlVZ7@4h5S`X{#Tnz)*)Ymh{_r%zJ#G2I>OdMy>ctFiM9
zS4rm(6I)~Gv-(hDNh$SN<;sh$P5F2x^Y^RyyFKD`l&6nlg77N{hnc>+j(8?Vk?#PX
zrPu`<Oo10!V~Pp8;$RucE<C5i_3*2t8%9`#IO2PPE0+0Ddk^%yDy%@nj~bp0DB2co
z){f4-L?@WYkx)k>7}c1nc~xsBBPnS)KWzK0h^ela83Tx#-Pa(Psh`r0+}4-;x9s@S
zg`pTHW-OwP&0vQ|A=k~%@~#-8g6AuPd0G`e9De-=((wwGkSM4j5v*#I6X5^Prny~^
zttRIfr(II%G3n|%7csN{&#hJ%uKw*)c_{Iu=6rT3odASg{dcv85j1SFYi1n3z{;hg
zov`j*SB^$m7)xvP=E&ynM9twge^0s$g8$tGNFCmpX~_+&HCa5!^Sz0_t|cACySAJq
z(As<gIWPC6CWGQp0iZ5gf9sB-dY<M=hnj+hkXHfY4~<EA>r??&e{&HDe$jr2kXyvQ
z4>d^pykRx+#)M%~hIBUwo^!p6yktHXch{h{{R+z_$g1&4%~nw<6omLRnj1J~Ibx6a
zT0oIShk;zKsWf){ejRzQj!u~ZX4cdOs9zvoQJGLyHO#xYz(q9=qQlcOd^(bunCu~-
z*G<QSBR|$n8cNMSO(p5AF>q@-*HpEcih!N<_4Th_Qp@VIXJ`oUN5A`P+pY)|N>nEw
zr2qv4Ptouw;wuS-q65SMMNY5ttQ@{+0j`i>k24QxvGYNlbJ9@z^*OzTwHu4xVwUmE
z&U44$<vnWI)R2nslYvxPUU>3~3%}YoDcc2NSFqIwXmW+xmMO8PBq%(6gpvVnSce&7
zNJ0Z}i|~@nezO(x`jGYJ1-U6pa5Q=v|FlROA1h5hV;d1;cmdi<NLn?6#rm3X+bN-T
z8UhRYbnHXmlWPUyd^r76jk;@X7A8rKOEVpe1NEOgs_o}a<RQwwz#E1&3aPJfVOpyi
z^--76o0!(4YeaVBu9AP@x^kNni9vPPcY=#?oGHVf6|eW@W74QeU+}25^H#e9Ro-T)
zjxqlJ*I~@8Vh2zSr$EPi-1KdDlgfh|(s;?LZ2w#dm_2ruxR#)G`L~i3H2lmUzeIKQ
zZ&^}M))0yr;Y~tV42ichz=ek!DnRid`JJY0+Q4-Wvgf#2H#W`i%SwWviPW)hP9wIa
z8j~jVadVe&PawQu?lU~8KiSq3RAOSMI~=qWe$cGK8mXj}Y-)6$A8t<?t3RT%6O+Jn
zwK<hhcWWV}%Y~#--0hPwTsz(Gp0!z<=((VuIWaGlBXd3UyR7ZNl<MfTsf1hxopAXz
zdl~(-%vF6B|LfjGSXg`Alt}O=q+&s`&^Hbe;ei-=U`-V;e@9eJtv4G&o+OB;Aa{Sc
z)5?P9Z}o(#c79~OiU1KR`!6u*?sSq&!W?>wy^GxZh7~{kj`>jd<v@5*b9l_}UbOv;
zNOG-QhTiunV74kPFiqQfOt$DZG0!XjAjVb$#NiVaF8q4Jr~CfO)_+(vJWrZ+Gvnc{
zy2~e%8c&%mco+a4c;z%M^Dq1zOtNBcILY5Q257_y=w;gh5Gb|!uo1i2(b+|FYRjY%
z@-3V6ySM*#NF`HI^=tGv3K8DWcBL$6+~Eb4&qr$vnibo{iL$P)ZAuy$n@8O7q7VHU
z95IfPGk~9aa>U-WKF0dIsaSgByuhn;`XVSdCHef-0L(~Xp5eM3=Z4^cYO6dhP*G~O
zCy>XNL}MgM+%7G~Pe@|B0ppG@2X@Aez`|W@sp7YiBv6nrmZ&z(H^RbyL&eMTah*+o
zuVWr2sgbWDTQVG`)9A~ZQYN(>S$(^#M^20pc;%DCgQ5pid1!c<*t-8scPotPrVWm9
z+ZqYTA06Cbl28D9DsOc3mrVkZ@<w``#WT#3`sNyD`Wni=!@WY+TNDXF@6!@QTBN^D
z|8pSbdc=m%H%aQGAC-<m1#{7a*{T#3k=hn&LmCO;0RrCOd<uC=NPBCvwir>2f4UsR
z`sawoENrj#!@Mnc`jXIy_-22VWWAaQz^Pzwm;yF`u|>{gzWFM1orc#ZiZ<^&ZCut(
zr$(d1tqo0jLvw_9tJAvs*k7$se^vFQ@%Pp5O!X*@(K;L8lhBbLquOc1=v&V&{$^c|
zainlD9}R^+qqU;f-{sHQdyn`wS|2c#ZDQ%-u0;L9?q@DtHq}ts69sW&SpRdn8)2~c
z2aHpgsoAA$ch#G#XmgZ{plU!wgSJ>oeT9>2wTqtBHl>C{#iVOrdTF2UeHUicwDGU;
zL%<r86DI4uq1>JyrR`Lzt<V?HGJ5AC-;`0hF<2OTvTd=N!TMlzK8H%Mgj7O7j!rAo
zRL3XmsUzOH!a~_hgMiHK|FJ@7;;jgrEaGhnRf<2&YvlS1+D>lwnr^O4INZ&fkn<F9
zv9)wrhteB~afF_IkX>XinY1bTxO4Q?bKCOSmk*cMO$D(&n}P(kENU+fHQ%h{FF9w*
zq(s0`Vq8%U=;P5(#(IbFGOey1^RUN{EAyY|HVIS)J(UF~Wsy7TQHsjb-t>3Gdh->7
zwZ?X3F)4s~M<1xn85QLGH%6`tFaEe<wDAfq*Wl695^eVjw-=eCz|dzH?H*rfioL%m
zSr^?9vVN;04y#VGCT>#0hvp(@)fGxQ_m%SwUv;$F@PP6lz9Y{Ki(eG*;<>p_FKPpe
zwGpSnZeNsoa|wKIHW3S^Tg<l{va6$>!W;VpzF6F>f<02BUQN;ECQ#)$ikn5ME5rP9
zORwFjNyw1q^wx72dv3AEOQcnSjWdo#awH#1gapSHtPYk%#r>L=SLv8H4-7xoDhX7o
zmO~c~Ut|@p46~-Q6?uwNugbiAmUpX=qYthf=?AMKg-cf}Z{jDv${JGVcywR9H_}9W
ziHPwIkoj}!XlM7T*zak-Y%@eLQ$T;4O_!bJz7fUE4jS5q$$YHsV~)+Km4XxGxcdiK
zr6;K96gmLZtADyHicC5I@dkh^<;+i1(E)x_g;wN*w>z(ECD0K!KvNbX12>h+Pt_zG
zl|czl4b_AQk-T<0`9gvyj(~<w$b?U)z~moSUYxU;Z@FOxB|n@y4K6xgy5%wN?^Nu`
z`<=CxMw55g#!5e1wQTbD6xGhulR6dlld90V3_BUb1q<}9tE<Hl(SfJe+me5Ooi86&
zEEV2<Br4+Z+)u5bh%li4x1^r>^t-64be{&t%LWuT(y$wh+ESL4FBzM7lAJVl;b@Iw
zxp}T8SNn`>4_tTl-NNV=tX4O&-6~~2!*qQ8VNs-N!INqCgv~Ft%<Ns>?rSi}ed<PL
z%ax;RZ0m-U{*Zb~+>P_}hR>u)>;YXr(V|s$mRFN@Vmy2a_4m!Z#)kuL0HNz&TgT*n
zkjxJ~%8;?#B#K%+uH2Mq2uBR~);QEpVCGahEV=iz^jG?bPS?2t8#`lZZ=Rs3uy?1^
zX?-M~h=3q>R6}p0dg4ec9}aU?w)2~iDb2X+hT^mWPYZ@G6%+#R%+<N}ejj)yJ@!M2
zA}u>+Kg#aw_>JM+-@djh)St5}!nDQ43wJx;Pudx0m*mY&uxF*Jn%M23c7!?T_6Ez7
zb+^Kn=m$)MK6RduR+WfjuIOD8|Ks!t=d}}U<-dz&Jbru-vbmMlGKrhcVJ_Cds7c}%
zxH<5HW9!p5^P7f85ZJN1TpoYGIIYyEPPJY3nx*i#Y<|}bAFR^PC0H?MpL+C`e3GLQ
z0|fJH0OEm?1OM6Suenj+X2(v;3?C@L*W|P}`=Bpj$ld_euP$s5kfTUC5s9zQ^HIK9
z9~AH1>mHWZ*;%$@Go2o>*6L`_^7|jePt2B>J9CWW!oR$Ox6Hm<Um5=*pMNBzq1|=)
z7ydoi({CfHp-HK})y896hi7qD*6zmMV3AH1JB<!FohQ9lQK$7x!l3qp=n(Szm>aj$
z7S<zCt%oaWu{-2(S;GbEyCdrDicHl_#-93ZYnjk5CuHvGU!3*N-Dc53ktSU?DNhU6
zR`3nKfJdbdxdO~JGqws4A}uP7zX)wwIC!{1^&j--hxE~OYM}gTh3MS8`{B78hG6Jn
z34RhTz>fKTn$?V}e&Noxr>ke=tv$igPyKZHhzqJgRN%q{B@KVA?H5&E{?u_C(MuOy
zOt`R#hjyd{3FUs$$?xWN7I7TdVDS0tt0vuOn&d@=2z+%j(gV}~wW?uK0tmIOf?w#H
z=h;40O00FpwzFn;)ZXZ0>XKUvqa6Zubc`cK3*WsykNh-E{1t!X&o5lS)>nVwl6bGb
zu0vfyw^1M4okj#{!B1r!SRWKpgCH4Dpaam{Q+>V+d?r^(NWr0MA+CW6LDWa@zKC)C
z^^}joDuAXnT+l)IS)}X0YyGSjZmQ0Ood+(f=~6Qi!0uktC69lvnm~M=OC1E1^l5lG
zjnpmuO%Z75AmnsVzle(kJ%;yoG%>j}4#fG37yo$jC$Fwoy+^S=isI;pN^>Et#oYPi
zOkzUXu2<`EiYWO8<|}^;%^$a8ZBMC|J<3q8O&H0U)<l~TF8nZ-5aE~9vb3Q$m#v8W
z`+071>-e`CWYrp`J_#?Vs1=MtQ0A(ygJWF6L>iIW+H50$e|B2fGP|<)Ii_cD#%FIj
z0XVrRinJAOyxd8m)9eQdswWXCcq{kU#;L=yto#?beNR8UmctVDO5dk}+v>O8NRraF
z`-a<FWy^N$8{znAUbu`{_dOO3)O7(dKdSeT$Xw%x%7}{+8y7!nwyJRG$&A)eiBaRx
zHCRL}1)%p04Xom|y;%Ix=Uf%0Z4PyJo|5FT`sfdFu6KBS#t-<HB6m47FldTCpuI<}
zPUSWmDD|h0X}^4S16X$DqzmZRWxwkT6-aC?Un%{p4gY4M>q=wi{86N6v%#{KC!0YN
z5zU>aq3cpeKiFjGmBlvbA9U*za}ARQr$n)VX_1VPkUZl%{I2==o;<nPJzzl&=gpbE
zMIz^4G+q4-t%L)kZjX2ttSIa=qvEVCDcLiQu{H~9l94s?KUE*-=ZM_8s}_&Xip`9%
zC_9b3E@Gkz|4o~x<t5q#is~Nx#EwiP=4cl~4G37#CX~3RYoqt<4t&)>WKPD<-Fn2{
z#JIG|doC}=rTP|0(`3w=i|M7`-Ju6G|K<1B1OR640#`<!2BITotlUZsj<yRLrtyA3
z$GsDaSG8Ys=>!;MtT3GF*H}vUT`bIMT@O6R5IDpG<xZhRy5UCeG>nd8DpHQu9HD<i
zuRT-{H*!unD<c%lq~RgkTD&-^W@unKn(|%sj@BlheN()-k0xR~pOV~~-57rA*8FLw
zkoxxQDs^y{k!-lBi{oRO`Vr=6qru{ZrTVsg{n=fFZkMAHmg6nGb)J;c*dTkyhr^!z
z&^qS|wE9x!RKZWQWX7i+h}#7nd1j>2p8So3?(sX!8}jJ8@dV5*A2jhG+QyDnZp0zg
z`tW4A{Omt@Z!7Z|K@zbtAm;)GO}HgI!Ag}Qo7|Z)i4OVBG9)@D;my`_kA+A75LbV;
z!2%PPdM2DN<r9wiO-Z1BmXOe&6uI*7RDu5Eq9ToxH2Q-!Nvj=j5@IKRx*#o6?hk@+
zzoC`sfA9_$TM70|e%6+Wt%zPu$Dcae3Vi`R_!lYluq8@^cz4z@ix+tZ@=y~dUyxAL
z$ViTZu3x(ZBSjHqyvR)w-cq)4zwg&pYLzge+$k>%D9M8BHdWq}3Kw6uYO;qejLn5i
zI@WPaznW1ajaBuv6ArYC;<3kZK_M*P7?Is9iPBw6)T7Xo*7PD?Z7XKv(aM_+kX|8z
zhL<>+o+oOTa=4&^m5<Z4t9LbS<IBZ#j#(h{KePIN^R6BN24w*(OtvnaOi1QEEjU4L
z`hp6p9(7fWoGduRqPrYLoaGx>)oTUlEC~ED7g4T>|7*kMjDn<^lqQXnc#bt|rCbGc
zw;!S2*B`T(#DNzo6X#x_)r@4@V0M+v|0~?A@h=Udxv4tmg%dkduF6Yt=m_SK$ad*#
zWX<k*v(~8|e;wI8HCEyBS8oKp>U(P}axYKY>4p8_b!iT*SJLvosDq9Ex(Za#*nsFu
zF8@Wu;oD^k`VG%rbazUgmk&(gQ!uL1pg8F;BrFc8V*&K3C$Ip_KhV!jzR6BZ^(g9?
z=kcSweGRbgtVbn*9wcZeGs0Wmf&o;dt7MO2zaW`GYMWbjj7|cf$;lM>^Ukii5B2PM
zArv{UW!)8jT$gV!#Fnv(nPW7v?VmW(V{TBbXtprvKkNAu9-3Tx-jsD{?^#gC96?Y_
z?5%Z05&~P8xvsOF*NX`jdf$c=H9rp{?sp*Iz0t<jMO^A$3HBz#C8G6KM2eObW&TC2
zRtAnd4-!WrmXF^wvGonJDBprMx|-MZ3J)QrkY7CgNPdD~c9cfI_%jugVq0C%4$>Cy
z$q8cSx$ROvKX-!)@shicENSjm&@0xqe@}IP>N%FDeYePBKcBvnr^&(En2K1gD8Hsa
z!r2v=@Aq5f@$(ZM_a*GCnI;;#&@A(z1Ih@Wf?%mEo<B8HMLN|Np;OiN>~6QA1C}l`
zgSt%tnKVQsRShq$bTSDp{*mX$FO7Sv4#ss##*AyFX960LOV&6RGGXJFnXO{*E}WQ$
zs3qJPOr(};K<zV<aJv`#3f-zNs>p@al*<>OlU~3w`?x$;+jy(N4{)O7#g7a5C2@ag
zIpJf11zt!ehfNl}9Y91{HwWVYob4j#d6>#=L<APNE~u4$9e2wnY{U{=NOVXF>h|xi
zT^#<Exer7^d)4(o>W)dlN#P}<A^v_cZcZok#w5ley{Yg|CUT5KAJiYkOWilrJA<5F
z&+Ed3SY)0VU_^zkZ{Vw9Q4QA#PgLGyVkWacp#XI<{mM8pZ1%ZHk|rcBo}=Q-K!t)u
zZt2JI<@{MUfCFEC{U^P6pB;>^iXV-v{vR%%`hww;fqAfPybsJYBs5ZFmHB0EJNZ@(
zb6!aMP($B~^CXq_Vut^6k(}9XF7%k;jiJdMbO%v_z!rH19aF;_p*~xD4<_T}(TNDp
z^(Nz`;(10QJeDAWI%cLJ{QmnL%@C5Mh>@WqUR`&F#^#aIOj(d|AjuP81w3ODNw@en
zqz<?0?AF|WCh2_HQ7fLuR$!d{lt2LIo3GaWmCEd~0iH*$I@I6k%|>f-v{)lf5*$B1
zeK98feRY^A6hzHH<Ce=_U;yDJ+W!z*_c7>J6)dFqejk>SogFWWjs)&N9b2N(PIc%t
z7#NwV18K9Gj>!@`*yR}FqD-7WY9xGr(R5IqFHFh);c+h9#)x1zk{AFLFnx5JPPLo|
z)YK~livKDUWXpxrs`t>V2z_o#pZt+E-Yx)j&e?R)$e!o7&#P0naid4tDX25!ugtou
zYg@jcsw%@i8=M6}N{Rk~`op0y!HXmY=5hW7di7Rqw$ouLPMjUp;t$LTHJB3Hq!e_i
z*L1AY=(ia;I_lxt?{Wuq^qx}tOKswut(RWj8rXTQAECcEt&trg3-JYmWU~t0@defw
z%w`&96PlEE_{U}d4lCwpwzK?v=N-XfK$%sgt5pO@`S!qRM$g_0TN%t{Eg{$P&;?co
znrxr$b}qr&Ga{(^XzmfI*5#*`6(}}B0|xTmgQ*yIPUFtBJR2+g%_g1e-cZNE>MW%y
z(_;MDv~Kp^K@M|%yU*rYRV;Ger7FbfL{tQkdsGZf3J^z0%&k7pQT<hnuLEc_OSCRY
z3YK!&E$$@TdZNo||77?>miN|DvFLD6`wb^7hqq)ZBQ6vL!DvAfh*}<|6a!n^)BqSY
z45gPPEj_Z%KTYFR$bl2q6;J%PMQ1nHw6nyviTP0Cni3*|QSJqgil2Z*zeY39ZgOvJ
z+Iuu<uo!ukCJ#^L!}Fn|mPS0e^?5S-a9>vn)*Rx%f4-w;IV_LZv;Gv3BRQFfuYg$B
z2|o+B4{E<0wk-b8n8XFO{!^qmbyi+xTXRtPYW5Z!xL;mya|%5&*`_ufiSujgE`W|d
zK4fya6nv;;XOUm}RlK4CoKum;N>KYxqfARPE|g-@wqTe+e|z;7R5`k*SUSp-%l*EZ
zcbzXwm%viZPE{H>j6IT2Hsu`F<tSeIbPQM@KCZiGr%nqsYEwveCPn4Rd@ues$_hdJ
zrbT>u_s`wVXK+bwF9zypWV*E_8t4(&4T*q92$V#?I*bMVjSD6<O;I&7&$MM_r`N13
zAy3zv`t!1#X@9fLO_33s+$`Sb-rr|*-E_K-?>%Ymdd-qmZY{mG7Qrr*{4O-8pd>I}
z05=_Bv4L$xiPK#ROx>b+cN9|H`^=SsHtOc@SQ@z3g$G8!TzyZMp-POq1Q8IBpI}Qd
zG+KFR_o$yxN1$ud&X(0hXwgZ8*cuU2>u5BEqiVg@ikZ5Nq0jJEO!chCb*^CiFuzu-
zI?7j(zqTr?)|ty8*&s{4OUb`>v^jrB)_OMdB!M&ct~Z?}SE*fWz(4fRq5JGn>F(dY
zG8~PEt<dPgUx>j287uF&*HJOd2gnhKs6=~vs`iV$z(_Nn@37K-NkEr!3)87_9@ov&
zTe1_n;632G1++8(`Lc;v{s@r_iASz8y-@|vDZQ++SBIZ5GSZKxwQ~ARR4C8eygK=t
zY``aqvwS^T3M0J5TP5hHet@LXuWBCe6`i@+M#o0J={_V{-~NX!o+sLOcFzL+c6868
zQFsggP@f(5YFTTRuTejKjbT7B)y!jHxt1d^s9iuOzKTWHQcr8L+(pW$H;GkF=UEkt
z&4=-gzr<!*ecLwLF!L1`4a`Jr4rqlI2bEaU)qH3g+LnWgplo51c_;3FwwNp3%fLu%
z-?FzrF5iE&r*UB)G<(@!&eDaQ*=^dx(0j<z>jdMBS<{MlG%pwCW8m_zE1xzEtYGPN
z=GBTvjf8bO!OB^BgZ^l36%y-A4hKU=<1axVZAT5ct&6DgN?7f%pibSepoOhg2y{``
z&-pBT?`qY{@8Bw7DN06@yq_}gx>-Dibl+ocg2bYdt#mIGMr%R(SLOnc_)*7rG7?@%
zUz$qOMM^SSaR7jh4gd@0P*?<Wb@E$;&kX|Ub%2<u>j1!FA(1tt0ss?O6H*8zW&|wz
zA#8Ke8J25nTml4+u=sdL!#=RY?*b%d)JAqLJ={DbwAWCvDpn6YZxg#{tML8rMht%9
zMBhp!0fJyP3df?s(Kz7JP|(El7!Di(M%cqpXI`#tu!*_F<FePam!qR`C4MIED^~Uv
z6@1g29_(8yU@{UC1_B^km<S=G3dxEMW(O*yBj26wMN$ht7n^h*#c&DcXB6EN1Ok@*
z!6t+R0LO|Am!lrIN_#uH9U$HwAM}g7$b|{LE-fawCH>iXr%UYe;9r76*_CufU0Xft
zxwR&CB|y-4&`Du|qT7l>IZ8EcGK*{Y`_PR2sQK|}LV%+W7EH8x5LeRp3Ej_!0+qa<
z<w_!0^MAF4I1CT>ElF7MFi%u8Pi)IEUIV+1YHuOAw>~s0r=)yK&~NDMObC$n!awml
zzsz)-a}7AE1%YcmgK-TkIyGq+>6#cxIEcs=#m>Hooef3$(gD8vRIJ_Y%0JT*`x880
z&o9Py+I$O#Yo>!2ZD`jLUZDD{q{f4tO_P#dXc?31HlOtPo#LZ}ro_EV#XKud-JQLh
z2lo)z-+W8PFaioM<-;q8I4;c>i5_$f$&rP|Y}g1w`WRxmZFnj0czNd<c)XW{K5_c)
zuU$D_Wkz;rm1#(}YdgV8pq~J+xl-o4V@*kzc(w36a_`r%;Lg!i<x$~P{a{5h=x|Y?
zDRjgk7<74~bcMQ9v~*lJF|+^@$Hj5NsQ$$EM<00IFIPZUD8J~_!$?u&ugXu(&d&Ul
zf}|k!&>(&S##Zq~w?pz~QhvKTCk0@iXauSD8rWG%OW61DY~E0^wZsQ)-BvxzOEKl;
z=8MtQz0{S9k_dF40j50xd)n6z=&zwI1IfGoZ*Ok`VRmm$T-uDrh>)->BG_MET0FLF
za8#Z>iG?T~jsD;_=*-)pxz=W@6)W{Y(7Ja5vl0O+oJ5$OB_HBFQr8;66F=;eR>00M
zZ3+!(9U-c4TTAK8q5W*q6~?P>ZN_33SP1^aC=L!L#lPrlN6;wg(^`VBT%xGX+#~Y~
zk}agJlG4uG!0k9!Y$RI^YhMj-lbwP%6gQbRJ4%=dHW5unOVAS_qiNbueR?*u1OydN
zBWK;-Wp4Z)K{H0ChV`qmbxdS{74$y5*NU#_9Q()=|1m&3#=;!9+@7SL=9!epvUkeF
z718fd<FSNP-0JBz6<)XRYpU6jrmt1|uZpek^GR89+l-VT=3)}rnwZ}DSsi~575jSe
ziL&AEdxe|zA1}VFFBSM4pqj5xp<+lnvNPceo$G0qn4vm<+8!DjXwd`2JpROw;>6H&
z>oRCD6tkoW`ye+g(pEh7R{K-N(&|rILHd8jW6e0cJYPe?PWQx~i!|(+2OOyzG)s(~
z{wAc>2nZ*`!*1N!DWc%x<qeD_Gf#acrA30mMrD5c@S(4&s@iKbUg|AOkkPmZ8V@G2
zmi3oF@QLuSt{b>4i2qs46*)OA&lmHLGu@ySQ4oqq9j2Nm5@oy*Qum=RzJm{Kk#iNx
zL{NI4S^MIjU?6U@@%d1u^j`DT>@ExjwH{0Ly99zt^d}msoU{Fovd5Yiz(GF_q7t;)
zIbw*U#k12~C1GyuPOx|>0Z4ym=1`;8>B$Mzu83!4V`F1|{Z^rC$6t&Yrni=okz<4j
zf})8D4r#{S;1!;(7{GumN>=i%T1K|cd{sgfZ^Rk9{almJYT1O?8_!giA8dw>Q_YE|
zdX>$pS9R$A)HqlgrmrMS;Obu@(d+7a9ALNxuAtAAZRnI)J-J*xk+=7r(z5OyjyJQk
z#rOhj<;OA38datvHg-06*x$m#fBziYI`ypWE*I`Cs;H{O_$70UFG^9$S?YG@rcz`W
z>2|O5D-{EpV_NQ;S@sTV3;j7{zd97F&Da<ECL2^pTm}=|(tU-N3))U6b4l>%)l${9
zY)*+ti@}@rtvbPRv5R)FU{SDl^(Fm_R9cf#L?e&m-)wcs4-8)B@mI3>Q2F}bEdNi|
zNZJtZuxA8LqZ1k2Nk1IvY!n!xwYGNADSkePqCI=v2@!t&eX?<FYslXBIM27JCxhWb
z`Ql|SD#dyQ952PUXrVlvx^pu#5QUAIw75vB$-%Q8K?_-b@X^jssUQW`!@6RcVp0y@
z^{?ql1{UWE(vA(%dQR}u$@n+y71%Xsd&>9=lpy0({!KtQpA?t-nyh*(T5~I;RUjd$
z&$P3g$Rer#c-{~>%RU}oa*DcGED%Z8-!SD(iIB#`2K>`cNzJJOS_-l>x0mccJgXS0
z0V`E#l`XlClzE*6iCuYj0{EI$`plbF;+!ME&Kfd>{A-0~bH66l2D~jR3o;#^yr@5!
z)oc<ip>@fe_g0F(Ej#KyNyp``s7ci9*t_#7BCH}}!ZeA?CQN~`nB^A>g!TNJ+YY-&
z>vm#N|4e^T_?rDHMcb@H<{0%cwuE`PMk0&jyX|q)n4y|P;*su;yvd@-!;!^}CMfT~
zue4K78%_e+2yFDhtb`7%J?coY6if_+#jyZj>hfv9;weR=)&7+Z0+polB_|z=Y=hE1
z4fk_d{gm~t?60n8_F!Q##%_t*hO|_%;89qx=(Hsfn}l&FWhE+w^BbFl(U`Z{Na0n)
zc3dt=6V|Cj8N{)ONB9R9l{^#z<g^Mj7mP)*%1hUFckoyFjz>?-cpy9Ugn)=FLr3vN
zxwT<ur^&P48Fj-KO2esr$MpRZJF*s0+^Zt85}O6w_FOy05FsZDpA<na)r~dX%cYO7
zQ}`JhiNUxQrwE*Wu=hf3y-Q~wG<dE@Y2|3<evY~k_)YG#G9e+3iB~|owsq(*8AeJ8
z(+XiOW4yR*)<=W{3>J7q^<j`7Pf@kfeE`$M4sBUCT64gsWywD{-xV7Hqgpx-wU+$B
zMgXRw9gD_q-`(^$j(|VWlyr`C#vQU+@sh(IQPbr2re6q5VpB-NUO!-WkG_wseD(v9
zv_DQ=HYs+*h3C~PY_!yIaCt1)cGP_ZxDm|o3pl7oTa_}TK!v1rTcI;>e0<of&vg9R
zNZ#`ksDUx>Xe_`cC>T;|beInE?f_i`>H&BoIs_cWmD-VIa&#+&+p-#^uTxTKtXWSz
zm$1D|<r$TNz^;od0sspLJ1wfQy>8bl>EupYjzmGwT4`U+D%+rS#m~l3PU3mzGrpTF
z#(`#e*&4e2{Urfz8An8r)F17#);{Axj(6jIohF;7oF;Mr1}992Vb0J-XI#bGbZFgt
zaJCeA;(N}KGI*Ml7#v>etkHB5d3kV|VBqbzrX;||Qd|CtYd5Y>K(*VnT`@NRqV#7^
z;!{Ms009XD2?1y4!>F?mSFqmn&^>atP=wnTQJr5{H=ZAy|NaicBav*ntc90qdT1H_
z3@5>U+4kpv)jkJH*6tIK{@LUl>NmpPdkI+5EHFNK9(uK7AnLy7!!*LGl?eVbj|?BX
znw^`QoSpUBpAR*-SiHpEyIO?!Sz7>>3ppg|U~v_)TF>ZUUAiG~OA-T!d72Nze-~~o
z(;Ql0d&Jw5+D1N;-tRxfNNGX}1pim}=AT@`MT}1}LlYB|wkA|sH$PUHEqDrq($bVm
z+JIyBuGqyq(R@wz<4=d&g(o~Vve*3fzopC}b7)fg8Jf>BuYA1szLZX1%%1x5_j-a-
z>&wo!>e;=I!leyny&O=C^fBGyjpHzLx(KG61MZ~m=GR~<8JP=bl`+bBb*-EsHK8O*
zrb?HpT<yb)kxvcre}LW%JnUaYXVZ2bUA-H;PkyaU^J*(_D(y7i0EPJTd*L%sfN|*8
zKna-F9J+B1b#{ev<7+~MZ~SdMTy<-zK~2ogqA3O%OQE$f22<$Sz02KE7%?GJkJC~Q
zT<B`iK=^#QVg_Wugt3H-0P)yUBwzE<Y8=IwJFmxrkbT7LRfomZ<p3n^(}@y0=7E$-
zx}jUS$I>GccplvaAA>`-kS~xsluIc17?Ko-@9#403M<gQ+gR1y)nS`Gwtu7kSP42X
zM+n#Vh@L(hnK*q}*KU9#LvIt>>*{z)>|z0$VBoo-V}IE{cZq<cp|i%O#%Cta4`<gX
zzIA<DSY7Spt(cgYcoCkqt6N)zIP5h*VK*Nw@-@=}FzrXF?Cb>BddeFPCar~<PYOER
zj}I~Ek~d0dWN3LP0bh4|rdQ4S6TPHv+-LOBL)m(q;~q-rrN?%VQ$yBc>k8Pu0Oq2Y
zr(<fu#H|82*WxF&vH(O~$~oEt|5SGv6RZ^!Dl9X^Y&9ci#{9Ohzx`eX+I#c$Ry54j
z*ByboIZgUbMqxIBQ!_JWoHjKqp&6B#2fqvEu8Kf&XS~5de{3{_z0VAtokNqV-AZh1
zcaBR$tD(+jrDX?;_LnoLtIbIMc$Wa55@4I9PPw0~AesCItmg43=aE0jh>pmJ$cRoj
zEz+4{jpa&<QNYLpw+R=`ST%1z4gStH7>==mec>*XXR{!H&%axvEgYD_grqtofs3f>
z&iB8T!xI32R^)`K2YYY1@LuEL@YwDw+S|fwERkiPe8KP!16Q9?)))nzltS}WPj5+_
z8IzKvDJL0e$98v2YhvGIbdYDGXvg`x4tFsw@TV(sa{$8=%Q5yZ5%?)`e=W#9E7ST{
z7I^QNx*p2SFD~ba0U>_tCR<$iXf_fSB|E=$GPW;vR}^1h^{hvp^st3t&ug9d916g{
z7tk7Q3?MY&q~TRq%zb{|-2&*_mH}7L*$KV~b?(Gu9Kp_q>)kP1ppunF(F)8;^HW5g
z@I8=9J$=yj8=LxayMxqVYvtUO8+PPvZH+pJk?ycDg}ive=jjoz$UoquQ@6N5G`E=~
z!~fS)f+jI2tosjN%OmB!-0C~-{Sjkc8}6sdB|`W)W70lZ5(8sV^+#lEAs)5^$2dEC
z$7<BKx*NaHh4VpkX`62Q?rQ1XiRUL0?i0_`1k)~#EyU1~ekZH;=+dz*jtU~_J~A^Y
zjwKd8Ngu90FLO?aZu4l0f^_5Ms@v>^Pynk%OmKI3w<%{5EYZW-+L{-b_&6%o?7YKE
z41LUg*(&P6lD^!#D2b=)o)PP14a+*KuW72T8sZ`4xc|bn=*&a&Ze!Sq!6^=?<3>|4
zcY{ap=yKj`60Zd%2H;sJ$%MV8AS5Ip;iFKVMO$2XBi9eyu2TGJY8yo$VY2Sl)`_PW
zIN?F#?~hJz#49F_FK01vD{AahNvMpuLh5O`alBbA$9){-TvdP*Oxr@N2|Y%QF7VT{
z*^Nh`E{!<NyT_x5jEIs&xq@jkkkgB*EO+?;sv+Eetq|MFBkKLG3~8a!<q<>FC}EZ_
z`q7s;O2asmje|F<sHBXUM(1S1vBF8zwa-aV_T#w;UKx=Qf#YtQ-;v+`=sd{pOlaxg
z3rC~Y2mM+nSBul0%*HNp?i5A)S@#8dzY~y0>K?VQ&%vrZ`uE_ZG5@qv1V%}d6f8#c
zQ-#(<FXv|>FVC(pX$ME!3kl;SE^`{EMLaSN(bY#p0&A~$gBY3xwPi3f;~XsPl0aKJ
ztCK5Y)dcxdQ}2booz|A0)$^wfDCkY4CfEzc`SM1fA*oYh*AvgNKKG_ueT}PQLKQXV
zbFu`6|Cl3HP|~#@^xN@6Qa2$R4NxnLdu!9Q8Nvf087~(vU%LHe?`_pat!~XtiMhMH
zrs_BEFcm~7mLk6yHH*1lEJtDLOJFE_6LJ!^haOSBTArIhuUKHl*qakrT+~^d)JHA7
zGo>*mFqUAULza!1uZV<CmXKC{6U^@7Pp7|PedASowkTBSfpg3`*Rj|?+`DHhS~*l5
zF&CQl^k%8!V+)#kEJy8SAnn`!c%e_tY}#=wI^&1usAk>KIt&9n8RN4PybM#%@q(sf
z7$ZMbxfKynYo6ktG}oY3pun*wPg1An>Q5JsN)&QO4oq!|fW1zBe$8`Rw)Xa#)+M5+
z7c*<cJ=keZ@dN^n(PTvNLbx0p75o54Hsa4FnIF5^<f&Oc*1wVe8EHDpdl*;3a3d8K
zt8!>sutXQr8YKm9d&D1q4b69869x%|;#X-@-ut<Jhn;>XAp@Tc=&7jpDV(&K832>z
z04C-ooF@7+O;J86N(q05TI%*sOxqRnI9^`3bgyjmFyn;;EtO+T?)39<gNx;^)5~MA
znoAAl6G6b7cW)^HKrB%+OK(@|LWHs^PXF0aCvG+VEhfyd-2b?x=^3R30Rcw^0ZojV
z@2hA{=?HV>wDKCvsaRwo5L!zV=pEM{+e7qZ@IMz5c)nv$@7egO2c&<w=|z2^5R}?{
zx#)1UG4tI(p>srkwt8uUbOZwl*~`6C(e7p;;QG#>iGj*GH>7cWe$wM%7r*2CtxGD%
zuNR9c8-IOtQ*vs_>nTVmOHs1|cG!5Y^C+;GhB*RY+MKKN3DoFg<ykU6$Gr~f%Qx);
zU7Zfi&FJ~xjccj(0!fs@9>_B!G-c1{VwbP^@`dAW9BK0^n37U>2Z7`(Y1|(a_P#{o
zHlN}9Ar}lTO|SMY>rfZCs+uV}A>oh!|8N=rVb6uh`)&7?(56;cmvQW8OpDOE|B&Lx
zH{)BeYP_8c-pA#~_5dQn7x>9!+X)C#YF<tVn2d|~BG>0GCw8lw)%o4_78)tWQZ06U
z_7A+!`l8SAsCL9W7gpuXw3?1DfC@I{HWq6=ZQoCm!Z~chx+`o<Opd~vuMB*eD(X)y
zu9_^ux;dEx!Z;+GPOKrXKg5&CwMDd28Gh&nJ*PLU`5eD(73hA0hm?wYfG<<3?qa^4
z^X_hsE~5c3Mh8R}(mvYC>UY?ROKA38LWaA|p=!JP5!QT|f$QE^L+FC3ffWxs$PA@j
zoS9J=0fD(mm=SMg_eTp<NYF9zTR&;)94!MN;WQNOGq;r#9(Cp@F4^uYRpmd)-Su2S
z@?WHi)uQ4AMT{{TVw%(TNx}%YP=75GF^Zg5&Qifbn{he1x;#WB;<kjaZ*Y7)No{AN
zKheaSLfrX-qm~16@`-5}CZ6MkbM&z+dTL$G8(z(#>xC#%mKwk3%q5i1`zpUfDM(^M
zf68pvamzh>n=kb33WU6OgtqVcKBz>|rS0F=$ArIO*5yRVhADj1jKP>_cIoNoV1IrM
zqwfYjD|;7_S4W5~J}Fbdl(;JI-N|s@X8WS4DK8mGGs~j}G4dS>6HKyya<Xf~`vQ~p
zPuOTY17XhbW^c*P1yaWkvUYko=O!0p5mWYj?kK6fG-hA8ujv`fvTo44FTCn$MP%=9
zvfWMLz)(cx(frMj^K18ALL#cV{%u84;rTrUmL^u>b1g|xmpX9C<;khNFB&l%j|tAE
zCu#+!pPL7EEq!R7vskqrE1s!$vlmR+wc8VgR<X!!eke)cqOgVpHJrsI1X4_m#$(2N
zd7h7!kSw9S(q?1IU$!kvCI+{kep?+R5nQ#OV-&pnE}6wlY>?G4NV;XY_S@~YoK7lJ
zO!Cxu(x%tOdzX%ZV9o2j<8&A>#@Kt!;uM!G{IvP1&5xUWXTZE;b=BNbzF9vxsaUUm
zm1<I2nQBFAcU;hddRHV>fw56IO_5PSn0#l?#@_F+8--2n*AoDw5;b1}z2PFLExoUm
z7>)zq(DXXdiCH55=(m3j57%8S-`Y5~ylZf{ka|IFx$M4%wk!)>Yr7I90Zx>Wsw;$$
zqtCd==OQ-zeAoWMP*`w(!`<%+C&h+0WyPc96)pqUbG*)_?vv4z%a4A-<Qxa?oJ{5c
zL~CG(60Z6A=2#PA!QJIF^2$C1-#Z;7j<PfYn47d=(KVBfN44AbG}&~$n!8<#!eRTX
z6Z@-+H8HWRTz=wOnTp8rv-p0SAgx7m6Z1BJ={V?HHsAO;5@aD2W!CwewzboNBgvQd
zyfney29J;Ldx}>4S}j4DM?5|fJz+E1>qSc*6~tPELC^Uh;RffUZl_}Cvjc-hi*gp$
zHU{Ih(C*IDR0f(8`{0LM6+v?lmXBX=wYF3c(<f47OImXj27^VxN|;+xBNJ^d7^b=L
z5+8rxkP%;QUj-F!&-n1yAUEXM8%!Z483*oFey;)X3!UbpTmXtrhZ4ThQ2`67c7bY+
zb)9Ngdtv5~VeKt2q(1~-)ZOiPB9%7d{W&7VyZfwIx4nJ)^uGN1gMLD38b_PIw?bf*
zCd%5zwdI=tLb$v-qzz&)?OB6@Ha2z<)>jCzngd`nXDVe_C$_;X>VnblC{5l1@`o|a
z@9=zPfLhr5HTjEJGug#L=;-9Yp6@CK=q2N=pPHifJ6M=O83<Yz0ly3B7+f)4)l5&a
zN%^C(80Hp2(93iH&d#S41UO`gCXnYQ*WJ7@WGIkhl}TBV<*X#$W&vQJ=>i8E@dhS#
zjVhi}c^^*9_?GOkG@mYDbnawgsc{HJ-E`V9GjMrwGLXB}y$iEz7TXs|>n%T9k*1zL
zPf45gb05$~ZIGr-Pt}WI@cEI6TsN`$(|wFd+O<fVgNQT;G4J$69XUrP26Gu~ga=qK
zI4%&V;_%02-^zpaBudp9r}D>Z+|Y#@)M!V*pzl$U7jpUNYVFFiuG$R^9PnFNAw9Gi
z<ooswJ><^acyRHUfGYA`Ag3{5lox)J_x}C@95T}=9Z4nTs{jt~R4x%a6^_~7-JPw!
z+Rse8T=VifUpraC|E~2;q4PO|6QJGnmD2g+6hE}D8O`d`DG3Gao0a*@<AK_#MkGkT
z=viVHi}@hx;e78khky}pYdag|04Jew8b7Kpdtst+fcj$S3fXPAgyyqH6zlf#@s{iR
zl|suJd8WP2&eodU_d1=&_)V;L+=YF1H=*T~nM0VW!0~eT<?qYOgcz@m^`HFXe%`1O
zuO)Oi%iN!e)bu8fXSrA8fU;-NcJCCLXhH7!5fp)C*ta(T4AI_SeK4ZU`J#40ITLxu
z3`*?_6flXQ<DUivSU^#&DSvOjQtE)s1m85!Vx$>)&;*s*$brRqL{^oUe!Fw(iH7WW
zJC6j>&~|)OQR?h)Uu3}EHB7S@5mil76yuv>puj_ZW1(2pvMb-GY{FwDObzrNj^lsG
zZ$lVg$$yjYV>15N;aGirHbsb`Vbjj@@D|5rTU|UwG|OI!cY>w)Oy6V@l#5YAm&4Zz
zpGt_}v{o}}crN}|SHthVJ`t1h@Nj)|r&Zs0M0p>`M^-I1ZvT}dy5j89pqUo(2b(BL
zj^)3bgaR{bbVNQ=Rk7yCa48x}{Nt#yJ3d%5G5B5Phvu=0QT3vnpdf#f-j5J9>`pud
zrACLAsGuMsN5px9f+-%^ocg3+(VS9m^3s^G=CDp*U+juGH#r%g&Ge$SPu%oAz2WUn
zyUKU-c7R@ZqU%0F?59F8FgqE)vR+nVHvw4=Ha=Cu1ss(3s^k9!c>;$0xs)!2xKV3m
zm0ME=^-Zg?+Cd4Ed*c_?^{I+mC&J;=goqupVZ(W^_t~ePW_~^rak?}&*aZv#00000
zux{;G+h~r}d46&xt*}A`*yl+@loL;j*+(Dz^5*l;Z*6U5S;oHCa&^`bG>X9bAh+(=
zKG{cHYwf|o!6%=5Vw}y`#J#`a1cwSR000000Ki#m6noG5ak}LqVV$!Ny2fzN(ahN|
zKK;~ESjpU3sr5~vW2db2t}LEQ#Ob$Y_v!ixDJL@-qKvqgnI3ays;$A{Bn$!u00000
z066y=C11Zldd(fAbHCEq_mpC0Bh)iw9F@5dA?pJ$*K(;!oRa>_%%N8mGYJXT0<O>4
z=@6#`T=mtWFaRlBArxbBMr@ce=8TysEyebmgXyS6X#fBK0000uxyByg6lnE1jf0J>
zyZ#KEr%qQs*%~G%oEy$agve1GzZ>ZQ?90FY4k?fNH{u~x>y>aUl$3>;d`@QOc0oC8
z8|Dyt!<`JL5^~7CSOE<H00000uuk*xYUlCxL4D*5_5g?Ry75qGD#e^;API-ryQ$jB
ze(ACJ#45Fw&BDYIcIq;dNa)xsaWQoW+`>e{an!F#*ZY=PoZ3h;u?b_6nq8=gC_@h{
z00000003A*9s;SZ@y0T&sbX#Yt+;2HLN1OCn~8`xv~W%<m1A9)*@xm(C1xTrR2`Do
zh)Z1=>eE#ZE)lK@%}4Lb1poj50002bs$8c@jvIR8w%+QzRGSqwz({LPHA-KmgY~FP
z`gL;>FvV@bjSpg$`f2{2Z@u-_QNMEl000000C=YS7m%Iq!;}x_U;qFB07*qoM6N<$
Ef@@v(mH+?%

literal 0
HcmV?d00001

diff --git a/fileformats/IMAGES/battle.png b/fileformats/IMAGES/battle.png
index 30dd6edb90dd5681b6cc43193e86468199648ccf..e3833a65c4fb8b7f36481ad6a34fd733c299bc71 100644
GIT binary patch
literal 7350
zcmWkzWmr^A6ov(9kOt}Q?(Xgdk#tcSq`RcMyJH3ESUOy~76haP0YMss1?h%wzaRI`
zea@Zd&Y78W-uKLV<Meb?aj__{kdTmY)zy^r5p6%>8p8k}?)-3nX+(qRre@-agoLB>
z|Aidlo5+YTqI;=pE2IB;MMj88jE$-eLPDZ4R9BLJ>$d_g^7YFcS&2FI6{Xi^pVOzq
z#{kDL$kVX^MC1q<U>?1%Q5}$pf${eEBW&RS0HJ(&5GFuDESr&vAVMw82LnJa#Jqs7
z#z+FFhDvVGKIAjID-zCK{}#L%*%gMixcJzHNM1+@PD_<x(5I@M5XU$MK?<qn=H1=o
zDiwhXthi{zQTJEl;{(<Tm5P-HwTUV?XcVFq!JqGx)sW@ikyh#ukc{k3SlfJ=Pb-+P
zO5y*2w7$;7az3wX-YKU~C_(M-?{%W3hkvud`|7KWk~a}GH%*XUDAL)#p{*@tO+$rn
zavAgb^D_cTAB?!4K*vF}_(bbvzR*Zi({?UkR+@YU3sTAF(c!rBn_7P_;j;=C7spMA
zr$Gdo<G_frPcLz*5|)}z*w+A5CbCE-Uj}e@clXDk=%>qhU5&H3Bqe=!WD-(R6%`dU
zbadG8@YqS}TT?mTjn6kVhPC?o`uA5yzSqYlzZlcMW2#loC(%etaB*=73eInAyxg8`
zHybcziIlSH7C(-&mRQ@^T%B&bELntPiL`y411&F98yGd1=jG>1SPsX+S35KdO!dW)
zk+(;a5)u=;gYM3&fMs|zQfz^$|C<$K@ZPuBYFk=b>gmno3EEkst8=i@eHe}<(9Gsi
z*VM$uz=%yqfHF>)bFX!q*c!@*9S2F0;Qw3s1mQMrq!Scu(Jhggot@2Ut4=WNu+coM
z*&3-(jA7%-e1d#-A^O{7Jx&O=naGypAnIxfXggR2;@+Q~6Ux3gRj+gzNL^)`?jCbx
zbERzxUDLd7wVlcbmZ|s$2CAy4$Xw1Sb}Vg;XE?2@=o5Bz{XMW0n(G$t?Y+Ho-$HeF
zU+a_y(S(jG4MqC}%ysa-hkmDRe#b5gcKZFzo45D26bgO#Q6zZ^J?&k^vnB2`Ib#UL
zXZ~JZGx>TqK1>=L<8~{7mqn*=xzl|cu?Tm!w_~7;Oe>|Ftt=x@o@_|4ib`}}-%FDf
z%o_6llF%_RSr3H2a&T}!LC0Hbu}e7?Q@;Z(TbMLizMA>wee@gZtBJ1U!CEOWDdL?#
z%H8htYpz_A><&9q#jD)+w^5z(+4%&osPoF@%ooLa)3)Zy6F!K{LM>|)FarP}<ub-6
zB%J%Ip7Hc>)8V=Snt$(h#*mk{v%h^jxi!-2G``lQPcCeQ^833g?PpZKfB+gXH#v-t
z0(q@sQItuRljO7Q_1|RhEC*2?mfwbRP&+>(Vy(@^pg?Qu(t$suS6QyQTAw5ftg%1H
zqMd)an`1EwgQbx3Z;hof<`)i<1by!EnQB&AugfdUcKkqH#if!=^@fHf_;9Wq3<f8V
z@j5nPH@Ap;jY$<;oIv#n+c@czf#DGmWIX1%g@wnbry+-P%v0V2S4TCWp<yWHOed4r
z6H~i`ue4aGsAi59zn3y#Vg0+VaG3Ylu>Vmge%kxc0EGs=efxH);e8aoX<W^EOH2$c
zj}Lq6lXtP0{QeK59G=ZBh4~8MUf`2mIC};r{p}v5PT`-ySC;`U>r8y9O;-Hm9Oo*6
zc0cNjAnTWh^CkX!d63@w8Y2iO|G+&Xj#_fzJQSHcDZ3<vWx4s4ogE=zY_bXjwwM)#
z?SI7W16KgvPKP+k%zcSeFDl|5O)}_7`%$E<rDfxMzB`eF;=Ix-?)MMOQW#sxuz66`
z?zgG%rK>Hr+90a0&&?fJ(CA*a+%dfc<S{pXa0zm0xQ7`vbTdMhi3tdhTkU7JCi4XI
z-L?~;56cLYoqhGn^3Fq(==!)RQ(h}i{{g_kq5tBiG+Y$STrrYBhB8$k+UKzw4}S@t
znxf{Dv$nSPp!Zr}Yr}NyWe1>)EH_y$av+xm`U2m+-KOpTva+wF46M+~OV7w4qM*3%
zM|pj`-UCHMa=VjauEQF+sw%e&liOXhsgC-<QqIeREK*2_Y1`ny7ZDkG;S{-%$zo~B
zf7jQ^$;s_gC9XQjHmw_-z?K3`41Dc^_-i-<J@ZZDc$Rpvv9UGP)W~ImI`5oPr|@K*
zS2A_bYDgFu7Zpq?re!n}NKMVuxO^duQc{m=U7iRBo}O+toa=8wo=v!0U9^vW<`d84
zSeRD)nJp9UBz)f>Eo3{HTdtXdh`$^7swg}Actt?Ss>lS!LT3}ptJcp@(}Q0IQzcGD
z0D(^ji$)ejf_6F{9v&Sozn$zL+tAYm>9<Bk0hdUzNsG%Gm(Nex=VNJWo+;8;W0R7n
z-H5fw&(B|}HG(WJ8=D<G6^QcZAyJ5YwUE7rTdj#*y{X41_(Ccr_3yk!P`0t6yRlEe
zbzQ1|X=#Zn;#~(0rR|x;dXNF?t2l$oR^m~nNH<@j0zNk|8{5nWDLorZOiU9*Vt0A&
zgM!XRB&N%asBSW{M@yBZ9=Jjt3T#Jdls_)<G&e8AJU@Gr!r*$)sdu9(w7ijiyIDqP
zxD>4+FVETD`_j6({dX6S|4>ST2K&S8c^X%L7v%}Ev-K}#?Uz6%$|nUX8Vze5oo<Em
zwyS^t{+*GLVe_`?b5tuSBzS*kVNFcPYBUi6))imBdY!I6AwpkGDB<L1Q`PX`;N}o9
z$>JJqv2@^dok<HJ5fM5rg;$jrgI=k)MxttgNL=s}*Mnk<?P4S6M=We?l$8$Gkex9C
zaccWCSw+)~jJxN+^bB?meMS7J{&7qrBQzXv;0;AOWZc@c%VReZlPD-C$me*O-V<h@
zOwrZU*i2#CY7bOXi><7*b8>Q;#~QZKbecn}snrF~_neJVBGOY!L*wsCTP^9d_ZYz#
zORl)*UJPyUGJ@(3=PNA)T@8Mzl5xhDm6grf3sEFpGf}^Ook9lk8;C|_ip-S_c}{#I
zSXfj<8+^N2ntzG>DPwSOa3lDkUO9nOMn-0k$Au0^%*@RVM-U?dN(`Lp)dvO!R8we@
z;^LYL<k<uTJ;ze%6{B(d56g3ow~aOr4my2L*DFhcC4_|+2Y$+!m#HLqNl?##Z^P}9
ztoX<;19}n?5^8H}e@|MtxVY>=)Ir}kXFJJQ(g5jd$m&e`a_K8Dd7lAlI@G8r@}%W3
zi>w0dKRaGA4(eY+Pa+vrjhn)Ul|)>B8cXC_CaU}>W){z5*3=`W35boMtx!Zi={3Wu
zitcicNX7So>&Gx85fTh^`xCP=uXUycT#-xV#>RekP{XR4t23{zQ7y~Ws(U}NGmanv
zxb}20hP*!E>}=2j_u-+_n%W4NdwD1aY;#DfpaRY^46BU+_jHSSVTg(%+1ZUI+rUkI
zPFc7TZ`LzF##1w8=<%h7P?*%?WPW*ehij#Y;M$s-ry^v3g4bagKO@eymtNQqs|w9;
zhaj|HZg5bDi_UZ5q4DE8ycQl))YN>9k%$Gva2ob(f!8yg`~(Evo>)DmZf^aBn_J_o
z_2d(}GMK4pKuktmtSW`!VSJioe1xOa5~(GS#puT)3&(-(M*}Qh-!?b6sq#Fk8giDd
z0$^Z(iB&LABt@p?&H^w~f&2TLNl4gT<jHBDnZUj}vLR+!nsz~K(#S-@*|zWoRS{nQ
zNcp7jrF;ZZe0<f1$9iJDJDt;=ale4`i|H4Vo5ll<Y7BPpYFfI298!NQ!LnP;FA0*u
z<M8IOsof|tHBGC2B-<&DG=UB=`o;(mGE47o0uVVjpN6kytWo-;lD^HpygE8kXQ*cF
z#)Pj9t{(Sg9sP&UE(6xqFfeAKT}yJ%Q?pe9zFm>k83V;B5!<BYvL*+qY)tLg;DOJR
z`kv(SW5}<z*O^t~BKO?TB#@@158ho|o;dF!N(ZDAX%(oCzMSFEY#Q{W6x<*0VA73w
z`X?0MbmbR<QLsDuBC5CUetgBXrl$8h5uckMA8$H$ouat15f@+U95~y)y>lpgAFnW7
zj0E-d+*UbUc_WDQcd1e{XQeevUtdk5`B4oU%gw7*N{C#;RaV3`IVJ|~d+FTiKR+kt
z{A*T%x=iJ4)m2I5eC1P3ZajbGiR*eHj20q{{3hx0R2M{}!YD4DtCdKjt%ZY$d2p4h
zb$g$lHy(v8WFHDj0Zq@Ac|_I@(T)mE^M%Od@bG&u0fE`XPed$kTd4i1^g^znPk_0@
z1=-a$&X-5lo3#iX)s5b4<BpMpvzz@Ti#)!tM4Zcj!onRglbBAZpf3-js>i($GP0i^
zKJoDPtQrea{C;%Wg$hd7UcTm#kls6$BrB*#lo`ZT1d{Z!O)DnOAJiFrLl2MrqNuLE
z3GYx>r)M4!V7@%~X!50sn=#<R_W4@0_hp^%m49vMM)0bB@V$e%`RxIt<Sk%w9g1)I
zUX3`s+8{20QL1piWdHdA6W3-#27xAXu7<mKVj;!6eQ&oJrV1tP*dOk*L8e_tJmN^p
zu?c_R+HQOU1BL;$9N6|hxoG_Q8Js+^yf4s+!|4?@y8X^9pPzm2o_-M-lIk@DOb&uN
zbh7YfDs>OZR^_E4zverG^@%sY=r~lycA{cxtsLNbGw$8>9^s%Md3|(%gx^dv5`4RC
zQ4@*Tn+5#OZKB;fhsWFVRhiNdV5M)PS@(BSS@i2ZwZC$557%jFU$T38-iYb>G<a=u
z4owwgi*c&LG-6cVQD3YymS(nOG>}YA5p4OKRr)Z47i+m0^`?t$iY05r@o1Q&3I`%E
zvF5r18q7BjfbA~KqB$^HR=(71Ztk>YA2#q;rU`i=GP0wAbm6IZk~)y~L^cI!sz2&`
zXtwYA=68|_-uc<I89fCBC%5<Y`KXzxAAW`Tx`D4<6_VmMb1WA68XT^;jQbPckSDc%
zLeLF{ybI66_1Os&ar(O3&ywjZ$7KxI*SVSuZi;sN0!{eUTa*K0;0LbGXO}km3!ZjI
z%*K|`Qi>A38Na`JyeM&$DcPNfOKyh{9Q^xOT8c>EL;Z;ifB&E>5_CL1A17Qq<@mv9
z+&T+L!{=3)vKXXC1xS!Yd9fMeb!_h+Jc?s!B_5FJFfZoTpNzWmC$yGRMkeUmByK+;
zer&4#Y`|w%1CL5?`c1CZ&c2aQS){YaULwWbdapDJT4t5wQnGx6SU~21eWFUi3SCWp
z=r^D8PfHRH$FxD<`_B^8cGJyn^z7^uq%()}#H6M3{0`|^D?IP*ms5|OWS)(sr9Qg4
z1i=dmJMIHmbsB@Z+V>%hstbM_$4;DWCnud<X+=|uwb%AaOL61=oKaEsPdpvD<ni${
zhvYJA8ugWx6xSw&3>sK!`r(!nqmB!%1tPf+#@^uf2n%&Y199pwUMgU2#<x5Jke;c1
zmNrqx#o0#2Q<Xrxha-#NsW}|l<N`_-A|UXcBN5S}&8X-`CLrCoEcml`x<Dn<eeEk}
zky1+GbcBtO51*Aa^24eKXWK?l*$JuaRVL!|6x#VS)kF&aCV0zFYdQn6mW`2kc~79a
zi1E>CjcQdc&0MpVn=x<=TWsqrTtCs8?5VXfo3>fbGE`_=E%5*Vevj_v@9(aRbc%=V
znZ$BIJzql|(LBY_cbQXKKeK2nR9gLg%VYj$OW8|8c)?)|pOm|KAfxx10Zb#!B|n@$
zIuOQgKrR$p5{x*kscGB%pb83dn)1mu$aUU6n)s^D42YN{m~W2}Disc|r@=)m1A?Ky
zh9Wq6QS3LT&*F$gQ7PN?65Hz4pv!u<|L*s!BN0-lKg`<BZhvo&g_*fX+;bFsWy9fJ
zJ+L_#g}v9lTpId(yPbkg8>DA1t@f;|#bRJ<yN9UHhlYmWwx}FzY<%Q6@ui4vCp|ao
zv>}iDtgJ8>74Ucl>uU-j`-7P;K7s&h2`~G#PIm<iGvd^O0<+b2XZRj0KP_!@Z|`Tb
z&4f;o#4qi#=9U&}YU*-CUE$J=PzxAdG5ud)Ae?W5&rR@D(TR(Htw_&`0_m2iv^rI9
zdL`O6H>>HgN>VBhSeN>H=8KFh{?FE8eyPlw%N;3^sG)e&e&^~HT1{)lwc_or`xn#V
zeyKawS9!_Qm^eGMFJOy4jYx<(a@KS*_2cwQYMz5X3r}*VSnzXRy_v(JMj-b}W7wY$
z6ZD6@pAl(kP$}jeuU%l=)l9eq(4efMx<0l0BPSr}FcXS`F6J41v2W4@P*v3_8Qq|r
z(Rbvezdexz1*LUMb$7?c(#aG<`dHZG?k<q$=KPMhb&4|qH7uZzqHw@TS4<TfLT#B^
zmkO4;*xTGua^#rEb~to-MIReKXg@p@@%e#VF#276=RS>;6b9zU0f2YV(_c<@@LzDF
zUeB1{zdv)nqNwQGhnV;jHRYsvT6L!7!Ox`J8lR4mL>J6&SKHmM>xlKTOj<F(9~HyH
z-8?vei(us7U^XljMt=T$2cUcM7ZGQTz_dMguX`^f^q6=W`3%4}>b*oMgpLz1s4sO>
z$U%o|L-xG=I^Ys)r<*Uz>zRy_I2ymVmJM2l^Vuo&9PxB_*DZjcXsH=Pqe&uxClDbJ
z=<#6#Lw+dw-Pba<pl5Npi#-x;Mn+Ze>PMZ!g;sVMnRkw?S_lCP!%XvckR*l3@DPfw
zE+=+${9xlpYn#pE$$4F)%TY6Su%q13+4)`q9C0G$bv|9mqF3a&fBDXS+*fq$6nq<&
zimz{g3;-;*PX*LCveT(!dU(dgTRsJdxS-nq&L4>Ie|gfVQpKvGijNN!pkCRclxZVp
z57`75R5pJi+iSs&Ko|ThfsCAGL6*wVg}aBBl(IiYz}aTjVJWcrCv-1-_ce8CNC;w}
zLaO`AkEb9Jr%s})F@h?p;(&N+Nj~yARyz?p18;YFK0VE(Z+>ZDy2Y(uT^Xvh^>fg1
zf&(8R2Y{Y&)%`{J?Jk)&d<XK0qg~6Isk&NB;(R;B&@hEqPy7cwmOxBAEqm0+A`6r^
zHO(qPL67iV=Ce=>eM#YDxBvh0T7TH$zi7P0nJHLuT54#5X50i~Mr<5|Bd>aji=`K#
z4MNIi>oe%IjSfVVqUUR#*()=8!j<bs5Hpa|L(mPisLM><8#ENCkI4oEKm7jcaLuGg
zyLHbQ++ugPiGF>`%Bl(<dkjKsu`aF5Gr64|h49vw7~|$hG+ZIpvN$44?CpDRm6W~j
zBxpEvvL&$?+1x`Pz|LkW$qV|Plf_oHET_F@6}}EabM=&)n<NQYM20YXVue^>8EVx_
zz%}vs_@FhR0*0*YmAZvRTAs;Cfp&oiJPe%%zg<Zy(SAWKbml0ktjx`eSfU6Cq2G*6
zaK41->gvA6z%Xui%HwV=H{zY>@G1xi4&GYpTJ4!$?+Gj_Dr#wNuCYQDm^SYKb;IFF
zP^c-WH5NvLBIcVMN3^);p}n~e8;D4x8Xrm6*#XZ3AvC%&>Pkw7<gZuvf7#t_ym0Re
z?;!=Ypa9KW9^;6pWa_euiu@1gHM7M3X2`k*EP+Eqec%gk&tC4y5KKD8XzGn!p;Nzi
zQ^$hL%$%0_HCvNAaT(-tT=Sv5%vpHfC2B4FZ+ZUOZLQJb0r>^&_*cttvtrZplxN;`
z6U58gn+IIS)%*1G+-(#m!7`NJip$U<h(6F9Yb<{?r{I&n{q^GidM<0RUPvPdL?x{e
zgVzj$C;n{=`%z*C!<!iDms<}m;553u|3n-m;_P>2$fEOh`-xd!uAKY9%ys!_y{OBx
z+9+km8VlQDDVaw4V9lgPRp+A(FNM>Fi~n*5@6pdDM-sDkK7WDz9|Uj4iFENv-_7!c
zjECfeUIrip8L2`6W$uMqRbz7Bjrw?}zYB!(g$PLAeP^;3=z4fHVfOUf4A(iXHSBHg
z!w>!7$1@2t`thmqDhxY2xHC`Y$W%cMYwf%tkA{gAz_gc28JH7vf5k};9*S86Z&`Xm
z1Nb56B{JGxLWtrmSFKV9747^_grA?iu>>romizm61)!U^%_MoyXNURG6IAQogq1p+
zp5h-xni%$Q(<>SSuzZBT>-l%e(nm`dv#O8J(EFXA^+-<-g03{d!4&gJUCI;LXJ@cs
zSWeab{U-@;%MmO}oZ|X?+*Zq|aw>9T%dfv%V#d@G_J#e=snMKsqDt`z28QDvpCua_
z5^1Ked8?YlSKIl6#9+w|T5|D&YhB&X5@%-zUQ*{6Kw!{)HHDbpIg`A6HuWd7xu+tJ
ztD1lR8Y5G2$myC}7Hh0vk(HI@f6H??o*PJ#(C^`*v)|f~fRN(YBodV}Ha2{;h}-AD
ztCZfWY&N#WDEvZ=VU#?xon7XwEv1iN@D<2$O2KkYt1J{k_;mM|O=;xSTYg|kim(O?
zJGdzTpr#8O$7E$KEQ*U~V2aEWJp7sTaJs)DTv(VZU0?+>?(M$E1>;gKxCbBVpY&Pa
z&dnbA@4W#9;?hYK4l8jd$!&z_21vvYZoKF`T#HH6M9cRCT>dS$b?x*XQ5q6SjX*&J
z`SXJ#W5W0}%-V8AD0IE&?7IDA+NdZIXKM>7U+ClG?c6L00zJLh4-bb&Os3;M6qxsD
z$RjIcV)Te?Z&|iflb@=|H8d;|&4$3t`*chx`X_kJfR!zR!NG`lwq|;I$icYku+b?h
zwNfoC^t%LdBCECs94i)}V{dO8Qr`Vss2)MM)}>BJ*qZrrUgX>9Z?HIJf$rp~nSc@n
zAI7d7BB*M_f7Tj%hb1by(t*C*W2Oo4@U3(<^KPnKfCV2i3%6{pb$OuHysIlF@^JqW
z=<D2}2_%=!U#!)XdP6!IOMrM+uPiS4DZEd%C$M(Afhvq?cfOVk4JANYg)!uDU?Af1
zWU312NT`S)p!-{!px}BK1an}yDUrHXMoaC(4=M(R+b!&9JOnC<M;Rt<DJH(VxHgB5
z?oF)}PiXjmTwj-Z>HcfVW5MGL=9n)}$QOHt(bg|e;8@$CB$9uWt(?2RF?v5y5}XdG
zNzR*)^3U^>${MuRFGDIU5}q$*RQ-3U1YGcbj8E*<m-E$0ApMK^CFBLFG?td<xxXM?
z##%fxNzkuTw1B*qp<CC7C^0U*`hS*&3rPa5PLf&#b9kD(sz-kEzxeKIgtBNK%qj{3
zJUj-M$mA-mrYJahms{0)j!&L$%0p`+nyeO+=2B!B1m>Di@CgUMc_U@8Wc4PGj=m8@
z>!Hbro0*woXOp=Ny;*1EO|hLK=ac((wzyMSXQp~{Vr|W5i<3Y$-z$ws=gi1~&_3C1
z*r#KRzz=kNkAqez?so!KFaiJOZ@65jOASC{wH8|{am!Df#HOIQlb=b;##e)djH<DT
zZ&466WX@DUt$2954<aV6kL5Aq<Hx>l{WU}!{J)o0#Rfl#`Ol%j-X`%f`5cylzW5xI
z1A$t33K3{Hlogw#h*{$+DWw)prpRvXt3p7nF7Fw3(~0%2%wG3bmejl!&hOcO7aoCZ
z`=eFLsy3+^HuV-dxsG^B_b)}DCm}ms9HKK_q~7sFth<|=9<j2k#kk5;QnNDe<Oe=$
zYwO|B(Y;*W<~bRJum%l&3NSZc3qwK2G3_>;%nv{SZGKJ;I@{nVgYD0T_Ye0+ko}#V
z11}$eo_wu}!9j(76UABN-L#UD)2*%a{Cr1GfB-qp-Q68pgnU|;moqtiBnZ-X)Bt^^
ZEiK+qy2#d?L;Q0@QdibdYEbwP{vRllRQUh^

literal 6877
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
A-~a#s

diff --git a/fileformats/IMAGES/battleTB.png b/fileformats/IMAGES/battleTB.png
new file mode 100644
index 0000000000000000000000000000000000000000..c8de96830a91b00a39b0bffe2d7bf8fb77366ad1
GIT binary patch
literal 19147
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

literal 0
HcmV?d00001

diff --git a/fileformats/IMAGES/corners.png b/fileformats/IMAGES/corners.png
new file mode 100644
index 0000000000000000000000000000000000000000..c76be4d8bf522694bf737ab78028c0d39033724d
GIT binary patch
literal 7720
zcmb7p1yEdFknZ3T9D)ZYxI=IW!98dQ7Tle|HMj?N4Ne#|5IndHF2Ta!I@sXO&i`+1
z)z;SAdhgw;duQra_w94KPoLBMebE|f^4OT<m;e9(TTwwq697O6hW{T%M}$9}mWqtv
zKNv0w`tAV0E5d(n1VDB!Df}gxhoY)1+Byme0iS?bf20op@McI+=DoJ}@^PMz$7`MZ
zp`dO99WE{k1_ZOPI<9y20Hhc??nQJue%9t=+rjs0iOtK)d)^KP1Ga_MZ9@lHwvHBZ
z+H!tGz%y>~;u;}3&M@Tf4RYv+5jY0#(($CzZ>kO<cl1~^D>V$YtUenL!cX$llh``t
zhc^;8H|;<YT_t<~pa}&r5k5Es1ON>U01zAu0N~*P08&x_06IG0-*?E!00758KRuvE
zUWqJpLL+KsW+pp3TX}5abgojXJMhWOO?YaTn@_OwNSSN+%Whj+TfoCLS%hm3s#0Z1
zNy*sQn2S){&o^&aB*d1P2%?*w-J+wT`K-pgU!HEbrmY@tVbFzIXB(T}D+d752-9~5
z^yKlz#YW6T%T2bk$1Q95>FJ(5s7VUj_t4q`$)M*t(>{ll!IWdtFlpLEoO7pY<&@-P
zv+S}hArj>zO)V{RAjg!k5_f6pJIBiEYEj?I{ps)WTz|g2JU_+9$1hu8_TwwDJkEvG
zdcO%HmbPhRL1qK|CV_hZ0H5kV9snRB{_BDNi&y>;r4g!QtgiJXVL&EB&1?J^4Ncbc
zNOEie*r2A%N>4F*_PXY3!B7#5h)GfPiSb$JK-F7StdQ;kHntI9bXIC{81hoLWNCS|
zaVHTzVN$BaN?80~sS9%zA`*95l#Dc2A7LGxJl-VD)Z}7RT-}ioyMFYvv{Lri9E-V$
zHgR-jIc_a!M0{7-aAx-Hc#45$N9~V2)6DY=TIO41-RSQtD=qX{Sro5MYvmHt%?F3;
z%~@ze3^VGAIDW~*>8BG&Q;IQ5Jf#Xc5#_vt!M5fW6|k}ArhdoATO(WOS7|Zvs?N9a
z0Z)EJ;H1H|VO#URLu6!<6hsfsXbL~g=@;P%yo<Sk@Iic)9sVjXsh`8PJkCqr=0@#<
zxoofO($eKBD^F@#+FDl2+}spcVg{&A3%>)MHDiF#xCLWElK@%y#C*-k0UMijLMF9v
zGW-Bo`0Z>#g@K^3UFySk>X95LxQAloDr+W5LV`cPAr=rAOlBN3aEA4S`ro=-Xc{h*
znh)JB^3d_#oCp~EsRo?-P4wY{bDW(bmw0U`*kd!}1=sk~Ikr0eT01%zZQU4pb#%0K
zERU8MCGHil$u=kQpcDD3EG!ufq{wrizTW2e*KA`0u|5x;j$Pl&o73&>Tbt&V+jNYA
zIy=9FkV|wph9Wfyvr@imb`l`r-0qbIRmJpl?+Y2~kEErU&A#30ep%74lS&|)ji|(v
z=xbqyVTAu`n)6*pfI|FQ>$p*`g$Z3_z~F%@ogxD#o&q1a@V>B`XD)TD&|XvfX*y{0
zO8>*@(4d61`)1guPLaz{>dZ+A<%C)ODr|&-(155oTuH3e!1j87ANF~7H9_Ed@Ez2I
z>8~rA0RNQiL@4r`bd9L$>YAm-@wJzHW#tiIKx<5@_D55R=U-Rrq5k_CvwB466>sQ~
z6>WbQ+Ky-S$;t+X4=e@DiJmh2^`_U;O^!CZYoMhhUTKN6ntTTdSg55sad24izS4ou
zz~{yZGm^H@)1e>&^#V7jZg-;e@GzM3P^iOF*=AP-R1qA?N%BBM^hxp_e{T=%?zQv}
zeRJ_kyi>><7b;`~A5aG!{>9b8_}xV)6-X<l#qrg6X3x$}#ej%V`heffXIzQlHUC*u
z@uTIRe<lM5{jQOP|557$#si^aCXdCAAP`Z|(@y~}P9AfWwmvgb|LrK?X{Vv~oR$9b
z^3TBrOOH#NFGg<~eAN#UnOS)D#_dPsVIU*;x^=sCfv;s2*)o=Q&b!WC8&3~8H>V0L
z5-)#!k9Z!ItYMB_ABx$*pPLkji1;6H{jO65{}$d~rECo*ZQ=1PEW{SmK{^e#cRun-
z7GzC|eUHF)x1M|p#{AOEkGx%UD-!rOSF#|H(pFBz&^7#_k9t(teS5uUk5f)3CbP9+
z=2PRK_lYp1brveQyvUr+B{&%G9(4ObCGEr}tZ$dCHcF>D`^svy)qS<#Nd<>&hDe*C
z|A5rpdQ9jwABAA{%k$~xWY9HaUSC~|Rz5+yF9M~G8=Wx|XXPDyA$Q#5>s@(3cgG5-
zIoLe{U;KpK7#JD8*(RIj-W9-~6(_5Ct?u+I%}dUmrKq^qpFY8+zwgef&(@n;OJjS)
zZB`fedT*eBD$eYpv-s%SJ(rX-MmPG@(dH{LJ4a+xd(v~+nbhJypYV;kjUnFO7al4r
zxL@uHT06voxj#_a&rnMQ{`K9btu=LB1z!7|3U}YdkB-hH>hPsN+ZwH8U%lGN6{eDO
zgGb_z<RenJw72jZG%znQ7qO_P_c37xM=Z#&()a3IgoZh+V>f%B!ueOC*rrajbJqxk
zAnF+z4q_X_)zz+Zkg|Y4{t;h5+tcF(uV9PMRgxwvQ4FWa2_&eyycQQ5d-J%(XQjD0
zyA9J!Mf&S7m`}H+_}*9jTEBIs^WnrQapD(eY5B@4;$P|#2SAVAC2M$OP8rY<+qP#}
z*!Yb7r&9vns?-$(evT)7KW(E7np?Et(%*c(EH^%<0ab7p_~8_6i>jnMcHCDDot|7b
zSe}e!aZpmECnu*I4^ewj2mRGL+uMPqa|ANI$D106mWkWTzc_E0&*Ygn4J?<7vzcFX
zG5_9a5#0gh3@9Lsk5QM{;4t`x42-*!CnEN>g+3nYotV4;tGiTMIT@K&5+x2Na`pr;
zs;bTfFun$JLipzA$+$X8TGVyZFJ=oy?Q7$E7GQ&Neg~QY-gVEA(b2KJ0(pWt{F#E5
zwOw()j*`WMy~BfKa(DQidh`6SbF~0H{#G!#(tMYV{9cMAKz)#{)?3M;Tn)H4W^1|w
z?3$3K-OIAR4FAN>`p#iJ22+SRp`QJDm*V-+oy(*>Z|#XQqOy}xRCgkK$8tU#X7V!d
z^XIc_P<SxseexKI@zjIa*_WG>b{5KnrF$%v)zcsowVbk3QCv#ybWYjV#6zSJx3}hy
zc0Ci}Rrf^7ckEWg8Zm|oomaYC)VuL55Rt}teq<s%rRX=J`%|=?oS=3!h_`uMIm&YL
z#hlhXLq)Uh_MTuV%-b9miANModUxl4TPN}4b2&}QCEM&M>{2Ld8I!SdI@o@y8PKV2
z3O{=5hFr(@@@MT2tE&G}zuanP5NJJ({5ABs7{6z*S(B)Ddb5i>VEe?_b^A3owzEXC
z%6c;M<#`FX6G!H@Dbq=>TWhtZ`ywSpLP!3ZI$*o>IXQ*tp@A3dnj1;|XJ~4pZ?kdo
z8^QqN*k*O@uO@A-!h**z>7qq0aD$`pm*9@;&yJ5#*c27Q&~G$_x(g-)10I`UWjZZR
z=VdvM?XQGwlkXun{PAkJcogpnF=OQ)@bFLnR^m23Kkew~-Cfe=MsJ5<*e!Ca>tsqQ
z;vst=AdsDQRXeBW9ly&n+8|8Wg7}n6MBq^MhZWxT@wfiU^g8`hE_t)Mr+k0$lGW9*
zOD^nDVN8gELKJ^LJqeHbX#4_b-kLe!VN@c(p9rt<l7>daQ^f%i_p{P9!Zb=Xr^Ejx
zdBJdNi?kq>RahUJtoVtFOX4Lr2?1rhU~9++Osx8y(`c?gIxs`L!P(?+`h$Cmd_vTC
zj%$T`F5{9+hc#|Snr-&gQ6(z&Ik1X^a0H)Tdon-UbAG-fsGHg^L|ST3JP8QBL`co&
zlux`4Xn$M!SHH0-jhuwUeb$qkMorT}H|FMaVK6b5`+Zhfx9P4BtDxT1!B!>ag{dD6
z`hLgRVza7q1juM-IH}8dp`U#yezv6wv|D4qgGD5m`Sx^q01fw0YaO=5LfhkoaJ665
z=Cu&Hv^yS%B_stmj$ad;S?T4Rmc03Jaw%PrOBv9(H6*Ku5fQS9+P98`)<Mb7ET4#D
zm7H<7RzN@~(DTa_snuzW&{5{NwcDrY4d8H25r>*erHB6EvS>^t9@pOPR|#@0XMV#G
z656GKKzW&_l@<3>47rd75L(u04XTOv5kW-=xM9i2NO3YynQv{R6ksi+&{RsGtQ-&a
zo}`NVF!U-W>gIHBR7rI$C5J*ozb5r?NvpIR8uTXUPI;^`5Pe_tXWAJzKqfkRt~~K{
zs5l?g+k{BB*}(f&MLsT()SQmXPZFF<xpM>1AWWc-#3^M1O|3ngtm1u}^!^lFm7Hv`
z)`fr(rEd&O>(UPpzw2-%iqc7x9!jufk|M;nv_|tF20=A_MHrc&q4iBfi05}VC#J46
zj7-)2{lOFRucdwPHH?e^D>q*=J2XH)E*lVy;Y#kjdRjXB2OlycE0ORtpi11wn^Jum
zOH1z|$%iX?Ylqv4pdbCa7BJdEdiniZ*G?keD@<l2Iy1VoG}+3^Y^#TBTBP$kRh#y*
zFyups_^*0mtJjzZ<1?uUA>RAj`*8K@*;mZs;=`%BrKK#Z5GlNGFB?S<`85OtmluD`
z$w*={bzYvct(ep`eT0oo{(86#B^*Gxy7#0CKIjscme`zh{J=syZ}plv@iWtBrKewS
z*KAWXI}(cP%iaoCkdcg(U}0Iu7f;LFuiWGtUkr2z5ALEMqcRSjNgL&%7MM!>u&{8k
z(U*xyL_N3Q{vlKjP0yHY5rBuEl*%f)qWmQ`Pt-gIzLi=NVAtDcbm<HI@V&v=r+BnQ
zIQY|_0wov>-mE~L#jLQNlp?uNRLm3cS)$G!9W^r`m6ozDsvgVnkcy5DA>LCBj8>$W
zqB?W?s-;y*XpzaXbKqA0JcEfK@UnsGKwY{BX0=cWO+eGuqTXd>#5m96P1*9UsxcGi
zMM22BBKC-eu{;Q=6?S{}O$DLQ(=80x#a)~1Hg27bq!_b4N%7GPeSCUI$=La#qr=?e
z{|YB@wlES4c2&20;XF3WK7VM($u(ry?-`Hhaaoa}WP(jzB1UOI-p6i07Lmbr4(Y`E
z<~;Z3a4prgDwxRzkA>@Vz2kXuPe}7baL18(xu)jwL2ve_Q!H$RfEI#l&95jyCREN;
zS0ueZ#Q%!H+p4I<Dx&|b&#a)|vOGuGT@KbAB<;mQY;$qAJgLErQwX!S`wC%a1(kzB
zW`BVWA$gz<&6h@YPN#CwF&`pk<hid*)%Tavg0V8UQ$<oJ45iGhGlI&BAC1~kJ#^7*
zV6}Sa$It09G6Di2C$(nTW~atn<+9ZqedZL8cp73dj;irpI(Ah`s^P)G-94H42^{(X
zNL!)+<X6ZZ>8pNM=bw?#s#ynb)#T|!bCQ$!ojWR#U-6DD+jvkSid-OeU`cB^*4!Re
zOSP=J8vV)t#1(e#(ky605<-k)?*-Y|G{bbmTjp=A7@j4aioz#FI&UOAJ9j|>&85yb
zYp3R_WMwhaY?U119lO?2({><xjwObL1b037ySwq9yHZ}efSlr#xsRuK`L3noa%B8|
z0~|r)4>u`}Xv_0HON4E<-#?)b51lC}&o))m?ya^Xbuukju3CGiWwAtJ_d#QEI~?9D
zEbbqi#gWE*fwwalZ_S^usSrhKy=K%<?3Pm{hFyL-KJC-Ei>~$%=04D;SIOg^bAK5c
zN<a~Lt)LW;Sy~EDP5t+u5oGB)d>S#i*}We;pB$~Ns!aP3-_hG_oQerAfemFK^`XVn
zU#hre`&U}D0y=jg?rtuenUl`FU^^_9)_R`0xKLc`KZ2Oy%mS~gc{b^hMn{W(us``p
zdN3DK$)YF7ErE6KI(>_fFItf)_!ZWEG^cx=VA)J900;I8pw43SAFM3aUFL41c<AO!
zV~wR48I4Qukg!6PmBrr>&$VzNZ@a(nTg5%&FU&`a`ymp1)BF*SHCsX@eugb!{Dp45
zI^*z<>IL}mT-nY6s~DN^D;w)=KSlsI4jCfCUEEeh2$BH8+~RN~4$2?X^9&Qa?2^(-
z1f;XWO%`nU4lIf@j)seRNgJ1Sb24uw#VTr0T4si~{IX6etU0^cj{)ft&)guE@JUuy
z;*aO$-PY0D7#P3?Rr_9PW@TktHIJj=AZzHd(LG-q9BY`5?MZ!*BEd-fYv`B`cb7YW
ztv8jR?J_b-JA;#zDe@~B7oeWtTZU1{`MG~>Z)R4M*U6lff!n3c`G(3D__>EB?$hvG
zGd~wq+eHUHztb&YW}XrRk7?@}hQtePGWC`yDQP01+7MzU6-)-|nU;+V3>fQ%j3}l&
zqI<*D!_4+Il+^z4i@1fodWCdLFuAP$g@uKeNgm%*CXOjn0h{WF@AcfHQ1@*wSXZN_
zm%IOD)$n7{MVQ8i$Yfh-srMGcCzl7=01@B0#k!sw?wU&cw(1IaEijyPi%jgr^EMK9
zL0v@DC%OB1`E*I@aVO(3quXYtfJH0S^mcj#UVBu;l&VR|$S^X(tF}bytuzArg+l`)
zpHfOe93&~%h^-3R58B;<_sBab>i&jlcBF<z9L>%PI6yG<V{or2Ix{nZkyl=G$L6_P
zy;Xc-pHzft$8~mdJUOq7m8B`BS;zccOm^A)zGn+wwXQ4hr^(e%OIQT9F|l6z){qwS
z_7DfWjKfSkasXb<lOv?1MGM$xhwa3oDl7k_pQ=(O5q6?HtQ7)&>)1ejDrs!stq<%B
z(#eE78B-yFQgOBIj%W{WN;dUniyEq2!eQXO^3EigW|seDOR}Q=<1D+Vfm%VrJsW4V
zoTU>e1H*6-%$1T_|MC<mZD`1jiP?0JCh7%JQaWdO6&lQWs~sk49wDK~!os5my4*4#
z%}B#=e6rL(KdiRAIjQL0{E5k@D(v|~Nqqs?+&KUC9=iDQ9L}v<Ll7RGZH0m1c5YFC
z8cb6d8!4}wo-3j=ThV3w!w5VuP_nYw(wf!^+l)2TuWaobQ@KeHtuqM_D_;V^#o$no
zdK4VFh=}-PEJ7RNb%aM9SdkaB4{?ia+r)f%`$1ZYMEz^vvwJ{QgHI!Dl&#)he9TbS
zirt{h5f0*PZ;v3H=AfBHZ&mb!mPW#iV6dUh?}=u_R%0cp^>%3)@x*`qPG}`3bKp~C
zrGby1TtI1dtU2Bbf=?Yp*+@ChKW_5!xtp7bV?2+iFR>CvGsPOG00CxX{OsTTiejkq
zngWfHA!<^BPxr@E0@Wyw`P}|=*TijPFeepNbTk~@fwreOcMA}6?apYPyKSG8VnmK-
z81trcEvy-wLQe9$=$@ke=<wl|=Qt%9HjUcH?k?1KxN2f~AdN$Y9gASKoRff?O0_(H
zqa7p!Bg(#ST4l_*Ih_>Lfi}<J?x`gD8geYmNcezx0xu{!bw#{9gPz?FXHcNsBGLr?
zNAP~kR&x_tYjCmWCnmYqyMP&4SvC6DN8Nuozr1@sNU?L%t&V}wWwnGi#b}~07tv^w
z)MdnP_Xtb;r{kXf&QU#}E#&ayv*q)7hM{g5$NJ8^Uc37)vaidVGXacjp^s_>CzfRe
zFy|Mmr}GSpY>uq21)0MS*ZS%bw(!0)&<wxvVwj$l4SY&YjX1;jp78Ck?d&B71^HO1
za!vPxD5NEkfG`K<C_z;0vgo^ka#24d_U3lBGNsXlHe8zY=|D*Fo8|<4B0PZNK;WdL
z^QsrMo}QM_k-(TrO0Ov=D=&56qW7^tRdsulZ`5$-9#vY7^7D_Euff^)l&p*cck{KE
zd*S#WKZL@DBtPG*aXs$^DJZG>qrb<%V5QtGri1pN#fQJTTXF7`N%p&0b?ZfbqLjsx
zm-$|0BDps$KhkGBO%zWKhY$W7Ee+0;ZVM6Nq*xmLVkZ3BYl<1!3U_9C5GK4kgzZT}
z-Kk6GeutcN-c&U;0m?G7ydOklUuC6iJwB}&P<4%J@v}-iPO-8kJ9p5Y{_4vUP-bMz
zqb84uqQ{5lZoOGJGxK_$sQ9>*Rl51m@+;ymhwhOc-~9ISiVJ^x@4S9`NYmWjyEs`L
zjCl=TIaL^h+h-dw`?(5R%b%Z*_+TSUa>i67Bz~()p-cKr3U)Ur;lW?Q-&D0Au959P
zXeEnehMH0uyawMoZjm)Dg4MoMMPPkILaU+@XQq5hXXmip>38=V0n(nq#;TV08=4e{
zwHHoOVXqhW>>*Xc0CvmwPljjU-Ce%SN1Xv39YaHSRlq8q*XEh_^dQKwyxu0l$x64d
zLoffULDO%2VM$0`Yy;xYmu1DxcSK9$9R5iz;v&|>#i#Xl9Vs!W*V58ZSI(eCQz=Ho
zC_!=L>S}Ik>Zm0r+phbufl`F%`k-#H`Ea@~@NQ@7^58!Hx4QlQFusUe3Cj(Bxt>F-
z6S&Og7p~a4#2J8*39Y#c&0H$~&0K9kqf1eFXy3%al3MP16)UI$4hw*)ic^>j&ODC=
zAui==vatCcS4shw!lxPKxlTXj=Z;EedmEdgfahK3TzP72Z$A_C3Sr)nk$Mw<SZb(H
zg(G)z@{vyUUly&)dFp+D%y+lP+kI$l%JpJg<|Z7>f#=NV1dh-kO`#RT`+oM?&OgRo
zhH5#)Q+}A?M`>)Um0G3+VCJ#Z<gG#3^Ycr#5HrhyNGi8{Z|ST3X%8TJMSv(X(~xmP
z|5csR_n#OG!%5Te6sw9UUkbpSV^P{`UDGd5CO08ykDa>k1ht6%$KI%2O7s<;hO!9r
zd}Dd1P14gn)L6~S4kKbi0v6Wk`;(GCDl9mF6a3Yr>eAzZ`i1BIdZo(pgY+`nST5Pq
zI+8U+EG>CPmj@N$r}l@DkrT%jS;^<cEJ>60a_x)W&2)oeAD`>3#A;5X!hA6KLTSH@
zu%(g(nAi_y_PYHet$<zX({9c+m<x<gzwD`wf?n|&hd}!37%FyW(Ny?bzpn7-5?*5m
z6l4<^csZ}PQ}Ho1GwNqqa4KD2;Y8l5&jp>R=i;OU+sk3?=M;UgfpdJ<OW<WFF1)qY
zE>|mO>uN^42>u*zS=kkkH$>%5?W^GbFWBDS23!tJpO|WG>^Kn-b}#dT*08cfOBZPg
zkhoF1G)J(<O4Hsrzx>G)%}`eAzrQkD6{!ytrxq=Hfg&JjJAp)jRk=bRfd|rMK6bjF
zMWcAonTdPe%am1WYORi>tVR<?N8!F9So7}_^*S&500#$j^a}1BYKa&bD^2^fnM>T<
z;fLkn^3~kt?kqH?h{~m2flrlJRluV{)VuB>rQjQ!6e%tYrj#cl$`x+aR#H+<`7W<z
zRt!J$85!~UFgCV$Jn=NzrJ~BZWZ@XW^@*zBs>g<5nWCI34}#Q1^%bAEuF&5mpVp4M
zUH6q-oJLP9<ZbIz?ujGB5E=51qGL{Cz$Nd1|Kz*=|4E>K>9YSfzUaS1|7F(x50?Hr
z;r0&+2mk8-6#XswmI@(CG?NUs$h<?IuldE0(7WL`ZmQ<|{Jf8k&$JDZIz1#w)5^l4
zUq$Nf?#_HLuE+dX!T<iCJmsybogN}9JA1B>E1j|G(0T-g({EBdK;gI&H{9}+6`b=6
ze)rwS99~rAKEG%xl@jIC0DhYwD6+JB9*bCxroykX(edWv&CSi^WCF4GfZ%S#21mdC
zD17@rKZKu5?Ck9ed=D!bmDATT5CQ&NJ%$TFqZ<#}KT}idLO4{^fI@*Uc;o;)XGBdU
zMHbktltYqczFJey&RLs*5aDO^=}N6~IA6HEZ6P+4Ku%et!Mq-8?6Z>=ii+LfNb$;7
zL@Y^xK~yv+$1Tf>17x~u!~a=ZyUBe|4cu_XEXtr%X**kHX=&;6QHO!Rwv#suZ)ax*
z2n2fHW+>ujBqz@hAP5K#^N%-{qlAEklg;R8=y<V^S|@itfc5&=N*z|39Vu|@kq9xv
z!_Y7JP*8(8*<^lipa1}Cu6R^%a`1l%a(~PV62&U^DmZ}$E(-uC%BsnLq`!Rq50h!j
AF8}}l

literal 0
HcmV?d00001

diff --git a/fileformats/strategic.md b/fileformats/strategic.md
index ef07b29..ca6fcb9 100644
--- a/fileformats/strategic.md
+++ b/fileformats/strategic.md
@@ -83,10 +83,118 @@ Players should also have names.
 We number players with 1, 2, 3 and so on.
 Player 0 is the special *chance player* in an EF game.
 
-The following is an example of a two-player game.
+## Two-player games
+
+The following is an example of a two-player game, a version
+of the "Battle of the Sexes" or BoS.
 
 ![](./IMAGES/battle.png) 
 
+Player 1 (named I) chooses a row, and player 2 (named II)
+chooses a column.
+The strategies of player 1 are named T and B.
+The strategies of player 2 are named l and r.
+Each cell contains two payoffs, one for player 1 and one for
+player 2.
+The name of player 1, his strategies, and payoffs, are shown
+in red (for "row player").
+The name of player 2, her strategies, and payoffs, are shown
+in blue.
+(For two players we use the two genders, for example "he"
+and "she".)
+
+This is the standard display of a two-player game.
+
+### Displaying two-player games
+
+We want to create displays that *look perfect* so that
+people use them in their presentations.
+
+We will also allow some customizations (e.g., fonts and
+colors), but the default should already look very nice.
+
+The next picture, although a bit crowded, shows the
+following features which make the display at least not
+messed up when there are long names for players and
+strategies.
+
+![](./IMAGES/battleTB.png) 
+
+All cells are *square*.
+
+*Player names* are shown next to a diagonal line of fixed
+length, about 3/4 of the length of a cell diagonal.
+(The length of this diagonal line should be configurable;
+not everyone wants to have this line.)
+The name of the row player is displayed *right-adjusted*.
+The name of the column player is displayed
+*left-adjusted*, and sufficiently *above* the names for
+the column strategies.
+
+In each cell, the payoffs are *left-adjusted* for player 1,
+and *right-adjusted* for player 2.
+The purpose is to make them look nice in the usual situation
+when most payoffs are small integers.
+We do *not* make the payoffs to player 1 right-adjusted
+because if only a single payoff is rather wide, such as a
+fraction like 5/12, then the others would be in a weird
+position.
+
+The *strategy names* are *right-adjusted* for player 1, and
+*centered* for player 2.
+
+It is (optionally) possible to put a *box* around each
+payoff that is a *best response*, i.e. gives maximal payoff,
+to the given strategy of the other player.
+(This information can be automatically derived. They
+identify pure-strategy NE as those cells where all payoffs
+are surrounded by boxes.)
+These boxes should not run into each other, i.e. payoffs be
+sufficiently apart, when the payoffs are wide.
+
+The next picture is taken from the `xfig` program which has
+been used to generate these pictures.  
+It displays (with small squares) the adjustment (left,
+right, or centered) of the respective text.
+
+Moreover, the lower left corner of each payoff to player 1 and the
+upper right corner of each payoff to player 2 should sit on
+the off-diagonal (from the lower left corner to the upper
+right corner) of each cell. The same applies to the
+best-response boxes.
+
+![](./IMAGES/TBcorners.png) 
+
+When drawing these, a specific problem is that the upper
+right corner of a textbox cannot normally be described, but
+has to be COMPUTED from the current font size (which should
+give the height in pints). We should provide for this, and
+not assume a fixed font size.
+
+This picture shows also, with a green circle, the
+*top left corner* of the main rectangle of the strategic
+form, where also the diagonal line starts. 
+This point should have graphic coordinates (0,0) against
+which all drawing commands of lines should be computed.
+
+The *grid* of cells should be drawn with as a *closed
+rectangle* around the entire strategic form (which, in
+theory, could have its own width).
+The next picture shows what goes wrong when the grid is just
+drawn with independet parallel horizontal and vertical lines
+- the corner will show a little dent (left) which does not
+occur when drawing a rectangle (right).
+
+![](./IMAGES/corners.png) 
+
+Suggestion: draw the outer retangle separate, with its own
+line width, and the separating parallel inner lines 
+independently (which may possibly have a different line
+width, default same as outer rectangle).  
+
+## More than two players
+
+
 The strategic form is a table that lists STRATEGIES for each
 player (rows for player 1, columns for player 2) and the
 payoff to each player in the resulting cell.

From adf77d3e781d9cbf6b41cc66993dee3782ec2b04 Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Mon, 23 May 2016 20:25:23 +0100
Subject: [PATCH 26/63] a bit on fonts, one pic updated

---
 fileformats/IMAGES/battleTB.png | Bin 19147 -> 16282 bytes
 fileformats/strategic.md        |  17 +++++++++++++++++
 2 files changed, 17 insertions(+)

diff --git a/fileformats/IMAGES/battleTB.png b/fileformats/IMAGES/battleTB.png
index c8de96830a91b00a39b0bffe2d7bf8fb77366ad1..f6d40a51833f564d25e070d031986c513055fccd 100644
GIT binary patch
literal 16282
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

literal 19147
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

diff --git a/fileformats/strategic.md b/fileformats/strategic.md
index ca6fcb9..d201cac 100644
--- a/fileformats/strategic.md
+++ b/fileformats/strategic.md
@@ -192,8 +192,25 @@ line width, and the separating parallel inner lines
 independently (which may possibly have a different line
 width, default same as outer rectangle).  
 
+### Fonts
+
+There should be a standard font *size* that makes single-digit
+payoffs look nice and balanced (see above pictures).
+A simple remedy to adjust overcrowded cells is to only
+change the *cell size* but leave the font size alone.
+
+As *typefaces* I have chosen above, and think it looks good:
+
+* Helvetica (sans serif) for payoffs
+* Roman (serif) for player names
+* Roman bold italic (alternative: italic) for strategy
+  names.
+
+Making these at some time choosable is a future feature.
+
 ## More than two players
 
+(not complete)
 
 The strategic form is a table that lists STRATEGIES for each
 player (rows for player 1, columns for player 2) and the

From fba9fa5b3293b6c372f9a3ffa4aa0d538a7f208c Mon Sep 17 00:00:00 2001
From: amelie <amelie.heliou@polytechnique.edu>
Date: Tue, 24 May 2016 09:52:36 +0200
Subject: [PATCH 27/63] svg version

---
 html/2by2_svg.html | 29 +++++++++++++++++++++--------
 1 file changed, 21 insertions(+), 8 deletions(-)

diff --git a/html/2by2_svg.html b/html/2by2_svg.html
index 0b93d58..00a8388 100644
--- a/html/2by2_svg.html
+++ b/html/2by2_svg.html
@@ -233,6 +233,19 @@
         stick.setAttributeNS(null, "x1",point2_2.x);
         stick.setAttributeNS(null, "x2",point2_2.x);
         
+        //change legend according to strategies name.
+        var temp= svg1.getElementById("y11");
+        temp.textContent=P2S1;
+        temp= svg1.getElementById("y12");
+        temp.textContent=P2S2;
+        temp= svg2.getElementById("y21");
+        temp.textContent=P1S1;
+        temp= svg2.getElementById("y22");
+        temp.textContent=P1S2;
+        temp= svg1.getElementById("prob2");
+        temp.textContent="Player2 "+P2S2+" prob";
+        temp= svg2.getElementById("prob1");
+        temp.textContent="Player1 "+P1S2+" prob";
     }
 
 </script>
@@ -260,9 +273,9 @@
             <polyline points="50,50 50,350 250,350, 250,50" style="fill:none;stroke:black;stroke-width:2" />
             <!-- Legend, strategy names will be updated after-->
             <text x="50" y="40" fill="green" font-family="Arial" font-size="30">Player1 payoff</text>
-            <text x="80" y="385" fill="blue" font-family="Arial" font-size="20">Player2 S2 prob</text>
-            <text x="5" y="180" fill="blue" font-family="Arial" font-size="30" transform="rotate(270 30,180)">S1</text>
-            <text x="260" y="180" fill="blue" font-family="Arial" font-size="30" transform="rotate(90 270,180)">S2</text>
+            <text id="prob2" x="80" y="385" fill="blue" font-family="Arial" font-size="20">Player2 S2 prob</text>
+            <text id="y11" x="5" y="180" fill="blue" font-family="Arial" font-size="30" transform="rotate(270 30,180)">S1</text>
+            <text id="y12" x="260" y="180" fill="blue" font-family="Arial" font-size="30" transform="rotate(90 270,180)">S2</text>
             <text x="40" y="368" fill="blue" font-family="Arial" font-size="20">0</text>
             <text x="250" y="368" fill="blue" font-family="Arial" font-size="20">1</text>
             <!-- Upper envelop, coordinates will be updated-->
@@ -312,7 +325,7 @@
             <text x="258" y="325" fill="black" font-family="Arial" font-size="15">1</text>
             <!-- Intersection point-->
             <circle id="inter1" cx="250" cy="350" r="8" fill="orange" stroke="black" stroke-width="1" draggable="false" ondragstart="doMouseDown()"/>
-            <line id="interstick1" x1="250" y1="350" x2="250" y2="355" style="stroke:black;stroke-width:1" />
+            <line id="interstick1" x1="250" y1="350" x2="250" y2="355" style="stroke:black;stroke-width:2" />
             <text id="interlabel1" x="250" y="368" fill="blue" font-family="Arial" font-size="20">1</text>
             <!-- Payoff points-->
             <circle id="Payoff1_11" asso="P1_11" cx="50" cy="350" r="10" fill="red" stroke="black" draggable="false" ondragstart="doMouseDown()"/>
@@ -328,11 +341,11 @@
             <polyline points="50,50 50,350 250,350, 250,50" style="fill:none;stroke:black;stroke-width:2" />
             <!-- Legend, strategy names will be updated after-->
             <text x="50" y="40" fill="blue" font-family="Arial" font-size="30">Player2 payoff</text>
-            <text x="80" y="385" fill="green" font-family="Arial" font-size="20">Player1 S2 prob</text>
+            <text id="prob1" x="80" y="385" fill="green" font-family="Arial" font-size="20">Player1 S2 prob</text>
             <text x="40" y="368" fill="green" font-family="Arial" font-size="20">0</text>
             <text x="250" y="368" fill="green" font-family="Arial" font-size="20">1</text>
-            <text x="5" y="180" fill="green" font-family="Arial" font-size="30" transform="rotate(270 30,180)">S1</text>
-            <text x="260" y="180" fill="green" font-family="Arial" font-size="30" transform="rotate(90 270,180)">S2</text>
+            <text id="y21" x="5" y="180" fill="green" font-family="Arial" font-size="30" transform="rotate(270 30,180)">S1</text>
+            <text id="y22" x="260" y="180" fill="green" font-family="Arial" font-size="30" transform="rotate(90 270,180)">S2</text>
             <!-- Upper envelop, coordinates will be updated-->
             <polygon id="envelop2" points="50,50 50,350 250,350 250,50" style="fill:orange;stroke:orange;stroke-width:0" />
             <!-- First strategy payoff-->
@@ -379,7 +392,7 @@
             <text x="258" y="325" fill="black" font-family="Arial" font-size="15">1</text>
             <!-- Intersection point-->
             <circle id="inter2" cx="250" cy="350" r="8" fill="orange" stroke="black" stroke-width="1" draggable="false" ondragstart="doMouseDown()"/>
-            <line id="interstick2" x1="250" y1="350" x2="250" y2="355" style="stroke:black;stroke-width:1" />
+            <line id="interstick2" x1="250" y1="350" x2="250" y2="355" style="stroke:black;stroke-width:2" />
             <text id="interlabel2" x="250" y="368" fill="green" font-family="Arial" font-size="20">1</text>
             <!-- Payoff points-->
             <circle id="Payoff2_11" asso="P2_11" cx="50" cy="350" r="10" fill="red" stroke="black" draggable="false" ondragstart="doMouseDown()"/>

From 09038eab0c4d516775de822e7a0dbf88b13198c7 Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Tue, 24 May 2016 12:01:17 +0100
Subject: [PATCH 28/63] minor edit

---
 fileformats/strategic.md | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/fileformats/strategic.md b/fileformats/strategic.md
index d201cac..840eb21 100644
--- a/fileformats/strategic.md
+++ b/fileformats/strategic.md
@@ -100,8 +100,7 @@ The name of player 1, his strategies, and payoffs, are shown
 in red (for "row player").
 The name of player 2, her strategies, and payoffs, are shown
 in blue.
-(For two players we use the two genders, for example "he"
-and "she".)
+(For two players we often use the two genders "he" and "she".)
 
 This is the standard display of a two-player game.
 

From 6accee0d1787ca220da7a54d8d06dae4d86026f6 Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Tue, 24 May 2016 12:21:43 +0100
Subject: [PATCH 29/63] standard strategy names 2,3 strats, 2 or 3 players

---
 fileformats/strategic.md | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/fileformats/strategic.md b/fileformats/strategic.md
index 840eb21..aa12e02 100644
--- a/fileformats/strategic.md
+++ b/fileformats/strategic.md
@@ -209,6 +209,38 @@ Making these at some time choosable is a future feature.
 
 ## More than two players
 
+2 players:
+
+* player 1 - rows
+* player 2 - columns
+
+3 players:
+as many PANELS has player 3 has strategies
+
+* player 1 - rows
+* player 2 - columns
+* player 3 - panels
+
+The panels should normally be displayed horizontally.
+
+Strategy names, per default:
+
+* player 1 - upper case
+* player 2 - lower case
+* player 3 - upper case
+
+standard strategy names:
+
+* player 1 - two strategies: T,B; three strategies: T,M,B;
+  four more strategies: A,B,C,D etc.
+* player 2 - two strategies: l,r; three strategies: l,c,r
+  four more strategies: a,b,c,d etc.
+* player 3 - if panels displayed horizontally:
+  two strategies: L,R; three strategies: L,C,R
+  if panels displayed vertically, or perhaps already
+  generally, for any number of strategies:
+  P,Q,R,S,T... (which conflicts least with the above).
+
 (not complete)
 
 The strategic form is a table that lists STRATEGIES for each

From b27f8e3eebac1f02adbcf977ac9cd9af83296201 Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Tue, 24 May 2016 23:37:11 +0100
Subject: [PATCH 30/63] 3player game example (2 strategies each)

---
 fileformats/IMAGES/3players.fig | 165 ++++++++++++++++++++++++++++++++
 fileformats/IMAGES/3players.png | Bin 0 -> 10431 bytes
 2 files changed, 165 insertions(+)
 create mode 100644 fileformats/IMAGES/3players.fig
 create mode 100644 fileformats/IMAGES/3players.png

diff --git a/fileformats/IMAGES/3players.fig b/fileformats/IMAGES/3players.fig
new file mode 100644
index 0000000..4eb510f
--- /dev/null
+++ b/fileformats/IMAGES/3players.fig
@@ -0,0 +1,165 @@
+#FIG 3.2  Produced by xfig version 3.2.5c
+Landscape
+Center
+Metric
+A4      
+100.00
+Single
+0
+1200 2
+6 8100 6390 18180 6930
+4 2 13 992 0 16 40 0.0000 4 480 375 10935 6885 3\001
+4 2 13 994 0 16 40 0.0000 4 480 375 8550 6885 0\001
+4 2 13 992 0 16 40 0.0000 4 465 375 18135 6885 2\001
+4 2 13 994 0 16 40 0.0000 4 465 375 15750 6885 1\001
+-6
+6 8100 3960 18180 4590
+4 2 13 991 0 16 40 0.0000 4 465 375 8550 4493 4\001
+4 2 13 986 0 16 40 0.0000 4 480 375 10935 4500 0\001
+4 2 13 991 0 16 40 0.0000 4 465 375 15750 4493 1\001
+4 2 13 986 0 16 40 0.0000 4 465 375 18135 4500 2\001
+-6
+6 7380 4590 17370 5310
+4 1 1 991 0 16 40 0.0000 4 465 375 7582 5198 4\001
+4 1 1 986 0 16 40 0.0000 4 480 375 9967 5205 0\001
+4 2 4 983 0 3 62 0.0000 4 690 630 13140 5286 T\001
+4 1 1 991 0 16 40 0.0000 4 465 375 14782 5198 2\001
+4 1 1 986 0 16 40 0.0000 4 480 375 17167 5205 0\001
+-6
+6 7380 6930 17370 7740
+4 1 1 992 0 16 40 0.0000 4 465 375 9967 7590 2\001
+4 1 1 994 0 16 40 0.0000 4 480 375 7582 7590 0\001
+4 2 4 995 0 3 62 0.0000 4 690 690 13185 7686 B\001
+4 1 1 992 0 16 40 0.0000 4 465 375 17167 7590 2\001
+4 1 1 994 0 16 40 0.0000 4 465 375 14782 7590 4\001
+-6
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 4725 2205 6335 3815
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 3799 8752 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 11152 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 3799 6352 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 3799 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 3799 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 6352 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 8599 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 6199 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 8599 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 8599 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 6199 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 8599 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11925 2205 13535 3815
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 3799 15952 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 3799 18352 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 3799 13552 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 3799 15952 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 18352 3799 18352 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 3799 15952 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 18352 3799 18352 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 6199 15952 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 6199 18352 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 6199 13552 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 6199 15952 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 8599 15952 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 18352 6199 18352 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 8599 18352 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 6199 15952 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 6199 18352 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 6199 15952 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 8599 15952 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 18352 6199 18352 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 8599 18352 8599
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 8955 7740 9540 7740 9540 8415 8955 8415 8955 7740
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 6615 5355 7200 5355 7200 6030 6615 6030 6615 5355
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 13770 7740 14355 7740 14355 8415 13770 8415 13770 7740
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 16155 5310 16740 5310 16740 5985 16155 5985 16155 5310
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 7290 4635 7875 4635 7875 5310 7290 5310 7290 4635
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 9675 7020 10260 7020 10260 7695 9675 7695 9675 7020
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 14490 6975 15075 6975 15075 7650 14490 7650 14490 6975
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 14490 4635 15075 4635 15075 5310 14490 5310 14490 4635
+2 2 0 2 13 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 8055 3915 8640 3915 8640 4590 8055 4590 8055 3915
+2 2 0 2 13 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 10440 6300 11025 6300 11025 6975 10440 6975 10440 6300
+2 2 0 2 13 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 17640 3915 18225 3915 18225 4590 17640 4590 17640 3915
+2 2 0 2 13 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 15255 6300 15840 6300 15840 6975 15255 6975 15255 6300
+4 2 4 989 0 0 60 0.0000 4 675 330 5085 3690 I\001
+4 2 4 983 0 3 62 0.0000 4 690 630 5940 5376 T\001
+4 2 4 995 0 3 62 0.0000 4 690 690 5985 7776 B\001
+4 1 1 987 0 3 62 0.0000 4 735 285 7650 3519 l\001
+4 1 1 985 0 3 62 0.0000 4 495 405 9900 3519 r\001
+4 0 1 996 0 0 60 0.0000 4 675 660 5535 2565 II\001
+4 0 4 984 0 16 40 0.0000 4 480 375 9096 8300 3\001
+4 0 4 990 0 16 40 0.0000 4 465 375 6696 5900 1\001
+4 0 4 988 0 16 40 0.0000 4 480 375 6696 8300 0\001
+4 0 4 993 0 16 40 0.0000 4 480 375 9096 5895 0\001
+4 2 4 989 0 0 60 0.0000 4 675 330 12285 3690 I\001
+4 1 1 987 0 3 62 0.0000 4 735 285 14850 3519 l\001
+4 1 1 985 0 3 62 0.0000 4 495 405 17100 3519 r\001
+4 0 1 996 0 0 60 0.0000 4 675 660 12735 2565 II\001
+4 0 4 984 0 16 40 0.0000 4 480 375 16296 8300 3\001
+4 0 4 990 0 16 40 0.0000 4 465 375 13896 5900 1\001
+4 0 4 988 0 16 40 0.0000 4 465 375 13896 8300 5\001
+4 0 4 993 0 16 40 0.0000 4 465 375 16296 5895 4\001
+4 0 13 996 0 0 60 0.0000 4 690 1275 6480 1530 III:\001
+4 1 13 995 0 3 62 0.0000 4 690 630 8820 1530 L\001
+4 0 13 996 0 0 60 0.0000 4 690 1275 13680 1530 III:\001
+4 1 13 995 0 3 62 0.0000 4 690 690 15930 1530 R\001
diff --git a/fileformats/IMAGES/3players.png b/fileformats/IMAGES/3players.png
new file mode 100644
index 0000000000000000000000000000000000000000..d6122ec6dcdd14eba121eb80aa000b078c89e45d
GIT binary patch
literal 10431
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

literal 0
HcmV?d00001


From 682d1788778873a88a5aab98c837ee6d761a7d1d Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Tue, 24 May 2016 23:47:07 +0100
Subject: [PATCH 31/63] 3 player PDFs, long names messing things up

---
 fileformats/IMAGES/3players.pdf     | Bin 0 -> 7157 bytes
 fileformats/IMAGES/longnames3pl.fig | 165 ++++++++++++++++++++++++++++
 fileformats/IMAGES/longnames3pl.pdf | Bin 0 -> 8607 bytes
 3 files changed, 165 insertions(+)
 create mode 100644 fileformats/IMAGES/3players.pdf
 create mode 100644 fileformats/IMAGES/longnames3pl.fig
 create mode 100644 fileformats/IMAGES/longnames3pl.pdf

diff --git a/fileformats/IMAGES/3players.pdf b/fileformats/IMAGES/3players.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..37e212fc49eec1d973166bbcaa3f25bf81ad5999
GIT binary patch
literal 7157
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
O(LmosU*Fc%j_@Cp$Yn|Z

literal 0
HcmV?d00001

diff --git a/fileformats/IMAGES/longnames3pl.fig b/fileformats/IMAGES/longnames3pl.fig
new file mode 100644
index 0000000..148fed1
--- /dev/null
+++ b/fileformats/IMAGES/longnames3pl.fig
@@ -0,0 +1,165 @@
+#FIG 3.2  Produced by xfig version 3.2.5c
+Landscape
+Center
+Metric
+A4      
+100.00
+Single
+0
+1200 2
+6 8100 6390 18180 6930
+4 2 13 992 0 16 40 0.0000 4 480 375 10935 6885 3\001
+4 2 13 994 0 16 40 0.0000 4 480 375 8550 6885 0\001
+4 2 13 992 0 16 40 0.0000 4 465 375 18135 6885 2\001
+4 2 13 994 0 16 40 0.0000 4 465 375 15750 6885 1\001
+-6
+6 8100 3960 18180 4590
+4 2 13 991 0 16 40 0.0000 4 465 375 8550 4493 4\001
+4 2 13 986 0 16 40 0.0000 4 480 375 10935 4500 0\001
+4 2 13 991 0 16 40 0.0000 4 465 375 15750 4493 1\001
+4 2 13 986 0 16 40 0.0000 4 465 375 18135 4500 2\001
+-6
+6 7380 4590 17370 5310
+4 1 1 991 0 16 40 0.0000 4 465 375 7582 5198 4\001
+4 1 1 986 0 16 40 0.0000 4 480 375 9967 5205 0\001
+4 2 4 983 0 3 62 0.0000 4 690 630 13140 5286 T\001
+4 1 1 991 0 16 40 0.0000 4 465 375 14782 5198 2\001
+4 1 1 986 0 16 40 0.0000 4 480 375 17167 5205 0\001
+-6
+6 7380 6930 17370 7740
+4 1 1 992 0 16 40 0.0000 4 465 375 9967 7590 2\001
+4 1 1 994 0 16 40 0.0000 4 480 375 7582 7590 0\001
+4 2 4 995 0 3 62 0.0000 4 690 690 13185 7686 B\001
+4 1 1 992 0 16 40 0.0000 4 465 375 17167 7590 2\001
+4 1 1 994 0 16 40 0.0000 4 465 375 14782 7590 4\001
+-6
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 4725 2205 6335 3815
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 3799 8752 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 11152 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 3799 6352 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 3799 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 3799 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 6352 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 8599 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 6199 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 8599 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 8599 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 6199 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 8599 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11925 2205 13535 3815
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 3799 15952 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 3799 18352 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 3799 13552 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 3799 15952 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 18352 3799 18352 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 3799 15952 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 18352 3799 18352 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 6199 15952 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 6199 18352 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 6199 13552 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 6199 15952 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 8599 15952 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 18352 6199 18352 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 8599 18352 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 6199 15952 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 6199 18352 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 6199 15952 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 13552 8599 15952 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 18352 6199 18352 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 15952 8599 18352 8599
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 8955 7740 9540 7740 9540 8415 8955 8415 8955 7740
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 6615 5355 7200 5355 7200 6030 6615 6030 6615 5355
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 13770 7740 14355 7740 14355 8415 13770 8415 13770 7740
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 16155 5310 16740 5310 16740 5985 16155 5985 16155 5310
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 7290 4635 7875 4635 7875 5310 7290 5310 7290 4635
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 9675 7020 10260 7020 10260 7695 9675 7695 9675 7020
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 14490 6975 15075 6975 15075 7650 14490 7650 14490 6975
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 14490 4635 15075 4635 15075 5310 14490 5310 14490 4635
+2 2 0 2 13 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 8055 3915 8640 3915 8640 4590 8055 4590 8055 3915
+2 2 0 2 13 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 10440 6300 11025 6300 11025 6975 10440 6975 10440 6300
+2 2 0 2 13 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 17640 3915 18225 3915 18225 4590 17640 4590 17640 3915
+2 2 0 2 13 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 15255 6300 15840 6300 15840 6975 15255 6975 15255 6300
+4 2 4 989 0 0 60 0.0000 4 705 2205 5085 3690 Alice\001
+4 2 4 983 0 3 62 0.0000 4 690 630 5940 5376 T\001
+4 2 4 995 0 3 62 0.0000 4 690 690 5985 7776 B\001
+4 1 1 987 0 3 62 0.0000 4 735 285 7650 3519 l\001
+4 1 1 985 0 3 62 0.0000 4 495 405 9900 3519 r\001
+4 0 1 996 0 0 60 0.0000 4 705 3765 5535 2565 Bernhard\001
+4 0 4 984 0 16 40 0.0000 4 480 375 9096 8300 3\001
+4 0 4 990 0 16 40 0.0000 4 465 375 6696 5900 1\001
+4 0 4 988 0 16 40 0.0000 4 480 375 6696 8300 0\001
+4 0 4 993 0 16 40 0.0000 4 480 375 9096 5895 0\001
+4 2 4 989 0 0 60 0.0000 4 705 2205 12285 3690 Alice\001
+4 1 1 987 0 3 62 0.0000 4 735 285 14850 3519 l\001
+4 1 1 985 0 3 62 0.0000 4 495 405 17100 3519 r\001
+4 0 1 996 0 0 60 0.0000 4 705 3765 12735 2565 Bernhard\001
+4 0 4 984 0 16 40 0.0000 4 480 375 16296 8300 3\001
+4 0 4 990 0 16 40 0.0000 4 465 375 13896 5900 1\001
+4 0 4 988 0 16 40 0.0000 4 465 375 13896 8300 5\001
+4 0 4 993 0 16 40 0.0000 4 465 375 16296 5895 4\001
+4 1 13 995 0 3 62 0.0000 4 690 630 8820 1530 L\001
+4 1 13 995 0 3 62 0.0000 4 690 690 15930 1530 R\001
+4 2 13 996 0 0 60 0.0000 4 705 3270 8235 1530 Charlie:\001
+4 2 13 996 0 0 60 0.0000 4 705 3270 15255 1530 Charlie:\001
diff --git a/fileformats/IMAGES/longnames3pl.pdf b/fileformats/IMAGES/longnames3pl.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..c89b05fe843dd1a934a035bf21214a5eae7d5ed2
GIT binary patch
literal 8607
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
L$B;AJXoUDbd=U{W

literal 0
HcmV?d00001


From 00edc761950b85367f42d07549a67e53d0f76f6e Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Wed, 1 Jun 2016 08:47:15 +0100
Subject: [PATCH 32/63] old XML spec and .efg .nfg fileformats

---
 fileformats/ConversionProgramsFinalReport.pdf | Bin 0 -> 560327 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 fileformats/ConversionProgramsFinalReport.pdf

diff --git a/fileformats/ConversionProgramsFinalReport.pdf b/fileformats/ConversionProgramsFinalReport.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..26c0557f0a0a6d501d3ae76657a02671eecd6dd8
GIT binary patch
literal 560327
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%0D6XI+
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

literal 0
HcmV?d00001


From d7910050351de4a780f30e53f0548f4e0e6975da Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Wed, 1 Jun 2016 09:06:34 +0100
Subject: [PATCH 33/63] sources on SF fileformat

---
 fileformats/IMAGES/battleAB.fig  |  75 ++++++++++++++++++++++++++++
 fileformats/IMAGES/battleAB.png  | Bin 0 -> 8313 bytes
 fileformats/IMAGES/battleTB.fig  |  82 +++++++++++++++++++++++++++++++
 fileformats/IMAGES/new.xml       |  52 ++++++++++++++++++++
 fileformats/IMAGES/poker.xml     |  52 ++++++++++++++++++++
 fileformats/IMAGES/rank1-6x6.xml |  31 ++++++++++++
 6 files changed, 292 insertions(+)
 create mode 100644 fileformats/IMAGES/battleAB.fig
 create mode 100644 fileformats/IMAGES/battleAB.png
 create mode 100644 fileformats/IMAGES/battleTB.fig
 create mode 100644 fileformats/IMAGES/new.xml
 create mode 100644 fileformats/IMAGES/poker.xml
 create mode 100644 fileformats/IMAGES/rank1-6x6.xml

diff --git a/fileformats/IMAGES/battleAB.fig b/fileformats/IMAGES/battleAB.fig
new file mode 100644
index 0000000..355be10
--- /dev/null
+++ b/fileformats/IMAGES/battleAB.fig
@@ -0,0 +1,75 @@
+#FIG 3.2  Produced by xfig version 3.2.5c
+Landscape
+Center
+Metric
+A4      
+100.00
+Single
+0
+1200 2
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 3799 8752 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 11152 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 3799 6352 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 3799 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 6352 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 8599 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 6199 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 8599 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 3799 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 8599 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 6199 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 8599 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 4725 2205 6335 3815
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 8955 7425 9810 7425 9810 8415 8955 8415 8955 7425
+2 1 0 1 2 7 51 -1 -1 0.000 0 0 -1 0 0 2
+	 6345 8595 11115 3825
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 7695 3960 8550 3960 8550 4950 7695 4950 7695 3960
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 6525 5040 7380 5040 7380 6030 6525 6030 6525 5040
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 10080 6345 10935 6345 10935 7335 10080 7335 10080 6345
+4 0 4 988 0 16 62 0.0000 4 765 585 6696 8300 0\001
+4 0 4 984 0 16 62 0.0000 4 765 585 9096 8300 3\001
+4 0 4 993 0 16 62 0.0000 4 765 585 9096 5895 0\001
+4 2 4 989 0 0 60 0.0000 4 705 2205 5085 3690 Alice\001
+4 2 4 983 0 3 62 0.0000 4 690 630 5940 5376 T\001
+4 2 4 995 0 3 62 0.0000 4 690 690 5985 7776 B\001
+4 0 4 990 0 16 62 0.0000 4 735 585 6696 5900 1\001
+4 2 1 991 0 16 62 0.0000 4 735 585 8415 4808 4\001
+4 2 1 994 0 16 62 0.0000 4 765 585 8415 7200 0\001
+4 2 1 992 0 16 62 0.0000 4 735 585 10800 7200 2\001
+4 2 1 986 0 16 62 0.0000 4 765 585 10800 4815 0\001
+4 1 1 987 0 3 62 0.0000 4 735 285 7650 3519 l\001
+4 1 1 985 0 3 62 0.0000 4 495 405 9900 3519 r\001
+4 0 1 996 0 0 60 0.0000 4 705 3765 5535 2565 Bernhard\001
diff --git a/fileformats/IMAGES/battleAB.png b/fileformats/IMAGES/battleAB.png
new file mode 100644
index 0000000000000000000000000000000000000000..30b4914d350564a20f7506cd5c4f3c4893dcc0fb
GIT binary patch
literal 8313
zcmb_=WmuHa+V0Q}NDW91J#<MAAR!?!bR#J#h%j`Aq>3O&BaMJCgn-1*4j`q3NaxTc
z-T94sf8W`AU)T9@&biKyxn^d)>sjxU_j5n%jgFQIF(Dlx001CXQ&rLf0I*>I0M_h1
zY|M(9fxid<02FspRMfGvcX;OQ;$`LGXd~ccYYPDQWu+uK>LkZdMGu_?&kzyq)OeW$
zB=Oi|ZMLda6=1{m_+aGKEH=2TZ(oZlC**};73x8Zl&Z-nDXa5LA@{h1Xp{|f4m+hO
z*5?m;f<t7E2Bp`tGH~R{@c{D5SbBPRL2}fATB^@!2-;Xaq-D6SFE0ZZR&ThN0e~~3
z;PxX6t`VV(M*tK2upmn*D?r!^c9=svvjrdwj0Z3>&}#w!B#8igA(#UI9ykCKcdKA9
zz(m(7m=R!d4Ui)MP!h-&bO$f%E}Vy+VgtBl4)B20LP+r4SChwD5V`22&2^h0cTf1@
z`TnR4#RuCq$@4p&P=d!Al>k5o3x6<$9E*Tu$3<@b6a47t{XN0?OKfbwy}<qUI~>5m
z@h>{8Mk2suTWIZP=dfK1fZqGNp9b%-9};3U?e5o{Pg#k80RTp>4gi&E1or1Jj*W2g
z^jGYY;S`M#61ehQE&#?ZMZ$d+g2QJ7l#hWs5fM5#C&Re>!z3m7^n;xb8c7<^0`E{1
zWGKp(aDP8i*u8Kvaw(M3Cvs&a;*rPi$OLTSpe#ABnLuxqnB7%*K18jsNhg9nflD9L
zB~YzUuYf)9kZ<m@y-xtzQC-kqMA~o>+vgvCmMVMip)36xhgg21(ET}nW(-w9;0VuG
za+x<i`NqRD8(cg}R{2CU)&}q5xSuuAP<wW?R6pdSTDCQ-wkZd_=$fv!bOAKS0IMZ;
z*y6)%m!MFKEcU?%)UTJ(!f-S9qDHz|pgDCVlP{^ntB*aw-$oBS{1{sB=82iY-*>Jr
z#_p$_I|Omw(uGjUMTKfJlTG3hhtqybAyZd{xNszcNGPQ4r2#u5)lk@ps>vK%WEHRH
zyHpFpOq9wwav+wh@nj{hnN$rvu=c%P(I8|i`ar0f^2z9z@~?YNnO~Kt*b#~Rz4I&2
z4>>$&k#A;UZHhUpg1TK?bd<d60QSV12t8$|67#}$`ty3F2KHr=V`-W4b6OPzIR*21
zS~_ySx}2s(37$gvW9!p=vV1a5U!SIGl^{l6Za(wE3KndQ3Q4(rcl$V!yMS|v1H@mW
z`N`-L%uZ=VEaHcb?WB<S!$X>scOvhk-%0A$d~W(2@%+<<(a6&g&jQ;5A{z}MMIpCp
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
YvW+vIm2|1VTzUi4l(m#96|BSm3+VcdJ^%m!

literal 0
HcmV?d00001

diff --git a/fileformats/IMAGES/battleTB.fig b/fileformats/IMAGES/battleTB.fig
new file mode 100644
index 0000000..cdb0017
--- /dev/null
+++ b/fileformats/IMAGES/battleTB.fig
@@ -0,0 +1,82 @@
+#FIG 3.2  Produced by xfig version 3.2.5c
+Landscape
+Center
+Metric
+A4      
+100.00
+Single
+0
+1200 2
+1 3 0 1 2 7 51 -1 -1 0.000 1 0.0000 6345 3780 270 270 6345 3780 6345 4050
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 3799 8752 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 11152 3799
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 3799 6352 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 3799 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 6352 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 8599 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 6199 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 8599 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 3799 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 6199 8752 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 3799 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 11152 6199
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 6199 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 6352 8599 8752 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 11152 6199 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 8752 8599 11152 8599
+2 1 0 4 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 4725 2205 6335 3815
+2 1 0 1 2 7 51 -1 -1 0.000 0 0 -1 0 0 2
+	 6345 8595 11115 3825
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 6525 5040 7920 5040 7920 6030 6525 6030 6525 5040
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 7155 3960 8550 3960 8550 4950 7155 4950 7155 3960
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 8955 7425 10305 7425 10305 8415 8955 8415 8955 7425
+2 1 0 1 2 7 51 -1 -1 0.000 0 0 -1 0 0 2
+	 6345 6187 8730 3780
+2 1 0 1 2 7 51 -1 -1 0.000 0 0 -1 0 0 2
+	 8775 8595 11115 6232
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 9612 6345 11007 6345 11007 7335 9612 7335 9612 6345
+2 1 0 1 2 7 51 -1 -1 0.000 0 0 -1 0 0 2
+	 5085 3015 5552 2555
+4 2 4 983 0 3 62 0.0000 4 900 1680 5940 5376 Top\001
+4 2 1 991 0 16 62 0.0000 4 765 1170 8415 4808 40\001
+4 2 4 995 0 3 62 0.0000 4 705 3120 5985 7776 Bottom\001
+4 0 1 996 0 0 60 0.0000 4 705 3765 5535 2565 Bernhard\001
+4 1 1 985 0 3 62 0.0000 4 930 2085 9990 3519 right\001
+4 1 1 987 0 3 62 0.0000 4 930 1380 7605 3519 left\001
+4 2 1 992 0 16 62 0.0000 4 765 1170 10869 7200 20\001
+4 2 1 986 0 16 62 0.0000 4 765 585 10844 4815 0\001
+4 0 4 990 0 16 62 0.0000 4 765 1170 6639 5900 10\001
+4 0 4 988 0 16 62 0.0000 4 765 585 6646 8300 0\001
+4 2 1 994 0 16 62 0.0000 4 765 585 8484 7200 0\001
+4 0 4 993 0 16 62 0.0000 4 765 585 9046 5895 0\001
+4 2 4 989 0 0 60 0.0000 4 705 2205 5085 3690 Alice\001
+4 0 4 984 0 16 62 0.0000 4 765 1170 9090 8280 30\001
diff --git a/fileformats/IMAGES/new.xml b/fileformats/IMAGES/new.xml
new file mode 100644
index 0000000..0ede539
--- /dev/null
+++ b/fileformats/IMAGES/new.xml
@@ -0,0 +1,52 @@
+<gte version="0.1">
+  <gameDescription/>
+  <display>
+    <color player="1">#FF0000</color>
+    <color player="2">#0000FF</color>
+    <font>Times</font>
+    <strokeWidth>1</strokeWidth>
+    <nodeDiameter>7</nodeDiameter>
+    <isetDiameter>25</isetDiameter>
+    <levelDistance>75</levelDistance>
+  </display>
+  <players>
+    <player playerId="1">Alice</player>
+    <player playerId="2">Bob</player>
+  </players>
+  <extensiveForm>
+    <node>
+      <node player="Alice" prob="1/2">
+        <node iset="2" player="Bob" move="R">
+          <outcome move="M">
+            <payoff player="Alice">2</payoff>
+            <payoff player="Bob">-2</payoff>
+          </outcome>
+          <outcome move="P">
+            <payoff player="Alice">1</payoff>
+            <payoff player="Bob">-1</payoff>
+          </outcome>
+        </node>
+        <outcome move="F">
+          <payoff player="Alice">-1</payoff>
+          <payoff player="Bob">1</payoff>
+        </outcome>
+      </node>
+      <node player="Alice" prob="1/2">
+        <node iset="2" player="Bob" move="R">
+          <outcome move="M">
+            <payoff player="Alice">-2</payoff>
+            <payoff player="Bob">2</payoff>
+          </outcome>
+          <outcome move="P">
+            <payoff player="Alice">1</payoff>
+            <payoff player="Bob">-1</payoff>
+          </outcome>
+        </node>
+        <outcome move="F">
+          <payoff player="Alice">-1</payoff>
+          <payoff player="Bob">1</payoff>
+        </outcome>
+      </node>
+    </node>
+  </extensiveForm>
+</gte>
\ No newline at end of file
diff --git a/fileformats/IMAGES/poker.xml b/fileformats/IMAGES/poker.xml
new file mode 100644
index 0000000..d5fb47d
--- /dev/null
+++ b/fileformats/IMAGES/poker.xml
@@ -0,0 +1,52 @@
+<gte version="0.1">
+  <gameDescription/>
+  <display>
+    <color player="1">#FF0000</color>
+    <color player="2">#0000FF</color>
+    <font>Times</font>
+    <strokeWidth>1</strokeWidth>
+    <nodeDiameter>7</nodeDiameter>
+    <isetDiameter>25</isetDiameter>
+    <levelDistance>75</levelDistance>
+  </display>
+  <players>
+    <player playerId="1">Alice</player>
+    <player playerId="2">Bob</player>
+  </players>
+  <extensiveForm>
+    <node>
+      <node player="Alice" prob="1/2" move="A">
+        <node iset="b" player="Bob" move="R">
+          <outcome move="M">
+            <payoff player="Alice">2</payoff>
+            <payoff player="Bob">-2</payoff>
+          </outcome>
+          <outcome move="P">
+            <payoff player="Alice">1</payoff>
+            <payoff player="Bob">-1</payoff>
+          </outcome>
+        </node>
+        <outcome move="F">
+          <payoff player="Alice">-1</payoff>
+          <payoff player="Bob">1</payoff>
+        </outcome>
+      </node>
+      <node player="Alice" prob="1/2" move="K">
+        <node iset="b" player="Bob" move="R">
+          <outcome move="M">
+            <payoff player="Alice">-2</payoff>
+            <payoff player="Bob">2</payoff>
+          </outcome>
+          <outcome move="P">
+            <payoff player="Alice">1</payoff>
+            <payoff player="Bob">-1</payoff>
+          </outcome>
+        </node>
+        <outcome move="F">
+          <payoff player="Alice">-1</payoff>
+          <payoff player="Bob">1</payoff>
+        </outcome>
+      </node>
+    </node>
+  </extensiveForm>
+</gte>
diff --git a/fileformats/IMAGES/rank1-6x6.xml b/fileformats/IMAGES/rank1-6x6.xml
new file mode 100644
index 0000000..1c724f5
--- /dev/null
+++ b/fileformats/IMAGES/rank1-6x6.xml
@@ -0,0 +1,31 @@
+<gte version="0.1">
+  <gameDescription/>
+  <display>
+    <color player="1">#FF0000</color>
+    <color player="2">#0000FF</color>
+    <font>Times</font>
+    <strokeWidth>1</strokeWidth>
+    <cellVertPadding>5</cellVertPadding>
+    <cellHorizPadding>5</cellHorizPadding>
+  </display>
+  <players>
+    <player playerId="1">1</player>
+    <player playerId="2">2</player>
+  </players>
+  <strategicForm size="{ 6 6 }">
+    <strategy player="1">{ "A" "B" "C" "D" "E" "F" }</strategy>
+    <strategy player="2">{ "g" "h" "i" "j" "k" "l" }</strategy>
+    <payoffs player="1">1 0 0 0 0 0
+6 9 0 0 0 0
+18 54 81 0 0 0
+54 162 486 729 0 0
+162 486 1458 4374 6561 0
+486 1458 4374 13122 39366 59049</payoffs>
+    <payoffs player="2">1 6 18 54 162 486
+0 9 54 162 486 1458
+0 0 81 486 1458 4374
+0 0 0 729 4374 13122
+0 0 0 0 6561 39366
+0 0 0 0 0 59049</payoffs>
+  </strategicForm>
+</gte>
\ No newline at end of file

From 0e9b2618e4cd7aeedd12858db8401b0e42cb312c Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Wed, 1 Jun 2016 09:12:43 +0100
Subject: [PATCH 34/63] smaller resources for later use

---
 INFOS/convex-why.pdf           | Bin 0 -> 125113 bytes
 INFOS/largergames.md           |   9 +++++++++
 INFOS/onsoftwaredevelopment.md |   7 +++++++
 3 files changed, 16 insertions(+)
 create mode 100644 INFOS/convex-why.pdf
 create mode 100644 INFOS/largergames.md
 create mode 100644 INFOS/onsoftwaredevelopment.md

diff --git a/INFOS/convex-why.pdf b/INFOS/convex-why.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..666d3c3d44c5f81137631f7165b545075d2c4372
GIT binary patch
literal 125113
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
R0HpH3V0cVSl1fr|{|A+U8Xf=u

literal 0
HcmV?d00001

diff --git a/INFOS/largergames.md b/INFOS/largergames.md
new file mode 100644
index 0000000..c8cff90
--- /dev/null
+++ b/INFOS/largergames.md
@@ -0,0 +1,9 @@
+## Larger games
+
+The following is an upper envelope diagram of a 4x2 game:
+
+![](./EQDIAG/42upper.png)
+
+which is the following game:
+
+
diff --git a/INFOS/onsoftwaredevelopment.md b/INFOS/onsoftwaredevelopment.md
new file mode 100644
index 0000000..48d6da4
--- /dev/null
+++ b/INFOS/onsoftwaredevelopment.md
@@ -0,0 +1,7 @@
+# Minor resources on software development
+
+https://theagileist.wordpress.com/2015/11/02/the-nature-of-software-development/
+
+review, says sensible things such as:
+
+set a time and money budget, produce the most valuable features first; keep the product ready to ship at all time - and stop when the clock runs out.

From 97827e35a60c3bddc5e5cdefd322c20814b1232c Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Sat, 4 Jun 2016 16:28:38 +0100
Subject: [PATCH 35/63] degen games documented

---
 INFOS/EQDIAG/degen1.fig | 238 ++++++++++++++++++++++++++++++++++++++++
 INFOS/EQDIAG/degen1.png | Bin 0 -> 19314 bytes
 INFOS/eqdiagrams.md     |  24 ++++
 3 files changed, 262 insertions(+)
 create mode 100644 INFOS/EQDIAG/degen1.fig
 create mode 100644 INFOS/EQDIAG/degen1.png

diff --git a/INFOS/EQDIAG/degen1.fig b/INFOS/EQDIAG/degen1.fig
new file mode 100644
index 0000000..dcae809
--- /dev/null
+++ b/INFOS/EQDIAG/degen1.fig
@@ -0,0 +1,238 @@
+#FIG 3.2  Produced by xfig version 3.2.5c
+Landscape
+Center
+Metric
+A4      
+100.00
+Single
+0
+1200 2
+5 1 0 1 0 2 50 -1 -1 0.000 0 0 0 0 -916.875 7183.125 0 7200 -225 7785 -900 8100
+5 1 0 1 0 2 50 -1 -1 0.000 0 0 0 0 -847.500 7252.500 1800 7200 1350 8730 -900 9900
+5 1 0 1 0 2 50 -1 -1 0.000 0 0 0 0 -714.375 7385.625 2700 7200 2250 9090 -900 10800
+1 3 0 3 13 2 30 -1 20 0.000 1 0.0000 -7200 8100 127 127 -7200 8100 -7110 8190
+1 3 0 3 13 2 30 -1 20 0.000 1 0.0000 -12600 8100 127 127 -12600 8100 -12510 8190
+2 1 0 2 1 7 50 -1 -1 0.000 0 0 -1 1 0 2
+	1 1 2.00 120.00 240.00
+	 -7200 4500 -4050 4500
+2 1 0 2 1 7 70 -1 -1 0.000 0 0 -1 1 0 2
+	1 1 2.00 120.00 240.00
+	 0 4500 0 450
+2 1 0 3 1 7 72 -1 -1 0.000 0 0 -1 0 0 2
+	 0 1800 2700 4500
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 -4500 4500 -4500 900
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 1 0 2
+	1 1 2.00 120.00 240.00
+	 -7200 4500 -7200 450
+2 1 0 3 1 7 74 -1 -1 0.000 0 0 -1 0 0 2
+	 0 4500 2700 3150
+2 1 0 2 4 1 70 -1 -1 0.000 0 0 -1 1 0 2
+	1 1 2.00 120.00 240.00
+	 0 4500 3150 4500
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 -7200 4500 -7425 4500
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 -7200 3825 -7425 3825
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 -7200 3150 -7425 3150
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 -7200 2475 -7425 2475
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 -7200 1800 -7425 1800
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 -7200 1125 -7425 1125
+2 1 0 2 1 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 0 4500 -225 4500
+2 1 0 2 1 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 0 3825 -225 3825
+2 1 0 2 1 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 0 2475 -225 2475
+2 1 0 2 1 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 0 1800 -225 1800
+2 1 0 2 1 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 0 1125 -225 1125
+2 3 0 0 1 1 76 -1 30 0.000 0 0 -1 0 0 8
+	 0 900 0 1800 1800 3600 2700 3150 2700 900 2160 720
+	 1170 1080 0 900
+2 1 0 2 1 7 70 -1 -1 0.000 0 0 -1 0 0 2
+	 2700 4500 2700 900
+2 1 0 3 4 1 52 -1 -1 0.000 0 0 -1 0 0 2
+	 -7200 3825 -4500 3825
+2 1 0 2 1 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 -4500 4725 -4500 4500
+2 1 0 2 1 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 -6525 4725 -6525 4500
+2 1 0 2 1 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 -7200 4725 -7200 4500
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 0 4725 0 4500
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 1800 4725 1800 4500
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 2700 4725 2700 4500
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 -11901 1916 -11420 1916 -11420 2474 -11901 2474 -11901 1916
+2 2 0 2 1 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 -10558 3259 -10077 3259 -10077 3816 -10558 3816 -10558 3259
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 -11167 3791 -10685 3791 -10685 4347 -11167 4347 -11167 3791
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 -12509 2448 -12027 2448 -12027 3006 -12509 3006 -12509 2448
+2 1 0 2 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -11281 4476 -9930 4476
+2 1 0 2 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -9930 3125 -9930 4476
+2 1 0 2 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -11281 3125 -11281 4476
+2 1 0 2 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -12632 4476 -11281 4476
+2 1 0 2 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -12632 3125 -11281 3125
+2 1 0 2 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -11281 1775 -11281 3125
+2 1 0 2 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -11281 3125 -9930 3125
+2 1 0 2 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -9930 1775 -9930 3125
+2 1 0 2 1 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 0 3150 -225 3150
+2 1 0 2 1 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 2925 3150 2700 3150
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 -4275 3825 -4500 3825
+2 1 0 3 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -11281 4476 -9930 4476
+2 1 0 3 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -12632 4476 -11281 4476
+2 1 0 3 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -11281 3125 -11281 4476
+2 1 0 3 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -9930 3125 -9930 4476
+2 1 0 3 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -11281 3125 -9930 3125
+2 1 0 3 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -9930 1775 -9930 3125
+2 1 0 3 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -11281 1775 -11281 3125
+2 1 0 3 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -12632 3125 -11281 3125
+2 1 0 3 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -12632 3125 -12632 4476
+2 1 0 3 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -12632 1775 -12632 3125
+2 1 0 3 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -12632 1775 -11281 1775
+2 1 0 3 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -11281 1775 -9930 1775
+2 1 0 3 0 0 997 0 -1 5.000 0 0 -1 0 0 2
+	 -13471 954 -12641 1784
+2 1 0 2 1 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 -7200 6885 -7200 6615
+2 1 0 2 1 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 -4500 6885 -4500 6615
+2 1 0 3 4 1 52 -1 -1 0.000 0 0 -1 0 0 2
+	 0 6750 2700 6750
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 0 6885 0 6615
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 1800 6885 1800 6615
+2 1 0 2 4 1 50 -1 -1 0.000 0 0 -1 0 0 2
+	 2700 6885 2700 6615
+2 1 0 1 0 2 50 -1 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 90.00 120.00
+	 -7200 7200 -7200 7875
+2 1 0 1 0 2 50 -1 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 90.00 120.00
+	 -4500 7200 -4500 7875
+2 1 0 1 0 2 50 -1 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 90.00 120.00
+	 -855 8100 -4275 8100
+2 1 0 1 0 2 50 -1 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 90.00 120.00
+	 -900 9900 -4275 9900
+2 1 0 1 0 2 50 -1 -1 0.000 0 0 -1 1 0 2
+	1 1 1.00 90.00 120.00
+	 -900 10800 -4275 10800
+2 2 0 2 4 7 50 -1 -1 0.000 0 0 -1 0 0 5
+	 -11167 2459 -10685 2459 -10685 3015 -11167 3015 -11167 2459
+2 3 0 0 4 4 56 -1 30 0.000 0 0 -1 0 0 8
+	 -7200 900 -7200 3825 -4500 3825 -4500 1800 -4500 900 -5580 1080
+	 -6120 540 -7200 900
+2 1 0 3 4 1 54 -1 -1 0.000 0 0 -1 0 0 2
+	 -7200 4500 -4500 3825
+2 1 0 4 4 1 40 -1 -1 0.000 0 0 -1 0 0 3
+	 -7200 8100 -4500 8100 -4500 10800
+2 2 0 1 0 2 99 -1 -1 0.000 0 0 -1 0 0 5
+	 -7200 8100 -4500 8100 -4500 10800 -7200 10800 -7200 8100
+2 2 0 3 13 2 100 -1 20 0.000 0 0 -1 0 0 5
+	 -4590 9855 -4410 9855 -4410 10890 -4590 10890 -4590 9855
+2 1 0 4 1 1 38 -1 -1 0.000 0 0 -1 0 0 4
+	 -7200 8100 -7200 9945 -4500 9945 -4500 10800
+2 1 1 4 4 1 38 -1 -1 10.000 0 0 -1 0 0 2
+	 -4500 9945 -4500 10845
+2 1 0 3 1 1 52 -1 -1 0.000 0 0 -1 0 0 2
+	 -7200 6750 -4500 6750
+2 2 0 3 13 2 32 -1 20 0.000 0 0 -1 0 0 5
+	 -12645 9990 -12465 9990 -12465 10845 -12645 10845 -12645 9990
+4 0 1 50 -1 3 30 0.0000 4 450 1485 -3960 4680 prob(r)\001
+4 0 4 70 -1 3 30 0.0000 4 450 1620 3240 4680 prob(B)\001
+4 0 4 50 -1 0 30 0.0000 4 435 2985 -7470 180 payoff player I\001
+4 0 1 70 -1 0 30 0.0000 4 435 3150 -180 180 payoff player II\001
+4 0 1 74 -1 3 30 0.0000 4 225 195 2340 3645 r\001
+4 0 1 72 -1 3 30 0.0000 4 345 135 675 3060 l\001
+4 0 4 52 -1 3 30 0.0000 4 330 300 -7155 4230 T\001
+4 1 4 70 -1 16 25 0.0000 4 285 240 0 5220 0\001
+4 1 1 50 -1 16 25 0.0000 4 285 240 -4500 5220 1\001
+4 1 1 50 -1 16 25 0.0000 4 285 240 -7200 5220 0\001
+4 0 1 994 0 16 35 0.0000 4 405 330 -11798 3745 0\001
+4 0 4 993 0 16 35 0.0000 4 405 330 -11087 2932 1\001
+4 0 1 992 0 16 35 0.0000 4 405 330 -10447 3745 2\001
+4 0 1 991 0 16 35 0.0000 4 405 330 -11798 2394 4\001
+4 0 4 990 0 16 35 0.0000 4 405 330 -12438 2932 1\001
+4 0 4 988 0 16 35 0.0000 4 405 330 -12438 4283 0\001
+4 0 1 986 0 16 35 0.0000 4 405 330 -10447 2394 0\001
+4 0 4 984 0 16 35 0.0000 4 405 330 -11087 4283 1\001
+4 0 1 996 0 0 34 0.0000 4 375 390 -13063 1133 II\001
+4 0 4 989 0 0 34 0.0000 4 375 195 -13522 1714 I\001
+4 0 4 983 0 3 35 0.0000 4 390 360 -13145 2663 T\001
+4 0 4 995 0 3 35 0.0000 4 390 390 -13209 4014 B\001
+4 0 1 987 0 3 35 0.0000 4 420 165 -12038 1617 l\001
+4 0 1 985 0 3 35 0.0000 4 270 225 -10718 1617 r\001
+4 1 1 50 -1 0 25 0.0000 4 285 540 -6525 5220 1/4\001
+4 1 4 70 -1 0 25 0.0000 4 285 540 1800 5220 2/3\001
+4 1 4 70 -1 0 25 0.0000 4 285 210 2700 5220 1\001
+4 1 4 70 -1 16 25 0.0000 4 285 240 -7650 2610 3\001
+4 1 4 70 -1 16 25 0.0000 4 285 240 -7650 1260 5\001
+4 1 4 70 -1 16 25 0.0000 4 285 240 -7650 3960 1\001
+4 1 4 70 -1 16 25 0.0000 4 285 240 -7650 3285 2\001
+4 1 4 70 -1 16 25 0.0000 4 285 240 -7650 1935 4\001
+4 1 4 70 -1 16 25 0.0000 4 285 240 -7650 4635 0\001
+4 1 1 70 -1 16 25 0.0000 4 285 240 -450 2610 3\001
+4 1 1 70 -1 16 25 0.0000 4 285 240 -450 1260 5\001
+4 1 1 70 -1 16 25 0.0000 4 285 240 -450 3960 1\001
+4 1 1 70 -1 16 25 0.0000 4 285 240 -450 3285 2\001
+4 1 1 70 -1 16 25 0.0000 4 285 240 -450 1935 4\001
+4 1 1 70 -1 16 25 0.0000 4 285 240 -450 4635 0\001
+4 1 1 70 -1 16 25 0.0000 4 285 240 3150 3285 2\001
+4 1 4 70 -1 16 25 0.0000 4 285 240 -4050 3960 1\001
+4 0 1 81 -1 3 30 0.0000 4 345 675 -4230 6885 l=0\001
+4 0 4 80 -1 3 30 0.0000 4 330 870 -1170 6885 B=0\001
+4 0 1 81 -1 3 30 0.0000 4 330 735 -8190 6885 r=0\001
+4 0 4 80 -1 3 30 0.0000 4 330 840 2970 6885 T=0\001
+4 0 4 54 -1 3 30 0.0000 4 330 330 -7875 10980 B\001
+4 0 1 74 -1 3 30 0.0000 4 225 195 -4545 11475 r\001
+4 0 1 72 -1 3 30 0.0000 4 345 135 -7245 11475 l\001
+4 0 4 52 -1 3 30 0.0000 4 330 300 -7875 8280 T\001
+4 0 1 72 -1 3 30 0.0000 4 345 135 720 6615 l\001
+4 0 1 74 -1 3 30 0.0000 4 225 195 2205 6615 r\001
+4 1 1 54 -1 0 20 0.0000 4 300 3150 1350 6075 best responses player II\001
+4 1 4 54 -1 0 20 0.0000 4 300 3045 -5850 6075 best responses player I\001
+4 0 4 52 -1 3 30 0.0000 4 330 300 -12060 8280 T\001
+4 0 1 72 -1 3 30 0.0000 4 345 135 -11520 8280 l\001
+4 0 13 52 -1 3 30 0.0000 4 450 3480 -12645 7245 Nash equilibria :\001
+4 0 4 54 -1 3 30 0.0000 4 330 330 -5040 4365 B\001
+4 0 4 54 -1 3 25 0.0000 4 390 3045 -12240 10710 prob(B) in [2/3,1]\001
+4 0 1 74 -1 3 30 0.0000 4 225 195 -8910 10710 r\001
+4 0 4 54 -1 3 30 0.0000 4 330 330 -4635 6525 B\001
+4 0 4 52 -1 3 30 0.0000 4 330 300 -6525 6525 T\001
diff --git a/INFOS/EQDIAG/degen1.png b/INFOS/EQDIAG/degen1.png
new file mode 100644
index 0000000000000000000000000000000000000000..1f64c6119aa878b19e6589920108ee4bc91e0b06
GIT binary patch
literal 19314
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
R^(LUz44$rjF6*2UngFLV=wtu@

literal 0
HcmV?d00001

diff --git a/INFOS/eqdiagrams.md b/INFOS/eqdiagrams.md
index 7de8ba9..7ade79a 100644
--- a/INFOS/eqdiagrams.md
+++ b/INFOS/eqdiagrams.md
@@ -231,3 +231,27 @@ and not the other possibilities which are seen on the left.
 At a later stage, the fineness of the grid should be
 adjustable, e.g. to multiples of 0.5 or 0.1.
 
+## Degenerate games
+
+The following picture shows a _degenerate_ game.
+
+![](./EQDIAG/leftupperenv.png)
+
+In two-player games, a game is degenerate if some player has
+a mixed strategy which assigns positive probability to _k_
+pure strategies, against which the other player has _more
+than k_ best responses.
+
+Hence, a 2x2 game is degenerate if and only if there is a
+pure strategy that has 2 best responses, like strategy _l_
+in the above game. (This holds because the only case where
+the definition of degeneracy can apply is when _k_=1).
+
+A degenerate game can have an infinite number of Nash
+equilibria. However, these will always be part of sets of
+``interchangeable'' equilibria where it suffices to specify
+the extreme points. In the above example, the two
+best-response curves intersect in an interval where player II
+play r for sure, and the two best responses T and B of
+player I can now be mixed so that r stays a best response,
+i.e. whenever $prob(B)\ge 2/3$.

From aaabc994903f7e6160559fc996e8570c1c828433 Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Sat, 4 Jun 2016 16:41:55 +0100
Subject: [PATCH 36/63] Degenerate games docu completed

---
 INFOS/eqdiagrams.md | 36 ++++++++++++++++++++++++++++++++++--
 1 file changed, 34 insertions(+), 2 deletions(-)

diff --git a/INFOS/eqdiagrams.md b/INFOS/eqdiagrams.md
index 7ade79a..25095ad 100644
--- a/INFOS/eqdiagrams.md
+++ b/INFOS/eqdiagrams.md
@@ -235,7 +235,7 @@ adjustable, e.g. to multiples of 0.5 or 0.1.
 
 The following picture shows a _degenerate_ game.
 
-![](./EQDIAG/leftupperenv.png)
+![](./EQDIAG/degen1.png)
 
 In two-player games, a game is degenerate if some player has
 a mixed strategy which assigns positive probability to _k_
@@ -254,4 +254,36 @@ the extreme points. In the above example, the two
 best-response curves intersect in an interval where player II
 play r for sure, and the two best responses T and B of
 player I can now be mixed so that r stays a best response,
-i.e. whenever $prob(B)\ge 2/3$.
+i.e. whenever prob(B) >= 2/3.
+
+This is a whole _interval_ of NE.
+In the diagram this is indicated by a green rectangle.
+It is displayed so that the two intersecting best response
+curves are drawn with first (at lowest visual depth) the
+green equilibrium rectangle, then (second-lowest depth) the
+blue best response curve, then (highest, most visible depth)
+for the interval where the two curves intersect the red
+best-reponse curve as a DOTTED LINE.
+(This is fine-tuning, but the green rectangle should be
+shown for sure.)
+
+The intersection of the two best-response curves can result
+in a single interval, and the two curves can even intersect
+_completely_ in which case we get the union of two NE line
+segments.
+
+### "Very" degenerate game: all strategies are best responses
+
+As an even further complication, two strategies can
+_simultaneously_ be best responses, where they define the
+same line segment in the goalpost diagram. In that case
+the best response "curve" (normally the Z-like line with a
+connecting orthogonal cross segment) is in fact the WHOLE
+SQUARE (because that player can always play everything),
+and the intersection is simply the other person's best
+response curve. Which in turn may also be the whole square.
+This is the case, for example, when all payoffs are zero.
+It may be confusing to display the equilibria for this came
+and therefore be advisable not use this as the default game,
+but rather, for example, one of the standard games such as
+Battle of the Sexes.

From 85bcc2b9460dcabb1e27199538dc4a2837ea6d3a Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <stengel@nash.lse.ac.uk>
Date: Sun, 5 Jun 2016 14:24:58 +0100
Subject: [PATCH 37/63] small additions on degenerate games

---
 INFOS/eqdiagrams.md | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/INFOS/eqdiagrams.md b/INFOS/eqdiagrams.md
index 25095ad..c12ad9c 100644
--- a/INFOS/eqdiagrams.md
+++ b/INFOS/eqdiagrams.md
@@ -238,9 +238,9 @@ The following picture shows a _degenerate_ game.
 ![](./EQDIAG/degen1.png)
 
 In two-player games, a game is degenerate if some player has
-a mixed strategy which assigns positive probability to _k_
+a mixed strategy which assigns positive probability to exactly _k_
 pure strategies, against which the other player has _more
-than k_ best responses.
+than k_ pure best responses.
 
 Hence, a 2x2 game is degenerate if and only if there is a
 pure strategy that has 2 best responses, like strategy _l_
@@ -282,6 +282,11 @@ connecting orthogonal cross segment) is in fact the WHOLE
 SQUARE (because that player can always play everything),
 and the intersection is simply the other person's best
 response curve. Which in turn may also be the whole square.
+In other words, this case arises if the two strategies have
+identical payoffs for the player, and then the two strategies may be arbitrarily
+substituted for each other, or played in an arbitrary mixture.
+(On the other hand, the two strategies may still have different effects 
+on the other player, and therefore one cannot just ignore one of them.)
 This is the case, for example, when all payoffs are zero.
 It may be confusing to display the equilibria for this came
 and therefore be advisable not use this as the default game,

From 3ea4d3f6d77ef69d9c7f47cbd9bbf5758bd5ec4c Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Wed, 8 Jun 2016 17:03:17 +0530
Subject: [PATCH 38/63] Added mergeIsets and setIsets

---
 html/js/guiutils/Block.js | 30 +++++++++++++++++++++++
 html/js/guiutils/Tools.js | 51 +++++++++++++++++++++++++++++++++++++--
 2 files changed, 79 insertions(+), 2 deletions(-)
 create mode 100644 html/js/guiutils/Block.js

diff --git a/html/js/guiutils/Block.js b/html/js/guiutils/Block.js
new file mode 100644
index 0000000..49bd136
--- /dev/null
+++ b/html/js/guiutils/Block.js
@@ -0,0 +1,30 @@
+GTE.TREE = (function(parentModule) {
+    "use strict";
+
+    /**
+     * Creates a new Block .
+     * @class
+     */
+    function Block(moves, x, y) {
+        this.shape = null;
+        this.moves = moves;
+        this.x1 = x;
+        this.y1 = y;
+    }
+
+    MultiAction.prototype.draw = function() {
+        var width = parseInt(GTE.STORAGE.settingsRectSize);
+        this.shape = GTE.canvas.rect(width, GTE.STORAGE.settingsCircleSize)
+            .fill({
+                color: '#9d9d9d'
+            })
+            .addClass('circle');
+        this.shape.translate(this.x1*width,
+            this.y1 * width);
+    };
+
+    // Add class to parent module
+    parentModule.Block = Block;
+
+    return parentModule;
+}(GTE.TREE)); // Add to GTE.TREE sub-module
diff --git a/html/js/guiutils/Tools.js b/html/js/guiutils/Tools.js
index f20b667..65c8547 100644
--- a/html/js/guiutils/Tools.js
+++ b/html/js/guiutils/Tools.js
@@ -44,7 +44,7 @@ GTE.UI = (function (parentModule) {
         var display = tree.display[0];
         this.resetPlayers(1);
         this.activePlayer = -1;
-        this.isetToolsRan = false;
+        this.isetToolsRan = true;
         var root = new GTE.TREE.Node(null);
         GTE.tree = new GTE.TREE.Tree(root);
         this.addChancePlayer();
@@ -52,6 +52,11 @@ GTE.UI = (function (parentModule) {
         this.setDisplayProperties(display);
         this.createTree(tree.extensiveForm[0].node[0], root);
         root.assignPlayer(GTE.tree.players[tree.extensiveForm[0].node[0].jAttr.player]);
+        tree.extensiveForm[0].node[0].jAttr.iset = 0;
+   ///     this.setIsets(tree.extensiveForm[0].node[0], root);
+        GTE.tree.initializeISets();
+        GTE.tree.draw();
+        this.mergeIsets(tree.extensiveForm[0].node[0], root);
         GTE.tree.draw();
         this.switchMode(GTE.MODES.ADD);
     };
@@ -81,7 +86,7 @@ GTE.UI = (function (parentModule) {
                 this.createRecursiveTree(node.node[node.jIndex[i][1]], root);
             }
             if(node.jIndex[i][0] == "outcome") {
-                GTE.tree.addChildNodeTo(root, GTE.tree.players[node.node[node.jIndex[i][1]].jAttr.player]);
+                GTE.tree.addChildNodeTo(root, GTE.tree.players[node.outcome[node.jIndex[i][1]].jAttr.player]);
             }
         }
         return root;
@@ -322,6 +327,48 @@ GTE.UI = (function (parentModule) {
         GTE.STORAGE.settingsDistLevels = display.levelDistance[0].jValue;
     };
 
+    /**
+    * Sets isets for the loaded tree
+    */
+    Tools.prototype.setIsets = function (nodejs, node) {
+
+    //        var nodes = GTE.tree.getAllNodes(true);
+    //        for (var i = 0; i < nodes.length; i++) {
+    //            GTE.tree.createSingletonISet(nodes[i]);
+    //       }
+        GTE.tree.createSingletonISet(node);
+
+        if(nodejs.jIndex != undefined) {
+            for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
+                if(nodejs.jIndex[i][0] == "node") {
+                    this.setIsets(nodejs.node[nodejs.jIndex[i][1]], node.children[i]);
+                }
+                if(nodejs.jIndex[i][0] == "outcome") {
+                    this.setIsets(nodejs.outcome[nodejs.jIndex[i][1]], node.children[i]);
+                }
+            }
+        }
+    };
+
+    Tools.prototype.mergeIsets = function (nodejs, node) {
+        if(node.iset != GTE.tree.isets[nodejs.jAttr.iset] && nodejs.jAttr.iset != undefined){
+//            GTE.MODE = GTE.MODES.MERGE;
+            node.changeISet(GTE.tree.isets[nodejs.jAttr.iset]);
+            GTE.tree.draw();
+//            GTE.tree.merge(node.iset, GTE.tree.isets[nodejs.jAttr.iset]);
+        }
+        if(nodejs.jIndex != undefined) {
+            for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
+                if(nodejs.jIndex[i][0] == "node") {
+                    this.mergeIsets(nodejs.node[nodejs.jIndex[i][1]], node.children[i]);
+                }
+                if(nodejs.jIndex[i][0] == "outcome") {
+                //    this.mergeIsets(nodejs.outcome[nodejs.jIndex[i][1]], node.children[i]);
+                }
+            }
+        }
+    };
+
     // Add class to parent module
     parentModule.Tools = Tools;
 

From 8311c3eb2cbaa7cef9e87a3ac91dfe819dc29ab3 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Wed, 8 Jun 2016 18:51:29 +0530
Subject: [PATCH 39/63] Shifted importing functionality to xmlImporter class

---
 html/index.html                    |  1 +
 html/js/guiutils/Tools.js          | 23 ++--------
 html/js/xmlimporter/XmlImporter.js | 71 ++++++++++++++++++++++++++++++
 3 files changed, 75 insertions(+), 20 deletions(-)
 create mode 100644 html/js/xmlimporter/XmlImporter.js

diff --git a/html/index.html b/html/index.html
index 80f25cd..118f660 100644
--- a/html/index.html
+++ b/html/index.html
@@ -109,5 +109,6 @@
         <script src="js/tree/Tree.js"></script>
         <script src="js/tree/Node.js"></script>
         <script src="js/main.js"></script>
+        <script src="js/xmlimporter/XmlImporter.js"></script>
     </body>
 </html>
diff --git a/html/js/guiutils/Tools.js b/html/js/guiutils/Tools.js
index 65c8547..41c5de5 100644
--- a/html/js/guiutils/Tools.js
+++ b/html/js/guiutils/Tools.js
@@ -39,26 +39,9 @@ GTE.UI = (function (parentModule) {
     * to the xml data received.
     */
     Tools.prototype.loadTree = function(xml) {
-        var jsTree = X2J.parseXml(xml);
-        var tree = jsTree[0].gte[0];
-        var display = tree.display[0];
-        this.resetPlayers(1);
-        this.activePlayer = -1;
-        this.isetToolsRan = true;
-        var root = new GTE.TREE.Node(null);
-        GTE.tree = new GTE.TREE.Tree(root);
-        this.addChancePlayer();
-        this.setPlayers(display.color, tree.players[0].player);
-        this.setDisplayProperties(display);
-        this.createTree(tree.extensiveForm[0].node[0], root);
-        root.assignPlayer(GTE.tree.players[tree.extensiveForm[0].node[0].jAttr.player]);
-        tree.extensiveForm[0].node[0].jAttr.iset = 0;
-   ///     this.setIsets(tree.extensiveForm[0].node[0], root);
-        GTE.tree.initializeISets();
-        GTE.tree.draw();
-        this.mergeIsets(tree.extensiveForm[0].node[0], root);
-        GTE.tree.draw();
-        this.switchMode(GTE.MODES.ADD);
+        var importer = new GTE.TREE.XmlImporter(xml);
+        importer.parseXmlToJson();
+        importer.loadTree();
     };
 
     /**
diff --git a/html/js/xmlimporter/XmlImporter.js b/html/js/xmlimporter/XmlImporter.js
new file mode 100644
index 0000000..f92b86f
--- /dev/null
+++ b/html/js/xmlimporter/XmlImporter.js
@@ -0,0 +1,71 @@
+GTE.TREE = (function(parentModule) {
+    "use strict";
+
+    /**
+     * Creates a new XmlImporter.
+     * @class
+     * @param {xml} : Data in xml format
+     */
+    function XmlImporter(xml) {
+        this.xml = xml;
+        this.json = null;
+    }
+
+    XmlImporter.prototype.parseXmlToJson = function() {
+        this.json = X2J.parseXml(this.xml);
+    };
+
+    XmlImporter.prototype.loadTree = function() {
+        var tree = this.json[0].gte[0];
+        var display = this.json[0].gte[0].display[0];
+        GTE.tools.resetPlayers(1);
+        GTE.tools.activePlayer = -1;
+        GTE.tools.isetToolsRan = false;
+        var root = new GTE.TREE.Node(null);
+        GTE.tree = new GTE.TREE.Tree(root);
+        GTE.tools.addChancePlayer();
+        GTE.tools.setPlayers(display.color, tree.players[0].player);
+        GTE.tools.setDisplayProperties(display);
+        this.createTree(tree.extensiveForm[0].node[0], root);
+        root.assignPlayer(GTE.tree.players[tree.extensiveForm[0].node[0].jAttr.player]);
+        GTE.tools.switchMode(GTE.MODES.MERGE);
+        GTE.tree.draw();
+        GTE.tools.switchMode(GTE.MODES.ADD);
+    };
+
+    /**
+    * Builds the sub-tree for the variable @node
+    */
+    XmlImporter.prototype.createRecursiveTree = function(node, father) {
+        var currentNode = GTE.tree.addChildNodeTo( father, GTE.tree.players[node.jAttr.player] );
+        for( var i = 0 ; i < node.jIndex.length ; i++) {
+            if(node.jIndex[i][0] == "node") {
+                this.createRecursiveTree(node.node[node.jIndex[i][1]], currentNode);
+            }
+            if(node.jIndex[i][0] == "outcome") {
+                GTE.tree.addChildNodeTo(currentNode, GTE.tree.players[node.outcome[node.jIndex[i][1]].jAttr.player]);
+            }
+        }
+    };
+
+    /**
+    * Function to create nodes of the laoded tree
+    */
+    XmlImporter.prototype.createTree = function(node, root) {
+        //  var root = new GTE.TREE.Node(null, node.jAttr.player);
+        for( var i = 0 ; i < node.jIndex.length ; i++) {
+            if(node.jIndex[i][0] == "node") {
+                this.createRecursiveTree(node.node[node.jIndex[i][1]], root);
+            }
+            if(node.jIndex[i][0] == "outcome") {
+                GTE.tree.addChildNodeTo(root, GTE.tree.players[node.outcome[node.jIndex[i][1]].jAttr.player]);
+            }
+        }
+        return root;
+    };
+
+    // Add class to parent module
+    parentModule.XmlImporter = XmlImporter;
+
+    return parentModule;
+}(GTE.TREE)); // Add to GTE.TREE sub-module

From 95a2035bb3da6cd96d8c936e2bcf18d0ed890ba6 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Thu, 9 Jun 2016 22:56:03 +0530
Subject: [PATCH 40/63] Shifted iset setting functions to xmlImporter

---
 html/js/guiutils/Tools.js          |  8 ++--
 html/js/xmlimporter/XmlImporter.js | 59 +++++++++++++++++++++++++++++-
 2 files changed, 62 insertions(+), 5 deletions(-)

diff --git a/html/js/guiutils/Tools.js b/html/js/guiutils/Tools.js
index 41c5de5..1bcdabf 100644
--- a/html/js/guiutils/Tools.js
+++ b/html/js/guiutils/Tools.js
@@ -333,17 +333,17 @@ GTE.UI = (function (parentModule) {
         }
     };
 
-    Tools.prototype.mergeIsets = function (nodejs, node) {
-        if(node.iset != GTE.tree.isets[nodejs.jAttr.iset] && nodejs.jAttr.iset != undefined){
+    Tools.prototype.mergeIsets = function (nodejs, node, listOfIsets) {
+        if(node.iset != listOfIsets[nodejs.jAttr.iset] && nodejs.jAttr.iset != undefined){
 //            GTE.MODE = GTE.MODES.MERGE;
-            node.changeISet(GTE.tree.isets[nodejs.jAttr.iset]);
+            node.changeISet(listOfisets[nodejs.jAttr.iset]);
             GTE.tree.draw();
 //            GTE.tree.merge(node.iset, GTE.tree.isets[nodejs.jAttr.iset]);
         }
         if(nodejs.jIndex != undefined) {
             for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
                 if(nodejs.jIndex[i][0] == "node") {
-                    this.mergeIsets(nodejs.node[nodejs.jIndex[i][1]], node.children[i]);
+                    this.mergeIsets(nodejs.node[nodejs.jIndex[i][1]], node.children[i], listOfIsets);
                 }
                 if(nodejs.jIndex[i][0] == "outcome") {
                 //    this.mergeIsets(nodejs.outcome[nodejs.jIndex[i][1]], node.children[i]);
diff --git a/html/js/xmlimporter/XmlImporter.js b/html/js/xmlimporter/XmlImporter.js
index f92b86f..e387ab6 100644
--- a/html/js/xmlimporter/XmlImporter.js
+++ b/html/js/xmlimporter/XmlImporter.js
@@ -28,8 +28,11 @@ GTE.TREE = (function(parentModule) {
         GTE.tools.setDisplayProperties(display);
         this.createTree(tree.extensiveForm[0].node[0], root);
         root.assignPlayer(GTE.tree.players[tree.extensiveForm[0].node[0].jAttr.player]);
-        GTE.tools.switchMode(GTE.MODES.MERGE);
+        //GTE.tools.switchMode(GTE.MODES.MERGE);
+        this.setIsets(tree.extensiveForm[0].node[0], root);
         GTE.tree.draw();
+        var listOfIsets = this.getListOfIsets(tree.extensiveForm[0].node[0], root);
+        this.mergeIsets(tree.extensiveForm[0].node[0], root, listOfIsets);
         GTE.tools.switchMode(GTE.MODES.ADD);
     };
 
@@ -64,6 +67,60 @@ GTE.TREE = (function(parentModule) {
         return root;
     };
 
+    /**
+    * Function to create nodes of the laoded tree
+    */
+    XmlImporter.prototype.setIsets = function(nodejs, node) {
+        GTE.tree.createSingletonISet(node);
+        if(nodejs.jIndex != undefined) {
+            for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
+                if(nodejs.jIndex[i][0] == "node") {
+                    this.setIsets(nodejs.node[nodejs.jIndex[i][1]], node.children[i]);
+                }
+                if(nodejs.jIndex[i][0] == "outcome") {
+                    this.setIsets(nodejs.outcome[nodejs.jIndex[i][1]], node.children[i]);
+                }
+            }
+        }
+    };
+
+    /**
+    * Function that returns a list of isets
+    */
+    XmlImporter.prototype.getListOfIsets = function(nodejs, node) {
+        var list = [node.iset];
+        if(nodejs.jIndex != undefined) {
+            for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
+                if(nodejs.jIndex[i][0] == "node") {
+                    list = list.concat(this.getListOfIsets(nodejs.node[nodejs.jIndex[i][1]], node.children[i]));
+                }
+                if(nodejs.jIndex[i][0] == "outcome") {
+                    list = list.concat((this.getListOfIsets(nodejs.outcome[nodejs.jIndex[i][1]], node.children[i])));
+                }
+            }
+        }
+        return list;
+    };
+
+    XmlImporter.prototype.mergeIsets = function (nodejs, node, listOfIsets) {
+        if(node.iset != listOfIsets[nodejs.jAttr.iset] && nodejs.jAttr.iset != undefined){
+            var currentIset = node.iset;
+            node.changeISet(listOfIsets[nodejs.jAttr.iset]);
+            listOfIsets.splice(listOfIsets.indexOf(currentIset), 1);
+            GTE.tree.draw();
+        }
+        if(nodejs.jIndex != undefined) {
+            for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
+                if(nodejs.jIndex[i][0] == "node") {
+                    this.mergeIsets(nodejs.node[nodejs.jIndex[i][1]], node.children[i], listOfIsets);
+                }
+                if(nodejs.jIndex[i][0] == "outcome") {
+                //    this.mergeIsets(nodejs.outcome[nodejs.jIndex[i][1]], node.children[i]);
+                }
+            }
+        }
+    };
+
     // Add class to parent module
     parentModule.XmlImporter = XmlImporter;
 

From 57d01427b299ac4b706fc40d0d697527e80c2ae5 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Sat, 11 Jun 2016 02:23:33 +0530
Subject: [PATCH 41/63] Assigned payoffs from loaded data

---
 html/js/xmlimporter/XmlImporter.js | 33 +++++++++++++++++++++++++++---
 1 file changed, 30 insertions(+), 3 deletions(-)

diff --git a/html/js/xmlimporter/XmlImporter.js b/html/js/xmlimporter/XmlImporter.js
index e387ab6..39526fd 100644
--- a/html/js/xmlimporter/XmlImporter.js
+++ b/html/js/xmlimporter/XmlImporter.js
@@ -29,10 +29,14 @@ GTE.TREE = (function(parentModule) {
         this.createTree(tree.extensiveForm[0].node[0], root);
         root.assignPlayer(GTE.tree.players[tree.extensiveForm[0].node[0].jAttr.player]);
         //GTE.tools.switchMode(GTE.MODES.MERGE);
-        this.setIsets(tree.extensiveForm[0].node[0], root);
+        if (GTE.tools.ableToSwitchToISetEditingMode()) {
+            GTE.tree.initializeISets();
+            this.isetToolsRan = true;
+            var listOfIsets = this.getListOfIsets(tree.extensiveForm[0].node[0], root);
+            this.mergeIsets(tree.extensiveForm[0].node[0], root, listOfIsets);
+            this.assignPayoffs(tree.extensiveForm[0].node[0], root);
+        }
         GTE.tree.draw();
-        var listOfIsets = this.getListOfIsets(tree.extensiveForm[0].node[0], root);
-        this.mergeIsets(tree.extensiveForm[0].node[0], root, listOfIsets);
         GTE.tools.switchMode(GTE.MODES.ADD);
     };
 
@@ -121,6 +125,29 @@ GTE.TREE = (function(parentModule) {
         }
     };
 
+    XmlImporter.prototype.assignPayoffs = function (nodejs, node, listOfIsets) {
+        if(nodejs.jIndex != undefined) {
+            for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
+                if(nodejs.jIndex[i][0] == "node") {
+                    this.assignPayoffs(nodejs.node[nodejs.jIndex[i][1]], node.children[i], listOfIsets);
+                }
+                if(nodejs.jIndex[i][0] == "outcome") {
+                    var outcome = nodejs.outcome[nodejs.jIndex[i][1]];
+                    for(var j = 0; j<outcome.payoff.length;j++) {
+                        var index = GTE.tree.players[outcome.payoff[j].jAttr.player].payoffs.map(function(el) {
+                          return el.leaf;
+                        }).indexOf(node.children[i]);
+
+                        if(index != -1) {
+                            GTE.tree.players[outcome.payoff[j].jAttr.player].payoffs[index].setValue(outcome.payoff[j].jValue);
+                            GTE.tree.players[outcome.payoff[j].jAttr.player].payoffs[index].changeText(outcome.payoff[j].jValue);
+                        }
+                    }
+                }
+            }
+        }
+    };
+
     // Add class to parent module
     parentModule.XmlImporter = XmlImporter;
 

From 028e804ebcad9bdc0cce1f4377d538245122d763 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Sun, 12 Jun 2016 15:55:13 +0530
Subject: [PATCH 42/63] Assigned Moves to imported tree

---
 html/js/xmlimporter/XmlImporter.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/html/js/xmlimporter/XmlImporter.js b/html/js/xmlimporter/XmlImporter.js
index 39526fd..4c9392c 100644
--- a/html/js/xmlimporter/XmlImporter.js
+++ b/html/js/xmlimporter/XmlImporter.js
@@ -34,6 +34,7 @@ GTE.TREE = (function(parentModule) {
             this.isetToolsRan = true;
             var listOfIsets = this.getListOfIsets(tree.extensiveForm[0].node[0], root);
             this.mergeIsets(tree.extensiveForm[0].node[0], root, listOfIsets);
+            this.assignMoves(tree.extensiveForm[0].node[0], root);
             this.assignPayoffs(tree.extensiveForm[0].node[0], root);
         }
         GTE.tree.draw();
@@ -125,6 +126,18 @@ GTE.TREE = (function(parentModule) {
         }
     };
 
+    XmlImporter.prototype.assignMoves = function (nodejs, node) {
+        for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
+            if(nodejs.jIndex[i][0] == "node") {
+                node.iset.moves[i].name = nodejs.node[nodejs.jIndex[i][1]].jAttr.move;
+                this.assignMoves(nodejs.node[nodejs.jIndex[i][1]], node.children[i]);
+            }
+            if(nodejs.jIndex[i][0] == "outcome") {
+                node.iset.moves[i].name = nodejs.outcome[nodejs.jIndex[i][1]].jAttr.move;
+            }
+        }
+    };
+
     XmlImporter.prototype.assignPayoffs = function (nodejs, node, listOfIsets) {
         if(nodejs.jIndex != undefined) {
             for( var i = 0 ; i < nodejs.jIndex.length ; i++) {

From 79712dbb7ff34792b73cd05ecc731aad7f9cd02e Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <bvonstengel@gmail.com>
Date: Mon, 13 Jun 2016 14:27:49 +0100
Subject: [PATCH 43/63] git docu, working with remote

---
 INFOS/ongit.md | 151 +++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 147 insertions(+), 4 deletions(-)

diff --git a/INFOS/ongit.md b/INFOS/ongit.md
index 3022eea..b448456 100644
--- a/INFOS/ongit.md
+++ b/INFOS/ongit.md
@@ -1,8 +1,151 @@
-## Commits and Pull Requests
+# Using git with jsgte
 
-Follow the guidelines at
+This is on introductory stuff everyone must know.
+
+Our repository on github:
+https://github.com/gambitproject/jsgte
+
+## Basics: Unix command line, recording in markdown
+
+### Unix command line basics
+
+We assume you can use the command line in Unix (Linux or
+MacOS).
+
+Basic operations to get started:
+Open terminal, get familiar with the most basic Unix commands 
+    
+    cd
+    ls
+    mv
+    cp
+
+start an editor you are familiar with (e.g. gedit on Linux),
+use TAB-completion, and have the prompt display your current
+working directory which can also be displayed with `pwd`.
+
+### Markdown files
+
+The minimal markup syntax ("markdown") is used in these
+documentation files with the ending .md such as this one.
+
+Please record any useful experiences you have into such a
+markdown file and add it to the INFOS/ directory.
+
+## Behaviour of the main webpage and creating the branch `gh-pages`
+
+The main file is in
+
+    ./html/index.html
+
+which loads as a webpage and its JS functionality as a file
+on your local computer, for example.
+
+However, on github this page will be displayed as code.
+
+In order to display its behaviour on github, a special
+branch called
+
+    gh-pages
+
+has to be created, which has the URL
+http://gambitproject.github.io/jsgte/
+
+To update this when changes happen to master use 
+
+  `ghp-import -p html`
+
+This moves the directory `html`, which contains
+`index.html`, to the root of the branch `gh-pages`.
+For more details see
+
+https://help.github.com/categories/github-pages-basics/
+
+On Linux you can install ghp-import via 
+
+  `pip install ghp-import`
+
+## Git
+
+### Documentation about git
+
+Short intro to git (very useful and essential): http://gitref.org/
+
+
+Long intro to git: https://git-scm.com/book/en/v2
+
+### Cloning the directory with git
+
+I prefer to use the ssh (secure shell) based interaction
+with the remote which makes most authentication automatic.
+
+Clone the repository from github
+
+    git clone git@github.com:gambitproject/jsgte.git
+
+which will create the directore `jsgte`
+
+### Branches
+
+create your own branch with 
+
+    git branch my-test-branch
+
+and work on it with 
+
+    git checkout my-test-branch
+
+The list of all branches is visible with
+
+    git branch -a
+
+### Basic git operation
+
+Make sure you know which branch you work on, listed with
+
+    git branch
+
+Modify your program and files. Information about them is
+listed with
+
+    git status
+
+The basic cycle is then
+
+    git add file
+    git commit
+
+and to include a message directly with the commit with
+    
+    git commit -m "my commit message" 
+
+Note that all your work is local on your computer.
+
+### Synchronization with the remote repository on github
+
+Be careful not to commit on the master branch!
+See the guidelines of the JQUERY foundation at
 http://contribute.jquery.org/commits-and-pull-requests/
 
-git commit with message
+### Testing other remote work
+
+Example: Harkirat has created a branch named
+`load-functionality` and wants me to test it.
+
+I first create such a branch locally, and switch to it, with
+
+    git checkout -b load-functionality
+
+I then try to get the corresponding information from
+Harkirat's repository with
+
+    git pull git@github.com:hkirat/jsgte.git load-functionality
+
+and in response it asks me "please tell me who you are",
+presumably so Harkirat knows who copied from his directory.
+I do this with some configuration that seemed to have been
+lost (including on my editor `vim`).
 
-git commit -m "my commit message" file
+    git config --global user.email "bvonstengel@gmail.com"
+    git config --global user.name "Bernhard von Stengel"
+    git config --global core.editor vim

From e4c71de0397e0ae4fb7f5c6d794205b791589371 Mon Sep 17 00:00:00 2001
From: Bernhard von Stengel <bvonstengel@gmail.com>
Date: Mon, 13 Jun 2016 14:34:12 +0100
Subject: [PATCH 44/63] minor chg of git info file

---
 INFOS/ongit.md | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/INFOS/ongit.md b/INFOS/ongit.md
index b448456..45e5ceb 100644
--- a/INFOS/ongit.md
+++ b/INFOS/ongit.md
@@ -74,7 +74,7 @@ Short intro to git (very useful and essential): http://gitref.org/
 
 Long intro to git: https://git-scm.com/book/en/v2
 
-### Cloning the directory with git
+### Cloning the repository 
 
 I prefer to use the ssh (secure shell) based interaction
 with the remote which makes most authentication automatic.
@@ -83,7 +83,8 @@ Clone the repository from github
 
     git clone git@github.com:gambitproject/jsgte.git
 
-which will create the directore `jsgte`
+which will create the directory `jsgte` in your current
+directory.
 
 ### Branches
 
@@ -123,6 +124,9 @@ Note that all your work is local on your computer.
 
 ### Synchronization with the remote repository on github
 
+(More details on how to push a newly created branch.
+Creating it on github first seems the simplest.)
+
 Be careful not to commit on the master branch!
 See the guidelines of the JQUERY foundation at
 http://contribute.jquery.org/commits-and-pull-requests/
@@ -143,8 +147,10 @@ Harkirat's repository with
 
 and in response it asks me "please tell me who you are",
 presumably so Harkirat knows who copied from his directory.
-I do this with some configuration that seemed to have been
-lost (including on my editor `vim`).
+I do this with some configuration that was lost (including
+on my editor `vim`) when I started over by cloning the
+repository after some mess-up. So do this first (with your
+own configuration data of course :-) :
 
     git config --global user.email "bvonstengel@gmail.com"
     git config --global user.name "Bernhard von Stengel"

From d00c4240bd54c030d33f59a40f3ecd85bb7e63e0 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Tue, 14 Jun 2016 20:25:42 +0530
Subject: [PATCH 45/63] Added functions to check if a node is chance Node

---
 html/js/xmlimporter/XmlImporter.js | 72 +++++++++++++++++++++++++-----
 1 file changed, 62 insertions(+), 10 deletions(-)

diff --git a/html/js/xmlimporter/XmlImporter.js b/html/js/xmlimporter/XmlImporter.js
index 4c9392c..3dad9bf 100644
--- a/html/js/xmlimporter/XmlImporter.js
+++ b/html/js/xmlimporter/XmlImporter.js
@@ -27,12 +27,11 @@ GTE.TREE = (function(parentModule) {
         GTE.tools.setPlayers(display.color, tree.players[0].player);
         GTE.tools.setDisplayProperties(display);
         this.createTree(tree.extensiveForm[0].node[0], root);
-        root.assignPlayer(GTE.tree.players[tree.extensiveForm[0].node[0].jAttr.player]);
-        //GTE.tools.switchMode(GTE.MODES.MERGE);
+        this.assignChancePlayers(tree.extensiveForm[0].node[0], root);
         if (GTE.tools.ableToSwitchToISetEditingMode()) {
             GTE.tree.initializeISets();
             this.isetToolsRan = true;
-            var listOfIsets = this.getListOfIsets(tree.extensiveForm[0].node[0], root);
+            var listOfIsets = this.getListOfIsets(tree.extensiveForm[0].node[0], root, {});
             this.mergeIsets(tree.extensiveForm[0].node[0], root, listOfIsets);
             this.assignMoves(tree.extensiveForm[0].node[0], root);
             this.assignPayoffs(tree.extensiveForm[0].node[0], root);
@@ -45,7 +44,10 @@ GTE.TREE = (function(parentModule) {
     * Builds the sub-tree for the variable @node
     */
     XmlImporter.prototype.createRecursiveTree = function(node, father) {
-        var currentNode = GTE.tree.addChildNodeTo( father, GTE.tree.players[node.jAttr.player] );
+        var index = GTE.tree.players.map(function(el) {
+                          return el.name;
+                        }).indexOf(node.jAttr.player);
+        var currentNode = GTE.tree.addChildNodeTo(father, GTE.tree.players[index]);
         for( var i = 0 ; i < node.jIndex.length ; i++) {
             if(node.jIndex[i][0] == "node") {
                 this.createRecursiveTree(node.node[node.jIndex[i][1]], currentNode);
@@ -60,6 +62,10 @@ GTE.TREE = (function(parentModule) {
     * Function to create nodes of the laoded tree
     */
     XmlImporter.prototype.createTree = function(node, root) {
+        var index = GTE.tree.players.map(function(el) {
+                  return el.name;
+                }).indexOf(node.jAttr.player);
+        root.assignPlayer(GTE.tree.players[index]);
         //  var root = new GTE.TREE.Node(null, node.jAttr.player);
         for( var i = 0 ; i < node.jIndex.length ; i++) {
             if(node.jIndex[i][0] == "node") {
@@ -72,6 +78,50 @@ GTE.TREE = (function(parentModule) {
         return root;
     };
 
+
+    /**
+    * Function to assign Chance Players to Nodes recursively
+    */
+    XmlImporter.prototype.assignRecursiveChancePlayers = function(nodejs, node) {
+        if(this.isChanceNode(nodejs)) {
+            node.assignPlayer(GTE.tree.players[0]);
+        }
+        for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
+            if(nodejs.jIndex[i][0] == "node") {
+                this.assignRecursiveChancePlayers(nodejs.node[nodejs.jIndex[i][1]], node.children[i]);
+            }
+        }
+    };
+
+    /**
+    * Function to assign Chance Players to Nodes
+    */
+    XmlImporter.prototype.assignChancePlayers = function(node, root) {
+        if(this.isChanceNode(node)) {
+            root.assignPlayer(GTE.tree.players[0]);
+        }
+        //  var root = new GTE.TREE.Node(null, node.jAttr.player);
+        for( var i = 0 ; i < node.jIndex.length ; i++) {
+            if(node.jIndex[i][0] == "node") {
+                this.assignRecursiveChancePlayers(node.node[node.jIndex[i][1]], root.children[i]);
+            }
+        }
+    };
+
+    XmlImporter.prototype.isChanceNode = function(node) {
+        for( var i = 0 ; i < node.jIndex.length ; i++) {
+            if(node.jIndex[i][0] == "node") {
+                if(node.node[node.jIndex[i][1]].jAttr.prob != undefined)
+                    return true;
+            }
+            if(node.jIndex[i][0] == "outcome") {
+                if(node.outcome[node.jIndex[i][1]].jAttr.prob != undefined)
+                    return true;
+            }
+        }
+        return false;
+    };
+
     /**
     * Function to create nodes of the laoded tree
     */
@@ -92,15 +142,17 @@ GTE.TREE = (function(parentModule) {
     /**
     * Function that returns a list of isets
     */
-    XmlImporter.prototype.getListOfIsets = function(nodejs, node) {
-        var list = [node.iset];
+    XmlImporter.prototype.getListOfIsets = function(nodejs, node, list) {
+        if(nodejs.jAttr.iset != undefined) {
+            if(list[nodejs.jAttr.iset] == undefined){
+                list[nodejs.jAttr.iset] = [];
+            }
+            list[nodejs.jAttr.iset].push(node);
+        }
         if(nodejs.jIndex != undefined) {
             for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
                 if(nodejs.jIndex[i][0] == "node") {
-                    list = list.concat(this.getListOfIsets(nodejs.node[nodejs.jIndex[i][1]], node.children[i]));
-                }
-                if(nodejs.jIndex[i][0] == "outcome") {
-                    list = list.concat((this.getListOfIsets(nodejs.outcome[nodejs.jIndex[i][1]], node.children[i])));
+                    list = this.getListOfIsets(nodejs.node[nodejs.jIndex[i][1]], node.children[i], list);
                 }
             }
         }

From 8b6c0944f9e62955e48adec815742318662ce538 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Tue, 14 Jun 2016 21:13:13 +0530
Subject: [PATCH 46/63] Modified mergeIset Function

---
 html/js/xmlimporter/XmlImporter.js | 26 ++++++++------------------
 1 file changed, 8 insertions(+), 18 deletions(-)

diff --git a/html/js/xmlimporter/XmlImporter.js b/html/js/xmlimporter/XmlImporter.js
index 3dad9bf..6cc9521 100644
--- a/html/js/xmlimporter/XmlImporter.js
+++ b/html/js/xmlimporter/XmlImporter.js
@@ -32,9 +32,9 @@ GTE.TREE = (function(parentModule) {
             GTE.tree.initializeISets();
             this.isetToolsRan = true;
             var listOfIsets = this.getListOfIsets(tree.extensiveForm[0].node[0], root, {});
-            this.mergeIsets(tree.extensiveForm[0].node[0], root, listOfIsets);
-            this.assignMoves(tree.extensiveForm[0].node[0], root);
-            this.assignPayoffs(tree.extensiveForm[0].node[0], root);
+            this.mergeIsets(listOfIsets);
+        //    this.assignMoves(tree.extensiveForm[0].node[0], root);
+        //    this.assignPayoffs(tree.extensiveForm[0].node[0], root);
         }
         GTE.tree.draw();
         GTE.tools.switchMode(GTE.MODES.ADD);
@@ -159,21 +159,11 @@ GTE.TREE = (function(parentModule) {
         return list;
     };
 
-    XmlImporter.prototype.mergeIsets = function (nodejs, node, listOfIsets) {
-        if(node.iset != listOfIsets[nodejs.jAttr.iset] && nodejs.jAttr.iset != undefined){
-            var currentIset = node.iset;
-            node.changeISet(listOfIsets[nodejs.jAttr.iset]);
-            listOfIsets.splice(listOfIsets.indexOf(currentIset), 1);
-            GTE.tree.draw();
-        }
-        if(nodejs.jIndex != undefined) {
-            for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
-                if(nodejs.jIndex[i][0] == "node") {
-                    this.mergeIsets(nodejs.node[nodejs.jIndex[i][1]], node.children[i], listOfIsets);
-                }
-                if(nodejs.jIndex[i][0] == "outcome") {
-                //    this.mergeIsets(nodejs.outcome[nodejs.jIndex[i][1]], node.children[i]);
-                }
+    XmlImporter.prototype.mergeIsets = function (listOfIsets) {
+        for (var index in listOfIsets) {
+            for(var i = 1; i<listOfIsets[index].length; i++) {
+                listOfIsets[index][i].changeISet(listOfIsets[index][0].iset);
+                GTE.tree.draw();
             }
         }
     };

From 73d547bea65488ffddfc767db9d87eeb99493ae9 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Tue, 14 Jun 2016 21:31:40 +0530
Subject: [PATCH 47/63] Fixed assignPayoff function

---
 html/js/xmlimporter/XmlImporter.js | 26 ++++++++++++++++++--------
 1 file changed, 18 insertions(+), 8 deletions(-)

diff --git a/html/js/xmlimporter/XmlImporter.js b/html/js/xmlimporter/XmlImporter.js
index 6cc9521..5a15697 100644
--- a/html/js/xmlimporter/XmlImporter.js
+++ b/html/js/xmlimporter/XmlImporter.js
@@ -33,8 +33,8 @@ GTE.TREE = (function(parentModule) {
             this.isetToolsRan = true;
             var listOfIsets = this.getListOfIsets(tree.extensiveForm[0].node[0], root, {});
             this.mergeIsets(listOfIsets);
-        //    this.assignMoves(tree.extensiveForm[0].node[0], root);
-        //    this.assignPayoffs(tree.extensiveForm[0].node[0], root);
+            this.assignMoves(tree.extensiveForm[0].node[0], root);
+            this.assignPayoffs(tree.extensiveForm[0].node[0], root);
         }
         GTE.tree.draw();
         GTE.tools.switchMode(GTE.MODES.ADD);
@@ -171,11 +171,19 @@ GTE.TREE = (function(parentModule) {
     XmlImporter.prototype.assignMoves = function (nodejs, node) {
         for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
             if(nodejs.jIndex[i][0] == "node") {
-                node.iset.moves[i].name = nodejs.node[nodejs.jIndex[i][1]].jAttr.move;
+                if(nodejs.node[nodejs.jIndex[i][1]].jAttr.prob != undefined) {
+                    node.iset.moves[i].name = nodejs.node[nodejs.jIndex[i][1]].jAttr.prob;
+                } else {
+                    node.iset.moves[i].name = nodejs.node[nodejs.jIndex[i][1]].jAttr.move;    
+                }
                 this.assignMoves(nodejs.node[nodejs.jIndex[i][1]], node.children[i]);
             }
             if(nodejs.jIndex[i][0] == "outcome") {
-                node.iset.moves[i].name = nodejs.outcome[nodejs.jIndex[i][1]].jAttr.move;
+                if(nodejs.outcome[nodejs.jIndex[i][1]].jAttr.prob != undefined ) {
+                    node.iset.moves[i].name = nodejs.outcome[nodejs.jIndex[i][1]].jAttr.prob;
+                } else  {
+                    node.iset.moves[i].name = nodejs.outcome[nodejs.jIndex[i][1]].jAttr.move;
+                }
             }
         }
     };
@@ -189,13 +197,15 @@ GTE.TREE = (function(parentModule) {
                 if(nodejs.jIndex[i][0] == "outcome") {
                     var outcome = nodejs.outcome[nodejs.jIndex[i][1]];
                     for(var j = 0; j<outcome.payoff.length;j++) {
-                        var index = GTE.tree.players[outcome.payoff[j].jAttr.player].payoffs.map(function(el) {
+                        var index1 = GTE.tree.players.map(function(el) {
+                          return el.name;
+                        }).indexOf(outcome.payoff[j].jAttr.player);
+                        var index = GTE.tree.players[index1].payoffs.map(function(el) {
                           return el.leaf;
                         }).indexOf(node.children[i]);
-
                         if(index != -1) {
-                            GTE.tree.players[outcome.payoff[j].jAttr.player].payoffs[index].setValue(outcome.payoff[j].jValue);
-                            GTE.tree.players[outcome.payoff[j].jAttr.player].payoffs[index].changeText(outcome.payoff[j].jValue);
+                            GTE.tree.players[index1].payoffs[index].setValue(outcome.payoff[j].jValue);
+                            GTE.tree.players[index1].payoffs[index].changeText(outcome.payoff[j].jValue);
                         }
                     }
                 }

From e04b9138c814016f63824a3703581156615b871a Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Wed, 15 Jun 2016 03:14:44 +0530
Subject: [PATCH 48/63] Added function to set text of moves

---
 html/js/tree/Move.js | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/html/js/tree/Move.js b/html/js/tree/Move.js
index d7b7d84..0c95b96 100644
--- a/html/js/tree/Move.js
+++ b/html/js/tree/Move.js
@@ -11,6 +11,7 @@ GTE.TREE = (function (parentModule) {
         this.name = name;
         this.atISet = atISet;
         this.line = {};
+        this.editable = null;
     }
 
     /**
@@ -126,7 +127,7 @@ GTE.TREE = (function (parentModule) {
         var contentEditable = new GTE.UI.Widgets.ContentEditable(
                         middleX, middleY, growingDirectionOfText, this.name, "move")
                         .colour(parent.player.colour);
-
+        this.editable = contentEditable;
         // ChanceMove inherits from Move so in order not to having to rewrite this
         // whole function, create a function with all that needs to be modified
         // by ChanceMove
@@ -156,6 +157,14 @@ GTE.TREE = (function (parentModule) {
         });
     };
 
+    /**
+     * Changes the text of the editable label
+     * @param {String} text New Move's text
+     */
+    Move.prototype.changeText = function(text) {
+        this.editable.setText("text");
+    };
+
     /**
     * Get current move position within the set of moves
     * @return {Number} index This move's index in the array of moves

From 6d912dc2efa3a8ba84fa6f6b07f8967e32e9384c Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Wed, 15 Jun 2016 03:19:57 +0530
Subject: [PATCH 49/63] Modified function assigning values to moves

---
 html/js/tree/Move.js               | 3 ++-
 html/js/xmlimporter/XmlImporter.js | 8 ++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/html/js/tree/Move.js b/html/js/tree/Move.js
index 0c95b96..fe84bcc 100644
--- a/html/js/tree/Move.js
+++ b/html/js/tree/Move.js
@@ -162,7 +162,8 @@ GTE.TREE = (function (parentModule) {
      * @param {String} text New Move's text
      */
     Move.prototype.changeText = function(text) {
-        this.editable.setText("text");
+        this.editable.setText(text);
+        this.changeName(text);
     };
 
     /**
diff --git a/html/js/xmlimporter/XmlImporter.js b/html/js/xmlimporter/XmlImporter.js
index 5a15697..676ad67 100644
--- a/html/js/xmlimporter/XmlImporter.js
+++ b/html/js/xmlimporter/XmlImporter.js
@@ -172,17 +172,17 @@ GTE.TREE = (function(parentModule) {
         for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
             if(nodejs.jIndex[i][0] == "node") {
                 if(nodejs.node[nodejs.jIndex[i][1]].jAttr.prob != undefined) {
-                    node.iset.moves[i].name = nodejs.node[nodejs.jIndex[i][1]].jAttr.prob;
+                    node.iset.moves[i].changeName(nodejs.node[nodejs.jIndex[i][1]].jAttr.prob);
                 } else {
-                    node.iset.moves[i].name = nodejs.node[nodejs.jIndex[i][1]].jAttr.move;    
+                    node.iset.moves[i].changeText(nodejs.node[nodejs.jIndex[i][1]].jAttr.move);
                 }
                 this.assignMoves(nodejs.node[nodejs.jIndex[i][1]], node.children[i]);
             }
             if(nodejs.jIndex[i][0] == "outcome") {
                 if(nodejs.outcome[nodejs.jIndex[i][1]].jAttr.prob != undefined ) {
-                    node.iset.moves[i].name = nodejs.outcome[nodejs.jIndex[i][1]].jAttr.prob;
+                    node.iset.moves[i].changeName(nodejs.outcome[nodejs.jIndex[i][1]].jAttr.prob);
                 } else  {
-                    node.iset.moves[i].name = nodejs.outcome[nodejs.jIndex[i][1]].jAttr.move;
+                    node.iset.moves[i].changeText(nodejs.outcome[nodejs.jIndex[i][1]].jAttr.move);
                 }
             }
         }

From a466ea166f2a6cfb2649d21c90f0c0d32231c8e1 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Thu, 16 Jun 2016 19:29:50 +0530
Subject: [PATCH 50/63] Added XmlExporter class

---
 html/js/xmlExporter/XmlExporter.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 html/js/xmlExporter/XmlExporter.js

diff --git a/html/js/xmlExporter/XmlExporter.js b/html/js/xmlExporter/XmlExporter.js
new file mode 100644
index 0000000..aa193b6
--- /dev/null
+++ b/html/js/xmlExporter/XmlExporter.js
@@ -0,0 +1,15 @@
+GTE.TREE = (function (parentModule) {
+    "use strict";
+
+    /**
+    * Creates a new xml Exporter
+    * @class
+    */
+    function XmlExporter() {
+
+    }
+
+    // Add class to parent module
+    parentModule.XmlExporter = XmlExporter;
+    return parentModule;
+}(GTE.TREE)); // Add to GTE.TREE sub-module

From 6b3879db32a7239c469be6871f4f676de76561ae Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Thu, 16 Jun 2016 20:18:47 +0530
Subject: [PATCH 51/63] Added buttons and basic exporting prototypes to
 XmlExporter class

---
 html/index.html                    |  2 ++
 html/js/main.js                    |  7 +++++
 html/js/xmlExporter/XmlExporter.js | 47 +++++++++++++++++++++++++++++-
 3 files changed, 55 insertions(+), 1 deletion(-)

diff --git a/html/index.html b/html/index.html
index 7566841..103d879 100644
--- a/html/index.html
+++ b/html/index.html
@@ -25,6 +25,7 @@
             <div>
                 <ul class="vertical-centered">
                     <li><button id="button-new" class="button button--sacnite button--inverted" alt="New game" title="New game"><i class="icon-file"></i></button></li>
+                    <li><button id="button-save" class="button button--sacnite button--inverted" alt="Save Game" title="Save game"><i class="icon-file"></i></button></li>
                 </ul>
             </div>
             <div>
@@ -103,5 +104,6 @@
         <script src="js/tree/Tree.js"></script>
         <script src="js/tree/Node.js"></script>
         <script src="js/main.js"></script>
+        <script src="js/xmlExporter/XmlExporter.js"></script>
     </body>
 </html>
diff --git a/html/js/main.js b/html/js/main.js
index 84abc8e..1653d21 100644
--- a/html/js/main.js
+++ b/html/js/main.js
@@ -79,6 +79,13 @@
         return false;
     });
 
+    document.getElementById("button-save").addEventListener("click", function(){
+        var exporter = new GTE.TREE.XmlExporter();
+        exporter.exportTree();
+        console.log(exporter.toString());
+        return false;
+    });
+
     document.getElementById("button-add").addEventListener("click", function(){
         GTE.tools.switchMode(GTE.MODES.ADD);
         return false;
diff --git a/html/js/xmlExporter/XmlExporter.js b/html/js/xmlExporter/XmlExporter.js
index aa193b6..32b7fe4 100644
--- a/html/js/xmlExporter/XmlExporter.js
+++ b/html/js/xmlExporter/XmlExporter.js
@@ -6,8 +6,53 @@ GTE.TREE = (function (parentModule) {
     * @class
     */
     function XmlExporter() {
+        this.tree = "";
+    };
 
-    }
+    XmlExporter.prototype.exportTree = function() {
+        this.exportGTE();
+    };
+
+    XmlExporter.prototype.exportGTE = function() {
+        this.startProperty("gte", {version : "0.1"}, 0);
+        this.endProperty("gte", 0);
+    };
+
+    XmlExporter.prototype.startProperty = function(property_name, parameters, tab) {
+        var append = this.assignTab(tab);
+        append += "<"+property_name+" ";
+        for(var parameter in parameters) {
+            append += parameter;
+            append += "=\"";
+            append += parameters[parameter];
+            append += "\"";
+            append += " ";
+        }
+        append += ">\n";
+        this.tree += append;
+    };
+
+    XmlExporter.prototype.endProperty = function(property_name, tab) {
+        var append = this.assignTab(tab);
+        append += "<"+property_name+">\n";
+        this.tree += append;
+    };
+
+    XmlExporter.prototype.assignTab = function(tab) {
+        var string = "";
+        for(var i = 0; i<tab; i++) {
+            string = string + "\t";
+        }
+        return string;
+    };
+
+    XmlExporter.prototype.exportDisplayProperties = function(tab_space) {
+
+    };
+
+    XmlExporter.prototype.toString = function() {
+        console.log(this.tree);
+    };
 
     // Add class to parent module
     parentModule.XmlExporter = XmlExporter;

From 9970368fa56cf930a867ef8de573397c244745d2 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Fri, 17 Jun 2016 06:29:35 +0530
Subject: [PATCH 52/63] Added display properties

---
 html/js/xmlExporter/XmlExporter.js | 43 ++++++++++++++++++++++++++----
 1 file changed, 38 insertions(+), 5 deletions(-)

diff --git a/html/js/xmlExporter/XmlExporter.js b/html/js/xmlExporter/XmlExporter.js
index 32b7fe4..9695007 100644
--- a/html/js/xmlExporter/XmlExporter.js
+++ b/html/js/xmlExporter/XmlExporter.js
@@ -15,18 +15,18 @@ GTE.TREE = (function (parentModule) {
 
     XmlExporter.prototype.exportGTE = function() {
         this.startProperty("gte", {version : "0.1"}, 0);
+        this.exportDisplayProperties();
         this.endProperty("gte", 0);
     };
 
-    XmlExporter.prototype.startProperty = function(property_name, parameters, tab) {
+    XmlExporter.prototype.startProperty = function(property_name, parameters, tab, body) {
         var append = this.assignTab(tab);
-        append += "<"+property_name+" ";
+        append += "<"+property_name;
         for(var parameter in parameters) {
-            append += parameter;
+            append += (" "+parameter);
             append += "=\"";
             append += parameters[parameter];
             append += "\"";
-            append += " ";
         }
         append += ">\n";
         this.tree += append;
@@ -34,10 +34,17 @@ GTE.TREE = (function (parentModule) {
 
     XmlExporter.prototype.endProperty = function(property_name, tab) {
         var append = this.assignTab(tab);
-        append += "<"+property_name+">\n";
+        append += "</"+property_name+">\n";
         this.tree += append;
     };
 
+    XmlExporter.prototype.addBody = function(property_name, tab) {
+        var append = this.assignTab(tab);
+        append += property_name+"\n";
+        this.tree += append;
+    };
+
+
     XmlExporter.prototype.assignTab = function(tab) {
         var string = "";
         for(var i = 0; i<tab; i++) {
@@ -47,7 +54,33 @@ GTE.TREE = (function (parentModule) {
     };
 
     XmlExporter.prototype.exportDisplayProperties = function(tab_space) {
+        this.startProperty("display", {}, 1);
+        for(var i = 1; i<GTE.tree.players.length; i++) {
+            this.startProperty("color", {player : i}, 2);
+            this.addBody(GTE.tree.players[i].colour, 3);
+            this.endProperty("color", 2);
+        }
+        this.startProperty("font", {}, 2);
+        this.addBody("Times", 3);
+        this.endProperty("font", 2);
+
+        this.startProperty("strokeWidth", {}, 2);
+        this.addBody(GTE.STORAGE.settingsLineThickness, 3);
+        this.endProperty("strokeWidth", 2);
+
+        this.startProperty("nodeDiameter", {}, 2);
+        this.addBody(GTE.STORAGE.settingsCircleSize, 3);
+        this.endProperty("nodeDiameter", 2);
+
+        this.startProperty("isetDiameter", {}, 2);
+        this.addBody(GTE.STORAGE.settingsLineThickness, 3);
+        this.endProperty("isetDiameter", 2);
+
+        this.startProperty("levelDistance", {}, 2);
+        this.addBody(GTE.STORAGE.settingsDistLevels, 3);
+        this.endProperty("levelDistance", 2);
 
+        this.endProperty("display",1);
     };
 
     XmlExporter.prototype.toString = function() {

From afdb92ac92216a8edf3f4169440058f39cc8d020 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Fri, 17 Jun 2016 20:38:16 +0530
Subject: [PATCH 53/63] Exports Player Properties

---
 html/js/xmlExporter/XmlExporter.js | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/html/js/xmlExporter/XmlExporter.js b/html/js/xmlExporter/XmlExporter.js
index 9695007..ee04515 100644
--- a/html/js/xmlExporter/XmlExporter.js
+++ b/html/js/xmlExporter/XmlExporter.js
@@ -16,6 +16,7 @@ GTE.TREE = (function (parentModule) {
     XmlExporter.prototype.exportGTE = function() {
         this.startProperty("gte", {version : "0.1"}, 0);
         this.exportDisplayProperties();
+        this.exportPlayers();
         this.endProperty("gte", 0);
     };
 
@@ -82,7 +83,15 @@ GTE.TREE = (function (parentModule) {
 
         this.endProperty("display",1);
     };
-
+    XmlExporter.prototype.exportPlayers = function() {
+        this.startProperty("players", {}, 1);
+        for(var i = 1; i<GTE.tree.players.length;i++) {
+            this.startProperty("player", {playerId : i}, 2);
+            this.addBody(GTE.tree.players[i].name, 3);
+            this.endProperty("player", 2);
+        }
+        this.endProperty("players",1);
+    };
     XmlExporter.prototype.toString = function() {
         console.log(this.tree);
     };

From 7e71948d09b4f08f61f347d64f90b93acb02c742 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Fri, 17 Jun 2016 21:04:34 +0530
Subject: [PATCH 54/63] Initial exporting of nodes added

---
 html/js/xmlExporter/XmlExporter.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/html/js/xmlExporter/XmlExporter.js b/html/js/xmlExporter/XmlExporter.js
index ee04515..068548a 100644
--- a/html/js/xmlExporter/XmlExporter.js
+++ b/html/js/xmlExporter/XmlExporter.js
@@ -17,6 +17,7 @@ GTE.TREE = (function (parentModule) {
         this.startProperty("gte", {version : "0.1"}, 0);
         this.exportDisplayProperties();
         this.exportPlayers();
+        this.exportExtensiveForm();
         this.endProperty("gte", 0);
     };
 
@@ -83,6 +84,7 @@ GTE.TREE = (function (parentModule) {
 
         this.endProperty("display",1);
     };
+
     XmlExporter.prototype.exportPlayers = function() {
         this.startProperty("players", {}, 1);
         for(var i = 1; i<GTE.tree.players.length;i++) {
@@ -92,6 +94,32 @@ GTE.TREE = (function (parentModule) {
         }
         this.endProperty("players",1);
     };
+
+    XmlExporter.prototype.exportExtensiveForm= function() {
+        this.startProperty("extensiveform", {}, 1);
+        this.exportNodes();
+        this.endProperty("extensiveform",1);
+    };
+
+    XmlExporter.prototype.exportNodes = function() {
+        this.exportNode(GTE.tree.root, {}, 2);
+    };
+
+    XmlExporter.prototype.exportNode = function(node, parameters, tab) {
+        if(node.children.length == 0 ) {
+            // export as an outcome
+            this.startProperty("outcome", parameters, tab);
+            this.endProperty("outcome", tab);
+        } else {
+            //exprot nodes
+            this.startProperty("node", parameters, tab);
+            for(var i = 0; i<node.children.length; i++) {
+                this.exportNode(node.children[i], {}, tab+1);
+            }
+            this.endProperty("node", tab);
+        }
+    };
+
     XmlExporter.prototype.toString = function() {
         console.log(this.tree);
     };

From 64e696c4e40654f4288572dacb39f7fa38862a3b Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Sat, 18 Jun 2016 21:14:46 +0530
Subject: [PATCH 55/63] Added function to export nodes

---
 html/js/xmlExporter/XmlExporter.js | 43 ++++++++++++++++++++++++------
 1 file changed, 35 insertions(+), 8 deletions(-)

diff --git a/html/js/xmlExporter/XmlExporter.js b/html/js/xmlExporter/XmlExporter.js
index 068548a..1795fdc 100644
--- a/html/js/xmlExporter/XmlExporter.js
+++ b/html/js/xmlExporter/XmlExporter.js
@@ -25,10 +25,12 @@ GTE.TREE = (function (parentModule) {
         var append = this.assignTab(tab);
         append += "<"+property_name;
         for(var parameter in parameters) {
-            append += (" "+parameter);
-            append += "=\"";
-            append += parameters[parameter];
-            append += "\"";
+            if(parameters[parameter] != undefined) {
+                append += (" "+parameter);
+                append += "=\"";
+                append += parameters[parameter];
+                append += "\"";
+            }
         }
         append += ">\n";
         this.tree += append;
@@ -96,13 +98,17 @@ GTE.TREE = (function (parentModule) {
     };
 
     XmlExporter.prototype.exportExtensiveForm= function() {
-        this.startProperty("extensiveform", {}, 1);
+        this.startProperty("extensiveForm", {}, 1);
         this.exportNodes();
-        this.endProperty("extensiveform",1);
+        this.endProperty("extensiveForm",1);
     };
 
     XmlExporter.prototype.exportNodes = function() {
-        this.exportNode(GTE.tree.root, {}, 2);
+        if(GTE.tree.root.player == null) {
+            this.exportNode(GTE.tree.root, {}, 2);
+        } else {
+            this.exportNode(GTE.tree.root, {player: GTE.tree.root.player.name}, 2);
+        }
     };
 
     XmlExporter.prototype.exportNode = function(node, parameters, tab) {
@@ -114,7 +120,28 @@ GTE.TREE = (function (parentModule) {
             //exprot nodes
             this.startProperty("node", parameters, tab);
             for(var i = 0; i<node.children.length; i++) {
-                this.exportNode(node.children[i], {}, tab+1);
+                if(GTE.tools.isetToolsRan) {
+                    if(node.children[i].player == null) {
+                        if((node.iset.moves[i]).__proto__.constructor.name == "ChanceMove") {
+                            this.exportNode(node.children[i], {prob : node.iset.moves[i].name, iset : GTE.tree.isets.indexOf(node.children[i].iset)}, tab+1);
+                        } else {
+                            this.exportNode(node.children[i], {move : node.iset.moves[i].name, iset : GTE.tree.isets.indexOf(node.children[i].iset)}, tab+1);
+                        }
+                    } else {
+                        if((node.iset.moves[i]).__proto__.constructor.name == "ChanceMove") {
+                            this.exportNode(node.children[i], {player : node.children[i].player.name, prob : node.iset.moves[i].name, iset : GTE.tree.isets.indexOf(node.children[i].iset)}, tab+1);
+                        } else {
+                            this.exportNode(node.children[i], {player : node.children[i].player.name, move : node.iset.moves[i].name, iset : GTE.tree.isets.indexOf(node.children[i].iset)}, tab+1);
+                        }
+                    }
+
+                } else {
+                    if(node.children[i].player == null) {
+                        this.exportNode(node.children[i], {}, tab+1);
+                    } else {
+                        this.exportNode(node.children[i], {player : node.children[i].player.name}, tab+1);
+                    }
+                }
             }
             this.endProperty("node", tab);
         }

From 14f0a4ad605358c29f5488aeacbe83f090261a23 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Mon, 20 Jun 2016 06:19:38 +0530
Subject: [PATCH 56/63] Exported the payoff

---
 html/js/xmlExporter/XmlExporter.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/html/js/xmlExporter/XmlExporter.js b/html/js/xmlExporter/XmlExporter.js
index 1795fdc..0acff1c 100644
--- a/html/js/xmlExporter/XmlExporter.js
+++ b/html/js/xmlExporter/XmlExporter.js
@@ -111,10 +111,25 @@ GTE.TREE = (function (parentModule) {
         }
     };
 
+    XmlExporter.prototype.assignPayoff = function(player, payoff, tab) {
+        this.startProperty("payoff", {player : player.name,}, tab);
+        this.addBody(payoff.value, tab+1);
+        this.endProperty("payoff", tab);
+    }
+
     XmlExporter.prototype.exportNode = function(node, parameters, tab) {
         if(node.children.length == 0 ) {
             // export as an outcome
             this.startProperty("outcome", parameters, tab);
+            if(GTE.tools.isetToolsRan) {
+                // assign payoffs
+                for(var i=1; i<GTE.tree.players.length;i++) {
+                    var index = GTE.tree.players[i].payoffs.map(function(el) {
+                          return el.leaf;
+                    }).indexOf(node);
+                    this.assignPayoff(GTE.tree.players[i], GTE.tree.players[i].payoffs[index], tab+1);    
+                }
+            }
             this.endProperty("outcome", tab);
         } else {
             //exprot nodes

From 6d4a3dda0f688c5e13af5389ed678a12a71ec242 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Mon, 20 Jun 2016 06:33:21 +0530
Subject: [PATCH 57/63] Added Comments

---
 html/js/xmlExporter/XmlExporter.js | 62 ++++++++++++++++++++++++++++--
 1 file changed, 59 insertions(+), 3 deletions(-)

diff --git a/html/js/xmlExporter/XmlExporter.js b/html/js/xmlExporter/XmlExporter.js
index 0acff1c..9888ec2 100644
--- a/html/js/xmlExporter/XmlExporter.js
+++ b/html/js/xmlExporter/XmlExporter.js
@@ -9,10 +9,16 @@ GTE.TREE = (function (parentModule) {
         this.tree = "";
     };
 
+    /**
+    * Exports the tree to xml format
+    */
     XmlExporter.prototype.exportTree = function() {
         this.exportGTE();
     };
 
+    /**
+    * Exports the GTE section of the xml tree
+    */
     XmlExporter.prototype.exportGTE = function() {
         this.startProperty("gte", {version : "0.1"}, 0);
         this.exportDisplayProperties();
@@ -21,7 +27,14 @@ GTE.TREE = (function (parentModule) {
         this.endProperty("gte", 0);
     };
 
-    XmlExporter.prototype.startProperty = function(property_name, parameters, tab, body) {
+    /**
+    *  Function that adds properties in
+    *  xml format.
+    *  @param {property_name} Name of the property to be exported
+    *  @param {parameters} Parameters to be associated with the property
+    *  @param {tab} The amount of tab space to be left in the beginning.
+    */
+    XmlExporter.prototype.startProperty = function(property_name, parameters, tab) {
         var append = this.assignTab(tab);
         append += "<"+property_name;
         for(var parameter in parameters) {
@@ -36,19 +49,34 @@ GTE.TREE = (function (parentModule) {
         this.tree += append;
     };
 
+    /**
+    * Function that adds an ending tag
+    * to a particular property
+    * @param {property_name} Name of the proprety to be exported
+    * @param {tab} The amount of tab space associated with the closing tag
+    */
     XmlExporter.prototype.endProperty = function(property_name, tab) {
         var append = this.assignTab(tab);
         append += "</"+property_name+">\n";
         this.tree += append;
     };
 
+    /**
+    * Function that adds material between the
+    * starting and ending tag
+    * @param {property_name} The content of the body to be added
+    * @param {tab} The amount of tab space to be left in the beginning
+    */
     XmlExporter.prototype.addBody = function(property_name, tab) {
         var append = this.assignTab(tab);
         append += property_name+"\n";
         this.tree += append;
     };
 
-
+    /**
+    * Function that assigns tab space
+    * to the beginning of a tag
+    */
     XmlExporter.prototype.assignTab = function(tab) {
         var string = "";
         for(var i = 0; i<tab; i++) {
@@ -57,6 +85,10 @@ GTE.TREE = (function (parentModule) {
         return string;
     };
 
+    /**
+    * Function that exports the properties inside
+    * the display tag of the xml tree
+    */
     XmlExporter.prototype.exportDisplayProperties = function(tab_space) {
         this.startProperty("display", {}, 1);
         for(var i = 1; i<GTE.tree.players.length; i++) {
@@ -87,6 +119,10 @@ GTE.TREE = (function (parentModule) {
         this.endProperty("display",1);
     };
 
+    /**
+    * Function that exports players inside the
+    * player tag of the xml tree
+    */
     XmlExporter.prototype.exportPlayers = function() {
         this.startProperty("players", {}, 1);
         for(var i = 1; i<GTE.tree.players.length;i++) {
@@ -97,12 +133,20 @@ GTE.TREE = (function (parentModule) {
         this.endProperty("players",1);
     };
 
+    /**
+    * Function that exports the properties
+    * inside the extensiveForm tag
+    */
     XmlExporter.prototype.exportExtensiveForm= function() {
         this.startProperty("extensiveForm", {}, 1);
         this.exportNodes();
         this.endProperty("extensiveForm",1);
     };
 
+    /**
+    * Function that exports the nodes
+    * in the final xml tree
+    */
     XmlExporter.prototype.exportNodes = function() {
         if(GTE.tree.root.player == null) {
             this.exportNode(GTE.tree.root, {}, 2);
@@ -111,12 +155,20 @@ GTE.TREE = (function (parentModule) {
         }
     };
 
+    /**
+    * Funciton that adds payoff tags
+    * to outcomes in the final xml tree
+    */
     XmlExporter.prototype.assignPayoff = function(player, payoff, tab) {
         this.startProperty("payoff", {player : player.name,}, tab);
         this.addBody(payoff.value, tab+1);
         this.endProperty("payoff", tab);
     }
 
+    /**
+    * Function that exports node tags
+    * recursively to the xml tree
+    */
     XmlExporter.prototype.exportNode = function(node, parameters, tab) {
         if(node.children.length == 0 ) {
             // export as an outcome
@@ -162,8 +214,12 @@ GTE.TREE = (function (parentModule) {
         }
     };
 
+    /**
+    * Funciton that returns the tree
+    * in xml format
+    */
     XmlExporter.prototype.toString = function() {
-        console.log(this.tree);
+        return "Tree in xml :\n"+this.tree;
     };
 
     // Add class to parent module

From ff3cef281fd89dffbb9d06b14a0ff8cad601dc5c Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Mon, 20 Jun 2016 06:45:54 +0530
Subject: [PATCH 58/63] Added comments

---
 html/js/xmlimporter/XmlImporter.js | 39 ++++++++++++++++++++++++++++--
 1 file changed, 37 insertions(+), 2 deletions(-)

diff --git a/html/js/xmlimporter/XmlImporter.js b/html/js/xmlimporter/XmlImporter.js
index 676ad67..56a9521 100644
--- a/html/js/xmlimporter/XmlImporter.js
+++ b/html/js/xmlimporter/XmlImporter.js
@@ -11,10 +11,17 @@ GTE.TREE = (function(parentModule) {
         this.json = null;
     }
 
+    /**
+    * Function that parses xml data to
+    * Json using third party software
+    */
     XmlImporter.prototype.parseXmlToJson = function() {
         this.json = X2J.parseXml(this.xml);
     };
 
+    /**
+    * Main function that loads the tree
+    */
     XmlImporter.prototype.loadTree = function() {
         var tree = this.json[0].gte[0];
         var display = this.json[0].gte[0].display[0];
@@ -95,6 +102,10 @@ GTE.TREE = (function(parentModule) {
 
     /**
     * Function to assign Chance Players to Nodes
+    * @param {node} the node to which the chance
+    * player is to be assigned in json
+    * @param {root} Reference to the node to which
+    * chancePlayer is to be assigned
     */
     XmlImporter.prototype.assignChancePlayers = function(node, root) {
         if(this.isChanceNode(node)) {
@@ -108,6 +119,11 @@ GTE.TREE = (function(parentModule) {
         }
     };
 
+    /**
+    * Function that checks if a given node
+    * is has chancePlayer assigned to it
+    * @param {node} node in json format
+    */
     XmlImporter.prototype.isChanceNode = function(node) {
         for( var i = 0 ; i < node.jIndex.length ; i++) {
             if(node.jIndex[i][0] == "node") {
@@ -159,6 +175,12 @@ GTE.TREE = (function(parentModule) {
         return list;
     };
 
+    /**
+    * Function that merges isets according
+    * to the loaded tree
+    * @param {listOfIsets} Object containing a list
+    * of nodes with similar isets
+    */
     XmlImporter.prototype.mergeIsets = function (listOfIsets) {
         for (var index in listOfIsets) {
             for(var i = 1; i<listOfIsets[index].length; i++) {
@@ -168,6 +190,13 @@ GTE.TREE = (function(parentModule) {
         }
     };
 
+    /**
+    * Function that assigns moves to nodes
+    * according to the data returned by their
+    * father node
+    * @param {nodejs} Node in json format
+    * @param {node} Reference to the node
+    */
     XmlImporter.prototype.assignMoves = function (nodejs, node) {
         for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
             if(nodejs.jIndex[i][0] == "node") {
@@ -188,11 +217,17 @@ GTE.TREE = (function(parentModule) {
         }
     };
 
-    XmlImporter.prototype.assignPayoffs = function (nodejs, node, listOfIsets) {
+    /**
+    * Function that assigns payoffs to the
+    * given node
+    * @param {nodejs} Node in json format
+    * @param {node} Reference to the node
+    */
+    XmlImporter.prototype.assignPayoffs = function (nodejs, node) {
         if(nodejs.jIndex != undefined) {
             for( var i = 0 ; i < nodejs.jIndex.length ; i++) {
                 if(nodejs.jIndex[i][0] == "node") {
-                    this.assignPayoffs(nodejs.node[nodejs.jIndex[i][1]], node.children[i], listOfIsets);
+                    this.assignPayoffs(nodejs.node[nodejs.jIndex[i][1]], node.children[i]);
                 }
                 if(nodejs.jIndex[i][0] == "outcome") {
                     var outcome = nodejs.outcome[nodejs.jIndex[i][1]];

From c506e097206fe61aa54b59f9f5888d1260f3d56d Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Sun, 26 Jun 2016 16:11:31 +0530
Subject: [PATCH 59/63] Trimmed display properties

---
 html/js/guiutils/Tools.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/html/js/guiutils/Tools.js b/html/js/guiutils/Tools.js
index 1bcdabf..7f4b651 100644
--- a/html/js/guiutils/Tools.js
+++ b/html/js/guiutils/Tools.js
@@ -297,7 +297,7 @@ GTE.UI = (function (parentModule) {
     Tools.prototype.setPlayers = function (colour,name) {
         for(var i=1; i<=name.length; i++)
         {
-            this.addPlayer(colour[i-1].jValue, i, name[i-1].jValue);
+            this.addPlayer(colour[i-1].jValue.trim(), i, name[i-1].jValue.trim());
         }
     };
 
@@ -305,9 +305,9 @@ GTE.UI = (function (parentModule) {
     * Sets display properties of the tree
     */
     Tools.prototype.setDisplayProperties = function (display) {
-        GTE.STORAGE.settingsLineThickness = display.strokeWidth[0].jValue;
-        GTE.STORAGE.settingsCircleSize = display.nodeDiameter[0].jValue;
-        GTE.STORAGE.settingsDistLevels = display.levelDistance[0].jValue;
+        GTE.STORAGE.settingsLineThickness = display.strokeWidth[0].jValue.trim();
+        GTE.STORAGE.settingsCircleSize = display.nodeDiameter[0].jValue.trim();
+        GTE.STORAGE.settingsDistLevels = display.levelDistance[0].jValue.trim();
     };
 
     /**

From fe50e0dad242fa0d51c2681540913705238bff61 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Sun, 26 Jun 2016 17:36:20 +0530
Subject: [PATCH 60/63] this -> GTE.tools

---
 html/js/xmlimporter/XmlImporter.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/html/js/xmlimporter/XmlImporter.js b/html/js/xmlimporter/XmlImporter.js
index 56a9521..a3a31c9 100644
--- a/html/js/xmlimporter/XmlImporter.js
+++ b/html/js/xmlimporter/XmlImporter.js
@@ -37,7 +37,7 @@ GTE.TREE = (function(parentModule) {
         this.assignChancePlayers(tree.extensiveForm[0].node[0], root);
         if (GTE.tools.ableToSwitchToISetEditingMode()) {
             GTE.tree.initializeISets();
-            this.isetToolsRan = true;
+            GTE.tools.isetToolsRan = true;
             var listOfIsets = this.getListOfIsets(tree.extensiveForm[0].node[0], root, {});
             this.mergeIsets(listOfIsets);
             this.assignMoves(tree.extensiveForm[0].node[0], root);

From 547ead2e49a19ad2aa244fbc497475f65615cf3b Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Mon, 27 Jun 2016 00:58:33 +0530
Subject: [PATCH 61/63] Exported to external file tree.xml

---
 html/js/main.js                    | 19 +++++++++++++++++--
 html/js/xmlExporter/XmlExporter.js |  2 +-
 2 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/html/js/main.js b/html/js/main.js
index 0b1a783..28c447f 100644
--- a/html/js/main.js
+++ b/html/js/main.js
@@ -101,7 +101,7 @@
     document.getElementById("button-save").addEventListener("click", function(){
         var exporter = new GTE.TREE.XmlExporter();
         exporter.exportTree();
-        console.log(exporter.toString());
+        saveData(exporter.toString(),"tree.xml");
         return false;
     });
 
@@ -226,4 +226,19 @@
         settings.style.left = left + 'px';
     }
 
-}());
+    var saveData = (function () {
+        var a = document.createElement("a");
+        document.body.appendChild(a);
+        a.style = "display: none";
+        return function (data, fileName) {
+            var curData = data,
+                blob = new Blob([curData], {type: "text/plain"}),
+                url = window.URL.createObjectURL(blob);
+            a.href = url;
+            a.download = fileName;
+            a.click();
+            window.URL.revokeObjectURL(url);
+        };
+    }());
+
+}());
\ No newline at end of file
diff --git a/html/js/xmlExporter/XmlExporter.js b/html/js/xmlExporter/XmlExporter.js
index 9888ec2..66c4356 100644
--- a/html/js/xmlExporter/XmlExporter.js
+++ b/html/js/xmlExporter/XmlExporter.js
@@ -219,7 +219,7 @@ GTE.TREE = (function (parentModule) {
     * in xml format
     */
     XmlExporter.prototype.toString = function() {
-        return "Tree in xml :\n"+this.tree;
+        return this.tree;
     };
 
     // Add class to parent module

From bcc5c8e2024423c31425e08013aa1ecd1f903700 Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Mon, 27 Jun 2016 08:28:43 +0530
Subject: [PATCH 62/63] Added check in recursiveCheckAllNodesHavePlayer

---
 html/js/tree/Tree.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/html/js/tree/Tree.js b/html/js/tree/Tree.js
index ada1053..f3b3a68 100644
--- a/html/js/tree/Tree.js
+++ b/html/js/tree/Tree.js
@@ -998,7 +998,7 @@ GTE.TREE = (function (parentModule) {
         if (node === undefined) {
             node = this.root;
         }
-        if (node.children.length !== 0 && node.player === null) {
+        if (node.children.length !== 0 && (node.player === null || node.player === undefined)) {
             return false;
         }
         for (var i = 0; i < node.children.length; i++) {

From d9da108b73827fa0e6f63ef03c3710eb9599b1ff Mon Sep 17 00:00:00 2001
From: Harkirat Singh <harkirat96@gmail.com>
Date: Wed, 29 Jun 2016 21:55:16 +0530
Subject: [PATCH 63/63] Removed strategicform.md

---
 INFOS/strategicform.md | 23 -----------------------
 1 file changed, 23 deletions(-)
 delete mode 100644 INFOS/strategicform.md

diff --git a/INFOS/strategicform.md b/INFOS/strategicform.md
deleted file mode 100644
index 6b3075d..0000000
--- a/INFOS/strategicform.md
+++ /dev/null
@@ -1,23 +0,0 @@
-## Strategic Form
-
-The role of the Strategic form would be to convert the complete game tree (in which all nodes are assigned with players and all leaf nodes have payoffs assigned to them) into strategic form.
-The strategic form for an n-player game would be an n-dimensional matrix.
-As suggested by Bernhard, the matrix should be integer addressable rather than string addressable. To implement this functionality, the following classes have been added to jsgte.
-
-Right now it is being implemented only for 2 player games as they are easy to represent. Can be extended to n-player games after further discussion.
-
-## Matrix.js
-The role of matrix.js is to create an instance of the matrix that will be rendered to the Canvas when the user wants to see the strategic form of the game tree.
-It will contain a multidimensional array of the type strategyBlock which will be indexed by integers itself. There will be prototype functions that will return (n-1) dimensional arrays of a given strategy passed as a parameter.
-
-## StrategyBlock.js
-The role of StrategyBlock.js is to create an instance of strategyBlock class. The strategy class represents one unit of the matrix represented by Matrix.js. It will have parameters :
-coordinate -> array of coordinates used to reference this particular strategy ( the number will be equal to the number of players)
-strategies -> an array of strategies that are used in this StrategyBlock instance. 
-node -> the leaf node to which these set of strategies point to
-
-##Strategy.js
-The role of Strategy.js is to create an instance of a strategy. A strategy represents for a particular player, a set of moves that he may take forward
-player -> The player whose strategy is represented in this strategy.js instance.
-moves -> a set of moves assigned to this player
-This class will also contain a toString method which will output the set of moves in string format.