📄 `GLTFLoader.js`¶

📊 Analysis Summary¶

Metric	Count
🔧 Functions	103
🧱 Classes	26
📦 Imports	66
📊 Variables & Constants	426
⚡ Async/Await Patterns	4

📚 Table of Contents¶

Imports
Variables & Constants
Async/Await Patterns
Functions
Classes

🛠️ File Location:¶

📂 examples/jsm/loaders/GLTFLoader.js

📦 Imports¶

Name	Source
`AnimationClip`	`three`
`Bone`	`three`
`Box3`	`three`
`BufferAttribute`	`three`
`BufferGeometry`	`three`
`ClampToEdgeWrapping`	`three`
`Color`	`three`
`ColorManagement`	`three`
`DirectionalLight`	`three`
`DoubleSide`	`three`
`FileLoader`	`three`
`FrontSide`	`three`
`Group`	`three`
`ImageBitmapLoader`	`three`
`InstancedMesh`	`three`
`InterleavedBuffer`	`three`
`InterleavedBufferAttribute`	`three`
`Interpolant`	`three`
`InterpolateDiscrete`	`three`
`InterpolateLinear`	`three`
`Line`	`three`
`LineBasicMaterial`	`three`
`LineLoop`	`three`
`LineSegments`	`three`
`LinearFilter`	`three`
`LinearMipmapLinearFilter`	`three`
`LinearMipmapNearestFilter`	`three`
`LinearSRGBColorSpace`	`three`
`Loader`	`three`
`LoaderUtils`	`three`
`Material`	`three`
`MathUtils`	`three`
`Matrix4`	`three`
`Mesh`	`three`
`MeshBasicMaterial`	`three`
`MeshPhysicalMaterial`	`three`
`MeshStandardMaterial`	`three`
`MirroredRepeatWrapping`	`three`
`NearestFilter`	`three`
`NearestMipmapLinearFilter`	`three`
`NearestMipmapNearestFilter`	`three`
`NumberKeyframeTrack`	`three`
`Object3D`	`three`
`OrthographicCamera`	`three`
`PerspectiveCamera`	`three`
`PointLight`	`three`
`Points`	`three`
`PointsMaterial`	`three`
`PropertyBinding`	`three`
`Quaternion`	`three`
`QuaternionKeyframeTrack`	`three`
`RepeatWrapping`	`three`
`Skeleton`	`three`
`SkinnedMesh`	`three`
`Sphere`	`three`
`SpotLight`	`three`
`Texture`	`three`
`TextureLoader`	`three`
`TriangleFanDrawMode`	`three`
`TriangleStripDrawMode`	`three`
`Vector2`	`three`
`Vector3`	`three`
`VectorKeyframeTrack`	`three`
`SRGBColorSpace`	`three`
`InstancedBufferAttribute`	`three`
`toTrianglesDrawMode`	`../utils/BufferGeometryUtils.js`

Variables & Constants¶

Name	Type	Kind	Value	Exported
`scope`	`this`	let/var	`this`	✗
`resourcePath`	`any`	let/var	`not shown`	✗
`loader`	`any`	let/var	`new FileLoader( this.manager )`	✗
`json`	`any`	let/var	`not shown`	✗
`extensions`	`{}`	let/var	`{}`	✗
`plugins`	`{}`	let/var	`{}`	✗
`textDecoder`	`TextDecoder`	let/var	`new TextDecoder()`	✗
`parser`	`GLTFParser`	let/var	`new GLTFParser( json, { path: path \\|\\| this.resourcePath \\|\\| '', crossOrigi...`	✗
`extensionName`	`any`	let/var	`json.extensionsUsed[ i ]`	✗
`extensionsRequired`	`any`	let/var	`json.extensionsRequired \\|\\| []`	✗
`scope`	`this`	let/var	`this`	✗
`objects`	`{}`	let/var	`{}`	✗
`EXTENSIONS`	`{ KHR_BINARY_GLTF: string; KHR_DRACO_...`	let/var	`{ KHR_BINARY_GLTF: 'KHR_binary_glTF', KHR_DRACO_MESH_COMPRESSION: 'KHR_draco_...`	✗
`parser`	`any`	let/var	`this.parser`	✗
`nodeDefs`	`any`	let/var	`this.parser.json.nodes \\|\\| []`	✗
`nodeDef`	`any`	let/var	`nodeDefs[ nodeIndex ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`cacheKey`	`string`	let/var	`'light:' + lightIndex`	✗
`json`	`any`	let/var	`parser.json`	✗
`extensions`	`any`	let/var	`( json.extensions && json.extensions[ this.name ] ) \\|\\| {}`	✗
`lightDefs`	`any`	let/var	`extensions.lights \\|\\| []`	✗
`lightDef`	`any`	let/var	`lightDefs[ lightIndex ]`	✗
`lightNode`	`any`	let/var	`not shown`	✗
`color`	`any`	let/var	`new Color( 0xffffff )`	✗
`range`	`any`	let/var	`lightDef.range !== undefined ? lightDef.range : 0`	✗
`self`	`this`	let/var	`this`	✗
`parser`	`any`	let/var	`this.parser`	✗
`json`	`any`	let/var	`parser.json`	✗
`nodeDef`	`any`	let/var	`json.nodes[ nodeIndex ]`	✗
`lightDef`	`any`	let/var	`( nodeDef.extensions && nodeDef.extensions[ this.name ] ) \\|\\| {}`	✗
`lightIndex`	`any`	let/var	`lightDef.light`	✗
`pending`	`any[]`	let/var	`[]`	✗
`metallicRoughness`	`any`	let/var	`materialDef.pbrMetallicRoughness`	✗
`array`	`any`	let/var	`metallicRoughness.baseColorFactor`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`emissiveStrength`	`any`	let/var	`materialDef.extensions[ this.name ].emissiveStrength`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`pending`	`any[]`	let/var	`[]`	✗
`extension`	`any`	let/var	`materialDef.extensions[ this.name ]`	✗
`scale`	`any`	let/var	`extension.clearcoatNormalTexture.scale`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`extension`	`any`	let/var	`materialDef.extensions[ this.name ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`pending`	`any[]`	let/var	`[]`	✗
`extension`	`any`	let/var	`materialDef.extensions[ this.name ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`pending`	`any[]`	let/var	`[]`	✗
`extension`	`any`	let/var	`materialDef.extensions[ this.name ]`	✗
`colorFactor`	`any`	let/var	`extension.sheenColorFactor`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`pending`	`any[]`	let/var	`[]`	✗
`extension`	`any`	let/var	`materialDef.extensions[ this.name ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`pending`	`any[]`	let/var	`[]`	✗
`extension`	`any`	let/var	`materialDef.extensions[ this.name ]`	✗
`colorArray`	`any`	let/var	`extension.attenuationColor \\|\\| [ 1, 1, 1 ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`extension`	`any`	let/var	`materialDef.extensions[ this.name ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`pending`	`any[]`	let/var	`[]`	✗
`extension`	`any`	let/var	`materialDef.extensions[ this.name ]`	✗
`colorArray`	`any`	let/var	`extension.specularColorFactor \\|\\| [ 1, 1, 1 ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`pending`	`any[]`	let/var	`[]`	✗
`extension`	`any`	let/var	`materialDef.extensions[ this.name ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`materialDef`	`any`	let/var	`parser.json.materials[ materialIndex ]`	✗
`pending`	`any[]`	let/var	`[]`	✗
`extension`	`any`	let/var	`materialDef.extensions[ this.name ]`	✗
`parser`	`any`	let/var	`this.parser`	✗
`json`	`any`	let/var	`parser.json`	✗
`textureDef`	`any`	let/var	`json.textures[ textureIndex ]`	✗
`extension`	`any`	let/var	`textureDef.extensions[ this.name ]`	✗
`loader`	`any`	let/var	`parser.options.ktx2Loader`	✗
`name`	`string`	let/var	`this.name`	✗
`parser`	`any`	let/var	`this.parser`	✗
`json`	`any`	let/var	`parser.json`	✗
`textureDef`	`any`	let/var	`json.textures[ textureIndex ]`	✗
`extension`	`any`	let/var	`textureDef.extensions[ name ]`	✗
`source`	`any`	let/var	`json.images[ extension.source ]`	✗
`loader`	`any`	let/var	`parser.textureLoader`	✗
`name`	`string`	let/var	`this.name`	✗
`parser`	`any`	let/var	`this.parser`	✗
`json`	`any`	let/var	`parser.json`	✗
`textureDef`	`any`	let/var	`json.textures[ textureIndex ]`	✗
`extension`	`any`	let/var	`textureDef.extensions[ name ]`	✗
`source`	`any`	let/var	`json.images[ extension.source ]`	✗
`loader`	`any`	let/var	`parser.textureLoader`	✗
`json`	`any`	let/var	`this.parser.json`	✗
`bufferView`	`any`	let/var	`json.bufferViews[ index ]`	✗
`extensionDef`	`any`	let/var	`bufferView.extensions[ this.name ]`	✗
`decoder`	`any`	let/var	`this.parser.options.meshoptDecoder`	✗
`byteOffset`	`any`	let/var	`extensionDef.byteOffset \\|\\| 0`	✗
`byteLength`	`any`	let/var	`extensionDef.byteLength \\|\\| 0`	✗
`count`	`any`	let/var	`extensionDef.count`	✗
`stride`	`any`	let/var	`extensionDef.byteStride`	✗
`source`	`Uint8Array<any>`	let/var	`new Uint8Array( res, byteOffset, byteLength )`	✗
`result`	`ArrayBuffer`	let/var	`new ArrayBuffer( count * stride )`	✗
`json`	`any`	let/var	`this.parser.json`	✗
`nodeDef`	`any`	let/var	`json.nodes[ nodeIndex ]`	✗
`meshDef`	`any`	let/var	`json.meshes[ nodeDef.mesh ]`	✗
`extensionDef`	`any`	let/var	`nodeDef.extensions[ this.name ]`	✗
`attributesDef`	`any`	let/var	`extensionDef.attributes`	✗
`pending`	`any[]`	let/var	`[]`	✗
`attributes`	`{}`	let/var	`{}`	✗
`meshes`	`any`	let/var	`nodeObject.isGroup ? nodeObject.children : [ nodeObject ]`	✗
`count`	`any`	let/var	`results[ 0 ].count`	✗
`instancedMeshes`	`any[]`	let/var	`[]`	✗
`m`	`any`	let/var	`new Matrix4()`	✗
`p`	`any`	let/var	`new Vector3()`	✗
`q`	`any`	let/var	`new Quaternion()`	✗
`s`	`any`	let/var	`new Vector3( 1, 1, 1 )`	✗
`instancedMesh`	`any`	let/var	`new InstancedMesh( mesh.geometry, mesh.material, count )`	✗
`attr`	`any`	let/var	`attributes[ attributeName ]`	✗
`BINARY_EXTENSION_HEADER_MAGIC`	`"glTF"`	let/var	`'glTF'`	✗
`BINARY_EXTENSION_HEADER_LENGTH`	`12`	let/var	`12`	✗
`BINARY_EXTENSION_CHUNK_TYPES`	`{ JSON: number; BIN: number; }`	let/var	`{ JSON: 0x4E4F534A, BIN: 0x004E4942 }`	✗
`headerView`	`DataView<any>`	let/var	`new DataView( data, 0, BINARY_EXTENSION_HEADER_LENGTH )`	✗
`textDecoder`	`TextDecoder`	let/var	`new TextDecoder()`	✗
`chunkContentsLength`	`number`	let/var	`this.header.length - BINARY_EXTENSION_HEADER_LENGTH`	✗
`chunkView`	`DataView<any>`	let/var	`new DataView( data, BINARY_EXTENSION_HEADER_LENGTH )`	✗
`chunkIndex`	`number`	let/var	`0`	✗
`contentArray`	`Uint8Array<any>`	let/var	`new Uint8Array( data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength )`	✗
`byteOffset`	`number`	let/var	`BINARY_EXTENSION_HEADER_LENGTH + chunkIndex`	✗
`json`	`any`	let/var	`this.json`	✗
`dracoLoader`	`any`	let/var	`this.dracoLoader`	✗
`bufferViewIndex`	`any`	let/var	`primitive.extensions[ this.name ].bufferView`	✗
`gltfAttributeMap`	`any`	let/var	`primitive.extensions[ this.name ].attributes`	✗
`threeAttributeMap`	`{}`	let/var	`{}`	✗
`attributeNormalizedMap`	`{}`	let/var	`{}`	✗
`attributeTypeMap`	`{}`	let/var	`{}`	✗
`threeAttributeName`	`any`	let/var	`ATTRIBUTES[ attributeName ] \\|\\| attributeName.toLowerCase()`	✗
`threeAttributeName`	`any`	let/var	`ATTRIBUTES[ attributeName ] \\|\\| attributeName.toLowerCase()`	✗
`accessorDef`	`any`	let/var	`json.accessors[ primitive.attributes[ attributeName ] ]`	✗
`componentType`	`any`	let/var	`WEBGL_COMPONENT_TYPES[ accessorDef.componentType ]`	✗
`attribute`	`any`	let/var	`geometry.attributes[ attributeName ]`	✗
`normalized`	`any`	let/var	`attributeNormalizedMap[ attributeName ]`	✗
`result`	`any`	let/var	`this.resultBuffer`	✗
`values`	`any`	let/var	`this.sampleValues`	✗
`valueSize`	`any`	let/var	`this.valueSize`	✗
`offset`	`any`	let/var	`index * valueSize * 3 + valueSize`	✗
`result`	`any`	let/var	`this.resultBuffer`	✗
`values`	`any`	let/var	`this.sampleValues`	✗
`stride`	`any`	let/var	`this.valueSize`	✗
`stride2`	`number`	let/var	`stride * 2`	✗
`stride3`	`number`	let/var	`stride * 3`	✗
`td`	`number`	let/var	`t1 - t0`	✗
`p`	`number`	let/var	`( t - t0 ) / td`	✗
`pp`	`number`	let/var	`p * p`	✗
`ppp`	`number`	let/var	`pp * p`	✗
`offset1`	`number`	let/var	`i1 * stride3`	✗
`offset0`	`number`	let/var	`offset1 - stride3`	✗
`s2`	`number`	let/var	`- 2 * ppp + 3 * pp`	✗
`s3`	`number`	let/var	`ppp - pp`	✗
`s0`	`number`	let/var	`1 - s2`	✗
`s1`	`number`	let/var	`s3 - pp + p`	✗
`p0`	`any`	let/var	`values[ offset0 + i + stride ]`	✗
`m0`	`number`	let/var	`values[ offset0 + i + stride2 ] * td`	✗
`p1`	`any`	let/var	`values[ offset1 + i + stride ]`	✗
`m1`	`number`	let/var	`values[ offset1 + i ] * td`	✗
`_quaternion`	`any`	let/var	`new Quaternion()`	✗
`WEBGL_CONSTANTS`	`{ FLOAT: number; FLOAT_MAT3: number; ...`	let/var	`{ FLOAT: 5126, //FLOAT_MAT2: 35674, FLOAT_MAT3: 35675, FLOAT_MAT4: 35676, FLO...`	✗
`WEBGL_COMPONENT_TYPES`	`{ 5120: Int8ArrayConstructor; 5121: U...`	let/var	`{ 5120: Int8Array, 5121: Uint8Array, 5122: Int16Array, 5123: Uint16Array, 512...`	✗
`WEBGL_FILTERS`	`{ 9728: any; 9729: any; 9984: any; 99...`	let/var	`{ 9728: NearestFilter, 9729: LinearFilter, 9984: NearestMipmapNearestFilter, ...`	✗
`WEBGL_WRAPPINGS`	`{ 33071: any; 33648: any; 10497: any; }`	let/var	`{ 33071: ClampToEdgeWrapping, 33648: MirroredRepeatWrapping, 10497: RepeatWra...`	✗
`WEBGL_TYPE_SIZES`	`{ SCALAR: number; VEC2: number; VEC3:...`	let/var	`{ 'SCALAR': 1, 'VEC2': 2, 'VEC3': 3, 'VEC4': 4, 'MAT2': 4, 'MAT3': 9, 'MAT4':...`	✗
`ATTRIBUTES`	`{ POSITION: string; NORMAL: string; T...`	let/var	`{ POSITION: 'position', NORMAL: 'normal', TANGENT: 'tangent', TEXCOORD_0: 'uv...`	✗
`PATH_PROPERTIES`	`{ scale: string; translation: string;...`	let/var	`{ scale: 'scale', translation: 'position', rotation: 'quaternion', weights: '...`	✗
`INTERPOLATION`	`{ CUBICSPLINE: any; LINEAR: any; STEP...`	let/var	`{ CUBICSPLINE: undefined, // We use a custom interpolant (GLTFCubicSplineInte...`	✗
`ALPHA_MODES`	`{ OPAQUE: string; MASK: string; BLEND...`	let/var	`{ OPAQUE: 'OPAQUE', MASK: 'MASK', BLEND: 'BLEND' }`	✗
`hasMorphPosition`	`boolean`	let/var	`false`	✗
`hasMorphNormal`	`boolean`	let/var	`false`	✗
`hasMorphColor`	`boolean`	let/var	`false`	✗
`target`	`GLTF.Target`	let/var	`targets[ i ]`	✗
`pendingPositionAccessors`	`any[]`	let/var	`[]`	✗
`pendingNormalAccessors`	`any[]`	let/var	`[]`	✗
`pendingColorAccessors`	`any[]`	let/var	`[]`	✗
`target`	`GLTF.Target`	let/var	`targets[ i ]`	✗
`pendingAccessor`	`any`	let/var	`target.POSITION !== undefined ? parser.getDependency( 'accessor', target.POSI...`	✗
`pendingAccessor`	`any`	let/var	`target.NORMAL !== undefined ? parser.getDependency( 'accessor', target.NORMAL...`	✗
`pendingAccessor`	`any`	let/var	`target.COLOR_0 !== undefined ? parser.getDependency( 'accessor', target.COLOR...`	✗
`morphPositions`	`any`	let/var	`accessors[ 0 ]`	✗
`morphNormals`	`any`	let/var	`accessors[ 1 ]`	✗
`morphColors`	`any`	let/var	`accessors[ 2 ]`	✗
`targetNames`	`any`	let/var	`meshDef.extras.targetNames`	✗
`geometryKey`	`any`	let/var	`not shown`	✗
`dracoExtension`	`any`	let/var	`primitiveDef.extensions && primitiveDef.extensions[ EXTENSIONS.KHR_DRACO_MESH...`	✗
`attributesKey`	`string`	let/var	`''`	✗
`_identityMatrix`	`any`	let/var	`new Matrix4()`	✗
`isSafari`	`boolean`	let/var	`false`	✗
`safariVersion`	`number`	let/var	`- 1`	✗
`isFirefox`	`boolean`	let/var	`false`	✗
`firefoxVersion`	`number`	let/var	`- 1`	✗
`userAgent`	`string`	let/var	`navigator.userAgent`	✗
`parser`	`this`	let/var	`this`	✗
`json`	`{}`	let/var	`this.json`	✗
`extensions`	`{}`	let/var	`this.extensions`	✗
`result`	`{ scene: any; scenes: any[]; animatio...`	let/var	`{ scene: dependencies[ 0 ][ json.scene \\|\\| 0 ], scenes: dependencies[ 0 ], a...`	✗
`nodeDefs`	`any`	let/var	`this.json.nodes \\|\\| []`	✗
`skinDefs`	`any`	let/var	`this.json.skins \\|\\| []`	✗
`meshDefs`	`any`	let/var	`this.json.meshes \\|\\| []`	✗
`joints`	`any`	let/var	`skinDefs[ skinIndex ].joints`	✗
`nodeDef`	`any`	let/var	`nodeDefs[ nodeIndex ]`	✗
`pending`	`any[]`	let/var	`[]`	✗
`cacheKey`	`string`	let/var	`type + ':' + index`	✗
`parser`	`this`	let/var	`this`	✗
`defs`	`any`	let/var	`this.json[ type + ( type === 'mesh' ? 'es' : 's' ) ] \\|\\| []`	✗
`bufferDef`	`any`	let/var	`this.json.buffers[ bufferIndex ]`	✗
`loader`	`any`	let/var	`this.fileLoader`	✗
`options`	`{}`	let/var	`this.options`	✗
`bufferViewDef`	`any`	let/var	`this.json.bufferViews[ bufferViewIndex ]`	✗
`byteLength`	`any`	let/var	`bufferViewDef.byteLength \\|\\| 0`	✗
`byteOffset`	`any`	let/var	`bufferViewDef.byteOffset \\|\\| 0`	✗
`parser`	`this`	let/var	`this`	✗
`json`	`{}`	let/var	`this.json`	✗
`accessorDef`	`any`	let/var	`this.json.accessors[ accessorIndex ]`	✗
`itemSize`	`any`	let/var	`WEBGL_TYPE_SIZES[ accessorDef.type ]`	✗
`TypedArray`	`any`	let/var	`WEBGL_COMPONENT_TYPES[ accessorDef.componentType ]`	✗
`normalized`	`boolean`	let/var	`accessorDef.normalized === true`	✗
`array`	`any`	let/var	`new TypedArray( accessorDef.count * itemSize )`	✗
`pendingBufferViews`	`any[]`	let/var	`[]`	✗
`bufferView`	`any`	let/var	`bufferViews[ 0 ]`	✗
`itemSize`	`any`	let/var	`WEBGL_TYPE_SIZES[ accessorDef.type ]`	✗
`TypedArray`	`any`	let/var	`WEBGL_COMPONENT_TYPES[ accessorDef.componentType ]`	✗
`elementBytes`	`any`	let/var	`TypedArray.BYTES_PER_ELEMENT`	✗
`itemBytes`	`number`	let/var	`elementBytes * itemSize`	✗
`byteOffset`	`any`	let/var	`accessorDef.byteOffset \\|\\| 0`	✗
`byteStride`	`any`	let/var	`accessorDef.bufferView !== undefined ? json.bufferViews[ accessorDef.bufferVi...`	✗
`normalized`	`boolean`	let/var	`accessorDef.normalized === true`	✗
`array`	`any`	let/var	`not shown`	✗
`bufferAttribute`	`any`	let/var	`not shown`	✗
`ibCacheKey`	`string`	let/var	`'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentTy...`	✗
`itemSizeIndices`	`number`	let/var	`WEBGL_TYPE_SIZES.SCALAR`	✗
`TypedArrayIndices`	`any`	let/var	`WEBGL_COMPONENT_TYPES[ accessorDef.sparse.indices.componentType ]`	✗
`byteOffsetIndices`	`any`	let/var	`accessorDef.sparse.indices.byteOffset \\|\\| 0`	✗
`byteOffsetValues`	`any`	let/var	`accessorDef.sparse.values.byteOffset \\|\\| 0`	✗
`sparseIndices`	`any`	let/var	`new TypedArrayIndices( bufferViews[ 1 ], byteOffsetIndices, accessorDef.spars...`	✗
`sparseValues`	`any`	let/var	`new TypedArray( bufferViews[ 2 ], byteOffsetValues, accessorDef.sparse.count ...`	✗
`index`	`any`	let/var	`sparseIndices[ i ]`	✗
`json`	`{}`	let/var	`this.json`	✗
`options`	`{}`	let/var	`this.options`	✗
`textureDef`	`any`	let/var	`json.textures[ textureIndex ]`	✗
`sourceIndex`	`any`	let/var	`textureDef.source`	✗
`sourceDef`	`any`	let/var	`json.images[ sourceIndex ]`	✗
`loader`	`any`	let/var	`this.textureLoader`	✗
`parser`	`this`	let/var	`this`	✗
`json`	`{}`	let/var	`this.json`	✗
`textureDef`	`any`	let/var	`json.textures[ textureIndex ]`	✗
`sourceDef`	`any`	let/var	`json.images[ sourceIndex ]`	✗
`cacheKey`	`string`	let/var	`( sourceDef.uri \\|\\| sourceDef.bufferView ) + ':' + textureDef.sampler`	✗
`samplers`	`any`	let/var	`json.samplers \\|\\| {}`	✗
`sampler`	`any`	let/var	`samplers[ textureDef.sampler ] \\|\\| {}`	✗
`parser`	`this`	let/var	`this`	✗
`json`	`{}`	let/var	`this.json`	✗
`options`	`{}`	let/var	`this.options`	✗
`sourceDef`	`any`	let/var	`json.images[ sourceIndex ]`	✗
`URL`	`{ new (url: string \\| URL, base?: str...`	let/var	`self.URL \\|\\| self.webkitURL`	✗
`sourceURI`	`any`	let/var	`sourceDef.uri \\|\\| ''`	✗
`isObjectURL`	`boolean`	let/var	`false`	✗
`blob`	`Blob`	let/var	`new Blob( [ bufferView ], { type: sourceDef.mimeType } )`	✗
`onLoad`	`(value: any) => void`	let/var	`resolve`	✗
`texture`	`any`	let/var	`new Texture( imageBitmap )`	✗
`parser`	`this`	let/var	`this`	✗
`transform`	`any`	let/var	`mapDef.extensions !== undefined ? mapDef.extensions[ EXTENSIONS.KHR_TEXTURE_T...`	✗
`geometry`	`any`	let/var	`mesh.geometry`	✗
`material`	`any`	let/var	`mesh.material`	✗
`useDerivativeTangents`	`boolean`	let/var	`geometry.attributes.tangent === undefined`	✗
`useVertexColors`	`boolean`	let/var	`geometry.attributes.color !== undefined`	✗
`useFlatShading`	`boolean`	let/var	`geometry.attributes.normal === undefined`	✗
`cacheKey`	`string`	let/var	`'PointsMaterial:' + material.uuid`	✗
`cacheKey`	`string`	let/var	`'LineBasicMaterial:' + material.uuid`	✗
`cacheKey`	`string`	let/var	`'ClonedMaterial:' + material.uuid + ':'`	✗
`parser`	`this`	let/var	`this`	✗
`json`	`{}`	let/var	`this.json`	✗
`extensions`	`{}`	let/var	`this.extensions`	✗
`materialDef`	`any`	let/var	`json.materials[ materialIndex ]`	✗
`materialType`	`any`	let/var	`not shown`	✗
`materialParams`	`{ color: any; opacity: any; metalness...`	let/var	`{}`	✗
`materialExtensions`	`any`	let/var	`materialDef.extensions \\|\\| {}`	✗
`pending`	`any[]`	let/var	`[]`	✗
`kmuExtension`	`any`	let/var	`extensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ]`	✗
`metallicRoughness`	`any`	let/var	`materialDef.pbrMetallicRoughness \\|\\| {}`	✗
`array`	`any`	let/var	`metallicRoughness.baseColorFactor`	✗
`alphaMode`	`any`	let/var	`materialDef.alphaMode \\|\\| ALPHA_MODES.OPAQUE`	✗
`scale`	`any`	let/var	`materialDef.normalTexture.scale`	✗
`emissiveFactor`	`any`	let/var	`materialDef.emissiveFactor`	✗
`material`	`any`	let/var	`new materialType( materialParams )`	✗
`parser`	`this`	let/var	`this`	✗
`extensions`	`{}`	let/var	`this.extensions`	✗
`cache`	`{}`	let/var	`this.primitiveCache`	✗
`pending`	`any[]`	let/var	`[]`	✗
`primitive`	`GLTF.Primitive`	let/var	`primitives[ i ]`	✗
`cached`	`any`	let/var	`cache[ cacheKey ]`	✗
`geometryPromise`	`any`	let/var	`not shown`	✗
`parser`	`this`	let/var	`this`	✗
`json`	`{}`	let/var	`this.json`	✗
`extensions`	`{}`	let/var	`this.extensions`	✗
`meshDef`	`any`	let/var	`json.meshes[ meshIndex ]`	✗
`primitives`	`any`	let/var	`meshDef.primitives`	✗
`pending`	`any[]`	let/var	`[]`	✗
`material`	`any`	let/var	`primitives[ i ].material === undefined ? createDefaultMaterial( this.cache ) ...`	✗
`geometries`	`any`	let/var	`results[ results.length - 1 ]`	✗
`meshes`	`any[]`	let/var	`[]`	✗
`geometry`	`any`	let/var	`geometries[ i ]`	✗
`primitive`	`any`	let/var	`primitives[ i ]`	✗
`mesh`	`any`	let/var	`not shown`	✗
`material`	`any`	let/var	`materials[ i ]`	✗
`group`	`any`	let/var	`new Group()`	✗
`camera`	`any`	let/var	`not shown`	✗
`cameraDef`	`any`	let/var	`this.json.cameras[ cameraIndex ]`	✗
`params`	`any`	let/var	`cameraDef[ cameraDef.type ]`	✗
`skinDef`	`any`	let/var	`this.json.skins[ skinIndex ]`	✗
`pending`	`any[]`	let/var	`[]`	✗
`jointNodes`	`any[]`	let/var	`results`	✗
`bones`	`any[]`	let/var	`[]`	✗
`boneInverses`	`any[]`	let/var	`[]`	✗
`jointNode`	`any`	let/var	`jointNodes[ i ]`	✗
`mat`	`any`	let/var	`new Matrix4()`	✗
`json`	`{}`	let/var	`this.json`	✗
`parser`	`this`	let/var	`this`	✗
`animationDef`	`any`	let/var	`json.animations[ animationIndex ]`	✗
`animationName`	`any`	let/var	`animationDef.name ? animationDef.name : 'animation_' + animationIndex`	✗
`pendingNodes`	`any[]`	let/var	`[]`	✗
`pendingInputAccessors`	`any[]`	let/var	`[]`	✗
`pendingOutputAccessors`	`any[]`	let/var	`[]`	✗
`pendingSamplers`	`any[]`	let/var	`[]`	✗
`pendingTargets`	`any[]`	let/var	`[]`	✗
`channel`	`any`	let/var	`animationDef.channels[ i ]`	✗
`sampler`	`any`	let/var	`animationDef.samplers[ channel.sampler ]`	✗
`target`	`any`	let/var	`channel.target`	✗
`name`	`any`	let/var	`target.node`	✗
`input`	`any`	let/var	`animationDef.parameters !== undefined ? animationDef.parameters[ sampler.inpu...`	✗
`output`	`any`	let/var	`animationDef.parameters !== undefined ? animationDef.parameters[ sampler.outp...`	✗
`nodes`	`any`	let/var	`dependencies[ 0 ]`	✗
`inputAccessors`	`any`	let/var	`dependencies[ 1 ]`	✗
`outputAccessors`	`any`	let/var	`dependencies[ 2 ]`	✗
`samplers`	`any`	let/var	`dependencies[ 3 ]`	✗
`targets`	`any`	let/var	`dependencies[ 4 ]`	✗
`tracks`	`any[]`	let/var	`[]`	✗
`node`	`any`	let/var	`nodes[ i ]`	✗
`inputAccessor`	`any`	let/var	`inputAccessors[ i ]`	✗
`outputAccessor`	`any`	let/var	`outputAccessors[ i ]`	✗
`sampler`	`any`	let/var	`samplers[ i ]`	✗
`target`	`any`	let/var	`targets[ i ]`	✗
`json`	`{}`	let/var	`this.json`	✗
`parser`	`this`	let/var	`this`	✗
`nodeDef`	`any`	let/var	`json.nodes[ nodeIndex ]`	✗
`json`	`{}`	let/var	`this.json`	✗
`parser`	`this`	let/var	`this`	✗
`nodeDef`	`any`	let/var	`json.nodes[ nodeIndex ]`	✗
`childPending`	`any[]`	let/var	`[]`	✗
`childrenDef`	`any`	let/var	`nodeDef.children \\|\\| []`	✗
`skeletonPending`	`Promise<any>`	let/var	`nodeDef.skin === undefined ? Promise.resolve( null ) : parser.getDependency( ...`	✗
`node`	`any`	let/var	`results[ 0 ]`	✗
`children`	`any`	let/var	`results[ 1 ]`	✗
`skeleton`	`any`	let/var	`results[ 2 ]`	✗
`json`	`{}`	let/var	`this.json`	✗
`extensions`	`{}`	let/var	`this.extensions`	✗
`parser`	`this`	let/var	`this`	✗
`nodeDef`	`any`	let/var	`json.nodes[ nodeIndex ]`	✗
`nodeName`	`string`	let/var	`nodeDef.name ? parser.createUniqueName( nodeDef.name ) : ''`	✗
`pending`	`any[]`	let/var	`[]`	✗
`node`	`any`	let/var	`not shown`	✗
`matrix`	`any`	let/var	`new Matrix4()`	✗
`extensions`	`{}`	let/var	`this.extensions`	✗
`sceneDef`	`any`	let/var	`this.json.scenes[ sceneIndex ]`	✗
`parser`	`this`	let/var	`this`	✗
`scene`	`any`	let/var	`new Group()`	✗
`nodeIds`	`any`	let/var	`sceneDef.nodes \\|\\| []`	✗
`pending`	`any[]`	let/var	`[]`	✗
`reducedAssociations`	`Map<any, any>`	let/var	`new Map()`	✗
`tracks`	`any[]`	let/var	`[]`	✗
`targetName`	`any`	let/var	`node.name ? node.name : node.uuid`	✗
`targetNames`	`any[]`	let/var	`[]`	✗
`TypedKeyframeTrack`	`any`	let/var	`not shown`	✗
`interpolation`	`any`	let/var	`sampler.interpolation !== undefined ? INTERPOLATION[ sampler.interpolation ] ...`	✗
`track`	`any`	let/var	`new TypedKeyframeTrack( targetNames[ j ] + '.' + PATH_PROPERTIES[ target.path...`	✗
`outputArray`	`any`	let/var	`accessor.array`	✗
`scaled`	`Float32Array<any>`	let/var	`new Float32Array( outputArray.length )`	✗
`interpolantType`	`typeof GLTFCubicSplineInterpolant`	let/var	`( this instanceof QuaternionKeyframeTrack ) ? GLTFCubicSplineQuaternionInterp...`	✗
`attributes`	`any`	let/var	`primitiveDef.attributes`	✗
`box`	`any`	let/var	`new Box3()`	✗
`accessor`	`any`	let/var	`parser.json.accessors[ attributes.POSITION ]`	✗
`min`	`any`	let/var	`accessor.min`	✗
`max`	`any`	let/var	`accessor.max`	✗
`targets`	`any`	let/var	`primitiveDef.targets`	✗
`maxDisplacement`	`any`	let/var	`new Vector3()`	✗
`vector`	`any`	let/var	`new Vector3()`	✗
`target`	`any`	let/var	`targets[ i ]`	✗
`accessor`	`any`	let/var	`parser.json.accessors[ target.POSITION ]`	✗
`min`	`any`	let/var	`accessor.min`	✗
`max`	`any`	let/var	`accessor.max`	✗
`sphere`	`any`	let/var	`new Sphere()`	✗
`attributes`	`any`	let/var	`primitiveDef.attributes`	✗
`pending`	`any[]`	let/var	`[]`	✗
`threeAttributeName`	`any`	let/var	`ATTRIBUTES[ gltfAttributeName ] \\|\\| gltfAttributeName.toLowerCase()`	✗

Async/Await Patterns¶

Type	Function	Await Expressions	Promise Chains
promise-chain	`addMorphTargets`	none	Promise.resolve, Promise.all( [
Promise.all( pendingPositionAccessors ),
Promise.all( pendingNormalAccessors ),
Promise.all( pendingColorAccessors )
] ).then, Promise.all, Promise.all, Promise.all, Promise.all
promise-chain	`createDracoPrimitive`	none	extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ]
.decodePrimitive( primitive, parser ).then
promise-chain	`addPrimitiveAttributes`	none	parser.getDependency( 'accessor', accessorIndex ).then, parser.getDependency( 'accessor', primitiveDef.indices ).then, Promise.all( pending ).then, Promise.all
promise-chain	`assignAttributeAccessor`	none	parser.getDependency( 'accessor', accessorIndex ).then

Functions¶

`GLTFLoader.load(url: string, onLoad: any, onProgress: onProgressCallback, onError: onErrorCallback): void`¶

JSDoc:

/**
     * Starts loading from the given URL and passes the loaded glTF asset
     * to the `onLoad()` callback.
     *
     * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
     * @param {function(GLTFLoader~LoadObject)} onLoad - Executed when the loading process has been finished.
     * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
     * @param {onErrorCallback} onError - Executed when errors occur.
     */

Parameters:

url string
onLoad any
onProgress onProgressCallback
onError onErrorCallback

Returns: void

Calls:

LoaderUtils.extractUrlBase
LoaderUtils.resolveURL
this.manager.itemStart
onError
console.error
scope.manager.itemError
scope.manager.itemEnd
loader.setPath
loader.setResponseType
loader.setRequestHeader
loader.setWithCredentials
loader.load
scope.parse
onLoad
_onError

Internal Comments:

// If a base path is set, resources will be relative paths from that plus the relative path of the gltf file (x2)
// Example  path = 'https://my-cnd-server.com/', url = 'assets/models/model.gltf' (x2)
// resourcePath = 'https://my-cnd-server.com/assets/models/' (x2)
// referenced resource 'model.bin' will be loaded from 'https://my-cnd-server.com/assets/models/model.bin' (x2)
// referenced resource '../textures/texture.png' will be loaded from 'https://my-cnd-server.com/assets/textures/texture.png' (x2)
// Tells the LoadingManager to track an extra item, which resolves after (x5)
// the model is fully loaded. This means the count of items loaded will (x5)
// be incorrect, but ensures manager.onLoad() does not fire early. (x5)

Code

load( url, onLoad, onProgress, onError ) {

        const scope = this;

        let resourcePath;

        if ( this.resourcePath !== '' ) {

            resourcePath = this.resourcePath;

        } else if ( this.path !== '' ) {

            // If a base path is set, resources will be relative paths from that plus the relative path of the gltf file
            // Example  path = 'https://my-cnd-server.com/', url = 'assets/models/model.gltf'
            // resourcePath = 'https://my-cnd-server.com/assets/models/'
            // referenced resource 'model.bin' will be loaded from 'https://my-cnd-server.com/assets/models/model.bin'
            // referenced resource '../textures/texture.png' will be loaded from 'https://my-cnd-server.com/assets/textures/texture.png'
            const relativeUrl = LoaderUtils.extractUrlBase( url );
            resourcePath = LoaderUtils.resolveURL( relativeUrl, this.path );

        } else {

            resourcePath = LoaderUtils.extractUrlBase( url );

        }

        // Tells the LoadingManager to track an extra item, which resolves after
        // the model is fully loaded. This means the count of items loaded will
        // be incorrect, but ensures manager.onLoad() does not fire early.
        this.manager.itemStart( url );

        const _onError = function ( e ) {

            if ( onError ) {

                onError( e );

            } else {

                console.error( e );

            }

            scope.manager.itemError( url );
            scope.manager.itemEnd( url );

        };

        const loader = new FileLoader( this.manager );

        loader.setPath( this.path );
        loader.setResponseType( 'arraybuffer' );
        loader.setRequestHeader( this.requestHeader );
        loader.setWithCredentials( this.withCredentials );

        loader.load( url, function ( data ) {

            try {

                scope.parse( data, resourcePath, function ( gltf ) {

                    onLoad( gltf );

                    scope.manager.itemEnd( url );

                }, _onError );

            } catch ( e ) {

                _onError( e );

            }

        }, onProgress, _onError );

    }

`GLTFLoader.setDRACOLoader(dracoLoader: DRACOLoader): GLTFLoader`¶

JSDoc:

/**
     * Sets the given Draco loader to this loader. Required for decoding assets
     * compressed with the `KHR_draco_mesh_compression` extension.
     *
     * @param {DRACOLoader} dracoLoader - The Draco loader to set.
     * @return {GLTFLoader} A reference to this loader.
     */

Parameters:

dracoLoader DRACOLoader

Returns: GLTFLoader

Code

setDRACOLoader( dracoLoader ) {

        this.dracoLoader = dracoLoader;
        return this;

    }

`GLTFLoader.setKTX2Loader(ktx2Loader: KTX2Loader): GLTFLoader`¶

JSDoc:

/**
     * Sets the given KTX2 loader to this loader. Required for loading KTX2
     * compressed textures.
     *
     * @param {KTX2Loader} ktx2Loader - The KTX2 loader to set.
     * @return {GLTFLoader} A reference to this loader.
     */

Parameters:

ktx2Loader KTX2Loader

Returns: GLTFLoader

Code

setKTX2Loader( ktx2Loader ) {

        this.ktx2Loader = ktx2Loader;
        return this;

    }

`GLTFLoader.setMeshoptDecoder(meshoptDecoder: any): GLTFLoader`¶

JSDoc:

/**
     * Sets the given meshopt decoder. Required for decoding assets
     * compressed with the `EXT_meshopt_compression` extension.
     *
     * @param {Object} meshoptDecoder - The meshopt decoder to set.
     * @return {GLTFLoader} A reference to this loader.
     */

Parameters:

meshoptDecoder any

Returns: GLTFLoader

Code

setMeshoptDecoder( meshoptDecoder ) {

        this.meshoptDecoder = meshoptDecoder;
        return this;

    }

`GLTFLoader.register(callback: any): GLTFLoader`¶

JSDoc:

/**
     * Registers a plugin callback. This API is internally used to implement the various
     * glTF extensions but can also used by third-party code to add additional logic
     * to the loader.
     *
     * @param {function(parser:GLTFParser)} callback - The callback function to register.
     * @return {GLTFLoader} A reference to this loader.
     */

Parameters:

callback any

Returns: GLTFLoader

Calls:

this.pluginCallbacks.indexOf
this.pluginCallbacks.push

Code

register( callback ) {

        if ( this.pluginCallbacks.indexOf( callback ) === - 1 ) {

            this.pluginCallbacks.push( callback );

        }

        return this;

    }

`GLTFLoader.unregister(callback: Function): GLTFLoader`¶

JSDoc:

/**
     * Unregisters a plugin callback.
     *
     * @param {Function} callback - The callback function to unregister.
     * @return {GLTFLoader} A reference to this loader.
     */

Parameters:

callback Function

Returns: GLTFLoader

Calls:

this.pluginCallbacks.indexOf
this.pluginCallbacks.splice

Code

unregister( callback ) {

        if ( this.pluginCallbacks.indexOf( callback ) !== - 1 ) {

            this.pluginCallbacks.splice( this.pluginCallbacks.indexOf( callback ), 1 );

        }

        return this;

    }

`GLTFLoader.parse(data: string | ArrayBuffer, path: string, onLoad: any, onError: onErrorCallback): void`¶

JSDoc:

/**
     * Parses the given FBX data and returns the resulting group.
     *
     * @param {string|ArrayBuffer} data - The raw glTF data.
     * @param {string} path - The URL base path.
     * @param {function(GLTFLoader~LoadObject)} onLoad - Executed when the loading process has been finished.
     * @param {onErrorCallback} onError - Executed when errors occur.
     */

Parameters:

data string | ArrayBuffer
path string
onLoad any
onError onErrorCallback

Returns: void

Calls:

JSON.parse
textDecoder.decode
onError
parser.fileLoader.setRequestHeader
complex_call_11206
console.error
extensionsRequired.indexOf
console.warn
parser.setExtensions
parser.setPlugins
parser.parse

Internal Comments:

// Workaround to avoid determining as unknown extension (x4)
// in addUnknownExtensionsToUserData(). (x4)
// Remove this workaround if we move all the existing (x4)
// extension handlers to plugin system (x4)

Code

parse( data, path, onLoad, onError ) {

        let json;
        const extensions = {};
        const plugins = {};
        const textDecoder = new TextDecoder();

        if ( typeof data === 'string' ) {

            json = JSON.parse( data );

        } else if ( data instanceof ArrayBuffer ) {

            const magic = textDecoder.decode( new Uint8Array( data, 0, 4 ) );

            if ( magic === BINARY_EXTENSION_HEADER_MAGIC ) {

                try {

                    extensions[ EXTENSIONS.KHR_BINARY_GLTF ] = new GLTFBinaryExtension( data );

                } catch ( error ) {

                    if ( onError ) onError( error );
                    return;

                }

                json = JSON.parse( extensions[ EXTENSIONS.KHR_BINARY_GLTF ].content );

            } else {

                json = JSON.parse( textDecoder.decode( data ) );

            }

        } else {

            json = data;

        }

        if ( json.asset === undefined || json.asset.version[ 0 ] < 2 ) {

            if ( onError ) onError( new Error( 'THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported.' ) );
            return;

        }

        const parser = new GLTFParser( json, {

            path: path || this.resourcePath || '',
            crossOrigin: this.crossOrigin,
            requestHeader: this.requestHeader,
            manager: this.manager,
            ktx2Loader: this.ktx2Loader,
            meshoptDecoder: this.meshoptDecoder

        } );

        parser.fileLoader.setRequestHeader( this.requestHeader );

        for ( let i = 0; i < this.pluginCallbacks.length; i ++ ) {

            const plugin = this.pluginCallbacks[ i ]( parser );

            if ( ! plugin.name ) console.error( 'THREE.GLTFLoader: Invalid plugin found: missing name' );

            plugins[ plugin.name ] = plugin;

            // Workaround to avoid determining as unknown extension
            // in addUnknownExtensionsToUserData().
            // Remove this workaround if we move all the existing
            // extension handlers to plugin system
            extensions[ plugin.name ] = true;

        }

        if ( json.extensionsUsed ) {

            for ( let i = 0; i < json.extensionsUsed.length; ++ i ) {

                const extensionName = json.extensionsUsed[ i ];
                const extensionsRequired = json.extensionsRequired || [];

                switch ( extensionName ) {

                    case EXTENSIONS.KHR_MATERIALS_UNLIT:
                        extensions[ extensionName ] = new GLTFMaterialsUnlitExtension();
                        break;

                    case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
                        extensions[ extensionName ] = new GLTFDracoMeshCompressionExtension( json, this.dracoLoader );
                        break;

                    case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
                        extensions[ extensionName ] = new GLTFTextureTransformExtension();
                        break;

                    case EXTENSIONS.KHR_MESH_QUANTIZATION:
                        extensions[ extensionName ] = new GLTFMeshQuantizationExtension();
                        break;

                    default:

                        if ( extensionsRequired.indexOf( extensionName ) >= 0 && plugins[ extensionName ] === undefined ) {

                            console.warn( 'THREE.GLTFLoader: Unknown extension "' + extensionName + '".' );

                        }

                }

            }

        }

        parser.setExtensions( extensions );
        parser.setPlugins( plugins );
        parser.parse( onLoad, onError );

    }

`GLTFLoader.parseAsync(data: string | ArrayBuffer, path: string): Promise<GLTFLoader>`¶

JSDoc:

/**
     * Async version of {@link GLTFLoader#parse}.
     *
     * @async
     * @param {string|ArrayBuffer} data - The raw glTF data.
     * @param {string} path - The URL base path.
     * @return {Promise<GLTFLoader~LoadObject>} A Promise that resolves with the loaded glTF when the parsing has been finished.
     */

Parameters:

data string | ArrayBuffer
path string

Returns: Promise<GLTFLoader>

Calls:

scope.parse

Code

parseAsync( data, path ) {

        const scope = this;

        return new Promise( function ( resolve, reject ) {

            scope.parse( data, path, resolve, reject );

        } );

    }

`_onError(e: any): void`¶

Parameters:

e any

Returns: void

Calls:

onError
console.error
scope.manager.itemError
scope.manager.itemEnd

Code

function ( e ) {

            if ( onError ) {

                onError( e );

            } else {

                console.error( e );

            }

            scope.manager.itemError( url );
            scope.manager.itemEnd( url );

        }

`GLTFRegistry(): { get: (key: any) => any; add: (key: any, object: any) => void; remove: (key: any) => void; removeAll: () => void; }`¶

Returns: { get: (key: any) => any; add: (key: any, object: any) => void; remove: (key: any) => void; removeAll: () => void; }

Code

function GLTFRegistry() {

    let objects = {};

    return  {

        get: function ( key ) {

            return objects[ key ];

        },

        add: function ( key, object ) {

            objects[ key ] = object;

        },

        remove: function ( key ) {

            delete objects[ key ];

        },

        removeAll: function () {

            objects = {};

        }

    };

}

`get(key: any): any`¶

Parameters:

key any

Returns: any

Code

function ( key ) {

            return objects[ key ];

        }

`add(key: any, object: any): void`¶

Parameters:

key any
object any

Returns: void

Code

function ( key, object ) {

            objects[ key ] = object;

        }

`remove(key: any): void`¶

Parameters:

key any

Returns: void

Code

function ( key ) {

            delete objects[ key ];

        }

`removeAll(): void`¶

Returns: void

Code

function () {

            objects = {};

        }

`get(key: any): any`¶

Parameters:

key any

Returns: any

Code

function ( key ) {

            return objects[ key ];

        }

`add(key: any, object: any): void`¶

Parameters:

key any
object any

Returns: void

Code

function ( key, object ) {

            objects[ key ] = object;

        }

`remove(key: any): void`¶

Parameters:

key any

Returns: void

Code

function ( key ) {

            delete objects[ key ];

        }

`removeAll(): void`¶

Returns: void

Code

function () {

            objects = {};

        }

`GLTFLightsExtension._markDefs(): void`¶

Returns: void

Calls:

parser._addNodeRef

Code

_markDefs() {

        const parser = this.parser;
        const nodeDefs = this.parser.json.nodes || [];

        for ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {

            const nodeDef = nodeDefs[ nodeIndex ];

            if ( nodeDef.extensions
                    && nodeDef.extensions[ this.name ]
                    && nodeDef.extensions[ this.name ].light !== undefined ) {

                parser._addNodeRef( this.cache, nodeDef.extensions[ this.name ].light );

            }

        }

    }

`GLTFLightsExtension._loadLight(lightIndex: any): any`¶

Parameters:

lightIndex any

Returns: any

Calls:

parser.cache.get
color.setRGB
lightNode.target.position.set
lightNode.add
lightNode.position.set
assignExtrasToUserData
parser.createUniqueName
Promise.resolve
parser.cache.add

Internal Comments:

// Handle spotlight properties. (x4)
// Some lights (e.g. spot) default to a position other than the origin. Reset the position (x5)
// here, because node-level parsing will only override position if explicitly specified. (x5)

Code

_loadLight( lightIndex ) {

        const parser = this.parser;
        const cacheKey = 'light:' + lightIndex;
        let dependency = parser.cache.get( cacheKey );

        if ( dependency ) return dependency;

        const json = parser.json;
        const extensions = ( json.extensions && json.extensions[ this.name ] ) || {};
        const lightDefs = extensions.lights || [];
        const lightDef = lightDefs[ lightIndex ];
        let lightNode;

        const color = new Color( 0xffffff );

        if ( lightDef.color !== undefined ) color.setRGB( lightDef.color[ 0 ], lightDef.color[ 1 ], lightDef.color[ 2 ], LinearSRGBColorSpace );

        const range = lightDef.range !== undefined ? lightDef.range : 0;

        switch ( lightDef.type ) {

            case 'directional':
                lightNode = new DirectionalLight( color );
                lightNode.target.position.set( 0, 0, - 1 );
                lightNode.add( lightNode.target );
                break;

            case 'point':
                lightNode = new PointLight( color );
                lightNode.distance = range;
                break;

            case 'spot':
                lightNode = new SpotLight( color );
                lightNode.distance = range;
                // Handle spotlight properties.
                lightDef.spot = lightDef.spot || {};
                lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== undefined ? lightDef.spot.innerConeAngle : 0;
                lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== undefined ? lightDef.spot.outerConeAngle : Math.PI / 4.0;
                lightNode.angle = lightDef.spot.outerConeAngle;
                lightNode.penumbra = 1.0 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;
                lightNode.target.position.set( 0, 0, - 1 );
                lightNode.add( lightNode.target );
                break;

            default:
                throw new Error( 'THREE.GLTFLoader: Unexpected light type: ' + lightDef.type );

        }

        // Some lights (e.g. spot) default to a position other than the origin. Reset the position
        // here, because node-level parsing will only override position if explicitly specified.
        lightNode.position.set( 0, 0, 0 );

        assignExtrasToUserData( lightNode, lightDef );

        if ( lightDef.intensity !== undefined ) lightNode.intensity = lightDef.intensity;

        lightNode.name = parser.createUniqueName( lightDef.name || ( 'light_' + lightIndex ) );

        dependency = Promise.resolve( lightNode );

        parser.cache.add( cacheKey, dependency );

        return dependency;

    }

`GLTFLightsExtension.getDependency(type: any, index: any): any`¶

Parameters:

type any
index any

Returns: any

Calls:

this._loadLight

Code

getDependency( type, index ) {

        if ( type !== 'light' ) return;

        return this._loadLight( index );

    }

`GLTFLightsExtension.createNodeAttachment(nodeIndex: any): any`¶

Parameters:

nodeIndex any

Returns: any

Calls:

this._loadLight( lightIndex ).then
parser._getNodeRef

Code

createNodeAttachment( nodeIndex ) {

        const self = this;
        const parser = this.parser;
        const json = parser.json;
        const nodeDef = json.nodes[ nodeIndex ];
        const lightDef = ( nodeDef.extensions && nodeDef.extensions[ this.name ] ) || {};
        const lightIndex = lightDef.light;

        if ( lightIndex === undefined ) return null;

        return this._loadLight( lightIndex ).then( function ( light ) {

            return parser._getNodeRef( self.cache, lightIndex, light );

        } );

    }

`GLTFMaterialsUnlitExtension.getMaterialType(): any`¶

Returns: any

Code

getMaterialType() {

        return MeshBasicMaterial;

    }

`GLTFMaterialsUnlitExtension.extendParams(materialParams: any, materialDef: any, parser: any): Promise<any[]>`¶

Parameters:

materialParams any
materialDef any
parser any

Returns: Promise<any[]>

Calls:

Array.isArray
materialParams.color.setRGB
pending.push
parser.assignTexture
Promise.all

Code

extendParams( materialParams, materialDef, parser ) {

        const pending = [];

        materialParams.color = new Color( 1.0, 1.0, 1.0 );
        materialParams.opacity = 1.0;

        const metallicRoughness = materialDef.pbrMetallicRoughness;

        if ( metallicRoughness ) {

            if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {

                const array = metallicRoughness.baseColorFactor;

                materialParams.color.setRGB( array[ 0 ], array[ 1 ], array[ 2 ], LinearSRGBColorSpace );
                materialParams.opacity = array[ 3 ];

            }

            if ( metallicRoughness.baseColorTexture !== undefined ) {

                pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) );

            }

        }

        return Promise.all( pending );

    }

`GLTFMaterialsEmissiveStrengthExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void>`¶

Parameters:

materialIndex any
materialParams any

Returns: Promise<void>

Calls:

Promise.resolve

Code

extendMaterialParams( materialIndex, materialParams ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {

            return Promise.resolve();

        }

        const emissiveStrength = materialDef.extensions[ this.name ].emissiveStrength;

        if ( emissiveStrength !== undefined ) {

            materialParams.emissiveIntensity = emissiveStrength;

        }

        return Promise.resolve();

    }

`GLTFMaterialsClearcoatExtension.getMaterialType(materialIndex: any): any`¶

Parameters:

materialIndex any

Returns: any

Code

getMaterialType( materialIndex ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;

        return MeshPhysicalMaterial;

    }

`GLTFMaterialsClearcoatExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Parameters:

materialIndex any
materialParams any

Returns: Promise<void> | Promise<any[]>

Calls:

Promise.resolve
pending.push
parser.assignTexture
Promise.all

Code

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.clearcoatFactor !== undefined ) {

            materialParams.clearcoat = extension.clearcoatFactor;

        }

        if ( extension.clearcoatTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'clearcoatMap', extension.clearcoatTexture ) );

        }

        if ( extension.clearcoatRoughnessFactor !== undefined ) {

            materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor;

        }

        if ( extension.clearcoatRoughnessTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'clearcoatRoughnessMap', extension.clearcoatRoughnessTexture ) );

        }

        if ( extension.clearcoatNormalTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'clearcoatNormalMap', extension.clearcoatNormalTexture ) );

            if ( extension.clearcoatNormalTexture.scale !== undefined ) {

                const scale = extension.clearcoatNormalTexture.scale;

                materialParams.clearcoatNormalScale = new Vector2( scale, scale );

            }

        }

        return Promise.all( pending );

    }

`GLTFMaterialsDispersionExtension.getMaterialType(materialIndex: any): any`¶

Parameters:

materialIndex any

Returns: any

Code

getMaterialType( materialIndex ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;

        return MeshPhysicalMaterial;

    }

`GLTFMaterialsDispersionExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void>`¶

Parameters:

materialIndex any
materialParams any

Returns: Promise<void>

Calls:

Promise.resolve

Code

extendMaterialParams( materialIndex, materialParams ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {

            return Promise.resolve();

        }

        const extension = materialDef.extensions[ this.name ];

        materialParams.dispersion = extension.dispersion !== undefined ? extension.dispersion : 0;

        return Promise.resolve();

    }

`GLTFMaterialsIridescenceExtension.getMaterialType(materialIndex: any): any`¶

Parameters:

materialIndex any

Returns: any

Code

getMaterialType( materialIndex ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;

        return MeshPhysicalMaterial;

    }

`GLTFMaterialsIridescenceExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Parameters:

materialIndex any
materialParams any

Returns: Promise<void> | Promise<any[]>

Calls:

Promise.resolve
pending.push
parser.assignTexture
Promise.all

Code

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.iridescenceFactor !== undefined ) {

            materialParams.iridescence = extension.iridescenceFactor;

        }

        if ( extension.iridescenceTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'iridescenceMap', extension.iridescenceTexture ) );

        }

        if ( extension.iridescenceIor !== undefined ) {

            materialParams.iridescenceIOR = extension.iridescenceIor;

        }

        if ( materialParams.iridescenceThicknessRange === undefined ) {

            materialParams.iridescenceThicknessRange = [ 100, 400 ];

        }

        if ( extension.iridescenceThicknessMinimum !== undefined ) {

            materialParams.iridescenceThicknessRange[ 0 ] = extension.iridescenceThicknessMinimum;

        }

        if ( extension.iridescenceThicknessMaximum !== undefined ) {

            materialParams.iridescenceThicknessRange[ 1 ] = extension.iridescenceThicknessMaximum;

        }

        if ( extension.iridescenceThicknessTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'iridescenceThicknessMap', extension.iridescenceThicknessTexture ) );

        }

        return Promise.all( pending );

    }

