https://zipmex.com/assets/js/vendor/GLTFLoader.js

1( function () {
2
3	class GLTFLoader extends THREE.Loader {
4
5		constructor( manager ) {
6
7			super( manager );
8			this.dracoLoader = null;
9			this.ktx2Loader = null;
10			this.meshoptDecoder = null;
11			this.pluginCallbacks = [];
12			this.register( function ( parser ) {
13
14				return new GLTFMaterialsClearcoatExtension( parser );
15
16			} );
17			this.register( function ( parser ) {
18
19				return new GLTFTextureBasisUExtension( parser );
20
21			} );
22			this.register( function ( parser ) {
23
24				return new GLTFTextureWebPExtension( parser );
25
26			} );
27			this.register( function ( parser ) {
28
29				return new GLTFMaterialsTransmissionExtension( parser );
30
31			} );
32			this.register( function ( parser ) {
33
34				return new GLTFLightsExtension( parser );
35
36			} );
37			this.register( function ( parser ) {
38
39				return new GLTFMeshoptCompression( parser );
40
41			} );
42
43		}
44
45		load( url, onLoad, onProgress, onError ) {
46
47			const scope = this;
48			let resourcePath;
49
50			if ( this.resourcePath !== '' ) {
51
52				resourcePath = this.resourcePath;
53
54			} else if ( this.path !== '' ) {
55
56				resourcePath = this.path;
57
58			} else {
59
60				resourcePath = THREE.LoaderUtils.extractUrlBase( url );
61
62			} // Tells the LoadingManager to track an extra item, which resolves after
63			// the model is fully loaded. This means the count of items loaded will
64			// be incorrect, but ensures manager.onLoad() does not fire early.
65
66
67			this.manager.itemStart( url );
68
69			const _onError = function ( e ) {
70
71				if ( onError ) {
72
73					onError( e );
74
75				} else {
76
77					console.error( e );
78
79				}
80
81				scope.manager.itemError( url );
82				scope.manager.itemEnd( url );
83
84			};
85
86			const loader = new THREE.FileLoader( this.manager );
87			loader.setPath( this.path );
88			loader.setResponseType( 'arraybuffer' );
89			loader.setRequestHeader( this.requestHeader );
90			loader.setWithCredentials( this.withCredentials );
91			loader.load( url, function ( data ) {
92
93				try {
94
95					scope.parse( data, resourcePath, function ( gltf ) {
96
97						onLoad( gltf );
98						scope.manager.itemEnd( url );
99
100					}, _onError );
101
102				} catch ( e ) {
103
104					_onError( e );
105
106				}
107
108			}, onProgress, _onError );
109
110		}
111
112		setDRACOLoader( dracoLoader ) {
113
114			this.dracoLoader = dracoLoader;
115			return this;
116
117		}
118
119		setDDSLoader() {
120
121			throw new Error( 'THREE.GLTFLoader: "MSFT_texture_dds" no longer supported. Please update to "KHR_texture_basisu".' );
122
123		}
124
125		setKTX2Loader( ktx2Loader ) {
126
127			this.ktx2Loader = ktx2Loader;
128			return this;
129
130		}
131
132		setMeshoptDecoder( meshoptDecoder ) {
133
134			this.meshoptDecoder = meshoptDecoder;
135			return this;
136
137		}
138
139		register( callback ) {
140
141			if ( this.pluginCallbacks.indexOf( callback ) === - 1 ) {
142
143				this.pluginCallbacks.push( callback );
144
145			}
146
147			return this;
148
149		}
150
151		unregister( callback ) {
152
153			if ( this.pluginCallbacks.indexOf( callback ) !== - 1 ) {
154
155				this.pluginCallbacks.splice( this.pluginCallbacks.indexOf( callback ), 1 );
156
157			}
158
159			return this;
160
161		}
162
163		parse( data, path, onLoad, onError ) {
164
165			let content;
166			const extensions = {};
167			const plugins = {};
168
169			if ( typeof data === 'string' ) {
170
171				content = data;
172
173			} else {
174
175				const magic = THREE.LoaderUtils.decodeText( new Uint8Array( data, 0, 4 ) );
176
177				if ( magic === BINARY_EXTENSION_HEADER_MAGIC ) {
178
179					try {
180
181						extensions[ EXTENSIONS.KHR_BINARY_GLTF ] = new GLTFBinaryExtension( data );
182
183					} catch ( error ) {
184
185						if ( onError ) onError( error );
186						return;
187
188					}
189
190					content = extensions[ EXTENSIONS.KHR_BINARY_GLTF ].content;
191
192				} else {
193
194					content = THREE.LoaderUtils.decodeText( new Uint8Array( data ) );
195
196				}
197
198			}
199
200			const json = JSON.parse( content );
201
202			if ( json.asset === undefined || json.asset.version[ 0 ] < 2 ) {
203
204				if ( onError ) onError( new Error( 'THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported.' ) );
205				return;
206
207			}
208
209			const parser = new GLTFParser( json, {
210				path: path || this.resourcePath || '',
211				crossOrigin: this.crossOrigin,
212				requestHeader: this.requestHeader,
213				manager: this.manager,
214				ktx2Loader: this.ktx2Loader,
215				meshoptDecoder: this.meshoptDecoder
216			} );
217			parser.fileLoader.setRequestHeader( this.requestHeader );
218
219			for ( let i = 0; i < this.pluginCallbacks.length; i ++ ) {
220
221				const plugin = this.pluginCallbacks[ i ]( parser );
222				plugins[ plugin.name ] = plugin; // Workaround to avoid determining as unknown extension
223				// in addUnknownExtensionsToUserData().
224				// Remove this workaround if we move all the existing
225				// extension handlers to plugin system
226
227				extensions[ plugin.name ] = true;
228
229			}
230
231			if ( json.extensionsUsed ) {
232
233				for ( let i = 0; i < json.extensionsUsed.length; ++ i ) {
234
235					const extensionName = json.extensionsUsed[ i ];
236					const extensionsRequired = json.extensionsRequired || [];
237
238					switch ( extensionName ) {
239
240						case EXTENSIONS.KHR_MATERIALS_UNLIT:
241							extensions[ extensionName ] = new GLTFMaterialsUnlitExtension();
242							break;
243
244						case EXTENSIONS.KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS:
245							extensions[ extensionName ] = new GLTFMaterialsPbrSpecularGlossinessExtension();
246							break;
247
248						case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
249							extensions[ extensionName ] = new GLTFDracoMeshCompressionExtension( json, this.dracoLoader );
250							break;
251
252						case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
253							extensions[ extensionName ] = new GLTFTextureTransformExtension();
254							break;
255
256						case EXTENSIONS.KHR_MESH_QUANTIZATION:
257							extensions[ extensionName ] = new GLTFMeshQuantizationExtension();
258							break;
259
260						default:
261							if ( extensionsRequired.indexOf( extensionName ) >= 0 && plugins[ extensionName ] === undefined ) {
262
263								console.warn( 'THREE.GLTFLoader: Unknown extension "' + extensionName + '".' );
264
265							}
266
267					}
268
269				}
270
271			}
272
273			parser.setExtensions( extensions );
274			parser.setPlugins( plugins );
275			parser.parse( onLoad, onError );
276
277		}
278
279	}
280	/* GLTFREGISTRY */
281
282
283	function GLTFRegistry() {
284
285		let objects = {};
286		return {
287			get: function ( key ) {
288
289				return objects[ key ];
290
291			},
292			add: function ( key, object ) {
293
294				objects[ key ] = object;
295
296			},
297			remove: function ( key ) {
298
299				delete objects[ key ];
300
301			},
302			removeAll: function () {
303
304				objects = {};
305
306			}
307		};
308
309	}
310	/*********************************/
311
312	/********** EXTENSIONS ***********/
313
314	/*********************************/
315
316
317	const EXTENSIONS = {
318		KHR_BINARY_GLTF: 'KHR_binary_glTF',
319		KHR_DRACO_MESH_COMPRESSION: 'KHR_draco_mesh_compression',
320		KHR_LIGHTS_PUNCTUAL: 'KHR_lights_punctual',
321		KHR_MATERIALS_CLEARCOAT: 'KHR_materials_clearcoat',
322		KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS: 'KHR_materials_pbrSpecularGlossiness',
323		KHR_MATERIALS_TRANSMISSION: 'KHR_materials_transmission',
324		KHR_MATERIALS_UNLIT: 'KHR_materials_unlit',
325		KHR_TEXTURE_BASISU: 'KHR_texture_basisu',
326		KHR_TEXTURE_TRANSFORM: 'KHR_texture_transform',
327		KHR_MESH_QUANTIZATION: 'KHR_mesh_quantization',
328		EXT_TEXTURE_WEBP: 'EXT_texture_webp',
329		EXT_MESHOPT_COMPRESSION: 'EXT_meshopt_compression'
330	};
331	/**
332	 * Punctual Lights Extension
333	 *
334	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_lights_punctual
335	 */
336
337	class GLTFLightsExtension {
338
339		constructor( parser ) {
340
341			this.parser = parser;
342			this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL; // THREE.Object3D instance caches
343
344			this.cache = {
345				refs: {},
346				uses: {}
347			};
348
349		}
350
351		_markDefs() {
352
353			const parser = this.parser;
354			const nodeDefs = this.parser.json.nodes || [];
355
356			for ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {
357
358				const nodeDef = nodeDefs[ nodeIndex ];
359
360				if ( nodeDef.extensions && nodeDef.extensions[ this.name ] && nodeDef.extensions[ this.name ].light !== undefined ) {
361
362					parser._addNodeRef( this.cache, nodeDef.extensions[ this.name ].light );
363
364				}
365
366			}
367
368		}
369
370		_loadLight( lightIndex ) {
371
372			const parser = this.parser;
373			const cacheKey = 'light:' + lightIndex;
374			let dependency = parser.cache.get( cacheKey );
375			if ( dependency ) return dependency;
376			const json = parser.json;
377			const extensions = json.extensions && json.extensions[ this.name ] || {};
378			const lightDefs = extensions.lights || [];
379			const lightDef = lightDefs[ lightIndex ];
380			let lightNode;
381			const color = new THREE.Color( 0xffffff );
382			if ( lightDef.color !== undefined ) color.fromArray( lightDef.color );
383			const range = lightDef.range !== undefined ? lightDef.range : 0;
384
385			switch ( lightDef.type ) {
386
387				case 'directional':
388					lightNode = new THREE.DirectionalLight( color );
389					lightNode.target.position.set( 0, 0, - 1 );
390					lightNode.add( lightNode.target );
391					break;
392
393				case 'point':
394					lightNode = new THREE.PointLight( color );
395					lightNode.distance = range;
396					break;
397
398				case 'spot':
399					lightNode = new THREE.SpotLight( color );
400					lightNode.distance = range; // Handle spotlight properties.
401
402					lightDef.spot = lightDef.spot || {};
403					lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== undefined ? lightDef.spot.innerConeAngle : 0;
404					lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== undefined ? lightDef.spot.outerConeAngle : Math.PI / 4.0;
405					lightNode.angle = lightDef.spot.outerConeAngle;
406					lightNode.penumbra = 1.0 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;
407					lightNode.target.position.set( 0, 0, - 1 );
408					lightNode.add( lightNode.target );
409					break;
410
411				default:
412					throw new Error( 'THREE.GLTFLoader: Unexpected light type: ' + lightDef.type );
413
414			} // Some lights (e.g. spot) default to a position other than the origin. Reset the position
415			// here, because node-level parsing will only override position if explicitly specified.
416
417
418			lightNode.position.set( 0, 0, 0 );
419			lightNode.decay = 2;
420			if ( lightDef.intensity !== undefined ) lightNode.intensity = lightDef.intensity;
421			lightNode.name = parser.createUniqueName( lightDef.name || 'light_' + lightIndex );
422			dependency = Promise.resolve( lightNode );
423			parser.cache.add( cacheKey, dependency );

876				const chunkLength = chunkView.getUint32( chunkIndex, true );
877				chunkIndex += 4;
878				const chunkType = chunkView.getUint32( chunkIndex, true );
879				chunkIndex += 4;
880
881				if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON ) {
882
883					const contentArray = new Uint8Array( data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength );
884					this.content = THREE.LoaderUtils.decodeText( contentArray );
885
886				} else if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN ) {
887
888					const byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
889					this.body = data.slice( byteOffset, byteOffset + chunkLength );
890
891				} // Clients must ignore chunks with unknown types.
892
893
894				chunkIndex += chunkLength;
895
896			}
897
898			if ( this.content === null ) {
899
900				throw new Error( 'THREE.GLTFLoader: JSON content not found.' );
901
902			}
903
904		}
905
906	}
907	/**
908	 * DRACO THREE.Mesh Compression Extension
909	 *
910	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression
911	 */
912
913
914	class GLTFDracoMeshCompressionExtension {
915
916		constructor( json, dracoLoader ) {
917
918			if ( ! dracoLoader ) {
919
920				throw new Error( 'THREE.GLTFLoader: No DRACOLoader instance provided.' );
921
922			}
923
924			this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION;
925			this.json = json;
926			this.dracoLoader = dracoLoader;
927			this.dracoLoader.preload();
928
929		}
930
931		decodePrimitive( primitive, parser ) {
932
933			const json = this.json;
934			const dracoLoader = this.dracoLoader;
935			const bufferViewIndex = primitive.extensions[ this.name ].bufferView;
936			const gltfAttributeMap = primitive.extensions[ this.name ].attributes;
937			const threeAttributeMap = {};
938			const attributeNormalizedMap = {};
939			const attributeTypeMap = {};
940
941			for ( const attributeName in gltfAttributeMap ) {
942
943				const threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();
944				threeAttributeMap[ threeAttributeName ] = gltfAttributeMap[ attributeName ];
945
946			}
947
948			for ( const attributeName in primitive.attributes ) {
949
950				const threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();
951
952				if ( gltfAttributeMap[ attributeName ] !== undefined ) {
953
954					const accessorDef = json.accessors[ primitive.attributes[ attributeName ] ];
955					const componentType = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
956					attributeTypeMap[ threeAttributeName ] = componentType;
957					attributeNormalizedMap[ threeAttributeName ] = accessorDef.normalized === true;
958
959				}
960
961			}
962
963			return parser.getDependency( 'bufferView', bufferViewIndex ).then( function ( bufferView ) {
964
965				return new Promise( function ( resolve ) {
966
967					dracoLoader.decodeDracoFile( bufferView, function ( geometry ) {
968
969						for ( const attributeName in geometry.attributes ) {
970
971							const attribute = geometry.attributes[ attributeName ];
972							const normalized = attributeNormalizedMap[ attributeName ];
973							if ( normalized !== undefined ) attribute.normalized = normalized;
974
975						}
976
977						resolve( geometry );
978
979					}, threeAttributeMap, attributeTypeMap );
980
981				} );
982
983			} );
984
985		}
986
987	}
988	/**
989	 * Texture Transform Extension
990	 *
991	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_texture_transform
992	 */
993
994
995	class GLTFTextureTransformExtension {
996
997		constructor() {
998
999			this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM;
1000
1001		}
1002
1003		extendTexture( texture, transform ) {
1004
1005			texture = texture.clone();
1006
1007			if ( transform.offset !== undefined ) {
1008
1009				texture.offset.fromArray( transform.offset );
1010
1011			}
1012
1013			if ( transform.rotation !== undefined ) {
1014
1015				texture.rotation = transform.rotation;
1016
1017			}
1018
1019			if ( transform.scale !== undefined ) {
1020
1021				texture.repeat.fromArray( transform.scale );
1022
1023			}
1024
1025			if ( transform.texCoord !== undefined ) {
1026
1027				console.warn( 'THREE.GLTFLoader: Custom UV sets in "' + this.name + '" extension not yet supported.' );
1028
1029			}
1030
1031			texture.needsUpdate = true;
1032			return texture;
1033
1034		}
1035
1036	}
1037	/**
1038	 * Specular-Glossiness Extension
1039	 *
1040	 * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness
1041	 */
1042
1043	/**
1044	 * A sub class of StandardMaterial with some of the functionality
1045	 * changed via the `onBeforeCompile` callback
1046	 * @pailhead
1047	 */
1048
1049
1050	class GLTFMeshStandardSGMaterial extends THREE.MeshStandardMaterial {
1051
1052		constructor( params ) {
1053
1054			super();
1055			this.isGLTFSpecularGlossinessMaterial = true; //various chunks that need replacing
1056
1057			const specularMapParsFragmentChunk = [ '#ifdef USE_SPECULARMAP', '	uniform sampler2D specularMap;', '#endif' ].join( '\n' );
1058			const glossinessMapParsFragmentChunk = [ '#ifdef USE_GLOSSINESSMAP', '	uniform sampler2D glossinessMap;', '#endif' ].join( '\n' );
1059			const specularMapFragmentChunk = [ 'vec3 specularFactor = specular;', '#ifdef USE_SPECULARMAP', '	vec4 texelSpecular = texture2D( specularMap, vUv );', '	texelSpecular = sRGBToLinear( texelSpecular );', '	// reads channel RGB, compatible with a glTF Specular-Glossiness (RGBA) texture', '	specularFactor *= texelSpecular.rgb;', '#endif' ].join( '\n' );
1060			const glossinessMapFragmentChunk = [ 'float glossinessFactor = glossiness;', '#ifdef USE_GLOSSINESSMAP', '	vec4 texelGlossiness = texture2D( glossinessMap, vUv );', '	// reads channel A, compatible with a glTF Specular-Glossiness (RGBA) texture', '	glossinessFactor *= texelGlossiness.a;', '#endif' ].join( '\n' );
1061			const lightPhysicalFragmentChunk = [ 'PhysicalMaterial material;', 'material.diffuseColor = diffuseColor.rgb * ( 1. - max( specularFactor.r, max( specularFactor.g, specularFactor.b ) ) );', 'vec3 dxy = max( abs( dFdx( geometryNormal ) ), abs( dFdy( geometryNormal ) ) );', 'float geometryRoughness = max( max( dxy.x, dxy.y ), dxy.z );

1290			this.name = EXTENSIONS.KHR_MESH_QUANTIZATION;
1291
1292		}
1293
1294	}
1295	/*********************************/
1296
1297	/********** INTERPOLATION ********/
1298
1299	/*********************************/
1300	// Spline Interpolation
1301	// Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#appendix-c-spline-interpolation
1302
1303
1304	class GLTFCubicSplineInterpolant extends THREE.Interpolant {
1305
1306		constructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
1307
1308			super( parameterPositions, sampleValues, sampleSize, resultBuffer );
1309
1310		}
1311
1312		copySampleValue_( index ) {
1313
1314			// Copies a sample value to the result buffer. See description of glTF
1315			// CUBICSPLINE values layout in interpolate_() function below.
1316			const result = this.resultBuffer,
1317				values = this.sampleValues,
1318				valueSize = this.valueSize,
1319				offset = index * valueSize * 3 + valueSize;
1320
1321			for ( let i = 0; i !== valueSize; i ++ ) {
1322
1323				result[ i ] = values[ offset + i ];
1324
1325			}
1326
1327			return result;
1328
1329		}
1330
1331	}
1332
1333	GLTFCubicSplineInterpolant.prototype.beforeStart_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
1334	GLTFCubicSplineInterpolant.prototype.afterEnd_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
1335
1336	GLTFCubicSplineInterpolant.prototype.interpolate_ = function ( i1, t0, t, t1 ) {
1337
1338		const result = this.resultBuffer;
1339		const values = this.sampleValues;
1340		const stride = this.valueSize;
1341		const stride2 = stride * 2;
1342		const stride3 = stride * 3;
1343		const td = t1 - t0;
1344		const p = ( t - t0 ) / td;
1345		const pp = p * p;
1346		const ppp = pp * p;
1347		const offset1 = i1 * stride3;
1348		const offset0 = offset1 - stride3;
1349		const s2 = - 2 * ppp + 3 * pp;
1350		const s3 = ppp - pp;
1351		const s0 = 1 - s2;
1352		const s1 = s3 - pp + p; // Layout of keyframe output values for CUBICSPLINE animations:
1353		//   [ inTangent_1, splineVertex_1, outTangent_1, inTangent_2, splineVertex_2, ... ]
1354
1355		for ( let i = 0; i !== stride; i ++ ) {
1356
1357			const p0 = values[ offset0 + i + stride ]; // splineVertex_k
1358
1359			const m0 = values[ offset0 + i + stride2 ] * td; // outTangent_k * (t_k+1 - t_k)
1360
1361			const p1 = values[ offset1 + i + stride ]; // splineVertex_k+1
1362
1363			const m1 = values[ offset1 + i ] * td; // inTangent_k+1 * (t_k+1 - t_k)
1364
1365			result[ i ] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
1366
1367		}
1368
1369		return result;
1370
1371	};
1372	/*********************************/
1373
1374	/********** INTERNALS ************/
1375
1376	/*********************************/
1377
1378	/* CONSTANTS */
1379
1380
1381	const WEBGL_CONSTANTS = {
1382		FLOAT: 5126,
1383		//FLOAT_MAT2: 35674,
1384		FLOAT_MAT3: 35675,
1385		FLOAT_MAT4: 35676,
1386		FLOAT_VEC2: 35664,
1387		FLOAT_VEC3: 35665,
1388		FLOAT_VEC4: 35666,
1389		LINEAR: 9729,
1390		REPEAT: 10497,
1391		SAMPLER_2D: 35678,
1392		POINTS: 0,
1393		LINES: 1,
1394		LINE_LOOP: 2,
1395		LINE_STRIP: 3,
1396		TRIANGLES: 4,
1397		TRIANGLE_STRIP: 5,
1398		TRIANGLE_FAN: 6,
1399		UNSIGNED_BYTE: 5121,
1400		UNSIGNED_SHORT: 5123
1401	};
1402	const WEBGL_COMPONENT_TYPES = {
1403		5120: Int8Array,
1404		5121: Uint8Array,
1405		5122: Int16Array,
1406		5123: Uint16Array,
1407		5125: Uint32Array,
1408		5126: Float32Array
1409	};
1410	const WEBGL_FILTERS = {
1411		9728: THREE.NearestFilter,
1412		9729: THREE.LinearFilter,
1413		9984: THREE.NearestMipmapNearestFilter,
1414		9985: THREE.LinearMipmapNearestFilter,
1415		9986: THREE.NearestMipmapLinearFilter,
1416		9987: THREE.LinearMipmapLinearFilter
1417	};
1418	const WEBGL_WRAPPINGS = {
1419		33071: THREE.ClampToEdgeWrapping,
1420		33648: THREE.MirroredRepeatWrapping,
1421		10497: THREE.RepeatWrapping
1422	};
1423	const WEBGL_TYPE_SIZES = {
1424		'SCALAR': 1,
1425		'VEC2': 2,
1426		'VEC3': 3,
1427		'VEC4': 4,
1428		'MAT2': 4,
1429		'MAT3': 9,
1430		'MAT4': 16
1431	};
1432	const ATTRIBUTES = {
1433		POSITION: 'position',
1434		NORMAL: 'normal',
1435		TANGENT: 'tangent',
1436		TEXCOORD_0: 'uv',
1437		TEXCOORD_1: 'uv2',
1438		COLOR_0: 'color',
1439		WEIGHTS_0: 'skinWeight',
1440		JOINTS_0: 'skinIndex'
1441	};
1442	const PATH_PROPERTIES = {
1443		scale: 'scale',
1444		translation: 'position',
1445		rotation: 'quaternion',
1446		weights: 'morphTargetInfluences'
1447	};
1448	const INTERPOLATION = {
1449		CUBICSPLINE: undefined,
1450		// We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each
1451		// keyframe track will be initialized with a default interpolation type, then modified.
1452		LINEAR: THREE.InterpolateLinear,
1453		STEP: THREE.InterpolateDiscrete
1454	};
1455	const ALPHA_MODES = {
1456		OPAQUE: 'OPAQUE',
1457		MASK: 'MASK',
1458		BLEND: 'BLEND'
1459	};
1460	/* UTILITY FUNCTIONS */
1461
1462	function resolveURL( url, path ) {
1463
1464		// Invalid URL
1465		if ( typeof url !== 'string' || url === '' ) return ''; // Host Relative URL
1466
1467		if ( /^https?:\/\//i.test( path ) && /^\//.test( url ) ) {
1468
1469			path = path.replace( /(^https?:\/\/[^\/]+).*/i, '$1' );
1470
1471		} // Absolute URL http://,https://,//
1472
1473
1474		if ( /^(https?:)?\/\//i.test( url ) ) return url; // Data URI
1475
1476		if ( /^data:.*,.*$/i.test( url ) ) return url; // Blob URL
1477
1478		if ( /^blob:.*$/i.test( url ) ) return url; // Relative URL
1479
1480		return path + url;
1481
1482	}
1483	/**
1484	 * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#default-material
1485	 */
1486
1487
1488	function createDefaultMaterial( cache ) {
1489
1490		if ( cache[ 'DefaultMaterial' ] === undefined ) {
1491
1492			cache[ 'DefaultMaterial' ] = new THREE.MeshStandardMaterial( {
1493				color: 0xFFFFFF,
1494				emissive: 0x000000,
1495				metalness: 1,
1496				roughness: 1,
1497				transparent: false,
1498				depthTest: true,
1499				side: THREE.FrontSide
1500			} );
1501
1502		}
1503
1504		return cache[ 'DefaultMaterial' ];
1505
1506	}
1507
1508	function addUnknownExtensionsToUserData( knownExtensions, object, objectDef ) {
1509
1510		// Add unknown glTF extensions to an object's userData.
1511		for ( const name in objectDef.extensions ) {
1512
1513			if ( knownExtensions[ name ] === undefined ) {
1514
1515				object.userData.gltfExtensions = object.userData.gltfExtensions || {};
1516				object.userData.gltfExtensions[ name ] = objectDef.extensions[ name ];
1517
1518			}
1519
1520		}
1521
1522	}
1523	/**
1524	 * @param {Object3D|Material|BufferGeometry} object
1525	 * @param {GLTF.definition} gltfDef
1526	 */
1527
1528
1529	function assignExtrasToUserData( object, gltfDef ) {
1530
1531		if ( gltfDef.extras !== undefined ) {
1532
1533			if ( typeof gltfDef.extras === 'object' ) {
1534
1535				Object.assign( object.userData, gltfDef.extras );
1536
1537			} else {
1538
1539				console.warn( 'THREE.GLTFLoader: Ignoring primitive type .extras, ' + gltfDef.extras );
1540
1541			}
1542
1543		}
1544
1545	}
1546	/**
1547	 * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#morph-targets
1548	 *
1549	 * @param {BufferGeometry} geometry
1550	 * @param {Array<GLTF.Target>} targets
1551	 * @param {GLTFParser} parser
1552	 * @return {Promise<BufferGeometry>}
1553	 */
1554
1555
1556	function addMorphTargets( geometry, targets, parser ) {
1557
1558		let hasMorphPosition = false;
1559		let hasMorphNormal = false;
1560
1561		for ( let i = 0, il = targets.length; i < il; i ++ ) {
1562
1563			const target = targets[ i ];
1564			if ( target.POSITION !== undefined ) hasMorphPosition = true;
1565			if ( target.NORMAL !== undefined ) hasMorphNormal = true;
1566			if ( hasMorphPosition && hasMorphNormal ) break;
1567
1568		}
1569
1570		if ( ! hasMorphPosition && ! hasMorphNormal ) return Promise.resolve( geometry );
1571		const pendingPositionAccessors = [];
1572		const pendingNormalAccessors = [];
1573
1574		for ( let i = 0, il = targets.length; i < il; i ++ ) {
1575
1576			const target = targets[ i ];
1577
1578			if ( hasMorphPosition ) {
1579
1580				const pendingAccessor = target.POSITION !== undefined ? parser.getDependency( 'accessor', target.POSITION ) : geometry.attributes.position;
1581				pendingPositionAccessors.push( pendingAccessor );
1582
1583			}
1584
1585			if ( hasMorphNormal ) {
1586
1587				const pendingAccessor = target.NORMAL !== undefined ? parser.getDependency( 'accessor', target.NORMAL ) : geometry.attributes.normal;
1588				pendingNormalAccessors.push( pendingAccessor );
1589
1590			}
1591
1592		}
1593
1594		return Promise.all( [ Promise.all( pendingPositionAccessors ), Promise.all( pendingNormalAccessors ) ] ).then( function ( accessors ) {
1595
1596			const morphPositions = accessors[ 0 ];
1597			const morphNormals = accessors[ 1 ];
1598			if ( hasMorphPosition ) geometry.morphAttributes.position = morphPositions;
1599			if ( hasMorphNormal ) geometry.morphAttributes.normal = morphNormals;
1600			geometry.morphTargetsRelative = true;
1601			return geometry;
1602
1603		} );
1604
1605	}
1606	/**
1607	 * @param {Mesh} mesh
1608	 * @param {GLTF.Mesh} meshDef
1609	 */
1610
1611
1612	function updateMorphTargets( mesh, meshDef ) {
1613
1614		mesh.updateMorphTargets();
1615
1616		if ( meshDef.weights !== undefined ) {
1617
1618			for ( let i = 0, il = meshDef.weights.length; i < il; i ++ ) {
1619
1620				mesh.morphTargetInfluences[ i ] = meshDef.weights[ i ];
1621
1622			}
1623
1624		} // .extras has user-defined data, so check that .extras.targetNames is an array.
1625
1626
1627		if ( meshDef.extras && Array.isArray( meshDef.extras.targetNames ) ) {
1628
1629			const targetNames = meshDef.extras.targetNames;
1630
1631			if ( mesh.morphTargetInfluences.length === targetNames.length ) {
1632
1633				mesh.morphTargetDictionary = {};
1634
1635				for ( let i = 0, il = targetNames.length; i < il; i ++ ) {
1636
1637					mesh.morphTargetDictionary[ targetNames[ i ] ] = i;
1638
1639				}
1640
1641			} else {
1642
1643				console.warn( 'THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.' );
1644
1645			}
1646
1647		}
1648
1649	}
1650
1651	function createPrimitiveKey( primitiveDef ) {
1652
1653		const dracoExtension = primitiveDef.extensions && primitiveDef.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ];
1654		let geometryKey;
1655
1656		if ( dracoExtension ) {
1657
1658			geometryKey = 'draco:' + dracoExtension.bufferView + ':' + dracoExtension.indices + ':' + createAttributesKey( dracoExtension.attributes );
1659
1660		} else {
1661
1662			geometryKey = primitiveDef.indices + ':' + createAttributesKey( primitiveDef.attributes ) + ':' + primitiveDef.mode;
1663
1664		}
1665
1666		return geometryKey;
1667
1668	}
1669
1670	function createAttributesKey( attributes ) {
1671
1672		let attributesKey = '';
1673		const keys = Object.keys( attributes ).sort();
1674
1675		for ( let i = 0, il = keys.length; i < il; i ++ ) {
1676
1677			attributesKey += keys[ i ] + ':' + attributes[ keys[ i ] ] + ';';
1678
1679		}
1680
1681		return attributesKey;
1682
1683	}
1684
1685	function getNormalizedComponentScale( constructor ) {
1686
1687		// Reference:
1688		// https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_mesh_quantization#encoding-quantized-data
1689		switch ( constructor ) {
1690
1691			case Int8Array:
1692				return 1 / 127;
1693
1694			case Uint8Array:
1695				return 1 / 255;
1696
1697			case Int16Array:
1698				return 1 / 32767;
1699
1700			case Uint16Array:
1701				return 1 / 65535;
1702
1703			default:
1704				throw new Error( 'THREE.GLTFLoader: Unsupported normalized accessor component type.' );
1705
1706		}
1707
1708	}
1709	/* GLTF PARSER */
1710
1711
1712	class GLTFParser {
1713
1714		constructor( json = {}, options = {} ) {
1715
1716			this.json = json;
1717			this.extensions = {};
1718			this.plugins = {};
1719			this.options = options; // loader object cache
1720
1721			this.cache = new GLTFRegistry(); // associations between Three.js objects and glTF elements
1722
1723			this.associations = new Map(); // THREE.BufferGeometry caching
1724
1725			this.primitiveCache = {}; // THREE.Object3D instance caches
1726
1727			this.meshCache = {
1728				refs: {},
1729				uses: {}
1730			};
1731			this.cameraCache = {
1732				refs: {},
1733				uses: {}
1734			};
1735			this.lightCache = {
1736				refs: {},
1737				uses: {}
1738			}; // Track node names, to ensure no duplicates
1739
1740			this.nodeNamesUsed = {}; // Use an THREE.ImageBitmapLoader if imageBitmaps are supported. Moves much of the
1741			// expensive work of uploading a texture to the GPU off the main thread.
1742
1743			if ( typeof createImageBitmap !== 'undefined' && /Firefox/.test( navigator.userAgent ) === false ) {
1744
1745				this.textureLoader = new THREE.ImageBitmapLoader( this.options.manager );
1746
1747			} else {
1748
1749				this.textureLoader = new THREE.TextureLoader( this.options.manager );
1750
1751			}
1752
1753			this.textureLoader.setCrossOrigin( this.options.crossOrigin );
1754			this.textureLoader.setRequestHeader( this.options.requestHeader );
1755			this.fileLoader = new THREE.FileLoader( this.options.manager );
1756			this.fileLoader.setResponseType( 'arraybuffer' );
1757
1758			if ( this.options.crossOrigin === 'use-credentials' ) {
1759
1760				this.fileLoader.setWithCredentials( true );
1761
1762			}
1763
1764		}
1765
1766		setExtensions( extensions ) {
1767
1768			this.extensions = extensions;
1769
1770		}
1771
1772		setPlugins( plugins ) {
1773
1774			this.plugins = plugins;
1775
1776		}
1777
1778		parse( onLoad, onError ) {
1779
1780			const parser = this;
1781			const json = this.json;
1782			const extensions = this.extensions; // Clear the loader cache
1783
1784			this.cache.removeAll(); // Mark the special nodes/meshes in json for efficient parse
1785
1786			this._invokeAll( function ( ext ) {
1787
1788				return ext._markDefs && ext._markDefs();
1789
1790			} );
1791
1792			Promise.all( this._invokeAll( function ( ext ) {
1793
1794				return ext.beforeRoot && ext.beforeRoot();
1795
1796			} ) ).then( function () {
1797
1798				return Promise.all( [ parser.getDependencies( 'scene' ), parser.getDependencies( 'animation' ), parser.getDependencies( 'camera' ) ] );
1799
1800			} ).then( function ( dependencies ) {
1801
1802				const result = {

1803					scene: dependencies[ 0 ][ json.scene || 0 ],
1804					scenes: dependencies[ 0 ],
1805					animations: dependencies[ 1 ],
1806					cameras: dependencies[ 2 ],
1807					asset: json.asset,
1808					parser: parser,
1809					userData: {}
1810				};
1811				addUnknownExtensionsToUserData( extensions, result, json );
1812				assignExtrasToUserData( result, json );
1813				Promise.all( parser._invokeAll( function ( ext ) {
1814
1815					return ext.afterRoot && ext.afterRoot( result );
1816
1817				} ) ).then( function () {
1818
1819					onLoad( result );
1820
1821				} );
1822
1823			} ).catch( onError );
1824
1825		}
1826		/**
1827   * Marks the special nodes/meshes in json for efficient parse.
1828   */
1829
1830
1831		_markDefs() {
1832
1833			const nodeDefs = this.json.nodes || [];
1834			const skinDefs = this.json.skins || [];
1835			const meshDefs = this.json.meshes || []; // Nothing in the node definition indicates whether it is a THREE.Bone or an
1836			// THREE.Object3D. Use the skins' joint references to mark bones.
1837
1838			for ( let skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex ++ ) {
1839
1840				const joints = skinDefs[ skinIndex ].joints;
1841
1842				for ( let i = 0, il = joints.length; i < il; i ++ ) {
1843
1844					nodeDefs[ joints[ i ] ].isBone = true;
1845
1846				}
1847
1848			} // Iterate over all nodes, marking references to shared resources,
1849			// as well as skeleton joints.
1850
1851
1852			for ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {
1853
1854				const nodeDef = nodeDefs[ nodeIndex ];
1855
1856				if ( nodeDef.mesh !== undefined ) {
1857
1858					this._addNodeRef( this.meshCache, nodeDef.mesh ); // Nothing in the mesh definition indicates whether it is
1859					// a THREE.SkinnedMesh or THREE.Mesh. Use the node's mesh reference
1860					// to mark THREE.SkinnedMesh if node has skin.
1861
1862
1863					if ( nodeDef.skin !== undefined ) {
1864
1865						meshDefs[ nodeDef.mesh ].isSkinnedMesh = true;
1866
1867					}
1868
1869				}
1870
1871				if ( nodeDef.camera !== undefined ) {
1872
1873					this._addNodeRef( this.cameraCache, nodeDef.camera );
1874
1875				}
1876
1877			}
1878
1879		}
1880		/**
1881   * Counts references to shared node / THREE.Object3D resources. These resources
1882   * can be reused, or "instantiated", at multiple nodes in the scene
1883   * hierarchy. THREE.Mesh, Camera, and Light instances are instantiated and must
1884   * be marked. Non-scenegraph resources (like Materials, Geometries, and
1885   * Textures) can be reused directly and are not marked here.
1886   *
1887   * Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
1888   */
1889
1890
1891		_addNodeRef( cache, index ) {
1892
1893			if ( index === undefined ) return;
1894
1895			if ( cache.refs[ index ] === undefined ) {
1896
1897				cache.refs[ index ] = cache.uses[ index ] = 0;
1898
1899			}
1900
1901			cache.refs[ index ] ++;
1902
1903		}
1904		/** Returns a reference to a shared resource, cloning it if necessary. */
1905
1906
1907		_getNodeRef( cache, index, object ) {
1908
1909			if ( cache.refs[ index ] <= 1 ) return object;
1910			const ref = object.clone();
1911			ref.name += '_instance_' + cache.uses[ index ] ++;
1912			return ref;
1913
1914		}
1915
1916		_invokeOne( func ) {
1917
1918			const extensions = Object.values( this.plugins );
1919			extensions.push( this );
1920
1921			for ( let i = 0; i < extensions.length; i ++ ) {
1922
1923				const result = func( extensions[ i ] );
1924				if ( result ) return result;
1925
1926			}
1927
1928			return null;
1929
1930		}
1931
1932		_invokeAll( func ) {
1933
1934			const extensions = Object.values( this.plugins );
1935			extensions.unshift( this );
1936			const pending = [];
1937
1938			for ( let i = 0; i < extensions.length; i ++ ) {
1939
1940				const result = func( extensions[ i ] );
1941				if ( result ) pending.push( result );
1942
1943			}
1944
1945			return pending;
1946
1947		}
1948		/**
1949   * Requests the specified dependency asynchronously, with caching.
1950   * @param {string} type
1951   * @param {number} index
1952   * @return {Promise<Object3D|Material|THREE.Texture|AnimationClip|ArrayBuffer|Object>}
1953   */
1954
1955
1956		getDependency( type, index ) {
1957
1958			const cacheKey = type + ':' + index;
1959			let dependency = this.cache.get( cacheKey );
1960
1961			if ( ! dependency ) {
1962
1963				switch ( type ) {
1964
1965					case 'scene':
1966						dependency = this.loadScene( index );
1967						break;
1968
1969					case 'node':
1970						dependency = this.loadNode( index );
1971						break;
1972
1973					case 'mesh':
1974						dependency = this._invokeOne( function ( ext ) {
1975
1976							return ext.loadMesh && ext.loadMesh( index );
1977
1978						} );
1979						break;
1980
1981					case 'accessor':
1982						dependency = this.loadAccessor( index );
1983						break;
1984
1985					case 'bufferView':
1986						dependency = this._invokeOne( function ( ext ) {
1987
1988							return ext.loadBufferView && ext.loadBufferView( index );
1989
1990						} );
1991						break;
1992
1993					case 'buffer':
1994						dependency = this.loadBuffer( index );
1995						break;
1996
1997					case 'material':
1998						dependency = this._invokeOne( function ( ext ) {
1999
2000							return ext.loadMaterial && ext.loadMaterial( index );
2001
2002						} );
2003						break;
2004
2005					case 'texture':
2006						dependency = this._invokeOne( function ( ext ) {
2007
2008							return ext.loadTexture && ext.loadTexture( index );
2009
2010						} );
2011						break;
2012
2013					case 'skin':
2014						dependency = this.loadSkin( index );
2015						break;
2016
2017					case 'animation':
2018						dependency = this.loadAnimation( index );
2019						break;
2020
2021					case 'camera':
2022						dependency = this.loadCamera( index );
2023						break;
2024
2025					default:
2026						throw new Error( 'Unknown type: ' + type );
2027
2028				}
2029
2030				this.cache.add( cacheKey, dependency );
2031
2032			}
2033

2034			return dependency;
2035
2036		}
2037		/**
2038   * Requests all dependencies of the specified type asynchronously, with caching.
2039   * @param {string} type
2040   * @return {Promise<Array<Object>>}
2041   */
2042
2043
2044		getDependencies( type ) {
2045
2046			let dependencies = this.cache.get( type );
2047
2048			if ( ! dependencies ) {
2049
2050				const parser = this;
2051				const defs = this.json[ type + ( type === 'mesh' ? 'es' : 's' ) ] || [];
2052				dependencies = Promise.all( defs.map( function ( def, index ) {
2053
2054					return parser.getDependency( type, index );
2055
2056				} ) );
2057				this.cache.add( type, dependencies );
2058
2059			}
2060
2061			return dependencies;
2062
2063		}
2064		/**
2065   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
2066   * @param {number} bufferIndex
2067   * @return {Promise<ArrayBuffer>}
2068   */
2069
2070
2071		loadBuffer( bufferIndex ) {
2072
2073			const bufferDef = this.json.buffers[ bufferIndex ];
2074			const loader = this.fileLoader;
2075
2076			if ( bufferDef.type && bufferDef.type !== 'arraybuffer' ) {
2077
2078				throw new Error( 'THREE.GLTFLoader: ' + bufferDef.type + ' buffer type is not supported.' );
2079
2080			} // If present, GLB container is required to be the first buffer.
2081
2082
2083			if ( bufferDef.uri === undefined && bufferIndex === 0 ) {
2084
2085				return Promise.resolve( this.extensions[ EXTENSIONS.KHR_BINARY_GLTF ].body );
2086
2087			}
2088
2089			const options = this.options;
2090			return new Promise( function ( resolve, reject ) {
2091
2092				loader.load( resolveURL( bufferDef.uri, options.path ), resolve, undefined, function () {
2093
2094					reject( new Error( 'THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".' ) );
2095
2096				} );
2097
2098			} );
2099
2100		}
2101		/**
2102   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
2103   * @param {number} bufferViewIndex
2104   * @return {Promise<ArrayBuffer>}
2105   */
2106
2107
2108		loadBufferView( bufferViewIndex ) {
2109
2110			const bufferViewDef = this.json.bufferViews[ bufferViewIndex ];
2111			return this.getDependency( 'buffer', bufferViewDef.buffer ).then( function ( buffer ) {
2112
2113				const byteLength = bufferViewDef.byteLength || 0;
2114				const byteOffset = bufferViewDef.byteOffset || 0;
2115				return buffer.slice( byteOffset, byteOffset + byteLength );
2116
2117			} );
2118
2119		}
2120		/**
2121   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
2122   * @param {number} accessorIndex
2123   * @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
2124   */
2125
2126
2127		loadAccessor( accessorIndex ) {
2128
2129			const parser = this;
2130			const json = this.json;
2131			const accessorDef = this.json.accessors[ accessorIndex ];
2132
2133			if ( accessorDef.bufferView === undefined && accessorDef.sparse === undefined ) {
2134
2135				// Ignore empty accessors, which may be used to declare runtime
2136				// information about attributes coming from another source (e.g. Draco
2137				// compression extension).
2138				return Promise.resolve( null );
2139
2140			}
2141
2142			const pendingBufferViews = [];
2143
2144			if ( accessorDef.bufferView !== undefined ) {
2145
2146				pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.bufferView ) );
2147
2148			} else {
2149
2150				pendingBufferViews.push( null );
2151
2152			}
2153
2154			if ( accessorDef.sparse !== undefined ) {
2155
2156				pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.indices.bufferView ) );
2157				pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.values.bufferView ) );
2158
2159			}
2160
2161			return Promise.all( pendingBufferViews ).then( function ( bufferViews ) {
2162
2163				const bufferView = bufferViews[ 0 ];
2164				const itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];
2165				const TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ]; // For VEC3: itemSize is 3, elementBytes is 4, itemBytes is 12.
2166
2167				const elementBytes = TypedArray.BYTES_PER_ELEMENT;
2168				const itemBytes = elementBytes * itemSize;
2169				const byteOffset = accessorDef.byteOffset || 0;
2170				const byteStride = accessorDef.bufferView !== undefined ? json.bufferViews[ accessorDef.bufferView ].byteStride : undefined;
2171				const normalized = accessorDef.normalized === true;
2172				let array, bufferAttribute; // The buffer is not interleaved if the stride is the item size in bytes.
2173
2174				if ( byteStride && byteStride !== itemBytes ) {
2175
2176					// Each "slice" of the buffer, as defined by 'count' elements of 'byteStride' bytes, gets its own THREE.InterleavedBuffer
2177					// This makes sure that IBA.count reflects accessor.count properly
2178					const ibSlice = Math.floor( byteOffset / byteStride );
2179					const ibCacheKey = 'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentType + ':' + ibSlice + ':' + accessorDef.count;
2180					let ib = parser.cache.get( ibCacheKey );
2181
2182					if ( ! ib ) {
2183
2184						array = new TypedArray( bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes ); // Integer parameters to IB/IBA are in array elements, not bytes.
2185
2186						ib = new THREE.InterleavedBuffer( array, byteStride / elementBytes );
2187						parser.cache.add( ibCacheKey, ib );
2188
2189					}
2190
2191					bufferAttribute = new THREE.InterleavedBufferAttribute( ib, itemSize, byteOffset % byteStride / elementBytes, normalized );
2192
2193				} else {
2194
2195					if ( bufferView === null ) {
2196
2197						array = new TypedArray( accessorDef.count * itemSize );
2198
2199					} else {
2200