| // Copyright 2019 The Amber Authors. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "src/vulkan/vertex_buffer.h" |
| |
| #include <utility> |
| |
| #include "amber/value.h" |
| #include "gtest/gtest.h" |
| #include "src/format.h" |
| #include "src/make_unique.h" |
| #include "src/type_parser.h" |
| #include "src/vulkan/command_buffer.h" |
| #include "src/vulkan/command_pool.h" |
| #include "src/vulkan/device.h" |
| |
| namespace amber { |
| namespace vulkan { |
| namespace { |
| |
| class DummyDevice : public Device { |
| public: |
| DummyDevice() |
| : Device(VkInstance(), |
| VkPhysicalDevice(), |
| 0u, |
| VkDevice(this), |
| VkQueue()) { |
| memory_.resize(64); |
| dummyPtrs_.vkCreateBuffer = vkCreateBuffer; |
| dummyPtrs_.vkGetBufferMemoryRequirements = vkGetBufferMemoryRequirements; |
| dummyPtrs_.vkAllocateMemory = vkAllocateMemory; |
| dummyPtrs_.vkBindBufferMemory = vkBindBufferMemory; |
| dummyPtrs_.vkMapMemory = vkMapMemory; |
| dummyPtrs_.vkCmdPipelineBarrier = vkCmdPipelineBarrier; |
| dummyPtrs_.vkAllocateCommandBuffers = vkAllocateCommandBuffers; |
| dummyPtrs_.vkCreateFence = vkCreateFence; |
| dummyPtrs_.vkDestroyBufferView = vkDestroyBufferView; |
| dummyPtrs_.vkFreeMemory = vkFreeMemory; |
| dummyPtrs_.vkDestroyBuffer = vkDestroyBuffer; |
| } |
| ~DummyDevice() override {} |
| |
| const VulkanPtrs* GetPtrs() const override { return &dummyPtrs_; } |
| |
| bool HasMemoryFlags(uint32_t, const VkMemoryPropertyFlags) const override { |
| return true; |
| } |
| |
| void* GetMemoryPtr() { return memory_.data(); } |
| |
| private: |
| VulkanPtrs dummyPtrs_; |
| std::vector<uint8_t> memory_; |
| |
| static VkResult vkCreateBuffer(VkDevice, |
| const VkBufferCreateInfo*, |
| const VkAllocationCallbacks*, |
| VkBuffer* pBuffer) { |
| *pBuffer = VkBuffer(1); |
| return VK_SUCCESS; |
| } |
| static void vkGetBufferMemoryRequirements( |
| VkDevice, |
| VkBuffer, |
| VkMemoryRequirements* pMemoryRequirements) { |
| pMemoryRequirements->alignment = 0; |
| pMemoryRequirements->size = 0; |
| pMemoryRequirements->memoryTypeBits = 0xffffffff; |
| } |
| static VkResult vkAllocateMemory(VkDevice, |
| const VkMemoryAllocateInfo*, |
| const VkAllocationCallbacks*, |
| VkDeviceMemory*) { |
| return VK_SUCCESS; |
| } |
| static VkResult vkBindBufferMemory(VkDevice, |
| VkBuffer, |
| VkDeviceMemory, |
| VkDeviceSize) { |
| return VK_SUCCESS; |
| } |
| static VkResult vkMapMemory(VkDevice device, |
| VkDeviceMemory, |
| VkDeviceSize, |
| VkDeviceSize, |
| VkMemoryMapFlags, |
| void** ppData) { |
| DummyDevice* devicePtr = reinterpret_cast<DummyDevice*>(device); |
| *ppData = devicePtr->GetMemoryPtr(); |
| return VK_SUCCESS; |
| } |
| static void vkCmdPipelineBarrier(VkCommandBuffer, |
| VkPipelineStageFlags, |
| VkPipelineStageFlags, |
| VkDependencyFlags, |
| uint32_t, |
| const VkMemoryBarrier*, |
| uint32_t, |
| const VkBufferMemoryBarrier*, |
| uint32_t, |
| const VkImageMemoryBarrier*) {} |
| static VkResult vkAllocateCommandBuffers(VkDevice, |
| const VkCommandBufferAllocateInfo*, |
| VkCommandBuffer*) { |
| return VK_SUCCESS; |
| } |
| static VkResult vkCreateFence(VkDevice, |
| const VkFenceCreateInfo*, |
| const VkAllocationCallbacks*, |
| VkFence*) { |
| return VK_SUCCESS; |
| } |
| static void vkDestroyBufferView(VkDevice, |
| VkBufferView, |
| const VkAllocationCallbacks*) {} |
| static void vkFreeMemory(VkDevice, |
| VkDeviceMemory, |
| const VkAllocationCallbacks*) {} |
| static void vkDestroyBuffer(VkDevice, |
| VkBuffer, |
| const VkAllocationCallbacks*) {} |
| }; |
| |
| class VertexBufferTest : public testing::Test { |
| public: |
| VertexBufferTest() |
| : device_(MakeUnique<DummyDevice>()), |
| commandPool_(MakeUnique<CommandPool>(device_.get())), |
| commandBuffer_( |
| MakeUnique<CommandBuffer>(device_.get(), commandPool_.get())), |
| vertex_buffer_(MakeUnique<VertexBuffer>(device_.get())) { |
| commandBuffer_->Initialize(); |
| } |
| |
| ~VertexBufferTest() override { vertex_buffer_.reset(); } |
| |
| Result SetData(uint8_t location, Format* format, std::vector<Value> values) { |
| auto buffer = MakeUnique<Buffer>(); |
| buffer->SetFormat(format); |
| buffer->SetData(std::move(values)); |
| |
| vertex_buffer_->SetData(location, buffer.get(), InputRate::kVertex, format, |
| 0, format->SizeInBytes()); |
| return vertex_buffer_->SendVertexData(commandBuffer_.get()); |
| } |
| |
| const void* GetVkBufferPtr() { return device_->GetMemoryPtr(); } |
| |
| private: |
| std::unique_ptr<DummyDevice> device_; |
| std::unique_ptr<CommandPool> commandPool_; |
| std::unique_ptr<CommandBuffer> commandBuffer_; |
| std::unique_ptr<VertexBuffer> vertex_buffer_; |
| }; |
| |
| } // namespace |
| |
| TEST_F(VertexBufferTest, R8G8B8A8_UINT) { |
| std::vector<Value> values(4); |
| values[0].SetIntValue(55); |
| values[1].SetIntValue(3); |
| values[2].SetIntValue(27); |
| values[3].SetIntValue(255); |
| |
| TypeParser parser; |
| auto type = parser.Parse("R8G8B8A8_UINT"); |
| Format fmt(type.get()); |
| Result r = SetData(0, &fmt, values); |
| |
| const uint8_t* ptr = static_cast<const uint8_t*>(GetVkBufferPtr()); |
| EXPECT_EQ(55, ptr[0]); |
| EXPECT_EQ(3, ptr[1]); |
| EXPECT_EQ(27, ptr[2]); |
| EXPECT_EQ(255, ptr[3]); |
| } |
| |
| TEST_F(VertexBufferTest, R16G16B16A16_UINT) { |
| std::vector<Value> values(4); |
| values[0].SetIntValue(55); |
| values[1].SetIntValue(3); |
| values[2].SetIntValue(27); |
| values[3].SetIntValue(255); |
| |
| TypeParser parser; |
| auto type = parser.Parse("R16G16B16A16_UINT"); |
| Format fmt(type.get()); |
| Result r = SetData(0, &fmt, values); |
| |
| const uint16_t* ptr = static_cast<const uint16_t*>(GetVkBufferPtr()); |
| EXPECT_EQ(55, ptr[0]); |
| EXPECT_EQ(3, ptr[1]); |
| EXPECT_EQ(27, ptr[2]); |
| EXPECT_EQ(255, ptr[3]); |
| } |
| |
| TEST_F(VertexBufferTest, R32G32B32A32_UINT) { |
| std::vector<Value> values(4); |
| values[0].SetIntValue(55); |
| values[1].SetIntValue(3); |
| values[2].SetIntValue(27); |
| values[3].SetIntValue(255); |
| |
| TypeParser parser; |
| auto type = parser.Parse("R32G32B32A32_UINT"); |
| Format fmt(type.get()); |
| Result r = SetData(0, &fmt, values); |
| |
| const uint32_t* ptr = static_cast<const uint32_t*>(GetVkBufferPtr()); |
| EXPECT_EQ(55, ptr[0]); |
| EXPECT_EQ(3, ptr[1]); |
| EXPECT_EQ(27, ptr[2]); |
| EXPECT_EQ(255, ptr[3]); |
| } |
| |
| TEST_F(VertexBufferTest, R64G64B64A64_UINT) { |
| std::vector<Value> values(4); |
| values[0].SetIntValue(55); |
| values[1].SetIntValue(3); |
| values[2].SetIntValue(27); |
| values[3].SetIntValue(255); |
| |
| TypeParser parser; |
| auto type = parser.Parse("R64G64B64A64_UINT"); |
| Format fmt(type.get()); |
| Result r = SetData(0, &fmt, values); |
| |
| const uint64_t* ptr = static_cast<const uint64_t*>(GetVkBufferPtr()); |
| EXPECT_EQ(55, ptr[0]); |
| EXPECT_EQ(3, ptr[1]); |
| EXPECT_EQ(27, ptr[2]); |
| EXPECT_EQ(255, ptr[3]); |
| } |
| |
| TEST_F(VertexBufferTest, R8G8B8A8_SNORM) { |
| std::vector<Value> values(4); |
| values[0].SetIntValue(static_cast<uint64_t>(-55)); |
| values[1].SetIntValue(3); |
| values[2].SetIntValue(static_cast<uint64_t>(-128)); |
| values[3].SetIntValue(127); |
| |
| TypeParser parser; |
| auto type = parser.Parse("R8G8B8A8_SNORM"); |
| Format fmt(type.get()); |
| Result r = SetData(0, &fmt, values); |
| const int8_t* ptr = static_cast<const int8_t*>(GetVkBufferPtr()); |
| |
| EXPECT_EQ(-55, ptr[0]); |
| EXPECT_EQ(3, ptr[1]); |
| EXPECT_EQ(-128, ptr[2]); |
| EXPECT_EQ(127, ptr[3]); |
| } |
| |
| TEST_F(VertexBufferTest, R16G16B16A16_SNORM) { |
| std::vector<Value> values(4); |
| values[0].SetIntValue(static_cast<uint64_t>(-55)); |
| values[1].SetIntValue(3); |
| values[2].SetIntValue(static_cast<uint64_t>(-27)); |
| values[3].SetIntValue(255); |
| |
| TypeParser parser; |
| auto type = parser.Parse("R16G16B16A16_SNORM"); |
| Format fmt(type.get()); |
| Result r = SetData(0, &fmt, values); |
| |
| const int16_t* ptr = static_cast<const int16_t*>(GetVkBufferPtr()); |
| EXPECT_EQ(-55, ptr[0]); |
| EXPECT_EQ(3, ptr[1]); |
| EXPECT_EQ(-27, ptr[2]); |
| EXPECT_EQ(255, ptr[3]); |
| } |
| |
| TEST_F(VertexBufferTest, R32G32B32A32_SINT) { |
| std::vector<Value> values(4); |
| values[0].SetIntValue(static_cast<uint64_t>(-55)); |
| values[1].SetIntValue(3); |
| values[2].SetIntValue(static_cast<uint64_t>(-27)); |
| values[3].SetIntValue(255); |
| |
| TypeParser parser; |
| auto type = parser.Parse("R32G32B32A32_SINT"); |
| Format fmt(type.get()); |
| Result r = SetData(0, &fmt, values); |
| |
| const int32_t* ptr = static_cast<const int32_t*>(GetVkBufferPtr()); |
| EXPECT_EQ(-55, ptr[0]); |
| EXPECT_EQ(3, ptr[1]); |
| EXPECT_EQ(-27, ptr[2]); |
| EXPECT_EQ(255, ptr[3]); |
| } |
| |
| TEST_F(VertexBufferTest, R64G64B64A64_SINT) { |
| std::vector<Value> values(4); |
| values[0].SetIntValue(static_cast<uint64_t>(-55)); |
| values[1].SetIntValue(3); |
| values[2].SetIntValue(static_cast<uint64_t>(-27)); |
| values[3].SetIntValue(255); |
| |
| TypeParser parser; |
| auto type = parser.Parse("R64G64B64A64_SINT"); |
| Format fmt(type.get()); |
| Result r = SetData(0, &fmt, values); |
| |
| const int64_t* ptr = static_cast<const int64_t*>(GetVkBufferPtr()); |
| EXPECT_EQ(-55, ptr[0]); |
| EXPECT_EQ(3, ptr[1]); |
| EXPECT_EQ(-27, ptr[2]); |
| EXPECT_EQ(255, ptr[3]); |
| } |
| |
| TEST_F(VertexBufferTest, R32G32B32_SFLOAT) { |
| std::vector<Value> values(3); |
| values[0].SetDoubleValue(-6.0); |
| values[1].SetDoubleValue(14.0); |
| values[2].SetDoubleValue(0.1171875); |
| |
| TypeParser parser; |
| auto type = parser.Parse("R32G32B32_SFLOAT"); |
| Format fmt(type.get()); |
| Result r = SetData(0, &fmt, values); |
| |
| const float* ptr = static_cast<const float*>(GetVkBufferPtr()); |
| EXPECT_FLOAT_EQ(-6.0f, ptr[0]); |
| EXPECT_FLOAT_EQ(14.0f, ptr[1]); |
| EXPECT_FLOAT_EQ(0.1171875f, ptr[2]); |
| } |
| |
| TEST_F(VertexBufferTest, R64G64B64_SFLOAT) { |
| std::vector<Value> values(3); |
| values[0].SetDoubleValue(-6.0); |
| values[1].SetDoubleValue(14.0); |
| values[2].SetDoubleValue(0.1171875); |
| |
| TypeParser parser; |
| auto type = parser.Parse("R64G64B64_SFLOAT"); |
| Format fmt(type.get()); |
| Result r = SetData(0, &fmt, values); |
| |
| const double* ptr = static_cast<const double*>(GetVkBufferPtr()); |
| EXPECT_DOUBLE_EQ(-6.0, ptr[0]); |
| EXPECT_DOUBLE_EQ(14.0, ptr[1]); |
| EXPECT_DOUBLE_EQ(0.1171875, ptr[2]); |
| } |
| |
| } // namespace vulkan |
| } // namespace amber |
