Unify buffer sizes. (google#465)

* Unify buffer sizes.

Currently the format buffer and data buffer count their size
differently. For data buffers we counted elements (so 1 vec4 was size 1)
and format buffers counted values (so 1 vec4 was size 4).

This CL unifies the two sizes and adds ElementCount and ValueCount to
make it explicit which version the user wants.

As part of this, the data types used for ssbo and uniform commands must
be consistent. The tests where we switched data formats part way through
are updated.

* build fix

docs/vk_script.md

@@ -225,7 +225,7 @@ multiple of the requested `type`.
 ### SSBO size
  * `ssbo _binding_ _size_`
 
-Sets the size of the SSBO at `binding` to `size`.
+Sets the number of elements in the SSBO at `binding` to `size`.
 
 
 ### SSBO subdata

src/amber.cc

@@ -216,7 +216,7 @@ amber::Result Amber::ExecuteWithShaderData(const amber::Recipe* recipe,
 
     const uint8_t* ptr = buffer->ValuePtr()->data();
     auto& values = buffer_info.values;
-    for (size_t i = 0; i < buffer->GetSize(); ++i) {
+    for (size_t i = 0; i < buffer->GetSizeInBytes(); ++i) {
       values.emplace_back();
       values.back().SetIntValue(*ptr);
       ++ptr;

src/amberscript/parser.cc

@@ -755,7 +755,7 @@ Result Parser::ParseBufferInitializerSize(DataBuffer* buffer) {
     return Result("BUFFER size invalid");
 
   uint32_t size_in_items = token->AsUint32();
-  buffer->SetSize(size_in_items);
+  buffer->SetElementCount(size_in_items);
 
   token = tokenizer_->NextToken();
   if (!token->IsString())
@@ -877,10 +877,7 @@ Result Parser::ParseBufferInitializerData(DataBuffer* buffer) {
     values.emplace_back(v);
   }
 
-  uint32_t size_in_items = static_cast<uint32_t>(values.size()) /
-                           fmt->RowCount() / fmt->ColumnCount();
-  buffer->SetSize(size_in_items);
-
+  buffer->SetValueCount(static_cast<uint32_t>(values.size()));
   buffer->SetData(std::move(values));
   return ValidateEndOfStatement("BUFFER data command");
 }
@@ -1095,7 +1092,7 @@ Result Parser::ParseExpect() {
     if (buffer->GetBufferType() != buffer_2->GetBufferType())
       return Result(
           "EXPECT EQ_BUFFER command cannot compare buffers of different type");
-    if (buffer->GetSize() != buffer_2->GetSize())
+    if (buffer->ElementCount() != buffer_2->ElementCount())
       return Result(
           "EXPECT EQ_BUFFER command cannot compare buffers of different size");
     if (buffer->GetWidth() != buffer_2->GetWidth())
@@ -1272,7 +1269,7 @@ Result Parser::ParseCopy() {
     buffer_to->SetBufferType(buffer_from->GetBufferType());
     buffer_to->SetWidth(buffer_from->GetWidth());
     buffer_to->SetHeight(buffer_from->GetHeight());
-    buffer_to->SetSize(buffer_from->GetSize());
+    buffer_to->SetElementCount(buffer_from->ElementCount());
   }
 
   if (buffer_from->GetBufferType() != buffer_to->GetBufferType())

src/amberscript/parser_bind_test.cc

@@ -50,7 +50,8 @@ END)";
   const auto& buf_info = color_buffers[0];
   ASSERT_TRUE(buf_info.buffer != nullptr);
   EXPECT_EQ(0, buf_info.location);
-  EXPECT_EQ(250 * 250, buf_info.buffer->GetSize());
+  EXPECT_EQ(250 * 250, buf_info.buffer->ElementCount());
+  EXPECT_EQ(250 * 250 * 4, buf_info.buffer->ValueCount());
   EXPECT_EQ(250 * 250 * 4 * sizeof(float), buf_info.buffer->GetSizeInBytes());
 }
 
@@ -318,16 +319,18 @@ END)";
   const auto& buf1 = color_buffers1[0];
   ASSERT_TRUE(buf1.buffer != nullptr);
   EXPECT_EQ(0, buf1.location);
-  EXPECT_EQ(90 * 180, buf1.buffer->GetSize());
+  EXPECT_EQ(90 * 180, buf1.buffer->ElementCount());
+  EXPECT_EQ(90 * 180 * 4, buf1.buffer->ValueCount());
   EXPECT_EQ(90 * 180 * 4 * sizeof(float), buf1.buffer->GetSizeInBytes());
 
   pipeline = pipelines[1].get();
   const auto& color_buffers2 = pipeline->GetColorAttachments();
   const auto& buf2 = color_buffers2[0];
   ASSERT_TRUE(buf2.buffer != nullptr);
   EXPECT_EQ(9, buf2.location);
-  EXPECT_EQ(256 * 300, buf2.buffer->GetSize());
-  EXPECT_EQ(256 * 300 * sizeof(uint32_t), buf2.buffer->GetSizeInBytes());
+  EXPECT_EQ(256 * 300, buf2.buffer->ElementCount());
+  EXPECT_EQ(256 * 300 * 4, buf2.buffer->ValueCount());
+  EXPECT_EQ(256 * 300 * 4 * sizeof(uint8_t), buf2.buffer->GetSizeInBytes());
 }
 
 TEST_F(AmberScriptParserTest, BindColorFBSizeSetBeforeBuffer) {
@@ -361,7 +364,8 @@ END)";
   const auto& buf1 = color_buffers1[0];
   ASSERT_TRUE(buf1.buffer != nullptr);
   EXPECT_EQ(0, buf1.location);
-  EXPECT_EQ(90 * 180, buf1.buffer->GetSize());
+  EXPECT_EQ(90 * 180, buf1.buffer->ElementCount());
+  EXPECT_EQ(90 * 180 * 4, buf1.buffer->ValueCount());
   EXPECT_EQ(90 * 180 * 4 * sizeof(float), buf1.buffer->GetSizeInBytes());
 }
 
