Merge remote-tracking branch 'haydelj/cameraSaveFix' into dipole_movement.

Rotate/scale/translate are working. All widget parts update together.
Fixed arcball and lighting update while rotating

Author: tpat

src/Externals/spire/arc-ball/ArcBall.cpp

@@ -1,22 +1,23 @@
 #include "ArcBall.hpp"
+#include <iostream>
 
 namespace spire {
 
 //------------------------------------------------------------------------------
-ArcBall::ArcBall(const glm::vec3& center, glm::float_t radius, const glm::mat4& screenToTCS) :
+  ArcBall::ArcBall(const glm::vec3& center, glm::float_t radius, bool inverted, const glm::mat4& screenToTCS) :
+    mScreenToTCS(screenToTCS),
+    invertHemisphere(inverted),
     mCenter(center),
-    mRadius(radius),
-    mScreenToTCS(screenToTCS)
+    mRadius(radius)
 {
   // glm uses the following format for quaternions: w,x,y,z.
   //        w,    x,    y,    z
   glm::quat qOne(1.0, 0.0, 0.0, 0.0);
   glm::vec3 vZero(0.0, 0.0, 0.0);
 
-  mVDown    = vZero;
-  mVNow     = vZero;
-  mQDown    = qOne;
-  mQNow     = qOne;
+  mQDown       = qOne;
+  mQNow        = qOne;
+  mVSphereDown = mouseOnSphere(vZero);
 }
 
 //------------------------------------------------------------------------------
@@ -28,86 +29,66 @@ glm::vec3 ArcBall::mouseOnSphere(const glm::vec3& tscMouse)
   ballMouse.x = (tscMouse.x - mCenter.x) / mRadius;
   ballMouse.y = (tscMouse.y - mCenter.y) / mRadius;
 
-  glm::float_t mag = glm::dot(ballMouse, ballMouse);
-  if (mag > 1.0)
+  glm::float_t mag_sq = glm::dot(ballMouse, ballMouse);
+  if (mag_sq > 1.0)
   {
-    // Since we are outside of the sphere, map to the visible boundary of
-    // the sphere.
-    ballMouse *= 1.0 / sqrtf(mag);
-    ballMouse.z = 0.0;
+    // Since we are outside of the sphere, map to the visible boundary of the sphere.
+    ballMouse *= 1.0 / sqrtf(mag_sq);
   }
   else
   {
-    // We are not at the edge of the sphere, we are inside of it.
-    // Essentially, we are normalizing the vector by adding the missing z
-    // component.
-    ballMouse.z = sqrtf(1.0 - mag);
+    // Essentially, we are normalizing the vector by adding the missing z component.
+    ballMouse.z = sqrtf(1.0 - mag_sq);
   }
 
+  if(invertHemisphere)
+    ballMouse.z = -ballMouse.z;
+
   return ballMouse;
 }
 
 //------------------------------------------------------------------------------
 void ArcBall::beginDrag(const glm::vec2& msc)
 {
-  // The next two lines are usually a part of end drag. But end drag introduces
-  // too much statefullness, so we are shortcircuiting it.
-  mQDown      = mQNow;
-
-  // Normal 'begin' code.
-  mVDown      = (mScreenToTCS * glm::vec4(msc.x, msc.y, 0.0f, 1.0)).xyz();
+  mQDown       = mQNow;
+  mVSphereDown = mouseOnSphere((mScreenToTCS * glm::vec4(msc, 0.0f, 1.0)).xyz());
 }
 
 //------------------------------------------------------------------------------
 void ArcBall::drag(const glm::vec2& msc)
 {
-  // Regular drag code to follow...
-  mVNow       = (mScreenToTCS * glm::vec4(msc.x, msc.y, 0.0, 1.0)).xyz();
-  mVSphereFrom= mouseOnSphere(mVDown);
-  mVSphereTo  = mouseOnSphere(mVNow);
+  glm::vec3 mVSphereNow = mouseOnSphere((mScreenToTCS * glm::vec4(msc, 0.0, 1.0)).xyz());
 
   // Construct a quaternion from two points on the unit sphere.
-  mQDrag = quatFromUnitSphere(mVSphereFrom, mVSphereTo);
+  glm:: quat mQDrag = quatFromUnitSphere(mVSphereDown, mVSphereNow);
   mQNow = mQDrag * mQDown;
-
-  // Perform complex conjugate
-  glm::quat q = mQNow;
-  q.x = -q.x;
-  q.y = -q.y;
-  q.z = -q.z;
-  q.w =  q.w;
-  mMatNow = glm::mat4_cast(q);
+  if(glm::dot(mVSphereDown, mVSphereNow) < 0.0)
+    beginDrag(msc);
 }
 
 //------------------------------------------------------------------------------
 void ArcBall::setLocationOnSphere(glm::vec3 location, glm::vec3 up)
 {
-  mMatNow = glm::lookAt(location, glm::vec3(0.0f), up);
-  glm::quat q = glm::quat_cast(mMatNow);
-  q.x = -q.x;
-  q.y = -q.y;
-  q.z = -q.z;
-  q.w = q.w;
-  mQNow = q;
-
+  glm::mat4 mMatNow = glm::lookAt(location, glm::vec3(0.0f), up);
+  mQNow   = glm::quat_cast(mMatNow);
 }
 
 //------------------------------------------------------------------------------
 glm::quat ArcBall::quatFromUnitSphere(const glm::vec3& from, const glm::vec3& to)
 {
-  glm::quat q;
-  q.x = from.y*to.z - from.z*to.y;
-  q.y = from.z*to.x - from.x*to.z;
-  q.z = from.x*to.y - from.y*to.x;
-  q.w = from.x*to.x + from.y*to.y + from.z*to.z;
-  return q;
+  glm::vec3 axis = glm::normalize(glm::cross(from, to));
+  float angle = std::acos(glm::dot(from, to));
+
+  if(angle <= 0.00001)
+    return glm::quat(1.0, 0.0, 0.0, 0.0);
+
+  return glm::angleAxis(angle, axis);
 }
 
 //------------------------------------------------------------------------------
 glm::mat4 ArcBall::getTransformation() const
 {
-  return mMatNow;
+  return glm::mat4_cast(mQNow);
 }
 
