8 years ago · 57bfcdb44c
--- a/build/three.js
+++ b/build/three.js
--- a/build/three.min.js
+++ b/build/three.min.js
--- a/build/three.module.js
+++ b/build/three.module.js
--- a/docs/api/animation/AnimationMixer.html
+++ b/docs/api/animation/AnimationMixer.html
@@ -1,102 +1,154 @@
 
															 <!DOCTYPE html>
														
 
															 <html lang="en">
														
 
															-  <head>
														
 
															-    <meta charset="utf-8" />
														
 
															-    <base href="../../" />
														
 
															-    <script src="list.js"></script>
														
 
															-    <script src="page.js"></script>
														
 
															-    <link type="text/css" rel="stylesheet" href="page.css" />
														
 
															-  </head>
														
 
															-  <body>
														
 
															-    <h1>[name]</h1>
														
 
															+	<head>
														
 
															+		<meta charset="utf-8" />
														
 
															+		<base href="../../" />
														
 
															+		<script src="list.js"></script>
														
 
															+		<script src="page.js"></script>
														
 
															+		<link type="text/css" rel="stylesheet" href="page.css" />
														
 
															+	</head>
														
 
															+	<body>
														
 
															+		<h1>[name]</h1>
														
 
															+
														
 
															+		<div class="desc">
														
 
															+		The AnimationMixer is a player for animations on a particular object in the scene.
														
 
															+		</div>
														
 
															+
														
 
															+		<p>
														
 
															+		Each available animation sequence is stored as an [page:AnimationClip AnimationClip], and
														
 
															+		playback of that clip is controlled with an [page:AnimationClip AnimationAction]. When multiple
														
 
															+		objects in the scene are animated independently, one AnimationMixer may be used for each object.
														
 
															+		</p>
														
 
															+
														
 
															+		<h2>Example</h2>
														
 
															+
														
 
															+		<p>
														
 
															+		When loading a 3D model that includes animation, many loaders also return a list of
														
 
															+		[page:AnimationClip AnimationClip] instances. Each clip represents a specific animation
														
 
															+		sequence, and may be played or paused individually.
														
 
															+		</p>
														
 
															+
														
 
															+		<code>
														
 
															+		var mesh;
														
 
															+
														
 
															+		// Create an AnimationMixer, and get the list of AnimationClip instances
														
 
															+		var mixer = new THREE.AnimationMixer( mesh );
														
 
															+		var clips = mesh.animations;
														
 
															+
														
 
															+		// Update the mixer on each frame
														
 
															+		function update () {
														
 
															+			mixer.update( deltaSeconds );
														
 
															+		}
														
 
															+
														
 
															+		// Play a specific animation
														
 
															+		var clip = THREE.AnimationClip.findByName( clips, 'dance' );
														
 
															+		var action = mixer.clipAction(clip);
														
 
															+		action.play();
														
 
															+
														
 
															+		// Play all animations
														
 
															+		clips.forEach( function (clip) {
														
 
															+			mixer.clipAction(clip).play();
														
 
															+		} );
														
 
															+		</code>
														
 
															+
														
 
															+		<p>
														
 
															+		Note that not all model formats include animation (OBJ notably does not), and that only some
														
 
															+		THREE.js loaders support [page:AnimationClip AnimationClip] sequences. Several that <i>do</i>
														
 
															+		support this animation type:
														
 
															+		</p>
														
 
															+
														
 
															+		<ul>
														
 
															+			<li>[page:ObjectLoader THREE.ObjectLoader]</li>
														
 
															+			<li>THREE.BVHLoader</li>
														
 
															+			<li>THREE.FBXLoader</li>
														
 
															+			<li>THREE.FBXLoader2</li>
														
 
															+			<li>[page:GLTFLoader THREE.GLTFLoader]</li>
														
 
															+			<li>THREE.MMDLoader</li>
														
 
															+			<li>THREE.SEA3DLoader</li>
														
 
															+		</ul>
														
 
															+
														
 
															+		<h2>Constructor</h2>
														
 
															+
														
 
															+
														
 
															+		<h3>[name]( [page:Object3D root] )</h3>
														
 
															+
														
 
															+
														
 
															+		<h2>Properties</h2>
														
 
															+
														
 
															+
														
 
															+		<h3>[property:Number time]</h3>
														
 
															+
														
 
															+		<h3>[property:Number timeScale]</h3>
														
 
															+
														
 
															+
														
 
															+		<h2>Methods</h2>
														
 
															+
														
 
															+
														
 
															+		<h3>[method:AnimationAction clipAction]([page:AnimationClip clip], [page:Object3D optionalRoot])</h3>
														
 
															+		<div>
														
 
															+		clip -- AnimationClip <br />
														
 
															+		optionalRoot -- Object3D
														
 
															+		</div>
														
 
															+		<div>
														
 
															+		Return an action for a clip, optionally using a custom root target object.
														
 
															+		</div>
														
 
															+
														
 
															+		<h3>[method:AnimationAction existingAction]([page:AnimationClip clip], [page:Object3D optionalRoot])</h3>
														
 
															+		<div>
														
 
															+		clip -- AnimationClip <br />
														
 
															+		optionalRoot -- Object3D
														
 
															+		</div>
														
 
															+		<div>
														
 
															+		Return an existing action.
														
 
															+		</div>
														
 
															+
														
 
															+		<h3>[method:AnimationMixer stopAllAction]()</h3>
														
 
															+		<div>
														
 
															+		Deactivates all scheduled actions.
														
 
															+		</div>
														
 
															+
														
 
															+		<h3>[method:AnimationMixer update]([page:Number deltaTimeMS]) </h3>
														
 
															+		<div>
														
 
															+		deltaTimeMS -- Time elapsed since last update in milliseconds.
														
 
															+		</div>
														
 
															+		<div>
														
 
															+		Updates the animation with deltaTimeMS.
														
 
															+		</div>
														
 
															+
														
 
															+		<h3>[method:Object3D getRoot]()</h3>
														
 
															+		<div>
														
 
															+		Return this mixer's root target object.
														
 
															+		</div>
														
 
															+
														
 
															+		<h3>[method:null uncacheClip]([page:AnimationClip clip])</h3>
														
 
															+		<div>
														
 
															+		clip -- AnimationClip
														
 
															+		</div>
														
 
															+		<div>
														
 
															+		Free all resources for a clip.
														
 
															+		</div>
														
 
															+
														
 
															+		<h3>[method:null uncacheRoot]([page:Object3D root]) </h3>
														
 
															+		<div>
														
 
															+		root -- Object3D
														
 
															+		</div>
														
 
															+		<div>
														
 
															+		Free all resources for a root target object.
														
 
															+		</div>
														
 
															+
														
 
															+		<h3>[method:null uncacheAction]([page:AnimationClip clip], [page:Object3D optionalRoot])</h3>
														
 
															+		<div>
														
 
															+		clip -- AnimationClip <br />
														
 
															+		optionalRoot -- Object3D
														
 
															+		</div>
														
 
															+		<div>
														
 
															+		Free all resources for an action.
														
 
															+		</div>
														
 
															+
														
 
															+
														
 
															+		<h2>Source</h2>
														
 
															-    <div class="desc">
														
 
															-    The AnimationMixer is a player for AnimationClip objects.
														
 
															-    </div>
														
 
															-
														
 
															-    <h2>Constructor</h2>
														
 
															-
														
 
															-
														
 
															-    <h3>[name]( [page:Object3D root] )</h3>
														
 
															-
														
 
															-
														
 
															-    <h2>Properties</h2>
														
 
															-
														
 
															-
														
 
															-    <h3>[property:Number time]</h3>
														
 
															-
														
 
															-    <h3>[property:Number timeScale]</h3>
														
 
															-
														
 
															-
														
 
															-    <h2>Methods</h2>
														
 
															-
														
 
															-
														
 
															-    <h3>[method:AnimationAction clipAction]([page:AnimationClip clip], [page:Object3D optionalRoot])</h3>
														
 
															-    <div>
														
 
															-    clip -- AnimationClip <br />
														
 
															-    optionalRoot -- Object3D
														
 
															-    </div>
														
 
															-    <div>
														
 
															-    Return an action for a clip, optionally using a custom root target object.
														
 
															-    </div>
														
 
															-
														
 
															-    <h3>[method:AnimationAction existingAction]([page:AnimationClip clip], [page:Object3D optionalRoot])</h3>
														
 
															-    <div>
														
 
															-    clip -- AnimationClip <br />
														
 
															-    optionalRoot -- Object3D
														
 
															-    </div>
														
 
															-    <div>
														
 
															-    Return an existing action.
														
 
															-    </div>
														
 
															-
														
 
															-    <h3>[method:AnimationMixer stopAllAction]()</h3>
														
 
															-    <div>
														
 
															-    Deactivates all scheduled actions.
														
 
															-    </div>
														
 
															-
														
 
															-    <h3>[method:AnimationMixer update]([page:Number deltaTimeMS]) </h3>
														
 
															-    <div>
														
 
															-    deltaTimeMS -- Time elapsed since last update in milliseconds.
														
 
															-    </div>
														
 
															-    <div>
														
 
															-    Updates the animation with deltaTimeMS.
														
 
															-    </div>
														
 
															-
														
 
															-    <h3>[method:Object3D getRoot]()</h3>
														
 
															-    <div>
														
 
															-    Return this mixer's root target object.
														
 
															-    </div>
														
 
															-
														
 
															-    <h3>[method:null uncacheClip]([page:AnimationClip clip])</h3>
														
 
															-    <div>
														
 
															-    clip -- AnimationClip
														
 
															-    </div>
														
 
															-    <div>
														
 
															-    Free all resources for a clip.
														
 
															-    </div>
														
 
															-
														
 
															-    <h3>[method:null uncacheRoot]([page:Object3D root]) </h3>
														
 
															-    <div>
														
 
															-    root -- Object3D
														
 
															-    </div>
														
 
															-    <div>
														
 
															-    Free all resources for a root target object.
														
 
															-    </div>
														
 
															-
														
 
															-    <h3>[method:null uncacheAction]([page:AnimationClip clip], [page:Object3D optionalRoot])</h3>
														
 
															-    <div>
														
 
															-    clip -- AnimationClip <br />
														
 
															-    optionalRoot -- Object3D
														
 
															-    </div>
														
 
															-    <div>
														
 
															-    Free all resources for an action.
														
 
															-    </div>
														
 
															-
														
 
															-
														
 
															-    <h2>Source</h2>
														
 
															-
														
 
															-
														
 
															-    [link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
														
 
															-  </body>
														
 
															+		[link:https://github.com/mrdoob/three.js/blob/master/src/[path].js src/[path].js]
														
 
															+	</body>
														
 
															 </html>
														
--- a/docs/api/extras/core/Font.html
+++ b/docs/api/extras/core/Font.html
@@ -16,6 +16,13 @@
 
															 		This is used internally by the [page:FontLoader].
														
 
															 		</div>
														
 
															+		<h2>Examples</h2>
														
 
															+
														
 
															+		<div>
														
 
															+		[example:webgl_geometry_text_shapes geometry / text / shapes ]<br/>
														
 
															+		[example:webgl_shaders_vector vector / text ]<br/>
														
 
															+		</div>
														
 
															+
														
 
															 		<h2>Constructor</h2>
														
 
															 		<h3>[name]( data )</h3>
														
--- a/docs/api/geometries/TextGeometry.html
+++ b/docs/api/geometries/TextGeometry.html
@@ -12,7 +12,11 @@
 
															 		<h1>[name]</h1>

														
 
															-		<div class="desc">This object creates a 3D object of text as a single object.</div>

														
 
															+		<div class="desc">

														
 
															+			A class for generating text as a single geometry. It is constructed by providing a string of text, and a hash of 

														
 
															+			parameters consisting of a loaded [page:Font] and settings for the geometry's parent [page:ExtrudeGeometry].

														
 
															+			See the [page:Font], [page:FontLoader] and [page:Creating_Text] pages for additional details.

														
 
															+		</div>

														
 
															 		<iframe id="scene" src="scenes/geometry-browser.html#TextGeometry"></iframe>

														
@@ -32,13 +36,31 @@
 
															 		</script>

														
 
															-		<h2>Example</h2>

														
 
															+		<h2>Examples</h2>

														
 
															 		<div>

														
 
															 		[example:webgl_geometry_text geometry / text ]<br/>

														
 
															 		[example:webgl_geometry_text2 geometry / text2 ]

														
 
															 		</div>

														
 
															+		<code>

														
 
															+		var loader = new THREE.FontLoader();

														
 
															+		

														
 
															+		loader.load( 'fonts/helvetiker_regular.typeface.json', function ( font ) {

														
 
															+

														
 
															+			var geometry = new THREE.TextGeometry( 'Hello three.js!', {

														
 
															+				font: font,

														
 
															+				size: 80,

														
 
															+				height: 5,

														
 
															+				curveSegments: 12,

														
 
															+				bevelEnabled: true,

														
 
															+				bevelThickness: 10,

														
 
															+				bevelSize: 8,

														
 
															+				bevelSegments: 5

														
 
															+			} );

														
 
															+		} );			

														
 
															+		</code>

														
 
															+

														
 
															 		<h2>Constructor</h2>

														
 
															 		<h3>[name]([page:String text], [page:Object parameters])</h3>

														
@@ -46,8 +68,8 @@
 
															 		text — The text that needs to be shown. <br />

														
 
															 		parameters — Object that can contains the following parameters.

														
 
															 		<ul>

														
 
															-			<li>font — THREE.Font.</li>

														
 
															-			<li>size — Float. Size of the text.</li>

														
 
															+			<li>font — an instance of THREE.Font.</li>

														
 
															+			<li>size — Float. Size of the text. Default is 100.</li>

														
 
															 			<li>height — Float. Thickness to extrude text.  Default is 50.</li>

														
 
															 			<li>curveSegments — Integer. Number of points on the curves. Default is 12.</li>

														
 
															 			<li>bevelEnabled — Boolean. Turn on bevel. Default is False.</li>

														
--- a/docs/api/loaders/FontLoader.html
+++ b/docs/api/loaders/FontLoader.html
@@ -21,6 +21,7 @@
 
															 		<h2>Examples</h2>
														
 
															 		<div>
														
 
															+		[example:webgl_geometry_text_shapes geometry / text / shapes ]<br/>
														
 
															 		[example:webgl_geometry_text geometry / text ]<br />
														
 
															 		[example:webgl_geometry_text_earcut geometry / text / earcut]<br />
														
 
															 		[example:webgl_geometry_text_pnltri geometry / text / pnltri]<br />
														
--- a/docs/api/materials/ShaderMaterial.html
+++ b/docs/api/materials/ShaderMaterial.html
@@ -234,6 +234,13 @@
 
															 			</code>
														
 
															 			</p>
														
 
															+			<p>
														
 
															+			You're recommended to update custom [page:Uniform] values depending on [page:Object3D object] and [page:Camera camera]
														
 
															+			in [page:Object3D.onBeforeRender] because [page:Material] can be shared among [page:Mesh meshes], [page:Matrix4 matrixWorld]
														
 
															+			of [page:Scene] and [page:Camera] are updated in [page:WebGLRenderer.render], and some effects(ex:VREffect) render a [page:Scene scene]
														
 
															+			with private their own [page:Camera cameras].
														
 
															+			</p>
														
 
															+
														
 
															 		</div>
														
 
															 		<h2>Constructor</h2>
														
--- a/docs/api/math/Line3.html
+++ b/docs/api/math/Line3.html
@@ -40,7 +40,7 @@
 
															 		<h2>Methods</h2>
														
 
															 		<h3>[method:Line3 applyMatrix4]( [page:Matrix4 matrix] )</h3>
														
 
															-		<div>Apply a matrix transform to the line segment.</div>
														
 
															+		<div>Applies a matrix transform to the line segment.</div>
														
 
															 		<h3>[method:Vector3 at]( [page:Float t], [page:Vector3 optionalTarget] )</h3>
														
 
															 		<div>
														
@@ -48,12 +48,12 @@
 
															 		[page:Vector3 optionalTarget] - (optional) if specified, the result will be copied into this [page:Vector3],
														
 
															 		otherwise a new [page:Vector3] will be created.<br /><br />
														
 
															-		Return a vector at a certain position along the line. When [page:Float t] = 0, it returns the start vector,
														
 
															+		Returns a vector at a certain position along the line. When [page:Float t] = 0, it returns the start vector,
														
 
															 		and when [page:Float t] = 1 it returns the end vector.<br />
														
 
															 		</div>
														
 
															 		<h3>[method:Line3 clone]()</h3>
														
 
															-		<div>Return a new [page:Line3] with the same [page:.start start] and [page:.end end] vectors as this one.</div>
														
 
															+		<div>Returns a new [page:Line3] with the same [page:.start start] and [page:.end end] vectors as this one.</div>
														
 
															 		<h3>[method:Vector3 closestPointToPoint]( [page:Vector3 point], [page:Boolean clampToLine], [page:Vector3 optionalTarget] )</h3>
														
 
															 		<div>
														
@@ -72,7 +72,7 @@
 
															 		[page:Boolean clampToLine] - Whether to clamp the result to the range [0, 1].<br /><br />
														
 
															 		Returns a point parameter based on the closest point as projected on the line segement.
														
 
															-		If clamp to line is true, then the returned value will be between 0 and 1.
														
 
															+		If [page:Boolean clampToLine] is true, then the returned value will be between 0 and 1.
														
 
															 		</div>
														
 
															 		<h3>[method:Line3 copy]( [page:Line3 line] )</h3>
														
@@ -109,13 +109,13 @@
 
															 			[page:Vector3 optionalTarget] - (optional) if specified, the result will be copied into this [page:Vector3],
														
 
															 			otherwise a new [page:Vector3] will be created.<br /><br />
														
 
															-		Return the center of the line segment.
														
 
															+		Returns the center of the line segment.
														
 
															 		</div>
														
 
															 		<h3>[method:Line3 set]( [page:Vector3 start], [page:Vector3 end] )</h3>
														
 
															 		<div>
														
 
															 		[page:Vector3 start] - set the [page:.start start point] of the line.<br />
														
 
															-		end - [page:Vector3] - set the [page:.end end point] of the line.<br /><br />
														
 
															+		[page:Vector3 end] - set the [page:.end end point] of the line.<br /><br />
														
 
															 		Sets the start and end values by copying the provided vectors.
														
 
															 		</div>
														
--- a/docs/api/math/Math.html
+++ b/docs/api/math/Math.html
@@ -30,7 +30,7 @@
 
															 		<div>
														
 
															 		[page:Integer n], [page:Integer m] - Integers<br /><br />
														
 
															-		Compute the Euclidean modulo of m % [page:Integer n], that is:
														
 
															+		Computes the Euclidean modulo of [page:Integer m] % [page:Integer n], that is:
														
 
															 		<code>( ( n % m ) + m ) % m</code>
														
 
															 		</div>
														
@@ -71,10 +71,10 @@
 
															 		</div>
														
 
															 		<h3>[method:Integer nearestPowerOfTwo]( [page:Number n] )</h3>
														
 
															-		<div>	Return the nearest power of 2 to a given number [page:Number n].</div>
														
 
															+		<div>	Returns the nearest power of 2 to a given number [page:Number n].</div>
														
 
															 		<h3>[method:Integer nextPowerOfTwo]( [page:Number n] )</h3>
														
 
															-		<div>Return the nearest power of 2 that is bigger than [page:Number n].</div>
														
 
															+		<div>Returns the nearest power of 2 that is bigger than [page:Number n].</div>
														
 
															 		<h3>[method:Float radToDeg]( [page:Float radians] )</h3>
														
 
															 		<div>Converts radians to degrees.</div>
														
@@ -83,7 +83,7 @@
 
															 		<div>Random float in the interval [page:Float low] to [page:Float high].</div>
														
 
															 		<h3>[method:Float randFloatSpread]( [page:Float range] )</h3>
														
 
															-		<div>Random float in the intercal *- [page:Float range] / 2* to *[page:Float range] / 2*.</div>
														
 
															+		<div>Random float in the interval *- [page:Float range] / 2* to *[page:Float range] / 2*.</div>
														
 
															 		<h3>[method:Integer randInt]( [page:Integer low], [page:Integer high] )</h3>
														
 
															 		<div>Random integer in the interval [page:Float low] to [page:Float high].</div>
														
--- a/docs/api/math/Quaternion.html
+++ b/docs/api/math/Quaternion.html
@@ -89,7 +89,7 @@
 
															 		<h3>[method:Float dot]( [page:Quaternion v] )</h3>
														
 
															 		<div>
														
 
															-			Calculate the [link:https://en.wikipedia.org/wiki/Dot_product dot product] of
														
 
															+			Calculates the [link:https://en.wikipedia.org/wiki/Dot_product dot product] of
														
 
															 			quaternions [page:Quaternion v] and this one.
														
 
															 		</div>
														
@@ -137,11 +137,11 @@
 
															 		</div>
														
 
															 		<h3>[method:Quaternion onChange]( [page:Function onChangeCallback] )</h3>
														
 
															-		<div>Set the [page:.onChangeCallback onChangeCallback]() method.</div>
														
 
															+		<div>Sets the [page:.onChangeCallback onChangeCallback]() method.</div>
														
 
															 		<h3>[method:Quaternion onChangeCallback]( )</h3>
														
 
															 		<div>
														
 
															-			This function is called whenever and of the following occur:
														
 
															+			This function is called whenever any of the following occurs:
														
 
															 			<ul>
														
 
															 				<li>
														
 
															 					The [page:.x x], [page:.y y], [page:.z z] or
														
@@ -188,7 +188,7 @@
 
															 		<div>
														
 
															 		Sets this quaternion from rotation specified by [page:Vector3 axis] and [page:Float angle].<br />
														
 
															 		Adapted from the method [link:http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm here].<br />
														
 
															-		*Axis* is asumed to be normalized, *angle* is in radians.
														
 
															+		*Axis* is assumed to be normalized, *angle* is in radians.
														
 
															 		</div>
														
 
															 		<h3>[method:Quaternion setFromEuler]( [page:Euler euler] )</h3>
														
@@ -210,8 +210,8 @@
 
															 		<h3>[method:Array toArray]( [page:Array array], [page:Integer offset] )</h3>
														
 
															 		<div>
														
 
															-		[page:Array array] - An optional array to store the quaternion. If not specified a new array will be created.<br/>
														
 
															-		[page:Integer offset] - optional) if specified, the result will be copied
														
 
															+		[page:Array array] - An optional array to store the quaternion. If not specified, a new array will be created.<br/>
														
 
															+		[page:Integer offset] - (optional) if specified, the result will be copied
														
 
															 		into this [page:Array].<br /><br />
														
 
															 		Returns the numerical elements of this quaternion in an array of format [x, y, z, w].
														
--- a/docs/api/math/Vector2.html
+++ b/docs/api/math/Vector2.html
@@ -54,7 +54,7 @@
 
															 		[page:Float x] - the x value of the vector. Default is *0*.<br />
														
 
															 		[page:Float y] -  the y value of the vector. Default is *0*.<br /><br />
														
 
															-		Created a new [name].
														
 
															+		Creates a new [name].
														
 
															 		</div>
														
@@ -64,7 +64,7 @@
 
															 		<div>
														
 
															 			Used to check whether this or derived classes are Vector2s. Default is *true*.<br /><br />
														
 
															-			You should not change this, as it used internally for optimisation.
														
 
															+			You should not change this, as it is used internally for optimisation.
														
 
															 		</div>
														
 
															 		<h3>[property:Float height]</h3>
														
@@ -84,7 +84,7 @@
 
															 		<div>Adds [page:Vector2 v] to this vector.</div>
														
 
															 		<h3>[method:Vector2 addScalar]( [page:Float s] )</h3>
														
 
															-		<div>Add the scalar value s to this vector's [page:.x x] and [page:.y y] values.</div>
														
 
															+		<div>Adds the scalar value [page:Float s] to this vector's [page:.x x] and [page:.y y] values.</div>
														
 
															 		<h3>[method:Vector2 addScaledVector]( [page:Vector2 v], [page:Float s] )</h3>
														
 
															 		<div>Adds the multiple of [page:Vector2 v] and [page:Float s] to this vector.</div>
														
@@ -131,13 +131,13 @@
 
															 		<h3>[method:Vector2 clone]()</h3>
														
 
															 		<div>
														
 
															-		Returns a new vector2 with the same [page:.x x] and [page:.y y] values as this one.
														
 
															+		Returns a new Vector2 with the same [page:.x x] and [page:.y y] values as this one.
														
 
															 		</div>
														
 
															 		<h3>[method:Vector2 copy]( [page:Vector2 v] )</h3>
														
 
															 		<div>
														
 
															-			Copies the values of the passed vector2's [page:.x x] and [page:.y y]
														
 
															-			properties to this vector2.
														
 
															+			Copies the values of the passed Vector2's [page:.x x] and [page:.y y]
														
 
															+			properties to this Vector2.
														
 
															 		</div>
														
 
															 		<h3>[method:Float distanceTo]( [page:Vector2 v] )</h3>
														
@@ -166,7 +166,7 @@
 
															 		<h3>[method:Float dot]( [page:Vector2 v] )</h3>
														
 
															 		<div>
														
 
															-		Calculate the [link:https://en.wikipedia.org/wiki/Dot_product dot product] of this
														
 
															+		Calculates the [link:https://en.wikipedia.org/wiki/Dot_product dot product] of this
														
 
															 	  vector and [page:Vector2 v].
														
 
															 		</div>
														
@@ -179,9 +179,9 @@
 
															 		<h3>[method:Vector2 fromArray]( [page:Array array], [page:Integer offset] )</h3>
														
 
															 		<div>
														
 
															 		[page:Array array] - the source array.<br />
														
 
															-		[page:Integer offset] - ( optional) offset into the array. Default is 0.<br /><br />
														
 
															+		[page:Integer offset] - (optional) offset into the array. Default is 0.<br /><br />
														
 
															-		Sets this vector's [page:.x x] value to be array[0] and [page:.y y] value to be array[1].
														
 
															+		Sets this vector's [page:.x x] value to be array[ offset ] and [page:.y y] value to be array[ offset + 1 ].
														
 
															 		</div>
														
 
															 		<h3>[method:Vector2 fromBufferAttribute]( [page:BufferAttribute attribute], [page:Integer index] )</h3>
														
@@ -221,7 +221,7 @@
 
															 		[page:Vector2 v] - [page:Vector2] to interpolate towards.<br />
														
 
															 		alpha - interpolation factor in the closed interval [0, 1].<br /><br />
														
 
															-		Linearly interpolate between this vector and [page:Vector2 v], where alpha is the
														
 
															+		Linearly interpolates between this vector and [page:Vector2 v], where alpha is the
														
 
															 		distance along the line - alpha = 0 will be this vector, and alpha = 1 will be [page:Vector2 v].
														
 
															 		</div>
														
@@ -241,19 +241,19 @@
 
															 		<h3>[method:Vector2 normalize]()</h3>
														
 
															 		<div>
														
 
															-		Convert this vector to a [link:https://en.wikipedia.org/wiki/Unit_vector unit vector] - that is, sets it equal to the vector with the same direction
														
 
															+		Converts this vector to a [link:https://en.wikipedia.org/wiki/Unit_vector unit vector] - that is, sets it equal to the vector with the same direction
														
 
															 		as this one, but [page:.length length] 1.
														
 
															 		</div>
														
 
															 		<h3>[method:Vector2 max]( [page:Vector2 v] )</h3>
														
 
															 		<div>
														
 
															-		If this vector's x or y value is less than [page:Vector2 v's] x or y value, replace
														
 
															+		If this vector's x or y value is less than [page:Vector2 v]'s x or y value, replace
														
 
															 		that value with the corresponding max value.
														
 
															 		</div>
														
 
															 		<h3>[method:Vector2 min]( [page:Vector2 v] )</h3>
														
 
															 		<div>
														
 
															-		If this vector's x or y value is greater than [page:Vector2 v's] x or y value, replace
														
 
															+		If this vector's x or y value is greater than [page:Vector2 v]'s x or y value, replace
														
 
															 		that value with the corresponding min value.
														
 
															 		</div>
														
@@ -269,7 +269,7 @@
 
															 			[page:Vector2 center] - the point around which to rotate.<br />
														
 
															 			[page:float angle] - the angle to rotate, in radians.<br /><br />
														
 
															-			Rotate the vector arounf [page:Vector2 center] by [page:float angle] radians.
														
 
															+			Rotates the vector around [page:Vector2 center] by [page:float angle] radians.
														
 
															 		</div>
														
 
															 		<h3>[method:Vector2 round]()</h3>
														
@@ -294,34 +294,33 @@
 
															 		<h3>[method:Vector2 setLength]( [page:Float l] )</h3>
														
 
															 		<div>
														
 
															-		Set this vector to the vector with the same direction as this one, but [page:.length length]
														
 
															+		Sets this vector to the vector with the same direction as this one, but [page:.length length]
														
 
															 		[page:Float l].
														
 
															 		</div>
														
 
															 		<h3>[method:Vector2 setScalar]( [page:Float scalar] )</h3>
														
 
															 		<div>
														
 
															-		Set the [page:.x x] and [page:.y y] values of this vector both equal to [page:Float scalar].
														
 
															+		Sets the [page:.x x] and [page:.y y] values of this vector both equal to [page:Float scalar].
														
 
															 		</div>
														
 
															 		<h3>[method:Vector2 setX]( [page:Float x] )</h3>
														
 
															-		<div>Replace this vector's [page:.x x] value with [page:Float x].</div>
														
 
															+		<div>Replaces this vector's [page:.x x] value with [page:Float x].</div>
														
 
															 		<h3>[method:Vector2 setY]( [page:Float y] )</h3>
														
 
															-		<div>Replace this vector's [page:.y y] value with [page:Float y].</div>
														
 
															+		<div>Replaces this vector's [page:.y y] value with [page:Float y].</div>
														
 
															 		<h3>[method:Vector2 sub]( [page:Vector2 v] )</h3>
														
 
															 		<div>Subtracts [page:Vector2 v] from this vector.</div>
														
 
															 		<h3>[method:Vector2 subScalar]( [page:Float s] )</h3>
														
 
															-		<div>Subtracts [page:Float s]  from this vector's [page:.x x] and [page:.y y] compnents.</div>
														
 
															+		<div>Subtracts [page:Float s]  from this vector's [page:.x x] and [page:.y y] components.</div>
														
 
															 		<h3>[method:Vector2 subVectors]( [page:Vector2 a], [page:Vector2 b] )</h3>
														
 
															 		<div>Sets this vector to [page:Vector2 a] - [page:Vector2 b].</div>
														
 
															 		<h3>[method:Array toArray]( [page:Array array], [page:Integer offset] )</h3>
														
 
															 		<div>
														
 
															-		[page:Array array] - (optional) array to store the vector to. If this is not provided
														
 
															-		a new array will be created.<br />
														
 
															+		[page:Array array] - (optional) array to store the vector to. If this is not provided, a new array will be created.<br />
														
 
															 		[page:Integer offset] - (optional) optional offset into the array.<br /><br />
														
 
															 		Returns an array [x, y], or copies x and y into the provided [page:Array array].
														
--- a/docs/api/math/Vector3.html
+++ b/docs/api/math/Vector3.html
@@ -65,7 +65,7 @@ var d = a.distanceTo( b );
 
															 		<div>
														
 
															 			Used to check whether this or derived classes are Vector3s. Default is *true*.<br /><br />
														
 
															-			You should not change this, as it used internally for optimisation.
														
 
															+			You should not change this, as it is used internally for optimisation.
														
 
															 		</div>
														
 
															 		<h3>[property:Float x]</h3>
														
@@ -81,7 +81,7 @@ var d = a.distanceTo( b );
 
															 		<div>Adds [page:Vector3 v] to this vector.</div>
														
 
															 		<h3>[method:Vector3 addScalar]( [page:Float s] )</h3>
														
 
															-		<div>Add the scalar value s to this vector's [page:.x x], [page:.y y] and [page:.z z] values.</div>
														
 
															+		<div>Adds the scalar value s to this vector's [page:.x x], [page:.y y] and [page:.z z] values.</div>
														
 
															 		<h3>[method:Vector3 addScaledVector]( [page:Vector3 v], [page:Float s] )</h3>
														
 
															 		<div>Adds the multiple of [page:Vector3 v] and [page:Float s] to this vector.</div>
														
@@ -104,7 +104,7 @@ var d = a.distanceTo( b );
 
															 		</div>
														
 
															 		<h3>[method:Vector3 applyMatrix3]( [page:Matrix3 m] )</h3>
														
 
															-		<div>Multiply this vector by [page:Matrix3 m]</div>
														
 
															+		<div>Multiplies this vector by [page:Matrix3 m]</div>
														
 
															 		<h3>[method:Vector3 applyMatrix4]( [page:Matrix4 m] )</h3>
														
 
															 		<div>
														
@@ -284,13 +284,13 @@ var d = a.distanceTo( b );
 
															 		<h3>[method:Vector3 max]( [page:Vector3 v] )</h3>
														
 
															 		<div>
														
 
															-		If this vector's x, y or z value is less than [page:Vector3 v's] x, y or z value, replace
														
 
															+		If this vector's x, y or z value is less than [page:Vector3 v]'s x, y or z value, replace
														
 
															 		that value with the corresponding max value.
														
 
															 		</div>
														
 
															 		<h3>[method:Vector3 min]( [page:Vector3 v] )</h3>
														
 
															 		<div>
														
 
															-		If this vector's x, y or z value is greater than [page:Vector3 v's] x, y or z value, replace
														
 
															+		If this vector's x, y or z value is greater than [page:Vector3 v]'s x, y or z value, replace
														
 
															 		that value with the corresponding min value.
														
 
															 		</div>
														
--- a/docs/api/math/Vector4.html
+++ b/docs/api/math/Vector4.html
@@ -22,7 +22,7 @@
 
															 			<li>
														
 
															 				A direction and length in 4D space. In three.js the length will always be the
														
 
															 				[link:https://en.wikipedia.org/wiki/Euclidean_distance Euclidean distance]
														
 
															-				(straight-line distance) from (0, 0, 0, 0, 0) to (x, y, z, w) and the direction is also
														
 
															+				(straight-line distance) from (0, 0, 0, 0) to (x, y, z, w) and the direction is also
														
 
															 				measured from (0, 0, 0, 0) towards (x, y, z, w).
														
 
															 			</li>
														
 
															 			<li>
														
@@ -42,7 +42,7 @@ var a = new THREE.Vector4( 0, 1, 0, 0 );
 
															 //no arguments; will be initialised to (0, 0, 0, 1)
														
 
															 var b = new THREE.Vector4( );
														
 
															-var d = a.distanceTo( b );
														
 
															+var d = a.dot( b );
														
 
															 		</code>
														
@@ -65,7 +65,7 @@ var d = a.distanceTo( b );
 
															 		<div>
														
 
															 			Used to check whether this or derived classes are Vector4s. Default is *true*.<br /><br />
														
 
															-			You should not change this, as it used internally for optimisation.
														
 
															+			You should not change this, as it is used internally for optimisation.
														
 
															 		</div>
														
 
															 		<h3>[property:Float x]</h3>
														
@@ -83,7 +83,7 @@ var d = a.distanceTo( b );
 
															 		<div>Adds [page:Vector4 v] to this vector.</div>
														
 
															 		<h3>[method:Vector4 addScalar]( [page:Float s] )</h3>
														
 
															-		<div>Add the scalar value s to this vector's [page:.x x], [page:.y y], [page:.z z] and [page:.w w] values.</div>
														
 
															+		<div>Adds the scalar value s to this vector's [page:.x x], [page:.y y], [page:.z z] and [page:.w w] values.</div>
														
 
															 		<h3>[method:Vector4 addScaledVector]( [page:Vector4 v], [page:Float s] )</h3>
														
 
															 		<div>Adds the multiple of [page:Vector4 v] and [page:Float s] to this vector.</div>
														
@@ -93,7 +93,7 @@ var d = a.distanceTo( b );
 
															 		<h3>[method:Vector4 applyMatrix4]( [page:Matrix4 m] )</h3>
														
 
															 		<div>
														
 
															-		Multiply this vector by 4 x 4 [page:Matrix4 m].
														
 
															+		Multiplies this vector by 4 x 4 [page:Matrix4 m].
														
 
															 		</div>
														
 
															 		<h3>[method:Vector4 ceil]()</h3>
														
@@ -138,7 +138,7 @@ var d = a.distanceTo( b );
 
															 		<h3>[method:Float dot]( [page:Vector4 v] )</h3>
														
 
															 		<div>
														
 
															-		Calculate the [link:https://en.wikipedia.org/wiki/Dot_product dot product] of this
														
 
															+		Calculates the [link:https://en.wikipedia.org/wiki/Dot_product dot product] of this
														
 
															 		vector and [page:Vector4 v].
														
 
															 		</div>
														
@@ -151,7 +151,7 @@ var d = a.distanceTo( b );
 
															 		<h3>[method:Vector4 fromArray]( [page:Array array], [page:Integer offset] )</h3>
														
 
															 		<div>
														
 
															 		[page:Array array] - the source array.<br />
														
 
															-		[page:Integer offset] - ( optional) offset into the array. Default is 0.<br /><br />
														
 
															+		[page:Integer offset] - (optional) offset into the array. Default is 0.<br /><br />
														
 
															 		Sets this vector's [page:.x x] value to be array[ offset + 0 ], [page:.y y] value to be array[ offset + 1 ]
														
 
															 		[page:.z z] value to be array[ offset + 2 ] and [page:.w w ] value to be array[ offset + 3 ].
														
@@ -196,7 +196,7 @@ var d = a.distanceTo( b );
 
															 		[page:Vector4 v] - [page:Vector4] to interpolate towards.<br />
														
 
															 		alpha - interpolation factor in the closed interval [0, 1].<br /><br />
														
 
															-		Linearly interpolate between this vector and [page:Vector4 v], where alpha is the
														
 
															+		Linearly interpolates between this vector and [page:Vector4 v], where alpha is the
														
 
															 		distance along the line - alpha = 0 will be this vector, and alpha = 1 will be [page:Vector4 v].
														
 
															 		</div>
														
@@ -216,7 +216,7 @@ var d = a.distanceTo( b );
 
															 		<h3>[method:Vector4 normalize]()</h3>
														
 
															 		<div>
														
 
															-		Convert this vector to a [link:https://en.wikipedia.org/wiki/Unit_vector unit vector] - that is, sets it equal to the vector with the same direction
														
 
															+		Converts this vector to a [link:https://en.wikipedia.org/wiki/Unit_vector unit vector] - that is, sets it equal to the vector with the same direction
														
 
															 		as this one, but [page:.length length] 1.
														
 
															 		</div>
														
@@ -250,7 +250,7 @@ var d = a.distanceTo( b );
 
															 		<div>
														
 
															 			[page:Quaterion q] - a normalized [page:Quaterion]<br /><br />
														
 
															-			Set the [page:.x x], [page:.y y] and [page:.z z] components of this vector to the
														
 
															+			Sets the [page:.x x], [page:.y y] and [page:.z z] components of this vector to the
														
 
															 			quaternion's axis and [page:.w w] to the angle.
														
 
															 		</div>
														
@@ -258,7 +258,7 @@ var d = a.distanceTo( b );
 
															 		<div>
														
 
															 			 [page:Matrix4 m] - a [page:Matrix4] of which the upper left 3x3 matrix is a pure rotation matrix.<br /><br />
														
 
															-			Set the [page:.x x], [page:.y y] and [page:.z z] to the axis of rotation and [page:.w w] to the angle.
														
 
															+			Sets the [page:.x x], [page:.y y] and [page:.z z] to the axis of rotation and [page:.w w] to the angle.
														
 
															 		</div>
														
 
															 		<h3>[method:null setComponent]( [page:Integer index], [page:Float value] )</h3>
														
@@ -275,26 +275,26 @@ var d = a.distanceTo( b );
 
															 		<h3>[method:Vector4 setLength]( [page:Float l] )</h3>
														
 
															 		<div>
														
 
															-		Set this vector to the vector with the same direction as this one, but [page:.length length]
														
 
															+		Sets this vector to the vector with the same direction as this one, but [page:.length length]
														
 
															 		[page:Float l].
														
 
															 		</div>
														
 
															 		<h3>[method:Vector4 setScalar]( [page:Float scalar] )</h3>
														
 
															 		<div>
														
 
															-		Set the [page:.x x], [page:.y y], [page:.z z] and [page:.w w] values of this vector both equal to [page:Float scalar].
														
 
															+		Sets the [page:.x x], [page:.y y], [page:.z z] and [page:.w w] values of this vector both equal to [page:Float scalar].
														
 
															 		</div>
														
 
															 		<h3>[method:Vector4 setX]( [page:Float x] )</h3>
														
 
															-		<div>Replace this vector's [page:.x x] value with [page:Float x].</div>
														
 
															+		<div>Replaces this vector's [page:.x x] value with [page:Float x].</div>
														
 
															 		<h3>[method:Vector4 setY]( [page:Float y] )</h3>
														
 
															-		<div>Replace this vector's [page:.y y] value with [page:Float y].</div>
														
 
															+		<div>Replaces this vector's [page:.y y] value with [page:Float y].</div>
														
 
															 		<h3>[method:Vector4 setZ]( [page:Float z] )</h3>
														
 
															-		<div>Replace this vector's [page:.z z] value with [page:Float z].</div>
														
 
															+		<div>Replaces this vector's [page:.z z] value with [page:Float z].</div>
														
 
															 		<h3>[method:Vector4 setW]( [page:Float w] )</h3>
														
 
															-		<div>Replace this vector's [page:.w w] value with [page:Float w].</div>
														
 
															+		<div>Replaces this vector's [page:.w w] value with [page:Float w].</div>
														
 
															 		<h3>[method:Vector4 sub]( [page:Vector4 v] )</h3>
														
 
															 		<div>Subtracts [page:Vector4 v] from this vector.</div>
														
@@ -307,8 +307,7 @@ var d = a.distanceTo( b );
 
															 		<h3>[method:Array toArray]( [page:Array array], [page:Integer offset] )</h3>
														
 
															 		<div>
														
 
															-		[page:Array array] - (optional) array to store the vector to. If this is not provided
														
 
															-		a new array will be created.<br />
														
 
															+		[page:Array array] - (optional) array to store the vector to. If this is not provided, a new array will be created.<br />
														
 
															 		[page:Integer offset] - (optional) optional offset into the array.<br /><br />
														
 
															 		Returns an array [x, y, z, w], or copies x, y, z and w into the provided [page:Array array].
														
--- a/docs/examples/loaders/GLTFLoader.html
+++ b/docs/examples/loaders/GLTFLoader.html
@@ -26,18 +26,18 @@
 
															 		<h2>Example</h2>
														
 
															 		<code>
														
 
															-		// instantiate a loader
														
 
															+		// Instantiate a loader
														
 
															 		var loader = new THREE.GLTFLoader();
														
 
															-		// load a glTF resource
														
 
															-		loader.load(
														
 
															-			// resource URL
														
 
															-			'models/gltf/duck/duck.json',
														
 
															-			// Function when resource is loaded
														
 
															-			function ( object ) {
														
 
															-				scene.add( object.scene );
														
 
															-			}
														
 
															-		);
														
 
															+		// Load a glTF resource
														
 
															+		loader.load( 'models/gltf/duck/duck.gltf', function ( gltf ) {
														
 
															+			scene.add( gltf.scene );
														
 
															+
														
 
															+			gltf.animations; // Array&lt;THREE.AnimationClip&gt;
														
 
															+			gltf.scene;      // THREE.Scene
														
 
															+			gltf.scenes;     // Array&lt;THREE.Scene&gt;
														
 
															+			gltf.cameras;    // Array&lt;THREE.Camera&gt;
														
 
															+		} );
														
 
															 		</code>
														
 
															 		[example:webgl_loader_gltf]
														
--- a/docs/manual/introduction/Creating-text.html
+++ b/docs/manual/introduction/Creating-text.html
@@ -61,13 +61,19 @@
 
															 		<h2>4. Procedural Text Geometry</h2>
														
 
															 		<div>
														
 
															 			<p>
														
 
															-				Use this method if you prefer to work purely in three.js or create procedural and dynamic 3d
														
 
															-				text geometries. However, font data files in THREE.js JSON format need to be loaded
														
 
															-				before this will work.
														
 
															-				See the [page:TextGeometry] page for examples of JSON fonts.
														
 
															+				If you prefer to work purely in THREE.js or to create procedural and dynamic 3D
														
 
															+				text geometries, you can create a mesh whose geometry is an instance of THREE.TextGeometry:
														
 
															+			</p>
														
 
															+			<p>
														
 
															+				<code>new THREE.TextGeometry( text, parameters );</code>
														
 
															+			</p>
														
 
															+			<p>
														
 
															+				In order for this to work, however, your TextGeomety will need an instance of THREE.Font 
														
 
															+				to be set on its "font" parameter.
														
 
															+
														
 
															+				See the [page:TextGeometry] page for more info on how this can be done, descriptions of each
														
 
															+				accepted parameter, and a list of the JSON fonts that come with the THREE.js distribution itself.
														
 
															 			</p>
														
 
															-			<p>A Text Geometry can then be created with </p>
														
 
															-			<code>new THREE.TextGeometry( text, parameters );</code>
														
 
															 			<h3>Examples</h3>
														
 
															 			[example:webgl_geometry_text WebGL / geometry / text]<br />
														
--- a/docs/scenes/js/geometry.js
+++ b/docs/scenes/js/geometry.js
@@ -744,7 +744,7 @@ var guis = {
 
															 		var folder = gui.addFolder( 'THREE.RingBufferGeometry' );
														
 
															-		folder.add( data, 'innerRadius', 0, 30 ).onChange( generateGeometry );
														
 
															+		folder.add( data, 'innerRadius', 1, 30 ).onChange( generateGeometry );
														
 
															 		folder.add( data, 'outerRadius', 1, 30 ).onChange( generateGeometry );
														
 
															 		folder.add( data, 'thetaSegments', 1, 30 ).step( 1 ).onChange( generateGeometry );
														
 
															 		folder.add( data, 'phiSegments', 1, 30 ).step( 1 ).onChange( generateGeometry );
														
@@ -778,7 +778,7 @@ var guis = {
 
															 		var folder = gui.addFolder( 'THREE.RingGeometry' );
														
 
															-		folder.add( data, 'innerRadius', 0, 30 ).onChange( generateGeometry );
														
 
															+		folder.add( data, 'innerRadius', 1, 30 ).onChange( generateGeometry );
														
 
															 		folder.add( data, 'outerRadius', 1, 30 ).onChange( generateGeometry );
														
 
															 		folder.add( data, 'thetaSegments', 1, 30 ).step( 1 ).onChange( generateGeometry );
														
 
															 		folder.add( data, 'phiSegments', 1, 30 ).step( 1 ).onChange( generateGeometry );
														
--- a/editor/js/Sidebar.Animation.js
+++ b/editor/js/Sidebar.Animation.js
@@ -27,6 +27,24 @@ Sidebar.Animation = function ( editor ) {
 
															 		object.traverse( function ( child ) {
														
 
															+			if ( child instanceof THREE.SkinnedMesh ) {
														
 
															+
														
 
															+				var material = child.material;
														
 
															+
														
 
															+				if ( material instanceof THREE.MultiMaterial ) {
														
 
															+
														
 
															+					for ( var i = 0; i < material.materials.length; i ++ ) {
														
 
															+
														
 
															+						material.materials[ i ].skinning = true;
														
 
															+
														
 
															+					}
														
 
															+
														
 
															+				} else {
														
 
															+
														
 
															+					child.material.skinning = true;
														
 
															+
														
 
															+				}
														
 
															+
														
 
															 				animations[ child.id ] = new THREE.Animation( child, child.geometry.animation );
														
 
															 			} else if ( child instanceof THREE.MorphAnimMesh ) {
														
--- a/editor/js/Sidebar.Material.js
+++ b/editor/js/Sidebar.Material.js
@@ -229,6 +229,16 @@ Sidebar.Material = function ( editor ) {
 
															 	container.add( materialVertexColorsRow );
														
 
															+	// skinning
														
 
															+
														
 
															+	var materialSkinningRow = new UI.Row();
														
 
															+	var materialSkinning = new UI.Checkbox( false ).onChange( update );
														
 
															+
														
 
															+	materialSkinningRow.add( new UI.Text( 'Skinning' ).setWidth( '90px' ) );
														
 
															+	materialSkinningRow.add( materialSkinning );
														
 
															+
														
 
															+	container.add( materialSkinningRow );
														
 
															+
														
 
															 	// map
														
 
															 	var materialMapRow = new UI.Row();
														
@@ -571,6 +581,12 @@ Sidebar.Material = function ( editor ) {
 
															 			}
														
 
															+			if ( material.skinning !== undefined && material.skinning !== materialSkinning.getValue() ) {
														
 
															+
														
 
															+				editor.execute( new SetMaterialValueCommand( currentObject, 'skinning', materialSkinning.getValue() ) );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															 			if ( material.map !== undefined ) {
														
 
															 				var mapEnabled = materialMapEnabled.getValue() === true;
														
@@ -938,6 +954,7 @@ Sidebar.Material = function ( editor ) {
 
															 			'clearCoatRoughness': materialClearCoatRoughnessRow,
														
 
															 			'vertexShader': materialProgramRow,
														
 
															 			'vertexColors': materialVertexColorsRow,
														
 
															+			'skinning': materialSkinningRow,
														
 
															 			'map': materialMapRow,
														
 
															 			'alphaMap': materialAlphaMapRow,
														
 
															 			'bumpMap': materialBumpMapRow,
														
@@ -1044,6 +1061,12 @@ Sidebar.Material = function ( editor ) {
 
															 		}
														
 
															+		if ( material.skinning !== undefined ) {
														
 
															+
														
 
															+			materialSkinning.setValue( material.skinning );
														
 
															+
														
 
															+		}
														
 
															+
														
 
															 		if ( material.map !== undefined ) {
														
 
															 			materialMapEnabled.setValue( material.map !== null );
														
--- a/examples/canvas_geometry_panorama.html
+++ b/examples/canvas_geometry_panorama.html
@@ -81,7 +81,7 @@
 
															 				];
														
 
															-				mesh = new THREE.Mesh( new THREE.BoxGeometry( 300, 300, 300, 7, 7, 7 ), new THREE.MultiMaterial( materials ) );
														
 
															+				mesh = new THREE.Mesh( new THREE.BoxGeometry( 300, 300, 300, 7, 7, 7 ), materials );
														
 
															 				mesh.scale.x = - 1;
														
 
															 				scene.add( mesh );
														
--- a/examples/canvas_geometry_panorama_fisheye.html
+++ b/examples/canvas_geometry_panorama_fisheye.html
@@ -81,7 +81,7 @@
 
															 				];
														
 
															-				mesh = new THREE.Mesh( new THREE.BoxGeometry( 300, 300, 300, 7, 7, 7 ), new THREE.MultiMaterial( materials ) );
														
 
															+				mesh = new THREE.Mesh( new THREE.BoxGeometry( 300, 300, 300, 7, 7, 7 ), materials );
														
 
															 				mesh.scale.x = - 1;
														
 
															 				scene.add( mesh );
														
--- a/examples/canvas_geometry_text.html
+++ b/examples/canvas_geometry_text.html
@@ -92,12 +92,12 @@
 
															 				var centerOffset = -0.5 * ( geometry.boundingBox.max.x - geometry.boundingBox.min.x );
														
 
															-				var material = new THREE.MultiMaterial( [
														
 
															+				var materials = [
														
 
															 					new THREE.MeshBasicMaterial( { color: Math.random() * 0xffffff, overdraw: 0.5 } ),
														
 
															 					new THREE.MeshBasicMaterial( { color: 0x000000, overdraw: 0.5 } )
														
 
															-				] );
														
 
															+				];
														
 
															-				var mesh = new THREE.Mesh( geometry, material );
														
 
															+				var mesh = new THREE.Mesh( geometry, materials );
														
 
															 				mesh.position.x = centerOffset;
														
 
															 				mesh.position.y = 100;
														
--- a/examples/canvas_materials.html
+++ b/examples/canvas_materials.html
@@ -93,7 +93,7 @@
 
															 				}
														
 
															-				materials.push( new THREE.MultiMaterial( materials ) );
														
 
															+				materials.push( materials );
														
 
															 				objects = [];
														
--- a/examples/js/BlendCharacter.js
+++ b/examples/js/BlendCharacter.js
@@ -36,6 +36,8 @@ THREE.BlendCharacter = function () {
 
															 			}
														
 
															+			scope.material.skinning = true;
														
 
															+
														
 
															 			scope.mixer = new THREE.AnimationMixer( scope );
														
 
															 			// Create the animations
														
@@ -57,9 +59,10 @@ THREE.BlendCharacter = function () {
 
															 		var scope = this;
														
 
															 		var loader = new THREE.JSONLoader();
														
 
															-		loader.load( url, function ( geometry, materials ) {
														
 
															+		loader.load( url, function( geometry, materials ) {
														
 
															 			var originalMaterial = materials[ 0 ];
														
 
															+			originalMaterial.skinning = true;
														
 
															 			THREE.SkinnedMesh.call( scope, geometry, originalMaterial );
														
@@ -79,7 +82,7 @@ THREE.BlendCharacter = function () {
 
															 		} );
														
 
															 	};
														
 
															-
														
 
															+	
														
 
															 	this.update = function( dt ) {
														
 
															 		this.mixer.update( dt );
														
@@ -176,3 +179,4 @@ THREE.BlendCharacter.prototype.getForward = function() {
 
															 	}
														
 
															 };
														
 
															+
														
--- a/examples/js/Car.js
+++ b/examples/js/Car.js
@@ -299,8 +299,8 @@ THREE.Car = function () {
 
															 			var s = scope.modelScale,
														
 
															 				delta = new THREE.Vector3();
														
 
															-			var bodyFaceMaterial = new THREE.MultiMaterial( scope.bodyMaterials );
														
 
															-			var wheelFaceMaterial = new THREE.MultiMaterial( scope.wheelMaterials );
														
 
															+			var bodyFaceMaterial = scope.bodyMaterials;
														
 
															+			var wheelFaceMaterial = scope.wheelMaterials;
														
 
															 			// body
														
--- a/examples/js/Mirror.js
+++ b/examples/js/Mirror.js
@@ -2,52 +2,50 @@
 
															  * @author Slayvin / http://slayvin.net

														
 
															  */

														
 
															-THREE.Mirror = function ( renderer, camera, options ) {

														
 
															+THREE.Mirror = function ( width, height, options ) {

														
 
															-	THREE.Object3D.call( this );

														
 
															+	THREE.Mesh.call( this, new THREE.PlaneBufferGeometry( width, height ) );

														
 
															-	this.name = 'mirror_' + this.id;

														
 
															+	var scope = this;

														
 
															-	options = options || {};

														
 
															-

														
 
															-	this.matrixNeedsUpdate = true;

														
 
															+	scope.name = 'mirror_' + scope.id;

														
 
															+	scope.matrixNeedsUpdate = true;

														
 
															-	var width = options.textureWidth !== undefined ? options.textureWidth : 512;

														
 
															-	var height = options.textureHeight !== undefined ? options.textureHeight : 512;

														
 
															+	options = options || {};

														
 
															-	this.clipBias = options.clipBias !== undefined ? options.clipBias : 0.0;

														
 
															+	var textureWidth = options.textureWidth !== undefined ? options.textureWidth : 512;

														
 
															+	var textureHeight = options.textureHeight !== undefined ? options.textureHeight : 512;

														
 
															+	var clipBias = options.clipBias !== undefined ? options.clipBias : 0.0;

														
 
															 	var mirrorColor = options.color !== undefined ? new THREE.Color( options.color ) : new THREE.Color( 0x7F7F7F );

														
 
															-	this.renderer = renderer;

														
 
															-	this.mirrorPlane = new THREE.Plane();

														
 
															-	this.normal = new THREE.Vector3( 0, 0, 1 );

														
 
															-	this.mirrorWorldPosition = new THREE.Vector3();

														
 
															-	this.cameraWorldPosition = new THREE.Vector3();

														
 
															-	this.rotationMatrix = new THREE.Matrix4();

														
 
															-	this.lookAtPosition = new THREE.Vector3( 0, 0, - 1 );

														
 
															-	this.clipPlane = new THREE.Vector4();

														
 
															+	var mirrorPlane = new THREE.Plane();

														
 
															+	var normal = new THREE.Vector3();

														
 
															+	var mirrorWorldPosition = new THREE.Vector3();

														
 
															+	var cameraWorldPosition = new THREE.Vector3();

														
 
															+	var rotationMatrix = new THREE.Matrix4();

														
 
															+	var lookAtPosition = new THREE.Vector3( 0, 0, - 1 );

														
 
															+	var clipPlane = new THREE.Vector4();

														
 
															-	if ( camera instanceof THREE.PerspectiveCamera ) {

														
 
															+	var textureMatrix = new THREE.Matrix4();

														
 
															-		this.camera = camera;

														
 
															+	var mirrorCamera = new THREE.PerspectiveCamera();

														
 
															+	mirrorCamera.matrixAutoUpdate = true;

														
 
															-	} else {

														
 
															-

														
 
															-		this.camera = new THREE.PerspectiveCamera();

														
 
															-		console.log( this.name + ': camera is not a Perspective Camera!' );

														
 
															-

														
 
															-	}

														
 
															+	var parameters = {

														
 
															+		minFilter: THREE.LinearFilter,

														
 
															+		magFilter: THREE.LinearFilter,

														
 
															+		format: THREE.RGBFormat,

														
 
															+		stencilBuffer: false

														
 
															+	};

														
 
															-	this.textureMatrix = new THREE.Matrix4();

														
 
															+	var renderTarget = new THREE.WebGLRenderTarget( textureWidth, textureHeight, parameters );

														
 
															-	this.mirrorCamera = this.camera.clone();

														
 
															-	this.mirrorCamera.matrixAutoUpdate = true;

														
 
															+	if ( ! THREE.Math.isPowerOfTwo( textureWidth ) || ! THREE.Math.isPowerOfTwo( textureHeight ) ) {

														
 
															-	var parameters = { minFilter: THREE.LinearFilter, magFilter: THREE.LinearFilter, format: THREE.RGBFormat, stencilBuffer: false };

														
 
															+		renderTarget.texture.generateMipmaps = false;

														
 
															-	this.renderTarget = new THREE.WebGLRenderTarget( width, height, parameters );

														
 
															-	this.renderTarget2 = new THREE.WebGLRenderTarget( width, height, parameters );

														
 
															+	}

														
 
															 	var mirrorShader = {

														
@@ -92,7 +90,7 @@ THREE.Mirror = function ( renderer, camera, options ) {
 
															 	var mirrorUniforms = THREE.UniformsUtils.clone( mirrorShader.uniforms );

														
 
															-	this.material = new THREE.ShaderMaterial( {

														
 
															+	var material = new THREE.ShaderMaterial( {

														
 
															 		fragmentShader: mirrorShader.fragmentShader,

														
 
															 		vertexShader: mirrorShader.vertexShader,

														
@@ -100,181 +98,105 @@ THREE.Mirror = function ( renderer, camera, options ) {
 
															 	} );

														
 
															-	this.material.uniforms.mirrorSampler.value = this.renderTarget.texture;

														
 
															-	this.material.uniforms.mirrorColor.value = mirrorColor;

														
 
															-	this.material.uniforms.textureMatrix.value = this.textureMatrix;

														
 
															-

														
 
															-	if ( ! THREE.Math.isPowerOfTwo( width ) || ! THREE.Math.isPowerOfTwo( height ) ) {

														
 
															-

														
 
															-		this.renderTarget.texture.generateMipmaps = false;

														
 
															-		this.renderTarget2.texture.generateMipmaps = false;

														
 
															-

														
 
															-	}

														
 
															-

														
 
															-	this.updateTextureMatrix();

														
 
															-	this.render();

														
 
															-

														
 
															-};

														
 
															-

														
 
															-THREE.Mirror.prototype = Object.create( THREE.Object3D.prototype );

														
 
															-

														
 
															-Object.assign( THREE.Mirror.prototype, {

														
 
															-

														
 
															-	constructor: THREE.Mirror,

														
 
															-

														
 
															-	renderWithMirror: function ( otherMirror ) {

														
 
															-

														
 
															-		// update the mirror matrix to mirror the current view

														
 
															-		this.updateTextureMatrix();

														
 
															-		this.matrixNeedsUpdate = false;

														
 
															-

														
 
															-		// set the camera of the other mirror so the mirrored view is the reference view

														
 
															-		var tempCamera = otherMirror.camera;

														
 
															-		otherMirror.camera = this.mirrorCamera;

														
 
															-

														
 
															-		// render the other mirror in temp texture

														
 
															-		otherMirror.renderTemp();

														
 
															-		otherMirror.material.uniforms.mirrorSampler.value = otherMirror.renderTarget2.texture;

														
 
															+	material.uniforms.mirrorSampler.value = renderTarget.texture;

														
 
															+	material.uniforms.mirrorColor.value = mirrorColor;

														
 
															+	material.uniforms.textureMatrix.value = textureMatrix;

														
 
															-		// render the current mirror

														
 
															-		this.render();

														
 
															-		this.matrixNeedsUpdate = true;

														
 
															+	scope.material = material;

														
 
															-		// restore material and camera of other mirror

														
 
															-		otherMirror.material.uniforms.mirrorSampler.value = otherMirror.renderTarget.texture;

														
 
															-		otherMirror.camera = tempCamera;

														
 
															+	function updateTextureMatrix( camera ) {

														
 
															-		// restore texture matrix of other mirror

														
 
															-		otherMirror.updateTextureMatrix();

														
 
															+		camera.updateMatrixWorld();

														
 
															-	},

														
 
															+		mirrorCamera.copy( camera );

														
 
															+		mirrorCamera.updateProjectionMatrix();

														
 
															-	updateTextureMatrix: function () {

														
 
															+		scope.updateMatrixWorld();

														
 
															-		this.updateMatrixWorld();

														
 
															-		this.camera.updateMatrixWorld();

														
 
															+		mirrorWorldPosition.setFromMatrixPosition( scope.matrixWorld );

														
 
															+		cameraWorldPosition.setFromMatrixPosition( camera.matrixWorld );

														
 
															-		this.mirrorWorldPosition.setFromMatrixPosition( this.matrixWorld );

														
 
															-		this.cameraWorldPosition.setFromMatrixPosition( this.camera.matrixWorld );

														
 
															+		rotationMatrix.extractRotation( scope.matrixWorld );

														
 
															-		this.rotationMatrix.extractRotation( this.matrixWorld );

														
 
															+		normal.set( 0, 0, 1 );

														
 
															+		normal.applyMatrix4( rotationMatrix );

														
 
															-		this.normal.set( 0, 0, 1 );

														
 
															-		this.normal.applyMatrix4( this.rotationMatrix );

														
 
															+		var view = mirrorWorldPosition.clone().sub( cameraWorldPosition );

														
 
															+		view.reflect( normal ).negate();

														
 
															+		view.add( mirrorWorldPosition );

														
 
															-		var view = this.mirrorWorldPosition.clone().sub( this.cameraWorldPosition );

														
 
															-		view.reflect( this.normal ).negate();

														
 
															-		view.add( this.mirrorWorldPosition );

														
 
															+		rotationMatrix.extractRotation( camera.matrixWorld );

														
 
															-		this.rotationMatrix.extractRotation( this.camera.matrixWorld );

														
 
															+		lookAtPosition.set( 0, 0, - 1 );

														
 
															+		lookAtPosition.applyMatrix4( rotationMatrix );

														
 
															+		lookAtPosition.add( cameraWorldPosition );

														
 
															-		this.lookAtPosition.set( 0, 0, - 1 );

														
 
															-		this.lookAtPosition.applyMatrix4( this.rotationMatrix );

														
 
															-		this.lookAtPosition.add( this.cameraWorldPosition );

														
 
															+		var target = mirrorWorldPosition.clone().sub( lookAtPosition );

														
 
															+		target.reflect( normal ).negate();

														
 
															+		target.add( mirrorWorldPosition );

														
 
															-		var target = this.mirrorWorldPosition.clone().sub( this.lookAtPosition );

														
 
															-		target.reflect( this.normal ).negate();

														
 
															-		target.add( this.mirrorWorldPosition );

														
 
															+		mirrorCamera.position.copy( view );

														
 
															+		mirrorCamera.up.set( 0, - 1, 0 );

														
 
															+		mirrorCamera.up.applyMatrix4( rotationMatrix );

														
 
															+		mirrorCamera.up.reflect( normal ).negate();

														
 
															+		mirrorCamera.lookAt( target );

														
 
															-		this.up.set( 0, - 1, 0 );

														
 
															-		this.up.applyMatrix4( this.rotationMatrix );

														
 
															-		this.up.reflect( this.normal ).negate();

														
 
															-

														
 
															-		this.mirrorCamera.position.copy( view );

														
 
															-		this.mirrorCamera.up = this.up;

														
 
															-		this.mirrorCamera.lookAt( target );

														
 
															-

														
 
															-		this.mirrorCamera.updateProjectionMatrix();

														
 
															-		this.mirrorCamera.updateMatrixWorld();

														
 
															-		this.mirrorCamera.matrixWorldInverse.getInverse( this.mirrorCamera.matrixWorld );

														
 
															+		mirrorCamera.updateProjectionMatrix();

														
 
															+		mirrorCamera.updateMatrixWorld();

														
 
															+		mirrorCamera.matrixWorldInverse.getInverse( mirrorCamera.matrixWorld );

														
 
															 		// Update the texture matrix

														
 
															-		this.textureMatrix.set(

														
 
															+		textureMatrix.set(

														
 
															 			0.5, 0.0, 0.0, 0.5,

														
 
															 			0.0, 0.5, 0.0, 0.5,

														
 
															 			0.0, 0.0, 0.5, 0.5,

														
 
															 			0.0, 0.0, 0.0, 1.0

														
 
															 		);

														
 
															-		this.textureMatrix.multiply( this.mirrorCamera.projectionMatrix );

														
 
															-		this.textureMatrix.multiply( this.mirrorCamera.matrixWorldInverse );

														
 
															+		textureMatrix.multiply( mirrorCamera.projectionMatrix );

														
 
															+		textureMatrix.multiply( mirrorCamera.matrixWorldInverse );

														
 
															 		// Now update projection matrix with new clip plane, implementing code from: http://www.terathon.com/code/oblique.html

														
 
															 		// Paper explaining this technique: http://www.terathon.com/lengyel/Lengyel-Oblique.pdf

														
 
															-		this.mirrorPlane.setFromNormalAndCoplanarPoint( this.normal, this.mirrorWorldPosition );

														
 
															-		this.mirrorPlane.applyMatrix4( this.mirrorCamera.matrixWorldInverse );

														
 
															+		mirrorPlane.setFromNormalAndCoplanarPoint( normal, mirrorWorldPosition );

														
 
															+		mirrorPlane.applyMatrix4( mirrorCamera.matrixWorldInverse );

														
 
															-		this.clipPlane.set( this.mirrorPlane.normal.x, this.mirrorPlane.normal.y, this.mirrorPlane.normal.z, this.mirrorPlane.constant );

														
 
															+		clipPlane.set( mirrorPlane.normal.x, mirrorPlane.normal.y, mirrorPlane.normal.z, mirrorPlane.constant );

														
 
															 		var q = new THREE.Vector4();

														
 
															-		var projectionMatrix = this.mirrorCamera.projectionMatrix;

														
 
															+		var projectionMatrix = mirrorCamera.projectionMatrix;

														
 
															-		q.x = ( Math.sign( this.clipPlane.x ) + projectionMatrix.elements[ 8 ] ) / projectionMatrix.elements[ 0 ];

														
 
															-		q.y = ( Math.sign( this.clipPlane.y ) + projectionMatrix.elements[ 9 ] ) / projectionMatrix.elements[ 5 ];

														
 
															+		q.x = ( Math.sign( clipPlane.x ) + projectionMatrix.elements[ 8 ] ) / projectionMatrix.elements[ 0 ];

														
 
															+		q.y = ( Math.sign( clipPlane.y ) + projectionMatrix.elements[ 9 ] ) / projectionMatrix.elements[ 5 ];

														
 
															 		q.z = - 1.0;

														
 
															 		q.w = ( 1.0 + projectionMatrix.elements[ 10 ] ) / projectionMatrix.elements[ 14 ];

														
 
															 		// Calculate the scaled plane vector

														
 
															 		var c = new THREE.Vector4();

														
 
															-		c = this.clipPlane.multiplyScalar( 2.0 / this.clipPlane.dot( q ) );

														
 
															+		c = clipPlane.multiplyScalar( 2.0 / clipPlane.dot( q ) );

														
 
															 		// Replacing the third row of the projection matrix

														
 
															 		projectionMatrix.elements[ 2 ] = c.x;

														
 
															 		projectionMatrix.elements[ 6 ] = c.y;

														
 
															-		projectionMatrix.elements[ 10 ] = c.z + 1.0 - this.clipBias;

														
 
															+		projectionMatrix.elements[ 10 ] = c.z + 1.0 - clipBias;

														
 
															 		projectionMatrix.elements[ 14 ] = c.w;

														
 
															-	},

														
 
															-

														
 
															-	render: function () {

														
 
															-

														
 
															-		if ( this.matrixNeedsUpdate ) this.updateTextureMatrix();

														
 
															-

														
 
															-		this.matrixNeedsUpdate = true;

														
 
															-

														
 
															-		// Render the mirrored view of the current scene into the target texture

														
 
															-		var scene = this;

														
 
															-

														
 
															-		while ( scene.parent !== null ) {

														
 
															-

														
 
															-			scene = scene.parent;

														
 
															-

														
 
															-		}

														
 
															-

														
 
															-		if ( scene !== undefined && scene instanceof THREE.Scene ) {

														
 
															-

														
 
															-			// We can't render ourself to ourself

														
 
															-			var visible = this.material.visible;

														
 
															-			this.material.visible = false;

														
 
															-

														
 
															-			this.renderer.render( scene, this.mirrorCamera, this.renderTarget, true );

														
 
															-

														
 
															-			this.material.visible = visible;

														
 
															-

														
 
															-		}

														
 
															-

														
 
															-	},

														
 
															-

														
 
															-	renderTemp: function () {

														
 
															-

														
 
															-		if ( this.matrixNeedsUpdate ) this.updateTextureMatrix();

														
 
															-

														
 
															-		this.matrixNeedsUpdate = true;

														
 
															+	}

														
 
															-		// Render the mirrored view of the current scene into the target texture

														
 
															-		var scene = this;

														
 
															+	scope.onBeforeRender = function ( renderer, scene, camera ) {

														
 
															-		while ( scene.parent !== null ) {

														
 
															+		updateTextureMatrix( camera );

														
 
															-			scene = scene.parent;

														
 
															+		scope.visible = false;

														
 
															-		}

														
 
															+		var currentRenderTarget = renderer.getRenderTarget();

														
 
															-		if ( scene !== undefined && scene instanceof THREE.Scene ) {

														
 
															+		renderer.render( scene, mirrorCamera, renderTarget, true );

														
 
															+		renderer.setRenderTarget( currentRenderTarget );

														
 
															-			this.renderer.render( scene, this.mirrorCamera, this.renderTarget2, true );

														
 
															+		scope.visible = true;

														
 
															-		}

														
 
															+	};

														
 
															-	}

														
 
															+};

														
 
															-} );

														
 
															+THREE.Mirror.prototype = Object.create( THREE.Mesh.prototype );

														
--- a/examples/js/UCSCharacter.js
+++ b/examples/js/UCSCharacter.js
@@ -44,7 +44,7 @@ THREE.UCSCharacter = function() {
 
															 			geometry.computeBoundingBox();
														
 
															 			geometry.computeVertexNormals();
														
 
															-			mesh = new THREE.SkinnedMesh( geometry, new THREE.MultiMaterial() );
														
 
															+			mesh = new THREE.SkinnedMesh( geometry, [] );
														
 
															 			mesh.name = config.character;
														
 
															 			scope.root.add( mesh );
														
--- a/examples/js/controls/OrbitControls.js
+++ b/examples/js/controls/OrbitControls.js
@@ -96,6 +96,14 @@ THREE.OrbitControls = function ( object, domElement ) {
 
															 	};
														
 
															+	this.saveState = function () {
														
 
															+
														
 
															+		scope.target0.copy( scope.target );
														
 
															+		scope.position0.copy( scope.object.position );
														
 
															+		scope.zoom0 = scope.object.zoom;
														
 
															+
														
 
															+	};
														
 
															+
														
 
															 	this.reset = function () {
														
 
															 		scope.target.copy( scope.target0 );
														
--- a/examples/js/effects/OutlineEffect.js
+++ b/examples/js/effects/OutlineEffect.js
@@ -13,11 +13,11 @@
 
															  *
														
 
															  * // How to set outline parameters for each material
														
 
															  * material.outlineParameters = {
														
 
															- * 	thickNess: 0.01,                     // this paremeter won't work for MultiMaterial
														
 
															- * 	color: new THREE.Color( 0x888888 ),  // this paremeter won't work for MultiMaterial
														
 
															- * 	alpha: 0.8,                          // this paremeter won't work for MultiMaterial
														
 
															+ * 	thickNess: 0.01,
														
 
															+ * 	color: new THREE.Color( 0x888888 ),
														
 
															+ * 	alpha: 0.8,
														
 
															  * 	visible: true,
														
 
															- * 	keepAlive: true  // this paremeter won't work for Material in materials of MultiMaterial
														
 
															+ * 	keepAlive: true
														
 
															  * };
														
 
															  *
														
 
															  * TODO
														
@@ -35,8 +35,8 @@ THREE.OutlineEffect = function ( renderer, parameters ) {
 
															 	var defaultAlpha = parameters.defaultAlpha !== undefined ? parameters.defaultAlpha : 1.0;
														
 
															 	var defaultKeepAlive = parameters.defaultKeepAlive !== undefined ? parameters.defaultKeepAlive : false;
														
 
															-	// object.material.uuid -> outlineMaterial
														
 
															-	// (no mapping from children of MultiMaterial)
														
 
															+	// object.material.uuid -> outlineMaterial or
														
 
															+	// object.material[ n ].uuid -> outlineMaterial
														
 
															 	// save at the outline material creation and release
														
 
															 	// if it's unused removeThresholdCount frames
														
 
															 	// unless keepAlive is true.
														
@@ -44,8 +44,8 @@ THREE.OutlineEffect = function ( renderer, parameters ) {
 
															 	var removeThresholdCount = 60;
														
 
															-	// outlineMaterial.uuid (or object.uuid for invisibleMaterial) -> originalMaterial
														
 
															-	// including children of MultiMaterial.
														
 
															+	// outlineMaterial.uuid -> object.material or
														
 
															+	// outlineMaterial.uuid -> object.material[ n ]
														
 
															 	// save before render and release after render.
														
 
															 	var originalMaterials = {};
														
@@ -55,8 +55,6 @@ THREE.OutlineEffect = function ( renderer, parameters ) {
 
															 	//this.cache = cache;  // for debug
														
 
															-	var invisibleMaterial = new THREE.ShaderMaterial( { visible: false } );
														
 
															-
														
 
															 	// copied from WebGLPrograms and removed some materials
														
 
															 	var shaderIDs = {
														
 
															 		MeshBasicMaterial: 'basic',
														
@@ -139,6 +137,12 @@ THREE.OutlineEffect = function ( renderer, parameters ) {
 
															 	].join( "\n" );
														
 
															+	function createInvisibleMaterial() {
														
 
															+
														
 
															+		return new THREE.ShaderMaterial( { name: 'invisible', visible: false } );
														
 
															+
														
 
															+	}
														
 
															+
														
 
															 	function createMaterial( originalMaterial ) {
														
 
															 		var shaderID = shaderIDs[ originalMaterial.type ];
														
@@ -162,7 +166,7 @@ THREE.OutlineEffect = function ( renderer, parameters ) {
 
															 				console.warn( 'THREE.OutlineEffect requires both vec3 position and normal attributes in vertex shader, ' +
														
 
															 				              'does not draw outline for ' + originalMaterial.name + '(uuid:' + originalMaterial.uuid + ') material.' );
														
 
															-				return invisibleMaterial;
														
 
															+				return createInvisibleMaterial();
														
 
															 			}
														
@@ -173,7 +177,7 @@ THREE.OutlineEffect = function ( renderer, parameters ) {
 
															 		} else {
														
 
															-			return invisibleMaterial;
														
 
															+			return createInvisibleMaterial();
														
 
															 		}
														
@@ -195,85 +199,74 @@ THREE.OutlineEffect = function ( renderer, parameters ) {
 
															 		if ( ! /vec3\s+transformed\s*=/.test( originalVertexShader ) &&
														
 
															 		     ! /#include\s+<begin_vertex>/.test( originalVertexShader ) ) defines.DECLARE_TRANSFORMED = true;
														
 
															-		var material = new THREE.ShaderMaterial( {
														
 
															+		return new THREE.ShaderMaterial( {
														
 
															 			defines: defines,
														
 
															 			uniforms: uniforms,
														
 
															 			vertexShader: vertexShader,
														
 
															 			fragmentShader: fragmentShader,
														
 
															 			side: THREE.BackSide,
														
 
															 			//wireframe: true,
														
 
															+			skinning: false,
														
 
															 			morphTargets: false,
														
 
															 			morphNormals: false,
														
 
															 			fog: false
														
 
															 		} );
														
 
															-		return material;
														
 
															-
														
 
															-	}
														
 
															-
														
 
															-	function createMultiMaterial( originalMaterial ) {
														
 
															-
														
 
															-		var materials = [];
														
 
															-
														
 
															-		for ( var i = 0, il = originalMaterial.materials.length; i < il; i ++ ) {
														
 
															-
														
 
															-			materials.push( createMaterial( originalMaterial.materials[ i ] ) );
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-		return new THREE.MultiMaterial( materials );
														
 
															-
														
 
															 	}
														
 
															-	function setOutlineMaterial( object ) {
														
 
															-
														
 
															-		if ( object.material === undefined ) return;
														
 
															+	function getOutlineMaterialFromCache( originalMaterial ) {
														
 
															-		var data = cache[ object.material.uuid ];
														
 
															+		var data = cache[ originalMaterial.uuid ];
														
 
															 		if ( data === undefined ) {
														
 
															 			data = {
														
 
															-				material: object.material.isMultiMaterial === true ? createMultiMaterial( object.material ) : createMaterial( object.material ),
														
 
															+				material: createMaterial( originalMaterial ),
														
 
															 				used: true,
														
 
															 				keepAlive: defaultKeepAlive,
														
 
															 				count: 0
														
 
															 			};
														
 
															-			cache[ object.material.uuid ] = data;
														
 
															+			cache[ originalMaterial.uuid ] = data;
														
 
															 		}
														
 
															-		var outlineMaterial = data.material;
														
 
															 		data.used = true;
														
 
															-		var uuid = outlineMaterial !== invisibleMaterial ? outlineMaterial.uuid : object.uuid;
														
 
															-		originalMaterials[ uuid ] = object.material;
														
 
															+		return data.material;
														
 
															-		if ( object.material.isMultiMaterial === true ) {
														
 
															+	}
														
 
															-			for ( var i = 0, il = object.material.materials.length; i < il; i ++ ) {
														
 
															+	function getOutlineMaterial( originalMaterial ) {
														
 
															-				// originalMaterial of leaf material of MultiMaterial is used only for
														
 
															-				// updating outlineMaterial. so need not to save for invisibleMaterial.
														
 
															-				if ( outlineMaterial.materials[ i ] !== invisibleMaterial ) {
														
 
															+		var outlineMaterial = getOutlineMaterialFromCache( originalMaterial );
														
 
															-					originalMaterials[ outlineMaterial.materials[ i ].uuid ] = object.material.materials[ i ];
														
 
															+		originalMaterials[ outlineMaterial.uuid ] = originalMaterial;
														
 
															-				}
														
 
															+		updateOutlineMaterial( outlineMaterial, originalMaterial );
														
 
															-			}
														
 
															+		return outlineMaterial;
														
 
															+
														
 
															+	}
														
 
															+
														
 
															+	function setOutlineMaterial( object ) {
														
 
															+
														
 
															+		if ( object.material === undefined ) return;
														
 
															-			updateOutlineMultiMaterial( outlineMaterial, object.material );
														
 
															+		if ( Array.isArray( object.material ) ) {
														
 
															+
														
 
															+			for ( var i = 0, il = object.material.length; i < il; i ++ ) {
														
 
															+
														
 
															+				object.material[ i ] = getOutlineMaterial( object.material[ i ] );
														
 
															+
														
 
															+			}
														
 
															 		} else {
														
 
															-			updateOutlineMaterial( outlineMaterial, object.material );
														
 
															+			object.material = getOutlineMaterial( object.material );
														
 
															 		}
														
 
															-		object.material = outlineMaterial;
														
 
															-
														
 
															 		originalOnBeforeRenders[ object.uuid ] = object.onBeforeRender;
														
 
															 		object.onBeforeRender = onBeforeRender;
														
@@ -283,31 +276,29 @@ THREE.OutlineEffect = function ( renderer, parameters ) {
 
															 		if ( object.material === undefined ) return;
														
 
															-		var originalMaterial = originalMaterials[ object.material.uuid ];
														
 
															+		if ( Array.isArray( object.material ) ) {
														
 
															+
														
 
															+			for ( var i = 0, il = object.material.length; i < il; i ++ ) {
														
 
															-		if ( originalMaterial === undefined ) {
														
 
															+				object.material[ i ] = originalMaterials[ object.material[ i ].uuid ];
														
 
															+
														
 
															+			}
														
 
															-			originalMaterial = originalMaterials[ object.uuid ];
														
 
															+		} else {
														
 
															-			if ( originalMaterial === undefined ) return;
														
 
															+			object.material = originalMaterials[ object.material.uuid ];
														
 
															 		}
														
 
															-		object.material = originalMaterial;
														
 
															 		object.onBeforeRender = originalOnBeforeRenders[ object.uuid ];
														
 
															 	}
														
 
															 	function onBeforeRender( renderer, scene, camera, geometry, material, group ) {
														
 
															-		// check some things before updating just in case
														
 
															-
														
 
															-		if ( material === invisibleMaterial ) return;
														
 
															-
														
 
															-		if ( material.isMultiMaterial === true ) return;
														
 
															-
														
 
															 		var originalMaterial = originalMaterials[ material.uuid ];
														
 
															+		// just in case
														
 
															 		if ( originalMaterial === undefined ) return;
														
 
															 		updateUniforms( material, originalMaterial );
														
@@ -332,10 +323,11 @@ THREE.OutlineEffect = function ( renderer, parameters ) {
 
															 	function updateOutlineMaterial( material, originalMaterial ) {
														
 
															-		if ( material === invisibleMaterial ) return;
														
 
															+		if ( material.name === 'invisible' ) return;
														
 
															 		var outlineParameters = originalMaterial.outlineParameters;
														
 
															+		material.skinning = originalMaterial.skinning;
														
 
															 		material.morphTargets = originalMaterial.morphTargets;
														
 
															 		material.morphNormals = originalMaterial.morphNormals;
														
 
															 		material.fog = originalMaterial.fog;
														
@@ -354,8 +346,7 @@ THREE.OutlineEffect = function ( renderer, parameters ) {
 
															 			material.transparent = ( outlineParameters.alpha !== undefined && outlineParameters.alpha < 1.0 ) ? true : originalMaterial.transparent;
														
 
															-			// cache[ originalMaterial.uuid ] is undefined if originalMaterial is in materials of MultiMaterial
														
 
															-			if ( outlineParameters.keepAlive !== undefined && cache[ originalMaterial.uuid ] !== undefined ) cache[ originalMaterial.uuid ].keepAlive = outlineParameters.keepAlive;
														
 
															+			if ( outlineParameters.keepAlive !== undefined ) cache[ originalMaterial.uuid ].keepAlive = outlineParameters.keepAlive;
														
 
															 		} else {
														
@@ -368,40 +359,6 @@ THREE.OutlineEffect = function ( renderer, parameters ) {
 
															 	}
														
 
															-	function updateOutlineMultiMaterial( material, originalMaterial ) {
														
 
															-
														
 
															-		if ( material === invisibleMaterial ) return;
														
 
															-
														
 
															-		var outlineParameters = originalMaterial.outlineParameters;
														
 
															-
														
 
															-		if ( outlineParameters !== undefined ) {
														
 
															-
														
 
															-			if ( originalMaterial.visible === false ) {
														
 
															-
														
 
															-				material.visible = false;
														
 
															-
														
 
															-			} else {
														
 
															-
														
 
															-				material.visible = ( outlineParameters.visible !== undefined ) ? outlineParameters.visible : true;
														
 
															-
														
 
															-			}
														
 
															-
														
 
															-			if ( outlineParameters.keepAlive !== undefined ) cache[ originalMaterial.uuid ].keepAlive = outlineParameters.keepAlive;
														
 
															-
														
 
															-		} else {
														
 
															-
														
 
															-			material.visible = originalMaterial.visible;
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-		for ( var i = 0, il = material.materials.length; i < il; i ++ ) {
														
 
															-
														
 
															-			updateOutlineMaterial( material.materials[ i ], originalMaterial.materials[ i ] );
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-	}
														
 
															-
														
 
															 	function cleanupCache() {
														
 
															 		var keys;
														
--- a/examples/js/geometries/DecalGeometry.js
+++ b/examples/js/geometries/DecalGeometry.js
@@ -1,289 +1,359 @@
 
															-THREE.DecalVertex = function( v, n ) {
														
 
															+/**
														
 
															+ * @author Mugen87 / https://github.com/Mugen87
														
 
															+ * @author spite / https://github.com/spite
														
 
															+ *
														
 
															+ * You can use this geometry to create a decal mesh, that serves different kinds of purposes.
														
 
															+ * e.g. adding unique details to models, performing dynamic visual environmental changes or covering seams.
														
 
															+ *
														
 
															+ * Constructor parameter:
														
 
															+ *
														
 
															+ * mesh — Any mesh object
														
 
															+ * position — Position of the decal projector
														
 
															+ * orientation — Orientation of the decal projector
														
 
															+ * size — Size of the decal projector
														
 
															+ *
														
 
															+ * reference: http://blog.wolfire.com/2009/06/how-to-project-decals/
														
 
															+ *
														
 
															+ */
														
 
															-	this.vertex = v;
														
 
															-	this.normal = n;
														
 
															+( function() {
														
 
															-};
														
 
															+  function DecalGeometry( mesh, position, orientation, size ) {
														
 
															-THREE.DecalVertex.prototype.clone = function() {
														
 
															+  	THREE.BufferGeometry.call( this );
														
 
															-	return new THREE.DecalVertex( this.vertex.clone(), this.normal.clone() );
														
 
															+  	this.type = 'DecalGeometry';
														
 
															-};
														
 
															+  	// buffers
														
 
															-THREE.DecalGeometry = function( mesh, position, rotation, dimensions, check ) {
														
 
															+  	var vertices = [];
														
 
															+  	var normals = [];
														
 
															+  	var uvs = [];
														
 
															-	THREE.Geometry.call( this );
														
 
															+  	// helpers
														
 
															-	if ( check === undefined ) check = null;
														
 
															-	check = check || new THREE.Vector3( 1, 1, 1 );
														
 
															+  	var plane = new THREE.Vector3();
														
 
															-	this.uvs = [];
														
 
															+  	// this matrix represents the transformation of the decal projector
														
 
															-	this.cube = new THREE.Mesh( new THREE.BoxGeometry( dimensions.x, dimensions.y, dimensions.z ), new THREE.MeshBasicMaterial() );
														
 
															-	this.cube.rotation.set( rotation.x, rotation.y, rotation.z );
														
 
															-	this.cube.position.copy( position );
														
 
															-	this.cube.scale.set( 1, 1, 1 );
														
 
															-	this.cube.updateMatrix();
														
 
															+  	var projectorMatrix = new THREE.Matrix4();
														
 
															+  	projectorMatrix.makeRotationFromEuler( orientation );
														
 
															+  	projectorMatrix.setPosition( position );
														
 
															-	this.iCubeMatrix = ( new THREE.Matrix4() ).getInverse( this.cube.matrix );
														
 
															+  	var projectorMatrixInverse = new THREE.Matrix4().getInverse( projectorMatrix );
														
 
															-	this.faceIndices = [ 'a', 'b', 'c', 'd' ];
														
 
															+  	// generate buffers
														
 
															-	this.clipFace = function( inVertices, plane ) {
														
 
															+  	generate();
														
 
															-		var size = .5 * Math.abs( ( dimensions.clone() ).dot( plane ) );
														
 
															+  	// build geometry
														
 
															-		function clip( v0, v1, p ) {
														
 
															+  	this.addAttribute( 'position', new THREE.Float32BufferAttribute( vertices, 3 ) );
														
 
															+  	this.addAttribute( 'normal', new THREE.Float32BufferAttribute( normals, 3 ) );
														
 
															+  	this.addAttribute( 'uv', new THREE.Float32BufferAttribute( uvs, 2 ) );
														
 
															-			var d0 = v0.vertex.dot( p ) - size,
														
 
															-				d1 = v1.vertex.dot( p ) - size;
														
 
															+  	function generate() {
														
 
															-			var s = d0 / ( d0 - d1 );
														
 
															-			var v = new THREE.DecalVertex(
														
 
															-				new THREE.Vector3(
														
 
															-					v0.vertex.x + s * ( v1.vertex.x - v0.vertex.x ),
														
 
															-					v0.vertex.y + s * ( v1.vertex.y - v0.vertex.y ),
														
 
															-					v0.vertex.z + s * ( v1.vertex.z - v0.vertex.z )
														
 
															-				),
														
 
															-				new THREE.Vector3(
														
 
															-					v0.normal.x + s * ( v1.normal.x - v0.normal.x ),
														
 
															-					v0.normal.y + s * ( v1.normal.y - v0.normal.y ),
														
 
															-					v0.normal.z + s * ( v1.normal.z - v0.normal.z )
														
 
															-				)
														
 
															-			);
														
 
															+  		var i, j;
														
 
															+  		var geometry = new THREE.BufferGeometry();
														
 
															+  		var decalVertices = [];
														
 
															-			// need to clip more values (texture coordinates)? do it this way:
														
 
															-			//intersectpoint.value = a.value + s*(b.value-a.value);
														
 
															+  		var vertex = new THREE.Vector3();
														
 
															+  		var normal = new THREE.Vector3();
														
 
															-			return v;
														
 
															+  		// handle different geometry types
														
 
															-		}
														
 
															+  		if ( mesh.geometry.isGeometry ) {
														
 
															-		if ( inVertices.length === 0 ) return [];
														
 
															-		var outVertices = [];
														
 
															+  			geometry.fromGeometry( mesh.geometry );
														
 
															-		for ( var j = 0; j < inVertices.length; j += 3 ) {
														
 
															+  		} else {
														
 
															-			var v1Out, v2Out, v3Out, total = 0;
														
 
															+  			geometry.copy( mesh.geometry );
														
 
															-			var d1 = inVertices[ j + 0 ].vertex.dot( plane ) - size,
														
 
															-				d2 = inVertices[ j + 1 ].vertex.dot( plane ) - size,
														
 
															-				d3 = inVertices[ j + 2 ].vertex.dot( plane ) - size;
														
 
															+  		}
														
 
															-			v1Out = d1 > 0;
														
 
															-			v2Out = d2 > 0;
														
 
															-			v3Out = d3 > 0;
														
 
															+  		var positionAttribute = geometry.attributes.position;
														
 
															+  		var normalAttribute = geometry.attributes.normal;
														
 
															-			total = ( v1Out ? 1 : 0 ) + ( v2Out ? 1 : 0 ) + ( v3Out ? 1 : 0 );
														
 
															+  		// first, create an array of 'DecalVertex' objects
														
 
															+  		// three consecutive 'DecalVertex' objects represent a single face
														
 
															+  		//
														
 
															+  		// this data structure will be later used to perform the clipping
														
 
															-			switch ( total ) {
														
 
															-				case 0: {
														
 
															+  		if ( geometry.index !== null ) {
														
 
															-					outVertices.push( inVertices[ j ] );
														
 
															-					outVertices.push( inVertices[ j + 1 ] );
														
 
															-					outVertices.push( inVertices[ j + 2 ] );
														
 
															-					break;
														
 
															+  			// indexed BufferGeometry
														
 
															-				}
														
 
															-				case 1: {
														
 
															+  			var index = geometry.index;
														
 
															-					var nV1, nV2, nV3, nV4;
														
 
															-					if ( v1Out ) {
														
 
															+  			for ( i = 0; i < index.count; i ++ ) {
														
 
															-						nV1 = inVertices[ j + 1 ];
														
 
															-						nV2 = inVertices[ j + 2 ];
														
 
															-						nV3 = clip( inVertices[ j ], nV1, plane );
														
 
															-						nV4 = clip( inVertices[ j ], nV2, plane );
														
 
															+  				vertex.fromBufferAttribute( positionAttribute, index.getX( i ) );
														
 
															+  				normal.fromBufferAttribute( normalAttribute, index.getX( i ) );
														
 
															-					}
														
 
															-					if ( v2Out ) {
														
 
															+  				pushDecalVertex( decalVertices, vertex, normal );
														
 
															-						nV1 = inVertices[ j ];
														
 
															-						nV2 = inVertices[ j + 2 ];
														
 
															-						nV3 = clip( inVertices[ j + 1 ], nV1, plane );
														
 
															-						nV4 = clip( inVertices[ j + 1 ], nV2, plane );
														
 
															+  			}
														
 
															-						outVertices.push( nV3 );
														
 
															-						outVertices.push( nV2.clone() );
														
 
															-						outVertices.push( nV1.clone() );
														
 
															+  		} else {
														
 
															-						outVertices.push( nV2.clone() );
														
 
															-						outVertices.push( nV3.clone() );
														
 
															-						outVertices.push( nV4 );
														
 
															-						break;
														
 
															+  			// non-indexed BufferGeometry
														
 
															-					}
														
 
															-					if ( v3Out ) {
														
 
															+  			for ( i = 0; i < positionAttribute.count; i ++ ) {
														
 
															-						nV1 = inVertices[ j ];
														
 
															-						nV2 = inVertices[ j + 1 ];
														
 
															-						nV3 = clip( inVertices[ j + 2 ], nV1, plane );
														
 
															-						nV4 = clip( inVertices[ j + 2 ], nV2, plane );
														
 
															+  				vertex.fromBufferAttribute( positionAttribute, i );
														
 
															+  				normal.fromBufferAttribute( normalAttribute, i );
														
 
															-					}
														
 
															+  				pushDecalVertex( decalVertices, vertex, normal );
														
 
															-					outVertices.push( nV1.clone() );
														
 
															-					outVertices.push( nV2.clone() );
														
 
															-					outVertices.push( nV3 );
														
 
															+  			}
														
 
															-					outVertices.push( nV4 );
														
 
															-					outVertices.push( nV3.clone() );
														
 
															-					outVertices.push( nV2.clone() );
														
 
															+  		}
														
 
															-					break;
														
 
															+  		// second, clip the geometry so that it doesn't extend out from the projector
														
 
															-				}
														
 
															-				case 2: {
														
 
															+  		decalVertices = clipGeometry( decalVertices, plane.set(   1,   0,   0 ) );
														
 
															+  		decalVertices = clipGeometry( decalVertices, plane.set( - 1,   0,   0 ) );
														
 
															+  		decalVertices = clipGeometry( decalVertices, plane.set(   0,   1,   0 ) );
														
 
															+  		decalVertices = clipGeometry( decalVertices, plane.set(   0, - 1,   0 ) );
														
 
															+  		decalVertices = clipGeometry( decalVertices, plane.set(   0,   0,   1 ) );
														
 
															+  		decalVertices = clipGeometry( decalVertices, plane.set(   0,   0, - 1 ) );
														
 
															-					var nV1, nV2, nV3;
														
 
															-					if ( ! v1Out ) {
														
 
															+  		// third, generate final vertices, normals and uvs
														
 
															-						nV1 = inVertices[ j ].clone();
														
 
															-						nV2 = clip( nV1, inVertices[ j + 1 ], plane );
														
 
															-						nV3 = clip( nV1, inVertices[ j + 2 ], plane );
														
 
															-						outVertices.push( nV1 );
														
 
															-						outVertices.push( nV2 );
														
 
															-						outVertices.push( nV3 );
														
 
															+  		for ( i = 0; i < decalVertices.length; i ++ ) {
														
 
															-					}
														
 
															-					if ( ! v2Out ) {
														
 
															+  			var decalVertex = decalVertices[ i ];
														
 
															-						nV1 = inVertices[ j + 1 ].clone();
														
 
															-						nV2 = clip( nV1, inVertices[ j + 2 ], plane );
														
 
															-						nV3 = clip( nV1, inVertices[ j ], plane );
														
 
															-						outVertices.push( nV1 );
														
 
															-						outVertices.push( nV2 );
														
 
															-						outVertices.push( nV3 );
														
 
															+  			// create texture coordinates (we are still in projector space)
														
 
															-					}
														
 
															-					if ( ! v3Out ) {
														
 
															+  			uvs.push(
														
 
															+  				0.5 + ( decalVertex.position.x / size.x ),
														
 
															+  				0.5 + ( decalVertex.position.y / size.y )
														
 
															+  			);
														
 
															-						nV1 = inVertices[ j + 2 ].clone();
														
 
															-						nV2 = clip( nV1, inVertices[ j ], plane );
														
 
															-						nV3 = clip( nV1, inVertices[ j + 1 ], plane );
														
 
															-						outVertices.push( nV1 );
														
 
															-						outVertices.push( nV2 );
														
 
															-						outVertices.push( nV3 );
														
 
															+  			// transform the vertex back to world space
														
 
															-					}
														
 
															+  			decalVertex.position.applyMatrix4( projectorMatrix );
														
 
															-					break;
														
 
															+  			// now create vertex and normal buffer data
														
 
															-				}
														
 
															-				case 3: {
														
 
															+  			vertices.push( decalVertex.position.x, decalVertex.position.y, decalVertex.position.z );
														
 
															+  			normals.push( decalVertex.normal.x, decalVertex.normal.y, decalVertex.normal.z );
														
 
															-					break;
														
 
															+  		}
														
 
															-				}
														
 
															-			}
														
 
															+  	}
														
 
															-		}
														
 
															+  	function pushDecalVertex( decalVertices, vertex, normal ) {
														
 
															-		return outVertices;
														
 
															+  		// transform the vertex to world space, then to projector space
														
 
															-	};
														
 
															+  		vertex.applyMatrix4( mesh.matrix );
														
 
															+  		vertex.applyMatrix4( projectorMatrixInverse );
														
 
															-	this.pushVertex = function( vertices, id, n ) {
														
 
															+  		decalVertices.push( new DecalVertex( vertex.clone(), normal.clone() ) );
														
 
															-		var v = mesh.geometry.vertices[ id ].clone();
														
 
															-		v.applyMatrix4( mesh.matrix );
														
 
															-		v.applyMatrix4( this.iCubeMatrix );
														
 
															-		vertices.push( new THREE.DecalVertex( v, n.clone() ) );
														
 
															+  	}
														
 
															-	};
														
 
															+  	function clipGeometry( inVertices, plane ) {
														
 
															-	this.computeDecal = function() {
														
 
															+  		var outVertices = [];
														
 
															-		var finalVertices = [];
														
 
															+  		var s = 0.5 * Math.abs( size.dot( plane ) );
														
 
															-		for ( var i = 0; i < mesh.geometry.faces.length; i ++ ) {
														
 
															+  		// a single iteration clips one face,
														
 
															+  		// which consists of three consecutive 'DecalVertex' objects
														
 
															-			var f = mesh.geometry.faces[ i ];
														
 
															-			var vertices = [];
														
 
															+  		for ( var i = 0; i < inVertices.length; i += 3 ) {
														
 
															-			this.pushVertex( vertices, f[ this.faceIndices[ 0 ] ], f.vertexNormals[ 0 ] );
														
 
															-			this.pushVertex( vertices, f[ this.faceIndices[ 1 ] ], f.vertexNormals[ 1 ] );
														
 
															-			this.pushVertex( vertices, f[ this.faceIndices[ 2 ] ], f.vertexNormals[ 2 ] );
														
 
															+  			var v1Out, v2Out, v3Out, total = 0;
														
 
															+  			var nV1, nV2, nV3, nV4;
														
 
															-			if ( check.x ) {
														
 
															+  			var d1 = inVertices[ i + 0 ].position.dot( plane ) - s;
														
 
															+  			var d2 = inVertices[ i + 1 ].position.dot( plane ) - s;
														
 
															+  			var d3 = inVertices[ i + 2 ].position.dot( plane ) - s;
														
 
															-				vertices = this.clipFace( vertices, new THREE.Vector3( 1, 0, 0 ) );
														
 
															-				vertices = this.clipFace( vertices, new THREE.Vector3( - 1, 0, 0 ) );
														
 
															+  			v1Out = d1 > 0;
														
 
															+  			v2Out = d2 > 0;
														
 
															+  			v3Out = d3 > 0;
														
 
															-			}
														
 
															-			if ( check.y ) {
														
 
															+  			// calculate, how many vertices of the face lie outside of the clipping plane
														
 
															-				vertices = this.clipFace( vertices, new THREE.Vector3( 0, 1, 0 ) );
														
 
															-				vertices = this.clipFace( vertices, new THREE.Vector3( 0, - 1, 0 ) );
														
 
															+  			total = ( v1Out ? 1 : 0 ) + ( v2Out ? 1 : 0 ) + ( v3Out ? 1 : 0 );
														
 
															-			}
														
 
															-			if ( check.z ) {
														
 
															+  			switch ( total ) {
														
 
															-				vertices = this.clipFace( vertices, new THREE.Vector3( 0, 0, 1 ) );
														
 
															-				vertices = this.clipFace( vertices, new THREE.Vector3( 0, 0, - 1 ) );
														
 
															+  				case 0: {
														
 
															-			}
														
 
															+  					// the entire face lies inside of the plane, no clipping needed
														
 
															-			for ( var j = 0; j < vertices.length; j ++ ) {
														
 
															+  					outVertices.push( inVertices[ i ] );
														
 
															+  					outVertices.push( inVertices[ i + 1 ] );
														
 
															+  					outVertices.push( inVertices[ i + 2 ] );
														
 
															+  					break;
														
 
															-				var v = vertices[ j ];
														
 
															+  				}
														
 
															-				this.uvs.push( new THREE.Vector2(
														
 
															-					.5 + ( v.vertex.x / dimensions.x ),
														
 
															-					.5 + ( v.vertex.y / dimensions.y )
														
 
															-				) );
														
 
															+  				case 1: {
														
 
															-				vertices[ j ].vertex.applyMatrix4( this.cube.matrix );
														
 
															+  					// one vertex lies outside of the plane, perform clipping
														
 
															-			}
														
 
															+  					if ( v1Out ) {
														
 
															-			if ( vertices.length === 0 ) continue;
														
 
															+  						nV1 = inVertices[ i + 1 ];
														
 
															+  						nV2 = inVertices[ i + 2 ];
														
 
															+  						nV3 = clip( inVertices[ i ], nV1, plane, s );
														
 
															+  						nV4 = clip( inVertices[ i ], nV2, plane, s );
														
 
															-			finalVertices = finalVertices.concat( vertices );
														
 
															+  					}
														
 
															-		}
														
 
															+  					if ( v2Out ) {
														
 
															-		for ( var k = 0; k < finalVertices.length; k += 3 ) {
														
 
															+  						nV1 = inVertices[ i ];
														
 
															+  						nV2 = inVertices[ i + 2 ];
														
 
															+  						nV3 = clip( inVertices[ i + 1 ], nV1, plane, s );
														
 
															+  						nV4 = clip( inVertices[ i + 1 ], nV2, plane, s );
														
 
															-			this.vertices.push(
														
 
															-				finalVertices[ k ].vertex,
														
 
															-				finalVertices[ k + 1 ].vertex,
														
 
															-				finalVertices[ k + 2 ].vertex
														
 
															-			);
														
 
															+  						outVertices.push( nV3 );
														
 
															+  						outVertices.push( nV2.clone() );
														
 
															+  						outVertices.push( nV1.clone() );
														
 
															-			var f = new THREE.Face3(
														
 
															-				k,
														
 
															-				k + 1,
														
 
															-				k + 2
														
 
															-			);
														
 
															-			f.vertexNormals.push( finalVertices[ k + 0 ].normal );
														
 
															-			f.vertexNormals.push( finalVertices[ k + 1 ].normal );
														
 
															-			f.vertexNormals.push( finalVertices[ k + 2 ].normal );
														
 
															+  						outVertices.push( nV2.clone() );
														
 
															+  						outVertices.push( nV3.clone() );
														
 
															+  						outVertices.push( nV4 );
														
 
															+  						break;
														
 
															-			this.faces.push( f );
														
 
															+  					}
														
 
															-			this.faceVertexUvs[ 0 ].push( [
														
 
															-				this.uvs[ k ],
														
 
															-				this.uvs[ k + 1 ],
														
 
															-				this.uvs[ k + 2 ]
														
 
															-			] );
														
 
															+  					if ( v3Out ) {
														
 
															-		}
														
 
															+  						nV1 = inVertices[ i ];
														
 
															+  						nV2 = inVertices[ i + 1 ];
														
 
															+  						nV3 = clip( inVertices[ i + 2 ], nV1, plane, s );
														
 
															+  						nV4 = clip( inVertices[ i + 2 ], nV2, plane, s );
														
 
															-		this.verticesNeedUpdate = true;
														
 
															-		this.elementsNeedUpdate = true;
														
 
															-		this.morphTargetsNeedUpdate = true;
														
 
															-		this.uvsNeedUpdate = true;
														
 
															-		this.normalsNeedUpdate = true;
														
 
															-		this.colorsNeedUpdate = true;
														
 
															-		this.computeFaceNormals();
														
 
															+  					}
														
 
															-	};
														
 
															+  					outVertices.push( nV1.clone() );
														
 
															+  					outVertices.push( nV2.clone() );
														
 
															+  					outVertices.push( nV3 );
														
 
															-	this.computeDecal();
														
 
															+  					outVertices.push( nV4 );
														
 
															+  					outVertices.push( nV3.clone() );
														
 
															+  					outVertices.push( nV2.clone() );
														
 
															-};
														
 
															+  					break;
														
 
															-THREE.DecalGeometry.prototype = Object.create( THREE.Geometry.prototype );
														
 
															-THREE.DecalGeometry.prototype.constructor = THREE.DecalGeometry;
														
 
															+  				}
														
 
															+
														
 
															+  				case 2: {
														
 
															+
														
 
															+  					// two vertices lies outside of the plane, perform clipping
														
 
															+
														
 
															+  					if ( ! v1Out ) {
														
 
															+
														
 
															+  						nV1 = inVertices[ i ].clone();
														
 
															+  						nV2 = clip( nV1, inVertices[ i + 1 ], plane, s );
														
 
															+  						nV3 = clip( nV1, inVertices[ i + 2 ], plane, s );
														
 
															+  						outVertices.push( nV1 );
														
 
															+  						outVertices.push( nV2 );
														
 
															+  						outVertices.push( nV3 );
														
 
															+
														
 
															+  					}
														
 
															+
														
 
															+  					if ( ! v2Out ) {
														
 
															+
														
 
															+  						nV1 = inVertices[ i + 1 ].clone();
														
 
															+  						nV2 = clip( nV1, inVertices[ i + 2 ], plane, s );
														
 
															+  						nV3 = clip( nV1, inVertices[ i ], plane, s );
														
 
															+  						outVertices.push( nV1 );
														
 
															+  						outVertices.push( nV2 );
														
 
															+  						outVertices.push( nV3 );
														
 
															+
														
 
															+  					}
														
 
															+
														
 
															+  					if ( ! v3Out ) {
														
 
															+
														
 
															+  						nV1 = inVertices[ i + 2 ].clone();
														
 
															+  						nV2 = clip( nV1, inVertices[ i ], plane, s );
														
 
															+  						nV3 = clip( nV1, inVertices[ i + 1 ], plane, s );
														
 
															+  						outVertices.push( nV1 );
														
 
															+  						outVertices.push( nV2 );
														
 
															+  						outVertices.push( nV3 );
														
 
															+
														
 
															+  					}
														
 
															+
														
 
															+  					break;
														
 
															+
														
 
															+  				}
														
 
															+
														
 
															+  				case 3: {
														
 
															+
														
 
															+  					// the entire face lies outside of the plane, so let's discard the corresponding vertices
														
 
															+
														
 
															+  					break;
														
 
															+
														
 
															+  				}
														
 
															+
														
 
															+  			}
														
 
															+
														
 
															+  		}
														
 
															+
														
 
															+  		return outVertices;
														
 
															+
														
 
															+  	}
														
 
															+
														
 
															+  	function clip( v0, v1, p, s ) {
														
 
															+
														
 
															+  		var d0 = v0.position.dot( p ) - s;
														
 
															+  		var d1 = v1.position.dot( p ) - s;
														
 
															+
														
 
															+  		var s0 = d0 / ( d0 - d1 );
														
 
															+
														
 
															+  		var v = new DecalVertex(
														
 
															+  			new THREE.Vector3(
														
 
															+  				v0.position.x + s0 * ( v1.position.x - v0.position.x ),
														
 
															+  				v0.position.y + s0 * ( v1.position.y - v0.position.y ),
														
 
															+  				v0.position.z + s0 * ( v1.position.z - v0.position.z )
														
 
															+  			),
														
 
															+  			new THREE.Vector3(
														
 
															+  				v0.normal.x + s0 * ( v1.normal.x - v0.normal.x ),
														
 
															+  				v0.normal.y + s0 * ( v1.normal.y - v0.normal.y ),
														
 
															+  				v0.normal.z + s0 * ( v1.normal.z - v0.normal.z )
														
 
															+  			)
														
 
															+  		);
														
 
															+
														
 
															+  		// need to clip more values (texture coordinates)? do it this way:
														
 
															+  		// intersectpoint.value = a.value + s * ( b.value - a.value );
														
 
															+
														
 
															+  		return v;
														
 
															+
														
 
															+  	}
														
 
															+
														
 
															+  }
														
 
															+
														
 
															+  DecalGeometry.prototype = Object.create( THREE.BufferGeometry.prototype );
														
 
															+  DecalGeometry.prototype.constructor = DecalGeometry;
														
 
															+
														
 
															+  // helper
														
 
															+
														
 
															+  function DecalVertex( position, normal ) {
														
 
															+
														
 
															+  	this.position = position;
														
 
															+  	this.normal = normal;
														
 
															+
														
 
															+  }
														
 
															+
														
 
															+  DecalVertex.prototype.clone = function() {
														
 
															+
														
 
															+  	return new DecalVertex( this.position.clone(), this.normal.clone() );
														
 
															+
														
 
															+  };
														
 
															+
														
 
															+  // export
														
 
															+
														
 
															+  THREE.DecalGeometry = DecalGeometry;
														
 
															+
														
 
															+} ) ();
														
--- a/examples/js/lights/RectAreaLightUniformsLib.js
+++ b/examples/js/lights/RectAreaLightUniformsLib.js
@@ -27,8 +27,6 @@
 
															 	//
														
 
															-	var UniformsLib = THREE.UniformsLib;
														
 
															-	var ShaderLib = THREE.ShaderLib;
														
 
															 	var LTC_MAT_TEXTURE = new THREE.DataTexture(
														
 
															 			new Float32Array( LTC_MAT ),
														
@@ -47,15 +45,12 @@
 
															 	LTC_MAT_TEXTURE.needsUpdate = true;
														
 
															 	LTC_MAG_TEXTURE.needsUpdate = true;
														
 
															-	THREE.UniformsLib.LTC_MAT_TEXTURE = LTC_MAT_TEXTURE;
														
 
															-	THREE.UniformsLib.LTC_MAG_TEXTURE = LTC_MAG_TEXTURE;
														
 
															-
														
 
															 	// Add ltc tables to materials
														
 
															-	var ltc_brdf = { ltcMat: { value: null }, ltcMag: { value: null } };
														
 
															+	var ltc_brdf = { ltcMat: { value: LTC_MAT_TEXTURE }, ltcMag: { value: LTC_MAT_TEXTURE } };
														
 
															-	Object.assign( ShaderLib.phong.uniforms, ltc_brdf );
														
 
															-	Object.assign( ShaderLib.standard.uniforms, ltc_brdf );
														
 
															-	Object.assign( ShaderLib.physical.uniforms, ltc_brdf );
														
 
															+	Object.assign( THREE.ShaderLib.phong.uniforms, ltc_brdf );
														
 
															+	Object.assign( THREE.ShaderLib.standard.uniforms, ltc_brdf );
														
 
															+	Object.assign( THREE.ShaderLib.physical.uniforms, ltc_brdf );
														
 
															 } )()
														
--- a/examples/js/loaders/AssimpLoader.js
+++ b/examples/js/loaders/AssimpLoader.js
@@ -635,6 +635,7 @@
 
															 			var skeleton = new THREE.Skeleton( allBones, offsetMatrix );

														
 
															 			this.threeNode.bind( skeleton, new THREE.Matrix4() );

														
 
															+			this.threeNode.material.skinning = true;

														
 
															 		};

														
@@ -1849,7 +1850,7 @@
 
															 					}

														
 
															-

														
 
															+					

														
 
															 				}

														
@@ -1872,7 +1873,7 @@
 
															 				} else {

														
 
															 					throw ( new Error( "Sorry, can't currently triangulate polys. Use the triangulate preprocessor in Assimp." ))

														
 
															-

														
 
															+					

														
 
															 				}

														
@@ -2349,4 +2350,4 @@
 
															 	THREE.AssimpLoader = AssimpLoader;

														
 
															-} )();

														
 
															+} )();
														
--- a/examples/js/loaders/ColladaLoader.js
+++ b/examples/js/loaders/ColladaLoader.js
@@ -1197,7 +1197,18 @@ THREE.ColladaLoader = function () {
 
															 					applySkin( geom, skinController );
														
 
															-					material.morphTargets = geom.morphTargets.length > 0;
														
 
															+					if ( geom.morphTargets.length > 0 ) {
														
 
															+
														
 
															+						material.morphTargets = true;
														
 
															+						material.skinning = false;
														
 
															+
														
 
															+					} else {
														
 
															+
														
 
															+						material.morphTargets = false;
														
 
															+						material.skinning = true;
														
 
															+
														
 
															+					}
														
 
															+
														
 
															 					mesh = new THREE.SkinnedMesh( geom, material, false );
														
--- a/examples/js/loaders/ColladaLoader2.js
+++ b/examples/js/loaders/ColladaLoader2.js
@@ -1439,7 +1439,8 @@ THREE.ColladaLoader.prototype = {
 
															 			}
														
 
															 			object.name = data.name;
														
 
															-			matrix.decompose( object.position, object.quaternion, object.scale );
														
 
															+			object.matrix.copy( matrix );
														
 
															+			object.matrix.decompose( object.position, object.quaternion, object.scale );
														
 
															 			return object;
														
--- a/examples/js/loaders/FBXLoader.js
+++ b/examples/js/loaders/FBXLoader.js
@@ -464,6 +464,20 @@
 
															 			if ( geometry.bones !== undefined && geometry.skinWeights !== undefined && geometry.skinWeights.length > 0 ) {
														
 
															+				if ( material instanceof THREE.MultiMaterial ) {
														
 
															+
														
 
															+					for ( var i = 0; i < material.materials.length; ++ i ) {
														
 
															+
														
 
															+						material.materials[ i ].skinning = true;
														
 
															+
														
 
															+					}
														
 
															+
														
 
															+				} else {
														
 
															+
														
 
															+					material.skinning = true;
														
 
															+
														
 
															+				}
														
 
															+
														
 
															 				mesh = new THREE.SkinnedMesh( geometry, material );
														
 
															 			} else {
														
--- a/examples/js/loaders/FBXLoader2.js
+++ b/examples/js/loaders/FBXLoader2.js
@@ -1224,6 +1224,11 @@
 
															 								}
														
 
															 								if ( geometry.FBX_Deformer ) {
														
 
															+									for ( var materialsIndex = 0, materialsLength = materials.length; materialsIndex < materialsLength; ++ materialsIndex ) {
														
 
															+
														
 
															+										materials[ materialsIndex ].skinning = true;
														
 
															+
														
 
															+									}
														
 
															 									model = new THREE.SkinnedMesh( geometry, material );
														
 
															 								} else {
														
--- a/examples/js/loaders/GLTF2Loader.js
+++ b/examples/js/loaders/GLTF2Loader.js
@@ -136,15 +136,6 @@ THREE.GLTF2Loader = ( function () {
 
															 			update: function ( scene, camera ) {
														
 
															-				// update scene graph
														
 
															-
														
 
															-				scene.updateMatrixWorld();
														
 
															-
														
 
															-				// update camera matrices and frustum
														
 
															-
														
 
															-				camera.updateMatrixWorld();
														
 
															-				camera.matrixWorldInverse.getInverse( camera.matrixWorld );
														
 
															-
														
 
															 				for ( var name in objects ) {
														
 
															 					var object = objects[ name ];
														
@@ -163,10 +154,6 @@ THREE.GLTF2Loader = ( function () {
 
															 	}
														
 
															-	/* GLTFSHADERS */
														
 
															-
														
 
															-	GLTF2Loader.Shaders = new GLTFRegistry();
														
 
															-
														
 
															 	/* GLTFSHADER */
														
 
															 	function GLTFShader( targetNode, allNodes ) {
														
@@ -568,9 +555,9 @@ THREE.GLTF2Loader = ( function () {
 
															 						value.then( function( key, value ) {
														
 
															-							results[ idx ] = value;
														
 
															+							results[ key ] = value;
														
 
															-						}.bind( this, key ));
														
 
															+						}.bind( this, idx ));
														
 
															 					} else {
														
@@ -632,8 +619,8 @@ THREE.GLTF2Loader = ( function () {
 
															 		if ( typeof url !== 'string' || url === '' )
														
 
															 			return '';
														
 
															-		// Absolute URL
														
 
															-		if ( /^https?:\/\//i.test( url ) ) {
														
 
															+		// Absolute URL http://,https://,//
														
 
															+		if ( /^(https?:)?\/\//i.test( url ) ) {
														
 
															 			return url;
														
@@ -1063,7 +1050,7 @@ THREE.GLTF2Loader = ( function () {
 
															 			return _each( json.textures, function ( texture ) {
														
 
															-				if ( texture.source ) {
														
 
															+				if ( texture.source !== undefined ) {
														
 
															 					return new Promise( function ( resolve ) {
														
@@ -1103,7 +1090,7 @@ THREE.GLTF2Loader = ( function () {
 
															 							_texture.type = texture.type !== undefined ? WEBGL_TEXTURE_DATATYPES[ texture.type ] : THREE.UnsignedByteType;
														
 
															-							if ( texture.sampler ) {
														
 
															+							if ( texture.sampler !== undefined ) {
														
 
															 								var sampler = json.samplers[ texture.sampler ];
														
@@ -1573,7 +1560,7 @@ THREE.GLTF2Loader = ( function () {
 
															 			return _each( json.meshes, function ( mesh ) {
														
 
															-				var group = new THREE.Object3D();
														
 
															+				var group = new THREE.Group();
														
 
															 				if ( mesh.name !== undefined ) group.name = mesh.name;
														
 
															 				if ( mesh.extras ) group.userData = mesh.extras;
														
@@ -1594,7 +1581,7 @@ THREE.GLTF2Loader = ( function () {
 
															 							var attributeEntry = attributes[ attributeId ];
														
 
															-							if ( ! attributeEntry ) return;
														
 
															+							if ( attributeEntry === undefined ) return;
														
 
															 							var bufferAttribute = dependencies.accessors[ attributeEntry ];
														
@@ -1632,7 +1619,7 @@ THREE.GLTF2Loader = ( function () {
 
															 						}
														
 
															-						if ( primitive.indices ) {
														
 
															+						if ( primitive.indices !== undefined ) {
														
 
															 							geometry.setIndex( dependencies.accessors[ primitive.indices ] );
														
@@ -1682,7 +1669,7 @@ THREE.GLTF2Loader = ( function () {
 
															 						var meshNode;
														
 
															-						if ( primitive.indices ) {
														
 
															+						if ( primitive.indices !== undefined ) {
														
 
															 							geometry.setIndex( dependencies.accessors[ primitive.indices ] );
														
@@ -1923,11 +1910,25 @@ THREE.GLTF2Loader = ( function () {
 
															 					var node = json.nodes[ nodeId ];
														
 
															-					if ( node.meshes !== undefined ) {
														
 
															+					var meshes;
														
 
															+
														
 
															+					if ( node.mesh !== undefined) {
														
 
															+
														
 
															+						meshes = [ node.mesh ];
														
 
															+
														
 
															+					} else if ( node.meshes !== undefined ) {
														
 
															+
														
 
															+						console.warn( 'GLTF2Loader: Legacy glTF file detected. Nodes may have no more than 1 mesh.' );
														
 
															+
														
 
															+						meshes = node.meshes;
														
 
															+
														
 
															+					}
														
 
															+
														
 
															+					if ( meshes !== undefined ) {
														
 
															-						for ( var meshId in node.meshes ) {
														
 
															+						for ( var meshId in meshes ) {
														
 
															-							var mesh = node.meshes[ meshId ];
														
 
															+							var mesh = meshes[ meshId ];
														
 
															 							var group = dependencies.meshes[ mesh ];
														
 
															 							if ( group === undefined ) {
														
@@ -1985,7 +1986,7 @@ THREE.GLTF2Loader = ( function () {
 
															 								var skinEntry;
														
 
															-								if ( node.skin ) {
														
 
															+								if ( node.skin !== undefined ) {
														
 
															 									skinEntry = dependencies.skins[ node.skin ];
														
@@ -2012,6 +2013,7 @@ THREE.GLTF2Loader = ( function () {
 
															 									var geometry = originalGeometry;
														
 
															 									var material = originalMaterial;
														
 
															+									material.skinning = true;
														
 
															 									child = new THREE.SkinnedMesh( geometry, material, false );
														
 
															 									child.castShadow = true;
														
@@ -2163,8 +2165,10 @@ THREE.GLTF2Loader = ( function () {
 
															 					// Register raw material meshes with GLTF2Loader.Shaders
														
 
															 					if ( child.material && child.material.isRawShaderMaterial ) {
														
 
															-						var xshader = new GLTFShader( child, dependencies.nodes );
														
 
															-						GLTF2Loader.Shaders.add( child.uuid, xshader );
														
 
															+						child.gltfShader = new GLTFShader( child, dependencies.nodes );
														
 
															+						child.onBeforeRender = function(renderer, scene, camera){
														
 
															+							this.gltfShader.update(scene, camera);
														
 
															+						};
														
 
															 					}
														
--- a/examples/js/loaders/GLTFLoader.js
+++ b/examples/js/loaders/GLTFLoader.js
@@ -135,15 +135,6 @@ THREE.GLTFLoader = ( function () {
 
															 			update: function ( scene, camera ) {
														
 
															-				// update scene graph
														
 
															-
														
 
															-				scene.updateMatrixWorld();
														
 
															-
														
 
															-				// update camera matrices and frustum
														
 
															-
														
 
															-				camera.updateMatrixWorld();
														
 
															-				camera.matrixWorldInverse.getInverse( camera.matrixWorld );
														
 
															-
														
 
															 				for ( var name in objects ) {
														
 
															 					var object = objects[ name ];
														
@@ -164,7 +155,15 @@ THREE.GLTFLoader = ( function () {
 
															 	/* GLTFSHADERS */
														
 
															-	GLTFLoader.Shaders = new GLTFRegistry();
														
 
															+	GLTFLoader.Shaders = {
														
 
															+
														
 
															+		update: function () {
														
 
															+
														
 
															+			console.warn( 'THREE.GLTFLoader.Shaders has been deprecated, and now updates automatically.' );
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+	};
														
 
															 	/* GLTFSHADER */
														
@@ -580,9 +579,9 @@ THREE.GLTFLoader = ( function () {
 
															 						value.then( function( key, value ) {
														
 
															-							results[ idx ] = value;
														
 
															+							results[ key ] = value;
														
 
															-						}.bind( this, key ));
														
 
															+						}.bind( this, idx ));
														
 
															 					} else {
														
@@ -644,8 +643,8 @@ THREE.GLTFLoader = ( function () {
 
															 		if ( typeof url !== 'string' || url === '' )
														
 
															 			return '';
														
 
															-		// Absolute URL
														
 
															-		if ( /^https?:\/\//i.test( url ) ) {
														
 
															+		// Absolute URL http://,https://,//
														
 
															+		if ( /^(https?:)?\/\//i.test( url ) ) {
														
 
															 			return url;
														
@@ -1109,7 +1108,7 @@ THREE.GLTFLoader = ( function () {
 
															 							if ( texture.internalFormat !== undefined && _texture.format !== WEBGL_TEXTURE_FORMATS[ texture.internalFormat ] ) {
														
 
															 								console.warn( 'THREE.GLTFLoader: Three.js doesn\'t support texture internalFormat which is different from texture format. ' +
														
 
															-								              'internalFormat will be forced to be the same value as format.' );
														
 
															+															'internalFormat will be forced to be the same value as format.' );
														
 
															 							}
														
@@ -1585,7 +1584,7 @@ THREE.GLTFLoader = ( function () {
 
															 			return _each( json.meshes, function ( mesh ) {
														
 
															-				var group = new THREE.Object3D();
														
 
															+				var group = new THREE.Group();
														
 
															 				if ( mesh.name !== undefined ) group.name = mesh.name;
														
 
															 				if ( mesh.extras ) group.userData = mesh.extras;
														
@@ -2024,6 +2023,7 @@ THREE.GLTFLoader = ( function () {
 
															 									var geometry = originalGeometry;
														
 
															 									var material = originalMaterial;
														
 
															+									material.skinning = true;
														
 
															 									child = new THREE.SkinnedMesh( geometry, material, false );
														
 
															 									child.castShadow = true;
														
@@ -2175,8 +2175,10 @@ THREE.GLTFLoader = ( function () {
 
															 					// Register raw material meshes with GLTFLoader.Shaders
														
 
															 					if ( child.material && child.material.isRawShaderMaterial ) {
														
 
															-						var xshader = new GLTFShader( child, dependencies.nodes );
														
 
															-						GLTFLoader.Shaders.add( child.uuid, xshader );
														
 
															+						child.gltfShader = new GLTFShader( child, dependencies.nodes );
														
 
															+						child.onBeforeRender = function(renderer, scene, camera){
														
 
															+							this.gltfShader.update(scene, camera);
														
 
															+						};
														
 
															 					}
														
--- a/examples/js/loaders/MMDLoader.js
+++ b/examples/js/loaders/MMDLoader.js
@@ -495,7 +495,7 @@ THREE.MMDLoader.prototype.createMesh = function ( model, texturePath, onProgress
 
															 	var scope = this;
														
 
															 	var geometry = new THREE.BufferGeometry();
														
 
															-	var material = new THREE.MultiMaterial();
														
 
															+	var materials = [];
														
 
															 	var helper = new THREE.MMDLoader.DataCreationHelper();
														
 
															 	var buffer = {};
														
@@ -1118,6 +1118,7 @@ THREE.MMDLoader.prototype.createMesh = function ( model, texturePath, onProgress
 
															 			if ( p.name !== undefined ) m.name = p.name;
														
 
															+			m.skinning = geometry.bones.length > 0 ? true : false;
														
 
															 			m.morphTargets = geometry.morphTargets.length > 0 ? true : false;
														
 
															 			m.lights = true;
														
 
															 			m.side = ( model.metadata.format === 'pmx' && ( p2.flag & 0x1 ) === 1 ) ? THREE.DoubleSide : p.side;
														
@@ -1329,7 +1330,7 @@ THREE.MMDLoader.prototype.createMesh = function ( model, texturePath, onProgress
 
															 			}
														
 
															-			material.materials.push( m );
														
 
															+			materials.push( m );
														
 
															 		}
														
@@ -1353,7 +1354,7 @@ THREE.MMDLoader.prototype.createMesh = function ( model, texturePath, onProgress
 
															 					}
														
 
															-					var m = material.materials[ e.index ];
														
 
															+					var m = materials[ e.index ];
														
 
															 					if ( m.opacity !== e.diffuse[ 3 ] ) {
														
@@ -1498,7 +1499,7 @@ THREE.MMDLoader.prototype.createMesh = function ( model, texturePath, onProgress
 
															 	initPhysics();
														
 
															 	initGeometry();
														
 
															-	var mesh = new THREE.SkinnedMesh( geometry, material );
														
 
															+	var mesh = new THREE.SkinnedMesh( geometry, materials );
														
 
															 	// console.log( mesh ); // for console debug
														
--- a/examples/js/loaders/STLLoader.js
+++ b/examples/js/loaders/STLLoader.js
@@ -70,19 +70,23 @@ THREE.STLLoader.prototype = {
 
															 			}
														
 
															-			// some binary files will have different size from expected,
														
 
															-			// checking characters higher than ASCII to confirm is binary
														
 
															-			var fileLength = reader.byteLength;
														
 
															-			for ( var index = 0; index < fileLength; index ++ ) {
														
 
															+			// An ASCII STL data must begin with 'solid ' as the first six bytes.
														
 
															+			// However, ASCII STLs lacking the SPACE after the 'd' are known to be
														
 
															+			// plentiful.  So, check the first 5 bytes for 'solid'.
														
 
															-				if ( reader.getUint8( index, false ) > 127 ) {
														
 
															+			// US-ASCII ordinal values for 's', 'o', 'l', 'i', 'd'
														
 
															+			var solid = [ 115, 111, 108, 105, 100 ];
														
 
															-					return true;
														
 
															+			for ( var i = 0; i < 5; i ++ ) {
														
 
															-				}
														
 
															+				// If solid[ i ] does not match the i-th byte, then it is not an
														
 
															+				// ASCII STL; hence, it is binary and return true.
														
 
															-			}
														
 
															+				if ( solid[ i ] != reader.getUint8( i, false ) ) return true;
														
 
															+
														
 
															+ 			}
														
 
															+			// First 5 bytes read "solid"; declare it to be an ASCII STL
														
 
															 			return false;
														
 
															 		};
														
--- a/examples/js/loaders/sea3d/SEA3DLoader.js
+++ b/examples/js/loaders/sea3d/SEA3DLoader.js
@@ -1993,18 +1993,21 @@ THREE.SEA3D.prototype.readMesh = function ( sea ) {
 
															 				mats[ i ] = sea.material[ i ].tag;
														
 
															+				mats[ i ].skinning = skeleton != undefined;
														
 
															 				mats[ i ].morphTargets = uMorph;
														
 
															 				mats[ i ].morphNormals = uMorphNormal;
														
 
															 				mats[ i ].vertexColors = sea.geometry.color ? THREE.VertexColors : THREE.NoColors;
														
 
															 			}
														
 
															-			mat = new THREE.MultiMaterial( mats );
														
 
															+//			mat = new THREE.MultiMaterial( mats );
														
 
															+			mat = mats;
														
 
															 		} else {
														
 
															 			mat = sea.material[ 0 ].tag;
														
 
															+			mat.skinning = skeleton != undefined;
														
 
															 			mat.morphTargets = uMorph;
														
 
															 			mat.morphNormals = uMorphNormal;
														
 
															 			mat.vertexColors = sea.geometry.color ? THREE.VertexColors : THREE.NoColors;
														
--- a/examples/js/nodes/inputs/MirrorNode.js
+++ b/examples/js/nodes/inputs/MirrorNode.js
@@ -11,7 +11,7 @@ THREE.MirrorNode = function( renderer, camera, options ) {
 
															 	this.coord = new THREE.OperatorNode( this.textureMatrix, this.worldPosition, THREE.OperatorNode.MUL );
														
 
															 	this.coordResult = new THREE.OperatorNode( null, this.coord, THREE.OperatorNode.ADD );
														
 
															-	this.texture = new THREE.TextureNode( this.mirror.renderTarget.texture, this.coord, null, true );
														
 
															+	this.texture = new THREE.TextureNode( this.mirror.material.uniforms.mirrorSampler.value, this.coord, null, true );
														
 
															 };
														
--- a/examples/js/renderers/CanvasRenderer.js
+++ b/examples/js/renderers/CanvasRenderer.js
@@ -9,7 +9,7 @@ THREE.SpriteCanvasMaterial = function ( parameters ) {
 
															 	this.type = 'SpriteCanvasMaterial';
														
 
															 	this.color = new THREE.Color( 0xffffff );
														
 
															-	this.program = function ( context, color ) {};
														
 
															+	this.program = function () {};
														
 
															 	this.setValues( parameters );
														
@@ -17,6 +17,7 @@ THREE.SpriteCanvasMaterial = function ( parameters ) {
 
															 THREE.SpriteCanvasMaterial.prototype = Object.create( THREE.Material.prototype );
														
 
															 THREE.SpriteCanvasMaterial.prototype.constructor = THREE.SpriteCanvasMaterial;
														
 
															+THREE.SpriteCanvasMaterial.prototype.isSpriteCanvasMaterial = true;
														
 
															 THREE.SpriteCanvasMaterial.prototype.clone = function () {
														
@@ -39,78 +40,69 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 	parameters = parameters || {};
														
 
															 	var _this = this,
														
 
															-	_renderData, _elements, _lights,
														
 
															-	_projector = new THREE.Projector(),
														
 
															+		_renderData, _elements, _lights,
														
 
															+		_projector = new THREE.Projector(),
														
 
															-	_canvas = parameters.canvas !== undefined
														
 
															-			 ? parameters.canvas
														
 
															-			 : document.createElement( 'canvas' ),
														
 
															+		_canvas = parameters.canvas !== undefined
														
 
															+				 ? parameters.canvas
														
 
															+				 : document.createElement( 'canvas' ),
														
 
															-	_canvasWidth = _canvas.width,
														
 
															-	_canvasHeight = _canvas.height,
														
 
															-	_canvasWidthHalf = Math.floor( _canvasWidth / 2 ),
														
 
															-	_canvasHeightHalf = Math.floor( _canvasHeight / 2 ),
														
 
															+		_canvasWidth = _canvas.width,
														
 
															+		_canvasHeight = _canvas.height,
														
 
															+		_canvasWidthHalf = Math.floor( _canvasWidth / 2 ),
														
 
															+		_canvasHeightHalf = Math.floor( _canvasHeight / 2 ),
														
 
															-	_viewportX = 0,
														
 
															-	_viewportY = 0,
														
 
															-	_viewportWidth = _canvasWidth,
														
 
															-	_viewportHeight = _canvasHeight,
														
 
															+		_viewportX = 0,
														
 
															+		_viewportY = 0,
														
 
															+		_viewportWidth = _canvasWidth,
														
 
															+		_viewportHeight = _canvasHeight,
														
 
															-	_pixelRatio = 1,
														
 
															+		_pixelRatio = 1,
														
 
															-	_context = _canvas.getContext( '2d', {
														
 
															-		alpha: parameters.alpha === true
														
 
															-	} ),
														
 
															+		_context = _canvas.getContext( '2d', {
														
 
															+			alpha: parameters.alpha === true
														
 
															+		} ),
														
 
															-	_clearColor = new THREE.Color( 0x000000 ),
														
 
															-	_clearAlpha = parameters.alpha === true ? 0 : 1,
														
 
															+		_clearColor = new THREE.Color( 0x000000 ),
														
 
															+		_clearAlpha = parameters.alpha === true ? 0 : 1,
														
 
															-	_contextGlobalAlpha = 1,
														
 
															-	_contextGlobalCompositeOperation = 0,
														
 
															-	_contextStrokeStyle = null,
														
 
															-	_contextFillStyle = null,
														
 
															-	_contextLineWidth = null,
														
 
															-	_contextLineCap = null,
														
 
															-	_contextLineJoin = null,
														
 
															-	_contextLineDash = [],
														
 
															+		_contextGlobalAlpha = 1,
														
 
															+		_contextGlobalCompositeOperation = 0,
														
 
															+		_contextStrokeStyle = null,
														
 
															+		_contextFillStyle = null,
														
 
															+		_contextLineWidth = null,
														
 
															+		_contextLineCap = null,
														
 
															+		_contextLineJoin = null,
														
 
															+		_contextLineDash = [],
														
 
															-	_camera,
														
 
															+		_v1, _v2, _v3,
														
 
															-	_v1, _v2, _v3, _v4,
														
 
															-	_v5 = new THREE.RenderableVertex(),
														
 
															-	_v6 = new THREE.RenderableVertex(),
														
 
															+		_v1x, _v1y, _v2x, _v2y, _v3x, _v3y,
														
 
															-	_v1x, _v1y, _v2x, _v2y, _v3x, _v3y,
														
 
															-	_v4x, _v4y, _v5x, _v5y, _v6x, _v6y,
														
 
															+		_color = new THREE.Color(),
														
 
															-	_color = new THREE.Color(),
														
 
															-	_color1 = new THREE.Color(),
														
 
															-	_color2 = new THREE.Color(),
														
 
															-	_color3 = new THREE.Color(),
														
 
															-	_color4 = new THREE.Color(),
														
 
															+		_diffuseColor = new THREE.Color(),
														
 
															+		_emissiveColor = new THREE.Color(),
														
 
															-	_diffuseColor = new THREE.Color(),
														
 
															-	_emissiveColor = new THREE.Color(),
														
 
															+		_lightColor = new THREE.Color(),
														
 
															-	_lightColor = new THREE.Color(),
														
 
															+		_patterns = {},
														
 
															-	_patterns = {},
														
 
															+		_uvs,
														
 
															+		_uv1x, _uv1y, _uv2x, _uv2y, _uv3x, _uv3y,
														
 
															-	_image, _uvs,
														
 
															-	_uv1x, _uv1y, _uv2x, _uv2y, _uv3x, _uv3y,
														
 
															+		_clipBox = new THREE.Box2(),
														
 
															+		_clearBox = new THREE.Box2(),
														
 
															+		_elemBox = new THREE.Box2(),
														
 
															-	_clipBox = new THREE.Box2(),
														
 
															-	_clearBox = new THREE.Box2(),
														
 
															-	_elemBox = new THREE.Box2(),
														
 
															+		_ambientLight = new THREE.Color(),
														
 
															+		_directionalLights = new THREE.Color(),
														
 
															+		_pointLights = new THREE.Color(),
														
 
															-	_ambientLight = new THREE.Color(),
														
 
															-	_directionalLights = new THREE.Color(),
														
 
															-	_pointLights = new THREE.Color(),
														
 
															-
														
 
															-	_vector3 = new THREE.Vector3(), // Needed for PointLight
														
 
															-	_centroid = new THREE.Vector3(),
														
 
															-	_normal = new THREE.Vector3(),
														
 
															-	_normalViewMatrix = new THREE.Matrix3();
														
 
															+		_vector3 = new THREE.Vector3(), // Needed for PointLight
														
 
															+		_centroid = new THREE.Vector3(),
														
 
															+		_normal = new THREE.Vector3(),
														
 
															+		_normalViewMatrix = new THREE.Matrix3();
														
 
															 	/* TODO
														
 
															 	_canvas.mozImageSmoothingEnabled = false;
														
@@ -266,10 +258,10 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 			_clearBox.intersect( _clipBox );
														
 
															 			_clearBox.expandByScalar( 2 );
														
 
															-			_clearBox.min.x = _clearBox.min.x + _canvasWidthHalf;
														
 
															-			_clearBox.min.y =  - _clearBox.min.y + _canvasHeightHalf;		// higher y value !
														
 
															-			_clearBox.max.x = _clearBox.max.x + _canvasWidthHalf;
														
 
															-			_clearBox.max.y =  - _clearBox.max.y + _canvasHeightHalf;		// lower y value !
														
 
															+			_clearBox.min.x =   _clearBox.min.x + _canvasWidthHalf;
														
 
															+			_clearBox.min.y = - _clearBox.min.y + _canvasHeightHalf;		// higher y value !
														
 
															+			_clearBox.max.x =   _clearBox.max.x + _canvasWidthHalf;
														
 
															+			_clearBox.max.y = - _clearBox.max.y + _canvasHeightHalf;		// lower y value !
														
 
															 			if ( _clearAlpha < 1 ) {
														
@@ -312,7 +304,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 	this.render = function ( scene, camera ) {
														
 
															-		if ( camera instanceof THREE.Camera === false ) {
														
 
															+		if ( camera.isCamera === undefined ) {
														
 
															 			console.error( 'THREE.CanvasRenderer.render: camera is not an instance of THREE.Camera.' );
														
 
															 			return;
														
@@ -341,7 +333,6 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 		_renderData = _projector.projectScene( scene, camera, this.sortObjects, this.sortElements );
														
 
															 		_elements = _renderData.elements;
														
 
															 		_lights = _renderData.lights;
														
 
															-		_camera = camera;
														
 
															 		_normalViewMatrix.getNormalMatrix( camera.matrixWorldInverse );
														
@@ -454,17 +445,17 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 			var light = _lights[ l ];
														
 
															 			var lightColor = light.color;
														
 
															-			if ( light instanceof THREE.AmbientLight ) {
														
 
															+			if ( light.isAmbientLight ) {
														
 
															 				_ambientLight.add( lightColor );
														
 
															-			} else if ( light instanceof THREE.DirectionalLight ) {
														
 
															+			} else if ( light.isDirectionalLight ) {
														
 
															 				// for sprites
														
 
															 				_directionalLights.add( lightColor );
														
 
															-			} else if ( light instanceof THREE.PointLight ) {
														
 
															+			} else if ( light.isPointLight ) {
														
 
															 				// for sprites
														
@@ -484,7 +475,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 			_lightColor.copy( light.color );
														
 
															-			if ( light instanceof THREE.DirectionalLight ) {
														
 
															+			if ( light.isDirectionalLight ) {
														
 
															 				var lightPosition = _vector3.setFromMatrixPosition( light.matrixWorld ).normalize();
														
@@ -496,7 +487,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 				color.add( _lightColor.multiplyScalar( amount ) );
														
 
															-			} else if ( light instanceof THREE.PointLight ) {
														
 
															+			} else if ( light.isPointLight ) {
														
 
															 				var lightPosition = _vector3.setFromMatrixPosition( light.matrixWorld );
														
@@ -530,7 +521,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 		_elemBox.min.set( v1.x - dist, v1.y - dist );
														
 
															 		_elemBox.max.set( v1.x + dist, v1.y + dist );
														
 
															-		if ( material instanceof THREE.SpriteMaterial ) {
														
 
															+		if ( material.isSpriteMaterial ) {
														
 
															 			var texture = material.map;
														
@@ -586,7 +577,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 			}
														
 
															-		} else if ( material instanceof THREE.SpriteCanvasMaterial ) {
														
 
															+		} else if ( material.isSpriteCanvasMaterial ) {
														
 
															 			setStrokeStyle( material.color.getStyle() );
														
 
															 			setFillStyle( material.color.getStyle() );
														
@@ -600,6 +591,17 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 			_context.restore();
														
 
															+		} else if ( material.isPointsMaterial ) {
														
 
															+
														
 
															+			setFillStyle( material.color.getStyle() );
														
 
															+
														
 
															+			_context.save();
														
 
															+			_context.translate( v1.x, v1.y );
														
 
															+			if ( material.rotation !== 0 ) _context.rotate( material.rotation );
														
 
															+			_context.scale( scaleX * material.size, - scaleY * material.size );
														
 
															+			_context.fillRect( - 0.5, - 0.5, 1, 1 );
														
 
															+			_context.restore();
														
 
															+
														
 
															 		}
														
 
															 		/* DEBUG
														
@@ -623,7 +625,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 		_context.moveTo( v1.positionScreen.x, v1.positionScreen.y );
														
 
															 		_context.lineTo( v2.positionScreen.x, v2.positionScreen.y );
														
 
															-		if ( material instanceof THREE.LineBasicMaterial ) {
														
 
															+		if ( material.isLineBasicMaterial ) {
														
 
															 			setLineWidth( material.linewidth );
														
 
															 			setLineCap( material.linecap );
														
@@ -670,7 +672,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 			_context.stroke();
														
 
															 			_elemBox.expandByScalar( material.linewidth * 2 );
														
 
															-		} else if ( material instanceof THREE.LineDashedMaterial ) {
														
 
															+		} else if ( material.isLineDashedMaterial ) {
														
 
															 			setLineWidth( material.linewidth );
														
 
															 			setLineCap( material.linecap );
														
@@ -702,7 +704,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 		drawTriangle( _v1x, _v1y, _v2x, _v2y, _v3x, _v3y );
														
 
															-		if ( ( material instanceof THREE.MeshLambertMaterial || material instanceof THREE.MeshPhongMaterial ) && material.map === null ) {
														
 
															+		if ( ( material.isMeshLambertMaterial || material.isMeshPhongMaterial || material.isMeshStandardMaterial ) && material.map === null ) {
														
 
															 			_diffuseColor.copy( material.color );
														
 
															 			_emissiveColor.copy( material.emissive );
														
@@ -725,9 +727,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 				 ? strokePath( _color, material.wireframeLinewidth, material.wireframeLinecap, material.wireframeLinejoin )
														
 
															 				 : fillPath( _color );
														
 
															-		} else if ( material instanceof THREE.MeshBasicMaterial ||
														
 
															-				    material instanceof THREE.MeshLambertMaterial ||
														
 
															-				    material instanceof THREE.MeshPhongMaterial ) {
														
 
															+		} else if ( material.isMeshBasicMaterial || material.isMeshLambertMaterial || material.isMeshPhongMaterial || material.isMeshStandardMaterial ) {
														
 
															 			if ( material.map !== null ) {
														
@@ -776,7 +776,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 			}
														
 
															-		} else if ( material instanceof THREE.MeshNormalMaterial ) {
														
 
															+		} else if ( material.isMeshNormalMaterial ) {
														
 
															 			_normal.copy( element.normalModel ).applyMatrix3( _normalViewMatrix );
														
@@ -944,10 +944,10 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 		// http://extremelysatisfactorytotalitarianism.com/blog/?p=2120
														
 
															 		var a, b, c, d, e, f, det, idet,
														
 
															-		offsetX = texture.offset.x / texture.repeat.x,
														
 
															-		offsetY = texture.offset.y / texture.repeat.y,
														
 
															-		width = texture.image.width * texture.repeat.x,
														
 
															-		height = texture.image.height * texture.repeat.y;
														
 
															+			offsetX = texture.offset.x / texture.repeat.x,
														
 
															+			offsetY = texture.offset.y / texture.repeat.y,
														
 
															+			width = texture.image.width * texture.repeat.x,
														
 
															+			height = texture.image.height * texture.repeat.y;
														
 
															 		u0 = ( u0 + offsetX ) * width;
														
 
															 		v0 = ( v0 + offsetY ) * height;
														
@@ -985,6 +985,7 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 	}
														
 
															+	/*
														
 
															 	function clipImage( x0, y0, x1, y1, x2, y2, u0, v0, u1, v1, u2, v2, image ) {
														
 
															 		// http://extremelysatisfactorytotalitarianism.com/blog/?p=2120
														
@@ -1022,13 +1023,14 @@ THREE.CanvasRenderer = function ( parameters ) {
 
															 		_context.restore();
														
 
															 	}
														
 
															+	*/
														
 
															 	// Hide anti-alias gaps
														
 
															 	function expand( v1, v2, pixels ) {
														
 
															 		var x = v2.x - v1.x, y = v2.y - v1.y,
														
 
															-		det = x * x + y * y, idet;
														
 
															+			det = x * x + y * y, idet;
														
 
															 		if ( det === 0 ) return;
														
--- a/examples/js/renderers/Projector.js
+++ b/examples/js/renderers/Projector.js
@@ -99,33 +99,32 @@ THREE.RenderableSprite = function () {
 
															 THREE.Projector = function () {
														
 
															 	var _object, _objectCount, _objectPool = [], _objectPoolLength = 0,
														
 
															-	_vertex, _vertexCount, _vertexPool = [], _vertexPoolLength = 0,
														
 
															-	_face, _faceCount, _facePool = [], _facePoolLength = 0,
														
 
															-	_line, _lineCount, _linePool = [], _linePoolLength = 0,
														
 
															-	_sprite, _spriteCount, _spritePool = [], _spritePoolLength = 0,
														
 
															+		_vertex, _vertexCount, _vertexPool = [], _vertexPoolLength = 0,
														
 
															+		_face, _faceCount, _facePool = [], _facePoolLength = 0,
														
 
															+		_line, _lineCount, _linePool = [], _linePoolLength = 0,
														
 
															+		_sprite, _spriteCount, _spritePool = [], _spritePoolLength = 0,
														
 
															-	_renderData = { objects: [], lights: [], elements: [] },
														
 
															+		_renderData = { objects: [], lights: [], elements: [] },
														
 
															-	_vector3 = new THREE.Vector3(),
														
 
															-	_vector4 = new THREE.Vector4(),
														
 
															+		_vector3 = new THREE.Vector3(),
														
 
															+		_vector4 = new THREE.Vector4(),
														
 
															-	_clipBox = new THREE.Box3( new THREE.Vector3( - 1, - 1, - 1 ), new THREE.Vector3( 1, 1, 1 ) ),
														
 
															-	_boundingBox = new THREE.Box3(),
														
 
															-	_points3 = new Array( 3 ),
														
 
															-	_points4 = new Array( 4 ),
														
 
															+		_clipBox = new THREE.Box3( new THREE.Vector3( - 1, - 1, - 1 ), new THREE.Vector3( 1, 1, 1 ) ),
														
 
															+		_boundingBox = new THREE.Box3(),
														
 
															+		_points3 = new Array( 3 ),
														
 
															-	_viewMatrix = new THREE.Matrix4(),
														
 
															-	_viewProjectionMatrix = new THREE.Matrix4(),
														
 
															+		_viewMatrix = new THREE.Matrix4(),
														
 
															+		_viewProjectionMatrix = new THREE.Matrix4(),
														
 
															-	_modelMatrix,
														
 
															-	_modelViewProjectionMatrix = new THREE.Matrix4(),
														
 
															+		_modelMatrix,
														
 
															+		_modelViewProjectionMatrix = new THREE.Matrix4(),
														
 
															-	_normalMatrix = new THREE.Matrix3(),
														
 
															+		_normalMatrix = new THREE.Matrix3(),
														
 
															-	_frustum = new THREE.Frustum(),
														
 
															+		_frustum = new THREE.Frustum(),
														
 
															-	_clippedVertex1PositionScreen = new THREE.Vector4(),
														
 
															-	_clippedVertex2PositionScreen = new THREE.Vector4();
														
 
															+		_clippedVertex1PositionScreen = new THREE.Vector4(),
														
 
															+		_clippedVertex2PositionScreen = new THREE.Vector4();
														
 
															 	//
														
@@ -143,7 +142,7 @@ THREE.Projector = function () {
 
															 	};
														
 
															-	this.pickingRay = function ( vector, camera ) {
														
 
															+	this.pickingRay = function () {
														
 
															 		console.error( 'THREE.Projector: .pickingRay() is now raycaster.setFromCamera().' );
														
@@ -154,6 +153,7 @@ THREE.Projector = function () {
 
															 	var RenderList = function () {
														
 
															 		var normals = [];
														
 
															+		var colors = [];
														
 
															 		var uvs = [];
														
 
															 		var object = null;
														
@@ -169,6 +169,7 @@ THREE.Projector = function () {
 
															 			normalMatrix.getNormalMatrix( object.matrixWorld );
														
 
															 			normals.length = 0;
														
 
															+			colors.length = 0;
														
 
															 			uvs.length = 0;
														
 
															 		}
														
@@ -209,6 +210,12 @@ THREE.Projector = function () {
 
															 		}
														
 
															+		function pushColor( r, g, b ) {
														
 
															+
														
 
															+			colors.push( r, g, b );
														
 
															+
														
 
															+		}
														
 
															+
														
 
															 		function pushUv( x, y ) {
														
 
															 			uvs.push( x, y );
														
@@ -241,17 +248,36 @@ THREE.Projector = function () {
 
															 			var v1 = _vertexPool[ a ];
														
 
															 			var v2 = _vertexPool[ b ];
														
 
															-			_line = getNextLineInPool();
														
 
															+			// Clip
														
 
															+
														
 
															+			v1.positionScreen.copy( v1.position ).applyMatrix4( _modelViewProjectionMatrix );
														
 
															+			v2.positionScreen.copy( v2.position ).applyMatrix4( _modelViewProjectionMatrix );
														
 
															+
														
 
															+			if ( clipLine( v1.positionScreen, v2.positionScreen ) === true ) {
														
 
															-			_line.id = object.id;
														
 
															-			_line.v1.copy( v1 );
														
 
															-			_line.v2.copy( v2 );
														
 
															-			_line.z = ( v1.positionScreen.z + v2.positionScreen.z ) / 2;
														
 
															-			_line.renderOrder = object.renderOrder;
														
 
															+				// Perform the perspective divide
														
 
															+				v1.positionScreen.multiplyScalar( 1 / v1.positionScreen.w );
														
 
															+				v2.positionScreen.multiplyScalar( 1 / v2.positionScreen.w );
														
 
															-			_line.material = object.material;
														
 
															+				_line = getNextLineInPool();
														
 
															+				_line.id = object.id;
														
 
															+				_line.v1.copy( v1 );
														
 
															+				_line.v2.copy( v2 );
														
 
															+				_line.z = Math.max( v1.positionScreen.z, v2.positionScreen.z );
														
 
															+				_line.renderOrder = object.renderOrder;
														
 
															-			_renderData.elements.push( _line );
														
 
															+				_line.material = object.material;
														
 
															+
														
 
															+				if ( object.material.vertexColors === THREE.VertexColors ) {
														
 
															+
														
 
															+					_line.vertexColors[ 0 ].fromArray( colors, a * 3 );
														
 
															+					_line.vertexColors[ 1 ].fromArray( colors, b * 3 );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				_renderData.elements.push( _line );
														
 
															+
														
 
															+			}
														
 
															 		}
														
@@ -307,76 +333,89 @@ THREE.Projector = function () {
 
															 			checkBackfaceCulling: checkBackfaceCulling,
														
 
															 			pushVertex: pushVertex,
														
 
															 			pushNormal: pushNormal,
														
 
															+			pushColor: pushColor,
														
 
															 			pushUv: pushUv,
														
 
															 			pushLine: pushLine,
														
 
															 			pushTriangle: pushTriangle
														
 
															-		}
														
 
															+		};
														
 
															 	};
														
 
															 	var renderList = new RenderList();
														
 
															-	this.projectScene = function ( scene, camera, sortObjects, sortElements ) {
														
 
															+	function projectObject( object ) {
														
 
															-		_faceCount = 0;
														
 
															-		_lineCount = 0;
														
 
															-		_spriteCount = 0;
														
 
															+		if ( object.visible === false ) return;
														
 
															-		_renderData.elements.length = 0;
														
 
															+		if ( object instanceof THREE.Light ) {
														
 
															-		if ( scene.autoUpdate === true ) scene.updateMatrixWorld();
														
 
															-		if ( camera.parent === null ) camera.updateMatrixWorld();
														
 
															+			_renderData.lights.push( object );
														
 
															-		_viewMatrix.copy( camera.matrixWorldInverse.getInverse( camera.matrixWorld ) );
														
 
															-		_viewProjectionMatrix.multiplyMatrices( camera.projectionMatrix, _viewMatrix );
														
 
															+		} else if ( object instanceof THREE.Mesh || object instanceof THREE.Line || object instanceof THREE.Points ) {
														
 
															-		_frustum.setFromMatrix( _viewProjectionMatrix );
														
 
															+			if ( object.material.visible === false ) return;
														
 
															+			if ( object.frustumCulled === true && _frustum.intersectsObject( object ) === false ) return;
														
 
															-		//
														
 
															+			addObject( object );
														
 
															-		_objectCount = 0;
														
 
															+		} else if ( object instanceof THREE.Sprite ) {
														
 
															-		_renderData.objects.length = 0;
														
 
															-		_renderData.lights.length = 0;
														
 
															+			if ( object.material.visible === false ) return;
														
 
															+			if ( object.frustumCulled === true && _frustum.intersectsSprite( object ) === false ) return;
														
 
															+
														
 
															+			addObject( object );
														
 
															-		function addObject( object ) {
														
 
															+		}
														
 
															-			_object = getNextObjectInPool();
														
 
															-			_object.id = object.id;
														
 
															-			_object.object = object;
														
 
															+		var children = object.children;
														
 
															-			_vector3.setFromMatrixPosition( object.matrixWorld );
														
 
															-			_vector3.applyMatrix4( _viewProjectionMatrix );
														
 
															-			_object.z = _vector3.z;
														
 
															-			_object.renderOrder = object.renderOrder;
														
 
															+		for ( var i = 0, l = children.length; i < l; i ++ ) {
														
 
															-			_renderData.objects.push( _object );
														
 
															+			projectObject( children[ i ] );
														
 
															 		}
														
 
															-		scene.traverseVisible( function ( object ) {
														
 
															+	}
														
 
															-			if ( object instanceof THREE.Light ) {
														
 
															+	function addObject( object ) {
														
 
															-				_renderData.lights.push( object );
														
 
															+		_object = getNextObjectInPool();
														
 
															+		_object.id = object.id;
														
 
															+		_object.object = object;
														
 
															-			} else if ( object instanceof THREE.Mesh || object instanceof THREE.Line ) {
														
 
															+		_vector3.setFromMatrixPosition( object.matrixWorld );
														
 
															+		_vector3.applyMatrix4( _viewProjectionMatrix );
														
 
															+		_object.z = _vector3.z;
														
 
															+		_object.renderOrder = object.renderOrder;
														
 
															-				if ( object.material.visible === false ) return;
														
 
															-				if ( object.frustumCulled === true && _frustum.intersectsObject( object ) === false ) return;
														
 
															+		_renderData.objects.push( _object );
														
 
															-				addObject( object );
														
 
															+	}
														
 
															-			} else if ( object instanceof THREE.Sprite ) {
														
 
															+	this.projectScene = function ( scene, camera, sortObjects, sortElements ) {
														
 
															-				if ( object.material.visible === false ) return;
														
 
															-				if ( object.frustumCulled === true && _frustum.intersectsSprite( object ) === false ) return;
														
 
															+		_faceCount = 0;
														
 
															+		_lineCount = 0;
														
 
															+		_spriteCount = 0;
														
 
															-				addObject( object );
														
 
															+		_renderData.elements.length = 0;
														
 
															-			}
														
 
															+		if ( scene.autoUpdate === true ) scene.updateMatrixWorld();
														
 
															+		if ( camera.parent === null ) camera.updateMatrixWorld();
														
 
															+
														
 
															+		_viewMatrix.copy( camera.matrixWorldInverse.getInverse( camera.matrixWorld ) );
														
 
															+		_viewProjectionMatrix.multiplyMatrices( camera.projectionMatrix, _viewMatrix );
														
 
															+
														
 
															+		_frustum.setFromMatrix( _viewProjectionMatrix );
														
 
															-		} );
														
 
															+		//
														
 
															+
														
 
															+		_objectCount = 0;
														
 
															+
														
 
															+		_renderData.objects.length = 0;
														
 
															+		_renderData.lights.length = 0;
														
 
															+
														
 
															+		projectObject( scene );
														
 
															 		if ( sortObjects === true ) {
														
@@ -386,9 +425,11 @@ THREE.Projector = function () {
 
															 		//
														
 
															-		for ( var o = 0, ol = _renderData.objects.length; o < ol; o ++ ) {
														
 
															+		var objects = _renderData.objects;
														
 
															+
														
 
															+		for ( var o = 0, ol = objects.length; o < ol; o ++ ) {
														
 
															-			var object = _renderData.objects[ o ].object;
														
 
															+			var object = objects[ o ].object;
														
 
															 			var geometry = object.geometry;
														
 
															 			renderList.setObject( object );
														
@@ -609,6 +650,8 @@ THREE.Projector = function () {
 
															 			} else if ( object instanceof THREE.Line ) {
														
 
															+				_modelViewProjectionMatrix.multiplyMatrices( _viewProjectionMatrix, _modelMatrix );
														
 
															+
														
 
															 				if ( geometry instanceof THREE.BufferGeometry ) {
														
 
															 					var attributes = geometry.attributes;
														
@@ -623,6 +666,18 @@ THREE.Projector = function () {
 
															 						}
														
 
															+						if ( attributes.color !== undefined ) {
														
 
															+
														
 
															+							var colors = attributes.color.array;
														
 
															+
														
 
															+							for ( var i = 0, l = colors.length; i < l; i += 3 ) {
														
 
															+
														
 
															+								renderList.pushColor( colors[ i ], colors[ i + 1 ], colors[ i + 2 ] );
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+						}
														
 
															+
														
 
															 						if ( geometry.index !== null ) {
														
 
															 							var indices = geometry.index.array;
														
@@ -649,8 +704,6 @@ THREE.Projector = function () {
 
															 				} else if ( geometry instanceof THREE.Geometry ) {
														
 
															-					_modelViewProjectionMatrix.multiplyMatrices( _viewProjectionMatrix, _modelMatrix );
														
 
															-
														
 
															 					var vertices = object.geometry.vertices;
														
 
															 					if ( vertices.length === 0 ) continue;
														
@@ -704,36 +757,34 @@ THREE.Projector = function () {
 
															 				}
														
 
															-			} else if ( object instanceof THREE.Sprite ) {
														
 
															+			} else if ( object instanceof THREE.Points ) {
														
 
															-				_vector4.set( _modelMatrix.elements[ 12 ], _modelMatrix.elements[ 13 ], _modelMatrix.elements[ 14 ], 1 );
														
 
															-				_vector4.applyMatrix4( _viewProjectionMatrix );
														
 
															+				_modelViewProjectionMatrix.multiplyMatrices( _viewProjectionMatrix, _modelMatrix );
														
 
															-				var invW = 1 / _vector4.w;
														
 
															+				if ( geometry instanceof THREE.Geometry ) {
														
 
															-				_vector4.z *= invW;
														
 
															-
														
 
															-				if ( _vector4.z >= - 1 && _vector4.z <= 1 ) {
														
 
															+					var vertices = object.geometry.vertices;
														
 
															-					_sprite = getNextSpriteInPool();
														
 
															-					_sprite.id = object.id;
														
 
															-					_sprite.x = _vector4.x * invW;
														
 
															-					_sprite.y = _vector4.y * invW;
														
 
															-					_sprite.z = _vector4.z;
														
 
															-					_sprite.renderOrder = object.renderOrder;
														
 
															-					_sprite.object = object;
														
 
															+					for ( var v = 0, vl = vertices.length; v < vl; v ++ ) {
														
 
															-					_sprite.rotation = object.rotation;
														
 
															+						var vertex = vertices[ v ];
														
 
															-					_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 ] ) );
														
 
															+						_vector4.set( vertex.x, vertex.y, vertex.z, 1 );
														
 
															+						_vector4.applyMatrix4( _modelViewProjectionMatrix );
														
 
															-					_sprite.material = object.material;
														
 
															+						pushPoint( _vector4, object, camera );
														
 
															-					_renderData.elements.push( _sprite );
														
 
															+					}
														
 
															 				}
														
 
															+			} else if ( object instanceof THREE.Sprite ) {
														
 
															+
														
 
															+				_vector4.set( _modelMatrix.elements[ 12 ], _modelMatrix.elements[ 13 ], _modelMatrix.elements[ 14 ], 1 );
														
 
															+				_vector4.applyMatrix4( _viewProjectionMatrix );
														
 
															+
														
 
															+				pushPoint( _vector4, object, camera );
														
 
															+
														
 
															 			}
														
 
															 		}
														
@@ -748,6 +799,35 @@ THREE.Projector = function () {
 
															 	};
														
 
															+	function pushPoint( _vector4, object, camera ) {
														
 
															+
														
 
															+		var invW = 1 / _vector4.w;
														
 
															+
														
 
															+		_vector4.z *= invW;
														
 
															+
														
 
															+		if ( _vector4.z >= - 1 && _vector4.z <= 1 ) {
														
 
															+
														
 
															+			_sprite = getNextSpriteInPool();
														
 
															+			_sprite.id = object.id;
														
 
															+			_sprite.x = _vector4.x * invW;
														
 
															+			_sprite.y = _vector4.y * invW;
														
 
															+			_sprite.z = _vector4.z;
														
 
															+			_sprite.renderOrder = object.renderOrder;
														
 
															+			_sprite.object = object;
														
 
															+
														
 
															+			_sprite.rotation = object.rotation;
														
 
															+
														
 
															+			_sprite.scale.x = object.scale.x * Math.abs( _sprite.x - ( _vector4.x + camera.projectionMatrix.elements[ 0 ] ) / ( _vector4.w + camera.projectionMatrix.elements[ 12 ] ) );
														
 
															+			_sprite.scale.y = object.scale.y * Math.abs( _sprite.y - ( _vector4.y + camera.projectionMatrix.elements[ 5 ] ) / ( _vector4.w + camera.projectionMatrix.elements[ 13 ] ) );
														
 
															+
														
 
															+			_sprite.material = object.material;
														
 
															+
														
 
															+			_renderData.elements.push( _sprite );
														
 
															+
														
 
															+		}
														
 
															+
														
 
															+	}
														
 
															+
														
 
															 	// Pools
														
 
															 	function getNextObjectInPool() {
														
@@ -861,10 +941,11 @@ THREE.Projector = function () {
 
															 		// Calculate the boundary coordinate of each vertex for the near and far clip planes,
														
 
															 		// Z = -1 and Z = +1, respectively.
														
 
															-		bc1near =  s1.z + s1.w,
														
 
															-		bc2near =  s2.z + s2.w,
														
 
															-		bc1far =  - s1.z + s1.w,
														
 
															-		bc2far =  - s2.z + s2.w;
														
 
															+
														
 
															+			bc1near = s1.z + s1.w,
														
 
															+			bc2near = s2.z + s2.w,
														
 
															+			bc1far = - s1.z + s1.w,
														
 
															+			bc2far = - s2.z + s2.w;
														
 
															 		if ( bc1near >= 0 && bc2near >= 0 && bc1far >= 0 && bc2far >= 0 ) {
														
--- a/examples/js/renderers/WebGLDeferredRenderer.js
+++ b/examples/js/renderers/WebGLDeferredRenderer.js
@@ -67,8 +67,7 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 	var _lightPrePass = false;
														
 
															 	var _cacheKeepAlive = false;
														
 
															-	var _invisibleMaterial = new THREE.ShaderMaterial( { visible: false } );
														
 
															-
														
 
															+	var _tmpMaterial = new THREE.ShaderMaterial( { visible: false } );
														
 
															 	var _tmpVector3 = new THREE.Vector3();
														
 
															 	// scene/material/light cache for deferred rendering.
														
@@ -80,13 +79,12 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 	var _lightScenesCache = {};
														
 
															 	var _lightFullscreenScenesCache = {};
														
 
															-	// originalMaterial.uuid -> deferredMaterial
														
 
															-	// (no mapping from children of MultiMaterial)
														
 
															+	// object.material.uuid -> deferredMaterial or
														
 
															+	// object.material[ n ].uuid -> deferredMaterial
														
 
															 	var _normalDepthMaterialsCache = {};
														
 
															 	var _normalDepthShininessMaterialsCache = {};
														
 
															 	var _colorMaterialsCache = {};
														
 
															 	var _reconstructionMaterialsCache = {};
														
 
															-	var _invisibleMultiMaterialsCache = {};
														
 
															 	// originalLight.uuid -> deferredLight
														
 
															 	var _deferredLightsCache = {};
														
@@ -97,8 +95,8 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 	var _removeThresholdCount = 60;
														
 
															-	// object.uuid -> originalMaterial
														
 
															-	// deferred materials.uuid -> originalMaterial
														
 
															+	// deferredMaterials.uuid -> object.material or
														
 
															+	// deferredMaterials.uuid -> object.material[ n ]
														
 
															 	// save before render and release after render.
														
 
															 	var _originalMaterialsTable = {};
														
@@ -106,6 +104,11 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 	// save before render and release after render.
														
 
															 	var _originalOnBeforeRendersTable = {};
														
 
															+	// object.material.uuid -> object.material.visible or
														
 
															+	// object.material[ i ].uuid -> object.material[ i ].visible or
														
 
															+	// save before render and release after render.
														
 
															+	var _originalVisibleTable = {};
														
 
															+
														
 
															 	// external properties
														
 
															 	this.renderer = undefined;
														
@@ -328,70 +331,73 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 	}
														
 
															-	function getMaterialFromCacheOrCreate( originalMaterial, cache, func ) {
														
 
															+	function getMaterialFromCacheOrCreate( originalMaterial, cache, createFunc, updateFunc ) {
														
 
															 		var data = cache[ originalMaterial.uuid ];
														
 
															 		if ( data === undefined ) {
														
 
															 			data = createCacheData();
														
 
															+			data.material = createFunc( originalMaterial );
														
 
															+			cache[ originalMaterial.uuid ] = data;
														
 
															-			var material;
														
 
															+		}
														
 
															-			if ( originalMaterial.isMultiMaterial === true ) {
														
 
															+		data.used = true;
														
 
															-				var materials = [];
														
 
															+		updateFunc( data.material, originalMaterial );
														
 
															-				for ( var i = 0, il = originalMaterial.materials.length; i < il; i ++ ) {
														
 
															+		_originalMaterialsTable[ data.material.uuid ] = originalMaterial;
														
 
															-					materials.push( func( originalMaterial.materials[ i ] ) );
														
 
															+		return data.material;
														
 
															-				}
														
 
															+	}
														
 
															-				material = new THREE.MultiMaterial( materials );
														
 
															+	function overrideMaterialAndOnBeforeRender( object, getMaterialFunc, onBeforeRender ) {
														
 
															-			} else {
														
 
															+		if ( object.material === undefined ) return;
														
 
															+
														
 
															+		if ( Array.isArray( object.material ) ) {
														
 
															-				material = func( originalMaterial );
														
 
															+			for ( var i = 0, il = object.material.length; i < il; i ++ ) {
														
 
															+
														
 
															+				object.material[ i ] = getMaterialFunc( object.material[ i ] );
														
 
															 			}
														
 
															-			data.material = material;
														
 
															+		} else {
														
 
															-			cache[ originalMaterial.uuid ] = data;
														
 
															+			object.material = getMaterialFunc( object.material );
														
 
															 		}
														
 
															-		return data.material;
														
 
															+		object.onBeforeRender = onBeforeRender;
														
 
															 	}
														
 
															-	function setMaterialNormalDepth( object ) {
														
 
															+	function restoreOriginalMaterial( object ) {
														
 
															 		if ( object.material === undefined ) return;
														
 
															-		var originalMaterial = _originalMaterialsTable[ object.uuid ];
														
 
															-		var material = getNormalDepthMaterial( originalMaterial );
														
 
															-
														
 
															-		_originalMaterialsTable[ material.uuid ] = originalMaterial;
														
 
															+		if ( Array.isArray( object.material ) ) {
														
 
															-		if ( material.isMultiMaterial === true ) {
														
 
															+			for ( var i = 0, il = object.material.length; i < il; i ++ ) {
														
 
															-			for ( var i = 0, il = material.materials.length; i < il; i ++ ) {
														
 
															-
														
 
															-				_originalMaterialsTable[ material.materials[ i ].uuid ] = originalMaterial.materials[ i ];
														
 
															-				updateDeferredNormalDepthMaterial( material.materials[ i ], originalMaterial.materials[ i ] );
														
 
															+				object.material[ i ] = _originalMaterialsTable[ object.material[ i ].uuid ];
														
 
															 			}
														
 
															 		} else {
														
 
															-			updateDeferredNormalDepthMaterial( material, originalMaterial );
														
 
															+			object.material = _originalMaterialsTable[ object.material.uuid ];
														
 
															 		}
														
 
															-		object.material = material;
														
 
															-		object.onBeforeRender = updateDeferredNormalDepthUniforms;
														
 
															+	}
														
 
															+
														
 
															+	function setMaterialNormalDepth( object ) {
														
 
															+
														
 
															+		overrideMaterialAndOnBeforeRender( object, getNormalDepthMaterial, updateDeferredNormalDepthUniforms );
														
 
															 	}
														
@@ -400,7 +406,8 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 		return getMaterialFromCacheOrCreate(
														
 
															 			originalMaterial,
														
 
															 			( _lightPrePass ) ? _normalDepthShininessMaterialsCache : _normalDepthMaterialsCache,
														
 
															-			createDeferredNormalDepthMaterial
														
 
															+			createDeferredNormalDepthMaterial,
														
 
															+			updateDeferredNormalDepthMaterial
														
 
															 		);
														
 
															 	}
														
@@ -420,6 +427,7 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 	function updateDeferredNormalDepthMaterial( material, originalMaterial ) {
														
 
															+		if ( originalMaterial.skinning !== undefined ) material.skinning = originalMaterial.skinning;
														
 
															 		if ( originalMaterial.morphTargets !== undefined ) material.morphTargets = originalMaterial.morphTargets;
														
 
															 		if ( originalMaterial.visible === true ) {
														
@@ -448,30 +456,7 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 	function setMaterialColor( object ) {
														
 
															-		if ( object.material === undefined ) return;
														
 
															-
														
 
															-		var originalMaterial = _originalMaterialsTable[ object.uuid ];
														
 
															-		var material = getColorMaterial( originalMaterial );
														
 
															-
														
 
															-		_originalMaterialsTable[ material.uuid ] = originalMaterial;
														
 
															-
														
 
															-		if ( originalMaterial.isMultiMaterial === true ) {
														
 
															-
														
 
															-			for ( var i = 0, il = originalMaterial.materials.length; i < il; i ++ ) {
														
 
															-
														
 
															-				_originalMaterialsTable[ material.materials[ i ].uuid ] = originalMaterial.materials[ i ];
														
 
															-				updateDeferredColorMaterial( material.materials[ i ], originalMaterial.materials[ i ] );
														
 
															-
														
 
															-			}
														
 
															-
														
 
															-		} else {
														
 
															-
														
 
															-			updateDeferredColorMaterial( material, originalMaterial );
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-		object.material = material;
														
 
															-		object.onBeforeRender = updateDeferredColorUniforms;
														
 
															+		overrideMaterialAndOnBeforeRender( object, getColorMaterial, updateDeferredColorUniforms );
														
 
															 	}
														
@@ -480,7 +465,8 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 		return getMaterialFromCacheOrCreate(
														
 
															 			originalMaterial,
														
 
															 			_colorMaterialsCache,
														
 
															-			createDeferredColorMaterial
														
 
															+			createDeferredColorMaterial,
														
 
															+			updateDeferredColorMaterial
														
 
															 		);
														
 
															 	}
														
@@ -505,6 +491,7 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 	function updateDeferredColorMaterial( material, originalMaterial ) {
														
 
															 		if ( originalMaterial.map !== undefined ) material.map = originalMaterial.map;
														
 
															+		if ( originalMaterial.skinning !== undefined ) material.skinning = originalMaterial.skinning;
														
 
															 		if ( originalMaterial.morphTargets !== undefined ) material.morphTargets = originalMaterial.morphTargets;
														
 
															 		if ( originalMaterial.visible === true ) {
														
@@ -551,48 +538,24 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 	function setMaterialReconstruction( object ) {
														
 
															-		if ( object.material === undefined ) return;
														
 
															-
														
 
															-		var originalMaterial = _originalMaterialsTable[ object.uuid ];
														
 
															-
														
 
															-		if ( originalMaterial.transparent === true ) {
														
 
															-
														
 
															-			object.material = originalMaterial;
														
 
															-			object.onBeforeRender = _originalOnBeforeRendersTable[ object.uuid ];
														
 
															-
														
 
															-			return;
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-		var material = getReconstructionMaterial( originalMaterial );
														
 
															-		_originalMaterialsTable[ material.uuid ] = originalMaterial;
														
 
															+		overrideMaterialAndOnBeforeRender( object, getReconstructionMaterial, updateDeferredReconstructionUniforms );
														
 
															-		if ( originalMaterial.isMultiMaterial === true ) {
														
 
															-
														
 
															-			for ( var i = 0, il = originalMaterial.materials.length; i < il; i ++ ) {
														
 
															-
														
 
															-				_originalMaterialsTable[ material.materials[ i ].uuid ] = originalMaterial.materials[ i ];
														
 
															-				updateDeferredReconstructionMaterial( material.materials[ i ], originalMaterial.materials[ i ] );
														
 
															+	}
														
 
															-			}
														
 
															+	function getReconstructionMaterial( originalMaterial ) {
														
 
															-		} else {
														
 
															+		if ( originalMaterial.transparent === true ) {
														
 
															-			updateDeferredReconstructionMaterial( material, originalMaterial );
														
 
															+			_originalMaterialsTable[ originalMaterial.uuid ] = originalMaterial;
														
 
															+			return originalMaterial;
														
 
															 		}
														
 
															-		object.material = material;
														
 
															-		object.onBeforeRender = updateDeferredReconstructionUniforms;
														
 
															-
														
 
															-	}
														
 
															-
														
 
															-	function getReconstructionMaterial( originalMaterial ) {
														
 
															-
														
 
															 		return getMaterialFromCacheOrCreate(
														
 
															 			originalMaterial,
														
 
															 			_reconstructionMaterialsCache,
														
 
															-			createDeferredReconstructionMaterial
														
 
															+			createDeferredReconstructionMaterial,
														
 
															+			updateDeferredReconstructionMaterial
														
 
															 		);
														
 
															 	}
														
@@ -622,65 +585,72 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 	function updateDeferredReconstructionUniforms( renderer, scene, camera, geometry, material, group ) {
														
 
															+		if ( material.transparent === true ) {
														
 
															+
														
 
															+			// 'this' is object here because this method is set as object.onBefore()
														
 
															+			var onBeforeRender = _originalOnBeforeRendersTable[ this.uuid ];
														
 
															+
														
 
															+			if ( onBeforeRender ) {
														
 
															+
														
 
															+				onBeforeRender.call( this, renderer, scene, camera, geometry, material, group );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			return;
														
 
															+
														
 
															+		}
														
 
															+
														
 
															 		updateDeferredColorUniforms( renderer, scene, camera, geometry, material, group );
														
 
															 		material.uniforms.samplerLight.value = _compLight.renderTarget2.texture;
														
 
															 	}
														
 
															-	function setMaterialForwardRendering( object ) {
														
 
															+	function setVisibleForForwardRendering( object ) {
														
 
															 		if ( object.material === undefined ) return;
														
 
															-		var originalMaterial = _originalMaterialsTable[ object.uuid ];
														
 
															+		if ( Array.isArray( object.material ) ) {
														
 
															-		if ( originalMaterial.isMultiMaterial === true ) {
														
 
															+			for ( var i = 0, il = object.material.length; i < il; i ++ ) {
														
 
															-			var material = getInvisibleMultiMaterial( originalMaterial );
														
 
															+				if ( _originalVisibleTable[ object.material[ i ].uuid ] === undefined ) {
														
 
															-			for ( var i = 0, il = originalMaterial.materials.length; i < il; i ++ ) {
														
 
															+					_originalVisibleTable[ object.material[ i ].uuid ] = object.material[ i ].visible;
														
 
															+					object.material[ i ].visible = object.material[ i ].transparent && object.material[ i ].visible;
														
 
															-				material.materials[ i ] = getForwardRenderingMaterial( originalMaterial.materials[ i ] );
														
 
															+				}
														
 
															 			}
														
 
															-			object.material = material;
														
 
															-
														
 
															 		} else {
														
 
															-			object.material = getForwardRenderingMaterial( originalMaterial );
														
 
															+			if ( _originalVisibleTable[ object.material.uuid ] === undefined ) {
														
 
															-		}
														
 
															+				_originalVisibleTable[ object.material.uuid ] = object.material.visible;
														
 
															+				object.material.visible = object.material.transparent && object.material.visible;
														
 
															-		object.onBeforeRender = _originalOnBeforeRendersTable[ object.uuid ];
														
 
															-
														
 
															-	}
														
 
															-
														
 
															-	function getInvisibleMultiMaterial( originalMaterial ) {
														
 
															+			}
														
 
															-		return getMaterialFromCacheOrCreate(
														
 
															-			originalMaterial,
														
 
															-			_invisibleMultiMaterialsCache,
														
 
															-			createInvisibleMaterial
														
 
															-		);
														
 
															+		}
														
 
															 	}
														
 
															-	function createInvisibleMaterial( originalMaterial ) {
														
 
															+	function restoreVisible( object ) {
														
 
															-		return _invisibleMaterial;
														
 
															+		if ( object.material === undefined ) return;
														
 
															-	}
														
 
															+		if ( Array.isArray( object.material ) ) {
														
 
															-	function getForwardRenderingMaterial( originalMaterial ) {
														
 
															+			for ( var i = 0, il = object.material.length; i < il; i ++ ) {
														
 
															-		if ( originalMaterial.transparent === true && originalMaterial.visible === true ) {
														
 
															+				object.material[ i ].visible = _originalVisibleTable[ object.material[ i ].uuid ];
														
 
															-			return originalMaterial;
														
 
															+			}
														
 
															 		} else {
														
 
															-			return _invisibleMaterial;
														
 
															+			object.material.visible = _originalVisibleTable[ object.material.uuid ];
														
 
															 		}
														
@@ -761,11 +731,12 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 			data = createCacheData();
														
 
															 			data.material = createDeferredLightMaterial( light.userData.originalLight );
														
 
															-
														
 
															 			cache[ light.uuid ] = data;
														
 
															 		}
														
 
															+		data.used = true;
														
 
															+
														
 
															 		return data.material;
														
 
															 	}
														
@@ -784,7 +755,7 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 	function createDeferredLightMesh( light, geometry ) {
														
 
															-		var mesh = new THREE.Mesh( geometry, _invisibleMaterial );
														
 
															+		var mesh = new THREE.Mesh( geometry, _tmpMaterial );
														
 
															 		mesh.userData.originalLight = light;
														
@@ -973,21 +944,22 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 	}
														
 
															-	function saveOriginalMaterialAndCheckTransparency( object ) {
														
 
															+	function saveOriginalOnBeforeRenderAndCheckTransparency( object ) {
														
 
															 		if ( object.material === undefined ) return;
														
 
															-		_originalMaterialsTable[ object.uuid ] = object.material;
														
 
															 		_originalOnBeforeRendersTable[ object.uuid ] = object.onBeforeRender;
														
 
															 		// _hasTransparentObject is used only for Classic Deferred Rendering
														
 
															 		if ( _hasTransparentObject || _lightPrePass ) return;
														
 
															-		if ( object.material.isMultiMaterial === true ) {
														
 
															+		if ( ! object.visible ) return;
														
 
															+
														
 
															+		if ( Array.isArray( object.material ) ) {
														
 
															-			for ( var i = 0, il = object.material.materials.length; i < il; i ++ ) {
														
 
															+			for ( var i = 0, il = object.material.length; i < il; i ++ ) {
														
 
															-				if ( object.material.materials[ i ].transparent === true ) {
														
 
															+				if ( object.material[ i ].visible === true && object.material[ i ].transparent === true ) {
														
 
															 					_hasTransparentObject = true;
														
 
															 					break;
														
@@ -998,17 +970,16 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 		} else {
														
 
															-			if ( object.material.transparent === true ) _hasTransparentObject = true;
														
 
															+			if ( object.material.visible === true && object.material.transparent === true ) _hasTransparentObject = true;
														
 
															 		}
														
 
															 	}
														
 
															-	function restoreOriginalMaterial( object ) {
														
 
															+	function restoreOriginalOnBeforeRender( object ) {
														
 
															 		if ( object.material === undefined ) return;
														
 
															-		object.material = _originalMaterialsTable[ object.uuid ];
														
 
															 		object.onBeforeRender = _originalOnBeforeRendersTable[ object.uuid ];
														
 
															 	}
														
@@ -1023,11 +994,12 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 			data = createCacheData();
														
 
															 			data.light = createDeferredLight( object );
														
 
															-
														
 
															 			_deferredLightsCache[ object.uuid ] = data;
														
 
															 		}
														
 
															+		data.used = true;
														
 
															+
														
 
															 		var light = data.light;
														
 
															 		if ( light === null ) return;
														
@@ -1225,7 +1197,7 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 	function cleanupTable( table ) {
														
 
															-		var keys = Object.keys( cache );
														
 
															+		var keys = Object.keys( table );
														
 
															 		for ( var i = 0, il = keys.length; i < il; i ++ ) {
														
@@ -1245,13 +1217,13 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 		cleanupCache( _normalDepthShininessMaterialsCache );
														
 
															 		cleanupCache( _colorMaterialsCache );
														
 
															 		cleanupCache( _reconstructionMaterialsCache );
														
 
															-		cleanupCache( _invisibleMultiMaterialsCache );
														
 
															 		cleanupCache( _classicDeferredLightMaterialsCache );
														
 
															 		cleanupCache( _lightPrePassMaterialsCache );
														
 
															 		cleanupCache( _deferredLightsCache );
														
 
															 		cleanupTable( _originalMaterialsTable );
														
 
															 		cleanupTable( _originalOnBeforeRendersTable );
														
 
															+		cleanupTable( _originalVisibleTable );
														
 
															 	}
														
@@ -1289,6 +1261,8 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 		_compNormalDepth.render();
														
 
															+		scene.traverse( restoreOriginalMaterial );
														
 
															+
														
 
															 	}
														
 
															 	/*
														
@@ -1317,6 +1291,8 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 		_compColor.render();
														
 
															+		scene.traverse( restoreOriginalMaterial );
														
 
															+
														
 
															 	}
														
 
															 	/*
														
@@ -1397,6 +1373,8 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 		_gl.disable( _gl.STENCIL_TEST );
														
 
															+		scene.traverse( restoreOriginalMaterial );
														
 
															+
														
 
															 	}
														
 
															 	/*
														
@@ -1426,7 +1404,8 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 		if ( ! _lightPrePass && _hasTransparentObject ) {
														
 
															-			scene.traverse( setMaterialForwardRendering );
														
 
															+			scene.traverse( setVisibleForForwardRendering );
														
 
															+			scene.traverse( restoreOriginalOnBeforeRender );
														
 
															 			_passForward.scene = scene;
														
 
															 			_passForward.camera = camera;
														
@@ -1440,6 +1419,12 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 		_compFinal.render();
														
 
															+		if ( ! _lightPrePass && _hasTransparentObject ) {
														
 
															+
														
 
															+			scene.traverse( restoreVisible );
														
 
															+
														
 
															+		}
														
 
															+
														
 
															 	}
														
 
															 	// external APIs
														
@@ -1504,7 +1489,7 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 		_hasTransparentObject = false;
														
 
															-		scene.traverse( saveOriginalMaterialAndCheckTransparency );
														
 
															+		scene.traverse( saveOriginalOnBeforeRenderAndCheckTransparency );
														
 
															 		updateDeferredCommonUniforms( camera );
														
@@ -1524,7 +1509,9 @@ THREE.WebGLDeferredRenderer = function ( parameters ) {
 
															 		renderFinal( scene, camera );
														
 
															-		scene.traverse( restoreOriginalMaterial );
														
 
															+		scene.traverse( restoreOriginalOnBeforeRender );
														
 
															+
														
 
															+		cleanupCaches();
														
 
															 		scene.autoUpdate = currentSceneAutoUpdate;
														
 
															 		this.renderer.autoClearColor = currentAutoClearColor;
														
--- a/examples/js/vr/WebVR.js
+++ b/examples/js/vr/WebVR.js
@@ -83,13 +83,13 @@ var WEBVR = {
 
															 		button.style.textAlign = 'center';
														
 
															 		button.style.zIndex = '999';
														
 
															 		button.textContent = 'ENTER VR';
														
 
															-		button.onclick = function() {
														
 
															+		button.onclick = function () {
														
 
															 			effect.isPresenting ? effect.exitPresent() : effect.requestPresent();
														
 
															 		};
														
 
															-		window.addEventListener( 'vrdisplaypresentchange', function ( event ) {
														
 
															+		window.addEventListener( 'vrdisplaypresentchange', function () {
														
 
															 			button.textContent = effect.isPresenting ? 'EXIT VR' : 'ENTER VR';
														
--- a/examples/models/gltf/RiggedSimple/glTF/RiggedSimple.bin
+++ b/examples/models/gltf/RiggedSimple/glTF/RiggedSimple.bin
--- a/examples/models/gltf/RiggedSimple/glTF/RiggedSimple.gltf
+++ b/examples/models/gltf/RiggedSimple/glTF/RiggedSimple.gltf
@@ -0,0 +1,588 @@
 
															+{
														
 
															+    "accessors": {
														
 
															+        "IBM_Armature_Cylinder-skin": {
														
 
															+            "bufferView": "bufferView_43",
														
 
															+            "byteOffset": 0,
														
 
															+            "componentType": 5126,
														
 
															+            "count": 2,
														
 
															+            "type": "MAT4"
														
 
															+        },
														
 
															+        "accessor_16": {
														
 
															+            "bufferView": "bufferView_44",
														
 
															+            "byteOffset": 0,
														
 
															+            "byteStride": 0,
														
 
															+            "componentType": 5123,
														
 
															+            "count": 564,
														
 
															+            "type": "SCALAR"
														
 
															+        },
														
 
															+        "accessor_18": {
														
 
															+            "bufferView": "bufferView_45",
														
 
															+            "byteOffset": 0,
														
 
															+            "byteStride": 12,
														
 
															+            "componentType": 5126,
														
 
															+            "count": 96,
														
 
															+            "max": [
														
 
															+                1,
														
 
															+                1,
														
 
															+                4.57508
														
 
															+            ],
														
 
															+            "min": [
														
 
															+                -1,
														
 
															+                -1,
														
 
															+                -4.57508
														
 
															+            ],
														
 
															+            "type": "VEC3"
														
 
															+        },
														
 
															+        "accessor_20": {
														
 
															+            "bufferView": "bufferView_45",
														
 
															+            "byteOffset": 1152,
														
 
															+            "byteStride": 12,
														
 
															+            "componentType": 5126,
														
 
															+            "count": 96,
														
 
															+            "max": [
														
 
															+                0.998198,
														
 
															+                0.998198,
														
 
															+                0.688838
														
 
															+            ],
														
 
															+            "min": [
														
 
															+                -0.998198,
														
 
															+                -0.998198,
														
 
															+                -0.644473
														
 
															+            ],
														
 
															+            "type": "VEC3"
														
 
															+        },
														
 
															+        "accessor_37": {
														
 
															+            "bufferView": "bufferView_45",
														
 
															+            "byteOffset": 3840,
														
 
															+            "byteStride": 16,
														
 
															+            "componentType": 5126,
														
 
															+            "count": 96,
														
 
															+            "max": [
														
 
															+                1,
														
 
															+                0.261398,
														
 
															+                0,
														
 
															+                0
														
 
															+            ],
														
 
															+            "min": [
														
 
															+                0.738602,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0
														
 
															+            ],
														
 
															+            "type": "VEC4"
														
 
															+        },
														
 
															+        "accessor_40": {
														
 
															+            "bufferView": "bufferView_45",
														
 
															+            "byteOffset": 2304,
														
 
															+            "byteStride": 16,
														
 
															+            "componentType": 5126,
														
 
															+            "count": 96,
														
 
															+            "max": [
														
 
															+                1,
														
 
															+                1,
														
 
															+                0,
														
 
															+                0
														
 
															+            ],
														
 
															+            "min": [
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0
														
 
															+            ],
														
 
															+            "type": "VEC4"
														
 
															+        },
														
 
															+        "animAccessor_0": {
														
 
															+            "bufferView": "bufferView_43",
														
 
															+            "byteOffset": 128,
														
 
															+            "componentType": 5126,
														
 
															+            "count": 3,
														
 
															+            "type": "SCALAR"
														
 
															+        },
														
 
															+        "animAccessor_1": {
														
 
															+            "bufferView": "bufferView_43",
														
 
															+            "byteOffset": 140,
														
 
															+            "componentType": 5126,
														
 
															+            "count": 3,
														
 
															+            "type": "VEC3"
														
 
															+        },
														
 
															+        "animAccessor_2": {
														
 
															+            "bufferView": "bufferView_43",
														
 
															+            "byteOffset": 176,
														
 
															+            "componentType": 5126,
														
 
															+            "count": 3,
														
 
															+            "type": "VEC3"
														
 
															+        },
														
 
															+        "animAccessor_3": {
														
 
															+            "bufferView": "bufferView_43",
														
 
															+            "byteOffset": 212,
														
 
															+            "componentType": 5126,
														
 
															+            "count": 3,
														
 
															+            "type": "VEC4"
														
 
															+        },
														
 
															+        "animAccessor_4": {
														
 
															+            "bufferView": "bufferView_43",
														
 
															+            "byteOffset": 260,
														
 
															+            "componentType": 5126,
														
 
															+            "count": 3,
														
 
															+            "type": "VEC3"
														
 
															+        },
														
 
															+        "animAccessor_5": {
														
 
															+            "bufferView": "bufferView_43",
														
 
															+            "byteOffset": 296,
														
 
															+            "componentType": 5126,
														
 
															+            "count": 3,
														
 
															+            "type": "VEC3"
														
 
															+        },
														
 
															+        "animAccessor_6": {
														
 
															+            "bufferView": "bufferView_43",
														
 
															+            "byteOffset": 332,
														
 
															+            "componentType": 5126,
														
 
															+            "count": 3,
														
 
															+            "type": "VEC4"
														
 
															+        }
														
 
															+    },
														
 
															+    "animations": {
														
 
															+        "animation_0": {
														
 
															+            "channels": [
														
 
															+                {
														
 
															+                    "sampler": "animation_0_scale_sampler",
														
 
															+                    "target": {
														
 
															+                        "id": "Bone",
														
 
															+                        "path": "scale"
														
 
															+                    }
														
 
															+                },
														
 
															+                {
														
 
															+                    "sampler": "animation_0_translation_sampler",
														
 
															+                    "target": {
														
 
															+                        "id": "Bone",
														
 
															+                        "path": "translation"
														
 
															+                    }
														
 
															+                },
														
 
															+                {
														
 
															+                    "sampler": "animation_0_rotation_sampler",
														
 
															+                    "target": {
														
 
															+                        "id": "Bone",
														
 
															+                        "path": "rotation"
														
 
															+                    }
														
 
															+                }
														
 
															+            ],
														
 
															+            "parameters": {
														
 
															+                "TIME": "animAccessor_0",
														
 
															+                "rotation": "animAccessor_3",
														
 
															+                "scale": "animAccessor_1",
														
 
															+                "translation": "animAccessor_2"
														
 
															+            },
														
 
															+            "samplers": {
														
 
															+                "animation_0_rotation_sampler": {
														
 
															+                    "input": "TIME",
														
 
															+                    "interpolation": "LINEAR",
														
 
															+                    "output": "rotation"
														
 
															+                },
														
 
															+                "animation_0_scale_sampler": {
														
 
															+                    "input": "TIME",
														
 
															+                    "interpolation": "LINEAR",
														
 
															+                    "output": "scale"
														
 
															+                },
														
 
															+                "animation_0_translation_sampler": {
														
 
															+                    "input": "TIME",
														
 
															+                    "interpolation": "LINEAR",
														
 
															+                    "output": "translation"
														
 
															+                }
														
 
															+            }
														
 
															+        },
														
 
															+        "animation_1": {
														
 
															+            "channels": [
														
 
															+                {
														
 
															+                    "sampler": "animation_1_scale_sampler",
														
 
															+                    "target": {
														
 
															+                        "id": "Bone_001",
														
 
															+                        "path": "scale"
														
 
															+                    }
														
 
															+                },
														
 
															+                {
														
 
															+                    "sampler": "animation_1_translation_sampler",
														
 
															+                    "target": {
														
 
															+                        "id": "Bone_001",
														
 
															+                        "path": "translation"
														
 
															+                    }
														
 
															+                },
														
 
															+                {
														
 
															+                    "sampler": "animation_1_rotation_sampler",
														
 
															+                    "target": {
														
 
															+                        "id": "Bone_001",
														
 
															+                        "path": "rotation"
														
 
															+                    }
														
 
															+                }
														
 
															+            ],
														
 
															+            "parameters": {
														
 
															+                "TIME": "animAccessor_0",
														
 
															+                "rotation": "animAccessor_6",
														
 
															+                "scale": "animAccessor_4",
														
 
															+                "translation": "animAccessor_5"
														
 
															+            },
														
 
															+            "samplers": {
														
 
															+                "animation_1_rotation_sampler": {
														
 
															+                    "input": "TIME",
														
 
															+                    "interpolation": "LINEAR",
														
 
															+                    "output": "rotation"
														
 
															+                },
														
 
															+                "animation_1_scale_sampler": {
														
 
															+                    "input": "TIME",
														
 
															+                    "interpolation": "LINEAR",
														
 
															+                    "output": "scale"
														
 
															+                },
														
 
															+                "animation_1_translation_sampler": {
														
 
															+                    "input": "TIME",
														
 
															+                    "interpolation": "LINEAR",
														
 
															+                    "output": "translation"
														
 
															+                }
														
 
															+            }
														
 
															+        }
														
 
															+    },
														
 
															+    "asset": {
														
 
															+        "generator": "collada2gltf@027f74366341d569dea42e9a68b7104cc3892054",
														
 
															+        "premultipliedAlpha": true,
														
 
															+        "profile": {
														
 
															+            "api": "WebGL",
														
 
															+            "version": "1.0.2"
														
 
															+        },
														
 
															+        "version": "1.0"
														
 
															+    },
														
 
															+    "bufferViews": {
														
 
															+        "bufferView_43": {
														
 
															+            "buffer": "RiggedSimple",
														
 
															+            "byteLength": 380,
														
 
															+            "byteOffset": 0
														
 
															+        },
														
 
															+        "bufferView_44": {
														
 
															+            "buffer": "RiggedSimple",
														
 
															+            "byteLength": 1128,
														
 
															+            "byteOffset": 380,
														
 
															+            "target": 34963
														
 
															+        },
														
 
															+        "bufferView_45": {
														
 
															+            "buffer": "RiggedSimple",
														
 
															+            "byteLength": 5376,
														
 
															+            "byteOffset": 1508,
														
 
															+            "target": 34962
														
 
															+        }
														
 
															+    },
														
 
															+    "buffers": {
														
 
															+        "RiggedSimple": {
														
 
															+            "byteLength": 6884,
														
 
															+            "type": "arraybuffer",
														
 
															+            "uri": "RiggedSimple.bin"
														
 
															+        }
														
 
															+    },
														
 
															+    "materials": {
														
 
															+        "Material_001-effect": {
														
 
															+            "name": "Material_001",
														
 
															+            "technique": "technique0",
														
 
															+            "values": {
														
 
															+                "ambient": [
														
 
															+                    0,
														
 
															+                    0,
														
 
															+                    0,
														
 
															+                    1
														
 
															+                ],
														
 
															+                "diffuse": [
														
 
															+                    0.279635,
														
 
															+                    0.64,
														
 
															+                    0.210944,
														
 
															+                    1
														
 
															+                ],
														
 
															+                "emission": [
														
 
															+                    0,
														
 
															+                    0,
														
 
															+                    0,
														
 
															+                    1
														
 
															+                ],
														
 
															+                "shininess": 50,
														
 
															+                "specular": [
														
 
															+                    0.5,
														
 
															+                    0.5,
														
 
															+                    0.5,
														
 
															+                    1
														
 
															+                ]
														
 
															+            }
														
 
															+        }
														
 
															+    },
														
 
															+    "meshes": {
														
 
															+        "Cylinder-mesh": {
														
 
															+            "name": "Cylinder",
														
 
															+            "primitives": [
														
 
															+                {
														
 
															+                    "attributes": {
														
 
															+                        "JOINT": "accessor_40",
														
 
															+                        "NORMAL": "accessor_20",
														
 
															+                        "POSITION": "accessor_18",
														
 
															+                        "WEIGHT": "accessor_37"
														
 
															+                    },
														
 
															+                    "indices": "accessor_16",
														
 
															+                    "material": "Material_001-effect",
														
 
															+                    "mode": 4
														
 
															+                }
														
 
															+            ]
														
 
															+        }
														
 
															+    },
														
 
															+    "nodes": {
														
 
															+        "Armature": {
														
 
															+            "children": [
														
 
															+                "Bone"
														
 
															+            ],
														
 
															+            "matrix": [
														
 
															+                1,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                1,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                1,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                1
														
 
															+            ],
														
 
															+            "name": "Armature"
														
 
															+        },
														
 
															+        "Bone": {
														
 
															+            "children": [
														
 
															+                "Bone_001"
														
 
															+            ],
														
 
															+            "jointName": "Bone",
														
 
															+            "name": "Bone",
														
 
															+            "rotation": [
														
 
															+                0.70474,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0.709465
														
 
															+            ],
														
 
															+            "scale": [
														
 
															+                1,
														
 
															+                1,
														
 
															+                1
														
 
															+            ],
														
 
															+            "translation": [
														
 
															+                0,
														
 
															+                -3.15606e-007,
														
 
															+                -4.18033
														
 
															+            ]
														
 
															+        },
														
 
															+        "Bone_001": {
														
 
															+            "children": [],
														
 
															+            "jointName": "Bone_001",
														
 
															+            "name": "Bone.001",
														
 
															+            "rotation": [
														
 
															+                0.00205211,
														
 
															+                9.94789e-008,
														
 
															+                0.000291371,
														
 
															+                0.999998
														
 
															+            ],
														
 
															+            "scale": [
														
 
															+                1,
														
 
															+                1,
														
 
															+                1
														
 
															+            ],
														
 
															+            "translation": [
														
 
															+                0,
														
 
															+                4.18717,
														
 
															+                0
														
 
															+            ]
														
 
															+        },
														
 
															+        "Cylinder": {
														
 
															+            "children": [],
														
 
															+            "matrix": [
														
 
															+                1,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                1,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                1,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                1
														
 
															+            ],
														
 
															+            "meshes": [
														
 
															+                "Cylinder-mesh"
														
 
															+            ],
														
 
															+            "name": "Cylinder",
														
 
															+            "skeletons": [
														
 
															+                "Bone"
														
 
															+            ],
														
 
															+            "skin": "Armature_Cylinder-skin"
														
 
															+        },
														
 
															+        "node_4": {
														
 
															+            "children": [
														
 
															+                "Armature",
														
 
															+                "Cylinder"
														
 
															+            ],
														
 
															+            "matrix": [
														
 
															+                1,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                -1,
														
 
															+                0,
														
 
															+                0,
														
 
															+                1,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                1
														
 
															+            ],
														
 
															+            "name": "Y_UP_Transform"
														
 
															+        }
														
 
															+    },
														
 
															+    "programs": {
														
 
															+        "program_0": {
														
 
															+            "attributes": [
														
 
															+                "a_joint",
														
 
															+                "a_normal",
														
 
															+                "a_position",
														
 
															+                "a_weight"
														
 
															+            ],
														
 
															+            "fragmentShader": "RiggedSimple0FS",
														
 
															+            "vertexShader": "RiggedSimple0VS"
														
 
															+        }
														
 
															+    },
														
 
															+    "scene": "defaultScene",
														
 
															+    "scenes": {
														
 
															+        "defaultScene": {
														
 
															+            "nodes": [
														
 
															+                "node_4"
														
 
															+            ]
														
 
															+        }
														
 
															+    },
														
 
															+    "shaders": {
														
 
															+        "RiggedSimple0FS": {
														
 
															+            "type": 35632,
														
 
															+            "uri": "RiggedSimple0FS.glsl"
														
 
															+        },
														
 
															+        "RiggedSimple0VS": {
														
 
															+            "type": 35633,
														
 
															+            "uri": "RiggedSimple0VS.glsl"
														
 
															+        }
														
 
															+    },
														
 
															+    "skins": {
														
 
															+        "Armature_Cylinder-skin": {
														
 
															+            "bindShapeMatrix": [
														
 
															+                1,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                1,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                1,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                0,
														
 
															+                1
														
 
															+            ],
														
 
															+            "inverseBindMatrices": "IBM_Armature_Cylinder-skin",
														
 
															+            "jointNames": [
														
 
															+                "Bone",
														
 
															+                "Bone_001"
														
 
															+            ],
														
 
															+            "name": "Armature"
														
 
															+        }
														
 
															+    },
														
 
															+    "techniques": {
														
 
															+        "technique0": {
														
 
															+            "attributes": {
														
 
															+                "a_joint": "joint",
														
 
															+                "a_normal": "normal",
														
 
															+                "a_position": "position",
														
 
															+                "a_weight": "weight"
														
 
															+            },
														
 
															+            "parameters": {
														
 
															+                "ambient": {
														
 
															+                    "type": 35666
														
 
															+                },
														
 
															+                "diffuse": {
														
 
															+                    "type": 35666
														
 
															+                },
														
 
															+                "emission": {
														
 
															+                    "type": 35666
														
 
															+                },
														
 
															+                "joint": {
														
 
															+                    "semantic": "JOINT",
														
 
															+                    "type": 35666
														
 
															+                },
														
 
															+                "jointMat": {
														
 
															+                    "count": 2,
														
 
															+                    "semantic": "JOINTMATRIX",
														
 
															+                    "type": 35676
														
 
															+                },
														
 
															+                "modelViewMatrix": {
														
 
															+                    "semantic": "MODELVIEW",
														
 
															+                    "type": 35676
														
 
															+                },
														
 
															+                "normal": {
														
 
															+                    "semantic": "NORMAL",
														
 
															+                    "type": 35665
														
 
															+                },
														
 
															+                "normalMatrix": {
														
 
															+                    "semantic": "MODELVIEWINVERSETRANSPOSE",
														
 
															+                    "type": 35675
														
 
															+                },
														
 
															+                "position": {
														
 
															+                    "semantic": "POSITION",
														
 
															+                    "type": 35665
														
 
															+                },
														
 
															+                "projectionMatrix": {
														
 
															+                    "semantic": "PROJECTION",
														
 
															+                    "type": 35676
														
 
															+                },
														
 
															+                "shininess": {
														
 
															+                    "type": 5126
														
 
															+                },
														
 
															+                "specular": {
														
 
															+                    "type": 35666
														
 
															+                },
														
 
															+                "weight": {
														
 
															+                    "semantic": "WEIGHT",
														
 
															+                    "type": 35666
														
 
															+                }
														
 
															+            },
														
 
															+            "program": "program_0",
														
 
															+            "states": {
														
 
															+                "enable": [
														
 
															+                    2929,
														
 
															+                    2884
														
 
															+                ]
														
 
															+            },
														
 
															+            "uniforms": {
														
 
															+                "u_ambient": "ambient",
														
 
															+                "u_diffuse": "diffuse",
														
 
															+                "u_emission": "emission",
														
 
															+                "u_jointMat": "jointMat",
														
 
															+                "u_modelViewMatrix": "modelViewMatrix",
														
 
															+                "u_normalMatrix": "normalMatrix",
														
 
															+                "u_projectionMatrix": "projectionMatrix",
														
 
															+                "u_shininess": "shininess",
														
 
															+                "u_specular": "specular"
														
 
															+            }
														
 
															+        }
														
 
															+    }
														
 
															+}
														
--- a/examples/models/gltf/RiggedSimple/glTF/RiggedSimple0FS.glsl
+++ b/examples/models/gltf/RiggedSimple/glTF/RiggedSimple0FS.glsl
@@ -0,0 +1,24 @@
 
															+precision highp float;
														
 
															+varying vec3 v_normal;
														
 
															+uniform vec4 u_ambient;
														
 
															+uniform vec4 u_diffuse;
														
 
															+uniform vec4 u_emission;
														
 
															+uniform vec4 u_specular;
														
 
															+uniform float u_shininess;
														
 
															+void main(void) {
														
 
															+vec3 normal = normalize(v_normal);
														
 
															+vec4 color = vec4(0., 0., 0., 0.);
														
 
															+vec4 diffuse = vec4(0., 0., 0., 1.);
														
 
															+vec4 emission;
														
 
															+vec4 ambient;
														
 
															+vec4 specular;
														
 
															+ambient = u_ambient;
														
 
															+diffuse = u_diffuse;
														
 
															+emission = u_emission;
														
 
															+specular = u_specular;
														
 
															+diffuse.xyz *= max(dot(normal,vec3(0.,0.,1.)), 0.);
														
 
															+color.xyz += diffuse.xyz;
														
 
															+color.xyz += emission.xyz;
														
 
															+color = vec4(color.rgb * diffuse.a, diffuse.a);
														
 
															+gl_FragColor = color;
														
 
															+}
														
--- a/examples/models/gltf/RiggedSimple/glTF/RiggedSimple0VS.glsl
+++ b/examples/models/gltf/RiggedSimple/glTF/RiggedSimple0VS.glsl
@@ -0,0 +1,19 @@
 
															+precision highp float;
														
 
															+attribute vec3 a_position;
														
 
															+attribute vec3 a_normal;
														
 
															+varying vec3 v_normal;
														
 
															+attribute vec4 a_joint;
														
 
															+attribute vec4 a_weight;
														
 
															+uniform mat4 u_jointMat[2];
														
 
															+uniform mat3 u_normalMatrix;
														
 
															+uniform mat4 u_modelViewMatrix;
														
 
															+uniform mat4 u_projectionMatrix;
														
 
															+void main(void) {
														
 
															+mat4 skinMat = a_weight.x * u_jointMat[int(a_joint.x)];
														
 
															+skinMat += a_weight.y * u_jointMat[int(a_joint.y)];
														
 
															+skinMat += a_weight.z * u_jointMat[int(a_joint.z)];
														
 
															+skinMat += a_weight.w * u_jointMat[int(a_joint.w)];
														
 
															+vec4 pos = u_modelViewMatrix * skinMat * vec4(a_position,1.0);
														
 
															+v_normal = u_normalMatrix * mat3(skinMat)* a_normal;
														
 
															+gl_Position = u_projectionMatrix * pos;
														
 
															+}
														
--- a/examples/models/json/suzanne.json
+++ b/examples/models/json/suzanne.json
--- a/examples/webgl_animation_skinning_morph.html
+++ b/examples/webgl_animation_skinning_morph.html
@@ -198,6 +198,7 @@
 
															 				for ( var i = 0; i < materials.length; i ++ ) {
														
 
															 					var m = materials[ i ];
														
 
															+					m.skinning = true;
														
 
															 					m.morphTargets = true;
														
 
															 					m.specular.setHSL( 0, 0, 0.1 );
														
@@ -214,7 +215,7 @@
 
															 				}
														
 
															-				mesh = new THREE.SkinnedMesh( geometry, new THREE.MultiMaterial( materials ) );
														
 
															+				mesh = new THREE.SkinnedMesh( geometry, materials );
														
 
															 				mesh.name = "Knight Mesh";
														
 
															 				mesh.position.set( x, y - bb.min.y * s, z );
														
 
															 				mesh.scale.set( s, s, s );
														
@@ -224,7 +225,7 @@
 
															 				mesh.receiveShadow = true;
														
 
															-				mesh2 = new THREE.SkinnedMesh( geometry, new THREE.MultiMaterial( materials ) );
														
 
															+				mesh2 = new THREE.SkinnedMesh( geometry, materials );
														
 
															 				mesh2.name = "Lil' Bro Mesh";
														
 
															 				mesh2.position.set( x - 240, y - bb.min.y * s, z + 500 );
														
 
															 				mesh2.scale.set( s / 2, s / 2, s / 2 );
														
--- a/examples/webgl_decals.html
+++ b/examples/webgl_decals.html
@@ -1,30 +1,38 @@
 
															 <!DOCTYPE html>
														
 
															 <html lang="en">
														
 
															 	<head>
														
 
															-		<title>WebGL decals</title>
														
 
															+		<title>three.js webgl - decals - Decal Splatter</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 {
														
 
															-				color: #fff;
														
 
															+				background:#777;
														
 
															+				padding:0;
														
 
															+				margin:0;
														
 
															+				font-weight: bold;
														
 
															+				overflow:hidden;
														
 
															+			}
														
 
															+
														
 
															+			#info {
														
 
															+				position: absolute;
														
 
															+				top: 0px;
														
 
															+				width: 100%;
														
 
															+				color: #ffffff;
														
 
															+				padding: 5px;
														
 
															 				font-family:Monospace;
														
 
															 				font-size:13px;
														
 
															-				margin: 0px;
														
 
															 				text-align:center;
														
 
															-				overflow: hidden;
														
 
															 			}
														
 
															-			#info{ position: absolute; width: 100%; padding: 5px; }
														
 
															+
														
 
															+			a {
														
 
															+				color: #ffffff;
														
 
															+			}
														
 
															 		</style>
														
 
															 	</head>
														
 
															 	<body>
														
 
															 		<div id="container"></div>
														
 
															-		<div id="info">
														
 
															-			<p>
														
 
															-				<strong>Decal Splatter</strong><br />
														
 
															-				Click or tap to shoot.
														
 
															-			</p>
														
 
															-		</div>
														
 
															+		<div id="info"><a href="https://threejs.org" target="_blank">three.js</a> - decals - Decal Splatter (click or tap to shoot)</div>
														
 
															 		<script src="../build/three.js"></script>
														
 
															 		<script src="js/geometries/DecalGeometry.js"></script>
														
@@ -67,15 +75,13 @@
 
															 		} );
														
 
															 		var decals = [];
														
 
															-		var decalHelper, mouseHelper;
														
 
															-		var p = new THREE.Vector3( 0, 0, 0 );
														
 
															-		var r = new THREE.Vector3( 0, 0, 0 );
														
 
															-		var s = new THREE.Vector3( 10, 10, 10 );
														
 
															+		var mouseHelper;
														
 
															+		var position = new THREE.Vector3();
														
 
															+		var orientation = new THREE.Euler();
														
 
															+		var size = new THREE.Vector3( 10, 10, 10 );
														
 
															 		var up = new THREE.Vector3( 0, 1, 0 );
														
 
															-		var check = new THREE.Vector3( 1, 1, 1 );
														
 
															 		var params = {
														
 
															-			projection: 'normal',
														
 
															 			minScale: 10,
														
 
															 			maxScale: 20,
														
 
															 			rotate: true,
														
@@ -98,7 +104,7 @@
 
															 			scene = new THREE.Scene();
														
 
															 			camera = new THREE.PerspectiveCamera( fov, window.innerWidth / window.innerHeight, 1, 1000 );
														
 
															-			camera.position.z = 100;
														
 
															+			camera.position.z = 120;
														
 
															 			camera.target = new THREE.Vector3();
														
 
															 			controls = new THREE.OrbitControls( camera, renderer.domElement );
														
@@ -148,7 +154,7 @@
 
															 			window.addEventListener( 'mouseup', function() {
														
 
															 				checkIntersection();
														
 
															-				if ( ! moved ) shoot();
														
 
															+				if ( ! moved && intersection.intersects ) shoot();
														
 
															 			} );
														
@@ -213,7 +219,6 @@
 
															 			var gui = new dat.GUI();
														
 
															-			gui.add( params, 'projection', { 'From cam to mesh': 'camera', 'Normal to mesh': 'normal' } );
														
 
															 			gui.add( params, 'minScale', 1, 30 );
														
 
															 			gui.add( params, 'maxScale', 1, 30 );
														
 
															 			gui.add( params, 'rotate' );
														
@@ -236,7 +241,6 @@
 
															 					map: textureLoader.load( 'obj/leeperrysmith/Map-COL.jpg' ),
														
 
															 					specularMap: textureLoader.load( 'obj/leeperrysmith/Map-SPEC.jpg' ),
														
 
															 					normalMap: textureLoader.load( 'obj/leeperrysmith/Infinite-Level_02_Tangent_SmoothUV.jpg' ),
														
 
															-					normalScale: new THREE.Vector2( 0.75, 0.75 ),
														
 
															 					shininess: 25
														
 
															 				} );
														
@@ -244,50 +248,25 @@
 
															 				scene.add( mesh );
														
 
															 				mesh.scale.set( 10, 10, 10 );
														
 
															-				//scene.add( new THREE.FaceNormalsHelper( mesh, 1 ) );
														
 
															-				//scene.add( new THREE.VertexNormalsHelper( mesh, 1 ) );
														
 
															-
														
 
															 			} );
														
 
															 		}
														
 
															 		function shoot() {
														
 
															-			if ( params.projection == 'camera' ) {
														
 
															-
														
 
															-				var dir = camera.target.clone();
														
 
															-				dir.sub( camera.position );
														
 
															-
														
 
															-				p = intersection.point;
														
 
															+			position.copy( intersection.point );
														
 
															+			orientation.copy( mouseHelper.rotation );
														
 
															-				var m = new THREE.Matrix4();
														
 
															-				var c = dir.clone();
														
 
															-				c.negate();
														
 
															-				c.multiplyScalar( 10 );
														
 
															-				c.add( p );
														
 
															-				m.lookAt( p, c, up );
														
 
															-				m = m.extractRotation( m );
														
 
															-
														
 
															-				dummy = new THREE.Object3D();
														
 
															-				dummy.rotation.setFromRotationMatrix( m );
														
 
															-				r.set( dummy.rotation.x, dummy.rotation.y, dummy.rotation.z );
														
 
															-
														
 
															-			} else {
														
 
															-
														
 
															-				p = intersection.point;
														
 
															-				r.copy( mouseHelper.rotation );
														
 
															-
														
 
															-			}
														
 
															+			if ( params.rotate ) orientation.z = Math.random() * 2 * Math.PI;
														
 
															 			var scale = params.minScale + Math.random() * ( params.maxScale - params.minScale );
														
 
															-			s.set( scale, scale, scale );
														
 
															-
														
 
															-			if ( params.rotate ) r.z = Math.random() * 2 * Math.PI;
														
 
															+			size.set( scale, scale, scale );
														
 
															 			var material = decalMaterial.clone();
														
 
															 			material.color.setHex( Math.random() * 0xffffff );
														
 
															-			var m = new THREE.Mesh( new THREE.DecalGeometry( mesh, p, r, s, check ), material );
														
 
															+			var m = new THREE.Mesh( new THREE.DecalGeometry( mesh, position, orientation, size ), material );
														
 
															+
														
 
															 			decals.push( m );
														
 
															 			scene.add( m );
														
@@ -298,36 +277,10 @@
 
															 			decals.forEach( function( d ) {
														
 
															 				scene.remove( d );
														
 
															-				d = null;
														
 
															 			} );
														
 
															-			decals = [];
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-		function mergeDecals() {
														
 
															-
														
 
															-			var merge = {};
														
 
															-			decals.forEach( function ( decal ) {
														
 
															-
														
 
															-				var uuid = decal.material.uuid;
														
 
															-				var d = merge[ uuid ] = merge[ uuid ] || {};
														
 
															-				d.material = d.material || decal.material;
														
 
															-				d.geometry = d.geometry || new THREE.Geometry();
														
 
															-				d.geometry.merge( decal.geometry, decal.matrix );
														
 
															-
														
 
															-			} );
														
 
															-
														
 
															-			removeDecals();
														
 
															-			for ( var key in merge ) {
														
 
															-
														
 
															-				var d = merge[ key ];
														
 
															-				var mesh = new THREE.Mesh( d.geometry, d.material );
														
 
															-				scene.add( mesh );
														
 
															-				decals.push( mesh );
														
 
															-
														
 
															-			}
														
 
															+			decals = [];
														
 
															 		}
														
--- a/examples/webgl_effects_parallaxbarrier.html
+++ b/examples/webgl_effects_parallaxbarrier.html
@@ -517,7 +517,7 @@
 
															 			}
														
 
															-			function attachButtonMaterials( materials, faceMaterial, material_indices, car ) {
														
 
															+			function attachButtonMaterials( materials, faceMaterials, material_indices, car ) {
														
 
															 				for( var i = 0; i < materials.length; i++ ) {
														
@@ -526,7 +526,7 @@
 
															 						for ( var j = 0; j < material_indices.length; j ++ ) {
														
 
															-							faceMaterial.materials[ material_indices [ j ] ] = materials[ this.counter ][ 1 ];
														
 
															+							faceMaterials[ material_indices [ j ] ] = materials[ this.counter ][ 1 ];
														
 
															 						}
														
@@ -540,7 +540,7 @@
 
															 				geometry.sortFacesByMaterialIndex();
														
 
															-				var m = new THREE.MultiMaterial(),
														
 
															+				var m = [],
														
 
															 					s = CARS[ car ].scale * 1,
														
 
															 					r = CARS[ car ].init_rotation,
														
 
															 					materials = CARS[ car ].materials,
														
@@ -549,7 +549,7 @@
 
															 				for( var i in CARS[ car ].mmap ) {
														
 
															-					m.materials[ i ] = CARS[ car ].mmap[ i ];
														
 
															+					m[ i ] = CARS[ car ].mmap[ i ];
														
 
															 				}
														
--- a/examples/webgl_effects_peppersghost.html
+++ b/examples/webgl_effects_peppersghost.html
@@ -125,8 +125,6 @@
 
															 		function render() {
														
 
															-				camera.lookAt( scene.position );
														
 
															-
														
 
															 				group.rotation.y += 0.01;
														
 
															 				effect.render( scene, camera );
														
--- a/examples/webgl_geometry_colors_blender.html
+++ b/examples/webgl_geometry_colors_blender.html
@@ -107,7 +107,7 @@
 
															 				materials[ 0 ].shading = THREE.FlatShading;
														
 
															-				mesh = new THREE.Mesh( geometry, new THREE.MultiMaterial( materials ) );
														
 
															+				mesh = new THREE.Mesh( geometry, materials );
														
 
															 				mesh.position.x = 400;
														
 
															 				mesh.scale.x = mesh.scale.y = mesh.scale.z = 250;
														
 
															 				scene.add( mesh );
														
@@ -118,7 +118,7 @@
 
															 				materials[ 0 ].shading = THREE.FlatShading;
														
 
															-				mesh2 = new THREE.Mesh( geometry, new THREE.MultiMaterial( materials ) );
														
 
															+				mesh2 = new THREE.Mesh( geometry, materials );
														
 
															 				mesh2.position.x = - 400;
														
 
															 				mesh2.scale.x = mesh2.scale.y = mesh2.scale.z = 250;
														
 
															 				scene.add( mesh2 );
														
--- a/examples/webgl_geometry_extrude_shapes.html
+++ b/examples/webgl_geometry_extrude_shapes.html
@@ -170,7 +170,7 @@
 
															 				var geometry = new THREE.ExtrudeGeometry( shape, extrudeSettings );
														
 
															-				var mesh = new THREE.Mesh( geometry, new THREE.MultiMaterial( materials ) );
														
 
															+				var mesh = new THREE.Mesh( geometry, materials );
														
 
															 				mesh.position.set( 50, 100, 50 );
														
--- a/examples/webgl_geometry_shapes.html
+++ b/examples/webgl_geometry_shapes.html
@@ -33,7 +33,6 @@
 
															 			var mouseXOnMouseDown = 0;
														
 
															 			var windowHalfX = window.innerWidth / 2;
														
 
															-			var windowHalfY = window.innerHeight / 2;
														
 
															 			init();
														
 
															 			animate();
														
@@ -105,6 +104,12 @@
 
															 					mesh.scale.set( s, s, s );
														
 
															 					group.add( mesh );
														
 
															+					addLineShape( shape, color, x, y, z, rx, ry, rz, s );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				function addLineShape( shape, color, x, y, z, rx, ry, rz, s ) {
														
 
															+
														
 
															 					// lines
														
 
															 					shape.autoClose = true;
														
@@ -150,28 +155,28 @@
 
															 				var californiaPts = [];
														
 
															-				californiaPts.push( new THREE.Vector2 ( 610, 320 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 450, 300 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 392, 392 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 266, 438 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 190, 570 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 190, 600 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 160, 620 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 160, 650 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 180, 640 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 165, 680 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 150, 670 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 (  90, 737 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 (  80, 795 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 (  50, 835 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 (  64, 870 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 (  60, 945 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 300, 945 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 300, 743 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 600, 473 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 626, 425 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 600, 370 ) );
														
 
															-				californiaPts.push( new THREE.Vector2 ( 610, 320 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 610, 320 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 450, 300 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 392, 392 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 266, 438 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 190, 570 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 190, 600 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 160, 620 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 160, 650 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 180, 640 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 165, 680 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 150, 670 ) );
														
 
															+				californiaPts.push( new THREE.Vector2(  90, 737 ) );
														
 
															+				californiaPts.push( new THREE.Vector2(  80, 795 ) );
														
 
															+				californiaPts.push( new THREE.Vector2(  50, 835 ) );
														
 
															+				californiaPts.push( new THREE.Vector2(  64, 870 ) );
														
 
															+				californiaPts.push( new THREE.Vector2(  60, 945 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 300, 945 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 300, 743 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 600, 473 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 626, 425 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 600, 370 ) );
														
 
															+				californiaPts.push( new THREE.Vector2( 610, 320 ) );
														
 
															 				for( var i = 0; i < californiaPts.length; i ++ ) californiaPts[ i ].multiplyScalar( 0.25 );
														
@@ -181,10 +186,10 @@
 
															 				// Triangle
														
 
															 				var triangleShape = new THREE.Shape();
														
 
															-				triangleShape.moveTo(  80, 20 );
														
 
															-				triangleShape.lineTo(  40, 80 );
														
 
															+				triangleShape.moveTo( 80, 20 );
														
 
															+				triangleShape.lineTo( 40, 80 );
														
 
															 				triangleShape.lineTo( 120, 80 );
														
 
															-				triangleShape.lineTo(  80, 20 ); // close path
														
 
															+				triangleShape.lineTo( 80, 20 ); // close path
														
 
															 				// Heart
														
@@ -195,7 +200,7 @@
 
															 				heartShape.moveTo( x + 25, y + 25 );
														
 
															 				heartShape.bezierCurveTo( x + 25, y + 25, x + 20, y, x, y );
														
 
															-				heartShape.bezierCurveTo( x - 30, y, x - 30, y + 35,x - 30,y + 35 );
														
 
															+				heartShape.bezierCurveTo( x - 30, y, x - 30, y + 35, x - 30, y + 35 );
														
 
															 				heartShape.bezierCurveTo( x - 30, y + 55, x - 10, y + 77, x + 25, y + 95 );
														
 
															 				heartShape.bezierCurveTo( x + 60, y + 77, x + 80, y + 55, x + 80, y + 35 );
														
 
															 				heartShape.bezierCurveTo( x + 80, y + 35, x + 80, y, x + 50, y );
														
@@ -207,7 +212,7 @@
 
															 				var sqLength = 80;
														
 
															 				var squareShape = new THREE.Shape();
														
 
															-				squareShape.moveTo( 0,0 );
														
 
															+				squareShape.moveTo( 0, 0 );
														
 
															 				squareShape.lineTo( 0, sqLength );
														
 
															 				squareShape.lineTo( sqLength, sqLength );
														
 
															 				squareShape.lineTo( sqLength, 0 );
														
@@ -219,7 +224,7 @@
 
															 				var rectLength = 120, rectWidth = 40;
														
 
															 				var rectShape = new THREE.Shape();
														
 
															-				rectShape.moveTo( 0,0 );
														
 
															+				rectShape.moveTo( 0, 0 );
														
 
															 				rectShape.lineTo( 0, rectWidth );
														
 
															 				rectShape.lineTo( rectLength, rectWidth );
														
 
															 				rectShape.lineTo( rectLength, 0 );
														
@@ -230,12 +235,12 @@
 
															 				var roundedRectShape = new THREE.Shape();
														
 
															-				( function roundedRect( ctx, x, y, width, height, radius ){
														
 
															+				( function roundedRect( ctx, x, y, width, height, radius ) {
														
 
															 					ctx.moveTo( x, y + radius );
														
 
															 					ctx.lineTo( x, y + height - radius );
														
 
															 					ctx.quadraticCurveTo( x, y + height, x + radius, y + height );
														
 
															-					ctx.lineTo( x + width - radius, y + height) ;
														
 
															+					ctx.lineTo( x + width - radius, y + height );
														
 
															 					ctx.quadraticCurveTo( x + width, y + height, x + width, y + height - radius );
														
 
															 					ctx.lineTo( x + width, y + radius );
														
 
															 					ctx.quadraticCurveTo( x + width, y, x + width - radius, y );
														
@@ -262,9 +267,9 @@
 
															 				var circleShape = new THREE.Shape();
														
 
															 				circleShape.moveTo( 0, circleRadius );
														
 
															 				circleShape.quadraticCurveTo( circleRadius, circleRadius, circleRadius, 0 );
														
 
															-				circleShape.quadraticCurveTo( circleRadius, -circleRadius, 0, -circleRadius );
														
 
															-				circleShape.quadraticCurveTo( -circleRadius, -circleRadius, -circleRadius, 0 );
														
 
															-				circleShape.quadraticCurveTo( -circleRadius, circleRadius, 0, circleRadius );
														
 
															+				circleShape.quadraticCurveTo( circleRadius, - circleRadius, 0, - circleRadius );
														
 
															+				circleShape.quadraticCurveTo( - circleRadius, - circleRadius, - circleRadius, 0 );
														
 
															+				circleShape.quadraticCurveTo( - circleRadius, circleRadius, 0, circleRadius );
														
 
															 				// Fish
														
@@ -273,23 +278,23 @@
 
															 				var fishShape = new THREE.Shape();
														
 
															-				fishShape.moveTo(x,y);
														
 
															-				fishShape.quadraticCurveTo(x + 50, y - 80, x + 90, y - 10);
														
 
															-				fishShape.quadraticCurveTo(x + 100, y - 10, x + 115, y - 40);
														
 
															-				fishShape.quadraticCurveTo(x + 115, y, x + 115, y + 40);
														
 
															-				fishShape.quadraticCurveTo(x + 100, y + 10, x + 90, y + 10);
														
 
															-				fishShape.quadraticCurveTo(x + 50, y + 80, x, y);
														
 
															+				fishShape.moveTo( x, y );
														
 
															+				fishShape.quadraticCurveTo( x + 50, y - 80, x + 90, y - 10 );
														
 
															+				fishShape.quadraticCurveTo( x + 100, y - 10, x + 115, y - 40 );
														
 
															+				fishShape.quadraticCurveTo( x + 115, y, x + 115, y + 40 );
														
 
															+				fishShape.quadraticCurveTo( x + 100, y + 10, x + 90, y + 10 );
														
 
															+				fishShape.quadraticCurveTo( x + 50, y + 80, x, y );
														
 
															 				// Arc circle
														
 
															 				var arcShape = new THREE.Shape();
														
 
															 				arcShape.moveTo( 50, 10 );
														
 
															-				arcShape.absarc( 10, 10, 40, 0, Math.PI*2, false );
														
 
															+				arcShape.absarc( 10, 10, 40, 0, Math.PI * 2, false );
														
 
															 				var holePath = new THREE.Path();
														
 
															 				holePath.moveTo( 20, 10 );
														
 
															-				holePath.absarc( 10, 10, 10, 0, Math.PI*2, true );
														
 
															+				holePath.absarc( 10, 10, 10, 0, Math.PI * 2, true );
														
 
															 				arcShape.holes.push( holePath );
														
@@ -297,17 +302,17 @@
 
															 				var smileyShape = new THREE.Shape();
														
 
															 				smileyShape.moveTo( 80, 40 );
														
 
															-				smileyShape.absarc( 40, 40, 40, 0, Math.PI*2, false );
														
 
															+				smileyShape.absarc( 40, 40, 40, 0, Math.PI * 2, false );
														
 
															 				var smileyEye1Path = new THREE.Path();
														
 
															 				smileyEye1Path.moveTo( 35, 20 );
														
 
															-				smileyEye1Path.absellipse( 25, 20, 10, 10, 0, Math.PI*2, true );
														
 
															+				smileyEye1Path.absellipse( 25, 20, 10, 10, 0, Math.PI * 2, true );
														
 
															 				smileyShape.holes.push( smileyEye1Path );
														
 
															 				var smileyEye2Path = new THREE.Path();
														
 
															 				smileyEye2Path.moveTo( 65, 20 );
														
 
															-				smileyEye2Path.absarc( 55, 20, 10, 0, Math.PI*2, true );
														
 
															+				smileyEye2Path.absarc( 55, 20, 10, 0, Math.PI * 2, true );
														
 
															 				smileyShape.holes.push( smileyEye2Path );
														
 
															 				var smileyMouthPath = new THREE.Path();
														
@@ -323,10 +328,10 @@
 
															 				// Spline shape
														
 
															 				var splinepts = [];
														
 
															-				splinepts.push( new THREE.Vector2 ( 70, 20 ) );
														
 
															-				splinepts.push( new THREE.Vector2 ( 80, 90 ) );
														
 
															-				splinepts.push( new THREE.Vector2 ( -30, 70 ) );
														
 
															-				splinepts.push( new THREE.Vector2 ( 0, 0 ) );
														
 
															+				splinepts.push( new THREE.Vector2( 70, 20 ) );
														
 
															+				splinepts.push( new THREE.Vector2( 80, 90 ) );
														
 
															+				splinepts.push( new THREE.Vector2( - 30, 70 ) );
														
 
															+				splinepts.push( new THREE.Vector2( 0, 0 ) );
														
 
															 				var splineShape = new THREE.Shape();
														
 
															 				splineShape.moveTo( 0, 0 );
														
@@ -343,10 +348,18 @@
 
															 				addShape( squareShape,      extrudeSettings, 0x0040f0,  150,  100, 0, 0, 0, 0, 1 );
														
 
															 				addShape( heartShape,       extrudeSettings, 0xf00000,   60,  100, 0, 0, 0, Math.PI, 1 );
														
 
															 				addShape( circleShape,      extrudeSettings, 0x00f000,  120,  250, 0, 0, 0, 0, 1 );
														
 
															-				addShape( fishShape,        extrudeSettings, 0x404040,  -60,  200, 0, 0, 0, 0, 1 );
														
 
															+				addShape( fishShape,        extrudeSettings, 0x404040, - 60,  200, 0, 0, 0, 0, 1 );
														
 
															 				addShape( smileyShape,      extrudeSettings, 0xf000f0, -200,  250, 0, 0, 0, Math.PI, 1 );
														
 
															 				addShape( arcShape,         extrudeSettings, 0x804000,  150,    0, 0, 0, 0, 0, 1 );
														
 
															-				addShape( splineShape,      extrudeSettings, 0x808080,  -50, -100, 0, 0, 0, 0, 1 );
														
 
															+				addShape( splineShape,      extrudeSettings, 0x808080, - 50, -100, 0, 0, 0, 0, 1 );
														
 
															+
														
 
															+				addLineShape( arcShape.holes[ 0 ], 0x804000, 150, 0, 0, 0, 0, 0, 1 );
														
 
															+
														
 
															+				for ( var i = 0; i < smileyShape.holes.length; i += 1 ) {
														
 
															+
														
 
															+					addLineShape( smileyShape.holes[ i ], 0xf000f0, - 200, 250, 0, 0, 0, Math.PI, 1 );
														
 
															+
														
 
															+				}
														
 
															 				//
														
@@ -371,9 +384,6 @@
 
															 			function onWindowResize() {
														
 
															-				windowHalfX = window.innerWidth / 2;
														
 
															-				windowHalfY = window.innerHeight / 2;
														
 
															-
														
 
															 				camera.aspect = window.innerWidth / window.innerHeight;
														
 
															 				camera.updateProjectionMatrix();
														
--- a/examples/webgl_geometry_spline_editor.html
+++ b/examples/webgl_geometry_spline_editor.html
@@ -11,10 +11,23 @@
 
															 				margin: 0px;
														
 
															 				overflow: hidden;
														
 
															 			}
														
 
															+
														
 
															+			#info {
														
 
															+				position: absolute;
														
 
															+				top: 0px;
														
 
															+				width: 100%;
														
 
															+				padding: 5px;
														
 
															+				font-family:Monospace;
														
 
															+				font-size:13px;
														
 
															+				text-align:center;
														
 
															+			}
														
 
															 		</style>
														
 
															 	</head>
														
 
															 	<body>
														
 
															+		<div id="container"></div>
														
 
															+		<div id="info"><a href="https://threejs.org" target="_blank">three.js</a> - geometry - catmull spline editor</div>
														
 
															+
														
 
															 		<script src="../build/three.js"></script>
														
 
															 		<script src="js/controls/DragControls.js"></script>
														
@@ -22,6 +35,7 @@
 
															 		<script src="js/controls/TransformControls.js"></script>
														
 
															 		<script src="js/libs/stats.min.js"></script>
														
 
															+		<script src="js/libs/dat.gui.min.js"></script>
														
 
															 		<script>
														
@@ -39,8 +53,7 @@
 
															 			var container, stats;
														
 
															 			var camera, scene, renderer;
														
 
															-			var splineHelperObjects = [],
														
 
															-				splineOutline;
														
 
															+			var splineHelperObjects = [], splineOutline;
														
 
															 			var splinePointsLength = 4;
														
 
															 			var positions = [];
														
 
															 			var options;
														
@@ -50,8 +63,16 @@
 
															 			var ARC_SEGMENTS = 200;
														
 
															 			var splineMesh;
														
 
															-			var splines = {
														
 
															+			var splines = {};
														
 
															+			var params = {
														
 
															+				uniform: true,
														
 
															+				tension: 0.5,
														
 
															+				centripetal: true,
														
 
															+				chordal: true,
														
 
															+				addPoint: addPoint,
														
 
															+				removePoint: removePoint,
														
 
															+				exportSpline: exportSpline
														
 
															 			};
														
 
															 			init();
														
@@ -59,11 +80,11 @@
 
															 			function init() {
														
 
															-				container = document.createElement( 'div' );
														
 
															-				document.body.appendChild( container );
														
 
															+				container = document.getElementById( 'container' );
														
 
															+
														
 
															 				scene = new THREE.Scene();
														
 
															 				camera = new THREE.PerspectiveCamera( 70, window.innerWidth / window.innerHeight, 1, 10000 );
														
 
															-				camera.position.z = 1000;
														
 
															+				camera.position.set( 0, 250, 1000 );
														
 
															 				scene.add( camera );
														
 
															 				scene.add( new THREE.AmbientLight( 0xf0f0f0 ) );
														
@@ -106,31 +127,23 @@
 
															 				renderer.shadowMap.enabled = true;
														
 
															 				container.appendChild( renderer.domElement );
														
 
															-				var info = document.createElement( 'div' );
														
 
															-				info.style.position = 'absolute';
														
 
															-				info.style.top = '10px';
														
 
															-				info.style.width = '100%';
														
 
															-				info.style.textAlign = 'center';
														
 
															-				info.innerHTML = 'catmull-rom rom spline comparisions';
														
 
															-				options = document.createElement( 'div' );
														
 
															-				options.style.position = 'absolute';
														
 
															-				options.style.top = '30px';
														
 
															-				options.style.width = '100%';
														
 
															-				options.style.textAlign = 'center';
														
 
															-
														
 
															-				options.innerHTML = 'Points: <input type="button" onclick="addPoint();" value="+" />\
														
 
															-					<input type="button" onclick="removePoint();" value="-" />\
														
 
															-					<input type="button" onclick="exportSpline();" value="Export" /><br />\
														
 
															-					<input type="checkbox" id="uniform" checked /> <label for="uniform">Uniform Catmull-rom</label>  <input type="range" id="tension" onchange="splines.uniform.tension = tension.value;updateSplineOutline();" min=0 max=1 step=0.01 value=0.5 /> <span id="tension_value" /></span> <br />\
														
 
															-					<input type="checkbox" id="centripetal" checked /> Centripetal Catmull-rom<br />\
														
 
															-					<input type="checkbox" id="chordal" checked /> Chordal Catmull-rom<br />';
														
 
															-
														
 
															-				container.appendChild( info );
														
 
															-				container.appendChild( options );
														
 
															-
														
 
															 				stats = new Stats();
														
 
															 				container.appendChild( stats.dom );
														
 
															+				var gui = new dat.GUI();
														
 
															+
														
 
															+				gui.add( params, 'uniform' );
														
 
															+				gui.add( params, 'tension', 0, 1 ).step( 0.01 ).onChange( function( value ) {
														
 
															+					splines.uniform.tension = value;
														
 
															+					updateSplineOutline();
														
 
															+				});
														
 
															+				gui.add( params, 'centripetal' );
														
 
															+				gui.add( params, 'chordal' );
														
 
															+				gui.add( params, 'addPoint' );
														
 
															+				gui.add( params, 'removePoint' );
														
 
															+				gui.add( params, 'exportSpline' );
														
 
															+				gui.open();
														
 
															+
														
 
															 				// Controls
														
 
															 				controls = new THREE.OrbitControls( camera, renderer.domElement );
														
 
															 				controls.damping = 0.2;
														
@@ -377,13 +390,14 @@
 
															 					strplace.push( 'new THREE.Vector3({0}, {1}, {2})'.format( p.x, p.y, p.z ) )
														
 
															 				}
														
 
															+
														
 
															 				console.log( strplace.join( ',\n' ) );
														
 
															 				var code = '[' + ( strplace.join( ',\n\t' ) ) + ']';
														
 
															 				prompt( 'copy and paste code', code );
														
 
															-				}
														
 
															+			}
														
 
															-				function load( new_positions ) {
														
 
															+			function load( new_positions ) {
														
 
															 				while ( new_positions.length > positions.length ) {
														
@@ -412,16 +426,15 @@
 
															 				requestAnimationFrame( animate );
														
 
															 				render();
														
 
															 				stats.update();
														
 
															-				controls.update();
														
 
															 				transformControl.update();
														
 
															 			}
														
 
															 			function render() {
														
 
															-				splines.uniform.mesh.visible = uniform.checked;
														
 
															-				splines.centripetal.mesh.visible = centripetal.checked;
														
 
															-				splines.chordal.mesh.visible = chordal.checked;
														
 
															+				splines.uniform.mesh.visible = params.uniform;
														
 
															+				splines.centripetal.mesh.visible = params.centripetal;
														
 
															+				splines.chordal.mesh.visible = params.chordal;
														
 
															 				renderer.render( scene, camera );
														
 
															 			}
														
--- a/examples/webgl_geometry_text.html
+++ b/examples/webgl_geometry_text.html
@@ -52,7 +52,7 @@
 
															 			var camera, cameraTarget, scene, renderer;
														
 
															-			var group, textMesh1, textMesh2, textGeo, material;
														
 
															+			var group, textMesh1, textMesh2, textGeo, materials;
														
 
															 			var firstLetter = true;
														
@@ -181,10 +181,10 @@
 
															 				}
														
 
															-				material = new THREE.MultiMaterial( [
														
 
															+				materials = [
														
 
															 					new THREE.MeshPhongMaterial( { color: 0xffffff, shading: THREE.FlatShading } ), // front
														
 
															 					new THREE.MeshPhongMaterial( { color: 0xffffff, shading: THREE.SmoothShading } ) // side
														
 
															-				] );
														
 
															+				];
														
 
															 				group = new THREE.Group();
														
 
															 				group.position.y = 100;
														
@@ -427,7 +427,7 @@
 
															 				var centerOffset = -0.5 * ( textGeo.boundingBox.max.x - textGeo.boundingBox.min.x );
														
 
															-				textMesh1 = new THREE.Mesh( textGeo, material );
														
 
															+				textMesh1 = new THREE.Mesh( textGeo, materials );
														
 
															 				textMesh1.position.x = centerOffset;
														
 
															 				textMesh1.position.y = hover;
														
@@ -440,7 +440,7 @@
 
															 				if ( mirror ) {
														
 
															-					textMesh2 = new THREE.Mesh( textGeo, material );
														
 
															+					textMesh2 = new THREE.Mesh( textGeo, materials );
														
 
															 					textMesh2.position.x = centerOffset;
														
 
															 					textMesh2.position.y = -hover;
														
--- a/examples/webgl_geometry_text_earcut.html
+++ b/examples/webgl_geometry_text_earcut.html
@@ -110,7 +110,7 @@
 
															 			var camera, cameraTarget, scene, renderer;
														
 
															-			var group, textMesh1, textMesh2, textGeo, material;
														
 
															+			var group, textMesh1, textMesh2, textGeo, materials;
														
 
															 			var firstLetter = true;
														
@@ -239,10 +239,10 @@
 
															 				}
														
 
															-				material = new THREE.MultiMaterial( [
														
 
															+				materials = [
														
 
															 					new THREE.MeshPhongMaterial( { color: 0xffffff, shading: THREE.FlatShading } ), // front
														
 
															 					new THREE.MeshPhongMaterial( { color: 0xffffff, shading: THREE.SmoothShading } ) // side
														
 
															-				] );
														
 
															+				];
														
 
															 				group = new THREE.Group();
														
 
															 				group.position.y = 100;
														
@@ -485,7 +485,7 @@
 
															 				var centerOffset = -0.5 * ( textGeo.boundingBox.max.x - textGeo.boundingBox.min.x );
														
 
															-				textMesh1 = new THREE.Mesh( textGeo, material );
														
 
															+				textMesh1 = new THREE.Mesh( textGeo, materials );
														
 
															 				textMesh1.position.x = centerOffset;
														
 
															 				textMesh1.position.y = hover;
														
@@ -498,7 +498,7 @@
 
															 				if ( mirror ) {
														
 
															-					textMesh2 = new THREE.Mesh( textGeo, material );
														
 
															+					textMesh2 = new THREE.Mesh( textGeo, materials );
														
 
															 					textMesh2.position.x = centerOffset;
														
 
															 					textMesh2.position.y = -hover;
														
--- a/examples/webgl_geometry_text_pnltri.html
+++ b/examples/webgl_geometry_text_pnltri.html
@@ -82,7 +82,7 @@
 
															 			var camera, cameraTarget, scene, renderer;
														
 
															-			var group, textMesh1, textMesh2, textGeo, material;
														
 
															+			var group, textMesh1, textMesh2, textGeo, materials;
														
 
															 			var firstLetter = true;
														
@@ -211,10 +211,10 @@
 
															 				}
														
 
															-				material = new THREE.MultiMaterial( [
														
 
															+				materials = [
														
 
															 					new THREE.MeshPhongMaterial( { color: 0xffffff, shading: THREE.FlatShading } ), // front
														
 
															 					new THREE.MeshPhongMaterial( { color: 0xffffff, shading: THREE.SmoothShading } ) // side
														
 
															-				] );
														
 
															+				];
														
 
															 				group = new THREE.Group();
														
 
															 				group.position.y = 100;
														
@@ -457,7 +457,7 @@
 
															 				var centerOffset = -0.5 * ( textGeo.boundingBox.max.x - textGeo.boundingBox.min.x );
														
 
															-				textMesh1 = new THREE.Mesh( textGeo, material );
														
 
															+				textMesh1 = new THREE.Mesh( textGeo, materials );
														
 
															 				textMesh1.position.x = centerOffset;
														
 
															 				textMesh1.position.y = hover;
														
@@ -470,7 +470,7 @@
 
															 				if ( mirror ) {
														
 
															-					textMesh2 = new THREE.Mesh( textGeo, material );
														
 
															+					textMesh2 = new THREE.Mesh( textGeo, materials );
														
 
															 					textMesh2.position.x = centerOffset;
														
 
															 					textMesh2.position.y = -hover;
														
--- a/examples/webgl_geometry_text_shapes.html
+++ b/examples/webgl_geometry_text_shapes.html
@@ -0,0 +1,166 @@
 
															+<!DOCTYPE html>
														
 
															+<html lang="en">
														
 
															+	<head>
														
 
															+		<title>three.js webgl - Simple text from json</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 {
														
 
															+				font-family: Monospace;
														
 
															+				background-color: #f0f0f0;
														
 
															+				margin: 0px;
														
 
															+				overflow: hidden;
														
 
															+			}
														
 
															+			#info {
														
 
															+				position: absolute;
														
 
															+				top: 10px;
														
 
															+				width: 100%;
														
 
															+				text-align: center;
														
 
															+			}
														
 
															+		</style>
														
 
															+	</head>
														
 
															+	<body>
														
 
															+		<div id="info">
														
 
															+			<a href="http://threejs.org" target="_blank">three.js</a> webgl - Simple text from json fonts.
														
 
															+		</div>
														
 
															+
														
 
															+		<script src="../build/three.js"></script>
														
 
															+		<script src="js/controls/OrbitControls.js"></script>
														
 
															+
														
 
															+		<script>
														
 
															+
														
 
															+			var camera, scene, renderer, controls;
														
 
															+
														
 
															+			init();
														
 
															+			animate();
														
 
															+
														
 
															+			function init( ) {
														
 
															+
														
 
															+				camera = new THREE.PerspectiveCamera( 45, window.innerWidth / window.innerHeight, 1, 10000 );
														
 
															+				camera.position.set( 0, - 400, 600 );
														
 
															+
														
 
															+				controls = new THREE.OrbitControls( camera );
														
 
															+				controls.target.set( 0, 0, 0 );
														
 
															+
														
 
															+				scene = new THREE.Scene();
														
 
															+
														
 
															+				var loader = new THREE.FontLoader();
														
 
															+				loader.load( 'fonts/helvetiker_regular.typeface.json', function ( font ) {
														
 
															+
														
 
															+					var xMid, text;
														
 
															+
														
 
															+					var textShape = new THREE.BufferGeometry();
														
 
															+
														
 
															+					var color = 0x006699;
														
 
															+
														
 
															+					var matDark = new THREE.LineBasicMaterial( {
														
 
															+						color: color,
														
 
															+						side: THREE.DoubleSide
														
 
															+					} );
														
 
															+
														
 
															+					var matLite = new THREE.MeshBasicMaterial( {
														
 
															+						color: color,
														
 
															+						transparent: true,
														
 
															+						opacity: 0.4,
														
 
															+						side: THREE.DoubleSide
														
 
															+					} );
														
 
															+
														
 
															+					var message = "   Three.js\nSimple text.";
														
 
															+
														
 
															+					var shapes = font.generateShapes( message, 100, 2 );
														
 
															+
														
 
															+					var geometry = new THREE.ShapeGeometry( shapes );
														
 
															+
														
 
															+					geometry.computeBoundingBox();
														
 
															+
														
 
															+					xMid = - 0.5 * ( geometry.boundingBox.max.x - geometry.boundingBox.min.x );
														
 
															+
														
 
															+					geometry.translate( xMid, 0, 0 );
														
 
															+
														
 
															+					// make shape ( N.B. edge view not visible )
														
 
															+
														
 
															+					textShape.fromGeometry( geometry );
														
 
															+
														
 
															+					text = new THREE.Mesh( textShape, matLite );
														
 
															+					text.position.z = - 150;
														
 
															+					scene.add( text );
														
 
															+
														
 
															+			        // make line shape ( N.B. edge view remains visible )
														
 
															+
														
 
															+			      		var holeShapes = [];
														
 
															+
														
 
															+					for ( var i = 0; i < shapes.length; i ++ ) {
														
 
															+
														
 
															+						var shape = shapes[ i ];
														
 
															+
														
 
															+						if ( shape.holes && shape.holes.length > 0 ) {
														
 
															+
														
 
															+							for ( var j = 0; j < shape.holes.length; j ++ ) {
														
 
															+
														
 
															+								var hole = shape.holes[ j ];
														
 
															+								holeShapes.push( hole );
														
 
															+
														
 
															+							}
														
 
															+
														
 
															+						}
														
 
															+
														
 
															+					}
														
 
															+
														
 
															+					shapes.push.apply( shapes, holeShapes );
														
 
															+
														
 
															+					var lineText = new THREE.Object3D();
														
 
															+
														
 
															+					for ( var i = 0; i < shapes.length; i ++ ) {
														
 
															+
														
 
															+						var shape = shapes[ i ];
														
 
															+
														
 
															+						var lineGeometry = shape.createPointsGeometry();
														
 
															+
														
 
															+						lineGeometry.translate( xMid, 0, 0 );
														
 
															+
														
 
															+						var lineMesh = new THREE.Line( lineGeometry, matDark );
														
 
															+						lineText.add( lineMesh );
														
 
															+
														
 
															+					}
														
 
															+
														
 
															+					scene.add( lineText );
														
 
															+
														
 
															+				} ); //end load function
														
 
															+
														
 
															+				renderer = new THREE.WebGLRenderer( { antialias: true } );
														
 
															+				renderer.setClearColor( 0xf0f0f0 );
														
 
															+				renderer.setSize( window.innerWidth, window.innerHeight );
														
 
															+				document.body.appendChild( renderer.domElement );
														
 
															+
														
 
															+				window.addEventListener( 'resize', onWindowResize, false );
														
 
															+
														
 
															+			} // end init
														
 
															+
														
 
															+			function onWindowResize() {
														
 
															+
														
 
															+				camera.aspect = window.innerWidth / window.innerHeight;
														
 
															+				camera.updateProjectionMatrix();
														
 
															+
														
 
															+				renderer.setSize( window.innerWidth, window.innerHeight );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			function animate() {
														
 
															+
														
 
															+				requestAnimationFrame( animate );
														
 
															+
														
 
															+				render();
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+			function render() {
														
 
															+
														
 
															+				controls.update();
														
 
															+				renderer.render( scene, camera );
														
 
															+
														
 
															+			}
														
 
															+
														
 
															+		</script>
														
 
															+
														
 
															+	</body>
														
 
															+</html>
														
--- a/examples/webgl_loader_ctm_materials.html
+++ b/examples/webgl_loader_ctm_materials.html
@@ -254,23 +254,6 @@
 
															 			//
														
 
															-			function createScene( geometry, materials, x, y, z, s ) {
														
 
															-
														
 
															-				geometry.center();
														
 
															-
														
 
															-				hackMaterials( materials );
														
 
															-
														
 
															-				var material = new THREE.MultiMaterial( materials );
														
 
															-
														
 
															-				mesh = new THREE.Mesh( geometry, material );
														
 
															-				mesh.position.set( x, y, z );
														
 
															-				mesh.scale.set( s, s, s );
														
 
															-				scene.add( mesh );
														
 
															-
														
 
															-			}
														
 
															-
														
 
															-			//
														
 
															-
														
 
															 			function onWindowResize( event ) {
														
 
															 				SCREEN_WIDTH = window.innerWidth;
														
--- a/examples/webgl_loader_gltf.html
+++ b/examples/webgl_loader_gltf.html
@@ -202,8 +202,7 @@
 
															 					scene.add(ground);
														
 
															 				}
														
 
															-				THREE.GLTF2Loader.Shaders.removeAll(); // remove all previous shaders
														
 
															-				loader = new THREE.GLTF2Loader;
														
 
															+				loader = new THREE.GLTF2Loader();
														
 
															 				for (var i = 0; i < extensionSelect.children.length; i++) {
														
 
															 					var child = extensionSelect.children[i];
														
@@ -338,7 +337,6 @@
 
															 			function animate() {
														
 
															 				requestAnimationFrame( animate );
														
 
															 				if (mixer) mixer.update(clock.getDelta());
														
 
															-				THREE.GLTF2Loader.Shaders.update(scene, camera);
														
 
															 				if (cameraIndex == 0)
														
 
															 					orbitControls.update();
														
 
															 				render();
														
@@ -409,6 +407,15 @@
 
															 					shadows:true,
														
 
															 					extensions: ["glTF", "glTF-MaterialsCommon", "glTF-Binary"]
														
 
															 				},
														
 
															+				{
														
 
															+					name : "Rigged Simple",
														
 
															+					url : "./models/gltf/RiggedSimple/%s/RiggedSimple.gltf",
														
 
															+					cameraPos: new THREE.Vector3(0, 5, 15),
														
 
															+					objectRotation: new THREE.Euler(0, 90, 0),
														
 
															+					addLights:true,
														
 
															+					shadows:true,
														
 
															+					extensions: ["glTF"]
														
 
															+				},
														
 
															 				{
														
 
															 					name : "Snowflake",
														
 
															 					url : "./models/gltf/snowflake/snowFlake.gltf",
														
--- a/examples/webgl_loader_json_blender.html
+++ b/examples/webgl_loader_json_blender.html
@@ -108,8 +108,6 @@
 
															 					material.morphTargets = true;
														
 
															 					material.color.setHex( 0xffaaaa );
														
 
															-					var faceMaterial = new THREE.MultiMaterial( materials );
														
 
															-
														
 
															 					for ( var i = 0; i < 729; i ++ ) {
														
 
															 						// random placement in a grid
														
@@ -121,7 +119,7 @@
 
															 						if ( Math.abs( x ) < 2 && Math.abs( z ) < 2 ) continue;
														
 
															-						mesh = new THREE.Mesh( geometry, faceMaterial );
														
 
															+						mesh = new THREE.Mesh( geometry, materials );
														
 
															 						var s = THREE.Math.randFloat( 0.00075, 0.001 );
														
 
															 						mesh.scale.set( s, s, s );
														
--- a/examples/webgl_loader_json_objconverter.html
+++ b/examples/webgl_loader_json_objconverter.html
@@ -217,7 +217,7 @@
 
															 			function createScene( geometry, materials, x, y, z, b ) {
														
 
															-				zmesh = new THREE.Mesh( geometry, new THREE.MultiMaterial( materials ) );
														
 
															+				zmesh = new THREE.Mesh( geometry, materials );
														
 
															 				zmesh.position.set( x, y, z );
														
 
															 				zmesh.scale.set( 3, 3, 3 );
														
 
															 				scene.add( zmesh );
														
--- a/examples/webgl_loader_mmd.html
+++ b/examples/webgl_loader_mmd.html
@@ -177,7 +177,7 @@
 
															 					}
														
 
															-					phongMaterials = new THREE.MultiMaterial( array );
														
 
															+					phongMaterials = array;
														
 
															 				}
														
@@ -202,7 +202,7 @@
 
															 					gui.add( api, 'gradient mapping' ).onChange( function () {
														
 
															 						if ( originalMaterials === undefined ) originalMaterials = mesh.material;
														
 
															-						if ( phongMaterials === undefined ) makePhongMaterials( mesh.material.materials );
														
 
															+						if ( phongMaterials === undefined ) makePhongMaterials( mesh.material );
														
 
															 						if ( api[ 'gradient mapping' ] ) {
														
--- a/examples/webgl_materials.html
+++ b/examples/webgl_materials.html
@@ -108,7 +108,7 @@
 
															 				}
														
 
															-				addMesh( geometry, new THREE.MultiMaterial( materials ) );
														
 
															+				addMesh( geometry, materials );
														
 
															 				particleLight = new THREE.Mesh( new THREE.SphereGeometry( 4, 8, 8 ), new THREE.MeshBasicMaterial( { color: 0xffffff } ) );
														
 
															 				scene.add( particleLight );
														
--- a/examples/webgl_materials_cars.html
+++ b/examples/webgl_materials_cars.html
@@ -516,7 +516,7 @@
 
															 			}
														
 
															-			function attachButtonMaterials( materials, faceMaterial, material_indices, car ) {
														
 
															+			function attachButtonMaterials( materials, faceMaterials, material_indices, car ) {
														
 
															 				for( var i = 0; i < materials.length; i ++ ) {
														
@@ -525,7 +525,7 @@
 
															 						for ( var j = 0; j < material_indices.length; j ++ ) {
														
 
															-							faceMaterial.materials[ material_indices [ j ] ] = materials[ this.counter ][ 1 ];
														
 
															+							faceMaterials[ material_indices [ j ] ] = materials[ this.counter ][ 1 ];
														
 
															 						}
														
@@ -539,7 +539,7 @@
 
															 				geometry.sortFacesByMaterialIndex();
														
 
															-				var m = new THREE.MultiMaterial(),
														
 
															+				var m = [],
														
 
															 					s = CARS[ car ].scale * 1,
														
 
															 					r = CARS[ car ].init_rotation,
														
 
															 					materials = CARS[ car ].materials,
														
@@ -548,7 +548,7 @@
 
															 				for ( var i in CARS[ car ].mmap ) {
														
 
															-					m.materials[ i ] = CARS[ car ].mmap[ i ];
														
 
															+					m[ i ] = CARS[ car ].mmap[ i ];
														
 
															 				}
														
--- a/examples/webgl_materials_lightmap.html
+++ b/examples/webgl_materials_lightmap.html
@@ -149,7 +149,7 @@
 
															 					}
														
 
															-					var mesh = new THREE.Mesh( geometry, new THREE.MultiMaterial( materials ) );
														
 
															+					var mesh = new THREE.Mesh( geometry, materials );
														
 
															 					mesh.scale.multiplyScalar( 100 );
														
 
															 					scene.add( mesh );
														
--- a/examples/webgl_mirror.html
+++ b/examples/webgl_mirror.html
@@ -54,15 +54,20 @@
 
															 			var cameraControls;
														
 
															-			var verticalMirror, groundMirror;
														
 
															 			var sphereGroup, smallSphere;
														
 
															+			init();
														
 
															+			animate();
														
 
															+
														
 
															 			function init() {
														
 
															+				var container = document.getElementById( 'container' );
														
 
															+
														
 
															 				// renderer
														
 
															 				renderer = new THREE.WebGLRenderer();
														
 
															 				renderer.setPixelRatio( window.devicePixelRatio );
														
 
															 				renderer.setSize( WIDTH, HEIGHT );
														
 
															+				container.appendChild( renderer.domElement );
														
 
															 				// scene
														
 
															 				scene = new THREE.Scene();
														
@@ -77,30 +82,21 @@
 
															 				cameraControls.minDistance = 10;
														
 
															 				cameraControls.update();
														
 
															-				var container = document.getElementById( 'container' );
														
 
															-				container.appendChild( renderer.domElement );
														
 
															-
														
 
															-			}
														
 
															-
														
 
															-			function fillScene() {
														
 
															+				//
														
 
															 				var planeGeo = new THREE.PlaneBufferGeometry( 100.1, 100.1 );
														
 
															 				// MIRROR planes
														
 
															-				groundMirror = new THREE.Mirror( renderer, camera, { clipBias: 0.003, textureWidth: WIDTH, textureHeight: HEIGHT, color: 0x777777 } );
														
 
															-				var mirrorMesh = new THREE.Mesh( planeGeo, groundMirror.material );
														
 
															-				mirrorMesh.add( groundMirror );
														
 
															-				mirrorMesh.rotateX( - Math.PI / 2 );
														
 
															-				scene.add( mirrorMesh );
														
 
															+				var groundMirror = new THREE.Mirror( 100, 100, { clipBias: 0.003, textureWidth: WIDTH, textureHeight: HEIGHT, color: 0x777777 } );
														
 
															+				groundMirror.rotateX( - Math.PI / 2 );
														
 
															+				scene.add( groundMirror );
														
 
															-				verticalMirror = new THREE.Mirror( renderer, camera, { clipBias: 0.003, textureWidth: WIDTH, textureHeight: HEIGHT, color:0x889999 } );
														
 
															+				var verticalMirror = new THREE.Mirror( 60, 60, { clipBias: 0.003, textureWidth: WIDTH, textureHeight: HEIGHT, color:0x889999 } );
														
 
															+				verticalMirror.position.y = 35;
														
 
															+				verticalMirror.position.z = -45;
														
 
															+				scene.add( verticalMirror );
														
 
															-				var verticalMirrorMesh = new THREE.Mesh( new THREE.PlaneBufferGeometry( 60, 60 ), verticalMirror.material );
														
 
															-				verticalMirrorMesh.add( verticalMirror );
														
 
															-				verticalMirrorMesh.position.y = 35;
														
 
															-				verticalMirrorMesh.position.z = -45;
														
 
															-				scene.add( verticalMirrorMesh );
														
 
															 				sphereGroup = new THREE.Object3D();
														
 
															 				scene.add( sphereGroup );
														
@@ -173,19 +169,9 @@
 
															 			}
														
 
															-			function render() {
														
 
															+			function animate() {
														
 
															-				// render (update) the mirrors
														
 
															-				groundMirror.renderWithMirror( verticalMirror );
														
 
															-				verticalMirror.renderWithMirror( groundMirror );
														
 
															-
														
 
															-				renderer.render(scene, camera);
														
 
															-
														
 
															-			}
														
 
															-
														
 
															-			function update() {
														
 
															-
														
 
															-				requestAnimationFrame( update );
														
 
															+				requestAnimationFrame( animate );
														
 
															 				var timer = Date.now() * 0.01;
														
@@ -201,12 +187,9 @@
 
															 				cameraControls.update();
														
 
															-				render();
														
 
															-			}
														
 
															+				renderer.render(scene, camera);
														
 
															-			init();
														
 
															-			fillScene();
														
 
															-			update();
														
 
															+			}
														
 
															 		</script>
														
 
															 	</body>
														
--- a/examples/webgl_mirror_nodes.html
+++ b/examples/webgl_mirror_nodes.html
@@ -116,7 +116,7 @@
 
															 			var clock = new THREE.Clock();
														
 
															 			var cameraControls;
														
 
															-			
														
 
															+
														
 
															 			var gui = new dat.GUI();
														
 
															 			var groundMirror;
														
@@ -283,13 +283,6 @@
 
															 			function render() {
														
 
															-				// render (update) the mirrors
														
 
															-				groundMirrorMaterial.visible = false;
														
 
															-
														
 
															-				groundMirror.render();
														
 
															-
														
 
															-				groundMirrorMaterial.visible = true;
														
 
															-
														
 
															 				renderer.render(scene, camera);
														
 
															 			}
														
--- a/examples/webgl_nearestneighbour.html
+++ b/examples/webgl_nearestneighbour.html
@@ -109,7 +109,7 @@
 
															 				];
														
 
															-				mesh = new THREE.Mesh( new THREE.BoxGeometry( 10000, 10000, 10000, 7, 7, 7 ), new THREE.MultiMaterial( materials ) );
														
 
															+				mesh = new THREE.Mesh( new THREE.BoxGeometry( 10000, 10000, 10000, 7, 7, 7 ), materials );
														
 
															 				mesh.scale.x = - 1;
														
 
															 				scene.add(mesh);
														
--- a/examples/webgl_objects_update.html
+++ b/examples/webgl_objects_update.html
@@ -47,22 +47,22 @@
 
															 				//
														
 
															-				var object = createObject( createMultiMaterial(), 1 );
														
 
															+				var object = createObject( createMaterials(), 1 );
														
 
															 				object.position.set( -100, 100, 0 );
														
 
															 				scene.add( object );
														
 
															 				objectNewGeometry = object;
														
 
															-				object = createObject( createMultiMaterial(), 1 );
														
 
															+				object = createObject( createMaterials(), 1 );
														
 
															 				object.position.set( 100, 100, 0 );
														
 
															 				scene.add( object );
														
 
															 				objectToggleAddRemove = object;
														
 
															-				object = createObject( createMultiMaterial(), 4 );
														
 
															+				object = createObject( createMaterials(), 4 );
														
 
															 				object.position.set( -100, -100, 0 );
														
 
															 				scene.add( object );
														
 
															 				objectRandomizeFaces = object;
														
 
															-				object = createObject( createMultiMaterial(), 4 );
														
 
															+				object = createObject( createMaterials(), 4 );
														
 
															 				object.position.set( 100, -100, 0 );
														
 
															 				scene.add( object );
														
 
															 				objectRandomizeMaterialIndices = object;
														
@@ -99,7 +99,7 @@
 
															 			}
														
 
															-			function createMultiMaterial(){
														
 
															+			function createMaterials(){
														
 
															 				var materials = [
														
 
															 					new THREE.MeshBasicMaterial( { color: 0xff0000 } ),
														
 
															 					new THREE.MeshBasicMaterial( { color: 0xffff00 } ),
														
@@ -109,7 +109,7 @@
 
															 					new THREE.MeshBasicMaterial( { color: 0xff00ff } )
														
 
															 				];
														
 
															-				return new THREE.MultiMaterial( materials );
														
 
															+				return materials;
														
 
															 			}
														
 
															 			function onWindowResize() {
														
--- a/examples/webgl_panorama_cube.html
+++ b/examples/webgl_panorama_cube.html
@@ -74,7 +74,7 @@
 
															 			}
														
 
															-			var skyBox = new THREE.Mesh( new THREE.CubeGeometry( 1, 1, 1 ), new THREE.MultiMaterial( materials ) );
														
 
															+			var skyBox = new THREE.Mesh( new THREE.CubeGeometry( 1, 1, 1 ), materials );
														
 
															 			skyBox.applyMatrix( new THREE.Matrix4().makeScale( 1, 1, - 1 ) );
														
 
															 			scene.add( skyBox );
														
--- a/examples/webgl_performance.html
+++ b/examples/webgl_performance.html
@@ -52,8 +52,8 @@
 
															 				var material = new THREE.MeshNormalMaterial();
														
 
															-				var loader = new THREE.JSONLoader();
														
 
															-				loader.load( 'obj/Suzanne.js', function ( geometry ) {
														
 
															+				var loader = new THREE.BufferGeometryLoader();
														
 
															+				loader.load( 'models/json/suzanne.json', function ( geometry ) {
														
 
															 					geometry.computeVertexNormals();
														
--- a/examples/webgl_performance_static.html
+++ b/examples/webgl_performance_static.html
@@ -50,8 +50,8 @@
 
															 				var material = new THREE.MeshNormalMaterial();
														
 
															-				var loader = new THREE.JSONLoader();
														
 
															-				loader.load( 'obj/Suzanne.js', function ( geometry ) {
														
 
															+				var loader = new THREE.BufferGeometryLoader();
														
 
															+				loader.load( 'models/json/suzanne.json', function ( geometry ) {
														
 
															 					geometry.computeVertexNormals();
														
--- a/examples/webgl_simple_gi.html
+++ b/examples/webgl_simple_gi.html
@@ -42,7 +42,9 @@
 
															 			THREE.Mesh.prototype.clone = function () {
														
 
															-				return new this.constructor( this.geometry.clone(), this.material.clone() ).copy( this );
														
 
															+				var newMaterial = ( this.material.isMaterial ) ? this.material.clone() : this.material.slice();
														
 
															+
														
 
															+				return new this.constructor( this.geometry.clone(), newMaterial ).copy( this );
														
 
															 			};
														
@@ -211,9 +213,8 @@
 
															 				}
														
 
															 				var geometry = new THREE.BoxBufferGeometry( 3, 3, 3 );
														
 
															-				var material = new THREE.MultiMaterial( materials );
														
 
															-				var mesh = new THREE.Mesh( geometry, material );
														
 
															+				var mesh = new THREE.Mesh( geometry, materials );
														
 
															 				scene.add( mesh );
														
 
															 				//
														
--- a/examples/webgl_skinning_simple.html
+++ b/examples/webgl_skinning_simple.html
@@ -63,7 +63,13 @@
 
															 				loader.load( './models/skinned/simple/simple.js', function ( geometry, materials ) {
														
 
															-					skinnedMesh = new THREE.SkinnedMesh(geometry, new THREE.MultiMaterial(materials));
														
 
															+					for ( var k in materials ) {
														
 
															+
														
 
															+						materials[k].skinning = true;
														
 
															+
														
 
															+					}
														
 
															+
														
 
															+					skinnedMesh = new THREE.SkinnedMesh(geometry, materials );
														
 
															 					skinnedMesh.scale.set( 1, 1, 1 );
														
 
															 					// Note: We test the corresponding code path with this example -
														
--- a/examples/webgldeferred_animation.html
+++ b/examples/webgldeferred_animation.html
@@ -112,6 +112,7 @@
 
															 					var material = materials[ 0 ];
														
 
															 					material.emissive.set( 0x101010 );
														
 
															+					material.skinning = true;
														
 
															 					material.morphTargets = true;
														
 
															 					var mesh = new THREE.SkinnedMesh( geometry, material );
														
--- a/examples/webvr_shadow.html
+++ b/examples/webvr_shadow.html
@@ -19,6 +19,8 @@
 
															 		<script src="js/effects/VREffect.js"></script>
														
 
															 		<script src="js/vr/WebVR.js"></script>
														
 
															+		<script src="js/Mirror.js"></script>
														
 
															+
														
 
															 		<script>
														
 
															 			if ( WEBVR.isAvailable() === false ) {
														
@@ -32,6 +34,8 @@
 
															 			var camera, scene, renderer;
														
 
															 			var effect, controls;
														
 
															+			var mirror;
														
 
															+
														
 
															 			init();
														
 
															 			animate();
														
@@ -39,41 +43,65 @@
 
															 				scene = new THREE.Scene();
														
 
															-				var dummy = new THREE.Camera();
														
 
															-				dummy.position.set( 2, 1, 2 );
														
 
															-				dummy.lookAt( scene.position );
														
 
															-				scene.add( dummy );
														
 
															-
														
 
															 				camera = new THREE.PerspectiveCamera( 50, window.innerWidth / window.innerHeight, 0.1, 10 );
														
 
															-				dummy.add( camera );
														
 
															+				scene.add( camera );
														
 
															 				var geometry = new THREE.TorusKnotGeometry( 0.4, 0.15, 150, 20 );
														
 
															 				var material = new THREE.MeshStandardMaterial( { roughness: 0.01, metalness: 0.2 } );
														
 
															 				var mesh = new THREE.Mesh( geometry, material );
														
 
															 				mesh.position.y = 0.75;
														
 
															+				mesh.position.z = - 2;
														
 
															 				mesh.castShadow = true;
														
 
															 				mesh.receiveShadow = true;
														
 
															 				scene.add( mesh );
														
 
															-				var geometry = new THREE.BoxGeometry( 3, 0.1, 3 );
														
 
															+				var geometry = new THREE.BoxGeometry( 1.5, 0.1, 1.5 );
														
 
															 				var material = new THREE.MeshStandardMaterial( { roughness: 1.0, metalness: 0.0 } );
														
 
															 				var mesh = new THREE.Mesh( geometry, material );
														
 
															-				mesh.position.y = - 0.1;
														
 
															+				mesh.position.y = - 0.2;
														
 
															+				mesh.position.z = - 2;
														
 
															 				mesh.castShadow = true;
														
 
															 				mesh.receiveShadow = true;
														
 
															 				scene.add( mesh );
														
 
															 				var light = new THREE.DirectionalLight( 0x8800ff );
														
 
															-				light.position.set( - 1, 1.5, 0.5 );
														
 
															+				light.position.set( - 1, 1.5, - 1.5 );
														
 
															 				light.castShadow = true;
														
 
															 				light.shadow.camera.zoom = 4;
														
 
															 				scene.add( light );
														
 
															+				light.target.position.set( 0, 0, - 2 );
														
 
															+				scene.add( light.target );
														
 
															+
														
 
															+				var helper = new THREE.CameraHelper( light.shadow.camera );
														
 
															+				// scene.add( helper );
														
 
															 				var light = new THREE.DirectionalLight( 0xff0000 );
														
 
															-				light.position.set( 1, 1.5, - 0.5 );
														
 
															+				light.position.set( 1, 1.5, - 2.5 );
														
 
															 				light.castShadow = true;
														
 
															 				light.shadow.camera.zoom = 4;
														
 
															 				scene.add( light );
														
 
															+				light.target.position.set( 0, 0, - 2 );
														
 
															+				scene.add( light.target );
														
 
															+
														
 
															+				var helper = new THREE.CameraHelper( light.shadow.camera );
														
 
															+				// scene.add( helper );
														
 
															+
														
 
															+				//
														
 
															+
														
 
															+				mirror = new THREE.Mirror( 1.4, 1.4, { textureWidth: window.innerWidth, textureHeight: window.innerHeight } );
														
 
															+				mirror.position.x = 1;
														
 
															+				mirror.position.y = 0.5;
														
 
															+				mirror.position.z = -3;
														
 
															+				mirror.rotation.y = - Math.PI / 4;
														
 
															+				scene.add( mirror );
														
 
															+
														
 
															+				var geometry = new THREE.BoxGeometry( 1.5, 1.5, 0.1 );
														
 
															+				var material = new THREE.MeshStandardMaterial( { roughness: 1.0, metalness: 0.0 } );
														
 
															+				var mesh = new THREE.Mesh( geometry, material );
														
 
															+				mesh.position.z = - 0.07;
														
 
															+				mesh.castShadow = true;
														
 
															+				mesh.receiveShadow = true;
														
 
															+				mirror.add( mesh );
														
 
															 				//
														
--- a/package.json
+++ b/package.json
@@ -33,7 +33,7 @@
 
															     "build-closure": "rollup -c && java -jar utils/build/compiler/closure-compiler-v20160713.jar --warning_level=VERBOSE --jscomp_off=globalThis --jscomp_off=checkTypes --externs utils/build/externs.js --language_in=ECMASCRIPT5_STRICT --js build/three.js --js_output_file build/three.min.js",
														
 
															     "dev": "rollup -c -w",
														
 
															     "lint": "eslint src",
														
 
															-    "test": "echo \"Error: no test specified\" && exit 1"
														
 
															+    "test": "rollup -c test/rollup.unit.config.js -w"
														
 
															   },
														
 
															   "keywords": [
														
 
															     "three",
														
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -8,9 +8,9 @@ function glsl() {
 
															 			var transformedCode = 'export default ' + JSON.stringify(
														
 
															 				code
														
 
															-					.replace( /[ \t]*\/\/.*\n/g, '' )
														
 
															-					.replace( /[ \t]*\/\*[\s\S]*?\*\//g, '' )
														
 
															-					.replace( /\n{2,}/g, '\n' )
														
 
															+					.replace( /[ \t]*\/\/.*\n/g, '' ) // remove //
														
 
															+					.replace( /[ \t]*\/\*[\s\S]*?\*\//g, '' ) // remove /* */
														
 
															+					.replace( /\n{2,}/g, '\n' ) // # \n+ to \n
														
 
															 			) + ';';
														
 
															 			return {
														
 
															 				code: transformedCode,
														
--- a/src/Three.Legacy.js
+++ b/src/Three.Legacy.js
@@ -994,20 +994,6 @@ Object.defineProperties( Uniform.prototype, {
 
															 Object.defineProperties( Material.prototype, {
														
 
															-	skinning: {
														
 
															-		get: function () {
														
 
															-
														
 
															-			console.warn( 'THREE.Material: .skinning has been removed.' );
														
 
															-
														
 
															-		},
														
 
															-		set: function () {
														
 
															-
														
 
															-			console.warn( 'THREE.Material: .skinning has been removed.' );
														
 
															-
														
 
															-		}
														
 
															-
														
 
															-	},
														
 
															-
														
 
															 	wrapAround: {
														
 
															 		get: function () {
														
@@ -1072,6 +1058,13 @@ Object.defineProperties( ShaderMaterial.prototype, {
 
															 Object.assign( WebGLRenderer.prototype, {
														
 
															+	getCurrentRenderTarget: function () {
														
 
															+
														
 
															+		console.warn( 'THREE.WebGLRenderer: .getCurrentRenderTarget() is now .getRenderTarget().' );
														
 
															+		return this.getRenderTarget();
														
 
															+
														
 
															+	},
														
 
															+
														
 
															 	supportsFloatTextures: function () {
														
 
															 		console.warn( 'THREE.WebGLRenderer: .supportsFloatTextures() is now .extensions.get( \'OES_texture_float\' ).' );
														
--- a/src/animation/AnimationUtils.js
+++ b/src/animation/AnimationUtils.js
@@ -7,11 +7,13 @@
 
															 var AnimationUtils = {
														
 
															 	// same as Array.prototype.slice, but also works on typed arrays
														
 
															-	arraySlice: function( array, from, to ) {
														
 
															+	arraySlice: function ( array, from, to ) {
														
 
															 		if ( AnimationUtils.isTypedArray( array ) ) {
														
 
															-			return new array.constructor( array.subarray( from, to ) );
														
 
															+			// in ios9 array.subarray(from, undefined) will return empty array
														
 
															+			// but array.subarray(from) or array.subarray(from, len) is correct
														
 
															+			return new array.constructor( array.subarray( from, to !== undefined ? to : array.length ) );
														
 
															 		}
														
@@ -20,7 +22,7 @@ var AnimationUtils = {
 
															 	},
														
 
															 	// converts an array to a specific type
														
 
															-	convertArray: function( array, type, forceClone ) {
														
 
															+	convertArray: function ( array, type, forceClone ) {
														
 
															 		if ( ! array || // let 'undefined' and 'null' pass
														
 
															 				! forceClone && array.constructor === type ) return array;
														
@@ -35,7 +37,7 @@ var AnimationUtils = {
 
															 	},
														
 
															-	isTypedArray: function( object ) {
														
 
															+	isTypedArray: function ( object ) {
														
 
															 		return ArrayBuffer.isView( object ) &&
														
 
															 				! ( object instanceof DataView );
														
@@ -43,7 +45,7 @@ var AnimationUtils = {
 
															 	},
														
 
															 	// returns an array by which times and values can be sorted
														
 
															-	getKeyframeOrder: function( times ) {
														
 
															+	getKeyframeOrder: function ( times ) {
														
 
															 		function compareTime( i, j ) {
														
@@ -62,7 +64,7 @@ var AnimationUtils = {
 
															 	},
														
 
															 	// uses the array previously returned by 'getKeyframeOrder' to sort data
														
 
															-	sortedArray: function( values, stride, order ) {
														
 
															+	sortedArray: function ( values, stride, order ) {
														
 
															 		var nValues = values.length;
														
 
															 		var result = new values.constructor( nValues );
														
@@ -84,7 +86,7 @@ var AnimationUtils = {
 
															 	},
														
 
															 	// function for parsing AOS keyframe formats
														
 
															-	flattenJSON: function( jsonKeys, times, values, valuePropertyName ) {
														
 
															+	flattenJSON: function ( jsonKeys, times, values, valuePropertyName ) {
														
 
															 		var i = 1, key = jsonKeys[ 0 ];
														
@@ -117,6 +119,7 @@ var AnimationUtils = {
 
															 			} while ( key !== undefined );
														
 
															 		} else if ( value.toArray !== undefined ) {
														
 
															+
														
 
															 			// ...assume THREE.Math-ish
														
 
															 			do {
														
@@ -135,6 +138,7 @@ var AnimationUtils = {
 
															 			} while ( key !== undefined );
														
 
															 		} else {
														
 
															+
														
 
															 			// otherwise push as-is
														
 
															 			do {
														
--- a/src/animation/KeyframeTrackConstructor.js
+++ b/src/animation/KeyframeTrackConstructor.js
@@ -2,9 +2,9 @@ import { AnimationUtils } from './AnimationUtils';
 
															 function KeyframeTrackConstructor( name, times, values, interpolation ) {
														
 
															-	if( name === undefined ) throw new Error( "track name is undefined" );
														
 
															+	if ( name === undefined ) throw new Error( "track name is undefined" );
														
 
															-	if( times === undefined || times.length === 0 ) {
														
 
															+	if ( times === undefined || times.length === 0 ) {
														
 
															 		throw new Error( "no keyframes in track named " + name );
														
--- a/src/animation/PropertyBinding.js
+++ b/src/animation/PropertyBinding.js
@@ -102,47 +102,83 @@ Object.assign( PropertyBinding, {
 
															 	},
														
 
															-	parseTrackName: function ( trackName ) {
														
 
															+	parseTrackName: function () {
														
 
															-		// matches strings in the form of:
														
 
															-		//    nodeName.property
														
 
															-		//    nodeName.property[accessor]
														
 
															-		//    nodeName.material.property[accessor]
														
 
															-		//    uuid.property[accessor]
														
 
															-		//    uuid.objectName[objectIndex].propertyName[propertyIndex]
														
 
															-		//    parentName/nodeName.property
														
 
															-		//    parentName/parentName/nodeName.property[index]
														
 
															-		//    .bone[Armature.DEF_cog].position
														
 
															-		//    scene:helium_balloon_model:helium_balloon_model.position
														
 
															-		// created and tested via https://regex101.com/#javascript
														
 
															+		// Parent directories, delimited by '/' or ':'. Currently unused, but must
														
 
															+		// be matched to parse the rest of the track name.
														
 
															+		var directoryRe = /((?:[\w-]+[\/:])*)/;
														
 
															-		var re = /^((?:[\w-]+[\/:])*)([\w-]+)?(?:\.([\w-]+)(?:\[(.+)\])?)?\.([\w-]+)(?:\[(.+)\])?$/;
														
 
															-		var matches = re.exec( trackName );
														
 
															+		// Target node. May contain word characters (a-zA-Z0-9_) and '.' or '-'.
														
 
															+		var nodeRe = /([\w-\.]+)?/;
														
 
															-		if ( ! matches ) {
														
 
															+		// Object on target node, and accessor. Name may contain only word
														
 
															+		// characters. Accessor may contain any character except closing bracket.
														
 
															+		var objectRe = /(?:\.([\w-]+)(?:\[(.+)\])?)?/;
														
 
															-			throw new Error( "cannot parse trackName at all: " + trackName );
														
 
															+		// Property and accessor. May contain only word characters. Accessor may
														
 
															+		// contain any non-bracket characters.
														
 
															+		var propertyRe = /\.([\w-]+)(?:\[(.+)\])?/;
														
 
															-		}
														
 
															+		var trackRe = new RegExp(''
														
 
															+			+ '^'
														
 
															+			+ directoryRe.source
														
 
															+			+ nodeRe.source
														
 
															+			+ objectRe.source
														
 
															+			+ propertyRe.source
														
 
															+			+ '$'
														
 
															+		);
														
 
															-		var results = {
														
 
															-			// directoryName: matches[ 1 ], // (tschw) currently unused
														
 
															-			nodeName: matches[ 2 ], 	// allowed to be null, specified root node.
														
 
															-			objectName: matches[ 3 ],
														
 
															-			objectIndex: matches[ 4 ],
														
 
															-			propertyName: matches[ 5 ],
														
 
															-			propertyIndex: matches[ 6 ]	// allowed to be null, specifies that the whole property is set.
														
 
															-		};
														
 
															+		var supportedObjectNames = [ 'material', 'materials', 'bones' ];
														
 
															-		if ( results.propertyName === null || results.propertyName.length === 0 ) {
														
 
															+		return function ( trackName ) {
														
 
															-			throw new Error( "can not parse propertyName from trackName: " + trackName );
														
 
															+				var matches = trackRe.exec( trackName );
														
 
															-		}
														
 
															+				if ( ! matches ) {
														
 
															-		return results;
														
 
															+					throw new Error( 'PropertyBinding: Cannot parse trackName: ' + trackName );
														
 
															-	},
														
 
															+				}
														
 
															+
														
 
															+				var results = {
														
 
															+					// directoryName: matches[ 1 ], // (tschw) currently unused
														
 
															+					nodeName: matches[ 2 ],
														
 
															+					objectName: matches[ 3 ],
														
 
															+					objectIndex: matches[ 4 ],
														
 
															+					propertyName: matches[ 5 ],     // required
														
 
															+					propertyIndex: matches[ 6 ]
														
 
															+				};
														
 
															+
														
 
															+				var lastDot = results.nodeName && results.nodeName.lastIndexOf( '.' );
														
 
															+
														
 
															+				if ( lastDot !== undefined && lastDot !== -1 ) {
														
 
															+
														
 
															+					var objectName = results.nodeName.substring( lastDot + 1 );
														
 
															+
														
 
															+					// Object names must be checked against a whitelist. Otherwise, there
														
 
															+					// is no way to parse 'foo.bar.baz': 'baz' must be a property, but
														
 
															+					// 'bar' could be the objectName, or part of a nodeName (which can
														
 
															+					// include '.' characters).
														
 
															+					if ( supportedObjectNames.indexOf( objectName ) !== -1 ) {
														
 
															+
														
 
															+						results.nodeName = results.nodeName.substring( 0, lastDot );
														
 
															+						results.objectName = objectName;
														
 
															+
														
 
															+					}
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				if ( results.propertyName === null || results.propertyName.length === 0 ) {
														
 
															+
														
 
															+					throw new Error( 'PropertyBinding: can not parse propertyName from trackName: ' + trackName );
														
 
															+
														
 
															+				}
														
 
															+
														
 
															+				return results;
														
 
															+
														
 
															+			};
														
 
															+
														
 
															+	}(),
														
 
															 	findNode: function ( root, nodeName ) {
														
--- a/src/cameras/Camera.js
+++ b/src/cameras/Camera.js
@@ -41,22 +41,6 @@ Camera.prototype.getWorldDirection = function () {
 
															 }();
														
 
															-Camera.prototype.lookAt = function () {
														
 
															-
														
 
															-	// This routine does not support cameras with rotated and/or translated parent(s)
														
 
															-
														
 
															-	var m1 = new Matrix4();
														
 
															-
														
 
															-	return function lookAt( vector ) {
														
 
															-
														
 
															-		m1.lookAt( this.position, vector, this.up );
														
 
															-
														
 
															-		this.quaternion.setFromRotationMatrix( m1 );
														
 
															-
														
 
															-	};
														
 
															-
														
 
															-}();
														
 
															-
														
 
															 Camera.prototype.clone = function () {
														
 
															 	return new this.constructor().copy( this );
														
--- a/src/core/BufferGeometry.js
+++ b/src/core/BufferGeometry.js
@@ -814,21 +814,19 @@ Object.assign( BufferGeometry.prototype, EventDispatcher.prototype, {
 
															 	normalizeNormals: function () {
														
 
															-		var normals = this.attributes.normal.array;
														
 
															+		var normals = this.attributes.normal;
														
 
															 		var x, y, z, n;
														
 
															-		for ( var i = 0, il = normals.length; i < il; i += 3 ) {
														
 
															+		for ( var i = 0, il = normals.count; i < il; i ++ ) {
														
 
															-			x = normals[ i ];
														
 
															-			y = normals[ i + 1 ];
														
 
															-			z = normals[ i + 2 ];
														
 
															+			x = normals.getX( i );
														
 
															+			y = normals.getY( i );
														
 
															+			z = normals.getZ( i );
														
 
															 			n = 1.0 / Math.sqrt( x * x + y * y + z * z );
														
 
															-			normals[ i ] *= n;
														
 
															-			normals[ i + 1 ] *= n;
														
 
															-			normals[ i + 2 ] *= n;
														
 
															+			normals.setXYZ(i, x * n, y * n, z * n)
														
 
															 		}
														
--- a/src/core/Face3.js
+++ b/src/core/Face3.js
@@ -12,10 +12,10 @@ function Face3( a, b, c, normal, color, materialIndex ) {
 
															 	this.b = b;
														
 
															 	this.c = c;
														
 
															-	this.normal = (normal && normal.isVector3) ? normal : new Vector3();
														
 
															+	this.normal = ( normal && normal.isVector3 ) ? normal : new Vector3();
														
 
															 	this.vertexNormals = Array.isArray( normal ) ? normal : [];
														
 
															-	this.color = (color && color.isColor) ? color : new Color();
														
 
															+	this.color = ( color && color.isColor ) ? color : new Color();
														
 
															 	this.vertexColors = Array.isArray( color ) ? color : [];
														
 
															 	this.materialIndex = materialIndex !== undefined ? materialIndex : 0;
														
--- a/src/core/InstancedBufferAttribute.js
+++ b/src/core/InstancedBufferAttribute.js
@@ -12,20 +12,24 @@ function InstancedBufferAttribute( array, itemSize, meshPerAttribute ) {
 
															 }
														
 
															-InstancedBufferAttribute.prototype = Object.create( BufferAttribute.prototype );
														
 
															-InstancedBufferAttribute.prototype.constructor = InstancedBufferAttribute;
														
 
															+InstancedBufferAttribute.prototype = Object.assign( Object.create( BufferAttribute.prototype ), {
														
 
															-InstancedBufferAttribute.prototype.isInstancedBufferAttribute = true;
														
 
															+	constructor: InstancedBufferAttribute,
														
 
															-InstancedBufferAttribute.prototype.copy = function ( source ) {
														
 
															+	isInstancedBufferAttribute: true,
														
 
															-	BufferAttribute.prototype.copy.call( this, source );
														
 
															+	copy: function ( source ) {
														
 
															-	this.meshPerAttribute = source.meshPerAttribute;
														
 
															+		BufferAttribute.prototype.copy.call( this, source );
														
 
															-	return this;
														
 
															+		this.meshPerAttribute = source.meshPerAttribute;
														
 
															+
														
 
															+		return this;
														
 
															+
														
 
															+	}
														
 
															+
														
 
															+} );
														
 
															-};
														
 
															 export { InstancedBufferAttribute };
														
--- a/src/core/InstancedBufferGeometry.js
+++ b/src/core/InstancedBufferGeometry.js
@@ -13,54 +13,56 @@ function InstancedBufferGeometry() {
 
															 }
														
 
															-InstancedBufferGeometry.prototype = Object.create( BufferGeometry.prototype );
														
 
															-InstancedBufferGeometry.prototype.constructor = InstancedBufferGeometry;
														
 
															+InstancedBufferGeometry.prototype = Object.assign( Object.create( BufferGeometry.prototype ), {
														
 
															-InstancedBufferGeometry.prototype.isInstancedBufferGeometry = true;
														
 
															+	constructor: InstancedBufferGeometry,
														
 
															-InstancedBufferGeometry.prototype.addGroup = function ( start, count, materialIndex ) {
														
 
															+	isInstancedBufferGeometry: true,
														
 
															-	this.groups.push( {
														
 
															+	addGroup: function ( start, count, materialIndex ) {
														
 
															-		start: start,
														
 
															-		count: count,
														
 
															-		materialIndex: materialIndex
														
 
															+		this.groups.push( {
														
 
															-	} );
														
 
															+			start: start,
														
 
															+			count: count,
														
 
															+			materialIndex: materialIndex
														
 
															-};
														
 
															+		} );
														
 
															-InstancedBufferGeometry.prototype.copy = function ( source ) {
														
 
															+	},
														
 
															-	var index = source.index;
														
 
															+	copy: function ( source ) {
														
 
															-	if ( index !== null ) {
														
 
															+		var index = source.index;
														
 
															-		this.setIndex( index.clone() );
														
 
															+		if ( index !== null ) {
														
 
															-	}
														
 
															+			this.setIndex( index.clone() );
														
 
															-	var attributes = source.attributes;
														
 
															+		}
														
 
															-	for ( var name in attributes ) {
														
 
															+		var attributes = source.attributes;
														
 
															-		var attribute = attributes[ name ];
														
 
															-		this.addAttribute( name, attribute.clone() );
														
 
															+		for ( var name in attributes ) {
														
 
															-	}
														
 
															+			var attribute = attributes[ name ];
														
 
															+			this.addAttribute( name, attribute.clone() );
														
 
															-	var groups = source.groups;
														
 
															+		}
														
 
															-	for ( var i = 0, l = groups.length; i < l; i ++ ) {
														
 
															+		var groups = source.groups;
														
 
															-		var group = groups[ i ];
														
 
															-		this.addGroup( group.start, group.count, group.materialIndex );
														
 
															+		for ( var i = 0, l = groups.length; i < l; i ++ ) {
														
 
															-	}
														
 
															+			var group = groups[ i ];
														
 
															+			this.addGroup( group.start, group.count, group.materialIndex );
														
 
															-	return this;
														
 
															+		}
														
 
															-};
														
 
															+		return this;
														
 
															+
														
 
															+	}
														
 
															+} );
														
 
															 export { InstancedBufferGeometry };
														
--- a/src/core/InstancedInterleavedBuffer.js
+++ b/src/core/InstancedInterleavedBuffer.js
@@ -12,20 +12,22 @@ function InstancedInterleavedBuffer( array, stride, meshPerAttribute ) {
 
															 }
														
 
															-InstancedInterleavedBuffer.prototype = Object.create( InterleavedBuffer.prototype );
														
 
															-InstancedInterleavedBuffer.prototype.constructor = InstancedInterleavedBuffer;
														
 
															+InstancedInterleavedBuffer.prototype = Object.assign( Object.create( InterleavedBuffer.prototype ), {
														
 
															-InstancedInterleavedBuffer.prototype.isInstancedInterleavedBuffer = true;
														
 
															+	constructor: InstancedInterleavedBuffer,
														
 
															-InstancedInterleavedBuffer.prototype.copy = function ( source ) {
														
 
															+	isInstancedInterleavedBuffer: true,
														
 
															-	InterleavedBuffer.prototype.copy.call( this, source );
														
 
															+	copy: function ( source ) {
														
 
															-	this.meshPerAttribute = source.meshPerAttribute;
														
 
															+		InterleavedBuffer.prototype.copy.call( this, source );
														
 
															-	return this;
														
 
															+		this.meshPerAttribute = source.meshPerAttribute;
														
 
															-};
														
 
															+		return this;
														
 
															+	}
														
 
															+
														
 
															+} );
														
 
															 export { InstancedInterleavedBuffer };
														
--- a/src/core/InterleavedBufferAttribute.js
+++ b/src/core/InterleavedBufferAttribute.js
@@ -18,7 +18,7 @@ function InterleavedBufferAttribute( interleavedBuffer, itemSize, offset, normal
 
															 Object.defineProperties( InterleavedBufferAttribute.prototype, {
														
 
															-	"count" : {
														
 
															+	count: {
														
 
															 		get: function () {
														
@@ -28,7 +28,7 @@ Object.defineProperties( InterleavedBufferAttribute.prototype, {
 
															 	},
														
 
															-	"array" : {
														
 
															+	array: {
														
 
															 		get: function () {
														
--- a/src/core/Layers.js
+++ b/src/core/Layers.js
@@ -4,7 +4,7 @@
 
															 function Layers() {
														
 
															-	this.mask = 1;
														
 
															+	this.mask = 1 | 0;
														
 
															 }
														
@@ -12,25 +12,25 @@ Object.assign( Layers.prototype, {
 
															 	set: function ( channel ) {
														
 
															-		this.mask = 1 << channel;
														
 
															+		this.mask = 1 << channel | 0;
														
 
															 	},
														
 
															 	enable: function ( channel ) {
														
 
															-		this.mask |= 1 << channel;
														
 
															+		this.mask |= 1 << channel | 0;
														
 
															 	},
														
 
															 	toggle: function ( channel ) {
														
 
															-		this.mask ^= 1 << channel;
														
 
															+		this.mask ^= 1 << channel | 0;
														
 
															 	},
														
 
															 	disable: function ( channel ) {
														
 
															-		this.mask &= ~ ( 1 << channel );
														
 
															+		this.mask &= ~ ( 1 << channel | 0 );
														
 
															 	},
														
--- a/src/core/Object3D.js
+++ b/src/core/Object3D.js
@@ -279,7 +279,15 @@ Object.assign( Object3D.prototype, EventDispatcher.prototype, {
 
															 		return function lookAt( vector ) {
														
 
															-			m1.lookAt( vector, this.position, this.up );
														
 
															+			if ( this.isCamera ) {
														
 
															+
														
 
															+				m1.lookAt( this.position, vector, this.up );
														
 
															+
														
 
															+			} else {
														
 
															+
														
 
															+				m1.lookAt( vector, this.position, this.up );
														
 
															+
														
 
															+			}
														
 
															 			this.quaternion.setFromRotationMatrix( m1 );
														
@@ -526,9 +534,9 @@ Object.assign( Object3D.prototype, EventDispatcher.prototype, {
 
															 	updateMatrixWorld: function ( force ) {
														
 
															-		if ( this.matrixAutoUpdate === true ) this.updateMatrix();
														
 
															+		if ( this.matrixAutoUpdate ) this.updateMatrix();
														
 
															-		if ( this.matrixWorldNeedsUpdate === true || force === true ) {
														
 
															+		if ( this.matrixWorldNeedsUpdate || force ) {
														
 
															 			if ( this.parent === null ) {
														
--- a/src/core/Raycaster.js
+++ b/src/core/Raycaster.js
@@ -73,12 +73,12 @@ Object.assign( Raycaster.prototype, {
 
															 	setFromCamera: function ( coords, camera ) {
														
 
															-		if ( (camera && camera.isPerspectiveCamera) ) {
														
 
															+		if ( ( camera && camera.isPerspectiveCamera ) ) {
														
 
															 			this.ray.origin.setFromMatrixPosition( camera.matrixWorld );
														
 
															 			this.ray.direction.set( coords.x, coords.y, 0.5 ).unproject( camera ).sub( this.ray.origin ).normalize();
														
 
															-		} else if ( (camera && camera.isOrthographicCamera) ) {
														
 
															+		} else if ( ( camera && camera.isOrthographicCamera ) ) {
														
 
															 			this.ray.origin.set( coords.x, coords.y, ( camera.near + camera.far ) / ( camera.near - camera.far ) ).unproject( camera ); // set origin in plane of camera
														
 
															 			this.ray.direction.set( 0, 0, - 1 ).transformDirection( camera.matrixWorld );
														
--- a/src/lights/RectAreaLight.js
+++ b/src/lights/RectAreaLight.js
@@ -4,7 +4,7 @@ import { Light } from './Light';
 
															  * @author abelnation / http://github.com/abelnation
														
 
															  */
														
 
															-function RectAreaLight ( color, intensity, width, height ) {
														
 
															+function RectAreaLight( color, intensity, width, height ) {
														
 
															 	Light.call( this, color, intensity );
														
@@ -21,7 +21,6 @@ function RectAreaLight ( color, intensity, width, height ) {
 
															 	// TODO (abelnation): update method for RectAreaLight to update transform to lookat target
														
 
															 	// TODO (abelnation): shadows
														
 
															-	// this.shadow = new THREE.RectAreaLightShadow( new THREE.PerspectiveCamera( 90, 1, 0.5, 500 ) );
														
 
															 }
														
@@ -39,10 +38,19 @@ RectAreaLight.prototype = Object.assign( Object.create( Light.prototype ), {
 
															 		this.width = source.width;
														
 
															 		this.height = source.height;
														
 
															-		// this.shadow = source.shadow.clone();
														
 
															-
														
 
															 		return this;
														
 
															+	},
														
 
															+
														
 
															+	toJSON: function ( meta ) {
														
 
															+
														
 
															+		var data = Light.prototype.toJSON.call( this, meta );
														
 
															+
														
 
															+		data.object.width = this.width;
														
 
															+		data.object.height = this.height;
														
 
															+
														
 
															+		return data;
														
 
															+
														
 
															 	}
														
 
															 } );
														
--- a/src/lights/RectAreaLightShadow.js
+++ b/src/lights/RectAreaLightShadow.js
@@ -1,18 +0,0 @@
 
															-/**
														
 
															- * @author aallison / http://github.com/abelnation
														
 
															- */
														
 
															-
														
 
															-THREE.RectAreaLightShadow = function () {
														
 
															-
														
 
															-	THREE.LightShadow.call( this, new THREE.PerspectiveCamera( 50, 1, 0.5, 500 ) );
														
 
															-
														
 
															-};
														
 
															-
														
 
															-THREE.RectAreaLightShadow.prototype = Object.create( THREE.LightShadow.prototype );
														
 
															-THREE.RectAreaLightShadow.prototype.constructor = THREE.RectAreaLightShadow;
														
 
															-
														
 
															-THREE.RectAreaLightShadow.prototype.update = function ( light ) {
														
 
															-
														
 
															-	// TODO (abelnation): implement
														
 
															-
														
 
															-};