initial WIP on better picking

Author: nmwsharp

include/polyscope/context.h

@@ -97,6 +97,15 @@ struct Context {
   glm::vec3 flightTargetViewT, flightInitialViewT;
   float flightTargetFov, flightInitialFov;
 
+  // ======================================================
+  // === Picking globals from pick.h / pick.cpp
+  // ======================================================
+
+  size_t currLocalPickInd = 0;
+  Structure* currPickStructure = nullptr;
+  bool haveSelectionVal = false;
+  size_t nextPickBufferInd = 1;
+  std::unordered_map<Structure*, std::tuple<size_t, size_t>> structureRanges;
 
   // ======================================================
   // === Internal globals from internal.h

include/polyscope/pick.h

@@ -8,23 +8,39 @@
 #include <utility>
 
 namespace polyscope {
-namespace pick {
 
+// == Main query
 
-// == Set up picking
-// Called by a structure to figure out what data it should render to the pick buffer.
-// Request 'count' contiguous indices for drawing a pick buffer. The return value is the start of the range.
-size_t requestPickBufferRange(Structure* requestingStructure, size_t count);
+// Pick queries test a screen location in the rendered viewport, and return a variety of info about what is underneath
+// the pixel at that point, including what structure is under the cursor, and the scene depth and color.
+//
+// This information can be fed into structure-specific functions like SurfaceMesh::interpretPick(PickQueryResult) to get
+// structure-specific info, like which vertex/face was clicked on.
+
+// Return type for pick queries
+struct PickQueryResult {
+  bool isHit;
+  Structure* structure;
+  std::string structureType;
+  std::string structureName;
+  glm::vec3 position;
+  float depth;
+};
+
+// Query functions to evaluate a pick.
+// Internally, these do a render pass to populate relevant information, then query the resulting buffers.
+PickQueryResult queryPickAtScreenCoords(glm::vec2 screenCoords); // takes screen coordinates
+PickQueryResult queryPickAtBufferCoords(int xPos, int yPos);     // takes indices into render buffer
 
+namespace pick {
 
-// == Main query
+// Old, deprecated picking API. Use the above functions instead.
 // Get the structure which was clicked on (nullptr if none), and the pick ID in local indices for that structure (such
 // that 0 is the first index as returned from requestPickBufferRange())
 std::pair<Structure*, size_t> pickAtScreenCoords(glm::vec2 screenCoords); // takes screen coordinates
 std::pair<Structure*, size_t> pickAtBufferCoords(int xPos, int yPos);     // takes indices into the buffer
 std::pair<Structure*, size_t> evaluatePickQuery(int xPos, int yPos);      // old, badly named. takes buffer coordinates.
 
-
 // == Stateful picking: track and update a current selection
 
 // Get/Set the "selected" item, if there is one (output has same meaning as evaluatePickQuery());
@@ -38,6 +54,11 @@ void resetSelectionIfStructure(Structure* s); // If something from this structur
 
 // == Helpers
 
+// Set up picking (internal)
+// Called by a structure to figure out what data it should render to the pick buffer.
+// Request 'count' contiguous indices for drawing a pick buffer. The return value is the start of the range.
+size_t requestPickBufferRange(Structure* requestingStructure, size_t count);
+
 // Convert between global pick indexing for the whole program, and local per-structure pick indexing
 std::pair<Structure*, size_t> globalIndexToLocal(size_t globalInd);
 size_t localIndexToGlobal(std::pair<Structure*, size_t> localPick);

include/polyscope/polyscope.h

@@ -129,6 +129,10 @@ Structure* getStructure(std::string type, std::string name = "");
 // True if such a structure exists
 bool hasStructure(std::string type, std::string name = "");
 
+// Look up the string type and name for a structure from its pointer
+// (performs a naive search over all structures for now, use sparingly)
+std::tuple<std::string, std::string> lookUpStructure(Structure* structure);
+
 // De-register a structure, of any type. Also removes any quantities associated with the structure
 void removeStructure(Structure* structure, bool errorIfAbsent = false);
 void removeStructure(std::string type, std::string name, bool errorIfAbsent = false);

include/polyscope/render/engine.h

@@ -584,7 +584,7 @@ class Engine {
   TransparencyMode getTransparencyMode();
   bool transparencyEnabled();
   virtual void applyTransparencySettings() = 0;
-  void addSlicePlane(std::string uniquePostfix);
+  void addSlicePlane(std::string uniquePostfix); // TODO move slice planes out of the engine
   void removeSlicePlane(std::string uniquePostfix);
   bool slicePlanesEnabled();                     // true if there is at least one slice plane in the scene
   virtual void setFrontFaceCCW(bool newVal) = 0; // true if CCW triangles are considered front-facing; false otherwise

include/polyscope/view.h

@@ -139,6 +139,7 @@ bool getWindowResizable();
 glm::vec3 screenCoordsToWorldRay(glm::vec2 screenCoords);
 glm::vec3 bufferCoordsToWorldRay(int xPos, int yPos);
 glm::vec3 screenCoordsToWorldPosition(glm::vec2 screenCoords); // queries the depth buffer to get full position
+glm::vec3 bufferCoordsToWorldPosition(int xPos, int yPos); 
 
 // Get and set camera from json string
 std::string getViewAsJson();
@@ -150,6 +151,7 @@ void setCameraFromJson(std::string jsonData, bool flyTo);
 std::string to_string(ProjectionMode mode);
 std::string to_string(NavigateStyle style);
 std::tuple<int, int> screenCoordsToBufferInds(glm::vec2 screenCoords);
+glm::vec2 bufferIndsToScreenCoords(int xPos, int yPos);
 
 // == Internal helpers. Should probably not be called in user code.
 

src/pick.cpp

@@ -9,19 +9,53 @@
 #include <unordered_map>
 
 namespace polyscope {
+
+PickQueryResult queryPickAtScreenCoords(glm::vec2 screenCoords) {
+  int xInd, yInd;
+  std::tie(xInd, yInd) = view::screenCoordsToBufferInds(screenCoords);
+  return queryPickAtBufferCoords(xInd, yInd);
+}
+PickQueryResult queryPickAtBufferCoords(int xPos, int yPos) {
+  PickQueryResult result;
+
+  // Query the render buffer
+  result.position = view::bufferCoordsToWorldPosition(xPos, yPos);
+  result.depth = glm::length(result.position - view::getCameraWorldPosition());
+
+  // Query the pick buffer
+  std::pair<Structure*, size_t> rawPickResult = pick::evaluatePickQuery(xPos, yPos);
+
+  // Transcribe result into return tuple
+  result.structure = rawPickResult.first;
+  if (rawPickResult.first == nullptr) {
+    result.isHit = false;
+    result.structureType = "";
+    result.structureName = "";
+  } else {
+    result.isHit = true;
+    std::tuple<std::string, std::string> lookupResult = lookUpStructure(rawPickResult.first);
+    result.structureType = std::get<0>(lookupResult);
+    result.structureName = std::get<1>(lookupResult);
+  }
+
+
+
+  return result;
+}
+
+
 namespace pick {
 
-size_t currLocalPickInd = 0;
-Structure* currPickStructure = nullptr;
-bool haveSelectionVal = false;
+size_t& currLocalPickInd = state::globalContext.currLocalPickInd;
+Structure*& currPickStructure = state::globalContext.currPickStructure;
+bool& haveSelectionVal = state::globalContext.haveSelectionVal;
 
 // The next pick index that a structure can use to identify its elements
 // (get it by calling request pickBufferRange())
-size_t nextPickBufferInd = 1; // 0 reserved for "none"
-                              //
+size_t& nextPickBufferInd = state::globalContext.nextPickBufferInd; // 0 reserved for "none"
+
 // Track which ranges have been allocated to which structures
-// std::vector<std::tuple<size_t, size_t, Structure*>> structureRanges;
-std::unordered_map<Structure*, std::tuple<size_t, size_t>> structureRanges;
+std::unordered_map<Structure*, std::tuple<size_t, size_t>> structureRanges = state::globalContext.structureRanges;
 
 
 // == Set up picking

src/polyscope.cpp

@@ -1063,6 +1063,19 @@ bool hasStructure(std::string type, std::string name) {
   return sMap.find(name) != sMap.end();
 }
 
+std::tuple<std::string, std::string> lookUpStructure(Structure* structure) {
+
+  for (auto& typeMap : state::structures) {
+    for (auto& entry : typeMap.second) {
+      if (entry.second.get() == structure) {
+        return std::tuple<std::string, std::string>(typeMap.first, entry.first);
+      }
+    }
+  }
+
+  // not found
+  return std::tuple<std::string, std::string>("", "");
+}
 
 void removeStructure(std::string type, std::string name, bool errorIfAbsent) {
 

src/view.cpp

@@ -102,6 +102,11 @@ std::tuple<int, int> screenCoordsToBufferInds(glm::vec2 screenCoords) {
   return std::tuple<int, int>(xPos, yPos);
 }
 
+glm::vec2 bufferIndsToScreenCoords(int xPos, int yPos) {
+  return glm::vec2{xPos * static_cast<float>(view::windowWidth) / view::bufferWidth,
+                   yPos * static_cast<float>(view::windowHeight) / view::bufferHeight};
+}
+
 void processRotate(glm::vec2 startP, glm::vec2 endP) {
 
   if (startP == endP) {
@@ -521,11 +526,15 @@ 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 bufferCoordsToWorldPosition(int xInd, int yInd) {
+
+  glm::vec2 screenCoords = bufferIndsToScreenCoords(xInd, yInd);
 
   glm::mat4 view = getCameraViewMatrix();
   glm::mat4 viewInv = glm::inverse(view);