three-stdlib 2.16.2 → 2.17.1

package/loaders/GLTFLoader.js

@@ -1,4 +1,4 @@
-import { Loader, LoaderUtils, FileLoader, Color, SpotLight, PointLight, DirectionalLight, MeshBasicMaterial, MeshPhysicalMaterial, Vector2, sRGBEncoding, TangentSpaceNormalMap, Quaternion, ImageBitmapLoader, TextureLoader, InterleavedBuffer, InterleavedBufferAttribute, BufferAttribute, LinearFilter, LinearMipmapLinearFilter, RepeatWrapping, PointsMaterial, Material, LineBasicMaterial, MeshStandardMaterial, DoubleSide, PropertyBinding, BufferGeometry, SkinnedMesh, Mesh, LineSegments, Line, LineLoop, Points, Group, PerspectiveCamera, MathUtils, OrthographicCamera, InterpolateLinear, AnimationClip, Bone, Object3D, Matrix4, Skeleton, TriangleFanDrawMode, NearestFilter, NearestMipmapNearestFilter, LinearMipmapNearestFilter, NearestMipmapLinearFilter, ClampToEdgeWrapping, MirroredRepeatWrapping, InterpolateDiscrete, FrontSide, Texture, TriangleStripDrawMode, VectorKeyframeTrack, QuaternionKeyframeTrack, NumberKeyframeTrack, Box3, Vector3, Sphere, Interpolant } from 'three';
+import { Loader, LoaderUtils, FileLoader, Color, SpotLight, PointLight, DirectionalLight, MeshBasicMaterial, sRGBEncoding, MeshPhysicalMaterial, Vector2, TangentSpaceNormalMap, Quaternion, TextureLoader, ImageBitmapLoader, InterleavedBuffer, InterleavedBufferAttribute, BufferAttribute, LinearFilter, LinearMipmapLinearFilter, RepeatWrapping, PointsMaterial, Material, LineBasicMaterial, MeshStandardMaterial, DoubleSide, PropertyBinding, BufferGeometry, SkinnedMesh, Mesh, LineSegments, Line, LineLoop, Points, Group, PerspectiveCamera, MathUtils, OrthographicCamera, InterpolateLinear, AnimationClip, Bone, Object3D, Matrix4, Skeleton, TriangleFanDrawMode, NearestFilter, NearestMipmapNearestFilter, LinearMipmapNearestFilter, NearestMipmapLinearFilter, ClampToEdgeWrapping, MirroredRepeatWrapping, InterpolateDiscrete, FrontSide, Texture, TriangleStripDrawMode, VectorKeyframeTrack, QuaternionKeyframeTrack, NumberKeyframeTrack, Box3, Vector3, Sphere, Interpolant } from 'three';
 
 class GLTFLoader extends Loader {
   constructor(manager) {
@@ -28,9 +28,15 @@ class GLTFLoader extends Loader {
     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 GLTFLightsExtension(parser);
     });
@@ -255,11 +261,13 @@ const EXTENSIONS = {
   KHR_MATERIALS_SHEEN: 'KHR_materials_sheen',
   KHR_MATERIALS_SPECULAR: 'KHR_materials_specular',
   KHR_MATERIALS_TRANSMISSION: 'KHR_materials_transmission',
+  KHR_MATERIALS_IRIDESCENCE: 'KHR_materials_iridescence',
   KHR_MATERIALS_UNLIT: 'KHR_materials_unlit',
   KHR_MATERIALS_VOLUME: 'KHR_materials_volume',
   KHR_TEXTURE_BASISU: 'KHR_texture_basisu',
   KHR_TEXTURE_TRANSFORM: 'KHR_texture_transform',
   KHR_MESH_QUANTIZATION: 'KHR_mesh_quantization',
+  KHR_MATERIALS_EMISSIVE_STRENGTH: 'KHR_materials_emissive_strength',
   EXT_TEXTURE_WEBP: 'EXT_texture_webp',
   EXT_MESHOPT_COMPRESSION: 'EXT_meshopt_compression'
 };
@@ -391,13 +399,44 @@ class GLTFMaterialsUnlitExtension {
       }
 
       if (metallicRoughness.baseColorTexture !== undefined) {
-        pending.push(parser.assignTexture(materialParams, 'map', metallicRoughness.baseColorTexture));
+        pending.push(parser.assignTexture(materialParams, 'map', metallicRoughness.baseColorTexture, sRGBEncoding));
       }
     }
 
     return Promise.all(pending);
   }
 
