super-three 0.136.1 → 0.144.0

package/examples/jsm/loaders/ifc/web-ifc-api.js

@@ -173,7 +173,7 @@ var require_web_ifc = __commonJS({
             scriptDirectory = _scriptDir;
           }
           if (scriptDirectory.indexOf("blob:") !== 0) {
-            scriptDirectory = scriptDirectory.substr(0, scriptDirectory.lastIndexOf("/") + 1);
+            scriptDirectory = scriptDirectory.slice(0, scriptDirectory.lastIndexOf("/") + 1);
           } else {
             scriptDirectory = "";
           }
@@ -728,7 +728,7 @@ var require_web_ifc = __commonJS({
           }
           return parts;
         }, normalize: function(path) {
-          var isAbsolute = path.charAt(0) === "/", trailingSlash = path.substr(-1) === "/";
+          var isAbsolute = path.charAt(0) === "/", trailingSlash = path.slice(-1) === "/";
           path = PATH.normalizeArray(path.split("/").filter(function(p) {
             return !!p;
           }), !isAbsolute).join("/");
@@ -745,7 +745,7 @@ var require_web_ifc = __commonJS({
             return ".";
           }
           if (dir) {
-            dir = dir.substr(0, dir.length - 1);
+            dir = dir.slice(0, dir.length - 1);
           }
           return root + dir;
         }, basename: function(path) {
@@ -756,7 +756,7 @@ var require_web_ifc = __commonJS({
           var lastSlash = path.lastIndexOf("/");
           if (lastSlash === -1)
             return path;
-          return path.substr(lastSlash + 1);
+          return path.slice(lastSlash + 1);
         }, extname: function(path) {
           return PATH.splitPath(path)[3];
         }, join: function() {
@@ -802,8 +802,8 @@ var require_web_ifc = __commonJS({
           }), !resolvedAbsolute).join("/");
           return (resolvedAbsolute ? "/" : "") + resolvedPath || ".";
         }, relative: function(from, to) {
-          from = PATH_FS.resolve(from).substr(1);
-          to = PATH_FS.resolve(to).substr(1);
+          from = PATH_FS.resolve(from).slice(1);
+          to = PATH_FS.resolve(to).slice(1);
           function trim(arr) {
             var start = 0;
             for (; start < arr.length; start++) {
@@ -2692,7 +2692,7 @@ var require_web_ifc = __commonJS({
         }, doMkdir: function(path, mode) {
           path = PATH.normalize(path);
           if (path[path.length - 1] === "/")
-            path = path.substr(0, path.length - 1);
+            path = path.slice(0, path.length - 1);
           FS.mkdir(path, mode, 0);
           return 0;
         }, doMknod: function(path, mode, dev) {
@@ -47500,4 +47500,5 @@ export {
 };
 
 
- var WasmPath = "";
+ var WasmPath = "";
+

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

@@ -1,20 +1,18 @@
-function LWO2Parser( IFFParser ) {
+class LWO2Parser {
 
-	this.IFF = IFFParser;
+	constructor( IFFParser ) {
 
-}
-
-LWO2Parser.prototype = {
+		this.IFF = IFFParser;
 
-	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 ) {
 
 			this.IFF.reader.offset -= 4;
@@ -235,7 +233,7 @@ LWO2Parser.prototype = {
 				break;
 
 			case 'IMAG':
-				var index = this.IFF.reader.getVariableLengthIndex();
+				const index = this.IFF.reader.getVariableLengthIndex();
 				this.IFF.currentForm.imageIndex = index;
 				break;
 
@@ -303,7 +301,7 @@ LWO2Parser.prototype = {
 
 			// 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;
 
@@ -411,6 +409,6 @@ LWO2Parser.prototype = {
 
 	}
 
-};
+}
 
 export { LWO2Parser };

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

@@ -1,20 +1,18 @@
-function LWO3Parser( IFFParser ) {
+class LWO3Parser {
 
-	this.IFF = IFFParser;
+	constructor( IFFParser ) {
 
-}
-
-LWO3Parser.prototype = {
+		this.IFF = IFFParser;
 
-	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;
@@ -204,7 +202,7 @@ LWO3Parser.prototype = {
 				break;
 
 			case 'IMAG':
-				var index = this.IFF.reader.getVariableLengthIndex();
+				const index = this.IFF.reader.getVariableLengthIndex();
 				this.IFF.currentForm.imageIndex = index;
 				break;
 
@@ -272,7 +270,7 @@ LWO3Parser.prototype = {
 
 			// 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;
 
@@ -370,6 +368,6 @@ LWO3Parser.prototype = {
 
 	}
 
-};
+}
 
 export { LWO3Parser };

package/examples/jsm/materials/MeshGouraudMaterial.js

@@ -0,0 +1,423 @@
+/**
+ * MeshGouraudMaterial
+ *
+ * Lambert illumination model with Gouraud (per-vertex) shading
+ *
+ */
+
+import { UniformsUtils, UniformsLib, ShaderMaterial, Color, MultiplyOperation } from 'three';
+
+const GouraudShader = {
+
+	uniforms: UniformsUtils.merge( [
+		UniformsLib.common,
+		UniformsLib.specularmap,
+		UniformsLib.envmap,
+		UniformsLib.aomap,
+		UniformsLib.lightmap,
+		UniformsLib.emissivemap,
+		UniformsLib.fog,
+		UniformsLib.lights,
+		{
+			emissive: { value: new 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 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 = 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 = 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;
+
+	}
+
+}
+
+export { MeshGouraudMaterial };

package/examples/jsm/math/ColorConverter.js

@@ -1,6 +1,4 @@
-import {
-	MathUtils
-} from 'three';
+import { MathUtils } from 'three';
 
 const _hsl = {};
 
@@ -20,13 +18,6 @@ class ColorConverter {
 
 	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
@@ -40,45 +31,6 @@ class ColorConverter {
 
 	}
 
-	// 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;
-
-	}
-
 }
 
 export { ColorConverter };

package/examples/jsm/math/ConvexHull.js

@@ -78,26 +78,17 @@ class ConvexHull {
 
 			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;
+						const point = new Vector3();
 
-					if ( attribute !== undefined ) {
+						point.fromBufferAttribute( attribute, i ).applyMatrix4( node.matrixWorld );
 
-						for ( let i = 0, l = attribute.count; i < l; i ++ ) {
-
-							const point = new Vector3();
-
-							point.fromBufferAttribute( attribute, i ).applyMatrix4( node.matrixWorld );
-
-							points.push( point );
-
-						}
+						points.push( point );
 
 					}