@needle-tools/three 0.146.10 → 0.153.1

package/examples/jsm/loaders/GLTFLoader.js

@@ -6,7 +6,6 @@ import {
 	BufferGeometry,
 	ClampToEdgeWrapping,
 	Color,
-	ColorKeyframeTrack,
 	DirectionalLight,
 	DoubleSide,
 	FileLoader,
@@ -61,8 +60,9 @@ import {
 	Vector2,
 	Vector3,
 	VectorKeyframeTrack,
-	sRGBEncoding
+	SRGBColorSpace
 } from 'three';
+import { toTrianglesDrawMode } from '../utils/BufferGeometryUtils.js';
 
 class GLTFLoader extends Loader {
 
@@ -73,7 +73,6 @@ class GLTFLoader extends Loader {
 		this.dracoLoader = null;
 		this.ktx2Loader = null;
 		this.meshoptDecoder = null;
-		this.animationPointerResolver = null;
 
 		this.pluginCallbacks = [];
 
@@ -95,6 +94,12 @@ class GLTFLoader extends Loader {
 
 		} );
 
+		this.register( function ( parser ) {
+
+			return new GLTFTextureAVIFExtension( parser );
+
+		} );
+
 		this.register( function ( parser ) {
 
 			return new GLTFMaterialsSheenExtension( parser );
@@ -139,25 +144,25 @@ class GLTFLoader extends Loader {
 
 		this.register( function ( parser ) {
 
-			return new GLTFLightsExtension( parser );
+			return new GLTFMaterialsAnisotropyExtension( parser );
 
 		} );
 
 		this.register( function ( parser ) {
 
-			return new GLTFMeshoptCompression( parser );
+			return new GLTFLightsExtension( parser );
 
 		} );
 
 		this.register( function ( parser ) {
 
-			return new GLTFMeshGpuInstancing( parser );
+			return new GLTFMeshoptCompression( parser );
 
 		} );
 
 		this.register( function ( parser ) {
 
-			return new GLTFAnimationPointerExtension( parser );
+			return new GLTFMeshGpuInstancing( parser );
 
 		} );
 
@@ -265,13 +270,6 @@ class GLTFLoader extends Loader {
 
 	}
 
-	setAnimationPointerResolver( animationPointerResolver ) {
-
-		this.animationPointerResolver = animationPointerResolver;
-		return this;
-
-	}
-
 	register( callback ) {
 
 		if ( this.pluginCallbacks.indexOf( callback ) === - 1 ) {
@@ -301,6 +299,7 @@ class GLTFLoader extends Loader {
 		let json;
 		const extensions = {};
 		const plugins = {};
+		const textDecoder = new TextDecoder();
 
 		if ( typeof data === 'string' ) {
 
@@ -308,7 +307,7 @@ class GLTFLoader extends Loader {
 
 		} else if ( data instanceof ArrayBuffer ) {
 
-			const magic = LoaderUtils.decodeText( new Uint8Array( data, 0, 4 ) );
+			const magic = textDecoder.decode( new Uint8Array( data, 0, 4 ) );
 
 			if ( magic === BINARY_EXTENSION_HEADER_MAGIC ) {
 
@@ -327,7 +326,7 @@ class GLTFLoader extends Loader {
 
 			} else {
 
-				json = JSON.parse( LoaderUtils.decodeText( new Uint8Array( data ) ) );
+				json = JSON.parse( textDecoder.decode( data ) );
 
 			}
 
@@ -351,8 +350,7 @@ class GLTFLoader extends Loader {
 			requestHeader: this.requestHeader,
 			manager: this.manager,
 			ktx2Loader: this.ktx2Loader,
-			meshoptDecoder: this.meshoptDecoder,
-			animationPointerResolver: this.animationPointerResolver,
+			meshoptDecoder: this.meshoptDecoder
 
 		} );
 
@@ -480,14 +478,15 @@ const EXTENSIONS = {
 	KHR_MATERIALS_SPECULAR: 'KHR_materials_specular',
 	KHR_MATERIALS_TRANSMISSION: 'KHR_materials_transmission',
 	KHR_MATERIALS_IRIDESCENCE: 'KHR_materials_iridescence',
+	KHR_MATERIALS_ANISOTROPY: 'KHR_materials_anisotropy',
 	KHR_MATERIALS_UNLIT: 'KHR_materials_unlit',
 	KHR_MATERIALS_VOLUME: 'KHR_materials_volume',
 	KHR_TEXTURE_BASISU: 'KHR_texture_basisu',
 	KHR_TEXTURE_TRANSFORM: 'KHR_texture_transform',
 	KHR_MESH_QUANTIZATION: 'KHR_mesh_quantization',
 	KHR_MATERIALS_EMISSIVE_STRENGTH: 'KHR_materials_emissive_strength',
-	KHR_ANIMATION_POINTER: 'KHR_animation_pointer',
 	EXT_TEXTURE_WEBP: 'EXT_texture_webp',
+	EXT_TEXTURE_AVIF: 'EXT_texture_avif',
 	EXT_MESHOPT_COMPRESSION: 'EXT_meshopt_compression',
 	EXT_MESH_GPU_INSTANCING: 'EXT_mesh_gpu_instancing'
 };
@@ -671,7 +670,7 @@ class GLTFMaterialsUnlitExtension {
 
 			if ( metallicRoughness.baseColorTexture !== undefined ) {
 
-				pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, sRGBEncoding ) );
+				pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) );
 
 			}
 
@@ -806,556 +805,6 @@ class GLTFMaterialsClearcoatExtension {
 
 }
 
-/**
- * Animation Pointer Extension
- *
- * Draft Specification: https://github.com/ux3d/glTF/tree/extensions/KHR_animation_pointer/extensions/2.0/Khronos/KHR_animation_pointer
- */
-
-
-// HACK monkey patching findNode to ensure we can map to other types required by KHR_animation_pointer.
-const find = PropertyBinding.findNode;
-const _animationPointerDebug = false;
-
-class GLTFAnimationPointerExtension {
-
-	ANIMATION_TARGET_TYPE = {
-		node: 'node',
-		material: 'material',
-		camera: 'camera',
-		light: 'light',
-	};
-
-	constructor( parser ) {
-
-		this.parser = parser;
-		this.name = EXTENSIONS.KHR_ANIMATION_POINTER;
-
-	}
-
-	_havePatchedPropertyBindings = false;
-	_patchPropertyBindingFindNode() {
-
-		if ( this._havePatchedPropertyBindings ) return;
-		this._havePatchedPropertyBindings = true;
-
-		// "node" is the Animator component in our case
-		// "path" is the animated property path, just with translated material names.
-		PropertyBinding.findNode = function ( node, path ) {
-
-			if ( path.startsWith( '.materials.' ) ) {
-
-				if ( _animationPointerDebug ) console.log( 'FIND', path );
-
-				const remainingPath = path.substring( '.materials.'.length ).substring( path.indexOf( '.' ) );
-				const nextIndex = remainingPath.indexOf( '.' );
-				const uuid = nextIndex < 0 ? remainingPath : remainingPath.substring( 0, nextIndex );
-				let res = null;
-				node.traverse( x => {
-
-					if ( res !== null || x.type !== 'Mesh' ) return;
-					if ( x[ 'material' ]?.uuid === uuid || x[ 'material' ]?.name === uuid ) {
-
-						res = x[ 'material' ];
-						if ( _animationPointerDebug ) console.log( res, remainingPath );
-						if ( res !== null ) {
-
-							if ( remainingPath.endsWith( '.map' ) )
-								res = res[ 'map' ];
-							else if ( remainingPath.endsWith( '.emissiveMap' ) )
-								res = res[ 'emissiveMap' ];
-
-							// TODO other texture slots only make sense if three.js actually supports them
-							// (currently only .map can have repeat/offset)
-
-						}
-
-					}
-
-				} );
-
-				return res;
-
-			} else if ( path.startsWith( '.nodes.' ) || path.startsWith( '.lights.' ) || path.startsWith( '.cameras.' ) ) {
-
-				const sections = path.split( '.' );
-				let currentTarget = undefined;
-				for ( let i = 1; i < sections.length; i ++ ) {
-
-					const val = sections[ i ];
-					const isUUID = val.length == 36;
-					if ( isUUID ) {
-
-						// access by UUID
-						currentTarget = node.getObjectByProperty( 'uuid', val );
-
-					} else if ( currentTarget && currentTarget[ val ] ) {
-
-						// access by index
-						const index = Number.parseInt( val );
-						let key = val;
-						if ( index >= 0 ) key = index;
-						currentTarget = currentTarget[ key ];
-						if ( _animationPointerDebug )
-							console.log( currentTarget );
-
-					} else {
-
-						// access by node name
-						const foundNode = node.getObjectByName( val );
-						if ( foundNode )
-							currentTarget = foundNode;
-
-					}
-
-				}
-
-				if ( ! currentTarget ) {
-
-					const originalFindResult = find( node, sections[ 2 ] );
-
-					if ( ! originalFindResult )
-						console.warn( EXTENSIONS.KHR_ANIMATION_POINTER + ': Property binding not found', path, node, node.name, sections );
-
-					return originalFindResult;
-
-				}
-
-				if ( _animationPointerDebug )
-					console.log( 'NODE', path, currentTarget );
-
-				return currentTarget;
-
-			}
-
-			return find( node, path );
-
-		};
-
-	}
-
-	loadAnimationTargetFromChannel( animationChannel ) {
-
-		if ( ! this._havePatchedPropertyBindings )
-			this._patchPropertyBindingFindNode();
-
-		const target = animationChannel.target;
-		const useExtension = target.extensions && target.extensions[ EXTENSIONS.KHR_ANIMATION_POINTER ] && target.path && target.path === 'pointer';
-		if ( ! useExtension ) return null;
-
-		let targetProperty = undefined;
-
-		// check if this is a extension animation
-		let type = this.ANIMATION_TARGET_TYPE.node;
-		let targetId = undefined;
-
-		if ( useExtension ) {
-
-			const ext = target.extensions[ EXTENSIONS.KHR_ANIMATION_POINTER ];
-			let path = ext.pointer;
-			if ( this._animationPointerDebug )
-				console.log( 'Original path: ' + path, target );
-
-			if ( ! path ) {
-
-				console.warn( 'Invalid path', ext, target );
-				return;
-
-			}
-
-			if ( path.startsWith( '/materials/' ) )
-				type = this.ANIMATION_TARGET_TYPE.material;
-			else if ( path.startsWith( '/extensions/KHR_lights_punctual/lights/' ) )
-				type = this.ANIMATION_TARGET_TYPE.light;
-			else if ( path.startsWith( '/cameras/' ) )
-				type = this.ANIMATION_TARGET_TYPE.camera;
-
-			targetId = this._tryResolveTargetId( path, type );
-			if ( targetId === null || isNaN( targetId ) ) {
-
-				console.warn( 'Failed resolving animation node id: ' + targetId, path );
-				return;
-
-			} else {
-
-				if ( this._animationPointerDebug ) console.log( 'Resolved node ID for ' + type, targetId );
-
-			}
-
-			// TODO could be parsed better
-			switch ( type ) {
-
-				case this.ANIMATION_TARGET_TYPE.material:
-					const pathIndex = ( '/materials/' + targetId.toString() + '/' ).length;
-					const pathStart = path.substring( 0, pathIndex );
-					targetProperty = path.substring( pathIndex );
-
-					switch ( targetProperty ) {
-
-						// Core Spec PBR Properties
-						case 'pbrMetallicRoughness/baseColorFactor':
-							targetProperty = 'color';
-							break;
-						case 'pbrMetallicRoughness/roughnessFactor':
-							targetProperty = 'roughness';
-							break;
-						case 'pbrMetallicRoughness/metallicFactor':
-							targetProperty = 'metalness';
-							break;
-						case 'emissiveFactor':
-							targetProperty = 'emissive';
-							break;
-						case 'alphaCutoff':
-							targetProperty = 'alphaTest';
-							break;
-						case 'occlusionTexture/strength':
-							targetProperty = 'aoMapIntensity';
-							break;
-						case 'normalTexture/scale':
-							targetProperty = 'normalScale';
-							break;
-
-						// Core Spec + KHR_texture_transform
-						case 'pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/scale':
-							targetProperty = 'map/repeat';
-							break;
-						case 'pbrMetallicRoughness/baseColorTexture/extensions/KHR_texture_transform/offset':
-							targetProperty = 'map/offset';
-							break;
-
-						// UV transforms for anything but map doesn't seem to currently be supported in three.js
-						case 'emissiveTexture/extensions/KHR_texture_transform/scale':
-							targetProperty = 'emissiveMap/repeat';
-							break;
-						case 'emissiveTexture/extensions/KHR_texture_transform/offset':
-							targetProperty = 'emissiveMap/offset';
-							break;
-
-						// KHR_materials_emissive_strength
-						case 'extensions/KHR_materials_emissive_strength/emissiveStrength':
-							targetProperty = 'emissiveIntensity';
-							break;
-
-						// KHR_materials_transmission
-						case 'extensions/KHR_materials_transmission/transmissionFactor':
-							targetProperty = 'transmission';
-							break;
-
-						// KHR_materials_ior
-						case 'extensions/KHR_materials_ior/ior':
-							targetProperty = 'ior';
-							break;
-
-						// KHR_materials_volume
-						case 'extensions/KHR_materials_volume/thicknessFactor':
-							targetProperty = 'thickness';
-							break;
-						case 'extensions/KHR_materials_volume/attenuationColor':
-							targetProperty = 'attenuationColor';
-							break;
-						case 'extensions/KHR_materials_volume/attenuationDistance':
-							targetProperty = 'attenuationDistance';
-							break;
-
-						// KHR_materials_iridescence
-						case 'extensions/KHR_materials_iridescence/iridescenceFactor':
-							targetProperty = 'iridescence';
-							break;
-						case 'extensions/KHR_materials_iridescence/iridescenceIor':
-							targetProperty = 'iridescenceIOR';
-							break;
-						case 'extensions/KHR_materials_iridescence/iridescenceThicknessMinimum':
-							targetProperty = 'iridescenceThicknessRange[0]';
-							break;
-						case 'extensions/KHR_materials_iridescence/iridescenceThicknessMaximum':
-							targetProperty = 'iridescenceThicknessRange[1]';
-							break;
-
-						// KHR_materials_clearcoat
-						case 'extensions/KHR_materials_clearcoat/clearcoatFactor':
-							targetProperty = 'clearcoat';
-							break;
-						case 'extensions/KHR_materials_clearcoat/clearcoatRoughnessFactor':
-							targetProperty = 'clearcoatRoughness';
-							break;
-
-						// KHR_materials_sheen
-						case 'extensions/KHR_materials_sheen/sheenColorFactor':
-							targetProperty = 'sheenColor';
-							break;
-						case 'extensions/KHR_materials_sheen/sheenRoughnessFactor':
-							targetProperty = 'sheenRoughness';
-							break;
-
-						// KHR_materials_specular
-						case 'extensions/KHR_materials_specular/specularFactor':
-							targetProperty = 'specularIntensity';
-							break;
-						case 'extensions/KHR_materials_specular/specularColorFactor':
-							targetProperty = 'specularColor';
-							break;
-
-					}
-
-					path = pathStart + targetProperty;
-					if ( this._animationPointerDebug ) console.log( 'PROPERTY PATH', pathStart, targetProperty, path );
-					break;
-
-				case this.ANIMATION_TARGET_TYPE.node:
-					const pathIndexNode = ( '/nodes/' + targetId.toString() + '/' ).length;
-					const pathStartNode = path.substring( 0, pathIndexNode );
-					targetProperty = path.substring( pathIndexNode );
-
-					switch ( targetProperty ) {
-
-						case 'translation':
-							targetProperty = 'position';
-							break;
-						case 'rotation':
-							targetProperty = 'quaternion';
-							break;
-						case 'scale':
-							targetProperty = 'scale';
-							break;
-						case 'weights':
-							targetProperty = 'morphTargetInfluences';
-							break;
-
-					}
-
-					path = pathStartNode + targetProperty;
-					break;
-
-				case this.ANIMATION_TARGET_TYPE.light:
-					const pathIndexLight = ( '/extensions/KHR_lights_punctual/lights/' + targetId.toString() + '/' ).length;
-					targetProperty = path.substring( pathIndexLight );
-
-					switch ( targetProperty ) {
-
-						case 'color':
-							break;
-						case 'intensity':
-							break;
-						case 'spot/innerConeAngle':
-							// TODO would need to set .penumbra, but requires calculations on every animation change (?)
-							targetProperty = 'penumbra';
-							break;
-						case 'spot/outerConeAngle':
-							targetProperty = 'angle';
-							break;
-						case 'range':
-							targetProperty = 'distance';
-							break;
-
-					}
-
-					path = '/lights/' + targetId.toString() + '/' + targetProperty;
-					break;
-
-				case this.ANIMATION_TARGET_TYPE.camera:
-					const pathIndexCamera = ( '/cameras/' + targetId.toString() + '/' ).length;
-					const pathStartCamera = path.substring( 0, pathIndexCamera );
-					targetProperty = path.substring( pathIndexCamera );
-
-					switch ( targetProperty ) {
-
-						case 'perspective/yfov':
-							targetProperty = 'fov';
-							break;
-						case 'perspective/znear':
-						case 'orthographic/znear':
-							targetProperty = 'near';
-							break;
-						case 'perspective/zfar':
-						case 'orthographic/zfar':
-							targetProperty = 'far';
-							break;
-						case 'perspective/aspect':
-							targetProperty = 'aspect';
-							break;
-						// these two write to the same target property since three.js orthographic camera only supports 'zoom'.
-						// TODO should there be a warning for either of them? E.g. a warning for "xmag" so that "yfov" + "ymag" work by default?
-						case 'orthographic/xmag':
-							targetProperty = 'zoom';
-							break;
-						case 'orthographic/ymag':
-							targetProperty = 'zoom';
-							break;
-
-					}
-
-					path = pathStartCamera + targetProperty;
-					break;
-
-			}
-
-			const pointerResolver = this.parser.options.animationPointerResolver;
-			if ( pointerResolver && pointerResolver.resolvePath ) {
-
-				path = pointerResolver.resolvePath( path );
-
-			}
-
-			target.extensions[ EXTENSIONS.KHR_ANIMATION_POINTER ].pointer = path;
-
-		}
-
-		if ( targetId === null || isNaN( targetId ) ) {
-
-			console.warn( 'Failed resolving animation node id: ' + targetId, target );
-			return;
-
-		}
-
-		let depPromise;
-
-		if ( type === this.ANIMATION_TARGET_TYPE.node )
-			depPromise = this.parser.getDependency( 'node', targetId );
-		else if ( type === this.ANIMATION_TARGET_TYPE.material )
-			depPromise = this.parser.getDependency( 'material', targetId );
-		else if ( type === this.ANIMATION_TARGET_TYPE.light )
-			depPromise = this.parser.getDependency( 'light', targetId );
-		else if ( type === this.ANIMATION_TARGET_TYPE.camera )
-			depPromise = this.parser.getDependency( 'camera', targetId );
-		else
-			console.error( 'Unhandled type', type );
-
-		return depPromise;
-
-	}
-
-	createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target ) {
-
-		const useExtension = target.extensions && target.extensions[ EXTENSIONS.KHR_ANIMATION_POINTER ] && target.path && target.path === 'pointer';
-		if ( ! useExtension ) return null;
-
-		let animationPointerPropertyPath = target.extensions[ EXTENSIONS.KHR_ANIMATION_POINTER ].pointer;
-		if ( ! animationPointerPropertyPath ) return null;
-
-		const tracks = [];
-
-		animationPointerPropertyPath = animationPointerPropertyPath.replaceAll( '/', '.' );
-		// replace node/material/camera/light ID by UUID
-		const parts = animationPointerPropertyPath.split( '.' );
-		parts[ 2 ] = node.name ?? node.uuid;
-		animationPointerPropertyPath = parts.join( '.' );
-		if ( this._animationPointerDebug )
-			console.log( node, inputAccessor, outputAccessor, target, animationPointerPropertyPath );
-
-		let TypedKeyframeTrack;
-
-		switch ( outputAccessor.itemSize ) {
-
-			case 1:
-				TypedKeyframeTrack = NumberKeyframeTrack;
-				break;
-			case 2:
-			case 3:
-				TypedKeyframeTrack = VectorKeyframeTrack;
-				break;
-			case 4:
-
-				if ( animationPointerPropertyPath.endsWith( '.quaternion' ) )
-					TypedKeyframeTrack = QuaternionKeyframeTrack;
-				else
-					TypedKeyframeTrack = ColorKeyframeTrack;
-
-				break;
-
-		}
-
-		const interpolation = sampler.interpolation !== undefined ? INTERPOLATION[ sampler.interpolation ] : InterpolateLinear;
-
-		let outputArray = getArrayFromAccessor( outputAccessor );
-
-		// convert fov values from radians to degrees
-		if ( animationPointerPropertyPath.endsWith( '.fov' ) ) {
-
-			outputArray = outputArray.map( value => value / Math.PI * 180 );
-
-		}
-
-		const track = new TypedKeyframeTrack(
-			animationPointerPropertyPath,
-			inputAccessor.array,
-			outputArray,
-			interpolation
-		);
-
-		// Override interpolation with custom factory method.
-		if ( interpolation === 'CUBICSPLINE' ) {
-
-			createCubicSplineTrackInterpolant( track );
-
-		}
-
-		tracks.push( track );
-
-		// glTF has opacity animation as last component of baseColorFactor,
-		// so we need to split that up here and create a separate opacity track if that is animated.
-		if ( animationPointerPropertyPath && outputAccessor.itemSize === 4 &&
-			animationPointerPropertyPath.startsWith( '.materials.' ) && animationPointerPropertyPath.endsWith( '.color' ) ) {
-
-			const opacityArray = new Float32Array( outputArray.length / 4 );
-
-			for ( let j = 0, jl = outputArray.length / 4; j < jl; j += 1 ) {
-
-				opacityArray[ j ] = outputArray[ j * 4 + 3 ];
-
-			}
-
-			const opacityTrack = new TypedKeyframeTrack(
-				animationPointerPropertyPath.replace( '.color', '.opacity' ),
-				inputAccessor.array,
-				opacityArray,
-				interpolation
-			);
-
-			// Override interpolation with custom factory method.
-			if ( interpolation === 'CUBICSPLINE' ) {
-
-				createCubicSplineTrackInterpolant( track );
-
-			}
-
-			tracks.push( opacityTrack );
-
-		}
-
-		return tracks;
-
-	}
-
-
-	_tryResolveTargetId( path, type ) {
-
-		let name = '';
-		if ( type === 'node' ) {
-
-			name = path.substring( '/nodes/'.length );
-
-		} else if ( type === 'material' ) {
-
-			name = path.substring( '/materials/'.length );
-
-		} else if ( type === 'light' ) {
-
-			name = path.substring( '/extensions/KHR_lights_punctual/lights/'.length );
-
-		} else if ( type === 'camera' ) {
-
-			name = path.substring( '/cameras/'.length );
-
-		}
-
-		name = name.substring( 0, name.indexOf( '/' ) );
-		const index = Number.parseInt( name );
-		return index;
-
-	}
-
-}
-
 /**
  * Iridescence Materials Extension
  *
@@ -1502,7 +951,7 @@ class GLTFMaterialsSheenExtension {
 
 		if ( extension.sheenColorTexture !== undefined ) {
 
-			pending.push( parser.assignTexture( materialParams, 'sheenColorMap', extension.sheenColorTexture, sRGBEncoding ) );
+			pending.push( parser.assignTexture( materialParams, 'sheenColorMap', extension.sheenColorTexture, SRGBColorSpace ) );
 
 		}
 
@@ -1735,7 +1184,71 @@ class GLTFMaterialsSpecularExtension {
 
 		if ( extension.specularColorTexture !== undefined ) {
 
-			pending.push( parser.assignTexture( materialParams, 'specularColorMap', extension.specularColorTexture, sRGBEncoding ) );
+			pending.push( parser.assignTexture( materialParams, 'specularColorMap', extension.specularColorTexture, SRGBColorSpace ) );
+
+		}
+
+		return Promise.all( pending );
+
+	}
+
+}
+
+/**
+ * Materials anisotropy Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_anisotropy
+ */
+class GLTFMaterialsAnisotropyExtension {
+
+	constructor( parser ) {
+
+		this.parser = parser;
+		this.name = EXTENSIONS.KHR_MATERIALS_ANISOTROPY;
+
+	}
+
+	getMaterialType( materialIndex ) {
+
+		const parser = this.parser;
+		const materialDef = parser.json.materials[ materialIndex ];
+
+		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
+
+		return MeshPhysicalMaterial;
+
+	}
+
+	extendMaterialParams( materialIndex, materialParams ) {
+
+		const parser = this.parser;
+		const materialDef = parser.json.materials[ materialIndex ];
+
+		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
+
+			return Promise.resolve();
+
+		}
+
+		const pending = [];
+
+		const extension = materialDef.extensions[ this.name ];
+
+		if ( extension.anisotropyStrength !== undefined ) {
+
+			materialParams.anisotropy = extension.anisotropyStrength;
+
+		}
+
+		if ( extension.anisotropyRotation !== undefined ) {
+
+			materialParams.anisotropyRotation = extension.anisotropyRotation;
+
+		}
+
+		if ( extension.anisotropyTexture !== undefined ) {
+
+			pending.push( parser.assignTexture( materialParams, 'anisotropyMap', extension.anisotropyTexture ) );
 
 		}
 
@@ -1881,6 +1394,89 @@ class GLTFTextureWebPExtension {
 
 }
 
+/**
+ * AVIF Texture Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/EXT_texture_avif
+ */
+class GLTFTextureAVIFExtension {
+
+	constructor( parser ) {
+
+		this.parser = parser;
+		this.name = EXTENSIONS.EXT_TEXTURE_AVIF;
+		this.isSupported = null;
+
+	}
+
+	loadTexture( textureIndex ) {
+
+		const name = this.name;
+		const parser = this.parser;
+		const json = parser.json;
+
+		const textureDef = json.textures[ textureIndex ];
+
+		if ( ! textureDef.extensions || ! textureDef.extensions[ name ] ) {
+
+			return null;
+
+		}
+
+		const extension = textureDef.extensions[ name ];
+		const source = json.images[ extension.source ];
+
+		let loader = parser.textureLoader;
+		if ( source.uri ) {
+
+			const handler = parser.options.manager.getHandler( source.uri );
+			if ( handler !== null ) loader = handler;
+
+		}
+
+		return this.detectSupport().then( function ( isSupported ) {
+
+			if ( isSupported ) return parser.loadTextureImage( textureIndex, extension.source, loader );
+
+			if ( json.extensionsRequired && json.extensionsRequired.indexOf( name ) >= 0 ) {
+
+				throw new Error( 'THREE.GLTFLoader: AVIF required by asset but unsupported.' );
+
+			}
+
+			// Fall back to PNG or JPEG.
+			return parser.loadTexture( textureIndex );
+
+		} );
+
+	}
+
+	detectSupport() {
+
+		if ( ! this.isSupported ) {
+
+			this.isSupported = new Promise( function ( resolve ) {
+
+				const image = new Image();
+
+				// Lossy test image.
+				image.src = 'data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAABcAAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAEAAAABAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQAMAAAAABNjb2xybmNseAACAAIABoAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAAB9tZGF0EgAKCBgABogQEDQgMgkQAAAAB8dSLfI=';
+				image.onload = image.onerror = function () {
+
+					resolve( image.height === 1 );
+
+				};
+
+			} );
+
+		}
+
+		return this.isSupported;
+
+	}
+
+}
+
 /**
  * meshopt BufferView Compression Extension
  *
@@ -2093,8 +1689,6 @@ class GLTFMeshGpuInstancing {
 				// Just in case
 				Object3D.prototype.copy.call( instancedMesh, mesh );
 
-				// https://github.com/mrdoob/three.js/issues/18334
-				instancedMesh.frustumCulled = false;
 				this.parser.assignFinalMaterial( instancedMesh );
 
 				instancedMeshes.push( instancedMesh );
@@ -2133,9 +1727,10 @@ class GLTFBinaryExtension {
 		this.body = null;
 
 		const headerView = new DataView( data, 0, BINARY_EXTENSION_HEADER_LENGTH );
+		const textDecoder = new TextDecoder();
 
 		this.header = {
-			magic: LoaderUtils.decodeText( new Uint8Array( data.slice( 0, 4 ) ) ),
+			magic: textDecoder.decode( new Uint8Array( data.slice( 0, 4 ) ) ),
 			version: headerView.getUint32( 4, true ),
 			length: headerView.getUint32( 8, true )
 		};
@@ -2165,7 +1760,7 @@ class GLTFBinaryExtension {
 			if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON ) {
 
 				const contentArray = new Uint8Array( data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength );
-				this.content = LoaderUtils.decodeText( contentArray );
+				this.content = textDecoder.decode( contentArray );
 
 			} else if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN ) {
 
@@ -2288,13 +1883,10 @@ class GLTFTextureTransformExtension {
 
 	extendTexture( texture, transform ) {
 
-		if ( transform.texCoord !== undefined ) {
-
-			console.warn( 'THREE.GLTFLoader: Custom UV sets in "' + this.name + '" extension not yet supported.' );
-
-		}
-
-		if ( transform.offset === undefined && transform.rotation === undefined && transform.scale === undefined ) {
+		if ( ( transform.texCoord === undefined || transform.texCoord === texture.channel )
+			&& transform.offset === undefined
+			&& transform.rotation === undefined
+			&& transform.scale === undefined ) {
 
 			// See https://github.com/mrdoob/three.js/issues/21819.
 			return texture;
@@ -2303,6 +1895,12 @@ class GLTFTextureTransformExtension {
 
 		texture = texture.clone();
 
+		if ( transform.texCoord !== undefined ) {
+
+			texture.channel = transform.texCoord;
+
+		}
+
 		if ( transform.offset !== undefined ) {
 
 			texture.offset.fromArray( transform.offset );
@@ -2504,7 +2102,9 @@ const ATTRIBUTES = {
 	NORMAL: 'normal',
 	TANGENT: 'tangent',
 	TEXCOORD_0: 'uv',
-	TEXCOORD_1: 'uv2',
+	TEXCOORD_1: 'uv1',
+	TEXCOORD_2: 'uv2',
+	TEXCOORD_3: 'uv3',
 	COLOR_0: 'color',
 	WEIGHTS_0: 'skinWeight',
 	JOINTS_0: 'skinIndex',
@@ -2726,18 +2326,29 @@ function updateMorphTargets( mesh, meshDef ) {
 
 function createPrimitiveKey( primitiveDef ) {
 
-	const dracoExtension = primitiveDef.extensions && primitiveDef.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ];
 	let geometryKey;
 
+	const dracoExtension = primitiveDef.extensions && primitiveDef.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ];
+
 	if ( dracoExtension ) {
 
 		geometryKey = 'draco:' + dracoExtension.bufferView
 				+ ':' + dracoExtension.indices
 				+ ':' + createAttributesKey( dracoExtension.attributes );
 
-	} else {
+	} else {
+
+		geometryKey = primitiveDef.indices + ':' + createAttributesKey( primitiveDef.attributes ) + ':' + primitiveDef.mode;
+
+	}
+
+	if ( primitiveDef.targets !== undefined ) {
 
-		geometryKey = primitiveDef.indices + ':' + createAttributesKey( primitiveDef.attributes ) + ':' + primitiveDef.mode;
+		for ( let i = 0, il = primitiveDef.targets.length; i < il; i ++ ) {
+
+			geometryKey += ':' + createAttributesKey( primitiveDef.targets[ i ] );
+
+		}
 
 	}
 
@@ -2787,48 +2398,6 @@ function getNormalizedComponentScale( constructor ) {
 
 }
 
-function getArrayFromAccessor( accessor ) {
-
-	let outputArray = accessor.array;
-
-	if ( accessor.normalized ) {
-
-		const scale = getNormalizedComponentScale( outputArray.constructor );
-		const scaled = new Float32Array( outputArray.length );
-
-		for ( let j = 0, jl = outputArray.length; j < jl; j ++ ) {
-
-			scaled[ j ] = outputArray[ j ] * scale;
-
-		}
-
-		outputArray = scaled;
-
-	}
-
-	return outputArray;
-
-}
-
-function createCubicSplineTrackInterpolant( track ) {
-
-	track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline( result ) {
-
-		// A CUBICSPLINE keyframe in glTF has three output values for each input value,
-		// representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize()
-		// must be divided by three to get the interpolant's sampleSize argument.
-
-		const interpolantType = ( this instanceof QuaternionKeyframeTrack ) ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant;
-
-		return new interpolantType( this.times, this.values, this.getValueSize() / 3, result );
-
-	};
-
-	// Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants.
-	track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
-
-}
-
 function getImageURIMimeType( uri ) {
 
 	if ( uri.search( /\.jpe?g($|\?)/i ) > 0 || uri.search( /^data\:image\/jpeg/ ) === 0 ) return 'image/jpeg';
@@ -2838,6 +2407,8 @@ function getImageURIMimeType( uri ) {
 
 }
 
+const _identityMatrix = new Matrix4();
+
 /* GLTF PARSER */
 
 class GLTFParser {
@@ -2858,6 +2429,9 @@ class GLTFParser {
 		// BufferGeometry caching
 		this.primitiveCache = {};
 
+		// Node cache
+		this.nodeCache = {};
+
 		// Object3D instance caches
 		this.meshCache = { refs: {}, uses: {} };
 		this.cameraCache = { refs: {}, uses: {} };
@@ -2928,6 +2502,7 @@ class GLTFParser {
 
 		// Clear the loader cache
 		this.cache.removeAll();
+		this.nodeCache = {};
 
 		// Mark the special nodes/meshes in json for efficient parse
 		this._invokeAll( function ( ext ) {
@@ -3147,7 +2722,11 @@ class GLTFParser {
 					break;
 
 				case 'node':
-					dependency = this.loadNode( index );
+					dependency = this._invokeOne( function ( ext ) {
+
+						return ext.loadNode && ext.loadNode( index );
+
+					} );
 					break;
 
 				case 'mesh':
@@ -3206,14 +2785,6 @@ class GLTFParser {
 					dependency = this.loadCamera( index );
 					break;
 
-				case 'light':
-					dependency = this._invokeOne( function ( ext ) {
-
-						return ext._loadLight && ext._loadLight( index );
-
-					} );
-					break;
-
 				default:
 					dependency = this._invokeOne( function ( ext ) {
 
@@ -3460,7 +3031,7 @@ class GLTFParser {
 	/**
 	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
 	 * @param {number} textureIndex
-	 * @return {Promise<THREE.Texture>}
+	 * @return {Promise<THREE.Texture|null>}
 	 */
 	loadTexture( textureIndex ) {
 
@@ -3506,6 +3077,12 @@ class GLTFParser {
 
 			texture.name = textureDef.name || sourceDef.name || '';
 
+			if ( texture.name === '' && typeof sourceDef.uri === 'string' && sourceDef.uri.startsWith( 'data:image/' ) === false ) {
+
+				texture.name = sourceDef.uri;
+
+			}
+
 			const samplers = json.samplers || {};
 			const sampler = samplers[ textureDef.sampler ] || {};
 
@@ -3625,17 +3202,18 @@ class GLTFParser {
 	 * @param {Object} mapDef
 	 * @return {Promise<Texture>}
 	 */
-	assignTexture( materialParams, mapName, mapDef, encoding ) {
+	assignTexture( materialParams, mapName, mapDef, colorSpace ) {
 
 		const parser = this;
 
 		return this.getDependency( 'texture', mapDef.index ).then( function ( texture ) {
 
-			// Materials sample aoMap from UV set 1 and other maps from UV set 0 - this can't be configured
-			// However, we will copy UV set 0 to UV set 1 on demand for aoMap
-			if ( mapDef.texCoord !== undefined && mapDef.texCoord != 0 && ! ( mapName === 'aoMap' && mapDef.texCoord == 1 ) ) {
+			if ( ! texture ) return null;
+
+			if ( mapDef.texCoord !== undefined && mapDef.texCoord > 0 ) {
 
-				console.warn( 'THREE.GLTFLoader: Custom UV set ' + mapDef.texCoord + ' for texture ' + mapName + ' not yet supported.' );
+				texture = texture.clone();
+				texture.channel = mapDef.texCoord;
 
 			}
 
@@ -3653,9 +3231,9 @@ class GLTFParser {
 
 			}
 
-			if ( encoding !== undefined && texture ) {
+			if ( colorSpace !== undefined ) {
 
-				texture.encoding = encoding;
+				texture.colorSpace = colorSpace;
 
 			}
 
@@ -3715,6 +3293,7 @@ class GLTFParser {
 				lineMaterial = new LineBasicMaterial();
 				Material.prototype.copy.call( lineMaterial, material );
 				lineMaterial.color.copy( material.color );
+				lineMaterial.map = material.map;
 
 				this.cache.add( cacheKey, lineMaterial );
 
@@ -3760,14 +3339,6 @@ class GLTFParser {
 
 		}
 
-		// workarounds for mesh and geometry
-
-		if ( material.aoMap && geometry.attributes.uv2 === undefined && geometry.attributes.uv !== undefined ) {
-
-			geometry.setAttribute( 'uv2', geometry.attributes.uv );
-
-		}
-
 		mesh.material = material;
 
 	}
@@ -3823,7 +3394,7 @@ class GLTFParser {
 
 			if ( metallicRoughness.baseColorTexture !== undefined ) {
 
-				pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, sRGBEncoding ) );
+				pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) );
 
 			}
 
@@ -3914,7 +3485,7 @@ class GLTFParser {
 
 		if ( materialDef.emissiveTexture !== undefined && materialType !== MeshBasicMaterial ) {
 
-			pending.push( parser.assignTexture( materialParams, 'emissiveMap', materialDef.emissiveTexture, sRGBEncoding ) );
+			pending.push( parser.assignTexture( materialParams, 'emissiveMap', materialDef.emissiveTexture, SRGBColorSpace ) );
 
 		}
 
@@ -3941,17 +3512,17 @@ class GLTFParser {
 
 		const sanitizedName = PropertyBinding.sanitizeNodeName( originalName || '' );
 
-		let name = sanitizedName;
+		if ( sanitizedName in this.nodeNamesUsed ) {
 
-		for ( let i = 1; this.nodeNamesUsed[ name ]; ++ i ) {
+			return sanitizedName + '_' + ( ++ this.nodeNamesUsed[ sanitizedName ] );
 
-			name = sanitizedName + '_' + i;
+		} else {
 
-		}
+			this.nodeNamesUsed[ sanitizedName ] = 0;
 
-		this.nodeNamesUsed[ name ] = true;
+			return sanitizedName;
 
-		return name;
+		}
 
 	}
 
@@ -4081,10 +3652,9 @@ class GLTFParser {
 						? new SkinnedMesh( geometry, material )
 						: new Mesh( geometry, material );
 
-					if ( mesh.isSkinnedMesh === true && ! mesh.geometry.attributes.skinWeight.normalized ) {
+					if ( mesh.isSkinnedMesh === true ) {
 
-						// we normalize floating point skin weight array to fix malformed assets (see #15319)
-						// it's important to skip this for non-float32 data since normalizeSkinWeights assumes non-normalized inputs
+						// normalize skin weights to fix malformed assets (see #15319)
 						mesh.normalizeSkinWeights();
 
 					}
@@ -4150,12 +3720,16 @@ class GLTFParser {
 
 			if ( meshes.length === 1 ) {
 
+				if ( meshDef.extensions ) addUnknownExtensionsToUserData( extensions, meshes[ 0 ], meshDef );
+
 				return meshes[ 0 ];
 
 			}
 
 			const group = new Group();
 
+			if ( meshDef.extensions ) addUnknownExtensionsToUserData( extensions, group, meshDef );
+
 			parser.associations.set( group, { meshes: meshIndex } );
 
 			for ( let i = 0, il = meshes.length; i < il; i ++ ) {
@@ -4209,25 +3783,68 @@ class GLTFParser {
 	/**
 	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
 	 * @param {number} skinIndex
-	 * @return {Promise<Object>}
+	 * @return {Promise<Skeleton>}
 	 */
 	loadSkin( skinIndex ) {
 
 		const skinDef = this.json.skins[ skinIndex ];
 
-		const skinEntry = { joints: skinDef.joints };
+		const pending = [];
+
+		for ( let i = 0, il = skinDef.joints.length; i < il; i ++ ) {
+
+			pending.push( this._loadNodeShallow( skinDef.joints[ i ] ) );
+
+		}
+
+		if ( skinDef.inverseBindMatrices !== undefined ) {
 
-		if ( skinDef.inverseBindMatrices === undefined ) {
+			pending.push( this.getDependency( 'accessor', skinDef.inverseBindMatrices ) );
+
+		} else {
 
-			return Promise.resolve( skinEntry );
+			pending.push( null );
 
 		}
 
-		return this.getDependency( 'accessor', skinDef.inverseBindMatrices ).then( function ( accessor ) {
+		return Promise.all( pending ).then( function ( results ) {
+
+			const inverseBindMatrices = results.pop();
+			const jointNodes = results;
+
+			// Note that bones (joint nodes) may or may not be in the
+			// scene graph at this time.
+
+			const bones = [];
+			const boneInverses = [];
+
+			for ( let i = 0, il = jointNodes.length; i < il; i ++ ) {
+
+				const jointNode = jointNodes[ i ];
+
+				if ( jointNode ) {
+
+					bones.push( jointNode );
+
+					const mat = new Matrix4();
+
+					if ( inverseBindMatrices !== null ) {
+
+						mat.fromArray( inverseBindMatrices.array, i * 16 );
+
+					}
+
+					boneInverses.push( mat );
+
+				} else {
 
-			skinEntry.inverseBindMatrices = accessor;
+					console.warn( 'THREE.GLTFLoader: Joint "%s" could not be found.', skinDef.joints[ i ] );
 
-			return skinEntry;
+				}
+
+			}
+
+			return new Skeleton( bones, boneInverses );
 
 		} );
 
@@ -4244,6 +3861,7 @@ class GLTFParser {
 		const parser = this;
 
 		const animationDef = json.animations[ animationIndex ];
+		const animationName = animationDef.name ? animationDef.name : 'animation_' + animationIndex;
 
 		const pendingNodes = [];
 		const pendingInputAccessors = [];
@@ -4257,16 +3875,13 @@ class GLTFParser {
 			const channel = animationDef.channels[ i ];
 			const sampler = animationDef.samplers[ channel.sampler ];
 			const target = channel.target;
+			const name = target.node;
 			const input = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.input ] : sampler.input;
 			const output = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.output ] : sampler.output;
 
-			const nodeDependency = parser._invokeOne( function ( ext ) {
+			if ( target.node === undefined ) continue;
 
-				return ext.loadAnimationTargetFromChannel && ext.loadAnimationTargetFromChannel( channel );
-
-			} );
-
-			pendingNodes.push( nodeDependency );
+			pendingNodes.push( this.getDependency( 'node', name ) );
 			pendingInputAccessors.push( this.getDependency( 'accessor', input ) );
 			pendingOutputAccessors.push( this.getDependency( 'accessor', output ) );
 			pendingSamplers.push( sampler );
@@ -4309,11 +3924,7 @@ class GLTFParser {
 
 				}
 
-				const createdTracks = parser._invokeOne( function ( ext ) {
-
-					return ext.createAnimationTracks && ext.createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target );
-
-				} );
+				const createdTracks = parser._createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target );
 
 				if ( createdTracks ) {
 
@@ -4327,9 +3938,7 @@ class GLTFParser {
 
 			}
 
-			const name = animationDef.name ? animationDef.name : 'animation_' + animationIndex;
-
-			return new AnimationClip( name, undefined, tracks );
+			return new AnimationClip( animationName, undefined, tracks );
 
 		} );
 
@@ -4378,53 +3987,118 @@ class GLTFParser {
 	loadNode( nodeIndex ) {
 
 		const json = this.json;
-		const extensions = this.extensions;
 		const parser = this;
 
 		const nodeDef = json.nodes[ nodeIndex ];
 
-		// reserve node's name before its dependencies, so the root has the intended name.
-		const nodeName = nodeDef.name ? parser.createUniqueName( nodeDef.name ) : '';
+		const nodePending = parser._loadNodeShallow( nodeIndex );
 
-		return ( function () {
+		const childPending = [];
+		const childrenDef = nodeDef.children || [];
 
-			const pending = [];
+		for ( let i = 0, il = childrenDef.length; i < il; i ++ ) {
 
-			const meshPromise = parser._invokeOne( function ( ext ) {
+			childPending.push( parser.getDependency( 'node', childrenDef[ i ] ) );
 
-				return ext.createNodeMesh && ext.createNodeMesh( nodeIndex );
+		}
 
-			} );
+		const skeletonPending = nodeDef.skin === undefined
+			? Promise.resolve( null )
+			: parser.getDependency( 'skin', nodeDef.skin );
 
-			if ( meshPromise ) {
+		return Promise.all( [
+			nodePending,
+			Promise.all( childPending ),
+			skeletonPending
+		] ).then( function ( results ) {
 
-				pending.push( meshPromise );
+			const node = results[ 0 ];
+			const children = results[ 1 ];
+			const skeleton = results[ 2 ];
 
-			}
+			if ( skeleton !== null ) {
 
-			if ( nodeDef.camera !== undefined ) {
+				// This full traverse should be fine because
+				// child glTF nodes have not been added to this node yet.
+				node.traverse( function ( mesh ) {
 
-				pending.push( parser.getDependency( 'camera', nodeDef.camera ).then( function ( camera ) {
+					if ( ! mesh.isSkinnedMesh ) return;
 
-					return parser._getNodeRef( parser.cameraCache, nodeDef.camera, camera );
+					mesh.bind( skeleton, _identityMatrix );
 
-				} ) );
+				} );
 
 			}
 
-			parser._invokeAll( function ( ext ) {
+			for ( let i = 0, il = children.length; i < il; i ++ ) {
 
-				return ext.createNodeAttachment && ext.createNodeAttachment( nodeIndex );
+				node.add( children[ i ] );
 
-			} ).forEach( function ( promise ) {
+			}
 
-				pending.push( promise );
+			return node;
 
-			} );
+		} );
+
+	}
+
+	// ._loadNodeShallow() parses a single node.
+	// skin and child nodes are created and added in .loadNode() (no '_' prefix).
+	_loadNodeShallow( nodeIndex ) {
+
+		const json = this.json;
+		const extensions = this.extensions;
+		const parser = this;
+
+		// This method is called from .loadNode() and .loadSkin().
+		// Cache a node to avoid duplication.
+
+		if ( this.nodeCache[ nodeIndex ] !== undefined ) {
+
+			return this.nodeCache[ nodeIndex ];
+
+		}
+
+		const nodeDef = json.nodes[ nodeIndex ];
+
+		// reserve node's name before its dependencies, so the root has the intended name.
+		const nodeName = nodeDef.name ? parser.createUniqueName( nodeDef.name ) : '';
+
+		const pending = [];
+
+		const meshPromise = parser._invokeOne( function ( ext ) {
+
+			return ext.createNodeMesh && ext.createNodeMesh( nodeIndex );
+
+		} );
 
-			return Promise.all( pending );
+		if ( meshPromise ) {
 
-		}() ).then( function ( objects ) {
+			pending.push( meshPromise );
+
+		}
+
+		if ( nodeDef.camera !== undefined ) {
+
+			pending.push( parser.getDependency( 'camera', nodeDef.camera ).then( function ( camera ) {
+
+				return parser._getNodeRef( parser.cameraCache, nodeDef.camera, camera );
+
+			} ) );
+
+		}
+
+		parser._invokeAll( function ( ext ) {
+
+			return ext.createNodeAttachment && ext.createNodeAttachment( nodeIndex );
+
+		} ).forEach( function ( promise ) {
+
+			pending.push( promise );
+
+		} );
+
+		this.nodeCache[ nodeIndex ] = Promise.all( pending ).then( function ( objects ) {
 
 			let node;
 
@@ -4508,6 +4182,8 @@ class GLTFParser {
 
 		} );
 
+		return this.nodeCache[ nodeIndex ];
+
 	}
 
 	/**
@@ -4517,7 +4193,6 @@ class GLTFParser {
 	 */
 	loadScene( sceneIndex ) {
 
-		const json = this.json;
 		const extensions = this.extensions;
 		const sceneDef = this.json.scenes[ sceneIndex ];
 		const parser = this;
@@ -4537,11 +4212,17 @@ class GLTFParser {
 
 		for ( let i = 0, il = nodeIds.length; i < il; i ++ ) {
 
-			pending.push( buildNodeHierarchy( nodeIds[ i ], scene, json, parser ) );
+			pending.push( parser.getDependency( 'node', nodeIds[ i ] ) );
 
 		}
 
-		return Promise.all( pending ).then( function () {
+		return Promise.all( pending ).then( function ( nodes ) {
+
+			for ( let i = 0, il = nodes.length; i < il; i ++ ) {
+
+				scene.add( nodes[ i ] );
+
+			}
 
 			// Removes dangling associations, associations that reference a node that
 			// didn't make it into the scene.
@@ -4583,15 +4264,7 @@ class GLTFParser {
 
 	}
 
-	loadAnimationTargetFromChannel( animationChannel ) {
-
-		const target = animationChannel.target;
-		const name = target.node !== undefined ? target.node : target.id; // NOTE: target.id is deprecated.
-		return this.getDependency( 'node', name );
-
-	}
-
-	createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target ) {
+	_createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target ) {
 
 		const tracks = [];
 
@@ -4643,9 +4316,6 @@ class GLTFParser {
 					case 3:
 						TypedKeyframeTrack = VectorKeyframeTrack;
 						break;
-					case 4:
-						TypedKeyframeTrack = ColorKeyframeTrack;
-						break;
 
 				}
 
@@ -4655,7 +4325,7 @@ class GLTFParser {
 
 		const interpolation = sampler.interpolation !== undefined ? INTERPOLATION[ sampler.interpolation ] : InterpolateLinear;
 
-		const outputArray = getArrayFromAccessor( outputAccessor );
+		const outputArray = this._getArrayFromAccessor( outputAccessor );
 
 		for ( let j = 0, jl = targetNames.length; j < jl; j ++ ) {
 
@@ -4669,7 +4339,7 @@ class GLTFParser {
 			// Override interpolation with custom factory method.
 			if ( interpolation === 'CUBICSPLINE' ) {
 
-				createCubicSplineTrackInterpolant( track );
+				this._createCubicSplineTrackInterpolant( track );
 
 			}
 
@@ -4681,101 +4351,47 @@ class GLTFParser {
 
 	}
 
-}
-
-function buildNodeHierarchy( nodeId, parentObject, json, parser ) {
-
-	const nodeDef = json.nodes[ nodeId ];
-
-	return parser.getDependency( 'node', nodeId ).then( function ( node ) {
+	_getArrayFromAccessor( accessor ) {
 
-		if ( nodeDef.skin === undefined ) return node;
+		let outputArray = accessor.array;
 
-		// build skeleton here as well
+		if ( accessor.normalized ) {
 
-		let skinEntry;
+			const scale = getNormalizedComponentScale( outputArray.constructor );
+			const scaled = new Float32Array( outputArray.length );
 
-		return parser.getDependency( 'skin', nodeDef.skin ).then( function ( skin ) {
+			for ( let j = 0, jl = outputArray.length; j < jl; j ++ ) {
 
-			skinEntry = skin;
-
-			const pendingJoints = [];
-
-			for ( let i = 0, il = skinEntry.joints.length; i < il; i ++ ) {
-
-				pendingJoints.push( parser.getDependency( 'node', skinEntry.joints[ i ] ) );
+				scaled[ j ] = outputArray[ j ] * scale;
 
 			}
 
-			return Promise.all( pendingJoints );
-
-		} ).then( function ( jointNodes ) {
-
-			node.traverse( function ( mesh ) {
-
-				if ( ! mesh.isMesh ) return;
-
-				const bones = [];
-				const boneInverses = [];
-
-				for ( let j = 0, jl = jointNodes.length; j < jl; j ++ ) {
-
-					const jointNode = jointNodes[ j ];
-
-					if ( jointNode ) {
-
-						bones.push( jointNode );
-
-						const mat = new Matrix4();
-
-						if ( skinEntry.inverseBindMatrices !== undefined ) {
-
-							mat.fromArray( skinEntry.inverseBindMatrices.array, j * 16 );
-
-						}
-
-						boneInverses.push( mat );
-
-					} else {
-
-						console.warn( 'THREE.GLTFLoader: Joint "%s" could not be found.', skinEntry.joints[ j ] );
-
-					}
-
-				}
-
-				mesh.bind( new Skeleton( bones, boneInverses ), mesh.matrixWorld );
+			outputArray = scaled;
 
-			} );
-
-			return node;
-
-		} );
-
-	} ).then( function ( node ) {
-
-		// build node hierachy
+		}
 
-		parentObject.add( node );
+		return outputArray;
 
-		const pending = [];
+	}
 
-		if ( nodeDef.children ) {
+	_createCubicSplineTrackInterpolant( track ) {
 
-			const children = nodeDef.children;
+		track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline( result ) {
 
-			for ( let i = 0, il = children.length; i < il; i ++ ) {
+			// A CUBICSPLINE keyframe in glTF has three output values for each input value,
+			// representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize()
+			// must be divided by three to get the interpolant's sampleSize argument.
 
-				const child = children[ i ];
-				pending.push( buildNodeHierarchy( child, node, json, parser ) );
+			const interpolantType = ( this instanceof QuaternionKeyframeTrack ) ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant;
 
-			}
+			return new interpolantType( this.times, this.values, this.getValueSize() / 3, result );
 
-		}
+		};
 
-		return Promise.all( pending );
+		// Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants.
+		track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
 
-	} );
+	}
 
 }
 
@@ -4954,98 +4570,4 @@ function addPrimitiveAttributes( geometry, primitiveDef, parser ) {
 
 }
 
-/**
- * @param {BufferGeometry} geometry
- * @param {Number} drawMode
- * @return {BufferGeometry}
- */
-function toTrianglesDrawMode( geometry, drawMode ) {
-
-	let index = geometry.getIndex();
-
-	// generate index if not present
-
-	if ( index === null ) {
-
-		const indices = [];
-
-		const position = geometry.getAttribute( 'position' );
-
-		if ( position !== undefined ) {
-
-			for ( let i = 0; i < position.count; i ++ ) {
-
-				indices.push( i );
-
-			}
-
-			geometry.setIndex( indices );
-			index = geometry.getIndex();
-
-		} else {
-
-			console.error( 'THREE.GLTFLoader.toTrianglesDrawMode(): Undefined position attribute. Processing not possible.' );
-			return geometry;
-
-		}
-
-	}
-
-	//
-
-	const numberOfTriangles = index.count - 2;
-	const newIndices = [];
-
-	if ( drawMode === TriangleFanDrawMode ) {
-
-		// gl.TRIANGLE_FAN
-
-		for ( let i = 1; i <= numberOfTriangles; i ++ ) {
-
-			newIndices.push( index.getX( 0 ) );
-			newIndices.push( index.getX( i ) );
-			newIndices.push( index.getX( i + 1 ) );
-
-		}
-
-	} else {
-
-		// gl.TRIANGLE_STRIP
-
-		for ( let i = 0; i < numberOfTriangles; i ++ ) {
-
-			if ( i % 2 === 0 ) {
-
-				newIndices.push( index.getX( i ) );
-				newIndices.push( index.getX( i + 1 ) );
-				newIndices.push( index.getX( i + 2 ) );
-
-
-			} else {
-
-				newIndices.push( index.getX( i + 2 ) );
-				newIndices.push( index.getX( i + 1 ) );
-				newIndices.push( index.getX( i ) );
-
-			}
-
-		}
-
-	}
-
-	if ( ( newIndices.length / 3 ) !== numberOfTriangles ) {
-
-		console.error( 'THREE.GLTFLoader.toTrianglesDrawMode(): Unable to generate correct amount of triangles.' );
-
-	}
-
-	// build final geometry
-
-	const newGeometry = geometry.clone();
-	newGeometry.setIndex( newIndices );
-
-	return newGeometry;
-
-}
-
 export { GLTFLoader };