Update interface.js

interface.js

@@ -1,294 +1,454 @@
-// 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;
+// interface.js
+// ==============================
+
+const currentScriptTag = document.currentScript;
+
+(async function() {
+  // 1. Locate the <script> and read 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];
+    }
   }
-  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
-    };
 
-    app.root.addChild(sphere);
-    tooltipEntities.push(sphere);
+  const configUrl = scriptTag.getAttribute('data-config');
+  let config = {};
+  if (configUrl) {
+    try {
+      const response = await fetch(configUrl);
+      config = await response.json();
+    } catch (error) {
+      console.error("Could not load config: " + error);
+      return;
+    }
+  } else {
+    console.error("No configUrl found for viewer");
+    return;
   }
 
-  // --- Gestion de la visibilité des tooltips ---
-  function setTooltipsVisibility(visible) {
-    tooltipEntities.forEach(ent => { ent.enabled = visible; });
+  // 2. Inject CSS if specified
+  if (config.css_url) {
+    const linkEl = document.createElement('link');
+    linkEl.rel = "stylesheet";
+    linkEl.href = config.css_url;
+    document.head.appendChild(linkEl);
   }
-  setTooltipsVisibility(!!defaultVisible);
 
-  // Écouteur externe (ex. UI HTML) pour afficher/masquer les tooltips
-  document.addEventListener("toggle-tooltips", (evt) => {
-    const { visible } = evt.detail;
-    setTooltipsVisibility(!!visible);
-  });
+  // 3. Setup unique instanceId for this widget
+  const instanceId = Math.random().toString(36).substr(2, 8);
+
+  // 4. Calculate aspect ratio (for padding-bottom hack)
+  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 {
+    // fallback: try to use parent container's aspect
+    const parentContainer = scriptTag.parentNode;
+    const containerWidth  = parentContainer.offsetWidth;
+    const containerHeight = parentContainer.offsetHeight;
+    if (containerWidth > 0 && containerHeight > 0) {
+      aspectPercent = (containerHeight / containerWidth * 100) + "%";
+    }
+  }
 
-  // --- Picking (détection de clic sur un tooltip) ---
-  let currentTween = null;
+  // 5. Create the widget container and controls
+  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>`
+    : '';
+
+  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" class="tooltip-panel" style="display: none;">
+      <div class="tooltip-content">
+        <span id="tooltip-close" class="tooltip-close">×</span>
+        <div id="tooltip-text" class="tooltip-text"></div>
+        <img id="tooltip-image" class="tooltip-image" src="" alt="" style="display: none;" />
+      </div>
+    </div>
+  `;
+
+  scriptTag.parentNode.appendChild(widgetContainer);
+
+  // 6. Grab references for UI controls
+  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');
+  const tooltipTextDiv      = document.getElementById('tooltip-text');
+  const tooltipImage        = document.getElementById('tooltip-image');
+  const tooltipCloseBtn     = document.getElementById('tooltip-close');
+
+  const isIOS    = /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
+  const isMobile = isIOS || /Android/i.test(navigator.userAgent);
+
+  const tooltipInstruction = config.tooltips_url
+    ? '- Cliquez sur ⦿ pour afficher/masquer les tooltips.<br>'
+    : '';
+
+  if (isMobile) {
+    helpTextDiv.innerHTML = 
+      '- Déplacez vous en glissant deux doigts sur l\'écran.<br>' +
+      '- Orbitez en glissant un doigt.<br>' +
+      '- Zoomez en pinçant avec deux doigts.<br>' +
+      tooltipInstruction +
+      '- Cliquez sur ⟲ pour réinitialiser la caméra.<br>' +
+      '- Cliquez sur ⇱ pour passer en plein écran.<br>';
+  } else {
+    helpTextDiv.innerHTML = 
+      '- Orbitez avec le clic droit<br>' +
+      '- Zoomez avec la molette<br>' +
+      '- Déplacez vous avec le clic gauche<br>' +
+      tooltipInstruction +
+      '- Cliquez sur ⟲ pour réinitialiser la caméra.<br>' +
+      '- Cliquez sur ⇱ pour passer en plein écran.<br>';
+  }
 
-  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;
+  // --- DYNAMIC MENU SIZING ---
+  function setMenuContentMaxSize() {
+    if (!isMobile) {
+      menuContent.style.maxWidth  = "";
+      menuContent.style.maxHeight = "";
+      menuContent.style.width     = "";
+      menuContent.style.height    = "";
+      menuContent.style.overflowY = "";
+      menuContent.style.overflowX = "";
+      return;
     }
+    let 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 = "";  // Let it shrink if smaller
+        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";
+      }
+    }
+  }
+  setMenuContentMaxSize();
+  window.addEventListener('resize', setMenuContentMaxSize);
+  document.addEventListener('fullscreenchange', setMenuContentMaxSize);
+  window.addEventListener('orientationchange', setMenuContentMaxSize);
 
-    const x = event.x, y = event.y;
-    const from = new pc.Vec3(), to = new pc.Vec3();
-    const camera = cameraEntity.camera;
-
-    // Ray picking écran -> monde
-    camera.screenToWorld(x, y, camera.nearClip, from);
-    camera.screenToWorld(x, y, camera.farClip, to);
+  // --- HELP PANEL DEFAULT VISIBILITY ---
+  menuContent.style.display = 'block';
 
-    const dir = new pc.Vec3().sub2(to, from).normalize();
+  viewerContainerElem.style.display = 'block';
 
-    let closestT = Infinity;
-    let pickedEntity = null;
+  let dragHide = null;
 
