diff --git a/renderdoc/driver/vulkan/vk_common.cpp b/renderdoc/driver/vulkan/vk_common.cpp index f926bbcff..20410f3e3 100644 --- a/renderdoc/driver/vulkan/vk_common.cpp +++ b/renderdoc/driver/vulkan/vk_common.cpp @@ -938,6 +938,42 @@ string ToStrHelper::Get(const VkFenceCreateFlagBit return ret; } +template<> +string ToStrHelper::Get(const VkQueryPipelineStatisticFlagBits &el) +{ + string ret; + + if(el & VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT) ret += " | VK_QUERY_PIPELINE_STATISTIC_IA_VERTICES_BIT"; + if(el & VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT) ret += " | VK_QUERY_PIPELINE_STATISTIC_IA_PRIMITIVES_BIT"; + if(el & VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT) ret += " | VK_QUERY_PIPELINE_STATISTIC_VS_INVOCATIONS_BIT"; + if(el & VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT) ret += " | VK_QUERY_PIPELINE_STATISTIC_GS_INVOCATIONS_BIT"; + if(el & VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT) ret += " | VK_QUERY_PIPELINE_STATISTIC_GS_PRIMITIVES_BIT"; + if(el & VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT) ret += " | VK_QUERY_PIPELINE_STATISTIC_C_INVOCATIONS_BIT"; + if(el & VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT) ret += " | VK_QUERY_PIPELINE_STATISTIC_C_PRIMITIVES_BIT"; + if(el & VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT) ret += " | VK_QUERY_PIPELINE_STATISTIC_FS_INVOCATIONS_BIT"; + if(el & VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT) ret += " | VK_QUERY_PIPELINE_STATISTIC_TCS_PATCHES_BIT"; + if(el & VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT) ret += " | VK_QUERY_PIPELINE_STATISTIC_TES_INVOCATIONS_BIT"; + if(el & VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT) ret += " | VK_QUERY_PIPELINE_STATISTIC_CS_INVOCATIONS_BIT"; + + if(!ret.empty()) + ret = ret.substr(3); + + return ret; +} + +template<> +string ToStrHelper::Get(const VkQueryControlFlagBits &el) +{ + string ret; + + if(el & VK_QUERY_CONTROL_CONSERVATIVE_BIT) ret += " | VK_QUERY_CONTROL_CONSERVATIVE_BIT"; + + if(!ret.empty()) + ret = ret.substr(3); + + return ret; +} + template<> string ToStrHelper::Get(const VkShaderStageFlagBits &el) { @@ -1390,6 +1426,19 @@ string ToStrHelper::Get(const VkDescriptorSetUsage return StringFormat::Fmt("VkDescriptorSetUsage<%d>", el); } +template<> +string ToStrHelper::Get(const VkQueryType &el) +{ + switch(el) + { + TOSTR_CASE_STRINGIZE(VK_QUERY_TYPE_OCCLUSION) + TOSTR_CASE_STRINGIZE(VK_QUERY_TYPE_PIPELINE_STATISTICS) + default: break; + } + + return StringFormat::Fmt("VkQueryType<%d>", el); +} + template<> string ToStrHelper::Get(const VkMemoryHeapFlagBits &el) { @@ -2572,6 +2621,20 @@ void Serialiser::Serialise(const char *name, VkStencilOpState &el) Serialise("stencilCompareOp", el.stencilCompareOp); } +template<> +void Serialiser::Serialise(const char *name, VkQueryPoolCreateInfo &el) +{ + ScopedContext scope(this, this, name, "VkQueryPoolCreateInfo", 0, true); + + RDCASSERT(m_Mode < WRITING || el.sType == VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO); + Serialise("sType", el.sType); + SerialiseNext(this, el.pNext); + + Serialise("queryType", el.queryType); + Serialise("slots", el.slots); + Serialise("pipelineStatistics", (VkQueryPipelineStatisticFlagBits &)el.pipelineStatistics); +} + template<> void Serialiser::Serialise(const char *name, VkSemaphoreCreateInfo &el) { diff --git a/renderdoc/driver/vulkan/vk_common.h b/renderdoc/driver/vulkan/vk_common.h index 7f1149794..0eb29f44c 100644 --- a/renderdoc/driver/vulkan/vk_common.h +++ b/renderdoc/driver/vulkan/vk_common.h @@ -112,6 +112,7 @@ template<> void Serialiser::Serialise(const char *name, VkCmdPoolCreateInfo &el) template<> void Serialiser::Serialise(const char *name, VkCmdBufferCreateInfo &el); template<> void Serialiser::Serialise(const char *name, VkCmdBufferBeginInfo &el); template<> void Serialiser::Serialise(const char *name, VkStencilOpState &el); +template<> void Serialiser::Serialise(const char *name, VkQueryPoolCreateInfo &el); template<> void Serialiser::Serialise(const char *name, VkSemaphoreCreateInfo &el); template<> void Serialiser::Serialise(const char *name, VkFenceCreateInfo &el); template<> void Serialiser::Serialise(const char *name, VkSamplerCreateInfo &el); @@ -183,6 +184,8 @@ enum VulkanChunkType GET_FENCE_STATUS, WAIT_FENCES, + CREATE_QUERY_POOL, + ALLOC_DESC_SET, UPDATE_DESC_SET, @@ -222,6 +225,9 @@ enum VulkanChunkType CLEAR_DEPTHSTENCIL_ATTACH, PIPELINE_BARRIER, WRITE_TIMESTAMP, + BEGIN_QUERY, + END_QUERY, + RESET_QUERY_POOL, DRAW, DRAW_INDIRECT, DRAW_INDEXED, diff --git a/renderdoc/driver/vulkan/vk_core.cpp b/renderdoc/driver/vulkan/vk_core.cpp index 7502a5015..0b5cadb2f 100644 --- a/renderdoc/driver/vulkan/vk_core.cpp +++ b/renderdoc/driver/vulkan/vk_core.cpp @@ -85,6 +85,8 @@ const char *VkChunkNames[] = "vkGetFenceStatus", "vkWaitForFences", + "vkCreateQueryPool", + "vkAllocDescriptorSets", "vkUpdateDescriptorSets", @@ -124,6 +126,9 @@ const char *VkChunkNames[] = "vkCmdClearDepthStencilAttachment", "vkCmdPipelineBarrier", "vkCmdWriteTimestamp", + "vkCmdBeginQuery", + "vkCmdEndQuery", + "vkCmdResetQueryPool", "vkCmdDraw", "vkCmdDrawIndirect", "vkCmdDrawIndexed", @@ -959,6 +964,10 @@ void WrappedVulkan::ProcessChunk(uint64_t offset, VulkanChunkType context) //Serialise_vkWaitForFences(VK_NULL_HANDLE, 0, NULL, VK_FALSE, 0.0f); break; + case CREATE_QUERY_POOL: + Serialise_vkCreateQueryPool(VK_NULL_HANDLE, NULL, NULL); + break; + case ALLOC_DESC_SET: Serialise_vkAllocDescriptorSets(VK_NULL_HANDLE, VK_NULL_HANDLE, VK_DESCRIPTOR_SET_USAGE_MAX_ENUM, 0, NULL, NULL, NULL); break; @@ -1067,6 +1076,15 @@ void WrappedVulkan::ProcessChunk(uint64_t offset, VulkanChunkType context) //VKTODOMED: //Serialise_vkCmdWriteTimestamp(VK_NULL_HANDLE, VK_TIMESTAMP_TYPE_MAX_ENUM, VK_NULL_HANDLE, 0); break; + case BEGIN_QUERY: + Serialise_vkCmdBeginQuery(VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); + break; + case END_QUERY: + Serialise_vkCmdEndQuery(VK_NULL_HANDLE, VK_NULL_HANDLE, 0); + break; + case RESET_QUERY_POOL: + Serialise_vkCmdResetQueryPool(VK_NULL_HANDLE, VK_NULL_HANDLE, 0, 0); + break; case DRAW: Serialise_vkCmdDraw(VK_NULL_HANDLE, 0, 0, 0, 0); break; diff --git a/renderdoc/driver/vulkan/vk_core.h b/renderdoc/driver/vulkan/vk_core.h index 3f7f9bf77..725e68dfd 100644 --- a/renderdoc/driver/vulkan/vk_core.h +++ b/renderdoc/driver/vulkan/vk_core.h @@ -524,6 +524,26 @@ public: IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDeviceWaitIdle( VkDevice device)); + // Query pool functions + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + VkQueryPool* pQueryPool)); + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkDestroyQueryPool( + VkDevice device, + VkQueryPool queryPool)); + + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount, + size_t* pDataSize, + void* pData, + VkQueryResultFlags flags)); + // Semaphore functions IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateSemaphore( @@ -1032,6 +1052,23 @@ public: uint32_t memBarrierCount, const void* const* ppMemBarriers)); + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdBeginQuery( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t slot, + VkQueryControlFlags flags)); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdEndQuery( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t slot)); + + IMPLEMENT_FUNCTION_SERIALISED(void, vkCmdResetQueryPool( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount)); + IMPLEMENT_FUNCTION_SERIALISED(VkResult, vkCreateFramebuffer( VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, diff --git a/renderdoc/driver/vulkan/vk_hookset_defs.h b/renderdoc/driver/vulkan/vk_hookset_defs.h index e3e06d637..1e1c76476 100644 --- a/renderdoc/driver/vulkan/vk_hookset_defs.h +++ b/renderdoc/driver/vulkan/vk_hookset_defs.h @@ -84,6 +84,9 @@ HookInit(CreateFence); \ HookInit(GetFenceStatus); \ HookInit(DestroyFence); \ + HookInit(CreateQueryPool); \ + HookInit(GetQueryPoolResults); \ + HookInit(DestroyQueryPool); \ HookInit(CreateSampler); \ HookInit(DestroySampler); \ HookInit(CreateDescriptorSetLayout); \ @@ -134,6 +137,9 @@ HookInit(CmdClearColorAttachment); \ HookInit(CmdClearDepthStencilAttachment); \ HookInit(CmdPipelineBarrier); \ + HookInit(CmdBeginQuery); \ + HookInit(CmdEndQuery); \ + HookInit(CmdResetQueryPool); \ HookInit(CreateFramebuffer); \ HookInit(DestroyFramebuffer); \ HookInit(CreateRenderPass); \ @@ -203,6 +209,9 @@ HookDefine2(VkResult, vkQueueWaitSemaphore, VkQueue, queue, VkSemaphore, semaphore); \ HookDefine3(VkResult, vkCreateFence, VkDevice, device, const VkFenceCreateInfo*, pCreateInfo, VkFence*, pFence); \ HookDefine2(VkResult, vkDestroyFence, VkDevice, device, VkFence, fence); \ + HookDefine3(VkResult, vkCreateQueryPool, VkDevice, device, const VkQueryPoolCreateInfo*, pCreateInfo, VkQueryPool*, pQueryPool); \ + HookDefine2(VkResult, vkDestroyQueryPool, VkDevice, device, VkQueryPool, queryPool); \ + HookDefine7(VkResult, vkGetQueryPoolResults, VkDevice, device, VkQueryPool, queryPool, uint32_t, startQuery, uint32_t, queryCount, size_t*, pDataSize, void*, pData, VkQueryResultFlags, flags); \ HookDefine2(VkResult, vkGetFenceStatus, VkDevice, device, VkFence, fence); \ HookDefine3(VkResult, vkCreateSampler, VkDevice, device, const VkSamplerCreateInfo*, pCreateInfo, VkSampler*, pSampler); \ HookDefine2(VkResult, vkDestroySampler, VkDevice, device, VkSampler, sampler); \ @@ -254,6 +263,9 @@ HookDefine6(void, vkCmdClearColorAttachment, VkCmdBuffer, cmdBuffer, uint32_t, colorAttachment, VkImageLayout, imageLayout, const VkClearColorValue*, pColor, uint32_t, rectCount, const VkRect3D*, pRects); \ HookDefine7(void, vkCmdClearDepthStencilAttachment, VkCmdBuffer, cmdBuffer, VkImageAspectFlags, imageAspectMask, VkImageLayout, imageLayout, float, depth, uint32_t, stencil, uint32_t, rectCount, const VkRect3D*, pRects); \ HookDefine6(void, vkCmdPipelineBarrier, VkCmdBuffer, cmdBuffer, VkPipelineStageFlags, srcStageMask, VkPipelineStageFlags, destStageMask, VkBool32, byRegion, uint32_t, memBarrierCount, const void* const*, ppMemBarriers); \ + HookDefine4(void, vkCmdBeginQuery, VkCmdBuffer, cmdBuffer, VkQueryPool, queryPool, uint32_t, slot, VkQueryControlFlags, flags); \ + HookDefine3(void, vkCmdEndQuery, VkCmdBuffer, cmdBuffer, VkQueryPool, queryPool, uint32_t, slot); \ + HookDefine4(void, vkCmdResetQueryPool, VkCmdBuffer, cmdBuffer, VkQueryPool, queryPool, uint32_t, startQuery, uint32_t, queryCount); \ HookDefine3(VkResult, vkCreateFramebuffer, VkDevice, device, const VkFramebufferCreateInfo*, pCreateInfo, VkFramebuffer*, pFramebuffer); \ HookDefine2(VkResult, vkDestroyFramebuffer, VkDevice, device, VkFramebuffer, framebuffer); \ HookDefine3(VkResult, vkCreateRenderPass, VkDevice, device, const VkRenderPassCreateInfo*, pCreateInfo, VkRenderPass*, pRenderPass); \ diff --git a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp index ee145648d..c4ad88440 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp @@ -1336,6 +1336,168 @@ void WrappedVulkan::vkCmdPipelineBarrier( } } +bool WrappedVulkan::Serialise_vkCmdBeginQuery( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t slot, + VkQueryControlFlags flags) +{ + SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); + SERIALISE_ELEMENT(ResourceId, qid, GetResID(queryPool)); + SERIALISE_ELEMENT(uint32_t, s, slot); + SERIALISE_ELEMENT(VkQueryControlFlagBits, f, (VkQueryControlFlagBits)flags); // serialise as 'bits' type to get nice enum values + + if(m_State < WRITING) + m_LastCmdBufferID = cmdid; + + if(m_State == EXECUTING) + { + queryPool = GetResourceManager()->GetLiveHandle(qid); + + if(IsPartialCmd(cmdid) && InPartialRange()) + { + cmdBuffer = PartialCmdBuf(); + ObjDisp(cmdBuffer)->CmdBeginQuery(Unwrap(cmdBuffer), Unwrap(queryPool), s, f); + } + } + else if(m_State == READING) + { + cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); + queryPool = GetResourceManager()->GetLiveHandle(qid); + + ObjDisp(cmdBuffer)->CmdBeginQuery(Unwrap(cmdBuffer), Unwrap(queryPool), s, f); + } + + return true; +} + +void WrappedVulkan::vkCmdBeginQuery( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t slot, + VkQueryControlFlags flags) +{ + ObjDisp(cmdBuffer)->CmdBeginQuery(Unwrap(cmdBuffer), Unwrap(queryPool), slot, flags); + + if(m_State >= WRITING) + { + VkResourceRecord *record = GetRecord(cmdBuffer); + + SCOPED_SERIALISE_CONTEXT(BEGIN_QUERY); + Serialise_vkCmdBeginQuery(cmdBuffer, queryPool, slot, flags); + + record->AddChunk(scope.Get()); + record->MarkResourceFrameReferenced(GetResID(queryPool), eFrameRef_Read); + } +} + +bool WrappedVulkan::Serialise_vkCmdEndQuery( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t slot) +{ + SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); + SERIALISE_ELEMENT(ResourceId, qid, GetResID(queryPool)); + SERIALISE_ELEMENT(uint32_t, s, slot); + + if(m_State < WRITING) + m_LastCmdBufferID = cmdid; + + if(m_State == EXECUTING) + { + queryPool = GetResourceManager()->GetLiveHandle(qid); + + if(IsPartialCmd(cmdid) && InPartialRange()) + { + cmdBuffer = PartialCmdBuf(); + ObjDisp(cmdBuffer)->CmdEndQuery(Unwrap(cmdBuffer), Unwrap(queryPool), s); + } + } + else if(m_State == READING) + { + cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); + queryPool = GetResourceManager()->GetLiveHandle(qid); + + ObjDisp(cmdBuffer)->CmdEndQuery(Unwrap(cmdBuffer), Unwrap(queryPool), s); + } + + return true; +} + +void WrappedVulkan::vkCmdEndQuery( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t slot) +{ + ObjDisp(cmdBuffer)->CmdEndQuery(Unwrap(cmdBuffer), Unwrap(queryPool), slot); + + if(m_State >= WRITING) + { + VkResourceRecord *record = GetRecord(cmdBuffer); + + SCOPED_SERIALISE_CONTEXT(END_QUERY); + Serialise_vkCmdEndQuery(cmdBuffer, queryPool, slot); + + record->AddChunk(scope.Get()); + record->MarkResourceFrameReferenced(GetResID(queryPool), eFrameRef_Read); + } +} + +bool WrappedVulkan::Serialise_vkCmdResetQueryPool( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount) +{ + SERIALISE_ELEMENT(ResourceId, cmdid, GetResID(cmdBuffer)); + SERIALISE_ELEMENT(ResourceId, qid, GetResID(queryPool)); + SERIALISE_ELEMENT(uint32_t, start, startQuery); + SERIALISE_ELEMENT(uint32_t, count, queryCount); + + if(m_State < WRITING) + m_LastCmdBufferID = cmdid; + + if(m_State == EXECUTING) + { + queryPool = GetResourceManager()->GetLiveHandle(qid); + + if(IsPartialCmd(cmdid) && InPartialRange()) + { + cmdBuffer = PartialCmdBuf(); + ObjDisp(cmdBuffer)->CmdResetQueryPool(Unwrap(cmdBuffer), Unwrap(queryPool), start, count); + } + } + else if(m_State == READING) + { + cmdBuffer = GetResourceManager()->GetLiveHandle(cmdid); + queryPool = GetResourceManager()->GetLiveHandle(qid); + + ObjDisp(cmdBuffer)->CmdResetQueryPool(Unwrap(cmdBuffer), Unwrap(queryPool), start, count); + } + + return true; +} + +void WrappedVulkan::vkCmdResetQueryPool( + VkCmdBuffer cmdBuffer, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount) +{ + ObjDisp(cmdBuffer)->CmdResetQueryPool(Unwrap(cmdBuffer), Unwrap(queryPool), startQuery, queryCount); + + if(m_State >= WRITING) + { + VkResourceRecord *record = GetRecord(cmdBuffer); + + SCOPED_SERIALISE_CONTEXT(RESET_QUERY_POOL); + Serialise_vkCmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount); + + record->AddChunk(scope.Get()); + record->MarkResourceFrameReferenced(GetResID(queryPool), eFrameRef_Read); + } +} + bool WrappedVulkan::Serialise_vkCmdDbgMarkerBegin( VkCmdBuffer cmdBuffer, const char* pMarker) diff --git a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp index bd43f9a51..b324a4136 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp @@ -53,6 +53,7 @@ DESTROY_IMPL(VkDynamicDepthStencilState, DestroyDynamicDepthStencilState) DESTROY_IMPL(VkSemaphore, DestroySemaphore) DESTROY_IMPL(VkFence, DestroyFence) DESTROY_IMPL(VkCmdPool, DestroyCommandPool) +DESTROY_IMPL(VkQueryPool, DestroyQueryPool) DESTROY_IMPL(VkFramebuffer, DestroyFramebuffer) DESTROY_IMPL(VkRenderPass, DestroyRenderPass) DESTROY_IMPL(VkSwapChainWSI, DestroySwapChainWSI) @@ -866,6 +867,82 @@ VkResult WrappedVulkan::vkCreateDynamicDepthStencilState( return ret; } +bool WrappedVulkan::Serialise_vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + VkQueryPool* pQueryPool) +{ + SERIALISE_ELEMENT(ResourceId, devId, GetResID(device)); + SERIALISE_ELEMENT(VkQueryPoolCreateInfo, info, *pCreateInfo); + SERIALISE_ELEMENT(ResourceId, id, GetResID(*pQueryPool)); + + if(m_State == READING) + { + device = GetResourceManager()->GetLiveHandle(devId); + VkQueryPool pool = VK_NULL_HANDLE; + + VkResult ret = ObjDisp(device)->CreateQueryPool(Unwrap(device), &info, &pool); + + if(ret != VK_SUCCESS) + { + RDCERR("Failed on resource serialise-creation, VkResult: 0x%08x", ret); + } + else + { + ResourceId live = GetResourceManager()->WrapResource(Unwrap(device), pool); + GetResourceManager()->AddLiveResource(id, pool); + } + } + + return true; +} + +VkResult WrappedVulkan::vkCreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + VkQueryPool* pQueryPool) +{ + VkResult ret = ObjDisp(device)->CreateQueryPool(Unwrap(device), pCreateInfo, pQueryPool); + + if(ret == VK_SUCCESS) + { + ResourceId id = GetResourceManager()->WrapResource(Unwrap(device), *pQueryPool); + + if(m_State >= WRITING) + { + Chunk *chunk = NULL; + + { + SCOPED_SERIALISE_CONTEXT(CREATE_QUERY_POOL); + Serialise_vkCreateQueryPool(device, pCreateInfo, pQueryPool); + + chunk = scope.Get(); + } + + VkResourceRecord *record = GetResourceManager()->AddResourceRecord(*pQueryPool); + record->AddChunk(chunk); + } + else + { + GetResourceManager()->AddLiveResource(id, *pQueryPool); + } + } + + return ret; +} + +VkResult WrappedVulkan::vkGetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t startQuery, + uint32_t queryCount, + size_t* pDataSize, + void* pData, + VkQueryResultFlags flags) +{ + return ObjDisp(device)->GetQueryPoolResults(Unwrap(device), Unwrap(queryPool), startQuery, queryCount, pDataSize, pData, flags); +} + VkResult WrappedVulkan::vkDbgCreateMsgCallback( VkInstance instance, VkFlags msgFlags,