Rejig extension handling and implement VK_LUNARG_DEBUG_MARKER support

* The WSI extensions should probably route through this method too

renderdoc/driver/vulkan/renderdoc.json

@@ -11,6 +11,13 @@
       "vkGetInstanceProcAddr": "RenderDoc_GetInstanceProcAddr",
       "vkGetDeviceProcAddr": "RenderDoc_GetDeviceProcAddr"
     },
+    "device_extensions": [
+      {
+        "name": "VK_LUNARG_DEBUG_MARKER",
+        "spec_version": "1",
+        "entrypoints": ["vkCmdDbgMarkerBegin", "vkCmdDbgMarkerEnd", "vkDbgSetObjectTag", "vkDbgSetObjectName"]
+      }
+    ],
     "enable_environment": {
       "ENABLE_VULKAN_RENDERDOC_CAPTURE": "1"
     },

renderdoc/driver/vulkan/vk_common.h

@@ -289,6 +289,8 @@ enum VulkanChunkType
 	SET_MARKER,
 	END_EVENT,
 
+	SET_NAME,
+
 	CREATE_SWAP_BUFFER,
 
 	CAPTURE_SCOPE,

renderdoc/driver/vulkan/vk_core.cpp

@@ -158,6 +158,8 @@ const char *VkChunkNames[] =
 	"vkCmdDbgMarker", // no equivalent function at the moment
 	"vkCmdDbgMarkerEnd",
 
+	"vkDbgSetObjectName",
+
 	"vkCreateSwapchainKHR",
 
 	"Capture",
@@ -1712,6 +1714,9 @@ void WrappedVulkan::ProcessChunk(uint64_t offset, VulkanChunkType context)
 	case END_EVENT:
 		Serialise_vkCmdDbgMarkerEnd(GetMainSerialiser(), VK_NULL_HANDLE);
 		break;
+	case SET_NAME:
+		Serialise_vkDbgSetObjectName(GetMainSerialiser(), VK_NULL_HANDLE, VK_OBJECT_TYPE_MAX_ENUM, 0, 0, NULL);
+		break;
 
 	case CREATE_SWAP_BUFFER:
 		Serialise_vkCreateSwapchainKHR(GetMainSerialiser(), VK_NULL_HANDLE, NULL, NULL, NULL);

renderdoc/driver/vulkan/vk_core.h

@@ -1358,7 +1358,7 @@ public:
 		VkRenderPass                                renderPass,
     const VkAllocationCallbacks*                pAllocator);
 
-	// Debug functions
+	// DEBUG_REPORT functions
 
 	IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDbgCreateMsgCallback,
     VkInstance                          instance,
@@ -1370,13 +1370,29 @@ public:
 	IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDbgDestroyMsgCallback,
     VkInstance                          instance,
     VkDbgMsgCallback                    msgCallback);
-	
+
+	// VK_LUNARG_DEBUG_MARKER functions
+
 	IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDbgMarkerBegin,
-		VkCommandBuffer  commandBuffer,
-		const char*     pMarker);
+		VkCommandBuffer commandBuffer,
+		const char* pMarker);
 
 	IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdDbgMarkerEnd,
-		VkCommandBuffer  commandBuffer);
+		VkCommandBuffer commandBuffer);
+
+	IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDbgSetObjectTag,
+		VkDevice device,
+		VkDbgObjectType objType,
+		uint64_t object,
+		size_t tagSize,
+		const void* pTag);
+
+	IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDbgSetObjectName,
+		VkDevice device,
+		VkDbgObjectType objType,
+		uint64_t object,
+		size_t nameSize,
+		const char* pName);
 
 	// Windowing extension functions
 

renderdoc/driver/vulkan/vk_dispatchtables.cpp

@@ -23,6 +23,7 @@
  ******************************************************************************/
 
 #include "vk_common.h"
+#include "vk_resources.h"
 #include "vk_hookset_defs.h"
 
 #include "os/os_specific.h"
@@ -30,8 +31,8 @@
 
 #include <unordered_map>
 
-static VkLayerDispatchTable replayDeviceTable = {0};
-static VkLayerInstanceDispatchTable replayInstanceTable = {0};
+static VkLayerDispatchTableExtended replayDeviceTable;
+static VkLayerInstanceDispatchTableExtended replayInstanceTable;
 
 static bool replay = false;
 