-    // Test d'intersection rayon/sphère (simple et suffisant ici)
-    for (const ent of tooltipEntities) {
-      if (!ent.enabled) continue;
+  function hideTooltipPanel() {
+    if (dragHide) {
+      viewerContainerElem.removeEventListener('pointermove', dragHide);
+      dragHide = null;
+    }
+    tooltipPanel.style.display = 'none';
+  }
+  function hideHelpPanel() {
+    menuContent.style.display = 'none';
+  }
 
-      const center = ent.getPosition();
-      const worldRadius = 0.5 * ent.getLocalScale().x;
+  // 7. Dynamically load viewer.js (modern ES2024 import, always fresh load)
+  let viewerModule;
+  try {
+    viewerModule = await import('https://mikafil-viewer-sgos.static.hf.space/viewer.js?' + Date.now());
+    await viewerModule.initializeViewer(config, instanceId);
+  } catch (err) {
+    console.error("Could not load viewer.js: " + err);
+    return;
+  }
 
-      const oc = new pc.Vec3().sub2(center, from);
-      const tca = oc.dot(dir);
-      if (tca < 0) continue;
+  // 8. Canvas reference (for tooltips and resizing)
+  const canvasId = 'canvas-' + instanceId;
+  const canvasEl = document.getElementById(canvasId);
 
-      const d2 = oc.lengthSq() - (tca * tca);
-      if (d2 > worldRadius * worldRadius) continue;
+  // 9. Tooltips toggle if any
+  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'; });
+    }
+  }
 
-      const thc = Math.sqrt(worldRadius * worldRadius - d2);
-      const t0 = tca - thc;
-      if (t0 < closestT && t0 >= 0) {
-        closestT = t0;
-        pickedEntity = ent;
+  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,
       }
+    };
+  }
+
+  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 (pickedEntity) {
-      // Notifier l'UI (titre, description, image)
-      const { title, description, imgUrl } = pickedEntity.tooltipData;
-      document.dispatchEvent(new CustomEvent("tooltip-selected", {
-        detail: { title, description, imgUrl }
-      }));
+    if (fullscreenToggle) fullscreenToggle.textContent = '⇱';
+
+    savedState = null;
+    setMenuContentMaxSize();
+  }
 
-      // Si on a une position caméra cible, on l'utilise
-      const desiredCamPos = pickedEntity.tooltipData.camTarget;
-      tweenCameraToTooltip(pickedEntity, moveDuration, desiredCamPos);
+  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);
     }
-  });
 
-  // --- 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;
+    if (fullscreenToggle) fullscreenToggle.textContent = '⇲';
+    isFullscreen = true;
+    setMenuContentMaxSize();
   }
 
-  /**
-   * 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 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');
+    }
   }
 
-  /**
-   * 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;
+  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();
+  });
+
+  helpToggle.addEventListener('click', (e) => {
+    hideTooltipPanel();
+    e.stopPropagation();
+    // Toggle menu panel
+    if (menuContent.style.display === 'block') {
+      menuContent.style.display = 'none';
     } else {
-      // --- 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;
+      menuContent.style.display = 'block';
+      setMenuContentMaxSize();
     }
+  });
+  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();
+    }
+  });
 
-    let elapsed = 0;
+  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);
 
-    // Si une interpolation était déjà en cours, on la débranche
-    if (currentTween) {
-      app.off("update", currentTween);
-      currentTween = null;
+  document.addEventListener('tooltip-selected', (evt) => {
+    // Always show panel, cancel hide first
+    if (dragHide) {
+      viewerContainerElem.removeEventListener('pointermove', dragHide);
+      dragHide = null;
+    }
+    const { title, description, imgUrl } = evt.detail;
+    tooltipTextDiv.innerHTML = `<strong>${title}</strong><br>${description}`;
+    // Force a repaint: clear src before setting, for repeated images
+    tooltipImage.style.display = 'none';
+    tooltipImage.src = '';
+    if (imgUrl) {
+      tooltipImage.onload = () => {
+        tooltipImage.style.display = 'block';
+      };
+      tooltipImage.src = imgUrl;
+    } else {
+      tooltipImage.style.display = 'none';
     }
+    tooltipPanel.style.display = 'flex';
+    // --- DELAYED pointermove handler ---
+    setTimeout(() => {
+      dragHide = (e) => {
+        if ((e.pointerType === 'mouse' && e.buttons !== 0) || e.pointerType === 'touch') {
+          hideTooltipPanel();
+        }
+      };
+      viewerContainerElem.addEventListener('pointermove', dragHide);
+    }, 100);
+  });
 
-    // --- 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;
+  if (canvasEl) {
+    canvasEl.addEventListener('wheel', hideTooltipPanel, { passive: true });
+  }
+  document.addEventListener('keydown', (e) => {
+    if ((e.key === 'Escape' || e.key === 'Esc') && isFullscreen) exitFullscreen();
+  });
+  window.addEventListener('resize', () => {
+    if (viewerModule.app) {
+      if (isFullscreen) {
+        viewerModule.app.resizeCanvas(window.innerWidth, window.innerHeight);
+      } else {
+        viewerModule.app.resizeCanvas(
+          viewerContainerElem.clientWidth,
+          viewerContainerElem.clientHeight
+        );
       }
     }
+    setMenuContentMaxSize();
+  });
 
-    currentTween = lerpUpdate;
-    app.on("update", lerpUpdate);
-  }
-}
+  setTimeout(() => {
+    saveCurrentState();
+    document.dispatchEvent(new CustomEvent('toggle-tooltips', { detail: { visible: !!config.showTooltipsDefault } }));
+    setMenuContentMaxSize();
+  }, 200);
+
+})();