Merge branch 'master' into cameraSaveFix

Author: dcwhite

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/Interface/Modules/Render/Tests/CMakeLists.txt

@@ -1,22 +1,22 @@
 #
 #  For more information, please see: http://software.sci.utah.edu
-# 
+#
 #  The MIT License
-# 
+#
 #  Copyright (c) 2015 Scientific Computing and Imaging Institute,
 #  University of Utah.
-# 
-#  
+#
+#
 #  Permission is hereby granted, free of charge, to any person obtaining a
 #  copy of this software and associated documentation files (the "Software"),
 #  to deal in the Software without restriction, including without limitation
 #  the rights to use, copy, modify, merge, publish, distribute, sublicense,
 #  and/or sell copies of the Software, and to permit persons to whom the
 #  Software is furnished to do so, subject to the following conditions:
-# 
+#
 #  The above copyright notice and this permission notice shall be included
-#  in all copies or substantial portions of the Software. 
-# 
+#  in all copies or substantial portions of the Software.
+#
 #  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 #  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 #  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
@@ -28,6 +28,7 @@
 
 SET(Interface_Modules_Render_Tests_SRCS
   SRInterfaceTests.cc
+  VarBufferTests.cc
 )
 
 SCIRUN_ADD_UNIT_TEST(Interface_Modules_Render_Tests

src/Interface/Modules/Render/Tests/VarBufferTests.cc

@@ -0,0 +1,110 @@
+#include <spire/var-buffer/VarBuffer.hpp>
+#include <bserialize/BSerialize.hpp>
+#include <gtest/gtest.h>
+#include <memory>
+#include <cstring>
+
+using namespace spire;
+
+TEST(VarBufferTest, BasicSerialization)
+{
+  VarBuffer vb;
+
+  // Proceed close to 1024 limit.
+  const size_t emptySize = 1020;
+  char empty[emptySize];
+  std::memset(empty, 0, emptySize);
+
+  vb.writeBytes(empty, emptySize);
+
+  // After this write, we are at 1024.
+  uint32_t v1 = 3;
+  double v2 = 5.483;
+  float v3 = 8293.09;
+  int32_t v4 = -323;
+  uint16_t v5 = 8924;
+  std::string v6 = "This is a test string.";
+  uint8_t v7 = 98;
+
+  vb.write(v1);
+
+  // Continue writing.
+  vb.write(v2);
+  vb.write(v3);
+  vb.write(v4);
+  vb.writeNullTermString("Blah!");
+  vb.write(v5);
+  vb.write(v6);
+  vb.write(v7);
+
+  // Now take the buffer and stuff it into BSerialize
+  BSerialize sin(vb.getBuffer(), vb.getBufferSize());
+  sin.readBytes(emptySize);
+  EXPECT_EQ(v1, sin.read<uint32_t>());
+  EXPECT_EQ(v2, sin.read<double>());
+  EXPECT_EQ(v3, sin.read<float>());
+  EXPECT_EQ(v4, sin.read<int32_t>());
+  EXPECT_EQ(std::string("Blah!"), std::string(sin.readNullTermString()));
+  EXPECT_EQ(v5, sin.read<uint16_t>());
+  EXPECT_EQ(v6, sin.read<std::string>());
+  EXPECT_EQ(v7, sin.read<uint8_t>());
+}
+
+TEST(VarBufferTest, TestPreallocatedSize)
+{
+  VarBuffer vb(5000);
+
+  EXPECT_EQ(5000, vb.getAllocatedSize());
+
+  // Proceed close to 1024 limit.
+  const size_t emptySize = 1020;
+  char empty[emptySize];
+  std::memset(empty, 0, emptySize);
+
+  vb.writeBytes(empty, emptySize);
+
+  // After this write, we are at 1024.
+  uint32_t v1 = 3;
+  double v2 = 5.483;
+  float v3 = 8293.09;
+  int32_t v4 = -323;
+  uint16_t v5 = 8924;
+  std::string v6 = "This is a test string.";
+  uint8_t v7 = 98;
+
+  vb.write(v1);
+
+  // Continue writing.
+  vb.write(v2);
+  vb.write(v3);
+  vb.write(v4);
+  vb.writeNullTermString("Blah!");
+  vb.write(v5);
+  vb.write(v6);
+  vb.write(v7);
+
+  // Now take the buffer and stuff it into BSerialize
+  BSerialize sin(vb.getBuffer(), vb.getBufferSize());
+  sin.readBytes(emptySize);
+  EXPECT_EQ(v1, sin.read<uint32_t>());
+  EXPECT_EQ(v2, sin.read<double>());
+  EXPECT_EQ(v3, sin.read<float>());
+  EXPECT_EQ(v4, sin.read<int32_t>());
+  EXPECT_EQ(std::string("Blah!"), std::string(sin.readNullTermString()));
+  EXPECT_EQ(v5, sin.read<uint16_t>());
+  EXPECT_EQ(v6, sin.read<std::string>());
+  EXPECT_EQ(v7, sin.read<uint8_t>());
+
+  // Check to ensure that we are still at size 5000.
+  EXPECT_EQ(5000, vb.getAllocatedSize());
+}
+
+
+//takes on the order of 10 second to run becasue of the large allocation size so I dsiabeld it for now
+TEST(VarBufferTest, DISABLED_TestLargeAllocation)
+{
+  size_t size = 1ull << 32;
+  EXPECT_GT(size, static_cast<size_t>(std::numeric_limits<uint32_t>::max()));
+  VarBuffer vb(size);
+  EXPECT_EQ(size, vb.getAllocatedSize());
+}