fix bugs with center projection, adjust clip plane policies, clean up view API

Author: nmwsharp

include/polyscope/view.h

@@ -113,14 +113,15 @@ void setVerticalFieldOfViewDegrees(float newVal);
 glm::mat4 computeHomeView();
 void resetCameraToHomeView();
 void flyToHomeView();
-void setViewCenter(glm::vec3 newCenter, bool flyTo = false);
+void setViewCenterAndLookAt(glm::vec3 newCenter, bool flyTo = false);
+void setViewCenterAndProject(glm::vec3 newCenter);
+void setViewCenterRaw(glm::vec3 newCenter);
 glm::vec3 getViewCenter();
 
 // These both set the new value, and project the current view as-needed to conform to the new setting
 void updateViewAndChangeNavigationStyle(NavigateStyle newStyle, bool flyTo = false);
 void updateViewAndChangeUpDir(UpDir newUpDir, bool flyTo = false);
 void updateViewAndChangeFrontDir(FrontDir newFrontDir, bool flyTo = false);
-void updateViewAndChangeCenter(glm::vec3 newCenter, bool flyTo = false);
 
 // Move the camera with a 'flight' where the camera's position is briefly animated
 void startFlightTo(const CameraParameters& p, float flightLengthInSeconds = .4);
@@ -169,8 +170,6 @@ std::string getCameraJson(); // DEPRACTED: old names for avove
 void setCameraFromJson(std::string jsonData, bool flyTo);
 
 // Misc helpers
-std::string to_string(ProjectionMode mode);
-std::string to_string(NavigateStyle style);
 std::tuple<int, int> screenCoordsToBufferInds(glm::vec2 screenCoords);
 glm::ivec2 screenCoordsToBufferIndsVec(glm::vec2 screenCoords);
 glm::vec2 bufferIndsToScreenCoords(int xPos, int yPos);
@@ -197,11 +196,15 @@ void ensureViewValid();
 
 float computeRelativeMotionScale();
 
+// For some navigation modes, the view and center must be compatible (e.g.) with turntable the view
+// must point at the center along the up axis. This function modifies the center as-needed to ensure compatibility.
+void projectCenterToBeValidForView();
+
 // Process user inputs which affect the view
 void processTranslate(glm::vec2 delta);
 void processRotate(glm::vec2 startP, glm::vec2 endP);
 void processClipPlaneShift(float amount);
-void processZoom(float amount, bool relativeToCenter = false);
+void processZoom(float amount);
 void processKeyboardNavigation(ImGuiIO& io);
 void processSetCenter(glm::vec2 screenCoords);
 

src/polyscope.cpp

