Merge pull request #1966 from Haydelj/cameraSaveFix

Camera Save Fix/General Fixes

Author: dcwhite

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

@@ -4,19 +4,18 @@ namespace spire {
 
 //------------------------------------------------------------------------------
 ArcBall::ArcBall(const glm::vec3& center, glm::float_t radius, const glm::mat4& screenToTCS) :
+    mScreenToTCS(screenToTCS),
     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);
 }
 
 //------------------------------------------------------------------------------
@@ -31,16 +30,12 @@ glm::vec3 ArcBall::mouseOnSphere(const glm::vec3& tscMouse)
   glm::float_t mag = glm::dot(ballMouse, ballMouse);
   if (mag > 1.0)
   {
-    // Since we are outside of the sphere, map to the visible boundary of
-    // the sphere.
+    // Since we are outside of the sphere, map to the visible boundary of the sphere.
     ballMouse *= 1.0 / sqrtf(mag);
-    ballMouse.z = 0.0;
   }
   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.
+    // Essentially, we are normalizing the vector by adding the missing z component.
     ballMouse.z = sqrtf(1.0 - mag);
   }
 
@@ -50,46 +45,25 @@ glm::vec3 ArcBall::mouseOnSphere(const glm::vec3& tscMouse)
 //------------------------------------------------------------------------------
 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);
 }
 
 //------------------------------------------------------------------------------
 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);
 }
 
 //------------------------------------------------------------------------------
@@ -106,8 +80,7 @@ glm::quat ArcBall::quatFromUnitSphere(const glm::vec3& from, const glm::vec3& to
 //------------------------------------------------------------------------------
 glm::mat4 ArcBall::getTransformation() const
 {
-  return mMatNow;
+  return glm::mat4_cast(mQNow);
 }
 
-
 } // namespace spire

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

@@ -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,17 @@ 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.
 
+  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

src/Externals/spire/es-general/comp/StaticCamera.hpp

@@ -15,9 +15,9 @@ namespace gen {
 // care anything about the camera itself.
 struct StaticCameraData
 {
-  glm::mat4 projIV;           // projection * iv
-  glm::mat4 worldToView;      // Inverse view (iv)
-  glm::mat4 projection;       // Projection matrix.
+  glm::mat4 view;
+  glm::mat4 projection;
+  glm::mat4 viewProjection;
 
   // Misc variables. fovy only applies to perspective matrices.
   float fovy;
@@ -51,24 +51,23 @@ struct StaticCameraData
     winWidth   = 0.0f;
   }
 
-  void setView(const glm::mat4& view)
+  void setView(const glm::mat4& view_in)
   {
-    worldToView = glm::affineInverse(view);
-    projIV = projection * worldToView;
+    view = view_in;
+    viewProjection = projection * view;
   }
 
-  void setProjection(const glm::mat4& projectionIn, float fovy_in, float aspect_in,
+  void setProjection(const glm::mat4& projection_in, float fovy_in, float aspect_in,
                      float znear_in, float zfar_in)
   {
-    fovy   = fovy_in;
-    aspect = aspect_in;
-    znear  = znear_in;
-    zfar   = zfar_in;
-
-    projection = projectionIn;
+    projection = projection_in;
+    fovy       = fovy_in;
+    aspect     = aspect_in;
+    znear      = znear_in;
+    zfar       = zfar_in;
 
     // Setup frustum details.
-		float zDist = fabs(zfar - znear);
+		float zDist  = fabs(zfar - znear);
 		float tanVal = tanf(0.5f * (fovy));
 		//for (int i = 0; i < mNumFrustumSections + 1; i++)
 
@@ -214,9 +213,9 @@ struct StaticCameraData
     zppHHeight = std::get<1>(halfWH);
   }
 
-  glm::mat4 getView() const
+  glm::mat4 getInverseView() const
   {
-    return glm::affineInverse(worldToView);
+    return glm::affineInverse(view);
   }
 };