From a8dfd365258216b5ad12e7bc44012eb2954ad473 Mon Sep 17 00:00:00 2001 From: GregF Date: Thu, 17 Sep 2015 18:08:27 -0600 Subject: [PATCH] Use layer specific dispatch table maps --- .../LoaderAndTools/layers/vk_layer_table.h | 4 + renderdoc/driver/vulkan/rdtrace.cpp | 16 +- renderdoc/driver/vulkan/vk_core.cpp | 514 +++++++++--------- 3 files changed, 273 insertions(+), 261 deletions(-) diff --git a/renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_table.h b/renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_table.h index fbf2a8cdc..99fa10dbf 100644 --- a/renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_table.h +++ b/renderdoc/driver/vulkan/LoaderAndTools/layers/vk_layer_table.h @@ -49,3 +49,7 @@ VkLayerInstanceDispatchTable *get_dispatch_table(instance_table_map &map, void* void destroy_device_dispatch_table(dispatch_key key); void destroy_instance_dispatch_table(dispatch_key key); + +void destroy_dispatch_table(device_table_map &map, dispatch_key key); +void destroy_dispatch_table(instance_table_map &map, dispatch_key key); + diff --git a/renderdoc/driver/vulkan/rdtrace.cpp b/renderdoc/driver/vulkan/rdtrace.cpp index 02dda6adf..3de6e00c4 100644 --- a/renderdoc/driver/vulkan/rdtrace.cpp +++ b/renderdoc/driver/vulkan/rdtrace.cpp @@ -55,6 +55,10 @@ WrappedVulkan *shadowVulkan = NULL; +// probably should not be extern in final release +extern device_table_map renderdoc_device_table_map; +extern instance_table_map renderdoc_instance_table_map; + // Layer Intercepts static const VkLayerProperties rdt_physicaldevice_layers[] = { @@ -193,7 +197,7 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, co /* loader uses this to force layer initialization; device object is wrapped */ if (!strcmp("vkGetDeviceProcAddr", pName)) { - initDeviceTable((const VkBaseLayerObject *) device); + initDeviceTable(renderdoc_device_table_map, (const VkBaseLayerObject *) device); return (PFN_vkVoidFunction) vkGetDeviceProcAddr; } @@ -205,9 +209,9 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, co return (PFN_vkVoidFunction) vkDestroyDevice; else { - if (device_dispatch_table(device)->GetDeviceProcAddr == NULL) + if (get_dispatch_table(renderdoc_device_table_map, device)->GetDeviceProcAddr == NULL) return NULL; - return device_dispatch_table(device)->GetDeviceProcAddr(device, pName); + return get_dispatch_table(renderdoc_device_table_map, device)->GetDeviceProcAddr(device, pName); } } @@ -218,7 +222,7 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instan /* loader uses this to force layer initialization; instance object is wrapped */ if (!strcmp("vkGetInstanceProcAddr", pName)) { - initInstanceTable((const VkBaseLayerObject *) instance); + initInstanceTable(renderdoc_instance_table_map, (const VkBaseLayerObject *) instance); if (shadowVulkan == NULL) { shadowVulkan = new WrappedVulkan(""); } @@ -234,8 +238,8 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetInstanceProcAddr(VkInstance instan if (!strcmp("vkGetGlobalLayerProperties", pName)) return (PFN_vkVoidFunction) vkGetGlobalLayerProperties; - if (instance_dispatch_table(instance)->GetInstanceProcAddr == NULL) + if (get_dispatch_table(renderdoc_instance_table_map, instance)->GetInstanceProcAddr == NULL) return NULL; - return instance_dispatch_table(instance)->GetInstanceProcAddr(instance, pName); + return get_dispatch_table(renderdoc_instance_table_map, instance)->GetInstanceProcAddr(instance, pName); } diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index dc036b9bc..62d3915b3 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -49,6 +49,10 @@ static bool operator <(const VkExtensionProperties &a, const VkExtensionProperti return cmp < 0; } +// probably should not be extern in final release +device_table_map renderdoc_device_table_map; +instance_table_map renderdoc_instance_table_map; + // VKTODOLOW assertion of structure types, handling of pNext or assert == NULL const char *VkChunkNames[] = @@ -265,7 +269,7 @@ void WrappedVulkan::Initialise(VkInitParams ¶ms) // GSFTODO: Fix this // VkResult ret = m_Real.vkCreateInstance(&instinfo, &inst); - VkResult ret = instance_dispatch_table(inst)->CreateInstance(&instinfo, &inst); + VkResult ret = get_dispatch_table(renderdoc_instance_table_map, inst)->CreateInstance(&instinfo, &inst); GetResourceManager()->RegisterResource(MakeRes(inst)); GetResourceManager()->AddLiveResource(params.InstanceID, MakeRes(inst)); @@ -413,7 +417,7 @@ WrappedVulkan::~WrappedVulkan() // VKTODOMED [0] isn't right.. // GSFTODO Fix this // m_Real.vkDbgDestroyMsgCallback(m_PhysicalReplayData[0].inst, m_MsgCallback); - instance_dispatch_table(m_PhysicalReplayData[0].inst)->DbgDestroyMsgCallback(m_PhysicalReplayData[0].inst, m_MsgCallback); + get_dispatch_table(renderdoc_instance_table_map, m_PhysicalReplayData[0].inst)->DbgDestroyMsgCallback(m_PhysicalReplayData[0].inst, m_MsgCallback); } #endif @@ -438,7 +442,7 @@ VkResult WrappedVulkan::vkCreateInstance( VkInstance inst = *pInstance; - VkResult ret = instance_dispatch_table(*pInstance)->CreateInstance(pCreateInfo, &inst); + VkResult ret = get_dispatch_table(renderdoc_instance_table_map, *pInstance)->CreateInstance(pCreateInfo, &inst); if(ret != VK_SUCCESS) return ret; @@ -453,7 +457,7 @@ VkResult WrappedVulkan::vkCreateInstance( // VKTODOLOW we should try and fetch vkDbgCreateMsgCallback ourselves if it isn't // already loaded - PFN_vkDbgCreateMsgCallback dcmc_fn = instance_dispatch_table(*pInstance)->DbgCreateMsgCallback; + PFN_vkDbgCreateMsgCallback dcmc_fn = get_dispatch_table(renderdoc_instance_table_map, *pInstance)->DbgCreateMsgCallback; if(RenderDoc::Inst().GetCaptureOptions().DebugDeviceMode && dcmc_fn) { VkFlags flags = VK_DBG_REPORT_INFO_BIT | @@ -482,19 +486,19 @@ VkResult WrappedVulkan::vkDestroyInstance( VkInstance instance) { dispatch_key key = get_dispatch_key(instance); - VkResult ret = instance_dispatch_table(instance)->DestroyInstance(instance); + VkResult ret = get_dispatch_table(renderdoc_instance_table_map, instance)->DestroyInstance(instance); if(ret != VK_SUCCESS) return ret; if(RenderDoc::Inst().GetCaptureOptions().DebugDeviceMode && m_MsgCallback != VK_NULL_HANDLE) { - instance_dispatch_table(instance)->DbgDestroyMsgCallback(instance, m_MsgCallback); + get_dispatch_table(renderdoc_instance_table_map, instance)->DbgDestroyMsgCallback(instance, m_MsgCallback); } GetResourceManager()->UnregisterResource(MakeRes(instance)); - destroy_instance_dispatch_table(key); + destroy_dispatch_table(renderdoc_instance_table_map, key); return VK_SUCCESS; } @@ -514,7 +518,7 @@ bool WrappedVulkan::Serialise_vkEnumeratePhysicalDevices( { instance = (VkInstance)GetResourceManager()->GetLiveResource(inst).handle; // GSFTODO right instance? - VkResult ret = instance_dispatch_table(instance)->EnumeratePhysicalDevices(instance, &count, devices); + VkResult ret = get_dispatch_table(renderdoc_instance_table_map, instance)->EnumeratePhysicalDevices(instance, &count, devices); RDCASSERT(ret == VK_SUCCESS); // VKTODOLOW match up physical devices to those available on replay @@ -538,7 +542,7 @@ bool WrappedVulkan::Serialise_vkEnumeratePhysicalDevices( data.inst = instance; data.phys = pd; - instance_dispatch_table(pd)->GetPhysicalDeviceMemoryProperties(pd, &data.memProps); + get_dispatch_table(renderdoc_instance_table_map, pd)->GetPhysicalDeviceMemoryProperties(pd, &data.memProps); data.readbackMemIndex = data.GetMemoryIndex(~0U, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, VK_MEMORY_PROPERTY_HOST_WRITE_COMBINED_BIT); data.uploadMemIndex = data.GetMemoryIndex(~0U, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, 0); @@ -556,7 +560,7 @@ VkResult WrappedVulkan::vkEnumeratePhysicalDevices( { uint32_t count; VkPhysicalDevice devices[8]; // VKTODOLOW: dynamically allocate - VkResult ret = instance_dispatch_table(instance)->EnumeratePhysicalDevices(instance, &count, devices); + VkResult ret = get_dispatch_table(renderdoc_instance_table_map, instance)->EnumeratePhysicalDevices(instance, &count, devices); if(ret != VK_SUCCESS) return ret; @@ -599,7 +603,7 @@ bool WrappedVulkan::Serialise_vkCreateDevice( // VKTODOLOW: check that extensions supported in capture (from createInfo) are supported in replay - VkResult ret = device_dispatch_table(*pDevice)->CreateDevice(rmPhys, &createInfo, &device); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, *pDevice)->CreateDevice(rmPhys, &createInfo, &device); VkResource res = MakeRes(device); @@ -619,27 +623,27 @@ bool WrappedVulkan::Serialise_vkCreateDevice( m_PhysicalReplayData[i].dev = device; // VKTODOHIGH: shouldn't be 0, 0 - VkResult vkr = device_dispatch_table(*pDevice)->GetDeviceQueue(device, 0, 0, &m_PhysicalReplayData[i].q); + VkResult vkr = get_dispatch_table(renderdoc_device_table_map, *pDevice)->GetDeviceQueue(device, 0, 0, &m_PhysicalReplayData[i].q); RDCASSERT(vkr == VK_SUCCESS); // VKTODOHIGH queueFamilyIndex VkCmdPoolCreateInfo poolInfo = { VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO, NULL, 0, 0 }; - vkr = device_dispatch_table(*pDevice)->CreateCommandPool(device, &poolInfo, &m_PhysicalReplayData[i].cmdpool); + vkr = get_dispatch_table(renderdoc_device_table_map, *pDevice)->CreateCommandPool(device, &poolInfo, &m_PhysicalReplayData[i].cmdpool); RDCASSERT(vkr == VK_SUCCESS); VkCmdBufferCreateInfo cmdInfo = { VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO, NULL, m_PhysicalReplayData[i].cmdpool, VK_CMD_BUFFER_LEVEL_PRIMARY, 0 }; - vkr = device_dispatch_table(*pDevice)->CreateCommandBuffer(device, &cmdInfo, &m_PhysicalReplayData[i].cmd); + vkr = get_dispatch_table(renderdoc_device_table_map, *pDevice)->CreateCommandBuffer(device, &cmdInfo, &m_PhysicalReplayData[i].cmd); RDCASSERT(vkr == VK_SUCCESS); #if defined(FORCE_VALIDATION_LAYER) - if(device_dispatch_table(*pDevice)->DbgCreateMsgCallback) + if(get_dispatch_table(renderdoc_device_table_map, *pDevice)->DbgCreateMsgCallback) { VkFlags flags = VK_DBG_REPORT_INFO_BIT | VK_DBG_REPORT_WARN_BIT | VK_DBG_REPORT_PERF_WARN_BIT | VK_DBG_REPORT_ERROR_BIT | VK_DBG_REPORT_DEBUG_BIT; - vkr = device_dispatch_table(*pDevice)->DbgCreateMsgCallback(m_PhysicalReplayData[i].inst, flags, &DebugCallbackStatic, this, &m_MsgCallback); + vkr = get_dispatch_table(renderdoc_device_table_map, *pDevice)->DbgCreateMsgCallback(m_PhysicalReplayData[i].inst, flags, &DebugCallbackStatic, this, &m_MsgCallback); RDCASSERT(vkr == VK_SUCCESS); RDCLOG("Created dbg callback"); } @@ -673,7 +677,7 @@ VkResult WrappedVulkan::vkCreateDevice( RDCDEBUG("Might want to fiddle with createinfo - e.g. to remove VK_RenderDoc from set of extensions or similar"); - VkResult ret = device_dispatch_table(*pDevice)->CreateDevice(physicalDevice, &createInfo, pDevice); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, *pDevice)->CreateDevice(physicalDevice, &createInfo, pDevice); if(ret == VK_SUCCESS) { @@ -685,16 +689,16 @@ VkResult WrappedVulkan::vkCreateDevice( { m_PhysicalReplayData[i].dev = *pDevice; // VKTODOHIGH: shouldn't be 0, 0 - VkResult vkr = device_dispatch_table(*pDevice)->GetDeviceQueue(*pDevice, 0, 0, &m_PhysicalReplayData[i].q); + VkResult vkr = get_dispatch_table(renderdoc_device_table_map, *pDevice)->GetDeviceQueue(*pDevice, 0, 0, &m_PhysicalReplayData[i].q); RDCASSERT(vkr == VK_SUCCESS); // VKTODOHIGH queueFamilyIndex VkCmdPoolCreateInfo poolInfo = { VK_STRUCTURE_TYPE_CMD_POOL_CREATE_INFO, NULL, 0, 0 }; - vkr = device_dispatch_table(*pDevice)->CreateCommandPool(*pDevice, &poolInfo, &m_PhysicalReplayData[i].cmdpool); + vkr = get_dispatch_table(renderdoc_device_table_map, *pDevice)->CreateCommandPool(*pDevice, &poolInfo, &m_PhysicalReplayData[i].cmdpool); RDCASSERT(vkr == VK_SUCCESS); VkCmdBufferCreateInfo cmdInfo = { VK_STRUCTURE_TYPE_CMD_BUFFER_CREATE_INFO, NULL, m_PhysicalReplayData[i].cmdpool, VK_CMD_BUFFER_LEVEL_PRIMARY, 0 }; - vkr = device_dispatch_table(*pDevice)->CreateCommandBuffer(*pDevice, &cmdInfo, &m_PhysicalReplayData[i].cmd); + vkr = get_dispatch_table(renderdoc_device_table_map, *pDevice)->CreateCommandBuffer(*pDevice, &cmdInfo, &m_PhysicalReplayData[i].cmd); RDCASSERT(vkr == VK_SUCCESS); found = true; break; @@ -760,7 +764,7 @@ VkResult WrappedVulkan::vkDestroyDevice(VkDevice device) } if(m_PhysicalReplayData[i].cmd != VK_NULL_HANDLE) - device_dispatch_table(device)->DestroyCommandBuffer(device, m_PhysicalReplayData[i].cmd); + get_dispatch_table(renderdoc_device_table_map, device)->DestroyCommandBuffer(device, m_PhysicalReplayData[i].cmd); m_PhysicalReplayData[i] = ReplayData(); break; @@ -769,8 +773,8 @@ VkResult WrappedVulkan::vkDestroyDevice(VkDevice device) } dispatch_key key = get_dispatch_key(device); - VkResult ret = device_dispatch_table(device)->DestroyDevice(device); - destroy_device_dispatch_table(key); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->DestroyDevice(device); + destroy_dispatch_table(renderdoc_device_table_map, key); GetResourceManager()->UnregisterResource(MakeRes(device)); @@ -781,7 +785,7 @@ VkResult WrappedVulkan::vkGetPhysicalDeviceFeatures( VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { - return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures); + return get_dispatch_table(renderdoc_instance_table_map, physicalDevice)->GetPhysicalDeviceFeatures(physicalDevice, pFeatures); } VkResult WrappedVulkan::vkGetPhysicalDeviceFormatProperties( @@ -789,7 +793,7 @@ VkResult WrappedVulkan::vkGetPhysicalDeviceFormatProperties( VkFormat format, VkFormatProperties* pFormatProperties) { - return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); + return get_dispatch_table(renderdoc_instance_table_map, physicalDevice)->GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); } VkResult WrappedVulkan::vkGetPhysicalDeviceImageFormatProperties( @@ -800,28 +804,28 @@ VkResult WrappedVulkan::vkGetPhysicalDeviceImageFormatProperties( VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties) { - return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, pImageFormatProperties); + return get_dispatch_table(renderdoc_instance_table_map, physicalDevice)->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, pImageFormatProperties); } VkResult WrappedVulkan::vkGetPhysicalDeviceLimits( VkPhysicalDevice physicalDevice, VkPhysicalDeviceLimits* pLimits) { - return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceLimits(physicalDevice, pLimits); + return get_dispatch_table(renderdoc_instance_table_map, physicalDevice)->GetPhysicalDeviceLimits(physicalDevice, pLimits); } VkResult WrappedVulkan::vkGetPhysicalDeviceProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) { - return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties); + return get_dispatch_table(renderdoc_instance_table_map, physicalDevice)->GetPhysicalDeviceProperties(physicalDevice, pProperties); } VkResult WrappedVulkan::vkGetPhysicalDeviceQueueCount( VkPhysicalDevice physicalDevice, uint32_t* pCount) { - return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueCount(physicalDevice, pCount); + return get_dispatch_table(renderdoc_instance_table_map, physicalDevice)->GetPhysicalDeviceQueueCount(physicalDevice, pCount); } VkResult WrappedVulkan::vkGetPhysicalDeviceQueueProperties( @@ -829,14 +833,14 @@ VkResult WrappedVulkan::vkGetPhysicalDeviceQueueProperties( uint32_t count, VkPhysicalDeviceQueueProperties* pQueueProperties) { - return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceQueueProperties(physicalDevice, count, pQueueProperties); + return get_dispatch_table(renderdoc_instance_table_map, physicalDevice)->GetPhysicalDeviceQueueProperties(physicalDevice, count, pQueueProperties); } VkResult WrappedVulkan::vkGetPhysicalDeviceMemoryProperties( VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { - return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); + return get_dispatch_table(renderdoc_instance_table_map, physicalDevice)->GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); } VkResult WrappedVulkan::vkGetImageSubresourceLayout( @@ -845,7 +849,7 @@ VkResult WrappedVulkan::vkGetImageSubresourceLayout( const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { - return device_dispatch_table(device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout); + return get_dispatch_table(renderdoc_device_table_map, device)->GetImageSubresourceLayout(device, image, pSubresource, pLayout); } VkResult WrappedVulkan::vkGetBufferMemoryRequirements( @@ -853,7 +857,7 @@ VkResult WrappedVulkan::vkGetBufferMemoryRequirements( VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) { - return device_dispatch_table(device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); + return get_dispatch_table(renderdoc_device_table_map, device)->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); } VkResult WrappedVulkan::vkGetImageMemoryRequirements( @@ -861,7 +865,7 @@ VkResult WrappedVulkan::vkGetImageMemoryRequirements( VkImage image, VkMemoryRequirements* pMemoryRequirements) { - return device_dispatch_table(device)->GetImageMemoryRequirements(device, image, pMemoryRequirements); + return get_dispatch_table(renderdoc_device_table_map, device)->GetImageMemoryRequirements(device, image, pMemoryRequirements); } VkResult WrappedVulkan::vkGetGlobalExtensionProperties( @@ -896,7 +900,7 @@ void WrappedVulkan::DestroyObject(VkResource res, ResourceId id) VkResult WrappedVulkan::vk ## func(VkDevice device, type obj) \ { \ DestroyObject(MakeRes(obj), GetResourceManager()->GetID(MakeRes(obj))); \ - return device_dispatch_table(device)->func(device, obj); \ + return get_dispatch_table(renderdoc_device_table_map, device)->func(device, obj); \ } DESTROY_IMPL(VkBuffer, DestroyBuffer) @@ -939,7 +943,7 @@ bool WrappedVulkan::Serialise_vkGetDeviceQueue( if(m_State == READING) { VkQueue queue; - VkResult ret = device_dispatch_table(device)->GetDeviceQueue((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, nodeIdx, idx, &queue); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->GetDeviceQueue((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, nodeIdx, idx, &queue); VkResource res = MakeRes(queue); @@ -956,7 +960,7 @@ VkResult WrappedVulkan::vkGetDeviceQueue( uint32_t queueIndex, VkQueue* pQueue) { - VkResult ret = device_dispatch_table(device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); if(ret == VK_SUCCESS) { @@ -1041,7 +1045,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit( { m_SubmittedFences.insert(fenceId); - device_dispatch_table(queue)->QueueSubmit(rmqueue, numCmds, cmds, fence); + get_dispatch_table(renderdoc_device_table_map, queue)->QueueSubmit(rmqueue, numCmds, cmds, fence); for(uint32_t i=0; i < numCmds; i++) { @@ -1153,7 +1157,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit( m_SubmittedFences.insert(fenceId); - device_dispatch_table(queue)->QueueSubmit(rmqueue, (uint32_t)trimmedCmds.size(), &trimmedCmds[0], fence); + get_dispatch_table(renderdoc_device_table_map, queue)->QueueSubmit(rmqueue, (uint32_t)trimmedCmds.size(), &trimmedCmds[0], fence); for(uint32_t i=0; i < numCmds; i++) { @@ -1165,7 +1169,7 @@ bool WrappedVulkan::Serialise_vkQueueSubmit( { m_SubmittedFences.insert(fenceId); - device_dispatch_table(queue)->QueueSubmit(rmqueue, numCmds, cmds, fence); + get_dispatch_table(renderdoc_device_table_map, queue)->QueueSubmit(rmqueue, numCmds, cmds, fence); for(uint32_t i=0; i < numCmds; i++) { @@ -1204,7 +1208,7 @@ VkResult WrappedVulkan::vkQueueSubmit( const VkCmdBuffer* pCmdBuffers, VkFence fence) { - VkResult ret = device_dispatch_table(queue)->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, queue)->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); if(m_State == WRITING_CAPFRAME) { @@ -1248,7 +1252,7 @@ bool WrappedVulkan::Serialise_vkQueueSignalSemaphore(VkQueue queue, VkSemaphore if(m_State < WRITING) { - device_dispatch_table(queue)->QueueSignalSemaphore((VkQueue)GetResourceManager()->GetLiveResource(qid).handle, + get_dispatch_table(renderdoc_device_table_map, queue)->QueueSignalSemaphore((VkQueue)GetResourceManager()->GetLiveResource(qid).handle, (VkSemaphore)GetResourceManager()->GetLiveResource(sid).handle); } @@ -1257,7 +1261,7 @@ bool WrappedVulkan::Serialise_vkQueueSignalSemaphore(VkQueue queue, VkSemaphore VkResult WrappedVulkan::vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) { - VkResult ret = device_dispatch_table(queue)->QueueSignalSemaphore(queue, semaphore); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, queue)->QueueSignalSemaphore(queue, semaphore); if(m_State >= WRITING) { @@ -1279,7 +1283,7 @@ bool WrappedVulkan::Serialise_vkQueueWaitSemaphore(VkQueue queue, VkSemaphore se if(m_State < WRITING) { - device_dispatch_table(queue)->QueueWaitSemaphore((VkQueue)GetResourceManager()->GetLiveResource(qid).handle, + get_dispatch_table(renderdoc_device_table_map, queue)->QueueWaitSemaphore((VkQueue)GetResourceManager()->GetLiveResource(qid).handle, (VkSemaphore)GetResourceManager()->GetLiveResource(sid).handle); } @@ -1288,7 +1292,7 @@ bool WrappedVulkan::Serialise_vkQueueWaitSemaphore(VkQueue queue, VkSemaphore se VkResult WrappedVulkan::vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) { - VkResult ret = device_dispatch_table(queue)->QueueWaitSemaphore(queue, semaphore); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, queue)->QueueWaitSemaphore(queue, semaphore); if(m_State >= WRITING_CAPFRAME) { @@ -1309,7 +1313,7 @@ bool WrappedVulkan::Serialise_vkQueueWaitIdle(VkQueue queue) if(m_State < WRITING_CAPFRAME) { - device_dispatch_table(queue)->QueueWaitIdle((VkQueue)GetResourceManager()->GetLiveResource(id).handle); + get_dispatch_table(renderdoc_device_table_map, queue)->QueueWaitIdle((VkQueue)GetResourceManager()->GetLiveResource(id).handle); } return true; @@ -1317,7 +1321,7 @@ bool WrappedVulkan::Serialise_vkQueueWaitIdle(VkQueue queue) VkResult WrappedVulkan::vkQueueWaitIdle(VkQueue queue) { - VkResult ret = device_dispatch_table(queue)->QueueWaitIdle(queue); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, queue)->QueueWaitIdle(queue); if(m_State >= WRITING_CAPFRAME) { @@ -1337,7 +1341,7 @@ bool WrappedVulkan::Serialise_vkDeviceWaitIdle(VkDevice device) if(m_State < WRITING) { - device_dispatch_table(device)->DeviceWaitIdle((VkDevice)GetResourceManager()->GetLiveResource(id).handle); + get_dispatch_table(renderdoc_device_table_map, device)->DeviceWaitIdle((VkDevice)GetResourceManager()->GetLiveResource(id).handle); } return true; @@ -1345,7 +1349,7 @@ bool WrappedVulkan::Serialise_vkDeviceWaitIdle(VkDevice device) VkResult WrappedVulkan::vkDeviceWaitIdle(VkDevice device) { - VkResult ret = device_dispatch_table(device)->DeviceWaitIdle(device); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->DeviceWaitIdle(device); if(m_State >= WRITING_CAPFRAME) { @@ -1375,7 +1379,7 @@ bool WrappedVulkan::Serialise_vkAllocMemory( // VKTODOLOW may need to re-write info to change memory type index to the // appropriate index on replay - VkResult ret = device_dispatch_table(device)->AllocMemory((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &mem); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->AllocMemory((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &mem); ResourceId live; @@ -1400,7 +1404,7 @@ VkResult WrappedVulkan::vkAllocMemory( const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) { - VkResult ret = device_dispatch_table(device)->AllocMemory(device, pAllocInfo, pMem); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->AllocMemory(device, pAllocInfo, pMem); if(ret == VK_SUCCESS) { @@ -1452,7 +1456,7 @@ VkResult WrappedVulkan::vkFreeMemory( record->Delete(GetResourceManager()); GetResourceManager()->UnregisterResource(MakeRes(mem)); - return device_dispatch_table(device)->FreeMemory(device, mem); + return get_dispatch_table(renderdoc_device_table_map, device)->FreeMemory(device, mem); } VkResult WrappedVulkan::vkMapMemory( @@ -1463,7 +1467,7 @@ VkResult WrappedVulkan::vkMapMemory( VkMemoryMapFlags flags, void** ppData) { - VkResult ret = device_dispatch_table(device)->MapMemory(device, mem, offset, size, flags, ppData); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->MapMemory(device, mem, offset, size, flags, ppData); if(ret == VK_SUCCESS && ppData) { @@ -1520,7 +1524,7 @@ bool WrappedVulkan::Serialise_vkUnmapMemory( mem = (VkDeviceMemory)GetResourceManager()->GetLiveResource(id).handle; void *mapPtr = NULL; - VkResult ret = device_dispatch_table(device)->MapMemory(rmDev, mem, memOffset, memSize, flags, &mapPtr); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->MapMemory(rmDev, mem, memOffset, memSize, flags, &mapPtr); if(ret != VK_SUCCESS) { @@ -1530,7 +1534,7 @@ bool WrappedVulkan::Serialise_vkUnmapMemory( { memcpy((byte *)mapPtr+memOffset, data, (size_t)memSize); - ret = device_dispatch_table(device)->UnmapMemory(rmDev, mem); + ret = get_dispatch_table(renderdoc_device_table_map, device)->UnmapMemory(rmDev, mem); if(ret != VK_SUCCESS) RDCERR("Error unmapping memory on replay: 0x%08x", ret); @@ -1546,7 +1550,7 @@ VkResult WrappedVulkan::vkUnmapMemory( VkDevice device, VkDeviceMemory mem) { - VkResult ret = device_dispatch_table(device)->UnmapMemory(device, mem); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->UnmapMemory(device, mem); if(m_State >= WRITING) { @@ -1610,7 +1614,7 @@ bool WrappedVulkan::Serialise_vkBindBufferMemory( buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufId).handle; mem = (VkDeviceMemory)GetResourceManager()->GetLiveResource(memId).handle; - device_dispatch_table(device)->BindBufferMemory(rmDev, buffer, mem, offs); + get_dispatch_table(renderdoc_device_table_map, device)->BindBufferMemory(rmDev, buffer, mem, offs); } return true; @@ -1650,7 +1654,7 @@ VkResult WrappedVulkan::vkBindBufferMemory( record->SetMemoryRecord(GetResourceManager()->GetResourceRecord(MakeRes(mem))); } - return device_dispatch_table(device)->BindBufferMemory(device, buffer, mem, memOffset); + return get_dispatch_table(renderdoc_device_table_map, device)->BindBufferMemory(device, buffer, mem, memOffset); } bool WrappedVulkan::Serialise_vkBindImageMemory( @@ -1670,7 +1674,7 @@ bool WrappedVulkan::Serialise_vkBindImageMemory( image = (VkImage)GetResourceManager()->GetLiveResource(imgId).handle; mem = (VkDeviceMemory)GetResourceManager()->GetLiveResource(memId).handle; - device_dispatch_table(device)->BindImageMemory(rmDev, image, mem, offs); + get_dispatch_table(renderdoc_device_table_map, device)->BindImageMemory(rmDev, image, mem, offs); } return true; @@ -1710,7 +1714,7 @@ VkResult WrappedVulkan::vkBindImageMemory( record->SetMemoryRecord(GetResourceManager()->GetResourceRecord(MakeRes(mem))); } - return device_dispatch_table(device)->BindImageMemory(device, image, mem, memOffset); + return get_dispatch_table(renderdoc_device_table_map, device)->BindImageMemory(device, image, mem, memOffset); } bool WrappedVulkan::Serialise_vkCreateBuffer( @@ -1726,7 +1730,7 @@ bool WrappedVulkan::Serialise_vkCreateBuffer( { VkBuffer buf = VK_NULL_HANDLE; - VkResult ret = device_dispatch_table(device)->CreateBuffer((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &buf); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateBuffer((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &buf); if(ret != VK_SUCCESS) { @@ -1747,7 +1751,7 @@ VkResult WrappedVulkan::vkCreateBuffer( const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) { - VkResult ret = device_dispatch_table(device)->CreateBuffer(device, pCreateInfo, pBuffer); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateBuffer(device, pCreateInfo, pBuffer); if(ret == VK_SUCCESS) { @@ -1790,7 +1794,7 @@ bool WrappedVulkan::Serialise_vkCreateBufferView( { VkBufferView view = VK_NULL_HANDLE; - VkResult ret = device_dispatch_table(device)->CreateBufferView((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &view); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateBufferView((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &view); if(ret != VK_SUCCESS) { @@ -1811,7 +1815,7 @@ VkResult WrappedVulkan::vkCreateBufferView( const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) { - VkResult ret = device_dispatch_table(device)->CreateBufferView(device, pCreateInfo, pView); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateBufferView(device, pCreateInfo, pView); if(ret == VK_SUCCESS) { @@ -1855,7 +1859,7 @@ bool WrappedVulkan::Serialise_vkCreateImage( { VkImage img = VK_NULL_HANDLE; - VkResult ret = device_dispatch_table(device)->CreateImage((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &img); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateImage((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &img); if(ret != VK_SUCCESS) { @@ -1901,7 +1905,7 @@ VkResult WrappedVulkan::vkCreateImage( const VkImageCreateInfo* pCreateInfo, VkImage* pImage) { - VkResult ret = device_dispatch_table(device)->CreateImage(device, pCreateInfo, pImage); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateImage(device, pCreateInfo, pImage); if(ret == VK_SUCCESS) { @@ -1971,7 +1975,7 @@ bool WrappedVulkan::Serialise_vkCreateImageView( { VkImageView view = VK_NULL_HANDLE; - VkResult ret = device_dispatch_table(device)->CreateImageView((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &view); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateImageView((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &view); if(ret != VK_SUCCESS) { @@ -1992,7 +1996,7 @@ VkResult WrappedVulkan::vkCreateImageView( const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) { - VkResult ret = device_dispatch_table(device)->CreateImageView(device, pCreateInfo, pView); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateImageView(device, pCreateInfo, pView); if(ret == VK_SUCCESS) { @@ -2036,7 +2040,7 @@ bool WrappedVulkan::Serialise_vkCreateAttachmentView( { VkAttachmentView view = VK_NULL_HANDLE; - VkResult ret = device_dispatch_table(device)->CreateAttachmentView((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &view); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateAttachmentView((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &view); if(ret != VK_SUCCESS) { @@ -2057,7 +2061,7 @@ VkResult WrappedVulkan::vkCreateAttachmentView( const VkAttachmentViewCreateInfo* pCreateInfo, VkAttachmentView* pView) { - VkResult ret = device_dispatch_table(device)->CreateAttachmentView(device, pCreateInfo, pView); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateAttachmentView(device, pCreateInfo, pView); if(ret == VK_SUCCESS) { @@ -2103,7 +2107,7 @@ bool WrappedVulkan::Serialise_vkCreateShaderModule( { VkShaderModule sh = VK_NULL_HANDLE; - VkResult ret = device_dispatch_table(device)->CreateShaderModule((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &sh); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateShaderModule((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &sh); if(ret != VK_SUCCESS) { @@ -2124,7 +2128,7 @@ VkResult WrappedVulkan::vkCreateShaderModule( const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShaderModule) { - VkResult ret = device_dispatch_table(device)->CreateShaderModule(device, pCreateInfo, pShaderModule); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateShaderModule(device, pCreateInfo, pShaderModule); if(ret == VK_SUCCESS) { @@ -2167,7 +2171,7 @@ bool WrappedVulkan::Serialise_vkCreateShader( { VkShader sh = VK_NULL_HANDLE; - VkResult ret = device_dispatch_table(device)->CreateShader((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &sh); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateShader((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &sh); if(ret != VK_SUCCESS) { @@ -2188,7 +2192,7 @@ VkResult WrappedVulkan::vkCreateShader( const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) { - VkResult ret = device_dispatch_table(device)->CreateShader(device, pCreateInfo, pShader); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateShader(device, pCreateInfo, pShader); if(ret == VK_SUCCESS) { @@ -2236,7 +2240,7 @@ bool WrappedVulkan::Serialise_vkCreatePipelineCache( { VkPipelineCache cache = VK_NULL_HANDLE; - VkResult ret = device_dispatch_table(device)->CreatePipelineCache((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &cache); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreatePipelineCache((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &cache); if(ret != VK_SUCCESS) { @@ -2257,7 +2261,7 @@ VkResult WrappedVulkan::vkCreatePipelineCache( const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache) { - VkResult ret = device_dispatch_table(device)->CreatePipelineCache(device, pCreateInfo, pPipelineCache); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreatePipelineCache(device, pCreateInfo, pPipelineCache); if(ret == VK_SUCCESS) { @@ -2309,7 +2313,7 @@ bool WrappedVulkan::Serialise_vkCreateGraphicsPipelines( VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; pipelineCache = (VkPipelineCache)GetResourceManager()->GetLiveResource(cacheId).handle; - VkResult ret = device_dispatch_table(device)->CreateGraphicsPipelines(rmDev, pipelineCache, 1, &info, &pipe); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateGraphicsPipelines(rmDev, pipelineCache, 1, &info, &pipe); if(ret != VK_SUCCESS) { @@ -2332,7 +2336,7 @@ VkResult WrappedVulkan::vkCreateGraphicsPipelines( const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines) { - VkResult ret = device_dispatch_table(device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines); if(ret == VK_SUCCESS) { @@ -2396,7 +2400,7 @@ bool WrappedVulkan::Serialise_vkCreateDescriptorPool( VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; - VkResult ret = device_dispatch_table(device)->CreateDescriptorPool(rmDev, pooluse, maxs, &info, &pool); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateDescriptorPool(rmDev, pooluse, maxs, &info, &pool); if(ret != VK_SUCCESS) { @@ -2419,7 +2423,7 @@ VkResult WrappedVulkan::vkCreateDescriptorPool( const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) { - VkResult ret = device_dispatch_table(device)->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); if(ret == VK_SUCCESS) { @@ -2468,7 +2472,7 @@ bool WrappedVulkan::Serialise_vkCreateDescriptorSetLayout( VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; - VkResult ret = device_dispatch_table(device)->CreateDescriptorSetLayout(rmDev, &info, &layout); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateDescriptorSetLayout(rmDev, &info, &layout); if(ret != VK_SUCCESS) { @@ -2489,7 +2493,7 @@ VkResult WrappedVulkan::vkCreateDescriptorSetLayout( const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) { - VkResult ret = device_dispatch_table(device)->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); if(ret == VK_SUCCESS) { @@ -2534,7 +2538,7 @@ bool WrappedVulkan::Serialise_vkCreatePipelineLayout( VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; - VkResult ret = device_dispatch_table(device)->CreatePipelineLayout(rmDev, &info, &layout); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreatePipelineLayout(rmDev, &info, &layout); if(ret != VK_SUCCESS) { @@ -2555,7 +2559,7 @@ VkResult WrappedVulkan::vkCreatePipelineLayout( const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) { - VkResult ret = device_dispatch_table(device)->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout); if(ret == VK_SUCCESS) { @@ -2600,7 +2604,7 @@ bool WrappedVulkan::Serialise_vkCreateSampler( { VkSampler samp = VK_NULL_HANDLE; - VkResult ret = device_dispatch_table(device)->CreateSampler((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &samp); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateSampler((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &samp); if(ret != VK_SUCCESS) { @@ -2621,7 +2625,7 @@ VkResult WrappedVulkan::vkCreateSampler( const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) { - VkResult ret = device_dispatch_table(device)->CreateSampler(device, pCreateInfo, pSampler); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateSampler(device, pCreateInfo, pSampler); if(ret == VK_SUCCESS) { @@ -2664,7 +2668,7 @@ bool WrappedVulkan::Serialise_vkCreateSemaphore( { VkSemaphore sem = VK_NULL_HANDLE; - VkResult ret = device_dispatch_table(device)->CreateSemaphore((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &sem); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateSemaphore((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &sem); if(ret != VK_SUCCESS) { @@ -2685,7 +2689,7 @@ VkResult WrappedVulkan::vkCreateSemaphore( const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) { - VkResult ret = device_dispatch_table(device)->CreateSemaphore(device, pCreateInfo, pSemaphore); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateSemaphore(device, pCreateInfo, pSemaphore); if(ret == VK_SUCCESS) { @@ -2731,7 +2735,7 @@ bool WrappedVulkan::Serialise_vkCreateFramebuffer( // use original ID m_CreationInfo.m_Framebuffer[id].Init(GetResourceManager(), &info); - VkResult ret = device_dispatch_table(device)->CreateFramebuffer((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &fb); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateFramebuffer((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &fb); if(ret != VK_SUCCESS) { @@ -2752,7 +2756,7 @@ VkResult WrappedVulkan::vkCreateFramebuffer( const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) { - VkResult ret = device_dispatch_table(device)->CreateFramebuffer(device, pCreateInfo, pFramebuffer); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateFramebuffer(device, pCreateInfo, pFramebuffer); if(ret == VK_SUCCESS) { @@ -2800,7 +2804,7 @@ bool WrappedVulkan::Serialise_vkCreateRenderPass( { VkRenderPass rp = VK_NULL_HANDLE; - VkResult ret = device_dispatch_table(device)->CreateRenderPass((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &rp); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateRenderPass((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &rp); if(ret != VK_SUCCESS) { @@ -2821,7 +2825,7 @@ VkResult WrappedVulkan::vkCreateRenderPass( const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) { - VkResult ret = device_dispatch_table(device)->CreateRenderPass(device, pCreateInfo, pRenderPass); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateRenderPass(device, pCreateInfo, pRenderPass); if(ret == VK_SUCCESS) { @@ -2869,7 +2873,7 @@ bool WrappedVulkan::Serialise_vkCreateDynamicViewportState( // use original ID m_CreationInfo.m_VPScissor[id].Init(GetResourceManager(), &info); - VkResult ret = device_dispatch_table(device)->CreateDynamicViewportState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateDynamicViewportState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); if(ret != VK_SUCCESS) { @@ -2890,7 +2894,7 @@ VkResult WrappedVulkan::vkCreateDynamicViewportState( const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState) { - VkResult ret = device_dispatch_table(device)->CreateDynamicViewportState(device, pCreateInfo, pState); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateDynamicViewportState(device, pCreateInfo, pState); if(ret == VK_SUCCESS) { @@ -2936,7 +2940,7 @@ bool WrappedVulkan::Serialise_vkCreateDynamicRasterState( // use original ID m_CreationInfo.m_Raster[id].Init(GetResourceManager(), &info); - VkResult ret = device_dispatch_table(device)->CreateDynamicRasterState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateDynamicRasterState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); if(ret != VK_SUCCESS) { @@ -2957,7 +2961,7 @@ VkResult WrappedVulkan::vkCreateDynamicRasterState( const VkDynamicRasterStateCreateInfo* pCreateInfo, VkDynamicRasterState* pState) { - VkResult ret = device_dispatch_table(device)->CreateDynamicRasterState(device, pCreateInfo, pState); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateDynamicRasterState(device, pCreateInfo, pState); if(ret == VK_SUCCESS) { @@ -3003,7 +3007,7 @@ bool WrappedVulkan::Serialise_vkCreateDynamicColorBlendState( // use original ID m_CreationInfo.m_Blend[id].Init(GetResourceManager(), &info); - VkResult ret = device_dispatch_table(device)->CreateDynamicColorBlendState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateDynamicColorBlendState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); if(ret != VK_SUCCESS) { @@ -3024,7 +3028,7 @@ VkResult WrappedVulkan::vkCreateDynamicColorBlendState( const VkDynamicColorBlendStateCreateInfo* pCreateInfo, VkDynamicColorBlendState* pState) { - VkResult ret = device_dispatch_table(device)->CreateDynamicColorBlendState(device, pCreateInfo, pState); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateDynamicColorBlendState(device, pCreateInfo, pState); if(ret == VK_SUCCESS) { @@ -3070,7 +3074,7 @@ bool WrappedVulkan::Serialise_vkCreateDynamicDepthStencilState( // use original ID m_CreationInfo.m_DepthStencil[id].Init(GetResourceManager(), &info); - VkResult ret = device_dispatch_table(device)->CreateDynamicDepthStencilState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateDynamicDepthStencilState((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &state); if(ret != VK_SUCCESS) { @@ -3091,7 +3095,7 @@ VkResult WrappedVulkan::vkCreateDynamicDepthStencilState( const VkDynamicDepthStencilStateCreateInfo* pCreateInfo, VkDynamicDepthStencilState* pState) { - VkResult ret = device_dispatch_table(device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateDynamicDepthStencilState(device, pCreateInfo, pState); if(ret == VK_SUCCESS) { @@ -3136,7 +3140,7 @@ bool WrappedVulkan::Serialise_vkCreateCommandPool( { VkCmdPool pool = VK_NULL_HANDLE; - VkResult ret = device_dispatch_table(device)->CreateCommandPool((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &pool); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateCommandPool((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &pool); if(ret != VK_SUCCESS) { @@ -3157,7 +3161,7 @@ VkResult WrappedVulkan::vkCreateCommandPool( const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool) { - VkResult ret = device_dispatch_table(device)->CreateCommandPool(device, pCreateInfo, pCmdPool); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateCommandPool(device, pCreateInfo, pCmdPool); if(ret == VK_SUCCESS) { @@ -3193,7 +3197,7 @@ VkResult WrappedVulkan::vkResetCommandPool( VkCmdPoolResetFlags flags) { // VKTODOMED do I need to serialise this? just a driver hint.. - return device_dispatch_table(device)->ResetCommandPool(device, cmdPool, flags); + return get_dispatch_table(renderdoc_device_table_map, device)->ResetCommandPool(device, cmdPool, flags); } @@ -3204,7 +3208,7 @@ VkResult WrappedVulkan::vkCreateCommandBuffer( const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) { - VkResult ret = device_dispatch_table(device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); if(ret == VK_SUCCESS) { @@ -3258,7 +3262,7 @@ bool WrappedVulkan::Serialise_vkAllocDescriptorSets( VkDescriptorSetLayout layout = (VkDescriptorSetLayout)GetResourceManager()->GetLiveResource(layoutId).handle; uint32_t cnt = 0; - VkResult ret = device_dispatch_table(device)->AllocDescriptorSets(rmDev, descriptorPool, usage, 1, &layout, &descset, &cnt); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->AllocDescriptorSets(rmDev, descriptorPool, usage, 1, &layout, &descset, &cnt); if(ret != VK_SUCCESS) { @@ -3286,7 +3290,7 @@ VkResult WrappedVulkan::vkAllocDescriptorSets( VkDescriptorSet* pDescriptorSets, uint32_t* pCount) { - VkResult ret = device_dispatch_table(device)->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); RDCASSERT(pCount == NULL || *pCount == count); // VKTODOMED: find out what *pCount < count means @@ -3338,7 +3342,7 @@ VkResult WrappedVulkan::vkFreeDescriptorSets( uint32_t count, const VkDescriptorSet* pDescriptorSets) { - VkResult ret = device_dispatch_table(device)->FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets); if(ret == VK_SUCCESS) { @@ -3386,9 +3390,9 @@ bool WrappedVulkan::Serialise_vkUpdateDescriptorSets( VkDevice rmDev = (VkDevice)GetResourceManager()->GetLiveResource(devId).handle; if(writes) - device_dispatch_table(device)->UpdateDescriptorSets(rmDev, 1, &writeDesc, 0, NULL); + get_dispatch_table(renderdoc_device_table_map, device)->UpdateDescriptorSets(rmDev, 1, &writeDesc, 0, NULL); else - device_dispatch_table(device)->UpdateDescriptorSets(rmDev, 0, NULL, 1, ©Desc); + get_dispatch_table(renderdoc_device_table_map, device)->UpdateDescriptorSets(rmDev, 0, NULL, 1, ©Desc); } return true; @@ -3401,7 +3405,7 @@ VkResult WrappedVulkan::vkUpdateDescriptorSets( uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) { - VkResult ret = device_dispatch_table(device)->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies); if(ret == VK_SUCCESS) { @@ -3512,7 +3516,7 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer( m_PartialReplayData.renderPassActive = false; VkCmdBuffer cmd = VK_NULL_HANDLE; - VkResult ret = device_dispatch_table(cmdBuffer)->CreateCommandBuffer(device, &createInfo, &cmd); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CreateCommandBuffer(device, &createInfo, &cmd); if(ret != VK_SUCCESS) { @@ -3529,7 +3533,7 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer( // add one-time submit flag as this partial cmd buffer will only be submitted once info.flags |= VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT; - device_dispatch_table(cmdBuffer)->BeginCommandBuffer(cmd, &info); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->BeginCommandBuffer(cmd, &info); } } } @@ -3542,7 +3546,7 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer( if(!GetResourceManager()->HasLiveResource(bakeId)) { - VkResult ret = device_dispatch_table(cmdBuffer)->CreateCommandBuffer(device, &createInfo, &cmd); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CreateCommandBuffer(device, &createInfo, &cmd); if(ret != VK_SUCCESS) { @@ -3568,7 +3572,7 @@ bool WrappedVulkan::Serialise_vkBeginCommandBuffer( m_CmdBufferInfo[liveBaked].device = VK_NULL_HANDLE; } - device_dispatch_table(cmdBuffer)->BeginCommandBuffer(cmd, &info); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->BeginCommandBuffer(cmd, &info); } return true; @@ -3601,7 +3605,7 @@ VkResult WrappedVulkan::vkBeginCommandBuffer( } } - return device_dispatch_table(cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo); + return get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->BeginCommandBuffer(cmdBuffer, pBeginInfo); } bool WrappedVulkan::Serialise_vkEndCommandBuffer(VkCmdBuffer cmdBuffer) @@ -3627,9 +3631,9 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(VkCmdBuffer cmdBuffer) RDCDEBUG("Ending partial command buffer for %llu baked to %llu", cmdId, bakeId); if(m_PartialReplayData.renderPassActive) - device_dispatch_table(cmdBuffer)->CmdEndRenderPass(PartialCmdBuf()); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdEndRenderPass(PartialCmdBuf()); - device_dispatch_table(cmdBuffer)->EndCommandBuffer(PartialCmdBuf()); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->EndCommandBuffer(PartialCmdBuf()); m_PartialReplayData.partialParent = ResourceId(); } @@ -3642,7 +3646,7 @@ bool WrappedVulkan::Serialise_vkEndCommandBuffer(VkCmdBuffer cmdBuffer) GetResourceManager()->RemoveReplacement(cmdId); - device_dispatch_table(cmdBuffer)->EndCommandBuffer(cmd); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->EndCommandBuffer(cmd); if(!m_CurEvents.empty()) { @@ -3680,7 +3684,7 @@ VkResult WrappedVulkan::vkEndCommandBuffer(VkCmdBuffer cmdBuffer) record->Bake(); } - return device_dispatch_table(cmdBuffer)->EndCommandBuffer(cmdBuffer); + return get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->EndCommandBuffer(cmdBuffer); } bool WrappedVulkan::Serialise_vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags) @@ -3722,7 +3726,7 @@ bool WrappedVulkan::Serialise_vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdB if(!GetResourceManager()->HasLiveResource(bakeId)) { - VkResult ret = device_dispatch_table(cmdBuffer)->CreateCommandBuffer((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &cmd); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CreateCommandBuffer((VkDevice)GetResourceManager()->GetLiveResource(devId).handle, &info, &cmd); if(ret != VK_SUCCESS) { @@ -3748,7 +3752,7 @@ bool WrappedVulkan::Serialise_vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdB m_CmdBufferInfo[liveBaked].device = VK_NULL_HANDLE; } - device_dispatch_table(cmdBuffer)->ResetCommandBuffer(cmd, fl); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->ResetCommandBuffer(cmd, fl); } return true; @@ -3786,7 +3790,7 @@ VkResult WrappedVulkan::vkResetCommandBuffer( } } - return device_dispatch_table(cmdBuffer)->ResetCommandBuffer(cmdBuffer, flags); + return get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->ResetCommandBuffer(cmdBuffer, flags); } // Command buffer building functions @@ -3805,7 +3809,7 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass( if(IsPartialCmd(cmdid) && InPartialRange()) { m_PartialReplayData.renderPassActive = true; - device_dispatch_table(cmdBuffer)->CmdBeginRenderPass(PartialCmdBuf(), &beginInfo, cont); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBeginRenderPass(PartialCmdBuf(), &beginInfo, cont); m_PartialReplayData.state.renderPass = GetResourceManager()->GetOriginalID(GetResourceManager()->GetID(MakeRes(beginInfo.renderPass))); m_PartialReplayData.state.framebuffer = GetResourceManager()->GetOriginalID(GetResourceManager()->GetID(MakeRes(beginInfo.framebuffer))); @@ -3816,7 +3820,7 @@ bool WrappedVulkan::Serialise_vkCmdBeginRenderPass( { VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - device_dispatch_table(cmdBuffer)->CmdBeginRenderPass(cmd, &beginInfo, cont); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBeginRenderPass(cmd, &beginInfo, cont); const string desc = m_pSerialiser->GetDebugStr(); @@ -3837,7 +3841,7 @@ void WrappedVulkan::vkCmdBeginRenderPass( const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents) { - device_dispatch_table(cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents); if(m_State >= WRITING) { @@ -3863,7 +3867,7 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass( if(IsPartialCmd(cmdid) && InPartialRange()) { m_PartialReplayData.renderPassActive = false; - device_dispatch_table(cmdBuffer)->CmdEndRenderPass(PartialCmdBuf()); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdEndRenderPass(PartialCmdBuf()); m_PartialReplayData.state.renderPass = ResourceId(); m_PartialReplayData.state.framebuffer = ResourceId(); @@ -3874,7 +3878,7 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass( { VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - device_dispatch_table(cmdBuffer)->CmdEndRenderPass(cmd); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdEndRenderPass(cmd); } return true; @@ -3883,7 +3887,7 @@ bool WrappedVulkan::Serialise_vkCmdEndRenderPass( void WrappedVulkan::vkCmdEndRenderPass( VkCmdBuffer cmdBuffer) { - device_dispatch_table(cmdBuffer)->CmdEndRenderPass(cmdBuffer); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdEndRenderPass(cmdBuffer); if(m_State >= WRITING) { @@ -3911,7 +3915,7 @@ bool WrappedVulkan::Serialise_vkCmdBindPipeline( if(IsPartialCmd(cmdid) && InPartialRange()) { - device_dispatch_table(cmdBuffer)->CmdBindPipeline(PartialCmdBuf(), bind, pipeline); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindPipeline(PartialCmdBuf(), bind, pipeline); if(bind == VK_PIPELINE_BIND_POINT_GRAPHICS) m_PartialReplayData.state.graphics.pipeline = pipeid; else @@ -3923,7 +3927,7 @@ bool WrappedVulkan::Serialise_vkCmdBindPipeline( VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; pipeline = (VkPipeline)GetResourceManager()->GetLiveResource(pipeid).handle; - device_dispatch_table(cmdBuffer)->CmdBindPipeline(cmd, bind, pipeline); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindPipeline(cmd, bind, pipeline); } return true; @@ -3934,7 +3938,7 @@ void WrappedVulkan::vkCmdBindPipeline( VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { - device_dispatch_table(cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); if(m_State >= WRITING) { @@ -3987,7 +3991,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets( if(IsPartialCmd(cmdid) && InPartialRange()) { - device_dispatch_table(cmdBuffer)->CmdBindDescriptorSets(PartialCmdBuf(), bind, layout, first, numSets, sets, offsCount, offs); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDescriptorSets(PartialCmdBuf(), bind, layout, first, numSets, sets, offsCount, offs); vector &descsets = (bind == VK_PIPELINE_BIND_POINT_GRAPHICS) @@ -4008,7 +4012,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDescriptorSets( VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; layout = (VkPipelineLayout)GetResourceManager()->GetLiveResource(layoutid).handle; - device_dispatch_table(cmdBuffer)->CmdBindDescriptorSets(cmd, bind, layout, first, numSets, sets, offsCount, offs); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDescriptorSets(cmd, bind, layout, first, numSets, sets, offsCount, offs); } if(m_State < WRITING) @@ -4030,7 +4034,7 @@ void WrappedVulkan::vkCmdBindDescriptorSets( uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { - device_dispatch_table(cmdBuffer)->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); if(m_State >= WRITING) { @@ -4139,7 +4143,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDynamicViewportState( if(IsPartialCmd(cmdid) && InPartialRange()) { - device_dispatch_table(cmdBuffer)->CmdBindDynamicViewportState(PartialCmdBuf(), dynamicViewportState); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDynamicViewportState(PartialCmdBuf(), dynamicViewportState); m_PartialReplayData.state.dynamicVP = stateid; } } @@ -4148,7 +4152,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDynamicViewportState( VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; dynamicViewportState = (VkDynamicViewportState)GetResourceManager()->GetLiveResource(stateid).handle; - device_dispatch_table(cmdBuffer)->CmdBindDynamicViewportState(cmd, dynamicViewportState); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDynamicViewportState(cmd, dynamicViewportState); } return true; @@ -4158,7 +4162,7 @@ void WrappedVulkan::vkCmdBindDynamicViewportState( VkCmdBuffer cmdBuffer, VkDynamicViewportState dynamicViewportState) { - device_dispatch_table(cmdBuffer)->CmdBindDynamicViewportState(cmdBuffer, dynamicViewportState); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDynamicViewportState(cmdBuffer, dynamicViewportState); if(m_State >= WRITING) { @@ -4185,7 +4189,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDynamicRasterState( if(IsPartialCmd(cmdid) && InPartialRange()) { - device_dispatch_table(cmdBuffer)->CmdBindDynamicRasterState(PartialCmdBuf(), dynamicRasterState); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDynamicRasterState(PartialCmdBuf(), dynamicRasterState); m_PartialReplayData.state.dynamicRS = stateid; } } @@ -4194,7 +4198,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDynamicRasterState( VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; dynamicRasterState = (VkDynamicRasterState)GetResourceManager()->GetLiveResource(stateid).handle; - device_dispatch_table(cmdBuffer)->CmdBindDynamicRasterState(cmd, dynamicRasterState); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDynamicRasterState(cmd, dynamicRasterState); } return true; @@ -4204,7 +4208,7 @@ void WrappedVulkan::vkCmdBindDynamicRasterState( VkCmdBuffer cmdBuffer, VkDynamicRasterState dynamicRasterState) { - device_dispatch_table(cmdBuffer)->CmdBindDynamicRasterState(cmdBuffer, dynamicRasterState); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDynamicRasterState(cmdBuffer, dynamicRasterState); if(m_State >= WRITING) { @@ -4231,7 +4235,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDynamicColorBlendState( if(IsPartialCmd(cmdid) && InPartialRange()) { - device_dispatch_table(cmdBuffer)->CmdBindDynamicColorBlendState(PartialCmdBuf(), dynamicColorBlendState); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDynamicColorBlendState(PartialCmdBuf(), dynamicColorBlendState); m_PartialReplayData.state.dynamicCB = stateid; } } @@ -4240,7 +4244,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDynamicColorBlendState( VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; dynamicColorBlendState = (VkDynamicColorBlendState)GetResourceManager()->GetLiveResource(stateid).handle; - device_dispatch_table(cmdBuffer)->CmdBindDynamicColorBlendState(cmd, dynamicColorBlendState); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDynamicColorBlendState(cmd, dynamicColorBlendState); } return true; @@ -4250,7 +4254,7 @@ void WrappedVulkan::vkCmdBindDynamicColorBlendState( VkCmdBuffer cmdBuffer, VkDynamicColorBlendState dynamicColorBlendState) { - device_dispatch_table(cmdBuffer)->CmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDynamicColorBlendState(cmdBuffer, dynamicColorBlendState); if(m_State >= WRITING) { @@ -4277,7 +4281,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDynamicDepthStencilState( if(IsPartialCmd(cmdid) && InPartialRange()) { - device_dispatch_table(cmdBuffer)->CmdBindDynamicDepthStencilState(PartialCmdBuf(), dynamicDepthStencilState); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDynamicDepthStencilState(PartialCmdBuf(), dynamicDepthStencilState); m_PartialReplayData.state.dynamicDS = stateid; } } @@ -4286,7 +4290,7 @@ bool WrappedVulkan::Serialise_vkCmdBindDynamicDepthStencilState( VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; dynamicDepthStencilState = (VkDynamicDepthStencilState)GetResourceManager()->GetLiveResource(stateid).handle; - device_dispatch_table(cmdBuffer)->CmdBindDynamicDepthStencilState(cmd, dynamicDepthStencilState); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDynamicDepthStencilState(cmd, dynamicDepthStencilState); } return true; @@ -4296,7 +4300,7 @@ void WrappedVulkan::vkCmdBindDynamicDepthStencilState( VkCmdBuffer cmdBuffer, VkDynamicDepthStencilState dynamicDepthStencilState) { - device_dispatch_table(cmdBuffer)->CmdBindDynamicDepthStencilState(cmdBuffer, dynamicDepthStencilState); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindDynamicDepthStencilState(cmdBuffer, dynamicDepthStencilState); if(m_State >= WRITING) { @@ -4350,7 +4354,7 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers( { if(IsPartialCmd(cmdid) && InPartialRange()) { - device_dispatch_table(cmdBuffer)->CmdBindVertexBuffers(PartialCmdBuf(), start, count, &bufs[0], &offs[0]); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindVertexBuffers(PartialCmdBuf(), start, count, &bufs[0], &offs[0]); if(m_PartialReplayData.state.vbuffers.size() < start + count) m_PartialReplayData.state.vbuffers.resize(start + count); @@ -4366,7 +4370,7 @@ bool WrappedVulkan::Serialise_vkCmdBindVertexBuffers( { VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - device_dispatch_table(cmdBuffer)->CmdBindVertexBuffers(cmd, start, count, &bufs[0], &offs[0]); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindVertexBuffers(cmd, start, count, &bufs[0], &offs[0]); } return true; @@ -4379,7 +4383,7 @@ void WrappedVulkan::vkCmdBindVertexBuffers( const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { - device_dispatch_table(cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets); if(m_State >= WRITING) { @@ -4412,7 +4416,7 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer( if(IsPartialCmd(cmdid) && InPartialRange()) { - device_dispatch_table(cmdBuffer)->CmdBindIndexBuffer(PartialCmdBuf(), buffer, offs, idxType); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindIndexBuffer(PartialCmdBuf(), buffer, offs, idxType); m_PartialReplayData.state.ibuffer.buf = bufid; m_PartialReplayData.state.ibuffer.offs = offs; @@ -4424,7 +4428,7 @@ bool WrappedVulkan::Serialise_vkCmdBindIndexBuffer( VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; - device_dispatch_table(cmdBuffer)->CmdBindIndexBuffer(cmd, buffer, offs, idxType); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindIndexBuffer(cmd, buffer, offs, idxType); } return true; @@ -4436,7 +4440,7 @@ void WrappedVulkan::vkCmdBindIndexBuffer( VkDeviceSize offset, VkIndexType indexType) { - device_dispatch_table(cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); if(m_State >= WRITING) { @@ -4466,13 +4470,13 @@ bool WrappedVulkan::Serialise_vkCmdDraw( if(m_State == EXECUTING) { if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdDraw(PartialCmdBuf(), firstVtx, vtxCount, firstInst, instCount); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDraw(PartialCmdBuf(), firstVtx, vtxCount, firstInst, instCount); } else if(m_State == READING) { VkCmdBuffer buf = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - device_dispatch_table(cmdBuffer)->CmdDraw(buf, firstVtx, vtxCount, firstInst, instCount); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDraw(buf, firstVtx, vtxCount, firstInst, instCount); const string desc = m_pSerialiser->GetDebugStr(); @@ -4506,7 +4510,7 @@ void WrappedVulkan::vkCmdDraw( uint32_t firstInstance, uint32_t instanceCount) { - device_dispatch_table(cmdBuffer)->CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); if(m_State >= WRITING) { @@ -4546,7 +4550,7 @@ bool WrappedVulkan::Serialise_vkCmdBlitImage( destImage = (VkImage)GetResourceManager()->GetLiveResource(dstid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdBlitImage(PartialCmdBuf(), srcImage, srclayout, destImage, dstlayout, count, regions, f); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBlitImage(PartialCmdBuf(), srcImage, srclayout, destImage, dstlayout, count, regions, f); } else if(m_State == READING) { @@ -4554,7 +4558,7 @@ bool WrappedVulkan::Serialise_vkCmdBlitImage( srcImage = (VkImage)GetResourceManager()->GetLiveResource(srcid).handle; destImage = (VkImage)GetResourceManager()->GetLiveResource(dstid).handle; - device_dispatch_table(cmdBuffer)->CmdBlitImage(cmd, srcImage, srclayout, destImage, dstlayout, count, regions, f); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBlitImage(cmd, srcImage, srclayout, destImage, dstlayout, count, regions, f); } SAFE_DELETE_ARRAY(regions); @@ -4572,7 +4576,7 @@ void WrappedVulkan::vkCmdBlitImage( const VkImageBlit* pRegions, VkTexFilter filter) { - device_dispatch_table(cmdBuffer)->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter); if(m_State >= WRITING) { @@ -4613,7 +4617,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyImage( destImage = (VkImage)GetResourceManager()->GetLiveResource(dstid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdCopyImage(PartialCmdBuf(), srcImage, srclayout, destImage, dstlayout, count, regions); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdCopyImage(PartialCmdBuf(), srcImage, srclayout, destImage, dstlayout, count, regions); } else if(m_State == READING) { @@ -4621,7 +4625,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyImage( srcImage = (VkImage)GetResourceManager()->GetLiveResource(srcid).handle; destImage = (VkImage)GetResourceManager()->GetLiveResource(dstid).handle; - device_dispatch_table(cmdBuffer)->CmdCopyImage(cmd, srcImage, srclayout, destImage, dstlayout, count, regions); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdCopyImage(cmd, srcImage, srclayout, destImage, dstlayout, count, regions); } SAFE_DELETE_ARRAY(regions); @@ -4638,7 +4642,7 @@ void WrappedVulkan::vkCmdCopyImage( uint32_t regionCount, const VkImageCopy* pRegions) { - device_dispatch_table(cmdBuffer)->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); if(m_State >= WRITING) { @@ -4677,7 +4681,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyBufferToImage( destImage = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdCopyBufferToImage(PartialCmdBuf(), srcBuffer, destImage, destImageLayout, count, regions); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdCopyBufferToImage(PartialCmdBuf(), srcBuffer, destImage, destImageLayout, count, regions); } else if(m_State == READING) { @@ -4685,7 +4689,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyBufferToImage( srcBuffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; destImage = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; - device_dispatch_table(cmdBuffer)->CmdCopyBufferToImage(cmd, srcBuffer, destImage, destImageLayout, count, regions); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdCopyBufferToImage(cmd, srcBuffer, destImage, destImageLayout, count, regions); } SAFE_DELETE_ARRAY(regions); @@ -4701,7 +4705,7 @@ void WrappedVulkan::vkCmdCopyBufferToImage( uint32_t regionCount, const VkBufferImageCopy* pRegions) { - device_dispatch_table(cmdBuffer)->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); if(m_State >= WRITING) { @@ -4741,7 +4745,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyImageToBuffer( destBuffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdCopyImageToBuffer(PartialCmdBuf(), srcImage, layout, destBuffer, count, regions); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdCopyImageToBuffer(PartialCmdBuf(), srcImage, layout, destBuffer, count, regions); } else if(m_State == READING) { @@ -4749,7 +4753,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyImageToBuffer( srcImage = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; destBuffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; - device_dispatch_table(cmdBuffer)->CmdCopyImageToBuffer(cmd, srcImage, layout, destBuffer, count, regions); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdCopyImageToBuffer(cmd, srcImage, layout, destBuffer, count, regions); } SAFE_DELETE_ARRAY(regions); @@ -4765,7 +4769,7 @@ void WrappedVulkan::vkCmdCopyImageToBuffer( uint32_t regionCount, const VkBufferImageCopy* pRegions) { - device_dispatch_table(cmdBuffer)->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); if(m_State >= WRITING) { @@ -4803,7 +4807,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyBuffer( destBuffer = (VkBuffer)GetResourceManager()->GetLiveResource(dstid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdCopyBuffer(PartialCmdBuf(), srcBuffer, destBuffer, count, regions); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdCopyBuffer(PartialCmdBuf(), srcBuffer, destBuffer, count, regions); } else if(m_State == READING) { @@ -4811,7 +4815,7 @@ bool WrappedVulkan::Serialise_vkCmdCopyBuffer( srcBuffer = (VkBuffer)GetResourceManager()->GetLiveResource(srcid).handle; destBuffer = (VkBuffer)GetResourceManager()->GetLiveResource(dstid).handle; - device_dispatch_table(cmdBuffer)->CmdCopyBuffer(cmd, srcBuffer, destBuffer, count, regions); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdCopyBuffer(cmd, srcBuffer, destBuffer, count, regions); } SAFE_DELETE_ARRAY(regions); @@ -4826,7 +4830,7 @@ void WrappedVulkan::vkCmdCopyBuffer( uint32_t regionCount, const VkBufferCopy* pRegions) { - device_dispatch_table(cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); if(m_State >= WRITING) { @@ -4865,14 +4869,14 @@ bool WrappedVulkan::Serialise_vkCmdClearColorImage( image = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdClearColorImage(PartialCmdBuf(), image, layout, &col, count, ranges); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdClearColorImage(PartialCmdBuf(), image, layout, &col, count, ranges); } else if(m_State == READING) { VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; image = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; - device_dispatch_table(cmdBuffer)->CmdClearColorImage(cmd, image, layout, &col, count, ranges); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdClearColorImage(cmd, image, layout, &col, count, ranges); } SAFE_DELETE_ARRAY(ranges); @@ -4888,7 +4892,7 @@ void WrappedVulkan::vkCmdClearColorImage( uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { - device_dispatch_table(cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges); if(m_State >= WRITING) { @@ -4924,14 +4928,14 @@ bool WrappedVulkan::Serialise_vkCmdClearDepthStencilImage( image = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdClearDepthStencilImage(PartialCmdBuf(), image, l, d, s, count, ranges); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdClearDepthStencilImage(PartialCmdBuf(), image, l, d, s, count, ranges); } else if(m_State == READING) { VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; image = (VkImage)GetResourceManager()->GetLiveResource(imgid).handle; - device_dispatch_table(cmdBuffer)->CmdClearDepthStencilImage(cmd, image, l, d, s, count, ranges); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdClearDepthStencilImage(cmd, image, l, d, s, count, ranges); } SAFE_DELETE_ARRAY(ranges); @@ -4948,7 +4952,7 @@ void WrappedVulkan::vkCmdClearDepthStencilImage( uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { - device_dispatch_table(cmdBuffer)->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); if(m_State >= WRITING) { @@ -4981,13 +4985,13 @@ bool WrappedVulkan::Serialise_vkCmdClearColorAttachment( if(m_State == EXECUTING) { if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdClearColorAttachment(PartialCmdBuf(), att, layout, &col, count, rects); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdClearColorAttachment(PartialCmdBuf(), att, layout, &col, count, rects); } else if(m_State == READING) { VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - device_dispatch_table(cmdBuffer)->CmdClearColorAttachment(cmdBuffer, att, layout, &col, count, rects); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdClearColorAttachment(cmdBuffer, att, layout, &col, count, rects); const string desc = m_pSerialiser->GetDebugStr(); @@ -5018,7 +5022,7 @@ void WrappedVulkan::vkCmdClearColorAttachment( uint32_t rectCount, const VkRect3D* pRects) { - device_dispatch_table(cmdBuffer)->CmdClearColorAttachment(cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdClearColorAttachment(cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects); if(m_State >= WRITING) { @@ -5053,13 +5057,13 @@ bool WrappedVulkan::Serialise_vkCmdClearDepthStencilAttachment( if(m_State == EXECUTING) { if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdClearDepthStencilAttachment(PartialCmdBuf(), asp, lay, d, s, count, rects); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdClearDepthStencilAttachment(PartialCmdBuf(), asp, lay, d, s, count, rects); } else if(m_State == READING) { VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - device_dispatch_table(cmdBuffer)->CmdClearDepthStencilAttachment(cmd, asp, lay, d, s, count, rects); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdClearDepthStencilAttachment(cmd, asp, lay, d, s, count, rects); } SAFE_DELETE_ARRAY(rects); @@ -5076,7 +5080,7 @@ void WrappedVulkan::vkCmdClearDepthStencilAttachment( uint32_t rectCount, const VkRect3D* pRects) { - device_dispatch_table(cmdBuffer)->CmdClearDepthStencilAttachment(cmdBuffer, imageAspectMask, imageLayout, depth, stencil, rectCount, pRects); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdClearDepthStencilAttachment(cmdBuffer, imageAspectMask, imageLayout, depth, stencil, rectCount, pRects); if(m_State >= WRITING) { @@ -5144,7 +5148,7 @@ bool WrappedVulkan::Serialise_vkCmdPipelineBarrier( { if(IsPartialCmd(cmdid) && InPartialRange()) { - device_dispatch_table(cmdBuffer)->CmdPipelineBarrier(PartialCmdBuf(), src, dest, region, memCount, (const void **)&mems[0]); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdPipelineBarrier(PartialCmdBuf(), src, dest, region, memCount, (const void **)&mems[0]); ResourceId cmd = GetResourceManager()->GetID(MakeRes(PartialCmdBuf())); GetResourceManager()->RecordTransitions(m_CmdBufferInfo[cmd].imgtransitions, m_ImageInfo, (uint32_t)imTrans.size(), &imTrans[0]); @@ -5154,7 +5158,7 @@ bool WrappedVulkan::Serialise_vkCmdPipelineBarrier( { VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - device_dispatch_table(cmdBuffer)->CmdPipelineBarrier(cmd, src, dest, region, memCount, (const void **)&mems[0]); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdPipelineBarrier(cmd, src, dest, region, memCount, (const void **)&mems[0]); ResourceId rmcmd = GetResourceManager()->GetID(MakeRes(cmdBuffer)); GetResourceManager()->RecordTransitions(m_CmdBufferInfo[rmcmd].imgtransitions, m_ImageInfo, (uint32_t)imTrans.size(), &imTrans[0]); @@ -5174,7 +5178,7 @@ void WrappedVulkan::vkCmdPipelineBarrier( uint32_t memBarrierCount, const void* const* ppMemBarriers) { - device_dispatch_table(cmdBuffer)->CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers); if(m_State >= WRITING) { @@ -5210,14 +5214,14 @@ VkResult WrappedVulkan::vkDbgCreateMsgCallback( void* pUserData, VkDbgMsgCallback* pMsgCallback) { - return instance_dispatch_table(instance)->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback); + return get_dispatch_table(renderdoc_instance_table_map, instance)->DbgCreateMsgCallback(instance, msgFlags, pfnMsgCallback, pUserData, pMsgCallback); } VkResult WrappedVulkan::vkDbgDestroyMsgCallback( VkInstance instance, VkDbgMsgCallback msgCallback) { - return instance_dispatch_table(instance)->DbgDestroyMsgCallback(instance, msgCallback); + return get_dispatch_table(renderdoc_instance_table_map, instance)->DbgDestroyMsgCallback(instance, msgCallback); } bool WrappedVulkan::Serialise_vkCmdDbgMarkerBegin( @@ -5439,7 +5443,7 @@ bool WrappedVulkan::Serialise_BeginCaptureFrame(bool applyInitialState) VkCmdBufferBeginInfo beginInfo = { VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, NULL, VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT }; - device_dispatch_table(cmd)->BeginCommandBuffer(cmd, &beginInfo); + get_dispatch_table(renderdoc_device_table_map, cmd)->BeginCommandBuffer(cmd, &beginInfo); VkPipelineStageFlags src_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; VkPipelineStageFlags dest_stages = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; @@ -5449,11 +5453,11 @@ bool WrappedVulkan::Serialise_BeginCaptureFrame(bool applyInitialState) vector barriers; for(size_t i=0; i < imgTransitions.size(); i++) barriers.push_back(&imgTransitions[i]); - device_dispatch_table(cmd)->CmdPipelineBarrier(cmd, src_stages, dest_stages, false, (uint32_t)imgTransitions.size(), (const void *const *)&barriers[0]); + get_dispatch_table(renderdoc_device_table_map, cmd)->CmdPipelineBarrier(cmd, src_stages, dest_stages, false, (uint32_t)imgTransitions.size(), (const void *const *)&barriers[0]); } - device_dispatch_table(cmd)->EndCommandBuffer(cmd); - device_dispatch_table(GetQ())->QueueSubmit(GetQ(), 1, &cmd, VK_NULL_HANDLE); + get_dispatch_table(renderdoc_device_table_map, cmd)->EndCommandBuffer(cmd); + get_dispatch_table(renderdoc_device_table_map, GetQ())->QueueSubmit(GetQ(), 1, &cmd, VK_NULL_HANDLE); } return true; @@ -5476,7 +5480,7 @@ void WrappedVulkan::FinishCapture() //m_SuccessfulCapture = false; - device_dispatch_table(GetDev())->DeviceWaitIdle(GetDev()); + get_dispatch_table(renderdoc_device_table_map, GetDev())->DeviceWaitIdle(GetDev()); } void WrappedVulkan::ReadLogInitialisation() @@ -5591,7 +5595,7 @@ void WrappedVulkan::ContextReplayLog(LogState readType, uint32_t startEventID, u Serialise_BeginCaptureFrame(!partial); - device_dispatch_table(GetDev())->DeviceWaitIdle(GetDev()); + get_dispatch_table(renderdoc_device_table_map, GetDev())->DeviceWaitIdle(GetDev()); m_pSerialiser->PopContext(NULL, header); @@ -5673,8 +5677,8 @@ void WrappedVulkan::ContextReplayLog(LogState readType, uint32_t startEventID, u if(m_PartialReplayData.resultPartialCmdBuffer != VK_NULL_HANDLE) { - device_dispatch_table(GetDev())->DeviceWaitIdle(m_PartialReplayData.partialDevice); - device_dispatch_table(GetDev())->DestroyCommandBuffer(m_PartialReplayData.partialDevice, m_PartialReplayData.resultPartialCmdBuffer); + get_dispatch_table(renderdoc_device_table_map, GetDev())->DeviceWaitIdle(m_PartialReplayData.partialDevice); + get_dispatch_table(renderdoc_device_table_map, GetDev())->DestroyCommandBuffer(m_PartialReplayData.partialDevice, m_PartialReplayData.resultPartialCmdBuffer); m_PartialReplayData.resultPartialCmdBuffer = VK_NULL_HANDLE; } @@ -5792,13 +5796,13 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexed( if(m_State == EXECUTING) { if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdDrawIndexed(PartialCmdBuf(), firstIdx, idxCount, vtxOffs, firstInst, instCount); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDrawIndexed(PartialCmdBuf(), firstIdx, idxCount, vtxOffs, firstInst, instCount); } else if(m_State == READING) { VkCmdBuffer buf = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - device_dispatch_table(cmdBuffer)->CmdDrawIndexed(buf, firstIdx, idxCount, vtxOffs, firstInst, instCount); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDrawIndexed(buf, firstIdx, idxCount, vtxOffs, firstInst, instCount); } return true; @@ -5812,7 +5816,7 @@ void WrappedVulkan::vkCmdDrawIndexed( uint32_t firstInstance, uint32_t instanceCount) { - device_dispatch_table(cmdBuffer)->CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); if(m_State >= WRITING) { @@ -5844,14 +5848,14 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndirect( buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdDrawIndirect(PartialCmdBuf(), buffer, offs, cnt, strd); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDrawIndirect(PartialCmdBuf(), buffer, offs, cnt, strd); } else if(m_State == READING) { VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; - device_dispatch_table(cmdBuffer)->CmdDrawIndirect(cmd, buffer, offs, cnt, strd); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDrawIndirect(cmd, buffer, offs, cnt, strd); } return true; @@ -5864,7 +5868,7 @@ void WrappedVulkan::vkCmdDrawIndirect( uint32_t count, uint32_t stride) { - device_dispatch_table(cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); if(m_State >= WRITING) { @@ -5896,14 +5900,14 @@ bool WrappedVulkan::Serialise_vkCmdDrawIndexedIndirect( buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdDrawIndexedIndirect(PartialCmdBuf(), buffer, offs, cnt, strd); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDrawIndexedIndirect(PartialCmdBuf(), buffer, offs, cnt, strd); } else if(m_State == READING) { VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; - device_dispatch_table(cmdBuffer)->CmdDrawIndexedIndirect(cmd, buffer, offs, cnt, strd); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDrawIndexedIndirect(cmd, buffer, offs, cnt, strd); } return true; @@ -5916,7 +5920,7 @@ void WrappedVulkan::vkCmdDrawIndexedIndirect( uint32_t count, uint32_t stride) { - device_dispatch_table(cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); if(m_State >= WRITING) { @@ -5943,13 +5947,13 @@ bool WrappedVulkan::Serialise_vkCmdDispatch( if(m_State == EXECUTING) { if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdDispatch(PartialCmdBuf(), x, y, z); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDispatch(PartialCmdBuf(), x, y, z); } else if(m_State == READING) { VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; - device_dispatch_table(cmdBuffer)->CmdDispatch(cmd, X, Y, Z); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDispatch(cmd, X, Y, Z); } return true; @@ -5961,7 +5965,7 @@ void WrappedVulkan::vkCmdDispatch( uint32_t y, uint32_t z) { - device_dispatch_table(cmdBuffer)->CmdDispatch(cmdBuffer, x, y, z); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDispatch(cmdBuffer, x, y, z); if(m_State >= WRITING) { @@ -5988,14 +5992,14 @@ bool WrappedVulkan::Serialise_vkCmdDispatchIndirect( buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; if(IsPartialCmd(cmdid) && InPartialRange()) - device_dispatch_table(cmdBuffer)->CmdDispatchIndirect(PartialCmdBuf(), buffer, offs); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDispatchIndirect(PartialCmdBuf(), buffer, offs); } else if(m_State == READING) { VkCmdBuffer cmd = (VkCmdBuffer)GetResourceManager()->GetLiveResource(cmdid).handle; buffer = (VkBuffer)GetResourceManager()->GetLiveResource(bufid).handle; - device_dispatch_table(cmdBuffer)->CmdDispatchIndirect(cmd, buffer, offs); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDispatchIndirect(cmd, buffer, offs); } return true; @@ -6006,7 +6010,7 @@ void WrappedVulkan::vkCmdDispatchIndirect( VkBuffer buffer, VkDeviceSize offset) { - device_dispatch_table(cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset); + get_dispatch_table(renderdoc_device_table_map, cmdBuffer)->CmdDispatchIndirect(cmdBuffer, buffer, offset); if(m_State >= WRITING) { @@ -6028,7 +6032,7 @@ VkResult WrappedVulkan::vkGetPhysicalDeviceSurfaceSupportWSI( const VkSurfaceDescriptionWSI* pSurfaceDescription, VkBool32* pSupported) { - return instance_dispatch_table(physicalDevice)->GetPhysicalDeviceSurfaceSupportWSI(physicalDevice, queueFamilyIndex, pSurfaceDescription, pSupported); + return get_dispatch_table(renderdoc_instance_table_map, physicalDevice)->GetPhysicalDeviceSurfaceSupportWSI(physicalDevice, queueFamilyIndex, pSurfaceDescription, pSupported); } VkResult WrappedVulkan::vkGetSurfaceInfoWSI( @@ -6038,7 +6042,7 @@ VkResult WrappedVulkan::vkGetSurfaceInfoWSI( size_t* pDataSize, void* pData) { - return device_dispatch_table(device)->GetSurfaceInfoWSI(device, pSurfaceDescription, infoType, pDataSize, pData); + return get_dispatch_table(renderdoc_device_table_map, device)->GetSurfaceInfoWSI(device, pSurfaceDescription, infoType, pDataSize, pData); } bool WrappedVulkan::Serialise_vkGetSwapChainInfoWSI( @@ -6083,7 +6087,7 @@ VkResult WrappedVulkan::vkGetSwapChainInfoWSI( if(pDataSize == NULL) pDataSize = &dummySize; - VkResult ret = device_dispatch_table(device)->GetSwapChainInfoWSI(device, swapChain, infoType, pDataSize, pData); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->GetSwapChainInfoWSI(device, swapChain, infoType, pDataSize, pData); if(infoType == VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI && pData && m_State >= WRITING) { @@ -6137,7 +6141,7 @@ VkResult WrappedVulkan::vkAcquireNextImageWSI( uint32_t* pImageIndex) { // VKTODOLOW: does this need to be intercepted/serialised? - return device_dispatch_table(device)->AcquireNextImageWSI(device, swapChain, timeout, semaphore, pImageIndex); + return get_dispatch_table(renderdoc_device_table_map, device)->AcquireNextImageWSI(device, swapChain, timeout, semaphore, pImageIndex); } bool WrappedVulkan::Serialise_vkCreateSwapChainWSI( @@ -6156,7 +6160,7 @@ bool WrappedVulkan::Serialise_vkCreateSwapChainWSI( VkResult vkr = VK_SUCCESS; size_t swapChainImagesSize; - vkr = device_dispatch_table(device)->GetSwapChainInfoWSI(device, *pSwapChain, VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, &swapChainImagesSize, NULL); + vkr = get_dispatch_table(renderdoc_device_table_map, device)->GetSwapChainInfoWSI(device, *pSwapChain, VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, &swapChainImagesSize, NULL); RDCASSERT(vkr == VK_SUCCESS); numIms = uint32_t(swapChainImagesSize/sizeof(VkSwapChainImagePropertiesWSI)); @@ -6203,12 +6207,12 @@ bool WrappedVulkan::Serialise_vkCreateSwapChainWSI( VkDeviceMemory mem = VK_NULL_HANDLE; VkImage im = VK_NULL_HANDLE; - VkResult vkr = device_dispatch_table(device)->CreateImage(dev, &imInfo, &im); + VkResult vkr = get_dispatch_table(renderdoc_device_table_map, device)->CreateImage(dev, &imInfo, &im); RDCASSERT(vkr == VK_SUCCESS); VkMemoryRequirements mrq = {0}; - vkr = device_dispatch_table(device)->GetImageMemoryRequirements(dev, im, &mrq); + vkr = get_dispatch_table(renderdoc_device_table_map, device)->GetImageMemoryRequirements(dev, im, &mrq); RDCASSERT(vkr == VK_SUCCESS); VkMemoryAllocInfo allocInfo = { @@ -6216,10 +6220,10 @@ bool WrappedVulkan::Serialise_vkCreateSwapChainWSI( mrq.size, GetGPULocalMemoryIndex(mrq.memoryTypeBits), }; - vkr = device_dispatch_table(device)->AllocMemory(dev, &allocInfo, &mem); + vkr = get_dispatch_table(renderdoc_device_table_map, device)->AllocMemory(dev, &allocInfo, &mem); RDCASSERT(vkr == VK_SUCCESS); - vkr = device_dispatch_table(device)->BindImageMemory(dev, im, mem, 0); + vkr = get_dispatch_table(renderdoc_device_table_map, device)->BindImageMemory(dev, im, mem, 0); RDCASSERT(vkr == VK_SUCCESS); GetResourceManager()->RegisterResource(MakeRes(mem)); @@ -6260,7 +6264,7 @@ VkResult WrappedVulkan::vkCreateSwapChainWSI( const VkSwapChainCreateInfoWSI* pCreateInfo, VkSwapChainWSI* pSwapChain) { - VkResult ret = device_dispatch_table(device)->CreateSwapChainWSI(device, pCreateInfo, pSwapChain); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->CreateSwapChainWSI(device, pCreateInfo, pSwapChain); if(ret == VK_SUCCESS) { @@ -6290,7 +6294,7 @@ VkResult WrappedVulkan::vkCreateSwapChainWSI( // serialise out the swap chain images { size_t swapChainImagesSize; - VkResult ret = device_dispatch_table(device)->GetSwapChainInfoWSI(device, *pSwapChain, VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, &swapChainImagesSize, NULL); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, device)->GetSwapChainInfoWSI(device, *pSwapChain, VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI, &swapChainImagesSize, NULL); RDCASSERT(ret == VK_SUCCESS); uint32_t numSwapImages = uint32_t(swapChainImagesSize)/sizeof(VkSwapChainImagePropertiesWSI); @@ -6344,7 +6348,7 @@ VkResult WrappedVulkan::vkQueuePresentWSI( VkQueue queue, VkPresentInfoWSI* pPresentInfo) { - VkResult ret = device_dispatch_table(queue)->QueuePresentWSI(queue, pPresentInfo); + VkResult ret = get_dispatch_table(renderdoc_device_table_map, queue)->QueuePresentWSI(queue, pPresentInfo); if(ret != VK_SUCCESS || pPresentInfo->swapChainCount == 0) return ret; @@ -6566,12 +6570,12 @@ bool WrappedVulkan::Prepare_InitialState(VkResource res) meminfo.size, GetReadbackMemoryIndex(mrq.memoryTypeBits), }; - vkr = device_dispatch_table(d)->AllocMemory(d, &allocInfo, &mem); + vkr = get_dispatch_table(renderdoc_device_table_map, d)->AllocMemory(d, &allocInfo, &mem); RDCASSERT(vkr == VK_SUCCESS); VkCmdBufferBeginInfo beginInfo = { VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, NULL, VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT }; - vkr = device_dispatch_table(d)->BeginCommandBuffer(cmd, &beginInfo); + vkr = get_dispatch_table(renderdoc_device_table_map, d)->BeginCommandBuffer(cmd, &beginInfo); RDCASSERT(vkr == VK_SUCCESS); VkBufferCreateInfo bufInfo = { @@ -6582,33 +6586,33 @@ bool WrappedVulkan::Prepare_InitialState(VkResource res) VkBuffer srcBuf, dstBuf; - vkr = device_dispatch_table(d)->CreateBuffer(d, &bufInfo, &srcBuf); + vkr = get_dispatch_table(renderdoc_device_table_map, d)->CreateBuffer(d, &bufInfo, &srcBuf); RDCASSERT(vkr == VK_SUCCESS); - vkr = device_dispatch_table(d)->CreateBuffer(d, &bufInfo, &dstBuf); + vkr = get_dispatch_table(renderdoc_device_table_map, d)->CreateBuffer(d, &bufInfo, &dstBuf); RDCASSERT(vkr == VK_SUCCESS); - vkr = device_dispatch_table(d)->BindBufferMemory(d, srcBuf, (VkDeviceMemory)res.handle, 0); + vkr = get_dispatch_table(renderdoc_device_table_map, d)->BindBufferMemory(d, srcBuf, (VkDeviceMemory)res.handle, 0); RDCASSERT(vkr == VK_SUCCESS); - vkr = device_dispatch_table(d)->BindBufferMemory(d, dstBuf, mem, 0); + vkr = get_dispatch_table(renderdoc_device_table_map, d)->BindBufferMemory(d, dstBuf, mem, 0); RDCASSERT(vkr == VK_SUCCESS); VkBufferCopy region = { 0, 0, meminfo.size }; - device_dispatch_table(d)->CmdCopyBuffer(cmd, srcBuf, dstBuf, 1, ®ion); + get_dispatch_table(renderdoc_device_table_map, d)->CmdCopyBuffer(cmd, srcBuf, dstBuf, 1, ®ion); - vkr = device_dispatch_table(d)->EndCommandBuffer(cmd); + vkr = get_dispatch_table(renderdoc_device_table_map, d)->EndCommandBuffer(cmd); RDCASSERT(vkr == VK_SUCCESS); - vkr = device_dispatch_table(d)->QueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); + vkr = get_dispatch_table(renderdoc_device_table_map, d)->QueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); RDCASSERT(vkr == VK_SUCCESS); // VKTODOMED would be nice to store a fence too at this point // so we can sync on that on serialise rather than syncing // every time. - device_dispatch_table(d)->QueueWaitIdle(q); + get_dispatch_table(renderdoc_device_table_map, d)->QueueWaitIdle(q); - device_dispatch_table(d)->DestroyBuffer(d, srcBuf); - device_dispatch_table(d)->DestroyBuffer(d, dstBuf); + get_dispatch_table(renderdoc_device_table_map, d)->DestroyBuffer(d, srcBuf); + get_dispatch_table(renderdoc_device_table_map, d)->DestroyBuffer(d, dstBuf); GetResourceManager()->SetInitialContents(id, VulkanResourceManager::InitialContentData(MakeRes(mem), (uint32_t)meminfo.size, NULL)); @@ -6664,13 +6668,13 @@ bool WrappedVulkan::Serialise_InitialState(VkResource res) VkDevice d = GetDev(); byte *ptr = NULL; - device_dispatch_table(d)->MapMemory(d, (VkDeviceMemory)initContents.resource.handle, 0, 0, 0, (void **)&ptr); + get_dispatch_table(renderdoc_device_table_map, d)->MapMemory(d, (VkDeviceMemory)initContents.resource.handle, 0, 0, 0, (void **)&ptr); size_t dataSize = (size_t)initContents.num; m_pSerialiser->SerialiseBuffer("data", ptr, dataSize); - device_dispatch_table(d)->UnmapMemory(d, (VkDeviceMemory)initContents.resource.handle); + get_dispatch_table(renderdoc_device_table_map, d)->UnmapMemory(d, (VkDeviceMemory)initContents.resource.handle); } } else @@ -6732,7 +6736,7 @@ bool WrappedVulkan::Serialise_InitialState(VkResource res) dataSize, GetUploadMemoryIndex(mrq.memoryTypeBits), }; - vkr = device_dispatch_table(d)->AllocMemory(d, &allocInfo, &mem); + vkr = get_dispatch_table(renderdoc_device_table_map, d)->AllocMemory(d, &allocInfo, &mem); RDCASSERT(vkr == VK_SUCCESS); VkBufferCreateInfo bufInfo = { @@ -6743,20 +6747,20 @@ bool WrappedVulkan::Serialise_InitialState(VkResource res) VkBuffer buf; - vkr = device_dispatch_table(d)->CreateBuffer(d, &bufInfo, &buf); + vkr = get_dispatch_table(renderdoc_device_table_map, d)->CreateBuffer(d, &bufInfo, &buf); RDCASSERT(vkr == VK_SUCCESS); - vkr = device_dispatch_table(d)->BindBufferMemory(d, buf, mem, 0); + vkr = get_dispatch_table(renderdoc_device_table_map, d)->BindBufferMemory(d, buf, mem, 0); RDCASSERT(vkr == VK_SUCCESS); byte *ptr = NULL; - device_dispatch_table(d)->MapMemory(d, mem, 0, 0, 0, (void **)&ptr); + get_dispatch_table(renderdoc_device_table_map, d)->MapMemory(d, mem, 0, 0, 0, (void **)&ptr); // VKTODOLOW could deserialise directly into this ptr if we serialised // size separately. memcpy(ptr, data, dataSize); - device_dispatch_table(d)->UnmapMemory(d, mem); + get_dispatch_table(renderdoc_device_table_map, d)->UnmapMemory(d, mem); // VKTODOMED leaking the memory here! needs to be cleaned up with the buffer GetResourceManager()->SetInitialContents(id, VulkanResourceManager::InitialContentData(MakeRes(buf), eInitialContents_Copy, NULL)); @@ -6813,7 +6817,7 @@ void WrappedVulkan::Apply_InitialState(VkResource live, VulkanResourceManager::I VkWriteDescriptorSet *writes = (VkWriteDescriptorSet *)initial.blob; - VkResult vkr = device_dispatch_table(GetDev())->UpdateDescriptorSets(GetDev(), initial.num, writes, 0, NULL); + VkResult vkr = get_dispatch_table(renderdoc_device_table_map, GetDev())->UpdateDescriptorSets(GetDev(), initial.num, writes, 0, NULL); RDCASSERT(vkr == VK_SUCCESS); } else if(live.Namespace == eResDeviceMemory) @@ -6839,7 +6843,7 @@ void WrappedVulkan::Apply_InitialState(VkResource live, VulkanResourceManager::I VkCmdBufferBeginInfo beginInfo = { VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, NULL, VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT }; - vkr = device_dispatch_table(cmd)->BeginCommandBuffer(cmd, &beginInfo); + vkr = get_dispatch_table(renderdoc_device_table_map, cmd)->BeginCommandBuffer(cmd, &beginInfo); RDCASSERT(vkr == VK_SUCCESS); VkBufferCreateInfo bufInfo = { @@ -6851,28 +6855,28 @@ void WrappedVulkan::Apply_InitialState(VkResource live, VulkanResourceManager::I VkBuffer dstBuf; // VKTODOMED this should be created once up front, not every time - vkr = device_dispatch_table(d)->CreateBuffer(d, &bufInfo, &dstBuf); + vkr = get_dispatch_table(renderdoc_device_table_map, d)->CreateBuffer(d, &bufInfo, &dstBuf); RDCASSERT(vkr == VK_SUCCESS); - vkr = device_dispatch_table(d)->BindBufferMemory(d, dstBuf, dstMem, 0); + vkr = get_dispatch_table(renderdoc_device_table_map, d)->BindBufferMemory(d, dstBuf, dstMem, 0); RDCASSERT(vkr == VK_SUCCESS); VkBufferCopy region = { 0, 0, meminfo.size }; - device_dispatch_table(cmd)->CmdCopyBuffer(cmd, srcBuf, dstBuf, 1, ®ion); + get_dispatch_table(renderdoc_device_table_map, cmd)->CmdCopyBuffer(cmd, srcBuf, dstBuf, 1, ®ion); - vkr = device_dispatch_table(cmd)->EndCommandBuffer(cmd); + vkr = get_dispatch_table(renderdoc_device_table_map, cmd)->EndCommandBuffer(cmd); RDCASSERT(vkr == VK_SUCCESS); - vkr = device_dispatch_table(q)->QueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); + vkr = get_dispatch_table(renderdoc_device_table_map, q)->QueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); RDCASSERT(vkr == VK_SUCCESS); // VKTODOMED would be nice to store a fence too at this point // so we can sync on that on serialise rather than syncing // every time. - device_dispatch_table(q)->QueueWaitIdle(q); + get_dispatch_table(renderdoc_device_table_map, q)->QueueWaitIdle(q); - device_dispatch_table(d)->DestroyBuffer(d, dstBuf); + get_dispatch_table(renderdoc_device_table_map, d)->DestroyBuffer(d, dstBuf); } else if(live.Namespace == eResImage) { @@ -7240,7 +7244,7 @@ void WrappedVulkan::ReplayLog(uint32_t frameID, uint32_t startEventID, uint32_t VkCmdBufferBeginInfo beginInfo = { VK_STRUCTURE_TYPE_CMD_BUFFER_BEGIN_INFO, NULL, VK_CMD_BUFFER_OPTIMIZE_SMALL_BATCH_BIT | VK_CMD_BUFFER_OPTIMIZE_ONE_TIME_SUBMIT_BIT }; - VkResult vkr = device_dispatch_table(cmd)->BeginCommandBuffer(cmd, &beginInfo); + VkResult vkr = get_dispatch_table(renderdoc_device_table_map, cmd)->BeginCommandBuffer(cmd, &beginInfo); RDCASSERT(vkr == VK_SUCCESS); ImgState &st = m_ImageInfo[GetResourceManager()->GetLiveID(m_FakeBBImgId)]; @@ -7261,15 +7265,15 @@ void WrappedVulkan::ReplayLog(uint32_t frameID, uint32_t startEventID, uint32_t void *barrier = (void *)&t; st.subresourceStates[0].state = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; - device_dispatch_table(cmd)->CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, (void **)&barrier); + get_dispatch_table(renderdoc_device_table_map, cmd)->CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, false, 1, (void **)&barrier); VkClearColorValue clearColor = { { 0.0f, 0.0f, 0.0f, 1.0f, } }; - device_dispatch_table(cmd)->CmdClearColorImage(cmd, m_FakeBBIm, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, &clearColor, 1, &t.subresourceRange); + get_dispatch_table(renderdoc_device_table_map, cmd)->CmdClearColorImage(cmd, m_FakeBBIm, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL, &clearColor, 1, &t.subresourceRange); - vkr = device_dispatch_table(cmd)->EndCommandBuffer(cmd); + vkr = get_dispatch_table(renderdoc_device_table_map, cmd)->EndCommandBuffer(cmd); RDCASSERT(vkr == VK_SUCCESS); - vkr = device_dispatch_table(q)->QueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); + vkr = get_dispatch_table(renderdoc_device_table_map, q)->QueueSubmit(q, 1, &cmd, VK_NULL_HANDLE); RDCASSERT(vkr == VK_SUCCESS); } }