`GLTFMaterialsSheenExtension.getMaterialType(materialIndex: any): any`¶

Parameters:

materialIndex any

Returns: any

Code

getMaterialType( materialIndex ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;

        return MeshPhysicalMaterial;

    }

`GLTFMaterialsSheenExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Parameters:

materialIndex any
materialParams any

Returns: Promise<void> | Promise<any[]>

Calls:

Promise.resolve
materialParams.sheenColor.setRGB
pending.push
parser.assignTexture
Promise.all

Code

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 = [];

        materialParams.sheenColor = new Color( 0, 0, 0 );
        materialParams.sheenRoughness = 0;
        materialParams.sheen = 1;

        const extension = materialDef.extensions[ this.name ];

        if ( extension.sheenColorFactor !== undefined ) {

            const colorFactor = extension.sheenColorFactor;
            materialParams.sheenColor.setRGB( colorFactor[ 0 ], colorFactor[ 1 ], colorFactor[ 2 ], LinearSRGBColorSpace );

        }

        if ( extension.sheenRoughnessFactor !== undefined ) {

            materialParams.sheenRoughness = extension.sheenRoughnessFactor;

        }

        if ( extension.sheenColorTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'sheenColorMap', extension.sheenColorTexture, SRGBColorSpace ) );

        }

        if ( extension.sheenRoughnessTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'sheenRoughnessMap', extension.sheenRoughnessTexture ) );

        }

        return Promise.all( pending );

    }

`GLTFMaterialsTransmissionExtension.getMaterialType(materialIndex: any): any`¶

Parameters:

materialIndex any

Returns: any

Code

getMaterialType( materialIndex ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;

        return MeshPhysicalMaterial;

    }

`GLTFMaterialsTransmissionExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Parameters:

materialIndex any
materialParams any

Returns: Promise<void> | Promise<any[]>

Calls:

Promise.resolve
pending.push
parser.assignTexture
Promise.all

Code

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.transmissionFactor !== undefined ) {

            materialParams.transmission = extension.transmissionFactor;

        }

        if ( extension.transmissionTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'transmissionMap', extension.transmissionTexture ) );

        }

        return Promise.all( pending );

    }

`GLTFMaterialsVolumeExtension.getMaterialType(materialIndex: any): any`¶

Parameters:

materialIndex any

Returns: any

Code

getMaterialType( materialIndex ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;

        return MeshPhysicalMaterial;

    }

`GLTFMaterialsVolumeExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Parameters:

materialIndex any
materialParams any

Returns: Promise<void> | Promise<any[]>

Calls:

Promise.resolve
pending.push
parser.assignTexture
new Color().setRGB
Promise.all

Code

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 ];

        materialParams.thickness = extension.thicknessFactor !== undefined ? extension.thicknessFactor : 0;

        if ( extension.thicknessTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'thicknessMap', extension.thicknessTexture ) );

        }

        materialParams.attenuationDistance = extension.attenuationDistance || Infinity;

        const colorArray = extension.attenuationColor || [ 1, 1, 1 ];
        materialParams.attenuationColor = new Color().setRGB( colorArray[ 0 ], colorArray[ 1 ], colorArray[ 2 ], LinearSRGBColorSpace );

        return Promise.all( pending );

    }

`GLTFMaterialsIorExtension.getMaterialType(materialIndex: any): any`¶

Parameters:

materialIndex any

Returns: any

Code

getMaterialType( materialIndex ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;

        return MeshPhysicalMaterial;

    }

`GLTFMaterialsIorExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void>`¶

Parameters:

materialIndex any
materialParams any

Returns: Promise<void>

Calls:

Promise.resolve

Code

extendMaterialParams( materialIndex, materialParams ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {

            return Promise.resolve();

        }

        const extension = materialDef.extensions[ this.name ];

        materialParams.ior = extension.ior !== undefined ? extension.ior : 1.5;

        return Promise.resolve();

    }

`GLTFMaterialsSpecularExtension.getMaterialType(materialIndex: any): any`¶

Parameters:

materialIndex any

Returns: any

Code

getMaterialType( materialIndex ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;

        return MeshPhysicalMaterial;

    }

`GLTFMaterialsSpecularExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Parameters:

materialIndex any
materialParams any

Returns: Promise<void> | Promise<any[]>

Calls:

Promise.resolve
pending.push
parser.assignTexture
new Color().setRGB
Promise.all

Code

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 ];

        materialParams.specularIntensity = extension.specularFactor !== undefined ? extension.specularFactor : 1.0;

        if ( extension.specularTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'specularIntensityMap', extension.specularTexture ) );

        }

        const colorArray = extension.specularColorFactor || [ 1, 1, 1 ];
        materialParams.specularColor = new Color().setRGB( colorArray[ 0 ], colorArray[ 1 ], colorArray[ 2 ], LinearSRGBColorSpace );

        if ( extension.specularColorTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'specularColorMap', extension.specularColorTexture, SRGBColorSpace ) );

        }

        return Promise.all( pending );

    }

`GLTFMaterialsBumpExtension.getMaterialType(materialIndex: any): any`¶

Parameters:

materialIndex any

Returns: any

Code

getMaterialType( materialIndex ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;

        return MeshPhysicalMaterial;

    }

`GLTFMaterialsBumpExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Parameters:

materialIndex any
materialParams any

Returns: Promise<void> | Promise<any[]>

Calls:

Promise.resolve
pending.push
parser.assignTexture
Promise.all

Code

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 ];

        materialParams.bumpScale = extension.bumpFactor !== undefined ? extension.bumpFactor : 1.0;

        if ( extension.bumpTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'bumpMap', extension.bumpTexture ) );

        }

        return Promise.all( pending );

    }

`GLTFMaterialsAnisotropyExtension.getMaterialType(materialIndex: any): any`¶

Parameters:

materialIndex any

Returns: any

Code

getMaterialType( materialIndex ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;

        return MeshPhysicalMaterial;

    }

`GLTFMaterialsAnisotropyExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Parameters:

materialIndex any
materialParams any

Returns: Promise<void> | Promise<any[]>

Calls:

Promise.resolve
pending.push
parser.assignTexture
Promise.all

Code

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 ) );

        }

        return Promise.all( pending );

    }

`GLTFTextureBasisUExtension.loadTexture(textureIndex: any): any`¶

Parameters:

textureIndex any

Returns: any

Calls:

json.extensionsRequired.indexOf
parser.loadTextureImage

Internal Comments:

// Assumes that the extension is optional and that a fallback texture is present

Code

loadTexture( textureIndex ) {

        const parser = this.parser;
        const json = parser.json;

        const textureDef = json.textures[ textureIndex ];

        if ( ! textureDef.extensions || ! textureDef.extensions[ this.name ] ) {

            return null;

        }

        const extension = textureDef.extensions[ this.name ];
        const loader = parser.options.ktx2Loader;

        if ( ! loader ) {

            if ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) {

                throw new Error( 'THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures' );

            } else {

                // Assumes that the extension is optional and that a fallback texture is present
                return null;

            }

        }

        return parser.loadTextureImage( textureIndex, extension.source, loader );

    }

`GLTFTextureWebPExtension.loadTexture(textureIndex: any): any`¶

Parameters:

textureIndex any

Returns: any

Calls:

parser.options.manager.getHandler
parser.loadTextureImage

Code

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 parser.loadTextureImage( textureIndex, extension.source, loader );

    }

`GLTFTextureAVIFExtension.loadTexture(textureIndex: any): any`¶

Parameters:

textureIndex any

Returns: any

Calls:

parser.options.manager.getHandler
parser.loadTextureImage

Code

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 parser.loadTextureImage( textureIndex, extension.source, loader );

    }

`GLTFMeshoptCompression.loadBufferView(index: any): any`¶

Parameters:

index any

Returns: any

Calls:

this.parser.getDependency
json.extensionsRequired.indexOf
buffer.then
decoder.decodeGltfBufferAsync( count, stride, source, extensionDef.mode, extensionDef.filter ).then
decoder.ready.then
decoder.decodeGltfBuffer

Internal Comments:

// Assumes that the extension is optional and that fallback buffer data is present
// Support for MeshoptDecoder 0.18 or earlier, without decodeGltfBufferAsync

Code

loadBufferView( index ) {

        const json = this.parser.json;
        const bufferView = json.bufferViews[ index ];

        if ( bufferView.extensions && bufferView.extensions[ this.name ] ) {

            const extensionDef = bufferView.extensions[ this.name ];

            const buffer = this.parser.getDependency( 'buffer', extensionDef.buffer );
            const decoder = this.parser.options.meshoptDecoder;

            if ( ! decoder || ! decoder.supported ) {

                if ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) {

                    throw new Error( 'THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files' );

                } else {

                    // Assumes that the extension is optional and that fallback buffer data is present
                    return null;

                }

            }

            return buffer.then( function ( res ) {

                const byteOffset = extensionDef.byteOffset || 0;
                const byteLength = extensionDef.byteLength || 0;

                const count = extensionDef.count;
                const stride = extensionDef.byteStride;

                const source = new Uint8Array( res, byteOffset, byteLength );

                if ( decoder.decodeGltfBufferAsync ) {

                    return decoder.decodeGltfBufferAsync( count, stride, source, extensionDef.mode, extensionDef.filter ).then( function ( res ) {

                        return res.buffer;

                    } );

                } else {

                    // Support for MeshoptDecoder 0.18 or earlier, without decodeGltfBufferAsync
                    return decoder.ready.then( function () {

                        const result = new ArrayBuffer( count * stride );
                        decoder.decodeGltfBuffer( new Uint8Array( result ), count, stride, source, extensionDef.mode, extensionDef.filter );
                        return result;

                    } );

                }

            } );

        } else {

            return null;

        }

    }

`GLTFMeshGpuInstancing.createNodeMesh(nodeIndex: any): Promise<any>`¶

Parameters:

nodeIndex any

Returns: Promise<any>

Calls:

pending.push
this.parser.getDependency( 'accessor', attributesDef[ key ] ).then
this.parser.createNodeMesh
Promise.all( pending ).then
results.pop
p.fromBufferAttribute
q.fromBufferAttribute
s.fromBufferAttribute
instancedMesh.setMatrixAt
m.compose
mesh.geometry.setAttribute
Object3D.prototype.copy.call
this.parser.assignFinalMaterial
instancedMeshes.push
nodeObject.clear
nodeObject.add

Internal Comments:

// No Points or Lines + Instancing support yet
// @TODO: Can we support InstancedMesh + SkinnedMesh? (x2)
// Temporal variables (x2)
// Add instance attributes to the geometry, excluding TRS.
// Just in case (x6)

Code

createNodeMesh( nodeIndex ) {

        const json = this.parser.json;
        const nodeDef = json.nodes[ nodeIndex ];

        if ( ! nodeDef.extensions || ! nodeDef.extensions[ this.name ] ||
            nodeDef.mesh === undefined ) {

            return null;

        }

        const meshDef = json.meshes[ nodeDef.mesh ];

        // No Points or Lines + Instancing support yet

        for ( const primitive of meshDef.primitives ) {

            if ( primitive.mode !== WEBGL_CONSTANTS.TRIANGLES &&
                 primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_STRIP &&
                 primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_FAN &&
                 primitive.mode !== undefined ) {

                return null;

            }

        }

        const extensionDef = nodeDef.extensions[ this.name ];
        const attributesDef = extensionDef.attributes;

        // @TODO: Can we support InstancedMesh + SkinnedMesh?

        const pending = [];
        const attributes = {};

        for ( const key in attributesDef ) {

            pending.push( this.parser.getDependency( 'accessor', attributesDef[ key ] ).then( accessor => {

                attributes[ key ] = accessor;
                return attributes[ key ];

            } ) );

        }

        if ( pending.length < 1 ) {

            return null;

        }

        pending.push( this.parser.createNodeMesh( nodeIndex ) );

        return Promise.all( pending ).then( results => {

            const nodeObject = results.pop();
            const meshes = nodeObject.isGroup ? nodeObject.children : [ nodeObject ];
            const count = results[ 0 ].count; // All attribute counts should be same
            const instancedMeshes = [];

            for ( const mesh of meshes ) {

                // Temporal variables
                const m = new Matrix4();
                const p = new Vector3();
                const q = new Quaternion();
                const s = new Vector3( 1, 1, 1 );

                const instancedMesh = new InstancedMesh( mesh.geometry, mesh.material, count );

                for ( let i = 0; i < count; i ++ ) {

                    if ( attributes.TRANSLATION ) {

                        p.fromBufferAttribute( attributes.TRANSLATION, i );

                    }

                    if ( attributes.ROTATION ) {

                        q.fromBufferAttribute( attributes.ROTATION, i );

                    }

                    if ( attributes.SCALE ) {

                        s.fromBufferAttribute( attributes.SCALE, i );

                    }

                    instancedMesh.setMatrixAt( i, m.compose( p, q, s ) );

                }

                // Add instance attributes to the geometry, excluding TRS.
                for ( const attributeName in attributes ) {

                    if ( attributeName === '_COLOR_0' ) {

                        const attr = attributes[ attributeName ];
                        instancedMesh.instanceColor = new InstancedBufferAttribute( attr.array, attr.itemSize, attr.normalized );

                    } else if ( attributeName !== 'TRANSLATION' &&
                         attributeName !== 'ROTATION' &&
                         attributeName !== 'SCALE' ) {

                        mesh.geometry.setAttribute( attributeName, attributes[ attributeName ] );

                    }

                }

                // Just in case
                Object3D.prototype.copy.call( instancedMesh, mesh );

                this.parser.assignFinalMaterial( instancedMesh );

                instancedMeshes.push( instancedMesh );

            }

            if ( nodeObject.isGroup ) {

                nodeObject.clear();

                nodeObject.add( ... instancedMeshes );

                return nodeObject;

            }

            return instancedMeshes[ 0 ];

        } );

    }

`GLTFDracoMeshCompressionExtension.decodePrimitive(primitive: any, parser: any): any`¶

Parameters:

primitive any
parser any

Returns: any

Calls:

attributeName.toLowerCase
parser.getDependency( 'bufferView', bufferViewIndex ).then
dracoLoader.decodeDracoFile
resolve

Code

decodePrimitive( primitive, parser ) {

        const json = this.json;
        const dracoLoader = this.dracoLoader;
        const bufferViewIndex = primitive.extensions[ this.name ].bufferView;
        const gltfAttributeMap = primitive.extensions[ this.name ].attributes;
        const threeAttributeMap = {};
        const attributeNormalizedMap = {};
        const attributeTypeMap = {};

        for ( const attributeName in gltfAttributeMap ) {

            const threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();

            threeAttributeMap[ threeAttributeName ] = gltfAttributeMap[ attributeName ];

        }

        for ( const attributeName in primitive.attributes ) {

            const threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();

            if ( gltfAttributeMap[ attributeName ] !== undefined ) {

                const accessorDef = json.accessors[ primitive.attributes[ attributeName ] ];
                const componentType = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];

                attributeTypeMap[ threeAttributeName ] = componentType.name;
                attributeNormalizedMap[ threeAttributeName ] = accessorDef.normalized === true;

            }

        }

        return parser.getDependency( 'bufferView', bufferViewIndex ).then( function ( bufferView ) {

            return new Promise( function ( resolve, reject ) {

                dracoLoader.decodeDracoFile( bufferView, function ( geometry ) {

                    for ( const attributeName in geometry.attributes ) {

                        const attribute = geometry.attributes[ attributeName ];
                        const normalized = attributeNormalizedMap[ attributeName ];

                        if ( normalized !== undefined ) attribute.normalized = normalized;

                    }

                    resolve( geometry );

                }, threeAttributeMap, attributeTypeMap, LinearSRGBColorSpace, reject );

            } );

        } );

    }

`GLTFTextureTransformExtension.extendTexture(texture: any, transform: any): any`¶

Parameters:

texture any
transform any

Returns: any

Calls:

texture.clone
texture.offset.fromArray
texture.repeat.fromArray

Internal Comments:

// See https://github.com/mrdoob/three.js/issues/21819.

Code

extendTexture( texture, transform ) {

        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;

        }

        texture = texture.clone();

        if ( transform.texCoord !== undefined ) {

            texture.channel = transform.texCoord;

        }

        if ( transform.offset !== undefined ) {

            texture.offset.fromArray( transform.offset );

        }

        if ( transform.rotation !== undefined ) {

            texture.rotation = transform.rotation;

        }

        if ( transform.scale !== undefined ) {

            texture.repeat.fromArray( transform.scale );

        }

        texture.needsUpdate = true;

        return texture;

    }

`GLTFCubicSplineInterpolant.copySampleValue_(index: any): any`¶

Parameters:

index any

Returns: any

Internal Comments:

// Copies a sample value to the result buffer. See description of glTF (x2)
// CUBICSPLINE values layout in interpolate_() function below. (x2)

Code

copySampleValue_( index ) {

        // Copies a sample value to the result buffer. See description of glTF
        // CUBICSPLINE values layout in interpolate_() function below.

        const result = this.resultBuffer,
            values = this.sampleValues,
            valueSize = this.valueSize,
            offset = index * valueSize * 3 + valueSize;

        for ( let i = 0; i !== valueSize; i ++ ) {

            result[ i ] = values[ offset + i ];

        }

        return result;

    }

`GLTFCubicSplineInterpolant.interpolate_(i1: any, t0: any, t: any, t1: any): any`¶

Parameters:

i1 any
t0 any
t any
t1 any

Returns: any

Internal Comments:

// Layout of keyframe output values for CUBICSPLINE animations:
//   [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]

Code

interpolate_( i1, t0, t, t1 ) {

        const result = this.resultBuffer;
        const values = this.sampleValues;
        const stride = this.valueSize;

        const stride2 = stride * 2;
        const stride3 = stride * 3;

        const td = t1 - t0;

        const p = ( t - t0 ) / td;
        const pp = p * p;
        const ppp = pp * p;

        const offset1 = i1 * stride3;
        const offset0 = offset1 - stride3;

        const s2 = - 2 * ppp + 3 * pp;
        const s3 = ppp - pp;
        const s0 = 1 - s2;
        const s1 = s3 - pp + p;

        // Layout of keyframe output values for CUBICSPLINE animations:
        //   [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]
        for ( let i = 0; i !== stride; i ++ ) {

            const p0 = values[ offset0 + i + stride ]; // splineVertex_k
            const m0 = values[ offset0 + i + stride2 ] * td; // outTangent_k * (t_k+1 - t_k)
            const p1 = values[ offset1 + i + stride ]; // splineVertex_k+1
            const m1 = values[ offset1 + i ] * td; // inTangent_k+1 * (t_k+1 - t_k)

            result[ i ] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;

        }

        return result;

    }

`GLTFCubicSplineQuaternionInterpolant.interpolate_(i1: any, t0: any, t: any, t1: any): any`¶

Parameters:

i1 any
t0 any
t any
t1 any

Returns: any

Calls:

super.interpolate_
_quaternion.fromArray( result ).normalize().toArray

Code

interpolate_( i1, t0, t, t1 ) {

        const result = super.interpolate_( i1, t0, t, t1 );

        _quaternion.fromArray( result ).normalize().toArray( result );

        return result;

    }

