- hooked up the debug names for objects, which was a bit of a waste of time since the validation layer is brain dead and doesn't use the information in its messages..

src/rendering/vulkan/renderer/vk_postprocess.cpp

@@ -229,6 +229,7 @@ void VkPostprocess::BeginFrame()
 		builder.addPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 100);
 		builder.setMaxSets(100);
 		mDescriptorPool = builder.create(GetVulkanFrameBuffer()->device);
+		mDescriptorPool->SetDebugName("VkPostprocess.mDescriptorPool");
 	}
 }
 
@@ -277,11 +278,13 @@ void VkPostprocess::UpdateEffectTextures()
 			if (!imgbuilder.isFormatSupported(fb->device))
 				I_FatalError("Vulkan device does not support the image format required by %s\n", pair->Key.GetChars());
 			vktex->Image = imgbuilder.create(fb->device);
+			vktex->Image->SetDebugName(pair->Key.GetChars());
 			vktex->Format = format;
 
 			ImageViewBuilder viewbuilder;
 			viewbuilder.setImage(vktex->Image.get(), format);
 			vktex->View = viewbuilder.create(fb->device);
+			vktex->View->SetDebugName(pair->Key.GetChars());
 
 			if (desc.Data)
 			{
@@ -290,6 +293,7 @@ void VkPostprocess::UpdateEffectTextures()
 				stagingbuilder.setSize(totalsize);
 				stagingbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY);
 				vktex->Staging = stagingbuilder.create(fb->device);
+				vktex->Staging->SetDebugName(pair->Key.GetChars());
 
 				PipelineBarrier barrier0;
 				barrier0.addImage(vktex->Image.get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 0, VK_ACCESS_TRANSFER_WRITE_BIT);
@@ -345,10 +349,12 @@ void VkPostprocess::CompileEffectShaders()
 			ShaderBuilder vertbuilder;
 			vertbuilder.setVertexShader(LoadShaderCode(desc.VertexShader, "", desc.Version));
 			vkshader->VertexShader = vertbuilder.create(fb->device);
+			vkshader->VertexShader->SetDebugName(desc.VertexShader.GetChars());
 
 			ShaderBuilder fragbuilder;
 			fragbuilder.setFragmentShader(LoadShaderCode(desc.FragmentShader, prolog, desc.Version));
 			vkshader->FragmentShader = fragbuilder.create(fb->device);
+			vkshader->FragmentShader->SetDebugName(desc.FragmentShader.GetChars());
 		}
 	}
 }
