Merge branch 'dev' of https://github.com/mrdoob/three.js into linesegments2-raycast

.github/ISSUE_TEMPLATE.md

@@ -17,7 +17,7 @@ Please also include a live example if possible. You can start from these templat
 ##### Three.js version
 
 - [ ] Dev
-- [ ] r109
+- [ ] r110
 - [ ] ...
 
 ##### Browser

docs/api/en/core/Object3D.html

@@ -240,7 +240,7 @@
 		<p>
 		id -- Unique number of the object instance<br /><br />
 
-		Searches through the object's children and returns the first with a matching id.<br />
+		Searches through an object and its children, starting with the object itself, and returns the first with a matching id.<br />
 		Note that ids are assigned in chronological order: 1, 2, 3, ..., incrementing by one for each new object.
 		</p>
 
@@ -248,7 +248,7 @@
 		<p>
 		name -- String to match to the children's Object3D.name property. <br /><br />
 
-		Searches through the object's children and returns the first with a matching name.<br />
+		Searches through an object and its children, starting with the object itself, and returns the first with a matching name.<br />
 		Note that for most objects the name is an empty string by default. You will
 		have to set it manually to make use of this method.
 		</p>
@@ -258,7 +258,7 @@
 		name -- the property name to search for. <br />
 		value -- value of the given property. <br /><br />
 
-		Searches through the object's children and returns the first with a property that matches the value given.
+		Searches through an object and its children, starting with the object itself, and returns the first with a property that matches the value given.
 		</p>
 
 		<h3>[method:Vector3 getWorldPosition]( [param:Vector3 target] )</h3>

docs/api/zh/animation/AnimationAction.html

@@ -54,8 +54,8 @@
 			(将 *enabled* 置为 *false* 不会重置此次动作) <br /><br />
 
 			说明: 将*enabled*置为*true*不会让动画自动重新开始。只有满足以下条件时才会马上重新开始:
