From 87530419745f15f2eb6e97d4facd72ff3cf7e493 Mon Sep 17 00:00:00 2001 From: baldurk Date: Sat, 7 May 2016 14:03:46 +0200 Subject: [PATCH 1/4] Add latest vulkan header, with VK_EXT_debug_marker * From revision 648049f625c956068495192447e3ef99772c8947 (2016-05-07) File src/vulkan/vulkan.h in KhronosGroup/Vulkan-Docs --- external/vulkan/vulkan.h | 114 ++++++++++++++++++++++++++++++++------- 1 file changed, 95 insertions(+), 19 deletions(-) diff --git a/external/vulkan/vulkan.h b/external/vulkan/vulkan.h index dca5e259..741da4ce 100644 --- a/external/vulkan/vulkan.h +++ b/external/vulkan/vulkan.h @@ -8,24 +8,17 @@ extern "C" { /* ** Copyright (c) 2015-2016 The Khronos Group Inc. ** -** Permission is hereby granted, free of charge, to any person obtaining a -** copy of this software and/or associated documentation files (the -** "Materials"), to deal in the Materials without restriction, including -** without limitation the rights to use, copy, modify, merge, publish, -** distribute, sublicense, and/or sell copies of the Materials, and to -** permit persons to whom the Materials are furnished to do so, subject to -** the following conditions: +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at ** -** The above copyright notice and this permission notice shall be included -** in all copies or substantial portions of the Materials. +** http://www.apache.org/licenses/LICENSE-2.0 ** -** THE MATERIALS ARE 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 -** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. */ /* @@ -50,7 +43,7 @@ extern "C" { #define VK_VERSION_MINOR(version) (((uint32_t)(version) >> 12) & 0x3ff) #define VK_VERSION_PATCH(version) ((uint32_t)(version) & 0xfff) // Version of this file -#define VK_HEADER_VERSION 8 +#define VK_HEADER_VERSION 12 #define VK_NULL_HANDLE 0 @@ -217,6 +210,10 @@ typedef enum VkStructureType { VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, + VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, VK_STRUCTURE_TYPE_BEGIN_RANGE = VK_STRUCTURE_TYPE_APPLICATION_INFO, VK_STRUCTURE_TYPE_END_RANGE = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO, VK_STRUCTURE_TYPE_RANGE_SIZE = (VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO - VK_STRUCTURE_TYPE_APPLICATION_INFO + 1), @@ -3278,7 +3275,7 @@ VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( #define VK_KHR_swapchain 1 VK_DEFINE_NON_DISPATCHABLE_HANDLE(VkSwapchainKHR) -#define VK_KHR_SWAPCHAIN_SPEC_VERSION 67 +#define VK_KHR_SWAPCHAIN_SPEC_VERSION 68 #define VK_KHR_SWAPCHAIN_EXTENSION_NAME "VK_KHR_swapchain" typedef VkFlags VkSwapchainCreateFlagsKHR; @@ -3434,7 +3431,7 @@ typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhys typedef VkResult (VKAPI_PTR *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); -typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR*pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); +typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); typedef VkResult (VKAPI_PTR *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); typedef VkResult (VKAPI_PTR *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); @@ -3835,6 +3832,85 @@ VKAPI_ATTR void VKAPI_CALL vkDebugReportMessageEXT( #define VK_IMG_FILTER_CUBIC_EXTENSION_NAME "VK_IMG_filter_cubic" +#define VK_AMD_rasterization_order 1 +#define VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION 1 +#define VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME "VK_AMD_rasterization_order" + + +typedef enum VkRasterizationOrderAMD { + VK_RASTERIZATION_ORDER_STRICT_AMD = 0, + VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, + VK_RASTERIZATION_ORDER_BEGIN_RANGE_AMD = VK_RASTERIZATION_ORDER_STRICT_AMD, + VK_RASTERIZATION_ORDER_END_RANGE_AMD = VK_RASTERIZATION_ORDER_RELAXED_AMD, + VK_RASTERIZATION_ORDER_RANGE_SIZE_AMD = (VK_RASTERIZATION_ORDER_RELAXED_AMD - VK_RASTERIZATION_ORDER_STRICT_AMD + 1), + VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF +} VkRasterizationOrderAMD; + +typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { + VkStructureType sType; + const void* pNext; + VkRasterizationOrderAMD rasterizationOrder; +} VkPipelineRasterizationStateRasterizationOrderAMD; + + + +#define VK_EXT_debug_marker 1 +#define VK_EXT_DEBUG_MARKER_SPEC_VERSION 3 +#define VK_EXT_DEBUG_MARKER_EXTENSION_NAME "VK_EXT_debug_marker" + +typedef struct VkDebugMarkerObjectNameInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + const char* pObjectName; +} VkDebugMarkerObjectNameInfoEXT; + +typedef struct VkDebugMarkerObjectTagInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkDebugMarkerObjectTagInfoEXT; + +typedef struct VkDebugMarkerMarkerInfoEXT { + VkStructureType sType; + const void* pNext; + const char* pMarkerName; + float color[4]; +} VkDebugMarkerMarkerInfoEXT; + + +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, VkDebugMarkerObjectTagInfoEXT* pTagInfo); +typedef VkResult (VKAPI_PTR *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, VkDebugMarkerObjectNameInfoEXT* pNameInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer); +typedef void (VKAPI_PTR *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +#ifndef VK_NO_PROTOTYPES +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT( + VkDevice device, + VkDebugMarkerObjectTagInfoEXT* pTagInfo); + +VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT( + VkDevice device, + VkDebugMarkerObjectNameInfoEXT* pNameInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerBeginEXT( + VkCommandBuffer commandBuffer, + VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerEndEXT( + VkCommandBuffer commandBuffer); + +VKAPI_ATTR void VKAPI_CALL vkCmdDebugMarkerInsertEXT( + VkCommandBuffer commandBuffer, + VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +#endif + #ifdef __cplusplus } #endif From 6362d7c21663917fe69271a3b7b4ba08e44a210f Mon Sep 17 00:00:00 2001 From: baldurk Date: Sat, 7 May 2016 14:05:56 +0200 Subject: [PATCH 2/4] Add utility functions to wrap up use of VK_EXT_debug_marker * vkDebug::DebugMarkerRegion adds automatically scoped region markers * vkDebug::insertDebugMarker() inserts a label in a command buffer * vkDebug::SetObjectName() names any vulkan object with a friendly name --- base/vulkandebug.cpp | 134 +++++++++++++++++++++++++++++++++++++++++++ base/vulkandebug.h | 48 ++++++++++++++++ 2 files changed, 182 insertions(+) diff --git a/base/vulkandebug.cpp b/base/vulkandebug.cpp index 25cb6d12..45bfe3ec 100644 --- a/base/vulkandebug.cpp +++ b/base/vulkandebug.cpp @@ -88,4 +88,138 @@ namespace vkDebug // DestroyDebugReportCallback(instance, msgCallback, nullptr); } } + + PFN_vkDebugMarkerSetObjectNameEXT DebugMarkerSetObjectName = NULL; + PFN_vkCmdDebugMarkerBeginEXT CmdDebugMarkerBegin = NULL; + PFN_vkCmdDebugMarkerEndEXT CmdDebugMarkerEnd = NULL; + PFN_vkCmdDebugMarkerInsertEXT CmdDebugMarkerInsert = NULL; + + // Set up the debug marker function pointers + void setupDebugMarkers(VkDevice device) + { + DebugMarkerSetObjectName = (PFN_vkDebugMarkerSetObjectNameEXT)vkGetDeviceProcAddr(device, "vkDebugMarkerSetObjectNameEXT"); + CmdDebugMarkerBegin = (PFN_vkCmdDebugMarkerBeginEXT)vkGetDeviceProcAddr(device, "vkCmdDebugMarkerBeginEXT"); + CmdDebugMarkerEnd = (PFN_vkCmdDebugMarkerEndEXT)vkGetDeviceProcAddr(device, "vkCmdDebugMarkerEndEXT"); + CmdDebugMarkerInsert = (PFN_vkCmdDebugMarkerInsertEXT)vkGetDeviceProcAddr(device, "vkCmdDebugMarkerInsertEXT"); + } + + void insertDebugMarker( + VkCommandBuffer cmdbuffer, + const char* pMarkerName, + float color[4]) + { + // need to check if the function pointer is valid - extension might not be present + if (CmdDebugMarkerInsert) + { + VkDebugMarkerMarkerInfoEXT markerInfo = {}; + markerInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; + memcpy(markerInfo.color, color, sizeof(float)*4); + markerInfo.pMarkerName = pMarkerName; + CmdDebugMarkerInsert(cmdbuffer, &markerInfo); + } + } + + void insertDebugMarker( + VkCommandBuffer cmdbuffer, + const char* pMarkerName) + { + // need to check if the function pointer is valid - extension might not be present + if (CmdDebugMarkerInsert) + { + VkDebugMarkerMarkerInfoEXT markerInfo = {}; + markerInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; + markerInfo.pMarkerName = pMarkerName; + CmdDebugMarkerInsert(cmdbuffer, &markerInfo); + } + } + + DebugMarkerRegion::DebugMarkerRegion(VkCommandBuffer cmdbuffer, + const char* pMarkerName, + float color[4]) + { + cmd = cmdbuffer; + // need to check if the function pointer is valid - extension might not be present + if (CmdDebugMarkerBegin) + { + VkDebugMarkerMarkerInfoEXT markerInfo = {}; + markerInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; + memcpy(markerInfo.color, color, sizeof(float)*4); + markerInfo.pMarkerName = pMarkerName; + CmdDebugMarkerBegin(cmd, &markerInfo); + } + } + + DebugMarkerRegion::DebugMarkerRegion(VkCommandBuffer cmdbuffer, + const char* pMarkerName) + { + cmd = cmdbuffer; + // need to check if the function pointer is valid - extension might not be present + if (CmdDebugMarkerBegin) + { + VkDebugMarkerMarkerInfoEXT markerInfo = {}; + markerInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT; + markerInfo.pMarkerName = pMarkerName; + CmdDebugMarkerBegin(cmd, &markerInfo); + } + } + + DebugMarkerRegion::~DebugMarkerRegion() + { + // need to check if the function pointer is valid - extension might not be present + if (CmdDebugMarkerEnd) + CmdDebugMarkerEnd(cmd); + } + + // we specialise this template for each object type + template + VkDebugReportObjectTypeEXT GetObjectTypeEnum(VulkanType object); + +#define OBJECT_TYPE(enumName, objectType) template<> VkDebugReportObjectTypeEXT GetObjectTypeEnum(objectType o) { (void)o; return VK_DEBUG_REPORT_OBJECT_TYPE_ ##enumName ##_EXT; } + OBJECT_TYPE(INSTANCE, VkInstance); + OBJECT_TYPE(PHYSICAL_DEVICE, VkPhysicalDevice); + OBJECT_TYPE(DEVICE, VkDevice); + OBJECT_TYPE(QUEUE, VkQueue); + OBJECT_TYPE(SEMAPHORE, VkSemaphore); + OBJECT_TYPE(COMMAND_BUFFER, VkCommandBuffer); + OBJECT_TYPE(FENCE, VkFence); + OBJECT_TYPE(DEVICE_MEMORY, VkDeviceMemory); + OBJECT_TYPE(BUFFER, VkBuffer); + OBJECT_TYPE(IMAGE, VkImage); + OBJECT_TYPE(EVENT, VkEvent); + OBJECT_TYPE(QUERY_POOL, VkQueryPool); + OBJECT_TYPE(BUFFER_VIEW, VkBufferView); + OBJECT_TYPE(IMAGE_VIEW, VkImageView); + OBJECT_TYPE(SHADER_MODULE, VkShaderModule); + OBJECT_TYPE(PIPELINE_CACHE, VkPipelineCache); + OBJECT_TYPE(PIPELINE_LAYOUT, VkPipelineLayout); + OBJECT_TYPE(RENDER_PASS, VkRenderPass); + OBJECT_TYPE(PIPELINE, VkPipeline); + OBJECT_TYPE(DESCRIPTOR_SET_LAYOUT, VkDescriptorSetLayout); + OBJECT_TYPE(SAMPLER, VkSampler); + OBJECT_TYPE(DESCRIPTOR_POOL, VkDescriptorPool); + OBJECT_TYPE(DESCRIPTOR_SET, VkDescriptorSet); + OBJECT_TYPE(FRAMEBUFFER, VkFramebuffer); + OBJECT_TYPE(COMMAND_POOL, VkCommandPool); + OBJECT_TYPE(SURFACE_KHR, VkSurfaceKHR); + OBJECT_TYPE(SWAPCHAIN_KHR, VkSwapchainKHR); + OBJECT_TYPE(DEBUG_REPORT, VkDebugReportCallbackEXT); +#undef OBJECT_TYPE + + void SetObjectName( + VkDevice device, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + const char* pObjectName) + { + // need to check if the function pointer is valid - extension might not be present + if (DebugMarkerSetObjectName) + { + VkDebugMarkerObjectNameInfoEXT nameInfo = {}; + nameInfo.sType = VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT; + nameInfo.objectType = objectType; + nameInfo.object = object; + nameInfo.pObjectName = pObjectName; + DebugMarkerSetObjectName(device, &nameInfo); + } + } } \ No newline at end of file diff --git a/base/vulkandebug.h b/base/vulkandebug.h index 6b722a85..b41fdfe9 100644 --- a/base/vulkandebug.h +++ b/base/vulkandebug.h @@ -44,4 +44,52 @@ namespace vkDebug VkDebugReportCallbackEXT callBack); // Clear debug callback void freeDebugCallback(VkInstance instance); + + // Set up the debug marker function pointers + void setupDebugMarkers(VkDevice device); + + // insert a debug label into the command buffer, with or + // without a color + void insertDebugMarker( + VkCommandBuffer cmdbuffer, + const char* pMarkerName, + float color[4]); + void insertDebugMarker( + VkCommandBuffer cmdbuffer, + const char* pMarkerName); + + // helper class for pushing and popping a debug region + // around some section of code. + struct DebugMarkerRegion + { + DebugMarkerRegion(VkCommandBuffer cmdbuffer, + const char* pMarkerName, + float color[4]); + DebugMarkerRegion(VkCommandBuffer cmdbuffer, + const char* pMarkerName); + ~DebugMarkerRegion(); + + VkCommandBuffer cmd; + }; + + // associate a friendly name with an object + void SetObjectName( + VkDevice device, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + const char* pObjectName); + + // specialised in vulkandebug.cpp for each object type + template + VkDebugReportObjectTypeEXT GetObjectTypeEnum(VulkanType object); + + // templated helper function for SetObjectName + template + void SetObjectName( + VkDevice device, + VulkanType object, + const char* pObjectName) + { + SetObjectName(device, GetObjectTypeEnum(object), (uint64_t)object, pObjectName); + } } From d223dfa72b3012cdf49bac50cfe0ac8ad80c0094 Mon Sep 17 00:00:00 2001 From: baldurk Date: Sat, 7 May 2016 14:06:47 +0200 Subject: [PATCH 3/4] Check for VK_EXT_debug_marker being present and enable it if so --- base/vulkanexamplebase.cpp | 11 +++++++++++ base/vulkanexamplebase.h | 2 ++ 2 files changed, 13 insertions(+) diff --git a/base/vulkanexamplebase.cpp b/base/vulkanexamplebase.cpp index 58ce8a5f..e1312e4b 100644 --- a/base/vulkanexamplebase.cpp +++ b/base/vulkanexamplebase.cpp @@ -61,6 +61,13 @@ VkResult VulkanExampleBase::createDevice(VkDeviceQueueCreateInfo requestedQueues deviceCreateInfo.pQueueCreateInfos = &requestedQueues; deviceCreateInfo.pEnabledFeatures = NULL; + // enable the debug marker extension if it is present (likely meaning a debugging tool is present) + if (vkTools::checkDeviceExtensionPresent(physicalDevice, VK_EXT_DEBUG_MARKER_EXTENSION_NAME)) + { + enabledExtensions.push_back(VK_EXT_DEBUG_MARKER_EXTENSION_NAME); + enableDebugMarkers = true; + } + if (enabledExtensions.size() > 0) { deviceCreateInfo.enabledExtensionCount = (uint32_t)enabledExtensions.size(); @@ -249,6 +256,10 @@ void VulkanExampleBase::prepare() { vkDebug::setupDebugging(instance, VK_DEBUG_REPORT_ERROR_BIT_EXT | VK_DEBUG_REPORT_WARNING_BIT_EXT, NULL); } + if (enableDebugMarkers) + { + vkDebug::setupDebugMarkers(device); + } createCommandPool(); createSetupCommandBuffer(); setupSwapChain(); diff --git a/base/vulkanexamplebase.h b/base/vulkanexamplebase.h index a506f031..1fcfaa87 100644 --- a/base/vulkanexamplebase.h +++ b/base/vulkanexamplebase.h @@ -45,6 +45,8 @@ class VulkanExampleBase private: // Set to true when example is created with enabled validation layers bool enableValidation = false; + // Set to true when the debug marker extension is detected + bool enableDebugMarkers = false; // fps timer (one second interval) float fpsTimer = 0.0f; // Create application wide Vulkan instance From a1d8558b89e31fae7ba07a66f2e9226484b657f3 Mon Sep 17 00:00:00 2001 From: baldurk Date: Sat, 7 May 2016 14:08:40 +0200 Subject: [PATCH 4/4] Add object naming and debug marker/regions to bloom sample --- base/vulkanexamplebase.cpp | 2 + bloom/bloom.cpp | 353 +++++++++++++++++++++---------------- 2 files changed, 202 insertions(+), 153 deletions(-) diff --git a/base/vulkanexamplebase.cpp b/base/vulkanexamplebase.cpp index e1312e4b..591bf737 100644 --- a/base/vulkanexamplebase.cpp +++ b/base/vulkanexamplebase.cpp @@ -1358,6 +1358,8 @@ void VulkanExampleBase::setupDepthStencil() getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &mem_alloc.memoryTypeIndex); err = vkAllocateMemory(device, &mem_alloc, nullptr, &depthStencil.mem); assert(!err); + + vkDebug::SetObjectName(device, depthStencil.image, "Backbuffer depth-stencil"); err = vkBindImageMemory(device, depthStencil.image, depthStencil.mem, 0); assert(!err); diff --git a/bloom/bloom.cpp b/bloom/bloom.cpp index 40f210a1..3f7824e3 100644 --- a/bloom/bloom.cpp +++ b/bloom/bloom.cpp @@ -432,173 +432,184 @@ public: VkResult err = vkBeginCommandBuffer(offScreenCmdBuffer, &cmdBufInfo); assert(!err); - VkViewport viewport = vkTools::initializers::viewport( - (float)offScreenFrameBuf.width, - (float)offScreenFrameBuf.height, - 0.0f, - 1.0f); - vkCmdSetViewport(offScreenCmdBuffer, 0, 1, &viewport); + { + vkDebug::DebugMarkerRegion offscreenBloom(offScreenCmdBuffer, "Off-screen bloom generation"); - VkRect2D scissor = vkTools::initializers::rect2D( - offScreenFrameBuf.width, - offScreenFrameBuf.height, - 0, - 0); - vkCmdSetScissor(offScreenCmdBuffer, 0, 1, &scissor); + VkViewport viewport = vkTools::initializers::viewport( + (float)offScreenFrameBuf.width, + (float)offScreenFrameBuf.height, + 0.0f, + 1.0f); + vkCmdSetViewport(offScreenCmdBuffer, 0, 1, &viewport); - vkCmdBeginRenderPass(offScreenCmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); + VkRect2D scissor = vkTools::initializers::rect2D( + offScreenFrameBuf.width, + offScreenFrameBuf.height, + 0, + 0); + vkCmdSetScissor(offScreenCmdBuffer, 0, 1, &scissor); - vkCmdBindDescriptorSets(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.scene, 0, NULL); - vkCmdBindPipeline(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.phongPass); + vkCmdBeginRenderPass(offScreenCmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); - VkDeviceSize offsets[1] = { 0 }; - vkCmdBindVertexBuffers(offScreenCmdBuffer, VERTEX_BUFFER_BIND_ID, 1, &meshes.ufoGlow.vertices.buf, offsets); - vkCmdBindIndexBuffer(offScreenCmdBuffer, meshes.ufoGlow.indices.buf, 0, VK_INDEX_TYPE_UINT32); - vkCmdDrawIndexed(offScreenCmdBuffer, meshes.ufoGlow.indexCount, 1, 0, 0, 0); + vkCmdBindDescriptorSets(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.scene, 0, NULL); + vkCmdBindPipeline(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.phongPass); - vkCmdEndRenderPass(offScreenCmdBuffer); + vkDebug::insertDebugMarker(offScreenCmdBuffer, "UFO Glow"); - // Make sure color writes to the framebuffer are finished before using it as transfer source - vkTools::setImageLayout( - offScreenCmdBuffer, - offScreenFrameBuf.color.image, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); + VkDeviceSize offsets[1] = { 0 }; + vkCmdBindVertexBuffers(offScreenCmdBuffer, VERTEX_BUFFER_BIND_ID, 1, &meshes.ufoGlow.vertices.buf, offsets); + vkCmdBindIndexBuffer(offScreenCmdBuffer, meshes.ufoGlow.indices.buf, 0, VK_INDEX_TYPE_UINT32); + vkCmdDrawIndexed(offScreenCmdBuffer, meshes.ufoGlow.indexCount, 1, 0, 0, 0); - // Transform texture target to transfer destination - vkTools::setImageLayout( - offScreenCmdBuffer, - offScreenFrameBuf.textureTarget.image, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); + vkCmdEndRenderPass(offScreenCmdBuffer); - // Blit offscreen color buffer to our texture target - VkImageBlit imgBlit; + // Make sure color writes to the framebuffer are finished before using it as transfer source + vkTools::setImageLayout( + offScreenCmdBuffer, + offScreenFrameBuf.color.image, + VK_IMAGE_ASPECT_COLOR_BIT, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); - imgBlit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; - imgBlit.srcSubresource.mipLevel = 0; - imgBlit.srcSubresource.baseArrayLayer = 0; - imgBlit.srcSubresource.layerCount = 1; + // Transform texture target to transfer destination + vkTools::setImageLayout( + offScreenCmdBuffer, + offScreenFrameBuf.textureTarget.image, + VK_IMAGE_ASPECT_COLOR_BIT, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); - imgBlit.srcOffsets[0] = { 0, 0, 0 }; - imgBlit.srcOffsets[1].x = offScreenFrameBuf.width; - imgBlit.srcOffsets[1].y = offScreenFrameBuf.height; - imgBlit.srcOffsets[1].z = 1; + // Blit offscreen color buffer to our texture target + VkImageBlit imgBlit; - imgBlit.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; - imgBlit.dstSubresource.mipLevel = 0; - imgBlit.dstSubresource.baseArrayLayer = 0; - imgBlit.dstSubresource.layerCount = 1; + imgBlit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + imgBlit.srcSubresource.mipLevel = 0; + imgBlit.srcSubresource.baseArrayLayer = 0; + imgBlit.srcSubresource.layerCount = 1; - imgBlit.dstOffsets[0] = { 0, 0, 0 }; - imgBlit.dstOffsets[1].x = offScreenFrameBuf.textureTarget.width; - imgBlit.dstOffsets[1].y = offScreenFrameBuf.textureTarget.height; - imgBlit.dstOffsets[1].z = 1; + imgBlit.srcOffsets[0] = { 0, 0, 0 }; + imgBlit.srcOffsets[1].x = offScreenFrameBuf.width; + imgBlit.srcOffsets[1].y = offScreenFrameBuf.height; + imgBlit.srcOffsets[1].z = 1; - // Blit from framebuffer image to texture image - // vkCmdBlitImage does scaling and (if necessary and possible) also does format conversions - vkCmdBlitImage( - offScreenCmdBuffer, - offScreenFrameBuf.color.image, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - offScreenFrameBuf.textureTarget.image, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - 1, - &imgBlit, - VK_FILTER_LINEAR - ); + imgBlit.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + imgBlit.dstSubresource.mipLevel = 0; + imgBlit.dstSubresource.baseArrayLayer = 0; + imgBlit.dstSubresource.layerCount = 1; - // Transform framebuffer color attachment back - vkTools::setImageLayout( - offScreenCmdBuffer, - offScreenFrameBuf.color.image, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + imgBlit.dstOffsets[0] = { 0, 0, 0 }; + imgBlit.dstOffsets[1].x = offScreenFrameBuf.textureTarget.width; + imgBlit.dstOffsets[1].y = offScreenFrameBuf.textureTarget.height; + imgBlit.dstOffsets[1].z = 1; - // Transform texture target back to shader read - // Makes sure that writes to the texture are finished before - // it's accessed in the shader - vkTools::setImageLayout( - offScreenCmdBuffer, - offScreenFrameBuf.textureTarget.image, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + vkDebug::insertDebugMarker(offScreenCmdBuffer, "Blit Framebuffer A -> textureTarget"); - // Vertical blur - // Render the textured quad containing the scene into - // another offscreen buffer applying a vertical blur - renderPassBeginInfo.framebuffer = offScreenFrameBufB.frameBuffer; - renderPassBeginInfo.renderArea.extent.width = offScreenFrameBufB.width; - renderPassBeginInfo.renderArea.extent.height = offScreenFrameBufB.height; + // Blit from framebuffer image to texture image + // vkCmdBlitImage does scaling and (if necessary and possible) also does format conversions + vkCmdBlitImage( + offScreenCmdBuffer, + offScreenFrameBuf.color.image, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + offScreenFrameBuf.textureTarget.image, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + 1, + &imgBlit, + VK_FILTER_LINEAR + ); - viewport.width = offScreenFrameBuf.width; - viewport.height = offScreenFrameBuf.height; - vkCmdSetViewport(offScreenCmdBuffer, 0, 1, &viewport); + // Transform framebuffer color attachment back + vkTools::setImageLayout( + offScreenCmdBuffer, + offScreenFrameBuf.color.image, + VK_IMAGE_ASPECT_COLOR_BIT, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); - vkCmdSetScissor(offScreenCmdBuffer, 0, 1, &scissor); + // Transform texture target back to shader read + // Makes sure that writes to the texture are finished before + // it's accessed in the shader + vkTools::setImageLayout( + offScreenCmdBuffer, + offScreenFrameBuf.textureTarget.image, + VK_IMAGE_ASPECT_COLOR_BIT, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); - vkCmdBeginRenderPass(offScreenCmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); + // Vertical blur + // Render the textured quad containing the scene into + // another offscreen buffer applying a vertical blur + renderPassBeginInfo.framebuffer = offScreenFrameBufB.frameBuffer; + renderPassBeginInfo.renderArea.extent.width = offScreenFrameBufB.width; + renderPassBeginInfo.renderArea.extent.height = offScreenFrameBufB.height; - // Draw horizontally blurred texture - vkCmdBindDescriptorSets(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.radialBlur, 0, 1, &descriptorSets.verticalBlur, 0, NULL); - vkCmdBindPipeline(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.blurVert); - vkCmdBindVertexBuffers(offScreenCmdBuffer, VERTEX_BUFFER_BIND_ID, 1, &meshes.quad.vertices.buf, offsets); - vkCmdBindIndexBuffer(offScreenCmdBuffer, meshes.quad.indices.buf, 0, VK_INDEX_TYPE_UINT32); - vkCmdDrawIndexed(offScreenCmdBuffer, meshes.quad.indexCount, 1, 0, 0, 0); + viewport.width = offScreenFrameBuf.width; + viewport.height = offScreenFrameBuf.height; + vkCmdSetViewport(offScreenCmdBuffer, 0, 1, &viewport); - vkCmdEndRenderPass(offScreenCmdBuffer); + vkCmdSetScissor(offScreenCmdBuffer, 0, 1, &scissor); - // Make sure color writes to the framebuffer are finished before using it as transfer source - vkTools::setImageLayout( - offScreenCmdBuffer, - offScreenFrameBufB.color.image, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); + vkCmdBeginRenderPass(offScreenCmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); - // Transform texture target to transfer destination - vkTools::setImageLayout( - offScreenCmdBuffer, - offScreenFrameBufB.textureTarget.image, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); + vkDebug::insertDebugMarker(offScreenCmdBuffer, "Vertical Blur"); + vkCmdBindDescriptorSets(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.radialBlur, 0, 1, &descriptorSets.verticalBlur, 0, NULL); + vkCmdBindPipeline(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.blurVert); + vkCmdBindVertexBuffers(offScreenCmdBuffer, VERTEX_BUFFER_BIND_ID, 1, &meshes.quad.vertices.buf, offsets); + vkCmdBindIndexBuffer(offScreenCmdBuffer, meshes.quad.indices.buf, 0, VK_INDEX_TYPE_UINT32); + vkCmdDrawIndexed(offScreenCmdBuffer, meshes.quad.indexCount, 1, 0, 0, 0); - // Blit from framebuffer image to texture image - // vkCmdBlitImage does scaling and (if necessary and possible) also does format conversions - vkCmdBlitImage( - offScreenCmdBuffer, - offScreenFrameBufB.color.image, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - offScreenFrameBufB.textureTarget.image, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - 1, - &imgBlit, - VK_FILTER_LINEAR - ); + vkCmdEndRenderPass(offScreenCmdBuffer); - // Transform framebuffer color attachment back - vkTools::setImageLayout( - offScreenCmdBuffer, - offScreenFrameBufB.color.image, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + // Make sure color writes to the framebuffer are finished before using it as transfer source + vkTools::setImageLayout( + offScreenCmdBuffer, + offScreenFrameBufB.color.image, + VK_IMAGE_ASPECT_COLOR_BIT, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL); - // Transform texture target back to shader read - // Makes sure that writes to the texture are finished before - // it's accessed in the shader - vkTools::setImageLayout( - offScreenCmdBuffer, - offScreenFrameBufB.textureTarget.image, - VK_IMAGE_ASPECT_COLOR_BIT, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + // Transform texture target to transfer destination + vkTools::setImageLayout( + offScreenCmdBuffer, + offScreenFrameBufB.textureTarget.image, + VK_IMAGE_ASPECT_COLOR_BIT, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL); + + vkDebug::insertDebugMarker(offScreenCmdBuffer, "Blit Framebuffer B -> textureTarget"); + + // Blit from framebuffer image to texture image + // vkCmdBlitImage does scaling and (if necessary and possible) also does format conversions + vkCmdBlitImage( + offScreenCmdBuffer, + offScreenFrameBufB.color.image, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + offScreenFrameBufB.textureTarget.image, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + 1, + &imgBlit, + VK_FILTER_LINEAR + ); + + // Transform framebuffer color attachment back + vkTools::setImageLayout( + offScreenCmdBuffer, + offScreenFrameBufB.color.image, + VK_IMAGE_ASPECT_COLOR_BIT, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); + + // Transform texture target back to shader read + // Makes sure that writes to the texture are finished before + // it's accessed in the shader + vkTools::setImageLayout( + offScreenCmdBuffer, + offScreenFrameBufB.textureTarget.image, + VK_IMAGE_ASPECT_COLOR_BIT, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); + + } // end of "offscreen bloom generation" region err = vkEndCommandBuffer(offScreenCmdBuffer); assert(!err); @@ -610,6 +621,8 @@ public: getAssetPath() + "textures/cubemap_space.ktx", VK_FORMAT_R8G8B8A8_UNORM, &textures.cubemap); + + vkDebug::SetObjectName(device, textures.cubemap.image, "textures/cubemap_space.ktx"); } void reBuildCommandBuffers() @@ -667,25 +680,30 @@ public: VkDeviceSize offsets[1] = { 0 }; - // Skybox - vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.skyBox, 0, NULL); - vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.skyBox); + { + vkDebug::DebugMarkerRegion scene(drawCmdBuffers[i], "3D Scene"); - vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.skyBox.vertices.buf, offsets); - vkCmdBindIndexBuffer(drawCmdBuffers[i], meshes.skyBox.indices.buf, 0, VK_INDEX_TYPE_UINT32); - vkCmdDrawIndexed(drawCmdBuffers[i], meshes.skyBox.indexCount, 1, 0, 0, 0); - - // 3D scene - vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.scene, 0, NULL); - vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.phongPass); + vkDebug::insertDebugMarker(drawCmdBuffers[i], "Skybox"); + vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.skyBox, 0, NULL); + vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.skyBox); - vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.ufo.vertices.buf, offsets); - vkCmdBindIndexBuffer(drawCmdBuffers[i], meshes.ufo.indices.buf, 0, VK_INDEX_TYPE_UINT32); - vkCmdDrawIndexed(drawCmdBuffers[i], meshes.ufo.indexCount, 1, 0, 0, 0); + vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.skyBox.vertices.buf, offsets); + vkCmdBindIndexBuffer(drawCmdBuffers[i], meshes.skyBox.indices.buf, 0, VK_INDEX_TYPE_UINT32); + vkCmdDrawIndexed(drawCmdBuffers[i], meshes.skyBox.indexCount, 1, 0, 0, 0); + + vkDebug::insertDebugMarker(drawCmdBuffers[i], "UFO"); + vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.scene, 0, NULL); + vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.phongPass); + + vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.ufo.vertices.buf, offsets); + vkCmdBindIndexBuffer(drawCmdBuffers[i], meshes.ufo.indices.buf, 0, VK_INDEX_TYPE_UINT32); + vkCmdDrawIndexed(drawCmdBuffers[i], meshes.ufo.indexCount, 1, 0, 0, 0); + } // Render vertical blurred scene applying a horizontal blur if (bloom) { + vkDebug::insertDebugMarker(drawCmdBuffers[i], "Bloom Apply"); vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.radialBlur, 0, 1, &descriptorSets.horizontalBlur, 0, NULL); vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.blurVert); vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.quad.vertices.buf, offsets); @@ -744,6 +762,13 @@ public: loadMesh(getAssetPath() + "models/retroufo.dae", &meshes.ufo, vertexLayout, 0.05f); loadMesh(getAssetPath() + "models/retroufo_glow.dae", &meshes.ufoGlow, vertexLayout, 0.05f); loadMesh(getAssetPath() + "models/cube.obj", &meshes.skyBox, vertexLayout, 1.0f); + + vkDebug::SetObjectName(device, meshes.ufo.vertices.buf, "UFO Vertices"); + vkDebug::SetObjectName(device, meshes.ufo.indices.buf, "UFO Indices"); + vkDebug::SetObjectName(device, meshes.ufoGlow.vertices.buf, "UFO Glow Vertices"); + vkDebug::SetObjectName(device, meshes.ufoGlow.indices.buf, "UFO Glow Indices"); + vkDebug::SetObjectName(device, meshes.skyBox.vertices.buf, "Skybox Vertices"); + vkDebug::SetObjectName(device, meshes.skyBox.indices.buf, "Skybox Indices"); } // Setup vertices for a single uv-mapped quad @@ -777,12 +802,16 @@ public: std::vector indexBuffer = { 0,1,2, 2,3,0 }; meshes.quad.indexCount = indexBuffer.size(); + vkDebug::SetObjectName(device, meshes.quad.vertices.buf, "Quad Vertices"); + createBuffer( VK_BUFFER_USAGE_INDEX_BUFFER_BIT, indexBuffer.size() * sizeof(uint32_t), indexBuffer.data(), &meshes.quad.indices.buf, &meshes.quad.indices.mem); + + vkDebug::SetObjectName(device, meshes.quad.indices.buf, "Quad Indices"); } void setupVertexDescriptions() @@ -1075,6 +1104,9 @@ public: shaderStages[0] = loadShader(getAssetPath() + "shaders/bloom/gaussblur.vert.spv", VK_SHADER_STAGE_VERTEX_BIT); shaderStages[1] = loadShader(getAssetPath() + "shaders/bloom/gaussblur.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT); + vkDebug::SetObjectName(device, shaderStages[0].module, "shaders/bloom/gaussblur.vert.spv"); + vkDebug::SetObjectName(device, shaderStages[1].module, "shaders/bloom/gaussblur.frag.spv"); + VkGraphicsPipelineCreateInfo pipelineCreateInfo = vkTools::initializers::pipelineCreateInfo( pipelineLayouts.radialBlur, @@ -1109,6 +1141,9 @@ public: shaderStages[0] = loadShader(getAssetPath() + "shaders/bloom/phongpass.vert.spv", VK_SHADER_STAGE_VERTEX_BIT); shaderStages[1] = loadShader(getAssetPath() + "shaders/bloom/phongpass.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT); + vkDebug::SetObjectName(device, shaderStages[0].module, "shaders/bloom/phongpass.vert.spv"); + vkDebug::SetObjectName(device, shaderStages[1].module, "shaders/bloom/phongpass.frag.spv"); + pipelineCreateInfo.layout = pipelineLayouts.scene; blendAttachmentState.blendEnable = VK_FALSE; depthStencilState.depthWriteEnable = VK_TRUE; @@ -1120,6 +1155,9 @@ public: shaderStages[0] = loadShader(getAssetPath() + "shaders/bloom/colorpass.vert.spv", VK_SHADER_STAGE_VERTEX_BIT); shaderStages[1] = loadShader(getAssetPath() + "shaders/bloom/colorpass.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT); + vkDebug::SetObjectName(device, shaderStages[0].module, "shaders/bloom/colorpass.vert.spv"); + vkDebug::SetObjectName(device, shaderStages[1].module, "shaders/bloom/colorpass.frag.spv"); + err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.colorPass); assert(!err); @@ -1130,6 +1168,9 @@ public: err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.skyBox); assert(!err); + vkDebug::SetObjectName(device, shaderStages[0].module, "shaders/bloom/skybox.vert.spv"); + vkDebug::SetObjectName(device, shaderStages[1].module, "shaders/bloom/skybox.frag.spv"); + } // Prepare and initialize uniform buffer containing shader uniforms @@ -1259,6 +1300,8 @@ public: prepareUniformBuffers(); prepareTextureTarget(&offScreenFrameBuf.textureTarget, TEX_DIM, TEX_DIM, TEX_FORMAT); prepareTextureTarget(&offScreenFrameBufB.textureTarget, TEX_DIM, TEX_DIM, TEX_FORMAT); + vkDebug::SetObjectName(device, offScreenFrameBuf.textureTarget.image, "Off-screen A textureTarget"); + vkDebug::SetObjectName(device, offScreenFrameBufB.textureTarget.image, "Off-screen B textureTarget"); setupDescriptorSetLayout(); preparePipelines(); setupDescriptorPool(); @@ -1266,6 +1309,10 @@ public: createOffscreenCommandBuffer(); prepareOffscreenFramebuffer(&offScreenFrameBuf); prepareOffscreenFramebuffer(&offScreenFrameBufB); + vkDebug::SetObjectName(device, offScreenFrameBuf.color.image, "Off-screen A color framebuffer"); + vkDebug::SetObjectName(device, offScreenFrameBuf.depth.image, "Off-screen A depth framebuffer"); + vkDebug::SetObjectName(device, offScreenFrameBufB.color.image, "Off-screen B color framebuffer"); + vkDebug::SetObjectName(device, offScreenFrameBufB.depth.image, "Off-screen B depth framebuffer"); buildCommandBuffers(); prepared = true; }