@@ -396,7 +400,8 @@ END)";
   const auto& buf1 = color_buffers1[0];
   ASSERT_TRUE(buf1.buffer != nullptr);
   EXPECT_EQ(0, buf1.location);
-  EXPECT_EQ(90 * 180, buf1.buffer->GetSize());
+  EXPECT_EQ(90 * 180, buf1.buffer->ElementCount());
+  EXPECT_EQ(90 * 180 * 4, buf1.buffer->ValueCount());
   EXPECT_EQ(90 * 180 * 4 * sizeof(float), buf1.buffer->GetSizeInBytes());
 }
 
@@ -427,7 +432,8 @@ END)";
   const auto* pipeline = pipelines[0].get();
   const auto& buf = pipeline->GetDepthBuffer();
   ASSERT_TRUE(buf.buffer != nullptr);
-  EXPECT_EQ(90 * 180, buf.buffer->GetSize());
+  EXPECT_EQ(90 * 180, buf.buffer->ElementCount());
+  EXPECT_EQ(90 * 180 * 4, buf.buffer->ValueCount());
   EXPECT_EQ(90 * 180 * 4 * sizeof(float), buf.buffer->GetSizeInBytes());
 }
 

src/amberscript/parser_buffer_test.cc

@@ -40,12 +40,13 @@ END)";
 
   auto* buffer = buffers[0].get();
   EXPECT_TRUE(buffer->GetFormat()->IsUint32());
-  EXPECT_EQ(7U, buffer->GetSize());
+  EXPECT_EQ(7U, buffer->ElementCount());
+  EXPECT_EQ(7U, buffer->ValueCount());
   EXPECT_EQ(7U * sizeof(uint32_t), buffer->GetSizeInBytes());
 
   std::vector<uint32_t> results = {1, 2, 3, 4, 55, 99, 1234};
   const auto* data = buffer->GetValues<uint32_t>();
-  ASSERT_EQ(results.size(), buffer->GetSize());
+  ASSERT_EQ(results.size(), buffer->ValueCount());
   for (size_t i = 0; i < results.size(); ++i) {
     EXPECT_EQ(results[i], data[i]);
   }
