Update tooltips.js

tooltips.js

@@ -4,30 +4,17 @@
  * initializeTooltips(options)
  *
  * - options.app: the PlayCanvas AppBase instance
- * - options.cameraEntity: PlayCanvas camera Entity (utilisant le script orbitCamera)
+ * - options.cameraEntity: PlayCanvas camera Entity
  * - 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
+    modelEntity,
     tooltipsUrl,
     defaultVisible,
     moveDuration = 0.6
@@ -35,20 +22,16 @@ export async function initializeTooltips(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;
-  }
+  } catch (e) { return; }
   if (!Array.isArray(tooltipsData)) return;
 
   const tooltipEntities = [];
 
-  // --- Matériau des sphères (tooltips) ---
+  // Create a material for tooltip spheres (still use StandardMaterial, works fine)
   const mat = new pc.StandardMaterial();
   mat.diffuse = new pc.Color(1, 0.8, 0);
   mat.specular = new pc.Color(1, 1, 1);
@@ -58,51 +41,35 @@ export async function initializeTooltips(options) {
   mat.useLighting = false;
   mat.update();
 
-  // --- Création des entités sphères pour chaque tooltip ---
+  // Build each tooltip sphere + attach custom data
   for (let i = 0; i < tooltipsData.length; i++) {
     const tt = tooltipsData[i];
-    const { x, y, z, title, description, imgUrl, camX, camY, camZ } = tt;
+    const { x, y, z, title, description, imgUrl } = 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
-    };
-
+    sphere.tooltipData = { title, description, imgUrl };
     app.root.addChild(sphere);
     tooltipEntities.push(sphere);
   }
 
-  // --- Gestion de la visibilité des tooltips ---
   function setTooltipsVisibility(visible) {
     tooltipEntities.forEach(ent => { ent.enabled = visible; });
   }
   setTooltipsVisibility(!!defaultVisible);
 
-  // Écouteur externe (ex. UI HTML) pour afficher/masquer les tooltips
   document.addEventListener("toggle-tooltips", (evt) => {
     const { visible } = evt.detail;
     setTooltipsVisibility(!!visible);
   });
 
-  // --- Picking (détection de clic sur un tooltip) ---
   let currentTween = 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;
@@ -112,7 +79,6 @@ export async function initializeTooltips(options) {
     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);
 
@@ -121,7 +87,6 @@ export async function initializeTooltips(options) {
     let closestT = Infinity;
     let pickedEntity = null;
 
-    // Test d'intersection rayon/sphère (simple et suffisant ici)
     for (const ent of tooltipEntities) {
       if (!ent.enabled) continue;
 
@@ -144,130 +109,77 @@ export async function initializeTooltips(options) {
     }
 
     if (pickedEntity) {
-      // Notifier l'UI (titre, description, image)
       const { title, description, imgUrl } = pickedEntity.tooltipData;
       document.dispatchEvent(new CustomEvent("tooltip-selected", {
         detail: { title, description, imgUrl }
       }));
-
-      // Si on a une position cam��ra cible, on l'utilise
-      const desiredCamPos = pickedEntity.tooltipData.camTarget;
-      tweenCameraToTooltip(pickedEntity, moveDuration, desiredCamPos);
+      tweenCameraToTooltip(pickedEntity, moveDuration);
     }
   });
 
-  // --- Helpers math/angles ---
+  // Camera animation
   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;
   }
 
-  /**
-   * 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);
+  function tweenCameraToTooltip(tooltipEnt, duration) {
+    const orbitCam = cameraEntity.script.orbitCamera;
+    if (!orbitCam) return;
 
-    const rotation = tempEnt.getRotation();
+    const targetPos = tooltipEnt.getPosition().clone();
+    const startPivot = orbitCam.pivotPoint.clone();
+    const startYaw = orbitCam._yaw;
+    const startPitch = orbitCam._pitch;
+    const startDist = orbitCam._distance;
+
+    const worldRadius = 0.5 * tooltipEnt.getLocalScale().x;
+    const minZoom = orbitCam.distanceMin;
+    const desiredDistance = Math.max(minZoom * 1.2, worldRadius * 4);
 
-    // Direction "forward" (de la caméra vers le pivot)
+    const camWorldPos = cameraEntity.getPosition().clone();
+    const tempEnt = new pc.Entity();
+    tempEnt.setPosition(camWorldPos);
+    tempEnt.lookAt(targetPos);
+    const rotation = tempEnt.getRotation();
     const forward = new pc.Vec3();
     rotation.transformVector(pc.Vec3.FORWARD, forward);
+    const rawTgtYaw = Math.atan2(-forward.x, -forward.z) * pc.math.RAD_TO_DEG;
+    const yawDelta = shortestAngleDiff(rawTgtYaw, startYaw);
+    const endYaw = startYaw + yawDelta;
 
-    // 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 yawQuat = new pc.Quat().setFromEulerAngles(0, -rawTgtYaw, 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();
+    const rawTgtPitch = Math.atan2(fNoYaw.y, -fNoYaw.z) * pc.math.RAD_TO_DEG;
+    const pitchDelta = shortestAngleDiff(rawTgtPitch, startPitch);
+    const endPitch = startPitch + pitchDelta;
 
     tempEnt.destroy();
-    return { yaw: rawYaw, pitch: rawPitch, distance: dist };
-  }
-
-  /**
-   * 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 {
-      // --- 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;
-    }
+    const endPivot = targetPos.clone();
+    const endDist = desiredDistance;
 
-    // Sauvegarde des origines pour l'interpolation
+    let elapsed = 0;
     const orgPivot = startPivot.clone();
     const orgYaw = startYaw;
     const orgPitch = startPitch;
     const orgDist = startDist;
 
-    let elapsed = 0;
-
-    // Si une interpolation était déjà en cours, on la débranche
     if (currentTween) {
       app.off("update", currentTween);
       currentTween = null;
     }
 
-    // --- 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);
@@ -279,7 +191,6 @@ export async function initializeTooltips(options) {
       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) {