super-three 0.136.1 → 0.144.0

package/examples/jsm/loaders/RGBELoader.js

@@ -168,13 +168,13 @@ class RGBELoader extends DataTextureLoader {
 
 					if ( match = line.match( gamma_re ) ) {
 
-						header.gamma = parseFloat( match[ 1 ], 10 );
+						header.gamma = parseFloat( match[ 1 ] );
 
 					}
 
 					if ( match = line.match( exposure_re ) ) {
 
-						header.exposure = parseFloat( match[ 1 ], 10 );
+						header.exposure = parseFloat( match[ 1 ] );
 
 					}
 
@@ -370,7 +370,7 @@ class RGBELoader extends DataTextureLoader {
 
 			if ( RGBE_RETURN_FAILURE !== image_rgba_data ) {
 
-				let data, format, type;
+				let data, type;
 				let numElements;
 
 				switch ( this.type ) {
@@ -418,7 +418,6 @@ class RGBELoader extends DataTextureLoader {
 					header: rgbe_header_info.string,
 					gamma: rgbe_header_info.gamma,
 					exposure: rgbe_header_info.exposure,
-					format: format,
 					type: type
 				};
 
@@ -444,14 +443,6 @@ class RGBELoader extends DataTextureLoader {
 			switch ( texture.type ) {
 
 				case FloatType:
-
-					texture.encoding = LinearEncoding;
-					texture.minFilter = LinearFilter;
-					texture.magFilter = LinearFilter;
-					texture.generateMipmaps = false;
-					texture.flipY = true;
-					break;
-
 				case HalfFloatType:
 
 					texture.encoding = LinearEncoding;
@@ -459,6 +450,7 @@ class RGBELoader extends DataTextureLoader {
 					texture.magFilter = LinearFilter;
 					texture.generateMipmaps = false;
 					texture.flipY = true;
+
 					break;
 
 			}

package/examples/jsm/loaders/RGBMLoader.js

@@ -151,7 +151,7 @@ UPNG.toRGBA8 = function ( out ) {
 
 		frms.push( img.buffer.slice( 0 ) );
 
-		if ( frm.dispose == 0 ) {} else if ( frm.dispose == 1 ) UPNG._copyTile( empty, fw, fh, img, w, h, fx, fy, 0 );
+		if ( frm.dispose == 1 ) UPNG._copyTile( empty, fw, fh, img, w, h, fx, fy, 0 );
 		else if ( frm.dispose == 2 ) for ( var j = 0; j < len; j ++ ) img[ j ] = prev[ j ];
 
 	}
@@ -285,7 +285,7 @@ UPNG.toRGBA8.decodeImage = function ( data, w, h, out ) {
 			var off = y * bpl, to = y * w;
 			if ( depth == 1 ) for ( var x = 0; x < w; x ++ ) {
 
-				var gr = 255 * ( ( data[ off + ( x >>> 3 ) ] >>> ( 7 - ( ( x & 7 ) ) ) ) & 1 ), al = ( gr == tr * 255 ) ? 0 : 255; bf32[ to + x ] = ( al << 24 ) | ( gr << 16 ) | ( gr << 8 ) | gr;
+				var gr = 255 * ( ( data[ off + ( x >>> 3 ) ] >>> ( 7 - ( x & 7 ) ) ) & 1 ), al = ( gr == tr * 255 ) ? 0 : 255; bf32[ to + x ] = ( al << 24 ) | ( gr << 16 ) | ( gr << 8 ) | gr;
 
 			}
 			else if ( depth == 2 ) for ( var x = 0; x < w; x ++ ) {
@@ -326,6 +326,7 @@ UPNG.decode = function ( buff ) {
 	var out = { tabs: {}, frames: [] };
 	var dd = new Uint8Array( data.length ), doff = 0;	 // put all IDAT data into it
 	var fd, foff = 0;	// frames
+	var text, keyw, bfr;
 
 	var mgck = [ 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a ];
 	for ( var i = 0; i < 8; i ++ ) if ( data[ i ] != mgck[ i ] ) throw new Error( 'The input is not a PNG file!' );
@@ -387,12 +388,12 @@ UPNG.decode = function ( buff ) {
 
 			if ( out.tabs[ type ] == null ) out.tabs[ type ] = {};
 			var nz = bin.nextZero( data, offset );
-			var keyw = bin.readASCII( data, offset, nz - offset );
-			var text, tl = offset + len - nz - 1;
+			keyw = bin.readASCII( data, offset, nz - offset );
+			var tl = offset + len - nz - 1;
 			if ( type == 'tEXt' ) text = bin.readASCII( data, nz + 1, tl );
 			else {
 
-				var bfr = UPNG.decode._inflate( data.slice( nz + 2, nz + 2 + tl ) );
+				bfr = UPNG.decode._inflate( data.slice( nz + 2, nz + 2 + tl ) );
 				text = bin.readUTF8( bfr, 0, bfr.length );
 
 			}
@@ -404,17 +405,17 @@ UPNG.decode = function ( buff ) {
 			if ( out.tabs[ type ] == null ) out.tabs[ type ] = {};
 			var nz = 0, off = offset;
 			nz = bin.nextZero( data, off );
-			var keyw = bin.readASCII( data, off, nz - off ); off = nz + 1;
+			keyw = bin.readASCII( data, off, nz - off ); off = nz + 1;
 			var cflag = data[ off ]; off += 2;
 			nz = bin.nextZero( data, off );
 			bin.readASCII( data, off, nz - off ); off = nz + 1;
 			nz = bin.nextZero( data, off );
 			bin.readUTF8( data, off, nz - off ); off = nz + 1;
-			var text, tl = len - ( off - offset );
+			var tl = len - ( off - offset );
 			if ( cflag == 0 ) text = bin.readUTF8( data, off, tl );
 			else {
 
-				var bfr = UPNG.decode._inflate( data.slice( off, off + tl ) );
+				bfr = UPNG.decode._inflate( data.slice( off, off + tl ) );
 				text = bin.readUTF8( bfr, 0, bfr.length );
 
 			}
@@ -809,6 +810,8 @@ UPNG.decode._readInterlace = function ( data, out ) {
 		UPNG.decode._filterZero( data, out, di, sw, sh );
 
 		var y = 0, row = starting_row[ pass ];
+		var val;
+
 		while ( row < h ) {
 
 			var col = starting_col[ pass ];
@@ -818,21 +821,21 @@ UPNG.decode._readInterlace = function ( data, out ) {
 
 				if ( bpp == 1 ) {
 
-					var val = data[ cdi >> 3 ]; val = ( val >> ( 7 - ( cdi & 7 ) ) ) & 1;
+					val = data[ cdi >> 3 ]; val = ( val >> ( 7 - ( cdi & 7 ) ) ) & 1;
 					img[ row * bpl + ( col >> 3 ) ] |= ( val << ( 7 - ( ( col & 7 ) << 0 ) ) );
 
 				}
 
 				if ( bpp == 2 ) {
 
-					var val = data[ cdi >> 3 ]; val = ( val >> ( 6 - ( cdi & 7 ) ) ) & 3;
+					val = data[ cdi >> 3 ]; val = ( val >> ( 6 - ( cdi & 7 ) ) ) & 3;
 					img[ row * bpl + ( col >> 2 ) ] |= ( val << ( 6 - ( ( col & 3 ) << 1 ) ) );
 
 				}
 
 				if ( bpp == 4 ) {
 
-					var val = data[ cdi >> 3 ]; val = ( val >> ( 4 - ( cdi & 7 ) ) ) & 15;
+					val = data[ cdi >> 3 ]; val = ( val >> ( 4 - ( cdi & 7 ) ) ) & 15;
 					img[ row * bpl + ( col >> 1 ) ] |= ( val << ( 4 - ( ( col & 1 ) << 2 ) ) );
 
 				}

package/examples/jsm/loaders/STLLoader.js

@@ -151,7 +151,7 @@ class STLLoader extends Loader {
 
 			for ( let i = 0, il = query.length; i < il; i ++ ) {
 
-				if ( query[ i ] !== reader.getUint8( offset + i, false ) ) return false;
+				if ( query[ i ] !== reader.getUint8( offset + i ) ) return false;
 
 			}
 

package/examples/jsm/loaders/SVGLoader.js

@@ -71,13 +71,14 @@ class SVGLoader extends Loader {
 
 			const transform = getNodeTransform( node );
 
-			let traverseChildNodes = true;
+			let isDefsNode = false;
 
 			let path = null;
 
 			switch ( node.nodeName ) {
 
 				case 'svg':
+					style = parseStyle( node, style );
 					break;
 
 				case 'style':
@@ -124,12 +125,14 @@ class SVGLoader extends Loader {
 					break;
 
 				case 'defs':
-					traverseChildNodes = false;
+					isDefsNode = true;
 					break;
 
 				case 'use':
 					style = parseStyle( node, style );
-					const usedNodeId = node.href.baseVal.substring( 1 );
+
+					const href = node.getAttributeNS( 'http://www.w3.org/1999/xlink', 'href' ) || '';
+					const usedNodeId = href.substring( 1 );
 					const usedNode = node.viewportElement.getElementById( usedNodeId );
 					if ( usedNode ) {
 
@@ -164,18 +167,26 @@ class SVGLoader extends Loader {
 
 			}
 
-			if ( traverseChildNodes ) {
+			const childNodes = node.childNodes;
+
+			for ( let i = 0; i < childNodes.length; i ++ ) {
 
-				const nodes = node.childNodes;
+				const node = childNodes[ i ];
 
-				for ( let i = 0; i < nodes.length; i ++ ) {
+				if ( isDefsNode && node.nodeName !== 'style' && node.nodeName !== 'defs' ) {
 
-					parseNode( nodes[ i ], style );
+					// Ignore everything in defs except CSS style definitions
+					// and nested defs, because it is OK by the standard to have
+					// <style/> there.
+					continue;
 
 				}
 
+				parseNode( node, style );
+
 			}
 
+
 			if ( transform ) {
 
 				transformStack.pop();
@@ -216,7 +227,7 @@ class SVGLoader extends Loader {
 				const command = commands[ i ];
 
 				const type = command.charAt( 0 );
-				const data = command.substr( 1 ).trim();
+				const data = command.slice( 1 ).trim();
 
 				if ( isFirstPoint === true ) {
 
@@ -1435,9 +1446,9 @@ class SVGLoader extends Loader {
 
 					if ( openParPos > 0 && openParPos < closeParPos ) {
 
-						const transformType = transformText.substr( 0, openParPos );
+						const transformType = transformText.slice( 0, openParPos );
 
-						const array = parseFloats( transformText.substr( openParPos + 1, closeParPos - openParPos - 1 ) );
+						const array = parseFloats( transformText.slice( openParPos + 1 ) );
 
 						currentTransform.identity();
 
@@ -1448,7 +1459,7 @@ class SVGLoader extends Loader {
 								if ( array.length >= 1 ) {
 
 									const tx = array[ 0 ];
-									let ty = tx;
+									let ty = 0;
 
 									if ( array.length >= 2 ) {
 
@@ -2096,7 +2107,7 @@ class SVGLoader extends Loader {
 		simplePaths = simplePaths.filter( sp => sp.points.length > 1 );
 
 		// check if path is solid or a hole
-		const isAHole = simplePaths.map( p => isHoleTo( p, simplePaths, scanlineMinX, scanlineMaxX, shapePath.userData.style.fillRule ) );
+		const isAHole = simplePaths.map( p => isHoleTo( p, simplePaths, scanlineMinX, scanlineMaxX, shapePath.userData?.style.fillRule ) );
 
 
 		const shapesToReturn = [];
@@ -2302,7 +2313,7 @@ class SVGLoader extends Loader {
 				const dot = Math.abs( normal1.dot( tempV2_3 ) );
 
 				// If path is straight, don't create join
-				if ( dot !== 0 ) {
+				if ( dot > Number.EPSILON ) {
 
 					// Compute inner and outer segment intersections
 					const miterSide = strokeWidth2 / dot;

package/examples/jsm/loaders/TIFFLoader.js

@@ -0,0 +1,36 @@
+import {
+	DataTextureLoader,
+	LinearFilter,
+	LinearMipmapLinearFilter
+} from 'three';
+
+import UTIF from '../libs/utif.module.js';
+
+class TIFFLoader extends DataTextureLoader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+	}
+
+	parse( buffer ) {
+
+		const ifds = UTIF.decode( buffer );
+		UTIF.decodeImage( buffer, ifds[ 0 ] );
+		const rgba = UTIF.toRGBA8( ifds[ 0 ] );
+
+		return {
+			width: ifds[ 0 ].width,
+			height: ifds[ 0 ].height,
+			data: rgba,
+			flipY: true,
+			magFilter: LinearFilter,
+			minFilter: LinearMipmapLinearFilter
+		};
+
+	}
+
+}
+
+export { TIFFLoader };

package/examples/jsm/loaders/TTFLoader.js

@@ -2,7 +2,7 @@ import {
 	FileLoader,
 	Loader
 } from 'three';
-import { opentype } from '../libs/opentype.module.min.js';
+import opentype from '../libs/opentype.module.js';
 
 /**
  * Requires opentype.js to be included in the project.

package/examples/jsm/loaders/USDZLoader.js

@@ -0,0 +1,393 @@
+import {
+	BufferAttribute,
+	BufferGeometry,
+	FileLoader,
+	Group,
+	Loader,
+	Mesh,
+	MeshStandardMaterial,
+	TextureLoader
+} from 'three';
+
+import * as fflate from '../libs/fflate.module.js';
+
+class USDZLoader extends Loader {
+
+	constructor( manager ) {
+
+		super( manager );
+
+	}
+
+	load( url, onLoad, onProgress, onError ) {
+
+		const scope = this;
+
+		const loader = new FileLoader( scope.manager );
+		loader.setPath( scope.path );
+		loader.setResponseType( 'arraybuffer' );
+		loader.setRequestHeader( scope.requestHeader );
+		loader.setWithCredentials( scope.withCredentials );
+		loader.load( url, function ( text ) {
+
+			try {
+
+				onLoad( scope.parse( text ) );
+
+			} catch ( e ) {
+
+				if ( onError ) {
+
+					onError( e );
+
+				} else {
+
+					console.error( e );
+
+				}
+
+				scope.manager.itemError( url );
+
+			}
+
+		}, onProgress, onError );
+
+	}
+
+	parse( buffer ) {
+
+		function createImages( zip ) {
+
+			const data = {};
+			const loader = new FileLoader();
+			loader.setResponseType( 'arraybuffer' );
+
+			for ( const filename in zip ) {
+
+				if ( filename.endsWith( 'png' ) ) {
+
+					const blob = new Blob( [ zip[ filename ] ], { type: { type: 'image/png' } } );
+					data[ filename ] = URL.createObjectURL( blob );
+
+				}
+
+			}
+
+			return data;
+
+		}
+
+		function findUSD( zip ) {
+
+			for ( const filename in zip ) {
+
+				if ( filename.endsWith( 'usda' ) ) {
+
+					return zip[ filename ];
+
+				}
+
+			}
+
+		}
+
+		const zip = fflate.unzipSync( new Uint8Array( buffer ) ); // eslint-disable-line no-undef
+
+		// console.log( zip );
+
+		const images = createImages( zip );
+		const file = findUSD( zip );
+
+		if ( file === undefined ) {
+
+			console.warn( 'THREE.USDZLoader: No usda file found.' );
+
+			return {};
+
+		}
+
+		// Parse file
+
+		const text = fflate.strFromU8( file );
+		const lines = text.split( '\n' );
+		const length = lines.length;
+
+		const data = {};
+
+		let current = 0;
+		let string = null;
+		let target = data;
+
+		const stack = [ data ];
+
+		// debugger;
+
+		function parseNextLine() {
+
+			const line = lines[ current ];
+
+			// console.log( line );
+
+			if ( line.includes( '=' ) ) {
+
+				const assignment = line.split( '=' );
+
+				const lhs = assignment[ 0 ].trim();
+				const rhs = assignment[ 1 ].trim();
+
+				if ( rhs.endsWith( '{' ) ) {
+
+					const group = {};
+					stack.push( group );
+
+					target[ lhs ] = group;
+					target = group;
+
+				} else {
+
+					target[ lhs ] = rhs;
+
+				}
+
+			} else if ( line.endsWith( '{' ) ) {
+
+				const group = target[ string ] || {};
+				stack.push( group );
+
+				target[ string ] = group;
+				target = group;
+
+			} else if ( line.endsWith( '}' ) ) {
+
+				stack.pop();
+
+				if ( stack.length === 0 ) return;
+
+				target = stack[ stack.length - 1 ];
+
+			} else if ( line.endsWith( '(' ) ) {
+
+				const meta = {};
+				stack.push( meta );
+
+				string = line.split( '(' )[ 0 ].trim() || string;
+
+				target[ string ] = meta;
+				target = meta;
+
+			} else if ( line.endsWith( ')' ) ) {
+
+				stack.pop();
+
+				target = stack[ stack.length - 1 ];
+
+			} else {
+
+				string = line.trim();
+
+			}
+
+			current ++;
+
+			if ( current < length ) {
+
+				parseNextLine();
+
+			}
+
+		}
+
+		parseNextLine();
+
+		// Build scene
+
+		function findGeometry( data ) {
+
+			for ( const name in data ) {
+
+				const object = data[ name ];
+
+				if ( name.startsWith( 'def Mesh' ) ) {
+
+					// Move st indices to Mesh
+
+					if ( data[ 'int[] primvars:st:indices' ] ) {
+
+						object[ 'int[] primvars:st:indices' ] = data[ 'int[] primvars:st:indices' ];
+
+					}
+
+					return object;
+
+				}
+
+
+				if ( typeof object === 'object' ) {
+
+					const geometry = findGeometry( object );
+
+					if ( geometry ) return geometry;
+
+				}
+
+			}
+
+		}
+
+		function buildGeometry( data ) {
+
+			const geometry = new BufferGeometry();
+			
+			const positions = JSON.parse( data[ 'point3f[] points' ].replace( /[()]*/g, '' ) );
+			const attribute = new BufferAttribute( new Float32Array( positions ), 3 );
+
+			if ( data[ 'int[] faceVertexIndices' ] ) {
+
+				const indices = JSON.parse( data[ 'int[] faceVertexIndices' ] );
+				geometry.setAttribute( 'position', toFlatBufferAttribute( attribute, indices ) );
+
+			} else {
+
+				geometry.setAttribute( 'position', attribute );
+
+			}
+
+
+			if ( data[ 'texCoord2f[] primvars:st' ] ) {
+
+				const uvs = JSON.parse( data[ 'texCoord2f[] primvars:st' ].replace( /[()]*/g, '' ) );
+				const attribute = new BufferAttribute( new Float32Array( uvs ), 2 );
+
+				if ( data[ 'int[] primvars:st:indices' ] ) {
+
+					const indices = JSON.parse( data[ 'int[] primvars:st:indices' ] );
+					geometry.setAttribute( 'uv', toFlatBufferAttribute( attribute, indices ) );
+
+				} else {
+
+					geometry.setAttribute( 'uv', attribute );
+
+				}
+
+			}
+
+			geometry.computeVertexNormals();
+			
+			return geometry;
+
+		}
+
+		function toFlatBufferAttribute( attribute, indices ) {
+
+			const array = attribute.array;
+			const itemSize = attribute.itemSize;
+
+			const array2 = new array.constructor( indices.length * itemSize );
+
+			let index = 0, index2 = 0;
+
+			for ( let i = 0, l = indices.length; i < l; i ++ ) {
+
+				index = indices[ i ] * itemSize;
+
+				for ( let j = 0; j < itemSize; j ++ ) {
+
+					array2[ index2 ++ ] = array[ index ++ ];
+
+				}
+
+			}
+
+			return new BufferAttribute( array2, itemSize );
+
+		}
+
+		function findMaterial( data ) {
+
+			for ( const name in data ) {
+
+				const object = data[ name ];
+
+				if ( name.startsWith( 'def Material' ) ) {
+
+					return object;
+
+				}
+
+
+				if ( typeof object === 'object' ) {
+
+					const material = findMaterial( object );
+
+					if ( material ) return material;
+
+				}
+
+			}
+
+		}
+
+		function buildMaterial( data ) {
+
+			const material = new MeshStandardMaterial();
+
+			// console.log( data );
+
+			if ( data[ 'def Shader "diffuseColor_texture"' ] ) {
+
+				const texture = data[ 'def Shader "diffuseColor_texture"' ];
+				const file = texture[ 'asset inputs:file' ].replace( /@*/g, '' );
+
+				material.map = new TextureLoader().load( images[ file ] );
+
+			}
+
+			if ( data[ 'def Shader "normal_texture"' ] ) {
+
+				const texture = data[ 'def Shader "normal_texture"' ];
+				const file = texture[ 'asset inputs:file' ].replace( /@*/g, '' );
+
+				material.normalMap = new TextureLoader().load( images[ file ] );
+
+			}
+
+
+			return material;
+
+		}
+
+		function buildMesh( data ) {
+
+			const geometry = buildGeometry( findGeometry( data ) );
+			const material = buildMaterial( findMaterial( data ) );
+
+			const mesh = new Mesh( geometry, material );
+
+			return mesh;
+
+		}
+
+		// console.log( data );
+
+		const group = new Group();
+
+		for ( const name in data ) {
+
+			if ( name.startsWith( 'def Xform' ) ) {
+
+				const mesh = buildMesh( data[ name ] );
+				group.add( mesh );
+
+			}
+
+		}
+
+		// console.log( group );
+
+		return group;
+
+	}
+
+}
+
+export { USDZLoader };