Name some internal image and imageview objects for vulkan

renderdoc/driver/vulkan/vk_common.cpp

@@ -102,6 +102,11 @@ void VkMarkerRegion::End(VkCommandBuffer cmd)
   ObjDisp(cmd)->CmdEndDebugUtilsLabelEXT(Unwrap(cmd));
 }
 
+VkDevice VkMarkerRegion::GetDev()
+{
+  return vk->GetDev();
+}
+
 void VkMarkerRegion::Begin(const rdcstr &marker, VkQueue q)
 {
   if(q == VK_NULL_HANDLE)
@@ -160,22 +165,14 @@ void VkMarkerRegion::End(VkQueue q)
 }
 
 template <>
-void NameVulkanObject(VkImage obj, const rdcstr &name)
+VkObjectType objType<VkImage>()
 {
-  if(!VkMarkerRegion::vk)
-    return;
-
-  VkDevice dev = VkMarkerRegion::vk->GetDev();
-
-  if(!ObjDisp(dev)->SetDebugUtilsObjectNameEXT)
-    return;
-
-  VkDebugUtilsObjectNameInfoEXT info = {};
-  info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
-  info.objectType = VK_OBJECT_TYPE_IMAGE;
-  info.objectHandle = NON_DISP_TO_UINT64(Unwrap(obj));
-  info.pObjectName = name.c_str();
-  ObjDisp(dev)->SetDebugUtilsObjectNameEXT(Unwrap(dev), &info);
+  return VK_OBJECT_TYPE_IMAGE;
+}
+template <>
+VkObjectType objType<VkImageView>()
+{
+  return VK_OBJECT_TYPE_IMAGE_VIEW;
 }
 
 void GPUBuffer::Create(WrappedVulkan *driver, VkDevice dev, VkDeviceSize size, uint32_t ringSize,

renderdoc/driver/vulkan/vk_common.h

@@ -178,15 +178,14 @@ struct VkMarkerRegion
   static void Set(const rdcstr &marker, VkQueue q = VK_NULL_HANDLE);
   static void End(VkQueue q = VK_NULL_HANDLE);
 
+  static VkDevice GetDev();
+
   VkCommandBuffer cmdbuf = VK_NULL_HANDLE;
   VkQueue queue = VK_NULL_HANDLE;
 
   static WrappedVulkan *vk;
 };
 
-template <typename T>
-void NameVulkanObject(T obj, const rdcstr &name);
-
 struct GPUBuffer
 {
   enum CreateFlags

renderdoc/driver/vulkan/vk_debug.cpp

@@ -476,6 +476,8 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver)
     vkr = driver->vkCreateImage(driver->GetDev(), &imInfo, NULL, &m_DummyStencilImage[0]);
     CheckVkResult(vkr);
 
+    NameVulkanObject(m_DummyStencilImage[0], "m_DummyStencilImage[0]");
+
     rm->SetInternalResource(GetResID(m_DummyStencilImage[0]));
 
     imInfo.samples = VK_SAMPLE_COUNT_2_BIT;
@@ -499,6 +501,8 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver)
     vkr = driver->vkCreateImage(driver->GetDev(), &imInfo, NULL, &m_DummyStencilImage[1]);
     CheckVkResult(vkr);
 
+    NameVulkanObject(m_DummyStencilImage[1], "m_DummyStencilImage[1]");
+
     rm->SetInternalResource(GetResID(m_DummyStencilImage[1]));
 
     VkMemoryRequirements mrq[2] = {};
@@ -550,6 +554,8 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver)
     vkr = driver->vkCreateImageView(driver->GetDev(), &viewInfo, NULL, &m_DummyStencilView[0]);
     CheckVkResult(vkr);
 
+    NameVulkanObject(m_DummyStencilView[0], "m_DummyStencilView[0]");
+
     rm->SetInternalResource(GetResID(m_DummyStencilView[0]));
 
     viewInfo.image = m_DummyStencilImage[1];
