three-stdlib 2.29.12 → 2.30.0

package/loaders/GLTFLoader.cjs

@@ -3,6 +3,10 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
 const BufferGeometryUtils = require("../utils/BufferGeometryUtils.cjs");
 const constants = require("../_polyfill/constants.cjs");
+const SRGBColorSpace = "srgb";
+const LinearSRGBColorSpace = "srgb-linear";
+const sRGBEncoding = 3001;
+const LinearEncoding = 3e3;
 class GLTFLoader extends THREE.Loader {
   constructor(manager) {
     super(manager);
@@ -13,6 +17,9 @@ class GLTFLoader extends THREE.Loader {
     this.register(function(parser) {
       return new GLTFMaterialsClearcoatExtension(parser);
     });
+    this.register(function(parser) {
+      return new GLTFMaterialsDispersionExtension(parser);
+    });
     this.register(function(parser) {
       return new GLTFTextureBasisUExtension(parser);
     });
@@ -46,6 +53,9 @@ class GLTFLoader extends THREE.Loader {
     this.register(function(parser) {
       return new GLTFMaterialsAnisotropyExtension(parser);
     });
+    this.register(function(parser) {
+      return new GLTFMaterialsBumpExtension(parser);
+    });
     this.register(function(parser) {
       return new GLTFLightsExtension(parser);
     });
@@ -62,7 +72,8 @@ class GLTFLoader extends THREE.Loader {
     if (this.resourcePath !== "") {
       resourcePath = this.resourcePath;
     } else if (this.path !== "") {
-      resourcePath = this.path;
+      const relativeUrl = THREE.LoaderUtils.extractUrlBase(url);
+      resourcePath = THREE.LoaderUtils.resolveURL(relativeUrl, this.path);
     } else {
       resourcePath = THREE.LoaderUtils.extractUrlBase(url);
     }
@@ -168,6 +179,8 @@ class GLTFLoader extends THREE.Loader {
     parser.fileLoader.setRequestHeader(this.requestHeader);
     for (let i = 0; i < this.pluginCallbacks.length; i++) {
       const plugin = this.pluginCallbacks[i](parser);
+      if (!plugin.name)
+        console.error("THREE.GLTFLoader: Invalid plugin found: missing name");
       plugins[plugin.name] = plugin;
       extensions[plugin.name] = true;
     }
@@ -228,6 +241,7 @@ const EXTENSIONS = {
   KHR_DRACO_MESH_COMPRESSION: "KHR_draco_mesh_compression",
   KHR_LIGHTS_PUNCTUAL: "KHR_lights_punctual",
   KHR_MATERIALS_CLEARCOAT: "KHR_materials_clearcoat",
+  KHR_MATERIALS_DISPERSION: "KHR_materials_dispersion",
   KHR_MATERIALS_IOR: "KHR_materials_ior",
   KHR_MATERIALS_SHEEN: "KHR_materials_sheen",
   KHR_MATERIALS_SPECULAR: "KHR_materials_specular",
@@ -240,6 +254,7 @@ const EXTENSIONS = {
   KHR_TEXTURE_TRANSFORM: "KHR_texture_transform",
   KHR_MESH_QUANTIZATION: "KHR_mesh_quantization",
   KHR_MATERIALS_EMISSIVE_STRENGTH: "KHR_materials_emissive_strength",
+  EXT_MATERIALS_BUMP: "EXT_materials_bump",
   EXT_TEXTURE_WEBP: "EXT_texture_webp",
   EXT_TEXTURE_AVIF: "EXT_texture_avif",
   EXT_MESHOPT_COMPRESSION: "EXT_meshopt_compression",
@@ -274,7 +289,7 @@ class GLTFLightsExtension {
     let lightNode;
     const color = new THREE.Color(16777215);
     if (lightDef.color !== void 0)
-      color.fromArray(lightDef.color);
+      color.setRGB(lightDef.color[0], lightDef.color[1], lightDef.color[2], LinearSRGBColorSpace);
     const range = lightDef.range !== void 0 ? lightDef.range : 0;
     switch (lightDef.type) {
       case "directional":
@@ -344,11 +359,11 @@ class GLTFMaterialsUnlitExtension {
     if (metallicRoughness) {
       if (Array.isArray(metallicRoughness.baseColorFactor)) {
         const array = metallicRoughness.baseColorFactor;
-        materialParams.color.fromArray(array);
+        materialParams.color.setRGB(array[0], array[1], array[2], LinearSRGBColorSpace);
         materialParams.opacity = array[3];
       }
       if (metallicRoughness.baseColorTexture !== void 0) {
-        pending.push(parser.assignTexture(materialParams, "map", metallicRoughness.baseColorTexture, 3001));
+        pending.push(parser.assignTexture(materialParams, "map", metallicRoughness.baseColorTexture, SRGBColorSpace));
       }
     }
     return Promise.all(pending);
@@ -414,6 +429,29 @@ class GLTFMaterialsClearcoatExtension {
     return Promise.all(pending);
   }
 }
+class GLTFMaterialsDispersionExtension {
+  constructor(parser) {
+    this.parser = parser;
+    this.name = EXTENSIONS.KHR_MATERIALS_DISPERSION;
+  }
+  getMaterialType(materialIndex) {
+    const parser = this.parser;
+    const materialDef = parser.json.materials[materialIndex];
+    if (!materialDef.extensions || !materialDef.extensions[this.name])
+      return null;
+    return THREE.MeshPhysicalMaterial;
+  }
+  extendMaterialParams(materialIndex, materialParams) {
+    const parser = this.parser;
+    const materialDef = parser.json.materials[materialIndex];
+    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
+      return Promise.resolve();
+    }
+    const extension = materialDef.extensions[this.name];
+    materialParams.dispersion = extension.dispersion !== void 0 ? extension.dispersion : 0;
+    return Promise.resolve();
+  }
+}
 class GLTFMaterialsIridescenceExtension {
   constructor(parser) {
     this.parser = parser;
@@ -484,13 +522,14 @@ class GLTFMaterialsSheenExtension {
     materialParams.sheen = 1;
     const extension = materialDef.extensions[this.name];
     if (extension.sheenColorFactor !== void 0) {
-      materialParams.sheenColor.fromArray(extension.sheenColorFactor);
+      const colorFactor = extension.sheenColorFactor;
+      materialParams.sheenColor.setRGB(colorFactor[0], colorFactor[1], colorFactor[2], LinearSRGBColorSpace);
     }
     if (extension.sheenRoughnessFactor !== void 0) {
       materialParams.sheenRoughness = extension.sheenRoughnessFactor;
     }
     if (extension.sheenColorTexture !== void 0) {
-      pending.push(parser.assignTexture(materialParams, "sheenColorMap", extension.sheenColorTexture, 3001));
+      pending.push(parser.assignTexture(materialParams, "sheenColorMap", extension.sheenColorTexture, SRGBColorSpace));
     }
     if (extension.sheenRoughnessTexture !== void 0) {
       pending.push(parser.assignTexture(materialParams, "sheenRoughnessMap", extension.sheenRoughnessTexture));
@@ -553,7 +592,12 @@ class GLTFMaterialsVolumeExtension {
     }
     materialParams.attenuationDistance = extension.attenuationDistance || Infinity;
     const colorArray = extension.attenuationColor || [1, 1, 1];
-    materialParams.attenuationColor = new THREE.Color(colorArray[0], colorArray[1], colorArray[2]);
+    materialParams.attenuationColor = new THREE.Color().setRGB(
+      colorArray[0],
+      colorArray[1],
+      colorArray[2],
+      LinearSRGBColorSpace
+    );
     return Promise.all(pending);
   }
 }
@@ -605,16 +649,42 @@ class GLTFMaterialsSpecularExtension {
       pending.push(parser.assignTexture(materialParams, "specularIntensityMap", extension.specularTexture));
     }
     const colorArray = extension.specularColorFactor || [1, 1, 1];
-    materialParams.specularColor = new THREE.Color(colorArray[0], colorArray[1], colorArray[2]);
+    materialParams.specularColor = new THREE.Color().setRGB(colorArray[0], colorArray[1], colorArray[2], LinearSRGBColorSpace);
     if (extension.specularColorTexture !== void 0) {
       pending.push(
-        parser.assignTexture(materialParams, "specularColorMap", extension.specularColorTexture, 3001)
-        // sRGBEncoding
+        parser.assignTexture(materialParams, "specularColorMap", extension.specularColorTexture, SRGBColorSpace)
       );
     }
     return Promise.all(pending);
   }
 }
+class GLTFMaterialsBumpExtension {
+  constructor(parser) {
+    this.parser = parser;
+    this.name = EXTENSIONS.EXT_MATERIALS_BUMP;
+  }
+  getMaterialType(materialIndex) {
+    const parser = this.parser;
+    const materialDef = parser.json.materials[materialIndex];
+    if (!materialDef.extensions || !materialDef.extensions[this.name])
+      return null;
+    return THREE.MeshPhysicalMaterial;
+  }
+  extendMaterialParams(materialIndex, materialParams) {
+    const parser = this.parser;
+    const materialDef = parser.json.materials[materialIndex];
+    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
+      return Promise.resolve();
+    }
+    const pending = [];
+    const extension = materialDef.extensions[this.name];
+    materialParams.bumpScale = extension.bumpFactor !== void 0 ? extension.bumpFactor : 1;
+    if (extension.bumpTexture !== void 0) {
+      pending.push(parser.assignTexture(materialParams, "bumpMap", extension.bumpTexture));
+    }
+    return Promise.all(pending);
+  }
+}
 class GLTFMaterialsAnisotropyExtension {
   constructor(parser) {
     this.parser = parser;
@@ -865,7 +935,10 @@ class GLTFMeshGpuInstancing {
           instancedMesh.setMatrixAt(i, m.compose(p, q, s));
         }
         for (const attributeName in attributes) {
-          if (attributeName !== "TRANSLATION" && attributeName !== "ROTATION" && attributeName !== "SCALE") {
+          if (attributeName === "_COLOR_0") {
+            const attr = attributes[attributeName];
+            instancedMesh.instanceColor = new THREE.InstancedBufferAttribute(attr.array, attr.itemSize, attr.normalized);
+          } else if (attributeName !== "TRANSLATION" && attributeName !== "ROTATION" && attributeName !== "SCALE") {
             mesh.geometry.setAttribute(attributeName, attributes[attributeName]);
           }
         }
@@ -955,7 +1028,7 @@ class GLTFDracoMeshCompressionExtension {
       }
     }
     return parser.getDependency("bufferView", bufferViewIndex).then(function(bufferView) {
-      return new Promise(function(resolve) {
+      return new Promise(function(resolve, reject) {
         dracoLoader.decodeDracoFile(
           bufferView,
           function(geometry) {
@@ -968,7 +1041,9 @@ class GLTFDracoMeshCompressionExtension {
             resolve(geometry);
           },
           threeAttributeMap,
-          attributeTypeMap
+          attributeTypeMap,
+          LinearSRGBColorSpace,
+          reject
         );
       });
     });
@@ -1360,11 +1435,14 @@ class GLTFParser {
       };
       addUnknownExtensionsToUserData(extensions, result, json);
       assignExtrasToUserData(result, json);
-      Promise.all(
+      return Promise.all(
         parser._invokeAll(function(ext) {
           return ext.afterRoot && ext.afterRoot(result);
         })
       ).then(function() {
+        for (const scene of result.scenes) {
+          scene.updateMatrixWorld();
+        }
         onLoad(result);
       });
     }).catch(onError);
@@ -1751,6 +1829,7 @@ class GLTFParser {
       if (isObjectURL === true) {
         URL.revokeObjectURL(sourceURI);
       }
+      assignExtrasToUserData(texture, sourceDef);
       texture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType(sourceDef.uri);
       return texture;
     }).catch(function(error) {
@@ -1767,7 +1846,7 @@ class GLTFParser {
    * @param {Object} mapDef
    * @return {Promise<Texture>}
    */
-  assignTexture(materialParams, mapName, mapDef, encoding) {
+  assignTexture(materialParams, mapName, mapDef, colorSpace) {
     const parser = this;
     return this.getDependency("texture", mapDef.index).then(function(texture) {
       if (!texture)
@@ -1784,11 +1863,13 @@ class GLTFParser {
           parser.associations.set(texture, gltfReference);
         }
       }
-      if (encoding !== void 0) {
+      if (colorSpace !== void 0) {
+        if (typeof colorSpace === "number")
+          colorSpace = colorSpace === sRGBEncoding ? SRGBColorSpace : LinearSRGBColorSpace;
         if ("colorSpace" in texture)
-          texture.colorSpace = encoding === 3001 ? "srgb" : "srgb-linear";
+          texture.colorSpace = colorSpace;
         else
-          texture.encoding = encoding;
+          texture.encoding = colorSpace === SRGBColorSpace ? sRGBEncoding : LinearEncoding;
       }
       materialParams[mapName] = texture;
       return texture;
@@ -1887,11 +1968,11 @@ class GLTFParser {
       materialParams.opacity = 1;
       if (Array.isArray(metallicRoughness.baseColorFactor)) {
         const array = metallicRoughness.baseColorFactor;
-        materialParams.color.fromArray(array);
+        materialParams.color.setRGB(array[0], array[1], array[2], LinearSRGBColorSpace);
         materialParams.opacity = array[3];
       }
       if (metallicRoughness.baseColorTexture !== void 0) {
-        pending.push(parser.assignTexture(materialParams, "map", metallicRoughness.baseColorTexture, 3001));
+        pending.push(parser.assignTexture(materialParams, "map", metallicRoughness.baseColorTexture, SRGBColorSpace));
       }
       materialParams.metalness = metallicRoughness.metallicFactor !== void 0 ? metallicRoughness.metallicFactor : 1;
       materialParams.roughness = metallicRoughness.roughnessFactor !== void 0 ? metallicRoughness.roughnessFactor : 1;
@@ -1938,10 +2019,16 @@ class GLTFParser {
       }
     }
     if (materialDef.emissiveFactor !== void 0 && materialType !== THREE.MeshBasicMaterial) {
-      materialParams.emissive = new THREE.Color().fromArray(materialDef.emissiveFactor);
+      const emissiveFactor = materialDef.emissiveFactor;
+      materialParams.emissive = new THREE.Color().setRGB(
+        emissiveFactor[0],
+        emissiveFactor[1],
+        emissiveFactor[2],
+        LinearSRGBColorSpace
+      );
     }
     if (materialDef.emissiveTexture !== void 0 && materialType !== THREE.MeshBasicMaterial) {
-      pending.push(parser.assignTexture(materialParams, "emissiveMap", materialDef.emissiveTexture, 3001));
+      pending.push(parser.assignTexture(materialParams, "emissiveMap", materialDef.emissiveTexture, SRGBColorSpace));
     }
     return Promise.all(pending).then(function() {
       const material = new materialType(materialParams);
@@ -2151,6 +2238,7 @@ class GLTFParser {
    */
   loadAnimation(animationIndex) {
     const json = this.json;
+    const parser = this;
     const animationDef = json.animations[animationIndex];
     const animationName = animationDef.name ? animationDef.name : "animation_" + animationIndex;
     const pendingNodes = [];
@@ -2194,57 +2282,14 @@ class GLTFParser {
         const target = targets[i];
         if (node === void 0)
           continue;
-        node.updateMatrix();
-        let TypedKeyframeTrack;
-        switch (PATH_PROPERTIES[target.path]) {
-          case PATH_PROPERTIES.weights:
-            TypedKeyframeTrack = THREE.NumberKeyframeTrack;
-            break;
-          case PATH_PROPERTIES.rotation:
-            TypedKeyframeTrack = THREE.QuaternionKeyframeTrack;
-            break;
-          case PATH_PROPERTIES.position:
-          case PATH_PROPERTIES.scale:
-          default:
-            TypedKeyframeTrack = THREE.VectorKeyframeTrack;
-            break;
-        }
-        const targetName = node.name ? node.name : node.uuid;
-        const interpolation = sampler.interpolation !== void 0 ? INTERPOLATION[sampler.interpolation] : THREE.InterpolateLinear;
-        const targetNames = [];
-        if (PATH_PROPERTIES[target.path] === PATH_PROPERTIES.weights) {
-          node.traverse(function(object) {
-            if (object.morphTargetInfluences) {
-              targetNames.push(object.name ? object.name : object.uuid);
-            }
-          });
-        } else {
-          targetNames.push(targetName);
+        if (node.updateMatrix) {
+          node.updateMatrix();
         }
-        let outputArray = outputAccessor.array;
-        if (outputAccessor.normalized) {
-          const scale = getNormalizedComponentScale(outputArray.constructor);
-          const scaled = new Float32Array(outputArray.length);
-          for (let j = 0, jl = outputArray.length; j < jl; j++) {
-            scaled[j] = outputArray[j] * scale;
+        const createdTracks = parser._createAnimationTracks(node, inputAccessor, outputAccessor, sampler, target);
+        if (createdTracks) {
+          for (let k = 0; k < createdTracks.length; k++) {
+            tracks.push(createdTracks[k]);
           }
-          outputArray = scaled;
-        }
-        for (let j = 0, jl = targetNames.length; j < jl; j++) {
-          const track = new TypedKeyframeTrack(
-            targetNames[j] + "." + PATH_PROPERTIES[target.path],
-            inputAccessor.array,
-            outputArray,
-            interpolation
-          );
-          if (sampler.interpolation === "CUBICSPLINE") {
-            track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline(result) {
-              const interpolantType = this instanceof THREE.QuaternionKeyframeTrack ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant;
-              return new interpolantType(this.times, this.values, this.getValueSize() / 3, result);
-            };
-            track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
-          }
-          tracks.push(track);
         }
       }
       return new THREE.AnimationClip(animationName, void 0, tracks);
@@ -2422,6 +2467,79 @@ class GLTFParser {
       return scene;
     });
   }
+  _createAnimationTracks(node, inputAccessor, outputAccessor, sampler, target) {
+    const tracks = [];
+    const targetName = node.name ? node.name : node.uuid;
+    const targetNames = [];
+    if (PATH_PROPERTIES[target.path] === PATH_PROPERTIES.weights) {
+      node.traverse(function(object) {
+        if (object.morphTargetInfluences) {
+          targetNames.push(object.name ? object.name : object.uuid);
+        }
+      });
+    } else {
+      targetNames.push(targetName);
+    }
+    let TypedKeyframeTrack;
+    switch (PATH_PROPERTIES[target.path]) {
+      case PATH_PROPERTIES.weights:
+        TypedKeyframeTrack = THREE.NumberKeyframeTrack;
+        break;
+      case PATH_PROPERTIES.rotation:
+        TypedKeyframeTrack = THREE.QuaternionKeyframeTrack;
+        break;
+      case PATH_PROPERTIES.position:
+      case PATH_PROPERTIES.scale:
+        TypedKeyframeTrack = THREE.VectorKeyframeTrack;
+        break;
+      default:
+        switch (outputAccessor.itemSize) {
+          case 1:
+            TypedKeyframeTrack = THREE.NumberKeyframeTrack;
+            break;
+          case 2:
+          case 3:
+          default:
+            TypedKeyframeTrack = THREE.VectorKeyframeTrack;
+            break;
+        }
+        break;
+    }
+    const interpolation = sampler.interpolation !== void 0 ? INTERPOLATION[sampler.interpolation] : THREE.InterpolateLinear;
+    const outputArray = this._getArrayFromAccessor(outputAccessor);
+    for (let j = 0, jl = targetNames.length; j < jl; j++) {
+      const track = new TypedKeyframeTrack(
+        targetNames[j] + "." + PATH_PROPERTIES[target.path],
+        inputAccessor.array,
+        outputArray,
+        interpolation
+      );
+      if (sampler.interpolation === "CUBICSPLINE") {
+        this._createCubicSplineTrackInterpolant(track);
+      }
+      tracks.push(track);
+    }
+    return tracks;
+  }
+  _getArrayFromAccessor(accessor) {
+    let outputArray = accessor.array;
+    if (accessor.normalized) {
+      const scale = getNormalizedComponentScale(outputArray.constructor);
+      const scaled = new Float32Array(outputArray.length);
+      for (let j = 0, jl = outputArray.length; j < jl; j++) {
+        scaled[j] = outputArray[j] * scale;
+      }
+      outputArray = scaled;
+    }
+    return outputArray;
+  }
+  _createCubicSplineTrackInterpolant(track) {
+    track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline(result) {
+      const interpolantType = this instanceof THREE.QuaternionKeyframeTrack ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant;
+      return new interpolantType(this.times, this.values, this.getValueSize() / 3, result);
+    };
+    track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
+  }
 }
 function computeBounds(geometry, primitiveDef, parser) {
   const attributes = primitiveDef.attributes;