Vk: Loads of improvements everywhere

Signed-off-by: Squareys <squareys@googlemail.com>
10 years ago · 4e1b17067c
10 changed files with 370 additions and 68 deletions
--- 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
--- 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<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,
-        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() {
--- 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<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;
 };

 }}
--- a/src/Magnum/Vk/Format.h
+++ 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š <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
--- 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;
--- 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;
--- 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<VkBuffer> _vertexBuffers;
        VkBuffer _indexBuffer;

-        int _numIndices;
+        bool _drawIndexed;
+
+        UnsignedInt _count;
 };

 }}
--- a/src/Magnum/Vk/Pipeline.cpp
+++ b/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.pVertexInputState = &_vertexInputState;
+    pipelineInfo.pInputAssemblyState = &inputAssemblyState;
+    pipelineInfo.pVertexInputState = &vertexInputState;
    pipelineInfo.pRasterizationState = &_rasterizationState;
    pipelineInfo.pColorBlendState = &_colorBlendState;
    pipelineInfo.pMultisampleState = &_multisampleState;
--- 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<VkVertexInputAttributeDescription> _vertexInputAttrbutes;
        std::vector<VkPushConstantRange> _pushConstantRanges;

+        PrimitiveTopology _primitiveTopology;
        RenderPass* _renderPass;
        std::vector<VkPipelineShaderStageCreateInfo> _shaderStages;
 };
--- 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<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;