super-three 0.181.0 → 0.185.0

package/examples/jsm/loaders/usd/USDAParser.js

@@ -1,23 +1,22 @@
-import {
-	BufferAttribute,
-	BufferGeometry,
-	ClampToEdgeWrapping,
-	Group,
-	NoColorSpace,
-	Mesh,
-	MeshPhysicalMaterial,
-	MirroredRepeatWrapping,
-	RepeatWrapping,
-	SRGBColorSpace,
-	TextureLoader,
-	Object3D,
-	Vector2
-} from 'three';
+// Pre-compiled regex patterns for performance
+const DEF_MATCH_REGEX = /^def\s+(?:(\w+)\s+)?"?([^"]+)"?$/;
+const VARIANT_STRING_REGEX = /^string\s+(\w+)$/;
+const ATTR_MATCH_REGEX = /^(?:uniform\s+)?(\w+(?:\[\])?)\s+(.+)$/;
+
+// Spec types (must match USDCParser/USDComposer)
+const SpecType = {
+	Attribute: 1,
+	Prim: 6,
+	Relationship: 8
+};
 
 class USDAParser {
 
 	parseText( text ) {
 
+		// Preprocess: strip comments and normalize multiline values
+		text = this._preprocess( text );
+
 		const root = {};
 
 		const lines = text.split( '\n' );
@@ -27,18 +26,22 @@ class USDAParser {
 
 		const stack = [ root ];
 
-		// Parse USDA file
-
 		for ( const line of lines ) {
 
-			// console.log( line );
-
 			if ( line.includes( '=' ) ) {
 
-				const assignment = line.split( '=' );
+				// Find the first '=' that's not inside quotes
+				const eqIdx = this._findAssignmentOperator( line );
 
-				const lhs = assignment[ 0 ].trim();
-				const rhs = assignment[ 1 ].trim();
+				if ( eqIdx === - 1 ) {
+
+					string = line.trim();
+					continue;
+
+				}
+
+				const lhs = line.slice( 0, eqIdx ).trim();
+				const rhs = line.slice( eqIdx + 1 ).trim();
 
 				if ( rhs.endsWith( '{' ) ) {
 
@@ -66,8 +69,24 @@ class USDAParser {
 
 				}
 
+			} else if ( line.includes( ':' ) && ! line.includes( '=' ) ) {
+
+				// Handle dictionary entries like "0: [(...)...]" for timeSamples
+				const colonIdx = line.indexOf( ':' );
+				const key = line.slice( 0, colonIdx ).trim();
+				const value = line.slice( colonIdx + 1 ).trim();
+
+				// Only process if key looks like a number (timeSamples frame)
+				if ( /^[\d.]+$/.test( key ) ) {
+
+					target[ key ] = value;
+
+				}
+
 			} else if ( line.endsWith( '{' ) ) {
 
+				string = line.slice( 0, - 1 ).trim() || string;
+
 				const group = target[ string ] || {};
 				stack.push( group );
 
@@ -98,7 +117,7 @@ class USDAParser {
 
 				target = stack[ stack.length - 1 ];
 
-			} else {
+			} else if ( line.trim() ) {
 
 				string = line.trim();
 
@@ -110,499 +129,604 @@ class USDAParser {
 
 	}
 
-	parse( text, assets ) {
-
-		const root = this.parseText( text );
+	_preprocess( text ) {
 
-		// Build scene graph
+		// Remove block comments /* ... */
+		text = this._stripBlockComments( text );
 
-		function findMeshGeometry( data ) {
+		// Collapse triple-quoted strings into single lines
+		text = this._collapseTripleQuotedStrings( text );
 
-			if ( ! data ) return undefined;
+		// Remove line comments # ... (but preserve #usda header)
+		// Only remove # comments that aren't at the start of a line or after whitespace
+		const lines = text.split( '\n' );
+		const processed = [];
 
-			if ( 'prepend references' in data ) {
+		let inMultilineValue = false;
+		let bracketDepth = 0;
+		let parenDepth = 0;
+		let accumulated = '';
 
-				const reference = data[ 'prepend references' ];
-				const parts = reference.split( '@' );
-				const path = parts[ 1 ].replace( /^.\//, '' );
-				const id = parts[ 2 ].replace( /^<\//, '' ).replace( />$/, '' );
+		for ( let i = 0; i < lines.length; i ++ ) {
 
-				return findGeometry( assets[ path ], id );
+			let line = lines[ i ];
 
-			}
+			// Strip inline comments (but not inside strings)
+			line = this._stripInlineComment( line );
 
-			return findGeometry( data );
+			// Track bracket/paren depth for multiline values
+			const trimmed = line.trim();
 
-		}
+			if ( inMultilineValue ) {
 
-		function findGeometry( data, id ) {
+				// Continue accumulating multiline value
+				accumulated += ' ' + trimmed;
 
-			if ( ! data ) return undefined;
+				// Update depths
+				for ( const ch of trimmed ) {
 
-			if ( id !== undefined ) {
+					if ( ch === '[' ) bracketDepth ++;
+					else if ( ch === ']' ) bracketDepth --;
+					else if ( ch === '(' && bracketDepth > 0 ) parenDepth ++;
+					else if ( ch === ')' && bracketDepth > 0 ) parenDepth --;
 
-				const def = `def Mesh "${id}"`;
+				}
 
-				if ( def in data ) {
+				// Check if multiline value is complete
+				if ( bracketDepth === 0 && parenDepth === 0 ) {
 
-					return data[ def ];
+					processed.push( accumulated );
+					accumulated = '';
+					inMultilineValue = false;
 
 				}
 
-			}
+			} else {
 
-			for ( const name in data ) {
+				// Check if this line starts a multiline array value
+				// Look for patterns like "attr = [" or "attr = @path@[" without closing ]
+				if ( trimmed.includes( '=' ) ) {
 
-				const object = data[ name ];
+					const eqIdx = this._findAssignmentOperator( trimmed );
 
-				if ( name.startsWith( 'def Mesh' ) ) {
+					if ( eqIdx !== - 1 ) {
 
-					return object;
+						const rhs = trimmed.slice( eqIdx + 1 ).trim();
 
-				}
+						// Count brackets in the value part
+						let openBrackets = 0;
+						let closeBrackets = 0;
+
+						for ( const ch of rhs ) {
+
+							if ( ch === '[' ) openBrackets ++;
+							else if ( ch === ']' ) closeBrackets ++;
+
+						}
 
+						if ( openBrackets > closeBrackets ) {
 
-				if ( typeof object === 'object' ) {
+							// Multiline array detected
+							inMultilineValue = true;
+							bracketDepth = openBrackets - closeBrackets;
+							parenDepth = 0;
+							accumulated = trimmed;
+							continue;
 
-					const geometry = findGeometry( object );
+						}
 
-					if ( geometry ) return geometry;
+					}
 
 				}
 
+				processed.push( trimmed );
+
 			}
 
 		}
 
-		function buildGeometry( data ) {
-
-			if ( ! data ) return undefined;
+		return processed.join( '\n' );
 
-			const geometry = new BufferGeometry();
-			let indices = null;
-			let counts = null;
-			let uvs = null;
+	}
 
-			let positionsLength = - 1;
+	_stripBlockComments( text ) {
 
-			// index
+		// Iteratively remove /* ... */ comments without regex backtracking
+		let result = '';
+		let i = 0;
 
-			if ( 'int[] faceVertexIndices' in data ) {
+		while ( i < text.length ) {
 
-				indices = JSON.parse( data[ 'int[] faceVertexIndices' ] );
+			// Check for block comment start
+			if ( text[ i ] === '/' && i + 1 < text.length && text[ i + 1 ] === '*' ) {
 
-			}
+				// Find the closing */
+				let j = i + 2;
 
-			// face count
+				while ( j < text.length ) {
 
-			if ( 'int[] faceVertexCounts' in data ) {
+					if ( text[ j ] === '*' && j + 1 < text.length && text[ j + 1 ] === '/' ) {
 
-				counts = JSON.parse( data[ 'int[] faceVertexCounts' ] );
-				indices = toTriangleIndices( indices, counts );
+						// Found closing, skip past it
+						j += 2;
+						break;
 
-			}
+					}
 
-			// position
+					j ++;
 
-			if ( 'point3f[] points' in data ) {
+				}
 
-				const positions = JSON.parse( data[ 'point3f[] points' ].replace( /[()]*/g, '' ) );
-				positionsLength = positions.length;
-				let attribute = new BufferAttribute( new Float32Array( positions ), 3 );
+				// Move past the comment (or to end if unclosed)
+				i = j;
 
-				if ( indices !== null ) attribute = toFlatBufferAttribute( attribute, indices );
+			} else {
 
-				geometry.setAttribute( 'position', attribute );
+				result += text[ i ];
+				i ++;
 
 			}
 
-			// uv
+		}
 
-			if ( 'float2[] primvars:st' in data ) {
+		return result;
 
-				data[ 'texCoord2f[] primvars:st' ] = data[ 'float2[] primvars:st' ];
+	}
 
-			}
+	_collapseTripleQuotedStrings( text ) {
 
-			if ( 'texCoord2f[] primvars:st' in data ) {
+		let result = '';
+		let i = 0;
 
-				uvs = JSON.parse( data[ 'texCoord2f[] primvars:st' ].replace( /[()]*/g, '' ) );
-				let attribute = new BufferAttribute( new Float32Array( uvs ), 2 );
+		while ( i < text.length ) {
 
-				if ( indices !== null ) attribute = toFlatBufferAttribute( attribute, indices );
+			if ( i + 2 < text.length ) {
 
-				geometry.setAttribute( 'uv', attribute );
+				const triple = text.slice( i, i + 3 );
 
-			}
+				if ( triple === '\'\'\'' || triple === '"""' ) {
 
-			if ( 'int[] primvars:st:indices' in data && uvs !== null ) {
+					const quoteChar = triple;
+					result += quoteChar;
+					i += 3;
 
-				// custom uv index, overwrite uvs with new data
+					while ( i < text.length ) {
 
-				const attribute = new BufferAttribute( new Float32Array( uvs ), 2 );
-				let indices = JSON.parse( data[ 'int[] primvars:st:indices' ] );
-				indices = toTriangleIndices( indices, counts );
-				geometry.setAttribute( 'uv', toFlatBufferAttribute( attribute, indices ) );
+						if ( i + 2 < text.length && text.slice( i, i + 3 ) === quoteChar ) {
 
-			}
+							result += quoteChar;
+							i += 3;
+							break;
 
-			// normal
+						} else {
 
-			if ( 'normal3f[] normals' in data ) {
+							if ( text[ i ] === '\n' ) {
 
-				const normals = JSON.parse( data[ 'normal3f[] normals' ].replace( /[()]*/g, '' ) );
-				let attribute = new BufferAttribute( new Float32Array( normals ), 3 );
+								result += '\\n';
 
-				// normals require a special treatment in USD
+							} else if ( text[ i ] !== '\r' ) {
 
-				if ( normals.length === positionsLength ) {
+								result += text[ i ];
 
-					// raw normal and position data have equal length (like produced by USDZExporter)
+							}
 
-					if ( indices !== null ) attribute = toFlatBufferAttribute( attribute, indices );
+							i ++;
 
-				} else {
+						}
 
-					// unequal length, normals are independent of faceVertexIndices
+					}
 
-					let indices = Array.from( Array( normals.length / 3 ).keys() ); // [ 0, 1, 2, 3 ... ]
-					indices = toTriangleIndices( indices, counts );
-					attribute = toFlatBufferAttribute( attribute, indices );
+					continue;
 
 				}
 
-				geometry.setAttribute( 'normal', attribute );
+			}
 
-			} else {
+			result += text[ i ];
+			i ++;
 
-				// compute flat vertex normals
+		}
 
-				geometry.computeVertexNormals();
+		return result;
 
-			}
+	}
 
-			return geometry;
+	_stripInlineComment( line ) {
 
-		}
+		// Don't strip if line starts with #usda
+		if ( line.trim().startsWith( '#usda' ) ) return line;
 
-		function toTriangleIndices( rawIndices, counts ) {
+		// Find # that's not inside a string
+		let inString = false;
+		let stringChar = null;
+		let escaped = false;
 
-			const indices = [];
+		for ( let i = 0; i < line.length; i ++ ) {
 
-			for ( let i = 0; i < counts.length; i ++ ) {
+			const ch = line[ i ];
 
-				const count = counts[ i ];
+			if ( escaped ) {
 
-				const stride = i * count;
+				escaped = false;
+				continue;
+
+			}
 
-				if ( count === 3 ) {
+			if ( ch === '\\' ) {
 
-					const a = rawIndices[ stride + 0 ];
-					const b = rawIndices[ stride + 1 ];
-					const c = rawIndices[ stride + 2 ];
+				escaped = true;
+				continue;
 
-					indices.push( a, b, c );
+			}
 
-				} else if ( count === 4 ) {
+			if ( ! inString && ( ch === '"' || ch === '\'' ) ) {
 
-					const a = rawIndices[ stride + 0 ];
-					const b = rawIndices[ stride + 1 ];
-					const c = rawIndices[ stride + 2 ];
-					const d = rawIndices[ stride + 3 ];
+				inString = true;
+				stringChar = ch;
 
-					indices.push( a, b, c );
-					indices.push( a, c, d );
+			} else if ( inString && ch === stringChar ) {
 
-				} else {
+				inString = false;
+				stringChar = null;
 
-					console.warn( 'THREE.USDZLoader: Face vertex count of %s unsupported.', count );
+			} else if ( ! inString && ch === '#' ) {
 
-				}
+				// Found comment start outside of string
+				return line.slice( 0, i ).trimEnd();
 
 			}
 
-			return indices;
-
 		}
 
-		function toFlatBufferAttribute( attribute, indices ) {
-
-			const array = attribute.array;
-			const itemSize = attribute.itemSize;
+		return line;
 
-			const array2 = new array.constructor( indices.length * itemSize );
+	}
 
-			let index = 0, index2 = 0;
+	_findAssignmentOperator( line ) {
 
-			for ( let i = 0, l = indices.length; i < l; i ++ ) {
+		// Find the first '=' that's not inside quotes
+		let inString = false;
+		let stringChar = null;
+		let escaped = false;
 
-				index = indices[ i ] * itemSize;
+		for ( let i = 0; i < line.length; i ++ ) {
 
-				for ( let j = 0; j < itemSize; j ++ ) {
+			const ch = line[ i ];
 
-					array2[ index2 ++ ] = array[ index ++ ];
+			if ( escaped ) {
 
-				}
+				escaped = false;
+				continue;
 
 			}
 
-			return new BufferAttribute( array2, itemSize );
-
-		}
+			if ( ch === '\\' ) {
 
-		function findMeshMaterial( data ) {
+				escaped = true;
+				continue;
 
-			if ( ! data ) return undefined;
+			}
 
-			if ( 'rel material:binding' in data ) {
+			if ( ! inString && ( ch === '"' || ch === '\'' ) ) {
 
-				const reference = data[ 'rel material:binding' ];
-				const id = reference.replace( /^<\//, '' ).replace( />$/, '' );
-				const parts = id.split( '/' );
+				inString = true;
+				stringChar = ch;
 
-				return findMaterial( root, ` "${ parts[ 1 ] }"` );
+			} else if ( inString && ch === stringChar ) {
 
-			}
+				inString = false;
+				stringChar = null;
 
-			return findMaterial( data );
+			} else if ( ! inString && ch === '=' ) {
 
-		}
+				return i;
 
-		function findMaterial( data, id = '' ) {
+			}
 
-			for ( const name in data ) {
+		}
 
-				const object = data[ name ];
+		return - 1;
 
-				if ( name.startsWith( 'def Material' + id ) ) {
+	}
 
-					return object;
+	/**
+	 * Parse USDA text and return raw spec data in specsByPath format.
+	 * Used by USDComposer for unified scene composition.
+	 */
+	parseData( text ) {
 
-				}
+		const root = this.parseText( text );
+		const specsByPath = {};
 
-				if ( typeof object === 'object' ) {
+		// Parse root metadata
+		const rootFields = {};
+		if ( '#usda 1.0' in root ) {
 
-					const material = findMaterial( object, id );
+			const header = root[ '#usda 1.0' ];
 
-					if ( material ) return material;
+			if ( header.upAxis ) {
 
-				}
+				rootFields.upAxis = header.upAxis.replace( /"/g, '' );
 
 			}
 
-		}
+			if ( header.defaultPrim ) {
 
-		function setTextureParams( map, data_value ) {
+				rootFields.defaultPrim = header.defaultPrim.replace( /"/g, '' );
 
-			// rotation, scale and translation
+			}
 
-			if ( data_value[ 'float inputs:rotation' ] ) {
+			if ( header.metersPerUnit !== undefined ) {
 
-				map.rotation = parseFloat( data_value[ 'float inputs:rotation' ] );
+				rootFields.metersPerUnit = parseFloat( header.metersPerUnit );
 
 			}
 
-			if ( data_value[ 'float2 inputs:scale' ] ) {
+			if ( header.framesPerSecond !== undefined ) {
 
-				map.repeat = new Vector2().fromArray( JSON.parse( '[' + data_value[ 'float2 inputs:scale' ].replace( /[()]*/g, '' ) + ']' ) );
+				rootFields.framesPerSecond = parseFloat( header.framesPerSecond );
 
 			}
 
-			if ( data_value[ 'float2 inputs:translation' ] ) {
+			if ( header.timeCodesPerSecond !== undefined ) {
 
-				map.offset = new Vector2().fromArray( JSON.parse( '[' + data_value[ 'float2 inputs:translation' ].replace( /[()]*/g, '' ) + ']' ) );
+				rootFields.timeCodesPerSecond = parseFloat( header.timeCodesPerSecond );
 
 			}
 
 		}
 
-		function buildMaterial( data ) {
+		specsByPath[ '/' ] = { specType: SpecType.Prim, fields: rootFields };
 
-			const material = new MeshPhysicalMaterial();
+		// Walk the tree and build specsByPath
+		const walkTree = ( data, parentPath ) => {
 
-			if ( data !== undefined ) {
+			const primChildren = [];
 
-				let surface = undefined;
+			for ( const key in data ) {
 
-				const surfaceConnection = data[ 'token outputs:surface.connect' ];
+				// Skip metadata
+				if ( key === '#usda 1.0' ) continue;
+				if ( key === 'variants' ) continue;
 
-				if ( surfaceConnection ) {
+				// Check for primitive definitions
+				// Matches both 'def TypeName "name"' and 'def "name"' (no type)
+				const defMatch = key.match( DEF_MATCH_REGEX );
+				if ( defMatch ) {
 
-					const match = /(\w+)\.output/.exec( surfaceConnection );
+					const typeName = defMatch[ 1 ] || '';
+					const name = defMatch[ 2 ];
+					const path = parentPath === '/' ? '/' + name : parentPath + '/' + name;
 
-					if ( match ) {
+					primChildren.push( name );
 
-						const surfaceName = match[ 1 ];
-						surface = data[ `def Shader "${surfaceName}"` ];
+					const primFields = { typeName };
+					const primData = data[ key ];
 
-					}
+					// Extract attributes and relationships from this prim
+					this._extractPrimData( primData, path, primFields, specsByPath, SpecType );
+
+					specsByPath[ path ] = { specType: SpecType.Prim, fields: primFields };
+
+					// Recurse into children
+					walkTree( primData, path );
 
 				}
 
-				if ( surface !== undefined ) {
+			}
 
-					if ( 'color3f inputs:diffuseColor.connect' in surface ) {
+			// Add primChildren to parent spec
+			if ( primChildren.length > 0 && specsByPath[ parentPath ] ) {
 
-						const path = surface[ 'color3f inputs:diffuseColor.connect' ];
-						const sampler = findTexture( root, /(\w+).output/.exec( path )[ 1 ] );
+				specsByPath[ parentPath ].fields.primChildren = primChildren;
 
-						material.map = buildTexture( sampler );
-						material.map.colorSpace = SRGBColorSpace;
+			}
 
-						if ( 'def Shader "Transform2d_diffuse"' in data ) {
+		};
 
-							setTextureParams( material.map, data[ 'def Shader "Transform2d_diffuse"' ] );
+		walkTree( root, '/' );
 
-						}
+		// Fallback: infer elementSize for primvars:skel:jointIndices/jointWeights
+		// when not explicitly declared in the USDA text
+		this._inferSkelElementSize( specsByPath );
 
-					} else if ( 'color3f inputs:diffuseColor' in surface ) {
+		return { specsByPath };
 
-						const color = surface[ 'color3f inputs:diffuseColor' ].replace( /[()]*/g, '' );
-						material.color.fromArray( JSON.parse( '[' + color + ']' ) );
+	}
 
-					}
+	_inferSkelElementSize( specsByPath ) {
 
-					if ( 'color3f inputs:emissiveColor.connect' in surface ) {
+		// For each mesh prim with primvars:skel:jointIndices/jointWeights but no
+		// elementSize, infer it from the data: elementSize = array.length / numVertices.
+		for ( const path in specsByPath ) {
 
-						const path = surface[ 'color3f inputs:emissiveColor.connect' ];
-						const sampler = findTexture( root, /(\w+).output/.exec( path )[ 1 ] );
+			const spec = specsByPath[ path ];
+			if ( spec.specType !== SpecType.Prim || spec.fields.typeName !== 'Mesh' ) continue;
 
-						material.emissiveMap = buildTexture( sampler );
-						material.emissiveMap.colorSpace = SRGBColorSpace;
-						material.emissive.set( 0xffffff );
+			const pointsSpec = specsByPath[ path + '.points' ];
+			if ( ! pointsSpec || ! pointsSpec.fields.default ) continue;
 
-						if ( 'def Shader "Transform2d_emissive"' in data ) {
+			const numVertices = pointsSpec.fields.default.length / 3;
+			if ( numVertices === 0 ) continue;
 
-							setTextureParams( material.emissiveMap, data[ 'def Shader "Transform2d_emissive"' ] );
+			this._inferElementSize( specsByPath[ path + '.primvars:skel:jointIndices' ], numVertices );
+			this._inferElementSize( specsByPath[ path + '.primvars:skel:jointWeights' ], numVertices );
 
-						}
+		}
 
-					} else if ( 'color3f inputs:emissiveColor' in surface ) {
+	}
 
-						const color = surface[ 'color3f inputs:emissiveColor' ].replace( /[()]*/g, '' );
-						material.emissive.fromArray( JSON.parse( '[' + color + ']' ) );
+	_inferElementSize( attrSpec, numVertices ) {
 
-					}
+		if ( ! attrSpec || attrSpec.fields.elementSize !== undefined || ! attrSpec.fields.default ) return;
 
-					if ( 'normal3f inputs:normal.connect' in surface ) {
+		const len = attrSpec.fields.default.length;
+		if ( len > 0 && len % numVertices === 0 ) attrSpec.fields.elementSize = len / numVertices;
 
-						const path = surface[ 'normal3f inputs:normal.connect' ];
-						const sampler = findTexture( root, /(\w+).output/.exec( path )[ 1 ] );
+	}
 
-						material.normalMap = buildTexture( sampler );
-						material.normalMap.colorSpace = NoColorSpace;
+	_extractPrimData( data, path, primFields, specsByPath, SpecType ) {
 
-						if ( 'def Shader "Transform2d_normal"' in data ) {
+		if ( ! data || typeof data !== 'object' ) return;
 
-							setTextureParams( material.normalMap, data[ 'def Shader "Transform2d_normal"' ] );
+		for ( const key in data ) {
 
-						}
+			// Skip nested defs (handled by walkTree)
+			if ( key.startsWith( 'def ' ) ) continue;
 
-					}
+			if ( key === 'prepend references' ) {
 
-					if ( 'float inputs:roughness.connect' in surface ) {
+				primFields.references = [ data[ key ] ];
+				continue;
 
-						const path = surface[ 'float inputs:roughness.connect' ];
-						const sampler = findTexture( root, /(\w+).output/.exec( path )[ 1 ] );
+			}
 
-						material.roughness = 1.0;
-						material.roughnessMap = buildTexture( sampler );
-						material.roughnessMap.colorSpace = NoColorSpace;
+			if ( key === 'payload' ) {
 
-						if ( 'def Shader "Transform2d_roughness"' in data ) {
+				primFields.payload = data[ key ];
+				continue;
 
-							setTextureParams( material.roughnessMap, data[ 'def Shader "Transform2d_roughness"' ] );
+			}
 
-						}
+			if ( key === 'variants' ) {
 
-					} else if ( 'float inputs:roughness' in surface ) {
+				const variantSelection = {};
+				const variants = data[ key ];
 
-						material.roughness = parseFloat( surface[ 'float inputs:roughness' ] );
+				for ( const vKey in variants ) {
+
+					const match = vKey.match( VARIANT_STRING_REGEX );
+					if ( match ) {
+
+						const variantSetName = match[ 1 ];
+						const variantValue = variants[ vKey ].replace( /"/g, '' );
+						variantSelection[ variantSetName ] = variantValue;
 
 					}
 
-					if ( 'float inputs:metallic.connect' in surface ) {
+				}
 
-						const path = surface[ 'float inputs:metallic.connect' ];
-						const sampler = findTexture( root, /(\w+).output/.exec( path )[ 1 ] );
+				if ( Object.keys( variantSelection ).length > 0 ) {
 
-						material.metalness = 1.0;
-						material.metalnessMap = buildTexture( sampler );
-						material.metalnessMap.colorSpace = NoColorSpace;
+					primFields.variantSelection = variantSelection;
 
-						if ( 'def Shader "Transform2d_metallic"' in data ) {
+				}
 
-							setTextureParams( material.metalnessMap, data[ 'def Shader "Transform2d_metallic"' ] );
+				continue;
 
-						}
+			}
 
-					} else if ( 'float inputs:metallic' in surface ) {
+			if ( key.startsWith( 'rel ' ) ) {
 
-						material.metalness = parseFloat( surface[ 'float inputs:metallic' ] );
+				const relName = key.slice( 4 );
+				const relPath = path + '.' + relName;
+				const target = data[ key ].replace( /[<>]/g, '' );
+				specsByPath[ relPath ] = {
+					specType: SpecType.Relationship,
+					fields: { targetPaths: [ target ] }
+				};
+				continue;
 
-					}
+			}
 
-					if ( 'float inputs:clearcoat.connect' in surface ) {
+			// Handle xformOpOrder
+			if ( key.includes( 'xformOpOrder' ) ) {
 
-						const path = surface[ 'float inputs:clearcoat.connect' ];
-						const sampler = findTexture( root, /(\w+).output/.exec( path )[ 1 ] );
+				const ops = data[ key ]
+					.replace( /[\[\]]/g, '' )
+					.split( ',' )
+					.map( s => s.trim().replace( /"/g, '' ) );
+				primFields.xformOpOrder = ops;
+				continue;
 
-						material.clearcoat = 1.0;
-						material.clearcoatMap = buildTexture( sampler );
-						material.clearcoatMap.colorSpace = NoColorSpace;
+			}
 
-						if ( 'def Shader "Transform2d_clearcoat"' in data ) {
+			// Handle typed attributes
+			// Format: [qualifier] type attrName (e.g., "uniform token[] joints", "float3 position")
+			const attrMatch = key.match( ATTR_MATCH_REGEX );
+			if ( attrMatch ) {
 
-							setTextureParams( material.clearcoatMap, data[ 'def Shader "Transform2d_clearcoat"' ] );
+				const valueType = attrMatch[ 1 ];
+				const attrName = attrMatch[ 2 ];
+				const rawValue = data[ key ];
 
-						}
+				// Handle connection attributes (e.g., "inputs:normal.connect = </path>")
+				if ( attrName.endsWith( '.connect' ) ) {
+
+					const baseAttrName = attrName.slice( 0, - 8 ); // Remove '.connect'
+					const attrPath = path + '.' + baseAttrName;
 
-					} else if ( 'float inputs:clearcoat' in surface ) {
+					// Parse connection path - extract from <path> format
+					let connPath = String( rawValue ).trim();
+					if ( connPath.startsWith( '<' ) ) connPath = connPath.slice( 1 );
+					if ( connPath.endsWith( '>' ) ) connPath = connPath.slice( 0, - 1 );
 
-						material.clearcoat = parseFloat( surface[ 'float inputs:clearcoat' ] );
+					// Get or create the attribute spec
+					if ( ! specsByPath[ attrPath ] ) {
+
+						specsByPath[ attrPath ] = {
+							specType: SpecType.Attribute,
+							fields: { typeName: valueType }
+						};
 
 					}
 
-					if ( 'float inputs:clearcoatRoughness.connect' in surface ) {
+					specsByPath[ attrPath ].fields.connectionPaths = [ connPath ];
+					continue;
 
-						const path = surface[ 'float inputs:clearcoatRoughness.connect' ];
-						const sampler = findTexture( root, /(\w+).output/.exec( path )[ 1 ] );
+				}
 
-						material.clearcoatRoughness = 1.0;
-						material.clearcoatRoughnessMap = buildTexture( sampler );
-						material.clearcoatRoughnessMap.colorSpace = NoColorSpace;
+				// Handle timeSamples attributes specially
+				if ( attrName.endsWith( '.timeSamples' ) && typeof rawValue === 'object' ) {
 
-						if ( 'def Shader "Transform2d_clearcoatRoughness"' in data ) {
+					const baseAttrName = attrName.slice( 0, - 12 ); // Remove '.timeSamples'
+					const attrPath = path + '.' + baseAttrName;
 
-							setTextureParams( material.clearcoatRoughnessMap, data[ 'def Shader "Transform2d_clearcoatRoughness"' ] );
+					// Parse timeSamples dictionary into times and values arrays
+					const times = [];
+					const values = [];
 
-						}
+					for ( const frameKey in rawValue ) {
 
-					} else if ( 'float inputs:clearcoatRoughness' in surface ) {
+						const frame = parseFloat( frameKey );
+						if ( isNaN( frame ) ) continue;
 
-						material.clearcoatRoughness = parseFloat( surface[ 'float inputs:clearcoatRoughness' ] );
+						times.push( frame );
+						values.push( this._parseAttributeValue( valueType, rawValue[ frameKey ] ) );
 
 					}
 
-					if ( 'float inputs:ior' in surface ) {
+					// Sort by time
+					const sorted = times.map( ( t, i ) => ( { t, v: values[ i ] } ) ).sort( ( a, b ) => a.t - b.t );
 
-						material.ior = parseFloat( surface[ 'float inputs:ior' ] );
+					specsByPath[ attrPath ] = {
+						specType: SpecType.Attribute,
+						fields: {
+							timeSamples: { times: sorted.map( s => s.t ), values: sorted.map( s => s.v ) },
+							typeName: valueType
+						}
+					};
 
-					}
+				} else {
 
-					if ( 'float inputs:occlusion.connect' in surface ) {
+					// Parse value based on type
+					const parsedValue = this._parseAttributeValue( valueType, rawValue );
 
-						const path = surface[ 'float inputs:occlusion.connect' ];
-						const sampler = findTexture( root, /(\w+).output/.exec( path )[ 1 ] );
+					// Store as attribute spec, preserving any existing fields
+					// (e.g. connectionPaths set by an earlier `.connect` form)
+					const attrPath = path + '.' + attrName;
 
-						material.aoMap = buildTexture( sampler );
-						material.aoMap.colorSpace = NoColorSpace;
+					if ( specsByPath[ attrPath ] ) {
 
-						if ( 'def Shader "Transform2d_occlusion"' in data ) {
+						specsByPath[ attrPath ].fields.default = parsedValue;
+						specsByPath[ attrPath ].fields.typeName = valueType;
 
-							setTextureParams( material.aoMap, data[ 'def Shader "Transform2d_occlusion"' ] );
+					} else {
 
-						}
+						specsByPath[ attrPath ] = {
+							specType: SpecType.Attribute,
+							fields: { default: parsedValue, typeName: valueType }
+						};
 
 					}
 
@@ -610,129 +734,165 @@ class USDAParser {
 
 			}
 
-			return material;
-
 		}
 
-		function findTexture( data, id ) {
-
-			for ( const name in data ) {
+	}
 
-				const object = data[ name ];
+	_parseAttributeValue( valueType, rawValue ) {
 
-				if ( name.startsWith( `def Shader "${ id }"` ) ) {
+		if ( rawValue === undefined || rawValue === null ) return undefined;
 
-					return object;
+		const str = String( rawValue ).trim();
 
-				}
+		// Array types
+		if ( valueType.endsWith( '[]' ) ) {
 
-				if ( typeof object === 'object' ) {
+			let result;
 
-					const texture = findTexture( object, id );
+			// Parse JSON-like arrays
+			try {
 
-					if ( texture ) return texture;
+				// Handle arrays with parentheses like [(1,2,3), (4,5,6)]
+				// Remove trailing comma (valid in USDA but not JSON)
+				let cleaned = str.replace( /\(/g, '[' ).replace( /\)/g, ']' );
+				if ( cleaned.endsWith( ',' ) ) cleaned = cleaned.slice( 0, - 1 );
+				const parsed = JSON.parse( cleaned );
 
-				}
+				// Flatten nested arrays for types like point3f[]
+				result = Array.isArray( parsed ) && Array.isArray( parsed[ 0 ] ) ? parsed.flat() : parsed;
 
-			}
+			} catch ( e ) {
 
-		}
+				// Try simple array parsing
+				const cleaned = str.replace( /[\[\]]/g, '' );
+				result = cleaned.split( ',' ).map( s => {
 
-		function buildTexture( data ) {
+					const trimmed = s.trim();
+					const num = parseFloat( trimmed );
+					return isNaN( num ) ? trimmed.replace( /"/g, '' ) : num;
 
-			if ( 'asset inputs:file' in data ) {
+				} );
 
-				const path = data[ 'asset inputs:file' ].replace( /@*/g, '' ).trim();
+			}
 
-				const loader = new TextureLoader();
+			//reorder (w, x, y, z) to (x, y, z, w)
+			if ( valueType.startsWith( 'quat' ) ) {
 
-				const texture = loader.load( assets[ path ] );
+				for ( let i = 0; i < result.length; i += 4 ) {
 
-				const map = {
-					'"clamp"': ClampToEdgeWrapping,
-					'"mirror"': MirroredRepeatWrapping,
-					'"repeat"': RepeatWrapping
-				};
+					const w = result[ i ];
+					result[ i ] = result[ i + 1 ];
+					result[ i + 1 ] = result[ i + 2 ];
+					result[ i + 2 ] = result[ i + 3 ];
+					result[ i + 3 ] = w;
 
-				if ( 'token inputs:wrapS' in data ) {
+				}
 
-					texture.wrapS = map[ data[ 'token inputs:wrapS' ] ];
+			}
 
-				}
+			return result;
 
-				if ( 'token inputs:wrapT' in data ) {
+		}
 
-					texture.wrapT = map[ data[ 'token inputs:wrapT' ] ];
+		// Vector types (double3, float3, point3f, etc.)
+		if ( valueType.includes( '3' ) || valueType.includes( '2' ) || valueType.includes( '4' ) ) {
 
-				}
+			// Parse (x, y, z) format
+			const cleaned = str.replace( /[()]/g, '' );
+			const values = cleaned.split( ',' ).map( s => parseFloat( s.trim() ) );
+			return values;
 
-				return texture;
+		}
 
-			}
+		// Quaternion types (quatf, quatd, quath)
+		// Text format is (w, x, y, z), convert to (x, y, z, w)
+		if ( valueType.startsWith( 'quat' ) ) {
 
-			return null;
+			const cleaned = str.replace( /[()]/g, '' );
+			const values = cleaned.split( ',' ).map( s => parseFloat( s.trim() ) );
+			return [ values[ 1 ], values[ 2 ], values[ 3 ], values[ 0 ] ];
 
 		}
 
-		function buildObject( data ) {
+		// Matrix types
+		if ( valueType.includes( 'matrix' ) ) {
 
-			const geometry = buildGeometry( findMeshGeometry( data ) );
-			const material = buildMaterial( findMeshMaterial( data ) );
+			const cleaned = str.replace( /[()]/g, '' );
+			const values = cleaned.split( ',' ).map( s => parseFloat( s.trim() ) );
+			return values;
 
-			const mesh = geometry ? new Mesh( geometry, material ) : new Object3D();
+		}
 
-			if ( 'matrix4d xformOp:transform' in data ) {
+		// Scalar numeric types
+		if ( valueType === 'float' || valueType === 'double' || valueType === 'int' ) {
 
-				const array = JSON.parse( '[' + data[ 'matrix4d xformOp:transform' ].replace( /[()]*/g, '' ) + ']' );
+			return parseFloat( str );
 
-				mesh.matrix.fromArray( array );
-				mesh.matrix.decompose( mesh.position, mesh.quaternion, mesh.scale );
+		}
 
-			}
+		// String/token types
+		if ( valueType === 'string' || valueType === 'token' ) {
 
-			return mesh;
+			return this._parseString( str );
 
 		}
 
-		function buildHierarchy( data, group ) {
+		// Asset path
+		if ( valueType === 'asset' ) {
 
-			for ( const name in data ) {
+			return str.replace( /@/g, '' ).replace( /"/g, '' );
 
-				if ( name.startsWith( 'def Scope' ) ) {
+		}
 
-					buildHierarchy( data[ name ], group );
+		// Default: return as string with quotes removed
+		return this._parseString( str );
 
-				} else if ( name.startsWith( 'def Xform' ) ) {
+	}
 
-					const mesh = buildObject( data[ name ] );
+	_parseString( str ) {
 
-					if ( /def Xform "(\w+)"/.test( name ) ) {
+		// Remove surrounding quotes
+		if ( ( str.startsWith( '"' ) && str.endsWith( '"' ) ) ||
+			( str.startsWith( '\'' ) && str.endsWith( '\'' ) ) ) {
 
-						mesh.name = /def Xform "(\w+)"/.exec( name )[ 1 ];
+			str = str.slice( 1, - 1 );
 
-					}
+		}
 
-					group.add( mesh );
+		// Handle escape sequences
+		let result = '';
+		let i = 0;
 
-					buildHierarchy( data[ name ], mesh );
+		while ( i < str.length ) {
 
-				}
+			if ( str[ i ] === '\\' && i + 1 < str.length ) {
 
-			}
+				const next = str[ i + 1 ];
 
-		}
+				switch ( next ) {
 
-		function buildGroup( data ) {
+					case 'n': result += '\n'; break;
+					case 't': result += '\t'; break;
+					case 'r': result += '\r'; break;
+					case '\\': result += '\\'; break;
+					case '"': result += '"'; break;
+					case '\'': result += '\''; break;
+					default: result += next; break;
 
-			const group = new Group();
+				}
 
-			buildHierarchy( data, group );
+				i += 2;
 
-			return group;
+			} else {
+
+				result += str[ i ];
+				i ++;
+
+			}
 
 		}
 
-		return buildGroup( root );
+		return result;
 
 	}