vor 11 Jahren · 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 = {
 
				 

			
 
				 	}

			
 
				 

			
 
				-};
			
 
				+};