lee/renderdoc
1
0
Fork 0
mirror of https://github.com/baldurk/renderdoc.git synced 2026-05-24 19:00:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement some query pool functions

Browse Source
This commit is contained in:
baldurk
2015-09-23 15:41:58 +02:00
parent 9ebb7cec1f
commit 12fc8e9935
7 changed files with 375 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
renderdoc/driver/vulkan/vk_common.cpp
+63
View File
@@ -938,6 +938,42 @@ string ToStrHelper<false, VkFenceCreateFlagBits>::Get(const VkFenceCreateFlagBit
return ret;
}
template<>
string ToStrHelper<false, VkQueryPipelineStatisticFlagBits>::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<false, VkQueryControlFlagBits>::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<false, VkShaderStageFlagBits>::Get(const VkShaderStageFlagBits &el)
{
@@ -1390,6 +1426,19 @@ string ToStrHelper<false, VkDescriptorSetUsage>::Get(const VkDescriptorSetUsage
return StringFormat::Fmt("VkDescriptorSetUsage<%d>", el);
}
template<>
string ToStrHelper<false, VkQueryType>::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<false, VkMemoryHeapFlagBits>::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)
{
renderdoc/driver/vulkan/vk_common.h
+6
View File
@@ -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,
renderdoc/driver/vulkan/vk_core.cpp
+18
View File
@@ -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;
renderdoc/driver/vulkan/vk_core.h
+37
View File
@@ -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,
renderdoc/driver/vulkan/vk_hookset_defs.h
+12
View File
@@ -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); \
renderdoc/driver/vulkan/wrappers/vk_cmd_funcs.cpp
+162
View File
@@ -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<VkQueryPool>(qid);
if(IsPartialCmd(cmdid) && InPartialRange())
{
cmdBuffer = PartialCmdBuf();
ObjDisp(cmdBuffer)->CmdBeginQuery(Unwrap(cmdBuffer), Unwrap(queryPool), s, f);
}
}
else if(m_State == READING)
{
cmdBuffer = GetResourceManager()->GetLiveHandle<VkCmdBuffer>(cmdid);
queryPool = GetResourceManager()->GetLiveHandle<VkQueryPool>(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<VkQueryPool>(qid);
if(IsPartialCmd(cmdid) && InPartialRange())
{
cmdBuffer = PartialCmdBuf();
ObjDisp(cmdBuffer)->CmdEndQuery(Unwrap(cmdBuffer), Unwrap(queryPool), s);
}
}
else if(m_State == READING)
{
cmdBuffer = GetResourceManager()->GetLiveHandle<VkCmdBuffer>(cmdid);
queryPool = GetResourceManager()->GetLiveHandle<VkQueryPool>(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<VkQueryPool>(qid);
if(IsPartialCmd(cmdid) && InPartialRange())
{
cmdBuffer = PartialCmdBuf();
ObjDisp(cmdBuffer)->CmdResetQueryPool(Unwrap(cmdBuffer), Unwrap(queryPool), start, count);
}
}
else if(m_State == READING)
{
cmdBuffer = GetResourceManager()->GetLiveHandle<VkCmdBuffer>(cmdid);
queryPool = GetResourceManager()->GetLiveHandle<VkQueryPool>(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)
renderdoc/driver/vulkan/wrappers/vk_misc_funcs.cpp
+77
View File
@@ -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<VkDevice>(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,