+}
+/**
+ * Materials Emissive Strength Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/blob/5768b3ce0ef32bc39cdf1bef10b948586635ead3/extensions/2.0/Khronos/KHR_materials_emissive_strength/README.md
+ */
+
+
+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();
+  }
+
 }
 /**
  * Clearcoat Materials Extension
@@ -458,6 +497,69 @@ class GLTFMaterialsClearcoatExtension {
     return Promise.all(pending);
   }
 
+}
+/**
+ * Iridescence Materials Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_iridescence
+ */
+
+
+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);
+  }
+
 }
 /**
  * Sheen Materials Extension
@@ -502,7 +604,7 @@ class GLTFMaterialsSheenExtension {
     }
 
     if (extension.sheenColorTexture !== undefined) {
-      pending.push(parser.assignTexture(materialParams, 'sheenColorMap', extension.sheenColorTexture));
+      pending.push(parser.assignTexture(materialParams, 'sheenColorMap', extension.sheenColorTexture, sRGBEncoding));
     }
 
     if (extension.sheenRoughnessTexture !== undefined) {
@@ -674,9 +776,7 @@ class GLTFMaterialsSpecularExtension {
     materialParams.specularColor = new Color(colorArray[0], colorArray[1], colorArray[2]);
 
     if (extension.specularColorTexture !== undefined) {
-      pending.push(parser.assignTexture(materialParams, 'specularColorMap', extension.specularColorTexture).then(function (texture) {
-        texture.encoding = sRGBEncoding;
-      }));
+      pending.push(parser.assignTexture(materialParams, 'specularColorMap', extension.specularColorTexture, sRGBEncoding));
     }
 
     return Promise.all(pending);
@@ -706,7 +806,6 @@ class GLTFTextureBasisUExtension {
     }
 
     const extension = textureDef.extensions[this.name];
-    const source = json.images[extension.source];
     const loader = parser.options.ktx2Loader;
 
     if (!loader) {
@@ -718,7 +817,7 @@ class GLTFTextureBasisUExtension {
       }
     }
 
-    return parser.loadTextureImage(textureIndex, source, loader);
+    return parser.loadTextureImage(textureIndex, extension.source, loader);
   }
 
 }
@@ -756,7 +855,7 @@ class GLTFTextureWebPExtension {
     }
 
     return this.detectSupport().then(function (isSupported) {
-      if (isSupported) return parser.loadTextureImage(textureIndex, source, loader);
+      if (isSupported) return parser.loadTextureImage(textureIndex, extension.source, loader);
 
       if (json.extensionsRequired && json.extensionsRequired.indexOf(name) >= 0) {
         throw new Error('THREE.GLTFLoader: WebP required by asset but unsupported.');
@@ -816,15 +915,25 @@ class GLTFMeshoptCompression {
         }
       }
 
-      return Promise.all([buffer, decoder.ready]).then(function (res) {
+      return buffer.then(function (res) {
         const byteOffset = extensionDef.byteOffset || 0;
         const byteLength = extensionDef.byteLength || 0;
         const count = extensionDef.count;
         const stride = extensionDef.byteStride;
-        const result = new ArrayBuffer(count * stride);
-        const source = new Uint8Array(res[0], byteOffset, byteLength);
-        decoder.decodeGltfBuffer(new Uint8Array(result), count, stride, source, extensionDef.mode, extensionDef.filter);
-        return result;
+        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;
@@ -927,7 +1036,7 @@ class GLTFDracoMeshCompressionExtension {
       if (gltfAttributeMap[attributeName] !== undefined) {
         const accessorDef = json.accessors[primitive.attributes[attributeName]];
         const componentType = WEBGL_COMPONENT_TYPES[accessorDef.componentType];
-        attributeTypeMap[threeAttributeName] = componentType;
+        attributeTypeMap[threeAttributeName] = componentType.name;
         attributeNormalizedMap[threeAttributeName] = accessorDef.normalized === true;
       }
     }
@@ -1129,7 +1238,7 @@ class GLTFMaterialsPbrSpecularGlossinessExtension {
     }
 
     if (pbrSpecularGlossiness.diffuseTexture !== undefined) {
-      pending.push(parser.assignTexture(materialParams, 'map', pbrSpecularGlossiness.diffuseTexture));
+      pending.push(parser.assignTexture(materialParams, 'map', pbrSpecularGlossiness.diffuseTexture, sRGBEncoding));
     }
 
     materialParams.emissive = new Color(0.0, 0.0, 0.0);
@@ -1143,7 +1252,7 @@ class GLTFMaterialsPbrSpecularGlossinessExtension {
     if (pbrSpecularGlossiness.specularGlossinessTexture !== undefined) {
       const specGlossMapDef = pbrSpecularGlossiness.specularGlossinessTexture;
       pending.push(parser.assignTexture(materialParams, 'glossinessMap', specGlossMapDef));
-      pending.push(parser.assignTexture(materialParams, 'specularMap', specGlossMapDef));
+      pending.push(parser.assignTexture(materialParams, 'specularMap', specGlossMapDef, sRGBEncoding));
     }
 
     return Promise.all(pending);
@@ -1159,7 +1268,7 @@ class GLTFMaterialsPbrSpecularGlossinessExtension {
     material.aoMap = materialParams.aoMap === undefined ? null : materialParams.aoMap;
     material.aoMapIntensity = 1.0;
     material.emissive = materialParams.emissive;
-    material.emissiveIntensity = 1.0;
+    material.emissiveIntensity = materialParams.emissiveIntensity === undefined ? 1.0 : materialParams.emissiveIntensity;
     material.emissiveMap = materialParams.emissiveMap === undefined ? null : materialParams.emissiveMap;
     material.bumpMap = materialParams.bumpMap === undefined ? null : materialParams.bumpMap;
     material.bumpScale = 1;
@@ -1223,43 +1332,40 @@ class GLTFCubicSplineInterpolant extends Interpolant {
     return result;
   }
 
-}
-
-GLTFCubicSplineInterpolant.prototype.beforeStart_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
-GLTFCubicSplineInterpolant.prototype.afterEnd_ = GLTFCubicSplineInterpolant.prototype.copySampleValue_;
+  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, ... ]
 
-GLTFCubicSplineInterpolant.prototype.interpolate_ = function (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
 
-  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 m0 = values[offset0 + i + stride2] * td; // outTangent_k * (t_k+1 - t_k)
+      const p1 = values[offset1 + i + stride]; // splineVertex_k+1
 
-    const p1 = values[offset1 + i + stride]; // splineVertex_k+1
+      const m1 = values[offset1 + i] * td; // inTangent_k+1 * (t_k+1 - t_k)
 
-    const m1 = values[offset1 + i] * td; // inTangent_k+1 * (t_k+1 - t_k)
+      result[i] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
+    }
 
-    result[i] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
+    return result;
   }
 
-  return result;
-};
+}
 
 const _q = new Quaternion();
 
@@ -1418,17 +1524,20 @@ function assignExtrasToUserData(object, gltfDef) {
 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 (hasMorphPosition && hasMorphNormal) break;
+    if (target.COLOR_0 !== undefined) hasMorphColor = true;
+    if (hasMorphPosition && hasMorphNormal && hasMorphColor) break;
   }
 
-  if (!hasMorphPosition && !hasMorphNormal) return Promise.resolve(geometry);
+  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];
@@ -1442,13 +1551,20 @@ function addMorphTargets(geometry, targets, parser) {
       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)]).then(function (accessors) {
+  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;
   });
@@ -1528,6 +1644,12 @@ function getNormalizedComponentScale(constructor) {
       throw new Error('THREE.GLTFLoader: Unsupported normalized accessor component type.');
   }
 }
+
+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';
+  return 'image/png';
+}
 /* GLTF PARSER */
 
 