@@ -439,6 +445,7 @@ VulkanDescriptorSet *VkPostprocess::GetInput(VkPPRenderPassSetup *passSetup, con
 {
 	auto fb = GetVulkanFrameBuffer();
 	auto descriptors = mDescriptorPool->allocate(passSetup->DescriptorLayout.get());
+	descriptors->SetDebugName("VkPostprocess.descriptors");
 
 	WriteDescriptors write;
 	PipelineBarrier barrier;
@@ -521,6 +528,7 @@ VulkanFramebuffer *VkPostprocess::GetOutput(VkPPRenderPassSetup *passSetup, cons
 		builder.setSize(w, h);
 		builder.addAttachment(view);
 		framebuffer = builder.create(GetVulkanFrameBuffer()->device);
+		framebuffer->SetDebugName(tex.debugname);
 	}
 
 	return framebuffer.get();
@@ -540,42 +548,49 @@ VkPostprocess::TextureImage VkPostprocess::GetTexture(const PPTextureType &type,
 		tex.image = fb->GetBuffers()->PipelineImage[idx].get();
 		tex.view = fb->GetBuffers()->PipelineView[idx].get();
 		tex.layout = &fb->GetBuffers()->PipelineLayout[idx];
+		tex.debugname = "PipelineTexture";
 	}
 	else if (type == PPTextureType::PPTexture)
 	{
 		tex.image = mTextures[name]->Image.get();
 		tex.view = mTextures[name]->View.get();
 		tex.layout = &mTextures[name]->Layout;
+		tex.debugname = name.GetChars();
 	}
 	else if (type == PPTextureType::SceneColor)
 	{
 		tex.image = fb->GetBuffers()->SceneColor.get();
 		tex.view = fb->GetBuffers()->SceneColorView.get();
 		tex.layout = &fb->GetBuffers()->SceneColorLayout;
+		tex.debugname = "SceneColor";
 	}
 	else if (type == PPTextureType::SceneNormal)
 	{
 		tex.image = fb->GetBuffers()->SceneNormal.get();
 		tex.view = fb->GetBuffers()->SceneNormalView.get();
 		tex.layout = &fb->GetBuffers()->SceneNormalLayout;
+		tex.debugname = "SceneNormal";
 	}
 	else if (type == PPTextureType::SceneFog)
 	{
 		tex.image = fb->GetBuffers()->SceneFog.get();
 		tex.view = fb->GetBuffers()->SceneFogView.get();
 		tex.layout = &fb->GetBuffers()->SceneFogLayout;
+		tex.debugname = "SceneFog";
 	}
 	else if (type == PPTextureType::SceneDepth)
 	{
 		tex.image = fb->GetBuffers()->SceneDepthStencil.get();
 		tex.view = fb->GetBuffers()->SceneDepthView.get();
 		tex.layout = &fb->GetBuffers()->SceneDepthStencilLayout;
+		tex.debugname = "SceneDepth";
 	}
 	else if (type == PPTextureType::SwapChain)
 	{
 		tex.image = nullptr;
 		tex.view = nullptr;
 		tex.layout = nullptr;
+		tex.debugname = "SwapChain";
 	}
 	else
 	{
@@ -598,6 +613,7 @@ VulkanSampler *VkPostprocess::GetSampler(PPFilterMode filter, PPWrapMode wrap)
 	builder.setMagFilter(filter == PPFilterMode::Nearest ? VK_FILTER_NEAREST : VK_FILTER_LINEAR);
 	builder.setAddressMode(wrap == PPWrapMode::Clamp ? VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE : VK_SAMPLER_ADDRESS_MODE_REPEAT);
 	sampler = builder.create(GetVulkanFrameBuffer()->device);
+	sampler->SetDebugName("VkPostprocess.mSamplers");
 	return sampler.get();
 }
 
@@ -621,6 +637,7 @@ void VkPPRenderPassSetup::CreateDescriptorLayout(const VkPPRenderPassKey &key)
 	for (int i = 0; i < key.InputTextures; i++)
 		builder.addBinding(i, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
 	DescriptorLayout = builder.create(GetVulkanFrameBuffer()->device);
+	DescriptorLayout->SetDebugName("VkPPRenderPassSetup.DescriptorLayout");
 }
 
 void VkPPRenderPassSetup::CreatePipelineLayout(const VkPPRenderPassKey &key)
@@ -630,6 +647,7 @@ void VkPPRenderPassSetup::CreatePipelineLayout(const VkPPRenderPassKey &key)
 	if (key.Uniforms > 0)
 		builder.addPushConstantRange(VK_SHADER_STAGE_FRAGMENT_BIT, 0, key.Uniforms);
 	PipelineLayout = builder.create(GetVulkanFrameBuffer()->device);
+	PipelineLayout->SetDebugName("VkPPRenderPassSetup.PipelineLayout");
 }
 
 void VkPPRenderPassSetup::CreatePipeline(const VkPPRenderPassKey &key)
@@ -648,6 +666,7 @@ void VkPPRenderPassSetup::CreatePipeline(const VkPPRenderPassKey &key)
 	builder.setLayout(PipelineLayout.get());
 	builder.setRenderPass(RenderPass.get());
 	Pipeline = builder.create(GetVulkanFrameBuffer()->device);
+	Pipeline->SetDebugName("VkPPRenderPassSetup.Pipeline");
 }
 
 void VkPPRenderPassSetup::CreateRenderPass(const VkPPRenderPassKey &key)
@@ -662,4 +681,5 @@ void VkPPRenderPassSetup::CreateRenderPass(const VkPPRenderPassKey &key)
 		VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
 		VK_ACCESS_COLOR_ATTACHMENT_READ_BIT);
 	RenderPass = builder.create(GetVulkanFrameBuffer()->device);
+	RenderPass->SetDebugName("VkPPRenderPassSetup.RenderPass");
 }

src/rendering/vulkan/renderer/vk_postprocess.h

@@ -64,6 +64,7 @@ private:
 		VulkanImage *image;
 		VulkanImageView *view;
 		VkImageLayout *layout;
+		const char *debugname;
 	};
 	TextureImage GetTexture(const PPTextureType &type, const PPTextureName &name);
 

src/rendering/vulkan/renderer/vk_renderbuffers.cpp

