fix pick depth for pretty transparency, read depth from pick buffer, deprecate old functions

Author: nmwsharp

examples/demo-app/demo_app.cpp

@@ -807,7 +807,6 @@ void callback() {
       std::tie(xInd, yInd) = polyscope::view::screenCoordsToBufferInds(screenCoords);
 
       glm::vec3 worldRay = polyscope::view::screenCoordsToWorldRay(screenCoords);
-      glm::vec3 worldPos = polyscope::view::screenCoordsToWorldPosition(screenCoords);
       polyscope::PickResult pickResult = polyscope::queryPickAtScreenCoords(screenCoords);
 
       std::cout << "Polyscope scene test click " << std::endl;
@@ -817,7 +816,7 @@ void callback() {
       std::cout << "    worldRay: ";
       polyscope::operator<<(std::cout, worldRay) << std::endl;
       std::cout << "    worldPos: ";
-      polyscope::operator<<(std::cout, worldPos) << std::endl;
+      polyscope::operator<<(std::cout, pickResult.position) << std::endl;
       if (pickResult.isHit) {
         std::cout << "    structure: " << pickResult.structureType << " " << pickResult.structureName
                   << " local ind: " << pickResult.localIndex << std::endl;
@@ -827,7 +826,7 @@ void callback() {
       }
 
       // Construct point at click location
-      polyscope::registerPointCloud("click point", std::vector<glm::vec3>({worldPos}));
+      polyscope::registerPointCloud("click point", std::vector<glm::vec3>({pickResult.position}));
 
       // Construct unit-length vector pointing in the direction of the click
       // (this depends only on the camera parameters, and does not require accessing the depth buffer)

include/polyscope/view.h

@@ -138,8 +138,7 @@ bool getWindowResizable();
 // Get world geometry corresponding to a screen pixel (e.g. from a mouse click)
 glm::vec3 screenCoordsToWorldRay(glm::vec2 screenCoords);
 glm::vec3 bufferIndsToWorldRay(glm::ivec2 bufferInds);
-glm::vec3 screenCoordsToWorldPosition(glm::vec2 screenCoords); // queries the depth buffer to get full position
-glm::vec3 bufferIndsToWorldPosition(glm::ivec2 bufferInds);
+glm::vec3 screenCoordsAndDepthToWorldPosition(glm::vec2 screenCoords, float clipDepth);
 
 // Get and set camera from json string
 std::string getViewAsJson();
@@ -181,7 +180,6 @@ void processKeyboardNavigation(ImGuiIO& io);
 
 // deprecated, bad names, see variants above
 glm::vec3 bufferCoordsToWorldRay(glm::vec2 bufferCoords);
-glm::vec3 bufferCoordsToWorldPosition(int xPos, int yPos);
 
 
 } // namespace view

src/pick.cpp

@@ -18,17 +18,21 @@ PickResult queryPickAtScreenCoords(glm::vec2 screenCoords) {
 PickResult queryPickAtBufferInds(glm::ivec2 bufferInds) {
   PickResult result;
 
-  // Query the render buffer
-  result.position = view::bufferIndsToWorldPosition(bufferInds);
-  result.depth = glm::length(result.position - view::getCameraWorldPosition());
-
   // Query the pick buffer
+  // (this necessarily renders to pickFrameBuffer)
   std::pair<Structure*, size_t> rawPickResult = pick::pickAtBufferCoords(bufferInds.x, bufferInds.y);
 
+  // Query the depth buffer populated above
+  render::FrameBuffer* pickFramebuffer = render::engine->pickFramebuffer.get();
+  float clipDepth = pickFramebuffer->readDepth(bufferInds.x, view::bufferHeight - bufferInds.y);
+
   // Transcribe result into return tuple
   result.structure = rawPickResult.first;
   result.bufferInds = bufferInds;
   result.screenCoords = view::bufferIndsToScreenCoords(bufferInds);
+  result.position = view::screenCoordsAndDepthToWorldPosition(result.screenCoords, clipDepth);
+  result.depth = glm::length(result.position - view::getCameraWorldPosition());
+
   if (rawPickResult.first == nullptr) {
     result.isHit = false;
     result.structureType = "";

src/render/opengl/gl_engine.cpp

@@ -977,7 +977,7 @@ float GLFrameBuffer::readDepth(int xPos, int yPos) {
   bind();
 
   // Read from the buffer
-  float result;
+  float result = 1.;
   glReadPixels(xPos, yPos, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &result);
 
   return result;

src/view.cpp

@@ -538,39 +538,26 @@ glm::vec3 bufferCoordsToWorldRay(glm::vec2 bufferCoords) {
   return worldRayDir;
 }
 
-glm::vec3 screenCoordsToWorldPosition(glm::vec2 screenCoords) {
-  int xInd, yInd;
-  std::tie(xInd, yInd) = screenCoordsToBufferInds(screenCoords);
-  return bufferCoordsToWorldPosition(xInd, yInd);
-}
 
-glm::vec3 bufferIndsToWorldPosition(glm::ivec2 bufferInds) {
-  return bufferCoordsToWorldPosition(bufferInds.x, bufferInds.y);
-}
+glm::vec3 screenCoordsAndDepthToWorldPosition(glm::vec2 screenCoords, float clipDepth) {
 
-glm::vec3 bufferCoordsToWorldPosition(int xInd, int yInd) {
+  if (clipDepth == 1.) {
+    // if we didn't hit anything in the depth buffer, just return infinity
+    float inf = std::numeric_limits<float>::infinity();
+    return glm::vec3{inf, inf, inf};
+  }
 
-  glm::vec2 screenCoords = bufferIndsToScreenCoords(xInd, yInd);
 
   glm::mat4 view = getCameraViewMatrix();
   glm::mat4 viewInv = glm::inverse(view);
   glm::mat4 proj = getCameraPerspectiveMatrix();
   glm::mat4 projInv = glm::inverse(proj);
   // glm::vec2 depthRange = {0., 1.}; // no support for nonstandard depth range, currently
 
-  // query the depth buffer to get depth
-  render::FrameBuffer* sceneFramebuffer = render::engine->sceneBuffer.get();
-  float depth = sceneFramebuffer->readDepth(xInd, view::bufferHeight - yInd);
-  if (depth == 1.) {
-    // if we didn't hit anything in the depth buffer, just return infinity
-    float inf = std::numeric_limits<float>::infinity();
-    return glm::vec3{inf, inf, inf};
-  }
-
   // convert depth to world units
   glm::vec2 screenPos{screenCoords.x / static_cast<float>(view::windowWidth),
                       1.f - screenCoords.y / static_cast<float>(view::windowHeight)};
-  float z = depth * 2.0f - 1.0f;
+  float z = clipDepth * 2.0f - 1.0f;
   glm::vec4 clipPos = glm::vec4(screenPos * 2.0f - 1.0f, z, 1.0f);
   glm::vec4 viewPos = projInv * clipPos;
   viewPos /= viewPos.w;