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

.github/CONTRIBUTING.md

@@ -56,13 +56,6 @@ The next most important script runs all the appropriate testing.
 The linting is there to keep a consistent code-style across the all of the code and the testing is
 there to help catch bugs and check that the code behaves as expected. It is important that
 neither of these steps comes up with any errors due to your changes.
-* If you’d like the linter to fix any errors that it can change, make the following addition to the “test-lint” script.
-        
-        {
-        ...
-        "test-lint": "eslint src --ext js --ext ts --fix && tsc -p utils/build/tsconfig.lint.json"
-        ...
-        }
 
 If you’d like to make a minified version of the build files i.e. ‘build/three.min.js’ run:
         

docs/api/en/core/Object3D.html

@@ -286,9 +286,9 @@
 
 		<h3>[method:Vector3 localToWorld]( [param:Vector3 vector] )</h3>
 		<p>
-		vector - A vector representing a position in local (object) space.<br /><br />
+		vector - A vector representing a position in this object's local space.<br /><br />
 
-		Converts the vector from local space to world space.
+		Converts the vector from this object's local space to world space.
 		</p>
 
 		<h3>[method:null lookAt]( [param:Vector3 vector] )<br />
@@ -447,9 +447,9 @@
 
 		<h3>[method:Vector3 worldToLocal]( [param:Vector3 vector] )</h3>
 		<p>
-		vector - A world vector.<br /><br />
+		vector - A vector representing a position in world space.<br /><br />
 
-		Updates the vector from world space to local space.
+		Converts the vector from world space to this object's local space.
 		</p>
 
 		<h2>Source</h2>

docs/api/en/helpers/ArrowHelper.html

@@ -33,8 +33,6 @@
 		<h2>Examples</h2>
 
 		<p>
-			[example:webgl_geometries WebGL / geometries]<br/>
-			[example:webgl_geometry_normals WebGL / geometry / normals]<br/>
 			[example:webgl_shadowmesh WebGL / shadowmesh]
 		</p>
 

docs/api/zh/core/Object3D.html

@@ -270,8 +270,9 @@
 
 	<h3>[method:Vector3 localToWorld]( [param:Vector3 vector] )</h3>
 	<p>
-		vector - 一个表示局部（物体）空间中位置的向量。 <br /><br />
-		将局部空间向量转换为世界空间向量。
+		vector - A vector representing a position in this object's local space.<br /><br />
+
+		Converts the vector from this object's local space to world space.
 	</p>
 
 	<h3>[method:null lookAt]( [param:Vector3 vector] )<br />
@@ -422,8 +423,9 @@
 
 	<h3>[method:Vector3 worldToLocal]( [param:Vector3 vector] )</h3>
 	<p>
-		vector - 一个世界向量.<br /><br />
-		将世界空间中的向量转换为局部空间向量。
+		vector - A vector representing a position in world space.<br /><br />
+
+		Converts the vector from world space to this object's local space.
 	</p>
 
 	<h2>源代码</h2>

docs/api/zh/helpers/ArrowHelper.html

@@ -33,8 +33,6 @@
 		<h2>例子</h2>
 
 		<p>
-			[example:webgl_geometries WebGL / geometries]<br/>
-			[example:webgl_geometry_normals WebGL / geometry / normals]<br/>
 			[example:webgl_shadowmesh WebGL / shadowmesh]
 		</p>
 

docs/api/zh/materials/MeshBasicMaterial.html

@@ -94,6 +94,8 @@
 		<h3>[property:Float refractionRatio]</h3>
 		<p> 空气的折射率（IOR）（约为1）除以材质的折射率。它与环境映射模式[page:Textures THREE.CubeRefractionMapping]
 			和[page:Textures THREE.EquirectangularRefractionMapping]一起使用。
+			The index of refraction (IOR) of air (approximately 1) divided by the index of refraction of the material.
+			It is used with environment mapping mode [page:Textures THREE.CubeRefractionMapping].
 			折射率不应超过1。默认值为*0.98*。
 		</p>
 

docs/api/zh/materials/MeshLambertMaterial.html

@@ -115,6 +115,8 @@
 		<h3>[property:Float refractionRatio]</h3>
 		<p>空气的折射率（IOR）（约为1）除以材质的折射率。它与环境映射模式[page:Textures THREE.CubeRefractionMapping]
 			和[page:Textures THREE.EquirectangularRefractionMapping]一起使用。
+			The index of refraction (IOR) of air (approximately 1) divided by the index of refraction of the material.
+			It is used with environment mapping mode [page:Textures THREE.CubeRefractionMapping].
 			折射率不应超过1。默认值为*0.98*。
 		</p>
 

docs/api/zh/materials/MeshPhongMaterial.html

@@ -151,6 +151,8 @@
 		<h3>[property:Float refractionRatio]</h3>
 		<p> 空气的折射率（IOR）（约为1）除以材质的折射率。它与环境映射模式[page:Textures THREE.CubeRefractionMapping]
 			和[page:Textures THREE.EquirectangularRefractionMapping]一起使用。
+			The index of refraction (IOR) of air (approximately 1) divided by the index of refraction of the material.
+			It is used with environment mapping mode [page:Textures THREE.CubeRefractionMapping].
 			折射率不应超过1。默认值为*0.98*。
 		</p>
 

docs/api/zh/materials/MeshStandardMaterial.html

@@ -188,6 +188,8 @@
 		<h3>[property:Float refractionRatio]</h3>
 		<p> 空气的折射率（IOR）（约为1）除以材质的折射率。它与环境映射模式[page:Textures THREE.CubeRefractionMapping]
 			和[page:Textures THREE.EquirectangularRefractionMapping]一起使用。
+			The index of refraction (IOR) of air (approximately 1) divided by the index of refraction of the material.
+			It is used with environment mapping mode [page:Textures THREE.CubeRefractionMapping].
 			折射率不应超过1。默认值为*0.98*。
 		</p>
 

docs/index.html

@@ -31,6 +31,7 @@
 					<div id="exitSearchButton"></div>
 					<select id="language">
 						<option value="en">en</option>
+						<option value="ar">ar</option>
 						<option value="zh">中文</option>
 					</select>
 				</div>