@@ -67,12 +68,13 @@ TEST_F(AmberScriptParserTest, BufferDataOneLine) {
 
   auto* buffer = buffers[0].get();
   EXPECT_TRUE(buffer->GetFormat()->IsUint32());
-  EXPECT_EQ(4U, buffer->GetSize());
+  EXPECT_EQ(4U, buffer->ElementCount());
+  EXPECT_EQ(4U, buffer->ValueCount());
   EXPECT_EQ(4U * sizeof(uint32_t), buffer->GetSizeInBytes());
 
   std::vector<uint32_t> results = {1, 2, 3, 4};
   const auto* data = buffer->GetValues<uint32_t>();
-  ASSERT_EQ(results.size(), buffer->GetSize());
+  ASSERT_EQ(results.size(), buffer->ValueCount());
   for (size_t i = 0; i < results.size(); ++i) {
     EXPECT_EQ(results[i], data[i]);
   }
@@ -95,12 +97,13 @@ TEST_F(AmberScriptParserTest, BufferDataFloat) {
   ASSERT_TRUE(buffers[0]->IsDataBuffer());
   auto* buffer = buffers[0]->AsDataBuffer();
   EXPECT_TRUE(buffer->GetDatumType().IsFloat());
-  EXPECT_EQ(4U, buffer->GetSize());
+  EXPECT_EQ(4U, buffer->ElementCount());
+  EXPECT_EQ(4U, buffer->ValueCount());
   EXPECT_EQ(4U * sizeof(float), buffer->GetSizeInBytes());
 
   std::vector<float> results = {1, 2, 3, 4};
   const auto* data = buffer->GetValues<float>();
-  ASSERT_EQ(results.size(), buffer->GetSize());
+  ASSERT_EQ(results.size(), buffer->ValueCount());
   for (size_t i = 0; i < results.size(); ++i) {
     EXPECT_FLOAT_EQ(results[i], data[i]);
   }
@@ -122,12 +125,13 @@ TEST_F(AmberScriptParserTest, BufferFill) {
   auto* buffer = buffers[0].get();
   EXPECT_EQ("my_buffer", buffer->GetName());
   EXPECT_TRUE(buffer->GetFormat()->IsUint8());
-  EXPECT_EQ(5U, buffer->GetSize());
+  EXPECT_EQ(5U, buffer->ElementCount());
+  EXPECT_EQ(5U, buffer->ValueCount());
   EXPECT_EQ(5U * sizeof(uint8_t), buffer->GetSizeInBytes());
 
   std::vector<uint32_t> results = {5, 5, 5, 5, 5};
   const auto* data = buffer->GetValues<uint8_t>();
-  ASSERT_EQ(results.size(), buffer->GetSize());
+  ASSERT_EQ(results.size(), buffer->ValueCount());
   for (size_t i = 0; i < results.size(); ++i) {
     EXPECT_EQ(results[i], data[i]);
   }
@@ -149,12 +153,13 @@ TEST_F(AmberScriptParserTest, BufferFillFloat) {
   auto* buffer = buffers[0].get();
   EXPECT_EQ("my_buffer", buffer->GetName());
   EXPECT_TRUE(buffer->GetFormat()->IsFloat());
-  EXPECT_EQ(5U, buffer->GetSize());
+  EXPECT_EQ(5U, buffer->ElementCount());
+  EXPECT_EQ(5U, buffer->ValueCount());
   EXPECT_EQ(5U * sizeof(float), buffer->GetSizeInBytes());
 
   std::vector<float> results = {5.2f, 5.2f, 5.2f, 5.2f, 5.2f};
   const auto* data = buffer->GetValues<float>();
-  ASSERT_EQ(results.size(), buffer->GetSize());
+  ASSERT_EQ(results.size(), buffer->ValueCount());
   for (size_t i = 0; i < results.size(); ++i) {
     EXPECT_FLOAT_EQ(results[i], data[i]);
   }
@@ -177,12 +182,13 @@ TEST_F(AmberScriptParserTest, BufferSeries) {
   auto* buffer = buffers[0].get();
   EXPECT_EQ("my_buffer", buffer->GetName());
   EXPECT_TRUE(buffer->GetFormat()->IsUint8());
-  EXPECT_EQ(5U, buffer->GetSize());
+  EXPECT_EQ(5U, buffer->ElementCount());
+  EXPECT_EQ(5U, buffer->ValueCount());
   EXPECT_EQ(5U * sizeof(uint8_t), buffer->GetSizeInBytes());
 
   std::vector<uint8_t> results = {2, 3, 4, 5, 6};
   const auto* data = buffer->GetValues<uint8_t>();
-  ASSERT_EQ(results.size(), buffer->GetSize());
+  ASSERT_EQ(results.size(), buffer->ValueCount());
   for (size_t i = 0; i < results.size(); ++i) {
     EXPECT_EQ(results[i], data[i]);
   }
@@ -206,12 +212,13 @@ TEST_F(AmberScriptParserTest, BufferSeriesFloat) {
   auto* buffer = buffers[0].get();
   EXPECT_EQ("my_buffer", buffer->GetName());
   EXPECT_TRUE(buffer->GetFormat()->IsFloat());
-  EXPECT_EQ(5U, buffer->GetSize());
+  EXPECT_EQ(5U, buffer->ElementCount());
+  EXPECT_EQ(5U, buffer->ValueCount());
   EXPECT_EQ(5U * sizeof(float), buffer->GetSizeInBytes());
 
   std::vector<float> results = {2.2f, 3.3f, 4.4f, 5.5f, 6.6f};
   const auto* data = buffer->GetValues<float>();
-  ASSERT_EQ(results.size(), buffer->GetSize());
+  ASSERT_EQ(results.size(), buffer->ValueCount());
   for (size_t i = 0; i < results.size(); ++i) {
     EXPECT_FLOAT_EQ(results[i], data[i]);
   }
@@ -238,12 +245,13 @@ END)";
   auto* buffer = buffers[0].get();
   EXPECT_EQ("color_buffer", buffer->GetName());
   EXPECT_TRUE(buffer->GetFormat()->IsUint8());
-  EXPECT_EQ(5U, buffer->GetSize());
+  EXPECT_EQ(5U, buffer->ElementCount());
+  EXPECT_EQ(5U, buffer->ValueCount());
   EXPECT_EQ(5U * sizeof(uint8_t), buffer->GetSizeInBytes());
 
   std::vector<uint32_t> results0 = {5, 5, 5, 5, 5};
   const auto* data0 = buffer->GetValues<uint8_t>();
-  ASSERT_EQ(results0.size(), buffer->GetSize());
+  ASSERT_EQ(results0.size(), buffer->ValueCount());
   for (size_t i = 0; i < results0.size(); ++i) {
     EXPECT_EQ(results0[i], data0[i]);
   }
@@ -253,12 +261,13 @@ END)";
   buffer = buffers[1].get();
   EXPECT_EQ("storage_buffer", buffer->GetName());
   EXPECT_TRUE(buffer->GetFormat()->IsUint32());
-  EXPECT_EQ(7U, buffer->GetSize());
+  EXPECT_EQ(7U, buffer->ElementCount());
+  EXPECT_EQ(7U, buffer->ValueCount());
   EXPECT_EQ(7U * sizeof(uint32_t), buffer->GetSizeInBytes());
 
   std::vector<uint32_t> results1 = {1, 2, 3, 4, 55, 99, 1234};
   const auto* data1 = buffer->GetValues<uint32_t>();
-  ASSERT_EQ(results1.size(), buffer->GetSize());
+  ASSERT_EQ(results1.size(), buffer->ValueCount());
   for (size_t i = 0; i < results1.size(); ++i) {
     EXPECT_EQ(results1[i], data1[i]);
   }
@@ -281,8 +290,9 @@ BUFFER my_index_buffer DATA_TYPE vec2<int32> SIZE 5 FILL 2)";
   auto* buffer = buffers[0].get();
   EXPECT_EQ("my_index_buffer", buffer->GetName());
   EXPECT_TRUE(buffer->GetFormat()->IsInt32());
-  EXPECT_EQ(5U, buffer->GetSize());
-  EXPECT_EQ(5U * 2 * sizeof(int32_t), buffer->GetSizeInBytes());
+  EXPECT_EQ(5U, buffer->ElementCount());
+  EXPECT_EQ(10U, buffer->ValueCount());
+  EXPECT_EQ(10U * sizeof(int32_t), buffer->GetSizeInBytes());
 
   std::vector<int32_t> results0 = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
   const auto* data0 = buffer->GetValues<int32_t>();
@@ -314,8 +324,9 @@ END
   auto* buffer = buffers[0].get();
   EXPECT_EQ("my_index_buffer", buffer->GetName());
   EXPECT_TRUE(buffer->GetFormat()->IsInt32());
-  EXPECT_EQ(4U, buffer->GetSize());
-  EXPECT_EQ(4U * 2 * sizeof(int32_t), buffer->GetSizeInBytes());
+  EXPECT_EQ(4U, buffer->ElementCount());
+  EXPECT_EQ(8U, buffer->ValueCount());
+  EXPECT_EQ(8U * sizeof(int32_t), buffer->GetSizeInBytes());
 
   std::vector<int32_t> results0 = {2, 3, 4, 5, 6, 7, 8, 9};
   const auto* data0 = buffer->GetValues<int32_t>();
@@ -324,6 +335,40 @@ END
   }
 }
 
+TEST_F(AmberScriptParserTest, BufferDataStd140Resized) {
+  std::string in = R"(
+BUFFER my_index_buffer DATA_TYPE vec3<int32> DATA
+2 3 3
+4 5 5
+6 7 7
+8 9 9
+END
+)";
+
+  Parser parser;
+  Result r = parser.Parse(in);
+  ASSERT_TRUE(r.IsSuccess()) << r.Error();
+
+  auto script = parser.GetScript();
+  const auto& buffers = script->GetBuffers();
+  ASSERT_EQ(1U, buffers.size());
+
+  ASSERT_TRUE(buffers[0] != nullptr);
+
+  auto* buffer = buffers[0].get();
+  EXPECT_EQ("my_index_buffer", buffer->GetName());
+  EXPECT_TRUE(buffer->GetFormat()->IsInt32());
+  EXPECT_EQ(4U, buffer->ElementCount());
+  EXPECT_EQ(12U, buffer->ValueCount());
+  EXPECT_EQ(16U * sizeof(int32_t), buffer->GetSizeInBytes());
+
+  std::vector<int32_t> results0 = {2, 3, 3, 4, 5, 5, 6, 7, 7, 8, 9, 9};
+  const auto* data0 = buffer->GetValues<int32_t>();
+  for (size_t i = 0; i < results0.size(); ++i) {
+    EXPECT_EQ(results0[i], data0[i]);
+  }
+}
+
 TEST_F(AmberScriptParserTest, BufferDataHex) {
   std::string in = R"(
 BUFFER my_index_buffer DATA_TYPE uint32 DATA
@@ -347,12 +392,13 @@ END
   auto* buffer = buffers[0].get();
   EXPECT_EQ("my_index_buffer", buffer->GetName());
   EXPECT_TRUE(buffer->GetFormat()->IsUint32());
-  EXPECT_EQ(4U, buffer->GetSize());
+  EXPECT_EQ(4U, buffer->ElementCount());
+  EXPECT_EQ(4U, buffer->ValueCount());
   EXPECT_EQ(4U * sizeof(uint32_t), buffer->GetSizeInBytes());
 
   std::vector<uint32_t> results0 = {4278190080, 16711680, 65280, 255};
   const auto* data0 = buffer->GetValues<uint32_t>();
-  ASSERT_EQ(results0.size(), buffer->GetSize());
+  ASSERT_EQ(results0.size(), buffer->ValueCount());
   for (size_t i = 0; i < results0.size(); ++i) {
     EXPECT_EQ(results0[i], data0[i]);
   }

src/amberscript/parser_pipeline_test.cc

@@ -200,8 +200,9 @@ END)";
   ASSERT_TRUE(buffer1->IsFormatBuffer());
   EXPECT_EQ(FormatType::kB8G8R8A8_UNORM, buffer1->GetFormat()->GetFormatType());
   EXPECT_EQ(0, buf1.location);