-
 } // namespace spire

src/Externals/spire/arc-ball/ArcBall.hpp

@@ -35,8 +35,8 @@ class SCISHARE ArcBall
   ///                       default is 0.75.
   /// \param screenToTCS    Transformation from screen coordinates
   ///                       to TCS. \p center and \p radius are given in TCS.
-  ArcBall(const glm::vec3& center, glm::float_t radius,
-          const glm::mat4& screenToTCS = glm::mat4());
+ArcBall(const glm::vec3& center, glm::float_t radius, bool inverted = false,
+        const glm::mat4& screenToTCS = glm::mat4());
 
   /// Initiate an arc ball drag given the mouse click in screen coordinates.
   /// \param mouseScreenCoords  Mouse screen coordinates.
@@ -57,6 +57,9 @@ class SCISHARE ArcBall
   /// from mQNow.
   glm::mat4 getTransformation() const;
 
+  glm::quat getQuat() const {return mQNow;}
+  void setQuat(const glm::quat q) {mQNow = q;}
+
 private:
 
   /// Calculates our position on the ArcBall from 2D mouse position.
@@ -66,25 +69,18 @@ class SCISHARE ArcBall
   /// Construct a unit quaternion from two points on the unit sphere.
   static glm::quat quatFromUnitSphere(const glm::vec3& from, const glm::vec3& to);
 
+  /// Transform from screen coordinates to the target coordinate system.
+  glm::mat4     mScreenToTCS;
   glm::vec3     mCenter;        ///< Center of the arcball in target coordinate system.
   glm::float_t  mRadius;        ///< Radius of the arcball in target coordinate system.
+  bool  invertHemisphere;
 
+  glm::vec3     mVSphereDown;   ///< vDown mapped to the sphere of 'mRadius' centered at 'mCenter' in TCS.
+  glm::quat     mQDown;         ///< State of the rotation since mouse down.
   glm::quat     mQNow;          ///< Current state of the rotation taking into account mouse.
                                 ///< Essentially QDrag * QDown (QDown is a applied first, just
                                 ///< as in matrix multiplication).
-  glm::quat     mQDown;         ///< State of the rotation since mouse down.
-  glm::quat     mQDrag;         ///< Dragged transform. Knows nothing of any prior
-                                ///< transformations.
 
