itowns 2.34.0 → 2.36.2

package/lib/ThreeExtended/loaders/GLTFLoader.js

@@ -7,6 +7,8 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.GLTFLoader = void 0;
 
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 
 var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
@@ -25,6 +27,12 @@ var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/ge
 
 var _three = require("three");
 
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function () { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
 
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
@@ -60,6 +68,18 @@ var GLTFLoader = /*#__PURE__*/function (_Loader) {
       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 GLTFMaterialsSpecularExtension(parser);
+    });
+
     _this.register(function (parser) {
       return new GLTFLightsExtension(parser);
     });
@@ -287,9 +307,12 @@ var EXTENSIONS = {
   KHR_DRACO_MESH_COMPRESSION: 'KHR_draco_mesh_compression',
   KHR_LIGHTS_PUNCTUAL: 'KHR_lights_punctual',
   KHR_MATERIALS_CLEARCOAT: 'KHR_materials_clearcoat',
+  KHR_MATERIALS_IOR: 'KHR_materials_ior',
   KHR_MATERIALS_PBR_SPECULAR_GLOSSINESS: 'KHR_materials_pbrSpecularGlossiness',
+  KHR_MATERIALS_SPECULAR: 'KHR_materials_specular',
   KHR_MATERIALS_TRANSMISSION: 'KHR_materials_transmission',
   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',
@@ -498,9 +521,8 @@ var GLTFMaterialsClearcoatExtension = /*#__PURE__*/function () {
         pending.push(parser.assignTexture(materialParams, 'clearcoatNormalMap', extension.clearcoatNormalTexture));
 
         if (extension.clearcoatNormalTexture.scale !== undefined) {
-          var scale = extension.clearcoatNormalTexture.scale; // https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
-
-          materialParams.clearcoatNormalScale = new _three.Vector2(scale, -scale);
+          var scale = extension.clearcoatNormalTexture.scale;
+          materialParams.clearcoatNormalScale = new _three.Vector2(scale, scale);
         }
       }
 
@@ -558,6 +580,147 @@ var GLTFMaterialsTransmissionExtension = /*#__PURE__*/function () {
   }]);
   return GLTFMaterialsTransmissionExtension;
 }();
