diff --git a/include/Nazara/Vulkan.hpp b/include/Nazara/Vulkan.hpp index 7a158c6f5..a19279f89 100644 --- a/include/Nazara/Vulkan.hpp +++ b/include/Nazara/Vulkan.hpp @@ -1,4 +1,4 @@ -// This file was automatically generated on 12 Jul 2016 at 17:44:44 +// This file was automatically generated on 20 Jul 2016 at 13:49:17 /* Nazara Engine - Vulkan @@ -35,6 +35,9 @@ #include #include #include +#include +#include +#include #include #include #include diff --git a/include/Nazara/Vulkan/VkCommandBuffer.hpp b/include/Nazara/Vulkan/VkCommandBuffer.hpp index 639373d45..0c7ff6a75 100644 --- a/include/Nazara/Vulkan/VkCommandBuffer.hpp +++ b/include/Nazara/Vulkan/VkCommandBuffer.hpp @@ -34,6 +34,9 @@ namespace Nz inline void BeginRenderPass(const VkRenderPassBeginInfo& beginInfo, VkSubpassContents contents = VK_SUBPASS_CONTENTS_INLINE); + inline void BindDescriptorSet(VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, UInt32 firstSet, const VkDescriptorSet& descriptorSets); + inline void BindDescriptorSets(VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, UInt32 firstSet, UInt32 descriptorSetCount, const VkDescriptorSet* descriptorSets); + inline void BindDescriptorSets(VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, UInt32 firstSet, UInt32 descriptorSetCount, const VkDescriptorSet* descriptorSets, UInt32 dynamicOffsetCount, const UInt32* dynamicOffsets); inline void BindIndexBuffer(VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); inline void BindPipeline(VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); inline void BindVertexBuffer(UInt32 binding, const VkBuffer buffer, const VkDeviceSize offset); diff --git a/include/Nazara/Vulkan/VkCommandBuffer.inl b/include/Nazara/Vulkan/VkCommandBuffer.inl index 11cb402b7..238113765 100644 --- a/include/Nazara/Vulkan/VkCommandBuffer.inl +++ b/include/Nazara/Vulkan/VkCommandBuffer.inl @@ -128,6 +128,21 @@ namespace Nz return m_pool->GetDevice()->vkCmdBeginRenderPass(m_handle, &beginInfo, contents); } + inline void CommandBuffer::BindDescriptorSet(VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, UInt32 firstSet, const VkDescriptorSet& descriptorSets) + { + return BindDescriptorSets(pipelineBindPoint, layout, firstSet, 1U, &descriptorSets); + } + + inline void CommandBuffer::BindDescriptorSets(VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, UInt32 firstSet, UInt32 descriptorSetCount, const VkDescriptorSet* descriptorSets) + { + return BindDescriptorSets(pipelineBindPoint, layout, firstSet, descriptorSetCount, descriptorSets, 0U, nullptr); + } + + inline void CommandBuffer::BindDescriptorSets(VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, UInt32 firstSet, UInt32 descriptorSetCount, const VkDescriptorSet* descriptorSets, UInt32 dynamicOffsetCount, const UInt32* dynamicOffsets) + { + return m_pool->GetDevice()->vkCmdBindDescriptorSets(m_handle, pipelineBindPoint, layout, firstSet, descriptorSetCount, descriptorSets, dynamicOffsetCount, dynamicOffsets); + } + inline void CommandBuffer::BindIndexBuffer(VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { return m_pool->GetDevice()->vkCmdBindIndexBuffer(m_handle, buffer, offset, indexType); diff --git a/include/Nazara/Vulkan/VkDescriptorPool.hpp b/include/Nazara/Vulkan/VkDescriptorPool.hpp new file mode 100644 index 000000000..f5f39d52d --- /dev/null +++ b/include/Nazara/Vulkan/VkDescriptorPool.hpp @@ -0,0 +1,52 @@ +// Copyright (C) 2016 Jérôme Leclercq +// This file is part of the "Nazara Engine - Vulkan" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_VULKAN_VKDESCRIPTORPOOL_HPP +#define NAZARA_VULKAN_VKDESCRIPTORPOOL_HPP + +#include +#include +#include + +namespace Nz +{ + namespace Vk + { + class DescriptorPool; + class DescriptorSet; + + using DescriptorPoolHandle = ObjectHandle; + + class NAZARA_VULKAN_API DescriptorPool : public DeviceObject, public HandledObject + { + friend DeviceObject; + + public: + DescriptorPool() = default; + DescriptorPool(const DescriptorPool&) = delete; + DescriptorPool(DescriptorPool&&) = default; + ~DescriptorPool() = default; + + DescriptorSet AllocateDescriptorSet(const VkDescriptorSetLayout& setLayouts); + std::vector AllocateDescriptorSets(UInt32 descriptorSetCount, const VkDescriptorSetLayout* setLayouts); + + using DeviceObject::Create; + inline bool Create(const DeviceHandle& device, UInt32 maxSets, const VkDescriptorPoolSize& poolSize, VkDescriptorPoolCreateFlags flags = 0, const VkAllocationCallbacks* allocator = nullptr); + inline bool Create(const DeviceHandle& device, UInt32 maxSets, UInt32 poolSizeCount, const VkDescriptorPoolSize* poolSize, VkDescriptorPoolCreateFlags flags = 0, const VkAllocationCallbacks* allocator = nullptr); + + DescriptorPool& operator=(const DescriptorPool&) = delete; + DescriptorPool& operator=(DescriptorPool&&) = delete; + + private: + static inline VkResult CreateHelper(const DeviceHandle& device, const VkDescriptorPoolCreateInfo* createInfo, const VkAllocationCallbacks* allocator, VkDescriptorPool* handle); + static inline void DestroyHelper(const DeviceHandle& device, VkDescriptorPool handle, const VkAllocationCallbacks* allocator); + }; + } +} + +#include + +#endif // NAZARA_VULKAN_VKDESCRIPTORPOOL_HPP diff --git a/include/Nazara/Vulkan/VkDescriptorPool.inl b/include/Nazara/Vulkan/VkDescriptorPool.inl new file mode 100644 index 000000000..7864a7b4a --- /dev/null +++ b/include/Nazara/Vulkan/VkDescriptorPool.inl @@ -0,0 +1,54 @@ +// Copyright (C) 2016 Jérôme Leclercq +// This file is part of the "Nazara Engine - Vulkan" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include + +namespace Nz +{ + namespace Vk + { + inline bool DescriptorPool::Create(const DeviceHandle& device, UInt32 maxSets, const VkDescriptorPoolSize& poolSize, VkDescriptorPoolCreateFlags flags, const VkAllocationCallbacks* allocator) + { + VkDescriptorPoolCreateInfo createInfo = + { + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // VkStructureType sType; + nullptr, // const void* pNext; + flags, // VkDescriptorPoolCreateFlags flags; + maxSets, // uint32_t maxSets; + 1U, // uint32_t poolSizeCount; + &poolSize // const VkDescriptorPoolSize* pPoolSizes; + }; + + return Create(device, createInfo, allocator); + } + + inline bool DescriptorPool::Create(const DeviceHandle& device, UInt32 maxSets, UInt32 poolSizeCount, const VkDescriptorPoolSize* poolSize, VkDescriptorPoolCreateFlags flags, const VkAllocationCallbacks* allocator) + { + VkDescriptorPoolCreateInfo createInfo = + { + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO, // VkStructureType sType; + nullptr, // const void* pNext; + flags, // VkDescriptorPoolCreateFlags flags; + maxSets, // uint32_t maxSets; + poolSizeCount, // uint32_t poolSizeCount; + poolSize // const VkDescriptorPoolSize* pPoolSizes; + }; + + return Create(device, createInfo, allocator); + } + + inline VkResult DescriptorPool::CreateHelper(const DeviceHandle& device, const VkDescriptorPoolCreateInfo* createInfo, const VkAllocationCallbacks* allocator, VkDescriptorPool* handle) + { + return device->vkCreateDescriptorPool(*device, createInfo, allocator, handle); + } + + inline void DescriptorPool::DestroyHelper(const DeviceHandle& device, VkDescriptorPool handle, const VkAllocationCallbacks* allocator) + { + return device->vkDestroyDescriptorPool(*device, handle, allocator); + } + } +} + +#include diff --git a/include/Nazara/Vulkan/VkDescriptorSet.hpp b/include/Nazara/Vulkan/VkDescriptorSet.hpp new file mode 100644 index 000000000..d3f30f0b2 --- /dev/null +++ b/include/Nazara/Vulkan/VkDescriptorSet.hpp @@ -0,0 +1,59 @@ +// Copyright (C) 2016 Jérôme Leclercq +// This file is part of the "Nazara Engine - Vulkan" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_VULKAN_VKDESCRIPTORSET_HPP +#define NAZARA_VULKAN_VKDESCRIPTORSET_HPP + +#include +#include +#include +#include + +namespace Nz +{ + namespace Vk + { + class DescriptorSet + { + friend DescriptorPool; + + public: + inline DescriptorSet(); + DescriptorSet(const DescriptorSet&) = delete; + inline DescriptorSet(DescriptorSet&& descriptorSet); + inline ~DescriptorSet(); + + inline void Free(); + + inline VkResult GetLastErrorCode() const; + + inline void WriteUniformDescriptor(UInt32 binding, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize range); + inline void WriteUniformDescriptor(UInt32 binding, const VkDescriptorBufferInfo& bufferInfo); + inline void WriteUniformDescriptor(UInt32 binding, UInt32 arrayElement, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize range); + inline void WriteUniformDescriptor(UInt32 binding, UInt32 arrayElement, const VkDescriptorBufferInfo& bufferInfo); + inline void WriteUniformDescriptors(UInt32 binding, UInt32 descriptorCount, const VkDescriptorBufferInfo* bufferInfo); + inline void WriteUniformDescriptors(UInt32 binding, UInt32 arrayElement, UInt32 descriptorCount, const VkDescriptorBufferInfo* bufferInfo); + + DescriptorSet& operator=(const DescriptorSet&) = delete; + DescriptorSet& operator=(DescriptorSet&& descriptorSet); + + inline operator VkDescriptorSet() const; + + private: + inline DescriptorSet(DescriptorPool& pool, VkDescriptorSet handle); + + DescriptorPoolHandle m_pool; + VkAllocationCallbacks m_allocator; + VkDescriptorSet m_handle; + VkResult m_lastErrorCode; + + }; + } +} + +#include + +#endif // NAZARA_VULKAN_VKDESCRIPTORSET_HPP diff --git a/include/Nazara/Vulkan/VkDescriptorSet.inl b/include/Nazara/Vulkan/VkDescriptorSet.inl new file mode 100644 index 000000000..73e7fae03 --- /dev/null +++ b/include/Nazara/Vulkan/VkDescriptorSet.inl @@ -0,0 +1,122 @@ +// Copyright (C) 2016 Jérôme Leclercq +// This file is part of the "Nazara Engine - Vulkan" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include +#include + +namespace Nz +{ + namespace Vk + { + inline DescriptorSet::DescriptorSet() : + m_pool(), + m_handle(VK_NULL_HANDLE) + { + } + + inline DescriptorSet::DescriptorSet(DescriptorPool& pool, VkDescriptorSet handle) : + m_pool(&pool), + m_handle(handle) + { + } + + inline DescriptorSet::DescriptorSet(DescriptorSet&& descriptorSet) : + m_pool(std::move(descriptorSet.m_pool)), + m_allocator(descriptorSet.m_allocator), + m_handle(descriptorSet.m_handle), + m_lastErrorCode(descriptorSet.m_lastErrorCode) + { + descriptorSet.m_handle = VK_NULL_HANDLE; + } + + inline DescriptorSet::~DescriptorSet() + { + Free(); + } + + inline void DescriptorSet::Free() + { + if (m_handle) + m_pool->GetDevice()->vkFreeDescriptorSets(*m_pool->GetDevice(), *m_pool, 1, &m_handle); + } + + inline VkResult DescriptorSet::GetLastErrorCode() const + { + return m_lastErrorCode; + } + + inline void DescriptorSet::WriteUniformDescriptor(UInt32 binding, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize range) + { + return WriteUniformDescriptor(binding, 0U, buffer, offset, range); + } + + inline void DescriptorSet::WriteUniformDescriptor(UInt32 binding, const VkDescriptorBufferInfo& bufferInfo) + { + return WriteUniformDescriptors(binding, 0U, 1U, &bufferInfo); + } + + inline void DescriptorSet::WriteUniformDescriptor(UInt32 binding, UInt32 arrayElement, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize range) + { + VkDescriptorBufferInfo bufferInfo = + { + buffer, // VkBuffer buffer; + offset, // VkDeviceSize offset; + range // VkDeviceSize range; + }; + + return WriteUniformDescriptor(binding, arrayElement, bufferInfo); + } + + inline void DescriptorSet::WriteUniformDescriptor(UInt32 binding, UInt32 arrayElement, const VkDescriptorBufferInfo& bufferInfo) + { + return WriteUniformDescriptors(binding, arrayElement, 1U, &bufferInfo); + } + + inline void DescriptorSet::WriteUniformDescriptors(UInt32 binding, UInt32 descriptorCount, const VkDescriptorBufferInfo* bufferInfo) + { + return WriteUniformDescriptors(binding, 0U, descriptorCount, bufferInfo); + } + + inline void DescriptorSet::WriteUniformDescriptors(UInt32 binding, UInt32 arrayElement, UInt32 descriptorCount, const VkDescriptorBufferInfo* bufferInfo) + { + VkWriteDescriptorSet writeDescriptorSet = + { + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET, // VkStructureType sType; + nullptr, // const void* pNext; + m_handle, // VkDescriptorSet dstSet; + binding, // uint32_t dstBinding; + arrayElement, // uint32_t dstArrayElement; + descriptorCount, // uint32_t descriptorCount; + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, // VkDescriptorType descriptorType; + nullptr, // const VkDescriptorImageInfo* pImageInfo; + bufferInfo, // const VkDescriptorBufferInfo* pBufferInfo; + nullptr // const VkBufferView* pTexelBufferView; + }; + + return m_pool->GetDevice()->vkUpdateDescriptorSets(*m_pool->GetDevice(), 1U, &writeDescriptorSet, 0U, nullptr); + } + + inline DescriptorSet& DescriptorSet::operator=(DescriptorSet&& descriptorSet) + { + m_allocator = descriptorSet.m_allocator; + m_handle = descriptorSet.m_handle; + m_lastErrorCode = descriptorSet.m_lastErrorCode; + m_pool = std::move(descriptorSet.m_pool); + m_handle = descriptorSet.m_handle; + + descriptorSet.m_handle = VK_NULL_HANDLE; + + return *this; + } + + inline DescriptorSet::operator VkDescriptorSet() const + { + return m_handle; + } + } +} + +#include diff --git a/include/Nazara/Vulkan/VkDescriptorSetLayout.hpp b/include/Nazara/Vulkan/VkDescriptorSetLayout.hpp new file mode 100644 index 000000000..b4cdb8427 --- /dev/null +++ b/include/Nazara/Vulkan/VkDescriptorSetLayout.hpp @@ -0,0 +1,43 @@ +// Copyright (C) 2016 Jérôme Leclercq +// This file is part of the "Nazara Engine - Vulkan" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#pragma once + +#ifndef NAZARA_VULKAN_VKDESCRIPTORSETLAYOUT_HPP +#define NAZARA_VULKAN_VKDESCRIPTORSETLAYOUT_HPP + +#include +#include + +namespace Nz +{ + namespace Vk + { + class DescriptorSetLayout : public DeviceObject + { + friend DeviceObject; + + public: + DescriptorSetLayout() = default; + DescriptorSetLayout(const DescriptorSetLayout&) = delete; + DescriptorSetLayout(DescriptorSetLayout&&) = default; + ~DescriptorSetLayout() = default; + + using DeviceObject::Create; + inline bool Create(const DeviceHandle& device, const VkDescriptorSetLayoutBinding& binding, VkDescriptorSetLayoutCreateFlags flags = 0, const VkAllocationCallbacks* allocator = nullptr); + inline bool Create(const DeviceHandle& device, UInt32 bindingCount, const VkDescriptorSetLayoutBinding* binding, VkDescriptorSetLayoutCreateFlags flags = 0, const VkAllocationCallbacks* allocator = nullptr); + + DescriptorSetLayout& operator=(const DescriptorSetLayout&) = delete; + DescriptorSetLayout& operator=(DescriptorSetLayout&&) = delete; + + private: + static inline VkResult CreateHelper(const DeviceHandle& device, const VkDescriptorSetLayoutCreateInfo* createInfo, const VkAllocationCallbacks* allocator, VkDescriptorSetLayout* handle); + static inline void DestroyHelper(const DeviceHandle& device, VkDescriptorSetLayout handle, const VkAllocationCallbacks* allocator); + }; + } +} + +#include + +#endif // NAZARA_VULKAN_VKDESCRIPTORSETLAYOUT_HPP diff --git a/include/Nazara/Vulkan/VkDescriptorSetLayout.inl b/include/Nazara/Vulkan/VkDescriptorSetLayout.inl new file mode 100644 index 000000000..1dde03e09 --- /dev/null +++ b/include/Nazara/Vulkan/VkDescriptorSetLayout.inl @@ -0,0 +1,43 @@ +// Copyright (C) 2016 Jérôme Leclercq +// This file is part of the "Nazara Engine - Vulkan" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include + +namespace Nz +{ + namespace Vk + { + inline bool DescriptorSetLayout::Create(const DeviceHandle& device, const VkDescriptorSetLayoutBinding& binding, VkDescriptorSetLayoutCreateFlags flags, const VkAllocationCallbacks* allocator) + { + return Create(device, 1U, &binding, flags, allocator); + } + + inline bool DescriptorSetLayout::Create(const DeviceHandle& device, UInt32 bindingCount, const VkDescriptorSetLayoutBinding* binding, VkDescriptorSetLayoutCreateFlags flags, const VkAllocationCallbacks* allocator) + { + VkDescriptorSetLayoutCreateInfo createInfo = + { + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO, // VkStructureType sType; + nullptr, // const void* pNext; + flags, // VkDescriptorSetLayoutCreateFlags flags; + bindingCount, // uint32_t bindingCount; + binding // const VkDescriptorSetLayoutBinding* pBindings; + }; + + return Create(device, createInfo, allocator); + } + + inline VkResult DescriptorSetLayout::CreateHelper(const DeviceHandle& device, const VkDescriptorSetLayoutCreateInfo* createInfo, const VkAllocationCallbacks* allocator, VkDescriptorSetLayout* handle) + { + return device->vkCreateDescriptorSetLayout(*device, createInfo, allocator, handle); + } + + inline void DescriptorSetLayout::DestroyHelper(const DeviceHandle& device, VkDescriptorSetLayout handle, const VkAllocationCallbacks* allocator) + { + return device->vkDestroyDescriptorSetLayout(*device, handle, allocator); + } + } +} + +#include diff --git a/include/Nazara/Vulkan/VkDevice.hpp b/include/Nazara/Vulkan/VkDevice.hpp index c9044fb1c..4fc7c7da2 100644 --- a/include/Nazara/Vulkan/VkDevice.hpp +++ b/include/Nazara/Vulkan/VkDevice.hpp @@ -63,6 +63,7 @@ namespace Nz // Vulkan core NAZARA_VULKAN_DEVICE_FUNCTION(vkAllocateCommandBuffers); + NAZARA_VULKAN_DEVICE_FUNCTION(vkAllocateDescriptorSets); NAZARA_VULKAN_DEVICE_FUNCTION(vkAllocateMemory); NAZARA_VULKAN_DEVICE_FUNCTION(vkBeginCommandBuffer); NAZARA_VULKAN_DEVICE_FUNCTION(vkBindBufferMemory); diff --git a/src/Nazara/Vulkan/VkDescriptorPool.cpp b/src/Nazara/Vulkan/VkDescriptorPool.cpp new file mode 100644 index 000000000..73e7325e3 --- /dev/null +++ b/src/Nazara/Vulkan/VkDescriptorPool.cpp @@ -0,0 +1,53 @@ +// Copyright (C) 2016 Jérôme Leclercq +// This file is part of the "Nazara Engine - Vulkan" +// For conditions of distribution and use, see copyright notice in Config.hpp + +#include +#include +#include + +namespace Nz +{ + namespace Vk + { + DescriptorSet DescriptorPool::AllocateDescriptorSet(const VkDescriptorSetLayout& setLayouts) + { + VkDescriptorSetAllocateInfo createInfo = + { + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType; + nullptr, // const void* pNext; + m_handle, // VkDescriptorPool descriptorPool; + 1U, // uint32_t descriptorSetCount; + &setLayouts // const VkDescriptorSetLayout* pSetLayouts; + }; + + VkDescriptorSet handle = VK_NULL_HANDLE; + m_lastErrorCode = m_device->vkAllocateDescriptorSets(*m_device, &createInfo, &handle); + + return DescriptorSet(*this, handle); + } + + std::vector DescriptorPool::AllocateDescriptorSets(UInt32 descriptorSetCount, const VkDescriptorSetLayout* setLayouts) + { + VkDescriptorSetAllocateInfo createInfo = + { + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType; + nullptr, // const void* pNext; + m_handle, // VkDescriptorPool descriptorPool; + descriptorSetCount, // uint32_t descriptorSetCount; + setLayouts // const VkDescriptorSetLayout* pSetLayouts; + }; + + std::vector handles(descriptorSetCount, VK_NULL_HANDLE); + m_lastErrorCode = m_device->vkAllocateDescriptorSets(*m_device, &createInfo, handles.data()); + if (m_lastErrorCode != VkResult::VK_SUCCESS) + return std::vector(); + + std::vector descriptorSets; + for (UInt32 i = 0; i < descriptorSetCount; ++i) + descriptorSets.emplace_back(DescriptorSet(*this, handles[i])); + + return descriptorSets; + } + } +} diff --git a/src/Nazara/Vulkan/VkDevice.cpp b/src/Nazara/Vulkan/VkDevice.cpp index 9ecbf57de..3f82f503e 100644 --- a/src/Nazara/Vulkan/VkDevice.cpp +++ b/src/Nazara/Vulkan/VkDevice.cpp @@ -50,6 +50,7 @@ namespace Nz ErrorFlags flags(ErrorFlag_ThrowException, true); NAZARA_VULKAN_LOAD_DEVICE(vkAllocateCommandBuffers); + NAZARA_VULKAN_LOAD_DEVICE(vkAllocateDescriptorSets); NAZARA_VULKAN_LOAD_DEVICE(vkAllocateMemory); NAZARA_VULKAN_LOAD_DEVICE(vkBeginCommandBuffer); NAZARA_VULKAN_LOAD_DEVICE(vkBindBufferMemory);