`createDefaultMaterial(cache: { [x: string]: Material; }): Material`¶

JSDoc:

/**
 * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material
 *
 * @private
 * @param {Object<string, Material>} cache
 * @return {Material}
 */

Parameters:

cache { [x: string]: Material; }

Returns: Material

Code

function createDefaultMaterial( cache ) {

    if ( cache[ 'DefaultMaterial' ] === undefined ) {

        cache[ 'DefaultMaterial' ] = new MeshStandardMaterial( {
            color: 0xFFFFFF,
            emissive: 0x000000,
            metalness: 1,
            roughness: 1,
            transparent: false,
            depthTest: true,
            side: FrontSide
        } );

    }

    return cache[ 'DefaultMaterial' ];

}

`addUnknownExtensionsToUserData(knownExtensions: any, object: any, objectDef: any): void`¶

Parameters:

knownExtensions any
object any
objectDef any

Returns: void

Internal Comments:

// Add unknown glTF extensions to an object's userData.

Code

function addUnknownExtensionsToUserData( knownExtensions, object, objectDef ) {

    // Add unknown glTF extensions to an object's userData.

    for ( const name in objectDef.extensions ) {

        if ( knownExtensions[ name ] === undefined ) {

            object.userData.gltfExtensions = object.userData.gltfExtensions || {};
            object.userData.gltfExtensions[ name ] = objectDef.extensions[ name ];

        }

    }

}

`assignExtrasToUserData(object: any, gltfDef: GLTF.definition): void`¶

JSDoc:

/**
 *
 * @private
 * @param {Object3D|Material|BufferGeometry|Object} object
 * @param {GLTF.definition} gltfDef
 */

Parameters:

object any
gltfDef GLTF.definition

Returns: void

Calls:

Object.assign
console.warn

Code

function assignExtrasToUserData( object, gltfDef ) {

    if ( gltfDef.extras !== undefined ) {

        if ( typeof gltfDef.extras === 'object' ) {

            Object.assign( object.userData, gltfDef.extras );

        } else {

            console.warn( 'THREE.GLTFLoader: Ignoring primitive type .extras, ' + gltfDef.extras );

        }

    }

}

`addMorphTargets(geometry: BufferGeometry, targets: GLTF.Target[], parser: GLTFParser): Promise<BufferGeometry>`¶

JSDoc:

/**
 * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#morph-targets
 *
 * @private
 * @param {BufferGeometry} geometry
 * @param {Array<GLTF.Target>} targets
 * @param {GLTFParser} parser
 * @return {Promise<BufferGeometry>}
 */

Parameters:

geometry BufferGeometry
targets GLTF.Target[]
parser GLTFParser

Returns: Promise<BufferGeometry>

Calls:

Promise.resolve
parser.getDependency
pendingPositionAccessors.push
pendingNormalAccessors.push
pendingColorAccessors.push
Promise.all( [ Promise.all( pendingPositionAccessors ), Promise.all( pendingNormalAccessors ), Promise.all( pendingColorAccessors ) ] ).then

Code

function addMorphTargets( geometry, targets, parser ) {

    let hasMorphPosition = false;
    let hasMorphNormal = false;
    let hasMorphColor = false;

    for ( let i = 0, il = targets.length; i < il; i ++ ) {

        const target = targets[ i ];

        if ( target.POSITION !== undefined ) hasMorphPosition = true;
        if ( target.NORMAL !== undefined ) hasMorphNormal = true;
        if ( target.COLOR_0 !== undefined ) hasMorphColor = true;

        if ( hasMorphPosition && hasMorphNormal && hasMorphColor ) break;

    }

    if ( ! hasMorphPosition && ! hasMorphNormal && ! hasMorphColor ) return Promise.resolve( geometry );

    const pendingPositionAccessors = [];
    const pendingNormalAccessors = [];
    const pendingColorAccessors = [];

    for ( let i = 0, il = targets.length; i < il; i ++ ) {

        const target = targets[ i ];

        if ( hasMorphPosition ) {

            const pendingAccessor = target.POSITION !== undefined
                ? parser.getDependency( 'accessor', target.POSITION )
                : geometry.attributes.position;

            pendingPositionAccessors.push( pendingAccessor );

        }

        if ( hasMorphNormal ) {

            const pendingAccessor = target.NORMAL !== undefined
                ? parser.getDependency( 'accessor', target.NORMAL )
                : geometry.attributes.normal;

            pendingNormalAccessors.push( pendingAccessor );

        }

        if ( hasMorphColor ) {

            const pendingAccessor = target.COLOR_0 !== undefined
                ? parser.getDependency( 'accessor', target.COLOR_0 )
                : geometry.attributes.color;

            pendingColorAccessors.push( pendingAccessor );

        }

    }

    return Promise.all( [
        Promise.all( pendingPositionAccessors ),
        Promise.all( pendingNormalAccessors ),
        Promise.all( pendingColorAccessors )
    ] ).then( function ( accessors ) {

        const morphPositions = accessors[ 0 ];
        const morphNormals = accessors[ 1 ];
        const morphColors = accessors[ 2 ];

        if ( hasMorphPosition ) geometry.morphAttributes.position = morphPositions;
        if ( hasMorphNormal ) geometry.morphAttributes.normal = morphNormals;
        if ( hasMorphColor ) geometry.morphAttributes.color = morphColors;
        geometry.morphTargetsRelative = true;

        return geometry;

    } );

}

`updateMorphTargets(mesh: Mesh, meshDef: GLTF.Mesh): void`¶

JSDoc:

/**
 *
 * @private
 * @param {Mesh} mesh
 * @param {GLTF.Mesh} meshDef
 */

Parameters:

mesh Mesh
meshDef GLTF.Mesh

Returns: void

Calls:

mesh.updateMorphTargets
Array.isArray
console.warn

Internal Comments:

// .extras has user-defined data, so check that .extras.targetNames is an array.

Code

function updateMorphTargets( mesh, meshDef ) {

    mesh.updateMorphTargets();

    if ( meshDef.weights !== undefined ) {

        for ( let i = 0, il = meshDef.weights.length; i < il; i ++ ) {

            mesh.morphTargetInfluences[ i ] = meshDef.weights[ i ];

        }

    }

    // .extras has user-defined data, so check that .extras.targetNames is an array.
    if ( meshDef.extras && Array.isArray( meshDef.extras.targetNames ) ) {

        const targetNames = meshDef.extras.targetNames;

        if ( mesh.morphTargetInfluences.length === targetNames.length ) {

            mesh.morphTargetDictionary = {};

            for ( let i = 0, il = targetNames.length; i < il; i ++ ) {

                mesh.morphTargetDictionary[ targetNames[ i ] ] = i;

            }

        } else {

            console.warn( 'THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.' );

        }

    }

}

`createPrimitiveKey(primitiveDef: any): string`¶

Parameters:

primitiveDef any

Returns: string

Calls:

createAttributesKey

Code

function createPrimitiveKey( primitiveDef ) {

    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 {

        geometryKey = primitiveDef.indices + ':' + createAttributesKey( primitiveDef.attributes ) + ':' + primitiveDef.mode;

    }

    if ( primitiveDef.targets !== undefined ) {

        for ( let i = 0, il = primitiveDef.targets.length; i < il; i ++ ) {

            geometryKey += ':' + createAttributesKey( primitiveDef.targets[ i ] );

        }

    }

    return geometryKey;

}

`createAttributesKey(attributes: any): string`¶

Parameters:

attributes any

Returns: string

Calls:

Object.keys( attributes ).sort

Code

function createAttributesKey( attributes ) {

    let attributesKey = '';

    const keys = Object.keys( attributes ).sort();

    for ( let i = 0, il = keys.length; i < il; i ++ ) {

        attributesKey += keys[ i ] + ':' + attributes[ keys[ i ] ] + ';';

    }

    return attributesKey;

}

`getNormalizedComponentScale(constructor: any): number`¶

Parameters:

constructor any

Returns: number

Internal Comments:

// Reference:
// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization#encoding-quantized-data

Code

function getNormalizedComponentScale( constructor ) {

    // Reference:
    // https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization#encoding-quantized-data

    switch ( constructor ) {

        case Int8Array:
            return 1 / 127;

        case Uint8Array:
            return 1 / 255;

        case Int16Array:
            return 1 / 32767;

        case Uint16Array:
            return 1 / 65535;

        default:
            throw new Error( 'THREE.GLTFLoader: Unsupported normalized accessor component type.' );

    }

}

`getImageURIMimeType(uri: any): "image/png" | "image/jpeg" | "image/webp" | "image/ktx2"`¶

Parameters:

uri any

Returns: "image/png" | "image/jpeg" | "image/webp" | "image/ktx2"

Calls:

uri.search

Code

function getImageURIMimeType( uri ) {

    if ( uri.search( /\.jpe?g($|\?)/i ) > 0 || uri.search( /^data\:image\/jpeg/ ) === 0 ) return 'image/jpeg';
    if ( uri.search( /\.webp($|\?)/i ) > 0 || uri.search( /^data\:image\/webp/ ) === 0 ) return 'image/webp';
    if ( uri.search( /\.ktx2($|\?)/i ) > 0 || uri.search( /^data\:image\/ktx2/ ) === 0 ) return 'image/ktx2';

    return 'image/png';

}

`GLTFParser.setExtensions(extensions: any): void`¶

Parameters:

extensions any

Returns: void

Code

setExtensions( extensions ) {

        this.extensions = extensions;

    }

`GLTFParser.setPlugins(plugins: any): void`¶

Parameters:

plugins any

Returns: void

Code

setPlugins( plugins ) {

        this.plugins = plugins;

    }

`GLTFParser.parse(onLoad: any, onError: any): void`¶

Parameters:

onLoad any
onError any

Returns: void

Calls:

this.cache.removeAll
this._invokeAll
ext._markDefs

`Promise.all( this._invokeAll( function ( ext ) {

    return ext.beforeRoot && ext.beforeRoot();

} ) ).then( function () {

    return Promise.all( [

        parser.getDependencies( 'scene' ),
        parser.getDependencies( 'animation' ),
        parser.getDependencies( 'camera' ),

    ] );

} ).then( function ( dependencies ) {

    const result = {
        scene: dependencies[ 0 ][ json.scene || 0 ],
        scenes: dependencies[ 0 ],
        animations: dependencies[ 1 ],
        cameras: dependencies[ 2 ],
        asset: json.asset,
        parser: parser,
        userData: {}
    };

    addUnknownExtensionsToUserData( extensions, result, json );

    assignExtrasToUserData( result, json );

    return Promise.all( parser._invokeAll( function ( ext ) {

        return ext.afterRoot && ext.afterRoot( result );

    } ) ).then( function () {

        for ( const scene of result.scenes ) {

            scene.updateMatrixWorld();

        }

        onLoad( result );

    } );

} ).catch`

Internal Comments:

// Clear the loader cache (x5)
// Mark the special nodes/meshes in json for efficient parse (x4)

Code

parse( onLoad, onError ) {

        const parser = this;
        const json = this.json;
        const extensions = this.extensions;

        // Clear the loader cache
        this.cache.removeAll();
        this.nodeCache = {};

        // Mark the special nodes/meshes in json for efficient parse
        this._invokeAll( function ( ext ) {

            return ext._markDefs && ext._markDefs();

        } );

        Promise.all( this._invokeAll( function ( ext ) {

            return ext.beforeRoot && ext.beforeRoot();

        } ) ).then( function () {

            return Promise.all( [

                parser.getDependencies( 'scene' ),
                parser.getDependencies( 'animation' ),
                parser.getDependencies( 'camera' ),

            ] );

        } ).then( function ( dependencies ) {

            const result = {
                scene: dependencies[ 0 ][ json.scene || 0 ],
                scenes: dependencies[ 0 ],
                animations: dependencies[ 1 ],
                cameras: dependencies[ 2 ],
                asset: json.asset,
                parser: parser,
                userData: {}
            };

            addUnknownExtensionsToUserData( extensions, result, json );

            assignExtrasToUserData( result, json );

            return Promise.all( parser._invokeAll( function ( ext ) {

                return ext.afterRoot && ext.afterRoot( result );

            } ) ).then( function () {

                for ( const scene of result.scenes ) {

                    scene.updateMatrixWorld();

                }

                onLoad( result );

            } );

        } ).catch( onError );

    }

`GLTFParser._markDefs(): void`¶

JSDoc:

/**
     * Marks the special nodes/meshes in json for efficient parse.
     *
     * @private
     */

Returns: void

Calls:

this._addNodeRef

Internal Comments:

// Nothing in the node definition indicates whether it is a Bone or an
// Object3D. Use the skins' joint references to mark bones.
// Iterate over all nodes, marking references to shared resources,
// as well as skeleton joints.
// Nothing in the mesh definition indicates whether it is
// a SkinnedMesh or Mesh. Use the node's mesh reference
// to mark SkinnedMesh if node has skin.

Code

_markDefs() {

        const nodeDefs = this.json.nodes || [];
        const skinDefs = this.json.skins || [];
        const meshDefs = this.json.meshes || [];

        // Nothing in the node definition indicates whether it is a Bone or an
        // Object3D. Use the skins' joint references to mark bones.
        for ( let skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex ++ ) {

            const joints = skinDefs[ skinIndex ].joints;

            for ( let i = 0, il = joints.length; i < il; i ++ ) {

                nodeDefs[ joints[ i ] ].isBone = true;

            }

        }

        // Iterate over all nodes, marking references to shared resources,
        // as well as skeleton joints.
        for ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {

            const nodeDef = nodeDefs[ nodeIndex ];

            if ( nodeDef.mesh !== undefined ) {

                this._addNodeRef( this.meshCache, nodeDef.mesh );

                // Nothing in the mesh definition indicates whether it is
                // a SkinnedMesh or Mesh. Use the node's mesh reference
                // to mark SkinnedMesh if node has skin.
                if ( nodeDef.skin !== undefined ) {

                    meshDefs[ nodeDef.mesh ].isSkinnedMesh = true;

                }

            }

            if ( nodeDef.camera !== undefined ) {

                this._addNodeRef( this.cameraCache, nodeDef.camera );

            }

        }

    }

`GLTFParser._addNodeRef(cache: any, index: Object3D): void`¶

JSDoc:

/**
     * Counts references to shared node / Object3D resources. These resources
     * can be reused, or "instantiated", at multiple nodes in the scene
     * hierarchy. Mesh, Camera, and Light instances are instantiated and must
     * be marked. Non-scenegraph resources (like Materials, Geometries, and
     * Textures) can be reused directly and are not marked here.
     *
     * Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
     *
     * @private
     * @param {Object} cache
     * @param {Object3D} index
     */

Parameters:

cache any
index Object3D

Returns: void

Code

_addNodeRef( cache, index ) {

        if ( index === undefined ) return;

        if ( cache.refs[ index ] === undefined ) {

            cache.refs[ index ] = cache.uses[ index ] = 0;

        }

        cache.refs[ index ] ++;

    }

`GLTFParser._getNodeRef(cache: any, index: number, object: any): any`¶

JSDoc:

/**
     * Returns a reference to a shared resource, cloning it if necessary.
     *
     * @private
     * @param {Object} cache
     * @param {number} index
     * @param {Object} object
     * @return {Object}
     */

Parameters:

cache any
index number
object any

Returns: any

Calls:

object.clone
this.associations.get
this.associations.set
original.children.entries
updateMappings

Internal Comments:

// Propagates mappings to the cloned object, prevents mappings on the (x2)
// original object from being lost. (x2)

Code

_getNodeRef( cache, index, object ) {

        if ( cache.refs[ index ] <= 1 ) return object;

        const ref = object.clone();

        // Propagates mappings to the cloned object, prevents mappings on the
        // original object from being lost.
        const updateMappings = ( original, clone ) => {

            const mappings = this.associations.get( original );
            if ( mappings != null ) {

                this.associations.set( clone, mappings );

            }

            for ( const [ i, child ] of original.children.entries() ) {

                updateMappings( child, clone.children[ i ] );

            }

        };

        updateMappings( object, ref );

        ref.name += '_instance_' + ( cache.uses[ index ] ++ );

        return ref;

    }

`GLTFParser._invokeOne(func: any): any`¶

Parameters:

func any

Returns: any

Calls:

Object.values
extensions.push
func

Code

_invokeOne( func ) {

        const extensions = Object.values( this.plugins );
        extensions.push( this );

        for ( let i = 0; i < extensions.length; i ++ ) {

            const result = func( extensions[ i ] );

            if ( result ) return result;

        }

        return null;

    }

`GLTFParser._invokeAll(func: any): any[]`¶

Parameters:

func any

Returns: any[]

Calls:

Object.values
extensions.unshift
func
pending.push

Code

_invokeAll( func ) {

        const extensions = Object.values( this.plugins );
        extensions.unshift( this );

        const pending = [];

        for ( let i = 0; i < extensions.length; i ++ ) {

            const result = func( extensions[ i ] );

            if ( result ) pending.push( result );

        }

        return pending;

    }

`GLTFParser.getDependency(type: string, index: number): Promise<any>`¶

JSDoc:

/**
     * Requests the specified dependency asynchronously, with caching.
     *
     * @private
     * @param {string} type
     * @param {number} index
     * @return {Promise<Object3D|Material|THREE.Texture|AnimationClip|ArrayBuffer|Object>}
     */

Parameters:

type string
index number

Returns: Promise<any>

Calls:

this.cache.get
this.loadScene
this._invokeOne
ext.loadNode
ext.loadMesh
this.loadAccessor
ext.loadBufferView
this.loadBuffer
ext.loadMaterial
ext.loadTexture
this.loadSkin
ext.loadAnimation
this.loadCamera
ext.getDependency
this.cache.add

Code

getDependency( type, index ) {

        const cacheKey = type + ':' + index;
        let dependency = this.cache.get( cacheKey );

        if ( ! dependency ) {

            switch ( type ) {

                case 'scene':
                    dependency = this.loadScene( index );
                    break;

                case 'node':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadNode && ext.loadNode( index );

                    } );
                    break;

                case 'mesh':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadMesh && ext.loadMesh( index );

                    } );
                    break;

                case 'accessor':
                    dependency = this.loadAccessor( index );
                    break;

                case 'bufferView':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadBufferView && ext.loadBufferView( index );

                    } );
                    break;

                case 'buffer':
                    dependency = this.loadBuffer( index );
                    break;

                case 'material':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadMaterial && ext.loadMaterial( index );

                    } );
                    break;

                case 'texture':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadTexture && ext.loadTexture( index );

                    } );
                    break;

                case 'skin':
                    dependency = this.loadSkin( index );
                    break;

                case 'animation':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadAnimation && ext.loadAnimation( index );

                    } );
                    break;

                case 'camera':
                    dependency = this.loadCamera( index );
                    break;

                default:
                    dependency = this._invokeOne( function ( ext ) {

                        return ext != this && ext.getDependency && ext.getDependency( type, index );

                    } );

                    if ( ! dependency ) {

                        throw new Error( 'Unknown type: ' + type );

                    }

                    break;

            }

            this.cache.add( cacheKey, dependency );

        }

        return dependency;

    }

`GLTFParser.getDependencies(type: string): Promise<any[]>`¶

JSDoc:

/**
     * Requests all dependencies of the specified type asynchronously, with caching.
     *
     * @private
     * @param {string} type
     * @return {Promise<Array<Object>>}
     */

Parameters:

type string

Returns: Promise<any[]>

Calls:

this.cache.get
Promise.all
defs.map
parser.getDependency
this.cache.add

Code

getDependencies( type ) {

        let dependencies = this.cache.get( type );

        if ( ! dependencies ) {

            const parser = this;
            const defs = this.json[ type + ( type === 'mesh' ? 'es' : 's' ) ] || [];

            dependencies = Promise.all( defs.map( function ( def, index ) {

                return parser.getDependency( type, index );

            } ) );

            this.cache.add( type, dependencies );

        }

        return dependencies;

    }

`GLTFParser.loadBuffer(bufferIndex: number): Promise<ArrayBuffer>`¶

JSDoc:

/**
     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
     *
     * @private
     * @param {number} bufferIndex
     * @return {Promise<ArrayBuffer>}
     */

Parameters:

bufferIndex number

Returns: Promise<ArrayBuffer>

Calls:

Promise.resolve
loader.load
LoaderUtils.resolveURL
reject

Internal Comments:

// If present, GLB container is required to be the first buffer.

Code

loadBuffer( bufferIndex ) {

        const bufferDef = this.json.buffers[ bufferIndex ];
        const loader = this.fileLoader;

        if ( bufferDef.type && bufferDef.type !== 'arraybuffer' ) {

            throw new Error( 'THREE.GLTFLoader: ' + bufferDef.type + ' buffer type is not supported.' );

        }

        // If present, GLB container is required to be the first buffer.
        if ( bufferDef.uri === undefined && bufferIndex === 0 ) {

            return Promise.resolve( this.extensions[ EXTENSIONS.KHR_BINARY_GLTF ].body );

        }

        const options = this.options;

        return new Promise( function ( resolve, reject ) {

            loader.load( LoaderUtils.resolveURL( bufferDef.uri, options.path ), resolve, undefined, function () {

                reject( new Error( 'THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".' ) );

            } );

        } );

    }

`GLTFParser.loadBufferView(bufferViewIndex: number): Promise<ArrayBuffer>`¶

JSDoc:

/**
     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
     *
     * @private
     * @param {number} bufferViewIndex
     * @return {Promise<ArrayBuffer>}
     */

Parameters:

bufferViewIndex number

Returns: Promise<ArrayBuffer>

Calls:

this.getDependency( 'buffer', bufferViewDef.buffer ).then
buffer.slice

Code

loadBufferView( bufferViewIndex ) {

        const bufferViewDef = this.json.bufferViews[ bufferViewIndex ];

        return this.getDependency( 'buffer', bufferViewDef.buffer ).then( function ( buffer ) {

            const byteLength = bufferViewDef.byteLength || 0;
            const byteOffset = bufferViewDef.byteOffset || 0;
            return buffer.slice( byteOffset, byteOffset + byteLength );

        } );

    }

`GLTFParser.loadAccessor(accessorIndex: number): Promise<any>`¶

JSDoc:

/**
     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
     *
     * @private
     * @param {number} accessorIndex
     * @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
     */

Parameters:

accessorIndex number

Returns: Promise<any>

Calls:

Promise.resolve
pendingBufferViews.push
this.getDependency
Promise.all( pendingBufferViews ).then
Math.floor
parser.cache.get
parser.cache.add
bufferAttribute.array.slice
bufferAttribute.setX
bufferAttribute.setY
bufferAttribute.setZ
bufferAttribute.setW

Internal Comments:

// For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12. (x2)
// The buffer is not interleaved if the stride is the item size in bytes.
// Each "slice" of the buffer, as defined by 'count' elements of 'byteStride' bytes, gets its own InterleavedBuffer (x2)
// This makes sure that IBA.count reflects accessor.count properly (x2)
// Integer parameters to IB/IBA are in array elements, not bytes. (x3)
// https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#sparse-accessors
// Avoid modifying the original ArrayBuffer, if the bufferView wasn't initialized with zeroes. (x3)
// Ignore normalized since we copy from sparse (x4)

Code

loadAccessor( accessorIndex ) {

        const parser = this;
        const json = this.json;

        const accessorDef = this.json.accessors[ accessorIndex ];

        if ( accessorDef.bufferView === undefined && accessorDef.sparse === undefined ) {

            const itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];
            const TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
            const normalized = accessorDef.normalized === true;

            const array = new TypedArray( accessorDef.count * itemSize );
            return Promise.resolve( new BufferAttribute( array, itemSize, normalized ) );

        }

        const pendingBufferViews = [];

        if ( accessorDef.bufferView !== undefined ) {

            pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.bufferView ) );

        } else {

            pendingBufferViews.push( null );

        }

        if ( accessorDef.sparse !== undefined ) {

            pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.indices.bufferView ) );
            pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.values.bufferView ) );

        }

        return Promise.all( pendingBufferViews ).then( function ( bufferViews ) {

            const bufferView = bufferViews[ 0 ];

            const itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];
            const TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];

            // For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12.
            const elementBytes = TypedArray.BYTES_PER_ELEMENT;
            const itemBytes = elementBytes * itemSize;
            const byteOffset = accessorDef.byteOffset || 0;
            const byteStride = accessorDef.bufferView !== undefined ? json.bufferViews[ accessorDef.bufferView ].byteStride : undefined;
            const normalized = accessorDef.normalized === true;
            let array, bufferAttribute;

            // The buffer is not interleaved if the stride is the item size in bytes.
            if ( byteStride && byteStride !== itemBytes ) {

                // Each "slice" of the buffer, as defined by 'count' elements of 'byteStride' bytes, gets its own InterleavedBuffer
                // This makes sure that IBA.count reflects accessor.count properly
                const ibSlice = Math.floor( byteOffset / byteStride );
                const ibCacheKey = 'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentType + ':' + ibSlice + ':' + accessorDef.count;
                let ib = parser.cache.get( ibCacheKey );

                if ( ! ib ) {

                    array = new TypedArray( bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes );

                    // Integer parameters to IB/IBA are in array elements, not bytes.
                    ib = new InterleavedBuffer( array, byteStride / elementBytes );

                    parser.cache.add( ibCacheKey, ib );

                }

                bufferAttribute = new InterleavedBufferAttribute( ib, itemSize, ( byteOffset % byteStride ) / elementBytes, normalized );

            } else {

                if ( bufferView === null ) {

                    array = new TypedArray( accessorDef.count * itemSize );

                } else {

                    array = new TypedArray( bufferView, byteOffset, accessorDef.count * itemSize );

                }

                bufferAttribute = new BufferAttribute( array, itemSize, normalized );

            }

            // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#sparse-accessors
            if ( accessorDef.sparse !== undefined ) {

                const itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR;
                const TypedArrayIndices = WEBGL_COMPONENT_TYPES[ accessorDef.sparse.indices.componentType ];

                const byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0;
                const byteOffsetValues = accessorDef.sparse.values.byteOffset || 0;

                const sparseIndices = new TypedArrayIndices( bufferViews[ 1 ], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices );
                const sparseValues = new TypedArray( bufferViews[ 2 ], byteOffsetValues, accessorDef.sparse.count * itemSize );

                if ( bufferView !== null ) {

                    // Avoid modifying the original ArrayBuffer, if the bufferView wasn't initialized with zeroes.
                    bufferAttribute = new BufferAttribute( bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized );

                }

                // Ignore normalized since we copy from sparse
                bufferAttribute.normalized = false;

                for ( let i = 0, il = sparseIndices.length; i < il; i ++ ) {

                    const index = sparseIndices[ i ];

                    bufferAttribute.setX( index, sparseValues[ i * itemSize ] );
                    if ( itemSize >= 2 ) bufferAttribute.setY( index, sparseValues[ i * itemSize + 1 ] );
                    if ( itemSize >= 3 ) bufferAttribute.setZ( index, sparseValues[ i * itemSize + 2 ] );
                    if ( itemSize >= 4 ) bufferAttribute.setW( index, sparseValues[ i * itemSize + 3 ] );
                    if ( itemSize >= 5 ) throw new Error( 'THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.' );

                }

                bufferAttribute.normalized = normalized;

            }

            return bufferAttribute;

        } );

    }

`GLTFParser.loadTexture(textureIndex: number): Promise<any>`¶

JSDoc:

/**
     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
     *
     * @private
     * @param {number} textureIndex
     * @return {Promise<THREE.Texture|null>}
     */

Parameters:

textureIndex number

Returns: Promise<any>

Calls:

options.manager.getHandler
this.loadTextureImage

Code

loadTexture( textureIndex ) {

        const json = this.json;
        const options = this.options;
        const textureDef = json.textures[ textureIndex ];
        const sourceIndex = textureDef.source;
        const sourceDef = json.images[ sourceIndex ];

        let loader = this.textureLoader;

        if ( sourceDef.uri ) {

            const handler = options.manager.getHandler( sourceDef.uri );
            if ( handler !== null ) loader = handler;

        }

        return this.loadTextureImage( textureIndex, sourceIndex, loader );

    }

`GLTFParser.loadTextureImage(textureIndex: any, sourceIndex: any, loader: any): any`¶

Parameters:

textureIndex any
sourceIndex any
loader any

Returns: any

Calls:

`this.loadImageSource( sourceIndex, loader ).then( function ( texture ) {

    texture.flipY = false;

    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 ] || {};

    texture.magFilter = WEBGL_FILTERS[ sampler.magFilter ] || LinearFilter;
    texture.minFilter = WEBGL_FILTERS[ sampler.minFilter ] || LinearMipmapLinearFilter;
    texture.wrapS = WEBGL_WRAPPINGS[ sampler.wrapS ] || RepeatWrapping;
    texture.wrapT = WEBGL_WRAPPINGS[ sampler.wrapT ] || RepeatWrapping;
    texture.generateMipmaps = ! texture.isCompressedTexture && texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter;

    parser.associations.set( texture, { textures: textureIndex } );

    return texture;

} ).catch`

Internal Comments:

// See https://github.com/mrdoob/three.js/issues/21559.

Code

loadTextureImage( textureIndex, sourceIndex, loader ) {

        const parser = this;
        const json = this.json;

        const textureDef = json.textures[ textureIndex ];
        const sourceDef = json.images[ sourceIndex ];

        const cacheKey = ( sourceDef.uri || sourceDef.bufferView ) + ':' + textureDef.sampler;

        if ( this.textureCache[ cacheKey ] ) {

            // See https://github.com/mrdoob/three.js/issues/21559.
            return this.textureCache[ cacheKey ];

        }

        const promise = this.loadImageSource( sourceIndex, loader ).then( function ( texture ) {

            texture.flipY = false;

            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 ] || {};

            texture.magFilter = WEBGL_FILTERS[ sampler.magFilter ] || LinearFilter;
            texture.minFilter = WEBGL_FILTERS[ sampler.minFilter ] || LinearMipmapLinearFilter;
            texture.wrapS = WEBGL_WRAPPINGS[ sampler.wrapS ] || RepeatWrapping;
            texture.wrapT = WEBGL_WRAPPINGS[ sampler.wrapT ] || RepeatWrapping;
            texture.generateMipmaps = ! texture.isCompressedTexture && texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter;

            parser.associations.set( texture, { textures: textureIndex } );

            return texture;

        } ).catch( function () {

            return null;

        } );

        this.textureCache[ cacheKey ] = promise;

        return promise;

    }

`GLTFParser.loadImageSource(sourceIndex: any, loader: any): any`¶

Parameters:

sourceIndex any
loader any

Returns: any

Calls:

this.sourceCache[ sourceIndex ].then
texture.clone
parser.getDependency( 'bufferView', sourceDef.bufferView ).then
URL.createObjectURL

`Promise.resolve( sourceURI ).then( function ( sourceURI ) {

    return new Promise( function ( resolve, reject ) {

        let onLoad = resolve;

        if ( loader.isImageBitmapLoader === true ) {

            onLoad = function ( imageBitmap ) {

                const texture = new Texture( imageBitmap );
                texture.needsUpdate = true;

                resolve( texture );

            };

        }

        loader.load( LoaderUtils.resolveURL( sourceURI, options.path ), onLoad, undefined, reject );

    } );

} ).then( function ( texture ) {

    // Clean up resources and configure Texture.

    if ( isObjectURL === true ) {

        URL.revokeObjectURL( sourceURI );

    }

    assignExtrasToUserData( texture, sourceDef );

    texture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType( sourceDef.uri );

    return texture;

} ).catch`

console.error

Internal Comments:

// Load binary image data from bufferView, if provided. (x3)
// Clean up resources and configure Texture.

Code

loadImageSource( sourceIndex, loader ) {

        const parser = this;
        const json = this.json;
        const options = this.options;

        if ( this.sourceCache[ sourceIndex ] !== undefined ) {

            return this.sourceCache[ sourceIndex ].then( ( texture ) => texture.clone() );

        }

        const sourceDef = json.images[ sourceIndex ];

        const URL = self.URL || self.webkitURL;

        let sourceURI = sourceDef.uri || '';
        let isObjectURL = false;

        if ( sourceDef.bufferView !== undefined ) {

            // Load binary image data from bufferView, if provided.

            sourceURI = parser.getDependency( 'bufferView', sourceDef.bufferView ).then( function ( bufferView ) {

                isObjectURL = true;
                const blob = new Blob( [ bufferView ], { type: sourceDef.mimeType } );
                sourceURI = URL.createObjectURL( blob );
                return sourceURI;

            } );

        } else if ( sourceDef.uri === undefined ) {

            throw new Error( 'THREE.GLTFLoader: Image ' + sourceIndex + ' is missing URI and bufferView' );

        }

        const promise = Promise.resolve( sourceURI ).then( function ( sourceURI ) {

            return new Promise( function ( resolve, reject ) {

                let onLoad = resolve;

                if ( loader.isImageBitmapLoader === true ) {

                    onLoad = function ( imageBitmap ) {

                        const texture = new Texture( imageBitmap );
                        texture.needsUpdate = true;

                        resolve( texture );

                    };

                }

                loader.load( LoaderUtils.resolveURL( sourceURI, options.path ), onLoad, undefined, reject );

            } );

        } ).then( function ( texture ) {

            // Clean up resources and configure Texture.

            if ( isObjectURL === true ) {

                URL.revokeObjectURL( sourceURI );

            }

            assignExtrasToUserData( texture, sourceDef );

            texture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType( sourceDef.uri );

            return texture;

        } ).catch( function ( error ) {

            console.error( 'THREE.GLTFLoader: Couldn\'t load texture', sourceURI );
            throw error;

        } );

        this.sourceCache[ sourceIndex ] = promise;
        return promise;

    }

`GLTFParser.assignTexture(materialParams: any, mapName: string, mapDef: any, colorSpace: string): Promise<Texture>`¶

JSDoc:

/**
     * Asynchronously assigns a texture to the given material parameters.
     *
     * @private
     * @param {Object} materialParams
     * @param {string} mapName
     * @param {Object} mapDef
     * @param {string} [colorSpace]
     * @return {Promise<Texture>}
     */

Parameters:

materialParams any
mapName string
mapDef any
colorSpace string

Returns: Promise<Texture>

Calls:

this.getDependency( 'texture', mapDef.index ).then
texture.clone
parser.associations.get
parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ].extendTexture
parser.associations.set

Code

assignTexture( materialParams, mapName, mapDef, colorSpace ) {

        const parser = this;

        return this.getDependency( 'texture', mapDef.index ).then( function ( texture ) {

            if ( ! texture ) return null;

            if ( mapDef.texCoord !== undefined && mapDef.texCoord > 0 ) {

                texture = texture.clone();
                texture.channel = mapDef.texCoord;

            }

            if ( parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] ) {

                const transform = mapDef.extensions !== undefined ? mapDef.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] : undefined;

                if ( transform ) {

                    const gltfReference = parser.associations.get( texture );
                    texture = parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ].extendTexture( texture, transform );
                    parser.associations.set( texture, gltfReference );

                }

            }

            if ( colorSpace !== undefined ) {

                texture.colorSpace = colorSpace;

            }

            materialParams[ mapName ] = texture;

            return texture;

        } );

    }

`GLTFParser.assignFinalMaterial(mesh: Object3D): void`¶

JSDoc:

/**
     * Assigns final material to a Mesh, Line, or Points instance. The instance
     * already has a material (generated from the glTF material options alone)
     * but reuse of the same glTF material may require multiple threejs materials
     * to accommodate different primitive types, defines, etc. New materials will
     * be created if necessary, and reused from a cache.
     *
     * @private
     * @param {Object3D} mesh Mesh, Line, or Points instance.
     */

Parameters:

mesh Object3D

Returns: void

Calls:

this.cache.get
Material.prototype.copy.call
pointsMaterial.color.copy
this.cache.add
lineMaterial.color.copy
material.clone
this.associations.set
this.associations.get

Internal Comments:

// Clone the material if it will be modified
// https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995

Code

assignFinalMaterial( mesh ) {

        const geometry = mesh.geometry;
        let material = mesh.material;

        const useDerivativeTangents = geometry.attributes.tangent === undefined;
        const useVertexColors = geometry.attributes.color !== undefined;
        const useFlatShading = geometry.attributes.normal === undefined;

        if ( mesh.isPoints ) {

            const cacheKey = 'PointsMaterial:' + material.uuid;

            let pointsMaterial = this.cache.get( cacheKey );

            if ( ! pointsMaterial ) {

                pointsMaterial = new PointsMaterial();
                Material.prototype.copy.call( pointsMaterial, material );
                pointsMaterial.color.copy( material.color );
                pointsMaterial.map = material.map;
                pointsMaterial.sizeAttenuation = false; // glTF spec says points should be 1px

                this.cache.add( cacheKey, pointsMaterial );

            }

            material = pointsMaterial;

        } else if ( mesh.isLine ) {

            const cacheKey = 'LineBasicMaterial:' + material.uuid;

            let lineMaterial = this.cache.get( cacheKey );

            if ( ! lineMaterial ) {

                lineMaterial = new LineBasicMaterial();
                Material.prototype.copy.call( lineMaterial, material );
                lineMaterial.color.copy( material.color );
                lineMaterial.map = material.map;

                this.cache.add( cacheKey, lineMaterial );

            }

            material = lineMaterial;

        }

        // Clone the material if it will be modified
        if ( useDerivativeTangents || useVertexColors || useFlatShading ) {

            let cacheKey = 'ClonedMaterial:' + material.uuid + ':';

            if ( useDerivativeTangents ) cacheKey += 'derivative-tangents:';
            if ( useVertexColors ) cacheKey += 'vertex-colors:';
            if ( useFlatShading ) cacheKey += 'flat-shading:';

            let cachedMaterial = this.cache.get( cacheKey );

            if ( ! cachedMaterial ) {

                cachedMaterial = material.clone();

                if ( useVertexColors ) cachedMaterial.vertexColors = true;
                if ( useFlatShading ) cachedMaterial.flatShading = true;

                if ( useDerivativeTangents ) {

                    // https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
                    if ( cachedMaterial.normalScale ) cachedMaterial.normalScale.y *= - 1;
                    if ( cachedMaterial.clearcoatNormalScale ) cachedMaterial.clearcoatNormalScale.y *= - 1;

                }

                this.cache.add( cacheKey, cachedMaterial );

                this.associations.set( cachedMaterial, this.associations.get( material ) );

            }

            material = cachedMaterial;

        }

        mesh.material = material;

    }

`GLTFParser.getMaterialType(): any`¶

Returns: any

Code

getMaterialType( /* materialIndex */ ) {

        return MeshStandardMaterial;

    }

`GLTFParser.loadMaterial(materialIndex: number): Promise<Material>`¶

