fixed showField vbo/ibo generation and spire::VarBuffer. Left Print sataments in

Author: Haydelj

src/Externals/spire/var-buffer/VarBuffer.cpp

@@ -8,13 +8,13 @@ namespace spire {
 
 VarBuffer::VarBuffer() :
 mBuffer(1024),
-    mBufferSize(1024)
+mBufferSize(1024)
 {
   RENDERER_LOG("VarBuffer ctor (mBufferSize {})", mBufferSize);
   mSerializer.reset(new spire::BSerialize(getBuffer(), mBufferSize));
 }
 
-VarBuffer::VarBuffer(uint32_t size) :
+VarBuffer::VarBuffer(size_t size) :
 mBuffer(size),
 mBufferSize(size)
 {

src/Externals/spire/var-buffer/VarBuffer.hpp

@@ -21,11 +21,11 @@ class SCISHARE VarBuffer final
   VarBuffer();
 
   // Preallocate the variable buffer to the preset size.
-  explicit VarBuffer(uint32_t size);
+  explicit VarBuffer(size_t size);
 
-  /// \todo Add flag which will swap bytes when reading out of or into buffer.
+  // todo Add flag which will swap bytes when reading out of or into buffer.
 
-  /// Writes \p numBytes of \p bytes.
+  // Writes numBytes of bytes.
   void writeBytes(const char* bytes, size_t numBytes);
 
   /// Writes a null terminated string.
@@ -53,7 +53,7 @@ class SCISHARE VarBuffer final
   size_t getBufferSize() const {return mSerializer->getOffset();}
 
   /// Retrieves currently allocated size of the buffer.
-  int getAllocatedSize() const {return mBufferSize;}
+  size_t getAllocatedSize() const {return mBufferSize;}
 
 private:
 
@@ -65,7 +65,7 @@ class SCISHARE VarBuffer final
   static uint16_t deserializeUInt16(const char* msg, int msgLen, int* offset_out);
 
   std::vector<char> mBuffer;      ///< buffer
-  int     mBufferSize;  ///< Absolute size of mBuffer in bytes.
+  size_t            mBufferSize;  ///< Absolute size of mBuffer in bytes.
 
   std::unique_ptr<spire::BSerialize> mSerializer;
 };

src/Graphics/Datatypes/GeometryImpl.h

@@ -85,7 +85,7 @@ namespace SCIRun {
         SpireVBO() : numElements(0), onGPU(false) {}
         SpireVBO(const std::string& vboName, const std::vector<AttributeData> attribs,
           std::shared_ptr<spire::VarBuffer> vboData,
-          int64_t numVBOElements, const Core::Geometry::BBox& bbox, bool placeOnGPU) :
+          size_t numVBOElements, const Core::Geometry::BBox& bbox, bool placeOnGPU) :
           name(vboName),
           attributes(attribs),
           data(vboData),
@@ -96,8 +96,8 @@ namespace SCIRun {
 
         std::string                           name;
         std::vector<AttributeData>            attributes;
-        std::shared_ptr<spire::VarBuffer> data; // Change to unique_ptr w/ move semantics (possibly).
-        int64_t                               numElements;
+        std::shared_ptr<spire::VarBuffer>     data; // Change to unique_ptr w/ move semantics (possibly).
+        size_t                                numElements;
         Core::Geometry::BBox                  boundingBox;
         bool                                  onGPU;
       };
@@ -123,7 +123,7 @@ namespace SCIRun {
         std::string                           name;
         size_t                                indexSize;
         PRIMITIVE                             prim;
-        std::shared_ptr<spire::VarBuffer> data; // Change to unique_ptr w/ move semantics (possibly).
+        std::shared_ptr<spire::VarBuffer>     data; // Change to unique_ptr w/ move semantics (possibly).
       };
 
       struct SpireText

src/Modules/Visualization/ShowField.cc

@@ -430,6 +430,11 @@ void GeometryBuilder::renderFaces(
 }
 
 
+
+static size_t vboInsertionSize = 0;
+static size_t iboInsertionSize = 0;
+static size_t vboLastPrintSize = 0;
+static size_t iboLastPrintSize = 0;
 void GeometryBuilder::renderFacesLinear(
   FieldHandle field,
   boost::optional<boost::shared_ptr<ColorMap>> colorMap,
@@ -439,20 +444,29 @@ void GeometryBuilder::renderFacesLinear(
   unsigned int approxDiv,
   const std::string& id)
 {
+  vboInsertionSize = 0;
+  iboInsertionSize = 0;
+  vboLastPrintSize = 0;
+  iboLastPrintSize = 0;
+
   VField* fld = field->vfield();
   VMesh*  mesh = field->vmesh();
 
   mesh->synchronize(Mesh::FACES_E);
 
   VMesh::Face::size_type numFaces;
+  int numAttributes = 3; //intially 3 because we will atleast be rendering verticies (vec3's)
 
   mesh->size(numFaces);
-
   if (numFaces == 0)
     return;
 
-  bool withNormals = (state.get(RenderState::USE_NORMALS));
-  if (withNormals) { mesh->synchronize(Mesh::NORMALS_E); }
+  bool withNormals = state.get(RenderState::USE_NORMALS);
+  if (withNormals)
+  {
+    numAttributes += 3;
+    mesh->synchronize(Mesh::NORMALS_E);
+  }
 
   bool invertNormals = state_->getValue(ShowField::FaceInvertNormals).toBool();
   ColorScheme colorScheme = ColorScheme::COLOR_UNIFORM;
@@ -467,58 +481,58 @@ void GeometryBuilder::renderFacesLinear(
   }
   else if (state.get(RenderState::USE_COLORMAP))
   {
+    numAttributes += 4;
     colorScheme = ColorScheme::COLOR_MAP;
   }
   else // if (fld->basis_order() >= 0)
   {
+    numAttributes += 4;
     colorScheme = ColorScheme::COLOR_IN_SITU;
   }
 
-  // Three 32 bit ints to index into the VBO
-  uint32_t iboSize = static_cast<uint32_t>(mesh->num_faces() * sizeof(uint32_t) * 3);
-  //Seven floats per VBO: Pos (3) XYZ, and Color (4) RGBA
-  uint32_t vboSize = static_cast<uint32_t>(mesh->num_faces() * sizeof(float) * 7);
-
-  // Construct VBO and IBO that will be used to render the faces. Once again,
-  // IBOs are not strictly needed. But, we may be able to optimize this code
-  // somewhat.
-  /// \todo Switch to unique_ptrs and move semantics.
-  std::shared_ptr<spire::VarBuffer> iboBufferSPtr(
-    new spire::VarBuffer(vboSize));
-  std::shared_ptr<spire::VarBuffer> vboBufferSPtr(
-    new spire::VarBuffer(iboSize));
-
-  // Accessing the pointers like this is contrived. We only do this for
-  // speed since we will be using the pointers in a tight inner loop.
-  auto iboBuffer = iboBufferSPtr.get();
-  auto vboBuffer = vboBufferSPtr.get();
-
-  uint32_t iboIndex = 0;
-  int64_t numVBOElements = 0;
-
+  Point idpt;
   VMesh::Face::iterator fiter, fiterEnd;
   VMesh::Node::array_type nodes;
-
   mesh->begin(fiter);
   mesh->end(fiterEnd);
-
-  Point idpt;
   mesh->get_nodes(nodes, *fiter);
   mesh->get_point(idpt, nodes[0]);
 
+  std::cout << "Number of Attributes: " << numAttributes << "\n";
+  // Three 32 bit ints for each triangle to index into the VBO (triangles = verticies - 2)
+  size_t iboSize = static_cast<size_t>(mesh->num_faces() * sizeof(uint32_t) * (nodes.size() - 2) * 3);
+  size_t vboSize = static_cast<size_t>(mesh->num_faces() * sizeof(float) * nodes.size() * numAttributes);
+
+  //size_t vboSize = static_cast<size_t>(mesh->num_faces() * sizeof(uint32_t) * 3);
+  //size_t iboSize = static_cast<size_t>(mesh->num_faces() * sizeof(float) * 7);
+
+  std::cout << "Faces: " << mesh->num_faces() << "\n";
+  std::cout << "IBO buffer size: " << iboSize/1024/1024 << "MiB\n";
+  std::cout << "VBO buffer size: " << vboSize/1024/1024 << "MiB\n";
+
+  // Construct VBO and IBO that will be used to render the faces. Once again, IBOs are not strictly
+  // needed. But, we may be able to optimize this code somewhat.
+  // todo Switch to unique_ptrs and move semantics.
+  std::shared_ptr<spire::VarBuffer> iboBufferSPtr(new spire::VarBuffer(iboSize));
+  std::shared_ptr<spire::VarBuffer> vboBufferSPtr(new spire::VarBuffer(vboSize));
+
+  // Accessing the pointers like this is contrived. We only do this for speed since we will be
+  // using the pointers in a tight inner loop.
+  auto iboBuffer = iboBufferSPtr.get();
+  auto vboBuffer = vboBufferSPtr.get();
+
+  uint32_t iboIndex = 0;
+  size_t numVBOElements = 0;
+
   while (fiter != fiterEnd)
   {
     interruptible->checkForInterruption();
 
     mesh->get_nodes(nodes, *fiter);
-
     std::vector<Point> points(nodes.size());
     std::vector<Vector> normals(nodes.size());
-
     for (size_t i = 0; i < nodes.size(); i++)
-    {
       mesh->get_point(points[i], nodes[i]);
-    }
 
     //TODO fix so the withNormals tp be woth lighting is called correctly, and the meshes are fixed.
     if (withNormals)
@@ -575,12 +589,14 @@ void GeometryBuilder::renderFacesLinear(
         }
       }
     }
+
     // Default color single face no matter the element data.
     if (colorScheme == ColorScheme::COLOR_UNIFORM)
     {
       addFaceGeom(points, normals, withNormals, iboIndex, iboBuffer, vboBuffer,
         colorScheme, face_colors, state);
     }
+
     // Element data (Cells) so two sided faces.
     else if (fld->basis_order() == 0 && mesh->dimensionality() == 3)
     {
@@ -647,6 +663,7 @@ void GeometryBuilder::renderFacesLinear(
       addFaceGeom(points, normals, withNormals, iboIndex, iboBuffer, vboBuffer,
         colorScheme, face_colors, state);
     }
+
     // Element data (faces)
     else if (fld->basis_order() == 0 && mesh->dimensionality() == 2)
     {
@@ -855,19 +872,18 @@ void GeometryBuilder::renderFacesLinear(
     }
   }
 
-  SpireVBO geomVBO(vboName, attribs, vboBufferSPtr,
-    numVBOElements, mesh->get_bounding_box(), true);
-
+  SpireVBO geomVBO(vboName, attribs, vboBufferSPtr, numVBOElements, mesh->get_bounding_box(), true);
   geom->vbos().push_back(geomVBO);
 
-  // Construct IBO.
-
   SpireIBO geomIBO(iboName, SpireIBO::PRIMITIVE::TRIANGLES, sizeof(uint32_t), iboBufferSPtr);
-
   geom->ibos().push_back(geomIBO);
 
-  SpireText text;
+  std::cout << "Actual IBO size: " << iboBufferSPtr->getBufferSize()/1024/1024 << "MiB\n";
+  std::cout << "Allocated IBO size: " << iboBufferSPtr->getAllocatedSize()/1024/1024 << "MiB\n";
+  std::cout << "Actual VBO size: " << vboBufferSPtr->getBufferSize()/1024/1024 << "MiB\n";
+  std::cout << "Allocated VBO size: " << vboBufferSPtr->getAllocatedSize()/1024/1024 << "MiB\n";
 
+  SpireText text;
   SpireSubPass pass(passName, vboName, iboName, shader,
     colorScheme, state, RenderType::RENDER_VBO_IBO, geomVBO, geomIBO, text);
 
@@ -880,6 +896,8 @@ void GeometryBuilder::renderFacesLinear(
   ///       build up to geometry / tessellation shaders if support is present.
 }
 
+
+
 // This function needs to be reorganized.
 // The fact that we are only rendering triangles helps us dramatically and
 // we get rid of the quads renderer pointers. Additionally, we can re-order
@@ -896,22 +914,26 @@ void GeometryBuilder::addFaceGeom(
   const std::vector<ColorRGB> &face_colors,
   const RenderState& state)
 {
+
   auto writeVBOPoint = [&vboBuffer](const Point& point)
   {
+    vboInsertionSize += 3*sizeof(float);
     vboBuffer->write(static_cast<float>(point.x()));
     vboBuffer->write(static_cast<float>(point.y()));
     vboBuffer->write(static_cast<float>(point.z()));
   };
 
   auto writeVBONormal = [&vboBuffer](const Vector& normal)
   {
+    vboInsertionSize += 3*sizeof(float);
     vboBuffer->write(static_cast<float>(normal.x()));
     vboBuffer->write(static_cast<float>(normal.y()));
     vboBuffer->write(static_cast<float>(normal.z()));
   };
 
   auto writeVBOColorValue = [&vboBuffer](ColorRGB value)
   {
+    vboInsertionSize += 4*sizeof(float);
     vboBuffer->write(static_cast<float>(value.r()));
     vboBuffer->write(static_cast<float>(value.g()));
     vboBuffer->write(static_cast<float>(value.b()));
@@ -920,11 +942,14 @@ void GeometryBuilder::addFaceGeom(
 
   auto writeIBOIndex = [&iboBuffer](uint32_t index)
   {
+    iboInsertionSize += sizeof(uint32_t);
     iboBuffer->write(index);
   };
 
+
   bool doubleSided = state.get(RenderState::IS_DOUBLE_SIDED);
 
+
   if (colorScheme == ColorScheme::COLOR_UNIFORM)
   {
     if (points.size() == 4)
@@ -1200,8 +1225,15 @@ void GeometryBuilder::addFaceGeom(
       iboIndex += points.size();
     }
   }
+
+  if((vboInsertionSize - vboLastPrintSize) > (1024 * 1024 * 16))
+    std::cout << "VBO size: " << (vboLastPrintSize = vboInsertionSize)/1024/1024 << "MiB\n";
+  if((iboInsertionSize - iboLastPrintSize) > (1024 * 1024 * 16))
+    std::cout << "IBO size: " << (iboLastPrintSize = iboInsertionSize)/1024/1024 << "MiB\n";
 }
 
+
+
 void GeometryBuilder::renderNodes(
   FieldHandle field,
   boost::optional<boost::shared_ptr<ColorMap>> colorMap,