@@ -80,10 +80,12 @@ void VkRenderBuffers::CreatePipeline(int width, int height)
 		builder.setFormat(VK_FORMAT_R16G16B16A16_SFLOAT);
 		builder.setUsage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
 		PipelineImage[i] = builder.create(fb->device);
+		PipelineImage[i]->SetDebugName("VkRenderBuffers.PipelineImage");
 
 		ImageViewBuilder viewbuilder;
 		viewbuilder.setImage(PipelineImage[i].get(), VK_FORMAT_R16G16B16A16_SFLOAT);
 		PipelineView[i] = viewbuilder.create(fb->device);
+		PipelineView[i]->SetDebugName("VkRenderBuffers.PipelineView");
 
 		barrier.addImage(PipelineImage[i].get(), VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, 0, VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT);
 		PipelineLayout[i] = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
@@ -129,10 +131,12 @@ void VkRenderBuffers::CreateSceneColor(int width, int height, VkSampleCountFlagB
 	builder.setFormat(VK_FORMAT_R16G16B16A16_SFLOAT);
 	builder.setUsage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT);
 	SceneColor = builder.create(fb->device);
+	SceneColor->SetDebugName("VkRenderBuffers.SceneColor");
 
 	ImageViewBuilder viewbuilder;
 	viewbuilder.setImage(SceneColor.get(), VK_FORMAT_R16G16B16A16_SFLOAT);
 	SceneColorView = viewbuilder.create(fb->device);
+	SceneColorView->SetDebugName("VkRenderBuffers.SceneColorView");
 }
 
 void VkRenderBuffers::CreateSceneDepthStencil(int width, int height, VkSampleCountFlagBits samples)
@@ -154,13 +158,16 @@ void VkRenderBuffers::CreateSceneDepthStencil(int width, int height, VkSampleCou
 		}
 	}
 	SceneDepthStencil = builder.create(fb->device);
+	SceneDepthStencil->SetDebugName("VkRenderBuffers.SceneDepthStencil");
 
 	ImageViewBuilder viewbuilder;
 	viewbuilder.setImage(SceneDepthStencil.get(), SceneDepthStencilFormat, VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT);
 	SceneDepthStencilView = viewbuilder.create(fb->device);
+	SceneDepthStencilView->SetDebugName("VkRenderBuffers.SceneDepthStencilView");
 
 	viewbuilder.setImage(SceneDepthStencil.get(), SceneDepthStencilFormat, VK_IMAGE_ASPECT_DEPTH_BIT);
 	SceneDepthView = viewbuilder.create(fb->device);
+	SceneDepthView->SetDebugName("VkRenderBuffers.SceneDepthView");
 }
 
 void VkRenderBuffers::CreateSceneFog(int width, int height, VkSampleCountFlagBits samples)
@@ -173,10 +180,12 @@ void VkRenderBuffers::CreateSceneFog(int width, int height, VkSampleCountFlagBit
 	builder.setFormat(VK_FORMAT_R8G8B8A8_UNORM);
 	builder.setUsage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
 	SceneFog = builder.create(fb->device);
+	SceneFog->SetDebugName("VkRenderBuffers.SceneFog");
 
 	ImageViewBuilder viewbuilder;
 	viewbuilder.setImage(SceneFog.get(), VK_FORMAT_R8G8B8A8_UNORM);
 	SceneFogView = viewbuilder.create(fb->device);
+	SceneFogView->SetDebugName("VkRenderBuffers.SceneFogView");
 }
 
 void VkRenderBuffers::CreateSceneNormal(int width, int height, VkSampleCountFlagBits samples)
