Make right drag follow mouse

Author: levinli303

src/celengine/observer.cpp

@@ -9,7 +9,9 @@
 // of the License, or (at your option) any later version.
 
 #include <numeric>
+#include <optional>
 #include <celmath/geomutil.h>
+#include <celmath/intersect.h>
 #include <celmath/mathlib.h>
 #include <celmath/solve.h>
 #include "body.h"
@@ -29,7 +31,10 @@ namespace math = celestia::math;
 
 #define VELOCITY_CHANGE_TIME      0.25f
 
-static Vector3d slerp(double t, const Vector3d& v0, const Vector3d& v1)
+namespace
+{
+
+Vector3d slerp(double t, const Vector3d& v0, const Vector3d& v1)
 {
     double r0 = v0.norm();
     double r1 = v1.norm();
@@ -46,6 +51,19 @@ static Vector3d slerp(double t, const Vector3d& v0, const Vector3d& v1)
     return (cos(theta * t) * u + sin(theta * t) * v) * math::lerp(t, r0, r1);
 }
 
+std::optional<Eigen::Vector3d> getNearIntersectionPoint(const Eigen::ParametrizedLine<double, 3>& ray,
+                                         const math::Sphered& sphere)
+{
+    double distance;
+    bool intersects = math::testIntersection(ray, sphere, distance);
+    if (intersects)
+        return ray.origin() + distance * ray.direction();
+    else
+        return std::nullopt;
+}
+
+}
+
 
 /*! Notes on the Observer class
  *  The values position and orientation are in observer's reference frame. positionUniv
@@ -909,6 +927,50 @@ void Observer::orbit(const Selection& selection, const Quaternionf& q)
     }
 }
 
+/*! Orbit around the reference object (if there is one.)  rotating the object with intersection point from
+ *  a direction to another. If there is no intersection point, return false.
+ */
+bool Observer::orbit(const Selection& selection, const Eigen::Vector3f &from, const Eigen::Vector3f &to)
+{
+    Selection center = frame->getRefObject();
+    if (center.empty())
+    {
+        if (selection.empty())
+            return false;
+        center = selection;
+    }
+
+    double radius = center.radius();
+    if (radius <= 0.0)
+        return false;
+
+    // Get the focus position (center of rotation) in frame
+    // coordinates; in order to make this function work in all
+    // frames of reference, it's important to work in frame
+    // coordinates.
+    UniversalCoord focusPosition = center.getPosition(getTime());
+    focusPosition = frame->convertFromUniversal(focusPosition, getTime());
+
+    Eigen::Vector3d objectCenter = focusPosition.offsetFromKm(position);
+
+    // Get the rays adjusted to orientation
+    Eigen::Vector3d transformedFrom = getOrientation().conjugate() * from.cast<double>();
+    Eigen::Vector3d transformedTo = getOrientation().conjugate() * to.cast<double>();
+
+    // Find intersections for the rays, if no intersection, return false
+    math::Sphered sphere { objectCenter, radius };
+    auto orbitStartPosition = getNearIntersectionPoint(Eigen::ParametrizedLine<double, 3>(Eigen::Vector3d::Zero(), transformedFrom), sphere);
+    if (!orbitStartPosition.has_value())
+        return false;
+
+    auto orbitEndPosition = getNearIntersectionPoint(Eigen::ParametrizedLine<double, 3>(Eigen::Vector3d::Zero(), transformedTo), sphere);
+    if (!orbitEndPosition.has_value())
+        return false;
+
+    orbit(selection, Eigen::Quaterniond::FromTwoVectors(transformedOrientation * (orbitStartPosition.value() - objectCenter), transformedOrientation * (orbitEndPosition.value() - objectCenter)).cast<float>());
+    return true;
+}
+
 
 /*! Exponential camera dolly--move toward or away from the selected object
  * at a rate dependent on the observer's distance from the object.

src/celengine/observer.h

@@ -148,6 +148,7 @@ class Observer
     void           update(double dt, double timeScale);
 
     void orbit(const Selection&, const Eigen::Quaternionf &q);
+    bool orbit(const Selection&, const Eigen::Vector3f &from, const Eigen::Vector3f &to);
     void rotate(const Eigen::Quaternionf &q);
     void changeOrbitDistance(const Selection&, float d);
     void setTargetSpeed(float s);

src/celengine/simulation.cpp

@@ -258,6 +258,12 @@ void Simulation::orbit(const Eigen::Quaternionf& q)
     activeObserver->orbit(selection, q);
 }
 
+// Orbit around the selection (if there is one.)  This involves changing
+// both the observer's position and orientation.
+bool Simulation::orbit(const Eigen::Vector3f& from, const Eigen::Vector3f& to)
+{
+    return activeObserver->orbit(selection, from, to);
+}
 
 // Exponential camera dolly--move toward or away from the selected object
 // at a rate dependent on the observer's distance from the object.

src/celengine/simulation.h

@@ -50,6 +50,7 @@ class Simulation
 
     Universe* getUniverse() const;
 
+    bool orbit(const Eigen::Vector3f& from, const Eigen::Vector3f& to);
     void orbit(const Eigen::Quaternionf& q);
     void rotate(const Eigen::Quaternionf& q);
     void changeOrbitDistance(float d);

src/celestia/celestiacore.cpp

@@ -412,6 +412,8 @@ void CelestiaCore::mouseButtonDown(float x, float y, int button)
     newLocation.y = y;
     dragLocation = newLocation;
 
+    dragStartFromSurface = std::nullopt;
+
 #ifdef CELX
     if (m_script != nullptr)
     {
@@ -435,6 +437,7 @@ void CelestiaCore::mouseButtonDown(float x, float y, int button)
 void CelestiaCore::mouseButtonUp(float x, float y, int button)
 {
     dragLocation = std::nullopt;
+    dragStartFromSurface = std::nullopt;
 
     // Four pixel tolerance for picking
     float obsPickTolerance = sim->getActiveObserver()->getFOV() / static_cast<float>(metrics.height) * this->pickTolerance;
@@ -656,21 +659,36 @@ void CelestiaCore::mouseMove(float dx, float dy, int modifiers)
                 flash(fmt::sprintf(_("Magnitude limit: %.2f"), sim->getFaintestVisible()));
             }
         }
-        else if ((modifiers & RightButton) != 0)
-        {
-            // Adjust the rotation rate based on the distance from the reference object.
-            float coarseness = ComputeRotationCoarseness(*sim);
-
-            Quaternionf q = math::XRotation(dy / static_cast<float>(metrics.height) * coarseness) *
-                            math::YRotation(dx / static_cast<float>(metrics.width) * coarseness);
-            sim->orbit(q);
-        }
         else if (oldLocation.has_value() && dragLocation.has_value())
         {
             auto view = viewManager->activeView();
             auto oldPickRay = getPickRay(oldLocation.value().x, oldLocation.value().y, view);
             auto newPickRay = getPickRay(dragLocation.value().x, dragLocation.value().y, view);
-            sim->rotate(Eigen::Quaternionf::FromTwoVectors(oldPickRay, newPickRay));
+            if ((modifiers & RightButton) != 0)
+            {
+                if (bool isDragStartDetermined = dragStartFromSurface.has_value(); !isDragStartDetermined || dragStartFromSurface.value())
+                {
+                    // The drag started from the surface or we are not sure yet, try to perform a surface drag
+                    bool surfaceDrag = sim->orbit(oldPickRay, newPickRay);
+
+                    if (!isDragStartDetermined)
+                        dragStartFromSurface = surfaceDrag;
+                }
+
+                if (!dragStartFromSurface.value())
+                {
+                    // Adjust the rotation rate based on the distance from the reference object.
+                    float coarseness = ComputeRotationCoarseness(*sim);
+
+                    Quaternionf q = math::XRotation(dy / static_cast<float>(metrics.height) * coarseness) *
+                    math::YRotation(dx / static_cast<float>(metrics.width) * coarseness);
+                    sim->orbit(q);
+                }
+            }
+            else
+            {
+                sim->rotate(Eigen::Quaternionf::FromTwoVectors(oldPickRay, newPickRay));
+            }
         }
 
         mouseMotion += abs(dy) + abs(dx);
@@ -2220,8 +2238,8 @@ Eigen::Vector3f CelestiaCore::getPickRay(float x, float y, const celestia::View
     float pickY;
     float aspectRatio = static_cast<float>(metrics.width) / static_cast<float>(metrics.height);
     view->mapWindowToView(x / static_cast<float>(metrics.width),
-                                               y / static_cast<float>(metrics.height),
-                                               pickX, pickY);
+                          y / static_cast<float>(metrics.height),
+                          pickX, pickY);
     pickX *= aspectRatio;
     if (isViewportEffectUsed)
         viewportEffect->distortXY(pickX, pickY);

src/celestia/celestiacore.h

@@ -500,7 +500,8 @@ class CelestiaCore // : public Watchable<CelestiaCore>
         float x;
         float y;
     };
-    std::optional<MouseLocation> dragLocation{ std::nullopt };
+    std::optional<MouseLocation> dragLocation { std::nullopt };
+    std::optional<bool> dragStartFromSurface { std::nullopt };
 
     std::unique_ptr<ViewportEffect> viewportEffect { nullptr };
     bool isViewportEffectUsed { false };