JSDoc:

/**
     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
     *
     * @private
     * @param {number} materialIndex
     * @return {Promise<Material>}
     */

Parameters:

materialIndex number

Returns: Promise<Material>

Calls:

kmuExtension.getMaterialType
pending.push
kmuExtension.extendParams
Array.isArray
materialParams.color.setRGB
parser.assignTexture
this._invokeOne
ext.getMaterialType
Promise.all
this._invokeAll
ext.extendMaterialParams
materialParams.normalScale.set
new Color().setRGB
Promise.all( pending ).then
assignExtrasToUserData
parser.associations.set
addUnknownExtensionsToUserData

Internal Comments:

// Specification: (x2)
// https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#metallic-roughness-material (x2)
// See: https://github.com/mrdoob/three.js/issues/17706 (x4)

Code

loadMaterial( materialIndex ) {

        const parser = this;
        const json = this.json;
        const extensions = this.extensions;
        const materialDef = json.materials[ materialIndex ];

        let materialType;
        const materialParams = {};
        const materialExtensions = materialDef.extensions || {};

        const pending = [];

        if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ] ) {

            const kmuExtension = extensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ];
            materialType = kmuExtension.getMaterialType();
            pending.push( kmuExtension.extendParams( materialParams, materialDef, parser ) );

        } else {

            // Specification:
            // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#metallic-roughness-material

            const metallicRoughness = materialDef.pbrMetallicRoughness || {};

            materialParams.color = new Color( 1.0, 1.0, 1.0 );
            materialParams.opacity = 1.0;

            if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {

                const array = metallicRoughness.baseColorFactor;

                materialParams.color.setRGB( array[ 0 ], array[ 1 ], array[ 2 ], LinearSRGBColorSpace );
                materialParams.opacity = array[ 3 ];

            }

            if ( metallicRoughness.baseColorTexture !== undefined ) {

                pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) );

            }

            materialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0;
            materialParams.roughness = metallicRoughness.roughnessFactor !== undefined ? metallicRoughness.roughnessFactor : 1.0;

            if ( metallicRoughness.metallicRoughnessTexture !== undefined ) {

                pending.push( parser.assignTexture( materialParams, 'metalnessMap', metallicRoughness.metallicRoughnessTexture ) );
                pending.push( parser.assignTexture( materialParams, 'roughnessMap', metallicRoughness.metallicRoughnessTexture ) );

            }

            materialType = this._invokeOne( function ( ext ) {

                return ext.getMaterialType && ext.getMaterialType( materialIndex );

            } );

            pending.push( Promise.all( this._invokeAll( function ( ext ) {

                return ext.extendMaterialParams && ext.extendMaterialParams( materialIndex, materialParams );

            } ) ) );

        }

        if ( materialDef.doubleSided === true ) {

            materialParams.side = DoubleSide;

        }

        const alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE;

        if ( alphaMode === ALPHA_MODES.BLEND ) {

            materialParams.transparent = true;

            // See: https://github.com/mrdoob/three.js/issues/17706
            materialParams.depthWrite = false;

        } else {

            materialParams.transparent = false;

            if ( alphaMode === ALPHA_MODES.MASK ) {

                materialParams.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : 0.5;

            }

        }

        if ( materialDef.normalTexture !== undefined && materialType !== MeshBasicMaterial ) {

            pending.push( parser.assignTexture( materialParams, 'normalMap', materialDef.normalTexture ) );

            materialParams.normalScale = new Vector2( 1, 1 );

            if ( materialDef.normalTexture.scale !== undefined ) {

                const scale = materialDef.normalTexture.scale;

                materialParams.normalScale.set( scale, scale );

            }

        }

        if ( materialDef.occlusionTexture !== undefined && materialType !== MeshBasicMaterial ) {

            pending.push( parser.assignTexture( materialParams, 'aoMap', materialDef.occlusionTexture ) );

            if ( materialDef.occlusionTexture.strength !== undefined ) {

                materialParams.aoMapIntensity = materialDef.occlusionTexture.strength;

            }

        }

        if ( materialDef.emissiveFactor !== undefined && materialType !== MeshBasicMaterial ) {

            const emissiveFactor = materialDef.emissiveFactor;
            materialParams.emissive = new Color().setRGB( emissiveFactor[ 0 ], emissiveFactor[ 1 ], emissiveFactor[ 2 ], LinearSRGBColorSpace );

        }

        if ( materialDef.emissiveTexture !== undefined && materialType !== MeshBasicMaterial ) {

            pending.push( parser.assignTexture( materialParams, 'emissiveMap', materialDef.emissiveTexture, SRGBColorSpace ) );

        }

        return Promise.all( pending ).then( function () {

            const material = new materialType( materialParams );

            if ( materialDef.name ) material.name = materialDef.name;

            assignExtrasToUserData( material, materialDef );

            parser.associations.set( material, { materials: materialIndex } );

            if ( materialDef.extensions ) addUnknownExtensionsToUserData( extensions, material, materialDef );

            return material;

        } );

    }

`GLTFParser.createUniqueName(originalName: string): string`¶

JSDoc:

/**
     * When Object3D instances are targeted by animation, they need unique names.
     *
     * @private
     * @param {string} originalName
     * @return {string}
     */

Parameters:

originalName string

Returns: string

Calls:

PropertyBinding.sanitizeNodeName

Code

createUniqueName( originalName ) {

        const sanitizedName = PropertyBinding.sanitizeNodeName( originalName || '' );

        if ( sanitizedName in this.nodeNamesUsed ) {

            return sanitizedName + '_' + ( ++ this.nodeNamesUsed[ sanitizedName ] );

        } else {

            this.nodeNamesUsed[ sanitizedName ] = 0;

            return sanitizedName;

        }

    }

`GLTFParser.loadGeometries(primitives: GLTF.Primitive[]): Promise<BufferGeometry[]>`¶

JSDoc:

/**
     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
     *
     * Creates BufferGeometries from primitives.
     *
     * @private
     * @param {Array<GLTF.Primitive>} primitives
     * @return {Promise<Array<BufferGeometry>>}
     */

Parameters:

primitives GLTF.Primitive[]

Returns: Promise<BufferGeometry[]>

Calls:

extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ] .decodePrimitive( primitive, parser ) .then
addPrimitiveAttributes
createPrimitiveKey
pending.push
createDracoPrimitive
Promise.all

Internal Comments:

// See if we've already created this geometry (x2)
// Use the cached geometry if it exists (x4)
// Use DRACO geometry if available (x3)
// Otherwise create a new geometry (x3)
// Cache this geometry (x4)

Code

loadGeometries( primitives ) {

        const parser = this;
        const extensions = this.extensions;
        const cache = this.primitiveCache;

        function createDracoPrimitive( primitive ) {

            return extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ]
                .decodePrimitive( primitive, parser )
                .then( function ( geometry ) {

                    return addPrimitiveAttributes( geometry, primitive, parser );

                } );

        }

        const pending = [];

        for ( let i = 0, il = primitives.length; i < il; i ++ ) {

            const primitive = primitives[ i ];
            const cacheKey = createPrimitiveKey( primitive );

            // See if we've already created this geometry
            const cached = cache[ cacheKey ];

            if ( cached ) {

                // Use the cached geometry if it exists
                pending.push( cached.promise );

            } else {

                let geometryPromise;

                if ( primitive.extensions && primitive.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ] ) {

                    // Use DRACO geometry if available
                    geometryPromise = createDracoPrimitive( primitive );

                } else {

                    // Otherwise create a new geometry
                    geometryPromise = addPrimitiveAttributes( new BufferGeometry(), primitive, parser );

                }

                // Cache this geometry
                cache[ cacheKey ] = { primitive: primitive, promise: geometryPromise };

                pending.push( geometryPromise );

            }

        }

        return Promise.all( pending );

    }

`GLTFParser.loadMesh(meshIndex: number): Promise<any>`¶

JSDoc:

/**
     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
     *
     * @private
     * @param {number} meshIndex
     * @return {Promise<Group|Mesh|SkinnedMesh|Line|Points>}
     */

Parameters:

meshIndex number

Returns: Promise<any>

Calls:

createDefaultMaterial
this.getDependency
pending.push
parser.loadGeometries
Promise.all( pending ).then
results.slice
mesh.normalizeSkinWeights
toTrianglesDrawMode (from ../utils/BufferGeometryUtils.js)
Object.keys
updateMorphTargets
parser.createUniqueName
assignExtrasToUserData
addUnknownExtensionsToUserData
parser.assignFinalMaterial
meshes.push
parser.associations.set
group.add

Internal Comments:

// 1. create Mesh (x2)
// .isSkinnedMesh isn't in glTF spec. See ._markDefs() (x3)
// normalize skin weights to fix malformed assets (see #15319) (x4)

Code

loadMesh( meshIndex ) {

        const parser = this;
        const json = this.json;
        const extensions = this.extensions;

        const meshDef = json.meshes[ meshIndex ];
        const primitives = meshDef.primitives;

        const pending = [];

        for ( let i = 0, il = primitives.length; i < il; i ++ ) {

            const material = primitives[ i ].material === undefined
                ? createDefaultMaterial( this.cache )
                : this.getDependency( 'material', primitives[ i ].material );

            pending.push( material );

        }

        pending.push( parser.loadGeometries( primitives ) );

        return Promise.all( pending ).then( function ( results ) {

            const materials = results.slice( 0, results.length - 1 );
            const geometries = results[ results.length - 1 ];

            const meshes = [];

            for ( let i = 0, il = geometries.length; i < il; i ++ ) {

                const geometry = geometries[ i ];
                const primitive = primitives[ i ];

                // 1. create Mesh

                let mesh;

                const material = materials[ i ];

                if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLES ||
                        primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ||
                        primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ||
                        primitive.mode === undefined ) {

                    // .isSkinnedMesh isn't in glTF spec. See ._markDefs()
                    mesh = meshDef.isSkinnedMesh === true
                        ? new SkinnedMesh( geometry, material )
                        : new Mesh( geometry, material );

                    if ( mesh.isSkinnedMesh === true ) {

                        // normalize skin weights to fix malformed assets (see #15319)
                        mesh.normalizeSkinWeights();

                    }

                    if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ) {

                        mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleStripDrawMode );

                    } else if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ) {

                        mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleFanDrawMode );

                    }

                } else if ( primitive.mode === WEBGL_CONSTANTS.LINES ) {

                    mesh = new LineSegments( geometry, material );

                } else if ( primitive.mode === WEBGL_CONSTANTS.LINE_STRIP ) {

                    mesh = new Line( geometry, material );

                } else if ( primitive.mode === WEBGL_CONSTANTS.LINE_LOOP ) {

                    mesh = new LineLoop( geometry, material );

                } else if ( primitive.mode === WEBGL_CONSTANTS.POINTS ) {

                    mesh = new Points( geometry, material );

                } else {

                    throw new Error( 'THREE.GLTFLoader: Primitive mode unsupported: ' + primitive.mode );

                }

                if ( Object.keys( mesh.geometry.morphAttributes ).length > 0 ) {

                    updateMorphTargets( mesh, meshDef );

                }

                mesh.name = parser.createUniqueName( meshDef.name || ( 'mesh_' + meshIndex ) );

                assignExtrasToUserData( mesh, meshDef );

                if ( primitive.extensions ) addUnknownExtensionsToUserData( extensions, mesh, primitive );

                parser.assignFinalMaterial( mesh );

                meshes.push( mesh );

            }

            for ( let i = 0, il = meshes.length; i < il; i ++ ) {

                parser.associations.set( meshes[ i ], {
                    meshes: meshIndex,
                    primitives: i
                } );

            }

            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 ++ ) {

                group.add( meshes[ i ] );

            }

            return group;

        } );

    }

`GLTFParser.loadCamera(cameraIndex: number): Promise<THREE.Camera>`¶

JSDoc:

/**
     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
     *
     * @private
     * @param {number} cameraIndex
     * @return {Promise<THREE.Camera>}
     */

Parameters:

cameraIndex number

Returns: Promise<THREE.Camera>

Calls:

console.warn
MathUtils.radToDeg
this.createUniqueName
assignExtrasToUserData
Promise.resolve

Code

loadCamera( cameraIndex ) {

        let camera;
        const cameraDef = this.json.cameras[ cameraIndex ];
        const params = cameraDef[ cameraDef.type ];

        if ( ! params ) {

            console.warn( 'THREE.GLTFLoader: Missing camera parameters.' );
            return;

        }

        if ( cameraDef.type === 'perspective' ) {

            camera = new PerspectiveCamera( MathUtils.radToDeg( params.yfov ), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6 );

        } else if ( cameraDef.type === 'orthographic' ) {

            camera = new OrthographicCamera( - params.xmag, params.xmag, params.ymag, - params.ymag, params.znear, params.zfar );

        }

        if ( cameraDef.name ) camera.name = this.createUniqueName( cameraDef.name );

        assignExtrasToUserData( camera, cameraDef );

        return Promise.resolve( camera );

    }

`GLTFParser.loadSkin(skinIndex: number): Promise<Skeleton>`¶

JSDoc:

/**
     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
     *
     * @private
     * @param {number} skinIndex
     * @return {Promise<Skeleton>}
     */

Parameters:

skinIndex number

Returns: Promise<Skeleton>

Calls:

pending.push
this._loadNodeShallow
this.getDependency
Promise.all( pending ).then
results.pop
bones.push
mat.fromArray
boneInverses.push
console.warn

Internal Comments:

// Note that bones (joint nodes) may or may not be in the (x2)
// scene graph at this time. (x2)

Code

loadSkin( skinIndex ) {

        const skinDef = this.json.skins[ skinIndex ];

        const pending = [];

        for ( let i = 0, il = skinDef.joints.length; i < il; i ++ ) {

            pending.push( this._loadNodeShallow( skinDef.joints[ i ] ) );

        }

        if ( skinDef.inverseBindMatrices !== undefined ) {

            pending.push( this.getDependency( 'accessor', skinDef.inverseBindMatrices ) );

        } else {

            pending.push( null );

        }

        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 {

                    console.warn( 'THREE.GLTFLoader: Joint "%s" could not be found.', skinDef.joints[ i ] );

                }

            }

            return new Skeleton( bones, boneInverses );

        } );

    }

`GLTFParser.loadAnimation(animationIndex: number): Promise<AnimationClip>`¶

JSDoc:

/**
     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
     *
     * @private
     * @param {number} animationIndex
     * @return {Promise<AnimationClip>}
     */

Parameters:

animationIndex number

Returns: Promise<AnimationClip>

Calls:

pendingNodes.push
this.getDependency
pendingInputAccessors.push
pendingOutputAccessors.push
pendingSamplers.push
pendingTargets.push

`Promise.all( [

    Promise.all( pendingNodes ),
    Promise.all( pendingInputAccessors ),
    Promise.all( pendingOutputAccessors ),
    Promise.all( pendingSamplers ),
    Promise.all( pendingTargets )

] ).then`

node.updateMatrix
parser._createAnimationTracks
tracks.push

Code

loadAnimation( animationIndex ) {

        const json = this.json;
        const parser = this;

        const animationDef = json.animations[ animationIndex ];
        const animationName = animationDef.name ? animationDef.name : 'animation_' + animationIndex;

        const pendingNodes = [];
        const pendingInputAccessors = [];
        const pendingOutputAccessors = [];
        const pendingSamplers = [];
        const pendingTargets = [];

        for ( let i = 0, il = animationDef.channels.length; i < il; i ++ ) {

            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;

            if ( target.node === undefined ) continue;

            pendingNodes.push( this.getDependency( 'node', name ) );
            pendingInputAccessors.push( this.getDependency( 'accessor', input ) );
            pendingOutputAccessors.push( this.getDependency( 'accessor', output ) );
            pendingSamplers.push( sampler );
            pendingTargets.push( target );

        }

        return Promise.all( [

            Promise.all( pendingNodes ),
            Promise.all( pendingInputAccessors ),
            Promise.all( pendingOutputAccessors ),
            Promise.all( pendingSamplers ),
            Promise.all( pendingTargets )

        ] ).then( function ( dependencies ) {

            const nodes = dependencies[ 0 ];
            const inputAccessors = dependencies[ 1 ];
            const outputAccessors = dependencies[ 2 ];
            const samplers = dependencies[ 3 ];
            const targets = dependencies[ 4 ];

            const tracks = [];

            for ( let i = 0, il = nodes.length; i < il; i ++ ) {

                const node = nodes[ i ];
                const inputAccessor = inputAccessors[ i ];
                const outputAccessor = outputAccessors[ i ];
                const sampler = samplers[ i ];
                const target = targets[ i ];

                if ( node === undefined ) continue;

                if ( node.updateMatrix ) {

                    node.updateMatrix();

                }

                const createdTracks = parser._createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target );

                if ( createdTracks ) {

                    for ( let k = 0; k < createdTracks.length; k ++ ) {

                        tracks.push( createdTracks[ k ] );

                    }

                }

            }

            return new AnimationClip( animationName, undefined, tracks );

        } );

    }

`GLTFParser.createNodeMesh(nodeIndex: any): Promise<any>`¶

Parameters:

nodeIndex any

Returns: Promise<any>

Calls:

parser.getDependency( 'mesh', nodeDef.mesh ).then
parser._getNodeRef
node.traverse

Internal Comments:

// if weights are provided on the node, override weights on the mesh.

Code

createNodeMesh( nodeIndex ) {

        const json = this.json;
        const parser = this;
        const nodeDef = json.nodes[ nodeIndex ];

        if ( nodeDef.mesh === undefined ) return null;

        return parser.getDependency( 'mesh', nodeDef.mesh ).then( function ( mesh ) {

            const node = parser._getNodeRef( parser.meshCache, nodeDef.mesh, mesh );

            // if weights are provided on the node, override weights on the mesh.
            if ( nodeDef.weights !== undefined ) {

                node.traverse( function ( o ) {

                    if ( ! o.isMesh ) return;

                    for ( let i = 0, il = nodeDef.weights.length; i < il; i ++ ) {

                        o.morphTargetInfluences[ i ] = nodeDef.weights[ i ];

                    }

                } );

            }

            return node;

        } );

    }

`GLTFParser.loadNode(nodeIndex: number): Promise<Object3D>`¶

JSDoc:

/**
     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
     *
     * @private
     * @param {number} nodeIndex
     * @return {Promise<Object3D>}
     */

Parameters:

nodeIndex number

Returns: Promise<Object3D>

Calls:

parser._loadNodeShallow
childPending.push
parser.getDependency
Promise.resolve
Promise.all( [ nodePending, Promise.all( childPending ), skeletonPending ] ).then
node.traverse
mesh.bind
node.add

Internal Comments:

// This full traverse should be fine because (x4)
// child glTF nodes have not been added to this node yet. (x4)

Code

loadNode( nodeIndex ) {

        const json = this.json;
        const parser = this;

        const nodeDef = json.nodes[ nodeIndex ];

        const nodePending = parser._loadNodeShallow( nodeIndex );

        const childPending = [];
        const childrenDef = nodeDef.children || [];

        for ( let i = 0, il = childrenDef.length; i < il; i ++ ) {

            childPending.push( parser.getDependency( 'node', childrenDef[ i ] ) );

        }

        const skeletonPending = nodeDef.skin === undefined
            ? Promise.resolve( null )
            : parser.getDependency( 'skin', nodeDef.skin );

        return Promise.all( [
            nodePending,
            Promise.all( childPending ),
            skeletonPending
        ] ).then( function ( results ) {

            const node = results[ 0 ];
            const children = results[ 1 ];
            const skeleton = results[ 2 ];

            if ( skeleton !== null ) {

                // This full traverse should be fine because
                // child glTF nodes have not been added to this node yet.
                node.traverse( function ( mesh ) {

                    if ( ! mesh.isSkinnedMesh ) return;

                    mesh.bind( skeleton, _identityMatrix );

                } );

            }

            for ( let i = 0, il = children.length; i < il; i ++ ) {

                node.add( children[ i ] );

            }

            return node;

        } );

    }

`GLTFParser._loadNodeShallow(nodeIndex: any): any`¶

Parameters:

nodeIndex any

Returns: any

Calls:

parser.createUniqueName
parser._invokeOne
ext.createNodeMesh
pending.push
parser.getDependency( 'camera', nodeDef.camera ).then
parser._getNodeRef
`parser._invokeAll( function ( ext ) {
```
    return ext.createNodeAttachment && ext.createNodeAttachment( nodeIndex );

} ).forEach`
```
- Promise.all( pending ).then
- node.add
- assignExtrasToUserData
- addUnknownExtensionsToUserData
- matrix.fromArray
- node.applyMatrix4
- node.position.fromArray
- node.quaternion.fromArray
- node.scale.fromArray
- parser.associations.has
- parser.associations.set
- parser.associations.get

Internal Comments:

// This method is called from .loadNode() and .loadSkin().
// Cache a node to avoid duplication.
// reserve node's name before its dependencies, so the root has the intended name. (x2)
// .isBone isn't in glTF spec. See ._markDefs

Code

_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 );

        } );

        if ( meshPromise ) {

            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;

            // .isBone isn't in glTF spec. See ._markDefs
            if ( nodeDef.isBone === true ) {

                node = new Bone();

            } else if ( objects.length > 1 ) {

                node = new Group();

            } else if ( objects.length === 1 ) {

                node = objects[ 0 ];

            } else {

                node = new Object3D();

            }

            if ( node !== objects[ 0 ] ) {

                for ( let i = 0, il = objects.length; i < il; i ++ ) {

                    node.add( objects[ i ] );

                }

            }

            if ( nodeDef.name ) {

                node.userData.name = nodeDef.name;
                node.name = nodeName;

            }

            assignExtrasToUserData( node, nodeDef );

            if ( nodeDef.extensions ) addUnknownExtensionsToUserData( extensions, node, nodeDef );

            if ( nodeDef.matrix !== undefined ) {

                const matrix = new Matrix4();
                matrix.fromArray( nodeDef.matrix );
                node.applyMatrix4( matrix );

            } else {

                if ( nodeDef.translation !== undefined ) {

                    node.position.fromArray( nodeDef.translation );

                }

                if ( nodeDef.rotation !== undefined ) {

                    node.quaternion.fromArray( nodeDef.rotation );

                }

                if ( nodeDef.scale !== undefined ) {

                    node.scale.fromArray( nodeDef.scale );

                }

            }

            if ( ! parser.associations.has( node ) ) {

                parser.associations.set( node, {} );

            } else if ( nodeDef.mesh !== undefined && parser.meshCache.refs[ nodeDef.mesh ] > 1 ) {

                const mapping = parser.associations.get( node );
                parser.associations.set( node, { ...mapping } );

            }

            parser.associations.get( node ).nodes = nodeIndex;

            return node;

        } );

        return this.nodeCache[ nodeIndex ];

    }

`GLTFParser.loadScene(sceneIndex: number): Promise<Group>`¶

JSDoc:

/**
     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
     *
     * @private
     * @param {number} sceneIndex
     * @return {Promise<Group>}
     */

Parameters:

sceneIndex number

Returns: Promise<Group>

Calls:

parser.createUniqueName
assignExtrasToUserData
addUnknownExtensionsToUserData
pending.push
parser.getDependency
Promise.all( pending ).then
scene.add
reducedAssociations.set
node.traverse
parser.associations.get
reduceAssociations

Internal Comments:

// Loader returns Group, not Scene. (x2)
// See: https://github.com/mrdoob/three.js/issues/18342#issuecomment-578981172 (x2)
// Removes dangling associations, associations that reference a node that (x2)
// didn't make it into the scene. (x2)

Code

loadScene( sceneIndex ) {

        const extensions = this.extensions;
        const sceneDef = this.json.scenes[ sceneIndex ];
        const parser = this;

        // Loader returns Group, not Scene.
        // See: https://github.com/mrdoob/three.js/issues/18342#issuecomment-578981172
        const scene = new Group();
        if ( sceneDef.name ) scene.name = parser.createUniqueName( sceneDef.name );

        assignExtrasToUserData( scene, sceneDef );

        if ( sceneDef.extensions ) addUnknownExtensionsToUserData( extensions, scene, sceneDef );

        const nodeIds = sceneDef.nodes || [];

        const pending = [];

        for ( let i = 0, il = nodeIds.length; i < il; i ++ ) {

            pending.push( parser.getDependency( 'node', nodeIds[ i ] ) );

        }

        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.
            const reduceAssociations = ( node ) => {

                const reducedAssociations = new Map();

                for ( const [ key, value ] of parser.associations ) {

                    if ( key instanceof Material || key instanceof Texture ) {

                        reducedAssociations.set( key, value );

                    }

                }

                node.traverse( ( node ) => {

                    const mappings = parser.associations.get( node );

                    if ( mappings != null ) {

                        reducedAssociations.set( node, mappings );

                    }

                } );

                return reducedAssociations;

            };

            parser.associations = reduceAssociations( scene );

            return scene;

        } );

    }

`GLTFParser._createAnimationTracks(node: any, inputAccessor: any, outputAccessor: any, sampler: any, target: any): any[]`¶

Parameters:

node any
inputAccessor any
outputAccessor any
sampler any
target any

Returns: any[]

Calls:

node.traverse
targetNames.push
this._getArrayFromAccessor
this._createCubicSplineTrackInterpolant
tracks.push

Internal Comments:

// Override interpolation with custom factory method.

Code

_createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target ) {

        const tracks = [];

        const targetName = node.name ? node.name : node.uuid;
        const targetNames = [];

        if ( PATH_PROPERTIES[ target.path ] === PATH_PROPERTIES.weights ) {

            node.traverse( function ( object ) {

                if ( object.morphTargetInfluences ) {

                    targetNames.push( object.name ? object.name : object.uuid );

                }

            } );

        } else {

            targetNames.push( targetName );

        }

        let TypedKeyframeTrack;

        switch ( PATH_PROPERTIES[ target.path ] ) {

            case PATH_PROPERTIES.weights:

                TypedKeyframeTrack = NumberKeyframeTrack;
                break;

            case PATH_PROPERTIES.rotation:

                TypedKeyframeTrack = QuaternionKeyframeTrack;
                break;

            case PATH_PROPERTIES.translation:
            case PATH_PROPERTIES.scale:

                TypedKeyframeTrack = VectorKeyframeTrack;
                break;

            default:

                switch ( outputAccessor.itemSize ) {

                    case 1:
                        TypedKeyframeTrack = NumberKeyframeTrack;
                        break;
                    case 2:
                    case 3:
                    default:
                        TypedKeyframeTrack = VectorKeyframeTrack;
                        break;

                }

                break;

        }

        const interpolation = sampler.interpolation !== undefined ? INTERPOLATION[ sampler.interpolation ] : InterpolateLinear;


        const outputArray = this._getArrayFromAccessor( outputAccessor );

        for ( let j = 0, jl = targetNames.length; j < jl; j ++ ) {

            const track = new TypedKeyframeTrack(
                targetNames[ j ] + '.' + PATH_PROPERTIES[ target.path ],
                inputAccessor.array,
                outputArray,
                interpolation
            );

            // Override interpolation with custom factory method.
            if ( sampler.interpolation === 'CUBICSPLINE' ) {

                this._createCubicSplineTrackInterpolant( track );

            }

            tracks.push( track );

        }

        return tracks;

    }

`GLTFParser._getArrayFromAccessor(accessor: any): any`¶

Parameters:

accessor any

Returns: any

Calls:

getNormalizedComponentScale

Code

_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;

    }

`GLTFParser._createCubicSplineTrackInterpolant(track: any): void`¶

Parameters:

track any

Returns: void

Calls:

this.getValueSize

Internal Comments:

// A CUBICSPLINE keyframe in glTF has three output values for each input value, (x2)
// representing inTangent, splineVertex, and outTangent. As a result, track.getValueSize() (x2)
// must be divided by three to get the interpolant's sampleSize argument. (x2)
// Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants. (x5)

Code

_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;

    }

`updateMappings(original: any, clone: any): void`¶

Parameters:

original any
clone any

Returns: void

Calls:

this.associations.get
this.associations.set
original.children.entries
updateMappings

Code

( original, clone ) => {

            const mappings = this.associations.get( original );
            if ( mappings != null ) {

                this.associations.set( clone, mappings );

            }

            for ( const [ i, child ] of original.children.entries() ) {

                updateMappings( child, clone.children[ i ] );

            }

        }

`createDracoPrimitive(primitive: any): any`¶

Parameters:

primitive any

Returns: any

Calls:

extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ] .decodePrimitive( primitive, parser ) .then
addPrimitiveAttributes

Code

function createDracoPrimitive( primitive ) {

            return extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ]
                .decodePrimitive( primitive, parser )
                .then( function ( geometry ) {

                    return addPrimitiveAttributes( geometry, primitive, parser );

                } );

        }

`reduceAssociations(node: any): Map<any, any>`¶

Parameters:

node any

Returns: Map<any, any>

Calls:

reducedAssociations.set
node.traverse
parser.associations.get

Code

( node ) => {

                const reducedAssociations = new Map();

                for ( const [ key, value ] of parser.associations ) {

                    if ( key instanceof Material || key instanceof Texture ) {

                        reducedAssociations.set( key, value );

                    }

                }

                node.traverse( ( node ) => {

                    const mappings = parser.associations.get( node );

                    if ( mappings != null ) {

                        reducedAssociations.set( node, mappings );

                    }

                } );

                return reducedAssociations;

            }

`computeBounds(geometry: BufferGeometry, primitiveDef: GLTF.Primitive, parser: GLTFParser): void`¶

JSDoc:

/**
 *
 * @private
 * @param {BufferGeometry} geometry
 * @param {GLTF.Primitive} primitiveDef
 * @param {GLTFParser} parser
 */

Parameters:

geometry BufferGeometry
primitiveDef GLTF.Primitive
parser GLTFParser

Returns: void

Calls:

box.set
getNormalizedComponentScale
box.min.multiplyScalar
box.max.multiplyScalar
console.warn
vector.setX
Math.max
Math.abs
vector.setY
vector.setZ
vector.multiplyScalar
maxDisplacement.max
box.expandByVector
box.getCenter
box.min.distanceTo

Internal Comments:

// glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement. (x2)
// we need to get max of absolute components because target weight is [-1,1] (x4)
// Note: this assumes that the sum of all weights is at most 1. This isn't quite correct - it's more conservative (x4)
// to assume that each target can have a max weight of 1. However, for some use cases - notably, when morph targets (x4)
// are used to implement key-frame animations and as such only two are active at a time - this results in very large (x4)
// boxes. So for now we make a box that's sometimes a touch too small but is hopefully mostly of reasonable size. (x4)
// As per comment above this box isn't conservative, but has a reasonable size for a very large number of morph targets. (x4)

Code

function computeBounds( geometry, primitiveDef, parser ) {

    const attributes = primitiveDef.attributes;

    const box = new Box3();

    if ( attributes.POSITION !== undefined ) {

        const accessor = parser.json.accessors[ attributes.POSITION ];

        const min = accessor.min;
        const max = accessor.max;

        // glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.

        if ( min !== undefined && max !== undefined ) {

            box.set(
                new Vector3( min[ 0 ], min[ 1 ], min[ 2 ] ),
                new Vector3( max[ 0 ], max[ 1 ], max[ 2 ] )
            );

            if ( accessor.normalized ) {

                const boxScale = getNormalizedComponentScale( WEBGL_COMPONENT_TYPES[ accessor.componentType ] );
                box.min.multiplyScalar( boxScale );
                box.max.multiplyScalar( boxScale );

            }

        } else {

            console.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' );

            return;

        }

    } else {

        return;

    }

    const targets = primitiveDef.targets;

    if ( targets !== undefined ) {

        const maxDisplacement = new Vector3();
        const vector = new Vector3();

        for ( let i = 0, il = targets.length; i < il; i ++ ) {

            const target = targets[ i ];

            if ( target.POSITION !== undefined ) {

                const accessor = parser.json.accessors[ target.POSITION ];
                const min = accessor.min;
                const max = accessor.max;

                // glTF requires 'min' and 'max', but VRM (which extends glTF) currently ignores that requirement.

                if ( min !== undefined && max !== undefined ) {

                    // we need to get max of absolute components because target weight is [-1,1]
                    vector.setX( Math.max( Math.abs( min[ 0 ] ), Math.abs( max[ 0 ] ) ) );
                    vector.setY( Math.max( Math.abs( min[ 1 ] ), Math.abs( max[ 1 ] ) ) );
                    vector.setZ( Math.max( Math.abs( min[ 2 ] ), Math.abs( max[ 2 ] ) ) );


                    if ( accessor.normalized ) {

                        const boxScale = getNormalizedComponentScale( WEBGL_COMPONENT_TYPES[ accessor.componentType ] );
                        vector.multiplyScalar( boxScale );

                    }

                    // Note: this assumes that the sum of all weights is at most 1. This isn't quite correct - it's more conservative
                    // to assume that each target can have a max weight of 1. However, for some use cases - notably, when morph targets
                    // are used to implement key-frame animations and as such only two are active at a time - this results in very large
                    // boxes. So for now we make a box that's sometimes a touch too small but is hopefully mostly of reasonable size.
                    maxDisplacement.max( vector );

                } else {

                    console.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' );

                }

            }

        }

        // As per comment above this box isn't conservative, but has a reasonable size for a very large number of morph targets.
        box.expandByVector( maxDisplacement );

    }

    geometry.boundingBox = box;

    const sphere = new Sphere();

    box.getCenter( sphere.center );
    sphere.radius = box.min.distanceTo( box.max ) / 2;

    geometry.boundingSphere = sphere;

}

`addPrimitiveAttributes(geometry: BufferGeometry, primitiveDef: GLTF.Primitive, parser: GLTFParser): Promise<BufferGeometry>`¶

JSDoc:

/**
 *
 * @private
 * @param {BufferGeometry} geometry
 * @param {GLTF.Primitive} primitiveDef
 * @param {GLTFParser} parser
 * @return {Promise<BufferGeometry>}
 */

Parameters:

geometry BufferGeometry
primitiveDef GLTF.Primitive
parser GLTFParser

Returns: Promise<BufferGeometry>

Calls:

parser.getDependency( 'accessor', accessorIndex ) .then
geometry.setAttribute
gltfAttributeName.toLowerCase
pending.push
assignAttributeAccessor
parser.getDependency( 'accessor', primitiveDef.indices ).then
geometry.setIndex
console.warn
assignExtrasToUserData
computeBounds
Promise.all( pending ).then
addMorphTargets

Internal Comments:

// Skip attributes already provided by e.g. Draco extension.

Code

function addPrimitiveAttributes( geometry, primitiveDef, parser ) {

    const attributes = primitiveDef.attributes;

    const pending = [];

    function assignAttributeAccessor( accessorIndex, attributeName ) {

        return parser.getDependency( 'accessor', accessorIndex )
            .then( function ( accessor ) {

                geometry.setAttribute( attributeName, accessor );

            } );

    }

    for ( const gltfAttributeName in attributes ) {

        const threeAttributeName = ATTRIBUTES[ gltfAttributeName ] || gltfAttributeName.toLowerCase();

        // Skip attributes already provided by e.g. Draco extension.
        if ( threeAttributeName in geometry.attributes ) continue;

        pending.push( assignAttributeAccessor( attributes[ gltfAttributeName ], threeAttributeName ) );

    }

    if ( primitiveDef.indices !== undefined && ! geometry.index ) {

        const accessor = parser.getDependency( 'accessor', primitiveDef.indices ).then( function ( accessor ) {

            geometry.setIndex( accessor );

        } );

        pending.push( accessor );

    }

    if ( ColorManagement.workingColorSpace !== LinearSRGBColorSpace && 'COLOR_0' in attributes ) {

        console.warn( `THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${ColorManagement.workingColorSpace}" not supported.` );

    }

    assignExtrasToUserData( geometry, primitiveDef );

    computeBounds( geometry, primitiveDef, parser );

    return Promise.all( pending ).then( function () {

        return primitiveDef.targets !== undefined
            ? addMorphTargets( geometry, primitiveDef.targets, parser )
            : geometry;

    } );

}

`assignAttributeAccessor(accessorIndex: any, attributeName: any): Promise<void>`¶

Parameters:

accessorIndex any
attributeName any

Returns: Promise<void>

Calls:

parser.getDependency( 'accessor', accessorIndex ) .then
geometry.setAttribute

Code

function assignAttributeAccessor( accessorIndex, attributeName ) {

        return parser.getDependency( 'accessor', accessorIndex )
            .then( function ( accessor ) {

                geometry.setAttribute( attributeName, accessor );

            } );

    }

Classes¶

`GLTFLoader`¶

Class Code

class GLTFLoader extends Loader {