@@ -189,8 +198,10 @@ void VkRenderBuffers::CreateSceneNormal(int width, int height, VkSampleCountFlag
 	builder.setFormat(VK_FORMAT_A2R10G10B10_UNORM_PACK32);
 	builder.setUsage(VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
 	SceneNormal = builder.create(fb->device);
+	SceneNormal->SetDebugName("VkRenderBuffers.SceneNormal");
 
 	ImageViewBuilder viewbuilder;
 	viewbuilder.setImage(SceneNormal.get(), VK_FORMAT_A2R10G10B10_UNORM_PACK32);
 	SceneNormalView = viewbuilder.create(fb->device);
+	SceneNormalView->SetDebugName("VkRenderBuffers.SceneNormalView");
 }

src/rendering/vulkan/renderer/vk_renderpass.cpp

@@ -54,6 +54,7 @@ void VkRenderPassManager::BeginRenderPass(const VkRenderPassKey &key, VulkanComm
 		if (key.DepthTest || key.DepthWrite || key.StencilTest)
 			builder.addAttachment(buffers->SceneDepthStencilView.get());
 		framebuffer = builder.create(GetVulkanFrameBuffer()->device);
+		framebuffer->SetDebugName("VkRenderPassSetup.Framebuffer");
 	}
 
 	RenderPassBegin beginInfo;
@@ -116,6 +117,7 @@ void VkRenderPassManager::CreateDynamicSetLayout()
 	builder.addBinding(2, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT);
 	builder.addBinding(3, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC, 1, VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT);
 	DynamicSetLayout = builder.create(GetVulkanFrameBuffer()->device);
+	DynamicSetLayout->SetDebugName("VkRenderPassManager.DynamicSetLayout");
 }
 
 void VkRenderPassManager::CreateTextureSetLayout()
@@ -127,6 +129,7 @@ void VkRenderPassManager::CreateTextureSetLayout()
 	}
 	builder.addBinding(16, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1, VK_SHADER_STAGE_FRAGMENT_BIT);
 	TextureSetLayout = builder.create(GetVulkanFrameBuffer()->device);
+	TextureSetLayout->SetDebugName("VkRenderPassManager.TextureSetLayout");
 }
 
 void VkRenderPassManager::CreatePipelineLayout()
@@ -136,6 +139,7 @@ void VkRenderPassManager::CreatePipelineLayout()
 	builder.addSetLayout(TextureSetLayout.get());
 	builder.addPushConstantRange(VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT, 0, sizeof(PushConstants));
 	PipelineLayout = builder.create(GetVulkanFrameBuffer()->device);
+	PipelineLayout->SetDebugName("VkRenderPassManager.PipelineLayout");
 }
 
 void VkRenderPassManager::CreateDescriptorPool()
@@ -146,6 +150,7 @@ void VkRenderPassManager::CreateDescriptorPool()
 	builder.addPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 5000 * 6);
 	builder.setMaxSets(5000);
 	DescriptorPool = builder.create(GetVulkanFrameBuffer()->device);
+	DescriptorPool->SetDebugName("VkRenderPassManager.DescriptorPool");
 }
 
 void VkRenderPassManager::CreateDynamicSet()
@@ -195,6 +200,7 @@ void VkRenderPassSetup::CreateRenderPass(const VkRenderPassKey &key)
 			VK_ACCESS_COLOR_ATTACHMENT_READ_BIT);
 	}
 	RenderPass = builder.create(GetVulkanFrameBuffer()->device);
+	RenderPass->SetDebugName("VkRenderPassSetup.RenderPass");
 }
 
 void VkRenderPassSetup::CreatePipeline(const VkRenderPassKey &key)
@@ -281,4 +287,5 @@ void VkRenderPassSetup::CreatePipeline(const VkRenderPassKey &key)
 	builder.setLayout(fb->GetRenderPassManager()->PipelineLayout.get());
 	builder.setRenderPass(RenderPass.get());
 	Pipeline = builder.create(fb->device);
+	Pipeline->SetDebugName("VkRenderPassSetup.Pipeline");
 }

src/rendering/vulkan/system/vk_device.cpp

@@ -353,6 +353,8 @@ void VulkanDevice::CreateInstance()
 		result = vkCreateDebugUtilsMessengerEXT(instance, &createInfo, nullptr, &debugMessenger);
 		if (result != VK_SUCCESS)
 			throw std::runtime_error("vkCreateDebugUtilsMessengerEXT failed");
+
+		DebugLayerActive = true;
 	}
 }
 
@@ -367,10 +369,22 @@ VkBool32 VulkanDevice::DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT mess
 	std::unique_lock<std::mutex> lock(mtx);
 
 	FString msg = callbackData->pMessage;
+
+	// For patent-pending reasons the validation layer apparently can't do this itself..
+	for (uint32_t i = 0; i < callbackData->objectCount; i++)
+	{
+		if (callbackData->pObjects[i].pObjectName)
+		{
+			FString hexname;
+			hexname.Format("0x%x", callbackData->pObjects[i].objectHandle);
+			msg.Substitute(hexname.GetChars(), callbackData->pObjects[i].pObjectName);
+		}
+	}
+
 	bool found = seenMessages.find(msg) != seenMessages.end();
 	if (!found)
 	{
-		if (totalMessages < 100)
+		if (totalMessages < 20)
 		{
 			totalMessages++;
 			seenMessages.insert(msg);
@@ -399,7 +413,7 @@ VkBool32 VulkanDevice::DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT mess
 
 			Printf("\n");
 			Printf(TEXTCOLOR_RED "[%s] ", typestr);
-			Printf(TEXTCOLOR_WHITE "%s\n", callbackData->pMessage);
+			Printf(TEXTCOLOR_WHITE "%s\n", msg.GetChars());
 		}
 	}
 