@@ -53,7 +54,7 @@
 
 			if ( /^(api|manual|examples)/.test( hash ) ) {
 
-				var hashLanguage = /^(api|manual|examples)\/(en|zh)\//.exec( hash );
+				var hashLanguage = /^(api|manual|examples)\/(en|ar|zh)\//.exec( hash );
 
 				if ( hashLanguage === null ) {
 

docs/list.js

@@ -462,6 +462,17 @@ var list = {
 
 	},
 
+	"ar": {
+		"الكتيب": {
+
+			"البدء": {
+				"إنشاء مشهد": "manual/ar/introduction/Creating-a-scene",
+				"التنصيب": "manual/ar/introduction/Installation",
+			},
+
+		},
+	},
+
 	"zh": {
 
 		"手册": {

docs/manual/ar/introduction/Creating-a-scene.html

@@ -0,0 +1,278 @@
+<!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" />
+		<style>
+			h1,
+			h2,
+			h3,
+			h4,
+			p {
+				direction: rtl !important;
+			}
+		</style>
+	</head>
+	<body>
+		<h1>إنشاء مشهد（[name]）</h1>
+
+		<p>الهدف من هذا القسم هو تقديم لمحة وجيزة عن كيفية عمل المكتبة. سنبدأ بتحضير مشهد يتمثل في مكعب ثلاثي الأبعاد .الصفحة مرفوقة بمثال أسفلها في حالة واجهتك بعض المشاكل وإحتجت إلى المساعدة.</p>
+
+		<h2>قبل أن نبدأ</h2>
+
+		<p>
+			قبل أن يمكنك إستعمال المكتبة, يجب أن توفر مكان لإظهار المشهد. قم بإنشاء ملف HTML يحتوي الشفرة البرمجية التالية
+        	بصحبة نسخة من المكتبة [link:https://threejs.org/build/three.js three.js] في مجلد سمه js و من ثم فم بفتح الصفحة في المتصفح.
+		</p>
+
+		<code>
+		&lt;!DOCTYPE html&gt;
+		&lt;html&gt;
+			&lt;head&gt;
+				&lt;meta charset="utf-8"&gt;
+				&lt;title&gt;My first three.js app&lt;/title&gt;
+				&lt;style&gt;
+					body { margin: 0; }
+					canvas { display: block; }
+				&lt;/style&gt;
+			&lt;/head&gt;
+			&lt;body&gt;
+				&lt;script src="js/three.js"&gt;&lt;/script&gt;
+				&lt;script&gt;
+					// Our Javascript will go here.
+				&lt;/script&gt;
+			&lt;/body&gt;
+		&lt;/html&gt;
+		</code>
+
+		<p>
+			هذا كل شيء. بقية الأوامر البرمجية ستكون محتوات في وسم &lt;script&gt; الفارغ حاليا.
+		</p>
+
+		<h2>إنشاء مشهد</h2>
+
+		<p>
+			لنتمكن من إظهار أي شيء بإستهمال three.js، نحتاج ثلاثة عناصر أساسية: المسرح (Scene)، الكاميرا (Camera)، و العارض
+			(Renderer).
+		</p>
+
+		<code>
+		var scene = new THREE.Scene();
+		var camera = new THREE.PerspectiveCamera( 75, window.innerWidth / window.innerHeight, 0.1, 1000 );
+
+		var renderer = new THREE.WebGLRenderer();
+		renderer.setSize( window.innerWidth, window.innerHeight );
+		document.body.appendChild( renderer.domElement );
+		</code>
+
+		<p>
+			لنتمهل لحظة من أجل توضيح ما يحصل هنا. لقد قمنا بتحضير كل من المسرح، الكاميرا، و العارض.
+		</p>
+
+		<p>
+			توفر مكتبة three.js العديد من الخيارات بخصوص نوع الكاميرا. للوقت الراهن، سنستعمل
+			<strong>PerspectiveCamera</strong>.
+		</p>
+
+		<p>
+			أول ميزة هي <strong>مجال الرؤية - Field of view</strong>. يمكن التعبير عنها بإستعمال إختصارها كالأتي FOV. هذه
+			القيمة تمثل مجال
+			المشاهدة المتاح في أي وقت
+			من العرض. وحده قيسها هي الدرجة (degrees)
+		</p>
+
+		<p>
+			القيمة الثانية هي <strong>نسبة العرض إلى الارتفاع - aspect ratio</strong>. من المستحسن إستعمال نتيجة قسمة عرض و
+			طول العنصر الحاوي، و إلا ستحصل على تجربة مماثلة
+			لمشاهدة فيلم قديم على تلفاز عريض حيث ستكون الصورة متغيرة.
+		</p>
+
+		<p>
+			القيمتين المتبقيتين هما <strong>أقرب</strong> و <strong>أبعد</strong> سطح فاصل. نقصد بدلك أن أي عنصر في المشهد
+			أبعد من السطح الفاصل البعيد بالنسبة
+			للكاميرا أو أقرب من السطح الفاصل القريب لن يتم عرضه.
+			أنت لست مطالب بالقلق حيال هذا، و لكن من الممكن أن تريد إستعمال قيم أخرى من أجل الحصول على أداء أفضل.
+		</p>
+
+		<p>
+			نصل الأن إلى العارض. هنا أين يكمن السحر. بالإضافة لإستعمال WebGLRenderer، المكتبة تتكفل بتمكين بعض المتصفحات
+			القديمة التي لا
+			تدعم WebGL لسبب ما من الخصائص المفقودة.
+		</p>
+
+		<p>
+			إلي جانب إنشاء نموذج من مكون عارض، نحن مطالبون بتوفير قياس المشهد المراد عرضه. إنها لا فكرة جيدة أن نستعمل عرض و
+			طول المنطقة التي نريد ملأها في الصفحة. في هذه الحالة إستعملنا عرض و طول نافدة المتصفح. بالنسبة لتطبيقات عالية
+			الأداء، يمكنك توفير قيم أقل مثل <strong>window.innerWidth/2</strong> و <strong>window.innerHeight/2</strong>،
+			التي
+			ستجعل المشهد يعرض أسرع بنصف المدة السابقة.
+		</p>
+
+		<p>
+			على سبيل المثال إلغاء قيمة <strong>updateStyle</strong> كالأتي:
+			<br />
+			<strong>setSize(window.innerWidth/2, window.innerHeight/2, false)</strong>
+			<br />
+			ستجعل المشهد يعرض بدقة أقل بنصف
+			الدرجة القديمة، مع العلم أن < canvas>
+				الخاصة بك تم إمدادها ب100% في كلا الطول و العرض.
+		</p>
+
+		<p>
+			أخيرا و ليس أخرا، سنقوم بإضافة <strong>العارض</strong> إلى ملف الـHTML.
+			<br />
+			< canvas> هو وسم يستعمله العارض لإظهار المشهد من خلاله.
+		</p>
+
+		<p>
+			<em>"كل شيء جيد، و لكن أي المكعب الذي وعدتنا به؟"</em> لنقم بإضافته الأن.
+		</p>
+
+		<code>
+		var geometry = new THREE.BoxGeometry();
+		var material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+		var cube = new THREE.Mesh( geometry, material );
+		scene.add( cube );
+
+		camera.position.z = 5;
+		</code>
+
+		<p>
+			لكي نقوم بإنشاء مكعب، نحتاج مكون <strong>BoxGeometry</strong>. هذا الأخير مسؤول عن حفض أماكن كل النقاط
+			(<strong>vertices</strong>) و تعبئة كل الأوجه
+			(<strong>faces</strong>) المكونة للمكعب. سنقوم بالتعمق في هذا الموضوع مستقبلا.
+		</p>
+
+		<p>
+			بالإضافة إلى الهندسة الخاصة بالمكعب، نحتاج المادة المكونة له لتعطيه لون. Three.js تأتي مع العديد من المواد،
+			و
+			لكن سنكتفي بإستعمال <strong>MeshBasicMaterial</strong> للوقت الراهن. كل المواد تأخذ مجموعة من القيم ستطبق
+			عليها
+			من أجل الوصول إلى النتيجة المرادة. لإبقاء الأشياء بسيطة، قمنا بإرفاق قيمة اللون التي تحمل
+			<strong>0x00ff00</strong>، و الذي يمثل اللون الأخضر. كيفية إحتساب القيمة هي نفسها كإستعمال CSS أو Photoshop
+			(<strong>hex colors</strong>).
+		</p>
+
+		<p>
+			الخطوة التالية هي إنشاء جسم <strong>Mesh</strong>. نقصد به الشيء الذي سيتكفل بالتعامل مع هندسة الشكل و
+			تطبيقها
+			على المادة المرفوقة، و من ثم يمكننا إدخال الشكل الجسم النهائي إلى المشهد، و التحرك بحرية حوله.
+		</p>
+
+		<p>
+			عند إستعمال أمر <strong>()scene.add</strong>، الشيء المراد إضافته للمشهد سيضاف في الإحداثيات التالية
+			(<strong>0,0,0</strong>). هذا يمكن له أن يشكل بعض المشاكل كون الكاميرا في هذه الحالة وسط المكعب. لتجنب هذا
+			نقوم
+			ببساطة بإبعاد الكاميرا قليلا.
+		</p>
+
+		<h2>عرض المشهد</h2>
+
+		<p>
+			إن قمت بنسخ الأوامر البرمجية الموجودة أعله وسط ملف HTML الذي قمنا بإنشائه مسبقا، لم تتمكن من رؤية أي شيء حتى
+			الأن. هذا بسبب أننا لم نقم بعرض أي شيء حتى اللحظة. لذلك، ما نحتاجه يدعى العرض (<strong>render</strong>) أو
+			حلقة
+			الحركات (<strong>animation loop</strong>).
+		</p>
+
+		<code>
+		function animate() {
+			requestAnimationFrame( animate );
+			renderer.render( scene, camera );
+		}
+		animate();
+		</code>
+
+		<p>
+			هذه الشفرة البرمجية تقوم بإنشاء حلقة تجعل العارض يعيد تحديث المشهد كل مرة يحدث فيها تغيير في الصفحة (أو نظريا
+			هذا يعني 60
+			مرة
+			خلال كل ثانية). إن كنت لا تملك تجربة مسبقة في صناعة ألعاب المتصفح، ستتسائل <em>"لماذا لا نستعمل
+				setInterval؟"</em> الحقيقة أننا بإمكاننا ذلك و لكن <strong>requestAnimationFrame</strong> تقدم لنا
+			العديد من
+			المزايا. من أهما أنها تقوم بإيقاف العمل عندما يقوم المستعمل بتغيير الصفحة، بالإضافة لعدم إستهلاك قدرة
+			الحاسب الخاص بالجهاز و عمر البطارية.
+		</p>
+
+		<h2>تحريك المكعب</h2>
+
+		<p>
+			إن قمت بإضافة الأوامر البرمجية السابقة للملف الخاص بك، من الأرجح أنك ترى الأن مكعبا أخضر اللون. لنقم بجعله
+			أكثر
+			جذابية من خلال تدويره.
+		</p>
+
+		<p>
+			قم بإضافة الشفرة التالية فوق السطر الذي يحتوي أمر <strong>renderer.render</strong> في الوظيفة
+			(<strong>animate</strong>):
+		</p>
+
+		<code>
+		cube.rotation.x += 0.01;
+		cube.rotation.y += 0.01;
+		</code>
+
+		<p>
+			هذه الأوامر سيتم تشغيلها في كل إطار (frame). ما يعني 60 مرة في الثانية تقريبا، و بذلك ستمكن المكعب من الدوران.
+			في
+			الأساس، أي شيء تريد تحريكه أو تغيره خلال فترة عمل التطبيق يستوجب أن تكون الأوامر الخاصة بذلك قد تم تشغيلها
+			داخل
+			حلقة الحركات. يمكنك بالتأكيد مناداة وظائف أخرى، لكي لا ينتهي بك المطاف بوظيفة واحدة تحتوي على مئات السطور.
+		</p>
+
+		<h2>النتيجة</h2>
+		<p>
+			تهانينا! لقد قمت بإكمال أول تطبيق three.js لك. الأمر ليس معقدا، يجب عليك فقد البدأ بشيء ما.
+		</p>
+
+		<p>
+			الشفرة البرمجية الكاملة في الأسفل إلى جانب محرر مباشر [link:https://jsfiddle.net/mkba0ecu/ live example].
+			أنت
+			مدعو للعب بالأوامر البرمجية لكي تصبح صورة كيفية عملها أوضح من قبل.
+		</p>
+
+		<code>
+		&lt;html&gt;
+			&lt;head&gt;
+				&lt;title&gt;My first three.js app&lt;/title&gt;
+				&lt;style&gt;
+					body { margin: 0; }
+					canvas { display: block; }
+				&lt;/style&gt;
+			&lt;/head&gt;
+			&lt;body&gt;
+				&lt;script src="js/three.js"&gt;&lt;/script&gt;
+				&lt;script&gt;
+					var scene = new THREE.Scene();
+					var camera = new THREE.PerspectiveCamera( 75, window.innerWidth / window.innerHeight, 0.1, 1000 );
+
+					var renderer = new THREE.WebGLRenderer();
+					renderer.setSize( window.innerWidth, window.innerHeight );
+					document.body.appendChild( renderer.domElement );
+
+					var geometry = new THREE.BoxGeometry();
+					var material = new THREE.MeshBasicMaterial( { color: 0x00ff00 } );
+					var cube = new THREE.Mesh( geometry, material );
+					scene.add( cube );
+
+					camera.position.z = 5;
+
+					var animate = function () {
+						requestAnimationFrame( animate );
+
+						cube.rotation.x += 0.01;
+						cube.rotation.y += 0.01;
+
+						renderer.render( scene, camera );
+					};
+
+					animate();
+				&lt;/script&gt;
+			&lt;/body&gt;
+		&lt;/html&gt;
+		</code>
+	</body>
+</html>

examples/css3d_orthographic.html

@@ -31,12 +31,13 @@
 
 			var scene2, renderer2;
 
+			var frustumSize = 500;
+
 			init();
 			animate();
 
 			function init() {
 
-				var frustumSize = 500;
 				var aspect = window.innerWidth / window.innerHeight;
 				camera = new THREE.OrthographicCamera( frustumSize * aspect / - 2, frustumSize * aspect / 2, frustumSize / 2, frustumSize / - 2, 1, 1000 );
 
@@ -116,6 +117,25 @@
 
 				}
 
+				window.addEventListener( 'resize', onWindowResize, false );
+
+			}
+
+			function onWindowResize() {
+
+				var aspect = window.innerWidth / window.innerHeight;
+
+				camera.left = - frustumSize * aspect / 2;
+				camera.right = frustumSize * aspect / 2;
+				camera.top = frustumSize / 2;
+				camera.bottom = - frustumSize / 2;
+
+				camera.updateProjectionMatrix();
+
+				renderer.setSize( window.innerWidth, window.innerHeight );
+
+				renderer2.setSize( window.innerWidth, window.innerHeight );
+
 			}
 
 			function animate() {

examples/css3d_sandbox.html

@@ -89,6 +89,20 @@
 
 				controls = new TrackballControls( camera, renderer2.domElement );
 
+				window.addEventListener( 'resize', onWindowResize, false );
+
+			}
+
+			function onWindowResize() {
+
+				camera.aspect = window.innerWidth / window.innerHeight;
+
+				camera.updateProjectionMatrix();
+
+				renderer.setSize( window.innerWidth, window.innerHeight );
+
+				renderer2.setSize( window.innerWidth, window.innerHeight );
+
 			}
 
 			function animate() {

examples/files.js

@@ -76,6 +76,7 @@ var files = {
 		"webgl_lines_fat",
 		"webgl_lines_fat_wireframe",
 		"webgl_lines_sphere",
+		"webgl_loader_3dm",
 		"webgl_loader_3ds",
 		"webgl_loader_3mf",
 		"webgl_loader_3mf_materials",
@@ -316,6 +317,7 @@ var files = {
 		"webgl2_materials_texture2darray",
 		"webgl2_materials_texture3d",
 		"webgl2_multisampled_renderbuffers",
+		"webgl2_volume_instancing",
 		"webgl2_volume_perlin"
 	],
 	"webaudio": [

examples/js/loaders/GLTFLoader.js

@@ -488,7 +488,12 @@ THREE.GLTFLoader = ( function () {
 
 	}
 
-	GLTFMaterialsClearcoatExtension.prototype.getMaterialType = function ( /* materialIndex */ ) {
+	GLTFMaterialsClearcoatExtension.prototype.getMaterialType = function ( materialIndex ) {
+
+		var parser = this.parser;
+		var materialDef = parser.json.materials[ materialIndex ];
+
+		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
 
 		return THREE.MeshPhysicalMaterial;
 
@@ -564,7 +569,12 @@ THREE.GLTFLoader = ( function () {
 
 	}
 
-	GLTFMaterialsTransmissionExtension.prototype.getMaterialType = function ( /* materialIndex */ ) {
+	GLTFMaterialsTransmissionExtension.prototype.getMaterialType = function ( materialIndex ) {
+
+		var parser = this.parser;
+		var materialDef = parser.json.materials[ materialIndex ];
+
+		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
 
 		return THREE.MeshPhysicalMaterial;
 

examples/jsm/loaders/3DMLoader.d.ts

@@ -0,0 +1,16 @@
+import {
+	Loader,
+	LoadingManager,
+	Object3D
+} from '../../../src/Three';
+
+export class Rhino3dmLoader extends Loader {
+
+	constructor( manager?: LoadingManager );
+
+	load( url: string, onLoad: ( object: Object3D ) => void, onProgress?: ( event: ProgressEvent ) => void, onError?: ( event: ErrorEvent ) => void ): void;
+	setLibraryPath( path: string ): Rhino3dmLoader;
+	setWorkerLimit( workerLimit: number ): Rhino3dmLoader;
+	dispose(): Rhino3dmLoader;
+
+}

examples/jsm/loaders/3DMLoader.js

@@ -0,0 +1,1011 @@
+/**
+ * @author Luis Fraguada / https://github.com/fraguada
+ */
+
+import {
+	BufferGeometryLoader,
+	FileLoader,
+	Loader,
+	Object3D,
+	MeshStandardMaterial,
+	Mesh,
+	Color,
+	Points,
+	PointsMaterial,
+	Line,
+	LineBasicMaterial,
+	Matrix4
+} from "../../../build/three.module.js";
+import { CSS2DObject } from '../renderers/CSS2DRenderer.js';
+
+var Rhino3dmLoader = function ( manager ) {
+
+	Loader.call( this, manager );
+
+	this.libraryPath = '';
+	this.libraryPending = null;
+	this.libraryBinary = null;
+	this.libraryConfig = {};
+
+	this.workerLimit = 4;
+	this.workerPool = [];
+	this.workerNextTaskID = 1;
+	this.workerSourceURL = '';
+	this.workerConfig = {};
+
+};
+
+Rhino3dmLoader.taskCache = new WeakMap();
+
+Rhino3dmLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
+
+	constructor: Rhino3dmLoader,
+
+	setLibraryPath: function ( path ) {
+
+		this.libraryPath = path;
+
+		return this;
+
+	},
+
+	setWorkerLimit: function ( workerLimit ) {
+
+		this.workerLimit = workerLimit;
+
+		return this;
+
+	},
+
+	load: function ( url, onLoad, onProgress, onError ) {
+
+		var loader = new FileLoader( this.manager );
+
+		loader.setPath( this.path );
+		loader.setResponseType( 'arraybuffer' );
+		loader.setRequestHeader( this.requestHeader );
+
+		loader.load( url, ( buffer ) => {
+
+			// Check for an existing task using this buffer. A transferred buffer cannot be transferred
+			// again from this thread.
+			if ( Rhino3dmLoader.taskCache.has( buffer ) ) {
+
+				var cachedTask = Rhino3dmLoader.taskCache.get( buffer );
+
+				return cachedTask.promise.then( onLoad ).catch( onError );
+
+			}
+
+			this.decodeObjects( buffer, url )
+				.then( onLoad )
+				.catch( onError );
+
+		}, onProgress, onError );
+
+
+	},
+
+	debug: function () {
+
+		console.log( 'Task load: ', this.workerPool.map( ( worker ) => worker._taskLoad ) );
+
+	},
+
+	decodeObjects: function ( buffer, url ) {
+
+		var worker;
+		var taskID;
+
+		var taskCost = buffer.byteLength;
+
+		var objectPending = this._getWorker( taskCost )
+			.then( ( _worker ) => {
+
+				worker = _worker;
+				taskID = this.workerNextTaskID ++; //hmmm
+
+				return new Promise( ( resolve, reject ) => {
+
+					worker._callbacks[ taskID ] = { resolve, reject };
+
+					worker.postMessage( { type: 'decode', id: taskID, buffer }, [ buffer ] );
+
+					//this.debug();
+
+				} );
+
+			} )
+			.then( ( message ) => this._createGeometry( message.data ) );
+
+		// Remove task from the task list.
+		// Note: replaced '.finally()' with '.catch().then()' block - iOS 11 support (#19416)
+		objectPending
+			.catch( () => true )
+			.then( () => {
+
+				if ( worker && taskID ) {
+
+					this._releaseTask( worker, taskID );
+
+					//this.debug();
+
+				}
+
+			} );
+
+		// Cache the task result.
+		Rhino3dmLoader.taskCache.set( buffer, {
+
+			url: url,
+			promise: objectPending
+
+		} );
+
+		return objectPending;
+
+	},
+
+	parse: function () {
+
+		// parsing logic goes here
+		console.warn( 'THREE.3DMLoader: TODO: Implement parse function' );
+
+	},
+
+	_createMaterial: function ( material ) {
+
+		if ( material === undefined ) {
+
+			return new MeshStandardMaterial( {
+				color: new Color( 1, 1, 1 ),
+				metalness: 0.8,
+				name: 'default',
+				side: 2
+			} );
+
+		}
+
+		var _diffuseColor = material.diffuseColor;
+
+		var diffusecolor = new Color( _diffuseColor.r / 255.0, _diffuseColor.g / 255.0, _diffuseColor.b / 255.0 );
+
+		if ( _diffuseColor.r === 0 && _diffuseColor.g === 0 && _diffuseColor.b === 0 ) {
+
+			diffusecolor.r = 1;
+			diffusecolor.g = 1;
+			diffusecolor.b = 1;
+
+		}
+
+		return new MeshStandardMaterial( {
+			color: diffusecolor,
+			metalness: 0.8,
+			name: material.name,
+			side: 2
+		} );
+
+	},
+
+	_createGeometry: function ( data ) {
+
+		// console.log(data);
+
+		var object = new Object3D();
+		var instanceDefinitionObjects = [];
+		var instanceDefinitions = [];
+		var instanceReferences = [];
+
+		object.userData[ 'layers' ] = data.layers;
+		object.userData[ 'groups' ] = data.groups;
+
+		var objects = data.objects;
+		var materials = data.materials;
+
+		for ( var i = 0; i < objects.length; i ++ ) {
+
+			var obj = objects[ i ];
+			var attributes = obj.attributes;
+
+			switch ( obj.objectType ) {
+
+				case 'InstanceDefinition':
+
+					instanceDefinitions.push( obj );
+
+					break;
+
+				case 'InstanceReference':
+
+					instanceReferences.push( obj );
+
+					break;
+
+				default:
+
+					var material = this._createMaterial( materials[ attributes.materialIndex ] );
+					var _object = this._createObject( obj, material );
+					_object.visible = data.layers[ attributes.layerIndex ].visible;
+
+					if ( attributes.isInstanceDefinitionObject ) {
+
+						instanceDefinitionObjects.push( _object );
+
+					} else {
+
+						object.add( _object );
+
+					}
+
+					break;
+
+			}
+
+		}
+
+		for ( var i = 0; i < instanceDefinitions.length; i ++ ) {
+
+			var iDef = instanceDefinitions[ i ];
+
+			var objects = [];
+
+			for ( var j = 0; j < iDef.attributes.objectIds.length; j ++ ) {
+
+				var objId = iDef.attributes.objectIds[ j ];
+
+				for ( var p = 0; p < instanceDefinitionObjects.length; p ++ ) {
+
+					var idoId = instanceDefinitionObjects[ p ].userData.attributes.id;
+
+					if ( objId === idoId ) {
+
+						objects.push( instanceDefinitionObjects[ p ] );
+
+					}
+
+				}
+
+			}
+
+			// Currently clones geometry and does not take advantage of instancing
+
+			for ( var j = 0; j < instanceReferences.length; j ++ ) {
+
+				var iRef = instanceReferences[ j ];
+
+				if ( iRef.geometry.parentIdefId === iDef.attributes.id ) {
+
+					var iRefObject = new Object3D();
+					var xf = iRef.geometry.xform.array;
+
+					var matrix = new Matrix4();
+          			matrix.set( xf[ 0 ], xf[ 1 ], xf[ 2 ], xf[ 3 ], xf[ 4 ], xf[ 5 ], xf[ 6 ], xf[ 7 ], xf[ 8 ], xf[ 9 ], xf[ 10 ], xf[ 11 ], xf[ 12 ], xf[ 13 ], xf[ 14 ], xf[ 15 ] );
+
+					iRefObject.applyMatrix4( matrix );
+
+					for ( var p = 0; p < objects.length; p ++ ) {
+
+						iRefObject.add( objects[ p ].clone( true ) );
+
+					}
+
+					object.add( iRefObject );
+
+				}
+
+			}
+
+		}
+
+		return object;
+
+	},
+
+	_createObject: function ( obj, mat ) {
+
+		var loader = new BufferGeometryLoader();
+
+		var attributes = obj.attributes;
+
+		switch ( obj.objectType ) {
+
+			case 'Point':
+			case 'PointSet':
+
+				var geometry = loader.parse( obj.geometry );
+				var material = new PointsMaterial( { sizeAttenuation: true, vertexColors: true } );
+				var points = new Points( geometry, material );
+				points.userData[ 'attributes' ] = attributes;
+				points.userData[ 'objectType' ] = obj.objectType;
+				return points;
+
+			case 'Mesh':
+			case 'Extrusion':
+
+				var geometry = loader.parse( obj.geometry );
+
+				var mesh = new Mesh( geometry, mat );
+				mesh.castShadow = attributes.castsShadows;
+				mesh.receiveShadow = attributes.receivesShadows;
+				mesh.userData[ 'attributes' ] = attributes;
+				mesh.userData[ 'objectType' ] = obj.objectType;
+
+				return mesh;
+
+			case 'Brep':
+
+				var brepObject = new Object3D();
+
+				for ( var j = 0; j < obj.geometry.length; j ++ ) {
+
+					geometry = loader.parse( obj.geometry[ j ] );
+					var mesh = new Mesh( geometry, mat );
+					mesh.castShadow = attributes.castsShadows;
+					mesh.receiveShadow = attributes.receivesShadows;
+
+					brepObject.add( mesh );
+
+				}
+
+				brepObject.userData[ 'attributes' ] = attributes;
+				brepObject.userData[ 'objectType' ] = obj.objectType;
+
+				return brepObject;
+
+			case 'Curve':
+
+				geometry = loader.parse( obj.geometry );
+
+				var _color = attributes.drawColor;
+				var color = new Color( _color.r / 255.0, _color.g / 255.0, _color.b / 255.0 );
+
+				var lines = new Line( geometry, new LineBasicMaterial( { color: color } ) );
+				lines.userData[ 'attributes' ] = attributes;
+				lines.userData[ 'objectType' ] = obj.objectType;
+
+				return lines;
+
+			case 'TextDot':
+
+				geometry = obj.geometry;
+				var dotDiv = document.createElement( 'div' );
+				dotDiv.style.fontFamily = geometry.fontFace;
+				dotDiv.style.fontSize = `${geometry.fontHeight}px`;
+				dotDiv.style.marginTop = '-1em';
+				dotDiv.style.color = '#FFF';
+				dotDiv.style.padding = '2px';
+				dotDiv.style.paddingRight = '5px';
+				dotDiv.style.paddingLeft = '5px';
+				dotDiv.style.borderRadius = '5px';
+				var color = attributes.drawColor;
+				dotDiv.style.background = `rgba(${color.r},${color.g},${color.b},${color.a})`;
+				dotDiv.textContent = geometry.text;
+				var dot = new CSS2DObject( dotDiv );
+				var location = geometry.point;
+				dot.position.set( location[ 0 ], location[ 1 ], location[ 2 ] );
+
+				dot.userData[ 'attributes' ] = attributes;
+				dot.userData[ 'objectType' ] = obj.objectType;
+
+				return dot;
+
+		}
+
+	},
+
+	_initLibrary: function () {
+
+		if ( ! this.libraryPending ) {
+
+			// Load rhino3dm wrapper.
+			var jsLoader = new FileLoader( this.manager );
+			jsLoader.setPath( this.libraryPath );
+			var jsContent = new Promise( ( resolve, reject ) => {
+
+				jsLoader.load( 'rhino3dm.js', resolve, undefined, reject );
+
+			} );
+
+			// Load rhino3dm WASM binary.
+			var binaryLoader = new FileLoader( this.manager );
+			binaryLoader.setPath( this.libraryPath );
+			binaryLoader.setResponseType( 'arraybuffer' );
+			var binaryContent = new Promise( ( resolve, reject ) => {
+
+				binaryLoader.load( 'rhino3dm.wasm', resolve, undefined, reject );
+
+			} );
+
+			this.libraryPending = Promise.all( [ jsContent, binaryContent ] )
+				.then( ( [ jsContent, binaryContent ] ) => {
+
+					//this.libraryBinary = binaryContent;
+					this.libraryConfig.wasmBinary = binaryContent;
+
+					var fn = Rhino3dmLoader.Rhino3dmWorker.toString();
+
+					var body = [
+						'/* rhino3dm.js */',
+						jsContent,
+						'/* worker */',
+						fn.substring( fn.indexOf( '{' ) + 1, fn.lastIndexOf( '}' ) )
+					].join( '\n' );
+
+					this.workerSourceURL = URL.createObjectURL( new Blob( [ body ] ) );
+
+				} );
+
+		}
+
+		return this.libraryPending;
+
+	},
+
+	_getWorker: function ( taskCost ) {
+
+		return this._initLibrary().then( () => {
+
+			if ( this.workerPool.length < this.workerLimit ) {
+
+				var worker = new Worker( this.workerSourceURL );
+
+				worker._callbacks = {};
+				worker._taskCosts = {};
+				worker._taskLoad = 0;
+
+				worker.postMessage( {
+					type: 'init',
+					libraryConfig: this.libraryConfig
+				} );
+
+				worker.onmessage = function ( e ) {
+
+					var message = e.data;
+
+					switch ( message.type ) {
+
+						case 'decode':
+							worker._callbacks[ message.id ].resolve( message );
+							break;
+
+						case 'error':
+							worker._callbacks[ message.id ].reject( message );
+							break;
+
+						default:
+							console.error( 'THREE.Rhino3dmLoader: Unexpected message, "' + message.type + '"' );
+
+					}
+
+				};
+
+				this.workerPool.push( worker );
+
+			} else {
+
+				this.workerPool.sort( function ( a, b ) {
+
+					return a._taskLoad > b._taskLoad ? - 1 : 1;
+
+				} );
+
+			}
+
+			var worker = this.workerPool[ this.workerPool.length - 1 ];
+
+			worker._taskLoad += taskCost;
+
+			return worker;
+
+		} );
+
+	},
+
+	_releaseTask: function ( worker, taskID ) {
+
+		worker._taskLoad -= worker._taskCosts[ taskID ];
+		delete worker._callbacks[ taskID ];
+		delete worker._taskCosts[ taskID ];
+
+	},
+
+	dispose: function () {
+
+		for ( var i = 0; i < this.workerPool.length; ++ i ) {
+
+			this.workerPool[ i ].terminate();
+
+		}
+
+		this.workerPool.length = 0;
+
+		return this;
+
+	}
+
+} );
+
+/* WEB WORKER */
+
+Rhino3dmLoader.Rhino3dmWorker = function () {
+
+	var libraryPending;
+	var libraryConfig;
+	var rhino;
+
+	onmessage = function ( e ) {
+
+		var message = e.data;
+
+		switch ( message.type ) {
+
+			case 'init':
+
+				libraryConfig = message.libraryConfig;
+				var wasmBinary = libraryConfig.wasmBinary;
+				var RhinoModule;
+				libraryPending = new Promise( function ( resolve ) {
+
+					/* Like Basis Loader */
+					RhinoModule = { wasmBinary, onRuntimeInitialized: resolve };
+
+					rhino3dm( RhinoModule );
+
+				 } ).then( () => {
+
+					rhino = RhinoModule;
+
+				 } );
+
+				break;
+
+			case 'decode':
+
+				var buffer = message.buffer;
+				libraryPending.then( () => {
+
+					var data = decodeObjects( rhino, buffer );
+
+					self.postMessage( { type: 'decode', id: message.id, data } );
+
+				} );
+
+				break;
+
+		}
+
+	};
+
+	function decodeObjects( rhino, buffer ) {
+
+		var arr = new Uint8Array( buffer );
+		var doc = rhino.File3dm.fromByteArray( arr );
+
+		var objects = [];
+		var materials = [];
+		var layers = [];
+		var views = [];
+		var namedViews = [];
+		var groups = [];
+		var strings = [];
+
+		//Handle objects
+
+		for ( var i = 0; i < doc.objects().count; i ++ ) {
+
+			var _object = doc.objects().get( i );
+
+			var object = extractObjectData( _object, doc );
+
+			if ( object !== undefined ) {
+
+				objects.push( object );
+
+			}
+
+			_object.delete();
+
+		}
+
+		// Handle instance definitions
+
+		for ( var i = 0; i < doc.instanceDefinitions().count(); i ++ ) {
+
+			var idef = doc.instanceDefinitions().get( i );
+			var idefAttributes = extractProperties( idef );
+			idefAttributes.objectIds = idef.getObjectIds();
+
+			objects.push( { geometry: null, attributes: idefAttributes, objectType: 'InstanceDefinition' } );
+
+		}
+
+		// Handle materials
+
+		for ( var i = 0; i < doc.materials().count(); i ++ ) {
+
+			var _material = doc.materials().get( i );
+			var materialProperties = extractProperties( _material );
+			var pbMaterialProperties = extractProperties( _material.physicallyBased() );
+
+			var material = Object.assign( materialProperties, pbMaterialProperties );
+
+			materials.push( material );
+
+			_material.delete();
+
+		}
+
+		// Handle layers
+
+		for ( var i = 0; i < doc.layers().count(); i ++ ) {
+
+			var _layer = doc.layers().get( i );
+			var layer = extractProperties( _layer );
+
+			layers.push( layer );
+
+			_layer.delete();
+
+		}
+
+		// Handle views
+
+		for ( var i = 0; i < doc.views().count(); i ++ ) {
+
+			var _view = doc.views().get( i );
+			var view = extractProperties( _view );
+
+			views.push( view );
+
+			_view.delete();
+
+		}
+
+		// Handle named views
+
+		for ( var i = 0; i < doc.namedViews().count(); i ++ ) {
+
+			var _namedView = doc.namedViews().get( i );
+			var namedView = extractProperties( _namedView );
+
+			namedViews.push( namedView );
+
+			_namedView.delete();
+
+		}
+
+		// Handle groups
+
+		for ( var i = 0; i < doc.groups().count(); i ++ ) {
+
+			var _group = doc.groups().get( i );
+			var group = extractProperties( _group );
+
+			groups.push( group );
+
+			_group.delete();
+
+		}
+
+		// Handle settings
+
+		var settings = extractProperties( doc.settings() );
+
+		//TODO: Handle other document stuff like dimstyles, instance definitions, bitmaps etc.
+
+		// Handle dimstyles
+		// console.log(`Dimstyle Count: ${doc.dimstyles().count()}`);
+
+		// Handle bitmaps
+		// console.log(`Bitmap Count: ${doc.bitmaps().count()}`);
+
+		// Handle instance definitions
+		// console.log(`Instance Definitions Count: ${doc.instanceDefinitions().count()}`);
+
+		// Handle strings -- this seems to be broken at the moment in rhino3dm
+		// console.log(`Strings Count: ${doc.strings().count()}`);
+		/*
+		for( var i = 0; i < doc.strings().count(); i++ ){
+
+			var _string= doc.strings().get( i );
+
+			console.log(_string);
+			var string = extractProperties( _group );
+
+			strings.push( string );
+
+			_string.delete();
+
+		}
+		*/
+
+		doc.delete();
+
+		return { objects, materials, layers, views, namedViews, groups, settings };
+
+	}
+
+	function extractObjectData( object, doc ) {
+
+		var _geometry = object.geometry();
+		var _attributes = object.attributes();
+		var objectType = _geometry.objectType;
+		var geometry = null;
+		var attributes = null;
+
+		// skip instance definition objects
+		//if( _attributes.isInstanceDefinitionObject ) { continue; }
+
+		// TODO: handle other geometry types
+		switch ( objectType ) {
+
+			case rhino.ObjectType.Curve:
+
+				var pts = curveToPoints( _geometry, 100 );
+
+				var position = {};
+				var color = {};
+				var attributes = {};
+				var data = {};
+
+				position.itemSize = 3;
+				position.type = 'Float32Array';
+				position.array = [];
+
+				for ( var j = 0; j < pts.length; j ++ ) {
+
+					position.array.push( pts[ j ][ 0 ] );
+					position.array.push( pts[ j ][ 1 ] );
+					position.array.push( pts[ j ][ 2 ] );
+
+				}
+
+				attributes.position = position;
+				data.attributes = attributes;
+
+				geometry = { data };
+
+				break;
+
+			case rhino.ObjectType.Point:
+
+				var pt = _geometry.location;
+
+				var position = {};
+				var color = {};
+				var attributes = {};
+				var data = {};
+
+				position.itemSize = 3;
+				position.type = 'Float32Array';
+				position.array = [ pt[ 0 ], pt[ 1 ], pt[ 2 ] ];
+
+				_color = _attributes.drawColor( doc );
+
+				color.itemSize = 3;
+				color.type = 'Float32Array';
+				color.array = [ _color.r / 255.0, _color.g / 255.0, _color.b / 255.0 ];
+
+				attributes.position = position;
+				attributes.color = color;
+				data.attributes = attributes;
+
+				geometry = { data };
+
+				break;
+
+			case rhino.ObjectType.PointSet:
+			case rhino.ObjectType.Mesh:
+
+				geometry = _geometry.toThreejsJSON();
+
+				break;
+
+			case rhino.ObjectType.Brep:
+
+				var faces = _geometry.faces();
+				geometry = [];
+
+				for ( var faceIndex = 0; faceIndex < faces.count; faceIndex ++ ) {
+
+					var face = faces.get( faceIndex );
+					var mesh = face.getMesh( rhino.MeshType.Any );
+
+					if ( mesh ) {
+
+						geometry.push( mesh.toThreejsJSON() );
+						mesh.delete();
+
+					}
+
+					face.delete();
+
+				}
+
+				faces.delete();
+
+				break;
+
+			case rhino.ObjectType.Extrusion:
+
+				var mesh = _geometry.getMesh( rhino.MeshType.Any );
+
+				if ( mesh ) {
+
+					geometry = mesh.toThreejsJSON();
+					mesh.delete();
+
+				}
+
+				break;
+
+			case rhino.ObjectType.TextDot:
+
+				geometry = extractProperties( _geometry );
+
+				break;
+
+			case rhino.ObjectType.InstanceReference:
+
+				geometry = extractProperties( _geometry );
+				geometry.xform = extractProperties( _geometry.xform );
+				geometry.xform.array = _geometry.xform.toFloatArray( true );
+
+				break;
+
+				/*
+				case rhino.ObjectType.Light:
+				case rhino.ObjectType.Annotation:
+				case rhino.ObjectType.Hatch:
+				case rhino.ObjectType.SubD:
+				case rhino.ObjectType.ClipPlane:
+				*/
+
+			default:
+				console.warn( `THREE.3DMLoader: TODO: Implement ${objectType.constructor.name}` );
+				break;
+
+		}
+
+		if ( geometry ) {
+
+			var attributes = extractProperties( _attributes );
+
+			if ( _attributes.groupCount > 0 ) {
+
+				attributes.groupIds = _attributes.getGroupList();
+
+			}
+
+			attributes.drawColor = _attributes.drawColor( doc );
+
+			objectType = objectType.constructor.name;
+			objectType = objectType.substring( 11, objectType.length );
+
+			return { geometry, attributes, objectType };
+
+		}
+
+	}
+
+	function extractProperties( object ) {
+
+		var result = {};
+
+		for ( var property in object ) {
+
+			if ( typeof object[ property ] !== 'function' ) {
+
+				result[ property ] = object[ property ];
+
+			} else {
+
+				// console.log(`${property}: ${object[property]}`);
+
+			}
+
+		}
+
+		return result;
+
+	}
+
+	function curveToPoints( curve, pointLimit ) {
+
+		var pointCount = pointLimit;
+		var rc = [];
+		var ts = [];
+
+		if ( curve instanceof rhino.LineCurve ) {
+
+		  	return [ curve.pointAtStart, curve.pointAtEnd ];
+
+		}
+
+		if ( curve instanceof rhino.PolylineCurve ) {
+
+		  	pointCount = curve.pointCount;
+		  	for ( var i = 0; i < pointCount; i ++ ) {
+
+				rc.push( curve.point( i ) );
+
+		  	}
+
+		  	return rc;
+
+		}
+
+		if ( curve instanceof rhino.PolyCurve ) {
+
+		  	var segmentCount = curve.segmentCount;
+
+		  	for ( var i = 0; i < segmentCount; i ++ ) {
+
+				var segment = curve.segmentCurve( i );
+				var segmentArray = curveToPoints( segment );
+				rc = rc.concat( segmentArray );
+				segment.delete();
+
+			}
+
+		  	return rc;
+
+		}
+
+		if ( curve instanceof rhino.NurbsCurve && curve.degree === 1 ) {
+
+		  	// console.info( 'degree 1 curve' );
+
+		}
+
+		var domain = curve.domain;
+		var divisions = pointCount - 1.0;
+
+		for ( var j = 0; j < pointCount; j ++ ) {
+
+			var t = domain[ 0 ] + ( j / divisions ) * ( domain[ 1 ] - domain[ 0 ] );
+
+			if ( t === domain[ 0 ] || t === domain[ 1 ] ) {
+
+				ts.push( t );
+				continue;
+
+		  	}
+
+		  	var tan = curve.tangentAt( t );
+		  	var prevTan = curve.tangentAt( ts.slice( - 1 )[ 0 ] );
+
+		  	// Duplicaated from THREE.Vector3
+		  	// How to pass imports to worker?
+
+		  	tS = tan[ 0 ] * tan[ 0 ] + tan[ 1 ] * tan[ 1 ] + tan[ 2 ] * tan[ 2 ];
+		  	ptS = prevTan[ 0 ] * prevTan[ 0 ] + prevTan[ 1 ] * prevTan[ 1 ] + prevTan[ 2 ] * prevTan[ 2 ];
+
+		  	var denominator = Math.sqrt( tS * ptS );
+
+		  	var angle;
+
+		  	if ( denominator === 0 ) {
+
+				angle = Math.PI / 2;
+
+		  	} else {
+
+				var theta = ( tan.x * prevTan.x + tan.y * prevTan.y + tan.z * prevTan.z ) / denominator;
+				angle = Math.acos( Math.max( - 1, Math.min( 1, theta ) ) );
+
+		  	}
+
+		  	if ( angle < 0.1 ) continue;
+		  	ts.push( t );
+
+		}
+
+		rc = ts.map( t => curve.pointAt( t ) );
+		return rc;
+
+	}
+
+};
+
+export { Rhino3dmLoader };

examples/jsm/loaders/GLTFLoader.js

@@ -551,7 +551,12 @@ var GLTFLoader = ( function () {
 
 	}
 
-	GLTFMaterialsClearcoatExtension.prototype.getMaterialType = function ( /* materialIndex */ ) {
+	GLTFMaterialsClearcoatExtension.prototype.getMaterialType = function ( materialIndex ) {
+
+		var parser = this.parser;
+		var materialDef = parser.json.materials[ materialIndex ];
+
+		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
 
 		return MeshPhysicalMaterial;
 
@@ -627,7 +632,12 @@ var GLTFLoader = ( function () {
 
 	}
 
-	GLTFMaterialsTransmissionExtension.prototype.getMaterialType = function ( /* materialIndex */ ) {
+	GLTFMaterialsTransmissionExtension.prototype.getMaterialType = function ( materialIndex ) {
+
+		var parser = this.parser;
+		var materialDef = parser.json.materials[ materialIndex ];
+
+		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
 
 		return MeshPhysicalMaterial;
 

examples/webgl2_volume_instancing.html

@@ -0,0 +1,258 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<title>three.js webgl2 - volume - instancing</title>
+		<meta charset="utf-8">
+		<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
+		<link type="text/css" rel="stylesheet" href="main.css">
+	</head>
+
+	<body>
+		<div id="info">
+			<a href="https://threejs.org" target="_blank" rel="noopener">three.js</a> webgl2 - volume - instancing
+		</div>
+
+		<script type="module">
+			import * as THREE from '../build/three.module.js';
+			import { OrbitControls } from './jsm/controls/OrbitControls.js';
+			import { VOXLoader } from './jsm/loaders/VOXLoader.js';
+
+			import { WEBGL } from './jsm/WebGL.js';
+
+			if ( WEBGL.isWebGL2Available() === false ) {
+
+				document.body.appendChild( WEBGL.getWebGL2ErrorMessage() );
+
+			}
+
+			let renderer, scene, camera;
+			let controls;
+
+			init();
+			animate();
+
+			function init() {
+
+				renderer = new THREE.WebGLRenderer();
+				renderer.setPixelRatio( window.devicePixelRatio );
+				renderer.setSize( window.innerWidth, window.innerHeight );
+				document.body.appendChild( renderer.domElement );
+
+				scene = new THREE.Scene();
+
+				camera = new THREE.PerspectiveCamera( 60, window.innerWidth / window.innerHeight, 0.1, 1000 );
+				camera.position.set( 0, 0, 4 );
+
+				controls = new OrbitControls( camera, renderer.domElement );
+				controls.autoRotate = true;
+				controls.autoRotateSpeed = - 1.0;
+				controls.enableDamping = true;
+
+				// Material
+
+				const vertexShader = `#version 300 es
+
+					in vec3 position;
+					in mat4 instanceMatrix;
+
+					uniform mat4 modelMatrix;
+					uniform mat4 modelViewMatrix;
+					uniform mat4 projectionMatrix;
+					uniform vec3 cameraPos;
+
+					out vec3 vOrigin;
+					out vec3 vDirection;
+
+					void main() {
+						vec4 mvPosition = modelViewMatrix * instanceMatrix * vec4( position, 1.0 );
+
+						vOrigin = vec3( inverse( instanceMatrix * modelMatrix ) * vec4( cameraPos, 1.0 ) ).xyz;
+						vDirection = position - vOrigin;
+
+						gl_Position = projectionMatrix * mvPosition;
+					}
+				`;
+
+				const fragmentShader = `#version 300 es
+					precision highp float;
+					precision highp sampler3D;
+
+					uniform mat4 modelViewMatrix;
+					uniform mat4 projectionMatrix;
+
+					in vec3 vOrigin;
+					in vec3 vDirection;
+
+					out vec4 color;
+
+					uniform sampler3D map;
+
+					uniform float threshold;
+					uniform float steps;
+
+					vec2 hitBox( vec3 orig, vec3 dir ) {
+						const vec3 box_min = vec3( - 0.5 );
+						const vec3 box_max = vec3( 0.5 );
+						vec3 inv_dir = 1.0 / dir;
+						vec3 tmin_tmp = ( box_min - orig ) * inv_dir;
+						vec3 tmax_tmp = ( box_max - orig ) * inv_dir;
+						vec3 tmin = min( tmin_tmp, tmax_tmp );
+						vec3 tmax = max( tmin_tmp, tmax_tmp );
+						float t0 = max( tmin.x, max( tmin.y, tmin.z ) );
+						float t1 = min( tmax.x, min( tmax.y, tmax.z ) );
+						return vec2( t0, t1 );
+					}
+
+					float sample1( vec3 p ) {
+						return texture( map, p ).r;
+					}
+
+					#define epsilon .0001
+
+					vec3 normal( vec3 coord ) {
+						if ( coord.x < epsilon ) return vec3( 1.0, 0.0, 0.0 );
+						if ( coord.y < epsilon ) return vec3( 0.0, 1.0, 0.0 );
+						if ( coord.z < epsilon ) return vec3( 0.0, 0.0, 1.0 );
+						if ( coord.x > 1.0 - epsilon ) return vec3( - 1.0, 0.0, 0.0 );
+						if ( coord.y > 1.0 - epsilon ) return vec3( 0.0, - 1.0, 0.0 );
+						if ( coord.z > 1.0 - epsilon ) return vec3( 0.0, 0.0, - 1.0 );
+
+						float step = 0.01;
+						float x = sample1( coord + vec3( - step, 0.0, 0.0 ) ) - sample1( coord + vec3( step, 0.0, 0.0 ) );
+						float y = sample1( coord + vec3( 0.0, - step, 0.0 ) ) - sample1( coord + vec3( 0.0, step, 0.0 ) );
+						float z = sample1( coord + vec3( 0.0, 0.0, - step ) ) - sample1( coord + vec3( 0.0, 0.0, step ) );
+
+						return normalize( vec3( x, y, z ) );
+					}
+
+					void main(){
+
+						vec3 rayDir = normalize( vDirection );
+						vec2 bounds = hitBox( vOrigin, rayDir );
+
+						if ( bounds.x > bounds.y ) discard;
+
+						bounds.x = max( bounds.x, 0.0 );
+
+						vec3 p = vOrigin + bounds.x * rayDir;
+						vec3 inc = 1.0 / abs( rayDir );
+						float delta = min( inc.x, min( inc.y, inc.z ) );
+						delta /= 50.0;
+
+						for ( float t = bounds.x; t < bounds.y; t += delta ) {
+
+							float d = sample1( p + 0.5 );
+
+							if ( d > 0.5 ) {
+
+								color.rgb = p * 2.0; // normal( p + 0.5 ); // * 0.5 + ( p * 1.5 + 0.25 );
+								color.a = 1.;
+								break;
+
+							}
+
+							p += rayDir * delta;
+
+						}
+
+						if ( color.a == 0.0 ) discard;
+
+					}
+				`;
+
+				var loader = new VOXLoader();
+				loader.load( 'models/vox/menger.vox', function ( chunks ) {
+
+					for ( var i = 0; i < chunks.length; i ++ ) {
+
+						const chunk = chunks[ i ];
+						const data = chunk.data;
+						const size = chunk.size;
+
+						const array = new Uint8Array( size.x * size.y * size.z );
+
+						console.log( size.x, size.y, size.z );
+
+						for ( var j = 0, k = 0; j < data.length; j += 4, k ++ ) {
+
+							const x = data[ j + 0 ];
+							const y = data[ j + 1 ];
+							const z = data[ j + 2 ];
+
+							const index = x + ( y * size.x ) + ( z * size.x * size.y );
+
+							array[ index ] = 255.0;
+
+						}
+
+						const texture = new THREE.DataTexture3D( array, size.x, size.y, size.z );
+						texture.format = THREE.RedFormat;
+						texture.minFilter = THREE.NearestFilter;
+						texture.magFilter = THREE.LinearFilter;
+						texture.unpackAlignment = 1;
+
+						const geometry = new THREE.BoxBufferGeometry( 1, 1, 1 );
+						const material = new THREE.RawShaderMaterial( {
+							uniforms: {
+								map: { value: texture },
+								cameraPos: { value: new THREE.Vector3() }
+							},
+							vertexShader,
+							fragmentShader,
+							side: THREE.BackSide
+						} );
+
+						const mesh = new THREE.InstancedMesh( geometry, material, 100000 );
+						mesh.onBeforeRender = function () {
+
+							this.material.uniforms.cameraPos.value.copy( camera.position );
+
+						};
+
+						const transform = new THREE.Object3D();
+
+						for ( let i = 0; i < mesh.count; i ++ ) {
+
+							transform.position.random().subScalar( 0.5 ).multiplyScalar( 150 );
+							transform.rotation.x = Math.random() * Math.PI;
+							transform.rotation.y = Math.random() * Math.PI;
+							transform.rotation.z = Math.random() * Math.PI;
+							transform.updateMatrix();
+
+							mesh.setMatrixAt( i, transform.matrix );
+
+						}
+
+						scene.add( mesh );
+
+					}
+
+				} );
+
+				window.addEventListener( 'resize', onWindowResize, false );
+
+			}
+
+			function onWindowResize() {
+
+				camera.aspect = window.innerWidth / window.innerHeight;
+				camera.updateProjectionMatrix();
+
+				renderer.setSize( window.innerWidth, window.innerHeight );
+
+			}
+
+			function animate() {
+
+				requestAnimationFrame( animate );
+
+				controls.update();
+
+				renderer.render( scene, camera );
+
+			}
+
+		</script>
+
+	</body>
+</html>

examples/webgl2_volume_perlin.html

@@ -91,12 +91,12 @@
 					out vec3 vDirection;
 
 					void main() {
-						vec4 worldPosition = modelViewMatrix * vec4( position, 1.0 );
+						vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
 
 						vOrigin = vec3( inverse( modelMatrix ) * vec4( cameraPos, 1.0 ) ).xyz;
 						vDirection = position - vOrigin;
 
-						gl_Position = projectionMatrix * worldPosition;
+						gl_Position = projectionMatrix * mvPosition;
 					}
 				`;
 

examples/webgl_buffergeometry_compression.html

@@ -106,7 +106,7 @@
 
 				//
 
-				var geom = newGeometry(data);
+				var geom = newGeometry( data );
 
 				var mesh = new THREE.Mesh( geom, meshMaterial );
 				var lineSegments = new THREE.LineSegments( new THREE.WireframeGeometry( geom ), lineMaterial );
@@ -120,24 +120,26 @@
 				gui = new GUI();
 				gui.width = 350;
 
-				function newGeometry(data) {
+				function newGeometry( data ) {
 
-					switch (data.model) {
-						case "Icosahedron": 
+					switch ( data.model ) {
+
+						case "Icosahedron":
 							return new THREE.IcosahedronBufferGeometry( radius, data.detail );
-						case "Cylinder": 
+						case "Cylinder":
 							return new THREE.CylinderBufferGeometry( radius, radius, radius * 2, data.detail * 6 );
-						case "Teapot": 
+						case "Teapot":
 							return new TeapotBufferGeometry( radius, data.detail * 3, true, true, true, true, true );
-						case "TorusKnot": 
+						case "TorusKnot":
 							return new THREE.TorusKnotBufferGeometry( radius, 10, data.detail * 20, data.detail * 6, 3, 4 );
-					}
+
+		}
 
 				}
 
 				function generateGeometry() {
 
-					geom = newGeometry(data);
+					geom = newGeometry( data );
 
 					updateGroupGeometry(
 						mesh,
@@ -155,7 +157,7 @@
 				}
 
 				var folder = gui.addFolder( 'Scene' );
-				folder.add( data, 'model', ["Icosahedron", "Cylinder", "TorusKnot", "Teapot"] ).onChange( generateGeometry );
+				folder.add( data, 'model', [ "Icosahedron", "Cylinder", "TorusKnot", "Teapot" ] ).onChange( generateGeometry );
 				folder.add( data, 'wireframe', false ).onChange( updateLineSegments );
 				folder.add( data, 'texture', false ).onChange( generateGeometry );
 				folder.add( data, 'detail', 1, 8, 1 ).onChange( generateGeometry );
@@ -167,7 +169,7 @@
 				folder.open();
 
 				folder = gui.addFolder( 'Normal Compression' );
-				folder.add( data, 'NormEncodingMethods', ["None", "DEFAULT", "OCT1Byte", "OCT2Byte", "ANGLES"] ).onChange( generateGeometry );
+				folder.add( data, 'NormEncodingMethods', [ "None", "DEFAULT", "OCT1Byte", "OCT2Byte", "ANGLES" ] ).onChange( generateGeometry );
 				folder.open();
 
 				folder = gui.addFolder( 'UV Compression' );
@@ -252,19 +254,19 @@
 				mesh.material = new THREE.MeshPhongMaterial( { color: 0xffffff, emissive: 0x111111 } );
 				mesh.material.map = data.texture ? texture : null;
 
-				if ( data["QuantizePosEncoding"] ) {
+				if ( data[ "QuantizePosEncoding" ] ) {
 
 					GeometryCompressionUtils.compressPositions( mesh );
 
 				}
 
-				if ( data["NormEncodingMethods"] !== "None" ) {
+				if ( data[ "NormEncodingMethods" ] !== "None" ) {
 
-					GeometryCompressionUtils.compressNormals( mesh, data["NormEncodingMethods"] );
+					GeometryCompressionUtils.compressNormals( mesh, data[ "NormEncodingMethods" ] );
 
 				}
 
-				if ( data["DefaultUVEncoding"] ) {
+				if ( data[ "DefaultUVEncoding" ] ) {
 
 					GeometryCompressionUtils.compressUvs( mesh );
 
@@ -278,7 +280,7 @@
 			function computeGPUMemory( mesh ) {
 
 				// Use BufferGeometryUtils to do memory calculation
-				memoryDisplay.setValue( BufferGeometryUtils.estimateBytesUsed(mesh.geometry) + " bytes");
+				memoryDisplay.setValue( BufferGeometryUtils.estimateBytesUsed( mesh.geometry ) + " bytes" );
 
 			}
 

examples/webgl_loader_3dm.html

@@ -0,0 +1,147 @@
+<!DOCTYPE html>
+<html lang="en">
+	<head>
+		<title>three.js webgl - loaders - Rhino 3DM loader</title>
+		<meta charset="utf-8">
+		<meta name="viewport" content="width=device-width, user-scalable=no, minimum-scale=1.0, maximum-scale=1.0">
+		<link type="text/css" rel="stylesheet" href="main.css">
+	</head>
+
+	<body>
+		<div id="info">
+			<a href="https://threejs.org" target="_blank" rel="noopener">three.js</a> - Rhino 3DM loader
+		</div>
+
+		<script type="module">
+
+			import * as THREE from '../build/three.module.js';
+			import { CSS2DRenderer } from './jsm/renderers/CSS2DRenderer.js';
+
+			import { OrbitControls } from './jsm/controls/OrbitControls.js';
+			import { Rhino3dmLoader } from './jsm/loaders/3DMLoader.js';
+
+			import { GUI } from './jsm/libs/dat.gui.module.js';
+
+			var container, controls;
+			var camera, scene, renderer, labelRenderer;
+			var gui;
+
+			init();
+			animate();
+
+			function init() {
+
+				THREE.Object3D.DefaultUp = new THREE.Vector3( 0, 0, 1 );
+				container = document.createElement( 'div' );
+				document.body.appendChild( container );
+
+				camera = new THREE.PerspectiveCamera( 60, window.innerWidth / window.innerHeight, 1, 1000 );
+				camera.position.set( 26, - 40, 5 );
+
+				scene = new THREE.Scene();
+
+				scene.add( new THREE.AmbientLight( { intensity: 0.0001 } ) );
+
+				var directionalLight = new THREE.DirectionalLight( 0xffffff );
+				directionalLight.position.set( 0, 0, 2 );
+				directionalLight.castShadow = true;
+				directionalLight.intensity = 2;
+				scene.add( directionalLight );
+
+				var loader = new Rhino3dmLoader();
+				loader.setLibraryPath( 'jsm/libs/rhino3dm/' );
+
+				loader.load( 'models/3dm/Rhino_Logo.3dm', function ( object ) {
+
+					console.log( object );
+					scene.add( object );
+					initGUI( object.userData.layers );
+
+				} );
+
+				var width = window.innerWidth;
+				var height = window.innerHeight;
+
+				renderer = new THREE.WebGLRenderer( { antialias: true } );
+				renderer.setPixelRatio( window.devicePixelRatio );
+				renderer.setSize( width, height );
+				container.appendChild( renderer.domElement );
+
+				labelRenderer = new CSS2DRenderer();
+				labelRenderer.setSize( width, height );
+				labelRenderer.domElement.style.position = 'absolute';
+				labelRenderer.domElement.style.top = '0px';
+				container.appendChild( labelRenderer.domElement );
+
+				controls = new OrbitControls( camera, container );
+
+				window.addEventListener( 'resize', resize, false );
+
+			}
+
+			function resize() {
+
+				var width = window.innerWidth;
+				var height = window.innerHeight;
+
+				camera.aspect = width / height;
+				camera.updateProjectionMatrix();
+
+				renderer.setSize( width, height );
+				labelRenderer.setSize( width, height );
+
+			}
+
+			function animate() {
+
+				controls.update();
+				renderer.render( scene, camera );
+				labelRenderer.render( scene, camera );
+
+				requestAnimationFrame( animate );
+
+			}
+
+			function initGUI( layers ) {
+
+				gui = new GUI( { width: 300 } );
+				var layersControl = gui.addFolder( 'layers' );
+				layersControl.open();
+
+				for ( var i = 0; i < layers.length; i ++ ) {
+
+					var layer = layers[ i ];
+					layersControl.add( layer, 'visible' ).name( layer.name ).onChange( function ( val ) {
+
+						var name = this.object.name;
+
+						scene.traverse( function ( child ) {
+
+							if ( child.userData.hasOwnProperty( 'attributes' ) ) {
+
+								if ( 'layerIndex' in child.userData.attributes ) {
+
+									var layerName = layers[ child.userData.attributes.layerIndex ].name;
+
+									if ( layerName === name ) {
+										
+										child.visible = val;
+										layer.visible = val;
+
+									}
+
+								}
+
+							}
+
+						} );
+
+					} );
+
+				}
+
+			}
+		</script>
+
+	</body>
+</html>

examples/webgl_materials_cubemap_dynamic.html

@@ -28,7 +28,7 @@
 
 			textureLoader.load( 'textures/2294472375_24a3b8ef46_o.jpg', function ( texture ) {
 
-				texture.mapping = THREE.UVMapping;
+				texture.encoding = THREE.sRGBEncoding;
 
 				init( texture );
 				animate();
@@ -40,6 +40,9 @@
 				renderer = new THREE.WebGLRenderer( { antialias: true } );
 				renderer.setPixelRatio( window.devicePixelRatio );
 				renderer.setSize( window.innerWidth, window.innerHeight );
+				document.body.appendChild( renderer.domElement );
+
+				renderer.outputEncoding = THREE.sRGBEncoding;
 
 				scene = new THREE.Scene();
 
@@ -47,30 +50,35 @@
 
 				// background
 
-				var options = {
-					generateMipmaps: true,
-					minFilter: THREE.LinearMipmapLinearFilter,
-					magFilter: THREE.LinearFilter
-				};
-
+				var options = {}; // none required
 				scene.background = new THREE.WebGLCubeRenderTarget( 1024, options ).fromEquirectangularTexture( renderer, texture );
 
 				//
 
-				cubeRenderTarget1 = new THREE.WebGLCubeRenderTarget( 256, { format: THREE.RGBFormat, generateMipmaps: true, minFilter: THREE.LinearMipmapLinearFilter } );
+				cubeRenderTarget1 = new THREE.WebGLCubeRenderTarget( 256, {
+					format: THREE.RGBFormat,
+					generateMipmaps: true,
+					minFilter: THREE.LinearMipmapLinearFilter,
+					encoding: THREE.sRGBEncoding // temporary -- to prevent the material's shader from recompiling every frame
+				} );
+
 				cubeCamera1 = new THREE.CubeCamera( 1, 1000, cubeRenderTarget1 );
-				scene.add( cubeCamera1 );
 
-				cubeRenderTarget2 = new THREE.WebGLCubeRenderTarget( 256, { format: THREE.RGBFormat, generateMipmaps: true, minFilter: THREE.LinearMipmapLinearFilter } );
-				cubeCamera2 = new THREE.CubeCamera( 1, 1000, cubeRenderTarget2 );
-				scene.add( cubeCamera2 );
+				cubeRenderTarget2 = new THREE.WebGLCubeRenderTarget( 256, {
+					format: THREE.RGBFormat,
+					generateMipmaps: true,
+					minFilter: THREE.LinearMipmapLinearFilter,
+					encoding: THREE.sRGBEncoding
+				} );
 
-				document.body.appendChild( renderer.domElement );
+				cubeCamera2 = new THREE.CubeCamera( 1, 1000, cubeRenderTarget2 );
 
 				//
 
 				material = new THREE.MeshBasicMaterial( {
-					envMap: cubeRenderTarget2.texture
+					envMap: cubeRenderTarget2.texture,
+					combine: THREE.MultiplyOperation,
+					reflectivity: 1
 				} );
 
 				sphere = new THREE.Mesh( new THREE.IcosahedronBufferGeometry( 20, 3 ), material );
@@ -79,7 +87,7 @@
 				cube = new THREE.Mesh( new THREE.BoxBufferGeometry( 20, 20, 20 ), material );
 				scene.add( cube );
 
-				torus = new THREE.Mesh( new THREE.TorusKnotBufferGeometry( 10, 5, 100, 25 ), material );
+				torus = new THREE.Mesh( new THREE.TorusKnotBufferGeometry( 10, 5, 128, 16 ), material );
 				scene.add( torus );
 
 				//

examples/webgl_materials_envmaps.html

@@ -22,10 +22,8 @@
 			import { OrbitControls } from './jsm/controls/OrbitControls.js';
 
 			var controls, camera, scene, renderer;
-			var cameraCube, sceneCube;
 			var textureEquirec, textureCube;
-			var cubeMesh, sphereMesh;
-			var sphereMaterial;
+			var sphereMesh, sphereMaterial;
 
 			init();
 			animate();
@@ -36,12 +34,10 @@
 
 				camera = new THREE.PerspectiveCamera( 70, window.innerWidth / window.innerHeight, 1, 100000 );
 				camera.position.set( 0, 0, 1000 );
-				cameraCube = new THREE.PerspectiveCamera( 70, window.innerWidth / window.innerHeight, 1, 100000 );
 
 				// SCENE
 
 				scene = new THREE.Scene();
-				sceneCube = new THREE.Scene();
 
 				// Lights
 
@@ -50,12 +46,10 @@
 
 				// Textures
 
-				var r = 'textures/cube/Bridge2/';
-				var urls = [ r + 'posx.jpg', r + 'negx.jpg',
-							 r + 'posy.jpg', r + 'negy.jpg',
-							 r + 'posz.jpg', r + 'negz.jpg' ];
+				var loader = new THREE.CubeTextureLoader();
+				loader.setPath( 'textures/cube/Bridge2/' );
 
-				textureCube = new THREE.CubeTextureLoader().load( urls );
+				textureCube = loader.load( [ 'posx.jpg', 'negx.jpg', 'posy.jpg', 'negy.jpg', 'posz.jpg', 'negz.jpg' ] );
 				textureCube.encoding = THREE.sRGBEncoding;
 
 				var textureLoader = new THREE.TextureLoader();
@@ -64,65 +58,22 @@
 				textureEquirec.mapping = THREE.EquirectangularReflectionMapping;
 				textureEquirec.encoding = THREE.sRGBEncoding;
 
-				// Materials
-
-				var equirectShader = THREE.ShaderLib[ 'equirect' ];
-
-				var equirectMaterial = new THREE.ShaderMaterial( {
-					uniforms: THREE.UniformsUtils.clone( equirectShader.uniforms ),
-					fragmentShader: equirectShader.fragmentShader,
-					vertexShader: equirectShader.vertexShader,
-					depthWrite: false,
-					side: THREE.BackSide
-				} );
-
-				equirectMaterial.uniforms[ 'tEquirect' ].value = textureEquirec;
-
-				// enable code injection for non-built-in material
-				Object.defineProperty( equirectMaterial, 'map', {
-
-					get: function () {
-
-						return this.uniforms.tEquirect.value;
-
-					}
-
-				} );
-
-				var cubeShader = THREE.ShaderLib[ 'cube' ];
-
-				var cubeMaterial = new THREE.ShaderMaterial( {
-					uniforms: THREE.UniformsUtils.clone( cubeShader.uniforms ),
-					fragmentShader: cubeShader.fragmentShader,
-					vertexShader: cubeShader.vertexShader,
-					depthWrite: false,
-					side: THREE.BackSide
-				} );
-
-				cubeMaterial.envMap = textureCube;
-
-				// Skybox
-
-				cubeMesh = new THREE.Mesh( new THREE.BoxBufferGeometry( 100, 100, 100 ), cubeMaterial );
-				sceneCube.add( cubeMesh );
+				scene.background = textureCube;
 
 				//
 
-				var geometry = new THREE.SphereBufferGeometry( 400.0, 48, 24 );
+				var geometry = new THREE.IcosahedronBufferGeometry( 400, 4 );
 				sphereMaterial = new THREE.MeshLambertMaterial( { envMap: textureCube } );
 				sphereMesh = new THREE.Mesh( geometry, sphereMaterial );
-
 				scene.add( sphereMesh );
 
 				//
 
 				renderer = new THREE.WebGLRenderer();
-				renderer.autoClear = false;
 				renderer.setPixelRatio( window.devicePixelRatio );
 				renderer.setSize( window.innerWidth, window.innerHeight );
-				document.body.appendChild( renderer.domElement );
-
 				renderer.outputEncoding = THREE.sRGBEncoding;
+				document.body.appendChild( renderer.domElement );
 
 				//
 
@@ -135,16 +86,16 @@
 				var params = {
 					Cube: function () {
 
-						cubeMesh.material = cubeMaterial;
-						cubeMesh.visible = true;
+						scene.background = textureCube;
+
 						sphereMaterial.envMap = textureCube;
 						sphereMaterial.needsUpdate = true;
 
 					},
 					Equirectangular: function () {
 
-						cubeMesh.material = equirectMaterial;
-						cubeMesh.visible = true;
+						scene.background = textureEquirec;
+
 						sphereMaterial.envMap = textureEquirec;
 						sphereMaterial.needsUpdate = true;
 
@@ -183,9 +134,6 @@
 				camera.aspect = window.innerWidth / window.innerHeight;
 				camera.updateProjectionMatrix();
 
-				cameraCube.aspect = window.innerWidth / window.innerHeight;
-				cameraCube.updateProjectionMatrix();
-
 				renderer.setSize( window.innerWidth, window.innerHeight );
 
 			}
@@ -203,9 +151,6 @@
 			function render() {
 
 				camera.lookAt( scene.position );
-				cameraCube.rotation.copy( camera.rotation );
-
-				renderer.render( sceneCube, cameraCube );
 				renderer.render( scene, camera );
 
 			}

examples/webgl_materials_envmaps_parallax.html

@@ -173,22 +173,6 @@
 
 						vec4 envMapColor = textureCubeUV( envMap, reflectVec, roughness );
 
-					#elif defined( ENVMAP_TYPE_EQUIREC )
-
-						vec2 sampleUV = equirectUv( reflectVec );
-
-						#ifdef TEXTURE_LOD_EXT
-
-							vec4 envMapColor = texture2DLodEXT( envMap, sampleUV, specularMIPLevel );
-
-						#else
-
-							vec4 envMapColor = texture2D( envMap, sampleUV, specularMIPLevel );
-
-						#endif
-
-						envMapColor.rgb = envMapTexelToLinear( envMapColor ).rgb;
-
 					#endif
 
 					return envMapColor.rgb * envMapIntensity;

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "three",
-  "version": "0.118.3",
+  "version": "0.119.1",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -49,12 +49,12 @@
       "dev": true
     },
     "@typescript-eslint/eslint-plugin": {
-      "version": "3.6.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-3.6.1.tgz",
-      "integrity": "sha512-06lfjo76naNeOMDl+mWG9Fh/a0UHKLGhin+mGaIw72FUMbMGBkdi/FEJmgEDzh4eE73KIYzHWvOCYJ0ak7nrJQ==",
+      "version": "3.9.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-3.9.0.tgz",
+      "integrity": "sha512-UD6b4p0/hSe1xdTvRCENSx7iQ+KR6ourlZFfYuPC7FlXEzdHuLPrEmuxZ23b2zW96KJX9Z3w05GE/wNOiEzrVg==",
       "dev": true,
       "requires": {
-        "@typescript-eslint/experimental-utils": "3.6.1",
+        "@typescript-eslint/experimental-utils": "3.9.0",
         "debug": "^4.1.1",
         "functional-red-black-tree": "^1.0.1",
         "regexpp": "^3.0.0",
@@ -63,45 +63,45 @@
       }
     },
     "@typescript-eslint/experimental-utils": {
-      "version": "3.6.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-3.6.1.tgz",
-      "integrity": "sha512-oS+hihzQE5M84ewXrTlVx7eTgc52eu+sVmG7ayLfOhyZmJ8Unvf3osyFQNADHP26yoThFfbxcibbO0d2FjnYhg==",
+      "version": "3.9.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/experimental-utils/-/experimental-utils-3.9.0.tgz",
+      "integrity": "sha512-/vSHUDYizSOhrOJdjYxPNGfb4a3ibO8zd4nUKo/QBFOmxosT3cVUV7KIg8Dwi6TXlr667G7YPqFK9+VSZOorNA==",
       "dev": true,
       "requires": {
         "@types/json-schema": "^7.0.3",
-        "@typescript-eslint/types": "3.6.1",
-        "@typescript-eslint/typescript-estree": "3.6.1",
+        "@typescript-eslint/types": "3.9.0",
+        "@typescript-eslint/typescript-estree": "3.9.0",
         "eslint-scope": "^5.0.0",
         "eslint-utils": "^2.0.0"
       }
     },
     "@typescript-eslint/parser": {
-      "version": "3.6.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-3.6.1.tgz",
-      "integrity": "sha512-SLihQU8RMe77YJ/jGTqOt0lMq7k3hlPVfp7v/cxMnXA9T0bQYoMDfTsNgHXpwSJM1Iq2aAJ8WqekxUwGv5F67Q==",
+      "version": "3.9.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-3.9.0.tgz",
+      "integrity": "sha512-rDHOKb6uW2jZkHQniUQVZkixQrfsZGUCNWWbKWep4A5hGhN5dLHMUCNAWnC4tXRlHedXkTDptIpxs6e4Pz8UfA==",
       "dev": true,
       "requires": {
         "@types/eslint-visitor-keys": "^1.0.0",
-        "@typescript-eslint/experimental-utils": "3.6.1",
-        "@typescript-eslint/types": "3.6.1",
-        "@typescript-eslint/typescript-estree": "3.6.1",
+        "@typescript-eslint/experimental-utils": "3.9.0",
+        "@typescript-eslint/types": "3.9.0",
+        "@typescript-eslint/typescript-estree": "3.9.0",
         "eslint-visitor-keys": "^1.1.0"
       }
     },
     "@typescript-eslint/types": {
-      "version": "3.6.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-3.6.1.tgz",
-      "integrity": "sha512-NPxd5yXG63gx57WDTW1rp0cF3XlNuuFFB5G+Kc48zZ+51ZnQn9yjDEsjTPQ+aWM+V+Z0I4kuTFKjKvgcT1F7xQ==",
+      "version": "3.9.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-3.9.0.tgz",
+      "integrity": "sha512-rb6LDr+dk9RVVXO/NJE8dT1pGlso3voNdEIN8ugm4CWM5w5GimbThCMiMl4da1t5u3YwPWEwOnKAULCZgBtBHg==",
       "dev": true
     },
     "@typescript-eslint/typescript-estree": {
-      "version": "3.6.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-3.6.1.tgz",
-      "integrity": "sha512-G4XRe/ZbCZkL1fy09DPN3U0mR6SayIv1zSeBNquRFRk7CnVLgkC2ZPj8llEMJg5Y8dJ3T76SvTGtceytniaztQ==",
+      "version": "3.9.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-3.9.0.tgz",
+      "integrity": "sha512-N+158NKgN4rOmWVfvKOMoMFV5n8XxAliaKkArm/sOypzQ0bUL8MSnOEBW3VFIeffb/K5ce/cAV0yYhR7U4ALAA==",
       "dev": true,
       "requires": {
-        "@typescript-eslint/types": "3.6.1",
-        "@typescript-eslint/visitor-keys": "3.6.1",
+        "@typescript-eslint/types": "3.9.0",
+        "@typescript-eslint/visitor-keys": "3.9.0",
         "debug": "^4.1.1",
         "glob": "^7.1.6",
         "is-glob": "^4.0.1",
@@ -111,18 +111,18 @@
       }
     },
     "@typescript-eslint/visitor-keys": {
-      "version": "3.6.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-3.6.1.tgz",
-      "integrity": "sha512-qC8Olwz5ZyMTZrh4Wl3K4U6tfms0R/mzU4/5W3XeUZptVraGVmbptJbn6h2Ey6Rb3hOs3zWoAUebZk8t47KGiQ==",
+      "version": "3.9.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-3.9.0.tgz",
+      "integrity": "sha512-O1qeoGqDbu0EZUC/MZ6F1WHTIzcBVhGqDj3LhTnj65WUA548RXVxUHbYhAW9bZWfb2rnX9QsbbP5nmeJ5Z4+ng==",
       "dev": true,
       "requires": {
         "eslint-visitor-keys": "^1.1.0"
       }
     },
     "acorn": {
-      "version": "7.3.1",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.3.1.tgz",
-      "integrity": "sha512-tLc0wSnatxAQHVHUapaHdz72pi9KUyHjq5KyHjGg9Y8Ifdc79pTh2XvI6I1/chZbnM7QtNKzh66ooDogPZSleA==",
+      "version": "7.4.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-7.4.0.tgz",
+      "integrity": "sha512-+G7P8jJmCHr+S+cLfQxygbWhXy+8YTVGzAkpEbcLo2mLoL7tij/VG41QSHACSf5QgYRhMZYHuNc6drJaO0Da+w==",
       "dev": true
     },
     "acorn-dynamic-import": {
@@ -348,9 +348,9 @@
       "dev": true
     },
     "concurrently": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/concurrently/-/concurrently-5.2.0.tgz",
-      "integrity": "sha512-XxcDbQ4/43d6CxR7+iV8IZXhur4KbmEJk1CetVMUqCy34z9l0DkszbY+/9wvmSnToTej0SYomc2WSRH+L0zVJw==",
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/concurrently/-/concurrently-5.3.0.tgz",
+      "integrity": "sha512-8MhqOB6PWlBfA2vJ8a0bSFKATOdWlHiQlk11IfmQBPaHVP8oP2gsh2MObE6UR3hqDHqvaIvLTyceNW6obVuFHQ==",
       "dev": true,
       "requires": {
         "chalk": "^2.4.2",
@@ -388,9 +388,9 @@
       }
     },
     "date-fns": {
-      "version": "2.13.0",
-      "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-2.13.0.tgz",
-      "integrity": "sha512-xm0c61mevGF7f0XpCGtDTGpzEFC/1fpLXHbmFpxZZQJuvByIK2ozm6cSYuU+nxFYOPh2EuCfzUwlTEFwKG+h5w==",
+      "version": "2.15.0",
+      "resolved": "https://registry.npmjs.org/date-fns/-/date-fns-2.15.0.tgz",
+      "integrity": "sha512-ZCPzAMJZn3rNUvvQIMlXhDr4A+Ar07eLeGsGREoWU19a3Pqf5oYa+ccd+B3F6XVtQY6HANMFdOQ8A+ipFnvJdQ==",
       "dev": true
     },
     "debug": {
@@ -449,9 +449,9 @@
       }
     },
     "domutils": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.0.0.tgz",
-      "integrity": "sha512-n5SelJ1axbO636c2yUtOGia/IcJtVtlhQbFiVDBZHKV5ReJO1ViX7sFEemtuyoAnBxk5meNSYgA8V4s0271efg==",
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/domutils/-/domutils-2.1.0.tgz",
+      "integrity": "sha512-CD9M0Dm1iaHfQ1R/TI+z3/JWp/pgub0j4jIQKH89ARR4ATAV2nbaOQS5XxU9maJP5jHaPdDDQSEHuE2UmpUTKg==",
       "dev": true,
       "requires": {
         "dom-serializer": "^0.2.1",
@@ -495,9 +495,9 @@
       }
     },
     "entities": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/entities/-/entities-2.0.0.tgz",
-      "integrity": "sha512-D9f7V0JSRwIxlRI2mjMqufDrRDnx8p+eEOz7aUM9SuvF8gsBzra0/6tbjl1m8eQHrZlYj6PxqE00hZ1SAIKPLw==",
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-2.0.3.tgz",
+      "integrity": "sha512-MyoZ0jgnLvB2X3Lg5HqpFmn1kybDiIfEQmKzTb5apr51Rb+T3KdmMiqa70T+bhGnyv7bQ6WMj2QMHpGMmlrUYQ==",
       "dev": true
     },
     "error-ex": {
@@ -516,9 +516,9 @@
       "dev": true
     },
     "eslint": {
-      "version": "7.4.0",
-      "resolved": "https://registry.npmjs.org/eslint/-/eslint-7.4.0.tgz",
-      "integrity": "sha512-gU+lxhlPHu45H3JkEGgYhWhkR9wLHHEXC9FbWFnTlEkbKyZKWgWRLgf61E8zWmBuI6g5xKBph9ltg3NtZMVF8g==",
+      "version": "7.6.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-7.6.0.tgz",
+      "integrity": "sha512-QlAManNtqr7sozWm5TF4wIH9gmUm2hE3vNRUvyoYAa4y1l5/jxD/PQStEjBMQtCqZmSep8UxrcecI60hOpe61w==",
       "dev": true,
       "requires": {
         "@babel/code-frame": "^7.0.0",
@@ -529,9 +529,9 @@
         "doctrine": "^3.0.0",
         "enquirer": "^2.3.5",
         "eslint-scope": "^5.1.0",
-        "eslint-utils": "^2.0.0",
-        "eslint-visitor-keys": "^1.2.0",
-        "espree": "^7.1.0",
+        "eslint-utils": "^2.1.0",
+        "eslint-visitor-keys": "^1.3.0",
+        "espree": "^7.2.0",
         "esquery": "^1.2.0",
         "esutils": "^2.0.2",
         "file-entry-cache": "^5.0.1",
@@ -545,7 +545,7 @@
         "js-yaml": "^3.13.1",
         "json-stable-stringify-without-jsonify": "^1.0.1",
         "levn": "^0.4.1",
-        "lodash": "^4.17.14",
+        "lodash": "^4.17.19",
         "minimatch": "^3.0.4",
         "natural-compare": "^1.4.0",
         "optionator": "^0.9.1",
@@ -633,9 +633,9 @@
       "dev": true
     },
     "eslint-plugin-html": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/eslint-plugin-html/-/eslint-plugin-html-6.0.2.tgz",
-      "integrity": "sha512-Ik/z32UteKLo8GEfwNqVKcJ/WOz/be4h8N5mbMmxxnZ+9aL9XczOXQFz/bGu+nAGVoRg8CflldxJhONFpqlrxw==",
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/eslint-plugin-html/-/eslint-plugin-html-6.0.3.tgz",
+      "integrity": "sha512-1KV2ebQHywlXkfpXOGjxuEyoq+g6AWvD6g9TB28KsGhbM5rJeHXAEpHOev6LqZv6ylcfa9BWokDsNVKyYefzGw==",
       "dev": true,
       "requires": {
         "htmlparser2": "^4.1.0"
@@ -667,14 +667,14 @@
       "dev": true
     },
     "espree": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/espree/-/espree-7.1.0.tgz",
-      "integrity": "sha512-dcorZSyfmm4WTuTnE5Y7MEN1DyoPYy1ZR783QW1FJoenn7RailyWFsq/UL6ZAAA7uXurN9FIpYyUs3OfiIW+Qw==",
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-7.2.0.tgz",
+      "integrity": "sha512-H+cQ3+3JYRMEIOl87e7QdHX70ocly5iW4+dttuR8iYSPr/hXKFb+7dBsZ7+u1adC4VrnPlTkv0+OwuPnDop19g==",
       "dev": true,
       "requires": {
-        "acorn": "^7.2.0",
+        "acorn": "^7.3.1",
         "acorn-jsx": "^5.2.0",
-        "eslint-visitor-keys": "^1.2.0"
+        "eslint-visitor-keys": "^1.3.0"
       },
       "dependencies": {
         "acorn-jsx": {
@@ -701,9 +701,9 @@
       },
       "dependencies": {
         "estraverse": {
-          "version": "5.1.0",
-          "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.1.0.tgz",
-          "integrity": "sha512-FyohXK+R0vE+y1nHLoBM7ZTyqRpqAlhdZHCWIWEviFLiGB8b04H6bQs8G+XTthacvT8VuwvteiP7RJSxMs8UEw==",
+          "version": "5.2.0",
+          "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.2.0.tgz",
+          "integrity": "sha512-BxbNGGNm0RyRYvUdHpIwv9IWzeM9XClbOxwoATuFdOE7ZE6wHL+HQ5T8hoPM+zHvmKzzsEqhgy0GrQ5X13afiQ==",
           "dev": true
         }
       }
@@ -872,52 +872,52 @@
       }
     },
     "google-closure-compiler": {
-      "version": "20200628.0.0",
-      "resolved": "https://registry.npmjs.org/google-closure-compiler/-/google-closure-compiler-20200628.0.0.tgz",
-      "integrity": "sha512-ZMhFmlzNCWdL43UbTHzdFa4fgAfBR37TbAOKLSLUATT3RvCNu0AvX0rQBuJNzmI21ySsM9T3r5WXPBwiL0Hn4g==",
+      "version": "20200719.0.0",
+      "resolved": "https://registry.npmjs.org/google-closure-compiler/-/google-closure-compiler-20200719.0.0.tgz",
+      "integrity": "sha512-2fZl8M6U7KTXami1joNo9e5hW88iZX1MGBSHWlDaeBqSYkvLUH2Qn/VltAQuluSRBIjPXXhxZGKHyJamVoFFnA==",
       "dev": true,
       "requires": {
         "chalk": "2.x",
-        "google-closure-compiler-java": "^20200628.0.0",
-        "google-closure-compiler-js": "^20200628.0.0",
-        "google-closure-compiler-linux": "^20200628.0.0",
-        "google-closure-compiler-osx": "^20200628.0.0",
-        "google-closure-compiler-windows": "^20200628.0.0",
+        "google-closure-compiler-java": "^20200719.0.0",
+        "google-closure-compiler-js": "^20200719.0.0",
+        "google-closure-compiler-linux": "^20200719.0.0",
+        "google-closure-compiler-osx": "^20200719.0.0",
+        "google-closure-compiler-windows": "^20200719.0.0",
         "minimist": "1.x",
         "vinyl": "2.x",
         "vinyl-sourcemaps-apply": "^0.2.0"
       }
     },
     "google-closure-compiler-java": {
-      "version": "20200628.0.0",
-      "resolved": "https://registry.npmjs.org/google-closure-compiler-java/-/google-closure-compiler-java-20200628.0.0.tgz",
-      "integrity": "sha512-ikQEHiuaRR8d3w4QWsJqC2baDfoIyw/KqDW7LXyxbq6WpRiJ+ItTAtShVoqzQTyn3IXVL8viUMGb/AxkUv01RA==",
+      "version": "20200719.0.0",
+      "resolved": "https://registry.npmjs.org/google-closure-compiler-java/-/google-closure-compiler-java-20200719.0.0.tgz",
+      "integrity": "sha512-/alYc8OC9zAETZ2m10OhtqI+PAs2b8y6cLn2VlN/53dHrCC6gKqj7Ajun/GAVAUOW4HMRMnpBYdCJgMLpAniSA==",
       "dev": true
     },
     "google-closure-compiler-js": {
-      "version": "20200628.0.0",
-      "resolved": "https://registry.npmjs.org/google-closure-compiler-js/-/google-closure-compiler-js-20200628.0.0.tgz",
-      "integrity": "sha512-kGO/fvKDNOawBmzpWEzLW2EMb0ikTc0Y1hZEedLOex/cOm9zc5Cn8w2L0f963ydgFcj4fszzIgAtmZ9CRxqkfg==",
+      "version": "20200719.0.0",
+      "resolved": "https://registry.npmjs.org/google-closure-compiler-js/-/google-closure-compiler-js-20200719.0.0.tgz",
+      "integrity": "sha512-cuowL5A4VOx9yxxMc3sSiqcj/d9aYjnHgFDvDB/dpMMOhlUMN1MDsVubuEc32tut7k/FTYFZY114CLH4r2q9/A==",
       "dev": true
     },
     "google-closure-compiler-linux": {
-      "version": "20200628.0.0",
-      "resolved": "https://registry.npmjs.org/google-closure-compiler-linux/-/google-closure-compiler-linux-20200628.0.0.tgz",
-      "integrity": "sha512-SSglqHEW+PtHCOXPwhZFxFzRVxXdvyunkfwP0y2FAO2b0xF6lRfrZSgs0/lgkwlcO2RHnJtIhU8y4bzYMn24QQ==",
+      "version": "20200719.0.0",
+      "resolved": "https://registry.npmjs.org/google-closure-compiler-linux/-/google-closure-compiler-linux-20200719.0.0.tgz",
+      "integrity": "sha512-hqPP8/7g7IMhcVle9xJ0aeiI4oRCucUGrWtQ12VwswKu2tyXTk2BDcXj5WqHae6TDPUONikQ8MCJSIENGLBC2Q==",
       "dev": true,
       "optional": true
     },
     "google-closure-compiler-osx": {
-      "version": "20200628.0.0",
-      "resolved": "https://registry.npmjs.org/google-closure-compiler-osx/-/google-closure-compiler-osx-20200628.0.0.tgz",
-      "integrity": "sha512-Ntd/kYqjYu7CScvne0yscZGqQV19y7BCu5PXxGtcs9G5KLe7Ep9RxPWznvFGZXky5vPc6Yq9p6E2uOhpA20cIg==",
+      "version": "20200719.0.0",
+      "resolved": "https://registry.npmjs.org/google-closure-compiler-osx/-/google-closure-compiler-osx-20200719.0.0.tgz",
+      "integrity": "sha512-Y0RDdOAJ7CLya0pMjmLahiqh7b9aJGybKBTxPywK2CiJj1+z+EtvXN+QsaM0aSE8yvuvIbAWHOX4FjEXMRiTmw==",
       "dev": true,
       "optional": true
     },
     "google-closure-compiler-windows": {
-      "version": "20200628.0.0",
-      "resolved": "https://registry.npmjs.org/google-closure-compiler-windows/-/google-closure-compiler-windows-20200628.0.0.tgz",
-      "integrity": "sha512-Il4NIhzvemgEk2kC33tDj9HVpqXEU8SmS1f3AmkLMAUbSI5FdBBzTqjLRa8Y/ucEz4nTRqvpTvbOG3vhIVUUWw==",
+      "version": "20200719.0.0",
+      "resolved": "https://registry.npmjs.org/google-closure-compiler-windows/-/google-closure-compiler-windows-20200719.0.0.tgz",
+      "integrity": "sha512-U1onpG6RaTpRlR2nac+4GPU27LhJMr4kB4meNihwGvPRXcLh1qVcrKo+BjBuoX+Oq8KFwjc+mif3ldmv4AZzew==",
       "dev": true,
       "optional": true
     },
@@ -1487,9 +1487,9 @@
       }
     },
     "rollup": {
-      "version": "2.21.0",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.21.0.tgz",
-      "integrity": "sha512-BEGgy+wSzux7Ycq58pRiWEOBZaXRXTuvzl1gsm7gqmsAHxkWf9nyA5V2LN9fGSHhhDQd0/C13iRzSh4bbIpWZQ==",
+      "version": "2.23.1",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-2.23.1.tgz",
+      "integrity": "sha512-Heyl885+lyN/giQwxA8AYT2GY3U+gOlTqVLrMQYno8Z1X9lAOpfXPiKiZCyPc25e9BLJM3Zlh957dpTlO4pa8A==",
       "dev": true,
       "requires": {
         "fsevents": "~2.1.2"
@@ -1515,9 +1515,9 @@
       }
     },
     "rxjs": {
-      "version": "6.5.5",
-      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.5.5.tgz",
-      "integrity": "sha512-WfQI+1gohdf0Dai/Bbmk5L5ItH5tYqm3ki2c5GdWhKjalzjg93N3avFjVStyZZz+A2Em+ZxKH5bNghw9UeylGQ==",
+      "version": "6.6.2",
+      "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-6.6.2.tgz",
+      "integrity": "sha512-BHdBMVoWC2sL26w//BCu3YzKT4s2jip/WhwsGEDmeKYBhKDZeYezVUnHatYB7L85v5xs0BAQmg6BEYJEKxBabg==",
       "dev": true,
       "requires": {
         "tslib": "^1.9.0"
@@ -1592,9 +1592,9 @@
       "dev": true
     },
     "spdx-correct": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.0.tgz",
-      "integrity": "sha512-lr2EZCctC2BNR7j7WzJ2FpDznxky1sjfxvvYEyzxNyb6lZXHODmEoJeFu4JupYlkfha1KZpJyoqiJ7pgA1qq8Q==",
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.1.tgz",
+      "integrity": "sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==",
       "dev": true,
       "requires": {
         "spdx-expression-parse": "^3.0.0",
@@ -1608,9 +1608,9 @@
       "dev": true
     },
     "spdx-expression-parse": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.0.tgz",
-      "integrity": "sha512-Yg6D3XpRD4kkOmTpdgbUiEJFKghJH03fiC1OPll5h/0sO6neh2jqRDVHOQ4o/LMea0tgCkbMgea5ip/e+MkWyg==",
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz",
+      "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==",
       "dev": true,
       "requires": {
         "spdx-exceptions": "^2.1.0",
@@ -1698,9 +1698,9 @@
       "dev": true
     },
     "tslib": {
-      "version": "1.10.0",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.10.0.tgz",
-      "integrity": "sha512-qOebF53frne81cf0S9B41ByenJ3/IuH8yJKngAX35CmiZySA0khhkovshKK+jGCaMnVomla7gVlIcc3EvKPbTQ==",
+      "version": "1.13.0",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.13.0.tgz",
+      "integrity": "sha512-i/6DQjL8Xf3be4K/E6Wgpekn5Qasl1usyw++dAA35Ue5orEn65VIxOA+YvNNl9HV3qv70T7CNwjODHZrLwvd1Q==",
       "dev": true
     },
     "tsutils": {
@@ -1728,9 +1728,9 @@
       "dev": true
     },
     "typescript": {
-      "version": "3.9.6",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.6.tgz",
-      "integrity": "sha512-Pspx3oKAPJtjNwE92YS05HQoY7z2SFyOpHo9MqJor3BXAGNaPUs83CuVp9VISFkSjyRfiTpmKuAYGJB7S7hOxw==",
+      "version": "3.9.7",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-3.9.7.tgz",
+      "integrity": "sha512-BLbiRkiBzAwsjut4x/dsibSTB6yWpwT5qWmC2OfuCg3GgVQCSgMs4vEctYPhsaGtd0AeuuHMkjZ2h2WG8MSzRw==",
       "dev": true
     },
     "unicode-canonical-property-names-ecmascript": {

package.json

@@ -41,6 +41,13 @@
         {
           "SwitchCase": 1
         }
+      ],
+      "prefer-const": [
+        "error",
+        {
+          "destructuring": "any",
+          "ignoreReadBeforeAssign": false
+        }
       ]
     }
   },
@@ -48,9 +55,10 @@
     "start": "npm run dev",
     "test": "npm run test-lint && npm run test-unit",
     "build": "rollup -c utils/build/rollup.config.js",
-    "build-closure": "rollup -c utils/build/rollup.config.js && google-closure-compiler --warning_level=VERBOSE --jscomp_off=globalThis --jscomp_off=checkTypes --externs utils/build/externs.js --language_in=ECMASCRIPT5_STRICT --js build/three.js --js_output_file build/three.min.js",
+    "build-closure": "npm run build && google-closure-compiler --warning_level=VERBOSE --jscomp_off=globalThis --jscomp_off=checkTypes --externs utils/build/externs.js --language_in=ECMASCRIPT5_STRICT --js build/three.js --js_output_file build/three.min.js",
     "dev": "concurrently --names \"ROLLUP,HTTP\" -c \"bgBlue.bold,bgGreen.bold\" \"rollup -c utils/build/rollup.config.js -w -m inline\" \"http-server -c-1 -p 8080\"",
     "dev-test": "concurrently --names \"ROLLUP,ROLLUPTEST,HTTP\" -c \"bgBlue.bold,bgRed.bold,bgGreen.bold\" \"rollup -c utils/build/rollup.config.js -w -m inline\" \"npm run dev --prefix test\" \"http-server -p 8080\"",
+    "lint-fix": "eslint src --ext js --ext ts --fix && eslint examples/jsm --ext js --ext ts --ignore-pattern libs --fix",
     "lint-docs": "eslint docs --ext html",
     "lint-examples": "eslint examples/jsm --ext js --ext ts --ignore-pattern libs && tsc -p utils/build/tsconfig-examples.lint.json",
     "test-lint": "eslint src --ext js --ext ts && tsc -p utils/build/tsconfig.lint.json",
@@ -81,17 +89,17 @@
   },
   "homepage": "https://threejs.org/",
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^3.6.1",
-    "@typescript-eslint/parser": "^3.6.1",
-    "concurrently": "^5.2.0",
-    "eslint": "^7.4.0",
+    "@typescript-eslint/eslint-plugin": "^3.9.0",
+    "@typescript-eslint/parser": "^3.9.0",
+    "concurrently": "^5.3.0",
+    "eslint": "^7.6.0",
     "eslint-config-mdcs": "^5.0.0",
-    "eslint-plugin-html": "^6.0.2",
-    "google-closure-compiler": "20200628.0.0",
+    "eslint-plugin-html": "^6.0.3",
+    "google-closure-compiler": "20200719.0.0",
     "http-server": "^0.12.3",
-    "rollup": "^2.21.0",
+    "rollup": "^2.23.1",
     "rollup-plugin-buble": "^0.19.8",
-    "typescript": "^3.9.6"
+    "typescript": "^3.9.7"
   },
   "jspm": {
     "files": [

src/Three.js

@@ -38,8 +38,8 @@ export * from './geometries/Geometries.js';
 export * from './materials/Materials.js';
 export { AnimationLoader } from './loaders/AnimationLoader.js';
 export { CompressedTextureLoader } from './loaders/CompressedTextureLoader.js';
-export { DataTextureLoader } from './loaders/DataTextureLoader.js';
 export { CubeTextureLoader } from './loaders/CubeTextureLoader.js';
+export { DataTextureLoader } from './loaders/DataTextureLoader.js';
 export { TextureLoader } from './loaders/TextureLoader.js';
 export { ObjectLoader } from './loaders/ObjectLoader.js';
 export { MaterialLoader } from './loaders/MaterialLoader.js';

src/animation/AnimationAction.d.ts

@@ -9,15 +9,55 @@ export class AnimationAction {
 	constructor( mixer: AnimationMixer, clip: AnimationClip, localRoot?: Object3D, blendMode?: AnimationBlendMode );
 
 	blendMode: AnimationBlendMode;
+
+	/**
+	 * @default THREE.LoopRepeat
+	 */
 	loop: AnimationActionLoopStyles;
+
+	/**
+	 * @default 0
+	 */
 	time: number;
+
+	/**
+	 * @default 1
+	 */
 	timeScale: number;
+
+	/**
+	 * @default 1
+	 */
 	weight: number;
+
+	/**
+	 * @default Infinity
+	 */
 	repetitions: number;
+
+	/**
+	 * @default false
+	 */
 	paused: boolean;
+
+	/**
+	 * @default true
+	 */
 	enabled: boolean;
+
+	/**
+	 * @default false
+	 */
 	clampWhenFinished: boolean;
+
+	/**
+	 * @default true
+	 */
 	zeroSlopeAtStart: boolean;
+
+	/**
+	 * @default true
+	 */
 	zeroSlopeAtEnd: boolean;
 
 	play(): AnimationAction;

src/animation/AnimationClip.d.ts

@@ -9,7 +9,15 @@ export class AnimationClip {
 
 	name: string;
 	tracks: KeyframeTrack[];
+
+	/**
+	 * @default THREE.NormalAnimationBlendMode
+	 */
 	blendMode: AnimationBlendMode;
+
+	/**
+	 * @default -1
+	 */
 	duration: number;
 	uuid: string;
 	results: any[];

src/animation/AnimationMixer.d.ts

@@ -9,7 +9,14 @@ export class AnimationMixer extends EventDispatcher {
 
 	constructor( root: Object3D | AnimationObjectGroup );
 
+	/**
+	 * @default 0
+	 */
 	time: number;
+
+	/**
+	 * @default 1.0
+	 */
 	timeScale: number;
 
 	clipAction( clip: AnimationClip, root?: Object3D | AnimationObjectGroup, blendMode?: AnimationBlendMode ): AnimationAction;

src/animation/AnimationUtils.d.ts

@@ -16,6 +16,14 @@ export namespace AnimationUtils {
 		values: any[],
 		valuePropertyName: string
 	): void;
+
+	/**
+	 * @param sourceClip
+	 * @param name
+	 * @param startFrame
+	 * @param endFrame
+	 * @param [fps=30]
+	 */
 	export function subclip(
 		sourceClip: AnimationClip,
 		name: string,
@@ -23,6 +31,13 @@ export namespace AnimationUtils {
 		endFrame: number,
 		fps?: number
 	): AnimationClip;
+
+	/**
+	 * @param targetClip
+	 * @param [referenceFrame=0]
+	 * @param [referenceClip=targetClip]
+	 * @param [fps=30]
+	 */
 	export function makeClipAdditive(
 		targetClip: AnimationClip,
 		referenceFrame?: number,

src/animation/AnimationUtils.js

@@ -252,13 +252,30 @@ const AnimationUtils = {
 			const targetTrack = targetClip.tracks.find( function ( track ) {
 
 				return track.name === referenceTrack.name
-				&& track.ValueTypeName === referenceTrackType;
+					&& track.ValueTypeName === referenceTrackType;
 
 			} );
 
 			if ( targetTrack === undefined ) continue;
 
-			const valueSize = referenceTrack.getValueSize();
+			let referenceOffset = 0;
+			const referenceValueSize = referenceTrack.getValueSize();
+
+			if ( referenceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline ) {
+
+				referenceOffset = referenceValueSize / 3;
+
+			}
+
+			let targetOffset = 0;
+			const targetValueSize = targetTrack.getValueSize();
+
+			if ( targetTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline ) {
+
+				targetOffset = targetValueSize / 3;
+
+			}
+
 			const lastIndex = referenceTrack.times.length - 1;
 			let referenceValue;
 
@@ -266,32 +283,32 @@ const AnimationUtils = {
 			if ( referenceTime <= referenceTrack.times[ 0 ] ) {
 
 				// Reference frame is earlier than the first keyframe, so just use the first keyframe
-				referenceValue = AnimationUtils.arraySlice( referenceTrack.values, 0, referenceTrack.valueSize );
+				const startIndex = referenceOffset;
+				const endIndex = referenceValueSize - referenceOffset;
+				referenceValue = AnimationUtils.arraySlice( referenceTrack.values, startIndex, endIndex );
 
 			} else if ( referenceTime >= referenceTrack.times[ lastIndex ] ) {
 
 				// Reference frame is after the last keyframe, so just use the last keyframe
-				const startIndex = lastIndex * valueSize;
-				referenceValue = AnimationUtils.arraySlice( referenceTrack.values, startIndex );
+				const startIndex = lastIndex * referenceValueSize + referenceOffset;
+				const endIndex = startIndex + referenceValueSize - referenceOffset;
+				referenceValue = AnimationUtils.arraySlice( referenceTrack.values, startIndex, endIndex );
 
 			} else {
 
 				// Interpolate to the reference value
 				const interpolant = referenceTrack.createInterpolant();
+				const startIndex = referenceOffset;
+				const endIndex = referenceValueSize - referenceOffset;
 				interpolant.evaluate( referenceTime );
-				referenceValue = interpolant.resultBuffer;
+				referenceValue = AnimationUtils.arraySlice( interpolant.resultBuffer, startIndex, endIndex );
 
 			}
 
 			// Conjugate the quaternion
 			if ( referenceTrackType === 'quaternion' ) {
 
-				const referenceQuat = new Quaternion(
-					referenceValue[ 0 ],
-					referenceValue[ 1 ],
-					referenceValue[ 2 ],
-					referenceValue[ 3 ]
-				).normalize().conjugate();
+				const referenceQuat = new Quaternion().fromArray( referenceValue ).normalize().conjugate();
 				referenceQuat.toArray( referenceValue );
 
 			}
@@ -301,7 +318,7 @@ const AnimationUtils = {
 			const numTimes = targetTrack.times.length;
 			for ( let j = 0; j < numTimes; ++ j ) {
 
-				const valueStart = j * valueSize;
+				const valueStart = j * targetValueSize + targetOffset;
 
 				if ( referenceTrackType === 'quaternion' ) {
 
@@ -317,8 +334,10 @@ const AnimationUtils = {
 
 				} else {
 
+					const valueEnd = targetValueSize - targetOffset * 2;
+
 					// Subtract each value for all other numeric track types
-					for ( let k = 0; k < valueSize; ++ k ) {
+					for ( let k = 0; k < valueEnd; ++ k ) {
 
 						targetTrack.values[ valueStart + k ] -= referenceValue[ k ];
 

src/animation/KeyframeTrack.d.ts

@@ -5,6 +5,12 @@ import { InterpolationModes } from '../constants';
 
 export class KeyframeTrack {
 
+	/**
+	 * @param name
+	 * @param times
+	 * @param values
+	 * @param [interpolation=THREE.InterpolateLinear]
+	 */
 	constructor(
 		name: string,
 		times: any[],
@@ -20,6 +26,9 @@ export class KeyframeTrack {
 	TimeBufferType: Float32Array;
 	ValueBufferType: Float32Array;
 
+	/**
+	 * @default THREE.InterpolateLinear
+	 */
 	DefaultInterpolation: InterpolationModes;
 
 	InterpolantFactoryMethodDiscrete( result: any ): DiscreteInterpolant;

src/animation/PropertyMixer.js

@@ -234,7 +234,7 @@ Object.assign( PropertyMixer.prototype, {
 	_setAdditiveIdentityQuaternion: function () {
 
 		this._setAdditiveIdentityNumeric();
-		this.buffer[ this._addIndex * 4 + 3 ] = 1;
+		this.buffer[ this._addIndex * this.valueSize + 3 ] = 1;
 
 	},
 

src/animation/tracks/BooleanKeyframeTrack.d.ts

@@ -4,4 +4,9 @@ export class BooleanKeyframeTrack extends KeyframeTrack {
 
 	constructor( name: string, times: any[], values: any[] );
 
+	/**
+	 * @default 'bool'
+	 */
+	ValueTypeName: string;
+
 }

src/animation/tracks/ColorKeyframeTrack.d.ts

@@ -10,4 +10,9 @@ export class ColorKeyframeTrack extends KeyframeTrack {
 		interpolation?: InterpolationModes
 	);
 
+	/**
+	 * @default 'color'
+	 */
+	ValueTypeName: string;
+
 }

src/animation/tracks/NumberKeyframeTrack.d.ts

@@ -10,4 +10,9 @@ export class NumberKeyframeTrack extends KeyframeTrack {
 		interpolation?: InterpolationModes
 	);
 
+	/**
+	 * @default 'number'
+	 */
+	ValueTypeName: string;
+
 }

src/animation/tracks/QuaternionKeyframeTrack.d.ts

@@ -10,4 +10,9 @@ export class QuaternionKeyframeTrack extends KeyframeTrack {
 		interpolation?: InterpolationModes
 	);
 
+	/**
+	 * @default 'quaternion'
+	 */
+	ValueTypeName: string;
+
 }

src/animation/tracks/StringKeyframeTrack.d.ts

@@ -10,4 +10,9 @@ export class StringKeyframeTrack extends KeyframeTrack {
 		interpolation?: InterpolationModes
 	);
 
+	/**
+	 * @default 'string'
+	 */
+	ValueTypeName: string;
+
 }

src/animation/tracks/VectorKeyframeTrack.d.ts

@@ -10,4 +10,9 @@ export class VectorKeyframeTrack extends KeyframeTrack {
 		interpolation?: InterpolationModes
 	);
 
+	/**
+	 * @default 'vector'
+	 */
+	ValueTypeName: string;
+
 }

src/audio/Audio.d.ts

@@ -12,19 +12,67 @@ export class Audio<NodeType extends AudioNode = GainNode> extends Object3D {
 	listener: AudioListener;
 	context: AudioContext;
 	gain: GainNode;
+
+	/**
+	 * @default false
+	 */
 	autoplay: boolean;
 	buffer: null | AudioBuffer;
+
+	/**
+	 * @default 0
+	 */
 	detune: number;
+
+	/**
+	 * @default false
+	 */
 	loop: boolean;
+
+	/**
+	 * @default 0
+	 */
 	loopStart: number;
+
+	/**
+	 * @default 0
+	 */
 	loopEnd: number;
+
+	/**
+	 * @default 0
+	 */
 	offset: number;
+
+	/**
+	 * @default undefined
+	 */
 	duration: number | undefined;
+
+	/**
+	 * @default 1
+	 */
 	playbackRate: number;
+
+	/**
+	 * @default false
+	 */
 	isPlaying: boolean;
+
+	/**
+	 * @default true
+	 */
 	hasPlaybackControl: boolean;
+
+	/**
+	 * @default 'empty'
+	 */
 	sourceType: string;
-	source: AudioBufferSourceNode;
+	source: null | AudioBufferSourceNode;
+
+	/**
+	 * @default []
+	 */
 	filters: any[];
 
 	getOutput(): NodeType;

src/audio/Audio.js

@@ -1,49 +1,48 @@
 import { Object3D } from '../core/Object3D.js';
 
-function Audio( listener ) {
+class Audio extends Object3D {
 
-	Object3D.call( this );
+	constructor( listener ) {
 
-	this.type = 'Audio';
+		super();
 
-	this.listener = listener;
-	this.context = listener.context;
+		this.type = 'Audio';
 
-	this.gain = this.context.createGain();
-	this.gain.connect( listener.getInput() );
+		this.listener = listener;
+		this.context = listener.context;
 
-	this.autoplay = false;
+		this.gain = this.context.createGain();
+		this.gain.connect( listener.getInput() );
 
-	this.buffer = null;
-	this.detune = 0;
-	this.loop = false;
-	this.loopStart = 0;
-	this.loopEnd = 0;
-	this.offset = 0;
-	this.duration = undefined;
-	this.playbackRate = 1;
-	this.isPlaying = false;
-	this.hasPlaybackControl = true;
-	this.sourceType = 'empty';
+		this.autoplay = false;
 
-	this._startedAt = 0;
-	this._progress = 0;
-
-	this.filters = [];
+		this.buffer = null;
+		this.detune = 0;
+		this.loop = false;
+		this.loopStart = 0;
+		this.loopEnd = 0;
+		this.offset = 0;
+		this.duration = undefined;
+		this.playbackRate = 1;
+		this.isPlaying = false;
+		this.hasPlaybackControl = true;
+		this.source = null;
+		this.sourceType = 'empty';
 
-}
+		this._startedAt = 0;
+		this._progress = 0;
 
-Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
+		this.filters = [];
 
-	constructor: Audio,
+	}
 
-	getOutput: function () {
+	getOutput() {
 
 		return this.gain;
 
-	},
+	}
 
-	setNodeSource: function ( audioNode ) {
+	setNodeSource( audioNode ) {
 
 		this.hasPlaybackControl = false;
 		this.sourceType = 'audioNode';
@@ -52,9 +51,9 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	setMediaElementSource: function ( mediaElement ) {
+	setMediaElementSource( mediaElement ) {
 
 		this.hasPlaybackControl = false;
 		this.sourceType = 'mediaNode';
@@ -63,9 +62,9 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	setMediaStreamSource: function ( mediaStream ) {
+	setMediaStreamSource( mediaStream ) {
 
 		this.hasPlaybackControl = false;
 		this.sourceType = 'mediaStreamNode';
@@ -74,9 +73,9 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	setBuffer: function ( audioBuffer ) {
+	setBuffer( audioBuffer ) {
 
 		this.buffer = audioBuffer;
 		this.sourceType = 'buffer';
@@ -85,9 +84,9 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	play: function ( delay ) {
+	play( delay ) {
 
 		if ( delay === undefined ) delay = 0;
 
@@ -124,9 +123,9 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this.connect();
 
-	},
+	}
 
-	pause: function () {
+	pause() {
 
 		if ( this.hasPlaybackControl === false ) {
 
@@ -158,9 +157,9 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	stop: function () {
+	stop() {
 
 		if ( this.hasPlaybackControl === false ) {
 
@@ -177,9 +176,9 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	connect: function () {
+	connect() {
 
 		if ( this.filters.length > 0 ) {
 
@@ -201,9 +200,9 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	disconnect: function () {
+	disconnect() {
 
 		if ( this.filters.length > 0 ) {
 
@@ -225,15 +224,15 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	getFilters: function () {
+	getFilters() {
 
 		return this.filters;
 
-	},
+	}
 
-	setFilters: function ( value ) {
+	setFilters( value ) {
 
 		if ( ! value ) value = [];
 
@@ -251,9 +250,9 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	setDetune: function ( value ) {
+	setDetune( value ) {
 
 		this.detune = value;
 
@@ -267,27 +266,27 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	getDetune: function () {
+	getDetune() {
 
 		return this.detune;
 
-	},
+	}
 
-	getFilter: function () {
+	getFilter() {
 
 		return this.getFilters()[ 0 ];
 
-	},
+	}
 
-	setFilter: function ( filter ) {
+	setFilter( filter ) {
 
 		return this.setFilters( filter ? [ filter ] : [] );
 
-	},
+	}
 
-	setPlaybackRate: function ( value ) {
+	setPlaybackRate( value ) {
 
 		if ( this.hasPlaybackControl === false ) {
 
@@ -306,21 +305,21 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	getPlaybackRate: function () {
+	getPlaybackRate() {
 
 		return this.playbackRate;
 
-	},
+	}
 
-	onEnded: function () {
+	onEnded() {
 
 		this.isPlaying = false;
 
-	},
+	}
 
-	getLoop: function () {
+	getLoop() {
 
 		if ( this.hasPlaybackControl === false ) {
 
@@ -331,9 +330,9 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this.loop;
 
-	},
+	}
 
-	setLoop: function ( value ) {
+	setLoop( value ) {
 
 		if ( this.hasPlaybackControl === false ) {
 
@@ -352,31 +351,31 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	setLoopStart: function ( value ) {
+	setLoopStart( value ) {
 
 		this.loopStart = value;
 
 		return this;
 
-	},
+	}
 
-	setLoopEnd: function ( value ) {
+	setLoopEnd( value ) {
 
 		this.loopEnd = value;
 
 		return this;
 
-	},
+	}
 
-	getVolume: function () {
+	getVolume() {
 
 		return this.gain.gain.value;
 
-	},
+	}
 
-	setVolume: function ( value ) {
+	setVolume( value ) {
 
 		this.gain.gain.setTargetAtTime( value, this.context.currentTime, 0.01 );
 
@@ -384,6 +383,6 @@ Audio.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 	}
 
-} );
+}
 
 export { Audio };

src/audio/AudioAnalyser.d.ts

@@ -2,7 +2,11 @@ import { Audio } from './Audio';
 
 export class AudioAnalyser {
 
-	constructor( audio: Audio<AudioNode>, fftSize: number );
+	/**
+	 * @param audio
+	 * @param [fftSize=2048]
+	 */
+	constructor( audio: Audio<AudioNode>, fftSize?: number );
 
 	analyser: AnalyserNode;
 	data: Uint8Array;

src/audio/AudioListener.d.ts

@@ -8,7 +8,15 @@ export class AudioListener extends Object3D {
 	type: 'AudioListener';
 	context: AudioContext;
 	gain: GainNode;
+
+	/**
+	 * @default null
+	 */
 	filter: null | any;
+
+	/**
+	 * @default 0
+	 */
 	timeDelta: number;
 
 	getInput(): GainNode;

src/audio/AudioListener.js

@@ -9,38 +9,36 @@ const _quaternion = new Quaternion();
 const _scale = new Vector3();
 const _orientation = new Vector3();
 
-function AudioListener() {
+class AudioListener extends Object3D {
 
-	Object3D.call( this );
+	constructor() {
 
-	this.type = 'AudioListener';
+		super();
 
-	this.context = AudioContext.getContext();
+		this.type = 'AudioListener';
 
-	this.gain = this.context.createGain();
-	this.gain.connect( this.context.destination );
+		this.context = AudioContext.getContext();
 
-	this.filter = null;
+		this.gain = this.context.createGain();
+		this.gain.connect( this.context.destination );
 
-	this.timeDelta = 0;
+		this.filter = null;
 
-	// private
+		this.timeDelta = 0;
 
-	this._clock = new Clock();
+		// private
 
-}
-
-AudioListener.prototype = Object.assign( Object.create( Object3D.prototype ), {
+		this._clock = new Clock();
 
-	constructor: AudioListener,
+	}
 
-	getInput: function () {
+	getInput() {
 
 		return this.gain;
 
-	},
+	}
 
-	removeFilter: function ( ) {
+	removeFilter() {
 
 		if ( this.filter !== null ) {
 
@@ -53,15 +51,15 @@ AudioListener.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	getFilter: function () {
+	getFilter() {
 
 		return this.filter;
 
-	},
+	}
 
-	setFilter: function ( value ) {
+	setFilter( value ) {
 
 		if ( this.filter !== null ) {
 
@@ -80,25 +78,25 @@ AudioListener.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	getMasterVolume: function () {
+	getMasterVolume() {
 
 		return this.gain.gain.value;
 
-	},
+	}
 
-	setMasterVolume: function ( value ) {
+	setMasterVolume( value ) {
 
 		this.gain.gain.setTargetAtTime( value, this.context.currentTime, 0.01 );
 
 		return this;
 
-	},
+	}
 
-	updateMatrixWorld: function ( force ) {
+	updateMatrixWorld( force ) {
 
-		Object3D.prototype.updateMatrixWorld.call( this, force );
+		super.updateMatrixWorld( force );
 
 		const listener = this.context.listener;
 		const up = this.up;
@@ -134,6 +132,6 @@ AudioListener.prototype = Object.assign( Object.create( Object3D.prototype ), {
 
 	}
 
-} );
+}
 
 export { AudioListener };

src/audio/PositionalAudio.js

@@ -1,90 +1,87 @@
 import { Vector3 } from '../math/Vector3.js';
 import { Quaternion } from '../math/Quaternion.js';
 import { Audio } from './Audio.js';
-import { Object3D } from '../core/Object3D.js';
 
 const _position = new Vector3();
 const _quaternion = new Quaternion();
 const _scale = new Vector3();
 const _orientation = new Vector3();
 
-function PositionalAudio( listener ) {
+class PositionalAudio extends Audio {
 
-	Audio.call( this, listener );
+	constructor( listener ) {
 
-	this.panner = this.context.createPanner();
-	this.panner.panningModel = 'HRTF';
-	this.panner.connect( this.gain );
+		super( listener );
 
-}
-
-PositionalAudio.prototype = Object.assign( Object.create( Audio.prototype ), {
+		this.panner = this.context.createPanner();
+		this.panner.panningModel = 'HRTF';
+		this.panner.connect( this.gain );
 
-	constructor: PositionalAudio,
+	}
 
-	getOutput: function () {
+	getOutput() {
 
 		return this.panner;
 
-	},
+	}
 
-	getRefDistance: function () {
+	getRefDistance() {
 
 		return this.panner.refDistance;
 
-	},
+	}
 
-	setRefDistance: function ( value ) {
+	setRefDistance( value ) {
 
 		this.panner.refDistance = value;
 
 		return this;
 
-	},
+	}
 
-	getRolloffFactor: function () {
+	getRolloffFactor() {
 
 		return this.panner.rolloffFactor;
 
-	},
+	}
 
-	setRolloffFactor: function ( value ) {
+	setRolloffFactor( value ) {
 
 		this.panner.rolloffFactor = value;
 
 		return this;
 
-	},
+	}
 
-	getDistanceModel: function () {
+	getDistanceModel() {
 
 		return this.panner.distanceModel;
 
-	},
+	}
 
-	setDistanceModel: function ( value ) {
+	setDistanceModel( value ) {
 
 		this.panner.distanceModel = value;
 
 		return this;
 
-	},
+	}
 
-	getMaxDistance: function () {
+	getMaxDistance() {
 
 		return this.panner.maxDistance;
 
-	},
+	}
 
-	setMaxDistance: function ( value ) {
+	setMaxDistance( value ) {
 
 		this.panner.maxDistance = value;
 
 		return this;
 
-	},
+	}
 
-	setDirectionalCone: function ( coneInnerAngle, coneOuterAngle, coneOuterGain ) {
+	setDirectionalCone( coneInnerAngle, coneOuterAngle, coneOuterGain ) {
 
 		this.panner.coneInnerAngle = coneInnerAngle;
 		this.panner.coneOuterAngle = coneOuterAngle;
@@ -92,11 +89,11 @@ PositionalAudio.prototype = Object.assign( Object.create( Audio.prototype ), {
 
 		return this;
 
-	},
+	}
 
-	updateMatrixWorld: function ( force ) {
+	updateMatrixWorld( force ) {
 
-		Object3D.prototype.updateMatrixWorld.call( this, force );
+		super.updateMatrixWorld( force );
 
 		if ( this.hasPlaybackControl === true && this.isPlaying === false ) return;
 
@@ -128,6 +125,6 @@ PositionalAudio.prototype = Object.assign( Object.create( Audio.prototype ), {
 
 	}
 
-} );
+}
 
 export { PositionalAudio };

src/cameras/ArrayCamera.d.ts

@@ -4,6 +4,9 @@ export class ArrayCamera extends PerspectiveCamera {
 
 	constructor( cameras?: PerspectiveCamera[] );
 
+	/**
+	 * @default []
+	 */
 	cameras: PerspectiveCamera[];
 	readonly isArrayCamera: true;
 

src/cameras/Camera.d.ts

@@ -16,16 +16,19 @@ export class Camera extends Object3D {
 
 	/**
 	 * This is the inverse of matrixWorld. MatrixWorld contains the Matrix which has the world transform of the Camera.
+	 * @default new THREE.Matrix4()
 	 */
 	matrixWorldInverse: Matrix4;
 
 	/**
 	 * This is the matrix which contains the projection.
+	 * @default new THREE.Matrix4()
 	 */
 	projectionMatrix: Matrix4;
 
 	/**
 	 * This is the inverse of projectionMatrix.
+	 * @default new THREE.Matrix4()
 	 */
 	projectionMatrixInverse: Matrix4;
 

src/cameras/OrthographicCamera.d.ts

@@ -16,8 +16,8 @@ export class OrthographicCamera extends Camera {
 	 * @param right Camera frustum right plane.
 	 * @param top Camera frustum top plane.
 	 * @param bottom Camera frustum bottom plane.
-	 * @param near Camera frustum near plane.
-	 * @param far Camera frustum far plane.
+	 * @param [near=0.1] Camera frustum near plane.
+	 * @param [far=2000] Camera frustum far plane.
 	 */
 	constructor(
 		left: number,
@@ -32,7 +32,14 @@ export class OrthographicCamera extends Camera {
 
 	readonly isOrthographicCamera: true;
 
+	/**
+	 * @default 1
+	 */
 	zoom: number;
+
+	/**
+	 * @default null
+	 */
 	view: null | {
 		enabled: boolean;
 		fullWidth: number;
@@ -45,31 +52,37 @@ export class OrthographicCamera extends Camera {
 
 	/**
 	 * Camera frustum left plane.
+	 * @default -1
 	 */
 	left: number;
 
 	/**
 	 * Camera frustum right plane.
+	 * @default 1
 	 */
 	right: number;
 
 	/**
 	 * Camera frustum top plane.
+	 * @default 1
 	 */
 	top: number;
 
 	/**
 	 * Camera frustum bottom plane.
+	 * @default -1
 	 */
 	bottom: number;
 
 	/**
 	 * Camera frustum near plane.
+	 * @default 0.1
 	 */
 	near: number;
 
 	/**
 	 * Camera frustum far plane.
+	 * @default 2000
 	 */
 	far: number;
 

src/cameras/PerspectiveCamera.d.ts

@@ -8,10 +8,10 @@ import { Camera } from './Camera';
 export class PerspectiveCamera extends Camera {
 
 	/**
-	 * @param fov Camera frustum vertical field of view. Default value is 50.
-	 * @param aspect Camera frustum aspect ratio. Default value is 1.
-	 * @param near Camera frustum near plane. Default value is 0.1.
-	 * @param far Camera frustum far plane. Default value is 2000.
+	 * @param [fov=50] Camera frustum vertical field of view. Default value is 50.
+	 * @param [aspect=1] Camera frustum aspect ratio. Default value is 1.
+	 * @param [near=0.1] Camera frustum near plane. Default value is 0.1.
+	 * @param [far=2000] Camera frustum far plane. Default value is 2000.
 	 */
 	constructor( fov?: number, aspect?: number, near?: number, far?: number );
 
@@ -19,29 +19,43 @@ export class PerspectiveCamera extends Camera {
 
 	readonly isPerspectiveCamera: true;
 
+	/**
+	 * @default 1
+	 */
 	zoom: number;
 
 	/**
 	 * Camera frustum vertical field of view, from bottom to top of view, in degrees.
+	 * @default 50
 	 */
 	fov: number;
 
 	/**
 	 * Camera frustum aspect ratio, window width divided by window height.
+	 * @default 1
 	 */
 	aspect: number;
 
 	/**
 	 * Camera frustum near plane.
+	 * @default 0.1
 	 */
 	near: number;
 
 	/**
 	 * Camera frustum far plane.
+	 * @default 2000
 	 */
 	far: number;
 
+	/**
+	 * @default 10
+	 */
 	focus: number;
+
+	/**
+	 * @default null
+	 */
 	view: null | {
 		enabled: boolean;
 		fullWidth: number;
@@ -51,7 +65,15 @@ export class PerspectiveCamera extends Camera {
 		width: number;
 		height: number;
 	};
+
+	/**
+	 * @default 35
+	 */
 	filmGauge: number;
+
+	/**
+	 * @default 0
+	 */
 	filmOffset: number;
 
 	setFocalLength( focalLength: number ): void;

src/cameras/StereoCamera.d.ts

@@ -7,8 +7,16 @@ export class StereoCamera extends Camera {
 
 	type: 'StereoCamera';
 
+	/**
+	 * @default 1
+	 */
 	aspect: number;
+
+	/**
+	 * @default 0.064
+	 */
 	eyeSep: number;
+
 	cameraL: PerspectiveCamera;
 	cameraR: PerspectiveCamera;
 

src/core/BufferAttribute.d.ts

@@ -9,13 +9,36 @@ export class BufferAttribute {
 
 	constructor( array: ArrayLike<number>, itemSize: number, normalized?: boolean ); // array parameter should be TypedArray.
 
+	/**
+	 * @default ''
+	 */
 	name: string;
 	array: ArrayLike<number>;
 	itemSize: number;
+
+	/**
+	 * @default THREE.StaticDrawUsage
+	 */
 	usage: Usage;
+
+	/**
+	 * @default { offset: number; count: number }
+	 */
 	updateRange: { offset: number; count: number };
+
+	/**
+	 * @default 0
+	 */
 	version: number;
+
+	/**
+	 * @default false
+	 */
 	normalized: boolean;
+
+	/**
+	 * @default 0
+	 */
 	count: number;
 
 	set needsUpdate( value: boolean );

src/core/BufferGeometry.d.ts

@@ -31,20 +31,64 @@ export class BufferGeometry extends EventDispatcher {
 	 */
 	id: number;
 	uuid: string;
+
+	/**
+	 * @default ''
+	 */
 	name: string;
+
+	/**
+	 * @default 'BufferGeometry'
+	 */
 	type: string;
+
+	/**
+	 * @default null
+	 */
 	index: BufferAttribute | null;
+
+	/**
+	 * @default {}
+	 */
 	attributes: {
 		[name: string]: BufferAttribute | InterleavedBufferAttribute;
 	};
+
+	/**
+	 * @default {}
+	 */
 	morphAttributes: {
 		[name: string]: ( BufferAttribute | InterleavedBufferAttribute )[];
 	};
+
+	/**
+	 * @default false
+	 */
 	morphTargetsRelative: boolean;
+
+	/**
+	 * @default []
+	 */
 	groups: { start: number; count: number; materialIndex?: number }[];
+
+	/**
+	 * @default null
+	 */
 	boundingBox: Box3 | null;
+
+	/**
+	 * @default null
+	 */
 	boundingSphere: Sphere | null;
+
+	/**
+	 * @default { start: 0, count: Infinity }
+	 */
 	drawRange: { start: number; count: number };
+
+	/**
+	 * @default {}
+	 */
 	userData: {[key: string]: any};
 	readonly isBufferGeometry: true;
 

src/core/Clock.d.ts

@@ -6,35 +6,40 @@
 export class Clock {
 
 	/**
-	 * @param autoStart Automatically start the clock.
+	 * @param [autoStart=true] Automatically start the clock.
 	 */
 	constructor( autoStart?: boolean );
 
 	/**
 	 * If set, starts the clock automatically when the first update is called.
+	 * @default true
 	 */
 	autoStart: boolean;
 
 	/**
 	 * When the clock is running, It holds the starttime of the clock.
 	 * This counted from the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC.
+	 * @default 0
 	 */
 	startTime: number;
 
 	/**
 	 * When the clock is running, It holds the previous time from a update.
 	 * This counted from the number of milliseconds elapsed since 1 January 1970 00:00:00 UTC.
+	 * @default 0
 	 */
 	oldTime: number;
 
 	/**
 	 * When the clock is running, It holds the time elapsed between the start of the clock to the previous update.
 	 * This parameter is in seconds of three decimal places.
+	 * @default 0
 	 */
 	elapsedTime: number;
 
 	/**
 	 * This property keeps track whether the clock is running or not.
+	 * @default false
 	 */
 	running: boolean;
 

src/core/DirectGeometry.d.ts

@@ -18,22 +18,90 @@ export class DirectGeometry {
 	uuid: string;
 	name: string;
 	type: string;
+
+	/**
+	 * @default []
+	 */
 	indices: number[];
+
+	/**
+	 * @default []
+	 */
 	vertices: Vector3[];
+
+	/**
+	 * @default []
+	 */
 	normals: Vector3[];
+
+	/**
+	 * @default []
+	 */
 	colors: Color[];
+
+	/**
+	 * @default []
+	 */
 	uvs: Vector2[];
+
+	/**
+	 * @default []
+	 */
 	uvs2: Vector2[];
+
+	/**
+	 * @default []
+	 */
 	groups: { start: number; materialIndex: number }[];
+
+	/**
+	 * @default {}
+	 */
 	morphTargets: MorphTarget[];
+
+	/**
+	 * @default []
+	 */
 	skinWeights: Vector4[];
+
+	/**
+	 * @default []
+	 */
 	skinIndices: Vector4[];
+
+	/**
+	 * @default null
+	 */
 	boundingBox: Box3 | null;
+
+	/**
+	 * @default null
+	 */
 	boundingSphere: Sphere | null;
+
+	/**
+	 * @default false
+	 */
 	verticesNeedUpdate: boolean;
+
+	/**
+	 * @default false
+	 */
 	normalsNeedUpdate: boolean;
+
+	/**
+	 * @default false
+	 */
 	colorsNeedUpdate: boolean;
+
+	/**
+	 * @default false
+	 */
 	uvsNeedUpdate: boolean;
+
+	/**
+	 * @default false
+	 */
 	groupsNeedUpdate: boolean;
 
 	computeBoundingBox(): void;

src/core/Face3.d.ts

@@ -66,26 +66,31 @@ export class Face3 {
 
 	/**
 	 * Face normal.
+	 * @default new THREE.Vector3()
 	 */
 	normal: Vector3;
 
 	/**
 	 * Array of 3 vertex normals.
+	 * @default []
 	 */
 	vertexNormals: Vector3[];
 
 	/**
 	 * Face color.
+	 * @default new THREE.Color()
 	 */
 	color: Color;
 
 	/**
 	 * Array of 3 vertex colors.
+	 * @default []
 	 */
 	vertexColors: Color[];
 
 	/**
 	 * Material index (points to {@link Geometry.materials}).
+	 * @default 0
 	 */
 	materialIndex: number;
 

src/core/Geometry.d.ts

@@ -54,14 +54,19 @@ export class Geometry extends EventDispatcher {
 
 	/**
 	 * Name for this geometry. Default is an empty string.
+	 * @default ''
 	 */
 	name: string;
 
+	/**
+	 * @default 'Geometry'
+	 */
 	type: string;
 
 	/**
 	 * The array of vertices hold every position of points of the model.
 	 * To signal an update in this array, Geometry.verticesNeedUpdate needs to be set to true.
+	 * @default []
 	 */
 	vertices: Vector3[];
 
@@ -70,6 +75,7 @@ export class Geometry extends EventDispatcher {
 	 * Used in ParticleSystem, Line and Ribbon.
 	 * Meshes use per-face-use-of-vertex colors embedded directly in faces.
 	 * To signal an update in this array, Geometry.colorsNeedUpdate needs to be set to true.
+	 * @default []
 	 */
 	colors: Color[];
 
@@ -77,6 +83,7 @@ export class Geometry extends EventDispatcher {
 	 * Array of triangles or/and quads.
 	 * The array of faces describe how each vertex in the model is connected with each other.
 	 * To signal an update in this array, Geometry.elementsNeedUpdate needs to be set to true.
+	 * @default []
 	 */
 	faces: Face3[];
 
@@ -84,6 +91,7 @@ export class Geometry extends EventDispatcher {
 	 * Array of face UV layers.
 	 * Each UV layer is an array of UV matching order and number of vertices in faces.
 	 * To signal an update in this array, Geometry.uvsNeedUpdate needs to be set to true.
+	 * @default [[]]
 	 */
 	faceVertexUvs: Vector2[][][];
 
@@ -93,6 +101,7 @@ export class Geometry extends EventDispatcher {
 	 *		 { name: "targetName", vertices: [ new THREE.Vector3(), ... ] }
 	 *
 	 * Morph vertices match number and order of primary vertices.
+	 * @default []
 	 */
 	morphTargets: MorphTarget[];
 
@@ -100,66 +109,78 @@ export class Geometry extends EventDispatcher {
 	 * Array of morph normals. Morph normals have similar structure as morph targets, each normal set is a Javascript object:
 	 *
 	 *		 morphNormal = { name: "NormalName", normals: [ new THREE.Vector3(), ... ] }
+	 * @default []
 	 */
 	morphNormals: MorphNormals[];
 
 	/**
 	 * Array of skinning weights, matching number and order of vertices.
+	 * @default []
 	 */
 	skinWeights: Vector4[];
 
 	/**
 	 * Array of skinning indices, matching number and order of vertices.
+	 * @default []
 	 */
 	skinIndices: Vector4[];
 
 	/**
-	 *
+	 * @default []
 	 */
 	lineDistances: number[];
 
 	/**
 	 * Bounding box.
+	 * @default null
 	 */
 	boundingBox: Box3 | null;
 
 	/**
 	 * Bounding sphere.
+	 * @default null
 	 */
 	boundingSphere: Sphere | null;
 
 	/**
 	 * Set to true if the vertices array has been updated.
+	 * @default false
 	 */
 	verticesNeedUpdate: boolean;
 
 	/**
 	 * Set to true if the faces array has been updated.
+	 * @default false
 	 */
 	elementsNeedUpdate: boolean;
 
 	/**
 	 * Set to true if the uvs array has been updated.
+	 * @default false
 	 */
 	uvsNeedUpdate: boolean;
 
 	/**
 	 * Set to true if the normals array has been updated.
+	 * @default false
 	 */
 	normalsNeedUpdate: boolean;
 
 	/**
 	 * Set to true if the colors array has been updated.
+	 * @default false
 	 */
 	colorsNeedUpdate: boolean;
 
 	/**
 	 * Set to true if the linedistances array has been updated.
+	 * @default false
 	 */
 	lineDistancesNeedUpdate: boolean;
 
 	/**
 	 *
+	 * @default false
 	 */
 	groupsNeedUpdate: boolean;
 

src/core/InstancedBufferAttribute.d.ts

@@ -44,6 +44,9 @@ export class InstancedBufferAttribute extends BufferAttribute {
 		meshPerAttribute?: number
 	);
 
+	/**
+	 * @default 1
+	 */
 	meshPerAttribute: number;
 
 }

src/core/InstancedBufferGeometry.d.ts

@@ -7,7 +7,16 @@ export class InstancedBufferGeometry extends BufferGeometry {
 
 	constructor();
 
+	/**
+	 * @default 'InstancedBufferGeometry
+	 */
+	type: string;
+
 	groups: { start: number; count: number; instances: number }[];
+
+	/**
+	 * @default Infinity
+	 */
 	instanceCount: number;
 
 	addGroup( start: number, count: number, instances: number ): void;

src/core/InstancedInterleavedBuffer.d.ts

@@ -11,6 +11,9 @@ export class InstancedInterleavedBuffer extends InterleavedBuffer {
 		meshPerAttribute?: number
 	);
 
+	/**
+	 * @default 1
+	 */
 	meshPerAttribute: number;
 
 }

src/core/InterleavedBuffer.d.ts

@@ -10,10 +10,27 @@ export class InterleavedBuffer {
 
 	array: ArrayLike<number>;
 	stride: number;
+
+	/**
+	 * @default THREE.StaticDrawUsage
+	 */
 	usage: Usage;
+
+	/**
+	 * @default { offset: number; count: number }
+	 */
 	updateRange: { offset: number; count: number };
+
+	/**
+	 * @default 0
+	 */
 	version: number;
+
 	length: number;
+
+	/**
+	 * @default 0
+	 */
 	count: number;
 	needsUpdate: boolean;
 	uuid: string;

src/core/InterleavedBufferAttribute.d.ts

@@ -13,10 +13,17 @@ export class InterleavedBufferAttribute {
 		normalized?: boolean
 	);
 
+	/**
+	 * @default ''
+	 */
 	name: string;
 	data: InterleavedBuffer;
 	itemSize: number;
 	offset: number;
+
+	/**
+	 * @default false
+	 */
 	normalized: boolean;
 
 	get count(): number;

src/core/Layers.d.ts

@@ -2,6 +2,9 @@ export class Layers {
 
 	constructor();
 
+	/**
+	 * @default 1 | 0
+	 */
 	mask: number;
 
 	set( channel: number ): void;

src/core/Object3D.d.ts

@@ -36,98 +36,128 @@ export class Object3D extends EventDispatcher {
 
 	/**
 	 * Optional name of the object (doesn't need to be unique).
+	 * @default ''
 	 */
 	name: string;
 
+	/**
+	 * @default 'Object3D'
+	 */
 	type: string;
 
 	/**
 	 * Object's parent in the scene graph.
+	 * @default null
 	 */
 	parent: Object3D | null;
 
 	/**
 	 * Array with object's children.
+	 * @default []
 	 */
 	children: Object3D[];
 
 	/**
 	 * Up direction.
+	 * @default THREE.Object3D.DefaultUp.clone()
 	 */
 	up: Vector3;
 
 	/**
 	 * Object's local position.
+	 * @default new THREE.Vector3()
 	 */
 	readonly position: Vector3;
 
 	/**
 	 * Object's local rotation (Euler angles), in radians.
+	 * @default new THREE.Euler()
 	 */
 	readonly rotation: Euler;
 
 	/**
 	 * Global rotation.
+	 * @default new THREE.Quaternion()
 	 */
 	readonly quaternion: Quaternion;
 
 	/**
 	 * Object's local scale.
+	 * @default new THREE.Vector3()
 	 */
 	readonly scale: Vector3;
 
+	/**
+	 * @default new THREE.Matrix4()
+	 */
 	readonly modelViewMatrix: Matrix4;
 
+	/**
+	 * @default new THREE.Matrix3()
+	 */
 	readonly normalMatrix: Matrix3;
 
 	/**
 	 * Local transform.
+	 * @default new THREE.Matrix4()
 	 */
 	matrix: Matrix4;
 
 	/**
 	 * The global transform of the object. If the Object3d has no parent, then it's identical to the local transform.
+	 * @default new THREE.Matrix4()
 	 */
 	matrixWorld: Matrix4;
 
 	/**
 	 * When this is set, it calculates the matrix of position, (rotation or quaternion) and scale every frame and also recalculates the matrixWorld property.
+	 * @default THREE.Object3D.DefaultMatrixAutoUpdate
 	 */
 	matrixAutoUpdate: boolean;
 
 	/**
 	 * When this is set, it calculates the matrixWorld in that frame and resets this property to false.
+	 * @default false
 	 */
 	matrixWorldNeedsUpdate: boolean;
 
+	/**
+	 * @default new THREE.Layers()
+	 */
 	layers: Layers;
 	/**
 	 * Object gets rendered if true.
+	 * @default true
 	 */
 	visible: boolean;
 
 	/**
 	 * Gets rendered into shadow map.
+	 * @default false
 	 */
 	castShadow: boolean;
 
 	/**
 	 * Material gets baked in shadow receiving.
+	 * @default false
 	 */
 	receiveShadow: boolean;
 
 	/**
 	 * When this is set, it checks every frame if the object is in the frustum of the camera. Otherwise the object gets drawn every frame even if it isn't visible.
+	 * @default true
 	 */
 	frustumCulled: boolean;
 
 	/**
 	 * Overrides the default rendering order of scene graph objects, from lowest to highest renderOrder. Opaque and transparent objects remain sorted independently though. When this property is set for an instance of Group, all descendants objects will be sorted and rendered together.
+	 * @default 0
 	 */
 	renderOrder: number;
 
 	/**
 	 * An object that can be used to store custom data about the Object3d. It should not hold references to functions as these will not be cloned.
+	 * @default {}
 	 */
 	userData: { [key: string]: any };
 

src/core/Raycaster.d.ts

@@ -48,12 +48,14 @@ export class Raycaster {
 	/**
 	 * The near factor of the raycaster. This value indicates which objects can be discarded based on the
 	 * distance. This value shouldn't be negative and should be smaller than the far property.
+	 * @default 0
 	 */
 	near: number;
 
 	/**
 	 * The far factor of the raycaster. This value indicates which objects can be discarded based on the
 	 * distance. This value shouldn't be negative and should be larger than the near property.
+	 * @default Infinity
 	 */
 	far: number;
 
@@ -65,9 +67,13 @@ export class Raycaster {
 
 	/**
 	 * Used by Raycaster to selectively ignore 3D objects when performing intersection tests.
+	 * @default new THREE.Layers()
 	 */
 	layers: Layers;
 
+	/**
+	 * @default { Mesh: {}, Line: { threshold: 1 }, LOD: {}, Points: { threshold: 1 }, Sprite: {} }
+	 */
 	params: RaycasterParameters;
 
 	/**

src/extras/core/Curve.d.ts

@@ -8,10 +8,15 @@ import { Vector } from './../../math/Vector2';
  */
 export class Curve<T extends Vector> {
 
+	/**
+	 * @default 'Curve'
+	 */
+	type: string;
+
 	/**
 	 * This value determines the amount of divisions when calculating the cumulative segment lengths of a curve via .getLengths.
 	 * To ensure precision when using methods like .getSpacedPoints, it is recommended to increase .arcLengthDivisions if the curve is very large.
-	 * Default is 200.
+	 * @default 200
 	 */
 	arcLengthDivisions: number;
 

src/extras/core/CurvePath.d.ts

@@ -6,7 +6,19 @@ export class CurvePath<T extends Vector> extends Curve<T> {
 
 	constructor();
 
+	/**
+	 * @default 'CurvePath'
+	 */
+	type: string;
+
+	/**
+	 * @default []
+	 */
 	curves: Curve<T>[];
+
+	/**
+	 * @default false
+	 */
 	autoClose: boolean;
 
 	add( curve: Curve<T> ): void;

src/extras/core/Font.d.ts

@@ -4,6 +4,11 @@ export class Font {
 
 	constructor( jsondata: any );
 
+	/**
+	 * @default 'Font'
+	 */
+	type: string;
+
 	data: string;
 
 	generateShapes( text: string, size: number ): Shape[];

src/extras/core/Path.d.ts

@@ -8,6 +8,14 @@ export class Path extends CurvePath<Vector2> {
 
 	constructor( points?: Vector2[] );
 
+	/**
+	 * @default 'Path'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	currentPoint: Vector2;
 
 	/**

src/extras/core/Shape.d.ts

@@ -10,6 +10,14 @@ export class Shape extends Path {
 
 	constructor( points?: Vector2[] );
 
+	/**
+	 * @default 'Shape'
+	 */
+	type: string;
+
+	/**
+	 * @default []
+	 */
 	holes: Path[];
 
 	/**

src/extras/core/ShapePath.d.ts

@@ -1,11 +1,29 @@
 import { Vector2 } from './../../math/Vector2';
 import { Shape } from './Shape';
+import { Color } from '../../math/Color';
 
 export class ShapePath {
 
 	constructor();
 
+	/**
+	 * @default 'ShapePath'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Color()
+	 */
+	color: Color;
+
+	/**
+	 * @default []
+	 */
 	subPaths: any[];
+
+	/**
+	 * @default null
+	 */
 	currentPath: any;
 
 	moveTo( x: number, y: number ): this;

src/extras/curves/ArcCurve.d.ts

@@ -10,4 +10,9 @@ export class ArcCurve extends EllipseCurve {
 		aClockwise: boolean
 	);
 
+	/**
+	 * @default 'ArcCurve'
+	 */
+	type: string;
+
 }

src/extras/curves/CatmullRomCurve3.d.ts

@@ -34,6 +34,12 @@ export namespace CurveUtils {
 
 export class CatmullRomCurve3 extends Curve<Vector3> {
 
+	/**
+	 * @param [points=[]]
+	 * @param [closed=false]
+	 * @param [curveType='centripetal']
+	 * @param [tension=0.5]
+	 */
 	constructor(
 		points?: Vector3[],
 		closed?: boolean,
@@ -41,6 +47,14 @@ export class CatmullRomCurve3 extends Curve<Vector3> {
 		tension?: number
 	);
 
+	/**
+	 * @default 'CatmullRomCurve3'
+	 */
+	type: string;
+
+	/**
+	 * @default []
+	 */
 	points: Vector3[];
 
 }

src/extras/curves/CubicBezierCurve.d.ts

@@ -5,9 +5,29 @@ export class CubicBezierCurve extends Curve<Vector2> {
 
 	constructor( v0: Vector2, v1: Vector2, v2: Vector2, v3: Vector2 );
 
+	/**
+	 * @default 'CubicBezierCurve'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v0: Vector2;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v1: Vector2;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v2: Vector2;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v3: Vector2;
 
 }

src/extras/curves/CubicBezierCurve3.d.ts

@@ -5,9 +5,29 @@ export class CubicBezierCurve3 extends Curve<Vector3> {
 
 	constructor( v0: Vector3, v1: Vector3, v2: Vector3, v3: Vector3 );
 
+	/**
+	 * @default 'CubicBezierCurve3'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v0: Vector3;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v1: Vector3;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v2: Vector3;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v3: Vector3;
 
 }

src/extras/curves/EllipseCurve.d.ts

@@ -14,13 +14,49 @@ export class EllipseCurve extends Curve<Vector2> {
 		aRotation: number
 	);
 
+	/**
+	 * @default 'EllipseCurve'
+	 */
+	type: string;
+
+	/**
+	 * @default 0
+	 */
 	aX: number;
+
+	/**
+	 * @default 0
+	 */
 	aY: number;
+
+	/**
+	 * @default 1
+	 */
 	xRadius: number;
+
+	/**
+	 * @default 1
+	 */
 	yRadius: number;
+
+	/**
+	 * @default 0
+	 */
 	aStartAngle: number;
+
+	/**
+	 * @default 2 * Math.PI
+	 */
 	aEndAngle: number;
+
+	/**
+	 * @default false
+	 */
 	aClockwise: boolean;
+
+	/**
+	 * @default 0
+	 */
 	aRotation: number;
 
 }

src/extras/curves/LineCurve.d.ts

@@ -5,7 +5,20 @@ export class LineCurve extends Curve<Vector2> {
 
 	constructor( v1: Vector2, v2: Vector2 );
 
+	/**
+	 * @default 'LineCurve'
+	 */
+	type: string;
+
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v1: Vector2;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v2: Vector2;
 
 }

src/extras/curves/LineCurve3.d.ts

@@ -5,7 +5,20 @@ export class LineCurve3 extends Curve<Vector3> {
 
 	constructor( v1: Vector3, v2: Vector3 );
 
+	/**
+	 * @default 'LineCurve3'
+	 */
+	type: string;
+
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v1: Vector3;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v2: Vector3;
 
 }

src/extras/curves/QuadraticBezierCurve.d.ts

@@ -5,8 +5,24 @@ export class QuadraticBezierCurve extends Curve<Vector2> {
 
 	constructor( v0: Vector2, v1: Vector2, v2: Vector2 );
 
+	/**
+	 * @default 'QuadraticBezierCurve'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v0: Vector2;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v1: Vector2;
+
+	/**
+	 * @default new THREE.Vector2()
+	 */
 	v2: Vector2;
 
 }

src/extras/curves/QuadraticBezierCurve3.d.ts

@@ -5,8 +5,24 @@ export class QuadraticBezierCurve3 extends Curve<Vector3> {
 
 	constructor( v0: Vector3, v1: Vector3, v2: Vector3 );
 
+	/**
+	 * @default 'QuadraticBezierCurve3'
+	 */
+	type: string;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v0: Vector3;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v1: Vector3;
+
+	/**
+	 * @default new THREE.Vector3()
+	 */
 	v2: Vector3;
 
 }

src/extras/curves/SplineCurve.d.ts

@@ -5,6 +5,14 @@ export class SplineCurve extends Curve<Vector2> {
 
 	constructor( points?: Vector2[] );
 
+	/**
+	 * @default 'SplineCurve'
+	 */
+	type: string;
+
+	/**
+	 * @default []
+	 */
 	points: Vector2[];
 
 }

src/extras/objects/ImmediateRenderObject.d.ts

@@ -11,16 +11,49 @@ export class ImmediateRenderObject extends Object3D {
 
 	material: Material;
 
+	/**
+	 * @default false
+	 */
 	hasPositions: boolean;
+
+	/**
+	 * @default false
+	 */
 	hasNormals: boolean;
+
+	/**
+	 * @default false
+	 */
 	hasColors: boolean;
+
+	/**
+	 * @default false
+	 */
 	hasUvs: boolean;
 
+	/**
+	 * @default null
+	 */
 	positionArray: null | Float32Array;
+
+	/**
+	 * @default null
+	 */
 	normalArray: null | Float32Array;
+
+	/**
+	 * @default null
+	 */
 	colorArray: null | Float32Array;
+
+	/**
+	 * @default null
+	 */
 	uvArray: null | Float32Array;
 
+	/**
+	 * @default 0
+	 */
 	count: number;
 
 	render( renderCallback: Function ): void;

src/geometries/BoxGeometry.d.ts

@@ -4,6 +4,14 @@ import { BufferGeometry } from '../core/BufferGeometry';
 // Extras / Geometries /////////////////////////////////////////////////////////////////////
 export class BoxBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @param [width=1] — Width of the sides on the X axis.
+	 * @param [height=1] — Height of the sides on the Y axis.
+	 * @param [depth=1] — Depth of the sides on the Z axis.
+	 * @param [widthSegments=1] — Number of segmented faces along the width of the sides.
+	 * @param [heightSegments=1] — Number of segmented faces along the height of the sides.
+	 * @param [depthSegments=1] — Number of segmented faces along the depth of the sides.
+	 */
 	constructor(
 		width?: number,
 		height?: number,
@@ -13,6 +21,11 @@ export class BoxBufferGeometry extends BufferGeometry {
 		depthSegments?: number
 	);
 
+	/**
+	 * @default 'BoxBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		width: number;
 		height: number;
@@ -30,12 +43,12 @@ export class BoxBufferGeometry extends BufferGeometry {
 export class BoxGeometry extends Geometry {
 
 	/**
-	 * @param width — Width of the sides on the X axis.
-	 * @param height — Height of the sides on the Y axis.
-	 * @param depth — Depth of the sides on the Z axis.
-	 * @param widthSegments — Number of segmented faces along the width of the sides.
-	 * @param heightSegments — Number of segmented faces along the height of the sides.
-	 * @param depthSegments — Number of segmented faces along the depth of the sides.
+	 * @param [width=1] — Width of the sides on the X axis.
+	 * @param [height=1] — Height of the sides on the Y axis.
+	 * @param [depth=1] — Depth of the sides on the Z axis.
+	 * @param [widthSegments=1] — Number of segmented faces along the width of the sides.
+	 * @param [heightSegments=1] — Number of segmented faces along the height of the sides.
+	 * @param [depthSegments=1] — Number of segmented faces along the depth of the sides.
 	 */
 	constructor(
 		width?: number,
@@ -46,6 +59,11 @@ export class BoxGeometry extends Geometry {
 		depthSegments?: number
 	);
 
+	/**
+	 * @default 'BoxGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		width: number;
 		height: number;

src/geometries/CircleGeometry.d.ts

@@ -3,6 +3,12 @@ import { BufferGeometry } from '../core/BufferGeometry';
 
 export class CircleBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [segments=8]
+	 * @param [thetaStart=0]
+	 * @param [widthSegments=Math.PI * 2]
+	 */
 	constructor(
 		radius?: number,
 		segments?: number,
@@ -10,6 +16,11 @@ export class CircleBufferGeometry extends BufferGeometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'CircleBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radius: number;
 		segments: number;
@@ -21,6 +32,12 @@ export class CircleBufferGeometry extends BufferGeometry {
 
 export class CircleGeometry extends Geometry {
 
+	/**
+	 * @param [radius=1]
+	 * @param [segments=8]
+	 * @param [thetaStart=0]
+	 * @param [widthSegments=Math.PI * 2]
+	 */
 	constructor(
 		radius?: number,
 		segments?: number,
@@ -28,6 +45,11 @@ export class CircleGeometry extends Geometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'CircleGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radius: number;
 		segments: number;

src/geometries/CircleGeometry.js

@@ -6,109 +6,110 @@ import { Vector2 } from '../math/Vector2.js';
 
 // CircleGeometry
 
-function CircleGeometry( radius, segments, thetaStart, thetaLength ) {
+class CircleGeometry extends Geometry {
 
-	Geometry.call( this );
+	constructor( radius, segments, thetaStart, thetaLength ) {
 
-	this.type = 'CircleGeometry';
+		super();
+		this.type = 'CircleGeometry';
 
-	this.parameters = {
-		radius: radius,
-		segments: segments,
-		thetaStart: thetaStart,
-		thetaLength: thetaLength
-	};
+		this.parameters = {
+			radius: radius,
+			segments: segments,
+			thetaStart: thetaStart,
+			thetaLength: thetaLength
+		};
 
-	this.fromBufferGeometry( new CircleBufferGeometry( radius, segments, thetaStart, thetaLength ) );
-	this.mergeVertices();
+		this.fromBufferGeometry( new CircleBufferGeometry( radius, segments, thetaStart, thetaLength ) );
+		this.mergeVertices();
 
-}
+	}
 
-CircleGeometry.prototype = Object.create( Geometry.prototype );
-CircleGeometry.prototype.constructor = CircleGeometry;
+}
 
 // CircleBufferGeometry
 
-function CircleBufferGeometry( radius, segments, thetaStart, thetaLength ) {
+class CircleBufferGeometry extends BufferGeometry {
 
-	BufferGeometry.call( this );
+	constructor( radius, segments, thetaStart, thetaLength ) {
 
-	this.type = 'CircleBufferGeometry';
+		super();
 
-	this.parameters = {
-		radius: radius,
-		segments: segments,
-		thetaStart: thetaStart,
-		thetaLength: thetaLength
-	};
+		this.type = 'CircleBufferGeometry';
 
-	radius = radius || 1;
-	segments = segments !== undefined ? Math.max( 3, segments ) : 8;
+		this.parameters = {
+			radius: radius,
+			segments: segments,
+			thetaStart: thetaStart,
+			thetaLength: thetaLength
+		};
 
-	thetaStart = thetaStart !== undefined ? thetaStart : 0;
-	thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;
+		radius = radius || 1;
+		segments = segments !== undefined ? Math.max( 3, segments ) : 8;
 
-	// buffers
+		thetaStart = thetaStart !== undefined ? thetaStart : 0;
+		thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;
 
-	const indices = [];
-	const vertices = [];
-	const normals = [];
-	const uvs = [];
+		// buffers
 
-	// helper variables
+		const indices = [];
+		const vertices = [];
+		const normals = [];
+		const uvs = [];
 
-	const vertex = new Vector3();
-	const uv = new Vector2();
+		// helper variables
 
-	// center point
+		const vertex = new Vector3();
+		const uv = new Vector2();
 
-	vertices.push( 0, 0, 0 );
-	normals.push( 0, 0, 1 );
-	uvs.push( 0.5, 0.5 );
+		// center point
 
-	for ( let s = 0, i = 3; s <= segments; s ++, i += 3 ) {
+		vertices.push( 0, 0, 0 );
+		normals.push( 0, 0, 1 );
+		uvs.push( 0.5, 0.5 );
 
-		const segment = thetaStart + s / segments * thetaLength;
+		for ( let s = 0, i = 3; s <= segments; s ++, i += 3 ) {
 
-		// vertex
+			const segment = thetaStart + s / segments * thetaLength;
 
-		vertex.x = radius * Math.cos( segment );
-		vertex.y = radius * Math.sin( segment );
+			// vertex
 
-		vertices.push( vertex.x, vertex.y, vertex.z );
+			vertex.x = radius * Math.cos( segment );
+			vertex.y = radius * Math.sin( segment );
 
-		// normal
+			vertices.push( vertex.x, vertex.y, vertex.z );
 
-		normals.push( 0, 0, 1 );
+			// normal
 
-		// uvs
+			normals.push( 0, 0, 1 );
 
-		uv.x = ( vertices[ i ] / radius + 1 ) / 2;
-		uv.y = ( vertices[ i + 1 ] / radius + 1 ) / 2;
+			// uvs
 
-		uvs.push( uv.x, uv.y );
+			uv.x = ( vertices[ i ] / radius + 1 ) / 2;
+			uv.y = ( vertices[ i + 1 ] / radius + 1 ) / 2;
 
-	}
+			uvs.push( uv.x, uv.y );
 
-	// indices
+		}
 
-	for ( let i = 1; i <= segments; i ++ ) {
+		// indices
 
-		indices.push( i, i + 1, 0 );
+		for ( let i = 1; i <= segments; i ++ ) {
 
-	}
+			indices.push( i, i + 1, 0 );
 
-	// build geometry
+		}
 
-	this.setIndex( indices );
-	this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
-	this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
-	this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
+		// build geometry
 
-}
+		this.setIndex( indices );
+		this.setAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
+		this.setAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
+		this.setAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
 
-CircleBufferGeometry.prototype = Object.create( BufferGeometry.prototype );
-CircleBufferGeometry.prototype.constructor = CircleBufferGeometry;
+	}
+
+}
 
 
 export { CircleGeometry, CircleBufferGeometry };

src/geometries/ConeGeometry.d.ts

@@ -3,6 +3,16 @@ import { CylinderBufferGeometry } from './CylinderGeometry';
 
 export class ConeBufferGeometry extends CylinderBufferGeometry {
 
+	/**
+	 * @param [radiusTop=0] — Radius of the cylinder at the top.
+	 * @param [radiusBottom=1] — Radius of the cylinder at the bottom.
+	 * @param [height=1] — Height of the cylinder.
+	 * @param [radiusSegments=8] — Number of segmented faces around the circumference of the cylinder.
+	 * @param [heightSegments=1] — Number of rows of faces along the height of the cylinder.
+	 * @param [openEnded=false] - A Boolean indicating whether or not to cap the ends of the cylinder.
+	 * @param [thetaStart=0]
+	 * @param [widthSegments=Math.PI * 2]
+	 */
 	constructor(
 		radius?: number,
 		height?: number,
@@ -13,10 +23,25 @@ export class ConeBufferGeometry extends CylinderBufferGeometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'ConeBufferGeometry'
+	 */
+	type: string;
+
 }
 
 export class ConeGeometry extends CylinderGeometry {
 
+	/**
+	 * @param [radiusTop=0] — Radius of the cylinder at the top.
+	 * @param [radiusBottom=1] — Radius of the cylinder at the bottom.
+	 * @param [height=1] — Height of the cylinder.
+	 * @param [radiusSegments=8] — Number of segmented faces around the circumference of the cylinder.
+	 * @param [heightSegments=1] — Number of rows of faces along the height of the cylinder.
+	 * @param [openEnded=false] - A Boolean indicating whether or not to cap the ends of the cylinder.
+	 * @param [thetaStart=0]
+	 * @param [widthSegments=Math.PI * 2]
+	 */
 	constructor(
 		radius?: number,
 		height?: number,
@@ -27,4 +52,9 @@ export class ConeGeometry extends CylinderGeometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'ConeGeometry'
+	 */
+	type: string;
+
 }

src/geometries/ConeGeometry.js

@@ -3,49 +3,49 @@ import { CylinderBufferGeometry } from './CylinderGeometry.js';
 
 // ConeGeometry
 
-function ConeGeometry( radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {
+class ConeGeometry extends CylinderGeometry {
 
-	CylinderGeometry.call( this, 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength );
+	constructor( radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {
 
-	this.type = 'ConeGeometry';
+		super( 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength );
+		this.type = 'ConeGeometry';
 
-	this.parameters = {
-		radius: radius,
-		height: height,
-		radialSegments: radialSegments,
-		heightSegments: heightSegments,
-		openEnded: openEnded,
-		thetaStart: thetaStart,
-		thetaLength: thetaLength
-	};
+		this.parameters = {
+			radius: radius,
+			height: height,
+			radialSegments: radialSegments,
+			heightSegments: heightSegments,
+			openEnded: openEnded,
+			thetaStart: thetaStart,
+			thetaLength: thetaLength
+		};
 
-}
+	}
 
-ConeGeometry.prototype = Object.create( CylinderGeometry.prototype );
-ConeGeometry.prototype.constructor = ConeGeometry;
+}
 
 // ConeBufferGeometry
 
-function ConeBufferGeometry( radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {
+class ConeBufferGeometry extends CylinderBufferGeometry {
 
-	CylinderBufferGeometry.call( this, 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength );
+	constructor( radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength ) {
 
-	this.type = 'ConeBufferGeometry';
+		super( 0, radius, height, radialSegments, heightSegments, openEnded, thetaStart, thetaLength );
+		this.type = 'ConeBufferGeometry';
 
-	this.parameters = {
-		radius: radius,
-		height: height,
-		radialSegments: radialSegments,
-		heightSegments: heightSegments,
-		openEnded: openEnded,
-		thetaStart: thetaStart,
-		thetaLength: thetaLength
-	};
+		this.parameters = {
+			radius: radius,
+			height: height,
+			radialSegments: radialSegments,
+			heightSegments: heightSegments,
+			openEnded: openEnded,
+			thetaStart: thetaStart,
+			thetaLength: thetaLength
+		};
 
-}
+	}
 
-ConeBufferGeometry.prototype = Object.create( CylinderBufferGeometry.prototype );
-ConeBufferGeometry.prototype.constructor = ConeBufferGeometry;
+}
 
 
 export { ConeGeometry, ConeBufferGeometry };

src/geometries/CylinderGeometry.d.ts

@@ -3,6 +3,16 @@ import { BufferGeometry } from '../core/BufferGeometry';
 
 export class CylinderBufferGeometry extends BufferGeometry {
 
+	/**
+	 * @param [radiusTop=1] — Radius of the cylinder at the top.
+	 * @param [radiusBottom=1] — Radius of the cylinder at the bottom.
+	 * @param [height=1] — Height of the cylinder.
+	 * @param [radiusSegments=8] — Number of segmented faces around the circumference of the cylinder.
+	 * @param [heightSegments=1] — Number of rows of faces along the height of the cylinder.
+	 * @param [openEnded=false] - A Boolean indicating whether or not to cap the ends of the cylinder.
+	 * @param [thetaStart=0]
+	 * @param [widthSegments=Math.PI * 2]
+	 */
 	constructor(
 		radiusTop?: number,
 		radiusBottom?: number,
@@ -14,6 +24,11 @@ export class CylinderBufferGeometry extends BufferGeometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'CylinderBufferGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radiusTop: number;
 		radiusBottom: number;
@@ -30,12 +45,14 @@ export class CylinderBufferGeometry extends BufferGeometry {
 export class CylinderGeometry extends Geometry {
 
 	/**
-	 * @param radiusTop — Radius of the cylinder at the top.
-	 * @param radiusBottom — Radius of the cylinder at the bottom.
-	 * @param height — Height of the cylinder.
-	 * @param radiusSegments — Number of segmented faces around the circumference of the cylinder.
-	 * @param heightSegments — Number of rows of faces along the height of the cylinder.
-	 * @param openEnded - A Boolean indicating whether or not to cap the ends of the cylinder.
+	 * @param [radiusTop=1] — Radius of the cylinder at the top.
+	 * @param [radiusBottom=1] — Radius of the cylinder at the bottom.
+	 * @param [height=1] — Height of the cylinder.
+	 * @param [radiusSegments=8] — Number of segmented faces around the circumference of the cylinder.
+	 * @param [heightSegments=1] — Number of rows of faces along the height of the cylinder.
+	 * @param [openEnded=false] - A Boolean indicating whether or not to cap the ends of the cylinder.
+	 * @param [thetaStart=0]
+	 * @param [widthSegments=Math.PI * 2]
 	 */
 	constructor(
 		radiusTop?: number,
@@ -48,6 +65,11 @@ export class CylinderGeometry extends Geometry {
 		thetaLength?: number
 	);
 
+	/**
+	 * @default 'CylinderGeometry'
+	 */
+	type: string;
+
 	parameters: {
 		radiusTop: number;
 		radiusBottom: number;