update for new managed buffer setup

Author: nmwsharp

include/polyscope/simple_triangle_mesh.ipp

@@ -26,53 +26,36 @@ SimpleTriangleMesh* registerSimpleTriangleMesh(std::string name, const V& vertex
 template <class V>
 void SimpleTriangleMesh::updateVertices(const V& newPositions) {
   validateSize(newPositions, vertices.size(), "newPositions");
-  auto d = standardizeVectorArray<glm::vec3, 3>(newPositions);
-  vertices.resize(d.size());
-  vertices.setDataHost(d);
-  vertices.markHostBufferUpdated();
+  vertices.setDataHost(standardizeVectorArray<glm::vec3, 3>(newPositions));
 }
 
 template <class V, class F>
 void SimpleTriangleMesh::update(const V& newPositions, const F& newFaces) {
-  {
-    auto d = standardizeVectorArray<glm::vec3, 3>(newPositions);
-    vertices.resize(d.size());
-    vertices.setDataHost(d);
-  }
-  vertices.markHostBufferUpdated();
+  auto vertsStd = standardizeVectorArray<glm::vec3, 3>(newPositions);
+  vertices.resize(vertsStd.size()); // ManagedBuffer internally does amortized doubling to make this efficient
+  vertices.setDataHost(vertsStd);
 
-  {
-    auto d = standardizeVectorArray<glm::uvec3, 3>(newFaces);
-    faces.resize(d.size());
-    faces.setDataHost(d);
-  }
-  faces.markHostBufferUpdated();
+  auto facesStd = standardizeVectorArray<glm::uvec3, 3>(newFaces);
+  faces.resize(facesStd.size());
+  faces.setDataHost(facesStd);
 }
 
 template <class V>
 void SimpleTriangleMesh::updateVertexPositions(const V& newPositions) {
   validateSize(newPositions, nVertices(), "newPositions");
-  verticesData = standardizeVectorArray<glm::vec3, 3>(newPositions);
-  vertices.markHostBufferUpdated();
+  vertices.setDataHost(standardizeVectorArray<glm::vec3, 3>(newPositions));
   updateObjectSpaceBounds();
 }
 
 template <class V, class F>
 void SimpleTriangleMesh::updateMesh(const V& newVerts, const F& newFaces) {
-  std::vector<glm::vec3> vertsStd = standardizeVectorArray<glm::vec3, 3>(newVerts);
-  if (vertsStd.size() > verticesData.capacity()) {
-    // amortized doubling on the CPU-side backing vectors.
-    verticesData.reserve(std::max(vertsStd.size(), 2 * verticesData.capacity()));
-  }
-  verticesData = std::move(vertsStd);
-  vertices.markHostBufferUpdated();
+  auto vertsStd = standardizeVectorArray<glm::vec3, 3>(newVerts);
+  vertices.resize(vertsStd.size()); // amortized doubling handled by ManagedBuffer
+  vertices.setDataHost(vertsStd);
 
-  std::vector<glm::uvec3> facesStd = standardizeVectorArray<glm::uvec3, 3>(newFaces);
-  if (facesStd.size() > facesData.capacity()) {
-    facesData.reserve(std::max(facesStd.size(), 2 * facesData.capacity()));
-  }
-  facesData = std::move(facesStd);
-  faces.markHostBufferUpdated();
+  auto facesStd = standardizeVectorArray<glm::uvec3, 3>(newFaces);
+  faces.resize(facesStd.size());
+  faces.setDataHost(facesStd);
 
   updateObjectSpaceBounds();
 }

include/polyscope/simple_triangle_mesh_color_quantity.h

@@ -29,10 +29,9 @@ class SimpleTriangleMeshColorQuantity : public SimpleTriangleMeshQuantity,
   // For same-size updates, prefer ColorQuantity::updateData() which validates the size.
   template <class V>
   void updateData(const V& newColors) {
-    std::vector<glm::vec3> newData = standardizeVectorArray<glm::vec3, 3>(newColors);
-    colors.resize(newData.size());
-    colors.data.assign(newData.begin(), newData.end());
-    colors.markHostBufferUpdated();
+    auto newData = standardizeVectorArray<glm::vec3, 3>(newColors);
+    colors.resize(newData.size()); // amortized doubling handled by ManagedBuffer
+    colors.setDataHost(newData);
   }
 
   const std::string definedOn;

include/polyscope/simple_triangle_mesh_scalar_quantity.h

@@ -30,10 +30,9 @@ class SimpleTriangleMeshScalarQuantity : public SimpleTriangleMeshQuantity,
   // For same-size updates, prefer ScalarQuantity::updateData() which validates the size.
   template <class V>
   void updateData(const V& newValues) {
-    std::vector<float> newData = standardizeArray<float, V>(newValues);
-    values.resize(newData.size());
-    values.data.assign(newData.begin(), newData.end());
-    values.markHostBufferUpdated();
+    auto newData = standardizeArray<float, V>(newValues);
+    values.resize(newData.size()); // amortized doubling handled by ManagedBuffer
+    values.setDataHost(newData);
   }
 
   const std::string definedOn;

src/simple_triangle_mesh.cpp

@@ -307,8 +307,8 @@ void SimpleTriangleMesh::updateObjectSpaceBounds() {
 }
 
 void SimpleTriangleMesh::reserve(size_t nVerts, size_t nFaces) {
-  verticesData.reserve(nVerts);
-  facesData.reserve(nFaces);
+  vertices.setCapacity(nVerts);
+  faces.setCapacity(nFaces);
 }
 
 SimpleTriangleMeshPickResult SimpleTriangleMesh::interpretPickResult(const PickResult& rawResult) {

src/simple_triangle_mesh_color_quantity.cpp

@@ -112,6 +112,7 @@ SimpleTriangleMeshFaceColorQuantity::SimpleTriangleMeshFaceColorQuantity(std::st
                                                                          const std::vector<glm::vec3>& colors_,
                                                                          SimpleTriangleMesh& mesh_)
     : SimpleTriangleMeshColorQuantity(name, colors_, "face", mesh_) {
+  colors.setAsType(DeviceBufferType::Texture1d);
   colors.setTextureSize(parent.nFaces());
 }
 

src/simple_triangle_mesh_scalar_quantity.cpp

@@ -107,6 +107,7 @@ SimpleTriangleMeshFaceScalarQuantity::SimpleTriangleMeshFaceScalarQuantity(std::
                                                                            SimpleTriangleMesh& mesh_,
                                                                            DataType dataType_)
     : SimpleTriangleMeshScalarQuantity(name, values_, "face", mesh_, dataType_) {
+  values.setAsType(DeviceBufferType::Texture1d);
   values.setTextureSize(parent.nFaces());
 }