11 vuotta sitten · a89b5adf1f
--- a/build/three.js
+++ b/build/three.js
--- a/build/three.min.js
+++ b/build/three.min.js
--- a/docs/api/materials/ShaderMaterial.html
+++ b/docs/api/materials/ShaderMaterial.html
@@ -14,36 +14,31 @@
 
															 		<div class="desc">Material rendered with custom shaders</div>
														
 
															-		<h2>Constructor</h2>
														
 
															-
														
 
															-
														
 
															-		<h3>[name]([page:Object parameters])</h3>
														
 
															-		<div>
														
 
															-		parameters -- An object containing various parameters setting up shaders and their uniforms.
														
 
															-		</div>
														
 
															-		<div>
														
 
															-		<br>
														
 
															-		Example:<br>
														
 
															-		<br>
														
 
															-		uniforms = {
														
 
															-			time: { type: "f", value: 1.0 },
														
 
															-			resolution: { type: "v2", value: new THREE.Vector2() }
														
 
															-		};
														
 
															+		<h2>Example</h2>
														
 
															-		material = new THREE.ShaderMaterial( {
														
 
															+		<code>
														
 
															+		var material = new THREE.ShaderMaterial( {
														
 
															-			uniforms: uniforms,
														
 
															+			uniforms: {
														
 
															+				time: { type: "f", value: 1.0 },
														
 
															+				resolution: { type: "v2", value: new THREE.Vector2() }
														
 
															+			},
														
 
															 			vertexShader: document.getElementById( 'vertexShader' ).textContent,
														
 
															 			fragmentShader: document.getElementById( 'fragmentShader' ).textContent
														
 
															 		} );
														
 
															+		</code>
														
 
															-		</div>
														
 
															+		<h2>Constructor</h2>
														
 
															-		<h2>Properties</h2>
														
 
															+		<h3>[name]([page:Object parameters])</h3>
														
 
															+		<div>
														
 
															+		parameters -- An object containing various parameters setting up shaders and their uniforms.
														
 
															+		</div>
														
 
															+		<h2>Properties</h2>
														
 
															 		<h3>.[page:object uniforms]</h3>
														
 
															 		<div>
														
--- a/docs/api/math/Box3.html
+++ b/docs/api/math/Box3.html
@@ -51,15 +51,6 @@
 
															 		Sets the lower and upper (x, y, z) boundaries of this box.
														
 
															 		</div>
														
 
															-		<h3>.addPoint([page:Vector3 point]) [page:Box3 this]</h3>
														
 
															-		<div>
														
 
															-		point -- [page:Vector3] to add to the box <br />
														
 
															-		</div>
														
 
															-		<div>
														
 
															-		If the *point* is outside the bounds of the box, the bounds are expanded
														
 
															-		so that the point is within the bounds.
														
 
															-		</div>
														
 
															-		
														
 
															 		<h3>.applyMatrix4([page:Matrix4 matrix]) [page:Box3 this]</h3>
														
 
															 		<div>
														
 
															 		matrix -- The [page:Matrix4] to apply
														
--- a/docs/api/renderers/webgl/WebGLProgram.html
+++ b/docs/api/renderers/webgl/WebGLProgram.html
@@ -9,36 +9,78 @@
 
															 	<body>
														
 
															 		<h1>[name]</h1>
														
 
															-		<div class="desc">todo</div>
														
 
															+		<div class="desc">Constructor for the GLSL program sent to vertex and fragment shaders, including default uniforms and attributes.</div>
														
 
															-		<h2>Example</h2>
														
 
															+		<h2>Constructor</h2>
														
 
															-		<code>todo</code>
														
 
															+		<h3>[name]( [page:WebGLRenderer renderer], [page:Object code], [page:Material material], [page:Object parameters] )</h3>
														
 
															+		<div>For parameters see [page:WebGLRenderer WebGLRenderer]</div>
														
 
															+		<div>Standard defaults for vertex shader:<br/><br/>
														
 
															+		uniform mat4 modelMatrix;<br/>
														
 
															+		uniform mat4 modelViewMatrix;<br/>
														
 
															+		uniform mat4 projectionMatrix;<br/>
														
 
															+		uniform mat4 viewMatrix;<br/>
														
 
															+		uniform mat3 normalMatrix;<br/>
														
 
															+		uniform vec3 cameraPosition;<br/><br/>
														
 
															+		attribute vec3 position;<br/>
														
 
															+		attribute vec3 normal;<br/>
														
 
															+		attribute vec2 uv;<br/>
														
 
															+		attribute vec2 uv2;</div>
														
 
															+		
														
 
															+		<div>Conditional defaults for vertex shader:<br/><br/>
														
 
															+		attribute vec3 color;<br/><br/>
														
 
															+		attribute vec3 morphTarget0;<br/>
														
 
															+		attribute vec3 morphTarget1;<br/>
														
 
															+		attribute vec3 morphTarget2;<br/>
														
 
															+		attribute vec3 morphTarget3;<br/><br/>
														
 
															+		attribute vec3 morphNormal0;<br/>
														
 
															+		attribute vec3 morphNormal1;<br/>
														
 
															+		attribute vec3 morphNormal2;<br/>
														
 
															+		attribute vec3 morphNormal3;<br/><br/>
														
 
															+		attribute vec3 morphTarget4;<br/>
														
 
															+		attribute vec3 morphTarget5;<br/>
														
 
															+		attribute vec3 morphTarget6;<br/>
														
 
															+		attribute vec3 morphTarget7;<br/><br/>
														
 
															+		attribute vec4 skinIndex;<br/>
														
 
															+		attribute vec4 skinWeight;</div>
														
 
															+		
														
 
															+		<div>Standard defaults for fragment shader:<br/><br/>
														
 
															+		uniform mat4 viewMatrix;<br/>
														
 
															+		uniform vec3 cameraPosition;</div>
														
 
															+		
														
 
															-		<h2>Constructor</h2>
														
 
															+		<h2>Properties</h2>
														
 
															+		<h3>.[page:Object uniforms]</h3>
														
 
															+		<div></div> 
														
 
															-		<h3>todo</h3>
														
 
															-		<div></div>
														
 
															+		<h3>.[page:Object attributes]</h3>
														
 
															+		<div></div> 
														
 
															+		<h3>.[page:Integer id]</h3>
														
 
															+		<div></div> 
														
 
															-		<h2>Properties</h2>
														
 
															+		<h3>.[page:Object code]</h3>
														
 
															+		<div></div> 
														
 
															+
														
 
															+		<h3>.[page:Integer usedTimes]</h3>
														
 
															+		<div></div> 
														
 
															+
														
 
															+		<h3>.[page:Object program]</h3>
														
 
															+		<div></div> 
														
 
															-		<h3>todo</h3>
														
 
															-		<div>
														
 
															-		todo
														
 
															-		</div> 
														
 
															+		<h3>.[page:Object vertexShader]</h3>
														
 
															+		<div></div> 
														
 
															+
														
 
															+		<h3>.[page:Object fragmentShader]</h3>
														
 
															+		<div></div> 
														
 
															 		<h2>Methods</h2>
														
 
															+		<h3>none</h3>
														
 
															+		<div></div>
														
 
															-		<h3>todo</h3>
														
 
															-		<div>todo</div>
														
 
															-		<div>
														
 
															-		todo
														
 
															-		</div>
														
 
															-		
														
 
															 		<h2>Source</h2>
														
 
															 		[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
														
--- a/docs/index.html
+++ b/docs/index.html
@@ -3,6 +3,7 @@
 
															 	<head>
														
 
															 		<meta charset="utf-8">
														
 
															 		<title>three.js - documentation</title>
														
 
															+		<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
														
 
															 		<style>
														
 
															 			@font-face {
														
 
															 				font-family: 'inconsolata';
														
@@ -11,6 +12,8 @@
 
															 				font-style: normal;
														
 
															 			}
														
 
															+			*{ box-sizing: border-box;}
														
 
															+
														
 
															 			html {
														
 
															 				height: 100%;
														
 
															 			}
														
@@ -80,10 +83,126 @@
 
															 				overflow: auto;
														
 
															 			}
														
 
															+			.filterBlock{
														
 
															+				margin: 20px;
														
 
															+				position: relative;
														
 
															+			}
														
 
															+			.filterBlock p {
														
 
															+				margin: 0;
														
 
															+			}
														
 
															+			#filterInput {
														
 
															+				width: 100%;
														
 
															+				padding: 5px;
														
 
															+				font-family: inherit;
														
 
															+				font-size: 15px;
														
 
															+				outline: none;
														
 
															+				border: 1px solid #dedede;
														
 
															+			}
														
 
															+			#filterInput:focus{
														
 
															+				border: 1px solid #2194CE;
														
 
															+			}
														
 
															+			#clearFilterButton {
														
 
															+				position: absolute; 
														
 
															+				right: 6px;
														
 
															+				top: 50%;
														
 
															+				margin-top: -8px;
														
 
															+				width: 16px;
														
 
															+				height: 16px;
														
 
															+				font-size: 14px;
														
 
															+				color: grey;
														
 
															+				text-align: center;
														
 
															+				line-height: 0;
														
 
															+				padding-top: 7px;
														
 
															+				opacity: .5;
														
 
															+			}
														
 
															+			#clearFilterButton:hover{
														
 
															+				opacity: 1;
														
 
															+			}
														
 
															+			.filtered{
														
 
															+				display: none;
														
 
															+			}
														
 
															+			#panel li b{
														
 
															+				font-weight: bold;
														
 
															+			}
														
 
															+			#expandButton{
														
 
															+				display: none;
														
 
															+				position: absolute;
														
 
															+				right: 20px;
														
 
															+				top: 12px;
														
 
															+				width: 32px;
														
 
															+				height: 32px;
														
 
															+				background-color: #2194CE;
														
 
															+			}
														
 
															+			#expandButton span{
														
 
															+				height: 3px;
														
 
															+				background-color: white;
														
 
															+				width: 16px;
														
 
															+				position: absolute;
														
 
															+				left: 8px;
														
 
															+				top: 8px;
														
 
															+			}
														
 
															+			#expandButton span:nth-child(1) {
														
 
															+				top: 14px;
														
 
															+			}
														
 
															+			#expandButton span:nth-child(2) {
														
 
															+				top: 20px;
														
 
															+				width: 12px;
														
 
															+			}
														
 
															+			@media all and ( max-width: 640px ) {
														
 
															+				#panel{
														
 
															+					position: absolute;
														
 
															+					left: 0;
														
 
															+					top: 0;
														
 
															+					height: 480px;
														
 
															+					width: 100%;
														
 
															+					right: 0;
														
 
															+					z-index: 100;
														
 
															+					overflow: hidden;
														
 
															+					border-bottom: 1px solid #dedede;
														
 
															+				}
														
 
															+				#content{
														
 
															+					overflow: auto;
														
 
															+					position: absolute;
														
 
															+					left: 0;
														
 
															+					top: 120px;
														
 
															+					right: 0;
														
 
															+					bottom: 0;
														
 
															+				}
														
 
															+				#viewer{
														
 
															+					position: absolute;
														
 
															+					left: 0;
														
 
															+					top: 48px;
														
 
															+				}
														
 
															+				#expandButton{
														
 
															+					display: block;
														
 
															+				}
														
 
															+				#panel.collapsed{
														
 
															+					height: 56px;
														
 
															+				}
														
 
															+				#panel h1{
														
 
															+					margin-top: 20px;
														
 
															+					margin-bottom: 20px;
														
 
															+				}
														
 
															+				#content{
														
 
															+					top: 90px;
														
 
															+				}
														
 
															+			}
														
 
															 		</style>
														
 
															 	</head>
														
 
															 	<body>
														
 
															-		<div id="panel"></div>
														
 
															+
														
 
															+		<div id="panel" class="collapsed">
														
 
															+			<a id="expandButton" href="#" >
														
 
															+				<span></span><span></span><span></span>
														
 
															+			</a>
														
 
															+			<h1><a href="http://threejs.org">three.js</a> / docs</h1>
														
 
															+			<div class="filterBlock" >
														
 
															+				<input type="text" id="filterInput" placeholder="Type to filter"/>
														
 
															+				<a href="#" id="clearFilterButton" >x</a>
														
 
															+			</div>
														
 
															+			<div id="content" >
														
 
															+			</div>
														
 
															+		</div>
														
 
															 		<iframe id="viewer"></iframe>
														
 
															 		<script src="list.js"></script>
														
@@ -91,46 +210,132 @@
 
															 			var panel = document.getElementById( 'panel' );
														
 
															 			var viewer = document.getElementById( 'viewer' );
														
 
															-			var html = '<h1><a href="http://threejs.org">three.js</a> / docs</h1>';
														
 
															+			var clearFilterButton = document.getElementById( 'clearFilterButton' );
														
 
															+			var filterInput = document.getElementById( 'filterInput' );
														
 
															+			//filterInput.focus();
														
 
															+
														
 
															+			panel.addEventListener( 'click', function( e ) {
														
 
															+				//filterInput.focus();
														
 
															+				e.preventDefault();
														
 
															+			} );
														
 
															+
														
 
															+			document.getElementById( 'expandButton' ).addEventListener( 'click', function( e ) {
														
 
															+				panel.classList.toggle( 'collapsed' );
														
 
															+				if( !panel.classList.contains( 'collapsed' ) ) {
														
 
															+					//filterInput.focus();
														
 
															+				}
														
 
															+				e.preventDefault();
														
 
															+			} );
														
 
															 			var DELIMITER = '/';
														
 
															 			var nameCategoryMap = {};
														
 
															+			var sections = [];
														
 
															+
														
 
															+			var content = document.getElementById( 'content' );
														
 
															 			for ( var section in list ) {
														
 
															-				html += '<h2>' + section + '</h2>';
														
 
															+				var h2 = document.createElement( 'h2' );
														
 
															+				h2.textContent = section;
														
 
															-				html += '<ul>';
														
 
															+				content.appendChild( h2 );
														
 
															 				for ( var category in list[ section ] ) {
														
 
															-					html += '<h3>' + category + '</h3>';
														
 
															+					var div = document.createElement( 'div' );
														
 
															-					html += '<ul>';
														
 
															+					var h3 = document.createElement( 'h3' );
														
 
															+					h3.textContent = category;
														
 
															+
														
 
															+					div.appendChild( h3 );
														
 
															+
														
 
															+					var ul = document.createElement( 'ul' );
														
 
															+					div.appendChild( ul );
														
 
															 					for ( var i = 0; i < list[ section ][ category ].length; i ++ ) {
														
 
															 						var page = list[ section ][ category ][ i ];
														
 
															-						html += '<li><a href="javascript:goTo(\'' + section + '\', \'' + category + '\', \'' + page[ 0 ] + '\')">' + page[ 0 ] + '</a></li>';
														
 
															+						var li = document.createElement( 'li' );
														
 
															+						var a = document.createElement( 'a' );
														
 
															+						a.setAttribute( 'href', '#' );
														
 
															+						( function( s, c, p ) { 
														
 
															+							a.addEventListener( 'click', function( e ) {
														
 
															+								goTo( s, c, p );
														
 
															+								e.preventDefault();
														
 
															+							} ) 
														
 
															+						} )( section, category, page[ 0 ] )
														
 
															+						a.textContent = page[ 0 ];
														
 
															+						li.appendChild( a );
														
 
															+						ul.appendChild( li );
														
 
															 						nameCategoryMap[page[0]] = {
														
 
															 							section: section,
														
 
															 							category: category,
														
 
															-							name: page[0]
														
 
															+							name: page[0],
														
 
															+							element: a
														
 
															 						};
														
 
															 					}
														
 
															-					html += '</ul>';
														
 
															+					content.appendChild( div );
														
 
															+					sections.push( ul );
														
 
															 				}
														
 
															-				html += '</ul>';
														
 
															 			}
														
 
															-			panel.innerHTML += html;
														
 
															+			panel.appendChild( content )
														
 
															+
														
 
															+			function layoutList() {
														
 
															+
														
 
															+				sections.forEach( function( el ) {
														
 
															+					var collapsed = true;
														
 
															+					Array.prototype.slice.apply( el.children ).forEach( function( item ) {
														
 
															+						if( !item.classList.contains( 'filtered' ) ) {
														
 
															+							collapsed = false;
														
 
															+							return;
														
 
															+						}
														
 
															+					} );
														
 
															+					if( collapsed ) {
														
 
															+						el.parentElement.classList.add( 'filtered' );
														
 
															+					} else {
														
 
															+						el.parentElement.classList.remove( 'filtered' );
														
 
															+					}
														
 
															+				} );
														
 
															+			}
														
 
															+
														
 
															+			filterInput.addEventListener( 'input', function( e ) {
														
 
															+				updateFilter();
														
 
															+			} );
														
 
															+
														
 
															+			clearFilterButton.addEventListener( 'click', function( e ) {
														
 
															+				filterInput.value = '';
														
 
															+				updateFilter();
														
 
															+				e.preventDefault();
														
 
															+			} );
														
 
															+
														
 
															+			function updateFilter() {
														
 
															+
														
 
															+				var exp = new RegExp( filterInput.value, 'gi' );
														
 
															+				for( var j in nameCategoryMap ) {
														
 
															+					var res = nameCategoryMap[ j ].name.match( exp );
														
 
															+					if( res && res.length > 0 ) {
														
 
															+						nameCategoryMap[ j ].element.parentElement.classList.remove( 'filtered' );
														
 
															+						var str = nameCategoryMap[ j ].name;
														
 
															+						for( var i = 0; i < res.length; i++ ) {
														
 
															+							str = str.replace( res[ i ], '<b>' + res[ i ] + '</b>' );
														
 
															+						}
														
 
															+						nameCategoryMap[ j ].element.innerHTML = str;
														
 
															+					} else {
														
 
															+						nameCategoryMap[ j ].element.parentElement.classList.add( 'filtered' );
														
 
															+						nameCategoryMap[ j ].element.textContent = nameCategoryMap[ j ].name;
														
 
															+					}
														
 
															+				}
														
 
															+				layoutList();
														
 
															+
														
 
															+			}
														
 
															 			function encodeUrl( path ) {
														
@@ -162,8 +367,8 @@
 
															 				window.location.hash = url;
														
 
															 				window.document.title = title;
														
 
															-
														
 
															 				viewer.src = pages[ section ][ category ][ name ] + '.html';
														
 
															+				panel.classList.add( 'collapsed' );
														
 
															 			}
														
--- a/editor/index.html
+++ b/editor/index.html
@@ -18,6 +18,7 @@
 
															 		<script src="../examples/js/loaders/ColladaLoader.js"></script>
														
 
															 		<script src="../examples/js/loaders/OBJLoader.js"></script>
														
 
															 		<script src="../examples/js/loaders/PLYLoader.js"></script>
														
 
															+		<script src="../examples/js/loaders/SceneLoader.js"></script>
														
 
															 		<script src="../examples/js/loaders/STLLoader.js"></script>
														
 
															 		<script src="../examples/js/loaders/UTF8Loader.js"></script>
														
 
															 		<script src="../examples/js/loaders/VRMLLoader.js"></script>
														
@@ -34,8 +35,6 @@
 
															 		<!-- WIP -->
														
 
															-		<script src="../examples/js/BufferGeometryUtils.js"></script>
														
 
															-
														
 
															 		<script src="../examples/js/exporters/BufferGeometryExporter.js"></script>
														
 
															 		<script src="../examples/js/exporters/TypedGeometryExporter.js"></script>
														
 
															 		<script src="../examples/js/exporters/GeometryExporter.js"></script>
														
--- a/editor/js/Loader.js
+++ b/editor/js/Loader.js
@@ -374,7 +374,14 @@ var Loader = function ( editor ) {
 
															 		} else if ( data.metadata.type.toLowerCase() === 'scene' ) {
														
 
															-			console.error( 'Editor: Scene format 3 is no longer supported.' );
														
 
															+			// DEPRECATED
														
 
															+
														
 
															+			var loader = new THREE.SceneLoader();
														
 
															+			loader.parse( data, function ( result ) {
														
 
															+
														
 
															+				editor.setScene( result.scene );
														
 
															+
														
 
															+			}, '' );
														
 
															 		}
														
--- a/editor/js/Menubar.Edit.js
+++ b/editor/js/Menubar.Edit.js
@@ -40,6 +40,7 @@ Menubar.Edit = function ( editor ) {
 
															 		// convert to BufferGeometry
														
 
															 		var object = editor.selected;
														
 
															+
														
 
															 		if ( object.geometry instanceof THREE.Geometry ) {
														
 
															 			if ( object.parent === undefined ) return; // avoid flattening the camera or scene
														
@@ -48,9 +49,10 @@ Menubar.Edit = function ( editor ) {
 
															 			delete object.__webglInit; // TODO: Remove hack (WebGLRenderer refactoring)
														
 
															-			object.geometry = THREE.BufferGeometryUtils.fromGeometry( object.geometry );
														
 
															+			object.geometry = new THREE.BufferGeometry().fromGeometry( object.geometry );
														
 
															 			editor.signals.objectChanged.dispatch( object );
														
 
															+
														
 
															 		}
														
 
															 	}
														
--- a/examples/canvas_camera_orthographic2.html
+++ b/examples/canvas_camera_orthographic2.html
@@ -46,13 +46,13 @@
 
															 					<a href="#" onclick="camera.setZoom(2);return false;">2x</a> |
														
 
															 				<br/>
														
 
															-			Views: <a href="#" onclick="camera.toTopView();return false;">Top view</a> |
														
 
															-				<a href="#" onclick="camera.toBottomView();return false;">Bottom view</a> |
														
 
															-				<a href="#" onclick="camera.toLeftView();return false;">Left view</a> |
														
 
															-				<a href="#" onclick="camera.toRightView();return false;">Right view</a> |
														
 
															-				<a href="#" onclick="camera.toFrontView();return false;">Front view</a> |
														
 
															-				<a href="#" onclick="camera.toBackView();return false;">Back view</a> |
														
 
															-				<a href="#" onclick="camera.rotationAutoUpdate = true;return false;">Look at Scene</a>
														
 
															+			Views: <a href="#" onclick="camera.toTopView();lookAtScene=false;return false;">Top view</a> |
														
 
															+				<a href="#" onclick="camera.toBottomView();lookAtScene=false;return false;">Bottom view</a> |
														
 
															+				<a href="#" onclick="camera.toLeftView();lookAtScene=false;return false;">Left view</a> |
														
 
															+				<a href="#" onclick="camera.toRightView();lookAtScene=false;return false;">Right view</a> |
														
 
															+				<a href="#" onclick="camera.toFrontView();lookAtScene=false;return false;">Front view</a> |
														
 
															+				<a href="#" onclick="camera.toBackView();lookAtScene=false;return false;">Back view</a> |
														
 
															+				<a href="#" onclick="lookAtScene=true;return false;">Look at Scene</a>
														
 
															 				<br/>
														
 
															 			<div id="fov"></div>
														
 
															 		</div>
														
@@ -63,6 +63,7 @@
 
															 			var container, stats;
														
 
															 			var camera, scene, renderer;
														
 
															+			var lookAtScene = true;
														
 
															 			init();
														
 
															 			animate();
														
@@ -215,7 +216,7 @@
 
															 				camera.position.x = Math.cos( timer ) * 200;
														
 
															 				camera.position.z = Math.sin( timer ) * 200;
														
 
															-				camera.lookAt( scene.position );
														
 
															+				if ( lookAtScene ) camera.lookAt( scene.position );
														
 
															 				renderer.render( scene, camera );
														
--- a/examples/canvas_geometry_birds.html
+++ b/examples/canvas_geometry_birds.html
@@ -359,7 +359,6 @@
 
															 					bird = birds[ i ] = new THREE.Mesh( new Bird(), new THREE.MeshBasicMaterial( { color:Math.random() * 0xffffff, side: THREE.DoubleSide } ) );
														
 
															 					bird.phase = Math.floor( Math.random() * 62.83 );
														
 
															-					bird.position = boids[ i ].position;
														
 
															 					scene.add( bird );
														
@@ -429,6 +428,7 @@
 
															 					boid.run( boids );
														
 
															 					bird = birds[ i ];
														
 
															+					bird.position.copy( boids[ i ].position );
														
 
															 					color = bird.material.color;
														
 
															 					color.r = color.g = color.b = ( 500 - bird.position.z ) / 1000;
														
--- a/examples/canvas_lines_colors.html
+++ b/examples/canvas_lines_colors.html
@@ -140,8 +140,6 @@
 
															 				renderer.setSize( window.innerWidth, window.innerHeight );
														
 
															-				composer.reset();
														
 
															-
														
 
															 			}
														
 
															 			//
														