    /**
     * Constructs a new glTF loader.
     *
     * @param {LoadingManager} [manager] - The loading manager.
     */
    constructor( manager ) {

        super( manager );

        this.dracoLoader = null;
        this.ktx2Loader = null;
        this.meshoptDecoder = null;

        this.pluginCallbacks = [];

        this.register( function ( parser ) {

            return new GLTFMaterialsClearcoatExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFMaterialsDispersionExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFTextureBasisUExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFTextureWebPExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFTextureAVIFExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFMaterialsSheenExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFMaterialsTransmissionExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFMaterialsVolumeExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFMaterialsIorExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFMaterialsEmissiveStrengthExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFMaterialsSpecularExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFMaterialsIridescenceExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFMaterialsAnisotropyExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFMaterialsBumpExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFLightsExtension( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFMeshoptCompression( parser );

        } );

        this.register( function ( parser ) {

            return new GLTFMeshGpuInstancing( parser );

        } );

    }

    /**
     * Starts loading from the given URL and passes the loaded glTF asset
     * to the `onLoad()` callback.
     *
     * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
     * @param {function(GLTFLoader~LoadObject)} onLoad - Executed when the loading process has been finished.
     * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
     * @param {onErrorCallback} onError - Executed when errors occur.
     */
    load( url, onLoad, onProgress, onError ) {

        const scope = this;

        let resourcePath;

        if ( this.resourcePath !== '' ) {

            resourcePath = this.resourcePath;

        } else if ( this.path !== '' ) {

            // If a base path is set, resources will be relative paths from that plus the relative path of the gltf file
            // Example  path = 'https://my-cnd-server.com/', url = 'assets/models/model.gltf'
            // resourcePath = 'https://my-cnd-server.com/assets/models/'
            // referenced resource 'model.bin' will be loaded from 'https://my-cnd-server.com/assets/models/model.bin'
            // referenced resource '../textures/texture.png' will be loaded from 'https://my-cnd-server.com/assets/textures/texture.png'
            const relativeUrl = LoaderUtils.extractUrlBase( url );
            resourcePath = LoaderUtils.resolveURL( relativeUrl, this.path );

        } else {

            resourcePath = LoaderUtils.extractUrlBase( url );

        }

        // Tells the LoadingManager to track an extra item, which resolves after
        // the model is fully loaded. This means the count of items loaded will
        // be incorrect, but ensures manager.onLoad() does not fire early.
        this.manager.itemStart( url );

        const _onError = function ( e ) {

            if ( onError ) {

                onError( e );

            } else {

                console.error( e );

            }

            scope.manager.itemError( url );
            scope.manager.itemEnd( url );

        };

        const loader = new FileLoader( this.manager );

        loader.setPath( this.path );
        loader.setResponseType( 'arraybuffer' );
        loader.setRequestHeader( this.requestHeader );
        loader.setWithCredentials( this.withCredentials );

        loader.load( url, function ( data ) {

            try {

                scope.parse( data, resourcePath, function ( gltf ) {

                    onLoad( gltf );

                    scope.manager.itemEnd( url );

                }, _onError );

            } catch ( e ) {

                _onError( e );

            }

        }, onProgress, _onError );

    }

    /**
     * Sets the given Draco loader to this loader. Required for decoding assets
     * compressed with the `KHR_draco_mesh_compression` extension.
     *
     * @param {DRACOLoader} dracoLoader - The Draco loader to set.
     * @return {GLTFLoader} A reference to this loader.
     */
    setDRACOLoader( dracoLoader ) {

        this.dracoLoader = dracoLoader;
        return this;

    }

    /**
     * Sets the given KTX2 loader to this loader. Required for loading KTX2
     * compressed textures.
     *
     * @param {KTX2Loader} ktx2Loader - The KTX2 loader to set.
     * @return {GLTFLoader} A reference to this loader.
     */
    setKTX2Loader( ktx2Loader ) {

        this.ktx2Loader = ktx2Loader;
        return this;

    }

    /**
     * Sets the given meshopt decoder. Required for decoding assets
     * compressed with the `EXT_meshopt_compression` extension.
     *
     * @param {Object} meshoptDecoder - The meshopt decoder to set.
     * @return {GLTFLoader} A reference to this loader.
     */
    setMeshoptDecoder( meshoptDecoder ) {

        this.meshoptDecoder = meshoptDecoder;
        return this;

    }

    /**
     * Registers a plugin callback. This API is internally used to implement the various
     * glTF extensions but can also used by third-party code to add additional logic
     * to the loader.
     *
     * @param {function(parser:GLTFParser)} callback - The callback function to register.
     * @return {GLTFLoader} A reference to this loader.
     */
    register( callback ) {

        if ( this.pluginCallbacks.indexOf( callback ) === - 1 ) {

            this.pluginCallbacks.push( callback );

        }

        return this;

    }

    /**
     * Unregisters a plugin callback.
     *
     * @param {Function} callback - The callback function to unregister.
     * @return {GLTFLoader} A reference to this loader.
     */
    unregister( callback ) {

        if ( this.pluginCallbacks.indexOf( callback ) !== - 1 ) {

            this.pluginCallbacks.splice( this.pluginCallbacks.indexOf( callback ), 1 );

        }

        return this;

    }

    /**
     * Parses the given FBX data and returns the resulting group.
     *
     * @param {string|ArrayBuffer} data - The raw glTF data.
     * @param {string} path - The URL base path.
     * @param {function(GLTFLoader~LoadObject)} onLoad - Executed when the loading process has been finished.
     * @param {onErrorCallback} onError - Executed when errors occur.
     */
    parse( data, path, onLoad, onError ) {

        let json;
        const extensions = {};
        const plugins = {};
        const textDecoder = new TextDecoder();

        if ( typeof data === 'string' ) {

            json = JSON.parse( data );

        } else if ( data instanceof ArrayBuffer ) {

            const magic = textDecoder.decode( new Uint8Array( data, 0, 4 ) );

            if ( magic === BINARY_EXTENSION_HEADER_MAGIC ) {

                try {

                    extensions[ EXTENSIONS.KHR_BINARY_GLTF ] = new GLTFBinaryExtension( data );

                } catch ( error ) {

                    if ( onError ) onError( error );
                    return;

                }

                json = JSON.parse( extensions[ EXTENSIONS.KHR_BINARY_GLTF ].content );

            } else {

                json = JSON.parse( textDecoder.decode( data ) );

            }

        } else {

            json = data;

        }

        if ( json.asset === undefined || json.asset.version[ 0 ] < 2 ) {

            if ( onError ) onError( new Error( 'THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported.' ) );
            return;

        }

        const parser = new GLTFParser( json, {

            path: path || this.resourcePath || '',
            crossOrigin: this.crossOrigin,
            requestHeader: this.requestHeader,
            manager: this.manager,
            ktx2Loader: this.ktx2Loader,
            meshoptDecoder: this.meshoptDecoder

        } );

        parser.fileLoader.setRequestHeader( this.requestHeader );

        for ( let i = 0; i < this.pluginCallbacks.length; i ++ ) {

            const plugin = this.pluginCallbacks[ i ]( parser );

            if ( ! plugin.name ) console.error( 'THREE.GLTFLoader: Invalid plugin found: missing name' );

            plugins[ plugin.name ] = plugin;

            // Workaround to avoid determining as unknown extension
            // in addUnknownExtensionsToUserData().
            // Remove this workaround if we move all the existing
            // extension handlers to plugin system
            extensions[ plugin.name ] = true;

        }

        if ( json.extensionsUsed ) {

            for ( let i = 0; i < json.extensionsUsed.length; ++ i ) {

                const extensionName = json.extensionsUsed[ i ];
                const extensionsRequired = json.extensionsRequired || [];

                switch ( extensionName ) {

                    case EXTENSIONS.KHR_MATERIALS_UNLIT:
                        extensions[ extensionName ] = new GLTFMaterialsUnlitExtension();
                        break;

                    case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
                        extensions[ extensionName ] = new GLTFDracoMeshCompressionExtension( json, this.dracoLoader );
                        break;

                    case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
                        extensions[ extensionName ] = new GLTFTextureTransformExtension();
                        break;

                    case EXTENSIONS.KHR_MESH_QUANTIZATION:
                        extensions[ extensionName ] = new GLTFMeshQuantizationExtension();
                        break;

                    default:

                        if ( extensionsRequired.indexOf( extensionName ) >= 0 && plugins[ extensionName ] === undefined ) {

                            console.warn( 'THREE.GLTFLoader: Unknown extension "' + extensionName + '".' );

                        }

                }

            }

        }

        parser.setExtensions( extensions );
        parser.setPlugins( plugins );
        parser.parse( onLoad, onError );

    }

    /**
     * Async version of {@link GLTFLoader#parse}.
     *
     * @async
     * @param {string|ArrayBuffer} data - The raw glTF data.
     * @param {string} path - The URL base path.
     * @return {Promise<GLTFLoader~LoadObject>} A Promise that resolves with the loaded glTF when the parsing has been finished.
     */
    parseAsync( data, path ) {

        const scope = this;

        return new Promise( function ( resolve, reject ) {

            scope.parse( data, path, resolve, reject );

        } );

    }

}

Methods¶

`load(url: string, onLoad: any, onProgress: onProgressCallback, onError: onErrorCallback): void`¶

Code

load( url, onLoad, onProgress, onError ) {

        const scope = this;

        let resourcePath;

        if ( this.resourcePath !== '' ) {

            resourcePath = this.resourcePath;

        } else if ( this.path !== '' ) {

            // If a base path is set, resources will be relative paths from that plus the relative path of the gltf file
            // Example  path = 'https://my-cnd-server.com/', url = 'assets/models/model.gltf'
            // resourcePath = 'https://my-cnd-server.com/assets/models/'
            // referenced resource 'model.bin' will be loaded from 'https://my-cnd-server.com/assets/models/model.bin'
            // referenced resource '../textures/texture.png' will be loaded from 'https://my-cnd-server.com/assets/textures/texture.png'
            const relativeUrl = LoaderUtils.extractUrlBase( url );
            resourcePath = LoaderUtils.resolveURL( relativeUrl, this.path );

        } else {

            resourcePath = LoaderUtils.extractUrlBase( url );

        }

        // Tells the LoadingManager to track an extra item, which resolves after
        // the model is fully loaded. This means the count of items loaded will
        // be incorrect, but ensures manager.onLoad() does not fire early.
        this.manager.itemStart( url );

        const _onError = function ( e ) {

            if ( onError ) {

                onError( e );

            } else {

                console.error( e );

            }

            scope.manager.itemError( url );
            scope.manager.itemEnd( url );

        };

        const loader = new FileLoader( this.manager );

        loader.setPath( this.path );
        loader.setResponseType( 'arraybuffer' );
        loader.setRequestHeader( this.requestHeader );
        loader.setWithCredentials( this.withCredentials );

        loader.load( url, function ( data ) {

            try {

                scope.parse( data, resourcePath, function ( gltf ) {

                    onLoad( gltf );

                    scope.manager.itemEnd( url );

                }, _onError );

            } catch ( e ) {

                _onError( e );

            }

        }, onProgress, _onError );

    }

`setDRACOLoader(dracoLoader: DRACOLoader): GLTFLoader`¶

Code

setDRACOLoader( dracoLoader ) {

        this.dracoLoader = dracoLoader;
        return this;

    }

`setKTX2Loader(ktx2Loader: KTX2Loader): GLTFLoader`¶

Code

setKTX2Loader( ktx2Loader ) {

        this.ktx2Loader = ktx2Loader;
        return this;

    }

`setMeshoptDecoder(meshoptDecoder: any): GLTFLoader`¶

Code

setMeshoptDecoder( meshoptDecoder ) {

        this.meshoptDecoder = meshoptDecoder;
        return this;

    }

`register(callback: any): GLTFLoader`¶

Code

register( callback ) {

        if ( this.pluginCallbacks.indexOf( callback ) === - 1 ) {

            this.pluginCallbacks.push( callback );

        }

        return this;

    }

`unregister(callback: Function): GLTFLoader`¶

Code

unregister( callback ) {

        if ( this.pluginCallbacks.indexOf( callback ) !== - 1 ) {

            this.pluginCallbacks.splice( this.pluginCallbacks.indexOf( callback ), 1 );

        }

        return this;

    }

`parse(data: string | ArrayBuffer, path: string, onLoad: any, onError: onErrorCallback): void`¶

Code

parse( data, path, onLoad, onError ) {

        let json;
        const extensions = {};
        const plugins = {};
        const textDecoder = new TextDecoder();

        if ( typeof data === 'string' ) {

            json = JSON.parse( data );

        } else if ( data instanceof ArrayBuffer ) {

            const magic = textDecoder.decode( new Uint8Array( data, 0, 4 ) );

            if ( magic === BINARY_EXTENSION_HEADER_MAGIC ) {

                try {

                    extensions[ EXTENSIONS.KHR_BINARY_GLTF ] = new GLTFBinaryExtension( data );

                } catch ( error ) {

                    if ( onError ) onError( error );
                    return;

                }

                json = JSON.parse( extensions[ EXTENSIONS.KHR_BINARY_GLTF ].content );

            } else {

                json = JSON.parse( textDecoder.decode( data ) );

            }

        } else {

            json = data;

        }

        if ( json.asset === undefined || json.asset.version[ 0 ] < 2 ) {

            if ( onError ) onError( new Error( 'THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported.' ) );
            return;

        }

        const parser = new GLTFParser( json, {

            path: path || this.resourcePath || '',
            crossOrigin: this.crossOrigin,
            requestHeader: this.requestHeader,
            manager: this.manager,
            ktx2Loader: this.ktx2Loader,
            meshoptDecoder: this.meshoptDecoder

        } );

        parser.fileLoader.setRequestHeader( this.requestHeader );

        for ( let i = 0; i < this.pluginCallbacks.length; i ++ ) {

            const plugin = this.pluginCallbacks[ i ]( parser );

            if ( ! plugin.name ) console.error( 'THREE.GLTFLoader: Invalid plugin found: missing name' );

            plugins[ plugin.name ] = plugin;

            // Workaround to avoid determining as unknown extension
            // in addUnknownExtensionsToUserData().
            // Remove this workaround if we move all the existing
            // extension handlers to plugin system
            extensions[ plugin.name ] = true;

        }

        if ( json.extensionsUsed ) {

            for ( let i = 0; i < json.extensionsUsed.length; ++ i ) {

                const extensionName = json.extensionsUsed[ i ];
                const extensionsRequired = json.extensionsRequired || [];

                switch ( extensionName ) {

                    case EXTENSIONS.KHR_MATERIALS_UNLIT:
                        extensions[ extensionName ] = new GLTFMaterialsUnlitExtension();
                        break;

                    case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
                        extensions[ extensionName ] = new GLTFDracoMeshCompressionExtension( json, this.dracoLoader );
                        break;

                    case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
                        extensions[ extensionName ] = new GLTFTextureTransformExtension();
                        break;

                    case EXTENSIONS.KHR_MESH_QUANTIZATION:
                        extensions[ extensionName ] = new GLTFMeshQuantizationExtension();
                        break;

                    default:

                        if ( extensionsRequired.indexOf( extensionName ) >= 0 && plugins[ extensionName ] === undefined ) {

                            console.warn( 'THREE.GLTFLoader: Unknown extension "' + extensionName + '".' );

                        }

                }

            }

        }

        parser.setExtensions( extensions );
        parser.setPlugins( plugins );
        parser.parse( onLoad, onError );

    }

`parseAsync(data: string | ArrayBuffer, path: string): Promise<GLTFLoader>`¶

Code

parseAsync( data, path ) {

        const scope = this;

        return new Promise( function ( resolve, reject ) {

            scope.parse( data, path, resolve, reject );

        } );

    }

`GLTFLightsExtension`¶

Class Code

class GLTFLightsExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL;

        // Object3D instance caches
        this.cache = { refs: {}, uses: {} };

    }

    _markDefs() {

        const parser = this.parser;
        const nodeDefs = this.parser.json.nodes || [];

        for ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {

            const nodeDef = nodeDefs[ nodeIndex ];

            if ( nodeDef.extensions
                    && nodeDef.extensions[ this.name ]
                    && nodeDef.extensions[ this.name ].light !== undefined ) {

                parser._addNodeRef( this.cache, nodeDef.extensions[ this.name ].light );

            }

        }

    }

    _loadLight( lightIndex ) {

        const parser = this.parser;
        const cacheKey = 'light:' + lightIndex;
        let dependency = parser.cache.get( cacheKey );

        if ( dependency ) return dependency;

        const json = parser.json;
        const extensions = ( json.extensions && json.extensions[ this.name ] ) || {};
        const lightDefs = extensions.lights || [];
        const lightDef = lightDefs[ lightIndex ];
        let lightNode;

        const color = new Color( 0xffffff );

        if ( lightDef.color !== undefined ) color.setRGB( lightDef.color[ 0 ], lightDef.color[ 1 ], lightDef.color[ 2 ], LinearSRGBColorSpace );

        const range = lightDef.range !== undefined ? lightDef.range : 0;

        switch ( lightDef.type ) {

            case 'directional':
                lightNode = new DirectionalLight( color );
                lightNode.target.position.set( 0, 0, - 1 );
                lightNode.add( lightNode.target );
                break;

            case 'point':
                lightNode = new PointLight( color );
                lightNode.distance = range;
                break;

            case 'spot':
                lightNode = new SpotLight( color );
                lightNode.distance = range;
                // Handle spotlight properties.
                lightDef.spot = lightDef.spot || {};
                lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== undefined ? lightDef.spot.innerConeAngle : 0;
                lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== undefined ? lightDef.spot.outerConeAngle : Math.PI / 4.0;
                lightNode.angle = lightDef.spot.outerConeAngle;
                lightNode.penumbra = 1.0 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;
                lightNode.target.position.set( 0, 0, - 1 );
                lightNode.add( lightNode.target );
                break;

            default:
                throw new Error( 'THREE.GLTFLoader: Unexpected light type: ' + lightDef.type );

        }

        // Some lights (e.g. spot) default to a position other than the origin. Reset the position
        // here, because node-level parsing will only override position if explicitly specified.
        lightNode.position.set( 0, 0, 0 );

        assignExtrasToUserData( lightNode, lightDef );

        if ( lightDef.intensity !== undefined ) lightNode.intensity = lightDef.intensity;

        lightNode.name = parser.createUniqueName( lightDef.name || ( 'light_' + lightIndex ) );

        dependency = Promise.resolve( lightNode );

        parser.cache.add( cacheKey, dependency );

        return dependency;

    }

    getDependency( type, index ) {

        if ( type !== 'light' ) return;

        return this._loadLight( index );

    }

    createNodeAttachment( nodeIndex ) {

        const self = this;
        const parser = this.parser;
        const json = parser.json;
        const nodeDef = json.nodes[ nodeIndex ];
        const lightDef = ( nodeDef.extensions && nodeDef.extensions[ this.name ] ) || {};
        const lightIndex = lightDef.light;

        if ( lightIndex === undefined ) return null;

        return this._loadLight( lightIndex ).then( function ( light ) {

            return parser._getNodeRef( self.cache, lightIndex, light );

        } );

    }

}

Methods¶

`_markDefs(): void`¶

Code

_markDefs() {

        const parser = this.parser;
        const nodeDefs = this.parser.json.nodes || [];

        for ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {

            const nodeDef = nodeDefs[ nodeIndex ];

            if ( nodeDef.extensions
                    && nodeDef.extensions[ this.name ]
                    && nodeDef.extensions[ this.name ].light !== undefined ) {

                parser._addNodeRef( this.cache, nodeDef.extensions[ this.name ].light );

            }

        }

    }

`_loadLight(lightIndex: any): any`¶

Code

_loadLight( lightIndex ) {

        const parser = this.parser;
        const cacheKey = 'light:' + lightIndex;
        let dependency = parser.cache.get( cacheKey );

        if ( dependency ) return dependency;

        const json = parser.json;
        const extensions = ( json.extensions && json.extensions[ this.name ] ) || {};
        const lightDefs = extensions.lights || [];
        const lightDef = lightDefs[ lightIndex ];
        let lightNode;

        const color = new Color( 0xffffff );

        if ( lightDef.color !== undefined ) color.setRGB( lightDef.color[ 0 ], lightDef.color[ 1 ], lightDef.color[ 2 ], LinearSRGBColorSpace );

        const range = lightDef.range !== undefined ? lightDef.range : 0;

        switch ( lightDef.type ) {

            case 'directional':
                lightNode = new DirectionalLight( color );
                lightNode.target.position.set( 0, 0, - 1 );
                lightNode.add( lightNode.target );
                break;

            case 'point':
                lightNode = new PointLight( color );
                lightNode.distance = range;
                break;

            case 'spot':
                lightNode = new SpotLight( color );
                lightNode.distance = range;
                // Handle spotlight properties.
                lightDef.spot = lightDef.spot || {};
                lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== undefined ? lightDef.spot.innerConeAngle : 0;
                lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== undefined ? lightDef.spot.outerConeAngle : Math.PI / 4.0;
                lightNode.angle = lightDef.spot.outerConeAngle;
                lightNode.penumbra = 1.0 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;
                lightNode.target.position.set( 0, 0, - 1 );
                lightNode.add( lightNode.target );
                break;

            default:
                throw new Error( 'THREE.GLTFLoader: Unexpected light type: ' + lightDef.type );

        }

        // Some lights (e.g. spot) default to a position other than the origin. Reset the position
        // here, because node-level parsing will only override position if explicitly specified.
        lightNode.position.set( 0, 0, 0 );

        assignExtrasToUserData( lightNode, lightDef );

        if ( lightDef.intensity !== undefined ) lightNode.intensity = lightDef.intensity;

        lightNode.name = parser.createUniqueName( lightDef.name || ( 'light_' + lightIndex ) );

        dependency = Promise.resolve( lightNode );

        parser.cache.add( cacheKey, dependency );

        return dependency;

    }

`getDependency(type: any, index: any): any`¶

Code

getDependency( type, index ) {

        if ( type !== 'light' ) return;

        return this._loadLight( index );

    }

`createNodeAttachment(nodeIndex: any): any`¶

Code

createNodeAttachment( nodeIndex ) {

        const self = this;
        const parser = this.parser;
        const json = parser.json;
        const nodeDef = json.nodes[ nodeIndex ];
        const lightDef = ( nodeDef.extensions && nodeDef.extensions[ this.name ] ) || {};
        const lightIndex = lightDef.light;

        if ( lightIndex === undefined ) return null;

        return this._loadLight( lightIndex ).then( function ( light ) {

            return parser._getNodeRef( self.cache, lightIndex, light );

        } );

    }

`GLTFMaterialsUnlitExtension`¶

Class Code

class GLTFMaterialsUnlitExtension {

    constructor() {

        this.name = EXTENSIONS.KHR_MATERIALS_UNLIT;

    }

    getMaterialType() {

        return MeshBasicMaterial;

    }

    extendParams( materialParams, materialDef, parser ) {

        const pending = [];

        materialParams.color = new Color( 1.0, 1.0, 1.0 );
        materialParams.opacity = 1.0;

        const metallicRoughness = materialDef.pbrMetallicRoughness;

        if ( metallicRoughness ) {

            if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {

                const array = metallicRoughness.baseColorFactor;

                materialParams.color.setRGB( array[ 0 ], array[ 1 ], array[ 2 ], LinearSRGBColorSpace );
                materialParams.opacity = array[ 3 ];

            }

            if ( metallicRoughness.baseColorTexture !== undefined ) {

                pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) );

            }

        }

        return Promise.all( pending );

    }

}

Methods¶

`getMaterialType(): any`¶

Code

getMaterialType() {

        return MeshBasicMaterial;

    }

`extendParams(materialParams: any, materialDef: any, parser: any): Promise<any[]>`¶

Code

extendParams( materialParams, materialDef, parser ) {

        const pending = [];

        materialParams.color = new Color( 1.0, 1.0, 1.0 );
        materialParams.opacity = 1.0;

        const metallicRoughness = materialDef.pbrMetallicRoughness;

        if ( metallicRoughness ) {

            if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {

                const array = metallicRoughness.baseColorFactor;

                materialParams.color.setRGB( array[ 0 ], array[ 1 ], array[ 2 ], LinearSRGBColorSpace );
                materialParams.opacity = array[ 3 ];

            }

            if ( metallicRoughness.baseColorTexture !== undefined ) {

                pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) );

            }

        }

        return Promise.all( pending );

    }

`GLTFMaterialsEmissiveStrengthExtension`¶

Class Code

class GLTFMaterialsEmissiveStrengthExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.KHR_MATERIALS_EMISSIVE_STRENGTH;

    }

    extendMaterialParams( materialIndex, materialParams ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {

            return Promise.resolve();

        }

        const emissiveStrength = materialDef.extensions[ this.name ].emissiveStrength;

        if ( emissiveStrength !== undefined ) {

            materialParams.emissiveIntensity = emissiveStrength;

        }

        return Promise.resolve();

    }

}

Methods¶

`extendMaterialParams(materialIndex: any, materialParams: any): Promise<void>`¶

Code

extendMaterialParams( materialIndex, materialParams ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {

            return Promise.resolve();

        }

        const emissiveStrength = materialDef.extensions[ this.name ].emissiveStrength;

        if ( emissiveStrength !== undefined ) {

            materialParams.emissiveIntensity = emissiveStrength;

        }

        return Promise.resolve();

    }

`GLTFMaterialsClearcoatExtension`¶

Class Code

class GLTFMaterialsClearcoatExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.KHR_MATERIALS_CLEARCOAT;

    }

    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.clearcoatFactor !== undefined ) {

            materialParams.clearcoat = extension.clearcoatFactor;

        }

        if ( extension.clearcoatTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'clearcoatMap', extension.clearcoatTexture ) );

        }

        if ( extension.clearcoatRoughnessFactor !== undefined ) {

            materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor;

        }

        if ( extension.clearcoatRoughnessTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'clearcoatRoughnessMap', extension.clearcoatRoughnessTexture ) );

        }

        if ( extension.clearcoatNormalTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'clearcoatNormalMap', extension.clearcoatNormalTexture ) );

            if ( extension.clearcoatNormalTexture.scale !== undefined ) {

                const scale = extension.clearcoatNormalTexture.scale;

                materialParams.clearcoatNormalScale = new Vector2( scale, scale );

            }

        }

        return Promise.all( pending );

    }

}

Methods¶

`getMaterialType(materialIndex: any): any`¶

Code

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: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Code

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.clearcoatFactor !== undefined ) {

            materialParams.clearcoat = extension.clearcoatFactor;

        }

        if ( extension.clearcoatTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'clearcoatMap', extension.clearcoatTexture ) );

        }

        if ( extension.clearcoatRoughnessFactor !== undefined ) {

            materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor;

        }

        if ( extension.clearcoatRoughnessTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'clearcoatRoughnessMap', extension.clearcoatRoughnessTexture ) );

        }

        if ( extension.clearcoatNormalTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'clearcoatNormalMap', extension.clearcoatNormalTexture ) );

            if ( extension.clearcoatNormalTexture.scale !== undefined ) {

                const scale = extension.clearcoatNormalTexture.scale;

                materialParams.clearcoatNormalScale = new Vector2( scale, scale );

            }

        }

        return Promise.all( pending );

    }

`GLTFMaterialsDispersionExtension`¶

Class Code

class GLTFMaterialsDispersionExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.KHR_MATERIALS_DISPERSION;

    }

    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 extension = materialDef.extensions[ this.name ];

        materialParams.dispersion = extension.dispersion !== undefined ? extension.dispersion : 0;

        return Promise.resolve();

    }

}

Methods¶

`getMaterialType(materialIndex: any): any`¶

Code

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: any, materialParams: any): Promise<void>`¶

Code

extendMaterialParams( materialIndex, materialParams ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {

            return Promise.resolve();

        }

        const extension = materialDef.extensions[ this.name ];

        materialParams.dispersion = extension.dispersion !== undefined ? extension.dispersion : 0;

        return Promise.resolve();

    }

`GLTFMaterialsIridescenceExtension`¶

Class Code

class GLTFMaterialsIridescenceExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.KHR_MATERIALS_IRIDESCENCE;

    }

    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.iridescenceFactor !== undefined ) {

            materialParams.iridescence = extension.iridescenceFactor;

        }

        if ( extension.iridescenceTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'iridescenceMap', extension.iridescenceTexture ) );

        }

        if ( extension.iridescenceIor !== undefined ) {

            materialParams.iridescenceIOR = extension.iridescenceIor;

        }

        if ( materialParams.iridescenceThicknessRange === undefined ) {

            materialParams.iridescenceThicknessRange = [ 100, 400 ];

        }

        if ( extension.iridescenceThicknessMinimum !== undefined ) {

            materialParams.iridescenceThicknessRange[ 0 ] = extension.iridescenceThicknessMinimum;

        }

        if ( extension.iridescenceThicknessMaximum !== undefined ) {

            materialParams.iridescenceThicknessRange[ 1 ] = extension.iridescenceThicknessMaximum;

        }

        if ( extension.iridescenceThicknessTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'iridescenceThicknessMap', extension.iridescenceThicknessTexture ) );

        }

        return Promise.all( pending );

    }

}

Methods¶

`getMaterialType(materialIndex: any): any`¶

Code

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: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Code

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.iridescenceFactor !== undefined ) {

            materialParams.iridescence = extension.iridescenceFactor;

        }

        if ( extension.iridescenceTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'iridescenceMap', extension.iridescenceTexture ) );

        }

        if ( extension.iridescenceIor !== undefined ) {

            materialParams.iridescenceIOR = extension.iridescenceIor;

        }

        if ( materialParams.iridescenceThicknessRange === undefined ) {

            materialParams.iridescenceThicknessRange = [ 100, 400 ];

        }

        if ( extension.iridescenceThicknessMinimum !== undefined ) {

            materialParams.iridescenceThicknessRange[ 0 ] = extension.iridescenceThicknessMinimum;

        }

        if ( extension.iridescenceThicknessMaximum !== undefined ) {

            materialParams.iridescenceThicknessRange[ 1 ] = extension.iridescenceThicknessMaximum;

        }

        if ( extension.iridescenceThicknessTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'iridescenceThicknessMap', extension.iridescenceThicknessTexture ) );

        }

        return Promise.all( pending );

    }

`GLTFMaterialsSheenExtension`¶

Class Code

class GLTFMaterialsSheenExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.KHR_MATERIALS_SHEEN;

    }

    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 = [];

        materialParams.sheenColor = new Color( 0, 0, 0 );
        materialParams.sheenRoughness = 0;
        materialParams.sheen = 1;

        const extension = materialDef.extensions[ this.name ];

        if ( extension.sheenColorFactor !== undefined ) {

            const colorFactor = extension.sheenColorFactor;
            materialParams.sheenColor.setRGB( colorFactor[ 0 ], colorFactor[ 1 ], colorFactor[ 2 ], LinearSRGBColorSpace );

        }

        if ( extension.sheenRoughnessFactor !== undefined ) {

            materialParams.sheenRoughness = extension.sheenRoughnessFactor;

        }

        if ( extension.sheenColorTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'sheenColorMap', extension.sheenColorTexture, SRGBColorSpace ) );

        }

        if ( extension.sheenRoughnessTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'sheenRoughnessMap', extension.sheenRoughnessTexture ) );

        }

        return Promise.all( pending );

    }

}

Methods¶

`getMaterialType(materialIndex: any): any`¶

Code

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: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Code

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 = [];

        materialParams.sheenColor = new Color( 0, 0, 0 );
        materialParams.sheenRoughness = 0;
        materialParams.sheen = 1;

        const extension = materialDef.extensions[ this.name ];

        if ( extension.sheenColorFactor !== undefined ) {

            const colorFactor = extension.sheenColorFactor;
            materialParams.sheenColor.setRGB( colorFactor[ 0 ], colorFactor[ 1 ], colorFactor[ 2 ], LinearSRGBColorSpace );

        }

        if ( extension.sheenRoughnessFactor !== undefined ) {

            materialParams.sheenRoughness = extension.sheenRoughnessFactor;

        }

        if ( extension.sheenColorTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'sheenColorMap', extension.sheenColorTexture, SRGBColorSpace ) );

        }

        if ( extension.sheenRoughnessTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'sheenRoughnessMap', extension.sheenRoughnessTexture ) );

        }

        return Promise.all( pending );

    }

`GLTFMaterialsTransmissionExtension`¶

Class Code

class GLTFMaterialsTransmissionExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.KHR_MATERIALS_TRANSMISSION;

    }

    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.transmissionFactor !== undefined ) {

            materialParams.transmission = extension.transmissionFactor;

        }

        if ( extension.transmissionTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'transmissionMap', extension.transmissionTexture ) );

        }

        return Promise.all( pending );

    }

}

Methods¶

`getMaterialType(materialIndex: any): any`¶

Code

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: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Code

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.transmissionFactor !== undefined ) {

            materialParams.transmission = extension.transmissionFactor;

        }

        if ( extension.transmissionTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'transmissionMap', extension.transmissionTexture ) );

        }

        return Promise.all( pending );

    }

`GLTFMaterialsVolumeExtension`¶

Class Code

class GLTFMaterialsVolumeExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.KHR_MATERIALS_VOLUME;

    }

    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 ];

        materialParams.thickness = extension.thicknessFactor !== undefined ? extension.thicknessFactor : 0;

        if ( extension.thicknessTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'thicknessMap', extension.thicknessTexture ) );

        }

        materialParams.attenuationDistance = extension.attenuationDistance || Infinity;

        const colorArray = extension.attenuationColor || [ 1, 1, 1 ];
        materialParams.attenuationColor = new Color().setRGB( colorArray[ 0 ], colorArray[ 1 ], colorArray[ 2 ], LinearSRGBColorSpace );

        return Promise.all( pending );

    }

}

Methods¶

`getMaterialType(materialIndex: any): any`¶

Code

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: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Code

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 ];

        materialParams.thickness = extension.thicknessFactor !== undefined ? extension.thicknessFactor : 0;

        if ( extension.thicknessTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'thicknessMap', extension.thicknessTexture ) );

        }

        materialParams.attenuationDistance = extension.attenuationDistance || Infinity;

        const colorArray = extension.attenuationColor || [ 1, 1, 1 ];
        materialParams.attenuationColor = new Color().setRGB( colorArray[ 0 ], colorArray[ 1 ], colorArray[ 2 ], LinearSRGBColorSpace );

        return Promise.all( pending );

    }

`GLTFMaterialsIorExtension`¶

Class Code

class GLTFMaterialsIorExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.KHR_MATERIALS_IOR;

    }

    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 extension = materialDef.extensions[ this.name ];

        materialParams.ior = extension.ior !== undefined ? extension.ior : 1.5;

        return Promise.resolve();

    }

}

Methods¶

`getMaterialType(materialIndex: any): any`¶

Code

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: any, materialParams: any): Promise<void>`¶

Code

extendMaterialParams( materialIndex, materialParams ) {

        const parser = this.parser;
        const materialDef = parser.json.materials[ materialIndex ];

        if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {

            return Promise.resolve();

        }

        const extension = materialDef.extensions[ this.name ];

        materialParams.ior = extension.ior !== undefined ? extension.ior : 1.5;

        return Promise.resolve();

    }

`GLTFMaterialsSpecularExtension`¶

Class Code

class GLTFMaterialsSpecularExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.KHR_MATERIALS_SPECULAR;

    }

    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 ];

        materialParams.specularIntensity = extension.specularFactor !== undefined ? extension.specularFactor : 1.0;

        if ( extension.specularTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'specularIntensityMap', extension.specularTexture ) );

        }

        const colorArray = extension.specularColorFactor || [ 1, 1, 1 ];
        materialParams.specularColor = new Color().setRGB( colorArray[ 0 ], colorArray[ 1 ], colorArray[ 2 ], LinearSRGBColorSpace );

        if ( extension.specularColorTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'specularColorMap', extension.specularColorTexture, SRGBColorSpace ) );

        }

        return Promise.all( pending );

    }

}

Methods¶

`getMaterialType(materialIndex: any): any`¶

Code

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: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Code

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 ];

        materialParams.specularIntensity = extension.specularFactor !== undefined ? extension.specularFactor : 1.0;

        if ( extension.specularTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'specularIntensityMap', extension.specularTexture ) );

        }

        const colorArray = extension.specularColorFactor || [ 1, 1, 1 ];
        materialParams.specularColor = new Color().setRGB( colorArray[ 0 ], colorArray[ 1 ], colorArray[ 2 ], LinearSRGBColorSpace );

        if ( extension.specularColorTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'specularColorMap', extension.specularColorTexture, SRGBColorSpace ) );

        }

        return Promise.all( pending );

    }

`GLTFMaterialsBumpExtension`¶

Class Code

class GLTFMaterialsBumpExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.EXT_MATERIALS_BUMP;

    }

    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 ];

        materialParams.bumpScale = extension.bumpFactor !== undefined ? extension.bumpFactor : 1.0;

        if ( extension.bumpTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'bumpMap', extension.bumpTexture ) );

        }

        return Promise.all( pending );

    }

}

Methods¶

`getMaterialType(materialIndex: any): any`¶

Code

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: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Code

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 ];

        materialParams.bumpScale = extension.bumpFactor !== undefined ? extension.bumpFactor : 1.0;

        if ( extension.bumpTexture !== undefined ) {

            pending.push( parser.assignTexture( materialParams, 'bumpMap', extension.bumpTexture ) );

        }

        return Promise.all( pending );

    }

`GLTFMaterialsAnisotropyExtension`¶

Class Code

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 ) );

        }

        return Promise.all( pending );

    }

}

Methods¶

`getMaterialType(materialIndex: any): any`¶