@@ -557,6 +563,8 @@ VulkanDebugManager::VulkanDebugManager(WrappedVulkan *driver)
     vkr = driver->vkCreateImageView(driver->GetDev(), &viewInfo, NULL, &m_DummyStencilView[1]);
     CheckVkResult(vkr);
 
+    NameVulkanObject(m_DummyStencilView[0], "m_DummyStencilView[1]");
+
     rm->SetInternalResource(GetResID(m_DummyStencilView[1]));
 
     VkCommandBuffer cmd = driver->GetNextCmd();
@@ -893,6 +901,8 @@ void VulkanDebugManager::CreateCustomShaderTex(uint32_t width, uint32_t height,
   vkr = m_pDriver->vkCreateImage(m_Device, &imInfo, NULL, &m_Custom.TexImg);
   CheckVkResult(vkr);
 
+  NameVulkanObject(m_Custom.TexImg, "m_Custom.TexImg");
+
   VkMemoryRequirements mrq = {0};
   m_pDriver->vkGetImageMemoryRequirements(m_Device, m_Custom.TexImg, &mrq);
 
@@ -939,6 +949,8 @@ void VulkanDebugManager::CreateCustomShaderTex(uint32_t width, uint32_t height,
     viewInfo.subresourceRange.baseMipLevel = i;
     vkr = m_pDriver->vkCreateImageView(m_Device, &viewInfo, NULL, &m_Custom.TexImgView[i]);
     CheckVkResult(vkr);
+
+    NameVulkanObject(m_Custom.TexImgView[i], "m_Custom.TexImgView[" + ToStr(i) + "]");
   }
 
   // need to update image layout into valid state
@@ -2001,6 +2013,8 @@ void VulkanDebugManager::FillWithDiscardPattern(VkCommandBuffer cmd, DiscardType
           VkImageView view;
           VkResult vkr = driver->vkCreateImageView(driver->GetDev(), &viewInfo, NULL, &view);
           CheckVkResult(vkr);
+          NameVulkanObject(view, StringFormat::Fmt("FillWithDiscardPattern view %s",
+                                                   ToStr(GetResID(image)).c_str()));
 
           imgdata.views.push_back(view);
 
@@ -3310,6 +3324,9 @@ void VulkanReplay::TextureRendering::Init(WrappedVulkan *driver, VkDescriptorPoo
         vkr = driver->vkCreateImage(driver->GetDev(), &imInfo, NULL, &DummyImages[fmt][type]);
         driver->CheckVkResult(vkr);
 
+        NameVulkanObject(DummyImages[fmt][type],
+                         "DummyImages[" + ToStr(fmt) + "][" + ToStr(type) + "]");
+
         MemoryAllocation alloc = driver->AllocateMemoryForResource(
             DummyImages[fmt][type], MemoryScope::ImmutableReplayDebug, MemoryType::GPULocal);
 
@@ -3421,6 +3438,9 @@ void VulkanReplay::TextureRendering::Init(WrappedVulkan *driver, VkDescriptorPoo
                                         &DummyImageViews[fmt][type]);
         driver->CheckVkResult(vkr);
 
+        NameVulkanObject(DummyImageViews[fmt][type],
+                         "DummyImageViews[" + ToStr(fmt) + "][" + ToStr(type) + "]");
+
         // the cubemap view we don't create an info for it, and the image is already transitioned
         if(cube)
           continue;
@@ -3836,6 +3856,8 @@ void VulkanReplay::PixelPicking::Init(WrappedVulkan *driver, VkDescriptorPool de
   vkr = driver->vkCreateImage(driver->GetDev(), &imInfo, NULL, &Image);
   driver->CheckVkResult(vkr);
 
+  NameVulkanObject(Image, "PixelPick.Image");
+
   VkMemoryRequirements mrq = {0};
   driver->vkGetImageMemoryRequirements(driver->GetDev(), Image, &mrq);
 
@@ -3868,6 +3890,8 @@ void VulkanReplay::PixelPicking::Init(WrappedVulkan *driver, VkDescriptorPool de
   vkr = driver->vkCreateImageView(driver->GetDev(), &viewInfo, NULL, &ImageView);
   driver->CheckVkResult(vkr);
 
+  NameVulkanObject(ImageView, "PixelPick.ImageView");
+
   // need to update image layout into valid state
 
   VkCommandBuffer cmd = driver->GetNextCmd();
@@ -4153,6 +4177,8 @@ void ShaderDebugData::Init(WrappedVulkan *driver, VkDescriptorPool descriptorPoo
   vkr = driver->vkCreateImage(driver->GetDev(), &imInfo, NULL, &Image);
   driver->CheckVkResult(vkr);
 
+  NameVulkanObject(Image, "ShaderDebugData.Image");
+
   VkMemoryRequirements mrq = {0};
   driver->vkGetImageMemoryRequirements(driver->GetDev(), Image, &mrq);
 
@@ -4185,6 +4211,8 @@ void ShaderDebugData::Init(WrappedVulkan *driver, VkDescriptorPool descriptorPoo
   vkr = driver->vkCreateImageView(driver->GetDev(), &viewInfo, NULL, &ImageView);
   driver->CheckVkResult(vkr);
 
+  NameVulkanObject(ImageView, "ShaderDebugData.ImageView");
+
   VkAttachmentDescription attDesc = {
       0,
       VK_FORMAT_R32G32B32A32_SFLOAT,

renderdoc/driver/vulkan/vk_initstate.cpp

@@ -157,6 +157,9 @@ bool WrappedVulkan::Prepare_InitialState(WrappedVkRes *res)
 
       GetResourceManager()->WrapResource(Unwrap(d), arrayIm);
 
+      NameUnwrappedVulkanObject(
+          arrayIm, StringFormat::Fmt("Initial State array image for %s", ToStr(id).c_str()));
+
       MemoryAllocation arrayMem =
           AllocateMemoryForResource(arrayIm, MemoryScope::InitialContents, MemoryType::GPULocal);
 
@@ -1616,6 +1619,9 @@ bool WrappedVulkan::Serialise_InitialState(SerialiserType &ser, ResourceId id, V
           vkr = vkCreateImage(d, &arrayInfo, NULL, &arrayIm);
           CheckVkResult(vkr);
 
+          NameVulkanObject(
+              arrayIm, StringFormat::Fmt("Initial State array image for %s", ToStr(id).c_str()));
+
           MemoryAllocation arrayMem =
               AllocateMemoryForResource(arrayIm, MemoryScope::InitialContents, MemoryType::GPULocal);
 

renderdoc/driver/vulkan/vk_msaa_array_conv.cpp

@@ -92,6 +92,7 @@ void VulkanDebugManager::CopyTex2DMSToArray(VkImage destArray, VkImage srcMS, Vk
 
   vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &srcView);
   CheckVkResult(vkr);
+  NameUnwrappedVulkanObject(srcView, "MS -> Array srcView");
 
   viewInfo.image = destArray;
   viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
@@ -128,6 +129,7 @@ void VulkanDebugManager::CopyTex2DMSToArray(VkImage destArray, VkImage srcMS, Vk
 
     vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &destView);
     CheckVkResult(vkr);
+    NameUnwrappedVulkanObject(destView, "MS -> Array destView");
 
     views.push_back(destView);
 
@@ -237,12 +239,14 @@ void VulkanDebugManager::CopyDepthTex2DMSToArray(VkImage destArray, VkImage srcM
 
   vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &srcDepthView);
   CheckVkResult(vkr);
+  NameUnwrappedVulkanObject(srcDepthView, "Depth MS -> Array srcDepthView");
 
   if(aspectFlags & VK_IMAGE_ASPECT_STENCIL_BIT)
   {
     viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
     vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &srcStencilView);
     CheckVkResult(vkr);
+    NameUnwrappedVulkanObject(srcStencilView, "Depth MS -> Array srcStencilView");
   }
 
   viewInfo.subresourceRange.aspectMask = aspectFlags;
@@ -260,6 +264,7 @@ void VulkanDebugManager::CopyDepthTex2DMSToArray(VkImage destArray, VkImage srcM
 
     vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &destView[i]);
     CheckVkResult(vkr);
+    NameUnwrappedVulkanObject(destView[i], "Depth MS -> Array destView[i]");
   }
 
   VkDescriptorImageInfo srcdesc[2];
@@ -488,12 +493,14 @@ void VulkanDebugManager::CopyArrayToTex2DMS(VkImage destMS, VkImage srcArray, Vk
 
   vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &srcView);
   CheckVkResult(vkr);
+  NameUnwrappedVulkanObject(srcView, "Array -> MS srcView");
 
   viewInfo.image = destMS;
   viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D_ARRAY;
 
   vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &destView);
   CheckVkResult(vkr);
+  NameUnwrappedVulkanObject(destView, "Array -> MS destView");
 
   VkDescriptorImageInfo srcdesc = {0};
   srcdesc.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
@@ -610,12 +617,14 @@ void VulkanDebugManager::CopyDepthArrayToTex2DMS(VkImage destMS, VkImage srcArra
 
   vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &srcDepthView);
   CheckVkResult(vkr);
+  NameUnwrappedVulkanObject(srcDepthView, "Depth Array -> MS srcDepthView");
 
   if(aspectFlags & VK_IMAGE_ASPECT_STENCIL_BIT)
   {
     viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT;
     vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &srcStencilView);
     CheckVkResult(vkr);
+    NameUnwrappedVulkanObject(srcStencilView, "Depth Array -> MS srcStencilView");
   }
 
   viewInfo.subresourceRange.aspectMask = aspectFlags;
@@ -633,6 +642,7 @@ void VulkanDebugManager::CopyDepthArrayToTex2DMS(VkImage destMS, VkImage srcArra
 
     vkr = ObjDisp(dev)->CreateImageView(Unwrap(dev), &viewInfo, NULL, &destView[i]);
     CheckVkResult(vkr);
+    NameUnwrappedVulkanObject(destView[i], "Depth Array -> MS destView[i]");
   }
 
   VkDescriptorImageInfo srcdesc[2];

renderdoc/driver/vulkan/vk_outputwindow.cpp

@@ -414,6 +414,8 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device,
 
     GetResourceManager()->WrapResource(Unwrap(device), dsimg);
 
+    NameVulkanObject(dsimg, "outputwindow dsimg");
+
     VkMemoryRequirements mrq = {0};
 
     vt->GetImageMemoryRequirements(Unwrap(device), Unwrap(dsimg), &mrq);
@@ -451,6 +453,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device,
 
     vkr = vt->CreateImageView(Unwrap(device), &info, NULL, &dsview);
     driver->CheckVkResult(vkr);
+    NameUnwrappedVulkanObject(dsview, "output window dsview");
 
     GetResourceManager()->WrapResource(Unwrap(device), dsview);
 
@@ -465,6 +468,8 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device,
 
     GetResourceManager()->WrapResource(Unwrap(device), resolveimg);
 
+    NameVulkanObject(resolveimg, "outputwindow resolveimg");
+
     vt->GetImageMemoryRequirements(Unwrap(device), Unwrap(resolveimg), &mrq);
 
     allocInfo.allocationSize = mrq.size;
@@ -561,6 +566,8 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device,
 
     GetResourceManager()->WrapResource(Unwrap(device), bb);
 
+    NameVulkanObject(bb, "outputwindow bb");
+
     VkMemoryRequirements mrq = {0};
 
     vt->GetImageMemoryRequirements(Unwrap(device), Unwrap(bb), &mrq);
@@ -600,6 +607,7 @@ void VulkanReplay::OutputWindow::Create(WrappedVulkan *driver, VkDevice device,
 
     vkr = vt->CreateImageView(Unwrap(device), &info, NULL, &bbview);
     driver->CheckVkResult(vkr);
+    NameUnwrappedVulkanObject(bbview, "output window bbview");
 
     GetResourceManager()->WrapResource(Unwrap(device), bbview);
 

renderdoc/driver/vulkan/vk_overlay.cpp

@@ -602,6 +602,8 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D
     vkr = m_pDriver->vkCreateImage(m_Device, &imInfo, NULL, &m_Overlay.Image);
     CheckVkResult(vkr);
 
+    NameVulkanObject(m_Overlay.Image, "m_Overlay.Image");
+
     VkMemoryRequirements mrq = {0};
     m_pDriver->vkGetImageMemoryRequirements(m_Device, m_Overlay.Image, &mrq);
 
@@ -2150,6 +2152,8 @@ ResourceId VulkanReplay::RenderOverlay(ResourceId texid, FloatVector clearCol, D
       vkr = m_pDriver->vkCreateImage(m_Device, &imInfo, NULL, &quadImg);
       CheckVkResult(vkr);
 
+      NameVulkanObject(quadImg, "m_Overlay.quadImg");
+
       VkMemoryRequirements mrq = {0};
 
       m_pDriver->vkGetImageMemoryRequirements(m_Device, quadImg, &mrq);

renderdoc/driver/vulkan/vk_rendertext.cpp

@@ -354,6 +354,8 @@ VulkanTextRenderer::VulkanTextRenderer(WrappedVulkan *driver)
       vkr = m_pDriver->vkCreateImage(dev, &imInfo, NULL, &m_TextAtlas);
       RDCASSERTEQUAL(vkr, VK_SUCCESS);
 
+      NameVulkanObject(m_TextAtlas, "m_TextAtlas");
+
       rm->SetInternalResource(GetResID(m_TextAtlas));
 
       VkMemoryRequirements mrq = {0};

renderdoc/driver/vulkan/vk_rendertexture.cpp

@@ -104,6 +104,8 @@ void VulkanReplay::CreateTexImageView(VkImage liveIm, const VulkanCreationInfo::
     // create first view
     vkr = m_pDriver->vkCreateImageView(dev, &viewInfo, NULL, &views.views[0]);
     CheckVkResult(vkr);
+    NameVulkanObject(views.views[0], StringFormat::Fmt("CreateTexImageView view 0 %s",
+                                                       ToStr(GetResID(liveIm)).c_str()));
 
     // for depth-stencil images, create a second view for stencil only
     if(IsDepthAndStencilFormat(fmt))
@@ -112,6 +114,8 @@ void VulkanReplay::CreateTexImageView(VkImage liveIm, const VulkanCreationInfo::
 
       vkr = m_pDriver->vkCreateImageView(dev, &viewInfo, NULL, &views.views[1]);
       CheckVkResult(vkr);
+      NameVulkanObject(views.views[1], StringFormat::Fmt("CreateTexImageView view 1 %s",
+                                                         ToStr(GetResID(liveIm)).c_str()));
     }
   }
 }

renderdoc/driver/vulkan/vk_replay.cpp

@@ -3368,6 +3368,8 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub,
     GetResourceManager()->WrapResource(Unwrap(dev), wrappedTmpImage);
     tmpImageState = ImageState(wrappedTmpImage, ImageInfo(imCreateInfo), eFrameRef_None);
 
+    NameVulkanObject(wrappedTmpImage, "GetTextureData tmpImage");
+
     VkMemoryRequirements mrq = {0};
     vt->GetImageMemoryRequirements(Unwrap(dev), tmpImage, &mrq);
 
@@ -3500,6 +3502,8 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub,
       vkr = vt->CreateImageView(Unwrap(dev), &viewInfo, NULL, &tmpView[i]);
       CheckVkResult(vkr);
 
+      NameUnwrappedVulkanObject(tmpView[i], "GetTextureData tmpView[i]");
+
       VkFramebufferCreateInfo fbinfo = {
           VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO,
           NULL,
@@ -3539,6 +3543,7 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub,
 
         vkr = vt->CreateImageView(Unwrap(dev), &viewInfo, NULL, &tmpView[i + numFBs]);
         CheckVkResult(vkr);
+        NameUnwrappedVulkanObject(tmpView[i + numFBs], "GetTextureData tmpView[i]");
         fbinfo.pAttachments = &tmpView[i + numFBs];
         vkr = vt->CreateFramebuffer(Unwrap(dev), &fbinfo, NULL, &tmpFB[i + numFBs]);
         CheckVkResult(vkr);
@@ -3596,6 +3601,8 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub,
     GetResourceManager()->WrapResource(Unwrap(dev), wrappedTmpImage);
     tmpImageState = ImageState(wrappedTmpImage, ImageInfo(imCreateInfo), eFrameRef_None);
 
+    NameVulkanObject(wrappedTmpImage, "GetTextureData tmpImage");
+
     VkMemoryRequirements mrq = {0};
     vt->GetImageMemoryRequirements(Unwrap(dev), tmpImage, &mrq);
 
@@ -3693,6 +3700,8 @@ void VulkanReplay::GetTextureData(ResourceId tex, const Subresource &sub,
     GetResourceManager()->WrapResource(Unwrap(dev), wrappedTmpImage);
     tmpImageState = ImageState(wrappedTmpImage, ImageInfo(imCreateInfo), eFrameRef_None);
 
+    NameVulkanObject(wrappedTmpImage, "GetTextureData tmpImage");
+
     VkMemoryRequirements mrq = {0};
     vt->GetImageMemoryRequirements(Unwrap(dev), tmpImage, &mrq);
 

renderdoc/driver/vulkan/vk_resources.h

@@ -2414,6 +2414,47 @@ uint32_t GetByteSize(uint32_t Width, uint32_t Height, uint32_t Depth, VkFormat F
 uint32_t GetPlaneByteSize(uint32_t Width, uint32_t Height, uint32_t Depth, VkFormat Format,
                           uint32_t mip, uint32_t plane);
 
+template <typename T>
+VkObjectType objType();
+
+template <typename T>
+void NameVulkanObject(T obj, const rdcstr &name)
+{
+  if(!VkMarkerRegion::vk)
+    return;
+
+  VkDevice dev = VkMarkerRegion::GetDev();
+
+  if(!ObjDisp(dev)->SetDebugUtilsObjectNameEXT)
+    return;
+
+  VkDebugUtilsObjectNameInfoEXT info = {};
+  info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
+  info.objectType = objType<T>();
+  info.objectHandle = NON_DISP_TO_UINT64(Unwrap(obj));
+  info.pObjectName = name.c_str();
+  ObjDisp(dev)->SetDebugUtilsObjectNameEXT(Unwrap(dev), &info);
+}
+
+template <typename T>
+void NameUnwrappedVulkanObject(T obj, const rdcstr &name)
+{
+  if(!VkMarkerRegion::vk)
+    return;
+
+  VkDevice dev = VkMarkerRegion::GetDev();
+
+  if(!ObjDisp(dev)->SetDebugUtilsObjectNameEXT)
+    return;
+
+  VkDebugUtilsObjectNameInfoEXT info = {};
+  info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
+  info.objectType = objType<T>();
+  info.objectHandle = NON_DISP_TO_UINT64(obj);
+  info.pObjectName = name.c_str();
+  ObjDisp(dev)->SetDebugUtilsObjectNameEXT(Unwrap(dev), &info);
+}
+
 template <typename Compose>
 FrameRefType MarkImageReferenced(rdcflatmap<ResourceId, ImgRefs> &imgRefs, ResourceId img,
                                  const ImageInfo &imageInfo, const ImageRange &range,