@@ -45,27 +46,29 @@ void InitReplayTables(void *vulkanModule)
 	#define HookInit(name) table.name = (CONCAT(PFN_vk, name))Process::GetFunctionAddress(vulkanModule, STRINGIZE(CONCAT(vk, name)))
 	
 	{
-		VkLayerDispatchTable &table = replayDeviceTable;
+		VkLayerDispatchTableExtended &table = replayDeviceTable;
+		memset(&table, 0, sizeof(table));
 		HookInit(GetDeviceProcAddr);
 		HookInitVulkanDevice();
 	}
 
 	{
-		VkLayerInstanceDispatchTable &table = replayInstanceTable;
+		VkLayerInstanceDispatchTableExtended &table = replayInstanceTable;
+		memset(&table, 0, sizeof(table));
 		HookInit(GetInstanceProcAddr);
 		HookInitVulkanInstance();
 	}
 }
 
+#define InstanceGPA(func) table->func = (CONCAT(PFN_vk, func))table->GetInstanceProcAddr(instance, STRINGIZE(CONCAT(vk, func)));
+
 void InitInstanceReplayTables(VkInstance instance)
 {
-	VkLayerInstanceDispatchTable *table = GetInstanceDispatchTable(NULL);
+	VkLayerInstanceDispatchTable *table = GetInstanceDispatchTable(instance);
 	RDCASSERT(table);
 
 	// we know we'll only have one instance, so this is safe
 	
-#define InstanceGPA(func) table->func = (CONCAT(PFN_vk, func))table->GetInstanceProcAddr(instance, STRINGIZE(CONCAT(vk, func)));
-	
 	InstanceGPA(GetPhysicalDeviceSurfaceCapabilitiesKHR)
 	InstanceGPA(GetPhysicalDeviceSurfaceFormatsKHR)
 	InstanceGPA(GetPhysicalDeviceSurfacePresentModesKHR)
@@ -86,33 +89,59 @@ void InitInstanceReplayTables(VkInstance instance)
 #endif
 	
 	InstanceGPA(DestroySurfaceKHR)
-
-#undef InstanceGPA
 }
 
+void InitInstanceExtensionTables(VkInstance instance)
+{
+	VkLayerInstanceDispatchTableExtended *table = GetInstanceDispatchTable(instance);
+	RDCASSERT(table);
+
+	InstanceDeviceInfo *info = GetRecord(instance)->instDevInfo;
+	
+#undef HookInitExtension
+#define HookInitExtension(ext, func) if(info->ext) { InstanceGPA(func); }
+
+	HookInitVulkanInstanceExts();
+}
+
+#undef InstanceGPA
+
+#define DeviceGPA(func) table->func = (CONCAT(PFN_vk, func))table->GetDeviceProcAddr(device, STRINGIZE(CONCAT(vk, func)));
+	
 void InitDeviceReplayTables(VkDevice device)
 {
-	VkLayerDispatchTable *table = GetDeviceDispatchTable(NULL);
+	VkLayerDispatchTable *table = GetDeviceDispatchTable(device);
 	RDCASSERT(table);
 	
 	// MULTIDEVICE each device will need a replay table
 
-#define DeviceGPA(func) table->func = (CONCAT(PFN_vk, func))table->GetDeviceProcAddr(device, STRINGIZE(CONCAT(vk, func)));
-	
 	DeviceGPA(CreateSwapchainKHR)
 	DeviceGPA(DestroySwapchainKHR)
 	DeviceGPA(GetSwapchainImagesKHR)
 	DeviceGPA(AcquireNextImageKHR)
 	DeviceGPA(QueuePresentKHR)
-
-#undef DeviceGPA
 }
 
+void InitDeviceExtensionTables(VkDevice device)
+{
+	VkLayerDispatchTableExtended *table = GetDeviceDispatchTable(device);
+	RDCASSERT(table);
+
+	InstanceDeviceInfo *info = GetRecord(device)->instDevInfo;
+
+#undef HookInitExtension
+#define HookInitExtension(ext, func) if(info->ext) { DeviceGPA(func); }
+
+	HookInitVulkanDeviceExts();
+}
+
+#undef DeviceGPA
+
 static Threading::CriticalSection devlock;
-std::map<void *, VkLayerDispatchTable> devlookup;
+std::map<void *, VkLayerDispatchTableExtended> devlookup;
 
 static Threading::CriticalSection instlock;
