super-three 0.136.1 → 0.144.0

package/examples/js/loaders/lwo/LWO2Parser.js

@@ -1,19 +1,19 @@
 ( function () {
 
-	function LWO2Parser( IFFParser ) {
+	class LWO2Parser {
 
-		this.IFF = IFFParser;
+		constructor( IFFParser ) {
 
-	}
+			this.IFF = IFFParser;
+
+		}
 
-	LWO2Parser.prototype = {
-		constructor: LWO2Parser,
-		parseBlock: function () {
+		parseBlock() {
 
 			this.IFF.debugger.offset = this.IFF.reader.offset;
 			this.IFF.debugger.closeForms();
-			var blockID = this.IFF.reader.getIDTag();
-			var length = this.IFF.reader.getUint32(); // size of data in bytes
+			const blockID = this.IFF.reader.getIDTag();
+			let length = this.IFF.reader.getUint32(); // size of data in bytes
 
 			if ( length > this.IFF.reader.dv.byteLength - this.IFF.reader.offset ) {
 
@@ -247,7 +247,7 @@
 					break;
 
 				case 'IMAG':
-					var index = this.IFF.reader.getVariableLengthIndex();
+					const index = this.IFF.reader.getVariableLengthIndex();
 					this.IFF.currentForm.imageIndex = index;
 					break;
 					// Texture Mapping Form
@@ -315,7 +315,7 @@
 					// LWO2 Spec chunks: these are needed since the SURF FORMs are often in LWO2 format
 
 				case 'SMAN':
-					var maxSmoothingAngle = this.IFF.reader.getFloat32();
+					const maxSmoothingAngle = this.IFF.reader.getFloat32();
 					this.IFF.currentSurface.attributes.smooth = maxSmoothingAngle < 0 ? false : true;
 					break;
 					// LWO2: Basic Surface Parameters
@@ -440,7 +440,8 @@
 			}
 
 		}
-	};
+
+	}
 
 	THREE.LWO2Parser = LWO2Parser;
 

package/examples/js/loaders/lwo/LWO3Parser.js

@@ -1,19 +1,19 @@
 ( function () {
 
-	function LWO3Parser( IFFParser ) {
+	class LWO3Parser {
 
-		this.IFF = IFFParser;
+		constructor( IFFParser ) {
 
-	}
+			this.IFF = IFFParser;
+
+		}
 
-	LWO3Parser.prototype = {
-		constructor: LWO3Parser,
-		parseBlock: function () {
+		parseBlock() {
 
 			this.IFF.debugger.offset = this.IFF.reader.offset;
 			this.IFF.debugger.closeForms();
-			var blockID = this.IFF.reader.getIDTag();
-			var length = this.IFF.reader.getUint32(); // size of data in bytes
+			const blockID = this.IFF.reader.getIDTag();
+			const length = this.IFF.reader.getUint32(); // size of data in bytes
 
 			this.IFF.debugger.dataOffset = this.IFF.reader.offset;
 			this.IFF.debugger.length = length; // Data types may be found in either LWO2 OR LWO3 spec
@@ -212,7 +212,7 @@
 					break;
 
 				case 'IMAG':
-					var index = this.IFF.reader.getVariableLengthIndex();
+					const index = this.IFF.reader.getVariableLengthIndex();
 					this.IFF.currentForm.imageIndex = index;
 					break;
 					// Texture Mapping Form
@@ -280,7 +280,7 @@
 					// LWO2 Spec chunks: these are needed since the SURF FORMs are often in LWO2 format
 
 				case 'SMAN':
-					var maxSmoothingAngle = this.IFF.reader.getFloat32();
+					const maxSmoothingAngle = this.IFF.reader.getFloat32();
 					this.IFF.currentSurface.attributes.smooth = maxSmoothingAngle < 0 ? false : true;
 					break;
 					// LWO2: Basic Surface Parameters
@@ -394,7 +394,8 @@
 			}
 
 		}
-	};
+
+	}
 
 	THREE.LWO3Parser = LWO3Parser;
 

package/examples/js/materials/MeshGouraudMaterial.js

@@ -0,0 +1,385 @@
+( function () {
+
+	/**
+ * MeshGouraudMaterial
+ *
+ * Lambert illumination model with Gouraud (per-vertex) shading
+ *
+ */
+	const GouraudShader = {
+		uniforms: THREE.UniformsUtils.merge( [ THREE.UniformsLib.common, THREE.UniformsLib.specularmap, THREE.UniformsLib.envmap, THREE.UniformsLib.aomap, THREE.UniformsLib.lightmap, THREE.UniformsLib.emissivemap, THREE.UniformsLib.fog, THREE.UniformsLib.lights, {
+			emissive: {
+				value: new THREE.Color( 0x000000 )
+			}
+		} ] ),
+		vertexShader:
+  /* glsl */
+  `
+
+		#define GOURAUD
+
+		varying vec3 vLightFront;
+		varying vec3 vIndirectFront;
+
+		#ifdef DOUBLE_SIDED
+			varying vec3 vLightBack;
+			varying vec3 vIndirectBack;
+		#endif
+
+		#include <common>
+		#include <uv_pars_vertex>
+		#include <uv2_pars_vertex>
+		#include <envmap_pars_vertex>
+		#include <bsdfs>
+		#include <lights_pars_begin>
+		#include <color_pars_vertex>
+		#include <fog_pars_vertex>
+		#include <morphtarget_pars_vertex>
+		#include <skinning_pars_vertex>
+		#include <shadowmap_pars_vertex>
+		#include <logdepthbuf_pars_vertex>
+		#include <clipping_planes_pars_vertex>
+
+		void main() {
+
+			#include <uv_vertex>
+			#include <uv2_vertex>
+			#include <color_vertex>
+			#include <morphcolor_vertex>
+
+			#include <beginnormal_vertex>
+			#include <morphnormal_vertex>
+			#include <skinbase_vertex>
+			#include <skinnormal_vertex>
+			#include <defaultnormal_vertex>
+
+			#include <begin_vertex>
+			#include <morphtarget_vertex>
+			#include <skinning_vertex>
+			#include <project_vertex>
+			#include <logdepthbuf_vertex>
+			#include <clipping_planes_vertex>
+
+			#include <worldpos_vertex>
+			#include <envmap_vertex>
+
+			// inlining legacy <lights_lambert_vertex>
+
+			vec3 diffuse = vec3( 1.0 );
+
+			GeometricContext geometry;
+			geometry.position = mvPosition.xyz;
+			geometry.normal = normalize( transformedNormal );
+			geometry.viewDir = ( isOrthographic ) ? vec3( 0, 0, 1 ) : normalize( -mvPosition.xyz );
+
+			GeometricContext backGeometry;
+			backGeometry.position = geometry.position;
+			backGeometry.normal = -geometry.normal;
+			backGeometry.viewDir = geometry.viewDir;
+
+			vLightFront = vec3( 0.0 );
+			vIndirectFront = vec3( 0.0 );
+			#ifdef DOUBLE_SIDED
+				vLightBack = vec3( 0.0 );
+				vIndirectBack = vec3( 0.0 );
+			#endif
+
+			IncidentLight directLight;
+			float dotNL;
+			vec3 directLightColor_Diffuse;
+
+			vIndirectFront += getAmbientLightIrradiance( ambientLightColor );
+
+			vIndirectFront += getLightProbeIrradiance( lightProbe, geometry.normal );
+
+			#ifdef DOUBLE_SIDED
+
+				vIndirectBack += getAmbientLightIrradiance( ambientLightColor );
+
+				vIndirectBack += getLightProbeIrradiance( lightProbe, backGeometry.normal );
+
+			#endif
+
+			#if NUM_POINT_LIGHTS > 0
+
+				#pragma unroll_loop_start
+				for ( int i = 0; i < NUM_POINT_LIGHTS; i ++ ) {
+
+					getPointLightInfo( pointLights[ i ], geometry, directLight );
+
+					dotNL = dot( geometry.normal, directLight.direction );
+					directLightColor_Diffuse = directLight.color;
+
+					vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
+
+					#ifdef DOUBLE_SIDED
+
+						vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
+
+					#endif
+
+				}
+				#pragma unroll_loop_end
+
+			#endif
+
+			#if NUM_SPOT_LIGHTS > 0
+
+				#pragma unroll_loop_start
+				for ( int i = 0; i < NUM_SPOT_LIGHTS; i ++ ) {
+
+					getSpotLightInfo( spotLights[ i ], geometry, directLight );
+
+					dotNL = dot( geometry.normal, directLight.direction );
+					directLightColor_Diffuse = directLight.color;
+
+					vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
+
+					#ifdef DOUBLE_SIDED
+
+						vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
+
+					#endif
+				}
+				#pragma unroll_loop_end
+
+			#endif
+
+			#if NUM_DIR_LIGHTS > 0
+
+				#pragma unroll_loop_start
+				for ( int i = 0; i < NUM_DIR_LIGHTS; i ++ ) {
+
+					getDirectionalLightInfo( directionalLights[ i ], geometry, directLight );
+
+					dotNL = dot( geometry.normal, directLight.direction );
+					directLightColor_Diffuse = directLight.color;
+
+					vLightFront += saturate( dotNL ) * directLightColor_Diffuse;
+
+					#ifdef DOUBLE_SIDED
+
+						vLightBack += saturate( - dotNL ) * directLightColor_Diffuse;
+
+					#endif
+
+				}
+				#pragma unroll_loop_end
+
+			#endif
+
+			#if NUM_HEMI_LIGHTS > 0
+
+				#pragma unroll_loop_start
+				for ( int i = 0; i < NUM_HEMI_LIGHTS; i ++ ) {
+
+					vIndirectFront += getHemisphereLightIrradiance( hemisphereLights[ i ], geometry.normal );
+
+					#ifdef DOUBLE_SIDED
+
+						vIndirectBack += getHemisphereLightIrradiance( hemisphereLights[ i ], backGeometry.normal );
+
+					#endif
+
+				}
+				#pragma unroll_loop_end
+
+			#endif
+
+			#include <shadowmap_vertex>
+			#include <fog_vertex>
+
+		}`,
+		fragmentShader:
+  /* glsl */
+  `
+
+		#define GOURAUD
+
+		uniform vec3 diffuse;
+		uniform vec3 emissive;
+		uniform float opacity;
+
+		varying vec3 vLightFront;
+		varying vec3 vIndirectFront;
+
+		#ifdef DOUBLE_SIDED
+			varying vec3 vLightBack;
+			varying vec3 vIndirectBack;
+		#endif
+
+		#include <common>
+		#include <packing>
+		#include <dithering_pars_fragment>
+		#include <color_pars_fragment>
+		#include <uv_pars_fragment>
+		#include <uv2_pars_fragment>
+		#include <map_pars_fragment>
+		#include <alphamap_pars_fragment>
+		#include <alphatest_pars_fragment>
+		#include <aomap_pars_fragment>
+		#include <lightmap_pars_fragment>
+		#include <emissivemap_pars_fragment>
+		#include <envmap_common_pars_fragment>
+		#include <envmap_pars_fragment>
+		#include <bsdfs>
+		#include <lights_pars_begin>
+		#include <fog_pars_fragment>
+		#include <shadowmap_pars_fragment>
+		#include <shadowmask_pars_fragment>
+		#include <specularmap_pars_fragment>
+		#include <logdepthbuf_pars_fragment>
+		#include <clipping_planes_pars_fragment>
+
+		void main() {
+
+			#include <clipping_planes_fragment>
+
+			vec4 diffuseColor = vec4( diffuse, opacity );
+			ReflectedLight reflectedLight = ReflectedLight( vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ), vec3( 0.0 ) );
+			vec3 totalEmissiveRadiance = emissive;
+
+			#include <logdepthbuf_fragment>
+			#include <map_fragment>
+			#include <color_fragment>
+			#include <alphamap_fragment>
+			#include <alphatest_fragment>
+			#include <specularmap_fragment>
+			#include <emissivemap_fragment>
+
+			// accumulation
+
+			#ifdef DOUBLE_SIDED
+
+				reflectedLight.indirectDiffuse += ( gl_FrontFacing ) ? vIndirectFront : vIndirectBack;
+
+			#else
+
+				reflectedLight.indirectDiffuse += vIndirectFront;
+
+			#endif
+
+			#include <lightmap_fragment>
+
+			reflectedLight.indirectDiffuse *= BRDF_Lambert( diffuseColor.rgb );
+
+			#ifdef DOUBLE_SIDED
+
+				reflectedLight.directDiffuse = ( gl_FrontFacing ) ? vLightFront : vLightBack;
+
+			#else
+
+				reflectedLight.directDiffuse = vLightFront;
+
+			#endif
+
+			reflectedLight.directDiffuse *= BRDF_Lambert( diffuseColor.rgb ) * getShadowMask();
+
+			// modulation
+
+			#include <aomap_fragment>
+
+			vec3 outgoingLight = reflectedLight.directDiffuse + reflectedLight.indirectDiffuse + totalEmissiveRadiance;
+
+			#include <envmap_fragment>
+
+			#include <output_fragment>
+			#include <tonemapping_fragment>
+			#include <encodings_fragment>
+			#include <fog_fragment>
+			#include <premultiplied_alpha_fragment>
+			#include <dithering_fragment>
+
+		}`
+	}; //
+
+	class MeshGouraudMaterial extends THREE.ShaderMaterial {
+
+		constructor( parameters ) {
+
+			super();
+			this.isMeshGouraudMaterial = true;
+			this.type = 'MeshGouraudMaterial'; //this.color = new THREE.Color( 0xffffff ); // diffuse
+			//this.map = null;
+			//this.lightMap = null;
+			//this.lightMapIntensity = 1.0;
+			//this.aoMap = null;
+			//this.aoMapIntensity = 1.0;
+			//this.emissive = new THREE.Color( 0x000000 );
+			//this.emissiveIntensity = 1.0;
+			//this.emissiveMap = null;
+			//this.specularMap = null;
+			//this.alphaMap = null;
+			//this.envMap = null;
+
+			this.combine = THREE.MultiplyOperation; // combine has no uniform
+			//this.reflectivity = 1;
+			//this.refractionRatio = 0.98;
+
+			this.fog = false; // set to use scene fog
+
+			this.lights = true; // set to use scene lights
+
+			this.clipping = false; // set to use user-defined clipping planes
+
+			const shader = GouraudShader;
+			this.defines = Object.assign( {}, shader.defines );
+			this.uniforms = THREE.UniformsUtils.clone( shader.uniforms );
+			this.vertexShader = shader.vertexShader;
+			this.fragmentShader = shader.fragmentShader;
+			const exposePropertyNames = [ 'map', 'lightMap', 'lightMapIntensity', 'aoMap', 'aoMapIntensity', 'emissive', 'emissiveIntensity', 'emissiveMap', 'specularMap', 'alphaMap', 'envMap', 'reflectivity', 'refractionRatio', 'opacity', 'diffuse' ];
+
+			for ( const propertyName of exposePropertyNames ) {
+
+				Object.defineProperty( this, propertyName, {
+					get: function () {
+
+						return this.uniforms[ propertyName ].value;
+
+					},
+					set: function ( value ) {
+
+						this.uniforms[ propertyName ].value = value;
+
+					}
+				} );
+
+			}
+
+			Object.defineProperty( this, 'color', Object.getOwnPropertyDescriptor( this, 'diffuse' ) );
+			this.setValues( parameters );
+
+		}
+
+		copy( source ) {
+
+			super.copy( source );
+			this.color.copy( source.color );
+			this.map = source.map;
+			this.lightMap = source.lightMap;
+			this.lightMapIntensity = source.lightMapIntensity;
+			this.aoMap = source.aoMap;
+			this.aoMapIntensity = source.aoMapIntensity;
+			this.emissive.copy( source.emissive );
+			this.emissiveMap = source.emissiveMap;
+			this.emissiveIntensity = source.emissiveIntensity;
+			this.specularMap = source.specularMap;
+			this.alphaMap = source.alphaMap;
+			this.envMap = source.envMap;
+			this.combine = source.combine;
+			this.reflectivity = source.reflectivity;
+			this.refractionRatio = source.refractionRatio;
+			this.wireframe = source.wireframe;
+			this.wireframeLinewidth = source.wireframeLinewidth;
+			this.wireframeLinecap = source.wireframeLinecap;
+			this.wireframeLinejoin = source.wireframeLinejoin;
+			this.fog = source.fog;
+			return this;
+
+		}
+
+	}
+
+	THREE.MeshGouraudMaterial = MeshGouraudMaterial;
+
+} )();

package/examples/js/math/ColorConverter.js

@@ -16,17 +16,6 @@
 
 		static getHSV( color, target ) {
 
-			if ( target === undefined ) {
-
-				console.warn( 'THREE.ColorConverter: .getHSV() target is now required' );
-				target = {
-					h: 0,
-					s: 0,
-					l: 0
-				};
-
-			}
-
 			color.getHSL( _hsl ); // based on https://gist.github.com/xpansive/1337890#file-index-js
 
 			_hsl.s *= _hsl.l < 0.5 ? _hsl.l : 1 - _hsl.l;
@@ -35,45 +24,6 @@
 			target.v = _hsl.l + _hsl.s;
 			return target;
 
-		} // where c, m, y, k is between 0 and 1
-
-
-		static setCMYK( color, c, m, y, k ) {
-
-			const r = ( 1 - c ) * ( 1 - k );
-			const g = ( 1 - m ) * ( 1 - k );
-			const b = ( 1 - y ) * ( 1 - k );
-			return color.setRGB( r, g, b );
-
-		}
-
-		static getCMYK( color, target ) {
-
-			if ( target === undefined ) {
-
-				console.warn( 'THREE.ColorConverter: .getCMYK() target is now required' );
-				target = {
-					c: 0,
-					m: 0,
-					y: 0,
-					k: 0
-				};
-
-			}
-
-			const r = color.r;
-			const g = color.g;
-			const b = color.b;
-			const k = 1 - Math.max( r, g, b );
-			const c = ( 1 - r - k ) / ( 1 - k );
-			const m = ( 1 - g - k ) / ( 1 - k );
-			const y = ( 1 - b - k ) / ( 1 - k );
-			target.c = c;
-			target.m = m;
-			target.y = y;
-			target.k = k;
-			return target;
-
 		}
 
 	}

package/examples/js/math/ConvexHull.js

@@ -73,24 +73,15 @@
 
 				if ( geometry !== undefined ) {
 
-					if ( geometry.isGeometry ) {
+					const attribute = geometry.attributes.position;
 
-						console.error( 'THREE.ConvexHull no longer supports Geometry. Use THREE.BufferGeometry instead.' );
-						return;
+					if ( attribute !== undefined ) {
 
-					} else if ( geometry.isBufferGeometry ) {
+						for ( let i = 0, l = attribute.count; i < l; i ++ ) {
 
-						const attribute = geometry.attributes.position;
-
-						if ( attribute !== undefined ) {
-
-							for ( let i = 0, l = attribute.count; i < l; i ++ ) {
-
-								const point = new THREE.Vector3();
-								point.fromBufferAttribute( attribute, i ).applyMatrix4( node.matrixWorld );
-								points.push( point );
-
-							}
+							const point = new THREE.Vector3();
+							point.fromBufferAttribute( attribute, i ).applyMatrix4( node.matrixWorld );
+							points.push( point );
 
 						}
 

package/examples/js/math/Lut.js

@@ -4,6 +4,7 @@
 
 		constructor( colormap, count = 32 ) {
 
+			this.isLut = true;
 			this.lut = [];
 			this.map = [];
 			this.n = 0;
@@ -44,27 +45,35 @@
 			this.map = ColorMapKeywords[ colormap ] || ColorMapKeywords.rainbow;
 			this.n = count;
 			const step = 1.0 / this.n;
-			this.lut.length = 0;
+			const minColor = new THREE.Color();
+			const maxColor = new THREE.Color();
+			this.lut.length = 0; // sample at 0
 
-			for ( let i = 0; i <= 1; i += step ) {
+			this.lut.push( new THREE.Color( this.map[ 0 ][ 1 ] ) ); // sample at 1/n, ..., (n-1)/n
+
+			for ( let i = 1; i < count; i ++ ) {
+
+				const alpha = i * step;
 
 				for ( let j = 0; j < this.map.length - 1; j ++ ) {
 
-					if ( i >= this.map[ j ][ 0 ] && i < this.map[ j + 1 ][ 0 ] ) {
+					if ( alpha > this.map[ j ][ 0 ] && alpha <= this.map[ j + 1 ][ 0 ] ) {
 
 						const min = this.map[ j ][ 0 ];
 						const max = this.map[ j + 1 ][ 0 ];
-						const minColor = new THREE.Color( this.map[ j ][ 1 ] );
-						const maxColor = new THREE.Color( this.map[ j + 1 ][ 1 ] );
-						const color = minColor.lerp( maxColor, ( i - min ) / ( max - min ) );
+						minColor.set( this.map[ j ][ 1 ] );
+						maxColor.set( this.map[ j + 1 ][ 1 ] );
+						const color = new THREE.Color().lerpColors( minColor, maxColor, ( alpha - min ) / ( max - min ) );
 						this.lut.push( color );
 
 					}
 
 				}
 
-			}
+			} // sample at 1
 
+
+			this.lut.push( new THREE.Color( this.map[ this.map.length - 1 ][ 1 ] ) );
 			return this;
 
 		}
@@ -82,19 +91,9 @@
 
 		getColor( alpha ) {
 
-			if ( alpha <= this.minV ) {
-
-				alpha = this.minV;
-
-			} else if ( alpha >= this.maxV ) {
-
-				alpha = this.maxV;
-
-			}
-
+			alpha = THREE.MathUtils.clamp( alpha, this.minV, this.maxV );
 			alpha = ( alpha - this.minV ) / ( this.maxV - this.minV );
-			let colorPosition = Math.round( alpha * this.n );
-			colorPosition == this.n ? colorPosition -= 1 : colorPosition;
+			const colorPosition = Math.round( alpha * this.n );
 			return this.lut[ colorPosition ];
 
 		}
@@ -125,6 +124,9 @@
 			const data = imageData.data;
 			let k = 0;
 			const step = 1.0 / this.n;
+			const minColor = new THREE.Color();
+			const maxColor = new THREE.Color();
+			const finalColor = new THREE.Color();
 
 			for ( let i = 1; i >= 0; i -= step ) {
 
@@ -134,12 +136,12 @@
 
 						const min = this.map[ j - 1 ][ 0 ];
 						const max = this.map[ j ][ 0 ];
-						const minColor = new THREE.Color( this.map[ j - 1 ][ 1 ] );
-						const maxColor = new THREE.Color( this.map[ j ][ 1 ] );
-						const color = minColor.lerp( maxColor, ( i - min ) / ( max - min ) );
-						data[ k * 4 ] = Math.round( color.r * 255 );
-						data[ k * 4 + 1 ] = Math.round( color.g * 255 );
-						data[ k * 4 + 2 ] = Math.round( color.b * 255 );
+						minColor.set( this.map[ j - 1 ][ 1 ] );
+						maxColor.set( this.map[ j ][ 1 ] );
+						finalColor.lerpColors( minColor, maxColor, ( i - min ) / ( max - min ) );
+						data[ k * 4 ] = Math.round( finalColor.r * 255 );
+						data[ k * 4 + 1 ] = Math.round( finalColor.g * 255 );
+						data[ k * 4 + 2 ] = Math.round( finalColor.b * 255 );
 						data[ k * 4 + 3 ] = 255;
 						k += 1;
 
@@ -156,7 +158,6 @@
 
 	}
 
-	Lut.prototype.isLut = true;
 	const ColorMapKeywords = {
 		'rainbow': [[ 0.0, 0x0000FF ], [ 0.2, 0x00FFFF ], [ 0.5, 0x00FF00 ], [ 0.8, 0xFFFF00 ], [ 1.0, 0xFF0000 ]],
 		'cooltowarm': [[ 0.0, 0x3C4EC2 ], [ 0.2, 0x9BBCFF ], [ 0.5, 0xDCDCDC ], [ 0.8, 0xF6A385 ], [ 1.0, 0xB40426 ]],