From 4019e9c88580bc9a8124ffdcba67a5092bfeac6a Mon Sep 17 00:00:00 2001 From: Alejandro Saucedo Date: Fri, 31 Jul 2020 06:42:45 +0100 Subject: [PATCH] Initial upgrade --- src/VulkanInitializers.hpp | 428 +++++++++++++++---------------------- src/VulkanTools.cpp | 171 ++++++--------- src/VulkanTools.h | 113 +++++----- src/main.cpp | 24 ++- 4 files changed, 305 insertions(+), 431 deletions(-) diff --git a/src/VulkanInitializers.hpp b/src/VulkanInitializers.hpp index 81a2621b5..aca24ed2f 100644 --- a/src/VulkanInitializers.hpp +++ b/src/VulkanInitializers.hpp @@ -11,78 +11,63 @@ #pragma once -#include "vulkan/vulkan.h" #include +#include "vulkan/vulkan.h" namespace vks { namespace initializers { -inline VkMemoryAllocateInfo -memoryAllocateInfo() -{ +inline VkMemoryAllocateInfo memoryAllocateInfo() { VkMemoryAllocateInfo memAllocInfo{}; memAllocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; return memAllocInfo; } -inline VkMappedMemoryRange -mappedMemoryRange() -{ +inline VkMappedMemoryRange mappedMemoryRange() { VkMappedMemoryRange mappedMemoryRange{}; mappedMemoryRange.sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE; return mappedMemoryRange; } -inline VkCommandBufferAllocateInfo -commandBufferAllocateInfo(VkCommandPool commandPool, - VkCommandBufferLevel level, - uint32_t bufferCount) -{ +inline VkCommandBufferAllocateInfo commandBufferAllocateInfo( + VkCommandPool commandPool, + VkCommandBufferLevel level, + uint32_t bufferCount) { VkCommandBufferAllocateInfo commandBufferAllocateInfo{}; commandBufferAllocateInfo.sType = - VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; commandBufferAllocateInfo.commandPool = commandPool; commandBufferAllocateInfo.level = level; commandBufferAllocateInfo.commandBufferCount = bufferCount; return commandBufferAllocateInfo; } -inline VkCommandPoolCreateInfo -commandPoolCreateInfo() -{ +inline VkCommandPoolCreateInfo commandPoolCreateInfo() { VkCommandPoolCreateInfo cmdPoolCreateInfo{}; cmdPoolCreateInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; return cmdPoolCreateInfo; } -inline VkCommandBufferBeginInfo -commandBufferBeginInfo() -{ +inline VkCommandBufferBeginInfo commandBufferBeginInfo() { VkCommandBufferBeginInfo cmdBufferBeginInfo{}; cmdBufferBeginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; return cmdBufferBeginInfo; } -inline VkCommandBufferInheritanceInfo -commandBufferInheritanceInfo() -{ +inline VkCommandBufferInheritanceInfo commandBufferInheritanceInfo() { VkCommandBufferInheritanceInfo cmdBufferInheritanceInfo{}; cmdBufferInheritanceInfo.sType = - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO; return cmdBufferInheritanceInfo; } -inline VkRenderPassBeginInfo -renderPassBeginInfo() -{ +inline VkRenderPassBeginInfo renderPassBeginInfo() { VkRenderPassBeginInfo renderPassBeginInfo{}; renderPassBeginInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO; return renderPassBeginInfo; } -inline VkRenderPassCreateInfo -renderPassCreateInfo() -{ +inline VkRenderPassCreateInfo renderPassCreateInfo() { VkRenderPassCreateInfo renderPassCreateInfo{}; renderPassCreateInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; return renderPassCreateInfo; @@ -90,9 +75,7 @@ renderPassCreateInfo() /** @brief Initialize an image memory barrier with no image transfer ownership */ -inline VkImageMemoryBarrier -imageMemoryBarrier() -{ +inline VkImageMemoryBarrier imageMemoryBarrier() { VkImageMemoryBarrier imageMemoryBarrier{}; imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; imageMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; @@ -102,9 +85,7 @@ imageMemoryBarrier() /** @brief Initialize a buffer memory barrier with no image transfer ownership */ -inline VkBufferMemoryBarrier -bufferMemoryBarrier() -{ +inline VkBufferMemoryBarrier bufferMemoryBarrier() { VkBufferMemoryBarrier bufferMemoryBarrier{}; bufferMemoryBarrier.sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER; bufferMemoryBarrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; @@ -112,83 +93,66 @@ bufferMemoryBarrier() return bufferMemoryBarrier; } -inline VkMemoryBarrier -memoryBarrier() -{ +inline VkMemoryBarrier memoryBarrier() { VkMemoryBarrier memoryBarrier{}; memoryBarrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; return memoryBarrier; } -inline VkImageCreateInfo -imageCreateInfo() -{ +inline VkImageCreateInfo imageCreateInfo() { VkImageCreateInfo imageCreateInfo{}; imageCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; return imageCreateInfo; } -inline VkSamplerCreateInfo -samplerCreateInfo() -{ +inline VkSamplerCreateInfo samplerCreateInfo() { VkSamplerCreateInfo samplerCreateInfo{}; samplerCreateInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; samplerCreateInfo.maxAnisotropy = 1.0f; return samplerCreateInfo; } -inline VkImageViewCreateInfo -imageViewCreateInfo() -{ +inline VkImageViewCreateInfo imageViewCreateInfo() { VkImageViewCreateInfo imageViewCreateInfo{}; imageViewCreateInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; return imageViewCreateInfo; } -inline VkFramebufferCreateInfo -framebufferCreateInfo() -{ +inline VkFramebufferCreateInfo framebufferCreateInfo() { VkFramebufferCreateInfo framebufferCreateInfo{}; framebufferCreateInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; return framebufferCreateInfo; } -inline VkSemaphoreCreateInfo -semaphoreCreateInfo() -{ +inline VkSemaphoreCreateInfo semaphoreCreateInfo() { VkSemaphoreCreateInfo semaphoreCreateInfo{}; semaphoreCreateInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; return semaphoreCreateInfo; } -inline VkFenceCreateInfo -fenceCreateInfo(VkFenceCreateFlags flags = 0) -{ +inline VkFenceCreateInfo fenceCreateInfo(VkFenceCreateFlags flags = 0) { VkFenceCreateInfo fenceCreateInfo{}; fenceCreateInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; fenceCreateInfo.flags = flags; return fenceCreateInfo; } -inline VkEventCreateInfo -eventCreateInfo() -{ +inline VkEventCreateInfo eventCreateInfo() { VkEventCreateInfo eventCreateInfo{}; eventCreateInfo.sType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO; return eventCreateInfo; } -inline VkSubmitInfo -submitInfo() -{ +inline VkSubmitInfo submitInfo() { VkSubmitInfo submitInfo{}; submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; return submitInfo; } -inline VkViewport -viewport(float width, float height, float minDepth, float maxDepth) -{ +inline VkViewport viewport(float width, + float height, + float minDepth, + float maxDepth) { VkViewport viewport{}; viewport.width = width; viewport.height = height; @@ -197,9 +161,10 @@ viewport(float width, float height, float minDepth, float maxDepth) return viewport; } -inline VkRect2D -rect2D(int32_t width, int32_t height, int32_t offsetX, int32_t offsetY) -{ +inline VkRect2D rect2D(int32_t width, + int32_t height, + int32_t offsetX, + int32_t offsetY) { VkRect2D rect2D{}; rect2D.extent.width = width; rect2D.extent.height = height; @@ -208,17 +173,14 @@ rect2D(int32_t width, int32_t height, int32_t offsetX, int32_t offsetY) return rect2D; } -inline VkBufferCreateInfo -bufferCreateInfo() -{ +inline VkBufferCreateInfo bufferCreateInfo() { VkBufferCreateInfo bufCreateInfo{}; bufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; return bufCreateInfo; } -inline VkBufferCreateInfo -bufferCreateInfo(VkBufferUsageFlags usage, VkDeviceSize size) -{ +inline VkBufferCreateInfo bufferCreateInfo(VkBufferUsageFlags usage, + VkDeviceSize size) { VkBufferCreateInfo bufCreateInfo{}; bufCreateInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; bufCreateInfo.usage = usage; @@ -226,11 +188,10 @@ bufferCreateInfo(VkBufferUsageFlags usage, VkDeviceSize size) return bufCreateInfo; } -inline VkDescriptorPoolCreateInfo -descriptorPoolCreateInfo(uint32_t poolSizeCount, - VkDescriptorPoolSize* pPoolSizes, - uint32_t maxSets) -{ +inline VkDescriptorPoolCreateInfo descriptorPoolCreateInfo( + uint32_t poolSizeCount, + VkDescriptorPoolSize* pPoolSizes, + uint32_t maxSets) { VkDescriptorPoolCreateInfo descriptorPoolInfo{}; descriptorPoolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; descriptorPoolInfo.poolSizeCount = poolSizeCount; @@ -239,10 +200,9 @@ descriptorPoolCreateInfo(uint32_t poolSizeCount, return descriptorPoolInfo; } -inline VkDescriptorPoolCreateInfo -descriptorPoolCreateInfo(const std::vector& poolSizes, - uint32_t maxSets) -{ +inline VkDescriptorPoolCreateInfo descriptorPoolCreateInfo( + const std::vector& poolSizes, + uint32_t maxSets) { VkDescriptorPoolCreateInfo descriptorPoolInfo{}; descriptorPoolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; descriptorPoolInfo.poolSizeCount = static_cast(poolSizes.size()); @@ -251,21 +211,19 @@ descriptorPoolCreateInfo(const std::vector& poolSizes, return descriptorPoolInfo; } -inline VkDescriptorPoolSize -descriptorPoolSize(VkDescriptorType type, uint32_t descriptorCount) -{ +inline VkDescriptorPoolSize descriptorPoolSize(VkDescriptorType type, + uint32_t descriptorCount) { VkDescriptorPoolSize descriptorPoolSize{}; descriptorPoolSize.type = type; descriptorPoolSize.descriptorCount = descriptorCount; return descriptorPoolSize; } -inline VkDescriptorSetLayoutBinding -descriptorSetLayoutBinding(VkDescriptorType type, - VkShaderStageFlags stageFlags, - uint32_t binding, - uint32_t descriptorCount = 1) -{ +inline VkDescriptorSetLayoutBinding descriptorSetLayoutBinding( + VkDescriptorType type, + VkShaderStageFlags stageFlags, + uint32_t binding, + uint32_t descriptorCount = 1) { VkDescriptorSetLayoutBinding setLayoutBinding{}; setLayoutBinding.descriptorType = type; setLayoutBinding.stageFlags = stageFlags; @@ -274,72 +232,64 @@ descriptorSetLayoutBinding(VkDescriptorType type, return setLayoutBinding; } -inline VkDescriptorSetLayoutCreateInfo -descriptorSetLayoutCreateInfo(const VkDescriptorSetLayoutBinding* pBindings, - uint32_t bindingCount) -{ +inline VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo( + const VkDescriptorSetLayoutBinding* pBindings, + uint32_t bindingCount) { VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo{}; descriptorSetLayoutCreateInfo.sType = - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; descriptorSetLayoutCreateInfo.pBindings = pBindings; descriptorSetLayoutCreateInfo.bindingCount = bindingCount; return descriptorSetLayoutCreateInfo; } -inline VkDescriptorSetLayoutCreateInfo -descriptorSetLayoutCreateInfo( - const std::vector& bindings) -{ +inline VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo( + const std::vector& bindings) { VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo{}; descriptorSetLayoutCreateInfo.sType = - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; descriptorSetLayoutCreateInfo.pBindings = bindings.data(); descriptorSetLayoutCreateInfo.bindingCount = - static_cast(bindings.size()); + static_cast(bindings.size()); return descriptorSetLayoutCreateInfo; } -inline VkPipelineLayoutCreateInfo -pipelineLayoutCreateInfo(const VkDescriptorSetLayout* pSetLayouts, - uint32_t setLayoutCount = 1) -{ +inline VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo( + const VkDescriptorSetLayout* pSetLayouts, + uint32_t setLayoutCount = 1) { VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo{}; pipelineLayoutCreateInfo.sType = - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipelineLayoutCreateInfo.setLayoutCount = setLayoutCount; pipelineLayoutCreateInfo.pSetLayouts = pSetLayouts; return pipelineLayoutCreateInfo; } -inline VkPipelineLayoutCreateInfo -pipelineLayoutCreateInfo(uint32_t setLayoutCount = 1) -{ +inline VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo( + uint32_t setLayoutCount = 1) { VkPipelineLayoutCreateInfo pipelineLayoutCreateInfo{}; pipelineLayoutCreateInfo.sType = - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; pipelineLayoutCreateInfo.setLayoutCount = setLayoutCount; return pipelineLayoutCreateInfo; } -inline VkDescriptorSetAllocateInfo -descriptorSetAllocateInfo(VkDescriptorPool descriptorPool, - const VkDescriptorSetLayout* pSetLayouts, - uint32_t descriptorSetCount) -{ +inline VkDescriptorSetAllocateInfo descriptorSetAllocateInfo( + VkDescriptorPool descriptorPool, + const VkDescriptorSetLayout* pSetLayouts, + uint32_t descriptorSetCount) { VkDescriptorSetAllocateInfo descriptorSetAllocateInfo{}; descriptorSetAllocateInfo.sType = - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; descriptorSetAllocateInfo.descriptorPool = descriptorPool; descriptorSetAllocateInfo.pSetLayouts = pSetLayouts; descriptorSetAllocateInfo.descriptorSetCount = descriptorSetCount; return descriptorSetAllocateInfo; } -inline VkDescriptorImageInfo -descriptorImageInfo(VkSampler sampler, - VkImageView imageView, - VkImageLayout imageLayout) -{ +inline VkDescriptorImageInfo descriptorImageInfo(VkSampler sampler, + VkImageView imageView, + VkImageLayout imageLayout) { VkDescriptorImageInfo descriptorImageInfo{}; descriptorImageInfo.sampler = sampler; descriptorImageInfo.imageView = imageView; @@ -347,13 +297,12 @@ descriptorImageInfo(VkSampler sampler, return descriptorImageInfo; } -inline VkWriteDescriptorSet -writeDescriptorSet(VkDescriptorSet dstSet, - VkDescriptorType type, - uint32_t binding, - VkDescriptorBufferInfo* bufferInfo, - uint32_t descriptorCount = 1) -{ +inline VkWriteDescriptorSet writeDescriptorSet( + VkDescriptorSet dstSet, + VkDescriptorType type, + uint32_t binding, + VkDescriptorBufferInfo* bufferInfo, + uint32_t descriptorCount = 1) { VkWriteDescriptorSet writeDescriptorSet{}; writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; writeDescriptorSet.dstSet = dstSet; @@ -364,13 +313,11 @@ writeDescriptorSet(VkDescriptorSet dstSet, return writeDescriptorSet; } -inline VkWriteDescriptorSet -writeDescriptorSet(VkDescriptorSet dstSet, - VkDescriptorType type, - uint32_t binding, - VkDescriptorImageInfo* imageInfo, - uint32_t descriptorCount = 1) -{ +inline VkWriteDescriptorSet writeDescriptorSet(VkDescriptorSet dstSet, + VkDescriptorType type, + uint32_t binding, + VkDescriptorImageInfo* imageInfo, + uint32_t descriptorCount = 1) { VkWriteDescriptorSet writeDescriptorSet{}; writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; writeDescriptorSet.dstSet = dstSet; @@ -381,11 +328,10 @@ writeDescriptorSet(VkDescriptorSet dstSet, return writeDescriptorSet; } -inline VkVertexInputBindingDescription -vertexInputBindingDescription(uint32_t binding, - uint32_t stride, - VkVertexInputRate inputRate) -{ +inline VkVertexInputBindingDescription vertexInputBindingDescription( + uint32_t binding, + uint32_t stride, + VkVertexInputRate inputRate) { VkVertexInputBindingDescription vInputBindDescription{}; vInputBindDescription.binding = binding; vInputBindDescription.stride = stride; @@ -393,12 +339,11 @@ vertexInputBindingDescription(uint32_t binding, return vInputBindDescription; } -inline VkVertexInputAttributeDescription -vertexInputAttributeDescription(uint32_t binding, - uint32_t location, - VkFormat format, - uint32_t offset) -{ +inline VkVertexInputAttributeDescription vertexInputAttributeDescription( + uint32_t binding, + uint32_t location, + VkFormat format, + uint32_t offset) { VkVertexInputAttributeDescription vInputAttribDescription{}; vInputAttribDescription.location = location; vInputAttribDescription.binding = binding; @@ -408,62 +353,58 @@ vertexInputAttributeDescription(uint32_t binding, } inline VkPipelineVertexInputStateCreateInfo -pipelineVertexInputStateCreateInfo() -{ +pipelineVertexInputStateCreateInfo() { VkPipelineVertexInputStateCreateInfo pipelineVertexInputStateCreateInfo{}; pipelineVertexInputStateCreateInfo.sType = - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; return pipelineVertexInputStateCreateInfo; } -inline VkPipelineVertexInputStateCreateInfo -pipelineVertexInputStateCreateInfo( - const std::vector& vertexBindingDescriptions, - const std::vector& - vertexAttributeDescriptions) -{ +inline VkPipelineVertexInputStateCreateInfo pipelineVertexInputStateCreateInfo( + const std::vector& + vertexBindingDescriptions, + const std::vector& + vertexAttributeDescriptions) { VkPipelineVertexInputStateCreateInfo pipelineVertexInputStateCreateInfo{}; pipelineVertexInputStateCreateInfo.sType = - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; pipelineVertexInputStateCreateInfo.vertexBindingDescriptionCount = - static_cast(vertexBindingDescriptions.size()); + static_cast(vertexBindingDescriptions.size()); pipelineVertexInputStateCreateInfo.pVertexBindingDescriptions = - vertexBindingDescriptions.data(); + vertexBindingDescriptions.data(); pipelineVertexInputStateCreateInfo.vertexAttributeDescriptionCount = - static_cast(vertexAttributeDescriptions.size()); + static_cast(vertexAttributeDescriptions.size()); pipelineVertexInputStateCreateInfo.pVertexAttributeDescriptions = - vertexAttributeDescriptions.data(); + vertexAttributeDescriptions.data(); return pipelineVertexInputStateCreateInfo; } inline VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateCreateInfo( - VkPrimitiveTopology topology, - VkPipelineInputAssemblyStateCreateFlags flags, - VkBool32 primitiveRestartEnable) -{ + VkPrimitiveTopology topology, + VkPipelineInputAssemblyStateCreateFlags flags, + VkBool32 primitiveRestartEnable) { VkPipelineInputAssemblyStateCreateInfo - pipelineInputAssemblyStateCreateInfo{}; + pipelineInputAssemblyStateCreateInfo{}; pipelineInputAssemblyStateCreateInfo.sType = - VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; pipelineInputAssemblyStateCreateInfo.topology = topology; pipelineInputAssemblyStateCreateInfo.flags = flags; pipelineInputAssemblyStateCreateInfo.primitiveRestartEnable = - primitiveRestartEnable; + primitiveRestartEnable; return pipelineInputAssemblyStateCreateInfo; } inline VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateCreateInfo( - VkPolygonMode polygonMode, - VkCullModeFlags cullMode, - VkFrontFace frontFace, - VkPipelineRasterizationStateCreateFlags flags = 0) -{ + VkPolygonMode polygonMode, + VkCullModeFlags cullMode, + VkFrontFace frontFace, + VkPipelineRasterizationStateCreateFlags flags = 0) { VkPipelineRasterizationStateCreateInfo - pipelineRasterizationStateCreateInfo{}; + pipelineRasterizationStateCreateInfo{}; pipelineRasterizationStateCreateInfo.sType = - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; pipelineRasterizationStateCreateInfo.polygonMode = polygonMode; pipelineRasterizationStateCreateInfo.cullMode = cullMode; pipelineRasterizationStateCreateInfo.frontFace = frontFace; @@ -473,24 +414,21 @@ pipelineRasterizationStateCreateInfo( return pipelineRasterizationStateCreateInfo; } -inline VkPipelineColorBlendAttachmentState -pipelineColorBlendAttachmentState(VkColorComponentFlags colorWriteMask, - VkBool32 blendEnable) -{ +inline VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState( + VkColorComponentFlags colorWriteMask, + VkBool32 blendEnable) { VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState{}; pipelineColorBlendAttachmentState.colorWriteMask = colorWriteMask; pipelineColorBlendAttachmentState.blendEnable = blendEnable; return pipelineColorBlendAttachmentState; } -inline VkPipelineColorBlendStateCreateInfo -pipelineColorBlendStateCreateInfo( - uint32_t attachmentCount, - const VkPipelineColorBlendAttachmentState* pAttachments) -{ +inline VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateCreateInfo( + uint32_t attachmentCount, + const VkPipelineColorBlendAttachmentState* pAttachments) { VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateCreateInfo{}; pipelineColorBlendStateCreateInfo.sType = - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; pipelineColorBlendStateCreateInfo.attachmentCount = attachmentCount; pipelineColorBlendStateCreateInfo.pAttachments = pAttachments; return pipelineColorBlendStateCreateInfo; @@ -499,11 +437,10 @@ pipelineColorBlendStateCreateInfo( inline VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateCreateInfo(VkBool32 depthTestEnable, VkBool32 depthWriteEnable, - VkCompareOp depthCompareOp) -{ + VkCompareOp depthCompareOp) { VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateCreateInfo{}; pipelineDepthStencilStateCreateInfo.sType = - VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO; pipelineDepthStencilStateCreateInfo.depthTestEnable = depthTestEnable; pipelineDepthStencilStateCreateInfo.depthWriteEnable = depthWriteEnable; pipelineDepthStencilStateCreateInfo.depthCompareOp = depthCompareOp; @@ -511,78 +448,70 @@ pipelineDepthStencilStateCreateInfo(VkBool32 depthTestEnable, return pipelineDepthStencilStateCreateInfo; } -inline VkPipelineViewportStateCreateInfo -pipelineViewportStateCreateInfo(uint32_t viewportCount, - uint32_t scissorCount, - VkPipelineViewportStateCreateFlags flags = 0) -{ +inline VkPipelineViewportStateCreateInfo pipelineViewportStateCreateInfo( + uint32_t viewportCount, + uint32_t scissorCount, + VkPipelineViewportStateCreateFlags flags = 0) { VkPipelineViewportStateCreateInfo pipelineViewportStateCreateInfo{}; pipelineViewportStateCreateInfo.sType = - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; pipelineViewportStateCreateInfo.viewportCount = viewportCount; pipelineViewportStateCreateInfo.scissorCount = scissorCount; pipelineViewportStateCreateInfo.flags = flags; return pipelineViewportStateCreateInfo; } -inline VkPipelineMultisampleStateCreateInfo -pipelineMultisampleStateCreateInfo( - VkSampleCountFlagBits rasterizationSamples, - VkPipelineMultisampleStateCreateFlags flags = 0) -{ +inline VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo( + VkSampleCountFlagBits rasterizationSamples, + VkPipelineMultisampleStateCreateFlags flags = 0) { VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateCreateInfo{}; pipelineMultisampleStateCreateInfo.sType = - VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; pipelineMultisampleStateCreateInfo.rasterizationSamples = - rasterizationSamples; + rasterizationSamples; pipelineMultisampleStateCreateInfo.flags = flags; return pipelineMultisampleStateCreateInfo; } -inline VkPipelineDynamicStateCreateInfo -pipelineDynamicStateCreateInfo(const VkDynamicState* pDynamicStates, - uint32_t dynamicStateCount, - VkPipelineDynamicStateCreateFlags flags = 0) -{ +inline VkPipelineDynamicStateCreateInfo pipelineDynamicStateCreateInfo( + const VkDynamicState* pDynamicStates, + uint32_t dynamicStateCount, + VkPipelineDynamicStateCreateFlags flags = 0) { VkPipelineDynamicStateCreateInfo pipelineDynamicStateCreateInfo{}; pipelineDynamicStateCreateInfo.sType = - VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; pipelineDynamicStateCreateInfo.pDynamicStates = pDynamicStates; pipelineDynamicStateCreateInfo.dynamicStateCount = dynamicStateCount; pipelineDynamicStateCreateInfo.flags = flags; return pipelineDynamicStateCreateInfo; } -inline VkPipelineDynamicStateCreateInfo -pipelineDynamicStateCreateInfo( - const std::vector& pDynamicStates, - VkPipelineDynamicStateCreateFlags flags = 0) -{ +inline VkPipelineDynamicStateCreateInfo pipelineDynamicStateCreateInfo( + const std::vector& pDynamicStates, + VkPipelineDynamicStateCreateFlags flags = 0) { VkPipelineDynamicStateCreateInfo pipelineDynamicStateCreateInfo{}; pipelineDynamicStateCreateInfo.sType = - VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; pipelineDynamicStateCreateInfo.pDynamicStates = pDynamicStates.data(); pipelineDynamicStateCreateInfo.dynamicStateCount = - static_cast(pDynamicStates.size()); + static_cast(pDynamicStates.size()); pipelineDynamicStateCreateInfo.flags = flags; return pipelineDynamicStateCreateInfo; } inline VkPipelineTessellationStateCreateInfo -pipelineTessellationStateCreateInfo(uint32_t patchControlPoints) -{ +pipelineTessellationStateCreateInfo(uint32_t patchControlPoints) { VkPipelineTessellationStateCreateInfo pipelineTessellationStateCreateInfo{}; pipelineTessellationStateCreateInfo.sType = - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO; pipelineTessellationStateCreateInfo.patchControlPoints = patchControlPoints; return pipelineTessellationStateCreateInfo; } -inline VkGraphicsPipelineCreateInfo -pipelineCreateInfo(VkPipelineLayout layout, - VkRenderPass renderPass, - VkPipelineCreateFlags flags = 0) -{ +inline VkGraphicsPipelineCreateInfo pipelineCreateInfo( + VkPipelineLayout layout, + VkRenderPass renderPass, + VkPipelineCreateFlags flags = 0) { VkGraphicsPipelineCreateInfo pipelineCreateInfo{}; pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineCreateInfo.layout = layout; @@ -593,9 +522,7 @@ pipelineCreateInfo(VkPipelineLayout layout, return pipelineCreateInfo; } -inline VkGraphicsPipelineCreateInfo -pipelineCreateInfo() -{ +inline VkGraphicsPipelineCreateInfo pipelineCreateInfo() { VkGraphicsPipelineCreateInfo pipelineCreateInfo{}; pipelineCreateInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; pipelineCreateInfo.basePipelineIndex = -1; @@ -603,21 +530,20 @@ pipelineCreateInfo() return pipelineCreateInfo; } -inline VkComputePipelineCreateInfo -computePipelineCreateInfo(VkPipelineLayout layout, - VkPipelineCreateFlags flags = 0) -{ +inline VkComputePipelineCreateInfo computePipelineCreateInfo( + VkPipelineLayout layout, + VkPipelineCreateFlags flags = 0) { VkComputePipelineCreateInfo computePipelineCreateInfo{}; computePipelineCreateInfo.sType = - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; computePipelineCreateInfo.layout = layout; computePipelineCreateInfo.flags = flags; return computePipelineCreateInfo; } -inline VkPushConstantRange -pushConstantRange(VkShaderStageFlags stageFlags, uint32_t size, uint32_t offset) -{ +inline VkPushConstantRange pushConstantRange(VkShaderStageFlags stageFlags, + uint32_t size, + uint32_t offset) { VkPushConstantRange pushConstantRange{}; pushConstantRange.stageFlags = stageFlags; pushConstantRange.offset = offset; @@ -625,18 +551,16 @@ pushConstantRange(VkShaderStageFlags stageFlags, uint32_t size, uint32_t offset) return pushConstantRange; } -inline VkBindSparseInfo -bindSparseInfo() -{ +inline VkBindSparseInfo bindSparseInfo() { VkBindSparseInfo bindSparseInfo{}; bindSparseInfo.sType = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO; return bindSparseInfo; } /** @brief Initialize a map entry for a shader specialization constant */ -inline VkSpecializationMapEntry -specializationMapEntry(uint32_t constantID, uint32_t offset, size_t size) -{ +inline VkSpecializationMapEntry specializationMapEntry(uint32_t constantID, + uint32_t offset, + size_t size) { VkSpecializationMapEntry specializationMapEntry{}; specializationMapEntry.constantID = constantID; specializationMapEntry.offset = offset; @@ -646,12 +570,11 @@ specializationMapEntry(uint32_t constantID, uint32_t offset, size_t size) /** @brief Initialize a specialization constant info structure to pass to a * shader stage */ -inline VkSpecializationInfo -specializationInfo(uint32_t mapEntryCount, - const VkSpecializationMapEntry* mapEntries, - size_t dataSize, - const void* data) -{ +inline VkSpecializationInfo specializationInfo( + uint32_t mapEntryCount, + const VkSpecializationMapEntry* mapEntries, + size_t dataSize, + const void* data) { VkSpecializationInfo specializationInfo{}; specializationInfo.mapEntryCount = mapEntryCount; specializationInfo.pMapEntries = mapEntries; @@ -662,11 +585,10 @@ specializationInfo(uint32_t mapEntryCount, /** @brief Initialize a specialization constant info structure to pass to a * shader stage */ -inline VkSpecializationInfo -specializationInfo(const std::vector& mapEntries, - size_t dataSize, - const void* data) -{ +inline VkSpecializationInfo specializationInfo( + const std::vector& mapEntries, + size_t dataSize, + const void* data) { VkSpecializationInfo specializationInfo{}; specializationInfo.mapEntryCount = static_cast(mapEntries.size()); specializationInfo.pMapEntries = mapEntries.data(); @@ -675,5 +597,5 @@ specializationInfo(const std::vector& mapEntries, return specializationInfo; } -} // namespace initializers -} // namespace vks +} // namespace initializers +} // namespace vks diff --git a/src/VulkanTools.cpp b/src/VulkanTools.cpp index 963084153..dbda6696f 100644 --- a/src/VulkanTools.cpp +++ b/src/VulkanTools.cpp @@ -9,9 +9,7 @@ #include "VulkanTools.h" -const std::string -getAssetPath() -{ +const std::string getAssetPath() { #if defined(VK_EXAMPLE_DATA_DIR) return VK_EXAMPLE_DATA_DIR; #else @@ -23,12 +21,10 @@ namespace vks { namespace tools { bool errorModeSilent = false; -std::string -errorString(VkResult errorCode) -{ +std::string errorString(VkResult errorCode) { switch (errorCode) { -#define STR(r) \ - case VK_##r: \ +#define STR(r) \ + case VK_##r: \ return #r STR(NOT_READY); STR(TIMEOUT); @@ -59,12 +55,10 @@ errorString(VkResult errorCode) } } -std::string -physicalDeviceTypeString(VkPhysicalDeviceType type) -{ +std::string physicalDeviceTypeString(VkPhysicalDeviceType type) { switch (type) { -#define STR(r) \ - case VK_PHYSICAL_DEVICE_TYPE_##r: \ +#define STR(r) \ + case VK_PHYSICAL_DEVICE_TYPE_##r: \ return #r STR(OTHER); STR(INTEGRATED_GPU); @@ -76,21 +70,19 @@ physicalDeviceTypeString(VkPhysicalDeviceType type) } } -VkBool32 -getSupportedDepthFormat(VkPhysicalDevice physicalDevice, VkFormat* depthFormat) -{ +VkBool32 getSupportedDepthFormat(VkPhysicalDevice physicalDevice, + VkFormat* depthFormat) { // Since all depth formats may be optional, we need to find a suitable depth // format to use Start with the highest precision packed format - std::vector depthFormats = { VK_FORMAT_D32_SFLOAT_S8_UINT, - VK_FORMAT_D32_SFLOAT, - VK_FORMAT_D24_UNORM_S8_UINT, - VK_FORMAT_D16_UNORM_S8_UINT, - VK_FORMAT_D16_UNORM }; + std::vector depthFormats = { + VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D32_SFLOAT, + VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_D16_UNORM_S8_UINT, + VK_FORMAT_D16_UNORM}; for (auto& format : depthFormats) { VkFormatProperties formatProps; - vkGetPhysicalDeviceFormatProperties( - physicalDevice, format, &formatProps); + vkGetPhysicalDeviceFormatProperties(physicalDevice, format, + &formatProps); // Format must support depth stencil attachment for optimal tiling if (formatProps.optimalTilingFeatures & VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT) { @@ -103,11 +95,9 @@ getSupportedDepthFormat(VkPhysicalDevice physicalDevice, VkFormat* depthFormat) } // Returns if a given format support LINEAR filtering -VkBool32 -formatIsFilterable(VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageTiling tiling) -{ +VkBool32 formatIsFilterable(VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageTiling tiling) { VkFormatProperties formatProps; vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &formatProps); @@ -126,18 +116,16 @@ formatIsFilterable(VkPhysicalDevice physicalDevice, // an image and put it into an active command buffer // See chapter 11.4 "Image Layout" for details -void -setImageLayout(VkCommandBuffer cmdbuffer, - VkImage image, - VkImageLayout oldImageLayout, - VkImageLayout newImageLayout, - VkImageSubresourceRange subresourceRange, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask) -{ +void setImageLayout(VkCommandBuffer cmdbuffer, + VkImage image, + VkImageLayout oldImageLayout, + VkImageLayout newImageLayout, + VkImageSubresourceRange subresourceRange, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask) { // Create an image barrier object VkImageMemoryBarrier imageMemoryBarrier = - vks::initializers::imageMemoryBarrier(); + vks::initializers::imageMemoryBarrier(); imageMemoryBarrier.oldLayout = oldImageLayout; imageMemoryBarrier.newLayout = newImageLayout; imageMemoryBarrier.image = image; @@ -165,7 +153,7 @@ setImageLayout(VkCommandBuffer cmdbuffer, // Image is a color attachment // Make sure any writes to the color buffer have been finished imageMemoryBarrier.srcAccessMask = - VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; break; case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: @@ -173,7 +161,7 @@ setImageLayout(VkCommandBuffer cmdbuffer, // Make sure any writes to the depth/stencil buffer have been // finished imageMemoryBarrier.srcAccessMask = - VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; break; case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: @@ -217,15 +205,15 @@ setImageLayout(VkCommandBuffer cmdbuffer, // Image will be used as a color attachment // Make sure any writes to the color buffer have been finished imageMemoryBarrier.dstAccessMask = - VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; break; case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: // Image layout will be used as a depth/stencil attachment // Make sure any writes to depth/stencil buffer have been finished imageMemoryBarrier.dstAccessMask = - imageMemoryBarrier.dstAccessMask | - VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; + imageMemoryBarrier.dstAccessMask | + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT; break; case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: @@ -233,7 +221,7 @@ setImageLayout(VkCommandBuffer cmdbuffer, // Make sure any writes to the image have been finished if (imageMemoryBarrier.srcAccessMask == 0) { imageMemoryBarrier.srcAccessMask = - VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT; + VK_ACCESS_HOST_WRITE_BIT | VK_ACCESS_TRANSFER_WRITE_BIT; } imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; break; @@ -243,55 +231,38 @@ setImageLayout(VkCommandBuffer cmdbuffer, } // Put barrier inside setup command buffer - vkCmdPipelineBarrier(cmdbuffer, - srcStageMask, - dstStageMask, - 0, - 0, - nullptr, - 0, - nullptr, - 1, - &imageMemoryBarrier); + vkCmdPipelineBarrier(cmdbuffer, srcStageMask, dstStageMask, 0, 0, nullptr, + 0, nullptr, 1, &imageMemoryBarrier); } // Fixed sub resource on first mip level and layer -void -setImageLayout(VkCommandBuffer cmdbuffer, - VkImage image, - VkImageAspectFlags aspectMask, - VkImageLayout oldImageLayout, - VkImageLayout newImageLayout, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask) -{ +void setImageLayout(VkCommandBuffer cmdbuffer, + VkImage image, + VkImageAspectFlags aspectMask, + VkImageLayout oldImageLayout, + VkImageLayout newImageLayout, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask) { VkImageSubresourceRange subresourceRange = {}; subresourceRange.aspectMask = aspectMask; subresourceRange.baseMipLevel = 0; subresourceRange.levelCount = 1; subresourceRange.layerCount = 1; - setImageLayout(cmdbuffer, - image, - oldImageLayout, - newImageLayout, - subresourceRange, - srcStageMask, - dstStageMask); + setImageLayout(cmdbuffer, image, oldImageLayout, newImageLayout, + subresourceRange, srcStageMask, dstStageMask); } -void -insertImageMemoryBarrier(VkCommandBuffer cmdbuffer, - VkImage image, - VkAccessFlags srcAccessMask, - VkAccessFlags dstAccessMask, - VkImageLayout oldImageLayout, - VkImageLayout newImageLayout, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - VkImageSubresourceRange subresourceRange) -{ +void insertImageMemoryBarrier(VkCommandBuffer cmdbuffer, + VkImage image, + VkAccessFlags srcAccessMask, + VkAccessFlags dstAccessMask, + VkImageLayout oldImageLayout, + VkImageLayout newImageLayout, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkImageSubresourceRange subresourceRange) { VkImageMemoryBarrier imageMemoryBarrier = - vks::initializers::imageMemoryBarrier(); + vks::initializers::imageMemoryBarrier(); imageMemoryBarrier.srcAccessMask = srcAccessMask; imageMemoryBarrier.dstAccessMask = dstAccessMask; imageMemoryBarrier.oldLayout = oldImageLayout; @@ -299,21 +270,11 @@ insertImageMemoryBarrier(VkCommandBuffer cmdbuffer, imageMemoryBarrier.image = image; imageMemoryBarrier.subresourceRange = subresourceRange; - vkCmdPipelineBarrier(cmdbuffer, - srcStageMask, - dstStageMask, - 0, - 0, - nullptr, - 0, - nullptr, - 1, - &imageMemoryBarrier); + vkCmdPipelineBarrier(cmdbuffer, srcStageMask, dstStageMask, 0, 0, nullptr, + 0, nullptr, 1, &imageMemoryBarrier); } -void -exitFatal(std::string message, int32_t exitCode) -{ +void exitFatal(std::string message, int32_t exitCode) { #if defined(_WIN32) if (!errorModeSilent) { MessageBox(NULL, message.c_str(), NULL, MB_OK | MB_ICONERROR); @@ -322,15 +283,11 @@ exitFatal(std::string message, int32_t exitCode) std::cerr << message << "\n"; } -void -exitFatal(std::string message, VkResult resultCode) -{ +void exitFatal(std::string message, VkResult resultCode) { exitFatal(message, (int32_t)resultCode); } -VkShaderModule -loadShader(const char* fileName, VkDevice device) -{ +VkShaderModule loadShader(const char* fileName, VkDevice device) { std::ifstream is(fileName, std::ios::binary | std::ios::in | std::ios::ate); if (is.is_open()) { @@ -348,8 +305,8 @@ loadShader(const char* fileName, VkDevice device) moduleCreateInfo.codeSize = size; moduleCreateInfo.pCode = (uint32_t*)shaderCode; - VK_CHECK_RESULT( - vkCreateShaderModule(device, &moduleCreateInfo, NULL, &shaderModule)); + VK_CHECK_RESULT(vkCreateShaderModule(device, &moduleCreateInfo, NULL, + &shaderModule)); delete[] shaderCode; @@ -361,11 +318,9 @@ loadShader(const char* fileName, VkDevice device) } } -bool -fileExists(const std::string& filename) -{ +bool fileExists(const std::string& filename) { std::ifstream f(filename.c_str()); return !f.fail(); } -} // namespace tools -} // namespace vks +} // namespace tools +} // namespace vks diff --git a/src/VulkanTools.h b/src/VulkanTools.h index bec00baa7..f159654dd 100644 --- a/src/VulkanTools.h +++ b/src/VulkanTools.h @@ -13,13 +13,13 @@ #include "vulkan/vulkan.h" #include +#include +#include +#include #include #include #include -#include #include -#include -#include #include #include #if defined(_WIN32) @@ -34,19 +34,18 @@ #define DEFAULT_FENCE_TIMEOUT 100000000000 // Macro to check and display Vulkan return results -#define VK_CHECK_RESULT(f) \ - { \ - VkResult res = (f); \ - if (res != VK_SUCCESS) { \ - std::cout << "Fatal : VkResult is \"" \ - << vks::tools::errorString(res) << "\" in " << __FILE__ \ - << " at line " << __LINE__ << std::endl; \ - assert(res == VK_SUCCESS); \ - } \ +#define VK_CHECK_RESULT(f) \ + { \ + VkResult res = (f); \ + if (res != VK_SUCCESS) { \ + std::cout << "Fatal : VkResult is \"" \ + << vks::tools::errorString(res) << "\" in " << __FILE__ \ + << " at line " << __LINE__ << std::endl; \ + assert(res == VK_SUCCESS); \ + } \ } -const std::string -getAssetPath(); +const std::string getAssetPath(); namespace vks { namespace tools { @@ -54,71 +53,61 @@ namespace tools { extern bool errorModeSilent; /** @brief Returns an error code as a string */ -std::string -errorString(VkResult errorCode); +std::string errorString(VkResult errorCode); /** @brief Returns the device type as a string */ -std::string -physicalDeviceTypeString(VkPhysicalDeviceType type); +std::string physicalDeviceTypeString(VkPhysicalDeviceType type); // Selected a suitable supported depth format starting with 32 bit down to 16 // bit Returns false if none of the depth formats in the list is supported by // the device -VkBool32 -getSupportedDepthFormat(VkPhysicalDevice physicalDevice, VkFormat* depthFormat); +VkBool32 getSupportedDepthFormat(VkPhysicalDevice physicalDevice, + VkFormat* depthFormat); // Returns if a given format support LINEAR filtering -VkBool32 -formatIsFilterable(VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageTiling tiling); +VkBool32 formatIsFilterable(VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageTiling tiling); // Put an image memory barrier for setting an image layout on the sub resource // into the given command buffer -void -setImageLayout( - VkCommandBuffer cmdbuffer, - VkImage image, - VkImageLayout oldImageLayout, - VkImageLayout newImageLayout, - VkImageSubresourceRange subresourceRange, - VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT); +void setImageLayout( + VkCommandBuffer cmdbuffer, + VkImage image, + VkImageLayout oldImageLayout, + VkImageLayout newImageLayout, + VkImageSubresourceRange subresourceRange, + VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT); // Uses a fixed sub resource layout with first mip level and layer -void -setImageLayout( - VkCommandBuffer cmdbuffer, - VkImage image, - VkImageAspectFlags aspectMask, - VkImageLayout oldImageLayout, - VkImageLayout newImageLayout, - VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, - VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT); +void setImageLayout( + VkCommandBuffer cmdbuffer, + VkImage image, + VkImageAspectFlags aspectMask, + VkImageLayout oldImageLayout, + VkImageLayout newImageLayout, + VkPipelineStageFlags srcStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, + VkPipelineStageFlags dstStageMask = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT); /** @brief Inser an image memory barrier into the command buffer */ -void -insertImageMemoryBarrier(VkCommandBuffer cmdbuffer, - VkImage image, - VkAccessFlags srcAccessMask, - VkAccessFlags dstAccessMask, - VkImageLayout oldImageLayout, - VkImageLayout newImageLayout, - VkPipelineStageFlags srcStageMask, - VkPipelineStageFlags dstStageMask, - VkImageSubresourceRange subresourceRange); +void insertImageMemoryBarrier(VkCommandBuffer cmdbuffer, + VkImage image, + VkAccessFlags srcAccessMask, + VkAccessFlags dstAccessMask, + VkImageLayout oldImageLayout, + VkImageLayout newImageLayout, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkImageSubresourceRange subresourceRange); // Display error message and exit on fatal error -void -exitFatal(std::string message, int32_t exitCode); -void -exitFatal(std::string message, VkResult resultCode); +void exitFatal(std::string message, int32_t exitCode); +void exitFatal(std::string message, VkResult resultCode); // Load a SPIR-V shader (binary) -VkShaderModule -loadShader(const char* fileName, VkDevice device); +VkShaderModule loadShader(const char* fileName, VkDevice device); /** @brief Checks if a file exists */ -bool -fileExists(const std::string& filename); -} // namespace tools -} // namespace vks +bool fileExists(const std::string& filename); +} // namespace tools +} // namespace vks diff --git a/src/main.cpp b/src/main.cpp index 1116eeded..e38f7467d 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -64,18 +64,20 @@ class VulkanExample // Create the buffer handle VkBufferCreateInfo bufferCreateInfo = vks::initializers::bufferCreateInfo(usageFlags, size); + bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; VK_CHECK_RESULT( - vkCreateBuffer(device, &bufferCreateInfo, nullptr, buffer)); + vkCreateBuffer(this->device, &bufferCreateInfo, nullptr, buffer)); // Create the memory backing up the buffer handle VkPhysicalDeviceMemoryProperties deviceMemoryProperties; - vkGetPhysicalDeviceMemoryProperties(physicalDevice, + vkGetPhysicalDeviceMemoryProperties(this->physicalDevice, &deviceMemoryProperties); VkMemoryRequirements memReqs; VkMemoryAllocateInfo memAlloc = vks::initializers::memoryAllocateInfo(); - vkGetBufferMemoryRequirements(device, *buffer, &memReqs); + vkGetBufferMemoryRequirements(this->device, *buffer, &memReqs); memAlloc.allocationSize = memReqs.size; + // Find a memory type index that fits the properties of the buffer bool memTypeFound = false; for (uint32_t i = 0; i < deviceMemoryProperties.memoryTypeCount; i++) { @@ -187,9 +189,11 @@ class VulkanExample uint32_t deviceCount = 0; VK_CHECK_RESULT( vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr)); + std::vector physicalDevices(deviceCount); VK_CHECK_RESULT(vkEnumeratePhysicalDevices( instance, &deviceCount, physicalDevices.data())); + physicalDevice = physicalDevices[0]; VkPhysicalDeviceProperties deviceProperties; @@ -202,13 +206,16 @@ class VulkanExample uint32_t queueFamilyCount; vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, &queueFamilyCount, nullptr); + std::vector queueFamilyProperties( queueFamilyCount); vkGetPhysicalDeviceQueueFamilyProperties( physicalDevice, &queueFamilyCount, queueFamilyProperties.data()); + for (uint32_t i = 0; i < static_cast(queueFamilyProperties.size()); i++) { + if (queueFamilyProperties[i].queueFlags & VK_QUEUE_COMPUTE_BIT) { queueFamilyIndex = i; queueCreateInfo.sType = @@ -225,18 +232,18 @@ class VulkanExample deviceCreateInfo.queueCreateInfoCount = 1; deviceCreateInfo.pQueueCreateInfos = &queueCreateInfo; VK_CHECK_RESULT( - vkCreateDevice(physicalDevice, &deviceCreateInfo, nullptr, &device)); + vkCreateDevice(this->physicalDevice, &deviceCreateInfo, nullptr, &device)); // Get a compute queue - vkGetDeviceQueue(device, queueFamilyIndex, 0, &queue); + vkGetDeviceQueue(this->device, this->queueFamilyIndex, 0, &queue); // Compute command pool VkCommandPoolCreateInfo cmdPoolInfo = {}; cmdPoolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; - cmdPoolInfo.queueFamilyIndex = queueFamilyIndex; + cmdPoolInfo.queueFamilyIndex = this->queueFamilyIndex; cmdPoolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; VK_CHECK_RESULT( - vkCreateCommandPool(device, &cmdPoolInfo, nullptr, &commandPool)); + vkCreateCommandPool(this->device, &cmdPoolInfo, nullptr, &this->commandPool)); /* Prepare storage buffers @@ -376,7 +383,7 @@ class VulkanExample pipelineCacheCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO; VK_CHECK_RESULT(vkCreatePipelineCache( - device, &pipelineCacheCreateInfo, nullptr, &pipelineCache)); + this->device, &pipelineCacheCreateInfo, nullptr, &this->pipelineCache)); // Create pipeline VkComputePipelineCreateInfo computePipelineCreateInfo = @@ -387,6 +394,7 @@ class VulkanExample { uint32_t BUFFER_ELEMENT_COUNT = BUFFER_ELEMENTS; } specializationData; + VkSpecializationMapEntry specializationMapEntry = vks::initializers::specializationMapEntry(0, 0, sizeof(uint32_t)); VkSpecializationInfo specializationInfo =