src/rendering/vulkan/system/vk_device.h

@@ -44,6 +44,18 @@ public:
 	void BeginFrame();
 	void PresentFrame();
 
+	void SetDebugObjectName(const char *name, uint64_t handle, VkObjectType type)
+	{
+		if (!DebugLayerActive) return;
+
+		VkDebugUtilsObjectNameInfoEXT info = {};
+		info.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
+		info.objectHandle = handle;
+		info.objectType = type;
+		info.pObjectName = name;
+		vkSetDebugUtilsObjectNameEXT(device, &info);
+	}
+
 	uint32_t FindMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties);
 
 	// Instance setup
@@ -56,6 +68,7 @@ public:
 	VkPhysicalDeviceFeatures UsedDeviceFeatures = {};
 	std::vector<const char *> EnabledDeviceExtensions = { VK_KHR_SWAPCHAIN_EXTENSION_NAME };
 	VulkanPhysicalDevice PhysicalDevice;
+	bool DebugLayerActive = false;
 
 	VkInstance instance = VK_NULL_HANDLE;
 	VkSurfaceKHR surface = VK_NULL_HANDLE;

src/rendering/vulkan/system/vk_framebuffer.cpp

@@ -574,6 +574,7 @@ VulkanCommandBuffer *VulkanFrameBuffer::GetUploadCommands()
 	if (!mUploadCommands)
 	{
 		mUploadCommands = mGraphicsCommandPool->createBuffer();
+		mUploadCommands->SetDebugName("VulkanFrameBuffer.mUploadCommands");
 		mUploadCommands->begin();
 	}
 	return mUploadCommands.get();
@@ -584,6 +585,7 @@ VulkanCommandBuffer *VulkanFrameBuffer::GetDrawCommands()
 	if (!mDrawCommands)
 	{
 		mDrawCommands = mGraphicsCommandPool->createBuffer();
+		mDrawCommands->SetDebugName("VulkanFrameBuffer.mDrawCommands");
 		mDrawCommands->begin();
 	}
 	return mDrawCommands.get();

src/rendering/vulkan/system/vk_objects.h

@@ -11,6 +11,8 @@ public:
 	VulkanSemaphore(VulkanDevice *device);
 	~VulkanSemaphore();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)semaphore, VK_OBJECT_TYPE_SEMAPHORE); }
+
 	VulkanDevice *device = nullptr;
 	VkSemaphore semaphore = VK_NULL_HANDLE;
 
@@ -25,6 +27,8 @@ public:
 	VulkanFence(VulkanDevice *device);
 	~VulkanFence();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)fence, VK_OBJECT_TYPE_FENCE); }
+
 	VulkanDevice *device = nullptr;
 	VkFence fence = VK_NULL_HANDLE;
 
@@ -39,6 +43,8 @@ public:
 	VulkanBuffer(VulkanDevice *device, VkBuffer buffer, VmaAllocation allocation, size_t size);
 	~VulkanBuffer();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)buffer, VK_OBJECT_TYPE_BUFFER); }
+
 	VulkanDevice *device = nullptr;
 
 	VkBuffer buffer;
@@ -59,6 +65,8 @@ public:
 	VulkanFramebuffer(VulkanDevice *device, VkFramebuffer framebuffer);
 	~VulkanFramebuffer();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)framebuffer, VK_OBJECT_TYPE_FRAMEBUFFER); }
+
 	VulkanDevice *device;
 	VkFramebuffer framebuffer;
 
@@ -73,6 +81,8 @@ public:
 	VulkanImage(VulkanDevice *device, VkImage image, VmaAllocation allocation, int width, int height, int mipLevels);
 	~VulkanImage();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)image, VK_OBJECT_TYPE_IMAGE); }
+
 	VkImage image = VK_NULL_HANDLE;
 	int width = 0;
 	int height = 0;
