super-three 0.155.0 → 0.157.0

package/examples/jsm/loaders/LDrawLoader.js

@@ -1520,19 +1520,19 @@ class LDrawPartsGeometryCache {
 		const group = info.group;
 		if ( info.faces.length > 0 ) {
 
-			group.add( createObject( info.faces, 3, false, info.totalFaces ) );
+			group.add( createObject( this.loader, info.faces, 3, false, info.totalFaces ) );
 
 		}
 
 		if ( info.lineSegments.length > 0 ) {
 
-			group.add( createObject( info.lineSegments, 2 ) );
+			group.add( createObject( this.loader, info.lineSegments, 2 ) );
 
 		}
 
 		if ( info.conditionalSegments.length > 0 ) {
 
-			group.add( createObject( info.conditionalSegments, 2, true ) );
+			group.add( createObject( this.loader, info.conditionalSegments, 2, true ) );
 
 		}
 
@@ -1640,7 +1640,7 @@ function sortByMaterial( a, b ) {
 
 }
 
-function createObject( elements, elementSize, isConditionalSegments = false, totalElements = null ) {
+function createObject( loader, elements, elementSize, isConditionalSegments = false, totalElements = null ) {
 
 	// Creates a LineSegments (elementSize = 2) or a Mesh (elementSize = 3 )
 	// With per face / segment material, implemented with mesh groups and materials array
@@ -1759,11 +1759,13 @@ function createObject( elements, elementSize, isConditionalSegments = false, tot
 
 					if ( isConditionalSegments ) {
 
-						materials.push( material.userData.edgeMaterial.userData.conditionalEdgeMaterial );
+						const edgeMaterial = loader.edgeMaterialCache.get( material );
+
+						materials.push( loader.conditionalEdgeMaterialCache.get( edgeMaterial ) );
 
 					} else {
 
-						materials.push( material.userData.edgeMaterial );
+						materials.push( loader.edgeMaterialCache.get( material ) );
 
 					}
 
@@ -1886,6 +1888,8 @@ class LDrawLoader extends Loader {
 		// Array of THREE.Material
 		this.materials = [];
 		this.materialLibrary = {};
+		this.edgeMaterialCache = new WeakMap();
+		this.conditionalEdgeMaterialCache = new WeakMap();
 
 		// This also allows to handle the embedded text files ("0 FILE" lines)
 		this.partsCache = new LDrawPartsGeometryCache( this );
@@ -1906,8 +1910,8 @@ class LDrawLoader extends Loader {
 		this.missingColorMaterial = new MeshStandardMaterial( { name: Loader.DEFAULT_MATERIAL_NAME, color: 0xFF00FF, roughness: 0.3, metalness: 0 } );
 		this.missingEdgeColorMaterial = new LineBasicMaterial( { name: Loader.DEFAULT_MATERIAL_NAME, color: 0xFF00FF } );
 		this.missingConditionalEdgeColorMaterial = new LDrawConditionalLineMaterial( { name: Loader.DEFAULT_MATERIAL_NAME, fog: true, color: 0xFF00FF } );
-		this.missingColorMaterial.userData.edgeMaterial = this.missingEdgeColorMaterial;
-		this.missingEdgeColorMaterial.userData.conditionalEdgeMaterial = this.missingConditionalEdgeColorMaterial;
+		this.edgeMaterialCache.set( this.missingColorMaterial, this.missingEdgeColorMaterial );
+		this.conditionalEdgeMaterialCache.set( this.missingEdgeColorMaterial, this.missingConditionalEdgeColorMaterial );
 
 	}
 
@@ -2126,11 +2130,11 @@ class LDrawLoader extends Loader {
 
 			if ( c.isLineSegments ) {
 
-				material = material.userData.edgeMaterial;
+				material = loader.edgeMaterialCache.get( material );
 
 				if ( c.isConditionalLine ) {
 
-					material = material.userData.conditionalEdgeMaterial;
+					material = loader.conditionalEdgeMaterialCache.get( material );
 
 				}
 
@@ -2151,7 +2155,7 @@ class LDrawLoader extends Loader {
 	getMainEdgeMaterial() {
 
 		const mat = this.getMaterial( MAIN_EDGE_COLOUR_CODE );
-		return mat ? mat.userData.edgeMaterial : null;
+		return mat ? this.edgeMaterialCache.get( mat ) : null;
 
 	}
 
@@ -2236,7 +2240,7 @@ class LDrawLoader extends Loader {
 							}
 
 							// Get the edge material for this triangle material
-							edgeMaterial = edgeMaterial.userData.edgeMaterial;
+							edgeMaterial = this.edgeMaterialCache.get( edgeMaterial );
 
 						}
 
@@ -2380,7 +2384,7 @@ class LDrawLoader extends Loader {
 			edgeMaterial.name = name + ' - Edge';
 
 			// This is the material used for conditional edges
-			edgeMaterial.userData.conditionalEdgeMaterial = new LDrawConditionalLineMaterial( {
+			const conditionalEdgeMaterial = new LDrawConditionalLineMaterial( {
 
 				fog: true,
 				transparent: isTransparent,
@@ -2389,15 +2393,17 @@ class LDrawLoader extends Loader {
 				opacity: alpha,
 
 			} );
-			edgeMaterial.userData.conditionalEdgeMaterial.userData.code = code;
-			edgeMaterial.userData.conditionalEdgeMaterial.name = name + ' - Conditional Edge';
+			conditionalEdgeMaterial.userData.code = code;
+			conditionalEdgeMaterial.name = name + ' - Conditional Edge';
+
+			this.conditionalEdgeMaterialCache.set( edgeMaterial, conditionalEdgeMaterial );
 
 		}
 
 		material.userData.code = code;
 		material.name = name;
 
-		material.userData.edgeMaterial = edgeMaterial;
+		this.edgeMaterialCache.set( material, edgeMaterial );
 
 		this.addMaterial( material );
 

package/examples/jsm/loaders/LogLuvLoader.js

@@ -393,7 +393,7 @@ UTIF.toRGBA = function ( out, type ) {
 			break;
 
 		default:
-			console.error( 'THREE.LogLuvLoader: Unsupported texture data type:', type );
+			throw new Error( 'THREE.LogLuvLoader: Unsupported texture data type: ' + type );
 
 	}
 
@@ -451,7 +451,7 @@ UTIF.toRGBA = function ( out, type ) {
 
 	} else {
 
-		console.log( 'Unsupported Photometric interpretation: ' + intp );
+		throw new Error( 'THREE.LogLuvLoader: Unsupported Photometric interpretation: ' + intp );
 
 	}
 

package/examples/jsm/loaders/MMDLoader.js

@@ -27,6 +27,7 @@ import {
 	Skeleton,
 	SkinnedMesh,
 	SrcAlphaFactor,
+	SRGBColorSpace,
 	TextureLoader,
 	Uint16BufferAttribute,
 	Vector3,
@@ -1133,17 +1134,18 @@ class MaterialBuilder {
 				 * MMDToonMaterial doesn't have ambient. Set it to emissive instead.
 				 * It'll be too bright if material has map texture so using coef 0.2.
 				 */
-			params.diffuse = new Color().fromArray( material.diffuse );
+			params.diffuse = new Color().setRGB(
+				material.diffuse[ 0 ],
+				material.diffuse[ 1 ],
+				material.diffuse[ 2 ],
+				SRGBColorSpace
+			);
 			params.opacity = material.diffuse[ 3 ];
-			params.specular = new Color().fromArray( material.specular );
+			params.specular = new Color().setRGB( ...material.specular, SRGBColorSpace );
 			params.shininess = material.shininess;
-			params.emissive = new Color().fromArray( material.ambient );
+			params.emissive = new Color().setRGB( ...material.ambient, SRGBColorSpace );
 			params.transparent = params.opacity !== 1.0;
 
-			params.diffuse.convertSRGBToLinear();
-			params.specular.convertSRGBToLinear();
-			params.emissive.convertSRGBToLinear();
-
 			//
 
 			params.fog = true;
@@ -1452,6 +1454,7 @@ class MaterialBuilder {
 			t.flipY = false;
 			t.wrapS = RepeatWrapping;
 			t.wrapT = RepeatWrapping;
+			t.colorSpace = SRGBColorSpace;
 
 			for ( let i = 0; i < texture.readyCallbacks.length; i ++ ) {
 

package/examples/jsm/loaders/RGBELoader.js

@@ -25,10 +25,6 @@ class RGBELoader extends DataTextureLoader {
 	parse( buffer ) {
 
 		const
-			/* return codes for rgbe routines */
-			//RGBE_RETURN_SUCCESS = 0,
-			RGBE_RETURN_FAILURE = - 1,
-
 			/* default error routine.  change this to change error handling */
 			rgbe_read_error = 1,
 			rgbe_write_error = 2,
@@ -38,19 +34,14 @@ class RGBELoader extends DataTextureLoader {
 
 				switch ( rgbe_error_code ) {
 
-					case rgbe_read_error: console.error( 'THREE.RGBELoader Read Error: ' + ( msg || '' ) );
-						break;
-					case rgbe_write_error: console.error( 'THREE.RGBELoader Write Error: ' + ( msg || '' ) );
-						break;
-					case rgbe_format_error: console.error( 'THREE.RGBELoader Bad File Format: ' + ( msg || '' ) );
-						break;
+					case rgbe_read_error: throw new Error( 'THREE.RGBELoader: Read Error: ' + ( msg || '' ) );
+					case rgbe_write_error: throw new Error( 'THREE.RGBELoader: Write Error: ' + ( msg || '' ) );
+					case rgbe_format_error: throw new Error( 'THREE.RGBELoader: Bad File Format: ' + ( msg || '' ) );
 					default:
-					case rgbe_memory_error: console.error( 'THREE.RGBELoader: Error: ' + ( msg || '' ) );
+					case rgbe_memory_error: throw new Error( 'THREE.RGBELoader: Memory Error: ' + ( msg || '' ) );
 
 				}
 
-				return RGBE_RETURN_FAILURE;
-
 			},
 
 			/* offsets to red, green, and blue components in a data (float) pixel */
@@ -138,14 +129,14 @@ class RGBELoader extends DataTextureLoader {
 
 				if ( buffer.pos >= buffer.byteLength || ! ( line = fgets( buffer ) ) ) {
 
-					return rgbe_error( rgbe_read_error, 'no header found' );
+					rgbe_error( rgbe_read_error, 'no header found' );
 
 				}
 
 				/* if you want to require the magic token then uncomment the next line */
 				if ( ! ( match = line.match( magic_token_re ) ) ) {
 
-					return rgbe_error( rgbe_format_error, 'bad initial token' );
+					rgbe_error( rgbe_format_error, 'bad initial token' );
 
 				}
 
@@ -199,13 +190,13 @@ class RGBELoader extends DataTextureLoader {
 
 				if ( ! ( header.valid & RGBE_VALID_FORMAT ) ) {
 
-					return rgbe_error( rgbe_format_error, 'missing format specifier' );
+					rgbe_error( rgbe_format_error, 'missing format specifier' );
 
 				}
 
 				if ( ! ( header.valid & RGBE_VALID_DIMENSIONS ) ) {
 
-					return rgbe_error( rgbe_format_error, 'missing image size specifier' );
+					rgbe_error( rgbe_format_error, 'missing image size specifier' );
 
 				}
 
@@ -231,7 +222,7 @@ class RGBELoader extends DataTextureLoader {
 
 				if ( scanline_width !== ( ( buffer[ 2 ] << 8 ) | buffer[ 3 ] ) ) {
 
-					return rgbe_error( rgbe_format_error, 'wrong scanline width' );
+					rgbe_error( rgbe_format_error, 'wrong scanline width' );
 
 				}
 
@@ -239,7 +230,7 @@ class RGBELoader extends DataTextureLoader {
 
 				if ( ! data_rgba.length ) {
 
-					return rgbe_error( rgbe_memory_error, 'unable to allocate buffer space' );
+					rgbe_error( rgbe_memory_error, 'unable to allocate buffer space' );
 
 				}
 
@@ -255,7 +246,7 @@ class RGBELoader extends DataTextureLoader {
 
 					if ( pos + 4 > buffer.byteLength ) {
 
-						return rgbe_error( rgbe_read_error );
+						rgbe_error( rgbe_read_error );
 
 					}
 
@@ -266,7 +257,7 @@ class RGBELoader extends DataTextureLoader {
 
 					if ( ( 2 != rgbeStart[ 0 ] ) || ( 2 != rgbeStart[ 1 ] ) || ( ( ( rgbeStart[ 2 ] << 8 ) | rgbeStart[ 3 ] ) != scanline_width ) ) {
 
-						return rgbe_error( rgbe_format_error, 'bad rgbe scanline format' );
+						rgbe_error( rgbe_format_error, 'bad rgbe scanline format' );
 
 					}
 
@@ -282,7 +273,7 @@ class RGBELoader extends DataTextureLoader {
 
 						if ( ( 0 === count ) || ( ptr + count > ptr_end ) ) {
 
-							return rgbe_error( rgbe_format_error, 'bad scanline data' );
+							rgbe_error( rgbe_format_error, 'bad scanline data' );
 
 						}
 
@@ -362,70 +353,61 @@ class RGBELoader extends DataTextureLoader {
 		byteArray.pos = 0;
 		const rgbe_header_info = RGBE_ReadHeader( byteArray );
 
-		if ( RGBE_RETURN_FAILURE !== rgbe_header_info ) {
-
-			const w = rgbe_header_info.width,
-				h = rgbe_header_info.height,
-				image_rgba_data = RGBE_ReadPixels_RLE( byteArray.subarray( byteArray.pos ), w, h );
-
-			if ( RGBE_RETURN_FAILURE !== image_rgba_data ) {
-
-				let data, type;
-				let numElements;
-
-				switch ( this.type ) {
-
-					case FloatType:
+		const w = rgbe_header_info.width,
+			h = rgbe_header_info.height,
+			image_rgba_data = RGBE_ReadPixels_RLE( byteArray.subarray( byteArray.pos ), w, h );
 
-						numElements = image_rgba_data.length / 4;
-						const floatArray = new Float32Array( numElements * 4 );
 
-						for ( let j = 0; j < numElements; j ++ ) {
+		let data, type;
+		let numElements;
 
-							RGBEByteToRGBFloat( image_rgba_data, j * 4, floatArray, j * 4 );
+		switch ( this.type ) {
 
-						}
+			case FloatType:
 
-						data = floatArray;
-						type = FloatType;
-						break;
+				numElements = image_rgba_data.length / 4;
+				const floatArray = new Float32Array( numElements * 4 );
 
-					case HalfFloatType:
+				for ( let j = 0; j < numElements; j ++ ) {
 
-						numElements = image_rgba_data.length / 4;
-						const halfArray = new Uint16Array( numElements * 4 );
+					RGBEByteToRGBFloat( image_rgba_data, j * 4, floatArray, j * 4 );
 
-						for ( let j = 0; j < numElements; j ++ ) {
+				}
 
-							RGBEByteToRGBHalf( image_rgba_data, j * 4, halfArray, j * 4 );
+				data = floatArray;
+				type = FloatType;
+				break;
 
-						}
+			case HalfFloatType:
 
-						data = halfArray;
-						type = HalfFloatType;
-						break;
+				numElements = image_rgba_data.length / 4;
+				const halfArray = new Uint16Array( numElements * 4 );
 
-					default:
+				for ( let j = 0; j < numElements; j ++ ) {
 
-						console.error( 'THREE.RGBELoader: unsupported type: ', this.type );
-						break;
+					RGBEByteToRGBHalf( image_rgba_data, j * 4, halfArray, j * 4 );
 
 				}
 
-				return {
-					width: w, height: h,
-					data: data,
-					header: rgbe_header_info.string,
-					gamma: rgbe_header_info.gamma,
-					exposure: rgbe_header_info.exposure,
-					type: type
-				};
+				data = halfArray;
+				type = HalfFloatType;
+				break;
 
-			}
+			default:
+
+				throw new Error( 'THREE.RGBELoader: Unsupported type: ' + this.type );
+				break;
 
 		}
 
-		return null;
+		return {
+			width: w, height: h,
+			data: data,
+			header: rgbe_header_info.string,
+			gamma: rgbe_header_info.gamma,
+			exposure: rgbe_header_info.exposure,
+			type: type
+		};
 
 	}
 

package/examples/jsm/loaders/STLLoader.js

@@ -274,6 +274,7 @@ class STLLoader extends Loader {
 			const geometry = new BufferGeometry();
 			const patternSolid = /solid([\s\S]*?)endsolid/g;
 			const patternFace = /facet([\s\S]*?)endfacet/g;
+			const patternName = /solid\s(.+)/;
 			let faceCounter = 0;
 
 			const patternFloat = /[\s]+([+-]?(?:\d*)(?:\.\d*)?(?:[eE][+-]?\d+)?)/.source;
@@ -282,6 +283,7 @@ class STLLoader extends Loader {
 
 			const vertices = [];
 			const normals = [];
+			const groupNames = [];
 
 			const normal = new Vector3();
 
@@ -297,6 +299,9 @@ class STLLoader extends Loader {
 
 				const solid = result[ 0 ];
 
+				const name = ( result = patternName.exec( solid ) ) !== null ? result[ 1 ] : '';
+				groupNames.push( name );
+
 				while ( ( result = patternFace.exec( solid ) ) !== null ) {
 
 					let vertexCountPerFace = 0;
@@ -345,6 +350,8 @@ class STLLoader extends Loader {
 				const start = startVertex;
 				const count = endVertex - startVertex;
 
+				geometry.userData.groupNames = groupNames;
+
 				geometry.addGroup( start, count, groupCount );
 				groupCount ++;