rework ManagedBuffer class, change buffer ownership and capacity handling

include/polyscope/color_image_quantity.h

@@ -34,8 +34,6 @@ class ColorImageQuantity : public ImageQuantity {
 
 
 protected:
-  std::vector<glm::vec4> colorsData;
-
   PersistentValue<bool> isPremultiplied;
 
   // rendering internals

include/polyscope/color_quantity.h

@@ -39,8 +39,6 @@ class ColorQuantity {
   // === ~DANGER~ experimental/unsupported functions
 
 protected:
-  std::vector<glm::vec3> colorsData;
-
   // === Visualization parameters
 
   // Parameters

include/polyscope/color_quantity.ipp

@@ -4,7 +4,7 @@ namespace polyscope {
 
 template <typename QuantityT>
 ColorQuantity<QuantityT>::ColorQuantity(QuantityT& quantity_, const std::vector<glm::vec3>& colors_)
-    : quantity(quantity_), colors(&quantity, quantity.uniquePrefix() + "colors", colorsData), colorsData(colors_) {
+    : quantity(quantity_), colors(&quantity, quantity.uniquePrefix() + "colors", std::vector<glm::vec3>(colors_)) {
   colors.checkInvalidValues();
 }
 
@@ -27,7 +27,9 @@ template <typename QuantityT>
 template <class V>
 void ColorQuantity<QuantityT>::updateData(const V& newColors) {
   validateSize(newColors, colors.size(), "color quantity");
-  colors.data = standardizeVectorArray<glm::vec3, 3>(newColors);
+  auto d = standardizeVectorArray<glm::vec3, 3>(newColors);
+  colors.resize(d.size());
+  colors.setDataHost(d);
   colors.markHostBufferUpdated();
 }
 

include/polyscope/color_render_image_quantity.h

@@ -37,9 +37,6 @@ class ColorRenderImageQuantity : public RenderImageQuantityBase {
 protected:
   // === Visualization parameters
 
-  // Store the raw data
-  std::vector<glm::vec3> colorsData;
-
   // === Render data
   std::shared_ptr<render::ShaderProgram> program;
 
@@ -60,7 +57,7 @@ void ColorRenderImageQuantity::updateBuffers(const T1& depthData, const T2& norm
   std::vector<glm::vec3> standardNormal(standardizeVectorArray<glm::vec3, 3>(normalData));
   std::vector<glm::vec3> standardColor(standardizeVectorArray<glm::vec3, 3>(colorsData));
 
-  colors.data = standardColor;
+  colors.setDataHost(standardColor);
   colors.markHostBufferUpdated();
 
   updateBaseBuffers(standardDepth, standardNormal);

include/polyscope/curve_network.h

@@ -162,13 +162,6 @@ class CurveNetwork : public Structure {
 
 
 private:
-  // Storage for the managed buffers above. You should generally interact with these through the managed buffers, not
-  // these members.
-  std::vector<glm::vec3> nodePositionsData;
-  std::vector<uint32_t> edgeTailIndsData;
-  std::vector<uint32_t> edgeTipIndsData;
-  std::vector<glm::vec3> edgeCentersData;
-
   void computeEdgeCenters();
 
   // === Visualization parameters

include/polyscope/curve_network.ipp

@@ -170,7 +170,9 @@ CurveNetwork* registerCurveNetworkLoop2D(std::string name, const P& nodes) {
 template <class V>
 void CurveNetwork::updateNodePositions(const V& newPositions) {
   validateSize(newPositions, nNodes(), "newPositions");
-  nodePositions.data = standardizeVectorArray<glm::vec3, 3>(newPositions);
+  auto d = standardizeVectorArray<glm::vec3, 3>(newPositions);
+  nodePositions.resize(d.size());
+  nodePositions.setDataHost(d);
   nodePositions.markHostBufferUpdated();
   recomputeGeometryIfPopulated();
 }

include/polyscope/curve_network_color_quantity.h

@@ -58,9 +58,6 @@ class CurveNetworkEdgeColorQuantity : public CurveNetworkColorQuantity {
 
   render::ManagedBuffer<glm::vec3> nodeAverageColors;
   void updateNodeAverageColors();
-
-private:
-  std::vector<glm::vec3> nodeAverageColorsData;
 };
 
 } // namespace polyscope

include/polyscope/curve_network_scalar_quantity.h

@@ -59,9 +59,6 @@ class CurveNetworkEdgeScalarQuantity : public CurveNetworkScalarQuantity {
 
   render::ManagedBuffer<float> nodeAverageValues;
   void updateNodeAverageValues();
-
-private:
-  std::vector<float> nodeAverageValuesData;
 };
 
 

include/polyscope/parameterization_quantity.h

@@ -70,9 +70,6 @@ class ParameterizationQuantity {
   void setParameterizationUniforms(render::ShaderProgram& p);
 
 protected:
-  // Raw storage for the data. You should only interact with this via the managed buffer above
-  std::vector<glm::vec2> coordsData;
-  std::vector<float> islandLabelsData;
   bool islandLabelsPopulated = false;
 
   // === Visualization parameters

include/polyscope/parameterization_quantity.ipp

@@ -40,9 +40,8 @@ ParameterizationQuantity<QuantityT>::ParameterizationQuantity(QuantityT& quantit
     : quantity(quantity_),
 
       // buffers
-      coords(&quantity, quantity.uniquePrefix() + "#coords", coordsData),
-      islandLabels(&quantity, quantity.uniquePrefix() + "#islandLabels", islandLabelsData), coordsType(type_),
-      coordsData(coords_),
+      coords(&quantity, quantity.uniquePrefix() + "#coords", std::vector<glm::vec2>(coords_)),
+      islandLabels(&quantity, quantity.uniquePrefix() + "#islandLabels", std::vector<float>{}), coordsType(type_),
 
       // options
       checkerSize(quantity.uniquePrefix() + "#checkerSize", 0.02),
@@ -227,7 +226,9 @@ template <typename QuantityT>
 template <class V>
 void ParameterizationQuantity<QuantityT>::updateCoords(const V& newCoords) {
   validateSize(newCoords, coords.size(), "parameterization quantity " + quantity.name);
-  coords.data = standardizeVectorArray<glm::vec2, 2>(newCoords);
+  auto d = standardizeVectorArray<glm::vec2, 2>(newCoords);
+  coords.resize(d.size());
+  coords.setDataHost(d);
   coords.markHostBufferUpdated();
 }
 

include/polyscope/point_cloud.h

@@ -154,8 +154,6 @@ class PointCloud : public Structure {
 
 
 private:
-  // Storage for the managed buffers above. You should generally interact with this directly through them.
-  std::vector<glm::vec3> pointsData;
 
   // === Visualization parameters
   PersistentValue<std::string> pointRenderMode;

include/polyscope/point_cloud.ipp

@@ -36,7 +36,9 @@ PointCloud* registerPointCloud2D(std::string name, const T& points) {
 template <class V>
 void PointCloud::updatePointPositions(const V& newPositions) {
   validateSize(newPositions, nPoints(), "point cloud updated positions " + name);
-  points.data = standardizeVectorArray<glm::vec3, 3>(newPositions);
+  auto d = standardizeVectorArray<glm::vec3, 3>(newPositions);
+  points.resize(d.size());
+  points.setDataHost(d);
   points.markHostBufferUpdated();
 }
 

include/polyscope/raw_color_alpha_render_image_quantity.h

@@ -35,9 +35,6 @@ class RawColorAlphaRenderImageQuantity : public RenderImageQuantityBase {
   bool getIsPremultiplied();
 
 protected:
-  // Store the raw data
-  std::vector<glm::vec4> colorsData;
-
   // === Visualization parameters
   PersistentValue<bool> isPremultiplied;
 
@@ -59,7 +56,7 @@ void RawColorAlphaRenderImageQuantity::updateBuffers(const T1& depthData, const
   std::vector<glm::vec3> standardNormal;
   std::vector<glm::vec4> standardColor(standardizeVectorArray<glm::vec4, 4>(colorsData));
 
-  colors.data = standardColor;
+  colors.setDataHost(standardColor);
   colors.markHostBufferUpdated();
 
   updateBaseBuffers(standardDepth, standardNormal);

include/polyscope/raw_color_render_image_quantity.h

@@ -35,9 +35,6 @@ class RawColorRenderImageQuantity : public RenderImageQuantityBase {
 protected:
   // === Visualization parameters
 
-  // Store the raw data
-  std::vector<glm::vec3> colorsData;
-
   // === Render data
   std::shared_ptr<render::ShaderProgram> program;
 
@@ -56,7 +53,7 @@ void RawColorRenderImageQuantity::updateBuffers(const T1& depthData, const T2& c
   std::vector<glm::vec3> standardNormal;
   std::vector<glm::vec3> standardColor(standardizeVectorArray<glm::vec3, 3>(colorsData));
 
-  colors.data = standardColor;
+  colors.setDataHost(standardColor);
   colors.markHostBufferUpdated();
 
   updateBaseBuffers(standardDepth, standardNormal);

include/polyscope/render/engine.h

@@ -17,6 +17,12 @@
 
 namespace polyscope {
 
+// Forward declarations for ManagedBuffer integration
+namespace render {
+  class ManagedBufferBase;
+  template <typename T> class ManagedBuffer;
+} // namespace render
+
 // == A few enums that control behavior
 // public enums are in the outer namespace to keep the typing burden down
 
@@ -96,6 +102,10 @@ class AttributeBuffer {
   virtual void setData(const std::vector<std::array<glm::vec3, 3>>& data) = 0;
   virtual void setData(const std::vector<std::array<glm::vec3, 4>>& data) = 0;
 
+  // Pre-allocate GPU memory for n elements without uploading any data. Subsequent setData()
+  // calls with size <= n will not need to reallocate the underlying buffer.
+  virtual void reserveCapacity(size_t n) = 0;
+
   virtual uint32_t getNativeBufferID() = 0; // used to interop with external things, e.g. ImGui
 
   // == Getters
@@ -391,7 +401,7 @@ class ShaderProgram {
   virtual bool hasAttribute(std::string name) = 0;
   virtual bool attributeIsSet(std::string name) = 0;
   virtual std::shared_ptr<AttributeBuffer> getAttributeBuffer(std::string name) = 0;
-  virtual void setAttribute(std::string name, std::shared_ptr<AttributeBuffer> externalBuffer) = 0; 
+  virtual void setAttribute(std::string name, std::shared_ptr<AttributeBuffer> externalBuffer, ManagedBufferBase* source = nullptr) = 0;
   virtual void setAttribute(std::string name, const std::vector<glm::vec2>& data) = 0;
   virtual void setAttribute(std::string name, const std::vector<glm::vec3>& data) = 0;
   virtual void setAttribute(std::string name, const std::vector<glm::vec4>& data) = 0;
@@ -414,8 +424,13 @@ class ShaderProgram {
                             bool withAlpha = true, bool useMipMap = false, bool repeat = false) = 0;
   virtual void setTextureFromColormap(std::string name, const std::string& colorMap, bool allowUpdate = false) = 0;
   // TODO make this one take a shared pointer and have the same semantics as the attribute version
-  virtual void setTextureFromBuffer(std::string name, TextureBuffer* textureBuffer) = 0;
+  virtual void setTextureFromBuffer(std::string name, TextureBuffer* textureBuffer, ManagedBufferBase* source = nullptr) = 0;
+
 
+  // Convenience overloads for ManagedBuffer — set the buffer AND record the source for lazy sync.
+  // Defined in managed_buffer.h after ManagedBuffer<T> is fully declared.
+  template <typename T> void setAttribute(std::string name, ManagedBuffer<T>& buf);
+  template <typename T> void setTextureFromBuffer(std::string name, ManagedBuffer<T>& buf);
 
   // Indices
   virtual void setIndex(std::shared_ptr<AttributeBuffer> externalBuffer) = 0;