From 4e1b17067c199f1b12f42b2b895d49cfed8aaeff Mon Sep 17 00:00:00 2001 From: Squareys Date: Wed, 24 Aug 2016 09:11:19 +0200 Subject: [PATCH] Vk: Loads of improvements everywhere Signed-off-by: Squareys --- src/Magnum/Vk/CMakeLists.txt | 5 +- src/Magnum/Vk/Device.cpp | 20 +-- src/Magnum/Vk/Device.h | 14 ++- src/Magnum/Vk/Format.h | 231 +++++++++++++++++++++++++++++++++++ src/Magnum/Vk/Framebuffer.h | 7 ++ src/Magnum/Vk/Image.h | 7 ++ src/Magnum/Vk/Mesh.h | 38 ++++-- src/Magnum/Vk/Pipeline.cpp | 23 +++- src/Magnum/Vk/Pipeline.h | 86 +++++++------ src/Magnum/Vk/Queue.h | 7 ++ 10 files changed, 370 insertions(+), 68 deletions(-) create mode 100644 src/Magnum/Vk/Format.h diff --git a/src/Magnum/Vk/CMakeLists.txt b/src/Magnum/Vk/CMakeLists.txt index 21698a06e..9d6ee44ad 100644 --- a/src/Magnum/Vk/CMakeLists.txt +++ b/src/Magnum/Vk/CMakeLists.txt @@ -31,7 +31,6 @@ set(MagnumVk_SRCS Buffer.cpp CommandBuffer.cpp CommandPool.cpp - Instance.cpp DescriptorPool.cpp DescriptorSet.cpp Device.cpp @@ -39,6 +38,7 @@ set(MagnumVk_SRCS Framebuffer.cpp Image.cpp ImageView.cpp + Instance.cpp Mesh.cpp PhysicalDevice.cpp Pipeline.cpp @@ -54,14 +54,15 @@ set(MagnumVk_HEADERS Command.h CommandBuffer.h CommandPool.h - Instance.h DescriptorPool.h DescriptorSet.h Device.h DeviceMemory.h + Format.h Framebuffer.h Image.h ImageView.h + Instance.h Math.h Mesh.h PhysicalDevice.h diff --git a/src/Magnum/Vk/Device.cpp b/src/Magnum/Vk/Device.cpp index 4bea61d17..726d89b17 100644 --- a/src/Magnum/Vk/Device.cpp +++ b/src/Magnum/Vk/Device.cpp @@ -32,24 +32,26 @@ namespace Magnum { namespace Vk { -Device::Device(PhysicalDevice& physicalDevice, VkDeviceQueueCreateInfo& requestedQueues): +Device::Device(PhysicalDevice& physicalDevice, const std::vector& requestedQueues, + const std::vector& extensions, const std::vector& validationLayers): _physicalDevice(physicalDevice) { - constexpr const char* enabledExtensions[]{VK_KHR_SWAPCHAIN_EXTENSION_NAME}; - constexpr const char* validationLayerNames[] = {"VK_LAYER_LUNARG_standard_validation"}; - - // TODO: Allow disabling validation layers - VkDeviceCreateInfo deviceCreateInfo = { VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, nullptr, 0, /* flags */ - 1, &requestedQueues, - 1, validationLayerNames, - 1, enabledExtensions, + requestedQueues.size(), requestedQueues.data(), + validationLayers.size(), validationLayers.data(), + extensions.size(), extensions.data(), nullptr}; vkCreateDevice(physicalDevice.vkPhysicalDevice(), &deviceCreateInfo, nullptr, &_device); + + for(const VkDeviceQueueCreateInfo& info : requestedQueues) { + for(UnsignedInt i = 0; i < info.queueCount; ++i) { + _queues.emplace_back(new Queue{*this, info.queueFamilyIndex, i}); + } + } } Device::~Device() { diff --git a/src/Magnum/Vk/Device.h b/src/Magnum/Vk/Device.h index 8f86f974d..61431cb3b 100644 --- a/src/Magnum/Vk/Device.h +++ b/src/Magnum/Vk/Device.h @@ -53,7 +53,10 @@ class MAGNUM_VK_EXPORT Device { /** @brief Move constructor */ Device(Device&& other); - Device(PhysicalDevice& physicalDevice, VkDeviceQueueCreateInfo& requestedQueues); + Device(PhysicalDevice& physicalDevice, + const std::vector& requestedQueues, + const std::vector& extensions, + const std::vector& validationLayers); /** * @brief Destructor @@ -96,9 +99,18 @@ class MAGNUM_VK_EXPORT Device { return _device; } + /** + * @brief Get a requested queue + * @param index Index of the queue in order requested + */ + Queue& getQueue(UnsignedInt index) { + return *_queues[index]; + } + private: VkDevice _device; PhysicalDevice& _physicalDevice; + std::vector> _queues; }; }} diff --git a/src/Magnum/Vk/Format.h b/src/Magnum/Vk/Format.h new file mode 100644 index 000000000..b49290853 --- /dev/null +++ b/src/Magnum/Vk/Format.h @@ -0,0 +1,231 @@ +#ifndef Magnum_Vk_Format_h +#define Magnum_Vk_Format_h +/* + This file is part of Magnum. + + Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016 + Vladimír Vondruš + Copyright © 2016 Jonathan Hale + + 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. + + 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 + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. +*/ + +/** @file + * @brief Enum @ref Magnum::Vk::Format + */ + +#include + +#include "Magnum/Vk/visibility.h" + +#include "vulkan.h" + +namespace Magnum { namespace Vk { + +enum class Format: UnsignedInt { + Undefined = VK_FORMAT_UNDEFINED, + RG4_UNorm_Pack8 = VK_FORMAT_R4G4_UNORM_PACK8, + RGBA4_UNorm_Pack16 = VK_FORMAT_R4G4B4A4_UNORM_PACK16, + BGRA4_UNorm_Pack16 = VK_FORMAT_B4G4R4A4_UNORM_PACK16, + R5G6B5_UNorm_Pack16 = VK_FORMAT_R5G6B5_UNORM_PACK16, + B5G6R5_UNorm_Pack16 = VK_FORMAT_B5G6R5_UNORM_PACK16, + RGB5A1_UNorm_Pack16 = VK_FORMAT_R5G5B5A1_UNORM_PACK16, + BGR5A1_UNorm_Pack16 = VK_FORMAT_B5G5R5A1_UNORM_PACK16, + A1RGB5_UNorm_Pack16 = VK_FORMAT_A1R5G5B5_UNORM_PACK16, + R8_UNorm = VK_FORMAT_R8_UNORM, + R8_SNorm = VK_FORMAT_R8_SNORM, + R8_UScaled = VK_FORMAT_R8_USCALED, + R8_SScaled = VK_FORMAT_R8_SSCALED, + R8_UInt = VK_FORMAT_R8_UINT, + R8_SInt = VK_FORMAT_R8_SINT, + R8_SRGB = VK_FORMAT_R8_SRGB, + RG8_UNorm = VK_FORMAT_R8G8_UNORM, + RG8_SNorm = VK_FORMAT_R8G8_SNORM, + RG8_UScaled = VK_FORMAT_R8G8_USCALED, + RG8_SScaled = VK_FORMAT_R8G8_SSCALED, + RG8_UInt = VK_FORMAT_R8G8_UINT, + RG8_SInt = VK_FORMAT_R8G8_SINT, + RG8_SRGB = VK_FORMAT_R8G8_SRGB, + RGB8_UNorm = VK_FORMAT_R8G8B8_UNORM, + RGB8_SNorm = VK_FORMAT_R8G8B8_SNORM, + RGB8_UScaled = VK_FORMAT_R8G8B8_USCALED, + RGB8_SScaled = VK_FORMAT_R8G8B8_SSCALED, + RGB8_UInt = VK_FORMAT_R8G8B8_UINT, + RGB8_SInt = VK_FORMAT_R8G8B8_SINT, + RGB8_SRGB = VK_FORMAT_R8G8B8_SRGB, + BGR8_UNorm = VK_FORMAT_B8G8R8_UNORM, + BGR8_SNorm = VK_FORMAT_B8G8R8_SNORM, + BGR8_UScaled = VK_FORMAT_B8G8R8_USCALED, + BGR8_SScaled = VK_FORMAT_B8G8R8_SSCALED, + BGR8_UInt = VK_FORMAT_B8G8R8_UINT, + BGR8_SInt = VK_FORMAT_B8G8R8_SINT, + BGR8_SRGB = VK_FORMAT_B8G8R8_SRGB, + RBA8_UNorm = VK_FORMAT_R8G8B8A8_UNORM, + RGBA8_SNorm = VK_FORMAT_R8G8B8A8_SNORM, + RGBA8_UScaled = VK_FORMAT_R8G8B8A8_USCALED, + RGBA8_SScaled = VK_FORMAT_R8G8B8A8_SSCALED, + RGBA8_UINT = VK_FORMAT_R8G8B8A8_UINT, + RGBA8_SINT = VK_FORMAT_R8G8B8A8_SINT, + RGBA8_SRGB = VK_FORMAT_R8G8B8A8_SRGB, + BGRA8_UNorm = VK_FORMAT_B8G8R8A8_UNORM, + BGRA8_SNorm = VK_FORMAT_B8G8R8A8_SNORM, + BGRA8_USCALED = VK_FORMAT_B8G8R8A8_USCALED, + BGRA8_SSCALED = VK_FORMAT_B8G8R8A8_SSCALED, + BGRA8_UINT = VK_FORMAT_B8G8R8A8_UINT, + BGRA8_SINT = VK_FORMAT_B8G8R8A8_SINT, + BGRA8_SRGB = VK_FORMAT_B8G8R8A8_SRGB, + ABGR8_UNorm_Pack32 = VK_FORMAT_A8B8G8R8_UNORM_PACK32, + ABGR8_SNorm_Pack32 = VK_FORMAT_A8B8G8R8_SNORM_PACK32, + ABGR8_USCALED_Pack32 = VK_FORMAT_A8B8G8R8_USCALED_PACK32, + ABGR8_SSCALED_Pack32 = VK_FORMAT_A8B8G8R8_SSCALED_PACK32, + ABGR8_UINT_Pack32 = VK_FORMAT_A8B8G8R8_UINT_PACK32, + ABGR8_SINT_Pack32 = VK_FORMAT_A8B8G8R8_SINT_PACK32, + ABGR8_SRGB_Pack32 = VK_FORMAT_A8B8G8R8_SRGB_PACK32, + A2RGB10_UNorm_Pack32 = VK_FORMAT_A2R10G10B10_UNORM_PACK32, + A2RGB10_SNorm_Pack32 = VK_FORMAT_A2R10G10B10_SNORM_PACK32, + A2RGB10_USCALED_Pack32 = VK_FORMAT_A2R10G10B10_USCALED_PACK32, + A2RGB10_SSCALED_Pack32 = VK_FORMAT_A2R10G10B10_SSCALED_PACK32, + A2RGB10_UINT_Pack32 = VK_FORMAT_A2R10G10B10_UINT_PACK32, + A2RGB10_SINT_Pack32 = VK_FORMAT_A2R10G10B10_SINT_PACK32, + A2BGR10_UNorm_Pack32 = VK_FORMAT_A2B10G10R10_UNORM_PACK32, + A2BGR10_SNorm_Pack32 = VK_FORMAT_A2B10G10R10_SNORM_PACK32, + A2BGR10_USCALED_PACK32 = VK_FORMAT_A2B10G10R10_USCALED_PACK32, + A2BGR10_SSCALED_PACK32 = VK_FORMAT_A2B10G10R10_SSCALED_PACK32, + A2BGR10_UINT_PACK32 = VK_FORMAT_A2B10G10R10_UINT_PACK32, + A2BGR10_SINT_PACK32 = VK_FORMAT_A2B10G10R10_SINT_PACK32, + R16_UNorm = VK_FORMAT_R16_UNORM, + R16_SNorm = VK_FORMAT_R16_SNORM, + R16_USCALED = VK_FORMAT_R16_USCALED, + R16_SSCALED = VK_FORMAT_R16_SSCALED, + R16_UINT = VK_FORMAT_R16_UINT, + R16_SINT = VK_FORMAT_R16_SINT, + R16_SFLOAT = VK_FORMAT_R16_SFLOAT, + RG16_UNorm = VK_FORMAT_R16G16_UNORM, + RG16_SNorm = VK_FORMAT_R16G16_SNORM, + RG16_USCALED = VK_FORMAT_R16G16_USCALED, + RG16_SSCALED = VK_FORMAT_R16G16_SSCALED, + RG16_UINT = VK_FORMAT_R16G16_UINT, + RG16_SINT = VK_FORMAT_R16G16_SINT, + RG16_SFLOAT = VK_FORMAT_R16G16_SFLOAT, + RGB16_UNorm = VK_FORMAT_R16G16B16_UNORM, + RGB16_SNorm = VK_FORMAT_R16G16B16_SNORM, + RGB16_USCALED = VK_FORMAT_R16G16B16_USCALED, + RGB16_SSCALED = VK_FORMAT_R16G16B16_SSCALED, + RGB16_UINT = VK_FORMAT_R16G16B16_UINT, + RGB16_SINT = VK_FORMAT_R16G16B16_SINT, + RGB16_SFLOAT = VK_FORMAT_R16G16B16_SFLOAT, + RGBA16_UNorm = VK_FORMAT_R16G16B16A16_UNORM, + RGBA16_SNorm = VK_FORMAT_R16G16B16A16_SNORM, + RGBA16_USCALED = VK_FORMAT_R16G16B16A16_USCALED, + RGBA16_SSCALED = VK_FORMAT_R16G16B16A16_SSCALED, + RGBA16_UINT = VK_FORMAT_R16G16B16A16_UINT, + RGBA16_SINT = VK_FORMAT_R16G16B16A16_SINT, + RGBA16_SFLOAT = VK_FORMAT_R16G16B16A16_SFLOAT, + R32_UINT = VK_FORMAT_R32_UINT, + R32_SINT = VK_FORMAT_R32_SINT, + R32_SFLOAT = VK_FORMAT_R32_SFLOAT, + RG32_UINT = VK_FORMAT_R32G32_UINT, + RG32_SINT = VK_FORMAT_R32G32_SINT, + RG32_SFLOAT = VK_FORMAT_R32G32_SFLOAT, + RGB32_UINT = VK_FORMAT_R32G32B32_UINT, + RGB32_SINT = VK_FORMAT_R32G32B32_SINT, + RGB32_SFLOAT = VK_FORMAT_R32G32B32_SFLOAT, + RGBA32_UINT = VK_FORMAT_R32G32B32A32_UINT, + RGBA32_SINT = VK_FORMAT_R32G32B32A32_SINT, + RGBA32_SFLOAT = VK_FORMAT_R32G32B32A32_SFLOAT, + R64_UINT = VK_FORMAT_R64_UINT, + R64_SINT = VK_FORMAT_R64_SINT, + R64_SFLOAT = VK_FORMAT_R64_SFLOAT, + RG64_UINT = VK_FORMAT_R64G64_UINT, + RG64_SINT = VK_FORMAT_R64G64_SINT, + RG64_SFLOAT = VK_FORMAT_R64G64_SFLOAT, + RGB64_UINT = VK_FORMAT_R64G64B64_UINT, + RGB64_SINT = VK_FORMAT_R64G64B64_SINT, + RGB64_SFLOAT = VK_FORMAT_R64G64B64_SFLOAT, + RGBA64_UINT = VK_FORMAT_R64G64B64A64_UINT, + RGBA64_SINT = VK_FORMAT_R64G64B64A64_SINT, + RGBA64_SFLOAT = VK_FORMAT_R64G64B64A64_SFLOAT, + B10GR11_UFLOAT_Pack32 = VK_FORMAT_B10G11R11_UFLOAT_PACK32, + E5BGR9_UFLOAT_Pack32 = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, + D16_UNorm = VK_FORMAT_D16_UNORM, + X8_D24_UNorm_Pack32 = VK_FORMAT_X8_D24_UNORM_PACK32, + D32_SFLOAT = VK_FORMAT_D32_SFLOAT, + S8_UINT = VK_FORMAT_S8_UINT, + D16_UNorm_S8_UINT = VK_FORMAT_D16_UNORM_S8_UINT, + D24_UNorm_S8_UINT = VK_FORMAT_D24_UNORM_S8_UINT, + D32_SFLOAT_S8_UINT = VK_FORMAT_D32_SFLOAT_S8_UINT, + BC1_RGB_UNorm_Block = VK_FORMAT_BC1_RGB_UNORM_BLOCK, + BC1_RGB_SRGB_Block = VK_FORMAT_BC1_RGB_SRGB_BLOCK, + BC1_RGBA_UNORM_Block = VK_FORMAT_BC1_RGBA_UNORM_BLOCK, + BC1_RGBA_SRGB_Block = VK_FORMAT_BC1_RGBA_SRGB_BLOCK, + BC2_UNORM_Block = VK_FORMAT_BC2_UNORM_BLOCK, + BC2_SRGB_Block = VK_FORMAT_BC2_SRGB_BLOCK, + BC3_UNORM_Block = VK_FORMAT_BC3_UNORM_BLOCK, + BC3_SRGB_Block = VK_FORMAT_BC3_SRGB_BLOCK, + BC4_UNorm_Block = VK_FORMAT_BC4_UNORM_BLOCK, + BC4_SNorm_Block = VK_FORMAT_BC4_SNORM_BLOCK, + BC5_UNorm_Block = VK_FORMAT_BC5_UNORM_BLOCK, + BC5_SNorm_Block = VK_FORMAT_BC5_SNORM_BLOCK, + BC6H_UFLOAT_Block = VK_FORMAT_BC6H_UFLOAT_BLOCK, + BC6H_SFLOAT_Block = VK_FORMAT_BC6H_SFLOAT_BLOCK, + BC7_UNorm_Block = VK_FORMAT_BC7_UNORM_BLOCK, + BC7_SRGB_Block = VK_FORMAT_BC7_SRGB_BLOCK, + ETC2_RGB8_UNorm_Block = VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, + ETC2_RGB8_SRGB_Block = VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, + ETC2_RGB8A1_UNorm_Block = VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, + ETC2_RGB8A1_SRGB_Block = VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, + ETC2_RGBA8_UNorm_Block = VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, + ETC2_RGBA8_SRGB_Block = VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, + EAC_R11_UNorm_Block = VK_FORMAT_EAC_R11_UNORM_BLOCK, + EAC_R11_SNorm_Block = VK_FORMAT_EAC_R11_SNORM_BLOCK, + EAC_RG11_UN= VK_FORMAT_EAC_R11G11_UNORM_BLOCK, + EAC_RG11_SNorm_Block = VK_FORMAT_EAC_R11G11_SNORM_BLOCK, + ASTC_4x4_UNorm_Block = VK_FORMAT_ASTC_4x4_UNORM_BLOCK, + ASTC_4x4_SRGB_Block = VK_FORMAT_ASTC_4x4_SRGB_BLOCK, + ASTC_5x4_UNorm_Block = VK_FORMAT_ASTC_5x4_UNORM_BLOCK, + ASTC_5x4_SRGB_Block = VK_FORMAT_ASTC_5x4_SRGB_BLOCK, + ASTC_5x5_UNorm_Block = VK_FORMAT_ASTC_5x5_UNORM_BLOCK, + ASTC_5x5_SRGB_Block = VK_FORMAT_ASTC_5x5_SRGB_BLOCK, + ASTC_6x5_UNorm_Block = VK_FORMAT_ASTC_6x5_UNORM_BLOCK, + ASTC_6x5_SRGB_Block = VK_FORMAT_ASTC_6x5_SRGB_BLOCK, + ASTC_6x6_UNorm_Block = VK_FORMAT_ASTC_6x6_UNORM_BLOCK, + ASTC_6x6_SRGB_Block = VK_FORMAT_ASTC_6x6_SRGB_BLOCK, + ASTC_8x5_UNorm_Block = VK_FORMAT_ASTC_8x5_UNORM_BLOCK, + ASTC_8x5_SRGB_Block = VK_FORMAT_ASTC_8x5_SRGB_BLOCK, + ASTC_8x6_UNorm_Block = VK_FORMAT_ASTC_8x6_UNORM_BLOCK, + ASTC_8x6_SRGB_Block = VK_FORMAT_ASTC_8x6_SRGB_BLOCK, + ASTC_8x8_UNorm_Block = VK_FORMAT_ASTC_8x8_UNORM_BLOCK, + ASTC_8x8_SRGB_Block = VK_FORMAT_ASTC_8x8_SRGB_BLOCK, + ASTC_10x5_UNorm_Block = VK_FORMAT_ASTC_10x5_UNORM_BLOCK, + ASTC_10x5_SRGB_Block = VK_FORMAT_ASTC_10x5_SRGB_BLOCK, + ASTC_10x6_UNorm_Block = VK_FORMAT_ASTC_10x6_UNORM_BLOCK, + ASTC_10x6_SRGB_Block = VK_FORMAT_ASTC_10x6_SRGB_BLOCK, + ASTC_10x8_UNorm_Block = VK_FORMAT_ASTC_10x8_UNORM_BLOCK, + ASTC_10x8_SRGB_Block = VK_FORMAT_ASTC_10x8_SRGB_BLOCK, + ASTC_10x10_UNorm_Block = VK_FORMAT_ASTC_10x10_UNORM_BLOCK, + ASTC_10x10_SRGB_Block = VK_FORMAT_ASTC_10x10_SRGB_BLOCK, + ASTC_12x10_UNorm_Block = VK_FORMAT_ASTC_12x10_UNORM_BLOCK, + ASTC_12x10_SRGB_Block = VK_FORMAT_ASTC_12x10_SRGB_BLOCK, + ASTC_12x12_UNorm_Block = VK_FORMAT_ASTC_12x12_UNORM_BLOCK, + ASTC_12x12_SRGB_Block = VK_FORMAT_ASTC_12x12_SRGB_BLOCK, +}; + +}} + +#endif diff --git a/src/Magnum/Vk/Framebuffer.h b/src/Magnum/Vk/Framebuffer.h index ea9b7f99f..d26435570 100644 --- a/src/Magnum/Vk/Framebuffer.h +++ b/src/Magnum/Vk/Framebuffer.h @@ -94,6 +94,13 @@ class MAGNUM_VK_EXPORT Framebuffer { return _framebuffer; } + /** + * @brief The device this framebuffer was created for. + */ + Device& device() { + return _device; + } + private: Device& _device; VkFramebuffer _framebuffer; diff --git a/src/Magnum/Vk/Image.h b/src/Magnum/Vk/Image.h index 11910d2e3..b897c0cc4 100644 --- a/src/Magnum/Vk/Image.h +++ b/src/Magnum/Vk/Image.h @@ -170,6 +170,13 @@ class MAGNUM_VK_EXPORT Image { return *this; } + /** + * @brief The device this image was created for. + */ + Device& device() { + return _device; + } + private: Device& _device; VkImage _image; diff --git a/src/Magnum/Vk/Mesh.h b/src/Magnum/Vk/Mesh.h index 0fd9a9e01..91f11bf0e 100644 --- a/src/Magnum/Vk/Mesh.h +++ b/src/Magnum/Vk/Mesh.h @@ -42,15 +42,14 @@ namespace Magnum { namespace Vk { class MAGNUM_VK_EXPORT Mesh { public: - Mesh() { - } - /** @brief Copying is not allowed */ Mesh(const Mesh&) = delete; /** @brief Move constructor */ Mesh(Mesh&& other); + Mesh(): _count(0), _drawIndexed(false) {}; + /** * @brief Destructor * @@ -68,15 +67,21 @@ class MAGNUM_VK_EXPORT Mesh { const VkBuffer* vertexBuffers = _vertexBuffers.data(); const VkBuffer indexBuffer = _indexBuffer; - const int numVertexBuffers = _vertexBuffers.size(); - const int numIndices = _numIndices; - return [vertexBuffers, indexBuffer, numVertexBuffers, numIndices](VkCommandBuffer cmdBuffer){ + const UnsignedInt numVertexBuffers = _vertexBuffers.size(); + const UnsignedInt count = _count; + const bool drawIndexed = _drawIndexed; + return [vertexBuffers, indexBuffer, numVertexBuffers, count, drawIndexed](VkCommandBuffer cmdBuffer){ VkDeviceSize offset = 0; vkCmdBindVertexBuffers(cmdBuffer, 0, numVertexBuffers, vertexBuffers, &offset); - vkCmdBindIndexBuffer(cmdBuffer, indexBuffer, 0, VK_INDEX_TYPE_UINT32); - vkCmdDrawIndexed(cmdBuffer, numIndices, 1, 0, 0, 1); + if(drawIndexed) { + vkCmdBindIndexBuffer(cmdBuffer, indexBuffer, 0, VK_INDEX_TYPE_UINT32); + + vkCmdDrawIndexed(cmdBuffer, count, 1, 0, 0, 1); + } else { + vkCmdDraw(cmdBuffer, count, 1, 0, 0); + } }; } @@ -87,7 +92,18 @@ class MAGNUM_VK_EXPORT Mesh { Mesh& setIndexBuffer(const Buffer& buffer) { _indexBuffer = buffer; - _numIndices = buffer.size(); + _count = buffer.size(); + _drawIndexed = true; + return *this; + } + + Mesh& setCount(UnsignedInt count) { + _count = count; + return *this; + } + + Mesh& setDrawIndexed(bool indexed) { + _drawIndexed = indexed; return *this; } @@ -95,7 +111,9 @@ class MAGNUM_VK_EXPORT Mesh { std::vector _vertexBuffers; VkBuffer _indexBuffer; - int _numIndices; + bool _drawIndexed; + + UnsignedInt _count; }; }} diff --git a/src/Magnum/Vk/Pipeline.cpp b/src/Magnum/Vk/Pipeline.cpp index 854bfe1ac..21f3bfe51 100644 --- a/src/Magnum/Vk/Pipeline.cpp +++ b/src/Magnum/Vk/Pipeline.cpp @@ -63,9 +63,28 @@ std::unique_ptr GraphicsPipelineBuilder::build() { nullptr /* initial data */ }; + err = vkCreatePipelineCache(_device, &pipelineCacheCreateInfo, nullptr, &cache); MAGNUM_VK_ASSERT_ERROR(err); + VkPipelineInputAssemblyStateCreateInfo inputAssemblyState = { + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, + nullptr, + 0, + VkPrimitiveTopology(_primitiveTopology), + 0 /* primitive restart enable */ + }; + + VkPipelineVertexInputStateCreateInfo vertexInputState = { + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, + nullptr, + 0, + _vertexInputBindings.size(), + _vertexInputBindings.data(), + _vertexInputAttrbutes.size(), + _vertexInputAttrbutes.data(), + }; + /* create pipeline itself */ VkPipelineDynamicStateCreateInfo dynamicState = { VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO, @@ -80,8 +99,8 @@ std::unique_ptr GraphicsPipelineBuilder::build() { pipelineInfo.pNext = nullptr; pipelineInfo.layout = layout; pipelineInfo.renderPass = *_renderPass; - pipelineInfo.pInputAssemblyState = &_inputAssemblyState; - pipelineInfo.pVertexInputState = &_vertexInputState; + pipelineInfo.pInputAssemblyState = &inputAssemblyState; + pipelineInfo.pVertexInputState = &vertexInputState; pipelineInfo.pRasterizationState = &_rasterizationState; pipelineInfo.pColorBlendState = &_colorBlendState; pipelineInfo.pMultisampleState = &_multisampleState; diff --git a/src/Magnum/Vk/Pipeline.h b/src/Magnum/Vk/Pipeline.h index d6c437336..b9e52d394 100644 --- a/src/Magnum/Vk/Pipeline.h +++ b/src/Magnum/Vk/Pipeline.h @@ -46,6 +46,8 @@ namespace Magnum { namespace Vk { +enum class Format: UnsignedInt; + class DescriptorSetLayout; enum class DynamicState: UnsignedInt { @@ -60,7 +62,7 @@ enum class DynamicState: UnsignedInt { StencilReference = VK_DYNAMIC_STATE_STENCIL_REFERENCE, }; -enum class Topology: UnsignedInt { +enum class PrimitiveTopology: UnsignedInt { PointList = VK_PRIMITIVE_TOPOLOGY_POINT_LIST, LineList = VK_PRIMITIVE_TOPOLOGY_LINE_LIST, LineStrip = VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, @@ -167,6 +169,13 @@ class MAGNUM_VK_EXPORT Pipeline { }; } + /** + * @brief The device this pipeline was created for. + */ + Device& device() { + return _device; + } + private: Device& _device; VkPipeline _pipeline; @@ -178,15 +187,8 @@ class MAGNUM_VK_EXPORT GraphicsPipelineBuilder { public: GraphicsPipelineBuilder(Device& device): - _device{device} { - - _inputAssemblyState = { - VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, - nullptr, - 0, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST, - 0 /* primitive restart enable */ - }; + _device{device}, + _primitiveTopology{PrimitiveTopology::TriangleList} { _multisampleState = { VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, nullptr, 0, @@ -257,38 +259,6 @@ class MAGNUM_VK_EXPORT GraphicsPipelineBuilder { nullptr }; - VkVertexInputBindingDescription bindingDesc; - bindingDesc.binding = 0; - bindingDesc.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; - bindingDesc.stride = sizeof(Vector3)*2; - - _vertexInputBindings.push_back(bindingDesc); - - VkVertexInputAttributeDescription attributeDesc[2]; - attributeDesc[0].binding = 0; - attributeDesc[0].location = 0; - attributeDesc[0].format = VK_FORMAT_R32G32B32_SFLOAT; - attributeDesc[0].offset = 0; - - _vertexInputAttrbutes.push_back(attributeDesc[0]); - - // Color - attributeDesc[1].binding = 0; - attributeDesc[1].location = 1; - attributeDesc[1].format = VK_FORMAT_R32G32B32_SFLOAT; - attributeDesc[1].offset = sizeof(Vector3); - - _vertexInputAttrbutes.push_back(attributeDesc[1]); - - _vertexInputState = { - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, - nullptr, - 0, - _vertexInputBindings.size(), - _vertexInputBindings.data(), - _vertexInputAttrbutes.size(), - _vertexInputAttrbutes.data(), - }; } /** @brief Copying is not allowed */ // TODO(squareys) probably should be, though @@ -332,7 +302,7 @@ class MAGNUM_VK_EXPORT GraphicsPipelineBuilder { return *this; } - GraphicsPipelineBuilder& setTopology(Topology topology) { + GraphicsPipelineBuilder& setTopology(PrimitiveTopology topology) { _inputAssemblyState.topology = VkPrimitiveTopology(topology); return *this; } @@ -347,12 +317,39 @@ class MAGNUM_VK_EXPORT GraphicsPipelineBuilder { return *this; } + GraphicsPipelineBuilder& addVertexInputBinding(UnsignedInt binding, UnsignedInt stride) { + VkVertexInputBindingDescription bindingDesc; + bindingDesc.binding = binding; + bindingDesc.inputRate = VK_VERTEX_INPUT_RATE_VERTEX; + bindingDesc.stride = stride; + + _vertexInputBindings.push_back(bindingDesc); + + return *this; + } + + GraphicsPipelineBuilder& addVertexAttributeDescription(UnsignedInt binding, UnsignedInt location, Format format, UnsignedInt offset = 0) { + VkVertexInputAttributeDescription attributeDesc; + attributeDesc.binding = binding; + attributeDesc.location = location; + attributeDesc.format = VkFormat(format); + attributeDesc.offset = offset; + + _vertexInputAttrbutes.push_back(attributeDesc); + + return *this; + } + + GraphicsPipelineBuilder& setPrimitiveTopology(PrimitiveTopology topology) { + _primitiveTopology = topology; + return *this; + } + private: Device& _device; VkGraphicsPipelineCreateInfo _createInfo; VkPipelineInputAssemblyStateCreateInfo _inputAssemblyState; - VkPipelineVertexInputStateCreateInfo _vertexInputState; VkPipelineRasterizationStateCreateInfo _rasterizationState; VkPipelineColorBlendStateCreateInfo _colorBlendState; VkPipelineMultisampleStateCreateInfo _multisampleState; @@ -366,6 +363,7 @@ class MAGNUM_VK_EXPORT GraphicsPipelineBuilder { std::vector _vertexInputAttrbutes; std::vector _pushConstantRanges; + PrimitiveTopology _primitiveTopology; RenderPass* _renderPass; std::vector _shaderStages; }; diff --git a/src/Magnum/Vk/Queue.h b/src/Magnum/Vk/Queue.h index 69dd423ef..fbefafe85 100644 --- a/src/Magnum/Vk/Queue.h +++ b/src/Magnum/Vk/Queue.h @@ -80,6 +80,13 @@ class MAGNUM_VK_EXPORT Queue { Queue& submit(const CommandBuffer& cmdBuffer); Queue& submit(const CommandBuffer& cmdBuffer, std::vector> waitSemaphores, std::vector> signalSemaphores); + /** + * @brief The device this queue was created for. + */ + Device& device() { + return _device; + } + private: VkQueue _queue; Device& _device;