@@ -95,6 +105,8 @@ public:
 	VulkanImageView(VulkanDevice *device, VkImageView view);
 	~VulkanImageView();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)view, VK_OBJECT_TYPE_IMAGE_VIEW); }
+
 	VkImageView view = VK_NULL_HANDLE;
 
 private:
@@ -110,6 +122,8 @@ public:
 	VulkanSampler(VulkanDevice *device, VkSampler sampler);
 	~VulkanSampler();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)sampler, VK_OBJECT_TYPE_SAMPLER); }
+
 	VkSampler sampler = VK_NULL_HANDLE;
 
 private:
@@ -125,6 +139,8 @@ public:
 	VulkanShader(VulkanDevice *device, VkShaderModule module);
 	~VulkanShader();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)module, VK_OBJECT_TYPE_SHADER_MODULE); }
+
 	VkShaderModule module = VK_NULL_HANDLE;
 
 private:
@@ -140,6 +156,8 @@ public:
 	VulkanDescriptorSetLayout(VulkanDevice *device, VkDescriptorSetLayout layout);
 	~VulkanDescriptorSetLayout();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)layout, VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT); }
+
 	VulkanDevice *device;
 	VkDescriptorSetLayout layout;
 
@@ -154,6 +172,8 @@ public:
 	VulkanDescriptorSet(VulkanDevice *device, VulkanDescriptorPool *pool, VkDescriptorSet set);
 	~VulkanDescriptorSet();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)set, VK_OBJECT_TYPE_DESCRIPTOR_SET); }
+
 	VulkanDevice *device;
 	VulkanDescriptorPool *pool;
 	VkDescriptorSet set;
@@ -169,6 +189,8 @@ public:
 	VulkanDescriptorPool(VulkanDevice *device, VkDescriptorPool pool);
 	~VulkanDescriptorPool();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)pool, VK_OBJECT_TYPE_DESCRIPTOR_POOL); }
+
 	std::unique_ptr<VulkanDescriptorSet> allocate(VulkanDescriptorSetLayout *layout);
 
 	VulkanDevice *device;
@@ -185,6 +207,8 @@ public:
 	VulkanPipeline(VulkanDevice *device, VkPipeline pipeline);
 	~VulkanPipeline();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)pipeline, VK_OBJECT_TYPE_PIPELINE); }
+
 	VulkanDevice *device;
 	VkPipeline pipeline;
 
@@ -199,6 +223,8 @@ public:
 	VulkanPipelineLayout(VulkanDevice *device, VkPipelineLayout layout);
 	~VulkanPipelineLayout();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)layout, VK_OBJECT_TYPE_PIPELINE_LAYOUT); }
+
 	VulkanDevice *device;
 	VkPipelineLayout layout;
 
@@ -213,6 +239,8 @@ public:
 	VulkanRenderPass(VulkanDevice *device, VkRenderPass renderPass);
 	~VulkanRenderPass();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)renderPass, VK_OBJECT_TYPE_RENDER_PASS); }
+
 	VulkanDevice *device;
 	VkRenderPass renderPass;
 
@@ -246,6 +274,8 @@ public:
 	VulkanCommandBuffer(VulkanCommandPool *pool);
 	~VulkanCommandBuffer();
 
+	void SetDebugName(const char *name);
+
 	void begin();
 	void end();
 
@@ -316,6 +346,8 @@ public:
 	VulkanCommandPool(VulkanDevice *device, int queueFamilyIndex);
 	~VulkanCommandPool();
 
+	void SetDebugName(const char *name) { device->SetDebugObjectName(name, (uint64_t)pool, VK_OBJECT_TYPE_COMMAND_POOL); }
+
 	std::unique_ptr<VulkanCommandBuffer> createBuffer();
 
 	VkCommandPool pool = VK_NULL_HANDLE;
@@ -802,6 +834,11 @@ inline void VulkanCommandBuffer::executeCommands(uint32_t commandBufferCount, co
 	vkCmdExecuteCommands(buffer, commandBufferCount, pCommandBuffers);
 }
 
+inline void VulkanCommandBuffer::SetDebugName(const char *name)
+{
+	pool->device->SetDebugObjectName(name, (uint64_t)buffer, VK_OBJECT_TYPE_COMMAND_BUFFER);
+}
+
 /////////////////////////////////////////////////////////////////////////////
 
 inline VulkanShader::VulkanShader(VulkanDevice *device, VkShaderModule module) : module(module), device(device)

src/rendering/vulkan/system/vk_swapchain.cpp