Code

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: any, materialParams: any): Promise<void> | Promise<any[]>`¶

Code

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 ) );

        }

        return Promise.all( pending );

    }

`GLTFTextureBasisUExtension`¶

Class Code

class GLTFTextureBasisUExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.KHR_TEXTURE_BASISU;

    }

    loadTexture( textureIndex ) {

        const parser = this.parser;
        const json = parser.json;

        const textureDef = json.textures[ textureIndex ];

        if ( ! textureDef.extensions || ! textureDef.extensions[ this.name ] ) {

            return null;

        }

        const extension = textureDef.extensions[ this.name ];
        const loader = parser.options.ktx2Loader;

        if ( ! loader ) {

            if ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) {

                throw new Error( 'THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures' );

            } else {

                // Assumes that the extension is optional and that a fallback texture is present
                return null;

            }

        }

        return parser.loadTextureImage( textureIndex, extension.source, loader );

    }

}

Methods¶

`loadTexture(textureIndex: any): any`¶

Code

loadTexture( textureIndex ) {

        const parser = this.parser;
        const json = parser.json;

        const textureDef = json.textures[ textureIndex ];

        if ( ! textureDef.extensions || ! textureDef.extensions[ this.name ] ) {

            return null;

        }

        const extension = textureDef.extensions[ this.name ];
        const loader = parser.options.ktx2Loader;

        if ( ! loader ) {

            if ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) {

                throw new Error( 'THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures' );

            } else {

                // Assumes that the extension is optional and that a fallback texture is present
                return null;

            }

        }

        return parser.loadTextureImage( textureIndex, extension.source, loader );

    }

`GLTFTextureWebPExtension`¶

Class Code

class GLTFTextureWebPExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.EXT_TEXTURE_WEBP;

    }

    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 parser.loadTextureImage( textureIndex, extension.source, loader );

    }

}

Methods¶

`loadTexture(textureIndex: any): any`¶

Code

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 parser.loadTextureImage( textureIndex, extension.source, loader );

    }

`GLTFTextureAVIFExtension`¶

Class Code

class GLTFTextureAVIFExtension {

    constructor( parser ) {

        this.parser = parser;
        this.name = EXTENSIONS.EXT_TEXTURE_AVIF;

    }

    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 parser.loadTextureImage( textureIndex, extension.source, loader );

    }

}

Methods¶

`loadTexture(textureIndex: any): any`¶

Code

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 parser.loadTextureImage( textureIndex, extension.source, loader );

    }

`GLTFMeshoptCompression`¶

Class Code

class GLTFMeshoptCompression {

    constructor( parser ) {

        this.name = EXTENSIONS.EXT_MESHOPT_COMPRESSION;
        this.parser = parser;

    }

    loadBufferView( index ) {

        const json = this.parser.json;
        const bufferView = json.bufferViews[ index ];

        if ( bufferView.extensions && bufferView.extensions[ this.name ] ) {

            const extensionDef = bufferView.extensions[ this.name ];

            const buffer = this.parser.getDependency( 'buffer', extensionDef.buffer );
            const decoder = this.parser.options.meshoptDecoder;

            if ( ! decoder || ! decoder.supported ) {

                if ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) {

                    throw new Error( 'THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files' );

                } else {

                    // Assumes that the extension is optional and that fallback buffer data is present
                    return null;

                }

            }

            return buffer.then( function ( res ) {

                const byteOffset = extensionDef.byteOffset || 0;
                const byteLength = extensionDef.byteLength || 0;

                const count = extensionDef.count;
                const stride = extensionDef.byteStride;

                const source = new Uint8Array( res, byteOffset, byteLength );

                if ( decoder.decodeGltfBufferAsync ) {

                    return decoder.decodeGltfBufferAsync( count, stride, source, extensionDef.mode, extensionDef.filter ).then( function ( res ) {

                        return res.buffer;

                    } );

                } else {

                    // Support for MeshoptDecoder 0.18 or earlier, without decodeGltfBufferAsync
                    return decoder.ready.then( function () {

                        const result = new ArrayBuffer( count * stride );
                        decoder.decodeGltfBuffer( new Uint8Array( result ), count, stride, source, extensionDef.mode, extensionDef.filter );
                        return result;

                    } );

                }

            } );

        } else {

            return null;

        }

    }

}

Methods¶

`loadBufferView(index: any): any`¶

Code

loadBufferView( index ) {

        const json = this.parser.json;
        const bufferView = json.bufferViews[ index ];

        if ( bufferView.extensions && bufferView.extensions[ this.name ] ) {

            const extensionDef = bufferView.extensions[ this.name ];

            const buffer = this.parser.getDependency( 'buffer', extensionDef.buffer );
            const decoder = this.parser.options.meshoptDecoder;

            if ( ! decoder || ! decoder.supported ) {

                if ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) {

                    throw new Error( 'THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files' );

                } else {

                    // Assumes that the extension is optional and that fallback buffer data is present
                    return null;

                }

            }

            return buffer.then( function ( res ) {

                const byteOffset = extensionDef.byteOffset || 0;
                const byteLength = extensionDef.byteLength || 0;

                const count = extensionDef.count;
                const stride = extensionDef.byteStride;

                const source = new Uint8Array( res, byteOffset, byteLength );

                if ( decoder.decodeGltfBufferAsync ) {

                    return decoder.decodeGltfBufferAsync( count, stride, source, extensionDef.mode, extensionDef.filter ).then( function ( res ) {

                        return res.buffer;

                    } );

                } else {

                    // Support for MeshoptDecoder 0.18 or earlier, without decodeGltfBufferAsync
                    return decoder.ready.then( function () {

                        const result = new ArrayBuffer( count * stride );
                        decoder.decodeGltfBuffer( new Uint8Array( result ), count, stride, source, extensionDef.mode, extensionDef.filter );
                        return result;

                    } );

                }

            } );

        } else {

            return null;

        }

    }

`GLTFMeshGpuInstancing`¶

Class Code

class GLTFMeshGpuInstancing {

    constructor( parser ) {

        this.name = EXTENSIONS.EXT_MESH_GPU_INSTANCING;
        this.parser = parser;

    }

    createNodeMesh( nodeIndex ) {

        const json = this.parser.json;
        const nodeDef = json.nodes[ nodeIndex ];

        if ( ! nodeDef.extensions || ! nodeDef.extensions[ this.name ] ||
            nodeDef.mesh === undefined ) {

            return null;

        }

        const meshDef = json.meshes[ nodeDef.mesh ];

        // No Points or Lines + Instancing support yet

        for ( const primitive of meshDef.primitives ) {

            if ( primitive.mode !== WEBGL_CONSTANTS.TRIANGLES &&
                 primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_STRIP &&
                 primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_FAN &&
                 primitive.mode !== undefined ) {

                return null;

            }

        }

        const extensionDef = nodeDef.extensions[ this.name ];
        const attributesDef = extensionDef.attributes;

        // @TODO: Can we support InstancedMesh + SkinnedMesh?

        const pending = [];
        const attributes = {};

        for ( const key in attributesDef ) {

            pending.push( this.parser.getDependency( 'accessor', attributesDef[ key ] ).then( accessor => {

                attributes[ key ] = accessor;
                return attributes[ key ];

            } ) );

        }

        if ( pending.length < 1 ) {

            return null;

        }

        pending.push( this.parser.createNodeMesh( nodeIndex ) );

        return Promise.all( pending ).then( results => {

            const nodeObject = results.pop();
            const meshes = nodeObject.isGroup ? nodeObject.children : [ nodeObject ];
            const count = results[ 0 ].count; // All attribute counts should be same
            const instancedMeshes = [];

            for ( const mesh of meshes ) {

                // Temporal variables
                const m = new Matrix4();
                const p = new Vector3();
                const q = new Quaternion();
                const s = new Vector3( 1, 1, 1 );

                const instancedMesh = new InstancedMesh( mesh.geometry, mesh.material, count );

                for ( let i = 0; i < count; i ++ ) {

                    if ( attributes.TRANSLATION ) {

                        p.fromBufferAttribute( attributes.TRANSLATION, i );

                    }

                    if ( attributes.ROTATION ) {

                        q.fromBufferAttribute( attributes.ROTATION, i );

                    }

                    if ( attributes.SCALE ) {

                        s.fromBufferAttribute( attributes.SCALE, i );

                    }

                    instancedMesh.setMatrixAt( i, m.compose( p, q, s ) );

                }

                // Add instance attributes to the geometry, excluding TRS.
                for ( const attributeName in attributes ) {

                    if ( attributeName === '_COLOR_0' ) {

                        const attr = attributes[ attributeName ];
                        instancedMesh.instanceColor = new InstancedBufferAttribute( attr.array, attr.itemSize, attr.normalized );

                    } else if ( attributeName !== 'TRANSLATION' &&
                         attributeName !== 'ROTATION' &&
                         attributeName !== 'SCALE' ) {

                        mesh.geometry.setAttribute( attributeName, attributes[ attributeName ] );

                    }

                }

                // Just in case
                Object3D.prototype.copy.call( instancedMesh, mesh );

                this.parser.assignFinalMaterial( instancedMesh );

                instancedMeshes.push( instancedMesh );

            }

            if ( nodeObject.isGroup ) {

                nodeObject.clear();

                nodeObject.add( ... instancedMeshes );

                return nodeObject;

            }

            return instancedMeshes[ 0 ];

        } );

    }

}

Methods¶

`createNodeMesh(nodeIndex: any): Promise<any>`¶

Code

createNodeMesh( nodeIndex ) {

        const json = this.parser.json;
        const nodeDef = json.nodes[ nodeIndex ];

        if ( ! nodeDef.extensions || ! nodeDef.extensions[ this.name ] ||
            nodeDef.mesh === undefined ) {

            return null;

        }

        const meshDef = json.meshes[ nodeDef.mesh ];

        // No Points or Lines + Instancing support yet

        for ( const primitive of meshDef.primitives ) {

            if ( primitive.mode !== WEBGL_CONSTANTS.TRIANGLES &&
                 primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_STRIP &&
                 primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_FAN &&
                 primitive.mode !== undefined ) {

                return null;

            }

        }

        const extensionDef = nodeDef.extensions[ this.name ];
        const attributesDef = extensionDef.attributes;

        // @TODO: Can we support InstancedMesh + SkinnedMesh?

        const pending = [];
        const attributes = {};

        for ( const key in attributesDef ) {

            pending.push( this.parser.getDependency( 'accessor', attributesDef[ key ] ).then( accessor => {

                attributes[ key ] = accessor;
                return attributes[ key ];

            } ) );

        }

        if ( pending.length < 1 ) {

            return null;

        }

        pending.push( this.parser.createNodeMesh( nodeIndex ) );

        return Promise.all( pending ).then( results => {

            const nodeObject = results.pop();
            const meshes = nodeObject.isGroup ? nodeObject.children : [ nodeObject ];
            const count = results[ 0 ].count; // All attribute counts should be same
            const instancedMeshes = [];

            for ( const mesh of meshes ) {

                // Temporal variables
                const m = new Matrix4();
                const p = new Vector3();
                const q = new Quaternion();
                const s = new Vector3( 1, 1, 1 );

                const instancedMesh = new InstancedMesh( mesh.geometry, mesh.material, count );

                for ( let i = 0; i < count; i ++ ) {

                    if ( attributes.TRANSLATION ) {

                        p.fromBufferAttribute( attributes.TRANSLATION, i );

                    }

                    if ( attributes.ROTATION ) {

                        q.fromBufferAttribute( attributes.ROTATION, i );

                    }

                    if ( attributes.SCALE ) {

                        s.fromBufferAttribute( attributes.SCALE, i );

                    }

                    instancedMesh.setMatrixAt( i, m.compose( p, q, s ) );

                }

                // Add instance attributes to the geometry, excluding TRS.
                for ( const attributeName in attributes ) {

                    if ( attributeName === '_COLOR_0' ) {

                        const attr = attributes[ attributeName ];
                        instancedMesh.instanceColor = new InstancedBufferAttribute( attr.array, attr.itemSize, attr.normalized );

                    } else if ( attributeName !== 'TRANSLATION' &&
                         attributeName !== 'ROTATION' &&
                         attributeName !== 'SCALE' ) {

                        mesh.geometry.setAttribute( attributeName, attributes[ attributeName ] );

                    }

                }

                // Just in case
                Object3D.prototype.copy.call( instancedMesh, mesh );

                this.parser.assignFinalMaterial( instancedMesh );

                instancedMeshes.push( instancedMesh );

            }

            if ( nodeObject.isGroup ) {

                nodeObject.clear();

                nodeObject.add( ... instancedMeshes );

                return nodeObject;

            }

            return instancedMeshes[ 0 ];

        } );

    }

`GLTFBinaryExtension`¶

Class Code

class GLTFBinaryExtension {

    constructor( data ) {

        this.name = EXTENSIONS.KHR_BINARY_GLTF;
        this.content = null;
        this.body = null;

        const headerView = new DataView( data, 0, BINARY_EXTENSION_HEADER_LENGTH );
        const textDecoder = new TextDecoder();

        this.header = {
            magic: textDecoder.decode( new Uint8Array( data.slice( 0, 4 ) ) ),
            version: headerView.getUint32( 4, true ),
            length: headerView.getUint32( 8, true )
        };

        if ( this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC ) {

            throw new Error( 'THREE.GLTFLoader: Unsupported glTF-Binary header.' );

        } else if ( this.header.version < 2.0 ) {

            throw new Error( 'THREE.GLTFLoader: Legacy binary file detected.' );

        }

        const chunkContentsLength = this.header.length - BINARY_EXTENSION_HEADER_LENGTH;
        const chunkView = new DataView( data, BINARY_EXTENSION_HEADER_LENGTH );
        let chunkIndex = 0;

        while ( chunkIndex < chunkContentsLength ) {

            const chunkLength = chunkView.getUint32( chunkIndex, true );
            chunkIndex += 4;

            const chunkType = chunkView.getUint32( chunkIndex, true );
            chunkIndex += 4;

            if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON ) {

                const contentArray = new Uint8Array( data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength );
                this.content = textDecoder.decode( contentArray );

            } else if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN ) {

                const byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
                this.body = data.slice( byteOffset, byteOffset + chunkLength );

            }

            // Clients must ignore chunks with unknown types.

            chunkIndex += chunkLength;

        }

        if ( this.content === null ) {

            throw new Error( 'THREE.GLTFLoader: JSON content not found.' );

        }

    }

}

`GLTFDracoMeshCompressionExtension`¶

Class Code

class GLTFDracoMeshCompressionExtension {

    constructor( json, dracoLoader ) {

        if ( ! dracoLoader ) {

            throw new Error( 'THREE.GLTFLoader: No DRACOLoader instance provided.' );

        }

        this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION;
        this.json = json;
        this.dracoLoader = dracoLoader;
        this.dracoLoader.preload();

    }

    decodePrimitive( primitive, parser ) {

        const json = this.json;
        const dracoLoader = this.dracoLoader;
        const bufferViewIndex = primitive.extensions[ this.name ].bufferView;
        const gltfAttributeMap = primitive.extensions[ this.name ].attributes;
        const threeAttributeMap = {};
        const attributeNormalizedMap = {};
        const attributeTypeMap = {};

        for ( const attributeName in gltfAttributeMap ) {

            const threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();

            threeAttributeMap[ threeAttributeName ] = gltfAttributeMap[ attributeName ];

        }

        for ( const attributeName in primitive.attributes ) {

            const threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();

            if ( gltfAttributeMap[ attributeName ] !== undefined ) {

                const accessorDef = json.accessors[ primitive.attributes[ attributeName ] ];
                const componentType = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];

                attributeTypeMap[ threeAttributeName ] = componentType.name;
                attributeNormalizedMap[ threeAttributeName ] = accessorDef.normalized === true;

            }

        }

        return parser.getDependency( 'bufferView', bufferViewIndex ).then( function ( bufferView ) {

            return new Promise( function ( resolve, reject ) {

                dracoLoader.decodeDracoFile( bufferView, function ( geometry ) {

                    for ( const attributeName in geometry.attributes ) {

                        const attribute = geometry.attributes[ attributeName ];
                        const normalized = attributeNormalizedMap[ attributeName ];

                        if ( normalized !== undefined ) attribute.normalized = normalized;

                    }

                    resolve( geometry );

                }, threeAttributeMap, attributeTypeMap, LinearSRGBColorSpace, reject );

            } );

        } );

    }

}

Methods¶

`decodePrimitive(primitive: any, parser: any): any`¶

Code

decodePrimitive( primitive, parser ) {

        const json = this.json;
        const dracoLoader = this.dracoLoader;
        const bufferViewIndex = primitive.extensions[ this.name ].bufferView;
        const gltfAttributeMap = primitive.extensions[ this.name ].attributes;
        const threeAttributeMap = {};
        const attributeNormalizedMap = {};
        const attributeTypeMap = {};

        for ( const attributeName in gltfAttributeMap ) {

            const threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();

            threeAttributeMap[ threeAttributeName ] = gltfAttributeMap[ attributeName ];

        }

        for ( const attributeName in primitive.attributes ) {

            const threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();

            if ( gltfAttributeMap[ attributeName ] !== undefined ) {

                const accessorDef = json.accessors[ primitive.attributes[ attributeName ] ];
                const componentType = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];

                attributeTypeMap[ threeAttributeName ] = componentType.name;
                attributeNormalizedMap[ threeAttributeName ] = accessorDef.normalized === true;

            }

        }

        return parser.getDependency( 'bufferView', bufferViewIndex ).then( function ( bufferView ) {

            return new Promise( function ( resolve, reject ) {

                dracoLoader.decodeDracoFile( bufferView, function ( geometry ) {

                    for ( const attributeName in geometry.attributes ) {

                        const attribute = geometry.attributes[ attributeName ];
                        const normalized = attributeNormalizedMap[ attributeName ];

                        if ( normalized !== undefined ) attribute.normalized = normalized;

                    }

                    resolve( geometry );

                }, threeAttributeMap, attributeTypeMap, LinearSRGBColorSpace, reject );

            } );

        } );

    }

`GLTFTextureTransformExtension`¶

Class Code

class GLTFTextureTransformExtension {

    constructor() {

        this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM;

    }

    extendTexture( texture, transform ) {

        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;

        }

        texture = texture.clone();

        if ( transform.texCoord !== undefined ) {

            texture.channel = transform.texCoord;

        }

        if ( transform.offset !== undefined ) {

            texture.offset.fromArray( transform.offset );

        }

        if ( transform.rotation !== undefined ) {

            texture.rotation = transform.rotation;

        }

        if ( transform.scale !== undefined ) {

            texture.repeat.fromArray( transform.scale );

        }

        texture.needsUpdate = true;

        return texture;

    }

}

Methods¶

`extendTexture(texture: any, transform: any): any`¶

Code

extendTexture( texture, transform ) {

        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;

        }

        texture = texture.clone();

        if ( transform.texCoord !== undefined ) {

            texture.channel = transform.texCoord;

        }

        if ( transform.offset !== undefined ) {

            texture.offset.fromArray( transform.offset );

        }

        if ( transform.rotation !== undefined ) {

            texture.rotation = transform.rotation;

        }

        if ( transform.scale !== undefined ) {

            texture.repeat.fromArray( transform.scale );

        }

        texture.needsUpdate = true;

        return texture;

    }

`GLTFMeshQuantizationExtension`¶

Class Code

class GLTFMeshQuantizationExtension {

    constructor() {

        this.name = EXTENSIONS.KHR_MESH_QUANTIZATION;

    }

}

`GLTFCubicSplineInterpolant`¶

Class Code

class GLTFCubicSplineInterpolant extends Interpolant {

    constructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {

        super( parameterPositions, sampleValues, sampleSize, resultBuffer );

    }

    copySampleValue_( index ) {

        // Copies a sample value to the result buffer. See description of glTF
        // CUBICSPLINE values layout in interpolate_() function below.

        const result = this.resultBuffer,
            values = this.sampleValues,
            valueSize = this.valueSize,
            offset = index * valueSize * 3 + valueSize;

        for ( let i = 0; i !== valueSize; i ++ ) {

            result[ i ] = values[ offset + i ];

        }

        return result;

    }

    interpolate_( i1, t0, t, t1 ) {

        const result = this.resultBuffer;
        const values = this.sampleValues;
        const stride = this.valueSize;

        const stride2 = stride * 2;
        const stride3 = stride * 3;

        const td = t1 - t0;

        const p = ( t - t0 ) / td;
        const pp = p * p;
        const ppp = pp * p;

        const offset1 = i1 * stride3;
        const offset0 = offset1 - stride3;

        const s2 = - 2 * ppp + 3 * pp;
        const s3 = ppp - pp;
        const s0 = 1 - s2;
        const s1 = s3 - pp + p;

        // Layout of keyframe output values for CUBICSPLINE animations:
        //   [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]
        for ( let i = 0; i !== stride; i ++ ) {

            const p0 = values[ offset0 + i + stride ]; // splineVertex_k
            const m0 = values[ offset0 + i + stride2 ] * td; // outTangent_k * (t_k+1 - t_k)
            const p1 = values[ offset1 + i + stride ]; // splineVertex_k+1
            const m1 = values[ offset1 + i ] * td; // inTangent_k+1 * (t_k+1 - t_k)

            result[ i ] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;

        }

        return result;

    }

}

Methods¶

`copySampleValue_(index: any): any`¶

Code

copySampleValue_( index ) {

        // Copies a sample value to the result buffer. See description of glTF
        // CUBICSPLINE values layout in interpolate_() function below.

        const result = this.resultBuffer,
            values = this.sampleValues,
            valueSize = this.valueSize,
            offset = index * valueSize * 3 + valueSize;

        for ( let i = 0; i !== valueSize; i ++ ) {

            result[ i ] = values[ offset + i ];

        }

        return result;

    }

`interpolate_(i1: any, t0: any, t: any, t1: any): any`¶

Code

interpolate_( i1, t0, t, t1 ) {

        const result = this.resultBuffer;
        const values = this.sampleValues;
        const stride = this.valueSize;

        const stride2 = stride * 2;
        const stride3 = stride * 3;

        const td = t1 - t0;

        const p = ( t - t0 ) / td;
        const pp = p * p;
        const ppp = pp * p;

        const offset1 = i1 * stride3;
        const offset0 = offset1 - stride3;

        const s2 = - 2 * ppp + 3 * pp;
        const s3 = ppp - pp;
        const s0 = 1 - s2;
        const s1 = s3 - pp + p;

        // Layout of keyframe output values for CUBICSPLINE animations:
        //   [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]
        for ( let i = 0; i !== stride; i ++ ) {

            const p0 = values[ offset0 + i + stride ]; // splineVertex_k
            const m0 = values[ offset0 + i + stride2 ] * td; // outTangent_k * (t_k+1 - t_k)
            const p1 = values[ offset1 + i + stride ]; // splineVertex_k+1
            const m1 = values[ offset1 + i ] * td; // inTangent_k+1 * (t_k+1 - t_k)

            result[ i ] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;

        }

        return result;

    }

`GLTFCubicSplineQuaternionInterpolant`¶

Class Code

class GLTFCubicSplineQuaternionInterpolant extends GLTFCubicSplineInterpolant {

    interpolate_( i1, t0, t, t1 ) {

        const result = super.interpolate_( i1, t0, t, t1 );

        _quaternion.fromArray( result ).normalize().toArray( result );

        return result;

    }

}

Methods¶

`interpolate_(i1: any, t0: any, t: any, t1: any): any`¶

Code

interpolate_( i1, t0, t, t1 ) {

        const result = super.interpolate_( i1, t0, t, t1 );

        _quaternion.fromArray( result ).normalize().toArray( result );

        return result;

    }

`GLTFParser`¶

Class Code

class GLTFParser {

    constructor( json = {}, options = {} ) {

        this.json = json;
        this.extensions = {};
        this.plugins = {};
        this.options = options;

        // loader object cache
        this.cache = new GLTFRegistry();

        // associations between Three.js objects and glTF elements
        this.associations = new Map();

        // BufferGeometry caching
        this.primitiveCache = {};

        // Node cache
        this.nodeCache = {};

        // Object3D instance caches
        this.meshCache = { refs: {}, uses: {} };
        this.cameraCache = { refs: {}, uses: {} };
        this.lightCache = { refs: {}, uses: {} };

        this.sourceCache = {};
        this.textureCache = {};

        // Track node names, to ensure no duplicates
        this.nodeNamesUsed = {};

        // Use an ImageBitmapLoader if imageBitmaps are supported. Moves much of the
        // expensive work of uploading a texture to the GPU off the main thread.

        let isSafari = false;
        let safariVersion = - 1;
        let isFirefox = false;
        let firefoxVersion = - 1;

        if ( typeof navigator !== 'undefined' ) {

            const userAgent = navigator.userAgent;

            isSafari = /^((?!chrome|android).)*safari/i.test( userAgent ) === true;
            const safariMatch = userAgent.match( /Version\/(\d+)/ );
            safariVersion = isSafari && safariMatch ? parseInt( safariMatch[ 1 ], 10 ) : - 1;

            isFirefox = userAgent.indexOf( 'Firefox' ) > - 1;
            firefoxVersion = isFirefox ? userAgent.match( /Firefox\/([0-9]+)\./ )[ 1 ] : - 1;

        }

        if ( typeof createImageBitmap === 'undefined' || ( isSafari && safariVersion < 17 ) || ( isFirefox && firefoxVersion < 98 ) ) {

            this.textureLoader = new TextureLoader( this.options.manager );

        } else {

            this.textureLoader = new ImageBitmapLoader( this.options.manager );

        }

        this.textureLoader.setCrossOrigin( this.options.crossOrigin );
        this.textureLoader.setRequestHeader( this.options.requestHeader );

        this.fileLoader = new FileLoader( this.options.manager );
        this.fileLoader.setResponseType( 'arraybuffer' );

        if ( this.options.crossOrigin === 'use-credentials' ) {

            this.fileLoader.setWithCredentials( true );

        }

    }

    setExtensions( extensions ) {

        this.extensions = extensions;

    }

    setPlugins( plugins ) {

        this.plugins = plugins;

    }

    parse( onLoad, onError ) {

        const parser = this;
        const json = this.json;
        const extensions = this.extensions;

        // Clear the loader cache
        this.cache.removeAll();
        this.nodeCache = {};

        // Mark the special nodes/meshes in json for efficient parse
        this._invokeAll( function ( ext ) {

            return ext._markDefs && ext._markDefs();

        } );

        Promise.all( this._invokeAll( function ( ext ) {

            return ext.beforeRoot && ext.beforeRoot();

        } ) ).then( function () {

            return Promise.all( [

                parser.getDependencies( 'scene' ),
                parser.getDependencies( 'animation' ),
                parser.getDependencies( 'camera' ),

            ] );

        } ).then( function ( dependencies ) {

            const result = {
                scene: dependencies[ 0 ][ json.scene || 0 ],
                scenes: dependencies[ 0 ],
                animations: dependencies[ 1 ],
                cameras: dependencies[ 2 ],
                asset: json.asset,
                parser: parser,
                userData: {}
            };

            addUnknownExtensionsToUserData( extensions, result, json );

            assignExtrasToUserData( result, json );

            return Promise.all( parser._invokeAll( function ( ext ) {

                return ext.afterRoot && ext.afterRoot( result );

            } ) ).then( function () {

                for ( const scene of result.scenes ) {

                    scene.updateMatrixWorld();

                }

                onLoad( result );

            } );

        } ).catch( onError );

    }

    /**
     * Marks the special nodes/meshes in json for efficient parse.
     *
     * @private
     */
    _markDefs() {

        const nodeDefs = this.json.nodes || [];
        const skinDefs = this.json.skins || [];
        const meshDefs = this.json.meshes || [];

        // Nothing in the node definition indicates whether it is a Bone or an
        // Object3D. Use the skins' joint references to mark bones.
        for ( let skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex ++ ) {

            const joints = skinDefs[ skinIndex ].joints;

            for ( let i = 0, il = joints.length; i < il; i ++ ) {

                nodeDefs[ joints[ i ] ].isBone = true;

            }

        }

        // Iterate over all nodes, marking references to shared resources,
        // as well as skeleton joints.
        for ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {

            const nodeDef = nodeDefs[ nodeIndex ];

            if ( nodeDef.mesh !== undefined ) {

                this._addNodeRef( this.meshCache, nodeDef.mesh );

                // Nothing in the mesh definition indicates whether it is
                // a SkinnedMesh or Mesh. Use the node's mesh reference
                // to mark SkinnedMesh if node has skin.
                if ( nodeDef.skin !== undefined ) {

                    meshDefs[ nodeDef.mesh ].isSkinnedMesh = true;

                }

            }

            if ( nodeDef.camera !== undefined ) {

                this._addNodeRef( this.cameraCache, nodeDef.camera );

            }

        }

    }

    /**
     * Counts references to shared node / Object3D resources. These resources
     * can be reused, or "instantiated", at multiple nodes in the scene
     * hierarchy. Mesh, Camera, and Light instances are instantiated and must
     * be marked. Non-scenegraph resources (like Materials, Geometries, and
     * Textures) can be reused directly and are not marked here.
     *
     * Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
     *
     * @private
     * @param {Object} cache
     * @param {Object3D} index
     */
    _addNodeRef( cache, index ) {

        if ( index === undefined ) return;

        if ( cache.refs[ index ] === undefined ) {

            cache.refs[ index ] = cache.uses[ index ] = 0;

        }

        cache.refs[ index ] ++;

    }

    /**
     * Returns a reference to a shared resource, cloning it if necessary.
     *
     * @private
     * @param {Object} cache
     * @param {number} index
     * @param {Object} object
     * @return {Object}
     */
    _getNodeRef( cache, index, object ) {

        if ( cache.refs[ index ] <= 1 ) return object;

        const ref = object.clone();

        // Propagates mappings to the cloned object, prevents mappings on the
        // original object from being lost.
        const updateMappings = ( original, clone ) => {

            const mappings = this.associations.get( original );
            if ( mappings != null ) {

                this.associations.set( clone, mappings );

            }

            for ( const [ i, child ] of original.children.entries() ) {

                updateMappings( child, clone.children[ i ] );

            }

        };

        updateMappings( object, ref );

        ref.name += '_instance_' + ( cache.uses[ index ] ++ );

        return ref;

    }

    _invokeOne( func ) {

        const extensions = Object.values( this.plugins );
        extensions.push( this );

        for ( let i = 0; i < extensions.length; i ++ ) {

            const result = func( extensions[ i ] );

            if ( result ) return result;

        }

        return null;

    }

    _invokeAll( func ) {

        const extensions = Object.values( this.plugins );
        extensions.unshift( this );

        const pending = [];

        for ( let i = 0; i < extensions.length; i ++ ) {

            const result = func( extensions[ i ] );

            if ( result ) pending.push( result );

        }

        return pending;

    }

    /**
     * Requests the specified dependency asynchronously, with caching.
     *
     * @private
     * @param {string} type
     * @param {number} index
     * @return {Promise<Object3D|Material|THREE.Texture|AnimationClip|ArrayBuffer|Object>}
     */
    getDependency( type, index ) {

        const cacheKey = type + ':' + index;
        let dependency = this.cache.get( cacheKey );

        if ( ! dependency ) {

            switch ( type ) {

                case 'scene':
                    dependency = this.loadScene( index );
                    break;

                case 'node':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadNode && ext.loadNode( index );

                    } );
                    break;

                case 'mesh':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadMesh && ext.loadMesh( index );

                    } );
                    break;

                case 'accessor':
                    dependency = this.loadAccessor( index );
                    break;

                case 'bufferView':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadBufferView && ext.loadBufferView( index );

                    } );
                    break;

                case 'buffer':
                    dependency = this.loadBuffer( index );
                    break;

                case 'material':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadMaterial && ext.loadMaterial( index );

                    } );
                    break;

                case 'texture':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadTexture && ext.loadTexture( index );

                    } );
                    break;

                case 'skin':
                    dependency = this.loadSkin( index );
                    break;

                case 'animation':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadAnimation && ext.loadAnimation( index );

                    } );
                    break;

                case 'camera':
                    dependency = this.loadCamera( index );
                    break;

                default:
                    dependency = this._invokeOne( function ( ext ) {

                        return ext != this && ext.getDependency && ext.getDependency( type, index );

                    } );

                    if ( ! dependency ) {

                        throw new Error( 'Unknown type: ' + type );

                    }

                    break;

            }

            this.cache.add( cacheKey, dependency );

        }

        return dependency;

    }

    /**
     * Requests all dependencies of the specified type asynchronously, with caching.
     *
     * @private
     * @param {string} type
     * @return {Promise<Array<Object>>}
     */
    getDependencies( type ) {

        let dependencies = this.cache.get( type );

        if ( ! dependencies ) {

            const parser = this;
            const defs = this.json[ type + ( type === 'mesh' ? 'es' : 's' ) ] || [];

            dependencies = Promise.all( defs.map( function ( def, index ) {

                return parser.getDependency( type, index );

            } ) );

            this.cache.add( type, dependencies );

        }

        return dependencies;

    }

    /**
     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
     *
     * @private
     * @param {number} bufferIndex
     * @return {Promise<ArrayBuffer>}
     */
    loadBuffer( bufferIndex ) {

        const bufferDef = this.json.buffers[ bufferIndex ];
        const loader = this.fileLoader;

        if ( bufferDef.type && bufferDef.type !== 'arraybuffer' ) {

            throw new Error( 'THREE.GLTFLoader: ' + bufferDef.type + ' buffer type is not supported.' );

        }

        // If present, GLB container is required to be the first buffer.
        if ( bufferDef.uri === undefined && bufferIndex === 0 ) {

            return Promise.resolve( this.extensions[ EXTENSIONS.KHR_BINARY_GLTF ].body );

        }

        const options = this.options;

        return new Promise( function ( resolve, reject ) {

            loader.load( LoaderUtils.resolveURL( bufferDef.uri, options.path ), resolve, undefined, function () {

                reject( new Error( 'THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".' ) );

            } );

        } );

    }

    /**
     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
     *
     * @private
     * @param {number} bufferViewIndex
     * @return {Promise<ArrayBuffer>}
     */
    loadBufferView( bufferViewIndex ) {

        const bufferViewDef = this.json.bufferViews[ bufferViewIndex ];

        return this.getDependency( 'buffer', bufferViewDef.buffer ).then( function ( buffer ) {

            const byteLength = bufferViewDef.byteLength || 0;
            const byteOffset = bufferViewDef.byteOffset || 0;
            return buffer.slice( byteOffset, byteOffset + byteLength );

        } );

    }

    /**
     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
     *
     * @private
     * @param {number} accessorIndex
     * @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
     */
    loadAccessor( accessorIndex ) {

        const parser = this;
        const json = this.json;

        const accessorDef = this.json.accessors[ accessorIndex ];

        if ( accessorDef.bufferView === undefined && accessorDef.sparse === undefined ) {

            const itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];
            const TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
            const normalized = accessorDef.normalized === true;

            const array = new TypedArray( accessorDef.count * itemSize );
            return Promise.resolve( new BufferAttribute( array, itemSize, normalized ) );

        }

        const pendingBufferViews = [];

        if ( accessorDef.bufferView !== undefined ) {

            pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.bufferView ) );

        } else {

            pendingBufferViews.push( null );

        }

        if ( accessorDef.sparse !== undefined ) {

            pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.indices.bufferView ) );
            pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.values.bufferView ) );

        }

        return Promise.all( pendingBufferViews ).then( function ( bufferViews ) {

            const bufferView = bufferViews[ 0 ];

            const itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];
            const TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];

            // For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12.
            const elementBytes = TypedArray.BYTES_PER_ELEMENT;
            const itemBytes = elementBytes * itemSize;
            const byteOffset = accessorDef.byteOffset || 0;
            const byteStride = accessorDef.bufferView !== undefined ? json.bufferViews[ accessorDef.bufferView ].byteStride : undefined;
            const normalized = accessorDef.normalized === true;
            let array, bufferAttribute;

            // The buffer is not interleaved if the stride is the item size in bytes.
            if ( byteStride && byteStride !== itemBytes ) {

                // Each "slice" of the buffer, as defined by 'count' elements of 'byteStride' bytes, gets its own InterleavedBuffer
                // This makes sure that IBA.count reflects accessor.count properly
                const ibSlice = Math.floor( byteOffset / byteStride );
                const ibCacheKey = 'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentType + ':' + ibSlice + ':' + accessorDef.count;
                let ib = parser.cache.get( ibCacheKey );

                if ( ! ib ) {

                    array = new TypedArray( bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes );

                    // Integer parameters to IB/IBA are in array elements, not bytes.
                    ib = new InterleavedBuffer( array, byteStride / elementBytes );

                    parser.cache.add( ibCacheKey, ib );

                }

                bufferAttribute = new InterleavedBufferAttribute( ib, itemSize, ( byteOffset % byteStride ) / elementBytes, normalized );

            } else {

                if ( bufferView === null ) {

                    array = new TypedArray( accessorDef.count * itemSize );

                } else {

                    array = new TypedArray( bufferView, byteOffset, accessorDef.count * itemSize );

                }

                bufferAttribute = new BufferAttribute( array, itemSize, normalized );

            }

            // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#sparse-accessors
            if ( accessorDef.sparse !== undefined ) {

                const itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR;
                const TypedArrayIndices = WEBGL_COMPONENT_TYPES[ accessorDef.sparse.indices.componentType ];

                const byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0;
                const byteOffsetValues = accessorDef.sparse.values.byteOffset || 0;

                const sparseIndices = new TypedArrayIndices( bufferViews[ 1 ], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices );
                const sparseValues = new TypedArray( bufferViews[ 2 ], byteOffsetValues, accessorDef.sparse.count * itemSize );

                if ( bufferView !== null ) {

                    // Avoid modifying the original ArrayBuffer, if the bufferView wasn't initialized with zeroes.
                    bufferAttribute = new BufferAttribute( bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized );

                }

                // Ignore normalized since we copy from sparse
                bufferAttribute.normalized = false;

                for ( let i = 0, il = sparseIndices.length; i < il; i ++ ) {

                    const index = sparseIndices[ i ];

                    bufferAttribute.setX( index, sparseValues[ i * itemSize ] );
                    if ( itemSize >= 2 ) bufferAttribute.setY( index, sparseValues[ i * itemSize + 1 ] );
                    if ( itemSize >= 3 ) bufferAttribute.setZ( index, sparseValues[ i * itemSize + 2 ] );
                    if ( itemSize >= 4 ) bufferAttribute.setW( index, sparseValues[ i * itemSize + 3 ] );
                    if ( itemSize >= 5 ) throw new Error( 'THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.' );

                }

                bufferAttribute.normalized = normalized;

            }

            return bufferAttribute;

        } );

    }

    /**
     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
     *
     * @private
     * @param {number} textureIndex
     * @return {Promise<THREE.Texture|null>}
     */
    loadTexture( textureIndex ) {

        const json = this.json;
        const options = this.options;
        const textureDef = json.textures[ textureIndex ];
        const sourceIndex = textureDef.source;
        const sourceDef = json.images[ sourceIndex ];

        let loader = this.textureLoader;

        if ( sourceDef.uri ) {

            const handler = options.manager.getHandler( sourceDef.uri );
            if ( handler !== null ) loader = handler;

        }

        return this.loadTextureImage( textureIndex, sourceIndex, loader );

    }

    loadTextureImage( textureIndex, sourceIndex, loader ) {

        const parser = this;
        const json = this.json;

        const textureDef = json.textures[ textureIndex ];
        const sourceDef = json.images[ sourceIndex ];

        const cacheKey = ( sourceDef.uri || sourceDef.bufferView ) + ':' + textureDef.sampler;

        if ( this.textureCache[ cacheKey ] ) {

            // See https://github.com/mrdoob/three.js/issues/21559.
            return this.textureCache[ cacheKey ];

        }

        const promise = this.loadImageSource( sourceIndex, loader ).then( function ( texture ) {

            texture.flipY = false;

            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 ] || {};

            texture.magFilter = WEBGL_FILTERS[ sampler.magFilter ] || LinearFilter;
            texture.minFilter = WEBGL_FILTERS[ sampler.minFilter ] || LinearMipmapLinearFilter;
            texture.wrapS = WEBGL_WRAPPINGS[ sampler.wrapS ] || RepeatWrapping;
            texture.wrapT = WEBGL_WRAPPINGS[ sampler.wrapT ] || RepeatWrapping;
            texture.generateMipmaps = ! texture.isCompressedTexture && texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter;

            parser.associations.set( texture, { textures: textureIndex } );

            return texture;

        } ).catch( function () {

            return null;

        } );

        this.textureCache[ cacheKey ] = promise;

        return promise;

    }

    loadImageSource( sourceIndex, loader ) {

        const parser = this;
        const json = this.json;
        const options = this.options;

        if ( this.sourceCache[ sourceIndex ] !== undefined ) {

            return this.sourceCache[ sourceIndex ].then( ( texture ) => texture.clone() );

        }

        const sourceDef = json.images[ sourceIndex ];

        const URL = self.URL || self.webkitURL;

        let sourceURI = sourceDef.uri || '';
        let isObjectURL = false;

        if ( sourceDef.bufferView !== undefined ) {

            // Load binary image data from bufferView, if provided.

            sourceURI = parser.getDependency( 'bufferView', sourceDef.bufferView ).then( function ( bufferView ) {

                isObjectURL = true;
                const blob = new Blob( [ bufferView ], { type: sourceDef.mimeType } );
                sourceURI = URL.createObjectURL( blob );
                return sourceURI;

            } );

        } else if ( sourceDef.uri === undefined ) {

            throw new Error( 'THREE.GLTFLoader: Image ' + sourceIndex + ' is missing URI and bufferView' );

        }

        const promise = Promise.resolve( sourceURI ).then( function ( sourceURI ) {

            return new Promise( function ( resolve, reject ) {

                let onLoad = resolve;

                if ( loader.isImageBitmapLoader === true ) {

                    onLoad = function ( imageBitmap ) {

                        const texture = new Texture( imageBitmap );
                        texture.needsUpdate = true;

                        resolve( texture );

                    };

                }

                loader.load( LoaderUtils.resolveURL( sourceURI, options.path ), onLoad, undefined, reject );

            } );

        } ).then( function ( texture ) {

            // Clean up resources and configure Texture.

            if ( isObjectURL === true ) {

                URL.revokeObjectURL( sourceURI );

            }

            assignExtrasToUserData( texture, sourceDef );

            texture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType( sourceDef.uri );

            return texture;

        } ).catch( function ( error ) {

            console.error( 'THREE.GLTFLoader: Couldn\'t load texture', sourceURI );
            throw error;

        } );

        this.sourceCache[ sourceIndex ] = promise;
        return promise;

    }

    /**
     * Asynchronously assigns a texture to the given material parameters.
     *
     * @private
     * @param {Object} materialParams
     * @param {string} mapName
     * @param {Object} mapDef
     * @param {string} [colorSpace]
     * @return {Promise<Texture>}
     */
    assignTexture( materialParams, mapName, mapDef, colorSpace ) {

        const parser = this;

        return this.getDependency( 'texture', mapDef.index ).then( function ( texture ) {

            if ( ! texture ) return null;

            if ( mapDef.texCoord !== undefined && mapDef.texCoord > 0 ) {

                texture = texture.clone();
                texture.channel = mapDef.texCoord;

            }

            if ( parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] ) {

                const transform = mapDef.extensions !== undefined ? mapDef.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] : undefined;

                if ( transform ) {

                    const gltfReference = parser.associations.get( texture );
                    texture = parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ].extendTexture( texture, transform );
                    parser.associations.set( texture, gltfReference );

                }

            }

            if ( colorSpace !== undefined ) {

                texture.colorSpace = colorSpace;

            }

            materialParams[ mapName ] = texture;

            return texture;

        } );

    }

    /**
     * Assigns final material to a Mesh, Line, or Points instance. The instance
     * already has a material (generated from the glTF material options alone)
     * but reuse of the same glTF material may require multiple threejs materials
     * to accommodate different primitive types, defines, etc. New materials will
     * be created if necessary, and reused from a cache.
     *
     * @private
     * @param {Object3D} mesh Mesh, Line, or Points instance.
     */
    assignFinalMaterial( mesh ) {

        const geometry = mesh.geometry;
        let material = mesh.material;

        const useDerivativeTangents = geometry.attributes.tangent === undefined;
        const useVertexColors = geometry.attributes.color !== undefined;
        const useFlatShading = geometry.attributes.normal === undefined;

        if ( mesh.isPoints ) {

            const cacheKey = 'PointsMaterial:' + material.uuid;

            let pointsMaterial = this.cache.get( cacheKey );

            if ( ! pointsMaterial ) {

                pointsMaterial = new PointsMaterial();
                Material.prototype.copy.call( pointsMaterial, material );
                pointsMaterial.color.copy( material.color );
                pointsMaterial.map = material.map;
                pointsMaterial.sizeAttenuation = false; // glTF spec says points should be 1px

                this.cache.add( cacheKey, pointsMaterial );

            }

            material = pointsMaterial;

        } else if ( mesh.isLine ) {

            const cacheKey = 'LineBasicMaterial:' + material.uuid;

            let lineMaterial = this.cache.get( cacheKey );

            if ( ! lineMaterial ) {

                lineMaterial = new LineBasicMaterial();
                Material.prototype.copy.call( lineMaterial, material );
                lineMaterial.color.copy( material.color );
                lineMaterial.map = material.map;

                this.cache.add( cacheKey, lineMaterial );

            }

            material = lineMaterial;

        }

        // Clone the material if it will be modified
        if ( useDerivativeTangents || useVertexColors || useFlatShading ) {

            let cacheKey = 'ClonedMaterial:' + material.uuid + ':';

            if ( useDerivativeTangents ) cacheKey += 'derivative-tangents:';
            if ( useVertexColors ) cacheKey += 'vertex-colors:';
            if ( useFlatShading ) cacheKey += 'flat-shading:';

            let cachedMaterial = this.cache.get( cacheKey );

            if ( ! cachedMaterial ) {

                cachedMaterial = material.clone();

                if ( useVertexColors ) cachedMaterial.vertexColors = true;
                if ( useFlatShading ) cachedMaterial.flatShading = true;

                if ( useDerivativeTangents ) {

                    // https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
                    if ( cachedMaterial.normalScale ) cachedMaterial.normalScale.y *= - 1;
                    if ( cachedMaterial.clearcoatNormalScale ) cachedMaterial.clearcoatNormalScale.y *= - 1;

                }

                this.cache.add( cacheKey, cachedMaterial );

                this.associations.set( cachedMaterial, this.associations.get( material ) );

            }

            material = cachedMaterial;

        }

        mesh.material = material;

    }

    getMaterialType( /* materialIndex */ ) {

        return MeshStandardMaterial;

    }

    /**
     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
     *
     * @private
     * @param {number} materialIndex
     * @return {Promise<Material>}
     */
    loadMaterial( materialIndex ) {

        const parser = this;
        const json = this.json;
        const extensions = this.extensions;
        const materialDef = json.materials[ materialIndex ];

        let materialType;
        const materialParams = {};
        const materialExtensions = materialDef.extensions || {};

        const pending = [];

        if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ] ) {

            const kmuExtension = extensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ];
            materialType = kmuExtension.getMaterialType();
            pending.push( kmuExtension.extendParams( materialParams, materialDef, parser ) );

        } else {

            // Specification:
            // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#metallic-roughness-material

            const metallicRoughness = materialDef.pbrMetallicRoughness || {};

            materialParams.color = new Color( 1.0, 1.0, 1.0 );
            materialParams.opacity = 1.0;

            if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {

                const array = metallicRoughness.baseColorFactor;

                materialParams.color.setRGB( array[ 0 ], array[ 1 ], array[ 2 ], LinearSRGBColorSpace );
                materialParams.opacity = array[ 3 ];

            }

            if ( metallicRoughness.baseColorTexture !== undefined ) {

                pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) );

            }

            materialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0;
            materialParams.roughness = metallicRoughness.roughnessFactor !== undefined ? metallicRoughness.roughnessFactor : 1.0;

            if ( metallicRoughness.metallicRoughnessTexture !== undefined ) {

                pending.push( parser.assignTexture( materialParams, 'metalnessMap', metallicRoughness.metallicRoughnessTexture ) );
                pending.push( parser.assignTexture( materialParams, 'roughnessMap', metallicRoughness.metallicRoughnessTexture ) );

            }

            materialType = this._invokeOne( function ( ext ) {

                return ext.getMaterialType && ext.getMaterialType( materialIndex );

            } );

            pending.push( Promise.all( this._invokeAll( function ( ext ) {

                return ext.extendMaterialParams && ext.extendMaterialParams( materialIndex, materialParams );

            } ) ) );

        }

        if ( materialDef.doubleSided === true ) {

            materialParams.side = DoubleSide;

        }

        const alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE;

        if ( alphaMode === ALPHA_MODES.BLEND ) {

            materialParams.transparent = true;

            // See: https://github.com/mrdoob/three.js/issues/17706
            materialParams.depthWrite = false;

        } else {

            materialParams.transparent = false;

            if ( alphaMode === ALPHA_MODES.MASK ) {

                materialParams.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : 0.5;

            }

        }

        if ( materialDef.normalTexture !== undefined && materialType !== MeshBasicMaterial ) {

            pending.push( parser.assignTexture( materialParams, 'normalMap', materialDef.normalTexture ) );

            materialParams.normalScale = new Vector2( 1, 1 );

            if ( materialDef.normalTexture.scale !== undefined ) {

                const scale = materialDef.normalTexture.scale;

                materialParams.normalScale.set( scale, scale );

            }

        }

        if ( materialDef.occlusionTexture !== undefined && materialType !== MeshBasicMaterial ) {

            pending.push( parser.assignTexture( materialParams, 'aoMap', materialDef.occlusionTexture ) );

            if ( materialDef.occlusionTexture.strength !== undefined ) {

                materialParams.aoMapIntensity = materialDef.occlusionTexture.strength;

            }

        }

        if ( materialDef.emissiveFactor !== undefined && materialType !== MeshBasicMaterial ) {

            const emissiveFactor = materialDef.emissiveFactor;
            materialParams.emissive = new Color().setRGB( emissiveFactor[ 0 ], emissiveFactor[ 1 ], emissiveFactor[ 2 ], LinearSRGBColorSpace );

        }

        if ( materialDef.emissiveTexture !== undefined && materialType !== MeshBasicMaterial ) {

            pending.push( parser.assignTexture( materialParams, 'emissiveMap', materialDef.emissiveTexture, SRGBColorSpace ) );

        }

        return Promise.all( pending ).then( function () {

            const material = new materialType( materialParams );

            if ( materialDef.name ) material.name = materialDef.name;

            assignExtrasToUserData( material, materialDef );

            parser.associations.set( material, { materials: materialIndex } );

            if ( materialDef.extensions ) addUnknownExtensionsToUserData( extensions, material, materialDef );

            return material;

        } );

    }

    /**
     * When Object3D instances are targeted by animation, they need unique names.
     *
     * @private
     * @param {string} originalName
     * @return {string}
     */
    createUniqueName( originalName ) {

        const sanitizedName = PropertyBinding.sanitizeNodeName( originalName || '' );

        if ( sanitizedName in this.nodeNamesUsed ) {

            return sanitizedName + '_' + ( ++ this.nodeNamesUsed[ sanitizedName ] );

        } else {

            this.nodeNamesUsed[ sanitizedName ] = 0;

            return sanitizedName;

        }

    }

    /**
     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
     *
     * Creates BufferGeometries from primitives.
     *
     * @private
     * @param {Array<GLTF.Primitive>} primitives
     * @return {Promise<Array<BufferGeometry>>}
     */
    loadGeometries( primitives ) {

        const parser = this;
        const extensions = this.extensions;
        const cache = this.primitiveCache;

        function createDracoPrimitive( primitive ) {

            return extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ]
                .decodePrimitive( primitive, parser )
                .then( function ( geometry ) {

                    return addPrimitiveAttributes( geometry, primitive, parser );

                } );

        }

        const pending = [];

        for ( let i = 0, il = primitives.length; i < il; i ++ ) {

            const primitive = primitives[ i ];
            const cacheKey = createPrimitiveKey( primitive );

            // See if we've already created this geometry
            const cached = cache[ cacheKey ];

            if ( cached ) {

                // Use the cached geometry if it exists
                pending.push( cached.promise );

            } else {

                let geometryPromise;

                if ( primitive.extensions && primitive.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ] ) {

                    // Use DRACO geometry if available
                    geometryPromise = createDracoPrimitive( primitive );

                } else {

                    // Otherwise create a new geometry
                    geometryPromise = addPrimitiveAttributes( new BufferGeometry(), primitive, parser );

                }

                // Cache this geometry
                cache[ cacheKey ] = { primitive: primitive, promise: geometryPromise };

                pending.push( geometryPromise );

            }

        }

        return Promise.all( pending );

    }

    /**
     * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
     *
     * @private
     * @param {number} meshIndex
     * @return {Promise<Group|Mesh|SkinnedMesh|Line|Points>}
     */
    loadMesh( meshIndex ) {

        const parser = this;
        const json = this.json;
        const extensions = this.extensions;

        const meshDef = json.meshes[ meshIndex ];
        const primitives = meshDef.primitives;

        const pending = [];

        for ( let i = 0, il = primitives.length; i < il; i ++ ) {

            const material = primitives[ i ].material === undefined
                ? createDefaultMaterial( this.cache )
                : this.getDependency( 'material', primitives[ i ].material );

            pending.push( material );

        }

        pending.push( parser.loadGeometries( primitives ) );

        return Promise.all( pending ).then( function ( results ) {

            const materials = results.slice( 0, results.length - 1 );
            const geometries = results[ results.length - 1 ];

            const meshes = [];

            for ( let i = 0, il = geometries.length; i < il; i ++ ) {

                const geometry = geometries[ i ];
                const primitive = primitives[ i ];

                // 1. create Mesh

                let mesh;

                const material = materials[ i ];

                if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLES ||
                        primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ||
                        primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ||
                        primitive.mode === undefined ) {

                    // .isSkinnedMesh isn't in glTF spec. See ._markDefs()
                    mesh = meshDef.isSkinnedMesh === true
                        ? new SkinnedMesh( geometry, material )
                        : new Mesh( geometry, material );

                    if ( mesh.isSkinnedMesh === true ) {

                        // normalize skin weights to fix malformed assets (see #15319)
                        mesh.normalizeSkinWeights();

                    }

                    if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ) {

                        mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleStripDrawMode );

                    } else if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ) {

                        mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleFanDrawMode );

                    }

                } else if ( primitive.mode === WEBGL_CONSTANTS.LINES ) {

                    mesh = new LineSegments( geometry, material );

                } else if ( primitive.mode === WEBGL_CONSTANTS.LINE_STRIP ) {

                    mesh = new Line( geometry, material );

                } else if ( primitive.mode === WEBGL_CONSTANTS.LINE_LOOP ) {

                    mesh = new LineLoop( geometry, material );

                } else if ( primitive.mode === WEBGL_CONSTANTS.POINTS ) {

                    mesh = new Points( geometry, material );

                } else {

                    throw new Error( 'THREE.GLTFLoader: Primitive mode unsupported: ' + primitive.mode );

                }

                if ( Object.keys( mesh.geometry.morphAttributes ).length > 0 ) {

                    updateMorphTargets( mesh, meshDef );

                }

                mesh.name = parser.createUniqueName( meshDef.name || ( 'mesh_' + meshIndex ) );

                assignExtrasToUserData( mesh, meshDef );

                if ( primitive.extensions ) addUnknownExtensionsToUserData( extensions, mesh, primitive );

                parser.assignFinalMaterial( mesh );

                meshes.push( mesh );

            }

            for ( let i = 0, il = meshes.length; i < il; i ++ ) {

                parser.associations.set( meshes[ i ], {
                    meshes: meshIndex,
                    primitives: i
                } );

            }

            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 ++ ) {

                group.add( meshes[ i ] );

            }

            return group;

        } );

    }

    /**
     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
     *
     * @private
     * @param {number} cameraIndex
     * @return {Promise<THREE.Camera>}
     */
    loadCamera( cameraIndex ) {

        let camera;
        const cameraDef = this.json.cameras[ cameraIndex ];
        const params = cameraDef[ cameraDef.type ];

        if ( ! params ) {

            console.warn( 'THREE.GLTFLoader: Missing camera parameters.' );
            return;

        }

        if ( cameraDef.type === 'perspective' ) {

            camera = new PerspectiveCamera( MathUtils.radToDeg( params.yfov ), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6 );

        } else if ( cameraDef.type === 'orthographic' ) {

            camera = new OrthographicCamera( - params.xmag, params.xmag, params.ymag, - params.ymag, params.znear, params.zfar );

        }

        if ( cameraDef.name ) camera.name = this.createUniqueName( cameraDef.name );

        assignExtrasToUserData( camera, cameraDef );

        return Promise.resolve( camera );

    }

    /**
     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
     *
     * @private
     * @param {number} skinIndex
     * @return {Promise<Skeleton>}
     */
    loadSkin( skinIndex ) {

        const skinDef = this.json.skins[ skinIndex ];

        const pending = [];

        for ( let i = 0, il = skinDef.joints.length; i < il; i ++ ) {

            pending.push( this._loadNodeShallow( skinDef.joints[ i ] ) );

        }

        if ( skinDef.inverseBindMatrices !== undefined ) {

            pending.push( this.getDependency( 'accessor', skinDef.inverseBindMatrices ) );

        } else {

            pending.push( null );

        }

        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 {

                    console.warn( 'THREE.GLTFLoader: Joint "%s" could not be found.', skinDef.joints[ i ] );

                }

            }

            return new Skeleton( bones, boneInverses );

        } );

    }

    /**
     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
     *
     * @private
     * @param {number} animationIndex
     * @return {Promise<AnimationClip>}
     */
    loadAnimation( animationIndex ) {

        const json = this.json;
        const parser = this;

        const animationDef = json.animations[ animationIndex ];
        const animationName = animationDef.name ? animationDef.name : 'animation_' + animationIndex;

        const pendingNodes = [];
        const pendingInputAccessors = [];
        const pendingOutputAccessors = [];
        const pendingSamplers = [];
        const pendingTargets = [];

        for ( let i = 0, il = animationDef.channels.length; i < il; i ++ ) {

            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;

            if ( target.node === undefined ) continue;

            pendingNodes.push( this.getDependency( 'node', name ) );
            pendingInputAccessors.push( this.getDependency( 'accessor', input ) );
            pendingOutputAccessors.push( this.getDependency( 'accessor', output ) );
            pendingSamplers.push( sampler );
            pendingTargets.push( target );

        }

        return Promise.all( [

            Promise.all( pendingNodes ),
            Promise.all( pendingInputAccessors ),
            Promise.all( pendingOutputAccessors ),
            Promise.all( pendingSamplers ),
            Promise.all( pendingTargets )

        ] ).then( function ( dependencies ) {

            const nodes = dependencies[ 0 ];
            const inputAccessors = dependencies[ 1 ];
            const outputAccessors = dependencies[ 2 ];
            const samplers = dependencies[ 3 ];
            const targets = dependencies[ 4 ];

            const tracks = [];

            for ( let i = 0, il = nodes.length; i < il; i ++ ) {

                const node = nodes[ i ];
                const inputAccessor = inputAccessors[ i ];
                const outputAccessor = outputAccessors[ i ];
                const sampler = samplers[ i ];
                const target = targets[ i ];

                if ( node === undefined ) continue;

                if ( node.updateMatrix ) {

                    node.updateMatrix();

                }

                const createdTracks = parser._createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target );

                if ( createdTracks ) {

                    for ( let k = 0; k < createdTracks.length; k ++ ) {

                        tracks.push( createdTracks[ k ] );

                    }

                }

            }

            return new AnimationClip( animationName, undefined, tracks );

        } );

    }

    createNodeMesh( nodeIndex ) {

        const json = this.json;
        const parser = this;
        const nodeDef = json.nodes[ nodeIndex ];

        if ( nodeDef.mesh === undefined ) return null;

        return parser.getDependency( 'mesh', nodeDef.mesh ).then( function ( mesh ) {

            const node = parser._getNodeRef( parser.meshCache, nodeDef.mesh, mesh );

            // if weights are provided on the node, override weights on the mesh.
            if ( nodeDef.weights !== undefined ) {

                node.traverse( function ( o ) {

                    if ( ! o.isMesh ) return;

                    for ( let i = 0, il = nodeDef.weights.length; i < il; i ++ ) {

                        o.morphTargetInfluences[ i ] = nodeDef.weights[ i ];

                    }

                } );

            }

            return node;

        } );

    }

    /**
     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
     *
     * @private
     * @param {number} nodeIndex
     * @return {Promise<Object3D>}
     */
    loadNode( nodeIndex ) {

        const json = this.json;
        const parser = this;

        const nodeDef = json.nodes[ nodeIndex ];

        const nodePending = parser._loadNodeShallow( nodeIndex );

        const childPending = [];
        const childrenDef = nodeDef.children || [];

        for ( let i = 0, il = childrenDef.length; i < il; i ++ ) {

            childPending.push( parser.getDependency( 'node', childrenDef[ i ] ) );

        }

        const skeletonPending = nodeDef.skin === undefined
            ? Promise.resolve( null )
            : parser.getDependency( 'skin', nodeDef.skin );

        return Promise.all( [
            nodePending,
            Promise.all( childPending ),
            skeletonPending
        ] ).then( function ( results ) {

            const node = results[ 0 ];
            const children = results[ 1 ];
            const skeleton = results[ 2 ];

            if ( skeleton !== null ) {

                // This full traverse should be fine because
                // child glTF nodes have not been added to this node yet.
                node.traverse( function ( mesh ) {

                    if ( ! mesh.isSkinnedMesh ) return;

                    mesh.bind( skeleton, _identityMatrix );

                } );

            }

            for ( let i = 0, il = children.length; i < il; i ++ ) {

                node.add( children[ i ] );

            }

            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 );

        } );

        if ( meshPromise ) {

            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;

            // .isBone isn't in glTF spec. See ._markDefs
            if ( nodeDef.isBone === true ) {

                node = new Bone();

            } else if ( objects.length > 1 ) {

                node = new Group();

            } else if ( objects.length === 1 ) {

                node = objects[ 0 ];

            } else {

                node = new Object3D();

            }

            if ( node !== objects[ 0 ] ) {

                for ( let i = 0, il = objects.length; i < il; i ++ ) {

                    node.add( objects[ i ] );

                }

            }

            if ( nodeDef.name ) {

                node.userData.name = nodeDef.name;
                node.name = nodeName;

            }

            assignExtrasToUserData( node, nodeDef );

            if ( nodeDef.extensions ) addUnknownExtensionsToUserData( extensions, node, nodeDef );

            if ( nodeDef.matrix !== undefined ) {

                const matrix = new Matrix4();
                matrix.fromArray( nodeDef.matrix );
                node.applyMatrix4( matrix );

            } else {

                if ( nodeDef.translation !== undefined ) {

                    node.position.fromArray( nodeDef.translation );

                }

                if ( nodeDef.rotation !== undefined ) {

                    node.quaternion.fromArray( nodeDef.rotation );

                }

                if ( nodeDef.scale !== undefined ) {

                    node.scale.fromArray( nodeDef.scale );

                }

            }

            if ( ! parser.associations.has( node ) ) {

                parser.associations.set( node, {} );

            } else if ( nodeDef.mesh !== undefined && parser.meshCache.refs[ nodeDef.mesh ] > 1 ) {

                const mapping = parser.associations.get( node );
                parser.associations.set( node, { ...mapping } );

            }

            parser.associations.get( node ).nodes = nodeIndex;

            return node;

        } );

        return this.nodeCache[ nodeIndex ];

    }

    /**
     * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
     *
     * @private
     * @param {number} sceneIndex
     * @return {Promise<Group>}
     */
    loadScene( sceneIndex ) {

        const extensions = this.extensions;
        const sceneDef = this.json.scenes[ sceneIndex ];
        const parser = this;

        // Loader returns Group, not Scene.
        // See: https://github.com/mrdoob/three.js/issues/18342#issuecomment-578981172
        const scene = new Group();
        if ( sceneDef.name ) scene.name = parser.createUniqueName( sceneDef.name );

        assignExtrasToUserData( scene, sceneDef );

        if ( sceneDef.extensions ) addUnknownExtensionsToUserData( extensions, scene, sceneDef );

        const nodeIds = sceneDef.nodes || [];

        const pending = [];

        for ( let i = 0, il = nodeIds.length; i < il; i ++ ) {

            pending.push( parser.getDependency( 'node', nodeIds[ i ] ) );

        }

        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.
            const reduceAssociations = ( node ) => {

                const reducedAssociations = new Map();

                for ( const [ key, value ] of parser.associations ) {

                    if ( key instanceof Material || key instanceof Texture ) {

                        reducedAssociations.set( key, value );

                    }

                }

                node.traverse( ( node ) => {

                    const mappings = parser.associations.get( node );

                    if ( mappings != null ) {

                        reducedAssociations.set( node, mappings );

                    }

                } );

                return reducedAssociations;

            };

            parser.associations = reduceAssociations( scene );

            return scene;

        } );

    }

    _createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target ) {

        const tracks = [];

        const targetName = node.name ? node.name : node.uuid;
        const targetNames = [];

        if ( PATH_PROPERTIES[ target.path ] === PATH_PROPERTIES.weights ) {

            node.traverse( function ( object ) {

                if ( object.morphTargetInfluences ) {

                    targetNames.push( object.name ? object.name : object.uuid );

                }

            } );

        } else {

            targetNames.push( targetName );

        }

        let TypedKeyframeTrack;

        switch ( PATH_PROPERTIES[ target.path ] ) {

            case PATH_PROPERTIES.weights:

                TypedKeyframeTrack = NumberKeyframeTrack;
                break;

            case PATH_PROPERTIES.rotation:

                TypedKeyframeTrack = QuaternionKeyframeTrack;
                break;

            case PATH_PROPERTIES.translation:
            case PATH_PROPERTIES.scale:

                TypedKeyframeTrack = VectorKeyframeTrack;
                break;

            default:

                switch ( outputAccessor.itemSize ) {

                    case 1:
                        TypedKeyframeTrack = NumberKeyframeTrack;
                        break;
                    case 2:
                    case 3:
                    default:
                        TypedKeyframeTrack = VectorKeyframeTrack;
                        break;

                }

                break;

        }

        const interpolation = sampler.interpolation !== undefined ? INTERPOLATION[ sampler.interpolation ] : InterpolateLinear;


        const outputArray = this._getArrayFromAccessor( outputAccessor );

        for ( let j = 0, jl = targetNames.length; j < jl; j ++ ) {

            const track = new TypedKeyframeTrack(
                targetNames[ j ] + '.' + PATH_PROPERTIES[ target.path ],
                inputAccessor.array,
                outputArray,
                interpolation
            );

            // Override interpolation with custom factory method.
            if ( sampler.interpolation === 'CUBICSPLINE' ) {

                this._createCubicSplineTrackInterpolant( track );

            }

            tracks.push( track );

        }

        return tracks;

    }

    _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;

    }

    _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;

    }

}

Methods¶

`setExtensions(extensions: any): void`¶

Code

setExtensions( extensions ) {

        this.extensions = extensions;

    }

`setPlugins(plugins: any): void`¶

Code

setPlugins( plugins ) {

        this.plugins = plugins;

    }

`parse(onLoad: any, onError: any): void`¶

Code

parse( onLoad, onError ) {

        const parser = this;
        const json = this.json;
        const extensions = this.extensions;

        // Clear the loader cache
        this.cache.removeAll();
        this.nodeCache = {};

        // Mark the special nodes/meshes in json for efficient parse
        this._invokeAll( function ( ext ) {

            return ext._markDefs && ext._markDefs();

        } );

        Promise.all( this._invokeAll( function ( ext ) {

            return ext.beforeRoot && ext.beforeRoot();

        } ) ).then( function () {

            return Promise.all( [

                parser.getDependencies( 'scene' ),
                parser.getDependencies( 'animation' ),
                parser.getDependencies( 'camera' ),

            ] );

        } ).then( function ( dependencies ) {

            const result = {
                scene: dependencies[ 0 ][ json.scene || 0 ],
                scenes: dependencies[ 0 ],
                animations: dependencies[ 1 ],
                cameras: dependencies[ 2 ],
                asset: json.asset,
                parser: parser,
                userData: {}
            };

            addUnknownExtensionsToUserData( extensions, result, json );

            assignExtrasToUserData( result, json );

            return Promise.all( parser._invokeAll( function ( ext ) {

                return ext.afterRoot && ext.afterRoot( result );

            } ) ).then( function () {

                for ( const scene of result.scenes ) {

                    scene.updateMatrixWorld();

                }

                onLoad( result );

            } );

        } ).catch( onError );

    }

`_markDefs(): void`¶

Code

_markDefs() {

        const nodeDefs = this.json.nodes || [];
        const skinDefs = this.json.skins || [];
        const meshDefs = this.json.meshes || [];

        // Nothing in the node definition indicates whether it is a Bone or an
        // Object3D. Use the skins' joint references to mark bones.
        for ( let skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex ++ ) {

            const joints = skinDefs[ skinIndex ].joints;

            for ( let i = 0, il = joints.length; i < il; i ++ ) {

                nodeDefs[ joints[ i ] ].isBone = true;

            }

        }

        // Iterate over all nodes, marking references to shared resources,
        // as well as skeleton joints.
        for ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {

            const nodeDef = nodeDefs[ nodeIndex ];

            if ( nodeDef.mesh !== undefined ) {

                this._addNodeRef( this.meshCache, nodeDef.mesh );

                // Nothing in the mesh definition indicates whether it is
                // a SkinnedMesh or Mesh. Use the node's mesh reference
                // to mark SkinnedMesh if node has skin.
                if ( nodeDef.skin !== undefined ) {

                    meshDefs[ nodeDef.mesh ].isSkinnedMesh = true;

                }

            }

            if ( nodeDef.camera !== undefined ) {

                this._addNodeRef( this.cameraCache, nodeDef.camera );

            }

        }

    }

`_addNodeRef(cache: any, index: Object3D): void`¶

Code

_addNodeRef( cache, index ) {

        if ( index === undefined ) return;

        if ( cache.refs[ index ] === undefined ) {

            cache.refs[ index ] = cache.uses[ index ] = 0;

        }

        cache.refs[ index ] ++;

    }

`_getNodeRef(cache: any, index: number, object: any): any`¶

Code

_getNodeRef( cache, index, object ) {

        if ( cache.refs[ index ] <= 1 ) return object;

        const ref = object.clone();

        // Propagates mappings to the cloned object, prevents mappings on the
        // original object from being lost.
        const updateMappings = ( original, clone ) => {

            const mappings = this.associations.get( original );
            if ( mappings != null ) {

                this.associations.set( clone, mappings );

            }

            for ( const [ i, child ] of original.children.entries() ) {

                updateMappings( child, clone.children[ i ] );

            }

        };

        updateMappings( object, ref );

        ref.name += '_instance_' + ( cache.uses[ index ] ++ );

        return ref;

    }

`_invokeOne(func: any): any`¶

Code

_invokeOne( func ) {

        const extensions = Object.values( this.plugins );
        extensions.push( this );

        for ( let i = 0; i < extensions.length; i ++ ) {

            const result = func( extensions[ i ] );

            if ( result ) return result;

        }

        return null;

    }

`_invokeAll(func: any): any[]`¶

Code

_invokeAll( func ) {

        const extensions = Object.values( this.plugins );
        extensions.unshift( this );

        const pending = [];

        for ( let i = 0; i < extensions.length; i ++ ) {

            const result = func( extensions[ i ] );

            if ( result ) pending.push( result );

        }

        return pending;

    }

`getDependency(type: string, index: number): Promise<any>`¶

Code

getDependency( type, index ) {

        const cacheKey = type + ':' + index;
        let dependency = this.cache.get( cacheKey );

        if ( ! dependency ) {

            switch ( type ) {

                case 'scene':
                    dependency = this.loadScene( index );
                    break;

                case 'node':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadNode && ext.loadNode( index );

                    } );
                    break;

                case 'mesh':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadMesh && ext.loadMesh( index );

                    } );
                    break;

                case 'accessor':
                    dependency = this.loadAccessor( index );
                    break;

                case 'bufferView':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadBufferView && ext.loadBufferView( index );

                    } );
                    break;

                case 'buffer':
                    dependency = this.loadBuffer( index );
                    break;

                case 'material':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadMaterial && ext.loadMaterial( index );

                    } );
                    break;

                case 'texture':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadTexture && ext.loadTexture( index );

                    } );
                    break;

                case 'skin':
                    dependency = this.loadSkin( index );
                    break;

                case 'animation':
                    dependency = this._invokeOne( function ( ext ) {

                        return ext.loadAnimation && ext.loadAnimation( index );

                    } );
                    break;

                case 'camera':
                    dependency = this.loadCamera( index );
                    break;

                default:
                    dependency = this._invokeOne( function ( ext ) {

                        return ext != this && ext.getDependency && ext.getDependency( type, index );

                    } );

                    if ( ! dependency ) {

                        throw new Error( 'Unknown type: ' + type );

                    }

                    break;

            }

            this.cache.add( cacheKey, dependency );

        }

        return dependency;

    }

`getDependencies(type: string): Promise<any[]>`¶

Code

getDependencies( type ) {

        let dependencies = this.cache.get( type );

        if ( ! dependencies ) {

            const parser = this;
            const defs = this.json[ type + ( type === 'mesh' ? 'es' : 's' ) ] || [];

            dependencies = Promise.all( defs.map( function ( def, index ) {

                return parser.getDependency( type, index );

            } ) );

            this.cache.add( type, dependencies );

        }

        return dependencies;

    }

`loadBuffer(bufferIndex: number): Promise<ArrayBuffer>`¶

Code

loadBuffer( bufferIndex ) {

        const bufferDef = this.json.buffers[ bufferIndex ];
        const loader = this.fileLoader;

        if ( bufferDef.type && bufferDef.type !== 'arraybuffer' ) {

            throw new Error( 'THREE.GLTFLoader: ' + bufferDef.type + ' buffer type is not supported.' );

        }

        // If present, GLB container is required to be the first buffer.
        if ( bufferDef.uri === undefined && bufferIndex === 0 ) {

            return Promise.resolve( this.extensions[ EXTENSIONS.KHR_BINARY_GLTF ].body );

        }

        const options = this.options;

        return new Promise( function ( resolve, reject ) {

            loader.load( LoaderUtils.resolveURL( bufferDef.uri, options.path ), resolve, undefined, function () {

                reject( new Error( 'THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".' ) );

            } );

        } );

    }

`loadBufferView(bufferViewIndex: number): Promise<ArrayBuffer>`¶

Code

loadBufferView( bufferViewIndex ) {

        const bufferViewDef = this.json.bufferViews[ bufferViewIndex ];

        return this.getDependency( 'buffer', bufferViewDef.buffer ).then( function ( buffer ) {

            const byteLength = bufferViewDef.byteLength || 0;
            const byteOffset = bufferViewDef.byteOffset || 0;
            return buffer.slice( byteOffset, byteOffset + byteLength );

        } );

    }

`loadAccessor(accessorIndex: number): Promise<any>`¶

Code

loadAccessor( accessorIndex ) {

        const parser = this;
        const json = this.json;

        const accessorDef = this.json.accessors[ accessorIndex ];

        if ( accessorDef.bufferView === undefined && accessorDef.sparse === undefined ) {

            const itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];
            const TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
            const normalized = accessorDef.normalized === true;

            const array = new TypedArray( accessorDef.count * itemSize );
            return Promise.resolve( new BufferAttribute( array, itemSize, normalized ) );

        }

        const pendingBufferViews = [];

        if ( accessorDef.bufferView !== undefined ) {

            pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.bufferView ) );

        } else {

            pendingBufferViews.push( null );

        }

        if ( accessorDef.sparse !== undefined ) {

            pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.indices.bufferView ) );
            pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.values.bufferView ) );

        }

        return Promise.all( pendingBufferViews ).then( function ( bufferViews ) {

            const bufferView = bufferViews[ 0 ];

            const itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];
            const TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];

            // For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12.
            const elementBytes = TypedArray.BYTES_PER_ELEMENT;
            const itemBytes = elementBytes * itemSize;
            const byteOffset = accessorDef.byteOffset || 0;
            const byteStride = accessorDef.bufferView !== undefined ? json.bufferViews[ accessorDef.bufferView ].byteStride : undefined;
            const normalized = accessorDef.normalized === true;
            let array, bufferAttribute;

            // The buffer is not interleaved if the stride is the item size in bytes.
            if ( byteStride && byteStride !== itemBytes ) {

                // Each "slice" of the buffer, as defined by 'count' elements of 'byteStride' bytes, gets its own InterleavedBuffer
                // This makes sure that IBA.count reflects accessor.count properly
                const ibSlice = Math.floor( byteOffset / byteStride );
                const ibCacheKey = 'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentType + ':' + ibSlice + ':' + accessorDef.count;
                let ib = parser.cache.get( ibCacheKey );

                if ( ! ib ) {

                    array = new TypedArray( bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes );

                    // Integer parameters to IB/IBA are in array elements, not bytes.
                    ib = new InterleavedBuffer( array, byteStride / elementBytes );

                    parser.cache.add( ibCacheKey, ib );

                }

                bufferAttribute = new InterleavedBufferAttribute( ib, itemSize, ( byteOffset % byteStride ) / elementBytes, normalized );

            } else {

                if ( bufferView === null ) {

                    array = new TypedArray( accessorDef.count * itemSize );

                } else {

                    array = new TypedArray( bufferView, byteOffset, accessorDef.count * itemSize );

                }

                bufferAttribute = new BufferAttribute( array, itemSize, normalized );

            }

            // https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#sparse-accessors
            if ( accessorDef.sparse !== undefined ) {

                const itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR;
                const TypedArrayIndices = WEBGL_COMPONENT_TYPES[ accessorDef.sparse.indices.componentType ];

                const byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0;
                const byteOffsetValues = accessorDef.sparse.values.byteOffset || 0;

                const sparseIndices = new TypedArrayIndices( bufferViews[ 1 ], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices );
                const sparseValues = new TypedArray( bufferViews[ 2 ], byteOffsetValues, accessorDef.sparse.count * itemSize );

                if ( bufferView !== null ) {

                    // Avoid modifying the original ArrayBuffer, if the bufferView wasn't initialized with zeroes.
                    bufferAttribute = new BufferAttribute( bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized );

                }

                // Ignore normalized since we copy from sparse
                bufferAttribute.normalized = false;

                for ( let i = 0, il = sparseIndices.length; i < il; i ++ ) {

                    const index = sparseIndices[ i ];

                    bufferAttribute.setX( index, sparseValues[ i * itemSize ] );
                    if ( itemSize >= 2 ) bufferAttribute.setY( index, sparseValues[ i * itemSize + 1 ] );
                    if ( itemSize >= 3 ) bufferAttribute.setZ( index, sparseValues[ i * itemSize + 2 ] );
                    if ( itemSize >= 4 ) bufferAttribute.setW( index, sparseValues[ i * itemSize + 3 ] );
                    if ( itemSize >= 5 ) throw new Error( 'THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.' );

                }

                bufferAttribute.normalized = normalized;

            }

            return bufferAttribute;

        } );

    }

`loadTexture(textureIndex: number): Promise<any>`¶

Code

loadTexture( textureIndex ) {

        const json = this.json;
        const options = this.options;
        const textureDef = json.textures[ textureIndex ];
        const sourceIndex = textureDef.source;
        const sourceDef = json.images[ sourceIndex ];

        let loader = this.textureLoader;

        if ( sourceDef.uri ) {

            const handler = options.manager.getHandler( sourceDef.uri );
            if ( handler !== null ) loader = handler;

        }

        return this.loadTextureImage( textureIndex, sourceIndex, loader );

    }

`loadTextureImage(textureIndex: any, sourceIndex: any, loader: any): any`¶

Code

loadTextureImage( textureIndex, sourceIndex, loader ) {

        const parser = this;
        const json = this.json;

        const textureDef = json.textures[ textureIndex ];
        const sourceDef = json.images[ sourceIndex ];

        const cacheKey = ( sourceDef.uri || sourceDef.bufferView ) + ':' + textureDef.sampler;

        if ( this.textureCache[ cacheKey ] ) {

            // See https://github.com/mrdoob/three.js/issues/21559.
            return this.textureCache[ cacheKey ];

        }

        const promise = this.loadImageSource( sourceIndex, loader ).then( function ( texture ) {

            texture.flipY = false;

            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 ] || {};

            texture.magFilter = WEBGL_FILTERS[ sampler.magFilter ] || LinearFilter;
            texture.minFilter = WEBGL_FILTERS[ sampler.minFilter ] || LinearMipmapLinearFilter;
            texture.wrapS = WEBGL_WRAPPINGS[ sampler.wrapS ] || RepeatWrapping;
            texture.wrapT = WEBGL_WRAPPINGS[ sampler.wrapT ] || RepeatWrapping;
            texture.generateMipmaps = ! texture.isCompressedTexture && texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter;

            parser.associations.set( texture, { textures: textureIndex } );

            return texture;

        } ).catch( function () {

            return null;

        } );

        this.textureCache[ cacheKey ] = promise;

        return promise;

    }

`loadImageSource(sourceIndex: any, loader: any): any`¶

Code

loadImageSource( sourceIndex, loader ) {

        const parser = this;
        const json = this.json;
        const options = this.options;

        if ( this.sourceCache[ sourceIndex ] !== undefined ) {

            return this.sourceCache[ sourceIndex ].then( ( texture ) => texture.clone() );

        }

        const sourceDef = json.images[ sourceIndex ];

        const URL = self.URL || self.webkitURL;

        let sourceURI = sourceDef.uri || '';
        let isObjectURL = false;

        if ( sourceDef.bufferView !== undefined ) {

            // Load binary image data from bufferView, if provided.

            sourceURI = parser.getDependency( 'bufferView', sourceDef.bufferView ).then( function ( bufferView ) {

                isObjectURL = true;
                const blob = new Blob( [ bufferView ], { type: sourceDef.mimeType } );
                sourceURI = URL.createObjectURL( blob );
                return sourceURI;

            } );

        } else if ( sourceDef.uri === undefined ) {

            throw new Error( 'THREE.GLTFLoader: Image ' + sourceIndex + ' is missing URI and bufferView' );

        }

        const promise = Promise.resolve( sourceURI ).then( function ( sourceURI ) {

            return new Promise( function ( resolve, reject ) {

                let onLoad = resolve;

                if ( loader.isImageBitmapLoader === true ) {

                    onLoad = function ( imageBitmap ) {

                        const texture = new Texture( imageBitmap );
                        texture.needsUpdate = true;

                        resolve( texture );

                    };

                }

                loader.load( LoaderUtils.resolveURL( sourceURI, options.path ), onLoad, undefined, reject );

            } );

        } ).then( function ( texture ) {

            // Clean up resources and configure Texture.

            if ( isObjectURL === true ) {

                URL.revokeObjectURL( sourceURI );

            }

            assignExtrasToUserData( texture, sourceDef );

            texture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType( sourceDef.uri );

            return texture;

        } ).catch( function ( error ) {

            console.error( 'THREE.GLTFLoader: Couldn\'t load texture', sourceURI );
            throw error;

        } );

        this.sourceCache[ sourceIndex ] = promise;
        return promise;

    }

`assignTexture(materialParams: any, mapName: string, mapDef: any, colorSpace: string): Promise<Texture>`¶

Code

assignTexture( materialParams, mapName, mapDef, colorSpace ) {

        const parser = this;

        return this.getDependency( 'texture', mapDef.index ).then( function ( texture ) {

            if ( ! texture ) return null;

            if ( mapDef.texCoord !== undefined && mapDef.texCoord > 0 ) {

                texture = texture.clone();
                texture.channel = mapDef.texCoord;

            }

            if ( parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] ) {

                const transform = mapDef.extensions !== undefined ? mapDef.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] : undefined;

                if ( transform ) {

                    const gltfReference = parser.associations.get( texture );
                    texture = parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ].extendTexture( texture, transform );
                    parser.associations.set( texture, gltfReference );

                }

            }

            if ( colorSpace !== undefined ) {

                texture.colorSpace = colorSpace;

            }

            materialParams[ mapName ] = texture;

            return texture;

        } );

    }

`assignFinalMaterial(mesh: Object3D): void`¶

Code

assignFinalMaterial( mesh ) {

        const geometry = mesh.geometry;
        let material = mesh.material;

        const useDerivativeTangents = geometry.attributes.tangent === undefined;
        const useVertexColors = geometry.attributes.color !== undefined;
        const useFlatShading = geometry.attributes.normal === undefined;

        if ( mesh.isPoints ) {

            const cacheKey = 'PointsMaterial:' + material.uuid;

            let pointsMaterial = this.cache.get( cacheKey );

            if ( ! pointsMaterial ) {

                pointsMaterial = new PointsMaterial();
                Material.prototype.copy.call( pointsMaterial, material );
                pointsMaterial.color.copy( material.color );
                pointsMaterial.map = material.map;
                pointsMaterial.sizeAttenuation = false; // glTF spec says points should be 1px

                this.cache.add( cacheKey, pointsMaterial );

            }

            material = pointsMaterial;

        } else if ( mesh.isLine ) {

            const cacheKey = 'LineBasicMaterial:' + material.uuid;

            let lineMaterial = this.cache.get( cacheKey );

            if ( ! lineMaterial ) {

                lineMaterial = new LineBasicMaterial();
                Material.prototype.copy.call( lineMaterial, material );
                lineMaterial.color.copy( material.color );
                lineMaterial.map = material.map;

                this.cache.add( cacheKey, lineMaterial );

            }

            material = lineMaterial;

        }

        // Clone the material if it will be modified
        if ( useDerivativeTangents || useVertexColors || useFlatShading ) {

            let cacheKey = 'ClonedMaterial:' + material.uuid + ':';

            if ( useDerivativeTangents ) cacheKey += 'derivative-tangents:';
            if ( useVertexColors ) cacheKey += 'vertex-colors:';
            if ( useFlatShading ) cacheKey += 'flat-shading:';

            let cachedMaterial = this.cache.get( cacheKey );

            if ( ! cachedMaterial ) {

                cachedMaterial = material.clone();

                if ( useVertexColors ) cachedMaterial.vertexColors = true;
                if ( useFlatShading ) cachedMaterial.flatShading = true;

                if ( useDerivativeTangents ) {

                    // https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
                    if ( cachedMaterial.normalScale ) cachedMaterial.normalScale.y *= - 1;
                    if ( cachedMaterial.clearcoatNormalScale ) cachedMaterial.clearcoatNormalScale.y *= - 1;

                }

                this.cache.add( cacheKey, cachedMaterial );

                this.associations.set( cachedMaterial, this.associations.get( material ) );

            }

            material = cachedMaterial;

        }

        mesh.material = material;

    }

`getMaterialType(): any`¶

Code

getMaterialType( /* materialIndex */ ) {

        return MeshStandardMaterial;

    }

`loadMaterial(materialIndex: number): Promise<Material>`¶

Code

loadMaterial( materialIndex ) {

        const parser = this;
        const json = this.json;
        const extensions = this.extensions;
        const materialDef = json.materials[ materialIndex ];

        let materialType;
        const materialParams = {};
        const materialExtensions = materialDef.extensions || {};

        const pending = [];

        if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ] ) {

            const kmuExtension = extensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ];
            materialType = kmuExtension.getMaterialType();
            pending.push( kmuExtension.extendParams( materialParams, materialDef, parser ) );

        } else {

            // Specification:
            // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#metallic-roughness-material

            const metallicRoughness = materialDef.pbrMetallicRoughness || {};

            materialParams.color = new Color( 1.0, 1.0, 1.0 );
            materialParams.opacity = 1.0;

            if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {

                const array = metallicRoughness.baseColorFactor;

                materialParams.color.setRGB( array[ 0 ], array[ 1 ], array[ 2 ], LinearSRGBColorSpace );
                materialParams.opacity = array[ 3 ];

            }

            if ( metallicRoughness.baseColorTexture !== undefined ) {

                pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) );

            }

            materialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0;
            materialParams.roughness = metallicRoughness.roughnessFactor !== undefined ? metallicRoughness.roughnessFactor : 1.0;

            if ( metallicRoughness.metallicRoughnessTexture !== undefined ) {

                pending.push( parser.assignTexture( materialParams, 'metalnessMap', metallicRoughness.metallicRoughnessTexture ) );
                pending.push( parser.assignTexture( materialParams, 'roughnessMap', metallicRoughness.metallicRoughnessTexture ) );

            }

            materialType = this._invokeOne( function ( ext ) {

                return ext.getMaterialType && ext.getMaterialType( materialIndex );

            } );

            pending.push( Promise.all( this._invokeAll( function ( ext ) {

                return ext.extendMaterialParams && ext.extendMaterialParams( materialIndex, materialParams );

            } ) ) );

        }

        if ( materialDef.doubleSided === true ) {

            materialParams.side = DoubleSide;

        }

        const alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE;

        if ( alphaMode === ALPHA_MODES.BLEND ) {

            materialParams.transparent = true;

            // See: https://github.com/mrdoob/three.js/issues/17706
            materialParams.depthWrite = false;

        } else {

            materialParams.transparent = false;

            if ( alphaMode === ALPHA_MODES.MASK ) {

                materialParams.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : 0.5;

            }

        }

        if ( materialDef.normalTexture !== undefined && materialType !== MeshBasicMaterial ) {

            pending.push( parser.assignTexture( materialParams, 'normalMap', materialDef.normalTexture ) );

            materialParams.normalScale = new Vector2( 1, 1 );

            if ( materialDef.normalTexture.scale !== undefined ) {

                const scale = materialDef.normalTexture.scale;

                materialParams.normalScale.set( scale, scale );

            }

        }

        if ( materialDef.occlusionTexture !== undefined && materialType !== MeshBasicMaterial ) {

            pending.push( parser.assignTexture( materialParams, 'aoMap', materialDef.occlusionTexture ) );

            if ( materialDef.occlusionTexture.strength !== undefined ) {

                materialParams.aoMapIntensity = materialDef.occlusionTexture.strength;

            }

        }

        if ( materialDef.emissiveFactor !== undefined && materialType !== MeshBasicMaterial ) {

            const emissiveFactor = materialDef.emissiveFactor;
            materialParams.emissive = new Color().setRGB( emissiveFactor[ 0 ], emissiveFactor[ 1 ], emissiveFactor[ 2 ], LinearSRGBColorSpace );

        }

        if ( materialDef.emissiveTexture !== undefined && materialType !== MeshBasicMaterial ) {

            pending.push( parser.assignTexture( materialParams, 'emissiveMap', materialDef.emissiveTexture, SRGBColorSpace ) );

        }

        return Promise.all( pending ).then( function () {

            const material = new materialType( materialParams );

            if ( materialDef.name ) material.name = materialDef.name;

            assignExtrasToUserData( material, materialDef );

            parser.associations.set( material, { materials: materialIndex } );

            if ( materialDef.extensions ) addUnknownExtensionsToUserData( extensions, material, materialDef );

            return material;

        } );

    }

`createUniqueName(originalName: string): string`¶

Code

createUniqueName( originalName ) {

        const sanitizedName = PropertyBinding.sanitizeNodeName( originalName || '' );

        if ( sanitizedName in this.nodeNamesUsed ) {

            return sanitizedName + '_' + ( ++ this.nodeNamesUsed[ sanitizedName ] );

        } else {

            this.nodeNamesUsed[ sanitizedName ] = 0;

            return sanitizedName;

        }

    }

`loadGeometries(primitives: GLTF.Primitive[]): Promise<BufferGeometry[]>`¶

Code

loadGeometries( primitives ) {

        const parser = this;
        const extensions = this.extensions;
        const cache = this.primitiveCache;

        function createDracoPrimitive( primitive ) {

            return extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ]
                .decodePrimitive( primitive, parser )
                .then( function ( geometry ) {

                    return addPrimitiveAttributes( geometry, primitive, parser );

                } );

        }

        const pending = [];

        for ( let i = 0, il = primitives.length; i < il; i ++ ) {

            const primitive = primitives[ i ];
            const cacheKey = createPrimitiveKey( primitive );

            // See if we've already created this geometry
            const cached = cache[ cacheKey ];

            if ( cached ) {

                // Use the cached geometry if it exists
                pending.push( cached.promise );

            } else {

                let geometryPromise;

                if ( primitive.extensions && primitive.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ] ) {

                    // Use DRACO geometry if available
                    geometryPromise = createDracoPrimitive( primitive );

                } else {

                    // Otherwise create a new geometry
                    geometryPromise = addPrimitiveAttributes( new BufferGeometry(), primitive, parser );

                }

                // Cache this geometry
                cache[ cacheKey ] = { primitive: primitive, promise: geometryPromise };

                pending.push( geometryPromise );

            }

        }

        return Promise.all( pending );

    }

`loadMesh(meshIndex: number): Promise<any>`¶

Code

loadMesh( meshIndex ) {

        const parser = this;
        const json = this.json;
        const extensions = this.extensions;

        const meshDef = json.meshes[ meshIndex ];
        const primitives = meshDef.primitives;

        const pending = [];

        for ( let i = 0, il = primitives.length; i < il; i ++ ) {

            const material = primitives[ i ].material === undefined
                ? createDefaultMaterial( this.cache )
                : this.getDependency( 'material', primitives[ i ].material );

            pending.push( material );

        }

        pending.push( parser.loadGeometries( primitives ) );

        return Promise.all( pending ).then( function ( results ) {

            const materials = results.slice( 0, results.length - 1 );
            const geometries = results[ results.length - 1 ];

            const meshes = [];

            for ( let i = 0, il = geometries.length; i < il; i ++ ) {

                const geometry = geometries[ i ];
                const primitive = primitives[ i ];

                // 1. create Mesh

                let mesh;

                const material = materials[ i ];

                if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLES ||
                        primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ||
                        primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ||
                        primitive.mode === undefined ) {

                    // .isSkinnedMesh isn't in glTF spec. See ._markDefs()
                    mesh = meshDef.isSkinnedMesh === true
                        ? new SkinnedMesh( geometry, material )
                        : new Mesh( geometry, material );

                    if ( mesh.isSkinnedMesh === true ) {

                        // normalize skin weights to fix malformed assets (see #15319)
                        mesh.normalizeSkinWeights();

                    }

                    if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ) {

                        mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleStripDrawMode );

                    } else if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ) {

                        mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleFanDrawMode );

                    }

                } else if ( primitive.mode === WEBGL_CONSTANTS.LINES ) {

                    mesh = new LineSegments( geometry, material );

                } else if ( primitive.mode === WEBGL_CONSTANTS.LINE_STRIP ) {

                    mesh = new Line( geometry, material );

                } else if ( primitive.mode === WEBGL_CONSTANTS.LINE_LOOP ) {

                    mesh = new LineLoop( geometry, material );

                } else if ( primitive.mode === WEBGL_CONSTANTS.POINTS ) {

                    mesh = new Points( geometry, material );

                } else {

                    throw new Error( 'THREE.GLTFLoader: Primitive mode unsupported: ' + primitive.mode );

                }

                if ( Object.keys( mesh.geometry.morphAttributes ).length > 0 ) {

                    updateMorphTargets( mesh, meshDef );

                }

                mesh.name = parser.createUniqueName( meshDef.name || ( 'mesh_' + meshIndex ) );

                assignExtrasToUserData( mesh, meshDef );

                if ( primitive.extensions ) addUnknownExtensionsToUserData( extensions, mesh, primitive );

                parser.assignFinalMaterial( mesh );

                meshes.push( mesh );

            }

            for ( let i = 0, il = meshes.length; i < il; i ++ ) {

                parser.associations.set( meshes[ i ], {
                    meshes: meshIndex,
                    primitives: i
                } );

            }

            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 ++ ) {

                group.add( meshes[ i ] );

            }

            return group;

        } );

    }

`loadCamera(cameraIndex: number): Promise<THREE.Camera>`¶

Code

loadCamera( cameraIndex ) {

        let camera;
        const cameraDef = this.json.cameras[ cameraIndex ];
        const params = cameraDef[ cameraDef.type ];

        if ( ! params ) {

            console.warn( 'THREE.GLTFLoader: Missing camera parameters.' );
            return;

        }

        if ( cameraDef.type === 'perspective' ) {

            camera = new PerspectiveCamera( MathUtils.radToDeg( params.yfov ), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6 );

        } else if ( cameraDef.type === 'orthographic' ) {

            camera = new OrthographicCamera( - params.xmag, params.xmag, params.ymag, - params.ymag, params.znear, params.zfar );

        }

        if ( cameraDef.name ) camera.name = this.createUniqueName( cameraDef.name );

        assignExtrasToUserData( camera, cameraDef );

        return Promise.resolve( camera );

    }

`loadSkin(skinIndex: number): Promise<Skeleton>`¶

Code

loadSkin( skinIndex ) {

        const skinDef = this.json.skins[ skinIndex ];

        const pending = [];

        for ( let i = 0, il = skinDef.joints.length; i < il; i ++ ) {

            pending.push( this._loadNodeShallow( skinDef.joints[ i ] ) );

        }

        if ( skinDef.inverseBindMatrices !== undefined ) {

            pending.push( this.getDependency( 'accessor', skinDef.inverseBindMatrices ) );

        } else {

            pending.push( null );

        }

        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 {

                    console.warn( 'THREE.GLTFLoader: Joint "%s" could not be found.', skinDef.joints[ i ] );

                }

            }

            return new Skeleton( bones, boneInverses );

        } );

    }

`loadAnimation(animationIndex: number): Promise<AnimationClip>`¶

Code

loadAnimation( animationIndex ) {

        const json = this.json;
        const parser = this;

        const animationDef = json.animations[ animationIndex ];
        const animationName = animationDef.name ? animationDef.name : 'animation_' + animationIndex;

        const pendingNodes = [];
        const pendingInputAccessors = [];
        const pendingOutputAccessors = [];
        const pendingSamplers = [];
        const pendingTargets = [];

        for ( let i = 0, il = animationDef.channels.length; i < il; i ++ ) {

            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;

            if ( target.node === undefined ) continue;

            pendingNodes.push( this.getDependency( 'node', name ) );
            pendingInputAccessors.push( this.getDependency( 'accessor', input ) );
            pendingOutputAccessors.push( this.getDependency( 'accessor', output ) );
            pendingSamplers.push( sampler );
            pendingTargets.push( target );

        }

        return Promise.all( [

            Promise.all( pendingNodes ),
            Promise.all( pendingInputAccessors ),
            Promise.all( pendingOutputAccessors ),
            Promise.all( pendingSamplers ),
            Promise.all( pendingTargets )

        ] ).then( function ( dependencies ) {

            const nodes = dependencies[ 0 ];
            const inputAccessors = dependencies[ 1 ];
            const outputAccessors = dependencies[ 2 ];
            const samplers = dependencies[ 3 ];
            const targets = dependencies[ 4 ];

            const tracks = [];

            for ( let i = 0, il = nodes.length; i < il; i ++ ) {

                const node = nodes[ i ];
                const inputAccessor = inputAccessors[ i ];
                const outputAccessor = outputAccessors[ i ];
                const sampler = samplers[ i ];
                const target = targets[ i ];

                if ( node === undefined ) continue;

                if ( node.updateMatrix ) {

                    node.updateMatrix();

                }

                const createdTracks = parser._createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target );

                if ( createdTracks ) {

                    for ( let k = 0; k < createdTracks.length; k ++ ) {

                        tracks.push( createdTracks[ k ] );

                    }

                }

            }

            return new AnimationClip( animationName, undefined, tracks );

        } );

    }

`createNodeMesh(nodeIndex: any): Promise<any>`¶

Code

createNodeMesh( nodeIndex ) {

        const json = this.json;
        const parser = this;
        const nodeDef = json.nodes[ nodeIndex ];

        if ( nodeDef.mesh === undefined ) return null;

        return parser.getDependency( 'mesh', nodeDef.mesh ).then( function ( mesh ) {

            const node = parser._getNodeRef( parser.meshCache, nodeDef.mesh, mesh );

            // if weights are provided on the node, override weights on the mesh.
            if ( nodeDef.weights !== undefined ) {

                node.traverse( function ( o ) {

                    if ( ! o.isMesh ) return;

                    for ( let i = 0, il = nodeDef.weights.length; i < il; i ++ ) {

                        o.morphTargetInfluences[ i ] = nodeDef.weights[ i ];

                    }

                } );

            }

            return node;

        } );

    }

`loadNode(nodeIndex: number): Promise<Object3D>`¶

Code

loadNode( nodeIndex ) {

        const json = this.json;
        const parser = this;

        const nodeDef = json.nodes[ nodeIndex ];

        const nodePending = parser._loadNodeShallow( nodeIndex );

        const childPending = [];
        const childrenDef = nodeDef.children || [];

        for ( let i = 0, il = childrenDef.length; i < il; i ++ ) {

            childPending.push( parser.getDependency( 'node', childrenDef[ i ] ) );

        }

        const skeletonPending = nodeDef.skin === undefined
            ? Promise.resolve( null )
            : parser.getDependency( 'skin', nodeDef.skin );

        return Promise.all( [
            nodePending,
            Promise.all( childPending ),
            skeletonPending
        ] ).then( function ( results ) {

            const node = results[ 0 ];
            const children = results[ 1 ];
            const skeleton = results[ 2 ];

            if ( skeleton !== null ) {

                // This full traverse should be fine because
                // child glTF nodes have not been added to this node yet.
                node.traverse( function ( mesh ) {

                    if ( ! mesh.isSkinnedMesh ) return;

                    mesh.bind( skeleton, _identityMatrix );

                } );

            }

            for ( let i = 0, il = children.length; i < il; i ++ ) {

                node.add( children[ i ] );

            }

            return node;

        } );

    }

`_loadNodeShallow(nodeIndex: any): any`¶

Code

_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 );

        } );

        if ( meshPromise ) {

            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;

            // .isBone isn't in glTF spec. See ._markDefs
            if ( nodeDef.isBone === true ) {

                node = new Bone();

            } else if ( objects.length > 1 ) {

                node = new Group();

            } else if ( objects.length === 1 ) {

                node = objects[ 0 ];

            } else {

                node = new Object3D();

            }

            if ( node !== objects[ 0 ] ) {

                for ( let i = 0, il = objects.length; i < il; i ++ ) {

                    node.add( objects[ i ] );

                }

            }

            if ( nodeDef.name ) {

                node.userData.name = nodeDef.name;
                node.name = nodeName;

            }

            assignExtrasToUserData( node, nodeDef );

            if ( nodeDef.extensions ) addUnknownExtensionsToUserData( extensions, node, nodeDef );

            if ( nodeDef.matrix !== undefined ) {

                const matrix = new Matrix4();
                matrix.fromArray( nodeDef.matrix );
                node.applyMatrix4( matrix );

            } else {

                if ( nodeDef.translation !== undefined ) {

                    node.position.fromArray( nodeDef.translation );

                }

                if ( nodeDef.rotation !== undefined ) {

                    node.quaternion.fromArray( nodeDef.rotation );

                }

                if ( nodeDef.scale !== undefined ) {

                    node.scale.fromArray( nodeDef.scale );

                }

            }

            if ( ! parser.associations.has( node ) ) {

                parser.associations.set( node, {} );

            } else if ( nodeDef.mesh !== undefined && parser.meshCache.refs[ nodeDef.mesh ] > 1 ) {

                const mapping = parser.associations.get( node );
                parser.associations.set( node, { ...mapping } );

            }

            parser.associations.get( node ).nodes = nodeIndex;

            return node;

        } );

        return this.nodeCache[ nodeIndex ];

    }

`loadScene(sceneIndex: number): Promise<Group>`¶

Code

loadScene( sceneIndex ) {

        const extensions = this.extensions;
        const sceneDef = this.json.scenes[ sceneIndex ];
        const parser = this;

        // Loader returns Group, not Scene.
        // See: https://github.com/mrdoob/three.js/issues/18342#issuecomment-578981172
        const scene = new Group();
        if ( sceneDef.name ) scene.name = parser.createUniqueName( sceneDef.name );

        assignExtrasToUserData( scene, sceneDef );

        if ( sceneDef.extensions ) addUnknownExtensionsToUserData( extensions, scene, sceneDef );

        const nodeIds = sceneDef.nodes || [];

        const pending = [];

        for ( let i = 0, il = nodeIds.length; i < il; i ++ ) {

            pending.push( parser.getDependency( 'node', nodeIds[ i ] ) );

        }

        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.
            const reduceAssociations = ( node ) => {

                const reducedAssociations = new Map();

                for ( const [ key, value ] of parser.associations ) {

                    if ( key instanceof Material || key instanceof Texture ) {

                        reducedAssociations.set( key, value );

                    }

                }

                node.traverse( ( node ) => {

                    const mappings = parser.associations.get( node );

                    if ( mappings != null ) {

                        reducedAssociations.set( node, mappings );

                    }

                } );

                return reducedAssociations;

            };

            parser.associations = reduceAssociations( scene );

            return scene;

        } );

    }

`_createAnimationTracks(node: any, inputAccessor: any, outputAccessor: any, sampler: any, target: any): any[]`¶

Code

_createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target ) {

        const tracks = [];

        const targetName = node.name ? node.name : node.uuid;
        const targetNames = [];

        if ( PATH_PROPERTIES[ target.path ] === PATH_PROPERTIES.weights ) {

            node.traverse( function ( object ) {

                if ( object.morphTargetInfluences ) {

                    targetNames.push( object.name ? object.name : object.uuid );

                }

            } );

        } else {

            targetNames.push( targetName );

        }

        let TypedKeyframeTrack;

        switch ( PATH_PROPERTIES[ target.path ] ) {

            case PATH_PROPERTIES.weights:

                TypedKeyframeTrack = NumberKeyframeTrack;
                break;

            case PATH_PROPERTIES.rotation:

                TypedKeyframeTrack = QuaternionKeyframeTrack;
                break;

            case PATH_PROPERTIES.translation:
            case PATH_PROPERTIES.scale:

                TypedKeyframeTrack = VectorKeyframeTrack;
                break;

            default:

                switch ( outputAccessor.itemSize ) {

                    case 1:
                        TypedKeyframeTrack = NumberKeyframeTrack;
                        break;
                    case 2:
                    case 3:
                    default:
                        TypedKeyframeTrack = VectorKeyframeTrack;
                        break;

                }

                break;

        }

        const interpolation = sampler.interpolation !== undefined ? INTERPOLATION[ sampler.interpolation ] : InterpolateLinear;


        const outputArray = this._getArrayFromAccessor( outputAccessor );

        for ( let j = 0, jl = targetNames.length; j < jl; j ++ ) {

            const track = new TypedKeyframeTrack(
                targetNames[ j ] + '.' + PATH_PROPERTIES[ target.path ],
                inputAccessor.array,
                outputArray,
                interpolation
            );

            // Override interpolation with custom factory method.
            if ( sampler.interpolation === 'CUBICSPLINE' ) {

                this._createCubicSplineTrackInterpolant( track );

            }

            tracks.push( track );

        }

        return tracks;

    }

`_getArrayFromAccessor(accessor: any): any`¶

Code

_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;

    }

`_createCubicSplineTrackInterpolant(track: any): void`¶

Code

_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;

    }

📄 GLTFLoader.js¶

📊 Analysis Summary¶

📚 Table of Contents¶

🛠️ File Location:¶

📦 Imports¶

Variables & Constants¶

Async/Await Patterns¶

Functions¶

GLTFLoader.load(url: string, onLoad: any, onProgress: onProgressCallback, onError: onErrorCallback): void¶

GLTFLoader.setDRACOLoader(dracoLoader: DRACOLoader): GLTFLoader¶

GLTFLoader.setKTX2Loader(ktx2Loader: KTX2Loader): GLTFLoader¶

GLTFLoader.setMeshoptDecoder(meshoptDecoder: any): GLTFLoader¶

GLTFLoader.register(callback: any): GLTFLoader¶

GLTFLoader.unregister(callback: Function): GLTFLoader¶

GLTFLoader.parse(data: string | ArrayBuffer, path: string, onLoad: any, onError: onErrorCallback): void¶

GLTFLoader.parseAsync(data: string | ArrayBuffer, path: string): Promise<GLTFLoader>¶

_onError(e: any): void¶

GLTFRegistry(): { get: (key: any) => any; add: (key: any, object: any) => void; remove: (key: any) => void; removeAll: () => void; }¶

get(key: any): any¶

add(key: any, object: any): void¶

remove(key: any): void¶

removeAll(): void¶

get(key: any): any¶

add(key: any, object: any): void¶

remove(key: any): void¶

removeAll(): void¶

GLTFLightsExtension._markDefs(): void¶

GLTFLightsExtension._loadLight(lightIndex: any): any¶

GLTFLightsExtension.getDependency(type: any, index: any): any¶

GLTFLightsExtension.createNodeAttachment(nodeIndex: any): any¶

GLTFMaterialsUnlitExtension.getMaterialType(): any¶

GLTFMaterialsUnlitExtension.extendParams(materialParams: any, materialDef: any, parser: any): Promise<any[]>¶

GLTFMaterialsEmissiveStrengthExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void>¶

GLTFMaterialsClearcoatExtension.getMaterialType(materialIndex: any): any¶

GLTFMaterialsClearcoatExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>¶

GLTFMaterialsDispersionExtension.getMaterialType(materialIndex: any): any¶

GLTFMaterialsDispersionExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void>¶

GLTFMaterialsIridescenceExtension.getMaterialType(materialIndex: any): any¶

GLTFMaterialsIridescenceExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>¶

GLTFMaterialsSheenExtension.getMaterialType(materialIndex: any): any¶

GLTFMaterialsSheenExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>¶

GLTFMaterialsTransmissionExtension.getMaterialType(materialIndex: any): any¶

GLTFMaterialsTransmissionExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>¶

GLTFMaterialsVolumeExtension.getMaterialType(materialIndex: any): any¶

GLTFMaterialsVolumeExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>¶

GLTFMaterialsIorExtension.getMaterialType(materialIndex: any): any¶

GLTFMaterialsIorExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void>¶

GLTFMaterialsSpecularExtension.getMaterialType(materialIndex: any): any¶

GLTFMaterialsSpecularExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>¶

GLTFMaterialsBumpExtension.getMaterialType(materialIndex: any): any¶

GLTFMaterialsBumpExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>¶

GLTFMaterialsAnisotropyExtension.getMaterialType(materialIndex: any): any¶

GLTFMaterialsAnisotropyExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>¶

GLTFTextureBasisUExtension.loadTexture(textureIndex: any): any¶

GLTFTextureWebPExtension.loadTexture(textureIndex: any): any¶

GLTFTextureAVIFExtension.loadTexture(textureIndex: any): any¶

GLTFMeshoptCompression.loadBufferView(index: any): any¶

GLTFMeshGpuInstancing.createNodeMesh(nodeIndex: any): Promise<any>¶

GLTFDracoMeshCompressionExtension.decodePrimitive(primitive: any, parser: any): any¶

GLTFTextureTransformExtension.extendTexture(texture: any, transform: any): any¶

GLTFCubicSplineInterpolant.copySampleValue_(index: any): any¶

GLTFCubicSplineInterpolant.interpolate_(i1: any, t0: any, t: any, t1: any): any¶

GLTFCubicSplineQuaternionInterpolant.interpolate_(i1: any, t0: any, t: any, t1: any): any¶

createDefaultMaterial(cache: { [x: string]: Material; }): Material¶

addUnknownExtensionsToUserData(knownExtensions: any, object: any, objectDef: any): void¶

assignExtrasToUserData(object: any, gltfDef: GLTF.definition): void¶

addMorphTargets(geometry: BufferGeometry, targets: GLTF.Target[], parser: GLTFParser): Promise<BufferGeometry>¶

updateMorphTargets(mesh: Mesh, meshDef: GLTF.Mesh): void¶

createPrimitiveKey(primitiveDef: any): string¶

createAttributesKey(attributes: any): string¶

getNormalizedComponentScale(constructor: any): number¶

getImageURIMimeType(uri: any): "image/png" | "image/jpeg" | "image/webp" | "image/ktx2"¶

GLTFParser.setExtensions(extensions: any): void¶

GLTFParser.setPlugins(plugins: any): void¶

GLTFParser.parse(onLoad: any, onError: any): void¶

GLTFParser._markDefs(): void¶

GLTFParser._addNodeRef(cache: any, index: Object3D): void¶

GLTFParser._getNodeRef(cache: any, index: number, object: any): any¶

GLTFParser._invokeOne(func: any): any¶

GLTFParser._invokeAll(func: any): any[]¶

📄 `GLTFLoader.js`¶

`GLTFLoader.load(url: string, onLoad: any, onProgress: onProgressCallback, onError: onErrorCallback): void`¶

`GLTFLoader.setDRACOLoader(dracoLoader: DRACOLoader): GLTFLoader`¶

`GLTFLoader.setKTX2Loader(ktx2Loader: KTX2Loader): GLTFLoader`¶

`GLTFLoader.setMeshoptDecoder(meshoptDecoder: any): GLTFLoader`¶

`GLTFLoader.register(callback: any): GLTFLoader`¶

`GLTFLoader.unregister(callback: Function): GLTFLoader`¶

`GLTFLoader.parse(data: string | ArrayBuffer, path: string, onLoad: any, onError: onErrorCallback): void`¶

`GLTFLoader.parseAsync(data: string | ArrayBuffer, path: string): Promise<GLTFLoader>`¶

`_onError(e: any): void`¶

`GLTFRegistry(): { get: (key: any) => any; add: (key: any, object: any) => void; remove: (key: any) => void; removeAll: () => void; }`¶

`get(key: any): any`¶

`add(key: any, object: any): void`¶

`remove(key: any): void`¶

`removeAll(): void`¶

`get(key: any): any`¶

`add(key: any, object: any): void`¶

`remove(key: any): void`¶

`removeAll(): void`¶

`GLTFLightsExtension._markDefs(): void`¶

`GLTFLightsExtension._loadLight(lightIndex: any): any`¶

`GLTFLightsExtension.getDependency(type: any, index: any): any`¶

`GLTFLightsExtension.createNodeAttachment(nodeIndex: any): any`¶

`GLTFMaterialsUnlitExtension.getMaterialType(): any`¶

`GLTFMaterialsUnlitExtension.extendParams(materialParams: any, materialDef: any, parser: any): Promise<any[]>`¶

`GLTFMaterialsEmissiveStrengthExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void>`¶

`GLTFMaterialsClearcoatExtension.getMaterialType(materialIndex: any): any`¶

`GLTFMaterialsClearcoatExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