-            暂停（[page:.paused paused]）值为*false*, 同时动作没有失效 (执行停止([page:.stop stop])命令或重置([page:.reset reset])命令，
-            且权重([page:.weight weight])和时间比例([page:.timeScale timeScale])都不能为0
+			暂停（[page:.paused paused]）值为*false*, 同时动作没有失效 (执行停止([page:.stop stop])命令或重置([page:.reset reset])命令，
+			且权重([page:.weight weight])和时间比例([page:.timeScale timeScale])都不能为0
 
 		</p>
 
@@ -64,7 +64,7 @@
 			循环模式 (可以通过[page:.setLoop setLoop]改变)。默认值是
 			[page:Animation THREE.LoopRepeat] (重复[page:.repetitions repetitions]次数无穷)<br /><br />
 
-		    必须是以下值之一：<br /><br />
+			必须是以下值之一：<br /><br />
 			[page:Animation THREE.LoopOnce] - 只执行一次 <br />
 			[page:Animation THREE.LoopRepeat] - 重复次数为*repetitions*的值, 且每次循环结束时候将回到起始动作开始下一次循环。 <br />
 			[page:Animation THREE.LoopPingPong] - 重复次数为*repetitions*的值, 且像乒乓球一样在起始点与结束点之间来回循环。
@@ -120,12 +120,12 @@
 
 		<h3>[property:Boolean zeroSlopeAtEnd]</h3>
 		<p>
-            启用平滑插值，无须单独剪辑开始、循环和结束。默认值是*true*
+			启用平滑插值，无须单独剪辑开始、循环和结束。默认值是*true*
 		</p>
 
 		<h3>[property:Boolean zeroSlopeAtStart]</h3>
 		<p>
-            启用平滑插值，无须单独剪辑开始、循环和结束。默认值是*true*
+			启用平滑插值，无须单独剪辑开始、循环和结束。默认值是*true*
 		</p>
 
 
@@ -144,7 +144,7 @@
 
 		<h3>[method:AnimationAction crossFadeTo]( [param:AnimationAction fadeInAction], [param:Number durationInSeconds], [param:Boolean warpBoolean] )</h3>
 		<p>
-            在传入的时间段内, 让此动作淡出（[page:.fadeOut fade out]），同时让另一个动作淡入。此方法可链式调用。<br /><br />
+			在传入的时间段内, 让此动作淡出（[page:.fadeOut fade out]），同时让另一个动作淡入。此方法可链式调用。<br /><br />
 			如果warpBoolean值是true, 额外的 [page:.warp warping] (时间比例的渐变)将会被应用。<br /><br />
 
 			说明: 与 *fadeIn*/*fadeOut*一样, 淡入淡出动作开始/结束时的权重是1.
@@ -152,12 +152,12 @@
 
 		<h3>[method:AnimationAction fadeIn]( [param:Number durationInSeconds] )</h3>
 		<p>
-            在传入的时间间隔内，逐渐将此动作的权重（[page:.weight weight]）由0升到1。此方法可链式调用。
+			在传入的时间间隔内，逐渐将此动作的权重（[page:.weight weight]）由0升到1。此方法可链式调用。
 		</p>
 
 		<h3>[method:AnimationAction fadeOut]( [param:Number durationInSeconds] )</h3>
 		<p>
-            在传入的时间间隔内，逐渐将此动作的权重（[page:.weight weight]）由1降至0。此方法可链式调用。
+			在传入的时间间隔内，逐渐将此动作的权重（[page:.weight weight]）由1降至0。此方法可链式调用。
 		</p>
 
 		<h3>[method:Number getEffectiveTimeScale]()</h3>
@@ -177,7 +177,7 @@
 
 		<h3>[method:AnimationMixer getMixer]()</h3>
 		<p>
-            返回负责完成此动作的混合器
+			返回负责完成此动作的混合器
 		</p>
 
 		<h3>[method:Object3D getRoot]()</h3>
@@ -224,7 +224,7 @@
 			[page:.time time]设为0, 中断任何预定的淡入淡出和变形, 以及移除内部循环次数以及延迟启动。<br /><br />
 
 			说明: 停止方法[page:.stop stop]内调用了重置方法（reset）, 但是 .*reset*不会调用 .*stop*。
-            这就表示: 如果你想要这两者, 重置并且停止, 不要调用*reset*; 而应该调用*stop*。
+			这就表示: 如果你想要这两者, 重置并且停止, 不要调用*reset*; 而应该调用*stop*。
 		</p>
 
 		<h3>[method:AnimationAction setDuration]( [param:Number durationInSeconds] )</h3>
@@ -295,7 +295,7 @@
 
 		<h3>[method:AnimationAction warp]( [param:Number startTimeScale], [param:Number endTimeScale], [param:Number durationInSeconds] )</h3>
 		<p>
-            在传入的事件间隔内，通过逐渐将时间比例[page:.timeScale timeScale]由*startTimeScale*修改至*endTimeScale*来改变回放速度。该方法可被链式调用。
+			在传入的事件间隔内，通过逐渐将时间比例[page:.timeScale timeScale]由*startTimeScale*修改至*endTimeScale*来改变回放速度。该方法可被链式调用。
 		</p>
 
 

docs/api/zh/animation/AnimationClip.html

@@ -49,7 +49,7 @@
 
 		<h3>[property:Array tracks]</h3>
 		<p>
-            一个包含该剪辑中有动画的所有属性的关键帧轨道（[page:KeyframeTrack]）的数组。
+			一个包含该剪辑中有动画的所有属性的关键帧轨道（[page:KeyframeTrack]）的数组。
 		</p>
 
 		<h3>[property:String uuid]</h3>
@@ -67,14 +67,12 @@
 
 		<h3>[method:this optimize]()</h3>
 		<p>
-            通过移除等效的顺序键（在变形目标序列中很常见）来优化每一个轨道
-
+			通过移除等效的顺序键（在变形目标序列中很常见）来优化每一个轨道
 		</p>
 
 		<h3>[method:this resetDuration]()</h3>
 		<p>
 			将剪辑的持续时间（[page:.duration duration]）设为最长的关键帧轨道([page:KeyframeTrack])的持续时间。
-			.
 		</p>
 
 		<h3>[method:this trim]()</h3>
@@ -84,7 +82,7 @@
 
 		<h3>[method:Boolean validate]()</h3>
 		<p>
-            对剪辑中的每个轨道执行最小验证。如果所有轨道都有效，返回true。
+			对剪辑中的每个轨道执行最小验证。如果所有轨道都有效，返回true。
 		</p>
 
 
@@ -99,7 +97,7 @@
 
 		<h3>[method:AnimationClip CreateFromMorphTargetSequence]( [param:String name], [param:Array morphTargetSequence], [param:Number fps], [param:Boolean noLoop] )</h3>
 		<p>
-            返回一个由几何体变形目标数组([page:Geometry.morphTargets morph targets array])得到的新动画剪辑，接收名称和帧率参数。<br /><br />
+			返回一个由几何体变形目标数组([page:Geometry.morphTargets morph targets array])得到的新动画剪辑，接收名称和帧率参数。<br /><br />
 
 			说明: 帧率是必须参数, 但是动画速度可能会在*AnimationAction*中被[page:AnimationAction.setDuration animationAction.setDuration]方法重写。
 
@@ -117,7 +115,7 @@
 
 		<h3>[method:AnimationClip parseAnimation]( [param:Object animation], [param:Array bones] )</h3>
 		<p>
-            解析动画层级格式并返回动画剪辑。
+			解析动画层级格式并返回动画剪辑。
 		</p>
 
 		<h3>[method:Object toJSON]( [param:AnimationClip clip] )</h3>

docs/api/zh/animation/AnimationMixer.html

@@ -11,7 +11,7 @@
 		<h1>[name]</h1>
 
 		<p class="desc">
-            动画混合器是用于场景中特定对象的动画的播放器。当场景中的多个对象独立动画时，每个对象都可以使用同一个动画混合器。<br /><br />
+			动画混合器是用于场景中特定对象的动画的播放器。当场景中的多个对象独立动画时，每个对象都可以使用同一个动画混合器。<br /><br />
 
 			在使用手册的“下一步”章节中，“动画系统”一文对three.js动画系统中的不同元素作出了概述
 		</p>
@@ -41,6 +41,13 @@
 			说明: 将混合器的时间比例设为0, 稍后再设置为1，可以暂停/取消暂停由该混合器控制的所有动作。
 		</p>
 
+		<h3>[method:AnimationMixer setTime]([param:Number timeInSeconds]) </h3>
+		<p>
+			设置全局混合器到一个给定的时间，并相应地更新动画。<br /><br />
+
+			当你需要在一个动画里跳转到一个精确的时间，该函数将是十分有用的。输入的参数将会被混合器的[page:.timeScale timeScale]进行缩放。
+		</p>
+
 
 		<h2>方法</h2>
 

docs/api/zh/animation/AnimationObjectGroup.html

@@ -18,10 +18,10 @@
 		<h2>用法:</h2>
 
 		<p class="desc">
-            将本来要作为根对象传入构造器或者动画混合器([page:AnimationMixer AnimationMixer])的[page:AnimationMixer.clipAction clipAction]方法中的对象加入组中，并将这个组对象作为根对象传递。
+			将本来要作为根对象传入构造器或者动画混合器([page:AnimationMixer AnimationMixer])的[page:AnimationMixer.clipAction clipAction]方法中的对象加入组中，并将这个组对象作为根对象传递。
 			<br /><br />
 
-		    注意，这个类的实例作为混合器中的一个对象，因此，必须对组内的单个对象做缓存控制。
+			注意，这个类的实例作为混合器中的一个对象，因此，必须对组内的单个对象做缓存控制。
 		</p>
 
 

docs/api/zh/animation/AnimationUtils.html

@@ -11,7 +11,7 @@
 		<h1>[name]</h1>
 
 		<p class="desc">
-            一个提供各种动画辅助方法的对象，内部使用。
+		一个提供各种动画辅助方法的对象，内部使用。
 		</p>
 
 
@@ -25,17 +25,17 @@
 
 		<h3>[method:Array convertArray]( array, type, forceClone )</h3>
 		<p>
-            将数组转换为某种特定类型。
+		将数组转换为某种特定类型。
 		</p>
 
 		<h3>[method:Array flattenJSON]( jsonKeys, times, values, valuePropertyName  )</h3>
 		<p>
-            用于解析AOS关键帧格式。
+		用于解析AOS关键帧格式。
 		</p>
 
 		<h3>[method:Array getKeyframeOrder]( times )</h3>
 		<p>
-            返回一个数组，时间和值可以根据此数组排序。
+		返回一个数组，时间和值可以根据此数组排序。
 		</p>
 
 		<h3>[method:Number insertKeyframe]( [param:KeyframeTrack track], [param:Number time] )</h3>
@@ -43,7 +43,7 @@
 
 		<h3>[method:Boolean isTypedArray]( object )</h3>
 		<p>
-            如果该对象是类型化数组，返回*true*
+		如果该对象是类型化数组，返回*true*
 
 		</p>
 
@@ -52,10 +52,13 @@
 
 		<h3>[method:Array sortedArray]( values, stride, order )</h3>
 		<p>
-            将[page:AnimationUtils.getKeyframeOrder getKeyframeOrder]方法返回的数组排序。
-
+		将[page:AnimationUtils.getKeyframeOrder getKeyframeOrder]方法返回的数组排序。
 		</p>
 
+		<h3>[method:AnimationClip subclip]( [param:AnimationClip clip], [param:String name], [param:Number startFrame], [param:Number endFrame], [param:Number fps] )</h3>
+		<p>
+		创建一个新的片段，仅包含所给定帧之间的原始剪辑片段。
+		</p>
 
 		<h2>源码</h2>
 

docs/api/zh/animation/KeyframeTrack.html

@@ -17,26 +17,26 @@
 		</p>
 
 		<p>
-            在使用手册的“下一步”章节中，“动画系统”一文对three.js动画系统中的不同元素作出了概述
+			在使用手册的“下一步”章节中，“动画系统”一文对three.js动画系统中的不同元素作出了概述
 		</p>
 
 		<p>
-            和[link:https://github.com/mrdoob/three.js/wiki/JSON-Model-format-3 JSON model format]的动画层级相反，
-            关键帧轨道（KeyframeTrack）不会将单帧作为对象存储在“key”数组(一个存有每一帧的时间和值的地方)中。
+			和[link:https://github.com/mrdoob/three.js/wiki/JSON-Model-format-3 JSON model format]的动画层级相反，
+			关键帧轨道（KeyframeTrack）不会将单帧作为对象存储在“key”数组(一个存有每一帧的时间和值的地方)中。
 
 		</p>
 
 		<p>
-            关键帧轨道(KeyframeTrack)中总是存在两个数组：[page:.times times]数组按顺序存储该轨道的所有关键帧的时间值，而[page:.values values]数组包含动画属性的相应更改值。
+			关键帧轨道(KeyframeTrack)中总是存在两个数组：[page:.times times]数组按顺序存储该轨道的所有关键帧的时间值，而[page:.values values]数组包含动画属性的相应更改值。
 		</p>
 
 		<p>
-            值数组中的每一个成员，属于某一特定时间点，不仅可以是一个简单的数字，还可以是（比如）一个向量（如果是位置动画）或者是一个四元数（如果是旋转动画）。
-            因此，值数组（也是一个平面阵列）的长度可能是时间数组的三四倍。
+			值数组中的每一个成员，属于某一特定时间点，不仅可以是一个简单的数字，还可以是（比如）一个向量（如果是位置动画）或者是一个四元数（如果是旋转动画）。
+			因此，值数组（也是一个平面阵列）的长度可能是时间数组的三四倍。
 		</p>
 
 		<p>
-            与不同类型的动画值对应，存在若干关键帧轨道(KeyframeTrack)的子类，继承了它大多数属性和方法：
+			与不同类型的动画值对应，存在若干关键帧轨道(KeyframeTrack)的子类，继承了它大多数属性和方法：
 		</p>
 
 		<ul>
@@ -49,15 +49,15 @@
 		</ul>
 
 		<p>
-            可以在[link:https://threejs.org/examples/js/animation/AnimationClipCreator.js AnimationClipCreator]文件中找到用不同类型的关键帧轨道创建动画剪辑([page:AnimationClip AnimationClips])的示例。
+			可以在[link:https://threejs.org/examples/js/animation/AnimationClipCreator.js AnimationClipCreator]文件中找到用不同类型的关键帧轨道创建动画剪辑([page:AnimationClip AnimationClips])的示例。
 		</p>
 
 		<p>
-            由于显式值仅针对存储在时间数组中的离散时间点指定，因此必须在两个时间点之间进行插值
+			由于显式值仅针对存储在时间数组中的离散时间点指定，因此必须在两个时间点之间进行插值
 		</p>
 
 		<p>
-            轨道的名称对于这个轨道与动画节点的特定属性的连接(由[page:PropertyBinding]完成)很重要。
+			轨道的名称对于这个轨道与动画节点的特定属性的连接(由[page:PropertyBinding]完成)很重要。
 		</p>
 
 
@@ -81,11 +81,11 @@
 
 		<h3>[property:String name]</h3>
 		<p>
-            轨道的名称可以指动画对象中的变形目标([page:Geometry.morphTargets morph targets])、骨骼([page:SkinnedMesh bones])或可能的其他值
+			轨道的名称可以指动画对象中的变形目标([page:Geometry.morphTargets morph targets])、骨骼([page:SkinnedMesh bones])或可能的其他值
 			查看[page:PropertyBinding.parseTrackName]可获知哪些形式的字符串可以解析出绑定的属性:
 		</p>
 		<p>
-            可以使用节点名称或uuid（尽管它需要位于传递到混合器的场景图节点的子树中）引用到某节点。或者， 如果轨道名称的首字符是点,
+			可以使用节点名称或uuid（尽管它需要位于传递到混合器的场景图节点的子树中）引用到某节点。或者， 如果轨道名称的首字符是点,
 			该轨道会应用到传入到混合器的根节点上。
 		</p>
 
@@ -94,7 +94,7 @@
 		</p>
 
 		<p>
-            还可以使用对象名称来指定骨骼或多材质，例如：.bones[R_hand].scale；再比如，材料数组中的第四个材料的漫反射颜色的红通道可以通过 .materials[3].diffuse[r]访问到。
+			还可以使用对象名称来指定骨骼或多材质，例如：.bones[R_hand].scale；再比如，材料数组中的第四个材料的漫反射颜色的红通道可以通过 .materials[3].diffuse[r]访问到。
 		</p>
 
 		<p>
@@ -159,30 +159,30 @@
 
 		<h3>[method:DiscreteInterpolant InterpolantFactoryMethodDiscrete]( [link:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float32Array result] )</h3>
 		<p>
-            根据时间([page:KeyframeTrack.times times])和值([page:KeyframeTrack.times values])创建一个新的离散插值([page:DiscreteInterpolant DiscreteInterpolant])。
-            可传入一个Float32Array类型的变量来接收结果， 否则会自动创建一个长度适宜的新数组。
+			根据时间([page:KeyframeTrack.times times])和值([page:KeyframeTrack.times values])创建一个新的离散插值([page:DiscreteInterpolant DiscreteInterpolant])。
+			可传入一个Float32Array类型的变量来接收结果， 否则会自动创建一个长度适宜的新数组。
 		</p>
 
 		<h3>[method:null InterpolantFactoryMethodLinear]( [link:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float32Array result] )</h3>
 		<p>
-            根据时间([page:KeyframeTrack.times times])和值([page:KeyframeTrack.times values])创建一个新的线性插值([page:LinearInterpolant LinearInterpolant])。
-            可传入一个Float32Array类型的变量来接收结果， 否则会自动创建一个长度适宜的新数组。
+			根据时间([page:KeyframeTrack.times times])和值([page:KeyframeTrack.times values])创建一个新的线性插值([page:LinearInterpolant LinearInterpolant])。
+			可传入一个Float32Array类型的变量来接收结果， 否则会自动创建一个长度适宜的新数组。
 		</p>
 
 		<h3>[method:null InterpolantFactoryMethodSmooth]( [link:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float32Array result] )</h3>
 		<p>
-            根据时间([page:KeyframeTrack.times times])和值([page:KeyframeTrack.times values])创建一个新的立方插值([page:CubicInterpolant CubicInterpolant])。
-            可传入一个Float32Array类型的变量来接收结果， 否则会自动创建一个长度适宜的新数组。
+			根据时间([page:KeyframeTrack.times times])和值([page:KeyframeTrack.times values])创建一个新的立方插值([page:CubicInterpolant CubicInterpolant])。
+			可传入一个Float32Array类型的变量来接收结果， 否则会自动创建一个长度适宜的新数组。
 		</p>
 
 		<h3>[method:this optimize]()</h3>
 		<p>
-            删除等效的顺序键，这些键在变形目标序列中很常见。
+			删除等效的顺序键，这些键在变形目标序列中很常见。
 		</p>
 
 		<h3>[method:this scale]()</h3>
 		<p>
-            缩放所有关键帧的时间。<br /><br />
+			缩放所有关键帧的时间。<br /><br />
 
 			说明: 这个方法很有用，例如， 可用于转化为某一特定帧率(正如[page:AnimationClip.CreateFromMorphTargetSequence animationClip.CreateFromMorphTargetSequence]内部所做的一样)。
 		</p>
@@ -194,7 +194,7 @@
 
 		<h3>[method:this shift]( [param:Number timeOffsetInSeconds] )</h3>
 		<p>
-            及时删除之前或之后的所有关键帧。
+			及时删除之前或之后的所有关键帧。
 		</p>
 
 
@@ -205,7 +205,7 @@
 
 		<h3>[method:Boolean validate]()</h3>
 		<p>
-            在轨道上执行最小验证，有效则返回true
+			在轨道上执行最小验证，有效则返回true
 		</p>
 
 		<p>
@@ -217,12 +217,12 @@
 
 		<h3>[method:KeyframeTrack parse]( [param:JSON json] )</h3>
 		<p>
-            解析JSON对象并返回一个正确类型的新关键帧轨道。
+			解析JSON对象并返回一个正确类型的新关键帧轨道。
 		</p>
 
 		<h3>[method:JSON toJSON]( [param:KeyframeTrack track] )</h3>
 		<p>
-		    将该轨道转化为JSON
+			将该轨道转化为JSON
 		</p>
 
 

docs/api/zh/animation/PropertyBinding.html

@@ -11,7 +11,7 @@
 		<h1>[name]</h1>
 
 		<p class="desc">
-            对场景图中某一真实属性的引用，内部使用。
+			对场景图中某一真实属性的引用，内部使用。
 		</p>
 
 
@@ -97,7 +97,7 @@
 
 		<h3>[method:Constructor create]( root, path, parsedPath )</h3>
 		<p>
-            创建一个新的复合属性绑定(Composite PropertyBinding) (如果根对象是[page:AnimationObjectGroup])或普通属性绑定
+			创建一个新的复合属性绑定(Composite PropertyBinding) (如果根对象是[page:AnimationObjectGroup])或普通属性绑定
 		</p>
 
 		<h3>[method:Constructor parseTrackName]( trackName )</h3>
@@ -116,7 +116,7 @@
 
 		<h3>[method:Constructor findNode]( root, nodeName )</h3>
 		<p>
-            从节点树或骨骼([page:Skeleton Skeleton])中找出某节点
+			从节点树或骨骼([page:Skeleton Skeleton])中找出某节点
 		</p>
 
 

docs/api/zh/animation/PropertyMixer.html

@@ -11,7 +11,7 @@
 		<h1>[name]</h1>
 
 		<p class="desc">
-        允许加权累加的缓冲场景图属性，内部使用
+		允许加权累加的缓冲场景图属性，内部使用
 		</p>
 
 
@@ -54,12 +54,12 @@
 
 		<h3>[property:Number referenceCount]</h3>
 		<p>
-            默认值是0
+			默认值是0
 		</p>
 
 		<h3>[property:Number useCount]</h3>
 		<p>
-           默认值是0
+		   默认值是0
 		</p>
 
 
@@ -85,7 +85,7 @@
 
 		<h3>[method:null restoreOriginalState](  )</h3>
 		<p>
-            将预先通过'saveOriginalState'方法取得的状态应用于绑定。
+			将预先通过'saveOriginalState'方法取得的状态应用于绑定。
 		</p>
 
 

docs/api/zh/audio/Audio.html

@@ -193,9 +193,14 @@
 
 		<h3>[method:Audio setMediaElementSource]( mediaElement )</h3>
 		<p>
-		应用[link:https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement HTMLMediaElement]类型对象作为音源.<br />
-		并且设置[page:Audio.hasPlaybackControl hasPlaybackControl]为false.
+		应用传入的[link:https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement HTMLMediaElement]类型对象作为音源。<br />
+		并且设置[page:Audio.hasPlaybackControl hasPlaybackControl]为false。
+		</p>
 
+		<h3>[method:Audio setMediaStreamSource]( mediaStream )</h3>
+		<p>
+		应用传入的[link:https://developer.mozilla.org/en-US/docs/Web/API/MediaStream MediaStream]类型对象作为音源。<br />
+		并且设置[page:Audio.hasPlaybackControl hasPlaybackControl]为false。
 		</p>
 
 		<h3>[method:Audio setNodeSource]( audioNode )</h3>

docs/api/zh/constants/Animation.html

@@ -18,19 +18,19 @@ THREE.LoopRepeat
 THREE.LoopPingPong
 		</code>
 
-    <h2>插值模式</h2>
-    <code>
+	<h2>插值模式</h2>
+	<code>
 THREE.InterpolateDiscrete
 THREE.InterpolateLinear
 THREE.InterpolateSmooth
-    </code>
+	</code>
 
-    <h2>结束模式</h2>
-    <code>
+	<h2>结束模式</h2>
+	<code>
 THREE.ZeroCurvatureEnding
 THREE.ZeroSlopeEnding
 THREE.WrapAroundEnding
-    </code>
+	</code>
 
 		<h2>源代码</h2>
 

docs/api/zh/constants/Core.html

@@ -20,12 +20,12 @@
 			当前three.js的修订版本号（ [link:https://github.com/mrdoob/three.js/releases revision number]）。
 		</div>
 
-    <h2>鼠标按钮</h2>
-    <code>
+	<h2>鼠标按钮</h2>
+	<code>
 		THREE.MOUSE.LEFT
 		THREE.MOUSE.MIDDLE
 		THREE.MOUSE.RIGHT
-    </code>
+	</code>
 
 		<h2>源代码</h2>
 

docs/api/zh/constants/DrawModes.html

@@ -21,7 +21,7 @@
 			THREE.TrianglesDrawMode
 		</code>
 		<p>
-			这是默认值，这将使得每三个连续顶点(v0, v1, v2)，(v2, v3, v5)，……被解释为一个单独的三角形。
+			这是默认值，这将使得每三个连续顶点(v0, v1, v2)，(v3, v4, v5)，……被解释为一个单独的三角形。
 			<br />
 			如果顶点的数量不是3的倍数，那么将会忽略多余的顶点。
 		</p>
@@ -51,15 +51,15 @@
 		var geometry = new THREE.BufferGeometry();
 
 		var vertices = [];
-
+	
 		vertices.push( -10,  10, 0 );
 		vertices.push( -10, -10, 0 );
 		vertices.push(  10, -10, 0 );
-
+	
 		// ...
-
+	
 		geometry.addAttribute( 'position', new THREE.Float32BufferAttribute( vertices, 3 ) );
-
+	
 		var material = new THREE.MeshBasicMaterial( { color: 0xffff00 } );
 
 		var mesh = new THREE.Mesh( geometry, material );

docs/api/zh/constants/Renderer.html

@@ -46,8 +46,8 @@
 
 		[page:constant BasicShadowMap] 能够给出没有经过过滤的阴影映射 —— 速度最快，但质量最差。<br />
 		[page:constant PCFShadowMap] 为默认值，使用Percentage-Closer Filtering (PCF)算法来过滤阴影映射。<br />
-		[page:constant PCFSoftShadowMap] 使用Percentage-Closer Soft Shadows (PCSS) 算法来过滤阴影映射。<br />
-		[page:constant VSMShadowMap] filters shadow maps using the Variance Shadow Map (VSM) algorithm.
+		[page:constant PCFSoftShadowMap] 使用Percentage-Closer Soft Shadows (PCSS)算法来过滤阴影映射。<br />
+		[page:constant VSMShadowMap] 使用Variance Shadow Map (VSM)算法来过滤阴影映射。当使用VSMShadowMap时，所有阴影接收者也将会投射阴影。
 		</p>
 
 		<h2>色调映射</h2>
@@ -59,9 +59,9 @@
 		THREE.CineonToneMapping
 		</code>
 		<p>
-				这些常量定义了WebGLRenderer中[page:WebGLRenderer.toneMapping toneMapping]的属性。
+		这些常量定义了WebGLRenderer中[page:WebGLRenderer.toneMapping toneMapping]的属性。
 
-				这个属性用于在普通计算机显示器或者移动设备屏幕等低动态范围介质上，模拟、逼近高动态范围（HDR）效果。<br /><br />
+		这个属性用于在普通计算机显示器或者移动设备屏幕等低动态范围介质上，模拟、逼近高动态范围（HDR）效果。<br /><br />
 
 		[page:constant NoToneMapping] 禁用色调映射。<br />
 		[page:constant LinearToneMapping] 为默认值，线性色调映射。<br /><br />

docs/api/zh/constants/Textures.html

@@ -63,9 +63,7 @@
 		使用[page:constant MirroredRepeatWrapping]， 纹理将重复到无穷大，在每次重复时将进行镜像。
 	</p>
 
-	<h2>Magnification Filters
-		放大滤镜
-	</h2>
+	<h2>放大滤镜（Magnification Filters）</h2>
 	<code>
 		THREE.NearestFilter
 		THREE.LinearFilter
@@ -80,8 +78,7 @@
 
 	</p>
 
-	<h2>缩小滤镜
-		Minification Filters</h2>
+	<h2>缩小滤镜（Minification Filters）</h2>
 	<code>
 		THREE.NearestFilter
 		THREE.NearestMipmapNearestFilter
@@ -97,20 +94,20 @@
 		除了[page:constant NearestFilter] 和 [page:constant LinearFilter]，
 		下面的四个函数也可以用于缩小：<br /><br />
 
-		[page:constant NearestMipmapNearestFilter]选择与被纹理化像素的尺寸最匹配的mipmap，并以[page:constant
-		NearestFilter]（最靠近像素中心的纹理元素）为标准来生成纹理值。
+		[page:constant NearestMipmapNearestFilter]选择与被纹理化像素的尺寸最匹配的mipmap，
+		并以[page:constant NearestFilter]（最靠近像素中心的纹理元素）为标准来生成纹理值。
 		<br /><br />
 
-		[page:constant NearestMipmapLinearFilter]选择与被纹理化像素的尺寸最接近的两个mipmap，并以[page:constant
-		NearestFilter]为标准来从每个mipmap中生成纹理值。最终的纹理值是这两个值的加权平均值。
+		[page:constant NearestMipmapLinearFilter]选择与被纹理化像素的尺寸最接近的两个mipmap，
+		并以[page:constant NearestFilter]为标准来从每个mipmap中生成纹理值。最终的纹理值是这两个值的加权平均值。
 		<br /><br />
 
-		[page:constant LinearMipmapNearestFilter]选择与被纹理化像素的尺寸最匹配的mipmap，并以[page:constant
-		LinearFilter]（最靠近像素中心的四个纹理元素的加权平均值）为标准来生成纹理值。
+		[page:constant LinearMipmapNearestFilter]选择与被纹理化像素的尺寸最匹配的mipmap，
+		并以[page:constant LinearFilter]（最靠近像素中心的四个纹理元素的加权平均值）为标准来生成纹理值。
 		<br /><br />
 
-		[page:constant LinearMipmapLinearFilter]是默认值，它选择与被纹理化像素的尺寸最接近的两个mipmap，并以[page:constant
-		LinearFilter]为标准来从每个mipmap中生成纹理值。最终的纹理值是这两个值的加权平均值。<br /><br />
+		[page:constant LinearMipmapLinearFilter]是默认值，它选择与被纹理化像素的尺寸最接近的两个mipmap，
+		并以[page:constant LinearFilter]为标准来从每个mipmap中生成纹理值。最终的纹理值是这两个值的加权平均值。<br /><br />
 
 		请查看示例：[example:webgl_materials_texture_filters materials / texture / filters]。
 	</p>
@@ -175,8 +172,8 @@
 
 		<br /><br />
 		请注意，纹理必须具有正确的[page:Texture.type type]设置，正如上一节所描述的那样。
-		请参阅[link:https://developer.mozilla.org/en/docs/Web/API/WebGLRenderingContext/texImage2D
-		WebGLRenderingContext.texImage2D]来获得有关详细信息。
+		请参阅[link:https://developer.mozilla.org/en/docs/Web/API/WebGLRenderingContext/texImage2D WebGLRenderingContext.texImage2D]
+		来获得有关详细信息。
 	</p>
 
 	<h2>DDS / ST3C 压缩纹理格式</h2>
@@ -187,9 +184,9 @@
 		THREE.RGBA_S3TC_DXT5_Format
 		</code>
 	<p>
-		要使用[page:CompressedTexture CompressedTexture]中的[page:Texture.format
-		format]属性，需要获得[link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_s3tc/
-		WEBGL_compressed_texture_s3tc]扩展的支持。<br /><br />
+		要使用[page:CompressedTexture CompressedTexture]中的[page:Texture.format format]属性，
+		需要获得[link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_s3tc/ WEBGL_compressed_texture_s3tc]
+		扩展的支持。<br /><br />
 
 		通过这个扩展，这里的四种[link:https://en.wikipedia.org/wiki/S3_Texture_Compression S3TC]格式将可以使用：<br />
 
@@ -199,8 +196,7 @@
 		[page:constant RGBA_S3TC_DXT5_Format]：RGBA图像格式的DXT5压缩图像，它也提供了4:1的压缩比，但与DX3格式的不同之处在于其Alpha是如何被压缩的。<br />
 	</p>
 
-	<h2>PVRTC 压缩纹理格式
-		PVRTC Compressed Texture Formats</h2>
+	<h2>PVRTC 压缩纹理格式（PVRTC Compressed Texture Formats）</h2>
 	<code>
 		THREE.RGB_PVRTC_4BPPV1_Format
 		THREE.RGB_PVRTC_2BPPV1_Format
@@ -209,8 +205,8 @@
 		</code>
 	<p>
 		要使用[page:CompressedTexture CompressedTexture]中的[page:Texture.format format]属性，需要获得
-		[link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_pvrtc/
-		WEBGL_compressed_texture_pvrtc]扩展的支持。<br />
+		[link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_pvrtc/ WEBGL_compressed_texture_pvrtc]
+		扩展的支持。<br />
 		PVRTC通常只在具有PowerVR芯片的移动设备上可用，这些设备主要是苹果设备。<br /><br />
 
 
@@ -228,8 +224,8 @@
 		</code>
 	<p>
 		要使用[page:CompressedTexture CompressedTexture]中的[page:Texture.format format]属性，需要获得
-		[link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_etc1/
-		WEBGL_compressed_texture_etc1]扩展的支持。<br /><br />
+		[link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_etc1/ WEBGL_compressed_texture_etc1]
+		扩展的支持。<br /><br />
 	</p>
 
 	<h2>编码</h2>

docs/api/zh/core/BufferGeometry.html

@@ -158,7 +158,7 @@
 
 		<h3>[method:BufferGeometry setAttribute]( [param:String name], [param:BufferAttribute attribute] )</h3>
 		<p>
-			为当前几何体增加一个 attribute。 的属性，在类的内部，有一个存储 [page:.attributes] 的 hashmap，
+			为当前几何体设置一个 attribute 属性。在类的内部，有一个存储 [page:.attributes] 的 hashmap，
 			通过该 hashmap，遍历 attributes 的速度会更快。而使用该方法，可以向 hashmap 内部增加 attribute。
 			所以，你需要使用该方法来添加 attributes。
 		</p>

docs/api/zh/core/EventDispatcher.html

@@ -22,11 +22,11 @@
 
 var Car = function () {
 
-    this.start = function () {
+	this.start = function () {
 
-        this.dispatchEvent( { type: 'start', message: 'vroom vroom!' } );
+		this.dispatchEvent( { type: 'start', message: 'vroom vroom!' } );
 
-    };
+	};
 
 };
 
@@ -40,7 +40,7 @@ var car = new Car();
 
 car.addEventListener( 'start', function ( event ) {
 
-    alert( event.message );
+	alert( event.message );
 
 } );
 

docs/api/zh/core/Object3D.html

@@ -38,9 +38,9 @@
 
 	<h3>[property:Material customDepthMaterial]</h3>
 	<p>渲染到深度贴图时此材质要使用的自定义深度材质。
-	    当使用[page:DirectionalLight]或[page:SpotLight]进行阴影投射时，如果您正在（a）修改顶点着色器中的顶点位置，
-	    （b）使用位移贴图，（c）alphaTest中使用alpha贴图，或（d）alphaTest中使用透明纹理，
-	    您必须指定customDepthMaterial以得到合适的阴影。默认值*undefined*。
+		当使用[page:DirectionalLight]或[page:SpotLight]进行阴影投射时，如果您正在（a）修改顶点着色器中的顶点位置，
+		（b）使用位移贴图，（c）alphaTest中使用alpha贴图，或（d）alphaTest中使用透明纹理，
+		您必须指定customDepthMaterial以得到合适的阴影。默认值*undefined*。
 	</p>
 
 	<h3>[property:Material customDistanceMaterial]</h3>
@@ -111,8 +111,8 @@
 
 	<h3>[property:function onBeforeRender]</h3>
 	<p>
-			一个可选的回调函数，在Object3D渲染之前直接执行。
-			使用以下参数来调用此函数：renderer，scene，camera，geometry，material，group。
+		一个可选的回调函数，在Object3D渲染之前直接执行。
+		使用以下参数来调用此函数：renderer，scene，camera，geometry，material，group。
 	</p>
 
 	<h3>[property:Object3D parent]</h3>
@@ -416,8 +416,15 @@
 	<p>更新局部变换。</p>
 
 	<h3>[method:null updateMatrixWorld]( [param:Boolean force] )</h3>
-	<p>更新物体及其子级的全局变换。</p>
+	<p>更新物体及其后代的全局变换。</p>
+
+	<h3>[method:null updateWorldMatrix]( [param:Boolean updateParents], [param:Boolean updateChildren] )</h3>
+	<p>
+		updateParents - recursively updates global transform of ancestors.<br />
+		updateChildren - recursively updates global transform of descendants.<br /><br />
 
+		Updates the global transform of the object.
+	</p>
 
 	<h3>[method:Vector3 worldToLocal]( [param:Vector3 vector] )</h3>
 	<p>

docs/api/zh/core/bufferAttributeTypes/BufferAttributeTypes.html

@@ -34,7 +34,9 @@
 		<p>所有上述内容都以相同的方式调用。</p>
 		<h3>TypedBufferAttribute( [param:Array array], [param:Integer itemSize], [param:Boolean normalized] )</h3>
 		<p>
-			array -- 这可以是类型化或非类型化的（普通）数组。它将被转换为指定的类型。<br /><br />
+			array -- 该值可以是类型化或非类型化的（普通）数组。
+			它将被转换为指定的类型。
+			If a length is given a new TypedArray will created, initialized with all elements set to zero.<br /><br />
 
 			itemSize -- 应与特定顶点关联的数组值的数量。<br /><br />
 

docs/api/zh/extras/core/Path.html

@@ -59,7 +59,7 @@
 		<h2>方法</h2>
 		<p>共有方法请参见其基类[page:CurvePath]。</p>
 
-		<h3>[method:null absarc]( [param:Float x], [param:Float y], [param:Float radius], [param:Float startAngle], [param:Float endAngle], [param:Float clockwise] )</h3>
+		<h3>[method:this absarc]( [param:Float x], [param:Float y], [param:Float radius], [param:Float startAngle], [param:Float endAngle], [param:Float clockwise] )</h3>
 		<p>
 			x, y -- 弧线的绝对中心。<br />
 			radius -- 弧线的半径。<br />
@@ -70,7 +70,7 @@
 			添加一条绝对定位的[page:EllipseCurve EllipseCurve]到路径中。
 		</p>
 
-		<h3>[method:null absellipse]( [param:Float x], [param:Float y], [param:Float xRadius], [param:Float yRadius], [param:Float startAngle], [param:Float endAngle], [param:Float clockwise], [param:Float rotation] )</h3>
+		<h3>[method:this absellipse]( [param:Float x], [param:Float y], [param:Float xRadius], [param:Float yRadius], [param:Float startAngle], [param:Float endAngle], [param:Float clockwise], [param:Float rotation] )</h3>
 		<p>
 			x, y -- 椭圆的绝对中心。<br />
 			xRadius -- 椭圆x轴方向的半径。<br />
@@ -83,7 +83,7 @@
 			添加一条绝对定位的[page:EllipseCurve EllipseCurve]到路径中。
 		</p>
 
-		<h3>[method:null arc]( [param:Float x], [param:Float y], [param:Float radius], [param:Float startAngle], [param:Float endAngle], [param:Float clockwise] )</h3>
+		<h3>[method:this arc]( [param:Float x], [param:Float y], [param:Float radius], [param:Float startAngle], [param:Float endAngle], [param:Float clockwise] )</h3>
 		<p>
 			x, y -- 弧线的中心来自上次调用后的偏移量。<br />
 			radius -- 弧线的半径。<br />
@@ -95,10 +95,10 @@
 		</p>
 
 
-		<h3>[method:null bezierCurveTo]( [param:Float cp1X], [param:Float cp1Y], [param:Float cp2X], [param:Float cp2Y], [param:Float x], [param:Float y] )</h3>
+		<h3>[method:this bezierCurveTo]( [param:Float cp1X], [param:Float cp1Y], [param:Float cp2X], [param:Float cp2Y], [param:Float x], [param:Float y] )</h3>
 		<p>从[page:.currentPoint]创建一条贝塞尔曲线，以(cp1X, cp1Y)和(cp2X, cp2Y)作为控制点，并将[page:.currentPoint]更新到x,y。</p>
 
-		<h3>[method:null ellipse]( [param:Float x], [param:Float y], [param:Float xRadius], [param:Float yRadius], [param:Float startAngle], [param:Float endAngle], [param:Float clockwise], [param:Float rotation] )</h3>
+		<h3>[method:this ellipse]( [param:Float x], [param:Float y], [param:Float xRadius], [param:Float yRadius], [param:Float startAngle], [param:Float endAngle], [param:Float clockwise], [param:Float rotation] )</h3>
 		<p>
 			x, y -- 椭圆的中心来自上次调用后的偏移量。The center of the ellipse offset from the last call.<br />
 			xRadius -- 椭圆x轴方向的半径。<br />
@@ -111,25 +111,25 @@
 			添加一条[page:EllipseCurve EllipseCurve]到路径中，位置相对于[page:.currentPoint]。
 		</p>
 
-		<h3>[method:null lineTo]( [param:Float x], [param:Float y] )</h3>
+		<h3>[method:this lineTo]( [param:Float x], [param:Float y] )</h3>
 		<p>在当前路径上，从[page:.currentPoint]连接一条直线到x,y。</p>
 
 
-		<h3>[method:null moveTo]( [param:Float x], [param:Float y] )</h3>
+		<h3>[method:this moveTo]( [param:Float x], [param:Float y] )</h3>
 		<p>将[page:.currentPoint]移动到x, y。</p>
 
 
-		<h3>[method:null quadraticCurveTo]( [param:Float cpX], [param:Float cpY], [param:Float x], [param:Float y] )</h3>
+		<h3>[method:this quadraticCurveTo]( [param:Float cpX], [param:Float cpY], [param:Float x], [param:Float y] )</h3>
 		<p>从[page:.currentPoint]创建一条二次曲线，以(cpX,cpY)作为控制点，并将[page:.currentPoint]更新到x,y。</p>
 
-		<h3>[method:null setFromPoints]( [param:Array vector2s] )</h3>
+		<h3>[method:this setFromPoints]( [param:Array vector2s] )</h3>
 		<p>
 			points -- [page:Vector2 Vector2]数组。<br /><br />
 
 			点将被作为[page:LineCurve LineCurves]加入到[page:CurvePath.curves curves]数组中。
 		</p>
 
-		<h3>[method:null splineThru] ( [param:Array points] ) </h3>
+		<h3>[method:this splineThru] ( [param:Array points] ) </h3>
 		<p>
 			points -[page:Vector2 Vector2]数组。<br /><br />
 

docs/api/zh/extras/core/ShapePath.html

@@ -44,27 +44,27 @@
 
 		<h2>方法</h2>
 
-		<h3>[method:null moveTo]( [param:Float x], [param:Float y] )</h3>
+		<h3>[method:this moveTo]( [param:Float x], [param:Float y] )</h3>
 		<p>
 		创建一个新的[page:Path]，并在[page:Path]上调用[page:Path.moveTo]( x, y )。
 		</p>
 
-		<h3>[method:null lineTo]( [param:Float x], [param:Float y] )</h3>
+		<h3>[method:this lineTo]( [param:Float x], [param:Float y] )</h3>
 		<p>这一方法从[page:ShapePath.currentPath currentPath]（当前路径）的偏移量创建一条到X和Y的线，并将偏移量更新为X和Y。
 		</p>
 
-		<h3>[method:null quadraticCurveTo]( [param:Float cpX], [param:Float cpY], [param:Float x], [param:Float y] )</h3>
+		<h3>[method:this quadraticCurveTo]( [param:Float cpX], [param:Float cpY], [param:Float x], [param:Float y] )</h3>
 		<p>这一方法从[page:ShapePath.currentPath currentPath]（当前路径）创建一条到X和Y的二次曲线，cpX和cpY作为控制点，
 			并将[page:ShapePath.currentPath currentPath]的偏移量更新为x和y。
 		</p>
 
-		<h3>[method:null bezierCurveTo]( [param:Float cp1X], [param:Float cp1Y], [param:Float cp2X], [param:Float cp2Y], [param:Float x], [param:Float y] )</h3>
+		<h3>[method:this bezierCurveTo]( [param:Float cp1X], [param:Float cp1Y], [param:Float cp2X], [param:Float cp2Y], [param:Float x], [param:Float y] )</h3>
 		<p>
 			这一方法从[page:ShapePath.currentPath currentPath]（当前路径）的偏移量创建一条到X和Y的贝塞尔曲线，
 			cp1X、cp1Y和cp1X、cp1Y为控制点，并将[page:ShapePath.currentPath currentPath]的偏移量更新为x和y。
 		</p>
 
-		<h3>[method:null splineThru] ( [param:Array points] ) </h3>
+		<h3>[method:this splineThru] ( [param:Array points] ) </h3>
 		<p>points - 一个[page:Vector2]数组。</p>
 		<p>
 			连接一个新的[page:SplineCurve]（样条曲线）到[page:ShapePath.currentPath currentPath]（当前路径）。</p>

docs/api/zh/extras/curves/EllipseCurve.html

@@ -46,12 +46,10 @@ var ellipse = new THREE.Line( geometry, material );
 			[page:Float aY] – 椭圆的中心的Y坐标，默认值为*0*。<br/>
 			[page:Float xRadius] – X轴向上椭圆的半径，默认值为*1*。<br/>
 			[page:Float yRadius] – Y轴向上椭圆的半径，默认值为*1*。<br/>
-			[page:Radians aStartAngle] – 以弧度来表示，从正右侧算起曲线开始的角度，默认值为*0*。<br/>
-			[page:Radians aEndAngle] – 以弧度来表示，从正右侧算起曲线终止的角度，默认值为*2 x Math.PI*。<br/>
+			[page:Radians aStartAngle] – 以弧度来表示，从正X轴算起曲线开始的角度，默认值为*0*。<br/>
+			[page:Radians aEndAngle] – 以弧度来表示，从正X轴算起曲线终止的角度，默认值为*2 x Math.PI*。<br/>
 			[page:Boolean aClockwise] – 椭圆是否按照顺时针方向来绘制，默认值为*false*。<br/>
 			[page:Radians aRotation]  – 以弧度表示，椭圆从X轴正方向逆时针的旋转角度（可选），默认值为*0*。<br/><br/>
-
-			<em>请注意：</em> 当使用顺时针的时候，最好将起始角度角度设为(Math.PI * 2)，并向着更小的数字运行。
 		</p>
 
 		<h2>属性</h2>

docs/api/zh/helpers/AxesHelper.html

@@ -28,7 +28,7 @@
 		<code>
 var axesHelper = new THREE.AxesHelper( 5 );
 scene.add( axesHelper );
-    </code>
+		</code>
 
 		<h2>构造函数</h2>
 

docs/api/zh/helpers/CameraHelper.html

@@ -57,7 +57,7 @@ scene.add( helper );
 
 		<h3>[property:object matrixAutoUpdate]</h3>
 		<p>
-		    请查看 [page:Object3D.matrixAutoUpdate]. 这里设置为 *false* 表示辅助对象
+			请查看 [page:Object3D.matrixAutoUpdate]. 这里设置为 *false* 表示辅助对象
 			使用相机的 [page:Object3D.matrixWorld matrixWorld].
 		</p>
 

docs/api/zh/lights/HemisphereLight.html

@@ -8,7 +8,7 @@
 		<link type="text/css" rel="stylesheet" href="page.css" />
 	</head>
 	<body>
-        [page:Object3D] &rarr; [page:Light] &rarr;
+		[page:Object3D] &rarr; [page:Light] &rarr;
 
 		<h1>半球光（[name]）</h1>
 
@@ -37,7 +37,7 @@ scene.add( light );
 
 		<h2>构造器（Constructor）</h2>
 		<h3>[name]( [param:Integer skyColor], [param:Integer groundColor], [param:Float intensity] )</h3>
-    <p>
+	<p>
 		[page:Integer skyColor] - (可选参数) 天空中发出光线的颜色。 缺省值 0xffffff。<br />
 		[page:Integer groundColor] - (可选参数) 地面发出光线的颜色。 缺省值 0xffffff。<br />
 		[page:Float intensity] - (可选参数) 光照强度。 缺省值 1。<br /><br />

docs/api/zh/lights/shadows/LightShadow.html

@@ -68,11 +68,11 @@
 		<p>
 			将此值设置为大于1的值将模糊阴影的边缘。<br />
 
-
-			较高的值会在阴影中产生不必要的条带效果 - 更大的[page:.mapSize mapSize]将允许在这些效果变得可见之前使用更高的值。<br /><br />
-
+			较高的值会在阴影中产生不必要的条带效果 - 更大的[page:.mapSize mapSize]将允许在这些效果变得可见之前使用更高的值。<br />
+			If [page:WebGLRenderer.shadowMap.type] is set to [page:Renderer PCFSoftShadowMap], it is recommended to
+			leave radius at 1 and increase softness by decreasing [page:.mapSize mapSize] instead.<br /><br />
+			
 			请注意，如果[page：WebGLRenderer.shadowMap.type]设置为[page:Renderer BasicShadowMap]，将会无效。
-
 		</p>
 
 

docs/api/zh/lights/shadows/SpotLightShadow.html

@@ -58,7 +58,7 @@ scene.add( helper );
 
 
 		<h2>构造函数</h2>
-	        	构造函数创建一个 [param:PerspectiveCamera PerspectiveCamera] 来管理阴影的世界视图
+		构造函数创建一个 [param:PerspectiveCamera PerspectiveCamera] 来管理阴影的世界视图
 		<h2>属性</h2>
 		有关常用属性，请参阅基础LightShadow类。
 	 <h3>[property:Camera camera]</h3>

docs/api/zh/loaders/AnimationLoader.html

@@ -68,7 +68,7 @@
 		[page:Function onProgress] —  将在加载过程中进行调用。参数为XMLHttpRequest实例，实例包含[page:Integer total]和[page:Integer loaded]字节。<br />
 		[page:Function onError] — 在加载错误时被调用。<br /><br />
 
-            从URL中进行加载并将动画传递给onLoad。
+			从URL中进行加载并将动画传递给onLoad。
 		</p>
 
 		<h3>[method:Array parse]( [param:JSON json] )</h3>

docs/api/zh/loaders/AudioLoader.html

@@ -86,7 +86,7 @@
 		[page:Function onError] — 在加载错误时被调用。<br />
 		</p>
 		<p>
-            从URL中进行加载并将已经加载的[page:String AudioBuffer]传递给onLoad。
+			从URL中进行加载并将已经加载的[page:String AudioBuffer]传递给onLoad。
 		</p>
 
 		<h2>源</h2>

docs/api/zh/loaders/BufferGeometryLoader.html

@@ -74,7 +74,7 @@
 		[page:Function onError] —在加载错误时被调用。<br />
 		</p>
 		<p>
-            从URL中进行加载，并将已经以解析的响应内容传递给onLoad。
+			从URL中进行加载，并将已经以解析的响应内容传递给onLoad。
 		</p>
 
 		<h3>[method:BufferGeometry parse]( [param:Object json] )</h3>

docs/api/zh/loaders/Cache.html

@@ -11,7 +11,7 @@
 		<h1>[name]</h1>
 
 		<p class="desc">
-            一个简单的缓存系统，内部使用[page:FileLoader]。
+			一个简单的缓存系统，内部使用[page:FileLoader]。
 		</p>
 
 		<h2>例子</h2>
@@ -25,7 +25,7 @@
 		<h2>Usage</h2>
 
 		<p>
-            要在所有使用[page:FileLoader]的加载器上启用缓存， 需设置</p>
+			要在所有使用[page:FileLoader]的加载器上启用缓存， 需设置</p>
 		<code>
 THREE.Cache.enabled = true.
 		</code>
@@ -47,7 +47,7 @@ THREE.Cache.enabled = true.
 		[page:String key] — 通过引用缓存文件的[page:String key]。<br />
 		[page:Object file] — 所被缓存的文件<br /><br />
 
-           使用key为引用文件增加一个缓存入口。如果该key已持有一个文件，则会被覆盖。
+			使用key为引用文件增加一个缓存入口。如果该key已持有一个文件，则会被覆盖。
 		</p>
 
 		<h3>[method:null get]( [param:String key] )</h3>

docs/api/zh/loaders/CompressedTextureLoader.html

@@ -13,8 +13,8 @@
 		<h1>[name]</h1>
 
 		<p class="desc">
-            基于块的纹理加载器 (dds, pvr, ...)的抽象类。
-		内部使用[page:FileLoader]来加载文件。
+			基于块的纹理加载器 (dds, pvr, ...)的抽象类。
+			内部使用[page:FileLoader]来加载文件。
 		</p>
 
 		<h2>例子</h2>
@@ -50,7 +50,7 @@
 		[page:Function onError] — 在加载错误时被调用。<br />
 		</p>
 		<p>
-            从URL中进行加载，并将被加载的纹理传递给onLoad。
+			从URL中进行加载，并将被加载的纹理传递给onLoad。
 		</p>
 
 		<h2>源</h2>

docs/api/zh/loaders/CubeTextureLoader.html

@@ -62,16 +62,16 @@ scene.background = new THREE.CubeTextureLoader()
 		[page:String urls] — 数组长度为6的图像数组，数组内容为URL，每一个URL用于CubeTexture的每一侧。
 		这些URL将被指定顺序: pos-x, neg-x, pos-y, neg-y, pos-z, neg-z.
 		数组内容也可以为 [link:https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs Data URIs].<br />
-            请注意，一般来说，在立方体贴图坐标系中，当查找positive-z轴时，positive-x表示右侧
-             - 换句话说，此坐标系使用左手坐标系。
+			请注意，一般来说，在立方体贴图坐标系中，当查找positive-z轴时，positive-x表示右侧
+			 - 换句话说，此坐标系使用左手坐标系。
 		由于three.js使用右手坐标系， 环境贴图将在three.js进行pos-x和neg-x进行交互.<br />
 		[page:Function onLoad] —  加载完成时将调用。回调参数是已被加载的[page:Texture texture].<br />
 		[page:Function onProgress] — 将在加载过程中进行调用。参数为XMLHttpRequest实例，
-            其中包含 [page:Integer total] 和 [page:Integer loaded] 字节。<br />
+			其中包含 [page:Integer total] 和 [page:Integer loaded] 字节。<br />
 		[page:Function onError] — 在加载错误时被调用。<br />
 		</p>
 		<p>
-            从URL中进行加载，并将被加载的[page:Texture texture]传递给onLoad。
+			从URL中进行加载，并将被加载的[page:Texture texture]传递给onLoad。
 		</p>
 
 		<h2>源</h2>

docs/api/zh/loaders/DataTextureLoader.html

@@ -13,7 +13,7 @@
 		<h1>[name]</h1>
 
 		<p class="desc">
-            用于加载二进制文件格式的(rgbe, hdr, ...)的抽象类。
+			用于加载二进制文件格式的(rgbe, hdr, ...)的抽象类。
 		内部使用[page:FileLoader]来加载文件， 和创建一个新的
 		[page:DataTexture].
 		</p>
@@ -50,7 +50,7 @@
 		[page:Function onError] —在加载错误时被调用。<br />
 		</p>
 		<p>
-            从URL中进行加载，并将被加载的纹理传递给onLoad。
+			从URL中进行加载，并将被加载的纹理传递给onLoad。
 		</p>
 
 		<h2>源</h2>

docs/api/zh/loaders/FileLoader.html

@@ -13,8 +13,8 @@
 		<h1>[name]</h1>
 
 		<p class="desc">
-            使用XMLHttpRequest来加载资源的低级类，并由大多数加载器内部使用。
-            它也可以直接用于加载任何没有对应加载器的文件类型。
+			使用XMLHttpRequest来加载资源的低级类，并由大多数加载器内部使用。
+			它也可以直接用于加载任何没有对应加载器的文件类型。
 		</p>
 
 		<h2>例子</h2>
@@ -50,9 +50,9 @@
 
 		<p>
 			<em>注意:</em>
-            必须启用缓存
+			必须启用缓存
 			<code>THREE.Cache.enabled = true;</code>
-            这是一个全局属性，只需要设置一次，供内部使用FileLoader的所有加载器使用。
+			这是一个全局属性，只需要设置一次，供内部使用FileLoader的所有加载器使用。
 			[page:Cache Cache] 是​​一个缓存模块，用于保存通过此加载器发出的每个请求的响应，因此每个文件都会被请求一次。
 		</p>
 
@@ -82,8 +82,8 @@
 
 		<h3>[property:String withCredentials]</h3>
 		<p>
-            XMLHttpRequest是否使用证书。 请参考 [page:.setWithCredentials].
-            默认为 *undefined*.
+			XMLHttpRequest是否使用证书。 请参考 [page:.setWithCredentials].
+			默认为 *undefined*.
 		</p>
 
 		<h2>方法</h2>
@@ -95,16 +95,16 @@
 				[link:https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs Data URI].<br />
 			[page:Function onLoad] (可选) — 加载完成时将调用。回调参数将是加载的响应。<br />
 			[page:Function onProgress] (可选) — 将在加载过程中进行调用。参数将是XMLHttpRequest实例，
-            其中包含 [page:Integer total] 和 [page:Integer loaded] 字节<br />
+			其中包含 [page:Integer total] 和 [page:Integer loaded] 字节<br />
 			[page:Function onError] (可选) — 在加载错误时被调用。<br /><br />
 
-            加载URL并将响应传递给onLoad函数。
+			加载URL并将响应传递给onLoad函数。
 		</p>
 
 		<h3>[method:FileLoader setMimeType]( [param:String mimeType] )</h3>
 		<p>
-            设置正在加载的文件预期类型 [link:https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types mimeType]
-            。请注意，在许多情况下，这将自动确定，因此默认情况下它是 *undefined* 。
+			设置正在加载的文件预期类型 [link:https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types mimeType]
+			。请注意，在许多情况下，这将自动确定，因此默认情况下它是 *undefined* 。
 		</p>
 
 		<h3>[method:FileLoader setRequestHeader]( [param:object requestHeader] )</h3>
@@ -126,8 +126,8 @@
 
 		<h3>[method:FileLoader setWithCredentials]( [param:Boolean value] )</h3>
 		<p>
-            XMLHttpRequest是否使用cookie、授权头或TLS客户端证书等凭据。 请参考 [link:https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials XMLHttpRequest.withCredentials].<br />
-            请注意，当您在本地或从同一域加载文件，则该方法无效。
+			XMLHttpRequest是否使用cookie、授权头或TLS客户端证书等凭据。 请参考 [link:https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials XMLHttpRequest.withCredentials].<br />
+			请注意，当您在本地或从同一域加载文件，则该方法无效。
 		</p>
 
 

docs/api/zh/loaders/FontLoader.html

@@ -72,7 +72,7 @@
 		[page:Function onProgress] — 将在加载过程中进行调用。参数为XMLHttpRequest实例，实例包含[page:Integer total]和[page:Integer loaded]字节。<br />
 		[page:Function onError] — 在加载错误时被调用。<br /><br />
 
-            从URL中进行加载，并将被加载的[page:Texture texture]传递给onLoad。
+			从URL中进行加载，并将被加载的[page:Texture texture]传递给onLoad。
 		</p>
 
 		<h3>[method:Font parse]( [param:Object json] )</h3>

docs/api/zh/loaders/ImageBitmapLoader.html

@@ -14,7 +14,7 @@
 
 		<p class="desc">
 			一个把[page:Image]加载为[link:https://developer.mozilla.org/de/docs/Web/API/ImageBitmap ImageBitmap]的加载器。
-            ImageBitmap提供了一种异步且有效的资源的途径，用于在WebGL中渲染的纹理。<br/>
+			ImageBitmap提供了一种异步且有效的资源的途径，用于在WebGL中渲染的纹理。<br/>
 			不像[page:FileLoader], [name]无需避免对同一的URL进行多次请求。
 		</p>
 
@@ -75,7 +75,7 @@
 
 		<h3>[property:String options]</h3>
 		<p>一个可选对象，用来设置内部使用的[link:https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/createImageBitmap createImageBitmap]工厂方法，
-            默认为*undefined*.</p>
+			默认为*undefined*.</p>
 
 		<h2>方法</h2>
 		<p>共有方法请参见其基类[page:Loader]。</p>
@@ -89,7 +89,7 @@
 		[page:Function onError] —  在加载错误时被调用。<br />
 		</p>
 		<p>
-            从URL中进行加载，并返回将包含数据的[page:ImageBitmap image]对象。
+			从URL中进行加载，并返回将包含数据的[page:ImageBitmap image]对象。
 		</p>
 
 		<h3>[method:ImageBitmapLoader setOptions]( [param:Object options] )</h3>

docs/api/zh/loaders/ImageLoader.html

@@ -81,7 +81,7 @@
 		[page:Function onError] — 在加载错误时被调用。<br />
 		</p>
 		<p>
-            从URL中进行加载，并返回将包含数据的[page:Image image]对象。
+			从URL中进行加载，并返回将包含数据的[page:Image image]对象。
 		</p>
 
 		<h2>源</h2>

docs/api/zh/loaders/LoaderUtils.html

@@ -19,7 +19,7 @@
 		[page:TypedArray array] — 作为类型化数组的字节流
 		</p>
 		<p>
-            该函数将字节流作为输入并返回字符串作为表示。
+			该函数将字节流作为输入并返回字符串作为表示。
 		</p>
 
 		<h3>[method:String extractUrlBase]( [param:string url] )</h3>

docs/api/zh/loaders/MaterialLoader.html

@@ -73,7 +73,7 @@
 		[page:Function onProgress] — 将在加载过程中进行调用，参数为进度事件。<br />
 		[page:Function onError] — 在加载错误时被调用。<br /><br />
 
-            从URL中进行加载，并返回将包含数据的[page:Material]对象。
+			从URL中进行加载，并返回将包含数据的[page:Material]对象。
 		</p>
 
 		<h3>[method:Material parse]( [param:Object json] )</h3>

docs/api/zh/loaders/ObjectLoader.html

@@ -83,7 +83,7 @@
 		[page:Function onError] — 在加载错误时被调用。<br />
 		</p>
 		<p>
-            从URL中进行加载，并将被解析的响应内容传递给onLoad。
+			从URL中进行加载，并将被解析的响应内容传递给onLoad。
 		</p>
 
 
@@ -92,7 +92,7 @@
 		[page:Object json] — 必选参数，需要被解析的JSON源。<br /><br />
 		[page:Function onLoad] — 当解析完成时被调用，其中参数被解析为[page:Object3D object].<br /><br />
 
-            解析一个<em>JSON</em>结构，并返回一个threejs对象.
+			解析一个<em>JSON</em>结构，并返回一个threejs对象.
 		内部使用[page:.load]进行加载, 但也可以直接用于解析先前加载的JSON结构。
 		</p>
 
@@ -100,7 +100,7 @@
 		<p>
 		[page:Object json] — 必选参数，需要被解析的JSON源。<br /><br />
 
-            此函数以JSON结构，用[page:.parse]去解析[page:Geometry geometries]或[page:BufferGeometry buffer geometries]。
+			此函数以JSON结构，用[page:.parse]去解析[page:Geometry geometries]或[page:BufferGeometry buffer geometries]。
 		</p>
 
 		<h3>[method:Object3D parseMaterials]( [param:Object json] )</h3>
@@ -115,26 +115,26 @@
 		[page:Object json] —  必选参数，需要被解析的JSON源。<br /><br />
 
 		此函数通过[page:.parse]来使用[page:AnimationClip.parse]， 以解析JSON结构中任意动画。
-        </p>
+		</p>
 
 		<h3>[method:Object3D parseImages]( [param:Object json] )</h3>
 		<p>
 		[page:Object json] —  必选参数，需要被解析的JSON源。<br /><br />
 
-            此函数通过[page:.parse]来使用[page:ImageLoader]， 以解析JSON结构中任意图片。
+			此函数通过[page:.parse]来使用[page:ImageLoader]， 以解析JSON结构中任意图片。
 		</p>
 
 		<h3>[method:Object3D parseTextures]( [param:Object json] )</h3>
 		<p>
 		[page:Object json] —  必选参数，需要被解析的JSON源。<br /><br />
-            此函数通过[page:.parse]来解析JSON结构中任意纹理。
+			此函数通过[page:.parse]来解析JSON结构中任意纹理。
 		</p>
 
 		<h3>[method:Object3D parseObject]( [param:Object json] )</h3>
 		<p>
 		[page:Object json] —  必选参数，需要被解析的JSON源。<br /><br />
 
-            此函数通过[page:.parse]来解析JSON结构中任意对象。
+			此函数通过[page:.parse]来解析JSON结构中任意对象。
 		对象可以为如下类型：
 
 		<ul>

docs/api/zh/loaders/TextureLoader.html

@@ -56,8 +56,8 @@
 			}
 		);
 		</code>
-        请注意three.js r84遗弃了TextureLoader进度事件。对于支持进度事件的TextureLoader ，
-        请参考[link:https://github.com/mrdoob/three.js/issues/10439#issuecomment-293260145 this thread]。
+		请注意three.js r84遗弃了TextureLoader进度事件。对于支持进度事件的TextureLoader ，
+		请参考[link:https://github.com/mrdoob/three.js/issues/10439#issuecomment-293260145 this thread]。
 
 		<h2>构造函数</h2>
 
@@ -82,8 +82,8 @@
 		[page:Function onProgress] — 将在加载过程中进行调用。参数为XMLHttpRequest实例，实例包含[page:Integer total]和[page:Integer loaded]字节。<br />
 		[page:Function onError] — 在加载错误时被调用。<br /><br />
 
-            从给定的URL开始加载并将完全加载的[page:Texture texture]传递给onLoad。该方法还返回一个新的纹理对象，该纹理对象可以直接用于材质创建。
-            如果采用此方法，一旦相应的加载过程完成，纹理可能会在场景中出现。
+			从给定的URL开始加载并将完全加载的[page:Texture texture]传递给onLoad。该方法还返回一个新的纹理对象，该纹理对象可以直接用于材质创建。
+			如果采用此方法，一旦相应的加载过程完成，纹理可能会在场景中出现。
 		</p>
 
 		<h2>源</h2>

docs/api/zh/loaders/managers/DefaultLoadingManager.html

@@ -13,7 +13,7 @@
 		<p class="desc">[page:LoadingManager LoadingManager]是一个全局实例, 当其他加载器没有指定加载管理器时，它将被其他大多数的加载器设为默认的加载管理器。<br /><br />
 
 
-            LoadingManager对于大多数加载器来说已经足够了，但有时您可能需要单独设置加载管理器，例如纹理、模型加载器。
+			LoadingManager对于大多数加载器来说已经足够了，但有时您可能需要单独设置加载管理器，例如纹理、模型加载器。
 		</p>
 
 		<h2>例子</h2>
@@ -23,7 +23,7 @@
 			[page:LoadingManager.onProgress onProgress], [page:LoadingManager.onStart onError] 这些方法。
 			当你的加载器使用默认加载管理器时，这些方法都将被应用到加载器上。<br /><br />
 
-            请注意，个人的加载器的不应具有类似上面类似的命名函数，以避免混淆。因为这些函数时用于显示有关加载总体状态的信息，而不是处理已加载的数据。
+			请注意，个人的加载器的不应具有类似上面类似的命名函数，以避免混淆。因为这些函数时用于显示有关加载总体状态的信息，而不是处理已加载的数据。
 		</p>
 		<code>
 THREE.DefaultLoadingManager.onStart = function ( url, itemsLoaded, itemsTotal ) {

docs/api/zh/loaders/managers/LoadingManager.html

@@ -12,10 +12,10 @@
 
 		<p class="desc">
 
-            其功能时处理并跟踪已加载和待处理的数据。如果未手动设置加强管理器，则会为加载器创建和使用默认全局实例加载器管理器
-            - 请参阅 [page:DefaultLoadingManager].<br /><br />
+			其功能时处理并跟踪已加载和待处理的数据。如果未手动设置加强管理器，则会为加载器创建和使用默认全局实例加载器管理器
+			- 请参阅 [page:DefaultLoadingManager].<br /><br />
 
-            一般来说，默认的加载管理器已足够使用了，但有时候也需要设置单独的加载器 - 例如，如果你想为对象和纹理显示单独的加载条。
+			一般来说，默认的加载管理器已足够使用了，但有时候也需要设置单独的加载器 - 例如，如果你想为对象和纹理显示单独的加载条。
 
 		</p>
 
@@ -71,8 +71,8 @@
 
 		<p>
 
-            除了观察进度流程之外，还可以使用LoadingManager在加载期间覆写资源URL。当某资源来自拖拽事件、
-            WebSockets、WebRTC或其他API时，此方法可以有所帮助。下面显示了如何使用Blob URL加载内存模型的示例。
+			除了观察进度流程之外，还可以使用LoadingManager在加载期间覆写资源URL。当某资源来自拖拽事件、
+			WebSockets、WebRTC或其他API时，此方法可以有所帮助。下面显示了如何使用Blob URL加载内存模型的示例。
 		</p>
 
 		<code>
@@ -131,27 +131,27 @@
 
 		<h3>[property:Function onLoad]</h3>
 		<p>
-            所有的项加载完成后将调用此函数。默认情况下，此方法时未定义的，除非在构造函数中进行传递。
+			所有的项加载完成后将调用此函数。默认情况下，此方法时未定义的，除非在构造函数中进行传递。
 		</p>
 
 		<h3>[property:Function onProgress]</h3>
 		<p>
-		    此方法加载每一个项，加载完成时进行调用。
-            有如下参数:<br />
+			此方法加载每一个项，加载完成时进行调用。
+			有如下参数:<br />
 		[page:String url] — 被加载的项的url。<br />
 		[page:Integer itemsLoaded] — 目前已加载项的个数。<br />
 		[page:Iteger itemsTotal] — 总共所需要加载项的个数。<br /><br />
 
-            默认情况下，此方法时未定义的，除非在构造函数中进行传递。
+			默认情况下，此方法时未定义的，除非在构造函数中进行传递。
 		</p>
 
 		<h3>[property:Function onError]</h3>
 		<p>
-            此方法将在任意项加载错误时，进行调用。
-            有如下参数:<br />
+			此方法将在任意项加载错误时，进行调用。
+			有如下参数:<br />
 			[page:String url] — 所加载出错误的项的url<br /><br />
 
-            默认情况下，此方法时未定义的，除非在构造函数中进行传递。
+			默认情况下，此方法时未定义的，除非在构造函数中进行传递。
 		</p>
 
 
@@ -170,18 +170,18 @@
 manager.addHandler( /\.tga$/i, new TGALoader() );
 		</code>
 
-		<h3>[method:LoadingManager removeHandler]( [param:Object regex] )</h3>
+		<h3>[method:null getHandler]( [param:String file] )</h3>
 		<p>
-		[page:Object regex] — A regular expression.
+		[page:String file] — The file path.
 		<p>
-		Removes the loader for the given regular expression.
+		Can be used to retrieve the registered loader for the given file path.
 		</p>
 
-		<h3>[method:null getHandler]( [param:String file] )</h3>
+		<h3>[method:LoadingManager removeHandler]( [param:Object regex] )</h3>
 		<p>
-		[page:String file] — The file path.
+		[page:Object regex] — A regular expression.
 		<p>
-		Can be used to retrieve the registered loader for the given file path.
+		Removes the loader for the given regular expression.
 		</p>
 
 		<h3>[method:String resolveURL]( [param:String url] )</h3>
@@ -220,7 +220,6 @@ manager.addHandler( /\.tga$/i, new TGALoader() );
 		任何使用管理器的加载器都会调用此方法， 当加载器需要加载URL结束时。
 		</p>
 
-
 		<h3>[method:null itemError]( [param:String url] )</h3>
 		<p>
 		[page:String url] — 所要加载的url<br /><br />

docs/api/zh/materials/Material.html

@@ -1,19 +1,19 @@
 <!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"/>
+	<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>
 
 <p class="desc">材质的抽象基类。<br/><br/>
-    材质描述了对象[page:Object objects]的外观。它们的定义方式与渲染器无关，
-    因此，如果您决定使用不同的渲染器，不必重写材质。<br/><br/>
-    所有其他材质类型都继承了以下属性和方法（尽管它们可能具有不同的默认值）。
+	材质描述了对象[page:Object objects]的外观。它们的定义方式与渲染器无关，
+	因此，如果您决定使用不同的渲染器，不必重写材质。<br/><br/>
+	所有其他材质类型都继承了以下属性和方法（尽管它们可能具有不同的默认值）。
 </p>
 
 <h2>构造函数(Constructor)</h2>
@@ -31,8 +31,8 @@
 
 <h3>[property:Integer blendDst]</h3>
 <p> 混合目标。默认值为[page:CustomBlendingEquation OneMinusSrcAlphaFactor]。
-    目标因子所有可能的取值请参阅[page:CustomBlendingEquation constants]。
-    必须将材质的[page:Constant blending]设置为[page:Materials CustomBlending]才能生效。<br/>
+	目标因子所有可能的取值请参阅[page:CustomBlendingEquation constants]。
+	必须将材质的[page:Constant blending]设置为[page:Materials CustomBlending]才能生效。<br/>
 </p>
 
 <h3>[property:Integer blendDstAlpha]</h3>
@@ -40,8 +40,8 @@
 
 <h3>[property:Integer blendEquation]</h3>
 <p> 使用混合时所采用的混合方程式。默认值为[page:CustomBlendingEquation AddEquation]。
-    混合方程式所有可能的取值请参阅[page:CustomBlendingEquation constants]。
-    必须将材质的[page:Constant blending]设置为[page:Materials CustomBlending]才能生效。<br/>
+	混合方程式所有可能的取值请参阅[page:CustomBlendingEquation constants]。
+	必须将材质的[page:Constant blending]设置为[page:Materials CustomBlending]才能生效。<br/>
 </p>
 
 <h3>[property:Integer blendEquationAlpha]</h3>
@@ -49,15 +49,15 @@
 
 <h3>[property:Blending blending]</h3>
 <p> 在使用此材质显示对象时要使用何种混合。<br/>
-    必须将其设置为[page:Materials CustomBlending]才能使用自定义[page:Constant blendSrc], [page:Constant blendDst] 或者 [page:Constant
-    blendEquation]。
-    混合模式所有可能的取值请参阅[page:Materials constants]。默认值为[page:Materials NormalBlending]。
+	必须将其设置为[page:Materials CustomBlending]才能使用自定义[page:Constant blendSrc], [page:Constant blendDst] 或者 [page:Constant
+	blendEquation]。
+	混合模式所有可能的取值请参阅[page:Materials constants]。默认值为[page:Materials NormalBlending]。
 </p>
 
 <h3>[property:Integer blendSrc]</h3>
 <p> 混合源。默认值为[page:CustomBlendingEquation SrcAlphaFactor]。
-    源因子所有可能的取值请参阅[page:CustomBlendingEquation constants]。<br/>
-    必须将材质的[page:Constant blending]设置为[page:Materials CustomBlending]才能生效。
+	源因子所有可能的取值请参阅[page:CustomBlendingEquation constants]。<br/>
+	必须将材质的[page:Constant blending]设置为[page:Materials CustomBlending]才能生效。
 </p>
 
 <h3>[property:Integer blendSrcAlpha]</h3>
@@ -69,9 +69,9 @@
 
 <h3>[property:Array clippingPlanes]</h3>
 <p>
-    用户定义的剪裁平面，在世界空间中指定为THREE.Plane对象。这些平面适用于所有使用此材质的对象。空间中与平面的有符号距离为负的点被剪裁（未渲染）。
-    这需要[page:WebGLRenderer.localClippingEnabled]为*true*。
-    示例请参阅[example:webgl_clipping_intersection WebGL / clipping /intersection]。默认值为 *null*。
+	用户定义的剪裁平面，在世界空间中指定为THREE.Plane对象。这些平面适用于所有使用此材质的对象。空间中与平面的有符号距离为负的点被剪裁（未渲染）。
+	这需要[page:WebGLRenderer.localClippingEnabled]为*true*。
+	示例请参阅[example:webgl_clipping_intersection WebGL / clipping /intersection]。默认值为 *null*。
 </p>
 
 <h3>[property:Boolean clipShadows]</h3>
@@ -80,17 +80,17 @@
 
 <h3>[property:Boolean colorWrite]</h3>
 <p> 是否渲染材质的颜色。
-    这可以与网格的[page:Integer renderOrder]属性结合使用，以创建遮挡其他对象的不可见对象。默认值为*true*。
+	这可以与网格的[page:Integer renderOrder]属性结合使用，以创建遮挡其他对象的不可见对象。默认值为*true*。
 </p>
 
 <h3>[property:Object defines]</h3>
 <p> 注入shader的自定义对象。 以键值对形式的对象传递，{ MY_CUSTOM_DEFINE: '' , PI2: Math.PI * 2 }。
-    这些键值对在顶点和片元着色器中定义。默认值为*undefined*。
+	这些键值对在顶点和片元着色器中定义。默认值为*undefined*。
 </p>
 
 <h3>[property:Integer depthFunc]</h3>
 <p> 使用何种深度函数。默认为[page:Materials LessEqualDepth]。
-    深度模式所有可能的取值请查阅[page:Materials constants]。
+	深度模式所有可能的取值请查阅[page:Materials constants]。
 </p>
 
 <h3>[property:Boolean depthTest]</h3>
@@ -99,7 +99,7 @@
 
 <h3>[property:Boolean depthWrite]</h3>
 <p>渲染此材质是否对深度缓冲区有任何影响。默认为*true*。<br/><br/>
-    在绘制2D叠加时，将多个事物分层在一起而不创建z-index时，禁用深度写入会很有用。
+	在绘制2D叠加时，将多个事物分层在一起而不创建z-index时，禁用深度写入会很有用。
 </p>
 
 
@@ -156,7 +156,7 @@ Which stencil operation to perform when the comparison function returns true and
 <h3>[property:Boolean isMaterial]</h3>
 <p>用于检查此类或派生类是否为材质。默认值为 *true*。<br/><br/>
 
-    因为其通常用在内部优化，所以不应该更改该属性值。
+	因为其通常用在内部优化，所以不应该更改该属性值。
 </p>
 
 <h3>[property:String name]</h3>
@@ -164,13 +164,13 @@ Which stencil operation to perform when the comparison function returns true and
 
 <h3>[property:Boolean needsUpdate]</h3>
 <p>指定需要重新编译材质。<br/>
-    实例化新材质时，此属性自动设置为true。
+	实例化新材质时，此属性自动设置为true。
 </p>
 
 <h3>[property:Float opacity]</h3>
 <p> 在0.0 - 1.0的范围内的浮点数，表明材质的透明度。值*0.0*表示完全透明，*1.0*表示完全不透明。<br/>
-    如果材质的[page:Boolean transparent]属性未设置为*true*，则材质将保持完全不透明，此值仅影响其颜色。
-    默认值为*1.0*。 <br/>
+	如果材质的[page:Boolean transparent]属性未设置为*true*，则材质将保持完全不透明，此值仅影响其颜色。
+	默认值为*1.0*。 <br/>
 
 </p>
 
@@ -190,7 +190,7 @@ Which stencil operation to perform when the comparison function returns true and
 
 <h3>[property:Boolean premultipliedAlpha]</h3>
 <p> 是否预乘alpha（透明度）值。有关差异的示例，请参阅[Example:webgl_materials_transparency WebGL / Materials / Transparency]。
-    默认值为*false*。
+	默认值为*false*。
 </p>
 
 <h3>[property:Boolean dithering]</h3>
@@ -199,31 +199,31 @@ Which stencil operation to perform when the comparison function returns true and
 
 <h3>[property:Integer shadowSide]</h3>
 <p> 定义投影的面。设置时，可以是[page:Materials THREE.FrontSide], [page:Materials THREE.BackSide], 或[page:Materials]。默认值为 *null*。
-     <br/>
-    如果为*null*， 则面投射阴影确定如下： <br/>
+	 <br/>
+	如果为*null*， 则面投射阴影确定如下： <br/>
 
 <table>
-    <thead>
-    <tr>
-        <th>[page:Material.side]</th>
-        <th>Side casting shadows</th>
-    </tr>
-    </thead>
-    <tbody>
-
-    <tr>
-        <td>THREE.FrontSide</td>
-        <td>背面</td>
-    </tr>
-    <tr>
-        <td>THREE.BackSide</td>
-        <td>前面</td>
-    </tr>
-    <tr>
-        <td>THREE.DoubleSide</td>
-        <td>双面</td>
-    </tr>
-    </tbody>
+	<thead>
+	<tr>
+		<th>[page:Material.side]</th>
+		<th>Side casting shadows</th>
+	</tr>
+	</thead>
+	<tbody>
+
+	<tr>
+		<td>THREE.FrontSide</td>
+		<td>背面</td>
+	</tr>
+	<tr>
+		<td>THREE.BackSide</td>
+		<td>前面</td>
+	</tr>
+	<tr>
+		<td>THREE.DoubleSide</td>
+		<td>双面</td>
+	</tr>
+	</tbody>
 </table>
 
 
@@ -231,7 +231,7 @@ Which stencil operation to perform when the comparison function returns true and
 
 <h3>[property:Integer side]</h3>
 <p> 定义将要渲染哪一面 - 正面，背面或两者。
-    默认为[page:Materials THREE.FrontSide]。其他选项有[page:Materials THREE.BackSide]和[page:Materials THREE.DoubleSide]。
+	默认为[page:Materials THREE.FrontSide]。其他选项有[page:Materials THREE.BackSide]和[page:Materials THREE.DoubleSide]。
 </p>
 
 <h3>[property:Boolean toneMapped]</h3>
@@ -241,10 +241,10 @@ Defines whether this material is tone mapped according to the renderer's [page:W
 
 <h3>[property:Boolean transparent]</h3>
 <p>
-    定义此材质是否透明。这对渲染有影响，因为透明对象需要特殊处理，并在非透明对象之后渲染。
-    <br/>
-    设置为true时，通过设置材质的[page:Float opacity]属性来控制材质透明的程度。<br/>
-    默认值为*false*。
+	定义此材质是否透明。这对渲染有影响，因为透明对象需要特殊处理，并在非透明对象之后渲染。
+	<br/>
+	设置为true时，通过设置材质的[page:Float opacity]属性来控制材质透明的程度。<br/>
+	默认值为*false*。
 </p>
 
 <h3>[property:String type]</h3>
@@ -257,13 +257,13 @@ Defines whether this material is tone mapped according to the renderer's [page:W
 
 <h3>[property:Integer vertexColors]</h3>
 <p> 是否使用顶点着色。默认值为[page:Materials THREE.NoColors]。
-    其他选项有[page:Materials THREE.VertexColors] 和 [page:Materials THREE.FaceColors]。
+	其他选项有[page:Materials THREE.VertexColors] 和 [page:Materials THREE.FaceColors]。
 </p>
 
 <h3>[property:Boolean vertexTangents]</h3>
 <p>	Defines whether precomputed vertex tangents, which must be provided in a vec4 "tangent" attribute,
-    are used. When disabled, tangents are derived automatically. Using precomputed tangents will give
-    more accurate normal map details in some cases, such as with mirrored UVs. Default is false.
+	are used. When disabled, tangents are derived automatically. Using precomputed tangents will give
+	more accurate normal map details in some cases, such as with mirrored UVs. Default is false.
 </p>
 
 <h3>[property:Boolean visible]</h3>
@@ -297,13 +297,13 @@ Unlike properties, the callback is not supported by [page:Material.clone .clone]
 
 <h3>[method:null setValues]( [param:object values] )</h3>
 <p> values -- 具有参数的容器。
-    根据*values*设置属性。<br/>
+	根据*values*设置属性。<br/>
 </p>
 
 <h3>[method:Object toJSON]( [param:object meta] )</h3>
 <p>
-    meta -- 包含有元数据的对象，例如该对象的纹理或图片。
-    将material对象转换为 three.js [link:https://github.com/mrdoob/three.js/wiki/JSON-Object-Scene-format-4 JSON Object/Scene format]（three.js JSON 物体/场景格式）。
+	meta -- 包含有元数据的对象，例如该对象的纹理或图片。
+	将material对象转换为 three.js [link:https://github.com/mrdoob/three.js/wiki/JSON-Object-Scene-format-4 JSON Object/Scene format]（three.js JSON 物体/场景格式）。
 </p>
 
 <h2>源码(Source)</h2>

docs/api/zh/materials/MeshBasicMaterial.html

@@ -47,9 +47,13 @@
 		<p>共有属性请参见其基类[page:Material]。</p>
 
 		<h3>[property:Texture alphaMap]</h3>
-		<p> alpha贴图是一种灰度纹理，用于控制整个表面的不透明度（黑色：完全透明;白色：完全不透明）。默认值为null。<br /><br />
-			仅使用纹理的颜色，忽略alpha通道（如果存在）。对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
-			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。Luminance-only以及luminance/alpha纹理也仍然有效。
+		<p>alpha贴图是一张灰度纹理，用于控制整个表面的不透明度。（黑色：完全透明；白色：完全不透明）。
+			默认值为null。<br /><br />
+
+			仅使用纹理的颜色，忽略alpha通道（如果存在）。
+			对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
+			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。
+			Luminance-only以及luminance/alpha纹理也仍然有效。
 		</p>
 
 		<h3>[property:Texture aoMap]</h3>

docs/api/zh/materials/MeshDepthMaterial.html

@@ -43,9 +43,13 @@
 		<p>共有属性请参见其基类[page:Material]。</p>
 
 		<h3>[property:Texture alphaMap]</h3>
-		<p>alpha贴图是一种灰度纹理，用于控制整个表面的不透明度（黑色：完全透明;白色：完全不透明）。默认值为null。<br /><br />
-			仅使用纹理的颜色，忽略alpha通道（如果存在）。对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
-			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。Luminance-only以及luminance/alpha纹理也仍然有效。
+		<p>alpha贴图是一张灰度纹理，用于控制整个表面的不透明度。（黑色：完全透明；白色：完全不透明）。
+			默认值为null。<br /><br />
+
+			仅使用纹理的颜色，忽略alpha通道（如果存在）。
+			对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
+			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。
+			Luminance-only以及luminance/alpha纹理也仍然有效。
 		</p>
 
 		<h3>[property:Constant depthPacking]</h3>

docs/api/zh/materials/MeshDistanceMaterial.html

@@ -13,13 +13,13 @@
 		<h1>[name]</h1>
 
 		<p class="desc">
-			[name] is internally used for implementing shadow mapping with [page:PointLight]s.<br/><br/>
+			[name] 在内部用于使用[page:PointLight]来实现阴影映射。
 
-			Can also be used to customize the shadow casting of an object by assigning an instance of [name] to [page:Object3D.customDistanceMaterial].
-			The following examples demonstrates this approach in order to ensure transparent parts of objects do no cast shadows.
+			也可以用于通过将[name]实例指定给[page:Object3D.customDistanceMaterial]，来自定义物体阴影投射。
+			下列示例演示了这一方法，以确保物体的透明部分不投射阴影。
 		</p>
 
-		<h2>Example</h2>
+		<h2>示例</h2>
 
 		[example:webgl_shadowmap_pointlight WebGL / shadowmap / pointlight]
 
@@ -50,9 +50,13 @@
 		<p>共有属性请参见其基类[page:Material]。</p>
 
 		<h3>[property:Texture alphaMap]</h3>
-		<p>alpha贴图是一种灰度纹理，用于控制整个表面的不透明度（黑色：完全透明;白色：完全不透明）。默认值为null。<br /><br />
-			仅使用纹理的颜色，忽略alpha通道（如果存在）。对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
-			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。Luminance-only以及luminance/alpha纹理也仍然有效。
+		<p>alpha贴图是一张灰度纹理，用于控制整个表面的不透明度。（黑色：完全透明；白色：完全不透明）。
+			默认值为null。<br /><br />
+
+			仅使用纹理的颜色，忽略alpha通道（如果存在）。
+			对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
+			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。
+			Luminance-only以及luminance/alpha纹理也仍然有效。
 		</p>
 
 		<h3>[property:Texture displacementMap]</h3>
@@ -70,7 +74,7 @@
 
 		<h3>[property:Float farDistance]</h3>
 		<p>
-			TODO
+			The far value of the point light's internal shadow camera.
 		</p>
 
 		<h3>[property:Boolean fog]</h3>
@@ -90,12 +94,12 @@
 
 		<h3>[property:Float nearDistance]</h3>
 		<p>
-			TODO
+			The near value of the point light's internal shadow camera.
 		</p>
 
 		<h3>[property:Vector3 referencePosition]</h3>
 		<p>
-			TODO
+			The position of the point light in world space.
 		</p>
 
 		<h3>[property:Boolean skinning]</h3>

docs/api/zh/materials/MeshLambertMaterial.html

@@ -53,10 +53,13 @@
 		<p>共有属性请参见其基类[page:Material]。</p>
 
 		<h3>[property:Texture alphaMap]</h3>
-		<p>alpha贴图是一种灰度纹理，用于控制整个表面的不透明度（黑色：完全透明;白色：完全不透明）。默认值为null。<br /><br />
+		<p>alpha贴图是一张灰度纹理，用于控制整个表面的不透明度。（黑色：完全透明；白色：完全不透明）。
+			默认值为null。<br /><br />
 
-			仅使用纹理的颜色，忽略alpha通道（如果存在）。对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
-			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。Luminance-only以及luminance/alpha纹理也仍然有效。
+			仅使用纹理的颜色，忽略alpha通道（如果存在）。
+			对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
+			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。
+			Luminance-only以及luminance/alpha纹理也仍然有效。
 		</p>
 
 		<h3>[property:Texture aoMap]</h3>

docs/api/zh/materials/MeshMatcapMaterial.html

@@ -13,9 +13,9 @@
 		<h1>[name]</h1>
 
 		<p class="desc">
-			[name] is defined by a MatCap (or Lit Sphere) texture, which encodes the material color and shading.<br/><br/>
-			[name] does not respond to lights since the matcap image file encodes baked lighting.
-			It will cast a shadow onto an object that receives shadows (and shadow clipping works), but it will not self-shadow or receive shadows.
+			[name] 由一个材质捕捉（MatCap，或光照球（Lit Sphere））纹理所定义，其编码了材质的颜色与明暗。<br/><br/>
+			由于mapcap图像文件编码了烘焙过的光照，因此[name] 不对灯光作出反应。
+			它将会投射阴影到一个接受阴影的物体上(and shadow clipping works)，但不会产生自身阴影或是接受阴影。
 		</p>
 
 		<iframe id="scene" src="scenes/material-browser.html#MeshMatcapMaterial"></iframe>
@@ -48,9 +48,13 @@
 		<p>共有属性请参见其基类[page:Material]。</p>
 
 		<h3>[property:Texture alphaMap]</h3>
-		<p>Talpha贴图是一种灰度纹理，用于控制整个表面的不透明度（黑色：完全透明;白色：完全不透明）。默认值为null。<br /><br />
-			仅使用纹理的颜色，忽略alpha通道（如果存在）。对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
-			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。Luminance-only以及luminance/alpha纹理也仍然有效。
+		<p>alpha贴图是一张灰度纹理，用于控制整个表面的不透明度。（黑色：完全透明；白色：完全不透明）。
+			默认值为null。<br /><br />
+
+			仅使用纹理的颜色，忽略alpha通道（如果存在）。
+			对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
+			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。
+			Luminance-only以及luminance/alpha纹理也仍然有效。
 		</p>
 
 		<h3>[property:Texture bumpMap]</h3>
@@ -78,7 +82,8 @@
 		</p>
 
 		<h3>[property:Boolean isMeshMatcapMaterial]</h3>
-		<p>TODO<br /><br />
+		<p>
+			用于检查该类或其派生类是否为mesh Matcap materials。默认值为*true*。<br /><br />
 
 			因为其通常用在内部优化，所以不应该更改该属性值。
 		</p>
@@ -87,7 +92,7 @@
 		<p>颜色贴图。默认为null。纹理贴图颜色由漫反射颜色[page:.color]调节。</p>
 
 		<h3>[property:Texture matcap]</h3>
-		<p>TODO</p>
+		<p>matcap贴图，默认为null。</p>
 
 		<h3>[property:boolean morphNormals]</h3>
 		<p> 定义是否使用morphNormals。设置为true可将morphNormal属性从[page:Geometry]传递到shader。默认值为*false*。

docs/api/zh/materials/MeshPhongMaterial.html

@@ -51,9 +51,13 @@
 		<p>共有属性请参见其基类[page:Material]。</p>
 
 		<h3>[property:Texture alphaMap]</h3>
-		<p>Talpha贴图是一种灰度纹理，用于控制整个表面的不透明度（黑色：完全透明;白色：完全不透明）。默认值为null。<br /><br />
-			仅使用纹理的颜色，忽略alpha通道（如果存在）。对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
-			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。Luminance-only以及luminance/alpha纹理也仍然有效。
+		<p>alpha贴图是一张灰度纹理，用于控制整个表面的不透明度。（黑色：完全透明；白色：完全不透明）。
+			默认值为null。<br /><br />
+
+			仅使用纹理的颜色，忽略alpha通道（如果存在）。
+			对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
+			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。
+			Luminance-only以及luminance/alpha纹理也仍然有效。
 		</p>
 
 		<h3>[property:Texture aoMap]</h3>

docs/api/zh/materials/MeshStandardMaterial.html

@@ -72,9 +72,13 @@
 		<p>共有属性请参见其基类[page:Material]。</p>
 
 		<h3>[property:Texture alphaMap]</h3>
-		<p>alpha贴图是一种灰度纹理，用于控制整个表面的不透明度（黑色：完全透明;白色：完全不透明）。默认值为null。<br /><br />
-			仅使用纹理的颜色，忽略alpha通道（如果存在）。对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
-			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。Luminance-only以及luminance/alpha纹理也仍然有效。
+		<p>alpha贴图是一张灰度纹理，用于控制整个表面的不透明度。（黑色：完全透明；白色：完全不透明）。
+			默认值为null。<br /><br />
+
+			仅使用纹理的颜色，忽略alpha通道（如果存在）。
+			对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
+			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。
+			Luminance-only以及luminance/alpha纹理也仍然有效。
 		</p>
 
 		<h3>[property:Texture aoMap]</h3>

docs/api/zh/materials/PointsMaterial.html

@@ -65,6 +65,16 @@ scene.add( starField );
 		<h2>属性(Properties)</h2>
 		<p>共有属性请参见其基类[page:Material]。</p>
 
+		<h3>[property:Texture alphaMap]</h3>
+		<p>alpha贴图是一张灰度纹理，用于控制整个表面的不透明度。（黑色：完全透明；白色：完全不透明）。
+			默认值为null。<br /><br />
+
+			仅使用纹理的颜色，忽略alpha通道（如果存在）。
+			对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
+			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。
+			Luminance-only以及luminance/alpha纹理也仍然有效。
+		</p>
+
 		<h3>[property:Color color]</h3>
 		<p>材质的颜色([page:Color])，默认值为白色 (0xffffff)。</p>
 

docs/api/zh/materials/ShaderMaterial.html

@@ -319,9 +319,6 @@ this.extensions = {
 			因为其通常用在内部优化，所以不应该更改该属性值。
 		</p>
 
-
-
-
 		<h3>[property:Boolean lights]</h3>
 		<p> 材质是否受到光照的影响。默认值为 *false*。如果传递与光照相关的uniform数据到这个材质，则为true。默认是false。
 		</p>
@@ -331,7 +328,6 @@ this.extensions = {
 			由于[link:https://www.khronos.org/registry/OpenGL/specs/gl/glspec46.core.pdf OpenGL Core Profile]与大多数平台上[page:WebGLRenderer WebGL]渲染器的限制，无论如何设置该值，线宽始终为1。
 		</p>
 
-
 		<h3>[property:Boolean morphTargets]</h3>
 		<p> When set to true, morph target attributes are available in the vertex shader. Default is *false*.
 		</p>
@@ -340,7 +336,6 @@ this.extensions = {
 		<p> When set to true, morph normal attributes are available in the vertex shader. Default is *false*.
 		</p>
 
-
 		<h3>[property:WebGLProgram program]</h3>
 		<p> 与此材质相关联的编译后的shader程序，由[page:WebGLRenderer]生成。您应该不需要访问此属性。
 		</p>

docs/api/zh/materials/SpriteMaterial.html

@@ -49,6 +49,16 @@ scene.add( sprite );
 		<h2>属性(Properties)</h2>
 		<p>共有属性请参见其基类[page:Material]。</p>
 
+		<h3>[property:Texture alphaMap]</h3>
+		<p>alpha贴图是一张灰度纹理，用于控制整个表面的不透明度。（黑色：完全透明；白色：完全不透明）。
+			默认值为null。<br /><br />
+
+			仅使用纹理的颜色，忽略alpha通道（如果存在）。
+			对于RGB和RGBA纹理，[page:WebGLRenderer WebGL]渲染器在采样此纹理时将使用绿色通道，
+			因为在DXT压缩和未压缩RGB 565格式中为绿色提供了额外的精度。
+			Luminance-only以及luminance/alpha纹理也仍然有效。
+		</p>
+
 		<h3>[property:Color color]</h3>
 		<p>材质的颜色([page:Color])，默认值为白色 (0xffffff)。 [page:.map]会和 color 相乘。</p>
 

docs/api/zh/math/Box2.html

@@ -60,7 +60,7 @@
 		<h3>[method:Boolean containsBox]( [param:Box2 box] )</h3>
 		<p>
 		[page:Box2 box] - 要检查是否被包含的盒子。<br /><br />
-        如果盒子包含整个被检查盒子，则返回true。如果两者重叠，<br>
+		如果盒子包含整个被检查盒子，则返回true。如果两者重叠，<br>
 		也会返回true。
 		</p>
 

docs/api/zh/math/Color.html

@@ -296,6 +296,15 @@ var color = new THREE.Color( 1, 0, 0 );
 		注意，对于X11颜色名称，多个单词(如暗橙色)变成字符串“darkorange”(全部是小写字母)。
 		</p>
 
+		<h3>[method:Color setColorName]( [param:String style] ) </h3>
+		<p>
+		[page:String style] — color name ( from [link:https://en.wikipedia.org/wiki/X11_color_names#Color_name_chart X11 color names] ).<br /><br />
+
+		Sets this color from a color name. Faster than [page:.setStyle] method if you don't need the other CSS-style formats.<br/><br/>
+
+		For convenience, the list of names is exposed in Color.NAMES as a hash: <code>Color.NAMES.aliceblue // returns 0xF0F8FF</code>
+		</p>
+
 		<h3>[method:Color sub]( [param:Color color] ) </h3>
 		<p>
 		从该颜色的RGB分量中减去传入颜色的RGB分量。如果分量结果是负，则该分量为零。

docs/api/zh/math/Vector2.html

@@ -175,7 +175,7 @@
 		<p>
 			计算该vector和所传入[page:Vector2 v]的点积（[link:https://en.wikipedia.org/wiki/Dot_product dot product]）。
 		</p>
-        
+
 		<h3>[method:Float cross]( [param:Vector2 v] )</h3>
 		<p>
 			计算该vector和所传入[page:Vector2 v]的叉积（[link:https://en.wikipedia.org/wiki/Cross_product cross product]）。 

docs/api/zh/math/Vector3.html

@@ -121,7 +121,7 @@ var d = a.distanceTo( b );
 
 		<h3>[method:Float angleTo]( [param:Vector3 v] )</h3>
 		<p>
-		以弧度返回该向量与向量[page:Vector3 v]之间的角度。
+		以弧度返回该向量与向量[page:Vector3 v]之间的角度。 Neither this vector nor [page:Vector3 v] can be the zero vector.
 		</p>
 
 		<h3>[method:this ceil]()</h3>
@@ -320,7 +320,7 @@ var d = a.distanceTo( b );
 		</p>
 
 		<h3>[method:this projectOnVector]( [param:Vector3] )</h3>
-		<p>投影（[link:https://en.wikipedia.org/wiki/Vector_projection Projects]）该向量到另一个向量上。 </p>
+		<p>投影（[link:https://en.wikipedia.org/wiki/Vector_projection Projects]）该向量到向量[page:Vector3 v]上。[page:Vector3 v]不能是零向量。</p>
 
 		<h3>[method:this reflect]( [param:Vector3 normal] )</h3>
 		<p>

docs/api/zh/objects/SkinnedMesh.html

@@ -91,8 +91,8 @@
 		<h2>构造器</h2>
 		<h3>[name]( [param:BufferGeometry geometry], [param:Material material] )</h3>
 		<p>
-    [page:BufferGeometry geometry] —— 一个[page:BufferGeometry]实例。<br />
-    [page:Material material] —— （可选）一个[page:Material]实例，默认值是一个新的[page:MeshBasicMaterial]。
+	[page:BufferGeometry geometry] —— 一个[page:BufferGeometry]实例。<br />
+	[page:Material material] —— （可选）一个[page:Material]实例，默认值是一个新的[page:MeshBasicMaterial]。
 		</p>
 
 

docs/api/zh/objects/Sprite.html

@@ -31,7 +31,7 @@ scene.add( sprite );
 
 		<h3>[name]( [param:Material material] )</h3>
 		<p>
-    	[page:Material material] - （可选值）是[page:SpriteMaterial]的一个实例。 默认值是一个白色的[page:SpriteMaterial]。<br /><br />
+		[page:Material material] - （可选值）是[page:SpriteMaterial]的一个实例。 默认值是一个白色的[page:SpriteMaterial]。<br /><br />
 
 		创建一个新的[name]。
 		</p>

docs/api/zh/renderers/WebGLMultisampleRenderTarget.html

@@ -11,7 +11,8 @@
 		<h1>[name]</h1>
 
 		<p class="desc">
-			TODO
+			A special render target that can be used to utilize multi-sampled renderbuffers.
+			Heads up: [name] can only be used with a WebGL 2 rendering context.
 		</p>
 
 
@@ -21,23 +22,25 @@
 		<h3>[name]([param:Number width], [param:Number height], [param:Object options])</h3>
 
 		<p>
-		[page:Float width] - TODO <br />
-		[page:Float height] - TODO<br />
-		[page:Object options] - TODO
+		[page:Float width] - The width of the render target. <br />
+		[page:Float height] - The height of the render target.<br />
+		[page:Object options] - (optional) object that holds texture parameters for an auto-generated target
+		texture and depthBuffer/stencilBuffer booleans.
 		</p>
 
 		<h2>Properties</h2>
 
-		<h3>[property:Number samples]</h3>
+		<h3>[property:number samples]</h3>
 		<p>
-		TODO
+		Specifies the number of samples to be used for the renderbuffer storage. However, the maximum supported
+		size for multisampling is platform dependent and defined via *gl.MAX_SAMPLES*.
 		</p>
 
-		<p>[page:WebGLRenderTarget WebGLRenderTarget] TODO</p>
+		<p>[page:WebGLRenderTarget WebGLRenderTarget] properties are available on this class.</p>
 
 		<h2>Methods</h2>
 
-		<p>[page:WebGLRenderTarget WebGLRenderTarget] TODO</p>
+		<p>[page:WebGLRenderTarget WebGLRenderTarget] methods are available on this class.</p>
 
 		<h2>Source</h2>
 

docs/api/zh/renderers/WebGLRenderTarget.html

@@ -56,12 +56,12 @@
 
 		<h3>[property:Vector4 scissor]</h3>
 		<p>
-        渲染目标视口内的一个矩形区域，区域之外的片元将会被丢弃
+		渲染目标视口内的一个矩形区域，区域之外的片元将会被丢弃
 		</p>
 
 		<h3>[property:boolean scissorTest]</h3>
 		<p>
-        表明是否激活了剪裁测试
+		表明是否激活了剪裁测试
 		</p>
 
 		<h3>[property:Vector4 viewport]</h3>
@@ -71,7 +71,7 @@
 
 		<h3>[property:Texture texture]</h3>
 		<p>
-        纹理实例保存这渲染的像素，用作进一步处理的输入值
+		纹理实例保存这渲染的像素，用作进一步处理的输入值
 		</p>
 
 		<h3>[property:boolean depthBuffer]</h3>
@@ -81,12 +81,12 @@
 
 		<h3>[property:boolean stencilBuffer]</h3>
 		<p>
-        渲染到模板缓冲区。默认true.
+		渲染到模板缓冲区。默认true.
 		</p>
 
 		<h3>[property:DepthTexture depthTexture]</h3>
 		<p>
-        如果设置，那么场景的深度将会被渲染到慈纹理上。默认是null.
+		如果设置，那么场景的深度将会被渲染到慈纹理上。默认是null.
 		</p>
 
 
@@ -104,7 +104,7 @@
 
 		<h3>[method:WebGLRenderTarget copy]( [param:WebGLRenderTarget source] )</h3>
 		<p>
-        采用传入的渲染目标的设置
+		采用传入的渲染目标的设置
 		</p>
 
 		<h3>[method:null dispose]()</h3>

docs/api/zh/renderers/WebGLRenderTargetCube.html

@@ -56,11 +56,11 @@
 
 		<h3>[method:WebGLRenderTargetCube fromEquirectangularTexture]( [param:WebGLRenderer renderer], [param:Texture texture] )</h3>
 		<p>
-			[page:WebGLRenderer renderer] — the renderer.<br/>
-			[page:Texture texture] — the equirectangular texture.
+			[page:WebGLRenderer renderer] — 渲染器。<br/>
+			[page:Texture texture] — equirectangular 纹理。
 		</p>
 		<p>
-			Use this method if you want to convert an equirectangular panorama to the cubemap format.
+			如果你想将一张equirectangular格式的全景图转换到cubemap格式，则使用此方法。
 		</p>
 
 		<h2>源码</h2>

docs/api/zh/renderers/WebGLRenderer.html

@@ -11,15 +11,15 @@
 		<h1>[name]</h1>
 
 		<p class="desc">
-            WebGL Render 用[link:https://en.wikipedia.org/wiki/WebGL WebGL]渲染出你精心制作的场景。
+			WebGL Render 用[link:https://en.wikipedia.org/wiki/WebGL WebGL]渲染出你精心制作的场景。
 		</p>
 
 		<h2>构造器</h2>
 
 		<h3>[name]( [param:Object parameters] )</h3>
 		<p>
-        [page:Object parameters] - (可选) 该对象的属性定义了渲染器的行为。也可以完全不传参数。在所有情况下，当缺少参数时，它将采用合理的默认值。
-            以下是合法参数：<br /><br />
+		[page:Object parameters] - (可选) 该对象的属性定义了渲染器的行为。也可以完全不传参数。在所有情况下，当缺少参数时，它将采用合理的默认值。
+			以下是合法参数：<br /><br />
 
 		[page:DOMElement canvas] - 一个供渲染器绘制其输出的[link:https://developer.mozilla.org/en-US/docs/Web/HTML/Element/canvas canvas]
 		它和下面的[page:WebGLRenderer.domElement domElement]属性对应。
@@ -29,7 +29,7 @@
 		[page:WebGLRenderingContext context] - 可用于将渲染器附加到已有的渲染环境([link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext RenderingContext])中。默认值是null<br />
 
 		[page:String precision] - 着色器精度. 可以是 *"highp"*, *"mediump"* 或者 *"lowp"*.
-	    如果设备支持，默认为*"highp"* . 点击[link:https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/WebGL_best_practices here] 查看"应该避免的事"<br />
+		如果设备支持，默认为*"highp"* . 点击[link:https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/WebGL_best_practices here] 查看"应该避免的事"<br />
 
 		[page:Boolean alpha] - canvas是否包含alpha (透明度)。默认为 *false*<br />
 
@@ -96,7 +96,7 @@
 
 		<h3>[property:Object capabilities]</h3>
 		<p>
-            一个包含当前渲染环境([link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext RenderingContext])的功能细节的对象。<br />
+			一个包含当前渲染环境([link:https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext RenderingContext])的功能细节的对象。<br />
 
 		- [page:Boolean floatFragmentTextures]: 环境是否支持[link:https://developer.mozilla.org/en-US/docs/Web/API/OES_texture_float OES_texture_float]扩展。
 			根据[link:https://webglstats.com/ WebGLStats], 截至2016年2月，超过95％的支持WebGL的设备支持此功能<br />
@@ -121,9 +121,9 @@
 
 		<h3>[property:Array clippingPlanes]</h3>
 		<p>
-            用户自定义的剪裁平面，在世界空间中被指定为THREE.Plane对象。
-            这些平面全局使用。空间中与该平面点积为负的点将被切掉。
-            默认值是[]
+			用户自定义的剪裁平面，在世界空间中被指定为THREE.Plane对象。
+			这些平面全局使用。空间中与该平面点积为负的点将被切掉。
+			默认值是[]
 		</p>
 
 		<h3>[property:DOMElement domElement]</h3>
@@ -186,8 +186,8 @@
 
 		<h3>[property:Integer maxMorphTargets]</h3>
 		<p>
-        默认是8。 一个着色器中允许的最大MorphTargets数。
-        切记标准材质只允许8个MorphTargets。
+		默认是8。 一个着色器中允许的最大MorphTargets数。
+		切记标准材质只允许8个MorphTargets。
 		</p>
 
 		<h3>[property:Integer maxMorphNormals]</h3>
@@ -209,12 +209,12 @@
 
 		<h3>[property:WebGLRenderLists renderLists]</h3>
 		<p>
-        在内部用于处理场景渲染对象的排序。
+		在内部用于处理场景渲染对象的排序。
 		</p>
 
 		<h3>[property:WebGLShadowMap shadowMap]</h3>
 		<p>
-        如果使用，它包含阴影贴图的引用。
+		如果使用，它包含阴影贴图的引用。
 		</p>
 
 		<h3>[property:Boolean shadowMap.enabled]</h3>
@@ -234,15 +234,15 @@
 
 		<h3>[property:Boolean sortObjects]</h3>
 		<p>
-        定义渲染器是否应对对象进行排序。默认是*true*.<br /><br />
+		定义渲染器是否应对对象进行排序。默认是*true*.<br /><br />
 
-        说明: 排序用于尝试正确渲染出具有一定透明度的对象。根据定义，排序可能不总是有用。根据应用的需求，可能需要关闭排序并使其他方法来处理透明度的渲染，例如，
-        手动确定每个对象的显然顺序。
+		说明: 排序用于尝试正确渲染出具有一定透明度的对象。根据定义，排序可能不总是有用。根据应用的需求，可能需要关闭排序并使其他方法来处理透明度的渲染，例如，
+		手动确定每个对象的显然顺序。
 		</p>
 
 		<h3>[property:Object state]</h3>
 		<p>
-        包含设置[page:WebGLRenderer.context]状态的各种属性的函数。
+		包含设置[page:WebGLRenderer.context]状态的各种属性的函数。
 		</p>
 
 		<h3>[property:Constant toneMapping]</h3>
@@ -302,8 +302,8 @@
 
 		<h3>[method:Object extensions.get]( [param:String extensionName] )</h3>
 		<p>
-        用于检查是否支持各种扩展，并返回一个对象，其中包含扩展的详细信息。
-        该方法检查以下扩展：<br /><br />
+		用于检查是否支持各种扩展，并返回一个对象，其中包含扩展的详细信息。
+		该方法检查以下扩展：<br /><br />
 
 		- *WEBGL_depth_texture*<br />
 		- *EXT_texture_filter_anisotropic*<br />
@@ -314,7 +314,7 @@
 
 		<h3>[method:null forceContextLoss]( )</h3>
 		<p>
-        模拟WebGL环境的丢失。需要支持
+		模拟WebGL环境的丢失。需要支持
 			[link:https://developer.mozilla.org/en-US/docs/Web/API/WEBGL_lose_context WEBGL_lose_context]扩展才能用。
 		根据[link:https://webglstats.com/ WebGLStats], as of February 2016 90% of WebGL enabled devices support this.
 		</p>
@@ -409,13 +409,13 @@
 
 		<h3>[method:null setScissor]( [param:Integer x], [param:Integer y], [param:Integer width], [param:Integer height] )</h3>
 		<p>
-        将剪裁区域设为(x, y)到(x + width, y + height)
+		将剪裁区域设为(x, y)到(x + width, y + height)
 		Sets the scissor area from
 		</p>
 
 		<h3>[method:null setScissorTest]( [param:Boolean boolean] )</h3>
 		<p>
-        启用或禁用剪裁检测. 若启用，则只有在所定义的裁剪区域内的像素才会受之后的渲染器影响。
+		启用或禁用剪裁检测. 若启用，则只有在所定义的裁剪区域内的像素才会受之后的渲染器影响。
 		</p>
 
 		<h3>[method:null setSize]( [param:Integer width], [param:Integer height], [param:Boolean updateStyle] )</h3>

docs/api/zh/renderers/webgl/WebGLProgram.html

@@ -42,7 +42,7 @@
 		attribute vec2 uv;
 		</code>
 		<p>
-        注意，可以通过以下方式计算顶点着色器中顶点的位置：
+		注意，可以通过以下方式计算顶点着色器中顶点的位置：
 		<code>
 		gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
 		</code>
@@ -132,12 +132,12 @@
 
 		<h3>[method:Object getUniforms]()</h3>
 		<p>
-        返回所有活动态的变量(uniform)位置的name-value映射
+		返回所有活动态的变量(uniform)位置的name-value映射
 		</p>
 
 		<h3>[method:Object getAttributes]()</h3>
 		<p>
-        返回所有活动态的顶点属性位置的name-value映射
+		返回所有活动态的顶点属性位置的name-value映射
 		</p>
 
 		<h2>源码</h2>

docs/api/zh/renderers/webgl/WebGLShader.html

@@ -38,7 +38,7 @@
 		source -- 着色器源码
 		</p>
 		<p>
-        此函数将编译一个独立的着色器，不会将它和一个完整的[page:WebGLProgram]链接起来。
+		此函数将编译一个独立的着色器，不会将它和一个完整的[page:WebGLProgram]链接起来。
 		说明: 这是一个函数，因此不应该使用新的操作符。
 
 		</p>

docs/api/zh/renderers/webgl/WebGLState.html

@@ -17,12 +17,12 @@
 
 		<h3>[method:null enable]( [param:integer id], [param:boolean boolean] )</h3>
 		<p>
-		未完成
+		TODO
 		</p>
 
 		<h3>[method:null disable]( [param:integer id], [param:boolean boolean] )</h3>
 		<p>
-		未完成
+		TODO
 		</p>
 
 		<h3>[method:null setDepthTest]( [param:boolean depthTest] )</h3>

docs/api/zh/scenes/Scene.html

@@ -43,8 +43,8 @@
 
 		<h3>[property:Object background]</h3>
 		<p>
-            若不为空，在渲染场景的时候将设置背景，且背景总是首先被渲染的。
-            可以设置一个用于的“clear”的[page:Color]（颜色）、一个覆盖canvas的[page:Texture]（纹理），或是一个[page:CubeTexture]。默认值为null。
+			若不为空，在渲染场景的时候将设置背景，且背景总是首先被渲染的。
+			可以设置一个用于的“clear”的[page:Color]（颜色）、一个覆盖canvas的[page:Texture]（纹理），或是一个[page:CubeTexture]。默认值为null。
 		</p>
 
 		<h2>方法</h2>

docs/api/zh/textures/CanvasTexture.html

@@ -39,11 +39,11 @@
 		[page:Constant minFilter] -- 当一个纹素覆盖小于一个像素时，贴图将如何采样。
 		其默认值为[page:Textures THREE.LinearMipmapLinearFilter]。请参阅[page:Textures minification filter constants]（缩小滤镜常量）来了解其它选项。<br />
 
-    	[page:Constant format] -- 在纹理贴图中使用的格式。
-     	请参阅[page:Textures format constants]（格式常量）来了解各个选项。<br />
+		[page:Constant format] -- 在纹理贴图中使用的格式。
+			请参阅[page:Textures format constants]（格式常量）来了解各个选项。<br />
 
-    	[page:Constant type] -- 默认值是[page:Textures THREE.UnsignedByteType].
-    	请参阅[page:Textures type constants]（类型常量）来了解其他选项。<br />
+		[page:Constant type] -- 默认值是[page:Textures THREE.UnsignedByteType].
+		请参阅[page:Textures type constants]（类型常量）来了解其他选项。<br />
 
 		[page:Number anisotropy] -- 沿着轴，通过具有最高纹素密度的像素的样本数。
 		默认情况下，这个值为1。设置一个较高的值将会产生比基本的mipmap更清晰的效果，代价是需要使用更多纹理样本。
@@ -55,7 +55,7 @@
 
 		<p>
 		共有方法请参见其基类[page:Texture Texture]。
-    </p>
+	</p>
 
 		<h3>[property:boolean needsUpdate]</h3>
 
@@ -65,9 +65,9 @@
 
 		<h2>方法</h2>
 
-    <p>
+	<p>
 	共有方法请参见其基类[page:Texture Texture]。
-    </p>
+	</p>
 
 
 		<h2>源代码</h2>

docs/api/zh/textures/DataTexture.html

@@ -57,7 +57,6 @@
 		// used the buffer to create a [name]
 
 		var texture = new THREE.DataTexture( data, width, height, THREE.RGBFormat );
-		texture.needsUpdate = true
 		</code>
 
 		<h2>Properties</h2>

docs/api/zh/textures/DepthTexture.html

@@ -29,7 +29,7 @@
 		[page:Number height] -- 纹理的高度。<br />
 
 		[page:Constant type] -- 默认值是[page:Textures THREE.UnsignedShortType]。
-    	请参阅[page:Textures type constants]（类型常量）来了解其他选项。<br />
+		请参阅[page:Textures type constants]（类型常量）来了解其他选项。<br />
 
 		[page:Constant mapping] --
 		请参阅[page:Textures mapping constants]（映射模式常量）来了解其他选项。<br />

docs/api/zh/textures/VideoTexture.html

@@ -18,7 +18,7 @@
 		它和其基类[page:Texture Texture]几乎是相同的，除了它总是将[page:Texture.needsUpdate needsUpdate]设置为*true*，以便使得贴图能够在视频播放时进行更新。自动创建[page:Texture.mipmaps mipmaps]也会被禁用。
 		</p>
 
-    <h2>示例</h2>
+	<h2>示例</h2>
 
 		<p>[example:webgl_materials_video materials / video ]</p>
 
@@ -30,7 +30,7 @@ var texture = new THREE.VideoTexture( video );
 texture.minFilter = THREE.LinearFilter;
 texture.magFilter = THREE.LinearFilter;
 texture.format = THREE.RGBFormat;
-    </code>
+		</code>
 
 
 		<h2>构造函数</h2>
@@ -53,11 +53,11 @@ texture.format = THREE.RGBFormat;
 		[page:Constant minFilter] -- 当一个纹素覆盖小于一个像素时，贴图将如何采样。
 		其默认值为[page:Textures THREE.LinearMipmapLinearFilter]。请参阅[page:Textures minification filter constants]（缩小滤镜常量）来了解其它选项。<br />
 
-    	[page:Constant format] -- 在纹理贴图中使用的格式。
-     	请参阅[page:Textures format constants]（格式常量）来了解各个选项。<br />
+		[page:Constant format] -- 在纹理贴图中使用的格式。
+	 	请参阅[page:Textures format constants]（格式常量）来了解各个选项。<br />
 
-    	[page:Constant type] -- 默认值是[page:Textures THREE.UnsignedByteType].
-     	请参阅[page:Textures type constants]（类型常量）来了解其他选项。<br />
+		[page:Constant type] -- 默认值是[page:Textures THREE.UnsignedByteType].
+	 	请参阅[page:Textures type constants]（类型常量）来了解其他选项。<br />
 
 		[page:Number anisotropy] -- 沿着轴，通过具有最高纹素密度的像素的采样数。
 		默认情况下，这个值为1。设置一个较高的值将会比基本的mipmap产生更清晰的效果，代价是需要使用更多纹理样本。
@@ -69,7 +69,7 @@ texture.format = THREE.RGBFormat;
 
 		<p>
 		共有属性请参见其基类[page:Texture Texture]。
-    </p>
+	</p>
 
 		<h3>[property:boolean needsUpdate]</h3>
 		<p>
@@ -78,11 +78,11 @@ texture.format = THREE.RGBFormat;
 
 		<h2>方法</h2>
 
-    <p>
+	<p>
 		共有方法请参见其基类[page:Texture Texture]。
-    </p>
+	</p>
 
-    <h3>[method:null update]()</h3>
+	<h3>[method:null update]()</h3>
 		<p>
 		在每一次新的一帧可用时，这个方法将被自动调用，
 		并将[property:boolean needsUpdate]设置为*true*。

docs/examples/en/loaders/PCDLoader.html

@@ -14,7 +14,7 @@
 
 		<p class="desc">A loader for loading a <em>.pcd</em> resource. <br />
 		Point Cloud Data is a file format for <a href="https://en.wikipedia.org/wiki/Point_Cloud_Library">Point Cloud Library</a>. <br />
-		Loader support ascii and binary. Compressed binary files are not supported.
+		Loader support ascii and (compressed) binary.
 		</p>
 
 		<h2>Example</h2>

docs/examples/zh/loaders/GLTFLoader.html

@@ -10,22 +10,20 @@
 	<body>
 		[page:Loader] &rarr;
 
-		<h1>[name]</h1>
-
-		<p class="desc"> A loader for <em>glTF 2.0</em> resources. <br /><br />
-		[link:https://www.khronos.org/gltf glTF] (GL Transmission Format) is an
-		[link:https://github.com/KhronosGroup/glTF/tree/master/specification/2.0 open format specification]
-		for efficient delivery and loading of 3D content. Assets may be provided either in JSON (.gltf)
-		or binary (.glb) format. External files store textures (.jpg, .png) and additional binary
-		data (.bin). A glTF asset may deliver one or more scenes, including meshes, materials,
-		textures, skins, skeletons, morph targets, animations, lights, and/or cameras.
+		<h1>GLTF加载器（[name]）</h1>
+
+		<p class="desc">用于载入<em>glTF 2.0</em>资源的加载器。<br /><br />
+		[link:https://www.khronos.org/gltf glTF]（gl传输格式）是一种开放格式的规范
+		（[link:https://github.com/KhronosGroup/glTF/tree/master/specification/2.0 open format specification]），
+		用于更高效地传输、加载3D内容。该类文件以JSON（.glft）格式或二进制（.glb）格式提供，
+		外部文件存储贴图（.jpg、.png）和额外的二进制数据（.bin）。一个glTF组件可传输一个或多个场景，
+		包括网格、材质、贴图、蒙皮、骨架、变形目标、动画、灯光以及摄像机。
 		</p>
 
-		<h2>Extensions</h2>
+		<h2>扩展</h2>
 
 		<p>
-			GLTFLoader supports the following
-			[link:https://github.com/KhronosGroup/glTF/tree/master/extensions/ glTF 2.0 extensions]:
+			GLTFLoader支持下列glTF 2.0扩展（[link:https://github.com/KhronosGroup/glTF/tree/master/extensions/ glTF 2.0 extensions]）：
 		</p>
 
 		<ul>
@@ -38,19 +36,20 @@
 		</ul>
 
 		<p><i>
-			<sup>1</sup>Requires [link:https://threejs.org/docs/#api/en/renderers/WebGLRenderer.physicallyCorrectLights physicallyCorrectLights] to be enabled.
+			<sup>1</sup>需要[link:https://threejs.org/docs/#api/en/renderers/WebGLRenderer.physicallyCorrectLights physicallyCorrectLights]被启用。
 		</i></p>
 		<p><i>
-			<sup>2</sup>UV transforms are supported, with several key limitations. Transforms applied to
+			<sup>2</sup>支持UV变换，但存在一些重要的限制。
+			Transforms applied to
 			a texture using the first UV slot (all textures except aoMap and lightMap) must share the same
-			transform, or no transfor at all. The aoMap and lightMap textures cannot be transformed. No
-			more than one transform may be used per material. Each use of a texture with a unique
-			transform will result in an additional GPU texture upload. See
-			#[link:https://github.com/mrdoob/three.js/pull/13831 13831] and
-			#[link:https://github.com/mrdoob/three.js/issues/12788 12788].
+			transform, or no transfor at all. 
+			aoMap 和 lightMap 纹理不能被变换。每个材质最多只能使用一次变换。
+			每次对使用具有唯一变换的纹理都会导致一次额外的GPU纹理上传。
+			请参阅#[link:https://github.com/mrdoob/three.js/pull/13831 13831] 和
+			#[link:https://github.com/mrdoob/three.js/issues/12788 12788]。
 		</i></p>
 
-		<h2>Example</h2>
+		<h2>示例</h2>
 
 		<code>
 		// Instantiate a loader
@@ -94,29 +93,25 @@
 
 		[example:webgl_loader_gltf]
 
-		<h2>Browser compatibility</h2>
+		<h2>浏览器兼容性</h2>
 
-		<p>GLTFLoader relies on ES6 [link:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise Promises],
-		which are not supported in IE11. To use the loader in IE11, you must
-		[link:https://github.com/stefanpenner/es6-promise include a polyfill]
-		providing a Promise replacement.</p>
+		<p>GLTFLoader 依赖 ES6 [link:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise Promises]，
+		这一特性不支持IE11。若要在IE11中使用该加载器，你必须引入polyfill（[link:https://github.com/stefanpenner/es6-promise include a polyfill]）
+		来提供一个Promise的替代方案。</p>
 
-		<h2>Textures</h2>
+		<h2>纹理</h2>
 
-		<p>Textures containing color information (.map, .emissiveMap, and .specularMap) always use sRGB colorspace in
-		glTF, while vertex colors and material properties (.color, .emissive, .specular) use linear colorspace. In a
-		typical rendering workflow, textures are converted to linear colorspace by the renderer, lighting calculations
-		are made, then final output is converted back to sRGB and displayed on screen. Unless you need post-processing
-		in linear colorspace, always configure [page:WebGLRenderer] as follows when using glTF:</p>
+		<p>纹理中包含的颜色信息（.map, .emissiveMap, 和 .specularMap）在glTF中总是使用sRGB颜色空间，而顶点颜色和材质属性（.color, .emissive, .specular）
+		则使用线性颜色空间。在典型的渲染工作流程中，纹理会被渲染器转换为线性颜色空间，进行光照计算，然后最终输出会被转换回 sRGB
+		颜色空间并显示在屏幕上。除非你需要使用线性颜色空间进行后期处理，否则请在使用glTF的时候将[page:WebGLRenderer]进行如下配置：</p>
 
 		<code>
 		renderer.gammaOutput = true;
 		renderer.gammaFactor = 2.2;
 		</code>
 
-		<p>GLTFLoader will automatically configure textures referenced from a .gltf or .glb file correctly, with the
-		assumption that the renderer is set up as shown above. When loading textures externally (e.g., using
-		[page:TextureLoader]) and applying them to a glTF model, colorspace and orientation must be given:</p>
+		<p>假设渲染器的配置如上所示，则GLTFLoader将可以正确地自动配置从.gltf或.glb文件中引用的纹理。
+		当从外部加载纹理（例如，使用[page:TextureLoader]）并将纹理应用到glTF模型，则必须给定对应的颜色空间与朝向：</p>
 
 		<code>
 		// If texture is used for color information, set colorspace.
@@ -126,11 +121,11 @@
 		texture.flipY = false;
 		</code>
 
-		<h2>Custom extensions</h2>
+		<h2>自定义扩展</h2>
 
 		<p>
-			Metadata from unknown extensions is preserved as “.userData.gltfExtensions” on Object3D, Scene, and Material instances,
-			or attached to the response “gltf” object. Example:
+			来自未知扩展的元数据会被保存到Object3D、Scene和Material实例中上的“.userData.gltfExtensions”，
+			或被附加到 response “gltf”对象。示例：
 		</p>
 
 		<code>
@@ -151,58 +146,58 @@
 		<br>
 		<hr>
 
-		<h2>Constructor</h2>
+		<h2>构造函数</h2>
 
 		<h3>[name]( [param:LoadingManager manager] )</h3>
 		<p>
-		[page:LoadingManager manager] — The [page:LoadingManager loadingManager] for the loader to use. Default is [page:LoadingManager THREE.DefaultLoadingManager].
+		[page:LoadingManager manager] — 该加载器将要使用的 [page:LoadingManager loadingManager] 。默认为 [page:LoadingManager THREE.DefaultLoadingManager]。
 		</p>
 		<p>
-		Creates a new [name].
+		创建一个新的[name]。
 		</p>
 
-		<h2>Properties</h2>
-		<p>See the base [page:Loader] class for common properties.</p>
+		<h2>属性</h2>
+		<p>共有属性请参见其基类[page:Loader]。</p>
 
-		<h2>Methods</h2>
-		<p>See the base [page:Loader] class for common methods.</p>
+		<h2>方法</h2>
+		<p>共有方法请参见其基类[page:Loader]。</p>
 
 		<h3>[method:null load]( [param:String url], [param:Function onLoad], [param:Function onProgress], [param:Function onError] )</h3>
 		<p>
-		[page:String url] — A string containing the path/URL of the <em>.gltf</em> or <em>.glb</em> file.<br />
-		[page:Function onLoad] — A function to be called after the loading is successfully completed. The function receives the loaded JSON response returned from [page:Function parse].<br />
-		[page:Function onProgress] — (optional) A function to be called while the loading is in progress. The argument will be the XMLHttpRequest instance, that contains .[page:Integer total] and .[page:Integer loaded] bytes.<br />
-		[page:Function onError] — (optional) A function to be called if an error occurs during loading. The function receives error as an argument.<br />
+		[page:String url] — 包含有<em>.gltf</em>/<em>.glb</em>文件路径/URL的字符串。<br />
+		[page:Function onLoad] — 加载成功完成后将会被调用的函数。该函数接收[page:Function parse]所返回的已加载的JSON响应。<br />
+		[page:Function onProgress] — （可选）加载正在进行过程中会被调用的函数。其参数将会是XMLHttpRequest实例，包含有总字节数.[page:Integer total]与已加载的字节数.[page:Integer loaded]。<br />
+		[page:Function onError] — （可选）若在加载过程发生错误，将被调用的函数。该函数接收error来作为参数。<br />
 		</p>
 		<p>
-		Begin loading from url and call the callback function with the parsed response content.
+		开始从url加载，并使用解析过的响应内容调用回调函数。
 		</p>
 
 		<h3>[method:null setDRACOLoader]( [param:DRACOLoader dracoLoader] )</h3>
 		<p>
-		[page:DRACOLoader dracoLoader] — Instance of THREE.DRACOLoader, to be used for decoding assets compressed with the KHR_draco_mesh_compression extension.
+		[page:DRACOLoader dracoLoader] — THREE.DRACOLoader的实例，用于解码使用KHR_draco_mesh_compression扩展压缩过的文件。
 		</p>
 		<p>
-		Refer to this [link:https://github.com/mrdoob/three.js/tree/dev/examples/js/libs/draco#readme readme] for the details of Draco and its decoder.
+		请参阅[link:https://github.com/mrdoob/three.js/tree/dev/examples/js/libs/draco#readme readme]来了解Draco及其解码器的详细信息。
 		</p>
 
 		<h3>[method:null setDDSLoader]( [param:DDSLoader ddsLoader] )</h3>
 		<p>
-		[page:DDSLoader ddsLoader] — Instance of THREE.DDSLoader, to be used for loading compressed textures with the MSFT_TEXTURE_DDS extension.
+		[page:DDSLoader ddsLoader] — THREE.DDSLoader的实例，用于加载使用MSFT_TEXTURE_DDS扩展压缩过的纹理。
 		</p>
 
 		<h3>[method:null parse]( [param:ArrayBuffer data], [param:String path], [param:Function onLoad], [param:Function onError] )</h3>
 		<p>
-		[page:ArrayBuffer data] — glTF asset to parse, as an ArrayBuffer or <em>JSON</em> string.<br />
-		[page:String path] — The base path from which to find subsequent glTF resources such as textures and .bin data files.<br />
-		[page:Function onLoad] — A function to be called when parse completes.<br />
-		[page:Function onError] — (optional) A function to be called if an error occurs during parsing. The function receives error as an argument.<br />
+		[page:ArrayBuffer data] — 需要解析的glTF文件，值为一个ArrayBuffer或<em>JSON</em>字符串。<br />
+		[page:String path] — 用于找到后续glTF资源（如纹理和.bin数据文件）的基础路径。<br />
+		[page:Function onLoad] — 解析成功完成后将会被调用的函数。<br />
+		[page:Function onError] — （可选）若在解析过程发生错误，将被调用的函数。该函数接收error来作为参数。<br />
 		</p>
 		<p>
-		Parse a glTF-based ArrayBuffer or <em>JSON</em> String and fire [page:Function onLoad] callback when complete. The argument to [page:Function onLoad] will be an [page:object] that contains loaded parts: .[page:Scene scene], .[page:Array scenes], .[page:Array cameras], .[page:Array animations], and .[page:Object asset].
+		解析基于glTF的ArrayBuffer或<em>JSON</em>字符串，并在完成后触发[page:Function onLoad]回调。[page:Function onLoad]的参数将是一个包含有已加载部分的[page:object]：.[page:Scene scene]、 .[page:Array scenes]、 .[page:Array cameras]、 .[page:Array animations] 和 .[page:Object asset]。
 		</p>
 
-		<h2>Source</h2>
+		<h2>源代码</h2>
 
 		<p>
 			[link:https://github.com/mrdoob/three.js/blob/master/examples/js/loaders/GLTFLoader.js examples/js/loaders/GLTFLoader.js]

docs/examples/zh/loaders/PCDLoader.html

@@ -14,7 +14,7 @@
 
 		<p class="desc">A loader for loading a <em>.pcd</em> resource. <br />
 		Point Cloud Data is a file format for <a href="https://en.wikipedia.org/wiki/Point_Cloud_Library">Point Cloud Library</a>. <br />
-		Loader support ascii and binary. Compressed binary files are not supported.
+		Loader support ascii and (compressed) binary.
 		</p>
 
 		<h2>Example</h2>

docs/manual/zh/introduction/How-to-dispose-of-objects.html

@@ -92,11 +92,6 @@
 		如果你在你的应用程序中注意到了性能问题，一个较好的方法便是调试该属性，以便轻松识别内存泄漏。
 	</p>
 
-	<p>
-		对于纹理的内部资源仅在图像完全被加载后才会分配。如果你在图像被加载之前废置纹理，什么都不会发生。
-		没有资源被分配，因此也没有必要进行清理。
-	</p>
-
 	<h3>当你在纹理还没有被加载时，在纹理上调用*dispose()*，会发生什么？</h3>
 
 	<p>

docs/manual/zh/introduction/How-to-update-things.html

@@ -166,7 +166,6 @@ geometry.tangentsNeedUpdate = true;
 			<p>在运行时无法轻松更改以下属性（一旦material被渲染了一次）：</p>
 			<ul>
 				<li>uniforms的数量和类型</li>
-				<li>lights的数量和类型</li>
 				<li>是否存在
 					<ul>
 						<li>texture</li>

docs/manual/zh/introduction/Loading-3D-models.html

@@ -133,6 +133,9 @@
 		尝试将模型放大或缩小到原来的1000倍。许多模型的缩放比例各不相同，如果摄像机位于模型内，则大型模型将可能不会显示。
 		</li>
 		<li>
+		尝试添加一个光源并改变其位置。模型或许被隐藏在黑暗中。
+		</li>
+		<li>
 		在网络面板中查找失败的纹理贴图请求，比如说<em>C:\\Path\To\Model\texture.jpg</em>。载入贴图时，请使用相对于模型文件路径，例如
 		<em>images/texture.jpg</em> —— 这或许需要在文本编辑器中来对模型文件进行修改。
 		</li>

editor/index.html

@@ -7,8 +7,8 @@
 		<link rel="apple-touch-icon" href="images/icon.png">
 		<link rel="manifest" href="manifest.json">
 		<link rel="shortcut icon" href="../files/favicon.ico" />
-		<!-- WebXR Device API (For Chrome M76+), expires 10/16/2019 -->
-		<meta http-equiv="origin-trial" content="AtWCPo0cZgy0zJDSYftemy7eZvmcwR5qy/4osFkMkLZ0ar6OYyKfbu93pjpxiOVzcWNIVxgoWoK8YtxCXeFSqgIAAABTeyJvcmlnaW4iOiJodHRwczovL3RocmVlanMub3JnOjQ0MyIsImZlYXR1cmUiOiJXZWJYUkRldmljZU03NiIsImV4cGlyeSI6MTU3MTE4Mzk5OX0=">
+		<!-- WebXR Device API (For Chrome M76+), expires 12/04/2019 -->
+		<meta http-equiv="origin-trial" content="Aq9LklhCLNUveuCr7QTpGpqwCPG817cYHdVyQuJPOZYk47iRB390lUKa5edVmgS1pZSl8HPspElEC/91Fz55dwIAAABTeyJvcmlnaW4iOiJodHRwczovL3RocmVlanMub3JnOjQ0MyIsImZlYXR1cmUiOiJXZWJYUkRldmljZU03NiIsImV4cGlyeSI6MTU3NTQxNzU5OX0=">
 	</head>
 	<body ontouchstart="">
 		<link rel="stylesheet" href="css/main.css">

editor/js/Sidebar.Material.js

@@ -1160,6 +1160,7 @@ Sidebar.Material = function ( editor ) {
 			'alphaMap': materialAlphaMapRow,
 			'bumpMap': materialBumpMapRow,
 			'normalMap': materialNormalMapRow,
+			'clearcoatNormalMap': materialClearcoatNormalMapRow,
 			'displacementMap': materialDisplacementMapRow,
 			'roughnessMap': materialRoughnessMapRow,
 			'metalnessMap': materialMetalnessMapRow,

editor/sw.js

@@ -1,4 +1,4 @@
-// r109
+// r110
 
 const assets = [
 	'./',

examples/css3d_molecules.html

@@ -135,7 +135,6 @@
 
 				controls = new TrackballControls( camera, renderer.domElement );
 				controls.rotateSpeed = 0.5;
-				controls.addEventListener( 'change', render );
 
 				//
 
@@ -484,8 +483,6 @@
 
 					}
 
-					render();
-
 				} );
 
 
@@ -500,8 +497,6 @@
 
 				renderer.setSize( window.innerWidth, window.innerHeight );
 
-				render();
-
 			}
 
 			function animate() {

examples/files.js

@@ -61,6 +61,7 @@ var files = {
 		"webgl_layers",
 		"webgl_lensflares",
 		"webgl_lightprobe",
+		"webgl_lightprobe_cubecamera",
 		"webgl_lights_hemisphere",
 		"webgl_lights_physical",
 		"webgl_lights_pointlights",

examples/js/controls/OrbitControls.js

@@ -258,7 +258,7 @@ THREE.OrbitControls = function ( object, domElement ) {
 		document.removeEventListener( 'mousemove', onMouseMove, false );
 		document.removeEventListener( 'mouseup', onMouseUp, false );
 
-		window.removeEventListener( 'keydown', onKeyDown, false );
+		scope.domElement.removeEventListener( 'keydown', onKeyDown, false );
 
 		//scope.dispatchEvent( { type: 'dispose' } ); // should this be added here?
 
@@ -1136,7 +1136,15 @@ THREE.OrbitControls = function ( object, domElement ) {
 	scope.domElement.addEventListener( 'touchend', onTouchEnd, false );
 	scope.domElement.addEventListener( 'touchmove', onTouchMove, false );
 
-	window.addEventListener( 'keydown', onKeyDown, false );
+	scope.domElement.addEventListener( 'keydown', onKeyDown, false );
+
+	// make sure element can receive keys.
+
+	if ( scope.domElement.tabIndex === - 1 ) {
+
+		scope.domElement.tabIndex = 0;
+
+	}
 
 	// force an update at start
 

examples/js/lights/LightProbeGenerator.js

@@ -50,7 +50,7 @@ THREE.LightProbeGenerator = {
 				color.setRGB( data[ i ] / 255, data[ i + 1 ] / 255, data[ i + 2 ] / 255 );
 
 				// convert to linear color space
-				color.copySRGBToLinear( color );
+				convertColorToLinear( color, cubeTexture.encoding );
 
 				// pixel coordinate on unit cube
 
@@ -116,6 +116,128 @@ THREE.LightProbeGenerator = {
 
 		return new THREE.LightProbe( sh );
 
+	},
+
+	fromRenderTargetCube: function ( renderer, renderTargetCube ) {
+
+		// The renderTarget must be set to RGBA in order to make readRenderTargetPixels works
+		var norm, lengthSq, weight, totalWeight = 0;
+
+		var coord = new THREE.Vector3();
+
+		var dir = new THREE.Vector3();
+
+		var color = new THREE.Color();
+
+		var shBasis = [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
+
+		var sh = new THREE.SphericalHarmonics3();
+		var shCoefficients = sh.coefficients;
+
+		for ( var faceIndex = 0; faceIndex < 6; faceIndex ++ ) {
+
+			var imageWidth = renderTargetCube.width; // assumed to be square
+			var data = new Uint8Array( imageWidth * imageWidth * 4 );
+			renderer.readRenderTargetPixels( renderTargetCube, 0, 0, imageWidth, imageWidth, data, faceIndex );
+
+			var pixelSize = 2 / imageWidth;
+
+			for ( var i = 0, il = data.length; i < il; i += 4 ) { // RGBA assumed
+
+				// pixel color
+				color.setRGB( data[ i ] / 255, data[ i + 1 ] / 255, data[ i + 2 ] / 255 );
+
+				// convert to linear color space
+				convertColorToLinear( color, renderTargetCube.texture.encoding );
+
+				// pixel coordinate on unit cube
+
+				var pixelIndex = i / 4;
+
+				var col = - 1 + ( pixelIndex % imageWidth + 0.5 ) * pixelSize;
+
+				var row = 1 - ( Math.floor( pixelIndex / imageWidth ) + 0.5 ) * pixelSize;
+
+				switch ( faceIndex ) {
+
+					case 0: coord.set( 1, row, - col ); break;
+
+					case 1: coord.set( - 1, row, col ); break;
+
+					case 2: coord.set( col, 1, - row ); break;
+
+					case 3: coord.set( col, - 1, row ); break;
+
+					case 4: coord.set( col, row, 1 ); break;
+
+					case 5: coord.set( - col, row, - 1 ); break;
+
+				}
+
+				// weight assigned to this pixel
+
+				lengthSq = coord.lengthSq();
+
+				weight = 4 / ( Math.sqrt( lengthSq ) * lengthSq );
+
+				totalWeight += weight;
+
+				// direction vector to this pixel
+				dir.copy( coord ).normalize();
+
+				// evaluate SH basis functions in direction dir
+				THREE.SphericalHarmonics3.getBasisAt( dir, shBasis );
+
+				// accummuulate
+				for ( var j = 0; j < 9; j ++ ) {
+
+					shCoefficients[ j ].x += shBasis[ j ] * color.r * weight;
+					shCoefficients[ j ].y += shBasis[ j ] * color.g * weight;
+					shCoefficients[ j ].z += shBasis[ j ] * color.b * weight;
+
+				}
+
+			}
+
+		}
+
+		// normalize
+		norm = ( 4 * Math.PI ) / totalWeight;
+
+		for ( var j = 0; j < 9; j ++ ) {
+
+			shCoefficients[ j ].x *= norm;
+			shCoefficients[ j ].y *= norm;
+			shCoefficients[ j ].z *= norm;
+
+		}
+
+		return new THREE.LightProbe( sh );
+
+	}
+
+};
+
+var convertColorToLinear = function ( color, encoding ) {
+
+	switch ( encoding ) {
+
+		case THREE.sRGBEncoding:
+
+			color.convertSRGBToLinear();
+			break;
+
+		case THREE.LinearEncoding:
+
+			break;
+
+		default:
+
+			console.warn( 'WARNING: LightProbeGenerator convertColorToLinear() encountered an unsupported encoding.' );
+			break;
+
 	}
 
+	return color;
+
 };

examples/js/loaders/3MFLoader.js

@@ -14,6 +14,8 @@
  *
  * - Texture 2D
  * - Texture 2D Groups
+ * - Color Groups (Vertex Colors)
+ * - Metallic Display Properties (PBR)
  */
 
 THREE.ThreeMFLoader = function ( manager ) {
@@ -46,7 +48,6 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 
 		var scope = this;
 		var textureLoader = new THREE.TextureLoader( this.manager );
-		var textureMap = {};
 
 		function loadDocument( data ) {
 
@@ -100,7 +101,7 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 
 					printTicketPartNames.push( file );
 
-				} else if ( file.match( /^3D\/Texture\/.*/ ) ) {
+				} else if ( file.match( /^3D\/Textures?\/.*/ ) ) {
 
 					texturesPartNames.push( file );
 
@@ -193,17 +194,27 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 
 		function parseRelsXml( relsFileText ) {
 
+			var relationships = [];
+
 			var relsXmlData = new DOMParser().parseFromString( relsFileText, 'application/xml' );
-			var relsNode = relsXmlData.querySelector( 'Relationship' );
-			var target = relsNode.getAttribute( 'Target' );
-			var id = relsNode.getAttribute( 'Id' );
-			var type = relsNode.getAttribute( 'Type' );
 
-			return {
-				target: target,
-				id: id,
-				type: type
-			};
+			var relsNodes = relsXmlData.querySelectorAll( 'Relationship' );
+
+			for ( var i = 0; i < relsNodes.length; i ++ ) {
+
+				var relsNode = relsNodes[ i ];
+
+				var relationship = {
+					target: relsNode.getAttribute( 'Target' ), //required
+					id: relsNode.getAttribute( 'Id' ), //required
+					type: relsNode.getAttribute( 'Type' ) //required
+				};
+
+				relationships.push( relationship );
+
+			}
+
+			return relationships;
 
 		}
 
@@ -251,6 +262,7 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 
 				var basematerialNode = basematerialNodes[ i ];
 				var basematerialData = parseBasematerialNode( basematerialNode );
+				basematerialData.index = i; // the order and count of the material nodes form an implicit 0-based index
 				basematerialsData.basematerials.push( basematerialData );
 
 			}
@@ -274,7 +286,7 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 
 		}
 
-		function parseTextures2DGroupNodes( texture2DGroupNode ) {
+		function parseTextures2DGroupNode( texture2DGroupNode ) {
 
 			var texture2DGroupData = {
 				id: texture2DGroupNode.getAttribute( 'id' ), // required
@@ -302,12 +314,71 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 
 		}
 
+		function parseColorGroupNode( colorGroupNode ) {
+
+			var colorGroupData = {
+				id: colorGroupNode.getAttribute( 'id' ), // required
+				displaypropertiesid: colorGroupNode.getAttribute( 'displaypropertiesid' )
+			};
+
+			var colorNodes = colorGroupNode.querySelectorAll( 'color' );
+
+			var colors = [];
+			var colorObject = new THREE.Color();
+
+			for ( var i = 0; i < colorNodes.length; i ++ ) {
+
+				var colorNode = colorNodes[ i ];
+				var color = colorNode.getAttribute( 'color' );
+
+				colorObject.setStyle( color.substring( 0, 7 ) );
+				colorObject.convertSRGBToLinear(); // color is in sRGB
+
+				colors.push( colorObject.r, colorObject.g, colorObject.b );
+
+			}
+
+			colorGroupData[ 'colors' ] = new Float32Array( colors );
+
+			return colorGroupData;
+
+		}
+
+		function parseMetallicDisplaypropertiesNode( metallicDisplaypropetiesNode ) {
+
+			var metallicDisplaypropertiesData = {
+				id: metallicDisplaypropetiesNode.getAttribute( 'id' ) // required
+			};
+
+			var metallicNodes = metallicDisplaypropetiesNode.querySelectorAll( 'pbmetallic' );
+
+			var metallicData = [];
+
+			for ( var i = 0; i < metallicNodes.length; i ++ ) {
+
+				var metallicNode = metallicNodes[ i ];
+
+				metallicData.push( {
+					name: metallicNode.getAttribute( 'name' ), // required
+					metallicness: parseFloat( metallicNode.getAttribute( 'metallicness' ) ), // required
+					roughness: parseFloat( metallicNode.getAttribute( 'roughness' ) ) // required
+				} );
+
+			}
+
+			metallicDisplaypropertiesData.data = metallicData;
+
+			return metallicDisplaypropertiesData;
+
+		}
+
 		function parseBasematerialNode( basematerialNode ) {
 
 			var basematerialData = {};
 
 			basematerialData[ 'name' ] = basematerialNode.getAttribute( 'name' ); // required
 			basematerialData[ 'displaycolor' ] = basematerialNode.getAttribute( 'displaycolor' ); // required
+			basematerialData[ 'displaypropertiesid' ] = basematerialNode.getAttribute( 'displaypropertiesid' );
 
 			return basematerialData;
 
@@ -348,10 +419,16 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 				var p3 = triangleNode.getAttribute( 'p3' );
 				var pid = triangleNode.getAttribute( 'pid' );
 
-				triangles.push( parseInt( v1, 10 ), parseInt( v2, 10 ), parseInt( v3, 10 ) );
-
 				var triangleProperty = {};
 
+				triangleProperty[ 'v1' ] = parseInt( v1, 10 );
+				triangleProperty[ 'v2' ] = parseInt( v2, 10 );
+				triangleProperty[ 'v3' ] = parseInt( v3, 10 );
+
+				triangles.push( triangleProperty[ 'v1' ], triangleProperty[ 'v2' ], triangleProperty[ 'v3' ] );
+
+				// optional
+
 				if ( p1 ) {
 
 					triangleProperty[ 'p1' ] = parseInt( p1, 10 );
@@ -525,11 +602,15 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 		function parseResourcesNode( resourcesNode ) {
 
 			var resourcesData = {};
-			var basematerialsNode = resourcesNode.querySelector( 'basematerials' );
 
-			if ( basematerialsNode ) {
+			resourcesData[ 'basematerials' ] = {};
+			var basematerialsNodes = resourcesNode.querySelectorAll( 'basematerials' );
 
-				resourcesData[ 'basematerials' ] = parseBasematerialsNode( basematerialsNode );
+			for ( var i = 0; i < basematerialsNodes.length; i ++ ) {
+
+				var basematerialsNode = basematerialsNodes[ i ];
+				var basematerialsData = parseBasematerialsNode( basematerialsNode );
+				resourcesData[ 'basematerials' ][ basematerialsData[ 'id' ] ] = basematerialsData;
 
 			}
 
@@ -548,13 +629,39 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 
 			//
 
+			resourcesData[ 'colorgroup' ] = {};
+			var colorGroupNodes = resourcesNode.querySelectorAll( 'colorgroup' );
+
+			for ( var i = 0; i < colorGroupNodes.length; i ++ ) {
+
+				var colorGroupNode = colorGroupNodes[ i ];
+				var colorGroupData = parseColorGroupNode( colorGroupNode );
+				resourcesData[ 'colorgroup' ][ colorGroupData[ 'id' ] ] = colorGroupData;
+
+			}
+
+			//
+
+			resourcesData[ 'pbmetallicdisplayproperties' ] = {};
+			var pbmetallicdisplaypropertiesNodes = resourcesNode.querySelectorAll( 'pbmetallicdisplayproperties' );
+
+			for ( var i = 0; i < pbmetallicdisplaypropertiesNodes.length; i ++ ) {
+
+				var pbmetallicdisplaypropertiesNode = pbmetallicdisplaypropertiesNodes[ i ];
+				var pbmetallicdisplaypropertiesData = parseMetallicDisplaypropertiesNode( pbmetallicdisplaypropertiesNode );
+				resourcesData[ 'pbmetallicdisplayproperties' ][ pbmetallicdisplaypropertiesData[ 'id' ] ] = pbmetallicdisplaypropertiesData;
+
+			}
+
+			//
+
 			resourcesData[ 'texture2dgroup' ] = {};
 			var textures2DGroupNodes = resourcesNode.querySelectorAll( 'texture2dgroup' );
 
 			for ( var i = 0; i < textures2DGroupNodes.length; i ++ ) {
 
 				var textures2DGroupNode = textures2DGroupNodes[ i ];
-				var textures2DGroupData = parseTextures2DGroupNodes( textures2DGroupNode );
+				var textures2DGroupData = parseTextures2DGroupNode( textures2DGroupNode );
 				resourcesData[ 'texture2dgroup' ][ textures2DGroupData[ 'id' ] ] = textures2DGroupData;
 
 			}
@@ -634,371 +741,426 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 
 		}
 
-		function buildGroups( geometry, modelData, meshData ) {
+		function buildTexture( texture2dgroup, objects, modelData, textureData ) {
 
-			var basematerialsData = modelData[ 'resources' ][ 'basematerials' ];
-			var triangleProperties = meshData[ 'triangleProperties' ];
+			var texid = texture2dgroup.texid;
+			var texture2ds = modelData.resources.texture2d;
+			var texture2d = texture2ds[ texid ];
 
-			var start = 0;
-			var count = 0;
-			var currentMaterialIndex = - 1;
+			if ( texture2d ) {
 
-			for ( var i = 0, l = triangleProperties.length; i < l; i ++ ) {
+				var data = textureData[ texture2d.path ];
+				var type = texture2d.contenttype;
 
-				var triangleProperty = triangleProperties[ i ];
-				var pid = triangleProperty.pid;
+				var blob = new Blob( [ data ], { type: type } );
+				var sourceURI = URL.createObjectURL( blob );
 
-				// only proceed if the triangle refers to a basematerials definition
+				var texture = textureLoader.load( sourceURI, function () {
 
-				if ( basematerialsData && ( basematerialsData.id === pid ) ) {
+					URL.revokeObjectURL( sourceURI );
 
-					if ( currentMaterialIndex === - 1 ) currentMaterialIndex = triangleProperty.p1;
+				} );
 
-					if ( currentMaterialIndex === triangleProperty.p1 ) {
+				texture.encoding = THREE.sRGBEncoding;
 
-						count += 3; // primitives per triangle
+				// texture parameters
 
-					} else {
+				switch ( texture2d.tilestyleu ) {
 
-						geometry.addGroup( start, count, currentMaterialIndex );
+					case 'wrap':
+						texture.wrapS = THREE.RepeatWrapping;
+						break;
 
-						start += count;
-						count = 3;
-						currentMaterialIndex = triangleProperty.p1;
+					case 'mirror':
+						texture.wrapS = THREE.MirroredRepeatWrapping;
+						break;
 
-					}
+					case 'none':
+					case 'clamp':
+						texture.wrapS = THREE.ClampToEdgeWrapping;
+						break;
+
+					default:
+						texture.wrapS = THREE.RepeatWrapping;
 
 				}
 
-			}
+				switch ( texture2d.tilestylev ) {
 
-			if ( geometry.groups.length > 0 ) mergeGroups( geometry );
+					case 'wrap':
+						texture.wrapT = THREE.RepeatWrapping;
+						break;
 
-		}
+					case 'mirror':
+						texture.wrapT = THREE.MirroredRepeatWrapping;
+						break;
 
-		function buildGeometry( modelData, meshData, objectData ) {
+					case 'none':
+					case 'clamp':
+						texture.wrapT = THREE.ClampToEdgeWrapping;
+						break;
 
-			var geometry = new THREE.BufferGeometry();
-			geometry.setIndex( new THREE.BufferAttribute( meshData[ 'triangles' ], 1 ) );
-			geometry.setAttribute( 'position', new THREE.BufferAttribute( meshData[ 'vertices' ], 3 ) );
+					default:
+						texture.wrapT = THREE.RepeatWrapping;
 
-			//
+				}
 
-			var texture2dgroups = modelData.resources.texture2dgroup;
+				switch ( texture2d.filter ) {
 
-			if ( texture2dgroups ) {
+					case 'auto':
+						texture.magFilter = THREE.LinearFilter;
+						texture.minFilter = THREE.LinearMipmapLinearFilter;
+						break;
 
-				var textureCoordinates = [];
+					case 'linear':
+						texture.magFilter = THREE.LinearFilter;
+						texture.minFilter = THREE.LinearFilter;
+						break;
 
-				var triangleProperties = meshData[ 'triangleProperties' ];
-				var texture2dgroupObjectLevel;
+					case 'nearest':
+						texture.magFilter = THREE.NearestFilter;
+						texture.minFilter = THREE.NearestFilter;
+						break;
 
-				// check reference to texture coordinates on object level
+					default:
+						texture.magFilter = THREE.LinearFilter;
+						texture.minFilter = THREE.LinearMipmapLinearFilter;
 
-				var texid;
-				var pid = objectData.pid;
+				}
 
-				if ( pid && texture2dgroups[ pid ] ) texture2dgroupObjectLevel = texture2dgroups[ pid ];
+				return texture;
 
-				// process all triangles
+			} else {
 
-				for ( var i = 0, l = triangleProperties.length; i < l; i ++ ) {
+				return null;
 
-					var texture2dgroup = texture2dgroupObjectLevel;
-					var triangleProperty = triangleProperties[ i ];
-					pid = triangleProperty.pid;
+			}
 
-					// overwrite existing resource reference if necessary
+		}
 
-					if ( pid && texture2dgroups[ pid ] ) texture2dgroup = texture2dgroups[ pid ];
+		function buildBasematerialsMeshes( basematerials, triangleProperties, modelData, meshData, textureData, objectData ) {
 
-					if ( texture2dgroup ) {
+			var objectPindex = objectData.pindex;
 
-						texid = texture2dgroup.texid; // the loader only supports a single texture for a single geometry right now (and not per face)
-						var uvs = texture2dgroup.uvs;
+			var materialMap = {};
 
-						textureCoordinates.push( uvs[ ( triangleProperty.p1 * 2 ) + 0 ] );
-						textureCoordinates.push( uvs[ ( triangleProperty.p1 * 2 ) + 1 ] );
+			for ( var i = 0, l = triangleProperties.length; i < l; i ++ ) {
 
-						textureCoordinates.push( uvs[ ( triangleProperty.p2 * 2 ) + 0 ] );
-						textureCoordinates.push( uvs[ ( triangleProperty.p2 * 2 ) + 1 ] );
+				var triangleProperty = triangleProperties[ i ];
+				var pindex = ( triangleProperty.p1 !== undefined ) ? triangleProperty.p1 : objectPindex;
 
-						textureCoordinates.push( uvs[ ( triangleProperty.p3 * 2 ) + 0 ] );
-						textureCoordinates.push( uvs[ ( triangleProperty.p3 * 2 ) + 1 ] );
+				if ( materialMap[ pindex ] === undefined ) materialMap[ pindex ] = [];
 
-					}
+				materialMap[ pindex ].push( triangleProperty );
 
-				}
+			}
 
-				if ( textureCoordinates.length > 0 ) {
+			//
 
-					// uvs are defined on face level so the same vertex can have multiple uv coordinates
+			var keys = Object.keys( materialMap );
+			var meshes = [];
 
-					geometry = geometry.toNonIndexed();
-					geometry.setAttribute( 'uv', new THREE.Float32BufferAttribute( textureCoordinates, 2 ) );
-					geometry.__texid = texid; // save the relationship between texture coordinates and texture
+			for ( var i = 0, l = keys.length; i < l; i ++ ) {
 
-					return geometry;
+				var materialIndex = keys[ i ];
+				var trianglePropertiesProps = materialMap[ materialIndex ];
+				var basematerialData = basematerials.basematerials[ materialIndex ];
+				var material = getBuild( basematerialData, objects, modelData, textureData, objectData, buildBasematerial );
 
-				}
+				//
 
-			}
+				var geometry = new THREE.BufferGeometry();
 
-			return geometry;
+				var positionData = [];
 
-		}
+				var vertices = meshData.vertices;
 
-		function buildTexture( geometry, modelData, textureData ) {
+				for ( var j = 0, jl = trianglePropertiesProps.length; j < jl; j ++ ) {
 
-			var texid = geometry.__texid;
+					var triangleProperty = trianglePropertiesProps[ j ];
 
-			if ( texid !== undefined ) {
+					positionData.push( vertices[ ( triangleProperty.v1 * 3 ) + 0 ] );
+					positionData.push( vertices[ ( triangleProperty.v1 * 3 ) + 1 ] );
+					positionData.push( vertices[ ( triangleProperty.v1 * 3 ) + 2 ] );
 
-				delete geometry.__texid;
+					positionData.push( vertices[ ( triangleProperty.v2 * 3 ) + 0 ] );
+					positionData.push( vertices[ ( triangleProperty.v2 * 3 ) + 1 ] );
+					positionData.push( vertices[ ( triangleProperty.v2 * 3 ) + 2 ] );
 
-				if ( textureMap[ texid ] !== undefined ) {
+					positionData.push( vertices[ ( triangleProperty.v3 * 3 ) + 0 ] );
+					positionData.push( vertices[ ( triangleProperty.v3 * 3 ) + 1 ] );
+					positionData.push( vertices[ ( triangleProperty.v3 * 3 ) + 2 ] );
 
-					return textureMap[ texid ];
 
-				} else {
+				}
 
-					var texture2ds = modelData.resources.texture2d;
-					var texture2d = texture2ds[ texid ];
+				geometry.setAttribute( 'position', new THREE.Float32BufferAttribute( positionData, 3 ) );
 
-					if ( texture2d ) {
+				//
 
-						var data = textureData[ texture2d.path ];
-						var type = texture2d.contenttype;
+				var mesh = new THREE.Mesh( geometry, material );
+				meshes.push( mesh );
 
-						var blob = new Blob( [ data ], { type: type } );
-						var sourceURI = URL.createObjectURL( blob );
+			}
 
-						var texture = textureLoader.load( sourceURI, function () {
+			return meshes;
 
-							URL.revokeObjectURL( sourceURI );
+		}
 
-						} );
+		function buildTexturedMesh( texture2dgroup, triangleProperties, modelData, meshData, textureData, objectData ) {
 
-						texture.encoding = THREE.sRGBEncoding;
+			// geometry
 
-						// texture parameters
+			var geometry = new THREE.BufferGeometry();
 
-						switch ( texture2d.tilestyleu ) {
+			var positionData = [];
+			var uvData = [];
 
-							case 'wrap':
-								texture.wrapS = THREE.RepeatWrapping;
-								break;
+			var vertices = meshData.vertices;
+			var uvs = texture2dgroup.uvs;
 
-							case 'mirror':
-								texture.wrapS = THREE.MirroredRepeatWrapping;
-								break;
+			for ( var i = 0, l = triangleProperties.length; i < l; i ++ ) {
 
-							case 'none':
-							case 'clamp':
-								texture.wrapS = THREE.ClampToEdgeWrapping;
-								break;
+				var triangleProperty = triangleProperties[ i ];
 
-							default:
-								texture.wrapS = THREE.RepeatWrapping;
+				positionData.push( vertices[ ( triangleProperty.v1 * 3 ) + 0 ] );
+				positionData.push( vertices[ ( triangleProperty.v1 * 3 ) + 1 ] );
+				positionData.push( vertices[ ( triangleProperty.v1 * 3 ) + 2 ] );
 
-						}
+				positionData.push( vertices[ ( triangleProperty.v2 * 3 ) + 0 ] );
+				positionData.push( vertices[ ( triangleProperty.v2 * 3 ) + 1 ] );
+				positionData.push( vertices[ ( triangleProperty.v2 * 3 ) + 2 ] );
 
-						switch ( texture2d.tilestylev ) {
+				positionData.push( vertices[ ( triangleProperty.v3 * 3 ) + 0 ] );
+				positionData.push( vertices[ ( triangleProperty.v3 * 3 ) + 1 ] );
+				positionData.push( vertices[ ( triangleProperty.v3 * 3 ) + 2 ] );
 
-							case 'wrap':
-								texture.wrapT = THREE.RepeatWrapping;
-								break;
+				//
 
-							case 'mirror':
-								texture.wrapT = THREE.MirroredRepeatWrapping;
-								break;
+				uvData.push( uvs[ ( triangleProperty.p1 * 2 ) + 0 ] );
+				uvData.push( uvs[ ( triangleProperty.p1 * 2 ) + 1 ] );
 
-							case 'none':
-							case 'clamp':
-								texture.wrapT = THREE.ClampToEdgeWrapping;
-								break;
+				uvData.push( uvs[ ( triangleProperty.p2 * 2 ) + 0 ] );
+				uvData.push( uvs[ ( triangleProperty.p2 * 2 ) + 1 ] );
 
-							default:
-								texture.wrapT = THREE.RepeatWrapping;
+				uvData.push( uvs[ ( triangleProperty.p3 * 2 ) + 0 ] );
+				uvData.push( uvs[ ( triangleProperty.p3 * 2 ) + 1 ] );
 
-						}
+			}
 
-						switch ( texture2d.filter ) {
+			geometry.setAttribute( 'position', new THREE.Float32BufferAttribute( positionData, 3 ) );
+			geometry.setAttribute( 'uv', new THREE.Float32BufferAttribute( uvData, 2 ) );
 
-							case 'auto':
-								texture.magFilter = THREE.LinearFilter;
-								texture.minFilter = THREE.LinearMipmapLinearFilter;
-								break;
+			// material
 
-							case 'linear':
-								texture.magFilter = THREE.LinearFilter;
-								texture.minFilter = THREE.LinearFilter;
-								break;
+			var texture = getBuild( texture2dgroup, objects, modelData, textureData, objectData, buildTexture );
 
-							case 'nearest':
-								texture.magFilter = THREE.NearestFilter;
-								texture.minFilter = THREE.NearestFilter;
-								break;
+			var material = new THREE.MeshPhongMaterial( { map: texture, flatShading: true } );
 
-							default:
-								texture.magFilter = THREE.LinearFilter;
-								texture.minFilter = THREE.LinearMipmapLinearFilter;
+			// mesh
 
-						}
+			var mesh = new THREE.Mesh( geometry, material );
 
-						textureMap[ texid ] = texture;
+			return mesh;
 
-						return texture;
+		}
 
-					}
+		function buildVertexColorMesh( colorgroup, triangleProperties, modelData, meshData ) {
 
-				}
+			// geometry
 
-			}
+			var geometry = new THREE.BufferGeometry();
 
-			return null;
+			var positionData = [];
+			var colorData = [];
 
-		}
+			var vertices = meshData.vertices;
+			var colors = colorgroup.colors;
 
-		function buildMesh( meshData, objects, modelData, textureData, objectData ) {
+			for ( var i = 0, l = triangleProperties.length; i < l; i ++ ) {
 
-			var geometry = buildGeometry( modelData, meshData, objectData );
-			var texture = buildTexture( geometry, modelData, textureData );
+				var triangleProperty = triangleProperties[ i ];
 
-			// groups
+				var v1 = triangleProperty.v1;
+				var v2 = triangleProperty.v2;
+				var v3 = triangleProperty.v3;
 
-			buildGroups( geometry, modelData, meshData );
+				positionData.push( vertices[ ( v1 * 3 ) + 0 ] );
+				positionData.push( vertices[ ( v1 * 3 ) + 1 ] );
+				positionData.push( vertices[ ( v1 * 3 ) + 2 ] );
 
-			// material
+				positionData.push( vertices[ ( v2 * 3 ) + 0 ] );
+				positionData.push( vertices[ ( v2 * 3 ) + 1 ] );
+				positionData.push( vertices[ ( v2 * 3 ) + 2 ] );
 
-			var material = null;
+				positionData.push( vertices[ ( v3 * 3 ) + 0 ] );
+				positionData.push( vertices[ ( v3 * 3 ) + 1 ] );
+				positionData.push( vertices[ ( v3 * 3 ) + 2 ] );
 
-			// add material if an object-level definition is present
+				//
 
-			var basematerialsData = modelData[ 'resources' ][ 'basematerials' ];
+				var p1 = triangleProperty.p1;
+				var p2 = triangleProperty.p2;
+				var p3 = triangleProperty.p3;
 
-			if ( basematerialsData && ( basematerialsData.id === objectData.pid ) ) {
+				colorData.push( colors[ ( p1 * 3 ) + 0 ] );
+				colorData.push( colors[ ( p1 * 3 ) + 1 ] );
+				colorData.push( colors[ ( p1 * 3 ) + 2 ] );
 
-				var materialIndex = objectData.pindex;
-				var basematerialData = basematerialsData.basematerials[ materialIndex ];
+				colorData.push( colors[ ( ( p2 || p1 ) * 3 ) + 0 ] );
+				colorData.push( colors[ ( ( p2 || p1 ) * 3 ) + 1 ] );
+				colorData.push( colors[ ( ( p2 || p1 ) * 3 ) + 2 ] );
 
-				material = getBuild( basematerialData, objects, modelData, textureData, objectData, buildBasematerial );
+				colorData.push( colors[ ( ( p3 || p1 ) * 3 ) + 0 ] );
+				colorData.push( colors[ ( ( p3 || p1 ) * 3 ) + 1 ] );
+				colorData.push( colors[ ( ( p3 || p1 ) * 3 ) + 2 ] );
 
 			}
 
-			// add/overwrite material if definitions on triangles are present
+			geometry.setAttribute( 'position', new THREE.Float32BufferAttribute( positionData, 3 ) );
+			geometry.setAttribute( 'color', new THREE.Float32BufferAttribute( colorData, 3 ) );
 
-			if ( geometry.groups.length > 0 ) {
+			// material
 
-				var groups = geometry.groups;
-				material = [];
+			var material = new THREE.MeshPhongMaterial( { vertexColors: THREE.VertexColors, flatShading: true } );
 
-				for ( var i = 0, l = groups.length; i < l; i ++ ) {
+			// mesh
 
-					var group = groups[ i ];
-					var basematerialData = basematerialsData.basematerials[ group.materialIndex ];
-					material.push( getBuild( basematerialData, objects, modelData, textureData, objectData, buildBasematerial ) );
+			var mesh = new THREE.Mesh( geometry, material );
 
-				}
+			return mesh;
 
-			}
+		}
 
-			// default material
+		function buildDefaultMesh( meshData ) {
 
-			if ( material === null ) {
+			var geometry = new THREE.BufferGeometry();
+			geometry.setIndex( new THREE.BufferAttribute( meshData[ 'triangles' ], 1 ) );
+			geometry.setAttribute( 'position', new THREE.BufferAttribute( meshData[ 'vertices' ], 3 ) );
 
-				if ( texture === null ) {
+			var material = new THREE.MeshPhongMaterial( { color: 0xaaaaff, flatShading: true } );
 
-					material = new THREE.MeshPhongMaterial( { color: 0xaaaaff, flatShading: true } );
+			var mesh = new THREE.Mesh( geometry, material );
 
-				} else {
+			return mesh;
 
-					material = new THREE.MeshPhongMaterial( { map: texture, flatShading: true } );
+		}
 
-				}
+		function buildMeshes( resourceMap, modelData, meshData, textureData, objectData ) {
 
-			}
+			var keys = Object.keys( resourceMap );
+			var meshes = [];
 
-			return new THREE.Mesh( geometry, material );
+			for ( var i = 0, il = keys.length; i < il; i ++ ) {
 
-		}
+				var resourceId = keys[ i ];
+				var triangleProperties = resourceMap[ resourceId ];
+				var resourceType = getResourceType( resourceId, modelData );
 
-		function mergeGroups( geometry ) {
+				switch ( resourceType ) {
 
-			// sort by material index
+					case 'material':
+						var basematerials = modelData.resources.basematerials[ resourceId ];
+						var newMeshes = buildBasematerialsMeshes( basematerials, triangleProperties, modelData, meshData, textureData, objectData );
 
-			var groups = geometry.groups.sort( function ( a, b ) {
+						for ( var j = 0, jl = newMeshes.length; j < jl; j ++ ) {
 
-				if ( a.materialIndex !== b.materialIndex ) return a.materialIndex - b.materialIndex;
+							meshes.push( newMeshes[ j ] );
 
-				return a.start - b.start;
+						}
+						break;
 
-			} );
+					case 'texture':
+						var texture2dgroup = modelData.resources.texture2dgroup[ resourceId ];
+						meshes.push( buildTexturedMesh( texture2dgroup, triangleProperties, modelData, meshData, textureData ) );
+						break;
 
-			// reorganize index buffer
+					case 'vertexColors':
+						var colorgroup = modelData.resources.colorgroup[ resourceId ];
+						meshes.push( buildVertexColorMesh( colorgroup, triangleProperties, modelData, meshData, textureData ) );
+						break;
 
-			var index = geometry.index;
+					case 'default':
+						meshes.push( buildDefaultMesh( meshData ) );
+						break;
 
-			var itemSize = index.itemSize;
-			var srcArray = index.array;
+					default:
+						console.error( 'THREE.3MFLoader: Unsupported resource type.' );
 
-			var targetOffset = 0;
+				}
 
-			var targetArray = new srcArray.constructor( srcArray.length );
+			}
 
-			for ( var i = 0; i < groups.length; i ++ ) {
+			return meshes;
 
-				var group = groups[ i ];
+		}
 
-				var groupLength = group.count * itemSize;
-				var groupStart = group.start * itemSize;
+		function getResourceType( pid, modelData ) {
 
-				var sub = srcArray.subarray( groupStart, groupStart + groupLength );
+			if ( modelData.resources.texture2dgroup[ pid ] !== undefined ) {
 
-				targetArray.set( sub, targetOffset );
+				return 'texture';
 
-				targetOffset += groupLength;
+			} else if ( modelData.resources.basematerials[ pid ] !== undefined ) {
 
-			}
+				return 'material';
 
-			srcArray.set( targetArray );
+			} else if ( modelData.resources.colorgroup[ pid ] !== undefined ) {
 
-			// update groups
+				return 'vertexColors';
 
-			var start = 0;
+			} else if ( pid === 'default' ) {
 
-			for ( i = 0; i < groups.length; i ++ ) {
+				return 'default';
 
-				group = groups[ i ];
+			} else {
 
-				group.start = start;
-				start += group.count;
+				return undefined;
 
 			}
 
-			// merge groups
+		}
 
-			var lastGroup = groups[ 0 ];
+		function analyzeObject( modelData, meshData, objectData ) {
 
-			geometry.groups = [ lastGroup ];
+			var resourceMap = {};
 
-			for ( i = 1; i < groups.length; i ++ ) {
+			var triangleProperties = meshData[ 'triangleProperties' ];
 
-				group = groups[ i ];
+			var objectPid = objectData.pid;
 
-				if ( lastGroup.materialIndex === group.materialIndex ) {
+			for ( var i = 0, l = triangleProperties.length; i < l; i ++ ) {
 
-					lastGroup.count += group.count;
+				var triangleProperty = triangleProperties[ i ];
+				var pid = ( triangleProperty.pid !== undefined ) ? triangleProperty.pid : objectPid;
 
-				} else {
+				if ( pid === undefined ) pid = 'default';
 
-					lastGroup = group;
-					geometry.groups.push( lastGroup );
+				if ( resourceMap[ pid ] === undefined ) resourceMap[ pid ] = [];
 
-				}
+				resourceMap[ pid ].push( triangleProperty );
+
+			}
+
+			return resourceMap;
+
+		}
+
+		function buildGroup( meshData, objects, modelData, textureData, objectData ) {
+
+			var group = new THREE.Group();
+
+			var resourceMap = analyzeObject( modelData, meshData, objectData );
+			var meshes = buildMeshes( resourceMap, modelData, meshData, textureData, objectData );
+
+			for ( var i = 0, l = meshes.length; i < l; i ++ ) {
+
+				group.add( meshes[ i ] );
 
 			}
 
+			return group;
+
 		}
 
 		function applyExtensions( extensions, meshData, modelXml ) {
@@ -1049,9 +1211,29 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 
 		}
 
-		function buildBasematerial( materialData ) {
+		function buildBasematerial( materialData, objects, modelData ) {
+
+			var material;
 
-			var material = new THREE.MeshPhongMaterial( { flatShading: true } );
+			var displaypropertiesid = materialData.displaypropertiesid;
+			var pbmetallicdisplayproperties = modelData.resources.pbmetallicdisplayproperties;
+
+			if ( displaypropertiesid !== null && pbmetallicdisplayproperties[ displaypropertiesid ] !== undefined ) {
+
+				// metallic display property, use StandardMaterial
+
+				var pbmetallicdisplayproperty = pbmetallicdisplayproperties[ displaypropertiesid ];
+				var metallicData = pbmetallicdisplayproperty.data[ materialData.index ];
+
+				material = new THREE.MeshStandardMaterial( { flatShading: true, roughness: metallicData.roughness, metalness: metallicData.metallicness } );
+
+			} else {
+
+				// otherwise use PhongMaterial
+
+				material = new THREE.MeshPhongMaterial( { flatShading: true } );
+
+			}
 
 			material.name = materialData.name;
 
@@ -1124,7 +1306,7 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 
 				applyExtensions( extensions, meshData, modelXml );
 
-				objects[ objectData.id ] = getBuild( meshData, objects, modelData, textureData, objectData, buildMesh );
+				objects[ objectData.id ] = getBuild( meshData, objects, modelData, textureData, objectData, buildGroup );
 
 			} else {
 
@@ -1144,15 +1326,20 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 			var modelsKeys = Object.keys( modelsData );
 			var textureData = {};
 
-			// evaluate model relationship to a texture
+			// evaluate model relationships to textures
 
 			if ( modelRels ) {
 
-				var textureKey = modelRels.target.substring( 1 );
+				for ( var i = 0, l = modelRels.length; i < l; i ++ ) {
 
-				if ( data3mf.texture[ textureKey ] ) {
+					var modelRel = modelRels[ i ];
+					var textureKey = modelRel.target.substring( 1 );
 
-					textureData[ modelRels.target ] = data3mf.texture[ textureKey ];
+					if ( data3mf.texture[ textureKey ] ) {
+
+						textureData[ modelRel.target ] = data3mf.texture[ textureKey ];
+
+					}
 
 				}
 
@@ -1181,10 +1368,12 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 
 		}
 
-		function build( objects, refs, data3mf ) {
+		function build( objects, data3mf ) {
 
 			var group = new THREE.Group();
-			var buildData = data3mf.model[ refs[ 'target' ].substring( 1 ) ][ 'build' ];
+
+			var relationship = data3mf[ 'rels' ][ 0 ];
+			var buildData = data3mf.model[ relationship[ 'target' ].substring( 1 ) ][ 'build' ];
 
 			for ( var i = 0; i < buildData.length; i ++ ) {
 
@@ -1212,7 +1401,7 @@ THREE.ThreeMFLoader.prototype = Object.assign( Object.create( THREE.Loader.proto
 		var data3mf = loadDocument( data );
 		var objects = buildObjects( data3mf );
 
-		return build( objects, data3mf[ 'rels' ], data3mf );
+		return build( objects, data3mf );
 
 	},
 

examples/js/loaders/PCDLoader.js

@@ -3,9 +3,6 @@
  * @author Mugen87 / https://github.com/Mugen87
  *
  * Description: A THREE loader for PCD ascii and binary files.
- *
- * Limitations: Compressed binary files are not supported.
- *
  */
 
 THREE.PCDLoader = function ( manager ) {
@@ -54,6 +51,60 @@ THREE.PCDLoader.prototype = Object.assign( Object.create( THREE.Loader.prototype
 
 	parse: function ( data, url ) {
 
+		// from https://gitlab.com/taketwo/three-pcd-loader/blob/master/decompress-lzf.js
+
+		function decompressLZF( inData, outLength ) {
+
+			var inLength = inData.length;
+			var outData = new Uint8Array( outLength );
+			var inPtr = 0;
+			var outPtr = 0;
+			var ctrl;
+			var len;
+			var ref;
+			do {
+
+				ctrl = inData[ inPtr ++ ];
+				if ( ctrl < ( 1 << 5 ) ) {
+
+					ctrl ++;
+					if ( outPtr + ctrl > outLength ) throw new Error( 'Output buffer is not large enough' );
+					if ( inPtr + ctrl > inLength ) throw new Error( 'Invalid compressed data' );
+					do {
+
+						outData[ outPtr ++ ] = inData[ inPtr ++ ];
+
+					} while ( -- ctrl );
+
+				} else {
+
+					len = ctrl >> 5;
+					ref = outPtr - ( ( ctrl & 0x1f ) << 8 ) - 1;
+					if ( inPtr >= inLength ) throw new Error( 'Invalid compressed data' );
+					if ( len === 7 ) {
+
+						len += inData[ inPtr ++ ];
+						if ( inPtr >= inLength ) throw new Error( 'Invalid compressed data' );
+
+					}
+					ref -= inData[ inPtr ++ ];
+					if ( outPtr + len + 2 > outLength ) throw new Error( 'Output buffer is not large enough' );
+					if ( ref < 0 ) throw new Error( 'Invalid compressed data' );
+					if ( ref >= outPtr ) throw new Error( 'Invalid compressed data' );
+					do {
+
+						outData[ outPtr ++ ] = outData[ ref ++ ];
+
+					} while ( -- len + 2 );
+
+				}
+
+			} while ( inPtr < inLength );
+
+			return outData;
+
+		}
+
 		function parseHeader( data ) {
 
 			var PCDheader = {};
@@ -219,15 +270,54 @@ THREE.PCDLoader.prototype = Object.assign( Object.create( THREE.Loader.prototype
 
 		}
 
-		// binary
+		// binary-compressed
+
+		// normally data in PCD files are organized as array of structures: XYZRGBXYZRGB
+		// binary compressed PCD files organize their data as structure of arrays: XXYYZZRGBRGB
+		// that requires a totally different parsing approach compared to non-compressed data
 
 		if ( PCDheader.data === 'binary_compressed' ) {
 
-			console.error( 'THREE.PCDLoader: binary_compressed files are not supported' );
-			return;
+			var sizes = new Uint32Array( data.slice( PCDheader.headerLen, PCDheader.headerLen + 8 ) );
+			var compressedSize = sizes[ 0 ];
+			var decompressedSize = sizes[ 1 ];
+			var decompressed = decompressLZF( new Uint8Array( data, PCDheader.headerLen + 8, compressedSize ), decompressedSize );
+			var dataview = new DataView( decompressed.buffer );
+
+			var offset = PCDheader.offset;
+
+			for ( var i = 0; i < PCDheader.points; i ++ ) {
+
+				if ( offset.x !== undefined ) {
+
+					position.push( dataview.getFloat32( ( PCDheader.points * offset.x ) + PCDheader.size[ 0 ] * i, this.littleEndian ) );
+					position.push( dataview.getFloat32( ( PCDheader.points * offset.y ) + PCDheader.size[ 1 ] * i, this.littleEndian ) );
+					position.push( dataview.getFloat32( ( PCDheader.points * offset.z ) + PCDheader.size[ 2 ] * i, this.littleEndian ) );
+
+				}
+
+				if ( offset.rgb !== undefined ) {
+
+					color.push( dataview.getUint8( ( PCDheader.points * ( offset.rgb + 2 ) + PCDheader.size[ 3 ] * i ) / 255.0 ) );
+					color.push( dataview.getUint8( ( PCDheader.points * ( offset.rgb + 1 ) + PCDheader.size[ 3 ] * i ) / 255.0 ) );
+					color.push( dataview.getUint8( ( PCDheader.points * ( offset.rgb + 0 ) + PCDheader.size[ 3 ] * i ) / 255.0 ) );
+
+				}
+
+				if ( offset.normal_x !== undefined ) {
+
+					normal.push( dataview.getFloat32( ( PCDheader.points * offset.normal_x ) + PCDheader.size[ 4 ] * i, this.littleEndian ) );
+					normal.push( dataview.getFloat32( ( PCDheader.points * offset.normal_y ) + PCDheader.size[ 5 ] * i, this.littleEndian ) );
+					normal.push( dataview.getFloat32( ( PCDheader.points * offset.normal_z ) + PCDheader.size[ 6 ] * i, this.littleEndian ) );
+
+				}
+
+			}
 
 		}
 
+		// binary
+
 		if ( PCDheader.data === 'binary' ) {
 
 			var dataview = new DataView( data, PCDheader.headerLen );
@@ -287,7 +377,7 @@ THREE.PCDLoader.prototype = Object.assign( Object.create( THREE.Loader.prototype
 
 		}
 
-		// build mesh
+		// build point cloud
 
 		var mesh = new THREE.Points( geometry, material );
 		var name = url.split( '' ).reverse().join( '' );

examples/js/renderers/CSS2DRenderer.js

@@ -11,11 +11,15 @@ THREE.CSS2DObject = function ( element ) {
 
 	this.addEventListener( 'removed', function () {
 
-		if ( this.element.parentNode !== null ) {
+		this.traverse( function ( object ) {
 
-			this.element.parentNode.removeChild( this.element );
+			if ( object.element instanceof Element && object.element.parentNode !== null ) {
 
-		}
+				object.element.parentNode.removeChild( object.element );
+
+			}
+
+		} );
 
 	} );
 

examples/js/renderers/CSS3DRenderer.js

@@ -13,11 +13,15 @@ THREE.CSS3DObject = function ( element ) {
 
 	this.addEventListener( 'removed', function () {
 
-		if ( this.element.parentNode !== null ) {
+		this.traverse( function ( object ) {
 
-			this.element.parentNode.removeChild( this.element );
+			if ( object.element instanceof Element && object.element.parentNode !== null ) {
 
-		}
+				object.element.parentNode.removeChild( object.element );
+
+			}
+
+		} );
 
 	} );
 
@@ -279,6 +283,11 @@ THREE.CSS3DRenderer = function () {
 				domElement.style.WebkitPerspective = fov + 'px';
 				domElement.style.perspective = fov + 'px';
 
+			} else {
+
+				domElement.style.WebkitPerspective = '';
+				domElement.style.perspective = '';
+
 			}
 
 			cache.camera.fov = fov;

examples/js/vr/HelioWebXRPolyfill.js

@@ -2,7 +2,7 @@
  * @author mvilledieu / http://github.com/mvilledieu
  */
 
-if ( /(Helio)/g.test( navigator.userAgent ) && "xr" in navigator ) {
+if ( /(Helio)/g.test( navigator.userAgent ) && "xr" in navigator && 'isSessionSupported' in navigator.xr === false) {
 
 	console.log( "Helio WebXR Polyfill (Lumin 0.97.0)" );
 
@@ -12,10 +12,10 @@ if ( /(Helio)/g.test( navigator.userAgent ) && "xr" in navigator ) {
 
 	if (
 		"supportsSession" in navigator.xr === false &&
-    "supportsSessionMode" in navigator.xr
+	"supportsSessionMode" in navigator.xr
 	) {
 
-		navigator.xr.supportsSession = function ( sessionType ) {
+		navigator.xr.supportsSession = function ( /*sessionType*/ ) {
 
 			// Force using immersive-ar
 			return navigator.xr.supportsSessionMode( 'immersive-ar' );
@@ -28,7 +28,7 @@ if ( /(Helio)/g.test( navigator.userAgent ) && "xr" in navigator ) {
 
 		const tempRequestSession = navigator.xr.requestSession.bind( navigator.xr );
 
-		navigator.xr.requestSession = function ( sessionType ) {
+		navigator.xr.requestSession = function ( /*sessionType*/ ) {
 
 			return new Promise( function ( resolve, reject ) {
 

examples/js/vr/WebVR.js

@@ -169,7 +169,7 @@ THREE.WEBVR = {
 
 		}
 
-		if ( 'xr' in navigator && 'isSessionSupported' in navigator.xr ) {
+		if ( 'xr' in navigator ) {
 
 			var button = document.createElement( 'button' );
 			button.style.display = 'none';

examples/jsm/controls/OrbitControls.js

@@ -268,7 +268,7 @@ var OrbitControls = function ( object, domElement ) {
 		document.removeEventListener( 'mousemove', onMouseMove, false );
 		document.removeEventListener( 'mouseup', onMouseUp, false );
 
-		window.removeEventListener( 'keydown', onKeyDown, false );
+		scope.domElement.removeEventListener( 'keydown', onKeyDown, false );
 
 		//scope.dispatchEvent( { type: 'dispose' } ); // should this be added here?
 
@@ -1146,7 +1146,15 @@ var OrbitControls = function ( object, domElement ) {
 	scope.domElement.addEventListener( 'touchend', onTouchEnd, false );
 	scope.domElement.addEventListener( 'touchmove', onTouchMove, false );
 
-	window.addEventListener( 'keydown', onKeyDown, false );
+	scope.domElement.addEventListener( 'keydown', onKeyDown, false );
+
+	// make sure element can receive keys.
+
+	if ( scope.domElement.tabIndex === - 1 ) {
+
+		scope.domElement.tabIndex = 0;
+
+	}
 
 	// force an update at start
 

examples/jsm/lights/LightProbeGenerator.d.ts

@@ -1,10 +1,13 @@
 import {
 	CubeTexture,
-	LightProbe
+	LightProbe,
+	WebGLRenderer,
+	WebGLRenderTargetCube,
 } from '../../../src/Three';
 
 export namespace LightProbeGenerator {
 
-	export function fromCubeTexture( cubeTexture: CubeTexture ): LightProbe;
+	export function fromCubeTexture(cubeTexture: CubeTexture): LightProbe;
+	export function fromRenderTargetCube(renderer: WebGLRenderer, renderTargetCube: WebGLRenderTargetCube): LightProbe;
 
 }

examples/jsm/lights/LightProbeGenerator.js

@@ -5,8 +5,10 @@
 import {
 	Color,
 	LightProbe,
+	LinearEncoding,
 	SphericalHarmonics3,
-	Vector3
+	Vector3,
+	sRGBEncoding
 } from "../../../build/three.module.js";
 
 var LightProbeGenerator = {
@@ -57,7 +59,7 @@ var LightProbeGenerator = {
 				color.setRGB( data[ i ] / 255, data[ i + 1 ] / 255, data[ i + 2 ] / 255 );
 
 				// convert to linear color space
-				color.copySRGBToLinear( color );
+				convertColorToLinear( color, cubeTexture.encoding );
 
 				// pixel coordinate on unit cube
 
@@ -123,8 +125,130 @@ var LightProbeGenerator = {
 
 		return new LightProbe( sh );
 
+	},
+
+	fromRenderTargetCube: function ( renderer, renderTargetCube ) {
+
+		// The renderTarget must be set to RGBA in order to make readRenderTargetPixels works
+		var norm, lengthSq, weight, totalWeight = 0;
+
+		var coord = new Vector3();
+
+		var dir = new Vector3();
+
+		var color = new Color();
+
+		var shBasis = [ 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
+
+		var sh = new SphericalHarmonics3();
+		var shCoefficients = sh.coefficients;
+
+		for ( var faceIndex = 0; faceIndex < 6; faceIndex ++ ) {
+
+			var imageWidth = renderTargetCube.width; // assumed to be square
+			var data = new Uint8Array( imageWidth * imageWidth * 4 );
+			renderer.readRenderTargetPixels( renderTargetCube, 0, 0, imageWidth, imageWidth, data, faceIndex );
+
+			var pixelSize = 2 / imageWidth;
+
+			for ( var i = 0, il = data.length; i < il; i += 4 ) { // RGBA assumed
+
+				// pixel color
+				color.setRGB( data[ i ] / 255, data[ i + 1 ] / 255, data[ i + 2 ] / 255 );
+
+				// convert to linear color space
+				convertColorToLinear( color, renderTargetCube.texture.encoding );
+
+				// pixel coordinate on unit cube
+
+				var pixelIndex = i / 4;
+
+				var col = - 1 + ( pixelIndex % imageWidth + 0.5 ) * pixelSize;
+
+				var row = 1 - ( Math.floor( pixelIndex / imageWidth ) + 0.5 ) * pixelSize;
+
+				switch ( faceIndex ) {
+
+					case 0: coord.set( 1, row, - col ); break;
+
+					case 1: coord.set( - 1, row, col ); break;
+
+					case 2: coord.set( col, 1, - row ); break;
+
+					case 3: coord.set( col, - 1, row ); break;
+
+					case 4: coord.set( col, row, 1 ); break;
+
+					case 5: coord.set( - col, row, - 1 ); break;
+
+				}
+
+				// weight assigned to this pixel
+
+				lengthSq = coord.lengthSq();
+
+				weight = 4 / ( Math.sqrt( lengthSq ) * lengthSq );
+
+				totalWeight += weight;
+
+				// direction vector to this pixel
+				dir.copy( coord ).normalize();
+
+				// evaluate SH basis functions in direction dir
+				SphericalHarmonics3.getBasisAt( dir, shBasis );
+
+				// accummuulate
+				for ( var j = 0; j < 9; j ++ ) {
+
+					shCoefficients[ j ].x += shBasis[ j ] * color.r * weight;
+					shCoefficients[ j ].y += shBasis[ j ] * color.g * weight;
+					shCoefficients[ j ].z += shBasis[ j ] * color.b * weight;
+
+				}
+
+			}
+
+		}
+
+		// normalize
+		norm = ( 4 * Math.PI ) / totalWeight;
+
+		for ( var j = 0; j < 9; j ++ ) {
+
+			shCoefficients[ j ].x *= norm;
+			shCoefficients[ j ].y *= norm;
+			shCoefficients[ j ].z *= norm;
+
+		}
+
+		return new LightProbe( sh );
+
+	}
+
+};
+
+var convertColorToLinear = function ( color, encoding ) {
+
+	switch ( encoding ) {
+
+		case sRGBEncoding:
+
+			color.convertSRGBToLinear();
+			break;
+
+		case LinearEncoding:
+
+			break;
+
+		default:
+
+			console.warn( 'WARNING: LightProbeGenerator convertColorToLinear() encountered an unsupported encoding.' );
+			break;
+
 	}
 
+	return color;
+
 };
 
 export { LightProbeGenerator };

examples/jsm/loaders/3MFLoader.js

@@ -14,12 +14,15 @@
  *
  * - Texture 2D
  * - Texture 2D Groups
+ * - Color Groups (Vertex Colors)
+ * - Metallic Display Properties (PBR)
  */
 
 import {
 	BufferAttribute,
 	BufferGeometry,
 	ClampToEdgeWrapping,
+	Color,
 	FileLoader,
 	Float32BufferAttribute,
 	Group,
@@ -30,10 +33,12 @@ import {
 	Matrix4,
 	Mesh,
 	MeshPhongMaterial,
+	MeshStandardMaterial,
 	MirroredRepeatWrapping,
 	NearestFilter,
 	RepeatWrapping,
 	TextureLoader,
+	VertexColors,
 	sRGBEncoding
 } from "../../../build/three.module.js";
 
@@ -67,7 +72,6 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 
 		var scope = this;
 		var textureLoader = new TextureLoader( this.manager );
-		var textureMap = {};
 
 		function loadDocument( data ) {
 
@@ -121,7 +125,7 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 
 					printTicketPartNames.push( file );
 
-				} else if ( file.match( /^3D\/Texture\/.*/ ) ) {
+				} else if ( file.match( /^3D\/Textures?\/.*/ ) ) {
 
 					texturesPartNames.push( file );
 
@@ -214,17 +218,27 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 
 		function parseRelsXml( relsFileText ) {
 
+			var relationships = [];
+
 			var relsXmlData = new DOMParser().parseFromString( relsFileText, 'application/xml' );
-			var relsNode = relsXmlData.querySelector( 'Relationship' );
-			var target = relsNode.getAttribute( 'Target' );
-			var id = relsNode.getAttribute( 'Id' );
-			var type = relsNode.getAttribute( 'Type' );
 
-			return {
-				target: target,
-				id: id,
-				type: type
-			};
+			var relsNodes = relsXmlData.querySelectorAll( 'Relationship' );
+
+			for ( var i = 0; i < relsNodes.length; i ++ ) {
+
+				var relsNode = relsNodes[ i ];
+
+				var relationship = {
+					target: relsNode.getAttribute( 'Target' ), //required
+					id: relsNode.getAttribute( 'Id' ), //required
+					type: relsNode.getAttribute( 'Type' ) //required
+				};
+
+				relationships.push( relationship );
+
+			}
+
+			return relationships;
 
 		}
 
@@ -272,6 +286,7 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 
 				var basematerialNode = basematerialNodes[ i ];
 				var basematerialData = parseBasematerialNode( basematerialNode );
+				basematerialData.index = i; // the order and count of the material nodes form an implicit 0-based index
 				basematerialsData.basematerials.push( basematerialData );
 
 			}
@@ -295,7 +310,7 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 
 		}
 
-		function parseTextures2DGroupNodes( texture2DGroupNode ) {
+		function parseTextures2DGroupNode( texture2DGroupNode ) {
 
 			var texture2DGroupData = {
 				id: texture2DGroupNode.getAttribute( 'id' ), // required
@@ -323,12 +338,71 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 
 		}
 
+		function parseColorGroupNode( colorGroupNode ) {
+
+			var colorGroupData = {
+				id: colorGroupNode.getAttribute( 'id' ), // required
+				displaypropertiesid: colorGroupNode.getAttribute( 'displaypropertiesid' )
+			};
+
+			var colorNodes = colorGroupNode.querySelectorAll( 'color' );
+
+			var colors = [];
+			var colorObject = new Color();
+
+			for ( var i = 0; i < colorNodes.length; i ++ ) {
+
+				var colorNode = colorNodes[ i ];
+				var color = colorNode.getAttribute( 'color' );
+
+				colorObject.setStyle( color.substring( 0, 7 ) );
+				colorObject.convertSRGBToLinear(); // color is in sRGB
+
+				colors.push( colorObject.r, colorObject.g, colorObject.b );
+
+			}
+
+			colorGroupData[ 'colors' ] = new Float32Array( colors );
+
+			return colorGroupData;
+
+		}
+
+		function parseMetallicDisplaypropertiesNode( metallicDisplaypropetiesNode ) {
+
+			var metallicDisplaypropertiesData = {
+				id: metallicDisplaypropetiesNode.getAttribute( 'id' ) // required
+			};
+
+			var metallicNodes = metallicDisplaypropetiesNode.querySelectorAll( 'pbmetallic' );
+
+			var metallicData = [];
+
+			for ( var i = 0; i < metallicNodes.length; i ++ ) {
+
+				var metallicNode = metallicNodes[ i ];
+
+				metallicData.push( {
+					name: metallicNode.getAttribute( 'name' ), // required
+					metallicness: parseFloat( metallicNode.getAttribute( 'metallicness' ) ), // required
+					roughness: parseFloat( metallicNode.getAttribute( 'roughness' ) ) // required
+				} );
+
+			}
+
+			metallicDisplaypropertiesData.data = metallicData;
+
+			return metallicDisplaypropertiesData;
+
+		}
+
 		function parseBasematerialNode( basematerialNode ) {
 
 			var basematerialData = {};
 
 			basematerialData[ 'name' ] = basematerialNode.getAttribute( 'name' ); // required
 			basematerialData[ 'displaycolor' ] = basematerialNode.getAttribute( 'displaycolor' ); // required
+			basematerialData[ 'displaypropertiesid' ] = basematerialNode.getAttribute( 'displaypropertiesid' );
 
 			return basematerialData;
 
@@ -369,10 +443,16 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 				var p3 = triangleNode.getAttribute( 'p3' );
 				var pid = triangleNode.getAttribute( 'pid' );
 
-				triangles.push( parseInt( v1, 10 ), parseInt( v2, 10 ), parseInt( v3, 10 ) );
-
 				var triangleProperty = {};
 
+				triangleProperty[ 'v1' ] = parseInt( v1, 10 );
+				triangleProperty[ 'v2' ] = parseInt( v2, 10 );
+				triangleProperty[ 'v3' ] = parseInt( v3, 10 );
+
+				triangles.push( triangleProperty[ 'v1' ], triangleProperty[ 'v2' ], triangleProperty[ 'v3' ] );
+
+				// optional
+
 				if ( p1 ) {
 
 					triangleProperty[ 'p1' ] = parseInt( p1, 10 );
@@ -546,11 +626,15 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 		function parseResourcesNode( resourcesNode ) {
 
 			var resourcesData = {};
-			var basematerialsNode = resourcesNode.querySelector( 'basematerials' );
 
-			if ( basematerialsNode ) {
+			resourcesData[ 'basematerials' ] = {};
+			var basematerialsNodes = resourcesNode.querySelectorAll( 'basematerials' );
 
-				resourcesData[ 'basematerials' ] = parseBasematerialsNode( basematerialsNode );
+			for ( var i = 0; i < basematerialsNodes.length; i ++ ) {
+
+				var basematerialsNode = basematerialsNodes[ i ];
+				var basematerialsData = parseBasematerialsNode( basematerialsNode );
+				resourcesData[ 'basematerials' ][ basematerialsData[ 'id' ] ] = basematerialsData;
 
 			}
 
@@ -569,13 +653,39 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 
 			//
 
+			resourcesData[ 'colorgroup' ] = {};
+			var colorGroupNodes = resourcesNode.querySelectorAll( 'colorgroup' );
+
+			for ( var i = 0; i < colorGroupNodes.length; i ++ ) {
+
+				var colorGroupNode = colorGroupNodes[ i ];
+				var colorGroupData = parseColorGroupNode( colorGroupNode );
+				resourcesData[ 'colorgroup' ][ colorGroupData[ 'id' ] ] = colorGroupData;
+
+			}
+
+			//
+
+			resourcesData[ 'pbmetallicdisplayproperties' ] = {};
+			var pbmetallicdisplaypropertiesNodes = resourcesNode.querySelectorAll( 'pbmetallicdisplayproperties' );
+
+			for ( var i = 0; i < pbmetallicdisplaypropertiesNodes.length; i ++ ) {
+
+				var pbmetallicdisplaypropertiesNode = pbmetallicdisplaypropertiesNodes[ i ];
+				var pbmetallicdisplaypropertiesData = parseMetallicDisplaypropertiesNode( pbmetallicdisplaypropertiesNode );
+				resourcesData[ 'pbmetallicdisplayproperties' ][ pbmetallicdisplaypropertiesData[ 'id' ] ] = pbmetallicdisplaypropertiesData;
+
+			}
+
+			//
+
 			resourcesData[ 'texture2dgroup' ] = {};
 			var textures2DGroupNodes = resourcesNode.querySelectorAll( 'texture2dgroup' );
 
 			for ( var i = 0; i < textures2DGroupNodes.length; i ++ ) {
 
 				var textures2DGroupNode = textures2DGroupNodes[ i ];
-				var textures2DGroupData = parseTextures2DGroupNodes( textures2DGroupNode );
+				var textures2DGroupData = parseTextures2DGroupNode( textures2DGroupNode );
 				resourcesData[ 'texture2dgroup' ][ textures2DGroupData[ 'id' ] ] = textures2DGroupData;
 
 			}
@@ -655,371 +765,426 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 
 		}
 
-		function buildGroups( geometry, modelData, meshData ) {
+		function buildTexture( texture2dgroup, objects, modelData, textureData ) {
 
-			var basematerialsData = modelData[ 'resources' ][ 'basematerials' ];
-			var triangleProperties = meshData[ 'triangleProperties' ];
+			var texid = texture2dgroup.texid;
+			var texture2ds = modelData.resources.texture2d;
+			var texture2d = texture2ds[ texid ];
 
-			var start = 0;
-			var count = 0;
-			var currentMaterialIndex = - 1;
+			if ( texture2d ) {
 
-			for ( var i = 0, l = triangleProperties.length; i < l; i ++ ) {
+				var data = textureData[ texture2d.path ];
+				var type = texture2d.contenttype;
 
-				var triangleProperty = triangleProperties[ i ];
-				var pid = triangleProperty.pid;
+				var blob = new Blob( [ data ], { type: type } );
+				var sourceURI = URL.createObjectURL( blob );
 
-				// only proceed if the triangle refers to a basematerials definition
+				var texture = textureLoader.load( sourceURI, function () {
 
-				if ( basematerialsData && ( basematerialsData.id === pid ) ) {
+					URL.revokeObjectURL( sourceURI );
 
-					if ( currentMaterialIndex === - 1 ) currentMaterialIndex = triangleProperty.p1;
+				} );
 
-					if ( currentMaterialIndex === triangleProperty.p1 ) {
+				texture.encoding = sRGBEncoding;
 
-						count += 3; // primitives per triangle
+				// texture parameters
 
-					} else {
+				switch ( texture2d.tilestyleu ) {
 
-						geometry.addGroup( start, count, currentMaterialIndex );
+					case 'wrap':
+						texture.wrapS = RepeatWrapping;
+						break;
 
-						start += count;
-						count = 3;
-						currentMaterialIndex = triangleProperty.p1;
+					case 'mirror':
+						texture.wrapS = MirroredRepeatWrapping;
+						break;
 
-					}
+					case 'none':
+					case 'clamp':
+						texture.wrapS = ClampToEdgeWrapping;
+						break;
+
+					default:
+						texture.wrapS = RepeatWrapping;
 
 				}
 
-			}
+				switch ( texture2d.tilestylev ) {
 
-			if ( geometry.groups.length > 0 ) mergeGroups( geometry );
+					case 'wrap':
+						texture.wrapT = RepeatWrapping;
+						break;
 
-		}
+					case 'mirror':
+						texture.wrapT = MirroredRepeatWrapping;
+						break;
 
-		function buildGeometry( modelData, meshData, objectData ) {
+					case 'none':
+					case 'clamp':
+						texture.wrapT = ClampToEdgeWrapping;
+						break;
 
-			var geometry = new BufferGeometry();
-			geometry.setIndex( new BufferAttribute( meshData[ 'triangles' ], 1 ) );
-			geometry.setAttribute( 'position', new BufferAttribute( meshData[ 'vertices' ], 3 ) );
+					default:
+						texture.wrapT = RepeatWrapping;
 
-			//
+				}
 
-			var texture2dgroups = modelData.resources.texture2dgroup;
+				switch ( texture2d.filter ) {
 
-			if ( texture2dgroups ) {
+					case 'auto':
+						texture.magFilter = LinearFilter;
+						texture.minFilter = LinearMipmapLinearFilter;
+						break;
 
-				var textureCoordinates = [];
+					case 'linear':
+						texture.magFilter = LinearFilter;
+						texture.minFilter = LinearFilter;
+						break;
 
-				var triangleProperties = meshData[ 'triangleProperties' ];
-				var texture2dgroupObjectLevel;
+					case 'nearest':
+						texture.magFilter = NearestFilter;
+						texture.minFilter = NearestFilter;
+						break;
 
-				// check reference to texture coordinates on object level
+					default:
+						texture.magFilter = LinearFilter;
+						texture.minFilter = LinearMipmapLinearFilter;
 
-				var texid;
-				var pid = objectData.pid;
+				}
 
-				if ( pid && texture2dgroups[ pid ] ) texture2dgroupObjectLevel = texture2dgroups[ pid ];
+				return texture;
 
-				// process all triangles
+			} else {
 
-				for ( var i = 0, l = triangleProperties.length; i < l; i ++ ) {
+				return null;
 
-					var texture2dgroup = texture2dgroupObjectLevel;
-					var triangleProperty = triangleProperties[ i ];
-					pid = triangleProperty.pid;
+			}
 
-					// overwrite existing resource reference if necessary
+		}
 
-					if ( pid && texture2dgroups[ pid ] ) texture2dgroup = texture2dgroups[ pid ];
+		function buildBasematerialsMeshes( basematerials, triangleProperties, modelData, meshData, textureData, objectData ) {
 
-					if ( texture2dgroup ) {
+			var objectPindex = objectData.pindex;
 
-						texid = texture2dgroup.texid; // the loader only supports a single texture for a single geometry right now (and not per face)
-						var uvs = texture2dgroup.uvs;
+			var materialMap = {};
 
-						textureCoordinates.push( uvs[ ( triangleProperty.p1 * 2 ) + 0 ] );
-						textureCoordinates.push( uvs[ ( triangleProperty.p1 * 2 ) + 1 ] );
+			for ( var i = 0, l = triangleProperties.length; i < l; i ++ ) {
 
-						textureCoordinates.push( uvs[ ( triangleProperty.p2 * 2 ) + 0 ] );
-						textureCoordinates.push( uvs[ ( triangleProperty.p2 * 2 ) + 1 ] );
+				var triangleProperty = triangleProperties[ i ];
+				var pindex = ( triangleProperty.p1 !== undefined ) ? triangleProperty.p1 : objectPindex;
 
-						textureCoordinates.push( uvs[ ( triangleProperty.p3 * 2 ) + 0 ] );
-						textureCoordinates.push( uvs[ ( triangleProperty.p3 * 2 ) + 1 ] );
+				if ( materialMap[ pindex ] === undefined ) materialMap[ pindex ] = [];
 
-					}
+				materialMap[ pindex ].push( triangleProperty );
 
-				}
+			}
 
-				if ( textureCoordinates.length > 0 ) {
+			//
 
-					// uvs are defined on face level so the same vertex can have multiple uv coordinates
+			var keys = Object.keys( materialMap );
+			var meshes = [];
 
-					geometry = geometry.toNonIndexed();
-					geometry.setAttribute( 'uv', new Float32BufferAttribute( textureCoordinates, 2 ) );
-					geometry.__texid = texid; // save the relationship between texture coordinates and texture
+			for ( var i = 0, l = keys.length; i < l; i ++ ) {
 
-					return geometry;
+				var materialIndex = keys[ i ];
+				var trianglePropertiesProps = materialMap[ materialIndex ];
+				var basematerialData = basematerials.basematerials[ materialIndex ];
+				var material = getBuild( basematerialData, objects, modelData, textureData, objectData, buildBasematerial );
 
-				}
+				//
 
-			}
+				var geometry = new BufferGeometry();
 
-			return geometry;
+				var positionData = [];
 
-		}
+				var vertices = meshData.vertices;
 
-		function buildTexture( geometry, modelData, textureData ) {
+				for ( var j = 0, jl = trianglePropertiesProps.length; j < jl; j ++ ) {
 
-			var texid = geometry.__texid;
+					var triangleProperty = trianglePropertiesProps[ j ];
 
-			if ( texid !== undefined ) {
+					positionData.push( vertices[ ( triangleProperty.v1 * 3 ) + 0 ] );
+					positionData.push( vertices[ ( triangleProperty.v1 * 3 ) + 1 ] );
+					positionData.push( vertices[ ( triangleProperty.v1 * 3 ) + 2 ] );
 
-				delete geometry.__texid;
+					positionData.push( vertices[ ( triangleProperty.v2 * 3 ) + 0 ] );
+					positionData.push( vertices[ ( triangleProperty.v2 * 3 ) + 1 ] );
+					positionData.push( vertices[ ( triangleProperty.v2 * 3 ) + 2 ] );
 
-				if ( textureMap[ texid ] !== undefined ) {
+					positionData.push( vertices[ ( triangleProperty.v3 * 3 ) + 0 ] );
+					positionData.push( vertices[ ( triangleProperty.v3 * 3 ) + 1 ] );
+					positionData.push( vertices[ ( triangleProperty.v3 * 3 ) + 2 ] );
 
-					return textureMap[ texid ];
 
-				} else {
+				}
 
-					var texture2ds = modelData.resources.texture2d;
-					var texture2d = texture2ds[ texid ];
+				geometry.setAttribute( 'position', new Float32BufferAttribute( positionData, 3 ) );
 
-					if ( texture2d ) {
+				//
 
-						var data = textureData[ texture2d.path ];
-						var type = texture2d.contenttype;
+				var mesh = new Mesh( geometry, material );
+				meshes.push( mesh );
 
-						var blob = new Blob( [ data ], { type: type } );
-						var sourceURI = URL.createObjectURL( blob );
+			}
 
-						var texture = textureLoader.load( sourceURI, function () {
+			return meshes;
 
-							URL.revokeObjectURL( sourceURI );
+		}
 
-						} );
+		function buildTexturedMesh( texture2dgroup, triangleProperties, modelData, meshData, textureData, objectData ) {
 
-						texture.encoding = sRGBEncoding;
+			// geometry
 
-						// texture parameters
+			var geometry = new BufferGeometry();
 
-						switch ( texture2d.tilestyleu ) {
+			var positionData = [];
+			var uvData = [];
 
-							case 'wrap':
-								texture.wrapS = RepeatWrapping;
-								break;
+			var vertices = meshData.vertices;
+			var uvs = texture2dgroup.uvs;
 
-							case 'mirror':
-								texture.wrapS = MirroredRepeatWrapping;
-								break;
+			for ( var i = 0, l = triangleProperties.length; i < l; i ++ ) {
 
-							case 'none':
-							case 'clamp':
-								texture.wrapS = ClampToEdgeWrapping;
-								break;
+				var triangleProperty = triangleProperties[ i ];
 
-							default:
-								texture.wrapS = RepeatWrapping;
+				positionData.push( vertices[ ( triangleProperty.v1 * 3 ) + 0 ] );
+				positionData.push( vertices[ ( triangleProperty.v1 * 3 ) + 1 ] );
+				positionData.push( vertices[ ( triangleProperty.v1 * 3 ) + 2 ] );
 
-						}
+				positionData.push( vertices[ ( triangleProperty.v2 * 3 ) + 0 ] );
+				positionData.push( vertices[ ( triangleProperty.v2 * 3 ) + 1 ] );
+				positionData.push( vertices[ ( triangleProperty.v2 * 3 ) + 2 ] );
 
-						switch ( texture2d.tilestylev ) {
+				positionData.push( vertices[ ( triangleProperty.v3 * 3 ) + 0 ] );
+				positionData.push( vertices[ ( triangleProperty.v3 * 3 ) + 1 ] );
+				positionData.push( vertices[ ( triangleProperty.v3 * 3 ) + 2 ] );
 
-							case 'wrap':
-								texture.wrapT = RepeatWrapping;
-								break;
+				//
 
-							case 'mirror':
-								texture.wrapT = MirroredRepeatWrapping;
-								break;
+				uvData.push( uvs[ ( triangleProperty.p1 * 2 ) + 0 ] );
+				uvData.push( uvs[ ( triangleProperty.p1 * 2 ) + 1 ] );
 
-							case 'none':
-							case 'clamp':
-								texture.wrapT = ClampToEdgeWrapping;
-								break;
+				uvData.push( uvs[ ( triangleProperty.p2 * 2 ) + 0 ] );
+				uvData.push( uvs[ ( triangleProperty.p2 * 2 ) + 1 ] );
 
-							default:
-								texture.wrapT = RepeatWrapping;
+				uvData.push( uvs[ ( triangleProperty.p3 * 2 ) + 0 ] );
+				uvData.push( uvs[ ( triangleProperty.p3 * 2 ) + 1 ] );
 
-						}
+			}
 
-						switch ( texture2d.filter ) {
+			geometry.setAttribute( 'position', new Float32BufferAttribute( positionData, 3 ) );
+			geometry.setAttribute( 'uv', new Float32BufferAttribute( uvData, 2 ) );
 
-							case 'auto':
-								texture.magFilter = LinearFilter;
-								texture.minFilter = LinearMipmapLinearFilter;
-								break;
+			// material
 
-							case 'linear':
-								texture.magFilter = LinearFilter;
-								texture.minFilter = LinearFilter;
-								break;
+			var texture = getBuild( texture2dgroup, objects, modelData, textureData, objectData, buildTexture );
 
-							case 'nearest':
-								texture.magFilter = NearestFilter;
-								texture.minFilter = NearestFilter;
-								break;
+			var material = new MeshPhongMaterial( { map: texture, flatShading: true } );
 
-							default:
-								texture.magFilter = LinearFilter;
-								texture.minFilter = LinearMipmapLinearFilter;
+			// mesh
 
-						}
+			var mesh = new Mesh( geometry, material );
 
-						textureMap[ texid ] = texture;
+			return mesh;
 
-						return texture;
+		}
 
-					}
+		function buildVertexColorMesh( colorgroup, triangleProperties, modelData, meshData ) {
 
-				}
+			// geometry
 
-			}
+			var geometry = new BufferGeometry();
 
-			return null;
+			var positionData = [];
+			var colorData = [];
 
-		}
+			var vertices = meshData.vertices;
+			var colors = colorgroup.colors;
 
-		function buildMesh( meshData, objects, modelData, textureData, objectData ) {
+			for ( var i = 0, l = triangleProperties.length; i < l; i ++ ) {
 
-			var geometry = buildGeometry( modelData, meshData, objectData );
-			var texture = buildTexture( geometry, modelData, textureData );
+				var triangleProperty = triangleProperties[ i ];
 
-			// groups
+				var v1 = triangleProperty.v1;
+				var v2 = triangleProperty.v2;
+				var v3 = triangleProperty.v3;
 
-			buildGroups( geometry, modelData, meshData );
+				positionData.push( vertices[ ( v1 * 3 ) + 0 ] );
+				positionData.push( vertices[ ( v1 * 3 ) + 1 ] );
+				positionData.push( vertices[ ( v1 * 3 ) + 2 ] );
 
-			// material
+				positionData.push( vertices[ ( v2 * 3 ) + 0 ] );
+				positionData.push( vertices[ ( v2 * 3 ) + 1 ] );
+				positionData.push( vertices[ ( v2 * 3 ) + 2 ] );
 
-			var material = null;
+				positionData.push( vertices[ ( v3 * 3 ) + 0 ] );
+				positionData.push( vertices[ ( v3 * 3 ) + 1 ] );
+				positionData.push( vertices[ ( v3 * 3 ) + 2 ] );
 
-			// add material if an object-level definition is present
+				//
 
-			var basematerialsData = modelData[ 'resources' ][ 'basematerials' ];
+				var p1 = triangleProperty.p1;
+				var p2 = triangleProperty.p2;
+				var p3 = triangleProperty.p3;
 
-			if ( basematerialsData && ( basematerialsData.id === objectData.pid ) ) {
+				colorData.push( colors[ ( p1 * 3 ) + 0 ] );
+				colorData.push( colors[ ( p1 * 3 ) + 1 ] );
+				colorData.push( colors[ ( p1 * 3 ) + 2 ] );
 
-				var materialIndex = objectData.pindex;
-				var basematerialData = basematerialsData.basematerials[ materialIndex ];
+				colorData.push( colors[ ( ( p2 || p1 ) * 3 ) + 0 ] );
+				colorData.push( colors[ ( ( p2 || p1 ) * 3 ) + 1 ] );
+				colorData.push( colors[ ( ( p2 || p1 ) * 3 ) + 2 ] );
 
-				material = getBuild( basematerialData, objects, modelData, textureData, objectData, buildBasematerial );
+				colorData.push( colors[ ( ( p3 || p1 ) * 3 ) + 0 ] );
+				colorData.push( colors[ ( ( p3 || p1 ) * 3 ) + 1 ] );
+				colorData.push( colors[ ( ( p3 || p1 ) * 3 ) + 2 ] );
 
 			}
 
-			// add/overwrite material if definitions on triangles are present
+			geometry.setAttribute( 'position', new Float32BufferAttribute( positionData, 3 ) );
+			geometry.setAttribute( 'color', new Float32BufferAttribute( colorData, 3 ) );
 
-			if ( geometry.groups.length > 0 ) {
+			// material
 
-				var groups = geometry.groups;
-				material = [];
+			var material = new MeshPhongMaterial( { vertexColors: VertexColors, flatShading: true } );
 
-				for ( var i = 0, l = groups.length; i < l; i ++ ) {
+			// mesh
 
-					var group = groups[ i ];
-					var basematerialData = basematerialsData.basematerials[ group.materialIndex ];
-					material.push( getBuild( basematerialData, objects, modelData, textureData, objectData, buildBasematerial ) );
+			var mesh = new Mesh( geometry, material );
 
-				}
+			return mesh;
 
-			}
+		}
 
-			// default material
+		function buildDefaultMesh( meshData ) {
 
-			if ( material === null ) {
+			var geometry = new BufferGeometry();
+			geometry.setIndex( new BufferAttribute( meshData[ 'triangles' ], 1 ) );
+			geometry.setAttribute( 'position', new BufferAttribute( meshData[ 'vertices' ], 3 ) );
 
-				if ( texture === null ) {
+			var material = new MeshPhongMaterial( { color: 0xaaaaff, flatShading: true } );
 
-					material = new MeshPhongMaterial( { color: 0xaaaaff, flatShading: true } );
+			var mesh = new Mesh( geometry, material );
 
-				} else {
+			return mesh;
 
-					material = new MeshPhongMaterial( { map: texture, flatShading: true } );
+		}
 
-				}
+		function buildMeshes( resourceMap, modelData, meshData, textureData, objectData ) {
 
-			}
+			var keys = Object.keys( resourceMap );
+			var meshes = [];
 
-			return new Mesh( geometry, material );
+			for ( var i = 0, il = keys.length; i < il; i ++ ) {
 
-		}
+				var resourceId = keys[ i ];
+				var triangleProperties = resourceMap[ resourceId ];
+				var resourceType = getResourceType( resourceId, modelData );
 
-		function mergeGroups( geometry ) {
+				switch ( resourceType ) {
 
-			// sort by material index
+					case 'material':
+						var basematerials = modelData.resources.basematerials[ resourceId ];
+						var newMeshes = buildBasematerialsMeshes( basematerials, triangleProperties, modelData, meshData, textureData, objectData );
 
-			var groups = geometry.groups.sort( function ( a, b ) {
+						for ( var j = 0, jl = newMeshes.length; j < jl; j ++ ) {
 
-				if ( a.materialIndex !== b.materialIndex ) return a.materialIndex - b.materialIndex;
+							meshes.push( newMeshes[ j ] );
 
-				return a.start - b.start;
+						}
+						break;
 
-			} );
+					case 'texture':
+						var texture2dgroup = modelData.resources.texture2dgroup[ resourceId ];
+						meshes.push( buildTexturedMesh( texture2dgroup, triangleProperties, modelData, meshData, textureData ) );
+						break;
 
-			// reorganize index buffer
+					case 'vertexColors':
+						var colorgroup = modelData.resources.colorgroup[ resourceId ];
+						meshes.push( buildVertexColorMesh( colorgroup, triangleProperties, modelData, meshData, textureData ) );
+						break;
 
-			var index = geometry.index;
+					case 'default':
+						meshes.push( buildDefaultMesh( meshData ) );
+						break;
 
-			var itemSize = index.itemSize;
-			var srcArray = index.array;
+					default:
+						console.error( 'THREE.3MFLoader: Unsupported resource type.' );
 
-			var targetOffset = 0;
+				}
 
-			var targetArray = new srcArray.constructor( srcArray.length );
+			}
 
-			for ( var i = 0; i < groups.length; i ++ ) {
+			return meshes;
 
-				var group = groups[ i ];
+		}
 
-				var groupLength = group.count * itemSize;
-				var groupStart = group.start * itemSize;
+		function getResourceType( pid, modelData ) {
 
-				var sub = srcArray.subarray( groupStart, groupStart + groupLength );
+			if ( modelData.resources.texture2dgroup[ pid ] !== undefined ) {
 
-				targetArray.set( sub, targetOffset );
+				return 'texture';
 
-				targetOffset += groupLength;
+			} else if ( modelData.resources.basematerials[ pid ] !== undefined ) {
 
-			}
+				return 'material';
 
-			srcArray.set( targetArray );
+			} else if ( modelData.resources.colorgroup[ pid ] !== undefined ) {
 
-			// update groups
+				return 'vertexColors';
 
-			var start = 0;
+			} else if ( pid === 'default' ) {
 
-			for ( i = 0; i < groups.length; i ++ ) {
+				return 'default';
 
-				group = groups[ i ];
+			} else {
 
-				group.start = start;
-				start += group.count;
+				return undefined;
 
 			}
 
-			// merge groups
+		}
 
-			var lastGroup = groups[ 0 ];
+		function analyzeObject( modelData, meshData, objectData ) {
 
-			geometry.groups = [ lastGroup ];
+			var resourceMap = {};
 
-			for ( i = 1; i < groups.length; i ++ ) {
+			var triangleProperties = meshData[ 'triangleProperties' ];
 
-				group = groups[ i ];
+			var objectPid = objectData.pid;
 
-				if ( lastGroup.materialIndex === group.materialIndex ) {
+			for ( var i = 0, l = triangleProperties.length; i < l; i ++ ) {
 
-					lastGroup.count += group.count;
+				var triangleProperty = triangleProperties[ i ];
+				var pid = ( triangleProperty.pid !== undefined ) ? triangleProperty.pid : objectPid;
 
-				} else {
+				if ( pid === undefined ) pid = 'default';
 
-					lastGroup = group;
-					geometry.groups.push( lastGroup );
+				if ( resourceMap[ pid ] === undefined ) resourceMap[ pid ] = [];
 
-				}
+				resourceMap[ pid ].push( triangleProperty );
+
+			}
+
+			return resourceMap;
+
+		}
+
+		function buildGroup( meshData, objects, modelData, textureData, objectData ) {
+
+			var group = new Group();
+
+			var resourceMap = analyzeObject( modelData, meshData, objectData );
+			var meshes = buildMeshes( resourceMap, modelData, meshData, textureData, objectData );
+
+			for ( var i = 0, l = meshes.length; i < l; i ++ ) {
+
+				group.add( meshes[ i ] );
 
 			}
 
+			return group;
+
 		}
 
 		function applyExtensions( extensions, meshData, modelXml ) {
@@ -1070,9 +1235,29 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 
 		}
 
-		function buildBasematerial( materialData ) {
+		function buildBasematerial( materialData, objects, modelData ) {
+
+			var material;
 
-			var material = new MeshPhongMaterial( { flatShading: true } );
+			var displaypropertiesid = materialData.displaypropertiesid;
+			var pbmetallicdisplayproperties = modelData.resources.pbmetallicdisplayproperties;
+
+			if ( displaypropertiesid !== null && pbmetallicdisplayproperties[ displaypropertiesid ] !== undefined ) {
+
+				// metallic display property, use StandardMaterial
+
+				var pbmetallicdisplayproperty = pbmetallicdisplayproperties[ displaypropertiesid ];
+				var metallicData = pbmetallicdisplayproperty.data[ materialData.index ];
+
+				material = new MeshStandardMaterial( { flatShading: true, roughness: metallicData.roughness, metalness: metallicData.metallicness } );
+
+			} else {
+
+				// otherwise use PhongMaterial
+
+				material = new MeshPhongMaterial( { flatShading: true } );
+
+			}
 
 			material.name = materialData.name;
 
@@ -1145,7 +1330,7 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 
 				applyExtensions( extensions, meshData, modelXml );
 
-				objects[ objectData.id ] = getBuild( meshData, objects, modelData, textureData, objectData, buildMesh );
+				objects[ objectData.id ] = getBuild( meshData, objects, modelData, textureData, objectData, buildGroup );
 
 			} else {
 
@@ -1165,15 +1350,20 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 			var modelsKeys = Object.keys( modelsData );
 			var textureData = {};
 
-			// evaluate model relationship to a texture
+			// evaluate model relationships to textures
 
 			if ( modelRels ) {
 
-				var textureKey = modelRels.target.substring( 1 );
+				for ( var i = 0, l = modelRels.length; i < l; i ++ ) {
 
-				if ( data3mf.texture[ textureKey ] ) {
+					var modelRel = modelRels[ i ];
+					var textureKey = modelRel.target.substring( 1 );
 
-					textureData[ modelRels.target ] = data3mf.texture[ textureKey ];
+					if ( data3mf.texture[ textureKey ] ) {
+
+						textureData[ modelRel.target ] = data3mf.texture[ textureKey ];
+
+					}
 
 				}
 
@@ -1202,10 +1392,12 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 
 		}
 
-		function build( objects, refs, data3mf ) {
+		function build( objects, data3mf ) {
 
 			var group = new Group();
-			var buildData = data3mf.model[ refs[ 'target' ].substring( 1 ) ][ 'build' ];
+
+			var relationship = data3mf[ 'rels' ][ 0 ];
+			var buildData = data3mf.model[ relationship[ 'target' ].substring( 1 ) ][ 'build' ];
 
 			for ( var i = 0; i < buildData.length; i ++ ) {
 
@@ -1233,7 +1425,7 @@ ThreeMFLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
 		var data3mf = loadDocument( data );
 		var objects = buildObjects( data3mf );
 
-		return build( objects, data3mf[ 'rels' ], data3mf );
+		return build( objects, data3mf );
 
 	},