Convert Vertex data into a buffer. (#164)

This CL allows for Buffers to be described by a DatumType (like the
indices buffers) or by a Format type. The VertexNodes have been removed
and converted to Format type buffers.

4 files changed, 112 insertions, 87 deletions

diff --git a/src/amberscript/parser.cc b/src/amberscript/parser.cc
index c11d3fb..d45c52a 100644
--- a/src/amberscript/parser.cc
+++ b/src/amberscript/parser.cc
@@ -432,7 +432,7 @@ Result Parser::ParseBuffer() {
   if (!r.IsSuccess())
     return r;
 
-  auto buffer = MakeUnique<Buffer>(type);
+  auto buffer = MakeUnique<DataBuffer>(type);
 
   token = tokenizer_->NextToken();
   if (!token->IsString())
@@ -474,7 +474,7 @@ Result Parser::ParseBuffer() {
   return {};
 }
 
-Result Parser::ParseBufferFramebuffer(Buffer* buffer) {
+Result Parser::ParseBufferFramebuffer(DataBuffer* buffer) {
   auto token = tokenizer_->NextToken();
   if (token->IsEOL() || token->IsEOS())
     return Result("BUFFER framebuffer missing DIMS values");
@@ -506,7 +506,7 @@ Result Parser::ParseBufferFramebuffer(Buffer* buffer) {
   return ValidateEndOfStatement("BUFFER framebuffer command");
 }
 
-Result Parser::ParseBufferInitializer(Buffer* buffer) {
+Result Parser::ParseBufferInitializer(DataBuffer* buffer) {
   auto token = tokenizer_->NextToken();
   if (!token->IsString())
     return Result("BUFFER invalid data type");
@@ -530,7 +530,7 @@ Result Parser::ParseBufferInitializer(Buffer* buffer) {
   return Result("unknown initializer for BUFFER");
 }
 
-Result Parser::ParseBufferInitializerSize(Buffer* buffer) {
+Result Parser::ParseBufferInitializerSize(DataBuffer* buffer) {
   auto token = tokenizer_->NextToken();
   if (token->IsEOS() || token->IsEOL())
     return Result("BUFFER size missing");
@@ -552,7 +552,7 @@ Result Parser::ParseBufferInitializerSize(Buffer* buffer) {
   return Result("invalid BUFFER initializer provided");
 }
 
-Result Parser::ParseBufferInitializerFill(Buffer* buffer,
+Result Parser::ParseBufferInitializerFill(DataBuffer* buffer,
                                           uint32_t size_in_items) {
   auto token = tokenizer_->NextToken();
   if (token->IsEOS() || token->IsEOL())
@@ -578,7 +578,7 @@ Result Parser::ParseBufferInitializerFill(Buffer* buffer,
   return ValidateEndOfStatement("BUFFER fill command");
 }
 
-Result Parser::ParseBufferInitializerSeries(Buffer* buffer,
+Result Parser::ParseBufferInitializerSeries(DataBuffer* buffer,
                                             uint32_t size_in_items) {
   auto token = tokenizer_->NextToken();
   if (token->IsEOS() || token->IsEOL())
@@ -627,7 +627,7 @@ Result Parser::ParseBufferInitializerSeries(Buffer* buffer,
   return ValidateEndOfStatement("BUFFER series_from command");
 }
 
-Result Parser::ParseBufferInitializerData(Buffer* buffer) {
+Result Parser::ParseBufferInitializerData(DataBuffer* buffer) {
   auto token = tokenizer_->NextToken();
   if (!token->IsEOL())
     return Result("extra parameters after BUFFER data command");
diff --git a/src/amberscript/parser.h b/src/amberscript/parser.h
index aa86e19..7e4b764 100644
--- a/src/amberscript/parser.h
+++ b/src/amberscript/parser.h
@@ -51,12 +51,12 @@ class Parser : public amber::Parser {
   Result ValidateEndOfStatement(const std::string& name);
 
   Result ParseBuffer();
-  Result ParseBufferInitializer(Buffer*);
-  Result ParseBufferInitializerSize(Buffer*);
-  Result ParseBufferInitializerFill(Buffer*, uint32_t);
-  Result ParseBufferInitializerSeries(Buffer*, uint32_t);
-  Result ParseBufferInitializerData(Buffer*);
-  Result ParseBufferFramebuffer(Buffer*);
+  Result ParseBufferInitializer(DataBuffer*);
+  Result ParseBufferInitializerSize(DataBuffer*);
+  Result ParseBufferInitializerFill(DataBuffer*, uint32_t);
+  Result ParseBufferInitializerSeries(DataBuffer*, uint32_t);
+  Result ParseBufferInitializerData(DataBuffer*);
+  Result ParseBufferFramebuffer(DataBuffer*);
   Result ParseShaderBlock();
   Result ParsePipelineBlock();
   Result ParsePipelineAttach(Pipeline*);
diff --git a/src/amberscript/parser_test.cc b/src/amberscript/parser_test.cc
index 5d19139..fd57a5d 100644
--- a/src/amberscript/parser_test.cc
+++ b/src/amberscript/parser_test.cc
@@ -957,12 +957,15 @@ END)";
   ASSERT_TRUE(buffers[0] != nullptr);
   EXPECT_EQ("my_buffer", buffers[0]->GetName());
   EXPECT_EQ(BufferType::kStorage, buffers[0]->GetBufferType());
-  EXPECT_TRUE(buffers[0]->GetDatumType().IsUint32());
-  EXPECT_EQ(7U, buffers[0]->GetSize());
-  EXPECT_EQ(7U * sizeof(uint32_t), buffers[0]->GetSizeInBytes());
+
+  ASSERT_TRUE(buffers[0]->IsDataBuffer());
+  auto* buffer = buffers[0]->AsDataBuffer();
+  EXPECT_TRUE(buffer->GetDatumType().IsUint32());
+  EXPECT_EQ(7U, buffer->GetSize());
+  EXPECT_EQ(7U * sizeof(uint32_t), buffer->GetSizeInBytes());
 
   std::vector<uint32_t> results = {1, 2, 3, 4, 55, 99, 1234};
-  const auto& data = buffers[0]->GetData();
+  const auto& data = buffer->GetData();
   ASSERT_EQ(results.size(), data.size());
   for (size_t i = 0; i < results.size(); ++i) {
     ASSERT_TRUE(data[i].IsInteger());
@@ -983,14 +986,16 @@ TEST_F(AmberScriptParserTest, BufferFill) {
   ASSERT_EQ(1U, buffers.size());
 
   ASSERT_TRUE(buffers[0] != nullptr);
-  EXPECT_EQ("my_buffer", buffers[0]->GetName());
-  EXPECT_EQ(BufferType::kColor, buffers[0]->GetBufferType());
-  EXPECT_TRUE(buffers[0]->GetDatumType().IsUint8());
-  EXPECT_EQ(5U, buffers[0]->GetSize());
-  EXPECT_EQ(5U * sizeof(uint8_t), buffers[0]->GetSizeInBytes());
+  ASSERT_TRUE(buffers[0]->IsDataBuffer());
+  auto* buffer = buffers[0]->AsDataBuffer();
+  EXPECT_EQ("my_buffer", buffer->GetName());
+  EXPECT_EQ(BufferType::kColor, buffer->GetBufferType());
+  EXPECT_TRUE(buffer->GetDatumType().IsUint8());
+  EXPECT_EQ(5U, buffer->GetSize());
+  EXPECT_EQ(5U * sizeof(uint8_t), buffer->GetSizeInBytes());
 
   std::vector<uint32_t> results = {5, 5, 5, 5, 5};
-  const auto& data = buffers[0]->GetData();
+  const auto& data = buffer->GetData();
   ASSERT_EQ(results.size(), data.size());
   for (size_t i = 0; i < results.size(); ++i) {
     ASSERT_TRUE(data[i].IsInteger());
@@ -1011,14 +1016,16 @@ TEST_F(AmberScriptParserTest, BufferFillFloat) {
   ASSERT_EQ(1U, buffers.size());
 
   ASSERT_TRUE(buffers[0] != nullptr);
-  EXPECT_EQ("my_buffer", buffers[0]->GetName());
-  EXPECT_EQ(BufferType::kColor, buffers[0]->GetBufferType());
-  EXPECT_TRUE(buffers[0]->GetDatumType().IsFloat());
-  EXPECT_EQ(5U, buffers[0]->GetSize());
-  EXPECT_EQ(5U * sizeof(float), buffers[0]->GetSizeInBytes());
+  ASSERT_TRUE(buffers[0]->IsDataBuffer());
+  auto* buffer = buffers[0]->AsDataBuffer();
+  EXPECT_EQ("my_buffer", buffer->GetName());
+  EXPECT_EQ(BufferType::kColor, buffer->GetBufferType());
+  EXPECT_TRUE(buffer->GetDatumType().IsFloat());
+  EXPECT_EQ(5U, buffer->GetSize());
+  EXPECT_EQ(5U * sizeof(float), buffer->GetSizeInBytes());
 
   std::vector<float> results = {5.2f, 5.2f, 5.2f, 5.2f, 5.2f};
-  const auto& data = buffers[0]->GetData();
+  const auto& data = buffer->GetData();
   ASSERT_EQ(results.size(), data.size());
   for (size_t i = 0; i < results.size(); ++i) {
     ASSERT_TRUE(data[i].IsFloat());
@@ -1040,14 +1047,16 @@ TEST_F(AmberScriptParserTest, BufferSeries) {
   ASSERT_EQ(1U, buffers.size());
 
   ASSERT_TRUE(buffers[0] != nullptr);
-  EXPECT_EQ("my_buffer", buffers[0]->GetName());
-  EXPECT_EQ(BufferType::kColor, buffers[0]->GetBufferType());
-  EXPECT_TRUE(buffers[0]->GetDatumType().IsUint8());
-  EXPECT_EQ(5U, buffers[0]->GetSize());
-  EXPECT_EQ(5U * sizeof(uint8_t), buffers[0]->GetSizeInBytes());
+  ASSERT_TRUE(buffers[0]->IsDataBuffer());
+  auto* buffer = buffers[0]->AsDataBuffer();
+  EXPECT_EQ("my_buffer", buffer->GetName());
+  EXPECT_EQ(BufferType::kColor, buffer->GetBufferType());
+  EXPECT_TRUE(buffer->GetDatumType().IsUint8());
+  EXPECT_EQ(5U, buffer->GetSize());
+  EXPECT_EQ(5U * sizeof(uint8_t), buffer->GetSizeInBytes());
 
   std::vector<uint8_t> results = {2, 3, 4, 5, 6};
-  const auto& data = buffers[0]->GetData();
+  const auto& data = buffer->GetData();
   ASSERT_EQ(results.size(), data.size());
   for (size_t i = 0; i < results.size(); ++i) {
     ASSERT_TRUE(data[i].IsInteger());
@@ -1070,14 +1079,16 @@ TEST_F(AmberScriptParserTest, BufferSeriesFloat) {
   ASSERT_EQ(1U, buffers.size());
 
   ASSERT_TRUE(buffers[0] != nullptr);
-  EXPECT_EQ("my_buffer", buffers[0]->GetName());
-  EXPECT_EQ(BufferType::kColor, buffers[0]->GetBufferType());
-  EXPECT_TRUE(buffers[0]->GetDatumType().IsFloat());
-  EXPECT_EQ(5U, buffers[0]->GetSize());
-  EXPECT_EQ(5U * sizeof(float), buffers[0]->GetSizeInBytes());
+  ASSERT_TRUE(buffers[0]->IsDataBuffer());
+  auto* buffer = buffers[0]->AsDataBuffer();
+  EXPECT_EQ("my_buffer", buffer->GetName());
+  EXPECT_EQ(BufferType::kColor, buffer->GetBufferType());
+  EXPECT_TRUE(buffer->GetDatumType().IsFloat());
+  EXPECT_EQ(5U, buffer->GetSize());
+  EXPECT_EQ(5U * sizeof(float), buffer->GetSizeInBytes());
 
   std::vector<float> results = {2.2f, 3.3f, 4.4f, 5.5f, 6.6f};
-  const auto& data = buffers[0]->GetData();
+  const auto& data = buffer->GetData();
   ASSERT_EQ(results.size(), data.size());
   for (size_t i = 0; i < results.size(); ++i) {
     ASSERT_TRUE(data[i].IsFloat());
@@ -1098,12 +1109,14 @@ TEST_F(AmberScriptParserTest, BufferFramebuffer) {
   ASSERT_EQ(1U, buffers.size());
 
   ASSERT_TRUE(buffers[0] != nullptr);
-  EXPECT_EQ("my_buffer", buffers[0]->GetName());
-  EXPECT_EQ(BufferType::kFramebuffer, buffers[0]->GetBufferType());
-  EXPECT_TRUE(buffers[0]->GetDatumType().IsUint32());
-  EXPECT_EQ(4U, buffers[0]->GetDatumType().ColumnCount());
-  EXPECT_EQ(800U * 600U, buffers[0]->GetSize());
-  EXPECT_EQ(800U * 600U * 4U * sizeof(uint32_t), buffers[0]->GetSizeInBytes());
+  ASSERT_TRUE(buffers[0]->IsDataBuffer());
+  auto* buffer = buffers[0]->AsDataBuffer();
+  EXPECT_EQ("my_buffer", buffer->GetName());
+  EXPECT_EQ(BufferType::kFramebuffer, buffer->GetBufferType());
+  EXPECT_TRUE(buffer->GetDatumType().IsUint32());
+  EXPECT_EQ(4U, buffer->GetDatumType().ColumnCount());
+  EXPECT_EQ(800U * 600U, buffer->GetSize());
+  EXPECT_EQ(800U * 600U * 4U * sizeof(uint32_t), buffer->GetSizeInBytes());
 }
 
 TEST_F(AmberScriptParserTest, BufferMultipleBuffers) {
@@ -1124,14 +1137,16 @@ END)";
   ASSERT_EQ(2U, buffers.size());
 
   ASSERT_TRUE(buffers[0] != nullptr);
-  EXPECT_EQ("color_buffer", buffers[0]->GetName());
-  EXPECT_EQ(BufferType::kColor, buffers[0]->GetBufferType());
-  EXPECT_TRUE(buffers[0]->GetDatumType().IsUint8());
-  EXPECT_EQ(5U, buffers[0]->GetSize());
-  EXPECT_EQ(5U * sizeof(uint8_t), buffers[0]->GetSizeInBytes());
+  ASSERT_TRUE(buffers[0]->IsDataBuffer());
+  auto* buffer = buffers[0]->AsDataBuffer();
+  EXPECT_EQ("color_buffer", buffer->GetName());
+  EXPECT_EQ(BufferType::kColor, buffer->GetBufferType());
+  EXPECT_TRUE(buffer->GetDatumType().IsUint8());
+  EXPECT_EQ(5U, buffer->GetSize());
+  EXPECT_EQ(5U * sizeof(uint8_t), buffer->GetSizeInBytes());
 
   std::vector<uint32_t> results0 = {5, 5, 5, 5, 5};
-  const auto& data0 = buffers[0]->GetData();
+  const auto& data0 = buffer->GetData();
   ASSERT_EQ(results0.size(), data0.size());
   for (size_t i = 0; i < results0.size(); ++i) {
     ASSERT_TRUE(data0[i].IsInteger());
@@ -1139,14 +1154,16 @@ END)";
   }
 
   ASSERT_TRUE(buffers[1] != nullptr);
-  EXPECT_EQ("storage_buffer", buffers[1]->GetName());
-  EXPECT_EQ(BufferType::kStorage, buffers[1]->GetBufferType());
-  EXPECT_TRUE(buffers[1]->GetDatumType().IsUint32());
-  EXPECT_EQ(7U, buffers[1]->GetSize());
-  EXPECT_EQ(7U * sizeof(uint32_t), buffers[1]->GetSizeInBytes());
+  ASSERT_TRUE(buffers[1]->IsDataBuffer());
+  buffer = buffers[1]->AsDataBuffer();
+  EXPECT_EQ("storage_buffer", buffer->GetName());
+  EXPECT_EQ(BufferType::kStorage, buffer->GetBufferType());
+  EXPECT_TRUE(buffer->GetDatumType().IsUint32());
+  EXPECT_EQ(7U, buffer->GetSize());
+  EXPECT_EQ(7U * sizeof(uint32_t), buffer->GetSizeInBytes());
 
   std::vector<uint32_t> results1 = {1, 2, 3, 4, 55, 99, 1234};
-  const auto& data1 = buffers[1]->GetData();
+  const auto& data1 = buffer->GetData();
   ASSERT_EQ(results1.size(), data1.size());
   for (size_t i = 0; i < results1.size(); ++i) {
     ASSERT_TRUE(data1[i].IsInteger());
@@ -1168,14 +1185,16 @@ BUFFER index my_index_buffer DATA_TYPE vec2<int32> SIZE 5 FILL 2)";
   ASSERT_EQ(1U, buffers.size());
 
   ASSERT_TRUE(buffers[0] != nullptr);
-  EXPECT_EQ("my_index_buffer", buffers[0]->GetName());
-  EXPECT_EQ(BufferType::kIndex, buffers[0]->GetBufferType());
-  EXPECT_TRUE(buffers[0]->GetDatumType().IsInt32());
-  EXPECT_EQ(5U, buffers[0]->GetSize());
-  EXPECT_EQ(5U * 2 * sizeof(int32_t), buffers[0]->GetSizeInBytes());
+  ASSERT_TRUE(buffers[0]->IsDataBuffer());
+  auto* buffer = buffers[0]->AsDataBuffer();
+  EXPECT_EQ("my_index_buffer", buffer->GetName());
+  EXPECT_EQ(BufferType::kIndex, buffer->GetBufferType());
+  EXPECT_TRUE(buffer->GetDatumType().IsInt32());
+  EXPECT_EQ(5U, buffer->GetSize());
+  EXPECT_EQ(5U * 2 * sizeof(int32_t), buffer->GetSizeInBytes());
 
   std::vector<int32_t> results0 = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2};
-  const auto& data0 = buffers[0]->GetData();
+  const auto& data0 = buffer->GetData();
   ASSERT_EQ(results0.size(), data0.size());
   for (size_t i = 0; i < results0.size(); ++i) {
     ASSERT_TRUE(data0[i].IsInteger());
@@ -1203,14 +1222,16 @@ END
   ASSERT_EQ(1U, buffers.size());
 
   ASSERT_TRUE(buffers[0] != nullptr);
-  EXPECT_EQ("my_index_buffer", buffers[0]->GetName());
-  EXPECT_EQ(BufferType::kIndex, buffers[0]->GetBufferType());
-  EXPECT_TRUE(buffers[0]->GetDatumType().IsInt32());
-  EXPECT_EQ(4U, buffers[0]->GetSize());
-  EXPECT_EQ(4U * 2 * sizeof(int32_t), buffers[0]->GetSizeInBytes());
+  ASSERT_TRUE(buffers[0]->IsDataBuffer());
+  auto* buffer = buffers[0]->AsDataBuffer();
+  EXPECT_EQ("my_index_buffer", buffer->GetName());
+  EXPECT_EQ(BufferType::kIndex, buffer->GetBufferType());
+  EXPECT_TRUE(buffer->GetDatumType().IsInt32());
+  EXPECT_EQ(4U, buffer->GetSize());
+  EXPECT_EQ(4U * 2 * sizeof(int32_t), buffer->GetSizeInBytes());
 
   std::vector<int32_t> results0 = {2, 3, 4, 5, 6, 7, 8, 9};
-  const auto& data0 = buffers[0]->GetData();
+  const auto& data0 = buffer->GetData();
   ASSERT_EQ(results0.size(), data0.size());
   for (size_t i = 0; i < results0.size(); ++i) {
     ASSERT_TRUE(data0[i].IsInteger());
@@ -1238,14 +1259,16 @@ END
   ASSERT_EQ(1U, buffers.size());
 
   ASSERT_TRUE(buffers[0] != nullptr);
-  EXPECT_EQ("my_index_buffer", buffers[0]->GetName());
-  EXPECT_EQ(BufferType::kIndex, buffers[0]->GetBufferType());
-  EXPECT_TRUE(buffers[0]->GetDatumType().IsUint32());
-  EXPECT_EQ(4U, buffers[0]->GetSize());
-  EXPECT_EQ(4U * sizeof(uint32_t), buffers[0]->GetSizeInBytes());
+  ASSERT_TRUE(buffers[0]->IsDataBuffer());
+  auto* buffer = buffers[0]->AsDataBuffer();
+  EXPECT_EQ("my_index_buffer", buffer->GetName());
+  EXPECT_EQ(BufferType::kIndex, buffer->GetBufferType());
+  EXPECT_TRUE(buffer->GetDatumType().IsUint32());
+  EXPECT_EQ(4U, buffer->GetSize());
+  EXPECT_EQ(4U * sizeof(uint32_t), buffer->GetSizeInBytes());
 
   std::vector<uint32_t> results0 = {4278190080, 16711680, 65280, 255};
-  const auto& data0 = buffers[0]->GetData();
+  const auto& data0 = buffer->GetData();
   ASSERT_EQ(results0.size(), data0.size());
   for (size_t i = 0; i < results0.size(); ++i) {
     ASSERT_TRUE(data0[i].IsInteger());
@@ -1648,7 +1671,9 @@ TEST_P(AmberScriptParserBufferDataTypeTest, BufferTypes) {
   ASSERT_EQ(1U, buffers.size());
 
   ASSERT_TRUE(buffers[0] != nullptr);
-  auto& datum = buffers[0]->GetDatumType();
+  ASSERT_TRUE(buffers[0]->IsDataBuffer());
+  auto* buffer = buffers[0]->AsDataBuffer();
+  auto& datum = buffer->GetDatumType();
   EXPECT_EQ(test_data.type, datum.GetType());
   EXPECT_EQ(test_data.row_count, datum.RowCount());
   EXPECT_EQ(test_data.column_count, datum.ColumnCount());
diff --git a/src/amberscript/script_test.cc b/src/amberscript/script_test.cc
index 6110f88..2a2bd5e 100644
--- a/src/amberscript/script_test.cc
+++ b/src/amberscript/script_test.cc
@@ -171,8 +171,8 @@ TEST_F(ScriptTest, GetPipelines) {
   EXPECT_EQ(ptr2, pipelines[1].get());
 }
 
-TEST_F(ScriptTest, AddBuffer) {
-  auto buffer = MakeUnique<Buffer>(BufferType::kStorage);
+TEST_F(ScriptTest, AddDataBuffer) {
+  auto buffer = MakeUnique<DataBuffer>(BufferType::kStorage);
   buffer->SetName("my_buffer");
 
   Script s;
@@ -180,15 +180,15 @@ TEST_F(ScriptTest, AddBuffer) {
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 }
 
-TEST_F(ScriptTest, AddDuplicateBuffer) {
-  auto buffer1 = MakeUnique<Buffer>(BufferType::kStorage);
+TEST_F(ScriptTest, AddDuplicateDataBuffer) {
+  auto buffer1 = MakeUnique<DataBuffer>(BufferType::kStorage);
   buffer1->SetName("my_buffer");
 
   Script s;
   Result r = s.AddBuffer(std::move(buffer1));
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto buffer2 = MakeUnique<Buffer>(BufferType::kUniform);
+  auto buffer2 = MakeUnique<DataBuffer>(BufferType::kUniform);
   buffer2->SetName("my_buffer");
 
   r = s.AddBuffer(std::move(buffer2));
@@ -196,8 +196,8 @@ TEST_F(ScriptTest, AddDuplicateBuffer) {
   EXPECT_EQ("duplicate buffer name provided", r.Error());
 }
 
-TEST_F(ScriptTest, GetBuffer) {
-  auto buffer = MakeUnique<Buffer>(BufferType::kStorage);
+TEST_F(ScriptTest, GetDataBuffer) {
+  auto buffer = MakeUnique<DataBuffer>(BufferType::kStorage);
   buffer->SetName("my_buffer");
 
   const auto* ptr = buffer.get();
@@ -221,7 +221,7 @@ TEST_F(ScriptTest, GetBuffersEmpty) {
 }
 
 TEST_F(ScriptTest, GetBuffers) {
-  auto buffer1 = MakeUnique<Buffer>(BufferType::kStorage);
+  auto buffer1 = MakeUnique<DataBuffer>(BufferType::kStorage);
   buffer1->SetName("my_buffer1");
 
   const auto* ptr1 = buffer1.get();
@@ -230,7 +230,7 @@ TEST_F(ScriptTest, GetBuffers) {
   Result r = s.AddBuffer(std::move(buffer1));
   ASSERT_TRUE(r.IsSuccess()) << r.Error();
 
-  auto buffer2 = MakeUnique<Buffer>(BufferType::kUniform);
+  auto buffer2 = MakeUnique<DataBuffer>(BufferType::kUniform);
   buffer2->SetName("my_buffer2");
 
   const auto* ptr2 = buffer2.get();