Update tooltips.js

tooltips.js

@@ -155,46 +155,37 @@ export async function initializeTooltips(options) {
     const targetPos = tooltipEnt.getPosition().clone();
     // Compute current state
     const startPivot   = orbitCam.pivotPoint.clone();
-    const startYaw     = orbitCam._yaw;       // current yaw in degrees
-    const startPitch   = orbitCam._pitch;     // current pitch in degrees
-    const startDist    = orbitCam._distance;  // current distance
+    const startYaw     = orbitCam._yaw;
+    const startPitch   = orbitCam._pitch;
+    const startDist    = orbitCam._distance;
 
     // Compute direction & candidate distance:
     const worldRadius  = 0.5 * tooltipEnt.getLocalScale().x;
     const minZoom = orbitCam.distanceMin;
     const desiredDistance = Math.max(minZoom * 1.2, worldRadius * 4);
 
-    // Compute raw desired yaw/pitch from camera pointing at targetPos
-    // Create a temporary entity to compute the correct orientation
+    // Compute target yaw/pitch from camera pointing at targetPos
+    // Reuse reset logic: place a temp entity at camera’s current position, have it look at target
     const camWorldPos = cameraEntity.getPosition().clone();
     const tempEnt = new pc.Entity();
     tempEnt.setPosition(camWorldPos);
     tempEnt.lookAt(targetPos);
     const rotation = tempEnt.getRotation();
-
-    // Use OrbitCamera's own _calcYaw to get a yaw in [-180, 180]
-    const rawDesiredYaw = orbitCam._calcYaw(rotation);
-
-    // Compute raw desired pitch using same approach as OrbitCamera._calcPitch
-    const yawQuat = new pc.Quat().setFromEulerAngles(0, -rawDesiredYaw, 0);
+    const forward = new pc.Vec3();
+    rotation.transformVector(pc.Vec3.FORWARD, forward);
+    const tgtYaw = Math.atan2(-forward.x, -forward.z) * pc.math.RAD_TO_DEG;
+    const yawQuat = new pc.Quat().setFromEulerAngles(0, -tgtYaw, 0);
     const rotNoYaw = new pc.Quat().mul2(yawQuat, rotation);
     const fNoYaw = new pc.Vec3();
     rotNoYaw.transformVector(pc.Vec3.FORWARD, fNoYaw);
-    const rawDesiredPitch = Math.atan2(fNoYaw.y, -fNoYaw.z) * pc.math.RAD_TO_DEG;
-
+    const tgtPitch = Math.atan2(fNoYaw.y, -fNoYaw.z) * pc.math.RAD_TO_DEG;
     tempEnt.destroy();
 
-    // Compute shortest-path delta for yaw: wrap difference into [-180, 180]
-    let deltaYaw = rawDesiredYaw - startYaw;
-    deltaYaw = ((deltaYaw + 180) % 360) - 180; // now in [-180, 180]
-
-    // endYaw remains continuous: startYaw + deltaYaw (no further wrapping)
-    const endYaw = startYaw + deltaYaw;
-
-    // For pitch, we can assign rawDesiredPitch directly; it's within valid range
-    const endPitch = rawDesiredPitch;
-
-    const endDist  = desiredDistance;
+    // Target state:
+    const endPivot   = targetPos.clone();
+    const endYaw     = tgtYaw;
+    const endPitch   = tgtPitch;
+    const endDist    = desiredDistance;
 
     let elapsed = 0;
     const orgPivot = startPivot.clone();
@@ -214,23 +205,20 @@ export async function initializeTooltips(options) {
       const t = Math.min(elapsed / duration, 1);
 
       // Interpolate pivot (vector lerp)
-      const newPivot = new pc.Vec3().lerp(orgPivot, targetPos, t);
+      const newPivot = new pc.Vec3().lerp(orgPivot, endPivot, t);
       orbitCam.pivotPoint.copy(newPivot);
 
-      // Interpolate yaw numerically: since endYaw is continuous relative to startYaw
-      const newYaw = pc.math.lerp(orgYaw, endYaw, t);
-      // Interpolate pitch normally (no wrapping needed)
+      // Interpolate yaw/pitch/distance (simple lerp)
+      const newYaw   = pc.math.lerp(orgYaw,   endYaw,   t);
       const newPitch = pc.math.lerp(orgPitch, endPitch, t);
-      // Interpolate distance
-      const newDist = pc.math.lerp(orgDist, endDist, t);
-
-      // Assign to orbitCam so that _updatePosition() uses them
-      orbitCam._yaw = newYaw;
-      orbitCam._targetYaw = endYaw;
-      orbitCam._pitch = newPitch;
-      orbitCam._targetPitch = endPitch;
+      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;
-      orbitCam._targetDistance = endDist;
 
       orbitCam._updatePosition();