@@ -464,25 +464,23 @@ void processInputEvents() {
         float xoffset = io.MouseWheelH;
         float yoffset = io.MouseWheel;
         float scrollOffset = yoffset;
+        float clipPlaneOffset = std::abs(xoffset) > std::abs(yoffset) ? xoffset : yoffset;
 
         // NOTE: here we used to scroll according the to the larger of the two offsets (x or y)
         // (there was a comment about 'shift swaps scroll on some platforms'). However, on many
         // common machines (e.g. macs with touchpads),  two finger scrolling produces both x and y
         // offsets simultaneously, leading to jumpy zooms when an x was greater than a y.
-        // So now we just use the y offset always.
+        // So now we just use the y offset always for zooming. (But still use either for clip plane shifting,
+        // which might involve intentionally holding shift)
 
-        if (scrollOffset != 0.0f) {
+        bool scrollClipPlane = io.KeyShift && !io.KeyCtrl;
+        if (scrollClipPlane && clipPlaneOffset != 0.0f) {
+          view::processClipPlaneShift(clipPlaneOffset);
+          requestRedraw();
+        }
+        if (!scrollClipPlane && scrollOffset != 0.0f) {
+          view::processZoom(0.5 * scrollOffset);
           requestRedraw();
-
-          // Pass camera commands to the camera
-          bool scrollClipPlane = io.KeyShift && !io.KeyCtrl;
-
-          if (scrollClipPlane) {
-            view::processClipPlaneShift(scrollOffset);
-          } else {
-            // always relative
-            view::processZoom(scrollOffset, true);
-          }
         }
       }
 
@@ -502,7 +500,7 @@ void processInputEvents() {
           bool isDragZoom = dragLeft && io.KeyShift && io.KeyCtrl;
 
           if (isDragZoom) {
-            view::processZoom(dragDelta.y * 5, true);
+            view::processZoom(dragDelta.y * 5);
           }
           if (isRotate) {
             glm::vec2 currPos{io.MousePos.x / view::windowWidth,

src/view.cpp

@@ -48,8 +48,8 @@ float& flightInitialFov = state::globalContext.flightInitialFov;
 // Default values
 const int defaultWindowWidth = 1280;
 const int defaultWindowHeight = 720;
-const float defaultNearClipRatio = 1e-2;
-const float defaultFarClipRatio = 1e2;
+const float defaultNearClipRatio = 0.005f;
+const float defaultFarClipRatio = 20.f;
 const float defaultFov = 45.;
 const float minFov = 5.;   // for UI
 const float maxFov = 160.; // for UI
@@ -274,9 +274,11 @@ void processTranslate(glm::vec2 delta) {
     glm::vec3 worldspaceT =
         glm::transpose(glm::mat3(viewMat)) * glm::vec3(-movementScale * delta.x, -movementScale * delta.y, 0.0);
     glm::vec3 newCenter = oldCenter + worldspaceT;
-    setViewCenter(newCenter, false);
+    setViewCenterRaw(newCenter);
   }
 
+  projectCenterToBeValidForView();
+
   requestRedraw();
   immediatelyEndFlight();
 }
@@ -288,7 +290,7 @@ void processClipPlaneShift(float amount) {
   requestRedraw();
 }
 
-void processZoom(float amount, bool relativeToCenter) {
+void processZoom(float amount) {
   if (amount == 0.0) return;
   if (getNavigateStyle() == NavigateStyle::None || getNavigateStyle() == NavigateStyle::FirstPerson) {
     return;
@@ -381,7 +383,7 @@ void processSetCenter(glm::vec2 screenCoords) {
   PickResult pickResult = pickAtScreenCoords(screenCoords);
 
   if (pickResult.isHit) {
-    setViewCenter(pickResult.position, true);
+    setViewCenterAndLookAt(pickResult.position, true);
   }
 }
 
@@ -424,6 +426,36 @@ float computeRelativeMotionScale() {
   }
 }
 
+void projectCenterToBeValidForView() {
+  // If necessary, move the view center to be one that is compatible with the current view matrix and navigation style.
+
+  switch (style) {
+  case NavigateStyle::Turntable: {
+
+    // Center must lie exactly along the camera look direction
+
+    glm::vec3 camPos = getCameraWorldPosition();
+    glm::vec3 camLookDir, camUpDir, camRightDir;
+    getCameraFrame(camLookDir, camUpDir, camRightDir);
+    glm::vec3 sceneUpDir = getUpVec();
+    glm::vec3 vecToCenter = viewCenter - camPos;
+    float distToCenter = glm::length(vecToCenter);
+    glm::vec3 newCenter = camPos + camLookDir * distToCenter;
+
+    setViewCenterRaw(newCenter);
+
+    break;
+  }
+  case NavigateStyle::Planar:
+  case NavigateStyle::Free:
+  case NavigateStyle::Arcball:
+  case NavigateStyle::None:
+  case NavigateStyle::FirstPerson:
+    // No constraints
+    break;
+  }
+}
+
 glm::mat4 computeHomeView() {
 
   glm::vec3 target = view::viewCenter;
@@ -558,7 +590,7 @@ void updateViewAndChangeFrontDir(FrontDir newFrontDir, bool flyTo) {
   }
 }
 
-void updateViewAndChangeCenter(glm::vec3 newCenter, bool flyTo) {
+void setViewCenterAndLookAt(glm::vec3 newCenter, bool flyTo) {
 
   view::viewCenter = newCenter;
 
@@ -594,7 +626,12 @@ void updateViewAndChangeCenter(glm::vec3 newCenter, bool flyTo) {
   }
 }
 
-void setViewCenter(glm::vec3 newCenter, bool flyTo) { updateViewAndChangeCenter(newCenter, flyTo); }
+void setViewCenterAndProject(glm::vec3 newCenter) {
+  view::viewCenter = newCenter;
+  projectCenterToBeValidForView();
+}
+
+void setViewCenterRaw(glm::vec3 newCenter) { view::viewCenter = newCenter; }
 
 glm::vec3 getViewCenter() { return view::viewCenter; }
 
@@ -621,10 +658,12 @@ void lookAt(glm::vec3 cameraLocation, glm::vec3 target, glm::vec3 upDir, bool fl
     // just continue after; our view handling will take care of the NaN and set it to the default view
   }
 
+
   if (flyTo) {
     startFlightTo(targetView, fov);
   } else {
     viewMat = targetView;
+    projectCenterToBeValidForView();
     requestRedraw();
   }
 }
@@ -646,6 +685,7 @@ void setViewToCamera(const CameraParameters& p) {
   fov = p.getFoVVerticalDegrees();
   // aspectRatio = p.focalLengths.x / p.focalLengths.y; // TODO should be
   // flipped?
+  projectCenterToBeValidForView();
 }
 
 CameraParameters getCameraParametersForCurrentView() {
@@ -656,7 +696,11 @@ CameraParameters getCameraParametersForCurrentView() {
                           CameraExtrinsics::fromMatrix(viewMat));
 }
 
-void setCameraViewMatrix(glm::mat4 mat) { viewMat = mat; }
+void setCameraViewMatrix(glm::mat4 mat) {
+  viewMat = mat;
+  projectCenterToBeValidForView();
+  requestRedraw();
+}
 
 glm::mat4 getCameraViewMatrix() { return viewMat; }
 
@@ -778,7 +822,14 @@ glm::vec3 bufferCoordsToWorldRay(glm::vec2 bufferCoords) {
 std::tuple<float, float> computeClipPlanes() {
   float s = computeRelativeMotionScale();
   float absFarClip = farClip * s;
-  float absNearClip = nearClip * s;
+
+  // it's tempting to compute both near and far clip planes from the scale,
+  // but computing the near clip plane this way gives flickering very quickly when zooming in on surface details
+  // float absNearClip = nearClip * s;
+
+  // instead, always use the length scale for the near clip plane
+  float absNearClip = nearClip * state::lengthScale;
+
   return std::make_tuple(absNearClip, absFarClip);
 }
 
@@ -1000,10 +1051,10 @@ void setViewFromJson(std::string jsonData, bool flyTo) {
         newCenter.x = centerData[0];
         newCenter.y = centerData[1];
         newCenter.z = centerData[2];
-        setViewCenter(newCenter, flyTo);
+        setViewCenterRaw(newCenter);
       }
     }
-   
+
     // NOTE: it's important that we do this after the mode/dir settings, as this
     // lets us do our flight
     bool viewChanged = false;
@@ -1027,7 +1078,7 @@ void setViewFromJson(std::string jsonData, bool flyTo) {
       if (flyTo) {
         startFlightTo(newViewMat, fov);
       } else {
-        viewMat = newViewMat;
+        setCameraViewMatrix(newViewMat);
         fov = newFov;
         requestRedraw();
       }