Update tooltips.js

tooltips.js

@@ -155,43 +155,45 @@ export async function initializeTooltips(options) {
     const targetPos = tooltipEnt.getPosition().clone();
     // Compute current state
     const startPivot   = orbitCam.pivotPoint.clone();
-    const startYaw     = orbitCam._yaw;
-    const startPitch   = orbitCam._pitch;
-    const startDist    = orbitCam._distance;
+    const startYaw     = orbitCam._yaw;       // current yaw in degrees
+    const startPitch   = orbitCam._pitch;     // current pitch in degrees
+    const startDist    = orbitCam._distance;  // current 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 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
+    // Compute raw desired yaw/pitch from camera pointing at targetPos
+    // Create a temporary entity to compute the correct orientation
     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);
-    // Raw yaw and pitch from tempEnt
-    let tgtYaw = Math.atan2(-forward.x, -forward.z) * pc.math.RAD_TO_DEG;
-    // Compute pitch (the _calcPitch logic):
-    const yawQuat = new pc.Quat().setFromEulerAngles(0, -tgtYaw, 0);
+
+    // 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 rotNoYaw = new pc.Quat().mul2(yawQuat, rotation);
     const fNoYaw = new pc.Vec3();
     rotNoYaw.transformVector(pc.Vec3.FORWARD, fNoYaw);
-    let tgtPitch = Math.atan2(fNoYaw.y, -fNoYaw.z) * pc.math.RAD_TO_DEG;
+    const rawDesiredPitch = Math.atan2(fNoYaw.y, -fNoYaw.z) * pc.math.RAD_TO_DEG;
+
     tempEnt.destroy();
 
-    // Adjust yaw to follow the shortest path from current yaw to target yaw
-    const currentYaw = startYaw;
-    let deltaYaw = tgtYaw - currentYaw;
-    // Wrap into [-180, +180]
-    deltaYaw = ((deltaYaw + 180) % 360) - 180;
-    const endYaw = currentYaw + deltaYaw;
+    // 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;
 
-    // For pitch, since it’s usually within [-90, +90], direct assignment is fine
-    const endPitch = tgtPitch;
     const endDist  = desiredDistance;
 
     let elapsed = 0;
@@ -215,17 +217,20 @@ export async function initializeTooltips(options) {
       const newPivot = new pc.Vec3().lerp(orgPivot, targetPos, t);
       orbitCam.pivotPoint.copy(newPivot);
 
-      // Interpolate yaw/pitch/distance (simple lerp)
-      const newYaw   = pc.math.lerp(orgYaw,   endYaw,   t);
+      // Interpolate yaw numerically: since endYaw is continuous relative to startYaw
+      const newYaw = pc.math.lerp(orgYaw, endYaw, t);
+      // Interpolate pitch normally (no wrapping needed)
       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;
+      // 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;
+      orbitCam._distance = newDist;
+      orbitCam._targetDistance = endDist;
 
       orbitCam._updatePosition();