-  glm::vec3     mVNow;          ///< Most current TCS position of mouse (during drag).
-  glm::vec3     mVDown;         ///< TCS position of mouse when the drag was begun.
-  glm::vec3     mVSphereFrom;   ///< vDown mapped to the sphere of 'mRadius' centered at 'mCenter' in TCS.
-  glm::vec3     mVSphereTo;     ///< vNow mapped to the sphere of 'mRadius' centered at 'mCenter' in TCS.
-
-  glm::mat4     mMatNow;        ///< Matrix representing the current rotation.
-
-  /// Transform from screen coordinates to the target coordinate system.
-  glm::mat4     mScreenToTCS;
 };
 
 } // namespace spire

src/Externals/spire/arc-look-at/ArcLookAt.cpp

@@ -35,11 +35,7 @@
 namespace spire {
 
 //------------------------------------------------------------------------------
-ArcLookAt::ArcLookAt() :
-    mArcBall(new ArcBall(glm::vec3(0.0f, 0.0f, 0.0f), 1.0f)),
-    mCamLookAt(0.0f),
-    mCamDistance(3.0f),
-    mReferenceCamDistance(0.0f)
+ArcLookAt::ArcLookAt() : mArcBall(new ArcBall(glm::vec3(0.0f, 0.0f, 0.0f), 1.0f))
 {
 }
 
@@ -51,10 +47,8 @@ ArcLookAt::~ArcLookAt()
 //------------------------------------------------------------------------------
 void ArcLookAt::doReferenceDown(const glm::vec2& ssPos)
 {
-  mReferenceLookAt      = mCamLookAt;
   mReferenceScreenPos   = ssPos;
-  mReferenceTransform   = getWorldViewTransform();
-  mReferenceCamDistance = mCamDistance;
+  mReferenceLookAt      = mCamLookAt;
 
   mArcBall->beginDrag(ssPos);
 }
@@ -65,10 +59,10 @@ void ArcLookAt::doPan(const glm::vec2& ssPos)
   glm::vec2 delta = mReferenceScreenPos - ssPos;
   glm::vec2 trans = delta * mCamDistance / 2.0f;
 
-  glm::mat4 camRot = mArcBall->getTransformation();
-  glm::vec3 translation =
-        static_cast<glm::vec3>(camRot[0]) * trans.x
-      + static_cast<glm::vec3>(camRot[1]) * trans.y;
+  glm::mat4 camRot = glm::affineInverse(mArcBall->getTransformation());
+  glm::vec3 translation = static_cast<glm::vec3>(camRot[0]) * trans.x
+                        + static_cast<glm::vec3>(camRot[1]) * trans.y;
+
   mCamLookAt = mReferenceLookAt + translation;
 }
 
@@ -78,21 +72,6 @@ void ArcLookAt::doRotation(const glm::vec2& ssPos)
   mArcBall->drag(ssPos);
 }
 
-//------------------------------------------------------------------------------
-void ArcLookAt::doZoom(glm::float_t camZoom)
-{
-  //mCamDistance += camZoom;
-
-  glm::float_t prevDistance = mCamDistance;
-  camZoom /= 65;
-  camZoom *= prevDistance;
-  mCamDistance += camZoom;
-  if (mCamDistance <= 0)
-  {
-    mCamDistance = prevDistance;
-  }
-}
-
 //------------------------------------------------------------------------------
 void ArcLookAt::doZoom(glm::float_t camZoom, int zoomSpeed)
 {
@@ -102,9 +81,7 @@ void ArcLookAt::doZoom(glm::float_t camZoom, int zoomSpeed)
   camZoom *= prevDistance;
   mCamDistance += camZoom;
   if (mCamDistance <= 0)
-  {
     mCamDistance = prevDistance;
-  }
 }
 
 //------------------------------------------------------------------------------
@@ -115,30 +92,22 @@ void ArcLookAt::doZoom(const glm::vec2& ssPos)
   glm::vec2 delta = ssPos - mReferenceScreenPos;
   glm::float_t xScale = 4.0f;
   glm::float_t yScale = 4.0f;
-  //mCamDistance = mReferenceCamDistance + (delta.x) * xScale + (-delta.y) * yScale;
 
 	glm::float_t prevDistance = mCamDistance;
 	glm::float_t camZoom = mCamDistance + (delta.x) * xScale + (-delta.y) * yScale;
 	mCamDistance = camZoom;
 	if (mCamDistance <= 0)
