three-stdlib 2.35.5 → 2.35.6

package/exporters/GLTFExporter.cjs

@@ -94,184 +94,187 @@ const KHR_mesh_quantization_ExtraAttrTypes = {
   TANGENT: ["byte normalized", "short normalized"],
   TEXCOORD: ["byte", "byte normalized", "unsigned byte", "short", "short normalized", "unsigned short"]
 };
-class GLTFExporter {
-  constructor() {
-    this.pluginCallbacks = [];
-    this.register(function(writer) {
-      return new GLTFLightExtension(writer);
-    });
-    this.register(function(writer) {
-      return new GLTFMaterialsUnlitExtension(writer);
-    });
-    this.register(function(writer) {
-      return new GLTFMaterialsTransmissionExtension(writer);
-    });
-    this.register(function(writer) {
-      return new GLTFMaterialsVolumeExtension(writer);
-    });
-    this.register(function(writer) {
-      return new GLTFMaterialsIorExtension(writer);
-    });
-    this.register(function(writer) {
-      return new GLTFMaterialsSpecularExtension(writer);
-    });
-    this.register(function(writer) {
-      return new GLTFMaterialsClearcoatExtension(writer);
-    });
-    this.register(function(writer) {
-      return new GLTFMaterialsIridescenceExtension(writer);
-    });
-    this.register(function(writer) {
-      return new GLTFMaterialsSheenExtension(writer);
-    });
-    this.register(function(writer) {
-      return new GLTFMaterialsAnisotropyExtension(writer);
-    });
-    this.register(function(writer) {
-      return new GLTFMaterialsEmissiveStrengthExtension(writer);
-    });
-  }
-  register(callback) {
-    if (this.pluginCallbacks.indexOf(callback) === -1) {
-      this.pluginCallbacks.push(callback);
+const GLTFExporter = /* @__PURE__ */ (() => {
+  class GLTFExporter2 {
+    constructor() {
+      this.pluginCallbacks = [];
+      this.register(function(writer) {
+        return new GLTFLightExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsUnlitExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsTransmissionExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsVolumeExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsIorExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsSpecularExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsClearcoatExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsIridescenceExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsSheenExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsAnisotropyExtension(writer);
+      });
+      this.register(function(writer) {
+        return new GLTFMaterialsEmissiveStrengthExtension(writer);
+      });
     }
-    return this;
-  }
-  unregister(callback) {
-    if (this.pluginCallbacks.indexOf(callback) !== -1) {
-      this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1);
+    register(callback) {
+      if (this.pluginCallbacks.indexOf(callback) === -1) {
+        this.pluginCallbacks.push(callback);
+      }
+      return this;
+    }
+    unregister(callback) {
+      if (this.pluginCallbacks.indexOf(callback) !== -1) {
+        this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1);
+      }
+      return this;
+    }
+    /**
+     * Parse scenes and generate GLTF output
+     * @param  {Scene or [THREE.Scenes]} input   Scene or Array of THREE.Scenes
+     * @param  {Function} onDone  Callback on completed
+     * @param  {Function} onError  Callback on errors
+     * @param  {Object} options options
+     */
+    parse(input, onDone, onError, options) {
+      const writer = new GLTFWriter();
+      const plugins = [];
+      for (let i = 0, il = this.pluginCallbacks.length; i < il; i++) {
+        plugins.push(this.pluginCallbacks[i](writer));
+      }
+      writer.setPlugins(plugins);
+      writer.write(input, onDone, options).catch(onError);
+    }
+    parseAsync(input, options) {
+      const scope = this;
+      return new Promise(function(resolve, reject) {
+        scope.parse(input, resolve, reject, options);
+      });
     }
-    return this;
   }
   /**
-   * Parse scenes and generate GLTF output
-   * @param  {Scene or [THREE.Scenes]} input   Scene or Array of THREE.Scenes
-   * @param  {Function} onDone  Callback on completed
-   * @param  {Function} onError  Callback on errors
-   * @param  {Object} options options
+   * Static utility functions
    */
-  parse(input, onDone, onError, options) {
-    const writer = new GLTFWriter();
-    const plugins = [];
-    for (let i = 0, il = this.pluginCallbacks.length; i < il; i++) {
-      plugins.push(this.pluginCallbacks[i](writer));
-    }
-    writer.setPlugins(plugins);
-    writer.write(input, onDone, options).catch(onError);
-  }
-  parseAsync(input, options) {
-    const scope = this;
-    return new Promise(function(resolve, reject) {
-      scope.parse(input, resolve, reject, options);
-    });
-  }
-}
-/**
- * Static utility functions
- */
-__publicField(GLTFExporter, "Utils", {
-  insertKeyframe: function(track, time) {
-    const tolerance = 1e-3;
-    const valueSize = track.getValueSize();
-    const times = new track.TimeBufferType(track.times.length + 1);
-    const values = new track.ValueBufferType(track.values.length + valueSize);
-    const interpolant = track.createInterpolant(new track.ValueBufferType(valueSize));
-    let index;
-    if (track.times.length === 0) {
-      times[0] = time;
-      for (let i = 0; i < valueSize; i++) {
-        values[i] = 0;
-      }
-      index = 0;
-    } else if (time < track.times[0]) {
-      if (Math.abs(track.times[0] - time) < tolerance)
-        return 0;
-      times[0] = time;
-      times.set(track.times, 1);
-      values.set(interpolant.evaluate(time), 0);
-      values.set(track.values, valueSize);
-      index = 0;
-    } else if (time > track.times[track.times.length - 1]) {
-      if (Math.abs(track.times[track.times.length - 1] - time) < tolerance) {
-        return track.times.length - 1;
-      }
-      times[times.length - 1] = time;
-      times.set(track.times, 0);
-      values.set(track.values, 0);
-      values.set(interpolant.evaluate(time), track.values.length);
-      index = times.length - 1;
-    } else {
-      for (let i = 0; i < track.times.length; i++) {
-        if (Math.abs(track.times[i] - time) < tolerance)
-          return i;
-        if (track.times[i] < time && track.times[i + 1] > time) {
-          times.set(track.times.slice(0, i + 1), 0);
-          times[i + 1] = time;
-          times.set(track.times.slice(i + 1), i + 2);
-          values.set(track.values.slice(0, (i + 1) * valueSize), 0);
-          values.set(interpolant.evaluate(time), (i + 1) * valueSize);
-          values.set(track.values.slice((i + 1) * valueSize), (i + 2) * valueSize);
-          index = i + 1;
-          break;
+  __publicField(GLTFExporter2, "Utils", {
+    insertKeyframe: function(track, time) {
+      const tolerance = 1e-3;
+      const valueSize = track.getValueSize();
+      const times = new track.TimeBufferType(track.times.length + 1);
+      const values = new track.ValueBufferType(track.values.length + valueSize);
+      const interpolant = track.createInterpolant(new track.ValueBufferType(valueSize));
+      let index;
+      if (track.times.length === 0) {
+        times[0] = time;
+        for (let i = 0; i < valueSize; i++) {
+          values[i] = 0;
         }
-      }
-    }
-    track.times = times;
-    track.values = values;
-    return index;
-  },
-  mergeMorphTargetTracks: function(clip, root) {
-    const tracks = [];
-    const mergedTracks = {};
-    const sourceTracks = clip.tracks;
-    for (let i = 0; i < sourceTracks.length; ++i) {
-      let sourceTrack = sourceTracks[i];
-      const sourceTrackBinding = THREE.PropertyBinding.parseTrackName(sourceTrack.name);
-      const sourceTrackNode = THREE.PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
-      if (sourceTrackBinding.propertyName !== "morphTargetInfluences" || sourceTrackBinding.propertyIndex === void 0) {
-        tracks.push(sourceTrack);
-        continue;
-      }
-      if (sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete && sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear) {
-        if (sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
-          throw new Error("THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.");
+        index = 0;
+      } else if (time < track.times[0]) {
+        if (Math.abs(track.times[0] - time) < tolerance)
+          return 0;
+        times[0] = time;
+        times.set(track.times, 1);
+        values.set(interpolant.evaluate(time), 0);
+        values.set(track.values, valueSize);
+        index = 0;
+      } else if (time > track.times[track.times.length - 1]) {
+        if (Math.abs(track.times[track.times.length - 1] - time) < tolerance) {
+          return track.times.length - 1;
+        }
+        times[times.length - 1] = time;
+        times.set(track.times, 0);
+        values.set(track.values, 0);
+        values.set(interpolant.evaluate(time), track.values.length);
+        index = times.length - 1;
+      } else {
+        for (let i = 0; i < track.times.length; i++) {
+          if (Math.abs(track.times[i] - time) < tolerance)
+            return i;
+          if (track.times[i] < time && track.times[i + 1] > time) {
+            times.set(track.times.slice(0, i + 1), 0);
+            times[i + 1] = time;
+            times.set(track.times.slice(i + 1), i + 2);
+            values.set(track.values.slice(0, (i + 1) * valueSize), 0);
+            values.set(interpolant.evaluate(time), (i + 1) * valueSize);
+            values.set(track.values.slice((i + 1) * valueSize), (i + 2) * valueSize);
+            index = i + 1;
+            break;
+          }
         }
-        console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.");
-        sourceTrack = sourceTrack.clone();
-        sourceTrack.setInterpolation(THREE.InterpolateLinear);
-      }
-      const targetCount = sourceTrackNode.morphTargetInfluences.length;
-      const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex];
-      if (targetIndex === void 0) {
-        throw new Error("THREE.GLTFExporter: Morph target name not found: " + sourceTrackBinding.propertyIndex);
       }
-      let mergedTrack;
-      if (mergedTracks[sourceTrackNode.uuid] === void 0) {
-        mergedTrack = sourceTrack.clone();
-        const values = new mergedTrack.ValueBufferType(targetCount * mergedTrack.times.length);
+      track.times = times;
+      track.values = values;
+      return index;
+    },
+    mergeMorphTargetTracks: function(clip, root) {
+      const tracks = [];
+      const mergedTracks = {};
+      const sourceTracks = clip.tracks;
+      for (let i = 0; i < sourceTracks.length; ++i) {
+        let sourceTrack = sourceTracks[i];
+        const sourceTrackBinding = THREE.PropertyBinding.parseTrackName(sourceTrack.name);
+        const sourceTrackNode = THREE.PropertyBinding.findNode(root, sourceTrackBinding.nodeName);
+        if (sourceTrackBinding.propertyName !== "morphTargetInfluences" || sourceTrackBinding.propertyIndex === void 0) {
+          tracks.push(sourceTrack);
+          continue;
+        }
+        if (sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodDiscrete && sourceTrack.createInterpolant !== sourceTrack.InterpolantFactoryMethodLinear) {
+          if (sourceTrack.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline) {
+            throw new Error("THREE.GLTFExporter: Cannot merge tracks with glTF CUBICSPLINE interpolation.");
+          }
+          console.warn("THREE.GLTFExporter: Morph target interpolation mode not yet supported. Using LINEAR instead.");
+          sourceTrack = sourceTrack.clone();
+          sourceTrack.setInterpolation(THREE.InterpolateLinear);
+        }
+        const targetCount = sourceTrackNode.morphTargetInfluences.length;
+        const targetIndex = sourceTrackNode.morphTargetDictionary[sourceTrackBinding.propertyIndex];
+        if (targetIndex === void 0) {
+          throw new Error("THREE.GLTFExporter: Morph target name not found: " + sourceTrackBinding.propertyIndex);
+        }
+        let mergedTrack;
+        if (mergedTracks[sourceTrackNode.uuid] === void 0) {
+          mergedTrack = sourceTrack.clone();
+          const values = new mergedTrack.ValueBufferType(targetCount * mergedTrack.times.length);
+          for (let j = 0; j < mergedTrack.times.length; j++) {
+            values[j * targetCount + targetIndex] = mergedTrack.values[j];
+          }
+          mergedTrack.name = (sourceTrackBinding.nodeName || "") + ".morphTargetInfluences";
+          mergedTrack.values = values;
+          mergedTracks[sourceTrackNode.uuid] = mergedTrack;
+          tracks.push(mergedTrack);
+          continue;
+        }
+        const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1));
+        mergedTrack = mergedTracks[sourceTrackNode.uuid];
         for (let j = 0; j < mergedTrack.times.length; j++) {
-          values[j * targetCount + targetIndex] = mergedTrack.values[j];
+          mergedTrack.values[j * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j]);
+        }
+        for (let j = 0; j < sourceTrack.times.length; j++) {
+          const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j]);
+          mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j];
         }
-        mergedTrack.name = (sourceTrackBinding.nodeName || "") + ".morphTargetInfluences";
-        mergedTrack.values = values;
-        mergedTracks[sourceTrackNode.uuid] = mergedTrack;
-        tracks.push(mergedTrack);
-        continue;
-      }
-      const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1));
-      mergedTrack = mergedTracks[sourceTrackNode.uuid];
-      for (let j = 0; j < mergedTrack.times.length; j++) {
-        mergedTrack.values[j * targetCount + targetIndex] = sourceInterpolant.evaluate(mergedTrack.times[j]);
-      }
-      for (let j = 0; j < sourceTrack.times.length; j++) {
-        const keyframeIndex = this.insertKeyframe(mergedTrack, sourceTrack.times[j]);
-        mergedTrack.values[keyframeIndex * targetCount + targetIndex] = sourceTrack.values[j];
       }
+      clip.tracks = tracks;
+      return clip;
     }
-    clip.tracks = tracks;
-    return clip;
-  }
-});
+  });
+  return GLTFExporter2;
+})();
 const WEBGL_CONSTANTS = {
   POINTS: 0,
   LINES: 1,
@@ -316,7 +319,7 @@ const PATH_PROPERTIES = {
   quaternion: "rotation",
   morphTargetInfluences: "weights"
 };
-const DEFAULT_SPECULAR_COLOR = new THREE.Color();
+const DEFAULT_SPECULAR_COLOR = /* @__PURE__ */ new THREE.Color();
 const GLB_HEADER_BYTES = 12;
 const GLB_HEADER_MAGIC = 1179937895;
 const GLB_VERSION = 2;