`GLTFMaterialsDispersionExtension.getMaterialType(materialIndex: any): any`¶

`GLTFMaterialsDispersionExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void>`¶

`GLTFMaterialsIridescenceExtension.getMaterialType(materialIndex: any): any`¶

`GLTFMaterialsIridescenceExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

`GLTFMaterialsSheenExtension.getMaterialType(materialIndex: any): any`¶

`GLTFMaterialsSheenExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

`GLTFMaterialsTransmissionExtension.getMaterialType(materialIndex: any): any`¶

`GLTFMaterialsTransmissionExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

`GLTFMaterialsVolumeExtension.getMaterialType(materialIndex: any): any`¶

`GLTFMaterialsVolumeExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

`GLTFMaterialsIorExtension.getMaterialType(materialIndex: any): any`¶

`GLTFMaterialsIorExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void>`¶

`GLTFMaterialsSpecularExtension.getMaterialType(materialIndex: any): any`¶

`GLTFMaterialsSpecularExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

`GLTFMaterialsBumpExtension.getMaterialType(materialIndex: any): any`¶

`GLTFMaterialsBumpExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

`GLTFMaterialsAnisotropyExtension.getMaterialType(materialIndex: any): any`¶

`GLTFMaterialsAnisotropyExtension.extendMaterialParams(materialIndex: any, materialParams: any): Promise<void> | Promise<any[]>`¶

