Update interface.js

interface.js

@@ -1,493 +1,294 @@
-// interface.js
-// ==============================
-
-const currentScriptTag = document.currentScript;
-
-(async function () {
-  // 1) Localiser la balise <script> et lire data-config
-  let scriptTag = currentScriptTag;
-
-  if (!scriptTag) {
-    const scripts = document.getElementsByTagName('script');
-    for (let i = 0; i < scripts.length; i++) {
-      if (
-        scripts[i].src.includes('interface.js') &&
-        scripts[i].hasAttribute('data-config')
-      ) {
-        scriptTag = scripts[i];
-        break;
-      }
-    }
-    if (!scriptTag && scripts.length > 0) {
-      scriptTag = scripts[scripts.length - 1];
-    }
-  }
-
-  const configUrl = scriptTag.getAttribute('data-config');
-  let config = {};
-
-  if (configUrl) {
-    try {
-      const response = await fetch(configUrl);
-      config = await response.json();
-    } catch (error) {
-      return;
-    }
-  } else {
+// tooltips.js
+
+/**
+ * initializeTooltips(options)
+ *
+ * - options.app: the PlayCanvas AppBase instance
+ * - options.cameraEntity: PlayCanvas camera Entity (utilisant le script orbitCamera)
+ * - options.modelEntity: the main model entity (for relative positioning, optional)
+ * - options.tooltipsUrl: URL to fetch JSON array of tooltip definitions
+ * - options.defaultVisible: boolean: whether tooltips are visible initially
+ * - options.moveDuration: number (seconds) for smooth camera move to selected tooltip
+ *
+ * JSON attendu pour chaque tooltip :
+ * {
+ *   x, y, z,                       // position du tooltip (obligatoire)
+ *   title, description, imgUrl,    // infos UI (optionnelles)
+ *   camX, camY, camZ               // position de caméra cible (optionnelles)
+ * }
+ *
+ * Comportement :
+ * - Si camX/camY/camZ sont fournis, la caméra se déplacera exactement
+ *   vers (camX, camY, camZ) et s'orientera pour regarder le tooltip.
+ * - Sinon, on conserve l'ancien comportement : la caméra orbite vers le tooltip
+ *   avec une distance calculée (zoom minimum + taille du tooltip).
+ */
+export async function initializeTooltips(options) {
+  const {
+    app,
+    cameraEntity,
+    modelEntity,         // non utilisé directement ici mais conservé pour compat
+    tooltipsUrl,
+    defaultVisible,
+    moveDuration = 0.6
+  } = options;
+
+  if (!app || !cameraEntity || !tooltipsUrl) return;
+
+  // --- Chargement du JSON de tooltips ---
+  let tooltipsData;
+  try {
+    const resp = await fetch(tooltipsUrl);
+    tooltipsData = await resp.json();
+  } catch (e) {
+    // Échec du fetch/parse JSON -> on abandonne proprement
     return;
   }
+  if (!Array.isArray(tooltipsData)) return;
+
+  const tooltipEntities = [];
+
+  // --- Matériau des sphères (tooltips) ---
+  const mat = new pc.StandardMaterial();
+  mat.diffuse = new pc.Color(1, 0.8, 0);
+  mat.specular = new pc.Color(1, 1, 1);
+  mat.shininess = 20;
+  mat.emissive = new pc.Color(0.85, 0.85, 0.85);
+  mat.emissiveIntensity = 1;
+  mat.useLighting = false;
+  mat.update();
+
+  // --- Création des entités sphères pour chaque tooltip ---
+  for (let i = 0; i < tooltipsData.length; i++) {
+    const tt = tooltipsData[i];
+    const { x, y, z, title, description, imgUrl, camX, camY, camZ } = tt;
+
+    const sphere = new pc.Entity("tooltip-" + i);
+    sphere.addComponent("model", { type: "sphere" });
+    sphere.model.material = mat;
+
+    // Taille par défaut des "pins"
+    sphere.setLocalScale(0.05, 0.05, 0.05);
+    sphere.setLocalPosition(x, y, z);
+
+    // On stocke toutes les infos utiles sur l'entité
+    sphere.tooltipData = {
+      title,
+      description,
+      imgUrl,
+      // Nouvelle partie : coordonnées de caméra cibles (optionnelles)
+      camTarget: (Number.isFinite(camX) && Number.isFinite(camY) && Number.isFinite(camZ))
+        ? new pc.Vec3(camX, camY, camZ)
+        : null
+    };
 
-  // 2) CSS optionnelle
-  if (config.css_url) {
-    const linkEl = document.createElement('link');
-    linkEl.rel = 'stylesheet';
-    linkEl.href = config.css_url;
-    document.head.appendChild(linkEl);
-  }
-
-  // 3) ID d’instance
-  const instanceId = Math.random().toString(36).substr(2, 8);
-
-  // 4) Aspect ratio
-  let aspectPercent = '100%';
-  if (config.aspect) {
-    if (config.aspect.includes(':')) {
-      const parts = config.aspect.split(':');
-      const w = parseFloat(parts[0]);
-      const h = parseFloat(parts[1]);
-      if (!isNaN(w) && !isNaN(h) && w > 0) {
-        aspectPercent = (h / w) * 100 + '%';
-      }
-    } else {
-      const aspectValue = parseFloat(config.aspect);
-      if (!isNaN(aspectValue) && aspectValue > 0) {
-        aspectPercent = 100 / aspectValue + '%';
-      }
-    }
-  } else {
-    const parentContainer = scriptTag.parentNode;
-    const containerWidth = parentContainer.offsetWidth;
-    const containerHeight = parentContainer.offsetHeight;
-    if (containerWidth > 0 && containerHeight > 0) {
-      aspectPercent = (containerHeight / containerWidth) * 100 + '%';
-    }
-  }
-
-  // 5) Conteneur widget
-  const widgetContainer = document.createElement('div');
-  widgetContainer.id = 'ply-widget-container-' + instanceId;
-  widgetContainer.classList.add('ply-widget-container');
-  widgetContainer.style.height = '0';
-  widgetContainer.style.paddingBottom = aspectPercent;
-  widgetContainer.setAttribute('data-original-aspect', aspectPercent);
-
-  const tooltipsButtonHTML = config.tooltips_url
-    ? `<button id="tooltips-toggle-${instanceId}" class="widget-button tooltips-toggle">⦿</button>`
-    : '';
-
-  // HTML du widget (IDs spécifiques à l’instance)
-  widgetContainer.innerHTML = `
-    <div id="viewer-container-${instanceId}" class="viewer-container">
-      <div id="progress-dialog-${instanceId}" class="progress-dialog">
-        <progress id="progress-indicator-${instanceId}" max="100" value="0"></progress>
-      </div>
-      <button id="fullscreen-toggle-${instanceId}" class="widget-button fullscreen-toggle">⇱</button>
-      <button id="help-toggle-${instanceId}" class="widget-button help-toggle">?</button>
-      <button id="reset-camera-btn-${instanceId}" class="widget-button reset-camera-btn">
-        <span class="reset-icon">⟲</span>
-      </button>
-      ${tooltipsButtonHTML}
-      <div id="menu-content-${instanceId}" class="menu-content">
-        <span id="help-close-${instanceId}" class="help-close">×</span>
-        <div class="help-text"></div>
-      </div>
-    </div>
-
-    <div id="tooltip-panel-${instanceId}" class="tooltip-panel" style="display: none;">
-      <div class="tooltip-content">
-        <span id="tooltip-close-${instanceId}" class="tooltip-close">×</span>
-        <div id="tooltip-text-${instanceId}" class="tooltip-text"></div>
-        <img id="tooltip-image-${instanceId}" class="tooltip-image" src="" alt="" style="display: none;" />
-      </div>
-    </div>
-  `;
-
-  // Insérer dans le DOM
-  scriptTag.parentNode.appendChild(widgetContainer);
-
-  // 6) Références DOM de l’instance
-  const viewerContainerElem = document.getElementById('viewer-container-' + instanceId);
-  const fullscreenToggle = document.getElementById('fullscreen-toggle-' + instanceId);
-  const helpToggle = document.getElementById('help-toggle-' + instanceId);
-  const helpCloseBtn = document.getElementById('help-close-' + instanceId);
-  const resetCameraBtn = document.getElementById('reset-camera-btn-' + instanceId);
-  const tooltipsToggleBtn = document.getElementById('tooltips-toggle-' + instanceId);
-  const menuContent = document.getElementById('menu-content-' + instanceId);
-  const helpTextDiv = menuContent.querySelector('.help-text');
-
-  const tooltipPanel = document.getElementById('tooltip-panel-' + instanceId);
-  const tooltipTextDiv = document.getElementById('tooltip-text-' + instanceId);
-  const tooltipImage = document.getElementById('tooltip-image-' + instanceId);
-  const tooltipCloseBtn = document.getElementById('tooltip-close-' + instanceId);
-
-  // 7) Aide / textes
-  const isIOS = /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
-  const isMobile = isIOS || /Android/i.test(navigator.userAgent);
-
-  const tooltipInstruction = config.tooltips_url
-    ? '- ⦿ : annotations.<br>'
-    : '';
-
-  if (isMobile) {
-    helpTextDiv.innerHTML =
-      "- Déplacement avec deux doigts.<br>" +
-      "- Rotation avec un doigt.<br>" +
-      '- Zoom en pinçant avec deux doigts.<br>' +
-      tooltipInstruction +
-      '- ⟲ réinitialisation de la caméra.<br>' +
-      '- ⇱ plein écran.<br>';
-  } else {
-    helpTextDiv.innerHTML =
-      '- Rotation avec le clic droit ou maj + ←↑↓→<br>' +
-      '- Zoom avec la molette ou ctrl + ↑↓<br>' +
-      '- Déplacement avec le clic gauche ou ←↑↓→<br>' +
-      tooltipInstruction +
-      '- ⟲ réinitialisation de la caméra.<br>' +
-      '- ⇱ plein écran.<br>';
+    app.root.addChild(sphere);
+    tooltipEntities.push(sphere);
   }
 
-  // 8) Sizing dynamique du panneau d’aide
-  function setMenuContentMaxSize() {
-    if (!isMobile) {
-      menuContent.style.maxWidth = '';
-      menuContent.style.maxHeight = '';
-      menuContent.style.width = '';
-      menuContent.style.height = '';
-      menuContent.style.overflowY = '';
-      menuContent.style.overflowX = '';
-      return;
-    }
-    const parent = viewerContainerElem;
-    if (parent) {
-      const vw = parent.offsetWidth;
-      const vh = parent.offsetHeight;
-      if (vw && vh) {
-        menuContent.style.maxWidth = Math.round(vw * 0.8) + 'px';
-        menuContent.style.maxHeight = Math.round(vh * 0.8) + 'px';
-        menuContent.style.width = '';
-        menuContent.style.height = '';
-        menuContent.style.overflowY = 'auto';
-        menuContent.style.overflowX = 'auto';
-      } else {
-        menuContent.style.maxWidth = '80vw';
-        menuContent.style.maxHeight = '80vh';
-        menuContent.style.overflowY = 'auto';
-        menuContent.style.overflowX = 'auto';
-      }
-    }
+  // --- Gestion de la visibilité des tooltips ---
+  function setTooltipsVisibility(visible) {
+    tooltipEntities.forEach(ent => { ent.enabled = visible; });
   }
+  setTooltipsVisibility(!!defaultVisible);
 
-  setMenuContentMaxSize();
-  window.addEventListener('resize', setMenuContentMaxSize);
-  document.addEventListener('fullscreenchange', setMenuContentMaxSize);
-  window.addEventListener('orientationchange', setMenuContentMaxSize);
-
-  // 9) Aide visible par défaut
-  menuContent.style.display = 'block';
-  viewerContainerElem.style.display = 'block';
+  // Écouteur externe (ex. UI HTML) pour afficher/masquer les tooltips
+  document.addEventListener("toggle-tooltips", (evt) => {
+    const { visible } = evt.detail;
+    setTooltipsVisibility(!!visible);
+  });
 
-  // 10) Gestion du panneau tooltips
-  let dragHide = null;
+  // --- Picking (détection de clic sur un tooltip) ---
+  let currentTween = null;
 
-  function hideTooltipPanel() {
-    if (dragHide) {
-      viewerContainerElem.removeEventListener('pointermove', dragHide);
-      dragHide = null;
+  app.mouse.on(pc.EVENT_MOUSEDOWN, (event) => {
+    // Si une interpolation est en cours, on l'arrête proprement
+    if (currentTween) {
+      app.off("update", currentTween);
+      currentTween = null;
     }
-    tooltipPanel.style.display = 'none';
-  }
 
-  function hideHelpPanel() {
-    menuContent.style.display = 'none';
-  }
+    const x = event.x, y = event.y;
+    const from = new pc.Vec3(), to = new pc.Vec3();
+    const camera = cameraEntity.camera;
 
-  // 11) Charger viewer.js (avec cache-busting par instance)
-  let viewerModule;
-  try {
-    const viewerUrl = `https://mikafil-viewer-sgos.static.hf.space/viewer.js?inst=${instanceId}`;
-    viewerModule = await import(viewerUrl);
-    await viewerModule.initializeViewer(config, instanceId);
-  } catch (err) {
-    return;
-  }
+    // Ray picking écran -> monde
+    camera.screenToWorld(x, y, camera.nearClip, from);
+    camera.screenToWorld(x, y, camera.farClip, to);
 
-  const canvasId = 'canvas-' + instanceId;
-  const canvasEl = document.getElementById(canvasId);
+    const dir = new pc.Vec3().sub2(to, from).normalize();
 
-  // 12) Bouton tooltips : cacher si URL non valide
-  if (tooltipsToggleBtn) {
-    if (!config.tooltips_url) {
-      tooltipsToggleBtn.style.display = 'none';
-    } else {
-      fetch(config.tooltips_url)
-        .then((resp) => {
-          if (!resp.ok) tooltipsToggleBtn.style.display = 'none';
-        })
-        .catch(() => {
-          tooltipsToggleBtn.style.display = 'none';
-        });
-    }
-  }
+    let closestT = Infinity;
+    let pickedEntity = null;
 
-  // 13) Interactions locales / tooltips
-  if (canvasEl) {
-    canvasEl.addEventListener('wheel', hideTooltipPanel, { passive: true });
-  }
+    // Test d'intersection rayon/sphère (simple et suffisant ici)
+    for (const ent of tooltipEntities) {
+      if (!ent.enabled) continue;
 
-  document.addEventListener('tooltip-selected', (evt) => {
-    // Toujours afficher le panneau, annuler un hide différé si présent
-    if (dragHide) {
-      viewerContainerElem.removeEventListener('pointermove', dragHide);
-      dragHide = null;
-    }
-
-    const { title, description, imgUrl } = evt.detail || {};
-    tooltipTextDiv.innerHTML = `<strong>${title || ''}</strong><br>${description || ''}`;
+      const center = ent.getPosition();
+      const worldRadius = 0.5 * ent.getLocalScale().x;
 
-    // Forcer un repaint : nettoyer src avant de réassigner
-    tooltipImage.style.display = 'none';
-    tooltipImage.src = '';
-
-    if (imgUrl) {
-      tooltipImage.onload = () => {
-        tooltipImage.style.display = 'block';
-      };
-      tooltipImage.src = imgUrl;
-    } else {
-      tooltipImage.style.display = 'none';
-    }
+      const oc = new pc.Vec3().sub2(center, from);
+      const tca = oc.dot(dir);
+      if (tca < 0) continue;
 
-    tooltipPanel.style.display = 'flex';
-
-    // Fermer en cas de drag (après un petit délai pour éviter un flicker)
-    setTimeout(() => {
-      dragHide = (e) => {
-        if (
-          (e.pointerType === 'mouse' && e.buttons !== 0) ||
-          e.pointerType === 'touch'
-        ) {
-          hideTooltipPanel();
-        }
-      };
-      viewerContainerElem.addEventListener('pointermove', dragHide);
-    }, 100);
-  });
+      const d2 = oc.lengthSq() - (tca * tca);
+      if (d2 > worldRadius * worldRadius) continue;
 
-  // 14) Fullscreen
-  let isFullscreen = false;
-  let savedState = null;
-
-  function saveCurrentState() {
-    if (isFullscreen) return;
-    const originalAspect =
-      widgetContainer.getAttribute('data-original-aspect') || aspectPercent;
-
-    savedState = {
-      widget: {
-        position: widgetContainer.style.position,
-        top: widgetContainer.style.top,
-        left: widgetContainer.style.left,
-        width: widgetContainer.style.width,
-        height: widgetContainer.style.height,
-        maxWidth: widgetContainer.style.maxWidth,
-        maxHeight: widgetContainer.style.maxHeight,
-        paddingBottom: widgetContainer.style.paddingBottom || originalAspect,
-        margin: widgetContainer.style.margin
-      },
-      viewer: {
-        borderRadius: viewerContainerElem.style.borderRadius,
-        border: viewerContainerElem.style.border
+      const thc = Math.sqrt(worldRadius * worldRadius - d2);
+      const t0 = tca - thc;
+      if (t0 < closestT && t0 >= 0) {
+        closestT = t0;
+        pickedEntity = ent;
       }
-    };
-  }
-
-  function restoreOriginalStyles() {
-    if (!savedState) return;
-    const aspectToUse = savedState.widget.paddingBottom;
-
-    widgetContainer.style.position = savedState.widget.position || '';
-    widgetContainer.style.top = savedState.widget.top || '';
-    widgetContainer.style.left = savedState.widget.left || '';
-    widgetContainer.style.width = '100%';
-    widgetContainer.style.height = '0';
-    widgetContainer.style.maxWidth = savedState.widget.maxWidth || '';
-    widgetContainer.style.maxHeight = savedState.widget.maxHeight || '';
-    widgetContainer.style.paddingBottom = aspectToUse;
-    widgetContainer.style.margin = savedState.widget.margin || '';
-    widgetContainer.classList.remove('fake-fullscreen');
-
-    viewerContainerElem.style.position = 'absolute';
-    viewerContainerElem.style.top = '0';
-    viewerContainerElem.style.left = '0';
-    viewerContainerElem.style.right = '0';
-    viewerContainerElem.style.bottom = '0';
-    viewerContainerElem.style.width = '100%';
-    viewerContainerElem.style.height = '100%';
-    viewerContainerElem.style.borderRadius = savedState.viewer.borderRadius || '';
-    viewerContainerElem.style.border = savedState.viewer.border || '';
-
-    if (viewerModule.app) {
-      viewerModule.app.resizeCanvas(
-        viewerContainerElem.clientWidth,
-        viewerContainerElem.clientHeight
-      );
     }
 
-    if (fullscreenToggle) fullscreenToggle.textContent = '⇱';
-
-    savedState = null;
-    setMenuContentMaxSize();
-  }
+    if (pickedEntity) {
+      // Notifier l'UI (titre, description, image)
+      const { title, description, imgUrl } = pickedEntity.tooltipData;
+      document.dispatchEvent(new CustomEvent("tooltip-selected", {
+        detail: { title, description, imgUrl }
+      }));
 
-  function applyFullscreenStyles() {
-    widgetContainer.style.position = 'fixed';
-    widgetContainer.style.top = '0';
-    widgetContainer.style.left = '0';
-    widgetContainer.style.width = '100vw';
-    widgetContainer.style.height = '100vh';
-    widgetContainer.style.maxWidth = '100vw';
-    widgetContainer.style.maxHeight = '100vh';
-    widgetContainer.style.paddingBottom = '0';
-    widgetContainer.style.margin = '0';
-    widgetContainer.style.border = 'none';
-    widgetContainer.style.borderRadius = '0';
-
-    viewerContainerElem.style.width = '100%';
-    viewerContainerElem.style.height = '100%';
-    viewerContainerElem.style.borderRadius = '0';
-    viewerContainerElem.style.border = 'none';
-
-    if (viewerModule.app) {
-      viewerModule.app.resizeCanvas(window.innerWidth, window.innerHeight);
+      // Si on a une position caméra cible, on l'utilise
+      const desiredCamPos = pickedEntity.tooltipData.camTarget;
+      tweenCameraToTooltip(pickedEntity, moveDuration, desiredCamPos);
     }
+  });
 
-    if (fullscreenToggle) fullscreenToggle.textContent = '⇲';
-    isFullscreen = true;
-    setMenuContentMaxSize();
+  // --- Helpers math/angles ---
+  function shortestAngleDiff(target, current) {
+    // Retourne l'écart angulaire [-180, 180] pour interpoler par le plus court chemin
+    let delta = target - current;
+    delta = ((delta + 180) % 360 + 360) % 360 - 180;
+    return delta;
   }
 
-  function enterFullscreen() {
-    if (!savedState) saveCurrentState();
-
-    if (isIOS) {
-      applyFullscreenStyles();
-      widgetContainer.classList.add('fake-fullscreen');
-    } else if (widgetContainer.requestFullscreen) {
-      widgetContainer
-        .requestFullscreen()
-        .then(applyFullscreenStyles)
-        .catch(() => {
-          applyFullscreenStyles();
-          widgetContainer.classList.add('fake-fullscreen');
-        });
-    } else {
-      applyFullscreenStyles();
-      widgetContainer.classList.add('fake-fullscreen');
-    }
+  /**
+   * Calcule {yaw, pitch, distance} pour une caméra à cameraPos regardant pivotPos,
+   * selon la convention de l'orbitCamera.
+   */
+  function computeOrbitFromPositions(cameraPos, pivotPos) {
+    const tempEnt = new pc.Entity();
+    tempEnt.setPosition(cameraPos);
+    tempEnt.lookAt(pivotPos);
+
+    const rotation = tempEnt.getRotation();
+
+    // Direction "forward" (de la caméra vers le pivot)
+    const forward = new pc.Vec3();
+    rotation.transformVector(pc.Vec3.FORWARD, forward);
+
+    // Yaw : rotation horizontale
+    const rawYaw = Math.atan2(-forward.x, -forward.z) * pc.math.RAD_TO_DEG;
+
+    // Pitch : on retire d'abord l'influence du yaw pour isoler la composante verticale
+    const yawQuat = new pc.Quat().setFromEulerAngles(0, -rawYaw, 0);
+    const rotNoYaw = new pc.Quat().mul2(yawQuat, rotation);
+    const fNoYaw = new pc.Vec3();
+    rotNoYaw.transformVector(pc.Vec3.FORWARD, fNoYaw);
+    const rawPitch = Math.atan2(fNoYaw.y, -fNoYaw.z) * pc.math.RAD_TO_DEG;
+
+    // Distance : norme du vecteur pivot - caméra
+    const toPivot = new pc.Vec3().sub2(pivotPos, cameraPos);
+    const dist = toPivot.length();
+
+    tempEnt.destroy();
+    return { yaw: rawYaw, pitch: rawPitch, distance: dist };
   }
 
-  function exitFullscreen() {
-    if (document.fullscreenElement === widgetContainer && document.exitFullscreen) {
-      document.exitFullscreen().catch(() => {});
-    }
-    widgetContainer.classList.remove('fake-fullscreen');
-    restoreOriginalStyles();
-    isFullscreen = false;
-    if (fullscreenToggle) fullscreenToggle.textContent = '⇱';
-    setMenuContentMaxSize();
-  }
-
-  fullscreenToggle.addEventListener('click', () => {
-    hideTooltipPanel();
-    isFullscreen ? exitFullscreen() : enterFullscreen();
-  });
-
-  document.addEventListener('fullscreenchange', () => {
-    if (!document.fullscreenElement && isFullscreen) {
-      isFullscreen = false;
-      restoreOriginalStyles();
-      if (fullscreenToggle) fullscreenToggle.textContent = '⇱';
-    } else if (document.fullscreenElement === widgetContainer) {
-      if (fullscreenToggle) fullscreenToggle.textContent = '⇲';
-    }
-    setMenuContentMaxSize();
-  });
-
-  // 15) Aide / boutons
-  helpToggle.addEventListener('click', (e) => {
-    hideTooltipPanel();
-    e.stopPropagation();
-    if (menuContent.style.display === 'block') {
-      menuContent.style.display = 'none';
+  /**
+   * Animation caméra vers un tooltip.
+   * - tooltipEnt: entité du tooltip cliqué
+   * - duration: durée de l'interpolation (s)
+   * - overrideCamWorldPos (pc.Vec3|null): si fourni, la caméra ira EXACTEMENT à cette position
+   *   tout en regardant le tooltip.
+   */
+  function tweenCameraToTooltip(tooltipEnt, duration, overrideCamWorldPos = null) {
+    const orbitCam = cameraEntity.script && cameraEntity.script.orbitCamera;
+    if (!orbitCam) return;
+
+    const targetPos = tooltipEnt.getPosition().clone();
+
+    // État initial (depuis l'orbitCamera)
+    const startPivot = orbitCam.pivotPoint.clone();
+    const startYaw = orbitCam._yaw;
+    const startPitch = orbitCam._pitch;
+    const startDist = orbitCam._distance;
+
+    // Valeurs finales à déterminer
+    let endPivot = targetPos.clone();
+    let endYaw, endPitch, endDist;
+
+    if (overrideCamWorldPos) {
+      // --- Nouveau mode : position caméra imposée par le JSON ---
+      // On calcule l'orbite (yaw/pitch/dist) qui correspond exactement à cette position
+      const { yaw, pitch, distance } = computeOrbitFromPositions(overrideCamWorldPos, targetPos);
+
+      // Interpolation par le plus court chemin depuis l'état courant
+      endYaw = startYaw + shortestAngleDiff(yaw, startYaw);
+      endPitch = startPitch + shortestAngleDiff(pitch, startPitch);
+      endDist = distance;
     } else {
-      menuContent.style.display = 'block';
-      setMenuContentMaxSize();
+      // --- Comportement historique (aucune camX/Y/Z fournie) ---
+      const worldRadius = 0.5 * tooltipEnt.getLocalScale().x;
+      const minZoom = orbitCam.distanceMin || 0.1;
+      const desiredDistance = Math.max(minZoom * 1.2, worldRadius * 4);
+
+      // On garde la position caméra actuelle comme point de départ pour calculer les angles
+      const camWorldPos = cameraEntity.getPosition().clone();
+      const { yaw, pitch } = computeOrbitFromPositions(camWorldPos, targetPos);
+
+      endYaw = startYaw + shortestAngleDiff(yaw, startYaw);
+      endPitch = startPitch + shortestAngleDiff(pitch, startPitch);
+      endDist = desiredDistance;
     }
-  });
 
-  helpCloseBtn.addEventListener('click', hideHelpPanel);
+    // Sauvegarde des origines pour l'interpolation
+    const orgPivot = startPivot.clone();
+    const orgYaw = startYaw;
+    const orgPitch = startPitch;
+    const orgDist = startDist;
 
-  resetCameraBtn.addEventListener('click', () => {
-    hideTooltipPanel();
-    if (viewerModule.resetViewerCamera) {
-      viewerModule.resetViewerCamera();
-    }
-  });
-
-  if (tooltipsToggleBtn) {
-    let tooltipsVisible = !!config.showTooltipsDefault;
-    tooltipsToggleBtn.style.opacity = tooltipsVisible ? '1' : '0.5';
-    tooltipsToggleBtn.addEventListener('click', () => {
-      hideTooltipPanel();
-      tooltipsVisible = !tooltipsVisible;
-      tooltipsToggleBtn.style.opacity = tooltipsVisible ? '1' : '0.5';
-      document.dispatchEvent(
-        new CustomEvent('toggle-tooltips', { detail: { visible: tooltipsVisible } })
-      );
-    });
-  }
-
-  tooltipCloseBtn.addEventListener('click', hideTooltipPanel);
+    let elapsed = 0;
 
-  // 16) Échappement / resize
-  document.addEventListener('keydown', (e) => {
-    if ((e.key === 'Escape' || e.key === 'Esc') && isFullscreen) {
-      exitFullscreen();
+    // Si une interpolation était déjà en cours, on la débranche
+    if (currentTween) {
+      app.off("update", currentTween);
+      currentTween = null;
     }
-  });
 
-  window.addEventListener('resize', () => {
-    if (viewerModule.app) {
-      if (isFullscreen) {
-        viewerModule.app.resizeCanvas(window.innerWidth, window.innerHeight);
-      } else {
-        viewerModule.app.resizeCanvas(
-          viewerContainerElem.clientWidth,
-          viewerContainerElem.clientHeight
-        );
+    // --- Lerp frame-by-frame ---
+    function lerpUpdate(dt) {
+      elapsed += dt;
+      const t = Math.min(elapsed / duration, 1);
+
+      // Pivot (regard) vers le tooltip
+      const newPivot = new pc.Vec3().lerp(orgPivot, endPivot, t);
+      orbitCam.pivotPoint.copy(newPivot);
+
+      // Yaw, Pitch, Distance (on met aussi les "target" pour rester cohérent avec le script orbitCamera)
+      const newYaw = pc.math.lerp(orgYaw, endYaw, t);
+      const newPitch = pc.math.lerp(orgPitch, endPitch, t);
+      const newDist = pc.math.lerp(orgDist, endDist, t);
+
+      orbitCam._targetYaw = newYaw;
+      orbitCam._yaw = newYaw;
+      orbitCam._targetPitch = newPitch;
+      orbitCam._pitch = newPitch;
+      orbitCam._targetDistance = newDist;
+      orbitCam._distance = newDist;
+
+      // Mise à jour de la position monde de la caméra à partir des paramètres d'orbite
+      orbitCam._updatePosition();
+
+      if (t >= 1) {
+        app.off("update", lerpUpdate);
+        currentTween = null;
       }
     }
-    setMenuContentMaxSize();
-  });
 
-  // 17) Init par défaut
-  setTimeout(() => {
-    // Sauvegarder l’état non-fullscreen
-    saveCurrentState();
-    // Propager l’état par défaut des tooltips
-    document.dispatchEvent(
-      new CustomEvent('toggle-tooltips', { detail: { visible: !!config.showTooltipsDefault } })
-    );
-    setMenuContentMaxSize();
-  }, 200);
-})();
+    currentTween = lerpUpdate;
+    app.on("update", lerpUpdate);
+  }
+}