-  EXPECT_EQ(250 * 250, buffer1->GetSize());
-  EXPECT_EQ(250 * 250 * sizeof(uint32_t), buffer1->GetSizeInBytes());
+  EXPECT_EQ(250 * 250, buffer1->ElementCount());
+  EXPECT_EQ(250 * 250 * 4, buffer1->ValueCount());
+  EXPECT_EQ(250 * 250 * 4 * sizeof(uint8_t), buffer1->GetSizeInBytes());
 
   ASSERT_EQ(1U, pipelines[1]->GetColorAttachments().size());
   const auto& buf2 = pipelines[1]->GetColorAttachments()[0];
@@ -210,8 +211,9 @@ END)";
   EXPECT_EQ(0, buf2.location);
   EXPECT_EQ(FormatType::kB8G8R8A8_UNORM,
             buf2.buffer->GetFormat()->GetFormatType());
-  EXPECT_EQ(250 * 250, buf2.buffer->GetSize());
-  EXPECT_EQ(250 * 250 * sizeof(uint32_t), buf2.buffer->GetSizeInBytes());
+  EXPECT_EQ(250 * 250, buf2.buffer->ElementCount());
+  EXPECT_EQ(250 * 250 * 4, buf2.buffer->ValueCount());
+  EXPECT_EQ(250 * 250 * 4 * sizeof(uint8_t), buf2.buffer->GetSizeInBytes());
 }
 
 TEST_F(AmberScriptParserTest, PipelineDefaultColorBufferMismatchSize) {