@@ -125,6 +125,8 @@ VulkanSwapChain::VulkanSwapChain(VulkanDevice *device, int width, int height, bo
 		swapChainImageViews.resize(swapChainImages.size());
 		for (size_t i = 0; i < swapChainImages.size(); i++)
 		{
+			device->SetDebugObjectName("SwapChainImage", (uint64_t)swapChainImages[i], VK_OBJECT_TYPE_IMAGE);
+
 			VkImageViewCreateInfo createInfo = {};
 			createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
 			createInfo.image = swapChainImages[i];
@@ -138,6 +140,8 @@ VulkanSwapChain::VulkanSwapChain(VulkanDevice *device, int width, int height, bo
 			result = vkCreateImageView(device->device, &createInfo, nullptr, &swapChainImageViews[i]);
 			if (result != VK_SUCCESS)
 				throw std::runtime_error("Could not create image view for swapchain image");
+
+			device->SetDebugObjectName("SwapChainImageView", (uint64_t)swapChainImageViews[i], VK_OBJECT_TYPE_IMAGE_VIEW);
 		}
 	}
 	catch (...)

src/rendering/vulkan/textures/vk_hwtexture.cpp

@@ -85,6 +85,7 @@ VulkanDescriptorSet *VkHardwareTexture::GetDescriptorSet(const FMaterialState &s
 		auto fb = GetVulkanFrameBuffer();
 
 		descriptorSet = fb->GetRenderPassManager()->DescriptorPool->allocate(fb->GetRenderPassManager()->TextureSetLayout.get());
+		descriptorSet->SetDebugName("VkHardwareTexture.mDescriptorSets");
 
 		VulkanSampler *sampler = fb->GetSamplerManager()->Get(clampmode);
 		int numLayers = mat->GetLayers();
@@ -149,6 +150,7 @@ void VkHardwareTexture::CreateTexture(int w, int h, int pixelsize, VkFormat form
 	bufbuilder.setSize(totalSize);
 	bufbuilder.setUsage(VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VMA_MEMORY_USAGE_CPU_ONLY);
 	mStagingBuffer = bufbuilder.create(fb->device);
+	mStagingBuffer->SetDebugName("VkHardwareTexture.mStagingBuffer");
 
 	uint8_t *data = (uint8_t*)mStagingBuffer->Map(0, totalSize);
 	memcpy(data, pixels, totalSize);
@@ -159,10 +161,12 @@ void VkHardwareTexture::CreateTexture(int w, int h, int pixelsize, VkFormat form
 	imgbuilder.setSize(w, h, GetMipLevels(w, h));
 	imgbuilder.setUsage(VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT);
 	mImage = imgbuilder.create(fb->device);
+	mImage->SetDebugName("VkHardwareTexture.mImage");
 
 	ImageViewBuilder viewbuilder;
 	viewbuilder.setImage(mImage.get(), format);
 	mImageView = viewbuilder.create(fb->device);
+	mImageView->SetDebugName("VkHardwareTexture.mImageView");
 
 	auto cmdbuffer = fb->GetUploadCommands();
 
@@ -250,12 +254,14 @@ void VkHardwareTexture::AllocateBuffer(int w, int h, int texelsize)
 		imgbuilder.setUsage(VK_IMAGE_USAGE_SAMPLED_BIT, VMA_MEMORY_USAGE_CPU_TO_GPU, VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT | VMA_ALLOCATION_CREATE_MAPPED_BIT);
 		imgbuilder.setLinearTiling();
 		mImage = imgbuilder.create(fb->device);
+		mImage->SetDebugName("VkHardwareTexture.mImage");
 		mImageLayout = VK_IMAGE_LAYOUT_GENERAL;
 		mTexelsize = texelsize;
 
 		ImageViewBuilder viewbuilder;
 		viewbuilder.setImage(mImage.get(), format);
 		mImageView = viewbuilder.create(fb->device);
+		mImageView->SetDebugName("VkHardwareTexture.mImageView");
 
 		auto cmdbuffer = fb->GetUploadCommands();
 

src/rendering/vulkan/textures/vk_samplers.cpp

@@ -102,6 +102,7 @@ void VkSamplerManager::Create()
 			builder.setMaxLod(0.25f);
 		}
 		mSamplers[i] = builder.create(vDevice);
+		mSamplers[i]->SetDebugName("VkSamplerManager.mSamplers");
     }
 }