bind SimpleTriangleMesh, update ManagedBuffer

CMakeLists.txt

@@ -34,6 +34,7 @@ add_subdirectory(deps/polyscope)
 nanobind_add_module(polyscope_bindings 
   src/cpp/core.cpp
   src/cpp/surface_mesh.cpp
+  src/cpp/simple_triangle_mesh.cpp
   src/cpp/point_cloud.cpp
   src/cpp/curve_network.cpp
   src/cpp/volume_mesh.cpp

src/cpp/core.cpp

@@ -26,6 +26,7 @@ namespace ps = polyscope;
 
 // Forward-declare bindings from other files
 void bind_surface_mesh(nb::module_& m);
+void bind_simple_triangle_mesh(nb::module_& m);
 void bind_point_cloud(nb::module_& m);
 void bind_curve_network(nb::module_& m);
 void bind_volume_mesh(nb::module_& m);
@@ -732,6 +733,7 @@ NB_MODULE(polyscope_bindings, m) {
   bind_point_cloud(m);
   bind_curve_network(m);
   bind_surface_mesh(m);
+  bind_simple_triangle_mesh(m);
   bind_volume_mesh(m);
   bind_volume_grid(m);
   bind_sparse_volume_grid(m);

src/cpp/gaussian_particles_structure.cpp

@@ -110,14 +110,20 @@ void GaussianParticles::ensureImagebuffersAllocated() {
 
   // re-allocate buffers
   depths->setTextureSize(currImageWidth, currImageHeight);
-  depths->ensureHostBufferAllocated();
-  depths->data = std::vector<float>(currImageWidth * currImageHeight, 0.0f);
-  depths->markHostBufferUpdated();
+  {
+    std::vector<float> depthZeros(currImageWidth * currImageHeight, 0.0f);
+    depths->resize(depthZeros.size());
+    depths->setDataHost(depthZeros);
+    depths->markHostBufferUpdated();
+  }
 
   colors->setTextureSize(currImageWidth, currImageHeight);
-  colors->ensureHostBufferAllocated();
-  colors->data = std::vector<glm::vec4>(currImageWidth * currImageHeight, glm::vec4(0.0f));
-  colors->markHostBufferUpdated();
+  {
+    std::vector<glm::vec4> colorZeros(currImageWidth * currImageHeight, glm::vec4(0.0f));
+    colors->resize(colorZeros.size());
+    colors->setDataHost(colorZeros);
+    colors->markHostBufferUpdated();
+  }
 
   if (imageToScreenProgram) {
     imageToScreenProgram->setTextureFromBuffer("t_depth", depths->getRenderTextureBuffer().get());

src/cpp/managed_buffer.cpp

@@ -15,7 +15,7 @@ nb::class_<ps::render::ManagedBuffer<T>> bind_managed_buffer_T(nb::module_& m, p
   return nb::class_<ps::render::ManagedBuffer<T>>(m, ("ManagedBuffer_" + ps::typeName(t)).c_str())
       .def("size", &ps::render::ManagedBuffer<T>::size)
       .def("get_texture_size", &ps::render::ManagedBuffer<T>::getTextureSize)
-      .def("has_data", &ps::render::ManagedBuffer<T>::hasData)
+      .def("has_data", [](const ps::render::ManagedBuffer<T>& b) { return b.size() > 0; })
       .def("summary_string", &ps::render::ManagedBuffer<T>::summaryString)
       .def("get_device_buffer_type", &ps::render::ManagedBuffer<T>::getDeviceBufferType)
       .def("get_generic_weak_handle",
@@ -65,44 +65,44 @@ void bind_managed_buffer(nb::module_& m) {
   bind_managed_buffer_T<float>(m, ps::ManagedBufferType::Float)
     .def("update_data", [](ps::render::ManagedBuffer<float>& s, Eigen::VectorXf& d) {
       if(d.rows() != s.size()) ps::exception("bad update size, should be " + std::to_string(s.size()));
-      s.ensureHostBufferAllocated();
-      for(uint32_t i = 0; i < s.size(); i++) s.data[i] = d(i);
+      s.ensureHostBufferPopulated();
+      for(uint32_t i = 0; i < s.size(); i++) s.setHostValue(i, d(i));
       s.markHostBufferUpdated();
     })
   ;
 
   bind_managed_buffer_T<double>(m, ps::ManagedBufferType::Double)
     .def("update_data", [](ps::render::ManagedBuffer<double>& s, Eigen::VectorXd& d) {
       if(d.rows() != s.size()) ps::exception("bad update size, should be " + std::to_string(s.size()));
-      s.ensureHostBufferAllocated();
-      for(uint32_t i = 0; i < s.size(); i++) s.data[i] = d(i);
+      s.ensureHostBufferPopulated();
+      for(uint32_t i = 0; i < s.size(); i++) s.setHostValue(i, d(i));
       s.markHostBufferUpdated();
     })
   ;
 
   bind_managed_buffer_T<glm::vec2>(m, ps::ManagedBufferType::Vec2)
     .def("update_data", [](ps::render::ManagedBuffer<glm::vec2>& s, Eigen::Matrix<float, Eigen::Dynamic, 2>& d) {
       if(d.rows() != s.size()) ps::exception("bad update size, should be " + std::to_string(s.size()) + " x 2");
-      s.ensureHostBufferAllocated();
-      for(uint32_t i = 0; i < s.size(); i++) s.data[i] = {d(i,0), d(i,1)};
+      s.ensureHostBufferPopulated();
+      for(uint32_t i = 0; i < s.size(); i++) s.setHostValue(i, {d(i,0), d(i,1)});
       s.markHostBufferUpdated();
     })
   ;
 
   bind_managed_buffer_T<glm::vec3>(m, ps::ManagedBufferType::Vec3)
     .def("update_data", [](ps::render::ManagedBuffer<glm::vec3>& s, Eigen::Matrix<float, Eigen::Dynamic, 3>& d) {
       if(d.rows() != s.size()) ps::exception("bad update size, should be " + std::to_string(s.size()) + " x 3");
-      s.ensureHostBufferAllocated();
-      for(uint32_t i = 0; i < s.size(); i++) s.data[i] = {d(i,0), d(i,1), d(i,2)};
+      s.ensureHostBufferPopulated();
+      for(uint32_t i = 0; i < s.size(); i++) s.setHostValue(i, {d(i,0), d(i,1), d(i,2)});
       s.markHostBufferUpdated();
     })
   ;
 
   bind_managed_buffer_T<glm::vec4>(m, ps::ManagedBufferType::Vec4)
     .def("update_data", [](ps::render::ManagedBuffer<glm::vec4>& s, Eigen::Matrix<float, Eigen::Dynamic, 4>& d) {
       if(d.rows() != s.size() || d.cols() != 4) ps::exception("bad update size, should be " + std::to_string(s.size()) + " x 4");
-      s.ensureHostBufferAllocated();
-      for(uint32_t i = 0; i < s.size(); i++) s.data[i] = {d(i,0), d(i,1), d(i,2), d(i,3)};
+      s.ensureHostBufferPopulated();
+      for(uint32_t i = 0; i < s.size(); i++) s.setHostValue(i, {d(i,0), d(i,1), d(i,2), d(i,3)});
       s.markHostBufferUpdated();
     })
   ;
@@ -112,11 +112,11 @@ void bind_managed_buffer(nb::module_& m) {
       for(uint32_t k = 0; k < 2; k++) {
         if(d[k].rows() != s.size()) ps::exception("bad update size, should be " + std::to_string(s.size()) + " x 3");
       }
-      s.ensureHostBufferAllocated();
+      s.ensureHostBufferPopulated();
       for(uint32_t i = 0; i < s.size(); i++) {
-        for(uint32_t k = 0; k < 2; k++) {
-          s.data[i][k] = {d[k](i,0), d[k](i,1), d[k](i,2)};
-        }
+        std::array<glm::vec3, 2> val;
+        for(uint32_t k = 0; k < 2; k++) val[k] = {d[k](i,0), d[k](i,1), d[k](i,2)};
+        s.setHostValue(i, val);
       }
       s.markHostBufferUpdated();
     })
@@ -128,11 +128,11 @@ void bind_managed_buffer(nb::module_& m) {
       for(uint32_t k = 0; k < 3; k++) {
         if(d[k].rows() != s.size()) ps::exception("bad update size, should be " + std::to_string(s.size()) + " x 3");
       }
-      s.ensureHostBufferAllocated();
+      s.ensureHostBufferPopulated();
       for(uint32_t i = 0; i < s.size(); i++) {
-        for(uint32_t k = 0; k < 3; k++) {
-          s.data[i][k] = {d[k](i,0), d[k](i,1), d[k](i,2)};
-        }
+        std::array<glm::vec3, 3> val;
+        for(uint32_t k = 0; k < 3; k++) val[k] = {d[k](i,0), d[k](i,1), d[k](i,2)};
+        s.setHostValue(i, val);
       }
       s.markHostBufferUpdated();
     })
@@ -143,11 +143,11 @@ void bind_managed_buffer(nb::module_& m) {
       for(uint32_t k = 0; k < 4; k++) {
         if(d[k].rows() != s.size()) ps::exception("bad update size, should be " + std::to_string(s.size()) + " x 3");
       }
-      s.ensureHostBufferAllocated();
+      s.ensureHostBufferPopulated();
       for(uint32_t i = 0; i < s.size(); i++) {
-        for(uint32_t k = 0; k < 4; k++) {
-          s.data[i][k] = {d[k](i,0), d[k](i,1), d[k](i,2)};
-        }
+        std::array<glm::vec3, 4> val;
+        for(uint32_t k = 0; k < 4; k++) val[k] = {d[k](i,0), d[k](i,1), d[k](i,2)};
+        s.setHostValue(i, val);
       }
       s.markHostBufferUpdated();
     })
@@ -156,26 +156,26 @@ void bind_managed_buffer(nb::module_& m) {
   bind_managed_buffer_T<uint32_t>(m, ps::ManagedBufferType::UInt32)
     .def("update_data", [](ps::render::ManagedBuffer<uint32_t>& s, Eigen::Matrix<uint32_t, Eigen::Dynamic, 1>& d) {
       if(d.rows() != s.size()) ps::exception("bad update size, should be " + std::to_string(s.size()));
-      s.ensureHostBufferAllocated();
-      for(uint32_t i = 0; i < s.size(); i++) s.data[i] = d(i);
+      s.ensureHostBufferPopulated();
+      for(uint32_t i = 0; i < s.size(); i++) s.setHostValue(i, d(i));
       s.markHostBufferUpdated();
     })
   ;
 
   bind_managed_buffer_T<int32_t>(m, ps::ManagedBufferType::Int32)
     .def("update_data", [](ps::render::ManagedBuffer<uint32_t>& s, Eigen::Matrix<int32_t, Eigen::Dynamic, 1>& d) {
       if(d.rows() != s.size()) ps::exception("bad update size, should be " + std::to_string(s.size()));
-      s.ensureHostBufferAllocated();
-      for(uint32_t i = 0; i < s.size(); i++) s.data[i] = d(i);
+      s.ensureHostBufferPopulated();
+      for(uint32_t i = 0; i < s.size(); i++) s.setHostValue(i, d(i));
       s.markHostBufferUpdated();
     })
   ;
 
   bind_managed_buffer_T<glm::uvec2>(m, ps::ManagedBufferType::UVec2)
     .def("update_data", [](ps::render::ManagedBuffer<glm::uvec2>& s, Eigen::Matrix<uint32_t, Eigen::Dynamic, 2>& d) {
       if(d.rows() != s.size()) ps::exception("bad update size, should be " + std::to_string(s.size()) + " x 2");
-      s.ensureHostBufferAllocated();
-      for(uint32_t i = 0; i < s.size(); i++) s.data[i] = {d(i,0), d(i,1)};
+      s.ensureHostBufferPopulated();
+      for(uint32_t i = 0; i < s.size(); i++) s.setHostValue(i, {d(i,0), d(i,1)});
       s.markHostBufferUpdated();
     })
   ;
@@ -184,17 +184,17 @@ void bind_managed_buffer(nb::module_& m) {
   bind_managed_buffer_T<glm::uvec3>(m, ps::ManagedBufferType::UVec3)
     .def("update_data", [](ps::render::ManagedBuffer<glm::uvec3>& s, Eigen::Matrix<uint32_t, Eigen::Dynamic, 3>& d) {
       if(d.rows() != s.size()) ps::exception("bad update size, should be " + std::to_string(s.size()) + " x 3");
-      s.ensureHostBufferAllocated();
-      for(uint32_t i = 0; i < s.size(); i++) s.data[i] = {d(i,0), d(i,1), d(i,2)};
+      s.ensureHostBufferPopulated();
+      for(uint32_t i = 0; i < s.size(); i++) s.setHostValue(i, {d(i,0), d(i,1), d(i,2)});
       s.markHostBufferUpdated();
     })
   ;
 
   bind_managed_buffer_T<glm::uvec4>(m, ps::ManagedBufferType::UVec4)
     .def("update_data", [](ps::render::ManagedBuffer<glm::uvec4>& s, Eigen::Matrix<uint32_t, Eigen::Dynamic, 4>& d) {
       if(d.rows() != s.size()) ps::exception("bad update size, should be " + std::to_string(s.size()) + " x 4");
-      s.ensureHostBufferAllocated();
-      for(uint32_t i = 0; i < s.size(); i++) s.data[i] = {d(i,0), d(i,1), d(i,2), d(i,3)};
+      s.ensureHostBufferPopulated();
+      for(uint32_t i = 0; i < s.size(); i++) s.setHostValue(i, {d(i,0), d(i,1), d(i,2), d(i,3)});
       s.markHostBufferUpdated();
     })
   ;

src/cpp/simple_triangle_mesh.cpp

@@ -0,0 +1,96 @@
+#include "Eigen/Dense"
+
+#include "polyscope/polyscope.h"
+#include "polyscope/simple_triangle_mesh.h"
+
+#include "utils.h"
+
+void bind_simple_triangle_mesh(nb::module_& m) {
+
+  // == Quantity types
+
+  // Scalar quantities
+  bindScalarQuantity<ps::SimpleTriangleMeshVertexScalarQuantity>(m, "SimpleTriangleMeshVertexScalarQuantity")
+      .def("update_data", &ps::SimpleTriangleMeshVertexScalarQuantity::updateData<Eigen::VectorXf>,
+           nb::arg("values"), "Update scalar values (count must stay the same)");
+  bindScalarQuantity<ps::SimpleTriangleMeshFaceScalarQuantity>(m, "SimpleTriangleMeshFaceScalarQuantity")
+      .def("update_data", &ps::SimpleTriangleMeshFaceScalarQuantity::updateData<Eigen::VectorXf>,
+           nb::arg("values"), "Update scalar values (count must stay the same)");
+
+  // Color quantities
+  bindColorQuantity<ps::SimpleTriangleMeshVertexColorQuantity>(m, "SimpleTriangleMeshVertexColorQuantity")
+      .def("update_data", &ps::SimpleTriangleMeshVertexColorQuantity::updateData<Eigen::MatrixXf>,
+           nb::arg("values"), "Update color values (count must stay the same)");
+  bindColorQuantity<ps::SimpleTriangleMeshFaceColorQuantity>(m, "SimpleTriangleMeshFaceColorQuantity")
+      .def("update_data", &ps::SimpleTriangleMeshFaceColorQuantity::updateData<Eigen::MatrixXf>,
+           nb::arg("values"), "Update color values (count must stay the same)");
+
+
+  // == Helper classes
+  nb::class_<ps::SimpleTriangleMeshPickResult>(m, "SimpleTriangleMeshPickResult")
+      .def(nb::init<>())
+      .def_ro("element_type", &ps::SimpleTriangleMeshPickResult::elementType)
+      .def_ro("index", &ps::SimpleTriangleMeshPickResult::index);
+
+
+  // == Main class
+  bindStructure<ps::SimpleTriangleMesh>(m, "SimpleTriangleMesh")
+
+      // basics
+      .def("n_vertices", &ps::SimpleTriangleMesh::nVertices, "# vertices")
+      .def("n_faces", &ps::SimpleTriangleMesh::nFaces, "# faces")
+
+      // update
+      .def("update_vertex_positions", &ps::SimpleTriangleMesh::updateVertexPositions<Eigen::MatrixXf>,
+           "Update vertex positions (vertex count must stay the same)")
+      .def("update_mesh", &ps::SimpleTriangleMesh::updateMesh<Eigen::MatrixXf, Eigen::MatrixXi>,
+           nb::arg("vertices"), nb::arg("faces"),
+           "Update vertices and faces (counts may change)")
+      .def("reserve_mesh_capacity", &ps::SimpleTriangleMesh::reserveMeshCapacity,
+           nb::arg("n_verts"), nb::arg("n_faces"),
+           "Pre-allocate capacity to avoid reallocations on future updates")
+
+      // options
+      .def("set_color", &ps::SimpleTriangleMesh::setSurfaceColor, "Set surface color")
+      .def("get_color", &ps::SimpleTriangleMesh::getSurfaceColor, "Get surface color")
+      .def("set_back_face_policy", &ps::SimpleTriangleMesh::setBackFacePolicy, "Set back face policy")
+      .def("get_back_face_policy", &ps::SimpleTriangleMesh::getBackFacePolicy, "Get back face policy")
+      .def("set_back_face_color", &ps::SimpleTriangleMesh::setBackFaceColor, "Set back face color")
+      .def("get_back_face_color", &ps::SimpleTriangleMesh::getBackFaceColor, "Get back face color")
+      .def("set_material", &ps::SimpleTriangleMesh::setMaterial, "Set material")
+      .def("get_material", &ps::SimpleTriangleMesh::getMaterial, "Get material")
+      .def("set_selection_mode", &ps::SimpleTriangleMesh::setSelectionMode, "Set selection mode")
+      .def("get_selection_mode", &ps::SimpleTriangleMesh::getSelectionMode, "Get selection mode")
+
+      // picking
+      .def("interpret_pick_result", &ps::SimpleTriangleMesh::interpretPickResult)
+
+      // quantities — scalars
+      .def("add_vertex_scalar_quantity", &ps::SimpleTriangleMesh::addVertexScalarQuantity<Eigen::VectorXf>,
+           "Add a scalar quantity at vertices", nb::arg("name"), nb::arg("values"),
+           nb::arg("data_type") = ps::DataType::STANDARD, nb::rv_policy::reference)
+      .def("add_face_scalar_quantity", &ps::SimpleTriangleMesh::addFaceScalarQuantity<Eigen::VectorXf>,
+           "Add a scalar quantity at faces", nb::arg("name"), nb::arg("values"),
+           nb::arg("data_type") = ps::DataType::STANDARD, nb::rv_policy::reference)
+
+      // quantities — colors
+      .def("add_vertex_color_quantity", &ps::SimpleTriangleMesh::addVertexColorQuantity<Eigen::MatrixXf>,
+           "Add a color quantity at vertices", nb::arg("name"), nb::arg("values"), nb::rv_policy::reference)
+      .def("add_face_color_quantity", &ps::SimpleTriangleMesh::addFaceColorQuantity<Eigen::MatrixXf>,
+           "Add a color quantity at faces", nb::arg("name"), nb::arg("values"), nb::rv_policy::reference);
+
+
+  // == Module-level functions
+  m.def("register_simple_triangle_mesh",
+        &ps::registerSimpleTriangleMesh<Eigen::MatrixXf, Eigen::MatrixXi>,
+        nb::arg("name"), nb::arg("vertices"), nb::arg("faces"),
+        "Register a simple triangle mesh", nb::rv_policy::reference);
+
+  m.def("remove_simple_triangle_mesh", &ps::removeSimpleTriangleMesh,
+        nb::arg("name"), nb::arg("error_if_absent") = false,
+        "Remove a simple triangle mesh by name");
+  m.def("get_simple_triangle_mesh", &ps::getSimpleTriangleMesh,
+        nb::arg("name") = "", "Get a simple triangle mesh by name", nb::rv_policy::reference);
+  m.def("has_simple_triangle_mesh", &ps::hasSimpleTriangleMesh,
+        nb::arg("name") = "", "Check for a simple triangle mesh by name");
+}

src/polyscope/__init__.py

@@ -51,6 +51,7 @@
 from polyscope.device_interop import *  # noqa F403
 
 from polyscope.surface_mesh import *  # noqa F403
+from polyscope.simple_triangle_mesh import *  # noqa F403
 from polyscope.point_cloud import *  # noqa F403
 from polyscope.curve_network import *  # noqa F403
 from polyscope.volume_mesh import *  # noqa F403