three-stdlib 2.35.4 → 2.35.5

package/exporters/GLTFExporter.cjs

@@ -94,187 +94,184 @@ const KHR_mesh_quantization_ExtraAttrTypes = {
   TANGENT: ["byte normalized", "short normalized"],
   TEXCOORD: ["byte", "byte normalized", "unsigned byte", "short", "short normalized", "unsigned short"]
 };
-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);
-      });
-    }
-    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);
+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);
     }
-    parseAsync(input, options) {
-      const scope = this;
-      return new Promise(function(resolve, reject) {
-        scope.parse(input, resolve, reject, options);
-      });
+    return this;
+  }
+  unregister(callback) {
+    if (this.pluginCallbacks.indexOf(callback) !== -1) {
+      this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1);
     }
+    return this;
   }
   /**
-   * Static utility functions
+   * 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
    */
-  __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;
-        }
-        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;
-          }
-        }
+  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;
       }
-      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);
+      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;
         }
-        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;
+      }
+    }
+    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.");
         }
-        const sourceInterpolant = sourceTrack.createInterpolant(new sourceTrack.ValueBufferType(1));
-        mergedTrack = mergedTracks[sourceTrackNode.uuid];
+        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++) {
-          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];
+          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++) {
+        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;
     }
-  });
-  return GLTFExporter2;
-})();
+    clip.tracks = tracks;
+    return clip;
+  }
+});
 const WEBGL_CONSTANTS = {
   POINTS: 0,
   LINES: 1,
@@ -319,7 +316,7 @@ const PATH_PROPERTIES = {
   quaternion: "rotation",
   morphTargetInfluences: "weights"
 };
-const DEFAULT_SPECULAR_COLOR = /* @__PURE__ */ new THREE.Color();
+const DEFAULT_SPECULAR_COLOR = new THREE.Color();
 const GLB_HEADER_BYTES = 12;
 const GLB_HEADER_MAGIC = 1179937895;
 const GLB_VERSION = 2;