@polarfront-lab/ionian 3.0.6-hotfix.1 → 3.0.6

package/dist/ionian.js

@@ -35,10 +35,11 @@ class DefaultEventEmitter {
     this.emitter.on(type, handler);
   }
   once(type, handler) {
-    this.emitter.on(type, (payload) => {
-      this.emitter.off(type, handler);
+    const wrappedHandler = (payload) => {
+      this.emitter.off(type, wrappedHandler);
       handler(payload);
-    });
+    };
+    this.emitter.on(type, wrappedHandler);
   }
   dispose() {
     this.emitter.all.clear();
@@ -83,20 +84,27 @@ function clamp(value, min, max) {
   value = Math.max(value, min);
   return value;
 }
+const DEFAULT_DRACO_DECODER_PATH = "https://www.gstatic.com/draco/versioned/decoders/1.5.7/";
 class AssetService {
-  constructor(eventEmitter) {
+  constructor(eventEmitter, options = {}) {
     __publicField(this, "serviceState", "created");
     __publicField(this, "eventEmitter");
     __publicField(this, "meshes", /* @__PURE__ */ new Map());
     __publicField(this, "textures", /* @__PURE__ */ new Map());
     __publicField(this, "gltfLoader", new GLTFLoader());
     __publicField(this, "textureLoader", new THREE.TextureLoader());
-    __publicField(this, "dracoLoader", new DRACOLoader());
+    __publicField(this, "dracoLoader");
     __publicField(this, "solidColorTextures", /* @__PURE__ */ new Map());
     __publicField(this, "fallbackTexture", new THREE.DataTexture(new Uint8Array([127, 127, 127, 255]), 1, 1, THREE.RGBAFormat));
     this.eventEmitter = eventEmitter;
-    this.dracoLoader.setDecoderPath("https://www.gstatic.com/draco/versioned/decoders/1.5.7/");
-    this.gltfLoader.setDRACOLoader(this.dracoLoader);
+    const decoderPath = options.dracoDecoderPath === void 0 ? DEFAULT_DRACO_DECODER_PATH : options.dracoDecoderPath;
+    if (decoderPath !== null) {
+      this.dracoLoader = new DRACOLoader();
+      this.dracoLoader.setDecoderPath(decoderPath);
+      this.gltfLoader.setDRACOLoader(this.dracoLoader);
+    } else {
+      this.dracoLoader = null;
+    }
     this.fallbackTexture.name = "default-fallback-texture";
     this.updateServiceState("ready");
   }
@@ -189,17 +197,15 @@ class AssetService {
    * @returns The loaded mesh or null.
    */
   async loadMeshAsync(id, url, options = {}) {
-    const gltf = await this.gltfLoader.loadAsync(url);
     try {
-      if (options.meshName) {
-        const mesh = gltf.scene.getObjectByName(options.meshName);
-        this.register(id, mesh);
-        return mesh;
-      } else {
-        const mesh = gltf.scene.children[0];
-        this.register(id, mesh);
-        return mesh;
+      const gltf = await this.gltfLoader.loadAsync(url);
+      const mesh = this.findMesh(gltf.scene, options.meshName);
+      if (!mesh) {
+        this.eventEmitter.emit("invalidRequest", { message: `failed to load mesh: ${id}. mesh not found` });
+        return null;
       }
+      this.register(id, mesh);
+      return mesh;
     } catch (error) {
       this.eventEmitter.emit("invalidRequest", { message: `failed to load mesh: ${id}. ${error}` });
       return null;
@@ -222,6 +228,7 @@ class AssetService {
     }
   }
   dispose() {
+    var _a;
     this.updateServiceState("disposed");
     this.meshes.forEach((mesh) => disposeMesh(mesh));
     this.meshes.clear();
@@ -229,12 +236,29 @@ class AssetService {
     this.textures.clear();
     this.solidColorTextures.forEach((texture) => texture.dispose());
     this.solidColorTextures.clear();
+    (_a = this.dracoLoader) == null ? void 0 : _a.dispose();
     this.fallbackTexture.dispose();
   }
   updateServiceState(serviceState) {
     this.serviceState = serviceState;
     this.eventEmitter.emit("serviceStateUpdated", { type: "asset", state: serviceState });
   }
+  findMesh(root, meshName) {
+    if (meshName) {
+      const named = root.getObjectByName(meshName);
+      return isMesh(named) ? named : null;
+    }
+    let found = null;
+    root.traverse((object) => {
+      if (!found && isMesh(object)) {
+        found = object;
+      }
+    });
+    return found;
+  }
+}
+function isMesh(object) {
+  return !!object && "isMesh" in object && object.isMesh === true;
 }
 const _face = new Triangle();
 const _color = new Vector3();
@@ -444,14 +468,13 @@ class DataTextureService {
     if (cachedTexture) {
       return cachedTexture;
     }
-    const meshData = parseMeshData(asset);
-    const array = sampleMesh(meshData, this.textureSize);
+    const array = sampleMesh(asset, this.textureSize);
     const dataTexture = createDataTexture(array, this.textureSize);
     dataTexture.name = asset.name;
     this.dataTextures.set(asset.uuid, dataTexture);
     return dataTexture;
   }
-  dispose() {
+  async dispose() {
     this.dataTextures.forEach((texture) => texture.dispose());
     this.dataTextures.clear();
     if (this.currentAtlas) {
@@ -511,38 +534,28 @@ class DataTextureService {
     }
   }
 }
-function parseMeshData(mesh) {
-  var _a;
-  return {
-    position: mesh.geometry.attributes.position.array,
-    normal: (_a = mesh.geometry.attributes.normal) == null ? void 0 : _a.array,
-    scale: { x: mesh.scale.x, y: mesh.scale.y, z: mesh.scale.z }
-  };
-}
-function sampleMesh(meshData, size) {
-  const geometry = new THREE.BufferGeometry();
-  geometry.setAttribute("position", new THREE.BufferAttribute(new Float32Array(meshData.position), 3));
-  if (meshData.normal) {
-    geometry.setAttribute("normal", new THREE.BufferAttribute(new Float32Array(meshData.normal), 3));
-  }
-  const material = new THREE.MeshBasicMaterial();
-  const mesh = new THREE.Mesh(geometry, material);
-  mesh.scale.set(meshData.scale.x, meshData.scale.y, meshData.scale.z);
+function sampleMesh(sourceMesh, size) {
+  sourceMesh.updateWorldMatrix(true, false);
+  const geometry = sourceMesh.geometry.clone();
+  geometry.applyMatrix4(sourceMesh.matrixWorld);
+  const mesh = new THREE.Mesh(geometry);
   const sampler = new MeshSurfaceSampler(mesh).build();
   const data = new Float32Array(size * size * 4);
   const position = new THREE.Vector3();
-  for (let i = 0; i < size; i++) {
-    for (let j = 0; j < size; j++) {
-      const index = i * size + j;
-      sampler.sample(position);
-      data[4 * index] = position.x * meshData.scale.x;
-      data[4 * index + 1] = position.y * meshData.scale.y;
-      data[4 * index + 2] = position.z * meshData.scale.z;
-      data[4 * index + 3] = (Math.random() - 0.5) * 0.01;
+  try {
+    for (let i = 0; i < size; i++) {
+      for (let j = 0; j < size; j++) {
+        const index = i * size + j;
+        sampler.sample(position);
+        data[4 * index] = position.x;
+        data[4 * index + 1] = position.y;
+        data[4 * index + 2] = position.z;
+        data[4 * index + 3] = (Math.random() - 0.5) * 0.01;
+      }
     }
+  } finally {
+    geometry.dispose();
   }
-  geometry.dispose();
-  material.dispose();
   return data;
 }
 const instanceFragmentShader = `
@@ -707,15 +720,16 @@ class InstancedMeshManager {
   /**
    * Resizes or replaces the instanced mesh.
    * @param size The new size of the instanced mesh.
-   * @returns The updated instanced mesh.
+   * @returns An object containing the updated mesh, the previous mesh, and a boolean indicating whether the mesh was updated.
    */
   resize(size) {
-    if (this.size === size) return this.mesh;
+    if (this.size === size) return { current: this.mesh, previous: this.mesh };
     this.size = size;
     const prev = this.mesh;
     this.mesh = this.createInstancedMesh(size, prev.geometry, prev.material);
-    prev.dispose();
-    return this.mesh;
+    this.copyMeshState(prev, this.mesh);
+    this.replaceMeshInParent(prev, this.mesh);
+    return { current: this.mesh, previous: prev };
   }
   /**
    * Disposes the resources used by the InstancedMeshManager.
@@ -724,7 +738,6 @@ class InstancedMeshManager {
     this.mesh.dispose();
     this.geometries.forEach((geometry) => geometry.dispose());
     this.shaderMaterial.dispose();
-    this.fallbackGeometry.dispose();
     this.uvRefsCache.clear();
     this.geometries.clear();
   }
@@ -783,6 +796,41 @@ class InstancedMeshManager {
     const count = size * size;
     return new THREE.InstancedMesh(geometry, material, count);
   }
+  copyMeshState(source, target) {
+    target.name = source.name;
+    target.up.copy(source.up);
+    target.position.copy(source.position);
+    target.quaternion.copy(source.quaternion);
+    target.scale.copy(source.scale);
+    target.matrix.copy(source.matrix);
+    target.matrixWorld.copy(source.matrixWorld);
+    target.matrixAutoUpdate = source.matrixAutoUpdate;
+    target.matrixWorldAutoUpdate = source.matrixWorldAutoUpdate;
+    target.matrixWorldNeedsUpdate = source.matrixWorldNeedsUpdate;
+    target.layers.mask = source.layers.mask;
+    target.visible = source.visible;
+    target.castShadow = source.castShadow;
+    target.receiveShadow = source.receiveShadow;
+    target.frustumCulled = source.frustumCulled;
+    target.renderOrder = source.renderOrder;
+    target.animations = source.animations;
+    target.userData = source.userData;
+    target.customDepthMaterial = source.customDepthMaterial;
+    target.customDistanceMaterial = source.customDistanceMaterial;
+    target.onBeforeRender = source.onBeforeRender;
+    target.onAfterRender = source.onAfterRender;
+  }
+  replaceMeshInParent(previous, current) {
+    const parent = previous.parent;
+    if (!parent) return;
+    const previousIndex = parent.children.indexOf(previous);
+    parent.add(current);
+    parent.remove(previous);
+    const currentIndex = parent.children.indexOf(current);
+    if (previousIndex < 0 || currentIndex < 0 || previousIndex === currentIndex) return;
+    parent.children.splice(currentIndex, 1);
+    parent.children.splice(Math.min(previousIndex, parent.children.length), 0, current);
+  }
 }
 class IntersectionService {
   /**
@@ -796,11 +844,8 @@ class IntersectionService {
     __publicField(this, "mousePosition", new THREE.Vector2());
     __publicField(this, "camera");
     __publicField(this, "meshSequenceGeometries", []);
-    // ADDED: Store cloned geometries
     __publicField(this, "meshSequenceUUIDs", []);
-    // ADDED: Track UUIDs to avoid redundant cloning
     __publicField(this, "overallProgress", 0);
-    // ADDED: Store overall progress (0-1)
     __publicField(this, "intersectionMesh", new THREE.Mesh());
     // Use a single mesh for intersection target
     __publicField(this, "geometryNeedsUpdate");
@@ -1555,15 +1600,12 @@ class SimulationRendererService {
     __publicField(this, "state");
     __publicField(this, "textureSize");
     __publicField(this, "overallProgress");
-    // ADDED: Store overall progress
     __publicField(this, "velocityTractionForce");
     __publicField(this, "positionalTractionForce");
     __publicField(this, "simulationRenderer");
     __publicField(this, "webGLRenderer");
     __publicField(this, "eventEmitter");
-    // Store atlas info
     __publicField(this, "currentAtlasEntry", null);
-    // ADDED
     __publicField(this, "lastKnownVelocityDataTexture");
     __publicField(this, "lastKnownPositionDataTexture");
     this.eventEmitter = eventEmitter;
@@ -1642,41 +1684,13 @@ class SimulationRendererService {
     this.simulationRenderer.setMaxRepelDistance(distance);
   }
 }
-class ExecutionStatusMap {
-  constructor() {
-    __publicField(this, "execStatus", /* @__PURE__ */ new Map());
-  }
-  get(type) {
-    const status = this.execStatus.get(type);
-    if (!status) {
-      this.execStatus.set(type, "idle");
-      return "idle";
-    }
-    return status;
-  }
-  set(type, status) {
-    this.execStatus.set(type, status);
-  }
-}
 class TransitionService {
   constructor(eventEmitter) {
     __publicField(this, "eventEmitter");
     __publicField(this, "transitions", /* @__PURE__ */ new Map());
-    __publicField(this, "execStatus");
     __publicField(this, "ongoingTransitions", /* @__PURE__ */ new Map());
-    __publicField(this, "boundHandleTransitionCancelled");
     this.eventEmitter = eventEmitter;
-    this.execStatus = new ExecutionStatusMap();
-    this.boundHandleTransitionCancelled = this.handleTransitionCancelledEvent.bind(this);
-    this.eventEmitter.on("transitionCancelled", this.boundHandleTransitionCancelled);
-  }
-  dispose() {
-    this.eventEmitter.off("transitionCancelled", this.boundHandleTransitionCancelled);
-    this.ongoingTransitions.forEach((transition) => {
-      transition.cancelled = true;
-    });
-    this.ongoingTransitions.clear();
-    this.transitions.clear();
+    this.eventEmitter.on("transitionCancelled", this.handleTransitionCancelledEvent.bind(this));
   }
   /**
    * Enqueues a transition.
@@ -1740,6 +1754,7 @@ class TransitionService {
     if (ongoingTransition) {
       ongoingTransition.cancelled = true;
       (_a = ongoingTransition.onTransitionCancelled) == null ? void 0 : _a.call(ongoingTransition);
+      this.ongoingTransitions.delete(type);
     }
   }
   emitTransitionProgress(type, progress) {
@@ -1749,6 +1764,28 @@ class TransitionService {
     this.eventEmitter.emit("transitionFinished", { type });
   }
 }
+function resolveSequenceInterpolation(progress, itemCount) {
+  if (itemCount <= 1) {
+    return { indexA: 0, indexB: 0, localProgress: 0 };
+  }
+  const clampedProgress = Math.max(0, Math.min(progress, 1));
+  const totalSegments = itemCount - 1;
+  const scaledProgress = clampedProgress * totalSegments;
+  if (clampedProgress >= 1) {
+    return {
+      indexA: totalSegments,
+      indexB: totalSegments,
+      localProgress: 1
+    };
+  }
+  const indexA = Math.floor(scaledProgress);
+  const indexB = Math.min(indexA + 1, totalSegments);
+  return {
+    indexA,
+    indexB,
+    localProgress: scaledProgress - indexA
+  };
+}
 class ParticlesEngine {
   /**
    * Creates a new ParticlesEngine instance.
@@ -1767,21 +1804,16 @@ class ParticlesEngine {
     __publicField(this, "engineState");
     __publicField(this, "intersectionService");
     __publicField(this, "meshSequenceAtlasTexture", null);
-    // ADDED: To store the generated atlas
+    __publicField(this, "lastRenderElapsedTimeSeconds", null);
     __publicField(this, "eventEmitter");
-    // Bound event handlers for proper cleanup
-    __publicField(this, "boundHandleServiceStateUpdated");
-    __publicField(this, "boundHandleInteractionPositionUpdated");
     const { scene, renderer, camera, textureSize, useIntersection = true } = params;
     this.eventEmitter = new DefaultEventEmitter();
     this.serviceStates = this.getInitialServiceStates();
-    this.boundHandleServiceStateUpdated = this.handleServiceStateUpdated.bind(this);
-    this.boundHandleInteractionPositionUpdated = this.handleInteractionPositionUpdated.bind(this);
-    this.eventEmitter.on("serviceStateUpdated", this.boundHandleServiceStateUpdated);
+    this.eventEmitter.on("serviceStateUpdated", this.handleServiceStateUpdated.bind(this));
     this.scene = scene;
     this.renderer = renderer;
     this.engineState = this.initialEngineState(params);
-    this.assetService = new AssetService(this.eventEmitter);
+    this.assetService = new AssetService(this.eventEmitter, { dracoDecoderPath: params.dracoDecoderPath });
     this.transitionService = new TransitionService(this.eventEmitter);
     this.dataTextureManager = new DataTextureService(this.eventEmitter, textureSize);
     this.simulationRendererService = new SimulationRendererService(this.eventEmitter, textureSize, this.renderer);
@@ -1790,18 +1822,23 @@ class ParticlesEngine {
     this.intersectionService = new IntersectionService(this.eventEmitter, camera);
     if (!useIntersection) this.intersectionService.setActive(false);
     this.setOverallProgress(0, false);
-    this.eventEmitter.on("interactionPositionUpdated", this.boundHandleInteractionPositionUpdated);
+    this.eventEmitter.on("interactionPositionUpdated", this.handleInteractionPositionUpdated.bind(this));
   }
   /**
    * Renders the scene.
    * @param elapsedTime The elapsed time since the last frame.
    */
-  render(elapsedTime) {
-    const dt = elapsedTime / 1e3;
-    this.transitionService.compute(dt);
+  render(elapsedTimeMs) {
+    const elapsedTimeSeconds = elapsedTimeMs / 1e3;
+    const deltaTimeSeconds = this.lastRenderElapsedTimeSeconds === null ? 0 : Math.max(0, elapsedTimeSeconds - this.lastRenderElapsedTimeSeconds);
+    this.lastRenderElapsedTimeSeconds = elapsedTimeSeconds;
+    this.renderFrame(deltaTimeSeconds, elapsedTimeSeconds);
+  }
+  renderFrame(deltaTimeSeconds, elapsedTimeSeconds) {
+    this.transitionService.compute(elapsedTimeSeconds);
     this.intersectionService.calculate(this.instancedMeshManager.getMesh());
-    this.simulationRendererService.compute(dt);
-    this.instancedMeshManager.update(dt);
+    this.simulationRendererService.compute(deltaTimeSeconds);
+    this.instancedMeshManager.update(elapsedTimeSeconds);
     this.instancedMeshManager.updateVelocityTexture(this.simulationRendererService.getVelocityTexture());
     this.instancedMeshManager.updatePositionTexture(this.simulationRendererService.getPositionTexture());
   }
@@ -1810,27 +1847,30 @@ class ParticlesEngine {
     this.eventEmitter.emit("textureSequenceUpdated", { sequence });
     this.setOverallProgress(0, false);
   }
-  // --- Update setTextureSize ---
   async setTextureSize(size) {
     if (this.engineState.textureSize === size) {
       return;
     }
+    const meshSequence = [...this.engineState.meshSequence];
+    const overallProgress = this.engineState.overallProgress;
     this.engineState.textureSize = size;
     this.dataTextureManager.setTextureSize(size);
     this.simulationRendererService.setTextureSize(size);
-    this.scene.remove(this.instancedMeshManager.getMesh());
-    this.instancedMeshManager.resize(size);
-    this.scene.add(this.instancedMeshManager.getMesh());
-    if (this.engineState.meshSequence.length > 0) {
-      await this.setMeshSequence(this.engineState.meshSequence);
+    const { current, previous } = this.instancedMeshManager.resize(size);
+    if (current !== previous) {
+      previous.dispose();
+      if (!current.parent) {
+        this.scene.add(current);
+      }
+    }
+    if (meshSequence.length > 0) {
+      await this.setMeshSequence(meshSequence);
     }
     this.simulationRendererService.setVelocityTractionForce(this.engineState.velocityTractionForce);
     this.simulationRendererService.setPositionalTractionForce(this.engineState.positionalTractionForce);
     this.simulationRendererService.setMaxRepelDistance(this.engineState.maxRepelDistance);
-    this.simulationRendererService.setOverallProgress(this.engineState.overallProgress);
-    this.intersectionService.setOverallProgress(this.engineState.overallProgress);
     this.instancedMeshManager.setGeometrySize(this.engineState.instanceGeometryScale);
-    this.setOverallProgress(this.engineState.overallProgress, false);
+    this.setOverallProgress(overallProgress, false);
   }
   registerMesh(id, mesh) {
     this.assetService.register(id, mesh);
@@ -1838,8 +1878,8 @@ class ParticlesEngine {
   registerMatcap(id, matcap) {
     this.assetService.register(id, matcap);
   }
-  async fetchAndRegisterMesh(id, url) {
-    return await this.assetService.loadMeshAsync(id, url);
+  async fetchAndRegisterMesh(id, url, options) {
+    return await this.assetService.loadMeshAsync(id, url, options);
   }
   async fetchAndRegisterMatcap(id, url) {
     return await this.assetService.loadTextureAsync(id, url);
@@ -1932,7 +1972,7 @@ class ParticlesEngine {
     this.engineState.overallProgress = clampedProgress;
     this.simulationRendererService.setOverallProgress(clampedProgress);
     this.intersectionService.setOverallProgress(clampedProgress);
-    const { textureA, textureB, localProgress } = this.calculateTextureInterpolation(progress);
+    const { textureA, textureB, localProgress } = this.calculateTextureInterpolation(clampedProgress);
     this.instancedMeshManager.updateTextureInterpolation(textureA, textureB, localProgress);
   }
   /**
@@ -1998,27 +2038,22 @@ class ParticlesEngine {
    * Disposes the resources used by the engine.
    */
   dispose() {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f;
     if (this.scene && this.instancedMeshManager) {
       this.scene.remove(this.instancedMeshManager.getMesh());
     }
-    this.eventEmitter.off("serviceStateUpdated", this.boundHandleServiceStateUpdated);
-    this.eventEmitter.off("interactionPositionUpdated", this.boundHandleInteractionPositionUpdated);
     (_a = this.simulationRendererService) == null ? void 0 : _a.dispose();
     (_b = this.instancedMeshManager) == null ? void 0 : _b.dispose();
     (_c = this.intersectionService) == null ? void 0 : _c.dispose();
     (_d = this.assetService) == null ? void 0 : _d.dispose();
     (_e = this.dataTextureManager) == null ? void 0 : _e.dispose();
-    (_f = this.transitionService) == null ? void 0 : _f.dispose();
-    (_g = this.eventEmitter) == null ? void 0 : _g.dispose();
+    (_f = this.eventEmitter) == null ? void 0 : _f.dispose();
   }
   initialEngineState(params) {
     return {
       textureSize: params.textureSize,
       meshSequence: [],
-      // ADDED
       overallProgress: 0,
-      // ADDED
       textureSequence: [],
       velocityTractionForce: 0.1,
       positionalTractionForce: 0.1,
@@ -2051,23 +2086,7 @@ class ParticlesEngine {
       const tex = this.getTextureForSequenceItem(sequence[0]);
       return { textureA: tex, textureB: tex, localProgress: 0 };
     }
-    const totalSegments = numItems - 1;
-    const progressPerSegment = 1 / totalSegments;
-    const scaledProgress = progress * totalSegments;
-    let indexA = Math.floor(scaledProgress);
-    let indexB = indexA + 1;
-    indexA = Math.max(0, Math.min(indexA, totalSegments));
-    indexB = Math.max(0, Math.min(indexB, totalSegments));
-    let localProgress = 0;
-    if (progressPerSegment > 0) {
-      localProgress = (progress - indexA * progressPerSegment) / progressPerSegment;
-    }
-    if (progress >= 1) {
-      indexA = totalSegments;
-      indexB = totalSegments;
-      localProgress = 1;
-    }
-    localProgress = Math.max(0, Math.min(localProgress, 1));
+    const { indexA, indexB, localProgress } = resolveSequenceInterpolation(progress, numItems);
     const itemA = sequence[indexA];
     const itemB = sequence[indexB];
     const textureA = this.getTextureForSequenceItem(itemA);
@@ -2083,6 +2102,7 @@ class ParticlesEngine {
   }
 }
 export {
-  ParticlesEngine
+  ParticlesEngine,
+  resolveSequenceInterpolation
 };
 //# sourceMappingURL=ionian.js.map