+/**
+ * Materials Volume Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_volume
+ */
+
+
+var GLTFMaterialsVolumeExtension = /*#__PURE__*/function () {
+  function GLTFMaterialsVolumeExtension(parser) {
+    (0, _classCallCheck2["default"])(this, GLTFMaterialsVolumeExtension);
+    this.parser = parser;
+    this.name = EXTENSIONS.KHR_MATERIALS_VOLUME;
+  }
+
+  (0, _createClass2["default"])(GLTFMaterialsVolumeExtension, [{
+    key: "getMaterialType",
+    value: function getMaterialType(materialIndex) {
+      var parser = this.parser;
+      var materialDef = parser.json.materials[materialIndex];
+      if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
+      return _three.MeshPhysicalMaterial;
+    }
+  }, {
+    key: "extendMaterialParams",
+    value: function extendMaterialParams(materialIndex, materialParams) {
+      var parser = this.parser;
+      var materialDef = parser.json.materials[materialIndex];
+
+      if (!materialDef.extensions || !materialDef.extensions[this.name]) {
+        return Promise.resolve();
+      }
+
+      var pending = [];
+      var 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 || 0;
+      var colorArray = extension.attenuationColor || [1, 1, 1];
+      materialParams.attenuationTint = new _three.Color(colorArray[0], colorArray[1], colorArray[2]);
+      return Promise.all(pending);
+    }
+  }]);
+  return GLTFMaterialsVolumeExtension;
+}();
+/**
+ * Materials ior Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_ior
+ */
+
+
+var GLTFMaterialsIorExtension = /*#__PURE__*/function () {
+  function GLTFMaterialsIorExtension(parser) {
+    (0, _classCallCheck2["default"])(this, GLTFMaterialsIorExtension);
+    this.parser = parser;
+    this.name = EXTENSIONS.KHR_MATERIALS_IOR;
+  }
+
+  (0, _createClass2["default"])(GLTFMaterialsIorExtension, [{
+    key: "getMaterialType",
+    value: function getMaterialType(materialIndex) {
+      var parser = this.parser;
+      var materialDef = parser.json.materials[materialIndex];
+      if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
+      return _three.MeshPhysicalMaterial;
+    }
+  }, {
+    key: "extendMaterialParams",
+    value: function extendMaterialParams(materialIndex, materialParams) {
+      var parser = this.parser;
+      var materialDef = parser.json.materials[materialIndex];
+
+      if (!materialDef.extensions || !materialDef.extensions[this.name]) {
+        return Promise.resolve();
+      }
+
+      var extension = materialDef.extensions[this.name];
+      materialParams.ior = extension.ior !== undefined ? extension.ior : 1.5;
+      return Promise.resolve();
+    }
+  }]);
+  return GLTFMaterialsIorExtension;
+}();
+/**
+ * Materials specular Extension
+ *
+ * Specification: https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_specular
+ */
+
+
+var GLTFMaterialsSpecularExtension = /*#__PURE__*/function () {
+  function GLTFMaterialsSpecularExtension(parser) {
+    (0, _classCallCheck2["default"])(this, GLTFMaterialsSpecularExtension);
+    this.parser = parser;
+    this.name = EXTENSIONS.KHR_MATERIALS_SPECULAR;
+  }
+
+  (0, _createClass2["default"])(GLTFMaterialsSpecularExtension, [{
+    key: "getMaterialType",
+    value: function getMaterialType(materialIndex) {
+      var parser = this.parser;
+      var materialDef = parser.json.materials[materialIndex];
+      if (!materialDef.extensions || !materialDef.extensions[this.name]) return null;
+      return _three.MeshPhysicalMaterial;
+    }
+  }, {
+    key: "extendMaterialParams",
+    value: function extendMaterialParams(materialIndex, materialParams) {
+      var parser = this.parser;
+      var materialDef = parser.json.materials[materialIndex];
+
+      if (!materialDef.extensions || !materialDef.extensions[this.name]) {
+        return Promise.resolve();
+      }
+
+      var pending = [];
+      var 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));
+      }
+
+      var colorArray = extension.specularColorFactor || [1, 1, 1];
+      materialParams.specularTint = new _three.Color(colorArray[0], colorArray[1], colorArray[2]);
+
+      if (extension.specularColorTexture !== undefined) {
+        pending.push(parser.assignTexture(materialParams, 'specularTintMap', extension.specularColorTexture).then(function (texture) {
+          texture.encoding = _three.sRGBEncoding;
+        }));
+      }
+
+      return Promise.all(pending);
+    }
+  }]);
+  return GLTFMaterialsSpecularExtension;
+}();
 /**
  * BasisU Texture Extension
  *
@@ -913,7 +1076,7 @@ var GLTFMeshStandardSGMaterial = /*#__PURE__*/function (_MeshStandardMaterial) {
     var glossinessMapParsFragmentChunk = ['#ifdef USE_GLOSSINESSMAP', '	uniform sampler2D glossinessMap;', '#endif'].join('\n');
     var 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');
     var 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');
-    var 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 );', 'material.specularRoughness = max( 1.0 - glossinessFactor, 0.0525 ); // 0.0525 corresponds to the base mip of a 256 cubemap.', 'material.specularRoughness += geometryRoughness;', 'material.specularRoughness = min( material.specularRoughness, 1.0 );', 'material.specularColor = specularFactor;'].join('\n');
+    var 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 );', 'material.roughness = max( 1.0 - glossinessFactor, 0.0525 ); // 0.0525 corresponds to the base mip of a 256 cubemap.', 'material.roughness += geometryRoughness;', 'material.roughness = min( material.roughness, 1.0 );', 'material.specularColor = specularFactor;'].join('\n');
     var uniforms = {
       specular: {
         value: new _three.Color().setHex(0xffffff)
@@ -1177,6 +1340,31 @@ GLTFCubicSplineInterpolant.prototype.interpolate_ = function (i1, t0, t, t1) {
 
   return result;
 };
+
+var _q = new _three.Quaternion();
+
+var GLTFCubicSplineQuaternionInterpolant = /*#__PURE__*/function (_GLTFCubicSplineInter) {
+  (0, _inherits2["default"])(GLTFCubicSplineQuaternionInterpolant, _GLTFCubicSplineInter);
+
+  var _super4 = _createSuper(GLTFCubicSplineQuaternionInterpolant);
+
+  function GLTFCubicSplineQuaternionInterpolant() {
+    (0, _classCallCheck2["default"])(this, GLTFCubicSplineQuaternionInterpolant);
+    return _super4.apply(this, arguments);
+  }
+
+  (0, _createClass2["default"])(GLTFCubicSplineQuaternionInterpolant, [{
+    key: "interpolate_",
+    value: function interpolate_(i1, t0, t, t1) {
+      var result = (0, _get2["default"])((0, _getPrototypeOf2["default"])(GLTFCubicSplineQuaternionInterpolant.prototype), "interpolate_", this).call(this, i1, t0, t, t1);
+
+      _q.fromArray(result).normalize().toArray(result);
+
+      return result;
+    }
+  }]);
+  return GLTFCubicSplineQuaternionInterpolant;
+}(GLTFCubicSplineInterpolant);
 /*********************************/
 
 /********** INTERNALS ************/
@@ -1619,8 +1807,38 @@ var GLTFParser = /*#__PURE__*/function () {
   }, {
     key: "_getNodeRef",
     value: function _getNodeRef(cache, index, object) {
+      var _this3 = this;
+
       if (cache.refs[index] <= 1) return object;
-      var ref = object.clone();
+      var ref = object.clone(); // Propagates mappings to the cloned object, prevents mappings on the
+      // original object from being lost.
+
+      var updateMappings = function (original, clone) {
+        var mappings = _this3.associations.get(original);
+
+        if (mappings != null) {
+          _this3.associations.set(clone, mappings);
+        }
+
+        var _iterator = _createForOfIteratorHelper(original.children.entries()),
+            _step;
+
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var _step$value = (0, _slicedToArray2["default"])(_step.value, 2),
+                i = _step$value[0],
+                child = _step$value[1];
+
+            updateMappings(child, clone.children[i]);
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      };
+
+      updateMappings(object, ref);
       ref.name += '_instance_' + cache.uses[index]++;
       return ref;
     }
@@ -1928,24 +2146,10 @@ var GLTFParser = /*#__PURE__*/function () {
       var URL = self.URL || self.webkitURL;
       var sourceURI = source.uri || '';
       var isObjectURL = false;
-      var hasAlpha = true;
-      var isJPEG = sourceURI.search(/\.jpe?g($|\?)/i) > 0 || sourceURI.search(/^data\:image\/jpeg/) === 0;
-      if (source.mimeType === 'image/jpeg' || isJPEG) hasAlpha = false;
 
       if (source.bufferView !== undefined) {
         // Load binary image data from bufferView, if provided.
         sourceURI = parser.getDependency('bufferView', source.bufferView).then(function (bufferView) {
-          if (source.mimeType === 'image/png') {
-            // Inspect the PNG 'IHDR' chunk to determine whether the image could have an
-            // alpha channel. This check is conservative — the image could have an alpha
-            // channel with all values == 1, and the indexed type (colorType == 3) only
-            // sometimes contains alpha.
-            //
-            // https://en.wikipedia.org/wiki/Portable_Network_Graphics#File_header
-            var colorType = new DataView(bufferView, 25, 1).getUint8(0, false);
-            hasAlpha = colorType === 6 || colorType === 4 || colorType === 3;
-          }
-
           isObjectURL = true;
           var blob = new Blob([bufferView], {
             type: source.mimeType
@@ -1963,7 +2167,9 @@ var GLTFParser = /*#__PURE__*/function () {
 
           if (loader.isImageBitmapLoader === true) {
             onLoad = function (imageBitmap) {
-              resolve(new _three.CanvasTexture(imageBitmap));
+              var texture = new _three.Texture(imageBitmap);
+              texture.needsUpdate = true;
+              resolve(texture);
             };
           }
 
@@ -1976,9 +2182,7 @@ var GLTFParser = /*#__PURE__*/function () {
         }
 
         texture.flipY = false;
-        if (textureDef.name) texture.name = textureDef.name; // When there is definitely no alpha channel in the texture, set RGBFormat to save space.
-
-        if (!hasAlpha) texture.format = _three.RGBFormat;
+        if (textureDef.name) texture.name = textureDef.name;
         var samplers = json.samplers || {};
         var sampler = samplers[textureDef.sampler] || {};
         texture.magFilter = WEBGL_FILTERS[sampler.magFilter] || _three.LinearFilter;
@@ -1986,10 +2190,12 @@ var GLTFParser = /*#__PURE__*/function () {
         texture.wrapS = WEBGL_WRAPPINGS[sampler.wrapS] || _three.RepeatWrapping;
         texture.wrapT = WEBGL_WRAPPINGS[sampler.wrapT] || _three.RepeatWrapping;
         parser.associations.set(texture, {
-          type: 'textures',
-          index: textureIndex
+          textures: textureIndex
         });
         return texture;
+      })["catch"](function () {
+        console.error('THREE.GLTFLoader: Couldn\'t load texture', sourceURI);
+        return null;
       });
       this.textureCache[cacheKey] = promise;
       return promise;
@@ -1999,7 +2205,7 @@ var GLTFParser = /*#__PURE__*/function () {
      * @param {Object} materialParams
      * @param {string} mapName
      * @param {Object} mapDef
-     * @return {Promise}
+     * @return {Promise<Texture>}
      */
 
   }, {
@@ -2024,6 +2230,7 @@ var GLTFParser = /*#__PURE__*/function () {
         }
 
         materialParams[mapName] = texture;
+        return texture;
       });
     }
     /**
@@ -2040,11 +2247,9 @@ var GLTFParser = /*#__PURE__*/function () {
     value: function assignFinalMaterial(mesh) {
       var geometry = mesh.geometry;
       var material = mesh.material;
-      var useVertexTangents = geometry.attributes.tangent !== undefined;
+      var useDerivativeTangents = geometry.attributes.tangent === undefined;
       var useVertexColors = geometry.attributes.color !== undefined;
       var useFlatShading = geometry.attributes.normal === undefined;
-      var useMorphTargets = Object.keys(geometry.morphAttributes).length > 0;
-      var useMorphNormals = useMorphTargets && geometry.morphAttributes.normal !== undefined;
 
       if (mesh.isPoints) {
         var cacheKey = 'PointsMaterial:' + material.uuid;
@@ -2081,27 +2286,22 @@ var GLTFParser = /*#__PURE__*/function () {
       } // Clone the material if it will be modified
 
 
-      if (useVertexTangents || useVertexColors || useFlatShading || useMorphTargets) {
+      if (useDerivativeTangents || useVertexColors || useFlatShading) {
         var _cacheKey2 = 'ClonedMaterial:' + material.uuid + ':';
 
         if (material.isGLTFSpecularGlossinessMaterial) _cacheKey2 += 'specular-glossiness:';
-        if (useVertexTangents) _cacheKey2 += 'vertex-tangents:';
+        if (useDerivativeTangents) _cacheKey2 += 'derivative-tangents:';
         if (useVertexColors) _cacheKey2 += 'vertex-colors:';
         if (useFlatShading) _cacheKey2 += 'flat-shading:';
-        if (useMorphTargets) _cacheKey2 += 'morph-targets:';
-        if (useMorphNormals) _cacheKey2 += 'morph-normals:';
         var cachedMaterial = this.cache.get(_cacheKey2);
 
         if (!cachedMaterial) {
           cachedMaterial = material.clone();
           if (useVertexColors) cachedMaterial.vertexColors = true;
           if (useFlatShading) cachedMaterial.flatShading = true;
-          if (useMorphTargets) cachedMaterial.morphTargets = true;
-          if (useMorphNormals) cachedMaterial.morphNormals = true;
-
-          if (useVertexTangents) {
-            cachedMaterial.vertexTangents = true; // https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
 
+          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;
           }
@@ -2122,9 +2322,7 @@ var GLTFParser = /*#__PURE__*/function () {
     }
   }, {
     key: "getMaterialType",
-    value: function getMaterialType()
-    /* materialIndex */
-    {
+    value: function getMaterialType() {
       return _three.MeshStandardMaterial;
     }
     /**
@@ -2197,6 +2395,7 @@ var GLTFParser = /*#__PURE__*/function () {
 
         materialParams.depthWrite = false;
       } else {
+        materialParams.format = _three.RGBFormat;
         materialParams.transparent = false;
 
         if (alphaMode === ALPHA_MODES.MASK) {
@@ -2205,12 +2404,12 @@ var GLTFParser = /*#__PURE__*/function () {
       }
 
       if (materialDef.normalTexture !== undefined && materialType !== _three.MeshBasicMaterial) {
-        pending.push(parser.assignTexture(materialParams, 'normalMap', materialDef.normalTexture)); // https://github.com/mrdoob/three.js/issues/11438#issuecomment-507003995
-
-        materialParams.normalScale = new _three.Vector2(1, -1);
+        pending.push(parser.assignTexture(materialParams, 'normalMap', materialDef.normalTexture));
+        materialParams.normalScale = new _three.Vector2(1, 1);
 
         if (materialDef.normalTexture.scale !== undefined) {
-          materialParams.normalScale.set(materialDef.normalTexture.scale, -materialDef.normalTexture.scale);
+          var scale = materialDef.normalTexture.scale;
+          materialParams.normalScale.set(scale, scale);
         }
       }
 
@@ -2245,8 +2444,7 @@ var GLTFParser = /*#__PURE__*/function () {
         if (material.emissiveMap) material.emissiveMap.encoding = _three.sRGBEncoding;
         assignExtrasToUserData(material, materialDef);
         parser.associations.set(material, {
-          type: 'materials',
-          index: materialIndex
+          materials: materialIndex
         });
         if (materialDef.extensions) addUnknownExtensionsToUserData(extensions, material, materialDef);
         return material;
@@ -2395,14 +2593,24 @@ var GLTFParser = /*#__PURE__*/function () {
           meshes.push(mesh);
         }
 
+        for (var _i5 = 0, _il4 = meshes.length; _i5 < _il4; _i5++) {
+          parser.associations.set(meshes[_i5], {
+            meshes: meshIndex,
+            primitives: _i5
+          });
+        }
+
         if (meshes.length === 1) {
           return meshes[0];
         }
 
         var group = new _three.Group();
+        parser.associations.set(group, {
+          meshes: meshIndex
+        });
 
-        for (var _i5 = 0, _il4 = meshes.length; _i5 < _il4; _i5++) {
-          group.add(meshes[_i5]);
+        for (var _i6 = 0, _il5 = meshes.length; _i6 < _il5; _i6++) {
+          group.add(meshes[_i6]);
         }
 
         return group;
@@ -2499,12 +2707,12 @@ var GLTFParser = /*#__PURE__*/function () {
         var targets = dependencies[4];
         var tracks = [];
 
-        var _loop = function (_i6) {
-          var node = nodes[_i6];
-          var inputAccessor = inputAccessors[_i6];
-          var outputAccessor = outputAccessors[_i6];
-          var sampler = samplers[_i6];
-          var target = targets[_i6];
+        var _loop = function (_i7) {
+          var node = nodes[_i7];
+          var inputAccessor = inputAccessors[_i7];
+          var outputAccessor = outputAccessors[_i7];
+          var sampler = samplers[_i7];
+          var target = targets[_i7];
           if (node === undefined) return "continue";
           node.updateMatrix();
           node.matrixAutoUpdate = true;
@@ -2562,7 +2770,8 @@ var GLTFParser = /*#__PURE__*/function () {
                 // 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.
-                return new GLTFCubicSplineInterpolant(this.times, this.values, this.getValueSize() / 3, result);
+                var interpolantType = this instanceof _three.QuaternionKeyframeTrack ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant;
+                return new interpolantType(this.times, this.values, this.getValueSize() / 3, result);
               }; // Mark as CUBICSPLINE. `track.getInterpolation()` doesn't support custom interpolants.
 
 
@@ -2573,8 +2782,8 @@ var GLTFParser = /*#__PURE__*/function () {
           }
         };
 
-        for (var _i6 = 0, _il5 = nodes.length; _i6 < _il5; _i6++) {
-          var _ret = _loop(_i6, _il5);
+        for (var _i7 = 0, _il6 = nodes.length; _i7 < _il6; _i7++) {
+          var _ret = _loop(_i7, _il6);
 
           if (_ret === "continue") continue;
         }
@@ -2691,10 +2900,11 @@ var GLTFParser = /*#__PURE__*/function () {
           }
         }
 
-        parser.associations.set(node, {
-          type: 'nodes',
-          index: nodeIndex
-        });
+        if (!parser.associations.has(node)) {
+          parser.associations.set(node, {});
+        }
+
+        parser.associations.get(node).nodes = nodeIndex;
         return node;
       });
     }
@@ -2721,10 +2931,44 @@ var GLTFParser = /*#__PURE__*/function () {
       var pending = [];
 
       for (var i = 0, il = nodeIds.length; i < il; i++) {
-        pending.push(buildNodeHierachy(nodeIds[i], scene, json, parser));
+        pending.push(buildNodeHierarchy(nodeIds[i], scene, json, parser));
       }
 
       return Promise.all(pending).then(function () {
+        // Removes dangling associations, associations that reference a node that
+        // didn't make it into the scene.
+        parser.associations = function reduceAssociations(node) {
+          var reducedAssociations = new Map();
+
+          var _iterator2 = _createForOfIteratorHelper(parser.associations),
+              _step2;
+
+          try {
+            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+              var _step2$value = (0, _slicedToArray2["default"])(_step2.value, 2),
+                  key = _step2$value[0],
+                  value = _step2$value[1];
+
+              if (key instanceof _three.Material || key instanceof _three.Texture) {
+                reducedAssociations.set(key, value);
+              }
+            }
+          } catch (err) {
+            _iterator2.e(err);
+          } finally {
+            _iterator2.f();
+          }
+
+          node.traverse(function (node) {
+            var mappings = parser.associations.get(node);
+
+            if (mappings != null) {
+              reducedAssociations.set(node, mappings);
+            }
+          });
+          return reducedAssociations;
+        }(scene);
+
         return scene;
       });
     }
@@ -2732,7 +2976,7 @@ var GLTFParser = /*#__PURE__*/function () {
   return GLTFParser;
 }();
 
-function buildNodeHierachy(nodeId, parentObject, json, parser) {
+function buildNodeHierarchy(nodeId, parentObject, json, parser) {
   var nodeDef = json.nodes[nodeId];
   return parser.getDependency('node', nodeId).then(function (node) {
     if (nodeDef.skin === undefined) return node; // build skeleton here as well
@@ -2784,7 +3028,7 @@ function buildNodeHierachy(nodeId, parentObject, json, parser) {
 
       for (var i = 0, il = children.length; i < il; i++) {
         var child = children[i];
-        pending.push(buildNodeHierachy(child, node, json, parser));
+        pending.push(buildNodeHierarchy(child, node, json, parser));
       }
     }
 
@@ -2941,22 +3185,22 @@ function toTrianglesDrawMode(geometry, drawMode) {
 
   if (drawMode === _three.TriangleFanDrawMode) {
     // gl.TRIANGLE_FAN
-    for (var _i7 = 1; _i7 <= numberOfTriangles; _i7++) {
+    for (var _i8 = 1; _i8 <= numberOfTriangles; _i8++) {
       newIndices.push(index.getX(0));
-      newIndices.push(index.getX(_i7));
-      newIndices.push(index.getX(_i7 + 1));
+      newIndices.push(index.getX(_i8));
+      newIndices.push(index.getX(_i8 + 1));
     }
   } else {
     // gl.TRIANGLE_STRIP
-    for (var _i8 = 0; _i8 < numberOfTriangles; _i8++) {
-      if (_i8 % 2 === 0) {
-        newIndices.push(index.getX(_i8));
-        newIndices.push(index.getX(_i8 + 1));
-        newIndices.push(index.getX(_i8 + 2));
+    for (var _i9 = 0; _i9 < numberOfTriangles; _i9++) {
+      if (_i9 % 2 === 0) {
+        newIndices.push(index.getX(_i9));
+        newIndices.push(index.getX(_i9 + 1));
+        newIndices.push(index.getX(_i9 + 2));
       } else {
-        newIndices.push(index.getX(_i8 + 2));
-        newIndices.push(index.getX(_i8 + 1));
-        newIndices.push(index.getX(_i8));
+        newIndices.push(index.getX(_i9 + 2));
+        newIndices.push(index.getX(_i9 + 1));
+        newIndices.push(index.getX(_i9));
       }
     }
   }