`GLTFTextureBasisUExtension.loadTexture(textureIndex: any): any`¶

`GLTFTextureWebPExtension.loadTexture(textureIndex: any): any`¶

`GLTFTextureAVIFExtension.loadTexture(textureIndex: any): any`¶

`GLTFMeshoptCompression.loadBufferView(index: any): any`¶

`GLTFMeshGpuInstancing.createNodeMesh(nodeIndex: any): Promise<any>`¶

`GLTFDracoMeshCompressionExtension.decodePrimitive(primitive: any, parser: any): any`¶

`GLTFTextureTransformExtension.extendTexture(texture: any, transform: any): any`¶

`GLTFCubicSplineInterpolant.copySampleValue_(index: any): any`¶

`GLTFCubicSplineInterpolant.interpolate_(i1: any, t0: any, t: any, t1: any): any`¶

`GLTFCubicSplineQuaternionInterpolant.interpolate_(i1: any, t0: any, t: any, t1: any): any`¶

`createDefaultMaterial(cache: { [x: string]: Material; }): Material`¶

`addUnknownExtensionsToUserData(knownExtensions: any, object: any, objectDef: any): void`¶

`assignExtrasToUserData(object: any, gltfDef: GLTF.definition): void`¶

`addMorphTargets(geometry: BufferGeometry, targets: GLTF.Target[], parser: GLTFParser): Promise<BufferGeometry>`¶

`updateMorphTargets(mesh: Mesh, meshDef: GLTF.Mesh): void`¶

`createPrimitiveKey(primitiveDef: any): string`¶

`createAttributesKey(attributes: any): string`¶

`getNormalizedComponentScale(constructor: any): number`¶

`getImageURIMimeType(uri: any): "image/png" | "image/jpeg" | "image/webp" | "image/ktx2"`¶

`GLTFParser.setExtensions(extensions: any): void`¶

`GLTFParser.setPlugins(plugins: any): void`¶

`GLTFParser.parse(onLoad: any, onError: any): void`¶

`GLTFParser._markDefs(): void`¶

`GLTFParser._addNodeRef(cache: any, index: Object3D): void`¶

`GLTFParser._getNodeRef(cache: any, index: number, object: any): any`¶

`GLTFParser._invokeOne(func: any): any`¶

`GLTFParser._invokeAll(func: any): any[]`¶

`GLTFParser.getDependency(type: string, index: number): Promise<any>`¶

`GLTFParser.getDependencies(type: string): Promise<any[]>`¶

`GLTFParser.loadBuffer(bufferIndex: number): Promise<ArrayBuffer>`¶

`GLTFParser.loadBufferView(bufferViewIndex: number): Promise<ArrayBuffer>`¶

`GLTFParser.loadAccessor(accessorIndex: number): Promise<any>`¶

`GLTFParser.loadTexture(textureIndex: number): Promise<any>`¶

`GLTFParser.loadTextureImage(textureIndex: any, sourceIndex: any, loader: any): any`¶