Vk: Loads of improvements everywhere

Signed-off-by: Squareys <squareys@googlemail.com>

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

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<VkDeviceQueueCreateInfo>& requestedQueues,
+               const std::vector<const char*>& extensions, const std::vector<const char*>& 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,
+        requestedQueues.size(), requestedQueues.data(),
-        1, validationLayerNames,
+        validationLayers.size(), validationLayers.data(),
-        1, enabledExtensions,
+        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() {

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<VkDeviceQueueCreateInfo>& requestedQueues,
+               const std::vector<const char*>& extensions,
+               const std::vector<const char*>& 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<std::unique_ptr<Queue>> _queues;
 };
 
 }}

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š <mosra@centrum.cz>
+    Copyright © 2016 Jonathan Hale <squareys@googlemail.com>
+
+    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 <Corrade/Containers/EnumSet.h>
+
+#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

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;

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;

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 UnsignedInt numVertexBuffers = _vertexBuffers.size();
-            const int numIndices = _numIndices;
+            const UnsignedInt count = _count;
-            return [vertexBuffers, indexBuffer, numVertexBuffers, numIndices](VkCommandBuffer cmdBuffer){
+            const bool drawIndexed = _drawIndexed;
+            return [vertexBuffers, indexBuffer, numVertexBuffers, count, drawIndexed](VkCommandBuffer cmdBuffer){
                 VkDeviceSize offset = 0;
 
                 vkCmdBindVertexBuffers(cmdBuffer, 0, numVertexBuffers, vertexBuffers, &offset);
+
+                if(drawIndexed) {
                     vkCmdBindIndexBuffer(cmdBuffer, indexBuffer, 0, VK_INDEX_TYPE_UINT32);
 
-                vkCmdDrawIndexed(cmdBuffer, numIndices, 1, 0, 0, 1);
+                    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<VkBuffer> _vertexBuffers;
         VkBuffer _indexBuffer;
 
-        int _numIndices;
+        bool _drawIndexed;
+
+        UnsignedInt _count;
 };
 
 }}

src/Magnum/Vk/Pipeline.cpp

@@ -63,9 +63,28 @@ std::unique_ptr<Pipeline> 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<Pipeline> GraphicsPipelineBuilder::build() {
     pipelineInfo.pNext = nullptr;
     pipelineInfo.layout = layout;
     pipelineInfo.renderPass = *_renderPass;
-    pipelineInfo.pInputAssemblyState = &_inputAssemblyState;
+    pipelineInfo.pInputAssemblyState = &inputAssemblyState;
-    pipelineInfo.pVertexInputState = &_vertexInputState;
+    pipelineInfo.pVertexInputState = &vertexInputState;
     pipelineInfo.pRasterizationState = &_rasterizationState;
     pipelineInfo.pColorBlendState = &_colorBlendState;
     pipelineInfo.pMultisampleState = &_multisampleState;

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} {
+            _device{device},
-
+            _primitiveTopology{PrimitiveTopology::TriangleList} {
-            _inputAssemblyState = {
-                VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
-                nullptr,
-                0,
-                VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
-                0 /* primitive restart enable */
-            };
 
             _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<VkVertexInputAttributeDescription> _vertexInputAttrbutes;
         std::vector<VkPushConstantRange> _pushConstantRanges;
 
+        PrimitiveTopology _primitiveTopology;
         RenderPass* _renderPass;
         std::vector<VkPipelineShaderStageCreateInfo> _shaderStages;
 };

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<std::reference_wrapper<Semaphore>> waitSemaphores, std::vector<std::reference_wrapper<Semaphore>> signalSemaphores);
 
+        /**
+         * @brief The device this queue was created for.
+         */
+        Device& device() {
+            return _device;
+        }
+
     private:
         VkQueue _queue;
         Device& _device;