-	{
 		mCamDistance = prevDistance;
-	}
 }
 
 //------------------------------------------------------------------------------
 glm::mat4 ArcLookAt::getWorldViewTransform() const
 {
-  glm::mat4 camRot      = mArcBall->getTransformation();
-  glm::mat4 finalTrafo  = camRot;
-
-  // Translation is a post rotation operation where as zoom is a pre transform
-  // operation. We should probably ensure the user doesn't scroll passed zero.
-  // Remember, we are looking down NEGATIVE z.
-  // NOTE: We are translating both the lookat and the eye point.
-  // Eyepoint is a function of the lookat, the camera transform, and the
-  // camera distance.
-  finalTrafo[3].xyz() = mCamLookAt + static_cast<glm::vec3>(camRot[2]) * mCamDistance;
+  glm::mat4 finalTrafo;
+  finalTrafo[3].xyz() = -mCamLookAt;
+  finalTrafo          = mArcBall->getTransformation() * finalTrafo;
+  finalTrafo[3][2]   += -mCamDistance;
+
   return finalTrafo;
 }
 
@@ -161,27 +130,19 @@ void ArcLookAt::autoview(const spire::AABB& bbox, float fov)
   }
 
   mCamLookAt = bbox.getCenter();
-
-  // We are calculating the distance the camera would need to be away from
-  // the length of the diagonal of the bbox. See Van Dam, Foley, third edition
-  // page 304:
-
-  //    AC = f*tan(O(v)/2)
-  // => f = AC / tan(O(v)/2)
-  // Where AC is half the size of the diagonal.
-  // So, takning into account half the size:
-  // => f = AC / (2 * tan(O(v) / 2)
-
   mCamDistance = w / (2 * tan(fov / 2.0));
 }
 
 //------------------------------------------------------------------------------
 void ArcLookAt::setView(const glm::vec3& view, const glm::vec3& up)
 {
   mReferenceLookAt = mCamLookAt;
-  glm::vec3 location = mCamDistance * view;
+  glm::vec3 location = mCamDistance * -view;
   mArcBall->setLocationOnSphere(location, up);
   mCamLookAt = mReferenceLookAt;
 }
 
+glm::quat ArcLookAt::getRotation() const {return mArcBall->getQuat();}
+void ArcLookAt::setRotation(const glm::quat q) {mArcBall->setQuat(q);}
+
 } // namespace spire

src/Externals/spire/arc-look-at/ArcLookAt.hpp

@@ -75,13 +75,9 @@ class SCISHARE ArcLookAt
   /// Rotates about the look at position.
   void doRotation(const glm::vec2& ssPos);
 
-  /// Dollys the camera towards(negative) / away(positive) from the look at
-  /// point.
-  void doZoom(glm::float_t camZoom);
-
   /// Dollys the camera towards(negative) / away(positive) from the look at
   /// point. With vairiable zoomspeed.
-  void doZoom(glm::float_t camZoom, int zoomSpeed);
+  void doZoom(glm::float_t camZoom, int zoomSpeed = 65);
 
   /// Uses a custom function to determine camera zoom. Downwards and to the
   /// right increases size, upwards or to the left decreases size
@@ -98,10 +94,15 @@ class SCISHARE ArcLookAt
   void setView(const glm::vec3& view, const glm::vec3& up);
 
   /// Retrieves the camera's distance away from the look at point.
-  glm::float_t getCamDistance() const   {return mCamDistance;}
+  glm::float_t getDistance() const {return mCamDistance;}
+  void setDistance(const glm::float_t f) {mCamDistance = f;}
 
   /// Retrieves the current lookat point.
-  glm::vec3 getLookAt() const   {return mCamLookAt;}
+  glm::vec3 getLookAt() const {return mCamLookAt;}
+  void setLookAt(const glm::vec3 v) {mCamLookAt = v;}
+
+  glm::quat getRotation() const;
+  void setRotation(const glm::quat q);
 
   /// Retrieves the world transformation for the camera (looking down
   /// negative z).
@@ -110,14 +111,12 @@ class SCISHARE ArcLookAt
 private:
   std::unique_ptr<spire::ArcBall>  mArcBall;
 
-  glm::vec3                 mCamLookAt;     ///< Current lookat position.
-  glm::float_t              mCamDistance;   ///< Distance from look-at.
+  glm::vec3                 mCamLookAt   {0.0f};     ///< Current lookat position.
+  glm::float_t              mCamDistance {3.0f};   ///< Distance from look-at.
 
   // The following are reference variables set when doReferenceDown is called.
   glm::vec2                 mReferenceScreenPos;
   glm::vec3                 mReferenceLookAt;
-  glm::mat4                 mReferenceTransform;
-  glm::float_t              mReferenceCamDistance;
 };
 
 } // namespace spire