--- a/examples/css3d_molecules.html
+++ b/examples/css3d_molecules.html
@@ -346,7 +346,7 @@
 
															 				loader.load( url, function ( geometry, geometryBonds ) {
														
 
															-					var offset = THREE.GeometryUtils.center( geometry );
														
 
															+					var offset = geometry.center();
														
 
															 					geometryBonds.applyMatrix( new THREE.Matrix4().makeTranslation( offset.x, offset.y, offset.z ) );
														
 
															 					for ( var i = 0; i < geometry.vertices.length; i ++ ) {
														
--- a/examples/index.html
+++ b/examples/index.html
@@ -185,6 +185,7 @@
 
															 				"webgl_loader_obj_mtl",
														
 
															 				"webgl_loader_pdb",
														
 
															 				"webgl_loader_ply",
														
 
															+				"webgl_loader_scene",
														
 
															 				"webgl_loader_stl",
														
 
															 				"webgl_loader_utf8",
														
 
															 				"webgl_loader_vrml",
														
--- a/examples/js/BufferGeometryUtils.js
+++ b/examples/js/BufferGeometryUtils.js
@@ -1,182 +0,0 @@
 
															-/**
														
 
															- * @author spite / http://www.clicktorelease.com/
														
 
															- * @author mrdoob / http://mrdoob.com/
														
 
															- */
														
 
															-
														
 
															-THREE.BufferGeometryUtils = {
														
 
															-
														
 
															-	fromGeometry: function geometryToBufferGeometry( geometry, settings ) {
														
 
															-
														
 
															-		if ( geometry instanceof THREE.BufferGeometry ) {
														
 
															-
														
 
															-			return geometry;
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-		settings = settings || { 'vertexColors': THREE.NoColors };
														
 
															-
														
 
															-		var vertices = geometry.vertices;
														
 
															-		var faces = geometry.faces;
														
 
															-		var faceVertexUvs = geometry.faceVertexUvs;
														
 
															-		var vertexColors = settings.vertexColors;
														
 
															-		var hasFaceVertexUv = faceVertexUvs[ 0 ].length > 0;
														
 
															-		var hasFaceVertexNormals = faces[ 0 ].vertexNormals.length == 3;
														
 
															-
														
 
															-		var bufferGeometry = new THREE.BufferGeometry();
														
 
															-
														
 
															-		bufferGeometry.attributes = {
														
 
															-
														
 
															-			position: {
														
 
															-				itemSize: 3,
														
 
															-				array: new Float32Array( faces.length * 3 * 3 )
														
 
															-			},
														
 
															-			normal: {
														
 
															-				itemSize: 3,
														
 
															-				array: new Float32Array( faces.length * 3 * 3 )
														
 
															-			}
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-		var positions = bufferGeometry.attributes.position.array;
														
 
															-		var normals = bufferGeometry.attributes.normal.array;
														
 
															-
														
 
															-		if ( vertexColors !== THREE.NoColors ) {
														
 
															-
														
 
															-			bufferGeometry.attributes.color = {
														
 
															-				itemSize: 3,
														
 
															-				array: new Float32Array( faces.length * 3 * 3 )
														
 
															-			};
														
 
															-
														
 
															-			var colors = bufferGeometry.attributes.color.array;
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-		if ( hasFaceVertexUv === true ) {
														
 
															-
														
 
															-			bufferGeometry.attributes.uv = {
														
 
															-				itemSize: 2,
														
 
															-				array: new Float32Array( faces.length * 3 * 2 )
														
 
															-			};
														
 
															-
														
 
															-			var uvs = bufferGeometry.attributes.uv.array;
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-		for ( var i = 0, i2 = 0, i3 = 0; i < faces.length; i ++, i2 += 6, i3 += 9 ) {
														
 
															-
														
 
															-			var face = faces[ i ];
														
 
															-
														
 
															-			var a = vertices[ face.a ];
														
 
															-			var b = vertices[ face.b ];
														
 
															-			var c = vertices[ face.c ];
														
 
															-
														
 
															-			positions[ i3     ] = a.x;
														
 
															-			positions[ i3 + 1 ] = a.y;
														
 
															-			positions[ i3 + 2 ] = a.z;
														
 
															-			
														
 
															-			positions[ i3 + 3 ] = b.x;
														
 
															-			positions[ i3 + 4 ] = b.y;
														
 
															-			positions[ i3 + 5 ] = b.z;
														
 
															-			
														
 
															-			positions[ i3 + 6 ] = c.x;
														
 
															-			positions[ i3 + 7 ] = c.y;
														
 
															-			positions[ i3 + 8 ] = c.z;
														
 
															-
														
 
															-			if ( hasFaceVertexNormals === true ) {
														
 
															-
														
 
															-				var na = face.vertexNormals[ 0 ];
														
 
															-				var nb = face.vertexNormals[ 1 ];
														
 
															-				var nc = face.vertexNormals[ 2 ];
														
 
															-
														
 
															-				normals[ i3     ] = na.x;
														
 
															-				normals[ i3 + 1 ] = na.y;
														
 
															-				normals[ i3 + 2 ] = na.z;
														
 
															-
														
 
															-				normals[ i3 + 3 ] = nb.x;
														
 
															-				normals[ i3 + 4 ] = nb.y;
														
 
															-				normals[ i3 + 5 ] = nb.z;
														
 
															-
														
 
															-				normals[ i3 + 6 ] = nc.x;
														
 
															-				normals[ i3 + 7 ] = nc.y;
														
 
															-				normals[ i3 + 8 ] = nc.z;
														
 
															-
														
 
															-			} else {
														
 
															-
														
 
															-				var n = face.normal;
														
 
															-
														
 
															-				normals[ i3     ] = n.x;
														
 
															-				normals[ i3 + 1 ] = n.y;
														
 
															-				normals[ i3 + 2 ] = n.z;
														
 
															-
														
 
															-				normals[ i3 + 3 ] = n.x;
														
 
															-				normals[ i3 + 4 ] = n.y;
														
 
															-				normals[ i3 + 5 ] = n.z;
														
 
															-
														
 
															-				normals[ i3 + 6 ] = n.x;
														
 
															-				normals[ i3 + 7 ] = n.y;
														
 
															-				normals[ i3 + 8 ] = n.z;
														
 
															-
														
 
															-			}
														
 
															-
														
 
															-			if ( vertexColors === THREE.FaceColors ) {
														
 
															-
														
 
															-				var fc = face.color;
														
 
															-
														
 
															-				colors[ i3     ] = fc.r;
														
 
															-				colors[ i3 + 1 ] = fc.g;
														
 
															-				colors[ i3 + 2 ] = fc.b;
														
 
															-
														
 
															-				colors[ i3 + 3 ] = fc.r;
														
 
															-				colors[ i3 + 4 ] = fc.g;
														
 
															-				colors[ i3 + 5 ] = fc.b;
														
 
															-
														
 
															-				colors[ i3 + 6 ] = fc.r;
														
 
															-				colors[ i3 + 7 ] = fc.g;
														
 
															-				colors[ i3 + 8 ] = fc.b;
														
 
															-
														
 
															-			} else if ( vertexColors === THREE.VertexColors ) {
														
 
															-
														
 
															-				var vca = face.vertexColors[ 0 ];
														
 
															-				var vcb = face.vertexColors[ 1 ];
														
 
															-				var vcc = face.vertexColors[ 2 ];
														
 
															-
														
 
															-				colors[ i3     ] = vca.r;
														
 
															-				colors[ i3 + 1 ] = vca.g;
														
 
															-				colors[ i3 + 2 ] = vca.b;
														
 
															-
														
 
															-				colors[ i3 + 3 ] = vcb.r;
														
 
															-				colors[ i3 + 4 ] = vcb.g;
														
 
															-				colors[ i3 + 5 ] = vcb.b;
														
 
															-
														
 
															-				colors[ i3 + 6 ] = vcc.r;
														
 
															-				colors[ i3 + 7 ] = vcc.g;
														
 
															-				colors[ i3 + 8 ] = vcc.b;
														
 
															-
														
 
															-			}
														
 
															-
														
 
															-			if ( hasFaceVertexUv === true ) {
														
 
															-
														
 
															-				var uva = faceVertexUvs[ 0 ][ i ][ 0 ];
														
 
															-				var uvb = faceVertexUvs[ 0 ][ i ][ 1 ];
														
 
															-				var uvc = faceVertexUvs[ 0 ][ i ][ 2 ];
														
 
															-
														
 
															-				uvs[ i2     ] = uva.x;
														
 
															-				uvs[ i2 + 1 ] = uva.y;
														
 
															-			
														
 
															-				uvs[ i2 + 2 ] = uvb.x;
														
 
															-				uvs[ i2 + 3 ] = uvb.y;
														
 
															-			
														
 
															-				uvs[ i2 + 4 ] = uvc.x;
														
 
															-				uvs[ i2 + 5 ] = uvc.y;
														
 
															-
														
 
															-			}
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-		bufferGeometry.computeBoundingSphere();
														
 
															-
														
 
															-		return bufferGeometry;
														
 
															-
														
 
															-	}
														
 
															-
														
 
															-}
														
--- a/examples/js/Car.js
+++ b/examples/js/Car.js
@@ -274,7 +274,7 @@ THREE.Car = function () {
 
															 				scope.wheelDiameter = bb.max.y - bb.min.y;
														
 
															-				THREE.GeometryUtils.center( scope.wheelGeometry );
														
 
															+				scope.wheelGeometry.center();
														
 
															 			}
														
--- a/examples/js/loaders/AssimpJSONLoader.js
+++ b/examples/js/loaders/AssimpJSONLoader.js
@@ -85,6 +85,7 @@ THREE.AssimpJSONLoader.prototype = {
 
															 		}
														
 
															 		// read texture coordinates - three.js attaches them to its faces
														
 
															+		json.texturecoords = json.texturecoords || [];
														
 
															 		for(i = 0, e = json.texturecoords.length; i < e; ++i) {
														
 
															 			function convertTextureCoords(in_uv, out_faces, out_vertex_uvs) {
														
@@ -219,7 +220,9 @@ THREE.AssimpJSONLoader.prototype = {
 
															 						has_textures.push(keyname);
														
 
															 						loader.setCrossOrigin(this.crossOrigin);
														
 
															-						loader.load(scope.texturePath + '/' + prop.value, function(tex) {
														
 
															+						var material_url = scope.texturePath + '/' + prop.value
														
 
															+						material_url = material_url.replace(/\\/g, '/');
														
 
															+						loader.load(material_url, function(tex) {
														
 
															 							if(tex) {
														
 
															 								// TODO: read texture settings from assimp.
														
 
															 								// Wrapping is the default, though.
														
--- a/examples/js/loaders/ColladaLoader.js
+++ b/examples/js/loaders/ColladaLoader.js
@@ -1123,7 +1123,7 @@ THREE.ColladaLoader = function () {
 
															 		if ( options.centerGeometry && obj.geometry ) {
														
 
															-			var delta = THREE.GeometryUtils.center( obj.geometry );
														
 
															+			var delta = obj.geometry.center();
														
 
															 			delta.multiply( obj.scale );
														
 
															 			delta.applyQuaternion( obj.quaternion );
														
--- a/examples/js/loaders/PDBLoader.js
+++ b/examples/js/loaders/PDBLoader.js
@@ -2,75 +2,28 @@
 
															  * @author alteredq / http://alteredqualia.com/
														
 
															  */
														
 
															-THREE.PDBLoader = function () {};
														
 
															+THREE.PDBLoader = function ( manager ) {
														
 
															-THREE.PDBLoader.prototype = {
														
 
															-
														
 
															-	constructor: THREE.OBJLoader,
														
 
															-
														
 
															-	load: function ( url, callback ) {
														
 
															-
														
 
															-		var worker, scope = this;
														
 
															-
														
 
															-		this.loadAjaxPDB( this, url, callback );
														
 
															-
														
 
															-	},
														
 
															-
														
 
															-	loadAjaxPDB: function ( context, url, callback, callbackProgress ) {
														
 
															-
														
 
															-		var xhr = new XMLHttpRequest();
														
 
															-
														
 
															-		var length = 0;
														
 
															-
														
 
															-		xhr.onreadystatechange = function () {
														
 
															-
														
 
															-			if ( xhr.readyState === xhr.DONE ) {
														
 
															-
														
 
															-				if ( xhr.status === 200 || xhr.status === 0 ) {
														
 
															-
														
 
															-					if ( xhr.responseText ) {
														
 
															-
														
 
															-						var json = context.parsePDB( xhr.responseText );
														
 
															-						context.createModel( json, callback );
														
 
															-
														
 
															-					} else {
														
 
															+	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;
														
 
															-						console.warn( "THREE.PDBLoader: [" + url + "] seems to be unreachable or file there is empty" );
														
 
															+};
														
 
															-					}
														
 
															-
														
 
															-				} else {
														
 
															-
														
 
															-					console.error( "THREE.PDBLoader: Couldn't load [" + url + "] [" + xhr.status + "]" );
														
 
															-
														
 
															-				}
														
 
															-
														
 
															-			} else if ( xhr.readyState === xhr.LOADING ) {
														
 
															-
														
 
															-				if ( callbackProgress ) {
														
 
															-
														
 
															-					if ( length === 0 ) {
														
 
															-
														
 
															-						length = xhr.getResponseHeader( "Content-Length" );
														
 
															+THREE.PDBLoader.prototype = {
														
 
															-					}
														
 
															+	constructor: THREE.PDBLoader,
														
 
															-					callbackProgress( { total: length, loaded: xhr.responseText.length } );
														
 
															+	load: function ( url, onLoad ) {
														
 
															-				}
														
 
															+		var scope = this;
														
 
															-			} else if ( xhr.readyState === xhr.HEADERS_RECEIVED ) {
														
 
															+		var loader = new THREE.XHRLoader( scope.manager );
														
 
															+		loader.setCrossOrigin( this.crossOrigin );
														
 
															+		loader.load( url, function ( text ) {
														
 
															-				length = xhr.getResponseHeader( "Content-Length" );
														
 
															+			var json = scope.parsePDB( text );
														
 
															+			scope.createModel( json, onLoad );
														
 
															-			}
														
 
															-
														
 
															-		};
														
 
															-
														
 
															-		xhr.open( "GET", url, true );
														
 
															-		if ( xhr.overrideMimeType ) xhr.overrideMimeType( "text/plain; charset=x-user-defined" );
														
 
															-		xhr.setRequestHeader( "Content-Type", "text/plain" );
														
 
															-		xhr.send( null );
														
 
															+		} );
														
 
															 	},
														
@@ -114,7 +67,7 @@ THREE.PDBLoader.prototype = {
 
															 					// doesn't really work as almost all PDBs
														
 
															 					// have just normal bonds appearing multiple
														
 
															 					// times instead of being double/triple bonds
														
 
															-					//bonds[bhash[h]][2] += 1;
														
 
															+					// bonds[bhash[h]][2] += 1;
														
 
															 				}
														
@@ -194,6 +147,7 @@ THREE.PDBLoader.prototype = {
 
															 			var r = atom[ 3 ][ 0 ] / 255;
														
 
															 			var g = atom[ 3 ][ 1 ] / 255;
														
 
															 			var b = atom[ 3 ][ 2 ] / 255;
														
 
															+
														
 
															 			var color = new THREE.Color();
														
 
															 			color.setRGB( r, g, b );
														
@@ -218,7 +172,7 @@ THREE.PDBLoader.prototype = {
 
															 		}
														
 
															-		callback( geometryAtoms, geometryBonds );
														
 
															+		callback( geometryAtoms, geometryBonds, json );
														
 
															 	}
														
--- a/examples/js/loaders/STLLoader.js
+++ b/examples/js/loaders/STLLoader.js
@@ -50,7 +50,7 @@ THREE.STLLoader.prototype.load = function ( url, callback ) {
 
															 		} else {
														
 
															-			scope.dispatchEvent( { type: 'error', message: 'Couldn\'t load URL [' + url + ']', response: event.target.responseText } );
														
 
															+			scope.dispatchEvent( { type: 'error', message: 'Couldn\'t load URL [' + url + ']', response: event.target.statusText } );
														
 
															 		}
														
--- a/examples/js/loaders/SceneLoader.js
+++ b/examples/js/loaders/SceneLoader.js
@@ -0,0 +1,1259 @@
 
															+/**
														
 
															+ * @author alteredq / http://alteredqualia.com/
														
 
															+ */
														
 
															+
														
 
															+THREE.SceneLoader = function () {
														
 
															+
														
 
															+	this.onLoadStart = function () {};
														
 
															+	this.onLoadProgress = function() {};
														
 
															+	this.onLoadComplete = function () {};
														
 
															+
														
 
															+	this.callbackSync = function () {};
														
 
															+	this.callbackProgress = function () {};
														
 
															+
														
 
															+	this.geometryHandlers = {};
														
 
															+	this.hierarchyHandlers = {};
														
 
															+
														
 
															+	this.addGeometryHandler( "ascii", THREE.JSONLoader );
														
 
															+
														
 
															+};
														
 
															+
														
 
															+THREE.SceneLoader.prototype = {
														
 
															+
														
 
															+	constructor: THREE.SceneLoader,
														
 
															+
														
 
															+	load: function ( url, onLoad, onProgress, onError ) {
														
 
															+
														
 
															+		var scope = this;
														
 
															+
														
 
															+		var loader = new THREE.XHRLoader( scope.manager );
														
 
															+		loader.setCrossOrigin( this.crossOrigin );
														
 
															+		loader.load( url, function ( text ) {
														
 
															+
														
 
															+			scope.parse( JSON.parse( text ), onLoad, url );
														
 
															+
														
 
															+		} );
														
 
															+
														
 
															+	},
														
 
															+
														
 
															+	setCrossOrigin: function ( value ) {
														
 
															+
														
 
															+		this.crossOrigin = value;
														
 
															+
														
 
															+	},
														
 
															+
														
 
															+	addGeometryHandler: function ( typeID, loaderClass ) {
														
 
															+
														
 
															+		this.geometryHandlers[ typeID ] = { "loaderClass": loaderClass };
														
 
															+
														
 
															+	},
														
 
															+
														
 
															+	addHierarchyHandler: function ( typeID, loaderClass ) {
														
 
															+
														
 
															+		this.hierarchyHandlers[ typeID ] = { "loaderClass": loaderClass };
														
 
															+
														
 
															+	},
														
 
															+
														
 
															+	parse: function ( json, callbackFinished, url ) {
														
 
															+
														
 
															+		var scope = this;
														
 
															+
														
 
															+		var urlBase = THREE.Loader.prototype.extractUrlBase( url );
														
 
															+
														
 
															+		var geometry, material, camera, fog,
														
 
															+			texture, images, color,
														
 
															+			light, hex, intensity,
														
 
															+			counter_models, counter_textures,
														
 
															+			total_models, total_textures,
														
 
															+			result;
														
 
															+
														
 
															+		var target_array = [];
														
 
															+
														
 
															+		var data = json;
														
 
															+
														
 
															+		// async geometry loaders
														
 
															+
														
 
															+		for ( var typeID in this.geometryHandlers ) {
														
 
															+
														
 
															+			var loaderClass = this.geometryHandlers[ typeID ][ "loaderClass" ];
														
 
															+			this.geometryHandlers[ typeID ][ "loaderObject" ] = new loaderClass();
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		// async hierachy loaders
														
 
															+
														
 
															+		for ( var typeID in this.hierarchyHandlers ) {
														
 
															+
														
 
															+			var loaderClass = this.hierarchyHandlers[ typeID ][ "loaderClass" ];
														
 
															+			this.hierarchyHandlers[ typeID ][ "loaderObject" ] = new loaderClass();
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		counter_models = 0;
														
 
															+		counter_textures = 0;
														
 
															+
														
 
															+		result = {
														
 
															+
														
 
															+			scene: new THREE.Scene(),
														
 
															+			geometries: {},
														
 
															+			face_materials: {},
														
 
															+			materials: {},
														
 
															+			textures: {},
														
 
															+			objects: {},
														
 
															+			cameras: {},
														
 
															+			lights: {},
														
 
															+			fogs: {},
														
 
															+			empties: {},
														
 
															+			groups: {}
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+		if ( data.transform ) {
														
 
															+
														
 
															+			var position = data.transform.position,
														
 
															+				rotation = data.transform.rotation,
														
 
															+				scale = data.transform.scale;
														
 
															+
														
 
															+			if ( position ) {
														
 
															+
														
 
															+				result.scene.position.fromArray( position );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			if ( rotation ) {
														
 
															+
														
 
															+				result.scene.rotation.fromArray( rotation );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			if ( scale ) {
														
 
															+
														
 
															+				result.scene.scale.fromArray( scale );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			if ( position || rotation || scale ) {
														
 
															+
														
 
															+				result.scene.updateMatrix();
														
 
															+				result.scene.updateMatrixWorld();
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		function get_url( source_url, url_type ) {
														
 
															+
														
 
															+			if ( url_type == "relativeToHTML" ) {
														
 
															+
														
 
															+				return source_url;
														
 
															+
														
 
															+			} else {
														
 
															+
														
 
															+				return urlBase + source_url;
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+		// toplevel loader function, delegates to handle_children
														
 
															+
														
 
															+		function handle_objects() {
														
 
															+
														
 
															+			handle_children( result.scene, data.objects );
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		// handle all the children from the loaded json and attach them to given parent
														
 
															+
														
 
															+		function handle_children( parent, children ) {
														
 
															+
														
 
															+			var mat, dst, pos, rot, scl, quat;
														
 
															+
														
 
															+			for ( var objID in children ) {
														
 
															+
														
 
															+				// check by id if child has already been handled,
														
 
															+				// if not, create new object
														
 
															+
														
 
															+				var object = result.objects[ objID ];
														
 
															+				var objJSON = children[ objID ];
														
 
															+
														
 
															+				if ( object === undefined ) {
														
 
															+
														
 
															+					// meshes
														
 
															+
														
 
															+					if ( objJSON.type && ( objJSON.type in scope.hierarchyHandlers ) ) {
														
 
															+
														
 
															+						if ( objJSON.loading === undefined ) {
														
 
															+
														
 
															+							var reservedTypes = {
														
 
															+								"type": 1, "url": 1, "material": 1,
														
 
															+								"position": 1, "rotation": 1, "scale" : 1,
														
 
															+								"visible": 1, "children": 1, "userData": 1,
														
 
															+								"skin": 1, "morph": 1, "mirroredLoop": 1, "duration": 1
														
 
															+							};
														
 
															+
														
 
															+							var loaderParameters = {};
														
 
															+
														
 
															+							for ( var parType in objJSON ) {
														
 
															+
														
 
															+								if ( ! ( parType in reservedTypes ) ) {
														
 
															+
														
 
															+									loaderParameters[ parType ] = objJSON[ parType ];
														
 
															+
														
 
															+								}
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+							material = result.materials[ objJSON.material ];
														
 
															+
														
 
															+							objJSON.loading = true;
														
 
															+
														
 
															+							var loader = scope.hierarchyHandlers[ objJSON.type ][ "loaderObject" ];
														
 
															+
														
 
															+							// ColladaLoader
														
 
															+
														
 
															+							if ( loader.options ) {
														
 
															+
														
 
															+								loader.load( get_url( objJSON.url, data.urlBaseType ), create_callback_hierachy( objID, parent, material, objJSON ) );
														
 
															+
														
 
															+							// UTF8Loader
														
 
															+							// OBJLoader
														
 
															+
														
 
															+							} else {
														
 
															+
														
 
															+								loader.load( get_url( objJSON.url, data.urlBaseType ), create_callback_hierachy( objID, parent, material, objJSON ), loaderParameters );
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+						}
														
 
															+
														
 
															+					} else if ( objJSON.geometry !== undefined ) {
														
 
															+
														
 
															+						geometry = result.geometries[ objJSON.geometry ];
														
 
															+
														
 
															+						// geometry already loaded
														
 
															+
														
 
															+						if ( geometry ) {
														
 
															+
														
 
															+							var needsTangents = false;
														
 
															+
														
 
															+							material = result.materials[ objJSON.material ];
														
 
															+							needsTangents = material instanceof THREE.ShaderMaterial;
														
 
															+
														
 
															+							pos = objJSON.position;
														
 
															+							rot = objJSON.rotation;
														
 
															+							scl = objJSON.scale;
														
 
															+							mat = objJSON.matrix;
														
 
															+							quat = objJSON.quaternion;
														
 
															+
														
 
															+							// use materials from the model file
														
 
															+							// if there is no material specified in the object
														
 
															+
														
 
															+							if ( ! objJSON.material ) {
														
 
															+
														
 
															+								material = new THREE.MeshFaceMaterial( result.face_materials[ objJSON.geometry ] );
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+							// use materials from the model file
														
 
															+							// if there is just empty face material
														
 
															+							// (must create new material as each model has its own face material)
														
 
															+
														
 
															+							if ( ( material instanceof THREE.MeshFaceMaterial ) && material.materials.length === 0 ) {
														
 
															+
														
 
															+								material = new THREE.MeshFaceMaterial( result.face_materials[ objJSON.geometry ] );
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+							if ( material instanceof THREE.MeshFaceMaterial ) {
														
 
															+
														
 
															+								for ( var i = 0; i < material.materials.length; i ++ ) {
														
 
															+
														
 
															+									needsTangents = needsTangents || ( material.materials[ i ] instanceof THREE.ShaderMaterial );
														
 
															+
														
 
															+								}
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+							if ( needsTangents ) {
														
 
															+
														
 
															+								geometry.computeTangents();
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+							if ( objJSON.skin ) {
														
 
															+
														
 
															+								object = new THREE.SkinnedMesh( geometry, material );
														
 
															+
														
 
															+							} else if ( objJSON.morph ) {
														
 
															+
														
 
															+								object = new THREE.MorphAnimMesh( geometry, material );
														
 
															+
														
 
															+								if ( objJSON.duration !== undefined ) {
														
 
															+
														
 
															+									object.duration = objJSON.duration;
														
 
															+
														
 
															+								}
														
 
															+
														
 
															+								if ( objJSON.time !== undefined ) {
														
 
															+
														
 
															+									object.time = objJSON.time;
														
 
															+
														
 
															+								}
														
 
															+
														
 
															+								if ( objJSON.mirroredLoop !== undefined ) {
														
 
															+
														
 
															+									object.mirroredLoop = objJSON.mirroredLoop;
														
 
															+
														
 
															+								}
														
 
															+
														
 
															+								if ( material.morphNormals ) {
														
 
															+
														
 
															+									geometry.computeMorphNormals();
														
 
															+
														
 
															+								}
														
 
															+
														
 
															+							} else {
														
 
															+
														
 
															+								object = new THREE.Mesh( geometry, material );
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+							object.name = objID;
														
 
															+
														
 
															+							if ( mat ) {
														
 
															+
														
 
															+								object.matrixAutoUpdate = false;
														
 
															+								object.matrix.set(
														
 
															+									mat[0],  mat[1],  mat[2],  mat[3],
														
 
															+									mat[4],  mat[5],  mat[6],  mat[7],
														
 
															+									mat[8],  mat[9],  mat[10], mat[11],
														
 
															+									mat[12], mat[13], mat[14], mat[15]
														
 
															+								);
														
 
															+
														
 
															+							} else {
														
 
															+
														
 
															+								object.position.fromArray( pos );
														
 
															+
														
 
															+								if ( quat ) {
														
 
															+
														
 
															+									object.quaternion.fromArray( quat );
														
 
															+
														
 
															+								} else {
														
 
															+
														
 
															+									object.rotation.fromArray( rot );
														
 
															+
														
 
															+								}
														
 
															+
														
 
															+								object.scale.fromArray( scl );
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+							object.visible = objJSON.visible;
														
 
															+							object.castShadow = objJSON.castShadow;
														
 
															+							object.receiveShadow = objJSON.receiveShadow;
														
 
															+
														
 
															+							parent.add( object );
														
 
															+
														
 
															+							result.objects[ objID ] = object;
														
 
															+
														
 
															+						}
														
 
															+
														
 
															+					// lights
														
 
															+
														
 
															+					} else if ( objJSON.type === "AmbientLight" || objJSON.type === "PointLight" ||
														
 
															+						objJSON.type === "DirectionalLight" || objJSON.type === "SpotLight" ||
														
 
															+						objJSON.type === "HemisphereLight" || objJSON.type === "AreaLight" ) {
														
 
															+
														
 
															+						var color = objJSON.color;
														
 
															+						var intensity = objJSON.intensity;
														
 
															+						var distance = objJSON.distance;
														
 
															+						var position = objJSON.position;
														
 
															+						var rotation = objJSON.rotation;
														
 
															+
														
 
															+						switch ( objJSON.type ) {
														
 
															+
														
 
															+							case 'AmbientLight':
														
 
															+								light = new THREE.AmbientLight( color );
														
 
															+								break;
														
 
															+
														
 
															+							case 'PointLight':
														
 
															+								light = new THREE.PointLight( color, intensity, distance );
														
 
															+								light.position.fromArray( position );
														
 
															+								break;
														
 
															+
														
 
															+							case 'DirectionalLight':
														
 
															+								light = new THREE.DirectionalLight( color, intensity );
														
 
															+								light.position.fromArray( objJSON.direction );
														
 
															+								break;
														
 
															+
														
 
															+							case 'SpotLight':
														
 
															+								light = new THREE.SpotLight( color, intensity, distance, 1 );
														
 
															+								light.angle = objJSON.angle;
														
 
															+								light.position.fromArray( position );
														
 
															+								light.target.set( position[ 0 ], position[ 1 ] - distance, position[ 2 ] );
														
 
															+								light.target.applyEuler( new THREE.Euler( rotation[ 0 ], rotation[ 1 ], rotation[ 2 ], 'XYZ' ) );
														
 
															+								break;
														
 
															+
														
 
															+							case 'HemisphereLight':
														
 
															+								light = new THREE.DirectionalLight( color, intensity, distance );
														
 
															+								light.target.set( position[ 0 ], position[ 1 ] - distance, position[ 2 ] );
														
 
															+								light.target.applyEuler( new THREE.Euler( rotation[ 0 ], rotation[ 1 ], rotation[ 2 ], 'XYZ' ) );
														
 
															+								break;
														
 
															+
														
 
															+							case 'AreaLight':
														
 
															+								light = new THREE.AreaLight(color, intensity);
														
 
															+								light.position.fromArray( position );
														
 
															+								light.width = objJSON.size;
														
 
															+								light.height = objJSON.size_y;
														
 
															+								break;
														
 
															+
														
 
															+						}
														
 
															+
														
 
															+						parent.add( light );
														
 
															+
														
 
															+						light.name = objID;
														
 
															+						result.lights[ objID ] = light;
														
 
															+						result.objects[ objID ] = light;
														
 
															+
														
 
															+					// cameras
														
 
															+
														
 
															+					} else if ( objJSON.type === "PerspectiveCamera" || objJSON.type === "OrthographicCamera" ) {
														
 
															+
														
 
															+						pos = objJSON.position;
														
 
															+						rot = objJSON.rotation;
														
 
															+						quat = objJSON.quaternion;
														
 
															+
														
 
															+						if ( objJSON.type === "PerspectiveCamera" ) {
														
 
															+
														
 
															+							camera = new THREE.PerspectiveCamera( objJSON.fov, objJSON.aspect, objJSON.near, objJSON.far );
														
 
															+
														
 
															+						} else if ( objJSON.type === "OrthographicCamera" ) {
														
 
															+
														
 
															+							camera = new THREE.OrthographicCamera( objJSON.left, objJSON.right, objJSON.top, objJSON.bottom, objJSON.near, objJSON.far );
														
 
															+
														
 
															+						}
														
 
															+
														
 
															+						camera.name = objID;
														
 
															+						camera.position.fromArray( pos );
														
 
															+
														
 
															+						if ( quat !== undefined ) {
														
 
															+
														
 
															+							camera.quaternion.fromArray( quat );
														
 
															+
														
 
															+						} else if ( rot !== undefined ) {
														
 
															+
														
 
															+							camera.rotation.fromArray( rot );
														
 
															+
														
 
															+						}
														
 
															+
														
 
															+						parent.add( camera );
														
 
															+
														
 
															+						result.cameras[ objID ] = camera;
														
 
															+						result.objects[ objID ] = camera;
														
 
															+
														
 
															+					// pure Object3D
														
 
															+
														
 
															+					} else {
														
 
															+
														
 
															+						pos = objJSON.position;
														
 
															+						rot = objJSON.rotation;
														
 
															+						scl = objJSON.scale;
														
 
															+						quat = objJSON.quaternion;
														
 
															+
														
 
															+						object = new THREE.Object3D();
														
 
															+						object.name = objID;
														
 
															+						object.position.fromArray( pos );
														
 
															+
														
 
															+						if ( quat ) {
														
 
															+
														
 
															+							object.quaternion.fromArray( quat );
														
 
															+
														
 
															+						} else {
														
 
															+
														
 
															+							object.rotation.fromArray( rot );
														
 
															+
														
 
															+						}
														
 
															+
														
 
															+						object.scale.fromArray( scl );
														
 
															+						object.visible = ( objJSON.visible !== undefined ) ? objJSON.visible : false;
														
 
															+
														
 
															+						parent.add( object );
														
 
															+
														
 
															+						result.objects[ objID ] = object;
														
 
															+						result.empties[ objID ] = object;
														
 
															+
														
 
															+					}
														
 
															+
														
 
															+					if ( object ) {
														
 
															+
														
 
															+						if ( objJSON.userData !== undefined ) {
														
 
															+
														
 
															+							for ( var key in objJSON.userData ) {
														
 
															+
														
 
															+								var value = objJSON.userData[ key ];
														
 
															+								object.userData[ key ] = value;
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+						}
														
 
															+
														
 
															+						if ( objJSON.groups !== undefined ) {
														
 
															+
														
 
															+							for ( var i = 0; i < objJSON.groups.length; i ++ ) {
														
 
															+
														
 
															+								var groupID = objJSON.groups[ i ];
														
 
															+
														
 
															+								if ( result.groups[ groupID ] === undefined ) {
														
 
															+
														
 
															+									result.groups[ groupID ] = [];
														
 
															+
														
 
															+								}
														
 
															+
														
 
															+								result.groups[ groupID ].push( objID );
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+						}
														
 
															+
														
 
															+					}
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				if ( object !== undefined && objJSON.children !== undefined ) {
														
 
															+
														
 
															+					handle_children( object, objJSON.children );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+		function handle_mesh( geo, mat, id ) {
														
 
															+
														
 
															+			result.geometries[ id ] = geo;
														
 
															+			result.face_materials[ id ] = mat;
														
 
															+			handle_objects();
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+		function handle_hierarchy( node, id, parent, material, obj ) {
														
 
															+
														
 
															+			var p = obj.position;
														
 
															+			var r = obj.rotation;
														
 
															+			var q = obj.quaternion;
														
 
															+			var s = obj.scale;
														
 
															+
														
 
															+			node.position.fromArray( p );
														
 
															+
														
 
															+			if ( q ) {
														
 
															+
														
 
															+				node.quaternion.fromArray( q );
														
 
															+
														
 
															+			} else {
														
 
															+
														
 
															+				node.rotation.fromArray( r );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			node.scale.fromArray( s );
														
 
															+
														
 
															+			// override children materials
														
 
															+			// if object material was specified in JSON explicitly
														
 
															+
														
 
															+			if ( material ) {
														
 
															+
														
 
															+				node.traverse( function ( child ) {
														
 
															+
														
 
															+					child.material = material;
														
 
															+
														
 
															+				} );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			// override children visibility
														
 
															+			// with root node visibility as specified in JSON
														
 
															+
														
 
															+			var visible = ( obj.visible !== undefined ) ? obj.visible : true;
														
 
															+
														
 
															+			node.traverse( function ( child ) {
														
 
															+
														
 
															+				child.visible = visible;
														
 
															+
														
 
															+			} );
														
 
															+
														
 
															+			parent.add( node );
														
 
															+
														
 
															+			node.name = id;
														
 
															+
														
 
															+			result.objects[ id ] = node;
														
 
															+			handle_objects();
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+		function create_callback_geometry( id ) {
														
 
															+
														
 
															+			return function ( geo, mat ) {
														
 
															+
														
 
															+				geo.name = id;
														
 
															+
														
 
															+				handle_mesh( geo, mat, id );
														
 
															+
														
 
															+				counter_models -= 1;
														
 
															+
														
 
															+				scope.onLoadComplete();
														
 
															+
														
 
															+				async_callback_gate();
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+		function create_callback_hierachy( id, parent, material, obj ) {
														
 
															+
														
 
															+			return function ( event ) {
														
 
															+
														
 
															+				var result;
														
 
															+
														
 
															+				// loaders which use EventDispatcher
														
 
															+
														
 
															+				if ( event.content ) {
														
 
															+
														
 
															+					result = event.content;
														
 
															+
														
 
															+				// ColladaLoader
														
 
															+
														
 
															+				} else if ( event.dae ) {
														
 
															+
														
 
															+					result = event.scene;
														
 
															+
														
 
															+
														
 
															+				// UTF8Loader
														
 
															+
														
 
															+				} else {
														
 
															+
														
 
															+					result = event;
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				handle_hierarchy( result, id, parent, material, obj );
														
 
															+
														
 
															+				counter_models -= 1;
														
 
															+
														
 
															+				scope.onLoadComplete();
														
 
															+
														
 
															+				async_callback_gate();
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+		function create_callback_embed( id ) {
														
 
															+
														
 
															+			return function ( geo, mat ) {
														
 
															+
														
 
															+				geo.name = id;
														
 
															+
														
 
															+				result.geometries[ id ] = geo;
														
 
															+				result.face_materials[ id ] = mat;
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+		function async_callback_gate() {
														
 
															+
														
 
															+			var progress = {
														
 
															+
														
 
															+				totalModels : total_models,
														
 
															+				totalTextures : total_textures,
														
 
															+				loadedModels : total_models - counter_models,
														
 
															+				loadedTextures : total_textures - counter_textures
														
 
															+
														
 
															+			};
														
 
															+
														
 
															+			scope.callbackProgress( progress, result );
														
 
															+
														
 
															+			scope.onLoadProgress();
														
 
															+
														
 
															+			if ( counter_models === 0 && counter_textures === 0 ) {
														
 
															+
														
 
															+				finalize();
														
 
															+				callbackFinished( result );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+		function finalize() {
														
 
															+
														
 
															+			// take care of targets which could be asynchronously loaded objects
														
 
															+
														
 
															+			for ( var i = 0; i < target_array.length; i ++ ) {
														
 
															+
														
 
															+				var ta = target_array[ i ];
														
 
															+
														
 
															+				var target = result.objects[ ta.targetName ];
														
 
															+
														
 
															+				if ( target ) {
														
 
															+
														
 
															+					ta.object.target = target;
														
 
															+
														
 
															+				} else {
														
 
															+
														
 
															+					// if there was error and target of specified name doesn't exist in the scene file
														
 
															+					// create instead dummy target
														
 
															+					// (target must be added to scene explicitly as parent is already added)
														
 
															+
														
 
															+					ta.object.target = new THREE.Object3D();
														
 
															+					result.scene.add( ta.object.target );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				ta.object.target.userData.targetInverse = ta.object;
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+		var callbackTexture = function ( count ) {
														
 
															+
														
 
															+			counter_textures -= count;
														
 
															+			async_callback_gate();
														
 
															+
														
 
															+			scope.onLoadComplete();
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+		// must use this instead of just directly calling callbackTexture
														
 
															+		// because of closure in the calling context loop
														
 
															+
														
 
															+		var generateTextureCallback = function ( count ) {
														
 
															+
														
 
															+			return function () {
														
 
															+
														
 
															+				callbackTexture( count );
														
 
															+
														
 
															+			};
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+		function traverse_json_hierarchy( objJSON, callback ) {
														
 
															+
														
 
															+			callback( objJSON );
														
 
															+
														
 
															+			if ( objJSON.children !== undefined ) {
														
 
															+
														
 
															+				for ( var objChildID in objJSON.children ) {
														
 
															+
														
 
															+					traverse_json_hierarchy( objJSON.children[ objChildID ], callback );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+		// first go synchronous elements
														
 
															+
														
 
															+		// fogs
														
 
															+
														
 
															+		var fogID, fogJSON;
														
 
															+
														
 
															+		for ( fogID in data.fogs ) {
														
 
															+
														
 
															+			fogJSON = data.fogs[ fogID ];
														
 
															+
														
 
															+			if ( fogJSON.type === "linear" ) {
														
 
															+
														
 
															+				fog = new THREE.Fog( 0x000000, fogJSON.near, fogJSON.far );
														
 
															+
														
 
															+			} else if ( fogJSON.type === "exp2" ) {
														
 
															+
														
 
															+				fog = new THREE.FogExp2( 0x000000, fogJSON.density );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			color = fogJSON.color;
														
 
															+			fog.color.setRGB( color[0], color[1], color[2] );
														
 
															+
														
 
															+			result.fogs[ fogID ] = fog;
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		// now come potentially asynchronous elements
														
 
															+
														
 
															+		// geometries
														
 
															+
														
 
															+		// count how many geometries will be loaded asynchronously
														
 
															+
														
 
															+		var geoID, geoJSON;
														
 
															+
														
 
															+		for ( geoID in data.geometries ) {
														
 
															+
														
 
															+			geoJSON = data.geometries[ geoID ];
														
 
															+
														
 
															+			if ( geoJSON.type in this.geometryHandlers ) {
														
 
															+
														
 
															+				counter_models += 1;
														
 
															+
														
 
															+				scope.onLoadStart();
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		// count how many hierarchies will be loaded asynchronously
														
 
															+
														
 
															+		for ( var objID in data.objects ) {
														
 
															+
														
 
															+			traverse_json_hierarchy( data.objects[ objID ], function ( objJSON ) {
														
 
															+
														
 
															+				if ( objJSON.type && ( objJSON.type in scope.hierarchyHandlers ) ) {
														
 
															+
														
 
															+					counter_models += 1;
														
 
															+
														
 
															+					scope.onLoadStart();
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+			});
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		total_models = counter_models;
														
 
															+
														
 
															+		for ( geoID in data.geometries ) {
														
 
															+
														
 
															+			geoJSON = data.geometries[ geoID ];
														
 
															+
														
 
															+			if ( geoJSON.type === "cube" ) {
														
 
															+
														
 
															+				geometry = new THREE.BoxGeometry( geoJSON.width, geoJSON.height, geoJSON.depth, geoJSON.widthSegments, geoJSON.heightSegments, geoJSON.depthSegments );
														
 
															+				geometry.name = geoID;
														
 
															+				result.geometries[ geoID ] = geometry;
														
 
															+
														
 
															+			} else if ( geoJSON.type === "plane" ) {
														
 
															+
														
 
															+				geometry = new THREE.PlaneGeometry( geoJSON.width, geoJSON.height, geoJSON.widthSegments, geoJSON.heightSegments );
														
 
															+				geometry.name = geoID;
														
 
															+				result.geometries[ geoID ] = geometry;
														
 
															+
														
 
															+			} else if ( geoJSON.type === "sphere" ) {
														
 
															+
														
 
															+				geometry = new THREE.SphereGeometry( geoJSON.radius, geoJSON.widthSegments, geoJSON.heightSegments );
														
 
															+				geometry.name = geoID;
														
 
															+				result.geometries[ geoID ] = geometry;
														
 
															+
														
 
															+			} else if ( geoJSON.type === "cylinder" ) {
														
 
															+
														
 
															+				geometry = new THREE.CylinderGeometry( geoJSON.topRad, geoJSON.botRad, geoJSON.height, geoJSON.radSegs, geoJSON.heightSegs );
														
 
															+				geometry.name = geoID;
														
 
															+				result.geometries[ geoID ] = geometry;
														
 
															+
														
 
															+			} else if ( geoJSON.type === "torus" ) {
														
 
															+
														
 
															+				geometry = new THREE.TorusGeometry( geoJSON.radius, geoJSON.tube, geoJSON.segmentsR, geoJSON.segmentsT );
														
 
															+				geometry.name = geoID;
														
 
															+				result.geometries[ geoID ] = geometry;
														
 
															+
														
 
															+			} else if ( geoJSON.type === "icosahedron" ) {
														
 
															+
														
 
															+				geometry = new THREE.IcosahedronGeometry( geoJSON.radius, geoJSON.subdivisions );
														
 
															+				geometry.name = geoID;
														
 
															+				result.geometries[ geoID ] = geometry;
														
 
															+
														
 
															+			} else if ( geoJSON.type in this.geometryHandlers ) {
														
 
															+
														
 
															+				var loaderParameters = {};
														
 
															+
														
 
															+				for ( var parType in geoJSON ) {
														
 
															+
														
 
															+					if ( parType !== "type" && parType !== "url" ) {
														
 
															+
														
 
															+						loaderParameters[ parType ] = geoJSON[ parType ];
														
 
															+
														
 
															+					}
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				var loader = this.geometryHandlers[ geoJSON.type ][ "loaderObject" ];
														
 
															+				loader.load( get_url( geoJSON.url, data.urlBaseType ), create_callback_geometry( geoID ), loaderParameters );
														
 
															+
														
 
															+			} else if ( geoJSON.type === "embedded" ) {
														
 
															+
														
 
															+				var modelJson = data.embeds[ geoJSON.id ],
														
 
															+					texture_path = "";
														
 
															+
														
 
															+				// pass metadata along to jsonLoader so it knows the format version
														
 
															+
														
 
															+				modelJson.metadata = data.metadata;
														
 
															+
														
 
															+				if ( modelJson ) {
														
 
															+
														
 
															+					var jsonLoader = this.geometryHandlers[ "ascii" ][ "loaderObject" ];
														
 
															+					var model = jsonLoader.parse( modelJson, texture_path );
														
 
															+					create_callback_embed( geoID )( model.geometry, model.materials );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		// textures
														
 
															+
														
 
															+		// count how many textures will be loaded asynchronously
														
 
															+
														
 
															+		var textureID, textureJSON;
														
 
															+
														
 
															+		for ( textureID in data.textures ) {
														
 
															+
														
 
															+			textureJSON = data.textures[ textureID ];
														
 
															+
														
 
															+			if ( textureJSON.url instanceof Array ) {
														
 
															+
														
 
															+				counter_textures += textureJSON.url.length;
														
 
															+
														
 
															+				for( var n = 0; n < textureJSON.url.length; n ++ ) {
														
 
															+
														
 
															+					scope.onLoadStart();
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+			} else {
														
 
															+
														
 
															+				counter_textures += 1;
														
 
															+
														
 
															+				scope.onLoadStart();
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		total_textures = counter_textures;
														
 
															+
														
 
															+		for ( textureID in data.textures ) {
														
 
															+
														
 
															+			textureJSON = data.textures[ textureID ];
														
 
															+
														
 
															+			if ( textureJSON.mapping !== undefined && THREE[ textureJSON.mapping ] !== undefined ) {
														
 
															+
														
 
															+				textureJSON.mapping = new THREE[ textureJSON.mapping ]();
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			var texture;
														
 
															+
														
 
															+			if ( textureJSON.url instanceof Array ) {
														
 
															+
														
 
															+				var count = textureJSON.url.length;
														
 
															+				var url_array = [];
														
 
															+
														
 
															+				for ( var i = 0; i < count; i ++ ) {
														
 
															+
														
 
															+					url_array[ i ] = get_url( textureJSON.url[ i ], data.urlBaseType );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				var loader = THREE.Loader.Handlers.get( url_array[ 0 ] );
														
 
															+
														
 
															+				if ( loader !== null ) {
														
 
															+
														
 
															+					texture = loader.load( url_array, generateTextureCallback( count ) );
														
 
															+					texture.mapping = textureJSON.mapping;
														
 
															+
														
 
															+				} else {
														
 
															+
														
 
															+					texture = THREE.ImageUtils.loadTextureCube( url_array, textureJSON.mapping, generateTextureCallback( count ) );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+			} else {
														
 
															+
														
 
															+				var fullUrl = get_url( textureJSON.url, data.urlBaseType );
														
 
															+				var textureCallback = generateTextureCallback( 1 );
														
 
															+
														
 
															+				var loader = THREE.Loader.Handlers.get( fullUrl );
														
 
															+
														
 
															+				if ( loader !== null ) {
														
 
															+
														
 
															+					texture = loader.load( fullUrl, textureCallback );
														
 
															+
														
 
															+				} else {
														
 
															+
														
 
															+					texture = new THREE.Texture();
														
 
															+					loader = new THREE.ImageLoader();
														
 
															+					
														
 
															+					( function ( texture ) {
														
 
															+
														
 
															+						loader.load( fullUrl, function ( image ) {
														
 
															+
														
 
															+							texture.image = image;
														
 
															+							texture.needsUpdate = true;
														
 
															+
														
 
															+							textureCallback();
														
 
															+
														
 
															+						} );
														
 
															+					
														
 
															+					} )( texture )
														
 
															+					
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				texture.mapping = textureJSON.mapping;
														
 
															+
														
 
															+				if ( THREE[ textureJSON.minFilter ] !== undefined )
														
 
															+					texture.minFilter = THREE[ textureJSON.minFilter ];
														
 
															+
														
 
															+				if ( THREE[ textureJSON.magFilter ] !== undefined )
														
 
															+					texture.magFilter = THREE[ textureJSON.magFilter ];
														
 
															+
														
 
															+				if ( textureJSON.anisotropy ) texture.anisotropy = textureJSON.anisotropy;
														
 
															+
														
 
															+				if ( textureJSON.repeat ) {
														
 
															+
														
 
															+					texture.repeat.set( textureJSON.repeat[ 0 ], textureJSON.repeat[ 1 ] );
														
 
															+
														
 
															+					if ( textureJSON.repeat[ 0 ] !== 1 ) texture.wrapS = THREE.RepeatWrapping;
														
 
															+					if ( textureJSON.repeat[ 1 ] !== 1 ) texture.wrapT = THREE.RepeatWrapping;
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				if ( textureJSON.offset ) {
														
 
															+
														
 
															+					texture.offset.set( textureJSON.offset[ 0 ], textureJSON.offset[ 1 ] );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				// handle wrap after repeat so that default repeat can be overriden
														
 
															+
														
 
															+				if ( textureJSON.wrap ) {
														
 
															+
														
 
															+					var wrapMap = {
														
 
															+						"repeat": THREE.RepeatWrapping,
														
 
															+						"mirror": THREE.MirroredRepeatWrapping
														
 
															+					}
														
 
															+
														
 
															+					if ( wrapMap[ textureJSON.wrap[ 0 ] ] !== undefined ) texture.wrapS = wrapMap[ textureJSON.wrap[ 0 ] ];
														
 
															+					if ( wrapMap[ textureJSON.wrap[ 1 ] ] !== undefined ) texture.wrapT = wrapMap[ textureJSON.wrap[ 1 ] ];
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			result.textures[ textureID ] = texture;
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		// materials
														
 
															+
														
 
															+		var matID, matJSON;
														
 
															+		var parID;
														
 
															+
														
 
															+		for ( matID in data.materials ) {
														
 
															+
														
 
															+			matJSON = data.materials[ matID ];
														
 
															+
														
 
															+			for ( parID in matJSON.parameters ) {
														
 
															+
														
 
															+				if ( parID === "envMap" || parID === "map" || parID === "lightMap" || parID === "bumpMap" ) {
														
 
															+
														
 
															+					matJSON.parameters[ parID ] = result.textures[ matJSON.parameters[ parID ] ];
														
 
															+
														
 
															+				} else if ( parID === "shading" ) {
														
 
															+
														
 
															+					matJSON.parameters[ parID ] = ( matJSON.parameters[ parID ] === "flat" ) ? THREE.FlatShading : THREE.SmoothShading;
														
 
															+
														
 
															+				} else if ( parID === "side" ) {
														
 
															+
														
 
															+					if ( matJSON.parameters[ parID ] == "double" ) {
														
 
															+
														
 
															+						matJSON.parameters[ parID ] = THREE.DoubleSide;
														
 
															+
														
 
															+					} else if ( matJSON.parameters[ parID ] == "back" ) {
														
 
															+
														
 
															+						matJSON.parameters[ parID ] = THREE.BackSide;
														
 
															+
														
 
															+					} else {
														
 
															+
														
 
															+						matJSON.parameters[ parID ] = THREE.FrontSide;
														
 
															+
														
 
															+					}
														
 
															+
														
 
															+				} else if ( parID === "blending" ) {
														
 
															+
														
 
															+					matJSON.parameters[ parID ] = matJSON.parameters[ parID ] in THREE ? THREE[ matJSON.parameters[ parID ] ] : THREE.NormalBlending;
														
 
															+
														
 
															+				} else if ( parID === "combine" ) {
														
 
															+
														
 
															+					matJSON.parameters[ parID ] = matJSON.parameters[ parID ] in THREE ? THREE[ matJSON.parameters[ parID ] ] : THREE.MultiplyOperation;
														
 
															+
														
 
															+				} else if ( parID === "vertexColors" ) {
														
 
															+
														
 
															+					if ( matJSON.parameters[ parID ] == "face" ) {
														
 
															+
														
 
															+						matJSON.parameters[ parID ] = THREE.FaceColors;
														
 
															+
														
 
															+					// default to vertex colors if "vertexColors" is anything else face colors or 0 / null / false
														
 
															+
														
 
															+					} else if ( matJSON.parameters[ parID ] ) {
														
 
															+
														
 
															+						matJSON.parameters[ parID ] = THREE.VertexColors;
														
 
															+
														
 
															+					}
														
 
															+
														
 
															+				} else if ( parID === "wrapRGB" ) {
														
 
															+
														
 
															+					var v3 = matJSON.parameters[ parID ];
														
 
															+					matJSON.parameters[ parID ] = new THREE.Vector3( v3[ 0 ], v3[ 1 ], v3[ 2 ] );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			if ( matJSON.parameters.opacity !== undefined && matJSON.parameters.opacity < 1.0 ) {
														
 
															+
														
 
															+				matJSON.parameters.transparent = true;
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			if ( matJSON.parameters.normalMap ) {
														
 
															+
														
 
															+				var shader = THREE.ShaderLib[ "normalmap" ];
														
 
															+				var uniforms = THREE.UniformsUtils.clone( shader.uniforms );
														
 
															+
														
 
															+				var diffuse = matJSON.parameters.color;
														
 
															+				var specular = matJSON.parameters.specular;
														
 
															+				var ambient = matJSON.parameters.ambient;
														
 
															+				var shininess = matJSON.parameters.shininess;
														
 
															+
														
 
															+				uniforms[ "tNormal" ].value = result.textures[ matJSON.parameters.normalMap ];
														
 
															+
														
 
															+				if ( matJSON.parameters.normalScale ) {
														
 
															+
														
 
															+					uniforms[ "uNormalScale" ].value.set( matJSON.parameters.normalScale[ 0 ], matJSON.parameters.normalScale[ 1 ] );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				if ( matJSON.parameters.map ) {
														
 
															+
														
 
															+					uniforms[ "tDiffuse" ].value = matJSON.parameters.map;
														
 
															+					uniforms[ "enableDiffuse" ].value = true;
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				if ( matJSON.parameters.envMap ) {
														
 
															+
														
 
															+					uniforms[ "tCube" ].value = matJSON.parameters.envMap;
														
 
															+					uniforms[ "enableReflection" ].value = true;
														
 
															+					uniforms[ "reflectivity" ].value = matJSON.parameters.reflectivity;
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				if ( matJSON.parameters.lightMap ) {
														
 
															+
														
 
															+					uniforms[ "tAO" ].value = matJSON.parameters.lightMap;
														
 
															+					uniforms[ "enableAO" ].value = true;
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				if ( matJSON.parameters.specularMap ) {
														
 
															+
														
 
															+					uniforms[ "tSpecular" ].value = result.textures[ matJSON.parameters.specularMap ];
														
 
															+					uniforms[ "enableSpecular" ].value = true;
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				if ( matJSON.parameters.displacementMap ) {
														
 
															+
														
 
															+					uniforms[ "tDisplacement" ].value = result.textures[ matJSON.parameters.displacementMap ];
														
 
															+					uniforms[ "enableDisplacement" ].value = true;
														
 
															+
														
 
															+					uniforms[ "uDisplacementBias" ].value = matJSON.parameters.displacementBias;
														
 
															+					uniforms[ "uDisplacementScale" ].value = matJSON.parameters.displacementScale;
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				uniforms[ "diffuse" ].value.setHex( diffuse );
														
 
															+				uniforms[ "specular" ].value.setHex( specular );
														
 
															+				uniforms[ "ambient" ].value.setHex( ambient );
														
 
															+
														
 
															+				uniforms[ "shininess" ].value = shininess;
														
 
															+
														
 
															+				if ( matJSON.parameters.opacity ) {
														
 
															+
														
 
															+					uniforms[ "opacity" ].value = matJSON.parameters.opacity;
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				var parameters = { fragmentShader: shader.fragmentShader, vertexShader: shader.vertexShader, uniforms: uniforms, lights: true, fog: true };
														
 
															+
														
 
															+				material = new THREE.ShaderMaterial( parameters );
														
 
															+
														
 
															+			} else {
														
 
															+
														
 
															+				material = new THREE[ matJSON.type ]( matJSON.parameters );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			material.name = matID;
														
 
															+
														
 
															+			result.materials[ matID ] = material;
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		// second pass through all materials to initialize MeshFaceMaterials
														
 
															+		// that could be referring to other materials out of order
														
 
															+
														
 
															+		for ( matID in data.materials ) {
														
 
															+
														
 
															+			matJSON = data.materials[ matID ];
														
 
															+
														
 
															+			if ( matJSON.parameters.materials ) {
														
 
															+
														
 
															+				var materialArray = [];
														
 
															+
														
 
															+				for ( var i = 0; i < matJSON.parameters.materials.length; i ++ ) {
														
 
															+
														
 
															+					var label = matJSON.parameters.materials[ i ];
														
 
															+					materialArray.push( result.materials[ label ] );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				result.materials[ matID ].materials = materialArray;
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		// objects ( synchronous init of procedural primitives )
														
 
															+
														
 
															+		handle_objects();
														
 
															+
														
 
															+		// defaults
														
 
															+
														
 
															+		if ( result.cameras && data.defaults.camera ) {
														
 
															+
														
 
															+			result.currentCamera = result.cameras[ data.defaults.camera ];
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		if ( result.fogs && data.defaults.fog ) {
														
 
															+
														
 
															+			result.scene.fog = result.fogs[ data.defaults.fog ];
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		// synchronous callback
														
 
															+
														
 
															+		scope.callbackSync( result );
														
 
															+
														
 
															+		// just in case there are no async elements
														
 
															+
														
 
															+		async_callback_gate();
														
 
															+
														
 
															+	}
														
 
															+
														
 
															+}
														
--- a/examples/js/renderers/CSS2DRenderer.js
+++ b/examples/js/renderers/CSS2DRenderer.js
@@ -15,12 +15,6 @@ THREE.CSS2DObject = function ( element ) {
 
															 			this.element.parentNode.removeChild( this.element );
														
 
															-			for ( var i = 0, l = this.children.length; i < l; i ++ ) {
														
 
															-
														
 
															-				this.children[ i ].dispatchEvent( event );
														
 
															-
														
 
															-			}
														
 
															-
														
 
															 		}
														
 
															 	} );
														
@@ -33,7 +27,7 @@ THREE.CSS2DObject.prototype = Object.create( THREE.Object3D.prototype );
 
															 THREE.CSS2DRenderer = function () {
														
 
															-	console.log( 'THREE.CSS3DRenderer', THREE.REVISION );
														
 
															+	console.log( 'THREE.CSS2DRenderer', THREE.REVISION );
														
 
															 	var _width, _height;
														
 
															 	var _widthHalf, _heightHalf;
														
--- a/examples/js/renderers/CSS3DRenderer.js
+++ b/examples/js/renderers/CSS3DRenderer.js
@@ -16,12 +16,6 @@ THREE.CSS3DObject = function ( element ) {
 
															 			this.element.parentNode.removeChild( this.element );
														
 
															-			for ( var i = 0, l = this.children.length; i < l; i ++ ) {
														
 
															-
														
 
															-				this.children[ i ].dispatchEvent( event );
														
 
															-
														
 
															-			}
														
 
															-
														
 
															 		}
														
 
															 	} );
														
--- a/examples/js/renderers/WebGLRenderer3.js
+++ b/examples/js/renderers/WebGLRenderer3.js
@@ -426,7 +426,7 @@ THREE.WebGLRenderer3 = function ( parameters ) {
 
															 	var objectsOpaque = [];
														
 
															 	var objectsTransparent = [];
														
 
															-	var projectObject = function ( object, camera ) {
														
 
															+	var projectObject = function ( object ) {
														
 
															 		if ( object.visible === false ) return;
														
@@ -461,7 +461,7 @@ THREE.WebGLRenderer3 = function ( parameters ) {
 
															 		for ( var i = 0, l = object.children.length; i < l; i ++ ) {
														
 
															-			projectObject( object.children[ i ], camera );
														
 
															+			projectObject( object.children[ i ] );
														
 
															 		}
														
@@ -610,7 +610,7 @@ THREE.WebGLRenderer3 = function ( parameters ) {
 
															 		currentMaterial = undefined;
														
 
															 		currentProgram = undefined;
														
 
															-		projectObject( scene, camera );
														
 
															+		projectObject( scene );
														
 
															 		if ( objectsOpaque.length > 0 ) {
														
--- a/examples/js/shaders/FXAAShader.js
+++ b/examples/js/shaders/FXAAShader.js
@@ -49,8 +49,6 @@ THREE.FXAAShader = {
 
															 			"vec3 rgbSE = texture2D( tDiffuse, ( gl_FragCoord.xy + vec2( 1.0, 1.0 ) ) * resolution ).xyz;",
														
 
															 			"vec4 rgbaM  = texture2D( tDiffuse,  gl_FragCoord.xy  * resolution );",
														
 
															 			"vec3 rgbM  = rgbaM.xyz;",
														
 
															-			"float opacity  = rgbaM.w;",
														
 
															-
														
 
															 			"vec3 luma = vec3( 0.299, 0.587, 0.114 );",
														
 
															 			"float lumaNW = dot( rgbNW, luma );",
														
@@ -71,25 +69,20 @@ THREE.FXAAShader = {
 
															 			"dir = min( vec2( FXAA_SPAN_MAX,  FXAA_SPAN_MAX),",
														
 
															 				  "max( vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX),",
														
 
															 						"dir * rcpDirMin)) * resolution;",
														
 
															-
														
 
															-			"vec3 rgbA = texture2D( tDiffuse, gl_FragCoord.xy  * resolution + dir * ( 1.0 / 3.0 - 0.5 ) ).xyz;",
														
 
															-			"rgbA += texture2D( tDiffuse, gl_FragCoord.xy  * resolution + dir * ( 2.0 / 3.0 - 0.5 ) ).xyz;",
														
 
															-			"rgbA *= 0.5;",
														
 
															-
														
 
															-			"vec3 rgbB = texture2D( tDiffuse, gl_FragCoord.xy  * resolution + dir * -0.5 ).xyz;",
														
 
															-			"rgbB += texture2D( tDiffuse, gl_FragCoord.xy  * resolution + dir * 0.5 ).xyz;",
														
 
															-			"rgbB *= 0.25;",
														
 
															-			"rgbB += rgbA * 0.5;",
														
 
															-
														
 
															-			"float lumaB = dot( rgbB, luma );",
														
 
															+			"vec4 rgbA = (1.0/2.0) * (",
														
 
															+        	"texture2D(tDiffuse,  gl_FragCoord.xy  * resolution + dir * (1.0/3.0 - 0.5)) +",
														
 
															+			"texture2D(tDiffuse,  gl_FragCoord.xy  * resolution + dir * (2.0/3.0 - 0.5)));",
														
 
															+    		"vec4 rgbB = rgbA * (1.0/2.0) + (1.0/4.0) * (",
														
 
															+			"texture2D(tDiffuse,  gl_FragCoord.xy  * resolution + dir * (0.0/3.0 - 0.5)) +",
														
 
															+      		"texture2D(tDiffuse,  gl_FragCoord.xy  * resolution + dir * (3.0/3.0 - 0.5)));",
														
 
															+    		"float lumaB = dot(rgbB, vec4(luma, 0.0));",
														
 
															 			"if ( ( lumaB < lumaMin ) || ( lumaB > lumaMax ) ) {",
														
 
															-				"gl_FragColor = vec4( rgbA, opacity );",
														
 
															+				"gl_FragColor = rgbA;",
														
 
															 			"} else {",
														
 
															-
														
 
															-				"gl_FragColor = vec4( rgbB, opacity );",
														
 
															+				"gl_FragColor = rgbB;",
														
 
															 			"}",
														
--- a/examples/js/utils/GeometryUtils.js
+++ b/examples/js/utils/GeometryUtils.js
@@ -0,0 +1,300 @@
 
															+/**
														
 
															+ * @author mrdoob / http://mrdoob.com/
														
 
															+ * @author alteredq / http://alteredqualia.com/
														
 
															+ */
														
 
															+
														
 
															+THREE.GeometryUtils = {
														
 
															+
														
 
															+	// Merge two geometries or geometry and geometry from object (using object's transform)
														
 
															+
														
 
															+	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 );
														
 
															+
														
 
															+	},
														
 
															+
														
 
															+	// Get random point in triangle (via barycentric coordinates)
														
 
															+	// 	(uniform distribution)
														
 
															+	// 	http://www.cgafaq.info/wiki/Random_Point_In_Triangle
														
 
															+
														
 
															+	randomPointInTriangle: function () {
														
 
															+
														
 
															+		var vector = new THREE.Vector3();
														
 
															+
														
 
															+		return function ( vectorA, vectorB, vectorC ) {
														
 
															+
														
 
															+			var point = new THREE.Vector3();
														
 
															+
														
 
															+			var a = THREE.Math.random16();
														
 
															+			var b = THREE.Math.random16();
														
 
															+
														
 
															+			if ( ( a + b ) > 1 ) {
														
 
															+
														
 
															+				a = 1 - a;
														
 
															+				b = 1 - b;
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			var c = 1 - a - b;
														
 
															+
														
 
															+			point.copy( vectorA );
														
 
															+			point.multiplyScalar( a );
														
 
															+
														
 
															+			vector.copy( vectorB );
														
 
															+			vector.multiplyScalar( b );
														
 
															+
														
 
															+			point.add( vector );
														
 
															+
														
 
															+			vector.copy( vectorC );
														
 
															+			vector.multiplyScalar( c );
														
 
															+
														
 
															+			point.add( vector );
														
 
															+
														
 
															+			return point;
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+	}(),
														
 
															+
														
 
															+	// Get random point in face (triangle)
														
 
															+	// (uniform distribution)
														
 
															+
														
 
															+	randomPointInFace: function ( face, geometry, useCachedAreas ) {
														
 
															+
														
 
															+		var vA, vB, vC;
														
 
															+
														
 
															+		vA = geometry.vertices[ face.a ];
														
 
															+		vB = geometry.vertices[ face.b ];
														
 
															+		vC = geometry.vertices[ face.c ];
														
 
															+
														
 
															+		return THREE.GeometryUtils.randomPointInTriangle( vA, vB, vC );
														
 
															+
														
 
															+	},
														
 
															+
														
 
															+	// Get uniformly distributed random points in mesh
														
 
															+	// 	- create array with cumulative sums of face areas
														
 
															+	//  - pick random number from 0 to total area
														
 
															+	//  - find corresponding place in area array by binary search
														
 
															+	//	- get random point in face
														
 
															+
														
 
															+	randomPointsInGeometry: function ( geometry, n ) {
														
 
															+
														
 
															+		var face, i,
														
 
															+			faces = geometry.faces,
														
 
															+			vertices = geometry.vertices,
														
 
															+			il = faces.length,
														
 
															+			totalArea = 0,
														
 
															+			cumulativeAreas = [],
														
 
															+			vA, vB, vC, vD;
														
 
															+
														
 
															+		// precompute face areas
														
 
															+
														
 
															+		for ( i = 0; i < il; i ++ ) {
														
 
															+
														
 
															+			face = faces[ i ];
														
 
															+
														
 
															+			vA = vertices[ face.a ];
														
 
															+			vB = vertices[ face.b ];
														
 
															+			vC = vertices[ face.c ];
														
 
															+
														
 
															+			face._area = THREE.GeometryUtils.triangleArea( vA, vB, vC );
														
 
															+
														
 
															+			totalArea += face._area;
														
 
															+
														
 
															+			cumulativeAreas[ i ] = totalArea;
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		// binary search cumulative areas array
														
 
															+
														
 
															+		function binarySearchIndices( value ) {
														
 
															+
														
 
															+			function binarySearch( start, end ) {
														
 
															+
														
 
															+				// return closest larger index
														
 
															+				// if exact number is not found
														
 
															+
														
 
															+				if ( end < start )
														
 
															+					return start;
														
 
															+
														
 
															+				var mid = start + Math.floor( ( end - start ) / 2 );
														
 
															+
														
 
															+				if ( cumulativeAreas[ mid ] > value ) {
														
 
															+
														
 
															+					return binarySearch( start, mid - 1 );
														
 
															+
														
 
															+				} else if ( cumulativeAreas[ mid ] < value ) {
														
 
															+
														
 
															+					return binarySearch( mid + 1, end );
														
 
															+
														
 
															+				} else {
														
 
															+
														
 
															+					return mid;
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			var result = binarySearch( 0, cumulativeAreas.length - 1 )
														
 
															+			return result;
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		// pick random face weighted by face area
														
 
															+
														
 
															+		var r, index,
														
 
															+			result = [];
														
 
															+
														
 
															+		var stats = {};
														
 
															+
														
 
															+		for ( i = 0; i < n; i ++ ) {
														
 
															+
														
 
															+			r = THREE.Math.random16() * totalArea;
														
 
															+
														
 
															+			index = binarySearchIndices( r );
														
 
															+
														
 
															+			result[ i ] = THREE.GeometryUtils.randomPointInFace( faces[ index ], geometry, true );
														
 
															+
														
 
															+			if ( ! stats[ index ] ) {
														
 
															+
														
 
															+				stats[ index ] = 1;
														
 
															+
														
 
															+			} else {
														
 
															+
														
 
															+				stats[ index ] += 1;
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		return result;
														
 
															+
														
 
															+	},
														
 
															+
														
 
															+	randomPointsInBufferGeometry: function ( geometry, n ) {
														
 
															+
														
 
															+		var i,
														
 
															+			vertices = geometry.attributes.position.array,
														
 
															+			totalArea = 0,
														
 
															+			cumulativeAreas = [],
														
 
															+			vA, vB, vC;
														
 
															+
														
 
															+		// precompute face areas
														
 
															+		vA = new THREE.Vector3();
														
 
															+		vB = new THREE.Vector3();
														
 
															+		vC = new THREE.Vector3();
														
 
															+
														
 
															+		// geometry._areas = [];
														
 
															+		var il = vertices.length / 9;
														
 
															+
														
 
															+		for ( i = 0; i < il; i ++ ) {
														
 
															+
														
 
															+			vA.set( vertices[i * 9 + 0], vertices[i * 9 + 1], vertices[i * 9 + 2] );
														
 
															+			vB.set( vertices[i * 9 + 3], vertices[i * 9 + 4], vertices[i * 9 + 5] );
														
 
															+			vC.set( vertices[i * 9 + 6], vertices[i * 9 + 7], vertices[i * 9 + 8] );
														
 
															+
														
 
															+			area = THREE.GeometryUtils.triangleArea( vA, vB, vC );
														
 
															+			totalArea += area;
														
 
															+
														
 
															+			cumulativeAreas.push(totalArea);
														
 
															+		}
														
 
															+
														
 
															+		// binary search cumulative areas array
														
 
															+
														
 
															+		function binarySearchIndices( value ) {
														
 
															+
														
 
															+			function binarySearch( start, end ) {
														
 
															+
														
 
															+				// return closest larger index
														
 
															+				// if exact number is not found
														
 
															+
														
 
															+				if ( end < start )
														
 
															+					return start;
														
 
															+
														
 
															+				var mid = start + Math.floor( ( end - start ) / 2 );
														
 
															+
														
 
															+				if ( cumulativeAreas[ mid ] > value ) {
														
 
															+
														
 
															+					return binarySearch( start, mid - 1 );
														
 
															+
														
 
															+				} else if ( cumulativeAreas[ mid ] < value ) {
														
 
															+
														
 
															+					return binarySearch( mid + 1, end );
														
 
															+
														
 
															+				} else {
														
 
															+
														
 
															+					return mid;
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			var result = binarySearch( 0, cumulativeAreas.length - 1 )
														
 
															+			return result;
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		// pick random face weighted by face area
														
 
															+
														
 
															+		var r, index,
														
 
															+			result = [];
														
 
															+
														
 
															+		for ( i = 0; i < n; i ++ ) {
														
 
															+
														
 
															+			r = THREE.Math.random16() * totalArea;
														
 
															+
														
 
															+			index = binarySearchIndices( r );
														
 
															+
														
 
															+			// result[ i ] = THREE.GeometryUtils.randomPointInFace( faces[ index ], geometry, true );
														
 
															+			vA.set( vertices[index * 9 + 0], vertices[index * 9 + 1], vertices[index * 9 + 2] );
														
 
															+			vB.set( vertices[index * 9 + 3], vertices[index * 9 + 4], vertices[index * 9 + 5] );
														
 
															+			vC.set( vertices[index * 9 + 6], vertices[index * 9 + 7], vertices[index * 9 + 8] );
														
 
															+			result[ i ] = THREE.GeometryUtils.randomPointInTriangle( vA, vB, vC );
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		return result;
														
 
															+
														
 
															+	},
														
 
															+
														
 
															+	// Get triangle area (half of parallelogram)
														
 
															+	// http://mathworld.wolfram.com/TriangleArea.html
														
 
															+
														
 
															+	triangleArea: function () {
														
 
															+
														
 
															+		var vector1 = new THREE.Vector3();
														
 
															+		var vector2 = new THREE.Vector3();
														
 
															+
														
 
															+		return function ( vectorA, vectorB, vectorC ) {
														
 
															+
														
 
															+			vector1.subVectors( vectorB, vectorA );
														
 
															+			vector2.subVectors( vectorC, vectorA );
														
 
															+			vector1.cross( vector2 );
														
 
															+
														
 
															+			return 0.5 * vector1.length();
														
 
															+
														
 
															+		};
														
 
															+
														
 
															+	}(),
														
 
															+
														
 
															+	center: function ( geometry ) {
														
 
															+
														
 
															+		console.warn( 'THREE.GeometryUtils: .center() has been moved to Geometry. Use geometry.center() instead.' );
														
 
															+		return geometry.center();
														
 
															+
														
 
															+	}
														
 
															+
														
 
															+};
														
--- a/examples/js/utils/UVsUtils.js
+++ b/examples/js/utils/UVsUtils.js
@@ -1,8 +1,6 @@
 
															 /*
														
 
															  * @author gyuque / http://github.com/gyuque
														
 
															- *
														
 
															  * Cylinder Mapping for ExtrudeGeometry
														
 
															- *
														
 
															  */
														
 
															 THREE.UVsUtils = {
														
--- a/examples/js/wip/IndexedTypedGeometry.js
+++ b/examples/js/wip/IndexedTypedGeometry.js
@@ -20,8 +20,8 @@ THREE.IndexedTypedGeometry.prototype.setArrays = function ( indices, vertices, n
 
															 	this.attributes[ 'index' ] = { array: indices, itemSize: 1 };
														
 
															 	this.attributes[ 'position' ] = { array: vertices, itemSize: 3 };
														
 
															 	this.attributes[ 'normal' ] = { array: normals, itemSize: 3 };
														
 
															-	this.attributes[ 'uv' ] = { array: uvs, itemSize: 2 };	
														
 
															+	this.attributes[ 'uv' ] = { array: uvs, itemSize: 2 };
														
 
															 	return this;
														
 
															-};
														
 
															+};
														
--- a/examples/js/wip/PlaneTypedGeometry.js
+++ b/examples/js/wip/PlaneTypedGeometry.js
@@ -56,7 +56,7 @@ THREE.PlaneTypedGeometry = function ( width, height, widthSegments, heightSegmen
 
															 	offset = 0;
														
 
															-	var indices = new ( vertices.length > 65535 ? Uint32Array : Uint16Array )( gridX * gridY * 6 );
														
 
															+	var indices = new ( ( vertices.length / 3 ) > 65535 ? Uint32Array : Uint16Array )( gridX * gridY * 6 );
														
 
															 	for ( var iy = 0; iy < gridY; iy ++ ) {
														
--- a/examples/misc_animation_keys.html
+++ b/examples/misc_animation_keys.html
@@ -38,8 +38,8 @@
 
															 		<script src="../build/three.min.js"></script>
														
 
															 		<script src="js/Detector.js"></script>
														
 
															-    <script src="js/libs/stats.min.js"></script>
														
 
															-        
														
 
															+		<script src="js/libs/stats.min.js"></script>
														
 
															+
														
 
															 		<script>
														
 
															 			if ( ! Detector.webgl ) Detector.addGetWebGLMessage();
														
@@ -60,8 +60,8 @@
 
															 				renderer = new THREE.CanvasRenderer( { antialias: false } );
														
 
															 				renderer.setSize( window.innerWidth, window.innerHeight );
														
 
															-				renderer.setClearColor( 0x555555, 1);				
														
 
															-				container.appendChild( renderer.domElement );	
														
 
															+				renderer.setClearColor( 0x555555, 1 );
														
 
															+				container.appendChild( renderer.domElement );
														
 
															 				stats = new Stats();
														
 
															 				stats.domElement.style.position = 'absolute';
														
@@ -84,19 +84,19 @@
 
															 			}
														
 
															 			var createScene = function(){
														
 
															-								
														
 
															+				
														
 
															 				scene = new THREE.Scene();
														
 
															 				var axisHelper = new THREE.AxisHelper( 1 );
														
 
															-				scene.add( axisHelper );				
														
 
															+				scene.add( axisHelper );
														
 
															-				//SphereGeometry
														
 
															+				// SphereGeometry
														
 
															 				var sphereGeometry = new THREE.SphereGeometry( 5, 32, 32 );
														
 
															 				var material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
														
 
															 				var sphereMesh = new THREE.Mesh( sphereGeometry, material );
														
 
															-				//Setup animation
														
 
															-				sphereMesh.animation = {
														
 
															+				// Setup animation
														
 
															+				var animationData = {
														
 
															 					"name"      : "Action",
														
 
															 					"fps"       : 25,
														
 
															 					"length"    : 2.0, 
														
@@ -123,10 +123,10 @@
 
															 						}
														
 
															 					]
														
 
															 				};
														
 
															-				ensureLoop( sphereMesh.animation );
														
 
															-				THREE.AnimationHandler.add( sphereMesh.animation );
														
 
															-												
														
 
															-				var sphereMeshAnimation = new THREE.Animation( sphereMesh, sphereMesh.animation.name )
														
 
															+
														
 
															+				ensureLoop( animationData );
														
 
															+				
														
 
															+				var sphereMeshAnimation = new THREE.Animation( sphereMesh, animationData );
														
 
															 				sphereMeshAnimation.play();
														
 
															 				scene.add( sphereMesh );
														
@@ -136,7 +136,7 @@
 
															 			var ensureLoop = function( animation ) {
														
 
															 				for ( var i = 0; i < animation.hierarchy.length; i ++ ) {
														
 
															-          
														
 
															+
														
 
															 					var obj = animation.hierarchy[ i ];
														
 
															 					var first = obj.keys[ 0 ];
														
@@ -151,10 +151,11 @@
 
															 			};
														
 
															 			var animate = function () {
														
 
															-				requestAnimationFrame( animate );	
														
 
															+				requestAnimationFrame( animate );
														
 
															-				var delta = clock.getDelta();				
														
 
															-				THREE.AnimationHandler.update( delta );				
														
 
															+				var delta = clock.getDelta();
														
 
															+
														
 
															+				THREE.AnimationHandler.update( delta );
														
 
															 				render();
														
 
															 			};
														
@@ -164,14 +165,9 @@
 
															 				stats.update();
														
 
															 			};
														
 
															-			try {
														
 
															-				init();
														
 
															-				createScene();
														
 
															-				animate();
														
 
															-			} catch( e ) {
														
 
															-				var errorReport = "Your program encountered an unrecoverable error. Error was:<br/><br/>";
														
 
															-				alert( errorReport + e );
														
 
															-			}
														
 
															+			init();
														
 
															+			createScene();
														
 
															+			animate();
														
 
															 		</script>
														
--- a/examples/misc_controls_pointerlock.html
+++ b/examples/misc_controls_pointerlock.html
@@ -79,7 +79,7 @@
 
															 			var objects = [];
														
 
															-			var ray;
														
 
															+			var raycaster;
														
 
															 			var blocker = document.getElementById( 'blocker' );
														
 
															 			var instructions = document.getElementById( 'instructions' );
														
@@ -192,8 +192,7 @@
 
															 				controls = new THREE.PointerLockControls( camera );
														
 
															 				scene.add( controls.getObject() );
														
 
															-				ray = new THREE.Raycaster();
														
 
															-				ray.ray.direction.set( 0, -1, 0 );
														
 
															+				raycaster = new THREE.Raycaster( new THREE.Vector3(), new THREE.Vector3( 0, - 1, 0 ), 0, 10 );
														
 
															 				// floor
														
@@ -281,20 +280,14 @@
 
															 				controls.isOnObject( false );
														
 
															-				ray.ray.origin.copy( controls.getObject().position );
														
 
															-				ray.ray.origin.y -= 10;
														
 
															+				raycaster.ray.origin.copy( controls.getObject().position );
														
 
															+				raycaster.ray.origin.y -= 10;
														
 
															-				var intersections = ray.intersectObjects( objects );
														
 
															+				var intersections = raycaster.intersectObjects( objects );
														
 
															 				if ( intersections.length > 0 ) {
														
 
															-					var distance = intersections[ 0 ].distance;
														
 
															-
														
 
															-					if ( distance > 0 && distance < 10 ) {
														
 
															-
														
 
															-						controls.isOnObject( true );
														
 
															-
														
 
															-					}
														
 
															+					controls.isOnObject( true );
														
 
															 				}
														
--- a/examples/misc_ubiquity_test2.html
+++ b/examples/misc_ubiquity_test2.html
@@ -76,9 +76,9 @@
 
															 						tex.repeat.y = 0.1 * THREE.Math.randInt( 1, 3 );
														
 
															 						var material = new THREE.SpriteMaterial( { map: tex } );
														
 
															-						var sprite = new THREE.Sprite( material );
														
 
															+						material.rotation = 0.5 * Math.PI * ( Math.random() - 0.5 );
														
 
															-						sprite.material.rotation = 0.5 * Math.PI * ( Math.random() - 0.5 );
														
 
															+						var sprite = new THREE.Sprite( material );
														
 
															 						sprite.position.x = Math.random() * 1000 - 500;
														
 
															 						sprite.position.y = Math.random() * 1000 - 500;
														
@@ -119,17 +119,17 @@
 
															 				// SPRITES - PNG
														
 
															-				for ( var i = 0; i < 20; i ++ ) {
														
 
															+				texture3 = THREE.ImageUtils.loadTexture( 'textures/sprite1.png' );
														
 
															+				texture3.wrapS = THREE.ClampToEdgeWrapping;
														
 
															+				texture3.wrapT = THREE.ClampToEdgeWrapping;
														
 
															-					texture3 = THREE.ImageUtils.loadTexture( 'textures/sprite1.png' );
														
 
															-					texture3.wrapS = THREE.ClampToEdgeWrapping;
														
 
															-					texture3.wrapT = THREE.ClampToEdgeWrapping;
														
 
															+				for ( var i = 0; i < 20; i ++ ) {
														
 
															 					var material = new THREE.SpriteMaterial( { map: texture3 } );
														
 
															+					material.rotation = 2 * Math.PI * ( Math.random() - 0.5 );
														
 
															+					
														
 
															 					var sprite = new THREE.Sprite( material );
														
 
															-					sprite.material.rotation = 2 * Math.PI * ( Math.random() - 0.5 );
														
 
															-
														
 
															 					sprite.position.x = Math.random() * 1000 - 500;
														
 
															 					sprite.position.y = Math.random() * 1000 - 500;
														
 
															 					sprite.position.z = Math.random() * 1000 - 500;
														
--- a/examples/misc_uv_tests.html
+++ b/examples/misc_uv_tests.html
@@ -6,7 +6,7 @@
 
															 	</head>
														
 
															 	<body>
														
 
															 		<script src="../build/three.min.js"></script>
														
 
															-		<script src="js/UVsUtils.js"></script>
														
 
															+		<script src="js/utils/UVsUtils.js"></script>
														
 
															 		<script>
														
 
															 			/* 
														
 
															 			 * This is to help debug UVs problems in geometry, 
														
--- a/examples/webgl_custom_attributes_lines.html
+++ b/examples/webgl_custom_attributes_lines.html
@@ -163,7 +163,7 @@
 
															 			geometry.dynamic = true;
														
 
															-			THREE.GeometryUtils.center( geometry );
														
 
															+			geometry.center();
														
 
															 			object = new THREE.Line( geometry, shaderMaterial, THREE.LineStrip );
														
--- a/examples/webgl_geometries2.html
+++ b/examples/webgl_geometries2.html
@@ -20,19 +20,14 @@
 
															 		<script src="js/Detector.js"></script>
														
 
															 		<script src="js/libs/stats.min.js"></script>
														
 
															-		<!--
														
 
															-		<script src="../src/core/Geometry.js"></script>
														
 
															-		<script src="../src/extras/geometries/ParametricGeometry.js"></script>
														
 
															-		-->
														
 
															-
														
 
															 		<script src="js/CurveExtras.js"></script>
														
 
															-		<script src="js/UVsUtils.js"></script>
														
 
															 		<script src="js/ParametricGeometries.js"></script>
														
 
															+		<script src="js/utils/UVsUtils.js"></script>
														
 
															+
														
 
															 		<script>
														
 
															 			/* Testing the new Parametric Surfaces Geometries*/
														
 
															-
														
 
															 			if ( ! Detector.webgl ) Detector.addGetWebGLMessage();
														
 
															 			var container, stats;
														
--- a/examples/webgl_geometry_extrude_uvs2.html
+++ b/examples/webgl_geometry_extrude_uvs2.html
--- a/examples/webgl_geometry_tessellation.html
+++ b/examples/webgl_geometry_tessellation.html
@@ -161,7 +161,7 @@
 
															 			geometry.dynamic = true;

														
 
															-			THREE.GeometryUtils.center( geometry );

														
 
															+			geometry.center();

														
 
															 			var tessellateModifier = new THREE.TessellateModifier( 4 );

														
--- a/examples/webgl_geometry_text.html
+++ b/examples/webgl_geometry_text.html
@@ -39,6 +39,7 @@
 
															 		<script src="../build/three.min.js"></script>
														
 
															+		<script src="js/utils/GeometryUtils.js"></script>
														
 
															 		<script src="js/shaders/ConvolutionShader.js"></script>
														
 
															 		<script src="js/shaders/CopyShader.js"></script>
														
--- a/examples/webgl_lights_hemisphere.html
+++ b/examples/webgl_lights_hemisphere.html
@@ -84,7 +84,7 @@
 
															 			void main() {
														
 
															 				float h = normalize( vWorldPosition + offset ).y;
														
 
															-				gl_FragColor = vec4( mix( bottomColor, topColor, max( pow( h, exponent ), 0.0 ) ), 1.0 );
														
 
															+				gl_FragColor = vec4( mix( bottomColor, topColor, max( pow( max( h , 0.0), exponent ), 0.0 ) ), 1.0 );
														
 
															 			}
														
--- a/examples/webgl_loader_ctm_materials.html
+++ b/examples/webgl_loader_ctm_materials.html
@@ -270,7 +270,8 @@
 
															 				loader.statusDomElement.style.display = "none";
														
 
															-				THREE.GeometryUtils.center( geometry );
														
 
															+				geometry.center();
														
 
															+				
														
 
															 				hackMaterials( materials );
														
 
															 				var material = new THREE.MeshFaceMaterial( materials );
														
--- a/examples/webgl_loader_pdb.html
+++ b/examples/webgl_loader_pdb.html
@@ -53,26 +53,29 @@
 
															 				background-color: rgba(0,255,255,1);
														
 
															 			}
														
 
															-			.bond {
														
 
															-				width: 5px;
														
 
															-				height: 10px;
														
 
															-				background: #eee;
														
 
															-				display: block;
														
 
															+			.label {
														
 
															+				text-shadow: -1px 1px 1px rgb(0,0,0);
														
 
															+				margin-left: 25px;
														
 
															 			}
														
 
															+
														
 
															+
														
 
															 		</style>
														
 
															 	</head>
														
 
															 	<body>
														
 
															 		<script src="../build/three.min.js"></script>
														
 
															+
														
 
															 		<script src="js/controls/TrackballControls.js"></script>
														
 
															 		<script src="js/loaders/PDBLoader.js"></script>
														
 
															+		<script src="js/renderers/CSS2DRenderer.js"></script>
														
 
															 		<div id="container"></div>
														
 
															 		<div id="info"><a href="http://threejs.org" target="_blank">three.js webgl</a> - molecules</div>
														
 
															 		<div id="menu"></div>
														
 
															 		<script>
														
 
															-			var camera, scene, renderer;
														
 
															+			var camera, scene, renderer, labelsRenderer;
														
 
															 			var controls;
														
 
															+
														
 
															 			var root;
														
 
															 			var MOLECULES = {
														
@@ -97,8 +100,6 @@
 
															 			};
														
 
															 			var loader = new THREE.PDBLoader();
														
 
															-			var colorSpriteMap = {};
														
 
															-			var baseSprite = document.createElement( 'img' );
														
 
															 			var menu = document.getElementById( "menu" );
														
@@ -126,6 +127,13 @@
 
															 				renderer.setSize( window.innerWidth, window.innerHeight );
														
 
															 				document.getElementById( 'container' ).appendChild( renderer.domElement );
														
 
															+				labelRenderer = new THREE.CSS2DRenderer();
														
 
															+				labelRenderer.setSize( window.innerWidth, window.innerHeight );
														
 
															+				labelRenderer.domElement.style.position = 'absolute';
														
 
															+				labelRenderer.domElement.style.top = '0';
														
 
															+				labelRenderer.domElement.style.pointerEvents = 'none';
														
 
															+				document.getElementById( 'container' ).appendChild( labelRenderer.domElement );
														
 
															+
														
 
															 				//
														
 
															 				controls = new THREE.TrackballControls( camera, renderer.domElement );
														
@@ -134,14 +142,8 @@
 
															 				//
														
 
															-				baseSprite.onload = function () {
														
 
															-
														
 
															-					loadMolecule( "models/molecules/caffeine.pdb" );
														
 
															-					createMenu();
														
 
															-
														
 
															-				};
														
 
															-
														
 
															-				baseSprite.src = 'textures/sprites/ball.png';
														
 
															+				loadMolecule( "models/molecules/caffeine.pdb" );
														
 
															+				createMenu();
														
 
															 				//
														
@@ -188,12 +190,12 @@
 
															 				}
														
 
															-				loader.load( url, function ( geometry, geometryBonds ) {
														
 
															+				loader.load( url, function ( geometry, geometryBonds, json ) {
														
 
															 					var boxGeometry = new THREE.BoxGeometry( 1, 1, 1 );
														
 
															 					var sphereGeometry = new THREE.IcosahedronGeometry( 1, 2 );
														
 
															-					var offset = THREE.GeometryUtils.center( geometry );
														
 
															+					var offset = geometry.center();
														
 
															 					geometryBonds.applyMatrix( new THREE.Matrix4().makeTranslation( offset.x, offset.y, offset.z ) );
														
 
															 					for ( var i = 0; i < geometry.vertices.length; i ++ ) {
														
@@ -210,6 +212,17 @@
 
															 						object.scale.multiplyScalar( 25 );
														
 
															 						root.add( object );
														
 
															+						var atom = json.atoms[ i ];
														
 
															+
														
 
															+						var text = document.createElement( 'div' );
														
 
															+						text.className = 'label';
														
 
															+						text.style.color = 'rgb(' + atom[ 3 ][ 0 ] + ',' + atom[ 3 ][ 1 ] + ',' + atom[ 3 ][ 2 ] + ')';
														
 
															+						text.textContent = atom[ 4 ];
														
 
															+
														
 
															+						var label = new THREE.CSS2DObject( text );
														
 
															+						label.position.copy( object.position );
														
 
															+						root.add( label );
														
 
															+
														
 
															 					}
														
 
															 					for ( var i = 0; i < geometryBonds.vertices.length; i += 2 ) {
														
@@ -244,6 +257,7 @@
 
															 				camera.updateProjectionMatrix();
														
 
															 				renderer.setSize( window.innerWidth, window.innerHeight );
														
 
															+				labelRenderer.setSize( window.innerWidth, window.innerHeight );
														
 
															 				render();
														
@@ -266,6 +280,7 @@
 
															 			function render() {
														
 
															 				renderer.render( scene, camera );
														
 
															+				labelRenderer.render( scene, camera );
														
 
															 			}
														
--- a/examples/webgl_loader_scene.html
+++ b/examples/webgl_loader_scene.html
@@ -0,0 +1,458 @@
 
															+<!DOCTYPE html>
														
 
															+<html lang="en">
														
 
															+	<head>
														
 
															+		<title>three.js webgl - io - scene loader</title>
														
 
															+		<meta charset="utf-8">
														
 
															+		<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
														
 
															+		<style>
														
 
															+			body {
														
 
															+				background:#000;
														
 
															+				color:#fff;
														
 
															+				padding:0;
														
 
															+				margin:0;
														
 
															+				overflow:hidden;
														
 
															+				font-family:georgia;
														
 
															+				text-align:center;
														
 
															+			}
														
 
															+
														
 
															+			#info {
														
 
															+				position: absolute;
														
 
															+				top: 0px; width: 100%;
														
 
															+				padding: 5px;
														
 
															+				font-family: Monospace;
														
 
															+				font-size: 13px;
														
 
															+				text-align: center;
														
 
															+				z-index:100;
														
 
															+			}
														
 
															+
														
 
															+			#progress {
														
 
															+				color:red;
														
 
															+				top:7em;
														
 
															+				width: 100%;
														
 
															+				font-size:3em;
														
 
															+				font-variant:small-caps;
														
 
															+				font-weight:bold;
														
 
															+				position:absolute;
														
 
															+				z-index:100;
														
 
															+				text-align: center;
														
 
															+				text-shadow: #000 0px 0px 10px;
														
 
															+				display:none;
														
 
															+			}
														
 
															+
														
 
															+			#start {
														
 
															+				color:#fff;
														
 
															+				text-shadow: #000 0px 0px 2px;
														
 
															+				padding:0.1em 0.3em;
														
 
															+				width:3em;
														
 
															+				text-align: center;
														
 
															+				display:none;
														
 
															+			}
														
 
															+
														
 
															+			.shadow {
														
 
															+				-moz-box-shadow: 0px 0px 5px #000;
														
 
															+				-webkit-box-shadow: 0px 0px 5px #000;
														
 
															+				box-shadow: 0px 0px 5px #000;
														
 
															+			}
														
 
															+
														
 
															+			#progressbar {
														
 
															+				text-align: center;
														
 
															+				background: white;
														
 
															+				width: 250px;
														
 
															+				height: 10px;
														
 
															+			}
														
 
															+
														
 
															+			#bar {
														
 
															+				background:#d00;
														
 
															+				width:50px;
														
 
															+				height:10px;
														
 
															+			}
														
 
															+
														
 
															+			.enabled {
														
 
															+				color: lime!important;
														
 
															+				cursor:pointer;
														
 
															+			}
														
 
															+
														
 
															+			.enabled:hover {
														
 
															+				text-shadow: #0f0 0px 0px 5px !important;
														
 
															+			}
														
 
															+
														
 
															+			.disabled {
														
 
															+				background:gray;
														
 
															+				cursor:default;
														
 
															+			}
														
 
															+
														
 
															+			a { color:red }
														
 
															+			canvas { pointer-events:none; z-index:10; }
														
 
															+
														
 
															+		</style>
														
 
															+	</head>
														
 
															+
														
 
															+	<body>
														
 
															+		<div id="info">
														
 
															+			<a href="http://threejs.org">three.js</a> - scene loader test
														
 
															+		</div>
														
 
															+
														
 
															+		<div id="progress">
														
 
															+			<span id="message">Loading ...</span>
														
 
															+
														
 
															+			<center>
														
 
															+				<div id="progressbar" class="shadow"><div id="bar" class="shadow"></div></div>
														
 
															+				<div id="start" class="disabled">Start</div>
														
 
															+			</center>
														
 
															+		</div>
														
 
															+
														
 
															+		<script src="../build/three.min.js"></script>
														
 
															+
														
 
															+		<script src="js/loaders/DDSLoader.js"></script>
														
 
															+
														
 
															+		<script src="js/loaders/ctm/lzma.js"></script>
														
 
															+		<script src="js/loaders/ctm/ctm.js"></script>
														
 
															+		<script src="js/loaders/ctm/CTMLoader.js"></script>
														
 
															+
														
 
															+		<script src="js/loaders/SceneLoader.js"></script>
														
 
															+		<script src="js/loaders/BinaryLoader.js"></script>
														
 
															+		<script src="js/loaders/OBJLoader.js"></script>
														
 
															+		<script src="js/loaders/VTKLoader.js"></script>
														
 
															+		<script src="js/loaders/STLLoader.js"></script>
														
 
															+		<script src="js/loaders/ColladaLoader.js"></script>
														
 
															+		<script src="js/loaders/UTF8Loader.js"></script>
														
 
															+		<script src="js/loaders/MTLLoader.js"></script>
														
 
															+
														
 
															+		<script src="js/Detector.js"></script>
														
 
															+		<script src="js/libs/stats.min.js"></script>
														
 
															+
														
 
															+		<script>
														
 
															+
														
 
															+			if ( ! Detector.webgl ) Detector.addGetWebGLMessage();
														
 
															+
														
 
															+			var SCREEN_WIDTH = window.innerWidth;
														
 
															+			var SCREEN_HEIGHT = window.innerHeight;
														
 
															+
														
 
															+			var container,stats;
														
 
															+
														
 
															+			var camera, scene, loaded;
														
 
															+			var renderer;
														
 
															+
														
 
															+			var mouseX = 0, mouseY = 0;
														
 
															+
														
 
															+			var windowHalfX = window.innerWidth / 2;
														
 
															+			var windowHalfY = window.innerHeight / 2;
														
 
															+
														
 
															+			var rotatingObjects = [];
														
 
															+			var morphAnimatedObjects = [];
														
 
															+
														
 
															+			var clock = new THREE.Clock();
														
 
															+
														
 
															+			document.addEventListener( 'mousemove', onDocumentMouseMove, false );
														
 
															+
														
 
															+			THREE.DefaultLoadingManager.onProgress = function ( item, loaded, total ) {
														
 
															+
														
 
															+				console.log( item, loaded, total );
														
 
															+
														
 
															+			};
														
 
															+
														
 
															+			init();
														
 
															+			animate();
														
 
															+
														
 
															+			function $( id ) {
														
 
															+
														
 
															+				return document.getElementById( id );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			function handle_update( result, pieces ) {
														
 
															+
														
 
															+				//renderer.initWebGLObjects( result.scene );
														
 
															+
														
 
															+				var m, material, count = 0;
														
 
															+
														
 
															+				for ( m in result.materials ) {
														
 
															+
														
 
															+					material = result.materials[ m ];
														
 
															+					if ( ! ( material instanceof THREE.MeshFaceMaterial || material instanceof THREE.ShaderMaterial || material.morphTargets ) ) {
														
 
															+
														
 
															+						if( !material.program ) {
														
 
															+
														
 
															+							renderer.initMaterial( material, result.scene.__lights, result.scene.fog );
														
 
															+
														
 
															+							count += 1;
														
 
															+
														
 
															+							if( count > pieces ) {
														
 
															+
														
 
															+								//console.log("xxxxxxxxx");
														
 
															+								break;
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+						}
														
 
															+
														
 
															+					}
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			function init() {
														
 
															+
														
 
															+				container = document.createElement( 'div' );
														
 
															+				document.body.appendChild( container );
														
 
															+
														
 
															+				var loadScene = createLoadScene();
														
 
															+
														
 
															+				camera = loadScene.camera;
														
 
															+				scene = loadScene.scene;
														
 
															+
														
 
															+				renderer = new THREE.WebGLRenderer( { antialias: true } );
														
 
															+				renderer.setSize( SCREEN_WIDTH, SCREEN_HEIGHT );
														
 
															+				renderer.domElement.style.position = "relative";
														
 
															+				container.appendChild( renderer.domElement );
														
 
															+
														
 
															+				renderer.gammaInput = true;
														
 
															+				renderer.gammaOutput = true;
														
 
															+
														
 
															+				stats = new Stats();
														
 
															+				stats.domElement.style.position = 'absolute';
														
 
															+				stats.domElement.style.top = '0px';
														
 
															+				stats.domElement.style.right = '0px';
														
 
															+				stats.domElement.style.zIndex = 100;
														
 
															+				container.appendChild( stats.domElement );
														
 
															+
														
 
															+				$( "start" ).addEventListener( 'click', onStartClick, false );
														
 
															+
														
 
															+				var callbackProgress = function( progress, result ) {
														
 
															+
														
 
															+					var bar = 250,
														
 
															+						total = progress.totalModels + progress.totalTextures,
														
 
															+						loaded = progress.loadedModels + progress.loadedTextures;
														
 
															+
														
 
															+					if ( total )
														
 
															+						bar = Math.floor( bar * loaded / total );
														
 
															+
														
 
															+					$( "bar" ).style.width = bar + "px";
														
 
															+
														
 
															+					count = 0;
														
 
															+					for ( var m in result.materials ) count++;
														
 
															+
														
 
															+					handle_update( result, Math.floor( count/total ) );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				var callbackSync = function( result ) {
														
 
															+
														
 
															+					/*
														
 
															+
														
 
															+					// uncomment to see progressive scene loading
														
 
															+
														
 
															+					scene = result.scene;
														
 
															+					camera = result.currentCamera;
														
 
															+
														
 
															+					camera.aspect = window.innerWidth / window.innerHeight;
														
 
															+					camera.updateProjectionMatrix();
														
 
															+
														
 
															+					*/
														
 
															+
														
 
															+					//handle_update( result, 1 );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				var callbackFinished = function ( result ) {
														
 
															+
														
 
															+					loaded = result;
														
 
															+
														
 
															+					$( "message" ).style.display = "none";
														
 
															+					$( "progressbar" ).style.display = "none";
														
 
															+					$( "start" ).style.display = "block";
														
 
															+					$( "start" ).className = "enabled";
														
 
															+
														
 
															+					handle_update( result, 1 );
														
 
															+
														
 
															+					result.scene.traverse( function ( object ) {
														
 
															+
														
 
															+						if ( object.userData.rotating === true ) {
														
 
															+
														
 
															+							rotatingObjects.push( object );
														
 
															+
														
 
															+						}
														
 
															+
														
 
															+						if ( object instanceof THREE.MorphAnimMesh ) {
														
 
															+
														
 
															+							morphAnimatedObjects.push( object );
														
 
															+
														
 
															+						}
														
 
															+
														
 
															+						if ( object instanceof THREE.SkinnedMesh ) {
														
 
															+
														
 
															+							if ( object.geometry.animation ) {
														
 
															+
														
 
															+								var animation = new THREE.Animation( object, object.geometry.animation );
														
 
															+								animation.play();
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+						}
														
 
															+
														
 
															+					} );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				$( "progress" ).style.display = "block";
														
 
															+
														
 
															+				THREE.Loader.Handlers.add( /\.dds$/i, new THREE.DDSLoader() );
														
 
															+
														
 
															+				var loader = new THREE.SceneLoader();
														
 
															+
														
 
															+				loader.addGeometryHandler( "binary", THREE.BinaryLoader );
														
 
															+				loader.addGeometryHandler( "ctm", THREE.CTMLoader );
														
 
															+				loader.addGeometryHandler( "vtk", THREE.VTKLoader );
														
 
															+				loader.addGeometryHandler( "stl", THREE.STLLoader );
														
 
															+
														
 
															+				loader.addHierarchyHandler( "obj", THREE.OBJLoader );
														
 
															+				loader.addHierarchyHandler( "dae", THREE.ColladaLoader );
														
 
															+				loader.addHierarchyHandler( "utf8", THREE.UTF8Loader );
														
 
															+
														
 
															+				loader.callbackSync = callbackSync;
														
 
															+				loader.callbackProgress = callbackProgress;
														
 
															+
														
 
															+				loader.load( "scenes/test_scene.js", callbackFinished );
														
 
															+
														
 
															+				//
														
 
															+
														
 
															+				window.addEventListener( 'resize', onWindowResize, false );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			function onWindowResize() {
														
 
															+
														
 
															+				windowHalfX = window.innerWidth / 2;
														
 
															+				windowHalfY = window.innerHeight / 2;
														
 
															+
														
 
															+				camera.aspect = window.innerWidth / window.innerHeight;
														
 
															+				camera.updateProjectionMatrix();
														
 
															+
														
 
															+				renderer.setSize( window.innerWidth, window.innerHeight );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			function setButtonActive( id ) {
														
 
															+
														
 
															+				$( "start" ).style.backgroundColor = "green";
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			function onStartClick() {
														
 
															+
														
 
															+				$( "progress" ).style.display = "none";
														
 
															+
														
 
															+				camera = loaded.currentCamera;
														
 
															+				camera.aspect = window.innerWidth / window.innerHeight;
														
 
															+				camera.updateProjectionMatrix();
														
 
															+
														
 
															+				scene = loaded.scene;
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			function onDocumentMouseMove( event ) {
														
 
															+
														
 
															+				mouseX = ( event.clientX - windowHalfX );
														
 
															+				mouseY = ( event.clientY - windowHalfY );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			function createLoadScene() {
														
 
															+
														
 
															+				var result = {
														
 
															+
														
 
															+					scene:  new THREE.Scene(),
														
 
															+					camera: new THREE.PerspectiveCamera( 65, window.innerWidth / window.innerHeight, 1, 1000 )
														
 
															+
														
 
															+				};
														
 
															+
														
 
															+				result.camera.position.z = 100;
														
 
															+				result.scene.add( result.camera );
														
 
															+
														
 
															+				var object, geometry, material, light, count = 500, range = 200;
														
 
															+
														
 
															+				material = new THREE.MeshLambertMaterial( { color:0xffffff } );
														
 
															+				geometry = new THREE.BoxGeometry( 5, 5, 5 );
														
 
															+
														
 
															+				for( var i = 0; i < count; i++ ) {
														
 
															+
														
 
															+					object = new THREE.Mesh( geometry, material );
														
 
															+
														
 
															+					object.position.x = ( Math.random() - 0.5 ) * range;
														
 
															+					object.position.y = ( Math.random() - 0.5 ) * range;
														
 
															+					object.position.z = ( Math.random() - 0.5 ) * range;
														
 
															+
														
 
															+					object.rotation.x = Math.random() * 6;
														
 
															+					object.rotation.y = Math.random() * 6;
														
 
															+					object.rotation.z = Math.random() * 6;
														
 
															+
														
 
															+					object.matrixAutoUpdate = false;
														
 
															+					object.updateMatrix();
														
 
															+
														
 
															+					result.scene.add( object );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				result.scene.matrixAutoUpdate = false;
														
 
															+
														
 
															+				light = new THREE.PointLight( 0xffffff );
														
 
															+				result.scene.add( light );
														
 
															+
														
 
															+				light = new THREE.DirectionalLight( 0x111111 );
														
 
															+				light.position.x = 1;
														
 
															+				result.scene.add( light );
														
 
															+
														
 
															+				return result;
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			//
														
 
															+
														
 
															+			function animate() {
														
 
															+
														
 
															+				requestAnimationFrame( animate );
														
 
															+
														
 
															+				render();
														
 
															+				stats.update();
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			function render() {
														
 
															+
														
 
															+				var delta = clock.getDelta();
														
 
															+
														
 
															+				camera.position.x += ( mouseX - camera.position.x ) * .001;
														
 
															+				camera.position.y += ( - mouseY - camera.position.y ) * .001;
														
 
															+
														
 
															+				camera.lookAt( scene.position );
														
 
															+
														
 
															+				// update skinning
														
 
															+
														
 
															+				THREE.AnimationHandler.update( delta * 0.75 );
														
 
															+
														
 
															+				for ( var i = 0; i < rotatingObjects.length; i ++ ) {
														
 
															+
														
 
															+					var object = rotatingObjects[ i ];
														
 
															+
														
 
															+					if ( object.userData.rotateX ) object.rotation.x += 1 * delta;
														
 
															+					if ( object.userData.rotateY ) object.rotation.y += 0.5 * delta;
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				for ( var i = 0; i < morphAnimatedObjects.length; i ++ ) {
														
 
															+
														
 
															+					var object = morphAnimatedObjects[ i ];
														
 
															+
														
 
															+					object.updateAnimation( 1000 * delta );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				renderer.render( scene, camera );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		</script>
														
 
															+
														
 
															+	</body>
														
 
															+</html>
														
--- a/examples/webgl_materials_blending.html
+++ b/examples/webgl_materials_blending.html
@@ -21,7 +21,7 @@
 
															 			if ( ! Detector.webgl ) Detector.addGetWebGLMessage();
														
 
															 			var camera, scene, renderer;
														
 
															-			var mesh;
														
 
															+			var mesh, mapBg;
														
 
															 			init();
														
 
															 			animate();
														
@@ -53,7 +53,7 @@
 
															 				xc.fillStyle = "#777";
														
 
															 				xc.fillRect( 96, 96, 32, 32 );
														
 
															-				var mapBg = new THREE.Texture( x );
														
 
															+				mapBg = new THREE.Texture( x );
														
 
															 				mapBg.wrapS = mapBg.wrapT = THREE.RepeatWrapping;
														
 
															 				mapBg.repeat.set( 128, 64 );
														
 
															 				mapBg.needsUpdate = true;
														
@@ -167,6 +167,13 @@
 
															 			function animate() {
														
 
															 				requestAnimationFrame( animate );
														
 
															+				
														
 
															+				var time = Date.now() * 0.00025;
														
 
															+				var ox = ( time * -0.01 * mapBg.repeat.x ) % 1;
														
 
															+				var oy = ( time * -0.01 * mapBg.repeat.y ) % 1;
														
 
															+
														
 
															+				mapBg.offset.set( ox, oy );
														
 
															+
														
 
															 				renderer.render( scene, camera );
														
 
															 			}
														
--- a/examples/webgl_materials_blending_custom.html
+++ b/examples/webgl_materials_blending_custom.html
@@ -436,7 +436,6 @@
 
															 				var time = Date.now() * 0.00025;
														
 
															 				var ox = ( time * -0.01 * materialBg.map.repeat.x ) % 1;
														
 
															 				var oy = ( time * -0.01 * materialBg.map.repeat.y ) % 1;
														
 
															-				//var oy = Math.sin( 0.75 * time ) * 0.01 * materialBg.map.repeat.y;
														
 
															 				materialBg.map.offset.set( ox, oy );
														
--- a/examples/webgl_materials_lightmap.html
+++ b/examples/webgl_materials_lightmap.html
@@ -58,7 +58,7 @@
 
															 			void main() {
														
 
															 				float h = normalize( vWorldPosition + offset ).y;
														
 
															-				gl_FragColor = vec4( mix( bottomColor, topColor, max( pow( h, exponent ), 0.0 ) ), 1.0 );
														
 
															+				gl_FragColor = vec4( mix( bottomColor, topColor, max( pow( max( h, 0.0 ), exponent ), 0.0 ) ), 1.0 );
														
 
															 			}
														
--- a/src/cameras/Camera.js
+++ b/src/cameras/Camera.js
@@ -31,7 +31,7 @@ THREE.Camera.prototype.lookAt = function () {
 
															 }();
														
 
															-THREE.Camera.prototype.clone = function (camera) {
														
 
															+THREE.Camera.prototype.clone = function ( camera ) {
														
 
															 	if ( camera === undefined ) camera = new THREE.Camera();
														
--- a/src/cameras/CubeCamera.js
+++ b/src/cameras/CubeCamera.js
@@ -12,13 +12,13 @@ THREE.CubeCamera = function ( near, far, cubeResolution ) {
 
															 	var fov = 90, aspect = 1;
														
 
															 	var cameraPX = new THREE.PerspectiveCamera( fov, aspect, near, far );
														
 
															-	cameraPX.up.set( 0, -1, 0 );
														
 
															+	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 ) );
														
 
															+	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 );
														
@@ -27,18 +27,18 @@ THREE.CubeCamera = function ( near, far, cubeResolution ) {
 
															 	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 ) );
														
 
															+	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.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 ) );
														
 
															+	cameraNZ.up.set( 0, - 1, 0 );
														
 
															+	cameraNZ.lookAt( new THREE.Vector3( 0, 0, - 1 ) );
														
 
															 	this.add( cameraNZ );
														
 
															 	this.renderTarget = new THREE.WebGLRenderTargetCube( cubeResolution, cubeResolution, { format: THREE.RGBFormat, magFilter: THREE.LinearFilter, minFilter: THREE.LinearFilter } );
														
--- a/src/cameras/OrthographicCamera.js
+++ b/src/cameras/OrthographicCamera.js
@@ -36,7 +36,7 @@ THREE.OrthographicCamera.prototype.clone = function () {
 
															 	camera.right = this.right;
														
 
															 	camera.top = this.top;
														
 
															 	camera.bottom = this.bottom;
														
 
															-	
														
 
															+
														
 
															 	camera.near = this.near;
														
 
															 	camera.far = this.far;
														
--- a/src/cameras/PerspectiveCamera.js
+++ b/src/cameras/PerspectiveCamera.js
@@ -92,7 +92,7 @@ THREE.PerspectiveCamera.prototype.updateProjectionMatrix = function () {
 
															 		var aspect = this.fullWidth / this.fullHeight;
														
 
															 		var top = Math.tan( THREE.Math.degToRad( this.fov * 0.5 ) ) * this.near;
														
 
															-		var bottom = -top;
														
 
															+		var bottom = - top;
														
 
															 		var left = aspect * bottom;
														
 
															 		var right = aspect * top;
														
 
															 		var width = Math.abs( right - left );
														
--- a/src/core/BufferGeometry.js
+++ b/src/core/BufferGeometry.js
@@ -80,6 +80,154 @@ THREE.BufferGeometry.prototype = {
 
															 	},
														
 
															+	fromGeometry: function ( geometry, settings ) {
														
 
															+
														
 
															+		settings = settings || { 'vertexColors': THREE.NoColors };
														
 
															+
														
 
															+		var vertices = geometry.vertices;
														
 
															+		var faces = geometry.faces;
														
 
															+		var faceVertexUvs = geometry.faceVertexUvs;
														
 
															+		var vertexColors = settings.vertexColors;
														
 
															+		var hasFaceVertexUv = faceVertexUvs[ 0 ].length > 0;
														
 
															+		var hasFaceVertexNormals = faces[ 0 ].vertexNormals.length == 3;
														
 
															+
														
 
															+		var positions = new Float32Array( faces.length * 3 * 3 );
														
 
															+		this.addAttribute( 'position', new THREE.BufferAttribute( positions, 3 ) );
														
 
															+
														
 
															+		var normals = new Float32Array( faces.length * 3 * 3 );
														
 
															+		this.addAttribute( 'normal', new THREE.BufferAttribute( normals, 3 ) );
														
 
															+
														
 
															+		if ( vertexColors !== THREE.NoColors ) {
														
 
															+
														
 
															+			var colors = new Float32Array( faces.length * 3 * 3 );
														
 
															+			this.addAttribute( 'color', new THREE.BufferAttribute( colors, 3 ) );
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		if ( hasFaceVertexUv === true ) {
														
 
															+
														
 
															+			var uvs = new Float32Array( faces.length * 3 * 2 );
														
 
															+			this.addAttribute( 'uvs', new THREE.BufferAttribute( uvs, 2 ) );
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		for ( var i = 0, i2 = 0, i3 = 0; i < faces.length; i ++, i2 += 6, i3 += 9 ) {
														
 
															+
														
 
															+			var face = faces[ i ];
														
 
															+
														
 
															+			var a = vertices[ face.a ];
														
 
															+			var b = vertices[ face.b ];
														
 
															+			var c = vertices[ face.c ];
														
 
															+
														
 
															+			positions[ i3     ] = a.x;
														
 
															+			positions[ i3 + 1 ] = a.y;
														
 
															+			positions[ i3 + 2 ] = a.z;
														
 
															+
														
 
															+			positions[ i3 + 3 ] = b.x;
														
 
															+			positions[ i3 + 4 ] = b.y;
														
 
															+			positions[ i3 + 5 ] = b.z;
														
 
															+
														
 
															+			positions[ i3 + 6 ] = c.x;
														
 
															+			positions[ i3 + 7 ] = c.y;
														
 
															+			positions[ i3 + 8 ] = c.z;
														
 
															+
														
 
															+			if ( hasFaceVertexNormals === true ) {
														
 
															+
														
 
															+				var na = face.vertexNormals[ 0 ];
														
 
															+				var nb = face.vertexNormals[ 1 ];
														
 
															+				var nc = face.vertexNormals[ 2 ];
														
 
															+
														
 
															+				normals[ i3     ] = na.x;
														
 
															+				normals[ i3 + 1 ] = na.y;
														
 
															+				normals[ i3 + 2 ] = na.z;
														
 
															+
														
 
															+				normals[ i3 + 3 ] = nb.x;
														
 
															+				normals[ i3 + 4 ] = nb.y;
														
 
															+				normals[ i3 + 5 ] = nb.z;
														
 
															+
														
 
															+				normals[ i3 + 6 ] = nc.x;
														
 
															+				normals[ i3 + 7 ] = nc.y;
														
 
															+				normals[ i3 + 8 ] = nc.z;
														
 
															+
														
 
															+			} else {
														
 
															+
														
 
															+				var n = face.normal;
														
 
															+
														
 
															+				normals[ i3     ] = n.x;
														
 
															+				normals[ i3 + 1 ] = n.y;
														
 
															+				normals[ i3 + 2 ] = n.z;
														
 
															+
														
 
															+				normals[ i3 + 3 ] = n.x;
														
 
															+				normals[ i3 + 4 ] = n.y;
														
 
															+				normals[ i3 + 5 ] = n.z;
														
 
															+
														
 
															+				normals[ i3 + 6 ] = n.x;
														
 
															+				normals[ i3 + 7 ] = n.y;
														
 
															+				normals[ i3 + 8 ] = n.z;
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			if ( vertexColors === THREE.FaceColors ) {
														
 
															+
														
 
															+				var fc = face.color;
														
 
															+
														
 
															+				colors[ i3     ] = fc.r;
														
 
															+				colors[ i3 + 1 ] = fc.g;
														
 
															+				colors[ i3 + 2 ] = fc.b;
														
 
															+
														
 
															+				colors[ i3 + 3 ] = fc.r;
														
 
															+				colors[ i3 + 4 ] = fc.g;
														
 
															+				colors[ i3 + 5 ] = fc.b;
														
 
															+
														
 
															+				colors[ i3 + 6 ] = fc.r;
														
 
															+				colors[ i3 + 7 ] = fc.g;
														
 
															+				colors[ i3 + 8 ] = fc.b;
														
 
															+
														
 
															+			} else if ( vertexColors === THREE.VertexColors ) {
														
 
															+
														
 
															+				var vca = face.vertexColors[ 0 ];
														
 
															+				var vcb = face.vertexColors[ 1 ];
														
 
															+				var vcc = face.vertexColors[ 2 ];
														
 
															+
														
 
															+				colors[ i3     ] = vca.r;
														
 
															+				colors[ i3 + 1 ] = vca.g;
														
 
															+				colors[ i3 + 2 ] = vca.b;
														
 
															+
														
 
															+				colors[ i3 + 3 ] = vcb.r;
														
 
															+				colors[ i3 + 4 ] = vcb.g;
														
 
															+				colors[ i3 + 5 ] = vcb.b;
														
 
															+
														
 
															+				colors[ i3 + 6 ] = vcc.r;
														
 
															+				colors[ i3 + 7 ] = vcc.g;
														
 
															+				colors[ i3 + 8 ] = vcc.b;
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			if ( hasFaceVertexUv === true ) {
														
 
															+
														
 
															+				var uva = faceVertexUvs[ 0 ][ i ][ 0 ];
														
 
															+				var uvb = faceVertexUvs[ 0 ][ i ][ 1 ];
														
 
															+				var uvc = faceVertexUvs[ 0 ][ i ][ 2 ];
														
 
															+
														
 
															+				uvs[ i2     ] = uva.x;
														
 
															+				uvs[ i2 + 1 ] = uva.y;
														
 
															+
														
 
															+				uvs[ i2 + 2 ] = uvb.x;
														
 
															+				uvs[ i2 + 3 ] = uvb.y;
														
 
															+
														
 
															+				uvs[ i2 + 4 ] = uvc.x;
														
 
															+				uvs[ i2 + 5 ] = uvc.y;
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+		this.computeBoundingSphere()
														
 
															+
														
 
															+		return this;
														
 
															+
														
 
															+	},
														
 
															+
														
 
															 	computeBoundingBox: function () {
														
 
															 		if ( this.boundingBox === null ) {
														
@@ -88,13 +236,13 @@ THREE.BufferGeometry.prototype = {
 
															 		}
														
 
															-		var positions = this.attributes[ "position" ].array;
														
 
															+		var positions = this.attributes[ 'position' ].array;
														
 
															 		if ( positions ) {
														
 
															 			var bb = this.boundingBox;
														
 
															-			if( positions.length >= 3 ) {
														
 
															+			if ( positions.length >= 3 ) {
														
 
															 				bb.min.x = bb.max.x = positions[ 0 ];
														
 
															 				bb.min.y = bb.max.y = positions[ 1 ];
														
 
															 				bb.min.z = bb.max.z = positions[ 2 ];
														
@@ -151,7 +299,7 @@ THREE.BufferGeometry.prototype = {
 
															 		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.' );
														
 
															+			console.error( 'THREE.BufferGeometry.computeBoundingBox: Computed min/max have NaN values. The "position" attribute is likely to have NaN values.' );
														
 
															 		}
														
@@ -170,7 +318,7 @@ THREE.BufferGeometry.prototype = {
 
															 			}
														
 
															-			var positions = this.attributes[ "position" ].array;
														
 
															+			var positions = this.attributes[ 'position' ].array;
														
 
															 			if ( positions ) {
														
@@ -181,7 +329,7 @@ THREE.BufferGeometry.prototype = {
 
															 				for ( var i = 0, il = positions.length; i < il; i += 3 ) {
														
 
															 					vector.set( positions[ i ], positions[ i + 1 ], positions[ i + 2 ] );
														
 
															-					box.addPoint( vector );
														
 
															+					box.expandByPoint( vector );
														
 
															 				}
														
@@ -203,7 +351,7 @@ THREE.BufferGeometry.prototype = {
 
															 				if ( isNaN( this.boundingSphere.radius ) ) {
														
 
															-					console.error( 'THREE.BufferGeometry.computeBoundingSphere()', 'Computed radius is NaN. The "position" attribute is likely to have NaN values.' );
														
 
															+					console.error( 'THREE.BufferGeometry.computeBoundingSphere(): Computed radius is NaN. The "position" attribute is likely to have NaN values.' );
														
 
															 				}
														
@@ -221,16 +369,16 @@ THREE.BufferGeometry.prototype = {
 
															 	computeVertexNormals: function () {
														
 
															-		if ( this.attributes[ "position" ] ) {
														
 
															+		if ( this.attributes[ 'position' ] ) {
														
 
															 			var i, il;
														
 
															 			var j, jl;
														
 
															-			var nVertexElements = this.attributes[ "position" ].array.length;
														
 
															+			var nVertexElements = this.attributes[ 'position' ].array.length;
														
 
															-			if ( this.attributes[ "normal" ] === undefined ) {
														
 
															+			if ( this.attributes[ 'normal' ] === undefined ) {
														
 
															-				this.attributes[ "normal" ] = {
														
 
															+				this.attributes[ 'normal' ] = {
														
 
															 					itemSize: 3,
														
 
															 					array: new Float32Array( nVertexElements )
														
@@ -241,16 +389,16 @@ THREE.BufferGeometry.prototype = {
 
															 				// reset existing normals to zero
														
 
															-				for ( i = 0, il = this.attributes[ "normal" ].array.length; i < il; i ++ ) {
														
 
															+				for ( i = 0, il = this.attributes[ 'normal' ].array.length; i < il; i ++ ) {
														
 
															-					this.attributes[ "normal" ].array[ i ] = 0;
														
 
															+					this.attributes[ 'normal' ].array[ i ] = 0;
														
 
															 				}
														
 
															 			}
														
 
															-			var positions = this.attributes[ "position" ].array;
														
 
															-			var normals = this.attributes[ "normal" ].array;
														
 
															+			var positions = this.attributes[ 'position' ].array;
														
 
															+			var normals = this.attributes[ 'normal' ].array;
														
 
															 			var vA, vB, vC, x, y, z,
														
@@ -263,11 +411,11 @@ THREE.BufferGeometry.prototype = {
 
															 			// indexed elements
														
 
															-			if ( this.attributes[ "index" ] ) {
														
 
															+			if ( this.attributes[ 'index' ] ) {
														
 
															-				var indices = this.attributes[ "index" ].array;
														
 
															+				var indices = this.attributes[ 'index' ].array;
														
 
															-				var offsets = (this.offsets.length > 0 ? this.offsets : [ { start: 0, count: indices.length, index: 0 } ]);
														
 
															+				var offsets = ( this.offsets.length > 0 ? this.offsets : [ { start: 0, count: indices.length, index: 0 } ] );
														
 
															 				for ( j = 0, jl = offsets.length; j < jl; ++ j ) {
														
@@ -370,28 +518,28 @@ THREE.BufferGeometry.prototype = {
 
															 		// based on http://www.terathon.com/code/tangent.html
														
 
															 		// (per vertex tangents)
														
 
															-		if ( this.attributes[ "index" ] === undefined ||
														
 
															-			 this.attributes[ "position" ] === undefined ||
														
 
															-			 this.attributes[ "normal" ] === undefined ||
														
 
															-			 this.attributes[ "uv" ] === undefined ) {
														
 
															+		if ( this.attributes[ 'index' ] === undefined ||
														
 
															+			 this.attributes[ 'position' ] === undefined ||
														
 
															+			 this.attributes[ 'normal' ] === undefined ||
														
 
															+			 this.attributes[ 'uv' ] === undefined ) {
														
 
															-			console.warn( "Missing required attributes (index, position, normal or uv) in BufferGeometry.computeTangents()" );
														
 
															+			console.warn( 'Missing required attributes (index, position, normal or uv) in BufferGeometry.computeTangents()' );
														
 
															 			return;
														
 
															 		}
														
 
															-		var indices = this.attributes[ "index" ].array;
														
 
															-		var positions = this.attributes[ "position" ].array;
														
 
															-		var normals = this.attributes[ "normal" ].array;
														
 
															-		var uvs = this.attributes[ "uv" ].array;
														
 
															+		var indices = this.attributes[ 'index' ].array;
														
 
															+		var positions = this.attributes[ 'position' ].array;
														
 
															+		var normals = this.attributes[ 'normal' ].array;
														
 
															+		var uvs = this.attributes[ 'uv' ].array;
														
 
															 		var nVertices = positions.length / 3;
														
 
															-		if ( this.attributes[ "tangent" ] === undefined ) {
														
 
															+		if ( this.attributes[ 'tangent' ] === undefined ) {
														
 
															 			var nTangentElements = 4 * nVertices;
														
 
															-			this.attributes[ "tangent" ] = {
														
 
															+			this.attributes[ 'tangent' ] = {
														
 
															 				itemSize: 4,
														
 
															 				array: new Float32Array( nTangentElements )
														
@@ -400,7 +548,7 @@ THREE.BufferGeometry.prototype = {
 
															 		}
														
 
															-		var tangents = this.attributes[ "tangent" ].array;
														
 
															+		var tangents = this.attributes[ 'tangent' ].array;
														
 
															 		var tan1 = [], tan2 = [];
														
@@ -533,7 +681,7 @@ THREE.BufferGeometry.prototype = {
 
															 			tmp2.crossVectors( n2, t );
														
 
															 			test = tmp2.dot( tan2[ v ] );
														
 
															-			w = ( test < 0.0 ) ? -1.0 : 1.0;
														
 
															+			w = ( test < 0.0 ) ? - 1.0 : 1.0;
														
 
															 			tangents[ v * 4     ] = tmp.x;
														
 
															 			tangents[ v * 4 + 1 ] = tmp.y;
														
@@ -571,19 +719,19 @@ THREE.BufferGeometry.prototype = {
 
															 		WARNING: This method will also expand the vertex count to prevent sprawled triangles across draw offsets.
														
 
															 		indexBufferSize - Defaults to 65535, but allows for larger or smaller chunks.
														
 
															 	*/
														
 
															-	computeOffsets: function(indexBufferSize) {
														
 
															+	computeOffsets: function ( indexBufferSize ) {
														
 
															 		var size = indexBufferSize;
														
 
															-		if(indexBufferSize === undefined)
														
 
															+		if ( indexBufferSize === undefined )
														
 
															 			size = 65535; //WebGL limits type of index buffer values to 16-bit.
														
 
															 		var s = Date.now();
														
 
															-		var indices = this.attributes['index'].array;
														
 
															-		var vertices = this.attributes['position'].array;
														
 
															+		var indices = this.attributes[ 'index' ].array;
														
 
															+		var vertices = this.attributes[ 'position' ].array;
														
 
															-		var verticesCount = (vertices.length/3);
														
 
															-		var facesCount = (indices.length/3);
														
 
															+		var verticesCount = ( vertices.length / 3 );
														
 
															+		var facesCount = ( indices.length / 3 );
														
 
															 		/*
														
 
															 		console.log("Computing buffers in offsets of "+size+" -> indices:"+indices.length+" vertices:"+vertices.length);
														
@@ -596,72 +744,72 @@ THREE.BufferGeometry.prototype = {
 
															 		var vertexPtr = 0;
														
 
															 		var offsets = [ { start:0, count:0, index:0 } ];
														
 
															-		var offset = offsets[0];
														
 
															+		var offset = offsets[ 0 ];
														
 
															 		var duplicatedVertices = 0;
														
 
															 		var newVerticeMaps = 0;
														
 
															-		var faceVertices = new Int32Array(6);
														
 
															+		var faceVertices = new Int32Array( 6 );
														
 
															 		var vertexMap = new Int32Array( vertices.length );
														
 
															 		var revVertexMap = new Int32Array( vertices.length );
														
 
															-		for(var j = 0; j < vertices.length; j++) { vertexMap[j] = -1; revVertexMap[j] = -1; }
														
 
															+		for ( var j = 0; j < vertices.length; j ++ ) { vertexMap[ j ] = - 1; revVertexMap[ j ] = - 1; }
														
 
															 		/*
														
 
															 			Traverse every face and reorder vertices in the proper offsets of 65k.
														
 
															 			We can have more than 65k entries in the index buffer per offset, but only reference 65k values.
														
 
															 		*/
														
 
															-		for(var findex = 0; findex < facesCount; findex++) {
														
 
															+		for ( var findex = 0; findex < facesCount; findex ++ ) {
														
 
															 			newVerticeMaps = 0;
														
 
															-			for(var vo = 0; vo < 3; vo++) {
														
 
															-				var vid = indices[ findex*3 + vo ];
														
 
															-				if(vertexMap[vid] == -1) {
														
 
															+			for ( var vo = 0; vo < 3; vo ++ ) {
														
 
															+				var vid = indices[ findex * 3 + vo ];
														
 
															+				if ( vertexMap[ vid ] == - 1 ) {
														
 
															 					//Unmapped vertice
														
 
															-					faceVertices[vo*2] = vid;
														
 
															-					faceVertices[vo*2+1] = -1;
														
 
															-					newVerticeMaps++;
														
 
															-				} else if(vertexMap[vid] < offset.index) {
														
 
															+					faceVertices[ vo * 2 ] = vid;
														
 
															+					faceVertices[ vo * 2 + 1 ] = - 1;
														
 
															+					newVerticeMaps ++;
														
 
															+				} else if ( vertexMap[ vid ] < offset.index ) {
														
 
															 					//Reused vertices from previous block (duplicate)
														
 
															-					faceVertices[vo*2] = vid;
														
 
															-					faceVertices[vo*2+1] = -1;
														
 
															-					duplicatedVertices++;
														
 
															+					faceVertices[ vo * 2 ] = vid;
														
 
															+					faceVertices[ vo * 2 + 1 ] = - 1;
														
 
															+					duplicatedVertices ++;
														
 
															 				} else {
														
 
															 					//Reused vertice in the current block
														
 
															-					faceVertices[vo*2] = vid;
														
 
															-					faceVertices[vo*2+1] = vertexMap[vid];
														
 
															+					faceVertices[ vo * 2 ] = vid;
														
 
															+					faceVertices[ vo * 2 + 1 ] = vertexMap[ vid ];
														
 
															 				}
														
 
															 			}
														
 
															 			var faceMax = vertexPtr + newVerticeMaps;
														
 
															-			if(faceMax > (offset.index + size)) {
														
 
															+			if ( faceMax > ( offset.index + size ) ) {
														
 
															 				var new_offset = { start:indexPtr, count:0, index:vertexPtr };
														
 
															-				offsets.push(new_offset);
														
 
															+				offsets.push( new_offset );
														
 
															 				offset = new_offset;
														
 
															 				//Re-evaluate reused vertices in light of new offset.
														
 
															-				for(var v = 0; v < 6; v+=2) {
														
 
															-					var new_vid = faceVertices[v+1];
														
 
															-					if(new_vid > -1 && new_vid < offset.index)
														
 
															-						faceVertices[v+1] = -1;
														
 
															+				for ( var v = 0; v < 6; v += 2 ) {
														
 
															+					var new_vid = faceVertices[ v + 1 ];
														
 
															+					if ( new_vid > - 1 && new_vid < offset.index )
														
 
															+						faceVertices[ v + 1 ] = - 1;
														
 
															 				}
														
 
															 			}
														
 
															 			//Reindex the face.
														
 
															-			for(var v = 0; v < 6; v+=2) {
														
 
															-				var vid = faceVertices[v];
														
 
															-				var new_vid = faceVertices[v+1];
														
 
															+			for ( var v = 0; v < 6; v += 2 ) {
														
 
															+				var vid = faceVertices[ v ];
														
 
															+				var new_vid = faceVertices[ v + 1 ];
														
 
															-				if(new_vid === -1)
														
 
															-					new_vid = vertexPtr++;
														
 
															+				if ( new_vid === - 1 )
														
 
															+					new_vid = vertexPtr ++;
														
 
															-				vertexMap[vid] = new_vid;
														
 
															-				revVertexMap[new_vid] = vid;
														
 
															-				sortedIndices[indexPtr++] = new_vid - offset.index; //XXX overflows at 16bit
														
 
															-				offset.count++;
														
 
															+				vertexMap[ vid ] = new_vid;
														
 
															+				revVertexMap[ new_vid ] = vid;
														
 
															+				sortedIndices[ indexPtr ++ ] = new_vid - offset.index; //XXX overflows at 16bit
														
 
															+				offset.count ++;
														
 
															 			}
														
 
															 		}
														
 
															 		/* Move all attribute values to map to the new computed indices , also expand the vertice stack to match our new vertexPtr. */
														
 
															-		this.reorderBuffers(sortedIndices, revVertexMap, vertexPtr);
														
 
															+		this.reorderBuffers( sortedIndices, revVertexMap, vertexPtr );
														
 
															 		this.offsets = offsets;
														
 
															 		/*
														
@@ -683,7 +831,7 @@ THREE.BufferGeometry.prototype = {
 
															 	normalizeNormals: function () {
														
 
															-		var normals = this.attributes[ "normal" ].array;
														
 
															+		var normals = this.attributes[ 'normal' ].array;
														
 
															 		var x, y, z, n;
														
@@ -710,45 +858,45 @@ THREE.BufferGeometry.prototype = {
 
															 		indexMap - Int32Array where the position is the new vertex ID and the value the old vertex ID for each vertex.
														
 
															 		vertexCount - Amount of total vertices considered in this reordering (in case you want to grow the vertice stack).
														
 
															 	*/
														
 
															-	reorderBuffers: function(indexBuffer, indexMap, vertexCount) {
														
 
															+	reorderBuffers: function ( indexBuffer, indexMap, vertexCount ) {
														
 
															 		/* Create a copy of all attributes for reordering. */
														
 
															 		var sortedAttributes = {};
														
 
															 		var types = [ Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array ];
														
 
															-		for( var attr in this.attributes ) {
														
 
															-			if(attr == 'index')
														
 
															+		for ( var attr in this.attributes ) {
														
 
															+			if ( attr == 'index' )
														
 
															 				continue;
														
 
															-			var sourceArray = this.attributes[attr].array;
														
 
															-			for ( var i = 0, il = types.length; i < il; i++ ) {
														
 
															-				var type = types[i];
														
 
															-				if (sourceArray instanceof type) {
														
 
															-					sortedAttributes[attr] = new type( this.attributes[attr].itemSize * vertexCount );
														
 
															+			var sourceArray = this.attributes[ attr ].array;
														
 
															+			for ( var i = 0, il = types.length; i < il; i ++ ) {
														
 
															+				var type = types[ i ];
														
 
															+				if ( sourceArray instanceof type ) {
														
 
															+					sortedAttributes[ attr ] = new type( this.attributes[ attr ].itemSize * vertexCount );
														
 
															 					break;
														
 
															 				}
														
 
															 			}
														
 
															 		}
														
 
															 		/* Move attribute positions based on the new index map */
														
 
															-		for(var new_vid = 0; new_vid < vertexCount; new_vid++) {
														
 
															-			var vid = indexMap[new_vid];
														
 
															+		for ( var new_vid = 0; new_vid < vertexCount; new_vid ++ ) {
														
 
															+			var vid = indexMap[ new_vid ];
														
 
															 			for ( var attr in this.attributes ) {
														
 
															-				if(attr == 'index')
														
 
															+				if ( attr == 'index' )
														
 
															 					continue;
														
 
															-				var attrArray = this.attributes[attr].array;
														
 
															-				var attrSize = this.attributes[attr].itemSize;
														
 
															-				var sortedAttr = sortedAttributes[attr];
														
 
															-				for(var k = 0; k < attrSize; k++)
														
 
															+				var attrArray = this.attributes[ attr ].array;
														
 
															+				var attrSize = this.attributes[ attr ].itemSize;
														
 
															+				var sortedAttr = sortedAttributes[ attr ];
														
 
															+				for ( var k = 0; k < attrSize; k ++ )
														
 
															 					sortedAttr[ new_vid * attrSize + k ] = attrArray[ vid * attrSize + k ];
														
 
															 			}
														
 
															 		}
														
 
															 		/* Carry the new sorted buffers locally */
														
 
															-		this.attributes['index'].array = indexBuffer;
														
 
															+		this.attributes[ 'index' ].array = indexBuffer;
														
 
															 		for ( var attr in this.attributes ) {
														
 
															-			if(attr == 'index')
														
 
															+			if ( attr == 'index' )
														
 
															 				continue;
														
 
															-			this.attributes[attr].array = sortedAttributes[attr];
														
 
															-			this.attributes[attr].numItems = this.attributes[attr].itemSize * vertexCount;
														
 
															+			this.attributes[ attr ].array = sortedAttributes[ attr ];
														
 
															+			this.attributes[ attr ].numItems = this.attributes[ attr ].itemSize * vertexCount;
														
 
															 		}
														
 
															 	},
														
--- a/src/core/Clock.js
+++ b/src/core/Clock.js
@@ -21,8 +21,8 @@ THREE.Clock.prototype = {
 
															 	start: function () {
														
 
															 		this.startTime = self.performance !== undefined && self.performance.now !== undefined
														
 
															-					? self.performance.now()
														
 
															-					: Date.now();
														
 
															+					 ? self.performance.now()
														
 
															+					 : Date.now();
														
 
															 		this.oldTime = this.startTime;
														
 
															 		this.running = true;
														
@@ -55,8 +55,8 @@ THREE.Clock.prototype = {
 
															 		if ( this.running ) {
														
 
															 			var newTime = self.performance !== undefined && self.performance.now !== undefined
														
 
															-					? self.performance.now()
														
 
															-					: Date.now();
														
 
															+					 ? self.performance.now()
														
 
															+					 : Date.now();
														
 
															 			diff = 0.001 * ( newTime - this.oldTime );
														
 
															 			this.oldTime = newTime;
														
--- a/src/core/EventDispatcher.js
+++ b/src/core/EventDispatcher.js
@@ -75,7 +75,7 @@ THREE.EventDispatcher.prototype = {
 
															 	},
														
 
															 	dispatchEvent: function ( event ) {
														
 
															-			
														
 
															+
														
 
															 		if ( this._listeners === undefined ) return;
														
 
															 		var listeners = this._listeners;
														
--- a/src/core/Face3.js
+++ b/src/core/Face3.js
@@ -35,21 +35,21 @@ THREE.Face3.prototype = {
 
															 		face.materialIndex = this.materialIndex;
														
 
															 		for ( var i = 0, il = this.vertexNormals.length; i < il; i ++ ) {
														
 
															-		
														
 
															+
														
 
															 			face.vertexNormals[ i ] = this.vertexNormals[ i ].clone();
														
 
															-		
														
 
															+
														
 
															 		}
														
 
															 		for ( var i = 0, il = this.vertexColors.length; i < il; i ++ ) {
														
 
															-		
														
 
															+
														
 
															 			face.vertexColors[ i ] = this.vertexColors[ i ].clone();
														
 
															-		
														
 
															+
														
 
															 		}
														
 
															 		for ( var i = 0, il = this.vertexTangents.length; i < il; i ++ ) {
														
 
															-		
														
 
															+
														
 
															 			face.vertexTangents[ i ] = this.vertexTangents[ i ].clone();
														
 
															-		
														
 
															+
														
 
															 		}
														
 
															 		return face;
														
--- a/src/core/Face4.js
+++ b/src/core/Face4.js
@@ -4,7 +4,7 @@
 
															 THREE.Face4 = function ( a, b, c, d, normal, color, materialIndex ) {
														
 
															-	console.warn( 'THREE.Face4 has been removed. A THREE.Face3 will be created instead.')
														
 
															+	console.warn( 'THREE.Face4 has been removed. A THREE.Face3 will be created instead.' )
														
 
															 	return new THREE.Face3( a, b, c, normal, color, materialIndex );
														
 
															 };
														
--- a/src/core/Geometry.js
+++ b/src/core/Geometry.js
@@ -19,7 +19,7 @@ THREE.Geometry = function () {
 
															 	this.faces = [];
														
 
															-	this.faceVertexUvs = [[]];
														
 
															+	this.faceVertexUvs = [ [] ];
														
 
															 	this.morphTargets = [];
														
 
															 	this.morphColors = [];
														
@@ -93,6 +93,22 @@ THREE.Geometry.prototype = {
 
															 	},
														
 
															+	center: function () {
														
 
															+
														
 
															+		this.computeBoundingBox();
														
 
															+
														
 
															+		var offset = new THREE.Vector3();
														
 
															+
														
 
															+		offset.addVectors( this.boundingBox.min, this.boundingBox.max );
														
 
															+		offset.multiplyScalar( - 0.5 );
														
 
															+
														
 
															+		this.applyMatrix( new THREE.Matrix4().makeTranslation( offset.x, offset.y, offset.z ) );
														
 
															+		this.computeBoundingBox();
														
 
															+
														
 
															+		return offset;
														
 
															+
														
 
															+	},
														
 
															+
														
 
															 	computeFaceNormals: function () {
														
 
															 		var cb = new THREE.Vector3(), ab = new THREE.Vector3();
														
@@ -381,7 +397,7 @@ THREE.Geometry.prototype = {
 
															 			face = this.faces[ f ];
														
 
															-			for ( i = 0; i < Math.min( face.vertexNormals.length, 3 ); i++ ) {
														
 
															+			for ( i = 0; i < Math.min( face.vertexNormals.length, 3 ); i ++ ) {
														
 
															 				n.copy( face.vertexNormals[ i ] );
														
@@ -398,7 +414,7 @@ THREE.Geometry.prototype = {
 
															 				tmp2.crossVectors( face.vertexNormals[ i ], t );
														
 
															 				test = tmp2.dot( tan2[ vertexIndex ] );
														
 
															-				w = (test < 0.0) ? -1.0 : 1.0;
														
 
															+				w = ( test < 0.0 ) ? - 1.0 : 1.0;
														
 
															 				face.vertexTangents[ i ] = new THREE.Vector4( tmp.x, tmp.y, tmp.z, w );
														
@@ -410,7 +426,7 @@ THREE.Geometry.prototype = {
 
															 	},
														
 
															-	computeLineDistances: function ( ) {
														
 
															+	computeLineDistances: function () {
														
 
															 		var d = 0;
														
 
															 		var vertices = this.vertices;
														
@@ -545,11 +561,11 @@ THREE.Geometry.prototype = {
 
															 		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 ++ ) {
														
@@ -606,7 +622,7 @@ THREE.Geometry.prototype = {
 
															 		// have to remove them from the geometry.
														
 
															 		var faceIndicesToRemove = [];
														
 
															-		for( i = 0, il = this.faces.length; i < il; i ++ ) {
														
 
															+		for ( i = 0, il = this.faces.length; i < il; i ++ ) {
														
 
															 			face = this.faces[ i ];
														
@@ -616,7 +632,7 @@ THREE.Geometry.prototype = {
 
															 			indices = [ face.a, face.b, face.c ];
														
 
															-			var dupIndex = -1;
														
 
															+			var dupIndex = - 1;
														
 
															 			// if any duplicate vertices are found in a Face3
														
 
															 			// we have to remove the face as nothing can be saved
														
@@ -658,7 +674,7 @@ THREE.Geometry.prototype = {
 
															 	makeGroups: ( function () {
														
 
															 		var geometryGroupCounter = 0;
														
 
															-		
														
 
															+
														
 
															 		return function ( usesFaceMaterial, maxVerticesInGroup ) {
														
 
															 			var f, fl, face, materialIndex,
														
@@ -717,7 +733,7 @@ THREE.Geometry.prototype = {
 
															 			}
														
 
															 		};
														
 
															-		
														
 
															+
														
 
															 	} )(),
														
 
															 	clone: function () {
														
--- a/src/core/Object3D.js
+++ b/src/core/Object3D.js
@@ -18,7 +18,7 @@ THREE.Object3D = function () {
 
															 	this.up = THREE.Object3D.DefaultUp.clone();
														
 
															 	var scope = this;
														
 
															-	
														
 
															+
														
 
															 	var position = new THREE.Vector3();
														
 
															 	var rotation = new THREE.Euler();
														
 
															 	var quaternion = new THREE.Quaternion();
														
@@ -27,7 +27,7 @@ THREE.Object3D = function () {
 
															 	rotation.onChange( function () {
														
 
															 		quaternion.setFromEuler( rotation, false );
														
 
															 	} );
														
 
															-	
														
 
															+
														
 
															 	quaternion.onChange( function () {
														
 
															 		rotation.setFromQuaternion( quaternion, undefined, false );
														
 
															 	} );
														
@@ -35,44 +35,20 @@ THREE.Object3D = function () {
 
															 	Object.defineProperties( this, {
														
 
															 		position: {
														
 
															 			enumerable: true,
														
 
															-			get: function () {
														
 
															-				return position;
														
 
															-			},
														
 
															-			set: function ( value ) {
														
 
															-				console.error( 'THREE.Object3D: .position = new THREE.Vector3() pattern no longer works. Use .position.copy() instead.' );
														
 
															-				position.copy( value );
														
 
															-			}
														
 
															+			value: position
														
 
															 		},
														
 
															 		rotation: {
														
 
															 			enumerable: true,
														
 
															-			get: function () {
														
 
															-				return rotation;
														
 
															-			},
														
 
															-			set: function ( value ) {
														
 
															-				console.error( 'THREE.Object3D: .rotation = new THREE.Euler() pattern no longer works. Use .rotation.copy() instead.' );
														
 
															-				rotation.copy( value );
														
 
															-			}
														
 
															+			value: rotation
														
 
															 		},
														
 
															 		quaternion: {
														
 
															 			enumerable: true,
														
 
															-			get: function () {
														
 
															-				return quaternion;
														
 
															-			},
														
 
															-			set: function ( value ) {
														
 
															-				console.error( 'THREE.Object3D: .quaternion = new THREE.Quaternion() pattern no longer works. Use .quaternion.copy() instead.' );
														
 
															-				quaternion.copy( value );
														
 
															-			}
														
 
															+			value: quaternion
														
 
															 		},
														
 
															 		scale: {
														
 
															 			enumerable: true,
														
 
															-			get: function () {
														
 
															-				return scale;
														
 
															-			},
														
 
															-			set: function ( value ) {
														
 
															-				console.error( 'THREE.Object3D: .scale = new THREE.Vector3() pattern no longer works. Use .scale.copy() instead.' );
														
 
															-				scale.copy( value );
														
 
															-			}
														
 
															-		}
														
 
															+			value: scale
														
 
															+		},
														
 
															 	} );
														
 
															 	this.renderDepth = null;
														
@@ -168,7 +144,7 @@ THREE.Object3D.prototype = {
 
															 	},
														
 
															-	rotateOnAxis: function() {
														
 
															+	rotateOnAxis: function () {
														
 
															 		// rotate object on axis in object space
														
 
															 		// axis is assumed to be normalized
														
@@ -232,9 +208,7 @@ THREE.Object3D.prototype = {
 
															 		return function ( axis, distance ) {
														
 
															-			v1.copy( axis );
														
 
															-
														
 
															-			v1.applyQuaternion( this.quaternion );
														
 
															+			v1.copy( axis ).applyQuaternion( this.quaternion );
														
 
															 			this.position.add( v1.multiplyScalar( distance ) );
														
@@ -325,7 +299,7 @@ THREE.Object3D.prototype = {
 
															 		if ( object === this ) {
														
 
															-			console.warn( 'THREE.Object3D.add: An object can\'t be added as a child of itself.' );
														
 
															+			console.warn( "THREE.Object3D.add: An object can't be added as a child of itself." );
														
 
															 			return;
														
 
															 		}
														
@@ -393,7 +367,7 @@ THREE.Object3D.prototype = {
 
															 		}
														
 
															 	},
														
 
															-	
														
 
															+
														
 
															 	raycast: function () {},
														
 
															 	traverse: function ( callback ) {
														
--- a/src/core/Projector.js
+++ b/src/core/Projector.js
@@ -21,7 +21,7 @@ THREE.Projector = function () {
 
															 	_vector3 = new THREE.Vector3(),
														
 
															 	_vector4 = new THREE.Vector4(),
														
 
															-	_clipBox = new THREE.Box3( new THREE.Vector3( -1, -1, -1 ), new THREE.Vector3( 1, 1, 1 ) ),
														
 
															+	_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 ),
														
@@ -67,7 +67,7 @@ THREE.Projector = function () {
 
															 	this.pickingRay = function ( vector, camera ) {
														
 
															 		// set two vectors with opposing z values
														
 
															-		vector.z = -1.0;
														
 
															+		vector.z = - 1.0;
														
 
															 		var end = new THREE.Vector3( vector.x, vector.y, 1.0 );
														
 
															 		this.unprojectVector( vector, camera );
														
@@ -176,9 +176,9 @@ THREE.Projector = function () {
 
															 			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;
														
 
															+			vertex.visible = positionScreen.x >= - 1 && positionScreen.x <= 1 &&
														
 
															+					 positionScreen.y >= - 1 && positionScreen.y <= 1 &&
														
 
															+					 positionScreen.z >= - 1 && positionScreen.z <= 1;
														
 
															 		};
														
@@ -436,8 +436,8 @@ THREE.Projector = function () {
 
															 						face = faces[ f ];
														
 
															 						var material = isFaceMaterial === true
														
 
															-							? objectMaterials.materials[ face.materialIndex ]
														
 
															-							: object.material;
														
 
															+							 ? objectMaterials.materials[ face.materialIndex ]
														
 
															+							 : object.material;
														
 
															 						if ( material === undefined ) continue;
														
@@ -659,14 +659,14 @@ THREE.Projector = function () {
 
															 			} else if ( object instanceof THREE.Sprite ) {
														
 
															-				_vector4.set( _modelMatrix.elements[12], _modelMatrix.elements[13], _modelMatrix.elements[14], 1 );
														
 
															+				_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 ) {
														
 
															+				if ( _vector4.z >= - 1 && _vector4.z <= 1 ) {
														
 
															 					_sprite = getNextSpriteInPool();
														
 
															 					_sprite.id = object.id;
														
@@ -677,8 +677,8 @@ THREE.Projector = function () {
 
															 					_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.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;
														
@@ -815,7 +815,7 @@ THREE.Projector = function () {
 
															 			// Both vertices lie entirely within all clip planes.
														
 
															 			return true;
														
 
															-		} else if ( ( bc1near < 0 && bc2near < 0) || (bc1far < 0 && bc2far < 0 ) ) {
														
 
															+		} else if ( ( bc1near < 0 && bc2near < 0 ) || ( bc1far < 0 && bc2far < 0 ) ) {
														
 
															 			// Both vertices lie entirely outside one of the clip planes.
														
 
															 			return false;
														
--- a/src/core/Raycaster.js
+++ b/src/core/Raycaster.js
@@ -49,42 +49,48 @@
 
															 	};
														
 
															 	//
														
 
															+	
														
 
															+	THREE.Raycaster.prototype = {
														
 
															-	THREE.Raycaster.prototype.precision = 0.0001;
														
 
															-	THREE.Raycaster.prototype.linePrecision = 1;
														
 
															+		constructor: THREE.Raycaster,
														
 
															-	THREE.Raycaster.prototype.set = function ( origin, direction ) {
														
 
															+		precision: 0.0001,
														
 
															+		linePrecision: 1,
														
 
															-		this.ray.set( origin, direction );
														
 
															-		// direction is assumed to be normalized (for accurate distance calculations)
														
 
															+		set: function ( origin, direction ) {
														
 
															-	};
														
 
															+			this.ray.set( origin, direction );
														
 
															+			// direction is assumed to be normalized (for accurate distance calculations)
														
 
															-	THREE.Raycaster.prototype.intersectObject = function ( object, recursive ) {
														
 
															+		},
														
 
															-		var intersects = [];
														
 
															-		
														
 
															-		intersectObject( object, this, intersects, recursive );
														
 
															+		intersectObject: function ( object, recursive ) {
														
 
															-		intersects.sort( descSort );
														
 
															+			var intersects = [];
														
 
															-		return intersects;
														
 
															+			intersectObject( object, this, intersects, recursive );
														
 
															-	};
														
 
															+			intersects.sort( descSort );
														
 
															-	THREE.Raycaster.prototype.intersectObjects = function ( objects, recursive ) {
														
 
															+			return intersects;
														
 
															-		var intersects = [];
														
 
															+		},
														
 
															-		for ( var i = 0, l = objects.length; i < l; i ++ ) {
														
 
															+		intersectObjects: function ( objects, recursive ) {
														
 
															-			intersectObject( objects[ i ], this, intersects, recursive );
														
 
															+			var intersects = [];
														
 
															-		}
														
 
															+			for ( var i = 0, l = objects.length; i < l; i ++ ) {
														
 
															-		intersects.sort( descSort );
														
 
															+				intersectObject( objects[ i ], this, intersects, recursive );
														
 
															-		return intersects;
														
 
															+			}
														
 
															+
														
 
															+			intersects.sort( descSort );
														
 
															+
														
 
															+			return intersects;
														
 
															+
														
 
															+		}
														
 
															 	};
														
--- a/src/extras/FontUtils.js
+++ b/src/extras/FontUtils.js
@@ -21,23 +21,23 @@
 
															 THREE.FontUtils = {
														
 
															-	faces : {},
														
 
															+	faces: {},
														
 
															 	// Just for now. face[weight][style]
														
 
															-	face : "helvetiker",
														
 
															-	weight: "normal",
														
 
															-	style : "normal",
														
 
															-	size : 150,
														
 
															-	divisions : 10,
														
 
															+	face: 'helvetiker',
														
 
															+	weight: 'normal',
														
 
															+	style: 'normal',
														
 
															+	size: 150,
														
 
															+	divisions: 10,
														
 
															-	getFace : function() {
														
 
															+	getFace: function () {
														
 
															 		return this.faces[ this.face ][ this.weight ][ this.style ];
														
 
															 	},
														
 
															-	loadFace : function( data ) {
														
 
															+	loadFace: function ( data ) {
														
 
															 		var family = data.familyName.toLowerCase();
														
@@ -54,7 +54,7 @@ THREE.FontUtils = {
 
															 	},
														
 
															-	drawText : function( text ) {
														
 
															+	drawText: function ( text ) {
														
 
															 		var characterPts = [], allPts = [];
														
@@ -96,14 +96,14 @@ THREE.FontUtils = {
 
															 		//extract.paths = fontPaths;
														
 
															 		//extract.offset = width;
														
 
															-		return { paths : fontPaths, offset : width };
														
 
															+		return { paths: fontPaths, offset: width };
														
 
															 	},
														
 
															-	extractGlyphPoints : function( c, face, scale, offset, path ) {
														
 
															+	extractGlyphPoints: function ( c, face, scale, offset, path ) {
														
 
															 		var pts = [];
														
@@ -114,7 +114,7 @@ THREE.FontUtils = {
 
															 			laste,
														
 
															 			glyph = face.glyphs[ c ] || face.glyphs[ '?' ];
														
 
															-		if ( !glyph ) return;
														
 
															+		if ( ! glyph ) return;
														
 
															 		if ( glyph.o ) {
														
@@ -130,14 +130,14 @@ THREE.FontUtils = {
 
															 				//console.log( action );
														
 
															-				switch( action ) {
														
 
															+				switch ( action ) {
														
 
															 				case 'm':
														
 
															 					// Move To
														
 
															-					x = outline[ i++ ] * scaleX + offset;
														
 
															-					y = outline[ i++ ] * scaleY;
														
 
															+					x = outline[ i ++ ] * scaleX + offset;
														
 
															+					y = outline[ i ++ ] * scaleY;
														
 
															 					path.moveTo( x, y );
														
 
															 					break;
														
@@ -146,21 +146,21 @@ THREE.FontUtils = {
 
															 					// Line To
														
 
															-					x = outline[ i++ ] * scaleX + offset;
														
 
															-					y = outline[ i++ ] * scaleY;
														
 
															-					path.lineTo(x,y);
														
 
															+					x = outline[ i ++ ] * scaleX + offset;
														
 
															+					y = outline[ i ++ ] * scaleY;
														
 
															+					path.lineTo( x,y );
														
 
															 					break;
														
 
															 				case 'q':
														
 
															 					// QuadraticCurveTo
														
 
															-					cpx  = outline[ i++ ] * scaleX + offset;
														
 
															-					cpy  = outline[ i++ ] * scaleY;
														
 
															-					cpx1 = outline[ i++ ] * scaleX + offset;
														
 
															-					cpy1 = outline[ i++ ] * scaleY;
														
 
															+					cpx  = outline[ i ++ ] * scaleX + offset;
														
 
															+					cpy  = outline[ i ++ ] * scaleY;
														
 
															+					cpx1 = outline[ i ++ ] * scaleX + offset;
														
 
															+					cpy1 = outline[ i ++ ] * scaleY;
														
 
															-					path.quadraticCurveTo(cpx1, cpy1, cpx, cpy);
														
 
															+					path.quadraticCurveTo( cpx1, cpy1, cpx, cpy );
														
 
															 					laste = pts[ pts.length - 1 ];
														
@@ -184,14 +184,14 @@ THREE.FontUtils = {
 
															 					// Cubic Bezier Curve
														
 
															-					cpx  = outline[ i++ ] *  scaleX + offset;
														
 
															-					cpy  = outline[ i++ ] *  scaleY;
														
 
															-					cpx1 = outline[ i++ ] *  scaleX + offset;
														
 
															-					cpy1 = outline[ i++ ] * -scaleY;
														
 
															-					cpx2 = outline[ i++ ] *  scaleX + offset;
														
 
															-					cpy2 = outline[ i++ ] * -scaleY;
														
 
															+					cpx  = outline[ i ++ ] *  scaleX + offset;
														
 
															+					cpy  = outline[ i ++ ] *  scaleY;
														
 
															+					cpx1 = outline[ i ++ ] *  scaleX + offset;
														
 
															+					cpy1 = outline[ i ++ ] *  scaleY;
														
 
															+					cpx2 = outline[ i ++ ] *  scaleX + offset;
														
 
															+					cpy2 = outline[ i ++ ] *  scaleY;
														
 
															-					path.bezierCurveTo( cpx, cpy, cpx1, cpy1, cpx2, cpy2 );
														
 
															+					path.bezierCurveTo( cpx1, cpy1, cpx2, cpy2, cpx, cpy );
														
 
															 					laste = pts[ pts.length - 1 ];
														
@@ -219,24 +219,24 @@ THREE.FontUtils = {
 
															-		return { offset: glyph.ha*scale, path:path};
														
 
															+		return { offset: glyph.ha * scale, path:path };
														
 
															 	}
														
 
															 };
														
 
															-THREE.FontUtils.generateShapes = function( text, parameters ) {
														
 
															+THREE.FontUtils.generateShapes = function ( text, parameters ) {
														
 
															 	// Parameters 
														
 
															 	parameters = parameters || {};
														
 
															 	var size = parameters.size !== undefined ? parameters.size : 100;
														
 
															-	var curveSegments = parameters.curveSegments !== undefined ? parameters.curveSegments: 4;
														
 
															+	var curveSegments = parameters.curveSegments !== undefined ? parameters.curveSegments : 4;
														
 
															-	var font = parameters.font !== undefined ? parameters.font : "helvetiker";
														
 
															-	var weight = parameters.weight !== undefined ? parameters.weight : "normal";
														
 
															-	var style = parameters.style !== undefined ? parameters.style : "normal";
														
 
															+	var font = parameters.font !== undefined ? parameters.font : 'helvetiker';
														
 
															+	var weight = parameters.weight !== undefined ? parameters.weight : 'normal';
														
 
															+	var style = parameters.style !== undefined ? parameters.style : 'normal';
														
 
															 	THREE.FontUtils.size = size;
														
 
															 	THREE.FontUtils.divisions = curveSegments;
														
@@ -278,13 +278,13 @@ THREE.FontUtils.generateShapes = function( text, parameters ) {
 
															  */
														
 
															-( function( namespace ) {
														
 
															+( function ( namespace ) {
														
 
															 	var EPSILON = 0.0000000001;
														
 
															 	// takes in an contour array and returns
														
 
															-	var process = function( contour, indices ) {
														
 
															+	var process = function ( contour, indices ) {
														
 
															 		var n = contour.length;
														
@@ -300,11 +300,11 @@ THREE.FontUtils.generateShapes = function( text, parameters ) {
 
															 		if ( area( contour ) > 0.0 ) {
														
 
															-			for ( v = 0; v < n; v++ ) verts[ v ] = v;
														
 
															+			for ( v = 0; v < n; v ++ ) verts[ v ] = v;
														
 
															 		} else {
														
 
															-			for ( v = 0; v < n; v++ ) verts[ v ] = ( n - 1 ) - v;
														
 
															+			for ( v = 0; v < n; v ++ ) verts[ v ] = ( n - 1 ) - v;
														
 
															 		}
														
@@ -314,18 +314,18 @@ THREE.FontUtils.generateShapes = function( text, parameters ) {
 
															 		var count = 2 * nv;   /* error detection */
														
 
															-		for( v = nv - 1; nv > 2; ) {
														
 
															+		for ( v = nv - 1; nv > 2; ) {
														
 
															 			/* if we loop, it is probably a non-simple polygon */
														
 
															-			if ( ( count-- ) <= 0 ) {
														
 
															+			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.log( "Warning, unable to triangulate polygon!" );
														
 
															+				console.log( 'Warning, unable to triangulate polygon!' );
														
 
															 				if ( indices ) return vertIndices;
														
 
															 				return result;
														
@@ -359,13 +359,13 @@ THREE.FontUtils.generateShapes = function( text, parameters ) {
 
															 				/* remove v from the remaining polygon */
														
 
															-				for( s = v, t = v + 1; t < nv; s++, t++ ) {
														
 
															+				for ( s = v, t = v + 1; t < nv; s++, t++ ) {
														
 
															 					verts[ s ] = verts[ t ];
														
 
															 				}
														
 
															-				nv--;
														
 
															+				nv --;
														
 
															 				/* reset error detection counter */
														
@@ -387,7 +387,7 @@ THREE.FontUtils.generateShapes = function( text, parameters ) {
 
															 		var n = contour.length;
														
 
															 		var a = 0.0;
														
 
															-		for( var p = n - 1, q = 0; q < n; p = q++ ) {
														
 
															+		for ( var p = n - 1, q = 0; q < n; p = q ++ ) {
														
 
															 			a += contour[ p ].x * contour[ q ].y - contour[ q ].x * contour[ p ].y;
														
@@ -412,7 +412,7 @@ THREE.FontUtils.generateShapes = function( text, parameters ) {
 
															 		cx = contour[ verts[ w ] ].x;
														
 
															 		cy = contour[ verts[ w ] ].y;
														
 
															-		if ( EPSILON > (((bx-ax)*(cy-ay)) - ((by-ay)*(cx-ax))) ) return false;
														
 
															+		if ( 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;
														
@@ -422,14 +422,14 @@ THREE.FontUtils.generateShapes = function( text, parameters ) {
 
															 		bX = ax - cx;  bY = ay - cy;
														
 
															 		cX = bx - ax;  cY = by - ay;
														
 
															-		for ( p = 0; p < n; p++ ) {
														
 
															+		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;
														
 
															+			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;
														
@@ -437,11 +437,11 @@ THREE.FontUtils.generateShapes = function( text, parameters ) {
 
															 			// see if p is inside triangle abc
														
 
															-			aCROSSbp = aX*bpy - aY*bpx;
														
 
															-			cCROSSap = cX*apy - cY*apx;
														
 
															-			bCROSScp = bX*cpy - bY*cpx;
														
 
															+			aCROSSbp = aX * bpy - aY * bpx;
														
 
															+			cCROSSap = cX * apy - cY * apx;
														
 
															+			bCROSScp = bX * cpy - bY * cpx;
														
 
															-			if ( (aCROSSbp >= -EPSILON) && (bCROSScp >= -EPSILON) && (cCROSSap >= -EPSILON) ) return false;
														
 
															+			if ( ( aCROSSbp >= - EPSILON ) && ( bCROSScp >= - EPSILON ) && ( cCROSSap >= - EPSILON ) ) return false;
														
 
															 		}
														
@@ -455,7 +455,7 @@ THREE.FontUtils.generateShapes = function( text, parameters ) {
 
															 	return namespace;
														
 
															-})(THREE.FontUtils);
														
 
															+} )( THREE.FontUtils );
														
 
															 // To use the typeface.js face files, hook up the API
														
 
															 self._typeface_js = { faces: THREE.FontUtils.faces, loadFace: THREE.FontUtils.loadFace };
														
--- a/src/extras/GeometryUtils.js
+++ b/src/extras/GeometryUtils.js
@@ -1,12 +1,9 @@
 
															 /**
														
 
															  * @author mrdoob / http://mrdoob.com/
														
 
															- * @author alteredq / http://alteredqualia.com/
														
 
															  */
														
 
															 THREE.GeometryUtils = {
														
 
															-	// Merge two geometries or geometry and geometry from object (using object's transform)
														
 
															-
														
 
															 	merge: function ( geometry1, geometry2, materialIndexOffset ) {
														
 
															 		console.warn( 'THREE.GeometryUtils: .merge() has been moved to Geometry. Use geometry.merge( geometry2, matrix, materialIndexOffset ) instead.' );
														
@@ -26,201 +23,10 @@ THREE.GeometryUtils = {
 
															 	},
														
 
															-	// Get random point in triangle (via barycentric coordinates)
														
 
															-	// 	(uniform distribution)
														
 
															-	// 	http://www.cgafaq.info/wiki/Random_Point_In_Triangle
														
 
															-
														
 
															-	randomPointInTriangle: function () {
														
 
															-
														
 
															-		var vector = new THREE.Vector3();
														
 
															-
														
 
															-		return function ( vectorA, vectorB, vectorC ) {
														
 
															-
														
 
															-			var point = new THREE.Vector3();
														
 
															-
														
 
															-			var a = THREE.Math.random16();
														
 
															-			var b = THREE.Math.random16();
														
 
															-
														
 
															-			if ( ( a + b ) > 1 ) {
														
 
															-
														
 
															-				a = 1 - a;
														
 
															-				b = 1 - b;
														
 
															-
														
 
															-			}
														
 
															-
														
 
															-			var c = 1 - a - b;
														
 
															-
														
 
															-			point.copy( vectorA );
														
 
															-			point.multiplyScalar( a );
														
 
															-
														
 
															-			vector.copy( vectorB );
														
 
															-			vector.multiplyScalar( b );
														
 
															-
														
 
															-			point.add( vector );
														
 
															-
														
 
															-			vector.copy( vectorC );
														
 
															-			vector.multiplyScalar( c );
														
 
															-
														
 
															-			point.add( vector );
														
 
															-
														
 
															-			return point;
														
 
															-
														
 
															-		};
														
 
															-
														
 
															-	}(),
														
 
															-
														
 
															-	// Get random point in face (triangle)
														
 
															-	// (uniform distribution)
														
 
															-
														
 
															-	randomPointInFace: function ( face, geometry, useCachedAreas ) {
														
 
															-
														
 
															-		var vA, vB, vC;
														
 
															-
														
 
															-		vA = geometry.vertices[ face.a ];
														
 
															-		vB = geometry.vertices[ face.b ];
														
 
															-		vC = geometry.vertices[ face.c ];
														
 
															-
														
 
															-		return THREE.GeometryUtils.randomPointInTriangle( vA, vB, vC );
														
 
															-
														
 
															-	},
														
 
															-
														
 
															-	// Get uniformly distributed random points in mesh
														
 
															-	// 	- create array with cumulative sums of face areas
														
 
															-	//  - pick random number from 0 to total area
														
 
															-	//  - find corresponding place in area array by binary search
														
 
															-	//	- get random point in face
														
 
															-
														
 
															-	randomPointsInGeometry: function ( geometry, n ) {
														
 
															-
														
 
															-		var face, i,
														
 
															-			faces = geometry.faces,
														
 
															-			vertices = geometry.vertices,
														
 
															-			il = faces.length,
														
 
															-			totalArea = 0,
														
 
															-			cumulativeAreas = [],
														
 
															-			vA, vB, vC, vD;
														
 
															-
														
 
															-		// precompute face areas
														
 
															-
														
 
															-		for ( i = 0; i < il; i ++ ) {
														
 
															-
														
 
															-			face = faces[ i ];
														
 
															-
														
 
															-			vA = vertices[ face.a ];
														
 
															-			vB = vertices[ face.b ];
														
 
															-			vC = vertices[ face.c ];
														
 
															-
														
 
															-			face._area = THREE.GeometryUtils.triangleArea( vA, vB, vC );
														
 
															-
														
 
															-			totalArea += face._area;
														
 
															-
														
 
															-			cumulativeAreas[ i ] = totalArea;
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-		// binary search cumulative areas array
														
 
															-
														
 
															-		function binarySearchIndices( value ) {
														
 
															-
														
 
															-			function binarySearch( start, end ) {
														
 
															-
														
 
															-				// return closest larger index
														
 
															-				// if exact number is not found
														
 
															-
														
 
															-				if ( end < start )
														
 
															-					return start;
														
 
															-
														
 
															-				var mid = start + Math.floor( ( end - start ) / 2 );
														
 
															-
														
 
															-				if ( cumulativeAreas[ mid ] > value ) {
														
 
															-
														
 
															-					return binarySearch( start, mid - 1 );
														
 
															-
														
 
															-				} else if ( cumulativeAreas[ mid ] < value ) {
														
 
															-
														
 
															-					return binarySearch( mid + 1, end );
														
 
															-
														
 
															-				} else {
														
 
															-
														
 
															-					return mid;
														
 
															-
														
 
															-				}
														
 
															-
														
 
															-			}
														
 
															-
														
 
															-			var result = binarySearch( 0, cumulativeAreas.length - 1 )
														
 
															-			return result;
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-		// pick random face weighted by face area
														
 
															-
														
 
															-		var r, index,
														
 
															-			result = [];
														
 
															-
														
 
															-		var stats = {};
														
 
															-
														
 
															-		for ( i = 0; i < n; i ++ ) {
														
 
															-
														
 
															-			r = THREE.Math.random16() * totalArea;
														
 
															-
														
 
															-			index = binarySearchIndices( r );
														
 
															-
														
 
															-			result[ i ] = THREE.GeometryUtils.randomPointInFace( faces[ index ], geometry, true );
														
 
															-
														
 
															-			if ( ! stats[ index ] ) {
														
 
															-
														
 
															-				stats[ index ] = 1;
														
 
															-
														
 
															-			} else {
														
 
															-
														
 
															-				stats[ index ] += 1;
														
 
															-
														
 
															-			}
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-		return result;
														
 
															-
														
 
															-	},
														
 
															-
														
 
															-	// Get triangle area (half of parallelogram)
														
 
															-	//	http://mathworld.wolfram.com/TriangleArea.html
														
 
															-
														
 
															-	triangleArea: function () {
														
 
															-
														
 
															-		var vector1 = new THREE.Vector3();
														
 
															-		var vector2 = new THREE.Vector3();
														
 
															-
														
 
															-		return function ( vectorA, vectorB, vectorC ) {
														
 
															-
														
 
															-			vector1.subVectors( vectorB, vectorA );
														
 
															-			vector2.subVectors( vectorC, vectorA );
														
 
															-			vector1.cross( vector2 );
														
 
															-
														
 
															-			return 0.5 * vector1.length();
														
 
															-
														
 
															-		};
														
 
															-
														
 
															-	}(),
														
 
															-
														
 
															-	// Center geometry so that 0,0,0 is in center of bounding box
														
 
															-
														
 
															 	center: function ( geometry ) {
														
 
															-		geometry.computeBoundingBox();
														
 
															-
														
 
															-		var bb = geometry.boundingBox;
														
 
															-
														
 
															-		var offset = new THREE.Vector3();
														
 
															-
														
 
															-		offset.addVectors( bb.min, bb.max );
														
 
															-		offset.multiplyScalar( -0.5 );
														
 
															-
														
 
															-		geometry.applyMatrix( new THREE.Matrix4().makeTranslation( offset.x, offset.y, offset.z ) );
														
 
															-		geometry.computeBoundingBox();
														
 
															-
														
 
															-		return offset;
														
 
															+		console.warn( 'THREE.GeometryUtils: .center() has been moved to Geometry. Use geometry.center() instead.' );
														
 
															+		return geometry.center();
														
 
															 	}
														
--- a/src/extras/ImageUtils.js
+++ b/src/extras/ImageUtils.js
@@ -13,8 +13,7 @@ THREE.ImageUtils = {
 
															 		var loader = new THREE.ImageLoader();
														
 
															 		loader.crossOrigin = this.crossOrigin;
														
 
															-		var texture = new THREE.Texture();
														
 
															-		texture.mapping = mapping;
														
 
															+		var texture = new THREE.Texture( undefined, mapping );
														
 
															 		loader.load( url, function ( image ) {
														
@@ -41,17 +40,17 @@ THREE.ImageUtils = {
 
															 		var loader = new THREE.ImageLoader();
														
 
															 		loader.crossOrigin = this.crossOrigin;
														
 
															-		
														
 
															+
														
 
															 		var texture = new THREE.CubeTexture( images, mapping );
														
 
															 		// no flipping needed for cube textures
														
 
															 		texture.flipY = false;
														
 
															-		
														
 
															+
														
 
															 		var loaded = 0;
														
 
															-		
														
 
															+
														
 
															 		var loadTexture = function ( i ) {
														
 
															-		
														
 
															+
														
 
															 			loader.load( array[ i ], function ( image ) {
														
 
															 				texture.images[ i ] = image;
														
@@ -79,17 +78,17 @@ THREE.ImageUtils = {
 
															 		return texture;
														
 
															 	},
														
 
															-	
														
 
															+
														
 
															 	loadCompressedTexture: function () {
														
 
															-	
														
 
															-		console.error( 'THREE.ImageUtils.loadCompressedTexture has been removed. Use THREE.DDSLoader instead.')
														
 
															-	
														
 
															+
														
 
															+		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.')
														
 
															-	
														
 
															+
														
 
															+		console.error( 'THREE.ImageUtils.loadCompressedTextureCube has been removed. Use THREE.DDSLoader instead.' )
														
 
															+
														
 
															 	},
														
 
															 	getNormalMap: function ( image, depth ) {
														
@@ -206,7 +205,7 @@ THREE.ImageUtils = {
 
															 		for ( var i = 0; i < size; i ++ ) {
														
 
															-			data[ i * 3 ] 	  = r;
														
 
															+			data[ i * 3 ] 	   = r;
														
 
															 			data[ i * 3 + 1 ] = g;
														
 
															 			data[ i * 3 + 2 ] = b;
														
--- a/src/extras/SceneUtils.js
+++ b/src/extras/SceneUtils.js
@@ -18,7 +18,7 @@ THREE.SceneUtils = {
 
															 	},
														
 
															-	detach : function ( child, parent, scene ) {
														
 
															+	detach: function ( child, parent, scene ) {
														
 
															 		child.applyMatrix( parent.matrixWorld );
														
 
															 		parent.remove( child );
														
--- a/src/extras/animation/Animation.js
+++ b/src/extras/animation/Animation.js
@@ -148,6 +148,7 @@ THREE.Animation.prototype.update = (function(){
 
															 	};
														
 
															 	return function ( delta ) {
														
 
															+
														
 
															 		if ( this.isPlaying === false ) return;
														
 
															 		this.currentTime += delta * this.timeScale;
														
@@ -157,7 +158,6 @@ THREE.Animation.prototype.update = (function(){
 
															 		//
														
 
															-		var vector;
														
 
															 		var duration = this.data.length;
														
 
															 		if ( this.loop === true && this.currentTime > duration ) {
														
@@ -219,8 +219,6 @@ THREE.Animation.prototype.update = (function(){
 
															 				if ( type === "pos" ) {
														
 
															-					vector = object.position;
														
 
															-
														
 
															 					if ( this.interpolationType === THREE.AnimationHandler.LINEAR ) {
														
 
															 						newVector.x = prevXYZ[ 0 ] + ( nextXYZ[ 0 ] - prevXYZ[ 0 ] ) * scale;
														
@@ -228,17 +226,20 @@ THREE.Animation.prototype.update = (function(){
 
															 						newVector.z = prevXYZ[ 2 ] + ( nextXYZ[ 2 ] - prevXYZ[ 2 ] ) * scale;
														
 
															 						// blend
														
 
															-						if (object instanceof THREE.Bone) {
														
 
															+						if ( object instanceof THREE.Bone ) {
														
 
															 							var proportionalWeight = this.weight / ( this.weight + object.accumulatedPosWeight );
														
 
															-							vector.lerp( newVector, proportionalWeight );
														
 
															+							object.position.lerp( newVector, proportionalWeight );
														
 
															 							object.accumulatedPosWeight += this.weight;
														
 
															-						} else
														
 
															-							vector.copy( newVector );
														
 
															+						} else {
														
 
															+
														
 
															+							object.position.copy( newVector );
														
 
															+
														
 
															+						}
														
 
															 					} else if ( this.interpolationType === THREE.AnimationHandler.CATMULLROM ||
														
 
															-						this.interpolationType === THREE.AnimationHandler.CATMULLROM_FORWARD ) {
														
 
															+								this.interpolationType === THREE.AnimationHandler.CATMULLROM_FORWARD ) {
														
 
															 						points[ 0 ] = this.getPrevKeyWith( "pos", h, prevKey.index - 1 )[ "pos" ];
														
 
															 						points[ 1 ] = prevXYZ;
														
@@ -248,17 +249,19 @@ THREE.Animation.prototype.update = (function(){
 
															 						scale = scale * 0.33 + 0.33;
														
 
															 						var currentPoint = interpolateCatmullRom( points, scale );
														
 
															-
														
 
															+						var proportionalWeight = 1;
														
 
															+						
														
 
															 						if ( object instanceof THREE.Bone ) {
														
 
															-							var proportionalWeight = this.weight / ( this.weight + object.accumulatedPosWeight );
														
 
															+							proportionalWeight = this.weight / ( this.weight + object.accumulatedPosWeight );
														
 
															 							object.accumulatedPosWeight += this.weight;
														
 
															 						}
														
 
															-						else
														
 
															-							var proportionalWeight = 1;
														
 
															 						// blend
														
 
															+
														
 
															+						var vector = object.position;
														
 
															+						
														
 
															 						vector.x = vector.x + ( currentPoint[ 0 ] - vector.x ) * proportionalWeight;
														
 
															 						vector.y = vector.y + ( currentPoint[ 1 ] - vector.y ) * proportionalWeight;
														
 
															 						vector.z = vector.z + ( currentPoint[ 2 ] - vector.z ) * proportionalWeight;
														
@@ -284,18 +287,16 @@ THREE.Animation.prototype.update = (function(){
 
															 					THREE.Quaternion.slerp( prevXYZ, nextXYZ, newQuat, scale );
														
 
															 					// Avoid paying the cost of an additional slerp if we don't have to
														
 
															-					if ( !( object instanceof THREE.Bone ) ) {
														
 
															+					if ( ! ( object instanceof THREE.Bone ) ) {
														
 
															 						object.quaternion.copy(newQuat);
														
 
															-					}
														
 
															-					else if ( object.accumulatedRotWeight === 0) {
														
 
															+					} else if ( object.accumulatedRotWeight === 0 ) {
														
 
															 						object.quaternion.copy(newQuat);
														
 
															 						object.accumulatedRotWeight = this.weight;
														
 
															-					}
														
 
															-					else {
														
 
															+					} else {
														
 
															 						var proportionalWeight = this.weight / ( this.weight + object.accumulatedRotWeight );
														
 
															 						THREE.Quaternion.slerp( object.quaternion, newQuat, object.quaternion, proportionalWeight );
														
@@ -305,8 +306,6 @@ THREE.Animation.prototype.update = (function(){
 
															 				} else if ( type === "scl" ) {
														
 
															-					vector = object.scale;
														
 
															-
														
 
															 					newVector.x = prevXYZ[ 0 ] + ( nextXYZ[ 0 ] - prevXYZ[ 0 ] ) * scale;
														
 
															 					newVector.y = prevXYZ[ 1 ] + ( nextXYZ[ 1 ] - prevXYZ[ 1 ] ) * scale;
														
 
															 					newVector.z = prevXYZ[ 2 ] + ( nextXYZ[ 2 ] - prevXYZ[ 2 ] ) * scale;
														
@@ -314,11 +313,14 @@ THREE.Animation.prototype.update = (function(){
 
															 					if ( object instanceof THREE.Bone ) {
														
 
															 						var proportionalWeight = this.weight / ( this.weight + object.accumulatedSclWeight);
														
 
															-						vector.lerp( newVector, proportionalWeight );
														
 
															+						object.scale.lerp( newVector, proportionalWeight );
														
 
															 						object.accumulatedSclWeight += this.weight;
														
 
															-					} else
														
 
															-						vector.copy( newVector );
														
 
															+					} else {
														
 
															+
														
 
															+						object.scale.copy( newVector );
														
 
															+
														
 
															+					}
														
 
															 				}
														
@@ -353,7 +355,7 @@ THREE.Animation.prototype.getNextKeyWith = function ( type, h, key ) {
 
															 	}
														
 
															-	for ( ; key < keys.length; key++ ) {
														
 
															+	for ( ; key < keys.length; key ++ ) {
														
 
															 		if ( keys[ key ][ type ] !== undefined ) {
														
--- a/src/extras/animation/AnimationHandler.js
+++ b/src/extras/animation/AnimationHandler.js
@@ -39,7 +39,7 @@ THREE.AnimationHandler = {
 
															 				// create quaternions
														
 
															 				if ( data.hierarchy[ h ].keys[ k ].rot !== undefined &&
														
 
															-				  !( data.hierarchy[ h ].keys[ k ].rot instanceof THREE.Quaternion ) ) {
														
 
															+				  ! ( data.hierarchy[ h ].keys[ k ].rot instanceof THREE.Quaternion ) ) {
														
 
															 					var quat = data.hierarchy[ h ].keys[ k ].rot;
														
 
															 					data.hierarchy[ h ].keys[ k ].rot = new THREE.Quaternion().fromArray( quat );
														
@@ -61,7 +61,7 @@ THREE.AnimationHandler = {
 
															 					for ( var m = 0; m < data.hierarchy[ h ].keys[ k ].morphTargets.length; m ++ ) {
														
 
															 						var morphTargetName = data.hierarchy[ h ].keys[ k ].morphTargets[ m ];
														
 
															-						usedMorphTargets[ morphTargetName ] = -1;
														
 
															+						usedMorphTargets[ morphTargetName ] = - 1;
														
 
															 					}
														
@@ -140,7 +140,7 @@ THREE.AnimationHandler = {
 
															 			hierarchy.push( root );
														
 
															-			for ( var c = 0; c < root.children.length; c++ )
														
 
															+			for ( var c = 0; c < root.children.length; c ++ )
														
 
															 				parseRecurseHierarchy( root.children[ c ], hierarchy );
														
 
															 		};
														
@@ -151,7 +151,7 @@ THREE.AnimationHandler = {
 
															 		if ( root instanceof THREE.SkinnedMesh ) {
														
 
															-			for ( var b = 0; b < root.skeleton.bones.length; b++ ) {
														
 
															+			for ( var b = 0; b < root.skeleton.bones.length; b ++ ) {
														
 
															 				hierarchy.push( root.skeleton.bones[ b ] );
														
@@ -169,7 +169,7 @@ THREE.AnimationHandler = {
 
															 	play: function ( animation ) {
														
 
															-		if ( this.animations.indexOf( animation ) === -1 ) {
														
 
															+		if ( this.animations.indexOf( animation ) === - 1 ) {
														
 
															 			this.animations.push( animation );
														
@@ -181,7 +181,7 @@ THREE.AnimationHandler = {
 
															 		var index = this.animations.indexOf( animation );
														
 
															-		if ( index !== -1 ) {
														
 
															+		if ( index !== - 1 ) {
														
 
															 			this.animations.splice( index, 1 );
														
--- a/src/extras/animation/KeyFrameAnimation.js
+++ b/src/extras/animation/KeyFrameAnimation.js
@@ -27,7 +27,7 @@ THREE.KeyFrameAnimation = function ( data ) {
 
															 		if ( keys.length && sids ) {
														
 
															-			for ( var s = 0; s < sids.length; s++ ) {
														
 
															+			for ( var s = 0; s < sids.length; s ++ ) {
														
 
															 				var sid = sids[ s ],
														
 
															 					next = this.getNextKeyWith( sid, h, 0 );
														
@@ -65,7 +65,7 @@ THREE.KeyFrameAnimation.prototype.play = function ( startTime ) {
 
															 			object,
														
 
															 			node;
														
 
															-		for ( h = 0; h < hl; h++ ) {
														
 
															+		for ( h = 0; h < hl; h ++ ) {
														
 
															 			object = this.hierarchy[ h ];
														
 
															 			node = this.data.hierarchy[ h ];
														
@@ -113,7 +113,7 @@ THREE.KeyFrameAnimation.prototype.stop = function() {
 
															 	// reset JIT matrix and remove cache
														
 
															-	for ( var h = 0; h < this.data.hierarchy.length; h++ ) {
														
 
															+	for ( var h = 0; h < this.data.hierarchy.length; h ++ ) {
														
 
															 		var obj = this.hierarchy[ h ];
														
 
															 		var node = this.data.hierarchy[ h ];
														
@@ -154,7 +154,7 @@ THREE.KeyFrameAnimation.prototype.update = function ( delta ) {
 
															 	this.currentTime = Math.min( this.currentTime, duration );
														
 
															-	for ( var h = 0, hl = this.hierarchy.length; h < hl; h++ ) {
														
 
															+	for ( var h = 0, hl = this.hierarchy.length; h < hl; h ++ ) {
														
 
															 		var object = this.hierarchy[ h ];
														
 
															 		var node = this.data.hierarchy[ h ];
														
@@ -208,7 +208,7 @@ THREE.KeyFrameAnimation.prototype.getNextKeyWith = function( sid, h, key ) {
 
															 	var keys = this.data.hierarchy[ h ].keys;
														
 
															 	key = key % keys.length;
														
 
															-	for ( ; key < keys.length; key++ ) {
														
 
															+	for ( ; key < keys.length; key ++ ) {
														
 
															 		if ( keys[ key ].hasTarget( sid ) ) {
														
@@ -229,7 +229,7 @@ THREE.KeyFrameAnimation.prototype.getPrevKeyWith = function( sid, h, key ) {
 
															 	var keys = this.data.hierarchy[ h ].keys;
														
 
															 	key = key >= 0 ? key : key + keys.length;
														
 
															-	for ( ; key >= 0; key-- ) {
														
 
															+	for ( ; key >= 0; key -- ) {
														
 
															 		if ( keys[ key ].hasTarget( sid ) ) {
														
--- a/src/extras/core/Curve.js
+++ b/src/extras/core/Curve.js
@@ -62,7 +62,7 @@ THREE.Curve.prototype.getPointAt = function ( u ) {
 
															 THREE.Curve.prototype.getPoints = function ( divisions ) {
														
 
															-	if ( !divisions ) divisions = 5;
														
 
															+	if ( ! divisions ) divisions = 5;
														
 
															 	var d, pts = [];
														
@@ -80,7 +80,7 @@ THREE.Curve.prototype.getPoints = function ( divisions ) {
 
															 THREE.Curve.prototype.getSpacedPoints = function ( divisions ) {
														
 
															-	if ( !divisions ) divisions = 5;
														
 
															+	if ( ! divisions ) divisions = 5;
														
 
															 	var d, pts = [];
														
@@ -107,11 +107,11 @@ THREE.Curve.prototype.getLength = function () {
 
															 THREE.Curve.prototype.getLengths = function ( divisions ) {
														
 
															-	if ( !divisions ) divisions = (this.__arcLengthDivisions) ? (this.__arcLengthDivisions): 200;
														
 
															+	if ( ! divisions ) divisions = (this.__arcLengthDivisions) ? (this.__arcLengthDivisions): 200;
														
 
															 	if ( this.cacheArcLengths
														
 
															 		&& ( this.cacheArcLengths.length == divisions + 1 )
														
 
															-		&& !this.needsUpdate) {
														
 
															+		&& ! this.needsUpdate) {
														
 
															 		//console.log( "cached", this.cacheArcLengths );
														
 
															 		return this.cacheArcLengths;
														
@@ -282,7 +282,7 @@ THREE.Curve.Utils = {
 
															 	tangentCubicBezier: function (t, p0, p1, p2, p3 ) {
														
 
															-		return -3 * p0 * (1 - t) * (1 - t)  +
														
 
															+		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;
														
@@ -295,7 +295,7 @@ THREE.Curve.Utils = {
 
															 		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 h01 = - 6 * t * t + 6 * t; 	// − 2t3 + 3t2
														
 
															 		var h11 = 3 * t * t - 2 * t;	// t3 − t2
														
 
															 		return h00 + h10 + h01 + h11;
														
--- a/src/extras/core/CurvePath.js
+++ b/src/extras/core/CurvePath.js
@@ -37,7 +37,7 @@ THREE.CurvePath.prototype.closePath = function() {
 
															 	var startPoint = this.curves[0].getPoint(0);
														
 
															 	var endPoint = this.curves[this.curves.length-1].getPoint(1);
														
 
															-	if (!startPoint.equals(endPoint)) {
														
 
															+	if (! startPoint.equals(endPoint)) {
														
 
															 		this.curves.push( new THREE.LineCurve(endPoint, startPoint) );
														
 
															 	}
														
@@ -247,7 +247,7 @@ THREE.CurvePath.prototype.getTransformedPoints = function( segments, bends ) {
 
															 	var oldPts = this.getPoints( segments ); // getPoints getSpacedPoints
														
 
															 	var i, il;
														
 
															-	if ( !bends ) {
														
 
															+	if ( ! bends ) {
														
 
															 		bends = this.bends;
														
@@ -269,7 +269,7 @@ THREE.CurvePath.prototype.getTransformedSpacedPoints = function( segments, bends
 
															 	var i, il;
														
 
															-	if ( !bends ) {
														
 
															+	if ( ! bends ) {
														
 
															 		bends = this.bends;
														
@@ -312,7 +312,7 @@ THREE.CurvePath.prototype.getWrapPoints = function ( oldPts, path ) {
 
															 		var pathPt = path.getPoint( xNorm );
														
 
															 		var normal = path.getTangent( xNorm );
														
 
															-		normal.set( -normal.y, normal.x ).multiplyScalar( oldY );
														
 
															+		normal.set( - normal.y, normal.x ).multiplyScalar( oldY );
														
 
															 		p.x = pathPt.x + normal.x;
														
 
															 		p.y = pathPt.y + normal.y;
														
--- a/src/extras/core/Path.js
+++ b/src/extras/core/Path.js
@@ -345,7 +345,7 @@ THREE.Path.prototype.getPoints = function( divisions, closedPath ) {
 
															 			var aX = args[ 0 ], aY = args[ 1 ],
														
 
															 				aRadius = args[ 2 ],
														
 
															 				aStartAngle = args[ 3 ], aEndAngle = args[ 4 ],
														
 
															-				aClockwise = !!args[ 5 ];
														
 
															+				aClockwise = !! args[ 5 ];
														
 
															 			var deltaAngle = aEndAngle - aStartAngle;
														
 
															 			var angle;
														
@@ -382,7 +382,7 @@ THREE.Path.prototype.getPoints = function( divisions, closedPath ) {
 
															 				xRadius = args[ 2 ],
														
 
															 				yRadius = args[ 3 ],
														
 
															 				aStartAngle = args[ 4 ], aEndAngle = args[ 5 ],
														
 
															-				aClockwise = !!args[ 6 ];
														
 
															+				aClockwise = !! args[ 6 ];
														
 
															 			var deltaAngle = aEndAngle - aStartAngle;
														
@@ -519,7 +519,7 @@ THREE.Path.prototype.toShapes = function( isCCW, noHoles ) {
 
															 		//  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++ ) {
														
 
															+		for( var p = polyLen - 1, q = 0; q < polyLen; p = q ++ ) {
														
 
															 			var edgeLowPt  = inPolygon[ p ];
														
 
															 			var edgeHighPt = inPolygon[ q ];
														
@@ -528,8 +528,8 @@ THREE.Path.prototype.toShapes = function( isCCW, noHoles ) {
 
															 			if ( Math.abs(edgeDy) > EPSILON ) {			// not parallel
														
 
															 				if ( edgeDy < 0 ) {
														
 
															-					edgeLowPt  = inPolygon[ q ]; edgeDx = -edgeDx;
														
 
															-					edgeHighPt = inPolygon[ p ]; edgeDy = -edgeDy;
														
 
															+					edgeLowPt  = inPolygon[ q ]; edgeDx = - edgeDx;
														
 
															+					edgeHighPt = inPolygon[ p ]; edgeDy = - edgeDy;
														
 
															 				}
														
 
															 				if ( ( inPt.y < edgeLowPt.y ) || ( inPt.y > edgeHighPt.y ) ) 		continue;
														
@@ -540,7 +540,7 @@ THREE.Path.prototype.toShapes = function( isCCW, noHoles ) {
 
															 					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
														
 
															+					inside = ! inside;		// true intersection left of inPt
														
 
															 				}
														
 
															 			} else {		// parallel or colinear
														
 
															 				if ( inPt.y != edgeLowPt.y ) 		continue;			// parallel
														
@@ -574,8 +574,8 @@ THREE.Path.prototype.toShapes = function( isCCW, noHoles ) {
 
															 	}
														
 
															-	var holesFirst = !THREE.Shape.Utils.isClockWise( subPaths[ 0 ].getPoints() );
														
 
															-	holesFirst = isCCW ? !holesFirst : holesFirst;
														
 
															+	var holesFirst = ! THREE.Shape.Utils.isClockWise( subPaths[ 0 ].getPoints() );
														
 
															+	holesFirst = isCCW ? ! holesFirst : holesFirst;
														
 
															 	// console.log("Holes first", holesFirst);
														
@@ -595,17 +595,17 @@ THREE.Path.prototype.toShapes = function( isCCW, noHoles ) {
 
															 		tmpPath = subPaths[ i ];
														
 
															 		tmpPoints = tmpPath.getPoints();
														
 
															 		solid = THREE.Shape.Utils.isClockWise( tmpPoints );
														
 
															-		solid = isCCW ? !solid : solid;
														
 
															+		solid = isCCW ? ! solid : solid;
														
 
															 		if ( solid ) {
														
 
															-			if ( (! holesFirst ) && ( newShapes[mainIdx] ) )	mainIdx++;
														
 
															+			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++;
														
 
															+			if ( holesFirst )	mainIdx ++;
														
 
															 			newShapeHoles[mainIdx] = [];
														
 
															 			//console.log('cw', i);
														
@@ -621,23 +621,23 @@ THREE.Path.prototype.toShapes = function( isCCW, noHoles ) {
 
															 	}
														
 
															 	// only Holes? -> probably all Shapes with wrong orientation
														
 
															-	if ( !newShapes[0] )	return	toShapesNoHoles( subPaths );
														
 
															+	if ( ! newShapes[0] )	return	toShapesNoHoles( subPaths );
														
 
															 	if ( newShapes.length > 1 ) {
														
 
															 		var ambigious = false;
														
 
															 		var toChange = [];
														
 
															-		for (var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx++ ) {
														
 
															+		for (var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {
														
 
															 			betterShapeHoles[sIdx] = [];
														
 
															 		}
														
 
															-		for (var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx++ ) {
														
 
															+		for (var sIdx = 0, sLen = newShapes.length; sIdx < sLen; sIdx ++ ) {
														
 
															 			var sh = newShapes[sIdx];
														
 
															 			var sho = newShapeHoles[sIdx];
														
 
															-			for (var hIdx = 0; hIdx < sho.length; hIdx++ ) {
														
 
															+			for (var hIdx = 0; hIdx < sho.length; hIdx ++ ) {
														
 
															 				var ho = sho[hIdx];
														
 
															 				var hole_unassigned = true;
														
 
															-				for (var s2Idx = 0; s2Idx < newShapes.length; s2Idx++ ) {
														
 
															+				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 ) {
														
--- a/src/extras/core/Shape.js
+++ b/src/extras/core/Shape.js
@@ -339,7 +339,7 @@ THREE.Shape.Utils = {
 
															 			function intersectsShapeEdge( inShapePt, inHolePt ) {
														
 
															 				// checks for intersections with shape edges
														
 
															 				var sIdx, nextIdx, intersection;
														
 
															-				for ( sIdx = 0; sIdx < shape.length; sIdx++ ) {
														
 
															+				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;
														
@@ -354,9 +354,9 @@ THREE.Shape.Utils = {
 
															 				// checks for intersections with hole edges
														
 
															 				var ihIdx, chkHole,
														
 
															 					hIdx, nextIdx, intersection;
														
 
															-				for ( ihIdx = 0; ihIdx < indepHoles.length; ihIdx++ ) {
														
 
															+				for ( ihIdx = 0; ihIdx < indepHoles.length; ihIdx ++ ) {
														
 
															 					chkHole = holes[indepHoles[ihIdx]];
														
 
															-					for ( hIdx = 0; hIdx < chkHole.length; hIdx++ ) {
														
 
															+					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;
														
@@ -388,10 +388,10 @@ THREE.Shape.Utils = {
 
															 				// search for shape-vertex and hole-vertex,
														
 
															 				// which can be connected without intersections
														
 
															-				for ( shapeIndex = minShapeIndex; shapeIndex < shape.length; shapeIndex++ ) {
														
 
															+				for ( shapeIndex = minShapeIndex; shapeIndex < shape.length; shapeIndex ++ ) {
														
 
															 					shapePt = shape[ shapeIndex ];
														
 
															-					holeIndex	= -1;
														
 
															+					holeIndex	= - 1;
														
 
															 					// search for hole which can be reached without intersections
														
 
															 					for ( var h = 0; h < indepHoles.length; h ++ ) {
														
--- a/src/extras/curves/ArcCurve.js
+++ b/src/extras/curves/ArcCurve.js
@@ -7,4 +7,4 @@ 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 = Object.create( THREE.EllipseCurve.prototype );
														
--- a/src/extras/curves/ClosedSplineCurve3.js
+++ b/src/extras/curves/ClosedSplineCurve3.js
@@ -36,4 +36,4 @@ THREE.ClosedSplineCurve3 = THREE.Curve.create(
 
															     }
														
 
															-);
														
 
															+);
														
--- a/src/extras/curves/CubicBezierCurve.js
+++ b/src/extras/curves/CubicBezierCurve.js
@@ -36,4 +36,4 @@ THREE.CubicBezierCurve.prototype.getTangent = function( t ) {
 
															 	return tangent;
														
 
															-};
														
 
															+};
														
--- a/src/extras/curves/CubicBezierCurve3.js
+++ b/src/extras/curves/CubicBezierCurve3.js
@@ -25,4 +25,4 @@ THREE.CubicBezierCurve3 = THREE.Curve.create(
 
															 	}
														
 
															-);
														
 
															+);
														
--- a/src/extras/curves/LineCurve.js
+++ b/src/extras/curves/LineCurve.js
@@ -34,4 +34,4 @@ THREE.LineCurve.prototype.getTangent = function( t ) {
 
															 	return tangent.normalize();
														
 
															-};
														
 
															+};
														
--- a/src/extras/curves/QuadraticBezierCurve.js
+++ b/src/extras/curves/QuadraticBezierCurve.js
@@ -40,4 +40,4 @@ THREE.QuadraticBezierCurve.prototype.getTangent = function( t ) {
 
															 	return tangent;
														
 
															-};
														
 
															+};
														
--- a/src/extras/curves/QuadraticBezierCurve3.js
+++ b/src/extras/curves/QuadraticBezierCurve3.js
@@ -24,4 +24,4 @@ THREE.QuadraticBezierCurve3 = THREE.Curve.create(
 
															 	}
														
 
															-);
														
 
															+);
														
--- a/src/extras/curves/SplineCurve.js
+++ b/src/extras/curves/SplineCurve.js
@@ -30,4 +30,4 @@ THREE.SplineCurve.prototype.getPoint = function ( t ) {
 
															 	return v;
														
 
															-};
														
 
															+};
														
--- a/src/extras/curves/SplineCurve3.js
+++ b/src/extras/curves/SplineCurve3.js
@@ -68,4 +68,4 @@ THREE.SplineCurve3 = THREE.Curve.create(
 
															 // 	return v;
														
 
															-// }
														
 
															+// }
														
--- a/src/extras/geometries/BoxGeometry.js
+++ b/src/extras/geometries/BoxGeometry.js
@@ -81,9 +81,9 @@ THREE.BoxGeometry = function ( width, height, depth, widthSegments, heightSegmen
 
															 		}
														
 
															-		for ( iy = 0; iy < gridY; iy++ ) {
														
 
															+		for ( iy = 0; iy < gridY; iy ++ ) {
														
 
															-			for ( ix = 0; ix < gridX; ix++ ) {
														
 
															+			for ( ix = 0; ix < gridX; ix ++ ) {
														
 
															 				var a = ix + gridX1 * iy;
														
 
															 				var b = ix + gridX1 * ( iy + 1 );
														
--- a/src/extras/geometries/ExtrudeGeometry.js
+++ b/src/extras/geometries/ExtrudeGeometry.js
@@ -136,7 +136,7 @@ THREE.ExtrudeGeometry.prototype.addShape = function ( shape, options ) {
 
															 	var vertices = shapePoints.shape;
														
 
															 	var holes = shapePoints.holes;
														
 
															-	var reverse = !THREE.Shape.Utils.isClockWise( vertices ) ;
														
 
															+	var reverse = ! THREE.Shape.Utils.isClockWise( vertices ) ;
														
 
															 	if ( reverse ) {
														
@@ -178,7 +178,7 @@ THREE.ExtrudeGeometry.prototype.addShape = function ( shape, options ) {
 
															 	function scalePt2 ( pt, vec, size ) {
														
 
															-		if ( !vec ) console.log( "die" );
														
 
															+		if ( ! vec ) console.log( "die" );
														
 
															 		return vec.clone().multiplyScalar( size ).add( pt );
														
@@ -261,8 +261,8 @@ THREE.ExtrudeGeometry.prototype.addShape = function ( shape, options ) {
 
															 			if ( v_prev_x > EPSILON ) {
														
 
															 				if ( v_next_x > EPSILON ) { direction_eq = true; }
														
 
															 			} else {
														
 
															-				if ( v_prev_x < -EPSILON ) {
														
 
															-					if ( v_next_x < -EPSILON ) { direction_eq = true; }
														
 
															+				if ( v_prev_x < - EPSILON ) {
														
 
															+					if ( v_next_x < - EPSILON ) { direction_eq = true; }
														
 
															 				} else {
														
 
															 					if ( sign(v_prev_y) == sign(v_next_y) ) { direction_eq = true; }
														
 
															 				}
														
@@ -270,7 +270,7 @@ THREE.ExtrudeGeometry.prototype.addShape = function ( shape, options ) {
 
															 			if ( direction_eq ) {
														
 
															 				// console.log("Warning: lines are a straight sequence");
														
 
															-				v_trans_x = -v_prev_y;
														
 
															+				v_trans_x = - v_prev_y;
														
 
															 				v_trans_y =  v_prev_x;
														
 
															 				shrink_by = Math.sqrt( v_prev_lensq );
														
 
															 			} else {
														
@@ -353,16 +353,16 @@ THREE.ExtrudeGeometry.prototype.addShape = function ( shape, options ) {
 
															 		// expand holes
														
 
															-		for ( h = 0, hl = holes.length; h < hl; h++ ) {
														
 
															+		for ( h = 0, hl = holes.length; h < hl; h ++ ) {
														
 
															 			ahole = holes[ h ];
														
 
															 			oneHoleMovements = holesMovements[ h ];
														
 
															-			for ( i = 0, il = ahole.length; i < il; i++ ) {
														
 
															+			for ( i = 0, il = ahole.length; i < il; i ++ ) {
														
 
															 				vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );
														
 
															-				v( vert.x, vert.y,  -z );
														
 
															+				v( vert.x, vert.y,  - z );
														
 
															 			}
														
@@ -378,7 +378,7 @@ THREE.ExtrudeGeometry.prototype.addShape = function ( shape, options ) {
 
															 		vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];
														
 
															-		if ( !extrudeByPath ) {
														
 
															+		if ( ! extrudeByPath ) {
														
 
															 			v( vert.x, vert.y, 0 );
														
@@ -408,7 +408,7 @@ THREE.ExtrudeGeometry.prototype.addShape = function ( shape, options ) {
 
															 			vert = bevelEnabled ? scalePt2( vertices[ i ], verticesMovements[ i ], bs ) : vertices[ i ];
														
 
															-			if ( !extrudeByPath ) {
														
 
															+			if ( ! extrudeByPath ) {
														
 
															 				v( vert.x, vert.y, amount / steps * s );
														
@@ -460,7 +460,7 @@ THREE.ExtrudeGeometry.prototype.addShape = function ( shape, options ) {
 
															 				vert = scalePt2( ahole[ i ], oneHoleMovements[ i ], bs );
														
 
															-				if ( !extrudeByPath ) {
														
 
															+				if ( ! extrudeByPath ) {
														
 
															 					v( vert.x, vert.y,  amount + z );
														
@@ -521,7 +521,7 @@ THREE.ExtrudeGeometry.prototype.addShape = function ( shape, options ) {
 
															 			// Bottom faces
														
 
															-			for ( i = 0; i < flen; i++ ) {
														
 
															+			for ( i = 0; i < flen; i ++ ) {
														
 
															 				face = faces[ i ];
														
 
															 				f3( face[ 2 ], face[ 1 ], face[ 0 ], true );
														
--- a/src/extras/geometries/IcosahedronGeometry.js
+++ b/src/extras/geometries/IcosahedronGeometry.js
@@ -12,9 +12,9 @@ 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
														
 
															+		- 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 = [
														
--- a/src/extras/geometries/OctahedronGeometry.js
+++ b/src/extras/geometries/OctahedronGeometry.js
@@ -10,7 +10,7 @@ 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
														
 
															+		1, 0, 0,   - 1, 0, 0,    0, 1, 0,    0,- 1, 0,    0, 0, 1,    0, 0,- 1
														
 
															 	];
														
 
															 	var indices = [
														
--- a/src/extras/geometries/PolyhedronGeometry.js
+++ b/src/extras/geometries/PolyhedronGeometry.js
@@ -196,7 +196,7 @@ THREE.PolyhedronGeometry = function ( vertices, indices, radius, detail ) {
 
															 	function azimuth( vector ) {
														
 
															-		return Math.atan2( vector.z, -vector.x );
														
 
															+		return Math.atan2( vector.z, - vector.x );
														
 
															 	}
														
@@ -205,7 +205,7 @@ THREE.PolyhedronGeometry = function ( vertices, indices, radius, detail ) {
 
															 	function inclination( vector ) {
														
 
															-		return Math.atan2( -vector.y, Math.sqrt( ( vector.x * vector.x ) + ( vector.z * vector.z ) ) );
														
 
															+		return Math.atan2( - vector.y, Math.sqrt( ( vector.x * vector.x ) + ( vector.z * vector.z ) ) );
														
 
															 	}
														
--- a/src/extras/geometries/RingGeometry.js
+++ b/src/extras/geometries/RingGeometry.js
@@ -13,17 +13,16 @@ THREE.RingGeometry = function ( innerRadius, outerRadius, thetaSegments, phiSegm
 
															 	thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;
														
 
															 	thetaSegments = thetaSegments !== undefined ? Math.max( 3, thetaSegments ) : 8;
														
 
															-	phiSegments = phiSegments !== undefined ? Math.max( 3, phiSegments ) : 8;
														
 
															+	phiSegments = phiSegments !== undefined ? Math.max( 1, phiSegments ) : 8;
														
 
															 	var i, o, uvs = [], radius = innerRadius, radiusStep = ( ( outerRadius - innerRadius ) / phiSegments );
														
 
															-	for ( i = 0; i <= phiSegments; i ++ ) { // concentric circles inside ring
														
 
															+	for ( i = 0; i < phiSegments + 1; i ++ ) { // concentric circles inside ring
														
 
															-		for ( o = 0; o <= thetaSegments; o ++ ) { // number of segments per circle
														
 
															+		for ( o = 0; o < thetaSegments + 1; o ++ ) { // number of segments per circle
														
 
															 			var vertex = new THREE.Vector3();
														
 
															 			var segment = thetaStart + o / thetaSegments * thetaLength;
														
 
															-
														
 
															 			vertex.x = radius * Math.cos( segment );
														
 
															 			vertex.y = radius * Math.sin( segment );
														
@@ -39,22 +38,22 @@ THREE.RingGeometry = function ( innerRadius, outerRadius, thetaSegments, phiSegm
 
															 	for ( i = 0; i < phiSegments; i ++ ) { // concentric circles inside ring
														
 
															-		var thetaSegment = i * thetaSegments;
														
 
															+		var thetaSegment = i * (thetaSegments + 1);
														
 
															-		for ( o = 0; o <= thetaSegments; o ++ ) { // number of segments per circle
														
 
															+		for ( o = 0; o < thetaSegments ; o ++ ) { // number of segments per circle
														
 
															 			var segment = o + thetaSegment;
														
 
															-			var v1 = segment + i;
														
 
															-			var v2 = segment + thetaSegments + i;
														
 
															-			var v3 = segment + thetaSegments + 1 + i;
														
 
															+			var v1 = segment;
														
 
															+			var v2 = segment + thetaSegments + 1;
														
 
															+			var v3 = segment + thetaSegments + 2;
														
 
															 			this.faces.push( new THREE.Face3( v1, v2, v3, [ n.clone(), n.clone(), n.clone() ] ) );
														
 
															 			this.faceVertexUvs[ 0 ].push( [ uvs[ v1 ].clone(), uvs[ v2 ].clone(), uvs[ v3 ].clone() ]);
														
 
															-			v1 = segment + i;
														
 
															-			v2 = segment + thetaSegments + 1 + i;
														
 
															-			v3 = segment + 1 + i;
														
 
															+			v1 = segment;
														
 
															+			v2 = segment + thetaSegments + 2;
														
 
															+			v3 = segment + 1;
														
 
															 			this.faces.push( new THREE.Face3( v1, v2, v3, [ n.clone(), n.clone(), n.clone() ] ) );
														
 
															 			this.faceVertexUvs[ 0 ].push( [ uvs[ v1 ].clone(), uvs[ v2 ].clone(), uvs[ v3 ].clone() ]);
														
@@ -69,3 +68,4 @@ THREE.RingGeometry = function ( innerRadius, outerRadius, thetaSegments, phiSegm
 
															 };
														
 
															 THREE.RingGeometry.prototype = Object.create( THREE.Geometry.prototype );
														
 
															+
														
--- a/src/extras/geometries/ShapeGeometry.js
+++ b/src/extras/geometries/ShapeGeometry.js
@@ -35,7 +35,7 @@ THREE.ShapeGeometry.prototype = Object.create( THREE.Geometry.prototype );
 
															  */
														
 
															 THREE.ShapeGeometry.prototype.addShapeList = function ( shapes, options ) {
														
 
															-	for ( var i = 0, l = shapes.length; i < l; i++ ) {
														
 
															+	for ( var i = 0, l = shapes.length; i < l; i ++ ) {
														
 
															 		this.addShape( shapes[ i ], options );
														
@@ -68,7 +68,7 @@ THREE.ShapeGeometry.prototype.addShape = function ( shape, options ) {
 
															 	var vertices = shapePoints.shape;
														
 
															 	var holes = shapePoints.holes;
														
 
															-	var reverse = !THREE.Shape.Utils.isClockWise( vertices );
														
 
															+	var reverse = ! THREE.Shape.Utils.isClockWise( vertices );
														
 
															 	if ( reverse ) {
														
@@ -76,7 +76,7 @@ THREE.ShapeGeometry.prototype.addShape = function ( shape, options ) {
 
															 		// 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++ ) {
														
 
															+		for ( i = 0, l = holes.length; i < l; i ++ ) {
														
 
															 			hole = holes[ i ];
														
@@ -98,7 +98,7 @@ THREE.ShapeGeometry.prototype.addShape = function ( shape, options ) {
 
															 	var contour = vertices;
														
 
															-	for ( i = 0, l = holes.length; i < l; i++ ) {
														
 
															+	for ( i = 0, l = holes.length; i < l; i ++ ) {
														
 
															 		hole = holes[ i ];
														
 
															 		vertices = vertices.concat( hole );
														
@@ -111,7 +111,7 @@ THREE.ShapeGeometry.prototype.addShape = function ( shape, options ) {
 
															 	var face, flen = faces.length;
														
 
															 	var cont, clen = contour.length;
														
 
															-	for ( i = 0; i < vlen; i++ ) {
														
 
															+	for ( i = 0; i < vlen; i ++ ) {
														
 
															 		vert = vertices[ i ];
														
@@ -119,7 +119,7 @@ THREE.ShapeGeometry.prototype.addShape = function ( shape, options ) {
 
															 	}
														
 
															-	for ( i = 0; i < flen; i++ ) {
														
 
															+	for ( i = 0; i < flen; i ++ ) {
														
 
															 		face = faces[ i ];
														
--- a/src/extras/geometries/TetrahedronGeometry.js
+++ b/src/extras/geometries/TetrahedronGeometry.js
@@ -5,7 +5,7 @@
 
															 THREE.TetrahedronGeometry = function ( radius, detail ) {
														
 
															 	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
														
 
															 	];
														
 
															 	var indices = [
														
--- a/src/extras/geometries/TubeGeometry.js
+++ b/src/extras/geometries/TubeGeometry.js
@@ -67,7 +67,7 @@ THREE.TubeGeometry = function ( path, segments, radius, radialSegments, closed )
 
															 	// consruct the grid
														
 
															-	for ( i = 0; i < numpoints; i++ ) {
														
 
															+	for ( i = 0; i < numpoints; i ++ ) {
														
 
															 		grid[ i ] = [];
														
@@ -79,11 +79,11 @@ THREE.TubeGeometry = function ( path, segments, radius, radialSegments, closed )
 
															 		normal = normals[ i ];
														
 
															 		binormal = binormals[ i ];
														
 
															-		for ( j = 0; j < radialSegments; j++ ) {
														
 
															+		for ( j = 0; j < radialSegments; j ++ ) {
														
 
															 			v = j / radialSegments * 2 * Math.PI;
														
 
															-			cx = -radius * Math.cos( v ); // TODO: Hack: Negating it so it faces outside.
														
 
															+			cx = - radius * Math.cos( v ); // TODO: Hack: Negating it so it faces outside.
														
 
															 			cy = radius * Math.sin( v );
														
 
															 			pos2.copy( pos );
														
@@ -99,9 +99,9 @@ THREE.TubeGeometry = function ( path, segments, radius, radialSegments, closed )
 
															 	// construct the mesh
														
 
															-	for ( i = 0; i < segments; i++ ) {
														
 
															+	for ( i = 0; i < segments; i ++ ) {
														
 
															-		for ( j = 0; j < radialSegments; j++ ) {
														
 
															+		for ( j = 0; j < radialSegments; j ++ ) {
														
 
															 			ip = ( closed ) ? (i + 1) % segments : i + 1;
														
 
															 			jp = (j + 1) % radialSegments;
														
@@ -163,7 +163,7 @@ THREE.TubeGeometry.FrenetFrames = function ( path, segments, closed ) {
 
															 	// compute the tangent vectors for each segment on the path
														
 
															-	for ( i = 0; i < numpoints; i++ ) {
														
 
															+	for ( i = 0; i < numpoints; i ++ ) {
														
 
															 		u = i / ( numpoints - 1 );
														
@@ -230,7 +230,7 @@ THREE.TubeGeometry.FrenetFrames = function ( path, segments, closed ) {
 
															 	// compute the slowly-varying normal and binormal vectors for each segment on the path
														
 
															-	for ( i = 1; i < numpoints; i++ ) {
														
 
															+	for ( i = 1; i < numpoints; i ++ ) {
														
 
															 		normals[ i ] = normals[ i-1 ].clone();
														
@@ -242,7 +242,7 @@ THREE.TubeGeometry.FrenetFrames = function ( path, segments, closed ) {
 
															 			vec.normalize();
														
 
															-			theta = Math.acos( THREE.Math.clamp( tangents[ i-1 ].dot( tangents[ i ] ), -1, 1 ) ); // clamp for floating pt errors
														
 
															+			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 ) );
														
@@ -257,16 +257,16 @@ THREE.TubeGeometry.FrenetFrames = function ( path, segments, closed ) {
 
															 	if ( closed ) {
														
 
															-		theta = Math.acos( THREE.Math.clamp( normals[ 0 ].dot( normals[ numpoints-1 ] ), -1, 1 ) );
														
 
															+		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;
														
 
															+			theta = - theta;
														
 
															 		}
														
 
															-		for ( i = 1; i < numpoints; i++ ) {
														
 
															+		for ( i = 1; i < numpoints; i ++ ) {
														
 
															 			// twist a little...
														
 
															 			normals[ i ].applyMatrix4( mat.makeRotationAxis( tangents[ i ], theta * i ) );
														
--- a/src/extras/helpers/BoxHelper.js
+++ b/src/extras/helpers/BoxHelper.js
@@ -32,7 +32,6 @@ THREE.BoxHelper.prototype.update = function ( object ) {
 
															 	var min = geometry.boundingBox.min;
														
 
															 	var max = geometry.boundingBox.max;
														
 
															-
														
 
															 	/*
														
 
															 	  5____4
														
 
															 	1/___0/|
														
--- a/src/extras/helpers/CameraHelper.js
+++ b/src/extras/helpers/CameraHelper.js
@@ -124,40 +124,40 @@ THREE.CameraHelper.prototype.update = function () {
 
															 		// center / target
														
 
															-		setPoint( "c", 0, 0, -1 );
														
 
															+		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 );
														
 
															+		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( "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 );
														
 
															+		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( "cf1", - w,  0, 1 );
														
 
															 		setPoint( "cf2",  w,  0, 1 );
														
 
															-		setPoint( "cf3",  0, -h, 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 );
														
 
															+		setPoint( "cn1", - w,  0, - 1 );
														
 
															+		setPoint( "cn2",  w,  0, - 1 );
														
 
															+		setPoint( "cn3",  0, - h, - 1 );
														
 
															+		setPoint( "cn4",  0,  h, - 1 );
														
 
															 		function setPoint( point, x, y, z ) {
														
--- a/src/extras/helpers/SpotLightHelper.js
+++ b/src/extras/helpers/SpotLightHelper.js
@@ -16,7 +16,7 @@ THREE.SpotLightHelper = function ( light ) {
 
															 	var geometry = new THREE.CylinderGeometry( 0, 1, 1, 8, 1, true );
														
 
															-	geometry.applyMatrix( new THREE.Matrix4().makeTranslation( 0, -0.5, 0 ) );
														
 
															+	geometry.applyMatrix( new THREE.Matrix4().makeTranslation( 0, - 0.5, 0 ) );
														
 
															 	geometry.applyMatrix( new THREE.Matrix4().makeRotationX( - Math.PI / 2 ) );
														
 
															 	var material = new THREE.MeshBasicMaterial( { wireframe: true, fog: false } );
														
--- a/src/extras/objects/ImmediateRenderObject.js
+++ b/src/extras/objects/ImmediateRenderObject.js
@@ -6,7 +6,7 @@ THREE.ImmediateRenderObject = function () {
 
															 	THREE.Object3D.call( this );
														
 
															-	this.render = function ( renderCallback ) { };
														
 
															+	this.render = function ( renderCallback ) {};
														
 
															 };
														
--- a/src/extras/objects/LensFlare.js
+++ b/src/extras/objects/LensFlare.js
@@ -29,7 +29,7 @@ THREE.LensFlare.prototype = Object.create( THREE.Object3D.prototype );
 
															 THREE.LensFlare.prototype.add = function ( texture, size, distance, blending, color, opacity ) {
														
 
															-	if( size === undefined ) size = -1;
														
 
															+	if( size === undefined ) size = - 1;
														
 
															 	if( distance === undefined ) distance = 0;
														
 
															 	if( opacity === undefined ) opacity = 1;
														
 
															 	if( color === undefined ) color = new THREE.Color( 0xffffff );
														
@@ -59,8 +59,8 @@ 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;
														
 
															+	var vecX = - this.positionScreen.x * 2;
														
 
															+	var vecY = - this.positionScreen.y * 2;
														
 
															 	for( f = 0; f < fl; f ++ ) {
														
--- a/src/extras/objects/MorphBlendMesh.js
+++ b/src/extras/objects/MorphBlendMesh.js
@@ -77,7 +77,7 @@ THREE.MorphBlendMesh.prototype.autoCreateAnimations = function ( fps ) {
 
															 			var name = chunks[ 1 ];

														
 
															 			var num = chunks[ 2 ];

														
 
															-			if ( ! frameRanges[ name ] ) frameRanges[ name ] = { start: Infinity, end: -Infinity };

														
 
															+			if ( ! frameRanges[ name ] ) frameRanges[ name ] = { start: Infinity, end: - Infinity };

														
 
															 			var range = frameRanges[ name ];

														
@@ -120,7 +120,7 @@ THREE.MorphBlendMesh.prototype.setAnimationDirectionBackward = function ( name )
 
															 	if ( animation ) {

														
 
															-		animation.direction = -1;

														
 
															+		animation.direction = - 1;

														
 
															 		animation.directionBackwards = true;

														
 
															 	}

														
@@ -195,7 +195,7 @@ THREE.MorphBlendMesh.prototype.getAnimationTime = function ( name ) {
 
															 THREE.MorphBlendMesh.prototype.getAnimationDuration = function ( name ) {

														
 
															-	var duration = -1;

														
 
															+	var duration = - 1;

														
 
															 	var animation = this.animationsMap[ name ];

														
@@ -254,7 +254,7 @@ THREE.MorphBlendMesh.prototype.update = function ( delta ) {
 
															 			if ( animation.time > animation.duration || animation.time < 0 ) {

														
 
															-				animation.direction *= -1;

														
 
															+				animation.direction *= - 1;

														
 
															 				if ( animation.time > animation.duration ) {

														
--- a/src/extras/renderers/plugins/DepthPassPlugin.js
+++ b/src/extras/renderers/plugins/DepthPassPlugin.js
@@ -115,7 +115,7 @@ THREE.DepthPassPlugin = function () {
 
															 				// todo: create proper depth material for particles
														
 
															-				if ( object instanceof THREE.PointCloud && !object.customDepthMaterial ) continue;
														
 
															+				if ( object instanceof THREE.PointCloud && ! object.customDepthMaterial ) continue;
														
 
															 				objectMaterial = getObjectMaterial( object );
														
--- a/src/extras/renderers/plugins/LensFlarePlugin.js
+++ b/src/extras/renderers/plugins/LensFlarePlugin.js
@@ -18,21 +18,21 @@ THREE.LensFlarePlugin = function () {
 
															 		_lensFlare.faces = new Uint16Array( 6 );
														
 
															 		var i = 0;
														
 
															-		_lensFlare.vertices[ i++ ] = -1; _lensFlare.vertices[ i++ ] = -1;	// vertex
														
 
															-		_lensFlare.vertices[ i++ ] = 0;  _lensFlare.vertices[ i++ ] = 0;	// uv... etc.
														
 
															+		_lensFlare.vertices[ i ++ ] = - 1; _lensFlare.vertices[ i ++ ] = - 1;	// vertex
														
 
															+		_lensFlare.vertices[ i ++ ] = 0;  _lensFlare.vertices[ i ++ ] = 0;	// uv... etc.
														
 
															-		_lensFlare.vertices[ i++ ] = 1;  _lensFlare.vertices[ i++ ] = -1;
														
 
															-		_lensFlare.vertices[ i++ ] = 1;  _lensFlare.vertices[ i++ ] = 0;
														
 
															+		_lensFlare.vertices[ i ++ ] = 1;  _lensFlare.vertices[ i ++ ] = - 1;
														
 
															+		_lensFlare.vertices[ i ++ ] = 1;  _lensFlare.vertices[ i ++ ] = 0;
														
 
															-		_lensFlare.vertices[ i++ ] = 1;  _lensFlare.vertices[ i++ ] = 1;
														
 
															-		_lensFlare.vertices[ i++ ] = 1;  _lensFlare.vertices[ i++ ] = 1;
														
 
															+		_lensFlare.vertices[ i ++ ] = 1;  _lensFlare.vertices[ i ++ ] = 1;
														
 
															+		_lensFlare.vertices[ i ++ ] = 1;  _lensFlare.vertices[ i ++ ] = 1;
														
 
															-		_lensFlare.vertices[ i++ ] = -1; _lensFlare.vertices[ i++ ] = 1;
														
 
															-		_lensFlare.vertices[ i++ ] = 0;  _lensFlare.vertices[ i++ ] = 1;
														
 
															+		_lensFlare.vertices[ i ++ ] = - 1; _lensFlare.vertices[ i ++ ] = 1;
														
 
															+		_lensFlare.vertices[ i ++ ] = 0;  _lensFlare.vertices[ i ++ ] = 1;
														
 
															 		i = 0;
														
 
															-		_lensFlare.faces[ i++ ] = 0; _lensFlare.faces[ i++ ] = 1; _lensFlare.faces[ i++ ] = 2;
														
 
															-		_lensFlare.faces[ i++ ] = 0; _lensFlare.faces[ i++ ] = 2; _lensFlare.faces[ i++ ] = 3;
														
 
															+		_lensFlare.faces[ i ++ ] = 0; _lensFlare.faces[ i ++ ] = 1; _lensFlare.faces[ i ++ ] = 2;
														
 
															+		_lensFlare.faces[ i ++ ] = 0; _lensFlare.faces[ i ++ ] = 2; _lensFlare.faces[ i ++ ] = 3;
														
 
															 		// buffers
														
--- a/src/extras/renderers/plugins/ShadowMapPlugin.js
+++ b/src/extras/renderers/plugins/ShadowMapPlugin.js
@@ -392,14 +392,14 @@ THREE.ShadowMapPlugin = function () {
 
															 		var nearZ = light.shadowCascadeNearZ[ cascade ];
														
 
															 		var farZ = light.shadowCascadeFarZ[ cascade ];
														
 
															-		pointsFrustum[ 0 ].set( -1, -1, nearZ );
														
 
															-		pointsFrustum[ 1 ].set(  1, -1, nearZ );
														
 
															-		pointsFrustum[ 2 ].set( -1,  1, nearZ );
														
 
															+		pointsFrustum[ 0 ].set( - 1, - 1, nearZ );
														
 
															+		pointsFrustum[ 1 ].set(  1, - 1, nearZ );
														
 
															+		pointsFrustum[ 2 ].set( - 1,  1, nearZ );
														
 
															 		pointsFrustum[ 3 ].set(  1,  1, nearZ );
														
 
															-		pointsFrustum[ 4 ].set( -1, -1, farZ );
														
 
															-		pointsFrustum[ 5 ].set(  1, -1, farZ );
														
 
															-		pointsFrustum[ 6 ].set( -1,  1, farZ );
														
 
															+		pointsFrustum[ 4 ].set( - 1, - 1, farZ );
														
 
															+		pointsFrustum[ 5 ].set(  1, - 1, farZ );
														
 
															+		pointsFrustum[ 6 ].set( - 1,  1, farZ );
														
 
															 		pointsFrustum[ 7 ].set(  1,  1, farZ );
														
 
															 		return virtualLight;
														
@@ -447,7 +447,7 @@ THREE.ShadowMapPlugin = function () {
 
															 			pointsWorld = light.pointsWorld;
														
 
															 		_min.set( Infinity, Infinity, Infinity );
														
 
															-		_max.set( -Infinity, -Infinity, -Infinity );
														
 
															+		_max.set( - Infinity, - Infinity, - Infinity );
														
 
															 		for ( var i = 0; i < 8; i ++ ) {
														
--- a/src/lights/AreaLight.js
+++ b/src/lights/AreaLight.js
@@ -7,7 +7,7 @@ THREE.AreaLight = function ( color, intensity ) {
 
															 	THREE.Light.call( this, color );
														
 
															-	this.normal = new THREE.Vector3( 0, -1, 0 );
														
 
															+	this.normal = new THREE.Vector3( 0, - 1, 0 );
														
 
															 	this.right = new THREE.Vector3( 1, 0, 0 );
														
 
															 	this.intensity = ( intensity !== undefined ) ? intensity : 1;
														
--- a/src/lights/DirectionalLight.js
+++ b/src/lights/DirectionalLight.js
@@ -20,10 +20,10 @@ THREE.DirectionalLight = function ( color, intensity ) {
 
															 	this.shadowCameraNear = 50;
														
 
															 	this.shadowCameraFar = 5000;
														
 
															-	this.shadowCameraLeft = -500;
														
 
															+	this.shadowCameraLeft = - 500;
														
 
															 	this.shadowCameraRight = 500;
														
 
															 	this.shadowCameraTop = 500;
														
 
															-	this.shadowCameraBottom = -500;
														
 
															+	this.shadowCameraBottom = - 500;
														
 
															 	this.shadowCameraVisible = false;
														
@@ -37,14 +37,14 @@ THREE.DirectionalLight = function ( color, intensity ) {
 
															 	this.shadowCascade = false;
														
 
															-	this.shadowCascadeOffset = new THREE.Vector3( 0, 0, -1000 );
														
 
															+	this.shadowCascadeOffset = new THREE.Vector3( 0, 0, - 1000 );
														
 
															 	this.shadowCascadeCount = 2;
														
 
															 	this.shadowCascadeBias = [ 0, 0, 0 ];
														
 
															 	this.shadowCascadeWidth = [ 512, 512, 512 ];
														
 
															 	this.shadowCascadeHeight = [ 512, 512, 512 ];
														
 
															-	this.shadowCascadeNearZ = [ -1.000, 0.990, 0.998 ];
														
 
															+	this.shadowCascadeNearZ = [ - 1.000, 0.990, 0.998 ];
														
 
															 	this.shadowCascadeFarZ  = [  0.990, 0.998, 1.000 ];
														
 
															 	this.shadowCascadeArray = [];
														
--- a/src/lights/Light.js
+++ b/src/lights/Light.js
@@ -2,7 +2,7 @@
 
															  * @author mrdoob / http://mrdoob.com/
														
 
															  * @author alteredq / http://alteredqualia.com/
														
 
															  */
														
 
															- 
														
 
															+
														
 
															 THREE.Light = function ( color ) {
														
 
															 	THREE.Object3D.call( this );
														
--- a/src/loaders/Cache.js
+++ b/src/loaders/Cache.js
@@ -40,4 +40,4 @@ THREE.Cache.prototype = {
 
															 	}

														
 
															-};
														
 
															+};
 															     }
-															-);
+															+);
 															 	}
-															-};
+															+};