-std::map<void *, VkLayerInstanceDispatchTable> instlookup;
+std::map<void *, VkLayerInstanceDispatchTableExtended> instlookup;
 
 static void *GetKey(void *obj)
 {
@@ -124,7 +153,7 @@ void InitDeviceTable(const VkBaseLayerObject *obj)
 {
 	void *key = GetKey(obj->baseObject);
 	
-	VkLayerDispatchTable *table = NULL;
+	VkLayerDispatchTableExtended *table = NULL;
 
 	{
 		SCOPED_LOCK(devlock);
@@ -146,7 +175,7 @@ void InitInstanceTable(const VkBaseLayerObject *obj)
 {
 	void *key = GetKey(obj->baseObject);
 	
-	VkLayerInstanceDispatchTable *table = NULL;
+	VkLayerInstanceDispatchTableExtended *table = NULL;
 
 	{
 		SCOPED_LOCK(instlock);
@@ -168,7 +197,7 @@ void InitInstanceTable(const VkBaseLayerObject *obj)
 	HookInit(EnumerateDeviceLayerProperties);
 }
 
-VkLayerDispatchTable *GetDeviceDispatchTable(void *device)
+VkLayerDispatchTableExtended *GetDeviceDispatchTable(void *device)
 {
 	if(replay) return &replayDeviceTable;
 
@@ -186,7 +215,7 @@ VkLayerDispatchTable *GetDeviceDispatchTable(void *device)
 	}
 }
 
-VkLayerInstanceDispatchTable *GetInstanceDispatchTable(void *instance)
+VkLayerInstanceDispatchTableExtended *GetInstanceDispatchTable(void *instance)
 {
 	if(replay) return &replayInstanceTable;
 

renderdoc/driver/vulkan/vk_dispatchtables.h

@@ -34,12 +34,18 @@
 
 #include <vulkan/vk_layer.h>
 
+#include "vk_hookset_defs.h"
+
 void InitReplayTables(void *vulkanModule);
+
 void InitInstanceReplayTables(VkInstance instance);
 void InitDeviceReplayTables(VkDevice device);
 
-VkLayerDispatchTable *GetDeviceDispatchTable(void *device);
-VkLayerInstanceDispatchTable *GetInstanceDispatchTable(void *instance);
+void InitInstanceExtensionTables(VkInstance instance);
+void InitDeviceExtensionTables(VkDevice device);
+
+VkLayerDispatchTableExtended *GetDeviceDispatchTable(void *device);
+VkLayerInstanceDispatchTableExtended *GetInstanceDispatchTable(void *instance);
 
 class WrappedVulkan;
 

renderdoc/driver/vulkan/vk_hookset_defs.h

@@ -223,6 +223,19 @@
 	HookInit(AcquireNextImageKHR); \
 	HookInit(QueuePresentKHR);
 
+#define CheckInstanceExts()
+
+#define CheckDeviceExts() \
+	CheckExt(VK_LUNARG_DEBUG_MARKER)
+
+#define HookInitVulkanInstanceExts()
+
+#define HookInitVulkanDeviceExts() \
+	HookInitExtension(VK_LUNARG_DEBUG_MARKER, CmdDbgMarkerBegin); \
+	HookInitExtension(VK_LUNARG_DEBUG_MARKER, CmdDbgMarkerEnd); \
+	HookInitExtension(VK_LUNARG_DEBUG_MARKER, DbgSetObjectTag); \
+	HookInitExtension(VK_LUNARG_DEBUG_MARKER, DbgSetObjectName);
+
 #define DefineHooks() \
 	HookDefine3(VkResult, vkEnumeratePhysicalDevices, VkInstance, instance, uint32_t*, pPhysicalDeviceCount, VkPhysicalDevice*, pPhysicalDevices); \
 	HookDefine2(void, vkGetPhysicalDeviceFeatures, VkPhysicalDevice, physicalDevice, VkPhysicalDeviceFeatures*, pFeatures); \
@@ -355,6 +368,10 @@
 	HookDefine1(void, vkCmdEndRenderPass, VkCommandBuffer, commandBuffer); \
 	HookDefine5(VkResult, vkDbgCreateMsgCallback, VkInstance, instance, VkFlags, msgFlags, const PFN_vkDbgMsgCallback, pfnMsgCallback, void*, pUserData, VkDbgMsgCallback*, pMsgCallback); \
 	HookDefine2(VkResult, vkDbgDestroyMsgCallback, VkInstance, instance, VkDbgMsgCallback, msgCallback); \
+	HookDefine2(void, vkCmdDbgMarkerBegin, VkCommandBuffer, commandBuffer, const char*, pMarker); \
+	HookDefine1(void, vkCmdDbgMarkerEnd, VkCommandBuffer, commandBuffer); \
+	HookDefine5(VkResult, vkDbgSetObjectTag, VkDevice, device, VkDbgObjectType, objType, uint64_t, object, size_t, tagSize, const void*, pTag); \
+	HookDefine5(VkResult, vkDbgSetObjectName, VkDevice, device, VkDbgObjectType, objType, uint64_t, object, size_t, nameSize, const char*, pName); \
 	HookDefine4(VkResult, vkGetPhysicalDeviceSurfaceSupportKHR, VkPhysicalDevice, physicalDevice, uint32_t, queueFamilyIndex, VkSurfaceKHR, surface, VkBool32*, pSupported); \
 	HookDefine3(VkResult, vkGetPhysicalDeviceSurfaceCapabilitiesKHR, VkPhysicalDevice, physicalDevice, VkSurfaceKHR, surface, VkSurfaceCapabilitiesKHR*, pSurfaceProperties); \
 	HookDefine4(VkResult, vkGetPhysicalDeviceSurfaceFormatsKHR, VkPhysicalDevice, physicalDevice, VkSurfaceKHR, surface, uint32_t*, pSurfaceFormatCount, VkSurfaceFormatKHR*, pSurfaceFormats); \
@@ -366,3 +383,17 @@
 	HookDefine2(VkResult, vkQueuePresentKHR, VkQueue, queue, VkPresentInfoKHR*, pPresentInfo); \
 	HookDefine3(void, vkDestroySurfaceKHR, VkInstance, instance, VkSurfaceKHR, surface, const VkAllocationCallbacks*, pAllocator); \
 	HookDefine_PlatformSpecific()
+
+struct VkLayerInstanceDispatchTableExtended : VkLayerInstanceDispatchTable
+{
+	// extensions here
+};
+
+struct VkLayerDispatchTableExtended : VkLayerDispatchTable
+{
+	// VK_LUNARG_DEBUG_MARKER
+	PFN_vkCmdDbgMarkerBegin CmdDbgMarkerBegin;
+	PFN_vkCmdDbgMarkerEnd CmdDbgMarkerEnd;
+	PFN_vkDbgSetObjectTag DbgSetObjectTag;
+	PFN_vkDbgSetObjectName DbgSetObjectName;
+};

renderdoc/driver/vulkan/vk_replay.cpp

@@ -2773,8 +2773,15 @@ void VulkanReplay::SavePipelineState()
 				stages[i]->Shader = rm->GetOriginalID(p.shaders[i].module);
 				stages[i]->entryPoint = p.shaders[i].entryPoint;
 				stages[i]->ShaderDetails = NULL;
-				stages[i]->customName = false;
-				stages[i]->ShaderName = StringFormat::Fmt("Shader %llu", stages[i]->Shader);
+
+				stages[i]->customName = true;
+				stages[i]->ShaderName = m_pDriver->m_CreationInfo.m_Names[p.shaders[i].module];
+				if(stages[i]->ShaderName.count == 0)
+				{
+					stages[i]->customName = false;
+					stages[i]->ShaderName = StringFormat::Fmt("Shader %llu", stages[i]->Shader);
+				}
+
 				stages[i]->stage = ShaderStageType(eShaderStage_Vertex + i);
 				if(p.shaders[i].mapping)
 					stages[i]->BindpointMapping = *p.shaders[i].mapping;

renderdoc/driver/vulkan/vk_resources.cpp

@@ -590,6 +590,9 @@ VkResourceRecord::~VkResourceRecord()
 	if(resType == eResBuffer || resType == eResImage)
 		SAFE_DELETE(sparseInfo);
 
+	if(resType == eResInstance || resType == eResDevice)
+		SAFE_DELETE(instDevInfo);
+
 	if(resType == eResSwapchain)
 		SAFE_DELETE(swapInfo);
 

renderdoc/driver/vulkan/vk_resources.h

@@ -28,6 +28,7 @@
 #include "common/wrapped_pool.h"
 
 #include "vk_common.h"
+#include "vk_hookset_defs.h"
 
 struct VkResourceRecord;
 
@@ -180,7 +181,7 @@ struct WrappedVkInstance : WrappedVkDispRes
 {
 	WrappedVkInstance(VkInstance obj, ResourceId objId) : WrappedVkDispRes(obj, objId) {}
 	typedef VkInstance InnerType; ALLOCATE_WITH_WRAPPED_POOL(WrappedVkInstance);
-	typedef VkLayerInstanceDispatchTable DispatchTableType;
+	typedef VkLayerInstanceDispatchTableExtended DispatchTableType;
 	enum { UseInstanceDispatchTable = true, };
 	enum { TypeEnum = eResInstance, };
 };
@@ -188,7 +189,7 @@ struct WrappedVkPhysicalDevice : WrappedVkDispRes
 {
 	WrappedVkPhysicalDevice(VkPhysicalDevice obj, ResourceId objId) : WrappedVkDispRes(obj, objId) {}
 	typedef VkPhysicalDevice InnerType; ALLOCATE_WITH_WRAPPED_POOL(WrappedVkPhysicalDevice);
-	typedef VkLayerInstanceDispatchTable DispatchTableType;
+	typedef VkLayerInstanceDispatchTableExtended DispatchTableType;
 	enum { UseInstanceDispatchTable = true, };
 	enum { TypeEnum = eResPhysicalDevice, };
 };
@@ -196,7 +197,7 @@ struct WrappedVkDevice : WrappedVkDispRes
 {
 	WrappedVkDevice(VkDevice obj, ResourceId objId) : WrappedVkDispRes(obj, objId) {}
 	typedef VkDevice InnerType; ALLOCATE_WITH_WRAPPED_POOL(WrappedVkDevice);
-	typedef VkLayerDispatchTable DispatchTableType;
+	typedef VkLayerDispatchTableExtended DispatchTableType;
 	enum { UseInstanceDispatchTable = false, };
 	enum { TypeEnum = eResDevice, };
 };
@@ -204,7 +205,7 @@ struct WrappedVkQueue : WrappedVkDispRes
 {
 	WrappedVkQueue(VkQueue obj, ResourceId objId) : WrappedVkDispRes(obj, objId) {}
 	typedef VkQueue InnerType; ALLOCATE_WITH_WRAPPED_POOL(WrappedVkQueue);
-	typedef VkLayerDispatchTable DispatchTableType;
+	typedef VkLayerDispatchTableExtended DispatchTableType;
 	enum { UseInstanceDispatchTable = false, };
 	enum { TypeEnum = eResQueue, };
 };
@@ -215,7 +216,7 @@ struct WrappedVkCommandBuffer : WrappedVkDispRes
 	static const int AllocPoolCount = 32*1024;
 	static const int AllocPoolMaxByteSize = 2*1024*1024;
 	ALLOCATE_WITH_WRAPPED_POOL(WrappedVkCommandBuffer, AllocPoolCount, AllocPoolMaxByteSize);
-	typedef VkLayerDispatchTable DispatchTableType;
+	typedef VkLayerDispatchTableExtended DispatchTableType;
 	enum { UseInstanceDispatchTable = false, };
 	enum { TypeEnum = eResCommandBuffer, };
 };
@@ -592,6 +593,19 @@ struct SwapchainInfo
 	uint32_t lastPresent;
 };
 
+struct InstanceDeviceInfo
+{
+#undef CheckExt
+#define CheckExt(name) name = false;
+	InstanceDeviceInfo() { CheckDeviceExts(); CheckInstanceExts(); }
+
+#undef CheckExt
+#define CheckExt(name) bool name;
+
+	CheckDeviceExts();
+	CheckInstanceExts();
+};
+
 struct SparseMapping
 {
 	SparseMapping()
@@ -780,6 +794,7 @@ struct VkResourceRecord : public ResourceRecord
 		{
 			void *ptrunion;                               // for initialisation to NULL
 			VkPhysicalDeviceMemoryProperties *memProps;   // only for physical devices
+			InstanceDeviceInfo *instDevInfo;                  // only for logical devices or instances
 			SparseMapping *sparseInfo;                    // only for buffers, images, and views of them
 			SwapchainInfo *swapInfo;                      // only for swapchains
 			MemMapState *memMapState;                     // only for device memory

renderdoc/driver/vulkan/vk_tracelayer.cpp

@@ -169,6 +169,9 @@ VK_LAYER_EXPORT VkResult VKAPI_CALL RenderDocEnumerateDeviceExtensionProperties(
 #undef HookInit
 #define HookInit(function) if (!strcmp(pName, STRINGIZE(CONCAT(vk, function)))) return (PFN_vkVoidFunction) &CONCAT(hooked_vk, function);
 
+#undef HookInitExtension
+#define HookInitExtension(ext, function) if (instDevInfo->ext && !strcmp(pName, STRINGIZE(CONCAT(vk, function)))) return (PFN_vkVoidFunction) &CONCAT(hooked_vk, function);
+
 // proc addr routines
 
 VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI_CALL RenderDoc_GetDeviceProcAddr(VkDevice device, const char* pName)
@@ -189,6 +192,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI_CALL RenderDoc_GetDeviceProcAddr(VkDevi
 
 	HookInitVulkanDevice();
 
+	InstanceDeviceInfo *instDevInfo = GetRecord(device)->instDevInfo;
+
+	HookInitVulkanDeviceExts();
+
 	if (GetDeviceDispatchTable(device)->GetDeviceProcAddr == NULL)
 		return NULL;
 	return GetDeviceDispatchTable(device)->GetDeviceProcAddr(device, pName);

renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp

@@ -520,6 +520,17 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(Serialiser* localSerialiser, Vk
 		GetResourceManager()->RemoveReplacement(cmdid);
 
 		ObjDisp(commandBuffer)->EndCommandBuffer(Unwrap(commandBuffer));
+		
+		if(m_State == READING && !m_BakedCmdBufferInfo[m_LastCmdBufferID].curEvents.empty())
+		{
+			FetchDrawcall draw;
+			draw.name = "API Calls";
+			draw.flags |= eDraw_SetMarker;
+
+			AddDrawcall(draw, true);
+
+			m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID++;
+		}
 
 		{
 			if(GetDrawcallStack().size() > 1)
@@ -528,6 +539,7 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(Serialiser* localSerialiser, Vk
 
 		{
 			m_BakedCmdBufferInfo[bakeId].draw = m_BakedCmdBufferInfo[m_LastCmdBufferID].draw;
+			m_BakedCmdBufferInfo[bakeId].curEvents = m_BakedCmdBufferInfo[m_LastCmdBufferID].curEvents;
 			m_BakedCmdBufferInfo[bakeId].curEventID = 0;
 			m_BakedCmdBufferInfo[bakeId].eventCount = m_BakedCmdBufferInfo[m_LastCmdBufferID].curEventID;
 			m_BakedCmdBufferInfo[bakeId].drawCount = m_BakedCmdBufferInfo[m_LastCmdBufferID].drawCount;
@@ -2069,6 +2081,9 @@ void WrappedVulkan::vkCmdDbgMarkerBegin(
 			VkCommandBuffer  commandBuffer,
 			const char*     pMarker)
 {
+	if(ObjDisp(commandBuffer)->CmdDbgMarkerBegin)
+		ObjDisp(commandBuffer)->CmdDbgMarkerBegin(Unwrap(commandBuffer), pMarker);
+	
 	if(m_State >= WRITING)
 	{
 		VkResourceRecord *record = GetRecord(commandBuffer);
@@ -2104,6 +2119,9 @@ bool WrappedVulkan::Serialise_vkCmdDbgMarkerEnd(Serialiser* localSerialiser, VkC
 void WrappedVulkan::vkCmdDbgMarkerEnd(
 	VkCommandBuffer  commandBuffer)
 {
+	if(ObjDisp(commandBuffer)->CmdDbgMarkerEnd)
+		ObjDisp(commandBuffer)->CmdDbgMarkerEnd(Unwrap(commandBuffer));
+	
 	if(m_State >= WRITING)
 	{
 		VkResourceRecord *record = GetRecord(commandBuffer);

renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp

@@ -147,7 +147,19 @@ VkResult WrappedVulkan::vkCreateInstance(
 	RDCASSERT(m_State >= WRITING);
 
 	m_InitParams.Set(pCreateInfo, GetResID(m_Instance));
-	GetResourceManager()->AddResourceRecord(m_Instance);
+	VkResourceRecord *record = GetResourceManager()->AddResourceRecord(m_Instance);
+
+	record->instDevInfo = new InstanceDeviceInfo();
+	
+#undef CheckExt
+#define CheckExt(name) if(!strcmp(pCreateInfo->ppEnabledExtensionNames[i], STRINGIZE(name))) { record->instDevInfo->name = true; }
+
+	for(uint32_t i=0; i < pCreateInfo->enabledExtensionNameCount; i++)
+	{
+		CheckInstanceExts();
+	}
+
+	InitInstanceExtensionTables(m_Instance);
 
 	*pInstance = m_Instance;
 	
@@ -423,6 +435,19 @@ bool WrappedVulkan::Serialise_vkCreateDevice(
 				createInfo.enabledLayerNameCount--;
 			}
 		}
+
+		// disable this extension as we might have captured it but we don't need
+		// to replay it
+		for(uint32_t i=0; i < createInfo.enabledExtensionNameCount; i++)
+		{
+			const char **extNames = (const char **)createInfo.ppEnabledExtensionNames;
+			if(!strcmp(extNames[i], DEBUG_MARKER_EXTENSION_NAME))
+			{
+				for(uint32_t j=i; j < createInfo.enabledExtensionNameCount-1; j++)
+					extNames[j] = extNames[j+1];
+				createInfo.enabledExtensionNameCount--;
+			}
+		}
 		
 #if defined(FORCE_VALIDATION_LAYERS)
 		vector<const char *> layers;
@@ -712,6 +737,18 @@ VkResult WrappedVulkan::vkCreateDevice(
 
 			record->memIdxMap = GetRecord(physicalDevice)->memIdxMap;
 
+			record->instDevInfo = new InstanceDeviceInfo();
+
+#undef CheckExt
+#define CheckExt(name) if(!strcmp(createInfo.ppEnabledExtensionNames[i], STRINGIZE(name))) { record->instDevInfo->name = true; }
+
+			for(uint32_t i=0; i < createInfo.enabledExtensionNameCount; i++)
+			{
+				CheckDeviceExts();
+			}
+		
+			InitDeviceExtensionTables(*pDevice);
+
 			GetRecord(m_Instance)->AddParent(record);
 		}
 		else

renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp

@@ -778,3 +778,142 @@ VkResult WrappedVulkan::vkDbgDestroyMsgCallback(
 	return ObjDisp(instance)->DbgDestroyMsgCallback(Unwrap(instance), msgCallback);
 }
 
+VkResult WrappedVulkan::vkDbgSetObjectTag(
+		VkDevice device,
+		VkDbgObjectType objType,
+		uint64_t object,
+		size_t tagSize,
+		const void* pTag)
+{
+	if(ObjDisp(device)->DbgSetObjectTag)
+		ObjDisp(device)->DbgSetObjectTag(device, objType, object, tagSize, pTag);
+
+	// don't do anything with the tags
+
+	return VK_SUCCESS;
+}
+
+static VkResourceRecord *GetObjRecord(VkDbgObjectType objType, uint64_t object)
+{
+	switch(objType)
+	{
+		case VK_OBJECT_TYPE_INSTANCE:
+			return GetRecord((VkInstance)object);
+		case VK_OBJECT_TYPE_PHYSICAL_DEVICE:
+			return GetRecord((VkPhysicalDevice)object);
+		case VK_OBJECT_TYPE_DEVICE:
+			return GetRecord((VkDevice)object);
+		case VK_OBJECT_TYPE_QUEUE:
+			return GetRecord((VkQueue)object);
+		case VK_OBJECT_TYPE_COMMAND_BUFFER:
+			return GetRecord((VkCommandBuffer)object);
+		case VK_OBJECT_TYPE_DEVICE_MEMORY:
+			return GetRecord((VkDeviceMemory)object);
+		case VK_OBJECT_TYPE_BUFFER:
+			return GetRecord((VkBuffer)object);
+		case VK_OBJECT_TYPE_BUFFER_VIEW:
+			return GetRecord((VkBufferView)object);
+		case VK_OBJECT_TYPE_IMAGE:
+			return GetRecord((VkImage)object);
+		case VK_OBJECT_TYPE_IMAGE_VIEW:
+			return GetRecord((VkImageView)object);
+		case VK_OBJECT_TYPE_ATTACHMENT_VIEW:
+			return NULL;
+		case VK_OBJECT_TYPE_SHADER_MODULE:
+			return GetRecord((VkShaderModule)object);
+		case VK_OBJECT_TYPE_SHADER:
+			return NULL;
+		case VK_OBJECT_TYPE_PIPELINE:
+			return GetRecord((VkPipeline)object);
+		case VK_OBJECT_TYPE_PIPELINE_LAYOUT:
+			return GetRecord((VkPipelineLayout)object);
+		case VK_OBJECT_TYPE_SAMPLER:
+			return GetRecord((VkSampler)object);
+		case VK_OBJECT_TYPE_DESCRIPTOR_SET:
+			return GetRecord((VkDescriptorSet)object);
+		case VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT:
+			return GetRecord((VkDescriptorSetLayout)object);
+		case VK_OBJECT_TYPE_DESCRIPTOR_POOL:
+			return GetRecord((VkDescriptorPool)object);
+		case VK_OBJECT_TYPE_FENCE:
+			return GetRecord((VkFence)object);
+		case VK_OBJECT_TYPE_SEMAPHORE:
+			return GetRecord((VkSemaphore)object);
+		case VK_OBJECT_TYPE_EVENT:
+			return GetRecord((VkEvent)object);
+		case VK_OBJECT_TYPE_QUERY_POOL:
+			return GetRecord((VkQueryPool)object);
+		case VK_OBJECT_TYPE_FRAMEBUFFER:
+			return GetRecord((VkFramebuffer)object);
+		case VK_OBJECT_TYPE_RENDER_PASS:
+			return GetRecord((VkRenderPass)object);
+		case VK_OBJECT_TYPE_PIPELINE_CACHE:
+			return GetRecord((VkPipelineCache)object);
+		case VK_OBJECT_TYPE_SURFACE_KHR:
+			return GetRecord((VkSurfaceKHR)object);
+		case VK_OBJECT_TYPE_SWAPCHAIN_KHR:
+			return GetRecord((VkSwapchainKHR)object);
+		case VK_OBJECT_TYPE_COMMAND_POOL:
+			return GetRecord((VkCommandPool)object);
+	}
+	return NULL;
+}
+
+bool WrappedVulkan::Serialise_vkDbgSetObjectName(
+		Serialiser *localSerialiser,
+		VkDevice device,
+		VkDbgObjectType objType,
+		uint64_t object,
+		size_t nameSize,
+		const char* pName)
+{
+	SERIALISE_ELEMENT(ResourceId, id, GetObjRecord(objType, object)->GetResourceID());
+	
+	string name;
+	if(m_State >= WRITING)
+		name = string(pName, pName+nameSize);
+
+	localSerialiser->Serialise("name", name);
+
+	if(m_State == READING)
+		m_CreationInfo.m_Names[GetResourceManager()->GetLiveID(id)] = name;
+
+	return true;
+}
+
+VkResult WrappedVulkan::vkDbgSetObjectName(
+		VkDevice device,
+		VkDbgObjectType objType,
+		uint64_t object,
+		size_t nameSize,
+		const char* pName)
+{
+	if(ObjDisp(device)->DbgSetObjectName)
+		ObjDisp(device)->DbgSetObjectName(device, objType, object, nameSize, pName);
+	
+	if(m_State >= WRITING)
+	{
+		Chunk *chunk = NULL;
+		
+		VkResourceRecord *record = GetObjRecord(objType, object);
+
+		if(!record)
+		{
+			RDCERR("Unrecognised object %d %llu", objType, object);
+			return VK_SUCCESS;
+		}
+
+		{
+			CACHE_THREAD_SERIALISER();
+
+			SCOPED_SERIALISE_CONTEXT(SET_NAME);
+			Serialise_vkDbgSetObjectName(localSerialiser, device, objType, object, nameSize, pName);
+
+			chunk = scope.Get();
+		}
+
+		record->AddChunk(chunk);
+	}
+
+	return VK_SUCCESS;
+}

renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp

@@ -374,6 +374,7 @@ void WrappedVulkan::InsertDrawsAndRefreshIDs(vector<DrawcallTreeNode> &nodes, ve
 		auto it = std::lower_bound(m_DrawcallUses.begin(), m_DrawcallUses.end(), use);
 		m_DrawcallUses.insert(it, use);
 
+		n.children.clear();
 		InsertDrawsAndRefreshIDs(n.children, cmdBufNodes[i].children, baseEventID, baseDrawID);
 
 		nodes.push_back(n);