add integer buffer types and sparse volume grid structure

examples/demo-app/demo_app.cpp

@@ -12,13 +12,15 @@
 #include "polyscope/point_cloud.h"
 #include "polyscope/render/managed_buffer.h"
 #include "polyscope/simple_triangle_mesh.h"
+#include "polyscope/sparse_volume_grid.h"
 #include "polyscope/surface_mesh.h"
 #include "polyscope/types.h"
 #include "polyscope/view.h"
 #include "polyscope/volume_grid.h"
 #include "polyscope/volume_mesh.h"
 
 #include <iostream>
+#include <set>
 #include <unordered_set>
 #include <utility>
 
@@ -544,6 +546,90 @@ void addVolumeGrid() {
 }
 
 
+void addSparseVolumeGrid() {
+  glm::vec3 origin{-1., -1., -1.};
+  int32_t N = 20;
+  glm::vec3 cellWidth{1.0f / N, 1.0f / N, 1.0f / N};
+
+  // Build a spherical shell of occupied cells
+  std::vector<glm::ivec3> occupiedCells;
+  for (int i = -N; i <= N; i++) {
+    for (int j = -N; j <= N; j++) {
+      for (int k = -N; k <= N; k++) {
+        glm::vec3 cellCenter = origin + (glm::vec3(i, j, k) + 0.5f) * cellWidth;
+        float dist = glm::length(cellCenter - origin);
+        if (dist >= 0.35f && dist <= 1.0f) {
+          occupiedCells.push_back({i, j, k});
+        }
+      }
+    }
+  }
+  // Gather all unique nodes for the occupied cells
+  // Node (ci+dx, cj+dy, ck+dz) for dx,dy,dz in {0,1}
+  std::set<std::tuple<int, int, int>> nodeSet;
+  for (const auto& ci : occupiedCells) {
+    for (int dx = 0; dx < 2; dx++) {
+      for (int dy = 0; dy < 2; dy++) {
+        for (int dz = 0; dz < 2; dz++) {
+          nodeSet.insert({ci.x + dx, ci.y + dy, ci.z + dz});
+        }
+      }
+    }
+  }
+
+  std::cout << "adding sparse volume grid with " << occupiedCells.size() << " cells" << std::endl;
+  polyscope::SparseVolumeGrid* psGrid =
+      polyscope::registerSparseVolumeGrid("sparse grid", origin, cellWidth, occupiedCells);
+
+  // Cell scalar: distance from origin
+  {
+    std::vector<float> cellDist(occupiedCells.size());
+    for (size_t i = 0; i < occupiedCells.size(); i++) {
+      glm::vec3 cellCenter = origin + (glm::vec3(occupiedCells[i]) + 0.5f) * cellWidth;
+      cellDist[i] = glm::length(cellCenter - origin);
+    }
+    psGrid->addCellScalarQuantity("cell distance", cellDist);
+  }
+
+  // Node scalar: x-coordinate at node positions
+  {
+
+    std::vector<glm::ivec3> nodeIndices;
+    std::vector<float> nodeValues;
+    for (const auto& nodeInds : nodeSet) {
+      int32_t ni, nj, nk;
+      std::tie(ni, nj, nk) = nodeInds;
+      nodeIndices.push_back({ni, nj, nk});
+      glm::vec3 nodePos = origin + glm::vec3(ni, nj, nk) * cellWidth;
+      nodeValues.push_back(nodePos.x);
+    }
+    psGrid->addNodeScalarQuantity("node x-coord", nodeIndices, nodeValues);
+  }
+
+  // Cell color: random colors
+  {
+    std::vector<glm::vec3> cellColors(occupiedCells.size());
+    for (size_t i = 0; i < occupiedCells.size(); i++) {
+      cellColors[i] = glm::vec3{polyscope::randomUnit(), polyscope::randomUnit(), polyscope::randomUnit()};
+    }
+    psGrid->addCellColorQuantity("cell color", cellColors);
+  }
+
+  // Node color: random colors
+  {
+    std::vector<glm::ivec3> nodeIndices;
+    std::vector<glm::vec3> nodeColors;
+    for (const auto& nodeInds : nodeSet) {
+      int32_t ni, nj, nk;
+      std::tie(ni, nj, nk) = nodeInds;
+      nodeIndices.push_back({ni, nj, nk});
+      nodeColors.push_back(glm::vec3{polyscope::randomUnit(), polyscope::randomUnit(), polyscope::randomUnit()});
+    }
+    psGrid->addNodeColorQuantity("node color", nodeIndices, nodeColors);
+  }
+}
+
+
 void loadFloatingImageData(polyscope::CameraView* targetView = nullptr) {
 
   // load an image from disk as example data
@@ -864,6 +950,10 @@ void callback() {
     addVolumeGrid();
   }
 
+  if (ImGui::Button("add sparse volume grid")) {
+    addSparseVolumeGrid();
+  }
+
   // ImPlot
   // dummy data
   if (ImGui::TreeNode("ImPlot")) {
@@ -911,7 +1001,7 @@ int main(int argc, char** argv) {
   // polyscope::view::windowWidth = 600;
   // polyscope::view::windowHeight = 800;
   // polyscope::options::maxFPS = -1;
-  polyscope::options::verbosity = 101;
+  polyscope::options::verbosity = 200;
   polyscope::options::enableRenderErrorChecks = true;
   polyscope::options::allowHeadlessBackends = true;
 

include/polyscope/numeric_helpers.h

@@ -72,6 +72,19 @@ inline bool allComponentsFinite<glm::vec4>(const glm::vec4& x) {
   return glm::all(glm::isfinite(x));
 }
 
+template <>
+inline bool allComponentsFinite<glm::ivec2>(const glm::ivec2& x) {
+  return true;
+}
+template <>
+inline bool allComponentsFinite<glm::ivec3>(const glm::ivec3& x) {
+  return true;
+}
+template <>
+inline bool allComponentsFinite<glm::ivec4>(const glm::ivec4& x) {
+  return true;
+}
+
 template <>
 inline bool allComponentsFinite<glm::uvec2>(const glm::uvec2& x) {
   return true;

include/polyscope/render/engine.h

@@ -47,6 +47,9 @@ enum class RenderDataType {
   Matrix44Float,
   Float,
   Int,
+  Vector2Int,
+  Vector3Int,
+  Vector4Int,
   UInt,
   Vector2UInt,
   Vector3UInt,
@@ -78,6 +81,9 @@ class AttributeBuffer {
   virtual void setData(const std::vector<float>& data) = 0;
   virtual void setData(const std::vector<double>& data) = 0;
   virtual void setData(const std::vector<int32_t>& data) = 0;
+  virtual void setData(const std::vector<glm::ivec2>& data) = 0;
+  virtual void setData(const std::vector<glm::ivec3>& data) = 0;
+  virtual void setData(const std::vector<glm::ivec4>& data) = 0;
   virtual void setData(const std::vector<uint32_t>& data) = 0;
   virtual void setData(const std::vector<glm::uvec2>& data) = 0;
   virtual void setData(const std::vector<glm::uvec3>& data) = 0;
@@ -107,6 +113,9 @@ class AttributeBuffer {
   virtual glm::vec3 getData_vec3(size_t ind) = 0;
   virtual glm::vec4 getData_vec4(size_t ind) = 0;
   virtual int getData_int(size_t ind) = 0;
+  virtual glm::ivec2 getData_ivec2(size_t ind) = 0;
+  virtual glm::ivec3 getData_ivec3(size_t ind) = 0;
+  virtual glm::ivec4 getData_ivec4(size_t ind) = 0;
   virtual uint32_t getData_uint32(size_t ind) = 0;
   virtual glm::uvec2 getData_uvec2(size_t ind) = 0;
   virtual glm::uvec3 getData_uvec3(size_t ind) = 0;
@@ -119,6 +128,9 @@ class AttributeBuffer {
   virtual std::vector<glm::vec3> getDataRange_vec3(size_t ind, size_t count) = 0;
   virtual std::vector<glm::vec4> getDataRange_vec4(size_t ind, size_t count) = 0;
   virtual std::vector<int> getDataRange_int(size_t ind, size_t count) = 0;
+  virtual std::vector<glm::ivec2> getDataRange_ivec2(size_t ind, size_t count) = 0;
+  virtual std::vector<glm::ivec3> getDataRange_ivec3(size_t ind, size_t count) = 0;
+  virtual std::vector<glm::ivec4> getDataRange_ivec4(size_t ind, size_t count) = 0;
   virtual std::vector<uint32_t> getDataRange_uint32(size_t ind, size_t count) = 0;
   virtual std::vector<glm::uvec2> getDataRange_uvec2(size_t ind, size_t count) = 0;
   virtual std::vector<glm::uvec3> getDataRange_uvec3(size_t ind, size_t count) = 0;
@@ -155,6 +167,9 @@ class TextureBuffer {
   virtual void setData(const std::vector<float>& data) = 0;
   virtual void setData(const std::vector<double>& data) = 0;
   virtual void setData(const std::vector<int32_t>& data) = 0;
+  virtual void setData(const std::vector<glm::ivec2>& data) = 0;
+  virtual void setData(const std::vector<glm::ivec3>& data) = 0;
+  virtual void setData(const std::vector<glm::ivec4>& data) = 0;
   virtual void setData(const std::vector<uint32_t>& data) = 0;
   virtual void setData(const std::vector<glm::uvec2>& data) = 0;
   virtual void setData(const std::vector<glm::uvec3>& data) = 0;
@@ -364,6 +379,9 @@ class ShaderProgram {
   virtual void setUniform(std::string name, glm::vec4 val) = 0;
   virtual void setUniform(std::string name, std::array<float, 3> val) = 0;
   virtual void setUniform(std::string name, float x, float y, float z, float w) = 0;
+  virtual void setUniform(std::string name, glm::ivec2 val) = 0;
+  virtual void setUniform(std::string name, glm::ivec3 val) = 0;
+  virtual void setUniform(std::string name, glm::ivec4 val) = 0;
   virtual void setUniform(std::string name, glm::uvec2 val) = 0;
   virtual void setUniform(std::string name, glm::uvec3 val) = 0;
   virtual void setUniform(std::string name, glm::uvec4 val) = 0;

include/polyscope/render/managed_buffer.h

@@ -290,8 +290,11 @@ class ManagedBufferRegistry {
   ManagedBufferMap<std::array<glm::vec3,2>> managedBufferMap_arr2vec3;
   ManagedBufferMap<std::array<glm::vec3,3>> managedBufferMap_arr3vec3;
   ManagedBufferMap<std::array<glm::vec3,4>> managedBufferMap_arr4vec3;
-  ManagedBufferMap<uint32_t>     managedBufferMap_uint32;
   ManagedBufferMap<int32_t>      managedBufferMap_int32;
+  ManagedBufferMap<glm::ivec2>   managedBufferMap_ivec2;
+  ManagedBufferMap<glm::ivec3>   managedBufferMap_ivec3;
+  ManagedBufferMap<glm::ivec4>   managedBufferMap_ivec4;
+  ManagedBufferMap<uint32_t>     managedBufferMap_uint32;
   ManagedBufferMap<glm::uvec2>   managedBufferMap_uvec2;
   ManagedBufferMap<glm::uvec3>   managedBufferMap_uvec3;
   ManagedBufferMap<glm::uvec4>   managedBufferMap_uvec4;

include/polyscope/render/mock_opengl/mock_gl_engine.h

@@ -27,6 +27,9 @@ class GLAttributeBuffer : public AttributeBuffer {
   void setData(const std::vector<float>& data) override;
   void setData(const std::vector<double>& data) override;
   void setData(const std::vector<int32_t>& data) override;
+  void setData(const std::vector<glm::ivec2>& data) override;
+  void setData(const std::vector<glm::ivec3>& data) override;
+  void setData(const std::vector<glm::ivec4>& data) override;
   void setData(const std::vector<uint32_t>& data) override;
   void setData(const std::vector<glm::uvec2>& data) override;
   void setData(const std::vector<glm::uvec3>& data) override;
@@ -46,6 +49,9 @@ class GLAttributeBuffer : public AttributeBuffer {
   glm::vec3 getData_vec3(size_t ind) override;
   glm::vec4 getData_vec4(size_t ind) override;
   int getData_int(size_t ind) override;
+  glm::ivec2 getData_ivec2(size_t ind) override;
+  glm::ivec3 getData_ivec3(size_t ind) override;
+  glm::ivec4 getData_ivec4(size_t ind) override;
   uint32_t getData_uint32(size_t ind) override;
   glm::uvec2 getData_uvec2(size_t ind) override;
   glm::uvec3 getData_uvec3(size_t ind) override;
@@ -58,6 +64,9 @@ class GLAttributeBuffer : public AttributeBuffer {
   std::vector<glm::vec3> getDataRange_vec3(size_t ind, size_t count) override;
   std::vector<glm::vec4> getDataRange_vec4(size_t ind, size_t count) override;
   std::vector<int> getDataRange_int(size_t ind, size_t count) override;
+  std::vector<glm::ivec2> getDataRange_ivec2(size_t ind, size_t count) override;
+  std::vector<glm::ivec3> getDataRange_ivec3(size_t ind, size_t count) override;
+  std::vector<glm::ivec4> getDataRange_ivec4(size_t ind, size_t count) override;
   std::vector<uint32_t> getDataRange_uint32(size_t ind, size_t count) override;
   std::vector<glm::uvec2> getDataRange_uvec2(size_t ind, size_t count) override;
   std::vector<glm::uvec3> getDataRange_uvec3(size_t ind, size_t count) override;
@@ -113,6 +122,9 @@ class GLTextureBuffer : public TextureBuffer {
   void setData(const std::vector<float>& data) override;
   void setData(const std::vector<double>& data) override;
   void setData(const std::vector<int32_t>& data) override;
+  void setData(const std::vector<glm::ivec2>& data) override;
+  void setData(const std::vector<glm::ivec3>& data) override;
+  void setData(const std::vector<glm::ivec4>& data) override;
   void setData(const std::vector<uint32_t>& data) override;
   void setData(const std::vector<glm::uvec2>& data) override;
   void setData(const std::vector<glm::uvec3>& data) override;
@@ -257,6 +269,9 @@ class GLShaderProgram : public ShaderProgram {
   void setUniform(std::string name, glm::vec4 val) override;
   void setUniform(std::string name, std::array<float, 3> val) override;
   void setUniform(std::string name, float x, float y, float z, float w) override;
+  void setUniform(std::string name, glm::ivec2 val) override;
+  void setUniform(std::string name, glm::ivec3 val) override;
+  void setUniform(std::string name, glm::ivec4 val) override;
   void setUniform(std::string name, glm::uvec2 val) override;
   void setUniform(std::string name, glm::uvec3 val) override;
   void setUniform(std::string name, glm::uvec4 val) override;

include/polyscope/render/opengl/gl_engine.h

@@ -55,6 +55,9 @@ class GLAttributeBuffer : public AttributeBuffer {
   void setData(const std::vector<float>& data) override;
   void setData(const std::vector<double>& data) override;
   void setData(const std::vector<int32_t>& data) override;
+  void setData(const std::vector<glm::ivec2>& data) override;
+  void setData(const std::vector<glm::ivec3>& data) override;
+  void setData(const std::vector<glm::ivec4>& data) override;
   void setData(const std::vector<uint32_t>& data) override;
   void setData(const std::vector<glm::uvec2>& data) override;
   void setData(const std::vector<glm::uvec3>& data) override;
@@ -74,6 +77,9 @@ class GLAttributeBuffer : public AttributeBuffer {
   glm::vec3 getData_vec3(size_t ind) override;
   glm::vec4 getData_vec4(size_t ind) override;
   int getData_int(size_t ind) override;
+  glm::ivec2 getData_ivec2(size_t ind) override;
+  glm::ivec3 getData_ivec3(size_t ind) override;
+  glm::ivec4 getData_ivec4(size_t ind) override;
   uint32_t getData_uint32(size_t ind) override;
   glm::uvec2 getData_uvec2(size_t ind) override;
   glm::uvec3 getData_uvec3(size_t ind) override;
@@ -86,6 +92,9 @@ class GLAttributeBuffer : public AttributeBuffer {
   std::vector<glm::vec3> getDataRange_vec3(size_t ind, size_t count) override;
   std::vector<glm::vec4> getDataRange_vec4(size_t ind, size_t count) override;
   std::vector<int> getDataRange_int(size_t ind, size_t count) override;
+  std::vector<glm::ivec2> getDataRange_ivec2(size_t ind, size_t count) override;
+  std::vector<glm::ivec3> getDataRange_ivec3(size_t ind, size_t count) override;
+  std::vector<glm::ivec4> getDataRange_ivec4(size_t ind, size_t count) override;
   std::vector<uint32_t> getDataRange_uint32(size_t ind, size_t count) override;
   std::vector<glm::uvec2> getDataRange_uvec2(size_t ind, size_t count) override;
   std::vector<glm::uvec3> getDataRange_uvec3(size_t ind, size_t count) override;
@@ -145,6 +154,9 @@ class GLTextureBuffer : public TextureBuffer {
   void setData(const std::vector<float>& data) override;
   void setData(const std::vector<double>& data) override;
   void setData(const std::vector<int32_t>& data) override;
+  void setData(const std::vector<glm::ivec2>& data) override;
+  void setData(const std::vector<glm::ivec3>& data) override;
+  void setData(const std::vector<glm::ivec4>& data) override;
   void setData(const std::vector<uint32_t>& data) override;
   void setData(const std::vector<glm::uvec2>& data) override;
   void setData(const std::vector<glm::uvec3>& data) override;
@@ -300,6 +312,9 @@ class GLShaderProgram : public ShaderProgram {
   void setUniform(std::string name, glm::vec4 val) override;
   void setUniform(std::string name, std::array<float, 3> val) override;
   void setUniform(std::string name, float x, float y, float z, float w) override;
+  void setUniform(std::string name, glm::ivec2 val) override;
+  void setUniform(std::string name, glm::ivec3 val) override;
+  void setUniform(std::string name, glm::ivec4 val) override;
   void setUniform(std::string name, glm::uvec2 val) override;
   void setUniform(std::string name, glm::uvec3 val) override;
   void setUniform(std::string name, glm::uvec4 val) override;

include/polyscope/render/opengl/shaders/grid_shaders.h

@@ -20,8 +20,16 @@ extern const ShaderStageSpecification FLEX_GRIDCUBE_PLANE_FRAG_SHADER;
 extern const ShaderReplacementRule GRIDCUBE_PROPAGATE_NODE_VALUE;
 extern const ShaderReplacementRule GRIDCUBE_PROPAGATE_CELL_VALUE;
 extern const ShaderReplacementRule GRIDCUBE_WIREFRAME;
+extern const ShaderReplacementRule GRIDCUBE_PLANE_WIREFRAME;
 extern const ShaderReplacementRule GRIDCUBE_CONSTANT_PICK;
 extern const ShaderReplacementRule GRIDCUBE_CULLPOS_FROM_CENTER;
+extern const ShaderReplacementRule GRIDCUBE_PLANE_CULLPOS_FROM_CENTER;
+
+// Attribute-based rules for sparse volume grid quantities
+extern const ShaderReplacementRule GRIDCUBE_PROPAGATE_ATTR_CELL_SCALAR;
+extern const ShaderReplacementRule GRIDCUBE_PROPAGATE_ATTR_CELL_COLOR;
+extern const ShaderReplacementRule GRIDCUBE_PROPAGATE_ATTR_NODE_SCALAR;
+extern const ShaderReplacementRule GRIDCUBE_PROPAGATE_ATTR_NODE_COLOR;
 
 
 } // namespace backend_openGL3