super-three 0.144.0 → 0.147.1

package/examples/jsm/loaders/USDZLoader.js

@@ -1,16 +1,121 @@
 import {
 	BufferAttribute,
 	BufferGeometry,
+	ClampToEdgeWrapping,
 	FileLoader,
 	Group,
 	Loader,
 	Mesh,
 	MeshStandardMaterial,
-	TextureLoader
+	MirroredRepeatWrapping,
+	RepeatWrapping,
+	sRGBEncoding,
+	TextureLoader,
+	Object3D,
 } from 'three';
 
 import * as fflate from '../libs/fflate.module.js';
 
+class USDAParser {
+
+	parse( text ) {
+
+		const data = {};
+
+		const lines = text.split( '\n' );
+		const length = lines.length;
+
+		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();
+
+		return data;
+
+	}
+
+}
+
 class USDZLoader extends Loader {
 
 	constructor( manager ) {
@@ -56,7 +161,9 @@ class USDZLoader extends Loader {
 
 	parse( buffer ) {
 
-		function createImages( zip ) {
+		const parser = new USDAParser();
+
+		function parseAssets( zip ) {
 
 			const data = {};
 			const loader = new FileLoader();
@@ -71,6 +178,13 @@ class USDZLoader extends Loader {
 
 				}
 
+				if ( filename.endsWith( 'usd' ) ) {
+
+					const text = fflate.strFromU8( zip[ filename ] );
+					data[ filename ] = parser.parse( text );
+
+				}
+
 			}
 
 			return data;
@@ -95,123 +209,86 @@ class USDZLoader extends Loader {
 
 		// console.log( zip );
 
-		const images = createImages( zip );
+		const assets = parseAssets( zip );
+
+		// console.log( assets )
+
 		const file = findUSD( zip );
 
 		if ( file === undefined ) {
 
 			console.warn( 'THREE.USDZLoader: No usda file found.' );
 
-			return {};
+			return new Group();
 
 		}
 
+
 		// Parse file
 
 		const text = fflate.strFromU8( file );
-		const lines = text.split( '\n' );
-		const length = lines.length;
+		const root = parser.parse( text );
 
-		const data = {};
-
-		let current = 0;
-		let string = null;
-		let target = data;
+		// Build scene
 
-		const stack = [ data ];
+		function findMeshGeometry( data ) {
 
-		// debugger;
+			if ( ! data ) return undefined;
 
-		function parseNextLine() {
+			if ( 'prepend references' in data ) {
 
-			const line = lines[ current ];
+				const reference = data[ 'prepend references' ];
+				const parts = reference.split( '@' );
+				const path = parts[ 1 ].replace( /^.\//, '' );
+				const id = parts[ 2 ].replace( /^<\//, '' ).replace( />$/, '' );
 
-			// console.log( line );
+				return findGeometry( assets[ path ], id );
 
-			if ( line.includes( '=' ) ) {
+			}
 
-				const assignment = line.split( '=' );
+			return findGeometry( data );
 
-				const lhs = assignment[ 0 ].trim();
-				const rhs = assignment[ 1 ].trim();
+		}
 
-				if ( rhs.endsWith( '{' ) ) {
+		function findGeometry( data, id ) {
 
-					const group = {};
-					stack.push( group );
+			if ( id !== undefined ) {
 
-					target[ lhs ] = group;
-					target = group;
+				const def = `def "%{id}"`;
 
-				} else {
+				if ( def in data ) {
 
-					target[ lhs ] = rhs;
+					return data[ def ];
 
 				}
 
-			} 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 ++;
+			for ( const name in data ) {
 
-			if ( current < length ) {
+				const object = data[ name ];
 
-				parseNextLine();
+				if ( name.startsWith( 'def Mesh' ) ) {
 
-			}
+					// Move points to Mesh
 
-		}
+					if ( 'point3f[] points' in data ) {
 
-		parseNextLine();
+						object[ 'point3f[] points' ] = data[ 'point3f[] points' ];
 
-		// Build scene
+					}
 
-		function findGeometry( data ) {
+					// Move st to Mesh
 
-			for ( const name in data ) {
+					if ( 'float2[] primvars:st' in data ) {
 
-				const object = data[ name ];
+						object[ 'float2[] primvars:st' ] = data[ 'float2[] primvars:st' ];
 
-				if ( name.startsWith( 'def Mesh' ) ) {
+					}
 
 					// Move st indices to Mesh
 
-					if ( data[ 'int[] primvars:st:indices' ] ) {
+					if ( 'int[] primvars:st:indices' in data ) {
 
 						object[ 'int[] primvars:st:indices' ] = data[ 'int[] primvars:st:indices' ];
 
@@ -236,29 +313,51 @@ class USDZLoader extends Loader {
 
 		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 ) return undefined;
 
-			if ( data[ 'int[] faceVertexIndices' ] ) {
+			let geometry = new BufferGeometry();
+
+			if ( 'int[] faceVertexIndices' in data ) {
 
 				const indices = JSON.parse( data[ 'int[] faceVertexIndices' ] );
-				geometry.setAttribute( 'position', toFlatBufferAttribute( attribute, indices ) );
+				geometry.setIndex( new BufferAttribute( new Uint16Array( indices ), 1 ) );
 
-			} else {
+			}
+
+			if ( 'point3f[] points' in data ) {
 
+				const positions = JSON.parse( data[ 'point3f[] points' ].replace( /[()]*/g, '' ) );
+				const attribute = new BufferAttribute( new Float32Array( positions ), 3 );
 				geometry.setAttribute( 'position', attribute );
 
 			}
 
+			if ( 'normal3f[] normals' in data ) {
+
+				const normals = JSON.parse( data[ 'normal3f[] normals' ].replace( /[()]*/g, '' ) );
+				const attribute = new BufferAttribute( new Float32Array( normals ), 3 );
+				geometry.setAttribute( 'normal', attribute );
+
+			} else {
+
+				geometry.computeVertexNormals();
+
+			}
+
+			if ( 'float2[] primvars:st' in data ) {
 
-			if ( data[ 'texCoord2f[] primvars:st' ] ) {
+				data[ 'texCoord2f[] primvars:st' ] = data[ 'float2[] primvars:st' ];
+
+			}
+
+			if ( 'texCoord2f[] primvars:st' in data ) {
 
 				const uvs = JSON.parse( data[ 'texCoord2f[] primvars:st' ].replace( /[()]*/g, '' ) );
 				const attribute = new BufferAttribute( new Float32Array( uvs ), 2 );
 
-				if ( data[ 'int[] primvars:st:indices' ] ) {
+				if ( 'int[] primvars:st:indices' in data ) {
+
+					geometry = geometry.toNonIndexed();
 
 					const indices = JSON.parse( data[ 'int[] primvars:st:indices' ] );
 					geometry.setAttribute( 'uv', toFlatBufferAttribute( attribute, indices ) );
@@ -271,8 +370,6 @@ class USDZLoader extends Loader {
 
 			}
 
-			geometry.computeVertexNormals();
-			
 			return geometry;
 
 		}
@@ -302,22 +399,39 @@ class USDZLoader extends Loader {
 
 		}
 
-		function findMaterial( data ) {
+		function findMeshMaterial( data ) {
+
+			if ( ! data ) return undefined;
+
+			if ( 'rel material:binding' in data ) {
+
+				const reference = data[ 'rel material:binding' ];
+				const id = reference.replace( /^<\//, '' ).replace( />$/, '' );
+				const parts = id.split( '/' );
+
+				return findMaterial( root, ` "${ parts[ 1 ] }"` );
+
+			}
+
+			return findMaterial( data );
+
+		}
+
+		function findMaterial( data, id = '' ) {
 
 			for ( const name in data ) {
 
 				const object = data[ name ];
 
-				if ( name.startsWith( 'def Material' ) ) {
+				if ( name.startsWith( 'def Material' + id ) ) {
 
 					return object;
 
 				}
 
-
 				if ( typeof object === 'object' ) {
 
-					const material = findMaterial( object );
+					const material = findMaterial( object, id );
 
 					if ( material ) return material;
 
@@ -331,58 +445,184 @@ class USDZLoader extends Loader {
 
 			const material = new MeshStandardMaterial();
 
-			// console.log( data );
+			if ( data !== undefined ) {
+
+				if ( 'def Shader "PreviewSurface"' in data ) {
+
+					const surface = data[ 'def Shader "PreviewSurface"' ];
+
+					if ( 'color3f inputs:diffuseColor.connect' in surface ) {
+
+						const path = surface[ 'color3f inputs:diffuseColor.connect' ];
+						const sampler = findTexture( root, /(\w+).output/.exec( path )[ 1 ] );
+
+						material.map = buildTexture( sampler );
+						material.map.encoding = sRGBEncoding;
+
+					} else if ( 'color3f inputs:diffuseColor' in surface ) {
+
+						const color = surface[ 'color3f inputs:diffuseColor' ].replace( /[()]*/g, '' );
+						material.color.fromArray( JSON.parse( '[' + color + ']' ) );
+
+					}
+
+					if ( 'normal3f inputs:normal.connect' in surface ) {
+
+						const path = surface[ 'normal3f inputs:normal.connect' ];
+						const sampler = findTexture( root, /(\w+).output/.exec( path )[ 1 ] );
+
+						material.normalMap = buildTexture( sampler );
 
-			if ( data[ 'def Shader "diffuseColor_texture"' ] ) {
+					}
+
+					if ( 'float inputs:roughness' in surface ) {
+
+						material.roughness = parseFloat( surface[ 'float inputs:roughness' ] );
+
+					}
 
-				const texture = data[ 'def Shader "diffuseColor_texture"' ];
-				const file = texture[ 'asset inputs:file' ].replace( /@*/g, '' );
+					if ( 'float inputs:metallic' in surface ) {
+
+						material.metalness = parseFloat( surface[ 'float inputs:metallic' ] );
+
+					}
+
+				}
 
-				material.map = new TextureLoader().load( images[ file ] );
+				if ( 'def Shader "diffuseColor_texture"' in data ) {
+
+					const sampler = data[ 'def Shader "diffuseColor_texture"' ];
+
+					material.map = buildTexture( sampler );
+					material.map.encoding = sRGBEncoding;
+
+				}
+
+				if ( 'def Shader "normal_texture"' in data ) {
+
+					const sampler = data[ 'def Shader "normal_texture"' ];
+
+					material.normalMap = buildTexture( sampler );
+
+				}
 
 			}
 
-			if ( data[ 'def Shader "normal_texture"' ] ) {
+			return material;
+
+		}
+
+		function findTexture( data, id ) {
+
+			for ( const name in data ) {
+
+				const object = data[ name ];
+
+				if ( name.startsWith( `def Shader "${ id }"` ) ) {
 
-				const texture = data[ 'def Shader "normal_texture"' ];
-				const file = texture[ 'asset inputs:file' ].replace( /@*/g, '' );
+					return object;
+
+				}
+
+				if ( typeof object === 'object' ) {
 
-				material.normalMap = new TextureLoader().load( images[ file ] );
+					const texture = findTexture( object, id );
+
+					if ( texture ) return texture;
+
+				}
 
 			}
 
+		}
 
-			return material;
+		function buildTexture( data ) {
+
+			if ( 'asset inputs:file' in data ) {
+
+				const path = data[ 'asset inputs:file' ].replace( /@*/g, '' );
+
+				const loader = new TextureLoader();
+
+				const texture = loader.load( assets[ path ] );
+
+				const map = {
+					'"clamp"': ClampToEdgeWrapping,
+					'"mirror"': MirroredRepeatWrapping,
+					'"repeat"': RepeatWrapping
+				};
+
+				if ( 'token inputs:wrapS' in data ) {
+
+					texture.wrapS = map[ data[ 'token inputs:wrapS' ] ];
+
+				}
+
+				if ( 'token inputs:wrapT' in data ) {
+
+					texture.wrapT = map[ data[ 'token inputs:wrapT' ] ];
+
+				}
+
+				return texture;
+
+			}
+
+			return null;
 
 		}
 
-		function buildMesh( data ) {
+		function buildObject( data ) {
 
-			const geometry = buildGeometry( findGeometry( data ) );
-			const material = buildMaterial( findMaterial( data ) );
+			const geometry = buildGeometry( findMeshGeometry( data ) );
+			const material = buildMaterial( findMeshMaterial( data ) );
 
-			const mesh = new Mesh( geometry, material );
+			const mesh = geometry ? new Mesh( geometry, material ) : new Object3D();
+
+			if ( 'matrix4d xformOp:transform' in data ) {
+
+				const array = JSON.parse( '[' + data[ 'matrix4d xformOp:transform' ].replace( /[()]*/g, '' ) + ']' );
+
+				mesh.matrix.fromArray( array );
+				mesh.matrix.decompose( mesh.position, mesh.quaternion, mesh.scale );
+
+			}
 
 			return mesh;
 
 		}
 
-		// console.log( data );
+		function buildHierarchy( data, group ) {
 
-		const group = new Group();
+			for ( const name in data ) {
+
+				if ( name.startsWith( 'def Scope' ) ) {
+
+					buildHierarchy( data[ name ], group );
 
-		for ( const name in data ) {
+				} else if ( name.startsWith( 'def Xform' ) ) {
 
-			if ( name.startsWith( 'def Xform' ) ) {
+					const mesh = buildObject( data[ name ] );
 
-				const mesh = buildMesh( data[ name ] );
-				group.add( mesh );
+					if ( /def Xform "(\w+)"/.test( name ) ) {
+
+						mesh.name = /def Xform "(\w+)"/.exec( name )[ 1 ];
+
+					}
+
+					group.add( mesh );
+
+					buildHierarchy( data[ name ], mesh );
+
+				}
 
 			}
 
 		}
 
-		// console.log( group );
+		const group = new Group();
+
+		buildHierarchy( root, group );
 
 		return group;
 

package/examples/jsm/loaders/VRMLLoader.js

@@ -625,6 +625,7 @@ class VRMLLoader extends Loader {
 
 			switch ( nodeName ) {
 
+				case 'Anchor':
 				case 'Group':
 				case 'Transform':
 				case 'Collision':
@@ -706,7 +707,6 @@ class VRMLLoader extends Loader {
 					build = buildWorldInfoNode( node );
 					break;
 
-				case 'Anchor':
 				case 'Billboard':
 
 				case 'Inline':
@@ -794,10 +794,18 @@ class VRMLLoader extends Loader {
 						parseFieldChildren( fieldValues, object );
 						break;
 
+					case 'description':
+						// field not supported
+						break;
+
 					case 'collide':
 						// field not supported
 						break;
 
+					case 'parameter':
+						// field not supported
+						break;
+
 					case 'rotation':
 						const axis = new Vector3( fieldValues[ 0 ], fieldValues[ 1 ], fieldValues[ 2 ] );
 						const angle = fieldValues[ 3 ];
@@ -820,6 +828,10 @@ class VRMLLoader extends Loader {
 						// field not supported
 						break;
 
+					case 'url':
+						// field not supported
+						break;
+
 					default:
 						console.warn( 'THREE.VRMLLoader: Unknown field:', fieldName );
 						break;

package/examples/jsm/math/ConvexHull.js

@@ -122,7 +122,7 @@ class ConvexHull {
 
 	intersectRay( ray, target ) {
 
-		// based on "Fast Ray-Convex Polyhedron Intersection"  by Eric Haines, GRAPHICS GEMS II
+		// based on "Fast Ray-Convex Polyhedron Intersection" by Eric Haines, GRAPHICS GEMS II
 
 		const faces = this.faces;
 
@@ -156,7 +156,7 @@ class ConvexHull {
 
 			if ( vD > 0 ) {
 
-				//  plane faces away from the ray, so this plane is a back-face
+				// plane faces away from the ray, so this plane is a back-face
 
 				tFar = Math.min( t, tFar );
 
@@ -263,7 +263,7 @@ class ConvexHull {
 
 	}
 
-	// Removes all the visible vertices that a given face is able to see which are stored in the 'assigned' vertext list
+	// Removes all the visible vertices that a given face is able to see which are stored in the 'assigned' vertex list
 
 	removeAllVerticesFromFace( face ) {
 
@@ -1268,4 +1268,4 @@ class VertexList {
 
 }
 
-export { ConvexHull };
+export { ConvexHull, Face, HalfEdge, VertexNode, VertexList };