diff --git a/renderdoc/driver/vulkan/renderdoc.json b/renderdoc/driver/vulkan/renderdoc.json index b5a2c6525..5e4604914 100644 --- a/renderdoc/driver/vulkan/renderdoc.json +++ b/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" }, diff --git a/renderdoc/driver/vulkan/vk_common.h b/renderdoc/driver/vulkan/vk_common.h index 9f2802caa..597c8d1d9 100644 --- a/renderdoc/driver/vulkan/vk_common.h +++ b/renderdoc/driver/vulkan/vk_common.h @@ -289,6 +289,8 @@ enum VulkanChunkType SET_MARKER, END_EVENT, + SET_NAME, + CREATE_SWAP_BUFFER, CAPTURE_SCOPE, diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index de86803b7..4cda4cefa 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/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); diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index 627e60183..5a8b3d4b8 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/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 diff --git a/renderdoc/driver/vulkan/vk_dispatchtables.cpp b/renderdoc/driver/vulkan/vk_dispatchtables.cpp index f8bd6d176..d08f6e18e 100644 --- a/renderdoc/driver/vulkan/vk_dispatchtables.cpp +++ b/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 -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 devlookup; +std::map devlookup; static Threading::CriticalSection instlock; -std::map instlookup; +std::map 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; diff --git a/renderdoc/driver/vulkan/vk_dispatchtables.h b/renderdoc/driver/vulkan/vk_dispatchtables.h index f7dcb56cb..9de40012a 100644 --- a/renderdoc/driver/vulkan/vk_dispatchtables.h +++ b/renderdoc/driver/vulkan/vk_dispatchtables.h @@ -34,12 +34,18 @@ #include +#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; diff --git a/renderdoc/driver/vulkan/vk_hookset_defs.h b/renderdoc/driver/vulkan/vk_hookset_defs.h index 08b864873..cb3ad0b4d 100644 --- a/renderdoc/driver/vulkan/vk_hookset_defs.h +++ b/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; +}; diff --git a/renderdoc/driver/vulkan/vk_replay.cpp b/renderdoc/driver/vulkan/vk_replay.cpp index 022725fa4..b6e50701b 100644 --- a/renderdoc/driver/vulkan/vk_replay.cpp +++ b/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; diff --git a/renderdoc/driver/vulkan/vk_resources.cpp b/renderdoc/driver/vulkan/vk_resources.cpp index eb307b31a..178c8af41 100644 --- a/renderdoc/driver/vulkan/vk_resources.cpp +++ b/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); diff --git a/renderdoc/driver/vulkan/vk_resources.h b/renderdoc/driver/vulkan/vk_resources.h index 91cb8688e..ad7502bb6 100644 --- a/renderdoc/driver/vulkan/vk_resources.h +++ b/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 diff --git a/renderdoc/driver/vulkan/vk_tracelayer.cpp b/renderdoc/driver/vulkan/vk_tracelayer.cpp index a1f2d9e0b..f58bc0c81 100644 --- a/renderdoc/driver/vulkan/vk_tracelayer.cpp +++ b/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); diff --git a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp index d8fb0c526..ea984b521 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp +++ b/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); diff --git a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp index d1bee737d..f4fab9ba3 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp +++ b/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 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 diff --git a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp index ef057feee..6642dad9a 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp +++ b/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; +} diff --git a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp index 413ec62fa..2ca636c6d 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_queue_funcs.cpp @@ -374,6 +374,7 @@ void WrappedVulkan::InsertDrawsAndRefreshIDs(vector &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);