@@ -1556,15 +1678,20 @@ class GLTFParser {
       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.
 
-    if (typeof createImageBitmap !== 'undefined' && /Firefox|^((?!chrome|android).)*safari/i.test(navigator.userAgent) === false) {
-      this.textureLoader = new ImageBitmapLoader(this.options.manager);
-    } else {
+    const isSafari = typeof navigator !== 'undefined' && /^((?!chrome|android).)*safari/i.test(navigator.userAgent) === true;
+    const isFirefox = typeof navigator !== 'undefined' && navigator.userAgent.indexOf('Firefox') > -1;
+    const firefoxVersion = typeof navigator !== 'undefined' && isFirefox ? navigator.userAgent.match(/Firefox\/([0-9]+)\./)[1] : -1;
+
+    if (typeof createImageBitmap === 'undefined' || isSafari || isFirefox && firefoxVersion < 98) {
       this.textureLoader = new TextureLoader(this.options.manager);
+    } else {
+      this.textureLoader = new ImageBitmapLoader(this.options.manager);
     }
 
     this.textureLoader.setCrossOrigin(this.options.crossOrigin);
@@ -1787,7 +1914,9 @@ class GLTFParser {
           break;
 
         case 'animation':
-          dependency = this.loadAnimation(index);
+          dependency = this._invokeOne(function (ext) {
+            return ext.loadAnimation && ext.loadAnimation(index);
+          });
           break;
 
         case 'camera':
@@ -1973,45 +2102,76 @@ class GLTFParser {
     const json = this.json;
     const options = this.options;
     const textureDef = json.textures[textureIndex];
-    const source = json.images[textureDef.source];
+    const sourceIndex = textureDef.source;
+    const sourceDef = json.images[sourceIndex];
     let loader = this.textureLoader;
 
-    if (source.uri) {
-      const handler = options.manager.getHandler(source.uri);
+    if (sourceDef.uri) {
+      const handler = options.manager.getHandler(sourceDef.uri);
       if (handler !== null) loader = handler;
     }
 
-    return this.loadTextureImage(textureIndex, source, loader);
+    return this.loadTextureImage(textureIndex, sourceIndex, loader);
   }
 
-  loadTextureImage(textureIndex, source, loader) {
+  loadTextureImage(textureIndex, sourceIndex, loader) {
     const parser = this;
     const json = this.json;
-    const options = this.options;
     const textureDef = json.textures[textureIndex];
-    const cacheKey = (source.uri || source.bufferView) + ':' + textureDef.sampler;
+    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;
+      if (textureDef.name) texture.name = textureDef.name;
+      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;
+      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 = source.uri || '';
+    let sourceURI = sourceDef.uri || '';
     let isObjectURL = false;
 
-    if (source.bufferView !== undefined) {
+    if (sourceDef.bufferView !== undefined) {
       // Load binary image data from bufferView, if provided.
-      sourceURI = parser.getDependency('bufferView', source.bufferView).then(function (bufferView) {
+      sourceURI = parser.getDependency('bufferView', sourceDef.bufferView).then(function (bufferView) {
         isObjectURL = true;
         const blob = new Blob([bufferView], {
-          type: source.mimeType
+          type: sourceDef.mimeType
         });
         sourceURI = URL.createObjectURL(blob);
         return sourceURI;
       });
-    } else if (source.uri === undefined) {
-      throw new Error('THREE.GLTFLoader: Image ' + textureIndex + ' is missing URI and bufferView');
+    } 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) {
@@ -2034,23 +2194,13 @@ class GLTFParser {
         URL.revokeObjectURL(sourceURI);
       }
 
-      texture.flipY = false;
-      if (textureDef.name) texture.name = textureDef.name;
-      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;
-      parser.associations.set(texture, {
-        textures: textureIndex
-      });
+      texture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType(sourceDef.uri);
       return texture;
-    }).catch(function () {
+    }).catch(function (error) {
       console.error("THREE.GLTFLoader: Couldn't load texture", sourceURI);
-      return null;
+      throw error;
     });
-    this.textureCache[cacheKey] = promise;
+    this.sourceCache[sourceIndex] = promise;
     return promise;
   }
   /**
@@ -2062,7 +2212,7 @@ class GLTFParser {
    */
 
 
-  assignTexture(materialParams, mapName, mapDef) {
+  assignTexture(materialParams, mapName, mapDef, encoding) {
     const parser = this;
     return this.getDependency('texture', mapDef.index).then(function (texture) {
       // Materials sample aoMap from UV set 1 and other maps from UV set 0 - this can't be configured
@@ -2081,6 +2231,10 @@ class GLTFParser {
         }
       }
 
+      if (encoding !== undefined) {
+        texture.encoding = encoding;
+      }
+
       materialParams[mapName] = texture;
       return texture;
     });
@@ -2208,7 +2362,7 @@ class GLTFParser {
       }
 
       if (metallicRoughness.baseColorTexture !== undefined) {
-        pending.push(parser.assignTexture(materialParams, 'map', metallicRoughness.baseColorTexture));
+        pending.push(parser.assignTexture(materialParams, 'map', metallicRoughness.baseColorTexture, sRGBEncoding));
       }
 
       materialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0;
@@ -2268,7 +2422,7 @@ class GLTFParser {
     }
 
     if (materialDef.emissiveTexture !== undefined && materialType !== MeshBasicMaterial) {
-      pending.push(parser.assignTexture(materialParams, 'emissiveMap', materialDef.emissiveTexture));
+      pending.push(parser.assignTexture(materialParams, 'emissiveMap', materialDef.emissiveTexture, sRGBEncoding));
     }
 
     return Promise.all(pending).then(function () {
@@ -2280,10 +2434,7 @@ class GLTFParser {
         material = new materialType(materialParams);
       }
 
-      if (materialDef.name) material.name = materialDef.name; // baseColorTexture, emissiveTexture, and specularGlossinessTexture use sRGB encoding.
-
-      if (material.map) material.map.encoding = sRGBEncoding;
-      if (material.emissiveMap) material.emissiveMap.encoding = sRGBEncoding;
+      if (materialDef.name) material.name = materialDef.name;
       assignExtrasToUserData(material, materialDef);
       parser.associations.set(material, {
         materials: materialIndex
@@ -2523,8 +2674,7 @@ class GLTFParser {
       const channel = animationDef.channels[i];
       const sampler = animationDef.samplers[channel.sampler];
       const target = channel.target;
-      const name = target.node !== undefined ? target.node : target.id; // NOTE: target.id is deprecated.
-
+      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;
       pendingNodes.push(this.getDependency('node', name));
@@ -2550,7 +2700,6 @@ class GLTFParser {
         const target = targets[i];
         if (node === undefined) continue;
         node.updateMatrix();
-        node.matrixAutoUpdate = true;
         let TypedKeyframeTrack;
 
         switch (PATH_PROPERTIES[target.path]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "three-stdlib",
-  "version": "2.16.2",
+  "version": "2.17.1",
   "private": false,
   "description": "stand-alone library of threejs examples",
   "main": "index.cjs.js",